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

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

व्यापार

exchange.Buy

..exchange.Buy()खरीद आदेश देने के लिए उपयोग किया जाता है।Buy()फ़ंक्शन एक्सचेंज ऑब्जेक्ट {@var/EXCHANGE exchange} का सदस्य फ़ंक्शन है।Buy()विनिमय वस्तु से बंधे विनिमय खाते पर कार्य करता हैexchange. सदस्य कार्यों का उद्देश्य (प्रणाली)exchangeऑब्जेक्ट केवल संबंधित हैexchange, और यह प्रलेखन के बाद दोहराया नहीं जाएगा।

एक सफल आदेश आदेश आईडी देता है, एक असफल आदेश शून्य मान देता है. विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी का प्रारूपETH_USDTओकेएक्स एक्सचेंज का क्रम हैःETH-USDT,1547130415509278720. जब फोन करते हैंexchange.Buy()ऑर्डर देने के लिए फ़ंक्शन, रिटर्न वैल्यू ऑर्डरIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की विशेषता।

स्ट्रिंग, शून्य मान

विनिमय.खरीदें ((मूल्य, राशि) विनिमय.खरीदें ((मूल्य, राशि,... args)

..priceपैरामीटर का उपयोग आदेश मूल्य निर्धारित करने के लिए किया जाता है। मूल्य सच संख्या दamountपैरामीटर का उपयोग आदेश राशि को सेट करने के लिए किया जाता है। राशि सच संख्या विस्तारित मापदंड जो इस ऑर्डर लॉग के लिए सहायक जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है। आर्ग झूठी string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार

function main() {
    var id = exchange.Buy(100, 1);
    Log("id:", id);
}

def main():
    id = exchange.Buy(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Buy(100, 1);
    Log("id:", id);
}

द्वारा लौटाया गया क्रमांकexchange.Buy()आदेश की जानकारी पूछने और आदेश को रद्द करने के लिए इस्तेमाल किया जा सकता है।

// The following is an error call
function main() {
    exchange.SetContractType("quarter")
  
    // Set the shorting direction
    exchange.SetDirection("sell")     
    // If you place a buy order, an error will be reported, and shorting can only be sold
    var id = exchange.Buy(50, 1)

    // Set the long direction
    exchange.SetDirection("buy")      
    // If you place a sell order, it will report an error, go long, only buy
    var id2 = exchange.Sell(60, 1)    
  
    // Set direction to close long positions
    exchange.SetDirection("closebuy")    
    // If you place a buy order, it will report an error, close long, only sell
    var id3 = exchange.Buy(-1, 1)        
  
    // Set direction to close short positions
    exchange.SetDirection("closesell")   
    // If you place a sell order, it will report an error, close short, only buy
    var id4 = exchange.Sell(-1, 1)       
}

# The following is an error call
def main():
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    id = exchange.Buy(50, 1)
    exchange.SetDirection("buy")
    id2 = exchange.Sell(60, 1)
    exchange.SetDirection("closebuy")
    id3 = exchange.Buy(-1, 1)
    exchange.SetDirection("closesell")
    id4 = exchange.Sell(-1, 1)

// The following is an error call
void main() {
    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    auto id = exchange.Buy(50, 1);
    exchange.SetDirection("buy");
    auto id2 = exchange.Sell(60, 1);
    exchange.SetDirection("closebuy");
    auto id3 = exchange.Buy(-1, 1);
    exchange.SetDirection("closesell");
    auto id4 = exchange.Sell(-1, 1);
}

क्रिप्टोक्यूरेंसी वायदा अनुबंध के लिए ऑर्डर देते समय, यह सुनिश्चित करने के लिए सावधानी बरती जानी चाहिए कि ट्रेड दिशा सही ढंग से सेट हो, क्योंकि ट्रेड दिशा और ट्रेड फ़ंक्शन के बीच असंगतता के परिणामस्वरूप त्रुटि होगीः

direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell

// For example, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
    // Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
    exchange.Buy(-1, 0.1)    
}

def main():
    exchange.Buy(-1, 0.1)

void main() {
    exchange.Buy(-1, 0.1);
}

स्पॉट मार्केट ऑर्डर।

फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर देते समय, आपको इस बात पर ध्यान देना चाहिए कि क्या ट्रेड दिशा सही ढंग से सेट की गई है, क्योंकि यदि ट्रेड दिशा और ट्रेड फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की सूचना दी जाएगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर का आकार अनुबंधों की संख्या है यदि निर्दिष्ट नहीं है। पैरामीटरpriceपर सेट है-1बाजार के आदेशों को रखने के लिए, जिसके लिए एक्सचेंज के ऑर्डर प्लेसमेंट इंटरफ़ेस को बाजार के आदेशों का समर्थन करने की आवश्यकता होती है। क्रिप्टोक्यूरेंसी स्पॉट अनुबंधों के लिए बाजार के आदेशों को रखने पर, पैरामीटरamountआदेश की मुद्रा में पैसे की राशि है। जब क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए बाजार के आदेश रखने, राशि पैरामीटरamountअनुबंधों की संख्या है. कुछ क्रिप्टोक्यूरेंसी एक्सचेंजों हैं जो लाइव ट्रेडिंग के दौरान बाजार ऑर्डर इंटरफ़ेस का समर्थन नहीं करते हैं. कुछ स्पॉट एक्सचेंजों पर बाजार खरीद ऑर्डर के लिए ऑर्डर मात्रा ट्रेडिंग सिक्कों की संख्या है. कृपया देखेंआदान-प्रदान के लिए विशेष निर्देशउपयोगकर्ता मार्गदर्शिका में विवरण के लिए। यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, आदेश का मूल्य वापसIdकेexchange.Buy()कार्य आदेश के वापसी मूल्य से अलग हो सकता हैIdवर्तमान दस्तावेज में वर्णित है।

{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}

exchange.Sell

..exchange.Sell()विक्रय आदेश देने के लिए उपयोग किया जाता है।

एक सफल आदेश आदेश आईडी देता है, एक असफल आदेश शून्य मान देता है।Idएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी का प्रारूपETH_USDTओकेएक्स एक्सचेंज का क्रम हैःETH-USDT,1547130415509278720.exchange.Sell()ऑर्डर देने के लिए फ़ंक्शन, रिटर्न वैल्यू ऑर्डरIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की विशेषता। स्ट्रिंग, शून्य मान

विनिमय.बिक्री (मूल्य, राशि) विनिमय.बिक्री ((मूल्य, राशि,... args)

function main(){
    var id = exchange.Sell(100, 1)
    Log("id:", id)
}

def main():
    id = exchange.Sell(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Sell(100, 1);
    Log("id:", id);
}

द्वारा लौटाया गया क्रमांकexchange.Sell()आदेश सूचनाओं को क्वेरी करने और आदेशों को रद्द करने के लिए इस्तेमाल किया जा सकता है।

// The following is an error call
function main() {
    exchange.SetContractType("quarter")
  
    // Set the shorting direction
    exchange.SetDirection("sell")     
    // If you place a buy order, an error will be reported, and shorting can only be sold
    var id = exchange.Buy(50, 1)                  

    // Set the long direction
    exchange.SetDirection("buy")      
    // If you place a sell order, it will report an error, go long, only buy
    var id2 = exchange.Sell(60, 1)    
  
    // Set direction to close long positions
    exchange.SetDirection("closebuy")    
    // If you place a buy order, it will report an error, close long, only sell
    var id3 = exchange.Buy(-1, 1)        
  
    // Set direction to close short positions
    exchange.SetDirection("closesell")   
    // If you place a sell order, it will report an error, close short, only buy
    var id4 = exchange.Sell(-1, 1)       
}

# The following is an error call
def main():
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    id = exchange.Buy(50, 1)
    exchange.SetDirection("buy")
    id2 = exchange.Sell(60, 1)
    exchange.SetDirection("closebuy")
    id3 = exchange.Buy(-1, 1)
    exchange.SetDirection("closesell")
    id4 = exchange.Sell(-1, 1)

// The following is an error call
void main() {
    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    auto id = exchange.Buy(50, 1);
    exchange.SetDirection("buy");
    auto id2 = exchange.Sell(60, 1);
    exchange.SetDirection("closebuy");
    auto id3 = exchange.Buy(-1, 1);
    exchange.SetDirection("closesell");
    auto id4 = exchange.Sell(-1, 1);
}

direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell

// For example, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
    // Note: place a market order to sell, sell 0.2 ETH
    exchange.Sell(-1, 0.2)   
}

def main():
    exchange.Sell(-1, 0.2)

void main() {
    exchange.Sell(-1, 0.2);
}

स्पॉट मार्केट ऑर्डर।

फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर देते समय, आपको इस बात पर ध्यान देना चाहिए कि क्या ट्रेड दिशा सही ढंग से सेट की गई है, क्योंकि यदि ट्रेड दिशा और ट्रेड फ़ंक्शन मेल नहीं खाते हैं तो त्रुटि की सूचना दी जाएगी। क्रिप्टोक्यूरेंसी फ्यूचर्स कॉन्ट्रैक्ट के लिए ऑर्डर राशि अनुबंधों की संख्या है यदि निर्दिष्ट नहीं है। पैरामीटरpriceपर सेट है-1बाजार के आदेशों को रखने के लिए, जिसके लिए बाजार के आदेशों का समर्थन करने के लिए एक्सचेंज के ऑर्डर प्लेसमेंट इंटरफ़ेस की आवश्यकता होती है। क्रिप्टोक्यूरेंसी स्पॉट अनुबंधों के लिए बाजार के आदेशों को रखने के लिए, राशि पैरामीटरamountव्यापार मुद्रा में राशि है। क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए बाजार आदेश रखने पर, राशि पैरामीटरamountअनुबंधों की संख्या है. कुछ क्रिप्टोक्यूरेंसी एक्सचेंज हैं जो लाइव ट्रेडिंग के दौरान मार्केट ऑर्डर इंटरफ़ेस का समर्थन नहीं करते हैं. यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, आदेश का मूल्य वापसIdकेexchange.Sell()कार्य आदेश के वापसी मूल्य से अलग हो सकता हैIdवर्तमान दस्तावेज में वर्णित है।

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/Futures/exchange.

exchange.CreateOrder

..exchange.CreateOrder()ऑर्डर देने के लिए फ़ंक्शन का प्रयोग किया जाता है।

यदि आदेश सफलतापूर्वक रखा जाता है, तो आदेश आईडी लौटाया जाता है; यदि आदेश विफल हो जाता है, तो शून्य मान लौटाया जाता है।Idएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720.exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने के लिए फ़ंक्शन, ऑर्डर का रिटर्न मानIdके अनुरूप हैIdआदेश {@struct/Order Order} संरचना की संपत्ति। स्ट्रिंग, शून्य मान

exchange.CreateOrder ((प्रतीक, पक्ष, मूल्य, राशि) exchange.CreateOrder ((प्रतीक, पक्ष, मूल्य, राशि,... args)

पैरामीटरsymbolआदेश के विशिष्ट व्यापारिक जोड़े और अनुबंध कोड को निर्दिष्ट करने के लिए प्रयोग किया जाता है।exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeस्पॉट एक्सचेंज ऑब्जेक्ट है। यदि ऑर्डर की मुद्रा USDT है और ट्रेडिंग मुद्रा BTC है, तो पैरामीटरsymbolहै:"BTC_USDT", एफएमजेड प्लेटफॉर्म द्वारा परिभाषित ट्रेडिंग जोड़ी के प्रारूप में।exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeवायदा विनिमय वस्तु है। यदि आदेश एक BTCs यू-मानक स्थायी अनुबंध आदेश है, पैरामीटरsymbolहै:"BTC_USDT.swap", और प्रारूपव्यापारिक जोड़ीऔरअनुबंध कोडFMZ प्लेटफॉर्म द्वारा परिभाषित, वर्ण द्वारा अलग ..exchange.CreateOrder(symbol, side, price, amount)ऑर्डर देने की कार्यक्षमता,exchangeफ्यूचर्स एक्सचेंज ऑब्जेक्ट है। यदि ऑर्डर BTCs U- मानक विकल्प अनुबंध ऑर्डर है, तो पैरामीटरsymbolहै:"BTC_USDT.BTC-240108-40000-C"(उदाहरण के लिए बिनेंस विकल्प BTC-240108-40000-C लेते हुए), और प्रारूपव्यापारिक जोड़ीएफएमजेड प्लेटफॉर्म द्वारा परिभाषित और एक्सचेंज द्वारा परिभाषित विशिष्ट विकल्प अनुबंध कोड, जो वर्ण . द्वारा अलग किया गया है। चिह्न सच स्ट्रिंग दsideपैरामीटर का प्रयोग आदेश की ट्रेडिंग दिशा निर्दिष्ट करने के लिए किया जाता है। स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए, वैकल्पिक मानsideपैरामीटर हैंःbuy, sell. buyखरीदना है, औरsellबेचने का मतलब है। वायदा विनिमय वस्तुओं के लिए, वैकल्पिक मूल्यsideपैरामीटर हैंःbuy, closebuy, sell, closesell. buyएक लंबी स्थिति खोलने का अर्थ है,closebuyएक लंबी स्थिति को बंद करने का अर्थ है,sellशॉर्ट पोजीशन खोलना, औरclosesellमतलब शॉर्ट पोजीशन बंद करना।

पक्ष सच स्ट्रिंग पैरामीटरpriceआदेश की कीमत निर्धारित करने के लिए प्रयोग किया जाता है। -1 की कीमत इंगित करती है कि आदेश एक बाजार आदेश है। मूल्य सच संख्या पैरामीटरamountआदेश मात्रा निर्धारित करने के लिए प्रयोग किया जाता है। कृपया ध्यान दें कि जब आदेश एक बाजार खरीद आदेश है, आदेश मात्रा खरीद राशि है; कुछ स्पॉट एक्सचेंजों के बाजार खरीद आदेश के आदेश मात्रा व्यापार सिक्कों की संख्या है। विवरण के लिए, कृपया देखेंआदान-प्रदान के लिए विशेष निर्देशउपयोगकर्ता गाइड में। राशि सच संख्या विस्तारित मापदंड इस आदेश लॉग के लिए अतिरिक्त जानकारी आउटपुट कर सकते हैं।argमापदंडों को पारित किया जा सकता है। आर्ग झूठी सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बूल, ऑब्जेक्ट, सरणी, शून्य मान आदि।

function main() {
    var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)           // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
    // var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   // Futures exchange objects place orders for BTC's U-standard perpetual contracts
    Log("Order Id:", id)
}

def main():
    id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01)          # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
    # id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01)   # Futures exchange objects place orders for BTC's U-standard perpetual contracts
    Log("Order Id:", id)

void main() {
    auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01);           // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
    // auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01);   // Futures exchange objects place orders for BTC's U-standard perpetual contracts
    Log("Order Id:", id);
}

