Sdílet prostřednictvím

util module

Balíček:
powerbi-client

Modul node:util podporuje potřeby Node.js interních rozhraní API. Řada nástrojů je užitečná i pro vývojáře aplikací a modulů. Přístup k němu:

import util from 'node:util';

Viz zdrojové

Třídy

MIMEParams

Rozhraní API MIMEParams poskytuje přístup pro čtení a zápis k parametrům MIMEType.
MIMEType

Implementace MIMEType třídy.

V souladu s konvencemi prohlížeče se všechny vlastnosti MIMEType objektů implementují jako gettery a setter v prototypu třídy, nikoli jako datové vlastnosti samotného objektu.

Řetězec MIME je strukturovaný řetězec obsahující více smysluplných komponent. Při analýze se vrátí objekt MIMEType obsahující vlastnosti pro každou z těchto komponent.
TextDecoder

Implementace standarduTextDecoder API kódování WHATWG.

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

Implementace standarduTextEncoder API kódování WHATWG. Všechny instance TextEncoder podporují pouze kódování UTF-8.

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

Třída TextEncoder je také k dispozici v globálním objektu.

Rozhraní

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

Aliasy typu

CustomInspectFunction
CustomPromisify
DebugLoggerFunction
DiffEntry
ParseArgsOptionsType

Typ argumentu použitého v parseArgs.
Style

Funkce

aborted(AbortSignal, any)

Naslouchá přerušení události na zadaném signal a vrátí příslib, který se vyřeší při přerušení signal. Pokud je k dispozici resource, slabě odkazuje na přidružený objekt operace, takže pokud resource je uvolňování paměti před přerušením signal, pak vrácený slib zůstane čekající. To zabraňuje nevracení paměti v dlouhotrvajících nebo nerušitelných operacích.

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)

Přidá parametr na danou adresu URL.
assign(any[])

Zkopíruje hodnoty všech výčtových vlastností z jednoho nebo více zdrojových objektů do cílového objektu a vrátí cílový objekt.
autoAuthInEmbedUrl(string)

Zkontroluje, jestli adresa URL pro vložení obsahuje autoAuth=true.
callbackify(() => Promise<void>)

Vezme async funkci (nebo funkci, která vrací Promise) a vrátí funkci za stylem zpětného volání první chyby, tj. jako poslední argument vezme (err, value) => ... zpětné volání. V zpětném volání bude prvním argumentem důvod zamítnutí (nebo null, pokud Promise vyřešen) a druhý argument bude přeloženou hodnotou.

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

Vytiskne se:

hello world

Zpětné volání se provádí asynchronně a bude mít omezené trasování zásobníku. Pokud zpětné volání vyvolá, proces vygeneruje 'uncaughtException' událost a pokud se nezpracuje, ukončí se.

Vzhledem k tomu, že null má jako první argument zpětného volání zvláštní význam, pokud zabalená funkce odmítne Promise s falsy hodnotou jako důvod, je hodnota zabalena do Error s původní hodnotou uloženou v poli s názvem 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()

Vygeneruje náhodný řetězec 5 až 6 znaků.
debuglog(string, (fn: DebugLoggerFunction) => void)

Metoda util.debuglog() se používá k vytvoření funkce, která podmíněně zapisuje ladicí zprávy na stderr základě existence NODE_DEBUG proměnné prostředí. Pokud se název section zobrazí v hodnotě této proměnné prostředí, pak vrácená funkce funguje podobně jako console.error(). Pokud ne, vrácená funkce je no-op.

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

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

Pokud je tento program spuštěn s NODE_DEBUG=foo v prostředí, bude výstup vypadat přibližně takto:

FOO 3245: hello from foo [123]

kde 3245 je ID procesu. Pokud se nespustí s danou sadou proměnných prostředí, nic se nevytiskne.

section podporuje také zástupný znak:

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

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

Pokud se spustí s NODE_DEBUG=foo* v prostředí, bude výstup vypadat přibližně takto:

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

