सिंटैक्स गाइड

संसाधन लोड हो रहा है... लोड करना...

बाजार

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एक विशिष्ट प्रतीक (फ्यूचर्स प्रतीक) के लिए बाजार लेनदेन रिकॉर्ड डेटा का अनुरोध करने के लिए पैरामीटर।

exchange.GetTrades()वर्तमान ट्रेडिंग जोड़े, बाजार के लेनदेन इतिहास (अपने स्वयं के नहीं) अनुबंधों के अनुरूप प्राप्त करने के लिए कार्य। कुछ एक्सचेंजों इस समारोह का समर्थन नहीं करते हैं, और विशिष्ट डेटा लौटाया जाता है कि लेनदेन रिकॉर्ड की सीमा का कितना हिस्सा एक्सचेंज पर निर्भर करता है और विशिष्ट स्थिति के अनुसार संभालने की आवश्यकता होती है। रिटर्न डेटा एक सरणी है, जहां कालानुक्रमिक क्रम का प्रत्येक तत्व औरexchange.GetRecords ()फ़ंक्शन डेटा का एक ही क्रम लौटाता है, अर्थात, सरणी का अंतिम तत्व वर्तमान समय के निकटतम डेटा है। दexchange.GetTrades()function का उपयोग करते समय एक खाली सरणी लौटाता हैटिक का अनुकरण करेंबैकटेस्टिंग प्रणाली में बैकटेस्टिंग।exchange.GetTrades()उपयोग करते समय कार्यअसली टिकबैकटेस्टिंग प्रणाली में बैकटेस्टिंग ऑर्डर फ्लो स्नैपशॉट डेटा है, अर्थात {@struct/Trade Trade} संरचना सरणी। एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetTrades()कार्य:

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

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

exchange.GetRecords

वर्तमान में सेट ट्रेडिंग जोड़ी, अनुबंध कोड, यानी के-लाइन डेटा के अनुरूप स्पॉट या अनुबंध की {@struct/Record Record} संरचना सरणी प्राप्त करें.

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

विनिमय.GetRecords() विनिमय.GetRecords ((प्रतीक) exchange.GetRecords ((प्रतीक, बिंदु) exchange.GetRecords ((प्रतीक, अवधि, सीमा) विनिमय.GetRecords (अवधि) exchange.GetRecords (अवधि, सीमा)

पैरामीटरsymbol{@struct/Record Record} सरणी डेटा के अनुरूप विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड निर्दिष्ट करने के लिए प्रयोग किया जाता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो वर्तमान में सेट ट्रेडिंग जोड़ी और अनुबंध कोड के के-लाइन डेटा का डिफ़ॉल्ट रूप से अनुरोध किया जाएगा।exchange.GetRecords(symbol)कार्य,exchangeस्पॉट एक्सचेंज ऑब्जेक्ट है। यदि आपको USDT के रूप में मुद्रा और BTC के रूप में लेनदेन मुद्रा के साथ डेटा प्राप्त करने के लिए अनुरोध करने की आवश्यकता है, तो पैरामीटरsymbolहै:"BTC_USDT", और प्रारूप एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी प्रारूप है।exchange.GetRecords(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू मानक स्थायी अनुबंध के आदेश बुक डेटा का अनुरोध करने की जरूरत है, पैरामीटरsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग ..exchange.GetRecords(symbol)कार्य,exchangeवायदा विनिमय वस्तु है. यदि आप BTC के यू-मानक विकल्प अनुबंध के आदेश पुस्तिका डेटा का अनुरोध करने की आवश्यकता है, पैरामीटरsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण . द्वारा अलग किया गया है। चिह्न झूठी स्ट्रिंग पैरामीटरperiodअनुरोधित K-लाइन डेटा की अवधि निर्दिष्ट करता है, उदाहरण के लिएः {@var/PERIOD/PERIOD_M1 PERIOD_M1}, {@var/PERIOD/PERIOD_M5 PERIOD_M5}, {@var/PERIOD/PERIOD_M15 PERIOD_M15} आदि। पैरामीटर का मानperiodपरिभाषित मानक अवधि को ही नहीं, बल्कि सेकंड में पूर्णांक मानों को भी पारित किया जा सकता है। यदि यह पैरामीटर पारित नहीं किया जाता है, तो डिफ़ॉल्ट रूप से अनुरोधित K-लाइन डेटा की अवधि वर्तमान रणनीति वास्तविक समय/बैकटेस्ट कॉन्फ़िगरेशन की डिफ़ॉल्ट K-लाइन अवधि है। अवधि झूठी संख्या पैरामीटरlimitअनुरोधित के-लाइन डेटा की लंबाई निर्दिष्ट करने के लिए प्रयोग किया जाता है. यदि यह पैरामीटर पारित नहीं किया जाता है, तो डिफ़ॉल्ट अनुरोध लंबाई एक्सचेंज के-लाइन इंटरफ़ेस के समय अनुरोधित के-लाइन बार की अधिकतम संख्या है. यह पैरामीटर एक्सचेंज के-लाइन डेटा से पूछताछ करने के लिए पेजिंग का कारण बन सकता है, और पेजिंग क्वेरी के दौरान फ़ंक्शन कॉल की समय खपत बढ़ जाएगी. सीमा झूठी संख्या

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-लाइन बार (बार) की संख्या को प्रभावित करता है।
के-लाइन बार (बार) की अधिकतम संख्या को प्रभावित करता है।

{@मज़ा/बाजार/विनिमय.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}

लॉग व्यापार

2019 FMZ - सभी अधिकार सुरक्षित