Stratégie de point de rupture à moyenne mobile double des contrats à terme sur crypto-monnaie (enseignement)

Stratégie de point de rupture à moyenne mobile double des contrats à terme sur crypto-monnaie (enseignement)

Cet article explique la conception d'une stratégie de tendance simple, uniquement à partir du niveau de conception de la stratégie, pour aider les débutants à apprendre à concevoir une stratégie simple et à comprendre le processus d'exécution du programme de stratégie.

Conception de la stratégie

Lorsque l'on utilise les deux indicateurs EMA et que les deux moyennes mobiles ont un point de rupture, les points de rupture sont utilisés comme signal pour ouvrir des positions longues et courtes (ou inverser), pour concevoir une cible fixe pour le profit de l'écart de fermeture des positions.

Code de stratégie

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

Le code source de la stratégie:https://www.fmz.com/strategy/333269

La stratégie n'est qu'un enseignement de conception de programme, alors s'il vous plaît ne l'utilisez pas dans un bot.