powerbi-client package
類別
| AdvancedFilter | |
| BasicFilter | |
| BasicFilterWithKeys | |
| Filter | |
| HierarchyFilter | |
| HierarchyIdentityFilter | |
| IdentityFilter | |
| IncludeExcludeFilter | |
| NotSupportedFilter | |
| PageSelector | |
| RelativeDateFilter | |
| RelativeTimeFilter | |
| Selector | |
| SlicerTargetSelector | |
| TopNFilter | |
| TupleFilter | |
| VisualSelector | |
| VisualTypeSelector | |
| AdvancedFilterBuilder |
Power BI 進階篩選產生器元件 |
| BasicFilterBuilder |
Power BI Basic 篩選產生器元件 |
| BookmarksManager |
管理報表書籤。 |
| Create |
Power BI 報表建立者元件 |
| Dashboard |
Power BI 儀錶板內嵌元件 |
| FilterBuilder |
BasicFilter、AdvancedFilter、RelativeDate、RelativeTime 和 TopN 的泛型篩選產生器 |
| MIMEParams |
|
| MIMEType |
根據瀏覽器慣例， MIME 字串是包含多個有意義元件的結構化字串。 剖析時，會傳回 |
| Page |
Power BI 報表頁面 |
| Qna |
Power BI Q&內嵌元件 |
| QuickCreate |
Power BI 快速建立元件 |
| RelativeDateFilterBuilder |
Power BI 相對日期篩選產生器元件 |
| RelativeTimeFilterBuilder |
Power BI 相對時間篩選產生器元件 |
| Report |
Power BI 報表內嵌元件 |
| Service |
Power BI 服務內嵌元件，這是將所有其他 Power BI 元件內嵌至應用程式的進入點 |
| Tile |
Power BI 磚內嵌元件 |
| TopNFilterBuilder |
Power BI Top N 篩選產生器元件 |
| Visual |
Power BI Visual 內嵌元件 |
| VisualDescriptor |
頁面內的Power BI 視覺效果 |
介面
類型別名
列舉
函式
| is |
如果值是內建 請參閱 |
| is |
如果值是 |
| is |
如果值是內建 |
| is |
如果值是其中一個 |
| is |
如果值是異步函式 |
| is |
如果值是 |
| is |
如果值是 BigInt 物件，則傳回 |
| is |
如果值是 |
| is |
如果值是布爾物件，則傳回 |
| is |
如果值是任何 Boxed 基本物件，例如由 例如： |
| is |
如果 |
| is |
如果值是內建 請參閱 |
| is |
如果值是內建 |
| is |
如果值是原生 原生 如需 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值為產生器函式，則傳回 |
| is |
如果值是從內建產生器函式傳回的產生器物件，則傳回 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果 |
| is |
如果值是內建 |
| is |
如果值是針對內建 |
| is |
|
| is |
如果 原生錯誤類型的子類別也是原生錯誤：
相反地， |
| is |
如果值是數字物件，則傳回 |
| is |
如果值是內建 |
| is |
如果值是 |
| is |
如果值是正則表達式物件，則傳回 |
| is |
如果值是內建 |
| is |
如果值是針對內建 |
| is |
如果值是內建 |
| is |
如果值是字串物件，則傳回 |
| is |
如果值是符號物件，則傳回 |
| is |
如果值是內建 請參閱 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| is |
如果值是內建 |
| inspect(any, boolean, number | null, boolean) |
循環參考會使用參考索引指向其錨點： 下列範例會檢查 下列範例會反白顯示 [ [
|
| promisify<TCustom>(Custom |
採用遵循常見錯誤優先回呼樣式的函式，也就是以 或者，同樣地使用
除非特別處理，否則在類別方法或其他使用 |
| aborted(Abort |
接聽所提供 |
| add |
將參數新增至指定的 URL |
| assign(any[]) | 將所有可列舉屬性的值從一或多個來源物件複製到目標物件，並傳回目標物件。 |
| auto |
檢查內嵌 URL 是否包含 autoAuth=true。 |
| callbackify(() => Promise<void>) | 採用 將會列印： 回呼會以異步方式執行，而且會有有限的堆疊追蹤。
如果回呼擲回，進程將會發出 由於 |
| 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 |
此 若 這在與程序合作，根據終止程序的訊號來判定退出代碼時特別有用。 |
| create |
產生隨機 5 到 6 個字元字串。 |
| debuglog(string, (fn: Debug |
方法 如果此程式在環境中以 其中
如果在環境中以 環境變數中 選擇性 |
| deprecate<T>(T, string, string, Deprecate |
呼叫時， 如果在多個呼叫 如果使用 如果已設定 如果已設定命令行旗標
|
| diff(string | (readonly string[]), string | (readonly string[])) |
如果值相等，則會傳回空陣列。 |
| find<T>((x: T) => boolean, T[]) | 尋找陣列中符合指定述詞的第一個值。 |
| find |
尋找陣列中符合指定述詞之第一個值的索引。 |
| format(any, any[]) |
如果規範沒有對應的自變數，則不會取代： 如果格式字串的類型不是 如果傳遞至 如果第一個自變數不包含有效的格式規範， 如果只有一個自變數傳遞至
|
| format |
此函式與 |
| generateUUID() | 產生 20 個字元的 uuid。 |
| get |
傳回呼叫月台對象的陣列，其中包含呼叫端函式的堆疊。 與存取 藉由將 選項設定為 |
| get |
|
| get |
傳回隨機數 |
| get |
傳回可從 Node.js API 取得之所有系統錯誤碼的對應。
錯誤碼與錯誤名稱之間的對應與平台相關。
如需常見錯誤的名稱，請參閱 |
| get |
傳回來自 Node.js API 之數值錯誤碼的字串訊息。 錯誤碼與字串訊息之間的對應與平台相關。 |
| get |
傳回來自 Node.js API 之數值錯誤碼的字串名稱。
錯誤碼與錯誤名稱之間的對應與平台相關。
如需常見錯誤的名稱，請參閱 |
| get |
以毫秒為單位傳回兩個日期之間的時間間隔 |
| inherits(unknown, unknown) | 不建議使用 將原型方法從一個 建構函式 繼承到另一個建構函式。
這主要會在之上 使用 |
| inspect(any, Inspect |
|
| is |
如果指定的 |
| is |
檢查內嵌類型是否為建立 |
| is |
如果 如需深度嚴格相等的詳細資訊，請參閱 |
| is |
檢查內嵌 URL 是否為 RDL 報表。 |
| is |
檢查報表是否已儲存。 |
| parse |
提供比直接與 |
| parse |
穩定性：1.1 - 使用中開發 提供範例 |
| 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 |
使用指定 HTML 元素上的事件數據引發自訂事件。 |
| remove<T>((x: T) => boolean, T[]) | |
| set |
啟用或停用在 上 |
| strip |
傳回已移除任何 ANSI 逸出碼的 |
| style |
此函式會傳回格式化文字，
傳遞格式陣列時，套用的格式順序會由左至右，因此下列樣式可能會覆寫前一個格式。 特殊格式值 除了預設的色彩名稱外， 您可以在 修飾詞中找到格式的完整清單，。 |
| to |
以 Unicode “replacement character” U+FFFD 取代任何 Surrogate 字碼點之後，傳回 |
| transferable |
建立並傳回 |
| transferable |
將指定的 |
變數
| APINot |
|
| Embed |
|
| Text |
|
| Text |
|
| Document | |
| HTMLIFrame |
|
| Window | |
| config | |
| invalid |
|
| hpm |
|
| router |
|
| wpmp |
函式詳細資料
isAnyArrayBuffer(unknown)
如果值是內建 true 或 ArrayBuffer 實例，則傳回 SharedArrayBuffer。
請參閱 util.types.isArrayBuffer() 與 util.types.isSharedArrayBuffer()。
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike參數
- object
-
unknown
傳回
object is ArrayBufferLike
isArgumentsObject(unknown)
如果值是 true 物件，則傳回 arguments。
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
function isArgumentsObject(object: unknown): object is IArguments參數
- object
-
unknown
傳回
object is IArguments
isArrayBuffer(unknown)
如果值是內建 true 實例，則傳回 ArrayBuffer。
這不會 包含 SharedArrayBuffer 實例。 通常，最好同時測試這兩者：請參閱 util.types.isAnyArrayBuffer()。
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
function isArrayBuffer(object: unknown): object is ArrayBuffer參數
- object
-
unknown
傳回
object is ArrayBuffer
isArrayBufferView(unknown)
如果值是其中一個 true 檢視的實例，例如具類型的陣列物件或 ArrayBuffer，則傳回 DataView。 相當於 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 ArrayBufferView參數
- object
-
unknown
傳回
object is ArrayBufferView
isAsyncFunction(unknown)
isBigInt64Array(unknown)
如果值是 true 實例，則傳回 BigInt64Array。
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
function isBigInt64Array(value: unknown): value is BigInt64Array參數
- value
-
unknown
傳回
value is BigInt64Array
isBigIntObject(unknown)
如果值是 BigInt 物件，則傳回 true，例如，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 BigInt參數
- object
-
unknown
傳回
object is BigInt
isBigUint64Array(unknown)
如果值是 true 實例，則傳回 BigUint64Array。
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
function isBigUint64Array(value: unknown): value is BigUint64Array參數
- value
-
unknown
傳回
value is BigUint64Array
isBooleanObject(unknown)
如果值是布爾物件，則傳回 true，例如，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 Boolean參數
- object
-
unknown
傳回
object is Boolean
isBoxedPrimitive(unknown)
如果值是任何 Boxed 基本物件，例如由 true、new Boolean() 或 new String()所建立，則傳回 Object(Symbol())。
例如：
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 | BigInt參數
- object
-
unknown
傳回
object is String | Number | Boolean | Symbol | BigInt
isCryptoKey(unknown)
如果 true 為 value，則傳回 CryptoKey，否則傳回 false。
function isCryptoKey(object: unknown): object is CryptoKey參數
- object
-
unknown
傳回
object is CryptoKey
isDataView(unknown)
如果值是內建 true 實例，則傳回 DataView。
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
請參閱 ArrayBuffer.isView()。
function isDataView(object: unknown): object is DataView參數
- object
-
unknown
傳回
object is DataView
isDate(unknown)
如果值是內建 true 實例，則傳回 Date。
util.types.isDate(new Date()); // Returns true
function isDate(object: unknown): object is Date參數
- object
-
unknown
傳回
object is Date
isExternal(unknown)
如果值是原生 true 值，則傳回 External。
原生 External 值是特殊的物件類型，其中包含原始C++指標（void*），以便從機器碼存取，而且沒有其他屬性。 這類物件是由內部 Node.js 或原生附加元件所建立。 在 JavaScript 中，它們是具有原型的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
如需 napi_create_external的詳細資訊，請參閱 napi_create_external()。
function isExternal(object: unknown): boolean參數
- object
-
unknown
傳回
boolean
isFloat16Array(unknown)
如果值是內建 true 實例，則傳回 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 Float16Array參數
- object
-
unknown
傳回
object is Float16Array
isFloat32Array(unknown)
如果值是內建 true 實例，則傳回 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 Float32Array參數
- object
-
unknown
傳回
object is Float32Array
isFloat64Array(unknown)
如果值是內建 true 實例，則傳回 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 Float64Array參數
- object
-
unknown
傳回
object is Float64Array
isGeneratorFunction(unknown)
如果值為產生器函式，則傳回 true。
這隻會回報 JavaScript 引擎所看到的內容;特別是，如果使用轉譯工具，傳回值可能不符合原始原始原始程式碼。
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
function isGeneratorFunction(object: unknown): object is GeneratorFunction參數
- object
-
unknown
傳回
object is GeneratorFunction
isGeneratorObject(unknown)
如果值是從內建產生器函式傳回的產生器物件，則傳回 true。
這隻會回報 JavaScript 引擎所看到的內容;特別是，如果使用轉譯工具，傳回值可能不符合原始原始原始程式碼。
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
function isGeneratorObject(object: unknown): object is Generator參數
- object
-
unknown
傳回
object is Generator
isInt16Array(unknown)
如果值是內建 true 實例，則傳回 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 Int16Array參數
- object
-
unknown
傳回
object is Int16Array
isInt32Array(unknown)
如果值是內建 true 實例，則傳回 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 Int32Array參數
- object
-
unknown
傳回
object is Int32Array
isInt8Array(unknown)
如果值是內建 true 實例，則傳回 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 Int8Array參數
- object
-
unknown
傳回
object is Int8Array
isKeyObject(unknown)
如果 true 為 value，則傳回 KeyObject，否則傳回 false。
function isKeyObject(object: unknown): object is KeyObject參數
- object
-
unknown
傳回
object is KeyObject
isMap<T>({} | T)
如果值是內建 true 實例，則傳回 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>)參數
- object
-
{} | T
傳回
object is (T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>) : Map<unknown, unknown>)
isMapIterator(unknown)
如果值是針對內建 true 實例傳回的反覆運算器，則傳回 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): boolean參數
- object
-
unknown
傳回
boolean
isModuleNamespaceObject(unknown)
isNativeError(unknown)
警告
此 API 現已淘汰。
The util.types.isNativeError API is deprecated. Please use Error.isError instead.
如果 true的建構函式傳回值，則傳回 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
原生錯誤類型的子類別也是原生錯誤：
class MyError extends Error {}
console.log(util.types.isNativeError(new MyError())); // true
instanceof 原生錯誤類別的值不等於傳回該值 isNativeError()true。
isNativeError() 傳回來自不同 true 的錯誤 ，而 instanceof Error 傳回這些錯誤的 false：
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
相反地，isNativeError() 會針對原生錯誤建構函式未傳回的所有物件傳回 false。 這包括 instanceof 原生錯誤的值：
const myError = { __proto__: Error.prototype };
console.log(util.types.isNativeError(myError)); // false
console.log(myError instanceof Error); // true
function isNativeError(object: unknown): object is Error參數
- object
-
unknown
傳回
object is Error
isNumberObject(unknown)
如果值是數字物件，則傳回 true，例如，new Number()所建立。
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
function isNumberObject(object: unknown): object is Number參數
- object
-
unknown
傳回
object is Number
isPromise(unknown)
如果值是內建 true，則傳回 Promise。
util.types.isPromise(Promise.resolve(42)); // Returns true
function isPromise(object: unknown): object is Promise<unknown>參數
- object
-
unknown
傳回
object is Promise<unknown>
isProxy(unknown)
如果值是 true 實例，則傳回 Proxy。
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
function isProxy(object: unknown): boolean參數
- object
-
unknown
傳回
boolean
isRegExp(unknown)
如果值是正則表達式物件，則傳回 true。
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
function isRegExp(object: unknown): object is RegExp參數
- object
-
unknown
傳回
object is RegExp
isSet<T>({} | T)
如果值是內建 true 實例，則傳回 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>)參數
- object
-
{} | T
傳回
object is (T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>)
isSetIterator(unknown)
如果值是針對內建 true 實例傳回的反覆運算器，則傳回 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): boolean參數
- object
-
unknown
傳回
boolean
isSharedArrayBuffer(unknown)
如果值是內建 true 實例，則傳回 SharedArrayBuffer。
這不會 包含 ArrayBuffer 實例。 通常，最好同時測試這兩者：請參閱 util.types.isAnyArrayBuffer()。
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer參數
- object
-
unknown
傳回
object is SharedArrayBuffer
isStringObject(unknown)
如果值是字串物件，則傳回 true，例如，new String()所建立。
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
function isStringObject(object: unknown): object is String參數
- object
-
unknown
傳回
object is String
isSymbolObject(unknown)
如果值是符號物件，則傳回 true，方法是在 Object() 基本類型上呼叫 Symbol。
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
function isSymbolObject(object: unknown): object is Symbol參數
- object
-
unknown
傳回
object is Symbol
isTypedArray(unknown)
如果值是內建 true 實例，則傳回 TypedArray。
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
請參閱 ArrayBuffer.isView()。
function isTypedArray(object: unknown): object is TypedArray參數
- object
-
unknown
傳回
object is TypedArray
isUint16Array(unknown)
如果值是內建 true 實例，則傳回 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 Uint16Array參數
- object
-
unknown
傳回
object is Uint16Array
isUint32Array(unknown)
如果值是內建 true 實例，則傳回 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 Uint32Array參數
- object
-
unknown
傳回
object is Uint32Array
isUint8Array(unknown)
如果值是內建 true 實例，則傳回 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 Uint8Array參數
- object
-
unknown
傳回
object is Uint8Array
isUint8ClampedArray(unknown)
如果值是內建 true 實例，則傳回 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 Uint8ClampedArray參數
- object
-
unknown
傳回
object is Uint8ClampedArray
isWeakMap(unknown)
如果值是內建 true 實例，則傳回 WeakMap。
util.types.isWeakMap(new WeakMap()); // Returns true
function isWeakMap(object: unknown): object is WeakMap<object, unknown>參數
- object
-
unknown
傳回
object is WeakMap<object, unknown>
isWeakSet(unknown)
如果值是內建 true 實例，則傳回 WeakSet。
util.types.isWeakSet(new WeakSet()); // Returns true
function isWeakSet(object: unknown): object is WeakSet<object>參數
- object
-
unknown
傳回
object is WeakSet<object>
inspect(any, boolean, number | null, boolean)
util.inspect() 方法會傳回用於偵錯之 object 的字串表示。
util.inspect 的輸出隨時可能會變更，不應以程序設計方式相依。 可能會傳遞其他 options 來改變結果。
util.inspect() 會使用建構函式的名稱和/或 Symbol.toStringTag 屬性，為檢查的值建立可識別的標籤。
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] {}'
循環參考會使用參考索引指向其錨點：
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] }
// }
下列範例會檢查 util 物件的所有屬性：
import util from 'node:util';
console.log(util.inspect(util, { showHidden: true, depth: null }));
下列範例會反白顯示 [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.
[showHidden] 選項允許檢查 WeakMap 和 WeakSet 專案。 如果項目數超過 maxArrayLength，則不保證會顯示哪些專案。 這表示擷取相同的 WeakSet 專案兩次可能會導致不同的輸出。 此外，任何沒有剩餘強式參考的項目隨時都可以進行垃圾收集。
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 } }
sorted 選項可確保物件的屬性插入順序不會影響 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 }),
);
numericSeparator 選項會將底線每三位數新增至所有數位。
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() 是用於偵錯的同步方法。 其最大輸出長度約為 128 MiB。 會導致輸出較長的輸入將會被截斷。
function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string參數
- object
-
any
任何 JavaScript 基本或 Object。
- showHidden
-
boolean
- depth
-
number | null
- color
-
boolean
傳回
string
object的表示法。
promisify<TCustom>(CustomPromisify<TCustom>)
採用遵循常見錯誤優先回呼樣式的函式，也就是以 (err, value) => ... 回呼作為最後一個自變數，並傳回傳回 promise 的版本。
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.
});
或者，同樣地使用 async function：
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();
original[util.promisify.custom]如果有屬性存在，promisify將會傳回其值，請參閱自定義代理函式。
promisify() 假設 original 是在所有情況下採用回呼作為其最終自變數的函式。 如果 original 不是函式，promisify() 會擲回錯誤。 如果 original 是函式，但其最後一個自變數不是錯誤優先回呼，它仍會傳遞錯誤優先回呼作為其最後一個自變數。
除非特別處理，否則在類別方法或其他使用 promisify() 的方法上使用 this 可能無法如預期般運作：
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>): TCustom參數
- fn
-
CustomPromisify<TCustom>
傳回
TCustom
aborted(AbortSignal, any)
接聽所提供 signal 上的中止事件，並傳回在中止 signal 時解析的承諾。
如果提供 resource，它會弱式參考作業的相關物件，因此，如果在 resource 中止之前垃圾收集 signal，則傳回的承諾應維持擱置中。
這可防止長時間執行或不可取消的作業中記憶體流失。
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>參數
- signal
-
AbortSignal
- resource
-
any
任何系結至可中止作業並處於弱式狀態的非 Null 物件。
如果 resource 在 signal 中止之前進行垃圾收集，承諾仍會擱置中，讓 Node.js 停止追蹤。
這有助於防止長時間執行或無法取消作業中的記憶體流失。
傳回
Promise<void>
addParamToUrl(string, string, string)
將參數新增至指定的 URL
function addParamToUrl(url: string, paramName: string, value: string): string參數
- url
-
string
- paramName
-
string
- value
-
string
傳回
string
assign(any[])
將所有可列舉屬性的值從一或多個來源物件複製到目標物件，並傳回目標物件。
function assign(args: any[]): any參數
- args
-
any[]
傳回
any
autoAuthInEmbedUrl(string)
檢查內嵌 URL 是否包含 autoAuth=true。
function autoAuthInEmbedUrl(embedUrl: string): boolean參數
- embedUrl
-
string
傳回
boolean
callbackify(() => Promise<void>)
採用 async 函式（或傳回 Promise的函式），並在錯誤優先回呼樣式之後傳回函式，也就是以 (err, value) => ... 回呼作為最後一個自變數。 在回呼中，第一個自變數將是拒絕原因（如果已解析 null，則為 Promise），而第二個自變數將是解析的值。
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);
});
將會列印：
hello world
回呼會以異步方式執行，而且會有有限的堆疊追蹤。
如果回呼擲回，進程將會發出 'uncaughtException' 事件，如果未處理，則會結束。
由於 null 具有回呼的第一個自變數的特殊意義，因此，如果包裝函式拒絕具有假值作為原因的 Promise，則值會包裝在 Error 中，其原始值會儲存在名為 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) => void參數
- fn
-
() => Promise<void>
async 函式
傳回
(callback: (err: ErrnoException) => void) => void
回呼樣式函式
callbackify<TResult>(() => Promise<TResult>)
function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: ErrnoException, result: TResult) => void) => void參數
- fn
-
() => Promise<TResult>
傳回
(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) => void參數
- fn
-
(arg1: T1) => Promise<void>
傳回
(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) => void參數
- fn
-
(arg1: T1) => Promise<TResult>
傳回
(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) => void參數
- fn
-
(arg1: T1, arg2: T2) => Promise<void>
傳回
(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) => void參數
- fn
-
(arg1: T1, arg2: T2) => Promise<TResult>
傳回
(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) => void參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<void>
傳回
(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) => void參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>
傳回
(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) => void參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>
傳回
(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) => void參數
- 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) => 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) => void參數
- 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) => 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) => void參數
- 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) => 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) => void參數
- 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) => 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) => void參數
- 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) => void
convertProcessSignalToExitCode(Signals)
此 util.convertProcessSignalToExitCode() 方法將號誌名稱轉換為對應的 POSIX 出口代碼。 依照 POSIX 標準，終止於訊號的程序的出口代碼計算為 128 + signal number。
若 signal 不是有效訊號名稱，則會拋出錯誤。 請參閱 signal(7) 有效訊號清單。
import { convertProcessSignalToExitCode } from 'node:util';
console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)
這在與程序合作，根據終止程序的訊號來判定退出代碼時特別有用。
function convertProcessSignalToExitCode(signal: Signals): number參數
- signal
-
Signals
訊號名稱（例如 'SIGTERM'）
傳回
number
出口代碼對應於 signal
createRandomString()
產生隨機 5 到 6 個字元字串。
function createRandomString(): string傳回
string
debuglog(string, (fn: DebugLoggerFunction) => void)
方法util.debuglog()可用來建立函式，根據環境變數的存在，有條件地寫入偵stderr錯訊息NODE_DEBUG。 如果 section 名稱出現在該環境變數的值內，則傳回的函式會運作類似 console.error()。 如果沒有，則傳回的函式是 no-op。
import { debuglog } from 'node:util';
const log = debuglog('foo');
log('hello from foo [%d]', 123);
如果此程式在環境中以 NODE_DEBUG=foo 執行，則會輸出類似下列內容：
FOO 3245: hello from foo [123]
其中 3245 是進程標識碼。如果未使用該環境變數集執行，則不會列印任何專案。
section 也支援通配符：
import { debuglog } from 'node:util';
const log = debuglog('foo-bar');
log('hi there, it\'s foo-bar [%d]', 2333);
如果在環境中以 NODE_DEBUG=foo* 執行，則會輸出類似下列內容：
FOO-BAR 3257: hi there, it's foo-bar [2333]
環境變數中section可以指定多個逗號分隔NODE_DEBUG名稱：NODE_DEBUG=fs,net,tls。
選擇性 callback 自變數可用來將記錄函式取代為沒有任何初始化或不必要的包裝的不同函式。
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): DebugLogger參數
- section
-
string
字串，識別正在建立 debuglog 函式的應用程式部分。
- callback
-
(fn: DebugLoggerFunction) => void
第一次呼叫記錄函式時叫用的回呼，其函式自變數為更優化的記錄函式。
傳回
記錄函式
deprecate<T>(T, string, string, DeprecateOptions)
util.deprecate() 方法會包裝 fn（可能是函式或類別），使其標示為已被取代。
import { deprecate } from 'node:util';
export const obsoleteFunction = deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
呼叫時，util.deprecate() 會傳回會使用 DeprecationWarning 事件發出 'warning' 的函式。 第一次呼叫傳回的函式時，將會發出警告並列印到 stderr。 發出警告之後，會呼叫包裝函式而不發出警告。
如果在多個呼叫 code中提供相同的選擇性 util.deprecate()，則只會針對該 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
如果使用 --no-deprecation 或 --no-warnings 命令行旗標，或 process.noDeprecation 屬性設定為 true之前 為第一個取代警告，則 util.deprecate() 方法不會執行任何動作。
如果已設定 --trace-deprecation 或 --trace-warnings 命令行旗標，或 process.traceDeprecation 屬性設定為 true，則會在第一次呼叫已被取代的函式時列印警告和堆棧追蹤 stderr。
如果已設定命令行旗標 --throw-deprecation，或將 process.throwDeprecation 屬性設定為 true，則會在呼叫已被取代的函式時擲回例外狀況。
--throw-deprecation 命令行旗標和 process.throwDeprecation 屬性的優先順序高於 --trace-deprecation 和 process.traceDeprecation。
function deprecate<T>(fn: T, msg: string, code?: string, options?: DeprecateOptions): T參數
- fn
-
T
即將淘汰的函式。
- msg
-
string
叫用已淘汰函式時所顯示的警告訊息。
- code
-
string
取代程序代碼。 如需程式代碼清單，請參閱 list of deprecated APIs。
- options
- DeprecateOptions
傳回
T
已取代的函式已包裝以發出警告。
diff(string | (readonly string[]), string | (readonly string[]))
util.diff() 比較兩個字串或陣列值，並傳回差異項目的陣列。
它會使用 Myers 差異演算法來計算最小差異，這是判斷提示錯誤訊息在內部使用的相同演算法。
如果值相等，則會傳回空陣列。
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[]參數
- actual
-
string | (readonly string[])
要比較的第一個值
- expected
-
string | (readonly string[])
要比較的第二個值
傳回
差異項目的陣列。 每個專案都是具有兩個元素的陣列：
- 索引 0：作業程式代碼：
number-1用於刪除，0針對 no-op/未變更，1用於插入 - 索引 1：
string與作業相關聯的值
find<T>((x: T) => boolean, T[])
尋找陣列中符合指定述詞的第一個值。
function find<T>(predicate: (x: T) => boolean, xs: T[]): T參數
- predicate
-
(x: T) => boolean
- xs
-
T[]
傳回
T
findIndex<T>((x: T) => boolean, T[])
尋找陣列中符合指定述詞之第一個值的索引。
function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): number參數
- predicate
-
(x: T) => boolean
- xs
-
T[]
傳回
number
format(any, any[])
util.format() 方法會使用第一個自變數作為 printf格式字串傳回格式化字串，此字串可以包含零個或多個格式規範。 每個規範都會以對應自變數的轉換值取代。 支持的規範如下：
如果規範沒有對應的自變數，則不會取代：
util.format('%s:%s', 'foo');
// Returns: 'foo:%s'
如果格式字串的類型不是 util.inspect()，則不是格式字串的一部分的值會使用 string 格式化。
如果傳遞至 util.format() 方法的自變數比規範數目還多，則額外的自變數會串連至傳回的字串，並以空格分隔：
util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'
如果第一個自變數不包含有效的格式規範，util.format() 會傳回字串，該字串是以空格分隔的所有自變數串連：
util.format(1, 2, 3);
// Returns: '1 2 3'
如果只有一個自變數傳遞至 util.format()，則會傳回，因為它沒有任何格式設定：
util.format('%% %s');
// Returns: '%% %s'
util.format() 是同步方法，其用途為偵錯工具。
某些輸入值可能會有顯著的效能額外負荷，而可能會封鎖事件迴圈。 請小心使用此函式，且絕不會在經常性程式代碼路徑中使用。
function format(format?: any, param: any[]): string參數
- format
-
any
printf格式字串。
- param
-
any[]
傳回
string
formatWithOptions(InspectOptions, any, any[])
此函式與
util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.
function formatWithOptions(inspectOptions: InspectOptions, format?: any, param: any[]): string參數
- inspectOptions
- InspectOptions
- format
-
any
- param
-
any[]
傳回
string
generateUUID()
產生 20 個字元的 uuid。
function generateUUID(): string傳回
string
getCallSites(number, GetCallSitesOptions)
傳回呼叫月台對象的陣列，其中包含呼叫端函式的堆疊。
與存取 error.stack不同，從此 API 回傳的結果不會受到干擾 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();
藉由將 選項設定為 sourceMaptrue，即可重新建構原始位置。
如果來源對應無法使用，原始位置會與目前位置相同。
當該 --enable-source-maps 標誌啟用時， sourceMap 預設為 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[]參數
- frameCount
-
number
要擷取為呼叫月台對象的畫面數。
預設值：10。 允許的範圍介於 1 到 200 之間。
- options
- GetCallSitesOptions
傳回
呼叫月台物件的陣列
getCallSites(GetCallSitesOptions)
function getCallSites(options: GetCallSitesOptions): CallSiteObject[]參數
- options
- GetCallSitesOptions
傳回
getRandomValue()
傳回隨機數
function getRandomValue(): number傳回
number
getSystemErrorMap()
傳回可從 Node.js API 取得之所有系統錯誤碼的對應。
錯誤碼與錯誤名稱之間的對應與平台相關。
如需常見錯誤的名稱，請參閱 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]>傳回
Map<number, [string, string]>
getSystemErrorMessage(number)
傳回來自 Node.js API 之數值錯誤碼的字串訊息。 錯誤碼與字串訊息之間的對應與平台相關。
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): string參數
- err
-
number
傳回
string
getSystemErrorName(number)
傳回來自 Node.js API 之數值錯誤碼的字串名稱。
錯誤碼與錯誤名稱之間的對應與平台相關。
如需常見錯誤的名稱，請參閱 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): string參數
- err
-
number
傳回
string
getTimeDiffInMilliseconds(Date, Date)
以毫秒為單位傳回兩個日期之間的時間間隔
function getTimeDiffInMilliseconds(start: Date, end: Date): number參數
- start
-
Date
- end
-
Date
傳回
number
inherits(unknown, unknown)
不建議使用 util.inherits()。 請使用ES6 class 和 extends 關鍵詞來取得語言層級繼承支援。 另請注意，這兩種樣式 語意不相容。
將原型方法從一個 建構函式 繼承到另一個建構函式。
constructor 的原型將會設定為從 superConstructor建立的新物件。
這主要會在之上 Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)新增一些輸入驗證。
為了方便起見，superConstructor 可透過 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!"
使用 class 和 extends的 ES6 範例：
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)參數
- constructor
-
unknown
- superConstructor
-
unknown
inspect(any, InspectOptions)
function inspect(object: any, options?: InspectOptions): string參數
- object
-
any
- options
- InspectOptions
傳回
string
isArray(unknown)
警告
此 API 現已淘汰。
Since v4.0.0 - Use isArray instead.
Array.isArray() 的別名。
如果指定的 true 是 object，則傳回 Array。 否則，返回 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[]參數
- object
-
unknown
傳回
object is unknown[]
isCreate(string)
檢查內嵌類型是否為建立
function isCreate(embedType: string): boolean參數
- embedType
-
string
傳回
boolean
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)
如果 true 與 val1之間有深厚的嚴格相等，則傳回 val2。
否則，返回 false。
如需深度嚴格相等的詳細資訊，請參閱 assert.deepStrictEqual()。
function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): boolean參數
- val1
-
unknown
- val2
-
unknown
- options
- IsDeepStrictEqualOptions
傳回
boolean
isRDLEmbed(string)
檢查內嵌 URL 是否為 RDL 報表。
function isRDLEmbed(embedUrl: string): boolean參數
- embedUrl
-
string
傳回
boolean
isSavedInternal(HttpPostMessage, string, Window)
檢查報表是否已儲存。
function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>參數
- hpm
-
HttpPostMessage
- uid
-
string
- contentWindow
- Window
傳回
Promise<boolean>
parseArgs<T>(T)
提供比直接與 process.argv 互動更上層命令行自變數剖析的 API。 取得預期自變數的規格，並傳回具有剖析選項和位置的結構化物件。
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>參數
- config
-
T
用來提供剖析的自變數，以及設定剖析器。
config 支援下列屬性：
傳回
ParsedResults<T>
剖析的命令列自變數：
parseEnv(string)
穩定性：1.1 - 使用中開發 提供範例 .env 檔案：
import { parseEnv } from 'node:util';
parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
function parseEnv(content: string): Dict<string>參數
- content
-
string
.env 檔案的原始內容。
傳回
Dict<string>
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>參數
- fn
-
(callback: (err: any, result: TResult) => void) => void
傳回
() => Promise<TResult>
promisify((callback: (err?: any) => void) => void)
function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>參數
- fn
-
(callback: (err?: any) => void) => void
傳回
() => 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>參數
- fn
-
(arg1: T1, callback: (err: any, result: TResult) => void) => void
傳回
(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>參數
- fn
-
(arg1: T1, callback: (err?: any) => void) => void
傳回
(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>參數
- fn
-
(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void
傳回
(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>參數
- fn
-
(arg1: T1, arg2: T2, callback: (err?: any) => void) => void
傳回
(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>參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void
傳回
(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>參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void
傳回
(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>參數
- 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>
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>參數
- fn
-
(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void
傳回
(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>參數
- 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>
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>參數
- 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>
promisify(Function)
function promisify(fn: Function): Function參數
- fn
-
Function
傳回
Function
raiseCustomEvent(HTMLElement, string, any)
使用指定 HTML 元素上的事件數據引發自訂事件。
function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)參數
- element
-
HTMLElement
- eventName
-
string
- eventData
-
any
remove<T>((x: T) => boolean, T[])
function remove<T>(predicate: (x: T) => boolean, xs: T[])參數
- predicate
-
(x: T) => boolean
- xs
-
T[]
setTraceSigInt(boolean)
啟用或停用在 上 SIGINT列印堆疊追蹤。 API 僅在主執行緒上可用。
function setTraceSigInt(enable: boolean)參數
- enable
-
boolean
stripVTControlCharacters(string)
傳回已移除任何 ANSI 逸出碼的 str。
console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
function stripVTControlCharacters(str: string): string參數
- str
-
string
傳回
string
styleText(InspectColor | (readonly InspectColor[]) | Object, string, StyleTextOptions)
此函式會傳回格式化文字， format 以考慮在終端機中列印所傳遞的 。 它知道終端機的功能，並透過和 NO_COLORNODE_DISABLE_COLORS 環境變數根據組態集FORCE_COLOR運作。
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 也提供文字格式，例如 italic和 underline，而且您可以合併兩者：
console.log(
util.styleText(['underline', 'italic'], 'My italic underlined message'),
);
傳遞格式陣列時，套用的格式順序會由左至右，因此下列樣式可能會覆寫前一個格式。
console.log(
util.styleText(['red', 'green'], 'text'), // green
);
特殊格式值 none 不會將其他樣式套用至文字。
除了預設的色彩名稱外， util.styleText() 還支援使用 ANSI TrueColor（24 位元）跳脫序列的十六進位色彩字串。 十六進位顏色可指定為三位數（#RGB）或六位數（#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'));
您可以在 修飾詞中找到格式的完整清單，。
function styleText(format: InspectColor | (readonly InspectColor[]) | Object, text: string, options?: StyleTextOptions): string參數
- format
-
InspectColor | (readonly InspectColor[]) | Object
一個文字格式或定義在 util.inspect.colors中的文字格式陣列，或是 形式中的十六進位顏色#RGB#RRGGBB。
- text
-
string
要格式化的文字。
- options
- StyleTextOptions
傳回
string
toUSVString(string)
以 Unicode “replacement character” U+FFFD 取代任何 Surrogate 字碼點之後，傳回 string。
function toUSVString(string: string): string參數
- string
-
string
傳回
string
transferableAbortController()
建立並傳回 AbortController 實例，其 AbortSignal 標示為可傳輸，且可與 structuredClone() 或 postMessage()搭配使用。
function transferableAbortController(): AbortController傳回
AbortController
可轉移的 AbortController
transferableAbortSignal(AbortSignal)
將指定的 AbortSignal 標示為可轉移，以便與structuredClone() 和 postMessage()搭配使用。
const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);
function transferableAbortSignal(signal: AbortSignal): AbortSignal參數
- signal
-
AbortSignal
中止
傳回
AbortSignal
相同的中止
變數詳細資料
APINotSupportedForRDLError
APINotSupportedForRDLError: "This API is currently not supported for RDL reports"類型
"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"類型
"Embed URL is invalid for this scenario. Please use Power BI REST APIs to get the valid URL"
TextDecoder
TextDecoder: (label?: string, options?: TextDecoderOptions) => TextDecoder類型
(label?: string, options?: TextDecoderOptions) => TextDecoder
TextEncoder
TextEncoder: () => TextEncoder類型
() => TextEncoder
Document
Document: () => Document類型
() => Document
HTMLIFrameElement
HTMLIFrameElement: () => HTMLIFrameElement類型
() => HTMLIFrameElement
Window
Window: () => Window類型
() => Window
config
config: { type: string, version: string }類型
{ type: string, version: string }
invalidEmbedUrlErrorMessage
invalidEmbedUrlErrorMessage: string類型
string
hpmFactory
hpmFactory: IHpmFactory類型
IHpmFactory
routerFactory
routerFactory: IRouterFactory類型
IRouterFactory
wpmpFactory
wpmpFactory: IWpmpFactory類型
IWpmpFactory