V proměnné prostředí lze zadat section více názvů oddělených NODE_DEBUG čárkami: NODE_DEBUG=fs,net,tls.

Volitelný argument callback lze použít k nahrazení funkce protokolování jinou funkcí, která nemá žádné inicializace ani zbytečné zabalení.

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() zabalí fn (což může být funkce nebo třída) takovým způsobem, že je označena jako zastaralá.

import { deprecate } from 'node:util';

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

Při zavolání vrátí util.deprecate() funkci, která vygeneruje DeprecationWarning pomocí události 'warning'. Upozornění se vygeneruje a vytiskne na stderr při prvním zavolání vrácené funkce. Po vygenerování upozornění se zabalená funkce zavolá bez vygenerování upozornění.

Pokud je stejná volitelná code zadána ve více voláních util.deprecate(), upozornění se vygeneruje pouze jednou pro tento 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

Pokud se použijí příznaky příkazového řádku --no-deprecation nebo --no-warnings nebo pokud je vlastnost process.noDeprecation nastavená na truepřed na první upozornění na vyřazení, metoda util.deprecate() nic nedělá.

Pokud jsou nastavené příznaky --trace-deprecation nebo --trace-warnings příkazového řádku nebo je vlastnost process.traceDeprecation nastavena na true, zobrazí se upozornění a trasování zásobníku se vytiskne na stderr při prvním zavolání zastaralé funkce.

Pokud je nastaven příznak příkazového řádku --throw-deprecation nebo je vlastnost process.throwDeprecation nastavena na true, bude vyvolána výjimka při zavolání zastaralé funkce.

Příznak příkazového řádku --throw-deprecation a vlastnost process.throwDeprecation má přednost před --trace-deprecation a process.traceDeprecation.
diff(string | (readonly string[]), string | (readonly string[]))

util.diff() porovná dva řetězcové nebo maticové hodnoty a vrátí matici položek rozdílů. K výpočtu minimálních rozdílů používá myers rozdílový algoritmus, což je stejný algoritmus používaný interně pomocí chybových zpráv kontrolního výrazu.

Pokud jsou hodnoty stejné, vrátí se prázdné pole.

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

Najde první hodnotu v matici, která odpovídá zadanému predikátu.
findIndex<T>((x: T) => boolean, T[])

Vyhledá index první hodnoty v matici, která odpovídá zadanému predikátu.
format(any, any[])

Metoda util.format() vrátí formátovaný řetězec pomocí prvního argumentu jako printf-like formátovací řetězec, který může obsahovat nula nebo více specifikátorů formátu. Každý specifikátor se nahradí převedenou hodnotou z odpovídajícího argumentu. Podporované specifikátory jsou:

Pokud specifikátor nemá odpovídající argument, nenahradí se:

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

Hodnoty, které nejsou součástí formátovacího řetězce, jsou formátovány pomocí util.inspect(), pokud jejich typ není string.

Pokud je metodě util.format() předáno více argumentů než počet specifikátorů, další argumenty se zřetězí do vráceného řetězce oddělené mezerami:

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

Pokud první argument neobsahuje platný specifikátor formátu, util.format() vrátí řetězec, který je zřetězením všech argumentů oddělených mezerami:

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

Pokud se util.format()předá jenom jeden argument, vrátí se tak, jak je bez formátování:

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

util.format() je synchronní metoda, která je určená jako nástroj pro ladění. Některé vstupní hodnoty můžou mít významnou režii na výkon, která může blokovat smyčku událostí. Tuto funkci používejte opatrně a nikdy v horké cestě kódu.
formatWithOptions(InspectOptions, any, any[])

Tato funkce je shodná s formátem s tím rozdílem, že přebírá inspectOptions argument, který určuje možnosti, které se předávají kontrole.

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

Vygeneruje 20 znaků uuid.
getCallSites(GetCallSitesOptions)
getCallSites(number, GetCallSitesOptions)

Vrátí pole objektů lokality volání obsahující zásobník funkce volajícího.

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

