exchange.GetTicker

获取当前设置的交易对、合约代码所对应现货或合约的Ticker结构，即行情数据。GetTicker()函数是交易所对象exchange的成员函数，exchange对象的成员函数（方法）的用途仅与exchange相关，后续文档中不再赘述。

    
    
    
exchange.GetTicker()

    
    
    
exchange.GetTicker(symbol)

示例

• 对于期货交易所对象（即exchange或exchanges[0]），在调用行情函数前需要先使用exchange.SetContractType()函数设置合约代码，后续文档中不再赘述。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 如果是期货交易所对象，先设置合约代码，例如设置为永续合约
      // exchange.SetContractType("swap")
  
      var ticker = exchange.GetTicker()
      /*
          可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
          此时ticker为null，当访问ticker.High时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
      */
      Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume)
  }
  

  
      python
      
      
  def main():
      ticker = exchange.GetTicker()
      Log("Symbol:", ticker["Symbol"], "High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Open:", ticker["Open"], "Volume:", ticker["Volume"])
  

  
      rust
      
      
  fn main() {
      // 如果是期货交易所对象，先设置合约代码，例如设置为永续合约
      // exchange.SetContractType("swap").unwrap();
  
      let ticker = exchange.GetTicker(None).unwrap();
      Log!("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
  }
  

  
      c++
      
      
  void main() {
      auto ticker = exchange.GetTicker();
      Log("Symbol:", ticker.Symbol, "High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Open:", ticker.Open, "Volume:", ticker.Volume);
  }
  

• 使用symbol参数请求具体品种（现货品种）的行情数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var ticker = exchange.GetTicker("BTC_USDT")
      Log(ticker)
  }
  

  
      python
      
      
  def main():
      ticker = exchange.GetTicker("BTC_USDT")
      Log(ticker)
  

  
      rust
      
      
  fn main() {
      let ticker = exchange.GetTicker("BTC_USDT").unwrap();
      Log!(ticker);
  }
  

  
      c++
      
      
  void main() {
      auto ticker = exchange.GetTicker("BTC_USDT");
      Log(ticker);
  }
  

返回值

参数

参考

备注

在回测系统中，exchange.GetTicker()函数返回的Ticker数据中，High、Low为模拟值，取自当时盘口的卖一价和买一价。

在实盘中，exchange.GetTicker()函数返回的Ticker数据中，High和Low的值根据所封装的交易所Tick接口返回的数据确定，这些数据包含一定周期内（通常为24小时周期）的最高价和最低价。

不支持exchange.GetTicker()函数的交易所：

exchange.GetDepth

获取当前设置的交易对、合约代码所对应的现货或合约的Depth结构，即订单簿数据。

    
    
    
exchange.GetDepth()

    
    
    
exchange.GetDepth(symbol)

示例

• 测试exchange.GetDepth()函数：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      var depth = exchange.GetDepth()
      /*
          可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
          此时depth为null，当访问depth.Asks[1].Price时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
      */
      var price = depth.Asks[1].Price
      Log("Second ask price:", price)
  }
  

  
      python
      
      
  def main():
      depth = exchange.GetDepth()
      price = depth["Asks"][1]["Price"]
      Log("Second ask price:", price)
  

  
      rust
      
      
  fn main() {
      let depth = exchange.GetDepth(None).unwrap();
      let price = depth.Asks[1].Price;
      Log!("Second ask price:", price);
  }
  

  
      c++
      
      
  void main() {
      auto depth = exchange.GetDepth();
      auto price = depth.Asks[1].Price;
      Log("Second ask price:", price);
  }
  

• 当配置的exchange对象为期货交易所对象时，使用symbol参数请求指定品种（期货品种）的订单簿数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // BTC的U本位永续合约
      var depth = exchange.GetDepth("BTC_USDT.swap")
      Log(depth)
  }
  

  
      python
      
      
  def main():
      depth = exchange.GetDepth("BTC_USDT.swap")
      Log(depth)
  

  
      rust
      
      
  fn main() {
      // BTC的U本位永续合约
      let depth = exchange.GetDepth("BTC_USDT.swap").unwrap();
      Log!(depth);
  }
  

  
      c++
      
      
  void main() {
      auto depth = exchange.GetDepth("BTC_USDT.swap");
      Log(depth);
  }
  

返回值

参数

参考

备注

回测系统中，使用模拟级 Tick回测时，exchange.GetDepth()函数返回数据的各档位均为模拟值。

回测系统中，使用实盘级 Tick回测时，exchange.GetDepth()函数返回的数据为秒级别的深度快照。

exchange.GetTrades

获取当前设置的交易对、合约代码所对应的现货或合约的Trade结构数组，即市场的成交数据。

    
    
    
exchange.GetTrades()

    
    
    
exchange.GetTrades(symbol)

