JavaScript

平台支持用JavaScript编写策略，可以直接使用内置的TA指标库和talib指标库，见「内置库」一节。也可以用 TypeScript 编写，见本页末尾「用 TypeScript 编写」。

程序异常报错、接口业务报错
在JavaScript语言策略中，发生程序异常报错或接口业务报错时，错误日志将显示策略代码中发生错误的具体行号，便于策略调试与问题排查。

支持JavaScript异步编程特性：

• setTimeout / clearTimeout

  
              javascript
              
              
  function main() {
      let symbol = "rb888"
      let delay = 10
      let depth = exchange.GetDepth(symbol)
      let callback = function(e, id, msg) {
          Log(msg + "，撤销订单。")
          e.CancelOrder(id)
      }
  
      let ordersLen = 3
      let arrTimerId = []
      for (let i = 1 ; i <= ordersLen ; i++) {
          let orderId = exchange.CreateOrder(symbol, "buy", depth.Bids[i * 3].Price, i * 0.1)
          let timerId = setTimeout(callback, delay * 1000, exchange, orderId, `延迟${delay}秒`)
          Log("i:", i, ", timerId:", timerId)
          arrTimerId.push(timerId)
      }
  
      // clearTimeout
      let clearTimeoutIdx = 1
      Log("clearTimeoutIdx:", clearTimeoutIdx, `, arrTimerId[clearTimeoutIdx]:`, arrTimerId[clearTimeoutIdx])
      clearTimeout(arrTimerId[clearTimeoutIdx])
  
      Sleep(60 * 1000)
  }
  

• fetch
  fetch函数是HttpQuery函数的异步版本重载。

  使用await关键字以同步语法处理异步操作：

  
              javascript
              
              
  function main() {
      let url = "https://httpbin.org/get?test=123"
      const promiseBooks = new Promise(async function(resolve, reject) {
          Log("开始执行")
          let data = await fetch(url)
          Log("data.ok:", data.ok, ", data.text():", data.text())
          if (data.ok) {
              Log("成功获取 data:", data)
              return resolve(data.text())
          } else {
              return reject(new Error("data 无效"))
          }
      })
  
      promiseBooks.then(function(ret) {
          Log("ret:", ret)
      }).catch(function(err) {
          Log("err.name:", err.name, "err.stack:", err.stack, "err.message:", err.message)
      })
  }
  

• 使用Promise.all并发执行多个异步网络请求：

  
              javascript
              
              
  async function main() {
      let symbols = ["test1", "test2", "test3"]  // 等待请求耗时： 99 毫秒
      let arr = []
  
      let beginTs1 = new Date().getTime()
      for (let symbol of symbols) {
          let url = `https://httpbin.org/get?test=${symbol}`
          arr.push(fetch(url).then(function(resp) {
              if (resp.ok) {
                  return {"symbol": symbol, "json": resp.json()}
              } else {
                  throw "req failed"
              }
          }))
      }
      let endTs1 = new Date().getTime()
  
      let beginTs2 = new Date().getTime()
      const ret = await Promise.all(arr)
      for (let data of ret) {
          Log(data)
      }
      let endTs2 = new Date().getTime()
  
      Log("创建请求耗时：", endTs1 - beginTs1, "毫秒")
      Log("等待请求耗时：", endTs2 - beginTs2, "毫秒")
  
      LogStatus(_D(), ret)
  }
  

• 使用Promise.race获取多个异步请求中最先resolved或rejected的结果：

  
              javascript
              
              
  async function getTicker(e) {
      return Promise.resolve().then(function() {
          let ret = e.GetTicker("rb888")
          return {"name": e.GetLabel(), "ret": ret}
      })
  }
  
  async function main() {
      Log("begin")
      let arrPromise = []
      for (let e of exchanges) {
          arrPromise.push(getTicker(e))
      }
  
      let ret = await Promise.race(arrPromise)
      Log(ret)
  }
  

• 在threading.Thread中使用setTimeout()函数：

  
              javascript
              
              
  function test() {
      Log("Test function started")                           // step 3. Test function started
      let timerId1 = setTimeout(function() {
          Log("Timeout callback executed after 5 seconds")   // step 5. Timeout callback executed after 5 seconds
      }, 5000)
      Log("Test function completed")                         // step 4. Test function completed
  }
  
  function main() {
      Log("Main function started")                           // step 1. Main function started
      let t1 = threading.Thread(test)
      Log("Worker thread created successfully")              // step 2. Worker thread created successfully
      t1.join()
      Log("Main function completed")                         // step 6. Main function completed
  }
  

• 多线程并发获取ticker数据的异步处理示例：
  由于exchange.GetTicker()是同步阻塞操作，即使包装在Promise中，内部执行仍是同步的；JavaScript是单线程的，同步操作会阻塞事件循环；微任务队列中的回调函数仍然是串行执行的。

  
              javascript
              
              
  async function getTicker(symbol) {
      Log("getTicker symbol:", symbol)
      return Promise.resolve().then(function() {
          // 注意与fetch请求数据时的区别
          let ret = exchange.GetTicker(symbol)
          Log(ret)
          return ret
      })
  }
  
  async function main() {
      let symbols = ["rb888", "MA888", "i888"]
      let t1 = threading.Thread(async function(symbols, func) {
          let arrPromise = []
          for (let symbol of symbols) {
              arrPromise.push(func(symbol))
          }
          let ret = await Promise.all(arrPromise)
          Log("ret:", ret)
      }, symbols, getTicker)
  
      t1.join()
  }
  

用 TypeScript 编写

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

平台 API 的类型声明由策略编辑器内置提供，不需要在代码中引用：全局函数、exchange对象、ITicker、IRecord、IOrder、IPosition等数据结构接口，以及TA、talib等。静态类型检查能在编写时发现参数个数、属性名、类型用错之类的问题。运行时的语言特性、API 和库与 JavaScript 相同。

            typescript
            
            
//@ts-check
function getSignal(ticker: ITicker, ma: number): "buy" | "sell" | null {
    if (ticker.Last > ma) {
        return "buy"
    }
    return ticker.Last < ma ? "sell" : null
}

function main() {
    exchange.SetContractType("rb888")
    const records = exchange.GetRecords()
    const ticker = exchange.GetTicker()
    if (records && ticker && records.length > 20) {
        const ma = TA.MA(records, 20)
        Log(getSignal(ticker, ma[ma.length - 1]))
    }
}