Outils courants de Node.js

util est un module principal de Node.js qui fournit un ensemble de fonctions couramment utilisées pour compenser les lacunes des fonctions JavaScript de base trop rationalisées.

util.inherits

util.inherits(constructor, superConstructor) est une fonction qui implémente l'héritage prototypique entre les objets.

Les fonctionnalités orientées objet de JavaScript sont basées sur des prototypes, ce qui est différent des fonctionnalités courantes basées sur les classes. JavaScript ne fournit pas de fonctionnalités d'héritage d'objet au niveau du langage, mais le fait via la copie de prototypes.

Ici, nous introduisons uniquement l'utilisation de util.inherits. L'exemple est le suivant :

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 hérité de Base en a trois définis dans le constructeur. Les propriétés et fonctions définies dans un prototype sont héritées via util.inherits. Le résultat courant est le suivant :

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

Remarque : Sub hérite uniquement des fonctions définies par Base dans le prototype, et l'attribut de base et la fonction sayHello créés à l'intérieur du constructeur ne sont pas hérités par Sub .

Dans le même temps, les propriétés définies dans le prototype ne seront pas affichées par console.log en tant que propriétés de l'objet. Si nous supprimons le commentaire de 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)

util.inspect

util.inspect(object,[showHidden],[profondeur], [colors]) est une méthode qui convertit un objet arbitraire en chaîne, souvent utilisée pour le débogage et la sortie d'erreurs. Il accepte au moins un objet paramètre, qui est l'objet à convertir.

showHidden est un paramètre facultatif. Si la valeur est vraie, davantage d'informations cachées seront affichées.

La profondeur représente le nombre maximum de niveaux de récursion. Si l'objet est complexe, vous pouvez spécifier le nombre de niveaux pour contrôler la quantité d'informations de sortie. Si la profondeur n'est pas spécifiée, 2 niveaux de récursion seront effectués par défaut. Spécifier null signifie que l'objet sera complètement parcouru sans limiter le nombre de niveaux de récursion. Si la valeur de couleur est vraie, le format de sortie sera codé par couleur ANSI, généralement utilisé pour afficher de plus beaux effets dans le terminal.

Il faut notamment souligner que util.inspect ne convertira pas simplement l'objet en chaîne directement, même si l'objet définit la méthode toString, il ne sera pas appelé.

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'opération est :

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

util.isArray(object)

Si le paramètre "objet" donné est un tableau, il renvoie vrai , sinon il renvoie false .

var util = require('util');

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

util.isRegExp(object)

Renvoie vrai si le paramètre "objet" donné est une expression régulière, sinon renvoie faux.

var util = require('util');

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

util.isDate(object)

Renvoie vrai si le paramètre "objet" donné est une date, sinon renvoie faux.

var util = require('util');

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

util.isError(object)

Renvoie vrai si le paramètre "objet" donné est un objet d'erreur, sinon renvoie faux.

var util = require('util');

util.isError(new Error())
  // true
util.isError(new TypeError())
  // true
util.isError({ name: 'Error', message: 'an error occurred' })
  // false

Pour plus de détails, veuillez visiter http://nodejs.org/api/util.html pour plus de détails.