Version

返回系统当前的版本号。

    
    
    
Version()

示例

    javascript
    
    
function main() {
    Log("version:", Version())
}

    python
    
    
def main():
    Log("version:", Version())

    rust
    
    
fn main() {
    Log!("version:", Version());
}

    c++
    
    
void main() {
    Log("version:", Version());
}

返回值

备注

系统版本号即托管者程序的版本号。

Sleep

休眠函数，使程序暂停运行一段时间。

    
    
    
Sleep(millisecond)

示例

    javascript
    
    
function main() {
    Sleep(1000 * 10)   // 等待10秒钟
    Log("等待了10秒钟")
}

    python
    
    
def main():
    Sleep(1000 * 10)
    Log("等待了10秒钟")

    rust
    
    
fn main() {
    Sleep(1000 * 10);   // 等待10秒钟
    Log!("等待了10秒钟");
}

    c++
    
    
void main() {
    Sleep(1000 * 10);
    Log("等待了10秒钟");
}

参数

备注

例如，执行Sleep(1000)函数时，程序将休眠1秒。该函数支持小于1毫秒的休眠操作，例如Sleep(0.1)；支持的最小参数为0.000001，即纳秒级休眠，1纳秒等于1e-6毫秒。

在使用Python语言编写策略时，对于轮询间隔、时间等待等操作，应当使用Sleep(millisecond)函数，而不建议使用Python中time库的time.sleep(second)函数。因为在回测时，策略中的time.sleep(second)函数会使策略程序实际等待相应的时间（而非在回测系统的时间序列上跳过），从而导致回测速度非常缓慢。

IsVirtual

判断策略当前的运行环境是否为回测系统。

    
    
    
IsVirtual()

示例

    javascript
    
    
function main() {
    if (IsVirtual()) {
        Log("当前为回测系统环境。")
    } else {
        Log("当前为实盘环境。")
    }
}

    python
    
    
def main():
    if IsVirtual():
        Log("当前为回测系统环境。")
    else:
        Log("当前为实盘环境。")

    rust
    
    
fn main() {
    if IsVirtual() {
        Log!("当前为回测系统环境。");
    } else {
        Log!("当前为实盘环境。");
    }
}

    c++
    
    
void main() {
    if (IsVirtual()) {
        Log("当前为回测系统环境。");
    } else {
        Log("当前为实盘环境。");
    }
}

返回值

备注

用于判断当前运行环境是否为回测系统，以便兼容回测与实盘之间的差异。

Mail

发送邮件。

    
    
    
Mail(smtpServer, smtpUsername, smtpPassword, mailTo, title, body)

示例

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

    python
    
    
def main():
    Mail("smtp.163.com", "asdf@163.com", "password", "111@163.com", "title", "body")

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

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

返回值

参数

参考

备注

smtpPassword参数设置的是SMTP服务的密码，而非邮箱登录密码。

设置smtpServer参数时，如果需要更改端口，可以直接在smtpServer参数中加入端口号。例如：QQ邮箱smtp.qq.com:587，该端口经测试可用。

如果出现报错：unencryped connection，需要修改Mail函数的smtpServer参数。参数格式为：ssl://xxx.com:xxx，例如QQ邮箱SMTP的ssl连接方式：ssl://smtp.qq.com:465，或者smtp://xxx.com:xxx。

该函数在回测系统中不起作用。

Mail_Go

Mail函数的异步版本。

    
    
    
Mail_Go(smtpServer, smtpUsername, smtpPassword, mailTo, title, body)

示例

    javascript
    
    
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)
}

    python
    
    
# 不支持

    c++
    
    
// 不支持

返回值

参数

参考

备注

在回测系统中不起作用。

SetErrorFilter

过滤错误日志。

    
    
    
SetErrorFilter(filters)

示例

• 过滤常见错误信息。

  • javascript
  • python
  • rust
  • cpp

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

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

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

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

• 过滤某个接口的错误信息。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 由于这是测试代码，未采用商品期货策略的通用架构，此处仅通过 exchange.IO("status") 函数判断是否成功连接期货公司前置机，连接成功后立即执行测试代码。股票、证券交易无需使用 exchange.IO("status") 判断连接状态
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
      // 设置合约代码
      exchange.SetContractType("rb888")
  
      // 查询一个不存在的订单（id 为 123），故意触发接口报错
      var order = exchange.GetOrder("123")
      Log(order)
      // 过滤 http 502 错误及 GetOrder 接口错误；设置错误过滤后，再次调用 GetOrder 将不再报错
      SetErrorFilter("502:|GetOrder")
      order = exchange.GetOrder("123")
      Log(order)
  }
  

  
      python
      
      
  def main():
      while not exchange.IO("status"):
          Sleep(1000)
  
      exchange.SetContractType("rb888")
  
      order = exchange.GetOrder("123")
      Log(order)
      SetErrorFilter("502:|GetOrder")
      order = exchange.GetOrder("123")
      Log(order)
  

  
      rust
      
      
  fn main() {
      // 由于这是测试代码，未采用商品期货策略的通用架构，此处仅通过 exchange.IO("status") 函数判断是否成功连接期货公司前置机，连接成功后立即执行测试代码。股票、证券交易无需使用 exchange.IO("status") 判断连接状态
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
      // 设置合约代码
      let _ = exchange.SetContractType("rb888");
  
      // 查询一个不存在的订单（id 为 123），故意触发接口报错
      let orderId = OrderId { S: "123".to_string(), ..Default::default() };
      let order = exchange.GetOrder(&orderId);
      Log!(order);
      // 过滤 http 502 错误及 GetOrder 接口错误；设置错误过滤后，再次调用 GetOrder 将不再报错
      SetErrorFilter("502:|GetOrder");
      let order = exchange.GetOrder(&orderId);
      Log!(order);
  }
  

  
      c++
      
      
  void main() {
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888");
  
      TId orderId;
      Order order = exchange.GetOrder(orderId);
      Log(order);
      SetErrorFilter("502:|GetOrder");
      order = exchange.GetOrder(orderId);
      Log(order);
  }
  

参数

备注

被此正则表达式匹配的错误日志将不会上传至日志系统。该方法可多次调用（无次数限制）以设置多个过滤条件，多次设置的正则表达式会累积生效。若需重置用于过滤错误日志的正则表达式，可传入空字符串：SetErrorFilter("")。

被过滤的日志将不再写入托管者目录下对应实盘 Id 的数据库文件中，从而避免因频繁报错导致数据库文件膨胀。

GetPid

获取实盘进程的 Id。

    
    
    
GetPid()

示例

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

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

    rust
    
    
fn main() {
    let id = GetPid();
    Log!(id);
}

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

返回值

GetLastError

获取最近一次的错误信息。

    
    
    
GetLastError()

示例

    javascript
    
    
function main(){
    // 由于这是测试代码，未采用商品期货策略的通用架构，此处仅通过 exchange.IO("status") 函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票、证券交易无需使用 exchange.IO("status") 判断连接状态
    while(!exchange.IO("status")) {
        Sleep(1000)
    }

    exchange.SetContractType("rb888")

    // 由于不存在编号为 123 的订单，因此会触发错误
    exchange.GetOrder("123")
    var error = GetLastError()
    Log(error)
}

    python
    
    
def main():
    while not exchange.IO("status"):
        Sleep(1000)

    exchange.SetContractType("rb888")

    exchange.GetOrder("123")
    error = GetLastError()
    Log(error)

    rust
    
    
fn main() {
    // 由于这是测试代码，未采用商品期货策略的通用架构，此处仅通过 exchange.IO("status") 函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票、证券交易无需使用 exchange.IO("status") 判断连接状态
    while exchange.IO("status").unwrap_or_default() != "true" {
        Sleep(1000);
    }

    exchange.SetContractType("rb888").unwrap();

    // 由于不存在编号为 123 的订单，因此会触发错误
    let id = OrderId { S: "123".to_string(), ..Default::default() };
    let _ = exchange.GetOrder(&id);
    let error = GetLastError();
    Log!(error);
}

    c++
    
    
void main() {
    while(exchange.IO("status") == 0) {
        Sleep(1000);
    }

    exchange.SetContractType("rb888");

    // 订单 ID 类型为 TId，因此不能传入字符串，此处通过下一个不符合交易所规范的订单来触发错误
    exchange.GetOrder(exchange.Buy(1, 1));
    auto error = GetLastError();
    Log(error);
}

返回值

备注

该函数在回测系统中不起作用。

GetCommand

获取策略的交互命令。

    
    
    
GetCommand()

示例

• 检测交互命令，并在检测到交互命令时使用Log函数输出该交互命令。

  • javascript
  • python
  • rust
  • cpp

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

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

  
      rust
      
      
  fn main() {
      loop {
          if let Some(cmd) = GetCommand(0) {
              Log!(cmd);
          }
          Sleep(1000);
      }
  }
  

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

• 例如，在策略交互控件中添加一个不带输入框的控件，将交互控件命名为：buy，控件描述信息设置为：买入，这是一个按钮控件。接着再添加一个带输入框的控件，将交互控件命名为：sell，控件描述信息设置为：卖出，这是一个由按钮和输入框组合而成的交互控件。

  在策略中编写交互代码，以响应不同的交互控件：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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)
      }
  }
  

  
      python
      
      
  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)
  

  
      rust
      
      
  fn main() {
      loop {
          LogStatus!(_D(None));
          if let Some(cmd) = GetCommand(0) {
              Log!("cmd:", cmd);
              let arr: Vec<&str> = cmd.split(':').collect();
              if arr[0] == "buy" {
                  Log!("买入，该控件不带数量");
              } else if arr[0] == "sell" {
                  Log!("卖出，该控件带数量：", arr[1]);
              } else {
                  Log!("其它控件触发：", arr);
              }
          }
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  #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

获取生成策略注册码时写入的 Meta 值。

    
    
    
GetMeta()

示例

应用场景示例：使用 Meta 限制策略可操作的资产数量。

    javascript
    
    
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
    }

    // 鉴于此为测试代码，未采用商品期货策略的通用架构，这里仅通过 exchange.IO("status") 函数判断连接期货公司前置机成功后，立即执行测试代码。股票证券无需使用 exchange.IO("status") 判断连接状态
    while(!exchange.IO("status")) {
        Sleep(1000)
    }

    exchange.SetContractType("rb888")

    while(true) {
        Sleep(1000)
        var ticker = exchange.GetTicker()

        // 检测资产数值
        var acc = exchange.GetAccount()
        if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Balance + acc.FrozenBalance) {
            // 停止执行策略交易逻辑
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限制，不再执行策略交易逻辑！")
            continue
        }

        // 其他交易逻辑

        // 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker 数据：\n", ticker)
    }
}

    python
    
    
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 not exchange.IO("status"):
        Sleep(1000)

    exchange.SetContractType("rb888")

    while True:
        Sleep(1000)
        ticker = exchange.GetTicker()
        acc = exchange.GetAccount()
        if maxBaseCurrency != -1 and maxBaseCurrency < acc["Balance"] + acc["FrozenBalance"]:
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限制，不再执行策略交易逻辑！")
            continue

        # 其他交易逻辑

        # 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker 数据：\n", ticker)

    rust
    
    
fn main() {
    // 策略允许的计价币最大资产数量
    let maxBaseCurrency;

    // 获取创建注册码时的元数据
    let meta = GetMeta();
    let level = meta.as_str().unwrap_or("");

    // 检测 Meta 对应的条件
    if level == "level1" {
        // -1 表示不限制
        maxBaseCurrency = -1.0;
    } else if level == "level2" {
        maxBaseCurrency = 10.0;
    } else if level == "level3" {
        maxBaseCurrency = 1.0;
    } else {
        maxBaseCurrency = 0.5;
    }

    // 鉴于此为测试代码，未采用商品期货策略的通用架构，这里仅通过 exchange.IO("status") 函数判断连接期货公司前置机成功后，立即执行测试代码。股票证券无需使用 exchange.IO("status") 判断连接状态
    while exchange.IO("status").unwrap_or_default() != "true" {
        Sleep(1000);
    }

    exchange.SetContractType("rb888").unwrap();

    loop {
        Sleep(1000);
        let ticker = exchange.GetTicker(None).unwrap();

        // 检测资产数值
        let acc = exchange.GetAccount().unwrap();
        if maxBaseCurrency != -1.0 && maxBaseCurrency < acc.Balance + acc.FrozenBalance {
            // 停止执行策略交易逻辑
            LogStatus!(_D(None), "level:", level, "持仓超过注册码的使用限制，不再执行策略交易逻辑！");
            continue;
        }

        // 其他交易逻辑

        // 正常输出状态栏信息
        LogStatus!(_D(None), "level:", level, "策略正常运行！ticker 数据：\n", ticker);
    }
}

    c++
    
    
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(exchange.IO("status") == 0) {
        Sleep(1000);
    }

    exchange.SetContractType("rb888");

    while(true) {
        Sleep(1000);
        auto ticker = exchange.GetTicker();
        auto acc = exchange.GetAccount();
        if (maxBaseCurrency != -1 && maxBaseCurrency < acc.Balance + acc.FrozenBalance) {
            // 停止执行策略交易逻辑
            LogStatus(_D(), "level:", level, "持仓超过注册码的使用限制，不再执行策略交易逻辑！");
            continue;
        }

        // 其他交易逻辑

        // 正常输出状态栏信息
        LogStatus(_D(), "level:", level, "策略正常运行！ticker 数据：\n", ticker);
    }
}

返回值

备注

应用场景：需要对不同的策略租用者进行资金限制。生成注册码时设置的Meta值长度不能超过 190 个字符，GetMeta()函数仅支持实盘环境。

如果生成策略注册码时未设置元数据（Meta），则GetMeta()函数返回空值。

该函数在回测系统中不起作用。

Dial

用于原始的Socket访问，支持tcp、udp、tls、unix协议。

支持 4 种主流的通信协议：mqtt、nats、amqp、kafka。

支持连接数据库，可连接的数据库包括：sqlite3、mysql、postgres、clickhouse。

    
    
    
Dial(address)

    
    
    
Dial(address, timeout)

    
    
    
Dial(address, options)

示例

• Dial 函数调用示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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()
      }
  }
  

  
      python
      
      
  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()
  

  
      rust
      
      
  fn main() {
      // Dial 支持 tcp://、udp://、tls://、unix:// 协议，可使用 Dial::new(addr, timeout) 指定超时的秒数
      let mut client = Dial("tls://www.baidu.com:443");
      if client.Valid() {
          // write 的第二个数字参数指定超时，write 返回成功发送的字节数
          client.write("GET / HTTP/1.1\nConnection: Closed\n\n", 0);
          loop {
              // read 的数字参数指定超时，单位：毫秒。返回空字符串表示出错、超时或 socket 已关闭
              let buf = client.read(0);
              if buf == "" {
                  break;
              }
              Log!(buf);
          }
          client.close();
      }
  }
  

  
      c++
      
      
  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();
      }
  }
  

• Dial函数连接数据库时返回的连接对象具有2个独有的方法函数：

  - exec(sqlString): 用于执行SQL语句，使用方式与DBExec()函数类似。

  - fd(): fd()函数返回一个句柄（例如：句柄变量为handle），用于在其它线程中重连（即使Dial创建的连接对象已通过close()函数关闭连接），只需将该句柄传入Dial()函数即可重用连接，例如：Dial(handle)。

  以下是使用Dial函数连接sqlite3数据库的示例。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var client = null
  function main() {
      // client = Dial("sqlite3://:memory:")   // 使用内存数据库
      client = Dial("sqlite3://test1.db")      // 打开/连接托管者所在目录的数据库文件
  
      // 记录句柄
      var sqlite3Handle = client.fd()
      Log("sqlite3Handle:", sqlite3Handle)
  
      // 查询数据库中的表
      var ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'")
      Log(ret)
  }
  
  function onexit() {
      Log("执行client.close()")
      client.close()
  }
  

  
      python
      
      
  // 不支持

  
      rust
      
      
  fn main() {
      // let mut client = Dial("sqlite3://:memory:");   // 使用内存数据库
      let mut client = Dial("sqlite3://test1.db");      // 打开/连接托管者所在目录的数据库文件
  
      // Rust 的连接对象不支持 fd() 方法
  
      // 查询数据库中的表
      let ret = client.exec("SELECT name FROM sqlite_master WHERE type='table'");
      Log!(format!("{:?}", ret));
  
      Log!("执行client.close()");
      client.close();
  }
  

  
      c++
      
      
  // 不支持

