util module

Lyssnar på en avbruten händelse på den angivna signal och returnerar ett löfte som uppfylls när signal avbryts. Om den skickade resource är skräp som samlas in innan signal avbryts, ska det returnerade löftet förbli väntande på obestämd tid.

import { aborted } from 'node:util';

const dependent = obtainSomethingAbortable();

aborted(dependent.signal, dependent).then(() => {
  // Do something when dependent is aborted.
});

dependent.on('event', () => {
  dependent.abort();
});

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

Parametrar

Returer

Lägger till en parameter i den angivna URL:en

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

Parametrar

Returer

Kopierar värdena för alla uppräkningsbara egenskaper från ett eller flera källobjekt till ett målobjekt och returnerar målobjektet.

function assign(args: any[]): any

Parametrar

Returer

Kontrollerar om inbäddnings-URL:en innehåller autoAuth=true.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parametrar

Returer

Tar en async -funktion (eller en funktion som returnerar en Promise) och returnerar en funktion som följer motringningsformatet error-first, d.v.s. att ta en (err, value) => ... motringning som det sista argumentet. I motringningen är det första argumentet avslagsorsaken (eller null om Promise löst) och det andra argumentet är det lösta värdet.

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

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

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

Skrivs ut:

hello world

Återanropet körs asynkront och har en begränsad stackspårning. Om återanropet utlöser utlöser processen en 'uncaughtException' händelse, och om den inte hanteras avslutas den.

Eftersom null har en särskild betydelse som det första argumentet till ett återanrop, om en omsluten funktion avvisar en Promise med ett förfalskningsvärde som orsak, omsluts värdet i en Error med det ursprungliga värdet som lagras i ett fält med namnet 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

Parametrar

Returer

en funktion för återanropsformat

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

Genererar en slumpmässig sträng på 5 till 6 tecken.

function createRandomString(): string

Returer

Metoden util.debuglog() används för att skapa en funktion som villkorligt skriver felsökningsmeddelanden till stderr baserat på förekomsten av NODE_DEBUGmiljövariabeln. Om det section namnet visas inom värdet för miljövariabeln fungerar den returnerade funktionen ungefär som console.error(). Om inte är den returnerade funktionen en no-op.

const util = require('node:util');
const debuglog = util.debuglog('foo');

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

Om det här programmet körs med NODE_DEBUG=foo i miljön kommer det att mata ut ungefär så här:

FOO 3245: hello from foo [123]

där 3245 är process-ID:t. Om den inte körs med den miljövariabeluppsättningen skrivs ingenting ut.

section stöder även jokertecken:

const util = require('node:util');
const debuglog = util.debuglog('foo-bar');

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

Om den körs med NODE_DEBUG=foo* i miljön, kommer den att mata ut ungefär så här:

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

Flera kommaavgränsade section namn kan anges i miljövariabeln NODE_DEBUG: NODE_DEBUG=fs,net,tls.

Det valfria argumentet callback kan användas för att ersätta loggningsfunktionen med en annan funktion som inte har någon initiering eller onödig omslutning.

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

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

Parametrar

Returer

Loggningsfunktionen

Metoden util.debuglog() används för att skapa en funktion som villkorligt skriver felsökningsmeddelanden till stderr baserat på förekomsten av NODE_DEBUGmiljövariabeln. Om det section namnet visas inom värdet för miljövariabeln fungerar den returnerade funktionen ungefär som console.error(). Om inte är den returnerade funktionen en no-op.

const util = require('node:util');
const debuglog = util.debuglog('foo');

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

Om det här programmet körs med NODE_DEBUG=foo i miljön kommer det att mata ut ungefär så här:

FOO 3245: hello from foo [123]

där 3245 är process-ID:t. Om den inte körs med den miljövariabeluppsättningen skrivs ingenting ut.

section stöder även jokertecken:

const util = require('node:util');
const debuglog = util.debuglog('foo-bar');

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

Om den körs med NODE_DEBUG=foo* i miljön, kommer den att mata ut ungefär så här:

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

Flera kommaavgränsade section namn kan anges i miljövariabeln NODE_DEBUG: NODE_DEBUG=fs,net,tls.

