powerbi-client package

Restituisce true se il valore è un'istanza predefinita ArrayBuffer o SharedArrayBuffer.

Vedere anche 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 ArrayBufferLike

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto arguments.

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

function isArgumentsObject(object: unknown): object is IArguments

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di ArrayBuffer predefinita. Ciò non includere istanze di SharedArrayBuffer. Di solito, è consigliabile testare entrambi; Vedere util.types.isAnyArrayBuffer() per questo.

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

function isArrayBuffer(object: unknown): object is ArrayBuffer

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di una delle viste ArrayBuffer, ad esempio oggetti matrice tipizzati 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

Parametri

Valori restituiti

Restituisce true se il valore è una funzione asincrona . Questo riporta solo ciò che viene visualizzato dal motore JavaScript; in particolare, il valore restituito potrebbe non corrispondere al codice sorgente originale se è stato usato uno strumento di transpilazione.

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

function isAsyncFunction(object: unknown): boolean

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di BigInt64Array.

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

function isBigInt64Array(value: unknown): value is BigInt64Array

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto BigInt, ad esempio creato da 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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di BigUint64Array.

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

function isBigUint64Array(value: unknown): value is BigUint64Array

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto booleano, ad esempio creato da 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

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto primitivo boxed, ad esempio creato da new Boolean(), new String() o Object(Symbol()).

Per esempio:

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

Parametri

Valori restituiti

Restituisce true se value è un CryptoKey, false in caso contrario.

function isCryptoKey(object: unknown): object is CryptoKey

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di DataView predefinita.

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

Vedi anche ArrayBuffer.isView().

function isDataView(object: unknown): object is DataView

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Date predefinita.

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

function isDate(object: unknown): object is Date

Parametri

Valori restituiti

Restituisce true se il valore è un valore External nativo.

Un valore nativo External è un tipo speciale di oggetto che contiene un puntatore C++ non elaborato (void*) per l'accesso dal codice nativo e non ha altre proprietà. Tali oggetti vengono creati da Node.js componenti interni o componenti aggiuntivi nativi. In JavaScript sono oggetti bloccati 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

Per altre informazioni su napi_create_external, vedere napi_create_external().

function isExternal(object: unknown): boolean

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Float16Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Float32Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Float64Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è una funzione generatore. Questo riporta solo ciò che viene visualizzato dal motore JavaScript; in particolare, il valore restituito potrebbe non corrispondere al codice sorgente originale se è stato usato uno strumento di transpilazione.

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

function isGeneratorFunction(object: unknown): object is GeneratorFunction

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto generatore restituito da una funzione generatore predefinita. Questo riporta solo ciò che viene visualizzato dal motore JavaScript; in particolare, il valore restituito potrebbe non corrispondere al codice sorgente originale se è stato usato uno strumento di transpilazione.

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

function isGeneratorObject(object: unknown): object is Generator

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Int16Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Int32Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Int8Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se value è un KeyObject, false in caso contrario.

function isKeyObject(object: unknown): object is KeyObject

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Map predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un iteratore restituito per un'istanza di Map predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di un oggetto spazio dei nomi del modulo .

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

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

function isModuleNamespaceObject(value: unknown): boolean

Parametri

Valori restituiti

Restituisce true se il valore è stato restituito dal costruttore di un tipo predefinito 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

Anche le sottoclassi dei tipi di errore nativi sono errori nativi:

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

Un valore instanceof una classe di errore nativa non equivale a isNativeError() restituire true per tale valore. isNativeError() restituisce true per gli errori provenienti da un'area di autenticazione diversa mentre instanceof Error restituisce false per questi errori:

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

Al contrario, isNativeError() restituisce false per tutti gli oggetti che non sono stati restituiti dal costruttore di un errore nativo. Sono inclusi i valori instanceof errori nativi:

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

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto numerico, ad esempio creato da new Number().

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

function isNumberObject(object: unknown): object is Number

Parametri

Valori restituiti

Restituisce true se il valore è un Promisepredefinito.

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

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di 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

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto espressione regolare.

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

function isRegExp(object: unknown): object is RegExp

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Set predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un iteratore restituito per un'istanza di Set predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di SharedArrayBuffer predefinita. Ciò non includere istanze di ArrayBuffer. Di solito, è consigliabile testare entrambi; Vedere util.types.isAnyArrayBuffer() per questo.

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

