Erfinder quantifizieren die API-Dokumentation

void main() {
    Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body");
}

• MailAsynchrone Versionen von FunktionenMail_GoDie Funktion: Nutzung undexchange.GoDie Funktion ist ähnlich.

  function main() {
      var r1 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
      var r2 = Mail_Go("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")
      
      var ret1 = r1.wait()
      var ret2 = r2.wait()
      
      Log("ret1:", ret1)
      Log("ret2:", ret2)
  }
  

  # 不支持
  

  // 不支持
  

Bitte beachten: Der Ali-Cloud-Server kann einige Ports blockieren, was dazu führt, dass die E-Mails nicht gesendet werden können.smtp.qq.com:587Der Port-Test ist verfügbar. Wenn ein Fehler auftaucht:unencryped connectionDas muss geändert werden.MailDie FunktionsmtpServerDas Format der Parameter lautet:ssl://xxx.com:xxxEin Beispiel ist die QQ-E-Mail.SMTPDas ist ein sehr schwieriger Fall.ssl://smtp.qq.com:465Odersmtp://xxx.com:xxx。

SetErrorFilter(...)

SetErrorFilter(RegEx), Filter-Fehlerprotokoll. Parameterwert: String-Typ. Fehlerlogs, die mit diesem Regelausdruck übereinstimmen, werden nicht in das Logsystem hochgeladen, und mehrere Filterbedingungen können mehrmals aufgerufen werden (die gefilterten Logs werden nicht in die Datenbankdateien mit den entsprechenden Festplatten-IDs im Host-Verzeichnis geschrieben, um zu verhindern, dass häufige Fehlermeldungen zu einer Datenbank-Dateiexpansion führen).

function main() {
    SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")
}

def main():
    SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused")

void main() {
    SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused");
}

Sie können auch die Anzeige von einem Interface-Fehler filtern:

function main() {
    // 随便查询一个不存在的订单，id为123，故意让接口报错
    var order = exchange.GetOrder("123")
    Log(order)
    // 过滤http502错误、GetOrder接口错误，设置错误过滤之后，第二次调用GetOrder不再报错
    SetErrorFilter("502:|GetOrder")
    order = exchange.GetOrder("123")
    Log(order)
}

def main():
    order = exchange.GetOrder("123")
    Log(order)
    SetErrorFilter("502:|GetOrder")
    order = exchange.GetOrder("123")
    Log(order)

void main() {
    TId orderId;
    Order order = exchange.GetOrder(orderId);
    Log(order);
    SetErrorFilter("502:|GetOrder");
    order = exchange.GetOrder(orderId);
    Log(order);
}

GetPid (siehe unten)

GetPid(), gibt die Festplattenprozess-ID zurück.

function main(){
    var id = GetPid()
    Log(id)
}

def main():
    id = GetPid()
    Log(id)

void main() {
    auto id = GetPid();
    Log(id);
}

GetLastError()

GetLastError(), um die letzte Fehlermeldung zu erhalten. Es ist normalerweise nicht notwendig, da der Programm die Fehlermeldung automatisch an das Logsystem hochlädt.GetLastError()Die Funktion löscht den Cache, sodass beim nächsten Aufruf keine Fehlermeldung mehr zurückgegeben wird.

function main(){
    // 因为不存在编号为123的订单，所以会出错
    exchange.GetOrder("123")
    var error = GetLastError()
    Log(error)
}

def main():
    exchange.GetOrder("123")
    error = GetLastError()
    Log(error)

void main() {
    // 订单ID类型：TId，所以不能传入字符串，我们下一个不符合交易所规范的订单来触发
    exchange.GetOrder(exchange.Buy(1, 1));
    auto error = GetLastError();
    Log(error);
}

GetCommand (siehe unten)

GetCommand(), erhält die Interaktionsbefehlsstring ((utf-8)); erhält die Befehle, die von der Interaktionspolitik ausgesendet wurden, und räumt den Cache aus, ohne dass die Befehle eine leere Stringung zurückgeben.按钮名称:参数Wenn die Interaktionssteuerung keine Parameter hat (z. B. eine Tastensteuerung ohne Eingabebox), ist der Befehl der Tastenname.

function main(){
    while(true) { 
        var cmd = GetCommand()
        if (cmd) { 
            Log(cmd)
        }
        Sleep(1000) 
    }
}

def main():
    while True:
        cmd = GetCommand()
        if cmd:
            Log(cmd)
        Sleep(1000)

void main() {
    while(true) {
        auto cmd = GetCommand();
        if(cmd != "") {
            Log(cmd);
        }
        Sleep(1000);
    }
}

Das untergeordnete System hat eine Schlange Struktur, die Interaktionsbefehle aufzeichnet, wennGetCommand()Bei Aufruf der Funktion wird der zuerst eingegebene Interaktionsbefehl aus der Warteschlange herausgenommen (wenn kein Interaktionsbefehl vorhanden ist, kehrt er einen leeren String zurück).

Beispiele für die Verwendung von Interaktionssteuerelementen, die die Interaktionssteuerung in der Strategie-Editor-Schnittstelle einstellen.

Die Strategie ist es, den interaktiven Code zu entwerfen:

function main() {
    while (true) {
        LogStatus(_D())
        var cmd = GetCommand()
        if (cmd) {
            Log("cmd:", cmd)    
            var arr = cmd.split(":")
            if (arr[0] == "buy") {
                Log("买入，该控件不带数量")
            } else if (arr[0] == "sell") {
                Log("卖出，该控件带数量：", arr[1])
            } else {
                Log("其它控件触发：", arr)
            }
        }
        Sleep(1000)
    } 
}

def main():
    while True:
        LogStatus(_D())
        cmd = GetCommand()
        if cmd:
            Log("cmd:", cmd)
            arr = cmd.split(":")
            if arr[0] == "buy":
                Log("买入，该控件不带数量")
            elif arr[0] == "sell":
                Log("卖出，该控件带数量：", arr[1])
            else:
                Log("其它控件触发：", arr)
        Sleep(1000)

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
void split(const string& s,vector<string>& sv,const char flag = ' ') {
    sv.clear();
    istringstream iss(s);
    string temp;

    while (getline(iss, temp, flag)) {
        sv.push_back(temp);
    }
    return;
}

