参考
njs 提供了用于扩展 NGINX 功能的对象、方法和属性。
本参考文档仅包含 njs 特有的、不符合 ECMAScript 规范的属性、方法和模块。符合 ECMAScript 规范的 njs 属性和方法的定义可在 ECMAScript 规范中找到。所有 njs 属性和方法的列表可在 Compatibility 中找到。
NGINX 对象
HTTP 请求
HTTP 请求对象仅在 ngx_http_js_module 模块中可用。在 0.8.5 之前，该对象的所有字符串属性都是 字节字符串。
r.args{}- 请求参数对象，只读。
查询字符串作为对象返回。从 0.7.6 版本起，重复的键作为数组返回，键区分大小写，键和值都经过百分号解码。
例如，查询字符串
'a=1&b=%32&A=3&b=4&B=two%20words'
转换为
r.args后为{a: "1", b: ["2", "4"], A: "3", B: "two words"}更高级的解析场景可以使用 Query String 模块和
$args变量来实现，例如import qs from 'querystring'; function args(r) { return qs.parse(r.variables.args); }参数对象在首次访问
r.args时进行评估。如果只需要单个参数，例如foo，则可以使用 NGINX 变量r.variables.arg_foo
在这里，NGINX 变量对象返回给定键的第一个值，不区分大小写，且未经百分号解码。
要将
r.args转换回字符串，可以使用 Query String 的stringify方法。 r.done()- 调用此函数后，后续数据块将直接传递给客户端，而不再调用 js_body_filter (0.5.2)。只能从 js_body_filter 函数中调用此函数
r.error(string)- 将
string写入错误日志的error级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
r.finish()- 完成向客户端发送响应
r.headersIn{}- 传入的头部对象，只读。
Foo请求头部可以通过以下语法访问：headersIn.foo或headersIn['Foo']。“Authorization”、“Content-Length”、“Content-Range”、“Content-Type”、“ETag”、“Expect”、“From”、“Host”、“If-Match”、“If-Modified-Since”、“If-None-Match”、“If-Range”、“If-Unmodified-Since”、“Max-Forwards”、“Proxy-Authorization”、“Referer”、“Transfer-Encoding”和“User-Agent”等请求头部只能有一个字段值 (0.4.1)。“Cookie”头部中重复的字段值通过分号 (
;) 分隔。所有其他请求头部中重复的字段值通过逗号分隔。 r.headersOut{}- 主请求的传出头部对象，可写。
如果
r.headersOut{}是 子请求的响应对象，则它代表响应头部。在这种情况下，“Accept-Ranges”、“Connection”、“Content-Disposition”、“Content-Encoding”、“Content-Length”、“Content-Range”、“Date”、“Keep-Alive”、“Server”、“Transfer-Encoding”、“X-Accel-*”等响应头部中的字段值可能会被省略。“Foo”响应头部可以通过以下语法访问：
headersOut.foo或headersOut['Foo']。传出头部应该在向客户端发送响应头部之前设置，否则头部更新将被忽略。这意味着
r.headersOut{}在以下情况是有效可写的：- 在调用
r.sendHeader()或r.return()之前的 js_content 处理器中 - 在 js_header_filter 处理器中
多值响应头部 (0.4.0) 的字段值可以使用以下语法设置
r.headersOut['Foo'] = ['a', 'b']
输出将是
Foo: a Foo: b
“Foo”响应头部的所有先前字段值将被删除。
对于只接受单个字段值的标准响应头部，例如“Content-Type”，只有数组的最后一个元素会生效。“Set-Cookie”响应头部的字段值总是作为数组返回。“Age”、“Content-Encoding”、“Content-Length”、“Content-Type”、“ETag”、“Expires”、“Last-Modified”、“Location”、“Retry-After”等响应头部中重复的字段值将被忽略。所有其他响应头部中重复的字段值通过逗号分隔。
- 在调用
r.httpVersion- HTTP 版本，只读
r.internal- 布尔值，对于 内部位置为 true
r.internalRedirect(uri)- 对指定的
uri执行 内部重定向。如果 uri 以“@”前缀开头，则被视为命名位置。在新位置中，所有请求处理将从头开始重复，对于普通位置从 NGX_HTTP_SERVER_REWRITE_PHASE 开始，对于命名位置从 NGX_HTTP_REWRITE_PHASE 开始。因此，重定向到命名位置不会检查 client_max_body_size 限制。更多详细信息请参阅 开发指南。重定向的请求变为内部请求，可以访问 内部位置。实际的重定向发生在处理程序执行完成后。重定向后，将在目标位置启动新的 njs VM，原始位置的 VM 将停止。NGINX 变量的值会被保留，可用于向目标位置传递信息。从 0.5.3 版本起，可以使用通过 http 或 stream 的
js_var指令声明的变量。从 0.7.4 版本起，该方法接受转义的 URI。
r.log(string)- 将
string写入错误日志的info级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
r.method- HTTP 方法，只读
r.parent- 引用父请求对象
r.remoteAddress- 客户端地址，只读
r.requestBody- 该属性在 0.5.0 版本中已弃用，并在 0.8.0 版本中移除。应改用
r.requestBuffer或r.requestText属性。 r.requestBuffer- 客户端请求体（如果尚未写入临时文件）(自 0.5.0 版本起)。为确保客户端请求体在内存中，应通过 client_max_body_size 限制其大小，并使用 client_body_buffer_size 设置足够的缓冲区大小。此属性仅在 js_content 指令中可用。
r.requestText- 与
r.requestBuffer相同，但返回一个string。请注意，它可能将 UTF-8 编码中无效的字节转换为替换字符。 r.rawHeadersIn[]- 返回一个键值对数组，与其从客户端接收时的形式完全一致 (0.4.1)。
例如，使用以下请求头部
Host: localhost Foo: bar foo: bar2
r.rawHeadersIn的输出将是[ ['Host', 'localhost'], ['Foo', 'bar'], ['foo', 'bar2'] ]所有
foo头部可以通过以下语法收集r.rawHeadersIn.filter(v=>v[0].toLowerCase() == 'foo').map(v=>v[1])
输出将是
['bar', 'bar2']
头部字段名不转换为小写，重复的字段值不合并。
r.rawHeadersOut[]- 返回一个响应头部键值对数组 (0.4.1)。头部字段名不转换为小写，重复的字段值不合并。
r.responseBody- 该属性在 0.5.0 版本中已弃用，并在 0.8.0 版本中移除。应改用
r.responseBuffer或r.responseText属性。 r.responseBuffer- 保存 子请求的响应体，只读 (自 0.5.0 版本起)。
r.responseBuffer的大小受 subrequest_output_buffer_size 指令限制。 r.responseText- 与
r.responseBuffer相同，但返回一个 string (自 0.5.0 版本起)。请注意，它可能将 UTF-8 编码中无效的字节转换为替换字符。 r.return(status[, string | Buffer])- 向客户端发送带有指定
status的完整响应。响应可以是 string 或 Buffer (0.5.0)。可以将重定向 URL（对于代码 301、302、303、307 和 308）或响应正文文本（对于其他代码）指定为第二个参数
r.send(string | Buffer)- 将响应正文的一部分发送给客户端。发送的数据可以是 string 或 Buffer (0.5.0)
r.sendBuffer(data[,options])- 将 data 添加到数据块链中，以便转发到下一个 body filter (0.5.2)。实际转发发生在稍后，当当前链中的所有数据块都被处理完毕时。
data 可以是 string 或 Buffer。
options是一个用于覆盖从传入数据块缓冲区派生的 NGINX 缓冲区标志的对象。标志可以使用以下标志进行覆盖last- 布尔值，如果缓冲区是最后一个缓冲区则为 true
flush- 布尔值，如果缓冲区应该具有 flush 标志则为 true
该方法只能从 js_body_filter 函数中调用。 r.sendHeader()- 将 HTTP 头部发送给客户端
r.setReturnValue(value)- 设置 js_set 处理器 (0.7.0) 的返回值。与普通的 return 语句不同，当处理器是 JS async 函数时，应使用此方法。例如
async function js_set(r) { const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host); r.setReturnValue(digest); } r.status- status，可写
r.subrequest(uri[,options[,callback]])- 使用给定的
uri和options创建一个子请求，并安装一个可选的完成callback。子请求与其客户端请求共享输入头部。要向代理服务器发送与原始头部不同的头部，可以使用 proxy_set_header 指令。要向代理服务器发送一套全新的头部，可以使用 proxy_pass_request_headers 指令。
如果
options是一个 string，则它保存子请求的参数字符串。否则，options应该是一个具有以下键的对象args- 参数字符串，默认为空字符串
body- 请求体，默认为父请求对象的请求体
method- HTTP 方法，默认为 GET 方法
detached- 布尔标志 (0.3.9)，如果
true，创建的子请求是分离的子请求。对分离子请求的响应将被忽略。与普通子请求不同，分离子请求可以在变量处理器中创建。detached标志和 callback 参数互斥。
完成
callback接收一个 子请求响应对象，其方法和属性与父请求对象相同。从 0.3.8 版本起，如果没有提供
callback，则返回一个解析为 子请求响应对象的Promise对象。例如，查看子请求中的所有响应头部
async function handler(r) { const reply = await r.subrequest('/path'); for (const h in reply.headersOut) { r.log(`${h}: ${reply.headersOut[h]}`); } r.return(200); } r.uri- 请求中的当前 URI，已 规范化，只读
r.rawVariables{}- NGINX 变量作为 Buffers，可写 (自 0.5.0 版本起)
r.variables{}-
NGINX 变量对象，可写 (自 0.2.8 版本起)。
例如，要获取
$foo变量，可以使用以下任一语法r.variables['foo'] r.variables.foo
从 0.8.6 版本起，可以使用以下语法访问正则表达式捕获
r.variables['1'] r.variables[1]
NGINX 对 nginx.conf 中引用的变量和未引用的变量处理方式不同。当变量被引用时，可能是可缓存的，但未引用时总是不可缓存的。例如，当 $request_id 变量仅从 njs 访问时，每次评估都会有一个新值。但是，当 $request_id 被引用时，例如
proxy_set_header X-Request-Id $request_id;
r.variables.request_id每次都返回相同的值。变量在以下情况下是可写的：
即便如此，一些内嵌变量仍然无法被赋值（例如，
$http_）。 r.warn(string)- 将
string写入错误日志的warning级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
流会话
流会话对象仅在 ngx_stream_js_module 模块中可用。在 0.8.5 之前，该对象的所有字符串属性都是 字节字符串。
s.allow()- s.done(0) 的别名 (0.2.4)
s.decline()- s.done(-5) 的别名 (0.2.4)
s.deny()- s.done(403) 的别名 (0.2.4)
s.done([)code]- 为当前 阶段处理器设置退出
code，默认值为0。实际的终结发生在 js 处理器完成并且所有挂起的事件（例如来自ngx.fetch()或setTimeout()的事件）被处理后 (0.2.4)。可能的 code 值
-
0— 成功终结，将控制权传递给下一阶段 -
-5— 未决定，将控制权传递给当前阶段的下一个处理器（如果有） -
403— 访问被禁止
只能从阶段处理函数中调用：js_access或js_preread。 -
s.error(string)- 将发送的
string写入错误日志的error级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
s.log(string)- 将发送的
string写入错误日志的info级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
s.off(eventName)- 注销由 s.on() 方法设置的 callback (0.2.4)
s.on(event,callback)- 为指定的
event注册一个callback(0.2.4)。event可以是以下字符串之一upload- 来自客户端的新数据 (string)
下载- 发往客户端的新数据 (string)
upstream- 来自客户端的新数据 (Buffer) (自 0.5.0 版本起)
downstream- 发往客户端的新数据 (Buffer) (自 0.5.0 版本起)
完成 callback 的原型如下：
callback(data, flags)，其中data是 string 或 Buffer（取决于事件类型），flags是一个包含以下属性的对象last- 布尔值，如果 data 是最后一个缓冲区则为 true。
s.remoteAddress- 客户端地址，只读
s.rawVariables- NGINX 变量作为 Buffers，可写 (自 0.5.0 版本起)
s.send(data[,options])- 将 data 添加到数据块链中，这些数据块将按转发方向传递：在下载 callback 中发往客户端；在上传 callback 中发往上游服务器 (0.2.4)。实际转发发生在稍后，当当前链中的所有数据块都被处理完毕时。
data 可以是 string 或 Buffer (0.5.0)。
options是一个用于覆盖从传入数据块缓冲区派生的 NGINX 缓冲区标志的对象。标志可以使用以下标志进行覆盖last- 布尔值，如果缓冲区是最后一个缓冲区则为 true
flush- 布尔值，如果缓冲区应该具有 flush 标志则为 true
每个 callback 调用可以多次调用此方法。 s.sendDownstream()- 与 s.send() 相同，但它总是将数据发送到客户端 (自 0.7.8 版本起)。
s.sendUpstream()- 与 s.send() 相同，但它总是将数据从客户端发送出去 (自 0.7.8 版本起)。
s.status- 会话状态码，
$status变量的别名，只读 (自 0.5.2 版本起) s.setReturnValue(value)- 设置 js_set 处理器 (0.7.0) 的返回值。与普通的 return 语句不同，当处理器是 JS async 函数时，应使用此方法。例如
async function js_set(r) { const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host); r.setReturnValue(digest); } s.variables{}- NGINX 变量对象，可写 (自 0.2.8 版本起)。变量只有在 NGINX 配置文件中被引用时才能可写。即便如此，一些内嵌变量仍然无法被赋值。
s.warn(string)- 将发送的
string写入错误日志的warning级别由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
周期性会话
PeriodicSession.rawVariables{} |
PeriodicSession.variables{} |
Periodic Session 对象作为 http 和 stream 的 js_periodic 处理器 (自 0.8.1 版本起) 的第一个参数提供。
头部
Headers() |
Headers.append() |
Headers.delete() |
Headers.get() |
Headers.getAll() |
Headers.forEach() |
Headers.has() |
Headers.set() |
Fetch API 的 Headers 接口从 0.5.1 版本起可用。
可以使用 Headers() 构造函数创建新的 Headers 对象：(自 0.7.10 版本起)
Headers([init])-
init- 一个包含 HTTP 头部用于预填充
Headers对象的对象，可以是string、名称-值对array，或现有的Headers对象。
可以使用以下属性和方法创建新的 Headers 对象
append()- 向
Headers对象中的现有头部添加一个新值，如果头部不存在则添加该头部 (自 0.7.10 版本起)。 delete()- 从
Headers对象中删除一个头部 (自 0.7.10 版本起)。 get()- 返回一个 string，其中包含具有指定名称的所有头部的值，这些值以逗号和空格分隔。
getAll(name)- 返回一个 array，其中包含具有指定名称的所有头部的值。
forEach()- 对
Headers对象中的每个键/值对执行提供的函数一次 (自 0.7.10 版本起)。 has()- 返回一个布尔值，指示具有指定名称的头部是否存在。
set()- 设置
Headers对象中现有头部的新值，如果头部不存在则添加该头部 (自 0.7.10 版本起)。
请求
Request() |
Request.arrayBuffer() |
Request.bodyUsed |
Request.cache |
Request.credentials |
Request.headers |
Request.json() |
Request.method |
Request.mode |
Request.text() |
Request.url |
Fetch API 的 Request 接口从 0.7.10 版本起可用。
可以使用 Request() 构造函数创建新的 Request 对象
Request[resource[,options]])- 创建一个
Request对象用于 fetch，该对象稍后可以传递给ngx.fetch()。resource可以是 URL 或现有的Request对象。options是一个可选参数，应该是一个具有以下键的对象
可以使用以下属性和方法创建新的 Request 对象
arrayBuffer()- 返回一个解析为
ArrayBuffer的Promise。 bodyUsed- 布尔值，如果在请求中使用了 body 则为
true。 cache- 包含请求的缓存模式。
credentials- 包含请求的凭据，默认为
same-origin。 headers- 与
Request相关联的只读Headers对象。 json()- 返回一个解析为将请求体解析为 JSON 的结果的
Promise。 method- 包含请求方法。
mode- 包含请求的模式。
text()- 返回一个解析为请求体的 string 表示的
Promise。 url- 包含请求的 URL。
响应
Response() |
Response.arrayBuffer() |
Response.bodyUsed |
Response.headers |
Response.json() |
Response.ok |
Response.redirected |
Response.status |
Response.statusText |
Response.text() |
Response.type |
Response.url |
Response 接口从 0.5.1 版本起可用。
可以使用 Response() 构造函数创建新的 Response 对象 (自 0.7.10 版本起)
Response[body[,options]])- 创建一个
Response对象。body是一个可选参数，可以是string或buffer，默认为null。options是一个可选参数，应该是一个具有以下键的对象
可以使用以下属性和方法创建新的 Response() 对象
arrayBuffer()- 接收一个
Response流并完整读取。返回一个解析为ArrayBuffer的Promise。 bodyUsed- 布尔值，如果 body 已被读取则为
true。 headers- 与
Response相关联的只读Headers对象。 json()- 接收一个
Response流并完整读取。返回一个解析为将 body 文本解析为 JSON 的结果的Promise。 ok- 布尔值，如果响应成功（状态码在 200–299 之间）则为
true。 redirected- 布尔值，如果响应是重定向的结果则为
true。 status- 响应的状态码。
statusText- 对应于状态码的状态消息。
text()- 接收一个
Response流并完整读取。返回一个解析为 string 的Promise。 type- 响应的类型。
url- 响应的 URL。
ngx
ngx.build |
ngx.conf_file_path |
ngx.conf_prefix |
ngx.error_log_path |
ngx.fetch() |
ngx.log() |
ngx.prefix |
ngx.version |
ngx.version_number |
ngx.worker_id |
ngx 全局对象从 0.5.0 版本起可用。
ngx.build- 包含可选 NGINX 构建名称的 string，对应于 configure 脚本的
--build=name参数，默认为""(0.8.0) ngx.conf_file_path- 包含当前 NGINX 配置文件的文件路径的 string (0.8.0)
ngx.conf_prefix- 包含 NGINX 配置前缀文件路径的 string — NGINX 当前查找配置文件的目录 (0.7.8)
ngx.error_log_path- 包含当前 错误日志文件路径的 string (0.8.0)
ngx.fetch(resource, [options])-
发起请求以 fetch
resource(0.5.1)，resource 可以是 URL 或Request对象 (0.7.10)。返回一个解析为Response对象的Promise。从 0.7.0 版本起，支持https://scheme，但不处理重定向。如果
resource中的 URL 指定为域名，则使用 resolver 进行解析。如果指定了https://scheme，则应配置 js_fetch_trusted_certificate 指令以对resource的 HTTPS 服务器进行认证。options参数应该是一个具有以下键的对象body- 请求体，默认为空
buffer_size- 读取响应的缓冲区大小，默认为
4096 headers- 请求 头部对象
max_response_body_size- 响应体最大大小（字节），默认为
32768 method- HTTP 方法，默认为 GET 方法
verify- 启用或禁用 HTTPS 服务器证书验证，默认为
true(0.7.0)
示例
let reply = await ngx.fetch('https://nginxserver.cn/'); let body = await reply.text(); r.return(200, body); ngx.log(level,message)- 以指定的日志级别将 message 写入错误日志。
level参数指定日志级别之一，message参数可以是 string 或 Buffer。可指定的日志级别如下：ngx.INFO、ngx.WARN和ngx.ERR。由于 NGINX 有 硬编码的最大行长度限制，字符串的前 2048 字节才能被记录到日志。
ngx.prefix- 包含 NGINX 前缀文件路径的 string — 保存服务器文件的目录 (0.8.0)
ngx.version- 包含 NGINX 版本的 string，例如：
1.25.0(0.8.0) ngx.version_number- 包含 NGINX 版本号的 number，例如：
1025000(0.8.0) ngx.worker_id- 对应于 NGINX 内部 worker ID 的 number，该值介于
0和 worker_processes 指令中指定的值之间 (0.8.0)
ngx.shared
ngx.shared 全局对象从 0.8.0 版本起可用。
SharedDict
共享字典对象从 0.8.0 版本起可用。共享字典的名称、类型和大小通过 http 或 stream 中的 js_shared_dict_zone 指令设置。
一个 SharedDict() 对象具有以下属性和方法
ngx.shared.SharedDict.add(key,value[,timeout])- 仅当字典中尚不存在指定的
key时，才为其设置value。key是表示要添加项的键的 string，value是要添加项的值。可选的
timeout参数以毫秒为单位指定，并覆盖 http 或 stream 中js_shared_dict_zone指令的timeout参数 (自 0.8.5 版本起)。当某些键预期具有独特的超时值时，这非常有用。如果成功将 value 添加到
SharedDict字典中，则返回true；如果字典中已存在该 key，则返回false。如果SharedDict字典中没有足够的可用空间，则抛出SharedMemoryError。如果 value 的类型与此字典预期的类型不同，则抛出TypeError。 ngx.shared.SharedDict.capacity- 返回
SharedDict字典的容量，对应于 http 或 stream 中js_shared_dict_zone指令的size参数。 ngx.shared.SharedDict.clear()- 从
SharedDict字典中移除所有项。 ngx.shared.SharedDict.delete(key)- 从
SharedDict字典中移除与指定 key 相关联的项，如果字典中存在该项且已被移除则返回true，否则返回false。 ngx.shared.SharedDict.freeSpace()- 返回可用页面大小（字节）。如果大小为零，则如果已占用的页面中有空间，
SharedDict字典仍然会接受新值。 ngx.shared.SharedDict.get(key)- 通过其
key检索项，返回与该key相关联的 value，如果没有则返回undefined。 ngx.shared.SharedDict.has(key)- 通过其
key搜索项，如果存在则返回true，否则返回false。 ngx.shared.SharedDict.incr(key,delta[[,init],timeout]))- 将与
key相关联的整数值按delta增量或减量。key是 string，delta是要增加或减少值的数字。如果 key 不存在，则该项将初始化为可选的init参数，默认为0。可选的
timeout参数以毫秒为单位指定，并覆盖 http 或 stream 中js_shared_dict_zone指令的timeout参数 (自 0.8.5 版本起)。当某些键预期具有独特的超时值时，这非常有用。返回新值。如果
SharedDict字典中没有足够的可用空间，则抛出SharedMemoryError。如果此字典不接受数字，则抛出TypeError。仅当字典类型在 http 或 stream 的
js_shared_dict_zone指令中声明了type=number参数时，才能使用此方法。 ngx.shared.SharedDict.items([maxCount])- 返回
SharedDict字典的键值项 array (自 0.8.1 版本起)。maxCount参数设置要检索的最大项数，默认为1024。 ngx.shared.SharedDict.keys([maxCount])- 返回
SharedDict字典的键数组。maxCount参数设置要检索的最大键数，默认为1024。 ngx.shared.SharedDict.name- 返回
SharedDict字典的名称，对应于 http 或 stream 中js_shared_dict_zone指令的zone=参数。 ngx.shared.SharedDict.pop(key)- 从
SharedDict字典中移除与指定key关联的项，返回与key关联的值，如果不存在则返回undefined。 ngx.shared.SharedDict.replace(key,value)- 仅在指定的
key已存在时替换其对应的value，如果值成功替换则返回true，如果SharedDict字典中不存在该键则返回false。如果SharedDict字典中没有足够的可用空间，则抛出SharedMemoryError。如果value的类型与此字典期望的类型不同，则抛出TypeError。 ngx.shared.SharedDict.set(key,value[,timeout])- 为指定的
key设置value，返回此SharedDict字典（用于方法链）。可选的
timeout参数以毫秒为单位指定，并覆盖 http 或 stream 中js_shared_dict_zone指令的timeout参数 (自 0.8.5 版本起)。当某些键预期具有独特的超时值时，这非常有用。 ngx.shared.SharedDict.size()- 返回
SharedDict字典中的项数。 ngx.shared.SharedDict.type- 返回与 http 或 stream 中
js_shared_dict_zone指令的type=参数设置的SharedDict字典类型对应的string或number。
内建对象
控制台
console.error() |
console.info() |
console.log() |
console.time() |
console.timeEnd() |
console.warn() |
console 对象自 0.8.2 版本起在 nginx 中可用，自 0.2.6 版本起在 CLI 中可用。
console.error(msg[,msg2...])- 输出一个或多个错误消息。消息可以是字符串或对象。
console.info(msg[,msg2...])- 输出一个或多个信息消息。消息可以是字符串或对象。
console.log(msg[,msg2...])- 输出一个或多个日志消息。消息可以是字符串或对象。
console.time(label)- 启动一个计时器，用于跟踪操作所需的时间。
label参数允许为不同的计时器命名。如果调用与同一名称对应的console.timeEnd()，将输出自计时器启动以来经过的时间（以毫秒为单位）。 console.timeEnd(label)- 停止之前由
console.time()启动的计时器。label参数允许为不同的计时器命名。 console.warn(msg[,msg2...])- 输出一个或多个警告消息。消息可以是字符串或对象。
crypto
crypto 对象是一个全局对象，允许使用加密功能（自 0.7.0 版本起）。
сrypto.getRandomValues(typedArray)- 获取加密安全的随机值。返回作为
typedArray传入的同一个数组，但其内容已被新生成的随机数替换。可能的值typedArray- 可以是
Int8Array,Int16Array,Uint16Array,Int32Array或Uint32Array
сrypto.subtle.encrypt(algorithm,key,data)- 使用提供的
algorithm和key加密data。返回一个以包含密文的ArrayBuffer兑现的Promise。可能的值algorithm- 一个对象，指定要使用的算法以及任何所需的额外参数
- 对于
RSA-OAEP，传入包含以下键的对象-
name是一个字符串，应设置为RSA-OAEPcrypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)
-
- 对于
AES-CTR，传入包含以下键的对象-
name是一个字符串，应设置为AES-CTR -
counter是一个ArrayBuffer,TypedArray或DataView— 计数器块的初始值，必须为 16 字节长（AES 块大小）。此块最右边的 length 位用于计数器，其余用于 nonce。例如，如果 length 设置为 64，则 counter 的前半部分是 nonce，后半部分用作计数器 -
length是计数器块中用于实际计数器的位数。计数器必须足够大，以免溢出。
-
- 对于
AES-CBC，传入包含以下键的对象-
name是一个字符串，应设置为AES-CBC -
iv或初始化向量，是一个ArrayBuffer,TypedArray或DataView，必须为 16 字节，不可预测，最好是加密安全的随机值。但是，它不必保密，例如，它可以与密文一起未经加密传输。
-
- 对于
AES-GCM，传入包含以下键的对象-
name是一个字符串，应设置为AES-GCM -
iv或初始化向量，是一个ArrayBuffer,TypedArray或DataView，必须为 16 字节，且对于使用给定密钥进行的每一次加密操作都必须是唯一的 -
additionalData（可选）是一个ArrayBuffer,TypedArray或DataView，包含不会被加密但会与加密数据一起进行身份验证的附加数据。如果指定了additionalData，则在相应的decrypt()调用中必须指定相同的数据：如果提供给decrypt()调用的数据与原始数据不匹配，则解密将抛出异常。additionalData的位长度必须小于2^64 - 1。 -
tagLength（可选，默认值为128）- 一个number，确定加密操作中生成的身份验证标签的位大小，并用于相应的解密身份验证。可能的值有：32,64,96,104,112,120或128。AES-GCM 规范建议应为96,104,112,120或128，尽管在某些应用中32或64位也是可接受的。
-
- 对于
key- 一个
CryptoKey对象，包含用于加密的密钥 data- 一个
ArrayBuffer,TypedArray或DataView，包含要加密的数据（也称为明文）
сrypto.subtle.decrypt(algorithm,key,data)- 解密加密数据。返回一个包含解密数据的
Promise。可能的值algorithm- 一个对象，指定要使用的算法以及任何所需的额外参数。额外参数的值必须与传入相应
encrypt()调用的值匹配。- 对于
RSA-OAEP，传入包含以下键的对象-
name是一个字符串，应设置为RSA-OAEPcrypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)
-
- 对于
AES-CTR，传入包含以下键的对象-
name是一个字符串，应设置为AES-CTR -
counter是一个ArrayBuffer,TypedArray或DataView— 计数器块的初始值，必须为 16 字节长（AES 块大小）。此块最右边的 length 位用于计数器，其余用于 nonce。例如，如果 length 设置为 64，则 counter 的前半部分是 nonce，后半部分用作计数器。 -
length是计数器块中用于实际计数器的位数。计数器必须足够大，以免溢出。
-
- 对于
AES-CBC，传入包含以下键的对象-
name是一个字符串，应设置为AES-CBC -
iv或初始化向量，是一个ArrayBuffer,TypedArray或DataView，必须为 16 字节，不可预测，最好是加密安全的随机值。但是，它不必保密（例如，它可以与密文一起未经加密传输）。
-
- 对于
AES-GCM，传入包含以下键的对象-
name是一个字符串，应设置为AES-GCM -
iv或初始化向量，是一个ArrayBuffer,TypedArray或DataView，必须为 16 字节，且对于使用给定密钥进行的每一次加密操作都必须是唯一的 -
additionalData（可选）是一个ArrayBuffer,TypedArray或DataView，包含不会被加密但会与加密数据一起进行身份验证的附加数据。如果指定了additionalData，则在相应的decrypt()调用中必须指定相同的数据：如果提供给decrypt()调用的数据与原始数据不匹配，则解密将抛出异常。additionalData的位长度必须小于2^64 - 1。 -
tagLength（可选，默认值为128）- 一个number，确定加密操作中生成的身份验证标签的位大小，并用于相应的解密身份验证。可能的值有：32,64,96,104,112,120或128。AES-GCM 规范建议应为96,104,112,120或128，尽管在某些应用中32或64位也是可接受的。
-
- 对于
key- 一个
CryptoKey对象，包含用于解密的密钥。如果使用RSA-OAEP，这是CryptoKeyPair对象的privateKey属性。 data- 一个
ArrayBuffer,TypedArray或DataView，包含要解密的数据（也称为密文）
сrypto.subtle.deriveBits(algorithm,baseKey,length)- 从基础密钥派生位数组。返回一个
Promise，该 Promise 将以包含派生位的ArrayBuffer兑现。可能的值algorithm- 一个对象，定义要使用的派生算法
- 对于
HKDF，传入包含以下键的对象-
name是一个字符串，应设置为HKDF -
hash是一个字符串，包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512 -
salt是一个ArrayBuffer,TypedArray或DataView，表示随机或伪随机值，其长度与digest函数的输出长度相同。与传入deriveKey()的输入密钥材料不同，salt 不需要保密。 -
info是一个ArrayBuffer,TypedArray或DataView，表示特定于应用的上下文信息，用于将派生密钥绑定到应用或上下文，并允许在使用相同输入密钥材料的情况下为不同上下文派生不同的密钥。此属性是必需的，但可以是空缓冲区。
-
- 对于
PBKDF2，传入包含以下键的对象-
name是一个字符串，应设置为PBKDF2 -
hash是一个字符串，包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512 -
salt是一个ArrayBuffer,TypedArray或DataView，表示至少16字节的随机或伪随机值。与传入deriveKey()的输入密钥材料不同，salt 不需要保密。 -
iterations是一个number，表示在deriveKey()中执行哈希函数的次数
-
- 对于
baseKey- 是一个
CryptoKey对象，表示派生算法的输入 - 派生函数的初始密钥材料：例如，对于PBKDF2，它可能是一个密码，使用сrypto.subtle.importKey()导入为CryptoKey length- 是一个表示要派生位数的数字。为了兼容浏览器，该数字应为
8的倍数
сrypto.subtle.deriveKey(algorithm,baseKey,derivedKeyAlgorithm,extractable,keyUsages)- 从主密钥派生秘密密钥。可能的值
algorithm- 一个对象，定义要使用的派生算法
- 对于
HKDF，传入包含以下键的对象-
name是一个字符串，应设置为HKDF -
hash是一个字符串，包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512 -
salt是一个ArrayBuffer,TypedArray或DataView，表示随机或伪随机值，其长度与digest函数的输出长度相同。与传入deriveKey()的输入密钥材料不同，salt 不需要保密。 -
info是一个ArrayBuffer,TypedArray或DataView，表示特定于应用的上下文信息，用于将派生密钥绑定到应用或上下文，并允许在使用相同输入密钥材料的情况下为不同上下文派生不同的密钥。此属性是必需的，但可以是空缓冲区。
-
- 对于
PBKDF2，传入包含以下键的对象-
name是一个字符串，应设置为PBKDF2 -
hash是一个字符串，包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512 -
salt是一个ArrayBuffer,TypedArray或DataView，表示至少16字节的随机或伪随机值。与传入deriveKey()的输入密钥材料不同，salt 不需要保密。 -
iterations是一个number，表示在deriveKey()中执行哈希函数的次数
-
- 对于
baseKey- 是一个
CryptoKey对象，表示派生算法的输入 - 派生函数的初始密钥材料：例如，对于PBKDF2，它可能是一个密码，使用сrypto.subtle.importKey()导入为CryptoKey。 derivedKeyAlgorithm- 是一个对象，定义派生密钥将用于的算法
- 对于
HMAC，传入包含以下键的对象-
name是一个字符串，应设置为HMAC -
hash是一个字符串，包含要使用的摘要函数的名称：SHA-1,SHA-256,SHA-384或SHA-512 -
length（可选）是一个number，表示密钥的位长度。如果未指定，密钥的长度等于所选哈希函数的块大小
-
- 对于
AES-CTR,AES-CBC或AES-GCM，传入包含以下键的对象-
name是一个字符串，应根据使用的算法设置为AES-CTR,AES-CBC或AES-GCM -
length是一个number，表示要生成密钥的位长度：128,192或256
-
- 对于
extractable- 一个布尔值，指示是否可以导出密钥
keyUsages- 是一个
Array，指示可以使用派生密钥执行的操作。密钥用法必须由derivedKeyAlgorithm中设置的算法允许。可能的值encrypt- 用于加密消息的密钥
decrypt- 用于解密消息的密钥
sign- 用于签名消息的密钥
verify- 用于验证签名的密钥
deriveKey- 用于派生新密钥的密钥
deriveBits- 用于派生位的密钥
wrapKey- 用于包装密钥的密钥
unwrapKey- 用于解包密钥的密钥
сrypto.subtle.digest(algorithm,data)- 生成给定数据的摘要。接受要使用的摘要算法标识符和要摘要的数据作为参数。返回一个将以摘要兑现的
Promise。可能的值algorithm- 是一个字符串，定义要使用的哈希函数：
SHA-1（不适用于加密应用）,SHA-256,SHA-384或SHA-512 data- 是一个
ArrayBuffer,TypedArray或DataView，包含要摘要的数据
сrypto.subtle.exportKey(format,key)- 导出密钥：将密钥作为
CryptoKey对象传入，并以外部可移植格式返回密钥（自 0.7.10 版本起）。如果format是jwk，则Promise会以包含密钥的 JSON 对象兑现。否则，Promise 会以包含密钥的ArrayBuffer兑现。可能的值format- 一个字符串，描述密钥应导出的数据格式，可以是以下之一
raw- 原始数据格式
pkcs8- PKCS #8 格式
spki- SubjectPublicKeyInfo 格式
jwk- JSON Web Key (JWK) 格式（自 0.7.10 版本起）
key- 包含要导出密钥的
CryptoKey对象
сrypto.subtle.generateKey(algorithm,extractable,usage)- 为对称算法生成新密钥或为公钥算法生成密钥对（自 0.7.10 版本起）。返回一个
Promise，该 Promise 会以生成的密钥作为CryptoKey或CryptoKeyPair对象兑现。可能的值algorithm- 一个字典对象，定义要生成密钥的类型并提供额外的算法特定参数
- 对于
RSASSA-PKCS1-v1_5,RSA-PSS或RSA-OAEP，传入包含以下键的对象-
name是一个字符串，应根据使用的算法设置为RSASSA-PKCS1-v1_5,RSA-PSS或RSA-OAEP -
hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256,SHA-384或SHA-512
-
- 对于
ECDSA，传入包含以下键的对象-
name是一个字符串，应设置为ECDSA -
namedCurve是一个字符串，表示要使用的椭圆曲线的名称，可以是P-256,P-384或P-521
-
- 对于
HMAC，传入包含以下键的对象-
name是一个字符串，应设置为HMAC -
hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256,SHA-384或SHA-512 -
length（可选）是一个数字，表示密钥的位长度。如果省略，密钥的长度等于所选摘要函数生成的摘要长度。
-
- 对于
AES-CTR,AES-CBC或AES-GCM，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象，其中ALGORITHM是算法的名称
- 对于
extractable- 布尔值，指示是否可以导出密钥
usage- 一个
array，指示可以使用密钥执行的可能操作encrypt- 用于加密消息的密钥
decrypt- 用于解密消息的密钥
sign- 用于签名消息的密钥
verify- 用于验证签名的密钥
deriveKey- 用于派生新密钥的密钥
deriveBits- 用于派生位的密钥
wrapKey- 用于包装密钥的密钥
unwrapKey- 用于解包密钥的密钥
сrypto.subtle.importKey(format,keyData,algorithm,extractable,keyUsages)- 导入密钥：将外部可移植格式的密钥作为输入，并生成一个
CryptoKey对象。返回一个Promise，该 Promise 会以导入的密钥作为CryptoKey对象兑现。可能的值format- 一个字符串，描述要导入密钥的数据格式，可以是以下之一
raw- 原始数据格式
pkcs8- PKCS #8 格式
spki- SubjectPublicKeyInfo 格式
jwk- JSON Web Key (JWK) 格式（自 0.7.10 版本起）
keyData- 一个
ArrayBuffer,TypedArray或DataView对象，包含给定格式的密钥 algorithm- 一个字典对象，定义要导入密钥的类型并提供额外的算法特定参数
- 对于
RSASSA-PKCS1-v1_5,RSA-PSS或RSA-OAEP，传入包含以下键的对象-
name是一个字符串，应根据使用的算法设置为RSASSA-PKCS1-v1_5,RSA-PSS或RSA-OAEP -
hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-1,SHA-256,SHA-384或SHA-512
-
- 对于
ECDSA，传入包含以下键的对象-
name是一个字符串，应设置为ECDSA -
namedCurve是一个字符串，表示要使用的椭圆曲线的名称，可以是P-256,P-384或P-521
-
- 对于
HMAC，传入包含以下键的对象-
name是一个字符串，应设置为HMAC -
hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256,SHA-384或SHA-512 -
length（可选）是一个数字，表示密钥的位长度。如果省略，密钥的长度等于所选摘要函数生成的摘要长度。
-
- 对于
AES-CTR,AES-CBC或AES-GCM，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象，其中ALGORITHM是算法的名称 - 对于
PBKDF2，传入字符串PBKDF2 - 对于
HKDF，传入字符串HKDF
- 对于
extractable- 布尔值，指示是否可以导出密钥
keyUsages- 一个
array，指示可以使用密钥执行的可能操作encrypt- 用于加密消息的密钥
decrypt- 用于解密消息的密钥
sign- 用于签名消息的密钥
verify- 用于验证签名的密钥
deriveKey- 用于派生新密钥的密钥
deriveBits- 用于派生位的密钥
wrapKey- 用于包装密钥的密钥
unwrapKey- 用于解包密钥的密钥
сrypto.subtle.sign(algorithm,key,data)- 返回
signature作为Promise，该 Promise 以包含签名的ArrayBuffer兑现。可能的值algorithm- 是一个字符串或对象，指定要使用的签名算法及其参数
- 对于
RSASSA-PKCS1-v1_5，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象 - 对于
RSA-PSS，传入包含以下键的对象-
name是一个字符串，应设置为RSA-PSS -
saltLength是一个长integer，表示要使用的随机 salt 的长度，以字节为单位
-
- 对于
ECDSA，传入包含以下键的对象-
name是一个字符串，应设置为ECDSA -
hash是要使用的摘要算法的标识符，可以是SHA-256,SHA-384或SHA-512
-
- 对于
HMAC，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象
- 对于
key- 是一个
CryptoKey对象，表示用于签名的密钥。如果算法标识公钥密码系统，则这是私钥。 data- 是一个
ArrayBuffer,TypedArray或DataView对象，包含要签名的数据
сrypto.subtle.verify(algorithm,key,signature,data)- 验证数字签名，返回一个以布尔值兑现的
Promise：如果签名有效则为true，否则为false。可能的值algorithm- 是一个字符串或对象，指定要使用的算法及其参数
- 对于
RSASSA-PKCS1-v1_5，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象 - 对于
RSA-PSS，传入包含以下键的对象-
name是一个字符串，应设置为RSA-PSS -
saltLength是一个长integer，表示要使用的随机 salt 的长度，以字节为单位
-
- 对于
ECDSA，传入包含以下键的对象-
name是一个字符串，应设置为ECDSA -
hash是要使用的摘要算法的标识符，可以是SHA-256,SHA-384或SHA-512
-
- 对于
HMAC，传入标识算法的字符串或形式为{ "name": "ALGORITHM" }的对象
- 对于
key- 是一个
CryptoKey对象，表示用于验证的密钥。对于对称算法是秘密密钥，对于公钥系统是公钥。 signature- 是一个
ArrayBuffer,TypedArray或DataView，包含要验证的签名 data- 是一个
ArrayBuffer,TypedArray或DataView对象，包含其签名要验证的数据
CryptoKey
CryptoKey.algorithm |
CryptoKey.extractable |
CryptoKey.type |
CryptoKey.usages |
CryptoKey 对象表示通过 SubtleCrypto 方法之一（сrypto.subtle.generateKey(), сrypto.subtle.deriveKey(), сrypto.subtle.importKey()）获取的加密 key。
CryptoKey.algorithm- 返回一个对象，描述此密钥可用于的算法以及任何相关的额外参数（自 0.8.0 版本起），只读
CryptoKey.extractable- 一个布尔值，如果密钥可以导出则为
true（自 0.8.0 版本起），只读 CryptoKey.type- 一个字符串值，指示对象表示的密钥类型，只读。可能的值
secret- 此密钥是用于对称算法的秘密密钥。
private- 此密钥是非对称算法的
CryptoKeyPair的私钥部分。 public- 此密钥是非对称算法的
CryptoKeyPair的公钥部分。
CryptoKey.usages- 一个字符串数组，指示此密钥可用于的操作（自 0.8.0 版本起），只读。可能的数组值
encrypt- 用于加密消息的密钥
decrypt- 用于解密消息的密钥
sign- 用于签名消息的密钥
verify- 用于验证签名的密钥
deriveKey- 用于派生新密钥的密钥
deriveBits- 用于派生位的密钥
CryptoKeyPair
CryptoKeyPair.privateKey |
CryptoKeyPair.publicKey |
CryptoKeyPair 是 WebCrypto API 的一个字典对象，表示非对称密钥对。
njs
njs.version |
njs.version_number |
njs.dump() |
njs.memoryStats |
njs.on() |
njs 对象是一个全局对象，表示当前的 VM 实例（自 0.2.0 版本起）。
njs.version- 返回一个字符串，包含 njs 的当前版本（例如，“0.7.4”）。
njs.version_number- 返回一个数字，包含 njs 的当前版本。例如，“0.7.4” 返回为
0x000704（自 0.7.4 版本起）。 njs.dump(value)- 返回值的漂亮打印字符串表示。
njs.memoryStats- 包含当前 VM 实例内存统计信息的对象（自 0.7.8 版本起）。
size- njs 内存池从操作系统申请的内存量，以字节为单位。
njs.on(event,callback)- 为指定的 VM 事件注册回调（自 0.5.2 版本起）。事件可以是以下字符串之一
exit- 在 VM 销毁之前调用。回调在没有参数的情况下调用。
process
process.argv |
process.env |
process.kill() |
process.pid |
process.ppid |
process 对象是一个全局对象，提供关于当前进程的信息（自 0.3.3 版本起）。
process.argv- 返回一个数组，包含当前进程启动时传递的命令行参数。
process.env- 返回一个包含用户环境的对象。
默认情况下，nginx 会移除除 TZ 变量外所有继承自其父进程的环境变量。使用 env 指令可以保留一些继承的变量。
process.kill(pid,number|string)- 向由
pid标识的进程发送信号。信号名称可以是数字或字符串，例如 'SIGINT' 或 'SIGHUP'。有关详细信息，请参阅 kill(2)。 process.pid- 返回当前进程的 PID。
process.ppid- 返回当前父进程的 PID。
String
默认情况下，njs 中的所有字符串都是 Unicode 字符串。它们对应于包含 Unicode 字符的 ECMAScript 字符串。在 0.8.0 版本之前，还支持字节字符串。
字节字符串
自 0.8.0 版本起，移除了对字节字符串和字节字符串方法的支持。处理字节序列时，应使用 Buffer 对象和Buffer属性，例如r.requestBuffer,r.rawVariables。
字节字符串包含一个字节序列，用于将 Unicode 字符串序列化到外部数据并从外部源反序列化。例如，toUTF8() 方法使用 UTF-8 编码将 Unicode 字符串序列化为字节字符串
>> '£'.toUTF8().toString('hex')
'c2a3' /* C2 A3 is the UTF-8 representation of 00A3 ('£') code point */
当码点小于等于 255 时，toBytes() 方法将 Unicode 字符串序列化为字节字符串，否则返回 null
>> '£'.toBytes().toString('hex')
'a3' /* a3 is a byte equal to 00A3 ('£') code point */
String.bytesFrom(array|string,encoding)- 该方法在 0.4.4 版本中被废弃，并在 0.8.0 版本中移除。应改用
Buffer.from方法
在 0.4.4 版本之前，可以从包含八位字节的数组或编码字符串（0.2.3）创建字节字符串，编码可以是>> Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]).toString() 'buffer' >> Buffer.from('YnVmZmVy', 'base64').toString() 'buffer'hex,base64和base64url。 String.prototype.fromBytes(start[,end])- 该属性在 0.7.7 版本中被废弃，并在 0.8.0 版本中移除。在 0.7.7 版本之前，从字节字符串返回一个新的 Unicode 字符串，其中每个字节被替换为相应的 Unicode 码点。
String.prototype.fromUTF8(start[,end])- 该属性在 0.7.7 版本中被废弃，并在 0.8.0 版本中移除。应改用
TextDecoder方法。在 0.7.7 版本之前，将包含有效 UTF-8 字符串的字节字符串转换为 Unicode 字符串，否则返回null。 String.prototype.toBytes(start[,end])- 该属性在 0.7.7 版本中被废弃，并在 0.8.0 版本中移除。在 0.7.7 版本之前，将 Unicode 字符串序列化为字节字符串，如果在字符串中找到大于 255 的字符则返回
null。 String.prototype.toString(encoding)-
该属性在 0.7.7 版本中被废弃，并在 0.8.0 版本中移除。在 0.7.7 版本之前，可以将字符串编码为
hex,base64或base64url>> 'αβγδ'.toString('base64url') 'zrHOss6zzrQ'>> 'αβγδ'.toUTF8().toString('base64url') 'zrHOss6zzrQ' String.prototype.toUTF8(start[,end])- 该属性在 0.7.7 版本中被废弃，并在 0.8.0 版本中移除。应改用
TextEncoder方法。在 0.7.7 版本之前，使用 UTF-8 编码将 Unicode 字符串序列化为字节字符串>> 'αβγδ'.toUTF8().length 8 >> 'αβγδ'.length 4
Web API
Text Decoder
TextDecoder() |
TextDecoder.prototype.encoding |
TextDecoder.prototype.fatal |
TextDecoder.prototype.ignoreBOM |
TextDecoder.prototype.decode() |
TextDecoder 从字节流生成码点流（自 0.4.3 版本起）。
TextDecoder([[encoding],options]])- 为指定的
encoding创建一个新的TextDecoder对象，目前仅支持 UTF-8。options是一个TextDecoderOptions字典，包含属性fatal- 布尔标志，指示当发现编码错误时，
TextDecoder.decode()是否必须抛出TypeError异常，默认为false。
TextDecoder.prototype.encoding- 返回一个字符串，包含
TextDecoder()使用的编码名称，只读。 TextDecoder.prototype.fatal- 布尔标志，如果错误模式是致命的则为
true，只读。 TextDecoder.prototype.ignoreBOM- 布尔标志，如果忽略字节顺序标记则为
true，只读。 TextDecoder.prototype.decode(buffer, [options])- 返回一个字符串，其中包含由
TextDecoder()从buffer解码的文本。buffer 可以是ArrayBuffer。options是一个TextDecodeOptions字典，包含属性stream- 布尔标志，指示后续对
decode()的调用是否会跟进附加数据：如果是分块处理数据，则为true；如果是最终块或数据未分块，则为false。默认为false。
>> (new TextDecoder()).decode(new Uint8Array([206,177,206,178])) αβ
Text Encoder
TextEncoder() |
TextEncoder.prototype.encode() |
TextEncoder.prototype.encodeInto() |
TextEncoder 对象从码点流生成带有 UTF-8 编码的字节流（自 0.4.3 版本起）。
TextEncoder()- 返回新构建的
TextEncoder，它将生成带有 UTF-8 编码的字节流。 TextEncoder.prototype.encode(string)- 将
string编码为包含 UTF-8 编码文本的Uint8Array。 TextEncoder.prototype.encodeInto(string,uint8Array)- 将
string编码为 UTF-8，将结果放入目标Uint8Array，并返回一个显示编码进度的字典对象。该字典对象包含两个成员read- 从源
string转换为 UTF-8 的 UTF-16 代码单元数 written- 目标
Uint8Array中修改的字节数
timers
clearTimeout() |
setTimeout() |
clearTimeout(timeout)- 取消由
setTimeout()创建的timeout对象。 setTimeout(function,milliseconds[,argument1,argumentN])- 在指定的
milliseconds毫秒数后调用一个function。一个或多个可选的arguments可以传递给指定的函数。返回一个timeout对象。function handler(v) { // ... } t = setTimeout(handler, 12); // ... clearTimeout(t);
全局函数
atob() |
btoa() |
atob(encodedData)- 解码已使用
Base64编码的数据字符串。encodedData参数是一个包含 Base64 编码数据的二进制字符串。返回一个包含从encodedData解码的数据的字符串。类似的
btoa()方法可用于编码和传输可能导致通信问题的数据，然后进行传输并使用atob()方法再次解码数据。例如，您可以编码、传输和解码控制字符，例如 ASCII 值0到31。const encodedData = btoa("text to encode"); // encode a string const decodedData = atob(encodedData); // decode the string btoa(stringToEncode)- 从二进制字符串创建一个 Base64 编码的 ASCII 字符串。
stringToEncode参数是要编码的二进制字符串。返回一个包含stringToEncode的 Base64 表示的 ASCII 字符串。该方法可用于编码可能导致通信问题的数据，然后进行传输，并使用
atob()方法再次解码数据。例如，您可以编码控制字符，例如 ASCII 值0到31。const encodedData = btoa("text to encode"); // encode a string const decodedData = atob(encodedData); // decode the string
内建模块
Buffer
Buffer.alloc(size[,fill[,encoding]]))-
分配一个指定
size的新 Buffer。如果没有指定fill，Buffer 将会被零填充。如果指定了fill，分配的 Buffer 将通过调用buf.fill(fill)进行初始化。如果指定了fill和encoding，分配的 Buffer 将通过调用buf.fill(fill, encoding)进行初始化。fill参数可以是string、Buffer、Uint8Array或integer。 Buffer.allocUnsafe(size)-
与
Buffer.alloc()相同，区别在于为 Buffer 分配的内存没有被初始化，新 Buffer 的内容是未知的，可能包含敏感数据。 Buffer.byteLength(value[,encoding])- 返回一个指定值的字节长度，使用
encoding进行编码时。该值可以是string、Buffer、TypedArray、DataView或ArrayBuffer。如果该值是string，则encoding参数为其编码，可以是utf8、hex、base64、base64url；默认为utf8。 Buffer.compare(buffer1,buffer2)- 在对 Buffer 实例数组进行排序时，比较
buffer1和buffer2。如果buffer1与buffer2相同，则返回0；如果排序时buffer2应该在buffer1之前，则返回1；如果排序时buffer2应该在buffer1之后，则返回-1。 Buffer.concat(list[,totalLength])- 返回一个新 Buffer，它是列表中所有 Buffer 实例连接的结果。如果列表中没有项或总长度为 0，则返回一个新的零长度 Buffer。如果没有指定
totalLength，则通过将列表中 Buffer 实例的长度相加来计算。如果指定了totalLength，则将其强制转换为无符号整数。如果列表中 Buffers 的总长度超过totalLength，则结果将被截断为totalLength。 Buffer.from(array)- 使用一个字节范围在
0到255之间的数组来分配一个新的 Buffer。超出该范围的数组条目将被截断。 Buffer.from(arrayBuffer,byteOffset[,length]])- 创建
ArrayBuffer的视图，而不复制底层内存。可选的byteOffset和length参数指定arrayBuffer中将由 Buffer 共享的内存范围。 Buffer.from(buffer)- 将传入的 Buffer 数据复制到新的 Buffer 实例中。
Buffer.from(object[,offsetOrEncoding[,length]])- 对于其
valueOf()函数返回的值与对象不严格相等（!==）的对象，返回Buffer.from(object.valueOf(),offsetOrEncoding,length)。 Buffer.from(string[,encoding])- 使用
string创建一个新的 Buffer。encoding参数指定将字符串转换为字节时使用的字符编码。编码可以是utf8、hex、base64、base64url；默认为utf8。 Buffer.isBuffer(object)- 一个布尔值，如果
object是 Buffer，则返回true。 Buffer.isEncoding(encoding)- 一个布尔值，如果
encoding是支持的字符编码的名称，则返回true。 buffer[index]- 索引操作符，可用于获取和设置
buffer中位置index的八位字节。这些值表示单个字节，因此合法的值范围是 0 到 255（十进制）。 buf.buffer- 此 Buffer 对象基于其创建的底层
ArrayBuffer对象。 buf.byteOffset- 一个整数，指定 Buffer 的底层
ArrayBuffer对象的byteOffset。 buf.compare(target[,targetStart[,targetEnd[,sourceStart[,sourceEnd]]]])- 将 Buffer 与
target进行比较，并返回一个数字，指示 Buffer 在排序顺序上是位于target之前、之后还是与target相同。比较基于每个 Buffer 中实际的字节序列。targetStart是一个整数，指定在target内开始比较的偏移量，默认为 0。targetEnd是一个整数，指定在target内结束比较的偏移量（不包含），默认为target.length。sourceStart是一个整数，指定在 Buffer 内开始比较的偏移量，默认为 0。sourceEnd是一个整数，指定在 Buffer 内结束比较的偏移量（不包含），默认为buf.length。 buf.copy(target[,targetStart[,sourceStart[,sourceEnd]]])- 将数据从 Buffer 的某个区域复制到
target的某个区域，即使目标内存区域与 Buffer 重叠。target参数是要复制到的Buffer或Uint8Array。targetStart是一个整数，指定在 target 内开始写入的偏移量，默认为 0。sourceStart是一个整数，指定从 Buffer 内开始复制的偏移量，默认为 0。sourceEnd是一个整数，指定在 Buffer 内停止复制（不包含）的偏移量，默认为buf.length。 buf.equals(otherBuffer)- 一个布尔值，如果 Buffer 和
otherBuffer的字节完全相同，则返回true。 buf.fill(value[,offset[,end]][,encoding])- 用指定的
value填充 Buffer。如果未指定offset和end，则填充整个 Buffer。如果value不是string、Buffer或integer，则会被强制转换为uint32。如果生成的整数大于 255，Buffer 将填充value与 255 相与的结果（即截断为单字节）。 buf.includes(value[,byteOffset][,encoding])- 等同于
buf.indexOf()!== -1，如果 Buffer 中找到了value，则返回true。 buf.indexOf(value[,byteOffset][,encoding])- 返回一个整数，它是
value在 Buffer 中第一次出现的索引，如果 Buffer 不包含 value，则返回-1。value可以是带有指定encoding（默认为utf8）的string、Buffer、Unit8Array，或者是 0 到 255 之间的数字。 buf.lastIndexOf(value[,byteOffset][,encoding])- 与
buf.indexOf()相同，但找到的是value最后一次出现的位置而不是第一次。value可以是字符串、Buffer 或 1 到 255 之间的整数。如果value是空字符串或空 Buffer，则返回byteOffset。 buf.length- 返回 Buffer 中的字节数。
buf.readIntBE(offset,byteLength)- 从
buf中指定offset位置读取byteLength个字节，并将结果解释为大端序（big-endian）、使用二进制补码的有符号值，支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。还支持类似的方法：
buf.readInt8([offset])、buf.readInt16BE([offset])、buf.readInt32BE([offset])。 buf.readIntLE(offset,byteLength)- 从
buf中指定offset位置读取byteLength个字节，并将结果解释为小端序（little-endian）、使用二进制补码的有符号值，支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。还支持类似的方法：
buf.readInt8([offset])、buf.readInt16LE([offset])、buf.readInt32LE([offset])。 buf.readUIntBE(offset,byteLength)- 从
buf中指定offset位置读取byteLength个字节，并将结果解释为大端序（big-endian）的无符号整数，支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。还支持类似的方法：
buf.readUInt8([offset])、buf.readUInt16BE([offset])、buf.readUInt32BE([offset])。 buf.readUIntLE(offset,byteLength)- 从
buf中指定offset位置读取byteLength个字节，并将结果解释为小端序（little-endian）的无符号整数，支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。还支持类似的方法：
buf.readUInt8([offset])、buf.readUInt16LE([offset])、buf.readUInt32LE([offset])。 buf.readDoubleBE([offset])- 从
buf中指定offset位置读取一个 64 位大端序双精度浮点数。 buf.readDoubleLE([offset])- 从
buf中指定offset位置读取一个 64 位小端序双精度浮点数。 buf.readFloatBE([offset])- 从
buf中指定offset位置读取一个 32 位大端序单精度浮点数。 buf.readFloatLE([offset])- 从
buf中指定offset位置读取一个 32 位小端序单精度浮点数。 buf.subarray([start[,end]])- 返回一个新的
buf，它引用与原始 Buffer 相同的内存，但通过start和end进行了偏移和裁剪。如果end大于buf.length，则返回与 end 等于buf.length时相同的结果。 buf.slice([start[,end]])- 返回一个新的
buf，它引用与原始 Buffer 相同的内存，但通过start和end值进行了偏移和裁剪。该方法与Uint8Array.prototype.slice()不兼容，后者是 Buffer 的超类。要复制切片，请使用Uint8Array.prototype.slice()。 buf.swap16()- 将
buf解释为一个无符号 16 位数字的数组，并就地（in-place）交换字节顺序。如果buf.length不是 2 的倍数，则抛出错误。 buf.swap32()- 将
buf解释为一个无符号 32 位数字的数组，并就地交换字节顺序。如果buf.length不是 4 的倍数，则抛出错误。 buf.swap64()- 将
buf解释为一个 64 位数字的数组，并就地交换字节顺序。如果buf.length不是 8 的倍数，则抛出错误。 buf.toJSON()- 返回
buf的 JSON 表示。JSON.stringify()在字符串化 Buffer 实例时会隐式调用此函数。 buf.toString([encoding[,start[,end]]])- 根据指定的字符
encoding将buf解码为字符串，编码可以是utf8、hex、base64、base64url。可以传入start和end参数以仅解码 Buffer 的子集。 buf.write(string[,offset[,length]][,encoding])- 根据字符
encoding将string写入buf的offset位置。length参数是要写入的字节数。如果 Buffer 没有足够的空间容纳整个字符串，则只会写入字符串的一部分，但是，不会写入部分编码的字符。encoding可以是utf8、hex、base64、base64url。 buf.writeIntBE(value,offset,byteLength)- 将
value的byteLength个字节作为大端序写入buf的指定offset位置。支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要写入的字节数。还支持以下类似方法：
buf.writeInt8、buf.writeInt16BE、buf.writeInt32BE。 buf.writeIntLE(value,offset,byteLength)- 将
value的byteLength个字节作为小端序写入buf的指定offset位置。支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要写入的字节数。还支持以下类似方法：
buf.writeInt8、buf.writeInt16LE、buf.writeInt32LE。 buf.writeUIntBE(value,offset,byteLength)- 将
value的byteLength个字节作为大端序写入buf的指定offset位置。支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要写入的字节数。还支持以下类似方法：
buf.writeUInt8、buf.writeUInt16BE、buf.writeUInt32BE。 buf.writeUIntLE(value,offset,byteLength)- 将
value的byteLength个字节作为小端序写入buf的指定offset位置。支持高达 48 位的精度。byteLength参数是一个介于 1 和 6 之间的整数，指定要写入的字节数。还支持以下类似方法：
buf.writeUInt8、buf.writeUInt16LE、buf.writeUInt32LE。 buf.writeDoubleBE(value, [offset])- 将
value作为大端序写入buf的指定offset位置。 buf.writeDoubleLE(value, [offset])- 将
value作为小端序写入buf的指定offset位置。 buf.writeFloatBE(value, [offset])- 将
value作为大端序写入buf的指定offset位置。 buf.writeFloatLE(value, [offset])- 将
value作为小端序写入buf的指定offset位置。
Crypto
crypto.createHash() |
crypto.createHmac() |
自 0.7.0 起，扩展的 crypto API 可作为全局 crypto 对象使用。
Crypto 模块提供加密功能支持。Crypto 模块对象通过 import crypto from 'crypto' 导入。
crypto.createHash(algorithm)- 创建并返回一个 Hash 对象，该对象可用于使用给定的
algorithm生成哈希摘要。算法可以是md5、sha1和sha256。 crypto.createHmac(algorithm,secret key)- 创建并返回一个 HMAC 对象，该对象使用给定的
algorithm和secret key。算法可以是md5、sha1和sha256。
Hash
hash.update() |
hash.digest() |
hash.update(data)- 使用给定的
data更新哈希内容。 hash.digest([encoding])- 计算通过
hash.update()传入的所有数据的摘要。编码可以是hex、base64和base64url。如果未提供编码，则返回 Buffer 对象（0.4.4）。在 0.4.4 版本之前，返回的是字节字符串而不是 Buffer 对象。
hash.copy()- 复制哈希的当前状态（自 0.7.12 起）。
import crypto from 'crypto';
crypto.createHash('sha1').update('A').update('B').digest('base64url');
/* BtlFlCqiamG-GMPiK_GbvKjdK10 */
HMAC
hmac.update() |
hmac.digest() |
hmac.update(data)- 使用给定的
data更新 HMAC 内容。 hmac.digest([encoding])- 计算通过
hmac.update()传入的所有数据的 HMAC 摘要。编码可以是hex、base64和base64url。如果未提供编码，则返回 Buffer 对象（0.4.4）。在 0.4.4 版本之前，返回的是字节字符串而不是 Buffer 对象。
import crypto from 'crypto';
crypto.createHmac('sha1', 'secret.key').update('AB').digest('base64url');
/* Oglm93xn23_MkiaEq_e9u8zk374 */
File System
fs.Dirent |
fs.FileHandle |
fs.Stats |
File Access Constants |
File System Flags |
文件系统模块提供了文件操作功能。
模块对象通过 import fs from 'fs' 导入。自 0.3.9 起，通过 import fs from 'fs' 导入后，可以通过 fs.promises 对象获取文件系统方法的 Promise 版本。
import fs from 'fs';
fs.promises.readFile("/file/path").then((data) => {
/* <file data> */
});
accessSync(path[,mode])- 同步测试指定
path的文件或目录的权限（0.3.9）。如果检查失败，将返回一个错误，否则，方法返回 undefined。mode- 一个可选整数，指定要执行的可访问性检查，默认为
fs.constants.F_OK。try { fs.accessSync('/file/path', fs.constants.R_OK | fs.constants.W_OK); console.log('has access'); } catch (e) { console.log('no access');) }
appendFileSync(filename,data[,options])- 同步将指定
data附加到提供的filename文件中。data预期为字符串或 Buffer 对象（0.4.4）。如果文件不存在，将被创建。options参数预期为一个对象，包含以下键：mode- 模式选项，默认为
0o666。 flag- 文件系统 flag，默认为
a。
closeSync(fd)- 关闭由方法使用的整数表示的文件描述符
fd。返回undefined。 existsSync(path)- 布尔值，如果指定的
path存在，则返回true。（0.8.2） fstatSync(fd)- 检索文件描述符的
fs.Stats对象（0.7.7）。fd参数是方法使用的整数表示的文件描述符。 lstatSync(path[,options])- 同步检索由
path引用的符号链接的fs.Stats对象（0.7.1）。options参数预期为一个对象，包含以下键：throwIfNoEntry- 一个布尔值，指示如果文件系统条目不存在是抛出异常还是返回
undefined，默认为false。
mkdirSync(path[,options])- 同步在指定的
path位置创建目录（0.4.2）。options参数预期为一个指定 mode 的integer，或一个包含以下键的对象：mode- 模式选项，默认为
0o777。
openSync(path[,flags[,mode]])- 返回打开文件
path的文件描述符，表示为一个整数（0.7.7）。flags- 文件系统 flag，默认为
r。 mode- 模式选项，默认为
0o666。
promises.open(path[,flags[,mode]])- 返回一个表示打开文件
path的FileHandle对象（0.7.7）。flags- 文件系统 flag，默认为
r。 mode- 模式选项，默认为
0o666。
readdirSync(path[,options])- 同步读取指定
path目录的内容（0.4.2）。options参数预期为一个指定 encoding 的字符串，或一个包含以下键的对象： readFileSync(filename[,options])- 同步返回提供的
filename文件内容。options参数可以是指定编码的string。如果指定了编码，则返回字符串，否则返回 Buffer 对象（0.4.4）。在 0.4.4 版本之前，如果未指定编码，则返回 byte string。
否则，options预期为一个包含以下键的对象：import fs from 'fs'; var file = fs.readFileSync('/file/path.tar.gz'); console.log(file.slice(0,2).toString('hex')) /* '1f8b' */ readlinkSync(path[,options])- 使用 readlink(2) 同步获取符号链接
path的内容（0.8.7）。options参数可以是指定编码的字符串，或一个带有encoding属性的对象，指定用于传递给回调的路径的字符编码。如果encoding是buffer，结果将作为Buffer对象返回，否则作为字符串返回。 readSync(fd,buffer,offset[,length[,position]])- 使用文件描述符
fd读取文件路径的内容，返回读取的字节数（0.7.7）。bufferbuffer值可以是Buffer、TypedArray或DataView。offset- 一个
integer，表示在 buffer 中写入数据的位置。 length- 一个
integer，表示要读取的字节数。 position- 指定从文件中开始读取的位置，值可以是
integer或null，默认为null。如果position是null，将从当前文件位置读取数据，并且文件位置将更新。如果 position 是一个integer，文件位置将保持不变。
realpathSync(path[,options])- 使用 realpath(3) 通过解析
.、..和符号链接来同步计算规范路径名。options参数可以是指定编码的字符串，或一个带有编码属性的对象，指定用于传递给回调的路径的字符编码（0.3.9）。 renameSync(oldPath,newPath)- 同步更改文件的名称或位置，从
oldPath改为newPath（0.3.4）。import fs from 'fs'; fs.renameSync('hello.txt', 'HelloWorld.txt'); rmdirSync(path)- 同步移除指定
path的目录（0.4.2）。 statSync(path,[options])- 同步检索指定
path的fs.Stats对象（0.7.1）。path可以是string或buffer。options参数预期为一个对象，包含以下键：throwIfNoEntry- 一个布尔值，指示如果文件系统条目不存在是抛出异常还是返回
undefined，默认为true。
symlinkSync(target,path)- 使用 symlink(2) 同步创建名为
path指向target的链接（0.3.9）。相对目标是相对于链接的父目录。 unlinkSync(path)- 通过
path同步取消链接文件（0.3.9）。 writeFileSync(filename,data[,options])- 同步将
data写入提供的filename文件中。data预期为字符串或 Buffer 对象（0.4.4）。如果文件不存在，将被创建；如果文件存在，将被替换。options参数预期为一个对象，包含以下键：mode- 模式选项，默认为
0o666。 flag- 文件系统 flag，默认为
w。
import fs from 'fs'; fs.writeFileSync('hello.txt', 'Hello world'); writeSync(fd,buffer,offset[,length[,position]])- 使用文件描述符将 Buffer 写入文件，返回写入的字节
number（0.7.7）。fd- 一个
integer，表示文件描述符。 bufferbuffer值可以是Buffer、TypedArray或DataView。offset- 一个
integer，确定要写入的 Buffer 的哪一部分，默认为0。 length- 一个
integer，指定要写入的字节数，默认为 Buffer.byteLength 的偏移量。 position- 指从此数据应写入的文件开头的偏移量，可以是
integer或null，默认为null。另请参阅 pwrite(2)。
writeSync(fd,string[,position[,encoding]])- 使用文件描述符
fd将string写入文件，返回写入的字节number（0.7.7）。fd- 一个
integer，表示文件描述符。 position- 指从此数据应写入的文件开头的偏移量，可以是
integer或null，默认为null。另请参阅 pwrite(2)。 encoding- 一个
string，默认为utf8。
fs.Dirent
fs.Dirent 表示一个目录条目 — 一个文件或子目录。当调用带有 withFileTypes 选项的 readdirSync() 时，结果数组包含 fs.Dirent 对象。
-
dirent.isBlockDevice()— 如果fs.Dirent对象描述了一个块设备，则返回true。 -
dirent.isCharacterDevice()— 如果fs.Dirent对象描述了一个字符设备，则返回true。 -
dirent.isDirectory()— 如果fs.Dirent对象描述了一个文件系统目录，则返回true。 -
dirent.isFIFO()— 如果fs.Dirent对象描述了一个先进先出（FIFO）管道，则返回true。 -
dirent.isFile()— 如果fs.Dirent对象描述了一个普通文件，则返回true。 -
dirent.isSocket()— 如果fs.Dirent对象描述了一个套接字，则返回true。 -
dirent.isSymbolicLink()— 如果fs.Dirent对象描述了一个符号链接，则返回true。 -
dirent.name—fs.Dirent对象引用的文件名。
fs.FileHandle
filehandle.close() |
filehandle.fd |
filehandle.read() |
filehandle.stat() |
filehandle.write( |
filehandle.write( |
FileHandle 对象是数字文件描述符的对象包装器（0.7.7）。FileHandle 对象的实例由 fs.promises.open() 方法创建。如果一个 FileHandle 没有使用 filehandle.close() 方法关闭，它会尝试自动关闭文件描述符，从而帮助防止内存泄漏。请不要依赖这种行为，因为它可能不可靠。相反，请始终显式关闭 FileHandle。
filehandle.close()- 等待该句柄上所有待处理的操作完成后，关闭文件句柄。返回一个
promise，成功时以 undefined 实现（fulfill）。 filehandle.fd- 由
FileHandle对象管理的数字文件描述符。 filehandle.read(buffer,offset[,length[,position]])- 从文件读取数据并存储到给定的 buffer 中。
buffer- 一个将被读取的文件数据填充的 buffer，值可以是
Buffer、TypedArray或DataView。 offset- 一个
integer，表示在 buffer 中开始填充数据的位置。 length- 一个
integer，表示要读取的字节数。 position- 从文件中开始读取数据的位置，值可以是
integer或null。如果为null，将从当前文件位置读取数据并更新位置。如果 position 是一个integer，当前文件位置将保持不变。
Promise，成功时以一个包含两个属性的对象实现：bytesRead- 一个
integer，表示读取的字节数。 buffer- 对 buffer 中传入参数的引用，可以是
Buffer、TypedArray或DataView。
filehandle.stat()- 以文件的 fs.Stats 实现 Promise，返回一个
promise。 filehandle.write(buffer,offset[,length[,position]])- 将 buffer 写入文件。
bufferbuffer值可以是Buffer、TypedArray或DataView。offset- 一个
integer，表示从 buffer 内部开始写入数据的位置。 length- 一个
integer，表示要从 buffer 中写入的字节数，默认为 Buffer.byteLength 的偏移量。 position- 从文件开头处写入 buffer 数据的偏移量，可以是
integer或null，默认为null。如果position不是一个number，数据将写入当前位置。详细信息请参阅 POSIX pwrite(2) 文档。
Promise，该 Promise 解析为一个包含两个属性的对象：bytesWritten- 一个
integer，表示写入的字节数。 buffer- 对已写入 buffer 的引用，可以是
Buffer、TypedArray或DataView。
在同一个文件上多次使用
filehandle.write()而不等待 Promise 解析或拒绝是不安全的。 filehandle.write(string[,position[,encoding]])- 将
string写入文件。position- 从文件开头处写入 buffer 数据的偏移量，可以是
integer或null，默认为null。如果position不是一个number，数据将写入当前位置。详细信息请参阅 POSIX pwrite(2) 文档。 encoding- 字符串的预期编码，默认为
utf8。
Promise，该 Promise 解析为一个包含两个属性的对象：bytesWritten- 一个
integer，表示写入的字节数。 buffer- 对已写入 buffer 的引用，可以是
Buffer、TypedArray或DataView。
在同一个文件上多次使用
filehandle.write()而不等待 Promise 解析或拒绝是不安全的。
fs.Stats
fs.Stats 对象提供文件信息。该对象由 fs.statSync() 和 fs.lstatSync() 返回。
-
stats.isBlockDevice()— 如果fs.Stats对象描述了块设备，则返回true。 -
stats.isDirectory()— 如果fs.Stats对象描述了文件系统目录，则返回true。 -
stats.isFIFO()— 如果fs.Stats对象描述了先进先出（FIFO）管道，则返回true。 -
stats.isFile()— 如果fs.Stats对象描述了普通文件，则返回true。 -
stats.isSocket()— 如果fs.Stats对象描述了套接字，则返回true。 -
stats.isSymbolicLink()— 如果fs.Stats对象描述了符号链接，则返回true。 -
stats.dev— 包含文件的设备的数字标识符。 -
stats.ino— 文件的文件系统特定Inode号。 -
stats.mode— 一个位字段，描述文件类型和模式。 -
stats.nlink— 文件的硬链接数。 -
stats.uid— 拥有文件的用户的数字用户标识符（POSIX）。 -
stats.gid— 拥有文件的组的数字组标识符（POSIX）。 -
stats.rdev— 如果文件表示设备，则为数字设备标识符。 -
stats.size— 文件的字节大小。 -
stats.blksize— 用于 I/O 操作的文件系统块大小。 -
stats.blocks— 为此文件分配的块数。 -
stats.atimeMs— 指示自 POSIX Epoch 以来文件最后一次被访问的时间戳，以毫秒表示。 -
stats.mtimeMs— 指示自 POSIX Epoch 以来文件最后一次被修改的时间戳，以毫秒表示。 -
stats.ctimeMs— 指示自 POSIX Epoch 以来文件最后一次被更改的时间戳，以毫秒表示。 -
stats.birthtimeMs— 指示自 POSIX Epoch 以来文件创建的时间戳，以毫秒表示。 -
stats.atime— 指示文件最后一次被访问的时间戳。 -
stats.mtime— 指示文件最后一次被修改的时间戳。 -
stats.ctime— 指示文件最后一次被更改的时间戳。 -
stats.birthtime— 指示文件创建的时间戳。
File Access Constants
access() 方法可以接受以下标志。这些标志由 fs.constants 导出：
-
F_OK— 指示文件对调用进程可见，如果未指定模式，则默认使用此项。 -
R_OK— 指示文件可被调用进程读取。 -
W_OK— 表示文件可由调用进程写入 -
X_OK— 表示文件可由调用进程执行
File System Flags
该 flag 选项可接受以下值
-
a— 打开文件进行追加。如果文件不存在，则创建该文件 -
ax— 与a相同，但如果文件已存在则失败 -
a+— 打开文件进行读写和追加。如果文件不存在，则将创建它 -
ax+— 与a+相同，但如果文件已存在则失败 -
as— 以同步模式打开文件进行追加。如果文件不存在，则将创建它 -
as+— 以同步模式打开文件进行读写和追加。如果文件不存在，则将创建它 -
r— 打开文件进行读取。如果文件不存在，则会发生异常 -
r+— 打开文件进行读写。如果文件不存在，则会发生异常 -
rs+— 以同步模式打开文件进行读写。指示操作系统绕过本地文件系统缓存 -
w— 打开文件进行写入。如果文件不存在，则将创建它。如果文件存在，则将替换它 -
wx— 与w相同，但如果文件已存在则失败 -
w+— 打开文件进行读写。如果文件不存在，则将创建它。如果文件存在，则将替换它 -
wx+— 与w+相同，但如果文件已存在则失败
Query String
querystring.decode() |
querystring.encode() |
querystring.escape() |
querystring.parse() |
querystring.stringify() |
querystring.unescape() |
Query String 模块提供了解析和格式化 URL 查询字符串的支持 (0.4.3)。使用以下方式导入 Query String 模块对象： import qs from 'querystring'。
querystring.decode()- 是
querystring.parse()的别名。 querystring.encode()- 是
querystring.stringify()的别名。 querystring.escape(string)-
对给定的
string执行 URL 编码，返回一个转义的查询字符串。该方法由querystring.stringify()使用，不应直接使用。 querystring.parse(string[,separator[,equal[,options]]])-
解析查询字符串 URL 并返回一个对象。
separator参数是用于分隔查询字符串中键值对的子字符串，默认为“&”。equal参数是用于分隔查询字符串中键和值的子字符串，默认为“=”。options参数应该是一个具有以下键的对象decodeURIComponentfunction- 用于解码查询字符串中百分比编码字符的函数，默认为
querystring.unescape() maxKeysnumber- 要解析的最大键数，默认为
1000。值0删除键计数限制。
默认情况下，查询字符串中的百分比编码字符假定使用 UTF-8 编码，无效的 UTF-8 序列将被替换为
U+FFFD替换字符。例如，对于以下查询字符串
'foo=bar&abc=xyz&abc=123'
输出将是
{ foo: 'bar', abc: ['xyz', '123'] } querystring.stringify(object[,separator[,equal[,options]]])-
序列化一个对象并返回一个 URL 查询字符串。
separator参数是用于分隔查询字符串中键值对的子字符串，默认为“&”。equal参数是用于分隔查询字符串中键和值的子字符串，默认为“=”。options参数应该是一个具有以下键的对象encodeURIComponentfunction- 用于将查询字符串中 URL 不安全的字符转换为百分比编码的函数，默认为
querystring.escape()。
默认情况下，查询字符串中需要百分比编码的字符编码为 UTF-8。如果需要其他编码，则应指定
encodeURIComponent选项。例如，对于以下命令
querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], 123: '' });查询字符串将是
'foo=bar&baz=qux&baz=quux&123='
querystring.unescape(string)-
对
string的 URL 百分比编码字符执行解码，返回一个未转义的查询字符串。该方法由querystring.parse()使用，不应直接使用。
XML
xml.parse() |
xml.c14n() |
xml.exclusiveC14n() |
xml.serialize() |
xml.serializeToString() |
XMLDoc |
XMLNode |
XMLAttr |
XML 模块允许处理 XML 文档 (自 0.7.10 起)。使用以下方式导入 XML 模块对象： import xml from 'xml'。
示例
import xml from 'xml'; let data = `<note><to b="bar" a= "foo" >Tove</to><from>Jani</from></note>`; let doc = xml.parse(data); console.log(doc.note.to.$text) /* 'Tove' */ console.log(doc.note.to.$attr$b) /* 'bar' */ console.log(doc.note.$tags[1].$text) /* 'Jani' */ let dec = new TextDecoder(); let c14n = dec.decode(xml.exclusiveC14n(doc.note)); console.log(c14n) /* '<note><to a="foo" b="bar">Tove</to><from>Jani</from></note>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note.to)); console.log(c14n) /* '<to a="foo" b="bar">Tove</to>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note, doc.note.to /* excluding 'to' */)); console.log(c14n) /* '<note><from>Jani</from></note>' */
parse(string|Buffer)- 解析 string 或 Buffer 以获取 XML 文档，返回表示解析后的 XML 文档的
XMLDoc包装对象。 c14n(root_node[,excluding_node])- 根据 Canonical XML Version 1.1 对
root_node及其子节点进行规范化。root_node可以是围绕 XML 结构的XMLNode或XMLDoc包装对象。返回包含规范化输出的 Buffer 对象。excluding_node- 允许在输出中省略文档的一部分
exclusiveC14n(root_node[,excluding_node[,withComments[,prefix_list]]])- 根据 Exclusive XML Canonicalization Version 1.0 对
root_node及其子节点进行规范化。root_node- 是围绕 XML 结构的
XMLNode或XMLDoc包装对象 excluding_node- 允许在输出中省略对应于该节点及其子节点的文档部分
withComments- 一个布尔值，默认为
false。如果为true，则规范化对应于 Exclusive XML Canonicalization Version 1.0 (带注释)。返回包含规范化输出的 Buffer 对象。 prefix_list- 一个可选字符串，包含空格分隔的命名空间前缀，用于也应包含在输出中的命名空间
serialize()- 与
xml.c14n()相同 (自 0.7.11 起)。 serializeToString()- 与
xml.c14n()相同，但返回结果为string(自 0.7.11 起)。 XMLDoc- 围绕 XML 结构的 XMLDoc 包装对象，即文档的根节点。
doc.$root- 按名称获取文档的根节点，或为 undefined
doc.abc- 第一个名为
abc的根标签，作为XMLNode包装对象
XMLNode- 围绕 XML 标签节点的 XMLNode 包装对象。
node.abc- 与
node.$tag$相同abc node.$attr$abc- 节点
abc的属性值，自 0.7.11 起可写入 node.$attr$=abcxyz- 与
node.setAttribute('相同 (自 0.7.11 起)abc',xyz) node.$attrs- 一个用于节点所有属性的
XMLAttr包装对象 node.$name- 节点的名称
node.$ns- 节点的命名空间
node.$parent- 当前节点的父节点
node.$tag$abc- 节点中第一个名为
abc的子标签，自 0.7.11 起可写入 - 所有子标签的数组
- 与
node.removeChildren();node.addChild(;node1)node.addChild(相同 (自 0.7.11 起)。node2) - 节点中所有名为
abc的子标签，自 0.7.11 起可写入 node.$text- 节点的内容，自 0.7.11 起可写入
node.$text = 'abc'- 与
node.setText('abc')相同 (自 0.7.11 起) node.addChild(nd)- 将 XMLNode 添加为节点的子节点 (自 0.7.11 起)。
nd在添加到节点之前会被递归复制 node.removeAllAttributes()- 移除节点的所有属性 (自 0.7.11 起)
node.removeAttribute(attr_name)- 移除名为
attr_name的属性 (自 0.7.11 起) node.removeChildren(tag_name)- 移除所有名为
tag_name的子标签 (自 0.7.11 起)。如果省略tag_name，则移除所有子标签。 node.removeText()- 移除节点的文本值 (0.7.11)
node.setAttribute(attr_name,value)- 为
attr_name设置值 (自 0.7.11 起)。当值为null时，名为attr_name的属性将被删除。 node.setText(value)- 为节点设置文本值 (自 0.7.11 起)。当值为
null时，节点的文本将被删除。
XMLAttr- 围绕 XML 节点属性的 XMLAttrs 包装对象。
attr.abcabc的属性值
zlib
zlib.deflateRawSync() |
zlib.deflateSync() |
zlib.inflateRawSync() |
zlib.inflateSync() |
zlib 模块提供了使用“deflate”和“inflate”算法进行压缩的功能 (自 0.7.12 起)。使用以下方式导入 zlib 模块对象： import zlib from 'zlib'。
deflateRawSync(string|Buffer[,options])- 使用提供的 string 或 Buffer 数据，使用“deflate”算法进行压缩，且不附加 zlib 头部。Buffer 值可以是
Buffer、TypedArray或DataView。Options是一个可选对象，包含 zlib_options。返回包含压缩数据的 Buffer 实例。 deflateSync(string|Buffer[,options])- 使用提供的 string 或 Buffer 数据，使用“deflate”算法进行压缩。Buffer 值可以是
Buffer、TypedArray或DataView。Options是一个可选对象，包含 zlib_options。返回包含压缩数据的 Buffer 实例。 inflateRawSync(string|Buffer)- 使用“deflate”算法解压原始流。返回包含解压后数据的 Buffer 实例。
inflateSync(string|Buffer)- 使用“deflate”算法解压流。返回包含解压后数据的 Buffer 实例。
zlib 选项
-
chunkSize— 是一个整数，默认为1024 -
dictionary— 是Buffer、TypedArray或DataView。默认为空 -
level— 是一个整数，仅用于压缩，参见 zlib_compression_levels -
memLevel— 是一个介于1和9之间的整数，仅用于压缩 -
strategy— 是一个整数，仅用于压缩，参见 zlib_compression_strategy -
windowBits— 对于原始数据，是一个介于-15和-9之间的整数；对于普通流，是一个介于9和15之间的整数
zlib 压缩级别
| 名称 | 描述 |
zlib.constants.Z_NO_COMPRESSION | 无压缩 |
zlib.constants.Z_BEST_SPEED | 最快，压缩量最小 |
zlib.constants.Z_DEFAULT_COMPRESSION | 速度和压缩之间的权衡 |
zlib.constants.Z_BEST_COMPRESSION | 最慢，压缩量最大 |
zlib 压缩策略
| 名称 | 描述 |
zlib.constants.Z_FILTERED | 过滤策略: 用于过滤器或预测器产生的数据 |
zlib.constants.Z_HUFFMAN_ONLY | 仅哈夫曼策略: 仅使用哈夫曼编码，不进行字符串匹配 |
zlib.constants.Z_RLE | 游程编码策略: 将匹配距离限制为一，更适用于 PNG 图像数据压缩 |
zlib.constants.Z_FIXED | 固定表策略: 阻止使用动态哈夫曼编码，适用于特殊应用的更简单解码器 |
zlib.constants.Z_DEFAULT_STRATEGY | 默认策略，适用于通用压缩 |