Původní umístění je možné rekonstruovat nastavením možnosti sourceMaptrue. Pokud zdrojová mapa není k dispozici, původní umístění bude stejné jako aktuální umístění. Pokud je příznak --enable-source-maps povolený, například při použití --experimental-transform-types, sourceMap bude ve výchozím nastavení 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()

Vrátí náhodné číslo.
getSystemErrorMap()

Vrátí mapu všech kódů systémových chyb dostupných v rozhraní Node.js API. Mapování mezi kódy chyb a názvy chyb závisí na platformě. Názvy běžných chyb najdete v Common System Errors.

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

Vrátí řetězcovou zprávu pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a řetězcovými zprávami je závislé na platformě.

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

Vrátí název řetězce pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a názvy chyb závisí na platformě. Názvy běžných chyb najdete v Common System Errors.

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

Vrátí časový interval mezi dvěma daty v milisekundách.
inherits(unknown, unknown)

Použití util.inherits() se nedoporučuje. Pokud chcete získat podporu dědičnosti na úrovni jazyka, použijte class ES6 a klíčová slova extends. Všimněte si také, že tyto dva styly jsou sémanticky nekompatibilní.

Dědí prototypové metody z jednoho konstruktoru do jiného. Prototyp constructor bude nastaven na nový objekt vytvořený z superConstructor.

To hlavně přidává některé vstupní ověřování nad Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Jako další pohodlí bude superConstructor přístupné prostřednictvím constructor.super_ vlastnosti.

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!"

Příklad ES6 používající class a 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() vrátí řetězcovou reprezentaci object, která je určená pro ladění. Výstup util.inspect se může kdykoli změnit a neměl by být závislý programově. Další options mohou být předány, aby se změnil výsledek. util.inspect() použije název konstruktoru nebo Symbol.toStringTag vlastnost k vytvoření identifikovatelné značky pro zkontrolovanou hodnotu.

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

Cyklický odkaz odkazuje na jejich ukotvení pomocí indexu odkazu:

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

Následující příklad zkontroluje všechny vlastnosti util objektu:

import util from 'node:util';

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

Následující příklad zvýrazní účinek možnosti 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.

Možnost showHidden umožňuje kontrolovat WeakMap a WeakSet položky. Pokud existuje více položek než maxArrayLength, není zaručeno, které položky jsou zobrazeny. To znamená, že načtení stejných položek WeakSet dvakrát může vést k jinému výstupu. Položky bez zbývajících silných odkazů navíc mohou být kdykoli uvolněny z paměti.

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

Možnost sorted zajišťuje, že pořadí vložení vlastnosti objektu nemá vliv na výsledek 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 }),
);

Možnost numericSeparator přidá podtržítko každé tři číslice ke všem číslům.

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() je synchronní metoda určená pro ladění. Maximální délka výstupu je přibližně 128 MiB. Vstupy, které vedou k delšímu výstupu, budou zkráceny.
inspect(any, InspectOptions)
isArray(unknown)

Alias pro Array.isArray().

Vrátí true, pokud je daná objectArray. V opačném případě vrátí hodnotu false.

import util from 'node:util';

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

Zkontroluje, jestli je typ vložení pro vytvoření.
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Vrátí true, pokud existuje hloubková striktní rovnost mezi val1 a val2. V opačném případě vrátí hodnotu false.

Další informace o hluboké striktní rovnosti najdete v tématu assert.deepStrictEqual().
isRDLEmbed(string)

Zkontroluje, jestli je adresa URL pro vložení pro sestavu RDL.
isSavedInternal(HttpPostMessage, string, Window)

Zkontroluje, jestli je sestava uložená.
parseArgs<T>(T)

Poskytuje rozhraní API vyšší úrovně pro analýzu argumentů příkazového řádku než přímé interakce s process.argv. Vezme specifikaci očekávaných argumentů a vrátí strukturovaný objekt s parsovanými možnostmi a pozicemi.

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)

Stabilita: 1.1 – Aktivní vývoj Vzhledem k příkladu souboru .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>)