Det valfria argumentet callback kan användas för att ersätta loggningsfunktionen med en annan funktion som inte har någon initiering eller onödig omslutning.

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

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

Parametrar

Returer

Loggningsfunktionen

Metoden util.deprecate() omsluter fn (som kan vara en funktion eller klass) på ett sådant sätt att den markeras som inaktuell.

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

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

När den anropas returnerar util.deprecate() en funktion som genererar en DeprecationWarning med hjälp av händelsen 'warning'. Varningen genereras och skrivs ut till stderr första gången den returnerade funktionen anropas. När varningen har genererats anropas den omslutna funktionen utan att en varning skickas.

Om samma valfria code anges i flera anrop till util.deprecate()genereras varningen bara en gång för den code.

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

const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

Om kommandoradsflaggorna --no-deprecation eller --no-warnings används, eller om egenskapen process.noDeprecation är inställd på trueföre till den första utfasningsvarningen, gör util.deprecate()-metoden ingenting.

Om --trace-deprecation- eller --trace-warnings kommandoradsflaggor har angetts, eller om egenskapen process.traceDeprecation är inställd på true, skrivs en varning ut och en stackspårning skrivs ut till stderr första gången den inaktuella funktionen anropas.

Om kommandoradsflaggan --throw-deprecation har angetts eller om egenskapen process.throwDeprecation är inställd på truegenereras ett undantag när den inaktuella funktionen anropas.

Egenskapen --throw-deprecation kommandoradsflagga och process.throwDeprecation har företräde framför --trace-deprecation och process.traceDeprecation.

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

Parametrar

Returer

Den inaktuella funktionen omsluten för att generera en varning.

Hittar det första värdet i en matris som matchar det angivna predikatet.

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

Parametrar

Returer

Hittar indexet för det första värdet i en matris som matchar det angivna predikatet.

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

Parametrar

Returer

Metoden util.format() returnerar en formaterad sträng med det första argumentet som en printf-liknande formatsträng som kan innehålla noll eller fler formatspecificerare. Varje specificerare ersätts med det konverterade värdet från motsvarande argument. De som stöds är:

Om en specificerare inte har något motsvarande argument ersätts det inte:

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

Värden som inte ingår i formatsträngen formateras med util.inspect() om deras typ inte är string.

Om det finns fler argument som skickas till metoden util.format() än antalet specificerare sammanfogas de extra argumenten med den returnerade strängen, avgränsade med blanksteg:

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

Om det första argumentet inte innehåller en giltig formatspecificerare returnerar util.format() en sträng som är sammanlänkningen av alla argument avgränsade med blanksteg:

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

Om endast ett argument skickas till util.format()returneras det som det är utan formatering:

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

util.format() är en synkron metod som är avsedd som ett felsökningsverktyg. Vissa indatavärden kan ha betydande prestandaomkostnader som kan blockera händelseloopen. Använd den här funktionen med försiktighet och aldrig i en snabbkodssökväg.

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

Parametrar

Returer

Den här funktionen är identisk med format, förutom att den tar ett inspectOptions argument som anger alternativ som skickas vidare till inspektera.

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

Parametrar

Returer

Genererar en uuid på 20 tecken.

function generateUUID(): string

Returer

Returnerar slumptal

function getRandomValue(): number

Returer

Returnerar en karta över alla systemfelkoder som är tillgängliga från Node.js-API:et. Mappningen mellan felkoder och felnamn är plattformsberoende. Se Common System Errors för namnen på vanliga fel.

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

Returer

Returnerar strängnamnet för en numerisk felkod som kommer från ett Node.js API. Mappningen mellan felkoder och felnamn är plattformsberoende. Se Common System Errors för namnen på vanliga fel.

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

function getSystemErrorName(err: number): string

Parametrar

Returer

Returnerar tidsintervallet mellan två datum i millisekunder

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

Parametrar

Returer

Användning av util.inherits() rekommenderas inte. Använd nyckelorden ES6 class och extends för att få stöd för arv på språknivå. Observera också att de två formatmallarna är semantiskt inkompatibla.

