Compartilhar via

util module

Pacote:
powerbi-client

O módulo node:util dá suporte às necessidades de APIs internas Node.js. Muitos dos utilitários também são úteis para desenvolvedores de aplicativos e módulos. Para acessá-lo:

import util from 'node:util';

Consulte de origem

Classes

MIMEParams

A API MIMEParams fornece acesso de leitura e gravação aos parâmetros de um MIMEType.
MIMEType

Uma implementação de a classe MIMEType.

De acordo com as convenções do navegador, todas as propriedades de objetos MIMEType são implementadas como getters e setters no protótipo de classe, em vez de como propriedades de dados no próprio objeto.

Uma cadeia de caracteres MIME é uma cadeia de caracteres estruturada que contém vários componentes significativos. Quando analisado, um objeto MIMEType é retornado contendo propriedades para cada um desses componentes.
TextDecoder

Uma implementação da API de Padrão de Codificação do WHATWG.

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

Uma implementação da API de Padrão de Codificação do WHATWG. Todas as instâncias de TextEncoder dão suporte apenas à codificação UTF-8.

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

A classe TextEncoder também está disponível no objeto global.

Interfaces

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

Aliases de tipo

CustomInspectFunction
CustomPromisify
DebugLoggerFunction
DiffEntry
ParseArgsOptionsType

Tipo de argumento usado em parseArgs.
Style

Funções

aborted(AbortSignal, any)

Escuta o evento de anulação no signal fornecido e retorna uma promessa que é resolvida quando a signal é anulada. Se resource for fornecido, ele fará referência fraca ao objeto associado da operação, portanto, se resource for o lixo coletado antes da anulação do signal, a promessa retornada permanecerá pendente. Isso evita vazamentos de memória em operações de execução prolongada ou não canceláveis.

import { aborted } from 'node:util';

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

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

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

Adiciona um parâmetro à url fornecida
assign(any[])

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.
autoAuthInEmbedUrl(string)

Verifica se a URL de inserção contém autoAuth=true.
callbackify(() => Promise<void>)

Usa uma função async (ou uma função que retorna um Promise) e retorna uma função após o estilo de retorno de chamada de primeiro erro, 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.

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

O retorno de chamada é executado de forma assíncrona e terá um rastreamento de pilha limitado. Se o retorno de chamada for gerado, o processo emitirá um evento 'uncaughtException' e, se não for tratado, 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 falsificado como um 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
});
callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>)
callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>)
callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>)
callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>)
callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>)
callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>)
callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>)
callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>)
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
callbackify<T1>((arg1: T1) => Promise<void>)
callbackify<TResult>(() => Promise<TResult>)
createRandomString()

Gera uma cadeia de caracteres aleatória de 5 a 6 caracteres.
debuglog(string, (fn: DebugLoggerFunction) => void)

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

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

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

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

FOO 3245: hello from foo [123]

onde 3245 é a ID do processo. Se não for executado com esse conjunto de variáveis de ambiente, ele não imprimirá nada.

O section também dá suporte a curinga:

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

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

se 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 separados por vírgulas section podem ser especificados na variável de NODE_DEBUG ambiente: NODE_DEBUG=fs,net,tls.

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

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

O método util.deprecate() encapsula fn (que pode ser uma função ou classe) de modo que ele seja marcado como preterido.

import { deprecate } from 'node:util';

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

Quando chamado, util.deprecate() retornará uma função que emitirá uma DeprecationWarning usando o evento 'warning'. O aviso será emitido e impresso para stderr a primeira vez que a função retornada for chamada. Depois que o aviso é emitido, a função encapsulada é 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.

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

Se os sinalizadores de linha de comando --no-deprecation ou --no-warnings forem usados ou se a propriedade process.noDeprecation estiver definida como trueanterior ao primeiro aviso de substituiçã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 a 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á gerada 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.
diff(string | (readonly string[]), string | (readonly string[]))

util.diff() compara dois valores de cadeia de caracteres ou matriz e retorna uma matriz de entradas de diferença. Ele usa o algoritmo de diferenciação myers para calcular diferenças mínimas, que é o mesmo algoritmo usado internamente por mensagens de erro de declaração.

Se os valores forem iguais, uma matriz vazia será retornada.

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

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

Localiza o primeiro valor em uma matriz que corresponde ao predicado especificado.
findIndex<T>((x: T) => boolean, T[])

Localiza o índice do primeiro valor em uma matriz que corresponde ao predicado especificado.
format(any, any[])

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 com suporte 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 o 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 para a cadeia de caracteres retornada, separada 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 nenhuma formatação:

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

