JavaScript

平台支持用JavaScript编写策略。运行时基于 QuickJS 引擎，支持async/await、class、BigInt等现代语法；实盘时策略在托管者上运行，回测时在浏览器端的回测系统中运行。在代码中加入// @ts-check即可改用 TypeScript 编写，见 TypeScript。

策略结构与参数

策略入口为function main()，可选的init()、onexit()、onerror(msg)由托管者自动调用，见 策略结构。界面参数是同名的全局变量，可以直接读取，也可以在代码中修改，见 策略参数。

错误与返回值

API 函数调用失败（交易所返回错误、网络问题等）时返回null，并在日志中输出错误信息。使用返回值之前先判断，或者用 _C 重试：

            javascript
            
            
function main() {
    var ticker = exchange.GetTicker()
    // 调用失败时返回 null
    if (ticker) {
        Log(ticker)
    }

    // 失败时自动重试，直到返回有效数据
    var account = _C(exchange.GetAccount)
    Log(account)
}

程序异常（例如读取undefined的属性）和接口业务报错的日志中会显示出错位置在策略代码中的行号，便于调试和排查。

字符串与ArrayBuffer

JavaScript 的字符串是 UTF-16 编码。平台 API 返回的文本如果不是合法的 UTF-8 字节序列，为了不丢失数据，会返回ArrayBuffer（原始字节）。所有可以传入字符串的 API 参数也都接受ArrayBuffer。

            javascript
            
            
function stringToHex(str) {
    let hex = ''
    for (let i = 0; i < str.length; i++) {
        const charCode = str.charCodeAt(i).toString(16)
        hex += charCode.length === 1 ? '0' + charCode : charCode
    }
    return hex
}

function main() {
    // “𠮷”的 Unicode 码点超出 16 位，在 JavaScript 字符串中占两个 UTF-16 码元
    const inputString = "abc𠮷123"

    // Encode 按 UTF-8 编码后输出 hex
    const encodedHex = Encode("raw", "string", "hex", inputString)
    Log(encodedHex)                       // 616263f0a0aeb7313233

    // charCodeAt 取的是 UTF-16 码元，“𠮷”被写成 d842、dfb7，结果不是 UTF-8 编码
    const manuallyEncodedHex = stringToHex(inputString)
    Log(manuallyEncodedHex)               // 616263d842dfb7313233

    // 合法的 UTF-8 字节可以还原为字符串
    const decodedString = Encode("raw", "hex", "string", encodedHex)
    Log(decodedString)                    // abc𠮷123

    // 不是合法的 UTF-8 字节，返回 ArrayBuffer
    // （如果 inputString 改为 "abcG123"，两种编码结果相同，这里得到的是字符串）
    const outputD = Encode("raw", "hex", "string", manuallyEncodedHex)
    Log(outputD instanceof ArrayBuffer)   // true

    // 查看 ArrayBuffer 中的原始字节
    const bufferD = new Uint8Array(outputD)
    let hexBufferD = ''
    for (let i = 0; i < bufferD.length; i++) {
        hexBufferD += bufferD[i].toString(16).padStart(2, '0')
    }
    Log(hexBufferD)                       // 616263d842dfb7313233
}

异步与多线程

• setTimeout/clearTimeout：回调在主线程调用Sleep()等待期间执行；main()返回时还没到期的定时器会先执行完，再调用onexit()。
• fetch(url)：返回Promise，结果为响应对象（ok、status、headers属性，text()、json()直接返回内容）。托管者中的fetch在调用时就同步完成请求，返回的是已经完成的Promise，所以用Promise.all组合多个fetch并不会并发请求。
• 交易所 API（例如exchange.GetTicker()）是同步阻塞调用，包装进Promise或async函数也不会并发执行。
• 需要并发时使用 exchange.Go、HttpQuery_Go，或者用 Thread 创建线程，见 JavaScript多线程。

            javascript
            
            
async function main() {
    let resp = await fetch("https://www.okx.com/api/v5/market/books?instId=BTC-USDT")
    if (resp.ok) {
        Log(resp.json())
    } else {
        Log("status:", resp.status)
    }
}

库与依赖

JavaScript 策略可以直接使用内置的TA指标库和talib指标库，各语言可用的内置库见 内置库。其它第三方 JavaScript 库可以在运行时下载后用eval加载，示例见同一页。

TypeScript

TypeScript 不是单独的语言选项：创建策略时选择JavaScript，在代码中加入一行// @ts-check（或点击策略编辑区右上角的「TypeScript」按钮），平台就按 TypeScript 处理，在回测和实盘运行前先编译为 JavaScript。通过 AI/MCP 工具保存策略时，语言可以直接写typescript，平台按 JavaScript 策略保存，并在代码开头自动加上//@ts-check，见 AI接入。

静态类型检查能在编写时发现参数个数、属性名、类型用错之类的问题，编辑器的补全也更准确。

最小示例：

            ts
            
            
// @ts-check
interface Signal {
    side: "buy" | "sell"
    price: number
}

function getSignal(ticker: ITicker, ma: number): Signal | null {
    if (ticker.Last > ma) {
        return {side: "buy", price: ticker.Last}
    }
    if (ticker.Last < ma) {
        return {side: "sell", price: ticker.Last}
    }
    return null
}