function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto stringa, ad esempio creato da new String().

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

function isStringObject(object: unknown): object is String

Parametri

Valori restituiti

Restituisce true se il valore è un oggetto simbolo, creato chiamando Object() su una primitiva 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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di TypedArray predefinita.

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

Vedi anche ArrayBuffer.isView().

function isTypedArray(object: unknown): object is TypedArray

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Uint16Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Uint32Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Uint8Array predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di Uint8ClampedArray predefinita.

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di WeakMap predefinita.

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

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

Parametri

Valori restituiti

Restituisce true se il valore è un'istanza di WeakSet predefinita.

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

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

Parametri

Valori restituiti

Il metodo util.inspect() restituisce una rappresentazione di stringa di object destinata al debug. L'output di util.inspect può cambiare in qualsiasi momento e non deve dipendere a livello di codice. È possibile passare options aggiuntivi che modificano il risultato. util.inspect() userà il nome e/o Symbol.toStringTag la proprietà del costruttore per rendere un tag identificabile per un valore ispezionato.

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

I riferimenti circolari puntano al relativo ancoraggio usando un indice di riferimento:

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

Nell'esempio seguente vengono esaminate tutte le proprietà dell'oggetto util:

import util from 'node:util';

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

Nell'esempio seguente viene evidenziato l'effetto dell'opzione 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.

L'opzione showHidden consente di controllare WeakMap e WeakSet voci. Se sono presenti più voci di maxArrayLength, non esiste alcuna garanzia per quali voci vengono visualizzate. Ciò significa che il recupero delle stesse voci WeakSet due volte può comportare un output diverso. Inoltre, le voci senza riferimenti sicuri rimanenti possono essere raccolte in qualsiasi 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 } }

L'opzione sorted assicura che l'ordine di inserimento delle proprietà di un oggetto non influisca sul risultato di 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 }),
);

L'opzione numericSeparator aggiunge un carattere di sottolineatura ogni tre cifre a tutti i numeri.

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() è un metodo sincrono destinato al debug. La lunghezza massima dell'output è di circa 128 MiB. Gli input che generano un output più lungo verranno troncati.

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

Parametri

Valori restituiti

Rappresentazione di object.

Accetta una funzione che segue lo stile di callback di primo errore comune, ovvero l'acquisizione di un callback (err, value) => ... come ultimo argomento e restituisce una versione che restituisce promesse.

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

In alternativa, usando in modo equivalente 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 è presente una original[util.promisify.custom] proprietà, promisify restituirà il relativo valore, vedere Funzioni promisificate personalizzate.

promisify() presuppone che original sia una funzione che accetta un callback come argomento finale in tutti i casi. Se original non è una funzione, promisify() genererà un errore. Se original è una funzione ma l'ultimo argomento non è un callback di tipo error-first, verrà comunque passato un callback error-first come ultimo argomento.

L'uso di promisify() su metodi di classe o altri metodi che usano this potrebbe non funzionare come previsto, a meno che non venga gestito in modo speciale:

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

Parametri

Valori restituiti

È in ascolto dell'evento di interruzione nel signal fornito e restituisce una promessa che viene risolta quando il signal viene interrotto. Se viene specificato resource, fa riferimento debole all'oggetto associato dell'operazione, quindi se resource viene sottoposto a Garbage Collection prima dell'interruzione del signal, la promessa restituita rimarrà in sospeso. In questo modo si evitano perdite di memoria in operazioni con esecuzione prolungata o non annullabili.

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>

Parametri

Valori restituiti

Aggiunge un parametro all'URL specificato

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

Parametri

Valori restituiti

Copia i valori di tutte le proprietà enumerabili da uno o più oggetti di origine a un oggetto di destinazione e restituisce l'oggetto di destinazione.

function assign(args: any[]): any

Parametri

Valori restituiti

Controlla se l'URL di incorporamento contiene autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parametri

Valori restituiti

