Freigeben über

util module

Paket:
powerbi-client

Das node:util Modul unterstützt die Anforderungen Node.js internen APIs. Viele der Dienstprogramme sind auch für Anwendungs- und Modulentwickler nützlich. So greifen Sie darauf zu:

import util from 'node:util';

Siehe Quell-

Klassen

MIMEParams

Die MIMEParams-API bietet Lese- und Schreibzugriff auf die Parameter eines MIMEType.
MIMEType

Eine Implementierung der der MIMEType-Klasse.

In Übereinstimmung mit Browserkonventionen werden alle Eigenschaften von MIMEType Objekten als Getter und Setter für den Klassenprototyp und nicht als Dateneigenschaften für das Objekt selbst implementiert.

Eine MIME-Zeichenfolge ist eine strukturierte Zeichenfolge, die mehrere aussagekräftige Komponenten enthält. Bei der Analyse wird ein MIMEType-Objekt zurückgegeben, das Eigenschaften für jede dieser Komponenten enthält.
TextDecoder

Eine Implementierung der WHATWG Encoding StandardTextDecoder API.

const decoder = new TextDecoder();
const u8arr = new Uint8Array([72, 101, 108, 108, 111]);
console.log(decoder.decode(u8arr)); // Hello
TextEncoder

Eine Implementierung der WHATWG Encoding StandardTextEncoder API. Alle Instanzen von TextEncoder nur UTF-8-Codierung unterstützen.

const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');

Die TextEncoder Klasse ist auch für das globale Objekt verfügbar.

Schnittstellen

CallSiteObject
CustomPromisifyLegacy
CustomPromisifySymbol
DebugLogger
EncodeIntoResult
InspectOptions
InspectOptionsStylized
IsDeepStrictEqualOptions
ParseArgsConfig
ParseArgsOptionDescriptor
ParseArgsOptionsConfig
StyleTextOptions

Typaliase

CustomInspectFunction
CustomPromisify
DebugLoggerFunction
DiffEntry
ParseArgsOptionsType

Typ des Arguments, das in parseArgs verwendet wird.
Style

Functions

aborted(AbortSignal, any)

Lauscht auf das Abbruchereignis für die bereitgestellte signal und gibt eine Zusage zurück, die aufgelöst wird, wenn die signal abgebrochen wird. Wenn resource bereitgestellt wird, verweist sie schwach auf das zugeordnete Objekt des Vorgangs. Wenn also resource vor dem signal abgebrochen wird, bleibt die zurückgegebene Zusage ausstehend. Dadurch werden Speicherlecks in lang ausgeführten oder nicht abbruchfähigen Vorgängen verhindert.

import { aborted } from 'node:util';

// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();

// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
  // This code runs when `dependent` is aborted.
  console.log('Dependent resource was aborted.');
});

// Simulate an event that triggers the abort.
dependent.on('event', () => {
  dependent.abort(); // This will cause the `aborted` promise to resolve.
});
addParamToUrl(string, string, string)

Fügt der angegebenen URL einen Parameter hinzu.
assign(any[])

Kopiert die Werte aller aufzählbaren Eigenschaften aus einem oder mehreren Quellobjekten in ein Zielobjekt und gibt das Zielobjekt zurück.
autoAuthInEmbedUrl(string)

Überprüft, ob die Einbettungs-URL autoAuth=true enthält.
callbackify(() => Promise<void>)

Verwendet eine async Funktion (oder eine Funktion, die eine Promisezurückgibt) und gibt eine Funktion nach dem Fehlerrückrufstil zurück, d. h. ein (err, value) => ... Rückruf als letztes Argument. Im Rückruf ist das erste Argument der Ablehnungsgrund (oder null, wenn die Promise aufgelöst wurde), und das zweite Argument ist der aufgelöste Wert.

import { callbackify } from 'node:util';

async function fn() {
  return 'hello world';
}
const callbackFunction = callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

Druckt:

hello world

Der Rückruf wird asynchron ausgeführt und verfügt über eine eingeschränkte Stapelablaufverfolgung. Wenn der Rückruf ausgelöst wird, gibt der Prozess ein 'uncaughtException' Ereignis aus, und wenn nicht behandelt wird, wird das Ereignis beendet.

Da null eine besondere Bedeutung als erstes Argument für einen Rückruf hat, wenn eine umschlossene Funktion eine Promise mit einem gefälschten Wert als Grund ablehnt, wird der Wert in eine Error mit dem ursprünglichen Wert eingeschlossen, der in einem Feld mit dem Namen reasongespeichert ist.

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

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});
callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>)
callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>)
callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>)
callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>)
callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>)
callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>)
callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>)
callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>)
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
callbackify<T1>((arg1: T1) => Promise<void>)
callbackify<TResult>(() => Promise<TResult>)
createRandomString()

Generiert eine zufällige 5 bis 6 Zeichenzeichenfolge.
debuglog(string, (fn: DebugLoggerFunction) => void)

Die util.debuglog() Methode wird verwendet, um eine Funktion zu erstellen, die Debugmeldungen stderr bedingt basierend auf dem Vorhandensein der NODE_DEBUG Umgebungsvariable schreibt. Wenn der section Name innerhalb des Werts dieser Umgebungsvariable angezeigt wird, funktioniert die zurückgegebene Funktion ähnlich wie console.error(). Wenn nicht, ist die zurückgegebene Funktion eine no-op.

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hello from foo [%d]', 123);

Wenn dieses Programm mit NODE_DEBUG=foo in der Umgebung ausgeführt wird, gibt es etwas wie folgt aus:

FOO 3245: hello from foo [123]

dabei ist 3245 die Prozess-ID. Wenn sie nicht mit diesem Umgebungsvariablensatz ausgeführt wird, wird nichts gedruckt.

Die section unterstützt auch Folgendes:

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hi there, it\'s foo-bar [%d]', 2333);

wenn sie mit NODE_DEBUG=foo* in der Umgebung ausgeführt wird, wird folgendes ausgegeben:

FOO-BAR 3257: hi there, it's foo-bar [2333]

Mehrere durch Trennzeichen getrennte section Namen können in der Umgebungsvariable NODE_DEBUG angegeben werden: NODE_DEBUG=fs,net,tls.

Das optionale callback-Argument kann verwendet werden, um die Protokollierungsfunktion durch eine andere Funktion zu ersetzen, die keine Initialisierung oder unnötigen Umbruch enthält.

