60 lignes de code pour réaliser une idée -- la stratégie de transcription contractuelle.

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

Alors, Martin, une stratégie telle que faire plus, ne rien faire, tirer une copie à longue distance est-elle plus risquée que de faire deux fois? Cette idée semble bonne, mais on ne sait pas si elle résistera à la réalité. Mais au moins, nous pouvons tester cette idée avec un simple retest. C'est pourquoi nous avons le sujet de l'article d'aujourd'hui.

基于FMZ.COM迅捷开发

Le code pour réaliser cette idée est vraiment très simple, grâce à la flexibilité de la plateforme, l'emballage de l'interface, le système de retouche puissant, etc. Le code entier ne contient que 60 lignes (pour les spécifications de rédaction du code, beaucoup de choses qui peuvent être écrites en abrégé ne sont pas écrites en abrégé).

La conception de l'idée de la stratégie est simple: selon le prix initial au début de la logique, l'intervalle est suspendu vers le bas, le prix continue à descendre et continue à suspendre, à transcrire. Ensuite, suspendre un ordre de mise en place après une certaine différence de profit basée sur le prix de l'acquisition, en attendant un ordre de mise en place. Si l'acquisition est mise en place, répétez le prix initial au prix actuel.

Le code source de la stratégie:

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

La conception des paramètres est simple:

Il n'y a que ces quelques paramètres.

Regardez ces dizaines de lignes de code.

Il est possible de définir une plage de temps de retouche:

Le dépistage est en cours:

Il semble qu'il y ait beaucoup de grilles, le goût des stratégies de type Martin. Les nouveaux élèves qui apprennent à l'entrée ne sont pas effrayés par les stratégies longues et sont facilement dissuadés. Les stratégies courtes et raffinées sont plus appropriées pour l'entrée, elles sont plus faciles à digérer les idées stratégiques et à apprendre la conception logique.

Le code stratégique est uniquement utilisé pour l'apprentissage et la recherche.