返回值

参数

备注

address参数的详细说明：在标准地址wss://xxx.xxx.xxx:10441/websocket?compress之后，以|符号进行分隔。如果参数字符串中包含|字符，则使用||作为分隔符。分隔符之后的部分为功能参数设置，各参数之间使用&字符连接。

例如，同时设置ss5代理与压缩参数时，可写作：

Dial("wss://baidu.com/stream|proxy=socks5://xxx:9999&compress=gzip_raw&mode=recv")

Dial()函数仅支持实盘。

使用Dial函数连接数据库时，连接字符串的编写可参考各数据库的Go语言驱动项目。

| sqlite3 | github.com/mattn/go-sqlite3 | sqlite3://file:test.db?cache=shared&mode=memory
| sqlite3://前缀表示使用sqlite3数据库，调用示例：Dial("sqlite3://test1.db") |

| postgres | github.com/lib/pq | postgres://user=postgres dbname=yourdatabase sslmode=disable
password=yourpassword host=localhost port=5432 | -- |

目前仅JavaScript语言支持在Dial函数中使用mqtt、nats、amqp、kafka通信协议。以下以JavaScript语言的策略代码为例，展示mqtt、nats、amqp、kafka四种协议的使用示例：

            javascript
            
            
// 需要先配置并部署完成各个协议的代理服务器
// 为便于演示，主题test_topic的订阅（read操作）与发布（write操作）均在当前策略中进行

var arrConn = []
var arrName = []

function main() {
    LogReset(1)
    conn_nats = Dial("nats://admin@127.0.0.1:4222?topic=test_topic")
    conn_mqtt = Dial("mqtt://127.0.0.1:1883?topic=test_topic")
    conn_amqp = Dial("amqp://q:admin@127.0.0.1:5672/?queue=test_Queue")
    conn_kafka = Dial("kafka://localhost:9092/test_topic")
    arrConn = [conn_nats, conn_amqp, conn_mqtt, conn_kafka]
    arrName = ["nats", "amqp", "mqtt", "kafka"]

    while (true) {
        for (var i in arrConn) {
            var conn = arrConn[i]
            var name = arrName[i]

            // 写数据
            conn.write(name + ", time: " + _D() + ", test msg.")

            // 读数据
            var readMsg = conn.read(1000)
            Log(name + " readMsg: ", readMsg, "#FF0000")
        }

        Sleep(1000)
    }
}

function onexit() {
    for (var i in arrConn) {
        arrConn[i].close()
        Log("关闭", arrName[i], "连接")
    }
}

Dial函数在访问Websocket接口时，支持设置wss请求头：

            javascript
            
            

let options = {"headers": {"Authorization": "Bearer token123"}}

let conn = Dial("wss://api.example.com/ws", options)

            python
            
            

options = {"headers": {"Authorization": "Bearer token123"}}

conn = Dial("wss://api.example.com/ws", options)

            c++
            
            

// 暂不支持

HttpQuery

发送Http请求。

    
    
    
HttpQuery(url)

    
    
    
HttpQuery(url, options)

示例

HttpQuery函数使用代理设置的示例。

    javascript
    
    
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/")
}

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

    rust
    
    
fn main() {
    // 本次设置代理并发送http请求，无用户名，无密码，此次http请求会通过代理发送
    let ret1: String = HttpQuery("socks5://127.0.0.1:8889/http://www.baidu.com/", None);

    // 本次设置代理并发送http请求，输入用户名和密码，仅HttpQuery当前调用生效，之后再次调用HttpQuery("http://www.baidu.com")这样不会使用代理
    let ret2: String = HttpQuery("socks5://username:password@127.0.0.1:8889/http://www.baidu.com/", None);
}

    c++
    
    
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/");
}

返回值

参数

            json
            
            
{
    method: "POST",
    body: "a=10&b=20&c=30",
    charset: "UTF-8",
    cookie: "session_id=12345; lang=en",
    debug: false,
    headers: {"TEST-HTTP-QUERY": "123"},
    timeout: 1000
}

参考

备注

HttpQuery()函数仅支持JavaScript、C++语言；Python语言可以使用urllib库，直接发送Http请求。

回测系统中可以使用HttpQuery()发送请求（仅支持GET请求）以获取数据。

回测时限制访问20个不同的URL，并且HttpQuery()访问会缓存数据，

相同的URL第二次访问时，HttpQuery()函数将返回缓存数据，不再发起实际的网络请求。

HttpQuery_Go

发送HTTP请求，是HttpQuery函数的异步版本。

    
    
    
HttpQuery_Go(url)

    
    
    
HttpQuery_Go(url, options)

示例

HttpQuery_Go()函数使用示例：

    javascript
    
    
function main() {
    // 创建第一个异步线程
    var r1 = HttpQuery_Go("https://xxx.xxx.xxx")   // https://xxx.xxx.xxx 仅为演示地址，可以是某个数据源
    // 创建第二个异步线程
    var r2 = HttpQuery_Go("https://xxx.xxx.xxx")

    // 获取第一个异步线程调用的返回值
    var tickers1 = r1.wait()
    // 获取第二个异步线程调用的返回值
    var tickers2 = r2.wait()

    // 打印结果
    Log("tickers1:", tickers1)
    Log("tickers2:", tickers2)
}

    python
    
    
# 不支持

    c++
    
    
// 不支持

返回值

参数

            json
            
            
{
    method: "POST",
    body: "a=10&b=20&c=30",
    charset: "UTF-8",
    cookie: "session_id=12345; lang=en",
    debug: false,
    headers: {"TEST-HTTP-QUERY": "123"},
    timeout: 1000
}

参考

备注

HttpQuery_Go()函数仅支持JavaScript语言，Python语言可以使用urllib库直接发送HTTP请求。
HttpQuery_Go()主要用于访问交易所无需签名的接口，例如行情信息等公共接口。回测系统不支持HttpQuery_Go函数。

Encode

此函数根据传入的参数对数据进行编码。

    
    
    
Encode(algo, inputFormat, outputFormat, data)

    
    
    
Encode(algo, inputFormat, outputFormat, data, keyFormat, key)

示例

• Encode 函数调用示例。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log(Encode("raw", "raw", "hex", "example", "raw", "123"))            // 6578616d706c65
      Log(Encode("raw", "raw", "hex", "example"))                          // 6578616d706c65
      Log(Encode("sha256", "raw", "hex", "example", "raw", "123"))         // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "", "123"))            // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
      Log(Encode("sha256", "raw", "hex", "example", null, "123"))          // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
      Log(Encode("sha256", "raw", "hex", "example", "string", "123"))      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  
      Log(Encode("raw", "raw", "hex", "123"))           // 313233
      Log(Encode("raw", "raw", "base64", "123"))        // MTIz
  
      Log(Encode("sha256", "raw", "hex", "example", "hex", "313233"))      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz"))     // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  }
  

  
      python
      
      
  def main():
      Log(Encode("raw", "raw", "hex", "example", "raw", "123"))            # 6578616d706c65
      Log(Encode("raw", "raw", "hex", "example", "", ""))                  # 6578616d706c65
      Log(Encode("sha256", "raw", "hex", "example", "raw", "123"))         # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "", "123"))            # 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
  
      Log(Encode("sha256", "raw", "hex", "example", "string", "123"))      # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  
      Log(Encode("raw", "raw", "hex", "123", "", ""))           # 313233
      Log(Encode("raw", "raw", "base64", "123", "", ""))        # MTIz
  
      Log(Encode("sha256", "raw", "hex", "example", "hex", "313233"))      # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz"))     # 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  

  
      rust
      
      
  fn main() {
      Log!(Encode("raw", "raw", "hex", "example", "raw", "123"));            // 6578616d706c65
      Log!(Encode("raw", "raw", "hex", "example", "", ""));                  // 6578616d706c65
      Log!(Encode("sha256", "raw", "hex", "example", "raw", "123"));         // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log!(Encode("sha256", "raw", "hex", "example", "", "123"));            // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
  
      Log!(Encode("sha256", "raw", "hex", "example", "string", "123"));      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  
      Log!(Encode("raw", "raw", "hex", "123", "", ""));           // 313233
      Log!(Encode("raw", "raw", "base64", "123", "", ""));        // MTIz
  
      Log!(Encode("sha256", "raw", "hex", "example", "hex", "313233"));      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log!(Encode("sha256", "raw", "hex", "example", "base64", "MTIz"));     // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  }
  

  
      c++
      
      
  void main() {
      Log(Encode("raw", "raw", "hex", "example", "raw", "123"));            // 6578616d706c65
      Log(Encode("raw", "raw", "hex", "example"));                          // 6578616d706c65
      Log(Encode("sha256", "raw", "hex", "example", "raw", "123"));         // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "", "123"));            // 50d858e0985ecc7f60418aaf0cc5ab587f42c2570a884095a9e8ccacd0f6545c
  
      Log(Encode("sha256", "raw", "hex", "example", "string", "123"));      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  
      Log(Encode("raw", "raw", "hex", "123"));           // 313233
      Log(Encode("raw", "raw", "base64", "123"));        // MTIz
  
      Log(Encode("sha256", "raw", "hex", "example", "hex", "313233"));      // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
      Log(Encode("sha256", "raw", "hex", "example", "base64", "MTIz"));     // 698d54f0494528a759f19c8e87a9f99e75a5881b9267ee3926bcf62c992d84ba
  }
  

• 参数algo还支持以下编码器与解码器："text.encoder.utf8"、"text.decoder.utf8"、"text.encoder.gbk"、"text.decoder.gbk"，用于对字符串进行编码和解码。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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)
  }
  

  
      python
      
      
  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)
  

  
      rust
      
      
  fn main() {
      let ret1 = Encode("text.encoder.utf8", "raw", "hex", "你好", "", "");     // e4bda0e5a5bd
      Log!(ret1);
      let ret2 = Encode("text.decoder.utf8", "hex", "string", &ret1, "", "");
      Log!(ret2);
  
      let ret3 = Encode("text.encoder.gbk", "raw", "hex", "你好", "", "");      // c4e3bac3
      Log!(ret3);
      let ret4 = Encode("text.decoder.gbk", "hex", "string", &ret3, "", "");
      Log!(ret4);
  }
  

  
      c++
      
      
  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);
  }
  

返回值

参数

备注

Encode()函数仅支持实盘。若不传入key、keyFormat参数，则不使用key进行加密。

UnixNano

获取当前时刻的纳秒级时间戳。

    
    
    
UnixNano()

示例

如需获取毫秒级时间戳，可参考以下代码：

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

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

    rust
    
    
fn main() {
    let time = UnixNano() / 1000000;
    Log!(time);
}

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

返回值

参考

Unix

获取当前时刻的秒级时间戳。

    
    
    
Unix()

示例

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

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

    rust
    
    
fn main() {
    let t = Unix();
    Log!(t);
}

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

返回值

参考

GetOS

获取托管者所在设备的操作系统信息。

    
    
    
GetOS()

示例

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

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

    rust
    
    
fn main() {
    Log!("GetOS:", GetOS());
}

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

返回值

备注

例如，运行在 Mac OS 操作系统上的托管者，调用 GetOS() 函数可能返回：darwin/amd64。由于苹果电脑采用多种硬件架构，返回值中会一并包含具体的架构信息。其中 darwin 即 Mac OS 系统的名称。

MD5

计算参数data的MD5哈希值。

    
    
    
MD5(data)

示例

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

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

    rust
    
    
fn main() {
    Log!("MD5", MD5("hello world"));
}

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

返回值

参数

参考

备注

调用MD5("hello world")函数后，返回值为：5eb63bbbe01eeed093cb22bb8f5acdc3。

DBExec

数据库接口函数。

    
    
    
DBExec(sql)

示例

• 支持内存数据库。对于DBExec函数的参数，如果sql语句以:开头，则在内存数据库中执行操作，无需写入文件，速度更快。

  适用于无需持久化保存的数据库操作，例如：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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;"))
  }
  

  
      python
      
      
  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;"))
  

  
      rust
      
      
  fn main() {
      let 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)",
      ];
      let strSql = arr.join("");
      let ret = DBExec(&strSql);
      Log!(format!("{:?}", ret));
  
      // 增加一条数据
      Log!(format!("{:?}", DBExec(":INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);")));
  
      // 查询数据
      Log!(format!("{:?}", DBExec(":SELECT * FROM TEST_TABLE;")));
  }
  

  
      c++
      
      
  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;"));
  }
  

• 创建数据表。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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)
  }
  

  
      python
      
      
  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)
  

  
      rust
      
      
  fn main() {
      let 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)",
      ];
      let strSql = arr.join("");
      let ret = DBExec(&strSql);
      Log!(format!("{:?}", ret));
  }
  

  
      c++
      
      
  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);
  }
  

• 对数据表中记录进行增、删、改、查（增删改查）操作。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  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))
  }
  

  
      python
      
      
  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))
  

  
      rust
      
      
  fn main() {
      let 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)",
      ];
      let strSql = arr.join("");
      Log!(format!("{:?}", DBExec(&strSql)));
  
      // 增加一条数据
      Log!(format!("{:?}", DBExec("INSERT INTO TEST_TABLE (TS, HIGH, OPEN, LOW, CLOSE, VOLUME) VALUES (1518970320000, 100, 99.1, 90, 100, 12345.6);")));
  
      // 查询数据
      Log!(format!("{:?}", DBExec("SELECT * FROM TEST_TABLE;")));
  
      // 修改数据，Rust 的 DBExec() 函数只接受单个 SQL 语句字符串参数，不支持 ? 占位符传参，参数值需直接写入语句中
      Log!(format!("{:?}", DBExec("UPDATE TEST_TABLE SET HIGH=110 WHERE TS=1518970320000;")));
  
      // 删除数据
      Log!(format!("{:?}", DBExec("DELETE FROM TEST_TABLE WHERE HIGH=110;")));
  }
  

  
      c++
      
      
  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));
  }
  

返回值

参数

参考

备注

函数 DBExec() 通过传入参数操作实盘数据库（SQLite 数据库），可对实盘数据库中的数据执行增、删、查、改等操作，并支持 SQLite 语法。实盘数据库中的系统保留表包括 kvdb、cfg、log、profit、chart，请勿对这些表进行任何操作。目前不支持事务，不建议执行此类操作，否则会引发系统冲突。
DBExec() 函数仅支持实盘。

UUID

生成一个 UUID。

    
    
    
UUID()

示例

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

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

    rust
    
    
fn main() {
    let uuid1 = UUID();
    let uuid2 = UUID();
    Log!(uuid1, uuid2);
}

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

返回值

备注

UUID() 函数仅支持在实盘中使用。

EventLoop

监听事件，当有任意事件发生时返回。

    
    
    
EventLoop()

    
    
    
EventLoop(timeout)

示例

    javascript
    
    
function main(){
    while(true){
        // 需要在判断exchange.IO("status")函数返回true，即为真值时才可调用行情、交易等函数
        if(exchange.IO("status")){
            exchange.SetContractType("rb888")
            LogStatus(_D(), "已经连接CTP ！")
            var msg = EventLoop()
            Log(msg)
        } else {
            LogStatus(_D(), "未连接CTP ！")
        }
    }
}

    python
    
    
# 不支持EventLoop函数

    rust
    
    
fn main() {
    loop {
        // 需要在判断exchange.IO("status")函数返回true，即为真值时才可调用行情、交易等函数
        if exchange.IO("status").unwrap_or_default() == "true" {
            exchange.SetContractType("rb888").unwrap();
            LogStatus!(_D(None), "已经连接CTP ！");
            let msg = EventLoop(0);
            Log!(msg);
        } else {
            LogStatus!(_D(None), "未连接CTP ！");
        }
    }
}

    c++
    
    
