ग्रिड ट्रेडिंग रणनीति
(www.fmz.com)
ग्रिड ट्रेडिंग का मूल विचार बहुत सीधा है। एक ट्रेड करने के बजाय, हम एक ग्रिड पैटर्न बनाने वाले कई ट्रेड करते हैं। आमतौर पर ये वर्तमान मूल्य स्तर के आसपास
ग्रिड ट्रेडिंग क्या है और यह कैसे काम करती है? ग्रिड ट्रेडिंग बाजार की अस्थिरता पर एक खेल है। व्यापारियों द्वारा इसे पसंद करने के दो कारण हैं। पहला यह है कि यह आपको बाजार की दिशा पर एक निश्चित भविष्यवाणी करने की आवश्यकता नहीं है।
दूसरा यह है कि यह अस्थिर बाजारों में अच्छी तरह से काम करता है, जहां कोई स्पष्ट प्रवृत्ति नहीं है
ग्रिड ट्रेडिंग एक प्रकार का तकनीकी विश्लेषण ट्रेडिंग है जो विशिष्ट ग्रिड पैटर्न के भीतर आंदोलन पर आधारित है। ग्रिड ट्रेडिंग विदेशी मुद्रा व्यापार में लोकप्रिय है। कुल मिलाकर, तकनीक बाजारों में सामान्य मूल्य अस्थिरता पर लाभ उठाने का प्रयास करती है, कुछ नियमित अंतराल पर एक पूर्वनिर्धारित आधार मूल्य से ऊपर और नीचे खरीद और बिक्री ऑर्डर रखकर। ऐसे खरीद और बिक्री ऑर्डर, आमतौर पर 10 या 15 इकाइयों के अंतराल पर स्थित होते हैं, एक ट्रेडिंग ग्रिड बनाते हैं।
ग्रिड दिशा को अनुकूलित कर सकता है
मूल व्यापारिक परिचालनः पहले खरीदें और फिर बेचें।
ग्रिड पहली कीमत से नीचे की कीमत पर खरीद आदेश भेजना शुरू कर देगा, जो कि पहली कीमत (दूसरी नवीनतम खरीद मूल्य, तीसरी नवीनतम खरीद मूल्य...और इसी तरह) के बाद की कीमत है। प्रत्येक खरीद आदेश को
किसी भी खरीद आदेश पूरा हो गया है के बाद, कार्यक्रम खरीद मूल्य के आधार पर होगा, आदेश बेचा गया है के बाद, बेचने की कीमत के लिए
पहले शॉर्ट बेचना और फिर कवर करने के लिए खरीदनाः ऑपरेशन बिल्कुल विपरीत है
इस रणनीति का सबसे बड़ा जोखिम तब होता है जब बाजार का रुझान एकतरफा होता है और कीमतों में उतार-चढ़ाव ग्रिड से अधिक होता है।
निम्नलिखित कोड ने स्वचालित स्टॉप हानि और आंदोलन समारोह के साथ ग्रिड बनाया है।
टिप्पणियाँः
यह रणनीति एक आभासी लंबित आदेश डिजाइन का उपयोग करती है, जो लंबित आदेशों की संख्या को सीमित करने के लिए एक्सचेंज के लिए बहुत अधिक प्रसंस्करण प्रदान करती है, और समस्या को लचीले ढंग से हल करती है।
ग्रिड तर्क डिजाइन में लचीला और संरचना में स्मार्ट है।
लाभ और हानि की गणना, प्रत्येक संख्यात्मक सांख्यिकीय एल्गोरिथ्म का उपयोग संदर्भ के लिए किया जा सकता है, और प्रत्येक स्थिति का पता लगाने डिजाइन कठोर है।
स्रोत कोड सीखने लायक है।
अधिक जानकारी के लिए, कृपया देखेंः
https://www.fmz.com/strategy/112633
स्रोत कोडः
// स्रोत कोडः /* इंटरफ़ेस पैरामीटर (कोड में वैश्विक चर के रूप में दिखाए गए) OpType ग्रिड दिशा ड्रॉप-डाउन बॉक्स (चयनित) पहले खरीदें फिर बेचें FirstPriceAuto प्रारंभिक मूल्य स्वचालित बुलियन (सही/गलत) सच FirstPrice@!FirstPriceऑटो प्रारंभिक मूल्य संख्यात्मक (संख्या) 100 सभी संख्या कुल संख्यात्मक संख्या (संख्या) 10 मूल्यग्रिड मूल्य अंतराल संख्यात्मक (संख्या) 1 प्राइसडिफ़ स्प्रेड संख्यात्मक (संख्या) 2 राशिप्रकार आदेश आकार ड्रॉप-डाउन बॉक्स (चयनित) एक ही राशि खरीदें और बेचें AmountOnce@AmountType==0 एकल लेनदेन मात्रा संख्यात्मक (संख्या) 0.1 BAmountOnce@AmountType==1 क्रय आदेश आकार संख्यात्मक (संख्या) 0.1 SAmountOnce@AmountType==1 बिक्री आदेश आकार संख्यात्मक (संख्या) 0.1 AmountCoefficient@AmountType==0 मात्रा अंतर स्ट्रिंग (स्ट्रिंग) *1 AmountDot दशमलव बिंदु संख्यात्मक (संख्या) 3 EnableProtectDiff स्प्रेड सुरक्षा चालू करें बुलियन (सही/गलत) गलत ProtectDiff@EnableProtectDiff Entry spread मूल्य संरक्षण संख्यात्मक (संख्या) 20 CancelAllWS stop सभी लंबित ऑर्डर रद्द करता है बुलियन (सही/गलत) सच CheckInterval मतदान अंतराल संख्यात्मक (संख्या) 2000 अंतराल विफलता पुनः प्रयास अंतराल संख्यात्मक (संख्या) 1300 RestoreProfit अंतिम लाभ बूलियन (सही/गलत) गलत बहाल करता है LastProfit@RestoreProfit अंतिम लाभ संख्यात्मक (संख्या) 0 ProfitAsOrg@RestoreProfit अंतिम लाभ औसत मूल्य के रूप में गिना जाता है बुलियन (सही/गलत) गलत EnableAccountCheck संतुलन सत्यापन सक्षम करें बुलियन (सही/गलत) सच EnableStopLoss@EnableAccountCheck खोलें स्टॉप लॉस बुलियन (सही/गलत) गलत StopLoss@EnableStopLoss अधिकतम फ्लोटिंग हानि संख्यात्मक (संख्या) 100 StopLossMode@EnableStopLoss पोस्ट-स्टॉप हानि ऑपरेशन ड्रॉप-डाउन बॉक्स (चयनित) रीसायकल करें और बाहर निकलें। EnableStopWin@EnableAccountCheck ले लो लाभ चालू करें बुलियन (सही/गलत) गलत StopWin@EnableStopWin अधिकतम चलती लाभ संख्या प्रकार (संख्या) 120 StopWinMode@EnableStopWin लाभ लेने के बाद ऑपरेशन ड्रॉप-डाउन बॉक्स (चयनित) रीसायकल करें और बाहर निकलें। ऑटोमोव@एनेबलअकाउंटचेक ऑटोमोव बूलियन (सही/गलत) गलत MaxDistance@AutoMove अधिकतम दूरी संख्यात्मक (संख्या) 20 MaxIdle@AutoMove अधिकतम निष्क्रिय (सेकंड) संख्यात्मक (संख्या) 7200 EnableDynamic गतिशील लंबित आदेशों पर घूमता है बुलियन (सही/गलत) गलत DynamicMax@EnableDynamic आदेश समाप्ति दूरी संख्या (संख्या) 30 ResetData स्टार्टअप पर सभी डेटा को साफ़ करता है बुलियन (सही/गलत) सच सटीक मूल्य दशमलव लंबाई संख्यात्मक (संख्या) 5 */
function hasOrder ((ऑर्डर, orderId) { // जांचें कि क्या पैरामीटर ऑर्डर में ऑर्डर आईडी के साथ ऑर्डर है for (var i = 0; i < orders.length; i++) { // समान आईडी की जांच करने के लिए आदेशों को पार करें, यदि वहाँ है तो सही लौटाएं यदि (आदेश[i].Id == आदेशId) { true लौटाता है; } } false लौटाता है; // सभी पार किया, कोई ट्रिगर नहीं अगर अर्थ ID orderId के साथ क्रम नहीं मिला है, false लौटाता है }
function cancelPending() { // सभी लंबित आदेश कार्यों को रद्द करें var ret = false; // रिटर्न सफलता टैग चर सेट करें while (true) { // जबकि लूप यदि (ret) { // यदि ret सच है तो एक निश्चित समय के लिए नींद नींद ((अंतराल); } var orders = _C(exchange.GetOrders); // विनिमय द्वारा निष्पादित नहीं की गई आदेश जानकारी प्राप्त करने के लिए एपीआई को कॉल करें. if (orders.length == 0) { // यदि एक खाली सरणी लौटाई जाती है, तो एक्सचेंज में कोई निष्पादित आदेश नहीं हैं. ब्रेक; // जबकि लूप से बाहर कूदें }
for (var j = 0; j < orders.length; j++) { // Traverse the unfinished order array and use orders[j].Id one by one to cancel the order based on the index j.
exchange.CancelOrder(orders[j].Id, orders[j]);
ret = true; // Once there is a cancel operation, ret is assigned a value of true. Used to trigger above Sleep, wait for re-exchange.GetOrders detection
}
}
return ret; // return ret
}
फ़ंक्शन valuesToString(values, pos) { // स्ट्रिंग में परिवर्तित मान
var result =
फंक्शन ट्रेडर ((() { // ट्रेडर फंक्शन, समापन का उपयोग करते हुए।
var vId = 0; // आदेश वृद्धि आईडी
var orderBooks = []; // ऑर्डर बुक
var hisBooks = []; // ऐतिहासिक आदेश पुस्तिका
var orderBooksLen = 0; // ऑर्डर बुक की लंबाई
this.Buy = function ((मूल्य, राशि, अतिरिक्त) { // खरीद कार्य, मापदंडः मूल्य, मात्रा, विस्तारित जानकारी
if (typeof(extra) ===
if (orders[i].Id == order.Id) { // जब आप orderBooks में एक ही आदेश आईडी के साथ एक आदेश पाते हैं, तो find के लिए true का मान असाइन करें, जिसका अर्थ है find.
पाया = सच;
ब्रेक; // वर्तमान लूप से बाहर कूदें
}
}
यदि (!found) { // यदि नहीं मिला, तो आदेशों के लिए orderBooks[orderId] दबाएं.
orders.push ((orderBooks[orderId]); // आप इस तरह धक्का क्यों करना चाहते हैं?
}
}
वापसी आदेश; // वापसी आदेश
}
this.GetOrder = function ((orderId) { // आदेश प्राप्त करें
यदि (typeof(orderId) ===
var pfn = order.Type == ORDER_TYPE_BUY ? exchange.Buy : exchange.Sell; // Assign the corresponding API function reference to pfn according to the type of the order.
// That is, if the order type is a buy order, pfn is a reference to the exchange.Buy function, the same as the sell order.
if (order.Id == 0 && diff <= priceDiff) { // If the order order in the order book is not activated (ie Id is equal to 0) and the current price is less than or
// equal to the order plan price, the priceDiff passed in the parameter.
var realId = pfn(order.Price, order.Amount, order.Extra + "(distance: " + diff + (order.Type == ORDER_TYPE_BUY ? (" ask price: " + ticker.Buy) : (" bid price: " + ticker.Sell))+")");
// Execute order function, parameter passing price, quantity, order extension information + pending order distance + market data (ask price or bid price), return exchange order id
if (typeof(realId) === 'number') { // If the returned realId is a numeric type
order.Id = realId; // Assign the Id attribute of the current order order to the order book.
}
} else if (order.Id > 0 && diff > (priceDiff + 1)) { // If the order is active and the current distance is greater than the distance passed in by the parameter
var ok = true; // Declare a variable for tagging Initially set true
do { // Execute "do" first and then judge while
ok = true; // Ok assign true
exchange.CancelOrder(order.Id, "unnecessary" + (order.Type == ORDER_TYPE_BUY ? "buying" : "selling"), "placed order price:", order.Price, "volume:", order.Amount, ", distance:",
diff, order.Type == ORDER_TYPE_BUY ? ("ask price: " + ticker.Buy) : ("bid price: " + ticker.Sell));
// Cancel the pending order that is out of range. After canceling the order, print the current order information and the current distance diff.
Sleep(200); // Wait 200 milliseconds
orders = _C(exchange.GetOrders); // Call the API to get an uncompleted order in the exchange.
for (var i = 0; i < orders.length; i++) { // Traverse these unfinished orders.
if (orders[i].Id == order.Id) { // If the cancelled order is found in the list of orders that have not been completed by the exchange
ok = false; // Assign ok this variable to false, that is, no cancellation is successful.
}
}
} while (!ok); // If ok is false, then !ok is true and while will continue to repeat the loop, continue to cancel the order,
// and check if the cancellation is successful.
order.Id = 0; // Assigning a value of 0 to order.Id means that the current order is inactive.
}
}
};
}
function balanceAccount ((orgAccount, initAccount) { // Balance Account Function Parameter Initial account information when the strategy is started { // Balance Account Function Parameter Initial account information when the strategy is started } { { { { { { / i } } { { { / i } } { { / i } } { { / i } { / i } } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { / i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i } { i }
cancelPending(); // Call the custom function cancelPending() to cancel all pending orders. सभी लंबित आदेशों को रद्द करने के लिए कस्टम फ़ंक्शन को कॉल करें।
var nowAccount = _C ((exchange.GetAccount); // Declare a variable nowAccount to record the latest information about the account at the moment. अब खाते के बारे में नवीनतम जानकारी रिकॉर्ड करने के लिए एक चर अब खाता घोषित करें।
var slidePrice = 0.2; // Set the slip price when placing the order as 0.2 ऑर्डर देने पर स्लिप प्राइस सेट करें
var ok = true; // टैग चर शुरू में सच सेट
while (true) { // जबकि लूप
var diff = _N ((nowAccount.Stocks - initAccount.Stocks); // Calculate the difference between the current account and the initial account diff (वर्तमान खाते और प्रारंभिक खाते के बीच का अंतर गणना करें)
if (Math.abs(diff) < exchange.GetMinStock()) { // If the absolute value of the currency difference is less than the minimum transaction volume of the exchange, तो हम exchange की न्यूनतम लेन-देन मात्रा से कम है।
// the break jumps out of the loop and does not perform balancing operations. // ब्रेक लूप से बाहर कूदता है और संतुलन संचालन नहीं करता है.
ब्रेक;
}
var depth = _C ((exchange.GetDepth); // Get the exchange depth information घोषित गहराई चर को असाइन करें
var books = diff > 0? depth.Bids : depth.Asks; // According to the difference of the currency is greater than 0 or less than 0, extract the buy order array or
// sell order array in depth (equal to 0 will not be processed, it is break when it is judged to be less than GetMinStock) 0 के बराबर की ऑर्डर को गहराई में बेचें
// the difference between the coins is greater than 0 to sell the balance, so look at the buy order array, और आप देख सकते हैं कि यह कितना है
// the difference between the coins is less than 0 is the opposite. // सिक्कों के बीच का अंतर 0 से कम है, इसका विपरीत है.
var n = 0; // कथन n initial is 0
var price = 0; // स्टेटमेंट प्राइस initial 0
for (var i = 0; i < books.length; i++) { // क्रॉसिंग the buy or sell order array
n += books[i].Amount; // Accumulate Amount (order quantity) for each order based on the index i traversed (पुस्तकों[i].आमूल; // प्रत्येक आदेश के लिए एकत्रित मात्रा (ऑर्डर मात्रा)
if (n >= Math.abs(diff)) { // If the cumulative order quantity n is greater than or equal to the currency difference, then: यदि संचयी आदेश मात्रा n मुद्रा अंतर से अधिक या उसके बराबर है, तोः
price = books[i].Price; // Get the price of the current indexed order, assign it to price वर्तमान अनुक्रमित आदेश की कीमत प्राप्त करें, इसे मूल्य पर असाइन करें
break; // Jump out of the current for traversal cycle पार करने के लिए वर्तमान से बाहर कूदो
}
}
var pfn = diff > 0? exchange.Sell : exchange.Buy; // Pass the sell order API (exchange.Sell) or the next buy order API (exchange.Buy) reference to the declared pfn (एक्सचेंज.बुक) के लिए एक ऑर्डर भेजें
// 0 से अधिक या 0 से कम की मुद्रा अंतर पर आधारित
var amount = Math.abs(diff); // The amount of the order to be balanced is diff, the difference in the currency, assigned to the declared amount variable. // ऑर्डर की राशि को संतुलित करने के लिए मुद्रा में अंतर है, जिसे घोषित राशि चर को सौंपा गया है।
var price = diff > 0? (price - slidePrice) : (price + slidePrice); // The direction of buying and selling according to the difference in the currency, increase or decrease the
// मूल्य के आधार पर स्लिप मूल्य (स्लिप मूल्य यह व्यापार करने के लिए आसान बनाने के लिए है), और फिर मूल्य के लिए यह असाइन
Log ((
var STATE_WAIT_OPEN = 0; // fishTable में प्रत्येक नोड की स्थिति के लिए प्रयोग किया जाता है var STATE_WAIT_COVER = 1; //... var STATE_WAIT_CLOSE = 2; //... var ProfitCount = 0; var BuyFirst = true; // प्रारंभिक इंटरफ़ेस पैरामीटर var IsSupportGetOrder = true; // विनिमय का निर्धारण करें मुख्य फ़ंक्शन की शुरुआत निर्धारित करने के लिए उपयोग किया जाने वाला एक वैश्विक चर, GetOrder API फ़ंक्शन का समर्थन करें var LastBusy = 0; // अंतिम संसाधित समय वस्तु रिकॉर्ड करें
फ़ंक्शन setBusy() { // सेट व्यस्त समय LastBusy = new Date(); // वर्तमान समय ऑब्जेक्ट के लिए LastBusy असाइन करें }
function isTimeout() { // निर्धारित करें कि यह समय से बाहर है या नहीं यदि (MaxIdle <= 0) { // अधिकतम निष्क्रिय समय (ग्रिड के स्वचालित रूप से स्थानांतरित होने पर आधारित), // यदि अधिकतम निष्क्रिय समय MaxIdle से कम या 0 के बराबर सेट है return false; // false लौटाता है, टाइमआउट का न्याय नहीं करता है. यानी, हमेशा टाइमआउट के बिना false लौटाता है. } var now = new Date(); // वर्तमान समय वस्तु प्राप्त करें अगर (((now.getTime() - LastBusy.getTime()) / 1000) >= MaxIdle) { // वर्तमान समय ऑब्जेक्ट के getTime फ़ंक्शन का उपयोग समय के स्टैम्प और LastBusy के समय के स्टैम्प को प्राप्त करने के लिए अंतर की गणना करने के लिए, // दो समय वस्तुओं के बीच सेकंड की संख्या की गणना करने के लिए 1000 से विभाजित। // निर्धारित करें कि क्या यह अधिकतम निष्क्रिय समय MaxIdle से बड़ा है LastBusy = अब; // यदि यह से बड़ा है, वर्तमान समय वस्तु के लिए अद्यतन LastBusy अब return true; // true लौटाता है, जो एक टाइमआउट है. } false लौटाता है; // no timeout लौटाता है }
function onexit() { // कार्यक्रम के समाप्त होने पर बंद करने का कार्य।
यदि (CancelAllWS) { // बंद होने पर सभी लंबित आदेशों को रद्द करने के लिए, सभी लंबित आदेशों को रद्द करने के लिए call cancelPending() कॉल करें.
लॉग ((
फ़ंक्शन फिशिंग ((org) खाता, मछलीकाउंट) { // कास्टिंग पैरामीटरः खाता जानकारी, कास्टिंग की संख्या
setBusy(); // LastBuys को वर्तमान टाइमस्टैम्प पर सेट करें
var account = _C(exchange.GetAccount); // चालू खाता जानकारी प्राप्त करने और इसे असाइन करने के लिए एक खाता चर घोषित करें.
लॉग ((खाता); // मछली पकड़ने के कार्य के लिए कॉल की शुरुआत में खाता जानकारी आउटपुट करें.
var InitAccount = खाता; // एक चर InitAccount घोषित करें और इसे खाते के साथ असाइन करें. यहाँ से पहले दर्ज प्रारंभिक खाता धन है
// इस कास्टिंग, फ्लोटिंग लाभ और हानि की गणना के लिए इस्तेमाल किया।
var ticker = _C(exchange.GetTicker); // घोषित ticker चर को सौंपा गया उद्धरण मान प्राप्त करें
var amount = _N(AmountOnce); // इंटरफेस पैरामीटर की संख्या के अनुसार, दशमलव स्थानों को संसाधित करने के लिए _N का उपयोग करें (_N डिफ़ॉल्ट रूप से 2 बिट्स में है) और उन्हें amount को असाइन करें.
var amountB = [amount]; // amountB नामक एक चर घोषित करें एक सरणी है, amount के साथ एक तत्व आरंभ करें
var amountS = [amount]; // amountS नामक एक चर घोषित करें...
यदि (typeof(AmountType)!==
}
// मछली तालिका आरंभ करें
var fishTable = {}; // ग्रिड ऑब्जेक्ट घोषित करें
var uuidTable = {}; // पहचान कोड तालिका वस्तु
var needStocks = 0; // आवश्यक सिक्के चर
var needMoney = 0; // आवश्यक धन चर
var actualNeedMoney = 0; // वास्तव में पैसे की जरूरत
var actualNeedStocks = 0; // वास्तव में आवश्यक सिक्के
var notEnough = false; // अंडरफंडिंग टैग चर, प्रारंभ में false पर सेट
var canNum = 0; // उपलब्ध ग्रिड
for (var idx = 0; idx < AllNum; idx++) { // ग्रिड AllNum की संख्या के अनुसार संरचना को पार किया जाता है.
var price = _N((BuyFirst? FirstPrice - (idx * PriceGrid) : FirstPrice + (idx * PriceGrid)), सटीकता);
// निर्माण को पार करते समय, वर्तमान सूचकांक आईडीएक्स मूल्य सेटिंग BuyFirst के अनुसार सेट की जाती है. प्रत्येक सूचकांक मूल्य के बीच की दूरी PriceGrid है.
needStocks += amountS[idx]; // बेचे गए सिक्कों की संख्या चक्र के साथ धीरे-धीरे जमा हो जाती है। (बिक्री आदेश मात्रा सरणी द्वारा needStocks एक-एक करके जमा की जाती है)
needMoney += मूल्य * राशिB[idx]; // खरीदने के लिए आवश्यक धन की राशि चक्र के साथ धीरे-धीरे जमा हो जाती है. (.... आदेश मात्रा सरणी एक-एक करके खरीदें...)
अगर (खरीदेंपहला) { // पहले खरीदें हैंडलिंग
यदि (_N(needMoney) <= _N(account.Balance)) { // यदि ग्रिड को खाते पर उपलब्ध धनराशि से कम धनराशि की आवश्यकता है
actualNeedMondy = needMoney; // आवश्यक धन की वास्तविक राशि के लिए आवंटित
actualNeedStocks = needStocks; // आवश्यक सिक्कों की वास्तविक संख्या को असाइन करना. क्या इसमें कुछ गलत है?
canNum++; // उपलब्ध ग्रिड की संचयी संख्या
} else { // _N(needMoney) <= _N(account.Balance) यदि यह शर्त पूरी नहीं होती है, तो underfunded टैग चर को true पर सेट करें
notEnough = true;
}
} अन्य { // पहले बेचने से निपटने
यदि (_N(needStocks) <= _N(account.Stocks)) { // जांचें कि क्या आवश्यक सिक्कों की संख्या खाते में उपलब्ध सिक्कों की संख्या से कम है
actualNeedMondy = needMoney; // असाइनमेंट
actualNeedStocks = needStocks;
canNum++; // उपलब्ध ग्रिड की संचयी संख्या
} अन्य {
notEnough = true; // यदि वित्तपोषण की शर्तें पूरी नहीं की जाती हैं तो सच सेट करें
}
}
fishTable[idx] = STATE_WAIT_OPEN; // वर्तमान सूचकांक idx के अनुसार, ग्रिड ऑब्जेक्ट के idx सदस्य (ग्रिड नोड) की स्थिति सेट करें,
// प्रारंभ में STATE_WAIT_OPEN (स्थिति खोलने के लिए प्रतीक्षा)
uuidTable[idx] = -1; // अंकित ऑब्जेक्ट वर्तमान idx के आधार पर अपने स्वयं के idx मान (fishTable के अनुरूप नोड) को -1 पर आरंभ करता है.
}
यदि (!EnableAccountCheck && (canNum < AllNum)) { // यदि धन जांच सक्षम नहीं है, और ग्रिड की संख्या (नोड्स की कुल संख्या) जहां नोड छोटा है
// से इंटरफ़ेस पैरामीटर सेटिंग खोला जा सकता है.
लॉग ((
throw
var trader = new Trader(); // Constructs a Trader object, assigning it to the trader variable declared here.
var OpenFunc = BuyFirst ? exchange.Buy : exchange.Sell; // According to whether to buy and sell first, set the open function OpenFunc to refer to exchange.Buy or exchange.Sell
var CoverFunc = BuyFirst ? exchange.Sell : exchange.Buy; // same as above
if (EnableDynamic) { // Set OpenFunc/CoverFunc again according to whether the interface parameter EnableDynamic is enabled.
OpenFunc = BuyFirst ? trader.Buy : trader.Sell; // The member function Buy that references the trader object is used for dynamic pending orders (mainly because
// some exchanges limit the number of pending orders, so virtual dynamic pending orders are required)
CoverFunc = BuyFirst ? trader.Sell : trader.Buy; // same as above
}
var ts = new Date(); // Create a time object at this time (assigned to ts) to record the time at the moment.
var preMsg = ""; // Declare a variable to record the last message, the initial set to empty string
var profitMax = 0; // Maximum return
while (true) { // The main logic after the grid is casted
var now = new Date(); // Record the time when the current cycle started
var table = null; // Declare a variable
if (now.getTime() - ts.getTime() > 5000) { // Calculate whether the difference between the current time now and the recorded time ts is greater than 5000 milliseconds
if (typeof(GetCommand) == 'function' && GetCommand() == "Receiving grid") { // Check if the strategy interaction control command "receives the grid" is received,
// stops and balances to the initial state.
Log("Start executing commands to perform grid operations"); // Output information
balanceAccount(orgAccount, InitAccount); // Perform a balancing function to balance the number of coins to the initial state
return false; // This time the grid function is fishing and return false
}
ts = now; // Update ts with current time now for next comparison time
var nowAccount = _C(exchange.GetAccount); // Declare the nowAccount variable and initially been set as the current account information.
var ticker = _C(exchange.GetTicker); // Declare the ticker variable and initially been set as the current market information.
if (EnableDynamic) { // If you enable dynamic pending orders
trader.Poll(ticker, DynamicMax); // Call the Poll function of the trader object to detect and process all orders based on the
// current ticker market and the interface parameter DynamicMax.
}
var amount_diff = (nowAccount.Stocks + nowAccount.FrozenStocks) - (InitAccount.Stocks + InitAccount.FrozenStocks); // Calculate the current coin difference
var money_diff = (nowAccount.Balance + nowAccount.FrozenBalance) - (InitAccount.Balance + InitAccount.FrozenBalance); // Calculate the current money difference
var floatProfit = _N(money_diff + (amount_diff * ticker.Last)); // Calculate the current floating profit and loss of this time of casting grid
var floatProfitAll = _N((nowAccount.Balance + nowAccount.FrozenBalance - orgAccount.Balance - orgAccount.FrozenBalance) + ((nowAccount.Stocks + nowAccount.FrozenStocks
- orgAccount.Stocks - orgAccount.FrozenStocks) * ticker.Last));
// Calculate the overall floating profit and loss
var isHold = Math.abs(amount_diff) >= exchange.GetMinStock(); // If the absolute value of the coin difference at this moment is greater than the minimum trading
// volume of the exchange, it means that the position has been held.
if (isHold) { // If you have already held a position, execute the setBusy() function, which will update the LastBusy time.
setBusy(); // That is, after opening the position, the opening of the opening mechanism is started.
}
profitMax = Math.max(floatProfit, profitMax); // Refresh the maximum floating profit and loss
if (EnableAccountCheck && EnableStopLoss) { // If you initiate account detection and start a stop loss
if ((profitMax - floatProfit) >= StopLoss) { // If the maximum floating profit or loss minus the current floating profit or loss is greater than or equal to
// the maximum floating loss value, execute the code inside the curly braces
Log("Current floating profit a