60 लाइनों का कोड एक विचार को लागू करता है - अनुबंध प्रतिलेखन रणनीति।

网格策略、马丁策略这种喜欢震荡行情的策略有其固有弊端，在ETH合约市场上也测试了一段时间的类似策略。也经常和FMZ.COM上的新老玩家们聊天分享经验。对于此类策略，有一点是非常赞同一位朋友的说法的。那就是币圈中做合约，做多相对于做空风险小了那么一丢丢。或者简单说就是下跌最惨就是归零，上涨是无限的。

तो, मार्टिन, ग्रिड और अन्य रणनीतियाँ क्या केवल अधिक करना, कुछ भी नहीं करना, और एक लंबी दूरी के वितरण को खींचना, दो तरफा करने की तुलना में अधिक जोखिम भरा है? यह विचार अच्छा लगता है, लेकिन क्या यह वास्तविक युद्ध में खड़ा होगा, कोई नहीं जानता। लेकिन कम से कम हम इसे एक सरल रीटेस्ट के साथ परीक्षण कर सकते हैं। इसलिए हमारे पास आज का लेख है। एक अनुबंध को डिजाइन करने की रणनीति।

基于FMZ.COM迅捷开发

इस विचार को लागू करने के लिए कोड वास्तव में बहुत सरल है, प्लेटफॉर्म की लचीलापन, इंटरफ़ेस पैकेजिंग, शक्तिशाली पुनर्मूल्यांकन प्रणाली आदि के कारण। पूरे कोड में केवल 60 पंक्तियां हैं ((कोड लेखन के लिए, बहुत सारा संक्षिप्त नहीं है जिसे संक्षिप्त किया जा सकता है)) ।

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

रणनीति का स्रोत कोडः

function cancelAll() {
    while (true) {
        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) { 
            break 
        }
        for (var i = 0 ; i < orders.length ; i++) {
            exchange.CancelOrder(orders[i].Id, orders[i])
            Sleep(interval)
        }
    }
}

function getLong(arr, kind) {
    var ret = null 
    for (var i = 0 ; i < arr.length ; i++) {
        if (arr[i].Type == (kind == "pos" ? PD_LONG : ORDER_TYPE_BUY)) {
            ret = arr[i]
        }
    }
    return ret
}

function pendingBidOrders(firstPrice) {
    var index = 0
    var amount = baseAmount
    while (true) {
        var pos = _C(exchange.GetPosition)
        var price = firstPrice - index * baseSpacing
        amount *= ratio
        index++
        exchange.SetDirection("buy")
        exchange.Buy(price, amount)        
        if (pos.length != 0) {
            var longPos = getLong(pos, "pos")
            if (longPos) {
                exchange.SetDirection("closebuy")
                exchange.Sell(longPos.Price + profitTarget, longPos.Amount)
            }
        }
        while (true) {
            Sleep(interval)
            if (!getLong(_C(exchange.GetOrders), "orders")) {
                cancelAll()
                break
            }
            if (!getLong(_C(exchange.GetPosition), "pos")) {
                cancelAll()
                return 
            }
        }
    }
}

function main() {
    exchange.SetContractType(symbol)
    while (true) {
        pendingBidOrders(_C(exchange.GetTicker).Last)
    }
}

और पैरामीटर डिजाइन भी सरल हैः

केवल ये कुछ पैरामीटर हैं।

यह दर्जनों लाइनों का कोड है, और आप देख सकते हैं कि यह कैसे काम करता है।

यह एक बहुत ही अच्छा तरीका है कि हम अपने स्वयं के अनुभवों के बारे में बात कर सकते हैं।

पुनः परीक्षण चल रहा हैः

ऐसा लगता है कि बहुत सारे जाल हैं, मार्टिन प्रकार की रणनीति का स्वाद है..............

यह कोड केवल सीखने और शोध के लिए है।