void main() {
    while(true) {
        LogStatus(_D());
        auto cmd = GetCommand();
        if (cmd != "") {
            vector<string> arr;
            split(cmd, arr, ':');
            if(arr[0] == "buy") {
                Log("买入，该控件不带数量");
            } else if (arr[0] == "sell") {
                Log("卖出，该控件带数量：", arr[1]);
            } else {
                Log("其它控件触发：", arr);
            }
        }
        Sleep(1000);
    }
}

GetMeta()

GetMeta()Die Funktion gibt den Registrierungscode zurück, der bei der Erstellung der Registrierungspolitik eingegeben wurde.MetaDer Wert, den die Funktion zurückgibt, ist der String-Typ. Anwendungsszenarien, z.B. eine Strategie, bei der Geldbeschränkungen für verschiedene Mieter erforderlich sind. Bitte beachten Sie, dass die Registrierungskode generiert wirdMetaDie Funktion darf nicht länger als 190 Charaktere sein. Die Funktion ist nur für die Festplatte gültig und erfordert die Verwendung eines neuesten Administrators.GetMeta()Es wird ein Nullwert zurückgegeben.

Informationen über die Verwendung von Szenen

function main() {
    // 策略允许的计价币最大资产数值
    var maxBaseCurrency = null
    
    // 获取创建注册码时的元数据
    var level = GetMeta()
    
    // 检测Meta对应的条件
    if (level == "level1") {
        // -1为不限制
        maxBaseCurrency = -1       
    } else if (level == "level2") {
        maxBaseCurrency = 10     
    } else if (level == "level3") {
        maxBaseCurrency = 1
    } else {
        maxBaseCurrency = 0.5
    }
    
    while(1) {
        Sleep(1000)
        var ticker = exchange.GetTicker()
        
        // 检测资产数值
        var acc = exchange.GetAccount()
        if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
            // 停止执行策略交易逻辑
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！")
            continue
        }
        
        // 其它交易逻辑
        
        // 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker)
    }
}

def main():
    maxBaseCurrency = null
    level = GetMeta()
    
    if level == "level1":
        maxBaseCurrency = -1       
    elif level == "level2":
        maxBaseCurrency = 10     
    elif level == "level3":
        maxBaseCurrency = 1
    else:
        maxBaseCurrency = 0.5
    
    while True:
        Sleep(1000)
        ticker = exchange.GetTicker()        
        acc = exchange.GetAccount()
        if maxBaseCurrency != -1 and maxBaseCurrency < acc["Stocks"] + acc["FrozenStocks"]:
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！")
            continue        
        
        # 其它交易逻辑
        
        # 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker)

void main() {
    auto maxBaseCurrency = 0.0;
    auto level = GetMeta();
    
    if (level == "level1") {
        maxBaseCurrency = -1;  
    } else if (level == "level2") {
        maxBaseCurrency = 10;
    } else if (level == "level3") {
        maxBaseCurrency = 1;
    } else {
        maxBaseCurrency = 0.5;
    }
    
    while(1) {
        Sleep(1000);
        auto ticker = exchange.GetTicker();  
        auto acc = exchange.GetAccount();
        if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Stocks + acc.FrozenStocks) {
            // 停止执行策略交易逻辑
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限定，不再执行策略交易逻辑！");
            continue;
        }
        
        // 其它交易逻辑
        
        // 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker数据：\n", ticker);
    }
}

Wählen Sie...

Dial(Address, Timeout)Das ist nicht wahr.SocketBesuch, Unterstützungtcp，udp，tls，unixDas Protokoll. Parameterwert:AddressSie können auch eine andere Form verwenden, um die Stringart zu ermitteln.TimeOutDer Typ der Werte ist Sekunden, wenn die Zeit überschritten istDial(...)Die Funktion gibt einen Nullwert zurück.

AddressDie Parameter sind ausführlich:

function main(){
    // Dial支持tcp://，udp://，tls://，unix://协议，可加一个参数指定超时的秒数
    var client = Dial("tls://www.baidu.com:443")  
    if (client) {
        // write可再跟一个数字参数指定超时,write返回成功发送的字节数
        client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
        while (true) {
            // read可再跟一个数字参数指定超时，单位：毫秒。返回null指出错或者超时或者socket已经关闭
            var buf = client.read()
            if (!buf) {
                 break
            }
            Log(buf)
        }
        client.close()
    }
}

def main():
    client = Dial("tls://www.baidu.com:443")
    if client:
        client.write("GET / HTTP/1.1\nConnection: Closed\n\n")
        while True:
            buf = client.read()
            if not buf:
                break
            Log(buf)
        client.close()

void main() {
    auto client = Dial("tls://www.baidu.com:443");
    if(client.Valid) {
        client.write("GET / HTTP/1.1\nConnection: Closed\n\n");
        while(true) {
            auto buf = client.read();
            if(buf == "") {
                break;
            }
            Log(buf);
        }
        client.close();
    }
}

readDie Funktion unterstützt folgende Parameter:

• Wenn keine Parameter übermittelt werden, wird blockiert, bis eine Nachricht zurückgegeben wird.ws.read()。
• Bei der Übertragung der Parameter ist die Einheit Millisekunden und die Wartezeit der Nachrichten wird angegeben.ws.read(2000)Die Zeitverzögerung wird auf zwei Sekunden (z.B. 2000 Millisekunden) festgelegt.
• Die beiden folgenden Parameter sind nur richtig.websocketWirksam: Eintrittsparameter-1Eine Funktion kann sofort zurückgegeben werden, egal ob es eine Nachricht gibt oder nicht.ws.read(-1)Das ist nicht wahr. Eintrittsparameter-2Die Funktion kehrt unmittelbar zurück, egal ob keine Nachrichten vorhanden sind, aber nur die neuesten Nachrichten.ws.read(-2)。

