基础说明

入门

优宽量化交易平台能够做什么？

优宽（优宽）量化交易平台是量化交易领域最专业的量化社区，在这里你可以学习、编写、分享、买卖量化策略；在线回测和使用模拟盘进行模拟交易；运行、公开、围观实盘。支持商品期货CTP/易盛API/中泰证券XTP/腾讯富途证券(美股港股)。

系列教程

电子书PDF：

书名	优宽量化交易入门	商品期货量化交易实战	纸版书籍
封面
链接	youquantquantbook.pdf	youquantcfquant.pdf	京东自营购买

视频教程：

• 平台相关的动画简介：
  优宽量化交易平台--托管者概念
  优宽量化交易平台--网站概览
  优宽量化交易平台--托管者部署简介
  优宽量化交易平台--创建实盘
  优宽量化交易平台--策略注册、复制码讲解
  优宽量化交易平台--完整策略、参数配置导入导出简介
  优宽量化交易平台--调试工具和远程编辑功能

如果遇到问题可以随时到论坛发帖提问、讨论，在平台提出工单。问题一般都会很快解答。

可用哪些编程语言实现我的策略呢？

优宽量化交易平台支持使用JavaScript、TypeScript、Python、C++、PINE、麦语言、Blockly可视化编写设计策略。

• 麦语言（Mylanguage）版本使用文档
• PINE Script 文档

支持TypeScript语言，在策略创建时依然设置为JavaScript策略，然后在策略代码开头写入// @ts-check或者点击策略编辑区域右上角的按钮「TypeScript」，即可切换到TypeScript。平台将自动识别代码为TypeScript，并为您提供相应的编译和类型检查支持：

• 类型安全：TypeScript的静态类型检查功能可以帮助您在编写代码时发现潜在的错误，提高代码质量。
• 代码自动补全：TypeScript的类型系统使得您在编写代码时可以更快地找到所需的属性和方法，提高开发效率。
• 更清晰的代码结构：使用TypeScript，您可以更好地组织和维护您的代码，使其易于阅读和理解。
• 强大的面向对象编程特性：TypeScript提供了诸如接口、类、泛型等强大的面向对象编程特性，帮助您编写更加健壮、可重用的策略代码。

这些策略设计语言中掌握其中一种就足够了。除了支持编写代码的方式设计策略，还可以使用可视化模块创建策略（Blockly）。可视化模块拼接搭建策略采用了更加直观的方式设计策略，无需编码。非常适合培养策略设计兴趣，以便快速入门程序化、量化交易。

设置Python策略程序使用的Python解释器

使用Python编写的策略，回测或实盘时如果托管者所在系统环境同时安装了Python2和Python3，可以在策略开始第一行设置策略运行时启动的Python版本。例如：#!python3，#!python2，这样系统就会自动查找解释器。也可以指定绝对路径，例如：#!/usr/bin/python3。

什么是托管者？

托管者可以理解为您的交易策略的执行者，负责复杂的数据请求、数据接收、网络链接、日志回传等等工作。托管者运行在您的服务器上，即使优宽量化交易平台网站出现网络故障也不影响您的托管者运行。托管者可运行在Linux，Windows，Mac OS，android，树莓派 ARM Linux等系统上。托管者页面，Linux托管者安装步骤及托管者更新步骤。托管者管理的实盘日志均保存在托管者程序所在目录./logs/storage内，文件为db3的Sqlite数据库文件中。可以用Sqlite管理软件直接编辑，对于这些扩展名为db3的实盘数据库文件来说文件名即为实盘的ID。

支持的协议

• 商品期货：支持CTP协议、易盛协议，支持看穿式监管。
• 股票证券：支持富途证券、中泰证券(XTP)。

策略安全性

在优宽量化交易平台上开发策略，策略仅优宽量化账户持有者可见。并且在优宽量化交易平台上可以实现策略代码完全本地化，例如把策略封装成一个Python包在策略代码中加载，这样就实现了策略本地化。

Python代码的安全性：
因为Python是开源且极易被反编译的语言，如果策略非自用而是出租，如果担心策略泄漏可让策略运行于自己布署的托管者上并以子账号或全托管管理这种形式出租。

Python策略代码加密：
默认情况下，Python策略代码作者自用时不加密，租出给他人使用时加密。在Python策略开头编辑如下代码，可以指定自用或者租出Python策略运行时是否加密策略代码。支持策略代码加密的Python版本为：Python 2.7版本、Python 3.5版本、Python 3.6版本。

• 策略作者自己运行、通过注册码给他人使用均加密策略代码：
  #!python为指定Python解释器版本，之后使用逗号,间隔，输入加密指令encrypt。如果不指定Python版本直接添加#!encrypt。

  
              python
              
              
  #!python,encrypt
  

  或者

  
              python
              
              
  #!encrypt
  

• 策略作者自己运行、通过注册码给他人使用均不加密策略代码：

  
              python
              
              
  #!python,not encrypted
  

  或者

  
              python
              
              
  #!not encrypted
  

判断Python策略代码加密是否生效使用代码os.getenv('__优宽_ENV__')，返回字符串"encrypt"说明已经生效。仅实盘有效，回测不会加密Python策略代码。

            python
            
            
#!encrypt
def main():
    ret = os.getenv('__优宽_ENV__')
    # 打印变量ret为字符串encrypt或者ret == "encrypt"为真，即代表加密生效
    Log(ret, ret == "encrypt")

密钥安全性

在优宽量化交易平台上配置的账户信息、策略参数中的加密字符串等敏感数据均在浏览器端加密。这些在优宽量化交易平台上储存的信息均为加密信息（非明文数据）。只有用户的私有设备可以解密使用，从而极大提高了敏感数据的安全性。如果在策略代码、参数设置、策略描述等信息中包含了其它敏感信息，请不要公开或者出售该策略。

回测系统

什么是回测系统，有什么用？

当您完成了一个量化交易策略的设计工作后，怎么才能知道您这个策略的逻辑、策略收益方向等基本情况？当然我们不能直接拿真金白银去交易市场上跑策略，我们可以用历史数据来测试您的策略。看看您的策略在历史数据中盈利如何。

回测系统的数据准确么，回测结果的准确度如何?