Ärva prototypmetoderna från en konstruktor till en annan. Prototypen av constructor anges till ett nytt objekt som skapats från superConstructor.

Detta lägger huvudsakligen till viss indataverifiering ovanpåObject.setPrototypeOf(constructor.prototype, superConstructor.prototype). Som en extra bekvämlighet kan superConstructor nås via constructor.super_ egenskapen.

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

ES6-exempel med class och extends:

const EventEmitter = require('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)

Parametrar

Metoden util.inspect() returnerar en strängrepresentation av object som är avsedd för felsökning. Utdata från util.inspect kan ändras när som helst och bör inte vara beroende av programmatiskt. Ytterligare options kan skickas som ändrar resultatet. util.inspect() använder konstruktorns namn och/eller @@toStringTag för att skapa en identifierbar tagg för ett inspekterat värde.

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

Cirkelreferenser pekar på fästpunkten med hjälp av ett referensindex:

const { inspect } = require('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] }
// }

I följande exempel inspekteras alla egenskaper för util-objektet:

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

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

I följande exempel visas effekten av alternativet compact:

const util = require('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(util.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(util.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.

Med alternativet showHidden kan WeakMap och WeakSet poster inspekteras. Om det finns fler poster än maxArrayLengthfinns det ingen garanti för vilka poster som visas. Det innebär att om du hämtar samma WeakSet poster två gånger kan det resultera i olika utdata. Dessutom kan poster utan kvarvarande starka referenser vara skräp som samlas in när som helst.

const { inspect } = require('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 } }

Alternativet sorted säkerställer att infogningsordningen för ett objekts egenskap inte påverkar resultatet av util.inspect().

const { inspect } = require('node:util');
const assert = require('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 }),
);

Alternativet numericSeparator lägger till ett understreck var tredje siffra i alla tal.

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

const thousand = 1_000;
const million = 1_000_000;
const bigNumber = 123_456_789n;
const bigDecimal = 1_234.123_45;

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() är en synkron metod som är avsedd för felsökning. Dess maximala utdatalängd är cirka 128 MiB. Indata som resulterar i längre utdata trunkeras.

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

Parametrar

Returer

Representationen av object.

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

Parametrar

Returer

Alias för Array.isArray().

Returnerar true om den angivna object är en Array. Annars returnerar false.

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

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

function isArray(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är en Boolean. Annars returnerar false.

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

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

function isBoolean(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är en Buffer. Annars returnerar false.

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

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

function isBuffer(object: unknown): object

Parametrar

Returer

Kontrollerar om inbäddningstypen är för att skapa

function isCreate(embedType: string): boolean

Parametrar

Returer

Returnerar true om den angivna object är en Date. Annars returnerar false.

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

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

function isDate(object: unknown): object

Parametrar

Returer

Returnerar true om det finns en strikt likhet mellan val1 och val2. Annars returnerar false.

Mer information om djup strikt likhet finns i assert.deepStrictEqual().

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

Parametrar

Returer

Returnerar true om den angivna object är en Error. Annars returnerar false.

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

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

Den här metoden förlitar sig på Object.prototype.toString() beteende. Det går att få ett felaktigt resultat när argumentet object manipulerar @@toStringTag.

const util = require('node:util');
const obj = { name: 'Error', message: 'an error occurred' };

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

function isError(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är en Function. Annars returnerar false.

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

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

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

function isFunction(object: unknown): boolean

Parametrar

Returer

Returnerar true om den angivna object är strikt null. Annars returnerarfalse.

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

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

function isNull(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är null eller undefined. Annars returnerar false.

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

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

function isNullOrUndefined(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är en Number. Annars returnerar false.

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

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

function isNumber(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är strikt en Objectoch inte enFunction (även om funktioner är objekt i JavaScript). Annars returnerar false.

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

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

function isObject(object: unknown): boolean

Parametrar

Returer

Returnerar true om den angivna object är en primitiv typ. Annars returnerarfalse.

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

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

function isPrimitive(object: unknown): boolean

Parametrar

Returer

Kontrollerar om inbäddnings-URL:en är för RDL-rapporten.

function isRDLEmbed(embedUrl: string): boolean

Parametrar

Returer

Returnerar true om den angivna object är en RegExp. Annars returnerar false.

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

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

function isRegExp(object: unknown): object

Parametrar

Returer

Kontrollerar om rapporten sparas.

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

Parametrar

Returer

Returnerar true om den angivna object är en string. Annars returnerar false.

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

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

function isString(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är en Symbol. Annars returnerar false.

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

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

function isSymbol(object: unknown): object

Parametrar

Returer

Returnerar true om den angivna object är undefined. Annars returnerar false.

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

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

function isUndefined(object: unknown): object

Parametrar

Returer

Metoden util.log() skriver ut den angivna string till stdout med en inkluderad tidsstämpel.

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

util.log('Timestamped message.');

function log(string: string)

Parametrar

Tillhandahåller ett API på högre nivå för kommandoradsargumentparsning än att interagera med process.argv direkt. Tar en specifikation för de förväntade argumenten och returnerar ett strukturerat objekt med de parsade alternativen och positionerna.

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>

Parametrar

Returer

De parsade kommandoradsargumenten:

Stabilitet: 1.1 – Aktiv utveckling Givet ett exempel .env fil:

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

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

function parseEnv(content: string): object

Parametrar

Returer

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

Parametrar

Returer

function promisify(fn: Function): Function

Parametrar

Returer

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>

Parametrar

Returer

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>

Parametrar

Returer

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>

Parametrar

Returer

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>

Parametrar

Returer

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>

Parametrar

Returer

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>

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

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

Parametrar

Returer

Tar en funktion som följer det vanliga motringningsformatet error-first, det vill säga att ta ett (err, value) => ... motringning som det sista argumentet och returnerar en version som returnerar löften.

const util = require('node:util');
const fs = require('node:fs');

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

Eller, motsvarande användning av async functions:

const util = require('node:util');
const fs = require('node:fs');

const stat = util.promisify(fs.stat);

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

callStat();

Om det finns en original[util.promisify.custom] egenskap returnerar promisify dess värde, se Custom promisified functions.

promisify() förutsätter att original är en funktion som tar ett återanrop som slutargument i alla fall. Om original inte är en funktion utlöser promisify() ett fel. Om original är en funktion men dess sista argument inte är ett fel-första återanrop, skickas det fortfarande ett fel-första återanrop som sitt sista argument.

Användning av promisify() på klassmetoder eller andra metoder som använder this kanske inte fungerar som förväntat om de inte hanteras särskilt:

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

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

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

const foo = new Foo();

const naiveBar = util.promisify(foo.bar);
// TypeError: Cannot read property 'a' of undefined
// 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

Parametrar

Returer

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

Parametrar

Returer

Skapar en anpassad händelse med händelsedata på det angivna HTML-elementet.

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

Parametrar

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

Parametrar

Returnerar str med ansi-undantagskoder borttagna.

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

function stripVTControlCharacters(str: string): string

Parametrar

Returer

Stabilitet: 1.1 – Aktiv utveckling

Den här funktionen returnerar en formaterad text med tanke på format skickas.

const { styleText } = require('node:util');
const errorMessage = styleText('red', 'Error! Error!');
console.log(errorMessage);

util.inspect.colors innehåller även textformat som italicoch underline och du kan kombinera båda:

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

När du skickar en matris med format är formatets ordning vänster till höger så att följande formatmall kan skriva över den föregående.

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

Den fullständiga listan över format finns i modifierare.

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

Parametrar

Returer

Returnerar string efter att ha ersatt eventuella surrogatkodpunkter (eller motsvarande eventuella obetalda surrogatkodenheter) med Unicodes "ersättningstecken" U+FFFD.

function toUSVString(string: string): string

Parametrar

Returer

Skapar och returnerar en AbortController instans vars AbortSignal är markerad som överförbar och kan användas med structuredClone() eller postMessage().

function transferableAbortController(): AbortController

Returer

En överförbar AbortController

Markerar den angivna AbortSignal som överförbar så att den kan användas medstructuredClone() och postMessage().

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

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parametrar

Returer

Samma AbortSignal