示例

• 测试exchange.GetTrades()函数：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      var trades = exchange.GetTrades()
      /*
          可能由于网络原因，访问不到交易所接口（即使托管者程序所在设备能打开交易所网站，但是API接口也可能访问不通）
          此时trades为null，当访问trades[0].Id时，会导致错误，所以在测试该代码时，确保可以访问到交易所接口
      */
      Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
  }
  

  
      python
      
      
  def main():
      trades = exchange.GetTrades()
      Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])
  

  
      rust
      
      
  fn main() {
      let trades = exchange.GetTrades(None).unwrap();
      Log!("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
  }
  

  
      c++
      
      
  void main() {
      auto trades = exchange.GetTrades();
      Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
  }
  

• 当配置的exchange对象为期货交易所对象时，使用symbol参数请求具体品种（期货品种）的市场成交记录数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // BTC的U本位永续合约
      var trades = exchange.GetTrades("BTC_USDT.swap")
      Log(trades)
  }
  

  
      python
      
      
  def main():
      trades = exchange.GetTrades("BTC_USDT.swap")
      Log(trades)
  

  
      rust
      
      
  fn main() {
      // BTC的U本位永续合约
      let trades = exchange.GetTrades("BTC_USDT.swap").unwrap();
      Log!(trades);
  }
  

  
      c++
      
      
  void main() {
      auto trades = exchange.GetTrades("BTC_USDT.swap");
      Log(trades);
  }
  

返回值

参数

参考

备注

exchange.GetTrades()函数用于获取当前交易对、合约所对应市场的成交历史（非自身成交）。部分交易所不支持该函数，且具体返回的成交记录范围因交易所而异，需要根据实际情况处理。返回数据为一个数组，其中每个元素的时间顺序与exchange.GetRecords()函数的返回数据顺序一致，即数组的最后一个元素为距离当前时间最近的数据。

在回测系统中，使用模拟级 Tick回测时，exchange.GetTrades()函数返回空数组。

在回测系统中，使用**实盘级 Tick**回测时，exchange.GetTrades()函数返回的数据为订单流快照数据，即Trade结构数组。

不支持exchange.GetTrades()函数的交易所：

exchange.GetRecords

获取当前设置的交易对、合约代码所对应的现货或合约的Record结构数组，即K线数据。

    
    
    
exchange.GetRecords()

    
    
    
exchange.GetRecords(symbol)

    
    
    
exchange.GetRecords(symbol, period)

    
    
    
exchange.GetRecords(symbol, period, limit)

    
    
    
exchange.GetRecords(period)

    
    
    
exchange.GetRecords(period, limit)

示例

• 获取自定义周期的 K 线数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      // 打印 K 线周期为 120 秒（2 分钟）的 K 线数据
      Log(exchange.GetRecords(60 * 2))
      // 打印 K 线周期为 5 分钟的 K 线数据
      Log(exchange.GetRecords(PERIOD_M5))
  }
  

  
      python
      
      
  def main():
      Log(exchange.GetRecords(60 * 2))
      Log(exchange.GetRecords(PERIOD_M5))
  

  
      rust
      
      
  fn main() {
      // 打印 K 线周期为 120 秒（2 分钟）的 K 线数据
      Log!(exchange.GetRecords(None, 60 * 2, None));
      // 打印 K 线周期为 5 分钟的 K 线数据
      Log!(exchange.GetRecords(None, PERIOD_M5, None));
  }
  

  
      c++
      
      
  void main() {
      Log(exchange.GetRecords(60 * 2)[0]);
      Log(exchange.GetRecords(PERIOD_M5)[0]);
  }
  