स्पॉट एक्सचेंज ऑब्जेक्ट्स और फ्यूचर्स एक्सचेंज ऑब्जेक्ट्स कोexchange.CreateOrder()आदेश देने के लिए कार्य।

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}

exchange.CancelOrder

..exchange.CancelOrder()ऑर्डर रद्द करने के लिए फ़ंक्शन का प्रयोग किया जाता है. विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720. पैरामीटरorderIdमें पारित किया जब कॉलexchange.CancelOrder()एक आदेश रद्द करने के लिए समारोह के साथ संगत हैIdआदेश {@struct/Order Order} संरचना की संपत्ति।

..exchange.CancelOrder()फ़ंक्शन एक सही मान देता है, उदाहरण के लिएtrueका मतलब है कि रद्द आदेश अनुरोध सफलतापूर्वक भेजा गया था. यदि यह एक गलत मान देता है, जैसे किfalse, का मतलब है कि रद्द आदेश अनुरोध भेजने में विफल रहा है। रिटर्न मान केवल यह निर्धारित करने के लिए भेजा अनुरोध की सफलता या विफलता का प्रतिनिधित्व करता है कि क्या एक्सचेंज आदेश रद्द करता है। आप कॉल कर सकते हैंexchange.GetOrders()यह निर्धारित करने के लिए कि आदेश रद्द किया गया है या नहीं। बोल

विनिमय.ऑर्डर रद्द करें (ऑर्डर आईडी) विनिमय.ऑर्डर रद्द करें (ऑर्डर आईडी,... args)

..orderIdपैरामीटर का प्रयोग रद्द किए जाने वाले आदेश को निर्दिष्ट करने के लिए किया जाता है। आदेशित सच संख्या, स्ट्रिंग विस्तारित पैरामीटर, आप इस निकासी लॉग के लिए संलग्न जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है। आर्ग झूठी string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार

function main(){
    var id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)
}

def main():
    id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)

void main() {
    auto id = exchange.Sell(99999, 1);
    exchange.CancelOrder(id);
}

आदेश रद्द करो।

function main() {
    if (exchange.GetName().includes("Futures_")) {
        Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
        exchange.SetContractType("swap")
        exchange.SetDirection("buy")
    }
    
    var ticker = exchange.GetTicker()
    exchange.Buy(ticker.Last * 0.5, 0.1)
    
    var orders = exchange.GetOrders()
    for (var i = 0 ; i < orders.length ; i++) {
        exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i])
        Sleep(500)
    }
}

def main():
    if exchange.GetName().find("Futures_") != -1:
        Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
        exchange.SetContractType("swap")
        exchange.SetDirection("buy")
    
    ticker = exchange.GetTicker()
    exchange.Buy(ticker["Last"] * 0.5, 0.1)            

    orders = exchange.GetOrders()
    for i in range(len(orders)):
        exchange.CancelOrder(orders[i]["Id"], "Cancelled orders:", orders[i])
        Sleep(500)

void main() {
    if (exchange.GetName().find("Futures_") != std::string::npos) {
        Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
        exchange.SetContractType("swap");
        exchange.SetDirection("buy");
    }            

    auto ticker = exchange.GetTicker();
    exchange.Buy(ticker.Last * 0.5, 0.1);            

    auto orders = exchange.GetOrders();
    for (int i = 0 ; i < orders.size() ; i++) {
        exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i]);
        Sleep(500);
    }
}