优宽量化交易平台将回测模式分为实盘级回测和模拟级回测。实盘级回测完全按照完整的历史数据回测；模拟级回测则根据真实K线数据生成tick数据来进行回测。两者都是根据真实历史数据回测的，但实盘级回测的数据更精准，结果更加可信。优宽回测机制说明。但是回测仅仅是策略在历史数据下的表现，历史数据并不能完全代表将来的行情。历史行情可能重演，也可能飞出黑天鹅。所以对待回测结果要理性、客观看待。

不同语言策略回测时应注意的问题：

JavaScript和C++策略回测是在浏览器端进行。期货公司实盘账户、simnow仿真账户配置的实盘，运行不用安装任何其它软件、库或模块。
Python回测是在托管者上进行，可以在优宽量化的公共服务器上回测，也可以在用户自己的托管者上回测。实盘和回测都依赖托管者所在系统上安装的Python，如果需要使用一些库，需要自行安装（公共服务器上只支持常用的库）。

回测系统中的数据

优宽量化交易平台回测分模拟级回测和实盘级回测两种，模拟级回测根据底层K线周期生成模拟的tick，每个底层K线周期上将生成12个回测时间点，而实盘级则是真实收集的tick，大约几秒就有一次，数据量很大，回测速度慢，因此不能回测特别长的时间。优宽的回测机制可以使策略在一根K线上交易多次，避免了只能收盘价成交的情况，更加精准又兼顾了回测速度。具体的说明可参考，链接。

回测系统中支持的交易所

• 期货证券
  商品期货：支持大商所、郑商所、上期所、中金所期货数据，暂时不支持商品期权数据。
  股票证券：暂时仅支持有限的数据，股票目前仅支持K线的日线级别的回测数据。

模拟级别

模拟级别回测是根据回测系统的底层K线数据，按照一定算法在给定的底层K线Bar的最高价、最低价、开盘价、收盘价的数值构成的框架内模拟出tick数据，作为实时tick数据在请求接口时返回。具体可以参考：优宽量化模拟级别回测机制说明。

实盘级别

实盘级别回测是真实的tick级别数据在Bar的时间序列中。对于基于tick级别数据的策略来说，使用实盘级别回测更贴近真实。实盘级别回测tick是真实记录的数据，并非模拟生成。支持深度数据、市场成交记录数据回放，支持自定义深度，支持分笔数据。实盘级别回测数据最大支持50MB，在数据上限内不限制回测时间范围，如果需要尽可能增大回测时间范围，可以降低深度档位数值设置，不使用分笔数据以增加回测时间范围。调用GetDepth、GetTrades函数获取回放行情数据。在时间轴上某个行情数据时刻，调用GetTicker，GetTrades，GetDepth，GetRecords，不会多次推动时间在回测时间轴上移动（不会触发跳到下一个行情数据时刻）。对于以上某个函数重复调用，将推动回测时间在回测时间轴上移动（跳到下一个行情数据时刻）。回测时使用实盘级别回测不宜选择过早时间，可能过早时间段没有实盘级别数据。

实盘级别回测目前支持：

• 商品期货

回测系统参数调优

优宽量化交易平台回测系统参数调优功能是在回测时根据各个参数的调优选项设置调优，如下：

• 最小值：限定参数的起始值。

• 最大值：限定参数递增变动后的最大值。

• 步长：参数递增变动量。

生成参数组合，遍历这些参数组合进行回测（即每种参数组合都回测一遍）。策略参数只有类型为 数字型（number） 的参数才可以在回测系统中进行参数调优。

例如，在回测页面设置参数调优选项：

参数调优模式回测：

保存回测设置

在策略编辑页面，「模拟回测」分页中（即：回测系统）可以设置回测配置、策略参数等选项进行策略回测。回测配置是用来设置回测时间范围、回测的交易所、回测时滑点、手续费等条件；策略参数则是设置策略的参数选项。当设置好这些参数配置时便可按照设定回测策略，那么如何保存这些设置好的配置信息呢？方便下一次回测时使用（页面刷新回测时设置的选项会重置）。可以使用策略编辑页面的「保存回测设置到源文件」按钮将所有回测配置信息（包含回测设置、策略参数设置）以代码形式记录在策略源码中。再次打开策略编辑页面切换到回测系统时策略代码中记录的回测配置信息会自动配置在回测页面。

以JavaScript策略为例，点击「保存回测设置到源文件」：

JavaScript/Python/C++/麦语言保存回测设置到源文件格式略有差别：

            javascript
            
            
/*backtest
start: 2021-09-25 09:00:00
end: 2021-10-24 15:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_CTP","currency":"FUTURES"}]
*/

            python
            
            
'''backtest
start: 2021-09-25 09:00:00
end: 2021-10-24 15:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_CTP","currency":"FUTURES"}]
'''

            c++
            
            
/*backtest
start: 2021-09-25 09:00:00
end: 2021-10-24 15:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_CTP","currency":"FUTURES"}]
*/

麦语言：

            javascript
            
            
(*backtest
start: 2021-09-25 09:00:00
end: 2021-10-24 15:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_CTP","currency":"FUTURES"}]
*)

自定义数据源

系统用GET方法请求自定义的URL（可公开可访问的网址）来获取外部数据源进行回测，附加的请求参数如下：

注意：

            text
            
            
round与vround是为了避免网络传输过程中浮点数的精度丢失设计的两个参数，价格数据和成交量、订单量数据都采用整型传输。

一个拼接后的数据的例子：

            text
            
            
http://customserver:80/data?symbol=futures.MA888&eid=Futures_CTP&round=3&vround=3&period=900000&from=1564315200&to=1567267200

返回的格式必须为以下两种格式（可返回任意两种格式，系统自动识别）：

普通的Bar级别回测

            javascript
            
            
{
    "schema":["time","open","high","low","close","vol"],
    "data":[[1564315200000,9531300,9531300,9497060,9497060,787],[1564316100000,9495160,9495160,9474260,9489460,338]]
}

Tick级回测的数据（包含盘口深度信息, 深度格式为[价格,量]的数组, 可有多级深度, asks为价格升序, bids为价格倒序）

            javascript
            
            
{
    "schema":["time","asks", "bids","trades","close","vol"],
    "data":[[1564315200000,[[9531300,10]], [[9531300,10]],[[1564315200000,0,9531300,10]],9497060,787]]
}

说明

detail字段

数据格式

自定义数据源范例：

指定数据源，网址：http://xxx.xx.x.xx:9090/data
自定义数据服务端，使用golang编写：

            mylang
            
            