// 不支持EventLoop函数

返回值

            json
            
            

{"Seq":10,"Event":"tick","ThreadId":0,"Index":0,"Nano":1689216222796834300,"Symbol":"rb2311","Ticker":
{...}}

参数

参考

备注

只有在代码中第一次调用EventLoop()函数时，才会初始化该事件监听机制。如果在事件回调发生之后才首次调用EventLoop()函数，则会错过此前发生的事件。底层系统封装的队列结构最多可缓存500个事件回调，如果程序运行过程中未及时调用EventLoop()函数取出，超出500个缓存容量的较晚事件回调将会丢失。EventLoop()函数的调用不会影响系统底层WebSocket的缓存队列。

对于这些缓存，仍需使用各自对应的方法取出数据。对于在EventLoop()函数返回之前已经取出的数据，不会在EventLoop()函数中产生返回事件。EventLoop()函数的主要用途是通知策略层：系统底层已接收到新的网络数据，从而以事件驱动整个策略。当EventLoop()函数返回事件时，只需遍历所有数据来源即可。EventLoop()函数仅支持实盘。

在主函数main()中调用时，监听主线程的事件。在使用JavaScript语言编写的策略中，对于由threading.Thread()函数创建的线程，也可以在其执行函数中调用该函数，以监听当前线程的事件。

__Serve

__Serve函数用于创建Http服务、TCP服务、Websocket服务（基于Http协议）。

    
    
    
__Serve(serveURI, handler)

    
    
    
__Serve(serveURI, handler, ...args)

示例

    javascript
    
    
function main() {
    let httpServer = __Serve("http://:8088?gzip=true", function (ctx) {
        Log("http connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
        let path = ctx.path()
        if (path == "/") {
            ctx.write(JSON.stringify({
                path: ctx.path(),
                method: ctx.method(),
                headers: ctx.headers(),
                cookie: ctx.header("Cookie"),
                remote: ctx.remoteAddr(),
                query: ctx.rawQuery()
            }))
        } else if (path == "/tickers") {
            let ret = exchange.GetTickers()
            if (!ret) {
                ctx.setStatus(500)
                ctx.write(GetLastError())
            } else {
                ctx.write(JSON.stringify(ret))
            }
        } else if (path == "/wss") {
            if (ctx.upgrade("websocket")) { // upgrade to websocket
                while (true) {
                    let r = ctx.read(10)
                    if (r == "") {
                        break
                    } else if (r) {
                        if (r == "ticker") {
                            ctx.write(JSON.stringify(exchange.GetTicker()))
                        } else {
                            ctx.write("not support")
                        }
                    }
                }
                Log("websocket closed", ctx.remoteAddr())
            }
        } else {
            ctx.setStatus(404)
        }
    })
    let echoServer = __Serve("tcp://:8089", function (ctx) {
        Log("tcp connect from: ", ctx.remoteAddr(), "->", ctx.localAddr())
        while (true) {
            let d = ctx.read()
            if (!d) {
                break
            }
            ctx.write(d)
        }
        Log("connect closed")
    })
    Log("http serve on", httpServer, "tcp serve on", echoServer)

    for (var i = 0; i < 5; i++) {
        if (i == 2) {
            // test Http
            var retHttp = HttpQuery("http://127.0.0.1:8088?num=123&limit=100", {"debug": true})
            Log("retHttp:", retHttp)
        } else if (i == 3) {
            // test TCP
            var tcpConn = Dial("tcp://127.0.0.1:8089")
            tcpConn.write("Hello TCP Server")
            var retTCP = tcpConn.read()
            Log("retTCP:", retTCP)
        } else if (i == 4) {
            // test Websocket
            var wsConn = Dial("ws://127.0.0.1:8088/wss|compress=gzip")
            wsConn.write("ticker")
            var retWS = wsConn.read(1000)
            Log("retWS:", retWS)
            // no depth
            wsConn.write("depth")
            retWS = wsConn.read(1000)
            Log("retWS:", retWS)
        }
        Sleep(1000)
    }
}

    python
    
    
# 不支持

    c++
    
    
// 不支持

返回值

参数

            javascript
            
            
__Serve("http://:8088", function(ctx, a, b, c) {
    Log(`ctx.host():`, ctx.host(), ", a=", a, ", b=", b, ", c=", c)
}, 1, 2, 3)

参考

备注

• 该函数仅支持JavaScript语言策略。

  • 服务线程与全局作用域隔离，因此不支持闭包或引用外部变量、自定义函数等；但是可以调用平台所有的API函数。

  • Websocket服务基于Http协议实现，可以在path中设置一个路由分支，设计Websocket消息订阅/推送的实现代码，可以参考本节范例代码。

参数handler传入的回调处理函数接收一个ctx参数。ctx参数为一个上下文对象，用于获取数据和写入数据，有以下方法：

• ctx.proto()
  适用于Http/TCP协议，调用时返回协议名称。例如：HTTP/1.1、tcp。
• ctx.host()
  适用于Http协议，调用时返回主机信息：IP地址、端口。
• ctx.path()
  适用于Http协议，调用时返回请求路径。
• ctx.query(key)
  适用于Http协议，调用时返回请求中query查询中key对应的值。例如发送的请求为：http://127.0.0.1:8088?num=123，参数handler传入的回调处理函数中ctx.query("num")调用时返回"123"。
• ctx.rawQuery()
  适用于Http协议，调用时返回请求中的原始查询（Http请求的query）。
  • ctx.headers()
    适用于Http协议，调用时返回请求中的请求头信息。
• ctx.header(key)
  适用于Http协议，调用时返回指定的请求头中的某个key对应的值。例如获取当前请求的headers中的User-Agent：ctx.header("User-Agent")。
• ctx.method()
  适用于Http协议，调用时返回请求方法，例如GET、POST等。
  • ctx.body()
    适用于Http协议的POST请求，调用时返回请求的正文。
• ctx.setHeader(key, value)
  适用于Http协议，设置应答报文的请求头信息。
  • ctx.setStatus(code)
    适用于Http协议，设置Http报文状态码，通常在路由分支最后设置Http状态码，默认为200。
• ctx.remoteAddr()
  适用于Http/TCP协议，调用时返回请求中的远程客户端地址、端口。
• ctx.localAddr()
  适用于Http/TCP协议，调用时返回服务本地地址、端口。
  • ctx.upgrade("websocket")
    适用于基于Http协议的Websocket协议实现，切换ctx上下文对象为Websocket协议；切换成功返回布尔值（真），失败返回布尔值（假）。
  • ctx.read(timeout_ms)
    适用于基于Http协议的Websocket协议实现/TCP协议，读取Websocket连接的数据，TCP连接的数据，普通Http协议中不支持使用该read方法；可以指定超时时间参数timeout_ms，单位毫秒。
  • ctx.write(s)
    适用于Http/TCP协议，用于写入字符串数据，可以使用JSON.stringify()编码JSON对象为字符串之后写入。对于WebSocket协议，可以使用该方法将编码后的字符串传递给客户端。

_G

该函数用于持久化保存数据，实现了一个可保存的全局字典功能。数据以键值对（KV）表的结构存储，并永久保存在托管者的本地数据库文件中。

    
    
    
_G()

    
    
    
_G(k)

    
    
    
_G(k, v)

示例

    javascript
    
    
// 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
function main(){
    // 设置一个全局变量num，值为1
    _G("num", 1)
    // 更改一个全局变量num，值为字符串ok
    _G("num", "ok")
    // 删除全局变量num
    _G("num", null)
    // 返回全局变量num的值
    Log(_G("num"))
    // 删除所有全局变量
    _G(null)
    // 返回实盘ID
    var robotId = _G()
}

    python
    
    
def main():
    _G("num", 1)
    _G("num", "ok")
    _G("num", None)
    Log(_G("num"))
    _G(None)
    robotId = _G()

    rust
    
    
fn main() {
    // 设置一个全局变量num，值为1
    _G!("num", 1);
    // 更改一个全局变量num，值为字符串ok
    _G!("num", "ok");
    // 删除全局变量num
    _G!("num", null);
    // 返回全局变量num的值
    Log!(_G!("num"));
    // Rust 不支持 _G!(null) 删除所有全局变量的形式
    // 返回实盘ID
    let robotId = _G!();
}

    c++
    
    
void main() {
    _G("num", 1);
    _G("num", "ok");
    _G("num", NULL);
    Log(_G("num"));
    _G(NULL);
    // 不支持 auto robotId = _G();
}

返回值

参数

参考

备注

每个实盘单独使用一个数据库。策略重启或托管者停止运行后，_G()函数保存的数据依然会保留。而回测结束后，_G()函数在回测系统中保存的数据将被清除。使用_G()函数持久化保存数据时，应根据硬件设备的内存和硬盘空间合理使用，切勿滥用。

在实盘运行中，当调用_G()函数且不传入任何参数时，_G()函数返回当前实盘的Id。

调用_G()函数时，若参数v传入空值，表示删除该k-v键值对。

调用_G()函数时，若仅传入字符串参数k，_G()函数返回参数k对应的已保存键值。

调用_G()函数时，若仅参数k传入空值，表示删除所有已记录的k-v键值对。

当k-v键值对已经持久化保存后，再次调用_G()函数，传入已持久化保存的键名作为参数k，并传入新的键值作为参数v，即可更新该k-v键值对。

以实盘Id为123456为例，使用_G()函数持久化保存的K-V键值数据存储在实盘（即策略实例程序）所属托管者目录下的/logs/storage/123456/123456.db3数据库文件中（123456.db3），数据记录在kvdb表中。

_D

将毫秒时间戳或Date对象转换为时间字符串。

    
    
    
_D()

    
    
    
_D(timestamp)

    
    
    
_D(timestamp, fmt)

示例

• 获取并打印当前时间字符串：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  function main(){
      var time = _D()
      Log(time)
  }
  

  
      python
      
      
  def main():
      strTime = _D()
      Log(strTime)
  

  
      rust
      
      
  fn main() {
      let strTime = _D(None);
      Log!(strTime);
  }
  

  
      c++
      
      
  void main() {
      auto strTime = _D();
      Log(strTime);
  }
  

• 时间戳为1574993606000，使用代码进行转换：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  function main() {
      Log(_D(1574993606000))
  }
  

  
      python
      
      
  def main():
      # 北京时间的服务器上运行：2019-11-29 10:13:26 ，另一台其它地区的服务器上的托管者运行此代码结果则为：2019-11-29 02:13:26
      Log(_D(1574993606))
  

  
      rust
      
      
  fn main() {
      Log!(_D(1574993606000));
  }
  

  
      c++
      
      
  void main() {
      Log(_D(1574993606000));
  }
  

• 使用参数fmt进行格式化，JavaScript、Python、C++语言的格式化字符串有所不同，具体请参看以下示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log(_D(1574993606000, "yyyy--MM--dd hh--mm--ss"))   // 2019--11--29 10--13--26
  }
  

  
      python
      
      
  def main():
      # 1574993606为秒级别时间戳
      Log(_D(1574993606, "%Y--%m--%d %H--%M--%S"))        #  2019--11--29 10--13--26
  

  
      rust
      
      
  fn main() {
      // Rust 的 _D() 函数不支持 fmt 参数，仅支持默认格式：yyyy-MM-dd hh:mm:ss
      Log!(_D(1574993606000));    // 2019-11-29 10:13:26
  }
  

  
      c++
      
      
  void main() {
      Log(_D(1574993606000, "%Y--%m--%d %H--%M--%S"));    // 2019--11--29 10--13--26
  }
  

返回值

参数

参考

备注

若不传入任何参数，则返回当前时间字符串。在Python策略中使用_D()函数时，需要注意传入的参数为秒级别时间戳（在JavaScript、C++策略中为毫秒级别时间戳，1秒等于1000毫秒）。

在实盘中使用_D()函数将时间戳解析为可读的时间字符串时，需要注意托管者程序所在操作系统的时区与时间设置。_D()函数将时间戳解析为可读时间字符串时，是依据托管者系统的时间而定的。

_N

格式化浮点数。

    
    
    
_N()

    
    
    
_N(num)

    
    
    
_N(num, precision)

示例

• 例如_N(3.1415, 2)会舍弃3.1415小数点后第二位以后的数值，函数返回3.14。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  function main() {
      var i = 3.1415
      Log(i)
      var ii = _N(i, 2)
      Log(ii)
  }
  

  
      python
      
      
  def main():
      i = 3.1415
      Log(i)
      ii = _N(i, 2)
      Log(ii)
  

  
      rust
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  fn main() {
      let i = 3.1415;
      Log!(i);
      let ii = _N(i, 2);
      Log!(ii);
  }
  

  
      c++
      
      
  void main() {
      auto i = 3.1415;
      Log(i);
      auto ii = _N(i, 2);
      Log(ii);
  }
  

• 如果需要将小数点左边的N位数字都置为0，可以这样写：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  function main() {
      var i = 1300
      Log(i)
      var ii = _N(i, -3)
      // 查看日志得知为1000
      Log(ii)
  }
  

  
      python
      
      
  def main():
      i = 1300
      Log(i)
      ii = _N(i, -3)
      Log(ii)
  

  
      rust
      
      
  // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
  fn main() {
      let i = 1300;
      Log!(i);
      let ii = _N(i, -3);
      // 查看日志得知为1000
      Log!(ii);
  }
  

  
      c++
      
      
  void main() {
      auto i = 1300;
      Log(i);
      auto ii = _N(i, -3);
      Log(ii);
  }
  

返回值

参数

参考

备注

参数precision可以为正整数，也可以为负整数。

_C

容错重试函数，用于对接口调用进行容错处理。

    
    
    
_C(pfn)

    
    
    
_C(pfn, ...args)

示例

• 针对无参数函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888")
  
      var ticker = _C(exchange.GetTicker)
      // 将_C()函数的重试时间间隔调整为2秒
      _CDelay(2000)
      var depth = _C(exchange.GetDepth)
      Log(ticker)
      Log(depth)
  }
  

  
      python
      
      
  def main():
      while not exchange.IO("status"):
          Sleep(1000)
  
      exchange.SetContractType("rb888")
  
      ticker = _C(exchange.GetTicker)
      _CDelay(2000)
      depth = _C(exchange.GetDepth)
      Log(ticker)
      Log(depth)
  

  
      rust
      
      
  fn main() {
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888").unwrap();
  
      let ticker = _C!(exchange.GetTicker(None));
      // 将_C!()宏的重试时间间隔调整为2秒
      _CDelay(2000);
      let depth = _C!(exchange.GetDepth(None));
      Log!(ticker);
      Log!(depth);
  }
  

  
      c++
      
      
  void main() {
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888");
  
      auto ticker = _C(exchange.GetTicker);
      _CDelay(2000);
      auto depth = _C(exchange.GetDepth);
      Log(ticker);
      Log(depth);
  }
  

• 针对有参数函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888")
  
      var records = _C(exchange.GetRecords, PERIOD_D1)
      Log(records)
  }
  

  
      python
      
      
  def main():
      while not exchange.IO("status"):
          Sleep(1000)
  
      exchange.SetContractType("rb888")
  
      records = _C(exchange.GetRecords, PERIOD_D1)
      Log(records)
  

  
      rust
      
      
  fn main() {
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888").unwrap();
  
      let records = _C!(exchange.GetRecords(None, PERIOD_D1, None));
      Log!(records);
  }
  

  
      c++
      
      
  void main() {
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888");
  
      auto records = _C(exchange.GetRecords, PERIOD_D1);
      Log(records);
  }
  