function main() {
    while (true) {
        const records = exchange.GetRecords()
        const ticker = exchange.GetTicker()
        if (records && ticker && records.length > 20) {
            const ma = TA.MA(records, 20)
            const signal = getSignal(ticker, ma[ma.length - 1])
            if (signal) {
                Log(signal.side, signal.price)
            }
        }
        Sleep(60 * 1000)
    }
}

平台 API 的类型声明由策略编辑器内置提供，不需要在代码中引用：全局函数、exchange对象、ITicker、IRecord、IOrder、IPosition等数据结构接口，以及TA、talib等。运行时的语言特性、API 和库与 JavaScript 策略相同，见 JavaScript。

Python

平台支持用Python 3编写策略，不支持 Python 2。实盘以及在托管者上进行的回测，使用托管者所在机器上安装的 Python 解释器运行策略。

解释器

托管者按以下顺序查找解释器，使用第一个能启动、并且版本为 Python 3 的程序：

1. 环境变量PYTHON_BIN指定的解释器；
2. python3；
3. python。

需要使用指定的解释器（例如虚拟环境中的 Python）时，在启动托管者之前设置环境变量：

            bash
            
            
export PYTHON_BIN=/opt/venv/bin/python3

策略代码首行的#!python3、#!python2等写法不再用于选择解释器。

策略结构与参数

策略入口为def main()，可选的init()、onexit()由托管者自动调用（Python 不支持onerror()），见 策略结构。界面参数是同名的全局变量；在函数中给参数重新赋值时，需要先用global声明。

错误与返回值

API 函数调用失败时返回None，并在日志中输出错误信息。使用返回值之前先判断，或者用_C()重试。策略中未捕获的异常会结束运行，错误信息记录在日志中。

输出

print()的输出写到托管者进程的标准输出，不会出现在实盘日志里。需要显示在日志中的内容请用 Log。

第三方库

策略可以导入解释器中已经安装的任何库。安装时要使用托管者运行策略的那个解释器，例如：

            bash
            
            
python3 -m pip install numpy
# 设置了 PYTHON_BIN 时
$PYTHON_BIN -m pip install numpy

使用talib需要在托管者所在机器上安装 TA-Lib（talib包）和numpy。

自定义模块

策略运行时的当前目录和PYTHONPATH是托管者为本次运行创建的临时目录，运行结束后会被删除；放在托管者程序目录下（例如logs/storage/<实盘ID>/）的.py文件不会被自动找到。导入自己编写的模块有两种方式：

• 把模块安装到解释器的site-packages中（例如做成包用pip install安装，或者直接复制到site-packages目录）；
• 在策略中先把模块所在目录的绝对路径加入sys.path，再导入。

例如模块文件/home/user/fmz_modules/mymath.py：

            python
            
            
# mymath.py
def add(a, b):
    return a + b

策略代码：

            python
            
            
import sys
sys.path.append("/home/user/fmz_modules")   # 模块所在目录的绝对路径

import mymath

def main():
    Log("mymath.add(1, 2):", mymath.add(1, 2))

把核心代码做成模块放在自己的托管者上，策略代码中只保留调用部分，也是一种不把核心代码上传到平台的做法。

Rust

平台支持用Rust编写策略。Rust 策略先编译再运行：回测时由平台服务器编译，在浏览器端的回测系统中运行；实盘时编译通过后在托管者上运行。策略编辑器为 Rust 集成了rust-analyzer，提供代码补全与实时诊断。

策略结构

策略代码只需要一个fn main()。平台 API（exchange、exchanges、TA、Log!、_C!等）已经自动导入，不需要写use或mod声明。

可选的fn init()、fn onexit()由托管者自动调用，定义即可，不需要注册：init()在main()之前执行；onexit()在main()正常返回、实盘被停止、策略panic时都会执行。Rust 不支持onerror()。详见 策略结构。

            rust
            
            
fn init() {
    Log!("初始化");
}

fn main() {
    // 可能失败的 API 返回 Result<T>，_C! 宏在失败时重试，直到调用成功
    let ticker = _C!(exchange.GetTicker(None));
    Log!("Last:", ticker.Last);
}

fn onexit() {
    Log!("策略退出，执行扫尾处理");
}

日志等部分功能以宏的形式提供（注意感叹号）：Log!()、LogStatus!()、Panic!()、_G!()、_C!()；LogProfit()、Sleep()、_D()、_N()、HttpQuery()等是普通函数。

参数类型

界面参数以同名的全局常量注入策略，只能读取，不能在代码中修改（需要变化的值请复制到局部变量）。类型由参数种类决定：

• 整数用途需要自行转换，例如let n = Period as usize;。
• 选填参数没有填写时为该类型的零值：0.0、""、false，多选下拉框为空。
• 加密串参数在服务端不能预先解密时（例如私有托管者），注入为static的Decrypted类型，第一次使用时才解密。它实现了Display，可以直接用于format!；传给Log!或其它需要&str的地方写&*参数名（对&str类型的参数同样适用）：

            rust
            
            
fn main() {
    let key: &str = &*ApiKey;   // ApiKey 为加密串参数
    Log!("key length:", key.len());
}

• 参数名与代码中的其它名字冲突时，可以用args::参数名引用参数。

错误与返回值

可能失败的 API 调用返回Result<T>，用 Rust 惯用的方式处理（JavaScript 中失败返回null）：

            rust
            
            
fn main() {
    // 方式一：模式匹配
    if let Ok(ticker) = exchange.GetTicker(None) {
        Log!(ticker);
    }

    // 方式二：_C! 宏在失败时重试，直到调用成功
    let ticker = _C!(exchange.GetTicker(None));
    Log!(ticker);
}