import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
  // Replace with a logging function that optimizes out
  // testing if the section is enabled
  log = debug;
});
deprecate<T>(T, string, string)

Die util.deprecate()-Methode umschließt fn (die eine Funktion oder Klasse sein kann), sodass sie als veraltet gekennzeichnet ist.

import { deprecate } from 'node:util';

export const obsoleteFunction = deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

Wenn sie aufgerufen wird, gibt util.deprecate() eine Funktion zurück, die mithilfe des DeprecationWarning-Ereignisses eine 'warning' ausgibt. Die Warnung wird ausgegeben und in stderr gedruckt, wenn die zurückgegebene Funktion zum ersten Mal aufgerufen wird. Nachdem die Warnung ausgegeben wurde, wird die umschlossene Funktion aufgerufen, ohne eine Warnung auszusetzen.

Wenn dieselbe optionale code in mehreren Aufrufen von util.deprecate()angegeben wird, wird die Warnung nur einmal für diese codeausgegeben.

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Wenn entweder die --no-deprecation- oder --no-warnings Befehlszeilenflaggen verwendet werden oder die process.noDeprecation-Eigenschaft auf truevor dem auf die erste Warnung zum Veraltet festgelegt ist, führt die util.deprecate() Methode nichts aus.

Wenn die --trace-deprecation- oder --trace-warnings Befehlszeilenkennzeichnungen festgelegt sind oder die process.traceDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Warnung und eine Stapelablaufverfolgung beim ersten Aufruf der veralteten Funktion in stderr gedruckt.

Wenn die --throw-deprecation Befehlszeilenkennzeichnung festgelegt ist oder die process.throwDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Ausnahme ausgelöst, wenn die veraltete Funktion aufgerufen wird.

Die --throw-deprecation Befehlszeilenkennzeichnung und process.throwDeprecation Eigenschaft haben Vorrang vor --trace-deprecation und process.traceDeprecation.
diff(string | (readonly string[]), string | (readonly string[]))

util.diff() Vergleicht zwei Zeichenfolgen- oder Arraywerte und gibt ein Array mit Differenzeinträgen zurück. Es verwendet den Myers-Diff-Algorithmus, um minimale Unterschiede zu berechnen, was derselbe Algorithmus ist, der intern von Assertionsfehlermeldungen verwendet wird.

Wenn die Werte gleich sind, wird ein leeres Array zurückgegeben.

const { diff } = require('node:util');

// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
//   [0, '1'],
//   [0, '2'],
//   [1, '3'],
//   [1, '4'],
//   [-1, '!'],
//   [-1, '!'],
//   [0, '5'],
//   [1, '6'],
//   [-1, '!'],
//   [0, '7'],
//   [1, '8'],
//   [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
//   [0, '1'],
//   [1, '2'],
//   [0, '3'],
//   [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []
find<T>((x: T) => boolean, T[])

Sucht den ersten Wert in einem Array, das dem angegebenen Prädikat entspricht.
findIndex<T>((x: T) => boolean, T[])

Sucht den Index des ersten Werts in einem Array, das dem angegebenen Prädikat entspricht.
format(any, any[])

Die util.format() Methode gibt eine formatierte Zeichenfolge mit dem ersten Argument als printf-ähnliche Formatzeichenfolge zurück, die null oder mehr Formatbezeichner enthalten kann. Jeder Bezeichner wird durch den konvertierten Wert aus dem entsprechenden Argument ersetzt. Unterstützte Bezeichner sind:

Wenn ein Bezeichner nicht über ein entsprechendes Argument verfügt, wird er nicht ersetzt:

util.format('%s:%s', 'foo');
// Returns: 'foo:%s'

Werte, die nicht Teil der Formatzeichenfolge sind, werden mithilfe von util.inspect() formatiert, wenn ihr Typ nicht stringist.

Wenn mehr Argumente an die util.format()-Methode übergeben werden als die Anzahl der Bezeichner, werden die zusätzlichen Argumente mit der zurückgegebenen Zeichenfolge verkettet, getrennt durch Leerzeichen:

util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'

Wenn das erste Argument keinen gültigen Formatbezeichner enthält, gibt util.format() eine Zeichenfolge zurück, die die Verkettung aller Argumente ist, die durch Leerzeichen getrennt sind:

util.format(1, 2, 3);
// Returns: '1 2 3'

Wenn nur ein Argument an util.format()übergeben wird, wird es wie ohne Formatierung zurückgegeben:

util.format('%% %s');
// Returns: '%% %s'

util.format() ist eine synchrone Methode, die als Debuggingtool vorgesehen ist. Einige Eingabewerte können einen erheblichen Leistungsaufwand haben, der die Ereignisschleife blockieren kann. Verwenden Sie diese Funktion mit Bedacht und niemals in einem hot-Code-Pfad.
formatWithOptions(InspectOptions, any, any[])

Diese Funktion ist identisch mit Format, mit der Ausnahme, dass es ein inspectOptions Argument verwendet, das Optionen angibt, die an inspectübergeben werden.

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.
generateUUID()

Generiert eine Uuid mit 20 Zeichen.
getCallSites(GetCallSitesOptions)
getCallSites(number, GetCallSitesOptions)

Gibt ein Array von Aufrufwebsiteobjekten zurück, das den Stapel der Aufruferfunktion enthält.

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('Call Sites:');
  callSites.forEach((callSite, index) => {
    console.log(`CallSite ${index + 1}:`);
    console.log(`Function Name: ${callSite.functionName}`);
    console.log(`Script Name: ${callSite.scriptName}`);
    console.log(`Line Number: ${callSite.lineNumber}`);
    console.log(`Column Number: ${callSite.column}`);
  });
  // CallSite 1:
  // Function Name: exampleFunction
  // Script Name: /home/example.js
  // Line Number: 5
  // Column Number: 26

  // CallSite 2:
  // Function Name: anotherFunction
  // Script Name: /home/example.js
  // Line Number: 22
  // Column Number: 3

  // ...
}

// A function to simulate another stack layer
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

