powerbi-client package
Třídy
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Komponenta Rozšířeného tvůrce filtrů Power BI |
| BasicFilterBuilder |
Komponenta Tvůrce filtrů Power BI Basic |
| BookmarksManager |
Spravuje záložky sestavy. |
| Create |
Komponenta tvůrce sestav Power BI |
| Dashboard |
Komponenta pro vložení řídicího panelu Power BI |
| FilterBuilder |
Tvůrce obecných filtrů pro BasicFilter, AdvancedFilter, RelativeDate, RelativeTime a TopN |
| MIMEParams |
Rozhraní API |
| MIMEType |
Implementace MIMEType třídy. V souladu s konvencemi prohlížeče se všechny vlastnosti Řetězec MIME je strukturovaný řetězec obsahující více smysluplných komponent. Při analýze se vrátí objekt |
| Page |
Stránka sestavy Power BI |
| Qna |
Komponenta Q&A v Power BI |
| QuickCreate |
Komponenta Rychlé vytvoření Power BI |
| RelativeDateFilterBuilder |
Komponenta Tvůrce filtrů relativního data v Power BI |
| RelativeTimeFilterBuilder |
Komponenta Tvůrce filtrů relativního času v Power BI |
| Report |
Komponenta Pro vložení sestavy Power BI |
| Service |
Komponenta pro vložení služby Power BI, což je vstupní bod pro vložení všech ostatních komponent Power BI do vaší aplikace |
| Tile |
Komponenta pro vložení dlaždice Power BI |
| TopNFilterBuilder |
Komponenta Tvůrce filtrů Top N v Power BI |
| Visual |
Komponenta Pro vložení vizuálu Power BI |
| VisualDescriptor |
Vizuál Power BI na stránce |
Rozhraní
Aliasy typu
Výčty
Funkce
| is |
Vrátí Viz také |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí Příklady: |
| is |
Vrátí |
| is |
Vrátí Viz také |
| is |
Vrátí |
| is |
Vrátí Nativní hodnota Další informace o |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí Podtřídy nativních typů chyb jsou také nativní chyby: Hodnota, která je Naopak |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí Viz také |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| is |
Vrátí |
| inspect(any, boolean, number | null, boolean) | Metoda Cyklický odkaz odkazuje na jejich ukotvení pomocí indexu odkazu: Následující příklad zkontroluje všechny vlastnosti Následující příklad zvýrazní účinek možnosti Možnost Možnost Možnost
|
| promisify<TCustom>(Custom |
Přebírá funkci podle běžného stylu zpětného volání při první chybě, tj. přebírá Nebo ekvivalentní použití Pokud existuje
Použití |
| aborted(Abort |
Naslouchá přerušení události na zadaném |
| add |
Přidá parametr na danou adresu URL. |
| assign(any[]) | Zkopíruje hodnoty všech výčtových vlastností z jednoho nebo více zdrojových objektů do cílového objektu a vrátí cílový objekt. |
| auto |
Zkontroluje, jestli adresa URL pro vložení obsahuje autoAuth=true. |
| callbackify(() => Promise<void>) | Vezme Vytiskne se: Zpětné volání se provádí asynchronně a bude mít omezené trasování zásobníku.
Pokud zpětné volání vyvolá, proces vygeneruje Vzhledem k tomu, že |
| 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 |
Metoda Pokud To je zvlášť užitečné při práci s procesy, které určují ukončovací kód na základě signálu, který proces ukončil. |
| create |
Vygeneruje náhodný řetězec 5 až 6 znaků. |
| debuglog(string, (fn: Debug |
Metoda Pokud je tento program spuštěn s kde
Pokud se spustí s V proměnné prostředí lze zadat Volitelný argument |
| deprecate<T>(T, string, string, Deprecate |
Metoda Při zavolání vrátí Pokud je stejná volitelná Pokud se použijí příznaky příkazového řádku Pokud jsou nastavené příznaky Pokud je nastaven příznak příkazového řádku Příznak příkazového řádku |
| diff(string | (readonly string[]), string | (readonly string[])) |
Pokud jsou hodnoty stejné, vrátí se prázdné pole. |
| find<T>((x: T) => boolean, T[]) | Najde první hodnotu v matici, která odpovídá zadanému predikátu. |
| find |
Vyhledá index první hodnoty v matici, která odpovídá zadanému predikátu. |
| format(any, any[]) | Metoda Pokud specifikátor nemá odpovídající argument, nenahradí se: Hodnoty, které nejsou součástí formátovacího řetězce, jsou formátovány pomocí Pokud je metodě Pokud první argument neobsahuje platný specifikátor formátu, Pokud se
|
| format |
Tato funkce je shodná s formátem s tím rozdílem, že přebírá |
| generateUUID() | Vygeneruje 20 znaků uuid. |
| get |
Vrátí pole objektů lokality volání obsahující zásobník funkce volajícího. Na rozdíl od přístupu k Původní umístění je možné rekonstruovat nastavením možnosti |
| get |
|
| get |
Vrátí náhodné číslo. |
| get |
Vrátí mapu všech kódů systémových chyb dostupných v rozhraní Node.js API.
Mapování mezi kódy chyb a názvy chyb závisí na platformě.
Názvy běžných chyb najdete v |
| get |
Vrátí řetězcovou zprávu pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a řetězcovými zprávami je závislé na platformě. |
| get |
Vrátí název řetězce pro číselný kód chyby, který pochází z rozhraní API Node.js.
Mapování mezi kódy chyb a názvy chyb závisí na platformě.
Názvy běžných chyb najdete v |
| get |
Vrátí časový interval mezi dvěma daty v milisekundách. |
| inherits(unknown, unknown) | Použití Dědí prototypové metody z jednoho konstruktoru do jiného. Prototyp To hlavně přidává některé vstupní ověřování nad Příklad ES6 používající |
| inspect(any, Inspect |
|
| is |
Alias pro Vrátí |
| is |
Zkontroluje, jestli je typ vložení pro vytvoření. |
| is |
Vrátí Další informace o hluboké striktní rovnosti najdete v tématu |
| is |
Zkontroluje, jestli je adresa URL pro vložení pro sestavu RDL. |
| is |
Zkontroluje, jestli je sestava uložená. |
| parse |
Poskytuje rozhraní API vyšší úrovně pro analýzu argumentů příkazového řádku než přímé interakce s |
| parse |
Stabilita: 1.1 – Aktivní vývoj Vzhledem k příkladu souboru |
| 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 |
Vyvolá vlastní událost s daty události v zadaném elementu HTML. |
| remove<T>((x: T) => boolean, T[]) | |
| set |
Povolte nebo zakažte tisk trasování zásobníku . |
| strip |
Vrátí |
| style |
Tato funkce vrátí formátovaný text s ohledem na
Při předávání pole formátů je pořadí použitého formátu zleva doprava, takže následující styl může přepsat předchozí styl. Speciální hodnota Kromě předdefinovaných názvů Úplný seznam formátů najdete v modifikátory. |
| to |
Vrátí |
| transferable |
Vytvoří a vrátí instanci |
| transferable |
Označí danou |
Proměnné
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
Podrobnosti funkce
isAnyArrayBuffer(unknown)
Vrátí true, pokud je hodnota předdefinovaná ArrayBuffer nebo instance SharedArrayBuffer.
Viz také util.types.isArrayBuffer() a util.types.isSharedArrayBuffer().
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLikeParametry
- object
-
unknown
Návraty
object is ArrayBufferLike
isArgumentsObject(unknown)
Vrátí true, pokud je hodnota objektem arguments.
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArgumentsParametry
- object
-
unknown
Návraty
object is IArguments
isArrayBuffer(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance ArrayBuffer.
To nezahrnuje instance SharedArrayBuffer. Obvykle je žádoucí testovat pro oba; Viz util.types.isAnyArrayBuffer().
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBufferParametry
- object
-
unknown
Návraty
object is ArrayBuffer
isArrayBufferView(unknown)
Vrátí true, pokud je hodnota instance jednoho z ArrayBuffer zobrazení, jako jsou typové maticové objekty nebo DataView. Ekvivalent k 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 ArrayBufferViewParametry
- object
-
unknown
Návraty
object is ArrayBufferView
isAsyncFunction(unknown)
Vrátí true, pokud je hodnota asynchronní funkce.
Toto pouze hlásí, co javascriptový modul vidí; Vrácená hodnota se zejména nemusí shodovat s původním zdrojovým kódem, pokud byl použit transpilační nástroj.
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): booleanParametry
- object
-
unknown
Návraty
boolean
isBigInt64Array(unknown)
Vrátí true, pokud je hodnota instance BigInt64Array.
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64ArrayParametry
- value
-
unknown
Návraty
value is BigInt64Array
isBigIntObject(unknown)
Vrátí true, pokud je hodnota Objekt BigInt, například vytvořený 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 BigIntParametry
- object
-
unknown
Návraty
object is BigInt
isBigUint64Array(unknown)
Vrátí true, pokud je hodnota instance BigUint64Array.
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64ArrayParametry
- value
-
unknown
Návraty
value is BigUint64Array
isBooleanObject(unknown)
Vrátí true, pokud je hodnota logickým objektem, například vytvořeným 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 BooleanParametry
- object
-
unknown
Návraty
object is Boolean
isBoxedPrimitive(unknown)
Vrátí true, pokud je hodnota libovolný primitivní objekt, například vytvořený new Boolean(), new String() nebo Object(Symbol()).
Příklady:
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 | BigIntParametry
- object
-
unknown
Návraty
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
Vrátí true, pokud je valueCryptoKey, false jinak.
function isCryptoKey(object: unknown): object is CryptoKeyParametry
- object
-
unknown
Návraty
object is CryptoKey
isDataView(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance DataView.
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
Viz také ArrayBuffer.isView().
function isDataView(object: unknown): object is DataViewParametry
- object
-
unknown
Návraty
object is DataView
isDate(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance Date.
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is DateParametry
- object
-
unknown
Návraty
object is Date
isExternal(unknown)
Vrátí true, pokud je hodnota nativní hodnotou External.
Nativní hodnota External je speciální typ objektu, který obsahuje nezpracovaný ukazatel C++ (void*) pro přístup z nativního kódu a nemá žádné další vlastnosti. Tyto objekty se vytvářejí buď Node.js interními nebo nativními doplňky. V JavaScriptu jsou ukotvené objekty s prototypem null .
#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
Další informace o napi_create_externalnajdete v napi_create_external().
function isExternal(object: unknown): booleanParametry
- object
-
unknown
Návraty
boolean
isFloat16Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Float16ArrayParametry
- object
-
unknown
Návraty
object is Float16Array
isFloat32Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Float32ArrayParametry
- object
-
unknown
Návraty
object is Float32Array
isFloat64Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Float64ArrayParametry
- object
-
unknown
Návraty
object is Float64Array
isGeneratorFunction(unknown)
Vrátí true, pokud je hodnota funkcí generátoru.
Toto pouze hlásí, co javascriptový modul vidí; Vrácená hodnota se zejména nemusí shodovat s původním zdrojovým kódem, pokud byl použit transpilační nástroj.
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunctionParametry
- object
-
unknown
Návraty
object is GeneratorFunction
isGeneratorObject(unknown)
Vrátí true, pokud je hodnota objekt generátoru vrácený z předdefinované funkce generátoru.
Toto pouze hlásí, co javascriptový modul vidí; Vrácená hodnota se zejména nemusí shodovat s původním zdrojovým kódem, pokud byl použit transpilační nástroj.
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is GeneratorParametry
- object
-
unknown
Návraty
object is Generator
isInt16Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Int16ArrayParametry
- object
-
unknown
Návraty
object is Int16Array
isInt32Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Int32ArrayParametry
- object
-
unknown
Návraty
object is Int32Array
isInt8Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Int8ArrayParametry
- object
-
unknown
Návraty
object is Int8Array
isKeyObject(unknown)
Vrátí true, pokud je valueKeyObject, false jinak.
function isKeyObject(object: unknown): object is KeyObjectParametry
- object
-
unknown
Návraty
object is KeyObject
isMap<T>({} | T)
Vrátí true, pokud je hodnota předdefinovaná instance 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>)Parametry
- object
-
{} | T
Návraty
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
Vrátí true, pokud je hodnota iterátor vrácená pro integrovanou instanci Map.
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): booleanParametry
- object
-
unknown
Návraty
boolean
isModuleNamespaceObject(unknown)
Vrátí true, pokud je hodnota instance objektu oboru názvů modulu.
import * as ns from './a.js';
util.types.isModuleNamespaceObject(ns); // Returns true
function isModuleNamespaceObject(value: unknown): booleanParametry
- value
-
unknown
Návraty
boolean
isNativeError(unknown)
Upozornění
Toto rozhraní API je teď zastaralé.
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
Vrátí true, pokud byla hodnota vrácena konstruktorem předdefinovaný typ Error.
console.log(util.types.isNativeError(new Error())); // true
console.log(util.types.isNativeError(new TypeError())); // true
console.log(util.types.isNativeError(new RangeError())); // true
Podtřídy nativních typů chyb jsou také nativní chyby:
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
Hodnota, která je instanceof nativní třídu chyb není ekvivalentní isNativeError() vracející true pro tuto hodnotu.
isNativeError() vrací true pro chyby, které pocházejí z jiného sféry, zatímco instanceof Error vrací false pro tyto chyby:
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
Naopak isNativeError() vrátí false pro všechny objekty, které nebyly vráceny konstruktorem nativní chyby. To zahrnuje hodnoty, které jsou instanceof nativní chyby:
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
function isNativeError(object: unknown): object is ErrorParametry
- object
-
unknown
Návraty
object is Error
isNumberObject(unknown)
Vrátí true, pokud je hodnota číselný objekt, například vytvořený new Number().
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is NumberParametry
- object
-
unknown
Návraty
object is Number
isPromise(unknown)
Vrátí true, pokud je hodnota předdefinovaná Promise.
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>Parametry
- object
-
unknown
Návraty
object is Promise<unknown>
isProxy(unknown)
Vrátí true, pokud je hodnota 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): booleanParametry
- object
-
unknown
Návraty
boolean
isRegExp(unknown)
Vrátí true, pokud je hodnota objektem regulárního výrazu.
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExpParametry
- object
-
unknown
Návraty
object is RegExp
isSet<T>({} | T)
Vrátí true, pokud je hodnota předdefinovaná instance 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>)Parametry
- object
-
{} | T
Návraty
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
Vrátí true, pokud je hodnota iterátor vrácená pro integrovanou instanci Set.
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): booleanParametry
- object
-
unknown
Návraty
boolean
isSharedArrayBuffer(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance SharedArrayBuffer.
To nezahrnuje instance ArrayBuffer. Obvykle je žádoucí testovat pro oba; Viz util.types.isAnyArrayBuffer().
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBufferParametry
- object
-
unknown
Návraty
object is SharedArrayBuffer
isStringObject(unknown)
Vrátí true, pokud je hodnota objektem řetězce, například vytvořeným new String().
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is StringParametry
- object
-
unknown
Návraty
object is String
isSymbolObject(unknown)
Vrátí true, pokud je hodnota objekt symbolu vytvořený voláním Object() na Symbol primitivu.
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is SymbolParametry
- object
-
unknown
Návraty
object is Symbol
isTypedArray(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance TypedArray.
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
Viz také ArrayBuffer.isView().
function isTypedArray(object: unknown): object is TypedArrayParametry
- object
-
unknown
Návraty
object is TypedArray
isUint16Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Uint16ArrayParametry
- object
-
unknown
Návraty
object is Uint16Array
isUint32Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Uint32ArrayParametry
- object
-
unknown
Návraty
object is Uint32Array
isUint8Array(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Uint8ArrayParametry
- object
-
unknown
Návraty
object is Uint8Array
isUint8ClampedArray(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance 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 Uint8ClampedArrayParametry
- object
-
unknown
Návraty
object is Uint8ClampedArray
isWeakMap(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance WeakMap.
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>Parametry
- object
-
unknown
Návraty
object is WeakMap<object, unknown>
isWeakSet(unknown)
Vrátí true, pokud je hodnota předdefinovaná instance WeakSet.
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>Parametry
- object
-
unknown
Návraty
object is WeakSet<object>
inspect(any, boolean, number | null, boolean)
Metoda util.inspect() vrátí řetězcovou reprezentaci object, která je určená pro ladění. Výstup util.inspect se může kdykoli změnit a neměl by být závislý programově. Další options mohou být předány, aby se změnil výsledek.
util.inspect() použije název konstruktoru nebo Symbol.toStringTag vlastnost k vytvoření identifikovatelné značky pro zkontrolovanou hodnotu.
class Foo {
get [Symbol.toStringTag]() {
return 'bar';
}
}
class Bar {}
const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });
util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz); // '[foo] {}'
Cyklický odkaz odkazuje na jejich ukotvení pomocí indexu odkazu:
import { inspect } from 'node:util';
const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;
console.log(inspect(obj));
// <ref *1> {
// a: [ [Circular *1] ],
// b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }
Následující příklad zkontroluje všechny vlastnosti util objektu:
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
Následující příklad zvýrazní účinek možnosti compact:
import { inspect } from 'node:util';
const o = {
a: [1, 2, [[
'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
'test',
'foo']], 4],
b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));
// { a:
// [ 1,
// 2,
// [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
// 'test',
// 'foo' ] ],
// 4 ],
// b: Map(2) { 'za' => 1, 'zb' => 'test' } }
// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));
// {
// a: [
// 1,
// 2,
// [
// [
// 'Lorem ipsum dolor sit amet,\n' +
// 'consectetur adipiscing elit, sed do eiusmod \n' +
// 'tempor incididunt ut labore et dolore magna aliqua.',
// 'test',
// 'foo'
// ]
// ],
// 4
// ],
// b: Map(2) {
// 'za' => 1,
// 'zb' => 'test'
// }
// }
// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.
Možnost showHidden umožňuje kontrolovat WeakMap a WeakSet položky. Pokud existuje více položek než maxArrayLength, není zaručeno, které položky jsou zobrazeny. To znamená, že načtení stejných položek WeakSet dvakrát může vést k jinému výstupu. Položky bez zbývajících silných odkazů navíc mohou být kdykoli uvolněny z paměti.
import { inspect } from 'node:util';
const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);
console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }
Možnost sorted zajišťuje, že pořadí vložení vlastnosti objektu nemá vliv na výsledek util.inspect().
import { inspect } from 'node:util';
import assert from 'node:assert';
const o1 = {
b: [2, 3, 1],
a: '`a` comes before `b`',
c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }
const o2 = {
c: new Set([2, 1, 3]),
a: '`a` comes before `b`',
b: [2, 3, 1],
};
assert.strict.equal(
inspect(o1, { sorted: true }),
inspect(o2, { sorted: true }),
);
Možnost numericSeparator přidá podtržítko každé tři číslice ke všem číslům.
import { inspect } from 'node:util';
const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;
console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45
util.inspect() je synchronní metoda určená pro ladění. Maximální délka výstupu je přibližně 128 MiB. Vstupy, které vedou k delšímu výstupu, budou zkráceny.
function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): stringParametry
- object
-
any
Jakýkoli javascriptový primitiv nebo Object.
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
Návraty
string
Reprezentace object.
promisify<TCustom>(CustomPromisify<TCustom>)
Přebírá funkci podle běžného stylu zpětného volání při první chybě, tj. přebírá (err, value) => ... zpětné volání jako poslední argument a vrací verzi, která vrací přísliby.
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
// Do something with `stats`
}).catch((error) => {
// Handle the error.
});
Nebo ekvivalentní použití async functions:
import { promisify } from 'node:util';
import { stat } from 'node:fs';
const promisifiedStat = promisify(stat);
async function callStat() {
const stats = await promisifiedStat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
callStat();
Pokud existuje original[util.promisify.custom] vlastnost, promisify vrátí její hodnotu, viz Custom promisified functions.
promisify() předpokládá, že original je funkce, která ve všech případech přebírá zpětné volání jako konečný argument. Pokud original funkce není, promisify() vyvolá chybu. Pokud original je funkce, ale její poslední argument není zpětným voláním typu error-first, bude jako poslední argument předán zpětné volání první chyby.
Použití promisify() u metod tříd nebo jiných metod, které používají this nemusí fungovat podle očekávání, pokud se nezpracuje speciálně:
import { promisify } from 'node:util';
class Foo {
constructor() {
this.a = 42;
}
bar(callback) {
callback(null, this.a);
}
}
const foo = new Foo();
const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));
naiveBar.call(foo).then((a) => console.log(a)); // '42'
const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'
function promisify<TCustom>(fn: CustomPromisify<TCustom>): TCustomParametry
- fn
-
CustomPromisify<TCustom>
Návraty
TCustom
aborted(AbortSignal, any)
Naslouchá přerušení události na zadaném signal a vrátí příslib, který se vyřeší při přerušení signal.
Pokud je k dispozici resource, slabě odkazuje na přidružený objekt operace, takže pokud resource je uvolňování paměti před přerušením signal, pak vrácený slib zůstane čekající.
To zabraňuje nevracení paměti v dlouhotrvajících nebo nerušitelných operacích.
import { aborted } from 'node:util';
// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();
// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
// This code runs when `dependent` is aborted.
console.log('Dependent resource was aborted.');
});
// Simulate an event that triggers the abort.
dependent.on('event', () => {
dependent.abort(); // This will cause the `aborted` promise to resolve.
});
function aborted(signal: AbortSignal, resource: any): Promise<void>Parametry
- signal
-
AbortSignal
- resource
-
any
Všechny objekty, které nejsou null vázané na operaci přerušení a jsou slabě uloženy.
Pokud resource je před přerušením signal uvolňování paměti, příslib zůstane čekající a umožní Node.js zastavit jeho sledování.
To pomáhá zabránit nevracení paměti v dlouhotrvajících nebo nerušitelných operacích.
Návraty
Promise<void>
addParamToUrl(string, string, string)
Přidá parametr na danou adresu URL.
function addParamToUrl(url: string, paramName: string, value: string): stringParametry
- url
-
string
- paramName
-
string
- value
-
string
Návraty
string
assign(any[])
Zkopíruje hodnoty všech výčtových vlastností z jednoho nebo více zdrojových objektů do cílového objektu a vrátí cílový objekt.
function assign(args: any[]): anyParametry
- args
-
any[]
Návraty
any
autoAuthInEmbedUrl(string)
Zkontroluje, jestli adresa URL pro vložení obsahuje autoAuth=true.
function autoAuthInEmbedUrl(embedUrl: string): booleanParametry
- embedUrl
-
string
Návraty
boolean
callbackify(() => Promise<void>)
Vezme async funkci (nebo funkci, která vrací Promise) a vrátí funkci za stylem zpětného volání první chyby, tj. jako poslední argument vezme (err, value) => ... zpětné volání. V zpětném volání bude prvním argumentem důvod zamítnutí (nebo null, pokud Promise vyřešen) a druhý argument bude přeloženou hodnotou.
import { callbackify } from 'node:util';
async function fn() {
return 'hello world';
}
const callbackFunction = callbackify(fn);
callbackFunction((err, ret) => {
if (err) throw err;
console.log(ret);
});
Vytiskne se:
hello world
Zpětné volání se provádí asynchronně a bude mít omezené trasování zásobníku.
Pokud zpětné volání vyvolá, proces vygeneruje 'uncaughtException' událost a pokud se nezpracuje, ukončí se.
Vzhledem k tomu, že null má jako první argument zpětného volání zvláštní význam, pokud zabalená funkce odmítne Promise s falsy hodnotou jako důvod, je hodnota zabalena do Error s původní hodnotou uloženou v poli s názvem reason.
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) => voidParametry
- fn
-
() => Promise<void>
Funkce async
Návraty
(callback: (err: ErrnoException) => void) => void
funkce stylu zpětného volání
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => voidParametry
- fn
-
() => Promise<TResult>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1) => Promise<void>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1) => Promise<TResult>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
Návraty
(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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: 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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: 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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: 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) => voidParametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: ErrnoException | null, result: TResult) => void) => void
convertProcessSignalToExitCode(Signals)
Metoda util.convertProcessSignalToExitCode() převede název signálu na odpovídající ukončovací kód POSIX. Po provedení standardu POSIX se ukončovací kód pro proces ukončený signálem vypočítá jako 128 + signal number.
Pokud signal není platný název signálu, vyvolá se chyba. Podívejte signal(7) se na seznam platných signálů.
import { convertProcessSignalToExitCode } from 'node:util';
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
To je zvlášť užitečné při práci s procesy, které určují ukončovací kód na základě signálu, který proces ukončil.
function convertProcessSignalToExitCode(signal: Signals): numberParametry
- signal
-
Signals
Název signálu (např. 'SIGTERM')
Návraty
number
Ukončovací kód odpovídající signal
createRandomString()
Vygeneruje náhodný řetězec 5 až 6 znaků.
function createRandomString(): stringNávraty
string
debuglog(string, (fn: DebugLoggerFunction) => void)
Metoda util.debuglog() se používá k vytvoření funkce, která podmíněně zapisuje ladicí zprávy na stderr základě existence NODE_DEBUG proměnné prostředí. Pokud se název section zobrazí v hodnotě této proměnné prostředí, pak vrácená funkce funguje podobně jako console.error(). Pokud ne, vrácená funkce je no-op.
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hello from foo [%d]', 123);
Pokud je tento program spuštěn s NODE_DEBUG=foo v prostředí, bude výstup vypadat přibližně takto:
FOO 3245: hello from foo [123]
kde 3245 je ID procesu. Pokud se nespustí s danou sadou proměnných prostředí, nic se nevytiskne.
section podporuje také zástupný znak:
import { debuglog } from 'node:util';
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);
Pokud se spustí s NODE_DEBUG=foo* v prostředí, bude výstup vypadat přibližně takto:
FOO-BAR 3257: hi there, it's foo-bar [2333]
V proměnné prostředí lze zadat section více názvů oddělených NODE_DEBUG čárkami: NODE_DEBUG=fs,net,tls.
Volitelný argument callback lze použít k nahrazení funkce protokolování jinou funkcí, která nemá žádné inicializace ani zbytečné zabalení.
import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
// Replace with a logging function that optimizes out
// testing if the section is enabled
log = debug;
});
function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLoggerParametry
- section
-
string
Řetězec identifikující část aplikace, pro kterou se vytváří debuglog funkce.
- callback
-
(fn: DebugLoggerFunction) => void
Zpětné volání vyvoláno při prvním volání funkce protokolování s argumentem funkce, který je optimalizovanější funkce protokolování.
Návraty
Funkce protokolování
deprecate<T>(T, string, string, DeprecateOptions)
Metoda util.deprecate() zabalí fn (což může být funkce nebo třída) takovým způsobem, že je označena jako zastaralá.
import { deprecate } from 'node:util';
export const obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
Při zavolání vrátí util.deprecate() funkci, která vygeneruje DeprecationWarning pomocí události 'warning'. Upozornění se vygeneruje a vytiskne na stderr při prvním zavolání vrácené funkce. Po vygenerování upozornění se zabalená funkce zavolá bez vygenerování upozornění.
Pokud je stejná volitelná code zadána ve více voláních util.deprecate(), upozornění se vygeneruje pouze jednou pro tento code.
import { deprecate } from 'node:util';
const fn1 = deprecate(
() => 'a value',
'deprecation message',
'DEP0001',
);
const fn2 = deprecate(
() => 'a different value',
'other dep message',
'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code
Pokud se použijí příznaky příkazového řádku --no-deprecation nebo --no-warnings nebo pokud je vlastnost process.noDeprecation nastavená na truepřed na první upozornění na vyřazení, metoda util.deprecate() nic nedělá.
Pokud jsou nastavené příznaky --trace-deprecation nebo --trace-warnings příkazového řádku nebo je vlastnost process.traceDeprecation nastavena na true, zobrazí se upozornění a trasování zásobníku se vytiskne na stderr při prvním zavolání zastaralé funkce.
Pokud je nastaven příznak příkazového řádku --throw-deprecation nebo je vlastnost process.throwDeprecation nastavena na true, bude vyvolána výjimka při zavolání zastaralé funkce.
Příznak příkazového řádku --throw-deprecation a vlastnost process.throwDeprecation má přednost před --trace-deprecation a process.traceDeprecation.
function deprecate<T>(fn: T, msg: string, code?: string, options?: DeprecateOptions): TParametry
- fn
-
T
Funkce, která je zastaralá.
- msg
-
string
Zpráva s upozorněním, která se zobrazí při vyvolání zastaralé funkce.
- code
-
string
Kód vyřazení. Seznam kódů najdete v list of deprecated APIs.
- options
- DeprecateOptions
Návraty
T
Zastaralá funkce zabalená k vygenerování upozornění.
diff(string | (readonly string[]), string | (readonly string[]))
util.diff() porovná dva řetězcové nebo maticové hodnoty a vrátí matici položek rozdílů.
K výpočtu minimálních rozdílů používá myers rozdílový algoritmus, což je stejný algoritmus používaný interně pomocí chybových zpráv kontrolního výrazu.
Pokud jsou hodnoty stejné, vrátí se prázdné pole.
const { diff } = require('node:util');
// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
// [0, '1'],
// [0, '2'],
// [1, '3'],
// [1, '4'],
// [-1, '!'],
// [-1, '!'],
// [0, '5'],
// [1, '6'],
// [-1, '!'],
// [0, '7'],
// [1, '8'],
// [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
// [0, '1'],
// [1, '2'],
// [0, '3'],
// [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []
function diff(actual: string | (readonly string[]), expected: string | (readonly string[])): DiffEntry[]Parametry
- actual
-
string | (readonly string[])
První hodnota, která se má porovnat
- expected
-
string | (readonly string[])
Druhá hodnota, kterou chcete porovnat
Návraty
Pole položek rozdílů. Každá položka je pole se dvěma prvky:
- Index 0:
numberKód operace:-1pro odstranění0, pro no-op/beze změny,1pro vložení - Index 1:
stringHodnota přidružená k operaci
find<T>((x: T) => boolean, T[])
Najde první hodnotu v matici, která odpovídá zadanému predikátu.
function find<T>(predicate: (x: T) => boolean, xs: T[]): TParametry
- predicate
-
(x: T) => boolean
- xs
-
T[]
Návraty
T
findIndex<T>((x: T) => boolean, T[])
Vyhledá index první hodnoty v matici, která odpovídá zadanému predikátu.
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): numberParametry
- predicate
-
(x: T) => boolean
- xs
-
T[]
Návraty
number
format(any, any[])
Metoda util.format() vrátí formátovaný řetězec pomocí prvního argumentu jako printf-like formátovací řetězec, který může obsahovat nula nebo více specifikátorů formátu. Každý specifikátor se nahradí převedenou hodnotou z odpovídajícího argumentu. Podporované specifikátory jsou:
Pokud specifikátor nemá odpovídající argument, nenahradí se:
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
Hodnoty, které nejsou součástí formátovacího řetězce, jsou formátovány pomocí util.inspect(), pokud jejich typ není string.
Pokud je metodě util.format() předáno více argumentů než počet specifikátorů, další argumenty se zřetězí do vráceného řetězce oddělené mezerami:
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
Pokud první argument neobsahuje platný specifikátor formátu, util.format() vrátí řetězec, který je zřetězením všech argumentů oddělených mezerami:
util.format(1, 2, 3);
// Returns: '1 2 3'
Pokud se util.format()předá jenom jeden argument, vrátí se tak, jak je bez formátování:
util.format('%% %s');
// Returns: '%% %s'
util.format() je synchronní metoda, která je určená jako nástroj pro ladění.
Některé vstupní hodnoty můžou mít významnou režii na výkon, která může blokovat smyčku událostí. Tuto funkci používejte opatrně a nikdy v horké cestě kódu.
function format(format?: any, param: any[]): stringParametry
- format
-
any
Formátovací řetězec printf.
- param
-
any[]
Návraty
string
formatWithOptions(InspectOptions, any, any[])
Tato funkce je shodná s formátem s tím rozdílem, že přebírá inspectOptions argument, který určuje možnosti, které se předávají kontrole.
util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.
function formatWithOptions(inspectOptions: InspectOptions, format?: any, param: any[]): stringParametry
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
Návraty
string
generateUUID()
Vygeneruje 20 znaků uuid.
function generateUUID(): stringNávraty
string
getCallSites(number, GetCallSitesOptions)
Vrátí pole objektů lokality volání obsahující zásobník funkce volajícího.
Na rozdíl od přístupu k error.stackrozhraní API není výsledek vrácený z tohoto rozhraní API kolidován 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();
Původní umístění je možné rekonstruovat nastavením možnosti sourceMaptrue.
Pokud zdrojová mapa není k dispozici, původní umístění bude stejné jako aktuální umístění.
--enable-source-maps Pokud je příznak povolený, sourceMap bude ve výchozím nastavení true.
import { getCallSites } from 'node:util';
interface Foo {
foo: string;
}
const callSites = getCallSites({ sourceMap: true });
// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26
// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[]Parametry
- frameCount
-
number
Počet snímků, které se mají zachytit jako objekty lokality volání
výchozí :10. Povolený rozsah je mezi 1 a 200.
- options
- GetCallSitesOptions
Návraty
Pole objektů webu volání
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]Parametry
- options
- GetCallSitesOptions
Návraty
getRandomValue()
Vrátí náhodné číslo.
function getRandomValue(): numberNávraty
number
getSystemErrorMap()
Vrátí mapu všech kódů systémových chyb dostupných v rozhraní Node.js API.
Mapování mezi kódy chyb a názvy chyb závisí na platformě.
Názvy běžných chyb najdete v Common System Errors.
fs.access('file/that/does/not/exist', (err) => {
const errorMap = util.getSystemErrorMap();
const name = errorMap.get(err.errno);
console.error(name); // ENOENT
});
function getSystemErrorMap(): Map<number, [string, string]>Návraty
Map<number, [string, string]>
getSystemErrorMessage(number)
Vrátí řetězcovou zprávu pro číselný kód chyby, který pochází z rozhraní API Node.js. Mapování mezi kódy chyb a řetězcovými zprávami je závislé na platformě.
fs.access('file/that/does/not/exist', (err) => {
const message = util.getSystemErrorMessage(err.errno);
console.error(message); // no such file or directory
});
function getSystemErrorMessage(err: number): stringParametry
- err
-
number
Návraty
string
getSystemErrorName(number)
Vrátí název řetězce pro číselný kód chyby, který pochází z rozhraní API Node.js.
Mapování mezi kódy chyb a názvy chyb závisí na platformě.
Názvy běžných chyb najdete v Common System Errors.
fs.access('file/that/does/not/exist', (err) => {
const name = util.getSystemErrorName(err.errno);
console.error(name); // ENOENT
});
function getSystemErrorName(err: number): stringParametry
- err
-
number
Návraty
string
getTimeDiffInMilliseconds(Date, Date)
Vrátí časový interval mezi dvěma daty v milisekundách.
function getTimeDiffInMilliseconds(start: Date, end: Date): numberParametry
- start
-
Date
- end
-
Date
Návraty
number
inherits(unknown, unknown)
Použití util.inherits() se nedoporučuje. Pokud chcete získat podporu dědičnosti na úrovni jazyka, použijte class ES6 a klíčová slova extends. Všimněte si také, že tyto dva styly jsou sémanticky nekompatibilní.
Dědí prototypové metody z jednoho konstruktoru do jiného. Prototyp constructor bude nastaven na nový objekt vytvořený z superConstructor.
To hlavně přidává některé vstupní ověřování nad Object.setPrototypeOf(constructor.prototype, superConstructor.prototype).
Jako další pohodlí bude superConstructor přístupné prostřednictvím constructor.super_ vlastnosti.
const util = require('node:util');
const EventEmitter = require('node:events');
function MyStream() {
EventEmitter.call(this);
}
util.inherits(MyStream, EventEmitter);
MyStream.prototype.write = function(data) {
this.emit('data', data);
};
const stream = new MyStream();
console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"
Příklad ES6 používající class a extends:
import EventEmitter from 'node:events';
class MyStream extends EventEmitter {
write(data) {
this.emit('data', data);
}
}
const stream = new MyStream();
stream.on('data', (data) => {
console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
function inherits(constructor: unknown, superConstructor: unknown)Parametry
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): stringParametry
- object
-
any
- options
- InspectOptions
Návraty
string
isArray(unknown)
Upozornění
Toto rozhraní API je teď zastaralé.
Since v4.0.0 - Use isArray instead.
Alias pro Array.isArray().
Vrátí true, pokud je daná objectArray. V opačném případě vrátí hodnotu false.
import util from 'node:util';
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
function isArray(object: unknown): object is unknown[]Parametry
- object
-
unknown
Návraty
object is unknown[]
isCreate(string)
Zkontroluje, jestli je typ vložení pro vytvoření.
function isCreate(embedType: string): booleanParametry
- embedType
-
string
Návraty
boolean
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)
Vrátí true, pokud existuje hloubková striktní rovnost mezi val1 a val2.
V opačném případě vrátí hodnotu false.
Další informace o hluboké striktní rovnosti najdete v tématu assert.deepStrictEqual().
function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): booleanParametry
- val1
-
unknown
- val2
-
unknown
- options
- IsDeepStrictEqualOptions
Návraty
boolean
isRDLEmbed(string)
Zkontroluje, jestli je adresa URL pro vložení pro sestavu RDL.
function isRDLEmbed(embedUrl: string): booleanParametry
- embedUrl
-
string
Návraty
boolean
isSavedInternal(HttpPostMessage, string, Window)
Zkontroluje, jestli je sestava uložená.
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>Parametry
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
- Window
Návraty
Promise<boolean>
parseArgs<T>(T)
Poskytuje rozhraní API vyšší úrovně pro analýzu argumentů příkazového řádku než přímé interakce s process.argv. Vezme specifikaci očekávaných argumentů a vrátí strukturovaný objekt s parsovanými možnostmi a pozicemi.
import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
foo: {
type: 'boolean',
short: 'f',
},
bar: {
type: 'string',
},
};
const {
values,
positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []
function parseArgs<T>(config?: T): ParsedResults<T>Parametry
- config
-
T
Používá se k zadání argumentů pro analýzu a ke konfiguraci analyzátoru.
config podporuje následující vlastnosti:
Návraty
ParsedResults<T>
Analyzované argumenty příkazového řádku:
parseEnv(string)
Stabilita: 1.1 – Aktivní vývoj Vzhledem k příkladu souboru .env:
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): Dict<string>Parametry
- content
-
string
Nezpracovaný obsah souboru .env.
Návraty
Dict<string>
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>Parametry
- fn
-
(callback: (err: any, result: TResult) => void) => void
Návraty
() => Promise<TResult>
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>Parametry
- fn
-
(callback: (err?: any) => void) => void
Návraty
() => Promise<void>
promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>Parametry
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
Návraty
(arg1: T1) => Promise<TResult>
promisify<T1>((arg1: T1, callback: (err?: any) => void) => void)
function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>Parametry
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
Návraty
(arg1: T1) => Promise<void>
promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>Parametry
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
Návraty
(arg1: T1, arg2: T2) => Promise<TResult>
promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void)
function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>Parametry
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
Návraty
(arg1: T1, arg2: T2) => Promise<void>
promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>
promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void)
function promisify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>
promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void)
function promisify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>Parametry
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void
Návraty
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>
promisify(Function)
function promisify(fn: Function): FunctionParametry
- fn
-
Function
Návraty
Function
raiseCustomEvent(HTMLElement, string, any)
Vyvolá vlastní událost s daty události v zadaném elementu HTML.
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)Parametry
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])Parametry
- predicate
-
(x: T) => boolean
- xs
-
T[]
setTraceSigInt(boolean)
Povolte nebo zakažte tisk trasování zásobníku .SIGINT Rozhraní API je k dispozici pouze v hlavním vlákně.
function setTraceSigInt(enable: boolean)Parametry
- enable
-
boolean
stripVTControlCharacters(string)
Vrátí str s odebranými řídicími kódy ANSI.
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): stringParametry
- str
-
string
Návraty
string
styleText(InspectColor | Object | (readonly InspectColor | `#${string}`[]), string, StyleTextOptions)
Tato funkce vrátí formátovaný text s ohledem na format předaný tisk v terminálu. Je si vědom schopností terminálu a funguje podle konfigurační sady prostřednictvím NO_COLORa NODE_DISABLE_COLORSFORCE_COLOR proměnných prostředí.
import { styleText } from 'node:util';
import { stderr } from 'node:process';
const successMessage = styleText('green', 'Success!');
console.log(successMessage);
const errorMessage = styleText(
'red',
'Error! Error!',
// Validate if process.stderr has TTY
{ stream: stderr },
);
console.error(errorMessage);
util.inspect.colors také poskytuje textové formáty, jako jsou italica underline a můžete kombinovat obojí:
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
Při předávání pole formátů je pořadí použitého formátu zleva doprava, takže následující styl může přepsat předchozí styl.
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
Speciální hodnota none formátu neplatí pro text žádný další styl.
Kromě předdefinovaných názvů util.styleText() barev podporuje šestnáctkové barevné řetězce pomocí řídicích sekvencí ANSI TrueColor (24bitová). Šestnáctkové barvy lze zadat v 3ciferném (#RGB) nebo 6místném formátu (#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'));
// Hex color combined with other modifiers
console.log(styleText(['#00f', 'bold'], 'Bold blue text'));
Úplný seznam formátů najdete v modifikátory.
function styleText(format: InspectColor | Object | (readonly InspectColor | `#${string}`[]), text: string, options?: StyleTextOptions): stringParametry
- format
-
InspectColor | Object | (readonly InspectColor |
#${string}[])
Textový formát definovaný v util.inspect.colorsšestnáctkové barvě #RGB nebo #RRGGBB formě nebo pole textových formátů nebo šestnáctkových barev.
- text
-
string
Text, který se má naformátovat.
- options
- StyleTextOptions
Návraty
string
toUSVString(string)
Vrátí string po nahrazení všech náhradních bodů kódu (nebo ekvivalentních jednotek nezaplaceného náhradního kódu) znakem U+FFFD s kódováním Unicode.
function toUSVString(string: string): stringParametry
- string
-
string
Návraty
string
transferableAbortController()
Vytvoří a vrátí instanci AbortController, jejíž AbortSignal je označena jako přenositelná a lze ji použít s structuredClone() nebo postMessage().
function transferableAbortController(): AbortControllerNávraty
AbortController
Přenositelný AbortController
transferableAbortSignal(AbortSignal)
Označí danou AbortSignal jako přenosnou, aby ji bylo možné použít sstructuredClone() a postMessage().
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignalParametry
- signal
-
AbortSignal
The AbortSignal
Návraty
AbortSignal
Stejný AbortSignal
Podrobnosti proměnné
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