util module

Écoute l’événement d’abandon sur le signal fourni et retourne une promesse qui se résout lorsque le signal est abandonné. Si resource est fourni, il fait faiblement référence à l’objet associé de l’opération. Par conséquent, si resource est récupéré par le garbage collection avant que le signal abandonne, la promesse retournée reste en attente. Cela empêche les fuites de mémoire dans les opérations longues ou non annulables.

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>

Paramètres

Retours

Ajoute un paramètre à l’URL donnée

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

Paramètres

Retours

Copie les valeurs de toutes les propriétés énumérables d’un ou plusieurs objets sources vers un objet cible et retourne l’objet cible.

function assign(args: any[]): any

Paramètres

Retours

Vérifie si l’URL incorporée contient autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Paramètres

Retours

Prend une fonction async (ou une fonction qui retourne un Promise) et retourne une fonction suivant le style de rappel d’erreur premier, c’est-à-dire en prenant un rappel (err, value) => ... comme dernier argument. Dans le rappel, le premier argument est la raison du rejet (ou null si le Promise résolu) et le deuxième argument est la valeur résolue.

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

Imprimera :

hello world

Le rappel est exécuté de manière asynchrone et aura une trace de pile limitée. Si le rappel lève, le processus émet un événement 'uncaughtException', et s’il n’est pas géré, il se ferme.

Étant donné que null a une signification spéciale comme premier argument d’un rappel, si une fonction encapsulée rejette un Promise avec une valeur falsy comme raison, la valeur est encapsulée dans un Error avec la valeur d’origine stockée dans un champ nommé reason.

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

Paramètres

Retours

fonction de style de rappel

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

Génère une chaîne de caractères aléatoire de 5 à 6 caractères.

function createRandomString(): string

Retours

La util.debuglog() méthode est utilisée pour créer une fonction qui écrit conditionnellement des messages de débogage en stderr fonction de l’existence de la NODE_DEBUG variable d’environnement. Si le nom section apparaît dans la valeur de cette variable d’environnement, la fonction retournée fonctionne comme console.error(). Si ce n’est pas le cas, la fonction retournée est une no-op.

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

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

Si ce programme est exécuté avec NODE_DEBUG=foo dans l’environnement, il génère quelque chose comme suit :

FOO 3245: hello from foo [123]

où 3245 est l’ID de processus. S’il n’est pas exécuté avec cette variable d’environnement définie, il n’imprime rien.

Le section prend également en charge les caractères génériques :

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

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

s’il est exécuté avec NODE_DEBUG=foo* dans l’environnement, il génère quelque chose comme suit :

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

Plusieurs noms séparés par des virgules section peuvent être spécifiés dans la variable d’environnement NODE_DEBUG : NODE_DEBUG=fs,net,tls.

L’argument facultatif callback peut être utilisé pour remplacer la fonction de journalisation par une autre fonction qui n’a pas d’initialisation ni d’habillage inutile.

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

Paramètres

Retours

Fonction de journalisation

La méthode util.deprecate() encapsule fn (qui peut être une fonction ou une classe) de telle façon qu’elle est marquée comme déconseillée.

import { deprecate } from 'node:util';

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

Lorsqu’elle est appelée, util.deprecate() retourne une fonction qui émet une DeprecationWarning à l’aide de l’événement 'warning'. L’avertissement est émis et imprimé pour stderr la première fois que la fonction retournée est appelée. Une fois l’avertissement émis, la fonction encapsulée est appelée sans émettre d’avertissement.

Si la même code facultative est fournie dans plusieurs appels à util.deprecate(), l’avertissement n’est émis qu’une seule fois pour cette code.

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

Si les indicateurs de ligne de commande --no-deprecation ou --no-warnings sont utilisés ou si la propriété process.noDeprecation est définie sur true'avertissement antérieur à la première dépréciation, la méthode util.deprecate() ne fait rien.

Si les indicateurs de ligne de commande --trace-deprecation ou --trace-warnings sont définis, ou si la propriété process.traceDeprecation est définie sur true, un avertissement et une trace de pile sont imprimés pour stderr la première fois que la fonction dépréciée est appelée.

Si l’indicateur de ligne de commande --throw-deprecation est défini ou si la propriété process.throwDeprecation est définie sur true, une exception est levée lorsque la fonction déconseillée est appelée.

L’indicateur de ligne de commande --throw-deprecation et la propriété process.throwDeprecation sont prioritaires sur --trace-deprecation et process.traceDeprecation.

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

Paramètres

Retours

Fonction déconseillée encapsulée pour émettre un avertissement.

util.diff() compare deux valeurs de chaîne ou de tableau et retourne un tableau d’entrées de différence. Il utilise l’algorithme de différences Myers pour calculer des différences minimales, qui est le même algorithme utilisé en interne par les messages d’erreur d’assertion.

