Estrategia de punto de quiebre de promedio móvil doble de futuros de criptomonedas (Teaching)

Estrategia de punto de quiebre de promedio móvil doble de futuros de criptomonedas (Teaching)

Este artículo explica el diseño de una estrategia de tendencia simple, solo desde el nivel de diseño de estrategia, para ayudar a los principiantes a aprender a diseñar una estrategia simple y comprender el proceso de ejecución del programa de estrategia.

Diseño de estrategias

Cuando se utilizan los dos indicadores EMA y ambos promedios móviles tienen un punto de ruptura, los puntos de ruptura se utilizan como una señal para abrir posiciones largas y cortas (o invertir), para diseñar una meta fija de ganancias.

Código de estrategia

/*backtest
start: 2021-09-01 00:00:00
end: 2021-12-02 00:00:00
period: 1h
basePeriod: 5m
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

// above /**/ inside these are the default backtest settings; the backtest page can be reset by the related controls on the backtest page

var LONG = 1       // mark of holding long positions; enum constant  
var SHORT = -1     // mark of holding short positions; enum constant
var IDLE = 0       // mark of not holding no position; enum constant

// obtain the positions with a specified direction; positions indicates position data; direction indicates the direction of the positions to be obtained 
function getPosition(positions, direction) {
    var ret = {Price : 0, Amount : 0, Type : ""}    // define a structure when holding no position 
    // traverse positions, among which find the positions conforming to the direction
        if (pos.Type == direction) {
            ret = pos
        }
    })
    // return the positions found
    return ret 
}

// cancel all pending orders of the current trading pair and contract 
function cancellAll() {
    // infinite loop, detect without stop, until break is triggered 
    while (true) {
        // obtain the pending orders data of the current trading pair and contract, namely orders 
        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            // when orders is a null array, namely orders.length == 0, execute "break" statement to break the while loop 
            break
        } else {
            // traverse all the current pending orders, and cancel them one by one 
            for (var i = 0 ; i < orders.length ; i++) {
                // the function to cancel a specified order, canceling the order with an ID of:orders[i].Id
                exchange.CancelOrder(orders[i].Id, orders[i])
                Sleep(500)
            }
        }
        Sleep(500)
    }
}

// function of closing position, which executes close position, according to the passed tradeFunc and direction
function cover(tradeFunc, direction) {
    var mapDirection = {"closebuy": PD_LONG, "closesell": PD_SHORT}
    var positions = _C(exchange.GetPosition)  // obtain the position data of the current trading pair and contract 
    var pos = getPosition(positions, mapDirection[direction])  // find the position information of the specified close position direction 
    // when position volume is over 0 (only when there is a position, you can operate close position)
    if (pos.Amount > 0) {
        // cancel all possibly existing pending orders 
        cancellAll()
        // set trading direction 
        exchange.SetDirection(direction)
        // execute close position tradefunc 
        if (tradeFunc(-1, pos.Amount)) {
            // if ordering successfully, return true
            return true 
        } else {
            // if the ordering fails, return false 
            return false 
        }
    }
    // no position returns true
    return true 
}

