[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_11":12,"_13":12,"_14":15,"_16":17,"_18":19,"_20":21,"_22":-7,"_23":24,"_25":26},"routes/app/user-guide.$",{"_9":10},"userGuide","[{\"_src_hash\": \"8c6e9765e767148e5e58f161d86d965366110e6145ba9196e1fc99abcd1406ff\", \"children\": [], \"desc\": \"[优宽量化交易平台](https://www.youquant.com)是量化交易领域最专业的量化社区，在这里您可以学习、编写、分享、买卖量化策略；进行在线回测和使用模拟盘进行模拟交易；运行、公开、围观实盘。支持商品期货CTP/易盛API/中泰证券XTP/腾讯富途证券（美股港股）。\\n如果遇到问题，可以随时到论坛发帖提问、讨论，或在平台提交工单。问题通常会得到快速解答。\\n在优宽量化交易平台，您可以通过注册和登录开始您的量化交易之旅。登录后，访问[主页面](https://www.youquant.com/m)，您将看到以下内容：\\n\\n![控制中心概览](/upload/asset/1776db94120e02e88a408.png)\\n\\n- 左侧导航栏：主要包含用户控制台的功能跳转选项。\\n- 顶端导航栏：提供平台公共资源的跳转选项。\\n- 页面中部：展示账户设置、调试工具、分析工具、开发文档、平台功能快捷跳转等内容。\\n\\n用户控制台主要功能：\\n- [控制中心](https://www.youquant.com/m/dashboard)\\n 跳转至『控制中心』页面。在优宽量化交易平台运行量化交易程序（即实盘）需要满足三个条件：1、部署一个可用的托管者；2、拥有一个可用的策略；3、配置交易所账户供策略程序操作。\\n- [实盘](https://www.youquant.com/m/robots)\\n 跳转至『实盘』页面，实盘即量化交易策略程序实例。实盘页面主要用于管理、创建、控制策略实盘。\\n- [策略库](https://www.youquant.com/m/strategies)\\n 跳转至『策略库』页面，策略库可以分类保存、管理、设计编写各种编程语言的策略。\\n- [托管者](https://www.youquant.com/m/nodes)\\n 跳转至『托管者』页面，托管者页面可以管理、部署当前账户关联的托管者程序。\\n- [交易所](https://www.youquant.com/m/platforms)\\n 跳转至『交易所』页面，交易所页面可以管理、配置需要进行量化交易的交易所账户。\\n\\n平台公共资源：\\n- [策略](https://www.youquant.com/square)\\n 在策略广场，您可以找到各种编程语言编写的公开或上架出租的策略，适合学习和参考。\\n- [围观](https://www.youquant.com/live)\\n 实盘围观页面展示用户公开的策略实盘。\\n- [文库](https://www.youquant.com/digest)\\n 平台文库保存了平台原创文章等资料，方便您入门学习。\\n- [社区](https://www.youquant.com/bbs)\\n 社区论坛为您提供交流、讨论量化交易领域的平台。\\n- [众包](https://www.youquant.com/markets)\\n 众包版块为策略设计者和需求者搭建高效的沟通渠道。\\n- [公开课](https://www.youquant.com/class)\\n 新增的公开课页面记录了平台的视频教程。\\n- [API文档](https://www.youquant.com/api)\\n API文档页面为您编写和设计策略提供技术资料支持。\\n\\n电子书PDF：\\n|书名|优宽量化交易入门|商品期货量化交易实战|纸版书籍|\\n|-|-|-|-|\\n|封面| /upload/asset/170273a325477e5bc8d3.png | /upload/asset/17118c7d918c1ff4f5c9.png | /upload/asset/23702a1d5ef1135cca7bb.png |\\n|链接| https://q.youquant.com/chart/doc/fmzquantbook.pdf | https://q.youquant.com/chart/doc/fmzcfquant.pdf | [京东自营购买](https://item.jd.com/13624374.html) |\", \"title\": \"欢迎使用优宽量化交易平台\"}, {\"_src_hash\": \"ffefcd71c6528b565865dccb1dcba9367617f2a60d51e38eacfed634c6049704\", \"children\": [{\"_src_hash\": \"f88760204f56e16fc3c836ee0a5f334f0b65b2db4786e2e3adecef6c1a600cc5\", \"desc\": \"平台支持用```JavaScript```编写策略，可以直接使用内置的```TA```指标库和```talib```指标库，见「内置库」一节。也可以用 TypeScript 编写，见本页末尾「用 TypeScript 编写」。\\n\\n程序异常报错、接口业务报错\\n在```JavaScript```语言策略中，发生程序异常报错或接口业务报错时，错误日志将显示策略代码中发生错误的具体行号，便于策略调试与问题排查。\\n\\n支持```JavaScript```异步编程特性：\\n- setTimeout / clearTimeout\\n ```javascript\\n function main() {\\n let symbol = \\\"rb888\\\"\\n let delay = 10\\n let depth = exchange.GetDepth(symbol)\\n let callback = function(e, id, msg) {\\n Log(msg + \\\"，撤销订单。\\\")\\n e.CancelOrder(id)\\n }\\n\\n let ordersLen = 3\\n let arrTimerId = []\\n for (let i = 1 ; i <= ordersLen ; i++) {\\n let orderId = exchange.CreateOrder(symbol, \\\"buy\\\", depth.Bids[i * 3].Price, i * 0.1)\\n let timerId = setTimeout(callback, delay * 1000, exchange, orderId, `延迟${delay}秒`)\\n Log(\\\"i:\\\", i, \\\", timerId:\\\", timerId)\\n arrTimerId.push(timerId)\\n }\\n\\n // clearTimeout\\n let clearTimeoutIdx = 1\\n Log(\\\"clearTimeoutIdx:\\\", clearTimeoutIdx, `, arrTimerId[clearTimeoutIdx]:`, arrTimerId[clearTimeoutIdx])\\n clearTimeout(arrTimerId[clearTimeoutIdx])\\n\\n Sleep(60 * 1000)\\n }\\n ```\\n- fetch\\n ```fetch```函数是```HttpQuery```函数的异步版本重载。\\n\\n 使用```await```关键字以同步语法处理异步操作：\\n ```javascript\\n function main() {\\n let url = \\\"https://httpbin.org/get?test=123\\\"\\n const promiseBooks = new Promise(async function(resolve, reject) {\\n Log(\\\"开始执行\\\")\\n let data = await fetch(url)\\n Log(\\\"data.ok:\\\", data.ok, \\\", data.text():\\\", data.text())\\n if (data.ok) {\\n Log(\\\"成功获取 data:\\\", data)\\n return resolve(data.text())\\n } else {\\n return reject(new Error(\\\"data 无效\\\"))\\n }\\n })\\n\\n promiseBooks.then(function(ret) {\\n Log(\\\"ret:\\\", ret)\\n }).catch(function(err) {\\n Log(\\\"err.name:\\\", err.name, \\\"err.stack:\\\", err.stack, \\\"err.message:\\\", err.message)\\n })\\n }\\n ```\\n- 使用```Promise.all```并发执行多个异步网络请求：\\n ```javascript\\n async function main() {\\n let symbols = [\\\"test1\\\", \\\"test2\\\", \\\"test3\\\"] // 等待请求耗时： 99 毫秒\\n let arr = []\\n\\n let beginTs1 = new Date().getTime()\\n for (let symbol of symbols) {\\n let url = `https://httpbin.org/get?test=${symbol}`\\n arr.push(fetch(url).then(function(resp) {\\n if (resp.ok) {\\n return {\\\"symbol\\\": symbol, \\\"json\\\": resp.json()}\\n } else {\\n throw \\\"req failed\\\"\\n }\\n }))\\n }\\n let endTs1 = new Date().getTime()\\n\\n let beginTs2 = new Date().getTime()\\n const ret = await Promise.all(arr)\\n for (let data of ret) {\\n Log(data)\\n }\\n let endTs2 = new Date().getTime()\\n\\n Log(\\\"创建请求耗时：\\\", endTs1 - beginTs1, \\\"毫秒\\\")\\n Log(\\\"等待请求耗时：\\\", endTs2 - beginTs2, \\\"毫秒\\\")\\n\\n LogStatus(_D(), ret)\\n }\\n ```\\n- 使用```Promise.race```获取多个异步请求中最先```resolved```或```rejected```的结果：\\n ```javascript\\n async function getTicker(e) {\\n return Promise.resolve().then(function() {\\n let ret = e.GetTicker(\\\"rb888\\\")\\n return {\\\"name\\\": e.GetLabel(), \\\"ret\\\": ret}\\n })\\n }\\n\\n async function main() {\\n Log(\\\"begin\\\")\\n let arrPromise = []\\n for (let e of exchanges) {\\n arrPromise.push(getTicker(e))\\n }\\n\\n let ret = await Promise.race(arrPromise)\\n Log(ret)\\n }\\n ```\\n- 在```threading.Thread```中使用```setTimeout()```函数：\\n ```javascript\\n function test() {\\n Log(\\\"Test function started\\\") // step 3. Test function started\\n let timerId1 = setTimeout(function() {\\n Log(\\\"Timeout callback executed after 5 seconds\\\") // step 5. Timeout callback executed after 5 seconds\\n }, 5000)\\n Log(\\\"Test function completed\\\") // step 4. Test function completed\\n }\\n\\n function main() {\\n Log(\\\"Main function started\\\") // step 1. Main function started\\n let t1 = threading.Thread(test)\\n Log(\\\"Worker thread created successfully\\\") // step 2. Worker thread created successfully\\n t1.join()\\n Log(\\\"Main function completed\\\") // step 6. Main function completed\\n }\\n ```\\n- 多线程并发获取```ticker```数据的异步处理示例：\\n 由于```exchange.GetTicker()```是同步阻塞操作，即使包装在Promise中，内部执行仍是同步的；JavaScript是单线程的，同步操作会阻塞事件循环；微任务队列中的回调函数仍然是串行执行的。\\n ```javascript\\n async function getTicker(symbol) {\\n Log(\\\"getTicker symbol:\\\", symbol)\\n return Promise.resolve().then(function() {\\n // 注意与fetch请求数据时的区别\\n let ret = exchange.GetTicker(symbol)\\n Log(ret)\\n return ret\\n })\\n }\\n\\n async function main() {\\n let symbols = [\\\"rb888\\\", \\\"MA888\\\", \\\"i888\\\"]\\n let t1 = threading.Thread(async function(symbols, func) {\\n let arrPromise = []\\n for (let symbol of symbols) {\\n arrPromise.push(func(symbol))\\n }\\n let ret = await Promise.all(arrPromise)\\n Log(\\\"ret:\\\", ret)\\n }, symbols, getTicker)\\n\\n t1.join()\\n }\\n ```\\n\\n### 用 TypeScript 编写\\n\\nTypeScript 不是单独的语言选项：创建策略时选择```JavaScript```，在代码中（通常是首行）写一行```//@ts-check```注释（或点击策略编辑区右上角的「TypeScript」按钮），平台就按 TypeScript 处理，在回测和实盘运行前先编译为 JavaScript。通过 MCP 服务保存策略时，语言可以写```typescript```，平台按 JavaScript 策略保存，并在代码开头自动加上```//@ts-check```。\\n\\n平台 API 的类型声明由策略编辑器内置提供，不需要在代码中引用：全局函数、```exchange```对象、```ITicker```、```IRecord```、```IOrder```、```IPosition```等数据结构接口，以及```TA```、```talib```等。静态类型检查能在编写时发现参数个数、属性名、类型用错之类的问题。运行时的语言特性、API 和库与 JavaScript 相同。\\n\\n```typescript\\n//@ts-check\\nfunction getSignal(ticker: ITicker, ma: number): \\\"buy\\\" | \\\"sell\\\" | null {\\n if (ticker.Last > ma) {\\n return \\\"buy\\\"\\n }\\n return ticker.Last < ma ? \\\"sell\\\" : null\\n}\\n\\nfunction main() {\\n exchange.SetContractType(\\\"rb888\\\")\\n const records = exchange.GetRecords()\\n const ticker = exchange.GetTicker()\\n if (records && ticker && records.length > 20) {\\n const ma = TA.MA(records, 20)\\n Log(getSignal(ticker, ma[ma.length - 1]))\\n }\\n}\\n```\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"09603010cbcb459bdcdfcb79698a86533812f9a53b95b09e2fec3030d0be87fc\", \"desc\": \"平台支持用```Python 3```编写策略，不支持 Python 2。实盘以及在托管者上进行的回测，使用托管者所在机器上安装的 Python 解释器运行策略。\\n\\n### 解释器\\n\\n实盘按以下顺序查找解释器，使用第一个能启动、并且版本为 Python 3 的程序：\\n1. 策略代码首行```#!```指定的解释器，例如```#!/opt/venv/bin/python3```；写成```#!/usr/bin/env python3.11```时取```python3.11```；\\n2. 环境变量```PYTHON_BIN```指定的解释器；\\n3. ```python3```；\\n4. ```python```。\\n\\n首行指定的解释器不可用时，托管者退回后面的候选，并在实盘目录的```stderr.log```中留一行说明。不想改策略代码时，也可以在启动托管者之前设置环境变量来指定解释器（例如虚拟环境中的 Python）：\\n\\n```bash\\nexport PYTHON_BIN=/opt/venv/bin/python3\\n```\\n\\n在托管者上进行的回测不读```PYTHON_BIN```：按首行```#!```指定的解释器、```python3```、```python```的顺序，在```PATH```中查找第一个存在的程序。\\n\\n### 策略结构与参数\\n\\n策略入口为```def main()```，可选的```init()```、```onexit()```由托管者自动调用（Python 不支持```onerror()```），见「策略入口函数」一节。界面参数是同名的全局变量；在函数中给参数重新赋值时，需要先用```global```声明。\\n\\n### 错误与返回值\\n\\nAPI 函数调用失败时返回```None```，并在日志中输出错误信息。使用返回值之前先判断，或者用```_C()```重试。策略中未捕获的异常会结束运行，错误信息记录在日志中。\\n\\n### 输出\\n\\n```print()```的输出写入托管者目录下的```logs/storage/<实盘ID>/stdout.log```（错误输出写入同目录的```stderr.log```），不会出现在实盘日志里。需要显示在日志中的内容请用 {@fun/Log/Log Log}。\\n\\n### 第三方库\\n\\n策略可以导入解释器中已经安装的任何库。安装时要使用托管者运行策略的那个解释器，例如：\\n\\n```bash\\npython3 -m pip install numpy\\n# 首行用 #! 指定了解释器时，用该解释器安装，例如\\n/opt/venv/bin/python3 -m pip install numpy\\n# 设置了 PYTHON_BIN 时\\n$PYTHON_BIN -m pip install numpy\\n```\\n\\n使用```talib```需要在托管者所在机器上安装 TA-Lib（```talib```包）和```numpy```。\\n\\n### 自定义模块\\n\\n策略运行时的当前目录是实盘目录```logs/storage/<实盘ID>/```（用相对路径打开的文件落在这里，随实盘保留）；```PYTHONPATH```是托管者为本次运行创建的临时目录，运行结束后会被删除。当前目录不在模块搜索路径中，放在实盘目录下的```.py```文件不会被自动找到。导入自己编写的模块有两种方式：\\n- 把模块安装到解释器的```site-packages```中（例如做成包用```pip install```安装，或者直接复制到```site-packages```目录）；\\n- 在策略中先把模块所在目录的绝对路径加入```sys.path```，再导入。\\n\\n例如模块文件```/home/user/my_modules/mymath.py```：\\n\\n```python\\n# mymath.py\\ndef add(a, b):\\n return a + b\\n```\\n\\n策略代码：\\n\\n```python\\nimport sys\\nsys.path.append(\\\"/home/user/my_modules\\\") # 模块所在目录的绝对路径\\n\\nimport mymath\\n\\ndef main():\\n Log(\\\"mymath.add(1, 2):\\\", mymath.add(1, 2))\\n```\\n\\n把核心代码做成模块放在自己的托管者上，策略代码中只保留调用部分，也是一种不把核心代码上传到平台的做法。\", \"title\": \"Python\"}, {\"_src_hash\": \"f27fc98f06c11fe05b3755860e059d884053b76b04d9e1c57d51ab2082fdb7a3\", \"desc\": \"平台支持使用```Rust```编程语言编写策略。Rust 语言的策略采用预先编译后执行的模式：回测时，策略代码由平台服务器编译，并在浏览器端的回测系统中运行；实盘环境中，Rust 语言的策略在编译通过后基于托管者运行。\\n\\n借助 Rust 的所有权模型与静态类型系统，您可以在优宽量化交易平台上编写内存安全、高性能的交易策略。\\n\\n- 平台API自动注入\\n 策略代码只需一个```fn main()```入口即可。全部平台 API（```exchange```、```exchanges```、```TA```、```Log!```/```LogStatus!```、```_G!```/```_C!```等）均通过 prelude 自动注入，无需任何```use```/```mod```声明即可直接调用。可能失败的 API 调用会返回```Result```类型，可配合```_C!```宏实现自动重试。\\n ```rust\\n fn main() {\\n // GetTicker返回Result，用_C!宏重试直到调用成功\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(\\\"Last:\\\", ticker.Last);\\n }\\n ```\\n- 策略参数注入为全局常量\\n 界面上配置的策略参数将以全局常量的形式注入策略，其 Rust 类型由参数的实际值决定（数字对应```f64```、布尔值对应```bool```、字符串/密码对应```&str```等），可直接通过参数名引用。\\n- 支持第三方crate\\n 策略源码是唯一的代码文件（没有单独的 Cargo.toml），需在源码最顶部使用 cargo-script 风格的 frontmatter 声明依赖，构建时会自动合并进 Cargo.toml：\\n ```rust\\n ---\\n [dependencies]\\n serde_json = \\\"1\\\"\\n ---\\n fn main() {\\n let v: serde_json::Value = serde_json::from_str(r#\\\"{\\\"symbol\\\":\\\"BTC_USDT\\\",\\\"qty\\\":0.01}\\\"#).unwrap();\\n Log!(\\\"解析结果:\\\", v.to_string());\\n }\\n ```\\n 注意：编译沙盒中没有系统 OpenSSL，因此需要 TLS 的 crate（HTTP/WebSocket 客户端等）请选择基于纯 Rust 实现的```rustls```（例如为```tokio-tungstenite```开启```rustls-tls-webpki-roots```特性），避免依赖```native-tls```/```openssl-sys```；WebSocket 连接建议优先使用内置的```Dial()```函数，无需引入第三方 crate。\\n- 编辑器支持\\n 策略编辑器为 Rust 策略集成了```rust-analyzer```，可提供代码补全与实时诊断。\", \"title\": \"Rust\"}, {\"_src_hash\": \"00deed52f1c30905f13679e98f27b1b0cfe4b39353be05cb70c4d45d3a529dde\", \"desc\": \"平台支持My语言（麦语言）编写和设计策略，兼容文华麦语言的大部分语法、指令和函数。My语言鼓励积木式编程，将复杂算法拆解为函数模块。通过简洁的语法、专用数据结构和强大的金融函数库，支持复杂金融逻辑的实现。以模块化方式构建应用，有效提升开发效率和代码可维护性。\\n\\nMy语言策略示例：基于平移布林通道的交易系统\\n\\n```My\\nM := 12; // 参数范围 1, 20\\nN := 3; // 参数范围 1, 10\\nSDEV := 2; // 参数范围 1, 10\\nP := 16; // 参数范围 1, 20\\n\\n// 该策略为趋势跟踪交易策略，适用较大周期，如日线。\\n// 该模型仅用作模型开发案例，依此入市，风险自负。\\n\\n////////////////////////////////////////////////////////\\n\\n// 平移BOLL通道计算\\nMID:=MA(C,N); // 计算中轨\\nTMP:=STD(C,M)*SDEV; // 计算标准差\\nDISPTOP:=REF(MID,P)+TMP; // 平移BOLL通道上轨\\nDISPBOTTOM:=REF(MID,P)-TMP; // 平移BOLL通道下轨\\n\\n// 系统入场\\nH>=DISPTOP,BPK;\\nL<=DISPBOTTOM,SPK;\\nAUTOFILTER;\\n```\\n\\n- [优宽量化My语言文档](https://www.youquant.com/bbs-topic/8232)\\n- [优宽量化My语言--My语言交易类库参数](https://www.youquant.com/digest-topic/8529)\", \"title\": \"My语言（麦语言）\"}, {\"_src_hash\": \"0029387a44e26a9b56d50534d394f7f116236580688e2345ff27a4efd90f45cf\", \"desc\": \"平台支持并兼容```Trading View```的PINE语言脚本。PINE语言是一种轻量级但功能强大的策略编程语言，用于创建可进行回测和实盘交易的技术指标与策略。活跃的社区已创作了超过10万个PINE脚本。\\n用户可以轻松获取并应用各种技术分析工具和交易策略；能够借助社区脚本快速实现交易想法，无需从零开始编写代码，从而大幅缩短开发周期；帮助新手和资深交易员学习并理解不同的技术指标、策略和编程概念。\\n\\nPINE语言策略示例：超级趋势策略\\n```pine\\nstrategy(\\\"supertrend\\\", overlay=true)\\n\\n[supertrend, direction] = ta.supertrend(input(5, \\\"factor\\\"), input.int(10, \\\"atrPeriod\\\"))\\nplot(direction < 0 ? supertrend : na, \\\"Up direction\\\", color = color.green, style=plot.style_linebr)\\nplot(direction > 0 ? supertrend : na, \\\"Down direction\\\", color = color.red, style=plot.style_linebr)\\n\\nif direction < 0\\n if supertrend > supertrend[2]\\n strategy.entry(\\\"entry long\\\", strategy.long)\\n else if strategy.position_size < 0\\n strategy.close_all()\\nelse if direction > 0\\n if supertrend < supertrend[3]\\n strategy.entry(\\\"entry short\\\", strategy.short)\\n else if strategy.position_size > 0\\n strategy.close_all()\\n```\\n\\n- [PINE Script 文档](https://www.youquant.com/bbs-topic/9326)\", \"title\": \"PINE语言\"}, {\"_src_hash\": \"bca5abf9563ac0fff9c8949b4baac5fdb7fc8688320792e003d226915a4ea1ec\", \"desc\": \"平台支持以 Workflow 工作流方式编写策略。工作流是一种可视化的策略设计方式，通过节点连接和配置来构建交易逻辑，无需编写代码即可实现策略。\\n\\n### 工作流特点\\n- 可视化拖拽设计，所见即所得\\n- 预置丰富的功能节点（数据获取、指标计算、条件判断、交易执行等）\\n- 降低编程门槛，适合快速搭建和验证策略\\n- 支持回测功能，可视化查看节点执行状态\", \"title\": \"Workflow工作流\"}], \"desc\": \"在优宽量化交易平台上，可以使用哪些编程语言来编写我的交易策略？\\n\\n优宽量化交易平台支持使用```JavaScript```、```Python```、```Rust```、[```PINE```](https://www.youquant.com/bbs-topic/9326)、[```My语言```](https://www.youquant.com/bbs-topic/8232)以及```Workflow```工作流来编写和设计交易策略。\", \"title\": \"编程语言\"}, {\"_src_hash\": \"09958107fdfec6e1f80dffcbbf0b37bcbdec62fbbbb83658ad2e5b053959bf2b\", \"children\": [], \"desc\": \"- 商品期货：支持CTP协议、易盛协议，支持穿透式监管。\\n- 股票证券：支持[富途证券](https://www.youquant.com/bbs-topic/6270)、[中泰证券(XTP)](https://xtp.zts.com.cn/)。\", \"title\": \"支持的协议\"}, {\"_src_hash\": \"aba7bd7a273be3011e2ff019feb8cd352d5fb7f8a9d169522e66cb14c067b570\", \"children\": [], \"desc\": \"在优宽量化交易平台上配置的账户信息、策略参数中的加密字符串等敏感数据均在浏览器端进行加密处理。平台存储的所有信息均为加密数据（非明文形式），仅用户的私有设备能够解密使用，从而极大地提升了敏感数据的安全性。如果策略代码、参数设置、策略描述等信息中包含其他敏感信息，请勿公开或出售该策略。\\n\\n- 修改优宽量化交易平台账号密码后，所有交易所配置将失效，需按以下步骤处理：\\n 1、重新在[「交易所」管理页面](https://www.youquant.com/m/platforms)配置交易所账户的相关密钥、密码等信息。\\n 2、停止所有托管者，使用修改后的优宽量化交易平台账户密码重新部署并运行托管者。\", \"title\": \"密钥安全性\"}, {\"_src_hash\": \"9041b680caaf62e3cfefe31ccab2944e50b73921c1eea0ee38d068c663e365a2\", \"children\": [], \"desc\": \"在优宽量化交易平台上，「实盘」的概念区别于「回测」，指的是创建一个真正与交易所交互（获取行情、查询持仓、下单撤单等）的策略程序实例。与交易所生产环境交互的策略程序实例称为实盘，与交易所模拟环境（许多交易所提供测试环境）交互的策略程序实例也称为实盘。\\n在优宽量化交易平台上[创建一个实盘](https://www.youquant.com/m/add-robot)需要满足三个条件：\\n\\n### 创建实盘的条件\\n- 一个可用的策略\\n 可以在平台[策略库页面](https://www.youquant.com/m/strategies)，点击「新建策略」按钮创建策略。编写并设计策略后保存，策略将保存在策略库中。创建实盘时，在[实盘创建页面](https://www.youquant.com/m/add-robot)的「实盘配置」栏目下「运行策略」下拉框中即可选择策略库中的策略。\\n- 至少部署一个可用的托管者\\n 可以在平台[托管者页面](https://www.youquant.com/m/nodes)，点击「部署托管者」按钮进行托管者部署。托管者部署成功后，创建实盘时在[实盘创建页面](https://www.youquant.com/m/add-robot)的「实盘配置」栏目下「托管主机」下拉框中即可选择已部署的托管者。\\n- 至少配置一个可用的交易所\\n 可以在平台[交易所页面](https://www.youquant.com/m/platforms)，点击「添加交易所」按钮添加交易所，配置交易所账号信息。交易所配置完成后，创建实盘时在[实盘创建页面](https://www.youquant.com/m/add-robot)的「交易配置」栏目下「交易平台」下拉框中即可选择已配置的交易所。\\n\\n最后在实盘创建页面点击「创建实盘」按钮即可创建并运行一个量化交易策略程序实例（即优宽量化交易平台的实盘）。\\n\\n### 实盘分组\\n对于已创建的实盘可以进行分组管理，支持自定义分组名称。\\n\\n### 实盘围观\\n实盘可以公开展示，也可以创建私有围观链接发送给特定群体进行展示。\\n\\n### 实盘计费\\n实盘按小时计费，每个实盘每小时 0.125 CNY，不足一小时按一小时计费。创建新实盘将立即开始计费，实盘「停止」/「重启」不会重复计费。\\n可以在[充值页面](https://www.youquant.com/m/billing)查询所有计费的「账单明细」。\\n\\n### 实盘监控\\n在[实盘管理页面](https://www.youquant.com/m/robots)实盘列表中，处于运行中的实盘右侧**操作栏**中可以点击「监控」按钮开启实盘监控。开启监控后，如果实盘非手动操作退出，\\n当前优宽量化交易平台绑定的邮箱将收到通知消息。\\n\\n### 实盘数据库\\n以实盘Id```123456```为例，其对应的数据库文件位于该实盘所属托管者目录下的路径：```/logs/storage/123456/123456.db3```，其中数据库文件名为```123456.db3```。\\n数据库中包含以下表：\\n- chart：记录图表数据。\\n- kvdb：记录```_G()```函数持久化保存的数据。\\n- log：记录实盘日志数据。\\n- profit：记录实盘收益数据。\", \"title\": \"实盘\"}, {\"_src_hash\": \"bbcf6ec1d2313fb8893669753dc3ca315c65c3346436e2b2002e9b52aa7e7406\", \"children\": [], \"desc\": \"[策略库](https://www.youquant.com/m/strategies)页面保存当前账号下的所有策略，策略可以使用多种编程语言和方式进行设计。\\n\\n### 策略分组\\n策略支持分组管理功能，可以自定义分组名称。\\n\\n### 策略公开、出租\\n可以生成策略的「复制码」，用于公开分享策略。\\n可以生成策略的「注册码」，用于策略出租服务。\\n\\n### 策略导出、导入\\n在策略库页面中，点击策略名称即可跳转至该策略的编辑页面，编辑页面提供「导入」、「导出」功能。\\n\\n一个完整的策略包含：\\n- 策略源码\\n- 策略描述\\n- 策略笔记\\n- 策略说明书\\n- 策略参数配置\\n- 策略交互配置\\n\\n因此，导出策略时会生成一个包含上述所有信息的XML文件。新建空白策略后，导入该XML文件即可完整还原策略。策略迁移不能仅复制源码，必须导入完整的策略文件（或手动配置策略参数和交互设计）。\", \"title\": \"策略库\"}, {\"_src_hash\": \"454d6adcc21911b629febd1f0d87a650adbcf758be26ca5e7ffe118631830d00\", \"children\": [{\"_src_hash\": \"5e4484f522fe3eec0257f97240ebb7060eebce479a8109ee86370a132affe46f\", \"children\": [{\"_src_hash\": \"df265a8232c573f7ffa63d0d5135fba70557921144626910f7a38218f657d458\", \"desc\": \"在[托管者部署页面](https://www.youquant.com/m/add-node)点击**一键租用托管者**标签，根据配置、服务器机房地区等需求选择需要部署的服务器。\\n\\n点击「立即购买」并输入当前优宽量化交易平台的账号密码进行验证，验证通过后将自动进行托管者程序部署。整个部署过程需要几分钟时间，系统会自动安装常用的Python库。\\n\\n点击「立即购买」后租用的服务器由于是通过平台代为租用，仅具有有限的系统权限，不支持远程登录。如需使用未预装的第三方Python库，建议使用私有服务器进行手动部署。\\n\\n通过**一键租用托管者**功能租用的服务器采用独立计费方式，与实盘计费相互独立。\\n\\n点击「重新部署」按钮不会删除托管者目录下logs目录中的实盘日志和数据文件。\", \"title\": \"一键租用托管者\"}, {\"_src_hash\": \"9d68f7fbba49379d422428bd6baadd8eecc13771ec92a54403226e3b767c2e18\", \"desc\": \"您可以将托管者部署到各种设备上，例如：个人电脑、服务器、树莓派等，支持多种主流操作系统。\\n- Linux 命令行版本：Linux AMD64 / Linux 386 / Linux ARM64 / Linux ARMv7\\n- Mac 命令行版本：Mac Intel64 / Apple Silicon\\n- Windows 命令行版本、界面版本：64位 / 32位\\n- Docker 镜像\\n\\n登录需要部署托管者程序的设备后，根据设备的操作系统下载对应的托管者程序。下载链接可以在[托管者部署页面](https://www.youquant.com/m/add-node)点击**手动部署托管者**标签后显示的内容中找到。\\n部署托管者程序需要设置2个参数：\\n\\n![手动部署托管者页面](/upload/asset/17802f8375b2994284b5e.png)\\n\\n1、包含优宽量化交易平台UID的通信地址。\\n2、UID对应的优宽量化交易平台账号的密码。\\n\\n### 部署托管者时配置「通信地址」和「优宽量化交易平台账号密码」\\n- Windows界面版托管者\\n Windows界面版托管者可以直接将这两个参数填写到托管者界面上对应的输入框控件中。\\n\\n- 命令行版托管者\\n 对于其他命令行版托管者程序，不同的操作系统有不同的指令。以Linux & Mac为例，使用命令：```./robot -s node.youquant.com/123456 -p 654321```，以下说明命令中的各个部分：\\n\\n ```./robot```表示运行robot这个可执行程序（即托管者程序），其中```123456```为UID，```654321```为UID对应的优宽量化交易平台账户的密码。\\n ```-s```参数表示「优宽量化交易平台UID的通信地址」，参数值可以填写例如：```node.youquant.com/123456```。\\n ```-p```参数表示「UID对应的优宽量化交易平台账号的密码」，参数值可以填写例如：```654321```。\\n\\n 请注意这里的参数仅为示例，实际参数可以登录```https://www.youquant.com```后，在[托管者部署页面](https://www.youquant.com/m/add-node)点击**手动部署托管者**标签后查看。\\n ```-p```参数并非必须明文写在部署托管者的命令中，可以使用```./robot -s node.youquant.com/123456```命令运行，然后会提示输入密码，再手动输入密码即可。\\n 另外请注意执行程序的权限等问题，需要给予托管者程序足够的权限，解除运行限制。\", \"title\": \"手动部署托管者\"}, {\"_src_hash\": \"17839b6cb8cd8cab9911e7592f3bb7cacc2a10131c5c1a7a0d340ef2207a5ada\", \"desc\": \"重要操作提示\\n- 错误操作：\\n 请勿直接在服务器等设备上强制停止托管者进程（如直接终止进程或重启服务器）。此类操作可能导致托管者与优宽平台失联，引发以下问题：\\n - 实盘无法正常停止\\n - 实盘持续运行并计费\\n 出现此类情况，需要先删除已离线的托管者，才能停止实盘。\\n\\n- 正确操作流程：\\n - 确认托管者上没有任何运行中的实盘\\n - 再执行删除托管者或停止托管者进程的操作\\n 操作原则：先停实盘，再停托管者。\", \"title\": \"托管者操作注意事项\"}], \"desc\": \"在[托管者管理页面](https://www.youquant.com/m/nodes)可以查看当前优宽量化交易平台账号部署关联的托管者，支持列表展示或详细信息展示两种模式。在此页面可以查询托管者的IP地址、版本、编译发布时间等相关信息。点击**部署托管者**按钮可跳转至[托管者部署页面](https://www.youquant.com/m/add-node)。托管者部署分为两种模式：1、一键租用托管者；2、手动部署托管者。\\n\\n![托管者部署页面](/upload/asset/17807fc8f0ecd4a2ea65f.png)\", \"title\": \"部署托管者\"}, {\"_src_hash\": \"f2065701fdbe5c7151e39d01e6f53e5b3887de2e70cd1bb47fe33d210dd2fe23\", \"desc\": \"- ```Windows```系统的界面版托管者可以直接在托管者软件界面上设置IP地址，托管者软件默认为自动设置IP。\\n- 命令行环境下运行的托管者使用```-I```参数指定IP地址。\\n ```text\\n -I string\\n custom local ip address\\n -c string\\n config file\\n -d string\\n custom dns resolve server\\n -e string\\n docker node executable path\\n -f string\\n docker settings json\\n -i string\\n docker image name\\n -n string\\n node name\\n -p string\\n password\\n -s string\\n server address\\n -u string\\n run as system user\\n -v version info\\n -vv\\n show verbose log\\n -w string\\n working directory\\n ```\", \"title\": \"全局指定IP地址\"}, {\"_src_hash\": \"56b305efcb74f40d0de34f893f030d78eb6b1d2547e695b15ec8549dbf2d02d6\", \"desc\": \"下载托管者软件后，解压缩得到的可执行文件```robot```即为托管者程序，在部署托管者时可以为托管者程序指定参数。\\n- ```-v```：\\n 查看当前托管者程序的版本、编译时间等信息。完整的执行命令以```苹果电脑Mac系统```为例：```./robot -v```。\\n- ```-vv```：\\n 托管者程序的运行详细日志和交互消息，默认不显示且不写入托管者日志文件。这样可以防止频繁的交互指令导致日志记录膨胀并占用硬盘空间。如果您需要记录托管者的详细日志并在托管者运行时显示出来，可以通过使用```-vv```参数来设置详细日志和交互消息写入托管者日志文件。\\n- ```-s```：\\n 运行托管者程序时指定与优宽量化交易平台通信的地址。完整的执行命令以```苹果电脑Mac系统```为例：```./robot -s node.youquant.com/xxxxxxx```，```xxxxxxx```部分为每个优宽量化交易平台账号的唯一识别ID，命令执行后会提示要求输入对应的优宽量化交易平台账号密码。\\n- ```-p```：\\n 可以直接在运行命令中通过参数指定密码，不建议这样做，因为会在当前系统记录中留下密码参数。假设地址```node.youquant.com/xxxxxxx```对应的账号密码为：```abc123456```。完整的执行命令以```苹果电脑Mac系统```为例：```./robot -s node.youquant.com/xxxxxxx -p abc123456```。\\n- ```-n```：\\n 为运行的托管者程序添加标签信息。完整的执行命令以```苹果电脑Mac系统```为例：```./robot -n macTest -s node.youquant.com/xxxxxxx```。在平台托管者管理页面的托管者信息中会显示```macTest```文本标记。\\n- ```-l```：\\n 打印当前托管者支持的交易所列表。完整的执行命令以```苹果电脑Mac系统```为例：```./robot -l```。即可输出所支持的交易所名称。\", \"title\": \"命令行版本托管者程序的参数\"}, {\"_src_hash\": \"f0a534a03d205033aa740b05db599f8c3d3924e3051c110968b19a0b7adc8ac3\", \"desc\": \"当需要将实盘数据迁移到其他设备（服务器）上的托管者时，可以将实盘的数据库文件（扩展名为db3的数据库文件）移动到目标设备（服务器）上托管者目录中的对应路径位置。将文件名设置为平台上对应的实盘ID，这样之前实盘的所有日志信息就不会因为迁移到新设备而丢失。\", \"title\": \"实盘数据迁移\"}, {\"_src_hash\": \"385fa151a5c2f6a4bd2d56b9fd03a803d6a69afe8582d6056b1dc06bc91b6f4d\", \"desc\": \"[托管者管理页面](https://www.youquant.com/m/nodes)，在**托管者列表操作项**或**托管者详情操作项**中可以开启**托管者监控**功能。开启监控后，如果托管者异常离线，绑定的邮箱将收到告警通知。\", \"title\": \"托管者监控\"}], \"desc\": \"优宽量化交易平台的托管者软件是整个量化交易系统的核心组件。[托管者](https://www.youquant.com/m/add-node)可以理解为您交易策略的执行引擎，负责处理复杂的数据请求、数据接收、网络连接、日志回传等任务。实盘策略程序运行在托管者软件上，而非运行在优宽量化交易平台网站上。\\n\\n托管者运行在您的服务器上，即使**优宽量化交易平台**网站出现网络故障也不会影响托管者的正常运行。托管者支持在```Linux```、```Windows```、```Mac OS```、```android```、```树莓派 ARM Linux```等系统上运行。托管者管理的实盘日志均保存在托管者程序所在目录的```./logs/storage```路径下，以```db3```格式的```Sqlite```数据库文件存储。您可以使用```Sqlite```管理软件直接编辑这些文件。对于这些扩展名为```db3```的实盘数据库文件，文件名即为实盘的```Id```。\", \"title\": \"托管者\"}, {\"_src_hash\": \"c25b3174ddfb82427e133050e5481117a00094198760dba312f571f07b788d6d\", \"children\": [], \"desc\": \"[交易所](https://www.youquant.com/m/platforms)页面用于管理和展示当前已配置的交易所。在优宽量化交易平台中，「交易所」是一个核心概念，简而言之，它是指包含可供策略程序操作的资金账户相关密钥配置、通信协议和接口封装的对象。\\n在交易所管理页面，点击「添加交易所」按钮即可跳转到[交易所添加页面](https://www.youquant.com/m/add-platform)，根据需求选择并填写配置信息。所有配置信息经本地加密后存储在优宽量化交易平台，因此平台不会记录明文数据。\\n\\n### 风控设置\\n在添加交易所页面可以开启「风控设置」，用于控制每日的下单和撤单次数：\\n- 「每天最大下单次数」：默认为500次\\n- 「每天最大撤单次数」：默认为500单\\n- 超过限制将禁止报单\\n\\n### 交易所对象\\n配置完成的交易所，在策略代码层面即为```exchange```对象（交易所对象）。可以查阅「语法手册」中的{@var/EXCHANGE/exchange exchange}。\\n在配置回测/实盘时，可以添加多个交易所，因此在策略代码层面有```exchanges```对象数组（交易所对象数组）。可以查阅「语法手册」中的{@var/EXCHANGE/exchanges exchanges}。\\n\\n### 使用交易所对象\\n在策略代码中可以调用交易所对象进行账户查询、行情获取、下单、撤单等操作，以```JavaScript```语言为例：\\n\\n```javascript\\nfunction main(){\\n while(true){\\n // 需要在判断exchange.IO(\\\"status\\\")函数返回1（真值）时才可调用行情、交易等函数\\n if(exchange.IO(\\\"status\\\")){\\n exchange.SetContractType(\\\"rb888\\\") // 设置当前操作合约为rb主力连续合约，即螺纹钢主力连续合约\\n var account = exchange.GetAccount() // 获取账户信息\\n var ticker = exchange.GetTicker() // 获取ticker行情\\n exchange.SetDirection(\\\"buy\\\") // 设置交易方向为开多仓\\n var id = exchange.Buy(ticker.Last, 1) // 下单\\n exchange.CancelOrder(id) // 撤单\\n LogStatus(_D(), \\\"已连接CTP！\\\")\\n } else {\\n LogStatus(_D(), \\\"未连接CTP！\\\")\\n }\\n Sleep(1000)\\n }\\n}\\n```\", \"title\": \"交易所\"}, {\"_src_hash\": \"eb4901ccb5b74da2b9270aa0909ff3c8c1814efe052c398559aba17883b6bc7a\", \"children\": [{\"_src_hash\": \"a8fd93d4b3c68406fdf4c50052cbd020100ef15f2428382eba3003842d435bcb\", \"desc\": \"优宽量化交易平台集成了先进的AI大模型助手功能，为用户提供智能化的策略开发和交易辅助服务。通过与业界领先的大语言模型深度集成，平台能够帮助用户快速解决编程问题、优化交易策略、分析市场数据，并提供专业的量化交易指导。\\n\\n优宽量化平台目前支持以下AI大模型：\\nClaude Sonnet 4 - Anthropic最新发布的高性能模型，具备卓越的代码理解和生成能力。\\n\\n- 如何调用AI助手\\n\\n ![策略编辑器菜单中的AI助手](/upload/asset/17814e2df2d333f331686.png)\\n\\n 在编辑器空白处点击右键，在弹出的菜单中选择「AI助手」选项，即可调用AI助手，或者使用快捷键```⌘K```调用AI助手。\\n- 使用AI助手解释代码\\n\\n ![策略编辑器中的AI助手解释代码](/upload/asset/177b46daa80540718669b.png)\\n\\n AI助手不仅能够帮助您编写代码，还能为您解释代码逻辑。选中需要解释的代码片段后点击右键，在弹出菜单中选择「解释这段代码」，即可查看AI助手提供的详细代码解释。\\n- 优化建议和代码重构\\n 选中代码片段后点击右键，在弹出菜单中选择「提出优化建议」或「重新优化代码」，AI助手将为您提供代码优化建议或直接生成优化后的代码。\", \"title\": \"AI助手\"}, {\"_src_hash\": \"6f24b7bc83ebc263e9ddb34c7193689310fe9301748725ae38769a60dd650a68\", \"desc\": \"在策略代码编辑区域点击鼠标右键，选择弹出菜单中的「命令面板」选项，可查看各种功能的快捷键组合和编辑器命令。\\n\\n![策略编辑器中菜单的命令面板显示](/upload/asset/176d81c8d3f43ba3d9510.png)\", \"title\": \"命令面板\"}, {\"_src_hash\": \"c9810cc88d110f9a01c238795b7f331a480c9922e8cf7e31add776b6eb1a5a56\", \"desc\": \"在**策略编辑页面**的「代码」编辑区内，可以快速查询「语法手册」。根据操作系统不同，使用不同的快捷键：\\n\\n![策略编辑器中语法手册速查](/upload/asset/177ef4e13792f0f0ecdf5.png)\\n\\n- Mac系统（苹果电脑）的浏览器中：按住```⌘```键不放。\\n- Windows系统的浏览器中：按住```Ctrl```键不放。\\n\\n然后将鼠标移动到需要查询的**变量名**或**函数名**上时，会出现跳转链接。点击该链接即可弹出「语法手册」，并自动定位到查询的内容。\", \"title\": \"语法手册速查\"}, {\"_src_hash\": \"86c516447509e520d1f7aa3d0b7f5db2681dce6458a64ae1648e1dc0bbb07ca4\", \"desc\": \"选中需要查询的内容，点击鼠标右键弹出菜单。\\n- 转到定义：跳转至所查询内容的定义位置。\\n- 转到引用：跳转至所查询内容的引用位置。\\n- 快速查看-速览定义：在不离开当前代码行的情况下查看所选代码的定义。\\n- 快速查看-查看引用：在不离开当前代码行的情况下查看其他代码行中对当前代码的引用情况，支持快速跳转，便于更好地理解代码逻辑和结构。\", \"title\": \"定义与引用跳转\"}, {\"_src_hash\": \"e5ed3f9a21677901fc8818d7c0c8a0ea632a8fec05e72197419f03ef25c4d02b\", \"desc\": \"线上策略编辑页面提供了完善的文档记录功能，可将策略代码、策略描述、使用说明、开发日志等信息分类记录。\\n\\n![策略文档选项说明](/upload/asset/176da0c4d57962ab4b622.png)\\n\\n- 代码：策略程序的源代码。优宽量化交易平台上的完整策略包含：策略源码、{@策略参数策略参数设计}、{@交互控件策略交互设计}、{@模板类库策略模板引用}。\\n- 笔记：用于记录策略开发过程中的相关内容。\\n- 描述：用于记录策略公开展示时的描述信息。\\n- 手册：用于记录仅在策略租用后才可查看的详细信息。\", \"title\": \"策略文档\"}, {\"_src_hash\": \"80951636e4efe1e762c7c36813684786cb21c23cca422fe16447bde4596560c0\", \"desc\": \"平台支持策略开发过程中的版本迭代功能，在**策略编辑页面**「代码」编辑区内，点击「历史版本」按钮可以打开策略历史版本管理页面。\\n\\n- 当前策略没有任何历史版本快照时，点击「立即创建」按钮创建当前策略的快照。快照内容包括：策略代码、笔记、描述、手册、参数设计、交互设计等。\\n\\n- 创建历史快照后，历史版本管理页面右侧会显示已保存的历史快照列表。点击该列表上方的「创建历史版本」按钮可以继续保存新的历史快照。\\n\\n- 编辑、使用历史快照：可以对已记录的策略历史快照进行**修改历史快照名称**、**删除历史快照**、**恢复到历史快照的策略版本**等操作。\\n\\n- 预览当前选定的历史快照：点击历史版本管理页面左下角的「预览」按钮，可以预览当前历史快照中的策略代码、笔记、描述、手册、参数设计、交互设计等内容。\\n\\n- 对比当前选定的历史快照与当前策略的差异：点击历史版本管理页面左下角的「对比」按钮，可以对比当前历史快照与当前策略之间的差异。\\n\\n\\n### 实盘运行历史版本\\n\\n策略的历史版本不仅可以用于代码管理和版本回滚，还可以直接在实盘中运行：\\n\\n- **设置默认运行版本**：在策略编辑器页面点击「历史版本」按钮，选中某个历史版本后，点击菜单中的「修改」按钮，在弹框中可以勾选「设置为默认版本」选项。如果不设置，默认运行最新版本。\\n\\n- **在实盘中使用历史版本**：创建实盘或修改实盘参数时，策略所有者可以选择策略的某个历史版本来运行。此功能仅对策略所有者有效。\\n\\n- **出租策略的版本控制**：当策略出租给其他用户时，租用方只能运行策略所有者设置的「默认运行版本」，无法选择其他历史版本。策略所有者可以通过设置默认运行版本来控制出租策略使用的版本。\", \"title\": \"历史版本管理\"}, {\"_src_hash\": \"9951b130dfe3280c73e1f435bc464dd611b648ab907684b961dc0546e0d42088\", \"alias\": \"其它\", \"desc\": \"- {@远程编辑远程编辑}\\n ![远程编辑截图](/upload/asset/177e04005e5a0eb1cfdf4.png)\\n- {@回测系统/保存回测设置保存回测设置}\\n ![保存回测设置截图](/upload/asset/177cfe6b5abe80311a33d.png)\\n- {@完整策略的导入与导出策略导入、导出}\\n ![策略导入导出截图](/upload/asset/177bdc0aee73d5ef7e351.png)\", \"title\": \"其它功能\"}], \"desc\": \"在[新建策略页面](https://www.youquant.com/m/add-strategy)或者在[策略库](https://www.youquant.com/m/strategies)中打开一个现有策略进入**编辑页面**（例如策略Id为123456的地址为：```https://www.youquant.com/m/edit-strategy/123456```）即可编写、设计策略。\\n\\n优宽量化交易平台的在线策略编辑器提供了强大的策略编辑辅助功能。\\n\\n![线上策略编辑器界面](/upload/asset/177a14afb58f40f5c4aab.png)\", \"title\": \"策略编辑器\"}, {\"_src_hash\": \"61a084d083d916f960bffa8c1afb0d2cb01b82d5216b92ec5179bd3430fe7322\", \"children\": [{\"_src_hash\": \"d9bf2d87d706ed5835284531d9c299be98c11ea9689285e2a72078b9a116e524\", \"desc\": \"优宽量化交易平台将回测模式分为**实盘级 Tick**回测和**模拟级 Tick**回测。**实盘级 Tick**回测完全基于完整的历史数据进行回测；**模拟级 Tick**回测则根据真实K线数据生成**tick数据**来进行回测。两者都是基于真实历史数据进行回测的，但**实盘级 Tick**回测的数据更精准，结果更加可信。[优宽量化回测机制说明](https://www.youquant.com/bbs-topic/8291)。需要注意的是，回测仅反映策略在历史数据下的表现，历史数据并不能完全代表未来的行情，因此对待回测结果应保持理性、客观的态度。\\n\\n**模拟级 Tick**回测根据底层K线周期生成模拟的**tick数据**，每个底层K线周期上最多生成12个回测时间点。而**实盘级 Tick**回测使用的是真实收集的逐秒tick数据，数据量大，回测速度较慢，因此不适合回测特别长的时间范围。优宽量化的回测机制允许策略在一根K线上进行多次交易，避免了仅能在收盘价成交的局限性，在保证精准度的同时兼顾了回测速度。\\n\\n- 模拟级 Tick\\n **模拟级 Tick**回测是根据回测系统的底层K线数据，按照特定算法在给定的底层K线Bar的最高价、最低价、开盘价、收盘价构成的价格框架内模拟出tick数据进行回测，作为回测时间序列上的实时tick数据，在策略程序调用接口时返回。具体可参考：[优宽量化模拟级别回测机制说明](https://www.youquant.com/bbs-topic/8292)。\\n\\n- 实盘级 Tick\\n 实盘级别回测使用真实的tick级别数据在Bar的时间序列中进行。对于基于tick级别数据的策略而言，使用实盘级别回测更贴近真实交易环境。实盘级别回测的tick是真实记录的数据，并非模拟生成。支持深度数据、市场成交记录数据回放，支持自定义深度，支持分笔数据。实盘级别回测数据最大支持50MB，在数据上限内不限制回测时间范围。如需尽可能增大回测时间范围，可以降低深度档位数值设置，不使用分笔数据以扩展回测时间范围。调用```GetDepth```、```GetTrades```函数获取回放行情数据。在时间轴上某个行情数据时刻，调用```GetTicker```、```GetTrades```、```GetDepth```、```GetRecords```，不会多次推动时间在回测时间轴上移动（不会触发跳转到下一个行情数据时刻）。对于以上某个函数的重复调用，将推动回测时间在回测时间轴上移动（跳转到下一个行情数据时刻）。回测时使用实盘级别回测不宜选择过早的时间段，因为过早的时间段可能没有实盘级别数据。\\n\\n**实盘级Tick**和**模拟级Tick**模式的回测系统成交撮合机制：订单成交撮合按照见价成交、全量成交的原则进行。因此回测系统中无法测试部分成交的场景。\", \"title\": \"回测系统模式\"}, {\"_src_hash\": \"e8b6f5679d911fcc7c2490b779f6c130b7b4850876cb3cb14ecb87cfe7699f13\", \"desc\": \"回测系统支持对以下语言编写的策略进行回测：```JavaScript```、```Python```、```Rust```、[```PINE```](https://www.youquant.com/bbs-topic/9326)、[```My语言```](https://www.youquant.com/bbs-topic/8232)，以及```Workflow```工作流。\\n\\n **JavaScript**策略的回测在浏览器端进行，其策略在实盘和回测运行时无需安装任何额外的软件、库或模块。\\n\\n **Python**语言的策略回测在托管者上进行，既可以在优宽量化的公共服务器上回测，也可以在用户自己的托管者上回测。实盘和回测均依赖托管者所在系统上安装的Python环境，如需使用第三方库，请自行安装；优宽量化的公共服务器仅支持常用的**Python**库。\\n\\n **Rust**语言的策略在回测时由平台服务器编译，编译后的模块在浏览器端的回测系统中运行；策略中通过frontmatter声明的第三方crate依赖会在编译时自动获取，无需在本地安装任何工具链。\\n\\n **Workflow**工作流策略支持回测，可视化查看节点执行状态与数据流转。\", \"title\": \"回测系统支持多种编程语言\"}, {\"_src_hash\": \"d26ef3694a961a6338d447b01b33a6be57d8200491d2270a5028f30e21413477\", \"desc\": \"- 商品期货：支持大连商品交易所、郑州商品交易所、上海期货交易所、中国金融期货交易所等国内主要期货交易所的全品种期货数据，暂不支持商品期权数据。\\n- 股票证券：目前仅支持有限的数据，股票数据仅限于日线级别的K线回测数据。\", \"title\": \"回测系统支持的交易所\"}, {\"_src_hash\": \"b42df47af8711ba02f8c6b30776bcec7fa35b1151b6b746e731701e0e7bac86e\", \"desc\": \"优宽量化交易平台的回测系统参数调优功能允许在回测时根据各参数的调优选项设置参数组合。勾选策略参数右侧的**调优**选项即可显示调优设置界面。\\n\\n![参数调优截图](/upload/asset/1772c133d7d8e4e2e166d.png)\\n\\n- 最小值：设定参数的起始值。\\n- 最大值：设定参数递增后的最大值。\\n- 步长：参数的递增步进值。\\n- 并发线程：\\n 参数调优时，设置各回测参数组合并发执行的线程数。该选项仅支持```JavaScript```、```PINE```、```My语言```策略的参数调优，不支持模板参数调优。\\n\\n系统根据```最小值```、```最大值```、```步长```的设置生成参数组合，并遍历这些参数组合进行回测（即对每种参数组合执行一次回测）。策略参数仅支持**数字型（number）**参数在回测系统中进行参数调优设置。\", \"title\": \"回测系统参数调优\"}, {\"_src_hash\": \"5eeeae0493e8f87dc16ef20a3a0b3100cecb2bba605f70217e73eee8f411adba\", \"desc\": \"当配置好这些参数后，即可按照设定运行回测策略。那么，如何保存这些配置信息呢？\\n\\n- 1、可以使用[策略编辑页面](https://www.youquant.com/m/add-strategy)的「保存回测设置」按钮，将所有回测配置信息（包含回测设置、策略参数设置）以代码形式记录在策略源码中。\\n\\n- 2、在策略编辑页面点击「保存策略」按钮保存策略时，平台会自动记录当前的回测设置、策略参数配置等信息。\\n\\n\\n回测系统如何载入回测配置呢？\\n\\n- 1、刷新或重新打开策略编辑页面时，系统会优先自动载入「保存回测设置」按钮所记录的回测配置信息。\\n\\n- 2、如果当前策略代码中没有以```backtest```注释形式记录的回测配置信息（即未通过「保存回测设置」按钮保存到策略代码中），回测系统会自动将回测设置配置为该策略最后一次点击「保存策略」按钮时的回测配置信息。\\n\\n- 3、如果在策略编辑页面中修改了策略代码开头以注释形式记录的回测配置信息，需要将更新后的回测配置信息同步到策略回测界面的选项时，可以点击策略编辑区域```backtest```上方的「回测设置」按钮。\", \"examples\": [{\"examples\": [{\"code\": \"/*backtest\\nstart: 2022-09-13 09:00:00\\nend: 2023-09-19 15:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"depthDeep\\\":20}]\\n*/\", \"lang\": \"javascript\"}, {\"code\": \"'''backtest\\nstart: 2022-09-13 09:00:00\\nend: 2023-09-19 15:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"depthDeep\\\":20}]\\n'''\", \"lang\": \"python\"}, {\"code\": \"/*backtest\\nstart: 2022-09-13 09:00:00\\nend: 2023-09-19 15:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"depthDeep\\\":20}]\\n*/\", \"lang\": \"rust\"}], \"value\": \"点击「保存回测设置」时，```JavaScript```/```Python```/```Rust```/```My语言```/```PINE```语言的策略将回测设置保存到策略代码中，其格式略有差别：\"}, {\"value\": \"My语言：\\n```My\\n(*backtest\\nstart: 2022-09-13 09:00:00\\nend: 2023-09-19 15:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"depthDeep\\\":20}]\\nargs: [[\\\"ContractType\\\",\\\"rb888\\\",325065]]\\n*)\\n```\"}, {\"value\": \"PINE语言：\\n```pine\\n/*backtest\\nstart: 2022-09-13 09:00:00\\nend: 2023-09-19 15:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"depthDeep\\\":20}]\\nargs: [[\\\"ContractType\\\",\\\"rb888\\\",360008]]\\n*/\\n```\"}], \"title\": \"保存回测设置\"}, {\"_src_hash\": \"7225c2c7e6a9b81cc3a4c0b0c6a63801f13a093ec402a4c65f5481743872b239\", \"children\": [{\"_src_hash\": \"48b0037f9343cb0a31ffafaf9bf5d1426b4a50fc262e1fdb18256b7261b4d9de\", \"desc\": \"返回的格式必须为以下两种格式之一（系统自动识别）：\\n- 模拟级 Tick，以下是JSON数据示例：\\n 普通的Bar级别回测，以下是数据示例：\\n ```json\\n {\\n \\\"detail\\\": {\\n \\\"alias\\\": \\\"MA501\\\",\\n \\\"baseCurrency\\\": \\\"FUTURES\\\",\\n \\\"basePrecision\\\": 1,\\n \\\"contractType\\\": \\\"MA501\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"info\\\": {\\n \\\"CombinationType\\\": 48,\\n \\\"CreateDate\\\": 20240116,\\n \\\"DeliveryMonth\\\": 1,\\n \\\"DeliveryYear\\\": 1501,\\n \\\"EndDelivDate\\\": 20250114,\\n \\\"ExchangeID\\\": \\\"CZCE\\\",\\n \\\"ExchangeInstID\\\": \\\"MA501\\\",\\n \\\"ExpireDate\\\": 20250114,\\n \\\"InstLifePhase\\\": 49,\\n \\\"InstrumentID\\\": \\\"MA501\\\",\\n \\\"InstrumentName\\\": \\\"甲醇1月\\\",\\n \\\"IsTrading\\\": 1,\\n \\\"LongMarginRatio\\\": 0.08,\\n \\\"MaxLimitOrderVolume\\\": 1000,\\n \\\"MaxMarginSideAlgorithm\\\": 48,\\n \\\"MaxMarketOrderVolume\\\": 200,\\n \\\"MinLimitOrderVolume\\\": 1,\\n \\\"MinMarketOrderVolume\\\": 1,\\n \\\"OpenDate\\\": 20240116,\\n \\\"OptionsType\\\": 0,\\n \\\"PositionDateType\\\": 50,\\n \\\"PositionType\\\": 50,\\n \\\"PriceTick\\\": 1,\\n \\\"ProductClass\\\": 49,\\n \\\"ProductID\\\": \\\"MA\\\",\\n \\\"ShortMarginRatio\\\": 0.08,\\n \\\"StartDelivDate\\\": 0,\\n \\\"StrikePrice\\\": 0,\\n \\\"UnderlyingInstrID\\\": \\\"\\\",\\n \\\"UnderlyingMultiple\\\": 1,\\n \\\"VolumeMultiple\\\": 10\\n },\\n \\\"marginCurrency\\\": \\\"CNY\\\",\\n \\\"marginLevel\\\": 12,\\n \\\"maxNotional\\\": 10000000,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 1,\\n \\\"minQty\\\": 1,\\n \\\"priceTick\\\": 1,\\n \\\"quoteCurrency\\\": \\\"CNY\\\",\\n \\\"quotePrecision\\\": 0,\\n \\\"symbol\\\": \\\"MA501\\\",\\n \\\"volumeTick\\\": 1\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\", \\\"position\\\"],\\n \\\"data\\\": [\\n [1719795600000, 2632, 2633, 2621, 2625, 13070, 1720510], // 2024-07-01 09:00:00\\n [1719795660000, 2625, 2625, 2621, 2623, 4280, 1720940], // 2024-07-01 09:01:00\\n [1719795720000, 2623, 2626, 2622, 2622, 5320, 1722310], // 2024-07-01 09:02:00\\n [1719795780000, 2622, 2625, 2620, 2625, 3480, 1722160],\\n [1719795840000, 2624, 2624, 2622, 2623, 2220, 1723150],\\n [1719795900000, 2623, 2624, 2620, 2620, 3080, 1722840],\\n [1719795960000, 2621, 2622, 2620, 2620, 3090, 1723850]\\n ]\\n }\\n ```\\n\\n- 实盘级 Tick，以下是JSON数据示例：\\n Tick级回测的数据（包含盘口深度信息，深度格式为```[价格, 量]```的数组。可有多级深度，```asks```为价格升序，```bids```为价格降序）。\\n\\n ```json\\n // 不含分笔数据\\n {\\n \\\"detail\\\": {\\n \\\"alias\\\": \\\"MA501\\\",\\n \\\"baseCurrency\\\": \\\"FUTURES\\\",\\n \\\"basePrecision\\\": 1,\\n \\\"contractType\\\": \\\"MA501\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"info\\\": {\\n \\\"CombinationType\\\": 48,\\n \\\"CreateDate\\\": 20240116,\\n \\\"DeliveryMonth\\\": 1,\\n \\\"DeliveryYear\\\": 1501,\\n \\\"EndDelivDate\\\": 20250114,\\n \\\"ExchangeID\\\": \\\"CZCE\\\",\\n \\\"ExchangeInstID\\\": \\\"MA501\\\",\\n \\\"ExpireDate\\\": 20250114,\\n \\\"InstLifePhase\\\": 49,\\n \\\"InstrumentID\\\": \\\"MA501\\\",\\n \\\"InstrumentName\\\": \\\"甲醇1月\\\",\\n \\\"IsTrading\\\": 1,\\n \\\"LongMarginRatio\\\": 0.08,\\n \\\"MaxLimitOrderVolume\\\": 1000,\\n \\\"MaxMarginSideAlgorithm\\\": 48,\\n \\\"MaxMarketOrderVolume\\\": 200,\\n \\\"MinLimitOrderVolume\\\": 1,\\n \\\"MinMarketOrderVolume\\\": 1,\\n \\\"OpenDate\\\": 20240116,\\n \\\"OptionsType\\\": 0,\\n \\\"PositionDateType\\\": 50,\\n \\\"PositionType\\\": 50,\\n \\\"PriceTick\\\": 1,\\n \\\"ProductClass\\\": 49,\\n \\\"ProductID\\\": \\\"MA\\\",\\n \\\"ShortMarginRatio\\\": 0.08,\\n \\\"StartDelivDate\\\": 0,\\n \\\"StrikePrice\\\": 0,\\n \\\"UnderlyingInstrID\\\": \\\"\\\",\\n \\\"UnderlyingMultiple\\\": 1,\\n \\\"VolumeMultiple\\\": 10\\n },\\n \\\"marginCurrency\\\": \\\"CNY\\\",\\n \\\"marginLevel\\\": 12,\\n \\\"maxNotional\\\": 10000000,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 1,\\n \\\"minQty\\\": 1,\\n \\\"priceTick\\\": 1,\\n \\\"quoteCurrency\\\": \\\"CNY\\\",\\n \\\"quotePrecision\\\": 0,\\n \\\"symbol\\\": \\\"MA501\\\",\\n \\\"volumeTick\\\": 1\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"close\\\", \\\"vol\\\", \\\"position\\\"],\\n \\\"data\\\": [\\n [1719795601778, [[2633, 50]], [[2631, 50]], 2632, 110410, 1718490],\\n [1719795602192, [[2632, 120]], [[2631, 50]], 2632, 110410, 1718490],\\n [1719795603873, [[2631, 20]], [[2630, 600]], 2631, 110780, 1718790],\\n [1719795604769, [[2633, 120]], [[2630, 490]], 2631, 111300, 1718860],\\n [1719795605661, [[2632, 200]], [[2631, 30]], 2632, 111750, 1718880]\\n ]\\n }\\n ```\\n\\n| 字段 | 说明 |\\n| ------ | ------ |\\n| schema | 指定data数组中各列的属性，区分大小写，仅限于 time, open, high, low, close, vol, asks, bids, trades |\\n| data | 按schema指定的列顺序保存数据的数组 |\\n| detail | 商品期货品种需要提供的属性信息 |\\n\\n### detail字段\\n| 字段 | 说明 | 例子 |\\n| ------ | ------ | ------ |\\n| alias | 合约代码 | rb2501 |\\n| baseCurrency | 交易品种 | FUTURES |\\n| basePrecision | 交易品种精度 | 1 |\\n| contractType | 合约代码 | rb2501 |\\n| eid | 交易所对象Id | Futures_CTP |\\n| info | 合约详细信息 | 其中记录了合约的上市日期、交割日期、合约乘数、价格跳动单位等信息。 |\\n| marginCurrency | 保证金币种 | CNY |\\n| marginLevel | 杠杆倍数 | 该数据与合约具体的保证金率相关，一般不可修改 |\\n| maxNotional | 单笔最大下单金额 | 10000000 |\\n| maxQty | 单笔最大下单数量 | 1000 |\\n| minNotional | 单笔最小下单金额 | 1 |\\n| minQty | 单笔最小下单数量 | 1 |\\n| priceTick | 价格跳动单位 | -- |\\n| quoteCurrency | 计价货币 | CNY |\\n| quotePrecision | 计价货币精度 | 0 |\\n| symbol | 合约代码 | rb2501 |\\n| volumeTick | 下单量最小变动单位 | 1 |\\n\\n特殊的列属性```asks```、```bids```、```trades```：\\n\\n| 字段 | 说明 | 备注 |\\n| - | - | - |\\n| asks / bids | ```[[价格, 数量], ...]``` | 例如```实盘级 Tick```数据示例中的数据：```[[9531300, 10]]``` |\\n| trades | ```[[时间, 方向(0:买,1:卖), 价格, 数量], ...]```| 例如```实盘级 Tick```数据示例中的数据：```[[1564315200000, 0, 9531300, 10]]``` |\\n\\ndetail字段中```info```字段值内容与{@fun/Futures/exchange.SetContractType exchange.SetContractType()}函数返回的数据Info字段一致。\\n\\ndetail字段中```timeLine```字段说明：\\n当策略代码中设置的合约代码为主力连续合约（例如：```MA888```）或指数合约（例如：```MA000```）时，自定义数据源响应的数据的detail中还需要增加一个timeLine字段。\\n\\n```json\\n// timeLine字段值\\n[\\n {\\n \\\"begin\\\": 1451836800000,\\n \\\"end\\\": 1460013300000,\\n \\\"symbol\\\": \\\"MA605\\\"\\n }, {\\n \\\"begin\\\": 1460034000000,\\n \\\"end\\\": 1470640500000,\\n \\\"symbol\\\": \\\"MA609\\\"\\n }\\n // ...\\n]\\n```\", \"title\": \"数据格式\"}, {\"_src_hash\": \"6bbd31e897100d102c7f8b0eb0104e79f2e777513696f12e742f01cc7b1a122f\", \"desc\": \"指定数据源地址，例如：```http://120.24.2.20:9090/data```。自定义数据源服务程序使用```Golang```编写：\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"net/http\\\"\\n \\\"encoding/json\\\"\\n)\\n\\nfunc Handle (w http.ResponseWriter, r *http.Request) {\\n // e.g. set on backtest DataSourse: http://xxx.xx.x.xx:9090/data\\n // r.URL: /data?custom=0&depth=20&detail=true&eid=Futures_CTP&from=1719745260&period=60000&round=true&symbol=FUTURES_CNY.MA501&to=1720281600&trades=0\\n\\n fmt.Println(\\\"request:\\\", r)\\n\\n // response\\n defer func() {\\n // response data\\n /* e.g. data\\n {\\n \\\"detail\\\": {\\n \\\"alias\\\": \\\"MA501\\\",\\n \\\"baseCurrency\\\": \\\"FUTURES\\\",\\n \\\"basePrecision\\\": 1,\\n \\\"contractType\\\": \\\"MA501\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"info\\\": {\\n \\\"CombinationType\\\": 48,\\n \\\"CreateDate\\\": 20240116,\\n \\\"DeliveryMonth\\\": 1,\\n \\\"DeliveryYear\\\": 1501,\\n \\\"EndDelivDate\\\": 20250114,\\n \\\"ExchangeID\\\": \\\"CZCE\\\",\\n \\\"ExchangeInstID\\\": \\\"MA501\\\",\\n \\\"ExpireDate\\\": 20250114,\\n \\\"InstLifePhase\\\": 49,\\n \\\"InstrumentID\\\": \\\"MA501\\\",\\n \\\"InstrumentName\\\": \\\"甲醇1月\\\",\\n \\\"IsTrading\\\": 1,\\n \\\"LongMarginRatio\\\": 0.08,\\n \\\"MaxLimitOrderVolume\\\": 1000,\\n \\\"MaxMarginSideAlgorithm\\\": 48,\\n \\\"MaxMarketOrderVolume\\\": 200,\\n \\\"MinLimitOrderVolume\\\": 1,\\n \\\"MinMarketOrderVolume\\\": 1,\\n \\\"OpenDate\\\": 20240116,\\n \\\"OptionsType\\\": 0,\\n \\\"PositionDateType\\\": 50,\\n \\\"PositionType\\\": 50,\\n \\\"PriceTick\\\": 1,\\n \\\"ProductClass\\\": 49,\\n \\\"ProductID\\\": \\\"MA\\\",\\n \\\"ShortMarginRatio\\\": 0.08,\\n \\\"StartDelivDate\\\": 0,\\n \\\"StrikePrice\\\": 0,\\n \\\"UnderlyingInstrID\\\": \\\"\\\",\\n \\\"UnderlyingMultiple\\\": 1,\\n \\\"VolumeMultiple\\\": 10\\n },\\n \\\"marginCurrency\\\": \\\"CNY\\\",\\n \\\"marginLevel\\\": 12,\\n \\\"maxNotional\\\": 10000000,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 1,\\n \\\"minQty\\\": 1,\\n \\\"priceTick\\\": 1,\\n \\\"quoteCurrency\\\": \\\"CNY\\\",\\n \\\"quotePrecision\\\": 0,\\n \\\"symbol\\\": \\\"MA501\\\",\\n \\\"volumeTick\\\": 1\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\", \\\"position\\\"],\\n \\\"data\\\": [\\n [1719795600000, 2632, 2633, 2621, 2625, 13070, 1720510], // 2024-07-01 09:00:00\\n [1719795660000, 2625, 2625, 2621, 2623, 4280, 1720940], // 2024-07-01 09:01:00\\n [1719795720000, 2623, 2626, 2622, 2622, 5320, 1722310], // 2024-07-01 09:02:00\\n [1719795780000, 2622, 2625, 2620, 2625, 3480, 1722160],\\n [1719795840000, 2624, 2624, 2622, 2623, 2220, 1723150],\\n [1719795900000, 2623, 2624, 2620, 2620, 3080, 1722840],\\n [1719795960000, 2621, 2622, 2620, 2620, 3090, 1723850]\\n ]\\n }\\n */\\n\\n // /* 模拟级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"alias\\\": \\\"MA501\\\",\\n \\\"baseCurrency\\\": \\\"FUTURES\\\",\\n \\\"basePrecision\\\": 1,\\n \\\"contractType\\\": \\\"MA501\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"info\\\": map[string]interface{}{\\n \\\"CombinationType\\\": 48,\\n \\\"CreateDate\\\": 20240116,\\n \\\"DeliveryMonth\\\": 1,\\n \\\"DeliveryYear\\\": 1501,\\n \\\"EndDelivDate\\\": 20250114,\\n \\\"ExchangeID\\\": \\\"CZCE\\\",\\n \\\"ExchangeInstID\\\": \\\"MA501\\\",\\n \\\"ExpireDate\\\": 20250114,\\n \\\"InstLifePhase\\\": 49,\\n \\\"InstrumentID\\\": \\\"MA501\\\",\\n \\\"InstrumentName\\\": \\\"甲醇1月\\\",\\n \\\"IsTrading\\\": 1,\\n \\\"LongMarginRatio\\\": 0.08,\\n \\\"MaxLimitOrderVolume\\\": 1000,\\n \\\"MaxMarginSideAlgorithm\\\": 48,\\n \\\"MaxMarketOrderVolume\\\": 200,\\n \\\"MinLimitOrderVolume\\\": 1,\\n \\\"MinMarketOrderVolume\\\": 1,\\n \\\"OpenDate\\\": 20240116,\\n \\\"OptionsType\\\": 0,\\n \\\"PositionDateType\\\": 50,\\n \\\"PositionType\\\": 50,\\n \\\"PriceTick\\\": 1,\\n \\\"ProductClass\\\": 49,\\n \\\"ProductID\\\": \\\"MA\\\",\\n \\\"ShortMarginRatio\\\": 0.08,\\n \\\"StartDelivDate\\\": 0,\\n \\\"StrikePrice\\\": 0,\\n \\\"UnderlyingInstrID\\\": \\\"\\\",\\n \\\"UnderlyingMultiple\\\": 1,\\n \\\"VolumeMultiple\\\": 10,\\n },\\n \\\"marginCurrency\\\": \\\"CNY\\\",\\n \\\"marginLevel\\\": 12,\\n \\\"maxNotional\\\": 10000000,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 1,\\n \\\"minQty\\\": 1,\\n \\\"priceTick\\\": 1,\\n \\\"quoteCurrency\\\": \\\"CNY\\\",\\n \\\"quotePrecision\\\": 0,\\n \\\"symbol\\\": \\\"MA501\\\",\\n \\\"volumeTick\\\": 1,\\n },\\n \\\"schema\\\": []string{\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\", \\\"position\\\"},\\n \\\"data\\\": []interface{}{\\n []int64{1719795600000, 2632, 2633, 2621, 2625, 13070, 1720510},\\n []int64{1719795660000, 2625, 2625, 2621, 2623, 4280, 1720940},\\n []int64{1719795720000, 2623, 2626, 2622, 2622, 5320, 1722310},\\n []int64{1719795780000, 2622, 2625, 2620, 2625, 3480, 1722160},\\n []int64{1719795840000, 2624, 2624, 2622, 2623, 2220, 1723150},\\n []int64{1719795900000, 2623, 2624, 2620, 2620, 3080, 1722840},\\n []int64{1719795960000, 2621, 2622, 2620, 2620, 3090, 1723850},\\n },\\n }\\n // */\\n\\n /* 实盘级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"alias\\\": \\\"MA501\\\",\\n \\\"baseCurrency\\\": \\\"FUTURES\\\",\\n \\\"basePrecision\\\": 1,\\n \\\"contractType\\\": \\\"MA501\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"info\\\": map[string]interface{}{\\n \\\"CombinationType\\\": 48,\\n \\\"CreateDate\\\": 20240116,\\n \\\"DeliveryMonth\\\": 1,\\n \\\"DeliveryYear\\\": 1501,\\n \\\"EndDelivDate\\\": 20250114,\\n \\\"ExchangeID\\\": \\\"CZCE\\\",\\n \\\"ExchangeInstID\\\": \\\"MA501\\\",\\n \\\"ExpireDate\\\": 20250114,\\n \\\"InstLifePhase\\\": 49,\\n \\\"InstrumentID\\\": \\\"MA501\\\",\\n \\\"InstrumentName\\\": \\\"甲醇1月\\\",\\n \\\"IsTrading\\\": 1,\\n \\\"LongMarginRatio\\\": 0.08,\\n \\\"MaxLimitOrderVolume\\\": 1000,\\n \\\"MaxMarginSideAlgorithm\\\": 48,\\n \\\"MaxMarketOrderVolume\\\": 200,\\n \\\"MinLimitOrderVolume\\\": 1,\\n \\\"MinMarketOrderVolume\\\": 1,\\n \\\"OpenDate\\\": 20240116,\\n \\\"OptionsType\\\": 0,\\n \\\"PositionDateType\\\": 50,\\n \\\"PositionType\\\": 50,\\n \\\"PriceTick\\\": 1,\\n \\\"ProductClass\\\": 49,\\n \\\"ProductID\\\": \\\"MA\\\",\\n \\\"ShortMarginRatio\\\": 0.08,\\n \\\"StartDelivDate\\\": 0,\\n \\\"StrikePrice\\\": 0,\\n \\\"UnderlyingInstrID\\\": \\\"\\\",\\n \\\"UnderlyingMultiple\\\": 1,\\n \\\"VolumeMultiple\\\": 10,\\n },\\n \\\"marginCurrency\\\": \\\"CNY\\\",\\n \\\"marginLevel\\\": 12,\\n \\\"maxNotional\\\": 10000000,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 1,\\n \\\"minQty\\\": 1,\\n \\\"priceTick\\\": 1,\\n \\\"quoteCurrency\\\": \\\"CNY\\\",\\n \\\"quotePrecision\\\": 0,\\n \\\"symbol\\\": \\\"MA501\\\",\\n \\\"volumeTick\\\": 1,\\n },\\n \\\"schema\\\": []string{\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"close\\\", \\\"vol\\\", \\\"position\\\"},\\n \\\"data\\\": []interface{}{\\n []interface{}{1719795601778, []interface{}{[]int64{2633, 50}}, []interface{}{[]int64{2631, 50}}, 2632, 110410, 1718490},\\n []interface{}{1719795602192, []interface{}{[]int64{2632, 120}}, []interface{}{[]int64{2631, 50}}, 2632, 110410, 1718490},\\n []interface{}{1719795603873, []interface{}{[]int64{2631, 20}}, []interface{}{[]int64{2630, 600}}, 2631, 110780, 1718790},\\n []interface{}{1719795604769, []interface{}{[]int64{2633, 120}}, []interface{}{[]int64{2630, 490}}, 2631, 111300, 1718860},\\n []interface{}{1719795605661, []interface{}{[]int64{2632, 200}}, []interface{}{[]int64{2631, 30}}, 2632, 111750, 1718880},\\n },\\n }\\n */\\n\\n b, _ := json.Marshal(ret)\\n w.Write(b)\\n }()\\n}\\n\\nfunc main () {\\n fmt.Println(\\\"listen http://localhost:9090\\\")\\n http.HandleFunc(\\\"/data\\\", Handle)\\n http.ListenAndServe(\\\":9090\\\", nil)\\n}\\n```\\n\\n测试策略，```JavaScript```示例：\\n\\n```javascript\\n/*backtest\\nstart: 2024-07-01 00:00:00\\nend: 2024-07-07 00:00:00\\nperiod: 1m\\nbasePeriod: 1m\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"feeder\\\":\\\"http://120.24.2.20:9090/data\\\"}]\\n*/\\n\\nfunction main() {\\n // 对于测试代码，我们通过判断exchange.IO(\\\"status\\\")函数，连接成功后执行测试代码，区别于商品期货策略的一般架构\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n // 设置合约为MA501\\n exchange.SetContractType(\\\"MA501\\\")\\n // 获取ticker数据\\n var ticker = exchange.GetTicker()\\n // 获取records数据，即K线数据\\n var records = exchange.GetRecords()\\n // 打印数据\\n Log(ticker)\\n Log(records)\\n}\\n```\", \"title\": \"自定义数据源范例\"}], \"desc\": \"优宽量化交易平台的回测系统支持自定义数据源。回测系统使用 ```GET``` 方法请求自定义的 URL（可公开访问的网址）来获取外部数据源进行回测，附加的请求参数如下：\\n\\n| 参数 | 意义 | 说明 |\\n| ------ | ------ | ------ |\\n| symbol | 品种名称 | 如：FUTURES_CNY.MA501 |\\n| eid | 交易所标识 | 如：Futures_CTP |\\n| round | 数据精度 | 为 true 时，表示由自定义数据源返回的数据中定义具体精度。优宽量化交易平台回测系统向自定义数据源发送的请求固定为：```round=true``` |\\n| period | K线数据周期（毫秒） | 例如：```60000``` 表示1分钟周期 |\\n| depth | 深度档位数 | 1-20 |\\n| trades | 是否需要逐笔成交数据 | 真（1）/假（0） |\\n| from | 开始时间 | Unix 时间戳 |\\n| to | 结束时间 | Unix 时间戳 |\\n| detail | 请求品种详细信息 | 为 true 时，表示需要由自定义数据源提供。优宽量化交易平台回测系统向自定义数据源发送的请求固定为：```detail=true``` |\\n| custom | -- | 可忽略此参数 |\\n\\n当交易所对象的数据源设置为自定义数据源（feeder）时，回测系统向自定义数据源服务发送请求的示例：\\n\\n```url\\n// 模拟级Tick\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_CTP&from=1719745260&period=60000&round=true&symbol=FUTURES_CNY.MA501&to=1720281600&trades=0\\n\\n// 实盘级Tick\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_CTP&from=1719763200&period=1000&round=true&symbol=FUTURES_CNY.MA501&to=1720281600&trades=0\\n```\", \"title\": \"自定义数据源\"}, {\"_src_hash\": \"5c9f7f4346e49f1400378efb710220e86f44b2714e07f184526484187df42414\", \"desc\": \"优宽量化交易平台开源了```JavaScript```语言和```Python```语言的本地回测引擎，支持在回测时设置底层K线周期。\\n- [JavaScript语言回测引擎](https://github.com/fmzquant/backtest_javascript)\\n- [Python语言回测引擎](https://github.com/fmzquant/backtest_python)\\n\\n以Python语言为例，简述本地回测引擎的使用方法：\\n```python\\n'''backtest\\nstart: 2024-10-17 09:00:00\\nend: 2025-10-16 15:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"currency\\\":\\\"FUTURES\\\",\\\"balance\\\":30000000}]\\n'''\\n\\n# Part 1 -----------------------------------\\n# 初始化回测引擎，backtest 为回测引擎配置信息，与优宽平台线上回测系统配置一致\\n# 通过 __doc__ 读取上方的配置字符串并初始化回测环境\\nfrom fmz import *\\ntask = VCtx(__doc__) # initialize backtest engine from __doc__\\n# End -----------------------------------\\n\\n\\n# Part 2 -----------------------------------\\n# 以下为待测试的策略代码示例（可以从优宽平台复制完整的策略代码）\\n# 注意：仅复制策略代码时不包含参数设计、交互设计等其他配置内容\\ndef onTick():\\n\\tticker = _C(exchange.GetTicker)\\n\\tLogStatus(_D(), ticker.Last)\\n\\ndef main():\\n\\texchange.SetContractType(\\\"rb888\\\")\\n\\tLog(exchange.GetAccount())\\n\\twhile True:\\n\\t\\tonTick()\\n\\t\\tSleep(1000)\\n# End -----------------------------------\\n\\n\\n# Part 3 -----------------------------------\\n# 执行回测并捕获结束信号，回测结束时会触发 EOF 异常\\n# 捕获异常后可以输出回测结果数据或展示回测图表\\ntry:\\n\\tmain()\\nexcept:\\n\\tprint(\\\"Strategy testing completed.\\\")\\n\\tprint(task.Join(False)) # print backtest result\\n\\t# task.Show() # or show backtest chart\\n# End -----------------------------------\\n```\", \"title\": \"本地回测引擎\"}, {\"_src_hash\": \"9ce03cd655d10108b5f45e38eeb37772ca98764d20331924095fdaf7bbdb3e05\", \"desc\": \"- 策略编辑页面和策略回测页面切换的快捷键\\n 使用```Ctrl + ,```键切换回测页面和策略编辑页面，按住```Ctrl```键后，单按```,```键。\\n- 策略保存的快捷键\\n 使用```Ctrl + s```键保存策略。\\n- 启动回测的快捷键\\n 使用```Ctrl + b```键启动回测。\", \"title\": \"回测页面快捷键\"}, {\"_src_hash\": \"dce702b5a6ae6b286ad54ad0a3610fd64657893ef04b1c93dd68a9b59be3d27e\", \"desc\": \"- 回测系统日志数据下载\\n 打开具体策略，切换到「回测页面」进行策略回测。回测结束后，在显示的「状态信息」栏右上角有「下载表格」按钮，点击即可下载回测结束时状态栏数据的CSV格式文件。\\n- 回测系统状态栏数据下载\\n 打开具体策略，切换到「回测页面」进行策略回测。回测结束后，在显示的「日志信息」栏右上角有「下载表格」按钮，点击即可下载回测日志数据的CSV格式文件。\", \"title\": \"回测数据下载\"}, {\"_src_hash\": \"cb72f75bd534abb5fe4c88350a25ce602952f3d8054416fa8d16a009f5e7b92c\", \"desc\": \"回测系统计算夏普比率的JavaScript源代码如下。\\n\\n```javascript\\nfunction returnAnalyze(totalAssets, profits, ts, te, period, yearDays) {\\n // force by days\\n period = 86400000\\n if (profits.length == 0) {\\n return null\\n }\\n var freeProfit = 0.03 // 0.04\\n var yearRange = yearDays * 86400000\\n var totalReturns = profits[profits.length - 1][1] / totalAssets\\n var annualizedReturns = (totalReturns * yearRange) / (te - ts)\\n\\n // MaxDrawDown\\n var maxDrawdown = 0\\n var maxAssets = totalAssets\\n var maxAssetsTime = 0\\n var maxDrawdownTime = 0\\n var maxDrawdownStartTime = 0\\n var winningRate = 0\\n var winningResult = 0\\n for (var i = 0; i < profits.length; i++) {\\n if (i == 0) {\\n if (profits[i][1] > 0) {\\n winningResult++\\n }\\n } else {\\n if (profits[i][1] > profits[i - 1][1]) {\\n winningResult++\\n }\\n }\\n if ((profits[i][1] + totalAssets) > maxAssets) {\\n maxAssets = profits[i][1] + totalAssets\\n maxAssetsTime = profits[i][0]\\n }\\n if (maxAssets > 0) {\\n var drawDown = 1 - (profits[i][1] + totalAssets) / maxAssets\\n if (drawDown > maxDrawdown) {\\n maxDrawdown = drawDown\\n maxDrawdownTime = profits[i][0]\\n maxDrawdownStartTime = maxAssetsTime\\n }\\n }\\n }\\n if (profits.length > 0) {\\n winningRate = winningResult / profits.length\\n }\\n // trim profits\\n var i = 0\\n var datas = []\\n var sum = 0\\n var preProfit = 0\\n var perRatio = 0\\n var rangeEnd = te\\n if ((te - ts) % period > 0) {\\n rangeEnd = (parseInt(te / period) + 1) * period\\n }\\n for (var n = ts; n < rangeEnd; n += period) {\\n var dayProfit = 0.0\\n var cut = n + period\\n while (i < profits.length && profits[i][0] < cut) {\\n dayProfit += (profits[i][1] - preProfit)\\n preProfit = profits[i][1]\\n i++\\n }\\n perRatio = ((dayProfit / totalAssets) * yearRange) / period\\n sum += perRatio\\n datas.push(perRatio)\\n }\\n\\n var sharpeRatio = 0\\n var volatility = 0\\n if (datas.length > 0) {\\n var avg = sum / datas.length;\\n var std = 0;\\n for (i = 0; i < datas.length; i++) {\\n std += Math.pow(datas[i] - avg, 2);\\n }\\n volatility = Math.sqrt(std / datas.length);\\n if (volatility !== 0) {\\n sharpeRatio = (annualizedReturns - freeProfit) / volatility\\n }\\n }\\n\\n return {\\n totalAssets: totalAssets,\\n yearDays: yearDays,\\n totalReturns: totalReturns,\\n annualizedReturns: annualizedReturns,\\n sharpeRatio: sharpeRatio,\\n volatility: volatility,\\n maxDrawdown: maxDrawdown,\\n maxDrawdownTime: maxDrawdownTime,\\n maxAssetsTime: maxAssetsTime,\\n maxDrawdownStartTime: maxDrawdownStartTime,\\n winningRate: winningRate\\n }\\n}\\n```\", \"title\": \"回测系统夏普算法\"}], \"desc\": \"当您完成量化交易策略的设计后，如何验证策略的逻辑正确性、收益预期等关键指标？显然不能直接使用真实资金在市场中测试。正确的做法是使用历史数据对策略进行回测，通过分析策略在历史行情中的表现来评估其盈利能力和风险特征。\", \"title\": \"回测系统\"}, {\"_src_hash\": \"722e03add9b17f316445e166956aa1e4e572a75766d6fe78c49bce6d6a7a747e\", \"children\": [{\"_src_hash\": \"3fa24ddc5609ef0e938dd9d3e03c8da5af06838b8e6978ce9eb685dcd19e3eb5\", \"desc\": \"用户实现的退出处理函数，用于处理程序退出前的扫尾工作，最长执行时间为 5 分钟。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"开始运行, 5秒后停止，并执行扫尾函数！\\\")\\n Sleep(1000 * 5)\\n}\\n\\n// 扫尾函数实现\\nfunction onexit(){\\n // 不使用接口获取数据的测试，就无需使用exchange.IO(\\\"status\\\")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试\\n var beginTime = new Date().getTime()\\n while(true){\\n var nowTime = new Date().getTime()\\n Log(\\\"程序停止倒计时..扫尾开始，已经过去：\\\", (nowTime - beginTime) / 1000, \\\"秒！\\\")\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n Log(\\\"开始运行, 5秒后停止，并执行扫尾函数！\\\")\\n Sleep(1000 * 5)\\n\\ndef onexit():\\n beginTime = time.time() * 1000\\n while True:\\n ts = time.time() * 1000\\n Log(\\\"程序停止倒计时..扫尾开始，已经过去：\\\", (ts - beginTime) / 1000, \\\"秒！\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"开始运行, 5秒后停止，并执行扫尾函数！\\\");\\n Sleep(1000 * 5);\\n}\\n\\n// 扫尾函数实现\\nfn onexit() {\\n // 不使用接口获取数据的测试，就无需使用exchange.IO(\\\"status\\\")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试\\n let beginTime = Unix() * 1000;\\n loop {\\n let nowTime = Unix() * 1000;\\n Log!(\\\"程序停止倒计时..扫尾开始，已经过去：\\\", (nowTime - beginTime) / 1000, \\\"秒！\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"测试```onexit()```函数：\"}, {\"examples\": [{\"code\": \"function main() {\\n exchange.SetContractType(\\\"rb888\\\")\\n\\n if (IsVirtual()) {\\n try {\\n onTick()\\n } catch (e) {\\n Log(\\\"error:\\\", e)\\n }\\n } else {\\n onTick()\\n }\\n}\\n\\nfunction onTick() {\\n while (true) {\\n var ticker = exchange.GetTicker()\\n LogStatus(_D(), ticker ? ticker.Last : \\\"--\\\")\\n Sleep(500)\\n }\\n}\\n\\nfunction onexit() {\\n Log(\\\"执行扫尾函数\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n exchange.SetContractType(\\\"rb888\\\")\\n\\n if IsVirtual():\\n try:\\n onTick()\\n except Exception as e:\\n Log(e)\\n else:\\n onTick()\\n\\ndef onTick():\\n while True:\\n ticker = exchange.GetTicker()\\n LogStatus(_D(), ticker[\\\"Last\\\"] if ticker else \\\"--\\\")\\n Sleep(500)\\n\\ndef onexit():\\n Log(\\\"执行扫尾函数\\\")\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n loop {\\n match exchange.GetTicker(None) {\\n Ok(ticker) => LogStatus!(_D(None), ticker.Last),\\n Err(e) => {\\n // 回测结束时接口调用返回 Err，无需像 JavaScript 那样用 try/catch 捕获回测结束异常\\n Log!(\\\"error:\\\", e);\\n return;\\n }\\n }\\n Sleep(500);\\n }\\n}\\n\\nfn main() {\\n let _ = exchange.SetContractType(\\\"rb888\\\");\\n\\n onTick();\\n}\\n\\nfn onexit() {\\n Log!(\\\"执行扫尾函数\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"在回测系统中，策略通常被设计为一个死循环持续轮询执行，这会导致策略中实现的```onexit()```函数无法被触发。此时可以通过检测回测系统的结束标记（EOF 异常）来触发```onexit()```函数的执行。\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"28120d7245744a8ae05920f3289b629837efb7d01b878524092c64cce569ab40\", \"desc\": \"用户自行实现的初始化函数。策略开始运行时会首先自动执行 ```init()``` 函数，以完成策略中设计的各项初始化任务。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n // 不使用接口获取数据的测试，就无需使用exchange.IO(\\\"status\\\")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试\\n Log(\\\"程序第一行代码执行！\\\", \\\"#FF0000\\\")\\n Log(\\\"退出！\\\")\\n}\\n\\n// 初始化函数\\nfunction init(){\\n Log(\\\"初始化！\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"程序第一行代码执行！\\\", \\\"#FF0000\\\")\\n Log(\\\"退出！\\\")\\n\\ndef init():\\n Log(\\\"初始化！\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"程序第一行代码执行！\\\", \\\"#FF0000\\\");\\n Log!(\\\"退出！\\\");\\n}\\n\\n// 初始化函数\\nfn init() {\\n Log!(\\\"初始化！\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"```init()```在```main()```之前执行。\"}], \"title\": \"init()\"}, {\"_src_hash\": \"c70918fdc94933ed83a4a743011f304debf718f40fc8b55703571a097ee3ab2d\", \"desc\": \"发生异常时触发执行的函数。该函数不支持```Python```语言的策略。\\n\\n```onerror()```函数可以接收一个```msg```参数，该参数包含异常触发时的错误信息。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n // 不使用接口获取数据的测试，就无需使用exchange.IO(\\\"status\\\")函数判断连接状态，也不用设置合约代码，因为这里仅仅是测试\\n var arr = []\\n Log(arr[6].Close) // 这里故意引发一个程序异常\\n}\\n\\nfunction onerror(msg) {\\n Log(\\\"错误：\\\", msg)\\n}\", \"lang\": \"javascript\"}, {\"code\": \"# python不支持\", \"lang\": \"python\"}], \"value\": \"程序出现异常时由```onerror()```处理。\"}], \"title\": \"onerror()\"}], \"desc\": \"对于```JavaScript```、```Python```、```Rust```语言的策略，优宽量化交易平台已预先定义了以下入口函数。\\n\\n| 函数名 | 说明 |\\n| - | - |\\n|```main()```| 入口函数，即策略的主函数。 |\\n|```onexit()```| 正常退出时的扫尾函数，最长执行时间为5分钟，可以不声明；若执行超时，将报**interrupt**错误。在实盘中，若已先触发```onerror()```函数，则不会再触发```onexit()```函数。\\n|```onerror()```| 异常退出时触发执行的函数，最长执行时间为5分钟，可以不声明。使用```Python```语言编写的策略不支持该函数，回测系统亦不支持该函数。\\n|```init()```| 初始化函数，策略程序在开始运行时会首先自动调用该函数，可以不声明。 |\\n\\n### 注意事项\\n\\n- 当```main()```函数执行结束时，所有已创建的子线程都会被自动终止。\\n\\n- 在```Rust```语言策略中，直接定义```fn main()```、```fn init()```、```fn onexit()```即可（由引导层自动调用）；也可以在策略代码中调用```OnExit()```注册额外的退出钩子，详见「Rust策略编写说明」。\", \"title\": \"策略入口函数\"}, {\"_src_hash\": \"1e66d0850a1cba14a3c2702eaf389e24b2089839ee2bede0188a1a3b242d90c7\", \"children\": [{\"_src_hash\": \"b0a75a245555a22b53a6a86bad0b6ae0a11622f491259cb8a1e2747de31d0d95\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/Global/Version Version} | 返回系统当前版本号 |\\n| {@fun/Global/Sleep Sleep} | 休眠函数，参数为暂停的毫秒数 |\\n| {@fun/Global/IsVirtual IsVirtual} | 判断执行环境，返回真值表示当前为回测环境 |\\n| {@fun/Global/Mail Mail} | 发送邮件 |\\n| {@fun/Global/Mail_Go Mail_Go} | ```Mail```函数的异步版本 |\\n| {@fun/Global/SetErrorFilter SetErrorFilter} | 过滤错误日志，参数为正则表达式字符串，匹配该正则表达式的错误日志将不会上传到日志系统 |\\n| {@fun/Global/GetPid GetPid} | 获取实盘进程ID |\\n| {@fun/Global/GetLastError GetLastError} | 获取最近一次错误信息 |\\n| {@fun/Global/GetCommand GetCommand} | 获取策略交互命令，策略交互控件设置请参阅：{@交互控件交互控件} |\\n| {@fun/Global/GetMeta GetMeta} | 获取生成策略注册码时写入的Meta值 |\\n| {@fun/Global/Dial Dial} | 用于原始Socket访问 |\\n| {@fun/Global/HttpQuery HttpQuery} | 发送HTTP请求 |\\n| {@fun/Global/HttpQuery_Go HttpQuery_Go} | ```HttpQuery```函数的异步版本 |\\n| {@fun/Global/Encode Encode} | 数据编码函数 |\\n| {@fun/Global/UnixNano UnixNano} | 获取纳秒级时间戳 |\\n| {@fun/Global/Unix Unix} | 获取秒级时间戳 |\\n| {@fun/Global/GetOS GetOS} | 获取系统信息 |\\n| {@fun/Global/MD5 MD5} | 计算MD5值 |\\n| {@fun/Global/DBExec DBExec} | 数据库函数，用于执行SQL语句进行数据库操作 |\\n| {@fun/Global/UUID UUID} | 生成UUID |\\n| {@fun/Global/EventLoop EventLoop} | 监听事件 |\\n| {@fun/Global/_G _G} | 持久化保存数据，该函数实现可保存的全局字典功能。数据结构为KV表，永久保存在托管者本地数据库文件中 |\\n| {@fun/Global/_D _D} | 时间戳处理函数，将毫秒时间戳或Date对象转换为时间字符串 |\\n| {@fun/Global/_N _N} | 格式化浮点数，例如```_N(3.1415, 2)```将截取3.1415小数点后两位，函数返回3.14 |\\n| {@fun/Global/_C _C} | 重试函数，用于接口容错。注意：例如对```exchange.GetTicker```函数进行容错，应使用```_C(exchange.GetTicker)```而非```_C(exchange.GetTicker())``` |\\n| {@fun/Global/_Cross _Cross} | 交叉判断函数，```_Cross()```函数返回正数表示上穿周期数，负数表示下穿周期数，0表示当前价格相同 |\\n| {@fun/Global/JSON.parse JSON.parse} | 解析JSON，```safeStr```参数为真值时把较大的数值解析为字符串，避免丢失精度；回测系统不支持```safeStr```参数 |\\n| {@fun/Global/SetChannelData SetChannelData} | 在频道上发布最新状态数据，用于实盘间通信 |\\n| {@fun/Global/GetChannelData GetChannelData} | 订阅指定实盘的频道数据，用于实盘间通信 |\", \"title\": \"全局函数\"}, {\"_src_hash\": \"1f36466f6c85c745f20e094d439cbad3d17f56f7d301e2802924cdf9a97dc0ea\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/Log/Log Log} | 输出日志，支持设置日志文本颜色、推送功能，以及打印base64编码的图片 |\\n| {@fun/Log/LogProfit LogProfit} | 输出盈亏数据，打印盈亏数值并根据数值绘制收益曲线 |\\n| {@fun/Log/LogProfitReset LogProfitReset} | 清空```LogProfit```函数输出的所有收益日志和收益图表 |\\n| {@fun/Log/LogStatus LogStatus} | 在状态栏输出信息，支持输出表格、按钮控件和展示组件 |\\n| {@fun/Log/EnableLog EnableLog} | 开启或关闭订单信息的日志记录功能 |\\n| {@fun/Log/Chart Chart} | 图表绘制函数，基于Highcharts/Highstocks图表库 |\\n| {@fun/Log/KLineChart KLineChart} | Pine语言风格的图表绘制函数，用于在策略运行时以类似Pine语言的方式进行自定义绘图 |\\n| {@fun/Log/LogReset LogReset} | 清除日志，支持通过参数设置保留最近指定数量的日志记录 |\\n| {@fun/Log/LogVacuum LogVacuum} | 回收SQLite资源，在调用```LogReset()```函数清除日志后，回收SQLite删除数据时占用的存储空间 |\\n| {@fun/Log/console.log console.log} | 在实盘页面的「调试信息」栏中输出调试信息 |\\n| {@fun/Log/console.error console.error} | 在实盘页面的「调试信息」栏中输出错误信息 |\", \"title\": \"日志函数\"}, {\"_src_hash\": \"481f7e06a87a5fcac2a9d4e8c2d58ac9b717d69faab0226307db5cd8ab409bfc\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/Market/exchange.GetTicker exchange.GetTicker} | 获取Tick行情数据 |\\n| {@fun/Market/exchange.GetDepth exchange.GetDepth} | 获取订单簿深度数据 |\\n| {@fun/Market/exchange.GetTrades exchange.GetTrades} | 获取市场成交记录（基于Tick数据计算） |\\n| {@fun/Market/exchange.GetRecords exchange.GetRecords} | 获取K线数据 |\\n| {@fun/Market/exchange.GetPeriod exchange.GetPeriod} | 获取当前K线周期 |\\n| {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen} | 设置K线最大长度 |\\n| {@fun/Market/exchange.GetRate exchange.GetRate} | 获取当前设置的汇率 |\\n| {@fun/Market/exchange.SetData exchange.SetData} | 设置策略运行时加载的数据 |\\n| {@fun/Market/exchange.GetData exchange.GetData} | 获取已加载的数据或外部链接提供的数据 |\\n| {@fun/Market/exchange.GetMarkets exchange.GetMarkets} | 获取已订阅的交易品种信息 |\\n| {@fun/Market/exchange.GetTickers exchange.GetTickers} | 获取已订阅交易品种的聚合行情数据 |\", \"title\": \"行情函数\"}, {\"_src_hash\": \"9773f7eeef851a93ca2491dbc5c4df48eae6a3d0a944caf78fa624dc2f75f4bd\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/Trade/exchange.Buy exchange.Buy} | 提交买单，期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将报错 |\\n| {@fun/Trade/exchange.Sell exchange.Sell} | 提交卖单，期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将报错 |\\n| {@fun/Trade/exchange.CreateOrder exchange.CreateOrder} | 提交订单，通过参数指定交易品种、交易方向、价格和数量 |\\n| {@fun/Trade/exchange.CancelOrder exchange.CancelOrder} | 取消订单 |\\n| {@fun/Trade/exchange.GetOrder exchange.GetOrder} | 获取订单信息，数据结构为{@struct/Order Order}结构 |\\n| {@fun/Trade/exchange.GetOrders exchange.GetOrders} | 获取未完成的订单，数据结构为{@struct/Order Order}结构数组（列表） |\\n| {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}| 获取当前交易日所有合约的历史订单；支持获取指定合约的当前交易日历史订单 |\\n| {@fun/Trade/exchange.SetPrecision exchange.SetPrecision} | 设置exchange交易所对象的价格与下单量精度，设置后系统将自动忽略超出精度的部分 |\\n| {@fun/Trade/exchange.SetRate exchange.SetRate} | 设置汇率 |\\n| {@fun/Trade/exchange.IO exchange.IO} | 用于交易所对象相关的其他接口调用 |\\n| {@fun/Trade/exchange.Log exchange.Log} | 输出、记录交易日志，不执行实际下单 |\\n| {@fun/Account/exchange.GetName exchange.GetName} | 获取交易所对象的名称 |\\n| {@fun/Account/exchange.GetLabel exchange.GetLabel} | 获取交易所对象的标签 |\\n| {@fun/Account/exchange.GetCurrency exchange.GetCurrency} | 获取当前交易对 |\\n| {@fun/Account/exchange.GetAccount exchange.GetAccount} | 获取账户信息 |\\n| {@fun/Account/exchange.GetQuoteCurrency exchange.GetQuoteCurrency}| 获取当前交易对的计价币名称 |\", \"title\": \"交易函数\"}, {\"_src_hash\": \"1351134e86d0af5b185b1287590955f18cbb1aaf97f0192024acb644a8f8eb4c\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/Futures/exchange.GetPositions exchange.GetPositions} | 获取期货持仓信息，返回{@struct/Position Position}结构数组（列表） |\\n| {@fun/Futures/exchange.SetMarginLevel exchange.SetMarginLevel} | 设置杠杆倍数 |\\n| {@fun/Futures/exchange.SetDirection exchange.SetDirection} | 设置{@fun/Trade/exchange.Buy exchange.Buy}函数、{@fun/Trade/exchange.Sell exchange.Sell}函数在期货合约下单时的交易方向 |\\n| {@fun/Futures/exchange.SetContractType exchange.SetContractType}| 设置合约代码，例如切换当前操作的合约为螺纹钢主力连续合约：```exchange.SetContractType(\\\"rb888\\\")``` |\\n| {@fun/Futures/exchange.GetContractType exchange.GetContractType}| 获取当前设置的合约代码 |\\n| {@fun/Futures/StrDecode StrDecode} | GBK编码解码 |\", \"title\": \"期货函数\"}, {\"_src_hash\": \"b4540889de329ca41e5928e6c14942232ad2cf293be7a620b595ec3a74d8f087\", \"desc\": \"### 功能概述\\n\\n\\n优宽量化平台支持对商品期货交易所的 API 调用进行频率限制，以防止触发交易所的频率限制。通过合理配置 API 限流，可以有效避免因频繁调用而导致的接口限制问题，从而保障策略稳定运行。\\n\\n\\nAPI 限流功能支持两种限流模式：\\n\\n\\n- **rate 模式（平滑限流）**：不严格对齐时间窗口，适用于一般的限流需求。例如设置为每秒 10 次时，系统会平滑地控制调用频率。\\n\\n- **quota 模式（额度限流）**：严格对齐时间窗口，例如 1m 对齐到整分钟，1s 对齐到整秒。适用于需要严格控制时间窗口的场景。\\n\\n\\n### 基础用法\\n\\n\\n#### 函数签名\\n\\n\\n```javascript\\n\\nexchange.IO(\\\"rate\\\", functionNames, maxCalls, period, [behavior])\\n\\nexchange.IO(\\\"quota\\\", functionNames, maxCalls, period, [behavior])\\n\\n```\\n\\n\\n#### 参数说明\\n\\n\\n| 参数 | 类型 | 必填 | 说明 |\\n| - | - | - | - |\\n| mode | string | 是 | 限流模式：\\\"rate\\\"（平滑限流）或 \\\"quota\\\"（额度限流） |\\n| functionNames | string | 是 | 需要限制的函数名，支持单个函数、多个函数（以逗号分隔）以及通配符（```*```为兜底规则，作用于没有单独设置规则的函数） |\\n| maxCalls | number | 是 | 时间周期内允许的最大调用次数 |\\n| period | string | 是 | 时间周期或重置时间点。支持的时间单位：ns, us, µs, ms, s, m, h, d（例如：\\\"1s\\\"、\\\"1m\\\"、\\\"1h\\\"）。支持的重置时间点：@HHMM 或 @HHMMSS（例如：\\\"@0815\\\" 表示每天 08:15 重置） |\\n| behavior | string | 否 | 超限行为。默认为空（超限时返回 null 并报错）；设置为 \\\"delay\\\" 时，超限则等待 |\\n\\n\\n### 支持的函数列表\\n\\n\\n优宽量化平台的 API 限流功能支持以下函数：\\n\\n\\n#### 交易类（2 个）\\n\\n- ```CreateOrder``` - 创建订单\\n\\n- ```CancelOrder``` - 撤销订单\\n\\n\\n#### 账户类（2 个）\\n\\n- ```GetAccount``` - 获取账户信息\\n\\n- ```GetPositions``` - 获取持仓信息\\n\\n\\n#### 订单类（3 个）\\n\\n- ```GetOrder``` - 获取订单信息\\n\\n- ```GetOrders``` - 获取订单列表\\n\\n- ```GetHistoryOrders``` - 获取历史订单\\n\\n\\n#### 行情类（3 个）\\n\\n- ```GetTicker``` - 获取行情 Tick 数据\\n\\n- ```GetDepth``` - 获取深度数据\\n\\n- ```GetRecords``` - 获取 K 线数据\\n\\n\\n#### 其它（1 个）\\n\\n- ```IO/api``` - 仅对 ```exchange.IO(\\\"api\\\", ...)``` 调用生效\\n\\n\\n### 函数名称配置\\n\\n\\n#### 单个函数限流\\n\\n\\n限制单个函数的调用频率：\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 限制 GetTicker 每秒最多调用 3 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"rb888\\\")\\n if (ticker) {\\n Log(\\\"Success:\\\", ticker.Last)\\n } else {\\n Log(\\\"Rate limit exceeded\\\", \\\"#FF0000\\\")\\n }\\n Sleep(100)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 限制 GetTicker 每秒最多调用 3 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for i in range(10):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"rb888\\\")\\n if ticker:\\n Log(\\\"Success:\\\", ticker[\\\"Last\\\"])\\n else:\\n Log(\\\"Rate limit exceeded\\\", \\\"#FF0000\\\")\\n Sleep(100)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 限制 GetTicker 每秒最多调用 3 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\"));\\n\\n for _i in 0..10 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n match exchange.GetTicker(\\\"rb888\\\") {\\n Ok(ticker) => Log!(\\\"Success:\\\", ticker.Last),\\n Err(_) => Log!(\\\"Rate limit exceeded\\\", \\\"#FF0000\\\"),\\n }\\n Sleep(100);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"限制```GetTicker```每秒最多调用3次，超限时报错、返回空值。\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // GetTicker 和 GetDepth 共享同一限流配额，合计每秒最多 5 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 5, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n if (i % 2 == 0) {\\n var ticker = exchange.GetTicker(\\\"m888\\\")\\n Log(\\\"GetTicker:\\\", ticker ? \\\"Success\\\" : \\\"Failed\\\")\\n } else {\\n var depth = exchange.GetDepth(\\\"m888\\\")\\n Log(\\\"GetDepth:\\\", depth ? \\\"Success\\\" : \\\"Failed\\\")\\n }\\n Sleep(100)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # GetTicker 和 GetDepth 共享同一限流配额，合计每秒最多 5 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 5, \\\"1s\\\")\\n\\n for i in range(10):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n if i % 2 == 0:\\n ticker = exchange.GetTicker(\\\"m888\\\")\\n Log(\\\"GetTicker:\\\", \\\"Success\\\" if ticker else \\\"Failed\\\")\\n else:\\n depth = exchange.GetDepth(\\\"m888\\\")\\n Log(\\\"GetDepth:\\\", \\\"Success\\\" if depth else \\\"Failed\\\")\\n Sleep(100)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // GetTicker 和 GetDepth 共享同一限流配额，合计每秒最多 5 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 5, \\\"1s\\\"));\\n\\n for i in 0..10 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n if i % 2 == 0 {\\n let ticker = exchange.GetTicker(\\\"m888\\\");\\n Log!(\\\"GetTicker:\\\", if ticker.is_ok() { \\\"Success\\\" } else { \\\"Failed\\\" });\\n } else {\\n let depth = exchange.GetDepth(\\\"m888\\\");\\n Log!(\\\"GetDepth:\\\", if depth.is_ok() { \\\"Success\\\" } else { \\\"Failed\\\" });\\n }\\n Sleep(100);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 多个函数联合限流\\n\\n多个函数共享同一限流配额：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 限制所有 API 调用每秒最多 10 次\\n exchange.IO(\\\"mode\\\", 0) // 建议配合立即返回模式使用\\n exchange.IO(\\\"rate\\\", \\\"*\\\", 10, \\\"1s\\\")\\n\\n var symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\"]\\n for (var i = 0; i < 5; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var symbol = symbols[i % symbols.length]\\n var ticker = exchange.GetTicker(symbol)\\n var account = exchange.GetAccount()\\n\\n Log(\\\"Round\\\", i+1, \\\"Ticker:\\\", ticker ? \\\"✓\\\" : \\\"✗\\\",\\n \\\"Account:\\\", account ? \\\"✓\\\" : \\\"✗\\\")\\n Sleep(500)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 限制所有 API 调用每秒最多 10 次\\n exchange.IO(\\\"mode\\\", 0) # 建议配合立即返回模式使用\\n exchange.IO(\\\"rate\\\", \\\"*\\\", 10, \\\"1s\\\")\\n\\n symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\"]\\n for i in range(5):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n symbol = symbols[i % len(symbols)]\\n ticker = exchange.GetTicker(symbol)\\n account = exchange.GetAccount()\\n\\n Log(\\\"Round\\\", i+1, \\\"Ticker:\\\", \\\"✓\\\" if ticker else \\\"✗\\\",\\n \\\"Account:\\\", \\\"✓\\\" if account else \\\"✗\\\")\\n Sleep(500)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 限制所有 API 调用每秒最多 10 次\\n let _ = exchange.IO((\\\"mode\\\", 0)); // 建议配合立即返回模式使用\\n let _ = exchange.IO((\\\"rate\\\", \\\"*\\\", 10, \\\"1s\\\"));\\n\\n let symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\"];\\n for i in 0..5 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n let symbol = symbols[i % symbols.len()];\\n let ticker = exchange.GetTicker(symbol);\\n let account = exchange.GetAccount();\\n\\n Log!(\\\"Round\\\", i + 1, \\\"Ticker:\\\", if ticker.is_ok() { \\\"✓\\\" } else { \\\"✗\\\" },\\n \\\"Account:\\\", if account.is_ok() { \\\"✓\\\" } else { \\\"✗\\\" });\\n Sleep(500);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 通配符限流\\n\\n\\n 使用通配符```*```限制所有没有单独设置规则的 API 调用（```*```只是兜底，有单独规则的函数不再计入```*```）：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 不同时间周期的限流配置\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\") // 每秒 10 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 60, \\\"1m\\\") // 每分钟 60 次\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 100, \\\"1h\\\") // 每小时 100 次\\n\\n Log(\\\"Rate limits configured\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 不同时间周期的限流配置\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\") # 每秒 10 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 60, \\\"1m\\\") # 每分钟 60 次\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 100, \\\"1h\\\") # 每小时 100 次\\n\\n Log(\\\"Rate limits configured\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 不同时间周期的限流配置\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")); // 每秒 10 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetDepth\\\", 60, \\\"1m\\\")); // 每分钟 60 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetAccount\\\", 100, \\\"1h\\\")); // 每小时 100 次\\n\\n Log!(\\\"Rate limits configured\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"### 时间周期配置\\n\\n\\n#### 固定时间周期\\n\\n\\n支持多种时间单位：```ns```（纳秒）、```us/µs```（微秒）、```ms```（毫秒）、```s```（秒）、```m```（分钟）、```h```（小时）、```d```（天）。\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 每天 08:15 重置配额，上限 1000 次\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 1000, \\\"@0815\\\")\\n\\n Log(\\\"Daily quota configured: 1000 calls, reset at 08:15\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 每天 08:15 重置配额，上限 1000 次\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 1000, \\\"@0815\\\")\\n\\n Log(\\\"Daily quota configured: 1000 calls, reset at 08:15\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 每天 08:15 重置配额，上限 1000 次\\n let _ = exchange.IO((\\\"quota\\\", \\\"GetTicker\\\", 1000, \\\"@0815\\\"));\\n\\n Log!(\\\"Daily quota configured: 1000 calls, reset at 08:15\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 日内重置时间点\\n\\n\\n使用```@HHMM```或```@HHMMSS```格式指定每天的重置时间：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 默认模式：超过频率限制时返回 null\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"rb888\\\")\\n if (ticker) {\\n Log(\\\"Call\\\", i+1, \\\"Success\\\")\\n } else {\\n Log(\\\"Call\\\", i+1, \\\"Rate limit exceeded, returned null\\\", \\\"#FF0000\\\")\\n }\\n Sleep(100)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 默认模式：超过频率限制时返回 null\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for i in range(10):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"rb888\\\")\\n if ticker:\\n Log(\\\"Call\\\", i+1, \\\"Success\\\")\\n else:\\n Log(\\\"Call\\\", i+1, \\\"Rate limit exceeded, returned null\\\", \\\"#FF0000\\\")\\n Sleep(100)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 默认模式：超过频率限制时返回错误\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\"));\\n\\n for i in 0..10 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n match exchange.GetTicker(\\\"rb888\\\") {\\n Ok(_) => Log!(\\\"Call\\\", i + 1, \\\"Success\\\"),\\n Err(_) => Log!(\\\"Call\\\", i + 1, \\\"Rate limit exceeded, returned error\\\", \\\"#FF0000\\\"),\\n }\\n Sleep(100);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 行为模式配置\\n\\n\\n#### 默认模式（返回null）\\n\\n\\n当超过频率限制时，API 调用将立即返回 null，而不会等待：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // delay模式：超限后自动等待\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Testing delay mode\\\", \\\"#00FF00\\\")\\n for (var i = 0; i < 10; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var startTime = new Date().getTime()\\n var ticker = exchange.GetTicker(\\\"m888\\\")\\n var endTime = new Date().getTime()\\n\\n Log(\\\"Call\\\", i+1, \\\"Time cost:\\\", endTime - startTime, \\\"ms\\\")\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # delay模式：超限后自动等待\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Testing delay mode\\\", \\\"#00FF00\\\")\\n for i in range(10):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n startTime = time.time() * 1000\\n ticker = exchange.GetTicker(\\\"m888\\\")\\n endTime = time.time() * 1000\\n\\n Log(\\\"Call\\\", i+1, \\\"Time cost:\\\", endTime - startTime, \\\"ms\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // delay模式：超限后自动等待\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\", \\\"delay\\\"));\\n\\n Log!(\\\"Testing delay mode\\\", \\\"#00FF00\\\");\\n for i in 0..10 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n let startTime = UnixNano() / 1000000;\\n let _ticker = exchange.GetTicker(\\\"m888\\\");\\n let endTime = UnixNano() / 1000000;\\n\\n Log!(\\\"Call\\\", i + 1, \\\"Time cost:\\\", endTime - startTime, \\\"ms\\\");\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### delay模式（自动等待）\\n\\n当调用频率超出限制时自动等待，直到可以再次调用：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n exchange.IO(\\\"mode\\\", 0)\\n\\n // rate 模式：平滑限流，不严格对齐时间窗口\\n // exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n // quota 模式：严格对齐时间窗口，例如将 1s 对齐到整秒\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for (var i = 0; i < 8; i++) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"c888\\\")\\n Log(_D(), \\\"Call\\\", i+1, ticker ? \\\"Success\\\" : \\\"Quota exceeded\\\")\\n Sleep(150) // 每 150ms 调用一次\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n exchange.IO(\\\"mode\\\", 0)\\n\\n # rate 模式：平滑限流，不严格对齐时间窗口\\n # exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n # quota 模式：严格对齐时间窗口，例如将 1s 对齐到整秒\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n for i in range(8):\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"c888\\\")\\n Log(_D(), \\\"Call\\\", i+1, \\\"Success\\\" if ticker else \\\"Quota exceeded\\\")\\n Sleep(150) # 每 150ms 调用一次\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n let _ = exchange.IO((\\\"mode\\\", 0));\\n\\n // rate 模式：平滑限流，不严格对齐时间窗口\\n // let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 3, \\\"1s\\\"));\\n\\n // quota 模式：严格对齐时间窗口，例如将 1s 对齐到整秒\\n let _ = exchange.IO((\\\"quota\\\", \\\"GetTicker\\\", 3, \\\"1s\\\"));\\n\\n for i in 0..8 {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n let ticker = exchange.GetTicker(\\\"c888\\\");\\n Log!(_D(None), \\\"Call\\\", i + 1, if ticker.is_ok() { \\\"Success\\\" } else { \\\"Quota exceeded\\\" });\\n Sleep(150); // 每 150ms 调用一次\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 限流模式对比\\n\\n#### rate模式 vs quota模式\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n LogStatus(\\\"Waiting for connection...\\\")\\n Sleep(1000)\\n }\\n\\n // 设置行情获取频率限制\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Monitoring rb888 (rebar) price\\\")\\n while (true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"rb888\\\")\\n LogStatus(_D(), \\\"rb888 Price:\\\", ticker.Last,\\n \\\"Buy:\\\", ticker.Buy, \\\"Sell:\\\", ticker.Sell)\\n Sleep(200)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n LogStatus(\\\"Waiting for connection...\\\")\\n Sleep(1000)\\n\\n # 设置行情获取频率限制\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Monitoring rb888 (rebar) price\\\")\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"rb888\\\")\\n LogStatus(_D(), \\\"rb888 Price:\\\", ticker[\\\"Last\\\"],\\n \\\"Buy:\\\", ticker[\\\"Buy\\\"], \\\"Sell:\\\", ticker[\\\"Sell\\\"])\\n Sleep(200)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n LogStatus!(\\\"Waiting for connection...\\\");\\n Sleep(1000);\\n }\\n\\n // 设置行情获取频率限制\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n\\n Log!(\\\"Monitoring rb888 (rebar) price\\\");\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n if let Ok(ticker) = exchange.GetTicker(\\\"rb888\\\") {\\n LogStatus!(_D(None), \\\"rb888 Price:\\\", ticker.Last,\\n \\\"Buy:\\\", ticker.Buy, \\\"Sell:\\\", ticker.Sell);\\n }\\n Sleep(200);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 实际应用场景\\n\\n\\n#### 场景1：单品种行情监控\\n\\n\\n监控单个合约的行情，同时避免频繁调用接口：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n exchange.IO(\\\"mode\\\", 0)\\n // 所有行情函数共享配额\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 10, \\\"1s\\\")\\n\\n var symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\", \\\"c888\\\"]\\n Log(\\\"Monitoring multiple symbols:\\\", symbols.join(\\\", \\\"))\\n\\n while (true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n for (var i = 0; i < symbols.length; i++) {\\n var ticker = exchange.GetTicker(symbols[i])\\n if (ticker) {\\n Log(symbols[i], \\\"Price:\\\", ticker.Last)\\n }\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n exchange.IO(\\\"mode\\\", 0)\\n # 所有行情函数共享配额\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 10, \\\"1s\\\")\\n\\n symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\", \\\"c888\\\"]\\n Log(\\\"Monitoring multiple symbols:\\\", \\\", \\\".join(symbols))\\n\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n for symbol in symbols:\\n ticker = exchange.GetTicker(symbol)\\n if ticker:\\n Log(symbol, \\\"Price:\\\", ticker[\\\"Last\\\"])\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n let _ = exchange.IO((\\\"mode\\\", 0));\\n // 所有行情函数共享配额\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 10, \\\"1s\\\"));\\n\\n let symbols = [\\\"rb888\\\", \\\"m888\\\", \\\"i888\\\", \\\"c888\\\"];\\n Log!(\\\"Monitoring multiple symbols:\\\", symbols.join(\\\", \\\"));\\n\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n for symbol in &symbols {\\n if let Ok(ticker) = exchange.GetTicker(*symbol) {\\n Log!(*symbol, \\\"Price:\\\", ticker.Last);\\n }\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 场景2：多品种轮询策略\\n\\n\\n 轮询多个合约的行情，并控制整体的调用频率：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 分别为不同函数设置限流\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 2, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 1, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Rate limits configured for high-frequency trading\\\")\\n\\n // 策略逻辑\\n while (true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"rb888\\\")\\n var account = exchange.GetAccount()\\n\\n // 交易逻辑（示例）\\n LogStatus(_D(), \\\"Price:\\\", ticker.Last, \\\"Balance:\\\", account.Balance)\\n Sleep(500)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 分别为不同函数设置限流\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 2, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 1, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(\\\"Rate limits configured for high-frequency trading\\\")\\n\\n # 策略逻辑\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"rb888\\\")\\n account = exchange.GetAccount()\\n\\n # 交易逻辑（示例）\\n LogStatus(_D(), \\\"Price:\\\", ticker[\\\"Last\\\"], \\\"Balance:\\\", account[\\\"Balance\\\"])\\n Sleep(500)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 分别为不同函数设置限流\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\", \\\"delay\\\"));\\n let _ = exchange.IO((\\\"rate\\\", \\\"CreateOrder\\\", 2, \\\"1s\\\", \\\"delay\\\"));\\n let _ = exchange.IO((\\\"rate\\\", \\\"CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetAccount\\\", 1, \\\"1s\\\", \\\"delay\\\"));\\n\\n Log!(\\\"Rate limits configured for high-frequency trading\\\");\\n\\n // 策略逻辑\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n let ticker = exchange.GetTicker(\\\"rb888\\\");\\n let account = exchange.GetAccount();\\n\\n // 交易逻辑（示例）\\n if let (Ok(ticker), Ok(account)) = (ticker, account) {\\n LogStatus!(_D(None), \\\"Price:\\\", ticker.Last, \\\"Balance:\\\", account.Balance);\\n }\\n Sleep(500);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 场景3：高频交易策略\\n\\n\\n对交易相关接口实施严格的限流控制：\"}, {\"examples\": [{\"code\": \"function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n\\n // 每天09:00重置，限制每日开仓100次\\n exchange.IO(\\\"quota\\\", \\\"CreateOrder\\\", 100, \\\"@0900\\\")\\n\\n Log(\\\"Daily order limit: 100 orders, reset at 09:00\\\")\\n\\n var orderCount = 0\\n while (true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(5000)\\n continue\\n }\\n\\n var ticker = exchange.GetTicker(\\\"m888\\\")\\n\\n // 交易逻辑（示例）\\n // var orderId = exchange.CreateOrder(...)\\n // if (orderId) {\\n // orderCount++\\n // Log(\\\"Order created, daily count:\\\", orderCount)\\n // } else {\\n // Log(\\\"Daily order quota exceeded\\\", \\\"#FF0000\\\")\\n // }\\n\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n\\n # 每天09:00重置，限制每日开仓100次\\n exchange.IO(\\\"quota\\\", \\\"CreateOrder\\\", 100, \\\"@0900\\\")\\n\\n Log(\\\"Daily order limit: 100 orders, reset at 09:00\\\")\\n\\n orderCount = 0\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(5000)\\n continue\\n\\n ticker = exchange.GetTicker(\\\"m888\\\")\\n\\n # 交易逻辑（示例）\\n # orderId = exchange.CreateOrder(...)\\n # if orderId:\\n # orderCount += 1\\n # Log(\\\"Order created, daily count:\\\", orderCount)\\n # else:\\n # Log(\\\"Daily order quota exceeded\\\", \\\"#FF0000\\\")\\n\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n }\\n\\n // 每天09:00重置，限制每日开仓100次\\n let _ = exchange.IO((\\\"quota\\\", \\\"CreateOrder\\\", 100, \\\"@0900\\\"));\\n\\n Log!(\\\"Daily order limit: 100 orders, reset at 09:00\\\");\\n\\n let mut orderCount = 0;\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(5000);\\n continue;\\n }\\n\\n let _ticker = exchange.GetTicker(\\\"m888\\\");\\n\\n // 交易逻辑（示例）\\n // match exchange.CreateOrder(None, \\\"buy\\\", -1, 1) {\\n // Ok(_orderId) => {\\n // orderCount += 1;\\n // Log!(\\\"Order created, daily count:\\\", orderCount);\\n // }\\n // Err(_) => Log!(\\\"Daily order quota exceeded\\\", \\\"#FF0000\\\"),\\n // }\\n\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 场景4：日内交易次数控制\\n\\n使用 quota 模式控制每日的总交易次数：\"}, {\"value\": \"### 注意事项\\n\\n- **必须检查连接状态**\\n - 使用 API 限流功能前，必须先通过```exchange.IO(\\\"status\\\")```检查与交易服务器的连接状态\\n - 在循环中持续检查连接状态，以确保策略稳定运行\\n\\n- **配合立即返回模式**\\n - 建议配合```exchange.IO(\\\"mode\\\", 0)```立即返回模式一起使用\\n - 避免行情获取函数的等待影响限流效果\\n\\n- **商品期货市场**\\n - 优宽量化支持的市场为商品期货\\n - 合约代码格式示例：rb888（螺纹钢）、m888（豆粕）、i888（铁矿石）、c888（玉米）\\n\\n- **限流配置时机**\\n - 建议在策略初始化阶段配置限流规则\\n - 限流配置即时生效，无需重启策略\\n\\n- **quota 模式时间对齐**\\n - quota 模式严格对齐时间窗口\\n - 例如：设置为 \\\"1s\\\" 时，时间窗口对齐到整秒；设置为 \\\"1m\\\" 时，时间窗口对齐到整分钟\\n\\n- **delay 模式的时间差异**\\n - 使用 \\\"delay\\\" 参数时，API 调用时间与日志记录时间可能存在差异\\n - 这是由于函数正在等待限流窗口所致，属于正常现象\\n\\n- **合理设置限流参数**\\n - 应根据交易所的实际限制设置参数\\n - 预留一定余量，以避免触及交易所的硬性限制\\n\\n### 最佳实践\\n\\n- **分级限流策略**\\n - 针对不同类型的 API 设置不同的限流参数\\n - 对重要的交易接口（CreateOrder、CancelOrder）设置更严格的限制\\n - 对行情接口可适当放宽\\n\\n- **结合实际业务**\\n - 根据策略的实际调用频率设置限流参数\\n - 监控实际调用情况，并动态调整限流参数\\n\\n- **异常处理**\\n - 妥善处理返回 null 的情况\\n - 记录超限日志，以便后续分析与优化\\n\\n- **测试验证**\\n - 在模拟环境中充分测试限流配置\\n - 验证在各种极端情况下的表现\\n\\n- **持续监控**\\n - 监控 API 调用频率及限流触发情况\\n - 定期检查并优化限流配置\"}], \"title\": \"API限流控制\"}, {\"_src_hash\": \"10b2838bf9018c8c03fada8c79b79bc62fc77d7af51cc8e7b82d9f6e930083b4\", \"desc\": \"### 功能概述\\n\\n\\n策略实盘间通信功能允许不同的实盘策略之间进行数据共享与状态同步。通过频道机制，一个实盘可以将自身的状态数据广播给其他实盘，从而实现跨实盘、跨托管者、跨服务器的数据通信。\\n\\n\\n#### 核心概念\\n\\n\\n- **频道（Channel）**：每个实盘都拥有一个独立的频道，频道ID即为实盘ID\\n\\n- **广播端**：使用```SetChannelData()```函数在频道上发布数据的实盘\\n\\n- **订阅端**：使用```GetChannelData()```函数订阅其他实盘频道数据的实盘\\n\\n- **状态覆盖**：频道上仅保存最新状态，新数据会覆盖旧数据，而非采用消息队列机制\\n\\n\\n#### 主要特性\\n\\n\\n- **非阻塞通信**：所有函数调用均为非阻塞式，不会影响策略主流程\\n\\n- **跨平台支持**：可跨实盘、跨托管者、跨服务器进行数据传输\\n\\n- **多频道订阅**：一个实盘可同时订阅多个不同实盘的频道\\n\\n- **灵活的数据格式**：支持任何可JSON序列化的数据结构\\n\\n\\n#### 应用场景\\n\\n\\n- **主从策略协同**：主策略分析市场并广播交易信号，从策略接收信号并执行交易\\n\\n- **多账户同步**：在多个交易账户之间同步交易信号与持仓信息\\n\\n- **策略监控**：广播策略运行状态，由监控实盘订阅并进行展示或告警\\n\\n- **数据共享**：共享行情分析、指标计算等结果，避免重复计算\\n\\n\\n### 基本用法\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var updateId = 0\\n var robotId = _G() // 获取当前实盘 ID\\n\\n while(true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n continue\\n }\\n\\n // 获取市场行情数据\\n var ticker = exchange.GetTicker(\\\"rb888\\\")\\n if (!ticker) {\\n Sleep(5000)\\n continue\\n }\\n\\n // 构造频道状态数据\\n var channelState = {\\n robotId: robotId,\\n updateId: ++updateId,\\n timestamp: Date.now(),\\n symbol: \\\"rb888\\\",\\n lastPrice: ticker.Last,\\n volume: ticker.Volume,\\n high: ticker.High,\\n low: ticker.Low\\n }\\n\\n // 向频道发布最新状态(覆盖旧状态)\\n SetChannelData(channelState)\\n\\n // 显示当前频道状态\\n LogStatus(\\\"频道广播端 [实盘 ID: \\\" + robotId + \\\"]\\\\n\\\" +\\n \\\"更新 ID: #\\\" + channelState.updateId + \\\"\\\\n\\\" +\\n \\\"时间: \\\" + _D(channelState.timestamp) + \\\"\\\\n\\\" +\\n \\\"交易对: \\\" + channelState.symbol + \\\"\\\\n\\\" +\\n \\\"最新价: $\\\" + channelState.lastPrice.toFixed(2))\\n\\n Sleep(60000) // 每分钟更新一次频道状态\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n updateId = 0\\n robotId = _G() # 获取当前实盘 ID\\n\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n continue\\n\\n # 获取市场行情数据\\n ticker = exchange.GetTicker(\\\"rb888\\\")\\n if not ticker:\\n Sleep(5000)\\n continue\\n\\n # 构造频道状态数据\\n channelState = {\\n \\\"robotId\\\": robotId,\\n \\\"updateId\\\": updateId + 1,\\n \\\"timestamp\\\": time.time() * 1000,\\n \\\"symbol\\\": \\\"rb888\\\",\\n \\\"lastPrice\\\": ticker[\\\"Last\\\"],\\n \\\"volume\\\": ticker[\\\"Volume\\\"],\\n \\\"high\\\": ticker[\\\"High\\\"],\\n \\\"low\\\": ticker[\\\"Low\\\"]\\n }\\n updateId += 1\\n\\n # 向频道发布最新状态(覆盖旧状态)\\n SetChannelData(channelState)\\n\\n # 显示当前频道状态\\n LogStatus(\\\"频道广播端 [实盘 ID: {}]\\\\n\\\".format(robotId) +\\n \\\"更新 ID: #{}\\\\n\\\".format(channelState[\\\"updateId\\\"]) +\\n \\\"时间: {}\\\\n\\\".format(_D(channelState[\\\"timestamp\\\"])) +\\n \\\"最新价: ${:.2f}\\\".format(channelState[\\\"lastPrice\\\"]))\\n\\n Sleep(60000) # 每分钟更新一次频道状态\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let mut updateId = 0;\\n let robotId = _G!(); // 获取当前实盘 ID\\n\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n continue;\\n }\\n\\n // 获取市场行情数据\\n let ticker = match exchange.GetTicker(\\\"rb888\\\") {\\n Ok(t) => t,\\n Err(_) => {\\n Sleep(5000);\\n continue;\\n }\\n };\\n\\n // 构造频道状态数据\\n updateId += 1;\\n let timestamp = Unix() * 1000;\\n let channelState = format!(\\n r#\\\"{{\\\"robotId\\\": {}, \\\"updateId\\\": {}, \\\"timestamp\\\": {}, \\\"symbol\\\": \\\"rb888\\\", \\\"lastPrice\\\": {}, \\\"volume\\\": {}, \\\"high\\\": {}, \\\"low\\\": {}}}\\\"#,\\n robotId, updateId, timestamp, ticker.Last, ticker.Volume, ticker.High, ticker.Low\\n );\\n\\n // 向频道发布最新状态(覆盖旧状态)\\n SetChannelData(&channelState);\\n\\n // 显示当前频道状态\\n LogStatus!(format!(\\n \\\"频道广播端 [实盘 ID: {}]\\\\n更新 ID: #{}\\\\n时间: {}\\\\n交易对: rb888\\\\n最新价: ${:.2}\\\",\\n robotId, updateId, _D(timestamp), ticker.Last\\n ));\\n\\n Sleep(60000); // 每分钟更新一次频道状态\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 广播端示例 - 发布市场数据\"}, {\"examples\": [{\"code\": \"function main() {\\n // 需要订阅的两个频道ID(根据实际情况修改)\\n var channelId1 = \\\"632799\\\" // 频道1的实盘ID\\n var channelId2 = \\\"632800\\\" // 频道2的实盘ID\\n\\n while(true) {\\n // 订阅频道1的当前状态\\n var state1 = GetChannelData(channelId1)\\n\\n // 订阅频道2的当前状态\\n var state2 = GetChannelData(channelId2)\\n\\n // 构建状态显示\\n var statusMsg = \\\"频道订阅端 - 当前订阅状态\\\\n\\\\n\\\"\\n\\n // 显示频道1状态\\n statusMsg += \\\"═══ 频道1 [\\\" + channelId1 + \\\"] ═══\\\\n\\\"\\n if (state1 !== null) {\\n statusMsg += \\\"更新ID: #\\\" + state1.updateId + \\\"\\\\n\\\"\\n statusMsg += \\\"时间: \\\" + _D(state1.timestamp) + \\\"\\\\n\\\"\\n statusMsg += \\\"交易对: \\\" + state1.symbol + \\\"\\\\n\\\"\\n statusMsg += \\\"最新价: $\\\" + state1.lastPrice.toFixed(2) + \\\"\\\\n\\\"\\n } else {\\n statusMsg += \\\"状态: 等待中... (首次调用返回 null)\\\\n\\\"\\n }\\n\\n statusMsg += \\\"\\\\n\\\"\\n\\n // 显示频道2状态\\n statusMsg += \\\"═══ 频道2 [\\\" + channelId2 + \\\"] ═══\\\\n\\\"\\n if (state2 !== null) {\\n statusMsg += \\\"更新ID: #\\\" + state2.updateId + \\\"\\\\n\\\"\\n statusMsg += \\\"时间: \\\" + _D(state2.timestamp) + \\\"\\\\n\\\"\\n statusMsg += \\\"最新价: $\\\" + state2.lastPrice.toFixed(2) + \\\"\\\\n\\\"\\n } else {\\n statusMsg += \\\"状态: 等待中... (首次调用返回 null)\\\\n\\\"\\n }\\n\\n LogStatus(statusMsg)\\n\\n Sleep(5000) // 每5秒订阅一次频道\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 需要订阅的两个频道ID(根据实际情况修改)\\n channelId1 = \\\"632799\\\" # 频道1的实盘ID\\n channelId2 = \\\"632800\\\" # 频道2的实盘ID\\n\\n while True:\\n # 订阅频道1的当前状态\\n state1 = GetChannelData(channelId1)\\n\\n # 订阅频道2的当前状态\\n state2 = GetChannelData(channelId2)\\n\\n # 构建状态显示\\n statusMsg = \\\"频道订阅端 - 当前订阅状态\\\\n\\\\n\\\"\\n\\n # 显示频道1状态\\n statusMsg += \\\"═══ 频道1 [{}] ═══\\\\n\\\".format(channelId1)\\n if state1 is not None:\\n statusMsg += \\\"更新ID: #{}\\\\n\\\".format(state1[\\\"updateId\\\"])\\n statusMsg += \\\"时间: {}\\\\n\\\".format(_D(state1[\\\"timestamp\\\"]))\\n statusMsg += \\\"最新价: ${:.2f}\\\\n\\\".format(state1[\\\"lastPrice\\\"])\\n else:\\n statusMsg += \\\"状态: 等待中... (首次调用返回 None)\\\\n\\\"\\n\\n statusMsg += \\\"\\\\n\\\"\\n\\n # 显示频道2状态\\n statusMsg += \\\"═══ 频道2 [{}] ═══\\\\n\\\".format(channelId2)\\n if state2 is not None:\\n statusMsg += \\\"更新ID: #{}\\\\n\\\".format(state2[\\\"updateId\\\"])\\n statusMsg += \\\"时间: {}\\\\n\\\".format(_D(state2[\\\"timestamp\\\"]))\\n statusMsg += \\\"最新价: ${:.2f}\\\\n\\\".format(state2[\\\"lastPrice\\\"])\\n else:\\n statusMsg += \\\"状态: 等待中... (首次调用返回 None)\\\\n\\\"\\n\\n LogStatus(statusMsg)\\n\\n Sleep(5000) # 每5秒订阅一次频道\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // Rust 的 GetChannelData() 函数不接受频道 ID 参数，只能读取当前实盘自身频道\\n // （即本实盘通过 SetChannelData() 发布）的最新数据，无法订阅其它实盘的频道\\n loop {\\n // 订阅频道的当前状态\\n let state = GetChannelData();\\n\\n // 构建状态显示\\n let mut statusMsg = String::from(\\\"频道订阅端 - 当前订阅状态\\\\n\\\\n\\\");\\n\\n if !state.is_null() {\\n statusMsg += &format!(\\\"更新ID: #{}\\\\n\\\", state[\\\"updateId\\\"].as_i64().unwrap_or(0));\\n statusMsg += &format!(\\\"时间: {}\\\\n\\\", _D(state[\\\"timestamp\\\"].as_i64().unwrap_or(0)));\\n statusMsg += &format!(\\\"交易对: {}\\\\n\\\", state[\\\"symbol\\\"].as_str().unwrap_or(\\\"\\\"));\\n statusMsg += &format!(\\\"最新价: ${:.2}\\\\n\\\", state[\\\"lastPrice\\\"].as_f64().unwrap_or(0.0));\\n } else {\\n statusMsg += \\\"状态: 等待中... (首次调用返回 null)\\\\n\\\";\\n }\\n\\n LogStatus!(statusMsg);\\n\\n Sleep(5000); // 每5秒订阅一次频道\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 订阅端示例 - 订阅多个频道\"}, {\"examples\": [{\"code\": \"function main() {\\n var robotId = _G()\\n Log(\\\"主策略启动，实盘ID:\\\", robotId)\\n\\n while(true) {\\n if (!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n continue\\n }\\n\\n // 分析市场行情，生成交易信号\\n var records = exchange.GetRecords(\\\"rb888\\\")\\n if (!records || records.length < 20) {\\n Sleep(5000)\\n continue\\n }\\n\\n // 简单的均线交叉策略\\n var ma5 = TA.MA(records, 5)\\n var ma20 = TA.MA(records, 20)\\n var signal = \\\"HOLD\\\"\\n\\n if (ma5[ma5.length-1] > ma20[ma20.length-1] &&\\n ma5[ma5.length-2] <= ma20[ma20.length-2]) {\\n signal = \\\"BUY\\\"\\n } else if (ma5[ma5.length-1] < ma20[ma20.length-1] &&\\n ma5[ma5.length-2] >= ma20[ma20.length-2]) {\\n signal = \\\"SELL\\\"\\n }\\n\\n // 广播交易信号\\n var signalData = {\\n timestamp: Date.now(),\\n symbol: \\\"rb888\\\",\\n signal: signal,\\n price: records[records.length-1].Close,\\n ma5: ma5[ma5.length-1],\\n ma20: ma20[ma20.length-1]\\n }\\n\\n SetChannelData(signalData)\\n LogStatus(\\\"主策略 - 信号广播\\\\n\\\" +\\n \\\"信号: \\\" + signal + \\\"\\\\n\\\" +\\n \\\"价格: $\\\" + signalData.price.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"MA5: \\\" + signalData.ma5.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"MA20: \\\" + signalData.ma20.toFixed(2))\\n\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n robotId = _G()\\n Log(\\\"主策略启动，实盘ID:\\\", robotId)\\n\\n while True:\\n if not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n continue\\n\\n # 分析市场行情，生成交易信号\\n records = exchange.GetRecords(\\\"rb888\\\")\\n if not records or len(records) < 20:\\n Sleep(5000)\\n continue\\n\\n # 简单的均线交叉策略\\n ma5 = TA.MA(records, 5)\\n ma20 = TA.MA(records, 20)\\n signal = \\\"HOLD\\\"\\n\\n if ma5[-1] > ma20[-1] and ma5[-2] <= ma20[-2]:\\n signal = \\\"BUY\\\"\\n elif ma5[-1] < ma20[-1] and ma5[-2] >= ma20[-2]:\\n signal = \\\"SELL\\\"\\n\\n # 广播交易信号\\n signalData = {\\n \\\"timestamp\\\": time.time() * 1000,\\n \\\"symbol\\\": \\\"rb888\\\",\\n \\\"signal\\\": signal,\\n \\\"price\\\": records[-1][\\\"Close\\\"],\\n \\\"ma5\\\": ma5[-1],\\n \\\"ma20\\\": ma20[-1]\\n }\\n\\n SetChannelData(signalData)\\n LogStatus(\\\"主策略 - 信号广播\\\\n\\\" +\\n \\\"信号: {}\\\\n\\\".format(signal) +\\n \\\"价格: ${:.2f}\\\\n\\\".format(signalData[\\\"price\\\"]) +\\n \\\"MA5: {:.2f}\\\\n\\\".format(signalData[\\\"ma5\\\"]) +\\n \\\"MA20: {:.2f}\\\".format(signalData[\\\"ma20\\\"]))\\n\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let robotId = _G!();\\n Log!(\\\"主策略启动，实盘ID:\\\", robotId);\\n\\n loop {\\n if !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n Sleep(1000);\\n continue;\\n }\\n\\n // 分析市场行情，生成交易信号\\n let records = match exchange.GetRecords(\\\"rb888\\\", None, None) {\\n Ok(r) => r,\\n Err(_) => {\\n Sleep(5000);\\n continue;\\n }\\n };\\n if records.len() < 20 {\\n Sleep(5000);\\n continue;\\n }\\n\\n // 简单的均线交叉策略\\n let ma5 = TA.MA(&records, 5);\\n let ma20 = TA.MA(&records, 20);\\n let mut signal = \\\"HOLD\\\";\\n\\n if ma5[ma5.len() - 1] > ma20[ma20.len() - 1] && ma5[ma5.len() - 2] <= ma20[ma20.len() - 2] {\\n signal = \\\"BUY\\\";\\n } else if ma5[ma5.len() - 1] < ma20[ma20.len() - 1] && ma5[ma5.len() - 2] >= ma20[ma20.len() - 2] {\\n signal = \\\"SELL\\\";\\n }\\n\\n // 广播交易信号\\n let price = records[records.len() - 1].Close;\\n let signalData = format!(\\n r#\\\"{{\\\"timestamp\\\": {}, \\\"symbol\\\": \\\"rb888\\\", \\\"signal\\\": \\\"{}\\\", \\\"price\\\": {}, \\\"ma5\\\": {}, \\\"ma20\\\": {}}}\\\"#,\\n Unix() * 1000, signal, price, ma5[ma5.len() - 1], ma20[ma20.len() - 1]\\n );\\n\\n SetChannelData(&signalData);\\n LogStatus!(format!(\\n \\\"主策略 - 信号广播\\\\n信号: {}\\\\n价格: ${:.2}\\\\nMA5: {:.2}\\\\nMA20: {:.2}\\\",\\n signal, price, ma5[ma5.len() - 1], ma20[ma20.len() - 1]\\n ));\\n\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 实际应用场景\\n\\n#### 场景1：主从策略协同交易\\n\\n##### 主策略（信号广播端）\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterRobotId = \\\"632799\\\" // 主策略的实盘ID\\n var lastSignal = null\\n\\n Log(\\\"从策略启动，订阅主策略:\\\", masterRobotId)\\n\\n while(true) {\\n // 获取主策略的信号\\n var signalData = GetChannelData(masterRobotId)\\n\\n if (signalData === null) {\\n LogStatus(\\\"等待主策略信号...\\\")\\n Sleep(5000)\\n continue\\n }\\n\\n // 检查是否有新信号\\n if (lastSignal !== signalData.signal) {\\n Log(\\\"收到新信号:\\\", signalData.signal, \\\"价格:\\\", signalData.price)\\n\\n // 执行交易\\n if (signalData.signal === \\\"BUY\\\") {\\n var ticker = exchange.GetTicker(signalData.symbol)\\n if (ticker) {\\n exchange.Buy(ticker.Last, 0.01)\\n Log(\\\"执行买入，价格:\\\", ticker.Last)\\n }\\n } else if (signalData.signal === \\\"SELL\\\") {\\n var ticker = exchange.GetTicker(signalData.symbol)\\n if (ticker) {\\n exchange.Sell(ticker.Last, 0.01)\\n Log(\\\"执行卖出，价格:\\\", ticker.Last)\\n }\\n }\\n\\n lastSignal = signalData.signal\\n }\\n\\n LogStatus(\\\"从策略 - 跟随主策略\\\\n\\\" +\\n \\\"当前信号: \\\" + signalData.signal + \\\"\\\\n\\\" +\\n \\\"信号价格: $\\\" + signalData.price.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"信号时间: \\\" + _D(signalData.timestamp))\\n\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n masterRobotId = \\\"632799\\\" # 主策略的实盘ID\\n lastSignal = None\\n\\n Log(\\\"从策略启动，订阅主策略:\\\", masterRobotId)\\n\\n while True:\\n # 获取主策略的信号\\n signalData = GetChannelData(masterRobotId)\\n\\n if signalData is None:\\n LogStatus(\\\"等待主策略信号...\\\")\\n Sleep(5000)\\n continue\\n\\n # 检查是否有新信号\\n if lastSignal != signalData[\\\"signal\\\"]:\\n Log(\\\"收到新信号:\\\", signalData[\\\"signal\\\"], \\\"价格:\\\", signalData[\\\"price\\\"])\\n\\n # 执行交易\\n if signalData[\\\"signal\\\"] == \\\"BUY\\\":\\n ticker = exchange.GetTicker(signalData[\\\"symbol\\\"])\\n if ticker:\\n exchange.Buy(ticker[\\\"Last\\\"], 0.01)\\n Log(\\\"执行买入，价格:\\\", ticker[\\\"Last\\\"])\\n elif signalData[\\\"signal\\\"] == \\\"SELL\\\":\\n ticker = exchange.GetTicker(signalData[\\\"symbol\\\"])\\n if ticker:\\n exchange.Sell(ticker[\\\"Last\\\"], 0.01)\\n Log(\\\"执行卖出，价格:\\\", ticker[\\\"Last\\\"])\\n\\n lastSignal = signalData[\\\"signal\\\"]\\n\\n LogStatus(\\\"从策略 - 跟随主策略\\\\n\\\" +\\n \\\"当前信号: {}\\\\n\\\".format(signalData[\\\"signal\\\"]) +\\n \\\"信号价格: ${:.2f}\\\\n\\\".format(signalData[\\\"price\\\"]) +\\n \\\"信号时间: {}\\\".format(_D(signalData[\\\"timestamp\\\"])))\\n\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // Rust 的 GetChannelData() 函数不接受频道 ID 参数，只能读取当前实盘自身频道\\n // （即本实盘通过 SetChannelData() 发布）的最新数据，无法订阅其他实盘的频道\\n // 这里以读取本实盘频道上的信号数据为例，演示信号接收执行逻辑\\n let mut lastSignal = String::new();\\n\\n Log!(\\\"从策略启动，订阅频道信号\\\");\\n\\n loop {\\n // 获取频道上的信号\\n let signalData = GetChannelData();\\n\\n if signalData.is_null() {\\n LogStatus!(\\\"等待信号...\\\");\\n Sleep(5000);\\n continue;\\n }\\n\\n let signal = signalData[\\\"signal\\\"].as_str().unwrap_or(\\\"\\\").to_string();\\n let symbol = signalData[\\\"symbol\\\"].as_str().unwrap_or(\\\"\\\").to_string();\\n let price = signalData[\\\"price\\\"].as_f64().unwrap_or(0.0);\\n\\n // 检查是否有新信号\\n if lastSignal != signal {\\n Log!(\\\"收到新信号:\\\", signal, \\\"价格:\\\", price);\\n\\n // 执行交易\\n if signal == \\\"BUY\\\" {\\n if let Ok(ticker) = exchange.GetTicker(symbol.as_str()) {\\n let _ = exchange.Buy(ticker.Last, 0.01);\\n Log!(\\\"执行买入，价格:\\\", ticker.Last);\\n }\\n } else if signal == \\\"SELL\\\" {\\n if let Ok(ticker) = exchange.GetTicker(symbol.as_str()) {\\n let _ = exchange.Sell(ticker.Last, 0.01);\\n Log!(\\\"执行卖出，价格:\\\", ticker.Last);\\n }\\n }\\n\\n lastSignal = signal.clone();\\n }\\n\\n LogStatus!(format!(\\n \\\"从策略 - 跟随信号\\\\n当前信号: {}\\\\n信号价格: ${:.2}\\\\n信号时间: {}\\\",\\n signal, price, _D(signalData[\\\"timestamp\\\"].as_i64().unwrap_or(0))\\n ));\\n\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 实际应用场景\\n\\n\\n#### 场景1：主从策略协同交易\\n\\n\\n##### 从策略（信号接收执行端）\"}, {\"examples\": [{\"code\": \"function main() {\\n // 需要监控的策略实盘ID列表\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]\\n\\n while(true) {\\n var table = {\\n type: \\\"table\\\",\\n title: \\\"策略运行状态监控\\\",\\n cols: [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"当前价格\\\", \\\"盈亏\\\"],\\n rows: []\\n }\\n\\n for (var i = 0; i < monitorList.length; i++) {\\n var robotId = monitorList[i]\\n var data = GetChannelData(robotId)\\n\\n if (data !== null) {\\n var updateTime = _D(data.timestamp)\\n var timeDiff = Date.now() - data.timestamp\\n var status = timeDiff < 120000 ? \\\"运行中\\\" : \\\"异常\\\"\\n\\n table.rows.push([\\n robotId,\\n status,\\n updateTime,\\n data.symbol || \\\"-\\\",\\n data.lastPrice ? \\\"$\\\" + data.lastPrice.toFixed(2) : \\\"-\\\",\\n data.profit ? data.profit.toFixed(2) + \\\"%\\\" : \\\"-\\\"\\n ])\\n } else {\\n table.rows.push([\\n robotId,\\n \\\"等待数据\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\"\\n ])\\n }\\n }\\n\\n LogStatus(\\\"`\\\" + JSON.stringify(table) + \\\"`\\\")\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 需要监控的策略实盘ID列表\\n monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]\\n\\n while True:\\n table = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"策略运行状态监控\\\",\\n \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"当前价格\\\", \\\"盈亏\\\"],\\n \\\"rows\\\": []\\n }\\n\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n\\n if data is not None:\\n updateTime = _D(data[\\\"timestamp\\\"])\\n timeDiff = time.time() * 1000 - data[\\\"timestamp\\\"]\\n status = \\\"运行中\\\" if timeDiff < 120000 else \\\"异常\\\"\\n\\n table[\\\"rows\\\"].append([\\n robotId,\\n status,\\n updateTime,\\n data.get(\\\"symbol\\\", \\\"-\\\"),\\n \\\"${:.2f}\\\".format(data[\\\"lastPrice\\\"]) if \\\"lastPrice\\\" in data else \\\"-\\\",\\n \\\"{:.2f}%\\\".format(data[\\\"profit\\\"]) if \\\"profit\\\" in data else \\\"-\\\"\\n ])\\n else:\\n table[\\\"rows\\\"].append([\\n robotId,\\n \\\"等待数据\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\"\\n ])\\n\\n LogStatus(\\\"`\\\" + json.dumps(table) + \\\"`\\\")\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // Rust 的 GetChannelData() 不接受频道 ID 参数，只能读取本实盘自身频道的最新数据，\\n // 无法像 JavaScript/Python 那样传入实盘ID列表监控多个其它实盘，这里以监控本实盘自身频道状态为例\\n let robotId = _G!();\\n\\n loop {\\n let data = GetChannelData();\\n\\n let row = if !data.is_null() {\\n let timestamp = data[\\\"timestamp\\\"].as_i64().unwrap_or(0);\\n let updateTime = _D(timestamp);\\n let timeDiff = Unix() * 1000 - timestamp;\\n let status = if timeDiff < 120000 { \\\"运行中\\\" } else { \\\"异常\\\" };\\n\\n format!(\\n r#\\\"[\\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"${:.2}\\\", \\\"-\\\"]\\\"#,\\n robotId, status, updateTime,\\n data[\\\"symbol\\\"].as_str().unwrap_or(\\\"-\\\"),\\n data[\\\"lastPrice\\\"].as_f64().unwrap_or(0.0)\\n )\\n } else {\\n format!(r#\\\"[\\\"{}\\\", \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"]\\\"#, robotId)\\n };\\n\\n let table = format!(\\n r#\\\"{{\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"策略运行状态监控\\\", \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"当前价格\\\", \\\"盈亏\\\"], \\\"rows\\\": [{}]}}\\\"#,\\n row\\n );\\n\\n LogStatus!(format!(\\\"`{}`\\\", table));\\n Sleep(10000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"#### 场景2：多策略状态监控\\n\\n\\n##### 监控策略\"}, {\"value\": \"### API函数说明\\n\\n\\n#### SetChannelData(data)\\n\\n\\n**功能**：在频道上发布最新的状态数据\\n\\n\\n##### 参数\\n\\n- data：需要发布的数据，可以是任何支持JSON序列化的数据结构\\n\\n\\n**返回值**：无\\n\\n\\n##### 特性\\n\\n- 非阻塞调用\\n\\n- 覆盖上一次发布的数据，不累积历史记录\\n\\n- 自动使用当前实盘ID作为频道ID\\n\\n\\n##### 数据长度限制\\n\\n- JSON序列化后不得超过1024字节\\n\\n- 建议仅传输必要的状态信息\\n\\n\\n**详细文档**：{@fun/Global/SetChannelData SetChannelData}\\n\\n\\n#### GetChannelData(robotId)\\n\\n\\n**功能**：订阅指定实盘的频道数据\\n\\n\\n##### 参数\\n\\n- robotId：要订阅的实盘ID（字符串或数字）\\n\\n\\n##### 返回值\\n\\n- 首次调用返回null，需要重试\\n\\n- 订阅成功后返回该频道的最新数据\\n\\n\\n##### 特性\\n\\n- 非阻塞调用\\n\\n- 支持同时订阅多个频道\\n\\n- 支持订阅自身的频道\\n\\n\\n**详细文档**：{@fun/Global/GetChannelData GetChannelData}\\n\\n\\n### 注意事项\\n\\n\\n- **首次调用返回null**：```GetChannelData()```函数首次调用时会返回```null```，这是正常现象，表示数据尚未同步完成，需要重试等待。建议在代码中对返回值进行null判断。\\n\\n\\n- **数据覆盖机制**：频道上仅保存最新的状态数据，调用```SetChannelData()```会覆盖之前发布的数据。若需要保存历史数据，应在订阅端自行记录。\\n\\n\\n- **非阻塞特性**：所有频道通信函数均为非阻塞调用，不会影响策略主流程的执行。但这也意味着无法保证数据的实时性。\\n\\n\\n- **数据大小限制**：传入SetChannelData的数据在JSON序列化后不得超过1024字节。应仅传输必要的状态信息，如交易信号、价格、持仓等关键数据，避免传输完整的K线数组或大量历史数据。\\n\\n\\n- **实盘环境限制**：频道通信功能主要适用于实盘环境，在回测系统中可能受限或不可用。\\n\\n\\n- **实盘ID获取**：可以通过```_G()```函数获取当前实盘ID，也可以在平台界面中查看实盘ID。\\n\\n\\n- **安全性考虑**：频道数据可能被其他具有权限的实盘订阅，请勿在频道中传输敏感信息（如API密钥等）。\\n\\n\\n### 最佳实践\\n\\n\\n- **合理的更新频率**：根据实际需求设置数据更新频率，避免过于频繁的更新造成资源浪费。\\n\\n\\n- **数据结构设计**：设计清晰的数据结构，并包含必要的元数据（如时间戳、版本号等），便于订阅端处理。\\n\\n\\n- **错误处理**：订阅端应处理null返回值，发布端应确保数据格式正确。\\n\\n\\n- **状态版本控制**：在数据中包含版本号或更新ID，帮助订阅端判断是否存在新数据。\\n\\n\\n- **监控与告警**：对于关键的通信链路，建议实现超时监控和告警机制。\\n\\n\\n- **测试验证**：在正式使用前，先在测试环境中验证频道通信的稳定性和延迟。\\n\\n\\n- **文档记录**：记录频道数据格式与通信协议，便于后续维护和多人协作。\"}], \"seeAlso\": [\"{@fun/Global/SetChannelData SetChannelData}\", \"{@fun/Global/GetChannelData GetChannelData}\", \"{@fun/Global/_G _G}\"], \"title\": \"策略实盘间通信\"}, {\"_src_hash\": \"db83337f7bda20231546a08f5500c0c3b49bb1353937f13500fdf9f17df00dac\", \"desc\": \"优宽量化交易平台从系统底层真正支持```JavaScript```语言策略的多线程功能，实现了以下对象：\\n\\n| 对象 | 说明 | 备注 |\\n| - | - | - |\\n| threading | 多线程全局对象 | 成员函数：```Thread```、```getThread```、```mainThread```等。 |\\n| Thread | 线程对象 | 成员函数：```peekMessage```、```postMessage```、```join```等。 |\\n| ThreadLock | 线程锁对象 | 成员函数：```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadEvent | 事件对象 | 成员函数：```set```、```clear```、```wait```、```isSet```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadCondition | 条件对象 | 成员函数：```notify```、```notifyAll```、```wait```、```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadDict | 字典对象 | 成员函数：```get```、```set```。可作为线程执行函数的参数传入线程环境。 |\\n\\n优宽量化交易平台语法手册：{@fun/Threads JavaScript多线程}\", \"title\": \"JavaScript多线程\"}, {\"_src_hash\": \"fb65dc7f50f04ed538d513787f9d9a08c06a3070d034827affd2032535efcbee\", \"alias\": \"TA指标库\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| {@fun/TA/TA.MACD TA.MACD} | 计算指数平滑异同移动平均线指标 |\\n| {@fun/TA/TA.KDJ TA.KDJ} | 计算随机指标 |\\n| {@fun/TA/TA.RSI TA.RSI} | 计算相对强弱指标 |\\n| {@fun/TA/TA.ATR TA.ATR} | 计算真实波动幅度均值指标 |\\n| {@fun/TA/TA.OBV TA.OBV} | 计算能量潮指标 |\\n| {@fun/TA/TA.MA TA.MA} | 计算移动平均线指标 |\\n| {@fun/TA/TA.EMA TA.EMA} | 计算指数移动平均线指标 |\\n| {@fun/TA/TA.BOLL TA.BOLL} | 计算布林带指标 |\\n| {@fun/TA/TA.Alligator TA.Alligator} | 计算鳄鱼线指标 |\\n| {@fun/TA/TA.CMF TA.CMF} | 计算蔡金资金流量指标 |\\n| {@fun/TA/TA.Highest TA.Highest} | 计算指定周期内的最高价 |\\n| {@fun/TA/TA.Lowest TA.Lowest} | 计算指定周期内的最低价 |\\n| {@fun/TA/TA.SMA TA.SMA} | 计算简单移动平均线指标 |\", \"title\": \"TA指标函数\"}, {\"_src_hash\": \"4fd6d8a393fdc50218af283f53da08755778e6b6920a81c28330fc9cbe0898b5\", \"alias\": \"talib指标库\", \"desc\": \"talib指标库包含众多技术分析指标，例如：{@fun/Talib/talib.CDL2CROWS talib.CDL2CROWS}。详细信息请参阅语法手册。\", \"title\": \"talib指标函数\"}], \"desc\": \"在使用```JavaScript```、```Python```、```Rust```语言编写的策略中，需要在策略主循环中调用```Sleep()```函数。回测时，该函数用于控制回测的运行速度；实盘时，则用于控制策略的轮询时间间隔，从而控制访问交易所API接口的请求频率。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n while(true){\\n // 需要在判断exchange.IO(\\\"status\\\")函数返回1（真值）时才可调用行情、交易等函数\\n if(exchange.IO(\\\"status\\\")){\\n exchange.SetContractType(\\\"MA000\\\")\\n var ticker = exchange.GetTicker()\\n Log(\\\"MA000 ticker:\\\", ticker)\\n LogStatus(_D(), \\\"已经连接CTP ！\\\")\\n } else {\\n LogStatus(_D(), \\\"未连接CTP ！\\\")\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n while True:\\n if exchange.IO(\\\"status\\\"):\\n exchange.SetContractType(\\\"MA000\\\")\\n ticker = exchange.GetTicker()\\n Log(\\\"MA000 ticker:\\\", ticker)\\n LogStatus(_D(), \\\"已经连接CTP ！\\\")\\n else:\\n LogStatus(_D(), \\\"未连接CTP ！\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n loop {\\n // 需要在判断exchange.IO(\\\"status\\\")函数返回1（真值）时才可调用行情、交易等函数\\n if exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n let _ = exchange.SetContractType(\\\"MA000\\\");\\n let ticker = exchange.GetTicker(None);\\n Log!(\\\"MA000 ticker:\\\", ticker);\\n LogStatus!(_D(None), \\\"已经连接CTP ！\\\");\\n } else {\\n LogStatus!(_D(None), \\\"未连接CTP ！\\\");\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"经典的商品期货策略架构：\"}, {\"examples\": [{\"code\": \"function onTick() {\\n Log(\\\"K线更新，新BAR产生\\\")\\n}\\n\\nfunction main() {\\n var lastTs = 0\\n while (true) {\\n if (exchange.IO(\\\"status\\\")) {\\n exchange.SetContractType(\\\"rb888\\\")\\n var r = _C(exchange.GetRecords)\\n if (r.length > 0 && r[r.length - 1].Time != lastTs) {\\n onTick()\\n lastTs = r[r.length - 1].Time\\n }\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(\\\"K线更新，新BAR产生\\\")\\n\\ndef main():\\n lastTs = 0\\n while True:\\n if exchange.IO(\\\"status\\\"):\\n exchange.SetContractType(\\\"rb888\\\")\\n r = _C(exchange.GetRecords)\\n if len(r) > 0 and r[-1][\\\"Time\\\"] != lastTs:\\n onTick()\\n lastTs = r[-1][\\\"Time\\\"]\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n Log!(\\\"K线更新，新BAR产生\\\");\\n}\\n\\nfn main() {\\n let mut lastTs = 0;\\n loop {\\n if exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n let _ = exchange.SetContractType(\\\"rb888\\\");\\n let r = _C!(exchange.GetRecords(None, None, None));\\n if r.len() > 0 && r[r.len() - 1].Time != lastTs {\\n onTick();\\n lastTs = r[r.len() - 1].Time;\\n }\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"设计一个On Bar架构的策略\"}, {\"value\": \"以下各页是API函数速查表，点击函数名查看语法手册中的详细说明。\"}], \"title\": \"策略框架与API函数\"}, {\"_src_hash\": \"ea785d700a60c509b728157df72fa919b918cbdeec3d9837ed2876ecb2a62bb3\", \"children\": [{\"_src_hash\": \"ac1febc449f7528b5c9ca2da4ff6378616d17c974ae93f271b48adf681684a48\", \"desc\": \"导出函数是模板类库的接口函数，可被引用该模板类库的策略调用。\", \"examples\": [{\"examples\": [{\"code\": \"/*\\n-- 策略引用该模板以后直接用 $.Test() 调用此方法\\n-- main 函数在策略中不会触发, 只做为模板调试的入口\\n*/\\n$.Test = function() {\\n Log('Test')\\n}\\n\\nfunction main() {\\n $.Test()\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def Test():\\n Log(\\\"template call\\\")\\n\\n# 导出Test函数, 主策略可以通过ext.Test()调用\\next.Test = Test\", \"lang\": \"python\"}, {\"code\": \"// 策略引用该模板以后直接用 ext::Test() 调用此函数\\n// 供策略调用的函数必须声明为 pub\\npub fn Test() {\\n Log!(\\\"template call\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"不同编程语言的模板类库编写格式有所不同，以下是导出函数在模板类库中声明和实现的示例代码：\"}], \"title\": \"模板类库的导出函数\"}, {\"_src_hash\": \"123424e83b6b02d03d01324f5aa445a91f230841a2a8de8b94d94f3e6d5cf678\", \"desc\": \"模板类库可以设置自己的界面参数，这些参数在模板类库代码中以全局变量的形式使用。\\n\\n例如，我们设置了一个模板类库的参数：\\n\\n\\n![模板参数](/upload/asset/1778f550b85e6a1cac08e.png)\\n\\n\\n| 策略代码中参数的变量名 | 策略界面上显示的参数名称 | 类型 | 默认值 |\\n| - | - | - | - |\\n| param1 | 模板参数1 | 数字型（number） | 99 |\", \"examples\": [{\"examples\": [{\"code\": \"$.SetParam1 = function(p1) {\\n param1 = p1\\n}\\n\\n$.GetParam1 = function() {\\n Log(\\\"param1:\\\", param1)\\n return param1\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def SetParam1(p1):\\n global param1\\n param1 = p1\\n\\ndef GetParam1():\\n Log(\\\"param1:\\\", param1)\\n return param1\\n\\next.SetParam1 = SetParam1\\next.GetParam1 = GetParam1\", \"lang\": \"python\"}], \"value\": \"用于测试```param1```参数的模板类库代码：\"}, {\"examples\": [{\"code\": \"function main () {\\n Log(\\\"调用$.GetParam1:\\\", $.GetParam1())\\n Log(\\\"调用$.SetParam1:\\\", \\\"#FF0000\\\")\\n $.SetParam1(20)\\n Log(\\\"调用$.GetParam1:\\\", $.GetParam1())\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"调用ext.GetParam1:\\\", ext.GetParam1())\\n Log(\\\"调用ext.SetParam1:\\\", \\\"#FF0000\\\")\\n ext.SetParam1(20)\\n Log(\\\"调用ext.GetParam1:\\\", ext.GetParam1())\", \"lang\": \"python\"}], \"value\": \"引用上述模板类库示例的策略代码，使用模板类库的导出函数获取参数```param1```并修改参数```param1```。\"}], \"title\": \"模板类库的参数\"}, {\"_src_hash\": \"600a8c372ea4ba976ce28f563fe4a60cf7b2c388d124ba6e2961079ff259093d\", \"desc\": \"策略引用模板类库时，需要当前登录的优宽量化交易平台账号的策略库中有可用的模板类库。在[策略编辑页面](https://www.youquant.com/m/add-strategy)的模板栏中勾选需要引用的模板，保存策略后即可完成引用。\\n\\n![模板引用截图](/upload/asset/177aae7afb670c730ea17.png)\", \"title\": \"引用模板类库\"}], \"desc\": \"优宽量化交易平台中可复用的代码模块，属于策略代码的一种类别。优宽量化交易平台支持模板类库功能的编程语言包括：```JavaScript```、```Python```、```Rust```。创建策略时，如果将类别设置为模板类库，系统会在当前登录账号的策略库中创建一个模板类库。创建完成后，该类别无法再修改为普通策略。\\n\\n![创建模板类库页面](/upload/asset/17705260976fb49af4a33.png)\", \"title\": \"模板类库\"}, {\"_src_hash\": \"2cec725d45c14d28853e4079ea91bf1fc754f9d1a37c891a9050fcd55e976f89\", \"children\": [{\"_src_hash\": \"a16ed3727da26df5fd91209f6688b81c381586456c98943efb2bb3d173c492cd\", \"desc\": \"| 变量（命名举例） | 描述 | 类型 | 默认值（说明） | 组件配置（说明） | 备注 |\\n| - | - | - | - | - | - |\\n| pNum | 参数pNum的描述 | 数字型（number） | 举例：设置默认值为100 | 用于设置当前参数绑定的界面控件：组件类型、最小值、最大值、分组、过滤器等 | 参数pNum的备注，pNum的值为数值类型 |\\n| pBool | 参数pBool的描述 | 布尔型（true/false） | 使用开关控件设置默认值，不具备选填控件 | 同上 | 参数pBool的备注，pBool的值为布尔类型 |\\n| pStr | 参数pStr的描述 | 字符串（string） | 举例：设置默认值为abc | 同上 | 参数pStr的备注，pStr的值为字符串类型 |\\n| pCombox | 参数pCombox的描述 | 下拉框（selected） | 设置选项中的某一个或多个选项 | 同上 | 参数pCombox的备注，pCombox的值可能有多种形式 |\\n| pSecretStr | 参数pSecretStr的描述 | 加密串（string） | 举例：设置默认值为xyz | 同上 | 参数pSecretStr的备注，pSecretStr的值为字符串类型 |\\n\\n界面参数在策略编辑页面代码编辑区下方的策略参数区进行设置，需要注意以下几点：\\n1、参数设置的默认值选项中，「选填」控件默认为选填状态，可以更改该控件的状态，将当前参数设置为必填。设置参数默认值为必填后，如果策略在回测或实盘时未设置该参数，则无法进行回测或启动实盘。\\n2、界面参数在策略代码中的变量名不应设置为当前编程语言的保留字（关键字）。\\n3、在回测或实盘界面，将鼠标悬停在参数绑定的控件上时，会显示设置的参数备注信息。\\n4、参数的「描述」即为参数绑定控件的显示名称。\\n5、参数的「变量」即上表中的：```pNum```、```pBool```、```pStr```、```pCombox```、```pSecretStr```。在策略代码中以全局变量形式存在，因此可以在代码中修改策略参数。\\n6、对于「加密串」和「字符串」类型的参数，输入默认值时无需添加引号，所有输入均作为字符串处理。「加密串」参数的使用方式与「字符串」参数相同，加密字符串会被加密传输，不会以明文形式发送。\\n7、「字符串」类型的参数如果设置为「选填」，当参数绑定的控件中未填写参数时，参数变量的值为**空字符串**；\\n 同理，「数字型」参数的值为**空值**；\\n 同理，「下拉框」参数的值为**空值**；\\n 同理，「加密串」参数的值为**空值**。\\n8、对于下拉框类型的界面参数，例如变量名为```pCombox```。在「组件配置」中未开启「支持多选」时，pCombox的值为当前选中选项的索引或具体数据（给选项绑定数据时）。\\n 如果开启了「支持多选」，pCombox的值为一个数组，包含所有当前选中选项的索引或具体数据（给选项绑定数据时）。\", \"title\": \"界面参数种类\"}, {\"_src_hash\": \"5058974916be57a07d89969a9544962fb5d24347fb84c0b5ecd16fdf72b46959\", \"alias\": \"组件配置\", \"desc\": \"策略界面参数的「组件配置」选项用于设置平台上5种参数类型对应的控件，增强功能并简化设计。\\n\\n5种界面参数支持的组件类型：\\n- 数字型（number）参数\\n 支持的组件类型：输入框控件（默认）、时间选择器控件、滑动输入条控件。\\n- 布尔型（true/false）参数\\n 仅支持开关控件（默认）。\\n- 字符串（string）参数\\n 支持的组件类型：输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、交易代码。\\n- 下拉框（selected）参数\\n 支持的组件类型：下拉框控件（默认）、分段控制器控件、交易代码。\\n- 加密串（string）参数\\n 仅支持加密输入框控件（默认）。\\n\\n除了设置界面参数对应的控件类型外，还可以设置界面参数的分组和过滤。\\n- 分组\\n 在组件配置的「分组」输入框中，可以输入一个标签名称，将若干个策略界面参数划分到同一个分组标签中（替代平台旧功能「策略分组」）。\\n- 过滤器\\n 在组件配置的「过滤器」输入框中，可以输入过滤判定的表达式，控制界面参数是否生效（替代平台旧功能「参数依赖」）。\\n 过滤器默认为空，不进行任何参数条件过滤；可以设置：```a > b```、```a == 1```、```a```、```!a```、```a >= 1 && a <= 10```、```a > b```等。当过滤器条件为真时，当前参数可用。\\n - 当某个参数设置了过滤器：```a == 1```时，该参数的可用性依赖于参数```a```的取值。当参数```a```等于1时该参数可用，否则该参数不可用。\\n - 当某个参数设置了过滤器：```a >= 1 && a <= 10```时，表示过滤条件为：a大于等于1且a小于等于10。符合此条件时参数可用，否则参数不可用。\\n - 当某个参数设置了过滤器：```!a```时，表示过滤条件为：非a；a可以是布尔值，也可以是数值（!0表示真值）。\", \"title\": \"参数组件配置\"}, {\"_src_hash\": \"f597b5741c3ff1e21232637b6ae425c891951770cbbef92b0a049101375139e8\", \"desc\": \"- 回测系统中的参数保存\\n 在回测时，如果希望保存策略参数，可以在修改策略参数后点击「保存回测设置」按钮，具体可参考回测系统{@回测系统/保存回测设置「保存回测设置」}。\\n\\n | 变量 | 描述 | 类型 | 默认值 |\\n | - | - | - | - |\\n |number |数值类型 |数字型（number） |1 |\\n |string |字符串 |字符串（string） |Hello youquant |\\n |combox |下拉框 |下拉框（selected） |1\\\\|2\\\\|3|\\n |bool |布尔值 |布尔型（true/false） |true |\\n |numberA@isShowA |数值A |数字型（number） |2 |\\n |isShowA |是否显示 numberA 参数 |布尔型（true/false） |false |\\n\\n 设置完成后，策略参数将以代码形式保存在策略中，例如：\\n\\n ```javascript\\n /*backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello youquant\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n */\\n ```\\n\\n ```python\\n '''backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello youquant\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n '''\\n ```\\n\\n ```rust\\n /*backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello youquant\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n */\\n ```\\n- 实盘参数导入导出\\n 运行实盘时，如需保存实盘配置的参数数据，可以在策略实盘页面点击「参数设置」选项，再点击「导出参数」按钮，导出的策略参数将以```json```文件保存。\\n 导出的策略参数配置也可以再次导入实盘，点击「导入参数」按钮即可将已保存的策略实盘参数导入到当前实盘，导入后点击「更新参数」按钮即可保存生效。\", \"title\": \"保存参数设置\"}], \"desc\": \"策略界面上设置的策略参数在策略代码中以全局变量形式体现。```JavaScript```语言、```My语言```策略代码中可以直接访问策略界面上设置的参数数值或修改参数。```Python```策略的函数中修改全局变量、策略界面参数时需要使用```global```关键字。```PINE```语言使用```input()```函数创建界面参数。\\n\\n![策略参数设置界面](/upload/asset/17865cf1878f57595ddea.png)\", \"title\": \"策略参数\"}, {\"_src_hash\": \"1be244f34a05852c02621d9fdf67c4f517aa4f54e4fb9d43248db87511abd0ac\", \"children\": [{\"_src_hash\": \"cda49ae6409a89c0979d20ed266d28d6ae63ae064e8af3fc5bfcecfaa3b572d7\", \"desc\": \"| 变量（命名举例） | 描述 | 类型 | 默认值（说明） | 组件配置（说明） | 备注 |\\n| - | - | - | - | - | - |\\n| cmdNum | 交互控件cmdNum的描述 | 数字型（number） | 默认值选填，可留空 | 用于设置当前交互项绑定的界面控件：组件类型、最小值、最大值、分组等 | 交互控件cmdNum的备注 |\\n| cmdBool | 交互控件cmdBool的描述 | 布尔型（true/false） | 默认值必填，开启或关闭 | 同上 | 交互控件cmdBool的备注 |\\n| cmdStr | 交互控件cmdStr的描述 | 字符串（string） | 默认值选填，可留空 | 同上 | 交互控件cmdStr的备注 |\\n| cmdCombox | 交互控件cmdCombox的描述 | 下拉框（selected） | 默认值选填，可留空 | 同上 | 交互控件cmdCombox的备注 |\\n| cmdBtn | 交互控件cmdBtn的描述 | 按钮（button） | 按钮控件不绑定输入项 | 同上 | 交互控件cmdBtn的备注 |\\n\\n交互控件触发后发送给策略的消息（字符串）：\\n- 数字型\\n 在交互控件```cmdNum```的输入框中输入交互数据：```123```后，点击交互控件cmdNum的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdNum:123```。\\n- 布尔型\\n 在交互控件```cmdBool```的开关控件上设置为打开，点击交互控件cmdBool的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdBool:true```。\\n- 字符串\\n 在交互控件```cmdStr```的输入框中输入交互数据：```abc```后，点击交互控件cmdStr的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdStr:abc```。\\n- 下拉框\\n 在交互控件```cmdCombox```的下拉框中选中第二个选项后，点击交互控件cmdCombox的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdCombox:1```，其中1表示选中选项的索引，第一个选项索引为0，第二个选项索引为1。\\n- 按钮\\n 点击交互控件```cmdBtn```的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdBtn```。\\n\\n交互控件的应用：动态修改策略参数\\n例如，策略有一个参数为symbol，在策略界面上添加的策略参数也是全局变量，因此这里使用代码中的全局变量作为演示。\\n\\n```javascript\\n// 策略参数\\nvar symbol = \\\"rb888\\\"\\n\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n var arr = cmd.split(\\\":\\\")\\n if (arr.length == 2 && arr[0] == \\\"changeSymbol\\\") {\\n // 检测到 changeSymbol 控件触发，就会执行参数更新操作\\n Log(\\\"修改symbol参数为：\\\", arr[1])\\n symbol = arr[1]\\n }\\n }\\n\\n LogStatus(_D(), \\\"，当前的symbol参数值为：\\\", symbol)\\n Sleep(3000)\\n }\\n}\\n```\\n\\n设置交互控件：\\n\\n/upload/asset/1779c77f3bf7059d3c179.png\", \"title\": \"交互控件种类\"}, {\"_src_hash\": \"578fc5904af240c776f09ca84067f08b397a718644ee9802d7d68887eac99922\", \"alias\": \"组件配置\", \"desc\": \"策略交互控件的「组件配置」选项用于设置平台上5种交互控件类型对应的控件，增强功能并简化设计。\\n\\n5种交互控件支持的组件类型：\\n- 数字型（number）交互控件\\n 支持的组件类型：输入框控件（默认）、时间选择器控件、滑动输入条控件。\\n- 布尔型（true/false）交互控件\\n 仅支持开关控件（默认）。\\n- 字符串（string）交互控件\\n 支持的组件类型：输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、交易代码选择器。\\n- 下拉框（selected）交互控件\\n 支持的组件类型：下拉框控件（默认）、分段控制器控件、交易代码选择器。\\n- 按钮（button）交互控件\\n 仅支持按钮控件（默认），无输入项控件。\\n\\n交互控件与界面参数设置相同，均可进行分组。组件配置中提供了分组设置功能。\\n- 分组\\n 在组件配置的「分组」输入框中，可以输入标签名称，将多个策略交互控件划分到同一分组标签下（此功能替代平台原有的「交互控件分组」功能）。\", \"title\": \"交互控件组件配置\"}, {\"_src_hash\": \"5840f17a025943915a0014ef4df43773e2bddafc489ecc81896ffef7d5e6e817\", \"desc\": \"除了在「策略交互」栏中设计交互控件，还可以在策略状态栏中设计交互控件。目前支持的交互控件类型仅有按钮，可以参考{@fun/Log/LogStatus 「语法手册」中LogStatus函数章节}。\\n\\n状态栏中的按钮控件可以分为：\\n- 普通按钮控件\\n 数据结构示例：\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"按钮1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"这是第一个按钮\\\"}\\n ```\\n- 带单个输入数据的按钮控件\\n 使用```input```属性设置输入控件选项，数据结构示例：\\n\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"按钮2\\\", \\\"cmd\\\": \\\"button2\\\", \\\"description\\\": \\\"这是第二个按钮\\\", \\\"input\\\": {\\\"name\\\": \\\"开仓数量\\\", \\\"type\\\": \\\"number\\\", \\\"defValue\\\": 1}}\\n ```\\n\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"test1\\\",\\n \\\"name\\\": \\\"test1\\\",\\n \\\"input\\\": {\\n \\\"type\\\": \\\"selected\\\",\\n \\\"name\\\": \\\"selected\\\",\\n \\\"label\\\": \\\"下拉框\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": 100,\\n \\\"settings\\\": {\\n \\\"multiple\\\": true,\\n \\\"customizable\\\": true,\\n \\\"options\\\":[{\\\"name\\\": \\\"A\\\", \\\"value\\\": 100}, {\\\"name\\\": \\\"B\\\", \\\"value\\\": 200}]\\n }\\n },\\n }\\n ```\\n- 带一组输入数据的按钮控件\\n 使用```group```属性设置一组输入控件的选项，数据结构示例：\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"open\\\",\\n \\\"name\\\": \\\"开仓\\\",\\n \\\"group\\\": [\\n {\\\"name\\\": \\\"orderType\\\", \\\"description\\\": \\\"下单方式|order type\\\", \\\"type\\\": \\\"selected\\\", \\\"defValue\\\": \\\"市价单|挂单\\\"},\\n {\\\"name\\\": \\\"tradePrice@orderType==1\\\", \\\"description\\\": \\\"交易价格|trade price\\\", \\\"type\\\": \\\"number\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"orderAmount\\\", \\\"description\\\": \\\"委托数量|order amount\\\", \\\"type\\\": \\\"string\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"boolean\\\", \\\"description\\\": \\\"是/否|boolean\\\", \\\"type\\\": \\\"boolean\\\", \\\"defValue\\\": true}\\n ]\\n }\\n ```\\n\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"test2\\\",\\n \\\"name\\\": \\\"test2\\\",\\n \\\"group\\\": [{\\n \\\"type\\\": \\\"selected\\\",\\n \\\"name\\\": \\\"selected\\\",\\n \\\"label\\\": \\\"下拉框\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": 200,\\n \\\"group\\\": \\\"group1\\\",\\n \\\"settings\\\": {\\n \\\"multiple\\\": true,\\n \\\"options\\\":[{\\\"name\\\": \\\"A\\\", \\\"value\\\": 100}, {\\\"name\\\": \\\"B\\\", \\\"value\\\": 200}]\\n }\\n }, {\\n \\\"type\\\": \\\"string\\\",\\n \\\"name\\\": \\\"string\\\",\\n \\\"label\\\": \\\"输入框\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": \\\"ABC\\\",\\n \\\"group\\\": \\\"group1\\\"\\n }],\\n }\\n ```\\n\\n将这些按钮控件JSON数据编码为JSON字符串，然后使用``` ` ```字符包裹，在状态栏输出。以JavaScript语言为例：\\n\\n```javascript\\nfunction main() {\\n var btn = {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"按钮1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"这是第一个按钮\\\"}\\n LogStatus(\\\"`\\\" + JSON.stringify(btn) + \\\"`\\\")\\n}\\n```\\n\\n这些按钮控件也可以写入状态栏表格中，详细示例请查看{@fun/Log/LogStatus 语法手册}。\\n\\n```input```字段结构与```group```字段中单个控件结构一致，以下为详细说明：\\n\\n```desc\\n{\\n \\\"type\\\": \\\"selected\\\", // 控件类型（必需字段），支持设置为：number, string, selected, boolean\\n \\\"name\\\": \\\"test\\\", // 名称（在group中使用时为必需字段）\\n \\\"label\\\": \\\"topic\\\", // 标题（必需字段）\\n \\\"description\\\": \\\"desc\\\", // 组件的提示信息\\n \\\"default\\\": 1, // 默认值；当前JSON结构中如果不设置settings字段，兼容defValue，可以用defValue代替default\\n \\\"filter\\\": \\\"a>1\\\", // 选择器，不设置该字段表示不过滤（显示控件）；设置该字段时，当表达式为真时不过滤（显示控件），当表达式为假时过滤（不显示控件）\\n // 对于选择器，以当前示例中表达式a>1为例，a指的是type=button的结构中group字段下name为a的控件值，根据此数值判断是否过滤\\n \\\"group\\\": \\\"group1\\\", // 分组\\n \\\"settings\\\": { ... }, // 组件配置\\n}\\n```\\n\\n组件配置```settings```各字段详细说明：\\n- ```settings.required```：是否必填。\\n- ```settings.disabled```：是否禁用。\\n- ```settings.min```：```type=number```时有效，表示最小值或字符串最小长度。\\n- ```settings.max```：```type=number```时有效，表示最大值或字符串最大长度。\\n- ```settings.step```：```type=number```，```render=slider```时有效，表示步长。\\n- ```settings.multiple```：```type=selected```时有效，表示支持多选。\\n- ```settings.customizable```：```type=selected```时有效，表示支持自定义；用户可以直接在下拉框控件中编辑添加新选项，如果选中新编辑的选项，在触发交互时使用该选项的名称而不是选项代表的值。\\n- ```settings.options```：```type=selected```时有效，表示选择器的选项数据格式：```[\\\"选项1\\\"，\\\"选项2\\\"]```、```[{'name':'xxx','value':0}, {'name':'xxx','value':1}]```。\\n- ```settings.render```：渲染组件类型。\\n ```type=number```时，```settings.render```不设置（默认数字输入框），可选：```slider```（滑动条）、```date```（时间选择器返回时间戳）。\\n ```type=string```时，```settings.render```不设置（默认单行输入框），可选：```textarea```（多行输入）、```date```（时间选择器返回yyyy-MM-dd hh:mm:ss）、```color```（颜色选择器返回#FF00FF）。\\n ```type=selected```时，```settings.render```不设置（默认下拉框），可选：```segment```（分段选择器）。\\n ```type=boolean```时，目前只有默认复选框。\\n\\n支持双语设置，例如：```'选项｜options'```文本内容会根据当前语言环境适配；以```group```字段中单个控件为例，完整示例：\\n\\n```json\\n{\\n type:'selected',\\n name:'test',\\n label:'选项｜options',\\n description:'描述｜description',\\n default:0, // 这里default默认值设置为0，表示{name:'xxx|yyy',value:0}选项中的value值\\n filter:'a>1&&a<10',\\n group:'分组|group',\\n settings:{\\n multiple:true,\\n customizable:true,\\n options:[{name:'xxx|yyy',value:0}]\\n }\\n}\\n```\\n\\n### 状态栏展示组件\\n\\n除了文字、表格和按钮，{@fun/Log/LogStatus LogStatus}还可以直接传带 `type` 的对象，状态栏按类型显示成组件：`grid`、`tabs` 负责布局，`kpi`（指标卡）、`stat`（键值列表）、`chart`（折线、柱状、面积图）、`sparkline`、`gauge`、`progress`、`pie`、`histogram`、`heatmap`、`calendar`、`timeline`、`markdown`、`alert`、`badge` 负责展示。组件只用于展示，可以和按钮、表格放进同一个 `grid`：\\n\\n```javascript\\nfunction main() {\\n while (!exchange.IO(\\\"status\\\")) Sleep(1000)\\n exchange.SetContractType(\\\"rb888\\\")\\n var btn = {type: \\\"button\\\", name: \\\"平仓|Close\\\", cmd: \\\"close\\\"}\\n while (true) {\\n var ticker = exchange.GetTicker()\\n if (ticker) {\\n LogStatus({type: \\\"grid\\\", cols: 2, items: [\\n {type: \\\"kpi\\\", title: \\\"最新价\\\", value: ticker.Last},\\n btn // 按钮放进 grid 时不用加反引号\\n ]})\\n }\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(\\\"收到命令：\\\", cmd)\\n }\\n Sleep(1000)\\n }\\n}\\n```\\n\\n各组件的字段与三种语言的示例见{@struct/OtherStruct/LogStatus-display 状态栏组件}，直接传对象、反引号、多个参数的输入写法见{@fun/Log/LogStatus LogStatus}。\", \"title\": \"状态栏中的交互控件\"}], \"desc\": \"```JavaScript```、```Python```、```Rust```、My语言策略均可设计交互控件。策略的交互控件用于在策略实盘运行时向运行中的策略程序发送交互指令。对于```JavaScript```、```Python```、```Rust```语言类型的策略，可在策略代码中使用{@fun/Global/GetCommand GetCommand()}函数获取交互控件产生的消息。\\n\\n\\n![交互控件](/upload/asset/177160d0cc33c15eb935d.png)\\n\\n\\n在策略中编写好处理交互控件消息的代码后，实盘运行时即可通过交互控件实现（不限于）以下功能：\\n\\n- 手动平掉策略持仓。\\n\\n- 动态修改策略参数，无需重启策略实盘。\\n\\n- 切换策略逻辑。\\n\\n- 触发打印调试信息或数据，用于测试特定功能。\", \"title\": \"交互控件\"}, {\"_src_hash\": \"356785784aaad8eedd305a0a4d46b5cd8a63fd0fbde1397e689de3dedc5f9bde\", \"children\": [], \"desc\": \"关于传统商品期货API的更多信息，需要注意：策略程序启动运行时，需先确保与期货公司前置机服务器连接成功（账号登录验证是否成功，可通过```exchange.IO(\\\"status\\\")```函数调用时的返回值进行判断），之后才可以调用行情、交易等接口与期货公司前置机服务器进行通信。\\n\\n参考：{@fun/Trade/exchange.IO exchange.IO(...)函数}\\n```javascript\\nfunction main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n LogStatus(\\\"正在等待与交易服务器连接, \\\" + new Date())\\n Sleep(1000)\\n }\\n\\n exchange.GetAccount()\\n}\\n```\\n\\n```python\\ndef main():\\n while not exchange.IO(\\\"status\\\"):\\n LogStatus(\\\"正在等待与交易服务器连接, \\\" + _D())\\n Sleep(1000)\\n\\n exchange.GetAccount()\\n```\\n\\n```rust\\nfn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n LogStatus!(\\\"正在等待与交易服务器连接,\\\", _D(None));\\n Sleep(1000);\\n }\\n\\n exchange.GetAccount().unwrap();\\n}\\n```\\n\\n- 期货交易中```exchange.Buy(Price, Amount)```、```exchange.Sell(Price, Amount)```、```exchange.CancelOrder(Id)```与现货交易的区别：\\n 在调用```exchange.Buy(Price, Amount)```或```exchange.Sell(Price, Amount)```之前，需要先调用```exchange.SetDirection(Direction)```以明确下单方向。\\n\\n ```javascript\\n function main() {\\n while (!exchange.IO(\\\"status\\\")) {\\n LogStatus(\\\"正在等待与交易服务器连接, \\\" + new Date())\\n Sleep(1000)\\n }\\n\\n // 设置合约\\n exchange.SetContractType(\\\"MA888\\\")\\n // 设置为开空头仓位，调用exchange.Sell(...)函数下单开空头仓位\\n exchange.SetDirection(\\\"sell\\\")\\n var id = exchange.Sell(1000, 2)\\n exchange.CancelOrder(id)\\n }\\n ```\\n\\n ```python\\n def main():\\n while not exchange.IO(\\\"status\\\"):\\n LogStatus(\\\"正在等待与交易服务器连接, \\\" + _D())\\n Sleep(1000)\\n exchange.SetContractType(\\\"MA888\\\")\\n exchange.SetDirection(\\\"sell\\\")\\n id = exchange.Sell(1000, 2)\\n exchange.CancelOrder(id)\\n ```\\n\\n ```rust\\n fn main() {\\n while !exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n LogStatus!(\\\"正在等待与交易服务器连接,\\\", _D(None));\\n Sleep(1000);\\n }\\n\\n // 设置合约\\n exchange.SetContractType(\\\"MA888\\\").unwrap();\\n // 设置为开空头仓位，调用exchange.Sell(...)函数下单开空头仓位\\n exchange.SetDirection(\\\"sell\\\").unwrap();\\n let id = exchange.Sell(1000, 2).unwrap();\\n exchange.CancelOrder(&id).unwrap();\\n }\\n ```\\n\\n- 商品期货支持自定义订单类型（支持实盘，回测暂不支持）。\\n 通过后缀方式指定，附加在`_`之后，例如：\\n\\n CTP协议：\\n ```exchange.SetDirection(\\\"buy_ioc\\\")```\\n 交易所暂不支持此类型：```exchange.SetDirection(\\\"sell_gtd-20170111\\\")```。\\n\\n CTP协议：\\n |后缀|意义|对应CTP原始值|\\n |-|-|-|\\n |ioc|立即完成，否则撤销|THOST_FTDC_TC_IOC|\\n |gfs|本节有效|THOST_FTDC_TC_GFS|\\n |gfd|当日有效|THOST_FTDC_TC_GFD|\\n |gtd|指定日期前有效|THOST_FTDC_TC_GTD|\\n |gtc|撤销前有效|THOST_FTDC_TC_GTC|\\n |gfa|集合竞价有效|THOST_FTDC_TC_GFA|\\n |fak|部分成交，撤销剩余部分|THOST_FTDC_TC_IOC|\\n |fok|未能完全成交，全部撤销|THOST_FTDC_TC_IOC|\\n\\n 易盛协议：\\n |后缀|意义|对应易盛协议原始值|\\n |-|-|-|\\n |gfd|当日有效|TAPI_ORDER_TIMEINFORCE_GFD|\\n |gtc|撤销前有效|TAPI_ORDER_TIMEINFORCE_GTC|\\n |gtd|指定日期前有效|TAPI_ORDER_TIMEINFORCE_GTD|\\n |fak|部分成交，撤销剩余部分|TAPI_ORDER_TIMEINFORCE_FAK|\\n |ioc|立即完成，否则撤销|TAPI_ORDER_TIMEINFORCE_FAK|\\n |fok|未能完全成交，全部撤销|TAPI_ORDER_TIMEINFORCE_FOK|\\n\\n- 易盛协议\\n - 部分接口调用时立即返回\\n 执行```exchange.GetOrder(id)```、```exchange.GetOrders()```、```exchange.GetPositions()```、```exchange.GetAccount()```接口时会立即返回。当交易所对象配置为易盛协议时，这些接口均为立即返回，数据由本地维护，并由期货公司前置机推送更新，不会阻塞。\\n\\n- Futures_OP报错\\n 期货交易所对象相关的报错信息说明如下表所示：\\n\\n |值|错误函数显示|触发函数|描述|\\n |-|-|-|-|\\n |0|Futures_OP 0|exchange.SetMarginLevel|调用杠杆函数时报错。商品期货不支持SetMarginLevel函数，因此不会触发Futures_OP 0错误|\\n |1|Futures_OP 1|exchange.SetDirection|设置期货交易方向函数时报错|\\n |2|Futures_OP 2|exchange.SetContractType|设置合约函数时报错|\\n |3|Futures_OP 3|exchange.GetPositions|获取持仓函数时报错|\\n |4|Futures_OP 4|exchange.IO|调用IO函数时报错|\", \"title\": \"商品期货\"}, {\"_src_hash\": \"ba1006fd7aeeecdb82d72084912f8e8a1b8f32aeb75cb76b1ee8eb8fd3f64f50\", \"children\": [{\"_src_hash\": \"975c394ce86597b1854ea1274a05f1d94e07a0f8a174ccaf44a4976e8bdce049\", \"desc\": \"需要期货公司开通相关权限。期权合约的代码形式，例如铁矿石期权：```i2106-P-760```。\\n\\n商品期货期权合约基本格式：\\n> 标的期货合约 + 看涨/看跌 + 行权价\\n\\n由于交易所的标准合约命名规则各不相同，且对大小写敏感，各交易所合约格式可能存在差异，以下是各交易所对应的具体合约格式：\\n> 上期所：小写 + 四位数字 + C（或P） + 行权价\\n> 郑商所：大写 + 三位数字 + C（或P） + 行权价\\n> 中金所：大写 + 四位数字 + -C-（或-P-） + 行权价\\n> 大商所：小写 + 四位数字 + -C-（或-P-） + 行权价\\n\\n交易所期权合约代码示例：\\n\\n|交易所|合约名称|看涨期权|看跌期权|看涨期权示例|看跌期权示例|\\n|-|-|-|-|-|-|\\n| 中金所 | 沪深300 | IO合约月份-C-行权价格 | IO合约月份-P-行权价格 | IO2105-C-6400 | IO2105-P-6400 |\\n| 上期所 | 铜 | cu合约月份C行权价格 | cu合约月份P行权价格 | cu2106C69000 | cu2106P69000 |\\n| 上期所 | 黄金 | au合约月份C行权价格 | au合约月份P行权价格 | au2106C400 | au2106P400 |\\n| 上期所 | 铝 | al合约月份C行权价格 | al合约月份P行权价格 | al2106C20000 | al2106P20000 |\\n| 上期所 | 锌 | zn合约月份C行权价格 | zn合约月份P行权价格 | zn2106C23600 | zn2106P23600 |\\n| 上期所 | 橡胶 | ru合约月份C行权价格 | ru合约月份P行权价格 | ru2109C16000 | ru2109P16000 |\\n| 大商所 | 豆粕 | m合约月份-C-行权价格 | m合约月份-P-行权价格 | m2109-C-4000 | m2109-P-4000 |\\n| 大商所 | 玉米 | c合约月份-C-行权价格 | c合约月份-P-行权价格 | c2109-C-3000 | c2109-P-3000 |\\n| 大商所 | 铁矿 | i合约月份-C-行权价格 | i合约月份-P-行权价格 | i2109-C-1000 | i2109-P-1000 |\\n| 大商所 | 液化石油气 | pg合约月份-C-行权价格 | pg合约月份-P-行权价格 | pg2106-C-4000 | pg2106-P-4000 |\\n| 大商所 | PP | pp合约月份-C-行权价格 | pp合约月份-P-行权价格 | pp2109-C-9000 | pp2109-P-9000 |\\n| 大商所 | PVC | v合约月份-C-行权价格 | v合约月份-P-行权价格 | v2109-C-9000 | v2109-P-9000 |\\n| 大商所 | 塑料 | l合约月份-C-行权价格 | l合约月份-P-行权价格 | l2109-C-9000 | l2109-P-9000 |\\n| 郑商所 | 白糖 | SR合约月份C行权价格 | SR合约月份P行权价格 | SR109C5000 | SR109P5000 |\\n| 郑商所 | 棉花 | CF合约月份C行权价格 | CF合约月份P行权价格 | CF109C15000 | CF109P15000 |\\n| 郑商所 | PTA | TA合约月份C行权价格 | TA合约月份P行权价格 | TA109C5000 | TA109P5000 |\\n| 郑商所 | 甲醇 | MA合约月份C行权价格 | MA合约月份P行权价格 | MA109C2500 | MA109P2500 |\\n| 郑商所 | 菜粕 | RM合约月份C行权价格 | RM合约月份P行权价格 | RM109C3000 | RM109P3000 |\\n| 郑商所 | 动力煤 | ZC合约月份C行权价格 | ZC合约月份P行权价格 | ZC109C800 | ZC109P800 |\\n\\n查询期权合约代码的示例：\\n\\n```javascript\\nfunction main(){\\n var productsForFind = null\\n while(true){\\n if(exchange.IO(\\\"status\\\")){\\n LogStatus(_D(), \\\"已连接CTP！\\\")\\n var ret = exchange.IO(\\\"instruments\\\")\\n ret.forEach(function(product) {\\n // Log(product)\\n // 这里设置要查询的名称，i为铁矿石合约\\n if (product.InstrumentName.indexOf(\\\"i\\\") != -1 && (product.InstrumentName.indexOf(\\\"P\\\") != -1 || product.InstrumentName.indexOf(\\\"C\\\") != -1)) {\\n Log(product, \\\"#FF0000\\\")\\n productsForFind = product\\n }\\n })\\n break\\n } else {\\n LogStatus(_D(), \\\"未连接CTP！\\\")\\n }\\n Sleep(1000)\\n }\\n\\n Log(productsForFind, \\\"#FF0000\\\")\\n}\\n```\", \"title\": \"商品期货期权\"}], \"desc\": \"优宽量化交易平台支持商品期货期权交易。\", \"title\": \"期权交易\"}, {\"_src_hash\": \"6dd97fa9923374c3975bf74db0edc0249c6f3da9804f983a505b5a4fc18f9aa4\", \"children\": [{\"_src_hash\": \"268af763f6a2315a9690d5ef2c28cea940c45e5c27dafe3d9a5351cabcfe5a09\", \"desc\": \"[支持中泰证券(XTP)](https://xtp.zts.com.cn/)。\", \"title\": \"中泰证券\"}, {\"_src_hash\": \"d36fd1521fd5b110c7247877e72b3d91eed9fa3fcfca95ceabb96e8d82686e48\", \"desc\": \"支持富途牛牛的实盘交易与模拟交易，需下载```FutuOpenD```软件。使用```FutuOpenD```接入模拟交易时，部分股票代码不受支持，因此无法交易；但富途牛牛手机APP可以进行模拟交易。在优宽量化上配置交易所对象、运行```FutuOpenD```软件等操作，请参阅[富途证券配置说明文档](https://www.youquant.com/bbs-topic/6270)。\\n\\n- 接口调用频率\\n ```GetOrder```、```GetOrders```、```GetPositions```、```GetAccount```等函数默认使用缓存数据，因此不限制调用频率。当有新数据时，```FutuOpenD```会自动更新数据，缓存数据也会同步更新。\\n 调用```exchange.IO(\\\"refresh\\\", true)```函数可禁用缓存；禁用缓存后，调用频率限制为每30秒内最多请求10次查询，超过该频率限制将会报错。\\n- 股票代码\\n 例如：```600519.SH```。\\n - HK 港股\\n - US 美股\\n - SH 沪股\\n - SZ 深股\\n\\n 在策略代码中使用```exchange.SetContractType()```函数设置股票代码，例如：\\n\\n ```javascript\\n function main() {\\n var info = exchange.SetContractType(\\\"600519.SH\\\") // 设置为股票600519.SH即贵州茅台，账户即切换到大陆市场\\n Log(info)\\n Log(exchange.GetAccount()) // 当前设置的股票为贵州茅台，此时调用GetAccount函数获取账户资产，获取的为大陆市场账户资产\\n Log(exchange.GetTicker()) // 获取股票贵州茅台当前的价格信息\\n }\\n ```\\n\\n ```python\\n def main():\\n info = exchange.SetContractType(\\\"600519.SH\\\")\\n Log(info)\\n Log(exchange.GetAccount())\\n Log(exchange.GetTicker())\\n ```\\n\\n ```rust\\n fn main() {\\n let info = exchange.SetContractType(\\\"600519.SH\\\"); // 设置为股票600519.SH即贵州茅台，账户即切换到大陆市场\\n Log!(info);\\n Log!(exchange.GetAccount()); // 当前设置的股票为贵州茅台，此时调用GetAccount函数获取账户资产，获取的为大陆市场账户资产\\n Log!(exchange.GetTicker(None)); // 获取股票贵州茅台当前的价格信息\\n }\\n ```\\n\\n 设置交易方向的函数```exchange.SetDirection```、下单函数```exchange.Buy```/```exchange.Sell```、撤单函数```exchange.CancelOrder```、查询订单函数```exchange.GetOrder```等，其使用方法均与商品期货市场相同。\\n\\n- 账户信息数据格式\\n 使用```TrdMarket```定义市场，用以区分香港市场、美国市场与大陆市场。\\n 以下内容摘录自```Futu API```[文档](https://openapi.futunn.com/futu-api-doc/)：\\n\\n ```javascript\\n const (\\n TrdMarket_TrdMarket_Unknown TrdMarket = 0 //未知市场\\n TrdMarket_TrdMarket_HK TrdMarket = 1 //香港市场\\n TrdMarket_TrdMarket_US TrdMarket = 2 //美国市场\\n TrdMarket_TrdMarket_CN TrdMarket = 3 //大陆市场\\n TrdMarket_TrdMarket_HKCC TrdMarket = 4 //香港A股通市场\\n TrdMarket_TrdMarket_Futures TrdMarket = 5 //期货市场\\n )\\n ```\\n\\n 调用```exchange.GetAccount()```函数获取账户信息数据，返回：\\n\\n ```javascript\\n {\\n \\\"Info\\\": [{\\n \\\"Header\\\": {\\n ... // 省略\\n \\\"TrdMarket\\\": 1 // Info原始信息中，市场ID，表示该账户资产用于香港市场交易\\n },\\n \\\"Funds\\\": { // 账户在该市场的资产信息\\n ...\\n }\\n }, ...],\\n \\\"Balance\\\": 1000000, // 当前市场的资产数值\\n \\\"FrozenBalance\\\": 0\\n }\\n ```\\n\\n- FutuOpenD根据登录的IP地址区分所属地区\\n 使用非大陆IP地址登录的账户在获取行情数据时会受到一定限制，具体请查阅FutuOpenD（富途）官方文档。\", \"title\": \"富途证券\"}], \"desc\": \"支持中泰证券、富途证券。\", \"title\": \"股票证券\"}, {\"_src_hash\": \"1b497949f16cd3de522a0dade7a0497e37cd02b46954edd085bb4cfcc7712c31\", \"children\": [], \"desc\": \"1、使用```Rust```编写策略与使用```JavaScript```编写策略的区别，主要体现在平台API函数返回数据的形式上，例如```exchange.GetTicker()```函数：\\n- JavaScript\\n ```exchange.GetTicker()```调用成功时返回一个对象；若调用失败（如期货公司前置机故障、网络问题等），则返回```null```。\\n\\n ```javascript\\n function main() {\\n var ticker = exchange.GetTicker()\\n // 判断exchange.GetTicker函数是否调用失败（返回null）\\n if (ticker) {\\n Log(ticker)\\n }\\n }\\n ```\\n- Rust\\n 可能失败的API调用统一返回```Result```类型，可采用Rust惯用的方式处理错误：\\n\\n ```rust\\n fn main() {\\n // 方式一：使用模式匹配，判断exchange.GetTicker函数是否调用成功\\n if let Ok(ticker) = exchange.GetTicker(None) {\\n Log!(ticker);\\n }\\n\\n // 方式二：使用_C!宏自动重试，直至调用成功返回\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(ticker);\\n }\\n ```\\n 可选参数（例如```GetTicker```的```symbol```参数）在不传时使用```None```占位，需要传值时直接传入即可，例如```exchange.GetTicker(\\\"rb888\\\")```。\\n\\n2、策略入口与生命周期：Rust策略的入口为```fn main()```（与标准Rust程序的入口同名，但由平台调用，且无返回值）。与JavaScript一样，可以选择性地定义```fn init()```（在策略开始运行时首先自动执行）和```fn onexit()```（在策略退出时执行扫尾操作），引导层会自动调用；也可以在策略代码中调用```OnExit()```注册额外的退出钩子：\\n\\n```rust\\nfn main() {\\n // 策略逻辑...\\n}\\n\\nfn init() {\\n Log!(\\\"初始化\\\");\\n}\\n\\nfn onexit() {\\n Log!(\\\"策略退出，执行扫尾处理\\\");\\n}\\n```\\n\\n3、日志与全局功能以宏的形式提供：```Log!()```、```LogStatus!()```、```Panic!()```、```_G!()```、```_C!()```等均为Rust宏（注意末尾的感叹号）；而```LogProfit()```、```Sleep()```、```_D()```、```_N()```、```HttpQuery()```等则为普通函数。\\n\\n4、策略参数注入为全局常量：界面上配置的策略参数会按其值类型注入策略代码（number对应```f64```、boolean对应```bool```、string/密码对应```&str```、下拉框则按选项的值类型），可直接以参数名引用。若需用作整数，需自行转换，例如```let n = Period as usize;```。\\n\\n5、JSON数据处理：平台API返回的原始JSON文本（例如```exchange.IO()```的返回值、各结构体的```Info```字段）可使用内置的```JSONParse()```函数解析为```JsonValue```，并以```v[\\\"key\\\"]```、```v[0]```的形式进行索引导航，再通过```as_f64()```、```as_str()```、```as_bool()```等方法获取标量值。SDK未内置JSON序列化功能，如需构造JSON文本，可使用```format!```宏拼接，或引入第三方crate（如```serde_json```）。\\n\\n6、第三方crate与TLS注意事项：策略源码是唯一的代码文件，需在源码最顶部用```---```包裹的```[dependencies]``` frontmatter中声明依赖（详见「编程语言 - Rust」一节）。由于编译沙盒中没有系统OpenSSL，对于需要TLS的crate，请选择纯Rust实现的```rustls```，避免依赖```native-tls```/```openssl-sys```；WebSocket连接则优先使用内置的```Dial()```函数。\", \"title\": \"Rust策略编写说明\"}, {\"_src_hash\": \"391e2ce4ee56586b0dd1f2a0e53118eb049386a573f78f5a81b89ea1bab63746\", \"children\": [], \"desc\": \"由于```JavaScript```语言自身的限制（JavaScript语言内置字符串仅支持ASCII与UTF-16编码，为避免数据丢失），当遇到无法编码的字符串时将返回```ArrayBuffer```类型。优宽量化平台的所有API接口中，可以传入字符串参数的地方均支持传入```ArrayBuffer```类型。\\n\\n以下示例说明了这一特性：\\n```javascript\\nfunction stringToHex(str) {\\n let hex = '';\\n for (let i = 0; i < str.length; i++) {\\n const charCode = str.charCodeAt(i).toString(16);\\n hex += charCode.length === 1 ? '0' + charCode : charCode;\\n }\\n return hex;\\n}\\n\\nfunction main() {\\n const inputString = \\\"abc\\\\uD842\\\\uDFB7123\\\"; // 该\\\"\\\\uD842\\\\uDFB7\\\"字符的Unicode码点超出了16位范围\\n // const inputString = \\\"abcG123\\\"; // 如果使用abcG123字符串测试，则变量outputD不会被赋值为ArrayBuffer\\n\\n // 使用Encode函数将inputString编码为十六进制格式\\n const encodedHex = Encode(\\\"raw\\\", \\\"string\\\", \\\"hex\\\", inputString);\\n Log(encodedHex); // 内容为：61 62 63 f0a0aeb7 31 32 33\\n\\n // 使用自定义的stringToHex函数编码，由于无法正确处理\\\"\\\\uD842\\\\uDFB7\\\"字符，导致十六进制编码错误\\n const manuallyEncodedHex = stringToHex(inputString);\\n Log(manuallyEncodedHex); // 内容为：61 62 63 d842dfb7 31 32 33\\n\\n // 成功从十六进制编码还原为字符串（变量inputString）\\n const decodedString = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", encodedHex);\\n Log(decodedString);\\n\\n // 无法正确解码，返回ArrayBuffer类型，即变量outputD为ArrayBuffer\\n const outputD = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", manuallyEncodedHex);\\n Log(outputD);\\n\\n // 验证返回的ArrayBuffer类型变量outputD\\n const bufferD = new Uint8Array(outputD);\\n let hexBufferD = '';\\n for (let i = 0; i < bufferD.length; i++) {\\n hexBufferD += bufferD[i].toString(16).padStart(2, '0');\\n }\\n Log(hexBufferD); // 61 62 63 d842dfb7 31 32 33\\n}\\n```\", \"title\": \"JavaScript策略编写说明\"}, {\"_src_hash\": \"8b047eef7721169d0b35e5f5bb92fda17bf2aedbfe184f752b9428fc5abe2a2c\", \"children\": [{\"_src_hash\": \"864ca773933c3fc2fb6464fe14a0a688e69ba46ea9fd2eb82a8ca67bdfeb854c\", \"desc\": \"优宽量化的```TA```指标库优化了常用指标算法，支持```JavaScript```、```Python```、```Rust```语言的策略调用。\\n\\n[开源TA库代码](https://www.youquant.com/bbs-topic/8293)、语法手册的{@fun/TA TA}分类。\\n\\n```javascript\\nfunction main(){\\n // 由于这是测试代码，未采用商品期货策略的通用架构，此处仅通过 exchange.IO(\\\"status\\\") 函数判断是否成功连接期货公司前置机，连接成功后立即执行测试代码。股票、证券无需使用 exchange.IO(\\\"status\\\") 判断连接状态\\n while(true) {\\n if (exchange.IO(\\\"status\\\")) {\\n exchange.SetContractType(\\\"rb888\\\")\\n var records = exchange.GetRecords()\\n // K线需要有足够的长度才能计算指标数据\\n if (records && records.length > 100) {\\n break\\n }\\n }\\n Sleep(1000)\\n }\\n\\n var r = exchange.GetRecords()\\n var macd = TA.MACD(r)\\n var atr = TA.ATR(r, 14)\\n\\n // 打印最后一组指标值\\n Log(macd[0][r.length-1], macd[1][r.length-1], macd[2][r.length-1])\\n Log(atr[atr.length-1])\\n}\\n```\\n\\n```python\\n# Python 需要单独安装 talib 库\\n\\nimport talib\\n\\ndef main():\\n while True:\\n if exchange.IO(\\\"status\\\"):\\n exchange.SetContractType(\\\"rb888\\\")\\n records = exchange.GetRecords()\\n # records 为 None 或空数组 [] 时，判断结果均为假\\n if records and len(records) > 100:\\n break\\n Sleep(1000)\\n\\n r = exchange.GetRecords()\\n macd = TA.MACD(r)\\n atr = TA.ATR(r, 14)\\n Log(macd[0][-1], macd[1][-1], macd[2][-1])\\n Log(atr[-1])\\n```\\n\\n```rust\\nfn main() {\\n loop {\\n if exchange.IO(\\\"status\\\").is_ok_and(|v| v.as_i64() == Some(1)) {\\n let _ = exchange.SetContractType(\\\"rb888\\\");\\n if let Ok(records) = exchange.GetRecords(None, None, None) {\\n // K线需要有足够的长度才能计算指标数据\\n if records.len() > 100 {\\n break;\\n }\\n }\\n }\\n Sleep(1000);\\n }\\n\\n let r = exchange.GetRecords(None, None, None).unwrap();\\n let macd = TA.MACD(&r, None, None, None);\\n let atr = TA.ATR(&r, 14);\\n\\n // 打印最后一组指标值\\n Log!(macd[0][r.len() - 1], macd[1][r.len() - 1], macd[2][r.len() - 1]);\\n Log!(atr[atr.len() - 1]);\\n}\\n```\", \"title\": \"TA指标库\"}, {\"_src_hash\": \"f4e779f3774d45d42b9061a92767d3d42fe11a24522d491685af1d14a5c94862\", \"desc\": \"以下是```CCI```指标调用示例代码，更多talib指标函数请参阅语法手册的{@fun/Talib talib}分类。\\n\\n```javascript\\nfunction main() {\\n while(!exchange.IO(\\\"status\\\")) {\\n Sleep(1000)\\n }\\n exchange.SetContractType(\\\"rb888\\\")\\n\\n var records = exchange.GetRecords()\\n var cci = talib.CCI(records, 14)\\n Log(cci)\\n}\\n```\\n\\n```python\\nimport talib\\n\\ndef main():\\n while not exchange.IO(\\\"status\\\"):\\n Sleep(1000)\\n exchange.SetContractType(\\\"rb888\\\")\\n\\n records = exchange.GetRecords()\\n # 14这个参数可以省略\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\", \"title\": \"talib指标库\"}, {\"_src_hash\": \"8b2fdec3deb5442a4a97354a74a3856fb800470c5fc34dd3e45020b8212ddc30\", \"desc\": \"- http://ta-lib.org/\\n ```javascript\\n function main() {\\n // 由于是测试代码，未使用商品期货策略的通用架构，此处仅判断exchange.IO(\\\"status\\\")函数，确认连接期货公司前置机成功后立即执行测试代码。股票证券无需使用exchange.IO(\\\"status\\\")判断连接状态\\n while (true) {\\n if (exchange.IO(\\\"status\\\")) {\\n exchange.SetContractType(\\\"rb888\\\")\\n var records = exchange.GetRecords()\\n // K线数据需要足够的长度才能计算指标\\n if (records && records.length > 100) {\\n break\\n }\\n }\\n Sleep(1000)\\n }\\n\\n var r = exchange.GetRecords()\\n\\n // 打印所有指标数据，在优宽量化交易平台上，JavaScript语言策略已集成talib库\\n Log(talib.MACD(r))\\n Log(talib.MACD(r, 12, 26, 9))\\n }\\n ```\\n- 动态加载JavaScript库\\n 如需使用其他第三方JavaScript库，可通过以下方式动态加载：\\n ```javascript\\n function main() {\\n // via. https://cdnjs.com/libraries\\n eval(HttpQuery(\\\"https://cdnjs.cloudflare.com/ajax/libs/mathjs/13.2.0/math.min.js\\\"))\\n\\n Log(math.round(math.e, 3)) // 2.718\\n Log(math.atan2(3, -3) / math.pi) // 0.75\\n Log(math.log(10000, 10)) // 4\\n Log(math.sqrt(-4)) // {\\\"mathjs\\\":\\\"Complex\\\",\\\"re\\\":0,\\\"im\\\":2}\\n }\\n ```\", \"title\": \"JavaScript库\"}], \"desc\": \"优宽量化交易平台已内置集成了常用的第三方库。\", \"title\": \"内置库\"}, {\"_src_hash\": \"cfe693485aaa848d0623dff1be62bbd6e09eaa07761be47465fc51a459c5a8bc\", \"children\": [{\"_src_hash\": \"005dbd846afb72cf6fef1bdb404c6b93bfe0ced5d6d9038a33d7191b056c9568\", \"desc\": \"优宽量化交易平台支持扩展API接口的权限管理，可以设置```API KEY```的权限。在平台[账号设置](https://www.youquant.com/m/account)页面的「API接口」选项中，点击「创建新的ApiKey」按钮即可创建扩展```API KEY```。\\n\\n在创建```API KEY```时，可以编辑「API权限」输入框，输入```*```符号以开启所有**扩展API接口**权限。如需指定具体接口权限，请输入对应的扩展API函数名，使用英文逗号分隔，例如：```GetRobotDetail,DeleteRobot```。这将赋予该```API KEY```调用**获取实盘详细信息**接口和**删除实盘**接口的权限。在```API KEY```管理页面，您还可以对已创建的```API KEY```进行**修改**、**禁用**、**删除**等操作。\", \"title\": \"创建ApiKey\"}, {\"_src_hash\": \"c8865197d3fd42198b695aba82b4a2be2a7b7d9c4c123ab249926a007870d0b8\", \"desc\": \"扩展API接口返回的数据结构示例如下：\\n```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n // 省略 ...\\n }\\n}\\n```\\n\\n其中 ```code``` 字段表示扩展API接口的返回状态码。\\n\\n| 描述 | 代码 |\\n| - | - |\\n| 执行成功 | 0 |\\n| 错误的API KEY | 1 |\\n| 错误的签名 | 2 |\\n| Nonce错误 | 3 |\\n| 方法不正确 | 4 |\\n| 参数不正确 | 5 |\\n| 内部未知错误 | 6 |\", \"title\": \"扩展API接口返回码\"}, {\"_src_hash\": \"8b8ed2d79af6d486e83a8209f977049bc1a1aed8f8f404d13d1a8d0312db303d\", \"desc\": \"```GetRobotList```接口、```GetRobotDetail```接口、```GetRobotLogs```接口返回的数据中```status```字段为：实盘状态码。\\n\\n- 正常启动\\n | 状态 | 代码 |\\n | - | - |\\n | 空闲中 | 0 |\\n | 运行中 | 1 |\\n | 停止中 | 2 |\\n | 已退出 | 3 |\\n | 被停止 | 4 |\\n | 策略有错误 | 5 |\\n- 异常\\n | 状态 | 代码 |\\n | - | - |\\n | 策略已过期，请联系作者重新购买 | -1 |\\n | 未找到托管者 | -2 |\\n | 策略编译错误 | -3 |\\n | 实盘已处于运行状态 | -4 |\\n | 余额不足 | -5 |\\n | 策略并发数超限 | -6 |\", \"title\": \"实盘状态码\"}, {\"_src_hash\": \"48badd3c4a451433db2286ec098c63d862f05d127f6527b96036b8fa69f5b14a\", \"children\": [{\"_src_hash\": \"b935c1b4cb28543e45d3ecfd35b91b92ac999fd0b37bbe4a3691200d94761590\", \"desc\": \"使用```md5```加密方式进行验证，以下是```Python```、```Golang```语言的调用示例：\\n\\n```python\\n#!/usr/bin/python\\n# -*- coding: utf-8 -*-\\nimport time\\nimport json\\nimport ssl\\nssl._create_default_https_context = ssl._create_unverified_context\\n\\ntry:\\n import md5\\n import urllib2\\n from urllib import urlencode\\nexcept:\\n import hashlib as md5\\n import urllib.request as urllib2\\n from urllib.parse import urlencode\\n\\naccessKey = 'f27bfcXXXXXXXX013c62e98XXXXX817a'\\nsecretKey = 'ffeXXXXXXXX085ff7269XXXXXXXX6f82'\\n\\ndef api(method, *args):\\n d = {\\n 'version': '1.0',\\n 'access_key': accessKey,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n\\n d['sign'] = md5.md5(('%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], secretKey)).encode('utf-8')).hexdigest()\\n # 注意：urllib2.urlopen 函数可能存在超时问题，可以设置超时时间，例如：urllib2.urlopen('https://www.youquant.com/api/v1', urlencode(d).encode('utf-8'), timeout=10) 设置超时时间为10秒\\n return json.loads(urllib2.urlopen('https://www.youquant.com/api/v1', urlencode(d).encode('utf-8')).read().decode('utf-8'))\\n\\n# 返回托管者列表\\nprint(api('GetNodeList'))\\n# 返回交易所列表\\nprint(api('GetPlatformList'))\\n# GetRobotList(offset, length, robotStatus, label)，传入-1表示获取全部\\nprint(api('GetRobotList', 0, 5, -1, 'member2'))\\n# CommandRobot(robotId, cmd)向实盘发送命令\\nprint(api('CommandRobot', 123, 'ok'))\\n# StopRobot(robotId)返回实盘状态码\\nprint(api('StopRobot', 123))\\n# RestartRobot(robotId)返回实盘状态码\\nprint(api('RestartRobot', 123))\\n# GetRobotDetail(robotId)返回实盘详细信息\\nprint(api('GetRobotDetail', 123))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"time\\\"\\n \\\"encoding/json\\\"\\n \\\"crypto/md5\\\"\\n \\\"encoding/hex\\\"\\n \\\"net/http\\\"\\n \\\"io/ioutil\\\"\\n \\\"strconv\\\"\\n \\\"net/url\\\"\\n)\\n\\n// 填写您的优宽量化交易平台账号的API密钥\\nvar apiKey string = \\\"\\\"\\n// 填写您的优宽量化交易平台账号的密钥\\nvar secretKey string = \\\"\\\"\\nvar baseApi string = \\\"https://www.youquant.com/api/v1\\\"\\n\\nfunc api(method string, args ... interface{}) (ret interface{}) {\\n // 处理参数\\n jsonStr, err := json.Marshal(args)\\n if err != nil {\\n panic(err)\\n }\\n\\n params := map[string]string{\\n \\\"version\\\" : \\\"1.0\\\",\\n \\\"access_key\\\" : apiKey,\\n \\\"method\\\" : method,\\n \\\"args\\\" : string(jsonStr),\\n \\\"nonce\\\" : strconv.FormatInt(time.Now().UnixNano() / 1e6, 10),\\n }\\n\\n data := fmt.Sprintf(\\\"%s|%s|%s|%v|%s\\\", params[\\\"version\\\"], params[\\\"method\\\"], params[\\\"args\\\"], params[\\\"nonce\\\"], secretKey)\\n h := md5.New()\\n h.Write([]byte(data))\\n sign := h.Sum(nil)\\n\\n params[\\\"sign\\\"] = hex.EncodeToString(sign)\\n\\n // http request\\n client := &http.Client{}\\n\\n // request\\n urlValue := url.Values{}\\n for k, v := range params {\\n urlValue.Add(k, v)\\n }\\n urlStr := urlValue.Encode()\\n request, err := http.NewRequest(\\\"GET\\\", baseApi + \\\"?\\\" + urlStr, nil)\\n if err != nil {\\n panic(err)\\n }\\n\\n resp, err := client.Do(request)\\n if err != nil {\\n panic(err)\\n }\\n\\n defer resp.Body.Close()\\n\\n b, err := ioutil.ReadAll(resp.Body)\\n if err != nil {\\n panic(err)\\n }\\n\\n ret = string(b)\\n return\\n}\\n\\nfunc main() {\\n settings := map[string]interface{}{\\n \\\"name\\\": \\\"hedge test\\\",\\n \\\"strategy\\\": 1234,\\n // K线周期参数，60表示60秒\\n \\\"period\\\": 60,\\n \\\"node\\\" : 1234,\\n \\\"appid\\\": \\\"member2\\\",\\n \\\"exchanges\\\": []interface{}{\\n map[string]interface{}{\\n \\\"pid\\\": \\\"1234\\\",\\n \\\"pair\\\": \\\"FUTURES\\\",\\n },\\n },\\n }\\n\\n method := \\\"NewRobot\\\"\\n fmt.Println(\\\"调用接口：\\\", method)\\n ret := api(method, settings)\\n fmt.Println(\\\"main ret:\\\", ret)\\n}\\n```\", \"title\": \"token验证\"}, {\"_src_hash\": \"b171930b8aeb75d970f9b36d94fa92d125bdc449fbd16fd6584509a826f7c276\", \"desc\": \"支持不使用```token```验证（直接传递```secret_key```验证），可以生成一个用于直接访问的URL。例如直接向实盘发送交互指令的URL，可用于```Trading View```或其他场景的```WebHook```回调。对于扩展API接口```CommandRobot()```函数，不进行```nonce```校验，不限制该接口的访问频率和访问次数。\\n\\n例如，创建的扩展```API KEY```中的```AccessKey```为：```xxx```，```SecretKey```为：```yyy```，访问以下链接即可向ID为```186515```的实盘发送交互指令消息，消息内容为字符串：```ok12345```。\\n\\n```plaintext\\nhttps://www.youquant.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C%22ok12345%22%5D\\n```\\n\\n在支持直接验证方式下，可获取请求中的```Body```数据，仅支持```CommandRobot```接口。例如在```Trading View```的```WebHook URL```中设置：\\n\\n```plaintext\\nhttps://www.youquant.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\n```\\n\\n注意需要按照此格式设置：```%5B186515%2C+%22%22%5D```（编码前为：```[186515, \\\"\\\"]```），其中```186515```是优宽量化交易平台的实盘ID。\\n\\n模拟```Trading View```发送```WebHook URL```警报：\\n```javascript\\nfunction main() {\\n var options = {\\n method: \\\"POST\\\",\\n body: `{\\\"test\\\": 123}`,\\n headers: {\\\"Content-Type\\\": \\\"application/json\\\"}\\n }\\n\\n // WebHook URL 警报会自动发送POST请求，包含需要的 headers 设置\\n return HttpQuery(\\\"https://www.youquant.com/api/v1?access_key=xxx&secret_key=xxx&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\", options)\\n}\\n```\\n\\n```Trading View```消息框中设置（要发送的请求中的Body数据）：\\n- JSON格式：\\n\\n https://www.youquant.com/upload/asset/16d8a37ef80d9ccd0079.png\\n\\n ```text\\n {\\\"close\\\": {{close}}, \\\"name\\\": \\\"aaa\\\"}\\n ```\\n\\n ID为```186515```的实盘即可收到交互命令：```{\\\"close\\\": 39773.75, \\\"name\\\": \\\"aaa\\\"}```。\\n- 文本格式：\\n\\n https://www.youquant.com/upload/asset/1777914b2cb52a606ebb9.png\\n\\n ```text\\n XXX PERP 穿过(Crossing) 39700.00 close: {{close}}\\n ```\\n\\n ID为```186515```的实盘即可收到交互命令：```XXX PERP 穿过(Crossing) 39700.00 close: 39739.4```。\\n\\n```Python```、```Golang```语言调用示例：\\n\\n```python\\n#!/usr/bin/python\\n# -*- coding: utf-8 -*-\\n\\nimport json\\nimport ssl\\n\\nssl._create_default_https_context = ssl._create_unverified_context\\n\\ntry:\\n import urllib2\\nexcept:\\n import urllib.request as urllib2\\n\\naccessKey = 'your accessKey'\\nsecretKey = 'your secretKey'\\n\\ndef api(method, *args):\\n return json.loads(urllib2.urlopen(('https://www.youquant.com/api/v1?access_key=%s&secret_key=%s&method=%s&args=%s' % (accessKey, secretKey, method, json.dumps(list(args)))).replace(' ', '')).read().decode('utf-8'))\\n\\n# 如果APIKEY 没有该接口权限，调用 print(api('RestartRobot', 130350)) 会失败，返回数据：{'code': 4, 'data': None}\\n# print(api('RestartRobot', 130350))\\n# 打印ID为：130350的实盘详细信息\\n\\nprint(api('GetRobotDetail', 130350))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"encoding/json\\\"\\n \\\"net/http\\\"\\n \\\"io/ioutil\\\"\\n \\\"net/url\\\"\\n)\\n\\n// 填写自己的优宽量化交易平台账号的api key\\nvar apiKey string = \\\"your access_key\\\"\\n\\n// 填写自己的优宽量化交易平台账号的secret key\\nvar secretKey string = \\\"your secret_key\\\"\\n\\nvar baseApi string = \\\"https://www.youquant.com/api/v1\\\"\\n\\nfunc api(method string, args ... interface{}) (ret interface{}) {\\n jsonStr, err := json.Marshal(args)\\n if err != nil {\\n panic(err)\\n }\\n\\n params := map[string]string{\\n \\\"access_key\\\" : apiKey,\\n \\\"secret_key\\\" : secretKey,\\n \\\"method\\\" : method,\\n \\\"args\\\" : string(jsonStr),\\n }\\n\\n // http request\\n client := &http.Client{}\\n\\n // request\\n urlValue := url.Values{}\\n for k, v := range params {\\n urlValue.Add(k, v)\\n }\\n urlStr := urlValue.Encode()\\n request, err := http.NewRequest(\\\"GET\\\", baseApi + \\\"?\\\" + urlStr, nil)\\n if err != nil {\\n panic(err)\\n }\\n\\n resp, err := client.Do(request)\\n if err != nil {\\n panic(err)\\n }\\n\\n defer resp.Body.Close()\\n\\n b, err := ioutil.ReadAll(resp.Body)\\n if err != nil {\\n panic(err)\\n }\\n\\n ret = string(b)\\n return\\n}\\n\\nfunc main() {\\n method := \\\"GetRobotDetail\\\"\\n fmt.Println(\\\"调用接口：\\\", method)\\n ret := api(method, 130350)\\n fmt.Println(\\\"main ret:\\\", ret)\\n}\\n```\\n\\n[使用优宽量化交易平台扩展API实现TradingView报警信号交易](https://www.youquant.com/digest-topic/9475#9.基于tradingview信号执行交易)\\n[使用优宽量化交易平台扩展API实现TradingView报警信号交易，B站视频链接](https://www.bilibili.com/video/BV1Wk4y1k7zz/)\", \"title\": \"直接验证\"}], \"desc\": \"调用扩展API接口时支持两种验证方式：```token```验证和直接验证。\", \"title\": \"验证方式\"}, {\"_src_hash\": \"715360cd2ead41ae82d06edd00e59cdedaa9af70887e0ed580f6e994909f5487\", \"children\": [{\"_src_hash\": \"8523f240083b45784c90715c292fe1e5fae080c50749048194bac16b35709aaa\", \"args\": \"无参数\", \"desc\": [\"获取当前账号下的托管者列表。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"nodes\\\": [{\\n \\\"build\\\": \\\"3.7\\\",\\n \\\"city\\\": \\\"...\\\",\\n \\\"created\\\": \\\"2024-10-10 22:58:30\\\",\\n \\\"date\\\": \\\"2024-11-25 13:30:50\\\",\\n \\\"forward\\\": \\\"...\\\",\\n \\\"guid\\\": \\\"...\\\",\\n \\\"host\\\": \\\"node.youquant.com:9902\\\",\\n \\\"id\\\": 123,\\n \\\"ip\\\": \\\"...\\\",\\n \\\"is_owner\\\": true,\\n \\\"loaded\\\": 1,\\n \\\"name\\\": \\\"linux\\\",\\n \\\"online\\\": true,\\n \\\"os\\\": \\\"linux/amd64\\\",\\n \\\"peer\\\": \\\"...\\\",\\n \\\"public\\\": 0,\\n \\\"region\\\": \\\"...\\\",\\n \\\"tunnel\\\": false,\\n \\\"version\\\": \\\"...\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n返回值字段说明（含义明显的字段不再赘述）：\\n- all: 当前账户关联的托管者总数。\\n- nodes: 托管者节点的详细信息列表。\\n - build: 版本号。\\n - city: 所在城市。\\n - is_owner: true表示私有托管者，false表示公共托管者。\\n - loaded: 负载数量，即当前运行的策略实例数。\\n - public: 0表示私有托管者，1表示公共托管者。\\n - region: 地理位置。\\n - version: 托管者的详细版本信息。\\n - wd: 离线报警开关，0表示未开启。\\n一键部署的托管者包含额外信息，相关字段以```ecs_```、```unit_```为前缀，记录了一键部署托管者服务器的相关信息（运营商名称、配置、状态等）以及计费周期、价格等信息，此处不再详述。\", \"title\": \"GetNodeList\"}, {\"_src_hash\": \"7b215a849a4280cc2aa44c2907421ca85cc7839d87fec386b61daaa5cd926333\", \"args\": \"无参数\", \"desc\": [\"获取当前账号的实盘分组列表。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":{\\n \\\"items\\\":[{\\n \\\"id\\\":2426,\\n \\\"name\\\":\\\"商品期货实盘\\\"\\n }]\\n },\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- items: 实盘分组信息。\\n - id: 实盘分组ID。\\n - name: 实盘分组名称。\\n```items```字段仅记录创建的新分组，「默认」分组不包含在```items```中。\", \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"9ced2f2f2d0707ecaab46fe95aefaff406cdc185e9be47621af4d8625a8c2d5d\", \"args\": \"无参数\", \"desc\": [\"获取当前账号已添加的交易所列表。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"platforms\\\": [{\\n \\\"category\\\": \\\"商品期货\\\",\\n \\\"date\\\": \\\"2024-04-23 13:38:24\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"期货主席(看穿式监管)\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"CTP协议\\\",\\n \\\"profiles\\\": \\\"...\\\",\\n \\\"stocks\\\": [\\\"FUTURES\\\"],\\n \\\"website\\\": \\\"http://www.sfit.com.cn/\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: 已添加或配置的交易所对象总数。\\n- platforms: 交易所相关信息。\\n - eid: 优宽量化交易平台上的交易所标识符，在某些配置和参数中会使用```eid```。\\n - profiles: 前置机配置信息。\", \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"3d1524cb70c34571b4018faa8643b6df3fe53dad9e37ed9484c078f634b2a05d\", \"args\": [{\"info\": \"分页查询的偏移量设置。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"分页查询的数据长度设置。\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"指定要查询的实盘状态，参考扩展API接口{@扩展API接口/实盘状态码「实盘状态码」}，传入```-1```表示获取全部实盘。\", \"name\": \"robotStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"指定要查询的实盘自定义标签，可筛选出包含该标签的所有实盘。\", \"name\": \"label\", \"required\": false, \"type\": \"string\"}, {\"info\": \"查询关键字。\", \"name\": \"keyWord\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"获取当前账号的实盘列表。\"], \"isChildren\": true, \"remarks\": [\"以```Python```语言的扩展API接口{@扩展API接口/验证方式「验证方式」}为例：\\n\\n```print(api('GetRobotList'))```：获取全部实盘信息。\\n\\n```print(api('GetRobotList', 'member2'))```：打印所有自定义标签为member2的实盘信息。\\n\\n```print(api('GetRobotList', 0, 5, -1, 'member2'))```：分页查询，从偏移量0开始，最多返回5个标签为member2的实盘。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"concurrent\\\": 0,\\n \\\"robots\\\": [{\\n \\\"charge_time\\\": 1729561129,\\n \\\"date\\\": \\\"2024-09-26 21:34:28\\\",\\n \\\"end_time\\\": \\\"2024-10-22 09:12:47\\\",\\n \\\"fixed_id\\\": 1666928,\\n \\\"id\\\": 473200,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_guid\\\": \\\"0a77f717c15843910863a4c1b2867ca2\\\",\\n \\\"node_id\\\": 1666928,\\n \\\"node_public\\\": 0,\\n \\\"profit\\\": 123,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1729559554000,\\n \\\"start_time\\\": \\\"2024-10-11 13:38:49\\\",\\n \\\"status\\\": 4,\\n \\\"strategy_id\\\": 399872,\\n \\\"strategy_isowner\\\": true,\\n \\\"strategy_language\\\": 0,\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": 0,\\n \\\"uid\\\": \\\"0a77f717c15843910863a4c1b2867ca2\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- robots: 实盘信息\\n - group_id: 实盘分组ID；如果实盘位于默认分组中，则不包含```group_id```字段。\", \"title\": \"GetRobotList\"}, {\"_src_hash\": \"3d65dffb8c8965fc6e433dcd5454cb7d1a11ddc4a48b9ca162d0ea3cf3206c22\", \"args\": [{\"info\": \"接收交互指令的实盘ID。可以通过```GetRobotList```方法获取账号下实盘的信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"发送给实盘的交互指令。实盘策略中的```GetCommand()```函数会捕获该交互命令，触发策略的交互逻辑。策略代码中的具体交互逻辑实现，请参考{@fun/Global/GetCommand 优宽量化交易平台API手册}中的```GetCommand()```函数说明。\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"向当前账号下的实盘发送交互命令。接收交互命令的实盘ID由```robotId```参数指定，交互命令由策略中调用的```GetCommand()```函数捕获并返回。\"], \"isChildren\": true, \"remarks\": [\"实盘策略示例（假设该策略实盘正在运行，实盘ID为123）：\\n```javascript\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(cmd)\\n }\\n Sleep(2000)\\n }\\n}\\n```\\n\\n如果使用本章节的Python测试脚本访问优宽量化交易平台的扩展API：```api(\\\"CommandRobot\\\", 123, \\\"test command\\\")```，ID为123的实盘将收到交互指令```test command```，并通过Log函数输出打印。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":false,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 交互指令是否发送成功。向未运行的实盘发送指令时，返回数据中的result为false。\", \"title\": \"CommandRobot\"}, {\"_src_hash\": \"9a548bad31d735c16a1ab30ba9c583cc72e85c6e20c60b6a2292c252737a7859\", \"args\": [{\"info\": \"需要停止的实盘ID。可通过```GetRobotList```方法获取账户下的实盘信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"停止当前账号下的实盘。停止运行的实盘ID由```robotId```参数指定。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":4,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘状态码，4表示已停止。\", \"title\": \"StopRobot\"}, {\"_src_hash\": \"e8d974a03e46bba67cf0440b1a1cf26dedad5e09f39205d500fa337ebb647ef5\", \"args\": [{\"info\": \"要重启的实盘ID。可以使用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"实盘配置参数。```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"appid\\\":\\\"test\\\",\\n \\\"args\\\":[],\\n \\\"exchanges\\\":[\\n {\\\"pair\\\":\\\"FUTURES\\\",\\\"pid\\\":123}\\n ],\\n \\\"name\\\":\\\"测试\\\",\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"strategy\\\":123\\n}\\n```\\n\\n- appid: 自定义字段\\n 可以定义标签。\\n- args: 策略参数设置\\n 结构为数组，每个元素为一个参数。例如，策略有一个参数```Interval```，重启策略时希望将```Interval```设置为500，则```args```中应包含：```[\\\"Interval\\\", 500]```，即：```\\\"args\\\": [[\\\"Interval\\\", 500]]```。\\n- exchanges: 实盘绑定的交易所对象配置\\n 结构为数组，其中每个元素为一个交易所对象配置。\\n - 可以绑定已在平台配置的交易所对象\\n 使用```pid```配置：```{\\\"pair\\\":\\\"FUTURES\\\",\\\"pid\\\":123}```；```pid```可以通过```GetPlatformList```接口查询，返回数据中的```id```字段即为交易所```pid```。\\n - 可以直接传入配置信息，绑定交易所对象\\n 使用```eid```配置：```{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"meta\\\":{},\\\"pair\\\":\\\"FUTURES_CTP\\\"}```；传入的配置信息不会被优宽量化交易平台存储。这些数据会直接转发给托管者程序，因此每次创建或重启实盘时必须配置该信息。```meta```的具体格式请参考GetExchangeList接口返回数据中的```meta```字段内容。\\n 以CTP协议为例，配置华安期货的信息，```meta```字段结构如下：\\n ```json\\n \\\"meta\\\":{\\n \\\"AppID\\\":\\\"xxx\\\",\\n \\\"AuthCode\\\":\\\"xxx\\\",\\n \\\"BrokerId\\\":\\\"6020\\\",\\n \\\"ClientVer\\\":\\\"BT_T_V001\\\",\\n \\\"MDFront\\\":\\\"...\\\",\\n \\\"Name\\\":\\\"华安期货(看穿式监管)\\\",\\n \\\"Password\\\":\\\"xxx\\\",\\n \\\"TDFront\\\":\\\"...\\\",\\n \\\"Username\\\":\\\"xxx\\\",\\n \\\"V2\\\":true\\n }\\n ```\\n ```GetExchangeList```接口返回数据中```required```为真的配置项，在配置```meta```时不可为空。```required```为假的配置项在配置```meta```时可为空。例如上例中的```AuthCode```、```Name```。\\n Username: 资金账号。\\n Password: 资金账号的密码。\\n- name: 策略名称\\n- node: 托管者ID\\n 指定在哪个托管者上运行。如果不设置该属性，系统将自动分配运行。\\n- period: 默认K线周期\\n K线周期参数，60表示60秒。\\n- strategy: 策略ID\\n 可以使用```GetStrategyList```方法获取。\", \"name\": \"settings\", \"required\": false, \"type\": \"object\"}], \"desc\": [\"重启当前账号下的实盘。重启的实盘ID由```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"如果实盘是使用扩展API接口创建的，重启时必须使用扩展API接口```RestartRobot```进行重启，并且必须传入```settings```参数。在平台页面上创建的实盘，可以通过扩展API接口重启或者点击实盘页面上的按钮重启。可以传入```settings```参数或不传入。如果只传入```robotId```参数，则按照实盘的当前设置启动运行。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":1,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘状态码，1表示运行中。\", \"title\": \"RestartRobot\"}, {\"_src_hash\": \"82a5e771ce1695a7bdb8f1511d80a4af378f2df49eee6187ee5eb7a016b2f6c1\", \"args\": [{\"info\": \"需要获取详细信息的实盘ID。可通过```GetRobotList```方法获取账号下所有实盘的信息列表，其中包含各实盘的ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"获取当前账号下指定实盘的详细信息。所要查询的实盘通过```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"```strategy_exchange_pairs```属性说明，以下列数据为例：\\n\\n```plaintext\\n[86400,[123456],[\\\"FUTURES\\\"]]\\n```\\n\\n其中第一个元素```86400```表示实盘配置的默认K线周期为1天（86400秒）。\\n\\n```[123456]```为实盘配置的交易所对象```eid```列表（按添加顺序排列）。\\n```[\\\"FUTURES\\\"]```为实盘配置的交易所对象设置的交易对（按添加顺序与```eid```一一对应）。因此```[86400,[123456],[\\\"FUTURES\\\"]]```的数据结构为：```[K线周期，交易所对象ID列表，交易对列表]```。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"robot\\\": {\\n \\\"charge_time\\\": 1732520672,\\n \\\"charged\\\": 1184400,\\n \\\"consumed\\\": 87500000,\\n \\\"date\\\": \\\"2021-10-29 16:14:56\\\",\\n \\\"debug\\\": \\\"{\\\\\\\"Nano\\\\\\\":1732518261405924960,\\\\\\\"Stderr\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Stdout\\\\\\\":\\\\\\\"\\\\\\\"}\\\",\\n \\\"end_time\\\": \\\"2024-11-25 15:04:21\\\",\\n \\\"favorite\\\": {\\n \\\"added\\\": false,\\n \\\"type\\\": \\\"R\\\"\\n },\\n \\\"fixed_id\\\": 123,\\n \\\"hits\\\": 0,\\n \\\"id\\\": 123,\\n \\\"is_deleted\\\": 0,\\n \\\"is_manager\\\": true,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_id\\\": 123,\\n \\\"pexchanges\\\": {\\n \\\"-100\\\": \\\"Futures_CTP\\\"\\n },\\n \\\"phash\\\": {},\\n \\\"plabels\\\": {\\n \\\"-100\\\": \\\"Futures_CTP\\\"\\n },\\n \\\"priority\\\": 0,\\n \\\"profit\\\": 0,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1732518244000,\\n \\\"robot_args\\\": \\\"[]\\\",\\n \\\"start_time\\\": \\\"2024-11-25 15:03:38\\\",\\n \\\"status\\\": 4,\\n \\\"strategy_args\\\": \\\"...\\\",\\n \\\"strategy_exchange_pairs\\\": \\\"[60,[-100],[\\\\\\\"FUTURES_CTP\\\\\\\"]]\\\",\\n \\\"strategy_id\\\": 123,\\n \\\"strategy_last_modified\\\": \\\"2024-10-10 18:09:05\\\",\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": \\\"0\\\",\\n \\\"summary\\\": \\\"...\\\",\\n \\\"uid\\\": \\\"03dd49e1de9c29f7a02ae015c65ef136\\\",\\n \\\"username\\\": \\\"...\\\",\\n \\\"wd\\\": 0\\n }\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- charge_time: 下次扣费时间，即当前扣费后的有效截止时间。\\n- charged: 已消耗的时间。\\n- consumed: 已消耗的金额（0.125 CNY = 12500000 / 1e8）。\\n- date: 创建日期。\\n- fixed_id: 实盘运行时分配的托管者ID，如果是自动分配，该值为-1。\\n- is_manager: 是否拥有管理该实盘的权限。\\n- is_sandbox: 是否为模拟盘。\\n- name: 实盘名称。\\n- node_id: 托管者ID。\\n- pexchanges: 实盘配置的交易所对象，-100为pid，\\\"Futures_CTP\\\"为交易所类型。该实盘的交易所配置通过eid方式创建（通过meta字段配置），因此显示pid的内容为-100；通过eid方式创建的交易所对象pid依次递减，例如：```{\\\"-100\\\":\\\"Futures_CTP\\\",\\\"-101\\\":\\\"Futures_CTP\\\"}```。\\n- plabels: 实盘配置的交易所对象的标签信息。\\n- profit: 实盘收益数据。\\n- public: 实盘是否公开。\\n- refresh: 最近活跃时间。\\n- strategy_exchange_pairs: 配置的交易所对象及设置的交易对信息。\\n- wd: 是否开启离线报警。\", \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"9b1012b1000f6bea9a84fe36a3a94c83d1cc198ea713925cbb5c0eb204ccdc5f\", \"desc\": [\"获取当前账号的账户信息。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":{\\n \\\"balance\\\":52437600,\\n \\\"concurrent\\\":0,\\n \\\"consumed\\\":200647562400,\\n \\\"currency\\\":\\\"CNY\\\",\\n \\\"email\\\":\\\"...\\\",\\n \\\"openai\\\":false,\\n \\\"settings\\\":null,\\n \\\"sns\\\":{},\\n \\\"uid\\\":\\\"...\\\",\\n \\\"username\\\":\\\"...\\\"\\n },\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- balance: 账户余额\\n 该数值采用整数表示以确保精度，实际金额需除以1e8（即10的8次方）进行换算。示例中的实际余额为：0.52437600\", \"title\": \"GetAccount\"}, {\"_src_hash\": \"4bbf4c469b184e1ccdf7bed3389511c538c4ca3c7da2a304e50b6264db0844c6\", \"args\": [{\"info\": \"是否返回概要信息。\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"获取平台支持的交易所列表及其配置信息。\"], \"isChildren\": true, \"returns\": \"当```isSummary```参数为```false```时，返回的数据：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"商品期货\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"id\\\": 123,\\n \\\"logo\\\": \\\"/upload/asset/236192b0caaca5fadf948.svg\\\",\\n \\\"meta\\\": \\\"...\\\",\\n \\\"name\\\": \\\"CTP协议\\\",\\n \\\"priority\\\": 10,\\n \\\"profiles\\\": \\\"...\\\",\\n \\\"stocks\\\": \\\"FUTURES\\\",\\n \\\"website\\\": \\\"http://www.sfit.com.cn/\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n当```isSummary```参数为```true```时，返回的数据：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"商品期货\\\",\\n \\\"eid\\\": \\\"Futures_CTP\\\",\\n \\\"id\\\": 123,\\n \\\"logo\\\": \\\"/upload/asset/236192b0caaca5fadf948.svg\\\",\\n \\\"name\\\": \\\"CTP协议\\\",\\n \\\"priority\\\": 10,\\n \\\"website\\\": \\\"http://www.sfit.com.cn/\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- meta: 交易所配置元数据。\\n- profiles: 前置机配置信息。\", \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"f32b3c4c6be8d70b011db4ac2ea8b0bc202ef6dfe0b3ab2b3ac729c14fb66904\", \"args\": [{\"info\": \"要删除的托管者ID，可通过```GetNodeList```方法获取账号下的托管者信息。\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"删除当前账号的托管者节点，删除的托管者节点ID为```nid```参数指定的托管者ID。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 是否成功删除关联的托管者程序。\", \"title\": \"DeleteNode\"}, {\"_src_hash\": \"481b7132d5228446ca6dec88448b5b88771768908f406f643a5cc7347a3234aa\", \"args\": [{\"info\": \"要删除的实盘ID。可以使用```GetRobotList```方法获取账户下实盘的信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"是否删除实盘日志。如果传入真值（例如：```true```），则删除实盘日志。\", \"name\": \"deleteLogs\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"删除当前账号下的实盘。删除的实盘ID为```robotId```参数指定的实盘ID。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":0,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘删除操作的反馈结果。\\n - 0: 正常删除。\\n - -2: 删除成功，但无法与实盘关联的托管器联系，请手动删除文件 123.db3！\", \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"586b64739a63e86ff273b9ed6cc425881219004b4e8b88f69ad368bedefdc9ca\", \"args\": [{\"info\": \"查询的偏移量。\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询返回的数据条数。\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"要查询的策略类型。\\n\\n- ```strategyType```参数设置为```0```：查询所有策略。\\n\\n- ```strategyType```参数设置为```1```：查询已公开的策略。\\n\\n- ```strategyType```参数设置为```2```：查询待审核的策略。\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"要查询的策略类别。\\n\\n- ```category```参数设置为```-1```：查询所有策略。\\n\\n- ```category```参数设置为```0```：查询通用策略。\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询的策略是否需要参数。\\n\\n- ```needArgs```参数设置为```0```：查询所有策略。\", \"name\": \"needArgs\", \"required\": true, \"type\": \"number\"}, {\"info\": \"要查询策略的编程语言。\\n\\n- ```language```参数设置为```0```：JavaScript语言。\\n\\n- ```language```参数设置为```1```：Python语言。\\n\\n- ```language```参数设置为```3```：已停用的策略类型，只会出现在存量策略中。\\n\\n- ```language```参数设置为```4```：My语言。\\n\\n- ```language```参数设置为```5```：PINE语言。\\n\\n- ```language```参数设置为```6```：Workflow工作流。\\n\\n- ```language```参数设置为```7```：Rust语言。\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询策略的关键字。\\n\\n- 设置为空字符串表示不使用关键字筛选。\", \"name\": \"kw\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"获取平台策略信息。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1784,\\n \\\"strategies\\\": [{\\n \\\"category\\\": 1,\\n \\\"date\\\": \\\"2024-11-24 00:36:01\\\",\\n \\\"description\\\": \\\"...\\\",\\n \\\"forked\\\": 0,\\n \\\"hits\\\": 0,\\n \\\"id\\\": 401124,\\n \\\"is_buy\\\": false,\\n \\\"is_owner\\\": false,\\n \\\"language\\\": 0,\\n \\\"last_modified\\\": \\\"2024-11-24 00:36:01\\\",\\n \\\"name\\\": \\\"商品期货高频交易策略Penny Jump|CTP Penny Jump (Copy)\\\",\\n \\\"profile\\\": {\\n \\\"avatar\\\": \\\"...\\\",\\n \\\"nickname\\\": \\\"eway\\\",\\n \\\"uid\\\": \\\"cc381d795af0912b4fbe4a1bfe00583e\\\"\\n },\\n \\\"public\\\": 0,\\n \\\"tags\\\": \\\"\\\",\\n \\\"uid\\\": \\\"cc381d795af0912b4fbe4a1bfe00583e\\\",\\n \\\"username\\\": \\\"eway\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: 符合筛选条件的策略总数。\\n- strategies: 查询返回的策略详细信息。\", \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"c235cfa2cb16801311e08a300fdb10b6a7c0db0f9d4e9a4e8a410a6ff6fdeb98\", \"args\": [{\"info\": \"实盘配置参数，```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"appid\\\":\\\"test\\\",\\n \\\"args\\\":[],\\n \\\"exchanges\\\":[{\\\"pair\\\":\\\"FUTURES\\\",\\\"pid\\\":123}],\\n \\\"name\\\":\\\"测试\\\",\\n \\\"group\\\":123,\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"strategy\\\":123\\n}\\n```\\n\\n- group: 指定实盘分组。\\n- args: 策略参数，如果策略没有参数则为空数组。\\n- exchanges: 交易所对象配置，可参考```RestartRobot```接口。\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"desc\": [\"在当前账号下创建一个实盘。\"], \"isChildren\": true, \"remarks\": [\"使用```eid```配置时，```{\\\"eid\\\":\\\"Futures_CTP\\\",\\\"meta\\\":{},\\\"pair\\\":\\\"FUTURES_CTP\\\"}```；配置的敏感信息优宽量化交易平台不会存储。这些数据将直接转发给托管者程序，因此每次创建或重启实盘时必须配置该信息。```meta```具体格式请参考：```GetExchangeList```接口返回数据中的```meta```字段内容。\\n\\n以CTP协议为例，配置华安期货的信息，```meta```字段结构如下：\\n\\n```json\\n\\\"meta\\\":{\\n \\\"AppID\\\":\\\"xxx\\\",\\n \\\"AuthCode\\\":\\\"xxx\\\",\\n \\\"BrokerId\\\":\\\"6020\\\",\\n \\\"ClientVer\\\":\\\"BT_T_V001\\\",\\n \\\"MDFront\\\":\\\"...\\\",\\n \\\"Name\\\":\\\"华安期货(看穿式监管)\\\",\\n \\\"Password\\\":\\\"xxx\\\",\\n \\\"TDFront\\\":\\\"...\\\",\\n \\\"Username\\\":\\\"xxx\\\",\\n \\\"V2\\\":true\\n}\\n```\\n\\n```GetExchangeList```接口返回数据中```required```为真的配置项，在配置```meta```时不可为空。```required```为假的配置项在配置```meta```时可为空。例如上例中的```AuthCode```、```Name```。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":473823,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 创建成功，返回实盘Id。\", \"title\": \"NewRobot\"}, {\"_src_hash\": \"b6fdc8925ad418b744e34ccc61653ffe1f68de3393de7f91578afe76bad864dd\", \"args\": [{\"info\": \"调试工具中的设置参数，```settings```配置中包含测试代码，位于```source```属性中。```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"exchanges\\\":[{\\\"pair\\\":\\\"FUTURES\\\",\\\"pid\\\":123}],\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"source\\\":\\\"function main() {Log(\\\\\\\"Hello YouQuant\\\\\\\")}\\\"\\n}\\n```\\n\\n- source: 需要调试的代码。\\n- node: 托管者ID，可指定在哪个托管者上运行实盘。若该值为-1，则表示自动分配。\\n- exchanges: 交易所对象配置，可参考```RestartRobot```接口。\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"desc\": [\"调用平台的**调试工具**功能；仅支持JavaScript语言。\"], \"isChildren\": true, \"remarks\": [\"```{\\\"pid\\\": 1234, \\\"pair\\\": \\\"FUTURES\\\"}```\\n```{\\\"pid\\\": 1223, \\\"pair\\\": \\\"FUTURES\\\"}```\\n\\n对于```settings```中的```exchanges```属性，调用```PluginRun```方法时只需设置一个（在调试工具页面使用时也仅支持一个交易所对象）。在```settings```中设置2个交易所对象不会引发报错，但在代码中访问第二个交易所对象时将会报错。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":\\\"{\\\\\\\"logs\\\\\\\":[{\\\\\\\"PlatformId\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"OrderId\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"LogType\\\\\\\":6,\\\\\\\"Price\\\\\\\":0,\\\\\\\"Amount\\\\\\\":0,\\\\\\\"Extra\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Currency\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Instrument\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Direction\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Time\\\\\\\":1732525620326},{\\\\\\\"PlatformId\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"OrderId\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"LogType\\\\\\\":5,\\\\\\\"Price\\\\\\\":0,\\\\\\\"Amount\\\\\\\":0,\\\\\\\"Extra\\\\\\\":\\\\\\\"Hello YouQuant\\\\\\\",\\\\\\\"Currency\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Instrument\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Direction\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Time\\\\\\\":1732525620330}],\\\\\\\"result\\\\\\\":\\\\\\\"\\\\\\\"}\\\",\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 调试工具成功执行传入的JavaScript代码后返回的测试结果数据。\", \"title\": \"PluginRun\"}, {\"_src_hash\": \"70d2b806bf48aca9b4f7c4fe63aa492b369c2f9bf45eefc7f3fe839ef6508f72\", \"args\": [{\"info\": \"要获取日志信息的实盘Id，可通过```GetRobotList```方法获取账号下的实盘信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"日志记录的最小Id。\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"日志记录的最大Id。\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"偏移量，在由```logMinId```和```logMaxId```确定的范围内，根据```logOffset```跳过指定数量的记录，从而确定数据获取的起始位置。\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"从起始位置开始获取的数据记录条数。\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"收益日志的最小Id。\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"收益日志的最大Id。\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"偏移量，跳过指定数量的记录作为起始位置。\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"从起始位置开始获取的数据记录条数。\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"图表数据记录的最小Id。\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"图表数据记录的最大Id。\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"偏移量。\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"获取的记录条数。\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询更新记录的基准Id。\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"数据记录的更新时间戳，将筛选出大于此时间戳的记录。\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询状态栏数据的字节数。该参数为整型，设置为0表示不查询状态栏信息，设置为非0值表示需要查询的状态栏信息字节数（此接口不限制数据量，可指定较大的summaryLimit参数以获取所有状态栏信息），状态栏数据存储在返回数据的```summary```字段中。\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"获取当前账号下一个实盘的日志信息，所要获取的日志信息对应的实盘Id由```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"- 数据库中的策略日志表\\n 返回数据中```logs```的属性值（数组结构）的第一个元素中（日志数据）```Arr```属性值描述如下：\\n\\n ```plaintext\\n 'Arr': [\\n [12, 5, '', '', 0, 0, '[]', 1635495362912, '', ''],\\n [11, 3, 'Futures_Futu', '', 0, 0, 'Buy(1826.08, 1000): TrdMarket_CN: 缺少必要的参数: secMarket', 1635495362904, '', '']\\n ]\\n ```\\n\\n |id|logType|eid|orderId|price|amount|extra|date|contractType|direction|\\n |-|-|-|-|-|-|-|-|-|-|\\n |12|5|''|''|0|0|'[]'|1635495362912|''|''|\\n |11|3|'Futures_Futu'|''|0|0|'Buy(1826.08, 1000): TrdMarket_CN: 缺少必要的参数: secMarket'|1635495362904|''|''|\\n\\n ```extra```为打印日志的附加信息。\\n\\n ```logType```值对应的日志类型描述如下：\\n\\n | logType: | 0 | 1 | 2 | 3 | 4 | 5 | 6 |\\n | - | - | - | - | - | - | - | - |\\n | logType意义：| BUY | SALE | RETRACT | ERROR | PROFIT | MESSAGE | RESTART |\\n | 中文意义 | 买入订单日志 | 卖出订单日志 | 撤单 | 错误 | 收益 | 日志 | 重启 |\\n- 数据库中的收益图表日志表\\n 该图表日志表数据与策略日志表中的收益日志保持一致。\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [202, 2515.44, 1575896700315],\\n [201, 1415.44, 1575896341568]\\n ]\\n ```\\n\\n 以其中一条日志数据为例：\\n\\n ```plaintext\\n [202, 2515.44, 1575896700315]\\n ```\\n\\n ```202```为日志ID，```2515.44```为收益数值，```1575896700315```为时间戳。\\n- 数据库中的图表日志表\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [23637, 0, \\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"],\\n [23636, 5, \\\"{\\\\\\\"x\\\\\\\":1575960300000,\\\\\\\"y\\\\\\\":3.0735}\\\"]\\n ]\\n ```\\n\\n 以其中一条日志数据为例：\\n\\n ```plaintext\\n [23637, 0, \\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"],\\n ```\\n\\n ```23637```为日志ID，```0```为图表数据系列索引，最后的数据```\\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"```为日志数据，该条数据为图表上的K线数据。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"chart\\\": \\\"\\\",\\n \\\"chartTime\\\": 0,\\n \\\"logs\\\": [{\\n \\\"Total\\\": 8,\\n \\\"Max\\\": 94,\\n \\\"Min\\\": 87,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }],\\n \\\"node_id\\\": 123,\\n \\\"online\\\": true,\\n \\\"refresh\\\": 1732520711000,\\n \\\"status\\\": 4,\\n \\\"summary\\\": \\\"...\\\",\\n \\\"updateTime\\\": 1732520715044,\\n \\\"wd\\\": 0\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- logs: 日志信息；查询出的若干条日志数据存储在Arr字段中。\\n logs中第一个数据结构为实盘数据库中策略日志表的日志记录。\\n logs中第二个数据结构为实盘数据库中收益日志表的日志记录。\\n logs中第三个数据结构为实盘数据库中图表日志表的日志记录。\\n- summary: 实盘状态栏数据。\", \"title\": \"GetRobotLogs\"}], \"desc\": \"- 优宽量化交易平台扩展API接口\\n 在```https://www.youquant.com/api/v1?```中，```?```符号后面跟随请求参数。使用```Python```语言描述请求参数：\\n\\n ```python\\n {\\n 'version' : '1.0',\\n 'access_key': 'xxx', # AccessKey，在账户管理页面申请\\n 'method' : 'GetNodeList', # 具体调用的方法\\n 'args' : [], # 具体调用的method方法的参数列表\\n 'nonce' : 1516292399361, # 时间戳，单位为毫秒，允许与标准时间戳前后误差1小时，nonce必须大于上一次访问时的nonce值\\n 'sign' : '085b63456c93hfb243a757366600f9c2' # 签名\\n }\\n ```\\n\\n 各参数以字符```&```分隔，参数名和参数值用符号```=```连接，完整的请求URL（以```method=GetNodeList```为例）：\\n\\n ```text\\n https://www.youquant.com/api/v1?\\n access_key=xxx&\\n nonce=1516292399361&\\n args=%5B%5D&\\n sign=085b63456c93hfb243a757366600f9c2&\\n version=1.0&\\n method=GetNodeList\\n ```\\n\\n 注意：请求参数中不包含```secret_key```参数。\\n- 签名方式\\n 请求参数中```sign```参数的加密方式如下，按照以下格式：\\n\\n ```text\\n version + \\\"|\\\" + method + \\\"|\\\" + args + \\\"|\\\" + nonce + \\\"|\\\" + secretKey\\n ```\\n\\n 拼接字符串后，使用```MD5```加密算法对字符串进行加密，并转换为十六进制字符串，该值作为参数```sign```的值。签名部分参考```Python```代码，扩展API接口{@扩展API接口/验证方式「验证方式」}：\\n\\n ```python\\n # 参数\\n d = {\\n 'version': '1.0',\\n 'access_key': accessKey,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n\\n # 计算sign签名\\n d['sign'] = md5.md5(('%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], secretKey)).encode('utf-8')).hexdigest()\\n ```\\n- 接口业务错误：\\n - 参数不足：\\n ```json\\n {\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":null,\\n \\\"error\\\":\\\"Params length incorrect\\\"\\n }\\n }\\n ```\", \"title\": \"扩展API接口详解\"}], \"desc\": \"优宽量化开放了平台的扩展API接口，支持通过程序化方式调用优宽量化交易平台的各项功能。\", \"title\": \"扩展API接口\"}, {\"_src_hash\": \"4e308aae1cbba62929f908422253f112b5e920ed80a23052deed442c296ed601\", \"children\": [], \"desc\": \"MCP（Model Context Protocol）服务是一个用于模型上下文管理的协议服务，提供统一的接口来管理和交换AI模型的上下文信息。该服务支持多种数据格式和通信协议，确保不同AI系统之间的互操作性和数据一致性。\\n\\n/upload/asset/17867c0f4f0bc9bf2d6fb.png\", \"title\": \"MCP 服务\"}, {\"_src_hash\": \"d689185ffa3c91fa60e920bc7434554ac0180d7cbb3f21da8aab62a63f67d43d\", \"children\": [{\"_src_hash\": \"16ab325cd9ed4aa5fdece2f9cbd6d25bc5d1c55e30be67d1fecc46c725a1a439\", \"desc\": \"原理与**调试工具**相同，将一段代码发送到交易终端页面选定的托管者执行，支持返回图表和表格（调试工具目前也已升级支持此功能）。与**调试工具**功能相同，仅能执行3分钟，该功能不计费。可用于实现辅助手动交易的简单功能，复杂策略仍需运行实盘。\", \"title\": \"插件原理\"}, {\"_src_hash\": \"585c3ea7da785a89675a2c5940742abb3839631fdfb9233fed3da824f376017d\", \"desc\": \"创建交易终端插件，可在**新建策略**页面将策略类型设置为「交易插件」。交易插件只支持```JavaScript```。\", \"title\": \"插件编写\"}, {\"_src_hash\": \"79e5076d358c02d1f56a46b5f8c367e8e25b6496777bbad3777956caa2c3c87d\", \"desc\": \"插件可以运行一段代码，执行一些简单的操作，例如冰山委托、挂单、撤单、计算等任务。与调试工具一样，插件通过 return 返回结果，也可以直接返回图表和表格。\\n以下列举几个示例，其他功能可自行探索。\\n\\n- 返回深度的快照\\n ```javascript\\n // 返回深度的快照\\n function main() {\\n var tbl = {\\n type: 'table',\\n title: '深度快照 @ ' + _D(),\\n cols: ['#', 'Amount', 'Ask', 'Bid', 'Amount'],\\n rows: []\\n }\\n var d = exchange.GetDepth()\\n for (var i = 0; i < Math.min(Math.min(d.Asks.length, d.Bids.length), 15); i++) {\\n tbl.rows.push([i, d.Asks[i].Amount, d.Asks[i].Price+'#ff0000', d.Bids[i].Price+'#0000ff', d.Bids[i].Amount])\\n }\\n return tbl\\n }\\n ```\\n\\n ```python\\n def main():\\n tbl = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"深度快照 @ \\\" + _D(),\\n \\\"cols\\\": [\\\"#\\\", \\\"Amount\\\", \\\"Ask\\\", \\\"Bid\\\", \\\"Amount\\\"],\\n \\\"rows\\\": []\\n }\\n d = exchange.GetDepth()\\n for i in range(min(min(len(d[\\\"Asks\\\"]), len(d[\\\"Bids\\\"])), 15)):\\n tbl[\\\"rows\\\"].append([i, d[\\\"Asks\\\"][i][\\\"Amount\\\"], str(d[\\\"Asks\\\"][i][\\\"Price\\\"]) + \\\"#FF0000\\\", str(d[\\\"Bids\\\"][i][\\\"Price\\\"]) + \\\"#0000FF\\\", d[\\\"Bids\\\"][i][\\\"Amount\\\"]])\\n return tbl\\n ```\\n\\n ```rust\\n fn main() {\\n let d = exchange.GetDepth(None).unwrap();\\n let n = d.Asks.len().min(d.Bids.len()).min(15);\\n let mut rows = Vec::new();\\n for i in 0..n {\\n rows.push(format!(r#\\\"[{}, {}, \\\"{}#ff0000\\\", \\\"{}#0000ff\\\", {}]\\\"#, i, d.Asks[i].Amount, d.Asks[i].Price, d.Bids[i].Price, d.Bids[i].Amount));\\n }\\n let tbl = format!(\\n r##\\\"{{\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"深度快照 @ {}\\\", \\\"cols\\\": [\\\"#\\\", \\\"Amount\\\", \\\"Ask\\\", \\\"Bid\\\", \\\"Amount\\\"], \\\"rows\\\": [{}]}}\\\"##,\\n _D(None), rows.join(\\\",\\\"));\\n\\n LogStatus!(format!(\\\"`{}`\\\", tbl));\\n // Rust 不支持return json 显示表格，可以创建实盘显示状态栏表格\\n }\\n ```\\n- 画跨期差价\\n\\n ```javascript\\n // 画跨期差价\\n var chart = {\\n __isStock: true,\\n title : { text : '差价分析图'},\\n xAxis: { type: 'datetime'},\\n yAxis : {\\n title: {text: '差价'},\\n opposite: false\\n },\\n series : [\\n {name : \\\"diff\\\", data : []}\\n ]\\n }\\n\\n function main() {\\n exchange.SetContractType('rb2205') // 实际使用时，需要自行修改需要的合约代码\\n var recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType('rb2201') // 实际使用时，需要自行修改需要的合约代码\\n var recordsB = exchange.GetRecords(PERIOD_M5)\\n\\n for(var i = 0; i < Math.min(recordsA.length, recordsB.length); i++){\\n var diff = recordsA[recordsA.length - Math.min(recordsA.length, recordsB.length) + i].Close - recordsB[recordsB.length - Math.min(recordsA.length, recordsB.length) + i].Close\\n chart.series[0].data.push([recordsA[recordsA.length - Math.min(recordsA.length, recordsB.length) + i].Time, diff])\\n }\\n return chart\\n }\\n ```\\n\\n ```python\\n chart = {\\n \\\"__isStock\\\": True,\\n \\\"title\\\": {\\\"text\\\": \\\"差价分析图\\\"},\\n \\\"xAxis\\\": {\\\"type\\\": \\\"datetime\\\"},\\n \\\"yAxis\\\": {\\n \\\"title\\\": {\\\"text\\\": \\\"差价\\\"},\\n \\\"opposite\\\": False\\n },\\n \\\"series\\\": [\\n {\\\"name\\\": \\\"diff\\\", \\\"data\\\": []}\\n ]\\n }\\n\\n def main():\\n exchange.SetContractType(\\\"rb2205\\\")\\n recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType(\\\"rb2201\\\")\\n recordsB = exchange.GetRecords(PERIOD_M5)\\n\\n for i in range(min(len(recordsA), len(recordsB))):\\n diff = recordsA[len(recordsA) - min(len(recordsA), len(recordsB)) + i].Close - recordsB[len(recordsB) - min(len(recordsA), len(recordsB)) + i].Close\\n chart[\\\"series\\\"][0][\\\"data\\\"].append([recordsA[len(recordsA) - min(len(recordsA), len(recordsB)) + i][\\\"Time\\\"], diff])\\n return chart\\n ```\\n\\n**策略广场**中还有其他范例可供参考，例如逐笔小量买入/卖出。\", \"title\": \"插件用途\"}, {\"_src_hash\": \"a3b10feceec9b19e678775ccadff7152264956d5c618aa499bdf4bfc502e17a8\", \"desc\": \"- 添加交易终端插件模块\\n 在交易终端页面打开模块添加菜单，当前优宽量化交易平台账号策略库中的交易终端插件将自动显示在列表中，找到需要添加的插件并点击添加。\\n - 运行插件\\n 点击「执行」按钮，交易终端插件即开始运行。插件不会显示日志信息，但可以返回并显示数据表格。\\n- 插件运行时间\\n 交易终端插件的最长运行时间为3分钟，超过3分钟将自动停止运行。\", \"title\": \"使用方式\"}], \"desc\": \"优宽量化交易平台提供模块化、可定制的[交易终端](https://www.youquant.com/m/trade)页面。用户可以自由添加各种数据模块、交易功能模块，甚至可以自行编写代码开发模块（交易终端插件）。\\n\\n凭借高度灵活、自由的使用方式，极大地方便了手动交易、半程序化交易的用户。交易终端页面上的各种模块均可拖动、缩放，可修改模块绑定的交易对、交易所等设置，可添加多个同类型的模块。\\n\\n优宽量化交易平台持续完善交易终端功能，为更好地方便手动交易，推出了交易终端的交易插件功能。\\n\\n交易终端的相关数据存储在托管者程序（robot可执行文件）的运行目录下，具体路径为：```logs/storage/0```\", \"title\": \"交易终端\"}, {\"_src_hash\": \"f82ee2a9bc11c5ac9009ba5db6aa30de99b60f2d04204d2512bfadaa6e66ad9a\", \"children\": [{\"_src_hash\": \"31099859c85a8c4dac22c478d677c57e7866823d6d71bd676acd8ba82649fc4f\", \"desc\": \"DataData平台提供的数据源实时持续更新，提供多维度、多类型的数据支持。支持使用私有数据作为数据源，支持上传CSV格式文件，并可在「数据探索」页面预览数据。\", \"title\": \"数据源\"}, {\"_src_hash\": \"9964e87b9a34f9992645a83c1e695d256f572ec3d9e4ed2b80c2ba696cce7a9a\", \"desc\": \"支持使用SQL语句查询数据，并可配置查询参数。支持以下数据导出格式：CSV文件、JSON文件。\", \"title\": \"数据查询\"}, {\"_src_hash\": \"e65a5c16793c6b0c2c68c063756edb2094c93ae98776cec79a229ae595dacfab\", \"desc\": \"如需保存当前数据探索研究的内容，请点击右上角的「保存」按钮，将此SQL查询记录保存至当前优宽量化交易平台账户的「数据探索」资源列表中（资源列表按钮位于保存按钮左侧）。\", \"title\": \"保存探索研究\"}, {\"_src_hash\": \"3aab7cae94e581bbdd1be5ae612852bc6cb833e077cb3c8a0acdfba5db50af43\", \"desc\": \"分析和查询得出的数据除了可以使用表格形式展示外，还可以适配多种可视化组件，以更加丰富生动的方式展示数据。\", \"title\": \"数据图形化\"}, {\"_src_hash\": \"f16f38d9162d97e4ede2884f150fa08d8f77a3649b83abf2a17dd1f2a8cd70c2\", \"desc\": \"支持分享数据探索研究成果，支持以下形式：公开链接、嵌入代码（例如：在优宽量化交易平台社区帖子中嵌入）、嵌入网页、数据链接、预览图链接。\\n数据探索模块的研究成果除了用于展示外，还可以通过创建的「数据链接」直接为策略提供数据，支持实盘和回测环境。\", \"title\": \"分享研究\"}], \"desc\": \"优宽量化自研的**datadata**平台是一个量化金融数据平台，优宽量化交易平台[数据探索](https://www.youquant.com/m/database)模块已集成**datadata**平台的服务和功能。\\n\\n优宽量化用户无需重新注册**datadata**账号，即可开箱即用。使用户在多维度数据分析、挖掘、数据可视化、交易策略探索等方面更具优势。通过SQL查询分析海量数据，并借助可视化界面进行配置，生成适用于数据分析的多种图表并与团队分享，助您轻松掌握市场动态，精准把握投资机会！使用示例请参考：[数据探索模块专题文章](https://www.youquant.com/digest-topic/9505)。\", \"title\": \"数据探索\"}, {\"_src_hash\": \"83a0d7f995a56eb0c53a2a27beb5dd34b11acf5ec7fc5fb5e6b31a5583abc994\", \"children\": [{\"_src_hash\": \"fcfd3dfe9ca9f7188af2d7589840650bd81bf101d61fab7d1e004a2f8c083ceb\", \"desc\": \"下面的“{}”代表占位符，所有表达式均不区分大小写，x代表数据时间序列。\\n- ```abs(x), log(x), sign(x)```含义如其名称所示，分别为绝对值、对数和符号函数。\\n\\n以下操作符``` +, -, *, /, >, < ```均遵循其标准含义，```==```：判断是否相等，```||```：逻辑或，```x ? y : z```：三目运算符。\\n- ```rank(x)``` ：横截面排序：在每个时间点对品种池内各品种的x进行排序，返回百分位，取值范围为(0, 1]；数值相同时取平均名次，当时没有数据的品种不参与排序。品种池是在网页上选择的多个品种；只有一个品种时结果恒为1，不具有排序意义。\\n- ```delay(x, d)``` ：序列d个周期前的值。\\n- ```sma(x, d)``` ：序列d个周期的简单移动平均值。\\n- ```correlation(x, y, d)```：时间序列x和y过去d个周期的相关系数。\\n- ```covariance(x, y, d)``` ：时间序列x和y过去d个周期的协方差。\\n- ```scale(x, a)``` ：对数据进行归一化，使```sum(abs(x))=a```（a默认为1）。\\n- ```delta(x, d)``` ：时间序列x的当前值减去d个周期前的值。\\n- ```signedpower(x, a)``` ：带符号的幂：```sign(x) * abs(x)^a```，x为负数时结果仍为负。\\n- ```decay_linear(x, d)```：时间序列x的d周期加权移动平均值，权重为d,d-1,d-2....1（经过归一化处理）。\\n- ```indneutralize(x, g)``` ：中性化：在每个时间点减去品种池内的均值。目前没有行业分类数据，g不起作用，整个品种池视为同一组。\\n- ```ts_{O}(x, d)``` ：对时间序列x过去d个周期执行O操作（O可代表min、max等，详见下文），d会被转换为整数。\\n- ```ts_min(x, d)``` ：过去d个周期的最小值。\\n- ```ts_max(x, d)``` ：过去d个周期的最大值。\\n- ```ts_argmax(x, d)``` ： ```ts_max(x, d)```所在的位置。\\n- ```ts_argmin(x, d)``` ： ```ts_min(x, d)```所在的位置。\\n- ```ts_rank(x, d)``` ：时间序列x的值在过去d个周期内的排序（百分比排序）。\\n- ```min(x, d)``` ：等同于```ts_min(x, d)```。\\n- ```max(x, d)```：等同于```ts_max(x, d)```。\\n- ```sum(x, d)``` ：过去d个周期的和。\\n- ```product(x, d)``` ：过去d个周期的积。\\n- ```stddev(x, d)``` ：过去d个周期的标准差。\", \"title\": \"函数和操作符\"}, {\"_src_hash\": \"12cb9ae03cdefe21e754f2c9a02f5f28fddba5790b8e3f1290e6b728278b3cc6\", \"desc\": \"大小写不敏感。默认数据为网页上选择的品种（可多选），也可以直接指定，例如```MA888.close```\\n\\n - ```returns``` ：收盘价收益率。\\n\\n - ```open, close, high, low, volume``` ：周期内的开盘价、收盘价、最高价、最低价和成交量。\\n\\n - ```vwap``` ：成交量加权平均价的近似值。由于行情数据不含成交额，按```(high + low + close) / 3```计算。\\n\\n - ```cap``` ：总市值，暂未实现。\\n\\n - ```IndClass``` ：行业分类，暂未实现。\", \"title\": \"输入数据\"}, {\"_src_hash\": \"79ca208c80244825bd8e7457120abfbef52a411ff155fa879dbd0a713458b70d\", \"alias\": \"其它\", \"desc\": \"支持一次输出多个结果，使用列表形式表示。例如```[sma(close, 10), sma(high, 30)]```将在图表中绘制两条线。除了输入时间序列数据外，还可以作为简单的计算器使用。\", \"title\": \"其它用法\"}], \"desc\": \"分析公式参考了```worldquant```公开的[```alpha101```](https://github.com/yli188/WorldQuant_alpha101_code/blob/master/101%20Formulaic%20Alphas.pdf)中的行情计算方法，基本兼容其语法（未实现的功能已说明），并进行了增强。该工具用于快速对时间序列进行运算和验证投资想法。[Alpha因子分析工具页面](https://www.youquant.com/m/alpha)。\", \"title\": \"Alpha因子分析工具\"}, {\"_src_hash\": \"8816e6d2b8efbd41a93aad5f58282c108340bd87e779cfba2d16cb0706c3fd74\", \"children\": [], \"desc\": \"[调试工具](https://www.youquant.com/m/debug)页面提供了一个用于快速测试实盘代码的免费环境，目前仅支持```JavaScript```语言。\\n\\n![调试工具](/upload/asset/1777288db46154c25c23e.png)\\n\\n使用调试工具测试代码时，代码将直接在指定的托管者上运行，最长运行时间为3分钟。支持调用优宽量化交易平台的所有API函数，但仅支持单个交易所对象。\", \"title\": \"调试工具\"}, {\"_src_hash\": \"26aca95976b397f8f9c137379bb686d12c5b60dc597179d11ca1ac8d9619b473\", \"children\": [], \"desc\": \"![远程编辑截图](/upload/asset/177e04005e5a0eb1cfdf4.png)\\n\\n支持本地编辑器远程同步策略代码到优宽量化交易平台，支持```Sublime Text```/```Atom```/```Vim```/```VSCode```编辑器。\\n\\n![远程编辑支持的编辑器插件](/upload/asset/17883e0b1762e2df8fcf7.png)\\n\\n在策略编辑页面点击「远程编辑」展开插件下载地址按钮，显示当前策略的远程同步密钥（token）。\\n\\n- 点击「更新密钥」可刷新当前策略的密钥（token）。\\n- 点击「删除密钥」可删除当前策略的密钥（token）。\\n\\n点击页面上的```Sublime Text 3 Plugin```/```Atom Plugin```/```Vim Plugin```/```VSCode Plugin```编辑器插件下载按钮，即可跳转至对应的插件项目页面。不同编辑器的插件安装方式略有差异。\", \"title\": \"远程编辑\"}, {\"_src_hash\": \"251b4789961c977a39e2bea3cffd750cdad5a25ed94157fc823808b55236fdde\", \"children\": [], \"desc\": \"![策略导入导出截图](/upload/asset/177bdc0aee73d5ef7e351.png)\\n\\n- 下载源码\\n 导出策略源代码，导出的文件类型取决于策略所使用的编程语言。```JavaScript```策略导出为扩展名为```js```的文件；Python策略导出为扩展名为```py```的文件；My语言（麦语言）策略导出为扩展名为```txt```的文件。\\n 注意：仅导出策略源代码，不包含策略参数、模板引用等配置信息。\\n\\n- 导出策略\\n 导出完整的策略配置，包含策略源代码、参数设置等所有相关信息，导出的文件格式为```xml```。\\n\\n- 导入策略\\n 使用「导出策略」功能生成的```xml```文件，在策略编辑页面点击「导入策略」按钮，选择需要导入的```xml```文件即可导入完整的策略配置。\\n 导入完成后需要点击「保存」按钮以保存策略。\", \"title\": \"完整策略的导入与导出\"}, {\"_src_hash\": \"2f4cdd5c8d80fda2199f8366e603c6534e77822550edc96b2ecb07ba0444c2e5\", \"children\": [], \"desc\": \"策略名称与策略参数的描述均可采用```中文|英文```的格式书写，网页会自动识别并按语言显示。在其它使用位置，例如**策略描述**、**使用说明**等```Markdown```格式的文本中，可以使用```[trans]中文|英文[/trans]```或```[trans]中文||英文[/trans]```的格式，同样能够实现自动识别语言的效果。切换语言后，刷新网页即可生效。\\n\\n在策略代码中，可写入字符串的函数同样支持语言切换，例如```Log()```函数、```LogStatus()```函数等。\\n\\n```javascript\\nfunction main() {\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n var table = {\\n type: \\\"table\\\",\\n title: \\\"[trans]操作|option[/trans]\\\",\\n cols: [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n rows: [\\n [\\\"[trans]甲醇|MA[/trans]\\\", \\\"[trans]螺纹钢|rb[/trans]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}] // 注意：按钮中不用加[trans]标签\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + JSON.stringify(table) + \\\"`\\\")\\n throw \\\"[trans]错误|error[/trans]\\\"\\n}\\n```\\n\\n```python\\nimport json\\n\\ndef main():\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n table = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]甲醇|MA[/trans]\\\", \\\"[trans]螺纹钢|rb[/trans]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + json.dumps(table) + \\\"`\\\")\\n raise Exception(\\\"[trans]错误|error[/trans]\\\")\\n```\\n\\n```rust\\nfn main() {\\n Log!(\\\"[trans]日志|log[/trans]\\\");\\n let table = r#\\\"{\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]甲醇|MA[/trans]\\\", \\\"[trans]螺纹钢|rb[/trans]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\\"#;\\n LogStatus!(\\\"[trans]信息|message[/trans]\\\", format!(\\\"\\\\n`{}`\\\", table));\\n Panic!(\\\"[trans]错误|error[/trans]\\\");\\n}\\n```\", \"title\": \"多语言支持\"}, {\"_src_hash\": \"89b7b55097dec392670a9220e33f31341c731a70eec11bbd8fbaacabee1b2f49\", \"children\": [], \"desc\": \"在优宽量化交易平台的「实盘」页面和「策略库」页面，可以点击右侧的**分组管理**按钮，对策略和实盘进行分组管理。\\n例如，在进行策略分组管理时，可以将**模板类库**归为一组、**JavaScript语言的策略**归为一组、**测试用策略**归为一组。\\n- 策略分组\\n ![策略分组](/upload/asset/17766ba9b9aa272085d00.png)\\n\\n- 实盘分组\\n ![实盘分组](/upload/asset/1773408515d0f5930f680.png)\", \"title\": \"实盘、策略分组\"}, {\"_src_hash\": \"a21e2353ca668093aaca19d719e6a765834e13fb93b38e52233c16d2bbcbfd5f\", \"children\": [{\"_src_hash\": \"e5472be3a0b04bff6ffcbf9e62261d33ead4ada6260bced89a406aad02282d17\", \"desc\": \"登录平台后，点击「控制中心」、「账号设置」跳转到优宽量化交易平台账户[管理页面](https://www.youquant.com/m/account)。点击「子账户组」可查看子账户创建页面，在**操作权限**控件中选择所创建子账号可访问的实盘，在**用户信息**控件中设置子账号的**用户名**和**子账号登录密码**。点击「创建子账户」按钮即可创建子账号。创建完成后，子账号将在当前页面显示，并可进行「修改」、「锁定/解锁」、「删除」等操作。\\n\\n 子账号仅拥有有限权限，只能查看**操作权限**设置中授权的实盘。对于已授权的实盘，子账号拥有修改参数、停止实盘、重启实盘的权限，但无法修改实盘配置的交易所对象。\\n\\n ![子账号设置](/upload/asset/176cd0145e51a65f51b20.png)\\n\\n 子账号的典型使用场景包括：\\n - 1、量化团队管理多个实盘策略时，便于统一登录和管理。\\n - 2、策略出租时，为用户提供实盘调试功能。\", \"title\": \"子账号\"}, {\"_src_hash\": \"40d53aa1763bd2bd5d4420202c8413f128855cd204b309c179a2e9d9fe100025\", \"desc\": \"在优宽量化交易平台[实盘页面](https://www.youquant.com/m/robots)的实盘列表中点击「公开」按钮即可公开展示当前行的实盘。\\n\\n实盘围观目前支持两种方式：\\n- 1、在优宽量化交易平台的[实盘围观](https://www.youquant.com/live)页面公开展示实盘。点击「公开」按钮后选择**公开分享**即可。\\n- 2、创建实盘围观私有链接。\\n 点击「公开」按钮后选择**内部分享**，设置有效期后即可生成私有链接，用于访问该策略实盘的私有围观页面。\", \"title\": \"实盘围观\"}], \"desc\": \"优宽量化交易平台提供多种策略实盘展示方式。\", \"title\": \"实盘展示\"}, {\"_src_hash\": \"af63f40467aa6929626bfbef5cf48ad7485c9b36e686a5573fd2af3d008b0f26\", \"children\": [{\"_src_hash\": \"33dc89f53ef8813cd6a7a1c2f2a43bbb0adc8b2d7775fcf5ea0556fa5b42b41f\", \"desc\": \"![策略分享](/upload/asset/17877d57dc36afc004ef6.png)\\n\\n- 公开分享\\n 点击「分享」按钮后会弹出对话框，可以选择「公开分享」。策略将完整发布到平台的策略广场，所有用户均可复制该策略。\\n\\n- 内部分享\\n 点击「分享」按钮后会弹出对话框，可以选择「内部分享」。设置分享有效期和分享次数后，系统将生成该策略的**复制页面地址**和**复制码**。您可以将其分发给指定的优宽量化交易平台用户。需要该策略的用户通过**复制页面地址**链接访问**复制页面**，输入复制码即可获取策略。获取成功后，策略将自动出现在用户的策略库中。\", \"title\": \"策略分享\"}, {\"_src_hash\": \"2f086a33da2d98e2cd17ab08f67557fd9828c551d18dc0916cefb1d8db670087\", \"desc\": \"![策略出租](/upload/asset/177cb8f6c46c9dde1ce90.png)\\n\\n- 公开出售\\n 点击「出租」按钮后会弹出对话框，可以选择「公开出售」。策略即可申请上架（需要通过审核）。\\n\\n- 内部出售\\n 点击「出租」按钮后会弹出对话框，可以选择「内部出售」。选择使用天数、最大并发数、注册码数量后，系统会生成该策略的**注册页面地址**和**注册码**。您可以将其分发给指定的优宽量化交易平台用户。需要该策略的用户只需访问**注册页面地址**链接，登录**注册页面**后输入注册码即可获取策略的使用权。策略也会出现在策略库中，但用户只有回测和实盘使用权，无法查看策略源码等信息。并发实盘个数设置为0时表示不限制并发数量，允许无限制地创建实盘。\", \"title\": \"策略出租\"}], \"desc\": \"在[策略库](https://www.youquant.com/m/strategies)页面，点击策略右侧的「操作项」按钮后，弹出菜单中包含分享和出租操作选项。\\n\\n重要提示：创建和分发策略**注册码**时，请务必仔细确认是「注册码」还是「复制码」，以免误将策略分享出去。\", \"title\": \"策略分享与出租\"}, {\"_src_hash\": \"0b51aad29bc3e059c546e761e86082d10a6a13f3cf45362796c560dd0b6aae72\", \"children\": [], \"desc\": \"在[推送设置页面](https://www.youquant.com/m/account#push)中，可以开启消息推送。\\n\\n![推送设置](/upload/asset/177a8ccaa36cb3f965930.png)\\n\\n- 移动端（App）\\n 开启移动端App推送后，实盘程序发出的推送消息将推送至优宽量化移动端App。\\n- 邮箱\\n 开启邮箱推送需先验证邮箱，验证通过后即可接收实盘程序发出的推送消息。\\n- WebHook\\n 开启WebHook推送后，例如将推送地址设置为：```http://abc.com/push.php?data={body}```。\\n 当实盘程序发出推送消息时，平台会向所设置的地址```http://abc.com/push.php?data={body}```发送一个请求（仅支持```GET```方法），并将推送的消息填充至```{body}```位置。\\n\\n在策略中推送消息\\n- JavaScript/Python/Rust语言\\n 在策略代码中使用```Log()```函数，以及其它可在日志区域输出日志信息的函数，例如：```exchange.CreateOrder()```、```exchange.CancelOrder()```等。\\n 为这些函数传入一个附加参数```@```（即在必要参数之外再增加一个附加参数），例如：```Log(\\\"这是推送的消息\\\", \\\"@\\\")```，即可将该条日志信息进行推送，平台会根据「推送设置」执行消息推送。Rust语言中对应为```Log!```宏，用法相同：```Log!(\\\"这是推送的消息\\\", \\\"@\\\");```。\\n- PINE语言/My语言\\n 在PINE语言/My语言策略所集成的「交易类库」参数中，可以开启交易日志推送，触发交易动作后将自动进行推送。\\n\\n消息推送存在频率限制，具体规则如下：在一个实盘的20秒周期内，仅保留并推送最后一条消息，其余消息将被过滤，不予推送。\", \"title\": \"实盘消息推送\"}, {\"_src_hash\": \"c4434f162e8c1220eb0639dd6451d290aa034dce34f8188c42e3879c46d7a891\", \"children\": [], \"desc\": \"- 策略静态语法错误\\n\\n ![编辑器中语法错误](/upload/asset/1772f504395ed07cf9833.png)\\n\\n 此类错误较为明显，通常在策略编辑页面可以看到错误标记，在回测时即可发现并纠正。\\n- 策略运行时错误\\n 最常见的情况是对函数返回值不进行合法性判断就直接使用。\\n- 内存占用过度\\n 在全局变量中保存过多无法进行垃圾回收的内容，导致内存占用过大。\\n- 函数递归调用\\n 函数递归调用层数过多，导致超出协程堆栈大小限制。\\n- 接口业务错误、网络请求错误等\\n 此类报错会显示相关的交易所对象名称、函数名称、错误相关的消息和原因等信息。此类错误不会导致实盘异常停止（此类报错通常是起因，但并非直接原因，直接原因通常是**未对接口返回值进行合法性判断就直接使用而引起的程序异常**）。\\n- 平台底层报错\\n 常见的有```decrypt connector config (<交易所标签>): field '<字段>': AES decrypt failed (wrong password?)```（少数情况下为```secret key decrypt failed (wrong password)```）错误，该错误会导致实盘无法启动。错误原因是修改了优宽量化交易平台的账号密码，导致所有已配置的```API KEY```失效，需要重新配置```API KEY```并重启托管者即可。\\n- ```interrupt```错误\\n 该错误是由于程序在执行某个操作（例如访问交易所接口）时，用户点击了实盘页面上的**停止实盘按钮**，实盘停止中断了当前操作而打印的报错信息。该报错不会产生实际影响，仅作为日志记录。\\n\\n[常见问题汇总](https://www.youquant.com/bbs-topic/8278)。\", \"title\": \"实盘报错、异常退出的常见原因\"}, {\"_src_hash\": \"d3d942b1648ec77f2563c48f3e61d052d5b9951912ad72fc84055f91530968ed\", \"children\": [{\"_src_hash\": \"8c819f6f85bbd0486eabdd0759a905480fa66df12bab35b009cd3dfeba3ee6cf\", \"desc\": \"- 富途证券\\n 支持富途牛牛实盘交易与模拟盘交易，需下载[```FutuOpenD```](https://www.futunn.com/download/OpenAPI?lang=zh-CN)软件。\\n 使用```FutuOpenD```接入模拟交易时，部分股票代码不受支持，因此无法交易；但富途牛牛手机APP支持模拟交易。\\n 在优宽量化平台上配置交易所对象、运行```FutuOpenD```软件等操作，请参阅[富途证券配置说明文档](https://www.youquant.com/bbs-topic/6270)。\\n\\n - 接口调用频率\\n ```GetOrder```、```GetOrders```、```GetPositions```、```GetAccount```等函数默认使用**缓存数据**，因此不限制调用频率。\\n 当有新数据时，```FutuOpenD```会自动更新数据，**缓存数据**也会随之同步更新。\\n\\n 调用```exchange.IO(\\\"refresh\\\", true)```函数可禁用缓存。**禁用缓存**后，调用频率限制为**每30秒内最多请求10次查询**，超过该频率限制将会报错。\\n\\n - 股票代码\\n 例如：```600519.SH```\\n - HK 港股\\n - US 美股\\n - SH 沪股\\n - SZ 深股\\n\\n 在策略代码中，使用```exchange.SetContractType()```函数设置股票代码，例如：\\n\\n ```javascript\\n function main() {\\n var info = exchange.SetContractType(\\\"600519.SH\\\") // 设置为股票600519.SH即贵州茅台，账户即切换到大陆市场\\n Log(info)\\n Log(exchange.GetAccount()) // 当前设置的股票为贵州茅台，此时调用GetAccount函数获取账户资产，获取的为大陆市场账户资产\\n Log(exchange.GetTicker()) // 获取股票贵州茅台当前的价格信息\\n }\\n ```\\n\\n ```python\\n def main():\\n info = exchange.SetContractType(\\\"600519.SH\\\")\\n Log(info)\\n Log(exchange.GetAccount())\\n Log(exchange.GetTicker())\\n ```\\n\\n ```rust\\n fn main() {\\n let info = exchange.SetContractType(\\\"600519.SH\\\"); // 设置为股票600519.SH即贵州茅台，账户即切换到大陆市场\\n Log!(info);\\n Log!(exchange.GetAccount()); // 当前设置的股票为贵州茅台，此时调用GetAccount函数获取账户资产，获取的为大陆市场账户资产\\n Log!(exchange.GetTicker(None)); // 获取股票贵州茅台当前的价格信息\\n }\\n ```\\n\\n 设置交易方向的函数```exchange.SetDirection```、下单函数```exchange.Buy```/```exchange.Sell```、\\n 撤单函数```exchange.CancelOrder```、查询订单函数```exchange.GetOrder```等，其使用方法均与期货市场相同。\\n\\n - 账户信息数据格式：\\n 使用```TrdMarket```定义市场，用以区分```香港市场```、```美国市场```与```大陆市场```。\\n\\n 摘录自[```Futu API```文档](https://openapi.futunn.com/futu-api-doc/)：\\n\\n ```go\\n const (\\n TrdMarket_TrdMarket_Unknown TrdMarket = 0 //未知市场\\n TrdMarket_TrdMarket_HK TrdMarket = 1 //香港市场\\n TrdMarket_TrdMarket_US TrdMarket = 2 //美国市场\\n TrdMarket_TrdMarket_CN TrdMarket = 3 //大陆市场\\n TrdMarket_TrdMarket_HKCC TrdMarket = 4 //香港A股通市场\\n TrdMarket_TrdMarket_Futures TrdMarket = 5 //期货市场\\n )\\n ```\\n\\n 获取账户信息数据时，```exchange.GetAccount()```函数返回：\\n\\n ```json\\n {\\n \\\"Info\\\": [{\\n \\\"Header\\\": {\\n ... // 省略\\n \\\"TrdMarket\\\": 1 // Info原始信息中，市场ID，表示该账户资产用于香港市场交易\\n },\\n \\\"Funds\\\": { // 账户在该市场的资产信息\\n ...\\n }\\n }, ...],\\n \\\"Balance\\\": 1000000, // 当前市场的资产数值\\n \\\"FrozenBalance\\\": 0\\n }\\n ```\\n\\n - ```FutuOpenD```根据登录的**IP**地址进行地区区分\\n 对于使用非大陆IP地址登录的账户，在获取行情数据时会有所限制，具体请查阅```FutuOpenD```（富途）官方文档。\", \"title\": \"交易所特殊说明\"}, {\"_src_hash\": \"56a7db617f6f890d226c38438d6259c80640da2b9dfa2fd1f043c20b42a621e5\", \"desc\": \"为兼容历史版本而保留的函数，不推荐继续使用。\\n- GetRawJSON函数\\n 该函数返回最近一次API请求的原始响应内容。例如，调用```exchange.GetAccount()```后，再调用```exchange.GetRawJSON()```可获取未经封装的原始数据。注意：易盛协议不支持此函数。\\n 目前不推荐使用此函数，建议使用优宽量化交易平台API函数返回值中的```Info```字段。例如，```exchange.GetAccount()```函数返回值的```Info```字段包含账户的原始信息。\\n- GetPosition\\n 该函数用于请求当前持仓数据。目前不推荐使用此函数，建议使用优宽量化交易平台API函数```exchange.GetPositions()```。\", \"title\": \"兼容记录\"}], \"desc\": \"优宽量化交易平台文档记录了交易所特殊说明及兼容记录。\\n\\n- 某些交易所和金融平台可能具有特定的功能或行为，需要特别注意。这些特殊说明可能包括特定市场的独特属性、交易规则或其他平台特定信息。\\n\\n- 本用户指南文档记录了优宽量化交易平台API接口的兼容性信息，帮助您了解历史版本的API。\", \"title\": \"交易所特殊说明、兼容记录\"}]","language","zh-CN","languageMode","sessionData",{"_226":24,"_227":24,"_228":133,"_229":133,"_230":24,"_95":24,"_231":24,"_232":24},"settings",{"_30":31,"_32":33},"zone","youquant","theme",{"_27":28,"_29":-7},"colorUpGreen","isWebApp",false,"cdnBase","","themeMode","system","resolvedThemeMode","appSettings",{"_71":72,"_73":74,"_75":76,"_77":78,"_79":80,"_81":82,"_83":84,"_85":86,"_87":88,"_89":90,"_91":92,"_93":94,"_95":96,"_97":98},"uiFooter",{"_34":35,"_36":37,"_38":39},"copyright",{"_40":70},"download",{"_66":67,"_68":69},"footer",{"_40":41},"zh_CN",[42,43],{"_44":55,"_46":56},{"_44":45,"_46":47},"title","产品功能","items",[48,49],{"_44":53,"_51":54},{"_44":50,"_51":52},"新建策略","url","/m/add-strategy","创建实盘","/m/add-robot","社区",[57,58,59],{"_44":64,"_51":65},{"_44":62,"_51":63},{"_44":60,"_51":61},"关于我们","/about-us","API文档","/api","回测系统","/api#回测系统","android","https://www.youquant.com/dist/youquant.apk","ios","itms-apps://itunes.apple.com/WebObjects/MZStore.woa/wa/viewSoftware?id=6496064181","© 2015 - ∞ YouQuant 豫ICP备19046564号","banner",[225],"banner_bak",[214,215,216],"nav",[180,181,182,183,184,185,186,187],"ad_bak",[176],"ad1",[173,174,175],"ad1_bak",[160,161,162],"payments",[135,136,137,138],"strategy",[117,118,119,120,121],"update",{"_66":100,"_68":101,"_102":103},"ui",{"_99":96},"datadata_snapshot","https://www.datadata.cn/web/resources/{{uuid}}/screenshot.png","chart","https://www.youquant.com/app/chart","openai",true,"timeout",15000,"show_prop_strategies",{"_104":105,"_111":112,"_106":116,"_108":67,"_102":109,"_113":114,"_34":115},{"_106":110,"_104":105,"_111":112,"_108":69,"_113":114,"_34":115},"web",{"_104":105,"_106":107,"_108":109},"version","v2.2.36","paymethod","alipay,wechat,balance,voucher","link","https://www.youquant.com/mobile","","min_version","v2.0.1","name","YouQuant","Copyright © YouQuant 版权所有","alipay,voucher",{"_122":133,"_113":134},{"_122":131,"_128":129,"_113":132},{"_122":127,"_128":129,"_113":130},{"_122":125,"_113":126},{"_122":123,"_113":124},"id",21,"交易插件|Plugin",20,"模板类库|Template",2,"currency","CNY","股票证券|Stocks",1,"商品期货|Futures",0,"通用策略|Common",{"_122":133,"_113":158,"_128":129,"_153":139,"_155":156,"_141":142,"_144":159},{"_122":131,"_113":152,"_128":129,"_153":139,"_141":154,"_155":156,"_144":157},{"_122":146,"_113":147,"_141":148,"_149":150,"_144":151},{"_122":139,"_113":140,"_141":142,"_128":143,"_144":145},3,"余额|Balance","scope","buy","USD,CNY","image","https://www.youquant.com/upload/asset/293d3a001d670070202.png",4,"充值码|Voucher","charge","type","voucher","https://www.youquant.com/upload/asset/28fa674166cb24de22b.png","微信|Wechat","amount","charge,buy","platform","ios,android,web","https://www.youquant.com/upload/asset/254280ff997ba19946e.png","支付宝|Alipay","https://www.youquant.com/upload/asset/2557c01a8ebd75f791b.png",{"_144":170,"_164":171,"_108":172},{"_144":167,"_164":168,"_108":169},{"_144":163,"_164":165,"_108":166},"/upload/asset/15ce9c5df17eb9af463.png","image_dark","/upload/asset/309f2b0743dd12d5659.png","/bbs-topic/8284","/upload/asset/2b85d8e0029712de49d.png","/upload/asset/27b5928f8282ebe1864.png","/bbs-topic/8278","/upload/asset/f11efa83c5ac16f7c3.png","/upload/asset/1b3a7138563976cf4fc.png","/bbs-topic/9426",{"_144":167,"_164":168,"_108":169},{"_144":167,"_164":168,"_108":169},{"_144":163,"_164":165,"_108":166},{"_144":177,"_164":178,"_108":179},"/upload/asset/2c2c9521b3a6d0ee73b.png","/upload/asset/2c77ab5db219dc3e78f.png","/bbs-topic/8251",{"_113":211,"_144":212,"_108":213},{"_113":206,"_207":208,"_144":209,"_108":210},{"_113":203,"_144":204,"_108":205},{"_113":200,"_144":201,"_108":202},{"_113":197,"_144":198,"_108":199},{"_113":194,"_144":195,"_108":196},{"_113":191,"_144":192,"_108":193},{"_113":188,"_144":189,"_108":190},"消息中心|Message","/upload/asset/274a5fd7d23a979cd11.png","/messages","工单|Ticket","/upload/asset/236a747e72e6c33dc8cba.png","/tickets","交易所|Platform","/upload/asset/318b4addb664da55ea6.png","/platforms","交易终端|Trade","/upload/asset/236093e259ec86facf025.png","/trade","社区|Forum","/upload/asset/2e5a8b06b92e5f1357f.png","/bbs","文库|Digest","/upload/asset/237076e895993c78000f3.png","/digest","围观|Live","size",30,"/upload/asset/2f23fcaecaa612555f5.png","/live","策略广场|Square","/upload/asset/36bba6d48d47a6689f3.png","/square",{"_144":223,"_164":224,"_108":172},{"_144":220,"_164":221,"_108":222},{"_144":217,"_164":218,"_108":219},"/upload/asset/2242824e9ebd296493e.png","/upload/asset/360d0a9affe35a1bbd2.png","/strategy/325989","/upload/asset/235fc31c8de7ecd772625.png","/upload/asset/236a84369ede6689965bf.png","/bbs-topic/9085","/upload/asset/2367b0dc455db90d738c8.png","/upload/asset/236acaf94edaeb6759e57.png",{"_144":217,"_164":218,"_108":219},"isAuthenticated","isShadow","balance","fee","isAdmin","hasTwofactor","hasPassword"]

名称	描述
TA指标库	优宽量化的TA指标库优化了常用指标算法，支持JavaScript、Python、Rust语言的策略调用。
talib指标库	以下是CCI指标调用示例代码，更多talib指标函数请参阅语法手册的talib分类。
JavaScript库	http://ta-lib.org/