util.format() é um método síncrono que se destina a uma ferramenta de depuração. Alguns valores de entrada podem ter uma sobrecarga de desempenho significativa que pode bloquear o loop de eventos. Use essa função com cuidado e nunca em um caminho de código frequente.
formatWithOptions(InspectOptions, any, any[])

Essa função é idêntica ade formato de , exceto por usar um argumento que especifica as opções 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.
generateUUID()

Gera um uuid de 20 caracteres.
getCallSites(GetCallSitesOptions)
getCallSites(number, GetCallSitesOptions)

Retorna uma matriz de objetos de site de chamada que contém a pilha da função de chamador.

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

É possível reconstruir os locais originais definindo a opção sourceMap como true. Se o mapa de origem não estiver disponível, o local original será o mesmo que o local atual. Quando o sinalizador de --enable-source-maps estiver habilitado, por exemplo, ao usar --experimental-transform-types, sourceMap será verdadeiro por padrão.

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

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

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

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

Retorna número aleatório
getSystemErrorMap()

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

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

Retorna a mensagem de cadeia de caracteres para um código de erro numérico proveniente de uma API de Node.js. O mapeamento entre códigos de erro e mensagens de cadeia de caracteres depende da plataforma.

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

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

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

Retorna o intervalo de tempo entre duas datas em milissegundos
inherits(unknown, unknown)

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

Herda os métodos de protótipo de um construtor em outro. O protótipo de constructor será definido como um novo objeto criado a partir de superConstructor.

Isso adiciona principalmente alguma validação de entrada em cima de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Como conveniência adicional, superConstructor estarão acessíveis por meio 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 de ES6 usando class e extends:

import EventEmitter from 'node:events';

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

const stream = new MyStream();

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

O método util.inspect() retorna uma representação de cadeia de caracteres de object destinada à depuração. A saída de util.inspect pode ser alterada a qualquer momento e não deve depender programaticamente. Podem ser passadas options adicionais que alteram o resultado. util.inspect() usará o nome do construtor e/ou Symbol.toStringTag a propriedade para criar uma marca 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] {}'

Referências circulares apontam para a âncora usando um índice de referência:

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

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

import util from 'node:util';

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

O exemplo a seguir realça o efeito da opção 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.

A opção showHidden permite que entradas WeakMap e WeakSet sejam inspecionadas. Se houver mais entradas do que maxArrayLength, não haverá garantia de quais entradas serão exibidas. Isso significa que recuperar as mesmas entradas de WeakSet duas vezes pode resultar em uma saída diferente. Além disso, entradas sem referências fortes restantes podem ser coletadas a qualquer 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 } }

A opção sorted garante que a ordem de inserção de propriedade de um objeto não afete o 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 }),
);

A opção numericSeparator adiciona um sublinhado a cada três dígitos a todos os 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() é 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ída mais longa serão truncadas.
inspect(any, InspectOptions)
isArray(unknown)

Alias para Array.isArray().

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

import util from 'node:util';

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

Verifica se o tipo de inserção é para criar
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

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

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

Verifica se a URL de inserção é para o relatório RDL.
isSavedInternal(HttpPostMessage, string, Window)

Verifica se o relatório foi salvo.
parseArgs<T>(T)

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

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

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

import { parseEnv } from 'node:util';

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

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

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, equivalentemente, usando 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();

Se houver uma original[util.promisify.custom] propriedade presente, promisify retornará seu valor, consulte Funções promisificadas personalizadas.

promisify() pressupõe que original é uma função que recebe um retorno de chamada como seu argumento final em todos os casos. Se original não for uma função, promisify() gerará um erro. Se original for uma função, mas seu último argumento não for um retorno de chamada de primeiro erro, ele ainda será passado um retorno de chamada de primeiro erro como seu último argumento.

Usar promisify() em métodos de classe ou outros métodos que usam this pode não funcionar conforme o esperado, a menos que seja tratado 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'
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
raiseCustomEvent(HTMLElement, string, any)

Gera um evento personalizado com dados de evento no elemento HTML especificado.
remove<T>((x: T) => boolean, T[])
setTraceSigInt(boolean)

Habilitar ou desabilitar a impressão de um rastreamento de pilha.SIGINT A API só está disponível no thread principal.
stripVTControlCharacters(string)

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

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

Essa função retorna um texto formatado considerando o format passado para impressão em um terminal. Ele está ciente dos recursos do terminal e atua de acordo com o conjunto de configurações por meio NO_COLORNODE_DISABLE_COLORS de variáveis de ambiente e FORCE_COLOR de ambiente.

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 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 para que o estilo a seguir possa substituir o anterior.

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