// strategy main function 
function main() {
    // used to switch to OKEX V5 simulated bot 
    if (okexSimulate) {
        exchange.IO("simulate", true) // switch to OKEX V5 simulated bot to test  
        Log("switch to OKEX V5 simulated bot")
    }    
    
    // set contract code; set ct to swap, namely set the current operated contract to a perpetual contract  
    exchange.SetContractType(ct)
    // the initial status is no position 
    var state = IDLE
    // the initial position price is 0 
    var holdPrice = 0
    // innitialize the timestamp for comparison, to compare whether the current K-line BAR changes 
    var preTime = 0
    
    // strategy main loop 
    while (true) {
        // obtain the K-line data of the current trading pair and contract 
        var r = _C(exchange.GetRecords)
        // obtain the K-line length, namely 1
        var l = r.length
        // judge the K-line length of 1, which has to be longer than the indicator period (if the length is less than the indicator period, the indicator function cannot calculate the effective indicatorr data); if not, the loop will be restarted 
        if (l < Math.max(ema1Period, ema2Period)) {
            // wait 1000 miliseconds, namely 1 second, to avoid rotating too fast 
            Sleep(1000)
            // ignore the code after "if" at the moment, and restart the while loop
            continue
        }
        
        // calculate EMA indicator data 
        var ema1 = TA.EMA(r, ema1Period)
        var ema2 = TA.EMA(r, ema2Period)
        
        // plot
        $.PlotRecords(r, 'K-line')    // draw K-line chart 
        // when the timestamp of the last BAR changes, namely when the new K-line BAR is generated 
        if(preTime !== r[l - 1].Time){
            // before the new K-line BAR is generated, it is the last update of the last BAR  
            $.PlotLine('ema1', ema1[l - 2], r[l - 2].Time)
            $.PlotLine('ema2', ema2[l - 2], r[l - 2].Time)
            
            // draw the EMA lines of the new BAR, namely the EMA indicator data on the current last BAR 
            $.PlotLine('ema1', ema1[l - 1], r[l - 1].Time)
            $.PlotLine('ema2', ema2[l - 1], r[l - 1].Time)
            
            // update the timestamp for comparison 
            preTime = r[l - 1].Time
        } else {
            // at the moment when there is no new BAR generated, just update the EMA indicator data of the last BAR in the chart 
            $.PlotLine('ema1', ema1[l - 1], r[l - 1].Time)
            $.PlotLine('ema2', ema2[l - 1], r[l - 1].Time)
        }
        
        // condition of open long position, breakpoint 
        var up = (ema1[l - 2] > ema1[l - 3] && ema1[l - 4] > ema1[l - 3]) && (ema2[l - 2] > ema2[l - 3] && ema2[l - 4] > ema2[l - 3])
        // condition of open short position, breakpoint 
        var down = (ema1[l - 2] < ema1[l - 3] && ema1[l - 4] < ema1[l - 3]) && (ema2[l - 2] < ema2[l - 3] && ema2[l - 4] < ema2[l - 3])
        
        // when the condition of open long position is triggered and currently short positions are held, or when the condition of open long position is triggered but there is no position 
        if (up && (state == SHORT || state == IDLE)) {
            // if holding short, close first 
            if (state == SHORT && cover(exchange.Buy, "closesell")) {
                // after close positions, mark the status of no position
                state = IDLE
                // reset the position price to 0 
                holdPrice = 0
                // mark on the chart 
                $.PlotFlag(r[l - 1].Time, 'coverShort', 'CS')
            }
            // after close positions, reverse to open long 
            exchange.SetDirection("buy")
            if (exchange.Buy(-1, amount)) {
                // mark the current status 
                state = LONG
                // record the current price 
                holdPrice = r[l - 1].Close
                $.PlotFlag(r[l - 1].Time, 'openLong', 'L')
            }
        } else if (down && (state == LONG || state == IDLE)) {
            // similar to the judge of up condition 
            if (state == LONG && cover(exchange.Sell, "closebuy")) {
                state = IDLE
                holdPrice = 0
                $.PlotFlag(r[l - 1].Time, 'coverLong', 'CL')
            }
            exchange.SetDirection("sell")
            if (exchange.Sell(-1, amount)) {
                state = SHORT
                holdPrice = r[l - 1].Close
                $.PlotFlag(r[l - 1].Time, 'openShort', 'S')
            }
        }
        
        // stop profit 
        if (state == LONG && r[l - 1].Close - holdPrice > profitTarget && cover(exchange.Sell, "closebuy")) {            
            state = IDLE
            holdPrice = 0
            $.PlotFlag(r[l - 1].Time, 'coverLong', 'CL')
        } else if (state == SHORT && holdPrice - r[l - 1].Close > profitTarget && cover(exchange.Buy, "closesell")) {            
            state = IDLE
            holdPrice = 0
            $.PlotFlag(r[l - 1].Time, 'coverShort', 'CS')
        }
        // display the time on the status bar 
        LogStatus(_D())
        Sleep(500)        
    }
}

Código fuente de la estrategia:https://www.fmz.com/strategy/333269

La estrategia es sólo una enseñanza de diseño de programas, así que por favor no la uses en un bot.