एफएमजेड एपीआई फ़ंक्शन जो लॉग आउटपुट फ़ंक्शन जैसेःLog(), exchange.Buy(), exchange.CancelOrder()आवश्यक मापदंडों के बाद कुछ सहायक आउटपुट मापदंडों का अनुसरण किया जा सकता है। उदाहरण के लिएःexchange.CancelOrder(orders[i].Id, orders[i]), ताकि आदेश रद्द करते समय जिसका आईडी हैorders[i].Id, आदेश की जानकारी इसके साथ आउटपुट की जाती है।orders[i].

यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, तो exchange.CancelOrder() फ़ंक्शन का orderId पैरामीटर वर्तमान दस्तावेज़ में वर्णित orderId से भिन्न हो सकता है.

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.

exchange.GetOrder

..exchange.GetOrder()आदेश की जानकारी प्राप्त करने के लिए फ़ंक्शन का उपयोग किया जाता है.

आदेश संख्या के अनुसार आदेश विवरण की क्वेरी करें, और यदि क्वेरी सफल होती है तो {@struct/Order Order} संरचना लौटाएं, या यदि क्वेरी विफल होती है तो शून्य लौटाएं. {@struct/Order Order}, शून्य मान

विनिमय.GetOrder ((orderId)

..orderIdपैरामीटर का उपयोग क्वेरी करने के क्रम को निर्दिष्ट करने के लिए किया जाता है. विशेषताIdएफएमजेड प्लेटफॉर्म के आदेश {@struct/Order Order} संरचना में एक्सचेंज उत्पाद कोड और एक्सचेंज मूल आदेश आईडी शामिल है, जिन्हें अंग्रेजी अल्पविराम से अलग किया गया है। उदाहरण के लिए, विशेषताIdस्पॉट ट्रेडिंग जोड़ी के ऑर्डर का प्रारूपETH_USDTओकेएक्स एक्सचेंज का मूल्य हैःETH-USDT,1547130415509278720. पैरामीटरorderIdमें पारित किया जब कॉलexchange.GetOrder()एक आदेश की क्वेरी करने के लिए समारोह के साथ संगत हैIdआदेश {@struct/Order Order} संरचना की संपत्ति।

आदेशित सच स्ट्रिंग

function main(){
    var id = exchange.Sell(1000, 1)
    // Parameter id is the order number, you need to fill in the number of the order you want to query
    var order = exchange.GetOrder(id)      
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}

def main():
    id = exchange.Sell(1000, 1)
    order = exchange.GetOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:", 
        order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])

void main() {
    auto id = exchange.Sell(1000, 1);
    auto order = exchange.GetOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:", 
        order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}

..exchange.GetOrder()कार्य कुछ एक्सचेंजों द्वारा समर्थित नहीं है।AvgPrice{@struct/Order Order} संरचना में रिटर्न मान की विशेषता लेनदेन की औसत कीमत है। कुछ एक्सचेंजों इस क्षेत्र का समर्थन नहीं करते हैं, और यदि वे नहीं करते हैं, तो यह 0 पर सेट है। यदि आप डॉकर के पुराने संस्करण का उपयोग कर रहे हैं, तोorderIdपैरामीटरexchange.GetOrder()कार्य से भिन्न हो सकता हैorderIdवर्तमान प्रलेखन में वर्णित है। एक्सचेंजों जो समर्थन नहीं करते हैंexchange.GetOrder()कार्य:

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