Es ist möglich, die ursprünglichen Speicherorte zu rekonstruieren, indem Sie die Option sourceMap auf truefestlegen. Wenn die Quellkarte nicht verfügbar ist, entspricht der ursprüngliche Speicherort dem aktuellen Speicherort. Wenn das --enable-source-maps Flag aktiviert ist, z. B. bei Verwendung von --experimental-transform-types, ist sourceMap standardmäßig "true".

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

const callSites = getCallSites({ sourceMap: true });

// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26

// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
getRandomValue()

Gibt Zufallszahl zurück.
getSystemErrorMap()

Gibt eine Zuordnung aller Systemfehlercodes zurück, die über die Node.js-API verfügbar sind. Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig. Informationen zu den Namen häufiger Fehler finden Sie unter Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const errorMap = util.getSystemErrorMap();
  const name = errorMap.get(err.errno);
  console.error(name);  // ENOENT
});
getSystemErrorMessage(number)

Gibt die Zeichenfolgenmeldung für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Zeichenfolgenmeldungen ist plattformabhängig.

fs.access('file/that/does/not/exist', (err) => {
  const message = util.getSystemErrorMessage(err.errno);
  console.error(message);  // no such file or directory
});
getSystemErrorName(number)

Gibt den Zeichenfolgennamen für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig. Informationen zu den Namen häufiger Fehler finden Sie unter Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});
getTimeDiffInMilliseconds(Date, Date)

Gibt das Zeitintervall zwischen zwei Datumsangaben in Millisekunden zurück.
inherits(unknown, unknown)

Es wird davon abgeraten, util.inherits() zu verwenden. Verwenden Sie die Schlüsselwörter ES6 class und extends, um unterstützung für die Vererbung auf Sprachenebene zu erhalten. Beachten Sie außerdem, dass die beiden Formatvorlagen semantisch inkompatibelsind.

Erben Sie die Prototypmethoden von einem -Konstruktor in einen anderen. Der Prototyp von constructor wird auf ein neues Objekt festgelegt, das aus superConstructorerstellt wurde.

Dies fügt vor allem einige Eingabeüberprüfungen oben hinzu Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Als zusätzlichen Komfort wird superConstructor über die eigenschaft constructor.super_ zugänglich sein.

const util = require('node:util');
const EventEmitter = require('node:events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"

ES6-Beispiel mit class und extends:

import EventEmitter from 'node:events';

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
inspect(any, boolean, null | number, boolean)

Die util.inspect() Methode gibt eine Zeichenfolgendarstellung von object zurück, die für das Debuggen vorgesehen ist. Die Ausgabe von util.inspect kann sich jederzeit ändern und sollte nicht programmgesteuert abhängig sein. Zusätzliche options können übergeben werden, die das Ergebnis ändern. util.inspect() verwendet den Namen und/oder Symbol.toStringTag die Eigenschaft des Konstruktors, um ein identifizierbares Tag für einen geprüften Wert zu erstellen.

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

Zirkelbezüge verweisen mithilfe eines Referenzindex auf ihre Verankerung:

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

Im folgenden Beispiel werden alle Eigenschaften des util-Objekts überprüft:

import util from 'node:util';

console.log(util.inspect(util, { showHidden: true, depth: null }));

Im folgenden Beispiel wird die Auswirkung der option compact hervorgehoben:

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

Mit der Option showHidden können WeakMap und WeakSet Einträge überprüft werden. Wenn mehr Einträge als maxArrayLengthvorhanden sind, gibt es keine Garantie, welche Einträge angezeigt werden. Das bedeutet, dass das Abrufen desselben WeakSet Einträge zweimal zu einer anderen Ausgabe führen kann. Darüber hinaus können Einträge ohne verbleibende starke Verweise jederzeit garbage collection sein.

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

Mit der Option sorted wird sichergestellt, dass die Einfügereihenfolge eines Objekts nicht auf das Ergebnis util.inspect()wirkt.

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

Mit der Option numericSeparator werden allen Zahlen alle drei Ziffern ein Unterstrich hinzugefügt.

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

util.inspect() ist eine synchrone Methode zum Debuggen. Die maximale Ausgangslänge beträgt ca. 128 MiB. Eingaben, die zu einer längeren Ausgabe führen, werden abgeschnitten.
inspect(any, InspectOptions)
isArray(unknown)

Alias für Array.isArray().

Gibt true zurück, wenn die angegebene object ein Arrayist. Andernfalls wird falsezurückgegeben.

import util from 'node:util';

util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
isCreate(string)

Überprüft, ob der Einbettungstyp erstellt wird
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Gibt true zurück, wenn es eine tiefe strenge Gleichheit zwischen val1 und val2gibt. Andernfalls wird falsezurückgegeben.

Weitere Informationen zur tiefen strengen Gleichheit finden Sie unter assert.deepStrictEqual().
isRDLEmbed(string)

Überprüft, ob die Einbettungs-URL für DEN RDL-Bericht gilt.
isSavedInternal(HttpPostMessage, string, Window)

Überprüft, ob der Bericht gespeichert wird.
parseArgs<T>(T)

Stellt eine API auf höherer Ebene für die Befehlszeilenargumentanalyse bereit als die direkte Interaktion mit process.argv. Verwendet eine Spezifikation für die erwarteten Argumente und gibt ein strukturiertes Objekt mit den analysierten Optionen und Positionalen zurück.

import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
  foo: {
    type: 'boolean',
    short: 'f',
  },
  bar: {
    type: 'string',
  },
};
const {
  values,
  positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []
parseEnv(string)

Stabilität: 1.1 - Aktive Entwicklung Bei einem Beispiel .env Datei:

import { parseEnv } from 'node:util';

parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
promisify((callback: (err?: any) => void) => void)
promisify(Function)
promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void)
promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void)
promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void)
promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void)
promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void)
promisify<T1>((arg1: T1, callback: (err?: any) => void) => void)
promisify<TCustom>(CustomPromisify<TCustom>)

Verwendet eine Funktion nach dem allgemeinen Fehlerrückrufstil, d. h. ein (err, value) => ... Rückruf als letztes Argument zu übernehmen und eine Version zurück, die Zusagen zurückgibt.

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

Alternativ können Sie auch async functions verwenden:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

