[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":-7,"_24":25,"_26":27},"lang/routes/app/user-guide.$",{"_9":10},"userGuide","[{\"_src_hash\": \"7162dbcc22b2aac7d305ff403ffe19580e849ba726edea2f04004185f7035f1f\", \"children\": [{\"_src_hash\": \"3ef6f61641e672143ce8e5d223cc859f715d5db5707f639a855b3389bfabe97e\", \"children\": [], \"desc\": \"发明者量化交易平台（FMZ量化）是一个量化交易平台：在网页上编写策略、在线回测，然后在自己部署或租用的托管者上运行实盘；也可以在策略广场学习、分享、出租策略，或公开展示自己的实盘。\\n\\n**支持的市场**\\n- 加密货币：主流中心化交易所的现货、期货与永续合约，以及部分链上交易所。\\n- 证券与期货：富途证券、盈透证券（Interactive Brokers）等。\\n- 平台尚未对接的交易所，可以通过{@平台基础/交易所/通用协议通用协议}自行接入。\\n\\n**支持的策略语言**\\nJavaScript、TypeScript、Python、Rust、PINE、My语言（麦语言）、Blockly可视化和Workflow工作流，见{@编写策略/编程语言编程语言}。\\n\\n**AI 辅助**\\n- 策略编辑器内置{@开发工具/策略编辑器/AI助手 AI助手}，可以生成、解释、修改策略代码并分析回测结果。\\n- 也可以把自己使用的外部 AI 助手接入平台，通过对话管理策略、回测和实盘，见{@对外接口/AI接入 AI接入}。\\n\\n**控制台**\\n注册并登录后进入[控制台](https://www.fmz.com/m)：\\n\\n![控制中心概览](/upload/asset/2e4e636a6fe51c8f620e8.png)\\n\\n- [控制中心](https://www.fmz.com/m/dashboard)：账户概况和常用功能入口。运行一个实盘需要三样东西：一个在线的托管者、一个策略、一个配置好的交易所账户。\\n- [实盘](https://www.fmz.com/m/robots)：创建、管理、控制实盘。实盘即运行中的策略程序实例。\\n- [策略库](https://www.fmz.com/m/strategies)：编写、保存、分组管理各种语言的策略。\\n- [托管者](https://www.fmz.com/m/nodes)：部署和管理运行策略的托管者程序。\\n- [交易所](https://www.fmz.com/m/platforms)：添加和管理交易所账户。\\n\\n**平台公共资源**\\n- [策略广场](https://www.fmz.com/square)：公开分享或上架出租的策略，适合学习和参考。\\n- [实盘围观](https://www.fmz.com/live)：用户公开展示的实盘。\\n- [文库](https://www.fmz.com/digest)：平台原创文章。\\n- [社区](https://www.fmz.com/bbs)：交流、讨论量化交易的论坛。\\n- [众包](https://www.fmz.com/markets)：发布和承接策略开发需求。\\n- [公开课](https://www.fmz.com/class)：视频教程。\\n- [API文档](https://www.fmz.com/api)：策略编写的API语法手册。\\n\\n**获取帮助**\\n遇到问题可以在社区发帖、在控制台提交工单，或在[Telegram](https://t.me/fmzquant_cn)社群联系管理员。\", \"title\": \"欢迎使用发明者量化交易平台\"}, {\"_src_hash\": \"83cd038239fa9dbefac1e25aeeb1bcd4b6eae8fb60e07444c63bd99bda231769\", \"desc\": [\"从添加交易所到运行第一个实盘，按下面五步完成，每一步后面标了详细说明所在的章节。\\n\\n**1. 添加交易所账户**\\n\\n在控制中心的「交易所」页面添加交易所的API KEY。API KEY只开启读取和交易权限，不要开启提现；第一次使用建议先用交易所的模拟盘或小额子账号。见{@平台基础/交易所交易所}和{@入门/密钥安全性密钥安全性}。\\n\\n**2. 部署托管者**\\n\\n托管者是运行策略的程序，策略和实盘都运行在托管者上。可以一键租用平台提供的托管者，也可以部署在自己的服务器上。见{@平台基础/托管者托管者}。\\n\\n**3. 编写策略**\\n\\n在「策略库」新建策略并选择编程语言。策略由入口函数```main()```和其中的主循环构成：每轮获取行情、计算信号、下单，然后休眠等待下一轮。见「编写策略」，其中{@编写策略/策略结构策略结构}有各语言的主循环模板和全部API函数的速查表。也可以从策略广场复制一个公开策略开始。\\n\\n**4. 回测**\\n\\n在策略编辑页面选择交易所、交易对、时间范围和K线周期后开始回测，检查收益曲线、交易记录和日志。回测通过后再上实盘。见{@回测系统/概述与发起回测回测系统}。\\n\\n**5. 创建实盘**\\n\\n在控制中心的「实盘」页面新建实盘，选择策略、托管者和交易所账户，设置策略参数后启动。实盘按小时计费，启动前账户里需要有余额，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。运行状态、日志和收益在实盘页面查看，异常可以推送到手机。见{@平台基础/实盘实盘}。\\n\\n之后可以按需阅读：「开发工具」介绍编辑与调试，「进阶专题」介绍限流、实盘间通信、多线程和链上交易，「对外接口」介绍用程序或AI助手操作平台。\"], \"title\": \"快速开始\"}, {\"_src_hash\": \"7fa17de84cd668050bc16fe3df2eac85da33091051bf2c600d8fb4ed77e105fc\", \"children\": [], \"desc\": \"交易所密钥一旦泄露，损失的是交易所账户里的资产。配置交易所账户前，按下面的清单检查一遍：\\n\\n- **只开交易权限**：API KEY只开启读取和交易权限，**不要开启提现**。\\n- **绑定 IP 白名单**：在交易所把API KEY绑定到托管者所在服务器的出口IP。服务器有多个IP时，用托管者的```-I```参数固定出口IP，见{@平台基础/托管者/命令行参数命令行参数}。\\n- **私钥留在本地**：交易所支持RSA等非对称密钥时优先使用；私钥以凭据文件的形式放在托管者所在的机器上，平台只保存文件路径，见{@平台基础/交易所/本地凭据文件本地凭据文件}。\\n- **先小额试运行**：第一次运行新策略时使用交易所的模拟盘或小额子账号。\\n- **不公开敏感信息**：策略代码、参数、描述里如果写了密钥、账号等信息，不要公开或出售该策略。\\n\\n平台如何保存密钥：在交易所配置页面填写的密钥等加密字段，在浏览器端用平台账号密码加密后才上传，平台不保存明文；只有用账号密码启动的托管者能在本地解密。因此修改平台账号密码后，原有的交易所配置会失效，处理方法见{@平台基础/实盘/实盘报错、异常退出的常见原因实盘报错、异常退出的常见原因}。\", \"title\": \"密钥安全性\"}], \"desc\": \"第一次使用先读这里：认识平台、从添加交易所到运行实盘的五个步骤、密钥的安全设置。\", \"title\": \"入门\"}, {\"_src_hash\": \"6225a664f37b8f24c6b5de49be1f35fed4bf5afa4f02b04bdc6ba9691e8c1b99\", \"children\": [{\"_src_hash\": \"88d3987d19eb9dcf585de4c3fcae1249e4ed59a119cc6ce1e5419b7360e976c0\", \"children\": [{\"_src_hash\": \"b764ee5fb44f9801157f9e44937371750c63663ce0934b33ec060423d8caf8ae\", \"desc\": \"**实盘计费**\\n- 实盘按小时计费，每个实盘每小时 0.05 USD，不足一小时按一小时计费。\\n- 创建实盘即开始计费，启动时需要预付第一个小时，账户余额不足时实盘无法启动。实盘「停止」/「重启」不会重复计费。\\n- 实盘运行中账户余额耗尽时，平台会停止该实盘；租用的策略到期时，使用该策略的实盘同样会被停止。\\n- 一键租用托管者的服务器费用单独计费，与实盘计费无关，见{@平台基础/托管者/部署托管者/一键租用托管者一键租用托管者}。\\n\\n**查询账单与余额预警**\\n- 在[充值页面](https://www.fmz.com/m/billing)可以查看余额、充值记录和所有计费的账单明细。\\n- 在[账号设置的额度预警](https://www.fmz.com/m/account#alertthreshold)中设置预警阈值：可用余额低于该值时会收到邮件和微信通知（24小时内最多通知一次，充值或修改设置后重新计算）；设置为0表示关闭。\\n\\n**充值**\\n在[充值页面](https://www.fmz.com/m/billing)选择充值方式和金额。使用```USDT```充值时务必注意：\\n- 转账网络必须与充值页面选择的网络一致，目前支持TRC20、ERC20、BSC。ERC20与BSC的地址都以```0x```开头，格式相同，最容易选错。\\n- 充值资产选择```USDT```。\\n- 转账地址与充值页面显示的地址一致。\", \"title\": \"实盘计费与充值\"}, {\"_src_hash\": \"90a760361f505c39904442e2d304353865eeac9a48df3eed34e58c4e6327d404\", \"desc\": \"子账号用来把部分实盘交给他人查看和操作，而不交出主账号。\\n\\n**创建子账号**\\n在[账号设置页面](https://www.fmz.com/m/account#shadowmember)打开子账号页签，在操作权限中选择该子账号可以访问的实盘，填写子账号的用户名和登录密码后创建。创建后的子账号显示在同一页面，可以修改、锁定/解锁、删除。\\n\\n![子账号设置](/upload/asset/2e46d725dbe6b471f1b33.png)\\n\\n**子账号的权限**\\n子账号只能看到授权给它的实盘。对这些实盘可以修改参数、停止、重启，但不能修改实盘配置的交易所对象。\\n\\n**常见用途**\\n- 量化团队分工管理多个实盘。\\n- 出租策略时，让租用方协助调试实盘。\", \"title\": \"子账号\"}], \"desc\": \"实盘怎样计费、如何充值，以及如何用子账号把部分实盘交给他人管理。账号的其它设置（推送、二次验证、API接口等）在[账号设置页面](https://www.fmz.com/m/account)。\", \"title\": \"账号与计费\"}, {\"_src_hash\": \"9dfb9ca3945e3681944bc6ef85d101c759fd3e876fbe0f58d07c1d6f275cd6d1\", \"children\": [{\"_src_hash\": \"6eaace6109f13f7ef7e2ff3be168f54102a9248dd20504eaad4d35d0474161da\", \"children\": [], \"desc\": \"对于发明者量化交易平台尚未封装对接的交易所API接口，可通过编写通用协议插件程序进行接入。\\n\\n![通用协议配置截图](/upload/asset/2e43b059b3ec9f42ded6e.png)\\n\\n该通用协议可用于接入任何提供API接口的交易所，支持以下两种协议：\\n- ```REST```协议：[参考文档](https://www.fmz.com/digest-topic/10518)。\\n- ```FIX```协议：[参考项目](https://github.com/fmzquant/fixc)。\\n\\n```FIX```协议插件程序与```REST```协议插件程序的区别仅在于插件程序与交易所接口的交互方式不同。协议插件程序与发明者量化托管者程序的交互方式、数据格式等细节处理完全相同，具体实现可参考上述链接中的示例。\", \"title\": \"通用协议\"}, {\"_src_hash\": \"d86def8cbead5db631c9471a9ff50663b1325be3ba7108340d28009ff61d4cec\", \"desc\": \"配置交易所时，所有带掩码的加密输入框（Secret Key、私钥、密码等）都可以不填写内容本身，而填写一个凭据文件路径```file:///文件名.txt```。实盘运行时，托管者从本机读取该文件的内容作为这一项的值。这样私钥只存在于托管者所在的机器上，平台上保存的只是一个路径。\\n\\n**路径规则**\\n- 路径相对于**本实盘的目录**```logs/storage/<实盘ID>/```解析（```logs```位于托管者的工作目录下）。例如实盘ID为```123456```时，```file:///rsaKey.txt```对应```logs/storage/123456/rsaKey.txt```。\\n- 可以有子目录，例如```file:///keys/rsaKey.txt```。\\n- 只认```.txt```后缀；其它后缀不会当作文件读取，而是把这串文字原样作为配置值。\\n- 路径不能是绝对路径，不能包含```..```，解析后也不能跳出实盘目录（指向目录外的符号链接同样不行）。\\n- 凭据文件按实盘目录读取，多个实盘使用同一个交易所配置时，每个实盘的目录里都要放一份。\\n- 文件读不到时实盘启动失败，报错中包含```read key file```；路径不合法时报错为```key file path must be relative and cannot contain '..'```或```key file path escapes the robot directory```。\\n\\n**示例：使用 RSA 密钥**\\n以支持```RSA KEY```验证的交易所为例：\\n1. 生成RSA公钥和私钥，例如用```openssl```生成PKCS#8格式的密钥对。\\n2. 在交易所创建```RSA KEY```，上传第1步生成的公钥。\\n3. 在平台配置交易所：```Access Key```填写交易所创建的```RSA KEY```，```Secret Key```填写```file:///rsaKey.txt```。\\n4. 创建实盘，得到实盘ID（例如```123456```）。\\n5. 把第1步生成的私钥保存为```logs/storage/123456/rsaKey.txt```，然后启动（或重启）实盘。\\n\\n详细过程可以参考[视频讲解](https://www.bilibili.com/video/BV1UM41147Jj/)。\", \"title\": \"本地凭据文件\"}, {\"_src_hash\": \"b833097ce6331381104b2a51a860095935a7edd61e5a45d0fe84ec1b646bbb71\", \"children\": [{\"_src_hash\": \"aab381d8f248c69ad3716adbbe2199a6740abfba767e28c54e9560d11134956c\", \"desc\": \"**富途证券**\\n\\n支持富途牛牛的实盘交易和模拟交易，需要在托管者所在的机器上运行[```FutuOpenD```](https://www.futunn.com/download/OpenAPI?lang=zh-CN)。配置交易所对象、运行```FutuOpenD```等操作参看[富途证券配置说明文档](https://www.fmz.com/bbs-topic/10185)。\\n\\n使用```FutuOpenD```接入模拟交易时，有些股票代码不支持，因而无法交易（富途牛牛手机App上可以模拟交易）。\\n\\n- 接口调用频率\\n ```GetOrder```、```GetOrders```、```GetPositions```、```GetAccount```默认使用**缓存数据**，不限制调用频率；```FutuOpenD```收到新数据时会自动更新缓存。\\n 调用```exchange.IO(\\\"refresh\\\", true)```可以禁用缓存，禁用后的调用频率为**每30秒内最多10次查询**，超过会报错。\\n\\n- 股票代码\\n 格式为```代码.市场```，例如```600519.SH```。市场后缀：\\n - HK：港股\\n - US：美股\\n - SH：沪市\\n - SZ：深市\\n - SG：新加坡期货\\n - JP：日本期货\\n\\n 在策略中用```exchange.SetContractType()```设置股票代码，例如：\\n\\n ```js\\n function main() {\\n var info = exchange.SetContractType(\\\"600519.SH\\\") // 设置为股票600519.SH（贵州茅台），账户切换到A股市场\\n Log(info)\\n Log(exchange.GetAccount()) // 当前股票是茅台，GetAccount返回A股市场的账户资产\\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（贵州茅台），账户切换到A股市场\\n Log!(info);\\n Log!(exchange.GetAccount()); // 当前股票是茅台，GetAccount返回A股市场的账户资产\\n Log!(exchange.GetTicker(None)); // 获取茅台的当前行情\\n }\\n ```\\n\\n 设置交易方向的```exchange.SetDirection```、下单的```exchange.Buy```/```exchange.Sell```、撤单的```exchange.CancelOrder```、查询订单的```exchange.GetOrder```等函数，用法与期货市场相同。\\n\\n- 账户信息\\n 富途用```TrdMarket```区分香港市场、美国市场、大陆市场等。以下摘自[```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 \\\"Stocks\\\": 0,\\n \\\"FrozenStocks\\\": 0,\\n \\\"Balance\\\": 1000000, // 当前市场的资产\\n \\\"FrozenBalance\\\": 0\\n }\\n ```\\n\\n- ```FutuOpenD```按登录的**IP**地址区分地区，非大陆IP登录的账户获取行情时有所限制，具体查阅```FutuOpenD```（富途）官方文档。\\n\\n**盈透证券（Interactive Brokers）**\\n\\n- 配置交易所\\n 需要在托管者所在的机器上运行「IB Gateway」或「TWS（Trader Workstation）」。以TWS为例：登录后点击右上角的配置按钮，选择「配置」→「API」→「设置」，**不要**勾选「只读API」，勾选「启用ActiveX和套接字客户端」，并记下「套接字端口」（TWS默认实盘7496、模拟盘7497；IB Gateway默认实盘4001、模拟盘4002）。\\n 然后在平台的[交易所添加页面](https://www.fmz.com/m/add-platform)选择**盈透证券（Interactive Brokers）**：\\n - 服务器地址：TWS或IB Gateway的地址和端口，例如```localhost:7496```。\\n - 行情类型：实时数据、冻结数据、延迟数据、延迟冻结数据之一。没有订阅实时行情的账户可以选择延迟数据。运行中也可以用```exchange.IO(\\\"marketDataType\\\", n)```切换（```n```为1到4，顺序同上）。\\n\\n- 合约代码\\n 用```exchange.SetContractType()```设置，格式为```代码.货币[.类型[.交易所]]```，类型缺省为股票```STK```，交易所缺省为```SMART```：\\n - 美股：```AAPL.US```、```TSLA.US```（```US```表示美元计价）。\\n - 港股：```代码.HK```（```HK```表示港币计价）。\\n - 期货（```FUT```）：```代码-到期月份[-乘数].货币.FUT.交易所```，到期月份写成```YYYYMM```，交易所为IB的交易所代码。\\n - 期权（```OPT```）与期货期权（```FOP```）：```代码-到期-C或P-行权价×100[-乘数].货币.OPT或FOP.交易所```，行权价乘以100后写成整数。\\n - 纯数字：直接作为IB的合约ID（conId）。\\n\\n- 其它说明\\n - 托管者以实盘ID作为连接TWS的客户端号（clientId），实盘重启后客户端号不变，仍可撤销、修改此前挂出的订单。TWS只允许订单的原始客户端号（或主客户端）修改、撤销订单。\\n - 持仓、订单的```Symbol```是简写形式（如```Z74.SGD```），```exchange.GetPositions()```、```exchange.GetOrders()```传入简写或下单时用的完整代码（如```Z74.SGD.STK.SGX```）都可以。\\n - 订单被网关拒绝时，订单```Info```中的```Reject```字段记录拒单原因。\\n - ```exchange.IO(\\\"debug\\\", true)```开启后，与TWS收发的每一帧按TWS API日志的格式输出到日志，便于与网关日志对照排查。\", \"title\": \"证券与期货\"}, {\"_src_hash\": \"d5a9c56da9a44d86e6a21a635f2b3c664fef9da68c1fd2241c057dc9e8252f06\", \"desc\": \"- Futures_Binance\\n 支持币安的中文交易对：\\n\\n ```js\\n function main() {\\n let ticker = exchange.GetTicker(\\\"币安人生_USDT.swap\\\")\\n Log(\\\"ticker:\\\", ticker) // {\\\"Info\\\":{...},\\\"Symbol\\\":\\\"币安人生_USDT.swap\\\",\\\"Open\\\":0.29622,\\\"High\\\":0.31661, ...}\\n }\\n ```\\n\\n 币安期货的```exchange.IO()```切换功能（双向持仓、逐仓/全仓、统一账户、STP模式等）见{@fun/IO/exchange.IO exchange.IO}。\\n- Futures_HuobiDM\\n 使用```exchange.IO(\\\"base\\\", \\\"https://xxx.xxx.xxx\\\")```或```exchange.SetBase(\\\"https://xxx.xxx.xxx\\\")```切换交易所接口的基地址。\\n\\n 火币期货的```exchange.IO()```切换功能（signHost、逐仓/全仓、单向/双向持仓、统一账户等）见{@fun/IO/exchange.IO exchange.IO}。\\n\\n 条件单不支持OCO类型（```ORDER_CONDITION_TYPE_OCO```）；多资产保证金模式下同样可以使用条件单。\\n- Huobi\\n 支持火币的中文交易对：\\n\\n ```js\\n function main() {\\n let ticker = exchange.GetTicker(\\\"币安人生_USDT\\\")\\n Log(\\\"ticker:\\\", ticker) // {\\\"Info\\\":{...},\\\"Symbol\\\":\\\"币安人生_USDT\\\",\\\"Open\\\":0.29622,\\\"High\\\":0.31661, ...}\\n }\\n ```\\n- Bitfinex\\n 现货市价买单的下单量是交易币数，不是金额。\\n- AscendEx\\n 现货市价买单的下单量是交易币数，不是金额。\\n- Futures_Hyperliquid\\n 参考[Hyperliquid 使用指南](https://www.fmz.com/digest-topic/10574)。\\n\\n Hyperliquid期货的```exchange.IO()```切换功能（逐仓/全仓、主网/测试网、vaultAddress、walletAddress、expiresAfter等）见{@fun/IO/exchange.IO exchange.IO}。\\n- Futures_Lighter\\n 测试环境可以在配置交易所对象时勾选，也可以用```exchange.SetBase()```修改REST API端点切换到测试环境。\\n\\n Futures_Lighter的```exchange.IO()```切换功能（逐仓/全仓、订单过期时间等）见{@fun/IO/exchange.IO exchange.IO}。\\n\\n ```exchange.GetTickers()```返回的```Buy```、```Sell```是各品种的最新成交价（交易所没有批量盘口接口）；需要买一、卖一价时用```exchange.GetTicker()```或```exchange.GetDepth()```。\\n- Futures_edgeX\\n edgeX的永续合约都以USDC计价，交易对写作```BTC_USDC```等，完整代码形如```BTC_USDC.swap```；写成```BTC_USDT```、```BTC_USD```会提示合约不存在。\\n- Poloniex\\n 现货条件单只支持止损（```ORDER_CONDITION_TYPE_SL```）：买单在价格涨到触发价时触发，卖单在价格跌到触发价时触发。止盈（```ORDER_CONDITION_TYPE_TP```）和OCO条件单会直接报错，不会下单。\", \"title\": \"加密货币\"}], \"desc\": \"个别交易所的配置方法，以及与通用接口行为不同的地方。没有列出的交易所按语法手册中的通用说明使用；各交易所```exchange.IO()```支持的切换功能见{@fun/IO/exchange.IO exchange.IO}。\", \"title\": \"交易所特殊说明\"}], \"desc\": \"[交易所](https://www.fmz.com/m/platforms)页面用来管理已配置的交易所账户。在发明者量化交易平台中，「交易所」指一个可供策略程序操作的账户：它包含资金账户的密钥配置，以及与该交易所通信的协议和接口封装。\\n\\n在交易所管理页面点击「添加交易所」进入[交易所添加页面](https://www.fmz.com/m/add-platform)，按需选择交易所并填写配置。密钥等加密字段在浏览器端加密后才保存到平台，平台不记录明文，见{@入门/密钥安全性密钥安全性}。\\n\\n**交易所对象**\\n配置好的交易所在策略代码中就是交易所对象{@var/EXCHANGE/exchange exchange}。配置回测或实盘时可以添加多个交易所，在代码中对应交易所对象数组{@var/EXCHANGE/exchanges exchanges}。\\n\\n**使用交易所对象**\\n在策略代码中通过交易所对象读取账户和行情、下单、撤单，以```JavaScript```为例：\\n\\n```js\\nfunction main() {\\n let account = exchange.GetAccount() // 查询账户信息\\n let ticker = exchange.GetTicker() // 获取ticker行情\\n let id = exchange.Buy(1000, 1) // 价格为1000，下单量为1\\n if (id) {\\n exchange.CancelOrder(id) // 下单成功才有订单Id，订单未成交时可以撤单\\n }\\n}\\n```\\n\\n本章其余内容：\\n- {@平台基础/交易所/通用协议通用协议}：接入平台尚未对接的交易所。\\n- {@平台基础/交易所/本地凭据文件本地凭据文件}：把私钥等敏感信息只保存在托管者所在的机器上。\\n- {@平台基础/交易所/交易所特殊说明交易所特殊说明}：个别交易所的配置方法和与通用行为不同之处。\", \"title\": \"交易所\"}, {\"_src_hash\": \"bc4853141a2f0ff40439f5883c23c8f2f36688363c559aadc6729099a27a3266\", \"children\": [{\"_src_hash\": \"e9b9ee2b500025633a2a4ec0c496f886a5e409c0274abfff771d705e92ff3e39\", \"children\": [{\"_src_hash\": \"6e5941289f81b4a4cbfe703ed43ba507ca2630de6b3763f0551d3b03f98bfa14\", \"desc\": \"在[托管者部署页面](https://www.fmz.com/m/add-node)点击**一键租用托管者**标签，根据配置、服务器机房地区等需求选择需要部署的服务器。\\n\\n点击「立即购买」并输入当前发明者量化交易平台的账号密码进行验证，验证通过后将自动进行托管者程序部署。整个部署过程需要几分钟时间，系统会自动安装常用的Python库。\\n\\n点击「立即购买」后租用的服务器由于是通过平台代为租用，仅具有有限的系统权限，不支持远程登录。如果需要使用未预装的第三方Python库，建议使用私有服务器进行手动部署。\\n\\n通过**一键租用托管者**功能租用的服务器采用独立计费方式，与实盘计费相互独立。\\n\\n点击「重新部署」按钮不会删除托管者目录下logs目录中的实盘日志和数据文件。\", \"title\": \"一键租用托管者\"}, {\"_src_hash\": \"0ff04ef2b5a299f15b931d78dcb10b48706e47d1f7757c12f7e2b870cd125c9b\", \"desc\": \"可以把托管者部署在个人电脑、服务器、树莓派（64位系统）等设备上。托管者只发布64位版本：\\n- Linux命令行版：x86_64（amd64）、ARM64（aarch64）\\n- macOS命令行版：Intel、Apple Silicon\\n- Windows：x64、ARM64，各有命令行版和界面版\\n\\n在[托管者部署页面](https://www.fmz.com/m/add-node)点击**手动部署托管者**，按系统下载对应的托管者程序并解压，可执行文件```robot```即托管者程序。同一页面还显示部署需要的两项信息：\\n\\n![手动部署托管者页面](/upload/asset/2e460507bc21582ba1448.png)\\n\\n1. 通信地址：包含账号UID，形如```node.fmz.com/123456```。\\n2. 密码：UID对应的发明者量化交易平台账号的密码。\\n\\n**Windows界面版**\\n运行```robot.exe```，在界面上填写通信地址和密码，点击启动。\\n\\n**命令行版**\\n```bash\\nchmod +x robot # Linux/macOS 首次运行前加上执行权限\\n./robot -s node.fmz.com/123456 # 启动后提示输入密码，输入时不回显\\n```\\n\\n```123456```只是示例，实际的通信地址在托管者部署页面查看。不要用```-p```在命令行里写明文密码，它会留在shell历史和进程列表里；需要无人值守启动时，把地址和密码写进只有自己可读的配置文件```robot.conf```：\\n\\n```bash\\ncat > robot.conf <<'EOF'\\ns=node.fmz.com/123456\\np=你的密码\\nEOF\\nchmod 600 robot.conf\\n./robot -c robot.conf # 启动目录下有robot.conf时，直接 ./robot 也会自动加载\\n```\\n\\n全部参数和配置文件格式见{@平台基础/托管者/命令行参数命令行参数}。\\n\\n**在后台运行**\\n托管者忽略终端挂断信号：在SSH里前台启动后直接断开连接，托管者会继续运行，运行日志同时写在```logs/docker.log```。需要开机自启或崩溃后自动拉起时，可以用systemd等服务管理器运行，例如```/etc/systemd/system/robot.service```：\\n\\n```ini\\n[Unit]\\nDescription=FMZ robot\\nAfter=network-online.target\\nWants=network-online.target\\n\\n[Service]\\nWorkingDirectory=/opt/robot\\nExecStart=/opt/robot/robot -c /opt/robot/robot.conf\\nRestart=on-failure\\nTimeoutStopSec=90\\n\\n[Install]\\nWantedBy=multi-user.target\\n```\\n\\n```bash\\nsudo systemctl daemon-reload\\nsudo systemctl enable --now robot\\n```\\n\\n```systemctl stop robot```发送的```SIGTERM```会让托管者优雅退出：先停止其上的所有实盘、上报状态，再从平台下线。```TimeoutStopSec```留出足够的时间，避免收尾未完成就被强制结束。\\n\\n**升级托管者**\\n策略运行时和交易所连接器由平台按需下发，不需要手动更新。升级托管者程序本身：先停止托管者（见{@平台基础/托管者/部署托管者/托管者操作注意事项托管者操作注意事项}），用新版本替换```robot```可执行文件，再在**同一工作目录**启动。工作目录下的```logs```目录保留了托管者身份和实盘数据，启动后沿用原来的托管者ID。\\n\\n**用Docker容器隔离策略进程**\\nLinux和macOS的命令行版可以用```-i```参数让每个策略进程运行在独立的Docker容器里（需要本机已安装并运行Docker）。这是策略进程的隔离方式，不是托管者本身的Docker镜像，参数见{@平台基础/托管者/命令行参数命令行参数}。\", \"title\": \"手动部署托管者\"}, {\"_src_hash\": \"98ef7baf0e428ce1686765ebd45dde53b71ae2afab550d3dcb29bc6f09abecf9\", \"desc\": \"**先停实盘，再停托管者**\\n删除托管者或停止托管者进程前，先确认它上面没有运行中的实盘。\\n\\n**正常停止托管者**\\n- 命令行版：在终端按一次```Ctrl+C```，或向进程发送```SIGTERM```（```kill ```、```systemctl stop```）。\\n- Windows界面版：点击界面上的停止按钮。\\n\\n托管者收到停止指令后会优雅退出：先停止其上的所有实盘、上报最终状态，再从平台下线。收尾期间再按一次```Ctrl+C```会跳过状态上报和下线，直接退出，一般不要这样做。\\n\\n**避免强制结束**\\n不要用```kill -9```结束托管者进程，也不要直接断电或强制关机。这样托管者来不及下线，平台上的实盘可能仍显示为运行中并继续计费；出现这种情况，需要先删除已离线的托管者，才能停止这些实盘。重启服务器前先停止托管者；用systemd等服务管理器运行时，系统关机会自动发送```SIGTERM```。\", \"title\": \"托管者操作注意事项\"}], \"desc\": \"[托管者管理页面](https://www.fmz.com/m/nodes)列出当前账号下的托管者，可以切换列表或详细信息展示，查看托管者的IP地址、版本、编译时间等信息。点击**部署托管者**进入[托管者部署页面](https://www.fmz.com/m/add-node)，有两种方式：一键租用托管者、手动部署托管者。\\n\\n![托管者部署页面](/upload/asset/2e527e497b3fa27ba497b.png)\", \"title\": \"部署托管者\"}, {\"_src_hash\": \"97578eb6b2349d9d2d2161be5b56441b49d99f678069af82eded35a07955d9a5\", \"desc\": \"命令行版托管者程序```robot```的启动方式：\\n\\n```bash\\n./robot -s node.fmz.com/123456 # 启动后交互输入密码（不回显）\\n./robot node.fmz.com/123456 # 简写：robot 地址 [密码]\\n./robot -c robot.conf # 从配置文件读取参数\\n./robot -v # 查看版本\\n```\\n\\n**参数**\\n\\n| 参数 | 说明 |\\n| --- | --- |\\n| ```-s 地址``` | 与平台通信的地址，形如```node.fmz.com/123456```（```123456```为账号UID），可带```ws://```或```wss://```前缀。在[托管者部署页面](https://www.fmz.com/m/add-node)查看。 |\\n| ```-p 密码``` | 账号密码。不建议使用：明文密码会留在shell历史和进程列表中。不给时启动后交互输入，或写在配置文件里。 |\\n| ```-n 名称``` | 托管者名称，显示在平台的托管者页面上。 |\\n| ```-w 目录``` | 工作目录。```logs```（实盘数据、托管者日志、身份文件）都在这个目录下。 |\\n| ```-c 文件``` | 配置文件，格式见下文。 |\\n| ```-u 用户``` | 仅Linux/macOS：以该系统用户运行策略进程，托管者本身需要以root运行。使用```-i```时忽略。 |\\n| ```-I IP``` | 指定本机出口IP，托管者与平台的连接以及策略访问交易所的连接都绑定这个地址，见下文。 |\\n| ```-i 镜像``` | 仅Linux/macOS：用该Docker镜像为每个策略进程创建独立容器运行，需要本机已安装并运行Docker。 |\\n| ```-e 路径``` | 配合```-i```：容器内的可执行文件路径。 |\\n| ```-f JSON``` | 配合```-i```：Docker容器设置，可以直接写JSON，也可以写```@文件路径```从文件读取。 |\\n| ```-H 地址``` | 配合```-i```：容器回连宿主机的地址。 |\\n| ```-vv``` | 输出详细日志（托管者与平台的交互消息等），默认不输出，以免日志膨胀。 |\\n| ```-d DNS``` | 旧版的自定义DNS参数，仍可接受但会被忽略，托管者一律使用系统的DNS解析。 |\\n| ```-v```、```-V```、```--version``` | 打印版本和编译信息后退出。 |\\n| ```-h```、```--help``` | 打印用法。 |\\n| ```--ctl-stdin``` | 从标准输入读取控制指令（没有```-p```时第一行为密码），收到```stop```或输入结束时优雅退出。供把托管者封装成服务的程序使用。 |\\n\\n取值型参数也可以写成```-参数=值```，例如```-n=server01```。参数写错时打印用法并退出。\\n\\n**配置文件 robot.conf**\\n每行一个```键=值```，键是参数名去掉```-```（```s p n w u I d i e f H vv```），```#```开头的行是注释：\\n\\n```ini\\n# robot.conf\\ns=node.fmz.com/123456\\np=你的密码\\nn=server01\\nvv=true\\n```\\n\\n- 用```-c```指定配置文件；没有```-c```也没有给出通信地址时，如果启动目录下有```robot.conf```，会自动加载。\\n- 同一项命令行和配置文件都给了时，以命令行为准。\\n- 键区分大小写：```I```是出口IP，```i```是Docker镜像。\\n- 配置文件路径和```-f @文件```都相对启动目录解析（在```-w```切换目录之前）。\\n- 配置文件里有密码，记得设置只有自己可读（```chmod 600 robot.conf```）。\\n\\n**指定出口IP（-I）**\\n服务器有多个IP地址，而交易所API KEY绑定了其中某个IP的白名单时，用```-I```指定出口IP，例如```./robot -s node.fmz.com/123456 -I 192.168.1.100```。指定后托管者与平台的连接、策略访问交易所的连接都从该地址发出。使用```-i```容器隔离时，容器的网络里可能没有这个地址，此时需要让容器使用宿主机网络。\\n\\nWindows界面版没有IP设置，需要指定出口IP时请使用命令行版。界面版只接受```-s```、```-p```、```-n```三个启动参数，用于预填界面，同时给出```-s```和```-p```时自动启动。\", \"title\": \"命令行参数\"}, {\"_src_hash\": \"b2dca0be6da90267676a266efa14fc936b034cdad9299d93984d3ef693d073a1\", \"desc\": \"每个实盘的数据都在托管者工作目录下的```logs/storage/<实盘ID>/```目录里（数据库```<实盘ID>.db3```、```stdout.log```、```stderr.log```等）。平台显示的实盘日志、收益、图表都是从运行该实盘的托管者上读取的。\\n\\n**把单个实盘迁移到另一台机器的托管者**\\n1. 停止该实盘。\\n2. 把整个```logs/storage/<实盘ID>/```目录复制到新托管者工作目录下的相同位置，目录名保持为实盘ID。\\n3. 在实盘配置中把托管者改为新托管者，再启动实盘。\\n\\n这样实盘原有的日志、收益等数据不会因为换了机器而丢失。\\n\\n**整体迁移托管者**\\n1. 停止旧托管者上的实盘，再停止旧托管者。\\n2. 把旧托管者工作目录下的整个```logs```目录复制到新机器的工作目录。\\n3. 在新机器上启动托管者。\\n\\n```logs/docker.pid```保存了托管者的身份，旧托管者已离线时，新机器上的托管者会沿用原来的托管者ID，实盘配置无需修改。不要让两台机器同时使用同一份```logs```目录运行托管者。\", \"title\": \"实盘数据迁移\"}, {\"_src_hash\": \"5ca888ba06422961d44a545736d40a3b73c1f80bf8ed66a659defe184517ca02\", \"desc\": \"在[托管者管理页面](https://www.fmz.com/m/nodes)，托管者列表或托管者详情的操作项中可以开启**托管者监控**。开启后，托管者异常离线时，平台会向账号绑定的邮箱发送通知。\", \"title\": \"托管者监控\"}], \"desc\": \"[托管者](https://www.fmz.com/m/nodes)是运行策略的程序：实盘策略运行在托管者上，而不是运行在发明者量化交易平台网站上。托管者负责与平台通信、启动和停止策略进程、回传日志；策略访问交易所的网络请求也都从托管者所在的机器发出。托管者运行在你自己的服务器（或一键租用的服务器）上，平台网站出现网络故障也不影响托管者上正在运行的实盘。\\n\\n**支持的系统**\\n托管者只发布64位版本：Linux（x86_64、ARM64）、macOS（Intel、Apple Silicon）、Windows（x64、ARM64，另有界面版）。不支持32位系统。\\n\\n**数据目录**\\n托管者的数据都在工作目录（默认为启动目录，可用```-w```指定）下的```logs```目录中：\\n- ```logs/storage/<实盘ID>/<实盘ID>.db3```：实盘数据库（```SQLite```），保存日志、收益、图表、状态栏和```_G()```数据，可以用```SQLite```管理软件打开。\\n- ```logs/storage/<实盘ID>/stdout.log```、```stderr.log```：策略进程的标准输出和标准错误。\\n- ```logs/docker.log```：托管者自身的运行日志。\\n- ```logs/docker.pid```：托管者的身份信息，保留它，重启后平台会沿用原来的托管者ID。\\n\\n**网络代理**\\n托管者不会读取系统代理设置或```HTTP_PROXY```等环境变量。需要通过代理访问交易所时：\\n- 在策略中用{@fun/Exchange/exchange.SetProxy exchange.SetProxy}给交易所对象设置代理；\\n- 或使用在网络层接管流量的透明代理（例如 Clash 的 TUN 模式），托管者无需任何配置。\\n\\n本章内容：{@平台基础/托管者/部署托管者部署托管者}（手动部署、一键租用、操作注意事项）、{@平台基础/托管者/命令行参数命令行参数}、{@平台基础/托管者/实盘数据迁移实盘数据迁移}、{@平台基础/托管者/托管者监控托管者监控}。\", \"title\": \"托管者\"}, {\"_src_hash\": \"7501db47f0aadcfa10afbb5b38058e5423eafcdf2b44ed326e08cbee23e2e28e\", \"children\": [{\"_src_hash\": \"75549cfd63949cfd3cd6a0c07393e3a2815e3467e06e005437575ecee7e2f83b\", \"children\": [], \"desc\": \"迁移策略不能只复制源码：参数设计、交互设计、模板引用等都不在源码里。在策略编辑页面使用「导出策略」和「导入策略」可以完整地迁移一个策略。\\n\\n![策略导入导出截图](/upload/asset/2e52ccf44526f396fb795.png)\\n\\n- 导出策略\\n 导出为一个```xml```文件，所有编程语言的策略都一样。导出时可以勾选要包含的内容：策略名称、源码、笔记、描述、手册、模板引用、策略参数、交互控件、回测设置。\\n\\n- 导入策略\\n 在策略编辑页面点击「导入策略」，选择用「导出策略」得到的```xml```文件，再勾选要导入的内容。导入后点击「保存」保存策略。\", \"title\": \"完整策略的导入与导出\"}, {\"_src_hash\": \"e5dd4ffa20fe8115b70e53639d11d1698cd833dcb0746c6bc4b1bb890ea67e81\", \"children\": [{\"_src_hash\": \"99af998f1251eb783cef1c4beb761798d2a3a21ce629948a92c33b357a0fb68f\", \"desc\": \"![策略分享](/upload/asset/2e593d57dc36afc004ef6.png)\\n\\n- 公开分享\\n 点击「分享」按钮后会弹出对话框，可以选择「公开分享」。策略将完整地分享到平台的策略广场，任何用户都可以复制该策略。\\n\\n- 内部分享\\n 点击「分享」按钮后会弹出对话框，可以选择「内部分享」。选择分享有效期、分享次数后会生成该策略的**复制页面地址**和**复制码**。可以分发给指定的FMZ平台用户，需要该策略的用户只需使用**复制页面地址**链接，登录**复制页面**后输入复制码即可获取该策略，获取后策略会自动出现在策略库中。\", \"title\": \"策略分享\"}, {\"_src_hash\": \"04d980c301163f82edbfa285fdb4ff044e939a90313749011708d6279d7218d0\", \"desc\": \"![策略出租](/upload/asset/2e4e78f6c46c9dde1ce90.png)\\n\\n- 公开出售\\n 点击「出租」按钮后会弹出对话框，可以选择「公开出售」。策略即可申请上架（需要通过审核）。\\n\\n- 内部出售\\n 点击「出租」按钮后会弹出对话框，可以选择「内部出售」。选择使用天数、最大并发数、注册码数量后，系统会生成该策略的**注册页面地址**和**注册码**。您可以将其分发给指定的FMZ平台用户，需要该策略的用户只需访问**注册页面地址**链接，登录**注册页面**后输入注册码即可获取策略的使用权。策略也会出现在策略库中，但用户只有回测和实盘使用权限，无法查看策略源码等信息。并发实盘个数设置为0时表示不限制并发数量，允许无限制地创建实盘。\", \"title\": \"策略出租\"}], \"desc\": \"在[策略库](https://www.fmz.com/m/strategies)页面，点击策略右侧的「操作项」按钮后，弹出菜单中包含分享和出租操作选项。\\n\\n重要提示：创建和分发策略**注册码**时，请务必仔细确认是「注册码」还是「复制码」，以免误将策略泄露。\", \"title\": \"策略分享与出租\"}], \"desc\": \"[策略库](https://www.fmz.com/m/strategies)页面保存当前账号下的所有策略，策略可以用多种编程语言或可视化方式编写。\\n\\n- 分组：策略和实盘一样可以分组管理，见{@平台基础/实盘/分组分组}。\\n- 导入与导出：一个完整的策略除了源码，还包括参数、交互、描述、笔记、手册、模板引用等，迁移策略要导出、导入完整策略，见{@平台基础/策略库/完整策略的导入与导出完整策略的导入与导出}。\\n- 分享与出租：生成「复制码」分享策略，生成「注册码」出租策略，见{@平台基础/策略库/策略分享与出租策略分享与出租}。\", \"title\": \"策略库\"}, {\"_src_hash\": \"78b87c183d37a5fbf6275f985668e46fadbea6b98a87f1dfb54a9fa1c64bc839\", \"children\": [{\"_src_hash\": \"c8bc86ea2e0297eadabb90915f67fd91d69a794da353abe0cea1eb09ab9e3e78\", \"children\": [], \"desc\": \"在「实盘」页面和「策略库」页面点击右侧的**分组管理**按钮，可以给实盘、策略分组管理，分组名称可以自定义。\\n例如给策略分组时，可以把**模板类库**分为一组、**JavaScript语言的策略**分为一组、**测试用策略**分为一组。\\n\\n- 策略分组\\n ![策略分组](/upload/asset/2e482ba9b9aa272085d00.png)\\n\\n- 实盘分组\\n ![实盘分组](/upload/asset/2e577d050e817837bbfdf.png)\", \"title\": \"分组\"}, {\"_src_hash\": \"40243e33ec9a3613c27c9be64528aa59de1d453affb62d2f4e36426d66552b94\", \"desc\": \"在发明者量化交易平台[实盘页面](https://www.fmz.com/m/robots)的实盘列表中点击「公开」按钮即可公开展示当前行的实盘。\\n\\n实盘围观目前支持两种方式：\\n- 1、在发明者量化交易平台的[实盘围观](https://www.fmz.com/live)页面公开展示实盘。点击「公开」按钮后选择**公开分享**即可。\\n- 2、创建实盘围观私有链接。\\n 点击「公开」按钮后选择**内部分享**，设置有效期后即可生成私有链接，用于访问该策略实盘的私有围观页面。\", \"title\": \"实盘围观\"}, {\"_src_hash\": \"8f10f9414f7620c33ba2de573556f5f065d50b5f4027e88e8b666e0cc78878ef\", \"children\": [], \"desc\": \"[推送设置页面](https://www.fmz.com/m/account#push)中可以开启消息推送功能。\\n\\n![推送设置](/upload/asset/2e4ad17706aa842c914ce.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/TypeScript/Python/Rust语言\\n 在策略代码中，可使用```Log()```函数以及其它能在日志区域输出日志信息的函数，例如：```exchange.CreateOrder()```、```exchange.CancelOrder()```等。\\n 为这些函数传入一个附带参数```\\\"@\\\"```（即在必要参数之外再增加一个附带参数），例如：```Log(\\\"This is a push message\\\", \\\"@\\\")```，即可将这条输出的日志信息进行推送，平台会根据「推送设置」进行消息推送。Rust语言中对应```Log!```宏，用法相同：```Log!(\\\"This is a push message\\\", \\\"@\\\");```。\\n- PINE语言/My语言\\n 在PINE语言/My语言策略所集成的「交易类库」参数中，可开启交易日志推送，触发交易动作后将自动进行推送。\\n- Blockly可视化\\n 在「工具」一栏中选择**消息推送**模块，即可实现指定信息的推送。\\n\\n消息推送存在频率限制，具体规则如下：在实盘的每个20秒周期内，仅保留并推送最后一条消息，其余消息将被过滤，不予推送。\", \"title\": \"实盘消息推送\"}, {\"_src_hash\": \"fa0a0729594ca951563e82b535ae1bf0914413852b6376b77138366878fccc1d\", \"children\": [], \"desc\": \"**实盘无法启动**\\n- 没有在线的托管者\\n 实盘所选的托管者离线时实盘无法启动。在[托管者页面](https://www.fmz.com/m/nodes)确认托管者在线，或换一个在线的托管者。\\n- 账户余额不足\\n 启动实盘需要预付第一个小时的费用，余额不足时无法启动；运行中余额耗尽，实盘会被平台停止。充值后重新启动，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。\\n- 租用的策略到期或并发数已满\\n 租用的策略到期后，使用它的实盘会被停止且无法再启动；达到租用的最多并发实盘数后，无法再启动新的实盘。\\n- 密钥解密失败\\n 报错中包含```secret key decrypt failed (wrong password)```。原因是修改了发明者量化交易平台的账号密码，原先配置的交易所密钥无法再解密。处理方法：\\n 1. 在[「交易所」管理页面](https://www.fmz.com/m/platforms)重新填写交易所的密钥、密码等信息。\\n 2. 停止所有托管者，用新密码重新启动托管者。\\n- 凭据文件读不到\\n 交易所配置中使用了```file:///xxx.txt```凭据文件，而实盘目录里没有该文件，报错中包含```read key file```；路径不合法时报```key file path must be relative and cannot contain '..'```或```key file path escapes the robot directory```。见{@平台基础/交易所/本地凭据文件本地凭据文件}。\\n\\n**策略代码导致的错误**\\n- 静态语法错误\\n\\n ![编辑器中语法错误](/upload/asset/2e4daebbb80548adf3927.png)\\n\\n 此类错误比较明显，通常在策略编辑页面就能看到错误标记，回测时也能发现。\\n- 运行时错误\\n 最常见的是对函数返回值不做合法性判断就直接使用。\\n- 过度占用内存\\n 在全局变量里保存过多无法被垃圾回收的内容，导致内存占用过大。\\n- 未合理使用```exchange.Go```并发请求\\n 调用异步的```exchange.Go```后没有及时```wait```等待结果，导致并发任务数量过多。\\n- 递归调用过深\\n 递归层数过多，超出调用栈大小。\\n\\n**其它报错**\\n- 接口业务错误、网络请求错误\\n 此类报错会显示相关的交易所对象名称、函数名称、错误消息和原因，本身不会导致实盘异常停止。它们通常是起因而不是直接原因，直接原因一般是**没有判断接口返回值是否合法就直接使用而引发的程序异常**。\\n- ```interrupt```错误\\n 程序正在执行某个操作（例如访问交易所接口）时，用户点击了实盘页面上的**停止**按钮，停止中断了当前操作而打印的日志。它没有影响，只是一条记录。\\n\\n更多问题见[常见问题汇总](https://www.fmz.com/bbs-topic/1427)。\", \"title\": \"实盘报错、异常退出的常见原因\"}], \"desc\": \"「实盘」区别于「回测」，指真正与交易所交互（获取行情、查询持仓、下单撤单等）的策略程序实例。连接交易所生产环境的是实盘，连接交易所模拟环境（很多交易所提供测试环境）的同样是实盘。\\n\\n**创建实盘**\\n在[实盘创建页面](https://www.fmz.com/m/add-robot)选择运行策略、托管主机和交易所后创建，需要事先准备好三样东西：\\n- 一个策略：在[策略库](https://www.fmz.com/m/strategies)点击「新建策略」编写并保存。\\n- 一个在线的托管者：在[托管者页面](https://www.fmz.com/m/nodes)点击「部署托管者」，见{@平台基础/托管者托管者}。\\n- 一个交易所账户：在[交易所页面](https://www.fmz.com/m/platforms)点击「添加交易所」配置，见{@平台基础/交易所交易所}。\\n\\n实盘按小时计费，账户余额不足时无法启动，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。\\n\\n**实盘监控**\\n在[实盘管理页面](https://www.fmz.com/m/robots)，运行中的实盘右侧操作栏可以点击「监控」开启实盘监控。开启后，实盘不是因手动操作而退出时，平台会向账号绑定的邮箱发送通知。\\n\\n**实盘数据库**\\n以实盘ID```123456```为例，它的数据库文件位于所属托管者工作目录下的```logs/storage/123456/123456.db3```（```SQLite```格式），包含以下表：\\n- chart：图表数据。\\n- cfg：状态栏内容、图表配置等最新状态。\\n- kvdb：```_G()```函数持久化保存的数据。\\n- log：实盘日志。\\n- profit：收益数据。\\n\\n同一目录下还有策略进程的标准输出```stdout.log```和标准错误```stderr.log```。\\n\\n**本章内容**\\n- {@平台基础/实盘/分组分组}：实盘和策略的分组管理。\\n- {@平台基础/实盘/实盘围观实盘围观}：公开展示实盘，或生成私有围观链接。\\n- {@平台基础/实盘/实盘消息推送实盘消息推送}：把日志推送到手机App、邮箱或WebHook。\\n- {@平台基础/实盘/实盘报错、异常退出的常见原因实盘报错、异常退出的常见原因}。\\n\\n让他人查看、操作部分实盘可以使用{@平台基础/账号与计费/子账号子账号}。\", \"title\": \"实盘\"}], \"desc\": \"平台的几个基本对象：账号与计费、交易所账户、运行策略的托管者、策略库和实盘。\", \"title\": \"平台基础\"}, {\"_src_hash\": \"9bd1c3b66d296af2a8a0be425e2ce0320a5500f4c0502db2bf9632998304745f\", \"children\": [{\"_src_hash\": \"fbe9b8fee0cc88724a93bbaba6023163c850f301e7fd761cfe3ae97c1fd89dd9\", \"children\": [{\"_src_hash\": \"7a59706442772b7d9269eb058ebb26c33ac4d5bc18d8b6c14ab1ac312795d730\", \"desc\": \"平台支持用```JavaScript```编写策略。运行时基于 QuickJS 引擎，支持```async```/```await```、```class```、```BigInt```等现代语法；实盘时策略在托管者上运行，回测时在浏览器端的回测系统中运行。在代码中加入```// @ts-check```即可改用 TypeScript 编写，见 {@编写策略/编程语言/TypeScript TypeScript}。\\n\\n**策略结构与参数**\\n\\n策略入口为```function main()```，可选的```init()```、```onexit()```、```onerror(msg)```由托管者自动调用，见 {@编写策略/策略结构策略结构}。界面参数是同名的全局变量，可以直接读取，也可以在代码中修改，见 {@编写策略/策略参数策略参数}。\\n\\n**错误与返回值**\\n\\nAPI 函数调用失败（交易所返回错误、网络问题等）时返回```null```，并在日志中输出错误信息。使用返回值之前先判断，或者用 {@fun/Global/_C _C} 重试：\\n\\n```js\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n // 调用失败时返回 null\\n if (ticker) {\\n Log(ticker)\\n }\\n\\n // 失败时自动重试，直到返回有效数据\\n var account = _C(exchange.GetAccount)\\n Log(account)\\n}\\n```\\n\\n程序异常（例如读取```undefined```的属性）和接口业务报错的日志中会显示出错位置在策略代码中的行号，便于调试和排查。\\n\\n**字符串与ArrayBuffer**\\n\\nJavaScript 的字符串是 UTF-16 编码。平台 API 返回的文本如果不是合法的 UTF-8 字节序列，为了不丢失数据，会返回```ArrayBuffer```（原始字节）。所有可以传入字符串的 API 参数也都接受```ArrayBuffer```。\\n\\n```js\\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 // “𠮷”的 Unicode 码点超出 16 位，在 JavaScript 字符串中占两个 UTF-16 码元\\n const inputString = \\\"abc𠮷123\\\"\\n\\n // Encode 按 UTF-8 编码后输出 hex\\n const encodedHex = Encode(\\\"raw\\\", \\\"string\\\", \\\"hex\\\", inputString)\\n Log(encodedHex) // 616263f0a0aeb7313233\\n\\n // charCodeAt 取的是 UTF-16 码元，“𠮷”被写成 d842、dfb7，结果不是 UTF-8 编码\\n const manuallyEncodedHex = stringToHex(inputString)\\n Log(manuallyEncodedHex) // 616263d842dfb7313233\\n\\n // 合法的 UTF-8 字节可以还原为字符串\\n const decodedString = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", encodedHex)\\n Log(decodedString) // abc𠮷123\\n\\n // 不是合法的 UTF-8 字节，返回 ArrayBuffer\\n // （如果 inputString 改为 \\\"abcG123\\\"，两种编码结果相同，这里得到的是字符串）\\n const outputD = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", manuallyEncodedHex)\\n Log(outputD instanceof ArrayBuffer) // true\\n\\n // 查看 ArrayBuffer 中的原始字节\\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) // 616263d842dfb7313233\\n}\\n```\\n\\n**异步与多线程**\\n\\n- ```setTimeout```/```clearTimeout```：回调在主线程调用```Sleep()```等待期间执行；```main()```返回时还没到期的定时器会先执行完，再调用```onexit()```。\\n- ```fetch(url)```：返回```Promise```，结果为响应对象（```ok```、```status```、```headers```属性，```text()```、```json()```直接返回内容）。托管者中的```fetch```在调用时就同步完成请求，返回的是已经完成的```Promise```，所以用```Promise.all```组合多个```fetch```并不会并发请求。\\n- 交易所 API（例如```exchange.GetTicker()```）是同步阻塞调用，包装进```Promise```或```async```函数也不会并发执行。\\n- 需要并发时使用 {@fun/Threads/exchange.Go exchange.Go}、{@fun/Network/HttpQuery_Go HttpQuery_Go}，或者用 {@fun/Threads/threading/Thread Thread} 创建线程，见 {@进阶专题/JavaScript多线程 JavaScript多线程}。\\n\\n```js\\nasync function main() {\\n let resp = await fetch(\\\"https://www.okx.com/api/v5/market/books?instId=BTC-USDT\\\")\\n if (resp.ok) {\\n Log(resp.json())\\n } else {\\n Log(\\\"status:\\\", resp.status)\\n }\\n}\\n```\\n\\n**库与依赖**\\n\\nJavaScript 策略可以直接使用内置的```TA```指标库和```talib```指标库，各语言可用的内置库见 {@编写策略/内置库内置库}。其它第三方 JavaScript 库可以在运行时下载后用```eval```加载，示例见同一页。\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"ae30a75bf07b2e4a539e1e09487af17cde7771209aab25466afb6c50574f53a1\", \"desc\": \"TypeScript 不是单独的语言选项：创建策略时选择```JavaScript```，在代码中加入一行```// @ts-check```（或点击策略编辑区右上角的「TypeScript」按钮），平台就按 TypeScript 处理，在回测和实盘运行前先编译为 JavaScript。通过 AI/MCP 工具保存策略时，语言可以直接写```typescript```，平台按 JavaScript 策略保存，并在代码开头自动加上```//@ts-check```，见 {@对外接口/AI接入 AI接入}。\\n\\n静态类型检查能在编写时发现参数个数、属性名、类型用错之类的问题，编辑器的补全也更准确。\\n\\n最小示例：\\n\\n```ts\\n// @ts-check\\ninterface Signal {\\n side: \\\"buy\\\" | \\\"sell\\\"\\n price: number\\n}\\n\\nfunction getSignal(ticker: ITicker, ma: number): Signal | null {\\n if (ticker.Last > ma) {\\n return {side: \\\"buy\\\", price: ticker.Last}\\n }\\n if (ticker.Last < ma) {\\n return {side: \\\"sell\\\", price: ticker.Last}\\n }\\n return null\\n}\\n\\nfunction main() {\\n while (true) {\\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 const signal = getSignal(ticker, ma[ma.length - 1])\\n if (signal) {\\n Log(signal.side, signal.price)\\n }\\n }\\n Sleep(60 * 1000)\\n }\\n}\\n```\\n\\n平台 API 的类型声明由策略编辑器内置提供，不需要在代码中引用：全局函数、```exchange```对象、```ITicker```、```IRecord```、```IOrder```、```IPosition```等数据结构接口，以及```TA```、```talib```等。运行时的语言特性、API 和库与 JavaScript 策略相同，见 {@编写策略/编程语言/JavaScript JavaScript}。\", \"title\": \"TypeScript\"}, {\"_src_hash\": \"ea17b42609d0fc36aac0af41d4a3e8dd366ccee15e011cb47fe73d7a909ef420\", \"desc\": \"平台支持用```Python 3```编写策略，不支持 Python 2。实盘以及在托管者上进行的回测，使用托管者所在机器上安装的 Python 解释器运行策略。\\n\\n**解释器**\\n\\n托管者按以下顺序查找解释器，使用第一个能启动、并且版本为 Python 3 的程序：\\n1. 环境变量```PYTHON_BIN```指定的解释器；\\n2. ```python3```；\\n3. ```python```。\\n\\n需要使用指定的解释器（例如虚拟环境中的 Python）时，在启动托管者之前设置环境变量：\\n\\n```bash\\nexport PYTHON_BIN=/opt/venv/bin/python3\\n```\\n\\n策略代码首行的```#!python3```、```#!python2```等写法不再用于选择解释器。\\n\\n**策略结构与参数**\\n\\n策略入口为```def main()```，可选的```init()```、```onexit()```由托管者自动调用（Python 不支持```onerror()```），见 {@编写策略/策略结构策略结构}。界面参数是同名的全局变量；在函数中给参数重新赋值时，需要先用```global```声明。\\n\\n**错误与返回值**\\n\\nAPI 函数调用失败时返回```None```，并在日志中输出错误信息。使用返回值之前先判断，或者用```_C()```重试。策略中未捕获的异常会结束运行，错误信息记录在日志中。\\n\\n**输出**\\n\\n```print()```的输出写到托管者进程的标准输出，不会出现在实盘日志里。需要显示在日志中的内容请用 {@fun/Log/Log Log}。\\n\\n**第三方库**\\n\\n策略可以导入解释器中已经安装的任何库。安装时要使用托管者运行策略的那个解释器，例如：\\n\\n```bash\\npython3 -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策略运行时的当前目录和```PYTHONPATH```是托管者为本次运行创建的临时目录，运行结束后会被删除；放在托管者程序目录下（例如```logs/storage/<实盘ID>/```）的```.py```文件不会被自动找到。导入自己编写的模块有两种方式：\\n- 把模块安装到解释器的```site-packages```中（例如做成包用```pip install```安装，或者直接复制到```site-packages```目录）；\\n- 在策略中先把模块所在目录的绝对路径加入```sys.path```，再导入。\\n\\n例如模块文件```/home/user/fmz_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/fmz_modules\\\") # 模块所在目录的绝对路径\\n\\nimport mymath\\n\\ndef main():\\n Log(\\\"mymath.add(1, 2):\\\", mymath.add(1, 2))\\n```\\n\\n把核心代码做成模块放在自己的托管者上，策略代码中只保留调用部分，也是一种不把核心代码上传到平台的做法。\", \"title\": \"Python\"}, {\"_src_hash\": \"bd217346b3a5f58defb5137cb132a32280695d65b3387e0711924ce9a409e038\", \"desc\": \"平台支持用```Rust```编写策略。Rust 策略先编译再运行：回测时由平台服务器编译，在浏览器端的回测系统中运行；实盘时编译通过后在托管者上运行。策略编辑器为 Rust 集成了```rust-analyzer```，提供代码补全与实时诊断。\\n\\n**策略结构**\\n\\n策略代码只需要一个```fn main()```。平台 API（```exchange```、```exchanges```、```TA```、```Log!```、```_C!```等）已经自动导入，不需要写```use```或```mod```声明。\\n\\n可选的```fn init()```、```fn onexit()```由托管者自动调用，定义即可，不需要注册：```init()```在```main()```之前执行；```onexit()```在```main()```正常返回、实盘被停止、策略```panic```时都会执行。Rust 不支持```onerror()```。详见 {@编写策略/策略结构策略结构}。\\n\\n```rust\\nfn init() {\\n Log!(\\\"初始化\\\");\\n}\\n\\nfn main() {\\n // 可能失败的 API 返回 Result，_C! 宏在失败时重试，直到调用成功\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(\\\"Last:\\\", ticker.Last);\\n}\\n\\nfn onexit() {\\n Log!(\\\"策略退出，执行扫尾处理\\\");\\n}\\n```\\n\\n日志等部分功能以宏的形式提供（注意感叹号）：```Log!()```、```LogStatus!()```、```Panic!()```、```_G!()```、```_C!()```；```LogProfit()```、```Sleep()```、```_D()```、```_N()```、```HttpQuery()```等是普通函数。\\n\\n**参数类型**\\n\\n界面参数以同名的全局常量注入策略，只能读取，不能在代码中修改（需要变化的值请复制到局部变量）。类型由参数种类决定：\\n\\n| 参数种类 | Rust 类型 |\\n| - | - |\\n| 数字型 | ```f64``` |\\n| 布尔型 | ```bool``` |\\n| 字符串 | ```&str``` |\\n| 下拉框（单选） | ```f64```（选项索引）；选项绑定了字符串数据时为```&str``` |\\n| 下拉框（多选） | ```&[i64]```、```&[f64]```或```&[&str]```；选项值类型混杂时为 JSON 文本```&str``` |\\n| 加密串 | ```&str```或```Decrypted```（可解引用为```str```） |\\n\\n- 整数用途需要自行转换，例如```let n = Period as usize;```。\\n- 选填参数没有填写时为该类型的零值：```0.0```、```\\\"\\\"```、```false```，多选下拉框为空。\\n- 加密串参数在服务端不能预先解密时（例如私有托管者），注入为```static```的```Decrypted```类型，第一次使用时才解密。它实现了```Display```，可以直接用于```format!```；传给```Log!```或其它需要```&str```的地方写```&*参数名```（对```&str```类型的参数同样适用）：\\n\\n```rust\\nfn main() {\\n let key: &str = &*ApiKey; // ApiKey 为加密串参数\\n Log!(\\\"key length:\\\", key.len());\\n}\\n```\\n\\n- 参数名与代码中的其它名字冲突时，可以用```args::参数名```引用参数。\\n\\n**错误与返回值**\\n\\n可能失败的 API 调用返回```Result```，用 Rust 惯用的方式处理（JavaScript 中失败返回```null```）：\\n\\n```rust\\nfn main() {\\n // 方式一：模式匹配\\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\\n可选参数（例如```GetTicker```的```symbol```参数）不传时用```None```占位，传值时直接传入，例如```exchange.GetTicker(\\\"BTC_USDT\\\")```。\\n\\n**JSON**\\n\\n平台 API 返回的原始 JSON 文本（例如```exchange.IO()```的返回值、各结构体的```Info```字段）用内置的```JSONParse()```解析，得到```Option```；用```v[\\\"key\\\"]```、```v[0]```取子节点，用```as_f64()```、```as_str()```、```as_bool()```等方法取值。```JsonValue```实现了```Display```，```v.to_string()```或```format!(\\\"{}\\\", v)```得到紧凑的 JSON 文本。SDK 没有提供构造 JSON 的便捷接口，生成 JSON 文本可以用```format!```拼接，或者引入```serde_json```。\\n\\n**第三方 crate**\\n\\n策略源码是唯一的代码文件（没有单独的```Cargo.toml```）。在源码最顶部用```---```包裹的 frontmatter 声明依赖，构建时合并进```Cargo.toml```：\\n\\n```rust\\n---\\n[dependencies]\\nserde_json = \\\"1\\\"\\n---\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-02-01 00:00:00\\nperiod: 1h\\n*/\\nfn main() {\\n let v: serde_json::Value = serde_json::from_str(r#\\\"{\\\"a\\\": 1}\\\"#).unwrap();\\n Log!(\\\"a:\\\", v[\\\"a\\\"].to_string());\\n}\\n```\\n\\n- frontmatter 必须在源码开头，前面只能有空行；```/*backtest ... */```回测配置块要放在 frontmatter 结束的```---```之后。策略中还没有回测配置块时，「保存回测设置」会把配置块插入到源码最前面，这时需要把它移到 frontmatter 之后（之后再保存会在原位置更新）。\\n- 策略和它引用的模板类库中，依赖块只能写在其中一处，两处都写会编译失败。\\n- 编译环境中没有系统 OpenSSL，需要 TLS 的 crate（HTTP/WebSocket 客户端等）请选用纯 Rust 实现的```rustls```（例如```tokio-tungstenite```开启```rustls-tls-webpki-roots```特性），避免依赖```native-tls```/```openssl-sys```；WebSocket 连接优先使用内置的 {@fun/Network/Dial Dial} 函数，不需要第三方 crate。\\n\\n**内置库**\\n\\nRust 策略可以使用```TA```指标库，不支持```talib```，见 {@编写策略/内置库内置库}。\", \"title\": \"Rust\"}, {\"_src_hash\": \"6019397439ed79ee429eedabc904e390f0aa442a687203f0731cdf2cc8fceb69\", \"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- [FMZ量化My语言文档](https://www.fmz.com/bbs-topic/2569)\\n- [FMZ量化My语言--My语言交易类库参数](https://www.fmz.com/bbs-topic/5768)\", \"title\": \"My语言（麦语言）\"}, {\"_src_hash\": \"6931b8cbc80f11adbf0191d2f28c086f3d0f1a291c58d3eaa15405c2e50eb0b0\", \"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.fmz.com/bbs-topic/9315)\", \"title\": \"PINE语言\"}, {\"_src_hash\": \"46db0d70148678dfe7504c341fccc0e2f3cd5bc55cd5e3b03eee330830bf13c9\", \"desc\": \"平台支持Blockly可视化编程方式。借助Blockly编辑器，用户可以通过拼接图形块（类似积木）来表达代码概念，如变量、逻辑表达式、循环等。这种方式使编程过程无需过多关注繁琐的语法细节，而是可以直接按照编程原则进行操作。通过图形块的排列组合，用户能够轻松理解编程逻辑，实现创意想法，非常适合培养策略设计兴趣，快速入门程序化和量化交易。\\n\\n - [可视化模块搭建交易策略--初识](https://www.fmz.com/digest-topic/4016)\\n\\n - [可视化模块搭建交易策略--进阶](https://www.fmz.com/digest-topic/4046)\\n\\n - [可视化模块搭建交易策略--深入](https://www.fmz.com/digest-topic/4086)\\n\\n - [可视化模块搭建交易策略--浅出](https://www.fmz.com/digest-topic/4107)\", \"title\": \"Blockly可视化\"}, {\"_src_hash\": \"08e2fc002246d345e7118bd51513cac1ee5c601eb6e33c3465a99364c7d31ab2\", \"desc\": \"平台支持 Workflow 工作流方式编写策略。工作流是一种可视化的策略设计方式，通过节点连接和配置来构建交易逻辑，无需编写代码即可实现策略。\\n\\n**工作流特点**：\\n- 可视化拖拽设计，所见即所得\\n- 预置丰富的功能节点（数据获取、指标计算、条件判断、交易执行等）\\n- 降低编程门槛，适合快速搭建和验证策略\\n- 支持回测功能，可视化查看节点执行状态\\n\\n**学习资源**：\\n- [工作流系列视频教程](https://www.fmz.com/class/workflow)\", \"title\": \"Workflow工作流\"}], \"desc\": \"**在发明者量化交易平台上，可以使用哪些编程语言来编写我的策略呢？**\\n\\n![支持的编程语言](/upload/asset/2e52c7501f57044f7f0ef.png)\\n\\n发明者量化交易平台支持使用```JavaScript```、```TypeScript```、```Python```、```Rust```、[```PINE```](https://www.fmz.com/bbs-topic/9315)、[```My语言```](https://www.fmz.com/bbs-topic/2569)、```Blockly```可视化以及```Workflow```工作流来编写和设计交易策略。\", \"title\": \"编程语言\"}, {\"_src_hash\": \"e82a93791633e6173c3896b2a45896047412cab2ce37f3d120ba33b7561cbf22\", \"children\": [{\"_src_hash\": \"bbc0efe8902eca1d4d46df58fd2000f39c8e0ff057d2cfd262dfac55077a2628\", \"desc\": \"```init()``` 为用户实现的初始化函数。策略开始运行时，会首先自动执行 ```init()``` 函数，以完成策略中设计的初始化任务。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\")\\n Log(\\\"Exiting!\\\")\\n}\\n\\n// 初始化函数\\nfunction init(){\\n Log(\\\"Initializing!\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\")\\n Log(\\\"Exiting!\\\")\\n\\ndef init():\\n Log(\\\"Initializing!\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"First line of code executed!\\\", \\\"#FF0000\\\");\\n Log!(\\\"Exiting!\\\");\\n}\\n\\n// 初始化函数\\nfn init() {\\n Log!(\\\"Initializing!\\\");\\n}\", \"lang\": \"rust\"}]}], \"title\": \"init()\"}, {\"_src_hash\": \"0d5a56c059c9f3e258b6c7c49047e9298758d3ebdc7dfbf9fcc53af264e7fa52\", \"desc\": \"```onexit()```由用户实现，在策略退出时处理扫尾工作，可以不定义。最长执行 5 分钟，超时会被强制结束。各语言在哪些情况下调用```onexit()```，见 {@编写策略/策略结构策略结构}。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\")\\n Sleep(1000 * 5)\\n}\\n\\n// 扫尾函数实现\\nfunction onexit(){\\n var beginTime = new Date().getTime()\\n while(true){\\n var nowTime = new Date().getTime()\\n Log(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (nowTime - beginTime) / 1000, \\\"seconds!\\\")\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\")\\n Sleep(1000 * 5)\\n\\ndef onexit():\\n beginTime = time.time() * 1000\\n while True:\\n ts = time.time() * 1000\\n Log(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (ts - beginTime) / 1000, \\\"seconds!\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\");\\n Sleep(1000 * 5);\\n}\\n\\n// 扫尾函数实现\\nfn onexit() {\\n let beginTime = Unix() * 1000;\\n loop {\\n let nowTime = Unix() * 1000;\\n Log!(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (nowTime - beginTime) / 1000, \\\"seconds!\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"测试```onexit()```函数：\"}, {\"examples\": [{\"code\": \"function main() {\\n if (exchange.GetName().startsWith(\\\"Futures_\\\")) {\\n Log(\\\"Exchange is futures\\\")\\n exchange.SetContractType(\\\"swap\\\")\\n } else {\\n Log(\\\"Exchange is spot\\\")\\n }\\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(\\\"Executing cleanup function\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n if exchange.GetName().startswith(\\\"Futures_\\\"):\\n Log(\\\"Exchange is futures\\\")\\n else:\\n Log(\\\"Exchange is spot\\\")\\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(\\\"Executing cleanup function\\\")\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n loop {\\n match exchange.GetTicker(None) {\\n Ok(ticker) => LogStatus!(_D(None), ticker.Last),\\n Err(e) => {\\n // 回测结束时API调用返回Err，退出循环使main返回，从而触发onexit()扫尾函数\\n Log!(\\\"error:\\\", e);\\n break;\\n }\\n }\\n Sleep(500);\\n }\\n}\\n\\nfn main() {\\n if exchange.GetName().starts_with(\\\"Futures_\\\") {\\n Log!(\\\"Exchange is futures\\\");\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n } else {\\n Log!(\\\"Exchange is spot\\\");\\n }\\n\\n onTick();\\n}\\n\\nfn onexit() {\\n Log!(\\\"Executing cleanup function\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"回测系统中，策略通常写成不停轮询的死循环，回测数据结束时```main()```并没有正常返回，```JavaScript```、```Python```策略因此不会执行```onexit()```。可以在回测中（```IsVirtual()```为真）捕获回测结束时抛出的异常（EOF），让```main()```返回，从而执行```onexit()```。```Rust```策略在回测结束时 API 调用返回```Err```，退出循环即可。\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"8f8db57471be4325895c388110988cca3c94e8dabb6fb9c9e62ffcd1916b9a54\", \"desc\": \"```onerror(msg)```只有```JavaScript```（含 TypeScript）策略支持：```main()```因未捕获的异常结束时调用，参数```msg```为异常的错误信息。调用了```onerror()```就不再调用```onexit()```。最长执行 5 分钟，超时会被强制结束。回测系统不支持该函数。\\n\\n```Python```、```Rust```策略不支持```onerror()```。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var arr = []\\n Log(arr[6].Close) // 这里故意引发一个程序异常\\n}\\n\\nfunction onerror(msg) {\\n Log(\\\"Error:\\\", msg)\\n}\", \"lang\": \"javascript\"}, {\"code\": \"# Python 不支持\", \"lang\": \"python\"}, {\"code\": \"// Rust 不支持\", \"lang\": \"rust\"}]}], \"title\": \"onerror()\"}, {\"_src_hash\": \"6aed994ddacb3408f322560420cff1909b0c6823c79c76c3d4d7ce4d0256b02c\", \"desc\": \"策略通常在```main()```中写一个循环：每轮获取行情、计算信号、下单，然后调用 {@fun/Global/Sleep Sleep} 等待下一轮。```Sleep()```在回测中推进回测时间、控制回溯速度，在实盘中控制轮询间隔，从而控制访问交易所 API 的频率。循环中不调用```Sleep()```会以最快速度反复请求交易所接口，容易触发交易所的频率限制。需要在托管者上限制 API 调用频率时，见 {@进阶专题/API限流控制 API限流控制}。\", \"examples\": [{\"examples\": [{\"code\": \"function onTick(){\\n // 在这里写策略逻辑，将会不断调用，例如打印行情信息\\n Log(exchange.GetTicker())\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(exchange.GetTicker())\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // 在这里写策略逻辑，将会不断调用，例如打印行情信息\\n Log!(exchange.GetTicker(None));\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"基本框架：\"}, {\"examples\": [{\"code\": \"function onTick(){\\n // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用\\n exchange.Buy(100, 1)\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n exchange.Buy(100, 1)\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用\\n let _ = exchange.Buy(100, 1);\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"举个最简单的例子：每隔1秒钟在交易所挂一个价格为100、数量为1的买单，可以这样写：\"}, {\"examples\": [{\"code\": \"function onTick() {\\n Log(\\\"K-line updated, new BAR generated\\\")\\n}\\n\\nfunction main() {\\n var exName = exchange.GetName()\\n if (exName.includes(\\\"Futures_\\\")) {\\n exchange.SetContractType(\\\"swap\\\")\\n }\\n\\n var lastTs = 0\\n while (true) {\\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 Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(\\\"K-line updated, new BAR generated\\\")\\n\\ndef main():\\n exName = exchange.GetName()\\n if \\\"Futures_\\\" in exName:\\n exchange.SetContractType(\\\"swap\\\")\\n\\n lastTs = 0\\n while True:\\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-line updated, new BAR generated\\\");\\n}\\n\\nfn main() {\\n let exName = exchange.GetName();\\n if exName.contains(\\\"Futures_\\\") {\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n }\\n\\n let mut lastTs = 0;\\n loop {\\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 Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"按K线更新处理的策略（On Bar）：最新一根K线的时间变化时才执行```onTick()```：\"}], \"title\": \"主循环\"}, {\"_src_hash\": \"8cc0fa8a167ab65432ee570f121da32982a16656a9578169a951c4aa81232258\", \"desc\": \"除了按固定间隔轮询，策略也可以等待事件到达后再处理，减少无效请求，也能更快地响应行情变化。\\n\\n**EventLoop**\\n\\n{@fun/Threads/EventLoop EventLoop} 等待```exchange.Go()```、```HttpQuery_Go()```等并发任务完成、WebSocket 连接有可读数据、线程消息等事件；有事件时返回事件信息，策略再去读取对应的数据。第一次调用```EventLoop()```时才开始记录事件，所以先调用一次```EventLoop(-1)```再发起并发任务：\\n\\n```js\\nfunction main() {\\n EventLoop(-1) // 开始记录事件，避免错过之后发生的事件\\n var r1 = exchange.Go(\\\"GetTicker\\\")\\n var r2 = exchange.Go(\\\"GetDepth\\\")\\n var ev = EventLoop(1000) // 等待任意一个并发任务完成，最多等 1 秒\\n Log(\\\"event:\\\", ev)\\n Log(\\\"ticker:\\\", r1.wait(), \\\"depth:\\\", r2.wait())\\n}\\n```\\n\\n**ctx.subscribe / ctx.poll**\\n\\n```JavaScript```和```Rust```策略还可以使用托管者的事件订阅接口：```ctx.subscribe()```订阅某个账户、某个品种的行情或订单回报，返回流 ID；```ctx.poll()```取出下一条事件（可以设置等待超时），策略按事件的```kind```分别处理。```Python```策略不支持。\\n\\n```js\\nfunction main() {\\n ctx.subscribe(0, \\\"BTC_USDT\\\", {channel: \\\"ticker\\\"}) // 第一个参数是账户在 exchanges 中的下标\\n ctx.subscribe(0, \\\"\\\", {channel: \\\"orders\\\"}) // 订单回报\\n while (true) {\\n const ev = ctx.poll([], 1000) // [] 表示所有订阅，最多等 1 秒\\n if (!ev) {\\n continue\\n }\\n if (ev.kind === 1) {\\n Log(\\\"ticker:\\\", ev.symbol, ev.bid, ev.ask, ev.last)\\n } else if (ev.kind === 16) {\\n Log(\\\"order:\\\", ev.id, ev.state, ev.filledQty)\\n }\\n }\\n}\\n```\\n\\n- ```channel```可选```\\\"ticker\\\"```、```\\\"bbo\\\"```、```\\\"depth\\\"```、```\\\"trade\\\"```、```\\\"kline\\\"```（```interval```为周期秒数）、```\\\"orders\\\"```。\\n- 事件的```kind```：1 为 ticker，3 为深度（事件只表示订单簿已更新，档位用```ctx.book(ev.ex, ev.symbol, n)```读取），4 为成交，5 为 K 线，16 为订单回报。\\n- 行情类订阅消费不及时会只保留最新数据或丢弃最旧的数据，订单回报不会丢弃，策略需要持续调用```ctx.poll()```。\\n\\n```Rust```策略中的写法为```ctx::subscribe()```、```ctx::poll()```，事件为原始结构，价格、数量是定点整数：\\n\\n```rust\\nfn main() {\\n let s = ctx::subscribe(0, \\\"BTC_USDT\\\", ctx::SubOpts::ticker()).unwrap();\\n loop {\\n match ctx::poll(&[s], Some(1000)) {\\n ctx::Polled::Event(ev) => Log!(\\\"event kind:\\\", ev.kind),\\n ctx::Polled::Stopped => break,\\n _ => {}\\n }\\n }\\n}\\n```\", \"title\": \"事件驱动\"}, {\"_src_hash\": \"4dcc455703f8f18b2c3de75fe9b8d87ec961a775be8c8b80935d80afcc3b346f\", \"desc\": [\"按API手册的分类列出全部函数、结构体和常量，每项一句话说明，点击名称查看完整文档。本页由```doc_tools/gen_api_index.py```根据手册生成。\\n\\n## 内置函数\\n\\n### Global\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Global/Version Version} | 返回当前系统版本号。 |\\n| {@fun/Global/IsVirtual IsVirtual} | 用于判断策略的运行环境是否为回测系统。 |\\n| {@fun/Global/GetOS GetOS} | 获取托管者所在设备的操作系统信息。 |\\n| {@fun/Global/GetPid GetPid} | 获取实盘进程的 ID。 |\\n| {@fun/Global/GetMeta GetMeta} | 获取在生成策略注册码时写入的```Meta```值。 |\\n| {@fun/Global/Sleep Sleep} | 休眠函数，使程序暂停运行一段指定的时间。 |\\n| {@fun/Global/Unix Unix} | 获取当前时刻的秒级时间戳。 |\\n| {@fun/Global/UnixNano UnixNano} | 获取当前时刻的纳秒级时间戳。 |\\n| {@fun/Global/_D _D} | 将毫秒级时间戳或```Date```对象转换为时间字符串。 |\\n| {@fun/Global/GetCommand GetCommand} | 获取策略的交互命令。 |\\n| {@fun/Global/GetLastError GetLastError} | 获取最近一次的错误信息。 |\\n| {@fun/Global/SetErrorFilter SetErrorFilter} | 过滤错误日志。 |\\n| {@fun/Global/_N _N} | 格式化浮点数。 |\\n| {@fun/Global/_C _C} | 重试函数，用于对接口调用进行容错处理。 |\\n| {@fun/Global/_Cross _Cross} | 返回数组```arr1```与数组```arr2```的交叉周期数。 |\\n| {@fun/Global/JSON.parse JSON.parse} | ```JSON.parse```函数是**ECMAScript**标准内建对象```JSON```的方法，用于解码（解析）JSON字符串。 |\\n| {@fun/Global/JSON.stringify JSON.stringify} | ```JSON.stringify```函数是**ECMAScript**标准内置对象```JSON```的方法，用于将JavaScript值转换为JSON字符串。 |\\n| {@fun/Global/Encode Encode} | 该函数根据传入的参数对数据进行编码。 |\\n| {@fun/Global/MD5 MD5} | 计算参数```data```的 MD5 哈希值。 |\\n| {@fun/Global/UUID UUID} | 创建一个 UUID。 |\\n\\n### Log\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Log/Log Log} | ```Log()```函数用于输出日志。 |\\n| {@fun/Log/LogStatus LogStatus} | 在回测系统或实盘页面的状态栏中输出信息。 |\\n| {@fun/Log/LogProfit LogProfit} | 记录并打印盈亏数值，并根据盈亏数值绘制收益曲线。 |\\n| {@fun/Log/LogProfitReset LogProfitReset} | 清空所有收益日志及收益图表。 |\\n| {@fun/Log/LogReset LogReset} | 清除日志。 |\\n| {@fun/Log/LogVacuum LogVacuum} | 用于在调用 ```LogReset()``` 函数清除日志后，回收 **SQLite** 删除数据时所占用的存储空间。 |\\n| {@fun/Log/EnableLog EnableLog} | 启用或禁用订单信息的日志记录。 |\\n| {@fun/Log/Chart Chart} | 自定义图表绘图函数。 |\\n| {@fun/Log/KLineChart KLineChart} | 该函数用于采用类似```Pine```语言的绘图方式，在策略运行时进行自定义绘图。 |\\n| {@fun/Log/console.log console.log} | 用于在实盘页面的「调试信息」栏中输出调试信息。 |\\n| {@fun/Log/console.error console.error} | 用于在实盘页面的「调试信息」栏中输出错误信息。 |\\n| {@fun/Log/exchange.Log exchange.Log} | ```exchange.Log()```函数用于在日志栏区域输出下单、撤单日志。 |\\n\\n### Market\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Market/exchange.GetTicker exchange.GetTicker} | 获取当前设置的交易对、合约代码所对应现货或合约的Ticker结构，即行情数据。 |\\n| {@fun/Market/exchange.GetTickers exchange.GetTickers} | ```exchange.GetTickers()```函数用于获取交易所的聚合行情数据（Ticker结构的数组）。 |\\n| {@fun/Market/exchange.GetDepth exchange.GetDepth} | 获取当前设置的交易对、合约代码所对应的现货或合约的Depth结构，即订单簿数据。 |\\n| {@fun/Market/exchange.GetTrades exchange.GetTrades} | 获取当前设置的交易对、合约代码所对应的现货或合约的Trade结构数组，即市场的成交数据。 |\\n| {@fun/Market/exchange.GetRecords exchange.GetRecords} | 获取当前设置的交易对、合约代码所对应的现货或合约的Record结构数组，即K线数据。 |\\n| {@fun/Market/exchange.GetMarkets exchange.GetMarkets} | ```exchange.GetMarkets()```函数用于获取交易所的市场信息。 |\\n| {@fun/Market/exchange.GetRawJSON exchange.GetRawJSON} | 获取当前交易所对象（exchange、exchanges）最近一次```rest```请求返回的原始内容。 |\\n| {@fun/Market/exchange.SetData exchange.SetData} | ```exchange.SetData()```函数用于设置策略运行时所加载的数据。 |\\n| {@fun/Market/exchange.GetData exchange.GetData} | ```exchange.GetData()```函数用于获取由```exchange.SetData()```函数加载的数据，或外部链接提供的数据。 |\\n\\n### Trade\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Trade/exchange.Buy exchange.Buy} | ```exchange.Buy()```函数用于下买单。 |\\n| {@fun/Trade/exchange.Sell exchange.Sell} | ```exchange.Sell()```函数用于下达卖单。 |\\n| {@fun/Trade/exchange.CreateOrder exchange.CreateOrder} | ```exchange.CreateOrder()```函数用于下单。 |\\n| {@fun/Trade/exchange.ModifyOrder exchange.ModifyOrder} | ```exchange.ModifyOrder()```函数用于修改现有的普通订单，可修改订单的价格和数量。 |\\n| {@fun/Trade/exchange.CancelOrder exchange.CancelOrder} | ```exchange.CancelOrder()```函数用于取消订单。 |\\n| {@fun/Trade/exchange.GetOrder exchange.GetOrder} | ```exchange.GetOrder()```函数用于获取订单信息。 |\\n| {@fun/Trade/exchange.GetOrders exchange.GetOrders} | ```exchange.GetOrders()```函数用于获取当前未完成的订单。 |\\n| {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders} | ```exchange.GetHistoryOrders()```函数用于获取当前交易对、合约的历史订单，并支持指定具体的交易品种。 |\\n| {@fun/Trade/exchange.CreateConditionOrder exchange.CreateConditionOrder} | ```exchange.CreateConditionOrder()```函数用于创建条件单。 |\\n| {@fun/Trade/exchange.ModifyConditionOrder exchange.ModifyConditionOrder} | ```exchange.ModifyConditionOrder()```函数用于修改现有的条件单，可修改条件单的下单量、触发条件和执行价格。 |\\n| {@fun/Trade/exchange.CancelConditionOrder exchange.CancelConditionOrder} | ```exchange.CancelConditionOrder()```函数用于取消条件单。 |\\n| {@fun/Trade/exchange.GetConditionOrder exchange.GetConditionOrder} | ```exchange.GetConditionOrder()```函数用于获取指定条件单的信息。 |\\n| {@fun/Trade/exchange.GetConditionOrders exchange.GetConditionOrders} | ```exchange.GetConditionOrders()```函数用于获取未完成的条件单（尚未触发或尚未取消的条件单）。 |\\n| {@fun/Trade/exchange.GetHistoryConditionOrders exchange.GetHistoryConditionOrders} | ```exchange.GetHistoryConditionOrders()```函数用于获取当前交易对、合约的历史条件单（包括已触发、已取消、已过期的条件单），并支持指定具体的交易品种。 |\\n\\n### Account\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Account/exchange.GetAccount exchange.GetAccount} | ```exchange.GetAccount()```函数用于请求交易所账户信息。 |\\n| {@fun/Account/exchange.GetAssets exchange.GetAssets} | ```exchange.GetAssets```函数用于请求交易所账户的资产信息。 |\\n\\n### Futures\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Futures/exchange.SetContractType exchange.SetContractType} | ```exchange.SetContractType()```函数用于设置exchange交易所对象当前的合约代码。 |\\n| {@fun/Futures/exchange.GetContractType exchange.GetContractType} | ```exchange.GetContractType()```函数用于获取exchange交易所对象当前设置的合约代码。 |\\n| {@fun/Futures/exchange.SetDirection exchange.SetDirection} | ```exchange.SetDirection()```函数用于设置调用exchange.Buy函数、exchange.Sell函数进行期货合约下单时的订单方向。 |\\n| {@fun/Futures/exchange.SetMarginLevel exchange.SetMarginLevel} | ```exchange.SetMarginLevel()```函数用于设置```symbol```参数所指定的交易对、合约的杠杆值。 |\\n| {@fun/Futures/exchange.GetPositions exchange.GetPositions} | ```exchange.GetPositions()```函数用于获取持仓信息；```GetPositions()```函数是交易所对象exchange的成员函数。 |\\n| {@fun/Futures/exchange.GetFundings exchange.GetFundings} | ```exchange.GetFundings()```函数用于获取当前周期的资金费率数据。 |\\n\\n### Exchange\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Exchange/exchange.GetName exchange.GetName} | ```exchange.GetName()```函数用于获取当前交易所对象所绑定的交易所名称。 |\\n| {@fun/Exchange/exchange.GetLabel exchange.GetLabel} | ```exchange.GetLabel()```函数用于获取配置交易所对象时设置的自定义标签。 |\\n| {@fun/Exchange/exchange.GetCurrency exchange.GetCurrency} | ```exchange.GetCurrency()```函数用于获取当前设置的交易对。 |\\n| {@fun/Exchange/exchange.SetCurrency exchange.SetCurrency} | ```exchange.SetCurrency()```函数用于切换交易所对象exchange当前的交易对。 |\\n| {@fun/Exchange/exchange.GetQuoteCurrency exchange.GetQuoteCurrency} | ```exchange.GetQuoteCurrency()```函数用于获取当前交易对的计价币名称，即```quoteCurrency```。 |\\n| {@fun/Exchange/exchange.GetPeriod exchange.GetPeriod} | 获取回测或实盘运行策略时，在发明者量化交易平台网站页面上所设置的 K 线周期，即调用 ```exchange.GetRecords()``` 函数且不传入参数时使用的默认 K 线周期。 |\\n| {@fun/Exchange/exchange.SetMaxBarLen exchange.SetMaxBarLen} | 设置K线的最大长度。 |\\n| {@fun/Exchange/exchange.SetPrecision exchange.SetPrecision} | ```exchange.SetPrecision()```函数用于设置```exchange```交易所对象的**价格**与**下单量**的精度，设置后系统会自动忽略数据中超出精度的多余部分。 |\\n| {@fun/Exchange/exchange.GetRate exchange.GetRate} | 获取交易所对象当前设置的汇率。 |\\n| {@fun/Exchange/exchange.SetRate exchange.SetRate} | 设置交易所对象当前的汇率。 |\\n| {@fun/Exchange/exchange.SetBase exchange.SetBase} | ```exchange.SetBase()```函数用于设置exchange交易所对象所使用的交易所API接口基地址。 |\\n| {@fun/Exchange/exchange.GetBase exchange.GetBase} | ```exchange.GetBase()``` 函数用于获取当前交易所 API 接口的基础地址。 |\\n| {@fun/Exchange/exchange.SetProxy exchange.SetProxy} | ```exchange.SetProxy()```函数用于设置exchange交易所对象的代理配置。 |\\n| {@fun/Exchange/exchange.SetTimeout exchange.SetTimeout} | ```exchange.SetTimeout()```函数用于设置exchange交易所对象```rest```请求的超时时间。 |\\n| {@fun/Exchange/exchange.Encode exchange.Encode} | ```exchange.Encode()```函数用于执行签名与加密计算。 |\\n\\n### IO\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/IO/exchange.IO exchange.IO} | ```exchange.IO()```函数用于调用交易所对象相关的其它接口。 |\\n| ```exchange.IO(\\\"api\\\", ...)``` | ```exchange.IO(\\\"api\\\", ...)```调用交易所未封装的原始REST接口，签名由平台自动处理。 |\\n| ```exchange.IO(\\\"currency\\\", ...)``` | ```exchange.IO(\\\"currency\\\", ...)```在运行时切换交易所对象的当前交易对。 |\\n| ```exchange.IO(\\\"base\\\", ...)``` | ```exchange.IO(\\\"base\\\", ...)```切换交易接口的基地址，```exchange.IO(\\\"mbase\\\", ...)```切换行情接口的基地址。 |\\n| ```exchange.IO(mode, value)``` | ```exchange.IO(mode, value)```切换交易所的交易模式：模拟盘/实盘、全仓/逐仓、双向/单向持仓、统一账户、杠杆模式、自成交预防等。 |\\n| ```exchange.IO(\\\"rate\\\", ...)``` | ```exchange.IO(\\\"rate\\\", ...)```与```exchange.IO(\\\"quota\\\", ...)```限制API函数的调用频率。 |\\n\\n### Network\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Network/HttpQuery HttpQuery} | 发送HTTP请求。 |\\n| {@fun/Network/HttpQuery_Go HttpQuery_Go} | 发送Http请求，是```HttpQuery```函数的异步版本。 |\\n| {@fun/Network/Dial Dial} | 用于原始 ```Socket``` 访问，支持 ```tcp```、```udp```、```tls```、```unix``` 协议。 |\\n| {@fun/Network/Mail Mail} | 发送邮件。 |\\n| {@fun/Network/Mail_Go Mail_Go} | ```Mail```函数的异步版本。 |\\n\\n### Storage\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Storage/_G _G} | 持久化保存数据。 |\\n| {@fun/Storage/DBExec DBExec} | 数据库接口函数。 |\\n| {@fun/Storage/SetChannelData SetChannelData} | 在频道上发布最新的状态数据。 |\\n| {@fun/Storage/GetChannelData GetChannelData} | 订阅指定实盘的频道数据。 |\\n\\n### Threads\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/exchange.Go exchange.Go} | 多线程异步支持函数，可将所有受支持函数的操作转换为异步并发执行。 |\\n| {@fun/Threads/EventLoop EventLoop} | 监听事件，当任意```WebSocket```有可读数据，或```exchange.Go()```、```HttpQuery_Go()```等并发任务完成后返回。 |\\n\\n#### Threads/threading\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/threading/Thread Thread} | ```Thread()```函数用于创建并发线程。 |\\n| {@fun/Threads/threading/getThread getThread} | ```getThread()```函数用于根据指定的线程ID获取线程对象。 |\\n| {@fun/Threads/threading/mainThread mainThread} | ```mainThread()```函数用于获取主线程的线程对象，即策略中```main()```函数所在的线程。 |\\n| {@fun/Threads/threading/currentThread currentThread} | ```currentThread()```函数用于获取当前线程的线程对象。 |\\n| {@fun/Threads/threading/Lock Lock} | ```Lock()```函数用于创建线程锁对象。 |\\n| {@fun/Threads/threading/Condition Condition} | ```Condition()```函数用于创建一个条件变量对象，该对象用于在多线程并发环境中实现线程间的同步与通信。 |\\n| {@fun/Threads/threading/Event Event} | ```Event()```函数用于创建一个*线程事件*对象，该对象用于线程间的同步，允许一个线程等待另一个线程的通知或信号。 |\\n| {@fun/Threads/threading/Dict Dict} | ```Dict()```函数用于创建一个字典对象，用于在并发线程间传递和共享数据。 |\\n| {@fun/Threads/threading/Serve Serve} | ```Serve()```函数在策略进程内创建Http服务、TCP服务、Websocket服务（基于Http协议），返回Server对象。 |\\n| {@fun/Threads/threading/pending pending} | ```pending```函数用于获取当前策略程序中正在运行的并发线程数量。 |\\n\\n#### Threads/Thread\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/Thread/peekMessage peekMessage} | ```peekMessage()```函数用于从线程接收消息。 |\\n| {@fun/Threads/Thread/postMessage postMessage} | ```postMessage()```函数用于向线程发送消息。 |\\n| {@fun/Threads/Thread/join join} | ```join()```函数用于等待线程退出，并回收系统资源。 |\\n| {@fun/Threads/Thread/terminate terminate} | ```terminate()```函数用于强制终止线程，释放创建线程时占用的硬件资源。 |\\n| {@fun/Threads/Thread/getData getData} | ```getData()```函数用于访问线程环境中记录的变量。 |\\n| {@fun/Threads/Thread/setData setData} | ```setData()```函数用于在线程环境中存储变量。 |\\n| {@fun/Threads/Thread/id id} | ```id()```函数用于返回当前多线程对象实例的```threadId```。 |\\n| {@fun/Threads/Thread/name name} | ```name()```函数用于返回当前多线程对象实例的名称。 |\\n| {@fun/Threads/Thread/eventLoop eventLoop} | ```eventLoop()``` 函数用于监听当前线程接收到的事件。 |\\n\\n#### Threads/ThreadLock\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadLock/acquire acquire} | ```acquire()```函数用于请求线程锁（加锁）。 |\\n| {@fun/Threads/ThreadLock/release release} | ```release()```函数用于释放线程锁（解锁）。 |\\n\\n#### Threads/ThreadEvent\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadEvent/set set} | ```set()```函数用于设置事件信号。 |\\n| {@fun/Threads/ThreadEvent/clear clear} | ```clear()```函数用于清除信号。 |\\n| {@fun/Threads/ThreadEvent/wait wait} | ```wait()```函数用于设置事件（信号）等待，在事件（信号）被设置之前会阻塞；支持设置超时参数。 |\\n| {@fun/Threads/ThreadEvent/isSet isSet} | ```isSet()```函数用于判断事件（信号）是否已被设置。 |\\n\\n#### Threads/ThreadCondition\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadCondition/notify notify} | ```notify()```函数用于唤醒一个正在等待的线程（如果存在）。 |\\n| {@fun/Threads/ThreadCondition/notifyAll notifyAll} | ```notifyAll()```函数用于唤醒所有正在等待的线程。 |\\n| {@fun/Threads/ThreadCondition/wait wait} | ```wait()```函数用于在特定条件下使线程进入等待状态。 |\\n| {@fun/Threads/ThreadCondition/acquire acquire} | ```acquire()```函数用于请求线程锁（加锁）。 |\\n| {@fun/Threads/ThreadCondition/release release} | ```release()```函数用于释放线程锁（解锁）。 |\\n\\n#### Threads/ThreadDict\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadDict/get get} | ```get()```函数用于获取字典对象中记录的键值。 |\\n| {@fun/Threads/ThreadDict/set set} | ```set()```函数用于设置键值对。 |\\n\\n#### Threads/Server\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/Server/addr addr} | ```addr()```函数返回服务实际监听的地址和端口。 |\\n| {@fun/Threads/Server/close close} | ```close()```函数停止接收新连接，正在执行的处理函数继续执行完（优雅关闭）。 |\\n| {@fun/Threads/Server/stop stop} | ```stop()```函数先关闭服务（同```close()```），再强制结束所有正在执行的处理函数线程。 |\\n| {@fun/Threads/Server/join join} | ```join()```函数等待服务关闭且所有处理函数执行完毕。 |\\n| {@fun/Threads/Server/pending pending} | ```pending()```函数返回当前正在执行的处理函数数量，即正在处理的连接或请求数。 |\\n\\n### Web3\\n\\n| 名称 | 说明 |\\n| - | - |\\n| ```exchange.IO(\\\"abi\\\", ...)``` | 在发明者量化交易平台中，区块链相关的各种功能和调用主要通过```exchange.IO()```函数实现。 |\\n| ```exchange.IO(\\\"api\\\", blockChain, ...)``` | ```exchange.IO(\\\"api\\\", \\\"eth\\\", ...)```调用方式用于调用以太坊RPC方法（配置Web3交易所对象时需选择eth）。 |\\n| ```exchange.IO(\\\"encode\\\", ...)``` | ```exchange.IO(\\\"encode\\\", ...)```函数的这种调用方式用于数据编码。 |\\n| ```exchange.IO(\\\"encodePacked\\\", ...)``` | ```exchange.IO(\\\"encodePacked\\\", ...)```函数用于执行```encodePacked```编码操作。 |\\n| ```exchange.IO(\\\"decode\\\", ...)``` | ```exchange.IO(\\\"decode\\\", ...)```调用方式用于对数据进行解码。 |\\n| ```exchange.IO(\\\"hash\\\", ...)``` | ```exchange.IO(\\\"hash\\\", ...)```函数的调用方式用于计算哈希摘要、HMAC，以及使用交易所对象配置的私钥签名等，参数与Encode函数相同。 |\\n| ```exchange.IO(\\\"key\\\", ...)``` | ```exchange.IO(\\\"key\\\", ...)```函数用于切换私钥的调用方式。 |\\n| ```exchange.IO(\\\"sign\\\", ...)``` | ```exchange.IO(\\\"sign\\\", ...)```调用方式用于使用secp256k1私钥对32字节哈希进行签名，返回r、s、v等签名数据，适用于EIP-712结构化数据签名（如ERC-20 Permit授权、1inch限价单）等需要链下签名的场景。 |\\n| ```exchange.IO(\\\"signTypedData\\\", ...)``` | ```exchange.IO(\\\"signTypedData\\\", ...)```函数的调用方式用于按照EIP-712标准对结构化数据进行签名，一次调用即可完成类型哈希、域分隔符、结构体哈希和摘要的计算并签名，适用于ERC-20 Permit、Permit2、UniswapX、CoW、1inch限价单等场景。 |\\n| ```exchange.IO(\\\"signMessage\\\", ...)``` | ```exchange.IO(\\\"signMessage\\\", ...)```调用方式用于按照EIP-191标准（```personal_sign```）对消息进行签名，签名结果与ethers的```signMessage```、钱包的```personal_sign```一致，常用于DApp登录、链下鉴权等场景。 |\\n| ```exchange.IO(\\\"api\\\", ...)``` | ```exchange.IO(\\\"api\\\", ...)```调用方式用于调用智能合约的方法。 |\\n| ```exchange.IO(\\\"call\\\", ...)``` | ```exchange.IO(\\\"call\\\", ...)```调用方式通过```eth_call```模拟执行智能合约的任意方法（包括会修改链上状态的写入方法），该过程不签名、不广播交易、不消耗gas，适用于链上询价、交易预演以及检查交易能否成功执行。 |\\n| ```exchange.IO(\\\"multicall\\\", ...)``` | ```exchange.IO(\\\"multicall\\\", ...)```调用方式用于通过Multicall3合约在一次请求中批量读取多个合约调用的结果，适用于批量查询余额、流动池状态、报价等数据，可有效减少RPC请求次数。 |\\n| ```exchange.IO(\\\"logs\\\", ...)``` | ```exchange.IO(\\\"logs\\\", ...)```调用方式用于查询合约的事件日志（```eth_getLogs```），并按ABI进行解码。 |\\n| ```exchange.IO(\\\"waitReceipt\\\", ...)``` | ```exchange.IO(\\\"waitReceipt\\\", ...)```调用方式用于等待交易上链并达到指定的确认数，返回交易回执及解码后的事件日志。 |\\n| ```exchange.IO(\\\"nonce\\\", ...)``` | ```exchange.IO(\\\"nonce\\\", ...)```函数的调用方式用于查看、同步或设置发送交易时使用的nonce计数。 |\\n| ```exchange.IO(\\\"speedUp\\\", ...)``` | ```exchange.IO(\\\"speedUp\\\", ...)```调用方式用于对卡住（长时间未上链）的交易进行加价重发：保持接收地址、金额、调用数据和gas上限不变，仅提高手续费。 |\\n| ```exchange.IO(\\\"cancelTx\\\", ...)``` | ```exchange.IO(\\\"cancelTx\\\", ...)```调用方式用于取消尚未上链的交易：使用与原交易相同的nonce，以更高的手续费发送一笔转给自己的0金额交易；该交易先上链后，原交易即失效。 |\\n| ```exchange.IO(\\\"toUnits\\\", ...)``` | ```exchange.IO(\\\"toUnits\\\", ...)```函数的调用方式用于将可读数量换算为链上整数。 |\\n| ```exchange.IO(\\\"fromUnits\\\", ...)``` | ```exchange.IO(\\\"fromUnits\\\", ...)```调用方式用于将链上整数值换算为可读数量，整个换算过程基于字符串进行精确计算，不经过浮点数运算，避免精度损失。 |\\n| ```exchange.IO(\\\"uniswapV3\\\", ...)``` | ```exchange.IO(\\\"uniswapV3\\\", ...)```调用方式用于集中流动性（Uniswap V3）相关的计算，包括tick、价格与sqrtPriceX96之间的换算，以及流动性与代币数量之间的换算。 |\\n| ```exchange.IO(\\\"contracts\\\", ...)``` | ```exchange.IO(\\\"contracts\\\", ...)```调用方式用于获取当前链（或指定链）的常用合约地址，包括主流代币、Multicall3、Permit2，以及Uniswap V3、PancakeSwap V3的Factory、路由、QuoterV2和头寸管理合约。 |\\n| {@fun/Web3/exchange.IO(\\\"address\\\") exchange.IO(\\\"address\\\")} | ```exchange.IO(\\\"address\\\")```函数的调用方式用于获取exchange交易所对象配置的钱包的地址。 |\\n| ```exchange.IO(\\\"base\\\", ...)``` | ```exchange.IO(\\\"base\\\", ...)```调用方式用于设置RPC节点地址，支持设置多个节点互为备用。 |\\n| ```exchange.IO(\\\"sendBase\\\", ...)``` | ```exchange.IO(\\\"sendBase\\\", ...)```调用方式用于设置仅用于广播交易的节点。 |\\n\\n### Uniswap\\n\\n| 名称 | 说明 |\\n| - | - |\\n| ```exchange.IO(\\\"transfer\\\", ...)``` | ```exchange.IO(\\\"transfer\\\", ...)```调用方式用于从Uniswap交易所对象所配置的钱包中转出链上原生币（如ETH、BNB）或ERC20代币。 |\\n| ```exchange.IO(\\\"receipt\\\", ...)``` | 以```exchange.IO(\\\"receipt\\\", ...)```方式调用该函数，可查询Uniswap交易所对象所发出交易（如下单、转账等）的回执，也可等待交易上链。 |\\n| ```exchange.IO(\\\"route\\\", ...)``` | ```exchange.IO(\\\"route\\\", ...)```调用用于在Uniswap交易所对象上询价：列出一笔兑换在各条候选路径上的报价以及最优路径，不会实际下单。 |\\n| ```exchange.IO(\\\"simulate\\\", ...)``` | ```exchange.IO(\\\"simulate\\\", ...)```调用方式按照Uniswap交易所对象的下单逻辑（路径选择、询价、价格保护）构造兑换交易，仅在链上进行模拟执行（```eth_call```），不签名、不广播，也不消耗gas。 |\\n| ```exchange.IO(\\\"token\\\", ...)``` | ```exchange.IO(\\\"token\\\", ...)```函数的调用方式用于在Uniswap交易所对象上登记代币，或者列出代币表。 |\\n| ```exchange.IO(\\\"wrap\\\", ...)``` | ```exchange.IO(\\\"wrap\\\", ...)```函数的调用方式用于在Uniswap交易所对象上把原生币（ETH、BNB）包装成包装币（WETH、WBNB），1:1兑换，没有滑点，只花gas。 |\\n| ```exchange.IO(\\\"unwrap\\\", ...)``` | ```exchange.IO(\\\"unwrap\\\", ...)```函数的调用方式用于在Uniswap交易所对象上把包装币（WETH、WBNB）解包成原生币（ETH、BNB），1:1兑换，没有滑点，只花gas。 |\\n| ```exchange.IO(\\\"approve\\\", ...)``` | 以```exchange.IO(\\\"approve\\\", ...)```方式调用该函数，可在Uniswap交易所对象上设置代币授权模式。 |\\n| ```exchange.IO(\\\"slippage\\\", ...)``` | ```exchange.IO(\\\"slippage\\\", ...)```函数的此种调用方式用于为Uniswap交易所对象设置市价单的滑点保护。 |\\n| ```exchange.IO(\\\"deadline\\\", ...)``` | ```exchange.IO(\\\"deadline\\\", ...)```调用方式用于在Uniswap交易所对象上设置交易的截止时间。 |\\n| ```exchange.IO(\\\"gasMultiplier\\\", ...)``` | ```exchange.IO(\\\"gasMultiplier\\\", ...)```调用方式用于在Uniswap交易所对象上设置gas上限倍数。 |\\n\\n### TA\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/TA/TA.MACD TA.MACD} | ```TA.MACD()```函数用于计算**指数平滑异同移动平均线（MACD）指标**。 |\\n| {@fun/TA/TA.KDJ TA.KDJ} | ```TA.KDJ()```函数用于计算**随机指标（KDJ）**。 |\\n| {@fun/TA/TA.RSI TA.RSI} | ```TA.RSI()```函数用于计算**相对强弱指标（RSI）**。 |\\n| {@fun/TA/TA.ATR TA.ATR} | ```TA.ATR()```函数用于计算**平均真实波幅指标（ATR）**。 |\\n| {@fun/TA/TA.OBV TA.OBV} | ```TA.OBV()```函数用于计算**能量潮指标（OBV）**。 |\\n| {@fun/TA/TA.MA TA.MA} | ```TA.MA()```函数用于计算**移动平均线指标（Moving Average）**。 |\\n| {@fun/TA/TA.EMA TA.EMA} | ```TA.EMA()```函数用于计算**指数移动平均线（EMA）指标**。 |\\n| {@fun/TA/TA.BOLL TA.BOLL} | ```TA.BOLL()```函数用于计算**布林带指标**。 |\\n| {@fun/TA/TA.Alligator TA.Alligator} | ```TA.Alligator()```函数用于计算**鳄鱼线指标（Alligator）**。 |\\n| {@fun/TA/TA.CMF TA.CMF} | ```TA.CMF()```函数用于计算**蔡金资金流量指标（Chaikin Money Flow）**。 |\\n| {@fun/TA/TA.Highest TA.Highest} | ```TA.Highest()```函数用于计算**周期内最高价**。 |\\n| {@fun/TA/TA.Lowest TA.Lowest} | ```TA.Lowest()```函数用于计算**周期最低价**。 |\\n| {@fun/TA/TA.SMA TA.SMA} | ```TA.SMA()```函数用于计算**简单移动平均线（SMA）指标**。 |\\n\\n#### Talib/OverlapStudies\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/OverlapStudies/talib.BBANDS talib.BBANDS} | ```talib.BBANDS()```函数用于计算**Bollinger Bands（布林带）**。 |\\n| {@fun/Talib/OverlapStudies/talib.DEMA talib.DEMA} | ```talib.DEMA()```函数用于计算**Double Exponential Moving Average（双指数移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.EMA talib.EMA} | ```talib.EMA()```函数用于计算**Exponential Moving Average（指数移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.HT_TRENDLINE talib.HT_TRENDLINE} | ```talib.HT_TRENDLINE()```函数用于计算**Hilbert Transform - Instantaneous Trendline（希尔伯特变换瞬时趋势线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.KAMA talib.KAMA} | ```talib.KAMA()```函数用于计算**Kaufman自适应移动平均线（Kaufman Adaptive Moving Average）**。 |\\n| {@fun/Talib/OverlapStudies/talib.MA talib.MA} | ```talib.MA()```函数用于计算**Moving average（移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.MAMA talib.MAMA} | ```talib.MAMA()```函数用于计算**MESA自适应移动平均线（MESA Adaptive Moving Average）**。 |\\n| {@fun/Talib/OverlapStudies/talib.MIDPOINT talib.MIDPOINT} | ```talib.MIDPOINT()```函数用于计算**MidPoint over period（中点价格）**。 |\\n| {@fun/Talib/OverlapStudies/talib.MIDPRICE talib.MIDPRICE} | ```talib.MIDPRICE()```函数用于计算**Midpoint Price over period（中点价格）**。 |\\n| {@fun/Talib/OverlapStudies/talib.SAR talib.SAR} | ```talib.SAR()```函数用于计算**抛物线转向指标（Parabolic SAR）**。 |\\n| {@fun/Talib/OverlapStudies/talib.SAREXT talib.SAREXT} | ```talib.SAREXT()```函数用于计算**Parabolic SAR - Extended（增强型抛物线转向指标）**。 |\\n| {@fun/Talib/OverlapStudies/talib.SMA talib.SMA} | ```talib.SMA()```函数用于计算**Simple Moving Average（简单移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.T3 talib.T3} | ```talib.T3()```函数用于计算**Triple Exponential Moving Average (T3) (三重指数移动平均)**。 |\\n| {@fun/Talib/OverlapStudies/talib.TEMA talib.TEMA} | ```talib.TEMA()```函数用于计算**Triple Exponential Moving Average（三重指数移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.TRIMA talib.TRIMA} | ```talib.TRIMA()```函数用于计算**Triangular Moving Average（三角移动平均线）**。 |\\n| {@fun/Talib/OverlapStudies/talib.WMA talib.WMA} | ```talib.WMA()```函数用于计算**Weighted Moving Average（加权移动平均）**。 |\\n\\n#### Talib/MomentumIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MomentumIndicators/talib.ADX talib.ADX} | ```talib.ADX()```函数用于计算**Average Directional Movement Index（平均趋向指数）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ADXR talib.ADXR} | ```talib.ADXR()```函数用于计算**平均趋向指数评级（Average Directional Movement Index Rating）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.APO talib.APO} | ```talib.APO()```函数用于计算**Absolute Price Oscillator（绝对价格振荡器）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.AROON talib.AROON} | ```talib.AROON()```函数用于计算**Aroon（阿隆指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.AROONOSC talib.AROONOSC} | ```talib.AROONOSC()```函数用于计算**Aroon Oscillator（阿隆震荡指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.BOP talib.BOP} | ```talib.BOP()```函数用于计算**Balance Of Power（均势指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.CCI talib.CCI} | ```talib.CCI()```函数用于计算**Commodity Channel Index（商品通道指数）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.CMO talib.CMO} | ```talib.CMO()```函数用于计算**Chande Momentum Oscillator（钱德动量摆动指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.DX talib.DX} | ```talib.DX()```函数用于计算**Directional Movement Index（动向指数）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACD talib.MACD} | ```talib.MACD()```函数用于计算**Moving Average Convergence/Divergence（移动平均收敛发散指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACDEXT talib.MACDEXT} | ```talib.MACDEXT()```函数用于计算**MACD with controllable MA type（可控移动平均类型的MACD）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACDFIX talib.MACDFIX} | ```talib.MACDFIX()```函数用于计算**Moving Average Convergence/Divergence Fix 12/26（移动平均收敛/发散固定12/26）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MFI talib.MFI} | ```talib.MFI()```函数用于计算**Money Flow Index（资金流量指数）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DI talib.MINUS_DI} | ```talib.MINUS_DI()```函数用于计算**负向指标（Minus Directional Indicator）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DM talib.MINUS_DM} | ```talib.MINUS_DM()```函数用于计算**负向运动指标（Minus Directional Movement）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.MOM talib.MOM} | ```talib.MOM()```函数用于计算**Momentum（动量指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DI talib.PLUS_DI} | ```talib.PLUS_DI()```函数用于计算**Plus Directional Indicator（正向指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DM talib.PLUS_DM} | ```talib.PLUS_DM()```函数用于计算**Plus Directional Movement（正向运动指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.PPO talib.PPO} | ```talib.PPO()```函数用于计算**Percentage Price Oscillator（价格振荡百分比）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROC talib.ROC} | ```talib.ROC()```函数用于计算**变动率指标（Rate of change）：((price/prevPrice)-1)*100**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCP talib.ROCP} | ```talib.ROCP()```函数用于计算**价格变化率百分比：(price-prevPrice)/prevPrice**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR talib.ROCR} | ```talib.ROCR()```函数用于计算**价格变化率比值：(price/prevPrice)**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR100 talib.ROCR100} | ```talib.ROCR100()```函数用于计算**Rate of change ratio 100 scale: (price/prevPrice)*100（价格变化率比例100倍）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.RSI talib.RSI} | ```talib.RSI()```函数用于计算**Relative Strength Index（相对强弱指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCH talib.STOCH} | ```talib.STOCH()```函数用于计算**随机指标（STOCH指标）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHF talib.STOCHF} | ```talib.STOCHF()```函数用于计算**快速随机指标（Stochastic Fast）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHRSI talib.STOCHRSI} | ```talib.STOCHRSI()```函数用于计算**随机相对强弱指数（Stochastic Relative Strength Index）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.TRIX talib.TRIX} | ```talib.TRIX()```函数用于计算**1-day Rate-Of-Change (ROC) of a Triple Smooth EMA（三重指数平滑移动平均线的一日变化率）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.ULTOSC talib.ULTOSC} | ```talib.ULTOSC()```函数用于计算**Ultimate Oscillator（极限振荡器）**。 |\\n| {@fun/Talib/MomentumIndicators/talib.WILLR talib.WILLR} | ```talib.WILLR()```函数用于计算**Williams' %R（威廉指标）**。 |\\n\\n#### Talib/VolumeIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/VolumeIndicators/talib.AD talib.AD} | ```talib.AD()```函数用于计算**Chaikin A/D Line（累积/派发线指标）**。 |\\n| {@fun/Talib/VolumeIndicators/talib.ADOSC talib.ADOSC} | ```talib.ADOSC()```函数用于计算**Chaikin A/D Oscillator（佳庆指标）**。 |\\n| {@fun/Talib/VolumeIndicators/talib.OBV talib.OBV} | ```talib.OBV()```函数用于计算**On Balance Volume（能量潮指标）**。 |\\n\\n#### Talib/VolatilityIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/VolatilityIndicators/talib.ATR talib.ATR} | ```talib.ATR()```函数用于计算**Average True Range（平均真实波幅）**指标。 |\\n| {@fun/Talib/VolatilityIndicators/talib.NATR talib.NATR} | ```talib.NATR()```函数用于计算**Normalized Average True Range（归一化平均真实范围）**。 |\\n| {@fun/Talib/VolatilityIndicators/talib.TRANGE talib.TRANGE} | ```talib.TRANGE()```函数用于计算**True Range（真实范围）**指标。 |\\n\\n#### Talib/CycleIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPERIOD talib.HT_DCPERIOD} | ```talib.HT_DCPERIOD()```函数用于计算**Hilbert Transform - Dominant Cycle Period（希尔伯特变换主导周期）**。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPHASE talib.HT_DCPHASE} | ```talib.HT_DCPHASE()```函数用于计算**希尔伯特变换主周期相位（Hilbert Transform - Dominant Cycle Phase）**。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_PHASOR talib.HT_PHASOR} | ```talib.HT_PHASOR()```函数用于计算**Hilbert Transform - Phasor Components（希尔伯特变换-相量分量）**。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_SINE talib.HT_SINE} | ```talib.HT_SINE()```函数用于计算**Hilbert Transform - SineWave（希尔伯特变换 - 正弦波）**。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_TRENDMODE talib.HT_TRENDMODE} | ```talib.HT_TRENDMODE()```函数用于计算**Hilbert Transform - Trend vs Cycle Mode（希尔伯特变换 - 趋势与周期模式）**。 |\\n\\n#### Talib/PriceTransform\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/PriceTransform/talib.AVGPRICE talib.AVGPRICE} | ```talib.AVGPRICE()```函数用于计算**Average Price（平均价格）**。 |\\n| {@fun/Talib/PriceTransform/talib.MEDPRICE talib.MEDPRICE} | ```talib.MEDPRICE()```函数用于计算**Median Price（中位数价格）**。 |\\n| {@fun/Talib/PriceTransform/talib.TYPPRICE talib.TYPPRICE} | ```talib.TYPPRICE()```函数用于计算**典型价格（Typical Price）**。 |\\n| {@fun/Talib/PriceTransform/talib.WCLPRICE talib.WCLPRICE} | ```talib.WCLPRICE()```函数用于计算**Weighted Close Price（加权收盘价）**。 |\\n\\n#### Talib/StatisticFunctions\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG talib.LINEARREG} | ```talib.LINEARREG()```函数用于计算**Linear Regression（线性回归）**指标。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_ANGLE talib.LINEARREG_ANGLE} | ```talib.LINEARREG_ANGLE()```函数用于计算**Linear Regression Angle（线性回归角度）**。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_INTERCEPT talib.LINEARREG_INTERCEPT} | ```talib.LINEARREG_INTERCEPT()```函数用于计算**线性回归截距（Linear Regression Intercept）**。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_SLOPE talib.LINEARREG_SLOPE} | ```talib.LINEARREG_SLOPE()```函数用于计算**Linear Regression Slope（线性回归斜率）**。 |\\n| {@fun/Talib/StatisticFunctions/talib.STDDEV talib.STDDEV} | ```talib.STDDEV()```函数用于计算**标准偏差（Standard Deviation）**。 |\\n| {@fun/Talib/StatisticFunctions/talib.TSF talib.TSF} | ```talib.TSF()```函数用于计算**Time Series Forecast（时间序列预测）**。 |\\n| {@fun/Talib/StatisticFunctions/talib.VAR talib.VAR} | ```talib.VAR()```函数用于计算**方差（Variance）**。 |\\n\\n#### Talib/MathTransform\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MathTransform/talib.ACOS talib.ACOS} | ```talib.ACOS()```函数用于计算**向量三角反余弦函数（Vector Trigonometric ACos）**。 |\\n| {@fun/Talib/MathTransform/talib.ASIN talib.ASIN} | ```talib.ASIN()```函数用于计算**向量三角反正弦函数（Vector Trigonometric ASin）**。 |\\n| {@fun/Talib/MathTransform/talib.ATAN talib.ATAN} | ```talib.ATAN()```函数用于计算**向量三角反正切函数（Vector Trigonometric ATan）**。 |\\n| {@fun/Talib/MathTransform/talib.CEIL talib.CEIL} | ```talib.CEIL()```函数用于计算**向上取整（Vector Ceil）**。 |\\n| {@fun/Talib/MathTransform/talib.COS talib.COS} | ```talib.COS()```函数用于计算**Vector Trigonometric Cos（向量三角余弦函数）**。 |\\n| {@fun/Talib/MathTransform/talib.COSH talib.COSH} | ```talib.COSH()```函数用于计算**向量三角双曲余弦值（Vector Trigonometric Cosh）**。 |\\n| {@fun/Talib/MathTransform/talib.EXP talib.EXP} | ```talib.EXP()```函数用于计算**向量算术指数函数（Vector Arithmetic Exp）**。 |\\n| {@fun/Talib/MathTransform/talib.FLOOR talib.FLOOR} | ```talib.FLOOR()```函数用于计算**向量向下取整（Vector Floor）**。 |\\n| {@fun/Talib/MathTransform/talib.LN talib.LN} | ```talib.LN()```函数用于计算**向量自然对数（Vector Log Natural）**。 |\\n| {@fun/Talib/MathTransform/talib.LOG10 talib.LOG10} | ```talib.LOG10()```函数用于计算**Vector Log10（对数函数）**。 |\\n| {@fun/Talib/MathTransform/talib.SIN talib.SIN} | ```talib.SIN()```函数用于计算**Vector Trigonometric Sin（正弦值）**。 |\\n| {@fun/Talib/MathTransform/talib.SINH talib.SINH} | ```talib.SINH()```函数用于计算**向量三角双曲正弦函数（Vector Trigonometric Sinh）**。 |\\n| {@fun/Talib/MathTransform/talib.SQRT talib.SQRT} | ```talib.SQRT()```函数用于计算**向量平方根（Vector Square Root）**。 |\\n| {@fun/Talib/MathTransform/talib.TAN talib.TAN} | ```talib.TAN()```函数用于计算**向量三角正切值（Vector Trigonometric Tan）**。 |\\n| {@fun/Talib/MathTransform/talib.TANH talib.TANH} | ```talib.TANH()```函数用于计算**向量三角双曲正切函数（Vector Trigonometric Tanh）**。 |\\n\\n#### Talib/MathOperators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MathOperators/talib.MAX talib.MAX} | ```talib.MAX()```函数用于计算**指定周期内的最大值（Highest value over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.MAXINDEX talib.MAXINDEX} | ```talib.MAXINDEX()```函数用于计算**指定周期内最大值的索引位置（Index of highest value over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.MIN talib.MIN} | ```talib.MIN()```函数用于计算**指定周期内的最小值（Lowest value over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.MININDEX talib.MININDEX} | ```talib.MININDEX()```函数用于计算**指定周期内最小值的索引位置（Index of lowest value over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.MINMAX talib.MINMAX} | ```talib.MINMAX()```函数用于计算**指定周期内的最小值和最大值（Lowest and highest values over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.MINMAXINDEX talib.MINMAXINDEX} | ```talib.MINMAXINDEX()```函数用于计算**指定周期内最低值和最高值的索引位置（Indexes of lowest and highest values over a specified period）**。 |\\n| {@fun/Talib/MathOperators/talib.SUM talib.SUM} | ```talib.SUM()```函数用于计算**求和（Summation）**。 |\\n\\n#### Talib/PatternRecognition\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/PatternRecognition/talib.CDL2CROWS talib.CDL2CROWS} | ```talib.CDL2CROWS()```函数用于计算**Two Crows（K线形态--两只乌鸦）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3BLACKCROWS talib.CDL3BLACKCROWS} | ```talib.CDL3BLACKCROWS()```函数用于计算**Three Black Crows（K线图形态--三只黑乌鸦）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3INSIDE talib.CDL3INSIDE} | ```talib.CDL3INSIDE()```函数用于计算**Three Inside Up/Down（K线形态：三内上下震荡）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3LINESTRIKE talib.CDL3LINESTRIKE} | ```talib.CDL3LINESTRIKE()```函数用于计算**Three-Line Strike（K线图：三线震荡）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3OUTSIDE talib.CDL3OUTSIDE} | ```talib.CDL3OUTSIDE()```函数用于计算**Three Outside Up/Down（K线形态：三外包线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3STARSINSOUTH talib.CDL3STARSINSOUTH} | ```talib.CDL3STARSINSOUTH()```函数用于计算**Three Stars In The South（K线形态：南方三星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3WHITESOLDIERS talib.CDL3WHITESOLDIERS} | ```talib.CDL3WHITESOLDIERS()```函数用于计算**Three Advancing White Soldiers（K线形态：三白兵）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLABANDONEDBABY talib.CDLABANDONEDBABY} | ```talib.CDLABANDONEDBABY()```函数用于计算**弃婴形态（K线图：Abandoned Baby）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLADVANCEBLOCK talib.CDLADVANCEBLOCK} | ```talib.CDLADVANCEBLOCK()```函数用于计算**Advance Block（K线形态：推进阻挡）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLBELTHOLD talib.CDLBELTHOLD} | ```talib.CDLBELTHOLD()```函数用于计算**Belt-hold（K线形态：腰带线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLBREAKAWAY talib.CDLBREAKAWAY} | ```talib.CDLBREAKAWAY()```函数用于计算**Breakaway（K线形态：分离形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCLOSINGMARUBOZU talib.CDLCLOSINGMARUBOZU} | ```talib.CDLCLOSINGMARUBOZU()```函数用于计算**收盘光头光脚线（Closing Marubozu）**K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCONCEALBABYSWALL talib.CDLCONCEALBABYSWALL} | ```talib.CDLCONCEALBABYSWALL()```函数用于计算**Concealing Baby Swallow（K线图：藏婴吞没形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCOUNTERATTACK talib.CDLCOUNTERATTACK} | ```talib.CDLCOUNTERATTACK()```函数用于计算**反击线形态（K线图：反击）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDARKCLOUDCOVER talib.CDLDARKCLOUDCOVER} | ```talib.CDLDARKCLOUDCOVER()```函数用于计算**乌云盖顶（Dark Cloud Cover）K线形态**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJI talib.CDLDOJI} | ```talib.CDLDOJI()```函数用于计算**Doji（K线图：十字星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJISTAR talib.CDLDOJISTAR} | ```talib.CDLDOJISTAR()```函数用于计算**Doji Star（K线图：十字星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDRAGONFLYDOJI talib.CDLDRAGONFLYDOJI} | ```talib.CDLDRAGONFLYDOJI()```函数用于计算**Dragonfly Doji（K线形态：蜻蜓十字星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLENGULFING talib.CDLENGULFING} | ```talib.CDLENGULFING()```函数用于计算**吞没形态（Engulfing Pattern）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGDOJISTAR talib.CDLEVENINGDOJISTAR} | ```talib.CDLEVENINGDOJISTAR()```函数用于计算**Evening Doji Star（K线形态：黄昏十字星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGSTAR talib.CDLEVENINGSTAR} | ```talib.CDLEVENINGSTAR()```函数用于计算**Evening Star（K线图：黄昏之星）**形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLGAPSIDESIDEWHITE talib.CDLGAPSIDESIDEWHITE} | ```talib.CDLGAPSIDESIDEWHITE()```函数用于计算**Up/Down-gap side-by-side white lines (K线图：上/下间隙并排白色线条)**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLGRAVESTONEDOJI talib.CDLGRAVESTONEDOJI} | ```talib.CDLGRAVESTONEDOJI()```函数用于计算**墓碑十字线（Gravestone Doji）**K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHAMMER talib.CDLHAMMER} | ```talib.CDLHAMMER()```函数用于计算**锤子线（K线形态：锤子）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHANGINGMAN talib.CDLHANGINGMAN} | ```talib.CDLHANGINGMAN()```函数用于计算**Hanging Man（K线形态：吊人线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMI talib.CDLHARAMI} | ```talib.CDLHARAMI()```函数用于计算**Harami Pattern（K线图：阴阳线模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMICROSS talib.CDLHARAMICROSS} | ```talib.CDLHARAMICROSS()```函数用于计算**Harami Cross Pattern（K线图：十字星孕线形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIGHWAVE talib.CDLHIGHWAVE} | ```talib.CDLHIGHWAVE()```函数用于计算**High-Wave Candle（K线图：长脚十字线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKE talib.CDLHIKKAKE} | ```talib.CDLHIKKAKE()```函数用于计算**Hikkake Pattern（K线图：陷阱模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKEMOD talib.CDLHIKKAKEMOD} | ```talib.CDLHIKKAKEMOD()```函数用于计算**Modified Hikkake Pattern（K线图：改良陷阱模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHOMINGPIGEON talib.CDLHOMINGPIGEON} | ```talib.CDLHOMINGPIGEON()```函数用于计算**Homing Pigeon（K线形态：信鸽形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLIDENTICAL3CROWS talib.CDLIDENTICAL3CROWS} | ```talib.CDLIDENTICAL3CROWS()```函数用于计算**Identical Three Crows（K线形态：相同三只乌鸦）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLINNECK talib.CDLINNECK} | ```talib.CDLINNECK()```函数用于计算**颈内线形态（K线图：颈内线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLINVERTEDHAMMER talib.CDLINVERTEDHAMMER} | ```talib.CDLINVERTEDHAMMER()```函数用于计算**倒锤形态（K线图：倒锤）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKING talib.CDLKICKING} | ```talib.CDLKICKING()```函数用于计算**Kicking（K线形态：踢腿形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKINGBYLENGTH talib.CDLKICKINGBYLENGTH} | ```talib.CDLKICKINGBYLENGTH()```函数用于计算**Kicking - bull/bear determined by the longer marubozu (K线图：踢牛/踢熊)**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLADDERBOTTOM talib.CDLLADDERBOTTOM} | ```talib.CDLLADDERBOTTOM()```函数用于计算**Ladder Bottom（K线形态：梯底）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLEGGEDDOJI talib.CDLLONGLEGGEDDOJI} | ```talib.CDLLONGLEGGEDDOJI()```函数用于计算**长腿十字线（K线形态：Long Legged Doji）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLINE talib.CDLLONGLINE} | ```talib.CDLLONGLINE()```函数用于计算**长线蜡烛形态（K线图：长线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMARUBOZU talib.CDLMARUBOZU} | ```talib.CDLMARUBOZU()```函数用于计算**Marubozu（K线图：光头光脚）**模式。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATCHINGLOW talib.CDLMATCHINGLOW} | ```talib.CDLMATCHINGLOW()```函数用于计算**Matching Low（K线图：匹配低点）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATHOLD talib.CDLMATHOLD} | ```talib.CDLMATHOLD()```函数用于计算**Mat Hold（K线形态：垫住）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGDOJISTAR talib.CDLMORNINGDOJISTAR} | ```talib.CDLMORNINGDOJISTAR()```函数用于计算**Morning Doji Star（K线形态：早晨十字星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGSTAR talib.CDLMORNINGSTAR} | ```talib.CDLMORNINGSTAR()```函数用于计算**Morning Star（K线形态：晨星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLONNECK talib.CDLONNECK} | ```talib.CDLONNECK()```函数用于计算**On-Neck Pattern（K线图：颈上线形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLPIERCING talib.CDLPIERCING} | ```talib.CDLPIERCING()```函数用于计算**Piercing Pattern（K线图：穿透形态）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLRICKSHAWMAN talib.CDLRICKSHAWMAN} | ```talib.CDLRICKSHAWMAN()```函数用于计算**Rickshaw Man（K线形态：车夫线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLRISEFALL3METHODS talib.CDLRISEFALL3METHODS} | ```talib.CDLRISEFALL3METHODS()```函数用于计算**Rising/Falling Three Methods（K线形态：上升/下降三法）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSEPARATINGLINES talib.CDLSEPARATINGLINES} | ```talib.CDLSEPARATINGLINES()```函数用于计算**分离线形态（K线图：分离线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHOOTINGSTAR talib.CDLSHOOTINGSTAR} | ```talib.CDLSHOOTINGSTAR()```函数用于计算**Shooting Star（K线形态：流星）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHORTLINE talib.CDLSHORTLINE} | ```talib.CDLSHORTLINE()```函数用于计算**短线蜡烛图形态（K线图：短线）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSPINNINGTOP talib.CDLSPINNINGTOP} | ```talib.CDLSPINNINGTOP()```函数用于计算**Spinning Top（K线形态：陀螺）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTALLEDPATTERN talib.CDLSTALLEDPATTERN} | ```talib.CDLSTALLEDPATTERN()```函数用于计算**Stalled Pattern（K线图：停滞模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTICKSANDWICH talib.CDLSTICKSANDWICH} | ```talib.CDLSTICKSANDWICH()```函数用于计算**Stick Sandwich（K线形态：棍子三明治）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTAKURI talib.CDLTAKURI} | ```talib.CDLTAKURI()```函数用于计算**Takuri (Dragonfly Doji with very long lower shadow) (K线图:托里)**蜡烛图形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTASUKIGAP talib.CDLTASUKIGAP} | ```talib.CDLTASUKIGAP()```函数用于计算**Tasuki Gap（K线图：翼隙）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTHRUSTING talib.CDLTHRUSTING} | ```talib.CDLTHRUSTING()```函数用于计算**Thrusting Pattern（K线图：推进模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTRISTAR talib.CDLTRISTAR} | ```talib.CDLTRISTAR()```函数用于计算**三星形态（K线图：三星模式）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLUNIQUE3RIVER talib.CDLUNIQUE3RIVER} | ```talib.CDLUNIQUE3RIVER()```函数用于计算**Unique 3 River（K线形态：独特三河）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLUPSIDEGAP2CROWS talib.CDLUPSIDEGAP2CROWS} | ```talib.CDLUPSIDEGAP2CROWS()```函数用于计算**向上跳空双乌鸦形态（K线图：双飞乌鸦）**。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLXSIDEGAP3METHODS talib.CDLXSIDEGAP3METHODS} | ```talib.CDLXSIDEGAP3METHODS()```函数用于计算**上行/下行缺口三方法（K线形态识别）**。 |\\n\\n### OS\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/ListFilesResult ListFilesResult} | 文件列表对象，用于记录目录列表信息。 |\\n| {@fun/OS/FileStat FileStat} | 文件统计信息对象。 |\\n\\n#### OS/os\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/os/open open} | 以指定模式打开文件。 |\\n| {@fun/OS/os/fgets fgets} | 一次性读取整个文件的内容。 |\\n| {@fun/OS/os/fputs fputs} | 向文件写入内容。 |\\n| {@fun/OS/os/mmap mmap} | 内存映射文件，返回文件的二进制数据。 |\\n| {@fun/OS/os/getRootDir getRootDir} | 获取文件操作的根目录路径。 |\\n| {@fun/OS/os/listFiles listFiles} | 列出指定目录中的文件和子目录。 |\\n| {@fun/OS/os/exists exists} | 检查指定的文件或目录是否存在。 |\\n| {@fun/OS/os/remove remove} | 删除指定文件。 |\\n| {@fun/OS/os/mkdir mkdir} | 创建目录。 |\\n| {@fun/OS/os/rmdir rmdir} | 删除目录及其所有内容。 |\\n| {@fun/OS/os/rename rename} | 重命名文件或移动文件。 |\\n| {@fun/OS/os/stat stat} | 获取文件的详细统计信息。 |\\n| {@fun/OS/os/exit exit} | 退出程序。 |\\n\\n#### OS/File\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/File/close close} | 关闭文件并释放相关资源。 |\\n| {@fun/OS/File/puts puts} | 向文件写入一个或多个字符串。 |\\n| {@fun/OS/File/printf printf} | 格式化写入数据到文件。 |\\n| {@fun/OS/File/flush flush} | 刷新文件缓冲区，确保数据写入磁盘。 |\\n| {@fun/OS/File/tell tell} | 获取当前文件指针的位置。 |\\n| {@fun/OS/File/seek seek} | 将文件指针移动到指定位置。 |\\n| {@fun/OS/File/eof eof} | 检查文件指针是否已到达文件末尾。 |\\n| {@fun/OS/File/read read} | 从文件中读取数据。 |\\n| {@fun/OS/File/write write} | 向文件写入字符串数据。 |\\n| {@fun/OS/File/getline getline} | 从文件中读取下一行内容。 |\\n| {@fun/OS/File/toString toString} | 获取文件对象的字符串表示形式。 |\\n\\n## 结构体\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@struct/Ticker Ticker} | 市场行情数据结构。 |\\n| {@struct/Depth Depth} | 市场深度数据结构。 |\\n| {@struct/OrderBook OrderBook} | 市场深度中的订单结构。 |\\n| {@struct/Trade Trade} | 市场成交记录的数据结构。 |\\n| {@struct/Record Record} | K线柱的数据结构，标准的OHLC格式，用于绘制K线图和技术指标计算分析。 |\\n| {@struct/Market Market} | 交易品种市场信息的数据结构。 |\\n| {@struct/Order Order} | 订单结构。 |\\n| {@struct/Condition Condition} | 条件单配置信息结构，用于设置条件单的触发条件和执行价格。 |\\n| {@struct/Account Account} | 账户信息的数据结构。 |\\n| {@struct/Asset Asset} | 具体币种资产信息的数据结构。 |\\n| {@struct/Position Position} | 合约仓位信息的数据结构。 |\\n| {@struct/Funding Funding} | 交易品种资金费率信息的数据结构，仅加密货币永续合约支持资金费率功能。 |\\n\\n### OtherStruct\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@struct/OtherStruct/HttpQuery-options HttpQuery-options} | 此JSON结构用于配置HttpQuery函数和HttpQuery_Go函数发送HTTP请求的各项参数。 |\\n| {@struct/OtherStruct/HttpQuery-return HttpQuery-return} | 该JSON结构是调用HttpQuery函数时，在参数```options```结构中将debug字段指定为true后，HttpQuery函数在调试模式下返回的数据结构。 |\\n| {@struct/OtherStruct/LogStatus-table LogStatus-table} | 此JSON结构用于配置策略状态栏中显示的表格内容。 |\\n| {@struct/OtherStruct/LogStatus-btnTypeOne LogStatus-btnTypeOne} | 该JSON结构用于配置状态栏中的按钮控件，按钮控件JSON结构可以嵌入到状态栏表格JSON结构中。 |\\n| {@struct/OtherStruct/LogStatus-btnTypeTwo LogStatus-btnTypeTwo} | 此JSON结构用于配置状态栏中的按钮控件，按钮控件JSON结构可以嵌入到状态栏表格JSON结构中。 |\\n| {@struct/OtherStruct/Chart-options Chart-options} | 此JSON用于配置自定义绘图函数```Chart()```的图表设置信息，图表库使用Highcharts。 |\\n| {@struct/OtherStruct/KLineChart-options KLineChart-options} | 此JSON用于设置自定义绘图函数```KLineChart```的图表配置信息。 |\\n| {@struct/OtherStruct/SetData-data SetData-data} | 该JSON用于设置```exchange.SetData()```函数所要加载的数据。 |\\n| {@struct/OtherStruct/EventLoop-return EventLoop-return} | 该JSON是```EventLoop()```函数返回的数据结构。 |\\n| {@struct/OtherStruct/DBExec-return DBExec-return} | 该JSON是```DBExec()```函数返回的数据结构；使用```Dial()```函数创建的对象的```exec()```方法执行SQL语句时，也返回此JSON数据结构。 |\\n| {@struct/OtherStruct/Thread.join-return Thread.join-return} | 该JSON是```Thread```对象的成员函数```join()```返回的数据结构，用于保存```JavaScript```语言策略中并发线程的相关信息。 |\\n\\n## 内置变量与常量\\n\\n### EXCHANGE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/EXCHANGE/exchange exchange} | exchange 是一个交易所对象，也是在策略实盘设置、回测设置中添加的第一个交易所对象。 |\\n| {@var/EXCHANGE/exchanges exchanges} | exchanges 是一个交易所对象数组，包含在策略实盘设置或回测设置中添加的所有交易所对象，其中 exchanges[0] 即为 exchange。 |\\n\\n### ORDER_STATE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_STATE/ORDER_STATE_PENDING ORDER_STATE_PENDING} | ORDER_STATE_PENDING是Order结构中的```Status```属性的值，表示订单状态为待处理状态。 |\\n| {@var/ORDER_STATE/ORDER_STATE_CLOSED ORDER_STATE_CLOSED} | ORDER_STATE_CLOSED是Order结构中的```Status```属性的值，表示订单状态为已完成。 |\\n| {@var/ORDER_STATE/ORDER_STATE_CANCELED ORDER_STATE_CANCELED} | ORDER_STATE_CANCELED 是 Order 结构中 ```Status``` 属性的值，表示订单状态为已取消。 |\\n| {@var/ORDER_STATE/ORDER_STATE_UNKNOWN ORDER_STATE_UNKNOWN} | ORDER_STATE_UNKNOWN是Order结构中的```Status```属性的值，表示订单状态为未知状态（其他状态）。 |\\n\\n### ORDER_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_TYPE/ORDER_TYPE_BUY ORDER_TYPE_BUY} | ORDER_TYPE_BUY是Order结构中的```Type```属性值，表示买入订单类型。 |\\n| {@var/ORDER_TYPE/ORDER_TYPE_SELL ORDER_TYPE_SELL} | ORDER_TYPE_SELL是Order结构中的```Type```属性值，用于表示卖单类型。 |\\n\\n### ORDER_CONDITION_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_OCO ORDER_CONDITION_TYPE_OCO} | ORDER_CONDITION_TYPE_OCO是Condition结构中的```ConditionType```属性的值，表示OCO订单（One-Cancels-the-Other，一触即撤订单）。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_TP ORDER_CONDITION_TYPE_TP} | ORDER_CONDITION_TYPE_TP 是 Condition 结构中的 ```ConditionType``` 属性值，表示止盈单（Take Profit）。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_SL ORDER_CONDITION_TYPE_SL} | ORDER_CONDITION_TYPE_SL 是 Condition 结构中的 ```ConditionType``` 属性值，表示止损单（Stop Loss）。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_GENERIC ORDER_CONDITION_TYPE_GENERIC} | ORDER_CONDITION_TYPE_GENERIC 是 Condition 结构中的 ```ConditionType``` 属性值，表示通用条件单。 |\\n\\n### POSITION_DIRECTION\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/POSITION_DIRECTION/PD_LONG PD_LONG} | PD_LONG是Position结构中的```Type```属性值，表示多头仓位类型。 |\\n| {@var/POSITION_DIRECTION/PD_SHORT PD_SHORT} | PD_SHORT是Position结构中的```Type```属性值，表示空头仓位类型。 |\\n\\n### ORDER_OFFSET\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_OPEN ORDER_OFFSET_OPEN} | ORDER_OFFSET_OPEN是Order结构中```Offset```属性的取值，表示该订单为开仓操作。 |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_CLOSE ORDER_OFFSET_CLOSE} | ORDER_OFFSET_CLOSE是Order结构中```Offset```属性的取值，表示订单为平仓方向。 |\\n\\n### PERIOD\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/PERIOD/PERIOD_M1 PERIOD_M1} | 表示1分钟K线周期的常量，数值为60。 |\\n| {@var/PERIOD/PERIOD_M3 PERIOD_M3} | 表示3分钟K线周期的常量，其值为180。 |\\n| {@var/PERIOD/PERIOD_M5 PERIOD_M5} | 表示5分钟K线周期的常量，数值为300。 |\\n| {@var/PERIOD/PERIOD_M15 PERIOD_M15} | 表示15分钟K线周期的常量，其值为900。 |\\n| {@var/PERIOD/PERIOD_M30 PERIOD_M30} | 表示30分钟K线周期的常量，其值为1800秒。 |\\n| {@var/PERIOD/PERIOD_H1 PERIOD_H1} | 表示1小时K线周期的常量，数值为3600。 |\\n| {@var/PERIOD/PERIOD_H2 PERIOD_H2} | 表示2小时K线周期的常量，数值为7200。 |\\n| {@var/PERIOD/PERIOD_H4 PERIOD_H4} | 表示4小时K线周期的常量，数值为14400。 |\\n| {@var/PERIOD/PERIOD_H6 PERIOD_H6} | 表示6小时K线周期的常量，数值为21600。 |\\n| {@var/PERIOD/PERIOD_H12 PERIOD_H12} | 表示12小时K线周期的常量，数值为43200。 |\\n| {@var/PERIOD/PERIOD_D1 PERIOD_D1} | 表示1日K线周期的常量，数值为86400。 |\\n| {@var/PERIOD/PERIOD_D3 PERIOD_D3} | 表示3日K线周期的常量，数值为259200。 |\\n| {@var/PERIOD/PERIOD_W1 PERIOD_W1} | 表示1周K线周期的常量，数值为604800秒。 |\\n\\n### LOG_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY} | LOG_TYPE_BUY是exchange.Log函数的```LogType```参数可选值，用于设置```exchange.Log```函数打印的日志类型为买单日志。 |\\n| {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL} | LOG_TYPE_SELL是exchange.Log函数的```LogType```参数可选值，用于设置```exchange.Log```函数打印卖单日志。 |\\n| {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL} | LOG_TYPE_CANCEL是exchange.Log函数的```LogType```参数可选值，用于设置```exchange.Log```函数打印撤销订单日志。 |\"], \"title\": \"API函数速查\"}], \"desc\": \"```JavaScript```（含 TypeScript）、```Python```、```Rust```策略由几个约定名称的函数组成，托管者在固定的时机调用它们。My语言、PINE、Blockly、Workflow 策略不需要编写这些函数。\\n\\n**生命周期函数**\\n\\n| 函数 | 是否必须 | 调用时机 |\\n| - | - | - |\\n| ```main()``` | 必须 | 入口函数，策略的主体。```main()```返回，策略即运行结束。 |\\n| ```init()``` | 可选 | 在```main()```之前调用一次，用于初始化。 |\\n| ```onexit()``` | 可选 | 策略退出时调用，用于扫尾（撤单、平仓、保存状态等）。 |\\n| ```onerror(msg)``` | 可选 | 仅```JavaScript```：```main()```因未捕获的异常结束时调用，```msg```为错误信息。调用了```onerror()```就不再调用```onexit()```。 |\\n| ```destroy()``` | 可选 | 仅```JavaScript```模板类库：策略退出时，在```onexit()```或```onerror()```之后调用，见 {@编写策略/模板类库模板类库}。 |\\n\\n退出时调用哪个函数：\\n\\n| 退出原因 | JavaScript | Python | Rust |\\n| - | - | - | - |\\n| ```main()```正常返回 | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| 停止实盘 | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| 未捕获的异常、```panic``` | ```onerror(msg)``` | 都不调用 | ```onexit()``` |\\n\\n**注意事项：**\\n- ```onexit()```、```onerror()```最长执行 5 分钟（时长由服务端按任务下发，默认 5 分钟），超时会被强制结束。\\n- 回测中策略通常是不停轮询的死循环，回测结束时```main()```并没有正常返回，处理方法见 {@编写策略/策略结构/onexit() onexit()}。\\n- ```JavaScript```策略的```main()```返回时，用```threading```创建的子线程会被终止；还没有到期的```setTimeout```回调会先执行完，再调用```onexit()```。\\n- ```JavaScript```、```Python```模板类库可以定义自己的```init()```，在模板加载时执行，早于策略的```init()```。\\n\\n**主循环与事件驱动**\\n\\n大多数策略在```main()```中写一个循环：每轮获取数据、计算、下单，然后```Sleep()```等待下一轮，见 {@编写策略/策略结构/主循环主循环}。也可以等待行情、订单等事件到达后再处理，见 {@编写策略/策略结构/事件驱动事件驱动}。全部 API 函数的分类速查见 {@编写策略/策略结构/API函数速查 API函数速查}。\", \"title\": \"策略结构\"}, {\"_src_hash\": \"a206e0ec5373f65d518bf6261200d003492c052ee0958eecf1990e0fe9f91f71\", \"children\": [{\"_src_hash\": \"f181df7dfcc36f55629fc500d74b542c763150412fb81c8f1673fd1e35628e16\", \"desc\": \"| 变量(命名举例) | 描述 | 类型 | 默认值(说明) | 组件配置(说明) | 备注 |\\n| - | - | - | - | - | - |\\n| pNum | 参数pNum的描述 | 数字型(number) | 举例设置默认值为:100，Rust策略中为f64| 用于设置当前参数绑定的界面控件的：组件类型、最小值、最大值、分组、过滤器等 | 参数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```。在策略代码中是以全局变量形式存在的，也就是说可以在代码中修改策略参数（Rust 除外：Rust 中参数是全局常量，不能修改）。\\n6、对于「加密串」和「字符串」类型的参数，默认值输入时不需要加引号，输入均作为字符串处理。「加密串」参数的使用与「字符串」参数相同，加密字符串会被加密发送，不会明文传输。\\n7、「字符串」类型的参数如果设置为「选填」，当参数绑定的控件中不填写参数时，参数变量的值为**空字符串**；\\n 同理，如果是「数字型」的参数，参数变量的值为**空值**。\\n 同理，如果是「下拉框」的参数，参数变量的值为**空值**。\\n 同理，如果是「加密串」的参数，参数变量的值为**空值**。\\n ```Rust```策略中，没有填写的选填参数为该类型的零值：数字为```0```，字符串、加密串为空字符串，布尔为```false```。\\n8、对于下拉框类型的界面参数，例如变量名为```pCombox```。在「组件配置」中没有开启「支持多选」时，pCombox的值为当前选中的选项索引或具体数据（给选项绑定数据时）。\\n 如果开启了「支持多选」时，pCombox的值为一个数组，数组包含所有当前选中的选项的索引或具体数据（给选项绑定数据时）。\", \"title\": \"界面参数种类\"}, {\"_src_hash\": \"79d7dcbbe358771cf5ace610a7801ed8175eb040464eec7af580e3f8a1fd061f\", \"desc\": \"策略界面参数和策略交互控件都有「组件配置」选项，用于设置参数（或交互控件）对应的界面控件，以及最小值、最大值、分组、过滤器等。\\n\\n各种类型支持的组件：\\n- 数字型(number)\\n 输入框控件（默认）、时间选择器控件、滑动输入条控件。\\n- 布尔型(true/false)\\n 仅支持开关控件（默认）。\\n- 字符串(string)\\n 输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、币种、交易代码。\\n- 下拉框(selected)\\n 下拉框控件（默认）、分段控制器控件、币种、交易代码。\\n- 加密串(string)，仅策略参数\\n 仅支持加密输入框控件（默认）。\\n- 按钮(button)，仅交互控件\\n 只有一个按钮控件（默认），没有输入项。\\n\\n**分组**\\n\\n在组件配置的「分组」输入框中输入一个标签名，可以把若干个策略参数划分到同一个分组中（代替平台旧功能「策略分组」）。交互控件同样可以分组（代替旧功能「交互控件分组」）。\\n\\n**过滤器**\\n\\n策略参数的组件配置中，「过滤器」输入框可以填写判定表达式，控制参数是否可用（代替平台旧功能「参数依赖」）。\\n过滤器默认为空，不做任何过滤；可以设置：```a > b```、```a == 1```、```a```、```!a```、```a >= 1 && a <= 10```等。过滤条件为真时，当前参数可用。\\n- 设置过滤器```a == 1```：该参数是否可用取决于参数```a```的值，```a```等于1时可用，否则不可用。\\n- 设置过滤器```a >= 1 && a <= 10```：```a```大于等于1并且小于等于10时可用，否则不可用。\\n- 设置过滤器```!a```：过滤条件为「非a」；```a```可以是布尔值，也可以是数值（```!0```为真）。\", \"title\": \"组件配置\"}, {\"_src_hash\": \"b7c15282155c21b3d333140e2d03cfcf5136c6c56d9df27e79bc6d7c2fc17b2a\", \"desc\": \"- 回测系统中的参数保存\\n 在回测时如果希望将策略参数保存，可以在策略参数修改后点击「保存回测设置」按钮，参考 {@回测系统/回测配置与保存回测配置与保存}。\\n\\n | 变量 | 描述 | 类型 | 默认值 |\\n | - | - | - | - |\\n |number |数值类型 |数字型(number) |1 |\\n |string |字符串 |字符串(string) |Hello FMZ |\\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 ```js\\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 FMZ.COM\\\"],[\\\"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 FMZ.COM\\\"],[\\\"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 FMZ.COM\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n */\\n ```\\n\\n ```Rust```策略如果在开头用 frontmatter 声明了依赖，回测配置块要放在 frontmatter 之后，见 {@编写策略/编程语言/Rust Rust}。\\n- 实盘参数导入导出\\n 运行实盘时需要保存实盘配置的参数数据，可以点击策略实盘页面中「参数设置」选项，再点击「导出参数」按钮，导出的策略参数将以```json```文件保存。\\n 导出的策略参数配置也可以再次导入实盘，点击「导入参数」按钮即可把保存的策略实盘参数导入到当前实盘，导入后点击「更新参数」按钮保存生效。\", \"title\": \"保存参数设置\"}], \"desc\": \"策略界面上设置的策略参数，在策略代码中以同名的全局变量（Rust 中为全局常量）出现，直接用变量名访问：\\n- ```JavaScript```、```My语言```：可以直接读取参数，也可以在代码中修改参数变量。\\n- ```Python```：可以直接读取；在函数中给参数变量重新赋值时，需要先用```global```声明。\\n- ```Rust```：参数是常量，只能读取，不能修改；各种参数对应的类型见 {@编写策略/编程语言/Rust Rust}。\\n- ```PINE```：使用```input()```函数创建界面参数。\\n- ```Blockly可视化```：没有界面参数。\\n\\n![策略参数设置界面](/upload/asset/2e46b5e593de3b2f11445.png)\", \"title\": \"策略参数\"}, {\"_src_hash\": \"272de84678d5c2e1bd8888206393a8529070bd9090e6f61461c76d95e30be569\", \"children\": [{\"_src_hash\": \"498dbe7e6c6013e9681687f6c9366ddaf93a3b13760457354cf81705a7d5039a\", \"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\\n**示例：用交互控件动态修改策略参数**\\n\\n在策略编辑页面的「策略交互」中添加一个字符串类型的交互控件，变量名为```changeSymbol```。交互控件的设置界面：\\n\\n![设置交互控件](/upload/asset/1741a2b35e569c5e07e3.png)\\n\\n实盘运行时，在该控件的输入框中填入```ETH_USDT```并点击按钮，```GetCommand()```会收到消息```changeSymbol:ETH_USDT```。策略检测到这条消息后更新对应的变量（策略界面上的参数也是全局变量，这里用代码中的全局变量演示）：\\n\\n```js\\n// 策略参数\\nvar symbol = \\\"BTC_USDT\\\"\\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(\\\"Changed symbol parameter to:\\\", arr[1])\\n symbol = arr[1]\\n }\\n }\\n\\n LogStatus(_D(), \\\", Current symbol parameter value:\\\", symbol)\\n Sleep(3000)\\n }\\n}\\n```\", \"title\": \"交互控件种类\"}, {\"_src_hash\": \"6de560c1670ad5809a3999bd19a2affe30bb6f7da7e056ae35c86b0004865e06\", \"desc\": \"除了在「策略交互」栏中设计交互控件，还可以在策略状态栏中设计交互控件。目前支持的交互控件种类仅有按钮类型，见 {@fun/Log/LogStatus LogStatus}。\\n\\n状态栏中的按钮控件可以分为：\\n- 普通按钮控件\\n 数据结构举例为：\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"This is the first button\\\"}\\n ```\\n- 带一个输入数据的按钮控件\\n 使用```input```属性设置输入控件选项，数据结构举例为：\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 2\\\", \\\"cmd\\\": \\\"button2\\\", \\\"description\\\": \\\"This is the second button\\\", \\\"input\\\": {\\\"name\\\": \\\"Open Quantity\\\", \\\"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\\\": \\\"Dropdown\\\",\\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\\\": \\\"Open\\\",\\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\\\": \\\"Dropdown\\\",\\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\\\": \\\"Input Box\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": \\\"ABC\\\",\\n \\\"group\\\": \\\"group1\\\"\\n }]\\n }\\n ```\\n\\n将这些按钮控件JSON数据编码为JSON字符串，然后使用``` ` ```字符包裹住，在状态栏输出。以JavaScript语言为例：\\n\\n```js\\nfunction main() {\\n var btn = {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"This is the first button\\\"}\\n LogStatus(\\\"`\\\" + JSON.stringify(btn) + \\\"`\\\")\\n}\\n```\\n\\n这些按钮控件也可以写入状态栏表格中，详细例子见 {@fun/Log/LogStatus LogStatus}。\\n\\n```input```字段结构与```group```字段中单个控件结构一致，以下为详细说明（带注释的 JavaScript 对象）：\\n\\n```js\\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```时有效，表示选择器的选项数据格式：```[\\\"Option 1\\\", \\\"Option 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```字段中单个控件为例，完整的例子（JavaScript 对象）：\\n\\n```js\\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```\", \"title\": \"状态栏中的交互控件\"}], \"desc\": \"```JavaScript```、```Python```、```Rust```、My语言策略可以设计交互控件，策略的交互控件用来在策略实盘运行时给运行的策略程序发送交互指令。对于```JavaScript```、```Python```、```Rust```语言类型的策略，在策略代码中使用 {@fun/Global/GetCommand GetCommand} 函数获取交互控件产生的消息。交互控件的「组件配置」与策略参数相同，见 {@编写策略/策略参数/组件配置组件配置}。\\n\\n![交互控件](/upload/asset/2e4320d0cc33c15eb935d.png)\\n\\n在策略中设计好处理交互控件消息的代码，在实盘时使用交互控件可以实现（不限于）诸如以下功能：\\n- 手动平掉策略持仓。\\n- 动态修改策略参数，避免重启策略实盘。\\n- 切换策略逻辑。\\n- 触发打印某些调试信息、数据，用来测试某些功能。\", \"title\": \"交互控件\"}, {\"_src_hash\": \"1ca4ec5eefb2babb01bedc8c9ad1503a4f882b0965b15084fde2f4eec27cc693\", \"children\": [{\"_src_hash\": \"26435f824f1ecb1a6b0f3b2752c47d09e40cd38a72bb4365f76c05ed9713c382\", \"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\": \"不同的编程语言的模板类库书写格式有所不同，导出函数在模板类库中声明以及实现的例子代码如下：\"}, {\"value\": \"```Blockly可视化```方式编写的策略使用类库功能可以藉由```JavaScript```语言的模板类库编写实现，使用以下书写格式编写。\\n\\n```js\\n/*blockly\\n {\\n \\\"type\\\": \\\"ext_testA\\\",\\n \\\"message0\\\": \\\"testA|testA\\\",\\n \\\"template\\\": \\\"function(){return 99;}()\\\",\\n \\\"order\\\": \\\"ORDER_ATOMIC\\\",\\n \\\"output\\\": \\\"Number\\\"\\n },{\\n \\\"type\\\": \\\"ext_MA\\\",\\n \\\"message0\\\": \\\"MA 周期 %1| MA Period %1\\\",\\n \\\"args0\\\": [{\\n \\\"type\\\": \\\"input_value\\\",\\n \\\"check\\\": \\\"Number\\\"\\n }],\\n \\\"template\\\": \\\"(function(){var r = exchange.GetRecords(); return (!r || r.length < %1) ? false : TA.MA(r, %1); })()\\\",\\n \\\"order\\\": \\\"ORDER_ATOMIC\\\",\\n \\\"output\\\": null,\\n \\\"colour\\\": 85\\n }\\n*/\\n```\"}], \"title\": \"模板类库的导出函数\"}, {\"_src_hash\": \"324893503da9cadd8970462af372a35d544238d76c2175e0789742095672bfd5\", \"desc\": \"模板类库也可以设置自己的界面参数，模板类库的参数在模板类库代码中是以全局变量的形式使用的（Rust 中为全局常量）。\\n例如我们设置了一个模板类库的参数：\\n\\n![模板参数](/upload/asset/2e4ab550b85e6a1cac08e.png)\\n\\n| 策略代码中参数的变量名 | 策略界面上显示的参数名称 | 类型 | 默认值 |\\n| - | - | - | - |\\n| param1 | 模板参数1 | 数字型(number) | 99 |\\n\\n```Rust```模板的参数是常量，只能读取，不能修改，所以下面的例子在 Rust 中只能实现读取参数：\\n\\n```rust\\n// 模板代码\\npub fn GetParam1() -> f64 {\\n Log!(\\\"param1:\\\", param1);\\n param1\\n}\\n```\\n\\n```rust\\n// 策略代码\\nfn main() {\\n Log!(\\\"Calling ext::GetParam1:\\\", ext::GetParam1());\\n}\\n```\", \"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\"}, {\"code\": \"// Rust 模板参数是只读常量，不能修改，读取参数的写法见上文\", \"lang\": \"rust\"}], \"value\": \"用于测试```param1```参数的模板类库代码：\"}, {\"examples\": [{\"code\": \"function main () {\\n Log(\\\"Calling $.GetParam1:\\\", $.GetParam1())\\n Log(\\\"Calling $.SetParam1:\\\", \\\"#FF0000\\\")\\n $.SetParam1(20)\\n Log(\\\"Calling $.GetParam1:\\\", $.GetParam1())\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"Calling ext.GetParam1:\\\", ext.GetParam1())\\n Log(\\\"Calling ext.SetParam1:\\\", \\\"#FF0000\\\")\\n ext.SetParam1(20)\\n Log(\\\"Calling ext.GetParam1:\\\", ext.GetParam1())\", \"lang\": \"python\"}, {\"code\": \"// Rust 模板参数是只读常量，不能修改，读取参数的写法见上文\", \"lang\": \"rust\"}], \"value\": \"引用以上模板类库例子的策略代码，使用模板类库的导出函数获取参数```param1```和修改参数```param1```。\"}], \"title\": \"模板类库的参数\"}, {\"_src_hash\": \"7c36c7f9ab41a47ad0fdc24bdae20408883fc51ebc04cfdb93bb6e3453cf6f83\", \"desc\": \"策略引用模板类库时，需要当前登录的发明者量化交易平台账号的策略库中存在可用的模板类库。在[策略编辑页面](https://www.fmz.com/m/add-strategy)的模板栏中勾选需要引用的模板，保存策略后即可完成引用。\\n\\n![模板引用截图](/upload/asset/2e4ee2ec7b3e7b1649af8.png)\", \"title\": \"引用模板类库\"}], \"desc\": \"**模板类库**是发明者量化交易平台中可复用的代码模块，是策略代码的一种类别。支持模板类库的语言有：```JavaScript```（含 TypeScript）、```Python```、```Rust```；```Blockly可视化```策略可以使用 JavaScript 模板类库提供的积木。创建策略时如果类别设置为模板类库，会在当前登录账号的策略库中创建一个模板类库，创建后不能再修改类别为普通策略。\\n\\n![创建模板类库页面](/upload/asset/2e4c55da99fd457ca94a0.png)\\n\\n各语言中导出、调用模板函数的方式：\\n\\n| 语言 | 模板中导出 | 策略中调用 |\\n| - | - | - |\\n| JavaScript | 挂到```$```上：```$.Test = function() {...}``` | ```$.Test()``` |\\n| Python | 挂到```ext```上：```ext.Test = Test``` | ```ext.Test()``` |\\n| Rust | 模板代码并入```ext```模块，供策略调用的函数声明为```pub fn``` | ```ext::Test()``` |\\n\\n- 模板中的```main()```函数在策略中不会执行，只作为单独回测、调试模板时的入口。\\n- ```JavaScript```模板可以定义```init()```和```destroy()```：```init()```在模板加载时执行（早于策略的```init()```），```destroy()```在策略退出时、```onexit()```或```onerror()```之后执行。```Python```模板可以定义```init()```，在模板加载时执行。\\n- ```Rust```模板和策略都可以用 frontmatter 声明第三方 crate，但依赖块只能写在其中一处，两处都写会编译失败。\", \"title\": \"模板类库\"}, {\"_src_hash\": \"741cfc8ca91f042797472513837c7d82f585d592eebc941aabc96e62a92b9c77\", \"children\": [], \"desc\": \"发明者量化交易平台内置了一些常用库。各语言可用情况：\\n\\n| 库 | JavaScript / TypeScript | Python | Rust |\\n| - | - | - | - |\\n| ```TA```指标库 | 支持 | 支持 | 支持 |\\n| ```talib```指标库 | 支持 | 需在托管者所在机器安装 TA-Lib 和 numpy | 不支持 |\\n| JSON | 语言内置```JSON``` | 标准库```json``` | ```JSONParse()```/```JsonValue``` |\\n\\n完整的函数列表与参数见手册 {@fun/TA TA}、{@fun/Talib Talib}。\\n\\n**TA指标库**\\n\\n平台的```TA```指标库优化了常用指标算法（[开源TA库代码](https://www.fmz.com/bbs-topic/409)）。K 线数量不足以计算指标时，对应位置返回无效值。\\n\\n```js\\nfunction main(){\\n var records = exchange.GetRecords()\\n var macd = TA.MACD(records)\\n var atr = TA.ATR(records, 14)\\n\\n // 打印最后一组指标值\\n Log(macd[0][records.length-1], macd[1][records.length-1], macd[2][records.length-1])\\n Log(atr[atr.length-1])\\n}\\n```\\n\\n```rust\\nfn main() {\\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 Log!(macd[0][r.len() - 1], macd[1][r.len() - 1], macd[2][r.len() - 1]);\\n Log!(atr[atr.len() - 1]);\\n}\\n```\\n\\n**talib指标库**\\n\\n```js\\nfunction main() {\\n var records = exchange.GetRecords()\\n var cci = talib.CCI(records, 14)\\n Log(cci)\\n}\\n```\\n\\n```python\\n# Python 需要在托管者所在机器安装 TA-Lib 与 numpy，未安装时调用 talib 会报错提示安装\\ndef main():\\n records = exchange.GetRecords()\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\\n\\n**JavaScript：动态加载第三方库**\\n\\n其它第三方 JavaScript 库可以在运行时下载后用```eval```加载：\\n\\n```js\\nfunction 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\": \"内置库\"}, {\"_src_hash\": \"df5d355bf8d69d616a0c3063dbcecc6c999436fabc489a2f433344fd49094778\", \"children\": [], \"desc\": \"策略名称和策略参数的描述均可采用```中文|英文```的格式书写，使网页能够自动识别并显示相应的语言。在其它使用场景中，例如**策略描述**、**使用说明**等```Markdown```格式的文本，使用```[trans]中文|英文[/trans]```或```[trans]中文||英文[/trans]```同样可以实现语言的自动识别。切换语言后，刷新网页即可生效。此外，在策略代码中，凡是可以写入字符串的函数也支持语言切换，例如```Log()```函数、```LogStatus()```函数等。\\n\\n```js\\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]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/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]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/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]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/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\": \"多语言支持\"}], \"desc\": \"用各种编程语言编写策略：各语言的说明，策略结构（生命周期、主循环、事件驱动），策略参数，交互控件，模板类库，内置库，以及策略界面文字的多语言写法。\", \"title\": \"编写策略\"}, {\"_src_hash\": \"b7226f8b8520982c4b151ce37783450236e8b1a3cf1da34aa476f102904bd68a\", \"children\": [{\"_src_hash\": \"526c6f7ea00725409648f55d8915c8b4bc135b2006be2978f0a854669ba82f60\", \"children\": [{\"_src_hash\": \"8f700a46e39eaf7f8e036e0c6f69168e3209d627bb9bd40fc00bd4592d3202ab\", \"desc\": \"策略编辑器内置AI助手，可以根据描述生成策略代码，解释、修改选中的代码，调整策略参数和交互控件，并自动回测、分析回测结果。\\n\\n- AI助手面板\\n 代码编辑区右侧是AI助手面板，可以收起和展开。在输入框中描述需求即可对话；先在编辑器中选中代码，选中的代码会作为对话的上下文。\\n AI给出的代码、参数和交互控件修改以差异形式显示，可以逐处「接受」或「拒绝」，也可以全部接受；修改策略或自动回测前会先询问是否允许。\\n- 选中代码的快捷操作\\n 选中代码后点击鼠标右键，菜单中有AI操作（例如解释这段代码、优化代码），也可以用```⌘1```、```⌘2```……（Windows为```Ctrl+1```、```Ctrl+2```……）触发。\\n\\n ![策略编辑器中的AI助手解释代码](/upload/asset/16aa01684eda4e8163ed.png)\\n- 智能补全\\n 在右键菜单中选择开启或关闭智能补全，快捷键为```⌘J```（Windows为```Ctrl+J```）。\\n\\nAI助手按使用量从账户余额扣费，对话中会显示本次费用。\\n\\n除了编辑器内的AI助手，也可以把自己使用的外部AI助手接入平台，通过对话管理策略、回测和实盘，见{@对外接口/AI接入 AI接入}。\", \"title\": \"AI助手\"}, {\"_src_hash\": \"581e9d89c242b20fd07c1651d675dcd2b8ec0502124f7ac63d03954bd8bb1a6a\", \"desc\": \"在策略代码编辑区域点击鼠标右键，选择弹出菜单中的「命令面板」选项，可查看各种功能的快捷键组合和编辑器命令。\\n\\n![策略编辑器中菜单的命令面板显示](/upload/asset/2e429269f02185dfbab3b.png)\", \"title\": \"命令面板\"}, {\"_src_hash\": \"3fa3321e7caf9a6dd14edad9e60003fcf5155eec3bcc4baf98136ad4bb0d6de6\", \"desc\": \"在**策略编辑页面**的「代码」编辑区内，可以快速查询「语法手册」。根据操作系统不同，使用相应的快捷键：\\n\\n![策略编辑器中语法手册速查](/upload/asset/2e4d0722af99164f69996.png)\\n\\n- Mac系统（苹果电脑）的浏览器中：按住```⌘```键不放。\\n- Windows系统的浏览器中：按住```Ctrl```键不放。\\n\\n然后将鼠标移动到需要查询的**变量名**或**函数名**上时，会出现跳转链接。点击该链接即可弹出「语法手册」，并自动定位到查询的内容。\", \"title\": \"语法手册速查\"}, {\"_src_hash\": \"86c516447509e520d1f7aa3d0b7f5db2681dce6458a64ae1648e1dc0bbb07ca4\", \"desc\": \"选中需要查询的内容，点击鼠标右键弹出菜单。\\n- 转到定义：跳转至所查询内容的定义位置。\\n- 转到引用：跳转至所查询内容的引用位置。\\n- 快速查看-速览定义：在不离开当前代码行的情况下查看所选代码的定义。\\n- 快速查看-查看引用：在不离开当前代码行的情况下查看其他代码行中对当前代码的引用情况，支持快速跳转，便于更好地理解代码逻辑和结构。\", \"title\": \"定义与引用跳转\"}, {\"_src_hash\": \"8fe62a954909122634b24599f756adba484905fb01bab82b924266be7b19e142\", \"desc\": \"线上策略编辑页面把策略代码、策略描述、使用说明、开发记录等信息分开记录。\\n\\n![策略文档选项说明](/upload/asset/2e47983c191c1779bd52e.png)\\n\\n- 代码：策略程序的源码。\\n 平台上一个完整的策略包含：策略源码、{@编写策略/策略参数策略参数}设计、{@编写策略/交互控件交互控件}设计、{@编写策略/模板类库模板类库}引用。\\n- 笔记：记录策略开发过程中的内容。\\n- 描述：策略公开展示时显示的介绍。\\n- 手册：只有租用策略后才能看到的说明。\", \"title\": \"策略文档\"}, {\"_src_hash\": \"53cc258140f6218e48231c2d765d650e672f6abfb4a234476944f5dce02c7117\", \"desc\": \"平台支持策略开发过程中的版本迭代功能，在**策略编辑页面**「代码」编辑区内，点击「历史版本」按钮可以打开策略历史版本管理页面。\\n\\n- 当前策略没有任何历史版本快照时，点击「立即创建」按钮创建当前策略的快照。快照内容包括：策略代码、笔记、描述、手册、参数设计、交互设计等。\\n\\n- 创建历史快照后，历史版本管理页面右侧会显示已保存的历史快照列表。点击该列表上方的「创建历史版本」按钮可以继续保存新的历史快照。\\n\\n- 编辑、使用历史快照：可以对已记录的策略历史快照进行**修改历史快照名称**、**删除历史快照**、**恢复到历史快照的策略版本**等操作。\\n\\n- 预览当前选定的历史快照：点击历史版本管理页面左下角的「预览」按钮，可以预览当前历史快照中的策略代码、笔记、描述、手册、参数设计、交互设计等内容。\\n\\n- 对比当前选定的历史快照与当前策略的差异：点击历史版本管理页面左下角的「对比」按钮，可以对比当前历史快照与当前策略之间的差异。\\n\\n\\n## 实盘运行历史版本\\n\\n策略的历史版本不仅可以用于代码管理和版本回滚，还可以直接在实盘中运行：\\n\\n- **设置默认运行版本**：在策略编辑器页面点击「历史版本」按钮，选中某个历史版本后，点击菜单中的「修改」按钮，在弹框中可以勾选「设置为默认版本」选项。如果不设置，默认运行最新版本。\\n\\n- **在实盘中使用历史版本**：创建实盘或修改实盘参数时，策略所有者可以选择策略的某个历史版本来运行。此功能仅对策略所有者有效。\\n\\n- **出租策略的版本控制**：当策略出租给其他用户时，租用方只能运行策略所有者设置的「默认运行版本」，无法选择其他历史版本。策略所有者可以通过设置默认运行版本来控制出租策略使用的版本。\", \"title\": \"历史版本管理\"}], \"desc\": \"在[新建策略页面](https://www.fmz.com/m/add-strategy)或者从[策略库](https://www.fmz.com/m/strategies)打开一个现有策略，进入**编辑页面**（例如策略ID为123456的地址为```https://www.fmz.com/m/edit-strategy/123456```）编写策略。\\n\\n![线上策略编辑器界面](/upload/asset/2e50fff4160187be92248.png)\\n\\n本章介绍编辑器的辅助功能。与编辑页面相关的其它功能：\\n- {@开发工具/远程编辑远程编辑}：用本地编辑器编写，自动同步到平台。\\n- {@回测系统/回测配置与保存回测配置与保存}：把回测配置和策略参数随策略保存。\\n- {@平台基础/策略库/完整策略的导入与导出完整策略的导入与导出}：导出、导入包含参数等全部信息的完整策略。\", \"title\": \"策略编辑器\"}, {\"_src_hash\": \"6266f248a4753affa4904612b653f510bf85992b0e9e6f3540ec23e6b5fceecf\", \"children\": [], \"desc\": \"[调试工具](https://www.fmz.com/m/debug)页面提供了一个用于快速测试实盘代码的免费环境，目前仅支持```JavaScript```语言。\\n\\n![调试工具](/upload/asset/2e48d6d1bc77e46099058.png)\\n\\n使用调试工具测试代码时，代码将直接在指定的托管者上运行，最长运行时间为3分钟。支持调用发明者量化交易平台的所有API函数，但仅支持单个交易所对象。\", \"title\": \"调试工具\"}, {\"_src_hash\": \"d3caefd50f5dcf3306b7ff40c7f3a57f078776b1fa987dc11d056851679e9e7d\", \"children\": [], \"desc\": \"可以用本地编辑器编写策略，保存时自动同步到发明者量化交易平台。支持```VSCode```、```Vim```、```Sublime Text 3```，```JavaScript```策略还可以用```WebStorm```，```Python```策略还可以用```PyCharm```。Blockly可视化策略不支持远程编辑。\\n\\n![远程编辑截图](/upload/asset/2e4e8975d1e32517fd989.png)\\n\\n**使用步骤**\\n1. 在策略编辑页面点击「远程编辑」。弹出的窗口上方是各编辑器插件的下载链接，点击跳转到对应的插件页面安装，不同编辑器的安装方式略有差别。\\n2. 窗口中显示当前策略的远程同步密钥（token）。密钥为空时，点击「更新密钥」生成。\\n3. 把策略源码保存到本地，在源码第一行插入窗口中给出的密钥行（例如```JavaScript```为```// fmz@<密钥>```，```Python```为```# fmz@<密钥>```），之后每次保存都会自动同步到平台。\\n\\n也可以不装插件，用```curl```直接上传本地源码（窗口中有带密钥的完整命令），例如：\\n\\n```bash\\ncurl -T quant.js -H \\\"Authorization: Bearer <密钥>\\\" https://www.fmz.com/rsync\\n```\\n\\n**管理密钥**\\n- 「更新密钥」：生成新密钥，原密钥随即失效。\\n- 「删除密钥」：删除当前策略的密钥，关闭远程编辑。\\n\\n拿到密钥的人可以改写这个策略的源码，不要把密钥公开。\", \"title\": \"远程编辑\"}], \"desc\": \"编写和调试策略的工具：策略编辑器、调试工具、在本地编辑器里远程编辑。\", \"title\": \"开发工具\"}, {\"_src_hash\": \"69618d1ce04d499c37a4083833918aca8f0a32f2ecaef4df310801e2aff62d53\", \"children\": [{\"_src_hash\": \"1ec95c2d4c62b9956cdd3ff46f00bb8c243c28a06c439cc678b932ea8aca6e7b\", \"desc\": \"回测用平台的历史行情驱动策略代码：回测引擎维护一个虚拟时钟，为每个交易所对象维护一个模拟账户，策略调用的行情、下单、账户等函数都由引擎按历史数据应答。回测结果只反映策略在历史行情下的表现，历史行情不能代表未来，对回测结果要理性、客观地看待。\\n\\n**发起回测**\\n\\n- 网页：打开策略编辑页面，切换到「模拟回测」分页，设置回测配置和策略参数后点击「开始回测」（快捷键见{@回测系统/回测页面快捷键回测页面快捷键}）。回测配置可以保存进策略源码，见{@回测系统/回测配置与保存回测配置与保存}。\\n- AI助手：通过MCP工具```run_backtest```发起回测、```get_backtest```读取结果，见{@对外接口/AI接入 AI接入}。MCP发起的回测只使用模拟级Tick模式。\\n- 本机：使用开源的本地回测引擎，见{@回测系统/本地回测引擎本地回测引擎}。\\n\\n**回测配置项**\\n\\n| 配置项 | 说明 |\\n| - | - |\\n| 时间范围 | 回测的开始时间和结束时间。 |\\n| K线周期 | 策略调用```GetRecords()```默认得到的K线周期。 |\\n| 底层K线周期 | 模拟级Tick模式下用来生成tick的K线周期。越小越接近真实行情，回测也越慢；策略K线由底层K线合成，不能小于底层K线周期。 |\\n| 模式 | 模拟级Tick或实盘级Tick，见{@回测系统/回测模式与撮合回测模式与撮合}。 |\\n| 交易所、交易对 | 每个交易所对象有各自的模拟账户；交易对写成```BTC_USDT```的形式。期货交易所需要在策略中先调用```exchange.SetContractType()```设置合约，才能获取行情、下单。 |\\n| 初始资金 | 计价币（如USDT）和交易币（如BTC）的初始余额。币本位合约以交易币作保证金，需要设置交易币余额。 |\\n| 手续费 | 挂单（maker）和吃单（taker）费率，单位为百分比，默认取该交易所市场的配置。限价单下单时立即成交按吃单费率计算，挂在盘口上之后才成交按挂单费率计算。 |\\n| 滑点 | 单位为价格最小变动单位（一跳）的个数，加在模拟盘口买一价、卖一价的外侧，默认为0。 |\\n| 网络延迟 | 单位为毫秒，策略每调用一次交易所接口，虚拟时钟前进相应时间，默认为200。 |\\n| 深度档位、每档数量 | ```GetDepth()```返回的档位数（1～20）和模拟盘口每档的数量；实盘级Tick模式下深度档位是向数据源请求的真实深度档数。 |\\n| K线最大条数 | 第一次调用```GetRecords()```时返回的历史K线条数上限（100～5000，默认300）。 |\\n| 日志条数 | 回测保留的运行日志、收益日志、图表数据的条数上限。 |\\n| 数据源 | 默认使用平台的历史数据，也可以使用自定义数据源，见{@回测系统/自定义数据源自定义数据源}。 |\\n\\n**容错测试**\\n\\n回测页面另外提供「容错测试」：按一定概率（默认0.5）让交易所接口调用失败，并且每种接口的第一次调用一定失败，失败时记录错误日志```FaultTolerant Test```。用于检验策略对接口失败的处理，例如是否用```_C()```重试。\\n\\n**回测中的策略**\\n\\n- ```IsVirtual()```返回```true```，不应在回测中执行的逻辑可以据此跳过，见{@fun/Global/IsVirtual IsVirtual}。\\n- 时间是虚拟时间：```Unix()```、```_D()```等读取的是回测时钟，```Sleep()```推动时钟前进。时钟越过结束时间时，引擎抛出```EOF```异常结束回测，此时不会调用```onexit()```。\\n- 回测中```GetCommand()```收不到交互命令，不支持```onerror()```，网络请求类功能受限。\", \"title\": \"概述与发起回测\"}, {\"_src_hash\": \"7e3c93e74cc0150d98aa24295c1301b3b11d2986f61fb8c0b367a3b9d60fa466\", \"desc\": \"回测分为**模拟级Tick**和**实盘级Tick**两种模式。两者都基于真实的历史数据：模拟级Tick由K线生成tick，实盘级Tick回放真实记录的tick，后者更精确，也更慢。\\n\\n**模拟级Tick**\\n\\n回测引擎在每根底层K线的开盘价、最高价、最低价、收盘价构成的价格框架内，沿开盘→最低/最高→收盘的路径生成2～14个模拟tick，K线的成交量分摊到这些tick上；策略调用行情接口时得到的是当前模拟tick的数据。因此每根底层K线上有多个回测时间点，策略可以在一根K线内多次交易，而不是只能按收盘价成交。底层K线周期越小，生成的tick越接近真实走势，回测也越慢。机制详见[回测系统模拟级别机制说明](https://www.fmz.com/bbs-topic/662)、[回测系统机制说明](https://www.fmz.com/digest-topic/4009)。\\n\\n模拟盘口：卖一价 = 当前tick收盘价 + 一跳 + 滑点，买一价 = 收盘价 − 一跳 − 滑点（滑点以跳数计）；```GetDepth()```返回按此间隔排列的若干档模拟深度，每档数量为配置中的「每档数量」。\\n\\n**实盘级Tick**\\n\\n使用平台真实记录的逐秒tick数据，包含盘口深度（档位可设置，最多20档），可以选择回放逐笔成交数据；```GetDepth()```、```GetTrades()```返回回放的真实数据。由于数据量大、回测速度慢，单次回测的数据上限为50MB，可回测的时间范围因此受限；需要更长的时间范围时，可以降低深度档位、不使用逐笔成交数据。较早的时间段可能没有实盘级数据，时间范围不宜选得过早。\\n\\n在某个行情时刻，```GetTicker()```、```GetDepth()```、```GetTrades()```、```GetRecords()```各调用一次不会推动回测时间；再次调用其中同一个函数时，回测时间跳到下一个行情时刻。实盘级Tick模式下，策略循环中的```Sleep()```宜设得短一些（例如100毫秒）。\\n\\n**撮合规则**\\n\\n两种模式使用相同的撮合规则：\\n\\n- 按价格触及成交，并且一次全部成交，回测中不会出现部分成交。\\n- 市价单在当前tick按卖一价/买一价成交；现货市价买单的数量是计价币金额。\\n- 限价买单价格大于等于卖一价、限价卖单价格小于等于买一价时成交，挂单后的每个tick都会检查。下单时立即成交的，按市场价成交并收取吃单（taker）手续费；挂在盘口之后被价格触及而成交的，按委托价成交并收取挂单（maker）手续费。\\n- 实盘级Tick模式下，挂在买一/卖一价位上的订单，要等排在它前面的挂单量被消耗后才成交。\\n- 期货按名义价值 ÷ 杠杆冻结保证金；行情数据中包含资金费率时，永续合约按资金费率结算资金费。\\n\\n**数据粒度的影响**\\n\\n同一个策略在不同的数据粒度下（实盘级Tick、底层K线周期较小的模拟级Tick、底层K线周期较大的模拟级Tick等）回测，交易次数和盈亏都会不同。数据粒度大时回测快，但结果可能失真，回测时应尽量使用较小的数据粒度。可以用下面的策略在几种粒度下分别回测对比：\\n\\n```js\\n/*backtest\\nstart: 2025-04-01 08:00:00\\nend: 2025-04-18 00:00:00\\nperiod: 1m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":1000000}]\\nmode: 1\\n*/\\n\\nvar delta = 50\\nvar lotSize = 0.001\\nvar lastPrice = null\\nvar direction = null\\n\\nfunction main() {\\n while (true) {\\n var ticker = _C(exchange.GetTicker)\\n if (!lastPrice) {\\n lastPrice = ticker.Last\\n }\\n var diff = ticker.Last - lastPrice\\n if ((!direction || direction == \\\"long\\\") && diff >= delta) {\\n // 价格上涨超过阈值 -> 做空\\n exchange.Sell(ticker.Last, lotSize)\\n Log(\\\"Short @\\\", ticker.Last)\\n direction = \\\"short\\\"\\n } else if ((!direction || direction == \\\"short\\\") && diff <= -delta) {\\n // 价格下跌超过阈值 -> 做多\\n exchange.Buy(ticker.Last, lotSize)\\n Log(\\\"Long @\\\", ticker.Last)\\n direction = \\\"long\\\"\\n }\\n // Tick 模式中尽量短，K线模式中没有影响\\n Sleep(100)\\n }\\n}\\n```\", \"title\": \"回测模式与撮合\"}, {\"_src_hash\": \"2c5ff13dad5c0022d6cfa68d2d0895c7a5ccab6ea3423b686de44f04ce5376e2\", \"desc\": \"「模拟回测」分页中的回测配置（时间范围、交易所、手续费等）和策略参数可以随策略保存，再次打开策略时自动载入。\\n\\n**保存**\\n\\n- 点击「保存回测设置」：把回测配置和策略参数以注释（```backtest```注释块）的形式写在策略源码开头。\\n- 点击「保存策略」：平台同时记录当前的回测配置和策略参数。\\n\\n**载入**\\n\\n- 打开或刷新策略编辑页面时，优先载入源码中```backtest```注释块记录的配置。\\n- 源码中没有```backtest```注释块时，载入最后一次「保存策略」时记录的配置。\\n- 在源码中手动修改了```backtest```注释块后，点击注释块上方的「回测设置」按钮，把修改同步到回测页面的选项中。\\n\\n**注释块格式**\\n\\n在该语言的块注释起始符后紧接着写```backtest```，之后每行一个```键: 值```：\\n\\n```js\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-03-01 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0,\\\"fee\\\":[0.1,0.1]}]\\nargs: [[\\\"fast\\\",5],[\\\"slow\\\",20]]\\n*/\\n```\\n\\n各语言的注释写法：JavaScript、TypeScript、Rust、PINE语言使用```/*backtest ... */```；Python使用```'''backtest ... '''```；My语言使用```(*backtest ... *)```。\\n\\n| 键 | 格式 | 说明 |\\n| - | - | - |\\n| start、end | ```YYYY-MM-DD HH:mm:ss``` | 开始、结束时间，按浏览器所在时区解析。 |\\n| period | ```1m```、```1h```、```1d```等，或秒数 | 策略K线周期。 |\\n| basePeriod | 同上 | 底层K线周期，不写时与```period```相同；实盘级Tick模式下忽略。 |\\n| mode | ```1``` | 实盘级Tick模式；不写为模拟级Tick模式。 |\\n| exchanges | JSON数组 | 每个元素对应一个交易所对象，字段见下表。 |\\n| args | JSON数组 | 策略参数，```[[\\\"参数名\\\", 值], ...]```；第三个元素为模板Id时设置该模板的参数：```[\\\"参数名\\\", 值, 模板Id]```。 |\\n\\n```exchanges```元素的字段，除```eid```、```currency```外都可以省略：\\n\\n| 字段 | 说明 |\\n| - | - |\\n| eid | 交易所Id，例如```Binance```、```Futures_OKX```。 |\\n| currency | 交易对，例如```BTC_USDT```。 |\\n| balance、stocks | 计价币、交易币的初始余额。 |\\n| fee | ```[挂单费率, 吃单费率]```，单位为百分比。 |\\n| feeMin | 每笔成交的最低手续费，只对部分市场生效。 |\\n| depthDeep、depthAmount | 深度档位、模拟盘口每档的数量。 |\\n| tradesMode | 实盘级Tick模式下是否回放逐笔成交：```\\\"0\\\"```回放，```\\\"1\\\"```不回放。 |\\n| feeder | 自定义数据源地址，见{@回测系统/自定义数据源自定义数据源}。 |\\n\\n「保存回测设置」还会写入一些以```bt```开头的键（例如```btSlipPoint```滑点、```btNetDelay```网络延迟、```btFaultTolerant```容错概率、```btMaxBarLen```K线最大条数），记录回测页面上其他选项的取值，不建议手工修改。本地回测引擎也读取同样的注释块，见{@回测系统/本地回测引擎本地回测引擎}。\", \"title\": \"回测配置与保存\"}, {\"_src_hash\": \"3c03d019e2df200c8f4b2082adb784a487e7e080c60034bfcfac5b367d3fcf99\", \"desc\": \"**编程语言**\\n\\n回测系统支持以下语言编写的策略：JavaScript、TypeScript、Python、Rust、[PINE语言](https://www.fmz.com/bbs-topic/9315)、[My语言](https://www.fmz.com/bbs-topic/2569)、Blockly可视化、Workflow工作流。\\n\\n- JavaScript策略（TypeScript先编译为JavaScript）在浏览器中回测，回测引擎以WebAssembly形式运行，不需要安装任何软件。JavaScript策略回测时可以在Chrome浏览器的DevTools中调试，见[参考说明](https://www.fmz.com/digest-topic/9459)。\\n- Rust策略由平台服务器编译，编译结果在浏览器中回测；策略中通过frontmatter声明的第三方crate在编译时自动获取，本地不需要安装工具链。\\n- Python策略在托管者上回测，可以使用平台的公共服务器，也可以使用自己的托管者。回测与实盘都依赖托管者所在系统的Python 3环境，需要的第三方库要自行安装；公共服务器只提供常用的库。\\n- Workflow工作流策略回测时可以可视化查看各节点的执行状态和数据流转。\\n\\n**交易所**\\n\\n回测数据来自平台的历史数据，可以回测的交易所以回测页面中可选的为准（也可以通过MCP工具```list_exchanges```查看，```backtest```为```true```的交易所有历史数据）。\\n\\n- 加密货币：主流交易所的现货和期货，例如Binance与Futures_Binance、OKX与Futures_OKX、HTX与Futures_HTX、Bybit与Futures_Bybit、Bitget与Futures_Bitget、GateIO与Futures_GateIO，支持交易所的全部品种。\\n- 富途证券（```Futures_Futu```）：港股、美股等市场。回测只支持日线级别数据，```currency```设置为```STOCK```，在策略中用```exchange.SetContractType()```设置股票代码：\\n\\n```js\\n/*backtest\\nstart: 2024-05-01 00:00:00\\nend: 2025-02-17 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"Futures_Futu\\\",\\\"currency\\\":\\\"STOCK\\\",\\\"fee\\\":[0.03,0.03]}]\\n*/\\n\\nfunction main() {\\n var info = exchange.SetContractType(\\\"TSLA.US\\\") // 设置股票代码：特斯拉\\n Log(\\\"info:\\\", info) // 合约信息：InstrumentID、PriceTick、LotTick、VolumeMultiple等\\n Log(exchange.GetTicker()) // 回测时间点的日线行情\\n}\\n```\", \"title\": \"支持范围\"}, {\"_src_hash\": \"0e3093bb46bbb35ad881c4eef00a675789811592d66617ae667eb70fc12cee7f\", \"desc\": \"参数调优在回测时按设置的范围生成多组参数，逐组回测。在「模拟回测」分页的策略参数部分，勾选参数右侧的**调优**选项后出现调优设置：\\n\\n- 最小值：参数的起始值。\\n- 最大值：参数递增后的最大值。\\n- 步长：每次递增的量。\\n- 并发线程：参数调优时同时执行的回测数。该选项只支持JavaScript、PINE、My语言策略的参数调优，不支持模板上的参数调优。\\n\\n回测系统按```最小值```、```最大值```、```步长```生成参数组合，对每种组合各回测一次。只有**数字型（number）**的策略参数可以设置调优。\", \"title\": \"参数调优\"}, {\"_src_hash\": \"44b5611b9c54b1a4fe1b532a9be8462cbe406da7520ec85937b9fe3c3a7c71fc\", \"desc\": \"回测结束后，回测页面显示收益曲线、统计指标、状态信息、日志信息和账户信息。\\n\\n**收益曲线**\\n\\n收益曲线由策略调用```LogProfit()```记录的收益值组成（{@fun/Log/LogProfit LogProfit}）。策略不调用```LogProfit()```时没有收益曲线，下面依赖收益序列的统计指标也无法计算，只能从账户信息中查看回测结束时的资产。MCP工具```get_backtest```返回的```profit```、```max_drawdown```同样来自```LogProfit()```。\\n\\n**统计指标**\\n\\n统计指标由收益序列```profits```（每个元素为```[时间戳, 收益]```）和初始资产```totalAssets```按下面的算法计算：\\n\\n| 指标 | 含义 |\\n| - | - |\\n| 收益率（totalReturns） | 最后一个收益值 ÷ 初始资产。 |\\n| 年化收益（annualizedReturns） | 收益率 × 一年的时长（yearDays天）÷ 回测时长，按比例线性折算。 |\\n| 最大回撤（maxDrawdown） | 资产（初始资产 + 收益）相对此前最高点下跌的最大比例。maxDrawdownStartTime为该最高点的时间，maxDrawdownTime为回撤最深的时间。 |\\n| 胜率（winningRate） | 收益序列中高于前一个点的点所占的比例（第一个点与0比较）。统计的是收益记录，不是逐笔交易的胜率。 |\\n| 波动率（volatility） | 把回测时间按天切分，每天的收益额 ÷ 初始资产，再乘以yearDays折算为年化值（没有收益记录的日子按0计），取这些值的总体标准差。 |\\n| 夏普比率（sharpeRatio） | （年化收益 − 无风险利率3%）÷ 波动率；波动率为0时为0。 |\\n\\nyearDays是年化时使用的一年天数，由回测页面传入。注意波动率是把每日收益率直接乘以yearDays年化，而不是常见的乘以√yearDays，因此这里的夏普比率不宜与其他平台的数值直接比较。\\n\\n算法源码：\\n\\n```js\\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```\\n\\n**数据下载**\\n\\n- 状态栏数据下载：回测结束后，在「状态信息」栏右上角点击「下载表格」，下载回测结束时状态栏数据的CSV文件。\\n- 日志数据下载：在「日志信息」栏右上角点击「下载表格」，下载回测日志的CSV文件。\", \"title\": \"结果解读\"}, {\"_src_hash\": \"d687185b15fd4d8ab49db2e8c0014d9f58c63e1500fcf4cb61c8fc4775024745\", \"children\": [{\"_src_hash\": \"39bc262b1ea3c3b3f282faa79b0a13564f55ee112de90f062a36e64652632569\", \"desc\": \"返回的格式必须为以下两种格式其中之一（系统自动识别）：\\n- 模拟级Tick，以下是JSON数据范例：\\n ```json\\n {\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, 9531300, 9531300, 9497060, 9497060, 787],\\n [1564316100000, 9495160, 9495160, 9474260, 9489460, 338]\\n ]\\n }\\n ```\\n- 实盘级Tick，以下是JSON数据范例：\\n Tick级回测的数据（包含盘口深度信息，深度格式为```[价格, 量]```的数组。可有多级深度，```asks```为价格升序，```bids```为价格倒序）。\\n ```json\\n {\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, [[9531300, 10]], [[9531300, 10]], [[1564315200000, 0, 9531300, 10]], 9497060, 787],\\n [1564316100000, [[9531300, 10]], [[9531300, 10]], [[1564316100000, 0, 9531300, 10]], 9497060, 787]\\n ]\\n }\\n ```\\n\\n| 字段 | 说明 |\\n| - | - |\\n| detail | 请求数据的品种详细信息，包含计价币名称、交易币名称，精度，最小下单量等 |\\n| schema | 指定data数组中列的属性，区分大小写。仅限于 time, open, high, low, close, vol, asks, bids, trades|\\n| data | 按照schema设置的列结构，记录的数据。|\\n\\n**数值精度**\\n\\n请求中固定带```round=true```，返回的数值都写成按精度放大后的整数，以免传输过程中丢失浮点数精度：\\n\\n- 价格类数值（```open```、```high```、```low```、```close```，```asks```/```bids```和```trades```中的价格）= 实际值 × 10^```quotePrecision```。\\n- 数量类数值（```vol```，```asks```/```bids```和```trades```中的数量）= 实际值 × 10^```basePrecision```。\\n\\n例如上面的范例中```quotePrecision```为2，```9531300```表示价格95313.00；```basePrecision```为5，```787```表示数量0.00787。时间列（```time```及```trades```中的时间）是毫秒时间戳，不放大。\\n\\n**detail字段**\\n\\n| 字段 | 说明 |\\n| - | - |\\n| eid | 交易所Id，注意某个交易所现货与期货是不同的eid |\\n| symbol | 交易品种代码 |\\n| alias | 当前交易品种代码对应的交易所中的symbol |\\n| baseCurrency | 交易币种 |\\n| quoteCurrency | 计价币种 |\\n| marginCurrency | 保证金币种 |\\n| basePrecision | 交易币种精度 |\\n| quotePrecision | 计价币种精度 |\\n| minQty | 最小下单量 |\\n| maxQty | 最大下单量 |\\n| minNotional | 最小下单金额 |\\n| maxNotional | 最大下单金额 |\\n| priceTick | 价格一跳 |\\n| volumeTick | 下单量最小变动数值（下单量一跳） |\\n| marginLevel | 期货杠杆值 |\\n| contractType | 对于永续合约设置为：```swap```，回测系统会继续发送资金费率、价格指数请求 |\\n\\n特殊的列属性```asks```、```bids```、```trades```：\\n\\n| 字段 | 说明 | 备注 |\\n| - | - | - |\\n| asks / bids | [[价格, 数量], ...] | 例如```实盘级Tick```数据范例中的数据：```[[9531300, 10]]``` |\\n| trades | [[时间, 方向(0:买,1:卖), 价格, 数量], ...] | 例如```实盘级Tick```数据范例中的数据：```[[1564315200000, 0, 9531300, 10]]``` |\\n\\n期货交易所的永续合约回测时，自定义数据源还需要额外的资金费率数据、价格指数数据。只有当请求的行情数据返回时，返回的结构中detail字段包含```\\\"contractType\\\": \\\"swap\\\"```键值对，回测系统才会继续发送对于资金费率的请求。\\n当回测系统收到资金费率数据时，才会继续发送对于价格指数数据的请求。\\n\\n资金费率数据结构如下：\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.funding\\\",\\n \\\"alias\\\": \\\"BTC_USDT.funding\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"\\\",\\n \\\"basePrecision\\\": 8,\\n \\\"quotePrecision\\\": 8,\\n \\\"minQty\\\": 1,\\n \\\"maxQty\\\": 10000,\\n \\\"minNotional\\\": 1,\\n \\\"maxNotional\\\": 100000000,\\n \\\"priceTick\\\": 1e-8,\\n \\\"volumeTick\\\": 1e-8,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [\\n 1584921600000,\\n -16795,\\n -16795,\\n -16795,\\n -16795,\\n 0\\n ],\\n [\\n 1584950400000,\\n -16294,\\n -16294,\\n -16294,\\n -16294,\\n 0\\n ]\\n ]\\n}\\n```\\n\\n- 相邻的周期间隔8小时\\n- 资金费率数据为什么是 -16795？\\n 与K线数据一样按精度放大为整数：该数据的```quotePrecision```为8，-16795表示资金费率-0.00016795。资金费率可以为负值。\\n\\n回测系统发出的资金费率数据请求，举例为：\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.funding&to=1611244800&trades=0\\n```\\n\\n价格指数数据结构如下：\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.index\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"contractType\\\": \\\"index\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 3,\\n \\\"quotePrecision\\\": 1,\\n \\\"minQty\\\": 0.001,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 0,\\n \\\"maxNotional\\\": 1.7976931348623157e+308,\\n \\\"priceTick\\\": 0.1,\\n \\\"volumeTick\\\": 0.001,\\n \\\"marginLevel\\\": 10,\\n \\\"volumeMultiple\\\": 1\\n },\\n \\\"schema\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [1584921600000, 58172, 59167, 56902, 58962, 0],\\n [1584922500000, 58975, 59428, 58581, 59154, 0]\\n ]\\n}\\n```\\n\\n回测系统发出的价格指数数据请求，举例为：\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.index&to=1611244800&trades=0\\n```\", \"title\": \"数据格式\"}, {\"_src_hash\": \"57df19812523959049163c9015a4d18228de43938c0f4dbdcfca7030e9d0205f\", \"desc\": \"把下面的服务程序部署在能从公网访问的服务器上，数据源地址即为```http://<服务器地址>:9090/data```（```<服务器地址>```替换为该服务器的公网IP或域名）。自定义数据源服务程序使用```Golang```编写：\\n\\n```golang\\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 DataSource: http://xxx.xx.x.xx:9090/data\\n\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=OKX&from=1584921600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\n // http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&from=1599958800&period=3600000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=0\\n fmt.Println(\\\"request:\\\", r)\\n\\n // response\\n defer func() {\\n // response data\\n /* e.g. data\\n {\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151],\\n [1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738],\\n [1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875],\\n [1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777],\\n [1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292],\\n [1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666],\\n [1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405],\\n [1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768],\\n [1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797],\\n [1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692]\\n ]\\n }\\n */\\n\\n // /* 模拟级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10,\\n },\\n \\\"schema\\\": []string{\\\"time\\\",\\\"open\\\",\\\"high\\\",\\\"low\\\",\\\"close\\\",\\\"vol\\\"},\\n \\\"data\\\": []interface{}{\\n []int64{1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151}, // 1610755200000 : 2021-01-16 08:00:00\\n []int64{1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738}, // 1610841600000 : 2021-01-17 08:00:00\\n []int64{1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875},\\n []int64{1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777},\\n []int64{1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292},\\n []int64{1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666},\\n []int64{1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405},\\n []int64{1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768},\\n []int64{1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797},\\n []int64{1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692},\\n },\\n }\\n // */\\n\\n /* 实盘级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10,\\n },\\n \\\"schema\\\": []string{\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"},\\n \\\"data\\\": []interface{}{\\n []interface{}{1610755200000, []interface{}{[]int64{9531300, 10}}, []interface{}{[]int64{9531300, 10}}, []interface{}{[]int64{1610755200000, 0, 9531300, 10}}, 9497060, 787},\\n []interface{}{1610841600000, []interface{}{[]int64{9531300, 15}}, []interface{}{[]int64{9531300, 15}}, []interface{}{[]int64{1610841600000, 0, 9531300, 11}}, 9497061, 789},\\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```js\\n/*backtest\\nstart: 2021-01-16 08:00:00\\nend: 2021-01-22 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"OKX\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"feeder\\\":\\\"http://<服务器地址>:9090/data\\\"}]\\nargs: [[\\\"number\\\",2]]\\n*/\\n\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n var records = exchange.GetRecords()\\n Log(exchange.GetName(), exchange.GetCurrency())\\n Log(ticker)\\n Log(records)\\n}\\n```\", \"title\": \"自定义数据源范例\"}], \"desc\": \"发明者量化交易平台的回测系统支持自定义数据源，回测时由平台的数据服务器使用```GET```方法请求自定义的URL获取数据，因此该URL必须能从公网访问。请求附加的参数如下：\\n\\n| 参数 | 意义 | 说明 |\\n| - | - | - |\\n| symbol | 品种名 | 现货行情数据例如：```BTC_USDT```，期货行情数据例如：```BTC_USDT.swap```，期货永续合约资金费率数据例如：```BTC_USDT.funding```，期货永续合约价格指数数据例如：```BTC_USDT.index``` |\\n| eid | 交易所 | 例如：OKX、Futures_OKX |\\n| round | 数据精度 | 固定为```round=true```：返回的价格、数量都写成按精度放大后的整数，精度由返回数据```detail```中的```quotePrecision```、```basePrecision```给出，见{@回测系统/自定义数据源/数据格式数据格式}。 |\\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\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Bitget&from=1351641600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_OKX&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=1\\n```\", \"title\": \"自定义数据源\"}, {\"_src_hash\": \"32ef2e1e251fc30369102acedc553ee1e18960e8cff8f03021f5b06455cb7ea6\", \"desc\": \"平台开源了JavaScript和Python的本地回测引擎，与云端回测使用相同的引擎核心和历史数据（从平台的数据服务器下载），可以在自己的电脑上快速回测JavaScript、Python策略：\\n\\n- [Python回测引擎](https://github.com/fmzquant/backtest_python)\\n- [JavaScript回测引擎](https://github.com/fmzquant/backtest_javascript)\\n\\n**Python**\\n\\n安装（需要Python 3和pip）：\\n\\n```bash\\npip install https://github.com/fmzquant/backtest_python/archive/master.zip\\npip install pandas matplotlib # 仅在使用 Join(True)、Show() 时需要\\n```\\n\\n第一次使用时会从数据服务器下载对应系统的引擎文件，之后除了历史数据不再联网。策略文件就是普通的FMZ策略，加上开头的```backtest```配置注释（格式见{@回测系统/回测配置与保存回测配置与保存}）和几行引擎调用代码：\\n\\n```python\\n'''backtest\\nstart: 2026-09-01 00:00:00\\nend: 2026-09-15 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0}]\\n'''\\nimport json\\nfrom fmz import *\\ntask = VCtx(__doc__) # 按上方注释中的配置初始化回测引擎，exchange、Log、TA 等成为全局对象\\n\\n# 以下为待测试的策略代码，可以从平台直接复制\\ndef main():\\n Log(exchange.GetAccount())\\n while True:\\n r = exchange.GetRecords()\\n LogStatus(_D(), r[-1][\\\"Close\\\"])\\n Sleep(60 * 60 * 1000)\\n\\ntry:\\n main()\\nexcept EOFError: # 虚拟时钟到达结束时间时，引擎抛出 EOFError\\n pass\\nresult = json.loads(task.Join(False)) # 原始回测结果（JSON）\\nprint(result[\\\"LogsCount\\\"], result[\\\"Elapsed\\\"] / 1e6)\\n# task.Show() # 或者显示收益图表（需要 matplotlib）\\n```\\n\\n用```python strategy.py```运行。```task.Join(False)```返回原始回测结果的JSON，```task.Join(True)```返回收益数据的pandas表格，```task.Show()```画出收益曲线。\\n\\n**JavaScript**\\n\\n```bash\\nnpm install git+https://github.com/fmzquant/backtest_javascript.git\\n```\\n\\n```js\\nvar fmz = require(\\\"fmz\\\")\\nvar task = fmz.VCtx({\\n start: \\\"2026-09-01 00:00:00\\\", end: \\\"2026-09-15 00:00:00\\\", period: \\\"1h\\\", basePeriod: \\\"15m\\\",\\n exchanges: [{eid: \\\"Binance\\\", currency: \\\"BTC_USDT\\\", balance: 10000, stocks: 0}]\\n})\\n// 从这里开始 exchange、Log、TA 等成为全局对象，粘贴策略代码后调用 main()\\n\\nfunction main() {\\n Log(exchange.GetAccount())\\n while (true) {\\n var r = exchange.GetRecords()\\n LogStatus(_D(), r[r.length - 1].Close)\\n Sleep(60 * 60 * 1000)\\n }\\n}\\n\\ntry {\\n main()\\n} catch (e) {\\n // 虚拟时钟到达结束时间时，引擎抛出 \\\"EOF\\\"\\n}\\nvar result = JSON.parse(task.Join()) // 与 Python 引擎 Join(False) 的结果相同\\nconsole.log(result.LogsCount)\\n```\\n\\n**与云端回测的区别**\\n\\n- 只支持JavaScript和Python策略，不会自动加载模板：策略引用的模板代码需要粘贴到文件中，因此依赖交易类库的PINE、My语言策略不能在本地回测。\\n- 策略参数不会自动注入，需要在代码中定义为全局变量。\\n- 注释中的```start```、```end```按本机时区解析；网络延迟固定为200毫秒，不支持滑点和实盘级Tick模式。\\n- 收益、回撤和收益曲线同样只在策略调用```LogProfit()```时才有。\\n\\n**AI回测**\\n\\n在AI助手中可以直接让它回测：AI助手通过MCP工具```run_backtest```发起云端回测，用```get_backtest```读取收益、回撤、错误日志等结果，见{@对外接口/AI接入 AI接入}。也可以让AI助手在本机安装本地回测引擎，快速修改、回测，再用云端回测确认一次。\", \"title\": \"本地回测引擎\"}, {\"_src_hash\": \"9ce03cd655d10108b5f45e38eeb37772ca98764d20331924095fdaf7bbdb3e05\", \"desc\": \"- 策略编辑页面和策略回测页面切换的快捷键\\n 使用```Ctrl + ,```键切换回测页面和策略编辑页面，按住```Ctrl```键后，单按```,```键。\\n- 策略保存的快捷键\\n 使用```Ctrl + s```键保存策略。\\n- 启动回测的快捷键\\n 使用```Ctrl + b```键启动回测。\", \"title\": \"回测页面快捷键\"}], \"desc\": \"用历史数据检验策略：回测系统用历史行情驱动策略代码，模拟撮合与账户，给出收益、回撤等结果。回测只反映策略在历史行情下的表现，不代表未来收益。\", \"title\": \"回测系统\"}, {\"_src_hash\": \"c5d1b86d6acc7222d2adc53864bc5e0170c4cdef250a65baf3c461a6d412fe7b\", \"children\": [{\"_src_hash\": \"f3658676af954762bae69e8a233e4b305fa884ff089161a5f98cc875e7429588\", \"desc\": \"JavaScript策略可以用```threading```对象创建真正并行执行的线程，并用消息、共享字典、锁等对象在线程之间通信。本页说明怎么选用、怎么组织线程代码；各函数的参数和返回值见语法手册{@fun/Threads Threads}。\\n\\n## 先选对工具\\n\\n| 需求 | 推荐 | 适用语言 |\\n| - | - | - |\\n| 同时发出几个API请求（如同时取多个交易所的行情），等结果回来 | {@fun/Threads/exchange.Go exchange.Go}，配合{@fun/Threads/EventLoop EventLoop}等待完成事件 | 所有语言 |\\n| 长时间在后台运行的任务：独立的行情采集、风控巡检、耗时计算 | {@fun/Threads/threading/Thread threading.Thread} | 仅JavaScript |\\n| 在策略内提供HTTP、WebSocket或TCP服务 | {@fun/Threads/threading/Serve threading.Serve} | 仅JavaScript |\\n\\n只是并发几个请求时，```exchange.Go()```更简单，也不需要处理线程间的数据传递。本页的```threading```对象只适用于JavaScript策略，Python、Rust策略请使用```exchange.Go()```。\\n\\n回测系统中可以调用这些函数，但线程实际是按顺序执行的，只用于保证代码在回测中能运行。\\n\\n## 线程运行在隔离的环境中\\n\\n传给```threading.Thread()```的函数在一个独立的JavaScript环境中执行，这是写线程代码时最需要注意的一点：\\n\\n- 线程函数**不能引用外部的变量和闭包**，也不能调用策略里自定义的其它函数。需要的数据通过```threading.Thread(func, arg1, arg2, ...)```的参数传入。\\n- 普通对象、数组作为参数时是**深拷贝**：线程里修改它不影响其它线程。需要多个线程看到同一份数据时，使用```threading.Dict()```创建的字典。\\n- 函数也可以作为参数传入；```threading.Thread()```还支持传入函数源码字符串，用于在线程中加载外部库。\\n- 线程里可以直接调用平台的API函数，如```exchange.GetTicker()```、```Log()```。\\n- 线程函数的返回值通过```join()```取回：```t.join().ret```。\\n\\n## 线程之间怎样交换数据\\n\\n| 方式 | 用法 | 说明 |\\n| - | - | - |\\n| 消息 | ```t.postMessage(msg)```发给线程```t```；线程内用```threading.currentThread().peekMessage(timeout)```读取自己收到的消息；子线程用```threading.mainThread().postMessage(msg)```发回主线程 | 每个线程有自己的收件箱，按顺序读取。```peekMessage(-1)```不阻塞，没有消息时返回空值 |\\n| 共享字典 | ```var d = threading.Dict()```，作为参数传入线程后各线程```d.get(key)```、```d.set(key, value)``` | 适合保存「最新状态」，例如最新行情、运行标志 |\\n| 线程数据 | ```t.setData(key, value)```、```t.getData(key)``` | 挂在某个线程对象上的键值，线程结束（```join()```、```terminate()```）后失效 |\\n| 同步对象 | ```threading.Lock()```、```threading.Event()```、```threading.Condition()``` | 作为参数传入线程，用于互斥访问和等待通知 |\\n\\n线程收到消息时也会产生事件，可以用线程对象的{@fun/Threads/Thread/eventLoop eventLoop}统一等待消息和其它事件。\\n\\n## 线程的生命周期\\n\\n- ```t.join()```等待线程结束并取回返回值，可以设置超时；```t.terminate()```强制结束线程。\\n- 线程结束且不再被引用时，资源会自动回收，不必为了释放资源调用```join()```。持续引用、无法回收的线程累计超过2000个时会报错。\\n- ```threading.pending()```返回正在运行的线程数（包括主线程）。\\n- 实盘停止时所有线程一起结束。```peekMessage()```、```join()```、锁和事件的等待都会被停止打断。\\n\\n## 在策略内提供服务\\n\\n```threading.Serve(地址, 处理函数, ...参数)```在策略进程内启动HTTP（含WebSocket）或TCP服务，每个请求或连接在独立的线程中调用处理函数，返回{@fun/Threads/Server Server}对象（```addr()```取实际监听地址，```close()```关闭）。处理函数与线程函数一样运行在隔离环境中，需要的数据通过参数传入，常用```threading.Dict()```与主线程共享状态。地址写法、```ctx```对象的方法见{@fun/Threads/threading/Serve Serve}。\\n\\n旧的全局函数```__Serve()```仍可使用，它只返回监听地址字符串，新代码请使用```threading.Serve()```。\\n\\n## 示例\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbols = [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\", \\\"SOL_USDT\\\"]\\n var threads = []\\n for (var i = 0; i < symbols.length; i++) {\\n threads.push(threading.Thread(function(symbol, period) {\\n // 在线程中运行：只能使用参数和平台API\\n var records = exchange.GetRecords(symbol, period)\\n if (!records || records.length < 20) {\\n return null\\n }\\n var ma = TA.MA(records, 20)\\n return {symbol: symbol, close: records[records.length - 1].Close, ma20: ma[ma.length - 1]}\\n }, symbols[i], PERIOD_H1))\\n }\\n for (var i = 0; i < threads.length; i++) {\\n var r = threads[i].join().ret\\n if (r) {\\n Log(r.symbol, \\\"收盘价:\\\", r.close, \\\"MA20:\\\", r.ma20)\\n }\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"### 多个线程并行计算，主线程汇总结果\\n\\n每个线程拉取一个交易对的K线并计算均线，结果通过返回值交给主线程。注意交易对通过参数传入，线程函数里没有引用外部变量。\"}, {\"examples\": [{\"code\": \"function main() {\\n var shared = threading.Dict()\\n var worker = threading.Thread(function(dict, symbol) {\\n while (true) {\\n // 读取主线程发来的指令，-1 表示不阻塞\\n var cmd = threading.currentThread().peekMessage(-1)\\n if (cmd == \\\"stop\\\") {\\n break\\n }\\n var ticker = exchange.GetTicker(symbol)\\n if (ticker) {\\n dict.set(\\\"last\\\", ticker.Last)\\n dict.set(\\\"time\\\", ticker.Time)\\n } else {\\n threading.mainThread().postMessage(\\\"行情获取失败: \\\" + GetLastError())\\n }\\n Sleep(1000)\\n }\\n return \\\"worker exited\\\"\\n }, shared, \\\"BTC_USDT\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n // 最多等 1 秒后台线程的消息\\n var msg = threading.currentThread().peekMessage(1000)\\n if (msg) {\\n Log(\\\"后台线程报告:\\\", msg)\\n }\\n LogStatus(\\\"最新价:\\\", shared.get(\\\"last\\\"), \\\"时间:\\\", _D(shared.get(\\\"time\\\")))\\n }\\n worker.postMessage(\\\"stop\\\")\\n Log(worker.join().ret)\\n}\", \"lang\": \"javascript\"}], \"value\": \"### 后台线程采集行情，主线程读取与下发指令\\n\\n后台线程把最新价写进共享字典，并把异常通过消息报告给主线程；主线程通过消息通知后台线程退出。\"}, {\"examples\": [{\"code\": \"function main() {\\n var state = threading.Dict()\\n var server = threading.Serve(\\\"http://127.0.0.1:8088\\\", function(ctx, st) {\\n if (ctx.path() == \\\"/status\\\") {\\n ctx.setHeader(\\\"Content-Type\\\", \\\"application/json\\\")\\n ctx.write(JSON.stringify({last: st.get(\\\"last\\\"), updated: st.get(\\\"updated\\\")}))\\n } else {\\n ctx.setStatus(404)\\n }\\n }, state)\\n Log(\\\"服务地址:\\\", server.addr())\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n state.set(\\\"last\\\", ticker.Last)\\n state.set(\\\"updated\\\", _D())\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"### 用threading.Serve提供状态查询接口\\n\\n主线程把状态写进共享字典，HTTP处理函数从参数取到同一个字典并返回JSON。\"}], \"seeAlso\": [\"{@fun/Threads Threads}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Serve Serve}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Threads/EventLoop EventLoop}\"], \"title\": \"JavaScript多线程\"}, {\"_src_hash\": \"eb00dc29027044de2a9048beee3779610263afc99035b1451c6573f9c24c703f\", \"desc\": \"每个实盘都有一个频道，频道ID就是实盘ID。实盘用```SetChannelData()```在自己的频道上发布数据，其它实盘用```GetChannelData(实盘ID)```读取。数据经平台服务端转发，可以跨托管者、跨服务器传递。\\n\\n频道保存的是**最新状态**，不是消息队列：每次发布都覆盖上一次的数据，订阅端每次读到的都是当前最新的一份。需要历史记录时由订阅端自己保存。\\n\\n常见用途：\\n\\n- **主从协同**：主策略分析行情并发布信号，多个从策略读取信号在各自账户上执行。\\n- **状态监控**：各策略发布运行状态，监控实盘汇总展示或告警。\\n- **数据共享**：一个实盘计算指标、发布结果，其它实盘直接使用，避免重复计算。\\n\\n## 使用要点\\n\\n- **首次读取即订阅**：对某个频道第一次调用```GetChannelData()```时完成订阅并返回空值（```null```/```None```），之后服务端把该频道的更新推送到本实盘，再调用就能读到最新数据。订阅端应在启动时就开始读取，并处理空值。\\n- **订阅上限**：每个实盘最多订阅10个不同的频道（包括下面的UUID频道）。超出时该次调用返回空值，并记录一条错误日志```channel subscriber exceed limit```。\\n- **数据格式**：JavaScript、Python的```SetChannelData()```可以传入任何可以JSON序列化的数据，订阅端读到的是解析后的对象。数据不变时不会重复发送。数据大小限制见{@fun/Storage/SetChannelData SetChannelData}。\\n- **Rust**：```SetChannelData(string)```只接受字符串，需要自己拼好JSON文本；```GetChannelData()```没有频道参数，不能指定要读取的频道，因此不能订阅其它实盘或UUID频道。Rust策略适合作为广播端，订阅端请使用JavaScript或Python。\\n- **跨平台推送**：外部系统（如TradingView告警、自建程序）可以通过扩展API的```method=pub```向指定实盘推送一个以32位UUID标识的频道数据，实盘用```GetChannelData(UUID)```读取，具体方法见{@fun/Storage/SetChannelData SetChannelData}、{@fun/Storage/GetChannelData GetChannelData}。\\n- **实盘功能**：频道通信用于实盘之间，回测时不要依赖它。当前实盘ID可以用```_G()```获取。\\n- 不要在频道中传递密钥等敏感信息。\\n\\n## 基本用法\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var robotId = _G() // 当前实盘ID，也就是本实盘的频道ID\\n var updateId = 0\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n // 发布最新状态，覆盖上一次的数据\\n SetChannelData({\\n robotId: robotId,\\n updateId: ++updateId,\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n lastPrice: ticker.Last\\n })\\n LogStatus(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker.Last)\\n }\\n Sleep(60000) // 每分钟发布一次\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n robotId = _G() # 当前实盘ID，也就是本实盘的频道ID\\n updateId = 0\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n updateId += 1\\n # 发布最新状态，覆盖上一次的数据\\n SetChannelData({\\n \\\"robotId\\\": robotId,\\n \\\"updateId\\\": updateId,\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"lastPrice\\\": ticker[\\\"Last\\\"]\\n })\\n LogStatus(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker[\\\"Last\\\"])\\n Sleep(60000) # 每分钟发布一次\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let robotId = _G!(); // 当前实盘ID，也就是本实盘的频道ID\\n let mut updateId = 0;\\n\\n loop {\\n if let Ok(ticker) = exchange.GetTicker(\\\"BTC_USDT\\\") {\\n updateId += 1;\\n // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本\\n let state = format!(\\n r#\\\"{{\\\"robotId\\\": \\\"{}\\\", \\\"updateId\\\": {}, \\\"timestamp\\\": {}, \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"lastPrice\\\": {}}}\\\"#,\\n robotId, updateId, Unix() * 1000, ticker.Last\\n );\\n SetChannelData(&state);\\n LogStatus!(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker.Last);\\n }\\n Sleep(60000); // 每分钟发布一次\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 广播端：发布行情摘要\"}, {\"examples\": [{\"code\": \"function main() {\\n // 要订阅的实盘ID（按实际情况修改）\\n var channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while (true) {\\n var msg = \\\"\\\"\\n for (var i = 0; i < channels.length; i++) {\\n // 第一次调用完成订阅并返回 null，之后返回最新数据\\n var state = GetChannelData(channels[i])\\n if (state) {\\n msg += \\\"频道 \\\" + channels[i] + \\\"：#\\\" + state.updateId + \\\" \\\" + _D(state.timestamp) + \\\" 最新价 \\\" + state.lastPrice + \\\"\\\\n\\\"\\n } else {\\n msg += \\\"频道 \\\" + channels[i] + \\\"：等待数据\\\\n\\\"\\n }\\n }\\n LogStatus(msg)\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 要订阅的实盘ID（按实际情况修改）\\n channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while True:\\n msg = \\\"\\\"\\n for ch in channels:\\n # 第一次调用完成订阅并返回 None，之后返回最新数据\\n state = GetChannelData(ch)\\n if state:\\n msg += \\\"频道 {}：#{} {} 最新价 {}\\\\n\\\".format(ch, state[\\\"updateId\\\"], _D(state[\\\"timestamp\\\"]), state[\\\"lastPrice\\\"])\\n else:\\n msg += \\\"频道 {}：等待数据\\\\n\\\".format(ch)\\n LogStatus(msg)\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"// Rust 的 GetChannelData() 没有频道参数，不能订阅其它实盘的频道\", \"lang\": \"rust\"}], \"value\": \"### 订阅端：读取两个频道\"}, {\"examples\": [{\"code\": \"function main() {\\n while (true) {\\n var records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if (records && records.length >= 21) {\\n var ma5 = TA.MA(records, 5)\\n var ma20 = TA.MA(records, 20)\\n var n = records.length\\n var signal = \\\"HOLD\\\"\\n if (ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2]) {\\n signal = \\\"BUY\\\"\\n } else if (ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2]) {\\n signal = \\\"SELL\\\"\\n }\\n SetChannelData({\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n signal: signal,\\n price: records[n - 1].Close\\n })\\n LogStatus(\\\"当前信号:\\\", signal, \\\"价格:\\\", records[n - 1].Close)\\n }\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n while True:\\n records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if records and len(records) >= 21:\\n ma5 = TA.MA(records, 5)\\n ma20 = TA.MA(records, 20)\\n signal = \\\"HOLD\\\"\\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 SetChannelData({\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"signal\\\": signal,\\n \\\"price\\\": records[-1][\\\"Close\\\"]\\n })\\n LogStatus(\\\"当前信号:\\\", signal, \\\"价格:\\\", records[-1][\\\"Close\\\"])\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n loop {\\n if let Ok(records) = exchange.GetRecords(\\\"BTC_USDT\\\", None, None) {\\n let n = records.len();\\n if n >= 21 {\\n let ma5 = TA.MA(&records, 5);\\n let ma20 = TA.MA(&records, 20);\\n let mut signal = \\\"HOLD\\\";\\n if ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2] {\\n signal = \\\"BUY\\\";\\n } else if ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2] {\\n signal = \\\"SELL\\\";\\n }\\n let price = records[n - 1].Close;\\n // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本\\n let data = format!(\\n r#\\\"{{\\\"timestamp\\\": {}, \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"signal\\\": \\\"{}\\\", \\\"price\\\": {}}}\\\"#,\\n Unix() * 1000, signal, price\\n );\\n SetChannelData(&data);\\n LogStatus!(\\\"当前信号:\\\", signal, \\\"价格:\\\", price);\\n }\\n }\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"## 场景：主从策略协同\\n\\n主策略计算均线交叉信号并发布；从策略读取信号，在信号变化时下单。\\n\\n**主策略（发布信号）**\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterId = \\\"632799\\\" // 主策略的实盘ID\\n var lastSignal = null\\n\\n while (true) {\\n var data = GetChannelData(masterId)\\n if (!data) {\\n LogStatus(\\\"等待主策略信号...\\\")\\n } else {\\n if (data.signal !== lastSignal) {\\n Log(\\\"收到新信号:\\\", data.signal, \\\"信号价格:\\\", data.price)\\n var ticker = exchange.GetTicker(data.symbol)\\n if (ticker && data.signal === \\\"BUY\\\") {\\n exchange.CreateOrder(data.symbol, \\\"buy\\\", ticker.Last, 0.01)\\n } else if (ticker && data.signal === \\\"SELL\\\") {\\n exchange.CreateOrder(data.symbol, \\\"sell\\\", ticker.Last, 0.01)\\n }\\n lastSignal = data.signal\\n }\\n LogStatus(\\\"当前信号:\\\", data.signal, \\\"信号时间:\\\", _D(data.timestamp))\\n }\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n masterId = \\\"632799\\\" # 主策略的实盘ID\\n lastSignal = None\\n\\n while True:\\n data = GetChannelData(masterId)\\n if not data:\\n LogStatus(\\\"等待主策略信号...\\\")\\n else:\\n if data[\\\"signal\\\"] != lastSignal:\\n Log(\\\"收到新信号:\\\", data[\\\"signal\\\"], \\\"信号价格:\\\", data[\\\"price\\\"])\\n ticker = exchange.GetTicker(data[\\\"symbol\\\"])\\n if ticker and data[\\\"signal\\\"] == \\\"BUY\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"buy\\\", ticker[\\\"Last\\\"], 0.01)\\n elif ticker and data[\\\"signal\\\"] == \\\"SELL\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"sell\\\", ticker[\\\"Last\\\"], 0.01)\\n lastSignal = data[\\\"signal\\\"]\\n LogStatus(\\\"当前信号:\\\", data[\\\"signal\\\"], \\\"信号时间:\\\", _D(data[\\\"timestamp\\\"]))\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"// Rust 的 GetChannelData() 没有频道参数，不能读取主策略实盘的频道\", \"lang\": \"rust\"}], \"value\": \"**从策略（读取信号并执行）**\"}, {\"examples\": [{\"code\": \"function main() {\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] // 最多10个\\n\\n while (true) {\\n var table = {type: \\\"table\\\", title: \\\"策略运行状态\\\", cols: [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"最新价\\\"], rows: []}\\n for (var i = 0; i < monitorList.length; i++) {\\n var data = GetChannelData(monitorList[i])\\n if (data) {\\n var status = Date.now() - data.timestamp < 120000 ? \\\"运行中\\\" : \\\"异常\\\"\\n table.rows.push([monitorList[i], status, _D(data.timestamp), data.symbol || \\\"-\\\", data.lastPrice || \\\"-\\\"])\\n } else {\\n table.rows.push([monitorList[i], \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n }\\n }\\n LogStatus(\\\"`\\\" + JSON.stringify(table) + \\\"`\\\")\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import json\\nimport time\\n\\ndef main():\\n monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] # 最多10个\\n\\n while True:\\n table = {\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"策略运行状态\\\", \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"最新价\\\"], \\\"rows\\\": []}\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n if data:\\n status = \\\"运行中\\\" if time.time() * 1000 - data[\\\"timestamp\\\"] < 120000 else \\\"异常\\\"\\n table[\\\"rows\\\"].append([robotId, status, _D(data[\\\"timestamp\\\"]), data.get(\\\"symbol\\\", \\\"-\\\"), data.get(\\\"lastPrice\\\", \\\"-\\\")])\\n else:\\n table[\\\"rows\\\"].append([robotId, \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n LogStatus(\\\"`\\\" + json.dumps(table) + \\\"`\\\")\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"// Rust 的 GetChannelData() 没有频道参数，不能读取其它实盘的频道\", \"lang\": \"rust\"}], \"value\": \"## 场景：多策略状态监控\\n\\n各策略按上面广播端的方式发布状态，监控实盘读取所有频道，用表格展示，超过2分钟没有更新的标记为异常。\"}], \"seeAlso\": [\"{@fun/Storage/SetChannelData SetChannelData}, {@fun/Storage/GetChannelData GetChannelData}, {@fun/Storage/_G _G}\"], \"title\": \"策略实盘间通信\"}, {\"_src_hash\": \"529b4cddaf187986d3a6959e3e784d0a8433e36d6d9d0d8f7fdd9150c6c58999\", \"desc\": \"交易所对API调用频率有限制，超限轻则请求被拒，重则账号被临时封禁。用```exchange.IO(\\\"rate\\\", ...)```或```exchange.IO(\\\"quota\\\", ...)```可以在托管者本地给标准函数设置调用频率上限：超限的调用不会发出请求。\\n\\n```js\\nexchange.IO(\\\"rate\\\" | \\\"quota\\\", 名字, 次数, 窗口[, \\\"delay\\\"])\\n```\\n\\n## 两种模式\\n\\n- **rate（令牌桶）**：桶容量默认等于```次数```，开始时是满的，之后按「次数/窗口」的速度匀速补充，每次调用消耗一个。允许短时间连续调用，长期平均不超过「次数/窗口」。```次数```写成```\\\"10/5\\\"```时表示每个窗口补充10次、桶容量为5，用来限制突发。\\n- **quota（固定窗口）**：每个窗口内最多调用```次数```次，进入下一个窗口时清零。窗口按时间纪元对齐：```\\\"1s\\\"```对齐整秒，```\\\"1m\\\"```对齐整分钟，```\\\"1h\\\"```对齐整点，```\\\"1d\\\"```对齐UTC零点（即北京时间08:00）。例如12:00:00.900开始计数，到12:00:01.000就进入了新窗口。\\n\\n需要严格保证「任意一个交易所计数周期内不超过N次」时用```quota```并让窗口与交易所的计数周期一致；只需要控制平均频率时用```rate```。\\n\\n## 参数\\n\\n| 参数 | 说明 |\\n| - | - |\\n| 名字 | 要限制的函数名，见下表。多个名字用逗号分隔（如```\\\"GetTicker,GetDepth\\\"```）时共用一条规则，调用次数合并计算。```\\\"*\\\"```是兜底规则，只对没有专属规则的函数生效。 |\\n| 次数 | 每个窗口允许的调用次数，必须大于0；```rate```模式可以写成```\\\"次数/突发\\\"```。传```0```或负数表示删除该名字的规则。 |\\n| 窗口 | 时长，写法同Go语言的```time.ParseDuration```：单位```ns```、```us```（或```µs```）、```ms```、```s```、```m```、```h```，可以带小数（```\\\"1.5s\\\"```），可以组合（```\\\"1h30m\\\"```）；另外支持```\\\"Nd\\\"```表示N天（可以带小数，如```\\\"0.5d\\\"```，不能与其它单位组合）。写成```\\\"@HHMM\\\"```或```\\\"@HHMMSS\\\"```（如```\\\"@0800\\\"```）表示按天计数、每天在该时刻（北京时间）清零，```rate```和```quota```都可以使用。 |\\n| 动作 | 省略时超限的调用立即失败；写```\\\"delay\\\"```时阻塞等待，直到有可用次数再发出请求。等待期间停止实盘会打断等待。 |\\n\\n## 可以限制的函数名\\n\\n| 类别 | 名字 |\\n| - | - |\\n| 行情 | ```GetTicker```、```GetTickers```、```GetDepth```、```GetTrades```、```GetRecords```、```GetMarkets```、```GetFundings``` |\\n| 账户 | ```GetAccount```、```GetAssets```、```GetPositions```、```SetMarginLevel``` |\\n| 交易 | ```CreateOrder```（```Buy```、```Sell```也计入）、```CancelOrder```、```ModifyOrder``` |\\n| 订单查询 | ```GetOrder```、```GetOrders```、```GetHistoryOrders``` |\\n| 条件单 | ```CreateConditionOrder```、```ModifyConditionOrder```、```CancelConditionOrder```、```GetConditionOrder```、```GetConditionOrders```、```GetHistoryConditionOrders``` |\\n| 自定义请求 | ```IO/api```：只限制```exchange.IO(\\\"api\\\", ...)```，不影响其它```exchange.IO()```指令 |\\n\\n- ```GetAccount```和```GetAssets```是同一个底层请求，写其中任何一个名字的规则对两个函数都生效。\\n- 通过```exchange.Go()```并发调用时，按实际调用的函数计数。\\n\\n## 规则的作用范围\\n\\n- 规则按交易所对象分别设置：```exchanges[0]```上的规则不影响```exchanges[1]```。\\n- 规则只在本次运行中有效，实盘重启后需要重新设置，通常写在```main()```开头。\\n- 同一个名字再次设置时覆盖原规则；名字传空字符串（```exchange.IO(\\\"rate\\\", \\\"\\\")```）清空该交易所对象上的全部规则。\\n- 一次调用只按一条规则计数：有专属规则的函数不再计入```\\\"*\\\"```，所以```\\\"*\\\"```不能当作「所有调用的总配额」叠加在专属规则之上。\\n\\n## 超限时的表现\\n\\n默认动作下，超限的调用不发请求，按调用失败处理（JavaScript返回```null```，Python返回```None```，Rust返回```Err```），错误信息形如：\\n\\n```\\nrate limit exceeded: GetTicker 10/1s\\nquota limit exceeded: GetTicker 10/1m\\nquota limit exceeded: GetRecords 2000/day (resets at 0800)\\n```\\n\\n使用```\\\"delay\\\"```动作时调用会阻塞到有可用次数，日志中记录的调用时间是等待结束之后的时间。对每天清零的规则使用```\\\"delay\\\"```，最长可能等待到第二天，请谨慎使用。\\n\\n## 示例\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker.Last)\\n } else {\\n // 超限的调用不发请求，返回 null\\n Log(\\\"第\\\", i + 1, \\\"次被限流:\\\", GetLastError())\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker[\\\"Last\\\"])\\n else:\\n # 超限的调用不发请求，返回 None\\n Log(\\\"第\\\", i + 1, \\\"次被限流:\\\", GetLastError())\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\"));\\n\\n for i in 0..10 {\\n match exchange.GetTicker(\\\"BTC_USDT\\\") {\\n Ok(ticker) => Log!(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker.Last),\\n // 超限的调用不发请求，返回 Err\\n Err(e) => Log!(\\\"第\\\", i + 1, \\\"次被限流:\\\", e),\\n }\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 默认动作：超限时调用失败\"}, {\"examples\": [{\"code\": \"function main() {\\n // 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n var depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if (ticker && depth) {\\n Log(\\\"最新价:\\\", ticker.Last, \\\"买一:\\\", depth.Bids[0].Price)\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n # 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n # 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if ticker and depth:\\n Log(\\\"最新价:\\\", ticker[\\\"Last\\\"], \\\"买一:\\\", depth[\\\"Bids\\\"][0][\\\"Price\\\"])\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\"));\\n // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n let _ = exchange.IO((\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n let _ = exchange.IO((\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\"));\\n\\n loop {\\n if let (Ok(ticker), Ok(depth)) = (exchange.GetTicker(\\\"BTC_USDT\\\"), exchange.GetDepth(\\\"BTC_USDT\\\")) {\\n Log!(\\\"最新价:\\\", ticker.Last, \\\"买一:\\\", depth.Bids[0].Price);\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### 按交易所的限频规则分组设置\\n\\n行情和交易分别共用一条规则；交易类超限时等待而不是失败；其余没有专属规则的函数用```\\\"*\\\"```兜底。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 平均每秒 10 次，但最多连续突发 2 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n // 每天北京时间 08:00 清零，每天最多 2000 次\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n // 次数传 0：删除 GetOrders 的规则\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n // 名字传空字符串：清空本交易所对象上的全部规则\\n exchange.IO(\\\"rate\\\", \\\"\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 平均每秒 10 次，但最多连续突发 2 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n # 每天北京时间 08:00 清零，每天最多 2000 次\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n # 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n # 次数传 0：删除 GetOrders 的规则\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n # 名字传空字符串：清空本交易所对象上的全部规则\\n exchange.IO(\\\"rate\\\", \\\"\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 平均每秒 10 次，但最多连续突发 2 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\"));\\n // 每天北京时间 08:00 清零，每天最多 2000 次\\n let _ = exchange.IO((\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\"));\\n // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\"));\\n\\n // 次数传 0：删除 GetOrders 的规则\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 0));\\n // 名字传空字符串：清空本交易所对象上的全部规则\\n let _ = exchange.IO((\\\"rate\\\", \\\"\\\"));\\n}\", \"lang\": \"rust\"}], \"value\": \"### 突发容量、每日配额与删除规则\"}], \"seeAlso\": [\"{@fun/IO/exchange.IO exchange.IO}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Global/GetLastError GetLastError}\"], \"title\": \"API限流控制\"}, {\"_src_hash\": \"9c6654b6d2f6c7c73641f49a24b15f9f2b2cdf7d0b36734e55502285ac0d6fda\", \"desc\": \"发明者量化交易平台支持在以下加密货币期货交易所交易期权。期权的用法与期货合约相同：用```exchange.SetContractType()```把合约设为期权代码（期权代码就是交易所的原生代码，各交易所写法不同），之后```GetTicker()```、```GetDepth()```等行情函数，```Buy()```、```Sell()```（下单前用```exchange.SetDirection()```设置交易方向）、```CancelOrder()```、```GetPositions()```等交易函数都作用于该期权合约。也可以用完整的交易品种代码直接下单，形如```交易对.期权代码```，例如```BTC_USDT.BTC-260925-145000-C```。\\n\\n期权合约的盘口通常较薄：买一、卖一没有挂单时```Ticker```的```Buy```、```Sell```为0，从未成交的合约```Last```也可能为0，各交易所的处理见下文。```exchange.GetMarkets()```是否列出期权合约因交易所而异；不列出时，期权代码需要从交易所的接口或网页获取。\\n\\n## Futures_Deribit\\n\\n设置期权合约后即可获取行情、下单、撤单、查询持仓。期权代码例子：```BTC-13SEP24-60000-C```、```XRP_USDC-27SEP24-1-C```，组合合约例子：```BTC-CS-6SEP24-57000_57500```、```BTC-PCAL-20SEP24_13SEP24-55000```。```exchange.GetMarkets()```的结果包含期权合约。\\n\\n可供参考的策略代码：[Deribit期权测试策略](https://www.fmz.com/strategy/179475)\\n\\n## Futures_OKX\\n\\n用法与Deribit相同，交易对设置为```BTC_USD```等，期权代码形如```BTC-USD-200626-4500-C```。从未成交的期权合约，```GetTicker()```的```Last```取标记价格。```exchange.GetMarkets()```不列出期权合约，可以通过OKX的```/api/v5/public/instruments```接口查询期权合约列表，例如查询BTC期权：\\n\\n```js\\nfunction main() {\\n Log(HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\"))\\n}\\n```\\n\\n```python\\nimport json\\nimport urllib.request\\ndef main():\\n ret = json.loads(urllib.request.urlopen(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\").read().decode('utf-8'))\\n Log(ret)\\n```\\n\\n```rust\\nfn main() {\\n let body: String = HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\", None);\\n Log!(body);\\n}\\n```\\n\\n## Futures_Binance\\n\\n支持币安欧式期权（USDT结算），交易对设置为```BTC_USDT```等，期权代码形如```BTC-260925-145000-C```（标的-到期日YYMMDD-行权价-C/P）。需要账户已开通期权交易。限制：\\n\\n- 只支持限价单，不支持市价单、条件单和改单（```exchange.ModifyOrder()```）。\\n- 不支持```exchange.SetMarginLevel()```等杠杆、保证金模式设置。\\n- 统一账户（组合保证金）不支持期权。\\n- ```exchange.GetMarkets()```不列出期权合约。\\n\\n## Futures_Bybit\\n\\n支持两种结算的期权：\\n\\n- USDC结算：交易对设置为```ETH_USDC```等，期权代码形如```ETH-25NOV22-1375-P```。\\n- USDT结算：交易对设置为```ETH_USDT```等，期权代码比USDC结算的多一段结算币后缀，形如```ETH-25JUN27-2800-C-USDT```。\\n\\n```exchange.GetMarkets()```的结果包含两种结算的期权合约。Bybit期权没有K线接口，```GetRecords()```由成交记录合成。\\n\\n## Futures_Aevo\\n\\n支持Aevo交易所的USDC期权，交易对设置为```ETH_USDC```等，期权代码形如```ETH-30JUN23-1600-C```。```GetTicker()```的```Last```为标记价格。Aevo没有K线接口，```GetRecords()```由成交记录合成，合约没有成交时为空。```exchange.GetMarkets()```的结果包含期权合约。\\n\\n## Futures_GateIO\\n\\n支持Gate交易所的USDT期权，交易对设置为```BTC_USDT```等，期权代码形如```BTC_USDT-20211130-65000-C```。```exchange.GetMarkets()```的结果包含期权合约。账户没有开通期权时，查询订单、持仓会返回交易所的错误。\\n\\n## Futures_Kraken\\n\\n支持Kraken期货的期权，交易对设置为```ETH_USD```等，期权代码形如```OF_ETHUSD_261225_4000_C```（```OF_```、标的与计价币、到期日YYMMDD、行权价、C/P），代码中的标的与计价币必须与交易对一致，BTC在代码中写作```XBT```（如```OF_XBTUSD_...```）。\\n\\n- Kraken没有期权合约列表接口，```exchange.GetMarkets()```不包含期权合约，期权代码需要从Kraken网页获取。\\n- ```GetTicker()```的```Last```取标记价格，```Buy```、```Sell```、```High```、```Low```为0，原始数据```Info```中有隐含波动率、希腊值等字段。\\n- 行情、K线、订单、持仓、历史订单的查询可用；期权下单与期货合约走同一个下单接口，尚未经过实盘验证。\\n- 期权没有资金费率，不支持```exchange.SetMarginLevel()```。\", \"seeAlso\": [\"{@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.GetPositions exchange.GetPositions}\"], \"title\": \"期权交易\"}, {\"_src_hash\": \"a67824b1213013415d0d82f475ed7aa25dfb75b33b3be7c5899f1956a634586c\", \"children\": [{\"_src_hash\": \"4b8b85efaa17fc456b7b7f803313a0fbefc864dbd41ef7f46e21a1549602457e\", \"desc\": \"Uniswap交易所对象在一条链上连接Uniswap或PancakeSwap的V2、V3资金池，把链上兑换映射为现货交易函数：用```exchange.GetTicker()```看价格、用```exchange.CreateOrder()```下单，不需要自己注册ABI、编码合约调用。选路、询价、代币授权、价格保护、发送交易都由交易所对象完成。\\n\\n## 什么时候用Uniswap交易所对象，什么时候用Web3\\n\\n- 在Uniswap、PancakeSwap上**兑换代币**：用Uniswap交易所对象。\\n- 调用其它合约、DEX的其它功能（如提供流动性、管理V3头寸）、其它链、自定义交易：用Web3交易所对象，见{@进阶专题/Web3/以太坊（EVM）以太坊（EVM）}。\\n\\n一个策略可以同时添加两种交易所对象，使用同一个钱包。\\n\\n## 配置交易所对象\\n\\n| 字段 | 说明 |\\n| - | - |\\n| DEX | ```Uniswap```或```PancakeSwap``` |\\n| Chain | ```Ethereum```、```Arbitrum```、```Base```、```BNB Chain```。一个交易所对象只对应一条链上的一个DEX |\\n| Private Key | 钱包私钥（十六进制字符串）。支持把私钥本地化部署在托管者上，参看{@入门/密钥安全性密钥安全性} |\\n| Rpc Address | 该链的节点地址，选择Chain时自动填入公共节点（如以太坊为```https://ethereum-rpc.publicnode.com```）。可以写多个节点，用逗号分隔，互为备用 |\\n| Rpc Api Key | 节点鉴权，可以留空。写成```名称: 值```时作为该名称的请求头发送，否则作为```Authorization: Basic <值>```发送 |\\n\\n第一次调用时会核对节点所在的链与Chain是否一致，不一致时报错，不会把交易发到别的链上。钱包里需要有该链的原生币（ETH或BNB）支付gas。\\n\\n## 交易对\\n\\n- 交易对写作```ETH_USDC```、```UNI_USDT```这样的```基础币_计价币```。\\n- 代币名按以下顺序解析：内置的常用代币（原生币、包装币、USDC、USDT等）→ 用```exchange.IO(\\\"token\\\", 名字, 合约地址)```登记的代币 → 官方代币列表。官方列表中同一条链上有同名代币时，请改用合约地址。\\n- 不在代币表中的代币可以直接用合约地址作为交易对的一部分，例如```0x1f9840a85d5af5bf1d1762f925bdaddc4201f984_USDC```。\\n- **原生币与包装币是两种资产**：```ETH```与```WETH```、```BNB```与```WBNB```分别是不同的币。交易原生币时路由合约会自动包装、解包。两者之间的转换不能下单，用```exchange.IO(\\\"wrap\\\", 数量)```、```exchange.IO(\\\"unwrap\\\", 数量)```直接调用包装币合约，1:1兑换，只花gas。\\n- ```exchange.GetMarkets()```只列出常用的交易对，没有列出的交易对同样可以交易。\\n\\n## 标准函数的含义\\n\\n| 函数 | 行为 |\\n| - | - |\\n| ```exchange.GetTicker()``` | 买一、卖一是按一定规模实际询价得到的可成交价格（已包含池子手续费）；链上没有24小时统计 |\\n| ```exchange.GetDepth()``` | 按逐档递增的规模在链上询价，推算出的价位，不是真实的挂单簿 |\\n| ```exchange.GetTrades()``` | 该交易对资金池最近的链上兑换记录 |\\n| ```exchange.GetAccount()```、```exchange.GetAssets()``` | 钱包中原生币和代币表中各代币的余额 |\\n| ```exchange.CreateOrder()``` | 立即在链上兑换，见下文 |\\n| ```exchange.GetOrder()``` | 订单ID就是交易哈希，状态来自交易回执：上链前为未完成，上链后为成交或失败 |\\n| ```exchange.GetOrders()``` | 本次运行发出、还没有上链的订单 |\\n| ```exchange.CancelOrder()``` | 用同一个nonce发送一笔替换交易，尽力撤销，见下文 |\\n\\n不支持```exchange.GetRecords()```、```exchange.GetTickers()```、```exchange.GetHistoryOrders()```。\\n\\n## 下单\\n\\nDEX没有挂单簿，每笔订单都是一次立即执行的链上兑换：要么整笔成交，要么整笔回滚（只损失gas），不会部分成交、也不会挂在那里等价格。\\n\\n- **限价单**：限价是**最差成交价**。下单时先询价，按当前价格达不到限价时直接报错，不发交易；达得到时把「最少得到/最多支付」写进链上交易，交易上链前价格变动导致达不到时整笔回滚。\\n- **市价单**：按询价结果扣除滑点得到最少得到/最多支付的数量，滑点默认0.5%，用```exchange.IO(\\\"slippage\\\", 比例)```修改。\\n- **数量**：卖出时是卖出的基础币数量；限价买入时是要买到的基础币数量；**市价买入时是要花费的计价币数量**。\\n- 单笔订单可以在方向参数后附加设置，例如```exchange.CreateOrder(\\\"ETH_USDC\\\", 'sell;{\\\"slippage\\\":0.01,\\\"route\\\":\\\"v3\\\"}', -1, 0.1)```：```slippage```为本单滑点，```route```限定路径类型（```v2```、```v3```、```hop```两跳、```direct```直连）。\\n- 卖出代币（ERC20）前会检查路由合约的授权额度，不够时先发送授权交易并等待上链。默认只授权本次需要的数量，```exchange.IO(\\\"approve\\\", \\\"max\\\")```改为无限授权，省去之后的授权交易。\\n- 交易超过截止时间（默认120秒，```exchange.IO(\\\"deadline\\\", 秒数)```修改）仍未上链时会回滚，避免在价格大幅变化后才成交。\\n\\n## 撤单\\n\\n```exchange.CancelOrder()```用原订单的nonce发送一笔转给自己的0金额交易，手续费更高，先上链则原订单失效。这只是尽力撤销：原订单可能在替换交易之前上链并成交；原订单已经上链时撤单直接报错。撤单后用```exchange.GetOrder()```确认最终状态。\\n\\n## 常用的exchange.IO()指令\\n\\n| 指令 | 作用 |\\n| - | - |\\n| ```exchange.IO(\\\"slippage\\\", 比例)``` | 市价单滑点，默认```0.005``` |\\n| ```exchange.IO(\\\"deadline\\\", 秒数)``` | 交易截止时间，默认120秒 |\\n| ```exchange.IO(\\\"gasMultiplier\\\", 倍数)``` | gas上限 = 节点估算值 × 倍数，默认1.2 |\\n| ```exchange.IO(\\\"approve\\\", \\\"exact\\\" 或 \\\"max\\\")``` | 授权模式 |\\n| ```exchange.IO(\\\"token\\\", 名字, 合约地址)``` | 登记代币；不传参数时列出代币表 |\\n| ```exchange.IO(\\\"route\\\", 交易对, 方向, 数量)``` | 只询价：各候选路径的报价和最优路径，不下单 |\\n| ```exchange.IO(\\\"simulate\\\", 交易对, 方向, 数量[, 价格])``` | 按下单逻辑构造交易，只在链上模拟执行，不花gas |\\n| ```exchange.IO(\\\"transfer\\\", 收款地址, 数量[, 代币])``` | 转出原生币或代币，数量可以写```\\\"all\\\"``` |\\n| ```exchange.IO(\\\"receipt\\\", 交易哈希[, 等待毫秒])``` | 查询转账等交易的回执，可以等待上链 |\\n| ```exchange.IO(\\\"wrap\\\", 数量)```、```exchange.IO(\\\"unwrap\\\", 数量)``` | 原生币与包装币1:1互换 |\\n| ```exchange.IO(\\\"contracts\\\")``` | 当前DEX在当前链上的合约地址 |\\n| ```exchange.IO(\\\"base\\\", 节点地址)```、```exchange.IO(\\\"sendBase\\\", 节点地址)``` | 切换节点；设置只用于广播交易的节点（私有交易通道） |\\n| ```exchange.IO(\\\"address\\\")``` | 钱包地址 |\\n\\n各指令的参数与返回值见语法手册{@fun/Uniswap Uniswap}分类。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbol = \\\"ETH_USDC\\\"\\n exchange.IO(\\\"slippage\\\", 0.003) // 市价单滑点 0.3%\\n\\n var t = exchange.GetTicker(symbol)\\n Log(\\\"买一:\\\", t.Buy, \\\"卖一:\\\", t.Sell)\\n\\n // 只询价：卖出 0.1 ETH 的最优路径\\n var r = exchange.IO(\\\"route\\\", symbol, \\\"sell\\\", 0.1)\\n Log(\\\"最优路径:\\\", r.best, \\\"价格:\\\", r.price)\\n\\n // 链上模拟一遍，不花 gas\\n if (!exchange.IO(\\\"simulate\\\", symbol, \\\"sell\\\", 0.1)) {\\n Log(\\\"模拟失败:\\\", GetLastError())\\n return\\n }\\n\\n // 市价卖出 0.1 ETH，订单 ID 是交易哈希\\n var id = exchange.CreateOrder(symbol, \\\"sell\\\", -1, 0.1)\\n if (!id) {\\n Log(\\\"下单失败:\\\", GetLastError())\\n return\\n }\\n while (true) {\\n var o = exchange.GetOrder(id)\\n if (o && o.Status != ORDER_STATE_PENDING) {\\n Log(\\\"状态:\\\", o.Status, \\\"成交数量:\\\", o.DealAmount, \\\"成交均价:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"## 示例：询价、模拟，然后市价卖出\\n\\n以以太坊上的```ETH_USDC```为例。注意```CreateOrder```会发出真实交易。\"}], \"seeAlso\": [\"{@fun/Uniswap Uniswap}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}\"], \"title\": \"Uniswap与PancakeSwap\"}, {\"_src_hash\": \"ad0c1326570f7a7cf94f462ce1b00932c56d5fa59eaa30378757fc458ba0f937\", \"desc\": \"Web3交易所对象选择```ChainType```为```ETH```时，可以连接以太坊以及所有EVM兼容链（BSC、Base、Arbitrum、Optimism、Polygon等）的节点，用```exchange.IO()```的各个指令查询余额、调用合约、发送交易。本页按一笔链上操作的流程介绍常用指令，每个指令的完整参数见语法手册{@fun/Web3 Web3}分类中对应的```exchange.IO(\\\"指令\\\", ...)```。\\n\\n只是想在Uniswap、PancakeSwap上兑换代币时，请使用{@进阶专题/Web3/Uniswap与PancakeSwap Uniswap交易所对象}：它直接支持```exchange.GetTicker()```、```exchange.CreateOrder()```等标准函数，不需要自己编码合约调用。\\n\\n## 1. 配置交易所对象\\n\\n在「交易所」页面（```/m/add-platform```）添加交易所，协议选择「加密货币」，交易所选择```Web3```：\\n\\n| 字段 | 说明 |\\n| - | - |\\n| ChainType | ```ETH```：以太坊及所有EVM兼容链；```TRON```：波场，见{@进阶专题/Web3/波场（TRON）波场（TRON）} |\\n| Private Key | 钱包私钥（十六进制字符串，可以带```0x```前缀）。支持把私钥本地化部署在托管者上，参看{@入门/密钥安全性密钥安全性} |\\n| Rpc Address | 节点地址，默认```https://ethereum-rpc.publicnode.com```（以太坊主网公共节点）。连接其它链时填写该链的节点，例如BSC：```https://bsc-dataseed.binance.org```。支持```http(s)://```和```ws(s)://```。可以写多个节点，用逗号分隔，互为备用 |\\n| Rpc Api Key | 节点鉴权，可以留空。写成```名称: 值```（如```x-api-key: xxx```）时作为该名称的请求头发送；否则作为```Authorization: Basic <值>```发送 |\\n\\n多个节点时，从上次成功的节点开始依次尝试：只有节点不可用（连接失败、超时、限流）时才换下一个，合约执行失败之类的错误直接返回；链ID与第一个节点不同的节点会被跳过，避免把交易发到另一条链。\\n\\n运行中可以用```exchange.IO(\\\"base\\\", 节点地址)```切换节点（多个节点可以传数组或逗号分隔的字符串），用```exchange.IO(\\\"key\\\", 私钥)```切换钱包私钥，用{@fun/Web3/exchange.IO(\\\"address\\\") exchange.IO(\\\"address\\\")}获取当前钱包地址。\\n\\n标准函数中只有```exchange.GetAccount()```、```exchange.GetAssets()```可用，返回钱包的原生币余额（币种按链ID识别，如BSC为```BNB```）。\\n\\n## 2. 查询余额与读取合约\\n\\n调用合约的只读方法（```view```/```pure```）不消耗gas，直接返回解码后的结果：\\n\\n```js\\nexchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\") // 原生币余额，链上整数（十六进制字符串）\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"balanceOf\\\", wallet) // ERC20余额，链上整数\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"decimals\\\") // 代币精度\\n```\\n\\n- ```exchange.IO(\\\"api\\\", \\\"eth\\\", 方法, ...参数)```直接调用节点的JSON-RPC方法，如```eth_gasPrice```、```eth_blockNumber```、```eth_getTransactionReceipt```。\\n- ```exchange.IO(\\\"api\\\", 合约地址, 方法, ...参数)```调用合约方法。方法可以写方法名、完整签名（如```\\\"approve(address,uint256)\\\"```，用于区分重载）或方法选择器（如```\\\"0x095ea7b3\\\"```）。\\n- 链上数量都是整数。用```exchange.IO(\\\"fromUnits\\\", 链上整数, 精度)```换算成可读数量，用```exchange.IO(\\\"toUnits\\\", \\\"1.5\\\", 精度)```换算回链上整数；精度也可以直接传代币合约地址。两者都按字符串精确计算。\\n- 批量读取多个合约时用```exchange.IO(\\\"multicall\\\", ...)```一次请求完成；查询事件日志用```exchange.IO(\\\"logs\\\", ...)```。\\n\\n## 3. 注册ABI\\n\\n标准ERC20方法（```balanceOf```、```decimals```、```allowance```、```approve```、```transfer```等）已内置，不需要注册。调用其它合约的方法前，需要用```exchange.IO(\\\"abi\\\", 合约地址, ABI)```注册该合约的ABI。\\n\\n常用合约可以直接使用内置模板，第三个参数传模板名：```\\\"weth\\\"```、```\\\"uniswapV3Pool\\\"```、```\\\"uniswapV3Factory\\\"```、```\\\"uniswapV3QuoterV2\\\"```、```\\\"uniswapV3SwapRouter02\\\"```、```\\\"uniswapV3PositionManager\\\"```、```\\\"permit2\\\"```（PancakeSwap V3使用相同的模板，也可以写```\\\"pancakeV3Pool\\\"```等别名）。常用合约的地址可以用```exchange.IO(\\\"contracts\\\")```查询。\\n\\n```js\\nexchange.IO(\\\"abi\\\", poolAddress, \\\"uniswapV3Pool\\\")\\nvar slot0 = exchange.IO(\\\"api\\\", poolAddress, \\\"slot0\\\")\\n```\\n\\n其它合约的ABI可以从区块浏览器获取，例如Etherscan的V2接口（需要Etherscan的API Key，```chainid```为链ID，取返回结果中的```result```字段）：\\n\\n```url\\nhttps://api.etherscan.io/v2/api?chainid=1&module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45&apikey=YourApiKey\\n```\\n\\n## 4. 发送交易\\n\\n调用合约的写方法时，交易所对象用配置的私钥签名并广播交易，返回交易哈希。发送前可以把```\\\"api\\\"```换成```\\\"call\\\"```，用```exchange.IO(\\\"call\\\", ...)```预演同一笔调用：在节点上模拟执行，不签名、不消耗gas，执行失败时返回空值，```GetLastError()```中有合约给出的失败原因。\\n\\n以授权（approve）为例：\\n\\n```js\\nvar amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", tokenAddress) // 100个代币换算成链上整数\\nvar txHash = exchange.IO(\\\"api\\\", tokenAddress, \\\"approve\\\", spender, amount)\\n```\\n\\n方法的```stateMutability```为```payable```时，方法参数之前要多传一个参数：附带的原生币数量（链上整数）。最后一个参数可以传选项对象：\\n\\n| 选项 | 说明 |\\n| - | - |\\n| gasLimit | gas上限。不传时由节点估算（```eth_estimateGas```）。合约调用不要写```21000```，那只够普通转账 |\\n| gasPrice | 固定gas价格，传入时发送传统（legacy）交易。不传时，支持EIP-1559的链发送EIP-1559交易：小费取节点建议值与最近区块实际小费的较大者，最高费用为```2 × baseFee + 小费``` |\\n| nonce | 指定nonce。不传时自动分配，并与链上待处理计数同步，连续发送不会重复使用nonce |\\n| dryRun | 设为```true```时只签名不广播，返回```hash```、```raw```（签名后的交易）、```nonce```、```gasLimit```等字段，可用于检查交易或交给其它渠道发送 |\\n\\n转出原生币使用```exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"send\\\", 收款地址, 数量)```，数量是链上整数（wei）。它的选项还支持```data```（十六进制调用数据），用于原样发送聚合器等API返回的交易```{to, data, value}```，此时gas按合约调用估算。注意：普通转账不传```gasPrice```时按固定的100 Gwei出价、gas上限为21000，在以太坊主网上通常偏高，建议先用```eth_gasPrice```查询后传入。\\n\\n需要把交易发到私有交易通道（如Flashbots Protect、MEV Blocker）避免被抢跑时，用```exchange.IO(\\\"sendBase\\\", 节点地址)```设置只用于广播交易的节点。\\n\\n## 5. 等待交易上链\\n\\n```exchange.IO(\\\"waitReceipt\\\", 交易哈希, {timeout, confirmations})```等待交易上链并达到确认数，返回交易回执：```status```为```1```表示成功、```0```表示失败（```revertReason```为失败原因），```events```为按已注册ABI解码的事件。超时未上链时返回空值。\\n\\n## 6. nonce管理、加速与取消\\n\\n- ```exchange.IO(\\\"nonce\\\")```查看链上与本地的nonce计数；```exchange.IO(\\\"nonce\\\", \\\"sync\\\")```按链上重新同步（在别处用同一个钱包发过交易后使用）。\\n- 交易长时间未上链时，用```exchange.IO(\\\"speedUp\\\", 交易哈希)```以同一个nonce、更高的手续费重发；用```exchange.IO(\\\"cancelTx\\\", 交易哈希)```发送一笔同nonce、转给自己的0金额交易顶替原交易。两者都在原交易上链前才有效。\\n- 本地nonce记录只在当前实盘内有效：多个实盘共用一个钱包时彼此看不到对方的记录，仍可能冲突，建议每个实盘使用独立的钱包。\\n\\n## 其它指令\\n\\n- 编码与解码：```exchange.IO(\\\"encode\\\", ...)```编码合约调用数据或按类型编码（同Solidity的```abi.encode```），```exchange.IO(\\\"encodePacked\\\", ...)```紧凑编码（如Uniswap V3的兑换路径），```exchange.IO(\\\"decode\\\", ...)```按类型解码。\\n- 签名：```exchange.IO(\\\"sign\\\", ...)```对32字节哈希签名，```exchange.IO(\\\"signTypedData\\\", ...)```对EIP-712结构化数据签名（如ERC-20 Permit），```exchange.IO(\\\"signMessage\\\", ...)```对消息做EIP-191签名。\\n- Uniswap V3数学：```exchange.IO(\\\"uniswapV3\\\", ...)```在tick、价格、sqrtPrice之间换算，在流动性与代币数量之间换算。\\n- 哈希：```exchange.IO(\\\"hash\\\", \\\"keccak256\\\", \\\"raw\\\", \\\"hex\\\", 文本)```计算keccak256等摘要，可用于计算方法选择器、EIP-712摘要，参数与```Encode()```函数相同。\\n- 完整范例：通过聚合器兑换（询价、生成交易、用```exchange.IO(\\\"call\\\", ...)```预演、带```data```发送）见手册中```exchange.IO(\\\"call\\\", ...)```的范例；ERC-20 Permit签名并由合约验签见```exchange.IO(\\\"sign\\\", ...)```、```exchange.IO(\\\"signTypedData\\\", ...)```的范例。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdc = \\\"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\\\" // 以太坊主网 USDC\\n var spender = \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\" // 被授权的合约，这里以 Uniswap SwapRouter02 为例\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // 查余额：标准 ERC20 方法不需要注册 ABI\\n var eth = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\"), 18)\\n var usdcBalance = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", usdc, \\\"balanceOf\\\", wallet), usdc)\\n Log(\\\"ETH:\\\", eth, \\\"USDC:\\\", usdcBalance)\\n\\n // 读合约：当前授权额度\\n var allowance = exchange.IO(\\\"api\\\", usdc, \\\"allowance\\\", wallet, spender)\\n Log(\\\"当前授权:\\\", exchange.IO(\\\"fromUnits\\\", allowance, usdc))\\n\\n // 授权 100 USDC：先预演，再发送\\n var amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", usdc)\\n if (!exchange.IO(\\\"call\\\", usdc, \\\"approve\\\", spender, amount)) {\\n Log(\\\"预演失败:\\\", GetLastError())\\n return\\n }\\n var txHash = exchange.IO(\\\"api\\\", usdc, \\\"approve\\\", spender, amount)\\n Log(\\\"交易哈希:\\\", txHash)\\n\\n // 等待上链，最多 3 分钟\\n var receipt = exchange.IO(\\\"waitReceipt\\\", txHash, {timeout: 180000})\\n if (receipt && receipt.status == 1) {\\n Log(\\\"授权成功，区块:\\\", receipt.blockNumber)\\n } else if (receipt) {\\n Log(\\\"交易失败:\\\", receipt.revertReason)\\n } else {\\n // 未上链：可以用 speedUp 加价重发，或 cancelTx 取消\\n Log(\\\"超时未上链:\\\", GetLastError())\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"## 示例：查余额、授权并等待上链\\n\\n以以太坊主网的USDC为例。注意这段代码会发出真实交易、消耗gas。\"}], \"seeAlso\": [\"{@fun/Web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"以太坊（EVM）\"}, {\"_src_hash\": \"6cd095aba18e68729e7e7a725301488a2c15df8c318e32cf7ac94b634ee33d95\", \"desc\": \"Web3交易所对象选择```ChainType```为```TRON```时连接波场节点。用法与{@进阶专题/Web3/以太坊（EVM）以太坊（EVM）}基本一致：注册ABI、调用合约、编码解码、签名、切换私钥等```exchange.IO()```指令相同，地址使用波场格式（```T```开头），TRX数量的单位是sun（1 TRX = 1000000 sun）。本页说明配置和波场特有的部分。\\n\\n## 配置交易所对象\\n\\n| 字段 | 说明 |\\n| - | - |\\n| ChainType | 选择```TRON``` |\\n| Private Key | 钱包私钥（十六进制字符串）。支持把私钥本地化部署在托管者上，参看{@入门/密钥安全性密钥安全性} |\\n| Rpc Address | 波场全节点的HTTP地址，例如官方节点```https://api.trongrid.io```（测试网：```https://nile.trongrid.io```、```https://api.shasta.trongrid.io```） |\\n| Rpc Api Key | TronGrid的API Key，只填Key本身，会作为```TRON-PRO-API-KEY```请求头发送。不填也能使用，但TronGrid对没有Key的请求限频更严格 |\\n\\n托管者通过全节点的HTTP接口（```/wallet/...```）访问波场，不再使用gRPC。选择TRON时表单默认填入的旧gRPC地址```grpc.trongrid.io:50051```会自动换成```https://api.trongrid.io```（```grpc.nile.trongrid.io:50051```、```grpc.shasta.trongrid.io:50051```同样换成对应测试网的HTTP地址）；其它gRPC地址会报错，请改填节点的HTTP地址。\\n\\n运行中可以用```exchange.IO(\\\"base\\\", 节点地址)```切换节点，用```exchange.IO(\\\"key\\\", 私钥)```切换钱包，用```exchange.IO(\\\"address\\\")```获取当前钱包地址（```T```开头）。标准函数```exchange.GetAccount()```、```exchange.GetAssets()```返回钱包的TRX余额。账户还未激活（链上没有记录）时余额为0。\\n\\n## 调用智能合约\\n\\n与以太坊相同，使用```exchange.IO(\\\"api\\\", 合约地址, 方法, ...参数)```：只读方法直接返回结果，写方法签名并广播交易，返回交易ID。TRC20标准方法已内置；其它合约没有注册ABI时，会自动从链上读取该合约的ABI，读取不到时再用```exchange.IO(\\\"abi\\\", 合约地址, ABI)```手动注册。写方法的最后一个参数可以传```{gasLimit: 数量}```设置手续费上限（feeLimit，单位sun）。\\n\\n```js\\n// USDT（TRC20）合约\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nLog(exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))) // 链上整数，USDT精度为6\\n```\\n\\n编码解码与以太坊一致，地址参数可以直接写```T```开头的地址：\\n\\n```js\\nexchange.IO(\\\"encode\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"encodePacked\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"decode\\\", \\\"string\\\", \\\"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000a5465746865722055534400000000000000000000000000000000000000000000\\\")\\n// Tether USD\\n```\\n\\n## 调用波场节点的方法\\n\\n```exchange.IO(\\\"api\\\", \\\"tron\\\", 方法, ...参数)```调用波场节点的方法，方法名不区分大小写。需要签名的方法（转账、触发合约等）会自动签名并广播。常用方法：\\n\\n| 方法 | 参数 | 说明 |\\n| - | - | - |\\n| ```send``` | 收款地址, 数量(sun) | 从当前钱包转出TRX |\\n| ```Transfer``` | 付款地址, 收款地址, 数量(sun) | 转出TRX，付款地址必须是当前钱包 |\\n| ```GetAccount``` | 地址 | 账户信息 |\\n| ```GetAccountResource``` | 地址 | 账户的能量、带宽资源 |\\n| ```GetContractABI``` | 合约地址 | 合约在链上的ABI |\\n| ```GetAssetIssueByName``` | 名称 | TRC10资产信息 |\\n| ```GetNowBlock``` | 无 | 当前区块 |\\n| ```GetBlockByNum``` | 区块高度 | 指定区块 |\\n| ```GetTransactionByID``` | 交易ID | 交易内容 |\\n| ```GetTransactionInfoByID``` | 交易ID | 交易执行结果（手续费、能量消耗、日志等） |\\n| ```GetChainParameters``` | 无 | 链参数 |\\n| ```TriggerConstantContract``` | 调用者地址（可为空）, 合约地址, 方法, 参数编码 | 只读调用合约，结果在```constant_result```中（十六进制字符串，可以用```exchange.IO(\\\"decode\\\", ...)```解码） |\\n| ```TRC20ContractBalance``` | 地址, 合约地址 | TRC20余额（链上整数） |\\n| ```TRC20GetName```、```TRC20GetSymbol```、```TRC20GetDecimals``` | 合约地址 | TRC20的名称、符号、精度 |\\n| ```TRC20Send```、```TRC20Approve``` | 付款地址, 收款或被授权地址, 合约地址, 数量, feeLimit | TRC20转账、授权 |\\n| ```TRC20Call``` | 调用者地址（可为空）, 合约地址, 调用数据, 是否只读, feeLimit | 用原始调用数据调用合约 |\\n| ```ParseTRC20NumericProperty```、```ParseTRC20StringProperty``` | 十六进制数据 | 解析TRC20返回的数值、字符串 |\\n\\n表中没有的节点接口，可以直接传路径和请求体：```exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"/wallet/接口名\\\", {请求体})```。\\n\\n## 与以太坊的差异\\n\\n以下指令只支持以太坊（EVM），在波场上调用会报错：```call```、```multicall```、```logs```、```waitReceipt```、```nonce```、```speedUp```、```cancelTx```、```contracts```；```sendBase```和多个节点互为备用也只对以太坊有效。在波场上模拟执行合约调用可以用节点方法```TriggerConstantContract```，查询交易的执行结果用```GetTransactionInfoByID```。\\n\\n```toUnits```、```fromUnits```、```uniswapV3```、编码解码和签名指令在波场上同样可用，精度参数可以直接传TRC20合约地址：\\n\\n```js\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nvar raw = exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))\\nLog(exchange.IO(\\\"fromUnits\\\", raw, usdt)) // 按合约的 decimals() 换算为可读数量\\n```\\n\\n合约调用在节点校验阶段被拒绝时（例如合约不存在），错误信息中是节点给出的原因，例如```tron contract call rejected (CONTRACT_VALIDATE_ERROR): Smart contract is not exist.```；合约执行失败（revert）时报```tron contract execution failed```及失败原因。\\n\\n## 签名\\n\\n```exchange.IO(\\\"hash\\\", \\\"sign\\\", \\\"hex\\\", \\\"hex\\\", 交易哈希)```用当前私钥对32字节哈希签名，返回65字节签名```r‖s‖v```（v为0或1）；```hash```的其它算法（如```\\\"sha256\\\"```）用于计算摘要，功能与```Encode()```函数相同。需要分别取得r、s、v（v为27或28）用于合约校验时，使用```exchange.IO(\\\"sign\\\", ...)```，见语法手册{@fun/Web3 Web3}分类。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // TRX 余额（标准函数，单位 TRX）\\n Log(\\\"账户:\\\", exchange.GetAccount())\\n\\n // USDT 余额：链上整数，按精度换算\\n var raw = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20ContractBalance\\\", wallet, usdt)\\n var decimals = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20GetDecimals\\\", usdt)\\n Log(\\\"USDT:\\\", raw / Math.pow(10, decimals))\\n\\n // 用 TRC20Call 只读调用 name()（选择器 0x06fdde03），再解析返回的字符串\\n var ret = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20Call\\\", \\\"\\\", usdt, \\\"0x06fdde03\\\", true, 0)\\n // constant_result 中是十六进制字符串，直接解析\\n Log(\\\"名称:\\\", exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"ParseTRC20StringProperty\\\", ret.constant_result[0]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"## 示例\\n\\n### 查询TRX与USDT余额，读取代币信息\"}, {\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var multicall = \\\"TGXuuKAb4bnrn137u39EKbYzKNXvdCes98\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n var calls = [\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"name\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"decimals\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"balanceOf\\\", wallet)]\\n ]\\n // 注册 Multicall 合约的 aggregate 方法\\n exchange.IO(\\\"abi\\\", multicall, `[{\\\"inputs\\\":[{\\\"components\\\":[{\\\"internalType\\\":\\\"address\\\",\\\"name\\\":\\\"target\\\",\\\"type\\\":\\\"address\\\"},{\\\"internalType\\\":\\\"bytes\\\",\\\"name\\\":\\\"callData\\\",\\\"type\\\":\\\"bytes\\\"}],\\\"internalType\\\":\\\"struct TronMulticall.Call[]\\\",\\\"name\\\":\\\"calls\\\",\\\"type\\\":\\\"tuple[]\\\"}],\\\"name\\\":\\\"aggregate\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"blockNumber\\\",\\\"type\\\":\\\"uint256\\\"},{\\\"internalType\\\":\\\"bytes[]\\\",\\\"name\\\":\\\"returnData\\\",\\\"type\\\":\\\"bytes[]\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"}]`)\\n var ret = exchange.IO(\\\"api\\\", multicall, \\\"aggregate\\\", calls)\\n Log(\\\"name:\\\", exchange.IO(\\\"decode\\\", \\\"string\\\", ret.returnData[0]))\\n Log(\\\"decimals:\\\", exchange.IO(\\\"decode\\\", \\\"uint8\\\", ret.returnData[1]))\\n Log(\\\"balanceOf:\\\", exchange.IO(\\\"decode\\\", \\\"uint256\\\", ret.returnData[2]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"### 用Multicall合约一次读取多个合约方法\"}], \"seeAlso\": [\"{@fun/Web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"波场（TRON）\"}], \"desc\": \"在去中心化交易所Uniswap、PancakeSwap上兑换代币，请使用Uniswap交易所对象，见{@进阶专题/Web3/Uniswap与PancakeSwap Uniswap与PancakeSwap}；查询链上数据、调用智能合约、发送自定义交易，请使用Web3交易所对象，它支持以太坊等EVM兼容链和波场。\", \"title\": \"Web3\"}], \"desc\": \"进阶用法：JavaScript多线程、实盘之间通信、API限流、期权交易、Web3链上交易。\", \"title\": \"进阶专题\"}, {\"_src_hash\": \"ae6a45caba47ac9bfb485536fbb33bfd7de87522ee8daf0484881e23000abbe5\", \"children\": [{\"_src_hash\": \"88d3a2f4534fb85bb8d1530d77b6eb0b7e67c8123ff1df0ce89e1fbb64ef875a\", \"children\": [], \"desc\": \"发明者量化自研的**datadata**是一个量化金融数据平台，发明者量化交易平台的[数据探索](https://www.fmz.com/m/database)模块集成了它的服务和功能，发明者量化用户无需另外注册**datadata**账号即可使用。可以用SQL查询分析海量数据，通过可视化界面生成多种图表，并与团队分享。使用例子可以参考[数据探索模块专题文章](https://www.fmz.com/digest-topic/10370)。\\n\\n- 数据源：datadata提供的数据源实时、持续更新，涵盖多种类型的数据；也可以上传CSV文件作为私有数据源，并在「数据探索」页面预览。\\n- 数据查询：用SQL语句查询数据，支持查询参数；查询结果可以下载为CSV或JSON文件。\\n- 保存研究：点击右上角的「保存」，把当前SQL查询保存到账号「数据探索」的资源列表中（资源列表按钮在「保存」按钮左侧）。\\n- 数据图形化：查询结果除了以表格展示，还可以用多种可视化组件展示。\\n- 分享研究：支持公开链接、嵌入代码（例如嵌入平台社区帖子）、嵌入网页、数据链接、预览图链接等形式。用「数据链接」还可以把数据直接提供给策略使用，回测和实盘都支持。\", \"title\": \"数据探索\"}, {\"_src_hash\": \"271c559898f3b51287c2a05f4a6830095b7faceeaca95b86079a27822da939a5\", \"children\": [{\"_src_hash\": \"b17cbede810f9ad36a8b8f64fdba523f2b83ec26df197e8e730a78db4c6316d5\", \"desc\": \"**下面的```{}```代表占位符，所有表达式大小写不敏感，x代表数据时间序列**\\n\\n- ```abs(x), log(x), sign(x)```：分别是绝对值、对数、符号函数。\\n\\n以下操作符``` +, -, *, /, >, < ```也符合其标准的含义，```==```：是否相等，```||```：逻辑或，```x ? y : z```：三元条件运算符。\\n\\n- ```rank(x)``` ：横截面排序，返回所在的百分位。需要指定由多个标的组成的候选池；只有单个行情时无法排序，直接返回原值。\\n- ```delay(x, d)``` ：返回序列x在d个周期前的值。\\n- ```sma(x, d)``` ：计算序列x在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)``` ： ```x^a```。\\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\": \"7902b30b4eaee9530605218d9234abfc242873ba9f689f1ef6fbf4c4682a8796\", \"desc\": \"**输入数据不区分大小写，默认数据为网页上选择的品种，也可直接指定，例如：```binance.ada_bnb```**\\n\\n- ```returns```：收盘价收益率。\\n- ```open, close, high, low, volume```：周期内的开盘价、收盘价、最高价、最低价和成交量。\\n- ```vwap```：成交量加权平均价（暂未实现，当前使用收盘价）。\\n- ```cap```：总市值（暂未实现）。\\n- ```IndClass```：行业分类（暂未实现）。\", \"title\": \"输入数据\"}, {\"_src_hash\": \"76cdb1a745792cdda13efae175370f1396392dbb4d3161a9ec2b543bfe971042\", \"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.fmz.com/m/alpha)。\", \"title\": \"Alpha因子分析工具\"}], \"desc\": \"数据探索和Alpha因子分析工具。\", \"title\": \"数据与研究\"}, {\"_src_hash\": \"25985b8b13357cb7a743297539ba3e0c224a70a176936d7b504772a7b3cca85b\", \"children\": [{\"_src_hash\": \"44bbaf44a152677d136222a7ccd12c89e42ef3aed3f36629b5fb89df4ce4c8bf\", \"desc\": [\"把发明者量化接入Claude Code、Codex、Cursor等AI编程助手（AI agent）后，可以直接用对话完成写策略、回测、创建和管理实盘、查看日志与收益。AI助手通过平台提供的MCP（Model Context Protocol）服务调用这些功能，用的是一把专门为它创建的API KEY，权限由你在授权时决定，随时可以修改或吊销。\\n\\n**一句话接入**\\n\\n在AI助手里输入：\\n\\n```\\n读 https://www.fmz.com/agent/setup.zh-CN.md 然后接入发明者量化\\n```\\n\\nAI助手会按这份说明完成以下步骤，你只需要在浏览器里点一次同意：\\n\\n1. AI助手向平台申请授权，然后给出一个授权链接（形如```https://www.fmz.com/agent/authorize?code=XXXX-XXXX```），链接10分钟内有效。\\n2. 在已登录发明者量化的浏览器中打开链接，确认申请者名称和权限后点击同意。可以在页面上取消勾选不想给的权限。\\n3. AI助手取得API KEY，写入自己的MCP配置并连接。之后就可以直接对它说「列出我的实盘」「给这个策略跑一次回测」。\\n\\n申请时AI助手会用「名字 @ 机器名」（例如```Claude Code @ MacBook```）作为这把API KEY的名称。同一个名称再次申请并同意时，旧的API KEY会被吊销、换成新的，重复接入不会累积多余的API KEY。\\n\\n**权限**\\n\\n| 权限 | 允许的操作 | 默认 |\\n| - | - | - |\\n| read | 查看策略、实盘、托管者、交易所账户列表与详情，读取日志、消息、账户概览（不含任何密钥） | 是 |\\n| backtest | 发起、查询、停止回测 | 是 |\\n| write | 保存策略与版本、分组、告警开关，修改已停止实盘的配置 | 是 |\\n| trade | 创建、启动、停止实盘，给实盘发送交互命令（会扣费并真实下单） | 是 |\\n| danger | 删除策略、实盘、托管者，公开策略 | 否 |\\n\\n```danger```权限默认不授予，只有AI助手明确申请、并在授权页面勾选时才会获得。AI助手调用```[trade]```或```[danger]```类工具前，应当先向你确认。\\n\\n**手动配置**\\n\\n不能执行命令的客户端（例如Cherry Studio）可以手动配置：\\n\\n1. 在「账号设置 → API KEY」（```https://www.fmz.com/m/account#apikey```）创建API KEY，记下Access Key和Secret Key。\\n2. 在客户端添加一个MCP服务，类型选Streamable HTTP：\\n - URL：```https://www.fmz.com/api/mcp/```\\n - 请求头：```Authorization: Bearer ```\\n\\nSecret Key只能放在请求头里，不能写进URL。各客户端的配置示例：\\n\\n```bash\\n# Claude Code\\nclaude mcp add --transport http fmz \\\"https://www.fmz.com/api/mcp/\\\" --header \\\"Authorization: Bearer \\\"\\n```\\n\\n```json\\n{\\\"mcpServers\\\": {\\\"fmz\\\": {\\\"url\\\": \\\"https://www.fmz.com/api/mcp/\\\", \\\"headers\\\": {\\\"Authorization\\\": \\\"Bearer \\\"}}}}\\n```\\n\\n上面的JSON用于Cursor（```~/.cursor/mcp.json```）等支持Streamable HTTP的客户端；Claude Desktop需要通过```npx mcp-remote```转接，见接入说明原文。\\n\\n**安装skills（推荐）**\\n\\nskills是给AI助手阅读的平台知识包：平台操作流程、完整的API文档、各编程语言的策略写法、回测和指标。装上之后AI助手写出的策略更准确。在终端执行：\\n\\n```bash\\nnpx skills add fmzquant/skills --global --yes -a claude-code\\n```\\n\\n```-a```后面填你使用的AI助手名称（claude-code、codex、cursor、gemini-cli等）。也可以直接在GitHub阅读：```https://github.com/fmzquant/skills```。\\n\\n**可用的工具**\\n\\n连接后AI助手可以使用以下工具，完整说明以AI助手看到的工具列表为准：\\n\\n| 权限 | 工具 |\\n| - | - |\\n| read | ```ping```、```get_account_summary```、```list_exchanges```、```list_platforms```、```list_nodes```、```list_strategies```、```get_strategy```、```list_strategy_versions```、```get_strategy_version```、```list_robots```、```get_robot```、```get_robot_logs```、```get_robot_profit```、```get_robot_output```、```list_messages```、```list_groups```、```revoke_my_key``` |\\n| backtest | ```run_backtest```、```get_backtest```、```list_backtests```、```stop_backtest``` |\\n| write | ```check_strategy```、```save_strategy```、```save_strategy_version```、```delete_strategy_version```、```update_robot```、```save_group```、```move_to_group```、```delete_group```、```set_robot_alert```、```set_node_alert```、```delete_messages``` |\\n| trade | ```create_robot```、```start_robot```、```stop_robot```、```restart_robot```、```send_robot_command```，以及交易终端插件工具```plugin_*```（查询行情、下单等） |\\n| danger | ```delete_strategy```、```delete_robot```、```delete_node```、```publish_strategy``` |\\n\\n一个典型的流程：```list_platforms```和```list_nodes```了解账户里有哪些交易所账户和托管者；```save_strategy```保存策略并用```check_strategy```检查语法；```run_backtest```和```get_backtest```回测；确认后```create_robot```创建实盘，再用```get_robot```、```get_robot_logs```观察运行情况。\\n\\n**安全与管理**\\n\\n- 交易所的API KEY不经过AI助手：在网页的「交易所」页面添加，AI助手按编号选择。所有工具的返回结果里都不包含任何密钥。\\n- 在```https://www.fmz.com/m/account#apikey```可以查看AI助手使用的API KEY，修改权限或锁定。权限除了填写上表的权限名，还可以填工具名，用```!工具名```排除某个工具。\\n- 不再使用时，让AI助手调用```revoke_my_key```吊销它自己的API KEY，或在上面的页面中删除。\\n- ```stop_robot```只停止实盘，不会平仓。\\n- 第一次让AI助手创建实盘时，建议先回测，再用模拟盘或小额资金运行。\\n\\n**常见问题**\\n\\n- 提示没有在线托管者：创建实盘需要至少一个在线的托管者，见「平台基础 → 托管者」。\\n- 提示回测任务过多：同时运行的回测数量有上限，让AI助手先用```stop_backtest```停止不再需要的回测。\\n- AI助手说没有某个工具，或者调用被拒绝：这把API KEY没有对应的权限，在API KEY页面修改权限后重新连接。\\n\\n同一把API KEY也可以用于{@对外接口/扩展API接口扩展API接口}，供脚本和定时任务调用；能用MCP的场景优先使用MCP。\"], \"title\": \"AI接入\"}, {\"_src_hash\": \"7b98581f7d584be00f92709c0a12498873ea8a9e010b4a4be75e8278892329f8\", \"children\": [{\"_src_hash\": \"a60b8073afc9f92edf83fa06079aa9db6732d90c30f20c92aeceaa5d0e681213\", \"desc\": \"在[账号设置 → API KEY](https://www.fmz.com/m/account#apikey)页面（```/m/account#apikey```）点击「创建新的ApiKey」，得到一对```AccessKey```和```SecretKey```。```SecretKey```代表这把API KEY的全部权限，不要泄露。在该页面也可以修改已有API KEY的权限，或者禁用、删除API KEY。\\n\\n**权限**\\n\\n创建或修改时，在「API权限」输入框中填写逗号分隔的列表：\\n\\n- ```*```：允许全部扩展API接口。\\n- 方法名：只允许列出的方法，例如```GetRobotList,GetRobotDetail,CommandRobot```。\\n- ```!方法名```：排除某个方法，通常与```*```搭配，例如```*,!DeleteRobot,!DeleteNode```。\\n\\n同一把API KEY也可以用于{@对外接口/AI接入 AI接入}（MCP服务）。MCP工具除了按工具名授权，还可以按权限类别授权：```read```、```backtest```、```write```、```trade```、```danger```（含义见AI接入页面），同样支持用```!名称```排除。权限类别只对MCP工具生效；扩展API接口只认方法名和```*```。\\n\\n权限留空时，扩展API接口不限制方法（MCP开放```danger```以外的全部工具）。建议按用途只授予需要的方法，例如只用于TradingView警报的API KEY只授予```CommandRobot```。\", \"title\": \"创建ApiKey\"}, {\"_src_hash\": \"520115011d27c776aec3d0054c7a87174b0f21dfb3268ddf13fc2a773d477e66\", \"children\": [{\"_src_hash\": \"6a0c76c5c68177c8eb1766896135016fe3478b9b29b9876f8f76562b0fe4b261\", \"desc\": \"**请求格式**\\n\\n向```https://www.fmz.com/api/v1```发送```POST```请求，参数以表单（```application/x-www-form-urlencoded```）提交。服务端也接受把同样的参数放在URL查询串中的```GET```请求，但参数会留在各处的访问日志里，推荐使用```POST```。\\n\\n| 参数 | 说明 |\\n| - | - |\\n| version | 版本号，固定为```1.0```。 |\\n| access_key | API KEY的```AccessKey```。 |\\n| method | 调用的方法名，例如```GetNodeList```。 |\\n| args | 方法参数组成的JSON字符串：按顺序排列的数组（如```[]```、```[123, \\\"ok\\\"]```），或按参数名传值的对象（如```{\\\"robotId\\\": 123}```），见{@对外接口/扩展API接口/扩展API接口详解扩展API接口详解}。不传时按```[]```处理。 |\\n| nonce | 毫秒时间戳。与服务器时间相差不能超过1小时，并且必须大于这把API KEY上一次请求使用的```nonce```。 |\\n| sign | 签名，计算方法见下文。 |\\n\\n请求中不包含```SecretKey```。\\n\\n**签名方式**\\n\\n按下面的格式拼接字符串，其中```args```是实际提交的JSON字符串原文：\\n\\n```plaintext\\nversion + \\\"|\\\" + method + \\\"|\\\" + args + \\\"|\\\" + nonce + \\\"|\\\" + secretKey\\n```\\n\\n对拼接结果计算MD5，转换为32位小写十六进制字符串，作为```sign```的值。\\n\\n**Python示例**\\n\\n```python\\nimport hashlib\\nimport json\\nimport time\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # API KEY 的 AccessKey\\nSECRET_KEY = '' # API KEY 的 SecretKey\\n\\ndef api(method, *args, **kwargs):\\n d = {\\n 'version': '1.0',\\n 'access_key': ACCESS_KEY,\\n 'method': method,\\n # 位置参数传数组，关键字参数传对象（按参数名传值）\\n 'args': json.dumps(kwargs if kwargs else list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n s = '%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], SECRET_KEY)\\n d['sign'] = hashlib.md5(s.encode('utf-8')).hexdigest()\\n body = urllib.parse.urlencode(d).encode('utf-8')\\n with urllib.request.urlopen('https://www.fmz.com/api/v1', body, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\nprint(api('GetNodeList')) # 托管者列表\\nprint(api('GetRobotList', appId='member2')) # 按参数名传值：标签为 member2 的实盘\\nprint(api('CommandRobot', 123, 'ok')) # 向实盘 123 发送交互命令\\nprint(api('GetRobotDetail', 123)) # 实盘 123 的详细信息\\n```\\n\\n**Go示例**\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"crypto/md5\\\"\\n \\\"encoding/hex\\\"\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"strconv\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // API KEY 的 AccessKey\\n secretKey = \\\"\\\" // API KEY 的 SecretKey\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n nonce := strconv.FormatInt(time.Now().UnixMilli(), 10)\\n sum := md5.Sum([]byte(\\\"1.0|\\\" + method + \\\"|\\\" + string(b) + \\\"|\\\" + nonce + \\\"|\\\" + secretKey))\\n form := url.Values{\\n \\\"version\\\": {\\\"1.0\\\"},\\n \\\"access_key\\\": {accessKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n \\\"nonce\\\": {nonce},\\n \\\"sign\\\": {hex.EncodeToString(sum[:])},\\n }\\n resp, err := client.PostForm(baseAPI, form)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"GetNodeList\\\")\\n fmt.Println(ret, err)\\n\\n // 用新的配置重启实盘 123，settings 字段见「扩展API接口详解」中的实盘配置说明\\n settings := map[string]interface{}{\\n \\\"name\\\": \\\"hedge test\\\",\\n \\\"strategy\\\": 456,\\n \\\"period\\\": 60,\\n \\\"node\\\": 789,\\n \\\"exchanges\\\": []interface{}{\\n map[string]interface{}{\\\"pid\\\": 1001, \\\"pair\\\": \\\"BTC_USDT\\\"},\\n },\\n }\\n ret, err = api(\\\"RestartRobot\\\", 123, settings)\\n fmt.Println(ret, err)\\n}\\n```\", \"title\": \"签名验证\"}, {\"_src_hash\": \"84cd9b454df8d97a65aa0199e8e8427cedb19b83266b01ddd6a48d985e769b72\", \"desc\": \"直接验证不计算签名，而是把```secret_key```直接放在请求参数中，因此可以生成一个固定的URL，填到TradingView等只能设置一个URL的Webhook回调里。\\n\\n> **安全提示**：```secret_key```写在URL中，会留在浏览器历史、代理和服务器的访问日志、Webhook服务方的配置里，任何拿到这个URL的人都能以这把API KEY的权限调用接口。建议只在```CommandRobot```的Webhook中使用直接验证，并为它单独创建一把只授权```CommandRobot```的API KEY（见{@对外接口/扩展API接口/创建ApiKey 创建ApiKey}）；一旦泄露，立即删除这把API KEY。\\n\\n请求参数为```access_key```、```secret_key```、```method```、```args```（JSON数组，需要URL编码），不需要```version```、```nonce```、```sign```。```CommandRobot```不做```nonce```校验；其他方法仍会校验：不传```nonce```时服务器以当前时间（精确到秒）代替，同一秒内的第二次调用会返回Nonce错误（```code```为3）。\\n\\n例如API KEY的```AccessKey```为```xxx```、```SecretKey```为```yyy```，访问下面的URL即可向Id为```186515```的实盘发送交互命令```ok12345```：\\n\\n```plaintext\\nhttps://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C%22ok12345%22%5D\\n```\\n\\n**接收Webhook请求体**\\n\\n```CommandRobot```的命令参数为空字符串、请求为```POST```时，服务器把请求体（Body）作为交互命令发给实盘。例如在TradingView的Webhook URL中设置：\\n\\n```plaintext\\nhttps://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\n```\\n\\n其中```args```的值```%5B186515%2C+%22%22%5D```解码后为```[186515, \\\"\\\"]```（```+```是URL编码中的空格），```186515```是实盘Id，命令为空字符串。\\n\\n模拟TradingView发送Webhook警报：\\n\\n```js\\nfunction main() {\\n var options = {\\n method: \\\"POST\\\",\\n body: `{\\\"test\\\": 123}`,\\n headers: {\\\"Content-Type\\\": \\\"application/json\\\"}\\n }\\n\\n // Webhook 警报会自动发送 POST 请求，并带上需要的 headers\\n return HttpQuery(\\\"https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\", options)\\n}\\n```\\n\\nTradingView警报消息框中的内容就是请求体：\\n\\n- JSON格式：\\n\\n ![](https://www.fmz.com/upload/asset/16d8a37ef80d9ccd0079.png)\\n\\n ```plaintext\\n {\\\"close\\\": {{close}}, \\\"name\\\": \\\"aaa\\\"}\\n ```\\n\\n Id为```186515```的实盘收到交互命令：```{\\\"close\\\": 39773.75, \\\"name\\\": \\\"aaa\\\"}```。\\n\\n- 文本格式：\\n\\n ![](https://www.fmz.com/upload/asset/16d8a506dfbb6c60a077.png)\\n\\n ```plaintext\\n BTCUSDTPERP 穿过(Crossing) 39700.00 close: {{close}}\\n ```\\n\\n Id为```186515```的实盘收到交互命令：```BTCUSDTPERP 穿过(Crossing) 39700.00 close: 39739.4```。\\n\\n**Python、Go示例**\\n\\n```python\\nimport json\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # 只授权了 CommandRobot 的 API KEY 的 AccessKey\\nSECRET_KEY = '' # SecretKey\\n\\ndef api(method, *args):\\n query = urllib.parse.urlencode({\\n 'access_key': ACCESS_KEY,\\n 'secret_key': SECRET_KEY,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n })\\n with urllib.request.urlopen('https://www.fmz.com/api/v1?' + query, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\n# API KEY 没有该方法的权限时返回 {'code': 4, 'data': None}\\nprint(api('CommandRobot', 186515, 'ok12345'))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // 只授权了 CommandRobot 的 API KEY 的 AccessKey\\n secretKey = \\\"\\\" // SecretKey\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n q := url.Values{\\n \\\"access_key\\\": {accessKey},\\n \\\"secret_key\\\": {secretKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n }\\n resp, err := client.Get(baseAPI + \\\"?\\\" + q.Encode())\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"CommandRobot\\\", 186515, \\\"ok12345\\\")\\n fmt.Println(ret, err)\\n}\\n```\\n\\n参考：\\n\\n- [使用发明者量化交易平台扩展API实现TradingView报警信号交易](https://www.fmz.com/digest-topic/5533)\\n- [使用发明者量化交易平台扩展API实现TradingView报警信号交易（B站视频）](https://www.bilibili.com/video/BV1Wk4y1k7zz/)\", \"title\": \"直接验证\"}], \"desc\": \"调用扩展API接口时有两种验证方式：\\n\\n- {@对外接口/扩展API接口/验证方式/签名验证签名验证}：用```SecretKey```对请求参数签名，```SecretKey```本身不在网络上传输。程序调用应使用这种方式。\\n- {@对外接口/扩展API接口/验证方式/直接验证直接验证}：把```SecretKey```直接放进请求URL，主要用于TradingView等只能填写一个URL的Webhook场景。\", \"title\": \"验证方式\"}, {\"_src_hash\": \"3ff6c0aa1984e827377c05bae8c74acca74925bfbac0b8efb7c853f68fea3f4d\", \"children\": [{\"_src_hash\": \"f939c7a3be2d90843ede06cfcb0b50b30e9a1491eab08b2930a3605c1834d73e\", \"args\": \"无参数\", \"desc\": [\"```GetAccount```方法用于获取请求中的```API KEY```对应的发明者量化交易平台账号的账户信息。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":{\\n \\\"balance\\\":22944702436,\\n \\\"concurrent\\\":0,\\n \\\"consumed\\\":211092719653,\\n \\\"email\\\":\\\"123@qq.com\\\",\\n \\\"openai\\\":false,\\n \\\"settings\\\":null,\\n \\\"sns\\\":{\\\"wechat\\\":true},\\n \\\"uid\\\":\\\"105ea6e51bcc177926a10fdbb7e2a1d6\\\",\\n \\\"username\\\":\\\"abc\\\"\\n },\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- balance: 账户余额，单位为USD。为了控制精度使用整数表示，除以1e8（10的8次方）得到实际数值，示例中为229.44702436。\\n- consumed: 累计消费金额，单位与换算方式同```balance```。\", \"title\": \"GetAccount\"}, {\"_src_hash\": \"33a31d2618fcd4073d0e3c4349ddc3669c6adc3213577b5f845d65d3241611d2\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；不传或小于等于0时返回全部。\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"```GetNodeList```方法用于获取请求中的```API KEY```对应的平台账号可以使用的托管者列表，包括自己的托管者和平台的公共托管者。\"], \"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-11-08 09:21:08\\\",\\n \\\"date\\\": \\\"2024-11-08 16:37:16\\\",\\n \\\"forward\\\": \\\"...\\\",\\n \\\"guid\\\": \\\"...\\\",\\n \\\"host\\\": \\\"node.fmz.com:9902\\\",\\n \\\"id\\\": 123,\\n \\\"ip\\\": \\\"...\\\",\\n \\\"is_owner\\\": true,\\n \\\"loaded\\\": 0,\\n \\\"name\\\": \\\"MacBook-Pro-2.local\\\",\\n \\\"online\\\": true,\\n \\\"os\\\": \\\"darwin/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\\n一键部署的托管者包含一些额外信息，字段以```ecs_```、```unit_```前缀开头，记录了一键部署托管者服务器的相关信息（运营商名称、配置、状态等），计费周期、价格等信息，不再赘述。\", \"title\": \"GetNodeList\"}, {\"_src_hash\": \"a9522683b8b1a443e9b97a143b75d779f38df4e276e8dc3f26dea4fe33d03ba4\", \"args\": [{\"info\": \"```nid```参数用于指定要删除的托管者ID，可通过```GetNodeList```方法获取账号下托管者的信息。\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```DeleteNode```方法用于删除请求中```API KEY```对应的发明者量化交易平台账号下的托管者节点，删除的托管者节点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\": \"1821f76d0e6eb3e34ea30081406e309834e8db827691a1b21380d46998c368f5\", \"args\": [{\"info\": \"```isSummary```参数用于指定返回的数据是否为摘要信息。\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"```GetExchangeList```方法用于获取FMZ量化交易平台支持的交易所列表及其配置信息。\"], \"isChildren\": true, \"returns\": \"```isSummary```参数为```false```时，返回的数据：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"meta\\\": \\\"[{\\\\\\\"desc\\\\\\\": \\\\\\\"Access Key\\\\\\\", \\\\\\\"qr\\\\\\\":\\\\\\\"apiKey\\\\\\\",\\\\\\\"required\\\\\\\": true, \\\\\\\"type\\\\\\\": \\\\\\\"string\\\\\\\", \\\\\\\"name\\\\\\\": \\\\\\\"AccessKey\\\\\\\", \\\\\\\"label\\\\\\\": \\\\\\\"Access Key\\\\\\\"}, {\\\\\\\"encrypt\\\\\\\": true, \\\\\\\"qr\\\\\\\":\\\\\\\"secretKey\\\\\\\",\\\\\\\"name\\\\\\\": \\\\\\\"SecretKey\\\\\\\", \\\\\\\"required\\\\\\\": true, \\\\\\\"label\\\\\\\": \\\\\\\"Secret Key\\\\\\\", \\\\\\\"type\\\\\\\": \\\\\\\"password\\\\\\\", \\\\\\\"desc\\\\\\\": \\\\\\\"Secret Key\\\\\\\"}]\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"stocks\\\": \\\"BTC_USDT,ETH_USDT,ETH_USD\\\",\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\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\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- meta: 交易所配置元数据。\", \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"0cc6ccb96239c72e3190299428381150cc8d0dbac7ec9faea0baa31fde2fb114\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；不传或小于等于0时返回全部。\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"```GetPlatformList```方法用于获取请求中的```API KEY```对应的发明者量化交易平台账号下的已添加的交易所列表。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 2,\\n \\\"platforms\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"date\\\": \\\"2023-12-07 13:44:52\\\",\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"币安\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"币安现货|Binance\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"LTC_USDT\\\", \\\"ETH_USDT\\\", \\\"ETC_USDT\\\", \\\"BTC_TUSD\\\", \\\"ETH_TUSD\\\", \\\"BNB_TUSD\\\"],\\n \\\"website\\\": \\\"...\\\"\\n }, {\\n \\\"category\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"date\\\": \\\"2020-11-09 11:23:48\\\",\\n \\\"eid\\\": \\\"Exchange\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"XX交易所REST协议\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\"],\\n \\\"website\\\": \\\"\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: 已添加/配置的交易所对象个数。\\n- platforms: 交易所相关信息。\\n - eid: 在发明者量化交易平台上交易所的Id，一些配置、参数中会使用到```eid```。\", \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"4fc22681ff55b9e970c2bdb8d88723673b77d955dba8bfd5c9f83873eb15fd4a\", \"args\": [{\"info\": \"分页偏移。\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"每页数量；小于等于0时返回全部。\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询范围：\\n- ```-1```：自己的策略和租用的策略（含官方策略）。\\n- ```0```：自己的策略和租用的策略（不含官方策略）。\\n- ```-3```：只查自己的策略。\\n- ```-6```：只查租用的策略（含已过期的）。\\n- ```-4```：官方策略。\\n- ```-2```：策略广场中公开的策略和付费策略。\\n- ```1```：已公开的策略。\\n- ```2```：待审核的策略。\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略类型：\\n- ```-1```：全部。\\n- ```0```：普通策略。\\n- ```20```：模板类库。\\n- ```21```：交易插件。\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略的编程语言：\\n- ```-1```：全部语言。\\n- ```0```：JavaScript（TypeScript策略也按JavaScript保存，源码中带```//@ts-check```）。\\n- ```1```：Python。\\n- ```3```：Blockly可视化。\\n- ```4```：My语言。\\n- ```5```：PINE语言。\\n- ```6```：Workflow工作流。\\n- ```7```：Rust。\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"按策略名称模糊匹配的关键字，多个词用空格分隔；空字符串表示不筛选。以```id:```开头时按策略Id查询，例如```id:123,456```。\", \"name\": \"kw\", \"required\": true, \"type\": \"string\"}, {\"info\": \"策略分组：```-1```全部（默认），```0```未分组，大于0为指定分组。只对自己的策略生效。\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"排序字段：```name```、```last_modified```、```date```，可在后面加``` asc```表示升序（默认降序）；空字符串为默认排序。\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"```GetStrategyList```方法用于获取平台策略信息。\"], \"isChildren\": true, \"remarks\": [\"参数中没有```needArgs```。按旧版文档在```category```之后多传一个参数，会使后面的参数错位，请按上面的顺序传参，或按参数名传值：\\n\\n```plaintext\\napi('GetStrategyList', 0, 10, -3, -1, -1, '') # 自己的前10个策略\\napi('GetStrategyList', strategyType=-3, language=7) # 自己的全部Rust策略\\n```\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 123,\\n \\\"strategies\\\": [{\\n \\\"category\\\": 9,\\n \\\"date\\\": \\\"2024-11-10 20:40:04\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"forked\\\": 0,\\n \\\"hits\\\": 0,\\n \\\"id\\\": 123,\\n \\\"is_buy\\\": false,\\n \\\"is_owner\\\": false,\\n \\\"language\\\": 0,\\n \\\"last_modified\\\": \\\"2024-11-11 17:23:52\\\",\\n \\\"name\\\": \\\"HedgeGridStrategy\\\",\\n \\\"profile\\\": {\\n \\\"avatar\\\": \\\"...\\\",\\n \\\"nickname\\\": \\\"abc\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\"\\n },\\n \\\"public\\\": 0,\\n \\\"tags\\\": \\\"\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\",\\n \\\"username\\\": \\\"abc\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: 筛选查询出的策略总数。\\n- strategies: 查询出的具体策略信息，其中```category```、```language```的取值同上面的参数说明。\", \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"6c47ca726b1a25f4333a0f737017fde3c1e8a8c1d62e7f275aa14cb711ead40a\", \"args\": \"无参数\", \"desc\": [\"```GetRobotGroupList```方法用于获取请求中的```API KEY```对应的发明者量化交易平台账号下的实盘分组列表。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"items\\\": [{\\n \\\"id\\\": 3417,\\n \\\"name\\\": \\\"测试\\\"\\n }, {\\n \\\"id\\\": 3608,\\n \\\"name\\\": \\\"实盘演示\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- items: 实盘分组信息。\\n - id: 实盘分组Id。\\n - name: 实盘分组名称。\\n\\n```items```字段只记录创建的新分组，「默认」分组不在```items```中。\", \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"639225639d69f048b7f867490748f40aeec47381f744f9141104d112508504a9\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；小于等于0时返回全部（默认）。\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"按实盘状态码筛选，见{@对外接口/扩展API接口/实盘状态码实盘状态码}；```-1```为全部实盘（默认），```-2```为全部实盘并按启动时间排序。\", \"name\": \"customStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"按实盘的自定义标签（创建时```settings```中的```appid```）筛选，空字符串表示不筛选。\", \"name\": \"appId\", \"required\": false, \"type\": \"string\"}, {\"info\": \"按实盘名称模糊匹配的关键字，空字符串表示不筛选。\", \"name\": \"kw\", \"required\": false, \"type\": \"string\"}, {\"info\": \"实盘分组：```-1```全部（默认），```0```未分组，大于0为指定分组。\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"排序字段：```name```、```status```、```node```、```profit```、```date```、```refresh```、```start_time```、```strategy_name```，可在后面加``` asc```表示升序（默认降序）；空字符串为默认排序。\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}, {\"info\": \"大于0时只返回该策略的实盘，默认为0（不筛选）。\", \"name\": \"strategyId\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"```GetRobotList```方法用于获取请求中的```API KEY```对应的平台账号下的实盘列表。参数都可以省略。\"], \"isChildren\": true, \"remarks\": [\"以签名验证页面Python示例中的```api()```为例：\\n\\n- ```api('GetRobotList')```：获取全部实盘。\\n- ```api('GetRobotList', 'member2')```：只传一个字符串时视为标签，获取标签为member2的全部实盘。\\n- ```api('GetRobotList', 0, 100, -1, 'member2', '')```：按位置传参，从第0条开始最多获取100个标签为member2的实盘。\\n- ```api('GetRobotList', appId='member2', length=100)```：按参数名传值，效果同上。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"concurrent\\\": 0,\\n \\\"robots\\\": [{\\n \\\"charge_time\\\": 1731654846,\\n \\\"date\\\": \\\"2024-11-12 14:05:29\\\",\\n \\\"end_time\\\": \\\"2024-11-15 14:56:32\\\",\\n \\\"fixed_id\\\": 4509153,\\n \\\"id\\\": 591026,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_guid\\\": \\\"45891bcf3d57f99b08a43dff76ee1ea1\\\",\\n \\\"node_id\\\": 4519153,\\n \\\"node_public\\\": 0,\\n \\\"profit\\\": 0,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1731651257000,\\n \\\"start_time\\\": \\\"2024-11-15 14:56:30\\\",\\n \\\"status\\\": 3,\\n \\\"strategy_id\\\": 411670,\\n \\\"strategy_isowner\\\": true,\\n \\\"strategy_language\\\": 0,\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": 0,\\n \\\"uid\\\": \\\"105ed6e511cc977921610fdbb7e2a1d6\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: 符合条件的实盘总数。\\n- robots: 实盘信息，```status```为实盘状态码。\\n - group_id: 实盘分组Id；如果策略实盘在默认分组中则没有```group_id```字段。\", \"title\": \"GetRobotList\"}, {\"_src_hash\": \"09cd05a7fbc0674f6150c259bfc21b2c0dcfa8113d66d796f3aab56693fe754a\", \"args\": [{\"info\": \"```robotId```参数用于指定所要获取详细信息的实盘Id，可以用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```GetRobotDetail```方法用于获取请求中的```API KEY```对应的发明者量化交易平台账号下的实盘详细信息，所要被获取详细信息的实盘Id为```robotId```参数指定的实盘Id。\"], \"isChildren\": true, \"remarks\": [\"```strategy_exchange_pairs```属性说明，用以下数据为例：\\n\\n```plaintext\\n\\\"[60,[44314,42960,15445,14703],[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]]\\\"\\n```\\n\\n其中第一个数据```60```，代表实盘设置的默认K线周期为1分钟，即60秒。\\n\\n```[44314,42960,15445,14703]```为实盘配置的交易所对象的```pid```（按添加顺序）。\\n\\n```[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]```为实盘配置的交易所对象设置的交易对（按添加顺序与pid一一对应）。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"robot\\\": {\\n \\\"charge_time\\\": 1732246539,\\n \\\"charged\\\": 5850000,\\n \\\"consumed\\\": 5375000000,\\n \\\"date\\\": \\\"2018-12-28 14:34:51\\\",\\n \\\"favorite\\\": {\\n \\\"added\\\": false,\\n \\\"type\\\": \\\"R\\\"\\n },\\n \\\"fixed_id\\\": 123,\\n \\\"hits\\\": 1,\\n \\\"id\\\": 123,\\n \\\"is_deleted\\\": 0,\\n \\\"is_manager\\\": true,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_id\\\": 123,\\n \\\"pexchanges\\\": {\\n \\\"123\\\": \\\"Futures_OKX\\\"\\n },\\n \\\"phash\\\": {\\n \\\"123\\\": \\\"ca1aca74b9cf7d8624f2af2dac01e36d\\\"\\n },\\n \\\"plabels\\\": {\\n \\\"123\\\": \\\"OKX期货\\\"\\n },\\n \\\"priority\\\": 0,\\n \\\"profit\\\": 0,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1732244453000,\\n \\\"robot_args\\\": \\\"[]\\\",\\n \\\"start_time\\\": \\\"2024-11-22 11:00:48\\\",\\n \\\"status\\\": 1,\\n \\\"strategy_args\\\": \\\"[]\\\",\\n \\\"strategy_exchange_pairs\\\": \\\"[60,[123],[\\\\\\\"ETH_USDT\\\\\\\"]]\\\",\\n \\\"strategy_id\\\": 123,\\n \\\"strategy_last_modified\\\": \\\"2024-11-21 16:49:25\\\",\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": \\\"0\\\",\\n \\\"uid\\\": \\\"105ed6e51bcc17792a610fdbb7e2a1d6\\\",\\n \\\"username\\\": \\\"abc\\\",\\n \\\"wd\\\": 0\\n }\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- charge_time: 下次扣费时间（Unix时间戳，秒），即当前已付费时段的截止时间。\\n- charged: 累计计费时长，单位为秒。\\n- consumed: 累计扣费金额，单位为USD，按1e8放大为整数，示例中5375000000即53.75 USD。\\n- date: 创建日期。\\n- fixed_id: 实盘运行时指派的托管者ID，如果是自动，该值为-1。\\n- is_manager: 是否有权限管理该实盘。\\n- is_sandbox: 是否是模拟盘。\\n- name: 实盘名称。\\n- node_id: 托管者ID。\\n- pexchanges: 实盘配置的交易所对象，123为pid，\\\"Futures_OKX\\\"为交易所Id（eid）。\\n- plabels: 实盘配置的交易所对象的标签信息。\\n- profit: 实盘收益数据。\\n- public: 实盘是否公开。\\n- refresh: 最近活跃时间。\\n- strategy_exchange_pairs: 配置的交易所对象，设置的交易对信息。\\n- wd: 是否开启离线报警。\", \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"2ab8cb45f46e27f899017babd236368395a8e47d1a1653f1129cb7c54f71ce79\", \"args\": [{\"info\": \"```robotId```参数用于指定所要获取日志信息的实盘Id，可以用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logMinId```参数用于指定Log日志的最小Id。\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logMaxId```参数用于指定Log日志的最大Id。\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logOffset```参数用于设置偏移，由```logMinId```和```logMaxId```确定范围后，根据```logOffset```偏移（跳过多少条记录），开始作为获取数据的起始位置。\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logLimit```参数用于设置确定起始位置后，选取的数据记录条数。\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitMinId```参数用于设置收益日志的最小Id。\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitMaxId```参数用于设置收益日志的最大Id。\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitOffset```参数用于设置偏移（跳过多少条记录），作为起始位置。\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitLimit```参数用于设置确定起始位置后，选取的数据记录条数。\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartMinId```参数用于设置图表数据记录的最小Id。\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartMaxId```参数用于设置图表数据记录的最大Id。\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartOffset```参数用于设置偏移。\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartLimit```参数用于设置获取的记录条数。\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartUpdateBaseId```参数用于设置查询更新后的基础Id。\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartUpdateDate```参数用于设置数据记录更新时间戳，会筛选出比这个时间戳大的记录。\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```summaryLimit```参数用于设置查询的状态栏数据字节数。查询实盘的状态栏数据，该参数类型为整型。\\n设置0表示不需要查询状态栏信息，设置为非0表示需要查询的状态栏信息字节数（该接口不限制数据量，可以指定一个较大的summaryLimit参数来获取所有状态栏信息），状态栏数据储存在返回的数据的```summary```字段中。\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"只返回该交易所对象（按标签）的日志，空字符串表示不筛选。\", \"name\": \"logExchange\", \"required\": false, \"type\": \"string\"}, {\"info\": \"只返回日志内容包含该关键字的日志，空字符串表示不筛选。\", \"name\": \"logKeyword\", \"required\": false, \"type\": \"string\"}, {\"info\": \"只返回这些类型的日志，日志类型号用逗号分隔，例如```\\\"0,1,2\\\"```只看买单、卖单、撤单日志；空字符串表示全部类型。\", \"name\": \"logTypes\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"```GetRobotLogs```方法用于获取请求中的```API KEY```对应的发明者量化交易平台账号下的实盘日志信息，所要被获取日志信息的实盘Id为```robotId```参数指定的实盘Id。\"], \"isChildren\": true, \"remarks\": [\"- 数据库中的策略日志表\\n 返回数据中```logs```的属性值（数组结构）的第一个元素中（日志数据）```Arr```属性值描述如下：\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [3977, 3, \\\"Futures_OKX\\\", \\\"\\\", 0, 0, \\\"Sell(688.9, 2): 20016\\\", 1526954372591, \\\"\\\", \\\"\\\"],\\n [3976, 5, \\\"\\\", \\\"\\\", 0, 0, \\\"this_week 仓位过多, 多: 2\\\", 1526954372410, \\\"\\\", \\\"\\\"]\\n ],\\n ```\\n\\n | id | logType | eid | orderId | price | amount | extra | date | contractType | direction |\\n | - | - | - | - | - | - | - | - | - | - |\\n | 3977 | 3 | \\\"Futures_OKX\\\" | \\\"\\\" | 0 | 0 | \\\"Sell(688.9, 2): 20016\\\" | 1526954372591 | \\\"\\\" | \\\"\\\" |\\n | 3976 | 5 | \\\"\\\" | \\\"\\\" | 0 | 0 | \\\"this_week 仓位过多, 多: 2\\\" | 1526954372410 | \\\"\\\" | \\\"\\\" |\\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\\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\\\": 20,\\n \\\"Max\\\": 20,\\n \\\"Min\\\": 1,\\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\\\": 1732201544000,\\n \\\"status\\\": 4,\\n \\\"summary\\\": \\\"...\\\",\\n \\\"updateTime\\\": 1732201532636,\\n \\\"wd\\\": 0\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- logs: 日志信息；查询出的若干条日志数据在Arr字段中。\\n logs中第一个数据结构为实盘数据库中策略日志表中的日志记录。\\n logs中第二个数据结构为实盘数据库中收益日志表中的日志记录。\\n logs中第三个数据结构为实盘数据库中图表日志表中的日志记录。\\n- summary: 实盘状态栏数据。\", \"title\": \"GetRobotLogs\"}, {\"_src_hash\": \"2fe229be22cf6b6fece47bdec5a97c97051fc82d9c7ea63403513b7eb45990c2\", \"args\": [{\"info\": \"实盘配置，字段见{@对外接口/扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。例如：\\n\\n```json\\n{\\n \\\"name\\\": \\\"test\\\",\\n \\\"strategy\\\": 123,\\n \\\"args\\\": [],\\n \\\"exchanges\\\": [\\n {\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}\\n ],\\n \\\"period\\\": 60,\\n \\\"node\\\": 123,\\n \\\"group\\\": 123,\\n \\\"appid\\\": \\\"test\\\"\\n}\\n```\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON对象\"}], \"desc\": [\"```NewRobot```方法用于在请求中的```API KEY```对应的平台账号下创建一个实盘并启动运行，与在网页上创建实盘一样会扣费。\"], \"isChildren\": true, \"remarks\": [\"用```eid```方式直接传入交易所配置时，平台不保存```meta```中的密钥，之后每次用```RestartRobot```重启这个实盘都必须传入```settings```。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":591988,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 创建成功时为新实盘的Id；失败时为负数，含义同{@对外接口/扩展API接口/实盘状态码实盘状态码}中的异常代码（例如```-2```没有找到托管者，```-5```余额不足）。\", \"title\": \"NewRobot\"}, {\"_src_hash\": \"2ccdec24b92a2e89533f5d8635f599ef2a6d559837bd61158702d5b0a227d7d0\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```方法查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"实盘配置，字段见{@对外接口/扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。传入时先用它更新实盘的配置（名称、参数、交易所、K线周期、托管者、分组），再启动；不能更换策略。\", \"name\": \"settings\", \"required\": false, \"type\": \"JSON对象\"}], \"desc\": [\"```RestartRobot```方法用于启动（重启）请求中的```API KEY```对应的平台账号下的实盘，实盘Id由```robotId```参数指定。启动会扣费。\"], \"isChildren\": true, \"remarks\": [\"在平台页面创建、使用已添加交易所账户（```pid```）的实盘，可以只传```robotId```，按实盘当前的配置启动。用```eid```方式直接传入交易所配置的实盘（通常由扩展API接口创建），平台没有保存密钥，每次重启都必须传入```settings```。\"], \"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\": \"47255446ee1a4a6e2ae083c1bf1097334f392c09f713537967a2d91403f47b55\", \"args\": [{\"info\": \"```robotId```参数用于指定要停止的实盘Id。可以通过```GetRobotList```方法获取账号下的实盘信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```StopRobot```方法用于停止请求中```API KEY```对应的发明者量化交易平台账号下的实盘。停止运行的实盘Id由```robotId```参数指定。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":2,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘状态码，2表示停止中。\", \"title\": \"StopRobot\"}, {\"_src_hash\": \"22b48c2074f43dc043ac01bc3d15544d0a36330d6e5292df9f08463803e18c1a\", \"args\": [{\"info\": \"```robotId```参数用于指定接收交互指令的实盘Id，可以用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"发送给实盘的交互命令，策略中用```GetCommand()```函数获取，见{@fun/Global/GetCommand GetCommand}。\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"```CommandRobot```方法用于向请求中的```API KEY```对应的发明者量化交易平台账号下的实盘发送交互命令，接收交互命令的实盘Id为```robotId```参数指定的实盘Id，交互命令由策略中调用的```GetCommand()```函数捕获返回。\"], \"isChildren\": true, \"remarks\": [\"实盘策略，假设这个策略实盘处于运行中，实盘Id为123：\\n```js\\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\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 交互指令是否发送成功；向一个没有运行的实盘发送指令，返回的数据中result为false。\", \"title\": \"CommandRobot\"}, {\"_src_hash\": \"2a302ff84ae64550fb5a521d2d2ce496c5ad626788ef06d9058ed6c9a64f9d20\", \"args\": [{\"info\": \"要删除的实盘Id，可以用```GetRobotList```方法查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"是否同时删除托管者上的实盘日志数据，默认为```true```。\", \"name\": \"removeLog\", \"required\": false, \"type\": \"bool\"}], \"desc\": [\"```DeleteRobot```方法用于删除请求中的```API KEY```对应的平台账号下的实盘，实盘Id由```robotId```参数指定。运行中的实盘需要先停止才能删除。删除后不可恢复。\"], \"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 - -1：没有删除：实盘不存在，或者仍在运行、启动中、停止中。\\n - -2：实盘已删除，但无法与实盘所在的托管者联系，日志数据没有删除；需要到托管者目录```logs/storage/<实盘Id>/```下手动删除（例如```123.db3```）。\", \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"647d749c4736095bd9bfd9c32ba4a5f7998ea28e1475bf53dd0e7ea90f5e182f\", \"args\": [{\"info\": \"执行配置，例如：\\n\\n```json\\n{\\n \\\"source\\\": \\\"function main() {Log(\\\\\\\"Hello FMZ\\\\\\\")}\\\",\\n \\\"node\\\": 123,\\n \\\"period\\\": 60,\\n \\\"exchanges\\\": [{\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}]\\n}\\n```\\n\\n- source：要执行的代码。入口为```main()```，其返回值就是执行结果。\\n- strategy：不传```source```时，执行账号中这个Id的策略（例如交易插件）。\\n- node：执行代码的托管者Id；不写或为```-1```时自动选择。\\n- exchanges：交易所对象配置，写法同{@对外接口/扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON对象\"}], \"desc\": [\"```PluginRun```方法在托管者上执行一段JavaScript代码并返回结果，与开发工具中的「调试工具」、交易终端插件使用同一种执行机制（见{@对外接口/交易终端/插件原理与编写插件原理与编写}）。执行时不创建实盘、不计费，单次执行最长5分钟。\"], \"isChildren\": true, \"remarks\": [\"```exchanges```也可以不引用平台上的交易所账户，直接传入交易所配置，例如：\\n\\n```plaintext\\n{\\\"eid\\\": \\\"Binance\\\", \\\"pair\\\": \\\"ETH_BTC\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}\\n```\\n\\n```meta```的字段名见```GetExchangeList```返回的```meta```。```exchanges```中通常只设置一个交易所对象（调试工具页面也只支持一个）；设置两个不会报错，但代码中访问第二个交易所对象时会报错。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": \\\"{\\\\\\\"logs\\\\\\\":[{\\\\\\\"PlatformId\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"OrderId\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"LogType\\\\\\\":5,\\\\\\\"Price\\\\\\\":0,\\\\\\\"Amount\\\\\\\":0,\\\\\\\"Extra\\\\\\\":\\\\\\\"Hello FMZ\\\\\\\",\\\\\\\"Currency\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Instrument\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Direction\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Time\\\\\\\":1732267473108}],\\\\\\\"result\\\\\\\":\\\\\\\"\\\\\\\"}\\\",\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- result: 执行结果，是一个JSON字符串：```logs```为代码中```Log()```输出的日志，```result```为```main()```返回值的JSON文本。\", \"title\": \"PluginRun\"}], \"desc\": \"所有方法都通过```https://www.fmz.com/api/v1```调用，请求格式与签名见{@对外接口/扩展API接口/验证方式/签名验证签名验证}，返回结构与错误码见{@对外接口/扩展API接口/扩展API接口返回码扩展API接口返回码}。各方法页面示例中的```api()```即签名验证页面Python示例中的函数。\\n\\n**方法一览**\\n\\n| 对象 | 方法 | 参数（按顺序，方括号内可省略） | 说明 | 注意 |\\n| - | - | - | - | - |\\n| 账号 | GetAccount | 无 | 账号信息 | 只读 |\\n| 托管者 | GetNodeList | [offset, limit] | 托管者列表 | 只读 |\\n| 托管者 | DeleteNode | nid | 删除托管者 | 删除，不可恢复 |\\n| 交易所 | GetExchangeList | isSummary | 平台支持的交易所及配置项 | 只读 |\\n| 交易所 | GetPlatformList | [offset, limit] | 已添加的交易所账户 | 只读 |\\n| 策略 | GetStrategyList | offset, length, strategyType, category, language, kw[, groupId, orderBy] | 策略列表 | 只读 |\\n| 实盘 | GetRobotGroupList | 无 | 实盘分组 | 只读 |\\n| 实盘 | GetRobotList | [offset, length, customStatus, appId, kw, groupId, orderBy, strategyId] | 实盘列表 | 只读 |\\n| 实盘 | GetRobotDetail | robotId | 实盘详细信息 | 只读 |\\n| 实盘 | GetRobotLogs | robotId, logMinId, …, summaryLimit[, logExchange, logKeyword, logTypes] | 日志、收益、图表与状态栏数据 | 只读 |\\n| 实盘 | NewRobot | settings | 创建并启动实盘 | 扣费；实盘会真实交易 |\\n| 实盘 | RestartRobot | robotId[, settings] | 启动（重启）实盘 | 扣费；实盘会真实交易 |\\n| 实盘 | StopRobot | robotId | 停止实盘 | 不会平仓 |\\n| 实盘 | CommandRobot | robotId, cmd | 向实盘发送交互命令 | 策略可能据此下单 |\\n| 实盘 | DeleteRobot | robotId[, removeLog] | 删除实盘 | 删除，不可恢复 |\\n| 调试 | PluginRun | settings | 在托管者上执行一段代码 | 代码可以真实下单 |\\n\\nAPI KEY需要有对应方法的权限，见{@对外接口/扩展API接口/创建ApiKey 创建ApiKey}。\\n\\n**参数传法**\\n\\n```args```有两种写法：\\n\\n- 数组：按上表的顺序传位置参数，例如```[123, \\\"ok\\\"]```。\\n- 对象：按参数名传值，例如```{\\\"robotId\\\": 123, \\\"cmd\\\": \\\"ok\\\"}```。参数名不区分大小写、忽略下划线，没有传的参数取默认值。可选参数多的方法（GetRobotList、GetRobotLogs、GetStrategyList）建议用这种写法。\\n\\n**实盘配置（settings）**\\n\\nNewRobot、RestartRobot、PluginRun的```settings```参数是一个JSON对象，常用字段如下：\\n\\n| 字段 | 说明 |\\n| - | - |\\n| name | 实盘名称。 |\\n| strategy | 策略Id，可用GetStrategyList查询。RestartRobot不能更换实盘的策略。 |\\n| args | 策略参数，每个元素为```[\\\"参数名\\\", 值]```，例如```[[\\\"Interval\\\", 500]]```；策略没有参数时为```[]```。 |\\n| exchanges | 交易所对象配置数组，每个元素对应一个交易所对象，写法见下文。 |\\n| period | 默认K线周期，单位为秒，例如```60```、```3600```。 |\\n| node | 运行实盘的托管者Id，可用GetNodeList查询；不写或为```-1```时自动分配。 |\\n| group | 实盘分组Id，可用GetRobotGroupList查询。 |\\n| appid | 自定义标签，GetRobotList可以按标签筛选。 |\\n\\n```exchanges```的元素有两种写法，同一个数组中不能混用（以第一个元素的写法为准）：\\n\\n- 引用平台上已添加的交易所账户：```{\\\"pid\\\": 123, \\\"pair\\\": \\\"BTC_USDT\\\"}```。```pid```可用GetPlatformList查询（返回数据中的```id```）。\\n- 直接传入交易所配置：```{\\\"eid\\\": \\\"Binance\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}```。```eid```为交易所Id；```meta```的字段名见GetExchangeList返回的```meta```；```label```是交易所对象的标签，策略中用```exchange.GetLabel()```获取。平台不保存```meta```中的密钥，而是直接转发给托管者，所以用这种写法创建的实盘，每次重启时都必须重新传入```settings```。\\n\\n通用协议交易所的写法：```{\\\"eid\\\": \\\"Exchange\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\", \\\"Front\\\": \\\"http://127.0.0.1:6666/test\\\"}}```，```Front```为通用协议服务的地址。\", \"title\": \"扩展API接口详解\"}, {\"_src_hash\": \"18a80d72b02ca32542a9b6e3476f59f57d295081300532ee22365225e59dea75\", \"desc\": \"扩展API接口返回的结构如下：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n```code```是请求本身的状态码：\\n\\n| 描述 | 代码 |\\n| - | - |\\n| 执行成功 | 0 |\\n| 错误的API KEY：```AccessKey```不存在或已禁用；直接验证时```secret_key```不正确 | 1 |\\n| 错误的签名 | 2 |\\n| Nonce错误：```nonce```不大于上次请求的值，或与服务器时间相差超过1小时 | 3 |\\n| 方法不正确：方法不存在、不对外开放，或这把API KEY没有该方法的权限 | 4 |\\n| 参数不正确：```args```不是合法的JSON，或调用失败 | 5 |\\n| 内部未知错误 | 6 |\\n| 请求来源IP不在这把API KEY的IP白名单内 | 7 |\\n\\n```code```为0只表示请求被受理。方法的结果在```data.result```中；方法执行出错时，```data.error```为错误信息（成功时为```null```）。例如参数个数不对：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": \\\"Params number mismatch for StopRobot: expected 1, got 0\\\"\\n }\\n}\\n```\", \"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\": \"实盘状态码\"}], \"desc\": \"扩展API接口是平台的HTTP接口（```https://www.fmz.com/api/v1```），供脚本、定时任务等程序调用平台功能：查询账号、托管者、策略和实盘，创建、重启、停止实盘，向实盘发送交互命令等。\\n\\n在AI助手（Claude Code、Cursor等）中交互式地操作平台时，优先使用{@对外接口/AI接入 AI接入}（MCP服务）：工具更全，参数按名称传递，权限可以按类别授予。两者可以使用同一把API KEY。\\n\\n使用步骤：{@对外接口/扩展API接口/创建ApiKey 创建ApiKey}，按{@对外接口/扩展API接口/验证方式验证方式}发送请求，方法与参数见{@对外接口/扩展API接口/扩展API接口详解扩展API接口详解}。\", \"title\": \"扩展API接口\"}, {\"_src_hash\": \"7a5b85bf5d5a5f0d94aec2949f2c768dc5071210d137ffb53efa29acf68d0b61\", \"children\": [{\"_src_hash\": \"fda0732a375c2f1c28417fc2271d7f6fef838ceb7d1f17d6276bde22d51282b3\", \"desc\": \"**原理**\\n\\n交易插件是一段在托管者上执行的短代码：在交易终端页面点击「执行」时，平台把插件代码和模块选定的交易所账户发送到选定的托管者执行，执行结束后把返回值显示在模块中。下面几个入口使用同一种执行机制：\\n\\n| 入口 | 执行的代码 | 说明 |\\n| - | - | - |\\n| 交易终端插件 | 策略库中类型为「交易插件」的策略 | 在交易终端页面添加、执行 |\\n| 调试工具（开发工具） | 页面中临时编写的JavaScript代码 | 用于测试API调用 |\\n| 扩展API接口{@对外接口/扩展API接口/扩展API接口详解/PluginRun PluginRun} | 请求中的```source```，或账号中已有的策略 | 供程序调用 |\\n| MCP的```plugin_*```工具 | 平台内置的查询行情、下单等函数 | 供AI助手调用，按```trade```权限授权，见{@对外接口/AI接入 AI接入} |\\n\\n这种执行方式不创建实盘、不计费，单次执行最长5分钟，超时中断。适合辅助手动交易的简单任务，例如冰山委托、批量挂单撤单、计算；需要长期运行的逻辑应创建实盘。\\n\\n**编写**\\n\\n在新建策略页面把策略类型设置为「交易插件」即可创建交易插件。交易插件、调试工具和```PluginRun```都只支持JavaScript。\\n\\n插件的入口是```main()```，返回值就是执行结果：返回表格对象、图表对象时，在模块中显示为表格、图表（示例见{@对外接口/交易终端/插件示例插件示例}）。插件中```Log()```输出的日志不会在模块中显示。\\n\\n**使用**\\n\\n- 添加：在交易终端页面打开模块添加菜单，账号策略库中的交易插件会出现在列表中，选择需要的插件添加。\\n- 执行：点击插件模块中的「执行」运行插件。\\n\\n**数据目录**\\n\\n插件和调试工具在托管者上执行时，以托管者运行目录下的```logs/storage/p<数字>/```为工作目录（每个平台账号一个以```p```开头的目录，第一次执行后创建）。如果交易终端使用的交易所账户以密钥文件路径（```file:///xxx.txt```）的方式配置密钥，需要把密钥文件放在这个目录中。\", \"title\": \"插件原理与编写\"}, {\"_src_hash\": \"0ffd303f43c1d65239876e2e663f2da49572486d75b22289ab2c857f965f32e7\", \"desc\": \"插件可以在一段时间内执行代码，完成一些简单的操作，例如冰山委托、挂单、撤单、计算等。插件用```return```返回结果，返回表格、图表对象时直接显示为表格、图表。下面是两个例子，更多范例可以在**策略广场**中查找，例如逐笔小量买入/卖出。\\n\\n**返回深度快照**\\n\\n以表格显示当前盘口前15档：\\n\\n```js\\n// 返回深度快照\\nfunction 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 var n = Math.min(d.Asks.length, d.Bids.length, 15)\\n for (var i = 0; i < n; 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\\n**画跨期差价**\\n\\n期货交易所对象上，取季度合约与当周合约的5分钟K线，画出收盘价差：\\n\\n```js\\n// 画跨期差价\\nvar 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\\nfunction main() {\\n exchange.SetContractType('quarter')\\n var recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType('this_week')\\n var recordsB = exchange.GetRecords(PERIOD_M5)\\n\\n var n = Math.min(recordsA.length, recordsB.length)\\n for (var i = 0; i < n; i++) {\\n var a = recordsA[recordsA.length - n + i]\\n var b = recordsB[recordsB.length - n + i]\\n chart.series[0].data.push([a.Time, a.Close - b.Close])\\n }\\n return chart\\n}\\n```\", \"title\": \"插件示例\"}], \"desc\": \"平台提供模块化、可定制的[交易终端](https://www.fmz.com/m/trade)页面：可以自由添加行情、交易等各种模块，模块可以拖动、缩放，可以修改模块绑定的交易所、交易对，同一类模块可以添加多个，方便手动交易和半程序化交易。\\n\\n交易终端还支持交易插件：自己编写一段代码作为模块，在选定的托管者上执行，辅助手动交易。\", \"title\": \"交易终端\"}], \"desc\": \"从AI助手或外部程序操作平台：AI接入（MCP服务）、扩展API接口、交易终端插件。\", \"title\": \"对外接口\"}]","language","zh-CN","languageMode","system","sessionData",{"_373":25,"_374":25,"_375":240,"_376":240,"_377":25,"_170":25,"_378":25,"_379":25},"settings",{"_30":31,"_32":33},"zone","fmz","theme",{"_28":14,"_29":-7},"colorUpGreen","isWebApp",false,"cdnBase","","themeMode","resolvedThemeMode","appSettings",{"_150":151,"_152":153,"_154":155,"_156":157,"_158":159,"_160":161,"_162":163,"_164":165,"_166":167,"_168":169,"_170":171,"_172":173,"_174":175,"_176":177,"_178":179},"uiFooter",{"_34":35,"_36":37,"_38":39},"copyright",{"_40":149,"_42":149},"download",{"_145":146,"_147":148},"footer",{"_40":41,"_42":43},"zh_CN",[101,102,103],"en_US",[44,45,46],{"_47":84,"_49":85},{"_47":67,"_49":68},{"_47":48,"_49":50},"title","API","items",[51,52,53,54,55],{"_47":65,"_57":66},{"_47":63,"_57":64},{"_47":61,"_57":62},{"_47":59,"_57":60},{"_47":56,"_57":58},"Indicator","url","/api#indicator-functions","Blockchain","/api#blockchain","Trading api","/api#trading-api","User guide","/user-guide","Syntax guide","/syntax-guide","Product",[69,70,71,72,73],{"_47":82,"_57":83},{"_47":80,"_57":81},{"_47":78,"_57":79},{"_47":76,"_57":77},{"_47":74,"_57":75},"Tickets","/m/tickets","Platforms","/m/platforms","Node","/m/add-node","Strategy","/m/add-strategy","Robot","/m/add-robot","Forums",[86,87,88,89,90],{"_47":99,"_57":100},{"_47":97,"_57":98},{"_47":95,"_57":96},{"_47":93,"_57":94},{"_47":91,"_57":92},"About Us","/about-us","Web3","/bbs-topic/10032","MyLanguage","/bbs-topic/9480","FAQ Summary","/bbs-topic/9158","PINE Language","/bbs-topic/9637",{"_47":131,"_49":132},{"_47":119,"_49":120},{"_47":104,"_49":105},"API文档",[106,107,108,109,110],{"_47":118,"_57":66},{"_47":117,"_57":64},{"_47":115,"_57":116},{"_47":113,"_57":114},{"_47":111,"_57":112},"指标函数","/api#指标函数","区块链","/api#区块链","交易api","/api#交易api","用户指南","语法手册","产品功能",[121,122,123,124,125],{"_47":130,"_57":83},{"_47":129,"_57":81},{"_47":128,"_57":79},{"_47":127,"_57":77},{"_47":126,"_57":75},"工单","交易所","部署托管者","新建策略","创建实盘","社区",[133,134,135,136,137],{"_47":143,"_57":144},{"_47":117,"_57":64},{"_47":141,"_57":142},{"_47":139,"_57":140},{"_47":138,"_57":92},"关于我们","托管者安装和升级","/bbs-topic/2848","Python入门指南","/bbs-topic/4388","回测系统","/api#回测系统","android","/dist/fmz.apk","ios","itms-apps://itunes.apple.com/WebObjects/MZStore.woa/wa/viewSoftware?id=1572932684","© 2015 - ∞ INVENTOR PTE LTD (SG)","banner",[355,356,357,358,359],"nav",[322,323,324,325,326,327,328,329],"ad",[318],"ad1",[306,307,308],"embedx",[287,288],"payments",[242,243,244,245,246],"strategy",[220,221,222,223,224,225],"sso",[202,203,204],"update",{"_145":184,"_147":185,"_186":187},"redirect",{"_182":183},"openai",true,"ui",{"_180":171,"_181":171},"datadata_snapshot","https://www.datadata.com/web/resources/{{uuid}}/screenshot.png","chart","https://www.fmz.com/app/chart","timeout",15000,"show_prop_strategies","aiguide","/strategy/268542","/strategy/520271",{"_188":189,"_195":196,"_190":200,"_192":201,"_186":193,"_197":198,"_34":199},{"_190":194,"_188":189,"_195":196,"_192":148,"_197":198,"_34":199},"web",{"_188":189,"_190":191,"_192":193},"version","v2.2.36","paymethod","balance,voucher","link","https://www.fmz.com/mobile","","min_version","v2.0.1","name","FMZ","Copyright © FMZ.COM 版权所有","voucher","https://www.fmz.com/dist/fmz.apk",{"_205":216,"_207":217,"_47":218,"_210":219},{"_205":212,"_207":213,"_47":214,"_210":215},{"_205":206,"_207":208,"_47":209,"_210":211},"source","web3","logo","/upload/asset/ee79a670efe19d2365.svg","MetaMask","platform",[186],"apple","/upload/asset/4416f8d6618c84681e.png","Apple 登录|Apple",[186,147],"google","/upload/asset/102992e886fb7a2fc67.png","Google 登录|Google",[186,147,145],{"_226":240,"_197":241},{"_226":238,"_232":236,"_197":239},{"_226":235,"_232":236,"_197":237},{"_226":231,"_232":233,"_197":234},{"_226":229,"_197":230},{"_226":227,"_197":228},"id",21,"交易插件|Plugin",20,"模板类库|Template",9,"currency","USD","加密货币|Cryptocurrency",2,"CNY","股票证券|Stocks",1,"商品期货|Futures",0,"通用策略|Common",{"_226":235,"_197":285,"_261":247,"_249":262,"_232":233,"_252":286},{"_226":264,"_197":265,"_261":240,"_266":264,"_249":256,"_232":233,"_267":268,"_269":270,"_252":271},{"_226":259,"_197":260,"_261":247,"_249":262,"_232":233,"_252":263},{"_226":254,"_197":255,"_249":256,"_257":200,"_252":258},{"_226":247,"_197":248,"_249":250,"_232":251,"_252":253},3,"余额|Balance","scope","buy","USD,CNY","image","https://www.fmz.com/upload/asset/bc7ac3c0c5e1068a32.png",4,"充值码|Voucher","charge","type","https://www.fmz.com/upload/asset/28fa674166cb24de22b.png",6,"Stripe","amount","charge,buy","https://www.fmz.com/upload/asset/174be2a35fc37c113a6.png",5,"USDT","min","chain",[272,273,274],"description","您只可发送 USDT 至此地址，若发送其他数字货币，您将会失去这笔资金。||only send USDT to this address, you will lose your assets if you send any other crypto","https://www.fmz.com/upload/asset/bb9c83903a6cbfea0f.png",{"_275":282,"_197":283,"_269":284},{"_275":279,"_197":280,"_269":281},{"_275":276,"_197":277,"_269":278},"symbol","TRX","TRC20","Tron Network","ETH","ERC20","Ethereum Network","BNB","BSC","Binance Smart Chain","Paypal","https://www.fmz.com/upload/asset/297a3cb96cf4d1e7736.png",{"_289":303,"_291":304},{"_289":290,"_291":292},"path","/square_bak","banners",[293,294],{"_252":298,"_299":298,"_300":301,"_192":302},{"_295":296,"_192":297},"text","发明者量化平台全球KOL招募令||Financial Magic Zone Global KOL Recruitment","/bbs-topic/10382","/upload/asset/11c9e5536c5d4c1e46e.png","image_dark","height","100px","https://www.jinse.cn/blockchain/3690011.html","/digest",[305],{"_252":298,"_299":298,"_192":302},{"_252":315,"_299":316,"_192":317},{"_252":312,"_299":313,"_192":314},{"_252":309,"_299":310,"_192":311},"/upload/asset/15ce9c5df17eb9af463.png","/upload/asset/309f2b0743dd12d5659.png","/bbs-topic/8238","/upload/asset/2b85d8e0029712de49d.png","/upload/asset/27b5928f8282ebe1864.png","/bbs-topic/1427","/upload/asset/19bb3b1f48c49e196d8.png","/upload/asset/33b98e51d4670de9ce5.png","/bbs-topic/4158",{"_252":319,"_299":320,"_192":321},"/upload/asset/2c2c9521b3a6d0ee73b.png","/upload/asset/2c77ab5db219dc3e78f.png","/bbs-topic/4145",{"_197":352,"_252":353,"_192":354},{"_197":347,"_348":349,"_252":350,"_192":351},{"_197":345,"_252":346,"_192":303},{"_197":342,"_252":343,"_192":344},{"_197":339,"_252":340,"_192":341},{"_197":336,"_252":337,"_192":338},{"_197":333,"_252":334,"_192":335},{"_197":330,"_252":331,"_192":332},"消息中心|Message","/upload/asset/274a5fd7d23a979cd11.png","/messages","工单|Ticket","/upload/asset/11147e72e6c33dc8cba.png","/tickets","交易所|Platform","/upload/asset/318b4addb664da55ea6.png","/platforms","交易终端|Trade","/upload/asset/733e259ec86facf025.png","/trade","社区|Forum","/upload/asset/2e5a8b06b92e5f1357f.png","/bbs","文库|Digest","/upload/asset/1716e895993c78000f3.png","围观|Live","size",30,"/upload/asset/2f23fcaecaa612555f5.png","/live","策略广场|Square","/upload/asset/36bba6d48d47a6689f3.png","/square",{"_252":298,"_299":298,"_192":302},{"_252":370,"_299":371,"_192":372},{"_252":365,"_299":366,"_367":368,"_192":369},{"_252":363,"_299":364,"_192":183},{"_252":360,"_299":361,"_192":362},"/upload/asset/10f6f33ea3b03f80a90.png","/upload/asset/158be7477c0a9a4538a.png","/strategy/520273","/upload/asset/bca3a8d340c888e609.png","/upload/asset/8f0c8df04d8bd94a73.png","/upload/asset/a56df9bdccd3fbcb28.png","/upload/asset/d08dd59b5ac36ed333.png","delay",10000,"/strategy/520272","/upload/asset/de3b761a5c58f67993.png","/upload/asset/18e8a84aec3a5e77ff4.png","/strategy/520274","isAuthenticated","isShadow","balance","fee","isAdmin","hasTwofactor","hasPassword"]

状态	代码
空闲中	0
运行中	1
停止中	2
已退出	3
被停止	4
策略有错误	5

状态	代码
策略已过期，请联系作者重新购买	-1
未找到托管者	-2
策略编译错误	-3
实盘已处于运行状态	-4
余额不足	-5
策略并发数超限	-6