• 输出 K 线柱数据：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var records = exchange.GetRecords(PERIOD_H1)
      /*
          可能由于网络原因，无法访问交易所接口（即使托管者程序所在设备能够打开交易所网站，API 接口仍可能无法访问）
          此时 records 为 null，访问 records[0].Time 时会导致错误。因此在测试该代码时，请确保能够正常访问交易所接口
      */
      Log("First K-line data: Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
      Log("Second K-line data: Time:", records[1].Time ,"Close:", records[1].Close)
      Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
  }
  

  
      python
      
      
  def main():
      records = exchange.GetRecords(PERIOD_H1)
      Log("First K-line data: Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
      Log("Second K-line data: Time:", records[1]["Time"], "Close:", records[1]["Close"])
      Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])
  

  
      rust
      
      
  fn main() {
      let records = exchange.GetRecords(None, PERIOD_H1, None).unwrap();
      Log!("First K-line data: Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
      Log!("Second K-line data: Time:", records[1].Time, "Close:", records[1].Close);
      Log!("Current K-line (latest)", records[records.len() - 1], "Previous K-line", records[records.len() - 2]);
  }
  

  
      c++
      
      
  void main() {
      auto records = exchange.GetRecords(PERIOD_H1);
      Log("First K-line data: Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
      Log("Second K-line data: Time:", records[1].Time, "Close:", records[1].Close);
      Log("Current K-line (latest)", records[records.size() - 1], "Previous K-line", records[records.size() - 2]);
  }
  

• 当配置的exchange对象为期货交易所对象时，可使用symbol、period、limit参数请求指定品种（期货品种）的K线数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
      Log(records)
  }
  

  
      python
      
      
  def main():
      records = exchange.GetRecords("BTC_USDT.swap", 60, 100)
      Log(records)
  

  
      rust
      
      
  fn main() {
      let records = exchange.GetRecords("BTC_USDT.swap", 60, 100).unwrap();
      Log!(records);
  }
  

  
      c++
      
      
  void main() {
      auto records = exchange.GetRecords("BTC_USDT.swap", 60, 100);
      Log(records);
  }
  

返回值

参数

参考

备注

默认K线周期可在回测、实盘页面进行设置。调用exchange.GetRecords()函数时，如果指定了参数，则获取该参数所指定周期的K线数据；如果未指定参数，则返回回测、实盘参数中所设置周期的K线数据。

返回值为Record结构数组。返回的K线数据会随时间不断累积，累积的K线柱数量上限受exchange.SetMaxBarLen()函数设置的影响，未设置时默认上限为5000个K线柱。当K线数据达到累积上限后，每新增一根K线柱的同时会删除时间最早的一根K线柱（类似队列的先进先出）。部分交易所未提供K线接口，此时由托管者实时收集市场成交记录数据（Trade结构数组）来合成K线。

如果交易所的K线接口支持分页查询，当调用exchange.SetMaxBarLen()函数设置较大的K线长度时，系统会发起多次API请求。

初始调用exchange.GetRecords()函数时，所获取的K线柱数量在回测和实盘环境下有所不同：

• 回测系统会预先获取回测时间范围起始时刻之前一定数量的K线柱（默认为5000个，回测系统的相关设置及数据量会影响最终返回的数量），作为初始K线数据。

• 实盘时具体获取的K线柱数量取决于交易所K线接口所能提供的最大数据量。

将period参数设置为5，即表示请求获取以5秒为周期的K线数据。如果period参数不能被60整除（即所代表的周期无法以分钟为单位表示），系统底层会使用exchange.GetTrades()的相关接口获取成交记录数据，以合成所需的K线数据；如果period参数能被60整除，则最小使用1分钟K线数据（并尽可能使用较大的周期）来合成所需的K线数据。

在回测系统的模拟级别回测中，由于需要设置底层K线周期（模拟级别回测时，系统会根据设置的底层K线周期，使用对应的K线数据生成Tick数据），因此需要注意：策略中获取的K线数据周期不能小于底层K线周期。这是因为在模拟级别回测中，各个周期的K线数据均由底层K线周期对应的K线数据合成而来。

C++语言中如果需要自行构造K线数据，可参考以下代码范例：

            c++
            
            
#include <sstream>
void main() {
    Records r;
    r.Valid = true;
    for (auto i = 0; i < 10; i++) {
        Record ele;
        ele.Time = i * 100000;
        ele.High = i * 10000;
        ele.Low = i * 1000;
        ele.Close = i * 100;
        ele.Open = i * 10;
        ele.Volume = i * 1;
        r.push_back(ele);
    }
    // 输出显示：Records[10]
    Log(r);
    auto ma = TA.MA(r,10);
    // 输出显示：[nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);
}

不支持exchange.GetRecords()函数的交易所：

exchange.GetPeriod

获取回测或实盘运行策略时，在发明者量化交易平台网站页面上所设置的 K 线周期，即调用 exchange.GetRecords() 函数且不传入参数时使用的默认 K 线周期。

    
    
    
exchange.GetPeriod()

示例

    javascript
    
    
function main() {
    // 例如，回测或实盘时在发明者量化交易平台网站页面上设置的 K 线周期为 1 小时
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hours")
}

    python
    
    
def main():
    period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hours")

    rust
    
    
fn main() {
    // 例如，回测或实盘时在发明者量化交易平台网站页面上设置的 K 线周期为 1 小时
    let period = exchange.GetPeriod();
    Log!("K-line period:", period as f64 / (60.0 * 60.0), "hours");
}

    c++
    
    
void main() {
    auto period = exchange.GetPeriod();
    Log("K-line period:", period / (60 * 60.0), "hours");
}

返回值

参考

exchange.SetMaxBarLen

设置K线的最大长度。

    
    
    
exchange.SetMaxBarLen(len)

示例

    javascript
    
    
function main() {
    exchange.SetMaxBarLen(50)
    var records = exchange.GetRecords()
    Log(records.length, records)
}

    python
    
    
def main():
    exchange.SetMaxBarLen(50)
    r = exchange.GetRecords()
    Log(len(r), r)

    rust
    
    
fn main() {
    exchange.SetMaxBarLen(50);
    let records = exchange.GetRecords(None, None, None).unwrap();
    Log!(records.len(), records);
}

    c++
    
    
void main() {
    exchange.SetMaxBarLen(50);
    auto r = exchange.GetRecords();
    Log(r.size(), r[0]);
}

参数

参考

备注

exchange.SetMaxBarLen()函数在加密货币策略运行时会影响以下两个方面：

• 影响首次调用时获取的K线线柱（Bar）数量。

• 影响K线线柱（Bar）数量的上限。

exchange.GetRawJSON

获取当前交易所对象（exchange、exchanges）最近一次rest请求返回的原始内容。

    
    
    
exchange.GetRawJSON()

示例

    javascript
    
    
function main(){
    exchange.GetAccount();
    var obj = JSON.parse(exchange.GetRawJSON());
    Log(obj);
}

    python
    
    
import json
def main():
    exchange.GetAccount()
    obj = json.loads(exchange.GetRawJSON())
    Log(obj)

    c++
    
    
void main() {
    auto obj = exchange.GetAccount();
    // C++ 不支持GetRawJSON函数
    Log(obj);
}

返回值

参考

备注

exchange.GetRawJSON()函数仅支持实盘交易。C++语言的策略不支持此函数。

exchange.GetRate

获取交易所对象当前设置的汇率。

    
    
    
exchange.GetRate()

示例

    javascript
    
    
function main(){
    Log(exchange.GetTicker())
    // 设置汇率转换
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    Log("Current rate:", exchange.GetRate())
}

    python
    
    
def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    Log("Current rate:", exchange.GetRate())

    rust
    
    
fn main() {
    Log!(exchange.GetTicker(None));
    // 设置汇率转换
    exchange.SetRate(7);
    Log!(exchange.GetTicker(None));
    Log!("Current rate:", exchange.GetRate());
}

    c++
    
    
void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    Log("Current rate:", exchange.GetRate());
}