async function callStat() {
  const stats = await promisifiedStat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

callStat();

Wenn eine original[util.promisify.custom] Eigenschaft vorhanden ist, promisify wird der Wert zurückgegeben, siehe benutzerdefinierte promisifizierte Funktionen.

promisify() geht davon aus, dass original eine Funktion ist, die einen Rückruf als letztes Argument in allen Fällen annimmt. Wenn original keine Funktion ist, löst promisify() einen Fehler aus. Wenn original eine Funktion ist, aber das letzte Argument kein Fehlerrückruf ist, wird weiterhin ein Fehlerrückruf als letztes Argument übergeben.

Die Verwendung von promisify() für Klassenmethoden oder andere Methoden, die this verwenden, funktioniert möglicherweise nicht wie erwartet, es sei denn, es wird speziell behandelt:

import { promisify } from 'node:util';

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
raiseCustomEvent(HTMLElement, string, any)

Löst ein benutzerdefiniertes Ereignis mit Ereignisdaten für das angegebene HTML-Element aus.
remove<T>((x: T) => boolean, T[])
setTraceSigInt(boolean)

Aktivieren oder Deaktivieren des Druckens einer Stapelablaufverfolgung auf SIGINT. Die API ist nur im Hauptthread verfügbar.
stripVTControlCharacters(string)

Gibt str zurück, wobei alle ANSI-Escapecodes entfernt wurden.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
styleText(ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], string, StyleTextOptions)

Diese Funktion gibt einen formatierten Text zurück, der den format übergebenen Druckvorgang in einem Terminal berücksichtigt. Es ist sich der Funktionen des Terminals bewusst und verhält sich entsprechend dem Konfigurationssatz über NO_COLORund NODE_DISABLE_COLORSFORCE_COLOR Umgebungsvariablen.

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // Validate if process.stderr has TTY
  { stream: stderr },
);
console.error(errorMessage);

util.inspect.colors stellt auch Textformate wie italicund underline bereit, und Sie können beides kombinieren:

console.log(
  util.styleText(['underline', 'italic'], 'My italic underlined message'),
);

Wenn Sie ein Array von Formaten übergeben, wird die Reihenfolge des angewendeten Formats von links nach rechts festgelegt, sodass die folgende Formatvorlage die vorherige Formatvorlage überschreiben kann.

console.log(
  util.styleText(['red', 'green'], 'text'), // green
);

Der besondere Formatwert none wendet keine zusätzliche Formatierung auf den Text an.

Die vollständige Liste der Formate finden Sie in Modifizierern.
toUSVString(string)

Gibt den string zurück, nachdem alle Ersatzcodepunkte (oder gleichwertig, alle entkoppelten Ersatzcodeeinheiten) durch das Unicode-Zeichen "Ersetzungszeichen" U+FFFD ersetzt wurden.
transferableAbortController()

Erstellt und gibt eine AbortController Instanz zurück, deren AbortSignal als übertragbar gekennzeichnet ist und mit structuredClone() oder postMessage()verwendet werden kann.
transferableAbortSignal(AbortSignal)

Kennzeichnet die angegebene AbortSignal als übertragbar, damit sie mitstructuredClone() und postMessage()verwendet werden kann.

const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);

Details zur Funktion

aborted(AbortSignal, any)

Lauscht auf das Abbruchereignis für die bereitgestellte signal und gibt eine Zusage zurück, die aufgelöst wird, wenn die signal abgebrochen wird. Wenn resource bereitgestellt wird, verweist sie schwach auf das zugeordnete Objekt des Vorgangs. Wenn also resource vor dem signal abgebrochen wird, bleibt die zurückgegebene Zusage ausstehend. Dadurch werden Speicherlecks in lang ausgeführten oder nicht abbruchfähigen Vorgängen verhindert.

import { aborted } from 'node:util';

// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();

// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
  // This code runs when `dependent` is aborted.
  console.log('Dependent resource was aborted.');
});

// Simulate an event that triggers the abort.
dependent.on('event', () => {
  dependent.abort(); // This will cause the `aborted` promise to resolve.
});

function aborted(signal: AbortSignal, resource: any): Promise<void>

Parameter

signal

AbortSignal

resource

any

Jedes Nicht-Null-Objekt, das an den abgebrochenen Vorgang gebunden ist und schwach gehalten wird. Wenn resource vor dem Abbruch der signal garbage gesammelt wird, bleibt die Zusage ausstehend, sodass Node.js die Nachverfolgung beenden kann. Dadurch wird verhindert, dass Speicherverluste in lang ausgeführten oder nicht abbruchfähigen Vorgängen auftreten.

Gibt zurück

Promise<void>

addParamToUrl(string, string, string)

Fügt der angegebenen URL einen Parameter hinzu.

function addParamToUrl(url: string, paramName: string, value: string): string

Parameter

url

string

paramName

string

value

string

Gibt zurück

string

assign(any[])

Kopiert die Werte aller aufzählbaren Eigenschaften aus einem oder mehreren Quellobjekten in ein Zielobjekt und gibt das Zielobjekt zurück.

function assign(args: any[]): any

Parameter

args

any[]

Gibt zurück

any

autoAuthInEmbedUrl(string)

Überprüft, ob die Einbettungs-URL autoAuth=true enthält.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parameter

embedUrl

string

Gibt zurück

boolean

callbackify(() => Promise<void>)

Verwendet eine async Funktion (oder eine Funktion, die eine Promisezurückgibt) und gibt eine Funktion nach dem Fehlerrückrufstil zurück, d. h. ein (err, value) => ... Rückruf als letztes Argument. Im Rückruf ist das erste Argument der Ablehnungsgrund (oder null, wenn die Promise aufgelöst wurde), und das zweite Argument ist der aufgelöste Wert.

import { callbackify } from 'node:util';

async function fn() {
  return 'hello world';
}
const callbackFunction = callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

Druckt:

hello world

Der Rückruf wird asynchron ausgeführt und verfügt über eine eingeschränkte Stapelablaufverfolgung. Wenn der Rückruf ausgelöst wird, gibt der Prozess ein 'uncaughtException' Ereignis aus, und wenn nicht behandelt wird, wird das Ereignis beendet.

Da null eine besondere Bedeutung als erstes Argument für einen Rückruf hat, wenn eine umschlossene Funktion eine Promise mit einem gefälschten Wert als Grund ablehnt, wird der Wert in eine Error mit dem ursprünglichen Wert eingeschlossen, der in einem Feld mit dem Namen reasongespeichert ist.

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

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});

function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

() => Promise<void>

Eine async-Funktion

Gibt zurück

