Udostępnij za pomocą

util module

Pakiet:
powerbi-client

Moduł node:util obsługuje potrzeby Node.js wewnętrznych interfejsów API. Wiele narzędzi jest również przydatnych dla deweloperów aplikacji i modułów. Aby uzyskać do niego dostęp:

import util from 'node:util';

Zobacz source

Klasy

MIMEParams

Interfejs API MIMEParams zapewnia dostęp do odczytu i zapisu do parametrów MIMEType.
MIMEType

Implementacja klasy MIMEType.

Zgodnie z konwencjami przeglądarki wszystkie właściwości obiektów MIMEType są implementowane jako metody pobierające i ustawiane w prototypie klasy, a nie jako właściwości danych w samym obiekcie.

Ciąg MIME jest ciągiem ustrukturyzowanym zawierającym wiele znaczących składników. Podczas analizowania zwracany jest obiekt MIMEType zawierający właściwości dla każdego z tych składników.
TextDecoder

Implementacja interfejsu API standardowego kodowania WHATWG .

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

Implementacja interfejsu API standardowego kodowania WHATWG . Wszystkie wystąpienia TextEncoder obsługują tylko kodowanie UTF-8.

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

Klasa TextEncoder jest również dostępna w obiekcie globalnym.

Interfejsy

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

Aliasy typu

CustomInspectFunction
CustomPromisify
DebugLoggerFunction
DiffEntry
ParseArgsOptionsType

Typ argumentu używanego w parseArgs.
Style

Funkcje

aborted(AbortSignal, any)

Nasłuchuje zdarzenia przerwania w podanym signal i zwraca obietnicę, która rozwiązuje się po przerwaniu signal. Jeśli resource zostanie podana, słabo odwołuje się do skojarzonego obiektu operacji, więc jeśli resource jest wyrzucana śmieci przed przerwaniami signal, zwracana obietnica pozostanie w toku. Zapobiega to wyciekom pamięci w długotrwałych lub niemożliwych do anulowania operacjach.

import { aborted } from 'node:util';

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

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

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

Dodaje parametr do danego adresu URL
assign(any[])

Kopiuje wartości wszystkich właściwości wyliczalnych z co najmniej jednego obiektu źródłowego do obiektu docelowego i zwraca obiekt docelowy.
autoAuthInEmbedUrl(string)

Sprawdza, czy adres URL osadzania zawiera autoAuth=true.
callbackify(() => Promise<void>)

Pobiera funkcję async (lub funkcję zwracającą Promise) i zwraca funkcję po stylu wywołania zwrotnego pierwszego błędu, tj. biorąc wywołanie zwrotne (err, value) => ... jako ostatni argument. W wywołaniu zwrotnym pierwszym argumentem będzie przyczyna odrzucenia (lub null, jeśli Promise rozwiązana), a drugim argumentem będzie rozpoznana wartość.

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

Drukuje:

hello world

Wywołanie zwrotne jest wykonywane asynchronicznie i będzie miało ograniczony ślad stosu. Jeśli wywołanie zwrotne jest zwracane, proces będzie emitować zdarzenie 'uncaughtException', a jeśli nie zostanie obsłużone, zakończy się.

Ponieważ null ma specjalne znaczenie jako pierwszy argument wywołania zwrotnego, jeśli opakowana funkcja odrzuca Promise z falsyną wartością jako przyczyną, wartość jest owinięta w Error z oryginalną wartością przechowywaną w polu o nazwie reason.

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

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});
callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>)
callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>)
callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>)
callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>)
callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>)
callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>)
callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>)
callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>)
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
callbackify<T1>((arg1: T1) => Promise<void>)
callbackify<TResult>(() => Promise<TResult>)
createRandomString()

Generuje losowy ciąg od 5 do 6 znaków.
debuglog(string, (fn: DebugLoggerFunction) => void)

Metoda util.debuglog() służy do tworzenia funkcji, która warunkowo zapisuje komunikaty debugowania w oparciu stderr o istnienie zmiennej środowiskowej NODE_DEBUG . Jeśli nazwa section pojawi się w wartości tej zmiennej środowiskowej, zwracana funkcja działa podobnie do console.error(). Jeśli nie, zwracana funkcja jest no-op.

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

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

Jeśli ten program zostanie uruchomiony z NODE_DEBUG=foo w środowisku, dane wyjściowe będą wyglądać mniej więcej tak:

FOO 3245: hello from foo [123]

gdzie 3245 jest identyfikatorem procesu. Jeśli nie zostanie uruchomiona z tym zestawem zmiennych środowiskowych, nie będzie ona drukować niczego.

section obsługuje również symbol wieloznaczny:

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

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

jeśli jest uruchamiany z NODE_DEBUG=foo* w środowisku, dane wyjściowe będą wyglądać mniej więcej tak:

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