返回值

参考

备注

如果未调用exchange.SetRate()设置过转换汇率，exchange.GetRate()函数将返回默认汇率值1，即当前显示的计价货币（quoteCurrency）相关数据未经过汇率转换。

如果已使用exchange.SetRate()设置过汇率值，例如exchange.SetRate(7)，那么通过exchange交易所对象获取的行情、深度、下单价格等所有价格信息，都会乘以所设置的汇率7进行转换。

如果exchange对应的是以美元为计价货币的交易所，在调用exchange.SetRate(7)后，实盘中的所有价格都会乘以7，转换为接近人民币（CNY）的价格。此时通过exchange.GetRate()获取的汇率值即为7。

exchange.SetData

exchange.SetData()函数用于设置策略运行时所加载的数据。

    
    
    
exchange.SetData(key, value)

示例

参数value所要求的数据格式如同以下例子中的data变量。可以看到，时间戳1579622400000对应的时间为2020-01-22 00:00:00。当策略程序运行时刻超过该时间之后、且在下一条数据的时间戳1579708800000（即时间2020-01-23 00:00:00）之前，调用exchange.GetData()函数获取到的均为[1579622400000, 123]这条数据的内容。随着程序继续运行、时间推移，以此类推即可逐条获取数据。

在以下例子中，运行时（回测或实盘）当前时刻到达或超过1579795200000这个时间戳时，调用exchange.GetData()函数，返回值为：{"Time":1579795200000,"Data":["abc",123,{"price":123}]}。其中"Time":1579795200000对应数据[1579795200000, ["abc", 123, {"price": 123}]]中的1579795200000；"Data":["abc",123,{"price":123}]对应数据[1579795200000, ["abc", 123, {"price": 123}]]中的["abc", 123, {"price": 123}]。

    javascript
    
    
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    var data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000)
    }
}

    python
    
    
'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''

def main():
    data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000)

    rust
    
    
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

fn main() {
    // Rust SDK 中SetData的数据参数为JSON字符串
    let data = r#"[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]"#;
    exchange.SetData("test", data);
    loop {
        Log!(exchange.GetData("test"));
        Sleep(1000);
    }
}

    c++
    
    
/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/

void main() {
    json data = R"([
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ])"_json;

    exchange.SetData("test", data);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000);
    }
}

返回值

参数

参考

备注

加载的数据可以是任何经济指标、行业数据、相关指数等，用于在策略中量化评估各类可量化的信息。

exchange.GetData

exchange.GetData()函数用于获取由exchange.SetData()函数加载的数据，或外部链接提供的数据。

    
    
    
exchange.GetData(key)

    
    
    
exchange.GetData(key, timeout)

示例

