util module

Escucha el evento abort en el signal proporcionado y devuelve una promesa que se resuelve cuando se anula el signal. Si se proporciona resource, hace referencia débilmente al objeto asociado de la operación, por lo que si resource se recolecte de elementos no utilizados antes de que se anule la signal, la promesa devuelta permanecerá pendiente. Esto evita pérdidas de memoria en operaciones de larga duración o no cancelables.

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>

Parámetros

Devoluciones

Agrega un parámetro a la dirección URL especificada.

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

Parámetros

Devoluciones

Copia los valores de todas las propiedades enumerables de uno o varios objetos de origen en un objeto de destino y devuelve el objeto de destino.

function assign(args: any[]): any

Parámetros

Devoluciones

Comprueba si la dirección URL de inserción contiene autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parámetros

Devoluciones

Toma una función async (o una función que devuelve un Promise) y devuelve una función siguiendo el estilo de devolución de llamada de error primero, es decir, tomando una devolución de llamada (err, value) => ... como último argumento. En la devolución de llamada, el primer argumento será el motivo del rechazo (o null si el Promise resuelto) y el segundo argumento será el valor resuelto.

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

Imprimirá:

hello world

La devolución de llamada se ejecuta de forma asincrónica y tendrá un seguimiento limitado de la pila. Si se produce la devolución de llamada, el proceso emitirá un evento de 'uncaughtException' y, si no se controla, se cerrará.

Dado que null tiene un significado especial como primer argumento para una devolución de llamada, si una función ajustada rechaza un Promise con un valor falso como motivo, el valor se ajusta en un Error con el valor original almacenado en un campo denominado 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

Parámetros

Devoluciones

una función de estilo de devolución de llamada

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

Genera una cadena aleatoria de 5 a 6 caracteres.

function createRandomString(): string

Devoluciones

El util.debuglog() método se usa para crear una función que escribe condicionalmente mensajes de depuración en stderr función de la existencia de la NODE_DEBUG variable de entorno. Si el nombre del section aparece dentro del valor de esa variable de entorno, la función devuelta funciona de forma similar a console.error(). Si no es así, la función devuelta es un no-op.

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

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

Si este programa se ejecuta con NODE_DEBUG=foo en el entorno, generará un resultado similar al siguiente:

FOO 3245: hello from foo [123]

donde 3245 es el identificador de proceso. Si no se ejecuta con esa variable de entorno establecida, no imprimirá nada.

El section admite también caracteres comodín:

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

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

si se ejecuta con NODE_DEBUG=foo* en el entorno, generará un resultado similar al siguiente:

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

Se pueden especificar varios nombres separados por comas section en la NODE_DEBUG variable de entorno: NODE_DEBUG=fs,net,tls.

El argumento opcional callback se puede usar para reemplazar la función de registro por una función diferente que no tenga ninguna inicialización o ajuste innecesario.

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

Parámetros

Devoluciones

La función de registro

El método util.deprecate() encapsula fn (que puede ser una función o clase) de tal manera que esté marcado como en desuso.

import { deprecate } from 'node:util';

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

Cuando se llama a , util.deprecate() devolverá una función que emitirá un DeprecationWarning mediante el evento 'warning'. La advertencia se emitirá e imprimirá en stderr la primera vez que se llame a la función devuelta. Una vez emitida la advertencia, se llama a la función ajustada sin emitir una advertencia.

Si se proporciona el mismo code opcional en varias llamadas a util.deprecate(), la advertencia solo se emitirá una vez para ese 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 se usan las marcas de línea de comandos --no-deprecation o --no-warnings, o si la propiedad process.noDeprecation está establecida en trueanterior a la primera advertencia de desuso, el método util.deprecate() no hace nada.

Si se establecen las marcas de línea de comandos de --trace-deprecation o --trace-warnings, o la propiedad process.traceDeprecation se establece en true, se imprime una advertencia y se imprime un seguimiento de pila en stderr la primera vez que se llama a la función en desuso.

Si se establece la marca de línea de comandos --throw-deprecation o la propiedad process.throwDeprecation se establece en true, se producirá una excepción cuando se llame a la función en desuso.

La marca de línea de comandos --throw-deprecation y la propiedad process.throwDeprecation tienen prioridad sobre --trace-deprecation y process.traceDeprecation.

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

Parámetros

Devoluciones

Función en desuso ajustada para emitir una advertencia.

util.diff() compara dos valores de cadena o matriz y devuelve una matriz de entradas de diferencia. Usa el algoritmo de diferencias Myers para calcular las diferencias mínimas, que es el mismo algoritmo utilizado internamente por los mensajes de error de aserción.

