बाजार

exchange.GetTicker

वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी टिकर डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Ticker Ticker} संरचना प्राप्त करें।GetTicker ()फ़ंक्शन एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} का सदस्य फ़ंक्शन है,exchangeऑब्जेक्ट सदस्य फ़ंक्शन (विधि) केवल संबंधित हैंexchange, और यह दस्तावेज़ में दोहराया नहीं जाएगा।

..exchange.GetTicker()फ़ंक्शन {@struct/Ticker Ticker} संरचना देता है जब डेटा के लिए अनुरोध सफल होता है, और शून्य मान देता है जब डेटा के लिए अनुरोध विफल होता है. {@struct/Ticker Ticker}, शून्य मान

विनिमय.GetTicker() विनिमय.GetTicker ((प्रतीक)

पैरामीटरsymbol{@struct/Ticker Ticker} डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के बाजार डेटा को डिफ़ॉल्ट रूप से अनुरोध किया जाएगा। जब कॉलexchange.GetTicker(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में ट्रेडिंग मुद्रा के साथ बाजार डेटा का अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है। जब कॉलexchange.GetTicker(symbol)कार्य,exchangeहै वायदा विनिमय वस्तु. यदि आप BTC के यू मानक स्थायी अनुबंध के बाजार डेटा का अनुरोध करने की जरूरत है, पैरामीटरsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडएफएमजेड प्लेटफॉर्म द्वारा परिभाषित किया गया है, जिसे . अक्षर से अलग किया गया है। जब कॉलexchange.GetTicker(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू-मानक विकल्प अनुबंध के बाजार डेटा का अनुरोध करने की जरूरत है, पैरामीटरsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण . द्वारा अलग किया गया है।

चिह्न झूठी स्ट्रिंग

function main(){
    // If it is a futures exchange object, set the contract code first, e.g. set it as a perpetual contract
    // exchange.SetContractType("swap")

    var ticker = exchange.GetTicker()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, the ticker is null, and it will cause an error when accessing ticker.High, so when testing this code, make sure that the exchange interface can be accessed.
    */
    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)
}

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"])

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);
}

वायदा विनिमय वस्तुओं के लिए (यानीexchangeयाexchanges[0]), आपको अनुबंध कोड को सेट करने की आवश्यकता हैexchange.SetContractType()टिकर फंक्शन को बुलाने से पहले, जो दोहराया नहीं जाएगा।

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

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

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

उपयोग करेंsymbolएक विशिष्ट प्रतीक के लिए बाजार डेटा का अनुरोध करने के लिए पैरामीटर (स्पॉट प्रतीक) ।

..Tickerद्वारा लौटाए गए डेटाexchange.GetTicker()बैकटेस्टिंग प्रणाली में कार्य करता है।HighऔरLowमूल्य का अनुकरण किया जाता है, जो उस समय बाजार में एक बेचने और एक खरीदने से लिया जाता है।Tickerद्वारा लौटाए गए डेटाexchange.GetTicker()वास्तविक बाजार में कार्य करते हैं।HighऔरLowमूल्यों को कैप्सुलेटेड एक्सचेंज द्वारा लौटाए गए डेटा पर आधारित हैंTickइंटरफेस, जिसमें एक निश्चित अवधि (आमतौर पर 24 घंटे की अवधि) के भीतर उच्चतम और निम्नतम मूल्य शामिल हैं। एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTicker()कार्य:

फ़ंक्शन का नाम	असमर्थित स्पॉट एक्सचेंज	बिना समर्थन वाले फ्यूचर्स एक्सचेंज
GetTicker	–	फ्यूचर्स_एवो

{@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange.GetTickers exchange.GetTickers exchange.GetTickers}, {@fun/Market/exchange

exchange.GetDepth

वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी ऑर्डर बुक डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Depth Depth} संरचना प्राप्त करें।

..exchange.GetDepth()function {@struct/Depth Depth} संरचना को लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य लौटाता है. {@struct/Depth Depth}, शून्य मान

