Utilitaires courants Node.js

utilLe module est un module intégré de Node.js, contenant des fonctions utilitaires qui prennent en charge le débogage, la gestion des erreurs, le formatage et d'autres fonctions de la programmation JavaScript.

utilFournit un ensemble de fonctions couramment utilisées pour compenser le caractère trop simpliste des fonctionnalités du cœur de JavaScript.

utilLes fonctions du module couvrent divers aspects, de l'inspection d'objets et de l'héritage jusqu'au formatage de chaînes.

Importer le module util

Tout d'abord, vous devez importer le module util :

const util = require('util');

Méthodes courantes :

Méthodes de détection de type sous util.types

util.types est une collection de nombreuses méthodes de détection de type, étendant les opérateurs typeof et instanceof de JavaScript.

Exemples d'application

util.format() - Formatage de chaînes

util.format() est utilisé pour générer des chaînes formatées, en prenant en charge des espaces réservés tels que %s, %d et %j, représentant respectivement des chaînes, des nombres et du JSON.

util.promisify() - Convertir les fonctions de rappel en Promise

util.promisify() convertit les fonctions traditionnelles de style rappel en fonctions renvoyant une Promise, afin qu'elles puissent être utilisées avec async/await.

util.callbackify() - Convertir une Promise en callback

util.callbackify() convertit les fonctions retournant une Promise en fonctions de style callback, ce qui les rend pratiques à utiliser dans des environnements de code qui nécessitent des callbacks.

util.callbackify(original)vaasyncUne fonction async (ou une fonction dont la valeur de retour estPromisefonction) est convertie en une fonction de style callback suivant la convention error-first, par exemple en prenant le(err, value) => ...callback comme dernier paramètre.Promisese résout, il estnull), et le second paramètre est la valeur résolue.

La sortie du code ci-dessus est :

hello world

La fonction de rappel est exécutée de manière asynchrone et dispose d'un traçage de pile d'erreurs d'exception. Si la fonction de rappel lève une exception, le processus déclenchera une exception 'uncaughtException' ; si elle n'est pas interceptée, le processus se terminera.

null a une signification particulière en tant que paramètre dans la fonction de rappel. Si le premier paramètre de la fonction de rappel est la raison du rejet d'une Promise et a une valeur de retour, et que la valeur peut être convertie en booléen false, cette valeur sera encapsulée dans un objet Error et accessible via la propriété reason.

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // 当 Promise 被以 `null` 拒绝时，它被包装为 Error 并且原始值存储在 `reason` 中。
  err && err.hasOwnProperty('reason') && err.reason === null;  // true
});

original est une fonction async. Cette fonction renvoie une fonction de rappel traditionnelle.

util.deprecate() - Marquer une fonction comme dépréciée

util.deprecate() sert à marquer les fonctions dont l'utilisation n'est pas recommandée, et un message d'avertissement s'affichera lorsqu'elles sont appelées.

util.types - Détection des types de données

util.types fournit un ensemble de méthodes pour détecter des types de données spécifiques, étendant les fonctionnalités de typeof et instanceof.

util.inherits

util.inherits(constructor, superConstructor)est une fonction qui met en œuvre l'héritage par prototype entre objets.

Les fonctionnalités orientées objet de JavaScript sont basées sur des prototypes, contrairement à l'approche courante basée sur les classes. JavaScript ne fournit pas de fonctionnalités au niveau du langage pour l'héritage d'objets, mais l'implémente via la copie de prototypes.

Nous présentons ici uniquement l'utilisation de util.inherits, voici l'exemple :

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 définissons un objet de base Base et un Sub qui hérite de Base. Base possède trois propriétés définies à l'intérieur du constructeur et une fonction définie dans le prototype. L'héritage est mis en œuvre via util.inherits. Le résultat de l'exécution est le suivant :

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

Remarque :Sub hérite uniquement de la fonction définie par Base dans le prototype, tandis que la propriété base et la fonction sayHello créées à l'intérieur du constructeur ne sont pas héritées par Sub.

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

node.js:201 
throw e; // process.nextTick error, or 'error' event on first tick 
^ 
TypeError: Object #<Sub> has no method '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) 

Remarque :Avant ES6, util.inherits était la principale méthode pour implémenter l'héritage dans Node.js. Cependant, après ES6, il est recommandé d'utiliser la syntaxe class et extends, ce qui rend le code d'héritage plus lisible.

util.inspect() - Afficher la structure d'un objet

util.inspect(object[, options]): Convertit un objet en une représentation sous forme de chaîne pour faciliter le débogage.

util.inspect() convertit un objet en une forme de chaîne, souvent utilisé lors du débogage pour afficher la structure détaillée et les propriétés de l'objet. Vous pouvez spécifier le paramètre options pour contrôler le format de sortie.

util.isArray(object)

Renvoie true si le paramètre donné "object" est un tableau, sinon renvoie false.

var util = require('util');

util.isArray([])
  // true
util.isArray(new Array)
  // true
util.isArray({})
  // false

util.isRegExp(object)

Renvoie true si le paramètre donné "object" est une expression régulière, 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)

Renvoie true si le paramètre donné "object" est une Date, sinon renvoie false.

var util = require('util');

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

Pour plus de détails, veuillez consulterhttp://nodejs.org/api/util.htmlpour en savoir plus.