可选参数（例如GetTicker的symbol参数）不传时用None占位，传值时直接传入，例如exchange.GetTicker("BTC_USDT")。

JSON

平台 API 返回的原始 JSON 文本（例如exchange.IO()的返回值、各结构体的Info字段）用内置的JSONParse()解析，得到Option<JsonValue>；用v["key"]、v[0]取子节点，用as_f64()、as_str()、as_bool()等方法取值。JsonValue实现了Display，v.to_string()或format!("{}", v)得到紧凑的 JSON 文本。SDK 没有提供构造 JSON 的便捷接口，生成 JSON 文本可以用format!拼接，或者引入serde_json。

第三方 crate

策略源码是唯一的代码文件（没有单独的Cargo.toml）。在源码最顶部用---包裹的 frontmatter 声明依赖，构建时合并进Cargo.toml：

            rust
            
            
---
[dependencies]
serde_json = "1"
---
/*backtest
start: 2024-01-01 00:00:00
end: 2024-02-01 00:00:00
period: 1h
*/
fn main() {
    let v: serde_json::Value = serde_json::from_str(r#"{"a": 1}"#).unwrap();
    Log!("a:", v["a"].to_string());
}

• frontmatter 必须在源码开头，前面只能有空行；/*backtest ... */回测配置块要放在 frontmatter 结束的---之后。策略中还没有回测配置块时，「保存回测设置」会把配置块插入到源码最前面，这时需要把它移到 frontmatter 之后（之后再保存会在原位置更新）。
• 策略和它引用的模板类库中，依赖块只能写在其中一处，两处都写会编译失败。
• 编译环境中没有系统 OpenSSL，需要 TLS 的 crate（HTTP/WebSocket 客户端等）请选用纯 Rust 实现的rustls（例如tokio-tungstenite开启rustls-tls-webpki-roots特性），避免依赖native-tls/openssl-sys；WebSocket 连接优先使用内置的 Dial 函数，不需要第三方 crate。

内置库

Rust 策略可以使用TA指标库，不支持talib，见 内置库。

My语言（麦语言）

平台支持My语言（麦语言）编写和设计策略，兼容文华麦语言的大部分语法、指令和函数。My语言鼓励积木式编程，将复杂算法拆解为函数模块。通过简洁的语法、专用数据结构和强大的金融函数库，支持复杂金融逻辑的实现。以模块化方式构建应用，提升开发效率和代码可维护性。

My语言策略范例：基于平移布林通道的系统

            mylang
            
            
M := 12;          // 参数范围 1, 20
N := 3;           // 参数范围 1, 10
SDEV := 2;        // 参数范围 1, 10
P := 16;          // 参数范围 1, 20

// 该策略为趋势跟踪交易策略，适用较大周期，如日线。
// 该模型仅用作模型开发案例，依此入市，风险自负。

////////////////////////////////////////////////////////

// 平移BOLL通道计算
MID:=MA(C,N);                 // 计算中轨
TMP:=STD(C,M)*SDEV;           // 计算标准差
DISPTOP:=REF(MID,P)+TMP;      // 平移BOLL通道上轨
DISPBOTTOM:=REF(MID,P)-TMP;   // 平移BOLL通道下轨

// 系统入场
H>=DISPTOP,BPK;
L<=DISPBOTTOM,SPK;
AUTOFILTER;

• FMZ量化My语言文档
• FMZ量化My语言--My语言交易类库参数

PINE语言

平台支持并兼容Trading View的PINE语言脚本。PINE语言是一种轻量级但功能强大的策略编程语言，用于创建可进行回测和实盘交易的技术指标与策略。活跃的社区已创作了超过10万个PINE脚本。
用户可以轻松获取并应用各种技术分析工具和交易策略；能够借助社区脚本快速实现交易想法，无需从零开始编写代码，从而大幅缩短开发周期；帮助新手和资深交易员学习并理解不同的技术指标、策略及编程概念。

PINE语言策略示例：超级趋势策略

            pine
            
            
strategy("supertrend", overlay=true)

[supertrend, direction] = ta.supertrend(input(5, "factor"), input.int(10, "atrPeriod"))
plot(direction < 0 ? supertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(direction > 0 ? supertrend : na, "Down direction", color = color.red, style=plot.style_linebr)

if direction < 0
    if supertrend > supertrend[2]
        strategy.entry("entry long", strategy.long)
    else if strategy.position_size < 0
        strategy.close_all()
else if direction > 0
    if supertrend < supertrend[3]
        strategy.entry("entry short", strategy.short)
    else if strategy.position_size > 0
        strategy.close_all()

• PINE Script 文档

Blockly可视化

平台支持Blockly可视化编程方式。借助Blockly编辑器，用户可以通过拼接图形块（类似积木）来表达代码概念，如变量、逻辑表达式、循环等。这种方式使编程过程无需过多关注繁琐的语法细节，而是可以直接按照编程原则进行操作。通过图形块的排列组合，用户能够轻松理解编程逻辑，实现创意想法，非常适合培养策略设计兴趣，快速入门程序化和量化交易。

• 可视化模块搭建交易策略--初识

• 可视化模块搭建交易策略--进阶

• 可视化模块搭建交易策略--深入

• 可视化模块搭建交易策略--浅出

Workflow工作流

平台支持 Workflow 工作流方式编写策略。工作流是一种可视化的策略设计方式，通过节点连接和配置来构建交易逻辑，无需编写代码即可实现策略。

工作流特点：

• 可视化拖拽设计，所见即所得
• 预置丰富的功能节点（数据获取、指标计算、条件判断、交易执行等）
• 降低编程门槛，适合快速搭建和验证策略
• 支持回测功能，可视化查看节点执行状态

学习资源：

• 工作流系列视频教程

init()

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

示例

    javascript
    
    
function main(){
    Log("First line of code executed!", "#FF0000")
    Log("Exiting!")
}

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

    python
    
    
def main():
    Log("First line of code executed!", "#FF0000")
    Log("Exiting!")

def init():
    Log("Initializing!")

    rust
    
    
fn main() {
    Log!("First line of code executed!", "#FF0000");
    Log!("Exiting!");
}

// 初始化函数
fn init() {
    Log!("Initializing!");
}

onexit()

onexit()由用户实现，在策略退出时处理扫尾工作，可以不定义。最长执行 5 分钟，超时会被强制结束。各语言在哪些情况下调用onexit()，见 策略结构。

示例

• 测试onexit()函数：

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main(){
      Log("Starting, will stop after 5 seconds and execute cleanup function!")
      Sleep(1000 * 5)
  }
  
  // 扫尾函数实现
  function onexit(){
      var beginTime = new Date().getTime()
      while(true){
          var nowTime = new Date().getTime()
          Log("Program stop countdown..cleanup started, elapsed time:", (nowTime - beginTime) / 1000, "seconds!")
          Sleep(1000)
      }
  }
  

  
      python
      
      
  import time
  def main():
      Log("Starting, will stop after 5 seconds and execute cleanup function!")
      Sleep(1000 * 5)
  
  def onexit():
      beginTime = time.time() * 1000
      while True:
          ts = time.time() * 1000
          Log("Program stop countdown..cleanup started, elapsed time:", (ts - beginTime) / 1000, "seconds!")
          Sleep(1000)
  

  
      rust
      
      
  fn main() {
      Log!("Starting, will stop after 5 seconds and execute cleanup function!");
      Sleep(1000 * 5);
  }
  
  // 扫尾函数实现
  fn onexit() {
      let beginTime = Unix() * 1000;
      loop {
          let nowTime = Unix() * 1000;
          Log!("Program stop countdown..cleanup started, elapsed time:", (nowTime - beginTime) / 1000, "seconds!");
          Sleep(1000);
      }
  }
  

• 回测系统中，策略通常写成不停轮询的死循环，回测数据结束时main()并没有正常返回，JavaScript、Python策略因此不会执行onexit()。可以在回测中（IsVirtual()为真）捕获回测结束时抛出的异常（EOF），让main()返回，从而执行onexit()。Rust策略在回测结束时 API 调用返回Err，退出循环即可。

  • javascript
  • python
  • rust

  
      javascript
      
      
  function main() {
      if (exchange.GetName().startsWith("Futures_")) {
          Log("Exchange is futures")
          exchange.SetContractType("swap")
      } else {
          Log("Exchange is spot")
      }
  
      if (IsVirtual()) {
          try {
              onTick()
          } catch (e) {
              Log("error:", e)
          }
      } else {
          onTick()
      }
  }
  
  function onTick() {
      while (true) {
          var ticker = exchange.GetTicker()
          LogStatus(_D(), ticker ? ticker.Last : "--")
          Sleep(500)
      }
  }
  
  function onexit() {
      Log("Executing cleanup function")
  }
  

  
      python
      
      
  def main():
      if exchange.GetName().startswith("Futures_"):
          Log("Exchange is futures")
      else:
          Log("Exchange is spot")
  
      if IsVirtual():
          try:
              onTick()
          except Exception as e:
              Log(e)
      else:
          onTick()
  
  def onTick():
      while True:
          ticker = exchange.GetTicker()
          LogStatus(_D(), ticker["Last"] if ticker else "--")
          Sleep(500)
  
  def onexit():
      Log("Executing cleanup function")
  

  
      rust
      
      
  fn onTick() {
      loop {
          match exchange.GetTicker(None) {
              Ok(ticker) => LogStatus!(_D(None), ticker.Last),
              Err(e) => {
                  // 回测结束时API调用返回Err，退出循环使main返回，从而触发onexit()扫尾函数
                  Log!("error:", e);
                  break;
              }
          }
          Sleep(500);
      }
  }
  
  fn main() {
      if exchange.GetName().starts_with("Futures_") {
          Log!("Exchange is futures");
          let _ = exchange.SetContractType("swap");
      } else {
          Log!("Exchange is spot");
      }
  
      onTick();
  }
  
  fn onexit() {
      Log!("Executing cleanup function");
  }
  

onerror()

onerror(msg)只有JavaScript（含 TypeScript）策略支持：main()因未捕获的异常结束时调用，参数msg为异常的错误信息。调用了onerror()就不再调用onexit()。最长执行 5 分钟，超时会被强制结束。回测系统不支持该函数。

Python、Rust策略不支持onerror()。

示例

    javascript
    
    
function main() {
    var arr = []
    Log(arr[6].Close)  // 这里故意引发一个程序异常
}

function onerror(msg) {
    Log("Error:", msg)
}

    python
    
    
# Python 不支持

    rust
    
    
// Rust 不支持

主循环

策略通常在main()中写一个循环：每轮获取行情、计算信号、下单，然后调用 Sleep 等待下一轮。Sleep()在回测中推进回测时间、控制回溯速度，在实盘中控制轮询间隔，从而控制访问交易所 API 的频率。循环中不调用Sleep()会以最快速度反复请求交易所接口，容易触发交易所的频率限制。需要在托管者上限制 API 调用频率时，见 API限流控制。

示例

• 基本框架：

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick(){
      // 在这里写策略逻辑，将会不断调用，例如打印行情信息
      Log(exchange.GetTicker())
  }
  
  function main(){
      while(true){
          onTick()
          // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
          Sleep(60000)
      }
  }
  

  
      python
      
      
  def onTick():
      Log(exchange.GetTicker())
  
  def main():
      while True:
          onTick()
          Sleep(60000)
  

  
      rust
      
      
  fn onTick() {
      // 在这里写策略逻辑，将会不断调用，例如打印行情信息
      Log!(exchange.GetTicker(None));
  }
  
  fn main() {
      loop {
          onTick();
          // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
          Sleep(60000);
      }
  }
  

• 举个最简单的例子：每隔1秒钟在交易所挂一个价格为100、数量为1的买单，可以这样写：

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick(){
      // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用
      exchange.Buy(100, 1)
  }
  
  function main(){
      while(true){
          onTick()
          // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def onTick():
      exchange.Buy(100, 1)
  
  def main():
      while True:
          onTick()
          Sleep(1000)
  

  
      rust
      
      
  fn onTick() {
      // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用
      let _ = exchange.Buy(100, 1);
  }
  
  fn main() {
      loop {
          onTick();
          // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒
          Sleep(1000);
      }
  }
  

• 按K线更新处理的策略（On Bar）：最新一根K线的时间变化时才执行onTick()：

  • javascript
  • python
  • rust

  
      javascript
      
      
  function onTick() {
      Log("K-line updated, new BAR generated")
  }
  
  function main() {
      var exName = exchange.GetName()
      if (exName.includes("Futures_")) {
          exchange.SetContractType("swap")
      }
  
      var lastTs = 0
      while (true) {
          var r = _C(exchange.GetRecords)
          if (r.length > 0 && r[r.length - 1].Time != lastTs) {
              onTick()
              lastTs = r[r.length - 1].Time
          }
          Sleep(1000)
      }
  }
  

  
      python
      
      
  def onTick():
      Log("K-line updated, new BAR generated")
  
  def main():
      exName = exchange.GetName()
      if "Futures_" in exName:
          exchange.SetContractType("swap")
  
      lastTs = 0
      while True:
          r = _C(exchange.GetRecords)
          if len(r) > 0 and r[-1]["Time"] != lastTs:
              onTick()
              lastTs = r[-1]["Time"]
          Sleep(1000)
  

  
      rust
      
      
  fn onTick() {
      Log!("K-line updated, new BAR generated");
  }
  
  fn main() {
      let exName = exchange.GetName();
      if exName.contains("Futures_") {
          let _ = exchange.SetContractType("swap");
      }
  
      let mut lastTs = 0;
      loop {
          let r = _C!(exchange.GetRecords(None, None, None));
          if r.len() > 0 && r[r.len() - 1].Time != lastTs {
              onTick();
              lastTs = r[r.len() - 1].Time;
          }
          Sleep(1000);
      }
  }
  

事件驱动

除了按固定间隔轮询，策略也可以等待事件到达后再处理，减少无效请求，也能更快地响应行情变化。

EventLoop

EventLoop 等待exchange.Go()、HttpQuery_Go()等并发任务完成、WebSocket 连接有可读数据、线程消息等事件；有事件时返回事件信息，策略再去读取对应的数据。第一次调用EventLoop()时才开始记录事件，所以先调用一次EventLoop(-1)再发起并发任务：

            javascript
            
            
function main() {
    EventLoop(-1)                       // 开始记录事件，避免错过之后发生的事件
    var r1 = exchange.Go("GetTicker")
    var r2 = exchange.Go("GetDepth")
    var ev = EventLoop(1000)            // 等待任意一个并发任务完成，最多等 1 秒
    Log("event:", ev)
    Log("ticker:", r1.wait(), "depth:", r2.wait())
}

ctx.subscribe / ctx.poll

JavaScript和Rust策略还可以使用托管者的事件订阅接口：ctx.subscribe()订阅某个账户、某个品种的行情或订单回报，返回流 ID；ctx.poll()取出下一条事件（可以设置等待超时），策略按事件的kind分别处理。Python策略不支持。

            javascript
            
            
function main() {
    ctx.subscribe(0, "BTC_USDT", {channel: "ticker"})   // 第一个参数是账户在 exchanges 中的下标
    ctx.subscribe(0, "", {channel: "orders"})           // 订单回报
    while (true) {
        const ev = ctx.poll([], 1000)                    // [] 表示所有订阅，最多等 1 秒
        if (!ev) {
            continue
        }
        if (ev.kind === 1) {
            Log("ticker:", ev.symbol, ev.bid, ev.ask, ev.last)
        } else if (ev.kind === 16) {
            Log("order:", ev.id, ev.state, ev.filledQty)
        }
    }
}

• channel可选"ticker"、"bbo"、"depth"、"trade"、"kline"（interval为周期秒数）、"orders"。
• 事件的kind：1 为 ticker，3 为深度（事件只表示订单簿已更新，档位用ctx.book(ev.ex, ev.symbol, n)读取），4 为成交，5 为 K 线，16 为订单回报。
• 行情类订阅消费不及时会只保留最新数据或丢弃最旧的数据，订单回报不会丢弃，策略需要持续调用ctx.poll()。

Rust策略中的写法为ctx::subscribe()、ctx::poll()，事件为原始结构，价格、数量是定点整数：

            rust
            
            
fn main() {
    let s = ctx::subscribe(0, "BTC_USDT", ctx::SubOpts::ticker()).unwrap();
    loop {
        match ctx::poll(&[s], Some(1000)) {
            ctx::Polled::Event(ev) => Log!("event kind:", ev.kind),
            ctx::Polled::Stopped => break,
            _ => {}
        }
    }
}

API函数速查

按API手册的分类列出全部函数、结构体和常量，每项一句话说明，点击名称查看完整文档。本页由doc_tools/gen_api_index.py根据手册生成。

内置函数

Global

Log

Market

Trade

Account

Futures

Exchange

IO

Network

Storage

Threads

Threads/threading

Threads/Thread

Threads/ThreadLock

Threads/ThreadEvent

Threads/ThreadCondition

Threads/ThreadDict

Threads/Server

Web3

Uniswap

TA

Talib/OverlapStudies

Talib/MomentumIndicators

Talib/VolumeIndicators

Talib/VolatilityIndicators

Talib/CycleIndicators

Talib/PriceTransform

Talib/StatisticFunctions

Talib/MathTransform

Talib/MathOperators

Talib/PatternRecognition

OS

OS/os

OS/File

结构体

OtherStruct

内置变量与常量

EXCHANGE

ORDER_STATE

ORDER_TYPE

ORDER_CONDITION_TYPE

POSITION_DIRECTION

ORDER_OFFSET

PERIOD

LOG_TYPE

界面参数种类

界面参数，在策略编辑页面代码编辑区下方策略参数区设置，需要注意：
1、参数设置的默认值选项中「选填」控件默认为选填状态，可以改变该控件的状态，设置当前参数为必填。设置参数默认值为必填后，如果策略在回测/实盘时没有设置该参数则无法进行回测/启动实盘。
2、界面参数在策略代码中的变量名不要设置为当前编程语言的保留字（关键字）。
3、在回测/实盘界面鼠标放在参数绑定的控件上时，会显示设置的参数备注信息。
4、参数的「描述」即参数绑定的控件的显示名称。
5、参数的「变量」即以上表格中的：pNum、pBool、pStr、pCombox、pSecretStr。在策略代码中是以全局变量形式存在的，也就是说可以在代码中修改策略参数（Rust 除外：Rust 中参数是全局常量，不能修改）。
6、对于「加密串」和「字符串」类型的参数，默认值输入时不需要加引号，输入均作为字符串处理。「加密串」参数的使用与「字符串」参数相同，加密字符串会被加密发送，不会明文传输。
7、「字符串」类型的参数如果设置为「选填」，当参数绑定的控件中不填写参数时，参数变量的值为空字符串；
同理，如果是「数字型」的参数，参数变量的值为空值。
同理，如果是「下拉框」的参数，参数变量的值为空值。
同理，如果是「加密串」的参数，参数变量的值为空值。
Rust策略中，没有填写的选填参数为该类型的零值：数字为0，字符串、加密串为空字符串，布尔为false。
8、对于下拉框类型的界面参数，例如变量名为pCombox。在「组件配置」中没有开启「支持多选」时，pCombox的值为当前选中的选项索引或具体数据（给选项绑定数据时）。
如果开启了「支持多选」时，pCombox的值为一个数组，数组包含所有当前选中的选项的索引或具体数据（给选项绑定数据时）。

组件配置

策略界面参数和策略交互控件都有「组件配置」选项，用于设置参数（或交互控件）对应的界面控件，以及最小值、最大值、分组、过滤器等。

各种类型支持的组件：

• 数字型(number)
  输入框控件（默认）、时间选择器控件、滑动输入条控件。
• 布尔型(true/false)
  仅支持开关控件（默认）。
• 字符串(string)
  输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、币种、交易代码。
• 下拉框(selected)
  下拉框控件（默认）、分段控制器控件、币种、交易代码。
• 加密串(string)，仅策略参数
  仅支持加密输入框控件（默认）。
• 按钮(button)，仅交互控件
  只有一个按钮控件（默认），没有输入项。

分组

在组件配置的「分组」输入框中输入一个标签名，可以把若干个策略参数划分到同一个分组中（代替平台旧功能「策略分组」）。交互控件同样可以分组（代替旧功能「交互控件分组」）。

过滤器

策略参数的组件配置中，「过滤器」输入框可以填写判定表达式，控制参数是否可用（代替平台旧功能「参数依赖」）。
过滤器默认为空，不做任何过滤；可以设置：a > b、a == 1、a、!a、a >= 1 && a <= 10等。过滤条件为真时，当前参数可用。

• 设置过滤器a == 1：该参数是否可用取决于参数a的值，a等于1时可用，否则不可用。
• 设置过滤器a >= 1 && a <= 10：a大于等于1并且小于等于10时可用，否则不可用。
• 设置过滤器!a：过滤条件为「非a」；a可以是布尔值，也可以是数值（!0为真）。

保存参数设置

• 回测系统中的参数保存
  在回测时如果希望将策略参数保存，可以在策略参数修改后点击「保存回测设置」按钮，参考 回测配置与保存。

  变量	描述	类型	默认值
  number	数值类型	数字型(number)	1
  string	字符串	字符串(string)	Hello FMZ
  combox	下拉框	下拉框(selected)	1|2|3
  bool	布尔值	布尔型(true/false)	true
  numberA@isShowA	数值A	数字型(number)	2
  isShowA	是否显示numberA参数	布尔型(true/false)	false

  设置后的策略参数以代码形式保存在策略中，例如：

  • Javascript
  • Python
  • Rust

  
              javascript
              
              
  /*backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  */
  

  
              python
              
              
  '''backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  '''
  

  
              rust
              
              
  /*backtest
  start: 2020-02-29 00:00:00
  end: 2020-03-29 00:00:00
  period: 1d
  args: [["number",2],["string","Hello FMZ.COM"],["combox",2],["bool",false],["numberA@isShowA",666],["isShowA",true]]
  */
  

  Rust策略如果在开头用 frontmatter 声明了依赖，回测配置块要放在 frontmatter 之后，见 Rust。

• 实盘参数导入导出
  运行实盘时需要保存实盘配置的参数数据，可以点击策略实盘页面中「参数设置」选项，再点击「导出参数」按钮，导出的策略参数将以json文件保存。
  导出的策略参数配置也可以再次导入实盘，点击「导入参数」按钮即可把保存的策略实盘参数导入到当前实盘，导入后点击「更新参数」按钮保存生效。

交互控件种类

交互控件触发后发送给策略的消息（字符串）：

• 数字型
  在交互控件cmdNum的输入框中输入交互数据：123后，点击交互控件cmdNum的按钮。策略程序中的GetCommand()函数会收到消息：cmdNum:123。
• 布尔型
  在交互控件cmdBool的开关控件上设置为打开，点击交互控件cmdBool的按钮。策略程序中的GetCommand()函数会收到消息：cmdBool:true。
• 字符串
  在交互控件cmdStr的输入框中输入交互数据：abc后，点击交互控件cmdStr的按钮。策略程序中的GetCommand()函数会收到消息：cmdStr:abc。
• 下拉框
  在交互控件cmdCombox的下拉框中选中第二个选项后，点击交互控件cmdCombox的按钮。策略程序中的GetCommand()函数会收到消息：cmdCombox:1，1表示选中的选项的索引，第一个选项索引为0，第二个选项索引为1。
• 按钮
  点击交互控件cmdBtn的按钮。策略程序中的GetCommand()函数会收到消息：cmdBtn。

交互控件的「组件配置」与策略参数相同，见 组件配置。

示例：用交互控件动态修改策略参数

在策略编辑页面的「策略交互」中添加一个字符串类型的交互控件，变量名为changeSymbol。交互控件的设置界面：

实盘运行时，在该控件的输入框中填入ETH_USDT并点击按钮，GetCommand()会收到消息changeSymbol:ETH_USDT。策略检测到这条消息后更新对应的变量（策略界面上的参数也是全局变量，这里用代码中的全局变量演示）：

            javascript
            
            
// 策略参数
var symbol = "BTC_USDT"

function main() {
    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            var arr = cmd.split(":")
            if (arr.length == 2 && arr[0] == "changeSymbol") {
                // 检测到 changeSymbol 控件触发，就会执行参数更新操作
                Log("Changed symbol parameter to:", arr[1])
                symbol = arr[1]
            }
        }

        LogStatus(_D(), ", Current symbol parameter value:", symbol)
        Sleep(3000)
    }
}

状态栏中的交互控件

除了在「策略交互」栏中设计交互控件，还可以在策略状态栏中设计交互控件。目前支持的交互控件种类仅有按钮类型，见 LogStatus。

状态栏中的按钮控件可以分为：

• 普通按钮控件
  数据结构举例为：

  
              json
              
              
  {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
  

• 带一个输入数据的按钮控件
  使用input属性设置输入控件选项，数据结构举例为：

  
              json
              
              
  {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button", "input": {"name": "Open Quantity", "type": "number", "defValue": 1}}
  

  
              json
              
              
  {
      "type": "button",
      "cmd": "test1",
      "name": "test1",
      "input": {
          "type": "selected",
          "name": "selected",
          "label": "Dropdown",
          "description": "description",
          "default": 100,
          "settings": {
              "multiple": true,
              "customizable": true,
              "options":[{"name": "A", "value": 100}, {"name": "B", "value": 200}]
          }
      }
  }
  

• 带一组输入数据的按钮控件
  使用group属性设置一组输入控件的选项，数据结构举例为：

  
              json
              
              
  {
      "type": "button",
      "cmd": "open",
      "name": "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
              
              
  {
      "type": "button",
      "cmd": "test2",
      "name": "test2",
      "group": [{
          "type": "selected",
          "name": "selected",
          "label": "Dropdown",
          "description": "description",
          "default": 200,
          "group": "group1",
          "settings": {
              "multiple": true,
              "options":[{"name": "A", "value": 100}, {"name": "B", "value": 200}]
          }
      }, {
          "type": "string",
          "name": "string",
          "label": "Input Box",
          "description": "description",
          "default": "ABC",
          "group": "group1"
      }]
  }
  

将这些按钮控件JSON数据编码为JSON字符串，然后使用`字符包裹住，在状态栏输出。以JavaScript语言为例：

            javascript
            
            
function main() {
    var btn = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    LogStatus("`" + JSON.stringify(btn) + "`")
}

这些按钮控件也可以写入状态栏表格中，详细例子见 LogStatus。

input字段结构与group字段中单个控件结构一致，以下为详细说明（带注释的 JavaScript 对象）：

            javascript
            
            
{
    "type": "selected",     // 控件类型（必要字段），支持设置为：number, string, selected, boolean
    "name": "test",         // 名称（group中使用时，为必要字段）
    "label": "topic",       // 标题（必要字段）
    "description": "desc",  // 组件的提示
    "default": 1,           // 默认值；当前JSON结构中如果不设置settings字段，兼容defValue，可以用defValue代替default
    "filter": "a>1",        // 选择器，不设置该字段表示不过滤（显示控件）；设置该字段时，当表达式为真时不过滤（显示控件）。当表达式为假时过滤（不显示控件）
                            // 对于选择器，以当前例子中表达式a>1为例，a指的是type=button的结构中group字段下name为a的控件值，根据此数值判断是否过滤
    "group": "group1",      // 分组
    "settings": {}          // 组件配置，各字段见下文
}

组件配置settings各个字段详细说明：

• settings.required：是否必选。
• settings.disabled：是否禁用。
• settings.min：type=number时有效，表示最小值。
• settings.max：type=number时有效，表示最大值。
• settings.step：type=number，render=slider时有效，表示步长。
• settings.multiple：type=selected时有效，表示支持多选。
• settings.customizable：type=selected时有效，表示支持自定义；用户可以直接在下拉框控件中编辑添加新选项，如果选中新编辑的选项，在触发交互时使用该选项的名称而不是选项代表的值。
• settings.options：type=selected时有效，表示选择器的选项数据格式：["Option 1", "Option 2"]、[{'name':'xxx','value':0}, {'name':'xxx','value':1}]。
• settings.render：渲染组件类型。
  type=number时，settings.render不设置(默认数字输入框)，可选：slider(滑动条)、date(时间选择器返回时间戳)。
  type=string时，settings.render不设置(默认单行输入框)，可选：textarea(多行输入)、date(时间选择器返回yyyy-MM-dd hh:mm:ss)、color(颜色选择器返回#FF00FF)。
  type=selected时，settings.render不设置(默认下拉框)，可选：segment(分段选择器)。
  type=boolean时，目前只有默认复选框。

支持双语设置，例如：'选项|options'文本内容会根据当前语言环境适配；以group字段中单个控件为例，完整的例子（JavaScript 对象）：

            javascript
            
            
{
    type:'selected',
    name:'test',
    label:'选项|options',
    description:'描述|description',
    default:0,                            // 这里default默认值设置0，表示{name:'xxx|yyy',value:0}选项中的value值
    filter:'a>1&&a<10',
    group:'分组|group',
    settings:{
        multiple:true,
        customizable:true,
        options:[{name:'xxx|yyy',value:0}]
    }
}

模板类库的导出函数

导出函数为模板类库的接口函数，可以被引用该模板类库的策略调用。

示例

• 不同的编程语言的模板类库书写格式有所不同，导出函数在模板类库中声明以及实现的例子代码如下：

  • javascript
  • python
  • rust

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

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

  
      rust
      
      
  // 策略引用该模板以后直接用 ext::Test() 调用此函数
  // 供策略调用的函数必须声明为 pub
  pub fn Test() {
      Log!("template call");
  }
  

• Blockly可视化方式编写的策略使用类库功能可以藉由JavaScript语言的模板类库编写实现，使用以下书写格式编写。

  
              javascript
              
              
  /*blockly
      {
          "type": "ext_testA",
          "message0": "testA|testA",
          "template": "function(){return 99;}()",
          "order": "ORDER_ATOMIC",
          "output": "Number"
      },{
          "type": "ext_MA",
          "message0": "MA 周期 %1| MA Period %1",
          "args0": [{
              "type": "input_value",
              "check": "Number"
          }],
          "template": "(function(){var r = exchange.GetRecords(); return (!r || r.length < %1) ? false : TA.MA(r, %1); })()",
          "order": "ORDER_ATOMIC",
          "output": null,
          "colour": 85
      }
  */
  

模板类库的参数

模板类库也可以设置自己的界面参数，模板类库的参数在模板类库代码中是以全局变量的形式使用的（Rust 中为全局常量）。
例如我们设置了一个模板类库的参数：

Rust模板的参数是常量，只能读取，不能修改，所以下面的例子在 Rust 中只能实现读取参数：

            rust
            
            
// 模板代码
pub fn GetParam1() -> f64 {
    Log!("param1:", param1);
    param1
}

            rust
            
            
// 策略代码
fn main() {
    Log!("Calling ext::GetParam1:", ext::GetParam1());
}

示例

• 用于测试param1参数的模板类库代码：

  • javascript
  • python
  • rust

  
      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

  
      rust
      
      
  // Rust 模板参数是只读常量，不能修改，读取参数的写法见上文
  

• 引用以上模板类库例子的策略代码，使用模板类库的导出函数获取参数param1和修改参数param1。

  • javascript
  • python
  • rust

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

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

  
      rust
      
      
  // Rust 模板参数是只读常量，不能修改，读取参数的写法见上文
  

引用模板类库

策略引用模板类库时，需要当前登录的发明者量化交易平台账号的策略库中存在可用的模板类库。在策略编辑页面的模板栏中勾选需要引用的模板，保存策略后即可完成引用。