W zmiennej środowiskowej section można określić wiele nazw rozdzielonych NODE_DEBUG przecinkami: NODE_DEBUG=fs,net,tls.

Opcjonalny argument callback może służyć do zastępowania funkcji rejestrowania inną funkcją, która nie ma żadnych inicjalizacji ani niepotrzebnych zawijania.

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

Metoda util.deprecate() zawija fn (która może być funkcją lub klasą) w taki sposób, że jest oznaczona jako przestarzała.

import { deprecate } from 'node:util';

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

Po wywołaniu util.deprecate() zwróci funkcję, która będzie emitować DeprecationWarning przy użyciu zdarzenia 'warning'. Ostrzeżenie zostanie wyemitowane i wydrukowane w celu stderr przy pierwszym wywołaniu zwróconej funkcji. Po emitowaniu ostrzeżenia opakowana funkcja jest wywoływana bez emitowania ostrzeżenia.

Jeśli ta sama opcjonalna code jest dostarczana w wielu wywołaniach do util.deprecate(), ostrzeżenie będzie emitowane tylko raz dla tego 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

Jeśli są używane flagi wiersza polecenia --no-deprecation lub --no-warnings lub jeśli właściwość process.noDeprecation jest ustawiona na trueprzed do pierwszego ostrzeżenia o wycofaniu, metoda util.deprecate() nic nie robi.

Jeśli ustawiono flagi wiersza polecenia --trace-deprecation lub --trace-warnings lub właściwość process.traceDeprecation ma wartość true, ostrzeżenie i ślad stosu są drukowane w celu stderr wywołania przestarzałej funkcji.

Jeśli ustawiono flagę wiersza polecenia --throw-deprecation lub właściwość process.throwDeprecation została ustawiona na true, zostanie zgłoszony wyjątek po wywołaniu przestarzałej funkcji.

Flaga wiersza polecenia --throw-deprecation i właściwość process.throwDeprecation mają pierwszeństwo przed --trace-deprecation i process.traceDeprecation.
diff(string | (readonly string[]), string | (readonly string[]))

util.diff() Porównuje dwa ciągi lub wartości tablicy i zwraca tablicę wpisów różnicy. Używa algorytmu różnic Myers do obliczania minimalnych różnic, który jest tym samym algorytmem używanym wewnętrznie przez komunikaty o błędach asercji.

Jeśli wartości są równe, zwracana jest pusta tablica.

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

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

Znajduje pierwszą wartość w tablicy zgodnej z określonym predykatem.
findIndex<T>((x: T) => boolean, T[])

Znajduje indeks pierwszej wartości w tablicy zgodnej z określonym predykatem.
format(any, any[])

Metoda util.format() zwraca sformatowany ciąg przy użyciu pierwszego argumentu jako ciągu formatu printf, który może zawierać zero lub więcej specyfikatorów formatu. Każdy specyfikator jest zastępowany przekonwertowaną wartością z odpowiedniego argumentu. Obsługiwane specyfikatory to:

Jeśli specyfikator nie ma odpowiedniego argumentu, nie zostanie zastąpiony:

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

Wartości, które nie są częścią ciągu formatu, są formatowane przy użyciu util.inspect(), jeśli ich typ nie jest string.

Jeśli do metody util.format() jest przekazywanych więcej argumentów niż liczba specyfikatorów, dodatkowe argumenty są łączone z zwracanym ciągiem rozdzielonym spacjami:

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

Jeśli pierwszy argument nie zawiera prawidłowego specyfikatora formatu, util.format() zwraca ciąg, który jest łączeniem wszystkich argumentów rozdzielonych spacjami:

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

Jeśli tylko jeden argument jest przekazywany do util.format(), jest zwracany jako bez żadnego formatowania:

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

util.format() to metoda synchroniczna, która jest przeznaczona jako narzędzie do debugowania. Niektóre wartości wejściowe mogą mieć znaczne obciążenie związane z wydajnością, które mogą blokować pętlę zdarzeń. Tej funkcji należy używać z ostrożnością i nigdy w gorącej ścieżce kodu.
formatWithOptions(InspectOptions, any, any[])

Ta funkcja jest identyczna z formatem , z wyjątkiem tego, że przyjmuje argument inspectOptions, który określa opcje przekazywane do inspekcji.

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

Generuje identyfikator uuid 20 znaków.
getCallSites(GetCallSitesOptions)
getCallSites(number, GetCallSitesOptions)

Zwraca tablicę obiektów lokacji wywołań zawierających stos funkcji wywołującej.

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

Można odtworzyć oryginalne lokalizacje, ustawiając opcję sourceMap na true. Jeśli mapa źródłowa jest niedostępna, oryginalna lokalizacja będzie taka sama jak bieżąca lokalizacja. Gdy flaga --enable-source-maps jest włączona, na przykład w przypadku korzystania z --experimental-transform-typessourceMap będzie domyślnie true.

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

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

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

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