विनिमय.GetDepth() आदान-प्रदान.GetDepth ((प्रतीक)

पैरामीटरsymbol{@struct/Depth Depth} डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के ऑर्डर बुक डेटा का डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetDepth(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में लेनदेन मुद्रा के साथ ऑर्डर बुक डेटा प्राप्त करने के लिए अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetDepth(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू मानक स्थायी अनुबंध के आदेश बुक डेटा का अनुरोध करने की जरूरत है, पैरामीटरsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग ..exchange.GetDepth(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू-मानक विकल्प अनुबंध के आदेश पुस्तिका डेटा का अनुरोध करने की आवश्यकता है, पैरामीटरsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण . द्वारा अलग किया गया है। चिह्न झूठी स्ट्रिंग

function main(){
    var depth = exchange.GetDepth()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, the depth is null, which will cause an error when accessing depth.Asks[1].Price, so make sure you can access the exchange interface when testing the code.
    */
    var price = depth.Asks[1].Price
    Log("Sell 2 price is:", price)
}

def main():
    depth = exchange.GetDepth()
    price = depth["Asks"][1]["Price"]
    Log("Sell 2 price is:", price)

void main() {
    auto depth = exchange.GetDepth();
    auto price = depth.Asks[1].Price;
    Log("Sell 2 price is:", price);
}

परीक्षणexchange.GetDepth()कार्य:

function main() {
    // BTC U-based perpetual contract
    var depth = exchange.GetDepth("BTC_USDT.swap")
    Log(depth)
}

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

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

जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbolएक विशिष्ट प्रतीक (फ्यूचर्स प्रतीक) के ऑर्डर बुक डेटा की मांग करने के लिए पैरामीटर।

बैकटेस्टिंग प्रणाली में, प्रत्येक ग्रेड के लिए डेटाexchange.GetDepth()कार्य करते समयटिक का अनुकरण करेंbacktesting सभी अनुकरणीय मान हैं।exchange.GetDepth()कार्य करते समयअसली टिकबैकटेस्टिंग एक दूसरे स्तर की गहरी झलक है।

{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.GetRecords exchange.GetRecords}

exchange.GetTrades

{@struct/Trade Trade} स्ट्रक्चर सरणी प्राप्त करें जो वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, अर्थात बाजार लेनदेन डेटा के अनुरूप स्पॉट या अनुबंध है।

..exchange.GetTrades()फ़ंक्शन {@struct/Trade Trade} संरचनाओं की एक सरणी लौटाता है यदि डेटा के लिए अनुरोध सफल होता है, और यदि डेटा के लिए अनुरोध विफल होता है तो यह शून्य मान लौटाता है. {@struct/Trade Trade} सरणी, शून्य मान

विनिमय.GetTrades ((() exchange.GetTrades (प्रतीक)

पैरामीटरsymbol{@struct/Trade Trade} सरणी डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के नवीनतम लेनदेन रिकॉर्ड डेटा को डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetTrades(symbol)कार्य,exchangeयदि आपको USDT के रूप में मुद्रा और BTC के रूप में ट्रेडिंग मुद्रा के साथ ऑर्डर बुक डेटा प्राप्त करने का अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetTrades(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू मानक स्थायी अनुबंध के आदेश बुक डेटा का अनुरोध करने की जरूरत है, पैरामीटरsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग ..exchange.GetTrades(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू-मानक विकल्प अनुबंध के आदेश पुस्तिका डेटा का अनुरोध करने की आवश्यकता है, पैरामीटरsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण . द्वारा अलग किया गया है। चिह्न झूठी स्ट्रिंग

function main(){
    var trades = exchange.GetTrades()
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, trade is null. When accessing trade[0].Id, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
    */
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}

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"])

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.GetTrades()कार्य:

function main() {
    // BTC's U-based perpetual contract
    var trades = exchange.GetTrades("BTC_USDT.swap")
    Log(trades)
}

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

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

जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbolएक विशिष्ट प्रतीक (फ्यूचर्स प्रतीक) के लिए बाजार लेनदेन रिकॉर्ड डेटा का अनुरोध करने के लिए पैरामीटर।

The ```exchange.GetTrades()``` function returns an empty array when using **Simulate Tick** backtesting in the backtesting system. The data returned by the ```exchange.GetTrades()``` function when using **Real Tick** backtesting in the backtesting system is the order flow snapshot data, i.e. the {@struct/Trade Trade} structure array.
Exchanges that do not support the ```exchange.GetTrades()``` function:
| Function Name | Unsupported Spot Exchanges | Unsupported Futures Exchanges |
| - | - | - |
| GetTrades | -- | Futures_BitMart / Futures_Bibox |


{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetRecords exchange.GetRecords}

### exchange.GetRecords

Get the {@struct/Record Record} structure array of the spot or contract corresponding to the currently set trading pair, contract code, i.e. K-line data.

The ```exchange.GetRecords()``` function returns an array of {@struct/Record Record} structures when the request for data succeeds, and it returns null values when the request for data fails.
{@struct/Record Record}arrays, null values

exchange.GetRecords()
exchange.GetRecords(symbol)
exchange.GetRecords(symbol, period)
exchange.GetRecords(symbol, period, limit)
exchange.GetRecords(period)
exchange.GetRecords(period, limit)

The parameter ```symbol``` is used to specify the specific trading pair and contract code corresponding to the requested {@struct/Record Record} array data. If this parameter is not passed, the K-line data of the currently set trading pair and contract code will be requested by default. When calling the ```exchange.GetRecords(symbol)``` function, ```exchange``` is the spot exchange object. If you need to request to obtain the data with the denominated currency as USDT and the transaction currency as BTC, the parameter ```symbol``` is: ```"BTC_USDT"```, and the format is the trading pair format defined by the FMZ platform. When calling the ```exchange.GetRecords(symbol)``` function, ```exchange``` is the futures exchange object. If you need to request the order book data of BTC's U-standard perpetual contract, the parameter ```symbol``` is: ```"BTC_USDT.swap"```, and the format is a combination of the **trading pair** and **contract code** defined by the FMZ platform, separated by the character ".". When calling the ```exchange.GetRecords(symbol)``` function, ```exchange``` is the futures exchange object. If you need to request the order book data of BTC's U-standard option contract, the parameter ```symbol``` is: ```"BTC_USDT.BTC-240108-40000-C"``` (taking Binance Option BTC-240108-40000-C as an example), the format is the combination of the **trading pair** defined by the FMZ platform and the specific option contract code defined by the exchange, separated by the character ".".
symbol
false
string
The parameter ```period``` specifies the period of the requested K-line data, for example: {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15}, etc. The value of parameter ```period``` can be passed not only the defined standard period, but also integer values in seconds. If this parameter is not passed, the period of the K-line data requested by default is the default K-line period of the current strategy real-time/backtest configuration.
period
false
number
The parameter ```limit``` is used to specify the length of the requested K-line data. If this parameter is not passed, the default request length is the maximum number of K-line bars requested at a time of the exchange K-line interface. This parameter may cause paging to query the exchange K-line data, and the time consumption of the function call will increase during paging query.
limit
false
number

```javascript
function main() {
    // Print K-line data with a K-line period of 120 seconds (2 minutes)
    Log(exchange.GetRecords(60 * 2))         
    // Print K-line data with a K-line period of 5 minutes
    Log(exchange.GetRecords(PERIOD_M5))      
}

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

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

कस्टम अवधि के लिए के-लाइन डेटा प्राप्त करें।

function main() {
    var records = exchange.GetRecords(PERIOD_H1)
    /*
        The exchange interface may not be accessible due to network reasons (even if the docker program's device can open the exchange website, the API interface may not be accessible).
        At this point, records is null. When accessing records[0].Time, it will cause an error. Therefore, when testing this code, ensure that you can access the exchange interface.
    */
    Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
    Log("The second k-line data is Time:", records[1].Time ,"Close:", records[1].Close)
    Log("Current K-line (latest)", records[records.length-1], "Previous K-line", records[records.length-2])
}

def main():
    records = exchange.GetRecords(PERIOD_H1)
    Log("The first k-line data is Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
    Log("The second k-line data Time:", records[1]["Time"], "Close:", records[1]["Close"])
    Log("Current K-line (latest)", records[-1], "Previous K-line", records[-2])

void main() {
    auto records = exchange.GetRecords(PERIOD_H1);
    Log("The first k-line data is Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
    Log("The 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]);
}

आउटपुट K-लाइन बार डेटाः

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

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

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

जब विन्यस्तexchangeवस्तु एक वायदा विनिमय वस्तु है, का उपयोग करेंsymbol, period, औरlimitकिसी विशिष्ट उत्पाद (भविष्य के उत्पाद) के के-लाइन डेटा की मांग करने के लिए मापदंड।

डिफ़ॉल्ट के-लाइन अवधि बैकटेस्ट और वास्तविक व्यापार पृष्ठों में सेट किया जा सकता है.exchange.GetRecords()फ़ंक्शन, उस पैरामीटर अवधि के अनुरूप K-लाइन डेटा प्राप्त किया जाएगा. यदि कोई पैरामीटर फ़ंक्शन बुलाया जाता है जब निर्दिष्ट नहीं है, संबंधित K-लाइन डेटा बैकटेस्ट और वास्तविक बाजार मापदंडों में सेट K-लाइन अवधि के अनुसार लौटाया जाएगा. रिटर्न मान के एक सरणी हैRecordसंरचनाओं, लौटाए गए K-लाइन डेटा समय के साथ जमा हो जाएगा, संचित K-लाइन सलाखों की ऊपरी सीमाexchange.SetMaxBarLen()फ़ंक्शन सेटिंग. डिफ़ॉल्ट सीमा 5000 बार है जब यह सेट नहीं है. जब K-लाइन डेटा K-लाइन बार संचय सीमा तक पहुंचता है, तो इसे K-लाइन बार जोड़कर और सबसे पहले K-लाइन बार (जैसे कतार में / बाहर) को हटाकर अपडेट किया जाएगा। कुछ एक्सचेंजों में K-लाइन इंटरफ़ेस प्रदान नहीं किया जाता है, इसलिए डॉकर बाजार लेनदेन रिकॉर्ड डेटा एकत्र करता है (Tradeसंरचित सरणी) वास्तविक समय में K-रेखा उत्पन्न करने के लिए। यदि एक्सचेंज के के-लाइन इंटरफ़ेस पेजिंग क्वेरी का समर्थन करता है, तो कई एपीआई अनुरोध किए जाएंगे जब कॉल किया जाएगाexchange.SetMaxBarLen()एक बड़ी K-लाइन लंबाई सेट करने के लिए समारोह. जबexchange.GetRecords()यदि प्रारंभ में फ़ंक्शन को बुलाया जाता है, तो प्राप्त K-लाइन बार की संख्या बैकटेस्टिंग और वास्तविक ट्रेडिंग के बीच भिन्न होती हैः - बैकटेस्टिंग सिस्टम बैकटेस्टिंग समय सीमा की शुरुआत से पहले एक निश्चित संख्या में K-लाइन बार प्राप्त करेगा (डिफ़ॉल्ट 5000 है, बैकटेस्टिंग सिस्टम की सेटिंग्स और डेटा की मात्रा अंतिम संख्या को प्रभावित करेगी), प्रारंभिक K-लाइन डेटा के रूप में। - वास्तविक ट्रेडिंग के दौरान प्राप्त K-लाइन बार की संख्या एक्सचेंज के K-लाइन इंटरफ़ेस से प्राप्त किए जा सकने वाले डेटा की अधिकतम मात्रा पर आधारित है। दperiodपैरामीटर 5 पर सेट है, जो 5 सेकंड की अवधि के साथ K-लाइन डेटा प्राप्त करने के लिए एक अनुरोध है।periodपैरामीटर 60 से विभाजित नहीं है (यानी, प्रतिनिधित्व की गई अवधि मिनटों से विभाजित नहीं है) ।exchange.GetTrades()लेन-देन रिकॉर्ड डेटा प्राप्त करने और आवश्यक के-लाइन डेटा को संश्लेषित करने के लिए।periodपैरामीटर 60 से विभाजित है, तो आवश्यक K-लाइन डेटा कम से कम 1 मिनट के K-लाइन डेटा का उपयोग करके संश्लेषित किया जाता है (यदि संभव हो, तो आवश्यक K-लाइन डेटा को एक बड़ी अवधि का उपयोग करके संश्लेषित किया जाता है) । बैकटेस्टिंग प्रणाली में अनुकरणीय स्तर बैकटेस्टिंग के लिए अंतर्निहित के-लाइन अवधि की सेटिंग की आवश्यकता होती है (जब बैकटेस्टिंग प्रणाली स्तर बैकटेस्टिंग का अनुकरण करती है, तो संबंधित के-लाइन डेटा का उपयोग सेट अंतर्निहित के-लाइन अवधि के अनुसार टिक डेटा उत्पन्न करने के लिए किया जाता है) । यह ध्यान दिया जाना चाहिए कि रणनीति में प्राप्त के-लाइन डेटा की अवधि अंतर्निहित के-लाइन अवधि से कम नहीं होनी चाहिए। क्योंकि सिमुलेशन स्तर बैकटेस्टिंग में, बैकटेस्टिंग प्रणाली में प्रत्येक अवधि के के-लाइन डेटा को अंतर्निहित के-लाइन अवधि के के-लाइन डेटा से संश्लेषित किया जाता है। दC++भाषा में निम्न कोड उदाहरण है यदि आपको अपने स्वयं के K-लाइन डेटा का निर्माण करने की आवश्यकता है:

#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);
    }
    // Output display: Records[10]
    Log(r);                      
    auto ma = TA.MA(r,10);       
    // Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);                     
}

एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetRecords()कार्य:

फ़ंक्शन का नाम	असमर्थित स्पॉट एक्सचेंज	बिना समर्थन वाले फ्यूचर्स एक्सचेंज
GetRecords	Zaif / Coincheck / BitFlyer	फ्यूचर्स_एवो

{@fun/Market/exchange.GetTicker exchange.GetTicker}, {@fun/Market/exchange.GetDepth exchange.GetDepth}, {@fun/Market/exchange.GetTrades exchange.GetTrades}, {@fun/Market/exchange.SetMaxBarLen exchange.SetMaxBarLen}

exchange.GetPeriod

एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म वेबसाइट पेज पर सेट की गई के-लाइन अवधि प्राप्त करें जब बैकटेस्टिंग और लाइव ट्रेडिंग में रणनीति चल रही है, अर्थात डिफ़ॉल्ट के-लाइन अवधि का उपयोग जब कॉल किया जाता हैexchange.GetRecords()पैरामीटर पास किए बिना कार्य करता है।

सेकंड में के-लाइन अवधि, सेकंड में पूर्णांक मान। संख्या

विनिमय.GetPeriod (()

function main() {
    // For example, the K-line period set on the website page of the FMZ Quant Trading platform during backtesting and live trading is 1 hour.
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hours")
}

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

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

{@मज़ा/बाजार/विनिमय.GetRecordsविनिमय.GetRecords}

exchange.SetMaxBarLen

के-लाइन की अधिकतम लंबाई सेट करें.

विनिमय.SetMaxBarLen ((n)

पैरामीटरnअधिकतम के-लाइन लंबाई निर्दिष्ट करने के लिए प्रयोग किया जाता है। n सच संख्या

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

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

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

..exchange.SetMaxBarLen()यह क्रिया क्रिप्टोक्यूरेंसी रणनीति रनटाइम के दो पहलुओं को प्रभावित करती हैः - पहली कॉल पर प्राप्त होने वाले K-लाइन बार (Bars) की संख्या को प्रभावित करता है। - के-लाइन बार (बार) की अधिकतम संख्या को प्रभावित करता है।

{@मज़ा/बाजार/विनिमय.GetRecordsविनिमय.GetRecords}

exchange.GetRawJSON

मूल सामग्री को अंतिम समय तक लौटाएंrestवर्तमान विनिमय वस्तु के लिए अनुरोध ({@var/EXCHANGE exchange}, {@var/EXCHANGE/exchanges exchanges}).

उत्तर के आंकड़ेrestअनुरोध। स्ट्रिंग

विनिमय.GetRawJSON()

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

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

void main() {
    auto obj = exchange.GetAccount();
    // C++ does not support the GetRawJSON function
    Log(obj);
}

..exchange.GetRawJSON()यह फ़ंक्शन केवल वास्तविक ट्रेडिंग के लिए समर्थित है।C++ language.

{@var/EXCHANGE विनिमय}

exchange.GetRate

विनिमय वस्तु के लिए वर्तमान में सेट विनिमय दर प्राप्त करें.

विनिमय वस्तु की विनिमय दर का वर्तमान मूल्य। संख्या

विनिमय.GetRate()

function main(){
    Log(exchange.GetTicker())
    // Set up exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    Log("Current exchange rate:", exchange.GetRate())
}

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

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

यदिexchange.SetRate()विनिमय दर निर्धारित करने के लिए नहीं बुलाया गया है,exchange.GetRate()फ़ंक्शन 1 का एक डिफ़ॉल्ट दर मान देता है, यानी वर्तमान में प्रदर्शित मुद्रा (quoteCurrency) से संबंधित डेटा परिवर्तित नहीं किया गया है. यदि विनिमय दर का मूल्य विनिमय दर का उपयोग करके निर्धारित किया गया हैexchange.SetRate()उदाहरण के लिए,exchange.SetRate(7). फिर सभी मूल्य जानकारी, जैसे उद्धरण, गहराई, और आदेश कीमतों के माध्यम से प्राप्तexchangeविनिमय वस्तु को सेट विनिमय दर से गुणा करके परिवर्तित किया जाएगा7. यदिexchangeकॉल करने के बाद मुद्रा के रूप में USD के साथ एक विनिमय के अनुरूप हैexchange.SetRate(7), लाइव बाजार में सभी कीमतों को सीएनवाई के करीब मूल्य में गुणा करके परिवर्तित किया जाएगा7इस बिंदु पर, विनिमय दर मूल्य का उपयोग करके प्राप्तexchange.GetRate()है7.

{@fun/Trade/exchange.SetRate exchange.SetRate}

exchange.SetData

..exchange.SetData()फ़ंक्शन का उपयोग रणनीति चल रही है जब लोड डेटा सेट करने के लिए किया जाता है.

पैरामीटर के बाद स्ट्रिंग की लंबाईvalueJSON एन्कोडिंग. संख्या

exchange.SetData ((कुंजी, मान)

डेटा संग्रह का नाम। कुंजी सच स्ट्रिंग डेटा को लोड करने के लिएexchange.SetData()फ़ंक्शन के पास एक सरणी का डेटा संरचना है। डेटा संरचना उसी डेटा प्रारूप के समान है जिसे फ़ंक्शन द्वारा अनुरोध किया गया है।exchange.GetData()बाह्य डेटा का अनुरोध करते समय कार्य, अर्थातः"schema": ["time", "data"]. मूल्य सच सरणी

/*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)
    }
}

'''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)

/*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);
    }
}

यह आवश्यक है कि पैरामीटर के लिए डेटाvalueएक ही प्रारूप में होना चाहिएdataआप देख सकते हैं कि समयस्टैम्प1579622400000समय से मेल खाती है2020-01-22 00:00:00, और जब रणनीति कार्यक्रम इस समय के बाद चलाया जाता है, कॉलexchange.GetData()अगले डेटा टाइमस्टैम्प से पहले डेटा प्राप्त करने के लिए समारोह1579708800000, यानी समय2020-01-23 00:00:00. क्या आप प्राप्त कर रहे हैं[1579622400000, 123]उस डेटा की सामग्री, के रूप में कार्यक्रम चल रहा है, समय बदल जाता है, और इतने पर आइटम द्वारा डेटा आइटम प्राप्त करने के लिए. निम्नलिखित उदाहरण में, रनटाइम (बैकटेस्टिंग या लाइव ट्रेडिंग) में, वर्तमान क्षण तक पहुँचता है या समय से अधिक है1579795200000,exchange.GetData()फ़ंक्शन बुलाया जाता है और रिटर्न मान हैः{"Time":1579795200000,"Data":["abc", 123,{"price":123}]}. "Time":1579795200000से मेल खाती है1579795200000आंकड़ों में[1579795200000, ["abc", 123, {"price": 123}]]. "Data":["abc", 123, {"price": 123}]डेटा से मेल खाता है["abc", 123, {"price": 123}]]में[1579795200000, ["abc", 123, {"price": 123}]].

लोड किए गए डेटा किसी भी आर्थिक संकेतक, उद्योग के डेटा, प्रासंगिक संकेतक आदि हो सकते हैं, जिनका उपयोग सभी परिमाणात्मक जानकारी के रणनीतिक मात्रात्मक मूल्यांकन के लिए किया जाता है।

{@मज़ा/बाजार/विनिमय.GetData विनिमय.GetData}

exchange.GetData

..exchange.GetData()फ़ंक्शन का उपयोग डेटा लोड करने के लिए किया जाता हैexchange.SetData()कार्य या एक बाहरी लिंक द्वारा प्रदान की जाती है।

डेटा संग्रह में रिकॉर्ड। वस्तु

विनिमय.GetData(की) विनिमय.GetData ((कुंजी, टाइमआउट)

डेटा संग्रह का नाम। कुंजी सच स्ट्रिंग लाइव ट्रेडिंग के लिए डिफ़ॉल्ट रूप से एक मिनट केश टाइमआउट पर सेट किया जाता है. टाइमआउट झूठी संख्या

/*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)
    }
}

'''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)

/*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);
    }
}

सीधे डेटा लिखने के लिए कॉल।

/*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)
    }
}

'''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)

/*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);
    }
}

यह बाहरी लिंक के माध्यम से डेटा का अनुरोध करने के लिए समर्थन करता है, अनुरोधित डेटा का प्रारूपः

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

कहाँschemaलोड किए गए डेटा के शरीर में प्रत्येक रिकॉर्ड के लिए डेटा प्रारूप है, जो["time", "data"]जिसमें प्रविष्टि-दर-प्रविष्टि डेटा के प्रारूप के अनुरूपdataविशेषता। क्या संग्रहीत हैdataविशेषता डेटा का शरीर है, जिसमें प्रत्येक प्रविष्टि में एक मिलीसेकंड स्तर का टाइमस्टैम्प और डेटा सामग्री होती है (जो कोई भी JSON- एन्कोडेबल डेटा हो सकती है) । परीक्षण के लिए सेवा कार्यक्रम, गो में लिखा गयाः

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)
}

अनुरोध प्राप्त होने पर कार्यक्रम के प्रतिक्रिया डेटाः

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

परीक्षण रणनीति कोडः

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

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

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

बाहरी लिंक के डेटा प्राप्त करने के लिए कॉल विधि।

function main() {
    Log(exchange.GetData("https://www.datadata.com/api/v1/query/xxx/data"))   // The xxx part of the link is the code of the query data, here xxx is an example.
}

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

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

प्लेटफ़ॉर्म पर बनाई गई क्वेरी के लिए अनुरोध डेटाडाटाडेटा, अनुरोध है कि उत्तर के डेटा प्रारूप हो (समय होना चाहिए, डेटा क्षेत्रों में वर्णित स्कीमा):

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

data फ़ील्ड आवश्यक डेटा सामग्री है, और data फ़ील्ड में डेटा schema में सहमत होने के समान होना चाहिए।exchange.GetData()फ़ंक्शन बुलाया जाता है, एक JSON ऑब्जेक्ट लौटाया जाता है, उदाहरण के लिएः{"Time":1579795200000, "Data":"..."}.

बैकटेस्टिंग के लिए एक बार में डेटा प्राप्त करें और लाइव ट्रेडिंग के लिए एक मिनट के डेटा को कैश करें। बैकटेस्टिंग प्रणाली में, एक्सेस इंटरफ़ेस का उपयोग करके डेटा का अनुरोध करते समय, बैकटेस्टिंग प्रणाली स्वचालित रूप से जोड़ती हैfrom(सेकंडों में समय मुहर लगाकर),to(सेकंड में समय-स्टैम्प) अनुरोध के लिए, पैरामीटर जैसेperiod(आधारभूत के-लाइन अवधि, मिलीसेकंड में समय-स्टैम्प) का उपयोग उस समय-सीमा को निर्धारित करने के लिए किया जाता है जिस पर डेटा प्राप्त किया जाना है।

{@मज़ा/बाजार/विनिमय.सेटडेटा विनिमय.सेटडेटा}

exchange.GetMarkets

..exchange.GetMarkets()कार्य का उपयोग विनिमय बाजार की जानकारी प्राप्त करने के लिए किया जाता है।

शब्दकोश में {@struct/Market Market} संरचना शामिल है। वस्तु

विनिमय.GetMarkets()

function main() {
    var markets = exchange.GetMarkets()
    var currency = exchange.GetCurrency()

    // Get the current contract code can also use exchange.GetContractType() function
    var ct = "swap"

    var key = currency + "." + ct
    Log(key, ":", markets[key])
}

def main():
    markets = exchange.GetMarkets()
    currency = exchange.GetCurrency()
    ct = "swap"

    key = currency + "." + ct
    Log(key, ":", markets[key])

void main() {
    auto markets = exchange.GetMarkets();
    auto currency = exchange.GetCurrency();

    auto ct = "swap";
    auto key = currency + "." + ct;
    Log(key, ":", markets[key]);
}

फ्यूचर्स एक्सचेंज ऑब्जेक्ट पर कॉल का उदाहरणः

/*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]) + "`")
}

'''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]) + "`")

/*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()function in the backtesting system. किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetMarkets केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़ी के बाजार डेटा को लौटाता है. बाजार फ़ंक्शन को कॉल करने के बाद, यह सभी अनुरोधित किस्मों के बाजार डेटा को लौटाता है. आप निम्नलिखित परीक्षण उदाहरण का संदर्भ ले सकते हैंः

..exchange.GetMarkets()फ़ंक्शन ट्रेडिंग किस्म के नाम से एक कुंजी के साथ एक शब्दकोश लौटाता है, और एक ट्रेडिंग जोड़ी के रूप में स्वरूपित स्पॉट फिक्स के लिए, उदाहरण के लिएः

{
    "BTC_USDT" : {...},  // The key value is the Market structure
    "LTC_USDT" : {...},  
    ...
}

फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंजों के लिए, क्योंकि एक ही किस्म के लिए कई कॉन्ट्रैक्ट हो सकते हैं, जैसेBTC_USDTव्यापारिक जोड़े, वहाँ स्थायी अनुबंध, त्रैमासिक अनुबंध, और इतने पर कर रहे हैं।exchange.GetMarkets()फ़ंक्शन अनुबंध कोड के साथ संयुक्त जोड़ी के कुंजी नाम के साथ एक शब्दकोश लौटाता है, उदाहरण के लिएः

{
    "BTC_USDT.swap" : {...},     // The key value is the Market structure
    "BTC_USDT.quarter" : {...}, 
    "LTC_USDT.swap" : {...},
    ...
}

• ..exchange.GetMarkets()कार्य लाइव ट्रेडिंग, बैकटेस्टिंग प्रणाली का समर्थन करता है।
• ..exchange.GetMarkets()यह फ़ंक्शन केवल उन किस्मों के लिए बाजार की जानकारी देता है जिनसे ऑनलाइन व्यापार किया जाता है।
• ..exchange.GetMarkets()कार्य विकल्प अनुबंधों का समर्थन नहीं करता है.

एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetMarkets()कार्य:

फ़ंक्शन का नाम	असमर्थित स्पॉट एक्सचेंज	बिना समर्थन वाले फ्यूचर्स एक्सचेंज
GetMarkets	कॉइनचेक / बिथम्ब / बिटफ्लायर	–

{@struct/मार्केट मार्केट}

exchange.GetTickers

..exchange.GetTickers()function का प्रयोग एक्सचेंज एग्रीगेटेड टिकर डेटा ({@struct/Ticker Ticker} संरचना की सरणी) प्राप्त करने के लिए किया जाता है।exchangeसभी ट्रेडिंग जोड़े के लिए टिकर डेटा लौटाता है जब यह एक स्पॉट एक्सचेंज ऑब्जेक्ट है;exchangeसभी अनुबंधों के लिए टिकर डेटा लौटाता है जब यह वायदा विनिमय वस्तु है।

..exchange.GetTickers()फ़ंक्शन {@struct/Ticker Ticker} संरचनाओं की एक सरणी लौटाता है जब यह डेटा का अनुरोध करने में सफल होता है, और शून्य जब यह विफल होता है। {@struct/Ticker Ticker} सरणी, शून्य मान

विनिमय.GetTickers()

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

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

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

कॉल करेंexchange.GetTickers()संकलित बाजार डेटा प्राप्त करने के लिए कार्य।

/*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"]
    
    // Before requesting other trading pair market data, call Get Tickers
    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])
    }
    
    // Request market data for other trading pairs
    for (var symbol of arrSymbol) {
        exchange.GetTicker(symbol)
    }

    // Call GetTickers again
    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]) +  "`")
}

'''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]) +  "`")

/*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()function in the backtest system. किसी भी बाजार फ़ंक्शन को कॉल करने से पहले, GetTickers केवल वर्तमान डिफ़ॉल्ट ट्रेडिंग जोड़ी के टिकर डेटा को लौटाता है. बाजार फ़ंक्शन को कॉल करने के बाद, यह सभी अनुरोधित किस्मों के टिकर डेटा को लौटाता है. आप निम्नलिखित परीक्षण उदाहरण का संदर्भ ले सकते हैंः

• यह फ़ंक्शन एक्सचेंज से टिकर्स इंटरफेस को एकत्र करने के लिए अनुरोध करता है, कॉल करने से पहले ट्रेडिंग जोड़े, अनुबंध कोड सेट करने की आवश्यकता नहीं है। यह केवल एक्सचेंज पर ऑनलाइन ट्रेडिंग किस्मों के टिकर्स लौटाता है।
• बैकटेस्टिंग प्रणाली इस फ़ंक्शन का समर्थन करती है।
• एक्सचेंज ऑब्जेक्ट जो एक एकत्रित टिकर इंटरफ़ेस प्रदान नहीं करते हैं, इस फ़ंक्शन का समर्थन नहीं करते हैं.
  
• यह फ़ंक्शन विकल्प अनुबंधों का समर्थन नहीं करता है।

एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTickers()कार्य:

फ़ंक्शन का नाम	असमर्थित स्पॉट एक्सचेंज	बिना समर्थन वाले फ्यूचर्स एक्सचेंज
GetTickers	Zaif / WOO / Gemini / Coincheck / BitFlyer / Bibox	फ्यूचर्स_WOO / फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_डेरबिट / फ्यूचर्स_बिबॉक्स / फ्यूचर्स_एवो

{@struct/TickerTicker}, {@fun/Market/exchange.GetTicker एक्सचेंज.GetTicker}

लॉग व्यापार