util module
De node:util-module ondersteunt de behoeften van Node.js interne API's. Veel van de hulpprogramma's zijn ook nuttig voor ontwikkelaars van toepassingen en modules. Ga als volgende te werk om toegang te krijgen tot het:
const util = require('node:util');
Zie bron
Klassen
| MIMEParams |
De |
| MIMEType |
Een implementatie van de MIMEType-klasse. In overeenstemming met browserconventies worden alle eigenschappen van Een MIME-tekenreeks is een gestructureerde tekenreeks die meerdere zinvolle onderdelen bevat. Wanneer het object wordt geparseerd, wordt een |
| TextDecoder |
Een implementatie van de WHATWG Encoding Standard |
| TextEncoder |
Een implementatie van de WHATWG Encoding Standard De klasse |
Interfaces
| CustomPromisifyLegacy | |
| CustomPromisifySymbol | |
| DebugLogger | |
| EncodeIntoResult | |
| InspectOptions | |
| InspectOptionsStylized | |
| ParseArgsConfig |
Type-aliassen
| CustomInspectFunction | |
| CustomPromisify | |
| DebugLoggerFunction | |
| Style |
Functies
| aborted(Abort |
Luistert naar het afbreken van de gebeurtenis op de opgegeven |
| add |
Voegt een parameter toe aan de opgegeven URL |
| assign(any[]) | Kopieert de waarden van alle opsommingseigenschappen van een of meer bronobjecten naar een doelobject en retourneert het doelobject. |
| auto |
Controleert of de insluit-URL autoAuth=true bevat. |
| callbackify(() => Promise<void>) | Neemt een Wordt afgedrukt: De callback wordt asynchroon uitgevoerd en heeft een beperkte stack-trace.
Als de callback wordt gegenereerd, wordt er een Aangezien |
| 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>) | |
| create |
Hiermee wordt een willekeurige tekenreeks van 5 tot 6 tekens gegenereerd. |
| debug(string, (fn: Debug |
De Als dit programma wordt uitgevoerd met waarbij De als deze wordt uitgevoerd met Meerdere door komma's gescheiden Het optionele |
| debuglog(string, (fn: Debug |
De Als dit programma wordt uitgevoerd met waarbij De als deze wordt uitgevoerd met Meerdere door komma's gescheiden Het optionele |
| deprecate<T>(T, string, string) | De methode Wanneer deze wordt aangeroepen, retourneert Als dezelfde optionele Als de Als de Als de De |
| find<T>((x: T) => boolean, T[]) | Zoekt de eerste waarde in een matrix die overeenkomt met het opgegeven predicaat. |
| find |
Hiermee zoekt u de index van de eerste waarde in een matrix die overeenkomt met het opgegeven predicaat. |
| format(any, any[]) | De methode Als een aanduiding geen bijbehorend argument heeft, wordt deze niet vervangen: Waarden die geen deel uitmaken van de notatietekenreeks, worden opgemaakt met behulp van Als er meer argumenten worden doorgegeven aan de methode Als het eerste argument geen geldige notatieaanduiding bevat, retourneert Als er slechts één argument wordt doorgegeven aan
|
| format |
Deze functie is identiek aan indeling, behalve dat er een |
| generateUUID() | Genereert een uuid van 20 tekens. |
| get |
Geeft als resultaat een willekeurig getal |
| get |
Retourneert een kaart van alle systeemfoutcodes die beschikbaar zijn via de Node.js-API.
De toewijzing tussen foutcodes en foutnamen is afhankelijk van het platform.
Zie |
| get |
Retourneert de tekenreeksnaam voor een numerieke foutcode die afkomstig is van een Node.js-API.
De toewijzing tussen foutcodes en foutnamen is afhankelijk van het platform.
Zie |
| get |
Retourneert het tijdsinterval tussen twee datums in milliseconden |
| inherits(unknown, unknown) | Het gebruik van De prototypemethoden overnemen van de ene constructor in een andere. Het prototype van Hiermee wordt voornamelijk een invoervalidatie toegevoegd aan Voorbeeld van ES6 met behulp van |
| inspect(any, boolean, null | number, boolean) | De methode Kringverwijzingen wijzen naar hun anker met behulp van een referentieindex: In het volgende voorbeeld worden alle eigenschappen van het In het volgende voorbeeld wordt het effect van de optie Met de optie De optie Met de optie
|
| inspect(any, Inspect |
|
| is |
Alias voor Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| is |
Controleert of het insluittype voor maken is |
| is |
Retourneert |
| is |
Retourneert Zie |
| is |
Retourneert Deze methode is afhankelijk van |
| is |
Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| is |
Controleert of de invoeg-URL voor RDL-rapport is. |
| is |
Retourneert |
| is |
Controleert of het rapport is opgeslagen. |
| is |
Retourneert |
| is |
Retourneert |
| is |
Retourneert |
| log(string) | De methode |
| parse |
Biedt een API op een hoger niveau voor het parseren van opdrachtregelargumenten dan rechtstreeks communiceren met |
| parse |
Stabiliteit: 1.1 - Actieve ontwikkeling Gezien een voorbeeld |
| 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>(Custom |
Neemt een functie volgens de algemene callback-stijl voor fout-eerste, d.w.w.: het nemen van een Of, gelijkwaardig met behulp van Als er een
Het gebruik van |
| promisify<TResult>((callback: (err: any, result: TResult) => void) => void) | |
| raise |
Hiermee wordt een aangepaste gebeurtenis gegenereerd met gebeurtenisgegevens op het opgegeven HTML-element. |
| remove<T>((x: T) => boolean, T[]) | |
| strip |
Retourneert |
| style |
Stabiliteit: 1.1 - Actieve ontwikkeling Met deze functie wordt een opgemaakte tekst geretourneerd, rekening houdend met de
Wanneer u een matrix met opmaak doorgeeft, wordt de volgorde van de toegepaste indeling links naar rechts weergegeven, zodat de vorige stijl mogelijk wordt overschreven door de volgende stijl. De volledige lijst met indelingen vindt u in modifiers. |
| to |
Retourneert de |
| transferable |
Hiermee maakt en retourneert u een |
| transferable |
Markeert de opgegeven |
Functiedetails
aborted(AbortSignal, any)
Luistert naar het afbreken van de gebeurtenis op de opgegeven signal en retourneert een belofte die wordt uitgevoerd wanneer de signal wordt afgebroken. Indien de doorgegeven resource afval wordt verzameld voordat de signal wordt afgebroken, blijft de geretourneerde belofte voor onbepaalde tijd in behandeling.
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>Parameters
- signal
-
AbortSignal
- resource
-
any
Een niet-null-entiteit, waarnaar zwak wordt verwezen.
Retouren
Promise<void>
addParamToUrl(string, string, string)
Voegt een parameter toe aan de opgegeven URL
function addParamToUrl(url: string, paramName: string, value: string): stringParameters
- url
-
string
- paramName
-
string
- value
-
string
Retouren
string
assign(any[])
Kopieert de waarden van alle opsommingseigenschappen van een of meer bronobjecten naar een doelobject en retourneert het doelobject.
function assign(args: any[]): anyParameters
- args
-
any[]
Retouren
any
autoAuthInEmbedUrl(string)
Controleert of de insluit-URL autoAuth=true bevat.
function autoAuthInEmbedUrl(embedUrl: string): booleanParameters
- embedUrl
-
string
Retouren
boolean
callbackify(() => Promise<void>)
Neemt een async functie (of een functie die een Promiseretourneert) en retourneert een functie na de callbackstijl van de eerste fout, d.w.w.v. het nemen van een (err, value) => ... callback als laatste argument. In de callback is het eerste argument de reden voor afwijzing (of null als de Promise opgelost) en het tweede argument de opgeloste waarde is.
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);
});
Wordt afgedrukt:
hello world
De callback wordt asynchroon uitgevoerd en heeft een beperkte stack-trace.
Als de callback wordt gegenereerd, wordt er een 'uncaughtException'-gebeurtenis verzonden en als deze niet wordt afgehandeld, wordt het proces afgesloten.
Aangezien null een speciale betekenis heeft als het eerste argument voor een callback, wordt de waarde verpakt in een Error met de oorspronkelijke waarde die is opgeslagen in een veld met de naam reason, als een verpakte functie een Promise met een falsy-waarde als reden weigert.
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) => voidParameters
- fn
-
() => Promise<void>
Een async-functie
Retouren
(callback: (err: NodeJS.ErrnoException) => void) => void
een callback-stijlfunctie
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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1) => Promise<TResult>
Retouren
(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) => voidParameters
- fn
-
(arg1: T1) => Promise<void>
Retouren
(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) => voidParameters
- fn
-
() => Promise<TResult>
Retouren
(callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void
createRandomString()
Hiermee wordt een willekeurige tekenreeks van 5 tot 6 tekens gegenereerd.
function createRandomString(): stringRetouren
string
debug(string, (fn: DebugLoggerFunction) => void)
De util.debuglog() methode wordt gebruikt om een functie te maken waarmee foutopsporingsberichten voorwaardelijk naar stderr worden geschreven op basis van het bestaan van de omgevingsvariabele NODE_DEBUG. Als de section naam wordt weergegeven binnen de waarde van die omgevingsvariabele, werkt de geretourneerde functie vergelijkbaar met console.error(). Zo niet, dan is de geretourneerde functie een no-op.
const util = require('node:util');
const debuglog = util.debuglog('foo');
debuglog('hello from foo [%d]', 123);
Als dit programma wordt uitgevoerd met NODE_DEBUG=foo in de omgeving, wordt ongeveer het volgende uitgevoerd:
FOO 3245: hello from foo [123]
waarbij 3245 de proces-id is. Als deze niet wordt uitgevoerd met die omgevingsvariabeleset, wordt er niets afgedrukt.
De section ondersteunt ook jokertekens:
const util = require('node:util');
const debuglog = util.debuglog('foo-bar');
debuglog('hi there, it\'s foo-bar [%d]', 2333);
als deze wordt uitgevoerd met NODE_DEBUG=foo* in de omgeving, wordt ongeveer het volgende uitgevoerd:
FOO-BAR 3257: hi there, it's foo-bar [2333]
Meerdere door komma's gescheiden section namen kunnen worden opgegeven in de omgevingsvariabele NODE_DEBUG: NODE_DEBUG=fs,net,tls.
Het optionele callback argument kan worden gebruikt om de logboekregistratiefunctie te vervangen door een andere functie die geen initialisatie of onnodige terugloop heeft.
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): DebugLoggerParameters
- section
-
string
Een tekenreeks die het gedeelte van de toepassing aangeeft waarvoor de debuglog functie wordt gemaakt.
- callback
-
(fn: DebugLoggerFunction) => void
Een callback die de eerste keer wordt aangeroepen wanneer de logboekregistratiefunctie wordt aangeroepen met een functieargument dat een meer geoptimaliseerde logboekregistratiefunctie is.
Retouren
De functie logboekregistratie
debuglog(string, (fn: DebugLoggerFunction) => void)
De util.debuglog() methode wordt gebruikt om een functie te maken waarmee foutopsporingsberichten voorwaardelijk naar stderr worden geschreven op basis van het bestaan van de omgevingsvariabele NODE_DEBUG. Als de section naam wordt weergegeven binnen de waarde van die omgevingsvariabele, werkt de geretourneerde functie vergelijkbaar met console.error(). Zo niet, dan is de geretourneerde functie een no-op.
const util = require('node:util');
const debuglog = util.debuglog('foo');
debuglog('hello from foo [%d]', 123);
Als dit programma wordt uitgevoerd met NODE_DEBUG=foo in de omgeving, wordt ongeveer het volgende uitgevoerd:
FOO 3245: hello from foo [123]
waarbij 3245 de proces-id is. Als deze niet wordt uitgevoerd met die omgevingsvariabeleset, wordt er niets afgedrukt.
De section ondersteunt ook jokertekens:
const util = require('node:util');
const debuglog = util.debuglog('foo-bar');
debuglog('hi there, it\'s foo-bar [%d]', 2333);
als deze wordt uitgevoerd met NODE_DEBUG=foo* in de omgeving, wordt ongeveer het volgende uitgevoerd:
FOO-BAR 3257: hi there, it's foo-bar [2333]
Meerdere door komma's gescheiden section namen kunnen worden opgegeven in de omgevingsvariabele NODE_DEBUG: NODE_DEBUG=fs,net,tls.
Het optionele callback argument kan worden gebruikt om de logboekregistratiefunctie te vervangen door een andere functie die geen initialisatie of onnodige terugloop heeft.
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): DebugLoggerParameters
- section
-
string
Een tekenreeks die het gedeelte van de toepassing aangeeft waarvoor de debuglog functie wordt gemaakt.
- callback
-
(fn: DebugLoggerFunction) => void
Een callback die de eerste keer wordt aangeroepen wanneer de logboekregistratiefunctie wordt aangeroepen met een functieargument dat een meer geoptimaliseerde logboekregistratiefunctie is.
Retouren
De functie logboekregistratie
deprecate<T>(T, string, string)
De methode util.deprecate() verpakt fn (die een functie of klasse kan zijn) op een zodanige manier dat deze als afgeschaft wordt gemarkeerd.
const util = require('node:util');
exports.obsoleteFunction = util.deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
Wanneer deze wordt aangeroepen, retourneert util.deprecate() een functie die een DeprecationWarning verzendt met behulp van de 'warning'-gebeurtenis. De waarschuwing wordt verzonden en afgedrukt naar stderr de eerste keer dat de geretourneerde functie wordt aangeroepen. Nadat de waarschuwing is verzonden, wordt de verpakte functie aangeroepen zonder een waarschuwing te verzenden.
Als dezelfde optionele code in meerdere aanroepen naar util.deprecate()wordt verstrekt, wordt de waarschuwing slechts één keer verzonden voor die 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
Als de --no-deprecation of --no-warnings opdrachtregelvlagmen worden gebruikt of als de eigenschap process.noDeprecation is ingesteld op truevoorafgaande op de eerste afschaffingswaarschuwing, doet de util.deprecate() methode niets.
Als de --trace-deprecation of --trace-warnings opdrachtregelvlagken zijn ingesteld of als de eigenschap process.traceDeprecation is ingesteld op true, wordt er een waarschuwing en een stack-trace afgedrukt om te stderr de eerste keer dat de afgeschafte functie wordt aangeroepen.
Als de --throw-deprecation opdrachtregelvlag is ingesteld of als de eigenschap process.throwDeprecation is ingesteld op true, wordt er een uitzondering gegenereerd wanneer de afgeschafte functie wordt aangeroepen.
De --throw-deprecation opdrachtregelvlag en process.throwDeprecation eigenschap hebben voorrang op --trace-deprecation en process.traceDeprecation.
function deprecate<T>(fn: T, msg: string, code?: string): TParameters
- fn
-
T
De functie die wordt afgeschaft.
- msg
-
string
Er wordt een waarschuwingsbericht weergegeven wanneer de afgeschafte functie wordt aangeroepen.
- code
-
string
Een afschaffingscode. Zie de list of deprecated APIs voor een lijst met codes.
Retouren
T
De afgeschafte functie verpakt om een waarschuwing te verzenden.
find<T>((x: T) => boolean, T[])
Zoekt de eerste waarde in een matrix die overeenkomt met het opgegeven predicaat.
function find<T>(predicate: (x: T) => boolean, xs: T[]): TParameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
Retouren
T
findIndex<T>((x: T) => boolean, T[])
Hiermee zoekt u de index van de eerste waarde in een matrix die overeenkomt met het opgegeven predicaat.
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): numberParameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
Retouren
number
format(any, any[])
De methode util.format() retourneert een opgemaakte tekenreeks met behulp van het eerste argument als een printf-achtige notatietekenreeks die nul of meer notatieaanduidingen kan bevatten. Elke aanduiding wordt vervangen door de geconverteerde waarde van het bijbehorende argument. Ondersteunde aanduidingen zijn:
Als een aanduiding geen bijbehorend argument heeft, wordt deze niet vervangen:
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
Waarden die geen deel uitmaken van de notatietekenreeks, worden opgemaakt met behulp van util.inspect() als hun type niet is string.
Als er meer argumenten worden doorgegeven aan de methode util.format() dan het aantal aanduidingen, worden de extra argumenten samengevoegd met de geretourneerde tekenreeks, gescheiden door spaties:
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
Als het eerste argument geen geldige notatieaanduiding bevat, retourneert util.format() een tekenreeks die de samenvoeging is van alle argumenten, gescheiden door spaties:
util.format(1, 2, 3);
// Returns: '1 2 3'
Als er slechts één argument wordt doorgegeven aan util.format(), wordt het geretourneerd zoals het is zonder opmaak:
util.format('%% %s');
// Returns: '%% %s'
util.format() is een synchrone methode die is bedoeld als hulpprogramma voor foutopsporing.
Sommige invoerwaarden kunnen een aanzienlijke prestatieoverhead hebben die de gebeurtenislus kan blokkeren. Gebruik deze functie met zorg en nooit in een hot codepad.
function format(format?: any, param: any[]): stringParameters
- format
-
any
Een printf-achtige notatietekenreeks.
- param
-
any[]
Retouren
string
formatWithOptions(InspectOptions, any, any[])
Deze functie is identiek aan indeling, behalve dat er een inspectOptions argument nodig is waarmee opties worden opgegeven die aan worden doorgegeven.
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[]): stringParameters
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Retouren
string
generateUUID()
Genereert een uuid van 20 tekens.
function generateUUID(): stringRetouren
string
getRandomValue()
Geeft als resultaat een willekeurig getal
function getRandomValue(): numberRetouren
number
getSystemErrorMap()
Retourneert een kaart van alle systeemfoutcodes die beschikbaar zijn via de Node.js-API.
De toewijzing tussen foutcodes en foutnamen is afhankelijk van het platform.
Zie Common System Errors voor de namen van veelvoorkomende fouten.
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]>Retouren
Map<number, [string, string]>
getSystemErrorName(number)
Retourneert de tekenreeksnaam voor een numerieke foutcode die afkomstig is van een Node.js-API.
De toewijzing tussen foutcodes en foutnamen is afhankelijk van het platform.
Zie Common System Errors voor de namen van veelvoorkomende fouten.
fs.access('file/that/does/not/exist', (err) => {
const name = util.getSystemErrorName(err.errno);
console.error(name); // ENOENT
});
function getSystemErrorName(err: number): stringParameters
- err
-
number
Retouren
string
getTimeDiffInMilliseconds(Date, Date)
Retourneert het tijdsinterval tussen twee datums in milliseconden
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParameters
- start
-
Date
- end
-
Date
Retouren
number
inherits(unknown, unknown)
Het gebruik van util.inherits() wordt afgeraden. Gebruik de ES6-class en extends trefwoorden voor overname op taalniveau. Houd er ook rekening mee dat de twee stijlen semantisch niet compatibel zijn.
De prototypemethoden overnemen van de ene constructor in een andere. Het prototype van constructor wordt ingesteld op een nieuw object dat is gemaakt op basis van superConstructor.
Hiermee wordt voornamelijk een invoervalidatie toegevoegd aanObject.setPrototypeOf(constructor.prototype, superConstructor.prototype).
Als extra gemak is superConstructor toegankelijk via de eigenschap constructor.super_.
const util = require('node:util');
const EventEmitter = require('node:events');
function MyStream() {
EventEmitter.call(this);
}
util.inherits(MyStream, EventEmitter);
MyStream.prototype.write = function(data) {
this.emit('data', data);
};
const stream = new MyStream();
console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"
Voorbeeld van ES6 met behulp van class en 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)Parameters
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, boolean, null | number, boolean)
De methode util.inspect() retourneert een tekenreeksweergave van object die is bedoeld voor foutopsporing. De uitvoer van util.inspect kan op elk gewenst moment veranderen en mag niet programmatisch afhankelijk zijn. Aanvullende options kunnen worden doorgegeven die het resultaat wijzigen.
util.inspect() gebruikt de naam en/of @@toStringTag van de constructor om een identificeerbare tag te maken voor een geïnspecteerde waarde.
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] {}'
Kringverwijzingen wijzen naar hun anker met behulp van een referentieindex:
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] }
// }
In het volgende voorbeeld worden alle eigenschappen van het util-object gecontroleerd:
const util = require('node:util');
console.log(util.inspect(util, { showHidden: true, depth: null }));
In het volgende voorbeeld wordt het effect van de optie compact gemarkeerd:
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.
Met de optie showHidden kunnen WeakMap en WeakSet vermeldingen worden geïnspecteerd. Als er meer vermeldingen zijn dan maxArrayLength, is er geen garantie welke vermeldingen worden weergegeven. Dit betekent dat het twee keer ophalen van dezelfde WeakSet vermeldingen tot verschillende uitvoer kan leiden. Bovendien kunnen vermeldingen zonder resterende sterke verwijzingen op elk gewenst moment worden verzameld.
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 } }
De optie sorted zorgt ervoor dat de invoegvolgorde van een object geen invloed heeft op het resultaat van 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 }),
);
Met de optie numericSeparator wordt elke drie cijfers een onderstrepingsteken toegevoegd aan alle getallen.
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() is een synchrone methode die is bedoeld voor foutopsporing. De maximale uitvoerlengte is ongeveer 128 MiB. Invoer die resulteert in langere uitvoer, wordt afgekapt.
function inspect(object: any, showHidden?: boolean, depth?: null | number, color?: boolean): stringParameters
- object
-
any
Elke JavaScript-primitieve of Object.
- showHidden
-
boolean
- depth
-
null | number
- color
-
boolean
Retouren
string
De weergave van object.
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParameters
- object
-
any
- options
- InspectOptions
Retouren
string
isArray(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use isArray instead.
Alias voor Array.isArray().
Retourneert true als de opgegeven object een Arrayis. Anders wordt falsegeretourneerd.
const util = require('node:util');
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
function isArray(object: unknown): objectParameters
- object
-
unknown
Retouren
object
isBoolean(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use typeof value === 'boolean' instead.
Retourneert true als de opgegeven object een Booleanis. Anders wordt falsegeretourneerd.
const util = require('node:util');
util.isBoolean(1);
// Returns: false
util.isBoolean(0);
// Returns: false
util.isBoolean(false);
// Returns: true
function isBoolean(object: unknown): objectParameters
- object
-
unknown
Retouren
object
isBuffer(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use isBuffer instead.
Retourneert true als de opgegeven object een Bufferis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isCreate(string)
Controleert of het insluittype voor maken is
function isCreate(embedType: string): booleanParameters
- embedType
-
string
Retouren
boolean
isDate(unknown)
Retourneert true als de opgegeven object een Dateis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isDeepStrictEqual(unknown, unknown)
Retourneert true als er diepe strikte gelijkheid is tussen val1 en val2.
Anders wordt falsegeretourneerd.
Zie assert.deepStrictEqual() voor meer informatie over diepe strikte gelijkheid.
function isDeepStrictEqual(val1: unknown, val2: unknown): booleanParameters
- val1
-
unknown
- val2
-
unknown
Retouren
boolean
isError(unknown)
Retourneert true als de opgegeven object een Erroris. Anders wordt falsegeretourneerd.
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
Deze methode is afhankelijk van Object.prototype.toString() gedrag. Het is mogelijk om een onjuist resultaat te verkrijgen wanneer het object argument @@toStringTagbewerkt.
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): objectParameters
- object
-
unknown
Retouren
object
isFunction(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use typeof value === 'function' instead.
Retourneert true als de opgegeven object een Functionis. Anders wordt falsegeretourneerd.
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): booleanParameters
- object
-
unknown
Retouren
boolean
isNull(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use value === null instead.
Retourneert true als de gegeven object strikt nullis. Anders wordtfalsegeretourneerd.
const util = require('node:util');
util.isNull(0);
// Returns: false
util.isNull(undefined);
// Returns: false
util.isNull(null);
// Returns: true
function isNull(object: unknown): objectParameters
- object
-
unknown
Retouren
object
isNullOrUndefined(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use value === undefined || value === null instead.
Retourneert true als de opgegeven objectnull of undefinedis. Anders wordt falsegeretourneerd.
const util = require('node:util');
util.isNullOrUndefined(0);
// Returns: false
util.isNullOrUndefined(undefined);
// Returns: true
util.isNullOrUndefined(null);
// Returns: true
function isNullOrUndefined(object: unknown): objectParameters
- object
-
unknown
Retouren
object
isNumber(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use typeof value === 'number' instead.
Retourneert true als de opgegeven object een Numberis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isObject(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use value !== null && typeof value === 'object' instead.
Retourneert true als de opgegeven object strikt een Objectis en geenFunction (ook al zijn functies objecten in JavaScript).
Anders wordt falsegeretourneerd.
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): booleanParameters
- object
-
unknown
Retouren
boolean
isPrimitive(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use (typeof value !== 'object' && typeof value !== 'function') || value === null instead.
Retourneert true als de opgegeven object een primitief type is. Anders wordtfalsegeretourneerd.
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): booleanParameters
- object
-
unknown
Retouren
boolean
isRDLEmbed(string)
Controleert of de invoeg-URL voor RDL-rapport is.
function isRDLEmbed(embedUrl: string): booleanParameters
- embedUrl
-
string
Retouren
boolean
isRegExp(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Deprecated
Retourneert true als de opgegeven object een RegExpis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isSavedInternal(HttpPostMessage, string, Window)
Controleert of het rapport is opgeslagen.
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>Parameters
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
-
Window
Retouren
Promise<boolean>
isString(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use typeof value === 'string' instead.
Retourneert true als de opgegeven object een stringis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isSymbol(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use typeof value === 'symbol' instead.
Retourneert true als de opgegeven object een Symbolis. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
isUndefined(unknown)
Waarschuwing
Deze API is nu afgeschaft.
Since v4.0.0 - Use value === undefined instead.
Retourneert true als de opgegeven object is undefined. Anders wordt falsegeretourneerd.
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): objectParameters
- object
-
unknown
Retouren
object
log(string)
Waarschuwing
Deze API is nu afgeschaft.
Since v6.0.0 - Use a third party module instead.
De methode util.log() drukt de opgegeven string af op stdout met een opgenomen tijdstempel.
const util = require('node:util');
util.log('Timestamped message.');
function log(string: string)Parameters
- string
-
string
parseArgs<T>(T)
Biedt een API op een hoger niveau voor het parseren van opdrachtregelargumenten dan rechtstreeks communiceren met process.argv. Neemt een specificatie voor de verwachte argumenten en retourneert een gestructureerd object met de geparseerde opties en positionals.
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>Parameters
- config
-
T
Wordt gebruikt om argumenten op te geven voor parseren en om de parser te configureren.
config ondersteunt de volgende eigenschappen:
Retouren
ParsedResults<T>
De geparseerde opdrachtregelargumenten:
parseEnv(string)
Stabiliteit: 1.1 - Actieve ontwikkeling Gezien een voorbeeld .env bestand:
const { parseEnv } = require('node:util');
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): objectParameters
- content
-
string
De onbewerkte inhoud van een .env-bestand.
Retouren
object
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>Parameters
- fn
-
(callback: (err?: any) => void) => void
Retouren
() => Promise<void>
promisify(Function)
function promisify(fn: Function): FunctionParameters
- fn
-
Function
Retouren
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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
Retouren
(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>Parameters
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
Retouren
(arg1: T1) => Promise<void>
promisify<TCustom>(CustomPromisify<TCustom>)
Neemt een functie volgens de algemene callback-stijl voor fout-eerste, d.w.w.: het nemen van een (err, value) => ... callback als laatste argument en retourneert een versie die beloften retourneert.
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.
});
Of, gelijkwaardig met behulp van 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();
Als er een original[util.promisify.custom] eigenschap aanwezig is, retourneert promisify de waarde ervan, zie Custom promisified functions.
promisify() gaat ervan uit dat original een functie is die in alle gevallen een callback als laatste argument gebruikt. Als original geen functie is, genereert promisify() een fout. Als original een functie is, maar het laatste argument geen callback van de eerste fout is, wordt er nog steeds een callback van de eerste fout als laatste argument doorgegeven.
Het gebruik van promisify() voor klassemethoden of andere methoden die gebruikmaken van this werkt mogelijk niet zoals verwacht, tenzij speciaal wordt afgehandeld:
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>): TCustomParameters
- fn
-
CustomPromisify<TCustom>
Retouren
TCustom
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>Parameters
- fn
-
(callback: (err: any, result: TResult) => void) => void
Retouren
() => Promise<TResult>
raiseCustomEvent(HTMLElement, string, any)
Hiermee wordt een aangepaste gebeurtenis gegenereerd met gebeurtenisgegevens op het opgegeven HTML-element.
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)Parameters
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])Parameters
- predicate
-
(x: T) => boolean
- xs
-
T[]
stripVTControlCharacters(string)
Retourneert str met eventuele ANSI-escapecodes die zijn verwijderd.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): stringParameters
- str
-
string
Retouren
string
styleText(ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], string)
Stabiliteit: 1.1 - Actieve ontwikkeling
Met deze functie wordt een opgemaakte tekst geretourneerd, rekening houdend met de format doorgegeven.
const { styleText } = require('node:util');
const errorMessage = styleText('red', 'Error! Error!');
console.log(errorMessage);
util.inspect.colors biedt ook tekstopmaak zoals italicen underline en u kunt beide combineren:
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
Wanneer u een matrix met opmaak doorgeeft, wordt de volgorde van de toegepaste indeling links naar rechts weergegeven, zodat de vorige stijl mogelijk wordt overschreven door de volgende stijl.
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
De volledige lijst met indelingen vindt u in modifiers.
function styleText(format: ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], text: string): stringParameters
- format
-
ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[]
Een tekstopmaak of een matrix met tekstopmaak die is gedefinieerd in util.inspect.colors.
- text
-
string
De tekst die moet worden opgemaakt.
Retouren
string
toUSVString(string)
Retourneert de string na het vervangen van eventuele surrogaatcodepunten (of gelijkwaardig, alle niet-geaireerde surrogaatcode-eenheden) door het Unicode-vervangende teken U+FFFD.
function toUSVString(string: string): stringParameters
- string
-
string
Retouren
string
transferableAbortController()
Hiermee maakt en retourneert u een AbortController exemplaar waarvan de AbortSignal is gemarkeerd als overdraagbaar en kan worden gebruikt met structuredClone() of postMessage().
function transferableAbortController(): AbortControllerRetouren
AbortController
Een overdraagbare AbortController
transferableAbortSignal(AbortSignal)
Markeert de opgegeven AbortSignal als overdraagbaar, zodat deze kan worden gebruikt metstructuredClone() en postMessage().
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignalParameters
- signal
-
AbortSignal
De AbortSignal
Retouren
AbortSignal
Dezelfde AbortSignal