Accetta una funzione async (o una funzione che restituisce un Promise) e restituisce una funzione dopo lo stile di callback error-first, ovvero accettando un callback (err, value) => ... come ultimo argomento. Nel callback il primo argomento sarà il motivo del rifiuto (o null se il Promise risolto) e il secondo argomento sarà il valore risolto.

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

Stampa:

hello world

Il callback viene eseguito in modo asincrono e avrà un'analisi dello stack limitata. Se il callback viene generato, il processo genererà un evento 'uncaughtException' e, se non gestito, verrà chiuso.

Poiché null ha un significato speciale come primo argomento di un callback, se una funzione di cui è stato eseguito il wrapping rifiuta un Promise con un valore non valido come motivo, il valore viene incluso in un Error con il valore originale archiviato in un campo denominato 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

Parametri

Valori restituiti

una funzione di stile callback

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

Genera una stringa di caratteri da 5 a 6 casuali.

function createRandomString(): string

Valori restituiti

Il util.debuglog() metodo viene usato per creare una funzione che scrive in modo condizionale i messaggi di debug in stderr in base all'esistenza della NODE_DEBUG variabile di ambiente. Se il nome section viene visualizzato all'interno del valore della variabile di ambiente, la funzione restituita funziona in modo simile a console.error(). In caso contrario, la funzione restituita è un no-op.

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

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

Se questo programma viene eseguito con NODE_DEBUG=foo nell'ambiente, verrà restituito un risultato simile al seguente:

FOO 3245: hello from foo [123]

dove 3245 è l'ID processo. Se non viene eseguito con tale set di variabili di ambiente, non verrà stampato nulla.

Il section supporta anche i caratteri jolly:

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

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

se viene eseguito con NODE_DEBUG=foo* nell'ambiente, l'output sarà simile al seguente:

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

Nella variabile di ambiente possono essere specificati section più nomi delimitati da NODE_DEBUG virgole: NODE_DEBUG=fs,net,tls.

L'argomento facoltativo callback può essere usato per sostituire la funzione di registrazione con una funzione diversa che non dispone di inizializzazione o wrapping non necessario.

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

Parametri

Valori restituiti

Funzione di registrazione

Il metodo util.deprecate() esegue il wrapping di fn (che può essere una funzione o una classe) in modo che sia contrassegnato come deprecato.

import { deprecate } from 'node:util';

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

Quando viene chiamato, util.deprecate() restituirà una funzione che genererà un DeprecationWarning usando l'evento 'warning'. L'avviso verrà generato e stampato in stderr la prima volta che viene chiamata la funzione restituita. Dopo l'emissione dell'avviso, la funzione di cui è stato eseguito il wrapping viene chiamata senza generare un avviso.

Se lo stesso code facoltativo viene fornito in più chiamate a util.deprecate(), l'avviso verrà generato una sola volta per tale 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 vengono utilizzati i flag della riga di comando --no-deprecation o --no-warnings o se la proprietà process.noDeprecation è impostata su trueprima al primo avviso di deprecazione, il metodo util.deprecate() non esegue alcuna operazione.

Se vengono impostati i flag --trace-deprecation o --trace-warnings della riga di comando oppure la proprietà process.traceDeprecation è impostata su true, viene stampato un avviso e un'analisi dello stack per stderr la prima chiamata della funzione deprecata.

Se il flag della riga di comando --throw-deprecation è impostato o la proprietà process.throwDeprecation è impostata su true, verrà generata un'eccezione quando viene chiamata la funzione deprecata.

Il flag della riga di comando --throw-deprecation e la proprietà process.throwDeprecation hanno la precedenza su --trace-deprecation e process.traceDeprecation.

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

Parametri

Valori restituiti

Funzione deprecata di cui è stato eseguito il wrapping per generare un avviso.

util.diff() confronta due valori stringa o matrice e restituisce una matrice di voci di differenza. Usa l'algoritmo diff myers per calcolare le differenze minime, ovvero lo stesso algoritmo usato internamente dai messaggi di errore dell'asserzione.

Se i valori sono uguali, viene restituita una matrice vuota.

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

Parametri

Valori restituiti

Matrice di voci di differenza. Ogni voce è una matrice con due elementi:

• Indice 0: number codice operazione: -1 per l'eliminazione, 0 per no-op/unchanged, 1 per l'inserimento
• Indice 1: string valore associato all'operazione

