Ho sviluppato questo listato utilizzando JavaScript ES5 e desidero evitare l’uso delle…
- User
Ho sviluppato questo listato utilizzando JavaScript ES5 e desidero evitare l’uso delle funzionalità moderne di ES6. Vorrei un’analisi dettagliata di questo codice in italiano, focalizzandosi sui seguenti aspetti:
- Ridondanza di codice o controlli logici: Evidenziare eventuali duplicazioni o controlli logici non necessari.
- Ottimizzazioni: Indicare possibili miglioramenti per aumentare l’efficienza del codice.
- Compattazioni: Suggerire modi per rendere il codice più compatto.
- Miglioramento dell’efficienza e della velocità di esecuzione: Consigli su come ottimizzare le prestazioni del codice. Per ciascuno dei punti da 1 a 4, sarebbero graditi suggerimenti specifici. var CONFIG = { ORDER_SIDE: 'BID', SIZE: 1, MAX_OPERATIONS: 8, LEVELS: { BID: 6, ASK: 6 }, SECONDS: 5, MONITORING_MODE: 'MONITORA_yourlevel' };
var separator = "---------------------------------------------------\r\n";
var BookUtils = { dataTypes: { 'Price': function(level) { return this.Price(level); }, 'Quantity': function(level) { return this.Quantity(level); } }, getData: function(book, side, level, type) { var sideData = (side === 'BID') ? book.Bid : book.Ask; var typeFunc = this.dataTypes[type]; return typeFunc.call(sideData, level); }, getBookState: function(book) { return { bidPrice: this.getData(book, 'BID', 0, 'Price'), bidQuantity: this.getData(book, 'BID', 0, 'Quantity'), askPrice: this.getData(book, 'ASK', 0, 'Price'), askQuantity: this.getData(book, 'ASK', 0, 'Quantity') }; } };
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].oldLevel = price; return order; }, processOrModOrder: function(side, stock, price) { var currentOrder = UserContext.order.current; if (currentOrder && currentOrder.Price === price) { return currentOrder; } if (currentOrder) { return this.updateOrderContext(OrderManager.Modify(currentOrder.OrderCode, price), side, price); } return this.updateOrderContext(this.execOrder(side, stock, price, CONFIG.SIZE), side, price); }, deleteOrder: function(orderCode) { return OrderManager.Delete(orderCode); } };
var Helper = { messages: { 'Initialization Complete': "Inizializzazione completata:\nBid Price 0: {bidPrice}\nAsk Price 0: {askPrice}\n", 'Order Action': 'Ordine {action}: {orderCode}\n', 'Price Variation': "Livello da {lastLevel} all'attuale livello {priceLevel}\n", 'Order Deleted': 'Ordine cancellato: {orderCode}\n', 'PriceChange': "ULTIMO PREZZO: {currentPrice}, Precedente: {previousPrice}, Ora: {currentTime}\r\n" + separator, 'message': "{message}\r\n" + separator }, formatMessage: function(template, data) { return template.replace(/{(\w+)}/g, function(match, key) { return data.hasOwnProperty(key) ? data[key] : match; }); }, 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; }, log: function(type, data, includeFormattedState) { includeFormattedState = (typeof includeFormattedState !== 'undefined') ? includeFormattedState : true; var template = this.messages[type]; if (template) { var message = this.formatMessage(template, data || {}); if (includeFormattedState && (type === 'Initialization Complete' || type === 'Price Variation')) { message += this.formatState(BookUtils.getBookState(UserContext.book)); } Log(separator + message); } }, logFormattedState: function() { var bookState = BookUtils.getBookState(UserContext.book); Log(this.formatState(bookState)); }, priceDirection: function(targetPrice, oldPrice) { return (targetPrice > oldPrice) ? 1 : ((targetPrice < oldPrice) ? -1 : 0); } };
function setupTradeContext() { var book = Book(ps);
UserContext = { book: book, order: { current: null }, status: { run: true, secondCount: 0, numOperazione: 0 }, prices: { BID: { current: BookUtils.getData(book, 'BID', 0, 'Price'), oldLevel: BookUtils.getData(book, 'BID', getTargetPriceLevel('BID'), 'Price') }, ASK: { current: BookUtils.getData(book, 'ASK', 0, 'Price'), oldLevel: BookUtils.getData(book, 'ASK', getTargetPriceLevel('ASK'), 'Price') } }, targetPriceLevels: { BID: getTargetPriceLevel('BID'), ASK: getTargetPriceLevel('ASK') } }; var bookState = BookUtils.getBookState(UserContext.book); Helper.log('Initialization Complete', { bidPrice: bookState.bidPrice, askPrice: bookState.askPrice }, false); var side = CONFIG.ORDER_SIDE; var price = BookUtils.getData(book, side, UserContext.targetPriceLevels[side], 'Price'); var size = CONFIG.SIZE; UserContext.prices[side].current = price; var initialOrder = OrderUtils.execOrder(side, stock, price, size); OrderUtils.updateOrderContext(initialOrder, side, price); Helper.log('Order Action', { action: 'inserito', orderCode: initialOrder.OrderCode }, false); Helper.logFormattedState(); manageCycle();}
function getTargetPriceLevel(side) { return (CONFIG.MONITORING_MODE === 'MONITORA_1Level' ? 0 : CONFIG.LEVELS[side] - 1); }
function priceUpdate(side, book) { var context = UserContext; var status = context.status; var pricesSide = context.prices[side]; var targetPriceLevel = context.targetPriceLevels[side]; var targetPrice = BookUtils.getData(book, side, targetPriceLevel, 'Price'); var oldPrice = pricesSide.oldLevel;
if (targetPrice !== oldPrice) { var newOrder = OrderUtils.processOrModOrder(side, ps, targetPrice); if (newOrder) { pricesSide.current = targetPrice; var levelDiff = CONFIG.LEVELS[side] + Helper.priceDirection(targetPrice, oldPrice); Helper.log('Price Variation', { lastLevel: levelDiff, priceLevel: targetPriceLevel }); status.secondCount = 0; status.numOperazione++; }} }
function checkOps() { var status = UserContext.status; var currentOrder = UserContext.order.current; if (status.numOperazione >= CONFIG.MAX_OPERATIONS) { if (currentOrder) { var deletedOrder = OrderUtils.deleteOrder(currentOrder.OrderCode); Helper.log('Order Deleted', { orderCode: deletedOrder.OrderCode }); status.run = false; return true; } } return false; }
function manageCycle() { var status = UserContext.status; if (checkOps()) return; if (status.secondCount >= CONFIG.SECONDS) { var side = CONFIG.ORDER_SIDE; var book = UserContext.book; priceUpdate(side, book); status.secondCount = 0; } }
function handleTimeEvent() { UserContext.status.secondCount++; manageCycle(); }
function handlePriceEvent(currentPrice) { var context = UserContext; if (context.lastPrice !== currentPrice) { var currentTime = Now().ToString("HH:mm:ss.ff"); Helper.log('PriceChange', { currentPrice: currentPrice, previousPrice: context.lastPrice, currentTime: currentTime }); context.lastPrice = currentPrice; } }
var eventHandlers = {}; eventHandlers[TSEventType.Price] = function() { handlePriceEvent(Val(ps, "LAST")); }; eventHandlers[TSEventType.Time] = handleTimeEvent;
function marketEvent() { if (UserContext.status.run && eventHandlers[SystemContext.EventType]) { eventHandlersSystemContext.EventType; } }
if (SystemContext.IsFirst) { setupTradeContext(); }
marketEvent();
- Assistant
Analizziamo il codice JavaScript ES5 fornito nei suoi aspetti richiesti:
1. Ridondanza di codice o controlli logici:
-
BookUtils.dataTypes: La mappadataTypesè ridondante perché non esiste effettivamente alcuna implementazione perPriceeQuantity. Questo potrebbe essere diretto verso la struttura di datibookche si assume abbia queste proprietà. -
priceDirection: Questa funzione è utilizzata una sola volta e può essere ridotta in linea là dove è necessaria, se il codice deve essere reso più compatto. Tuttavia, se la funzione viene utilizzata più volte, si potrebbe mantenere così per chiarezza.
2. Ottimizzazioni:
-
Controllo ridondante in
OrderUtils.processOrModOrder: Il check percurrentOrderè presente due volte, potrebbe essere semplificato unendo la logica di modifica e nuovo ordine. -
Migliorare la gestione degli eventi: Considerare l'uso di meccanismi di ascolto più efficienti per gestire eventi di prezzo. Evitare controlli multipli per
SystemContext.EventType, implementando ad esempio un hash di funzioni dirette.
3. Compattazioni:
-
Utilizzo di variabili: Alcune variabili temporanee potrebbero non essere necessarie. Ad esempio,
var status = UserContext.status;in varie funzioni non è strettamente necessario se è usata solo una o due volte. -
Template per
Helper.messages: La struttura dimessagespuò essere ottimizzata eliminando stringhe non utilizzate o consolidando i messaggi simili.
4. Miglioramento dell’efficienza e della velocità di esecuzione:
-
Migliorare
BookUtils.getData: Verificare se il metodo di accesso ai dati del book può essere ottimizzato utilizzando riferimenti diretti invece di funzioni se i book sono solo oggetti semplici. -
manageCyclechiamato solo su necessità: InhandleTimeEvent,manageCycleviene sempre chiamato ad ogni incremento disecondCount, anche quando non necessario. Puoi sostituirlo con una logica che chiamapriceUpdatesolo quandosecondCountsuperaCONFIG.SECONDS.
Risultati e suggerimenti specifici:
-
Evitare duplicazione dei controlli: In
processOrModOrder, si può migliorare con:if (currentOrder) { if (currentOrder.Price === price) return currentOrder; return this.updateOrderContext(OrderManager.Modify(currentOrder.OrderCode, price), side, price); } return this.updateOrderContext(this.execOrder(side, stock, price, CONFIG.SIZE), side, price); -
Eventi gestiti con più precisione: Crea metodi specifici per la gestione di ogni tipo di evento al posto di utilizzare un hash centrale, riducendo i controlli condizionali in
marketEvent.
Riducendo alcune complessità e verificando l'accesso efficiente ai dati, il codice può non solo diventare più gestibile, ma anche più performante senza dover utilizzare funzionalità avanzate di ES6.
-
- User
BookUtils.dataTypes: La mappa dataTypes è ridondante perché non esiste effettivamente alcuna implementazione per Price e Quantity. Questo potrebbe essere diretto verso la struttura di dati book che si assume abbia queste proprietà. Mi fai vedere le modifiche del codice mio necessarie a togliere dataTypes ?
- Assistant
Certamente! Per eliminare la mappa
dataTypesdaBookUtils, puoi accedere direttamente alle proprietàPriceeQuantityall'interno del metodogetData. Supponendo che ilbooksia strutturato in modo che ogni livello abbia proprietàPriceeQuantity, puoi modificare il codice nel seguente modo:Codice Modificato per
BookUtils:var BookUtils = { getData: function(book, side, level, type) { var sideData = (side === 'BID') ? book.Bid : book.Ask; var levelData = sideData[level]; // Assumi che ogni livello sia un oggetto con proprietà 'Price' e 'Quantity'. if (type === 'Price') { return levelData.Price; } else if (type === 'Quantity') { return levelData.Quantity; } // Se il tipo richiesto non esiste, restituisci undefined o gestisci l'errore. return undefined; }, getBookState: function(book) { return { bidPrice: this.getData(book, 'BID', 0, 'Price'), bidQuantity: this.getData(book, 'BID', 0, 'Quantity'), askPrice: this.getData(book, 'ASK', 0, 'Price'), askQuantity: this.getData(book, 'ASK', 0, 'Quantity') }; } };Explicazione delle Modifiche:
-
Accesso Diretto ai Dati del Livello: Ora accediamo direttamente alle proprietà
.Pricee.QuantitysusideData[level], che assume che ogni livello nella struttura dei dati contenga direttamente questi campi. -
Rimozione di
dataTypes: Abbiamo eliminato la mappadataTypespoiché non è più necessaria, semplificando così la logica e riducendo la ridondanza. -
Gestione del Tipo Non Valido: Se vuoi gestire in modo più robusto il caso di tipo non valido, puoi aggiungere un controllo o lanciare un errore.
Con queste modifiche,
BookUtilsdiventa più snello e più comprensibile, utilizzando semplici controlli condizionali per determinare quale dato restituire. -
- User
Eventi gestiti con più precisione: Crea metodi specifici per la gestione di ogni tipo di evento al posto di utilizzare un hash centrale, riducendo i controlli condizionali in marketEvent. Mi mostri come ?
- Assistant
Certamente! Attualmente, stai utilizzando un oggetto
eventHandlersper memorizzare le funzioni di gestione degli eventi e una funzionemarketEventche verifica il tipo di evento nel contesto di sistema. Possiamo migliorare la gestione degli eventi suddividendo la logica in singole funzioni specifiche per ciascun tipo di evento. Questo riduce i controlli condizionali e rende il codice più chiaro e modulare.Modifiche Proposte:
- Creazione di Funzioni per Ogni Tipo di Evento:
function handlePriceEvent() { var currentPrice = Val(ps, "LAST"); var context = UserContext; if (context.lastPrice !== currentPrice) { var currentTime = Now().ToString("HH:mm:ss.ff"); Helper.log('PriceChange', { currentPrice: currentPrice, previousPrice: context.lastPrice, currentTime: currentTime }); context.lastPrice = currentPrice; } } function handleTimeEvent() { UserContext.status.secondCount++; manageCycle(); }- Direttamente Associa Funzioni di Gestione con gli Eventi:
Invece di usare l'oggetto
eventHandlers, puoi direttamente chiamare la funzione appropriata in base al tipo di evento:function marketEvent() { if (!UserContext.status.run) return; switch (SystemContext.EventType) { case TSEventType.Price: handlePriceEvent(); break; case TSEventType.Time: handleTimeEvent(); break; // Aggiungi altri casi per altri tipi di evento, se necessario. } }- Rimozione dell'HASH
eventHandlerse RistrutturazionemarketEvent:
Eliminando l'oggetto
eventHandlers, il codice è più semplice e leggibile. La funzionemarketEventdiventa una centralina chiara dove, a seconda del tipo di evento, chiami la funzione specificata.Vantaggi:
- Migliore Chiarezza e Manutenibilità: Separando ciascun gestore di eventi, diventa più facile modificare e comprendere la logica specifica per ogni tipo di evento.
- Riduzione dei Controlli: La nuova struttura semplifica il flusso condizionale riducendo la necessità di lookup in un oggetto dedicato.
Questa suddivisione dell'elaborazione degli eventi permette una gestione più diretta e leggibile degli eventi che si verificano nel tuo sistema.