powerbi-client package

Devuelve true si el valor es una instancia integrada de ArrayBuffer o SharedArrayBuffer.

Consulte también util.types.isArrayBuffer() y util.types.isSharedArrayBuffer().

util.types.isAnyArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer());  // Returns true

function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike

Parámetros

Devoluciones

Devuelve true si el valor es un objeto arguments.

function foo() {
  util.types.isArgumentsObject(arguments);  // Returns true
}

function isArgumentsObject(object: unknown): object is IArguments

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de ArrayBuffer integrada. Esto no incluir instancias de SharedArrayBuffer. Por lo general, es conveniente probar ambos; Consulte util.types.isAnyArrayBuffer() para ello.

util.types.isArrayBuffer(new ArrayBuffer());  // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer());  // Returns false

function isArrayBuffer(object: unknown): object is ArrayBuffer

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de una de las vistas de ArrayBuffer, como objetos de matriz con tipo o 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 ArrayBufferView

Parámetros

Devoluciones

Devuelve true si el valor es una función asincrónica . Esto solo informa de lo que ve el motor de JavaScript; en concreto, el valor devuelto puede no coincidir con el código fuente original si se usó una herramienta de transpilación.

util.types.isAsyncFunction(function foo() {});  // Returns false
util.types.isAsyncFunction(async function foo() {});  // Returns true

function isAsyncFunction(object: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de BigInt64Array.

util.types.isBigInt64Array(new BigInt64Array());   // Returns true
util.types.isBigInt64Array(new BigUint64Array());  // Returns false

function isBigInt64Array(value: unknown): value is BigInt64Array

Parámetros

Devoluciones

Devuelve true si el valor es un objeto BigInt, por ejemplo, creado 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 BigInt

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de BigUint64Array.

util.types.isBigUint64Array(new BigInt64Array());   // Returns false
util.types.isBigUint64Array(new BigUint64Array());  // Returns true

function isBigUint64Array(value: unknown): value is BigUint64Array

Parámetros

Devoluciones

Devuelve true si el valor es un objeto booleano, por ejemplo, creado 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 Boolean

Parámetros

Devoluciones

Devuelve true si el valor es cualquier objeto primitivo boxizado, por ejemplo, creado por new Boolean(), new String() o Object(Symbol()).

Por ejemplo:

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

Parámetros

Devoluciones

Devuelve true si value es un CryptoKey, false de lo contrario.

function isCryptoKey(object: unknown): object is CryptoKey

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de DataView integrada.

const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab));  // Returns true
util.types.isDataView(new Float64Array());  // Returns false

Consulte también ArrayBuffer.isView().

function isDataView(object: unknown): object is DataView

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Date integrada.

util.types.isDate(new Date());  // Returns true

function isDate(object: unknown): object is Date

Parámetros

Devoluciones

Devuelve true si el valor es un valor de External nativo.

Un valor de External nativo es un tipo especial de objeto que contiene un puntero de C++ sin procesar (void*) para el acceso desde código nativo y no tiene otras propiedades. Estos objetos se crean mediante Node.js complementos internos o nativos. En JavaScript, son objetos congelados con un null prototipo.

#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 obtener más información sobre napi_create_external, consulte napi_create_external().

function isExternal(object: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Float16Array integrada.

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): boolean

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Float32Array integrada.

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 Float32Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Float64Array integrada.

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 Float64Array

Parámetros

Devoluciones

Devuelve true si el valor es una función de generador. Esto solo informa de lo que ve el motor de JavaScript; en concreto, el valor devuelto puede no coincidir con el código fuente original si se usó una herramienta de transpilación.

util.types.isGeneratorFunction(function foo() {});  // Returns false
util.types.isGeneratorFunction(function* foo() {});  // Returns true

function isGeneratorFunction(object: unknown): object is GeneratorFunction

Parámetros

Devoluciones

Devuelve true si el valor es un objeto de generador tal como se devuelve desde una función de generador integrada. Esto solo informa de lo que ve el motor de JavaScript; en concreto, el valor devuelto puede no coincidir con el código fuente original si se usó una herramienta de transpilación.

function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator);  // Returns true

function isGeneratorObject(object: unknown): object is Generator

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Int16Array integrada.

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 Int16Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Int32Array integrada.

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 Int32Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Int8Array integrada.

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 Int8Array

Parámetros

Devoluciones

Devuelve true si value es un KeyObject, false de lo contrario.

function isKeyObject(object: unknown): object is KeyObject

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Map integrada.

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

Devoluciones