read()Die Funktionsbuffer beschreibt: Die Daten, die durch das WS-Protokoll geschickt werden, werden in der Strategie geschaltet.read()Zu lange Zeitintervalle zwischen Funktionsaufrufen können zu Datenaufkommen führen. Diese Daten werden in einem Buffer gespeichert, dessen Buffer-Datenstruktur eine Reihe von bis zu 2000 Daten umfasst. Nach 2000 werden die neuesten Daten in den Buffer eingegeben und die ältesten Daten gelöscht.

• Unterstützt das wss ((WebSocket)) Protokoll Die Websocket-Marktoberfläche von Binance:

  function main() {
      LogStatus("正在连接...")
      // 访问币安的websocket接口
      var client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
      if (!client) {
          Log("连接失败, 程序退出")
          return
      }
      
      while (true) {
          // read只返回调用read之后获取的数据
          var buf = client.read()      
          if (!buf) {
              break
          }
          var table = {
              type: 'table',
              title: '行情图表',
              cols: ['币种', '最高', '最低', '买一', '卖一', '最后成交价', '成交量', '更新时间'],
              rows: []
          }
          var obj = JSON.parse(buf)
          _.each(obj, function(ticker) {
              table.rows.push([ticker.s, ticker.h, ticker.l, ticker.b, ticker.a, ticker.c, ticker.q, _D(ticker.E)])
          })
          LogStatus('`' + JSON.stringify(table) + '`')
      }
      client.close()
  }
  

  import json
  def main():
      LogStatus("正在连接...")
      client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr")
      if not client:
          Log("连接失败, 程序退出")
          return 
      
      while True:
          buf = client.read()
          if not buf:
              break
          table = {
              "type" : "table", 
              "title" : "行情图表", 
              "cols" : ["币种", "最高", "最低", "买一", "卖一", "最后成交价", "成交量", "更新时间"], 
              "rows" : [] 
          }
          obj = json.loads(buf)
          for i in range(len(obj)):
              table["rows"].append([obj[i]["s"], obj[i]["h"], obj[i]["l"], obj[i]["b"], obj[i]["a"], obj[i]["c"], obj[i]["q"], _D(int(obj[i]["E"]))])
          LogStatus('`' + json.dumps(table) + '`')
      client.close()
  

  void main() {
      LogStatus("正在连接...");
      auto client = Dial("wss://stream.binance.com:9443/ws/!ticker@arr");
      if(!client.Valid) {
          Log("连接失败, 程序退出");
          return;
      }
      
      while(true) {
          auto buf = client.read();
          if(buf == "") {
              break;
          }
          json table = R"({
              "type" : "table", 
              "title" : "行情图表", 
              "cols" : ["币种", "最高", "最低", "买一", "卖一", "最后成交价", "成交量", "更新时间"], 
              "rows" : []
          })"_json;
          json obj = json::parse(buf);
          for(auto& ele : obj.items()) {
              table["rows"].push_back({ele.value()["s"], ele.value()["h"], ele.value()["l"], ele.value()["b"], ele.value()["a"], ele.value()["c"], 
                  ele.value()["q"], _D(ele.value()["E"])});
          }
          LogStatus("`" + table.dump() + "`");
      }
      client.close();
  }
  

  Die Websocket-Marktoberfläche für OKX:

  var ws = null 
  function main(){
      var param = {
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      }
      // 在调用Dial函数时，指定reconnect=true即设置为重连模式，指定payload即为重连时发送的消息。在websocket连接断开后，会自动重连，自动发送消息
      ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
      if(ws){
          var pingCyc = 1000 * 20
          var lastPingTime = new Date().getTime()
          while(true){
              var nowTime = new Date().getTime()
              var ret = ws.read()
              Log("ret:", ret)
              if(nowTime - lastPingTime > pingCyc){
                  var retPing = ws.write("ping")
                  lastPingTime = nowTime
                  Log("发送 ：ping", "#FF0000")
              }
              LogStatus("当前时间：", _D())
              Sleep(1000)
          }
      }
  }  
  
  function onexit() {
      ws.close() 
      Log("退出")
  }
  

  import json
  import time  
  
  ws = None
  def main():
      global ws 
      param = {
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      }
      ws = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true&payload=" + json.dumps(param))
      if ws:
          pingCyc = 1000 * 20
          lastPingTime = time.time() * 1000
          while True:
              nowTime = time.time() * 1000
              ret = ws.read()
              Log("ret:", ret)
              if nowTime - lastPingTime > pingCyc:
                  retPing = ws.write("ping")
                  lastPingTime = nowTime
                  Log("发送：ping", "#FF0000")
              LogStatus("当前时间：", _D())
              Sleep(1000)  
  
  def onexit():
      ws.close()
      Log("退出")
  

  auto objWS = Dial("wss://ws.okx.com:8443/ws/v5/public|compress=gzip_raw&mode=recv&reconnect=true");  
  
  void main() {
      json param = R"({
          "op": "subscribe",
          "args": [{
              "channel": "tickers",
              "instId": "BTC-USDT"
          }]
      })"_json;
      
      objWS.write(param.dump());
      if(objWS.Valid) {
          uint64_t pingCyc = 1000 * 20;
          uint64_t lastPingTime = Unix() * 1000;
          while(true) {
              uint64_t nowTime = Unix() * 1000;
              auto ret = objWS.read();
              Log("ret:", ret);
              if(nowTime - lastPingTime > pingCyc) {
                  auto retPing = objWS.write("ping");
                  lastPingTime = nowTime;
                  Log("发送：ping", "#FF0000");
              }
              LogStatus("当前时间：", _D());
              Sleep(1000);
          }
      }
  }  
  
  void onexit() {
      objWS.close();
      Log("退出");
  }
  

  Die Websocket-Marktoberfläche für den Zugriff auf die Token:

  var ws = null   
  
  function main(){
      var param = {"sub": "market.btcusdt.detail", "id": "id1"}
      ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload="+ JSON.stringify(param))
      if(ws){
          while(1){
              var ret = ws.read()
              Log("ret:", ret)
              // 响应心跳包操作
              try {
                  var jsonRet = JSON.parse(ret)
                  if(typeof(jsonRet.ping) == "number") {
                      var strPong = JSON.stringify({"pong" : jsonRet.ping})
                      ws.write(strPong)
                      Log("响应ping，发送pong:", strPong, "#FF0000")
                  }
              } catch(e) {
                  Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
              }
              
              LogStatus("当前时间：", _D())
              Sleep(1000)
          }
      }
  }  
  
  function onexit() {
      ws.close() 
      Log("执行ws.close()函数")
  }
  

  import json
  ws = None  
  
  def main():
      global ws
      param = {"sub" : "market.btcusdt.detail", "id" : "id1"}
      ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + json.dumps(param))
      if ws:
          while True:
              ret = ws.read()
              Log("ret:", ret)              
              # 响应心跳包操作
              try:
                  jsonRet = json.loads(ret)
                  if "ping" in jsonRet and type(jsonRet["ping"]) == int:
                      strPong = json.dumps({"pong" : jsonRet["ping"]})
                      ws.write(strPong)
                      Log("响应ping，发送pong:", strPong, "#FF0000")
              except Exception as e:
                  Log("e:", e)
                  
              LogStatus("当前时间：", _D())
              Sleep(1000)
      
  def onexit():
      ws.close()
      Log("执行ws.close()函数")  
  

  using namespace std;
  void main() {
      json param = R"({"sub" : "market.btcusdt.detail", "id" : "id1"})"_json;
      auto ws = Dial("wss://api.huobi.pro/ws|compress=gzip&mode=recv&reconnect=true&payload=" + param.dump());
      if(ws.Valid) {
          while(true) {
              auto ret = ws.read();
              Log("ret:", ret);              
              // 响应心跳包操作
              try 
              {
                  auto jsonRet = json::parse(ret);
                  if(jsonRet["ping"].is_number()) {
                      json pong = R"({"pong" : 0})"_json;
                      pong["pong"] = jsonRet["ping"];
                      auto strPong = pong.dump();
                      ws.write(strPong);
                      Log("响应ping，发送pong:", strPong, "#FF0000");
                  }
              } catch(exception &e) 
              {
                  Log("e:", e.what());
              }
              
              LogStatus("当前时间：", _D());
              Sleep(1000);
          }
      }
  }  
  
  void onexit() {
      // ws.close();
      Log("执行ws.close()函数");
  }
  

  Die Websocket-Verifizierungsoberfläche für OKX:

  function getLogin(pAccessKey, pSecretKey, pPassphrase) {
      // 签名函数，用于登录
      var ts = (new Date().getTime() / 1000).toString()
      var login = {
          "op": "login",
          "args":[{
              "apiKey"    : pAccessKey,
              "passphrase" : pPassphrase,
              "timestamp" : ts,
              "sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
          }]
      }    
      return login
  }    
  
  var client_private = null 
  function main() {
      // 因为read函数使用了超时设置，过滤超时的报错，否则会有冗余错误输出
      SetErrorFilter("timeout")
      
      // 持仓频道订阅信息
      var posSubscribe = {
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      }    
  
      var accessKey = "xxx"
      var secretKey = "xxx"
      var passphrase = "xxx"
  
      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
      client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
      Sleep(3000)  // 登录时，不能立即订阅私有频道，需要等待服务器反应
      client_private.write(JSON.stringify(posSubscribe))
      if (client_private) {
          var lastPingTS = new Date().getTime()
          while (true) {
              var buf = client_private.read(-1)
              if (buf) {
                  Log(buf)
              }
              
              // 检测断开，重连
              if (buf == "" && client_private.write(JSON.stringify(posSubscribe)) == 0) {
                  Log("检测到断开，关闭连接，重连")
                  client_private.close()
                  client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
                  client_private.write(JSON.stringify(getLogin(accessKey, secretKey, passphrase)))
                  Sleep(3000)
                  client_private.write(JSON.stringify(posSubscribe))
              }
              
              // 发送心跳包
              var nowPingTS = new Date().getTime()
              if (nowPingTS - lastPingTS > 10 * 1000) {
                  client_private.write("ping")
                  lastPingTS = nowPingTS
              }            
          }        
      }
  }    
  
  function onexit() {    
      var ret = client_private.close()
      Log("关闭连接！", ret)
  }
  

  import json
  import time
    
  def getLogin(pAccessKey, pSecretKey, pPassphrase):
      ts = str(time.time())
      login = {
          "op": "login",
          "args":[{
              "apiKey"    : pAccessKey,
              "passphrase" : pPassphrase,
              "timestamp" : ts,
              "sign" : exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey)
          }]
      }
      return login     
  
  client_private = None 
  def main():
      global client_private
      SetErrorFilter("timeout")
      
      posSubscribe = {
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      }      
  
      accessKey = "xxx"
      secretKey = "xxx"
      passphrase = "xxx"
      
      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
      client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
      Sleep(3000)
      client_private.write(json.dumps(posSubscribe))
      if client_private:
          lastPingTS = time.time() * 1000
          while True:
              buf = client_private.read(-1)
              if buf:
                  Log(buf)
              
              if buf == "" and client_private.write(json.dumps(posSubscribe)) == 0:
                  Log("检测到断开，关闭连接，重连")
                  ret = client_private.close()
                  client_private = Dial("wss://ws.okx.com:8443/ws/v5/private")
                  client_private.write(json.dumps(getLogin(accessKey, secretKey, passphrase)))
                  Sleep(3000)
                  client_private.write(json.dumps(posSubscribe))
              
              nowPingTS = time.time() * 1000
              if nowPingTS - lastPingTS > 10 * 1000:
                  client_private.write("ping")
                  lastPingTS = nowPingTS    
  
  def onexit():
      ret = client_private.close()
      Log("关闭连接！", ret)
  

  auto client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");      
  
  json getLogin(string pAccessKey, string pSecretKey, string pPassphrase) {
      auto ts = std::to_string(Unix());
      json login = R"({
          "op": "login",
          "args": [{
              "apiKey": "",
              "passphrase": "",
              "timestamp": "",
              "sign": ""
          }]
      })"_json;
      login["args"][0]["apiKey"] = pAccessKey;
      login["args"][0]["passphrase"] = pPassphrase;
      login["args"][0]["timestamp"] = ts;
      login["args"][0]["sign"] = exchange.HMAC("sha256", "base64", ts + "GET" + "/users/self/verify", pSecretKey);
      return login;
  }      
  
  void main() {
      SetErrorFilter("timeout");
      json posSubscribe = R"({
          "op": "subscribe",
          "args": [{
              "channel": "positions",
              "instType": "ANY"
          }]
      })"_json;
      
      auto accessKey = "xxx";
      auto secretKey = "xxx";
      auto passphrase = "xxx";
      
      client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
      Sleep(3000);
      client_private.write(posSubscribe.dump());    
  
      if (client_private.Valid) {
          uint64_t lastPingTS = Unix() * 1000;      
  
          while (true) {
              auto buf = client_private.read(-1);
              if (buf != "") {
                  Log(buf);
              }
              if (buf == "") {
                  if (client_private.write(posSubscribe.dump()) == 0) {
                      Log("检测到断开，关闭连接，重连");
                      client_private.close();
                      client_private = Dial("wss://ws.okx.com:8443/ws/v5/private");
                      client_private.write(getLogin(accessKey, secretKey, passphrase).dump());
                      Sleep(3000);
                      client_private.write(posSubscribe.dump());
                  }
              }
              
              uint64_t nowPingTS = Unix() * 1000;
              if (nowPingTS - lastPingTS > 10 * 1000) {
                  client_private.write("ping");
                  lastPingTS = nowPingTS;
              }
          }
      }
  }      
  
  void onexit() {
      client_private.close();
      Log("退出");
  }
  