Zwraca liczbę losową
getSystemErrorMap()

Zwraca mapę wszystkich kodów błędów systemowych dostępnych w interfejsie API Node.js. Mapowanie między kodami błędów a nazwami błędów jest zależne od platformy. Zobacz Common System Errors nazwy typowych błędów.

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

Zwraca komunikat ciągu dla liczbowego kodu błędu pochodzącego z interfejsu API Node.js. Mapowanie między kodami błędów i komunikatami ciągów jest zależne od platformy.

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

Zwraca nazwę ciągu dla kodu błędu liczbowego pochodzącego z interfejsu API Node.js. Mapowanie między kodami błędów a nazwami błędów jest zależne od platformy. Zobacz Common System Errors nazwy typowych błędów.

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

Zwraca interwał czasu między dwiema datami w milisekundach
inherits(unknown, unknown)

Nie zaleca się używania util.inherits(). Użyj słów kluczowych class i extends ES6, aby uzyskać obsługę dziedziczenia na poziomie języka. Należy również zauważyć, że dwa style są semantycznie niezgodne.

Dziedzicz metody prototypowe z jednego konstruktora do innego. Prototyp constructor zostanie ustawiony na nowy obiekt utworzony na podstawie superConstructor.

Powoduje to głównie dodanie weryfikacji danych wejściowych na podstawie elementu Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Jako dodatkowa wygoda superConstructor będzie dostępna za pośrednictwem obiektu 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!"

Przykład ES6 korzystający z class i extends:

import EventEmitter from 'node:events';

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

const stream = new MyStream();

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

Metoda util.inspect() zwraca reprezentację ciągu object, która jest przeznaczona do debugowania. Dane wyjściowe util.inspect mogą ulec zmianie w dowolnym momencie i nie powinny być zależne od programowego. Można przekazać dodatkowe options, które zmieniają wynik. util.inspect() użyje nazwy i/lub Symbol.toStringTag właściwości konstruktora, aby wprowadzić rozpoznawalny tag dla sprawdzanej wartości.

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

Odwołania cykliczne wskazują na ich kotwicę przy użyciu indeksu odwołania:

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

Poniższy przykład sprawdza wszystkie właściwości obiektu util:

import util from 'node:util';

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

W poniższym przykładzie wyróżniono efekt compact opcji:

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.

Opcja showHidden umożliwia inspekcję WeakMap i WeakSet wpisów. Jeśli istnieje więcej wpisów niż maxArrayLength, nie ma gwarancji, które wpisy są wyświetlane. Oznacza to, że pobieranie tych samych wpisów WeakSet dwa razy może spowodować powstanie różnych danych wyjściowych. Ponadto wpisy bez pozostałych silnych odwołań mogą być w dowolnym momencie wyrzucane śmieci.

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

Opcja sorted gwarantuje, że kolejność wstawiania właściwości obiektu nie ma wpływu na wynik 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 }),
);

Opcja numericSeparator dodaje podkreślenie co trzy cyfry do wszystkich liczb.

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() jest metodą synchroniczną przeznaczoną do debugowania. Maksymalna długość danych wyjściowych wynosi około 128 MiB. Dane wejściowe, które powodują dłuższe dane wyjściowe, zostaną obcięte.
inspect(any, InspectOptions)
isArray(unknown)

Alias dla elementu Array.isArray().

Zwraca true, jeśli dana object jest Array. W przeciwnym razie zwraca wartość false.

import util from 'node:util';

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

Sprawdza, czy typ osadzania jest przeznaczony do utworzenia
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Zwraca true, jeśli istnieje głęboka ścisła równość między val1 a val2. W przeciwnym razie zwraca wartość false.

Aby uzyskać więcej informacji na temat głębokiej równości, zobacz assert.deepStrictEqual().
isRDLEmbed(string)

Sprawdza, czy adres URL osadzania jest przeznaczony dla raportu języka RDL.
isSavedInternal(HttpPostMessage, string, Window)

Sprawdza, czy raport jest zapisany.
parseArgs<T>(T)

Udostępnia interfejs API wyższego poziomu do analizowania argumentów wiersza polecenia niż bezpośrednia interakcja z process.argv. Przyjmuje specyfikację oczekiwanych argumentów i zwraca obiekt ustrukturyzowany z analizowanymi opcjami i pozycjami.

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

Stabilność: 1.1 — Aktywny rozwój, biorąc pod uwagę przykładowy plik .env:

import { parseEnv } from 'node:util';

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

Przyjmuje funkcję po typowym stylu wywołania zwrotnego typu "pierwszy błąd", tj. biorąc (err, value) => ... wywołanie zwrotne jako ostatni argument i zwraca wersję zwracającą obietnice.

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