O valor none de formato especial não aplica nenhum estilo adicional ao texto.

A lista completa de formatos pode ser encontrada em modificadores .
toUSVString(string)

Retorna o string depois de substituir quaisquer pontos de código alternativos (ou equivalentemente, quaisquer unidades de código alternativo não pagas) pelo "caractere de substituição" U+FFFD unicode.
transferableAbortController()

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

Marca a AbortSignal fornecida como transferível para que possa ser usada comstructuredClone() e postMessage().

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

Detalhes da função

aborted(AbortSignal, any)

Escuta o evento de anulação no signal fornecido e retorna uma promessa que é resolvida quando a signal é anulada. Se resource for fornecido, ele fará referência fraca ao objeto associado da operação, portanto, se resource for o lixo coletado antes da anulação do signal, a promessa retornada permanecerá pendente. Isso evita vazamentos de memória em operações de execução prolongada ou não canceláveis.

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

signal

AbortSignal

resource

any

Qualquer objeto não nulo vinculado à operação anulável e mantido fracamente. Se resource for coletado antes da signal anular, a promessa permanecerá pendente, permitindo que Node.js pare de rastreá-la. Isso ajuda a evitar vazamentos de memória em operações de execução prolongada ou não canceláveis.

Retornos

Promise<void>

addParamToUrl(string, string, string)

Adiciona um parâmetro à url fornecida

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

Parâmetros

url

string

paramName

string

value

string

Retornos

string

assign(any[])

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

args

any[]

Retornos

any

autoAuthInEmbedUrl(string)

Verifica se a URL de inserção contém autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parâmetros

embedUrl

string

Retornos

boolean

callbackify(() => Promise<void>)

Usa uma função async (ou uma função que retorna um Promise) e retorna uma função após o estilo de retorno de chamada de primeiro erro, 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.

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

O retorno de chamada é executado de forma assíncrona e terá um rastreamento de pilha limitado. Se o retorno de chamada for gerado, o processo emitirá um evento 'uncaughtException' e, se não for tratado, 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 falsificado como um 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

fn

() => Promise<void>

Uma função async

Retornos

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

uma função de estilo de retorno de chamada

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

(arg1: T1) => Promise<TResult>

Retornos

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

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

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

Parâmetros

fn

(arg1: T1) => Promise<void>

Retornos

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

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

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

Parâmetros

fn

() => Promise<TResult>

Retornos

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

createRandomString()

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

function createRandomString(): string

Retornos

string

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

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

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

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

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

FOO 3245: hello from foo [123]

onde 3245 é a ID do processo. Se não for executado com esse conjunto de variáveis de ambiente, ele não imprimirá nada.

O section também dá suporte a curinga:

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

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

se 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 separados por vírgulas section podem ser especificados na variável de NODE_DEBUG ambiente: NODE_DEBUG=fs,net,tls.

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

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

section

string

Uma cadeia de caracteres que identifica a parte do aplicativo para a qual a função debuglog está sendo criada.

callback

(fn: DebugLoggerFunction) => void

Um retorno de chamada invocado na primeira vez em que a função de registro em log é chamada com um argumento de função que é uma função de log mais otimizada.

Retornos

DebugLogger

A função de registro em log

deprecate<T>(T, string, string)

O método util.deprecate() encapsula fn (que pode ser uma função ou classe) de modo que ele seja marcado como preterido.

import { deprecate } from 'node:util';

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

Quando chamado, util.deprecate() retornará uma função que emitirá uma DeprecationWarning usando o evento 'warning'. O aviso será emitido e impresso para stderr a primeira vez que a função retornada for chamada. Depois que o aviso é emitido, a função encapsulada é 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.

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

Se os sinalizadores de linha de comando --no-deprecation ou --no-warnings forem usados ou se a propriedade process.noDeprecation estiver definida como trueanterior ao primeiro aviso de substituiçã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 a 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á gerada 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

fn

T

A função que está sendo preterida.

msg

string

Uma mensagem de aviso a ser exibida quando a função preterida for invocada.

code

string

Um código de substituição. Consulte o list of deprecated APIs para obter uma lista de códigos.

Retornos

T

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

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

util.diff() compara dois valores de cadeia de caracteres ou matriz e retorna uma matriz de entradas de diferença. Ele usa o algoritmo de diferenciação myers para calcular diferenças mínimas, que é o mesmo algoritmo usado internamente por mensagens de erro de declaração.

