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 |
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 视觉对象嵌入组件 |
| VisualDescriptor |
页面中的 Power BI 视觉对象 |
接口
类型别名
枚举
函数
| is |
如果值是内置 另请参阅 |
| is |
如果值是 |
| is |
如果值是内置 |
| is |
如果值是其中一个 |
| is |
如果该值是异步函数 |
| is |
如果值是 |
| is |
如果值是 BigInt 对象，则返回 |
| 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 |
如果值是内置 |
| 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 |
返回包含调用方函数堆栈的调用站点对象的数组。 与访问 a 通过将选项 |
| 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“替换字符”U+FFFD 替换任何代理项码位（或者等效于任何未配对的代理项代码单元）后返回 |
| 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)
如果该值是异步函数
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
function isAsyncFunction(object: unknown): boolean参数
- object
-
unknown
返回
boolean
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)
如果值是任何装箱基元对象（例如由 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) => ... 回调作为最后一个参数，并返回返回承诺的版本。
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 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();
如果存在属性 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
对应于
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 是进程 ID。如果未使用该环境变量集运行，则不会打印任何内容。
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删除、0no-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[])
此函数与 格式相同，不同之处在于它采用 inspectOptions 参数，该参数指定传递给 检查的选项。
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)
返回包含调用方函数堆栈的调用站点对象的数组。
与访问 a 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();
通过将选项 sourceMap 设置为 true，可以重新构造原始位置。
如果源映射不可用，则原始位置将与当前位置相同。
--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_COLORSFORCE_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 位）转义序列的十六进制颜色字符串。 可以使用 3 位（#RGB）或 6 位（#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“替换字符”U+FFFD 替换任何代理项码位（或者等效于任何未配对的代理项代码单元）后返回 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
The 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