Możesz też użyć 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();

Jeśli istnieje original[util.promisify.custom] właściwość , promisify zwróci jej wartość, zobacz Niestandardowe funkcje promisified.

promisify() zakłada, że original jest funkcją przyjmującą wywołanie zwrotne jako ostatni argument we wszystkich przypadkach. Jeśli original nie jest funkcją, promisify() zgłosi błąd. Jeśli original jest funkcją, ale jej ostatni argument nie jest wywołaniem zwrotnym pierwszego błędu, nadal będzie przekazywany wywołanie zwrotne typu "pierwszy" jako ostatni argument.

Użycie promisify() metod klasy lub innych metod korzystających z this może nie działać zgodnie z oczekiwaniami, chyba że są obsługiwane specjalnie:

import { promisify } from 'node:util';

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

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

const foo = new Foo();

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

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

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
raiseCustomEvent(HTMLElement, string, any)

Wywołuje zdarzenie niestandardowe z danymi zdarzenia w określonym elemecie HTML.
remove<T>((x: T) => boolean, T[])
setTraceSigInt(boolean)

Włącz lub wyłącz drukowanie śledzenia stosu w programie SIGINT. Interfejs API jest dostępny tylko w wątku głównym.
stripVTControlCharacters(string)

Zwraca str z usuniętymi kodami ucieczki ANSI.

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

Ta funkcja zwraca sformatowany tekst uwzględniający format przekazany do drukowania w terminalu. Jest on świadomy możliwości terminalu i działa zgodnie z konfiguracją ustawioną za pośrednictwem NO_COLORzmiennych środowiskowych i NODE_DISABLE_COLORS . 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 również udostępnia formaty tekstowe, takie jak italici underline, i można połączyć oba te formaty:

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

Podczas przekazywania tablicy formatów kolejność zastosowanego formatu jest od lewej do prawej, więc następujący styl może zastąpić poprzedni.

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

Wartość none formatu specjalnego nie stosuje dodatkowego stylu do tekstu.

Pełną listę formatów można znaleźć w modyfikatorów.
toUSVString(string)

Zwraca string po zastąpieniu wszelkich zastępczych punktów kodu (lub równoważnej, wszelkich nieparzystych jednostek kodu zastępczego) znakiem Unicode "zastępczym" U+FFFD.
transferableAbortController()

Tworzy i zwraca wystąpienie AbortController, którego AbortSignal jest oznaczone jako możliwe do przeniesienia i może być używane z structuredClone() lub postMessage().
transferableAbortSignal(AbortSignal)

Oznacza podane AbortSignal jako możliwe do przeniesienia, aby można było go używać zstructuredClone() i postMessage().

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

Szczegóły funkcji

aborted(AbortSignal, any)

Nasłuchuje zdarzenia przerwania w podanym signal i zwraca obietnicę, która rozwiązuje się po przerwaniu signal. Jeśli resource zostanie podana, słabo odwołuje się do skojarzonego obiektu operacji, więc jeśli resource jest wyrzucana śmieci przed przerwaniami signal, zwracana obietnica pozostanie w toku. Zapobiega to wyciekom pamięci w długotrwałych lub niemożliwych do anulowania operacjach.

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>

Parametry

signal

AbortSignal

resource

any

Każdy obiekt bez wartości null związany z operacją abortable i przechowywany słabo. Jeśli resource jest wyrzucany śmieci przed przerwaniem signal, obietnica pozostaje oczekująca, co pozwoli Node.js zatrzymać śledzenie. Pomaga to zapobiegać wyciekom pamięci w długotrwałych lub niemożliwych do anulowania operacjach.

Zwraca

Promise<void>

addParamToUrl(string, string, string)

Dodaje parametr do danego adresu URL

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

Parametry

url

string

paramName

string

value

string

Zwraca

string

assign(any[])

Kopiuje wartości wszystkich właściwości wyliczalnych z co najmniej jednego obiektu źródłowego do obiektu docelowego i zwraca obiekt docelowy.

function assign(args: any[]): any

Parametry

args

any[]

Zwraca

any

autoAuthInEmbedUrl(string)

Sprawdza, czy adres URL osadzania zawiera autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parametry

embedUrl

string

Zwraca

boolean

callbackify(() => Promise<void>)

Pobiera funkcję async (lub funkcję zwracającą Promise) i zwraca funkcję po stylu wywołania zwrotnego pierwszego błędu, tj. biorąc wywołanie zwrotne (err, value) => ... jako ostatni argument. W wywołaniu zwrotnym pierwszym argumentem będzie przyczyna odrzucenia (lub null, jeśli Promise rozwiązana), a drugim argumentem będzie rozpoznana wartość.

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

Drukuje:

hello world

