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