Devuelve true si el valor es un iterador devuelto para una instancia de Map integrada.

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): boolean

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de un objeto de espacio de nombres módulo.

import * as ns from './a.js';

util.types.isModuleNamespaceObject(ns);  // Returns true

function isModuleNamespaceObject(value: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el constructor devolvió el valor de un tipo integrado Error.

console.log(util.types.isNativeError(new Error()));  // true
console.log(util.types.isNativeError(new TypeError()));  // true
console.log(util.types.isNativeError(new RangeError()));  // true

Las subclases de los tipos de error nativos también son errores nativos:

class MyError extends Error {}
console.log(util.types.isNativeError(new MyError()));  // true

Un valor que se instanceof una clase de error nativa no equivale a isNativeError() devolver true para ese valor. devuelve de errores que proceden de un de dominio de diferente, mientras que devuelve para estos errores:

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 el contrario, isNativeError() devuelve false para todos los objetos que no devolvió el constructor de un error nativo. Esto incluye valores que son instanceof errores 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 Error

Parámetros

Devoluciones

Devuelve true si el valor es un objeto number, por ejemplo, creado por new Number().

util.types.isNumberObject(0);  // Returns false
util.types.isNumberObject(new Number(0));   // Returns true

function isNumberObject(object: unknown): object is Number

Parámetros

Devoluciones

Devuelve true si el valor es un Promiseintegrado.

util.types.isPromise(Promise.resolve(42));  // Returns true

function isPromise(object: unknown): object is Promise<unknown>

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Proxy.

const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target);  // Returns false
util.types.isProxy(proxy);  // Returns true

function isProxy(object: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el valor es un objeto de expresión regular.

util.types.isRegExp(/abc/);  // Returns true
util.types.isRegExp(new RegExp('abc'));  // Returns true

function isRegExp(object: unknown): object is RegExp

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Set integrada.

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

Devoluciones

Devuelve true si el valor es un iterador devuelto para una instancia de Set integrada.

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): boolean

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de SharedArrayBuffer integrada. Esto no incluir instancias de ArrayBuffer. Por lo general, es conveniente probar ambos; Consulte util.types.isAnyArrayBuffer() para ello.

util.types.isSharedArrayBuffer(new ArrayBuffer());  // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer());  // Returns true

function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer

Parámetros

Devoluciones

Devuelve true si el valor es un objeto de cadena, por ejemplo, creado por new String().

util.types.isStringObject('foo');  // Returns false
util.types.isStringObject(new String('foo'));   // Returns true

function isStringObject(object: unknown): object is String

Parámetros

Devoluciones

Devuelve true si el valor es un objeto de símbolo, creado llamando a Object() en un primitivo de Symbol.

const symbol = Symbol('foo');
util.types.isSymbolObject(symbol);  // Returns false
util.types.isSymbolObject(Object(symbol));   // Returns true

function isSymbolObject(object: unknown): object is Symbol

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de TypedArray integrada.

util.types.isTypedArray(new ArrayBuffer());  // Returns false
util.types.isTypedArray(new Uint8Array());  // Returns true
util.types.isTypedArray(new Float64Array());  // Returns true

Consulte también ArrayBuffer.isView().

function isTypedArray(object: unknown): object is TypedArray

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Uint16Array integrada.

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 Uint16Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Uint32Array integrada.

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 Uint32Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Uint8Array integrada.

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 Uint8Array

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de Uint8ClampedArray integrada.

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 Uint8ClampedArray

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de WeakMap integrada.

util.types.isWeakMap(new WeakMap());  // Returns true

function isWeakMap(object: unknown): object is WeakMap<object, unknown>

Parámetros

Devoluciones

Devuelve true si el valor es una instancia de WeakSet integrada.

util.types.isWeakSet(new WeakSet());  // Returns true

function isWeakSet(object: unknown): object is WeakSet<object>

Parámetros

Devoluciones

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

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

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

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

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

import util from 'node:util';

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

En el ejemplo siguiente se resalta el efecto de la opción compact:

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

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

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

La opción sorted garantiza que el orden de inserción de propiedades de un objeto no afecte al resultado de util.inspect().

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

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

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

util.inspect() es un método sincrónico destinado a la depuración. Su longitud máxima de salida es de aproximadamente 128 MiB. Las entradas que dan como resultado una salida más larga se truncarán.

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

Parámetros

Devoluciones

Representación de object.

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

import { promisify } from 'node:util';
import { stat } from 'node:fs';

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

O bien, de forma equivalente mediante async functions:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

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

callStat();

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

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

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

import { promisify } from 'node:util';

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

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

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'