Wywołanie zwrotne jest wykonywane asynchronicznie i będzie miało ograniczony ślad stosu. Jeśli wywołanie zwrotne jest zwracane, proces będzie emitować zdarzenie 'uncaughtException', a jeśli nie zostanie obsłużone, zakończy się.

Ponieważ null ma specjalne znaczenie jako pierwszy argument wywołania zwrotnego, jeśli opakowana funkcja odrzuca Promise z falsyną wartością jako przyczyną, wartość jest owinięta w Error z oryginalną wartością przechowywaną w polu o nazwie reason.

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

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

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

Parametry

fn

() => Promise<void>

Funkcja async

Zwraca

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

funkcja stylu wywołania zwrotnego

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

(arg1: T1) => Promise<TResult>

Zwraca

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

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

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

Parametry

fn

(arg1: T1) => Promise<void>

Zwraca

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

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

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

Parametry

fn

() => Promise<TResult>

Zwraca

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

createRandomString()

Generuje losowy ciąg od 5 do 6 znaków.

function createRandomString(): string

Zwraca

string

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

Metoda util.debuglog() służy do tworzenia funkcji, która warunkowo zapisuje komunikaty debugowania w oparciu stderr o istnienie zmiennej środowiskowej NODE_DEBUG . Jeśli nazwa section pojawi się w wartości tej zmiennej środowiskowej, zwracana funkcja działa podobnie do console.error(). Jeśli nie, zwracana funkcja jest no-op.

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

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

Jeśli ten program zostanie uruchomiony z NODE_DEBUG=foo w środowisku, dane wyjściowe będą wyglądać mniej więcej tak:

FOO 3245: hello from foo [123]

gdzie 3245 jest identyfikatorem procesu. Jeśli nie zostanie uruchomiona z tym zestawem zmiennych środowiskowych, nie będzie ona drukować niczego.

section obsługuje również symbol wieloznaczny:

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

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

jeśli jest uruchamiany z NODE_DEBUG=foo* w środowisku, dane wyjściowe będą wyglądać mniej więcej tak:

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

W zmiennej środowiskowej section można określić wiele nazw rozdzielonych NODE_DEBUG przecinkami: NODE_DEBUG=fs,net,tls.

Opcjonalny argument callback może służyć do zastępowania funkcji rejestrowania inną funkcją, która nie ma żadnych inicjalizacji ani niepotrzebnych zawijania.

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

Parametry

section

string

Ciąg identyfikujący część aplikacji, dla której jest tworzona funkcja debuglog.

callback

(fn: DebugLoggerFunction) => void

Wywołanie zwrotne wywoływane po raz pierwszy funkcji rejestrowania jest wywoływane z argumentem funkcji, który jest bardziej zoptymalizowaną funkcją rejestrowania.

Zwraca

DebugLogger

Funkcja rejestrowania

deprecate<T>(T, string, string)

Metoda util.deprecate() zawija fn (która może być funkcją lub klasą) w taki sposób, że jest oznaczona jako przestarzała.

import { deprecate } from 'node:util';

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

Po wywołaniu util.deprecate() zwróci funkcję, która będzie emitować DeprecationWarning przy użyciu zdarzenia 'warning'. Ostrzeżenie zostanie wyemitowane i wydrukowane w celu stderr przy pierwszym wywołaniu zwróconej funkcji. Po emitowaniu ostrzeżenia opakowana funkcja jest wywoływana bez emitowania ostrzeżenia.

Jeśli ta sama opcjonalna code jest dostarczana w wielu wywołaniach do util.deprecate(), ostrzeżenie będzie emitowane tylko raz dla tego 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

Jeśli są używane flagi wiersza polecenia --no-deprecation lub --no-warnings lub jeśli właściwość process.noDeprecation jest ustawiona na trueprzed do pierwszego ostrzeżenia o wycofaniu, metoda util.deprecate() nic nie robi.

Jeśli ustawiono flagi wiersza polecenia --trace-deprecation lub --trace-warnings lub właściwość process.traceDeprecation ma wartość true, ostrzeżenie i ślad stosu są drukowane w celu stderr wywołania przestarzałej funkcji.

Jeśli ustawiono flagę wiersza polecenia --throw-deprecation lub właściwość process.throwDeprecation została ustawiona na true, zostanie zgłoszony wyjątek po wywołaniu przestarzałej funkcji.

Flaga wiersza polecenia --throw-deprecation i właściwość process.throwDeprecation mają pierwszeństwo przed --trace-deprecation i process.traceDeprecation.

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

Parametry

fn

T

Funkcja, która jest przestarzała.

msg

string

Komunikat ostrzegawczy wyświetlany po wywołaniu przestarzałej funkcji.

code

string

Kod wycofania. Aby uzyskać listę kodów, zobacz list of deprecated APIs.

Zwraca

T

