参考

nginx 对象
     HTTP 请求
     Stream 会话
     周期性会话
     Headers
     请求
     响应
     ngx
     ngx.shared
内置对象
     console
     crypto
     CryptoKey
     CryptoKeyPair
     njs
     process
     String
Web API
     Text Decoder
     Text Encoder
timers
     全局函数
内置模块
     Buffer
     Crypto
     文件系统
     Query String
     XML
     zlib

njs 提供用于扩展 nginx 功能的对象、方法和属性。

本参考文档仅包含不符合 ECMAScript 标准的 njs 特有属性、方法和模块。符合 ECMAScript 标准的 njs 属性和方法定义可在 ECMAScript 规范中找到。所有 njs 属性和方法的列表可在兼容性中找到。

nginx 对象

HTTP 请求

r.args{}
r.done()
r.error()
r.finish()
r.headersIn{}
r.headersOut{}
r.httpVersion
r.internal
r.internalRedirect()
r.log()
r.method
r.parent
r.remoteAddress
r.requestBody
r.requestBuffer
r.requestText
r.rawHeadersIn[]
r.rawHeadersOut[]
r.responseBody
r.responseBuffer
r.responseText
r.return()
r.send()
r.sendBuffer()
r.sendHeader()
r.setReturnValue()
r.status
r.subrequest()
r.uri
r.rawVariables{}
r.variables{}
r.warn()

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)
以 error 日志级别将 string 写入错误日志

由于 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{} 在以下位置可写

多值响应头的字段值 (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
布尔值，对于 internal 位置为 true
r.internalRedirect(uri)
执行到指定 uri 的内部重定向。如果 uri 以 “@” 前缀开头，则被视为命名位置。在新的位置中，普通位置从 NGX_HTTP_SERVER_REWRITE_PHASE 开始，命名位置从 NGX_HTTP_REWRITE_PHASE 开始，重复进行所有请求处理。因此，重定向到命名位置不会检查 client_max_body_size 限制。详情请参阅开发指南。重定向的请求变为内部请求，可以访问 internal 位置。实际的重定向发生在处理程序执行完成之后。

重定向后，会在目标位置启动一个新的 njs 虚拟机，原始位置的虚拟机停止。 nginx 变量的值会被保留，并可用于向目标位置传递信息。自 0.5.3 起，可以使用通过 http 或 stream 的 js_var 指令声明的变量。

自 0.7.4 起，该方法支持转义的 URI。

r.log(string)
以 info 日志级别将 string 写入错误日志

由于 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 相同，但返回字符串（自 0.5.0 起）。注意，它可能会将 UTF-8 编码中的无效字节转换为替换字符。
r.return(status[, string | Buffer])
向客户端发送带有指定 status 的完整响应。响应可以是字符串或 Buffer (0.5.0)。

可以指定重定向 URL（针对代码 301、302、303、307 和 308）或响应体文本（针对其他代码）作为第二个参数

r.send(string | Buffer)
向客户端发送响应体的一部分。发送的数据可以是字符串或 Buffer (0.5.0)
r.sendBuffer(data[, options])
将数据添加到将转发到下一个体过滤器的链中 (0.5.2)。实际转发稍后进行，即当当前链的所有数据块处理完毕时。

数据可以是字符串或 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 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 是一个字符串，它保存子请求参数字符串。否则，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{}
作为 Buffer 的 nginx 变量，可写（自 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 或 stream 的 js_var 指令创建的（自 0.5.3 起）
  • 它在 nginx 配置文件中被引用

即使如此，某些嵌入式变量仍然无法赋值（例如，$http_）。

r.warn(string)
以 warning 日志级别将 string 写入错误日志

由于 nginx 有硬编码的最大行长度限制，仅能记录字符串的前 2048 个字节。

Stream 会话

s.allow()
s.decline()
s.deny()
s.done()
s.error()
s.log()
s.off()
s.on()
s.remoteAddress
s.rawVariables{}
s.send()
s.sendDownstream()
s.sendUpstream()
s.status
s.setReturnValue()
s.variables{}
s.warn()

Stream 会话对象仅在 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)。

可能的代码值

  • 0 — 成功完成，将控制权传递给下一阶段
  • -5 — 未决定，将控制权传递给当前阶段的下一个处理程序（如果有）
  • 403 — 禁止访问

仅能在阶段处理程序函数中调用：js_access 或 js_preread。
s.error(string)
以 error 日志级别将发送的 string 写入错误日志

由于 nginx 有硬编码的最大行长度限制，仅能记录字符串的前 2048 个字节。

s.log(string)
以 info 日志级别将发送的 string 写入错误日志

由于 nginx 有硬编码的最大行长度限制，仅能记录字符串的前 2048 个字节。

s.off(eventName)
取消注册由 s.on() 方法设置的回调函数 (0.2.4)
s.on(event, callback)
为指定的 event 注册一个 callback (0.2.4)。

event 可以是以下字符串之一

upload
来自客户端的新数据（字符串）
下载
发送给客户端的新数据（字符串）
upstream
来自客户端的新数据（Buffer）（自 0.5.0 起）
downstream
发送给客户端的新数据（Buffer）（自 0.5.0 起）

完成回调具有以下原型：callback(data, flags)，其中 data 是字符串或 Buffer（取决于事件类型），flags 是一个包含以下属性的对象

last
布尔值，如果数据是最后一个缓冲区，则为 true。

s.remoteAddress
客户端地址，只读
s.rawVariables
作为 Buffer 的 nginx 变量，可写（自 0.5.0 起）
s.send(data[, options])
将数据添加到将按前向转发的数据块链中：在下载回调中转发给客户端；在上传中转发给上游服务器 (0.2.4)。实际转发稍后进行，即当当前链的所有数据块处理完毕时。

数据可以是字符串或 Buffer (0.5.0)。options 是一个用于覆盖从传入数据块缓冲区派生的 nginx 缓冲区标志的对象。可以使用以下标志覆盖标志