HttpQuery ist ein

HttpQuery(Url, PostData, Cookies, Headers, IsReturnHeader), Netzwerk-URL-Zugriff. Parameterwert: Alle für den Stringtyp.

Bitte beachten Sie:

• HttpQuery(...)Funktionen werden nur unterstütztJavaScriptDie Sprache.
• PythonSprache kann verwendet werdenurllibDas ist eine sehr schwierige Aufgabe.

HttpQuery(...)Es wird hauptsächlich für den Zugriff auf eine Anschlussstelle verwendet, die keine Unterschrift benötigt, z. B. für öffentliche Anschlüsse wie Marktinformationen.

Ein Beispiel für eine API-Schnittstelle, die keine Unterschrift benötigt, um zu OKX zu gelangen, und die einen Wert vonJSONIch bin nicht derjenige, der das sagt.JavaScriptDie Strategie der SpracheJSON.parse()Funktionsanalyse.

function main(){
    // 一个GET访问不带参数的例子
    var info = JSON.parse(HttpQuery("https://www.okx.com/api/v5/public/time"))
    Log(info)
    // 一个GET访问带参数的例子
    var ticker = JSON.parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"))
    Log(ticker)
}

import json
import urllib.request
def main():
    # HttpQuery不支持Python，可以使用urllib/urllib2库代替
    info = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/time").read().decode('utf-8'))
    Log(info)
    ticker = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/market/books?instId=BTC-USDT").read().decode('utf-8'))
    Log(ticker)

