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, // 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 = { getData: function (book, side, type, level) { var sideData = (side === 'BID') ? book.Bid : book.Ask; 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; // Accesso diretto if (currentOrder && currentOrder.Price === price) { return currentOrder; } var orderToUpdate = currentOrder ? OrderManager.Modify(currentOrder.OrderCode, price) : this.execOrder(side, stock, price, CONFIG.SIZE); return this.updateOrderContext(orderToUpdate, side, price); }, deleteOrder: function (orderCode) { return OrderManager.Delete(orderCode); }};
var Helper = { cachedPriceDirections: {},
priceDirection: function (targetPrice, oldPrice) { var key = targetPrice + '_' + oldPrice; if (this.cachedPriceDirections.hasOwnProperty(key)) { return this.cachedPriceDirections[key]; } this.cachedPriceDirections[key] = targetPrice > oldPrice ? 1 : (targetPrice < oldPrice ? -1 : 0); return this.cachedPriceDirections[key]; }, 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) { var message = ""; if (type === 'action') { message = getActionMessage(data.actionType, data.payload) + Helper.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] ? actionMessagesactionType : ""; }
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 priceData = UserContext.prices[side.toLowerCase()]; 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; // Accesso diretto 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.Time: UserContext.status.secondCount++; manageCycle(); break; 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; }}
if (SystemContext.IsFirst) { setupTradeContext(); }
marketEvent();
- Assistant
Analisi del codice e suggerimenti di ottimizzazione
Di seguito, forniamo un'analisi dettagliata del codice fornito, focalizzandoci sui quattro punti richiesti.
1. Ridondanza di codice o controlli logici non necessari
-
Duplicità nell'accesso ai dati del book:
Nella funzione
BookUtils.getData, l'accesso ai datibook.Bidobook.Askviene effettuato utilizzando la stessa logica(side === 'BID') ? book.Bid : book.Ask;. Questa stessa logica è presente anche in altre parti del codice.Suggerimento specifico: Creare una funzione ausiliaria all'interno di
BookUtilsper ottenere i dati del lato desiderato, riducendo così la duplicazione.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); }, -
Controlli logici ridondanti in
OrderUtils.processOrModOrder:Nel metodo
processOrModOrder, si verifica due volte securrentOrderesiste:var currentOrder = UserContext.order.current; if (currentOrder && currentOrder.Price === price) { return currentOrder; } var orderToUpdate = currentOrder ? OrderManager.Modify(currentOrder.OrderCode, price) : this.execOrder(side, stock, price, CONFIG.SIZE);Suggerimento specifico: Ristrutturare il codice per ridurre i controlli duplicati su
currentOrder.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); } -
Accesso diretto a proprietà nidificate:
Nelle funzioni, si accede direttamente a proprietà nidificate di
UserContext, ad esempioUserContext.order.current. Questo può rendere il codice meno leggibile e più difficile da mantenere.Suggerimento specifico: Creare funzioni getter e setter per accedere a queste proprietà, migliorando l'incapsulamento e la leggibilità.
// Aggiungere metodi getter e setter per UserContext UserContext.getCurrentOrder = function() { return this.order.current; }; UserContext.setCurrentOrder = function(order) { this.order.current = order; }; // Utilizzo nei metodi var currentOrder = UserContext.getCurrentOrder();
2. Ottimizzazioni per aumentare l'efficienza del codice
-
Ottimizzazione della cache nella funzione
Helper.priceDirection:L'uso di stringhe per le chiavi di cache può essere inefficiente, soprattutto se i prezzi sono numeri decimali che richiedono molte cifre.
Suggerimento specifico: Utilizzare un oggetto nidificato per la cache, evitando la concatenazione di stringhe.
cachedPriceDirections: {}, priceDirection: function (targetPrice, oldPrice) { if (!this.cachedPriceDirections[targetPrice]) { this.cachedPriceDirections[targetPrice] = {}; } if (this.cachedPriceDirections[targetPrice][oldPrice] !== undefined) { return this.cachedPriceDirections[targetPrice][oldPrice]; } var direction = targetPrice > oldPrice ? 1 : (targetPrice < oldPrice ? -1 : 0); this.cachedPriceDirections[targetPrice][oldPrice] = direction; return direction; },Oppure, se la cache non è strettamente necessaria, si può semplificare la funzione eliminandola:
priceDirection: function (targetPrice, oldPrice) { return targetPrice > oldPrice ? 1 : (targetPrice < oldPrice ? -1 : 0); }, -
Riduzione degli accessi globali:
Frequenti accessi a
UserContextpossono rallentare il codice.Suggerimento specifico: All'inizio delle funzioni che utilizzano intensivamente
UserContext, estrarre le variabili necessarie.function priceUpdate(side, book) { var status = UserContext.status; var prices = UserContext.prices; // Utilizzare 'status' e 'prices' invece di 'UserContext.status' e 'UserContext.prices' } -
Evitare calcoli ripetuti:
Nella funzione
priceUpdate,getTargetPriceLevelviene chiamato ogni volta.Suggerimento specifico: Poiché
CONFIG.MONITORING_MODEeCONFIG.LEVELS[side]non cambiano durante l'esecuzione, calcolaregetTargetPriceLeveluna sola volta durante l'inizializzazione e memorizzarlo.
3. Compattazioni per rendere il codice più compatto
-
Utilizzo di template string per la formattazione:
Anche se si utilizza ES5, si può migliorare la leggibilità delle stringhe concatenate.
Suggerimento specifico: Utilizzare una funzione per formattare le stringhe in modo più leggibile.
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; }, -
Creazione di funzioni helper per messaggi di log:
I messaggi di log possono essere standardizzati per ridurre la quantità di codice.
Suggerimento specifico: Creare una funzione
logActionMessageche gestisce la formattazione dei messaggi di azione.logActionMessage: function(actionType, data) { var message = ""; switch(actionType) { case "Initialization Complete": message = "Inizializzazione completata:\nBid Price 0: " + data.bidPrice + "\nAsk Price 0: " + data.askPrice + "\n"; break; // Altri casi... } Log(separator + message); },E sostituire le chiamate a
Helper.log('action', { ... })conHelper.logActionMessage(actionType, data). -
Utilizzo di variabili locali per accessi ripetuti a proprietà complesse:
Suggerimento specifico: All'interno delle funzioni, creare variabili locali per accedere a proprietà come
UserContext.prices[side.toLowerCase()].var priceData = UserContext.prices[sideLC];
4. Miglioramento dell’efficienza e della velocità di esecuzione
-
Ordine dei casi nel
switchdimarketEvent:Se l'evento
TSEventType.Priceè più frequente, spostarlo all'inizio per migliorare l'efficienza.Suggerimento specifico:
switch(eventType) { case TSEventType.Price: // Gestione dell'evento Price break; case TSEventType.Time: // Gestione dell'evento Time break; // Altri casi... } -
Evitare dichiarazioni di funzioni all'interno di altre funzioni quando non necessario:
Dichiarare tutte le funzioni a livello superiore per migliorare la struttura del codice.
Suggerimento specifico: Spostare tutte le funzioni come
initializeTradeContextfuori dalle altre funzioni, dichiarandole a livello globale (ma mantenendo comunque l'incapsulamento se necessario). -
Utilizzo efficiente delle strutture dati:
Assicurarsi che le strutture dati utilizzate non crescano in modo incontrollato.
Suggerimento specifico: Nella cache
cachedPriceDirections, implementare una logica di limitazione della dimensione della cache se necessario, ad esempio eliminando gli elementi meno recenti. -
Riduzione degli oggetti globali e delle dipendenze:
Suggerimento specifico: Se possibile, passare le dipendenze come parametri alle funzioni invece di accedere a variabili globali.
Conclusione
Applicando questi suggerimenti specifici, è possibile migliorare la qualità del codice rendendolo più leggero, leggibile ed efficiente. La riduzione della ridondanza e l'ottimizzazione delle strutture dati e dei controlli logici porteranno a un codice più mantenibile e performante.
-