Si les valeurs sont égales, un tableau vide est retourné.

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[]

Paramètres

Retours

Tableau d’entrées de différence. Chaque entrée est un tableau avec deux éléments :

• Index 0 : code d’opération : number-1 pour supprimer, 0 pour no-op/inchangé, 1 pour insérer
• Index 1 : string valeur associée à l’opération

Recherche la première valeur d’un tableau qui correspond au prédicat spécifié.

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

Paramètres

Retours

Recherche l’index de la première valeur dans un tableau qui correspond au prédicat spécifié.

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

Paramètres

Retours

La méthode util.format() retourne une chaîne mise en forme à l’aide du premier argument en tant que chaîne de format printfqui peut contenir zéro ou plusieurs spécificateurs de format. Chaque spécificateur est remplacé par la valeur convertie de l’argument correspondant. Les spécificateurs pris en charge sont les suivants :

Si un spécificateur n’a pas d’argument correspondant, il n’est pas remplacé :

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

Les valeurs qui ne font pas partie de la chaîne de format sont mises en forme à l’aide de util.inspect() si leur type n’est pas string.

S’il existe plus d’arguments passés à la méthode util.format() que le nombre de spécificateurs, les arguments supplémentaires sont concaténés à la chaîne retournée, séparés par des espaces :

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

Si le premier argument ne contient pas de spécificateur de format valide, util.format() retourne une chaîne qui est la concaténation de tous les arguments séparés par des espaces :

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

Si un seul argument est passé à util.format(), il est retourné, car il n’est pas mis en forme :

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

util.format() est une méthode synchrone destinée à être un outil de débogage. Certaines valeurs d’entrée peuvent avoir une surcharge significative des performances qui peut bloquer la boucle d’événement. Utilisez cette fonction avec soin et jamais dans un chemin de code chaud.

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

Paramètres

Retours

Cette fonction est identique à format, sauf qu’elle prend un argument inspectOptions qui spécifie les options transmises au inspecter.

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

Paramètres

Retours

Génère un uuid de 20 caractères.

function generateUUID(): string

Retours

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Paramètres

Retours

Retourne un tableau d’objets de site d’appel contenant la pile de la fonction appelante.

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

Il est possible de reconstruire les emplacements d’origine en définissant l’option sourceMap sur true. Si la carte source n’est pas disponible, l’emplacement d’origine est identique à l’emplacement actuel. Lorsque l’indicateur --enable-source-maps est activé, par exemple lors de l’utilisation de --experimental-transform-types, sourceMap sera true par défaut.

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[]

Paramètres

Retours

Tableau d’objets de site d’appel

Retourne un nombre aléatoire

function getRandomValue(): number

Retours

Retourne un mappage de tous les codes d’erreur système disponibles à partir de l’API Node.js. Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme. Consultez Common System Errors pour connaître les noms des erreurs courantes.

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]>

Retours

Retourne le message de chaîne d’un code d’erreur numérique provenant d’une API Node.js. Le mappage entre les codes d’erreur et les messages de chaîne dépend de la plateforme.

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

Paramètres

Retours

Retourne le nom de chaîne d’un code d’erreur numérique provenant d’une API Node.js. Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme. Consultez Common System Errors pour connaître les noms des erreurs courantes.

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

function getSystemErrorName(err: number): string

Paramètres

Retours

Retourne l’intervalle de temps entre deux dates en millisecondes

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

Paramètres

Retours

L’utilisation de util.inherits() est déconseillée. Utilisez les mots clés ES6 class et extends pour obtenir la prise en charge de l’héritage au niveau du langage. Notez également que les deux styles sont sémantiquement incompatibles.

Héritez des méthodes prototypes d’un constructeur dans une autre. Le prototype de constructor sera défini sur un nouvel objet créé à partir de superConstructor.

Cela ajoute principalement une validation d’entrée en plus de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). En guise de commodité supplémentaire, superConstructor sera accessible via la propriété constructor.super_.

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!"

Exemple ES6 utilisant class et 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)

Paramètres

La méthode util.inspect() retourne une représentation sous forme de chaîne de object destinée au débogage. La sortie de util.inspect peut changer à tout moment et ne doit pas être dépendante par programme. Des options supplémentaires peuvent être passées qui modifient le résultat. util.inspect() utilise le nom et/ou Symbol.toStringTag la propriété du constructeur pour rendre une balise identifiable pour une valeur inspectée.

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] {}'

Les références circulaires pointent vers leur ancre à l’aide d’un index de référence :

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] }
// }

L’exemple suivant inspecte toutes les propriétés de l’objet util :

import util from 'node:util';

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

L’exemple suivant met en évidence l’effet de l’option compact :

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.