Přebírá funkci podle běžného stylu zpětného volání při první chybě, tj. přebírá (err, value) => ... zpětné volání jako poslední argument a vrací verzi, která vrací přísliby.

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

Nebo ekvivalentní použití 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();

Pokud existuje original[util.promisify.custom] vlastnost, promisify vrátí její hodnotu, viz Custom promisified functions.

promisify() předpokládá, že original je funkce, která ve všech případech přebírá zpětné volání jako konečný argument. Pokud original funkce není, promisify() vyvolá chybu. Pokud original je funkce, ale její poslední argument není zpětným voláním typu error-first, bude jako poslední argument předán zpětné volání první chyby.

Použití promisify() u metod tříd nebo jiných metod, které používají this nemusí fungovat podle očekávání, pokud se nezpracuje speciálně:

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)

Vyvolá vlastní událost s daty události v zadaném elementu HTML.
remove<T>((x: T) => boolean, T[])
setTraceSigInt(boolean)

Povolte nebo zakažte tisk trasování zásobníku .SIGINT Rozhraní API je k dispozici pouze v hlavním vlákně.
stripVTControlCharacters(string)

Vrátí str s odebranými řídicími kódy ANSI.

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

Tato funkce vrátí formátovaný text s ohledem na format předaný tisk v terminálu. Je si vědom schopností terminálu a funguje podle konfigurační sady prostřednictvím NO_COLORa NODE_DISABLE_COLORSFORCE_COLOR proměnných prostředí.

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 také poskytuje textové formáty, jako jsou italica underline a můžete kombinovat obojí:

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

Při předávání pole formátů je pořadí použitého formátu zleva doprava, takže následující styl může přepsat předchozí styl.

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

Speciální hodnota none formátu neplatí pro text žádný další styl.

Úplný seznam formátů najdete v modifikátory.
toUSVString(string)

Vrátí string po nahrazení všech náhradních bodů kódu (nebo ekvivalentních jednotek nezaplaceného náhradního kódu) znakem U+FFFD s kódováním Unicode.
transferableAbortController()

Vytvoří a vrátí instanci AbortController, jejíž AbortSignal je označena jako přenositelná a lze ji použít s structuredClone() nebo postMessage().
transferableAbortSignal(AbortSignal)

Označí danou AbortSignal jako přenosnou, aby ji bylo možné použít sstructuredClone() a postMessage().

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

Podrobnosti funkce

aborted(AbortSignal, any)

Naslouchá přerušení události na zadaném signal a vrátí příslib, který se vyřeší při přerušení signal. Pokud je k dispozici resource, slabě odkazuje na přidružený objekt operace, takže pokud resource je uvolňování paměti před přerušením signal, pak vrácený slib zůstane čekající. To zabraňuje nevracení paměti v dlouhotrvajících nebo nerušitelných operacích.

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

Všechny objekty, které nejsou null vázané na operaci přerušení a jsou slabě uloženy. Pokud resource je před přerušením signal uvolňování paměti, příslib zůstane čekající a umožní Node.js zastavit jeho sledování. To pomáhá zabránit nevracení paměti v dlouhotrvajících nebo nerušitelných operacích.

Návraty

Promise<void>

addParamToUrl(string, string, string)

Přidá parametr na danou adresu URL.

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

Parametry

url

string

paramName

string

value

string

Návraty

string

assign(any[])

Zkopíruje hodnoty všech výčtových vlastností z jednoho nebo více zdrojových objektů do cílového objektu a vrátí cílový objekt.

function assign(args: any[]): any

Parametry

args

any[]

Návraty

any

autoAuthInEmbedUrl(string)

Zkontroluje, jestli adresa URL pro vložení obsahuje autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parametry

embedUrl

string

Návraty

boolean

callbackify(() => Promise<void>)

Vezme async funkci (nebo funkci, která vrací Promise) a vrátí funkci za stylem zpětného volání první chyby, tj. jako poslední argument vezme (err, value) => ... zpětné volání. V zpětném volání bude prvním argumentem důvod zamítnutí (nebo null, pokud Promise vyřešen) a druhý argument bude přeloženou hodnotou.

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