Przestarzała funkcja opakowana w celu emitowania ostrzeżenia.

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

util.diff() Porównuje dwa ciągi lub wartości tablicy i zwraca tablicę wpisów różnicy. Używa algorytmu różnic Myers do obliczania minimalnych różnic, który jest tym samym algorytmem używanym wewnętrznie przez komunikaty o błędach asercji.

Jeśli wartości są równe, zwracana jest pusta tablica.

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

Parametry

actual

string | (readonly string[])

Pierwsza wartość do porównania

expected

string | (readonly string[])

Druga wartość do porównania

Zwraca

DiffEntry[]

Tablica wpisów różnic. Każdy wpis jest tablicą z dwoma elementami:

  • Indeks 0: number kod operacji: -1 dla usuwania, 0 dla no-op/bez zmian, 1 dla wstawiania
  • Indeks 1: string wartość skojarzona z operacją

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

Znajduje pierwszą wartość w tablicy zgodnej z określonym predykatem.

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

Parametry

predicate

(x: T) => boolean

xs

T[]

Zwraca

T

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

Znajduje indeks pierwszej wartości w tablicy zgodnej z określonym predykatem.

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

Parametry

predicate

(x: T) => boolean

xs

T[]

Zwraca

number

format(any, any[])

Metoda util.format() zwraca sformatowany ciąg przy użyciu pierwszego argumentu jako ciągu formatu printf, który może zawierać zero lub więcej specyfikatorów formatu. Każdy specyfikator jest zastępowany przekonwertowaną wartością z odpowiedniego argumentu. Obsługiwane specyfikatory to:

Jeśli specyfikator nie ma odpowiedniego argumentu, nie zostanie zastąpiony:

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

Wartości, które nie są częścią ciągu formatu, są formatowane przy użyciu util.inspect(), jeśli ich typ nie jest string.

Jeśli do metody util.format() jest przekazywanych więcej argumentów niż liczba specyfikatorów, dodatkowe argumenty są łączone z zwracanym ciągiem rozdzielonym spacjami:

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

Jeśli pierwszy argument nie zawiera prawidłowego specyfikatora formatu, util.format() zwraca ciąg, który jest łączeniem wszystkich argumentów rozdzielonych spacjami:

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

Jeśli tylko jeden argument jest przekazywany do util.format(), jest zwracany jako bez żadnego formatowania:

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

util.format() to metoda synchroniczna, która jest przeznaczona jako narzędzie do debugowania. Niektóre wartości wejściowe mogą mieć znaczne obciążenie związane z wydajnością, które mogą blokować pętlę zdarzeń. Tej funkcji należy używać z ostrożnością i nigdy w gorącej ścieżce kodu.

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

Parametry

format

any

Ciąg formatu przypominający printf.

param

any[]

Zwraca

string

formatWithOptions(InspectOptions, any, any[])

Ta funkcja jest identyczna z formatem , z wyjątkiem tego, że przyjmuje argument inspectOptions, który określa opcje przekazywane do inspekcji.

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

Parametry

inspectOptions
InspectOptions
format

any

param

any[]

Zwraca

string

generateUUID()

Generuje identyfikator uuid 20 znaków.

function generateUUID(): string

Zwraca

string

getCallSites(GetCallSitesOptions) 

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parametry

options

GetCallSitesOptions

Zwraca

CallSiteObject[]

getCallSites(number, GetCallSitesOptions)

Zwraca tablicę obiektów lokacji wywołań zawierających stos funkcji wywołującej.

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

Można odtworzyć oryginalne lokalizacje, ustawiając opcję sourceMap na true. Jeśli mapa źródłowa jest niedostępna, oryginalna lokalizacja będzie taka sama jak bieżąca lokalizacja. Gdy flaga --enable-source-maps jest włączona, na przykład w przypadku korzystania z --experimental-transform-typessourceMap będzie domyślnie true.

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

Parametry

frameCount

number

Liczba ramek do przechwycenia jako obiektów lokacji wywołania. Domyślne:10. Dozwolony zakres wynosi od 1 do 200.

options

GetCallSitesOptions

Zwraca

CallSiteObject[]

Tablica obiektów lokacji wywołań

getRandomValue()

Zwraca liczbę losową

function getRandomValue(): number

Zwraca

number

getSystemErrorMap()

Zwraca mapę wszystkich kodów błędów systemowych dostępnych w interfejsie API Node.js. Mapowanie między kodami błędów a nazwami błędów jest zależne od platformy. Zobacz Common System Errors nazwy typowych błędów.

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

Zwraca

Map<number, [string, string]>

getSystemErrorMessage(number)

Zwraca komunikat ciągu dla liczbowego kodu błędu pochodzącego z interfejsu API Node.js. Mapowanie między kodami błędów i komunikatami ciągów jest zależne od platformy.

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

Parametry

err

number