void main() {
    auto info = json::parse(HttpQuery("https://www.okx.com/api/v5/public/time"));
    Log(info);
    auto ticker = json::parse(HttpQuery("https://www.okx.com/api/v5/market/books?instId=BTC-USDT"));
    Log(ticker);
}

Wenn die zweite Parameter die Rückgabe eines URLs erhält,PostDataFür die Stringa=1&b=2&c=abcDie Form ist:POSTWie kann ich das machen?PUTSie haben sich nicht verändert.PostDataDie Parameter sind:{method:'PUT', data:'a=1&b=2&c=abc'}。 PostDataDie Parameter können auchJSONDie Strings.

CookiesDie Form dieses Parameters lautet:a=10; b=20Die Parameter werden mit einem Komma bezeichnet.;Ich bin nicht derjenige, der es tut.HeadersDie Form dieses Parameters lautet:User-Agent: Mobile\nContent-Type: text/htmlDie Parameter werden mit Zeilenzeichen ausgetauscht.\nIch bin nicht derjenige, der es tut.

Der zweite ParameterPostDataSie können sich anpassen, wie zum Beispiel:HttpQuery("http://www.abc.com", {method:'PUT', data:'a=1&b=2&c=abc'})Bitte beachten Sie:HttpQueryDie Funktion setzt die Überstunden ein.{method:'PUT', data:'a=1&b=2&c=abc'}BeitritttimeoutEigenschaften (Standard 60 Sekunden)

Ein Sekunde Zeitverzug:HttpQuery("http://www.abc.com", {method:'PUT', data:'a=1&b=2&c=abc', timeout:1000})

ÜbertragenCookieEine String braucht einen dritten Parameter, aber nichtPOSTBitte setzen Sie den zweiten Parameter auf null. Während des Analogetests kehrt die Funktion eine feste String zurück, da die URL nicht simuliert werden kann.Dummy DataÜber diese Schnittstelle können Sie SMS senden oder mit anderen API-Schnittstellen interagieren.

GETEin Beispiel für einen Anruf:HttpQuery("http://www.baidu.com")。 POSTEin Beispiel für einen Anruf:HttpQuery("http://www.163.com", "a=1&b=2&c=abc")。

ZurückHeaderEin Beispiel für einen Anruf:

HttpQuery("http://www.baidu.com", null, "a=10; b=20", "User-Agent: Mobile\nContent-Type: text/html", true)  // will return {Header: HTTP Header, Body: HTML}

• HttpQueryDie Funktion wird mit einem Agenten eingestellt:

  function main() {
      // 本次设置代理并发送http请求，无用户名，无密码，此次http请求会通过代理发送
      HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/")
  
      // 本次设置代理并发送http请求，输入用户名和密码，仅HttpQuery当前调用生效，之后再次调用HttpQuery("http://www.baidu.com")这样不会使用代理
      HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/")
  }
  

  # HttpQuery不支持Python，可以使用Python的urllib2库
  

  void main() {
      HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/");
      HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/");
  }
  