Vytiskne se:

hello world

Zpětné volání se provádí asynchronně a bude mít omezené trasování zásobníku. Pokud zpětné volání vyvolá, proces vygeneruje 'uncaughtException' událost a pokud se nezpracuje, ukončí se.

Vzhledem k tomu, že null má jako první argument zpětného volání zvláštní význam, pokud zabalená funkce odmítne Promise s falsy hodnotou jako důvod, je hodnota zabalena do Error s původní hodnotou uloženou v poli s názvem 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>

Funkce async

Návraty

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

funkce stylu zpětného volání

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>

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

Návraty

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

createRandomString()

Vygeneruje náhodný řetězec 5 až 6 znaků.

function createRandomString(): string

Návraty

string

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

Metoda util.debuglog() se používá k vytvoření funkce, která podmíněně zapisuje ladicí zprávy na stderr základě existence NODE_DEBUG proměnné prostředí. Pokud se název section zobrazí v hodnotě této proměnné prostředí, pak vrácená funkce funguje podobně jako console.error(). Pokud ne, vrácená funkce je no-op.

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

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

Pokud je tento program spuštěn s NODE_DEBUG=foo v prostředí, bude výstup vypadat přibližně takto:

FOO 3245: hello from foo [123]

kde 3245 je ID procesu. Pokud se nespustí s danou sadou proměnných prostředí, nic se nevytiskne.

section podporuje také zástupný znak:

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

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

Pokud se spustí s NODE_DEBUG=foo* v prostředí, bude výstup vypadat přibližně takto:

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

V proměnné prostředí lze zadat section více názvů oddělených NODE_DEBUG čárkami: NODE_DEBUG=fs,net,tls.

Volitelný argument callback lze použít k nahrazení funkce protokolování jinou funkcí, která nemá žádné inicializace ani zbytečné zabalení.

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

Řetězec identifikující část aplikace, pro kterou se vytváří debuglog funkce.

callback

(fn: DebugLoggerFunction) => void

Zpětné volání vyvoláno při prvním volání funkce protokolování s argumentem funkce, který je optimalizovanější funkce protokolování.

Návraty

DebugLogger

Funkce protokolování

deprecate<T>(T, string, string)

Metoda util.deprecate() zabalí fn (což může být funkce nebo třída) takovým způsobem, že je označena jako zastaralá.

import { deprecate } from 'node:util';

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

Při zavolání vrátí util.deprecate() funkci, která vygeneruje DeprecationWarning pomocí události 'warning'. Upozornění se vygeneruje a vytiskne na stderr při prvním zavolání vrácené funkce. Po vygenerování upozornění se zabalená funkce zavolá bez vygenerování upozornění.

Pokud je stejná volitelná code zadána ve více voláních util.deprecate(), upozornění se vygeneruje pouze jednou pro tento 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

Pokud se použijí příznaky příkazového řádku --no-deprecation nebo --no-warnings nebo pokud je vlastnost process.noDeprecation nastavená na truepřed na první upozornění na vyřazení, metoda util.deprecate() nic nedělá.

Pokud jsou nastavené příznaky --trace-deprecation nebo --trace-warnings příkazového řádku nebo je vlastnost process.traceDeprecation nastavena na true, zobrazí se upozornění a trasování zásobníku se vytiskne na stderr při prvním zavolání zastaralé funkce.

Pokud je nastaven příznak příkazového řádku --throw-deprecation nebo je vlastnost process.throwDeprecation nastavena na true, bude vyvolána výjimka při zavolání zastaralé funkce.

Příznak příkazového řádku --throw-deprecation a vlastnost process.throwDeprecation má přednost před --trace-deprecation a process.traceDeprecation.

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

Parametry

fn

T

Funkce, která je zastaralá.

msg

string

Zpráva s upozorněním, která se zobrazí při vyvolání zastaralé funkce.

code

string

Kód vyřazení. Seznam kódů najdete v list of deprecated APIs.

Návraty

