主循环

策略通常在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);
      }
  }