Si los valores son iguales, se devuelve una matriz vacía.

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

Parámetros

Devoluciones

Matriz de entradas de diferencia. Cada entrada es una matriz con dos elementos:

• Índice 0: number Código de operación: -1 para eliminar, 0 para no-op/unchanged, 1 para insertar
• Índice 1: string el valor asociado a la operación

Busca el primer valor de una matriz que coincide con el predicado especificado.

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

Parámetros

Devoluciones

Busca el índice del primer valor de una matriz que coincide con el predicado especificado.

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

Parámetros

Devoluciones

El método util.format() devuelve una cadena con formato utilizando el primer argumento como una cadena de formato similar a printfque puede contener cero o más especificadores de formato. Cada especificador se reemplaza por el valor convertido del argumento correspondiente. Los especificadores admitidos son:

Si un especificador no tiene un argumento correspondiente, no se reemplaza:

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

Los valores que no forman parte de la cadena de formato tienen formato mediante util.inspect() si su tipo no es string.

Si hay más argumentos pasados al método util.format() que el número de especificadores, los argumentos adicionales se concatenan a la cadena devuelta, separadas por espacios:

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

Si el primer argumento no contiene un especificador de formato válido, util.format() devuelve una cadena que es la concatenación de todos los argumentos separados por espacios:

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

Si solo se pasa un argumento a util.format(), se devuelve tal como está sin ningún formato:

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

util.format() es un método sincrónico destinado a una herramienta de depuración. Algunos valores de entrada pueden tener una sobrecarga de rendimiento significativa que puede bloquear el bucle de eventos. Use esta función con cuidado y nunca en una ruta de acceso de código activa.

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

Parámetros

Devoluciones

Esta función es idéntica a formato, excepto en que toma un argumento inspectOptions que especifica las opciones que se pasan a inspeccionar.

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

Parámetros

Devoluciones

Genera un uuid de 20 caracteres.

function generateUUID(): string

Devoluciones

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parámetros

Devoluciones

Devuelve una matriz de objetos de sitio de llamada que contienen la pila de la función de llamador.

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 posible reconstruir las ubicaciones originales estableciendo la opción sourceMap en true. Si el mapa de origen no está disponible, la ubicación original será la misma que la ubicación actual. Cuando la marca --enable-source-maps está habilitada, por ejemplo, al usar --experimental-transform-types, sourceMap será true de forma predeterminada.

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

Parámetros

Devoluciones

Matriz de objetos de sitio de llamada

Devuelve un número aleatorio.

function getRandomValue(): number

Devoluciones

Devuelve un mapa de todos los códigos de error del sistema disponibles en la API de Node.js. La asignación entre códigos de error y nombres de error depende de la plataforma. Consulte Common System Errors para obtener los nombres de errores comunes.

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

Devoluciones

Devuelve el mensaje de cadena de un código de error numérico que procede de una API de Node.js. La asignación entre códigos de error y mensajes de cadena depende de la plataforma.

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

Parámetros

Devoluciones

Devuelve el nombre de cadena de un código de error numérico que procede de una API de Node.js. La asignación entre códigos de error y nombres de error depende de la plataforma. Consulte Common System Errors para obtener los nombres de errores comunes.

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

function getSystemErrorName(err: number): string

Parámetros

Devoluciones

Devuelve el intervalo de tiempo entre dos fechas en milisegundos.

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

Parámetros

Devoluciones

No se recomienda el uso de util.inherits(). Use las palabras clave es6 class y extends para obtener compatibilidad con la herencia de nivel de lenguaje. Tenga en cuenta también que los dos estilos son semánticamente incompatibles.

Herede los métodos prototipos de un constructor de en otro. El prototipo de constructor se establecerá en un nuevo objeto creado a partir de superConstructor.

Esto agrega principalmente cierta validación de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)entrada sobre . Como comodidad adicional, superConstructor será accesible a través de la propiedad 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!"

Ejemplo de ES6 mediante class y 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)

Parámetros

El método util.inspect() devuelve una representación de cadena de object que está pensada para la depuración. La salida de util.inspect puede cambiar en cualquier momento y no debe depender de ellas mediante programación. Es posible que se pasen options adicionales que modifiquen el resultado. util.inspect() usará el nombre o Symbol.toStringTag la propiedad del constructor para crear una etiqueta identificable para un valor inspeccionado.

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

Las referencias circulares apuntan a su delimitador mediante un índice de referencia:

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

En el ejemplo siguiente se inspeccionan todas las propiedades del objeto util:

import util from 'node:util';

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

En el ejemplo siguiente se resalta el efecto de la opción 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.