package main 
import (
    "fmt"
    "net/http"
    "encoding/json"
)

func Handle (w http.ResponseWriter, r *http.Request) {
    // e.g. set on backtest DataSourse: http://xxx.xx.x.xx:9090/data
    // r.URL: /data?depth=20&detail=true&eid=Futures_CTP&from=1566820800&period=900000&round=3&symbol=futures.MA888&to=1569686400&trades=1&vround=5
    // response
    defer func() {
        // response data
        /* e.g. data
        {
            "schema":["time","open","high","low","close","vol"],
            "data":[
                [1564315200000,9531300,9531300,9497060,9497060,787],
                [1564316100000,9495160,9495160,9474260,9489460,338]
            ]
        }
        */
        ret := map[string]interface{}{
            "schema" : []string{"time","open","high","low","close","vol"},
            "data" : []interface{}{
                []int64{1564315200000,9531300,9531300,9497060,9497060,787},
                []int64{1564316100000,9495160,9495160,9474260,9489460,338},
            },
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()
}

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

测试策略，JavaScript范例：

            javascript
            
            
/*backtest
start: 2019-07-28 00:00:00
end: 2019-07-29 00:00:00
period: 1m
exchanges: [{"eid":"Futures_CTP","currency":"FUTURES","feeder":"http://120.24.2.20:9090/data"}]
*/

function main() {
    // 对于测试代码，我们通过判断exchange.IO("status")函数，连接成功之后执行测试代码，区别于商品期货策略一般架构
    while(!exchange.IO("status")) {
        Sleep(1000)
    }
    // 设置合约为MA888
    exchange.SetContractType("MA888")
    // 获取ticker数据
    var ticker = exchange.GetTicker()
    // 获取records数据，即K线数据
    var records = exchange.GetRecords()
    // 打印数据
    Log(ticker)
    Log(records)
}

回测系统中自定义的数据画出的图表：

策略打印信息：

本地回测引擎

优宽量化交易平台开源了JavaScript语言和Python语言的本地回测引擎，支持回测时设置底层K线周期。

• JavaScript语言回测引擎

• Python语言回测引擎

回测页面快捷键

• 策略编辑页面和策略回测页面切换的快捷键

  

  使用Ctrl + ,键，切换回测页面和策略编辑页面，按住Ctrl键后，单按,键。

• 策略保存的快捷键

  

  使用Ctrl + s键，保存策略。

• 启动回测的快捷键

  

  使用Ctrl + b键，启动回测。

代码说明

入口函数

• 说明：
  • 回测系统不支持onerror()函数。
  • 在实盘时先触发了onerror()函数，就不会再触发onexit()函数。

onexit()

onexit()，处理扫尾工作，最长执行5分钟，由用户实现。

            javascript
            
            
function main(){
    Log("开始运行, 5秒后停止，并执行扫尾函数！")
    Sleep(1000 * 5)
}

// 扫尾函数实现
function onexit(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    var beginTime = new Date().getTime()
    while(true){
        var nowTime = new Date().getTime()
        Log("程序停止倒计时..扫尾开始，已经过去：", (nowTime - beginTime) / 1000, "秒！")
        Sleep(1000)
    }
}

            python
            
            
import time 
def main():
    Log("开始运行, 5秒后停止，并执行扫尾函数！")
    Sleep(1000 * 5)

def onexit():
    beginTime = time.time() * 1000
    while True:
        ts = time.time() * 1000
        Log("程序停止倒计时..扫尾开始，已经过去：", (ts - beginTime) / 1000, "秒！")
        Sleep(1000)

            c++
            
            
void main() {
    Log("开始运行, 5秒后停止，并执行扫尾函数！");
    Sleep(1000 * 5);
}

void onexit() {
    auto beginTime = Unix() * 1000;
    while(true) {
        auto ts = Unix() * 1000;
        Log("程序停止倒计时..扫尾开始，已经过去：", (ts - beginTime) / 1000, "秒！");
        Sleep(1000);
    }
}

init()

init()，用户实现初始化函数init()，策略开始运行时首先自动执行init()函数，完成策略中设计的初始化任务。

            javascript
            
            
function main(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    Log("程序第一行代码执行！", "#FF0000")
    Log("退出！")
}

// 初始化函数
function init(){     
    Log("初始化！")
}

            python
            
            
def main():
    Log("程序第一行代码执行！", "#FF0000")
    Log("退出！")

def init():
    Log("初始化！")

            c++
            
            
void main() {
    Log("程序第一行代码执行！", "#FF0000");
    Log("退出！");
}

void init() {
    Log("初始化！");
}

onerror()

onerror()，发生异常时会触发onerror()函数执行，该函数不支持Python、C++语言的策略。

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

function onerror() {
    Log("错误")
}

            python
            
            
# python不支持

            c++
            
            
// C++不支持

经典策略框架

在JavaScript、Python、C++语言编写的策略中需要在策略主循环中调用Sleep()函数。回测时用于控制回溯的速度，实盘时用于控制策略轮询的时间间隔，从而控制访问交易所API接口的请求频率。

• 经典的商品期货策略架构：

  • Javascript
  • Python
  • C++

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

  
              python
              
              
  def main():
      while True:
          if exchange.IO("status"):
              exchange.SetContractType("MA000")
              ticker = exchange.GetTicker()
              Log("MA000 ticker:", ticker)
              LogStatus(_D(), "已经连接CTP ！")
          else:
              LogStatus(_D(), "未连接CTP ！")
  

  
              c++
              
              
  void main() {
      while(true) {
          if(exchange.IO("status") == 1) {
              exchange.SetContractType("MA000");
              auto ticker = exchange.GetTicker();
              Log("MA000 ticker:", ticker);
              LogStatus(_D(), "已经连接CTP ！");
          } else {
              LogStatus(_D(), "未连接CTP ！");
          }
      }
  }
  

模板类库

模板类库是优宽量化交易平台中可复用的代码模块，是策略代码的一种类别。创建策略时如果类别设置为模板类库，则创建一个模板类库在优宽量化交易平台当前登录的账号策略库中，创建后无法再修改类别为普通策略。

JavaScript语言模板类库：

Python语言模板类库：

C++语言模板类库：

• 模板类库的导出函数

  导出函数为模板类库的接口函数，可以被引用该模板类库的策略调用。导出函数在模板类库中声明以及实现的例子代码如下：

  • Javascript
  • Python
  • C++

  
              javascript
              
              
  /*
  -- 策略引用该模板以后直接用 $.Test() 调用此方法
  -- main 函数在策略中不会触发, 只做为模板调试的入口
  */
  $.Test = function() {
      Log('Test')
  }
  
  function main() {
      $.Test()
  }
  

  
              python
              
              
  def Test():
      Log("template call")
  
  # 导出Test函数, 主策略可以通过ext.Test()调用
  ext.Test = Test 
  

  
              c++
              
              
  // 策略引用该模板以后直接用 ext::Test() 调用此方法
  void Test() {
      Log("template call");
  }
  

• 模板类库的参数
  模板类库也可以设置自己的界面参数，模板类库的参数在模板类库代码中是以全局变量的形式使用的。

  模板类库设置参数：

  

  模板类库代码：

  • Javascript
  • Python
  • C++

  
              javascript
              
              
  $.SetParam1 = function(p1) {
      param1 = p1
  }
  
  $.GetParam1 = function() {
      Log("param1:", param1)
      return param1
  }
  

  
              python
              
              
  def SetParam1(p1):
      global param1
      param1 = p1
  
  def GetParam1():
      Log("param1:", param1)
      return param1
  
  ext.SetParam1 = SetParam1
  ext.GetParam1 = GetParam1
  

  
              c++
              
              
  void SetParam1(float p1) {
      param1 = p1;
  }
  
  float GetParam1() {
      Log("param1:", param1);
      return param1;
  }
  

  引用以上模板类库例子的策略代码：

  • Javascript
  • Python
  • C++

  
              javascript
              
              
  function main () {
      Log("调用$.GetParam1:", $.GetParam1())
      Log("调用$.SetParam1:", "#FF0000")
      $.SetParam1(20)
      Log("调用$.GetParam1:", $.GetParam1())
  }
  

  
              python
              
              
  def main():
      Log("调用ext.GetParam1:", ext.GetParam1())
      Log("调用ext.SetParam1:", "#FF0000")
      ext.SetParam1(20)
      Log("调用ext.GetParam1:", ext.GetParam1())
  

  
              c++
              
              
  void main() {
      Log("调用ext::GetParam1:", ext::GetParam1());
      Log("调用ext::SetParam1:", "#FF0000");
      ext::SetParam1(20);
      Log("调用ext::GetParam1:", ext::GetParam1());
  }
  

  

• 引用模板类库

  在策略编辑页面模板栏中勾选引用后，保存策略即可。

  

内置结构

全局变量

exchange

exchange可视为一个交易所对象，默认为策略参数中添加的第一个交易所对象。所有与交易所的交互都通过这个对象里面的函数实现。一个交易所对象绑定一个期货账户。

• 回测添加交易所对象

  

• 实盘页面添加交易所对象

  

添加的交易所对象就对应代码中的exchange对象：

            javascript
            
            
function main() {
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel())
}

            python
            
            
def main():
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel())

            c++
            
            