• 也可用于自定义函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var test = function(a, b){
      var time = new Date().getTime() / 1000
      if(time % b == 3){
          Log("符合条件！", "#FF0000")
          return true
      }
      Log("重试！", "#FF0000")
      return false
  }
  
  function main(){
      // 此测试不通过接口获取数据，因此无需调用 exchange.IO("status") 函数判断连接状态，也无需设置合约代码，因为这里仅用于测试自定义函数
      var ret = _C(test, 1, 5)
      Log(ret)
  }
  

  
      python
      
      
  import time
  def test(a, b):
      ts = time.time()
      if ts % b == 3:
          Log("符合条件！", "#FF0000")
          return True
      Log("重试！", "#FF0000")
      return False
  
  def main():
      ret = _C(test, 1, 5)
      Log(ret)
  

  
      rust
      
      
  fn test(a: i64, b: i64) -> Result<bool> {
      let time = Unix();
      if time % b == 3 {
          Log!("符合条件！", "#FF0000");
          return Ok(true);
      }
      Log!("重试！", "#FF0000");
      Err(Error::Api("retry".to_string()))
  }
  
  fn main() {
      // 此测试不通过接口获取数据，因此无需调用 exchange.IO("status") 函数判断连接状态，也无需设置合约代码，因为这里仅用于测试自定义函数
      // 在 Rust 中，自定义函数返回 Result 类型即可使用 _C! 宏进行容错，返回 Err 时会自动重试
      let ret = _C!(test(1, 5));
      Log!(ret);
  }
  

  
      c++
      
      
  // C++ 不支持以这种方式对自定义函数进行容错处理

返回值

参数

备注

_C()函数会反复调用指定的函数，直到其成功返回为止（当参数pfn所引用的函数返回空值或假值时，_C()会重试调用pfn）。

例如_C(exchange.GetTicker)。默认的重试间隔为3秒，可以调用_CDelay()函数来设置重试间隔。

例如_CDelay(1000)，表示将_C()函数的重试间隔改为1秒。

可以对以下函数进行容错处理，但不限于此：

• exchange.GetTicker()

• exchange.GetDepth()

• exchange.GetTrades()

• exchange.GetRecords()

• exchange.GetAccount()

• exchange.GetOrders()

• exchange.GetOrder()

• exchange.GetPositions()

以上函数均可通过_C()函数调用来实现容错。_C()函数的容错能力并不局限于上述列出的函数。参数pfn为函数引用而非函数调用，请注意应写作_C(exchange.GetTicker)，而不是_C(exchange.GetTicker())。

_Cross

返回数组arr1与数组arr2的交叉周期数。

    
    
    
_Cross(arr1, arr2)

示例

可以模拟一组数据来测试_Cross(Arr1, Arr2)函数：

    javascript
    
    
// 快线指标
var arr1 = [1,2,3,4,5,6,8,8,9]

// 慢线指标
var arr2 = [2,3,4,5,6,7,7,7,7]

// 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
function main(){
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))
}

    python
    
    
arr1 = [1,2,3,4,5,6,8,8,9]
arr2 = [2,3,4,5,6,7,7,7,7]
def main():
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2))
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1))

    rust
    
    
fn main() {
    // 快线指标
    let arr1 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 8.0, 9.0];

    // 慢线指标
    let arr2 = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 7.0, 7.0, 7.0];

    Log!("_Cross(arr1, arr2) : ", _Cross(&arr1, &arr2));
    Log!("_Cross(arr2, arr1) : ", _Cross(&arr2, &arr1));
}

    c++
    
    
void main() {
    vector<double> arr1 = {1,2,3,4,5,6,8,8,9};
    vector<double> arr2 = {2,3,4,5,6,7,7,7,7};
    Log("_Cross(arr1, arr2) : ", _Cross(arr1, arr2));
    Log("_Cross(arr2, arr1) : ", _Cross(arr2, arr1));
}

返回值

参数

备注

_Cross()函数的返回值为正数时表示上穿的周期数，为负数时表示下穿的周期数，为0时表示当前价格相等。详细使用说明请参阅：内置函数_Cross分析及使用说明。

JSON.parse

JSON.parse 函数是 ECMAScript 标准内建对象 JSON 的方法，用于解码（解析）JSON 字符串。优宽量化交易平台为其扩展了一个 safeStr 参数。

    
    
    
JSON.parse(s)

    
    
    
JSON.parse(s, safeStr)

示例

解码（解析）一个包含大数值的 JSON 字符串。

    javascript
    
    
function main() {
    let s1 = '{"num": 8754613216564987646512354656874651651358}'
    Log("JSON.parse:", JSON.parse(s1))          // JSON.parse: {"num":8.754613216564987e+39}
    Log("JSON.parse:", JSON.parse(s1, true))    // JSON.parse: {"num":"8754613216564987646512354656874651651358"}

    let s2 = '{"num": 123}'
    Log("JSON.parse:", JSON.parse(s2))          // JSON.parse: {"num":123}
    Log("JSON.parse:", JSON.parse(s2, true))    // JSON.parse: {"num":123}
}

    python
    
    
# 可以使用 Python 的第三方库处理大数值数据。

    rust
    
    
fn main() {
    let s1 = r#"{"num": 8754613216564987646512354656874651651358}"#;
    Log!("JSONParse:", JSONParse(s1).unwrap());    // JSONParse: {"num":8.754613216564987e+39}
    // Rust 的 JSONParse() 函数不支持 safeStr 参数，大数值可使用第三方库处理

    let s2 = r#"{"num": 123}"#;
    Log!("JSONParse:", JSONParse(s2).unwrap());    // JSONParse: {"num":123}
}

    c++
    
    
// 可以使用其它方案处理。

返回值

参数

备注

JSON.parse() 函数可以正确解析包含较大数值的 JSON 字符串；当 safeStr 参数设置为真值时，会将较大的数值解析为字符串类型。

safeStr 参数位也支持作为 reviver 参数使用，即一个用于转换解析结果的函数，该函数会为对象的每个成员被调用。具体用法可查阅相关资料，此处不再赘述。

仅支持 JavaScript 语言。

回测系统中不支持 JSON.parse() 函数的 safeStr 参数功能。

JSON.stringify

JSON.stringify函数是ECMAScript标准内置对象JSON的方法，用于将JavaScript值编码为JSON字符串。

    
    
    
JSON.stringify(obj)

示例

编码一个对象，输出编码后的JSON字符串。

    javascript
    
    
function main() {
    let s1 = {"num": "8754613216564987646512354656874651651358"}
    Log("JSON.stringify:", JSON.stringify(s1))

    // JSON.stringify: {"num":"8754613216564987646512354656874651651358"}
    // JSON.stringify(s1) 返回的变量为一个字符串类型
}

    python
    
    
// 略

    c++
    
    
// 略

返回值

参数

备注

仅支持JavaScript语言。

SetChannelData

在频道上发布最新的状态数据。该函数用于实盘之间的通信，可将当前实盘的状态数据广播到频道上，供其他实盘订阅获取。

    
    
    
SetChannelData(data)

示例

• 频道广播端示例 - 发布市场行情数据

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var updateId = 0
      var robotId = _G()  // 获取当前实盘ID
  
      while(true) {
          if (!exchange.IO("status")) {
              Sleep(1000)
              continue
          }
  
          // 获取实时市场价格
          var ticker = exchange.GetTicker("rb888")
          if (!ticker) {
              Sleep(5000)
              continue
          }
  
          // 构建当前频道状态数据
          var channelState = {
              robotId: robotId,
              updateId: ++updateId,
              timestamp: Date.now(),
              symbol: "rb888",
              lastPrice: ticker.Last,
              volume: ticker.Volume,
              high: ticker.High,
              low: ticker.Low
          }
  
          // 向频道发布最新状态（覆盖旧状态）
          SetChannelData(channelState)
  
          // 显示当前频道状态
          LogStatus("频道广播端 [实盘ID: " + robotId + "]\n" +
                    "更新ID: #" + channelState.updateId + "\n" +
                    "时间: " + _D(channelState.timestamp) + "\n" +
                    "交易对: " + channelState.symbol + "\n" +
                    "最新价: $" + channelState.lastPrice.toFixed(2) + "\n" +
                    "成交量: " + channelState.volume.toFixed(4) + "\n" +
                    "最高价: $" + channelState.high.toFixed(2) + "\n" +
                    "最低价: $" + channelState.low.toFixed(2))
  
          Sleep(60000)  // 每分钟更新一次频道状态
      }
  }
  

  
      python
      
      
  def main():
      updateId = 0
      robotId = _G()  # 获取当前实盘ID
  
      while True:
          if not exchange.IO("status"):
              Sleep(1000)
              continue
  
          # 获取实时市场价格
          ticker = exchange.GetTicker("rb888")
          if not ticker:
              Sleep(5000)
              continue
  
          # 构建当前频道状态数据
          channelState = {
              "robotId": robotId,
              "updateId": updateId + 1,
              "timestamp": time.time() * 1000,
              "symbol": "rb888",
              "lastPrice": ticker["Last"],
              "volume": ticker["Volume"],
              "high": ticker["High"],
              "low": ticker["Low"]
          }
          updateId += 1
  
          # 向频道发布最新状态（覆盖旧状态）
          SetChannelData(channelState)
  
          # 显示当前频道状态
          LogStatus("频道广播端 [实盘ID: {}]\n".format(robotId) +
                    "更新ID: #{}\n".format(channelState["updateId"]) +
                    "时间: {}\n".format(_D(channelState["timestamp"])) +
                    "交易对: {}\n".format(channelState["symbol"]) +
                    "最新价: ${:.2f}\n".format(channelState["lastPrice"]) +
                    "成交量: {:.4f}\n".format(channelState["volume"]) +
                    "最高价: ${:.2f}\n".format(channelState["high"]) +
                    "最低价: ${:.2f}".format(channelState["low"]))
  
          Sleep(60000)  # 每分钟更新一次频道状态
  

  
      rust
      
      
  fn main() {
      let mut updateId = 0;
      let robotId = _G!();  // 获取当前实盘ID
  
      loop {
          if exchange.IO("status").unwrap_or_default() != "true" {
              Sleep(1000);
              continue;
          }
  
          // 获取实时市场价格
          let ticker = match exchange.GetTicker("rb888") {
              Ok(t) => t,
              Err(_) => {
                  Sleep(5000);
                  continue;
              }
          };
  
          // 构建当前频道状态数据
          updateId += 1;
          let timestamp = Unix() * 1000;
          let channelState = format!(
              r#"{{"robotId": {}, "updateId": {}, "timestamp": {}, "symbol": "rb888", "lastPrice": {}, "volume": {}, "high": {}, "low": {}}}"#,
              robotId, updateId, timestamp, ticker.Last, ticker.Volume, ticker.High, ticker.Low
          );
  
          // 向频道发布最新状态（覆盖旧状态）
          SetChannelData(&channelState);
  
          // 显示当前频道状态
          LogStatus!(format!(
              "频道广播端 [实盘ID: {}]\n更新ID: #{}\n时间: {}\n交易对: rb888\n最新价: ${:.2}\n成交量: {:.4}\n最高价: ${:.2}\n最低价: ${:.2}",
              robotId, updateId, _D(timestamp), ticker.Last, ticker.Volume, ticker.High, ticker.Low
          ));
  
          Sleep(60000);  // 每分钟更新一次频道状态
      }
  }
  

  
      c++
      
      
  

