60 linhas de código realizando uma ideia - uma estratégia de contractuação.

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

Então, Martin, as estratégias como fazer mais, não fazer nada, tirar um transcrição distribuída de longa distância é mais arriscado do que fazer duas vezes? Essa ideia soa bem, mas ninguém sabe se vai durar na vida real. Mas pelo menos podemos testar essa ideia com um simples retest.

基于FMZ.COM迅捷开发

O código para implementar essa idéia é muito simples, graças à flexibilidade da plataforma, ao envelope da interface, ao poderoso sistema de retrospecção e muito mais. O código inteiro é de apenas 60 linhas (muito do que pode ser resumido não é resumido para especificar o código).

O projeto da estratégia é simples: segundo o preço inicial no início da lógica, o intervalo é pendurado para baixo, o preço continua a descer e continua a pendurar, continuando a copiar. Em seguida, pendure a ordem de liquidação após um certo diferencial de lucro baseado no preço da detenção, e aguarde o equilíbrio. Se o equilíbrio ocorrer, repita o preço inicial no preço atual.

O código da estratégia:

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

O design dos parâmetros é simples:

A partir daí, a questão é se o que você está fazendo é errado.

Vejam o que acontece com estas dezenas de linhas de código.

A partir de agora, o número de casos confirmados de doenças cardiovasculares aumentará.

Re-teste em execução:

Parece muito grátis, o sabor de estratégias do tipo Martin. Os novos alunos que começam a estudar não têm medo dessas estratégias longas e são facilmente dissuadidos. Estratégias curtas e refinadas são mais adequadas para a introdução, são mais fáceis de digerir ideias estratégicas, aprendendo design lógico.

O código estratégico é usado apenas para aprendizagem e pesquisa.