• 获取直接写入数据的调用方式。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  function main() {
      exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
      while(true) {
          Log(exchange.GetData("test"))
          Sleep(1000 * 60 * 60 * 24)
      }
  }
  

  
      python
      
      
  '''backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  '''
  def main():
      exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
      while True:
          Log(exchange.GetData("test"))
          Sleep(1000 * 60 * 60 * 24)
  

  
      rust
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  fn main() {
      // Rust SDK 中SetData的数据参数为JSON字符串，使用format!拼接数据
      let data = format!(r#"[[1579536000000, "{}"], [1579622400000, "{}"], [1579708800000, "{}"]]"#, _D(1579536000000), _D(1579622400000), _D(1579708800000));
      exchange.SetData("test", &data);
      loop {
          Log!(exchange.GetData("test"));
          Sleep(1000 * 60 * 60 * 24);
      }
  }
  

  
      c++
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  void main() {
      json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
      arr[0][1] = _D(1579536000000);
      arr[1][1] = _D(1579622400000);
      arr[2][1] = _D(1579708800000);
      exchange.SetData("test", arr);
      while(true) {
          Log(exchange.GetData("test"));
          Sleep(1000 * 60 * 60 * 24);
      }
  }
  

• 支持通过外部链接请求数据，请求返回的数据格式如下：

  
              json
              
              
  {
      "schema":["time","data"],
      "data":[
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
  }
  

  其中schema定义了数据主体中每条记录的数据格式，该格式固定为["time","data"]，与data属性中逐条数据的格式一一对应。data属性用于存储数据主体，每条数据由毫秒级时间戳和数据内容构成（数据内容可以是任何可JSON编码的数据）。

  以下是使用Go语言编写的测试服务程序：

  
              golang
              
              
  package main
  
  import (
      "fmt"
      "net/http"
      "encoding/json"
  )
  
  func Handle (w http.ResponseWriter, r *http.Request) {
      defer func() {
          fmt.Println("req:", *r)
          ret := map[string]interface{}{
              "schema": []string{"time","data"},
              "data": []interface{}{
                  []interface{}{1579536000000, "abc"},
                  []interface{}{1579622400000, 123},
                  []interface{}{1579708800000, map[string]interface{}{"price":123}},
                  []interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
              },
          }
          b, _ := json.Marshal(ret)
          w.Write(b)
      }()
  }
  
  func main () {
      fmt.Println("listen http://localhost:9090")
      http.HandleFunc("/data", Handle)
      http.ListenAndServe(":9090", nil)
  }
  

  程序接收到请求后返回的应答数据：

  
              json
              
              
  {
      "schema":["time","data"],
      "data":[
          [1579536000000, "abc"],
          [1579622400000, 123],
          [1579708800000, {"price": 123}],
          [1579795200000, ["abc", 123, {"price": 123}]]
      ]
  }
  

  测试策略代码如下：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  function main() {
      while(true) {
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
          Sleep(1000)
      }
  }
  

  
      python
      
      
  '''backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  '''
  
  def main():
      while True:
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
          Sleep(1000)
  

  
      rust
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  
  fn main() {
      loop {
          Log!(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
          Sleep(1000);
      }
  }
  

  
      c++
      
      
  /*backtest
  start: 2020-01-21 00:00:00
  end: 2020-02-12 00:00:00
  period: 1d
  basePeriod: 1d
  exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
  */
  
  void main() {
      while(true) {
          Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
          Sleep(1000);
      }
  }
  

• 获取外部链接数据的调用方式。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
  }
  

  
      python
      
      
  def main():
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
  

  
      rust
      
      
  fn main() {
      Log!(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
      Log!(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
  }
  

  
      c++
      
      
  void main() {
      Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
      Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
  }
  

• 请求在datadata平台上创建的查询数据，应答的数据格式需满足以下要求（schema中必须描述time和data字段）：

  
              json
              
              
  {
      "data": [],
      "schema": ["time", "data"]
  }
  

  其中"data"字段为所需的数据内容，且"data"字段中的数据须与"schema"中约定的字段一致。调用exchange.GetData()函数时，将返回一个JSON对象，例如：{"Time":1579795200000, "Data":"..."}。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))   // 链接中xxx部分为查询数据的编码，此处xxx仅为示例
  }
  

  
      python
      
      
  def main():
      Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))
  

  
      rust
      
      
  fn main() {
      Log!(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));   // 链接中xxx部分为查询数据的编码，此处xxx仅为示例
  }
  

  
      c++
      
      
  void main() {
      Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"));
  }
  

返回值

参数

参考

备注

回测时一次性获取数据，实盘时缓存一分钟的数据。在回测系统中，当使用访问接口请求数据的方式时，回测系统会自动为请求添加from(时间戳，单位秒)、to(时间戳，单位秒)、period(底层K线周期，时间戳，单位毫秒)等参数，用于确定要获取数据的时间范围。