• 跨平台发送示例 - 模拟外部平台（如 TradingView）向优宽量化实盘发送数据

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  // 本示例演示如何使用 HttpQuery 发送 HTTP POST 请求，模拟外部平台向优宽量化实盘发送数据
  // 在实际场景中，外部平台（如 TradingView 的 Webhook 告警 URL、第三方交易系统等）会直接调用优宽量化 API 端点
  
  function main() {
      let uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
      let robotId = 123456  // 目标实盘 ID（即需要接收数据的实盘）
      let baseUrl = "https://www.youquant.com"
  
      while (true) {
          // 准备要发送的数据（可以是 JSON、文本或其他格式）
          let sendData = {
              "action": "buy",
              "symbol": "rb888",
              "price": 3500,
              "timestamp": Date.now()
          }
  
          // 构造 HTTP POST 请求
          let options = {
              method: "POST",
              body: JSON.stringify(sendData)  // body 可以是 JSON 字符串、普通文本等
          }
          let url = `${baseUrl}/api/v1?method=pub&robot=${robotId}&channel=${uuid}`
  
          // 发送数据
          let ret = HttpQuery(url, options)
          Log("Simulated external platform sending data, result:", ret)
  
          Sleep(10000)  // 每 10 秒发送一次
      }
  }
  

  
      python
      
      
  # 本示例演示如何使用 HttpQuery 发送 HTTP POST 请求，模拟外部平台向优宽量化实盘发送数据
  # 在实际场景中，外部平台（如 TradingView 的 Webhook 告警 URL、第三方交易系统等）会直接调用优宽量化 API 端点
  
  import json
  
  def main():
      uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
      robotId = 123456  # 目标实盘 ID（即需要接收数据的实盘）
      baseUrl = "https://www.youquant.com"
  
      while True:
          # 准备要发送的数据（可以是 JSON、文本或其他格式）
          sendData = {
              "action": "buy",
              "symbol": "rb888",
              "price": 3500,
              "timestamp": time.time() * 1000
          }
  
          # 构造 HTTP POST 请求
          options = {
              "method": "POST",
              "body": json.dumps(sendData)  # body 可以是 JSON 字符串、普通文本等
          }
          url = "{}/api/v1?method=pub&robot={}&channel={}".format(baseUrl, robotId, uuid)
  
          # 发送数据
          ret = HttpQuery(url, options)
          Log("Simulated external platform sending data, result:", ret)
  
          Sleep(10000)  # 每 10 秒发送一次
  

  
      rust
      
      
  // 本示例演示如何使用 HttpQuery 发送 HTTP POST 请求，模拟外部平台向优宽量化实盘发送数据
  // 在实际场景中，外部平台（如 TradingView 的 Webhook 告警 URL、第三方交易系统等）会直接调用优宽量化 API 端点
  
  fn main() {
      let uuid = "6BC42A119B5DBFA2188A8279DA3B5C30";
      let robotId = 123456;  // 目标实盘 ID（即需要接收数据的实盘）
      let baseUrl = "https://www.youquant.com";
  
      loop {
          // 准备要发送的数据（可以是 JSON、文本或其他格式）
          let sendData = format!(
              r#"{{"action": "buy", "symbol": "rb888", "price": 3500, "timestamp": {}}}"#,
              Unix() * 1000
          );
  
          // 构造 HTTP POST 请求
          let options = format!(r#"{{"method": "POST", "body": {:?}}}"#, sendData);
          let url = format!("{}/api/v1?method=pub&robot={}&channel={}", baseUrl, robotId, uuid);
  
          // 发送数据
          let ret: String = HttpQuery(&url, options.as_str());
          Log!("Simulated external platform sending data, result:", ret);
  
          Sleep(10000);  // 每 10 秒发送一次
      }
  }
  

  
      c++
      
      
  

返回值

参数

参考

备注

SetChannelData()函数为非阻塞调用，调用后立即返回，不会等待数据传输完成。

每个实盘都拥有一个独立的频道，频道ID即为实盘ID（可通过_G()函数获取）。

频道上仅保存最新的状态数据，每次调用SetChannelData()都会覆盖之前发布的数据，而非追加历史消息。

频道数据可跨实盘、跨托管者、跨服务器进行广播，多个实盘可订阅同一个频道。

订阅端使用GetChannelData()函数订阅频道数据。

频道通信适用于实盘环境，在回测系统中该功能可能受限。

传入的数据参数data经JSON序列化后的字节长度不得超过1024字节，超出该限制可能导致数据发布失败。建议仅传输必要的状态信息，避免传输过大的数据对象。

发布数据时应根据硬件设备的内存及网络带宽合理使用，避免发布过大的数据对象。

SetChannelData()函数发布的数据除可被优宽量化平台内的其它实盘订阅外，还支持跨平台数据发送功能。外部平台（如TradingView的Webhook告警、第三方交易系统、监控软件等）可通过HTTP POST请求向指定的优宽量化实盘发送数据。

跨平台发送数据的方式： 外部系统通过HTTP POST请求将数据发送到优宽量化平台API端点：https://www.youquant.com/api/v1?method=pub&robot={robotId}&channel={uuid}，其中robotId为目标实盘ID，uuid为32位字符的频道标识符。发送的数据在请求body中传递，可以是JSON格式、文本或其它格式。注意：必须先有实盘订阅该UUID频道，外部系统才能成功发送数据；广播的数据会发送至robotId实盘所在托管者下的所有实盘，同一托管者下订阅了该UUID频道的实盘均可接收数据。

GetChannelData

订阅指定实盘的频道数据。该函数用于实盘间通信，可获取其他实盘通过SetChannelData()函数发布的最新状态数据。

    
    
    
GetChannelData(channelId)

示例

• 频道订阅端示例 - 订阅两个实盘的频道数据

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 需要订阅的两个频道ID（请根据实际情况修改）
      var channelId1 = "632799"  // 频道1的实盘ID
      var channelId2 = "632800"  // 频道2的实盘ID
  
      while(true) {
          // 读取频道1的当前状态
          var state1 = GetChannelData(channelId1)
  
          // 读取频道2的当前状态
          var state2 = GetChannelData(channelId2)
  
          // 构建状态显示内容
          var statusMsg = "频道订阅端 - 当前订阅状态\n\n"
  
          // 显示频道1状态
          statusMsg += "═══ 频道1 [" + channelId1 + "] ═══\n"
          if (state1 !== null) {
              statusMsg += "更新ID: #" + state1.updateId + "\n"
              statusMsg += "时间: " + _D(state1.timestamp) + "\n"
              statusMsg += "交易对: " + state1.symbol + "\n"
              statusMsg += "最新价: $" + state1.lastPrice.toFixed(2) + "\n"
              statusMsg += "成交量: " + state1.volume.toFixed(4) + "\n"
          } else {
              statusMsg += "状态: 等待中... (首次调用返回 null)\n"
          }
  
          statusMsg += "\n"
  
          // 显示频道2状态
          statusMsg += "═══ 频道2 [" + channelId2 + "] ═══\n"
          if (state2 !== null) {
              statusMsg += "更新ID: #" + state2.updateId + "\n"
              statusMsg += "时间: " + _D(state2.timestamp) + "\n"
              statusMsg += "交易对: " + state2.symbol + "\n"
              statusMsg += "最新价: $" + state2.lastPrice.toFixed(2) + "\n"
              statusMsg += "成交量: " + state2.volume.toFixed(4) + "\n"
          } else {
              statusMsg += "状态: 等待中... (首次调用返回 null)\n"
          }
  
          LogStatus(statusMsg)
  
          Sleep(5000)  // 每5秒读取一次频道数据
      }
  }
  

  
      python
      
      
  def main():
      # 需要订阅的两个频道ID（请根据实际情况修改）
      channelId1 = "632799"  # 频道1的实盘ID
      channelId2 = "632800"  # 频道2的实盘ID
  
      while True:
          # 读取频道1的当前状态
          state1 = GetChannelData(channelId1)
  
          # 读取频道2的当前状态
          state2 = GetChannelData(channelId2)
  
          # 构建状态显示内容
          statusMsg = "频道订阅端 - 当前订阅状态\n\n"
  
          # 显示频道1状态
          statusMsg += "═══ 频道1 [{}] ═══\n".format(channelId1)
          if state1 is not None:
              statusMsg += "更新ID: #{}\n".format(state1["updateId"])
              statusMsg += "时间: {}\n".format(_D(state1["timestamp"]))
              statusMsg += "交易对: {}\n".format(state1["symbol"])
              statusMsg += "最新价: ${:.2f}\n".format(state1["lastPrice"])
              statusMsg += "成交量: {:.4f}\n".format(state1["volume"])
          else:
              statusMsg += "状态: 等待中... (首次调用返回 None)\n"
  
          statusMsg += "\n"
  
          # 显示频道2状态
          statusMsg += "═══ 频道2 [{}] ═══\n".format(channelId2)
          if state2 is not None:
              statusMsg += "更新ID: #{}\n".format(state2["updateId"])
              statusMsg += "时间: {}\n".format(_D(state2["timestamp"]))
              statusMsg += "交易对: {}\n".format(state2["symbol"])
              statusMsg += "最新价: ${:.2f}\n".format(state2["lastPrice"])
              statusMsg += "成交量: {:.4f}\n".format(state2["volume"])
          else:
              statusMsg += "状态: 等待中... (首次调用返回 None)\n"
  
          LogStatus(statusMsg)
  
          Sleep(5000)  # 每5秒读取一次频道数据
  

  
      rust
      
      
  fn main() {
      // Rust 的 GetChannelData() 函数不接受频道 ID 参数，只能读取当前实盘自身频道
      // （即本实盘通过 SetChannelData() 发布）的最新数据，无法订阅其它实盘或 UUID 频道
      loop {
          // 读取频道的当前状态
          let state = GetChannelData();
  
          // 构建状态显示内容
          let mut statusMsg = String::from("频道订阅端 - 当前订阅状态\n\n");
  
          if !state.is_null() {
              statusMsg += &format!("更新ID: #{}\n", state["updateId"].as_i64().unwrap_or(0));
              statusMsg += &format!("时间: {}\n", _D(state["timestamp"].as_i64().unwrap_or(0)));
              statusMsg += &format!("交易对: {}\n", state["symbol"].as_str().unwrap_or(""));
              statusMsg += &format!("最新价: ${:.2}\n", state["lastPrice"].as_f64().unwrap_or(0.0));
              statusMsg += &format!("成交量: {:.4}\n", state["volume"].as_f64().unwrap_or(0.0));
          } else {
              statusMsg += "状态: 等待中... (首次调用返回 null)\n";
          }
  
          LogStatus!(statusMsg);
  
          Sleep(5000);  // 每5秒读取一次频道数据
      }
  }
  

  
      c++
      
      
  

• 跨平台订阅示例 —— 使用 UUID 订阅外部系统发送的数据

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 使用 32 位 UUID 作为频道标识符
      let uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
  
      while (true) {
          // 订阅该 UUID 频道的数据
          let data = GetChannelData(uuid)
  
          if (data !== null) {
              Log("Received cross-platform data:", data)
          } else {
              Log("Waiting for data... (first call returns null)")
          }
  
          Sleep(10000)  // 每 10 秒检查一次
      }
  }
  

  
      python
      
      
  def main():
      # 使用 32 位 UUID 作为频道标识符
      uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
  
      while True:
          # 订阅该 UUID 频道的数据
          data = GetChannelData(uuid)
  
          if data is not None:
              Log("Received cross-platform data:", data)
          else:
              Log("Waiting for data... (first call returns None)")
  
          Sleep(10000)  # 每 10 秒检查一次
  

  
      rust
      
      
  fn main() {
      // Rust 的 GetChannelData() 函数不接受频道 ID 参数，只能读取当前实盘自身频道
      // （即本实盘通过 SetChannelData() 发布）的最新数据，无法订阅其它实盘或 UUID 频道
      loop {
          // 订阅当前频道的数据
          let data = GetChannelData();
  
          if !data.is_null() {
              Log!("Received cross-platform data:", data);
          } else {
              Log!("Waiting for data... (first call returns null)");
          }
  
          Sleep(10000);  // 每 10 秒检查一次
      }
  }
  

  
      c++
      
      
  

返回值

参数

参考

备注

GetChannelData()函数为非阻塞调用，调用后立即返回，不会等待数据接收完成。

首次调用GetChannelData()函数时会返回null，需重试以等待频道数据同步完成。

每次调用获取的均为频道上的最新状态数据，而非历史消息队列。

一个实盘可同时订阅多个不同实盘的频道，只需多次调用GetChannelData()并传入不同的实盘ID即可。

当前实盘也可订阅自身的频道，即robotId参数可为当前实盘ID。

频道数据可跨实盘、跨托管者、跨服务器进行传输。

广播端使用SetChannelData()函数发布频道数据。

频道通信适用于实盘环境，在回测系统中该功能可能受限。

GetChannelData()函数支持跨平台订阅功能。当使用32位UUID作为频道标识符时，可接收来自优宽量化平台外部系统通过HTTP API发送的数据。外部系统需同时指定实盘ID和UUID才能发送数据；同一托管者下的所有实盘均可订阅该UUID频道的数据，而不同托管者的实盘则无法订阅。

Log

输出日志信息。

    
    
    
Log(...msgs)

示例

• 可以传入多个msg参数：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log("msg1", "msg2", "msg3")
  }
  

  
      python
      
      
  def main():
      Log("msg1", "msg2", "msg3")
  

  
      rust
      
      
  fn main() {
      Log!("msg1", "msg2", "msg3");
  }
  

  
      c++
      
      
  void main() {
      Log("msg1", "msg2", "msg3");
  }
  

• 支持设置输出消息的颜色。如果需要同时设置颜色与推送，需先设置颜色，最后使用@字符启用推送。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log("优宽量化你好 !@")
      Sleep(1000 * 5)
      // 字符串内加入#ff0000，打印日志显示为红色，并且推送消息
      Log("你好, #ff0000@")
  }
  

  
      python
      
      
  def main():
      Log("优宽量化你好 !@")
      Sleep(1000 * 5)
      Log("你好, #ff0000@")
  

  
      rust
      
      
  fn main() {
      Log!("优宽量化你好 !@");
      Sleep(1000 * 5);
      // 字符串内加入#ff0000，打印日志显示为红色，并且推送消息
      Log!("你好, #ff0000@");
  }
  

  
      c++
      
      
  void main() {
      Log("优宽量化你好 !@");
      Sleep(1000 * 5);
      Log("你好, #ff0000@");
  }
  

• Log()函数支持打印经base64编码的图片，以`开头、以`结尾，例如：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log("`data:image/png;base64,AAAA`")
  }
  

  
      python
      
      
  def main():
      Log("`data:image/png;base64,AAAA`")
  

  
      rust
      
      
  fn main() {
      Log!("`data:image/png;base64,AAAA`");
  }
  

  
      c++
      
      
  void main() {
      Log("`data:image/png;base64,AAAA`");
  }
  

• Log()函数支持直接打印Python的matplotlib.pyplot对象。只要对象包含savefig方法，即可直接使用Log函数打印，例如：

  
      python
      
      
  import matplotlib.pyplot as plt
  def main():
      plt.plot([3,6,2,4,7,1])
      Log(plt)
  

• Log()函数支持语言切换。Log()函数输出的文本会根据平台页面的语言设置自动切换为对应的语言，例如：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log("[trans]中文|abc[/trans]")
  }
  

  
      python
      
      
  def main():
      Log("[trans]中文|abc[/trans]")
  

  
      rust
      
      
  fn main() {
      Log!("[trans]中文|abc[/trans]");
  }
  

  
      c++
      
      
  void main() {
      Log("[trans]中文|abc[/trans]");
  }
  

参数

参考

备注

Log()函数在实盘或回测系统的日志区域输出一条日志信息，实盘运行时该日志会保存至实盘数据库中。

若Log()函数输出的内容以@字符结尾，则该条日志会进入消息推送队列。

消息将推送到当前优宽量化交易平台账号推送设置中配置的邮箱、WebHook地址等。调试工具与回测系统不支持消息推送。消息推送存在频率限制，具体规则如下：在一个实盘的20秒周期内，仅保留并推送最后一条推送消息，其余消息将被过滤而不予推送（通过 Log 函数输出的推送日志仍会正常打印显示在日志区域）。

若Log()函数输出的内容以&字符结尾，则该条日志将被标记为私密日志。当实盘公开展示时，该条日志对其他用户隐藏，但在实盘拥有者账户视角下不隐藏。可用于记录API密钥、账户余额等敏感信息。例如：Log("私密信息", "&")。

关于WebHook推送，可以使用Golang编写服务程序：

            golang
            
            
package main

import (
    "fmt"
    "net/http"
)

func Handle (w http.ResponseWriter, r *http.Request) {
    defer func() {
        fmt.Println("req:", *r)
    }()
}

func main () {
    fmt.Println("listen http://localhost:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe(":9090", nil)
}

在推送设置中设置WebHook地址：http://XXX.XX.XXX.XX:9090/data?data=Hello_youquant。运行编写好的Golang服务程序后，启动策略进行实盘运行。以下为使用JavaScript语言编写的策略，策略运行时会执行Log()函数并推送消息：

            javascript
            
            
function main() {
    Log("msg", "@")
}

Golang语言编写的服务程序接收到推送后，打印如下信息：

            text
            
            
listen http://localhost:9090

req: {GET /data?data=Hello_youquant HTTP/1.1 1 1
map[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/xx.x.xxxx.xxx
Safari/537.36] Accept-Encoding:[gzip]] {} <nil> 0 [] false
1XX.XX.X.XX:9090 map[] map[] <nil> map[] XXX.XX.XXX.XX:4xxx2
/data?data=Hello_youquant <nil> <nil> <nil> 0xc420056300

LogProfit

记录并打印盈亏数值，并根据盈亏数值绘制收益曲线。

    
    
    
LogProfit(profit)

    
    
    
LogProfit(profit, ...args)

示例

LogProfit函数的参数如果以字符&结尾，则不将日志写入数据库，仅更新收益图表。使用&参数可以避免频繁的收益记录产生大量日志，从而保持日志清爽。例如：

    javascript
    
    
function main() {
    // 在收益图表上打印30个点
    for(var i = 0; i < 30; i++) {
        LogProfit(i, '&')
        Sleep(500)
    }
}

    python
    
    
def main():
    for i in range(30):
        LogProfit(i, '&')
        Sleep(500)

    rust
    
    
fn main() {
    // 在收益图表上打印30个点
    // Rust 中 LogProfit 只接受收益数值参数，不支持 '&' 等扩展参数
    for i in 0..30 {
        LogProfit(i);
        Sleep(500);
    }
}

    c++
    
    
void main() {
    for(int i = 0; i < 30; i++) {
        LogProfit(i, '&');
        Sleep(500);
    }
}

参数

参考

LogProfitReset

清空所有收益日志与收益图表。

    
    
    
LogProfitReset()

    
    
    
LogProfitReset(remain)

示例

在收益图表上打印30个数据点，然后重置，仅保留最后10个数据点。

    javascript
    
    
function main() {
    // 在收益图表上打印30个点，然后重置，只保留最后10个点
    for(var i = 0; i < 30; i++) {
        LogProfit(i)
        Sleep(500)
    }
    LogProfitReset(10)
}

    python
    
    
def main():
    for i in range(30):
        LogProfit(i)
        Sleep(500)
    LogProfitReset(10)

    rust
    
    
fn main() {
    // 在收益图表上打印30个点，然后重置，只保留最后10个点
    for i in 0..30 {
        LogProfit(i);
        Sleep(500);
    }
    LogProfitReset(10);
}

    c++
    
    
void main() {
    for(int i = 0; i < 30; i++) {
        LogProfit(i);
        Sleep(500);
    }
    LogProfitReset(10);
}

参数

参考

LogStatus

在回测系统或实盘页面的状态栏中输出信息。

    
    
    
LogStatus(...msgs)

示例

• 支持设置输出内容的颜色：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      LogStatus('这是一个普通的状态提示')
      LogStatus('这是一个红色字体的状态提示#ff0000')
      LogStatus('这是一个多行的状态信息\n我是第二行')
  }
  

  
      python
      
      
  def main():
      LogStatus('这是一个普通的状态提示')
      LogStatus('这是一个红色字体的状态提示#ff0000')
      LogStatus('这是一个多行的状态信息\n我是第二行')
  

  
      rust
      
      
  fn main() {
      LogStatus!("这是一个普通的状态提示");
      LogStatus!("这是一个红色字体的状态提示#ff0000");
      LogStatus!("这是一个多行的状态信息\n我是第二行");
  }
  

  
      c++
      
      
  void main() {
      LogStatus("这是一个普通的状态提示");
      LogStatus("这是一个红色字体的状态提示#ff0000");
      LogStatus("这是一个多行的状态信息\n我是第二行");
  }
  

