util module

Ouve o evento abortar no signal fornecido e retorna uma promessa que é cumprida quando o signal é abortado. Se o resource passado for lixo recolhido antes de o signal ser abortado, a promessa devolvida permanecerá pendente indefinidamente.

import { aborted } from 'node:util';

const dependent = obtainSomethingAbortable();

aborted(dependent.signal, dependent).then(() => {
  // Do something when dependent is aborted.
});

dependent.on('event', () => {
  dependent.abort();
});

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

Parâmetros

Devoluções

Adiciona um parâmetro à url fornecida

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

Parâmetros

Devoluções

Copia os valores de todas as propriedades enumeráveis de um ou mais objetos de origem para um objeto de destino e retorna o objeto de destino.

function assign(args: any[]): any

Parâmetros

Devoluções

Verifica se o url de incorporação contém autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parâmetros

Devoluções

Usa uma função async (ou uma função que retorna um Promise) e retorna uma função seguindo o estilo de retorno de chamada error-first, ou seja, tomando um retorno de chamada (err, value) => ... como o último argumento. No retorno de chamada, o primeiro argumento será o motivo da rejeição (ou null se o Promise resolvido), e o segundo argumento será o valor resolvido.

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

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

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

Irá imprimir:

hello world

O retorno de chamada é executado de forma assíncrona e terá um rastreamento de pilha limitado. Se o retorno de chamada for lançado, o processo emitirá um evento 'uncaughtException' e, se não for manipulado, será encerrado.

Como null tem um significado especial como o primeiro argumento para um retorno de chamada, se uma função encapsulada rejeitar um Promise com um valor falso como motivo, o valor será encapsulado em um Error com o valor original armazenado em um campo chamado 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

Devoluções

uma função de estilo de retorno de chamada

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Parâmetros

Devoluções

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

Parâmetros

Devoluções

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

Parâmetros

Devoluções

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

Parâmetros

Devoluções

Gera uma cadeia aleatória de 5 a 6 caracteres.

function createRandomString(): string

Devoluções

O método util.debuglog() é usado para criar uma função que grava condicionalmente mensagens de depuração para stderr com base na existência da variável de ambiente NODE_DEBUG. Se o nome do section aparecer dentro do valor dessa variável de ambiente, a função retornada funcionará de forma semelhante a console.error(). Se não, então a função retornada é um no-op.

const util = require('node:util');
const debuglog = util.debuglog('foo');

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

Se este programa for executado com NODE_DEBUG=foo no ambiente, então ele produzirá algo como:

FOO 3245: hello from foo [123]

onde 3245 é a ID do processo. Se ele não for executado com essa variável de ambiente definida, ele não imprimirá nada.

O section suporta curinga também:

const util = require('node:util');
const debuglog = util.debuglog('foo-bar');

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

Se ele for executado com NODE_DEBUG=foo* no ambiente, ele produzirá algo como:

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

Vários nomes de section separados por vírgulas podem ser especificados na variável de ambiente NODE_DEBUG: NODE_DEBUG=fs,net,tls.

O argumento callback opcional pode ser usado para substituir a função de registro por uma função diferente que não tenha nenhuma inicialização ou encapsulamento desnecessário.

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

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

Parâmetros

Devoluções

A função de registo

O método util.debuglog() é usado para criar uma função que grava condicionalmente mensagens de depuração para stderr com base na existência da variável de ambiente NODE_DEBUG. Se o nome do section aparecer dentro do valor dessa variável de ambiente, a função retornada funcionará de forma semelhante a console.error(). Se não, então a função retornada é um no-op.

const util = require('node:util');
const debuglog = util.debuglog('foo');

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

Se este programa for executado com NODE_DEBUG=foo no ambiente, então ele produzirá algo como:

FOO 3245: hello from foo [123]

onde 3245 é a ID do processo. Se ele não for executado com essa variável de ambiente definida, ele não imprimirá nada.

O section suporta curinga também:

const util = require('node:util');
const debuglog = util.debuglog('foo-bar');

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

Se ele for executado com NODE_DEBUG=foo* no ambiente, ele produzirá algo como:

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

Vários nomes de section separados por vírgulas podem ser especificados na variável de ambiente NODE_DEBUG: NODE_DEBUG=fs,net,tls.

O argumento callback opcional pode ser usado para substituir a função de registro por uma função diferente que não tenha nenhuma inicialização ou encapsulamento desnecessário.

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

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

Parâmetros

Devoluções

A função de registo

O método util.deprecate() encapsula fn (que pode ser uma função ou classe) de tal forma que é marcado como obsoleto.

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

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

Quando chamado, util.deprecate() retornará uma função que emitirá um DeprecationWarning usando o evento 'warning'. O aviso será emitido e impresso para stderr na primeira vez que a função retornada for chamada. Depois que o aviso é emitido, a função wrapped é chamada sem emitir um aviso.