• HttpQueryAsynchrone Versionen von FunktionenHttpQuery_GoIch bin nicht derjenige. Nutzung undexchange.GoDie Funktionen sind ähnlich, z. B. ein asynchroner Zugriff auf die öffentliche Schnittstelle der Börse, um Aggregatmarktdaten zu erhalten.

  function main() {
      // 创建第一个异步线程
      var r1 = HttpQuery_Go("https://www.okx.com/api/v5/market/tickers?instType=SPOT")
      // 创建第二个异步线程
      var r2 = HttpQuery_Go("https://api.huobi.pro/market/tickers")
      
      // 获取第一个异步线程调用的返回值
      var tickers1 = r1.wait()
      // 获取第二个异步线程调用的返回值
      var tickers2 = r2.wait()
      
      // 打印结果
      Log("tickers1:", tickers1)
      Log("tickers2:", tickers2)
  }
  

  # 不支持
  

  // 不支持
  

• Verwendung in Retest-SystemenHttpQuery(...)Die Funktion: Sie können in Retestsystemen verwendet werden.HttpQuery(...)Senden von Anfragen (nur unterstützt)GETVerwenden Sie die folgenden Funktionen: • Anfordern Sie Daten; • Beschränken Sie die Wiederholung auf 20 verschiedene URLs undHttpQuery(...)Der Zugriff speichert Daten, die beim zweiten Zugriff auf dieselbe URL gespeichert werden.HttpQuery(...)Die Funktion kehrt Cache-Daten zurück (es gibt keine tatsächlichen Netzwerkanfragen mehr).

  Wir können einen Serviceprogramm auf einem Server oder Gerät laufen lassen, um auf die Strategie zu reagieren.HttpQuery(...)Die Requests wurden mit dem folgenden Go-Language-Service-Programm getestet:

  package main
  import (
      "fmt"
      "net/http"
      "encoding/json"
  )
  
  func Handle (w http.ResponseWriter, r *http.Request) {
      defer func() {
          fmt.Println("req:", *r)
          ret := map[string]interface{}{
              "schema" : []string{"time","open","high","low","close","vol"},
              "data" : []interface{}{
                  []int64{1564315200000,9531300,9531300,9497060,9497060,787},
                  []int64{1564316100000,9495160,9495160,9474260,9489460,338},
              },
          }
          b, _ := json.Marshal(ret)
          w.Write(b)
      }()
  }
  
  func main () {
      fmt.Println("listen http://localhost:9090")
      http.HandleFunc("/data", Handle)
      http.ListenAndServe(":9090", nil)
  }
  

  Strategie-RücksichtHttpQuery(...)Funktionsanforderung:

  function main() {
      // 可以写自己运行服务程序所在设备的IP地址
      Log(HttpQuery("http://xxx.xx.x.xxx:9090/data?msg=hello"));
      Log(exchange.GetAccount());
  }
  

  # HttpQuery不支持Python，可以使用Python的urllib2库
  

  void main() {
      // 可以写自己运行服务程序所在设备的IP地址
      Log(HttpQuery("http://xxx.xx.x.xxx:9090/data?msg=hello"));
      Log(exchange.GetAccount());
  }
  

  

• Unterstützt die Umschlüsselung von Reaktionsdaten auf Anfragen und unterstützt die allgemeine Verschlüsselung. BestimmungPostDataParameter:{method: "GET",charset:"GB18030"}Die Datenübertragungskode (GB18030) wird dann umgesetzt.

Verschlüsselung

Encode(algo, inputFormat, outputFormat, data, keyFormat, key string)Die Funktion kodiert die Daten nach den eingegebenen Parametern.

ParameteralgoDie Algorithmen, die bei der Codeberechnung verwendet werden, werden unterstützt:??raw (ohne Algorithmen),??sign,??signTx,??md4,??md5,??sha256,??sha512,??sha1,??keccak256,??sha3.224,??sha3.256,??sha3.384,??sha3.512,??sha3.keccak256,??sha3.keccak512,??sha512.384,??sha512.256,??sha512.224,??ripemd160,??blake2b.256,??blake2b.512,??blake2s.128,??blake2s.256.dataDie Daten, die verarbeitet werden sollen.inputFormat/outputFormat/keyFormatParameter unterstütztraw，hex，base64，stringDas ist ein sehr schwieriger Fall. WennkeyFormatWenn es nicht null ist, dann benutzen wir die Parameter.keyVerschlüsselung (HMAC), ansonsten ist der StandardkeyParameteralgoSetzen Sie auf"sign"Oder"signTx"Wenn Parameter erforderlich sindkey。

function main(){
    Log(Encode("md5", "raw", "hex", "hello"))
    Log(Encode("sha512", "raw", "base64", "hello"))
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)"))

    Log(Encode("raw", "string", "hex", "example"))          // 6578616d706c65
    Log(Encode("raw", "hex", "string", "6578616d706c65"))   // example
}

def main():
    Log(Encode("md5", "raw", "hex", "hello", "", ""))
    Log(Encode("sha512", "raw", "base64", "hello", "", ""))
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)", "", ""))

    Log(Encode("raw", "string", "hex", "example", "", ""))
    Log(Encode("raw", "hex", "string", "6578616d706c65", "", ""))

void main(){
    Log(Encode("md5", "raw", "hex", "hello"));
    Log(Encode("sha512", "raw", "base64", "hello"));
    Log(Encode("keccak256", "raw", "hex", "unwrapWETH9(uint256,address)"));
    
    Log(Encode("raw", "string", "hex", "example"));          // 6578616d706c65
    Log(Encode("raw", "hex", "string", "6578616d706c65"));   // example
}

ParameteralgoSie unterstützen auch:text.encoder.utf8，text.decoder.utf8，text.encoder.gbk，text.decoder.gbk, für die String-Codierung, für die Entschlüsselung.

function main(){
    var ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好")     // e4bda0e5a5bd
    Log(ret1)    
    var ret2 = Encode("text.decoder.utf8", "hex", "string", ret1)   
    Log(ret2)

    var ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好")      // c4e3bac3
    Log(ret3)
    var ret4 = Encode("text.decoder.gbk", "hex", "string", ret3)
    Log(ret4)
}