exchange.GetMarkets

exchange.GetMarkets()函数用于获取交易所的市场信息。

    
    
    
exchange.GetMarkets()

示例

• 期货交易所对象的调用示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var markets = exchange.GetMarkets()
      var currency = exchange.GetCurrency()
  
      // 获取当前合约代码也可以使用exchange.GetContractType()函数
      var ct = "swap"
  
      var key = currency + "." + ct
      Log(key, ":", markets[key])
  }
  

  
      python
      
      
  def main():
      markets = exchange.GetMarkets()
      currency = exchange.GetCurrency()
      ct = "swap"
  
      key = currency + "." + ct
      Log(key, ":", markets[key])
  

  
      rust
      
      
  fn main() {
      let markets = exchange.GetMarkets();
      let currency = exchange.GetCurrency();
  
      // 获取当前合约代码也可以使用exchange.GetContractType()函数
      let ct = "swap";
  
      let key = format!("{}.{}", currency, ct);
      Log!(key, ":", format!("{:?}", markets.get(&key)));
  }
  

  
      c++
      
      
  void main() {
      auto markets = exchange.GetMarkets();
      auto currency = exchange.GetCurrency();
  
      auto ct = "swap";
      auto key = currency + "." + ct;
      Log(key, ":", markets[key]);
  }
  

• 在回测系统中，使用期货交易所对象调用exchange.GetMarkets()函数。在调用任何行情函数之前，GetMarkets仅返回当前默认交易对的market数据；在调用行情函数之后，则会返回所有已请求过品种的market数据。可参考以下测试示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2023-05-10 00:00:00
  end: 2023-05-20 00:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  */
  
  function main() {
      var arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
  
      var tbl1 = {
          type: "table",
          title: "markets1",
          cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          rows: []
      }
  
      var markets1 = exchange.GetMarkets()
      for (var key in markets1) {
          var market = markets1[key]
          tbl1.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
      }
  
      for (var symbol of arrSymbol) {
          exchange.GetTicker(symbol)
      }
  
      var tbl2 = {
          type: "table",
          title: "markets2",
          cols: ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          rows: []
      }
  
      var markets2 = exchange.GetMarkets()
      for (var key in markets2) {
          var market = markets2[key]
          tbl2.rows.push([key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal])
      }
  
      LogStatus("`" + JSON.stringify([tbl1, tbl2]) + "`")
  }
  

  
      python
      
      
  '''backtest
  start: 2023-05-10 00:00:00
  end: 2023-05-20 00:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  '''
  
  import json
  
  def main():
      arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
  
      tbl1 = {
          "type": "table",
          "title": "markets1",
          "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          "rows": []
      }
  
      markets1 = exchange.GetMarkets()
      for key in markets1:
          market = markets1[key]
          tbl1["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
  
      for symbol in arrSymbol:
          exchange.GetTicker(symbol)
  
      tbl2 = {
          "type": "table",
          "title": "markets2",
          "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          "rows": []
      }
  
      markets2 = exchange.GetMarkets()
      for key in markets2:
          market = markets2[key]
          tbl2["rows"].append([key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]])
  
      LogStatus("`" + json.dumps([tbl1, tbl2]) + "`")
  

  
      rust
      
      
  /*backtest
  start: 2023-05-10 00:00:00
  end: 2023-05-20 00:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  */
  
  fn marketToJson(key: &str, market: &Market) -> String {
      format!(r#"["{}", "{}", "{}", "{}", {}, {}, {}, {}, {}, {}, {}, {}, {}]"#, key, market.Symbol, market.BaseAsset, market.QuoteAsset, market.TickSize, market.AmountSize, market.PricePrecision, market.AmountPrecision, market.MinQty, market.MaxQty, market.MinNotional, market.MaxNotional, market.CtVal)
  }
  
  fn main() {
      let arrSymbol = ["SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"];
  
      // Rust SDK 没有JSON序列化功能，此处使用format!拼接表格的JSON文本
      let markets1 = exchange.GetMarkets();
      let mut rows1: Vec<String> = Vec::new();
      for (key, market) in &markets1 {
          rows1.push(marketToJson(key, market));
      }
      let tbl1 = format!(r#"{{"type": "table", "title": "markets1", "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"], "rows": [{}]}}"#, rows1.join(","));
  
      for symbol in arrSymbol {
          exchange.GetTicker(symbol);
      }
  
      let markets2 = exchange.GetMarkets();
      let mut rows2: Vec<String> = Vec::new();
      for (key, market) in &markets2 {
          rows2.push(marketToJson(key, market));
      }
      let tbl2 = format!(r#"{{"type": "table", "title": "markets2", "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"], "rows": [{}]}}"#, rows2.join(","));
  
      LogStatus!(format!("`[{},{}]`", tbl1, tbl2));
  }
  

  
      c++
      
      
  /*backtest
  start: 2023-05-10 00:00:00
  end: 2023-05-20 00:00:00
  period: 1m
  basePeriod: 1m
  exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
  */
  
  void main() {
      auto arrSymbol = {"SOL_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
  
      json tbl1 = R"({
          "type": "table",
          "title": "markets1",
          "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          "rows": []
      })"_json;
  
      auto markets1 = exchange.GetMarkets();
      for (auto& [key, market] : markets1.items()) {
          json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
          tbl1["rows"].push_back(arrJson);
      }
  
      for (const auto& symbol : arrSymbol) {
          exchange.GetTicker(symbol);
      }
  
      json tbl2 = R"({
          "type": "table",
          "title": "markets2",
          "cols": ["key", "Symbol", "BaseAsset", "QuoteAsset", "TickSize", "AmountSize", "PricePrecision", "AmountPrecision", "MinQty", "MaxQty", "MinNotional", "MaxNotional", "CtVal"],
          "rows": []
      })"_json;
  
      auto markets2 = exchange.GetMarkets();
      for (auto& [key, market] : markets2.items()) {
          json arrJson = {key, market["Symbol"], market["BaseAsset"], market["QuoteAsset"], market["TickSize"], market["AmountSize"], market["PricePrecision"], market["AmountPrecision"], market["MinQty"], market["MaxQty"], market["MinNotional"], market["MaxNotional"], market["CtVal"]};
          tbl2["rows"].push_back(arrJson);
      }
  
      json tbls = R"([])"_json;
      tbls.push_back(tbl1);
      tbls.push_back(tbl2);
      LogStatus("`" + tbls.dump() + "`");
  }
  