Se o mesmo code opcional for fornecido em várias chamadas para util.deprecate(), o aviso será emitido apenas uma vez para esse code.

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

const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Se os sinalizadores de linha de comando --no-deprecation ou --no-warnings forem usados, ou se a propriedade process.noDeprecation estiver definida como trueantes ao primeiro aviso de depreciação, o método util.deprecate() não fará nada.

Se os sinalizadores de linha de comando --trace-deprecation ou --trace-warnings estiverem definidos ou a propriedade process.traceDeprecation estiver definida como true, um aviso e um rastreamento de pilha serão impressos para stderr na primeira vez que a função preterida for chamada.

Se o sinalizador de linha de comando --throw-deprecation estiver definido ou a propriedade process.throwDeprecation estiver definida como true, uma exceção será lançada quando a função preterida for chamada.

O sinalizador de linha de comando --throw-deprecation e a propriedade process.throwDeprecation têm precedência sobre --trace-deprecation e process.traceDeprecation.

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

Parâmetros

Devoluções

A função preterida foi encapsulada para emitir um aviso.

Localiza o primeiro valor em uma matriz que corresponde ao predicado especificado.

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

Parâmetros

Devoluções

Localiza o índice do primeiro valor em uma matriz que corresponde ao predicado especificado.

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

Parâmetros

Devoluções

O método util.format() retorna uma cadeia de caracteres formatada usando o primeiro argumento como uma cadeia de caracteres de formato semelhante a printfque pode conter zero ou mais especificadores de formato. Cada especificador é substituído pelo valor convertido do argumento correspondente. Os especificadores suportados são:

Se um especificador não tiver um argumento correspondente, ele não será substituído:

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

Os valores que não fazem parte da cadeia de caracteres de formato são formatados usando util.inspect() se seu tipo não estiver string.

Se houver mais argumentos passados para o método util.format() do que o número de especificadores, os argumentos extras serão concatenados à cadeia de caracteres retornada, separados por espaços:

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

Se o primeiro argumento não contiver um especificador de formato válido, util.format() retornará uma cadeia de caracteres que é a concatenação de todos os argumentos separados por espaços:

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

Se apenas um argumento for passado para util.format(), ele será retornado como está, sem qualquer formatação:

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

util.format() é um método síncrono que se destina como uma ferramenta de depuração. Alguns valores de entrada podem ter uma sobrecarga de desempenho significativa que pode bloquear o loop de eventos. Use esta função com cuidado e nunca em um caminho de código quente.

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

Parâmetros

Devoluções

Esta função é idêntica a formato, exceto no sentido de que é necessário um argumento inspectOptions que especifica as opções que são passadas para inspecionar.

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

Devoluções

Gera um uuid de 20 caracteres.

function generateUUID(): string

Devoluções

Devolve um número aleatório

function getRandomValue(): number

Devoluções

Retorna um mapa de todos os códigos de erro do sistema disponíveis na API Node.js. O mapeamento entre códigos de erro e nomes de erro depende da plataforma. Consulte Common System Errors para obter os nomes dos erros comuns.

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

Devoluções

Retorna o nome da cadeia de caracteres para um código de erro numérico que vem de uma API Node.js. O mapeamento entre códigos de erro e nomes de erro depende da plataforma. Consulte Common System Errors para obter os nomes dos erros comuns.

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

Devoluções

Devolve o intervalo de tempo entre duas datas em milissegundos

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

Parâmetros

Devoluções

O uso de util.inherits() é desencorajado. Use o class ES6 e extends palavras-chave para obter suporte à herança no nível de idioma. Observe também que os dois estilos são semanticamente incompatíveis.

Herdar os métodos prototype de um construtor para outro. O protótipo do constructor será definido para um novo objeto criado a partir de superConstructor.

Isso adiciona principalmente alguma validação de entrada em cima deObject.setPrototypeOf(constructor.prototype, superConstructor.prototype). Como comodidade adicional, superConstructor será acessível através da propriedade 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!"

Exemplo ES6 usando class e extends:

const EventEmitter = require('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

O método util.inspect() retorna uma representação de cadeia de caracteres de object que se destina à depuração. A saída de util.inspect pode mudar a qualquer momento e não deve ser dependente programaticamente. Podem ser passados options adicionais que alterem o resultado. util.inspect() usará o nome do construtor e/ou @@toStringTag para criar uma tag identificável para um valor inspecionado.

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

As referências circulares apontam para a sua âncora utilizando um índice de referência:

const { inspect } = require('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] }
// }

O exemplo a seguir inspeciona todas as propriedades do objeto util:

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

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

O exemplo a seguir destaca o efeito da opção compact:

const util = require('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(util.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(util.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.

A opção showHidden permite que WeakMap e WeakSet entradas sejam inspecionadas. Se houver mais entradas do que maxArrayLength, não há garantia de quais entradas serão exibidas. Isso significa que recuperar as mesmas entradas WeakSet duas vezes pode resultar em saídas diferentes. Além disso, as entradas sem referências fortes restantes podem ser recolhidas a qualquer momento.

const { inspect } = require('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 } }

A opção sorted garante que a ordem de inserção de propriedade de um objeto não afete o resultado de util.inspect().

const { inspect } = require('node:util');
const assert = require('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 }),
);

A opção numericSeparator adiciona um sublinhado a cada três dígitos a todos os números.

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

const thousand = 1_000;
const million = 1_000_000;
const bigNumber = 123_456_789n;
const bigDecimal = 1_234.123_45;

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() é um método síncrono destinado à depuração. Seu comprimento máximo de saída é de aproximadamente 128 MiB. As entradas que resultam em saídas mais longas serão truncadas.

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

Parâmetros

Devoluções

A representação de object.

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

Parâmetros

Devoluções

Alias para Array.isArray().

Retorna true se o object dado for um Array. Caso contrário, retorna false.

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

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

function isArray(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for um Boolean. Caso contrário, retorna false.

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

util.isBoolean(1);
// Returns: false
util.isBoolean(0);
// Returns: false
util.isBoolean(false);
// Returns: true

function isBoolean(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for um Buffer. Caso contrário, retorna false.

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

util.isBuffer({ length: 0 });
// Returns: false
util.isBuffer([]);
// Returns: false
util.isBuffer(Buffer.from('hello world'));
// Returns: true

function isBuffer(object: unknown): object

Parâmetros

Devoluções

Verifica se o tipo de incorporação é para criar

function isCreate(embedType: string): boolean

Parâmetros

Devoluções

Retorna true se o object dado for um Date. Caso contrário, retorna false.

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

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

function isDate(object: unknown): object

Parâmetros

Devoluções

Retorna true se houver uma profunda igualdade estrita entre val1 e val2. Caso contrário, retorna false.

Consulte assert.deepStrictEqual() para obter mais informações sobre a igualdade estrita profunda.

function isDeepStrictEqual(val1: unknown, val2: unknown): boolean

Parâmetros

Devoluções

Retorna true se o object dado for um Error. Caso contrário, retorna false.

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

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

Este método baseia-se no comportamento Object.prototype.toString(). É possível obter um resultado incorreto quando o argumento object manipula @@toStringTag.

const util = require('node:util');
const obj = { name: 'Error', message: 'an error occurred' };

util.isError(obj);
// Returns: false
obj[Symbol.toStringTag] = 'Error';
util.isError(obj);
// Returns: true

function isError(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for um Function. Caso contrário, retorna false.

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

function Foo() {}
const Bar = () => {};

util.isFunction({});
// Returns: false
util.isFunction(Foo);
// Returns: true
util.isFunction(Bar);
// Returns: true

function isFunction(object: unknown): boolean

Parâmetros

Devoluções

Retorna true se o object dado for estritamente null. Caso contrário, retornafalse.

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

util.isNull(0);
// Returns: false
util.isNull(undefined);
// Returns: false
util.isNull(null);
// Returns: true

function isNull(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object fornecido for null ou undefined. Caso contrário, retorna false.

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

util.isNullOrUndefined(0);
// Returns: false
util.isNullOrUndefined(undefined);
// Returns: true
util.isNullOrUndefined(null);
// Returns: true

function isNullOrUndefined(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for um Number. Caso contrário, retorna false.

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

util.isNumber(false);
// Returns: false
util.isNumber(Infinity);
// Returns: true
util.isNumber(0);
// Returns: true
util.isNumber(NaN);
// Returns: true

function isNumber(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for estritamente um Objecte não umFunction (mesmo que as funções sejam objetos em JavaScript). Caso contrário, retorna false.

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

util.isObject(5);
// Returns: false
util.isObject(null);
// Returns: false
util.isObject({});
// Returns: true
util.isObject(() => {});
// Returns: false

function isObject(object: unknown): boolean

Parâmetros

Devoluções

Retorna true se o object dado for um tipo primitivo. Caso contrário, retornafalse.

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

util.isPrimitive(5);
// Returns: true
util.isPrimitive('foo');
// Returns: true
util.isPrimitive(false);
// Returns: true
util.isPrimitive(null);
// Returns: true
util.isPrimitive(undefined);
// Returns: true
util.isPrimitive({});
// Returns: false
util.isPrimitive(() => {});
// Returns: false
util.isPrimitive(/^$/);
// Returns: false
util.isPrimitive(new Date());
// Returns: false

function isPrimitive(object: unknown): boolean

Parâmetros

Devoluções

Verifica se a url de incorporação é para relatório RDL.

function isRDLEmbed(embedUrl: string): boolean

Parâmetros

Devoluções

Retorna true se o object dado for um RegExp. Caso contrário, retorna false.

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

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

function isRegExp(object: unknown): object

Parâmetros

Devoluções

Verifica se o relatório está salvo.

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

Parâmetros

Devoluções

Retorna true se o object dado for um string. Caso contrário, retorna false.

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

util.isString('');
// Returns: true
util.isString('foo');
// Returns: true
util.isString(String('foo'));
// Returns: true
util.isString(5);
// Returns: false

function isString(object: unknown): object

Parâmetros

Devoluções

Retorna true se o object dado for um Symbol. Caso contrário, retorna false.

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

util.isSymbol(5);
// Returns: false
util.isSymbol('foo');
// Returns: false
util.isSymbol(Symbol('foo'));
// Returns: true

function isSymbol(object: unknown): object

Parâmetros

Devoluções

Devolve true se a object dada for undefined. Caso contrário, retorna false.

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

const foo = undefined;
util.isUndefined(5);
// Returns: false
util.isUndefined(foo);
// Returns: true
util.isUndefined(null);
// Returns: false

function isUndefined(object: unknown): object

Parâmetros

Devoluções

O método util.log() imprime a string dada para stdout com um carimbo de data/hora incluído.

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

util.log('Timestamped message.');

function log(string: string)

Parâmetros

Fornece uma API de nível mais alto para análise de argumentos de linha de comando do que interagir com process.argv diretamente. Usa uma especificação para os argumentos esperados e retorna um objeto estruturado com as opções analisadas e posicionais.

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

Devoluções

Os argumentos de linha de comando analisados:

Estabilidade: 1.1 - Desenvolvimento ativo Dado um exemplo .env arquivo:

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

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

function parseEnv(content: string): object

Parâmetros

Devoluções

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

Parâmetros

Devoluções

function promisify(fn: Function): Function

Parâmetros

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Devoluções

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

Parâmetros

Devoluções

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

Parâmetros

Devoluções

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

Parâmetros

Devoluções

Usa uma função seguindo o estilo comum de retorno de chamada error-first, ou seja, tomando um retorno de chamada (err, value) => ... como o último argumento, e retorna uma versão que retorna promessas.

const util = require('node:util');
const fs = require('node:fs');

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

Ou, equivalentemente usando async functions:

const util = require('node:util');
const fs = require('node:fs');

const stat = util.promisify(fs.stat);

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

callStat();

Se houver uma propriedade original[util.promisify.custom] presente, promisify retornará seu valor, consulte Custom promisified functions.

promisify() assume que original é uma função que toma um retorno de chamada como seu argumento final em todos os casos. Se original não for uma função, promisify() lançará um erro. Se original for uma função, mas seu último argumento não for um retorno de chamada error-first, ele ainda será passado um error-first callback como seu último argumento.

O uso de promisify() em métodos de classe ou outros métodos que usam this pode não funcionar como esperado, a menos que seja manipulado especialmente:

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

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

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

const foo = new Foo();

const naiveBar = util.promisify(foo.bar);
// TypeError: Cannot read property 'a' of undefined
// 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

Devoluções

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

Parâmetros

Devoluções

Gera um evento personalizado com dados de evento no elemento HTML especificado.

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

Parâmetros

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

Parâmetros

Retorna str com quaisquer códigos de escape ANSI removidos.

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

function stripVTControlCharacters(str: string): string

Parâmetros

Devoluções

Estabilidade: 1.1 - Desenvolvimento ativo

Esta função retorna um texto formatado considerando o format passado.

const { styleText } = require('node:util');
const errorMessage = styleText('red', 'Error! Error!');
console.log(errorMessage);

util.inspect.colors também fornece formatos de texto como italice underline e você pode combinar ambos:

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

Ao passar uma matriz de formatos, a ordem do formato aplicado é da esquerda para a direita, de modo que o estilo a seguir pode substituir o anterior.

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

A lista completa de formatos pode ser encontrada em modificadores.

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

Parâmetros

Devoluções

Retorna o string depois de substituir quaisquer pontos de código substituto (ou equivalentemente, quaisquer unidades de código substituto não emparelhadas) pelo "caractere de substituição" Unicode U+FFFD.

function toUSVString(string: string): string

Parâmetros

Devoluções

Cria e retorna uma instância AbortController cujo AbortSignal está marcado como transferível e pode ser usado com structuredClone() ou postMessage().

function transferableAbortController(): AbortController

Devoluções

Um AbortController transferível

Marca o AbortSignal dado como transferível para que possa ser usado comstructuredClone() e postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parâmetros

Devoluções

O mesmo AbortSignal