def main():
    ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好", "", "")     # e4bda0e5a5bd
    Log(ret1)    
    ret2 = Encode("text.decoder.utf8", "hex", "string", ret1, "", "")   
    Log(ret2)

    ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好", "", "")      # c4e3bac3
    Log(ret3)
    ret4 = Encode("text.decoder.gbk", "hex", "string", ret3, "", "")
    Log(ret4)

void main(){
    auto ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好");     // e4bda0e5a5bd
    Log(ret1);    
    auto ret2 = Encode("text.decoder.utf8", "hex", "string", ret1);   
    Log(ret2);

    auto ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好");      // c4e3bac3
    Log(ret3);
    auto ret4 = Encode("text.decoder.gbk", "hex", "string", ret3);
    Log(ret4);
}

UnixNano (siehe unten)

UnixNano(), die eine Nanosekunden-Zeitspanne zurückgibt. Wenn Sie eine Millisekunden-Zeitspanne erhalten möchten, können Sie folgende Code verwenden:

function main() {
    var time = UnixNano() / 1000000
    Log(_N(time, 0))
}

def main():
    time = UnixNano()
    Log(time)

void main() {
    auto time = UnixNano();
    Log(time);
}

Unix()

Unix(), die Sekunden-Ebene-Zeitknalle zurückgibt.

function main() {
    var t = Unix()
    Log(t)
}

def main():
    t = Unix()
    Log(t)

void main() {
    auto t = Unix();
    Log(t);
}

GetOS()

GetOS()Die Daten werden von den Administratoren zurückgesendet.

function main() {
    Log("GetOS:", GetOS())
}

def main():
    Log("GetOS:", GetOS())

void main() {
    Log("GetOS:", GetOS());
}

Auf einem Apple ComputerMac OSDie Ausgabe des Administrator-Logs, der unter dem Betriebssystem ausgeführt wird:

GetOS: darwin/amd64

darwinDas heißtMac OSDer Name des Systems.

MD5 ((String)

MD5(String), Parameterwert: Stringtyp.

function main() {
    Log("MD5", MD5("hello world"))
}

def main():
    Log("MD5", MD5("hello world"))

void main() {
    Log("MD5", MD5("hello world"));
}

Die Datenbank ist hier:

Wir haben eine Reihe von Problemen.

DBExec ((...)

DBExec(), Parameterwerte: können Strings, Zahlenwerte, Bullwerte, Leerwerte usw. sein. Datenbank-Interface-FunktionenDBExec()Durch die Einführung von Parametern kann die Festplatten-Datenbank (SQLite-Datenbank) bedient werden.SQLiteSyntax.Die Systemreservierungstabelle in der Festplatten-Datenbank:kvdb、cfg、log、profit、chartSie müssen sich nicht an diese Tabellen beteiligen.DBExec()Die Funktion unterstützt nur die Festplatte.

• Unterstützung von Speicherdatenbanken FürDBExecDie Parameter der Funktion, wennQuadratkilometerDie Sätze sind::Anfänglich wird die Datenbank im Speicher betrieben, ohne Dateien zu schreiben, schneller. Geeignet für Datenbankoperationen, die keine persistierende Speicherung erfordern, wie zum Beispiel:

  function main() {
      var strSql = [
          ":CREATE TABLE TEST_TABLE(", 
          "TS INT PRIMARY KEY NOT NULL,",
          "HIGH REAL NOT NULL,", 
          "OPEN REAL NOT NULL,", 
          "LOW REAL NOT NULL,", 
          "CLOSE REAL NOT NULL,", 
          "VOLUME REAL NOT NULL)"
      ].join("")
      var ret = DBExec(strSql)
      Log(ret)
      
      // 增加一条数据
      Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
      
      // 查询数据
      Log(DBExec(":SELECT * FROM TEST_TABLE;"))
  }
  

  def main():
      arr = [
          ":CREATE TABLE TEST_TABLE(", 
          "TS INT PRIMARY KEY NOT NULL,",
          "HIGH REAL NOT NULL,", 
          "OPEN REAL NOT NULL,", 
          "LOW REAL NOT NULL,", 
          "CLOSE REAL NOT NULL,", 
          "VOLUME REAL NOT NULL)"
      ]
      strSql = ""
      for i in range(len(arr)):
          strSql += arr[i]
      ret = DBExec(strSql)
      Log(ret)
      
      # 增加一条数据
      Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
      
      # 查询数据
      Log(DBExec(":SELECT * FROM TEST_TABLE;"))
  

  void main() {
      string strSql = ":CREATE TABLE TEST_TABLE(\
          TS INT PRIMARY KEY NOT NULL,\
          HIGH REAL NOT NULL,\
          OPEN REAL NOT NULL,\
          LOW REAL NOT NULL,\
          CLOSE REAL NOT NULL,\
          VOLUME REAL NOT NULL)";
      auto ret = DBExec(strSql);
      Log(ret);
      
      // 增加一条数据
      Log(DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
      
      // 查询数据
      Log(DBExec(":SELECT * FROM TEST_TABLE;"));
  }
  

• Tabellen erstellen

function main() {
    var strSql = [
        "CREATE TABLE TEST_TABLE(", 
        "TS INT PRIMARY KEY NOT NULL,",
        "HIGH REAL NOT NULL,", 
        "OPEN REAL NOT NULL,", 
        "LOW REAL NOT NULL,", 
        "CLOSE REAL NOT NULL,", 
        "VOLUME REAL NOT NULL)"
    ].join("")
    var ret = DBExec(strSql)
    Log(ret)
}

def main():
    arr = [
        "CREATE TABLE TEST_TABLE(", 
        "TS INT PRIMARY KEY NOT NULL,",
        "HIGH REAL NOT NULL,", 
        "OPEN REAL NOT NULL,", 
        "LOW REAL NOT NULL,", 
        "CLOSE REAL NOT NULL,", 
        "VOLUME REAL NOT NULL)"
    ]
    strSql = ""
    for i in range(len(arr)):
        strSql += arr[i]
    ret = DBExec(strSql)
    Log(ret)

void main() {
    string strSql = "CREATE TABLE TEST_TABLE(\
        TS INT PRIMARY KEY NOT NULL,\
        HIGH REAL NOT NULL,\
        OPEN REAL NOT NULL,\
        LOW REAL NOT NULL,\
        CLOSE REAL NOT NULL,\
        VOLUME REAL NOT NULL)";
    auto ret = DBExec(strSql);
    Log(ret);
}

• Anpassung von Tabellenprotokollen

function main() {
    var strSql = [
        "CREATE TABLE TEST_TABLE(", 
        "TS INT PRIMARY KEY NOT NULL,",
        "HIGH REAL NOT NULL,", 
        "OPEN REAL NOT NULL,", 
        "LOW REAL NOT NULL,", 
        "CLOSE REAL NOT NULL,", 
        "VOLUME REAL NOT NULL)"
    ].join("")
    Log(DBExec(strSql))
    
    // 增加一条数据
    Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
    
    // 查询数据
    Log(DBExec("SELECT * FROM TEST_TABLE;"))
    
    // 修改数据
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))    
    
    // 删除数据
    Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))
}