void main() {
    Log("实盘页面或者回测页面上，添加的第一个交易所对象名字：", exchange.GetName(), "，标签：", exchange.GetLabel());
}

exchanges

可以理解为储存如同exchange交易所对象的所有交易所对象的数组，可能包含多个交易所对象，exchanges[0]即是exchange。

添加的交易所对象对应策略代码中的exchanges[0]、exchanges[1]、exchanges[2]、... ，以此类推。

            javascript
            
            
function main() {
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    for(var i = 0; i < exchanges.length; i++) {
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel())
    }
}

            python
            
            
def main():
    for i in range(len(exchanges)):
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel())

            c++
            
            
void main() {
    for(int i = 0; i < exchanges.size(); i++) {
        Log("添加的交易所对象索引(第一个为0以此类推)：", i, "名称：", exchanges[i].GetName(), "标签：", exchanges[i].GetLabel());
    }
}

订单状态

Order结构中的Status属性。

ORDER_STATE_UNKNOWN状态，可以调用exchange.GetRawJSON()获取原始订单状态信息，查询交易所文档，查看具体描述。
表格中的常量名可以直接在策略代码中用于和Order结构的Status属性比较、判断是否相等从而确定订单状态。打印这些常量名会显示这些常量名对应的值，以下其它常量名同理不再赘述。

订单买卖类型

Order结构中的Type属性。

仓位类型

Position结构中的Type属性。

期货开平仓方向

Order结构中的Offset属性。

策略参数

在策略代码中策略界面上设置的策略参数，是以全局变量形式体现的。JavaScript语言中可以直接访问策略界面上设置的参数数值或者修改，Python策略的函数中修改全局变量时需要使用global关键字。

参数种类：

• 界面参数，在策略编辑页面代码编辑区下方策略参数区设置。
• 界面参数在策略代码中是以全局变量形式存在的，也就是说可以在代码中修改界面参数。
• 界面参数在策略代码中的变量名：即上图中的number、string、combox、bool、secretString。
• 描述选项：界面参数在策略界面上的名字。
• 备注选项：界面参数的详细描述，该描述会在鼠标停留在界面参数上时相应的显示出。
• 类型选项：该界面参数的类型。
• 默认值选项：该界面参数的默认值。

参数依赖设置：

可以设置一个参数，让另一个参数基于该参数的选择实现显示与隐藏。比如我们设置参数numberA，是一个数值类型。我们让numberA基于一个参数：isShowA(布尔类型)的真假决定numberA显示与隐藏。需要把numberA变量在界面参数上设置为：numberA@isShowA。

这样不勾选isShowA参数，numberA参数就隐藏了。对于下拉框控件类型的参数，参数依赖部分为判断是否等于下拉框某个选项的索引值。同样以isShowA参数为例，在参数设置变量时写为：numberA@combox==2。numberA参数就基于combox参数是否选择为第三个选项进行显示或隐藏（索引0对应第一个选项，索引1对应第二个选项，索引2对应第三个选项）。

策略界面参数、交互控件、模板上的参数分组功能：
只用在开始分组的参数的描述开头加上 (?第一组)即可，例如下图。

在策略使用时会分组显示参数：

参数默认值保存：
策略参数如图，在回测时如果希望将策略参数默认值保存，可以在策略参数修改后点击保存回测设置按钮。