T

Zastaralá funkce zabalená k vygenerování upozornění.

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

util.diff() porovná dva řetězcové nebo maticové hodnoty a vrátí matici položek rozdílů. K výpočtu minimálních rozdílů používá myers rozdílový algoritmus, což je stejný algoritmus používaný interně pomocí chybových zpráv kontrolního výrazu.

Pokud jsou hodnoty stejné, vrátí se prázdné pole.

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

První hodnota, která se má porovnat

expected

string | (readonly string[])

Druhá hodnota, kterou chcete porovnat

Návraty

DiffEntry[]

Pole položek rozdílů. Každá položka je pole se dvěma prvky:

  • Index 0: number Kód operace: -1 pro odstranění 0 , pro no-op/beze změny, 1 pro vložení
  • Index 1: string Hodnota přidružená k operaci

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

Najde první hodnotu v matici, která odpovídá zadanému predikátu.

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

Parametry

predicate

(x: T) => boolean

xs

T[]

Návraty

T

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

Vyhledá index první hodnoty v matici, která odpovídá zadanému predikátu.

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

Parametry

predicate

(x: T) => boolean

xs

T[]

Návraty

number

format(any, any[])

Metoda util.format() vrátí formátovaný řetězec pomocí prvního argumentu jako printf-like formátovací řetězec, který může obsahovat nula nebo více specifikátorů formátu. Každý specifikátor se nahradí převedenou hodnotou z odpovídajícího argumentu. Podporované specifikátory jsou:

Pokud specifikátor nemá odpovídající argument, nenahradí se:

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

Hodnoty, které nejsou součástí formátovacího řetězce, jsou formátovány pomocí util.inspect(), pokud jejich typ není string.

Pokud je metodě util.format() předáno více argumentů než počet specifikátorů, další argumenty se zřetězí do vráceného řetězce oddělené mezerami:

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

Pokud první argument neobsahuje platný specifikátor formátu, util.format() vrátí řetězec, který je zřetězením všech argumentů oddělených mezerami:

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

Pokud se util.format()předá jenom jeden argument, vrátí se tak, jak je bez formátování:

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

util.format() je synchronní metoda, která je určená jako nástroj pro ladění. Některé vstupní hodnoty můžou mít významnou režii na výkon, která může blokovat smyčku událostí. Tuto funkci používejte opatrně a nikdy v horké cestě kódu.

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

Parametry

format

any

Formátovací řetězec printf.

param

any[]

Návraty

string

formatWithOptions(InspectOptions, any, any[])

Tato funkce je shodná s formátem s tím rozdílem, že přebírá inspectOptions argument, který určuje možnosti, které se předávají kontrole.

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

Návraty

string

generateUUID()

Vygeneruje 20 znaků uuid.

function generateUUID(): string

Návraty

string

getCallSites(GetCallSitesOptions) 

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parametry

options

GetCallSitesOptions

Návraty

CallSiteObject[]

getCallSites(number, GetCallSitesOptions)

Vrátí pole objektů lokality volání obsahující zásobník funkce volajícího.

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

Původní umístění je možné rekonstruovat nastavením možnosti sourceMaptrue. Pokud zdrojová mapa není k dispozici, původní umístění bude stejné jako aktuální umístění. Pokud je příznak --enable-source-maps povolený, například při použití --experimental-transform-types, sourceMap bude ve výchozím nastavení 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

Počet snímků, které se mají zachytit jako objekty lokality volání výchozí :10. Povolený rozsah je mezi 1 a 200.

options

GetCallSitesOptions

Návraty

CallSiteObject[]

Pole objektů webu volání

getRandomValue()

Vrátí náhodné číslo.

function getRandomValue(): number

Návraty

number

getSystemErrorMap()

Vrátí mapu všech kódů systémových chyb dostupných v rozhraní Node.js API. Mapování mezi kódy chyb a názvy chyb závisí na platformě. Názvy běžných chyb najdete v Common System Errors.

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

Návraty

Map<number, [string, string]>

getSystemErrorMessage(number)