返回值

参考

备注

exchange.GetMarkets()函数的返回值为一个字典。对于现货交易所，键名为交易品种名称，格式固定为交易对，例如：

            json
            
            
{
    "BTC_USDT" : {...},  // 键值为Market结构
    "LTC_USDT" : {...},
    ...
}

对于期货合约交易所而言，由于同一品种可能存在多个合约，例如BTC_USDT交易对包含永续合约、季度合约等，因此exchange.GetMarkets()函数返回的字典中，键名为交易对与合约代码的组合，例如：

            json
            
            
{
    "BTC_USDT.swap" : {...},     // 键值为Market结构
    "BTC_USDT.quarter" : {...},
    "LTC_USDT.swap" : {...},
    ...
}

• exchange.GetMarkets()函数支持实盘与回测系统。
• exchange.GetMarkets()函数仅返回交易所已上线交易品种的市场信息。
• exchange.GetMarkets()函数不支持期权合约。

不支持exchange.GetMarkets()函数的交易所：

exchange.GetTickers

exchange.GetTickers()函数用于获取交易所的聚合行情数据（Ticker结构的数组）。当exchange为现货交易所对象时，返回所有交易对的 ticker 行情数据；当exchange为期货交易所对象时，返回所有合约的 ticker 行情数据。

    
    
    
exchange.GetTickers()

示例

• 调用 exchange.GetTickers() 函数，获取聚合行情数据。

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main() {
      var tickers = exchange.GetTickers()
      if (tickers && tickers.length > 0) {
          Log("Number of tradable symbols:", tickers.length)
      }
  }
  

  
      python
      
      
  def main():
      tickers = exchange.GetTickers()
      if tickers and len(tickers) > 0:
          Log("Number of tradable symbols:", len(tickers))
  

  
      rust
      
      
  fn main() {
      if let Ok(tickers) = exchange.GetTickers() {
          if tickers.len() > 0 {
              Log!("Number of tradable symbols:", tickers.len());
          }
      }
  }
  

  
      c++
      
      
  void main() {
      auto tickers = exchange.GetTickers();
      if (tickers.Valid && tickers.size() > 0) {
          Log("Number of tradable symbols:", tickers.size());
      }
  }
  

