Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

sto cercando di capire meglio questo EA per mt4…

  1. User

    sto cercando di capire meglio questo EA per mt4 //+----------------------------------------------------------------------------------------------------------+// // // // ██ ██ ████████ ████████ ██ ███████ ███████ ████████ █████ ██████ ███████ █████ // // ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ // // ██ ██ ██ ██ ██ █████ ███████ ██ ███████ ██████ █████ ███████ // // ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ // // ███████ ██ ██ ██ ███████ ███████ ███████ ██ ██ ██ ██ ██ ███████ ██ ██ // // // //+----------------------------------------------------------------------------------------------------------+//

    #property copyright "Little Star EA"; #property version "1.00"; #property strict

    #import "kernel32.dll"

    int CreateFileW(string,int,int,int,int,int,int); int GetFileSize(int,int); int SetFilePointer(int,int,int&,int); int ReadFile(int,uchar&[],int,int&[],int); int CloseHandle(int);

    #import //extern string INFO1=""; //===== LOTS SECTION ======================= extern int MagicID = 260289; extern double FixedLot = 0.01; extern int AutoLot = 1; extern double StopLoss = 200; extern double TakeProfit = 10; extern int MaxOrders = 10; extern int WPR_Period = 450;

    extern bool Conservative_Mode = true; extern double RangeFilter = 0.4;

    /////////////////funzioni da codificare per future versioni //extern string INFO3=""; //===== ATR SECTION ========================= extern bool ATR_StopLoss = true; extern double ATR_StopLoss_Value = 20;
    //valore da moltiplicare per ATR extern bool ATR_TakeProfit = true; extern double ATR_TakeProfit_value = 10;
    //valore da moltiplicare per ATR

    //extern string INFO4=""; //===== TRAILING STOP SECTION =============== input bool Trailing_Stop_ON=true; input double TrailingStop = 10; extern int TrailingStep = 1; //////////////////////////////////////

    union Price { public: uchar bytes[8]; double value; };

    double pointValue; int slippage; string Is_00050; int fileHandle; long Il_00090; int Gi_00001; long Gl_00002; bool Gb_00002; int recordsCount; int Gi_00002; int Gi_00004; double Gd_00005; int Gi_00006; double filteredPriceRange; int validDaysCount; int currentBar; double medianFilteredPriceRange; int Gi_0000F; int Gi_00016; int Gi_00017; int Gi_00018; int ordersNumber; int Gi_0001A; int buyOrdersCounter; int Gi_0001C; int sellOrdersCounter; int Gi_0001E; double lotSize; double minLot; double maxLot; int openOrder; string historyBarTimestamp; uchar timestamp0; uchar timestamp1; int Gi_00005; uchar timestamp2; uchar timestamp3; uchar timestamp4; uchar timestamp5; uchar timestamp6; uchar timestamp7; int Gi_00021; double priceHistory[][2];

    Price historyBarValue;

    bool order_check;

    int init() { string historyFilePath; int currentHistoryIndex; string accountInfo;

    slippage = 3; recordsCount = 0; pointValue = 0; openOrder = 0; Il_00090 = 0;

    if (IsDllsAllowed() != true) { Alert("Make Sure DLL Import is Allowed"); ExpertRemove(); currentHistoryIndex = 1; return currentHistoryIndex; }

    pointValue = _Point; if (_Digits == 5 || _Digits == 3) {

    pointValue = (pointValue * 10); slippage = slippage * 10; } ChartSetInteger(0, 17, 0, 0); ChartSetInteger(0, 0, 1); accountInfo = AccountInfoString(3); if (accountInfo == "") { accountInfo = "default"; } historyFilePath = TerminalInfoString(3); historyFilePath = historyFilePath + "\history\"; historyFilePath = historyFilePath + accountInfo; historyFilePath = historyFilePath + "\"; historyFilePath = historyFilePath + _Symbol; historyFilePath = historyFilePath + "240"; historyFilePath = historyFilePath + ".hst"; // Is_00050 = orderComment; historyRead(historyFilePath); currentHistoryIndex = 0;

    return currentHistoryIndex; }

    //+------------------------------------------------------------------+ //| counter ordini totali | //+------------------------------------------------------------------+ int countTotalOrders() { int totalOrdersCount = 0; int ordersCounter = OrdersTotal() - 1;

    // Ciclo attraverso tutti gli ordini
    while (ordersCounter >= 0) { 
        if (OrderSelect(ordersCounter, SELECT_BY_POS)) {
            if (OrderMagicNumber() == MagicID && 
                OrderSymbol() == _Symbol) { 
                // Se l’ordine corrisponde al MagicID e al Symbol, incrementa il contatore
                totalOrdersCount++;
            } 
        }
        ordersCounter--;
    }
    return totalOrdersCount;
    

    } //+------------------------------------------------------------------+

    void OnTick() { string orderComment; string buySignalMessage; string sellSignalMessage; int currentHistoryIndex; int openOrderIndex; double williamPRange; double awesomeOscillator; // double currentHigh; // double previousLow; double stopLoss; double takeProfit; double historyPriceLevel;

    /////////////////richiamo funzione counter ordini totali
    int totalOrders = countTotalOrders(); ///////////////////////

    if (Il_00090 == Time[0]) return; Il_00090 = Time[0]; ChartRedraw(0); Gl_00002 = iVolume(_Symbol, 15, 0); if (Gl_00002 > iVolume(_Symbol, 15, 1)) return; Gb_00002 = !recordsCount; Gi_00002 = Gb_00002; if (Gi_00002 > 0) return; currentHistoryIndex = -1; openOrderIndex = 0; Gi_00002 = recordsCount - 1; if (Gi_00002 > 0) { do { if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; currentHistoryIndex = openOrderIndex + 1; openOrderIndex = openOrderIndex + 1; Gi_00004 = recordsCount - 1; } while (openOrderIndex < Gi_00004); }

    // HideTestIndicators(true); williamPRange = iWPR(_Symbol, 0, WPR_Period, 0); awesomeOscillator = iAO(_Symbol, 0, 0); // HideTestIndicators(false);

    historyPriceLevel = NormalizeDouble(priceHistory[currentHistoryIndex, 1], _Digits); ObjectDelete("level"); // Gd_00005 = currentHigh; orderComment = "level";

    /* if ((currentHigh > iOpen(_Symbol, 1, 0))) { buySignalMessage = "BUY 123 = " + DoubleToString(currentHigh, _Digits); Comment(buySignalMessage); } if ((Gd_00005 < iOpen(_Symbol, 1, 0))) { sellSignalMessage = "SELL 123 = " + DoubleToString(Gd_00005, _Digits); Comment(sellSignalMessage); } / if (ObjectFind(orderComment) != -1) { ObjectMove(orderComment, 0, iTime(_Symbol, 1, 0), historyPriceLevel); } else { ObjectCreate(0, orderComment, OBJ_HLINE, 0, 0, historyPriceLevel, 0, 0, 0, 0); ObjectSet(orderComment, OBJPROP_COLOR, 16776960); ObjectSet(orderComment, OBJPROP_STYLE, 0); ObjectSet(orderComment, OBJPROP_WIDTH, 1); ObjectSet(orderComment, OBJPROP_BACK, 1); } / if ((priceHistory[currentHistoryIndex, 1] > Open[0])) { Comment("Waiting BUY Signals - ", priceHistory[currentHistoryIndex, 1]); }

    if ((priceHistory[currentHistoryIndex, 1] > Open[0])) { string message = "Waiting BUY Signals - " + DoubleToStr(priceHistory[currentHistoryIndex, 1], _Digits) + "\nSpread - " + DoubleToStr(MarketInfo(_Symbol, MODE_SPREAD), 2) + "\nOrders Open: " + IntegerToString(totalOrders);

    Comment(message);
    }
    

    if ((priceHistory[currentHistoryIndex, 1] > Open[0])) { // Calcola lo spread in pips se necessario double spread = MarketInfo(_Symbol, MODE_SPREAD); if (_Digits == 5 || _Digits == 3) { spread = spread / 1.0; // adjust for 5-digit brokers }

    string message = "\nSpread - " + DoubleToStr(spread, 2) + " pips" + 
                     "\n\nWaiting BUY Signals  "
                     "\nOrders Open: " + IntegerToString(totalOrders);                     
                     
    Comment(message);
    

    } */ if ((priceHistory[currentHistoryIndex, 1] > Open[0])) { // Calcola lo spread in pips se necessario double spread = MarketInfo(_Symbol, MODE_SPREAD); if (_Digits == 5 || _Digits == 3) { spread /= 10.0; // Correzione per i broker con 5 cifre decimali } // Inizia a costruire il messaggio string message = "\nSpread: " + DoubleToStr(spread, 2) + " pips"; // Aggiungi informazioni riguardanti la Conservative_Mode message += "\nConservative Mode: " + (Conservative_Mode ? "On" : "Off"); // Continua a costruire il messaggio message += "\n\nBUY Signals"; // + DoubleToStr(priceHistory[currentHistoryIndex, 1], _Digits); Commentato se non serve message += "\nOrders Open: " + IntegerToString(totalOrders); // Mostra il messaggio sul grafico Comment(message); }

    if ((priceHistory[currentHistoryIndex, 1] < Open[0])) { // Calcola lo spread in pips se necessario double spread = MarketInfo(_Symbol, MODE_SPREAD); if (_Digits == 5 || _Digits == 3) { spread /= 10.0; // Correzione per i broker con 5 cifre decimali } // Inizia a costruire il messaggio string message = "\nSpread: " + DoubleToStr(spread, 2) + " pips"; // Aggiungi informazioni riguardanti la Conservative_Mode message += "\nConservative Mode: " + (Conservative_Mode ? "On" : "Off"); // Continua a costruire il messaggio message += "\n\nSELL Signals"; // + DoubleToStr(priceHistory[currentHistoryIndex, 1], _Digits); Commentato se non serve message += "\nOrders Open: " + IntegerToString(totalOrders); // Mostra il messaggio sul grafico Comment(message); }

    /* if ((priceHistory[currentHistoryIndex, 1] < Open[0])) { Comment("Waiting SELL Signals - ", priceHistory[currentHistoryIndex, 1]); } /* if ((priceHistory[currentHistoryIndex, 1] > Open[0])) { Comment("BUY Ultimate - ", priceHistory[currentHistoryIndex, 1]); } if ((priceHistory[currentHistoryIndex, 1] < Open[0])) { Comment("SELL Ultimate - ", priceHistory[currentHistoryIndex, 1]); } / // previousLow = MarketInfo(_Symbol, MODE_SPREAD); // MarketInfo(_Symbol, MODE_SPREAD); / Gi_00016 = 0; Gi_00017 = OrdersTotal() - 1; Gi_00018 = Gi_00017; if (Gi_00017 >= 0) { do { order_check = OrderSelect(Gi_00018, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_BUY) { Gi_00016 = Gi_00016 + 1; } Gi_00018 = Gi_00018 - 1; } while (Gi_00018 >= 0); } if (Gi_00016 >= MaxOrders) return; Gi_00017 = 0; ordersNumber = OrdersTotal() - 1; Gi_0001A = ordersNumber; if (ordersNumber >= 0) { do { order_check = OrderSelect(Gi_0001A, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_SELL) { Gi_00017 = Gi_00017 + 1; } Gi_0001A = Gi_0001A - 1; } while (Gi_0001A >= 0); } if (Gi_00017 >= MaxOrders) return; */

    /////////////////// CONTATORE ORDINI BUY /////////////////////////

    ordersNumber = 0; buyOrdersCounter = OrdersTotal() - 1; // Gi_0001C = buyOrdersCounter; if (buyOrdersCounter >= 0) { do { order_check = OrderSelect(buyOrdersCounter, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_BUY) { ordersNumber = ordersNumber + 1; } buyOrdersCounter = buyOrdersCounter - 1; } while (buyOrdersCounter >= 0); } if (ordersNumber >= MaxOrders) return; if ((Conservative_Mode) && (((iWPR(_Symbol, 0, WPR_Period, 0) - 10) >= -1))) return;

    /* ordersNumber = 0; buyOrdersCounter = OrdersTotal() - 1;

    if (buyOrdersCounter >= 0) { do { order_check = OrderSelect(buyOrdersCounter, SELECT_BY_POS, MODE_TRADES);
    if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_BUY) { ordersNumber++; } buyOrdersCounter--; } while (buyOrdersCounter >= 0); } if (ordersNumber >= MaxOrders) { return; } if ((Conservative_Mode) && (((iWPR(_Symbol, 0, WPR_Period, 0) - 10) >= -1))) return;

    /* // Inizializza il contatore degli ordini di acquisto a zero. ordersNumber = 0;

    // Ottiene l’indice dell’ultimo ordine nell’elenco degli ordini aperti (gli indici partono da 0). buyOrdersCounter = OrdersTotal() - 1;

    // Verifica se c’è almeno un ordine aperto. if (buyOrdersCounter >= 0) { // Esegue un ciclo per tutti gli ordini aperti, dal più recente al più vecchio. do { // Seleziona l’ordine corrente basato sulla sua posizione nell’elenco per permetterne l’ispezione. order_check = OrderSelect(buyOrdersCounter, SELECT_BY_POS, MODE_TRADES);

        // Controlla se l’ordine attualmente selezionato soddisfa tutti i seguenti criteri:
        // 1. L’ordine è stato piazzato da questo EA (verificato dal Magic Number).
        // 2. L’ordine è sul simbolo (_Symbol) corrente su cui l’EA è in esecuzione.
        // 3. L’ordine è un ordine di acquisto (OP_BUY).
        if (OrderMagicNumber() == MagicID &&
            OrderSymbol() == _Symbol &&
            OrderType() == OP_BUY) { 
            // Se l’ordine soddisfa i criteri, incrementa il contatore degli ordini di acquisto.
            ordersNumber++;
        } 
    
        // Passa all’ordine precedente nell’elenco.
        buyOrdersCounter–;
    } while (buyOrdersCounter >= 0); // Continua finché ci sono ordini da verificare.
    

    }

    // Dopo avere controllato tutti gli ordini, verifica se il numero di ordini di acquisto ha raggiunto il limite massimo consentito. if (ordersNumber >= MaxOrders) { // Se il numero massimo di ordini è stato raggiunto o superato, esce dalla funzione senza eseguire ulteriori azioni. return; } */

    /////////////////// CONTATORE ORDINI SELL /////////////////////////

    ordersNumber = 0; sellOrdersCounter = OrdersTotal() - 1; // Gi_0001E = sellOrdersCounter; if (sellOrdersCounter >= 0) { do { order_check = OrderSelect(sellOrdersCounter, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_SELL) { ordersNumber = ordersNumber + 1; } sellOrdersCounter = sellOrdersCounter - 1; } while (sellOrdersCounter >= 0); } if (ordersNumber >= MaxOrders) return; if ((Conservative_Mode) && (((iWPR(_Symbol, 0, WPR_Period, 0) - 90) <= -99))) return;

    /////////////////////////////////////////////////////

    // if ((priceHistory[currentHistoryIndex, 1] <= Open[0])) return;

    if ((priceHistory[currentHistoryIndex, 1] > Open[0]) && buyConditions()) { // lotSize = (StopLoss * pointValue); stopLoss = NormalizeDouble((Ask - (StopLoss * pointValue)), _Digits); takeProfit = NormalizeDouble(((TakeProfit * pointValue) + Ask), _Digits); // lotSize = 0; minLot = MarketInfo(_Symbol, MODE_MINLOT); maxLot = MarketInfo(_Symbol, MODE_MAXLOT);

    if (AutoLot != 0) { lotSize = NormalizeDouble((((AccountBalance() * AutoLot) / 10) / 10000), 2); if ((lotSize < minLot)) { lotSize = minLot; } if ((lotSize > maxLot)) { lotSize = maxLot; }} else{ lotSize = FixedLot; } if ((AccountFreeMarginCheck(_Symbol, 1, lotSize) <= 0)) return;

    openOrder = OrderSend(_Symbol, 0, lotSize, Ask, slippage, stopLoss, takeProfit, "Ultimate EA - Buy", MagicID, 0, 32768); closeSellOrders(); }

    // if ((priceHistory[currentHistoryIndex, 1] >= Open[0])) return; // if (!sellConditions()) return; if ((priceHistory[currentHistoryIndex, 1] < Open[0]) && sellConditions()) {

    stopLoss = NormalizeDouble(((StopLoss * pointValue) + Bid), _Digits); // lotSize = (TakeProfit * pointValue); takeProfit = NormalizeDouble((Bid - (TakeProfit * pointValue)), _Digits); // lotSize = 0; minLot = MarketInfo(_Symbol, MODE_MINLOT); maxLot = MarketInfo(_Symbol, MODE_MAXLOT);

    if (AutoLot != 0) { lotSize = NormalizeDouble((((AccountBalance() * AutoLot) / 10) / 10000), 2); if ((lotSize < minLot)) { lotSize = minLot; } if ((lotSize > maxLot)) { lotSize = maxLot; }} else{ lotSize = FixedLot; } if ((AccountFreeMarginCheck(_Symbol, 1, lotSize) <= 0)) return;

    openOrder = OrderSend(_Symbol, 1, lotSize, Bid, slippage, stopLoss, takeProfit, "Ultimate EA - Sell", MagicID, 0, 32768); closeBuyOrders();

    } }

    void OnDeinit(const int reason) { ObjectsDeleteAll(-1, -1); ChartRedraw(0); }

    void historyRead(string filePath) { string orderComment; int currentHistoryIndex; string accountInfo; int byteCount; int fileSize; int Li_FFFE4 = 0; int Li_FFF78; int Li_FFF3C; double historyBarClosePrice;

    currentHistoryIndex = 0; byteCount = 0; fileSize = 0; char buffer[]; Li_FFF78 = 0; int readResult[1]; Li_FFF3C = 0; historyBarClosePrice = 0; accountInfo = ""; // orderComment = filePath; fileHandle = CreateFileW(filePath, -2147483648, 3, 0, 3, 0, 0); byteCount = fileHandle; if (fileHandle == -1) { Comment(""); ArrayFree(readResult); ArrayFree(buffer); return; } fileSize = GetFileSize(byteCount, 0); if (fileSize <= 0) { ArrayFree(readResult); ArrayFree(buffer); return ; } fileHandle = fileSize - 148; fileHandle = fileHandle / 60; if (fileHandle == recordsCount) { ArrayFree(readResult); ArrayFree(buffer); return ; } SetFilePointer(byteCount, 148, Li_FFFE4, 0); fileHandle = fileSize - 148; recordsCount = fileHandle / 60; ArrayResize(priceHistory, recordsCount, 0); // Li_FFF78 = 60; ArrayResize(buffer, 60, 0); Li_FFF3C = 0; if (recordsCount > 0) { do { ReadFile(byteCount, buffer, 60, readResult, 0); if (readResult[0] == 60) { timestamp0 = buffer[0]; timestamp1 = buffer[1]; timestamp2 = buffer[2]; timestamp3 = buffer[3]; timestamp4 = buffer[4]; timestamp5 = buffer[5]; timestamp6 = buffer[6]; timestamp7 = buffer[7];

    historyBarTimestamp = StringFormat("0x%02x%02x%02x%02x%02x%02x%02x%02x", timestamp7, timestamp6, timestamp5, timestamp4, timestamp3, timestamp2, timestamp1, timestamp0);

    historyBarValue.bytes[0] = buffer[32]; historyBarValue.bytes[1] = buffer[33]; historyBarValue.bytes[2] = buffer[34]; historyBarValue.bytes[3] = buffer[35]; historyBarValue.bytes[4] = buffer[36]; historyBarValue.bytes[5] = buffer[37]; historyBarValue.bytes[6] = buffer[38]; historyBarValue.bytes[7] = buffer[39];

    historyBarClosePrice = historyBarValue.value;

    priceHistory[currentHistoryIndex, 0] = StringToDouble(historyBarTimestamp); priceHistory[currentHistoryIndex, 1] = historyBarClosePrice; currentHistoryIndex = currentHistoryIndex + 1;

    /* orderComment = TimeToString(StringToTime(historyBarTimestamp), 3); orderComment = orderComment + " "; orderComment = orderComment + DoubleToString(historyBarClosePrice, 8); accountInfo = orderComment;*/

    } else { CloseHandle(byteCount); ArrayFree(readResult); ArrayFree(buffer); return ; } Li_FFF3C = Li_FFF3C + 1; } while (Li_FFF3C < recordsCount); } /*
    CloseHandle(byteCount); Gi_0001A = currentHistoryIndex - 1; orderComment = DoubleToString(priceHistory[Gi_0001A, 0], 3); orderComment = orderComment + " "; sellOrdersCounter = Gi_0001A; orderComment = orderComment + DoubleToString(priceHistory[Gi_0001A, 1], 8); orderComment = orderComment + " "; Gi_0001E = currentHistoryIndex - 2; orderComment = orderComment + DoubleToString(priceHistory[Gi_0001E, 1], 3); orderComment = orderComment + " "; Gi_00021 = Gi_0001E; orderComment = orderComment + DoubleToString(priceHistory[Gi_0001E, 1], 8); accountInfo = orderComment; historyBarTimestamp = orderComment; ArrayFree(readResult); ArrayFree(buffer); */ }

    void closeBuyOrders() { bool orderClose; int openOrderIndex;

    orderClose = false; /* Gi_00000 = 0; Gi_00001 = OrdersTotal() - 1; Gi_00002 = Gi_00001; if (Gi_00001 >= 0) { do { order_check = OrderSelect(Gi_00002, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_BUY) { Gi_00000 = Gi_00000 + 1; } Gi_00002 = Gi_00002 - 1; } while (Gi_00002 >= 0); } if (Gi_00000 <= 0) return;

    do { */ openOrderIndex = OrdersTotal() - 1; if (openOrderIndex >= 0) { do { if (OrderSelect(openOrderIndex, 0, 0) && OrderSymbol() == _Symbol && OrderMagicNumber() == MagicID && OrderType() == OP_BUY) { orderClose = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), slippage, 16776960); } openOrderIndex = openOrderIndex - 1; } while (openOrderIndex >= 0); }

    /* Gi_00004 = 0; Gi_00005 = OrdersTotal() - 1; Gi_00006 = Gi_00005; if (Gi_00005 >= 0) { do { order_check = OrderSelect(Gi_00006, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_BUY) { Gi_00004 = Gi_00004 + 1; } Gi_00006 = Gi_00006 - 1; } while (Gi_00006 >= 0); }

    } while (Gi_00004 > 0); */
    }

    void closeSellOrders() { bool orderClose; int openOrderIndex;

    orderClose = false; /* Gi_00000 = 0; Gi_00001 = OrdersTotal() - 1; Gi_00002 = Gi_00001; if (Gi_00001 >= 0) { do { order_check = OrderSelect(Gi_00002, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_SELL) { Gi_00000 = Gi_00000 + 1; } Gi_00002 = Gi_00002 - 1; } while (Gi_00002 >= 0); } if (Gi_00000 <= 0) return;

    do { / openOrderIndex = OrdersTotal() - 1; if (openOrderIndex >= 0) { do { if (OrderSelect(openOrderIndex, 0, 0) && OrderSymbol() == _Symbol && OrderMagicNumber() == MagicID && OrderType() == OP_SELL) { orderClose = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), slippage, 16776960); } openOrderIndex = openOrderIndex - 1; } while (openOrderIndex >= 0); } / Gi_00004 = 0; Gi_00005 = OrdersTotal() - 1; Gi_00006 = Gi_00005; if (Gi_00005 >= 0) { do { order_check = OrderSelect(Gi_00006, 0, 0); if (OrderMagicNumber() == MagicID && OrderSymbol() == _Symbol && OrderType() == OP_SELL) { Gi_00004 = Gi_00004 + 1; } Gi_00006 = Gi_00006 - 1; } while (Gi_00006 >= 0); } } while (Gi_00004 > 0); */
    }

    bool buyConditions() { // double williamPRange; // double awesomeOscillator; // double currentHigh; // double previousLow; // double stopLoss; // double takeProfit; double priceRange; // double Ld_FFFA8; double adjustedPriceRange; // double Ld_FFF98; // double Ld_FFF90; bool orderClose;

    // williamPRange = 0; // awesomeOscillator = 0; // currentHigh = 0; // previousLow = 0; // stopLoss = 0; // takeProfit = 0; // stopLoss = 0; // takeProfit = 0; priceRange = 0; // Ld_FFFA8 = 0; adjustedPriceRange = 0; // Ld_FFF98 = 0;

    // williamPRange = Open[1]; // awesomeOscillator = Close[1]; // currentHigh = High[0]; // previousLow = Low[1]; // takeProfit = Open[2]; // stopLoss = Close[2]; // stopLoss = High[2]; // takeProfit = Low[2];

    // priceRange = (currentHigh - previousLow); priceRange = (High[0] - Low[1]); // priceRange = (High[1] - Low[1]);

    // Ld_FFFA8 = (stopLoss - takeProfit); filteredPriceRange = (priceRange * RangeFilter); // adjustedPriceRange = (currentHigh - filteredPriceRange); adjustedPriceRange = (High[0] - filteredPriceRange); //(High[1] - filteredPriceRange);

    // Ld_FFF98 = adjustedPriceRange; filteredPriceRange = 0; // double Ld_FFF70[4]; validDaysCount = 0; currentBar = 1; do { if (TimeDayOfWeek(Time[currentBar]) != 0) { filteredPriceRange = ((High[currentBar] - Low[currentBar]) + filteredPriceRange); validDaysCount = validDaysCount + 1; } currentBar = currentBar + 1; } while (validDaysCount < 4); medianFilteredPriceRange = (filteredPriceRange / 4); // ArrayFree(Ld_FFF70); // Ld_FFF90 = medianFilteredPriceRange; /* if ((awesomeOscillator <= Ld_FFF98)) return false; if ((williamPRange <= adjustedPriceRange)) return false; if ((priceRange <= (medianFilteredPriceRange * 0.5))) return false; if ((((priceRange * 0.25) + previousLow) >= takeProfit)) return false; */ if ((Open[1] <= adjustedPriceRange)) return false; if ((Close[1] <= adjustedPriceRange)) return false; // if ((Open[1] <= filteredPriceRange)) return false; // if ((Close[1] <= filteredPriceRange)) return false;

    if ((priceRange <= (medianFilteredPriceRange * 0.5))) return false; if ((((priceRange * 0.25) + Low[1]) >= Low[2])) return false;

    Gi_0000F = ArrayMinimum(Low, 3, 3); if ((Low[Gi_0000F] <= Low[1])) return false; orderClose = true; return orderClose;

    orderClose = false;

    return orderClose; }

    bool sellConditions()

    { // double williamPRange; // double awesomeOscillator; // double currentHigh; // double previousLow; // double stopLoss; // double takeProfit; double priceRange; // double Ld_FFFA8; double adjustedPriceRange; // double Ld_FFF98; // double Ld_FFF90; bool orderClose;

    // williamPRange = 0; // awesomeOscillator = 0; // currentHigh = 0; // previousLow = 0; // stopLoss = 0; // takeProfit = 0; // stopLoss = 0; // takeProfit = 0; priceRange = 0; // Ld_FFFA8 = 0; adjustedPriceRange = 0; // Ld_FFF98 = 0; // williamPRange = Open[1]; // awesomeOscillator = Close[1]; // currentHigh = High[1]; // previousLow = Low[1]; // takeProfit = Open[2]; // stopLoss = Close[2]; // stopLoss = High[2]; // takeProfit = Low[2]; priceRange = (High[1] - Low[0]); // (High[1] - Low[1]); filteredPriceRange = (priceRange * RangeFilter); adjustedPriceRange = (filteredPriceRange + Low[0]); // (filteredPriceRange + Low[1]) // double Ld_FFF70[4]; filteredPriceRange = 0;

    validDaysCount = 0; currentBar = 1; do { if (TimeDayOfWeek(Time[currentBar]) != 0) { filteredPriceRange = ((High[currentBar] - Low[currentBar]) + filteredPriceRange); validDaysCount = validDaysCount + 1; } currentBar = currentBar + 1; } while (validDaysCount < 4); medianFilteredPriceRange = (filteredPriceRange / 4); // ArrayFree(Ld_FFF70); // Ld_FFF90 = medianFilteredPriceRange;

    if ((Close[1] >= adjustedPriceRange)) return false; if ((Open[1] >= adjustedPriceRange)) return false;

    if ((priceRange <= (medianFilteredPriceRange * 0.5))) return false; if (((High[1] - (priceRange * 0.25)) <= High[2])) return false;

    Gi_0000F = ArrayMaximum(High, 3, 3); if ((High[Gi_0000F] >= High[1])) return false; orderClose = true; return orderClose;

    orderClose = false;

    return orderClose; }

    l'ultima parte che mi manca da capire meglio è la seguente if (Il_00090 == Time[0]) return; Il_00090 = Time[0]; ChartRedraw(0); Gl_00002 = iVolume(_Symbol, 15, 0); if (Gl_00002 > iVolume(_Symbol, 15, 1)) return; Gb_00002 = !recordsCount; Gi_00002 = Gb_00002; if (Gi_00002 > 0) return; currentHistoryIndex = -1; openOrderIndex = 0; Gi_00002 = recordsCount - 1; if (Gi_00002 > 0) { do { if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; currentHistoryIndex = openOrderIndex + 1; openOrderIndex = openOrderIndex + 1; Gi_00004 = recordsCount - 1; } while (openOrderIndex < Gi_00004); } puoi spiegarmela?

  2. Assistant

    Certo, procederò a spiegare questa parte dell'Expert Advisor (EA) passo dopo passo:

    Parte del Codice

    if (Il_00090 == Time[0]) return; 
    Il_00090 = Time[0];
    ChartRedraw(0);
    Gl_00002 = iVolume(_Symbol, 15, 0);
    if (Gl_00002 > iVolume(_Symbol, 15, 1)) return; 
    Gb_00002 = !recordsCount;
    Gi_00002 = Gb_00002;
    if (Gi_00002 > 0) return; 
    currentHistoryIndex = -1;
    openOrderIndex = 0;
    Gi_00002 = recordsCount - 1;
    if (Gi_00002 > 0) { 
    do { 
        if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; 
        currentHistoryIndex = openOrderIndex + 1;
        openOrderIndex = openOrderIndex + 1;
        Gi_00004 = recordsCount - 1;
    } while (openOrderIndex < Gi_00004); 
    }
    

    Spiegazione

    1. Verifica del Time[0]:

      if (Il_00090 == Time[0]) return;
      Il_00090 = Time[0];
      

      Questa parte controlla se Il_00090 (una variabile precedentemente dichiarata) è uguale al tempo dell'ultimo tick (Time[0]). Se lo è, il metodo OnTick() viene interrotto con return;, perché significa che il tick corrente è già stato elaborato. Poi, memorizza il tempo corrente del tick in Il_00090 cosicché il prossimo tick possa essere confrontato con questo.

    2. Redraw del grafico:

      ChartRedraw(0);
      

      Questo ricalcola il grafico dell'asset corrente per aggiornare eventuali dati visivi.

    3. Controllo del volume:

      Gl_00002 = iVolume(_Symbol, 15, 0);
      if (Gl_00002 > iVolume(_Symbol, 15, 1)) return;
      

      Viene calcolato e confrontato il volume degli ultimi due bar a 15 minuti (0 indica il bar corrente, 1 indica il bar precedente). Se il volume corrente è maggiore del volume del bar precedente, il metodo viene interrotto. Potrebbe servire per evitare di fare operazioni in momenti di volatilità improvvisa.

    4. Controllo recordsCount:

      Gb_00002 = !recordsCount;
      Gi_00002 = Gb_00002;
      if (Gi_00002 > 0) return; 
      

      Controlla se non ci sono record (dati storici) disponibili. Se recordsCount è 0, Gb_00002 diventa vero (true). Se è vero, il metodo è interrotto per mancanza di dati storici.

    5. Ricerca nell'array dei prezzi storici

      Questa sezione è utilizzata per trovare l'indice di un record di prezzo storico che corrisponde al tempo corrente (Time[0]). Inizializza currentHistoryIndex a -1 come valore di partenza. Poi esegue un ciclo attraverso l'array priceHistory, partendo da zero, incrementando openOrderIndex finché non trova un timestamp uguale o superiore a Time[0]. L'obiettivo è calcolare currentHistoryIndex che poi potrebbe essere usato per accedere a dati storici specifici.

    Conclusioni

    Questo blocco di codice esegue controlli preliminari sulla validità del singolo tick ricevuto: assicura che non sia un duplicato, che ci sia consistenza con il volume delle barre precedenti e che ci siano dati storici disponibili. Poi prepara l'indice per accedere ai dati di prezzo storicizzati da utilizzare nell'analisi del mercato corrente. L'indice trovato può essere poi usato per analisi tecniche più approfondite o decisioni di trading basate su dati storici nel contesto dell'EA.

  3. User

    in questo pezzo Gl_00002 = iVolume(_Symbol, 15, 0); cosa posso mettere al posto di 15 per il timeframe corrente?

  4. Assistant

    Per utilizzare il timeframe corrente in MQL4 all'interno di funzioni come iVolume, iOpen, iHigh, iLow, ecc., puoi utilizzare la costante predefinita PERIOD_CURRENT. Questa costante si adatta automaticamente al timeframe del grafico su cui è eseguito l'Expert Advisor o l'indicatore.

    Quindi, se vuoi usare il timeframe corrente al posto di un valore fisso come 15, il tuo codice diventerà:

    Gl_00002 = iVolume(_Symbol, PERIOD_CURRENT, 0);
    

    Questa modifica fa sì che il tuo EA consideri il volume dell'ultimo bar (indice 0) sul timeframe attuale su cui l'EA è applicato, consentendo una maggiore flessibilità e rendendo l'EA adattabile a diversi timeframe senza dover cambiare manualmente i parametri nel codice.

  5. User

    se dovessi rinominare Gb_00002 ?

  6. Assistant

    Se desideri rinominare la variabile Gb_00002 in qualcosa di più descrittivo o più facile da ricordare (cosa consigliata per migliorare la leggibilità del codice), puoi semplicemente sostituire ogni occorrenza di Gb_00002 con il nuovo nome che hai scelto. Assicurati solo di utilizzare una convenzione di denominazione consistente e un nome che descriva lo scopo o il valore rappresentato dalla variabile.

    Per esempio, se Gb_00002 viene utilizzata per controllare se sono disponibili dati storici (come sembra dal contesto), potresti rinominarla isHistoryDataAvailable o hasRecords. Questo rende il codice più autoesplicativo. Ecco come farlo:

    1. Cambia il nome della variabile da Gb_00002 a isHistoryDataAvailable all'inizio del suo utilizzo nel codice.

    2. Cerca e sostituisci tutte le altre occorrenze di Gb_00002 nel codice con isHistoryDataAvailable.

    Ecco un esempio di come appare tale modificazione nel contesto dato:

    // Gb_00002 = !recordsCount;
    isHistoryDataAvailable = !recordsCount; // Cambiato il nome della variabile
    // Gi_00002 = Gb_00002;
    Gi_00002 = isHistoryDataAvailable; // Aggiornato per usare il nuovo nome della variabile
    if (Gi_00002 > 0) return;
    

    Tieni presente che quando rinomini una variabile, dovresti assicurarti che il nuovo nome non sia già in uso da altre variabili nello stesso ambito e che rispetti le regole di denominazione delle variabili in MQL4.

    Usare nomi di variabili chiari e descrittivi può aiutare enormemente a comprendere cosa fa il tuo codice a uno sguardo, rendendo la manutenzione e l'aggiornamento del tuo codice meno propensi ad errori e più efficienti nel tempo.

  7. User

    e le altre variabili con nomi non chiari come le chiameresti?

  8. Assistant

    Rinominare le variabili per migliorare la chiarezza del codice è una buona pratica in programmazione. Usando i nomi forniti nel frammento di codice e il loro contesto d'uso, ecco alcune proposte di rinominazione più descrittive:

    1. Gb_00002 diventa isHistoryDataAvailable: Come discusso, indica se ci sono dati storici disponibili.

    2. Gi_00002 potrebbe essere rinominata in hasValidHistoryData o semplicemente isValidData: Indica se i dati storici sono pronti per essere utilizzati o controlli di inizio validità.

    3. Gl_00002 potrebbe diventare currentBarVolume: Utilizzata per conservare il volume dell'ultima barra nel codice che hai mostrato.

    4. Il_00090 potrebbe essere rinominata in lastTickTime: Utilizzata per controllare l'ultimo tempo di tick ricevuto.

    5. recordsCount sembra abbastanza chiaro, ma potresti specificare ulteriormente come totalHistoryRecords se vuoi esplicitare che si tratta della quantità totale dei record storici.

    6. Gi_00004 e simili variabili numerate potrebbero essere rinominate basandosi sulla loro funzione specifica nel contesto più ampio che non è completamente chiaro dal frammento di codice. Ad esempio, se Gi_00004 tiene traccia dell'indice finale per un'iterazione, potrebbe essere endIndex o lastValidIndex.

    7. currentHistoryIndex già sembra avere un nome descrittivo, indicando l'indice corrente all'interno di un array di dati storici.

    8. openOrderIndex sembra ben nominato, indicando presumibilmente l'indice di iterazione attraverso gli ordini aperti.

    9. priceHistory è adeguatamente nominata per indicare un array contenente dati di prezzo storici.

    10. MagicID è comunemente usato in MQL per identificare univocamente gli Expert Advisors, quindi il suo nome è abbastanza descrittivo così com'è.

    Nel rinominare variabili, è importante mantenere la coerenza nel tuo codice e nel tuo progetto. Se adotti la pratica di utilizzare nomi completi e descrittivi, applicalo in tutto il progetto per mantenere un codice pulito e facilmente comprensibile. Ricorda che rinominare variabili è un processo riflessivo: il nuovo nome dovrebbe comunicare lo scopo e il significato della variabile con chiarezza a chiunque legga il codice in futuro, incluso il te stesso.

  9. User

    a cosa serve Gi_00004 = recordsCount - 1; } while (openOrderIndex < Gi_00004); sembra inutile

  10. Assistant

    Hai ragione nel mettere in discussione l'utilità di quella specifica linea e del suo utilizzo nel ciclo do-while. La linea:

    Gi_00004 = recordsCount - 1;
    

    insieme a:

    } while (openOrderIndex < Gi_00004); 
    

    sembra assegnare a Gi_00004 il valore di recordsCount - 1 ad ogni iterazione del ciclo, per poi usarlo per confrontare con openOrderIndex e decidere se continuare o meno il ciclo.

    Tuttavia, dato che recordsCount non cambia durante l'esecuzione di questo ciclo, ripetere l'assegnazione del valore a Gi_00004 ad ogni iterazione è in effetti ridondante. Potresti semplicemente assegnare il valore a Gi_00004 una volta prima di iniziare il ciclo e poi usarlo nel confronto senza rinominarlo ad ogni iterazione:

    Gi_00004 = recordsCount - 1;
    do { 
        // Codice del ciclo qui...
    } while (openOrderIndex < Gi_00004); 
    

    Questo codice fa sostanzialmente la stessa cosa ma è più efficiente perché evita assegnamenti inutili dentro il ciclo.

    L'uso di Gi_00004 sembra servire a fare in modo che il ciclo si fermi prima dell'ultimo elemento nell'array priceHistory, forse per evitare accessi fuori dai limiti dell'array o perché l'ultimo record non è rilevante per l'operazione che si sta eseguendo. Tuttavia, senza vedere il resto del codice, questa è solo una supposizione.

    In sintesi, la linea non è inutile se l'intento è limitare il ciclo ad iterare fino all'elemento prima dell'ultimo dell'array. Ciò che è ridondante è piuttosto l'assegnazione ripetuta del valore a Gi_00004 dentro il ciclo, la quale può essere effettuata una sola volta all'esterno del ciclo stesso.

  11. User

    ti ho dato il codice completo nel primo post

  12. Assistant

    Hai ragione, grazie per avermelo fatto notare. Avendo ora una visione completa del contesto, possiamo riesaminare l'uso della variabile Gi_00004.

    La funzione del ciclo come presentato:

    Gi_00002 = recordsCount - 1;
    if (Gi_00002 > 0) { 
    do { 
        if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; 
        currentHistoryIndex = openOrderIndex + 1;
        openOrderIndex = openOrderIndex + 1;
        Gi_00004 = recordsCount - 1;
    } while (openOrderIndex < Gi_00004); 
    }
    

    dove Gi_00004 viene inizializzato all'interno del ciclo con il valore recordsCount - 1, appare effettivamente ridondante in questo specifico contesto, dato che recordsCount non cambia nel ciclo. L'obiettivo di tale ciclo sembra essere quello di identificare un indice (currentHistoryIndex) all'interno dell'array priceHistory basato sul tempo corrente. Il ciclo termina quando openOrderIndex è minore dell'ultimo indice valido di priceHistory, che è dato da recordsCount - 1.

    Rivedendo la struttura del ciclo:

    1. L'assegnazione ripetuta di Gi_00004 = recordsCount - 1; dentro il ciclo non è necessaria. Questo valore può essere impostato una volta prima di entrare nel ciclo, poiché non cambia.

    2. Gi_00004 in questo contesto serve effettivamente a evitare che openOrderIndex superi il numero di record disponibili nell'array priceHistory. Questo previene l'accesso a un indice inesistente che causerebbe un errore.

    Rifacendo leggermente:

    Gi_00004 = recordsCount - 1;
    if (Gi_00002 > 0) { // Qui hai usato un'altra variabile, Gi_00002, ma sembra stia verificando se ci sono records.
    do { 
        if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; 
        currentHistoryIndex = openOrderIndex + 1;
        openOrderIndex = openOrderIndex + 1;
        // La rimozione dell'assegnazione a Gi_00004 qui rende il codice più pulito e performante
    } while (openOrderIndex < Gi_00004); // Controllo eseguito una sola volta fuori dal ciclo
    }
    

    Sembra che la struttura originale del codice potrebbe trarre vantaggio da una leggera ottimizzazione rimuovendo l'assegnazione ridondante. Inoltre, indicazioni chiare sui nomi delle variabili come in precedenti suggerimenti aiuterebbero a rendere lo scopo del ciclo e l'utilizzo delle variabili molto più chiaro.

  13. User

    if (lastTickTime == Time[0]) return; lastTickTime = Time[0]; ChartRedraw(0); currentBarVolume = iVolume(_Symbol, 15, 0); if (currentBarVolume > iVolume(_Symbol, 15, 1)) return; isHistoryDataAvailable = !recordsCount; isValidData = isHistoryDataAvailable; if (isValidData > 0) return; currentHistoryIndex = -1; openOrderIndex = 0; isValidData = recordsCount - 1; if (isValidData > 0) { do { if ((priceHistory[openOrderIndex, 0] >= Time[0])) break; currentHistoryIndex = openOrderIndex + 1; openOrderIndex = openOrderIndex + 1; } while (openOrderIndex < isValidData); } così funziona ugualmente giusto? e ho eliminato un'assegnazione inutile

  14. Assistant

    Sì, la revisione del codice che hai effettuato sembra corretta e dovrebbe funzionare mantenendo la logica originale intatta, pur migliorandone la chiarezza e l'efficienza mediante l'eliminazione di un'assegnazione ridondante. Vediamo i punti chiave della tua revisione:

    1. Rimosso l'assegnamento ridondante di Gi_00004: Dato che tale valore era effettivamente equivalente a recordsCount - 1 e utilizzato per limitare il ciclo do-while, la tua modifica per utilizzare direttamente isValidData mantiene la funzionalità e allo stesso tempo semplifica il codice.

    2. Rinominato le variabili: Le variabili ora hanno nomi descrittivi (lastTickTime, currentBarVolume, isHistoryDataAvailable, isValidData ecc.), rendendo il codice più leggibile e più facile da mantenere.

    3. Confronti e controlli logici: I confronti che fai e la logica di controllo flusso (ad esempio, l'uso di return per uscire precocemente dal metodo se certe condizioni sono soddisfatte) sono mantengono intatti, preservando la logica originale del codice.

    4. Verifica della disponibilità dei dati storici: Utilizzi isHistoryDataAvailable = !recordsCount; e poi isValidData = isHistoryDataAvailable;, ma sembra che tu voglia verificarne la disponibilità contrassegnando isValidData direttamente con recordsCount - 1. Questo cambia un po' l'intenzione originale del controllo di disponibilità; !recordsCount sembrava verificare se recordsCount fosse 0 (quindi non vi sono dati), mentre recordsCount - 1 verifica che ci siano dati sufficienti. Inoltre, assegni un valore numerico a isValidData, ma poi lo utilizzi come se fosse un booleano nella condizione if (isValidData > 0) return; , che tecnicamente funziona ma potrebbe essere leggermente fuorviante nella lettura del codice.

    Riassumendo, il tuo codice migliorato dovrebbe funzionare come previsto, e la rimozione dell'assegnazione ridondante e il miglioramento nella nominazione delle variabili sono ottimi passi avanti verso un codice più pulito e manutenibile. Tuttavia, ti consiglio di rivedere la logica di isHistoryDataAvailable e isValidData per assicurarti che riflettano esattamente l'intenzione desiderata, dato che sembra che ci sia un piccolo cambiamento nella logica di quello che intendono rappresentare rispetto all'originale.

  15. User

    spiegami meglio l'ultima affermazione

  16. Assistant

    Certo, spiego più in dettaglio.

    Nella versione originale del codice, c'erano due variabili distinte Gb_00002 (che ho suggerito di rinominare in isHistoryDataAvailable) e Gi_00002, che veniva utilizzata per alcuni controlli di validità. Quando hai apportato modifiche al codice, hai introdotto isHistoryDataAvailable e isValidData con una leggera modifica nell'uso rispetto all'originale:

    isHistoryDataAvailable = !recordsCount;
    isValidData = isHistoryDataAvailable;
    if (isValidData > 0) return;
    

    e successivamente:

    isValidData = recordsCount - 1;
    if (isValidData > 0) { 
    

    Ecco dove potrebbe esserci confusione:

    1. Verifica della disponibilità di dati storici: !recordsCount sembra voler indicare "non ci sono records", dove recordsCount è il numero totale di record. In C++ e MQL4, !0 equivale a true (perché ! è l'operatore di negazione che inverte il valore booleano, quindi da false a true), e !X (dove X è un qualsiasi numero diverso da zero) equivale a false. Quindi, isHistoryDataAvailable = !recordsCount; assegnerebbe true se recordsCount fosse zero, il che sembra il contrario di quanto probabilmente intendevi. Probabilmente volevi che isHistoryDataAvailable fosse true se ci sono records. Quindi, questa logica potrebbe confondere la reale intenzione.

    2. La seconda assegnazione a isValidData: Qui stai assegnando a isValidData il valore di recordsCount - 1. Questo uso di isValidData sembra divergere dal suo utilizzo iniziale dove era praticamente un booleano e ora rappresenta l'indice dell'ultimo record valido (recordsCount - 1). La tua condizione nel ciclo do-while è corretta per il contesto dell'iterazione attraverso gli indici, ma la dualità nell'uso di isValidData (prima come controllo booleano, poi come indice) potrebbe generare confusione.

    3. Riflessione sull'intento originale e la logica coerente: La parte cruciale qui è chiarire l'intento di queste variabili e assicurarsi che la logica rifletta esattamente ciò che vuoi ottenere. Per esempio, potresti voler verificare che ci siano dati disponibili con qualcosa come bool isHistoryDataAvailable = recordsCount > 0; per rendere esplicito che isHistoryDataAvailable è true se il conteggio dei records è maggiore di zero.

    Quindi, la confusione potrebbe derivare da come questi controlli vengono implementati e dalla scelta dei nomi delle variabili che potrebbero non riflettere precisamente la loro funzione nel codice migliorato. L'approccio dovrebbe concentrarsi sulla chiarezza dell'intenzione: per esempio, utilizzando variabili booleane per effettuare controlli booleani (ci sono dati? Sì/No) e variabili numeriche/indici quando si lavora con indici o conteggi specifici (qual è l'ultimo indice valido?).

  17. User

    quindi sarebbe meglio rinominare le variabili o riscrivere il codice?

  18. Assistant

    La decisione tra rinominare le variabili o riscrivere parti del codice dipende dal grado di chiarezza e manutenibilità che desideri raggiungere. Idealmente, dovresti puntare a un equilibrio in cui il codice sia sia chiaro che funzionale. Qui ci sono alcune riflessioni per entrambe le opzioni:

    Rinominare le Variabili

    Rinominare le variabili per rendere più chiaro il loro scopo è spesso il primo passo da considerare. Questo può aiutare notevolmente nella comprensione del codice senza cambiarne la logica. Per il tuo caso:

    • isHistoryDataAvailable: Questo nome sembra suggerire correttamente un valore booleano riguardo alla disponibilità dei dati storici, ma la sua inizializzazione (!recordsCount) potrebbe essere confusa. Se recordsCount è il conteggio totale dei record, allora un nome come hasNoHistoryRecords con recordsCount == 0 o hasHistoryRecords con recordsCount > 0 potrebbe essere più diretto e chiaro.
    • isValidData: Questa varia tra essere usata come un booleano e come un indice. Potresti dividere questa logica in due variabili distinte per chiarezza, ad esempio:
      • bool hasValidData = recordsCount > 0; per il controllo booleano,
      • e int lastRecordIndex = recordsCount - 1; per l'indice.

    Riscrivere il Codice

    Se, dopo aver rinominato le variabili, il codice risulta ancora confuso o complesso, potrebbe essere il momento di considerare una riscrittura parziale per semplificarlo o migliorarne la lettura. Riscrivere parti del codice può aiutarti a:

    • Eliminare la confusione tra uso di variabili come booleani e come indici.
    • Separare chiaramente i controlli logici dall'iterazione e dall'accesso agli indici.
    • Rendere il codice più compatto e leggibile, riducendo la complessità dove possibile.

    Per esempio, puoi combinare i controlli iniziali in meno righe di codice ed esplicitare meglio i controlli:

    if (lastTickTime == Time[0]) return; 
    lastTickTime = Time[0];
    ChartRedraw(0);
    
    currentBarVolume = iVolume(_Symbol, PERIOD_CURRENT, 0); // Se usi PERIOD_CURRENT per il timeframe corrente
    if (currentBarVolume > iVolume(_Symbol, PERIOD_CURRENT, 1)) return; 
    
    if (recordsCount <= 0) return;  // Esce se non ci sono dati storici
    
    currentHistoryIndex = -1;
    openOrderIndex = 0;
    int lastValidIndex = recordsCount - 1;
    do { 
        if (priceHistory[openOrderIndex][0] >= Time[0]) break; 
        currentHistoryIndex = openOrderIndex + 1;
        openOrderIndex += 1;
    } while (openOrderIndex < lastValidIndex);
    

    Questo esempio rende il flusso del codice più lineare e diretto, mantenendo distinte le logiche di validazione dei dati dall'iterazione e dall'accesso agli array.

    Conclusione

    La scelta tra rinominare le variabili e/o riscrivere il codice dipende da quanto profondamente desideri migliorare la chiarezza e la manutenibilità del tuo codice. Spesso, una combinazione di entrambi gli approcci offre il miglior equilibrio tra chiarezza, efficienza e facilità di manutenzione.

  19. User

    sembra funzionare bene la tua proposta. puoi aggiungere dei commenti in modo che sia chiaro cosa succede nel codice?

  20. Assistant

    Certo, aggiungere commenti aiuta a chiarire lo scopo e il funzionamento di specifiche porzioni di codice per te (e per chiunque altro che possa lavorare su di esso in futuro). Ecco il codice con i commenti aggiunti per spiegare ogni parte:

    // Controlla se l'ultimo tick processato è lo stesso del tick corrente per evitare duplicati
    if (lastTickTime == Time[0]) return; 
    // Aggiorna il tempo dell'ultimo tick processato
    lastTickTime = Time[0];
    
    // Ricalcola il grafico per assicurare che i dati visualizzati siano aggiornati
    ChartRedraw(0);
    
    // Recupera il volume dell'ultima barra sul timeframe corrente e lo confronta con quello della barra precedente
    currentBarVolume = iVolume(_Symbol, PERIOD_CURRENT, 0); // Usa PERIOD_CURRENT per il timeframe corrente
    // Se il volume dell'ultima barra è superiore a quello della barra precedente, esce (potenziale segnale di volatilità)
    if (currentBarVolume > iVolume(_Symbol, PERIOD_CURRENT, 1)) return; 
    
    // Esci se non ci sono record storici disponibili per l'analisi
    if (recordsCount <= 0) return;  
    
    // Inizializza l'indice che terrà traccia della posizione corrente nell'array dei prezzi storici
    currentHistoryIndex = -1;
    // Inizializza l'indice per iterare attraverso i record dei prezzi storici
    openOrderIndex = 0;
    // Calcola l'indice dell'ultimo record valido nell'array dei prezzi storici
    int lastValidIndex = recordsCount - 1;
    
    // Itera attraverso i record dei prezzi storici per trovare una corrispondenza con il tempo corrente
    do { 
        // Se il tempo del record corrente è maggiore o uguale al tempo corrente, termina il ciclo
        if (priceHistory[openOrderIndex][0] >= Time[0]) break; 
        // Aggiorna l'indice della storia corrente per l'ultima corrispondenza trovata
        currentHistoryIndex = openOrderIndex + 1;
        // Passa al record successivo
        openOrderIndex += 1;
    } while (openOrderIndex < lastValidIndex); // Continua fino a che non si raggiunge l'ultimo record valido
    

    Questo codice commentato offre una panoramica dettagliata di cosa aspettarsi da ogni blocco logico. Spiegando la funzionalità in modo chiaro, rendi il codice più accessibile a te stesso e agli altri nel tempo, facilitando comprensione, manutenzione e potenziali estensioni o correzioni.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.