Vrátí řetězcovou zprávu pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a řetězcovými zprávami je závislé na platformě.

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

Návraty

string

getSystemErrorName(number)

Vrátí název řetězce pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a názvy chyb závisí na platformě. Názvy běžných chyb najdete v Common System Errors.

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

Návraty

string

getTimeDiffInMilliseconds(Date, Date)

Vrátí časový interval mezi dvěma daty v milisekundách.

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

Parametry

start

Date

end

Date

Návraty

number

inherits(unknown, unknown)

Použití util.inherits() se nedoporučuje. Pokud chcete získat podporu dědičnosti na úrovni jazyka, použijte class ES6 a klíčová slova extends. Všimněte si také, že tyto dva styly jsou sémanticky nekompatibilní.

Dědí prototypové metody z jednoho konstruktoru do jiného. Prototyp constructor bude nastaven na nový objekt vytvořený z superConstructor.

To hlavně přidává některé vstupní ověřování nad Object.setPrototypeOf(constructor.prototype, superConstructor.prototype). Jako další pohodlí bude superConstructor přístupné prostřednictvím constructor.super_ vlastnosti.

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!"

Příklad ES6 používající class a 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() vrátí řetězcovou reprezentaci object, která je určená pro ladění. Výstup util.inspect se může kdykoli změnit a neměl by být závislý programově. Další options mohou být předány, aby se změnil výsledek. util.inspect() použije název konstruktoru nebo Symbol.toStringTag vlastnost k vytvoření identifikovatelné značky pro zkontrolovanou hodnotu.

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

Cyklický odkaz odkazuje na jejich ukotvení pomocí indexu odkazu:

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

Následující příklad zkontroluje všechny vlastnosti util objektu:

import util from 'node:util';

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

Následující příklad zvýrazní účinek možnosti 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.

Možnost showHidden umožňuje kontrolovat WeakMap a WeakSet položky. Pokud existuje více položek než maxArrayLength, není zaručeno, které položky jsou zobrazeny. To znamená, že načtení stejných položek WeakSet dvakrát může vést k jinému výstupu. Položky bez zbývajících silných odkazů navíc mohou být kdykoli uvolněny z paměti.

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

Možnost sorted zajišťuje, že pořadí vložení vlastnosti objektu nemá vliv na výsledek 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 }),
);

Možnost numericSeparator přidá podtržítko každé tři číslice ke všem číslům.

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() je synchronní metoda určená pro ladění. Maximální délka výstupu je přibližně 128 MiB. Vstupy, které vedou k delšímu výstupu, budou zkráceny.

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

Parametry

object

any

Jakýkoli javascriptový primitiv nebo Object.

showHidden

boolean

depth

null | number

color

boolean

Návraty

string

Reprezentace object.

inspect(any, InspectOptions) 

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

Parametry

object

any

options
InspectOptions

Návraty

string

isArray(unknown)

Upozornění

Toto rozhraní API je teď zastaralé.

Since v4.0.0 - Use isArray instead.

Alias pro Array.isArray().

Vrátí true, pokud je daná objectArray. V opačném případě vrátí hodnotu 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

Návraty

object

isCreate(string)

Zkontroluje, jestli je typ vložení pro vytvoření.

function isCreate(embedType: string): boolean

Parametry

embedType

string

Návraty

boolean

isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

Vrátí true, pokud existuje hloubková striktní rovnost mezi val1 a val2. V opačném případě vrátí hodnotu false.

Další informace o hluboké striktní rovnosti najdete v tématu assert.deepStrictEqual().

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

Parametry

val1

unknown

val2

unknown

options
IsDeepStrictEqualOptions

Návraty

boolean

isRDLEmbed(string)

Zkontroluje, jestli je adresa URL pro vložení pro sestavu RDL.

function isRDLEmbed(embedUrl: string): boolean

Parametry

embedUrl

string

Návraty

boolean

isSavedInternal(HttpPostMessage, string, Window)

Zkontroluje, jestli je sestava uložená.

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

Parametry

