Strumenti comuni Node.js

Util e' un modulo nucleare di Node.js che fornisce una raccolta di funzioni comuni, utilizzate per compensare le funzionalita' troppo ridotte del core JavaScript.

Il metodo di utilizzo e':

const util = require('util');

util.callbackify

util.callbackify(original) trasforma una funzione asincrona (o una funzione che restituisce un valore Promise) in una funzione di stile callback che segue la priorita' delle eccezioni, ad esempio (err, value) => ... come ultimo parametro. Nel callback, il primo parametro e' la ragione di rifiuto (se Promise viene risolta, null), il secondo parametro e' il valore risolto.

const util = require('util');
async function fn() {
　　return 'hello world';
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err, ret) => {
　　if (err) throw err;
　　console.log(ret);
});

Il risultato dell'esecuzione del codice sopra e':

hello world

Il callback e' eseguito asincronamente e ha il tracciamento degli errori di stack. Se il callback lancia un'eccezione, il processo attiva un'eccezione 'uncaughtException', se non viene catturata, il processo uscirà.

Null ha un significato speciale nei callback, se il primo parametro del callback e' la ragione di rifiuto di Promise e ha un valore di ritorno, e il valore puo' essere convertito in booleano false, questo valore viene avvolto in un oggetto Error, che puo' essere recuperato tramite l'attributo reason.

function fn() {
　　return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err, ret) => {
　　// Quando Promise viene rifiutato con `null`, viene avvolto in Error e il valore originale viene memorizzato in `reason`.
　　err && err.hasOwnProperty('reason') && err.reason === null; // true
});

original è una funzione asincrona. Questa funzione restituisce una funzione di callback tradizionale.

util.inherits

util.inherits(constructor, superConstructor) è una funzione che realizza l'ereditarietà del prototipo tra gli oggetti.

Le caratteristiche orientate agli oggetti di JavaScript sono basate sul prototipo, diversamente dai comuni basati su classi. JavaScript non fornisce una caratteristica di livello linguistico per l'ereditarietà degli oggetti, ma la realizza tramite la copia del prototipo.

In questo articolo presenteremo l'uso di util.inherits, come nell'esempio seguente:

var　util　=　require('util');　
function Base() {　
　　　　this.name = 'base';　
　　　　this.base = 1991;　
　　　　this.sayHello = function() {　
　　　　console.log('Hello ' + this.name);　
　　　　};　
}　
Base.prototype.showName = function() {　
　　　　console.log(this.name);
};　
function Sub() {　
　　　　this.name = 'sub';　
}　
util.inherits(Sub, Base);　
var objBase = new Base();　
objBase.showName();　
objBase.sayHello();　
console.log(objBase);　
var objSub = new Sub();　
objSub.showName();　
//objSub.sayHello();　
console.log(objSub);

Abbiamo definito un oggetto di base Base e un Sub derivato da Base, Base ha tre proprietà definite nel costruttore e una funzione definita nel prototipo, realizzata tramite util.inherits per l'ereditarietà. Il risultato della runtime è il seguente:

base　
Hello base　
{ name: 'base', base: 1991, sayHello: [Function] }　
sub　
{ name: 'sub' }

Attenzione:Sub ha ereditato solo le funzioni definite nel prototipo di Base, mentre le proprietà definite all'interno del costruttore base e la funzione sayHello non sono state ereditate da Sub.

Inoltre, le proprietà definite nel prototipo non verranno outputte come proprietà dell'oggetto da console.log. Se rimuoviamo il commento dalla riga objSub.sayHello(); vedremo: }}

node.js:201　
throw e; // process.nextTick error, or 'error' event on first tick　
^　
TypeError: Object #<Sub> ha un metodo 'sayHello'　
at Object.<anonymous> (/home/byvoid/utilinherits.js:29:8)　
at Module._compile (module.js:441:26)　
at Object..js (module.js:459:10)　
at Module.load (module.js:348:31)　
at Function._load (module.js:308:12)　
at Array.0 (module.js:479:10)　
at EventEmitter._tickCallback (node.js:192:40)

util.inspect

util.inspect(object,[showHidden],[depth],[colors]) è un metodo che converte qualsiasi oggetto in una stringa, solitamente utilizzato per debug e output di errori. Accetta almeno un parametro object, l'oggetto da convertire.

showHidden è un parametro opzionale, se il valore è true, verranno outputte più informazioni nascoste.

depth rappresenta il numero massimo di livelli di ricorsione, se l'oggetto è molto complesso, puoi specificare il numero di livelli per controllare la quantità di informazioni di output. Se non specificato, il valore predefinito sarà 2 livelli di ricorsione, specificare null significa esplorare l'oggetto completamente senza limiti di ricorsione. Se il valore di colors è true, il formato di output sarà codificato con colori ANSI, solitamente utilizzato per visualizzare meglio i risultati nei terminali.

In particolare, util.inspect non convertirà semplicemente direttamente un oggetto in una stringa, anche se l'oggetto ha definito un metodo toString non verrà chiamato.

var　util　=　require('util');　
function Person() {　
　　　　this.name = 'byvoid';　
　　　　this.toString = function() {　
　　　　return　this.name;　
　　　　};　
}　
var　obj　=　new　Person();　
console.log(util.inspect(obj));　
console.log(util.inspect(obj,　true));

Il risultato della esecuzione è:

Person　{　name:　'byvoid',　toString:　[Function]　}
Person　{
　　name:　'byvoid',
　　toString:　
　　　{　[Function]
　　　　　[length]:　0,
　　　　　[name]:　'',
　　　　　[arguments]:　null,
　　　　　[caller]:　null,
　　　　　[prototype]:　{　[constructor]:　[Circular]　}　}

util.isArray(object)

Restituisce true se l'oggetto "object" è un array, altrimenti restituisce false.

var　util　=　require('util');
util.isArray([])
　　//　true
util.isArray(new　Array)
　　//　true
util.isArray({})
　　//　false

util.isRegExp(object)

Restituisce true se l'oggetto "object" è un'espressione regolare, altrimenti restituisce false.

var　util　=　require('util');
util.isRegExp(/some　regexp/)
　　//　true
util.isRegExp(new　RegExp('another　regexp'))
　　//　true
util.isRegExp({})
　　//　false

util.isDate(object)

Restituisce true se l'oggetto "object" è una data, altrimenti restituisce false.

var　util　=　require('util');
util.isDate(new　Date())
　　//　true
util.isDate(Date())
　　//　false　(without　'new'　returns　a　String)
util.isDate({})
　　//　false

Per ulteriori dettagli visita http://nodejs.org/api/util.html Per ulteriori dettagli