即可将设置后的策略参数以代码形式保存在策略中：

            javascript
            
            
/*backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",10],["string","Hello 优宽"],["combox",1],["bool",false]]
*/

            python
            
            
'''backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",10],["string","Hello 优宽"],["combox",1],["bool",false]]
'''

            c++
            
            
/*backtest
start: 2020-02-29 00:00:00
end: 2020-03-29 00:00:00
period: 1d
args: [["number",10],["string","Hello 优宽"],["combox",1],["bool",false]]
*/

数据结构

部分函数会附带在调用时请求返回的原始JSON数据，该原始JSON数据储存在返回对象的Info属性中。回测时由于并不是访问某个交易所的接口，所以回测时返回的数据中无Info属性，以下是各个数据结构的主要属性描述。

Trade

获取所有交易历史（非自己），由exchange.GetTrades()函数返回。商品期货、股票证券不支持该函数。

            javascript
            
            
{
    Id      : 9585306,          // 交易记录ID
    Time    : 1567736576000,    // 时间(Unix timestamp 毫秒)
    Price   : 1000,             // 价格
    Amount  : 1,                // 数量
    Type    : 0                 // 订单类型,参考常量里的订单类型,0即为ORDER_TYPE_BUY，ORDER_TYPE_BUY的值为0
}

Ticker

市场行情由exchange.GetTicker()函数返回。

            javascript
            
            
{
    Info    : {...},             // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    High    : 1000,              // 最高价
    Low     : 500,               // 最低价
    Sell    : 900,               // 卖一价
    Buy     : 899,               // 买一价
    Last    : 900,               // 最后成交价
    Volume  : 10000000,          // 最近成交量
    Time    : 1567736576000      // 毫秒级别时间戳
}

Record

标准的OHLC结构，用来画K线和指标计算分析。由exchange.GetRecords()函数返回此结构的数组。每一个Record结构代表一个K线柱，即一根K线BAR。Record其中的Time为这根K线柱周期的起始时间。

            javascript
            
            
{
    Time    : 1567736576000,     // 一个时间戳，精确到毫秒，与Javascript的new Date().getTime()得到的结果格式一样
    Open    : 1000,              // 开盘价
    High    : 1500,              // 最高价
    Low     : 900,               // 最低价
    Close   : 1200,              // 收盘价
    Volume  : 1000000            // 交易量
}

Order

订单结构，可由exchange.GetOrder()、exchange.GetOrders()函数返回。exchange.GetOrders()返回的是该结构的数组或者空数组（如果没有当前未完成的订单，返回[]，即空数组）。

            javascript
            
            
{
    Info        : {...},         // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    Id          : 123456,        // 交易单唯一标识
    Price       : 1000,          // 下单价格
    Amount      : 10,            // 下单数量
    DealAmount  : 10,            // 成交数量
    AvgPrice    : 1000,          // 成交均价
    Status      : 1,             // 订单状态，参考常量里的订单状态ORDER_STATE_CLOSED
    Type        : 0,             // 订单类型，参考常量里的订单类型ORDER_TYPE_BUY
    Offset      : 0              // 商品期货的订单数据中，订单的开平仓方向，ORDER_OFFSET_OPEN为开仓，ORDER_OFFSET_CLOSE为平仓方向
    ContractType : ""            // 该属性为具体的合约代码
}

MarketOrder

市场深度单，即exchange.GetDepth()函数返回数据中Bids、Asks数组中的元素的数据结构。

            javascript
            
            
{
    Price   : 1000,              // 价格
    Amount  : 1                  // 数量
}

Depth

市场深度，由exchange.GetDepth()函数返回。

            javascript
            
            
{
    Asks    : [...],             // 卖单数组，MarketOrder数组,按价格从低向高排序
    Bids    : [...],             // 买单数组，MarketOrder数组,按价格从高向低排序
    Time    : 1567736576000      // 毫秒级别时间戳
}

Account

账户信息，由exchange.GetAccount()函数返回。

            javascript
            
            
{
    Info            : {...},     // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    Balance         : 1000,      // 可用余额
    FrozenBalance   : 0,         // 挂单冻结的余额
    Stocks          : 1,         // 传统期货、股票证券此属性固定为0
    FrozenStocks    : 0          // 传统期货、股票证券此属性固定为0
}

Position

期货交易中持有的仓位信息，由exchange.GetPosition()函数返回此Position结构的数组。

            javascript
            
            
{
    Info            : {...},     // 请求交易所接口后，交易所接口应答的原始数据，回测时无此属性
    MarginLevel     : 10,        // 杆杠大小，商品期货无法修改杠杆值
    Amount          : 100,       // 持仓量
    FrozenAmount    : 0,         // 挂单平仓时，仓位冻结量
    Price           : 10000,     // 持仓均价
    Profit          : 0,         // 股票不支持此字段，商品期货为盯市盈亏
    // CTP中用closebuy_today平今多头仓位，对应的Type属性为PD_LONG；用closesell_today平今空头仓位，对应的Type属性为PD_SHORT；用closebuy平昨多头仓位，对应的Type属性为PD_LONG_YD；用closesell平昨空头仓位，对应的Type属性为PD_SHORT_YD
    Type            : 0,
    ContractType    : "rb2201",  // 合约代码、股票代码
    Margin          : 1          // 仓位占用的保证金
}

全局函数

Version()

Version()，返回系统当前版本号。返回值：字符串类型。

Sleep(Millisecond)

Sleep(Millisecond)，休眠函数，使程序暂停一段时间。参数值：Millisecond为数值类型。参数为毫秒数，例如：Sleep(1000)为休眠1秒。
支持休眠时间小于1毫秒的操作，例如设置Sleep(0.1)。支持最小参数为0.000001，纳秒级休眠。1纳秒等于1e-6毫秒。

注意：
在使用Python语言编写策略时，对于轮询间隔、时间等待的操作应当使用Sleep(Millisecond)函数。不建议使用Python的time库的time.sleep(second)函数。因为策略中使用time.sleep(second)函数在回测时会让策略程序实际等待一定秒数（second参数为设置暂停的秒数），导致策略回测非常慢。

IsVirtual()

IsVirtual()，判断当前策略运行是否为模拟回测。返回值：布尔类型。
模拟回测状态返回true，实盘返回false。

Mail(...)