{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade/exchange

exchange.GetOrders

..exchange.GetOrders()कार्य का उपयोग बकाया आदेश प्राप्त करने के लिए किया जाता है।

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

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

पैरामीटरsymbolसेट करने के लिए प्रयोग किया जाता हैलेनदेन चिह्नयालेन-देन प्रतीक श्रेणीपूछताछ की जाए। स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए, यदिsymbolपैरामीटर पारित नहीं किया जाता है, सभी स्पॉट उत्पादों के अधूरे आदेश डेटा का अनुरोध किया जाएगा। वायदा विनिमय वस्तुओं के लिए, यदिsymbolपैरामीटर पारित नहीं किया जाता है, डिफ़ॉल्ट रूप से वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड के आयाम सीमा में सभी किस्मों के अधूरे आदेश डेटा का अनुरोध करना है।

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

/*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 = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]

    for (var symbol of arrSymbol) {
        var t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
    }

    var spotOrders = exchange.GetOrders()

    var tbls = []
    for (var orders of [spotOrders]) {
        var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
        for (var order of orders) {
            tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        }
        tbls.push(tbl)
    }

    LogStatus("`" + JSON.stringify(tbls) +  "`")

    // Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
    return
}

'''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 = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]

    for symbol in arrSymbol:
        t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)

    spotOrders = exchange.GetOrders()

    tbls = []
    for orders in [spotOrders]:
        tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
        for order in orders:
            tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        tbls.append(tbl)

    LogStatus("`" + json.dumps(tbls) +  "`")

    return

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

void main() {
    auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
    
    for (const auto& symbol : arrSymbol) {
        auto t = exchange.GetTicker(symbol);
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
    }

    auto spotOrders = exchange.GetOrders();

    json tbls = R"([])"_json;
    std::vector<std::vector<Order>> arr = {spotOrders};
    for (const auto& orders : arr) {
        json tbl = R"({
            "type": "table", 
            "title": "test GetOrders", 
            "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
            "rows": []
        })"_json;

        for (const auto& order : orders) {
            json arrJson = R"([])"_json;

            arrJson.push_back("Symbol");
            arrJson.push_back("Id");
            arrJson.push_back(order.Price);
            arrJson.push_back(order.Amount);
            arrJson.push_back(order.DealAmount);
            arrJson.push_back(order.AvgPrice);
            arrJson.push_back(order.Status);
            arrJson.push_back(order.Type);
            arrJson.push_back(order.Offset);
            arrJson.push_back(order.ContractType);

            tbl["rows"].push_back(arrJson);
        }

        tbls.push_back(tbl);
    }
    
    LogStatus(_D(), "\n", "`" + tbls.dump() + "`");

    return;
}

स्पॉट एक्सचेंज ऑब्जेक्ट का उपयोग करें वर्तमान मूल्य के आधे मूल्य पर कई अलग-अलग ट्रेडिंग जोड़े के लिए खरीद ऑर्डर रखने के लिए, और फिर बकाया ऑर्डर जानकारी की क्वेरी करें।

/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

function main() {
    var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for (var symbol of arrSymbol) {
        var t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
        exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
    }

    var defaultOrders = exchange.GetOrders()
    var swapOrders = exchange.GetOrders("USDT.swap")
    var futuresOrders = exchange.GetOrders("USDT.futures")
    var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")

    var tbls = []
    var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
    var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
    for (var index in arr) {
        var orders = arr[index]
        var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
        for (var order of orders) {
            tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
        }
        tbls.push(tbl)
    }

    LogStatus("`" + JSON.stringify(tbls) +  "`")

    // Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
    return
}

'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''

import json

def main():
    arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]

    for symbol in arrSymbol:
        t = exchange.GetTicker(symbol)
        exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
        exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)

    defaultOrders = exchange.GetOrders()
    swapOrders = exchange.GetOrders("USDT.swap")
    futuresOrders = exchange.GetOrders("USDT.futures")
    btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")

    tbls = []
    arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
    tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
    for index in range(len(arr)):
        orders = arr[index]
        tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
        for order in orders:
            tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
        tbls.append(tbl)

    LogStatus("`" + json.dumps(tbls) +  "`")

    return

/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

void main() {
    auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
    
    for (const auto& symbol : arrSymbol) {
        auto t = exchange.GetTicker(symbol);
        exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
        exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
    }
    
    auto defaultOrders = exchange.GetOrders();
    auto swapOrders = exchange.GetOrders("USDT.swap");
    auto futuresOrders = exchange.GetOrders("USDT.futures");
    auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
    
    json tbls = R"([])"_json;
    std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
    std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
    for (int index = 0; index < arr.size(); index++) {
        auto orders = arr[index];
        json tbl = R"({
            "type": "table", 
            "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
            "rows": []
        })"_json;
        tbl["title"] = tblDesc[index];
    
        for (const auto& order : orders) {
            json arrJson = R"([])"_json;

            arrJson.push_back(order.Symbol);
            arrJson.push_back(to_string(order.Id));    // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
            arrJson.push_back(order.Price);
            arrJson.push_back(order.Amount);
            arrJson.push_back(order.DealAmount);
            arrJson.push_back(order.AvgPrice);
            arrJson.push_back(order.Status);
            arrJson.push_back(order.Type);
            arrJson.push_back(order.Offset);
            arrJson.push_back(order.ContractType);
    
            tbl["rows"].push_back(arrJson);
        }
    
        tbls.push_back(tbl);
    }
    
    LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
    
    return;
}

कई अलग-अलग ट्रेडिंग जोड़े और अनुबंध कोडों के लिए ऑर्डर देने के लिए वायदा विनिमय वस्तुओं का उपयोग करें। प्रतिपक्ष मूल्य से दूर की कीमतों पर ऑर्डर दें, एक अपूर्ण स्थिति में ऑर्डर रखें, और कई तरीकों से क्वेरी ऑर्डर करें।

function main() {
    var orders = exchange.GetOrders("BTC_USDT")           // Examples of spot products
    // var orders = exchange.GetOrders("BTC_USDT.swap")   // Examples of futures products
    Log("orders:", orders)
}

def main():
    orders = exchange.GetOrders("BTC_USDT")          # Examples of spot products
    # orders = exchange.GetOrders("BTC_USDT.swap")   # Examples of futures products
    Log("orders:", orders)

void main() {
    auto orders = exchange.GetOrders("BTC_USDT");           // Examples of spot products
    // auto orders = exchange.GetOrders("BTC_USDT.swap");   // Examples of futures products
    Log("orders:", orders);
}

जब कॉलexchange.GetOrders()कार्य, में पारितSymbolएक विशिष्ट ट्रेडिंग जोड़ी और अनुबंध कोड के लिए ऑर्डर डेटा का अनुरोध करने के लिए पैरामीटर।

मेंGetOrdersफंक्शन, प्रतीक पैरामीटर के उपयोग के परिदृश्यों को इस प्रकार संक्षेप में प्रस्तुत किया गया हैः

एक्सचेंज ऑब्जेक्ट वर्गीकरण	प्रतीक पैरामीटर	क्वेरी का दायरा	टिप्पणियाँ
स्पॉट	प्रतीक पैरामीटर पास न करें	सभी स्पॉट ट्रेडिंग जोड़े की क्वेरी करें	सभी कॉल परिदृश्यों के लिए, यदि एक्सचेंज इंटरफ़ेस इसका समर्थन नहीं करता है, तो एक त्रुटि की सूचना दी जाएगी और एक शून्य मान लौटाया जाएगा। कोई और स्पष्टीकरण नहीं दिया जाएगा।
स्पॉट	व्यापार प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः BTC_USDT	निर्दिष्ट BTC_USDT ट्रेडिंग जोड़ी की क्वेरी करें	स्पॉट एक्सचेंज ऑब्जेक्ट्स के लिए प्रतीक पैरामीटर प्रारूप हैः BTC_USDT
वायदा	प्रतीक पैरामीटर पास न करें	वर्तमान ट्रेडिंग जोड़ी और अनुबंध कोड आयाम सीमा के भीतर सभी ट्रेडिंग उत्पादों को क्वेरी करें	यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है और अनुबंध कोड स्वैप है, तो सभी USDT-मार्जिन वाले स्थायी अनुबंधों को क्वेरी किया जाएगा। यह कॉल करने के बराबर है`GetOrders("USDT.swap")`
वायदा	व्यापार प्रकार निर्दिष्ट करें, प्रतीक पैरामीटर हैः BTC_USDT.swap	एक निर्दिष्ट बीटीसी के लिए यूएसडीटी आधारित स्थायी अनुबंध की क्वेरी करें	वायदा विनिमय वस्तुओं के लिए पैरामीटर प्रतीक प्रारूप हैःव्यापारिक जोड़ीऔरअनुबंध कोडएफएमजेड प्लेटफॉर्म द्वारा परिभाषित, अक्षरों से अलग`".`.
वायदा	ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः USDT.swap	सभी USDT आधारित स्थायी अनुबंधों की क्वेरी करें	-
विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज	प्रतीक पैरामीटर पास न करें	वर्तमान ट्रेडिंग जोड़ी आयाम सीमा के भीतर सभी विकल्प अनुबंध पूछताछ करें	यदि वर्तमान ट्रेडिंग जोड़ी BTC_USDT है, तो अनुबंध एक विकल्प अनुबंध पर सेट किया जाता है, उदाहरण के लिए, Binance विकल्प अनुबंधः BTC-240108-40000-C
विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज	विशिष्ट व्यापारिक उत्पाद निर्दिष्ट करें	निर्दिष्ट विकल्प अनुबंध की क्वेरी करें	उदाहरण के लिए Binance Futures Exchange के लिए, प्रतीक पैरामीटर हैः BTC_USDT.BTC-240108-40000-C
विकल्पों का समर्थन करने वाले फ्यूचर्स एक्सचेंज	ट्रेडिंग उत्पादों की श्रेणी निर्दिष्ट करें, प्रतीक पैरामीटर हैः USDT.option	सभी USDT आधारित विकल्प अनुबंधों की खोज करें	-

मेंGetOrdersफ्यूचर्स एक्सचेंज ऑब्जेक्ट क्वेरी आयाम सीमा का सार इस प्रकार हैः

प्रतीक पैरामीटर	अनुरोध सीमा परिभाषा	टिप्पणियाँ
USDT.swap	यूएसडीटी आधारित स्थायी अनुबंध सीमा।	के लिए

आयाम जो एक्सचेंज एपीआई इंटरफ़ेस द्वारा समर्थित नहीं हैं, एक त्रुटि की सूचना दी जाएगी और शून्य मान लौटाया जाएगा जब बुला रहा है. ∙ ∙ USDT.futures ∙ ∙ USDT आधारित वितरण अनुबंध रेंज ∙ ∙ ∙ ∙ USD.swap ∙ मुद्रा आधारित स्थायी की सीमा अनुबंध। ∙ ∙ USD.futures ∙ मुद्रा आधारित वितरण की सीमा अनुबंध। ∙ ∙ USDT.option ∙ ∙ ∙ USDT आधारित विकल्प अनुबंध रेंज ∙ ∙ ∙ ∙ ∙ USD.option ∙ मुद्रा आधारित विकल्प अनुबंध रेंज ∙ USDT.futures_combo CFD संयोजनों की एक श्रृंखला। फ्यूचर्स_डेरिबिट एक्सचेंज USD.futures_ff मिश्रित मार्जिन वितरण अनुबंधों की एक श्रृंखला। फ्यूचर्स_क्रैकेन एक्सचेंज USD.swap_pf. मिश्रित मार्जिन स्थायी अनुबंधों की एक श्रृंखला। ∙∙ फ्यूचर्स_क्रैकेन एक्सचेंज

जब विनिमय वस्तु द्वारा दर्शाया गया खाताexchangeके भीतर कोई लंबित आदेश नहीं हैक्वेरी सीमायाविनिर्दिष्ट व्यापारिक साधन(अपूर्ति न हुई स्थिति में सक्रिय आदेश), इस फ़ंक्शन को कॉल करने से खाली सरणी लौटती है, अर्थातः[]. निम्नलिखित एक्सचेंजों को वर्तमान में अधूरे आदेशों की क्वेरी करते समय उपकरण को उपकरण पैरामीटर में पास करने की आवश्यकता होती है। इन एक्सचेंजों के साथ GetOrders फ़ंक्शन को कॉल करते समय, यदि उपकरण पैरामीटर पास नहीं किया जाता है, तो केवल वर्तमान उपकरण के अधूरे आदेशों का अनुरोध किया जाता है, सभी उपकरणों के अधूरे आदेशों का नहीं (क्योंकि एक्सचेंज इंटरफ़ेस इसका समर्थन नहीं करता है) । Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE

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

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

{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOr

exchange.GetHistoryOrders

..exchange.GetHistoryOrders()वर्तमान व्यापारिक जोड़ी, अनुबंधों के लिए ऐतिहासिक आदेश प्राप्त करने के लिए कार्य का उपयोग किया जाता है; यह विशिष्ट व्यापारिक किस्मों के विनिर्देश का समर्थन करता है।

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

विनिमय.GetHistoryOrders() exchange.GetHistoryOrders (प्रतीक) exchange.GetHistoryOrders ((प्रतीक, के बाद से) exchange.GetHistoryOrders ((प्रतीक, के बाद से, सीमा) विनिमय.GetHistoryOrders ((के बाद से) exchange.GetHistoryOrders ((जबसे, सीमा)

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

चिह्न झूठी स्ट्रिंग दsinceपैरामीटर का उपयोग मिलीसेकंड में क्वेरी के प्रारंभ समयस्टैम्प को निर्दिष्ट करने के लिए किया जाता है. के बाद से झूठी संख्या दlimitपैरामीटर का उपयोग क्वेरी करने के आदेशों की संख्या निर्दिष्ट करने के लिए किया जाता है. सीमा झूठी संख्या

function main() {
    var historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)
}

def main():
    historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)

void main() {
    auto historyOrders = exchange.GetHistoryOrders();
    Log(historyOrders);
}

कबsymbol, since, limitपैरामीटर निर्दिष्ट नहीं हैं, डिफ़ॉल्ट क्वेरी वर्तमान ट्रेडिंग जोड़ी, अनुबंध के ऐतिहासिक आदेश है। वर्तमान समय के निकटतम एक निश्चित सीमा के भीतर ऐतिहासिक आदेशों को क्वेरी करता है, क्वेरी रेंज एक्सचेंज इंटरफ़ेस की एकल क्वेरी रेंज पर निर्भर करती है।
जबsymbolपैरामीटर निर्दिष्ट है, सेट व्यापार प्रकार के लिए आदेशों के इतिहास की क्वेरी।
जबsinceपैरामीटर निर्दिष्ट है, वर्तमान समय की दिशा में क्वेरीsinceप्रारंभ समय के रूप में टाइमस्टैम्प।
यदिlimitपैरामीटर निर्दिष्ट है, क्वेरी प्रविष्टियों की पर्याप्त संख्या के बाद लौटाया जाता है.
यह फ़ंक्शन केवल उन एक्सचेंजों के लिए समर्थित है जो एक ऐतिहासिक ऑर्डर क्वेरी इंटरफ़ेस प्रदान करते हैं.

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

फ़ंक्शन का नाम	असमर्थित स्पॉट एक्सचेंज	बिना समर्थन वाले फ्यूचर्स एक्सचेंज
GetHistoryOrders प्राप्त करें	Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE	फ्यूचर्स_डीवाईडीएक्स / फ्यूचर्स_बिबॉक्स / फ्यूचर्स_अपोलोएक्स

{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange

exchange.SetPrecision

exchange.SetPrecision()समारोह की सटीकता को सेट करने के लिए प्रयोग किया जाता हैexchangeविनिमय वस्तुमूल्यऔरआदेश राशि, सेट करने के बाद, सिस्टम स्वचालित रूप से अतिरिक्त डेटा को अनदेखा करेगा।

exchange.SetPrecision ((मूल्यPrecision, राशिPrecision)

..pricePrecisionपैरामीटर का उपयोग मूल्य डेटा की सटीकता को नियंत्रित करने के लिए किया जाता है। मूल्य सटीकता सच संख्या दamountPrecisionपैरामीटर का उपयोग आदेश देने के लिए डेटा की मात्रा की सटीकता को नियंत्रित करने के लिए किया जाता है। राशि सटीकता सच संख्या

function main(){
    // Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
    exchange.SetPrecision(2, 3)
}

def main():
    exchange.SetPrecision(2, 3)

void main() {
    exchange.SetPrecision(2, 3);
}

बैकटेस्टिंग प्रणाली इस फ़ंक्शन का समर्थन नहीं करती है, और बैकटेस्टिंग प्रणाली की संख्यात्मक सटीकता स्वचालित रूप से संभाली जाती है।

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}

exchange.SetRate

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

exchange.SetRate (दर)

..rateरूपांतरण विनिमय दर को निर्दिष्ट करने के लिए पैरामीटर का प्रयोग किया जाता है। दर सच संख्या

function main(){
    Log(exchange.GetTicker())
    // Set exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    // Set to 1, no conversion
    exchange.SetRate(1)
}

def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    exchange.SetRate(1)

void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    exchange.SetRate(1);
}

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

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

exchange.IO

..exchange.IO()फ़ंक्शन का उपयोग एक्सचेंज ऑब्जेक्ट से संबंधित अन्य इंटरफेस कॉल के लिए किया जाता है.

..exchange.IO()फ़ंक्शन एक्सचेंज ऑब्जेक्ट से संबंधित अन्य इंटरफेस को कॉल करता है, एक सफल कॉल पर अनुरोधित प्रतिक्रिया डेटा लौटाता है और यह एक असफल कॉल पर शून्य लौटाता है। string, number, bool, object, array, null, और कोई अन्य प्रकार जो सिस्टम द्वारा समर्थित है

exchange.IO(k,... args)

..kपैरामीटर का उपयोग कॉल प्रकार सेट करने के लिए किया जाता है, वैकल्पिक मानों के साथ"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedऔर इसी तरह। क सच स्ट्रिंग विस्तारित पैरामीटर, विशिष्ट कॉल परिदृश्य के अनुसार पारित,argपैरामीटर एक से अधिक पारित किया जा सकता है।exchange.IO()कार्य, विभिन्न पैरामीटर सेटिंग्स विभिन्न कार्यों के अनुरूप हैं।exchange.IO()कार्य अनिश्चित हैं। आर्ग सच string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार

function main() {
    var arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    
    // Call exchange.IO to access the exchange's bulk order interface directly
    var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
    Log(ret)
}

import json
def main():
    arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}, 
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
    Log(ret)

void main() {
    json arrOrders = R"([
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ])"_json;
    auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
    Log(ret);
}

का उपयोग करनाexchange.IO("api", httpMethod, resource, params, raw)आमंत्रणexchange.IO()कार्यक्षमता, यह आवश्यक है समझने के लिए एपीआई इंटरफेस के विनिमय और जाँच प्रासंगिक प्रलेखन पहले. यह आप विस्तार करने के लिए अनुमति देगा कार्यक्षमता है कि नहीं है में जोड़ा गया है एफएमजेड मंच.POSTअनुरोध आपको एन्क्रिप्शन, हस्ताक्षर, या पैरामीटर सत्यापित करने के बारे में चिंता करने की आवश्यकता नहीं है, जो पहले से ही नीचे एफएमजेड द्वारा संभाला जाता है, जब तक आप संबंधित पैरामीटर भरते हैं। आप के बैच आदेश उदाहरण का संदर्भ ले सकते हैंओकेएक्स एक्सचेंजवायदा अनुबंध, और पैरामीटर का उपयोगrawआदेश मापदंडों को पारित करने के लिएः

var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
    // Note that both amount.toString() and price.toString() have a ' character on the left and right side
    var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
    var id = exchange.IO("api", "POST", "/v1/order/new", message)
}

amount = 1
price = 10
basecurrency = "ltc"
def main():
    message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
    id = exchange.IO("api", "POST", "/v1/order/new", message)

void main() {
    auto amount = 1.0;
    auto price = 10.0;
    auto basecurrency = "ltc";
    string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
    auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}

यदि कुंजी मानparamsपैरामीटर (यानी, Http अनुरोध पैरामीटर) एक स्ट्रिंग है, यह पैरामीटर मूल्य को लपेटने के लिए पैरामीटर मूल्य के चारों ओर एकल उद्धरण (यानी, प्रतीक ') में लिखा जाना चाहिए।

function main() {
    var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
    Log(ret)
}

def main():
    ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
    Log(ret)

void main() {
    auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
    Log(ret);
}

यह पूर्ण यूआरएल पैरामीटर में पारित करने का समर्थन करता है, जो आधार पते को स्विच करने के संचालन को छोड़ सकता हैexchange.SetBase()कार्य) ।

function main(){
    var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)
}

def main():
    ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)

void main() {
    auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
    Log(ret);
}

पैरामीटर के बिना कॉल का उदाहरणraw:

function main() {
    // For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
    Log(exchange.GetTicker())
    // Switch the trading pair to LTC_BTC      
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())
}

def main():
    Log(exchange.GetTicker())
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())

void main() {
    Log(exchange.GetTicker());
    exchange.IO("currency", "LTC_BTC");
    Log(exchange.GetTicker());
}

वर्तमान विनिमय की व्यापार जोड़ी स्विच करें, ताकि यह कोड द्वारा विन्यस्त व्यापार जोड़ी स्विच करेगालाइव ट्रेडिंग सृजन परयाबैकटेस्ट में.

function main () {
    // exchanges[0] is the first exchange object added when the live trading is created 
    exchanges[0].IO("base", "https://api.huobi.pro")
}

def main():
    exchanges[0].IO("base", "https://api.huobi.pro")

void main() {
    exchanges[0].IO("base", "https://api.huobi.pro");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
function main() {
    exchange.SetBase("https://api.bitfinex.com")
    exchange.IO("mbase", "https://api-pub.bitfinex.com")
}

def main():
    exchange.SetBase("https://api.bitfinex.com")
    exchange.IO("mbase", "https://api-pub.bitfinex.com")

void main() {
    exchange.SetBase("https://api.bitfinex.com");
    exchange.IO("mbase", "https://api-pub.bitfinex.com");
}

उदाहरण के लिए, टिकर इंटरफेस और ट्रेडिंग इंटरफेस के लिए अलग-अलग आधार पते वाले एक्सचेंजों के लिए, बिटकॉइन फ्यूचर्स में दो पते हैं, एक टिकर इंटरफेस के लिए और दूसरा ट्रेडिंग इंटरफेस के लिए। बिटकॉइन फ्यूचर्स निजी इंटरफ़ेस आधार पते का उपयोग करके स्विच करते हैंexchange.SetBase("xxx"). Bitfinex वायदा का उपयोग कर सार्वजनिक इंटरफ़ेस आधार पते स्विचexchange.IO("mbase", "xxx").

क्रिप्टोक्यूरेंसी-केंद्रित एक्सचेंजों के लिए अन्य एपीआई इंटरफेस कॉल जो समान रूप से कैप्सुलेट नहीं हैं, पैरामीटर के साथkसेट करना"api":

exchange.IO("api", httpMethod, resource, params, raw)

httpMethod : पैरामीटर एक स्ट्रिंग प्रकार है, अनुरोध प्रकार भरेंPOST, GETआदि।
संसाधन: पैरामीटर स्ट्रिंग प्रकार का है और अनुरोध पथ भरता है; यह पूर्ण अनुरोध पथों के उपयोग का समर्थन करता है, विवरण के लिए संदर्भ उदाहरण देखें.
parameters: पैरामीटर एक स्ट्रिंग प्रकार है, जो अनुरोध पैरामीटर से भरा हुआ है, जिसेURL.
raw: पैरामीटर कच्चा स्ट्रिंग पैरामीटर है और बाहर छोड़ दिया जा सकता है.

..exchange.IO("api", httpMethod, resource, params, raw)फ़ंक्शन कॉल एक्सचेंज इंटरफेस तक पहुंच जाएगा और यदि कॉल विफल हो जाती है और त्रुटि होती है तो शून्य लौटाएगा. केवल वास्तविक व्यापार का समर्थन करता हैexchange.IO("api", httpMethod, resource, params, raw) function.

II. व्यापारिक जोड़े बदलने के लिए, पैरामीटरkपर सेट है"currency":

exchange.IO("currency", currency)

मुद्राः पैरामीटर एक समान अपरकेस प्रारूप के साथ एक स्ट्रिंग प्रकार है, जो अलग करने के लिए एक रेखांकन का उपयोग करता हैbaseCurrencyसेquoteCurrency, जैसेBTC_USDT.
1. बैकटेस्टिंग प्रणाली अब व्यापारिक जोड़े स्विचिंग का समर्थन करता है (केवल डिजिटल मुद्रा स्पॉट विनिमय वस्तुओं के लिए), जब बैकटेस्टिंग, आप ध्यान देना चाहिए कि आप केवल एक ही मुद्रा के साथ व्यापारिक जोड़े के लिए स्विच कर सकते हैं, उदाहरण के लिए, वर्तमान व्यापारिक जोड़ी हैETH_BTCकेवल पर स्विच कर सकते हैंLTC_BTC, नहीं करनाLTC_USDT.
2. क्रिप्टोक्यूरेंसी वायदा अनुबंधों के लिए विनिमय वस्तु व्यापारिक जोड़े बदलती है और अनुबंध कोड को फिर से निर्धारित करने की आवश्यकता होती है कि किस अनुबंध का व्यापार किया जाना है।
3. {@fun/Account/exchange.SetCurrency exchange.SetCurrency} फ़ंक्शन का उपयोग ट्रेडिंग जोड़े को स्विच करने के लिए उपयोग करने के समान ही हैexchange.IO("currency", currency)व्यापारिक जोड़े बदलने के लिए।

क्रिप्टोक्यूरेंसी स्पॉट एक्सचेंज ऑब्जेक्ट लीवरेज्ड अकाउंट मोड को स्विच करने के लिए प्रयोग किया जाता हैः

पैरामीटरkपर सेट है"trade_margin"स्पॉट लीवरेज अकाउंट मोड पर स्विच करने के लिए। ऑर्डर देने और खाता परिसंपत्तियों को प्राप्त करने के लिए एक्सचेंज के स्पॉट लीवरेज इंटरफेस तक पहुंच होगी। यदि एक्सचेंज स्पॉट लीवरेज में पूर्ण मार्जिन और अलग-थलग मार्जिन के बीच अंतर करता है, तो उपयोग करेंःexchange.IO("trade_super_margin")लीवरेज्ड खाते के लिए पूर्ण मार्जिन पर स्विच करना औरexchange.IO("trade_margin")लीवरेज्ड खाते के लिए अलग-थलग मार्जिन पर स्विच करने के लिए।
पैरामीटरkपर सेट है"trade_normal"सामान्य स्पॉट खाता मोड पर लौटने के लिए।

ऐसे स्पॉट एक्सचेंज जो लाभप्रद खाता मॉडल के बीच स्विचिंग का समर्थन करते हैंः

आदान-प्रदान	विशेष टिप्पणी
ओकेएक्स	लीवरेज्ड अकाउंट मोड में ट्रेडिंग जोड़े सामान्य से भिन्न होते हैं, कुछ ट्रेडिंग जोड़े में वे नहीं हो सकते हैं।`exchange.IO("trade_super_margin")`लीवरेज्ड खातों के लिए पूर्ण स्थिति पर स्विच करने और उपयोग करने के लिए`exchange.IO("trade_margin")`स्थिति से स्थिति में स्विच करने के लिए।`trade_normal`सामान्य स्पॉट मोड पर स्विच करने के लिए।`exchange.IO("tdMode", "cross")`सीधे लीवरेज मोड को निर्दिष्ट करने के लिए।
हुओबी	लीवरेज्ड अकाउंट मोड ट्रेडिंग जोड़े सामान्य से भिन्न होते हैं, कुछ ट्रेडिंग जोड़े में वे नहीं हो सकते हैं। Huobi लीवरेज्ड खातों में पूर्ण पद और स्थिति-दर-स्थिति हैं। उपयोग करें`trade_margin`लेनदेन खाते की स्थिति के अनुसार लेनदेन पर स्विच करने के लिए,`trade_super_margin`लीवरेज खाते की पूर्ण स्थिति पर स्विच करने के लिए।`trade_normal`सामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए।
बाइनेंस	लीवरेज्ड खाता मोड को स्थिति के अनुसार स्थिति और पूर्ण स्थिति, उपयोग में विभाजित किया गया है।`trade_margin`स्थिति से स्थिति में स्विच करने के लिए, उपयोग`trade_super_margin`पूर्ण स्थिति में स्विच करने के लिए, उपयोग`trade_normal`सामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए।
द्वार	लीवरेज्ड खाता मोड को स्थिति के अनुसार स्थिति और पूर्ण स्थिति, उपयोग में विभाजित किया गया है।`trade_margin`स्थिति से स्थिति में स्विच करने के लिए, उपयोग`trade_super_margin`पूर्ण स्थिति में स्विच करने के लिए, उपयोग`trade_normal`सामान्य मुद्रा-मुद्रा मोड पर स्विच करने के लिए।
AscendEx	प्रयोग`exchange.IO("trade_margin")`लीवरेज खाते के मोड पर स्विच करने के लिए और`exchange.IO("trade_normal")`सामान्य खाता मोड पर वापस स्विच करने के लिए।
वू	प्रयोग`exchange.IO("trade_margin")`लीवरेज खाते के मोड पर स्विच करने के लिए और`exchange.IO("trade_normal")`सामान्य खाता मोड पर वापस स्विच करने के लिए।
CoinEx	प्रयोग`exchange.IO("trade_margin")`लीवरेज्ड खाता मोड पर स्विच करने के लिए और`exchange.IO("trade_normal")`सामान्य खाता मोड पर वापस स्विच करने के लिए।

अन्य स्विचिंग कार्य:देखोexchange.IO()कार्य के लिएअन्य स्विचिंग फ़ंक्शनउपयोगकर्ता गाइड में।

{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}

exchange.Log

..exchange.Log()function का उपयोग लॉग कॉलम क्षेत्र में ऑर्डर प्लेसमेंट और निकासी के लॉग को आउटपुट करने के लिए किया जाता है। जब कॉल किया जाता है, तो कोई ऑर्डर नहीं किया जाता है, केवल लेनदेन लॉग आउटपुट और रिकॉर्ड किया जाता है।

विनिमय.लॉग (ऑर्डर) प्रकार, मूल्य, राशि विनिमय.लॉग ((ऑर्डरप्रकार, कीमत, राशि,... args)

..orderTypeपैरामीटर का उपयोग आउटपुट लॉग प्रकार सेट करने के लिए किया जाता है, वैकल्पिक मान हैं {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}. आदेशप्रकार सच संख्या दpriceपैरामीटर का उपयोग आउटपुट लॉग में प्रदर्शित मूल्य को सेट करने के लिए किया जाता है। मूल्य सच संख्या दamountपैरामीटर का उपयोग आउटपुट लॉग में प्रदर्शित किए गए ऑर्डर की मात्रा को सेट करने के लिए किया जाता है। राशि सच संख्या विस्तारित मापदंड जो इस लॉग के लिए संगत जानकारी आउटपुट कर सकते हैं,argपैरामीटर एक से अधिक पारित किया जा सकता है। आर्ग झूठी string, number, bool, object, array, null और सिस्टम द्वारा समर्थित कोई अन्य प्रकार

var id = 123
function main() {
    // Order type buy, price 999, amount 0.1
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)      
    // Cancel the order
    exchange.Log(LOG_TYPE_CANCEL, id)         
}

id = 123
def main():
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)
    exchange.Log(LOG_TYPE_CANCEL, id)

void main() {
    auto id = 123;
    exchange.Log(LOG_TYPE_BUY, 999, 0.1);
    exchange.Log(LOG_TYPE_CANCEL, id);
}

प्रयोग करनाexchange.Log(orderType, price, amount)परीक्षणों के बाद लाइव ट्रेडिंग ऑर्डर के लिए इस्तेमाल किया जा सकता है, अनुकरणीय ऑर्डर प्लेसमेंट, और यह लॉगिंग ऑर्डर प्लेसमेंट में सहायता कर सकता है। सबसे आम परिदृश्यों में से एक {@fun/Trade/exchange.IO का उपयोग करना हैexchange.IO} फ़ंक्शन को विनिमय के इंटरफेस तक पहुँचने के लिए सशर्त आदेश बनाने के लिए, लेकिनexchange.IO()कार्य लाइव ट्रेडिंग लॉग रिकॉर्ड में लेनदेन लॉग जानकारी आउटपुट नहीं करता है।exchange.Log()ऑर्डर की जानकारी दर्ज करने के लिए आउटपुट लॉग को पूरक करने के लिए कार्य का उपयोग किया जा सकता है और ऑर्डर निकालने के संचालन के लिए भी यही सच है।

जबorderTypeपैरामीटर हैLOG_TYPE_CANCEL,priceपैरामीटर वापस लिए गए ऑर्डर का ऑर्डर आईडी है जिसका उपयोग वापस लेने के लॉग को प्रिंट करने के लिए किया जाता है जब ऑर्डर को सीधेexchange.IO()कार्य।exchange.Log()फ़ंक्शन {@var/EXCHANGE exchange} विनिमय वस्तु का सदस्य फ़ंक्शन है, जैसा कि वैश्विक फ़ंक्शन {@fun/Log Log} से अलग है।

{@fun/Log Log}, {@var/EXCHANGE exchange}, {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}

exchange.Encode

..exchange.Encode()हस्ताक्षर एन्क्रिप्शन की गणना के लिए फ़ंक्शन का प्रयोग किया जाता है.

..exchange.Encode()फ़ंक्शन गणना की गई हैश मान एन्कोडिंग लौटाता है. स्ट्रिंग

exchange.Encode ((algo, inputFormat, outputFormat, data) exchange.Encode ((algo, inputFormat, outputFormat, data, keyफॉर्मेट, कुंजी)

पैरामीटरalgoraw (कोई एल्गोरिथ्म इस्तेमाल नहीं किया), sign, signTx, md4, md5, sha256, sha512, sha1, keccak256, sha3.224, sha3.256, sha3.384, sha3.512, sha3.keccak256, sha3.keccak512, sha512.384, sha512.256, sha512.224, emd160, ripke2b.256, blake2b.512, blake2b.512, blake2s.1288, blake2s.256 पैरामीटर।algoयह भी समर्थन करता हैः text.encoder.utf8, text.decoder.utf8, text.encoder.gbk, text.decoder.gbk, एन्कोडिंग और डिकोडिंग स्ट्रिंग के लिए। पैरामीटरalgoयह विभिन्न हैश एल्गोरिदम के उपयोग का समर्थन करता है, उदाहरण के लिए पैरामीटरalgoed25519.md5, ed25519.sha512 आदि के रूप में लिखा जा सकता है।ed25519.seedगणना। कुछ सच स्ट्रिंग डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैdataपैरामीटर।inputFormatपैरामीटर में से किसी एक पर सेट किया जा सकता हैः raw, hex, base64, और string. raw का अर्थ है कि डेटा कच्चा डेटा है, hex का अर्थ है कि डेटा हैhexएन्कोडेड, base64 का अर्थ है कि डेटा हैbase64एन्कोडेड है, और string का मतलब है कि डेटा एक स्ट्रिंग है। इनपुटफ़ॉर्मेट सच स्ट्रिंग आउटपुट डेटा प्रारूप निर्दिष्ट करने के लिए प्रयोग किया जाता है।outputFormatपैरामीटर निम्नलिखित सेटिंग्स का समर्थन करता हैः raw, hex, base64, string. raw का अर्थ है कि डेटा कच्चा डेटा है, hex का अर्थ है कि डेटा हैhexएन्कोडेड, base64 का अर्थ है कि डेटा हैbase64एन्कोडेड है, और string का मतलब है कि डेटा एक स्ट्रिंग है। आउटपुटफ़ॉर्मेट सच स्ट्रिंग पैरामीटरdataसंसाधित किए जाने वाले डेटा हैं। आंकड़ा सच स्ट्रिंग डेटा प्रारूप को निर्दिष्ट करने के लिए प्रयोग किया जाता हैkeyपैरामीटर।keyपैरामीटर में से किसी एक पर सेट किया जा सकता हैः raw, hex, base64, और string. raw का अर्थ है कि डेटा कच्चा डेटा है, hex का अर्थ है कि डेटा हैhexएन्कोडेड, base64 का अर्थ है कि डेटा हैbase64एन्कोडेड है, और string का मतलब है कि डेटा एक स्ट्रिंग है। keyफ़ॉर्मेट झूठी स्ट्रिंग दkeyपैरामीटर हस्ताक्षर गणना में इस्तेमाल कुंजी निर्दिष्ट करने के लिए प्रयोग किया जाता है, और यह एक सादे पाठ स्ट्रिंग के रूप में इस्तेमाल किया जा सकता है. आप भी उपयोग कर सकते हैं"{{accesskey}}", "{{secretkey}}"संदर्भित करने के लिएaccessKeyऔरsecretKey{@var/EXCHANGE exchange} एक्सचेंज ऑब्जेक्ट में कॉन्फ़िगर किया गया है. कुंजी झूठी स्ट्रिंग

function main() {
    var APIKEY = "your Access Key(Bitmex API ID)"
    var expires = parseInt(Date.now() / 1000) + 10
    var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
    var client = Dial("wss://www.bitmex.com/realtime", 60)
    var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
    var pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while (true) {
        bitmexData = client.read()
        if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
            Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
            pos = parseInt(bitmexData.data[0].currentQty)
        }
    }
}

import time
def main():
    APIKEY = "your Access Key(Bitmex API ID)"
    expires = int(time.time() + 10)
    signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{secretkey}}")
    client = Dial("wss://www.bitmex.com/realtime", 60)
    auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
    pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while True:
        bitmexData = json.loads(client.read())
        if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:   
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
            pos = bitmexData["data"][0]["currentQty"]

void main() {
    auto APIKEY = "your Access Key(Bitmex API ID)";
    auto expires = Unix() + 10;
    auto signature = exchange.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{secretkey}}");
    
    auto client = Dial("wss://www.bitmex.com/realtime", 60);
    json auth = R"({"args": [], "op": "authKeyExpires"})"_json;            

    auth["args"].push_back(APIKEY);
    auth["args"].push_back(expires);
    auth["args"].push_back(signature);
    auto pos = 0;
    client.write(auth.dump());
    client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
    while(true) {
        auto bitmexData = json::parse(client.read());
        if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
            Log("test");
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
            pos = bitmexData["data"][0]["currentQty"];
        }
    }
}

BitMEX स्थिति परिवर्तन पुश (wss प्रोटोकॉल) का उदाहरणः

केवल वास्तविक व्यापार का समर्थन करता हैexchange.Encode()कार्य।"{{accesskey}}", "{{secretkey}}"संदर्भ केवल तभी मान्य होते हैं जबexchange.Encode()फ़ंक्शन का प्रयोग किया जाता है।

{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}

exchange.Go

मल्टी-थ्रेडेड असिंक्रोनस सपोर्ट फंक्शन सभी सपोर्ट किए गए फंक्शन के ऑपरेशन को असिंक्रोनस समवर्ती निष्पादन में बदल सकते हैं।

..exchange.Go()फ़ंक्शन तुरंत एक समवर्ती वस्तु देता है, और आप उपयोग कर सकते हैंwait()समवर्ती अनुरोध का परिणाम प्राप्त करने के लिए उस समवर्ती वस्तु की विधि. वस्तु

विनिमय.जाओ ((प्रक्रिया) आदान-प्रदान.जाओ ((प्रक्रिया,... args)

..methodपैरामीटर का उपयोग समवर्ती फ़ंक्शन का नाम निर्दिष्ट करने के लिए किया जाता है. ध्यान दें कि पैरामीटर फ़ंक्शन नाम स्ट्रिंग है, फ़ंक्शन संदर्भ नहीं। विधि सच स्ट्रिंग पैरामीटरसमवर्ती रूप से कार्य निष्पादित करना, एक से अधिक पैरामीटर हो सकते हैंarg. पैरामीटर का प्रकार और संख्याargपर निर्भर करता हैसमवर्ती निष्पादन कार्य. आर्ग झूठी string, number, bool, object, array, function, null, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित

function main(){
    // The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
    var a = exchange.Go("GetTicker")
    var b = exchange.Go("GetDepth") 
    var c = exchange.Go("Buy", 1000, 0.1)
    var d = exchange.Go("GetRecords", PERIOD_H1)
           
    // Call the wait method to wait for the return of the ticker results asynchronously 
    var ticker = a.wait()            
    // Returns the depth, or null if it fails 
    var depth = b.wait()             
    // return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait timeout 
    var orderId = c.wait(1000)
    if(typeof(orderId) == "undefined") {
        // Timeout, reacquire
        orderId = c.wait()
    }
    var records = d.wait()
}

def main():
    a = exchange.Go("GetTicker")
    b = exchange.Go("GetDepth")
    c = exchange.Go("Buy", 1000, 0.1)
    d = exchange.Go("GetRecords", PERIOD_H1)            

    ticker, ok = a.wait()
    depth, ok = b.wait()
    orderId, ok = c.wait(1000)
    if ok == False:
        orderId, ok = c.wait()
    records, ok = d.wait()

void main() {
    auto a = exchange.Go("GetTicker");
    auto b = exchange.Go("GetDepth");
    auto c = exchange.Go("Buy", 1000, 0.1);
    auto d = exchange.Go("GetRecords", PERIOD_H1);            

    Ticker ticker;
    Depth depth;
    Records records;
    TId orderId;
    a.wait(ticker);
    b.wait(depth);
    if(!c.wait(orderId, 300)) {
        c.wait(orderId);
    }
    d.wait(records);
}

Exchange.Go()फ़ंक्शन उपयोग उदाहरण, निर्धारित करने के लिएundefinedप्रयोग करने के लिएtypeof(xx) === "undefined", क्योंकिnull == undefinedजावास्क्रिप्ट में मान्य है.

function main() {
    var d = exchange.Go("GetRecords", PERIOD_H1)
    // Waiting for K-line results
    var records = d.wait()
    // Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
    var ret = d.wait()
}

def main():
    d = exchange.Go("GetRecords", PERIOD_H1)
    records, ok = d.wait()
    ret, ok = d.wait()

void main() {
    auto d = exchange.Go("GetRecords", PERIOD_H1);
    Records records;
    d.wait(records);
    Records ret;
    d.wait(ret);
}

बुला रहा हैwait()एक समवर्ती ऑब्जेक्ट पर विधि जो जारी किया गया है एक त्रुटि रिपोर्ट करेगाः

function main() {
    while(true) {
        var beginTS = new Date().getTime()
        var arrRoutine = []
        var arrTicker = []
        var arrName = []
        for(var i = 0; i < exchanges.length; i++) {
            arrRoutine.push(exchanges[i].Go("GetTicker"))
            arrName.push(exchanges[i].GetName())
        }            

        for(var i = 0; i < arrRoutine.length; i++) {
            arrTicker.push(arrRoutine[i].wait())
        }
        var endTS = new Date().getTime()            

        var tbl = {
            type: "table", 
            title: "ticker", 
            cols: ["index", "name", "latest-deal-price"], 
            rows: []
        }
        
        for(var i = 0; i < arrTicker.length; i++) {
            tbl.rows.push([i, arrName[i], arrTicker[i].Last])
        }            

        LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(500)
    }
}

import time 
import json
def main():
    while True:
        beginTS = time.time()
        arrRoutine = []
        arrTicker = []
        arrName = []
        for i in range(len(exchanges)):
            arrRoutine.append(exchanges[i].Go("GetTicker"))
            arrName.append(exchanges[i].GetName())            

        for i in range(len(exchanges)):
            ticker, ok = arrRoutine[i].wait()
            arrTicker.append(ticker)            

        endTS = time.time()
        tbl = {
            "type": "table", 
            "title": "ticker", 
            "cols": ["index", "name", "latest-deal-price"], 
            "rows": [] 
        }            

        for i in range(len(arrTicker)):
            tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])            

        LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)

void main() {
    while(true) {
        int length = exchanges.size();
        auto beginTS = UnixNano() / 1000000;
        Ticker arrTicker[length] = {};
        string arrName[length] = {};
        
        // Note that to add several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
        auto r0 = exchanges[0].Go("GetTicker");
        auto r1 = exchanges[1].Go("GetTicker");
        auto r2 = exchanges[2].Go("GetTicker");
        auto r3 = exchanges[3].Go("GetTicker");
        GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
        
        for(int i = 0; i < length; i++) {
            arrName[i] = exchanges[i].GetName();
        }            

        for(int i = 0; i < length; i++) {
            Ticker ticker;
            arrRoutine[i]->wait(ticker);
            arrTicker[i] = ticker;
        }        
        auto endTS = UnixNano() / 1000000;            

        json tbl = R"({
            "type": "table", 
            "title": "ticker", 
            "cols": ["index", "name", "latest-deal-price"], 
            "rows": [] 
        })"_json;            

        for(int i = 0; i < length; i++) {
            json arr = R"(["", "", ""])"_json;
            arr[0] = format("%d", i);
            arr[1] = arrName[i];
            arr[2] = format("%f", arrTicker[i].Last);
            tbl["rows"].push_back(arr);
        }            

        LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
        Sleep(500);
    }
}

एकाधिक विनिमय टिकरों तक एक साथ पहुँचः

function main() {
    /*  
        Testing with OKX futures order interface
        POST /api/v5/trade/order        
    */
    
    var beginTS = new Date().getTime()
    var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    
    var id1 = ret1.wait()
    var id2 = ret2.wait()
    var id3 = ret3.wait()
    var endTS = new Date().getTime()                

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond")
}

