powerbi-client package
Klassen
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Power BI Advanced Filter Builder-Komponente |
| BasicFilterBuilder |
Power BI Basic-Filter-Generatorkomponente |
| BookmarksManager |
Verwaltet Berichtsmarken. |
| Create |
Erstellen einer Power BI-Berichtskomponente |
| Dashboard |
Eine Power BI-Dashboard-Einbettungskomponente |
| FilterBuilder |
Generischer Filter-Generator für BasicFilter, AdvancedFilter, RelativeDate, RelativeTime und TopN |
| MIMEParams |
Die |
| MIMEType |
Eine Implementierung der der MIMEType-Klasse. In Übereinstimmung mit Browserkonventionen werden alle Eigenschaften von Eine MIME-Zeichenfolge ist eine strukturierte Zeichenfolge, die mehrere aussagekräftige Komponenten enthält. Bei der Analyse wird ein |
| Page |
Eine Power BI-Berichtsseite |
| Qna |
Die Power BI Q-&Eine Einbettungskomponente |
| QuickCreate |
Eine Power BI-Schnellerstellungskomponente |
| RelativeDateFilterBuilder |
Power BI Relative Date-Generatorkomponente |
| RelativeTimeFilterBuilder |
Power BI Relative Time-Generatorkomponente |
| Report |
Die Power BI-Berichtseinbettungskomponente |
| Service |
Die Power BI-Diensteinbettungskomponente, die der Einstiegspunkt ist, um alle anderen Power BI-Komponenten in Ihre Anwendung einzubetten |
| Tile |
Die Power BI-Kacheleinbettungskomponente |
| TopNFilterBuilder |
Power BI Top N-Filter-Generatorkomponente |
| Visual |
Die Visual Embed-Komponente von Power BI |
| VisualDescriptor |
Ein Visuelles Power BI-Element auf einer Seite |
Schnittstellen
Typaliase
Enumerationen
Functions
| is |
Gibt Siehe auch |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt Beispiel: |
| is |
Gibt |
| is |
Gibt Siehe auch |
| is |
Gibt |
| is |
Gibt Ein systemeigener Weitere Informationen zu |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt Unterklassen der systemeigenen Fehlertypen sind auch systemeigene Fehler: Ein Wert Umgekehrt gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt Siehe auch |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| is |
Gibt |
| inspect(any, boolean, number | null, boolean) | Die Zirkelbezüge verweisen mithilfe eines Referenzindex auf ihre Verankerung: Im folgenden Beispiel werden alle Eigenschaften des Im folgenden Beispiel wird die Auswirkung der option Mit der Option Mit der Option Mit der Option
|
| promisify<TCustom>(Custom |
Verwendet eine Funktion nach dem allgemeinen Fehlerrückrufstil, d. h. ein Alternativ können Sie auch Wenn eine
Die Verwendung von |
| aborted(Abort |
Lauscht auf das Abbruchereignis für die bereitgestellte |
| add |
Fügt der angegebenen URL einen Parameter hinzu. |
| assign(any[]) | Kopiert die Werte aller aufzählbaren Eigenschaften aus einem oder mehreren Quellobjekten in ein Zielobjekt und gibt das Zielobjekt zurück. |
| auto |
Überprüft, ob die Einbettungs-URL autoAuth=true enthält. |
| callbackify(() => Promise<void>) | Verwendet eine Druckt: Der Rückruf wird asynchron ausgeführt und verfügt über eine eingeschränkte Stapelablaufverfolgung.
Wenn der Rückruf ausgelöst wird, gibt der Prozess ein Da |
| callbackify<TResult>(() => Promise<TResult>) | |
| callbackify<T1>((arg1: T1) => Promise<void>) | |
| callbackify<T1, TResult>((arg1: T1) => Promise<TResult>) | |
| callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>) | |
| callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>) | |
| callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>) | |
| callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>) | |
| callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>) | |
| callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => 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, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => 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, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>) | |
| convert |
Die Wenn Dies ist besonders hilfreich beim Arbeiten mit Prozessen, um den Beendigungscode basierend auf dem Signal zu bestimmen, das den Prozess beendet hat. |
| create |
Generiert eine zufällige 5 bis 6 Zeichenzeichenfolge. |
| debuglog(string, (fn: Debug |
Die Wenn dieses Programm mit dabei ist Die wenn sie mit Mehrere durch Trennzeichen getrennte Das optionale |
| deprecate<T>(T, string, string, Deprecate |
Die Wenn sie aufgerufen wird, gibt Wenn dieselbe optionale Wenn entweder die Wenn die Wenn die Die |
| diff(string | (readonly string[]), string | (readonly string[])) |
Wenn die Werte gleich sind, wird ein leeres Array zurückgegeben. |
| find<T>((x: T) => boolean, T[]) | Sucht den ersten Wert in einem Array, das dem angegebenen Prädikat entspricht. |
| find |
Sucht den Index des ersten Werts in einem Array, das dem angegebenen Prädikat entspricht. |
| format(any, any[]) | Die Wenn ein Bezeichner nicht über ein entsprechendes Argument verfügt, wird er nicht ersetzt: Werte, die nicht Teil der Formatzeichenfolge sind, werden mithilfe von Wenn mehr Argumente an die Wenn das erste Argument keinen gültigen Formatbezeichner enthält, gibt Wenn nur ein Argument an
|
| format |
Diese Funktion ist identisch mit Format, mit der Ausnahme, dass es ein |
| generateUUID() | Generiert eine Uuid mit 20 Zeichen. |
| get |
Gibt ein Array von Aufrufwebsiteobjekten zurück, das den Stapel der Aufruferfunktion enthält. Im Gegensatz zum Zugriff auf ein Es ist möglich, die ursprünglichen Speicherorte zu rekonstruieren, indem Sie die Option |
| get |
|
| get |
Gibt Zufallszahl zurück. |
| get |
Gibt eine Zuordnung aller Systemfehlercodes zurück, die über die Node.js-API verfügbar sind.
Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig.
Informationen zu den Namen häufiger Fehler finden Sie unter |
| get |
Gibt die Zeichenfolgenmeldung für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Zeichenfolgenmeldungen ist plattformabhängig. |
| get |
Gibt den Zeichenfolgennamen für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt.
Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig.
Informationen zu den Namen häufiger Fehler finden Sie unter |
| get |
Gibt das Zeitintervall zwischen zwei Datumsangaben in Millisekunden zurück. |
| inherits(unknown, unknown) | Es wird davon abgeraten, Erben Sie die Prototypmethoden von einem -Konstruktor in einen anderen. Der Prototyp von Dies fügt vor allem einige Eingabeüberprüfungen oben hinzu ES6-Beispiel mit |
| inspect(any, Inspect |
|
| is |
Alias für Gibt |
| is |
Überprüft, ob der Einbettungstyp erstellt wird |
| is |
Gibt Weitere Informationen zur tiefen strengen Gleichheit finden Sie unter |
| is |
Überprüft, ob die Einbettungs-URL für DEN RDL-Bericht gilt. |
| is |
Überprüft, ob der Bericht gespeichert wird. |
| parse |
Stellt eine API auf höherer Ebene für die Befehlszeilenargumentanalyse bereit als die direkte Interaktion mit |
| parse |
Stabilität: 1.1 - Aktive Entwicklung Bei einem Beispiel |
| promisify<TResult>((callback: (err: any, result: TResult) => void) => void) | |
| promisify((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<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, 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, 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, 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(Function) | |
| raise |
Löst ein benutzerdefiniertes Ereignis mit Ereignisdaten für das angegebene HTML-Element aus. |
| remove<T>((x: T) => boolean, T[]) | |
| set |
Aktivieren oder Deaktivieren des Druckens einer Stapelablaufverfolgung auf |
| strip |
Gibt |
| style |
Diese Funktion gibt einen formatierten Text zurück, der den
Wenn Sie ein Array von Formaten übergeben, wird die Reihenfolge des angewendeten Formats von links nach rechts festgelegt, sodass die folgende Formatvorlage die vorherige Formatvorlage überschreiben kann. Der besondere Formatwert Zusätzlich zu vordefinierten Farbnamen Die vollständige Liste der Formate finden Sie in Modifizierern. |
| to |
Gibt den |
| transferable |
Erstellt und gibt eine |
| transferable |
Kennzeichnet die angegebene |
Variablen
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
Details zur Funktion
isAnyArrayBuffer(unknown)
Gibt true zurück, wenn der Wert eine integrierte ArrayBuffer- oder SharedArrayBuffer Instanz ist.
Siehe auch util.types.isArrayBuffer() und util.types.isSharedArrayBuffer().
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLikeParameter
- object
-
unknown
Gibt zurück
object is ArrayBufferLike
isArgumentsObject(unknown)
Gibt true zurück, wenn der Wert ein arguments -Objekt ist.
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArgumentsParameter
- object
-
unknown
Gibt zurück
object is IArguments
isArrayBuffer(unknown)
Gibt true zurück, wenn der Wert eine integrierte ArrayBuffer Instanz ist.
Dies nichtSharedArrayBuffer Instanzen enthalten. In der Regel ist es wünschenswert, beide zu testen; Siehe util.types.isAnyArrayBuffer() dazu.
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBufferParameter
- object
-
unknown
Gibt zurück
object is ArrayBuffer
isArrayBufferView(unknown)
Gibt true zurück, wenn der Wert eine Instanz einer der ArrayBuffer Ansichten ist, z. B. typierte Arrayobjekte oder DataView. Entspricht ArrayBuffer.isView().
util.types.isArrayBufferView(new Int8Array()); // true
util.types.isArrayBufferView(Buffer.from('hello world')); // true
util.types.isArrayBufferView(new DataView(new ArrayBuffer(16))); // true
util.types.isArrayBufferView(new ArrayBuffer()); // false
function isArrayBufferView(object: unknown): object is ArrayBufferViewParameter
- object
-
unknown
Gibt zurück
object is ArrayBufferView
isAsyncFunction(unknown)
Gibt true zurück, wenn der Wert eine asynchrone Funktionist.
Dies meldet nur, was das JavaScript-Modul sieht; Insbesondere entspricht der Rückgabewert möglicherweise nicht dem ursprünglichen Quellcode, wenn ein Transpilierungstool verwendet wurde.
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): booleanParameter
- object
-
unknown
Gibt zurück
boolean
isBigInt64Array(unknown)
Gibt true zurück, wenn der Wert eine BigInt64Array Instanz ist.
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64ArrayParameter
- value
-
unknown
Gibt zurück
value is BigInt64Array
isBigIntObject(unknown)
Gibt true zurück, wenn der Wert ein BigInt -Objekt ist, z. B. von Object(BigInt(123))erstellt.
util.types.isBigIntObject(Object(BigInt(123))); // Returns true
util.types.isBigIntObject(BigInt(123)); // Returns false
util.types.isBigIntObject(123); // Returns false
function isBigIntObject(object: unknown): object is BigIntParameter
- object
-
unknown
Gibt zurück
object is BigInt
isBigUint64Array(unknown)
Gibt true zurück, wenn der Wert eine BigUint64Array Instanz ist.
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64ArrayParameter
- value
-
unknown
Gibt zurück
value is BigUint64Array
isBooleanObject(unknown)
Gibt true zurück, wenn der Wert ein boolesches Objekt ist, z. B. von new Boolean()erstellt.
util.types.isBooleanObject(false); // Returns false
util.types.isBooleanObject(true); // Returns false
util.types.isBooleanObject(new Boolean(false)); // Returns true
util.types.isBooleanObject(new Boolean(true)); // Returns true
util.types.isBooleanObject(Boolean(false)); // Returns false
util.types.isBooleanObject(Boolean(true)); // Returns false
function isBooleanObject(object: unknown): object is BooleanParameter
- object
-
unknown
Gibt zurück
object is Boolean
isBoxedPrimitive(unknown)
Gibt true zurück, wenn es sich bei dem Wert um ein boxed primitives Objekt handelt, z. B. durch new Boolean(), new String() oder Object(Symbol())erstellt.
Beispiel:
util.types.isBoxedPrimitive(false); // Returns false
util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true
function isBoxedPrimitive(object: unknown): object is String | Number | Boolean | Symbol | BigIntParameter
- object
-
unknown
Gibt zurück
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
Gibt true zurück, wenn value ein CryptoKeyist, andernfalls false.
function isCryptoKey(object: unknown): object is CryptoKeyParameter
- object
-
unknown
Gibt zurück
object is CryptoKey
isDataView(unknown)
Gibt true zurück, wenn der Wert eine integrierte DataView Instanz ist.
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
Siehe auch ArrayBuffer.isView().
function isDataView(object: unknown): object is DataViewParameter
- object
-
unknown
Gibt zurück
object is DataView
isDate(unknown)
Gibt true zurück, wenn der Wert eine integrierte Date Instanz ist.
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is DateParameter
- object
-
unknown
Gibt zurück
object is Date
isExternal(unknown)
Gibt true zurück, wenn der Wert ein systemeigener External Wert ist.
Ein systemeigener External-Wert ist ein spezieller Objekttyp, der einen unformatierten C++-Zeiger (void*) für den Zugriff von systemeigenem Code enthält und keine anderen Eigenschaften aufweist. Solche Objekte werden entweder durch Node.js Interne oder systemeigene Addons erstellt. In JavaScript sind sie fixierte Objekte mit einem null Prototyp.
#include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(napi_env env, napi_callback_info info) {
int* raw = (int*) malloc(1024);
napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
if (status != napi_ok) {
napi_throw_error(env, NULL, "napi_create_external failed");
return NULL;
}
return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...
import native from 'napi_addon.node';
import { types } from 'node:util';
const data = native.myNapi();
types.isExternal(data); // returns true
types.isExternal(0); // returns false
types.isExternal(new String('foo')); // returns false
Weitere Informationen zu napi_create_externalfinden Sie unter napi_create_external().
function isExternal(object: unknown): booleanParameter
- object
-
unknown
Gibt zurück
boolean
isFloat16Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Float16Array Instanz ist.
util.types.isFloat16Array(new ArrayBuffer()); // Returns false
util.types.isFloat16Array(new Float16Array()); // Returns true
util.types.isFloat16Array(new Float32Array()); // Returns false
function isFloat16Array(object: unknown): object is Float16ArrayParameter
- object
-
unknown
Gibt zurück
object is Float16Array
isFloat32Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Float32Array Instanz ist.
util.types.isFloat32Array(new ArrayBuffer()); // Returns false
util.types.isFloat32Array(new Float32Array()); // Returns true
util.types.isFloat32Array(new Float64Array()); // Returns false
function isFloat32Array(object: unknown): object is Float32ArrayParameter
- object
-
unknown
Gibt zurück
object is Float32Array
isFloat64Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Float64Array Instanz ist.
util.types.isFloat64Array(new ArrayBuffer()); // Returns false
util.types.isFloat64Array(new Uint8Array()); // Returns false
util.types.isFloat64Array(new Float64Array()); // Returns true
function isFloat64Array(object: unknown): object is Float64ArrayParameter
- object
-
unknown
Gibt zurück
object is Float64Array
isGeneratorFunction(unknown)
Gibt true zurück, wenn der Wert eine Generatorfunktion ist.
Dies meldet nur, was das JavaScript-Modul sieht; Insbesondere entspricht der Rückgabewert möglicherweise nicht dem ursprünglichen Quellcode, wenn ein Transpilierungstool verwendet wurde.
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunctionParameter
- object
-
unknown
Gibt zurück
object is GeneratorFunction
isGeneratorObject(unknown)
Gibt true zurück, wenn der Wert ein Generatorobjekt ist, das von einer integrierten Generatorfunktion zurückgegeben wird.
Dies meldet nur, was das JavaScript-Modul sieht; Insbesondere entspricht der Rückgabewert möglicherweise nicht dem ursprünglichen Quellcode, wenn ein Transpilierungstool verwendet wurde.
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is GeneratorParameter
- object
-
unknown
Gibt zurück
object is Generator
isInt16Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Int16Array Instanz ist.
util.types.isInt16Array(new ArrayBuffer()); // Returns false
util.types.isInt16Array(new Int16Array()); // Returns true
util.types.isInt16Array(new Float64Array()); // Returns false
function isInt16Array(object: unknown): object is Int16ArrayParameter
- object
-
unknown
Gibt zurück
object is Int16Array
isInt32Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Int32Array Instanz ist.
util.types.isInt32Array(new ArrayBuffer()); // Returns false
util.types.isInt32Array(new Int32Array()); // Returns true
util.types.isInt32Array(new Float64Array()); // Returns false
function isInt32Array(object: unknown): object is Int32ArrayParameter
- object
-
unknown
Gibt zurück
object is Int32Array
isInt8Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Int8Array Instanz ist.
util.types.isInt8Array(new ArrayBuffer()); // Returns false
util.types.isInt8Array(new Int8Array()); // Returns true
util.types.isInt8Array(new Float64Array()); // Returns false
function isInt8Array(object: unknown): object is Int8ArrayParameter
- object
-
unknown
Gibt zurück
object is Int8Array
isKeyObject(unknown)
Gibt true zurück, wenn value ein KeyObjectist, andernfalls false.
function isKeyObject(object: unknown): object is KeyObjectParameter
- object
-
unknown
Gibt zurück
object is KeyObject
isMap<T>({} | T)
Gibt true zurück, wenn der Wert eine integrierte Map Instanz ist.
util.types.isMap(new Map()); // Returns true
function isMap<T>(object: {} | T): object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)Parameter
- object
-
{} | T
Gibt zurück
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
Gibt true zurück, wenn der Wert ein Iterator ist, der für eine integrierte Map Instanz zurückgegeben wird.
const map = new Map();
util.types.isMapIterator(map.keys()); // Returns true
util.types.isMapIterator(map.values()); // Returns true
util.types.isMapIterator(map.entries()); // Returns true
util.types.isMapIterator(map[Symbol.iterator]()); // Returns true
function isMapIterator(object: unknown): booleanParameter
- object
-
unknown
Gibt zurück
boolean
isModuleNamespaceObject(unknown)
Gibt true zurück, wenn der Wert eine Instanz eines Module Namespace Objectist.
import * as ns from './a.js';
util.types.isModuleNamespaceObject(ns); // Returns true
function isModuleNamespaceObject(value: unknown): booleanParameter
- value
-
unknown
Gibt zurück
boolean
isNativeError(unknown)
Warnung
Diese API ist nun veraltet.
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
Gibt true zurück, wenn der Wert vom Konstruktor eines integrierten Error Typszurückgegeben wurde.
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // true
Unterklassen der systemeigenen Fehlertypen sind auch systemeigene Fehler:
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
Ein Wert instanceof einer systemeigenen Fehlerklasse entspricht nicht isNativeError() rückgabenden true für diesen Wert.
isNativeError() gibt true für Fehler zurück, die aus einem anderen Bereich stammen, während instanceof Error für diese Fehler false zurückgibt:
import { createContext, runInContext } from 'node:vm';
import { types } from 'node:util';
const context = createContext({});
const myError = runInContext('new Error()', context);
console.log(types.isNativeError(myError)); // true
console.log(myError instanceof Error); // false
Umgekehrt gibt isNativeError()false für alle Objekte zurück, die nicht vom Konstruktor eines systemeigenen Fehlers zurückgegeben wurden. Dazu gehören Werte, die instanceof systemeigenen Fehler sind:
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
function isNativeError(object: unknown): object is ErrorParameter
- object
-
unknown
Gibt zurück
object is Error
isNumberObject(unknown)
Gibt true zurück, wenn der Wert ein Zahlenobjekt ist, z. B. von new Number()erstellt.
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is NumberParameter
- object
-
unknown
Gibt zurück
object is Number
isPromise(unknown)
Gibt true zurück, wenn der Wert ein integriertes Promiseist.
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>Parameter
- object
-
unknown
Gibt zurück
object is Promise<unknown>
isProxy(unknown)
Gibt true zurück, wenn der Wert eine Proxy Instanz ist.
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
function isProxy(object: unknown): booleanParameter
- object
-
unknown
Gibt zurück
boolean
isRegExp(unknown)
Gibt true zurück, wenn der Wert ein reguläres Ausdrucksobjekt ist.
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExpParameter
- object
-
unknown
Gibt zurück
object is RegExp
isSet<T>({} | T)
Gibt true zurück, wenn der Wert eine integrierte Set Instanz ist.
util.types.isSet(new Set()); // Returns true
function isSet<T>(object: {} | T): object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)Parameter
- object
-
{} | T
Gibt zurück
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
Gibt true zurück, wenn der Wert ein Iterator ist, der für eine integrierte Set Instanz zurückgegeben wird.
const set = new Set();
util.types.isSetIterator(set.keys()); // Returns true
util.types.isSetIterator(set.values()); // Returns true
util.types.isSetIterator(set.entries()); // Returns true
util.types.isSetIterator(set[Symbol.iterator]()); // Returns true
function isSetIterator(object: unknown): booleanParameter
- object
-
unknown
Gibt zurück
boolean
isSharedArrayBuffer(unknown)
Gibt true zurück, wenn der Wert eine integrierte SharedArrayBuffer Instanz ist.
Dies nichtArrayBuffer Instanzen enthalten. In der Regel ist es wünschenswert, beide zu testen; Siehe util.types.isAnyArrayBuffer() dazu.
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBufferParameter
- object
-
unknown
Gibt zurück
object is SharedArrayBuffer
isStringObject(unknown)
Gibt true zurück, wenn der Wert ein Zeichenfolgenobjekt ist, z. B. von new String()erstellt.
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is StringParameter
- object
-
unknown
Gibt zurück
object is String
isSymbolObject(unknown)
Gibt true zurück, wenn der Wert ein Symbolobjekt ist, das durch Aufrufen von Object() für einen Symbol Grundtyp erstellt wird.
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is SymbolParameter
- object
-
unknown
Gibt zurück
object is Symbol
isTypedArray(unknown)
Gibt true zurück, wenn der Wert eine integrierte TypedArray Instanz ist.
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
Siehe auch ArrayBuffer.isView().
function isTypedArray(object: unknown): object is TypedArrayParameter
- object
-
unknown
Gibt zurück
object is TypedArray
isUint16Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Uint16Array Instanz ist.
util.types.isUint16Array(new ArrayBuffer()); // Returns false
util.types.isUint16Array(new Uint16Array()); // Returns true
util.types.isUint16Array(new Float64Array()); // Returns false
function isUint16Array(object: unknown): object is Uint16ArrayParameter
- object
-
unknown
Gibt zurück
object is Uint16Array
isUint32Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Uint32Array Instanz ist.
util.types.isUint32Array(new ArrayBuffer()); // Returns false
util.types.isUint32Array(new Uint32Array()); // Returns true
util.types.isUint32Array(new Float64Array()); // Returns false
function isUint32Array(object: unknown): object is Uint32ArrayParameter
- object
-
unknown
Gibt zurück
object is Uint32Array
isUint8Array(unknown)
Gibt true zurück, wenn der Wert eine integrierte Uint8Array Instanz ist.
util.types.isUint8Array(new ArrayBuffer()); // Returns false
util.types.isUint8Array(new Uint8Array()); // Returns true
util.types.isUint8Array(new Float64Array()); // Returns false
function isUint8Array(object: unknown): object is Uint8ArrayParameter
- object
-
unknown
Gibt zurück
object is Uint8Array
isUint8ClampedArray(unknown)
Gibt true zurück, wenn der Wert eine integrierte Uint8ClampedArray Instanz ist.
util.types.isUint8ClampedArray(new ArrayBuffer()); // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray()); // Returns true
util.types.isUint8ClampedArray(new Float64Array()); // Returns false
function isUint8ClampedArray(object: unknown): object is Uint8ClampedArrayParameter
- object
-
unknown
Gibt zurück
object is Uint8ClampedArray
isWeakMap(unknown)
Gibt true zurück, wenn der Wert eine integrierte WeakMap Instanz ist.
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>Parameter
- object
-
unknown
Gibt zurück
object is WeakMap<object, unknown>
isWeakSet(unknown)
Gibt true zurück, wenn der Wert eine integrierte WeakSet Instanz ist.
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>Parameter
- object
-
unknown
Gibt zurück
object is WeakSet<object>
inspect(any, boolean, number | null, boolean)
Die util.inspect() Methode gibt eine Zeichenfolgendarstellung von object zurück, die für das Debuggen vorgesehen ist. Die Ausgabe von util.inspect kann sich jederzeit ändern und sollte nicht programmgesteuert abhängig sein. Zusätzliche options können übergeben werden, die das Ergebnis ändern.
util.inspect() verwendet den Namen und/oder Symbol.toStringTag die Eigenschaft des Konstruktors, um ein identifizierbares Tag für einen geprüften Wert zu erstellen.
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] {}'
Zirkelbezüge verweisen mithilfe eines Referenzindex auf ihre Verankerung:
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] }
// }
Im folgenden Beispiel werden alle Eigenschaften des util-Objekts überprüft:
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
Im folgenden Beispiel wird die Auswirkung der option compact hervorgehoben:
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.
Mit der Option showHidden können WeakMap und WeakSet Einträge überprüft werden. Wenn mehr Einträge als maxArrayLengthvorhanden sind, gibt es keine Garantie, welche Einträge angezeigt werden. Das bedeutet, dass das Abrufen desselben WeakSet Einträge zweimal zu einer anderen Ausgabe führen kann. Darüber hinaus können Einträge ohne verbleibende starke Verweise jederzeit garbage collection sein.
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 } }
Mit der Option sorted wird sichergestellt, dass die Einfügereihenfolge eines Objekts nicht auf das Ergebnis util.inspect()wirkt.
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 }),
);
Mit der Option numericSeparator werden allen Zahlen alle drei Ziffern ein Unterstrich hinzugefügt.
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() ist eine synchrone Methode zum Debuggen. Die maximale Ausgangslänge beträgt ca. 128 MiB. Eingaben, die zu einer längeren Ausgabe führen, werden abgeschnitten.
function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): stringParameter
- object
-
any
Jeder JavaScript-Grundtyp oder Object.
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
Gibt zurück
string
Die Darstellung von object.
promisify<TCustom>(CustomPromisify<TCustom>)
Verwendet eine Funktion nach dem allgemeinen Fehlerrückrufstil, d. h. ein (err, value) => ... Rückruf als letztes Argument zu übernehmen und eine Version zurück, die Zusagen zurückgibt.
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.
});
Alternativ können Sie auch async functions verwenden:
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();
Wenn eine original[util.promisify.custom] Eigenschaft vorhanden ist, promisify wird der Wert zurückgegeben, siehe benutzerdefinierte promisifizierte Funktionen.
promisify() geht davon aus, dass original eine Funktion ist, die einen Rückruf als letztes Argument in allen Fällen annimmt. Wenn original keine Funktion ist, löst promisify() einen Fehler aus. Wenn original eine Funktion ist, aber das letzte Argument kein Fehlerrückruf ist, wird weiterhin ein Fehlerrückruf als letztes Argument übergeben.
Die Verwendung von promisify() für Klassenmethoden oder andere Methoden, die this verwenden, funktioniert möglicherweise nicht wie erwartet, es sei denn, es wird speziell behandelt:
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>): TCustomParameter
- fn
-
CustomPromisify<TCustom>
Gibt zurück
TCustom
aborted(AbortSignal, any)
Lauscht auf das Abbruchereignis für die bereitgestellte signal und gibt eine Zusage zurück, die aufgelöst wird, wenn die signal abgebrochen wird.
Wenn resource bereitgestellt wird, verweist sie schwach auf das zugeordnete Objekt des Vorgangs. Wenn also resource vor dem signal abgebrochen wird, bleibt die zurückgegebene Zusage ausstehend.
Dadurch werden Speicherlecks in lang ausgeführten oder nicht abbruchfähigen Vorgängen verhindert.
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>Parameter
- signal
-
AbortSignal
- resource
-
any
Jedes Nicht-Null-Objekt, das an den abgebrochenen Vorgang gebunden ist und schwach gehalten wird.
Wenn resource vor dem Abbruch der signal garbage gesammelt wird, bleibt die Zusage ausstehend, sodass Node.js die Nachverfolgung beenden kann.
Dadurch wird verhindert, dass Speicherverluste in lang ausgeführten oder nicht abbruchfähigen Vorgängen auftreten.
Gibt zurück
Promise<void>
addParamToUrl(string, string, string)
Fügt der angegebenen URL einen Parameter hinzu.
function addParamToUrl(url: string, paramName: string, value: string): stringParameter
- url
-
string
- paramName
-
string
- value
-
string
Gibt zurück
string
assign(any[])
Kopiert die Werte aller aufzählbaren Eigenschaften aus einem oder mehreren Quellobjekten in ein Zielobjekt und gibt das Zielobjekt zurück.
function assign(args: any[]): anyParameter
- args
-
any[]
Gibt zurück
any
autoAuthInEmbedUrl(string)
Überprüft, ob die Einbettungs-URL autoAuth=true enthält.
function autoAuthInEmbedUrl(embedUrl: string): booleanParameter
- embedUrl
-
string
Gibt zurück
boolean
callbackify(() => Promise<void>)
Verwendet eine async Funktion (oder eine Funktion, die eine Promisezurückgibt) und gibt eine Funktion nach dem Fehlerrückrufstil zurück, d. h. ein (err, value) => ... Rückruf als letztes Argument. Im Rückruf ist das erste Argument der Ablehnungsgrund (oder null, wenn die Promise aufgelöst wurde), und das zweite Argument ist der aufgelöste Wert.
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);
});
Druckt:
hello world
Der Rückruf wird asynchron ausgeführt und verfügt über eine eingeschränkte Stapelablaufverfolgung.
Wenn der Rückruf ausgelöst wird, gibt der Prozess ein 'uncaughtException' Ereignis aus, und wenn nicht behandelt wird, wird das Ereignis beendet.
Da null eine besondere Bedeutung als erstes Argument für einen Rückruf hat, wenn eine umschlossene Funktion eine Promise mit einem gefälschten Wert als Grund ablehnt, wird der Wert in eine Error mit dem ursprünglichen Wert eingeschlossen, der in einem Feld mit dem Namen reasongespeichert ist.
import util from 'node:util';
function fn() {
return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err, ret) => {
// When the Promise was rejected with `null` it is wrapped with an Error and
// the original value is stored in `reason`.
err && Object.hasOwn(err, 'reason') && err.reason === null; // true
});
function callbackify(fn: () => Promise<void>): (callback: (err: ErrnoException) => void) => voidParameter
- fn
-
() => Promise<void>
Eine async-Funktion
Gibt zurück
(callback: (err: ErrnoException) => void) => void
Eine Rückrufformatfunktion
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => voidParameter
- fn
-
() => Promise<TResult>
Gibt zurück
(callback: (err: ErrnoException, result: TResult) => void) => void
callbackify<T1>((arg1: T1) => Promise<void>)
function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1) => Promise<void>
Gibt zurück
(arg1: T1, callback: (err: ErrnoException) => void) => void
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: ErrnoException, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1) => Promise<TResult>
Gibt zurück
(arg1: T1, callback: (err: ErrnoException, 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: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Gibt zurück
(arg1: T1, arg2: T2, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Gibt zurück
(arg1: T1, arg2: T2, callback: (err: 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: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, callback: (err: 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: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: 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: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: 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: ErrnoException | null, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: 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: ErrnoException) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException) => void) => void
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: ErrnoException | null, result: TResult) => void) => voidParameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException | null, result: TResult) => void) => void
convertProcessSignalToExitCode(Signals)
Die util.convertProcessSignalToExitCode() Methode konvertiert einen Signalnamen in den entsprechenden POSIX-Ausgangscode. Nach dem POSIX-Standard wird der Ausgangscode für einen Prozess, der durch ein Signal beendet wird, als 128 + signal numberberechnet.
Wenn signal es sich nicht um einen gültigen Signalnamen handelt, wird ein Fehler ausgelöst. Eine Liste der gültigen Signale finden Sie signal(7) unter.
import { convertProcessSignalToExitCode } from 'node:util';
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
Dies ist besonders hilfreich beim Arbeiten mit Prozessen, um den Beendigungscode basierend auf dem Signal zu bestimmen, das den Prozess beendet hat.
function convertProcessSignalToExitCode(signal: Signals): numberParameter
- signal
-
Signals
Ein Signalname (z. B. 'SIGTERM')
Gibt zurück
number
Der Beendigungscode, der dem signal
createRandomString()
Generiert eine zufällige 5 bis 6 Zeichenzeichenfolge.
function createRandomString(): stringGibt zurück
string
debuglog(string, (fn: DebugLoggerFunction) => void)
Die util.debuglog() Methode wird verwendet, um eine Funktion zu erstellen, die Debugmeldungen stderr bedingt basierend auf dem Vorhandensein der NODE_DEBUG Umgebungsvariable schreibt. Wenn der section Name innerhalb des Werts dieser Umgebungsvariable angezeigt wird, funktioniert die zurückgegebene Funktion ähnlich wie console.error(). Wenn nicht, ist die zurückgegebene Funktion eine no-op.
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hello from foo [%d]', 123);
Wenn dieses Programm mit NODE_DEBUG=foo in der Umgebung ausgeführt wird, gibt es etwas wie folgt aus:
FOO 3245: hello from foo [123]
dabei ist 3245 die Prozess-ID. Wenn sie nicht mit diesem Umgebungsvariablensatz ausgeführt wird, wird nichts gedruckt.
Die section unterstützt auch Folgendes:
import { debuglog } from 'node:util';
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);
wenn sie mit NODE_DEBUG=foo* in der Umgebung ausgeführt wird, wird folgendes ausgegeben:
FOO-BAR 3257: hi there, it's foo-bar [2333]
Mehrere durch Trennzeichen getrennte section Namen können in der Umgebungsvariable NODE_DEBUG angegeben werden: NODE_DEBUG=fs,net,tls.
Das optionale callback-Argument kann verwendet werden, um die Protokollierungsfunktion durch eine andere Funktion zu ersetzen, die keine Initialisierung oder unnötigen Umbruch enthält.
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): DebugLoggerParameter
- section
-
string
Eine Zeichenfolge, die den Teil der Anwendung angibt, für den die debuglog-Funktion erstellt wird.
- callback
-
(fn: DebugLoggerFunction) => void
Ein Rückruf wird aufgerufen, wenn die Protokollierungsfunktion zum ersten Mal mit einem Funktionsargument aufgerufen wird, bei dem es sich um eine optimierte Protokollierungsfunktion handelt.
Gibt zurück
Die Protokollierungsfunktion
deprecate<T>(T, string, string, DeprecateOptions)
Die util.deprecate()-Methode umschließt fn (die eine Funktion oder Klasse sein kann), sodass sie als veraltet gekennzeichnet ist.
import { deprecate } from 'node:util';
export const obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
Wenn sie aufgerufen wird, gibt util.deprecate() eine Funktion zurück, die mithilfe des DeprecationWarning-Ereignisses eine 'warning' ausgibt. Die Warnung wird ausgegeben und in stderr gedruckt, wenn die zurückgegebene Funktion zum ersten Mal aufgerufen wird. Nachdem die Warnung ausgegeben wurde, wird die umschlossene Funktion aufgerufen, ohne eine Warnung auszusetzen.
Wenn dieselbe optionale code in mehreren Aufrufen von util.deprecate()angegeben wird, wird die Warnung nur einmal für diese codeausgegeben.
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
Wenn entweder die --no-deprecation- oder --no-warnings Befehlszeilenflaggen verwendet werden oder die process.noDeprecation-Eigenschaft auf truevor dem auf die erste Warnung zum Veraltet festgelegt ist, führt die util.deprecate() Methode nichts aus.
Wenn die --trace-deprecation- oder --trace-warnings Befehlszeilenkennzeichnungen festgelegt sind oder die process.traceDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Warnung und eine Stapelablaufverfolgung beim ersten Aufruf der veralteten Funktion in stderr gedruckt.
Wenn die --throw-deprecation Befehlszeilenkennzeichnung festgelegt ist oder die process.throwDeprecation-Eigenschaft auf truefestgelegt ist, wird eine Ausnahme ausgelöst, wenn die veraltete Funktion aufgerufen wird.
Die --throw-deprecation Befehlszeilenkennzeichnung und process.throwDeprecation Eigenschaft haben Vorrang vor --trace-deprecation und process.traceDeprecation.
function deprecate<T>(fn: T, msg: string, code?: string, options?: DeprecateOptions): TParameter
- fn
-
T
Die Funktion, die veraltet ist.
- msg
-
string
Eine Warnmeldung, die angezeigt wird, wenn die veraltete Funktion aufgerufen wird.
- code
-
string
Ein Veralteter Code. Eine Liste der Codes finden Sie im list of deprecated APIs.
- options
- DeprecateOptions
Gibt zurück
T
Die veraltete Funktion, die zum Ausgeben einer Warnung umschlossen ist.
diff(string | (readonly string[]), string | (readonly string[]))
util.diff() Vergleicht zwei Zeichenfolgen- oder Arraywerte und gibt ein Array mit Differenzeinträgen zurück.
Es verwendet den Myers-Diff-Algorithmus, um minimale Unterschiede zu berechnen, was derselbe Algorithmus ist, der intern von Assertionsfehlermeldungen verwendet wird.
Wenn die Werte gleich sind, wird ein leeres Array zurückgegeben.
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[]Parameter
- actual
-
string | (readonly string[])
Der erste zu vergleichende Wert
- expected
-
string | (readonly string[])
Der zweite zu vergleichende Wert
Gibt zurück
Ein Array mit Differenzeinträgen. Jeder Eintrag ist ein Array mit zwei Elementen:
- Index 0: Operation code:
number-1for delete,0for no-op/unchanged, for insert,1for insert - Index 1:
stringDer dem Vorgang zugeordnete Wert
find<T>((x: T) => boolean, T[])
Sucht den ersten Wert in einem Array, das dem angegebenen Prädikat entspricht.
function find<T>(predicate: (x: T) => boolean, xs: T[]): TParameter
- predicate
-
(x: T) => boolean
- xs
-
T[]
Gibt zurück
T
findIndex<T>((x: T) => boolean, T[])
Sucht den Index des ersten Werts in einem Array, das dem angegebenen Prädikat entspricht.
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): numberParameter
- predicate
-
(x: T) => boolean
- xs
-
T[]
Gibt zurück
number
format(any, any[])
Die util.format() Methode gibt eine formatierte Zeichenfolge mit dem ersten Argument als printf-ähnliche Formatzeichenfolge zurück, die null oder mehr Formatbezeichner enthalten kann. Jeder Bezeichner wird durch den konvertierten Wert aus dem entsprechenden Argument ersetzt. Unterstützte Bezeichner sind:
Wenn ein Bezeichner nicht über ein entsprechendes Argument verfügt, wird er nicht ersetzt:
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
Werte, die nicht Teil der Formatzeichenfolge sind, werden mithilfe von util.inspect() formatiert, wenn ihr Typ nicht stringist.
Wenn mehr Argumente an die util.format()-Methode übergeben werden als die Anzahl der Bezeichner, werden die zusätzlichen Argumente mit der zurückgegebenen Zeichenfolge verkettet, getrennt durch Leerzeichen:
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
Wenn das erste Argument keinen gültigen Formatbezeichner enthält, gibt util.format() eine Zeichenfolge zurück, die die Verkettung aller Argumente ist, die durch Leerzeichen getrennt sind:
util.format(1, 2, 3);
// Returns: '1 2 3'
Wenn nur ein Argument an util.format()übergeben wird, wird es wie ohne Formatierung zurückgegeben:
util.format('%% %s');
// Returns: '%% %s'
util.format() ist eine synchrone Methode, die als Debuggingtool vorgesehen ist.
Einige Eingabewerte können einen erheblichen Leistungsaufwand haben, der die Ereignisschleife blockieren kann. Verwenden Sie diese Funktion mit Bedacht und niemals in einem hot-Code-Pfad.
function format(format?: any, param: any[]): stringParameter
- format
-
any
Eine printf-ähnliche Formatzeichenfolge.
- param
-
any[]
Gibt zurück
string
formatWithOptions(InspectOptions, any, any[])
Diese Funktion ist identisch mit Format, mit der Ausnahme, dass es ein inspectOptions Argument verwendet, das Optionen angibt, die an inspectübergeben werden.
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[]): stringParameter
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Gibt zurück
string
generateUUID()
Generiert eine Uuid mit 20 Zeichen.
function generateUUID(): stringGibt zurück
string
getCallSites(number, GetCallSitesOptions)
Gibt ein Array von Aufrufwebsiteobjekten zurück, das den Stapel der Aufruferfunktion enthält.
Im Gegensatz zum Zugriff auf ein error.stackApi-Ergebnis wird das von dieser API zurückgegebene Ergebnis nicht beeinträchtigt Error.prepareStackTrace.
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.columnNumber}`);
});
// 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();
Es ist möglich, die ursprünglichen Speicherorte zu rekonstruieren, indem Sie die Option sourceMap auf truefestlegen.
Wenn die Quellkarte nicht verfügbar ist, entspricht der ursprüngliche Speicherort dem aktuellen Speicherort.
Wenn die Kennzeichnung aktiviert ist, --enable-source-maps ist dies sourceMap standardmäßig "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[]Parameter
- frameCount
-
number
Anzahl der Frames, die als Aufrufwebsiteobjekte erfasst werden sollen.
Standard:10. Zulässiger Bereich liegt zwischen 1 und 200.
- options
- GetCallSitesOptions
Gibt zurück
Ein Array von Aufrufwebsiteobjekten
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]Parameter
- options
- GetCallSitesOptions
Gibt zurück
getRandomValue()
Gibt Zufallszahl zurück.
function getRandomValue(): numberGibt zurück
number
getSystemErrorMap()
Gibt eine Zuordnung aller Systemfehlercodes zurück, die über die Node.js-API verfügbar sind.
Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig.
Informationen zu den Namen häufiger Fehler finden Sie unter 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]>Gibt zurück
Map<number, [string, string]>
getSystemErrorMessage(number)
Gibt die Zeichenfolgenmeldung für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt. Die Zuordnung zwischen Fehlercodes und Zeichenfolgenmeldungen ist plattformabhängig.
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): stringParameter
- err
-
number
Gibt zurück
string
getSystemErrorName(number)
Gibt den Zeichenfolgennamen für einen numerischen Fehlercode zurück, der aus einer Node.js-API stammt.
Die Zuordnung zwischen Fehlercodes und Fehlernamen ist plattformabhängig.
Informationen zu den Namen häufiger Fehler finden Sie unter 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): stringParameter
- err
-
number
Gibt zurück
string
getTimeDiffInMilliseconds(Date, Date)
Gibt das Zeitintervall zwischen zwei Datumsangaben in Millisekunden zurück.
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParameter
- start
-
Date
- end
-
Date
Gibt zurück
number
inherits(unknown, unknown)
Es wird davon abgeraten, util.inherits() zu verwenden. Verwenden Sie die Schlüsselwörter ES6 class und extends, um unterstützung für die Vererbung auf Sprachenebene zu erhalten. Beachten Sie außerdem, dass die beiden Formatvorlagen semantisch inkompatibelsind.
Erben Sie die Prototypmethoden von einem -Konstruktor in einen anderen. Der Prototyp von constructor wird auf ein neues Objekt festgelegt, das aus superConstructorerstellt wurde.
Dies fügt vor allem einige Eingabeüberprüfungen oben hinzu Object.setPrototypeOf(constructor.prototype, superConstructor.prototype).
Als zusätzlichen Komfort wird superConstructor über die eigenschaft constructor.super_ zugänglich sein.
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-Beispiel mit class und 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)Parameter
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParameter
- object
-
any
- options
- InspectOptions
Gibt zurück
string
isArray(unknown)
Warnung
Diese API ist nun veraltet.
Since v4.0.0 - Use isArray instead.
Alias für Array.isArray().
Gibt true zurück, wenn die angegebene object ein Arrayist. Andernfalls wird false zurückgegeben.
import util from 'node:util';
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
function isArray(object: unknown): object is unknown[]Parameter
- object
-
unknown
Gibt zurück
object is unknown[]
isCreate(string)
Überprüft, ob der Einbettungstyp erstellt wird
function isCreate(embedType: string): booleanParameter
- embedType
-
string
Gibt zurück
boolean
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)
Gibt true zurück, wenn es eine tiefe strenge Gleichheit zwischen val1 und val2gibt.
Andernfalls wird false zurückgegeben.
Weitere Informationen zur tiefen strengen Gleichheit finden Sie unter assert.deepStrictEqual().
function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): booleanParameter
- val1
-
unknown
- val2
-
unknown
- options
- IsDeepStrictEqualOptions
Gibt zurück
boolean
isRDLEmbed(string)
Überprüft, ob die Einbettungs-URL für DEN RDL-Bericht gilt.
function isRDLEmbed(embedUrl: string): booleanParameter
- embedUrl
-
string
Gibt zurück
boolean
isSavedInternal(HttpPostMessage, string, Window)
Überprüft, ob der Bericht gespeichert wird.
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>Parameter
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
- Window
Gibt zurück
Promise<boolean>
parseArgs<T>(T)
Stellt eine API auf höherer Ebene für die Befehlszeilenargumentanalyse bereit als die direkte Interaktion mit process.argv. Verwendet eine Spezifikation für die erwarteten Argumente und gibt ein strukturiertes Objekt mit den analysierten Optionen und Positionalen zurück.
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>Parameter
- config
-
T
Wird verwendet, um Argumente für die Analyse bereitzustellen und den Parser zu konfigurieren.
config unterstützt die folgenden Eigenschaften:
Gibt zurück
ParsedResults<T>
Die analysierten Befehlszeilenargumente:
parseEnv(string)
Stabilität: 1.1 - Aktive Entwicklung Bei einem Beispiel .env Datei:
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): Dict<string>Parameter
- content
-
string
Der rohe Inhalt einer .env Datei.
Gibt zurück
Dict<string>
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>Parameter
- fn
-
(callback: (err: any, result: TResult) => void) => void
Gibt zurück
() => Promise<TResult>
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>Parameter
- fn
-
(callback: (err?: any) => void) => void
Gibt zurück
() => 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>Parameter
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
Gibt zurück
(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>Parameter
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
Gibt zurück
(arg1: T1) => 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>Parameter
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
Gibt zurück
(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>Parameter
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
Gibt zurück
(arg1: T1, arg2: T2) => 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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
Gibt zurück
(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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3) => 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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
Gibt zurück
(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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
Gibt zurück
(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>Parameter
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
Gibt zurück
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
promisify(Function)
function promisify(fn: Function): FunctionParameter
- fn
-
Function
Gibt zurück
Function
raiseCustomEvent(HTMLElement, string, any)
Löst ein benutzerdefiniertes Ereignis mit Ereignisdaten für das angegebene HTML-Element aus.
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)Parameter
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])Parameter
- predicate
-
(x: T) => boolean
- xs
-
T[]
setTraceSigInt(boolean)
Aktivieren oder Deaktivieren des Druckens einer Stapelablaufverfolgung auf SIGINT. Die API ist nur im Hauptthread verfügbar.
function setTraceSigInt(enable: boolean)Parameter
- enable
-
boolean
stripVTControlCharacters(string)
Gibt str zurück, wobei alle ANSI-Escapecodes entfernt wurden.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): stringParameter
- str
-
string
Gibt zurück
string
styleText(InspectColor | (readonly InspectColor[]) | Object, string, StyleTextOptions)
Diese Funktion gibt einen formatierten Text zurück, der den format übergebenen Druckvorgang in einem Terminal berücksichtigt. Es ist sich der Funktionen des Terminals bewusst und verhält sich entsprechend dem Konfigurationssatz über NO_COLORund NODE_DISABLE_COLORSFORCE_COLOR Umgebungsvariablen.
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 stellt auch Textformate wie italicund underline bereit, und Sie können beides kombinieren:
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
Wenn Sie ein Array von Formaten übergeben, wird die Reihenfolge des angewendeten Formats von links nach rechts festgelegt, sodass die folgende Formatvorlage die vorherige Formatvorlage überschreiben kann.
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
Der besondere Formatwert none wendet keine zusätzliche Formatierung auf den Text an.
Zusätzlich zu vordefinierten Farbnamen util.styleText() unterstützt Hex-Farbzeichenfolgen mithilfe von ANSI TrueColor (24-Bit)-Escapesequenzen. Hexfarben können entweder im 3-stelligen (#RGB) oder 6-stelligen (#RRGGBB) Format angegeben werden:
import { styleText } from 'node:util';
// 6-digit hex color
console.log(styleText('#ff5733', 'Orange text'));
// 3-digit hex color (shorthand)
console.log(styleText('#f00', 'Red text'));
Die vollständige Liste der Formate finden Sie in Modifizierern.
function styleText(format: InspectColor | (readonly InspectColor[]) | Object, text: string, options?: StyleTextOptions): stringParameter
- format
-
InspectColor | (readonly InspectColor[]) | Object
Ein Textformat oder ein Array von Textformaten, die in util.inspect.colorsoder in einer Hexadefiniertfarbe oder #RGB#RRGGBB form definiert sind.
- text
-
string
Der zu formatierende Text.
- options
- StyleTextOptions
Gibt zurück
string
toUSVString(string)
Gibt den string zurück, nachdem alle Ersatzcodepunkte (oder gleichwertig, alle entkoppelten Ersatzcodeeinheiten) durch das Unicode-Zeichen "Ersetzungszeichen" U+FFFD ersetzt wurden.
function toUSVString(string: string): stringParameter
- string
-
string
Gibt zurück
string
transferableAbortController()
Erstellt und gibt eine AbortController Instanz zurück, deren AbortSignal als übertragbar gekennzeichnet ist und mit structuredClone() oder postMessage()verwendet werden kann.
function transferableAbortController(): AbortControllerGibt zurück
AbortController
Ein übertragbarer AbortController
transferableAbortSignal(AbortSignal)
Kennzeichnet die angegebene AbortSignal als übertragbar, damit sie mitstructuredClone() und postMessage()verwendet werden kann.
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignalParameter
- signal
-
AbortSignal
Das AbortSignal
Gibt zurück
AbortSignal
Dasselbe AbortSignal
Details zu Variablen
APINotSupportedForRDLError
APINotSupportedForRDLError: "This API is currently not supported for RDL reports"Typ
"This API is currently not supported for RDL reports"
EmbedUrlNotSupported
EmbedUrlNotSupported: "Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"Typ
"Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"
TextDecoder
TextDecoder: (label?: string, options?: TextDecoderOptions) => TextDecoderTyp
(label?: string, options?: TextDecoderOptions) => TextDecoder
TextEncoder
TextEncoder: () => TextEncoderTyp
() => TextEncoder
Document
Document: () => DocumentTyp
() => Document
HTMLIFrameElement
HTMLIFrameElement: () => HTMLIFrameElementTyp
() => HTMLIFrameElement
Window
Window: () => WindowTyp
() => Window
config
config: { type: string, version: string }Typ
{ type: string, version: string }
invalidEmbedUrlErrorMessage
invalidEmbedUrlErrorMessage: stringTyp
string
hpmFactory
hpmFactory: IHpmFactoryTyp
IHpmFactory
routerFactory
routerFactory: IRouterFactoryTyp
IRouterFactory
wpmpFactory
wpmpFactory: IWpmpFactoryTyp
IWpmpFactory