L’option showHidden permet d’inspecter les entrées WeakMap et WeakSet. S’il y a plus d’entrées que maxArrayLength, il n’existe aucune garantie que les entrées sont affichées. Cela signifie que la récupération des mêmes entrées WeakSet deux fois peut entraîner une sortie différente. En outre, les entrées sans références fortes restantes peuvent être collectées à tout moment par la mémoire.

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

L’option sorted garantit que l’ordre d’insertion de propriété d’un objet n’a pas d’impact sur le résultat de util.inspect().

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

L’option numericSeparator ajoute un trait de soulignement toutes les trois chiffres à tous les nombres.

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() est une méthode synchrone destinée au débogage. Sa longueur de sortie maximale est d’environ 128 Mio. Les entrées qui entraînent une sortie plus longue seront tronquées.

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

Paramètres

Retours

Représentation de object.

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

Paramètres

Retours

Alias pour Array.isArray().

Retourne true si le object donné est un Array. Sinon, retourne false.

import util from 'node:util';

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

function isArray(object: unknown): object

Paramètres

Retours

Vérifie si le type d’incorporation est créé

function isCreate(embedType: string): boolean

Paramètres

Retours

Retourne true s’il existe une égalité stricte entre val1 et val2. Sinon, retourne false.

Consultez assert.deepStrictEqual() pour plus d’informations sur l’égalité stricte.

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

Paramètres

Retours

Vérifie si l’URL incorporée concerne le rapport RDL.

function isRDLEmbed(embedUrl: string): boolean

Paramètres

Retours

Vérifie si le rapport est enregistré.

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

Paramètres

Retours

Fournit une API de niveau supérieur pour l’analyse des arguments de ligne de commande que l’interaction avec process.argv directement. Prend une spécification pour les arguments attendus et retourne un objet structuré avec les options et les positions analysées.

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>

Paramètres

Retours

Arguments de ligne de commande analysés :

Stabilité : 1.1 - Développement actif En fonction d’un exemple de fichier .env :

import { parseEnv } from 'node:util';

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

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

Paramètres

Retours

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

Paramètres

Retours

function promisify(fn: Function): Function

Paramètres

Retours

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>

Paramètres

Retours

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>

Paramètres

Retours

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>

Paramètres

Retours

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>

Paramètres

Retours

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>

Paramètres

Retours

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>

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

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

Paramètres

Retours

Prend une fonction suivant le style de rappel d’erreur courant, c’est-à-dire en prenant un rappel (err, value) => ... comme dernier argument et retourne une version qui retourne des promesses.

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

Ou, en utilisant des async functions :

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

S’il existe une original[util.promisify.custom] propriété présente, promisify retourne sa valeur, consultez les fonctions promisifiées personnalisées.

promisify() suppose que original est une fonction prenant un rappel comme argument final dans tous les cas. Si original n’est pas une fonction, promisify() génère une erreur. Si original est une fonction mais que son dernier argument n’est pas un rappel d’erreur premier, il est toujours passé un rappel d’erreur en tant que dernier argument.

L’utilisation de promisify() sur des méthodes de classe ou d’autres méthodes qui utilisent this peut ne pas fonctionner comme prévu, sauf si elle est gérée spécialement :

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

Paramètres

Retours

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

Paramètres

Retours

Déclenche un événement personnalisé avec des données d’événement sur l’élément HTML spécifié.

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

Paramètres

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

Paramètres

Activez ou désactivez l’impression d’une trace de pile sur SIGINT. L’API est disponible uniquement sur le thread principal.

function setTraceSigInt(enable: boolean)

Paramètres

Retourne str avec les codes d’échappement ANSI supprimés.

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

function stripVTControlCharacters(str: string): string

Paramètres

Retours

Cette fonction retourne un texte mis en forme compte de l’impression format passée dans un terminal. Il est conscient des fonctionnalités du terminal et agit en fonction de l’ensemble de configuration via NO_COLOR, NODE_DISABLE_COLORS et FORCE_COLOR des variables d’environnement.

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 fournit également des formats de texte tels que italic, et underline et vous pouvez combiner les deux :

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

Lors du passage d’un tableau de formats, l’ordre du format appliqué est de gauche à droite afin que le style suivant puisse remplacer le format précédent.

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

La valeur none de format spéciale n’applique aucun style supplémentaire au texte.

Vous trouverez la liste complète des formats dans modificateurs.

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

Paramètres

Retours

Retourne l'string après avoir remplacé les points de code de substitution (ou équivalents, toutes les unités de code de substitution non souhaitées) par le caractère de remplacement Unicode U+FFFD.

function toUSVString(string: string): string

Paramètres

Retours

Crée et retourne une instance AbortController dont la AbortSignal est marquée comme transférable et peut être utilisée avec structuredClone() ou postMessage().

function transferableAbortController(): AbortController

Retours

AbortController transférable

Marque le AbortSignal donné comme transférable afin qu’il puisse être utilisé avecstructuredClone() et postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Paramètres

Retours

Le même AbortSignal