La opción showHidden permite inspeccionar WeakMap y WeakSet entradas. Si hay más entradas que maxArrayLength, no hay ninguna garantía de qué entradas se muestran. Esto significa que recuperar las mismas entradas de WeakSet dos veces puede dar lugar a una salida diferente. Además, las entradas sin referencias seguras restantes pueden ser recolecciones de elementos no utilizados en cualquier momento.

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

La opción sorted garantiza que el orden de inserción de propiedades de un objeto no afecte al resultado 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 }),
);

La opción numericSeparator agrega un carácter de subrayado cada tres dígitos a todos los números.

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() es un método sincrónico destinado a la depuración. Su longitud máxima de salida es de aproximadamente 128 MiB. Las entradas que dan como resultado una salida más larga se truncarán.

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

Parámetros

Devoluciones

Representación de object.

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

Parámetros

Devoluciones

Alias para Array.isArray().

Devuelve true si el object especificado es un Array. De lo contrario, devuelve 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

Parámetros

Devoluciones

Comprueba si el tipo de inserción es para crear

function isCreate(embedType: string): boolean

Parámetros

Devoluciones

Devuelve true si hay una igualdad estricta profunda entre val1 y val2. De lo contrario, devuelve false.

Consulte assert.deepStrictEqual() para obtener más información sobre la igualdad estricta profunda.

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

Parámetros

Devoluciones

Comprueba si la dirección URL de inserción es para el informe RDL.

function isRDLEmbed(embedUrl: string): boolean

Parámetros

Devoluciones

Comprueba si el informe se guarda.

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

Parámetros

Devoluciones

Proporciona una API de nivel superior para el análisis de argumentos de línea de comandos que interactuar con process.argv directamente. Toma una especificación para los argumentos esperados y devuelve un objeto estructurado con las opciones analizadas y los posicionales.

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>

Parámetros

Devoluciones

Argumentos de línea de comandos analizados:

Estabilidad: 1.1 - Desarrollo activo Dado un ejemplo .env archivo:

import { parseEnv } from 'node:util';

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

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

function promisify(fn: Function): Function

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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>

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

Toma una función siguiendo el estilo común de devolución de llamada de error primero, es decir, tomando una devolución de llamada (err, value) => ... como último argumento y devuelve una versión que devuelve promesas.

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

O bien, de forma equivalente mediante 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();

Si hay una original[util.promisify.custom] propiedad presente, promisify devolverá su valor, consulte Funciones promisificadas personalizadas.

promisify() supone que original es una función que toma una devolución de llamada como argumento final en todos los casos. Si original no es una función, promisify() producirá un error. Si original es una función pero su último argumento no es una devolución de llamada de error primero, se seguirá pasando una devolución de llamada de error primero como último argumento.

El uso de promisify() en métodos de clase u otros métodos que usan this puede no funcionar según lo previsto a menos que se controle especialmente:

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

Genera un evento personalizado con datos de eventos en el elemento HTML especificado.

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

Parámetros

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

Parámetros

Habilite o deshabilite la impresión de un seguimiento de pila en SIGINT. La API solo está disponible en el subproceso principal.

function setTraceSigInt(enable: boolean)

Parámetros

Devuelve str con los códigos de escape ANSI quitados.

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

function stripVTControlCharacters(str: string): string

Parámetros

Devoluciones

Esta función devuelve un texto con formato considerando el format pasado para imprimir en un terminal. Es consciente de las funcionalidades del terminal y actúa según la configuración establecida a través NO_COLORde variables NODE_DISABLE_COLORS de entorno y FORCE_COLOR .

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 también proporciona formatos de texto como italicy underline y puede combinar ambos:

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

Al pasar una matriz de formatos, el orden del formato aplicado se deja a la derecha para que el siguiente estilo pueda sobrescribir el anterior.

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

El valor none de formato especial no aplica ningún estilo adicional al texto.

La lista completa de formatos se puede encontrar en modificadores .

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

Parámetros

Devoluciones

Devuelve el string después de reemplazar los puntos de código suplentes (o equivalentemente, las unidades de código suplentes no emparejadas) con el U+FFFD "carácter de reemplazo" Unicode.

function toUSVString(string: string): string

Parámetros

Devoluciones

Crea y devuelve una instancia de AbortController cuya AbortSignal está marcada como transferible y se puede usar con structuredClone() o postMessage().

function transferableAbortController(): AbortController

Devoluciones

AnulaciónController transferible

Marca el AbortSignal dado como transferible para que se pueda usar constructuredClone() y postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parámetros

Devoluciones

El mismo AbortSignal