last
布尔值，如果缓冲区是最后一个缓冲区，则为 true
flush
布尔值，如果缓冲区应具有 flush 标志，则为 true

每个回调调用可以多次调用该方法。
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 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)
以 warning 日志级别将发送的 string 写入错误日志

由于 nginx 有硬编码的最大行长度限制，仅能记录字符串的前 2048 个字节。

周期性会话

PeriodicSession.rawVariables{}
PeriodicSession.variables{}

Periodic Session 对象作为 http 和 stream 的 js_periodic 处理程序的第一个参数提供（自 0.8.1 起）。

PeriodicSession.rawVariables{}
作为 Buffer 的 nginx 变量，可写。
PeriodicSession.variables{}
nginx 变量对象，可写。

Headers

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
一个包含用于预填充 Headers 对象的 HTTP 头部的对象，可以是 string、名称-值对的 array 或现有的 Headers 对象。

可以使用以下属性和方法创建新的 Headers 对象

append()
将新值附加到 Headers 对象中的现有头部，或者如果头部尚不存在则添加该头部（自 0.7.10 起）。
delete()
从 Headers 对象中删除头部（自 0.7.10 起）。
get()
返回一个包含指定名称的所有头部值的字符串，以逗号和空格分隔。
getAll(name)
返回一个包含指定名称的所有头部值的数组。
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]])
创建一个可供稍后传递给 ngx.fetch() 使用的 Request 获取对象。resource 可以是 URL 或现有的 Request 对象。options 是一个可选参数，应为一个包含以下键的对象
body
请求体，默认为空。
headers
响应头对象 — 包含用于预填充 Headers 对象的 HTTP 头部的对象，可以是 string、名称-值对的 array 或现有的 Headers 对象。
method
HTTP 方法，默认使用 GET 方法。

可以使用以下属性和方法创建新的 Request 对象

arrayBuffer()
返回解析为 ArrayBuffer 的 Promise。
bodyUsed
布尔值，如果请求中使用了主体，则为 true。
cache
包含请求的缓存模式。
credentials
包含请求的凭据，默认值为 same-origin。
headers
与 Request 关联的 Headers 只读对象。
json()
返回解析为将请求体解析为 JSON 的结果的 Promise。
method
包含请求方法。
mode
包含请求模式。
text()
返回解析为请求体字符串表示形式的 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 是一个可选参数，应为一个包含以下键的对象
headers
响应头对象 — 包含用于预填充 Headers 对象的 HTTP 头部的对象，可以是 string、名称-值对的 array 或现有的 Headers 对象。
status
响应的状态码。
statusText
与状态码对应的状态消息。

可以使用以下属性和方法创建新的 Response() 对象

arrayBuffer()
获取 Response 流并将其读至完成。返回解析为 ArrayBuffer 的 Promise。
bodyUsed
布尔值，如果已读取主体，则为 true。
headers
与 Response 关联的 Headers 只读对象。
json()
获取 Response 流并将其读至完成。返回解析为将主体文本解析为 JSON 的结果的 Promise。
ok
布尔值，如果响应成功（状态码在 200–299 之间），则为 true。
redirected
布尔值，如果响应是重定向的结果，则为 true。
status
响应的状态码。
statusText
与状态码对应的状态消息。
text()
获取 Response 流并将其读至完成。返回解析为字符串的 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 构建名称的字符串，对应于 configure 脚本的 --build=name 参数，默认值为 "" (0.8.0)
ngx.conf_file_path
包含当前 nginx 配置文件文件路径的字符串 (0.8.0)
ngx.conf_prefix
包含 nginx 配置前缀（即 nginx 当前查找配置的目录）文件路径的字符串 (0.7.8)
ngx.error_log_path
包含当前 错误日志 文件路径的字符串 (0.8.0)
ngx.fetch(resource, [options])

发出请求以获取 resource (0.5.1)，它可以是 URL 或 Request 对象 (0.7.10)。返回解析为 Response 对象的 Promise。自 0.7.0 起，支持 https:// 方案，不处理重定向。

如果 resource 中的 URL 指定为域名，则使用 解析器 确定。如果指定了 https:// 方案，则应配置 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://nginx.ac.cn/');
let body = await reply.text();

r.return(200, body);

ngx.log(level, message)
以指定的日志级别将消息写入错误日志。level 参数指定日志级别之一，message 参数可以是字符串或 Buffer。可以指定以下日志级别：ngx.INFO、ngx.WARN 和 ngx.ERR。

由于 nginx 有硬编码的最大行长度限制，仅能记录字符串的前 2048 个字节。

ngx.prefix
包含 nginx 前缀（即保存服务器文件的目录）文件路径的字符串 (0.8.0)
ngx.version
包含 nginx 版本的字符串，例如：1.25.0 (0.8.0)
ngx.version_number
包含 nginx 版本的数字，例如：1025000 (0.8.0)
ngx.worker_id
对应于 nginx 内部工作进程 ID 的数字，该值介于 0 和 worker_processes 指令中指定的值之间 (0.8.0)

ngx.shared

ngx.shared 全局对象自 0.8.0 起可用。

SharedDict

ngx.shared.SharedDict.add()
ngx.shared.SharedDict.capacity
ngx.shared.SharedDict.clear()
ngx.shared.SharedDict.delete()
ngx.shared.SharedDict.freeSpace()
ngx.shared.SharedDict.get()
ngx.shared.SharedDict.has()
ngx.shared.SharedDict.incr()
ngx.shared.SharedDict.items()
ngx.shared.SharedDict.keys()
ngx.shared.SharedDict.name
ngx.shared.SharedDict.pop()
ngx.shared.SharedDict.replace()
ngx.shared.SharedDict.set()
ngx.shared.SharedDict.size()
ngx.shared.SharedDict.ttl()
ngx.shared.SharedDict.type

共享字典对象自 0.8.0 起可用。共享字典名称、类型和大小是通过 http 或 stream 中的 js_shared_dict_zone 指令设置的。