function promisify<TCustom>(fn: CustomPromisify<TCustom>): TCustom

Parámetros

Devoluciones

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

import { aborted } from 'node:util';

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

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

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

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

Parámetros

Devoluciones

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

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

Parámetros

Devoluciones

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

function assign(args: any[]): any

Parámetros

Devoluciones

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

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parámetros

Devoluciones

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

import { callbackify } from 'node:util';

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

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

Imprimirá:

hello world

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

Dado que null tiene un significado especial como primer argumento para una devolución de llamada, si una función ajustada rechaza un Promise con un valor falso como motivo, el valor se ajusta en un Error con el valor original almacenado en un campo denominado reason.

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});

function callbackify(fn: () => Promise<void>): (callback: (err: ErrnoException) => void) => void

Parámetros

Devoluciones

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

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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) => void

Parámetros

Devoluciones

Genera una cadena aleatoria de 5 a 6 caracteres.

function createRandomString(): string

Devoluciones

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

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

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

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

FOO 3245: hello from foo [123]

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

El section admite también caracteres comodín:

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

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

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

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

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

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

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

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

Parámetros

Devoluciones

La función de registro

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

import { deprecate } from 'node:util';

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

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

Si se proporciona el mismo code opcional en varias llamadas a util.deprecate(), la advertencia solo se emitirá una vez para ese code.

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Si se usan las marcas de línea de comandos --no-deprecation o --no-warnings, o si la propiedad process.noDeprecation está establecida en trueanterior a la primera advertencia de desuso, el método util.deprecate() no hace nada.

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

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

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

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

Parámetros

Devoluciones

Función en desuso ajustada para emitir una advertencia.

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

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

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

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

function diff(actual: string | (readonly string[]), expected: string | (readonly string[])): DiffEntry[]

Parámetros

Devoluciones

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

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

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

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

Parámetros

Devoluciones

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

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

Parámetros

Devoluciones

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

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

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

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

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

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

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

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

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

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

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

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

Parámetros

Devoluciones

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

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.

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

Parámetros

Devoluciones

Genera un uuid de 20 caracteres.

function generateUUID(): string

Devoluciones

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

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('Call Sites:');
  callSites.forEach((callSite, index) => {
    console.log(`CallSite ${index + 1}:`);
    console.log(`Function Name: ${callSite.functionName}`);
    console.log(`Script Name: ${callSite.scriptName}`);
    console.log(`Line Number: ${callSite.lineNumber}`);
    console.log(`Column Number: ${callSite.column}`);
  });
  // CallSite 1:
  // Function Name: exampleFunction
  // Script Name: /home/example.js
  // Line Number: 5
  // Column Number: 26

  // CallSite 2:
  // Function Name: anotherFunction
  // Script Name: /home/example.js
  // Line Number: 22
  // Column Number: 3

  // ...
}

// A function to simulate another stack layer
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

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

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

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

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

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

function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[]

Parámetros

Devoluciones

Matriz de objetos de sitio de llamada

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parámetros

Devoluciones

Devuelve un número aleatorio.

function getRandomValue(): number

Devoluciones

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

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

function getSystemErrorMap(): Map<number, [string, string]>

Devoluciones

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

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

function getSystemErrorMessage(err: number): string

Parámetros

Devoluciones

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

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

function getSystemErrorName(err: number): string

Parámetros

Devoluciones

Devuelve el intervalo de tiempo entre dos fechas en milisegundos.

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

Parámetros

Devoluciones

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

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

Esto agrega principalmente cierta validación de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)entrada sobre . Como comodidad adicional, superConstructor será accesible a través de la propiedad constructor.super_.

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

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"

Ejemplo de ES6 mediante class y extends:

import EventEmitter from 'node:events';

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

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('With ES6');

function inherits(constructor: unknown, superConstructor: unknown)

Parámetros

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

Parámetros

Devoluciones

Alias para Array.isArray().

Devuelve true si el object especificado es un Array. De lo contrario, devuelve false.

import util from 'node:util';

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

function isArray(object: unknown): object is unknown[]

Parámetros

Devoluciones

Devuelve true si el object especificado es un Boolean. De lo contrario, devuelve false.

import util from 'node:util';

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

function isBoolean(object: unknown): object is boolean

Parámetros

Devoluciones

Devuelve true si el object especificado es un Buffer. De lo contrario, devuelve false.

import util from 'node:util';

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

function isBuffer(object: unknown): object is Buffer

Parámetros

Devoluciones

Comprueba si el tipo de inserción es para crear