(callback: (err: NodeJS.ErrnoException) => void) => void

Eine Rückrufformatfunktion

callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, T5, T6, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>) 

function callbackify<T1, T2, T3, T4, T5, T6>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>) 

function callbackify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>) 

function callbackify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>) 

function callbackify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>) 

function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3) => Promise<void>

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>) 

function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parameter

fn

(arg1: T1, arg2: T2) => Promise<TResult>

Gibt zurück

(arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>) 

function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1, arg2: T2) => Promise<void>

Gibt zurück

(arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, TResult>((arg1: T1) => Promise<TResult>) 

function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

Parameter

fn

(arg1: T1) => Promise<TResult>

Gibt zurück

(arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

callbackify<T1>((arg1: T1) => Promise<void>) 

function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void

Parameter

fn

(arg1: T1) => Promise<void>

Gibt zurück

(arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<TResult>(() => Promise<TResult>) 

function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

Parameter

fn

() => Promise<TResult>

Gibt zurück

(callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

createRandomString()

Generiert eine zufällige 5 bis 6 Zeichenzeichenfolge.

function createRandomString(): string

Gibt zurück

string

debuglog(string, (fn: DebugLoggerFunction) => void)

Die util.debuglog() Methode wird verwendet, um eine Funktion zu erstellen, die Debugmeldungen stderr bedingt basierend auf dem Vorhandensein der NODE_DEBUG Umgebungsvariable schreibt. Wenn der section Name innerhalb des Werts dieser Umgebungsvariable angezeigt wird, funktioniert die zurückgegebene Funktion ähnlich wie console.error(). Wenn nicht, ist die zurückgegebene Funktion eine no-op.

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hello from foo [%d]', 123);

Wenn dieses Programm mit NODE_DEBUG=foo in der Umgebung ausgeführt wird, gibt es etwas wie folgt aus:

FOO 3245: hello from foo [123]

dabei ist 3245 die Prozess-ID. Wenn sie nicht mit diesem Umgebungsvariablensatz ausgeführt wird, wird nichts gedruckt.

Die section unterstützt auch Folgendes:

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hi there, it\'s foo-bar [%d]', 2333);

wenn sie mit NODE_DEBUG=foo* in der Umgebung ausgeführt wird, wird folgendes ausgegeben:

FOO-BAR 3257: hi there, it's foo-bar [2333]

Mehrere durch Trennzeichen getrennte section Namen können in der Umgebungsvariable NODE_DEBUG angegeben werden: NODE_DEBUG=fs,net,tls.

Das optionale callback-Argument kann verwendet werden, um die Protokollierungsfunktion durch eine andere Funktion zu ersetzen, die keine Initialisierung oder unnötigen Umbruch enthält.

import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
  // Replace with a logging function that optimizes out
  // testing if the section is enabled
  log = debug;
});

function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger

Parameter

section

string

Eine Zeichenfolge, die den Teil der Anwendung angibt, für den die debuglog-Funktion erstellt wird.

callback

(fn: DebugLoggerFunction) => void

Ein Rückruf wird aufgerufen, wenn die Protokollierungsfunktion zum ersten Mal mit einem Funktionsargument aufgerufen wird, bei dem es sich um eine optimierte Protokollierungsfunktion handelt.

Gibt zurück

DebugLogger

Die Protokollierungsfunktion

deprecate<T>(T, string, string)

Die util.deprecate()-Methode umschließt fn (die eine Funktion oder Klasse sein kann), sodass sie als veraltet gekennzeichnet ist.

import { deprecate } from 'node:util';

export const obsoleteFunction = deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

Wenn sie aufgerufen wird, gibt util.deprecate() eine Funktion zurück, die mithilfe des DeprecationWarning-Ereignisses eine 'warning' ausgibt. Die Warnung wird ausgegeben und in stderr gedruckt, wenn die zurückgegebene Funktion zum ersten Mal aufgerufen wird. Nachdem die Warnung ausgegeben wurde, wird die umschlossene Funktion aufgerufen, ohne eine Warnung auszusetzen.

Wenn dieselbe optionale code in mehreren Aufrufen von util.deprecate()angegeben wird, wird die Warnung nur einmal für diese codeausgegeben.

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Wenn entweder die --no-deprecation- oder --no-warnings Befehlszeilenflaggen verwendet werden oder die process.noDeprecation-Eigenschaft auf truevor dem auf die erste Warnung zum Veraltet festgelegt ist, führt die util.deprecate() Methode nichts aus.

Wenn die --trace-deprecation- oder --trace-warnings Befehlszeilenkennzeichnungen festgelegt sind oder die process.traceDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Warnung und eine Stapelablaufverfolgung beim ersten Aufruf der veralteten Funktion in stderr gedruckt.

Wenn die --throw-deprecation Befehlszeilenkennzeichnung festgelegt ist oder die process.throwDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Ausnahme ausgelöst, wenn die veraltete Funktion aufgerufen wird.

Die --throw-deprecation Befehlszeilenkennzeichnung und process.throwDeprecation Eigenschaft haben Vorrang vor --trace-deprecation und process.traceDeprecation.

function deprecate<T>(fn: T, msg: string, code?: string): T

Parameter

fn

T

Die Funktion, die veraltet ist.

msg

string

Eine Warnmeldung, die angezeigt wird, wenn die veraltete Funktion aufgerufen wird.

code

string

Ein Veralteter Code. Eine Liste der Codes finden Sie im list of deprecated APIs.

Gibt zurück

T

Die veraltete Funktion, die zum Ausgeben einer Warnung umschlossen ist.

diff(string | (readonly string[]), string | (readonly string[]))

util.diff() Vergleicht zwei Zeichenfolgen- oder Arraywerte und gibt ein Array mit Differenzeinträgen zurück. Es verwendet den Myers-Diff-Algorithmus, um minimale Unterschiede zu berechnen, was derselbe Algorithmus ist, der intern von Assertionsfehlermeldungen verwendet wird.

Wenn die Werte gleich sind, wird ein leeres Array zurückgegeben.

const { diff } = require('node:util');

// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
//   [0, '1'],
//   [0, '2'],
//   [1, '3'],
//   [1, '4'],
//   [-1, '!'],
//   [-1, '!'],
//   [0, '5'],
//   [1, '6'],
//   [-1, '!'],
//   [0, '7'],
//   [1, '8'],
//   [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
//   [0, '1'],
//   [1, '2'],
//   [0, '3'],
//   [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []

function diff(actual: string | (readonly string[]), expected: string | (readonly string[])): DiffEntry[]

Parameter

actual

string | (readonly string[])

Der erste zu vergleichende Wert

expected

string | (readonly string[])

Der zweite zu vergleichende Wert

Gibt zurück

DiffEntry[]

Ein Array mit Differenzeinträgen. Jeder Eintrag ist ein Array mit zwei Elementen:

  • Index 0: Operation code: number-1 for delete, 0 for no-op/unchanged, for insert, 1 for insert
  • Index 1: string Der dem Vorgang zugeordnete Wert

find<T>((x: T) => boolean, T[])

Sucht den ersten Wert in einem Array, das dem angegebenen Prädikat entspricht.

function find<T>(predicate: (x: T) => boolean, xs: T[]): T

Parameter

predicate

(x: T) => boolean

xs

T[]

Gibt zurück

T

findIndex<T>((x: T) => boolean, T[])

Sucht den Index des ersten Werts in einem Array, das dem angegebenen Prädikat entspricht.

function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): number