Mail(smtpServer, smtpUsername, smtpPassword, mailTo, title, body)，发送邮件函数。参数值：参数全部为字符串类型。返回值：布尔类型，发送成功返回true。
smtpServer为发送邮箱smtp服务，smtpUsername为邮箱账号，smtpPassword为邮箱的SMTP密码（不是邮箱登录密码），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")

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

• Mail函数的异步版本Mail_Go函数：
  使用方式和exchange.Go函数类似。

  • Javascript
  • Python
  • C++

  
              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++
              
              
  // 不支持
  

注意：
阿里云服务器可能会封一些端口，导致邮件无法发出。如需更改端口，可以直接在第一个参数中加入端口号，例如：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。

SetErrorFilter(...)

SetErrorFilter(RegEx)，过滤错误日志。参数值：字符串类型。
被此正则表达式匹配的错误日志将不上传到日志系统，可多次调用设置多个过滤条件（被过滤的日志不写入托管者目录下对应实盘ID的数据库文件，防止频繁报错导致数据库文件膨胀）。

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

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

过滤某个接口错误信息：

            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)
    // 过滤http502错误、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)

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

GetPid()

GetPid()，返回实盘进程ID。返回值：字符串类型。

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

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

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

GetLastError()

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)

            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()，获取交互命令字符串(utf-8)。获取策略交互界面发来的命令并清空缓存，没有命令则返回空字符串。返回的命令格式为按钮名称:参数，如果交互控件没有参数（例如不带输入框的按钮控件）则命令就是按钮名称。

            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)

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

底层系统有一个队列结构记录交互命令，当GetCommand()函数被调用时，会取出队列中最先进入的交互命令（如果没有交互命令时返回空字符串）。

交互控件的使用例子，策略编辑界面设置交互控件。

策略中设计交互代码：

            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)

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

GetMeta()函数返回生成策略注册码时写入的Meta的值，该函数返回值为字符串类型。
应用场景，例如策略需要对不同租户做资金限制。注意：生成注册码时Meta的长度不能超过190字符，该函数仅适用于实盘，需要使用最新的托管者。如果生成策略注册码时没有设置元数据GetMeta()返回空值。

Dial(...)

Dial(Address, Timeout)，原始的Socket访问，支持tcp，udp，tls，unix协议。参数值：Address为字符串类型，TimeOut为数值类型，数值单位为秒，如果超时Dial(...)函数返回空值。

Address参数详细说明：

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

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

read函数支持以下参数:

• 不传参数时，阻塞到有消息时就返回。例如：ws.read()。
• 传入参数时，单位为毫秒，指定消息等待超时时间。例如：ws.read(2000)指定超时时间为两秒（2000毫秒）。
• 以下两个参数只对websocket有效：
  传入参数-1指不管有无消息，函数立即返回，例如：ws.read(-1)。
  传入参数-2指不管有无消息，函数立即返回，但只返回最新的消息，缓冲区的消息会被丢弃。例如ws.read(-2)。

read()函数缓冲区说明：
ws协议推送的来的数据，如果在策略read()函数调用之间时间间隔过长，就可能造成数据累积。这些数据储存在缓冲区，缓冲区数据结构为队列，上限2000个。超出2000后，最新的数据进入缓冲区，最旧的数据清除掉。

HttpQuery(...)

HttpQuery(Url, PostData, Cookies, Headers, IsReturnHeader)，网络URL访问。参数值：全部为字符串类型。
返回值为JSON字符串，JavaScript语言的策略中可以用JSON.parse()函数解析。

注意：

• HttpQuery(...)函数只支持JavaScript语言。
• Python语言可以使用urllib库，直接发送http请求。

获取一个Url的返回内容，如果第二个参数PostData为字符串a=1&b=2&c=abc形式，就以POST方式提交。其它例如PUT等方式提交，PostData参数为{method:'PUT', data:'a=1&b=2&c=abc'}。
PostData参数也可以是JSON字符串。

Cookies这个参数形式为：a=10; b=20，各参数用分号;间隔。
Headers这个参数形式为：User-Agent: Mobile\nContent-Type: text/html各参数用换行符\n间隔。

第二个参数PostData可以自定义方法比如：
HttpQuery("http://www.abc.com", {method:'PUT', data:'a=1&b=2&c=abc'})，注意：如果需要给HttpQuery函数设置超时时间，可以在{method:'PUT', data:'a=1&b=2&c=abc'}加入timeout属性（默认60秒）。

设置1秒钟超时：
HttpQuery("http://www.abc.com", {method:'PUT', data:'a=1&b=2&c=abc', timeout:1000})

传递Cookie字符串需要第三个参数，但不需要POST请将第二个参数置为空值。模拟测试的时候因为无法模拟访问URL，函数就返回固定字符串Dummy Data。可以用此接口发送短信，或者与其它API接口进行交互。

GET方法调用例子：HttpQuery("http://www.baidu.com")。
POST方法调用例子：HttpQuery("http://www.163.com", "a=1&b=2&c=abc")。

返回Header的调用例子：

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

• HttpQuery函数使用代理设置：

  • Javascript
  • Python
  • C++

  
              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库
  

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

• HttpQuery函数的异步版本HttpQuery_Go：
  使用方式和exchange.Go函数类似。

  • Javascript
  • Python
  • C++

  
              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++
              
              
  // 不支持
  

• 回测系统中使用HttpQuery(...)函数：
  回测系统中可以使用HttpQuery(...)发送请求（只支持GET请求）获取数据。回测时限制使用20次访问不同的URL，并且HttpQuery(...)访问会缓存数据，相同的URL第二次访问时HttpQuery(...)函数返回缓存数据（不再发生实际网络请求）。

  我们可以在某个服务器或者设备上运行一个服务程序，用来响应策略程序中HttpQuery(...)发送的请求，测试用的Go语言服务程序如下：

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

  策略回测时使用HttpQuery(...)函数发送请求：

  • Javascript
  • Python
  • C++

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

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

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

  

• 支持对请求的应答数据进行转码，支持常用编码。
  指定PostData参数：{method: "GET",charset:"GB18030"}，即可实现应答的数据转码（GB18030）。

Hash(...)

Hash(Algo, OutputAlgo, Data)，支持md5/sha256/sha512/sha1的哈希计算，只支持实盘。参数值：全部为字符串类型。
第二个参数可设置为raw/hex/base64，分别指输出加密后的原始内容/hex编码过的数据/base64编码过的数据。

            javascript
            
            