SharedDict() 对象具有以下属性和方法

ngx.shared.SharedDict.add(key, value [,timeout])
仅当字典中尚不存在 key 时，才为其设置 value。key 是表示要添加的项的键的字符串，value 是要添加的项的值。

可选的 timeout 参数以毫秒为单位指定，并覆盖 http 或 stream 中 js_shared_dict_zone 指令的 timeout 参数（自 0.8.5 起）。当某些键预期具有唯一超时时，这非常有用。

如果值已成功添加到 SharedDict 字典，则返回 true；如果键已存在于字典中，则返回 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 字典中删除与指定键关联的项，如果字典中存在该项并已被删除，则返回 true，否则返回 false。
ngx.shared.SharedDict.freeSpace()
返回以字节为单位的空闲页面大小。如果大小为零，只要已占用的页面中有空间，SharedDict 字典仍将接受新值。
ngx.shared.SharedDict.get(key)
按 key 检索项，返回与 key 关联的值，如果没有，则返回 undefined。
ngx.shared.SharedDict.has(key)
按 key 搜索项，如果该项存在则返回 true，否则返回 false。
ngx.shared.SharedDict.incr(key,delta[[,init], timeout]))
将与 key 关联的整数值增加 delta。key 是一个字符串，delta 是要增加或减少值的数字。如果键不存在，该项将被初始化为可选的 init 参数，默认值为 0。

可选的 timeout 参数以毫秒为单位指定，并覆盖 http 或 stream 中 js_shared_dict_zone 指令的 timeout 参数（自 0.8.5 起）。如果未指定 timeout 参数，则保留现有的每条目 TTL（自 0.9.7 起）。在版本 0.9.7 之前，省略 timeout 会将条目过期时间重置为指令默认值。

返回新值。如果 SharedDict 字典中没有足够的可用空间，则抛出 SharedMemoryError。如果此字典不预期数字，则抛出 TypeError。

此方法仅在字典类型通过 http 或 stream 中 js_shared_dict_zone 指令的 type=number 参数声明时才可使用。

ngx.shared.SharedDict.items([maxCount])
返回 SharedDict 字典键值项的数组（自 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.ttl(key)
返回指定 key 的剩余生存时间（以毫秒为单位），如果键不存在或已过期，则返回 undefined（自 0.9.7 起）。

如果声明字典时没有 http 或 stream 中 js_shared_dict_zone 指令的 timeout 参数，则抛出 TypeError。

ngx.shared.SharedDict.type
返回 string 或 number，对应于由 http 或 stream 中 js_shared_dict_zone 指令的 type= 参数设置的 SharedDict 字典类型。

内置对象

console

console.error()
console.info()
console.log()
console.time()
console.timeEnd()
console.warn()

console 对象在 nginx 中自 0.8.2 起可用，在 CLI 中自 0.2.6 起可用。

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

сrypto.getRandomValues()
сrypto.randomUUID()
сrypto.subtle.encrypt()
сrypto.subtle.decrypt()
сrypto.subtle.deriveBits()
сrypto.subtle.deriveKey()
сrypto.subtle.digest()
сrypto.subtle.exportKey()
сrypto.subtle.generateKey()
сrypto.subtle.importKey()
сrypto.subtle.sign()
сrypto.subtle.verify()
сrypto.subtle.wrapKey()
сrypto.subtle.unwrapKey()

crypto 是一个允许使用加密功能的全局对象（自 0.7.0 起）。自 0.9.7 起，支持完整的 Web Crypto API 规范。

сrypto.getRandomValues(typedArray)
获取加密安全的随机值。返回作为 typedArray 传递的相同数组，但其内容已被新生成的随机数替换。可能的值
typedArray
可以是 Int8Array、Int16Array、Uint16Array、Int32Array 或 Uint32Array
сrypto.randomUUID()
返回一个随机生成的 36 字符长的 v4 UUID 字符串，例如 "36b8f84d-df4e-4d49-b662-bcde71a8764f"（自 0.9.7 起）。
сrypto.subtle.encrypt(algorithm, key, data)
使用提供的 algorithm 和 key 加密 data。返回解析为包含密文的 ArrayBuffer 的 Promise。可能的值
algorithm
一个指定要使用的算法以及如果需要任何额外参数的对象
  • 对于 RSA-OAEP，传递带有以下键的对象
    • name 是字符串，应设置为 RSA-OAEP

      crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)

  • 对于 AES-CTR，传递带有以下键的对象
    • name 是字符串，应设置为 AES-CTR
    • counter 是 ArrayBuffer、TypedArray 或 DataView — 计数器块的初始值，必须为 16 字节长（AES 块大小）。此块的最右侧长度位用于计数器，其余部分用于随机数。例如，如果长度设置为 64，则计数器前半部分是随机数，后半部分用于计数器
    • 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） - 一个数字，决定加密操作中生成的认证标签的位数，用于在相应的解密中进行认证。可能的值：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-OAEP

      crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)

  • 对于 AES-CTR，传递带有以下键的对象
    • name 是字符串，应设置为 AES-CTR
    • counter 是 ArrayBuffer、TypedArray 或 DataView — 计数器块的初始值，必须为 16 字节长（AES 块大小）。此块的最右侧长度位用于计数器，其余部分用于随机数。例如，如果长度设置为 64，则计数器前半部分是随机数，后半部分用于计数器。
    • 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） - 一个数字，决定加密操作中生成的认证标签的位数，用于在相应的解密中进行认证。可能的值：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)
