Node.js 常用工具

Util ist ein Node.js-Kernmodul, das eine Sammlung von häufig verwendeten Funktionen bereitstellt und das Defizit der zu minimalistischen Funktionen des Kern-JavaScript ausgleicht.

Verwendung wie folgt:

const util = require('util');

util.callbackify

util.callbackify(original) wandelt asynchrone asynchrone Funktionen (oder Funktionen, die einen Promise zurückgeben) in Funktionen um, die dem Fehlerprioritätsstil folgen, z.B. (err, value) => ... als letzter Parameter. In Callback-Funktionen ist der erste Parameter der Grund für die Ablehnung (wenn die Promise gelöst wird, ist dies null), und der zweite Parameter ist der gelöste Wert.

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

Das obige Code-Ausgabeergebnis ist:

hello world

Callback-Funktionen werden asynchron ausgeführt und haben eine Fehlerstack-Verfolgung. Wenn eine Callback-Funktion eine Ausnahme wirft, wird ein 'uncaughtException'-Fehler ausgelöst, und wenn dieser nicht erfasst wird, wird der Prozess beendet.

Null hat in Callback-Funktionen eine besondere Bedeutung. Wenn der erste Parameter des Callbacks der Grund für die Ablehnung einer Promise ist und einen Wert zurückgibt, der in einen Boolean-Wert false umgewandelt werden kann, wird dieser Wert in einem Error-Objekt verpackt und kann über das Attribut reason abgerufen werden.

function fn() {
　　return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err,　ret)　=>　{
　　//　Wenn eine Promise mit `null` abgelehnt wird, wird sie in einen Error verpackt und der ursprüngliche Wert wird in `reason` gespeichert.
　　err　&&　err.hasOwnProperty('reason')　&&　err.reason　===　null;　　//　true
});

original ist eine asynchrone Funktion. Diese Funktion gibt eine traditionelle Callback-Funktion zurück.

util.inherits

util.inherits(constructor, superConstructor) ist eine Funktion, die die Vererbung zwischen Objekten implementiert.

Die objektorientierte Programmierung in JavaScript basiert auf Prototypen und unterscheidet sich von der gängigen klassischen Programmierung.

In diesem Abschnitt werden wir die Verwendung von util.inherits beschreiben, ein Beispiel ist wie folgt:

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

Wir haben ein Basisklasse-Objekt Base und ein von Base abgeleitetes Sub definiert, Base hat drei Eigenschaften, die im Konstruktor definiert sind, und eine Funktion, die im Prototypen definiert ist, und die Vererbung durch util.inherits implementiert. Das Ergebnis des Laufs ist wie folgt:

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

Hinweis:Sub hat nur die Funktionen, die in den Prototypen von Base definiert sind, geerbt, während die in der Konstruktorfunktion erstellten Eigenschaften base und die Funktion sayHello nicht von Sub geerbt werden.

Gleichzeitig werden in den Prototypen definierte Eigenschaften nicht als Objekteigenschaften von console.log ausgegeben. Wenn wir die Zeile objSub.sayHello(); entfernen, werden wir sehen:

node.js:201　
throw e;　//　process.nextTick error, oder 'error' Event auf dem ersten Tick　
^　
TypeError: Object #<Sub> hat kein Methode '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]) ist eine Methode, die jedes Objekt in einen String umwandelt und normalerweise für Debugging und Fehlerausgaben verwendet wird. Sie akzeptiert mindestens einen Parameter object, das zu konvertierende Objekt.

showHidden ist ein optionaler Parameter. Wenn der Wert true ist, werden mehr versteckte Informationen ausgegeben.

Depth gibt die maximale Rekursionstiefe an. Wenn das Objekt sehr komplex ist, können Sie die Anzahl der Ebenen angeben, um die Menge der ausgegebenen Informationen zu steuern. Wenn depth nicht angegeben ist, wird standardmäßig rekursiv ausgegeben. 2 Die Ebene, angegeben als null, bedeutet, dass das Objekt in voller Tiefe rekursiv durchsucht wird, ohne eine begrenzte Anzahl von Ebenen. Wenn der Wert von colors true ist, wird die Ausgabe in ANSI-Farbcodierung formatiert, was in der Regel für eine schönere Anzeige in der Konsole verwendet wird.

Besonders hervorzuheben ist, dass util.inspect nicht einfach direkt ein Objekt in einen String umwandelt, selbst wenn das Objekt ein toString-Methode definiert hat, wird diese nicht aufgerufen.

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

运行结果是：

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

util.isArray(object)

如果给定的参数 "object" 是一个数组返回 true，否则返回 false。

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

util.isRegExp(object)

如果给定的参数 "object" 是一个正则表达式返回true，否则返回false。

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

util.isDate(object)

如果给定的参数 "object" 是一个日期返回true，否则返回false。

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

更多详情可以访问 http://nodejs.org/api/util.html 了解详细内容。