Parameter

predicate

(x: T) => boolean

xs

T[]

Gibt zurück

number

format(any, any[])

Die util.format() Methode gibt eine formatierte Zeichenfolge mit dem ersten Argument als printf-ähnliche Formatzeichenfolge zurück, die null oder mehr Formatbezeichner enthalten kann. Jeder Bezeichner wird durch den konvertierten Wert aus dem entsprechenden Argument ersetzt. Unterstützte Bezeichner sind:

Wenn ein Bezeichner nicht über ein entsprechendes Argument verfügt, wird er nicht ersetzt:

util.format('%s:%s', 'foo');
// Returns: 'foo:%s'

Werte, die nicht Teil der Formatzeichenfolge sind, werden mithilfe von util.inspect() formatiert, wenn ihr Typ nicht stringist.

Wenn mehr Argumente an die util.format()-Methode übergeben werden als die Anzahl der Bezeichner, werden die zusätzlichen Argumente mit der zurückgegebenen Zeichenfolge verkettet, getrennt durch Leerzeichen:

util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'

Wenn das erste Argument keinen gültigen Formatbezeichner enthält, gibt util.format() eine Zeichenfolge zurück, die die Verkettung aller Argumente ist, die durch Leerzeichen getrennt sind:

util.format(1, 2, 3);
// Returns: '1 2 3'

Wenn nur ein Argument an util.format()übergeben wird, wird es wie ohne Formatierung zurückgegeben:

util.format('%% %s');
// Returns: '%% %s'

util.format() ist eine synchrone Methode, die als Debuggingtool vorgesehen ist. Einige Eingabewerte können einen erheblichen Leistungsaufwand haben, der die Ereignisschleife blockieren kann. Verwenden Sie diese Funktion mit Bedacht und niemals in einem hot-Code-Pfad.

function format(format?: any, param: any[]): string

Parameter

format

any

Eine printf-ähnliche Formatzeichenfolge.

param

any[]

Gibt zurück

string

formatWithOptions(InspectOptions, any, any[])

Diese Funktion ist identisch mit Format, mit der Ausnahme, dass es ein inspectOptions Argument verwendet, das Optionen angibt, die an inspectübergeben werden.

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.

function formatWithOptions(inspectOptions: InspectOptions, format?: any, param: any[]): string

Parameter

inspectOptions
InspectOptions
format

any

param

any[]

Gibt zurück

string

generateUUID()

Generiert eine Uuid mit 20 Zeichen.

function generateUUID(): string

Gibt zurück

string

getCallSites(GetCallSitesOptions) 

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parameter

options

GetCallSitesOptions

Gibt zurück

CallSiteObject[]

getCallSites(number, GetCallSitesOptions)

Gibt ein Array von Aufrufwebsiteobjekten zurück, das den Stapel der Aufruferfunktion enthält.

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('Call Sites:');
  callSites.forEach((callSite, index) => {
    console.log(`CallSite ${index + 1}:`);
    console.log(`Function Name: ${callSite.functionName}`);
    console.log(`Script Name: ${callSite.scriptName}`);
    console.log(`Line Number: ${callSite.lineNumber}`);
    console.log(`Column Number: ${callSite.column}`);
  });
  // CallSite 1:
  // Function Name: exampleFunction
  // Script Name: /home/example.js
  // Line Number: 5
  // Column Number: 26

  // CallSite 2:
  // Function Name: anotherFunction
  // Script Name: /home/example.js
  // Line Number: 22
  // Column Number: 3

  // ...
}

// A function to simulate another stack layer
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

Es ist möglich, die ursprünglichen Speicherorte zu rekonstruieren, indem Sie die Option sourceMap auf truefestlegen. Wenn die Quellkarte nicht verfügbar ist, entspricht der ursprüngliche Speicherort dem aktuellen Speicherort. Wenn das --enable-source-maps Flag aktiviert ist, z. B. bei Verwendung von --experimental-transform-types, ist sourceMap standardmäßig "true".

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

const callSites = getCallSites({ sourceMap: true });

// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26

// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26

function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[]

Parameter

frameCount

number

Anzahl der Frames, die als Aufrufwebsiteobjekte erfasst werden sollen. Standard:10. Zulässiger Bereich liegt zwischen 1 und 200.

options

GetCallSitesOptions

Gibt zurück

CallSiteObject[]

Ein Array von Aufrufwebsiteobjekten

getRandomValue()

Gibt Zufallszahl zurück.

function getRandomValue(): number

Gibt zurück

number

getSystemErrorMap()

Gibt eine Zuordnung aller Systemfehlercodes zurück, die über die Node.js-API verfügbar sind. Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig. Informationen zu den Namen häufiger Fehler finden Sie unter Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const errorMap = util.getSystemErrorMap();
  const name = errorMap.get(err.errno);
  console.error(name);  // ENOENT
});

function getSystemErrorMap(): Map<number, [string, string]>

Gibt zurück

Map<number, [string, string]>

getSystemErrorMessage(number)

Gibt die Zeichenfolgenmeldung für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Zeichenfolgenmeldungen ist plattformabhängig.