从基本密钥导出位数组。返回解析为包含派生位的 ArrayBuffer 的 Promise。可能的值
algorithm
是一个定义要使用的导出算法的对象
  • 对于 HKDF，传递带有以下键的对象
    • name 是字符串，应设置为 HKDF
    • hash 是一个带有要使用的摘要算法的字符串：SHA-1、SHA-256、SHA-384 或 SHA-512
    • salt 是一个 ArrayBuffer、TypedArray 或 DataView，表示长度与 digest 函数输出相同的随机或伪随机值。与传递到 deriveKey() 中的输入密钥材料不同，盐不需要保密。
    • info 是一个 ArrayBuffer、TypedArray 或 DataView，表示用于将派生密钥绑定到应用程序或上下文的特定于应用程序的上下文信息，并允许在同时使用相同的输入密钥材料时为不同的上下文派生不同的密钥。此属性是必须的，但可以是一个空缓冲区。
  • 对于 PBKDF2，传递带有以下键的对象
    • name 是字符串，应设置为 PBKDF2
    • hash 是一个带有要使用的摘要算法的字符串：SHA-1、SHA-256、SHA-384 或 SHA-512
    • salt 是一个 ArrayBuffer、TypedArray 或 DataView，表示至少 16 字节的随机或伪随机值。与传递到 deriveKey() 中的输入密钥材料不同，盐不需要保密。
    • iterations 是一个数字，表示将在 deriveKey() 中执行哈希函数的次数
  • 对于 ECDH，传递带有以下键的对象（自 0.9.1 起）
    • name 是字符串，应设置为 ECDH
    • public 是一个 CryptoKey，表示另一方的公钥。该密钥必须使用与基本密钥相同的曲线生成。
  • 对于 X25519，传递带有以下键的对象（自 0.9.7 起）
    • name 是字符串，应设置为 X25519
    • public 是一个 CryptoKey，表示另一方的公钥
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() 中的输入密钥材料不同，盐不需要保密。
    • info 是一个 ArrayBuffer、TypedArray 或 DataView，表示用于将派生密钥绑定到应用程序或上下文的特定于应用程序的上下文信息，并允许在同时使用相同的输入密钥材料时为不同的上下文派生不同的密钥。此属性是必须的，但可以是一个空缓冲区。
  • 对于 PBKDF2，传递带有以下键的对象
    • name 是字符串，应设置为 PBKDF2
    • hash 是一个带有要使用的摘要算法的字符串：SHA-1、SHA-256、SHA-384 或 SHA-512
    • salt 是一个 ArrayBuffer、TypedArray 或 DataView，表示至少 16 字节的随机或伪随机值。与传递到 deriveKey() 中的输入密钥材料不同，盐不需要保密。
    • iterations 是一个数字，表示将在 deriveKey() 中执行哈希函数的次数
  • 对于 ECDH，传递带有以下键的对象（自 0.9.1 起）
    • name 是字符串，应设置为 ECDH
    • public 是一个 CryptoKey，表示另一方的公钥。该密钥必须使用与基本密钥相同的曲线生成。
  • 对于 X25519，传递带有以下键的对象（自 0.9.7 起）
    • name 是字符串，应设置为 X25519
    • public 是一个 CryptoKey，表示另一方的公钥
baseKey
是一个 CryptoKey，表示导出算法的输入 - 导出函数的初始密钥材料：例如，对于 PBKDF2，它可能是一个密码，使用 сrypto.subtle.importKey() 导入为 CryptoKey。
derivedKeyAlgorithm
是一个定义派生密钥将用于的算法的对象
  • 对于 HMAC，传递带有以下键的对象
    • name 是字符串，应设置为 HMAC
    • hash 是一个带有要使用的摘要函数的名称的字符串：SHA-1、SHA-256、SHA-384 或 SHA-512
    • length（可选）是一个数字，表示密钥的位长度。如果未指定，密钥的长度等于所选哈希函数的块大小
  • 对于 AES-CTR、AES-CBC、AES-GCM 或 AES-KW（自 0.9.7 起），传递带有以下键的对象
    • name 是字符串，应设置为 AES-CTR、AES-CBC、AES-GCM 或 AES-KW，具体取决于所使用的算法
    • length 是一个数字，表示要生成的密钥的位长度：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 起）。返回解析为生成的密钥（作为 CryptoKey 或 CryptoKeyPair 对象）的 Promise。可能的值
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 或 AES-KW（自 0.9.7 起），传递标识该算法的字符串或形式为 { "name": "ALGORITHM" } 的对象，其中 ALGORITHM 是算法名称
  • 对于 ECDH，传递带有以下键的对象（自 0.9.1 起）
    • name 是字符串，应设置为 ECDH
    • namedCurve 是表示要使用的椭圆曲线名称的字符串，可以是 P-256、P-384 或 P-521
  • 对于 Ed25519，传递 Ed25519 字符串或形式为 { "name": "Ed25519" } 的对象（自 0.9.7 起）
  • 对于 X25519，传递 X25519 字符串或形式为 { "name": "X25519" } 的对象（自 0.9.7 起）
extractable
布尔值，指示是否可以导出密钥
usage
表示密钥可能操作的 array
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于签署消息的密钥
verify
用于验证签名的密钥
deriveKey
用于导出新密钥的密钥
deriveBits
用于导出位的密钥
wrapKey
用于包装密钥的密钥
unwrapKey
用于解包密钥的密钥
сrypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages)
导入密钥：将外部可移植格式的密钥作为输入，并提供 CryptoKey 对象。返回解析为导入密钥（作为 CryptoKey 对象）的 Promise。可能的值
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 或 AES-KW（自 0.9.7 起），传递标识该算法的字符串或形式为 { "name": "ALGORITHM" } 的对象，其中 ALGORITHM 是算法名称
  • 对于 PBKDF2，传递 PBKDF2 字符串
  • 对于 HKDF，传递 HKDF 字符串
  • 对于 ECDH，传递带有以下键的对象（自 0.9.1 起）
    • name 是字符串，应设置为 ECDH
    • namedCurve 是表示要使用的椭圆曲线名称的字符串，可以是 P-256、P-384 或 P-521
  • 对于 Ed25519，传递 Ed25519 字符串或形式为 { "name": "Ed25519" } 的对象（自 0.9.7 起）
  • 对于 X25519，传递 X25519 字符串或形式为 { "name": "X25519" } 的对象（自 0.9.7 起）