function main(){
    Log(Hash("md5", "hex", "hello"))
    Log(Hash("sha512", "base64", "hello"))
}

            python
            
            
def main():
    Log(Hash("md5", "hex", "hello"))
    Log(Hash("sha512", "base64", "hello"))

            c++
            
            
void main() {
    Log(Hash("md5", "hex", "hello"));
    Log(Hash("sha512", "base64", "hello"));
}

HMAC(...)

HMAC(Algo, OutputAlgo, Data, Key)，支持md5/sha256/sha512/sha1的HMAC加密计算，只支持实盘。参数值：全部为字符串类型。
第二个参数可设置为raw/hex/base64，分别指输出加密后的原始内容/hex编码过的数据/base64编码过的数据。

            javascript
            
            
function main(){
    Log(HMAC("md5", "hex", "hello", "pass"))
    Log(HMAC("sha512", "base64", "hello", "pass"))
}

            python
            
            
def main():
    Log(HMAC("md5", "hex", "hello", "pass"))
    Log(HMAC("sha512", "base64", "hello", "pass"))

            c++
            
            
void main() {
    Log(HMAC("md5", "hex", "hello", "pass"));
    Log(HMAC("sha512", "base64", "hello", "pass"));
}

UnixNano()

UnixNano()，返回纳秒级时间戳，如果需要获取毫秒级时间戳，可以使用如下代码：

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

            python
            
            
def main():
    time = UnixNano()
    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)

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

GetOS()

GetOS()，返回托管者所在系统的信息。

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

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

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

在苹果电脑Mac OS操作系统下运行的托管者日志输出：

GetOS:darwin/amd64

darwin即Mac OS系统的名称。

MD5(String)

MD5(String)，参数值：字符串类型。

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

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

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

日志输出：

MD5 5eb63bbbe01eeed093cb22bb8f5acdc3

DBExec(...)

DBExec()，参数值：可以是字符串、数值、布尔值、空值等类型。返回值：包含SQLite语句执行结果的对象。
数据库接口函数DBExec()通过传入参数，可以操作实盘数据库（SQLite数据库）。实现对实盘数据库中数据的增、删、查、改等操作，支持SQLite语法。实盘数据库中系统保留表：kvdb、cfg、log、profit、chart，切勿对这些表进行操作。注意：DBExec()函数只支持实盘。

• 支持内存数据库
  对于DBExec函数的参数，如果sql语句是以:开头，则在内存数据库中操作，不写文件，速度更快。适合不需要持久化保存的数据库操作，例如：

  • Javascript
  • Python
  • C++

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

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

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

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

内置函数

_G(K, V)

_G(K, V)，该函数实现了一个可保存的全局字典功能，回测和实盘均支持。回测结束后，保存的数据会被清除。
数据结构为KV表，永久保存在本地文件，每个实盘单独一个数据库，重启或者托管者退出后一直存在。K必须为字符串，不区分大小写，V可以为任何可以JSON序列化的内容。在实盘运行中当调用_G()函数并且不传任何参数时，_G()函数返回当前实盘的ID。

            javascript
            
            
function main(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    // 设置一个全局变量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()

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

注意：
使用_G函数持久化储存数据时，应当根据硬件设备的内存、硬盘空间合理使用，不可滥用。否则可能造成内存溢出的问题。

_D(Timestamp, Fmt)

_D(Timestamp, Fmt)，返回指定时间戳对应的时间字符串。参数值：Timestamp为数值类型，值为毫秒数。Fmt为字符串类型，Fmt默认为：yyyy-MM-dd hh:mm:ss，返回值：字符串类型。
返回指定时间戳（毫秒）对应的字符串，不传任何参数就返回当前时间。例如：_D()或者_D(1478570053241)，默认格式为yyyy-MM-dd hh:mm:ss。

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

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

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

注意：
Python策略中使用_D()时，需要注意传入的参数为秒级别时间戳（JavaScript、C++策略中为毫秒级别时间戳，1秒等于1000毫秒）。
在实盘时使用_D()函数解析一个时间戳为可读的时间字符串时，需要注意托管者程序所在的操作系统的时区、时间设置。_D()函数解析一个时间戳为可读时间字符串是根据托管者系统的时间而定的。

例如一个时间戳为1574993606000使用代码解析：

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

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

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

_N(Num, Precision)

_N(Num, Precision)，格式化一个浮点数。参数值：Num为数值类型，Precision为整型。返回值：数值类型。

例如_N(3.1415, 2)将删除3.1415小数点两位以后的值，函数返回3.14。

            javascript
            
            
function main(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    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)

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

如果需要将小数点左边的N个位数都变为0，可以这么写：

            javascript
            
            
function main(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    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)

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

_C(...)

_C(function, args...)，该函数为重试函数，用于获取行情、获取未完成订单等接口的容错。

该接口会一直调用指定函数直到成功返回（参数function引用的函数调用时返回空值或者false会重试调用）。例如_C(exchange.GetTicker)，默认重试间隔为3秒，可以调用_CDelay(...)函数来设置重试间隔，例如_CDelay(1000)，指改变_C函数重试间隔为1秒。

对于以下函数：

• exchange.GetTicker()
• exchange.GetDepth()
• exchange.GetTrades()
• exchange.GetRecords()
• exchange.GetAccount()
• exchange.GetOrders()
• exchange.GetOrder()
• exchange.GetPosition()

都可以通过_C(...)函数来调用进行容错。_C(function, args...)函数不局限于以上列出的函数容错，参数function是函数引用并非函数调用，注意是_C(exchange.GetTicker)并不是_C(exchange.GetTicker())。

            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)

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

对于有参数的函数使用_C(...)容错时：

            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)

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

    exchange.SetContractType("rb888");

    auto records = _C(exchange.GetRecords, PERIOD_D1);
    Log(records);
}

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

            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)

            c++
            
            
// C++ 不支持这种方式对于自定义函数容错

_Cross(Arr1, Arr2)

_Cross(Arr1, Arr2)，返回数组arr1与arr2的交叉周期数。正数为上穿周期，负数表示下穿的周期，0指当前价格一样。参数值：数值类型数组。

可以模拟一组数据测试_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]
function main(){
    // 不使用接口获取数据的测试，就无需使用exchange.IO("status")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试
    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))

            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分析及使用说明

