powerbi-client package
Classes
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Componente do construtor de filtros avançado do Power BI |
| BasicFilterBuilder |
Componente do construtor de filtros do Power BI Basic |
| BookmarksManager |
Gerencia indicadores de relatório. |
| Create |
Um componente do criador do Relatório do Power BI |
| Dashboard |
Um componente de inserção do Painel do Power BI |
| FilterBuilder |
Construtor de filtros genéricos para BasicFilter, AdvancedFilter, RelativeDate, RelativeTime e TopN |
| MIMEParams |
A API |
| MIMEType |
Uma implementação de a classe MIMEType. De acordo com as convenções do navegador, todas as propriedades de objetos Uma cadeia de caracteres MIME é uma cadeia de caracteres estruturada que contém vários componentes significativos. Quando analisado, um objeto |
| Page |
Uma página de relatório do Power BI |
| Qna |
O componente de inserção do Power BI Q&A |
| QuickCreate |
Um componente de Criação Rápida do Power BI |
| RelativeDateFilterBuilder |
Componente do construtor de filtros data relativa do Power BI |
| RelativeTimeFilterBuilder |
Componente do construtor de filtros de Tempo Relativo do Power BI |
| Report |
O componente de inserção de Relatório do Power BI |
| Service |
O componente de inserção do Serviço do Power BI, que é o ponto de entrada para inserir todos os outros componentes do Power BI em seu aplicativo |
| Tile |
O componente de inserção de bloco do Power BI |
| TopNFilterBuilder |
Componente do construtor de filtros Top N do Power BI |
| Visual |
O componente de inserção do Visual do Power BI |
| VisualDescriptor |
Um visual do Power BI em uma página |
Interfaces
Aliases de tipo
Enumerações
Funções
| is |
Retorna Consulte também |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna Por exemplo: |
| is |
Retorna |
| is |
Retorna Consulte também |
| is |
Retorna |
| is |
Retorna Um valor de Para obter mais informações sobre |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna Subclasses dos tipos de erro nativos também são erros nativos: Um valor que está sendo Por outro lado, |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna Consulte também |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| is |
Retorna |
| inspect(any, boolean, number | null, boolean) | O método Referências circulares apontam para a âncora usando um índice de referência: O exemplo a seguir inspeciona todas as propriedades do objeto O exemplo a seguir realça o efeito da opção A opção A opção A opção
|
| promisify<TCustom>(Custom |
Usa uma função seguindo o estilo comum de retorno de chamada de primeiro erro, ou seja, tomando um retorno de chamada Ou, equivalentemente, usando Se houver uma
Usar |
| aborted(Abort |
Escuta o evento de anulação no |
| add |
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. |
| auto |
Verifica se a URL de inserção contém autoAuth=true. |
| callbackify(() => Promise<void>) | Usa uma função Imprimirá: 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 Como |
| callbackify<TResult>(() => Promise<TResult>) | |
| callbackify<T1>((arg1: T1) => Promise<void>) | |
| callbackify<T1, TResult>((arg1: T1) => Promise<TResult>) | |
| callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>) | |
| callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>) | |
| callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>) | |
| callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>) | |
| callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>) | |
| callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => 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, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => 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, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>) | |
| convert |
O Se Isso é particularmente útil ao trabalhar com processos para determinar o código de saída com base no sinal que encerrou o processo. |
| create |
Gera uma cadeia de caracteres aleatória de 5 a 6 caracteres. |
| debuglog(string, (fn: Debug |
O Se este programa for executado com onde O se for executado com Vários nomes separados por vírgulas O argumento |
| deprecate<T>(T, string, string, Deprecate |
O método Quando chamado, Se o mesmo Se os sinalizadores de linha de comando Se os sinalizadores de linha de comando Se o sinalizador de linha de comando O sinalizador de linha de comando |
| diff(string | (readonly string[]), string | (readonly string[])) |
Se os valores forem iguais, uma matriz vazia será retornada. |
| find<T>((x: T) => boolean, T[]) | Localiza o primeiro valor em uma matriz que corresponde ao predicado especificado. |
| find |
Localiza o índice do primeiro valor em uma matriz que corresponde ao predicado especificado. |
| format(any, any[]) | O método Se um especificador não tiver um argumento correspondente, ele não será substituído: Os valores que não fazem parte da cadeia de caracteres de formato são formatados usando Se houver mais argumentos passados para o método Se o primeiro argumento não contiver um especificador de formato válido, Se apenas um argumento for passado para
|
| format |
Essa função é idêntica ade formato de |
| generateUUID() | Gera um uuid de 20 caracteres. |
| get |
Retorna uma matriz de objetos de site de chamada que contém a pilha da função de chamador. Ao contrário de acessar um É possível reconstruir os locais originais definindo a opção |
| get |
|
| get |
Retorna número aleatório |
| get |
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 |
| get |
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. |
| get |
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 |
| get |
Retorna o intervalo de tempo entre duas datas em milissegundos |
| inherits(unknown, unknown) | O uso de Herda os métodos de protótipo de um construtor em outro. O protótipo de Isso adiciona principalmente alguma validação de entrada em cima de Exemplo de ES6 usando |
| inspect(any, Inspect |
|
| is |
Alias para Retorna |
| is |
Verifica se o tipo de inserção é para criar |
| is |
Retorna Consulte |
| is |
Verifica se a URL de inserção é para o relatório RDL. |
| is |
Verifica se o relatório foi salvo. |
| parse |
Fornece uma API de nível mais alto para análise de argumentos de linha de comando do que interagir diretamente com |
| parse |
Estabilidade: 1.1 – Desenvolvimento ativo Dado um exemplo |
| promisify<TResult>((callback: (err: any, result: TResult) => void) => void) | |
| promisify((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<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, 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, 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, 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(Function) | |
| raise |
Gera um evento personalizado com dados de evento no elemento HTML especificado. |
| remove<T>((x: T) => boolean, T[]) | |
| set |
Habilitar ou desabilitar a impressão de um rastreamento de pilha. |
| strip |
Retorna |
| style |
Essa função retorna um texto formatado considerando o
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. O valor Além de nomes de cores predefinidos, A lista completa de formatos pode ser encontrada em modificadores . |
| to |
Retorna o |
| transferable |
Cria e retorna uma instância |
| transferable |
Marca a |
Variáveis
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
Detalhes da função
isAnyArrayBuffer(unknown)
Retorna true se o valor for uma instância interna de ArrayBuffer ou SharedArrayBuffer.
Consulte também util.types.isArrayBuffer() e util.types.isSharedArrayBuffer().
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLikeParâmetros
- object
-
unknown
Retornos
object is ArrayBufferLike
isArgumentsObject(unknown)
Retorna true se o valor for um objeto arguments.
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArgumentsParâmetros
- object
-
unknown
Retornos
object is IArguments
isArrayBuffer(unknown)
Retorna true se o valor for uma instância de ArrayBuffer interna.
Isso não incluir instâncias de SharedArrayBuffer. Normalmente, é desejável testar para ambos; Veja util.types.isAnyArrayBuffer() para isso.
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBufferParâmetros
- object
-
unknown
Retornos
object is ArrayBuffer
isArrayBufferView(unknown)
Retorna true se o valor for uma instância de uma das exibições de ArrayBuffer, como objetos de matriz digitado ou DataView. Equivalente a ArrayBuffer.isView().
util.types.isArrayBufferView(new Int8Array()); // true
util.types.isArrayBufferView(Buffer.from('hello world')); // true
util.types.isArrayBufferView(new DataView(new ArrayBuffer(16))); // true
util.types.isArrayBufferView(new ArrayBuffer()); // false
function isArrayBufferView(object: unknown): object is ArrayBufferViewParâmetros
- object
-
unknown
Retornos
object is ArrayBufferView
isAsyncFunction(unknown)
Retorna true se o valor for uma função assíncrona .
Isso só relata o que o mecanismo JavaScript está vendo; em particular, o valor retornado poderá não corresponder ao código-fonte original se uma ferramenta de transpilação tiver sido usada.
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): booleanParâmetros
- object
-
unknown
Retornos
boolean
isBigInt64Array(unknown)
Retorna true se o valor for uma instância BigInt64Array.
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64ArrayParâmetros
- value
-
unknown
Retornos
value is BigInt64Array
isBigIntObject(unknown)
Retorna true se o valor for um objeto BigInt, por exemplo, criado por Object(BigInt(123)).
util.types.isBigIntObject(Object(BigInt(123))); // Returns true
util.types.isBigIntObject(BigInt(123)); // Returns false
util.types.isBigIntObject(123); // Returns false
function isBigIntObject(object: unknown): object is BigIntParâmetros
- object
-
unknown
Retornos
object is BigInt
isBigUint64Array(unknown)
Retorna true se o valor for uma instância BigUint64Array.
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64ArrayParâmetros
- value
-
unknown
Retornos
value is BigUint64Array
isBooleanObject(unknown)
Retorna true se o valor for um objeto booliano, por exemplo, criado por new Boolean().
util.types.isBooleanObject(false); // Returns false
util.types.isBooleanObject(true); // Returns false
util.types.isBooleanObject(new Boolean(false)); // Returns true
util.types.isBooleanObject(new Boolean(true)); // Returns true
util.types.isBooleanObject(Boolean(false)); // Returns false
util.types.isBooleanObject(Boolean(true)); // Returns false
function isBooleanObject(object: unknown): object is BooleanParâmetros
- object
-
unknown
Retornos
object is Boolean
isBoxedPrimitive(unknown)
Retorna true se o valor for qualquer objeto primitivo em caixa, por exemplo, criado por new Boolean(), new String() ou Object(Symbol()).
Por exemplo:
util.types.isBoxedPrimitive(false); // Returns false
util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true
function isBoxedPrimitive(object: unknown): object is String | Number | Boolean | Symbol | BigIntParâmetros
- object
-
unknown
Retornos
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
Retorna true se value for um CryptoKey, false caso contrário.
function isCryptoKey(object: unknown): object is CryptoKeyParâmetros
- object
-
unknown
Retornos
object is CryptoKey
isDataView(unknown)
Retorna true se o valor for uma instância de DataView interna.
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
Consulte também ArrayBuffer.isView().
function isDataView(object: unknown): object is DataViewParâmetros
- object
-
unknown
Retornos
object is DataView
isDate(unknown)
Retorna true se o valor for uma instância de Date interna.
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is DateParâmetros
- object
-
unknown
Retornos
object is Date
isExternal(unknown)
Retorna true se o valor for um valor de External nativo.
Um valor de External nativo é um tipo especial de objeto que contém um ponteiro C++ bruto (void*) para acesso do código nativo e não tem outras propriedades. Esses objetos são criados por Node.js suplementos internos ou nativos. Em JavaScript, eles são objetos congelados com um null protótipo.
#include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(napi_env env, napi_callback_info info) {
int* raw = (int*) malloc(1024);
napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
if (status != napi_ok) {
napi_throw_error(env, NULL, "napi_create_external failed");
return NULL;
}
return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...
import native from 'napi_addon.node';
import { types } from 'node:util';
const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false
Para obter mais informações sobre napi_create_external, consulte napi_create_external().
function isExternal(object: unknown): booleanParâmetros
- object
-
unknown
Retornos
boolean
isFloat16Array(unknown)
Retorna true se o valor for uma instância de Float16Array interna.
util.types.isFloat16Array(new ArrayBuffer()); // Returns false
util.types.isFloat16Array(new Float16Array()); // Returns true
util.types.isFloat16Array(new Float32Array()); // Returns false
function isFloat16Array(object: unknown): object is Float16ArrayParâmetros
- object
-
unknown
Retornos
object is Float16Array
isFloat32Array(unknown)
Retorna true se o valor for uma instância de Float32Array interna.
util.types.isFloat32Array(new ArrayBuffer()); // Returns false
util.types.isFloat32Array(new Float32Array()); // Returns true
util.types.isFloat32Array(new Float64Array()); // Returns false
function isFloat32Array(object: unknown): object is Float32ArrayParâmetros
- object
-
unknown
Retornos
object is Float32Array
isFloat64Array(unknown)
Retorna true se o valor for uma instância de Float64Array interna.
util.types.isFloat64Array(new ArrayBuffer()); // Returns false
util.types.isFloat64Array(new Uint8Array()); // Returns false
util.types.isFloat64Array(new Float64Array()); // Returns true
function isFloat64Array(object: unknown): object is Float64ArrayParâmetros
- object
-
unknown
Retornos
object is Float64Array
isGeneratorFunction(unknown)
Retorna true se o valor for uma função geradora.
Isso só relata o que o mecanismo JavaScript está vendo; em particular, o valor retornado poderá não corresponder ao código-fonte original se uma ferramenta de transpilação tiver sido usada.
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunctionParâmetros
- object
-
unknown
Retornos
object is GeneratorFunction
isGeneratorObject(unknown)
Retorna true se o valor for um objeto gerador conforme retornado de uma função de gerador interna.
Isso só relata o que o mecanismo JavaScript está vendo; em particular, o valor retornado poderá não corresponder ao código-fonte original se uma ferramenta de transpilação tiver sido usada.
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is GeneratorParâmetros
- object
-
unknown
Retornos
object is Generator
isInt16Array(unknown)
Retorna true se o valor for uma instância de Int16Array interna.
util.types.isInt16Array(new ArrayBuffer()); // Returns false
util.types.isInt16Array(new Int16Array()); // Returns true
util.types.isInt16Array(new Float64Array()); // Returns false
function isInt16Array(object: unknown): object is Int16ArrayParâmetros
- object
-
unknown
Retornos
object is Int16Array
isInt32Array(unknown)
Retorna true se o valor for uma instância de Int32Array interna.
util.types.isInt32Array(new ArrayBuffer()); // Returns false
util.types.isInt32Array(new Int32Array()); // Returns true
util.types.isInt32Array(new Float64Array()); // Returns false
function isInt32Array(object: unknown): object is Int32ArrayParâmetros
- object
-
unknown
Retornos
object is Int32Array
isInt8Array(unknown)
Retorna true se o valor for uma instância de Int8Array interna.
util.types.isInt8Array(new ArrayBuffer()); // Returns false
util.types.isInt8Array(new Int8Array()); // Returns true
util.types.isInt8Array(new Float64Array()); // Returns false
function isInt8Array(object: unknown): object is Int8ArrayParâmetros
- object
-
unknown
Retornos
object is Int8Array
isKeyObject(unknown)
Retorna true se value for um KeyObject, false caso contrário.
function isKeyObject(object: unknown): object is KeyObjectParâmetros
- object
-
unknown
Retornos
object is KeyObject
isMap<T>({} | T)
Retorna true se o valor for uma instância de Map interna.
util.types.isMap(new Map()); // Returns true
function isMap<T>(object: {} | T): object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)Parâmetros
- object
-
{} | T
Retornos
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
Retorna true se o valor for um iterador retornado para uma instância de Map interna.
const map = new Map();
util.types.isMapIterator(map.keys()); // Returns true
util.types.isMapIterator(map.values()); // Returns true
util.types.isMapIterator(map.entries()); // Returns true
util.types.isMapIterator(map[Symbol.iterator]()); // Returns true
function isMapIterator(object: unknown): booleanParâmetros
- object
-
unknown
Retornos
boolean
isModuleNamespaceObject(unknown)
isNativeError(unknown)
Aviso
Essa API foi preterida.
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
Retorna true se o valor foi retornado pelo construtor de um tipo de Errorinterno.
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // true
Subclasses dos tipos de erro nativos também são erros nativos:
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
Um valor que está sendo instanceof uma classe de erro nativa não é equivalente a isNativeError() retornando true para esse valor.
import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false
Por outro lado, isNativeError() retorna false para todos os objetos que não foram retornados pelo construtor de um erro nativo. Isso inclui valores que são instanceof erros nativos:
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
function isNativeError(object: unknown): object is ErrorParâmetros
- object
-
unknown
Retornos
object is Error
isNumberObject(unknown)
Retorna true se o valor for um objeto numérico, por exemplo, criado por new Number().
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is NumberParâmetros
- object
-
unknown
Retornos
object is Number
isPromise(unknown)
Retorna true se o valor for um Promiseinterno.
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>Parâmetros
- object
-
unknown
Retornos
object is Promise<unknown>
isProxy(unknown)
Retorna true se o valor for uma instância Proxy.
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
function isProxy(object: unknown): booleanParâmetros
- object
-
unknown
Retornos
boolean
isRegExp(unknown)
Retorna true se o valor for um objeto de expressão regular.
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExpParâmetros
- object
-
unknown
Retornos
object is RegExp
isSet<T>({} | T)
Retorna true se o valor for uma instância de Set interna.
util.types.isSet(new Set()); // Returns true
function isSet<T>(object: {} | T): object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)Parâmetros
- object
-
{} | T
Retornos
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
Retorna true se o valor for um iterador retornado para uma instância de Set interna.
const set = new Set();
util.types.isSetIterator(set.keys()); // Returns true
util.types.isSetIterator(set.values()); // Returns true
util.types.isSetIterator(set.entries()); // Returns true
util.types.isSetIterator(set[Symbol.iterator]()); // Returns true
function isSetIterator(object: unknown): booleanParâmetros
- object
-
unknown
Retornos
boolean
isSharedArrayBuffer(unknown)
Retorna true se o valor for uma instância de SharedArrayBuffer interna.
Isso não incluir instâncias de ArrayBuffer. Normalmente, é desejável testar para ambos; Veja util.types.isAnyArrayBuffer() para isso.
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBufferParâmetros
- object
-
unknown
Retornos
object is SharedArrayBuffer
isStringObject(unknown)
Retorna true se o valor for um objeto de cadeia de caracteres, por exemplo, criado por new String().
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is StringParâmetros
- object
-
unknown
Retornos
object is String
isSymbolObject(unknown)
Retorna true se o valor for um objeto de símbolo, criado chamando Object() em um primitivo Symbol.
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is SymbolParâmetros
- object
-
unknown
Retornos
object is Symbol
isTypedArray(unknown)
Retorna true se o valor for uma instância de TypedArray interna.
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
Consulte também ArrayBuffer.isView().
function isTypedArray(object: unknown): object is TypedArrayParâmetros
- object
-
unknown
Retornos
object is TypedArray
isUint16Array(unknown)
Retorna true se o valor for uma instância de Uint16Array interna.
util.types.isUint16Array(new ArrayBuffer()); // Returns false
util.types.isUint16Array(new Uint16Array()); // Returns true
util.types.isUint16Array(new Float64Array()); // Returns false
function isUint16Array(object: unknown): object is Uint16ArrayParâmetros
- object
-
unknown
Retornos
object is Uint16Array
isUint32Array(unknown)
Retorna true se o valor for uma instância de Uint32Array interna.
util.types.isUint32Array(new ArrayBuffer()); // Returns false
util.types.isUint32Array(new Uint32Array()); // Returns true
util.types.isUint32Array(new Float64Array()); // Returns false
function isUint32Array(object: unknown): object is Uint32ArrayParâmetros
- object
-
unknown
Retornos
object is Uint32Array
isUint8Array(unknown)
Retorna true se o valor for uma instância de Uint8Array interna.
util.types.isUint8Array(new ArrayBuffer()); // Returns false
util.types.isUint8Array(new Uint8Array()); // Returns true
util.types.isUint8Array(new Float64Array()); // Returns false
function isUint8Array(object: unknown): object is Uint8ArrayParâmetros
- object
-
unknown
Retornos
object is Uint8Array
isUint8ClampedArray(unknown)
Retorna true se o valor for uma instância de Uint8ClampedArray interna.
util.types.isUint8ClampedArray(new ArrayBuffer()); // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray()); // Returns true
util.types.isUint8ClampedArray(new Float64Array()); // Returns false
function isUint8ClampedArray(object: unknown): object is Uint8ClampedArrayParâmetros
- object
-
unknown
Retornos
object is Uint8ClampedArray
isWeakMap(unknown)
Retorna true se o valor for uma instância de WeakMap interna.
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>Parâmetros
- object
-
unknown
Retornos
object is WeakMap<object, unknown>
isWeakSet(unknown)
Retorna true se o valor for uma instância de WeakSet interna.
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>Parâmetros
- object
-
unknown
Retornos
object is WeakSet<object>
inspect(any, boolean, number | null, 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?: number | null, color?: boolean): stringParâmetros
- object
-
any
Qualquer primitivo JavaScript ou Object.
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
Retornos
string
A representação de object.
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>): TCustomParâmetros
- fn
-
CustomPromisify<TCustom>
Retornos
TCustom
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): stringParâ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[]): anyParâmetros
- args
-
any[]
Retornos
any
autoAuthInEmbedUrl(string)
Verifica se a URL de inserção contém autoAuth=true.
function autoAuthInEmbedUrl(embedUrl: string): booleanParâ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.
import util from 'node:util';
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: ErrnoException) => void) => voidParâmetros
- fn
-
() => Promise<void>
Uma função async
Retornos
(callback: (err: ErrnoException) => void) => void
uma função de estilo de retorno de chamada
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => voidParâmetros
- fn
-
() => Promise<TResult>
Retornos
(callback: (err: ErrnoException, result: TResult) => void) => void
callbackify<T1>((arg1: T1) => Promise<void>)
function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: ErrnoException) => void) => voidParâmetros
- fn
-
(arg1: T1) => Promise<void>
Retornos
(arg1: T1, callback: (err: ErrnoException) => void) => void
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: ErrnoException, result: TResult) => void) => voidParâmetros
- fn
-
(arg1: T1) => Promise<TResult>
Retornos
(arg1: T1, callback: (err: ErrnoException, 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: ErrnoException) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Retornos
(arg1: T1, arg2: T2, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Retornos
(arg1: T1, arg2: T2, callback: (err: 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: ErrnoException) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Retornos
(arg1: T1, arg2: T2, arg3: T3, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Retornos
(arg1: T1, arg2: T2, arg3: T3, callback: (err: 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: ErrnoException) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Retornos
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParâmetros
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Retornos
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: 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: ErrnoException) => void) => voidParâ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: 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: ErrnoException | null, result: TResult) => void) => voidParâ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: 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: ErrnoException) => void) => voidParâ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: ErrnoException) => void) => void
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: ErrnoException | null, result: TResult) => void) => voidParâ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: ErrnoException | null, result: TResult) => void) => void
convertProcessSignalToExitCode(Signals)
O util.convertProcessSignalToExitCode() método converte um nome de sinal em seu código de saída POSIX correspondente. Seguindo o padrão POSIX, o código de saída de um processo encerrado por um sinal é calculado como 128 + signal number.
Se signal não for um nome de sinal válido, um erro será gerado. Consulte signal(7) uma lista de sinais válidos.
import { convertProcessSignalToExitCode } from 'node:util';
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
Isso é particularmente útil ao trabalhar com processos para determinar o código de saída com base no sinal que encerrou o processo.
function convertProcessSignalToExitCode(signal: Signals): numberParâmetros
- signal
-
Signals
Um nome de sinal (por exemplo 'SIGTERM')
Retornos
number
O código de saída correspondente a signal
createRandomString()
Gera uma cadeia de caracteres aleatória de 5 a 6 caracteres.
function createRandomString(): stringRetornos
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-bar');
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): DebugLoggerParâ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
A função de registro em log
deprecate<T>(T, string, string, DeprecateOptions)
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, options?: DeprecateOptions): TParâ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.
- options
- DeprecateOptions
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
Uma matriz de entradas de diferença. Cada entrada é uma matriz com dois elementos:
- Índice 0:
numberCódigo da operação:-1para exclusão,0para no-op/inalterado,1para inserção - Índice 1:
stringo 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[]): TParâ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[]): numberParâ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[]): stringParâ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
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[]): stringParâmetros
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Retornos
string
generateUUID()
Gera um uuid de 20 caracteres.
function generateUUID(): stringRetornos
string
getCallSites(number, GetCallSitesOptions)
Retorna uma matriz de objetos de site de chamada que contém a pilha da função de chamador.
Ao contrário de acessar um error.stack, o resultado retornado dessa API não está interferido Error.prepareStackTrace.
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.columnNumber}`);
});
// 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 --enable-source-maps sinalizador estiver habilitado, 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
Uma matriz de objetos de site de chamada
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]Parâmetros
- options
- GetCallSitesOptions
Retornos
getRandomValue()
Retorna número aleatório
function getRandomValue(): numberRetornos
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): stringParâ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): stringParâmetros
- err
-
number
Retornos
string
getTimeDiffInMilliseconds(Date, Date)
Retorna o intervalo de tempo entre duas datas em milissegundos
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParâ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, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParâ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 is unknown[]Parâmetros
- object
-
unknown
Retornos
object is unknown[]
isCreate(string)
Verifica se o tipo de inserção é para criar
function isCreate(embedType: string): booleanParâ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): booleanParâ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): booleanParâ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): Dict<string>Parâmetros
- content
-
string
O conteúdo bruto de um arquivo .env.
Retornos
Dict<string>
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>
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<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<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, 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, 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, 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(Function)
function promisify(fn: Function): FunctionParâmetros
- fn
-
Function
Retornos
Function
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): stringParâmetros
- str
-
string
Retornos
string
styleText(InspectColor | (readonly InspectColor[]) | Object, 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.
Além de nomes de cores predefinidos, util.styleText() dá suporte a cadeias de caracteres de cor hex usando sequências de escape ANSI TrueColor (24 bits). As cores hexadecimais podem ser especificadas no formato de 3 dígitos (#RGB) ou 6 dígitos (#RRGGBB):
import { styleText } from 'node:util';
// 6-digit hex color
console.log(styleText('#ff5733', 'Orange text'));
// 3-digit hex color (shorthand)
console.log(styleText('#f00', 'Red text'));
A lista completa de formatos pode ser encontrada em modificadores .
function styleText(format: InspectColor | (readonly InspectColor[]) | Object, text: string, options?: StyleTextOptions): stringParâmetros
- format
-
InspectColor | (readonly InspectColor[]) | Object
Um formato de texto ou uma matriz de formatos de texto definidos em util.inspect.colors, ou uma cor hexáxe em #RGB ou #RRGGBB forma.
- 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): stringParâ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(): AbortControllerRetornos
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): AbortSignalParâmetros
- signal
-
AbortSignal
O AbortSignal
Retornos
AbortSignal
O mesmo AbortSignal
Detalhes da variável
APINotSupportedForRDLError
APINotSupportedForRDLError: "This API is currently not supported for RDL reports"Tipo
"This API is currently not supported for RDL reports"
EmbedUrlNotSupported
EmbedUrlNotSupported: "Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"Tipo
"Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"
TextDecoder
TextDecoder: (label?: string, options?: TextDecoderOptions) => TextDecoderTipo
(label?: string, options?: TextDecoderOptions) => TextDecoder
TextEncoder
TextEncoder: () => TextEncoderTipo
() => TextEncoder
Document
Document: () => DocumentTipo
() => Document
HTMLIFrameElement
HTMLIFrameElement: () => HTMLIFrameElementTipo
() => HTMLIFrameElement
Window
Window: () => WindowTipo
() => Window
config
config: { type: string, version: string }Tipo
{ type: string, version: string }
invalidEmbedUrlErrorMessage
invalidEmbedUrlErrorMessage: stringTipo
string
hpmFactory
hpmFactory: IHpmFactoryTipo
IHpmFactory
routerFactory
routerFactory: IRouterFactoryTipo
IRouterFactory
wpmpFactory
wpmpFactory: IWpmpFactoryTipo
IWpmpFactory