- assert - 断言
- Buffer - 缓冲器
- child_process - 子进程
- cluster - 集群
- console - 控制台
- crypto - 加密
- dgram - 数据报
- dns - 域名服务器
- Error - 异常
- events - 事件
- fs - 文件系统
- global - 全局变量
- http - HTTP
- https - HTTPS
- module - 模块
- net - 网络
- os - 操作系统
- path - 路径
- process - 进程
- querystring - 查询字符串
- readline - 逐行读取
- repl - 交互式解释器
- stream - 流
- string_decoder - 字符串解码器
- timer - 定时器
- tls - 安全传输层
- tty - 终端
- url - 网址
- util - 实用工具
- v8 - V8引擎
- vm - 虚拟机
- zlib - 压缩
Node.js v10.8.0 文档
目录
-
- util.callbackify(original)
- util.debuglog(section)
- util.deprecate(fn, msg[, code])
- util.format(format[, ...args])
- util.formatWithOptions(inspectOptions, format[, ...args])
- util.getSystemErrorName(err)
- util.inherits(constructor, superConstructor)
- util.isDeepStrictEqual(val1, val2)
-
- util.types.isAnyArrayBuffer(value)
- util.types.isArgumentsObject(value)
- util.types.isArrayBuffer(value)
- util.types.isAsyncFunction(value)
- util.types.isBigInt64Array(value)
- util.types.isBigUint64Array(value)
- util.types.isBooleanObject(value)
- util.types.isDataView(value)
- util.types.isDate(value)
- util.types.isExternal(value)
- util.types.isFloat32Array(value)
- util.types.isFloat64Array(value)
- util.types.isGeneratorFunction(value)
- util.types.isGeneratorObject(value)
- util.types.isInt8Array(value)
- util.types.isInt16Array(value)
- util.types.isInt32Array(value)
- util.types.isMap(value)
- util.types.isMapIterator(value)
- util.types.isModuleNamespaceObject(value)
- util.types.isNativeError(value)
- util.types.isNumberObject(value)
- util.types.isPromise(value)
- util.types.isProxy(value)
- util.types.isRegExp(value)
- util.types.isSet(value)
- util.types.isSetIterator(value)
- util.types.isSharedArrayBuffer(value)
- util.types.isStringObject(value)
- util.types.isSymbolObject(value)
- util.types.isTypedArray(value)
- util.types.isUint8Array(value)
- util.types.isUint8ClampedArray(value)
- util.types.isUint16Array(value)
- util.types.isUint32Array(value)
- util.types.isWeakMap(value)
- util.types.isWeakSet(value)
- util.types.isWebAssemblyCompiledModule(value)
-
- util._extend(target, source)
- util.debug(string)
- util.error([...strings])
- util.isArray(object)
- util.isBoolean(object)
- util.isBuffer(object)
- util.isDate(object)
- util.isError(object)
- util.isFunction(object)
- util.isNull(object)
- util.isNullOrUndefined(object)
- util.isNumber(object)
- util.isObject(object)
- util.isPrimitive(object)
- util.isRegExp(object)
- util.isString(object)
- util.isSymbol(object)
- util.isUndefined(object)
- util.log(string)
- util.print([...strings])
- util.puts([...strings])
util (实用工具)#
util
模块主要用于支持 Node.js 内部 API 的需求。
大部分实用工具也可用于应用程序与模块开发者。
它可以通过以下方式使用:
const util = require('util');
util.callbackify(original)#
original
<Function>async
异步函数- Returns: <Function> 传统回调函数
将 async
异步函数(或者一个返回值为 Promise 的函数)转换成遵循异常优先的回调风格的函数,例如将 (err, value) => ...
回调作为最后一个参数。在回调函数中, 第一个参数 err 为 Promise rejected 的原因 (如果 Promise 状态为 resolved , err为 null
),第二个参数则是 Promise 状态为 resolved 时的返回值.
例如 :
const util = require('util');
async function fn() {
return 'hello world';
}
const callbackFunction = util.callbackify(fn);
callbackFunction((err, ret) => {
if (err) throw err;
console.log(ret);
});
将会打印出:
hello world
注意:
-
回调函数是异步执行的, 并且有异常堆栈错误追踪. 如果回调函数抛出一个异常, 进程会触发一个
'uncaughtException'
异常, 如果没有被捕获, 进程将会退出. -
null
在回调函数中作为一个参数有其特殊的意义, 如果回调函数的首个参数为 Promise rejected 的原因且带有返回值, 且值可以转换成布尔值false
, 这个值会被封装在Error
对象里, 可以通过属性reason
获取.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 && err.hasOwnProperty('reason') && err.reason === null; // true });
util.debuglog(section)#
section
<string> 一个字符串,指定要为应用的哪些部分创建debuglog
函数。debuglog
函数要为哪些应用创建。- 返回: <Function> 日志函数
util.debuglog()
方法用于创建一个函数,基于 NODE_DEBUG
环境变量的存在与否有条件地写入调试信息到 stderr
。
如果 section
名称在环境变量的值中,则返回的函数类似于 console.error()
。
否则,返回的函数是一个空操作。
例子:
const util = require('util');
const debuglog = util.debuglog('foo');
debuglog('hello from foo [%d]', 123);
如果程序在环境中运行时带上 NODE_DEBUG=foo
,则输出类似如下:
FOO 3245: hello from foo [123]
其中 3245
是进程 id。
如果运行时没带上环境变量集合,则不会打印任何东西。
NODE_DEBUG
环境变量中可指定多个由逗号分隔的 section
名称。
例如:NODE_DEBUG=fs,net,tls
。
util.deprecate(fn, msg[, code])#
fn
<Function> The function that is being deprecated.msg
<string> A warning message to display when the deprecated function is invoked.code
<string> A deprecation code. See the list of deprecated APIs for a list of codes.- Returns: <Function> The deprecated function wrapped to emit a warning.
The util.deprecate()
method wraps fn
(which may be a function or class) in
such a way that it is marked as deprecated.
const util = require('util');
exports.obsoleteFunction = util.deprecate(() => {
// Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');
When called, util.deprecate()
will return a function that will emit a
DeprecationWarning
using the 'warning'
event. The warning will
be emitted and printed to stderr
the first time the returned function is
called. After the warning is emitted, the wrapped function is called without
emitting a warning.
If the same optional code
is supplied in multiple calls to util.deprecate()
,
the warning will be emitted only once for that code
.
const util = require('util');
const fn1 = util.deprecate(someFunction, someMessage, 'DEP0001');
const fn2 = util.deprecate(someOtherFunction, someOtherMessage, 'DEP0001');
fn1(); // emits a deprecation warning with code DEP0001
fn2(); // does not emit a deprecation warning because it has the same code
If either the --no-deprecation
or --no-warnings
command line flags are
used, or if the process.noDeprecation
property is set to true
prior to
the first deprecation warning, the util.deprecate()
method does nothing.
If the --trace-deprecation
or --trace-warnings
command line flags are set,
or the process.traceDeprecation
property is set to true
, a warning and a
stack trace are printed to stderr
the first time the deprecated function is
called.
If the --throw-deprecation
command line flag is set, or the
process.throwDeprecation
property is set to true
, then an exception will be
thrown when the deprecated function is called.
The --throw-deprecation
command line flag and process.throwDeprecation
property take precedence over --trace-deprecation
and
process.traceDeprecation
.
util.format(format[, ...args])#
format
<string> 一个类似printf
的格式字符串。
util.format()
方法返回一个格式化后的字符串,使用第一个参数作为一个类似 printf
的格式。
第一个参数是一个字符串,包含零个或多个占位符。 每个占位符会被对应参数转换后的值所替换。 支持的占位符有:
%s
- 字符串。%d
- 数值(整数或浮点数)。%i
- Integer.%f
- Floating point value.%j
- JSON。如果参数包含循环引用,则用字符串'[Circular]'
替换。%o
- Object. A string representation of an object with generic JavaScript object formatting. Similar toutil.inspect()
with options{ showHidden: true, depth: 4, showProxy: true }
. This will show the full object including non-enumerable symbols and properties.%O
- Object. A string representation of an object with generic JavaScript object formatting. Similar toutil.inspect()
without options. This will show the full object not including non-enumerable symbols and properties.%%
- 单个百分号('%'
)。不消耗参数。
如果占位符没有对应的参数,则占位符不被替换。
util.format('%s:%s', 'foo');
// 返回: 'foo:%s'
如果传入 util.format()
方法的参数比占位符的数量多,则多出的参数会被强制转换为字符串,然后拼接到返回的字符串,参数之间用一个空格分隔。
Excessive arguments whose
typeof
is 'object'
or 'symbol'
(except null
) will be transformed by
util.inspect()
.
util.format('%s:%s', 'foo', 'bar', 'baz'); // 'foo:bar baz'
如果第一个参数不是一个字符串,则 util.format()
返回一个所有参数用空格分隔并连在一起的字符串。
每个参数都使用 util.inspect()
转换为一个字符串。
util.format(1, 2, 3); // '1 2 3'
If only one argument is passed to util.format()
, it is returned as it is
without any formatting.
util.format('%% %s'); // '%% %s'
util.formatWithOptions(inspectOptions, format[, ...args])#
This function is identical to util.format()
, except in that it takes
an inspectOptions
argument which specifies options that are passed along to
util.inspect()
.
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.
util.getSystemErrorName(err)#
Returns the string name for a numeric error code that comes from a Node.js API. The mapping between error codes and error names is platform-dependent. See Common System Errors for the names of common errors.
fs.access('file/that/does/not/exist', (err) => {
const name = util.getSystemErrorName(err.errno);
console.error(name); // ENOENT
});
util.inherits(constructor, superConstructor)#
注意,不建议使用 util.inherits()
。
请使用 ES6 的 class
和 extends
关键词获得语言层面的继承支持。
注意,这两种方式是语义上不兼容的。
constructor
<Function>superConstructor
<Function>
从一个构造函数中继承原型方法到另一个。
constructor
的原型会被设置到一个从 superConstructor
创建的新对象上。
superConstructor
可通过 constructor.super_
属性访问。
const util = require('util');
const EventEmitter = require('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(`接收的数据:"${data}"`);
});
stream.write('运作良好!'); // 接收的数据:"运作良好!"
例子:使用 ES6 的 class
和 extends
:
const EventEmitter = require('events');
class MyStream extends EventEmitter {
write(data) {
this.emit('data', data);
}
}
const stream = new MyStream();
stream.on('data', (data) => {
console.log(`接收的数据:"${data}"`);
});
stream.write('使用 ES6');
util.inspect(object[, options])#
object
<any> 任何 JavaScript 原始值或对象。-
options
<Object>showHidden
<boolean> 如果为true
,则object
的不可枚举的符号与属性也会被包括在格式化后的结果中。 默认为false
。depth
<number> 指定格式化object
时递归的次数。 这对查看大型复杂对象很有用。 默认为2
。 若要无限地递归则传入null
。colors
<boolean> 如果为true
,则输出样式使用 ANSI 颜色代码。 默认为false
。 颜色可自定义,详见自定义util.inspect
颜色。customInspect
<boolean> 如果为false
,则object
上自定义的inspect(depth, opts)
函数不会被调用。 默认为true
。showProxy
<boolean> 如果为true
,则Proxy
对象的对象和函数会展示它们的target
和handler
对象。 默认为false
。maxArrayLength
<number> 指定格式化时数组和TypedArray
元素能包含的最大数量。 默认为100
。 设为null
则显式全部数组元素。 设为0
或负数则不显式数组元素。breakLength
<number> 一个对象的键被拆分成多行的长度。 设为Infinity
则格式化一个对象为单行。 默认为60
。
util.inspect()
方法返回 object
的字符串表示,主要用于调试。
附加的 options
可用于改变格式化字符串的某些方面。
例子,查看 util
对象的所有属性:
const util = require('util');
console.log(util.inspect(util, { showHidden: true, depth: null }));
当调用到达递归查看的当前 depth
时,值支持自定义的 inspect(depth, opts)
函数,传入 util.inspect()
的选项对象也一样。
自定义 util.inspect
颜色#
可以通过 util.inspect.styles
和 util.inspect.colors
属性全局地自定义 util.inspect
的颜色输出(如果已启用)。
util.inspect.styles
是一个映射,关联一个样式名到一个 util.inspect.colors
颜色。
默认的样式与关联的颜色有:
number
-yellow
boolean
-yellow
string
-green
date
-magenta
regexp
-red
null
-bold
undefined
-grey
special
-cyan
(暂时只用于函数)name
- (无样式)
预定义的颜色代码有:white
、grey
、black
、blue
、cyan
、green
、magenta
、red
和 yellow
。
还有 bold
、italic
、underline
和 inverse
代码。
颜色样式使用 ANSI 控制码,可能不是所有终端都支持。
自定义对象的查看函数#
对象可以定义自己的 [util.inspect.custom](depth, opts)
(或已废弃的 inspect(depth, opts)
) 函数,util.inspect()
会调用并使用查看对象时的结果:
const util = require('util');
class Box {
constructor(value) {
this.value = value;
}
[util.inspect.custom](depth, options) {
if (depth < 0) {
return options.stylize('[Box]', 'special');
}
const newOptions = Object.assign({}, options, {
depth: options.depth === null ? null : options.depth - 1
});
// 五个空格的填充,因为那是 "Box< " 的大小。
const padding = ' '.repeat(5);
const inner = util.inspect(this.value, newOptions)
.replace(/\n/g, `\n${padding}`);
return `${options.stylize('Box', 'special')}< ${inner} >`;
}
}
const box = new Box(true);
util.inspect(box);
// 返回: "Box< true >"
自定义的 [util.inspect.custom](depth, opts)
函数通常返回一个字符串,但也可以返回一个任何类型的值,它会相应地被 util.inspect()
格式化。
const util = require('util');
const obj = { foo: '这个不会出现在 inspect() 的输出中' };
obj[util.inspect.custom] = (depth) => {
return { bar: 'baz' };
};
util.inspect(obj);
// 返回: "{ bar: 'baz' }"
util.inspect.custom#
一个符号,可被用于声明自定义的查看函数,详见自定义对象的查看函数。
util.inspect.defaultOptions#
defaultOptions
值允许对被 util.inspect
使用的默认选项进行自定义。
这对 console.log
或 util.format
等显式调用 util.inspect
的函数很有用。
它需被设为一个对象,包含一个或多个有效的 util.inspect()
选项。
也支持直接设置选项的属性。
const util = require('util');
const arr = Array(101).fill(0);
console.log(arr); // 打印截断的数组
util.inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // 打印完整的数组
util.isDeepStrictEqual(val1, val2)#
Returns true
if there is deep strict equality between val1
and val2
.
Otherwise, returns false
.
See assert.deepStrictEqual()
for more information about deep strict
equality.
util.promisify(original)#
original
<Function>- Returns: <Function>
让一个遵循异常优先的回调风格的函数, 即 (err, value) => ...
回调函数是最后一个参数, 返回一个返回值是一个 promise 版本的函数。
例如:
const util = require('util');
const fs = require('fs');
const stat = util.promisify(fs.stat);
stat('.').then((stats) => {
// Do something with `stats`
}).catch((error) => {
// Handle the error.
});
或者,使用async function
获得等效的效果:
const util = require('util');
const fs = require('fs');
const stat = util.promisify(fs.stat);
async function callStat() {
const stats = await stat('.');
console.log(`This directory is owned by ${stats.uid}`);
}
如果原本就有 original[util.promisify.custom]
属性, promisify
会返回它的值, 查阅 Custom promisified functions.
promisify()
会在所有情况下假定 original
是一个最后的参数是回调函数的函数,如果它不是,那么返回的函数的返回值为 undefined。
Custom promisified functions#
Using the util.promisify.custom
symbol one can override the return value of
const util = require('util');
function doSomething(foo, callback) {
// ...
}
doSomething[util.promisify.custom] = (foo) => {
return getPromiseSomehow();
};
const promisified = util.promisify(doSomething);
console.log(promisified === doSomething[util.promisify.custom]);
// prints 'true'
This can be useful for cases where the original function does not follow the standard format of taking an error-first callback as the last argument.
For example, with a function that takes in
(foo, onSuccessCallback, onErrorCallback)
:
doSomething[util.promisify.custom] = (foo) => {
return new Promise((resolve, reject) => {
doSomething(foo, resolve, reject);
});
};
If promisify.custom
is defined but is not a function, promisify()
will
throw an error.
util.promisify.custom#
A <symbol> that can be used to declare custom promisified variants of functions, see Custom promisified functions.
Class: util.TextDecoder#
An implementation of the WHATWG Encoding Standard TextDecoder
API.
const decoder = new TextDecoder('shift_jis');
let string = '';
let buffer;
while (buffer = getNextChunkSomehow()) {
string += decoder.decode(buffer, { stream: true });
}
string += decoder.decode(); // end-of-stream
WHATWG Supported Encodings#
Per the WHATWG Encoding Standard, the encodings supported by the
TextDecoder
API are outlined in the tables below. For each encoding,
one or more aliases may be used.
Different Node.js build configurations support different sets of encodings. While a very basic set of encodings is supported even on Node.js builds without ICU enabled, support for some encodings is provided only when Node.js is built with ICU and using the full ICU data (see Internationalization).
Encodings Supported Without ICU#
Encoding | Aliases |
---|---|
'utf-8' | 'unicode-1-1-utf-8' , 'utf8' |
'utf-16le' | 'utf-16' |
Encodings Supported by Default (With ICU)#
Encoding | Aliases |
---|---|
'utf-8' | 'unicode-1-1-utf-8' , 'utf8' |
'utf-16le' | 'utf-16' |
'utf-16be' |
Encodings Requiring Full ICU Data#
Encoding | Aliases |
---|---|
'ibm866' | '866' , 'cp866' , 'csibm866' |
'iso-8859-2' | 'csisolatin2' , 'iso-ir-101' , 'iso8859-2' , 'iso88592' , 'iso_8859-2' , 'iso_8859-2:1987' , 'l2' , 'latin2' |
'iso-8859-3' | 'csisolatin3' , 'iso-ir-109' , 'iso8859-3' , 'iso88593' , 'iso_8859-3' , 'iso_8859-3:1988' , 'l3' , 'latin3' |
'iso-8859-4' | 'csisolatin4' , 'iso-ir-110' , 'iso8859-4' , 'iso88594' , 'iso_8859-4' , 'iso_8859-4:1988' , 'l4' , 'latin4' |
'iso-8859-5' | 'csisolatincyrillic' , 'cyrillic' , 'iso-ir-144' , 'iso8859-5' , 'iso88595' , 'iso_8859-5' , 'iso_8859-5:1988' |
'iso-8859-6' | 'arabic' , 'asmo-708' , 'csiso88596e' , 'csiso88596i' , 'csisolatinarabic' , 'ecma-114' , 'iso-8859-6-e' , 'iso-8859-6-i' , 'iso-ir-127' , 'iso8859-6' , 'iso88596' , 'iso_8859-6' , 'iso_8859-6:1987' |
'iso-8859-7' | 'csisolatingreek' , 'ecma-118' , 'elot_928' , 'greek' , 'greek8' , 'iso-ir-126' , 'iso8859-7' , 'iso88597' , 'iso_8859-7' , 'iso_8859-7:1987' , 'sun_eu_greek' |
'iso-8859-8' | 'csiso88598e' , 'csisolatinhebrew' , 'hebrew' , 'iso-8859-8-e' , 'iso-ir-138' , 'iso8859-8' , 'iso88598' , 'iso_8859-8' , 'iso_8859-8:1988' , 'visual' |
'iso-8859-8-i' | 'csiso88598i' , 'logical' |
'iso-8859-10' | 'csisolatin6' , 'iso-ir-157' , 'iso8859-10' , 'iso885910' , 'l6' , 'latin6' |
'iso-8859-13' | 'iso8859-13' , 'iso885913' |
'iso-8859-14' | 'iso8859-14' , 'iso885914' |
'iso-8859-15' | 'csisolatin9' , 'iso8859-15' , 'iso885915' , 'iso_8859-15' , 'l9' |
'koi8-r' | 'cskoi8r' , 'koi' , 'koi8' , 'koi8_r' |
'koi8-u' | 'koi8-ru' |
'macintosh' | 'csmacintosh' , 'mac' , 'x-mac-roman' |
'windows-874' | 'dos-874' , 'iso-8859-11' , 'iso8859-11' , 'iso885911' , 'tis-620' |
'windows-1250' | 'cp1250' , 'x-cp1250' |
'windows-1251' | 'cp1251' , 'x-cp1251' |
'windows-1252' | 'ansi_x3.4-1968' , 'ascii' , 'cp1252' , 'cp819' , 'csisolatin1' , 'ibm819' , 'iso-8859-1' , 'iso-ir-100' , 'iso8859-1' , 'iso88591' , 'iso_8859-1' , 'iso_8859-1:1987' , 'l1' , 'latin1' , 'us-ascii' , 'x-cp1252' |
'windows-1253' | 'cp1253' , 'x-cp1253' |
'windows-1254' | 'cp1254' , 'csisolatin5' , 'iso-8859-9' , 'iso-ir-148' , 'iso8859-9' , 'iso88599' , 'iso_8859-9' , 'iso_8859-9:1989' , 'l5' , 'latin5' , 'x-cp1254' |
'windows-1255' | 'cp1255' , 'x-cp1255' |
'windows-1256' | 'cp1256' , 'x-cp1256' |
'windows-1257' | 'cp1257' , 'x-cp1257' |
'windows-1258' | 'cp1258' , 'x-cp1258' |
'x-mac-cyrillic' | 'x-mac-ukrainian' |
'gbk' | 'chinese' , 'csgb2312' , 'csiso58gb231280' , 'gb2312' , 'gb_2312' , 'gb_2312-80' , 'iso-ir-58' , 'x-gbk' |
'gb18030' | |
'big5' | 'big5-hkscs' , 'cn-big5' , 'csbig5' , 'x-x-big5' |
'euc-jp' | 'cseucpkdfmtjapanese' , 'x-euc-jp' |
'iso-2022-jp' | 'csiso2022jp' |
'shift_jis' | 'csshiftjis' , 'ms932' , 'ms_kanji' , 'shift-jis' , 'sjis' , 'windows-31j' , 'x-sjis' |
'euc-kr' | 'cseuckr' , 'csksc56011987' , 'iso-ir-149' , 'korean' , 'ks_c_5601-1987' , 'ks_c_5601-1989' , 'ksc5601' , 'ksc_5601' , 'windows-949' |
The 'iso-8859-16'
encoding listed in the WHATWG Encoding Standard
is not supported.
new TextDecoder([encoding[, options]])#
encoding
<string> Identifies theencoding
that thisTextDecoder
instance supports. Default:'utf-8'
.-
options
<Object>fatal
<boolean>true
if decoding failures are fatal. This option is only supported when ICU is enabled (see Internationalization). Default:false
.ignoreBOM
<boolean> Whentrue
, theTextDecoder
will include the byte order mark in the decoded result. Whenfalse
, the byte order mark will be removed from the output. This option is only used whenencoding
is'utf-8'
,'utf-16be'
or'utf-16le'
. Default:false
.
Creates an new TextDecoder
instance. The encoding
may specify one of the
supported encodings or an alias.
textDecoder.decode([input[, options]])#
input
<ArrayBuffer> | <DataView> | <TypedArray> AnArrayBuffer
,DataView
orTyped Array
instance containing the encoded data.-
options
<Object>stream
<boolean>true
if additional chunks of data are expected. Default:false
.
- Returns: <string>
Decodes the input
and returns a string. If options.stream
is true
, any
incomplete byte sequences occurring at the end of the input
are buffered
internally and emitted after the next call to textDecoder.decode()
.
If textDecoder.fatal
is true
, decoding errors that occur will result in a
TypeError
being thrown.
textDecoder.encoding#
The encoding supported by the TextDecoder
instance.
textDecoder.fatal#
The value will be true
if decoding errors result in a TypeError
being
thrown.
textDecoder.ignoreBOM#
The value will be true
if the decoding result will include the byte order
mark.
Class: util.TextEncoder#
An implementation of the WHATWG Encoding Standard TextEncoder
API. All
instances of TextEncoder
only support UTF-8 encoding.
const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');
textEncoder.encode([input])#
input
<string> The text to encode. Default: an empty string.- Returns: <Uint8Array>
UTF-8 encodes the input
string and returns a Uint8Array
containing the
encoded bytes.
textEncoder.encoding#
The encoding supported by the TextEncoder
instance. Always set to 'utf-8'
.
util.types#
util.types
provides a number of type checks for different kinds of built-in
objects. Unlike instanceof
or Object.prototype.toString.call(value)
,
these checks do not inspect properties of the object that are accessible from
JavaScript (like their prototype), and usually have the overhead of
calling into C++.
The result generally does not make any guarantees about what kinds of properties or behavior a value exposes in JavaScript. They are primarily useful for addon developers who prefer to do type checking in JavaScript.
util.types.isAnyArrayBuffer(value)#
- Returns: <boolean>
Returns true
if the value is a built-in ArrayBuffer
or
SharedArrayBuffer
instance.
See also util.types.isArrayBuffer()
and
util.types.isSharedArrayBuffer()
.
For example:
util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
util.types.isArgumentsObject(value)#
- Returns: <boolean>
Returns true
if the value is an arguments
object.
For example:
function foo() {
util.types.isArgumentsObject(arguments); // Returns true
}
util.types.isArrayBuffer(value)#
- Returns: <boolean>
Returns true
if the value is a built-in ArrayBuffer
instance.
This does not include SharedArrayBuffer
instances. Usually, it is
desirable to test for both; See util.types.isAnyArrayBuffer()
for that.
For example:
util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
util.types.isAsyncFunction(value)#
- Returns: <boolean>
Returns true
if the value is an async function.
Note that this only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
For example:
util.types.isAsyncFunction(function foo() {}); // Returns false
util.types.isAsyncFunction(async function foo() {}); // Returns true
util.types.isBigInt64Array(value)#
- Returns: <boolean>
Returns true
if the value is a BigInt64Array
instance. The
--harmony-bigint
command line flag is required in order to use the
BigInt64Array
type, but it is not required in order to use
isBigInt64Array()
.
For example:
util.types.isBigInt64Array(new BigInt64Array()); // Returns true
util.types.isBigInt64Array(new BigUint64Array()); // Returns false
util.types.isBigUint64Array(value)#
- Returns: <boolean>
Returns true
if the value is a BigUint64Array
instance. The
--harmony-bigint
command line flag is required in order to use the
BigUint64Array
type, but it is not required in order to use
isBigUint64Array()
.
For example:
util.types.isBigUint64Array(new BigInt64Array()); // Returns false
util.types.isBigUint64Array(new BigUint64Array()); // Returns true
util.types.isBooleanObject(value)#
- Returns: <boolean>
Returns true
if the value is a boolean object, e.g. created
by new Boolean()
.
For example:
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
util.types.isDataView(value)#
- Returns: <boolean>
Returns true
if the value is a built-in DataView
instance.
For example:
const ab = new ArrayBuffer(20);
util.types.isDataView(new DataView(ab)); // Returns true
util.types.isDataView(new Float64Array()); // Returns false
See also ArrayBuffer.isView()
.
util.types.isDate(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Date
instance.
For example:
util.types.isDate(new Date()); // Returns true
util.types.isExternal(value)#
- Returns: <boolean>
Returns true
if the value is a native External
value.
util.types.isFloat32Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Float32Array
instance.
For example:
util.types.isFloat32Array(new ArrayBuffer()); // Returns false
util.types.isFloat32Array(new Float32Array()); // Returns true
util.types.isFloat32Array(new Float64Array()); // Returns false
util.types.isFloat64Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Float64Array
instance.
For example:
util.types.isFloat64Array(new ArrayBuffer()); // Returns false
util.types.isFloat64Array(new Uint8Array()); // Returns false
util.types.isFloat64Array(new Float64Array()); // Returns true
util.types.isGeneratorFunction(value)#
- Returns: <boolean>
Returns true
if the value is a generator function.
Note that this only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
For example:
util.types.isGeneratorFunction(function foo() {}); // Returns false
util.types.isGeneratorFunction(function* foo() {}); // Returns true
util.types.isGeneratorObject(value)#
- Returns: <boolean>
Returns true
if the value is a generator object as returned from a
built-in generator function.
Note that this only reports back what the JavaScript engine is seeing;
in particular, the return value may not match the original source code if
a transpilation tool was used.
For example:
function* foo() {}
const generator = foo();
util.types.isGeneratorObject(generator); // Returns true
util.types.isInt8Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Int8Array
instance.
For example:
util.types.isInt8Array(new ArrayBuffer()); // Returns false
util.types.isInt8Array(new Int8Array()); // Returns true
util.types.isInt8Array(new Float64Array()); // Returns false
util.types.isInt16Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Int16Array
instance.
For example:
util.types.isInt16Array(new ArrayBuffer()); // Returns false
util.types.isInt16Array(new Int16Array()); // Returns true
util.types.isInt16Array(new Float64Array()); // Returns false
util.types.isInt32Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Int32Array
instance.
For example:
util.types.isInt32Array(new ArrayBuffer()); // Returns false
util.types.isInt32Array(new Int32Array()); // Returns true
util.types.isInt32Array(new Float64Array()); // Returns false
util.types.isMap(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Map
instance.
For example:
util.types.isMap(new Map()); // Returns true
util.types.isMapIterator(value)#
- Returns: <boolean>
Returns true
if the value is an iterator returned for a built-in
Map
instance.
For example:
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
util.types.isModuleNamespaceObject(value)#
- Returns: <boolean>
Returns true
if the value is an instance of a Module Namespace Object.
For example:
import * as ns from './a.js';
util.types.isModuleNamespaceObject(ns); // Returns true
util.types.isNativeError(value)#
- Returns: <boolean>
Returns true
if the value is an instance of a built-in Error
type.
For example:
util.types.isNativeError(new Error()); // Returns true
util.types.isNativeError(new TypeError()); // Returns true
util.types.isNativeError(new RangeError()); // Returns true
util.types.isNumberObject(value)#
- Returns: <boolean>
Returns true
if the value is a number object, e.g. created
by new Number()
.
For example:
util.types.isNumberObject(0); // Returns false
util.types.isNumberObject(new Number(0)); // Returns true
util.types.isPromise(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Promise
.
For example:
util.types.isPromise(Promise.resolve(42)); // Returns true
util.types.isProxy(value)#
- Returns: <boolean>
Returns true
if the value is a Proxy
instance.
For example:
const target = {};
const proxy = new Proxy(target, {});
util.types.isProxy(target); // Returns false
util.types.isProxy(proxy); // Returns true
util.types.isRegExp(value)#
- Returns: <boolean>
Returns true
if the value is a regular expression object.
For example:
util.types.isRegExp(/abc/); // Returns true
util.types.isRegExp(new RegExp('abc')); // Returns true
util.types.isSet(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Set
instance.
For example:
util.types.isSet(new Set()); // Returns true
util.types.isSetIterator(value)#
- Returns: <boolean>
Returns true
if the value is an iterator returned for a built-in
Set
instance.
For example:
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
util.types.isSharedArrayBuffer(value)#
- Returns: <boolean>
Returns true
if the value is a built-in SharedArrayBuffer
instance.
This does not include ArrayBuffer
instances. Usually, it is
desirable to test for both; See util.types.isAnyArrayBuffer()
for that.
For example:
util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
util.types.isStringObject(value)#
- Returns: <boolean>
Returns true
if the value is a string object, e.g. created
by new String()
.
For example:
util.types.isStringObject('foo'); // Returns false
util.types.isStringObject(new String('foo')); // Returns true
util.types.isSymbolObject(value)#
- Returns: <boolean>
Returns true
if the value is a symbol object, created
by calling Object()
on a Symbol
primitive.
For example:
const symbol = Symbol('foo');
util.types.isSymbolObject(symbol); // Returns false
util.types.isSymbolObject(Object(symbol)); // Returns true
util.types.isTypedArray(value)#
- Returns: <boolean>
Returns true
if the value is a built-in TypedArray
instance.
For example:
util.types.isTypedArray(new ArrayBuffer()); // Returns false
util.types.isTypedArray(new Uint8Array()); // Returns true
util.types.isTypedArray(new Float64Array()); // Returns true
See also ArrayBuffer.isView()
.
util.types.isUint8Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Uint8Array
instance.
For example:
util.types.isUint8Array(new ArrayBuffer()); // Returns false
util.types.isUint8Array(new Uint8Array()); // Returns true
util.types.isUint8Array(new Float64Array()); // Returns false
util.types.isUint8ClampedArray(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Uint8ClampedArray
instance.
For example:
util.types.isUint8ClampedArray(new ArrayBuffer()); // Returns false
util.types.isUint8ClampedArray(new Uint8ClampedArray()); // Returns true
util.types.isUint8ClampedArray(new Float64Array()); // Returns false
util.types.isUint16Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Uint16Array
instance.
For example:
util.types.isUint16Array(new ArrayBuffer()); // Returns false
util.types.isUint16Array(new Uint16Array()); // Returns true
util.types.isUint16Array(new Float64Array()); // Returns false
util.types.isUint32Array(value)#
- Returns: <boolean>
Returns true
if the value is a built-in Uint32Array
instance.
For example:
util.types.isUint32Array(new ArrayBuffer()); // Returns false
util.types.isUint32Array(new Uint32Array()); // Returns true
util.types.isUint32Array(new Float64Array()); // Returns false
util.types.isWeakMap(value)#
- Returns: <boolean>
Returns true
if the value is a built-in WeakMap
instance.
For example:
util.types.isWeakMap(new WeakMap()); // Returns true
util.types.isWeakSet(value)#
- Returns: <boolean>
Returns true
if the value is a built-in WeakSet
instance.
For example:
util.types.isWeakSet(new WeakSet()); // Returns true
util.types.isWebAssemblyCompiledModule(value)#
- Returns: <boolean>
Returns true
if the value is a built-in WebAssembly.Module
instance.
For example:
const module = new WebAssembly.Module(wasmBuffer);
util.types.isWebAssemblyCompiledModule(module); // Returns true
废弃的 API#
以下 API 已被废弃,不应该再被使用。 现存的应用和模块应该使用替代方法更新。
util.\_extend(target, source)#
Object.assign()
代替。The util._extend()
method was never intended to be used outside of internal
Node.js modules. The community found and used it anyway.
It is deprecated and should not be used in new code. JavaScript comes with very
similar built-in functionality through Object.assign()
.
util.debug(string)#
console.error()
代替。string
<string> The message to print tostderr
Deprecated predecessor of console.error
.
util.error([...strings])#
console.error()
代替。...strings
<string> The message to print tostderr
Deprecated predecessor of console.error
.
util.isArray(object)#
object
<any>
Internal alias for Array.isArray
.
Returns true
if the given object
is an Array
. Otherwise, returns false
.
const util = require('util');
util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
util.isBoolean(object)#
object
<any>
Returns true
if the given object
is a Boolean
. Otherwise, returns false
.
const util = require('util');
util.isBoolean(1);
// Returns: false
util.isBoolean(0);
// Returns: false
util.isBoolean(false);
// Returns: true
util.isBuffer(object)#
Buffer.isBuffer()
代替。object
<any>
Returns true
if the given object
is a Buffer
. Otherwise, returns false
.
const util = require('util');
util.isBuffer({ length: 0 });
// Returns: false
util.isBuffer([]);
// Returns: false
util.isBuffer(Buffer.from('hello world'));
// Returns: true
util.isDate(object)#
object
<any>
Returns true
if the given object
is a Date
. Otherwise, returns false
.
const util = require('util');
util.isDate(new Date());
// Returns: true
util.isDate(Date());
// false (without 'new' returns a String)
util.isDate({});
// Returns: false
util.isError(object)#
object
<any>
Returns true
if the given object
is an Error
. Otherwise, returns
false
.
const util = require('util');
util.isError(new Error());
// Returns: true
util.isError(new TypeError());
// Returns: true
util.isError({ name: 'Error', message: 'an error occurred' });
// Returns: false
Note that this method relies on Object.prototype.toString()
behavior. It is
possible to obtain an incorrect result when the object
argument manipulates
@@toStringTag
.
const util = require('util');
const obj = { name: 'Error', message: 'an error occurred' };
util.isError(obj);
// Returns: false
obj[Symbol.toStringTag] = 'Error';
util.isError(obj);
// Returns: true
util.isFunction(object)#
object
<any>
Returns true
if the given object
is a Function
. Otherwise, returns
false
.
const util = require('util');
function Foo() {}
const Bar = () => {};
util.isFunction({});
// Returns: false
util.isFunction(Foo);
// Returns: true
util.isFunction(Bar);
// Returns: true
util.isNull(object)#
object
<any>
Returns true
if the given object
is strictly null
. Otherwise, returns
false
.
const util = require('util');
util.isNull(0);
// Returns: false
util.isNull(undefined);
// Returns: false
util.isNull(null);
// Returns: true
util.isNullOrUndefined(object)#
object
<any>
Returns true
if the given object
is null
or undefined
. Otherwise,
returns false
.
const util = require('util');
util.isNullOrUndefined(0);
// Returns: false
util.isNullOrUndefined(undefined);
// Returns: true
util.isNullOrUndefined(null);
// Returns: true
util.isNumber(object)#
object
<any>
Returns true
if the given object
is a Number
. Otherwise, returns false
.
const util = require('util');
util.isNumber(false);
// Returns: false
util.isNumber(Infinity);
// Returns: true
util.isNumber(0);
// Returns: true
util.isNumber(NaN);
// Returns: true
util.isObject(object)#
object
<any>
Returns true
if the given object
is strictly an Object
and not a
Function
. Otherwise, returns false
.
const util = require('util');
util.isObject(5);
// Returns: false
util.isObject(null);
// Returns: false
util.isObject({});
// Returns: true
util.isObject(function() {});
// Returns: false
util.isPrimitive(object)#
object
<any>
Returns true
if the given object
is a primitive type. Otherwise, returns
false
.
const util = require('util');
util.isPrimitive(5);
// Returns: true
util.isPrimitive('foo');
// Returns: true
util.isPrimitive(false);
// Returns: true
util.isPrimitive(null);
// Returns: true
util.isPrimitive(undefined);
// Returns: true
util.isPrimitive({});
// Returns: false
util.isPrimitive(function() {});
// Returns: false
util.isPrimitive(/^$/);
// Returns: false
util.isPrimitive(new Date());
// Returns: false
util.isRegExp(object)#
object
<any>
Returns true
if the given object
is a RegExp
. Otherwise, returns false
.
const util = require('util');
util.isRegExp(/some regexp/);
// Returns: true
util.isRegExp(new RegExp('another regexp'));
// Returns: true
util.isRegExp({});
// Returns: false
util.isString(object)#
object
<any>
Returns true
if the given object
is a string
. Otherwise, returns false
.
const util = require('util');
util.isString('');
// Returns: true
util.isString('foo');
// Returns: true
util.isString(String('foo'));
// Returns: true
util.isString(5);
// Returns: false
util.isSymbol(object)#
object
<any>
Returns true
if the given object
is a Symbol
. Otherwise, returns false
.
const util = require('util');
util.isSymbol(5);
// Returns: false
util.isSymbol('foo');
// Returns: false
util.isSymbol(Symbol('foo'));
// Returns: true
util.isUndefined(object)#
object
<any>
Returns true
if the given object
is undefined
. Otherwise, returns false
.
const util = require('util');
const foo = undefined;
util.isUndefined(5);
// Returns: false
util.isUndefined(foo);
// Returns: true
util.isUndefined(null);
// Returns: false
util.log(string)#
string
<string>
The util.log()
method prints the given string
to stdout
with an included
timestamp.
const util = require('util');
util.log('Timestamped message.');
util.print([...strings])#
console.log()
代替。Deprecated predecessor of console.log
.
util.puts([...strings])#
console.log()
代替。Deprecated predecessor of console.log
.