Zwraca

string

getSystemErrorName(number)

Zwraca nazwę ciągu dla kodu błędu liczbowego pochodzącego z interfejsu API Node.js. Mapowanie między kodami błędów a nazwami błędów jest zależne od platformy. Zobacz Common System Errors nazwy typowych błędów.

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

function getSystemErrorName(err: number): string

Parametry

err

number

Zwraca

string

getTimeDiffInMilliseconds(Date, Date)

Zwraca interwał czasu między dwiema datami w milisekundach

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

Parametry

start

Date

end

Date

Zwraca

number

inherits(unknown, unknown)

Nie zaleca się używania util.inherits(). Użyj słów kluczowych class i extends ES6, aby uzyskać obsługę dziedziczenia na poziomie języka. Należy również zauważyć, że dwa style są semantycznie niezgodne.

Dziedzicz metody prototypowe z jednego konstruktora do innego. Prototyp constructor zostanie ustawiony na nowy obiekt utworzony na podstawie superConstructor.

Powoduje to głównie dodanie weryfikacji danych wejściowych na podstawie elementu Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Jako dodatkowa wygoda superConstructor będzie dostępna za pośrednictwem obiektu 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!"

Przykład ES6 korzystający z class i 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)

Parametry

constructor

unknown

superConstructor

unknown

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

Metoda util.inspect() zwraca reprezentację ciągu object, która jest przeznaczona do debugowania. Dane wyjściowe util.inspect mogą ulec zmianie w dowolnym momencie i nie powinny być zależne od programowego. Można przekazać dodatkowe options, które zmieniają wynik. util.inspect() użyje nazwy i/lub Symbol.toStringTag właściwości konstruktora, aby wprowadzić rozpoznawalny tag dla sprawdzanej wartości.

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

Odwołania cykliczne wskazują na ich kotwicę przy użyciu indeksu odwołania:

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

Poniższy przykład sprawdza wszystkie właściwości obiektu util:

import util from 'node:util';

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

W poniższym przykładzie wyróżniono efekt compact opcji:

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.

Opcja showHidden umożliwia inspekcję WeakMap i WeakSet wpisów. Jeśli istnieje więcej wpisów niż maxArrayLength, nie ma gwarancji, które wpisy są wyświetlane. Oznacza to, że pobieranie tych samych wpisów WeakSet dwa razy może spowodować powstanie różnych danych wyjściowych. Ponadto wpisy bez pozostałych silnych odwołań mogą być w dowolnym momencie wyrzucane śmieci.

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

Opcja sorted gwarantuje, że kolejność wstawiania właściwości obiektu nie ma wpływu na wynik 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 }),
);

Opcja numericSeparator dodaje podkreślenie co trzy cyfry do wszystkich liczb.

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() jest metodą synchroniczną przeznaczoną do debugowania. Maksymalna długość danych wyjściowych wynosi około 128 MiB. Dane wejściowe, które powodują dłuższe dane wyjściowe, zostaną obcięte.

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

Parametry

object

any

Dowolny kod pierwotny języka JavaScript lub Object.

showHidden

boolean

depth

null | number

color

boolean

Zwraca

string

Reprezentacja object.

inspect(any, InspectOptions) 

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

Parametry

object

any

options
InspectOptions

Zwraca

string

isArray(unknown)

Ostrzeżenie

Ten interfejs API jest już przestarzały.

Since v4.0.0 - Use isArray instead.

Alias dla elementu Array.isArray().

Zwraca true, jeśli dana object jest Array. W przeciwnym razie zwraca wartość 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

Parametry

object

unknown

Zwraca

object

isCreate(string)

Sprawdza, czy typ osadzania jest przeznaczony do utworzenia

function isCreate(embedType: string): boolean

Parametry

embedType

string

Zwraca

boolean

isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Zwraca true, jeśli istnieje głęboka ścisła równość między val1 a val2. W przeciwnym razie zwraca wartość false.

Aby uzyskać więcej informacji na temat głębokiej równości, zobacz assert.deepStrictEqual().

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

Parametry

val1

unknown

val2

unknown

options
IsDeepStrictEqualOptions

Zwraca

boolean

isRDLEmbed(string)

Sprawdza, czy adres URL osadzania jest przeznaczony dla raportu języka RDL.

function isRDLEmbed(embedUrl: string): boolean

Parametry

embedUrl

string

Zwraca

boolean

isSavedInternal(HttpPostMessage, string, Window)

Sprawdza, czy raport jest zapisany.

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

Parametry

hpm

HttpPostMessage

uid

string

contentWindow

Window

Zwraca

Promise<boolean>

parseArgs<T>(T)

Udostępnia interfejs API wyższego poziomu do analizowania argumentów wiersza polecenia niż bezpośrednia interakcja z process.argv. Przyjmuje specyfikację oczekiwanych argumentów i zwraca obiekt ustrukturyzowany z analizowanymi opcjami i pozycjami.

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>

