Ho scritto questo listato in Java Script ES5, e non vorrei programmare nelle…
- User
Ho scritto questo listato in Java Script ES5, e non vorrei programmare nelle funzionalita’ moderne di ES6. Vorrei un’analisi di questo listato in lingua italiana, in particolare segnalando 1 ridondanza di codice oppure di controlli logici, 2 ottimizzazioni, 3 compattazioni, 4 ricerca di maggiore efficienza e velocita’ di esecuzione del codice. Inoltre per ogni punto da 1 a 4 se vorrai darmi un suggerimento specifico sara’ gradito. Ho scritto questo listato in JavaScript ES5 e preferirei non utilizzare le funzionalità moderne di ES6. Vorrei un’analisi di questo listato in lingua italiana, con particolare attenzione ai seguenti punti e lasciando stare considerazioni su var sideUpper, toUpperCase sideLower e sideUpper che gia’ conosco var CONFIG = { ORDER_SIDE: 'BID', SIZE: 1, MAX_OPERATIONS: 8, LEVELS: { BID: 6, // stay at level ASK: 6 }, SECONDS: 5, MONITORING_MODE: 'MONITORA_yourlevel' // or 'MONITORA_1Level' };
var separator = "---------------------------------------------------\r\n";
var lookup = { BID: { side: 'BID', level: CONFIG.LEVELS.BID }, ASK: { side: 'ASK', level: CONFIG.LEVELS.ASK } };
var BookUtils = { getSideData: function (book, side) { return side === 'BID' ? book.Bid : book.Ask; },
getData: function (book, side, type, level) { var sideData = this.getSideData(book, side); return type === 'Price' ? sideData.Price(level) : sideData.Quantity(level); }, getBookState: function (book) { var bid = book.Bid; var ask = book.Ask; return { bidPrice: bid.Price(0), bidQuantity: bid.Quantity(0), askPrice: ask.Price(0), askQuantity: ask.Quantity(0) }; }};
var OrderUtils = { execOrder: function (side, stock, price, size) { return (side === 'BID') ? OrderManager.Buy(stock, price, size) : OrderManager.Sell(stock, price, size); },
updateOrderContext: function (order, side, price) { UserContext.order.current = order; UserContext.prices[side.toLowerCase()].oldLevel = price; return order; }, processOrModOrder: function (side, stock, price) { var currentOrder = UserContext.order.current; if (currentOrder) { if (currentOrder.Price === price) { return currentOrder; } else { var orderToUpdate = OrderManager.Modify(currentOrder.OrderCode, price); return this.updateOrderContext(orderToUpdate, side, price); } } else { var newOrder = this.execOrder(side, stock, price, CONFIG.SIZE); return this.updateOrderContext(newOrder, side, price); } }, deleteOrder: function (orderCode) { return OrderManager.Delete(orderCode); }};
var Helper = { cachedPriceDirections: {},
priceDirection: function (targetPrice, oldPrice) { return targetPrice > oldPrice ? 1 : (targetPrice < oldPrice ? -1 : 0); }, formatState: function (bookState) { return separator + "Bid Price \tBid Quant. \tAsk Price \tAsk Quant. \r\n" + separator + [bookState.bidPrice, bookState.bidQuantity, bookState.askPrice, bookState.askQuantity].join("\t\t") + "\r\n" + separator + "Numero Operazione: " + UserContext.status.numOperazione + "\r\n" + separator; }, log: function (type, data) { var message = ""; if (type === 'action') { message = getActionMessage(data.actionType, data.payload) + this.formatState(BookUtils.getBookState(UserContext.book)); } else if (type === 'message') { message = data + "\r\n" + separator; } else if (type === 'priceChange') { message = formatPriceChange(data); } Log(separator + message); }};
var actionMessages = { "Initialization Complete": function(data) { return "Inizializzazione completata:\nBid Price 0: " + UserContext.prices.bid.current + "\nAsk Price 0: " + UserContext.prices.ask.current + "\n"; }, "Order Action": function(data) { return 'Ordine ' + data.action + ': ' + data.order.OrderCode + "\n"; }, "Price Variation": function(data) { return 'Livello da ' + data.lastLevel + " all'attuale livello " + data.priceLevel + "\n"; }, "Order Deleted": function(data) { return 'Ordine cancellato: ' + data.order.OrderCode + "\n"; } };
function getActionMessage(actionType, data) { return actionMessages[actionType] ? actionMessages[actionType](data , "") : ""; }
function formatPriceChange(data) { return "ULTIMO PREZZO: " + data.currentPrice + ", " + "Precedente: " + data.previousPrice + ", " + "Ora: " + data.currentTime + "\r\n" + separator; }
function initializeTradeContext(book) { this.book = book; this.order = { current: null, modified: false }; this.status = { run: true, secondCount: 0, numOperazione: 1 }; this.prices = { bid: { current: BookUtils.getData(book, 'BID', 'Price', 0), oldLevel: 0 }, ask: { current: BookUtils.getData(book, 'ASK', 'Price', 0), oldLevel: 0 } }; this.initialPriceLevel = lookup[CONFIG.ORDER_SIDE].level; }
function getTargetPriceLevel(side, priceLevel) { return (CONFIG.MONITORING_MODE === 'MONITORA_1Level' ? priceLevel : CONFIG.LEVELS[side]) - 1; }
function priceUpdate(side, book) { var sideLC = side.toLowerCase(); var priceData = UserContext.prices[sideLC]; var lookupData = lookup[side]; var targetPriceLevel = getTargetPriceLevel(side, lookupData.level); var targetPrice = BookUtils.getData(book, lookupData.side, 'Price', targetPriceLevel); var oldPrice = priceData.oldLevel;
if (targetPrice !== oldPrice) { var newOrder = OrderUtils.processOrModOrder(side, stock, targetPrice); if (newOrder) { priceData.current = targetPrice; Helper.log('action', { actionType: "Price Variation", payload: { order: newOrder, lastLevel: lookupData.level + Helper.priceDirection(targetPrice, oldPrice), priceLevel: targetPriceLevel } }); UserContext.status.secondCount = 0; UserContext.status.numOperazione++; } }}
function checkOps() { var status = UserContext.status; var currentOrder = UserContext.order.current; if (status.numOperazione >= CONFIG.MAX_OPERATIONS && currentOrder) { var deletedOrder = OrderUtils.deleteOrder(currentOrder.OrderCode); Helper.log('action', { actionType: "Order Deleted", payload: { order: deletedOrder } }); status.run = false; return true; } return false; }
function manageCycle(priceLevel) { var status = UserContext.status; if (!status.run || checkOps()) return; if (status.secondCount >= CONFIG.SECONDS || typeof priceLevel !== 'undefined') { priceUpdate(CONFIG.ORDER_SIDE, UserContext.book); } }
function setupTradeContext() { var book = Book(ps); UserContext = new initializeTradeContext(book); Helper.log('action', { actionType: "Initialization Complete", payload: null }); manageCycle(UserContext.initialPriceLevel); }
function marketEvent() { if (!UserContext.status.run) return; var eventType = SystemContext.EventType; var book = UserContext.book || Book(ps); UserContext.book = book;
switch(eventType) { case TSEventType.Price: var currentPrice = Val(ps, "LAST"); if (UserContext.lastPrice !== currentPrice) { var currentTime = Now().ToString("HH:mm:ss.ff"); Helper.log('priceChange', { currentPrice: currentPrice, previousPrice: UserContext.lastPrice, currentTime: currentTime }); UserContext.lastPrice = currentPrice; } break; case TSEventType.Time: UserContext.status.secondCount++; manageCycle(); break; }}
if (SystemContext.IsFirst) { setupTradeContext(); }
marketEvent();
- Assistant
Certamente, procediamo con un'analisi dettagliata del tuo listato JavaScript ES5, focalizzandoci sui quattro punti richiesti: ridondanza di codice o controlli logici, ottimizzazioni, compattazioni e miglioramenti in termini di efficienza e velocità di esecuzione. Fornirò suggerimenti specifici per ciascun punto.
1. Ridondanza di Codice o Controlli Logici
Analisi:
- Funzioni Duplicate: La funzione
initializeTradeContextviene utilizzata per inizializzare il contesto di trading, ma alcune proprietà comeUserContext.bookvengono aggiornate altrove, il che può portare a incoerenze. - Controlli Ripetuti: Nel metodo
processOrModOrderdiOrderUtils, controlli sucurrentOrdervengono effettuati sia per verificare l'esistenza dell'ordine corrente che per confrontare i prezzi, potenzialmente ridondante. - Gestione dei Messaggi: Il sistema di gestione dei messaggi tramite
actionMessagesegetActionMessagepuò essere semplificato per evitare ripetizioni.
Suggerimenti:
- Unificazione delle Inizializzazioni: Consolidare le inizializzazioni del contesto di trading in un'unica funzione per evitare incoerenze e ridondanze.
- Semplificazione dei Controlli: Rifattorizzare i controlli logici per ridurre le verifiche ridondanti. Ad esempio, combinare i controlli su
currentOrderepricein un'unica condizione. - Centralizzazione della Gestione dei Messaggi: Creare una funzione unica per la gestione dei messaggi che possa gestire diversi tipi di messaggi senza dover passare attraverso più livelli di condizioni.
2. Ottimizzazioni
Analisi:
- Uso di Variabili Temporanee: Nell'oggetto
priceUpdate, vengono utilizzate variabili temporanee multiple che potrebbero essere ottimizzate. - Accesso Multiplo a Oggetti Annidati: Accedere ripetutamente a proprietà annidate come
UserContext.statuspuò essere ottimizzato memorizzando riferimenti locali. - Funzioni di Utilità Non Necessarie: Alcune funzioni come
priceDirectionpotrebbero essere semplificate o integrate in altre funzioni.
Suggerimenti:
- Cache di Riferimenti: All'interno delle funzioni, creare riferimenti locali a oggetti annidati per ridurre gli accessi ripetuti. Ad esempio:
function priceUpdate(side, book) { var context = UserContext; var status = context.status; // ... } - Incorporare Funzioni Semplici: Integrare funzioni semplici come
priceDirectiondirettamente dove necessario per ridurre il numero di chiamate di funzione. - Minimizzare l'Uso di Variabili Temporanee: Consolidare le operazioni che utilizzano variabili temporanee multiple in operazioni più dirette.
3. Compattazioni
Analisi:
- Stringhe di Separazione: La variabile
separatorviene utilizzata ripetutamente in diversi contesti, creando stringhe statiche che potrebbero essere migliorate. - Creazione degli Oggetti: Alcuni oggetti possono essere creati in modo più compatto, riducendo le linee di codice e migliorando la leggibilità.
- Funzioni Inline: Alcune funzioni, come
getActionMessageeformatPriceChange, possono essere rese inline per migliorare la compattazione del codice.
Suggerimenti:
- Utilizzo di Template Literals: Anche se si utilizza ES5, è possibile utilizzare la concatenazione più efficiente delle stringhe. Ad esempio, semplificare la funzione
formatState:formatState: function (bookState) { return separator + "Bid Price \tBid Quant.\tAsk Price \tAsk Quant.\r\n" + separator + bookState.bidPrice + "\t\t" + bookState.bidQuantity + "\t\t" + bookState.askPrice + "\t\t" + bookState.askQuantity + "\r\n" + separator + "Numero Operazione: " + UserContext.status.numOperazione + "\r\n" + separator; } - Raggruppamento delle Dichiarazioni: Raggruppare le dichiarazioni di variabili correlate per migliorare la leggibilità e compattezza.
- Minimizzazione delle Funzioni Ausiliarie: Valutare se alcune funzioni ausiliarie possono essere rimosse o combinate con altre per ridurre la complessità complessiva del codice.
4. Miglioramenti in Termini di Efficienza e Velocità di Esecuzione
Analisi:
- Loop e Accessi al DOM: Sebbene il tuo codice non contenga loop pesanti, è importante considerare l'uso efficiente delle strutture dati e degli accessi alle proprietà degli oggetti.
- Ottimizzazione delle Funzioni di Log: La funzione
Helper.logesegue diverse concatenazioni di stringhe che potrebbero rallentare l'esecuzione se chiamate frequentemente. - Gestione dello Stato Globale: L'uso di un oggetto globale
UserContextpuò portare a accessi non ottimizzati e potenziali collisioni di stato.
Suggerimenti:
- Lazy Loading delle Funzioni: Caricare e inizializzare le funzioni solo quando necessario per ridurre il carico iniziale.
- Ottimizzare le Funzioni di Log: Minimizzare l'uso delle concatenazioni di stringhe in
Helper.loge utilizzare tecniche più efficienti di formattazione o limitare la frequenza dei log. - Ridurre l'Uso di Stato Globale: Considerare l'uso di pattern modulari per gestire lo stato locale anziché fare affidamento su un oggetto globale, migliorando così l'accesso ai dati e riducendo la latenza.
Suggerimenti Generali:
- Modularizzazione del Codice: Suddividere il codice in moduli più piccoli e riutilizzabili può migliorare la manutenzione e l'efficienza.
- Caching dei Risultati: Implementare tecniche di caching per risultati di funzioni che vengono chiamate frequentemente con gli stessi parametri.
- Profilazione del Codice: Utilizzare strumenti di profilazione per identificare i colli di bottiglia specifici nel tuo codice e ottimizzare di conseguenza.
Esempio di Ottimizzazione:
Consideriamo la funzione
priceUpdate. Possiamo ottimizzarla riducendo l'accesso ripetuto aUserContexte combinando alcune operazioni:function priceUpdate(side, book) { var context = UserContext; var status = context.status; var prices = context.prices; var lookupData = lookup[side]; var targetPriceLevel = getTargetPriceLevel(side, lookupData.level); var targetPrice = BookUtils.getData(book, lookupData.side, 'Price', targetPriceLevel); var oldPrice = prices[side.toLowerCase()].oldLevel; if (targetPrice !== oldPrice) { var newOrder = OrderUtils.processOrModOrder(side, stock, targetPrice); if (newOrder) { prices[side.toLowerCase()].current = targetPrice; var payload = { order: newOrder, lastLevel: lookupData.level + Helper.priceDirection(targetPrice, oldPrice), priceLevel: targetPriceLevel }; Helper.log('action', { actionType: "Price Variation", payload: payload }); status.secondCount = 0; status.numOperazione++; } } }In questo esempio, abbiamo:
- Creato riferimenti locali a
UserContext,statusepricesper ridurre gli accessi ripetuti. - Consolidato le variabili temporanee per una maggiore leggibilità e efficienza.
- Ottimizzato la gestione del payload per la funzione di log.
Conclusione
Il tuo listato JavaScript ES5 è ben strutturato, ma ci sono diverse aree in cui può essere migliorato in termini di ridondanza, ottimizzazione, compattazione ed efficienza. Applicando i suggerimenti sopra riportati, potresti ottenere un codice più pulito, efficiente e manutenibile. Se hai ulteriori domande o necessiti di chiarimenti specifici, non esitare a chiedere!
- Funzioni Duplicate: La funzione