JavaScript

支持JavaScript语言，集成了以下JavaScript库：

• http://mathjs.org/
• http://mikemcl.github.io/decimal.js/
• http://underscorejs.org/
• http://ta-lib.org/

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

支持JavaScript异步编程特性： - setTimeout / clearTimeout

  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关键字以同步语法处理异步操作：

  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并发执行多个异步网络请求：

  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的结果： “`js 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()```函数：
  ```js
  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是单线程的，同步操作会阻塞事件循环；微任务队列中的回调函数仍然是串行执行的。 “`js 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()

} “`