fs.access('file/that/does/not/exist', (err) => {
  const message = util.getSystemErrorMessage(err.errno);
  console.error(message);  // no such file or directory
});

function getSystemErrorMessage(err: number): string

Parameter

err

number

Gibt zurück

string

getSystemErrorName(number)

Gibt den Zeichenfolgennamen für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig. Informationen zu den Namen häufiger Fehler finden Sie unter Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});

function getSystemErrorName(err: number): string

Parameter

err

number

Gibt zurück

string

getTimeDiffInMilliseconds(Date, Date)

Gibt das Zeitintervall zwischen zwei Datumsangaben in Millisekunden zurück.

function getTimeDiffInMilliseconds(start: Date, end: Date): number

Parameter

start

Date

end

Date

Gibt zurück

number

inherits(unknown, unknown)

Es wird davon abgeraten, util.inherits() zu verwenden. Verwenden Sie die Schlüsselwörter ES6 class und extends, um unterstützung für die Vererbung auf Sprachenebene zu erhalten. Beachten Sie außerdem, dass die beiden Formatvorlagen semantisch inkompatibelsind.

Erben Sie die Prototypmethoden von einem -Konstruktor in einen anderen. Der Prototyp von constructor wird auf ein neues Objekt festgelegt, das aus superConstructorerstellt wurde.

Dies fügt vor allem einige Eingabeüberprüfungen oben hinzu Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Als zusätzlichen Komfort wird superConstructor über die eigenschaft constructor.super_ zugänglich sein.

const util = require('node:util');
const EventEmitter = require('node:events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"

ES6-Beispiel mit class und extends:

import EventEmitter from 'node:events';

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('With ES6');

function inherits(constructor: unknown, superConstructor: unknown)

Parameter

constructor

unknown

superConstructor

unknown

inspect(any, boolean, null | number, boolean)

Die util.inspect() Methode gibt eine Zeichenfolgendarstellung von object zurück, die für das Debuggen vorgesehen ist. Die Ausgabe von util.inspect kann sich jederzeit ändern und sollte nicht programmgesteuert abhängig sein. Zusätzliche options können übergeben werden, die das Ergebnis ändern. util.inspect() verwendet den Namen und/oder Symbol.toStringTag die Eigenschaft des Konstruktors, um ein identifizierbares Tag für einen geprüften Wert zu erstellen.

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

Zirkelbezüge verweisen mithilfe eines Referenzindex auf ihre Verankerung:

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

Im folgenden Beispiel werden alle Eigenschaften des util-Objekts überprüft:

import util from 'node:util';

console.log(util.inspect(util, { showHidden: true, depth: null }));

Im folgenden Beispiel wird die Auswirkung der option compact hervorgehoben:

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

Mit der Option showHidden können WeakMap und WeakSet Einträge überprüft werden. Wenn mehr Einträge als maxArrayLengthvorhanden sind, gibt es keine Garantie, welche Einträge angezeigt werden. Das bedeutet, dass das Abrufen desselben WeakSet Einträge zweimal zu einer anderen Ausgabe führen kann. Darüber hinaus können Einträge ohne verbleibende starke Verweise jederzeit garbage collection sein.

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

Mit der Option sorted wird sichergestellt, dass die Einfügereihenfolge eines Objekts nicht auf das Ergebnis util.inspect()wirkt.

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

Mit der Option numericSeparator werden allen Zahlen alle drei Ziffern ein Unterstrich hinzugefügt.

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

util.inspect() ist eine synchrone Methode zum Debuggen. Die maximale Ausgangslänge beträgt ca. 128 MiB. Eingaben, die zu einer längeren Ausgabe führen, werden abgeschnitten.

function inspect(object: any, showHidden?: boolean, depth?: null | number, color?: boolean): string

Parameter

object

any

Jeder JavaScript-Grundtyp oder Object.

showHidden

boolean

depth

null | number

color

boolean

Gibt zurück

string

Die Darstellung von object.

inspect(any, InspectOptions) 

function inspect(object: any, options?: InspectOptions): string

Parameter

object

any

options
InspectOptions

Gibt zurück

string

isArray(unknown)

Warnung

Diese API ist nun veraltet.

Since v4.0.0 - Use isArray instead.

Alias für Array.isArray().

Gibt true zurück, wenn die angegebene object ein Arrayist. Andernfalls wird falsezurückgegeben.

import util from 'node:util';

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

function isArray(object: unknown): object

Parameter

object

unknown

Gibt zurück

object

isCreate(string)

Überprüft, ob der Einbettungstyp erstellt wird

function isCreate(embedType: string): boolean

Parameter

embedType

string

Gibt zurück

boolean

isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Gibt true zurück, wenn es eine tiefe strenge Gleichheit zwischen val1 und val2gibt. Andernfalls wird falsezurückgegeben.

Weitere Informationen zur tiefen strengen Gleichheit finden Sie unter assert.deepStrictEqual().

function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): boolean

Parameter

val1

unknown

val2

unknown

options
IsDeepStrictEqualOptions

Gibt zurück

boolean

isRDLEmbed(string)

Überprüft, ob die Einbettungs-URL für DEN RDL-Bericht gilt.

function isRDLEmbed(embedUrl: string): boolean

Parameter

embedUrl

string

Gibt zurück

boolean

isSavedInternal(HttpPostMessage, string, Window)

Überprüft, ob der Bericht gespeichert wird.

function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>

Parameter

hpm

HttpPostMessage

uid

string

contentWindow

Window

Gibt zurück

Promise<boolean>

parseArgs<T>(T)

Stellt eine API auf höherer Ebene für die Befehlszeilenargumentanalyse bereit als die direkte Interaktion mit process.argv. Verwendet eine Spezifikation für die erwarteten Argumente und gibt ein strukturiertes Objekt mit den analysierten Optionen und Positionalen zurück.

import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
  foo: {
    type: 'boolean',
    short: 'f',
  },
  bar: {
    type: 'string',
  },
};
const {
  values,
  positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []

function parseArgs<T>(config?: T): ParsedResults<T>

Parameter

config

T

Wird verwendet, um Argumente für die Analyse bereitzustellen und den Parser zu konfigurieren. config unterstützt die folgenden Eigenschaften:

Gibt zurück

ParsedResults<T>

Die analysierten Befehlszeilenargumente:

parseEnv(string)

Stabilität: 1.1 - Aktive Entwicklung Bei einem Beispiel .env Datei:

import { parseEnv } from 'node:util';

parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }

function parseEnv(content: string): NodeJS.Dict<string>

Parameter

content

string

Der rohe Inhalt einer .env Datei.

Gibt zurück

NodeJS.Dict<string>

promisify((callback: (err?: any) => void) => void) 

function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>

Parameter

fn

(callback: (err?: any) => void) => void

Gibt zurück

() => Promise<void>

promisify(Function) 

function promisify(fn: Function): Function

Parameter

fn

Function

Gibt zurück

Function

promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>

Parameter

fn

(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void

Gibt zurück

(arg1: T1, arg2: T2, arg3: T3) => Promise<void>

promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>

Parameter

fn

(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void

Gibt zurück

(arg1: T1, arg2: T2) => Promise<TResult>

promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void) 

function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>

Parameter

fn

(arg1: T1, arg2: T2, callback: (err?: any) => void) => void

Gibt zurück

(arg1: T1, arg2: T2) => Promise<void>

promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>

Parameter

fn

(arg1: T1, callback: (err: any, result: TResult) => void) => void

Gibt zurück

(arg1: T1) => Promise<TResult>

promisify<T1>((arg1: T1, callback: (err?: any) => void) => void) 

function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>

Parameter

fn

(arg1: T1, callback: (err?: any) => void) => void

Gibt zurück

(arg1: T1) => Promise<void>

promisify<TCustom>(CustomPromisify<TCustom>)

Verwendet eine Funktion nach dem allgemeinen Fehlerrückrufstil, d. h. ein (err, value) => ... Rückruf als letztes Argument zu übernehmen und eine Version zurück, die Zusagen zurückgibt.

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

Alternativ können Sie auch async functions verwenden:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

async function callStat() {
  const stats = await promisifiedStat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

callStat();

Wenn eine original[util.promisify.custom] Eigenschaft vorhanden ist, promisify wird der Wert zurückgegeben, siehe benutzerdefinierte promisifizierte Funktionen.

promisify() geht davon aus, dass original eine Funktion ist, die einen Rückruf als letztes Argument in allen Fällen annimmt. Wenn original keine Funktion ist, löst promisify() einen Fehler aus. Wenn original eine Funktion ist, aber das letzte Argument kein Fehlerrückruf ist, wird weiterhin ein Fehlerrückruf als letztes Argument übergeben.

Die Verwendung von promisify() für Klassenmethoden oder andere Methoden, die this verwenden, funktioniert möglicherweise nicht wie erwartet, es sei denn, es wird speziell behandelt:

import { promisify } from 'node:util';

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'

function promisify<TCustom>(fn: CustomPromisify<TCustom>): TCustom

Parameter

fn

CustomPromisify<TCustom>

Gibt zurück

TCustom

promisify<TResult>((callback: (err: any, result: TResult) => void) => void) 

function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>

Parameter

fn

(callback: (err: any, result: TResult) => void) => void

Gibt zurück

() => Promise<TResult>

raiseCustomEvent(HTMLElement, string, any)

Löst ein benutzerdefiniertes Ereignis mit Ereignisdaten für das angegebene HTML-Element aus.

function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)

Parameter

element

HTMLElement

eventName

string

eventData

any

remove<T>((x: T) => boolean, T[]) 

function remove<T>(predicate: (x: T) => boolean, xs: T[])

Parameter

predicate

(x: T) => boolean

xs

T[]

setTraceSigInt(boolean)

Aktivieren oder Deaktivieren des Druckens einer Stapelablaufverfolgung auf SIGINT. Die API ist nur im Hauptthread verfügbar.

function setTraceSigInt(enable: boolean)

Parameter

enable

boolean

stripVTControlCharacters(string)

Gibt str zurück, wobei alle ANSI-Escapecodes entfernt wurden.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"

function stripVTControlCharacters(str: string): string

Parameter

str

string

Gibt zurück

string

styleText(ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], string, StyleTextOptions)

Diese Funktion gibt einen formatierten Text zurück, der den format übergebenen Druckvorgang in einem Terminal berücksichtigt. Es ist sich der Funktionen des Terminals bewusst und verhält sich entsprechend dem Konfigurationssatz über NO_COLORund NODE_DISABLE_COLORSFORCE_COLOR Umgebungsvariablen.

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // Validate if process.stderr has TTY
  { stream: stderr },
);
console.error(errorMessage);

util.inspect.colors stellt auch Textformate wie italicund underline bereit, und Sie können beides kombinieren:

console.log(
  util.styleText(['underline', 'italic'], 'My italic underlined message'),
);

Wenn Sie ein Array von Formaten übergeben, wird die Reihenfolge des angewendeten Formats von links nach rechts festgelegt, sodass die folgende Formatvorlage die vorherige Formatvorlage überschreiben kann.

console.log(
  util.styleText(['red', 'green'], 'text'), // green
);

Der besondere Formatwert none wendet keine zusätzliche Formatierung auf den Text an.

Die vollständige Liste der Formate finden Sie in Modifizierern.

function styleText(format: ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], text: string, options?: StyleTextOptions): string

Parameter

format

ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[]

Ein Textformat oder ein Array von Textformaten, die in util.inspect.colorsdefiniert sind.

text

string

Der zu formatierende Text.

options
StyleTextOptions

Gibt zurück

string

toUSVString(string)

Gibt den string zurück, nachdem alle Ersatzcodepunkte (oder gleichwertig, alle entkoppelten Ersatzcodeeinheiten) durch das Unicode-Zeichen "Ersetzungszeichen" U+FFFD ersetzt wurden.

function toUSVString(string: string): string

Parameter

string

string

Gibt zurück

string

transferableAbortController()

Erstellt und gibt eine AbortController Instanz zurück, deren AbortSignal als übertragbar gekennzeichnet ist und mit structuredClone() oder postMessage()verwendet werden kann.

function transferableAbortController(): AbortController

Gibt zurück

AbortController

Ein übertragbarer AbortController

transferableAbortSignal(AbortSignal)

Kennzeichnet die angegebene AbortSignal als übertragbar, damit sie mitstructuredClone() und postMessage()verwendet werden kann.

const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parameter

signal

AbortSignal

Das AbortSignal

Gibt zurück

AbortSignal

Dasselbe AbortSignal