hpm

HttpPostMessage

uid

string

contentWindow

Window

Návraty

Promise<boolean>

parseArgs<T>(T)

Poskytuje rozhraní API vyšší úrovně pro analýzu argumentů příkazového řádku než přímé interakce s process.argv. Vezme specifikaci očekávaných argumentů a vrátí strukturovaný objekt s parsovanými možnostmi a pozicemi.

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

Používá se k zadání argumentů pro analýzu a ke konfiguraci analyzátoru. config podporuje následující vlastnosti:

Návraty

ParsedResults<T>

Analyzované argumenty příkazového řádku:

parseEnv(string)

Stabilita: 1.1 – Aktivní vývoj Vzhledem k příkladu souboru .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

Nezpracovaný obsah souboru .env.

Návraty

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

Návraty

() => Promise<void>

promisify(Function) 

function promisify(fn: Function): Function

Parametry

fn

Function

Návraty

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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(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

Návraty

(arg1: T1) => Promise<void>

promisify<TCustom>(CustomPromisify<TCustom>)

Přebírá funkci podle běžného stylu zpětného volání při první chybě, tj. přebírá (err, value) => ... zpětné volání jako poslední argument a vrací verzi, která vrací přísliby.

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

Nebo ekvivalentní použití 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();

Pokud existuje original[util.promisify.custom] vlastnost, promisify vrátí její hodnotu, viz Custom promisified functions.

promisify() předpokládá, že original je funkce, která ve všech případech přebírá zpětné volání jako konečný argument. Pokud original funkce není, promisify() vyvolá chybu. Pokud original je funkce, ale její poslední argument není zpětným voláním typu error-first, bude jako poslední argument předán zpětné volání první chyby.

Použití promisify() u metod tříd nebo jiných metod, které používají this nemusí fungovat podle očekávání, pokud se nezpracuje speciálně:

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>

Návraty

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

Návraty

() => Promise<TResult>

raiseCustomEvent(HTMLElement, string, any)

Vyvolá vlastní událost s daty události v zadaném elementu 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)

Povolte nebo zakažte tisk trasování zásobníku .SIGINT Rozhraní API je k dispozici pouze v hlavním vlákně.

function setTraceSigInt(enable: boolean)

Parametry

enable

boolean

stripVTControlCharacters(string)

Vrátí str s odebranými řídicími kódy ANSI.

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

function stripVTControlCharacters(str: string): string

Parametry

str

string

Návraty

string

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

Tato funkce vrátí formátovaný text s ohledem na format předaný tisk v terminálu. Je si vědom schopností terminálu a funguje podle konfigurační sady prostřednictvím NO_COLORa NODE_DISABLE_COLORSFORCE_COLOR proměnných prostředí.

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 také poskytuje textové formáty, jako jsou italica underline a můžete kombinovat obojí:

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

Při předávání pole formátů je pořadí použitého formátu zleva doprava, takže následující styl může přepsat předchozí styl.

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

Speciální hodnota none formátu neplatí pro text žádný další styl.

Úplný seznam formátů najdete v modifikátory.

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

Parametry

format

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

Textový formát nebo Pole textových formátů definovaných v util.inspect.colors.

text

string

Text, který se má naformátovat.

options
StyleTextOptions

Návraty

string

toUSVString(string)

Vrátí string po nahrazení všech náhradních bodů kódu (nebo ekvivalentních jednotek nezaplaceného náhradního kódu) znakem U+FFFD s kódováním Unicode.

function toUSVString(string: string): string

Parametry

string

string

Návraty

string

transferableAbortController()

Vytvoří a vrátí instanci AbortController, jejíž AbortSignal je označena jako přenositelná a lze ji použít s structuredClone() nebo postMessage().

function transferableAbortController(): AbortController

Návraty

AbortController

Přenositelný AbortController

transferableAbortSignal(AbortSignal)

Označí danou AbortSignal jako přenosnou, aby ji bylo možné použít sstructuredClone() a 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

Návraty

AbortSignal

Stejný AbortSignal