Herramientas comunes de Node.js

Util es un módulo nuclear de Node.js que proporciona una colección de funciones comunes para compensar la insuficiencia de funcionalidad demasiado simplificada del JavaScript nuclear.

El método de uso es el siguiente:

const util = require('util');

util.callbackify

util.callbackify(original) convierte una función asíncrona (o una función que devuelve un valor de Promise) en una función de estilo de callback que sigue la prioridad de excepciones, por ejemplo, (err, value) => ... como último parámetro. En la función de callback, el primer parámetro es la razón de rechazo (si Promise se resuelve, es null), y el segundo parámetro es el valor resuelto.

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

El resultado de salida del código anterior es:

hola mundo

La función de callback se ejecuta de manera asíncrona y tiene seguimiento de errores de pila. Si la función de callback lanza una excepción, el proceso desencadenará una excepción 'uncaughtException', y si no se captura, el proceso se cerrará.

Null tiene un significado especial como parámetro en la función de callback, si el primer parámetro de la función de callback es la razón de rechazo de Promise y tiene un valor de retorno que se puede convertir en el valor booleano false, este valor se encapsulará en el objeto Error y se puede obtener a través de la propiedad reason.

function fn() {
　　return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err,　ret)　=>　{}}
　　//　Cuando una Promise se rechaza con `null`, se envuelve en Error y el valor original se almacena en `reason`.
　　err　&&　err.hasOwnProperty('reason')　&&　err.reason　===　null;　　//　true
});

original es una función asíncrona. Esta función devuelve una función de callback tradicional.

util.inherits

util.inherits(constructor, superConstructor) es una función que realiza la herencia de prototipos entre objetos.

Las características orientadas a objetos de JavaScript se basan en prototipos, diferentes de las comunes basadas en clases. JavaScript no proporciona características de nivel de lenguaje para la herencia de objetos, sino que se realiza a través de la copia de prototipos.

Aquí solo se introduce el uso de util.inherits, el siguiente es un ejemplo:

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);

Definimos un objeto básico Base y un Sub que hereda de Base, Base tiene tres propiedades definidas en el constructor y una función definida en el prototipo, la herencia se realiza a través de util.inherits. El resultado de la ejecución es el siguiente:

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

Atención:Sub solo hereda las funciones definidas en el prototipo de Base, mientras que las propiedades base creadas en el constructor y la función sayHello no se heredan por Sub.

Al mismo tiempo, las propiedades definidas en el prototipo no se consideran propiedades del objeto al usar console.log. Si eliminamos el comentario de objSub.sayHello(); veremos que:

node.js:201　
throw e;　//　process.nextTick error, o evento 'error' en el primer tick　
^　
TypeError: Object #<Sub> tiene un método '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]) es un método que convierte cualquier objeto en una cadena de texto, generalmente utilizado para depuración y salida de errores. Al menos acepta un parámetro object, que es el objeto a convertir.

showHidden es un parámetro opcional, si su valor es true, se mostrarán más información oculta.

Depth representa la profundidad máxima de la recursión, si el objeto es muy complejo, puedes especificar el número de niveles para controlar la cantidad de información de salida. Si no se especifica depth, se recurrirá por defecto 2 El nivel, especificado como null, indica que se recorrerá el objeto completo sin limitar la profundidad de la recursión. Si el valor de colors es true, el formato de salida se codificará en colores ANSI, generalmente utilizado para mostrar efectos más atractivos en la terminal.

Es especialmente importante destacar que util.inspect no convierte directamente un objeto en una cadena de texto, incluso si el objeto define un método toString no se llama.

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));

El resultado de la ejecución es:

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

util.isArray(object)

Si el parámetro dado "object" es un array, devuelve true, de lo contrario devuelve false.

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

util.isRegExp(object)

Si el parámetro dado "object" es una expresión regular, devuelve true, de lo contrario devuelve false.

var util = require('util');
util.isRegExp(/alguna expresión regular/)
　　//　true
util.isRegExp(new RegExp('otro regexp'))
　　//　true
util.isRegExp({})
　　//　false

util.isDate(object)

Si el parámetro dado "object" es una fecha, devuelve true, de lo contrario devuelve false.

var util = require('util');
util.isDate(new Date())
　　//　true
util.isDate(Date())
　　//　false (sin 'new' devuelve una cadena)
util.isDate({})
　　//　false

Para obtener más detalles, consulte http://nodejs.org/api/util.html Conozca el contenido detallado.