• 使用现货交易所对象，在回测系统中调用exchange.GetTickers()函数。在调用任何行情函数之前，GetTickers仅返回当前默认交易对的ticker数据；在调用行情函数之后，则会返回所有已请求过的交易对的ticker数据。可参考以下测试示例：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  */
  
  function main() {
      var arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
  
      // 请求其它交易对行情数据之前，调用GetTickers
      var tickers1 = exchange.GetTickers()
      var tbl1 = {type: "table", title: "tickers1", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
      for (var ticker of tickers1) {
          tbl1.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
      }
  
      // 请求其它交易对行情数据
      for (var symbol of arrSymbol) {
          exchange.GetTicker(symbol)
      }
  
      // 再次调用GetTickers
      var tickers2 = exchange.GetTickers()
      var tbl2 = {type: "table", title: "tickers2", cols: ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], rows: []}
      for (var ticker of tickers2) {
          tbl2.rows.push([ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume])
      }
  
      LogStatus("`" + JSON.stringify([tbl1, tbl2]) +  "`")
  }
  

  
      python
      
      
  '''backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  '''
  
  import json
  
  def main():
      arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"]
  
      tickers1 = exchange.GetTickers()
      tbl1 = {"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
      for ticker in tickers1:
          tbl1["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
  
      for symbol in arrSymbol:
          exchange.GetTicker(symbol)
  
      tickers2 = exchange.GetTickers()
      tbl2 = {"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": []}
      for ticker in tickers2:
          tbl2["rows"].append([ticker["Symbol"], ticker["High"], ticker["Open"], ticker["Low"], ticker["Last"], ticker["Buy"], ticker["Sell"], ticker["Time"], ticker["Volume"]])
  
      LogStatus("`" + json.dumps([tbl1, tbl2]) +  "`")
  

  
      rust
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  */
  
  fn tickerToJson(ticker: &Ticker) -> String {
      format!(r#"["{}", {}, {}, {}, {}, {}, {}, {}, {}]"#, ticker.Symbol, ticker.High, ticker.Open, ticker.Low, ticker.Last, ticker.Buy, ticker.Sell, ticker.Time, ticker.Volume)
  }
  
  fn main() {
      let arrSymbol = ["ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"];
  
      // 请求其它交易对行情数据之前，调用GetTickers
      // Rust SDK 没有JSON序列化，使用format!拼接表格的JSON文本
      let tickers1 = exchange.GetTickers().unwrap();
      let rows1 = tickers1.iter().map(tickerToJson).collect::<Vec<String>>().join(",");
      let tbl1 = format!(r#"{{"type": "table", "title": "tickers1", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": [{}]}}"#, rows1);
  
      // 请求其它交易对行情数据
      for symbol in arrSymbol {
          exchange.GetTicker(symbol);
      }
  
      // 再次调用GetTickers
      let tickers2 = exchange.GetTickers().unwrap();
      let rows2 = tickers2.iter().map(tickerToJson).collect::<Vec<String>>().join(",");
      let tbl2 = format!(r#"{{"type": "table", "title": "tickers2", "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"], "rows": [{}]}}"#, rows2);
  
      LogStatus!(format!("`[{},{}]`", tbl1, tbl2));
  }
  

  
      c++
      
      
  /*backtest
  start: 2024-05-21 00:00:00
  end: 2024-09-05 00:00:00
  period: 5m
  basePeriod: 1m
  exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
  */
  
  json tickerToJson(const Ticker& ticker) {
      json arrJson;
  
      arrJson.push_back(ticker.Symbol);
      arrJson.push_back(ticker.High);
      arrJson.push_back(ticker.Open);
      arrJson.push_back(ticker.Low);
      arrJson.push_back(ticker.Last);
      arrJson.push_back(ticker.Buy);
      arrJson.push_back(ticker.Sell);
      arrJson.push_back(ticker.Time);
      arrJson.push_back(ticker.Volume);
  
      return arrJson;
  }
  
  void main() {
      std::string arrSymbol[] = {"ADA_USDT", "LTC_USDT", "ETH_USDT", "SOL_USDT"};
  
      auto tickers1 = exchange.GetTickers();
      json tbl1 = R"({
          "type": "table",
          "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
          "rows": []
      })"_json;
      tbl1["title"] = "tickers1";
  
      for (const auto& ticker : tickers1) {
          json arrJson = tickerToJson(ticker);
          tbl1["rows"].push_back(arrJson);
      }
  
      for (const std::string& symbol : arrSymbol) {
          exchange.GetTicker(symbol);
      }
  
      auto tickers2 = exchange.GetTickers();
      json tbl2 = R"({
          "type": "table",
          "cols": ["Symbol", "High", "Open", "Low", "Last", "Buy", "Sell", "Time", "Volume"],
          "rows": []
      })"_json;
      tbl2["title"] = "tickers2";
  
      for (const auto& ticker : tickers2) {
          json arrJson = tickerToJson(ticker);
          tbl2["rows"].push_back(arrJson);
      }
  
      json tbls = R"([])"_json;
      tbls.push_back(tbl1);
      tbls.push_back(tbl2);
      LogStatus("`" + tbls.dump() + "`");
  }
  

返回值

参考

备注

注意事项：

• 该函数请求交易所的聚合行情接口，调用前无需设置交易对或合约代码，且仅返回交易所已上线交易品种的行情数据。

• 回测系统支持该函数。

• 未提供聚合行情接口的交易所对象不支持该函数。

• 该函数不支持期权合约。

不支持exchange.GetTickers()函数的交易所：