extractable
布尔值，指示是否可以导出密钥
keyUsages
表示密钥可能操作的 array
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于签署消息的密钥
verify
用于验证签名的密钥
deriveKey
用于导出新密钥的密钥
deriveBits
用于导出位的密钥
wrapKey
用于包装密钥的密钥
unwrapKey
用于解包密钥的密钥
сrypto.subtle.sign(algorithm, key, data)
返回 signature 作为解析为包含签名的 ArrayBuffer 的 Promise。可能的值
algorithm
是一个指定要使用的签名算法及其参数的字符串或对象
  • 对于 RSASSA-PKCS1-v1_5，传递标识该算法的字符串或形式为 { "name": "ALGORITHM" } 的对象
  • 对于 RSA-PSS，传递带有以下键的对象
    • name 是字符串，应设置为 RSA-PSS
    • saltLength 是一个长 integer，表示要使用的随机盐的长度（以字节为单位）
  • 对于 ECDSA，传递带有以下键的对象
    • name 是字符串，应设置为 ECDSA
    • hash 是要使用的摘要算法的标识符，可以是 SHA-256、SHA-384 或 SHA-512
  • 对于 HMAC，传递标识该算法的字符串或形式为 { "name": "ALGORITHM" } 的对象
  • 对于 Ed25519，传递 Ed25519 字符串或形式为 { "name": "Ed25519" } 的对象（自 0.9.7 起）
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，表示要使用的随机盐的长度（以字节为单位）
  • 对于 ECDSA，传递带有以下键的对象
    • name 是字符串，应设置为 ECDSA
    • hash 是要使用的摘要算法的标识符，可以是 SHA-256、SHA-384 或 SHA-512
  • 对于 HMAC，传递标识该算法的字符串或形式为 { "name": "ALGORITHM" } 的对象
  • 对于 Ed25519，传递 Ed25519 字符串或形式为 { "name": "Ed25519" } 的对象（自 0.9.7 起）
key
是一个 CryptoKey 对象，该密钥将用于验证。它是对称算法的秘密密钥，也是公钥系统中的公钥。
signature
是一个 ArrayBuffer、TypedArray 或 DataView，包含要验证的签名
data
是一个 ArrayBuffer、TypedArray 或 DataView 对象，包含要验证其签名的数据
сrypto.subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm)
包装密钥：以外部可移植格式导出密钥，然后对导出的密钥进行加密（自 0.9.7 起）。返回解析为包含加密的导出密钥的 ArrayBuffer 的 Promise。可能的值
format
在加密前描述要导出密钥的数据格式的字符串，可以是以下内容
raw
原始数据格式
pkcs8
PKCS #8 格式
spki
SubjectPublicKeyInfo 格式
jwk
JSON Web Key (JWK) 格式
key
一个包含要包装的密钥的 CryptoKey。密钥必须将 CryptoKey.extractable 设置为 true。
wrappingKey
一个包含用于加密导出密钥的密钥的 CryptoKey。密钥必须设置 wrapKey 用法。
wrapAlgorithm
一个指定用于加密导出密钥的算法以及如果需要任何额外参数的对象
  • 对于 AES-CBC、AES-CTR 或 AES-GCM，传递如 сrypto.subtle.encrypt() 中所述的相应算法参数
  • 对于 AES-KW，传递 AES-KW 字符串或形式为 { "name": "AES-KW" } 的对象
  • 对于 RSA-OAEP，传递如 сrypto.subtle.encrypt() 中所述的相应算法参数
сrypto.subtle.unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages)
解包密钥：解密包装的密钥并根据结果创建 CryptoKey 对象（自 0.9.7 起）。返回解析为解包密钥（作为 CryptoKey）的 Promise。可能的值
format
描述已包装密钥的数据格式的字符串，可以是以下内容
raw
原始数据格式
pkcs8
PKCS #8 格式
spki
SubjectPublicKeyInfo 格式
jwk
JSON Web Key (JWK) 格式
wrappedKey
一个 ArrayBuffer、TypedArray 或 DataView，包含给定格式的已包装密钥
unwrappingKey
一个包含用于解密包装密钥的密钥的 CryptoKey。该密钥必须设置 unwrapKey 用途。
unwrapAlgorithm
一个指定用于解密包装密钥的算法及所需任何额外参数的对象
  • 对于 AES-CBC、AES-CTR 或 AES-GCM，传递如 сrypto.subtle.encrypt() 中所述的相应算法参数
  • 对于 AES-KW，传递 AES-KW 字符串或形式为 { "name": "AES-KW" } 的对象
  • 对于 RSA-OAEP，传递如 сrypto.subtle.encrypt() 中所述的相应算法参数
unwrappedKeyAlgorithm
一个字典对象，定义了要解包的密钥类型并提供算法特定的额外参数。适用于 сrypto.subtle.importKey() 的算法描述同样适用。
extractable
布尔值，指示是否可以导出密钥
keyUsages
表示密钥可能操作的 array
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于签署消息的密钥
verify
用于验证签名的密钥
deriveKey
用于导出新密钥的密钥
deriveBits
用于导出位的密钥
wrapKey
用于包装密钥的密钥
unwrapKey
用于解包密钥的密钥

CryptoKey

CryptoKey.algorithm
CryptoKey.extractable
CryptoKey.type
CryptoKey.usages

CryptoKey 对象表示从 SubtleCrypto 方法之一获得的加密 key：сrypto.subtle.generateKey()、сrypto.subtle.deriveKey()、сrypto.subtle.importKey()。

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 的字典对象，表示一对非对称密钥。

CryptoKeyPair.privateKey
代表私钥的 CryptoKey 对象。
CryptoKeyPair.publicKey
代表公钥的 CryptoKey 对象。

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 */

toBytes() 方法将码点在 255 以内的 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 方法
>> Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]).toString()
'buffer'