• 以下是在状态栏中输出数据的示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table = {type: 'table', title: '持仓信息', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
      // 将 JSON 序列化后，在字符串两端加上 ` 字符，即可将其识别为一种复杂消息格式（当前支持表格）
      LogStatus('`' + JSON.stringify(table) + '`')
      // 表格信息也可以出现在多行文本中
      LogStatus('第一行消息\n`' + JSON.stringify(table) + '`\n第三行消息')
      // 支持同时显示多个表格，它们将以 TAB 形式归为一组显示
      LogStatus('`' + JSON.stringify([table, table]) + '`')
  
      // 也可以在表格中构造按钮，策略通过 GetCommand 接收 cmd 属性的内容
      var table = {
          type: 'table',
          title: '持仓操作',
          cols: ['列1', '列2', 'Action'],
          rows: [
              ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
          ]
      }
      LogStatus('`' + JSON.stringify(table) + '`')
      // 或者构造一个独立的按钮
      LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': '平仓'}) + '`')
      // 可以自定义按钮样式（Bootstrap 的按钮属性）
      LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': '平仓'}) + '`')
  }
  

  
      python
      
      
  import json
  def main():
      table = {"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
      LogStatus('`' + json.dumps(table) + '`')
      LogStatus('第一行消息\n`' + json.dumps(table) + '`\n第三行消息')
      LogStatus('`' + json.dumps([table, table]) + '`')
  
      table = {
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      }
      LogStatus('`' + json.dumps(table) + '`')
      LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "平仓"}) + '`')
      LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"}) + '`')
  

  
      rust
      
      
  fn main() {
      let table = r#"{"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}"#;
      // 在 JSON 字符串两端加上 ` 字符，即可将其识别为一种复杂消息格式（当前支持表格）
      LogStatus!(format!("`{}`", table));
      // 表格信息也可以出现在多行文本中
      LogStatus!(format!("第一行消息\n`{}`\n第三行消息", table));
      // 支持同时显示多个表格，它们将以 TAB 形式归为一组显示
      LogStatus!(format!("`[{},{}]`", table, table));
  
      // 也可以在表格中构造按钮，策略通过 GetCommand 接收 cmd 属性的内容
      let table = r#"{"type": "table", "title": "持仓操作", "cols": ["列1", "列2", "Action"], "rows": [["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]]}"#;
      LogStatus!(format!("`{}`", table));
      // 或者构造一个独立的按钮
      LogStatus!(r#"`{"type": "button", "cmd": "coverAll", "name": "平仓"}`"#);
      // 可以自定义按钮样式（Bootstrap 的按钮属性）
      LogStatus!(r#"`{"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"}`"#);
  }
  

  
      c++
      
      
  void main() {
      json table = R"({"type": "table", "title": "持仓信息", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
      LogStatus("`" + table.dump() + "`");
      LogStatus("第一行消息\n`" + table.dump() + "`\n第三行消息");
      json arr = R"([])"_json;
      arr.push_back(table);
      arr.push_back(table);
      LogStatus("`" + arr.dump() + "`");
  
      table = R"({
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      })"_json;
      LogStatus("`" + table.dump() + "`");
      LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
      LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "平仓"})"_json.dump() + "`");
  }
  

• 支持在状态栏中设计按钮控件（旧版按钮结构）：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table = {
          type: "table",
          title: "状态栏按钮样式",
          cols: ["默认", "原始", "成功", "信息", "警告", "危险"],
          rows: [
              [
                  {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                  {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                  {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                  {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                  {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                  {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
              ]
          ]
      }
      LogStatus("`" + JSON.stringify(table) + "`")
  }
  

  
      python
      
      
  import json
  def main():
      table = {
          "type": "table",
          "title": "状态栏按钮样式",
          "cols": ["默认", "原始", "成功", "信息", "警告", "危险"],
          "rows": [
              [
                  {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                  {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                  {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                  {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                  {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                  {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
              ]
          ]
      }
      LogStatus("`" + json.dumps(table) + "`")
  

  
      rust
      
      
  fn main() {
      let table = String::from(r#"{"type": "table", "title": "状态栏按钮样式", "cols": ["默认", "原始", "成功", "信息", "警告", "危险"], "rows": [["#)
          + r#"{"type": "button", "class": "btn btn-xs btn-default", "name": "默认"},"#
          + r#"{"type": "button", "class": "btn btn-xs btn-primary", "name": "原始"},"#
          + r#"{"type": "button", "class": "btn btn-xs btn-success", "name": "成功"},"#
          + r#"{"type": "button", "class": "btn btn-xs btn-info", "name": "信息"},"#
          + r#"{"type": "button", "class": "btn btn-xs btn-warning", "name": "告警"},"#
          + r#"{"type": "button", "class": "btn btn-xs btn-danger", "name": "危险"}"#
          + r#"]]}"#;
      LogStatus!(format!("`{}`", table));
  }
  

  
      c++
      
      
  void main() {
      json table = R"({
          "type": "table",
          "title": "状态栏按钮样式",
          "cols": ["默认", "原始", "成功", "信息", "警告", "危险"],
          "rows": [
              [
                  {"type":"button", "class": "btn btn-xs btn-default", "name": "默认"},
                  {"type":"button", "class": "btn btn-xs btn-primary", "name": "原始"},
                  {"type":"button", "class": "btn btn-xs btn-success", "name": "成功"},
                  {"type":"button", "class": "btn btn-xs btn-info", "name": "信息"},
                  {"type":"button", "class": "btn btn-xs btn-warning", "name": "告警"},
                  {"type":"button", "class": "btn btn-xs btn-danger", "name": "危险"}
              ]
          ]
      })"_json;
      LogStatus("`" + table.dump() + "`");
  }
  

• 设置状态栏按钮的禁用及描述功能（旧版按钮结构）：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table = {
          type: "table",
          title: "状态栏按钮的禁用、描述功能测试",
          cols: ["列1", "列2", "列3"],
          rows: []
      }
      var button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
      var button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true}
      var button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false}
      table.rows.push([button1, button2, button3])
      LogStatus("`" + JSON.stringify(table) + "`")
  }
  

  
      python
      
      
  import json
  def main():
      table = {
          "type": "table",
          "title": "状态栏按钮的禁用、描述功能测试",
          "cols": ["列1", "列2", "列3"],
          "rows": []
      }
      button1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
      button2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": True}
      button3 = {"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": False}
      table["rows"].append([button1, button2, button3])
      LogStatus("`" + json.dumps(table) + "`")
  

  
      rust
      
      
  fn main() {
      let button1 = r#"{"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}"#;
      let button2 = r#"{"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true}"#;
      let button3 = r#"{"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false}"#;
      let table = format!(
          r#"{{"type": "table", "title": "状态栏按钮的禁用、描述功能测试", "cols": ["列1", "列2", "列3"], "rows": [[{}, {}, {}]]}}"#,
          button1, button2, button3
      );
      LogStatus!(format!("`{}`", table));
  }
  

  
      c++
      
      
  void main() {
      json table = R"({
          "type": "table",
          "title": "状态栏按钮的禁用、描述功能测试",
          "cols": ["列1", "列2", "列3"],
          "rows": []
      })"_json;
      json button1 = R"({"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"})"_json;
      json button2 = R"({"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮，设置为禁用", "disabled": true})"_json;
      json button3 = R"({"type": "button", "name": "按钮3", "cmd": "button3", "description": "这是第三个按钮，设置为启用", "disabled": false})"_json;
      json arr = R"([])"_json;
      arr.push_back(button1);
      arr.push_back(button2);
      arr.push_back(button3);
      table["rows"].push_back(arr);
      LogStatus("`" + table.dump() + "`");
  }
  

• 结合 GetCommand() 函数，构造状态栏按钮的交互功能（旧版按钮结构）：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function test1() {
      Log("调用自定义函数")
  }
  
  function main() {
      while (true) {
          var table = {
              type: 'table',
              title: '操作',
              cols: ['列1', '列2', 'Action'],
              rows: [
                  ['a', '1', {
                      'type': 'button',
                      'cmd': "CoverAll",
                      'name': '平仓'
                  }],
                  ['b', '1', {
                      'type': 'button',
                      'cmd': 10,
                      'name': '发送数值'
                  }],
                  ['c', '1', {
                      'type': 'button',
                      'cmd': _D(),
                      'name': '调用函数'
                  }],
                  ['d', '1', {
                      'type': 'button',
                      'cmd': 'test1',
                      'name': '调用自定义函数'
                  }]
              ]
          }
          LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')
  
          var str_cmd = GetCommand()
          if (str_cmd) {
              Log("接收到的交互数据 str_cmd:", "类型：", typeof(str_cmd), "值：", str_cmd)
              if(str_cmd == "test1") {
                  test1()
              }
          }
  
          Sleep(500)
      }
  }
  

  
      python
      
      
  import json
  def test1():
      Log("调用自定义函数")
  
  def main():
      while True:
          table = {
              "type": "table",
              "title": "操作",
              "cols": ["列1", "列2", "Action"],
              "rows": [
                  ["a", "1", {
                      "type": "button",
                      "cmd": "CoverAll",
                      "name": "平仓"
                  }],
                  ["b", "1", {
                      "type": "button",
                      "cmd": 10,
                      "name": "发送数值"
                  }],
                  ["c", "1", {
                      "type": "button",
                      "cmd": _D(),
                      "name": "调用函数"
                  }],
                  ["d", "1", {
                      "type": "button",
                      "cmd": "test1",
                      "name": "调用自定义函数"
                  }]
              ]
          }
  
          LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
          str_cmd = GetCommand()
          if str_cmd:
              Log("接收到的交互数据 str_cmd", "类型：", type(str_cmd), "值：", str_cmd)
              if str_cmd == "test1":
                  test1()
          Sleep(500)
  

  
      rust
      
      
  fn test1() {
      Log!("调用自定义函数");
  }
  
  fn main() {
      loop {
          let table = String::from(r#"{"type": "table", "title": "操作", "cols": ["列1", "列2", "Action"], "rows": ["#)
              + r#"["a", "1", {"type": "button", "cmd": "CoverAll", "name": "平仓"}],"#
              + r#"["b", "1", {"type": "button", "cmd": 10, "name": "发送数值"}],"#
              + &format!(r#"["c", "1", {{"type": "button", "cmd": "{}", "name": "调用函数"}}],"#, _D(None))
              + r#"["d", "1", {"type": "button", "cmd": "test1", "name": "调用自定义函数"}]"#
              + r#"]}"#;
          LogStatus!(_D(None), "\n", format!("`{}`", table));
  
          if let Some(str_cmd) = GetCommand(0) {
              Log!("接收到的交互数据 str_cmd:", "类型：", "String", "值：", &str_cmd);
              if str_cmd == "test1" {
                  test1();
              }
          }
  
          Sleep(500);
      }
  }
  

  
      c++
      
      
  void test1() {
      Log("调用自定义函数");
  }
  
  void main() {
      while(true) {
          json table = R"({
              "type": "table",
              "title": "操作",
              "cols": ["列1", "列2", "Action"],
              "rows": [
                  ["a", "1", {
                      "type": "button",
                      "cmd": "CoverAll",
                      "name": "平仓"
                  }],
                  ["b", "1", {
                      "type": "button",
                      "cmd": 10,
                      "name": "发送数值"
                  }],
                  ["c", "1", {
                      "type": "button",
                      "cmd": "",
                      "name": "调用函数"
                  }],
                  ["d", "1", {
                      "type": "button",
                      "cmd": "test1",
                      "name": "调用自定义函数"
                  }]
              ]
          })"_json;
          table["rows"][2][2]["cmd"] = _D();
          LogStatus(_D(), "\n", "`" + table.dump() + "`");
          auto str_cmd = GetCommand();
          if(str_cmd != "") {
              Log("接收到的交互数据 str_cmd", "类型：", typeid(str_cmd).name(), "值：", str_cmd);
              if(str_cmd == "test1") {
                  test1();
              }
          }
          Sleep(500);
      }
  }
  

• 在构造状态栏按钮进行交互时，同样支持输入数据，交互指令最终由GetCommand()函数捕获。

  在状态栏按钮控件的数据结构中增加input项（旧版按钮结构）。例如，为{"type": "button", "cmd": "open", "name": "开仓"}增加："input": {"name": "开仓数量", "type": "number", "defValue": 1}，即可使该按钮在被点击时弹出一个带输入框控件的弹窗（输入框中的默认值为1，即defValue所设置的数据），从而在输入一个数据后与按钮命令一起发送。例如运行以下测试代码，点击「开仓」按钮后会弹出一个带输入框的弹窗，在输入框中输入111并点击「确定」，GetCommand()函数便会捕获到消息：open:111。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var tbl = {
          type: "table",
          title: "操作",
          cols: ["列1", "列2"],
          rows: [
              ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
              ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
          ]
      }
  
      LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
      while (true) {
          var cmd = GetCommand()
          if (cmd) {
              Log("cmd:", cmd)
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  import json
  
  def main():
      tbl = {
          "type": "table",
          "title": "操作",
          "cols": ["列1", "列2"],
          "rows": [
              ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
              ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
          ]
      }
  
      LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
      while True:
          cmd = GetCommand()
          if cmd:
              Log("cmd:", cmd)
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      let tbl = String::from(r#"{"type": "table", "title": "操作", "cols": ["列1", "列2"], "rows": ["#)
          + r#"["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],"#
          + r#"["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]"#
          + r#"]}"#;
  
      LogStatus!(_D(None), "\n", format!("`{}`", tbl));
      loop {
          if let Some(cmd) = GetCommand(0) {
              Log!("cmd:", cmd);
          }
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  void main() {
      json tbl = R"({
          "type": "table",
          "title": "操作",
          "cols": ["列1", "列2"],
          "rows": [
              ["开仓操作", {"type": "button", "cmd": "open", "name": "开仓", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}],
              ["平仓操作", {"type": "button", "cmd": "coverAll", "name": "全部平仓"}]
          ]
      })"_json;
  
      LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
      while(true) {
          auto cmd = GetCommand();
          if(cmd != "") {
              Log("cmd:", cmd);
          }
          Sleep(1000);
      }
  }
  

• 支持分组按钮控件（旧版按钮结构），其功能与支持输入数据的状态栏按钮（使用"input"字段设置）一致。交互指令最终由GetCommand()函数捕获。区别在于：分组按钮控件通过"group"字段进行设置，当点击按钮触发交互时，页面弹出的对话框中会显示预先设置好的一组输入控件，可以一次性输入一组数据。

  关于状态栏按钮控件与分组按钮控件结构中的"group"字段，需要注意以下几点：

  • group中type属性仅支持以下4种类型，defValue属性用于设置默认值。
    "selected"：下拉框控件，设置下拉框的各个选项时使用|符号分隔。
    "number"：数值输入框控件。
    "string"：字符串输入框控件。
    "boolean"：勾选框控件，勾选表示（布尔值）真，不勾选表示（布尔值）假。
  • 交互输入时的控件支持依赖设置：
    例如以下例子中的"name": "tradePrice@orderType==1"设置，使交易价格（tradePrice）输入控件仅在下单方式（orderType）下拉框控件选择为挂单时可用。
  • 交互输入时的控件名称支持双语设置：
    例如以下例子中的"description": "下单方式|order type"设置，使用|符号分隔中英文描述内容。
  • group中的name、description与按钮结构中的name、description虽然字段名一致，但定义并不相同：
    group中的name与input中的name定义也不相同。
  • 分组按钮控件触发后，发送的交互内容格式为：按钮的cmd字段值，加上group字段的相关数据。例如以下例子测试时Log("cmd:", cmd)语句输出的内容：
    cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}，即发生交互操作时GetCommand()函数返回的内容：open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}。
  • 按钮控件的type属性仅支持"button"：
    支持输入数据的按钮控件，即设置了input属性的控件，其input字段的配置信息中的type属性支持多种控件类型。
    参考以下例子：
  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var tbl = {
          type: "table",
          title: "演示分组按钮控件",
          cols: ["操作"],
          rows: []
      }
  
      // 创建分组按钮控件结构
      var groupBtn = {
          type: "button",
          cmd: "open",
          name: "开仓",
          group: [
              {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
              {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
              {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
              {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
          ]
      }
  
      // 测试按钮1
      var testBtn1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
      var testBtn2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}
  
      // 在tbl中添加groupBtn
      tbl.rows.push([groupBtn])
      // 支持状态栏表格的一个单元格内设置多个按钮，即一个单元格内的数据为一个按钮结构数组：[testBtn1, testBtn2]
      tbl.rows.push([[testBtn1, testBtn2]])
  
      while (true) {
          LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + JSON.stringify(groupBtn) + "`")
          var cmd = GetCommand()
          if (cmd) {
              Log("cmd:", cmd)
          }
          Sleep(5000)
      }
  }
  

  
      python
      
      
  import json
  
  def main():
      tbl = {
          "type": "table",
          "title": "演示分组按钮控件",
          "cols": ["操作"],
          "rows": []
      }
  
      groupBtn = {
          "type": "button",
          "cmd": "open",
          "name": "开仓",
          "group": [
              {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
              {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
              {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
              {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": True}
          ]
      }
  
      testBtn1 = {"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}
      testBtn2 = {"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}
  
      tbl["rows"].append([groupBtn])
      tbl["rows"].append([[testBtn1, testBtn2]])
  
      while True:
          LogStatus("`" + json.dumps(tbl) + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + json.dumps(groupBtn) + "`")
          cmd = GetCommand()
          if cmd:
              Log("cmd:", cmd)
          Sleep(5000)
  

  
      rust
      
      
  fn main() {
      // 创建分组按钮控件结构
      let group_btn = String::from(r#"{"type": "button", "cmd": "open", "name": "开仓", "group": ["#)
          + r#"{"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},"#
          + r#"{"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},"#
          + r#"{"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},"#
          + r#"{"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}"#
          + r#"]}"#;
  
      // 测试按钮1、测试按钮2
      let test_btn1 = r#"{"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"}"#;
      let test_btn2 = r#"{"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}}"#;
  
      // 在tbl中添加groupBtn；支持状态栏表格的一个单元格内设置多个按钮，即一个单元格内的数据为一个按钮结构数组：[testBtn1, testBtn2]
      let tbl = format!(
          r#"{{"type": "table", "title": "演示分组按钮控件", "cols": ["操作"], "rows": [[{}], [[{}, {}]]]}}"#,
          group_btn, test_btn1, test_btn2
      );
  
      loop {
          LogStatus!(format!("`{}`", tbl), "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", format!("`{}`", group_btn));
          if let Some(cmd) = GetCommand(0) {
              Log!("cmd:", cmd);
          }
          Sleep(5000);
      }
  }
  

  
      c++
      
      
  void main() {
      json tbl = R"({
          "type": "table",
          "title": "演示分组按钮控件",
          "cols": ["操作"],
          "rows": []
      })"_json;
  
      json groupBtn = R"({
          "type": "button",
          "name": "开仓",
          "cmd": "open",
          "group": [
              {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
              {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
              {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
              {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
      ]})"_json;
  
      json testBtn1 = R"({"type": "button", "name": "按钮1", "cmd": "button1", "description": "这是第一个按钮"})"_json;
      json testBtn2 = R"({"type": "button", "name": "按钮2", "cmd": "button2", "description": "这是第二个按钮", "input": {"name": "开仓数量", "type": "number", "defValue": 1}})"_json;
  
      tbl["rows"].push_back({groupBtn});
      tbl["rows"].push_back({{testBtn1, testBtn2}});
  
      while(true) {
          LogStatus("`" + tbl.dump() + "`", "\n", "分组按钮控件除了设置在状态栏表格中，也可以直接设置在状态栏上：", "`" + groupBtn.dump() + "`");
          auto cmd = GetCommand();
          if(cmd != "") {
              Log("cmd:", cmd);
          }
          Sleep(5000);
      }
  }
  

• 当状态栏分组按钮控件（通过设置group字段实现）与状态栏按钮控件（通过设置input字段实现）被点击触发交互时（旧版按钮结构），页面弹出对话框中的下拉框控件同样支持多选。以下示例演示如何设计包含多选选项的下拉框控件：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 状态栏按钮控件（通过设置input字段实现）中，testBtn1按钮触发页面的下拉框控件通过options字段设置选项，并通过defValue字段设置默认选项。此方式区别于本章其它示例中直接使用defValue设置选项的做法。
      var testBtn1 = {
          type: "button",
          name: "testBtn1",
          cmd: "cmdTestBtn1",
          input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
      }
  
      /*
        状态栏按钮控件（通过设置input字段实现）中，testBtn2按钮触发页面的下拉框控件通过options字段设置选项。options字段中的选项不仅支持字符串，
        也支持使用```{text: "描述", value: "值"}```结构。defValue字段用于设置默认选项，默认选项可以为多选（通过数组结构实现多选）。多选时需额外将multiple字段设置为真值（true）。
      */
      var testBtn2 = {
          type: "button",
          name: "testBtn2",
          cmd: "cmdTestBtn2",
          input: {
              name: "testBtn2MultiComboBox",
              type: "selected",
              description: "实现下拉框多选",
              options: [{text: "选项A", value: "A"}, {text: "选项B", value: "B"}, {text: "选项C", value: "C"}],
              defValue: ["A", "C"],
              multiple: true
          }
      }
  
      // 状态栏分组按钮控件（通过设置group字段实现）中，testBtn3按钮触发页面的下拉框控件通过options字段设置选项，也支持直接使用defValue设置选项。
      var testBtn3 = {
          type: "button",
          name: "testBtn3",
          cmd: "cmdTestBtn3",
          group: [
              {name: "comboBox1", label: "labelComboBox1", description: "下拉框1", type: "selected", defValue: 1, options: ["A", "B"]},
              {name: "comboBox2", label: "labelComboBox2", description: "下拉框2", type: "selected", defValue: "A|B"},
              {name: "comboBox3", label: "labelComboBox3", description: "下拉框3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
              {
                  name: "comboBox4",
                  label: "labelComboBox4",
                  description: "下拉框4",
                  type: "selected",
                  defValue: ["A", "C"],
                  multiple: true,
                  options: [{text: "选项A", value: "A"}, {text: "选项B", value: "B"}, {text: "选项C", value: "C"}, {text: "选项D", value: "D"}]
              }
          ]
      }
      while (true) {
          LogStatus("`" + JSON.stringify(testBtn1) + "`\n", "`" + JSON.stringify(testBtn2) + "`\n", "`" + JSON.stringify(testBtn3) + "`\n")
          var cmd = GetCommand()
          if (cmd) {
              Log(cmd)
          }
          Sleep(5000)
      }
  }
  

  
      python
      
      
  import json
  
  def main():
      testBtn1 = {
          "type": "button",
          "name": "testBtn1",
          "cmd": "cmdTestBtn1",
          "input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
      }
  
      testBtn2 = {
          "type": "button",
          "name": "testBtn2",
          "cmd": "cmdTestBtn2",
          "input": {
              "name": "testBtn2MultiComboBox",
              "type": "selected",
              "description": "实现下拉框多选",
              "options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}],
              "defValue": ["A", "C"],
              "multiple": True
          }
      }
  
      testBtn3 = {
          "type": "button",
          "name": "testBtn3",
          "cmd": "cmdTestBtn3",
          "group": [
              {"name": "comboBox1", "label": "labelComboBox1", "description": "下拉框1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
              {"name": "comboBox2", "label": "labelComboBox2", "description": "下拉框2", "type": "selected", "defValue": "A|B"},
              {"name": "comboBox3", "label": "labelComboBox3", "description": "下拉框3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
              {
                  "name": "comboBox4",
                  "label": "labelComboBox4",
                  "description": "下拉框4",
                  "type": "selected",
                  "defValue": ["A", "C"],
                  "multiple": True,
                  "options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}, {"text": "选项D", "value": "D"}]
              }
          ]
      }
  
      while True:
          LogStatus("`" + json.dumps(testBtn1) + "`\n", "`" + json.dumps(testBtn2) + "`\n", "`" + json.dumps(testBtn3) + "`\n")
          cmd = GetCommand()
          if cmd:
              Log(cmd)
          Sleep(5000)
  

  
      rust
      
      
  fn main() {
      // 状态栏按钮控件（通过设置input字段实现）中，testBtn1按钮触发页面的下拉框控件通过options字段设置选项，并通过defValue字段设置默认选项。此方式区别于本章其它示例中直接使用defValue设置选项的做法。
      let test_btn1 = r#"{"type": "button", "name": "testBtn1", "cmd": "cmdTestBtn1", "input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}}"#;
  
      /*
        状态栏按钮控件（通过设置input字段实现）中，testBtn2按钮触发页面的下拉框控件通过options字段设置选项。options字段中的选项不仅支持字符串，
        也支持使用{"text": "描述", "value": "值"}结构。defValue字段用于设置默认选项，默认选项可以为多选（通过数组结构实现多选）。多选时需额外将multiple字段设置为真值（true）。
      */
      let test_btn2 = String::from(r#"{"type": "button", "name": "testBtn2", "cmd": "cmdTestBtn2", "input": {"#)
          + r#""name": "testBtn2MultiComboBox", "type": "selected", "description": "实现下拉框多选","#
          + r#""options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}],"#
          + r#""defValue": ["A", "C"], "multiple": true}}"#;
  
      // 状态栏分组按钮控件（通过设置group字段实现）中，testBtn3按钮触发页面的下拉框控件通过options字段设置选项，也支持直接使用defValue设置选项。
      let test_btn3 = String::from(r#"{"type": "button", "name": "testBtn3", "cmd": "cmdTestBtn3", "group": ["#)
          + r#"{"name": "comboBox1", "label": "labelComboBox1", "description": "下拉框1", "type": "selected", "defValue": 1, "options": ["A", "B"]},"#
          + r#"{"name": "comboBox2", "label": "labelComboBox2", "description": "下拉框2", "type": "selected", "defValue": "A|B"},"#
          + r#"{"name": "comboBox3", "label": "labelComboBox3", "description": "下拉框3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},"#
          + r#"{"name": "comboBox4", "label": "labelComboBox4", "description": "下拉框4", "type": "selected", "defValue": ["A", "C"], "multiple": true, "options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}, {"text": "选项D", "value": "D"}]}"#
          + r#"]}"#;
  
      loop {
          LogStatus!(format!("`{}`\n", test_btn1), format!("`{}`\n", test_btn2), format!("`{}`\n", test_btn3));
          if let Some(cmd) = GetCommand(0) {
              Log!(cmd);
          }
          Sleep(5000);
      }
  }
  

  
      c++
      
      
  void main() {
      json testBtn1 = R"({
          "type": "button",
          "name": "testBtn1",
          "cmd": "cmdTestBtn1",
          "input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
      })"_json;
  
      json testBtn2 = R"({
          "type": "button",
          "name": "testBtn2",
          "cmd": "cmdTestBtn2",
          "input": {
              "name": "testBtn2MultiComboBox",
              "type": "selected",
              "description": "实现下拉框多选",
              "options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}],
              "defValue": ["A", "C"],
              "multiple": true
          }
      })"_json;
  
      json testBtn3 = R"({
          "type": "button",
          "name": "testBtn3",
          "cmd": "cmdTestBtn3",
          "group": [
              {"name": "comboBox1", "label": "labelComboBox1", "description": "下拉框1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
              {"name": "comboBox2", "label": "labelComboBox2", "description": "下拉框2", "type": "selected", "defValue": "A|B"},
              {"name": "comboBox3", "label": "labelComboBox3", "description": "下拉框3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
              {
                  "name": "comboBox4",
                  "label": "labelComboBox4",
                  "description": "下拉框4",
                  "type": "selected",
                  "defValue": ["A", "C"],
                  "multiple": true,
                  "options": [{"text": "选项A", "value": "A"}, {"text": "选项B", "value": "B"}, {"text": "选项C", "value": "C"}, {"text": "选项D", "value": "D"}]
              }
          ]
      })"_json;
  
      while (true) {
          LogStatus("`" + testBtn1.dump() + "`\n", "`" + testBtn2.dump() + "`\n", "`" + testBtn3.dump() + "`\n");
          auto cmd = GetCommand();
          if (cmd != "") {
              Log(cmd);
          }
          Sleep(5000);
      }
  }
  

• 使用当前最新的按钮结构，在状态栏表格中构造按钮；点击按钮触发交互时，会弹出一个包含多个控件的弹窗。

  详细内容请参阅：用户指南-状态栏中的交互控件。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var symbols = ["rb2410", "MA501", "hc2501", "i2501", "TA888"]
  
  function createBtn(tmp, group) {
      var btn = JSON.parse(JSON.stringify(tmp))
  
      _.each(group, function(eleByGroup) {
          btn["group"].unshift(eleByGroup)
      })
  
      return btn
  }
  
  function main() {
      var arrManager = []
  
      _.each(symbols, function(symbol) {
          arrManager.push({
              "symbol": symbol,
          })
      })
  
      // Btn
      var tmpBtnOpen = {
          "type": "button",
          "cmd": "open",
          "name": "开仓下单",
          "group": [{
              "type": "selected",
              "name": "tradeType",
              "label": "下单类型",
              "description": "市价单、限价单",
              "default": 0,
              "group": "交易设置",
              "settings": {
                  "options": ["市价单", "限价单"],
                  "required": true,
              }
          }, {
              "type": "selected",
              "name": "direction",
              "label": "交易方向",
              "description": "买入、卖出",
              "default": "buy",
              "group": "交易设置",
              "settings": {
                  "render": "segment",
                  "required": true,
                  "options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
              }
          }, {
              "type": "number",
              "name": "price",
              "label": "价格",
              "description": "订单的价格",
              "group": "交易设置",
              "filter": "tradeType==1",
              "settings": {
                  "required": true,
              }
          }, {
              "type": "number",
              "name": "amount",
              "label": "下单量",
              "description": "订单的下单量",
              "group": "交易设置",
              "settings": {
                  "required": true,
              }
          }],
      }
  
      while (true) {
          var tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
  
          _.each(arrManager, function(m) {
              var btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": true}}])
              tbl["rows"].push([m["symbol"], btnOpen])
          })
  
          var cmd = GetCommand()
          if (cmd) {
              Log("收到交互：", cmd)
  
              // 解析交互消息: open:{"symbol":"TA888","tradeType":0,"direction":"buy","amount":111}
              // 根据第一个冒号:之前的指令判断是哪种按钮模板触发的消息
              var arrCmd = cmd.split(":", 2)
              if (arrCmd[0] == "open") {
                  var msg = JSON.parse(cmd.slice(5))
                  Log("交易品种：", msg["symbol"], "，交易方向：", msg["direction"], "，订单类型：", msg["tradeType"] == 0 ? "市价单" : "限价单", msg["tradeType"] == 0 ? "，订单价格：当前市价" : "，订单价格：" + msg["price"], "，订单数量：", msg["amount"])
              }
          }
  
          LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
          Sleep(1000)
      }
  }
  

  
      python
      
      
  import json
  
  symbols = ["rb2410", "MA501", "hc2501", "i2501", "TA888"]
  
  def createBtn(tmp, group):
      btn = json.loads(json.dumps(tmp))
      for eleByGroup in group:
          btn["group"].insert(0, eleByGroup)
      return btn
  
  def main():
      arrManager = []
  
      for symbol in symbols:
          arrManager.append({"symbol": symbol})
  
      # Btn
      tmpBtnOpen = {
          "type": "button",
          "cmd": "open",
          "name": "开仓下单",
          "group": [{
              "type": "selected",
              "name": "tradeType",
              "label": "下单类型",
              "description": "市价单、限价单",
              "default": 0,
              "group": "交易设置",
              "settings": {
                  "options": ["市价单", "限价单"],
                  "required": True,
              }
          }, {
              "type": "selected",
              "name": "direction",
              "label": "交易方向",
              "description": "买入、卖出",
              "default": "buy",
              "group": "交易设置",
              "settings": {
                  "render": "segment",
                  "required": True,
                  "options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}],
              }
          }, {
              "type": "number",
              "name": "price",
              "label": "价格",
              "description": "订单的价格",
              "group": "交易设置",
              "filter": "tradeType==1",
              "settings": {
                  "required": True,
              }
          }, {
              "type": "number",
              "name": "amount",
              "label": "下单量",
              "description": "订单的下单量",
              "group": "交易设置",
              "settings": {
                  "required": True,
              }
          }],
      }
  
      while True:
          tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
          for m in arrManager:
              btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "交易品种", "default": m["symbol"], "settings": {"required": True}}])
              tbl["rows"].append([m["symbol"], btnOpen])
  
          cmd = GetCommand()
  
          if cmd != "" and cmd != None:
              Log("收到交互：", cmd)
  
              # 解析交互消息: open:{"symbol":"TA888","tradeType":0,"direction":"buy","amount":111}
              # 根据第一个冒号:之前的指令判断是哪种按钮模板触发的消息
              arrCmd = cmd.split(":")
              if arrCmd[0] == "open":
                  msg = json.loads(cmd[5:])
                  Log("交易品种：", msg["symbol"], "，交易方向：", msg["direction"], "，订单类型：", "市价单" if msg["tradeType"] == 0 else "限价单", "，订单价格：当前市价" if msg["tradeType"] == 0 else "，订单价格：" + str(msg["price"]), "，订单数量：", msg["amount"])
  
          # 输出状态栏信息
          LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      let symbols = ["rb2410", "MA501", "hc2501", "i2501", "TA888"];
  
      // Btn：按钮模板，"group"的第一个元素为交易品种控件，__SYMBOL__为占位符，构造按钮时替换
      let tmp_btn_open = String::from(r#"{"type": "button", "cmd": "open", "name": "开仓下单", "group": ["#)
          + r#"{"type": "string", "name": "symbol", "label": "交易品种", "default": "__SYMBOL__", "settings": {"required": true}},"#
          + r#"{"type": "selected", "name": "tradeType", "label": "下单类型", "description": "市价单、限价单", "default": 0, "group": "交易设置", "settings": {"options": ["市价单", "限价单"], "required": true}},"#
          + r#"{"type": "selected", "name": "direction", "label": "交易方向", "description": "买入、卖出", "default": "buy", "group": "交易设置", "settings": {"render": "segment", "required": true, "options": [{"name": "买入", "value": "buy"}, {"name": "卖出", "value": "sell"}]}},"#
          + r#"{"type": "number", "name": "price", "label": "价格", "description": "订单的价格", "group": "交易设置", "filter": "tradeType==1", "settings": {"required": true}},"#
          + r#"{"type": "number", "name": "amount", "label": "下单量", "description": "订单的下单量", "group": "交易设置", "settings": {"required": true}}"#
          + r#"]}"#;
  
      loop {
          let mut rows: Vec<String> = Vec::new();
          for symbol in &symbols {
              let btn_open = tmp_btn_open.replace("__SYMBOL__", symbol);
              rows.push(format!(r#"["{}", {}]"#, symbol, btn_open));
          }
          let tbl = format!(r#"{{"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": [{}]}}"#, rows.join(","));
  
          if let Some(cmd) = GetCommand(0) {
              Log!("收到交互：", &cmd);
  
              // 解析交互消息: open:{"symbol":"TA888","tradeType":0,"direction":"buy","amount":111}
              // 根据第一个冒号:之前的指令判断是哪种按钮模板触发的消息
              if cmd.starts_with("open:") {
                  let msg = JSONParse(&cmd[5..]).unwrap();
                  let trade_type = msg["tradeType"].as_i64().unwrap_or(0);
                  Log!("交易品种：", msg["symbol"].as_str().unwrap_or(""),
                      "，交易方向：", msg["direction"].as_str().unwrap_or(""),
                      "，订单类型：", if trade_type == 0 { "市价单" } else { "限价单" },
                      if trade_type == 0 { "，订单价格：当前市价".to_string() } else { format!("，订单价格：{}", msg["price"].as_f64().unwrap_or(0.0)) },
                      "，订单数量：", msg["amount"].as_f64().unwrap_or(0.0));
              }
          }
  
          LogStatus!(_D(None), "\n", format!("`{}`", tbl));
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  // 略...

• 横向合并 LogStatus() 函数绘制的表格中的单元格：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table = {
          type: 'table',
          title: '持仓操作',
          cols: ['列1', '列2', 'Action'],
          rows: [
              ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
          ]
      }
  
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅判断 exchange.IO("status") 函数
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
      exchange.SetContractType("rb888")
  
      var ticker = exchange.GetTicker()
      // 添加一行数据，将第一个和第二个单元格合并，并在合并后的单元格内输出 ticker 变量
      table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
      LogStatus('`' + JSON.stringify(table) + '`')
  }
  

  
      python
      
      
  import json
  def main():
      table = {
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      }
  
      while not exchange.IO("status"):
          Sleep(1000)
      exchange.SetContractType("rb888")
  
      ticker = exchange.GetTicker()
      table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
      LogStatus("`" + json.dumps(table) + "`")
  

  
      rust
      
      
  fn main() {
      let table_tpl = String::from(r#"{"type": "table", "title": "持仓操作", "cols": ["列1", "列2", "Action"], "rows": ["#)
          + r#"["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}],"#
          + r#"__ROW2__"#
          + r#"]}"#;
  
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅判断 exchange.IO("status") 函数
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
      exchange.SetContractType("rb888").unwrap();
  
      let ticker = exchange.GetTicker(None).unwrap();
      let json_ticker = format!(
          r#"{{"Buy": {}, "Sell": {}, "High": {}, "Low": {}, "Volume": {}, "Last": {}, "Time": {}}}"#,
          ticker.Buy, ticker.Sell, ticker.High, ticker.Low, ticker.Volume, ticker.Last, ticker.Time
      );
      // 添加一行数据，将第一个和第二个单元格合并，并在合并后的单元格内输出 ticker 数据
      let row2 = format!(r#"[{{"body": {}, "colspan": 2}}, "abc"]"#, json_ticker);
      let table = table_tpl.replace("__ROW2__", &row2);
      LogStatus!(format!("`{}`", table));
  }
  

  
      c++
      
      
  void main() {
      json table = R"({
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      })"_json;
  
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
      exchange.SetContractType("rb888");
  
      auto ticker = exchange.GetTicker();
      json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
      jsonTicker["Buy"] = ticker.Buy;
      jsonTicker["Sell"] = ticker.Sell;
      jsonTicker["Last"] = ticker.Last;
      jsonTicker["Volume"] = ticker.Volume;
      jsonTicker["Time"] = ticker.Time;
      jsonTicker["High"] = ticker.High;
      jsonTicker["Low"] = ticker.Low;
  
      json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
      arr[0]["body"] = jsonTicker;
      table["rows"].push_back(arr);
      LogStatus("`" + table.dump() + "`");
  }
  

• 纵向合并 LogStatus() 函数绘制的表格中的单元格：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table = {
          type: 'table',
          title: '表格演示',
          cols: ['列A', '列B', '列C'],
          rows: [
              ['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
          ]
      }
  
      // 由于是测试代码，此处不采用商品期货策略的通用架构
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
      exchange.SetContractType("rb888")
  
      var ticker = exchange.GetTicker()
      var name = exchange.GetName()
  
      table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
      table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
      // A3 被上一行的第一个单元格合并
      table.rows.push(["B4", "C4"])
      // A2 被上一行的第一个单元格合并
      table.rows.push(["B5", "C5"])
      table.rows.push(["A6", "B6", "C6"])
      LogStatus('`' + JSON.stringify(table) + '`')
  }
  

  
      python
      
      
  import json
  def main():
      table = {
          "type" : "table",
          "title" : "表格演示",
          "cols" : ["列A", "列B", "列C"],
          "rows" : [
              ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
          ]
      }
  
      while not exchange.IO("status"):
          Sleep(1000)
      exchange.SetContractType("rb888")
  
      ticker = exchange.GetTicker()
      name = exchange.GetName()
  
      table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
      table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
      table["rows"].append(["B4", "C4"])
      table["rows"].append(["B5", "C5"])
      table["rows"].append(["A6", "B6", "C6"])
      LogStatus("`" + json.dumps(table) + "`")
  

  
      rust
      
      
  fn main() {
      // 为了便于测试，代码力求简短易读，此处使用构造的数据
      let json_ticker = r#"{"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0}"#;
      let name = exchange.GetName();
  
      let mut rows: Vec<String> = Vec::new();
      rows.push(String::from(r#"["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]"#));
      // body 为字符串，其中的引号需转义后再嵌入 JSON
      let body = format!("A2 + B2:{}", json_ticker).replace('"', "\\\"");
      rows.push(format!(r#"[{{"body": "{}", "colspan": 2}}, "C2"]"#, body));
      rows.push(format!(r#"[{{"body": "A3 + A4 + A5:{}", "rowspan": 3}}, "B3", "C3"]"#, name));
      // A3 被上一行的第一个单元格合并
      rows.push(String::from(r#"["B4", "C4"]"#));
      // A4 被合并
      rows.push(String::from(r#"["B5", "C5"]"#));
      rows.push(String::from(r#"["A6", "B6", "C6"]"#));
  
      let table = format!(r#"{{"type": "table", "title": "表格演示", "cols": ["列A", "列B", "列C"], "rows": [{}]}}"#, rows.join(","));
      LogStatus!(format!("`{}`", table));
  }
  

  
      c++
      
      
  void main() {
      json table = R"({
          "type" : "table",
          "title" : "表格演示",
          "cols" : ["列A", "列B", "列C"],
          "rows" : [
              ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
          ]
      })"_json;
      // 为了便于测试，代码力求简短易读，此处使用构造的数据
      json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
      auto name = exchange.GetName();
      json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
      arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
      json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
      arr2[0]["body"] = "A3 + A4 + A5:" + name;
      table["rows"].push_back(arr1);
      table["rows"].push_back(arr2);
      table["rows"].push_back(R"(["B4", "C4"])"_json);
      table["rows"].push_back(R"(["B5", "C5"])"_json);
      table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
      LogStatus("`" + table.dump() + "`");
  }
  

• 状态栏表格分页显示：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var table1 = {type: 'table', title: 'table1', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
      var table2 = {type: 'table', title: 'table2', cols: ['列1', '列2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
      LogStatus('`' + JSON.stringify([table1, table2]) + '`')
  }
  

  
      python
      
      
  import json
  def main():
      table1 = {"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
      table2 = {"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
      LogStatus("`" + json.dumps([table1, table2]) + "`")
  

  
      rust
      
      
  fn main() {
      let table1 = r#"{"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}"#;
      let table2 = r#"{"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}"#;
      LogStatus!(format!("`[{},{}]`", table1, table2));
  }
  

  
      c++
      
      
  void main() {
      json table1 = R"({"type": "table", "title": "table1", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
      json table2 = R"({"type": "table", "title": "table2", "cols": ["列1", "列2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
      json arr = R"([])"_json;
      arr.push_back(table1);
      arr.push_back(table2);
      LogStatus("`" + arr.dump() + "`");
  }
  

• 除了可以分页显示表格外，还可以将多个表格自上而下排列显示：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      var tab1 = {
          type : "table",
          title : "表格1",
          cols : ["1", "2"],
          rows : []
      }
      var tab2 = {
          type : "table",
          title : "表格2",
          cols : ["1", "2", "3"],
          rows : []
      }
      var tab3 = {
          type : "table",
          title : "表格3",
          cols : ["A", "B", "C"],
          rows : []
      }
  
      tab1.rows.push(["jack", "lucy"])
      tab2.rows.push(["A", "B", "C"])
      tab3.rows.push(["A", "B", "C"])
  
      LogStatus('`' + JSON.stringify(tab1) + '`\n' +
          '`' + JSON.stringify(tab2) + '`\n' +
          '`' + JSON.stringify(tab3) + '`')
  
      Log("exit")
  }
  

  
      python
      
      
  import json
  def main():
      tab1 = {
          "type": "table",
          "title": "表格1",
          "cols": ["1", "2"],
          "rows": []
      }
      tab2 = {
          "type": "table",
          "title": "表格2",
          "cols": ["1", "2", "3"],
          "rows": []
      }
      tab3 = {
          "type": "table",
          "title": "表格3",
          "cols": ["A", "B", "C"],
          "rows": []
      }
  
      tab1["rows"].append(["jack", "lucy"])
      tab2["rows"].append(["A", "B", "C"])
      tab3["rows"].append(["A", "B", "C"])
      LogStatus("`" + json.dumps(tab1) + "`\n" +
          "`" + json.dumps(tab2) + "`\n" +
          "`" + json.dumps(tab3) + "`")
  

  
      rust
      
      
  fn main() {
      // Rust 中直接把行数据写入JSON字符串中
      let tab1 = r#"{"type": "table", "title": "表格1", "cols": ["1", "2"], "rows": [["jack", "lucy"]]}"#;
      let tab2 = r#"{"type": "table", "title": "表格2", "cols": ["1", "2", "3"], "rows": [["A", "B", "C"]]}"#;
      let tab3 = r#"{"type": "table", "title": "表格3", "cols": ["A", "B", "C"], "rows": [["A", "B", "C"]]}"#;
  
      LogStatus!(format!("`{}`\n`{}`\n`{}`", tab1, tab2, tab3));
  }
  

  
      c++
      
      
  void main() {
      json tab1 = R"({
          "type": "table",
          "title": "表格1",
          "cols": ["1", "2"],
          "rows": []
      })"_json;
      json tab2 = R"({
          "type": "table",
          "title": "表格2",
          "cols": ["1", "2", "3"],
          "rows": []
      })"_json;
      json tab3 = R"({
          "type": "table",
          "title": "表格3",
          "cols": ["A", "B", "C"],
          "rows": []
      })"_json;
      tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
      tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
      tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
      LogStatus("`" + tab1.dump() + "`\n" +
          "`" + tab2.dump() + "`\n" +
          "`" + tab3.dump() + "`");
  }
  

• 支持设置状态栏表格的横向、纵向滚动模式。将scroll属性设置为"auto"后，当状态栏表格的纵向行数超过20行时，内容将自动滚动显示；当横向列数超出页面显示范围时，将进行横向滚动显示。使用scroll属性可以缓解实盘运行时状态栏中因大量写入数据而导致的卡顿问题。请参考以下测试示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var tbl = {
          type : "table",
          title : "test scroll",
          scroll : "auto",
          cols : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
              "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
          rows : []
      }
  
      for (var i = 1 ; i < 100 ; i++) {
          tbl.rows.push([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
              "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
      }
  
      LogStatus("`" + JSON.stringify(tbl) + "`")
  }
  

  
      python
      
      
  import json
  
  def main():
      tbl = {
          "type" : "table",
          "title" : "test scroll",
          "scroll" : "auto",
          "cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
              "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
          "rows" : []
      }
  
      for index in range(1, 100):
          i = str(index)
          tbl["rows"].append([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
              "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
  
      LogStatus("`" + json.dumps(tbl) + "`")
  

  
      rust
      
      
  fn main() {
      let tbl_tpl = String::from(r#"{"type": "table", "title": "test scroll", "scroll": "auto", "cols": ["#)
          + r#""col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10","#
          + r#""col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20""#
          + r#"], "rows": [__ROWS__]}"#;
  
      let mut rows: Vec<String> = Vec::new();
      for index in 1..100 {
          let i = index.to_string();
          rows.push(format!(
              r#"["{}", "1,{}", "2,{}", "3,{}", "4,{}", "5,{}", "6,{}", "7,{}", "8,{}", "9,{}", "10,{}", "11,{}", "12,{}", "13,{}", "14,{}", "15,{}", "16,{}", "17,{}", "18,{}", "19,{}", "20,{}"]"#,
              i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i
          ));
      }
  
      let tbl = tbl_tpl.replace("__ROWS__", &rows.join(","));
      LogStatus!(format!("`{}`", tbl));
  }
  

  
      c++
      
      
  void main() {
      json table = R"({
          "type" : "table",
          "title" : "test scroll",
          "scroll" : "auto",
          "cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
              "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
          "rows" : []
      })"_json;
  
      for (int index = 1; index < 100; ++index) {
          std::string i = std::to_string(index);
          table["rows"].push_back({i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
              "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i});
      }
  
      LogStatus("`" + table.dump() + "`");
  }