def main():
    arr = [
        "CREATE TABLE TEST_TABLE(", 
        "TS INT PRIMARY KEY NOT NULL,",
        "HIGH REAL NOT NULL,", 
        "OPEN REAL NOT NULL,", 
        "LOW REAL NOT NULL,", 
        "CLOSE REAL NOT NULL,", 
        "VOLUME REAL NOT NULL)"
    ]
    strSql = ""
    for i in range(len(arr)):
        strSql += arr[i]
    Log(DBExec(strSql))
    
    # 增加一条数据
    Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"))
    
    # 查询数据
    Log(DBExec("SELECT * FROM TEST_TABLE;"))
    
    # 修改数据
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000))
    
    # 删除数据
    Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110))

void main() {
    string strSql = "CREATE TABLE TEST_TABLE(\
        TS INT PRIMARY KEY NOT NULL,\
        HIGH REAL NOT NULL,\
        OPEN REAL NOT NULL,\
        LOW REAL NOT NULL,\
        CLOSE REAL NOT NULL,\
        VOLUME REAL NOT NULL)";
    Log(DBExec(strSql));

    // 增加一条数据
    Log(DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);"));
    
    // 查询数据
    Log(DBExec("SELECT * FROM TEST_TABLE;"));
    
    // 修改数据
    Log(DBExec("UPDATE TEST_TABLE SET HIGH=? WHERE TS=?", 110, 1518970320000));
    
    // 删除数据
    Log(DBExec("DELETE FROM TEST_TABLE WHERE HIGH=?", 110));
}

UUID (()

UUID(), die eine 32-Bit-Unique-UUID zurückgibt, die nur für die Festplatte verwendet wird.

function main() {
    var uuid1 = UUID()
    var uuid2 = UUID()
    Log(uuid1, uuid2)
}

def main():
    uuid1 = UUID()
    uuid2 = UUID()
    Log(uuid1, uuid2)

void main() {
    auto uuid1 = UUID();
    auto uuid2 = UUID();
    Log(uuid1, uuid2);
}

EventLoop (Zeitrahmen)

EventLoop(timeout)Ich habe keine Wahl.websocketLesbar oderexchange.Go、HttpQuery_GoSo werden die gleichzeitigen Aufgaben nach Abschluss zurückgegeben.timeoutWenn es auf 0 gesetzt ist, wird erst auf ein Ereignis gewartet, wenn es größer als 0 ist, wird die Ereigniszeit überschritten, wenn es kleiner als 0 ist, wird sofort das jüngste Ereignis zurückgegeben.nullDie Daten werden von den Benutzern gesammelt.EventDer Typ für die Ereignis-Triggerung. Diese Funktion gilt nur für die Festplatte.

Der erste Aufruf im CodeEventLoopWenn Sie das System nicht verwenden, wird die Überwachung erst initialiert, wenn Sie es erst nach dem Abruf des Ereignisses starten.EventLoopAufrufe, die die vorherigen Ereignisse verpassen. Die untergeordnete Systemumwandlung speichert bis zu 500 Ereignisrückrufe, wenn der Programmlauf nicht rechtzeitig aufgerufen wirdEventLoopWenn Sie das nicht tun, verlieren Sie 500 Cache-Ereignisse, die später abgerufen wurden.EventLoopFunktionsaufrufe beeinflussen nicht die SystembasiswebsocketDie Cache-Warteschlangen sind nicht beeinflusst.exchange.GoDie Cache von gleichzeitigen Funktionen, wie z.B. die Cache von parallelen Funktionen, benötigt immer noch eine eigene Methode, um Daten zu extrahieren.EventLoopDie Daten, die entnommen wurden, werden nicht in der Funktion zurückgegeben.EventLoopDie Funktion erzeugt eine Rückkehr.

EventLoopDie Funktion dient hauptsächlich der Benachrichtigung der Policy-Layer, bei der die Systemunterseite neue Netzwerkdaten empfängt.EventLoopWenn eine Funktion ein Ereignis zurückgibt, muss sie nur alle Datenquellen durchlaufen.websocketSie sind in der Lage, sich zu vernetzen.exchange.GoEin Objekt, das erstellt wird, versucht, Daten zu erhalten.Verknüpfungen zur Bibliothek。

In der Hauptfunktionmain()Der Hauptthread wird während des Zwischenrufs überwacht.JavaScriptIn der Strategie, Sprache zu schreiben, ist es wichtig, dass die Sprache in der Praxis funktioniert.__Thread()Die Funktion erstellt Threads, die auch in der Exekutivfunktion des Threads aufgerufen werden können, um auf die Ereignisse des aktuellen Threads zu hören.

function main() {
    var routine_getTicker = exchange.Go("GetTicker")
    var routine_getDepth = exchange.Go("GetDepth")
    var routine_getTrades = exchange.Go("GetTrades")
    
    // Sleep(2000)，如果这里使用Sleep语句，会导致之后的EventLoop函数错过之前的事件，因为等待了2秒，并发的函数