import time
import json
def main():
    beginTS = time.time()
    param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))            

    id1, ok1 = ret1.wait()
    id2, ok2 = ret2.wait()
    id3, ok3 = ret3.wait()
    endTS = time.time()            

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Concurrent order placement time consumption:", endTS - beginTS, "second")

void main() {
    auto beginTS = UnixNano() / 1000000;
    json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
    auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());            

    json id1 = R"({})"_json;
    json id2 = R"({})"_json;
    json id3 = R"({})"_json;            

    ret1.wait(id1);
    ret2.wait(id2);
    ret3.wait(id3);
    auto endTS = UnixNano() / 1000000;            

    Log("id1:", id1);
    Log("id2:", id2);
    Log("id3:", id3);
    Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}

समवर्ती आमंत्रणexchange.IO("api", ...)कार्य:

यह फ़ंक्शन केवल वास्तविक ट्रेडिंग में चलने पर बहु-थ्रेडेड निष्पादन कार्य बनाता है, बैकटेस्टिंग बहु-थ्रेडेड समवर्ती कार्य निष्पादन का समर्थन नहीं करता है (बैकटेस्टिंग उपलब्ध है, लेकिन फिर भी क्रमिक रूप से निष्पादित किया जाता है) । के बादexchange.Go()फ़ंक्शन एक ऑब्जेक्ट देता है, इसकेwait()फ़ंक्शन उस ऑब्जेक्ट के माध्यम से कहा जाता है धागे द्वारा लौटाए गए डेटा प्राप्त करने के लिए.wait()कार्य स्वचालित रूप से जारी किया जाएगा इससे पहले कि धागा डेटा प्राप्त करने के लिए बुलाया जाना चाहिए.wait()function निर्दिष्ट है, तो थ्रेड स्वचालित रूप से रिलीज़ नहीं होगा, भले ही टाइमआउट हो। थ्रेड का परिणाम स्वचालित रूप से रिलीज़ होने से पहले प्राप्त किया जाना चाहिए (समानकालिक पहुंच के लिए इंटरफ़ेस कॉल की सफलता या विफलता के बावजूद) । सरल शब्दों में, अनुरोधित थ्रेड को प्राप्त किया जाना चाहिएwait()कार्य चाहे निष्पादन सफल हो या असफल, और धागे के संसाधन द्वारा अनुरोध किया द्वाराexchange.Go()कार्य को डॉकर द्वारा स्वचालित रूप से जारी किया जाना चाहिए। दwait()विधि एक टाइमआउट पैरामीटर का समर्थन करती हैः एक समय सीमा पैरामीटर के बिना, कि है,wait(), या एक समय सीमा पैरामीटर 0 के साथ, यानी,wait(0).wait()फ़ंक्शन ब्लॉक करता है और तब तक प्रतीक्षा करता है जब तक समवर्ती थ्रेड समाप्त नहीं हो जाता है, समवर्ती थ्रेड के निष्पादन का परिणाम लौटाता है। समय सीमा पैरामीटर सेट -1, यानीwait(-1).wait()फ़ंक्शन तुरंत रिटर्न करता है, विभिन्न प्रोग्रामिंग भाषाओं के लिए अलग-अलग रिटर्न मानों के साथ, एक उदाहरण कॉल के लिए इस उपखंड को देखें। विशिष्ट टाइमआउट पैरामीटर सेट करें,wait(300), औरwait()कार्य वापस जाने से पहले अधिकतम 300 मिलीसेकंड का इंतजार करेगा।