JSONParse(strJson)

JSONParse(strJson)，该函数用于解析JSON字符串。可以正确解析包含有较大数值的JSON字符串，会将较大的数值解析为字符串类型。回测系统不支持该函数。

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

            python
            
            
import json

def main():
    s1 = '{"num": 8754613216564987646512354656874651651358}'
    Log("json.loads:", json.loads(s1))    # json.loads: map[num:8.754613216564987e+39]
    Log("JSONParse:", JSONParse(s1))      # JSONParse:  map[num:8754613216564987646512354656874651651358]
    
    s2 = '{"num": 123}'
    Log("json.loads:", json.loads(s2))    # json.loads: map[num:123]
    Log("JSONParse:", JSONParse(s2))      # JSONParse:  map[num:123]

            c++
            
            
void main() {
    auto s1 = "{\"num\":8754613216564987646512354656874651651358}";
    Log("json::parse:", json::parse(s1));
    // Log("JSONParse:", JSONParse(s1));   // 不支持该函数
    
    auto s2 = "{\"num\":123}";
    Log("json::parse:", json::parse(s2));
    // Log("JSONParse:", JSONParse(s2));   // 不支持该函数
}

自定义颜色

每个消息字符串都可以用#ff0000这样的RGB值结尾，代表需要显示的前景色。如果为#ff0000112233这样的格式，则后六位代表背景色。

颜色十六进制图：

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

            python
            
            
def main():
    Log("红色", "#FF0000")

            c++
            
            
void main() {
    Log("红色", "#FF0000");
}

日志信息

实盘运行时日志信息记录在实盘的数据库中，实盘的数据库采用sqlite3数据库，实盘的数据库文件在托管者程序所在设备，数据库文件在托管者程序（robot可执行程序）目录下。例如：ID为130350的实盘数据库文件在../logs/storage/130350这个目录内（..即为robot托管者程序所在目录），数据库文件名为130350.db3。
回测系统中的日志可以在回测结束后，点击回测页面底部右下角的[下载日志]按钮进行下载。
当需要迁移实盘到其它服务器上的托管者时，可以移动实盘的数据库文件（扩展名为db3的数据库文件）到迁移目标服务器上，把文件名设置为平台上对应的实盘ID。这样之前实盘的所有日志信息就不会因为迁移到新设备而丢失。

Log(...)

Log(message)，保存一条信息到日志列表。参数值：message可以是任意类型。
如果在字符串后面加上@字符则消息会进入推送队列，推送到当前优宽量化交易平台账号推送设置中配置的邮箱、WebHook等（依次打开控制中心页面、右上角账号设置页面、推送设置页面设置绑定）。

注意：

• 「调试工具」中不支持推送。
• 「回测系统」中不支持推送。

推送限制为50条/小时，每条消息推送间隔至少10秒。推送内容重复会被过滤掉。

            javascript
            
            
function main() {
    Log("优宽量化你好 !@")
    Sleep(1000 * 5)
    // 字符串内加入#ff0000，打印日志显示为红色，注意：回测系统不支持推送！
    Log("你好, #ff0000@")
}

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

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

WebHook推送：

使用Golang编写的服务程序DEMO：

            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_优宽

运行服务程序后，执行策略推送信息：

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

            python
            
            
def main():
    Log("msg", "@")

            c++
            
            
void main() {
    Log("msg", "@");
}

接收到推送，服务程序打印信息：

            mylang
            
            
listen http://localhost:9090
req: {GET /data?data=Hello_优宽 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_优宽 <nil> <nil> <nil> 0xc420056300}

打印base64编码后的图片
Log函数支持打印base64编码后的图片，以`开头，以 `结尾，例如：

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

            python
            
            
def 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
            
            
function main() {
    Log("中文")
}

            python
            
            
def main():
    Log("中文")

            c++
            
            
void main() {
    Log("中文");
}

LogProfit(Profit)

LogProfit(Profit)，记录盈亏值，打印盈亏数值并根据盈亏数值绘制收益曲线，参数值：Profit为数值类型。

该函数如果以字符&结尾，只绘制收益图表，不打印收益日志，例如：LogProfit(10, '&')。

LogProfitReset()

LogProfitReset()，清空所有收益日志，可以带一个整数数值参数，指定保留的条数。

            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)

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

LogStatus(Msg)

LogStatus(Msg)，此信息不保存到日志列表里，只更新当前实盘的状态信息，在实盘页面日志区域上方的状态栏显示，可多次调用更新状态。参数值：Msg可以为任意类型。

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

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

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

LogStatus(Msg)支持打印base64编码后的图片，以`开头，以`结尾，例如：LogStatus("`data:image/png;base64,AAAA`")。
LogStatus(Msg)支持直接传入Python的matplotlib.pyplot对象，只要对象包含savefig方法就可以传入LogStatus(Msg)函数，例如：

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

状态栏中数据输出示例：

            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": "平仓"}) + '`')

            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
            
            
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) + "`")

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

状态栏按钮样式设置：

            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) + "`")

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

结合GetCommand()函数，构造状态栏按钮交互功能：

            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)

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

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

合并LogStatus(Msg)函数画出的表格内的单元格：

• 横向合并

  • Javascript
  • Python
  • C++

  
              javascript
              
              
  function main() {
      var table = { 
          type: 'table', 
          title: '持仓操作', 
          cols: ['列1', '列2', 'Action'], 
          rows: [ 
              ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': '平仓'}]
          ]
      } 
      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": "平仓"}]
          ]
      }
      ticker = exchange.GetTicker()
      table["rows"].append([{"body": json.dumps(ticker), "colspan": 2}, "abc"])
      LogStatus("`" + json.dumps(table) + "`")
  

  
              c++
              
              
  void main() {
      json table = R"({
          "type" : "table",
          "title" : "持仓操作",
          "cols" : ["列1", "列2", "Action"],
          "rows" : [
              ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "平仓"}]
          ]
      })"_json;
  
      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() + "`");
  }
  

  

• 纵向合并

  • Javascript
  • Python
  • C++

  
              javascript
              
              
  function main() {
      var table = { 
          type: 'table', 
          title: '表格演示', 
          cols: ['列A', '列B', '列C'], 
          rows: [ 
              ['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
          ]
      } 
  
      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"}]
          ]
      }
      
      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) + "`")
  

  
              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
            
            
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]) + "`")

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