Lavorare con il modulo Node.js Util

Il modulo util fornisce una serie di utilità che puoi utilizzare per eseguire il debug, ispezionare e formattare i dati nelle applicazioni Node.js.

Approfondisci le diverse funzioni del modulo util ed esplora alcuni esempi per aiutarti a sfruttare questi strumenti.

Registrazione con più comodità

La registrazione si riferisce alla registrazione di informazioni o eventi importanti, come valori variabili, messaggi di errore e flusso di esecuzione, che si verificano all'interno di un'applicazione software. La registrazione ha molteplici scopi, tra cui il debug, il monitoraggio e il controllo.

Il modulo Node.js util fornisce un comodo meccanismo di registrazione utilizzando il util.debuglog metodo. Ti consente di creare funzioni di registrazione di debug con uno spazio dei nomi e puoi abilitarle o disabilitarle impostando il file NODO_DEBUG variabile d'ambiente. Ecco un esempio:

// indice.js
cost utile = richiedere("utile");
cost debug = util.debuglog("miaapp"); // inizializza il debug logger
eseguire il debug("Questo è un messaggio di debug"); // MYAPP 39668: questo è un messaggio di debug

Questo esempio mostra come impostare un semplice logger di debug, in uno spazio dei nomi "myapp", e registrare un messaggio e il relativo ID di processo nella console.

Per abilitare i log di debug, imposta il file NODO_DEBUG variabile di ambiente allo spazio dei nomi quando si esegue lo script:

NODE_DEBUG=myapp node index.js

Se desideri abilitare più spazi dei nomi di debug, aggiungi una virgola per separare gli spazi dei nomi:

NODE_DEBUG=myapp, myapp2,myapp3 nodo index.js

Se non includi uno spazio dei nomi nel file NODO_DEBUG variabile di ambiente, le chiamate a debuglog ignoreranno tale spazio dei nomi.

IL util.debuglog fornisce funzionalità utili, ma se la tua app richiede una registrazione più complessa, puoi usare uno degli altri metodi robusti registrazione dei pacchetti nell'ecosistema Node.js.

Funzioni promettenti per la flessibilità

Le promesse in JavaScript forniscono un modo per gestire il codice asincrono in modo più strutturato e gestibile modo consentendo di concatenare le operazioni, gestire gli errori e gli eventi di successo separatamente ed evitare il callback inferno.

Tuttavia, non tutte le funzioni integrate supportano le promesse. Tuttavia, puoi "promettere" le funzioni che utilizzano i callback tradizionali per consentire loro di supportare le promesse con il modulo util util.promisify metodo.

Questo metodo accetta una funzione che utilizza il tradizionale sistema di callback e restituisce una funzione che utilizza le promesse.

Per esempio:

cost utile = richiedere("utile");
// Versione richiamata
funzionefunzione di richiamata(arg1, arg2, richiamata) {
// Operazione asincrona
// Richiama la richiamata con errore (se presente) e risultato
}
// Promisify callbackFunction
cost callbackFunctionPromise = util.promisify (callbackFunction);
// Versione promessa
callbackFunctionPromise (arg1, arg2)
 .Poi((risultato) => {
// Risultato del processo
 })
 .presa((errore) => {
// Errore di gestione
 });

Nell'esempio sopra, il util.promisify Il metodo ha convertito la versione di callback della funzione in una versione che utilizza le promesse.

Questa conversione consente di utilizzare chain Poi E presa blocchi, uso prova a prenderee gestire meglio il codice asincrono.

Formattazione di stringhe con un metodo familiare

Il Node.js utile Il modulo fornisce una funzione di formattazione chiamata util.format che consente di creare stringhe formattate. Questo metodo funziona in modo simile a IL printf funzione in bash e altri linguaggi di programmazione come C e C++.

IL util.formato() Il metodo accetta una stringa di formato che può contenere zero o più identificatori di formato, ad esempio %S (stringhe), %D (numeri), come argomento. Prende anche un numero arbitrario di valori che sostituiranno i loro identificatori corrispondenti.

Per esempio:

cost utile = richiedere("utile");
cost nome = "Bonnie";
cost età = 30;
cost formattedString = util.format(
"Mi chiamo %s e ho %d anni.",
 nome,
 età
);
consolare.log (stringa formattata); // Mi chiamo Bonnie e ho 30 anni.

Questo esempio utilizza una stringa di formato con due segnaposto: %S E %D. IL %S segnaposto serve per la sostituzione di stringhe, mentre %D è per la sostituzione numerica. La chiamata a util.format passa i valori corrispondenti:nome E età—per ogni segnaposto.

Se uno specificatore non ha un argomento corrispondente, il util.format metodo non lo sostituirà e restituirà la stringa senza alterarla:

cost utile = richiedere("utile");
cost formattedString = util.format("Mi chiamo %s");
consolare.log (stringa formattata); // Mi chiamo %s

Questo esempio chiama format con un solo argomento, quindi il metodo restituisce la stringa originale.

Ci sono molti altri usi del modulo Util

Oltre a questi usi, il modulo Node.js util offre altre funzioni di utilità. Gli esempi includono l'ispezione di oggetti e valori e la deprecazione di strumenti obsoleti.

Sfruttando la funzionalità fornita dal modulo util, è possibile migliorare la leggibilità e la manutenibilità del codice e del flusso di lavoro complessivo.