Se os valores forem iguais, uma matriz vazia será retornada.

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

actual

string | (readonly string[])

O primeiro valor a ser comparado

expected

string | (readonly string[])

O segundo valor a ser comparado

Retornos

DiffEntry[]

Uma matriz de entradas de diferença. Cada entrada é uma matriz com dois elementos:

  • Índice 0: number Código da operação: -1 para exclusão, 0 para no-op/inalterado, 1 para inserção
  • Índice 1: string o valor associado à operação

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

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

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

Parâmetros

predicate

(x: T) => boolean

xs

T[]

Retornos

T

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

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

predicate

(x: T) => boolean

xs

T[]

Retornos

number

format(any, any[])

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 com suporte 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 o 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 para a cadeia de caracteres retornada, separada 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 nenhuma formatação:

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

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

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

Parâmetros

format

any

Uma cadeia de caracteres de formato semelhante a printf.

param

any[]

Retornos

string

formatWithOptions(InspectOptions, any, any[])

Essa função é idêntica ade formato de , exceto por usar um argumento que especifica as opções 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

inspectOptions
InspectOptions
format

any

param

any[]

Retornos

string

generateUUID()

Gera um uuid de 20 caracteres.

function generateUUID(): string

Retornos

string

getCallSites(GetCallSitesOptions) 

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parâmetros

options

GetCallSitesOptions

Retornos

CallSiteObject[]

getCallSites(number, GetCallSitesOptions)

Retorna uma matriz de objetos de site de chamada que contém a pilha da função de chamador.

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

É possível reconstruir os locais originais definindo a opção sourceMap como true. Se o mapa de origem não estiver disponível, o local original será o mesmo que o local atual. Quando o sinalizador de --enable-source-maps estiver habilitado, por exemplo, ao usar --experimental-transform-types, sourceMap será verdadeiro por padrão.

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

frameCount

number

Número de quadros a serem capturados como objetos de site de chamada. Padrão:10. O intervalo permitido está entre 1 e 200.

options

GetCallSitesOptions

Retornos

CallSiteObject[]

Uma matriz de objetos de site de chamada

getRandomValue()

Retorna número aleatório

function getRandomValue(): number

Retornos

number

getSystemErrorMap()

Retorna um mapa de todos os códigos de erro do sistema disponíveis na API de Node.js. O mapeamento entre códigos de erro e nomes de erro depende da plataforma. Consulte Common System Errors para obter os nomes de 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]>

Retornos

Map<number, [string, string]>

getSystemErrorMessage(number)

Retorna a mensagem de cadeia de caracteres para um código de erro numérico proveniente de uma API de Node.js. O mapeamento entre códigos de erro e mensagens de cadeia de caracteres depende da 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

err

number

Retornos

string

getSystemErrorName(number)

Retorna o nome da cadeia de caracteres para um código de erro numérico proveniente de uma API de Node.js. O mapeamento entre códigos de erro e nomes de erro depende da plataforma. Consulte Common System Errors para obter os nomes de 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

err

number

Retornos

string

getTimeDiffInMilliseconds(Date, Date)

Retorna o intervalo de tempo entre duas datas em milissegundos

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

Parâmetros

start

Date

end

Date

Retornos

number

inherits(unknown, unknown)

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

Herda os métodos de protótipo de um construtor em outro. O protótipo de constructor será definido como um novo objeto criado a partir de superConstructor.

Isso adiciona principalmente alguma validação de entrada em cima de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Como conveniência adicional, superConstructor estarão acessíveis por meio 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 de ES6 usando class e 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

constructor

unknown

superConstructor

unknown

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

O método util.inspect() retorna uma representação de cadeia de caracteres de object destinada à depuração. A saída de util.inspect pode ser alterada a qualquer momento e não deve depender programaticamente. Podem ser passadas options adicionais que alteram o resultado. util.inspect() usará o nome do construtor e/ou Symbol.toStringTag a propriedade para criar uma marca 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] {}'

Referências circulares apontam para a âncora usando um índice de referência:

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

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

import util from 'node:util';

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

O exemplo a seguir realça o efeito da opção 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.

A opção showHidden permite que entradas WeakMap e WeakSet sejam inspecionadas. Se houver mais entradas do que maxArrayLength, não haverá garantia de quais entradas serão exibidas. Isso significa que recuperar as mesmas entradas de WeakSet duas vezes pode resultar em uma saída diferente. Além disso, entradas sem referências fortes restantes podem ser coletadas a qualquer 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 } }

A opção sorted garante que a ordem de inserção de propriedade de um objeto não afete o 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 }),
);