>> Buffer.from('YnVmZmVy', 'base64').toString()
'buffer'
在 0.4.4 之前，可以从包含八位字节的数组或编码字符串（0.2.3）创建字节字符串，编码可以是 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'

在 0.4.3 版本之前，只能编码字节字符串

>>  'αβγδ'.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 解码出的文本字符串。缓冲区可以是 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()
Buffer.allocUnsafe()
Buffer.byteLength()
Buffer.compare()
Buffer.concat()
Buffer.from(array)
Buffer.from(arrayBuffer)
Buffer.from(buffer)
Buffer.from(object)
Buffer.from(string)
Buffer.isBuffer()
Buffer.isEncoding()
buffer[]
buf.buffer
buf.byteOffset
buf.compare()
buf.copy()
buf.equals()
buf.fill()
buf.includes()
buf.indexOf()
buf.lastIndexOf()
buf.length
buf.readIntBE()
buf.readIntLE()
buf.readUIntBE()
buf.readUIntLE()
buf.readDoubleBE
buf.readDoubleLE()
buf.readFloatBE()
buf.readFloatLE()
buf.subarray()
buf.slice()
buf.swap16()
buf.swap32()
buf.swap64()
buf.toJSON()
buf.toString()
buf.write()
buf.writeIntBE()
buf.writeIntLE()
buf.writeUIntBE()
buf.writeUIntLE()
buf.writeDoubleBE()
buf.writeDoubleLE()
buf.writeFloatBE()
buf.writeFloatLE()

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.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，它将被强制转换为无符号整数。如果列表中 Buffer 的组合长度超过了 totalLength，结果将被截断为 totalLength。
Buffer.from(array)
使用范围在 0 – 255 之间的字节数组分配一个新的 Buffer。超出该范围的数组条目将被截断。
Buffer.from(arrayBuffer, byteOffset[, length]])
创建 ArrayBuffer 的视图，而不复制底层内存。可选的 byteOffset 和 length 参数指定了 Buffer 将共享的 arrayBuffer 内的内存范围。
Buffer.from(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)
一个布尔值，如果编码是受支持的字符编码名称，则返回 true。
buffer[index]
可用于获取和设置 buffer 中 index 位置八位字节的索引运算符。这些值是指单个字节，因此合法值范围在 0 到 255（十进制）之间。
buf.buffer
创建此 Buffer 对象所依据的底层 ArrayBuffer 对象。
buf.byteOffset
一个整数，指定 Buffer 底层 ArrayBuffer 对象的 byteOffset。
buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
将缓冲区与 target 进行比较，并返回一个数字，指示缓冲区在排序顺序中是在 target 之前、之后还是与之相同。比较基于每个 Buffer 中的实际字节序列。targetStart 是一个整数，指定开始比较的 target 内的偏移量，默认为 0。targetEnd 是一个整数，指定结束比较的 target 内的偏移量，默认为 target.length。sourceStart 是一个整数，指定开始比较的缓冲区内的偏移量，默认为 0。sourceEnd 是一个整数，指定结束比较的缓冲区内的偏移量（不包含），默认为 buf.length。
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
将数据从缓冲区的一个区域复制到 target 中的一个区域，即使目标内存区域与缓冲区重叠。target 参数是要复制到的 Buffer 或 Uint8Array。

targetStart 是一个整数，指定开始写入的 target 内的偏移量，默认为 0。sourceStart 是一个整数，指定开始复制的缓冲区内的偏移量，默认为 0。sourceEnd 是一个整数，指定停止复制的缓冲区内的偏移量（不包含），默认为 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，如果 value 在 Buffer 中找到，则返回 true。
buf.indexOf(value[, byteOffset][, encoding])
返回一个整数，该整数是 value 在 Buffer 中第一次出现的索引，如果 Buffer 不包含该值，则返回 -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)
从指定 offset 的 buf 中读取 byteLength，并将结果解释为大端、二进制补码有符号值，支持高达 48 位的精度。byteLength 参数是 1 到 6 之间的整数，指定要读取的字节数。

也支持类似的方法：buf.readInt8([offset]), buf.readInt16BE([offset]), buf.readInt32BE([offset])。

buf.readIntLE(offset, byteLength)
从指定 offset 的 buf 中读取 byteLength，并将结果解释为小端、二进制补码有符号值，支持高达 48 位的精度。byteLength 参数是 1 到 6 之间的整数，指定要读取的字节数。

也支持类似的方法：buf.readInt8([offset]), buf.readInt16LE([offset]), buf.readInt32LE([offset])。

buf.readUIntBE(offset, byteLength)
从指定 offset 的 buf 中读取 byteLength，并将结果解释为大端无符号整数，支持高达 48 位的精度。byteLength 参数是 1 到 6 之间的整数，指定要读取的字节数。

也支持类似的方法：buf.readUInt8([offset]), buf.readUInt16BE([offset]), buf.readUInt32BE([offset])。

buf.readUIntLE(offset, byteLength)
从指定 offset 的 buf 中读取 byteLength，并将结果解释为小端无符号整数，支持高达 48 位的精度。byteLength 参数是 1 到 6 之间的整数，指定要读取的字节数。

也支持类似的方法：buf.readUInt8([offset]), buf.readUInt16LE([offset]), buf.readUInt32LE([offset])。

buf.readDoubleBE([offset])
从指定 offset 的 buf 中读取一个 64 位、大端双精度浮点数。
buf.readDoubleLE([offset])
从指定 offset 的 buf 中读取一个 64 位、小端双精度浮点数。
buf.readFloatBE([offset])
从指定 offset 的 buf 中读取一个 32 位、大端浮点数。
buf.readFloatLE([offset])
从指定 offset 的 buf 中读取一个 32 位、小端浮点数。
buf.subarray([start[, end]])
返回一个新的 buf，它引用与原始缓冲区相同的内存，但由 start 和 end 偏移和裁剪。如果 end 大于 buf.length，则返回与 end 等于 buf.length 相同的结果。
buf.slice([start[, end]])
返回一个新的 buf，它引用与原始缓冲区相同的内存，但由 start 和 end 值偏移和裁剪。该方法不兼容 Uint8Array.prototype.slice()，后者是 Buffer 的超类。要复制切片，请使用 Uint8Array.prototype.slice()。
buf.swap16()
将 buf 解释为无符号 16 位数字数组并就地交换字节顺序。如果 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 起，扩展的加密 API 作为全局 crypto 对象提供。