यदि अंतिम परिणाम लौटायाwait()कार्य प्राप्त नहीं होता है, धागा संसाधन स्वचालित रूप से जारी नहीं किया जाएगा, जो अनुरोधित धागे के संचय का कारण होगा और 2000 से अधिक एक त्रुटि की रिपोर्ट करेगाः"too many routine wait, max is 2000". समर्थित कार्यःGetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. इन सभी कार्यों को वर्तमान {@var/EXCHANGE exchange} विनिमय वस्तु के आधार पर निष्पादित किया जाता है जब समवर्ती रूप से बुलाया जाता है. पायथन भाषा और जावास्क्रिप्ट भाषा के बीच अंतर यह है किwait()पायथन भाषा में समवर्ती ऑब्जेक्ट्स का फ़ंक्शन दो पैरामीटर लौटाता है। पहला पैरामीटर एक असिंक्रोनस एपीआई कॉल द्वारा लौटाया गया परिणाम है, और दूसरा पैरामीटर इंगित करता है कि क्या असिंक्रोनस कॉल पूरा हो गया है।


def main():
    d = exchange.Go("GetRecords", PERIOD_D1)
    # ok will return True definitely, unless the strategy is stopped
    ret, ok = d.wait()          
    # If the wait times out, or if it waits for an instance that has already ended, ok returns False
    ret, ok = d.wait(100)

{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}

बाजार खाता

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