Parametry

config

T

Służy do podawania argumentów analizowania i konfigurowania analizatora. config obsługuje następujące właściwości:

Zwraca

ParsedResults<T>

Przeanalizowane argumenty wiersza polecenia:

parseEnv(string)

Stabilność: 1.1 — Aktywny rozwój, biorąc pod uwagę przykładowy plik .env:

import { parseEnv } from 'node:util';

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

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

Parametry

content

string

Nieprzetworzona zawartość pliku .env.

Zwraca

NodeJS.Dict<string>

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

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

Parametry

fn

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

Zwraca

() => Promise<void>

promisify(Function) 

function promisify(fn: Function): Function

Parametry

fn

Function

Zwraca

Function

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

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

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

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

Parametry

fn

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

Zwraca

(arg1: T1) => Promise<TResult>

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

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

Parametry

fn

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

Zwraca

(arg1: T1) => Promise<void>

promisify<TCustom>(CustomPromisify<TCustom>)

Przyjmuje funkcję po typowym stylu wywołania zwrotnego typu "pierwszy błąd", tj. biorąc (err, value) => ... wywołanie zwrotne jako ostatni argument i zwraca wersję zwracającą obietnice.

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

Możesz też użyć 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();

Jeśli istnieje original[util.promisify.custom] właściwość , promisify zwróci jej wartość, zobacz Niestandardowe funkcje promisified.

promisify() zakłada, że original jest funkcją przyjmującą wywołanie zwrotne jako ostatni argument we wszystkich przypadkach. Jeśli original nie jest funkcją, promisify() zgłosi błąd. Jeśli original jest funkcją, ale jej ostatni argument nie jest wywołaniem zwrotnym pierwszego błędu, nadal będzie przekazywany wywołanie zwrotne typu "pierwszy" jako ostatni argument.

Użycie promisify() metod klasy lub innych metod korzystających z this może nie działać zgodnie z oczekiwaniami, chyba że są obsługiwane specjalnie:

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

Parametry

fn

CustomPromisify<TCustom>

Zwraca

TCustom

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

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

Parametry

fn

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

Zwraca

() => Promise<TResult>

raiseCustomEvent(HTMLElement, string, any)

Wywołuje zdarzenie niestandardowe z danymi zdarzenia w określonym elemecie HTML.

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

Parametry

element

HTMLElement

eventName

string

eventData

any

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

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

Parametry

predicate

(x: T) => boolean

xs

T[]

setTraceSigInt(boolean)

Włącz lub wyłącz drukowanie śledzenia stosu w programie SIGINT. Interfejs API jest dostępny tylko w wątku głównym.

function setTraceSigInt(enable: boolean)

Parametry

enable

boolean

stripVTControlCharacters(string)

Zwraca str z usuniętymi kodami ucieczki ANSI.

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

function stripVTControlCharacters(str: string): string

Parametry

str

string

Zwraca

string

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

Ta funkcja zwraca sformatowany tekst uwzględniający format przekazany do drukowania w terminalu. Jest on świadomy możliwości terminalu i działa zgodnie z konfiguracją ustawioną za pośrednictwem NO_COLORzmiennych środowiskowych i NODE_DISABLE_COLORS . 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 również udostępnia formaty tekstowe, takie jak italici underline, i można połączyć oba te formaty:

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

Podczas przekazywania tablicy formatów kolejność zastosowanego formatu jest od lewej do prawej, więc następujący styl może zastąpić poprzedni.

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

Wartość none formatu specjalnego nie stosuje dodatkowego stylu do tekstu.

Pełną listę formatów można znaleźć w modyfikatorów.

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

Parametry

format

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

Format tekstu lub tablica formatów tekstu zdefiniowanych w util.inspect.colors.

text

string

Tekst do sformatowania.

options
StyleTextOptions

Zwraca

string

toUSVString(string)

Zwraca string po zastąpieniu wszelkich zastępczych punktów kodu (lub równoważnej, wszelkich nieparzystych jednostek kodu zastępczego) znakiem Unicode "zastępczym" U+FFFD.

function toUSVString(string: string): string

Parametry

string

string

Zwraca

string

transferableAbortController()

Tworzy i zwraca wystąpienie AbortController, którego AbortSignal jest oznaczone jako możliwe do przeniesienia i może być używane z structuredClone() lub postMessage().

function transferableAbortController(): AbortController

Zwraca

AbortController

Transferowalny element AbortController

transferableAbortSignal(AbortSignal)

Oznacza podane AbortSignal jako możliwe do przeniesienia, aby można było go używać zstructuredClone() i postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parametry

signal

AbortSignal

The AbortSignal

Zwraca

AbortSignal

To samo abortSignal