Crypto 模块提供加密功能支持。Crypto 模块对象通过 import crypto from 'crypto' 导入。

自 0.9.7 起，Crypto 模块需要 OpenSSL 并使用 OpenSSL EVP 进行哈希处理，使得链接的 OpenSSL 库支持的任何摘要算法都可用于 JavaScript 代码。

crypto.createHash(algorithm)
创建并返回一个 Hash 对象，可用于使用给定的 algorithm 生成哈希摘要。算法可以是 md5、sha1、sha256、sha384、sha512，以及链接的 OpenSSL 库支持的任何其他摘要（自 0.9.7 起）。在 0.9.7 版本之前，仅支持 md5、sha1 和 sha256。
crypto.createHmac(algorithm, secret key)
创建并返回一个使用给定 algorithm 和 secret key 的 HMAC 对象。算法可以是 md5、sha1、sha256、sha384、sha512，以及链接的 OpenSSL 库支持的任何其他摘要（自 0.9.7 起）。在 0.9.7 版本之前，仅支持 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 */

文件系统

fs.accessSync()
fs.appendFileSync()
fs.closeSync()
fs.existsSync()
fs.fstatSync()
fs.lstatSync()
fs.mkdirSync()
fs.openSync()
fs.promises.open()
fs.readdirSync()
fs.readFileSync()
fs.readlinkSync()
fs.readSync()
fs.realpathSync()
fs.renameSync()
fs.rmdirSync()
fs.statSync()
fs.symlinkSync()
fs.unlinkSync()
fs.writeFileSync()
fs.writeSync()
fs.writeSync()

fs.Dirent
fs.FileHandle
fs.Stats
文件访问常量
文件系统标志

文件系统模块提供文件操作。

模块对象通过 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
文件系统 标志，默认为 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 参数应为一个指定 模式 的 integer，或具有以下键的对象
mode
模式选项，默认为 0o777。
openSync(path[, flags[, mode]])
返回一个表示打开的 path 文件的文件描述符的整数（0.7.7）。
flags
文件系统 标志，默认为 r
mode
模式选项，默认为 0o666
promises.open(path[, flags[, mode]])
返回一个代表打开的 path 文件的 FileHandle 对象（0.7.7）。
flags
文件系统 标志，默认为 r
mode
模式选项，默认为 0o666
readdirSync(path[, options])
同步读取指定 path 的目录内容（0.4.2）。options 参数应为一个指定 编码 的字符串，或具有以下键的对象
encoding
编码，默认为 utf8。编码可以是 utf8 和 buffer（0.4.4）。
withFileTypes
如果设置为 true，则文件数组将包含 fs.Dirent 对象，默认为 false。
readFileSync(filename[, options])
同步返回带有提供的 filename 的文件内容。options 参数保存指定编码的 string。如果指定了编码，则返回一个字符串，否则返回一个 Buffer 对象（0.4.4）。
在 0.4.4 版本之前，如果未指定编码，则返回字节字符串。
否则，options 应为一个具有以下键的对象
encoding
编码，默认未指定。编码可以是 utf8、hex（0.4.4）、base64（0.4.4）、base64url（0.4.4）。
flag
文件系统 标志，默认为 r
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）。
buffer
buffer 值可以是 Buffer、TypedArray 或 DataView
offset
是一个表示缓冲区中写入数据位置的 integer
length
是一个表示要读取字节数的 integer
position
指定从文件何处开始读取，该值可以是 integer 或 null，默认为 null。如果 position 为 null，数据将从当前文件位置读取，并且文件位置将被更新。如果 position 是一个 integer，文件位置将保持不变
realpathSync(path[, options])
使用 realpath(3) 同步计算路径名，解析 .、.. 和符号链接。options 参数可以是一个指定编码的字符串，或者一个具有 encoding 属性的对象，用于指定传递给回调的路径的字符编码（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) 同步创建指向 target 的名为 path 的链接（0.3.9）。相对目标是相对于链接的父目录的。
unlinkSync(path)
通过 path 同步删除文件链接（0.3.9）。
writeFileSync(filename, data[, options])
同步将 data 写入具有提供的 filename 的文件。data 应为字符串或 Buffer 对象（0.4.4）。如果文件不存在，它将被创建；如果文件存在，它将被替换。options 参数应为一个具有以下键的对象
mode
模式选项，默认为 0o666
flag
文件系统 标志，默认为 w
import fs from 'fs';

fs.writeFileSync('hello.txt', 'Hello world');
writeSync(fd, buffer, offset[, length[, position]])
使用文件描述符将缓冲区写入文件，返回写入的字节 number（0.7.7）。
fd
一个代表文件描述符的 integer
buffer
buffer 值可以是 Buffer、TypedArray 或 DataView
offset
是一个确定要写入缓冲区部分的 integer，默认为 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 对象。

fs.FileHandle

filehandle.close()
filehandle.fd
filehandle.read()
filehandle.stat()
filehandle.write(buf)
filehandle.write(str)

FileHandle 对象是数字文件描述符的对象包装器（0.7.7）。FileHandle 对象的实例由 fs.promises.open() 方法创建。如果 FileHandle 未使用 filehandle.close() 方法关闭，它将尝试自动关闭文件描述符，有助于防止内存泄漏。请不要依赖此行为，因为它可能不可靠。相反，应始终显式关闭 FileHandle。

