powerbi-client package
Classes
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Composant générateur de filtres Avancé Power BI |
| BasicFilterBuilder |
Composant générateur de filtres De base Power BI |
| BookmarksManager |
Gère les signets de rapport. |
| Create |
Composant créateur de rapports Power BI |
| Dashboard |
Composant d’incorporation d’un tableau de bord Power BI |
| FilterBuilder |
Générateur de filtre générique pour BasicFilter, AdvancedFilter, RelativeDate, RelativeTime et TopN |
| MIMEParams |
L’API |
| MIMEType |
Implémentation de la classe MIMEType. Conformément aux conventions du navigateur, toutes les propriétés d’objets Une chaîne MIME est une chaîne structurée contenant plusieurs composants significatifs. Lorsqu’il est analysé, un objet |
| Page |
Page de rapport Power BI |
| Qna |
Composant incorporé Power BI Q&A |
| QuickCreate |
Un composant De création rapide Power BI |
| RelativeDateFilterBuilder |
Composant générateur de filtres date relative Power BI |
| RelativeTimeFilterBuilder |
Composant générateur de filtres de temps relatif Power BI |
| Report |
Composant incorporé power BI Report |
| Service |
Composant d’incorporation du service Power BI, qui est le point d’entrée pour incorporer tous les autres composants Power BI dans votre application |
| Tile |
Composant incorporé de vignette Power BI |
| TopNFilterBuilder |
Composant générateur de filtreS Power BI Top N |
| Visual |
Composant d’incorporation visuelle Power BI |
| VisualDescriptor |
Visuel Power BI dans une page |
Interfaces
Alias de type
Énumérations
Functions
| is |
Retourne Voir aussi |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne Par exemple: |
| is |
Retourne |
| is |
Retourne Voir aussi |
| is |
Retourne |
| is |
Retourne Une valeur Pour plus d’informations sur |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne Les sous-classes des types d’erreurs natifs sont également des erreurs natives : Une valeur À l’inverse, |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne Voir aussi |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| is |
Retourne |
| inspect(any, boolean, number | null, boolean) | La méthode Les références circulaires pointent vers leur ancre à l’aide d’un index de référence : L’exemple suivant inspecte toutes les propriétés de l’objet L’exemple suivant met en évidence l’effet de l’option L’option L’option L’option
|
| promisify<TCustom>(Custom |
Prend une fonction suivant le style de rappel d’erreur courant, c’est-à-dire en prenant un rappel Ou, en utilisant des S’il existe une
L’utilisation de |
| aborted(Abort |
Écoute l’événement d’abandon sur le |
| add |
Ajoute un paramètre à l’URL donnée |
| assign(any[]) | Copie les valeurs de toutes les propriétés énumérables d’un ou plusieurs objets sources vers un objet cible et retourne l’objet cible. |
| auto |
Vérifie si l’URL incorporée contient autoAuth=true. |
| callbackify(() => Promise<void>) | Prend une fonction Imprimera : Le rappel est exécuté de manière asynchrone et aura une trace de pile limitée.
Si le rappel lève, le processus émet un événement Étant donné que |
| 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 |
La S’il Cela est particulièrement utile lors de l’utilisation de processus pour déterminer le code de sortie en fonction du signal qui a terminé le processus. |
| create |
Génère une chaîne de caractères aléatoire de 5 à 6 caractères. |
| debuglog(string, (fn: Debug |
La Si ce programme est exécuté avec où Le s’il est exécuté avec Plusieurs noms séparés par des virgules L’argument facultatif |
| deprecate<T>(T, string, string, Deprecate |
La méthode Lorsqu’elle est appelée, Si la même Si les indicateurs de ligne de commande Si les indicateurs de ligne de commande Si l’indicateur de ligne de commande L’indicateur de ligne de commande |
| diff(string | (readonly string[]), string | (readonly string[])) |
Si les valeurs sont égales, un tableau vide est retourné. |
| find<T>((x: T) => boolean, T[]) | Recherche la première valeur d’un tableau qui correspond au prédicat spécifié. |
| find |
Recherche l’index de la première valeur dans un tableau qui correspond au prédicat spécifié. |
| format(any, any[]) | La méthode Si un spécificateur n’a pas d’argument correspondant, il n’est pas remplacé : Les valeurs qui ne font pas partie de la chaîne de format sont mises en forme à l’aide de S’il existe plus d’arguments passés à la méthode Si le premier argument ne contient pas de spécificateur de format valide, Si un seul argument est passé à
|
| format |
Cette fonction est identique à format, sauf qu’elle prend un argument |
| generateUUID() | Génère un uuid de 20 caractères. |
| get |
Retourne un tableau d’objets de site d’appel contenant la pile de la fonction appelante. Contrairement à l’accès à un Il est possible de reconstruire les emplacements d’origine en définissant l’option |
| get |
|
| get |
Retourne un nombre aléatoire |
| get |
Retourne un mappage de tous les codes d’erreur système disponibles à partir de l’API Node.js.
Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme.
Consultez |
| get |
Retourne le message de chaîne d’un code d’erreur numérique provenant d’une API Node.js. Le mappage entre les codes d’erreur et les messages de chaîne dépend de la plateforme. |
| get |
Retourne le nom de chaîne d’un code d’erreur numérique provenant d’une API Node.js.
Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme.
Consultez |
| get |
Retourne l’intervalle de temps entre deux dates en millisecondes |
| inherits(unknown, unknown) | L’utilisation de Héritez des méthodes prototypes d’un constructeur dans une autre. Le prototype de Cela ajoute principalement une validation d’entrée en plus de Exemple ES6 utilisant |
| inspect(any, Inspect |
|
| is |
Alias de Retourne |
| is |
Vérifie si le type d’incorporation est créé |
| is |
Retourne Consultez |
| is |
Vérifie si l’URL incorporée concerne le rapport RDL. |
| is |
Vérifie si le rapport est enregistré. |
| parse |
Fournit une API de niveau supérieur pour l’analyse des arguments de ligne de commande que l’interaction avec |
| parse |
Stabilité : 1.1 - Développement actif En fonction d’un exemple de fichier |
| 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 |
Déclenche un événement personnalisé avec des données d’événement sur l’élément HTML spécifié. |
| remove<T>((x: T) => boolean, T[]) | |
| set |
Activez ou désactivez l’impression d’une trace de pile sur |
| strip |
Retourne |
| style |
Cette fonction retourne un texte mis en forme compte de l’impression
Lors du passage d’un tableau de formats, l’ordre du format appliqué est de gauche à droite afin que le style suivant puisse remplacer le format précédent. La valeur En plus des noms de couleurs prédéfinis, Vous trouverez la liste complète des formats dans modificateurs. |
| to |
Retourne l' |
| transferable |
Crée et retourne une instance |
| transferable |
Marque le |
Variables
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
Informations relatives à la fonction
isAnyArrayBuffer(unknown)
Retourne true si la valeur est une instance intégrée ArrayBuffer ou SharedArrayBuffer.
Voir aussi util.types.isArrayBuffer() et util.types.isSharedArrayBuffer().
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLikeParamètres
- object
-
unknown
Retours
object is ArrayBufferLike
isArgumentsObject(unknown)
Retourne true si la valeur est un objet arguments.
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArgumentsParamètres
- object
-
unknown
Retours
object is IArguments
isArrayBuffer(unknown)
Retourne true si la valeur est une instance intégrée ArrayBuffer.
Cela n'pas inclure des instances SharedArrayBuffer. En règle générale, il est souhaitable de tester les deux ; Consultez util.types.isAnyArrayBuffer() pour cela.
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBufferParamètres
- object
-
unknown
Retours
object is ArrayBuffer
isArrayBufferView(unknown)
Retourne true si la valeur est une instance de l’une des vues ArrayBuffer, telles que les objets de tableau typés ou DataView. Équivalent à 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 ArrayBufferViewParamètres
- object
-
unknown
Retours
object is ArrayBufferView
isAsyncFunction(unknown)
Retourne true si la valeur est une fonction asynchrone .
Cela signale uniquement ce que le moteur JavaScript voit ; en particulier, la valeur de retour peut ne pas correspondre au code source d’origine si un outil de transpilation a été utilisé.
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): booleanParamètres
- object
-
unknown
Retours
boolean
isBigInt64Array(unknown)
Retourne true si la valeur est une instance BigInt64Array.
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64ArrayParamètres
- value
-
unknown
Retours
value is BigInt64Array
isBigIntObject(unknown)
Retourne true si la valeur est un objet BigInt, par exemple, créé par Object(BigInt(123)).
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 BigIntParamètres
- object
-
unknown
Retours
object is BigInt
isBigUint64Array(unknown)
Retourne true si la valeur est une instance BigUint64Array.
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64ArrayParamètres
- value
-
unknown
Retours
value is BigUint64Array
isBooleanObject(unknown)
Retourne true si la valeur est un objet booléen, par exemple, créé par new Boolean().
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 BooleanParamètres
- object
-
unknown
Retours
object is Boolean
isBoxedPrimitive(unknown)
Retourne true si la valeur est un objet primitif boxé, par exemple, créé par new Boolean(), new String() ou Object(Symbol()).
Par exemple:
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 | BigIntParamètres
- object
-
unknown
Retours
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
Retourne true si value est un CryptoKey, false sinon.
function isCryptoKey(object: unknown): object is CryptoKeyParamètres
- object
-
unknown
Retours
object is CryptoKey
isDataView(unknown)
Retourne true si la valeur est une instance intégrée DataView.
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
Voir aussi ArrayBuffer.isView().
function isDataView(object: unknown): object is DataViewParamètres
- object
-
unknown
Retours
object is DataView
isDate(unknown)
Retourne true si la valeur est une instance intégrée Date.
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is DateParamètres
- object
-
unknown
Retours
object is Date
isExternal(unknown)
Retourne true si la valeur est une valeur External native.
Une valeur External native est un type spécial d’objet qui contient un pointeur C++ brut (void*) pour l’accès à partir du code natif et n’a pas d’autres propriétés. Ces objets sont créés par Node.js des compléments internes ou natifs. En JavaScript, ils sont figés avec un null prototype.
#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
Pour plus d’informations sur napi_create_external, reportez-vous à napi_create_external().
function isExternal(object: unknown): booleanParamètres
- object
-
unknown
Retours
boolean
isFloat16Array(unknown)
Retourne true si la valeur est une instance intégrée Float16Array.
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 Float16ArrayParamètres
- object
-
unknown
Retours
object is Float16Array
isFloat32Array(unknown)
Retourne true si la valeur est une instance intégrée Float32Array.
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 Float32ArrayParamètres
- object
-
unknown
Retours
object is Float32Array
isFloat64Array(unknown)
Retourne true si la valeur est une instance intégrée Float64Array.
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 Float64ArrayParamètres
- object
-
unknown
Retours
object is Float64Array
isGeneratorFunction(unknown)
Retourne true si la valeur est une fonction de générateur.
Cela signale uniquement ce que le moteur JavaScript voit ; en particulier, la valeur de retour peut ne pas correspondre au code source d’origine si un outil de transpilation a été utilisé.
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunctionParamètres
- object
-
unknown
Retours
object is GeneratorFunction
isGeneratorObject(unknown)
Retourne true si la valeur est un objet générateur tel qu’il est retourné à partir d’une fonction de générateur intégrée.
Cela signale uniquement ce que le moteur JavaScript voit ; en particulier, la valeur de retour peut ne pas correspondre au code source d’origine si un outil de transpilation a été utilisé.
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is GeneratorParamètres
- object
-
unknown
Retours
object is Generator
isInt16Array(unknown)
Retourne true si la valeur est une instance intégrée Int16Array.
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 Int16ArrayParamètres
- object
-
unknown
Retours
object is Int16Array
isInt32Array(unknown)
Retourne true si la valeur est une instance intégrée Int32Array.
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 Int32ArrayParamètres
- object
-
unknown
Retours
object is Int32Array
isInt8Array(unknown)
Retourne true si la valeur est une instance intégrée Int8Array.
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 Int8ArrayParamètres
- object
-
unknown
Retours
object is Int8Array
isKeyObject(unknown)
Retourne true si value est un KeyObject, false sinon.
function isKeyObject(object: unknown): object is KeyObjectParamètres
- object
-
unknown
Retours
object is KeyObject
isMap<T>({} | T)
Retourne true si la valeur est une instance intégrée Map.
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>)Paramètres
- object
-
{} | T
Retours
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
Retourne true si la valeur est un itérateur retourné pour une instance Map intégrée.
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): booleanParamètres
- object
-
unknown
Retours
boolean
isModuleNamespaceObject(unknown)
isNativeError(unknown)
Avertissement
Cette API est à présent déconseillée.
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
Retourne true si la valeur a été retournée par le constructeur d’un type Error intégré.
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // true
Les sous-classes des types d’erreurs natifs sont également des erreurs natives :
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
Une valeur instanceof une classe d’erreur native n’est pas équivalente à isNativeError() retourner true pour cette valeur.
isNativeError() retourne true pour les erreurs provenant d’un autre domaine tandis que instanceof Error retourne false pour ces erreurs :
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
À l’inverse, isNativeError() retourne false pour tous les objets qui n’ont pas été retournés par le constructeur d’une erreur native. Cela inclut les valeurs qui sont instanceof erreurs natives :
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
function isNativeError(object: unknown): object is ErrorParamètres
- object
-
unknown
Retours
object is Error
isNumberObject(unknown)
Retourne true si la valeur est un objet numérique, par exemple, créé par new Number().
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is NumberParamètres
- object
-
unknown
Retours
object is Number
isPromise(unknown)
Retourne true si la valeur est une Promiseintégrée.
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>Paramètres
- object
-
unknown
Retours
object is Promise<unknown>
isProxy(unknown)
Retourne true si la valeur est une instance Proxy.
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
function isProxy(object: unknown): booleanParamètres
- object
-
unknown
Retours
boolean
isRegExp(unknown)
Retourne true si la valeur est un objet d’expression régulière.
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExpParamètres
- object
-
unknown
Retours
object is RegExp
isSet<T>({} | T)
Retourne true si la valeur est une instance intégrée Set.
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>)Paramètres
- object
-
{} | T
Retours
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
Retourne true si la valeur est un itérateur retourné pour une instance Set intégrée.
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): booleanParamètres
- object
-
unknown
Retours
boolean
isSharedArrayBuffer(unknown)
Retourne true si la valeur est une instance intégrée SharedArrayBuffer.
Cela n'pas inclure des instances ArrayBuffer. En règle générale, il est souhaitable de tester les deux ; Consultez util.types.isAnyArrayBuffer() pour cela.
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBufferParamètres
- object
-
unknown
Retours
object is SharedArrayBuffer
isStringObject(unknown)
Retourne true si la valeur est un objet de chaîne, par exemple, créé par new String().
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is StringParamètres
- object
-
unknown
Retours
object is String
isSymbolObject(unknown)
Retourne true si la valeur est un objet de symbole, créé en appelant Object() sur une primitive Symbol.
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is SymbolParamètres
- object
-
unknown
Retours
object is Symbol
isTypedArray(unknown)
Retourne true si la valeur est une instance intégrée TypedArray.
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
Voir aussi ArrayBuffer.isView().
function isTypedArray(object: unknown): object is TypedArrayParamètres
- object
-
unknown
Retours
object is TypedArray
isUint16Array(unknown)
Retourne true si la valeur est une instance intégrée Uint16Array.
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 Uint16ArrayParamètres
- object
-
unknown
Retours
object is Uint16Array
isUint32Array(unknown)
Retourne true si la valeur est une instance intégrée Uint32Array.
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 Uint32ArrayParamètres
- object
-
unknown
Retours
object is Uint32Array
isUint8Array(unknown)
Retourne true si la valeur est une instance intégrée Uint8Array.
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 Uint8ArrayParamètres
- object
-
unknown
Retours
object is Uint8Array
isUint8ClampedArray(unknown)
Retourne true si la valeur est une instance intégrée Uint8ClampedArray.
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 Uint8ClampedArrayParamètres
- object
-
unknown
Retours
object is Uint8ClampedArray
isWeakMap(unknown)
Retourne true si la valeur est une instance intégrée WeakMap.
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>Paramètres
- object
-
unknown
Retours
object is WeakMap<object, unknown>
isWeakSet(unknown)
Retourne true si la valeur est une instance intégrée WeakSet.
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>Paramètres
- object
-
unknown
Retours
object is WeakSet<object>
inspect(any, boolean, number | null, boolean)
La méthode util.inspect() retourne une représentation sous forme de chaîne de object destinée au débogage. La sortie de util.inspect peut changer à tout moment et ne doit pas être dépendante par programme. Des options supplémentaires peuvent être passées qui modifient le résultat.
util.inspect() utilise le nom et/ou Symbol.toStringTag la propriété du constructeur pour rendre une balise identifiable pour une valeur inspectée.
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] {}'
Les références circulaires pointent vers leur ancre à l’aide d’un index de référence :
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] }
// }
L’exemple suivant inspecte toutes les propriétés de l’objet util :
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
L’exemple suivant met en évidence l’effet de l’option compact :
import { inspect } from 'node:util';
const o = {
a: [1, 2, [[
'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
'test',
'foo']], 4],
b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));
// { a:
// [ 1,
// 2,
// [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
// 'test',
// 'foo' ] ],
// 4 ],
// b: Map(2) { 'za' => 1, 'zb' => 'test' } }
// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));
// {
// a: [
// 1,
// 2,
// [
// [
// 'Lorem ipsum dolor sit amet,\n' +
// 'consectetur adipiscing elit, sed do eiusmod \n' +
// 'tempor incididunt ut labore et dolore magna aliqua.',
// 'test',
// 'foo'
// ]
// ],
// 4
// ],
// b: Map(2) {
// 'za' => 1,
// 'zb' => 'test'
// }
// }
// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.
L’option showHidden permet d’inspecter les entrées WeakMap et WeakSet. S’il y a plus d’entrées que maxArrayLength, il n’existe aucune garantie que les entrées sont affichées. Cela signifie que la récupération des mêmes entrées WeakSet deux fois peut entraîner une sortie différente. En outre, les entrées sans références fortes restantes peuvent être collectées à tout moment par la mémoire.
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 } }
L’option sorted garantit que l’ordre d’insertion de propriété d’un objet n’a pas d’impact sur le résultat de util.inspect().
import { inspect } from 'node:util';
import assert from 'node:assert';
const o1 = {
b: [2, 3, 1],
a: '`a` comes before `b`',
c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }
const o2 = {
c: new Set([2, 1, 3]),
a: '`a` comes before `b`',
b: [2, 3, 1],
};
assert.strict.equal(
inspect(o1, { sorted: true }),
inspect(o2, { sorted: true }),
);
L’option numericSeparator ajoute un trait de soulignement toutes les trois chiffres à tous les nombres.
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() est une méthode synchrone destinée au débogage. Sa longueur de sortie maximale est d’environ 128 Mio. Les entrées qui entraînent une sortie plus longue seront tronquées.
function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): stringParamètres
- object
-
any
Toute primitive JavaScript ou Object.
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
Retours
string
Représentation de object.
promisify<TCustom>(CustomPromisify<TCustom>)
Prend une fonction suivant le style de rappel d’erreur courant, c’est-à-dire en prenant un rappel (err, value) => ... comme dernier argument et retourne une version qui retourne des promesses.
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.
});
Ou, en utilisant des async functions :
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
async function callStat() {
const stats = await promisifiedStat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
callStat();
S’il existe une original[util.promisify.custom] propriété présente, promisify retourne sa valeur, consultez les fonctions promisifiées personnalisées.
promisify() suppose que original est une fonction prenant un rappel comme argument final dans tous les cas. Si original n’est pas une fonction, promisify() génère une erreur. Si original est une fonction mais que son dernier argument n’est pas un rappel d’erreur premier, il est toujours passé un rappel d’erreur en tant que dernier argument.
L’utilisation de promisify() sur des méthodes de classe ou d’autres méthodes qui utilisent this peut ne pas fonctionner comme prévu, sauf si elle est gérée spécialement :
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>): TCustomParamètres
- fn
-
CustomPromisify<TCustom>
Retours
TCustom
aborted(AbortSignal, any)
Écoute l’événement d’abandon sur le signal fourni et retourne une promesse qui se résout lorsque le signal est abandonné.
Si resource est fourni, il fait faiblement référence à l’objet associé de l’opération. Par conséquent, si resource est récupéré par le garbage collection avant que le signal abandonne, la promesse retournée reste en attente.
Cela empêche les fuites de mémoire dans les opérations longues ou non annulables.
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>Paramètres
- signal
-
AbortSignal
- resource
-
any
Tout objet non null lié à l’opération abandonnée et conservé faiblement.
Si resource est récupéré avant l’abandon du signal, la promesse reste en attente, ce qui permet Node.js d’arrêter le suivi.
Cela permet d’éviter les fuites de mémoire dans les opérations longues ou non annulables.
Retours
Promise<void>
addParamToUrl(string, string, string)
Ajoute un paramètre à l’URL donnée
function addParamToUrl(url: string, paramName: string, value: string): stringParamètres
- url
-
string
- paramName
-
string
- value
-
string
Retours
string
assign(any[])
Copie les valeurs de toutes les propriétés énumérables d’un ou plusieurs objets sources vers un objet cible et retourne l’objet cible.
function assign(args: any[]): anyParamètres
- args
-
any[]
Retours
any
autoAuthInEmbedUrl(string)
Vérifie si l’URL incorporée contient autoAuth=true.
function autoAuthInEmbedUrl(embedUrl: string): booleanParamètres
- embedUrl
-
string
Retours
boolean
callbackify(() => Promise<void>)
Prend une fonction async (ou une fonction qui retourne un Promise) et retourne une fonction suivant le style de rappel d’erreur premier, c’est-à-dire en prenant un rappel (err, value) => ... comme dernier argument. Dans le rappel, le premier argument est la raison du rejet (ou null si le Promise résolu) et le deuxième argument est la valeur résolue.
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);
});
Imprimera :
hello world
Le rappel est exécuté de manière asynchrone et aura une trace de pile limitée.
Si le rappel lève, le processus émet un événement 'uncaughtException', et s’il n’est pas géré, il se ferme.
Étant donné que null a une signification spéciale comme premier argument d’un rappel, si une fonction encapsulée rejette un Promise avec une valeur falsy comme raison, la valeur est encapsulée dans un Error avec la valeur d’origine stockée dans un champ nommé reason.
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) => voidParamètres
- fn
-
() => Promise<void>
Fonction async
Retours
(callback: (err: ErrnoException) => void) => void
fonction de style de rappel
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => voidParamètres
- fn
-
() => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1) => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
Retours
(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) => voidParamètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
Retours
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException | null, result: TResult) => void) => void
convertProcessSignalToExitCode(Signals)
La util.convertProcessSignalToExitCode() méthode convertit un nom de signal en son code de sortie POSIX correspondant. À la suite de la norme POSIX, le code de sortie d’un processus arrêté par un signal est calculé comme 128 + signal number.
S’il signal n’est pas un nom de signal valide, une erreur est levée. Consultez signal(7) la liste des signaux valides.
import { convertProcessSignalToExitCode } from 'node:util';
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
Cela est particulièrement utile lors de l’utilisation de processus pour déterminer le code de sortie en fonction du signal qui a terminé le processus.
function convertProcessSignalToExitCode(signal: Signals): numberParamètres
- signal
-
Signals
Nom d’un signal (par exemple 'SIGTERM')
Retours
number
Code de sortie correspondant à signal
createRandomString()
Génère une chaîne de caractères aléatoire de 5 à 6 caractères.
function createRandomString(): stringRetours
string
debuglog(string, (fn: DebugLoggerFunction) => void)
La util.debuglog() méthode est utilisée pour créer une fonction qui écrit conditionnellement des messages de débogage en stderr fonction de l’existence de la NODE_DEBUG variable d’environnement. Si le nom section apparaît dans la valeur de cette variable d’environnement, la fonction retournée fonctionne comme console.error(). Si ce n’est pas le cas, la fonction retournée est une no-op.
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hello from foo [%d]', 123);
Si ce programme est exécuté avec NODE_DEBUG=foo dans l’environnement, il génère quelque chose comme suit :
FOO 3245: hello from foo [123]
où 3245 est l’ID de processus. S’il n’est pas exécuté avec cette variable d’environnement définie, il n’imprime rien.
Le section prend également en charge les caractères génériques :
import { debuglog } from 'node:util';
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);
s’il est exécuté avec NODE_DEBUG=foo* dans l’environnement, il génère quelque chose comme suit :
FOO-BAR 3257: hi there, it's foo-bar [2333]
Plusieurs noms séparés par des virgules section peuvent être spécifiés dans la variable d’environnement NODE_DEBUG : NODE_DEBUG=fs,net,tls.
L’argument facultatif callback peut être utilisé pour remplacer la fonction de journalisation par une autre fonction qui n’a pas d’initialisation ni d’habillage inutile.
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): DebugLoggerParamètres
- section
-
string
Chaîne identifiant la partie de l’application pour laquelle la fonction debuglog est en cours de création.
- callback
-
(fn: DebugLoggerFunction) => void
Un rappel appelé la première fois que la fonction de journalisation est appelée avec un argument de fonction qui est une fonction de journalisation plus optimisée.
Retours
Fonction de journalisation
deprecate<T>(T, string, string, DeprecateOptions)
La méthode util.deprecate() encapsule fn (qui peut être une fonction ou une classe) de telle façon qu’elle est marquée comme déconseillée.
import { deprecate } from 'node:util';
export const obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
Lorsqu’elle est appelée, util.deprecate() retourne une fonction qui émet une DeprecationWarning à l’aide de l’événement 'warning'. L’avertissement est émis et imprimé pour stderr la première fois que la fonction retournée est appelée. Une fois l’avertissement émis, la fonction encapsulée est appelée sans émettre d’avertissement.
Si la même code facultative est fournie dans plusieurs appels à util.deprecate(), l’avertissement n’est émis qu’une seule fois pour cette code.
import { deprecate } from 'node:util';
const fn1 = deprecate(
() => 'a value',
'deprecation message',
'DEP0001',
);
const fn2 = deprecate(
() => 'a different value',
'other dep message',
'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code
Si les indicateurs de ligne de commande --no-deprecation ou --no-warnings sont utilisés ou si la propriété process.noDeprecation est définie sur true'avertissement antérieur à la première dépréciation, la méthode util.deprecate() ne fait rien.
Si les indicateurs de ligne de commande --trace-deprecation ou --trace-warnings sont définis, ou si la propriété process.traceDeprecation est définie sur true, un avertissement et une trace de pile sont imprimés pour stderr la première fois que la fonction dépréciée est appelée.
Si l’indicateur de ligne de commande --throw-deprecation est défini ou si la propriété process.throwDeprecation est définie sur true, une exception est levée lorsque la fonction déconseillée est appelée.
L’indicateur de ligne de commande --throw-deprecation et la propriété process.throwDeprecation sont prioritaires sur --trace-deprecation et process.traceDeprecation.
function deprecate<T>(fn: T, msg: string, code?: string, options?: DeprecateOptions): TParamètres
- fn
-
T
Fonction en cours de dépréciation.
- msg
-
string
Message d’avertissement à afficher lorsque la fonction déconseillée est appelée.
- code
-
string
Code de dépréciation. Consultez la list of deprecated APIs pour obtenir la liste des codes.
- options
- DeprecateOptions
Retours
T
Fonction déconseillée encapsulée pour émettre un avertissement.
diff(string | (readonly string[]), string | (readonly string[]))
util.diff() compare deux valeurs de chaîne ou de tableau et retourne un tableau d’entrées de différence.
Il utilise l’algorithme de différences Myers pour calculer des différences minimales, qui est le même algorithme utilisé en interne par les messages d’erreur d’assertion.
Si les valeurs sont égales, un tableau vide est retourné.
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[]Paramètres
- actual
-
string | (readonly string[])
Première valeur à comparer
- expected
-
string | (readonly string[])
Deuxième valeur à comparer
Retours
Tableau d’entrées de différence. Chaque entrée est un tableau avec deux éléments :
- Index 0 : code d’opération :
number-1pour supprimer,0pour no-op/inchangé,1pour insérer - Index 1 :
stringvaleur associée à l’opération
find<T>((x: T) => boolean, T[])
Recherche la première valeur d’un tableau qui correspond au prédicat spécifié.
function find<T>(predicate: (x: T) => boolean, xs: T[]): TParamètres
- predicate
-
(x: T) => boolean
- xs
-
T[]
Retours
T
findIndex<T>((x: T) => boolean, T[])
Recherche l’index de la première valeur dans un tableau qui correspond au prédicat spécifié.
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): numberParamètres
- predicate
-
(x: T) => boolean
- xs
-
T[]
Retours
number
format(any, any[])
La méthode util.format() retourne une chaîne mise en forme à l’aide du premier argument en tant que chaîne de format printfqui peut contenir zéro ou plusieurs spécificateurs de format. Chaque spécificateur est remplacé par la valeur convertie de l’argument correspondant. Les spécificateurs pris en charge sont les suivants :
Si un spécificateur n’a pas d’argument correspondant, il n’est pas remplacé :
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
Les valeurs qui ne font pas partie de la chaîne de format sont mises en forme à l’aide de util.inspect() si leur type n’est pas string.
S’il existe plus d’arguments passés à la méthode util.format() que le nombre de spécificateurs, les arguments supplémentaires sont concaténés à la chaîne retournée, séparés par des espaces :
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
Si le premier argument ne contient pas de spécificateur de format valide, util.format() retourne une chaîne qui est la concaténation de tous les arguments séparés par des espaces :
util.format(1, 2, 3);
// Returns: '1 2 3'
Si un seul argument est passé à util.format(), il est retourné, car il n’est pas mis en forme :
util.format('%% %s');
// Returns: '%% %s'
util.format() est une méthode synchrone destinée à être un outil de débogage.
Certaines valeurs d’entrée peuvent avoir une surcharge significative des performances qui peut bloquer la boucle d’événement. Utilisez cette fonction avec soin et jamais dans un chemin de code chaud.
function format(format?: any, param: any[]): stringParamètres
- format
-
any
Chaîne de format de type printf.
- param
-
any[]
Retours
string
formatWithOptions(InspectOptions, any, any[])
Cette fonction est identique à format, sauf qu’elle prend un argument inspectOptions qui spécifie les options transmises au inspecter.
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[]): stringParamètres
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Retours
string
generateUUID()
Génère un uuid de 20 caractères.
function generateUUID(): stringRetours
string
getCallSites(number, GetCallSitesOptions)
Retourne un tableau d’objets de site d’appel contenant la pile de la fonction appelante.
Contrairement à l’accès à un error.stack, le résultat retourné à partir de cette API n’est pas interférer avec 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();
Il est possible de reconstruire les emplacements d’origine en définissant l’option sourceMap sur true.
Si la carte source n’est pas disponible, l’emplacement d’origine est identique à l’emplacement actuel.
Lorsque l’indicateur --enable-source-maps est activé, sourceMap la valeur est true par défaut.
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[]Paramètres
- frameCount
-
number
Nombre d’images à capturer en tant qu’objets de site d’appel.
Valeur par défaut :10. La plage autorisée est comprise entre 1 et 200.
- options
- GetCallSitesOptions
Retours
Tableau d’objets de site d’appel
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]Paramètres
- options
- GetCallSitesOptions
Retours
getRandomValue()
Retourne un nombre aléatoire
function getRandomValue(): numberRetours
number
getSystemErrorMap()
Retourne un mappage de tous les codes d’erreur système disponibles à partir de l’API Node.js.
Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme.
Consultez Common System Errors pour connaître les noms des erreurs courantes.
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]>Retours
Map<number, [string, string]>
getSystemErrorMessage(number)
Retourne le message de chaîne d’un code d’erreur numérique provenant d’une API Node.js. Le mappage entre les codes d’erreur et les messages de chaîne dépend de la plateforme.
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): stringParamètres
- err
-
number
Retours
string
getSystemErrorName(number)
Retourne le nom de chaîne d’un code d’erreur numérique provenant d’une API Node.js.
Le mappage entre les codes d’erreur et les noms d’erreurs dépend de la plateforme.
Consultez Common System Errors pour connaître les noms des erreurs courantes.
fs.access('file/that/does/not/exist', (err) => {
const name = util.getSystemErrorName(err.errno);
console.error(name); // ENOENT
});
function getSystemErrorName(err: number): stringParamètres
- err
-
number
Retours
string
getTimeDiffInMilliseconds(Date, Date)
Retourne l’intervalle de temps entre deux dates en millisecondes
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParamètres
- start
-
Date
- end
-
Date
Retours
number
inherits(unknown, unknown)
L’utilisation de util.inherits() est déconseillée. Utilisez les mots clés ES6 class et extends pour obtenir la prise en charge de l’héritage au niveau du langage. Notez également que les deux styles sont sémantiquement incompatibles.
Héritez des méthodes prototypes d’un constructeur dans une autre. Le prototype de constructor sera défini sur un nouvel objet créé à partir de superConstructor.
Cela ajoute principalement une validation d’entrée en plus de Object.setPrototypeOf(constructor.prototype, superConstructor.prototype).
En guise de commodité supplémentaire, superConstructor sera accessible via la propriété 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!"
Exemple ES6 utilisant class et 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)Paramètres
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParamètres
- object
-
any
- options
- InspectOptions
Retours
string
isArray(unknown)
Avertissement
Cette API est à présent déconseillée.
Since v4.0.0 - Use isArray instead.
Alias de Array.isArray().
Retourne true si le object donné est un Array. Sinon, retourne false.
import util from 'node:util';
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
function isArray(object: unknown): object is unknown[]Paramètres
- object
-
unknown
Retours
object is unknown[]
isCreate(string)
Vérifie si le type d’incorporation est créé
function isCreate(embedType: string): booleanParamètres
- embedType
-
string
Retours
boolean
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)
Retourne true s’il existe une égalité stricte entre val1 et val2.
Sinon, retourne false.
Consultez assert.deepStrictEqual() pour plus d’informations sur l’égalité stricte.
function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): booleanParamètres
- val1
-
unknown
- val2
-
unknown
- options
- IsDeepStrictEqualOptions
Retours
boolean
isRDLEmbed(string)
Vérifie si l’URL incorporée concerne le rapport RDL.
function isRDLEmbed(embedUrl: string): booleanParamètres
- embedUrl
-
string
Retours
boolean
isSavedInternal(HttpPostMessage, string, Window)
Vérifie si le rapport est enregistré.
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>Paramètres
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
- Window
Retours
Promise<boolean>
parseArgs<T>(T)
Fournit une API de niveau supérieur pour l’analyse des arguments de ligne de commande que l’interaction avec process.argv directement. Prend une spécification pour les arguments attendus et retourne un objet structuré avec les options et les positions analysées.
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>Paramètres
- config
-
T
Permet de fournir des arguments pour l’analyse et de configurer l’analyseur.
config prend en charge les propriétés suivantes :
Retours
ParsedResults<T>
Arguments de ligne de commande analysés :
parseEnv(string)
Stabilité : 1.1 - Développement actif En fonction d’un exemple de fichier .env :
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): Dict<string>Paramètres
- content
-
string
Contenu brut d’un fichier .env.
Retours
Dict<string>
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>Paramètres
- fn
-
(callback: (err: any, result: TResult) => void) => void
Retours
() => Promise<TResult>
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>Paramètres
- fn
-
(callback: (err?: any) => void) => void
Retours
() => 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>Paramètres
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
Retours
(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>Paramètres
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
Retours
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
promisify(Function)
function promisify(fn: Function): FunctionParamètres
- fn
-
Function
Retours
Function
raiseCustomEvent(HTMLElement, string, any)
Déclenche un événement personnalisé avec des données d’événement sur l’élément HTML spécifié.
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)Paramètres
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])Paramètres
- predicate
-
(x: T) => boolean
- xs
-
T[]
setTraceSigInt(boolean)
Activez ou désactivez l’impression d’une trace de pile sur SIGINT. L’API est disponible uniquement sur le thread principal.
function setTraceSigInt(enable: boolean)Paramètres
- enable
-
boolean
stripVTControlCharacters(string)
Retourne str avec les codes d’échappement ANSI supprimés.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): stringParamètres
- str
-
string
Retours
string
styleText(InspectColor | (readonly InspectColor[]) | Object, string, StyleTextOptions)
Cette fonction retourne un texte mis en forme compte de l’impression format passée dans un terminal. Il est conscient des fonctionnalités du terminal et agit en fonction de l’ensemble de configuration via NO_COLOR, NODE_DISABLE_COLORS et FORCE_COLOR des variables d’environnement.
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 fournit également des formats de texte tels que italic, et underline et vous pouvez combiner les deux :
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
Lors du passage d’un tableau de formats, l’ordre du format appliqué est de gauche à droite afin que le style suivant puisse remplacer le format précédent.
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
La valeur none de format spéciale n’applique aucun style supplémentaire au texte.
En plus des noms de couleurs prédéfinis, util.styleText() prend en charge les chaînes de couleurs hexadécimaux à l’aide de séquences d’échappement ANSI TrueColor (24 bits). Les couleurs hexadécimaux peuvent être spécifiées au format 3 chiffres (#RGB) ou à 6 chiffres (#RRGGBB) :
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'));
Vous trouverez la liste complète des formats dans modificateurs.
function styleText(format: InspectColor | (readonly InspectColor[]) | Object, text: string, options?: StyleTextOptions): stringParamètres
- format
-
InspectColor | (readonly InspectColor[]) | Object
Format de texte ou tableau de formats de texte définis dans util.inspect.colors, ou couleur hexadécimal dans #RGB ou #RRGGBB formulaire.
- text
-
string
Texte à mettre en forme.
- options
- StyleTextOptions
Retours
string
toUSVString(string)
Retourne l'string après avoir remplacé les points de code de substitution (ou équivalents, toutes les unités de code de substitution non souhaitées) par le caractère de remplacement Unicode U+FFFD.
function toUSVString(string: string): stringParamètres
- string
-
string
Retours
string
transferableAbortController()
Crée et retourne une instance AbortController dont la AbortSignal est marquée comme transférable et peut être utilisée avec structuredClone() ou postMessage().
function transferableAbortController(): AbortControllerRetours
AbortController
AbortController transférable
transferableAbortSignal(AbortSignal)
Marque le AbortSignal donné comme transférable afin qu’il puisse être utilisé avecstructuredClone() et postMessage().
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignalParamètres
- signal
-
AbortSignal
The AbortSignal
Retours
AbortSignal
Le même AbortSignal
Détails de variable
APINotSupportedForRDLError
APINotSupportedForRDLError: "This API is currently not supported for RDL reports"Type
"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"Type
"Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"
TextDecoder
TextDecoder: (label?: string, options?: TextDecoderOptions) => TextDecoderType
(label?: string, options?: TextDecoderOptions) => TextDecoder
TextEncoder
TextEncoder: () => TextEncoderType
() => TextEncoder
Document
Document: () => DocumentType
() => Document
HTMLIFrameElement
HTMLIFrameElement: () => HTMLIFrameElementType
() => HTMLIFrameElement
Window
Window: () => WindowType
() => Window
config
config: { type: string, version: string }Type
{ type: string, version: string }
invalidEmbedUrlErrorMessage
invalidEmbedUrlErrorMessage: stringType
string
hpmFactory
hpmFactory: IHpmFactoryType
IHpmFactory
routerFactory
routerFactory: IRouterFactoryType
IRouterFactory
wpmpFactory
wpmpFactory: IWpmpFactoryType
IWpmpFactory