Trova il primo valore in una matrice che corrisponde al predicato specificato.

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

Parametri

Valori restituiti

Trova l'indice del primo valore in una matrice che corrisponde al predicato specificato.

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

Parametri

Valori restituiti

Il metodo util.format() restituisce una stringa formattata usando il primo argomento come stringa di formato di printfche può contenere zero o più identificatori di formato. Ogni identificatore viene sostituito con il valore convertito dall'argomento corrispondente. Gli identificatori supportati sono:

Se un identificatore non dispone di un argomento corrispondente, non viene sostituito:

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

I valori che non fanno parte della stringa di formato vengono formattati usando util.inspect() se il tipo non è string.

Se sono presenti più argomenti passati al metodo util.format() rispetto al numero di identificatori, gli argomenti aggiuntivi vengono concatenati alla stringa restituita, separati da spazi:

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

Se il primo argomento non contiene un identificatore di formato valido, util.format() restituisce una stringa che rappresenta la concatenazione di tutti gli argomenti separati da spazi:

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

Se viene passato un solo argomento a util.format(), viene restituito così come è senza formattazione:

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

util.format() è un metodo sincrono destinato a uno strumento di debug. Alcuni valori di input possono avere un sovraccarico significativo delle prestazioni che può bloccare il ciclo di eventi. Usare questa funzione con attenzione e mai in un percorso di codice frequente.

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

Parametri

Valori restituiti

Questa funzione è identica a formato, ad eccezione del fatto che accetta un argomento inspectOptions che specifica le opzioni passate a ispezionare.

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

Parametri

Valori restituiti

Genera un uuid di 20 caratteri.

function generateUUID(): string

Valori restituiti

Restituisce una matrice di oggetti sito di chiamata contenenti lo stack della funzione chiamante.

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

È possibile ricostruire le posizioni originali impostando l'opzione sourceMap su true. Se la mappa di origine non è disponibile, la posizione originale sarà la stessa della posizione corrente. Quando il flag --enable-source-maps è abilitato, ad esempio quando si usa --experimental-transform-types, sourceMap sarà true per impostazione predefinita.

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

Parametri

Valori restituiti

Matrice di oggetti sito di chiamata

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parametri

Valori restituiti

Restituisce un numero casuale

function getRandomValue(): number

Valori restituiti

Restituisce una mappa di tutti i codici di errore di sistema disponibili nell'API Node.js. Il mapping tra i codici di errore e i nomi degli errori è dipendente dalla piattaforma. Vedere Common System Errors per i nomi degli errori comuni.

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

Valori restituiti

Restituisce il messaggio stringa per un codice di errore numerico proveniente da un'API Node.js. Il mapping tra i codici di errore e i messaggi stringa è dipendente dalla piattaforma.

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

Parametri

Valori restituiti

Restituisce il nome della stringa per un codice di errore numerico proveniente da un'API Node.js. Il mapping tra i codici di errore e i nomi degli errori è dipendente dalla piattaforma. Vedere Common System Errors per i nomi degli errori comuni.

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

function getSystemErrorName(err: number): string

Parametri

Valori restituiti

Restituisce l'intervallo di tempo tra due date in millisecondi

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

Parametri

Valori restituiti

L'utilizzo di util.inherits() è sconsigliato. Usare le parole chiave ES6 class e extends per ottenere il supporto dell'ereditarietà a livello di linguaggio. Si noti anche che i due stili sono semanticamente incompatibili.

Ereditare i metodi prototipo da un costruttore in un altro. Il prototipo di constructor verrà impostato su un nuovo oggetto creato da superConstructor.

In questo modo viene aggiunta principalmente una convalida di input all'inizio di Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Per comodità aggiuntiva, superConstructor sarà accessibile tramite la proprietà 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!"

Esempio di ES6 che usa 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)

Parametri

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

Parametri

Valori restituiti

Alias per Array.isArray().

Restituisce true se il object specificato è un Array. In caso contrario, restituisce 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[]

Parametri

Valori restituiti

Restituisce true se il object specificato è un Boolean. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è un Buffer. In caso contrario, restituisce 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

Parametri

Valori restituiti