A opção numericSeparator adiciona um sublinhado a cada três dígitos a todos os 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() é 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ída mais longa serão truncadas.

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

Parâmetros

object

any

Qualquer primitivo JavaScript ou Object.

showHidden

boolean

depth

null | number

color

boolean

Retornos

string

A representação de object.

inspect(any, InspectOptions) 

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

Parâmetros

object

any

options
InspectOptions

Retornos

string

isArray(unknown)

Aviso

Essa API foi preterida.

Since v4.0.0 - Use isArray instead.

Alias para Array.isArray().

Retorna true se o object determinado for um Array. Caso contrário, retorna 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

object

unknown

Retornos

object

isCreate(string)

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

function isCreate(embedType: string): boolean

Parâmetros

embedType

string

Retornos

boolean

isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

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

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

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

Parâmetros

val1

unknown

val2

unknown

options
IsDeepStrictEqualOptions

Retornos

boolean

isRDLEmbed(string)

Verifica se a URL de inserção é para o relatório RDL.

function isRDLEmbed(embedUrl: string): boolean

Parâmetros

embedUrl

string

Retornos

boolean

isSavedInternal(HttpPostMessage, string, Window)

Verifica se o relatório foi salvo.

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

Parâmetros

hpm

HttpPostMessage

uid

string

contentWindow

Window

Retornos

Promise<boolean>

parseArgs<T>(T)

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

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

config

T

Usado para fornecer argumentos para análise e para configurar o analisador. config dá suporte às seguintes propriedades:

Retornos

ParsedResults<T>

Os argumentos de linha de comando analisados:

parseEnv(string)

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

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

content

string

O conteúdo bruto de um arquivo .env.

Retornos

NodeJS.Dict<string>

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

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

Parâmetros

fn

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

Retornos

() => Promise<void>

promisify(Function) 

function promisify(fn: Function): Function

Parâmetros

fn

Function

Retornos

Function

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

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

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

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

Parâmetros

fn

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

Retornos

(arg1: T1) => Promise<TResult>

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

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

Parâmetros

fn

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

Retornos

(arg1: T1) => Promise<void>

promisify<TCustom>(CustomPromisify<TCustom>)

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

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, equivalentemente, usando 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();

Se houver uma original[util.promisify.custom] propriedade presente, promisify retornará seu valor, consulte Funções promisificadas personalizadas.

promisify() pressupõe que original é uma função que recebe um retorno de chamada como seu argumento final em todos os casos. Se original não for uma função, promisify() gerará um erro. Se original for uma função, mas seu último argumento não for um retorno de chamada de primeiro erro, ele ainda será passado um retorno de chamada de primeiro erro como seu último argumento.

Usar promisify() em métodos de classe ou outros métodos que usam this pode não funcionar conforme o esperado, a menos que seja tratado 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

fn

CustomPromisify<TCustom>

Retornos

TCustom

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

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

Parâmetros

fn

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

Retornos

() => Promise<TResult>

raiseCustomEvent(HTMLElement, string, any)

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

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

Parâmetros

element

HTMLElement

eventName

string

eventData

any

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

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

Parâmetros

predicate

(x: T) => boolean

xs

T[]

setTraceSigInt(boolean)

Habilitar ou desabilitar a impressão de um rastreamento de pilha.SIGINT A API só está disponível no thread principal.

function setTraceSigInt(enable: boolean)

Parâmetros

enable

boolean

stripVTControlCharacters(string)

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

str

string

Retornos

string

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

Essa função retorna um texto formatado considerando o format passado para impressão em um terminal. Ele está ciente dos recursos do terminal e atua de acordo com o conjunto de configurações por meio NO_COLORNODE_DISABLE_COLORS de variáveis de ambiente e FORCE_COLOR de ambiente.

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 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 para que o estilo a seguir possa substituir o anterior.

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

O valor none de formato especial não aplica nenhum estilo adicional ao texto.

A lista completa de formatos pode ser encontrada em modificadores .

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

Parâmetros

format

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

Um formato de texto ou uma matriz de formatos de texto definido em util.inspect.colors.

text

string

O texto a ser formatado.

options
StyleTextOptions

Retornos

string

toUSVString(string)

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

function toUSVString(string: string): string

Parâmetros

string

string

Retornos

string

transferableAbortController()

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

Retornos

AbortController

Um AbortController transferível

transferableAbortSignal(AbortSignal)

Marca a AbortSignal fornecida como transferível para que possa ser usada 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

signal

AbortSignal

O AbortSignal

Retornos

AbortSignal

O mesmo AbortSignal