function isCreate(embedType: string): boolean

Parámetros

Devoluciones

Devuelve true si el object especificado es un Date. De lo contrario, devuelve false.

import util from 'node:util';

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

function isDate(object: unknown): object is Date

Parámetros

Devoluciones

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

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

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

Parámetros

Devoluciones

Devuelve true si el object especificado es un Error. De lo contrario, devuelve false.

import util from 'node:util';

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

Este método se basa en Object.prototype.toString() comportamiento. Es posible obtener un resultado incorrecto cuando el argumento object manipula @@toStringTag.

import util from 'node:util';
const obj = { name: 'Error', message: 'an error occurred' };

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

function isError(object: unknown): object is Error

Parámetros

Devoluciones

Devuelve true si el object especificado es un Function. De lo contrario, devuelve false.

import util from 'node:util';

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

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

function isFunction(object: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el object especificado es estrictamente null. De lo contrario, devuelvefalse.

import util from 'node:util';

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

function isNull(object: unknown): object is null

Parámetros

Devoluciones

Devuelve true si el object especificado es null o undefined. De lo contrario, devuelve false.

import util from 'node:util';

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

function isNullOrUndefined(object: unknown): object is null | undefined

Parámetros

Devoluciones

Devuelve true si el object especificado es un Number. De lo contrario, devuelve false.

import util from 'node:util';

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

function isNumber(object: unknown): object is number

Parámetros

Devoluciones

Devuelve true si el object especificado es estrictamente un Objecty no unFunction (aunque las funciones son objetos en JavaScript). De lo contrario, devuelve false.

import util from 'node:util';

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

function isObject(object: unknown): boolean

Parámetros

Devoluciones

Devuelve true si el object especificado es un tipo primitivo. De lo contrario, devuelvefalse.

import util from 'node:util';

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

function isPrimitive(object: unknown): boolean

Parámetros

Devoluciones

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

function isRDLEmbed(embedUrl: string): boolean

Parámetros

Devoluciones

Devuelve true si el object especificado es un RegExp. De lo contrario, devuelve false.

import util from 'node:util';

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

function isRegExp(object: unknown): object is RegExp

Parámetros

Devoluciones

Comprueba si el informe se guarda.

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

Parámetros

Devoluciones

Devuelve true si el object especificado es un string. De lo contrario, devuelve false.

import util from 'node:util';

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

function isString(object: unknown): object is string

Parámetros

Devoluciones

Devuelve true si el object especificado es un Symbol. De lo contrario, devuelve false.

import util from 'node:util';

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

function isSymbol(object: unknown): object is symbol

Parámetros

Devoluciones

Devuelve true si el object especificado es undefined. De lo contrario, devuelve false.

import util from 'node:util';

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

function isUndefined(object: unknown): object is undefined

Parámetros

Devoluciones

El método util.log() imprime el string especificado en stdout con una marca de tiempo incluida.

import util from 'node:util';

util.log('Timestamped message.');

function log(string: string)

Parámetros

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

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

function parseArgs<T>(config?: T): ParsedResults<T>

Parámetros

Devoluciones

Argumentos de línea de comandos analizados:

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

import { parseEnv } from 'node:util';

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

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

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

Parámetros

Devoluciones

function promisify(fn: Function): Function

Parámetros

Devoluciones

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

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

Parámetros

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

Parámetros

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

function setTraceSigInt(enable: boolean)

Parámetros

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

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

function stripVTControlCharacters(str: string): string

Parámetros

Devoluciones

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

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // Validate if process.stderr has TTY
  { stream: stderr },
);
console.error(errorMessage);

util.inspect.colors también proporciona formatos de texto como italicy underline y puede combinar ambos:

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

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

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

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

La lista completa de formatos se puede encontrar en modificadores .

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

Parámetros

Devoluciones

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

function toUSVString(string: string): string

Parámetros

Devoluciones

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

function transferableAbortController(): AbortController

Devoluciones

AnulaciónController transferible

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

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parámetros

Devoluciones

El mismo AbortSignal

APINotSupportedForRDLError: "This API is currently not supported for RDL reports"

Tipo

EmbedUrlNotSupported: "Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"

Tipo

Document: () => Document

Tipo

HTMLIFrameElement: () => HTMLIFrameElement

Tipo

Window: () => Window

Tipo

config: { type: string, version: string }

Tipo

invalidEmbedUrlErrorMessage: string

Tipo

hpmFactory: IHpmFactory

Tipo

routerFactory: IRouterFactory

Tipo

wpmpFactory: IWpmpFactory

Tipo