Controlla se il tipo di incorporamento è per la creazione

function isCreate(embedType: string): boolean

Parametri

Valori restituiti

Restituisce true se il object specificato è un Date. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se esiste un'uguaglianza assoluta tra val1 e val2. In caso contrario, restituisce false.

Per altre informazioni sull'uguaglianza assoluta, vedere assert.deepStrictEqual().

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

Parametri

Valori restituiti

Restituisce true se il object specificato è un Error. In caso contrario, restituisce 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

Questo metodo si basa sul comportamento Object.prototype.toString(). È possibile ottenere un risultato non corretto quando l'argomento object modifica @@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

Parametri

Valori restituiti

Restituisce true se il object specificato è un Function. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è strettamente null. In caso contrario, restituiscefalse.

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

Parametri

Valori restituiti

Restituisce true se il object specificato è null o undefined. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è un Number. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è strettamente un Objecte non unFunction (anche se le funzioni sono oggetti in JavaScript). In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è un tipo primitivo. In caso contrario, restituiscefalse.

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

Parametri

Valori restituiti

Controlla se l'URL di incorporamento è per il report RDL.

function isRDLEmbed(embedUrl: string): boolean

Parametri

Valori restituiti

Restituisce true se il object specificato è un RegExp. In caso contrario, restituisce 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

Parametri

Valori restituiti

Controlla se il report viene salvato.

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

Parametri

Valori restituiti

Restituisce true se il object specificato è un string. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è un Symbol. In caso contrario, restituisce 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

Parametri

Valori restituiti

Restituisce true se il object specificato è undefined. In caso contrario, restituisce 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

Parametri

Valori restituiti

Il metodo util.log() stampa il string specificato per stdout con un timestamp incluso.

import util from 'node:util';

util.log('Timestamped message.');

function log(string: string)

Parametri

Fornisce un'API di livello superiore per l'analisi degli argomenti della riga di comando rispetto all'interazione diretta con process.argv. Accetta una specifica per gli argomenti previsti e restituisce un oggetto strutturato con le opzioni analizzate e i posizionali.

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>

Parametri

Valori restituiti

Argomenti della riga di comando analizzati:

Stabilità: 1.1 - Sviluppo attivo Dato un esempio .env file:

import { parseEnv } from 'node:util';

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

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

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>

Parametri

Valori restituiti

function promisify(fn: Function): Function

Parametri

Valori restituiti

Genera un evento personalizzato con i dati dell'evento nell'elemento HTML specificato.

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

Parametri

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

Parametri

Abilitare o disabilitare la stampa di un'analisi dello stack in SIGINT. L'API è disponibile solo nel thread principale.

function setTraceSigInt(enable: boolean)

Parametri

Restituisce str con eventuali codici di escape ANSI rimossi.

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

function stripVTControlCharacters(str: string): string

Parametri

Valori restituiti

Questa funzione restituisce un testo formattato considerando l'oggetto passato per la format stampa in un terminale. È a conoscenza delle funzionalità del terminale e agisce in base alla configurazione impostata tramite NO_COLORle NODE_DISABLE_COLORS variabili di ambiente e 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 fornisce anche formati di testo come italice underline ed è possibile combinare entrambi:

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

Quando si passa una matrice di formati, l'ordine del formato applicato viene lasciato a destra in modo che lo stile seguente possa sovrascrivere quello precedente.

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

Il valore none di formato speciale non applica stili aggiuntivi al testo.

L'elenco completo dei formati è disponibile in modificatori.

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

Parametri

Valori restituiti

Restituisce il string dopo aver sostituito qualsiasi punto di codice surrogato (o in modo equivalente, qualsiasi unità di codice surrogato non abbinato) con il carattere di sostituzione Unicode U+FFFD.

function toUSVString(string: string): string

Parametri

Valori restituiti

Crea e restituisce un'istanza di AbortController la cui AbortSignal è contrassegnata come trasferiscibile e può essere usata con structuredClone() o postMessage().

function transferableAbortController(): AbortController

Valori restituiti

Un abortController trasferiscibile

Contrassegna il AbortSignal specificato come trasferiscibile in modo che possa essere usato constructuredClone() e postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parametri

Valori restituiti

Lo stesso 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