Outils courants de Node.js

Util est un module natif de Node.js, fournissant une collection de fonctions courantes, utilisées pour compenser les fonctionnalités insuffisamment détaillées du JavaScript natif.

Voici la méthode d'utilisation :

const util = require('util');

util.callbackify

util.callbackify(original) convertit une fonction asynchrone (ou une fonction qui retourne une valeur Promise) en une fonction de style callback respectant la priorité des exceptions, par exemple en utilisant la callback (err, value) => ... comme dernier paramètre. Dans la fonction de rappel, le premier paramètre est la raison du rejet (si Promise est résolue, alors null), et le deuxième paramètre est la valeur résolue.

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

Le résultat de l'exécution du code ci-dessus est :

hello world

La fonction de rappel est exécutée de manière asynchrone et suit la trace des erreurs en pile. Si la fonction de rappel lève une exception, le processus déclenche une exception 'uncaughtException', et si elle n'est pas capturée, le processus se termine.

La valeur null a une signification spéciale dans la fonction de rappel, si le premier paramètre de la fonction de rappel est la raison du rejet de Promise et qu'il contient une valeur qui peut être convertie en un booléen false, cette valeur sera encapsulée dans un objet Error, et elle peut être obtenue via la propriété reason.

function fn() {
　　return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err,　ret)　=>　{
　　//　Lorsque Promise est rejetée avec `null`, elle est enveloppée dans Error et la valeur originale est stockée dans `reason`.
　　err　&&　err.hasOwnProperty('reason')　&&　err.reason　===　null;　　//　true
});

original est une fonction asynchrone. Cette fonction retourne une fonction de rappel traditionnelle.

util.inherits

util.inherits(constructor, superConstructor) est une fonction qui réalise l'héritage de prototype entre les objets.

Les caractéristiques orientées objet de JavaScript sont basées sur les prototypes, contrairement aux classiques basés sur les classes. JavaScript ne fournit pas de caractéristiques de niveau de langage pour l'héritage d'objets, mais les réalise par copie de prototype.

Ici, nous ne présentons que l'utilisation de util.inherits, comme suit :

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

Nous avons définie un objet de base Base et un Sub héritant de Base, Base ayant trois attributs définis dans le constructeur et une fonction définie dans le prototype, réalisé par util.inherits pour l'héritage. Le résultat de l'exécution est le suivant :

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

Attention :Sub n'a hérité que des fonctions définies dans le prototype de Base, et les propriétés créées dans le constructeur et la fonction sayHello n'ont pas été héritées par Sub.

En même temps, les propriétés définies dans le prototype ne sont pas affichées comme des propriétés de l'objet par console.log. Si nous supprimons le commentaire de la ligne objSub.sayHello();, nous verrons :

node.js:201　
throw e;　//　process.nextTick error, ou 'error' event sur le premier tick　
^　
TypeError: Object #<Sub> n'a pas de méthode '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]) est une méthode qui convertit n'importe quel objet en chaîne de caractères, généralement utilisée pour le débogage et les messages d'erreur. Elle accepte au moins un paramètre object, c'est-à-dire l'objet à convertir.

showHidden est un paramètre optionnel, si sa valeur est true, il enverra plus d'informations cachées.

La profondeur représente le nombre maximum de recursions, si l'objet est très complexe, vous pouvez spécifier le niveau pour contrôler la quantité d'informations de sortie. Si vous ne spécifiez pas depth, il sera récursif par défaut 2 Le niveau, spécifié comme null, signifie que l'objet sera complètement parcouru sans limitation de profondeur. Si la valeur de colors est true, le format de sortie sera codé en couleur ANSI, généralement utilisé pour afficher des effets plus jolis dans un terminal.

Il est important de noter que util.inspect ne convertit pas simplement directement un objet en chaîne de caractères, même si l'objet définit une méthode toString, il ne la appellera pas.

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

Le résultat de l'exécution est :

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

util.isArray(object)

Si l'argument 'object' donné est un tableau, renvoie true, sinon renvoie false.

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

util.isRegExp(object)

Si l'argument 'object' donné est une expression régulière, renvoie true, sinon renvoie false.

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

util.isDate(object)

Si l'argument 'object' donné est une date, renvoie true, sinon renvoie false.

var util = require('util');
util.isDate(new Date())
　　//　true
util.isDate(Date())
　　//　false (sans 'new' renvoie une chaîne de caractères)
util.isDate({})
　　//　false

Pour plus de détails, vous pouvez consulter http://nodejs.org/api/util.html Pour plus de détails.