filehandle.close()
在等待句柄上的任何待处理操作完成后关闭文件句柄。返回一个 promise，成功时以 undefined 履行。
filehandle.fd
FileHandle 对象管理的数字文件描述符。
filehandle.read(buffer, offset[, length[, position]])
从文件中读取数据并将其存储在给定的缓冲区中。
buffer
将填充读取的文件数据的缓冲区，该值可以是 Buffer、TypedArray 或 DataView
offset
是一个表示开始填充的缓冲区中位置的 integer
length
是一个表示要读取字节数的 integer
position
开始从文件中读取数据的位置，该值可以是 integer 或 null。如果为 null，数据将从当前文件位置读取，并且位置将被更新。如果 position 是一个 integer，当前文件位置将保持不变。
返回一个 Promise，在成功时以包含两个属性的对象履行
bytesRead
是一个表示读取字节数的 integer
buffer
是对缓冲区中传入参数的引用，可以是 Buffer、TypedArray 或 DataView
filehandle.stat()
获取文件的 fs.Stats，返回一个 promise。
filehandle.write(buffer, offset[, length[, position]])
将缓冲区写入文件。
buffer
buffer 值可以是 Buffer、TypedArray 或 DataView
offset
是一个表示缓冲区内写入数据开始位置的 integer
length
是一个表示要写入缓冲区字节数的 integer，默认为 Buffer.byteLength 的偏移量
position
缓冲区数据应写入的文件开头偏移量，可以是 integer 或 null，默认为 null。如果 position 不是 number，数据将写入当前位置。有关详细信息，请参阅 POSIX pwrite(2) 文档。
返回一个 Promise，该 Promise 以包含两个属性的对象解析
bytesWritten
是一个表示写入字节数的 integer
buffer
对写入缓冲区的引用，可以是 Buffer、TypedArray 或 DataView

在不等待 Promise 解析或拒绝的情况下，多次在同一文件上使用 filehandle.write() 是不安全的。

filehandle.write(string[, position[, encoding]])
将 string 写入文件。
position
缓冲区数据应写入的文件开头偏移量，可以是 integer 或 null，默认为 null。如果 position 不是 number，数据将写入当前位置。有关详细信息，请参阅 POSIX pwrite(2) 文档。
encoding
字符串的预期编码，默认为 utf8
返回一个 Promise，该 Promise 以包含两个属性的对象解析
bytesWritten
是一个表示写入字节数的 integer
buffer
对写入缓冲区的引用，可以是 Buffer、TypedArray 或 DataView

在不等待 Promise 解析或拒绝的情况下，多次在同一文件上使用 filehandle.write() 是不安全的。

fs.Stats

fs.Stats 对象提供有关文件的信息。该对象从 fs.statSync() 和 fs.lstatSync() 返回。

文件访问常量

access() 方法可以接受以下标志。这些标志由 fs.constants 导出

文件系统标志

flag 选项可以接受以下值

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 参数应为一个包含以下键的对象

decodeURIComponent function
用于解码查询字符串中百分号编码字符的函数，默认为 querystring.unescape()
maxKeys number
解析的最大键数，默认为 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 参数应为一个包含以下键的对象

encodeURIComponent function
用于将 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)
解析用于 XML 文档的字符串或 Buffer，返回一个代表解析后 XML 文档的 XMLDoc 包装器对象。
c14n(root_node[, excluding_node])
根据 Canonical XML Version 1.1 规范化 root_node 及其子节点。root_node 可以是 XMLNode 或 XML 结构周围的 XMLDoc 包装器对象。返回包含规范化输出的 Buffer 对象。

excluding_node
允许从输出中省略文档的一部分

exclusiveC14n(root_node[, excluding_node[, withComments [,prefix_list]]])
根据 Exclusive XML Canonicalization Version 1.0 规范化 root_node 及其子节点。

root_node
是 XMLNode 或 XML 结构周围的 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$abc=xyz
与 node.setAttribute('abc', xyz) 相同（自 0.7.11 起）
node.$attrs
节点所有属性的 XMLAttr 包装器对象
node.$name
节点的名称
node.$ns
节点的命名空间
node.$parent
当前节点的父节点
node.$tag$abc
节点第一个名为 abc 的子标签，自 0.7.11 起可写
node.$tags
所有子标签的数组
node.$tags = [node1, node2, ...]
与 node.removeChildren()；node.addChild(node1)；node.addChild(node2) 相同（自 0.7.11 起）。
node.$tags$abc
节点所有名为 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.abc
abc 的属性值

zlib

zlib.deflateRawSync()
zlib.deflateSync()
zlib.inflateRawSync()
zlib.inflateSync()

zlib 模块使用 “deflate” 和 “inflate” 算法提供压缩功能（自 0.7.12 起）。zlib 模块对象通过 import zlib from 'zlib' 导入。

deflateRawSync(string | Buffer[, options])
使用作为字符串或 Buffer 提供的 “deflate” 算法压缩数据，并且不追加 zlib 头。buffer 值可以是 Buffer、TypedArray 或 DataView。Options 是包含 zlib_options 的可选对象。返回包含压缩数据的 Buffer 实例。
deflateSync(string | Buffer[, options])
使用作为字符串或 Buffer 提供的 “deflate” 算法压缩数据。Buffer 值可以是 Buffer、TypedArray 或 DataView。Options 是包含 zlib_options 的可选对象。返回包含压缩数据的 Buffer 实例。
inflateRawSync(string | Buffer)
使用 “deflate” 算法解压原始流。返回包含解压数据的 Buffer 实例。
inflateSync(string | Buffer)
使用 “deflate” 算法解压流。返回包含解压数据的 Buffer 实例。

zlib 选项

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仅 Huffman 策略：仅 Huffman 编码，无字符串匹配
zlib.constants.Z_RLE运行长度编码策略：将匹配距离限制为 1，更好地压缩 PNG 图像数据
zlib.constants.Z_FIXED固定表策略：防止使用动态 Huffman 代码，这是特殊应用程序的更简单解码器
zlib.constants.Z_DEFAULT_STRATEGY默认策略，适用于通用压缩