参考

nginx 对象 HTTP 请求 流 会话 定期 会话 标头 请求 响应 ngx ngx.shared 内置对象 控制台 crypto CryptoKey CryptoKeyPair njs 进程 字符串 Web API 文本解码器 文本编码器 计时器 全局函数 内置模块 缓冲区 加密 文件系统 查询字符串 XML zlib

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

此引用仅包含特定于 njs 的属性、方法和模块 不符合 ECMAScript。 符合 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 之前， 对象的所有 String 属性 是字节字符串。

r.args{}

request arguments 对象，只读。

查询字符串作为对象返回。 从 0.7.6 开始， 重复的键以数组的形式返回， 键区分大小写，键和值都是百分比解码的。

例如，查询字符串

'a=1&b=%32&A=3&b=4&B=two%20words'

转换为 AS：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);
}

argument 对象 在首次访问 时进行评估。 如果只需要一个参数，例如 nginx 变量：r.argsfoo

r.variables.arg_foo

在这里，nginx variables 对象返回给定键的第一个值 不区分大小写，没有百分比解码。

要转换回字符串， 可以使用 Query String stringify 方法。r.args

r.done()

调用此函数后， next 数据块将传递给 client，而不调用 js_body_filter （0.5.2）。 只能从 js_body_filter 函数调用

r.error(string)

将 a 写入错误日志 在日志记录级别stringerror

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

r.finish()

完成向客户端发送响应

r.headersIn{}

incoming headers 对象，只读。

请求标头 可以使用语法进行访问：或 。FooheadersIn.fooheadersIn['Foo']

这 “授权”， “内容长度”， “内容范围”， “content-type”、 “ETag”、 “期望”， “发件人”、 “Host”， “如果匹配”， “如果修改自”， “如果-无-匹配”， “if-范围”， “if-unmodified-since”、 “Max-Forwards”、 “代理授权”、 “Referer”、 “transfer-encoding” 和 “User-Agent” （用户代理） 请求标头只能有一个字段值 （0.4.1） 的 “Cookie” 标头中的重复字段值 用分号 （） 分隔。 所有其他请求标头中的重复字段值用逗号分隔。;

r.headersOut{}

OUTGOING Headers 对象，writable。

If 是 一个 SubRequest，它表示响应标头。 在这种情况下，字段中的字段值 “接受范围”， “连接”， “内容-处置”， “内容编码”， “内容长度”， “内容范围”， “日期”， “Keep-Alive”， “服务器”， “传输编码”， “X-Accel-*” 可以省略响应标头。r.headersOut{}

“Foo” 响应标头 可以使用语法进行访问：或 。headersOut.fooheadersOut['Foo']

应在将响应标头发送到客户端之前设置传出标头， 否则，将忽略 header update。 这意味着 this 实际上可以在以下语言中写入：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” 响应标头的字段值 始终以数组的形式返回。 中的字段值重复 “年龄”， “内容编码”， “内容长度”， “content-type”、 “ETag”、 “过期”， “Last-Modified”、 “位置”， “Retry-After” （重试后） 响应标头将被忽略。 所有其他响应标头中的字段值重复 用逗号分隔。

r.httpVersion

HTTP 版本，只读

r.internal

布尔值，对于内部位置为 true

r.internalRedirect(uri)

执行内部 重定向到指定的 . 如果 uri 以 “” 前缀开头， 它被视为命名位置。 在新位置，将重复所有请求处理 普通位置的 NGX_HTTP_SERVER_REWRITE_PHASE 开始，命名位置的 NGX_HTTP_REWRITE_PHASE 开始。 因此，重定向到命名位置 不检查 client_max_body_size 限制。 有关更多详细信息，请参阅 开发指南 。 重定向的请求将成为内部请求，并且可以访问内部位置。 实际的重定向发生在处理程序执行完成后。uri@

重定向后， 在目标位置启动新的 njs VM， 原始位置的 VM 已停止。 保留 nginx 变量的值 ，并可用于将信息传递到目标位置。 从 0.5.3 开始， 可以使用使用 HTTP 或 Stream 的指令声明的变量。js_var

从 0.7.4 开始， 该方法接受转义的 URI。

r.log(string)

将 a 写入错误日志 在日志记录级别stringinfo

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

r.method

HTTP 方法，只读

r.parent

引用父 Request 对象

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 相同， 但返回一个 . 请注意， 它可以将 UTF-8 编码中无效的字节转换为替换字符。string

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

保存 SubRequest 响应正文， 只读 （从 0.5.0 开始）。 的大小受 subrequest_output_buffer_size 指令的限制。r.responseBuffer

r.responseText

与 r.responseBuffer 相同，但返回一个字符串 （从 0.5.0 开始）。 请注意， 它可以将 UTF-8 编码中无效的字节转换为替换字符。

r.return(status[, string | Buffer])

发送整个响应 替换为 Client 端。 响应可以是 String 或 Buffer （0.5.0 版本）。status

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

r.send(string | Buffer)

将响应正文的一部分发送到客户端。 发送的数据可以是字符串或 Buffer （0.5.0)

r.sendBuffer(data[, options])

将数据添加到要转发到下一个 body 过滤器的数据块链中 （0.5.2 的）。 实际的转发发生在稍后， 当当前链的所有数据块都被处理时。

数据可以是 String 或 Buffer。 是使用的对象 覆盖从传入数据块缓冲区派生的 nginx 缓冲区标志。 可以使用以下标志覆盖这些标志：options

last

布尔 如果缓冲区是最后一个缓冲区，则为 true

flush

布尔 如果缓冲区应具有标志，则为 trueflush

该方法只能从 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， writable （可写）

r.subrequest(uri[, options[, callback]])

创建一个具有给定 和 的子请求，并安装 可选的 completion 。urioptionscallback

子请求与客户端请求共享其 input 标头。 要将与原始 Headers 不同的 Headers 发送到代理服务器，可以使用 proxy_set_header 指令。 要将一组全新的 Headers 发送到代理服务器，可以使用 proxy_pass_request_headers 指令。

如果 是字符串，则 保存 subrequest arguments 字符串。 否则，应为 具有以下键的对象：optionsoptions

args

arguments 字符串，默认情况下使用空字符串

body

请求正文、 默认情况下，使用父请求对象的请求正文

method

HTTP 方法，默认情况下使用该方法GET

detached

布尔标志 （0.3.9）、 如果 ，则创建的子请求是 detached 子请求。 对分离的子请求的响应将被忽略。 与普通子请求不同，分离的子请求 可以在变量处理程序中创建。 flag 和 callback 参数 是互斥的。truedetached

完成接收 具有方法和属性的 SubRequest 响应对象 与父 Request 对象相同。callback

从 0.3.8 开始， 如果未提供 a，则 对象 ，该响应对象解析为 SubRequest 响应对象。callbackPromise

例如，要查看子请求中的所有响应标头：

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 variables 对象，可写 （自 0.2.8 起）。

例如，要获取变量 可以使用以下语法之一：$foo

r.variables['foo']
r.variables.foo

从 0.8.6 开始， 可以使用以下语法访问正则表达式捕获：

r.variables['1']
r.variables[1]

nginx 对 中引用的变量和未引用的变量的处理方式不同。 当一个变量被引用时，它可以是可缓存的， 但是当它未被引用时，它总是不可缓存的。 例如，当 $request_id 变量仅从 njs 访问时， 每次评估时，它都有一个新值。 但是，当引用 $request_id 时，例如：nginx.conf

proxy_set_header X-Request-Id $request_id;

每次都返回相同的值。r.variables.request_id

如果满足以下条件，则变量是可写的：

• 它是使用 HTTP 或 Stream 的指令创建的（从 0.5.3js_var)
• 它在 nginx 配置文件中引用

即便如此，某些嵌入变量仍然无法分配值（例如，$http_）。

r.warn(string)

将 a 写入错误日志 在日志记录级别stringwarning

由于 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()

流会话对象仅在 ngx_stream_js_module 模块中可用。 在 0.8.5 之前， 对象的所有 String 属性 是字节字符串。

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 值，默认情况下为 。 实际的终结发生在 js 处理程序完成时 以及所有待处理事件，例如，来自 ngx.fetch（） 或 setTimeout（）， 被处理 （0.2.4） 的code0

可能的 code 值：

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

只能从阶段处理程序函数 js_access 或 js_preread 调用。

s.error(string)

将 sent 写入错误日志 在日志记录级别stringerror

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

s.log(string)

将 sent 写入错误日志 在日志记录级别stringinfo

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

s.off(eventName)

取消注册 s.on（） 方法设置的回调 （0.2.4)

s.on(event, callback)

为指定的 （0.2.4） 注册 A。callbackevent

An 可以是以下字符串之一：event

upload

来自客户端的新数据 （string）

download

新数据 （string） 到客户端

upstream

来自客户端的新数据 （Buffer） （自 0.5.0 起)

downstream

新数据 （Buffer） 到客户端 （自 0.5.0 起)

补全回调具有以下原型：，其中 is string 或 Buffer（取决于事件类型）是一个对象 具有以下属性：callback(data, flags)dataflags

last

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

s.remoteAddress

客户端地址，只读

s.rawVariables

nginx 变量作为 Buffers， 写 （自 0.5.0 起)

s.send(data[, options])

将数据添加到将转发的数据块链中 前进方向： 在 download callback 到客户端;上传到上游服务器 （0.2.4） 的 实际的转发发生在稍后， 当当前链的所有数据块都被处理时。

数据可以是字符串或 Buffer （0.5.0 版本）。 是使用的对象 覆盖从传入数据块缓冲区派生的 nginx 缓冲区标志。 可以使用以下标志覆盖这些标志：options

last

布尔 如果缓冲区是最后一个缓冲区，则为 true

flush

布尔 如果缓冲区应具有标志，则为 trueflush

每次回调调用可以多次调用该方法。

s.sendDownstream()

与 s.send（） 相同， 除了它始终将数据发送到客户端 （自 0.7.8 起）。

s.sendUpstream()

与 s.send（） 相同， except it 始终从客户端发送数据 （自 0.7.8 起）。

s.status

session status code、$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 variables 对象，可写 （自 0.2.8 起）。 变量只能是可写的 如果在 nginx 配置文件中引用它。 即便如此，某些嵌入变量仍然无法分配值。

s.warn(string)

将 sent 写入错误日志 在日志记录级别stringwarning

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

周期性会话

PeriodicSession.rawVariables{}

PeriodicSession.variables{}

对象作为第一个参数提供 对于 HTTP 和 Stream 的处理程序（自 0.8.1 起）。Periodic Sessionjs_periodic

PeriodicSession.rawVariables{}

nginx 变量作为 Buffers， 写。

PeriodicSession.variables{}

nginx variables 对象，可写。

头

Headers()

Headers.append()

Headers.delete()

Headers.get()

Headers.getAll()

Headers.forEach()

Headers.has()

Headers.set()

Fetch API 的接口从 0.5.1 开始可用。Headers

可以使用 Headers（） 构造函数创建新对象： （自 0.7.10 起）：Headers

Headers([init])

init

一个包含 HTTP 标头的对象 预填充对象， 可以是 、 an of name-value 对， 或现有对象。HeadersstringarrayHeaders

可以创建新对象 具有以下属性和方法：Headers

append()

将新值追加到对象中的现有标头中， 或者添加标头（如果尚不存在） （自 0.7.10 起）。Headers

delete()

从对象中删除标头 （自 0.7.10 起）。Headers

get()

返回一个字符串，其中包含具有指定名称的所有标头的值 用逗号和空格分隔。

getAll(name)

返回一个数组，其中包含具有指定名称的所有标头的值。

forEach()

为每个键/值对执行一次提供的函数 在对象中 （自 0.7.10 起）。Headers

has()

返回布尔值 指示是否存在具有指定名称的 Header。

set()

为 对象 或者添加标头（如果尚不存在） （自 0.7.10 起）。Headers

请求

Request()

Request.arrayBuffer()

Request.bodyUsed

Request.cache

Request.credentials

Request.headers

Request.json()

Request.method

Request.mode

Request.text()

Request.url

Fetch API 的接口从 0.7.10 开始可用。Request

可以使用 Request（） 构造函数创建新对象：Request

Request[resource[, options]])

创建要获取的对象 稍后可以传递给 ngx.fetch（）。 可以是 URL 或现有对象。 这是一个可选参数 该对象应为具有以下键的对象：RequestresourceRequestoptions

body

默认情况下，请求正文为空。

headers

响应 headers 对象 — 包含 HTTP 标头的对象 预填充 Headers 对象， 可以是 、 an of name-value 对， 或现有的 Headers 对象。stringarray

method

HTTP 方法，默认情况下使用 GET 方法。

可以创建新对象 具有以下属性和方法：Request

arrayBuffer()

返回 a 解析为 一。PromiseArrayBuffer

bodyUsed

布尔值（如果在请求中使用了正文）。true

cache

包含请求的缓存模式。

credentials

包含请求的凭证， 默认情况下为 。same-origin

headers

Headers 只读对象 与 Request 相关联。

json()

返回 a 解析为 将请求正文解析为 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

该接口从 0.5.1 开始可用。Response

可以使用 Response（） 构造函数创建新对象 （自 0.7.10 起）：Response

Response[body[, options]])

创建对象。 这是一个可选参数 可以是 a 或 a ， 默认情况下为 。 这是一个可选参数 该对象应为具有以下键的对象：Responsebodystringbuffernulloptions

headers

响应 headers 对象 — 包含 HTTP 标头的对象 预填充 Headers 对象， 可以是 、 an of name-value 对， 或现有的 Headers 对象。stringarray

status

响应的状态代码。

statusText

与状态代码对应的状态消息。

可以创建新对象 具有以下属性和方法：Response()

arrayBuffer()

获取流并将其读取完成。 返回 a 解析为 一。ResponsePromiseArrayBuffer

bodyUsed

布尔值（如果读取了正文）。true

headers

Headers 只读对象 与 Response 相关联。

json()

获取流并将其读取完成。 返回 a 解析为 将正文文本解析为 JSON 的结果。ResponsePromise

ok

如果响应成功，则为布尔值（状态代码介于 200-299 之间）。true

redirected

布尔值（如果响应是重定向的结果）。true

status

响应的状态代码。

statusText

与状态代码对应的状态消息。

text()

获取流并将其读取完成。 返回 a ，该 a 使用 string 进行解析。ResponsePromise

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

全局对象可用 从 0.5.0 开始。ngx

ngx.build

包含可选 nginx 构建名称的字符串，对应于 --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])

请求获取 （0.5.1），可以是 URL 或 Request 对象 （0.7.10 的）。 返回 a 解析为 Response 对象。 从 0.7.0 开始， 支持该方案， 不处理重定向。resourcePromisehttps://

如果 中的 URL 指定为域名， 它是使用 Resolver 确定的。 如果指定了 scheme，则应配置 js_fetch_trusted_certificate 指令 用于 的 HTTPS 服务器的身份验证。resourcehttps://resource

参数应为对象 使用以下键：options

body

请求正文、 默认情况下为空

buffer_size

用于读取响应的缓冲区大小， 默认情况下为4096

headers

Request Headers 对象

max_response_body_size

响应正文的最大大小（以字节为单位）， 默认情况下为32768

method

HTTP 方法， 默认情况下，使用GET

verify

启用或禁用 HTTPS 服务器证书的验证， 默认情况下是 （0.7.0true)

例：

let reply = await ngx.fetch('http://nginx.org/');
let body = await reply.text();

r.return(200, body);

ngx.log(level,message)

将消息写入具有指定日志记录级别的错误日志。 该参数指定其中一个日志级别 参数可以是 String 或 Buffer。 可以指定以下日志级别： 、 、 和 。levelmessagengx.INFOngx.WARNngx.ERR

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

ngx.prefix

一个包含 nginx 前缀的文件路径的字符串 — 保存服务器文件的目录 （0.8.0)

ngx.version

包含 nginx 版本的字符串， 例如：（0.8.01.25.0)

ngx.version_number

包含 nginx 版本的数字， 例如：（0.8.01025000)

ngx.worker_id

与 nginx 内部 worker id 对应的数字， 该值介于 和 worker_processes 指令中指定的值之间 （0.8.00)

ngx.shared

全局对象可用 从 0.8.0 开始。ngx.shared

共享字典

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.type

共享字典对象可用 从 0.8.0 开始。 共享词典名称、类型和大小 使用 HTTP 或 Stream 中的指令设置。js_shared_dict_zone

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

ngx.shared.SharedDict.add(key, value [,timeout])

设置字典中指定的 仅当 key 尚不存在时。 这是一个字符串，表示 要添加的项的键， 是要添加的项的值。valuekeykeyvalue

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

返回值是否已成功添加 如果 key 已存在于 dictionary 中。 如果 字典中没有足够的可用空间。 如果 是 ，则抛出 的类型与此词典预期的类型不同。trueSharedDictfalseSharedMemoryErrorSharedDictTypeErrorvalue

ngx.shared.SharedDict.capacity

返回字典的容量， 对应于 HTTP 或 Stream 中 directive 的参数。SharedDictsizejs_shared_dict_zone

ngx.shared.SharedDict.clear()

从字典中删除所有项目。SharedDict

ngx.shared.SharedDict.delete(key)

删除与指定键关联的项目 从字典中，如果字典中的项存在并被删除，否则。SharedDicttruefalse

ngx.shared.SharedDict.freeSpace()

返回可用页面大小（以字节为单位）。 如果 size 为零，则字典 如果占用的页面中有空间，则仍会接受新值。SharedDict

ngx.shared.SharedDict.get(key)

按项的 检索项 ， 如果不存在，则返回与 或 关联的值。keykeyundefined

ngx.shared.SharedDict.has(key)

按项的 、 搜索项 如果存在此类项目，则返回。keytruefalse

ngx.shared.SharedDict.incr(key,delta[[,init], timeout]))

递增与 by 关联的整数值。 它是一个字符串， 是数字 以递增或递减值。 如果 key 不存在，则 该项目将被初始化为可选参数 默认情况下为 。keydeltakeydeltainit0

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

返回新值。 如果 字典中没有足够的可用空间。 如果此字典不需要数字，则引发。SharedMemoryErrorSharedDictTypeError

仅当字典类型是使用 http 或 stream 中指令的参数声明的时，才能使用此方法。type=numberjs_shared_dict_zone

ngx.shared.SharedDict.items([maxCount])

返回字典的数组 键值项（自 0.8.1 起）。 参数 设置要检索的最大项目数， 默认情况下为 。SharedDictmaxCount1024

ngx.shared.SharedDict.keys([maxCount])

返回字典键的数组。 参数 设置要检索的最大键数， 默认情况下为 。SharedDictmaxCount1024

ngx.shared.SharedDict.name

返回字典的名称， 对应于 HTTP 或 Stream 中 directive 的参数。SharedDictzone=js_shared_dict_zone

ngx.shared.SharedDict.pop(key)

从字典中删除与指定项关联的项， 如果不存在，则返回与 或 关联的值。keySharedDictkeyundefined

ngx.shared.SharedDict.replace(key, value)

仅当键已存在时，才替换指定的 for ， 如果键不存在，则返回值是否成功替换 在字典中。 如果 字典中没有足够的可用空间。 如果 是 ，则抛出 的类型与此词典预期的类型不同。valuekeytruefalseSharedDictSharedMemoryErrorSharedDictTypeErrorvalue

ngx.shared.SharedDict.set(key, value [,timeout])

为指定的 ， 返回此字典（用于方法链接）。valuekeySharedDict

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

ngx.shared.SharedDict.size()

返回字典的项数。SharedDict

ngx.shared.SharedDict.type

返回 Returns 或 对应于字典类型 由 HTTP 或 Stream 中的 Directive 参数设置。stringnumberSharedDicttype=js_shared_dict_zone

内置对象

安慰

console.error()

console.info()

console.log()

console.time()

console.timeEnd()

console.warn()

对象可用 在 nginx 中，从 0.8.2 开始， 从 0.2.6 开始在 CLI 中。console

console.error(msg[, msg2 ...])

输出一条或多条错误消息。 消息可以是字符串或对象。

console.info(msg[, msg2 ...])

输出一个或多个 info 消息。 消息可以是字符串或对象。

console.log(msg[, msg2 ...])

输出一条或多条日志消息。 消息可以是字符串或对象。

console.time(label)

启动一个计时器，该计时器可以跟踪作所花费的时间。 该参数允许命名不同的计时器。 如果调用同名的 console.timeEnd（） ， 将输出自计时器启动以来经过的时间， 以毫秒为单位。label

console.timeEnd(label)

停止之前由 console.time（） 启动的计时器 该参数允许命名不同的计时器。label

console.warn(msg[, msg2 ...])

输出一条或多条警告消息。 消息可以是字符串或对象。

加密

сrypto.getRandomValues()

с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()

对象是全局对象 允许使用加密功能 （自 0.7.0 起）。crypto

сrypto.getRandomValues(typedArray)

获取加密性强的随机值。 返回传递的相同数组，但其内容替换为新生成的随机数。 可能的值：typedArray

typedArray

可以是 、 或Int8ArrayInt16ArrayUint16ArrayInt32ArrayUint32Array

сrypto.subtle.encrypt(算法， 键， 数据)

使用提供的算法和密钥加密数据。 返回一个 fulfilled with an 包含密文。 可能的值：PromiseArrayBuffer

algorithm

一个对象，该对象指定 要使用的算法和任何额外的参数（如果需要）：

• 为 使用以下键传递对象：RSA-OAEP
  • name是一个字符串， 应设置为 ：RSA-OAEP

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

• 为 使用以下键传递对象：AES-CTR
  • name是一个字符串， 应设置为AES-CTR
  • counter是 、 或 — counter 块的初始值 长度必须为 16 字节（AES 块大小）。 此块最右边的长度位用于计数器 其余的用于 nonce。 例如，如果 length 设置为 64，则 那么 counter 的前半部分是 nonce 而后半部分则用于计数器ArrayBufferTypedArrayDataView
  • length是 counter 块中的位数 用于实际计数器。 计数器必须足够大，以至于它不会换行。
• for ，使用以下键传递对象：AES-CBC
  • name是一个字符串， 应设置为AES-CBC
  • iv或初始化向量为 、 或 、 必须是 16 字节，不可预测， 最好是密码随机的。 然而，它不一定是秘密的， 例如，它可能与密文一起以未加密的方式传输。ArrayBufferTypedArrayDataView
• for ，使用以下键传递对象：AES-GCM
  • name是一个字符串， 应设置为AES-GCM
  • iv或初始化向量为 、 或 、 必须为 16 字节， ，并且对于使用给定密钥执行的每个加密作必须是唯一的ArrayBufferTypedArrayDataView
  • additionalData（可选）是 ， 或 包含其他数据 不会加密，但将与加密数据一起进行身份验证。 如果指定，则 则必须在对 ： 如果给调用 与原始数据不匹配， 解密将引发异常。 的位长度必须小于 。ArrayBufferTypedArrayDataViewadditionalDatadecrypt()decrypt()additionalData2^64 - 1
  • tagLength（可选，默认为 ） - a 确定大小（以位为单位） 加密作中生成的身份验证标记 用于相应解密中的鉴权 可能的值： 、 、 、 、 、 或 。 AES-GCM 规范建议它应该是 、 或 、 尽管在某些应用程序中 OR BITS 可能是可以接受的。128number326496104112120128961041121201283264

key

一个 CryptoKey，其中包含 用于加密的密钥

data

包含 需要加密的数据（也称为明文）ArrayBufferTypedArrayDataView

сrypto.subtle.decrypt(算法， 键， 数据)

解密加密数据。 返回包含解密数据的 a。 可能的值：Promise

algorithm

对象 ，该参数指定要使用的算法以及所需的任何额外参数。 为 extra 参数给出的值必须匹配 这些 API 传递到相应的调用中。encrypt()

• 为 使用以下键传递对象：RSA-OAEP
  • name是一个字符串， 应设置为 ：RSA-OAEP

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

• 为 使用以下键传递对象：AES-CTR
  • name是一个字符串， 应设置为AES-CTR
  • counter是 、 或 — counter 块的初始值 长度必须为 16 字节（AES 块大小）。 此块最右边的长度位用于计数器 其余的用于 nonce。 例如，如果 length 设置为 64，则 那么 counter 的前半部分是 nonce 后半部分用于计数器。ArrayBufferTypedArrayDataView
  • length是 counter 块中的位数 用于实际计数器。 计数器必须足够大，以至于它不会换行。
• for ，使用以下键传递对象：AES-CBC
  • name是一个字符串， 应设置为AES-CBC
  • iv或初始化向量为 、 或 、 必须是 16 字节，不可预测， 最好是密码随机的。 但是，它不一定是秘密的 （例如，它可能与密文一起以未加密的方式传输）。ArrayBufferTypedArrayDataView
• for ，使用以下键传递对象：AES-GCM
  • name是一个字符串， 应设置为AES-GCM
  • iv或初始化向量为 、 或 、 必须为 16 字节， ，并且对于使用给定密钥执行的每个加密作必须是唯一的ArrayBufferTypedArrayDataView
  • additionalData（可选）是 ， 或 包含其他数据 不会加密，但将与加密数据一起进行身份验证。 如果指定，则 则必须在对 ： 如果给调用 与原始数据不匹配， 解密将引发异常。 的位长度必须小于 。ArrayBufferTypedArrayDataViewadditionalDatadecrypt()decrypt()additionalData2^64 - 1
  • tagLength（可选，默认为 ） - a 确定大小（以位为单位） 加密作中生成的身份验证标记 ，用于相应解密中的鉴权。 可能的值： 、 、 、 、 、 或 。 AES-GCM 规范建议它应该是 、 或 、 尽管在某些应用程序中 OR BITS 可能是可以接受的。128number326496104112120128961041121201283264

key

一个 CryptoKey，其中包含要用于解密的密钥。 如果使用，则这是 CryptoKeyPair 对象的属性。RSA-OAEPprivateKey

data

包含要解密的数据（也称为密文）的 ， 或ArrayBufferTypedArrayDataView

сrypto.subtle.deriveBits(algorithm， baseKey， 长度)

从基键派生位数组。 返回 a，该 a 将以包含派生位的 an 实现。 可能的值：PromiseArrayBuffer

algorithm

是一个对象，用于定义要使用的派生算法：

• 为 使用以下键传递对象：HKDF
  • name是一个字符串， 应设置为HKDF
  • hash是具有要使用的摘要算法的字符串：、、 或SHA-1SHA-256SHA-384SHA-512
  • salt是 ， 或 表示随机或伪随机值 其长度与函数的输出相同。 与传入 的输入键材料不同，。 盐不需要保密。ArrayBufferTypedArrayDataViewdigestderiveKey()
  • info是 ， 或 ，表示特定于应用程序的上下文信息 用于将派生的 key 绑定到应用程序或上下文， 并支持为不同的上下文派生不同的键 同时使用相同的输入键材料。 此属性是必需的，但可以是空缓冲区。ArrayBufferTypedArrayDataView
• 为 使用以下键传递对象：PBKDF2
  • name是一个字符串， 应设置为PBKDF2
  • hash是具有要使用的摘要算法的字符串：、、 或SHA-1SHA-256SHA-384SHA-512
  • salt是 ， 或 表示随机或伪随机值 至少字节。 与传入 的输入键材料不同，。 盐不需要保密。ArrayBufferTypedArrayDataView16deriveKey()
  • iterations是一个 a，表示哈希函数将被执行的次数 在numberderiveKey()

baseKey

是一个 CryptoKey，表示派生算法的输入 - 派生函数的初始密钥材料： 例如，因为它可能是一个密码， 使用 сrypto.subtle.importKey（） 作为 CryptoKey 导入PBKDF2

length

是一个数字，表示要派生的位数。 为了浏览器兼容性， 该数字应为8

сrypto.subtle.deriveKey(algorithm， baseKey， derivedKeyAlgorithm， 可提取的， keyUsages)

从主密钥派生密钥。 可能的值：

algorithm

是一个对象，用于定义要使用的派生算法：

• 为 使用以下键传递对象：HKDF
  • name是一个字符串， 应设置为HKDF
  • hash是具有要使用的摘要算法的字符串：、、 或SHA-1SHA-256SHA-384SHA-512
  • salt是 ， 或 表示随机或伪随机值 其长度与函数的输出相同。 与传入 的输入键材料不同，。 盐不需要保密。ArrayBufferTypedArrayDataViewdigestderiveKey()
  • info是 ， 或 ，表示特定于应用程序的上下文信息 用于将派生的 key 绑定到应用程序或上下文， 并支持为不同的上下文派生不同的键 同时使用相同的输入键材料。 此属性是必需的，但可以是空缓冲区。ArrayBufferTypedArrayDataView
• 为 使用以下键传递对象：PBKDF2
  • name是一个字符串， 应设置为PBKDF2
  • hash是具有要使用的摘要算法的字符串：、、 或SHA-1SHA-256SHA-384SHA-512
  • salt是 ， 或 表示随机或伪随机值 至少字节。 与传入 的输入键材料不同，。 盐不需要保密。ArrayBufferTypedArrayDataView16deriveKey()
  • iterations是一个 a，表示哈希函数将被执行的次数 在numberderiveKey()

baseKey

是一个 CryptoKey，表示派生算法的输入 - 派生函数的初始密钥材料： 例如，因为它可能是一个密码， 使用 сrypto.subtle.importKey（） 作为 CryptoKey 导入。PBKDF2

derivedKeyAlgorithm

是一个对象 ，它定义了派生键将用于的算法：

• 为 使用以下键传递对象：HMAC
  • name是一个字符串， 应设置为HMAC
  • hash是一个字符串，其中包含要使用的摘要函数的名称： 、 、 或SHA-1SHA-256SHA-384SHA-512
  • length（可选）是 a，表示键的长度（以位为单位）。 如果未指定，则 key 的长度等于 Chozen Hash 函数的区块大小number
• 对于 、 或 、 、 使用以下键传递对象：AES-CTRAES-CBCAES-GCM
  • name是一个字符串， 应设置为 、 或 、 取决于使用的算法AES-CTRAES-CBCAES-GCM
  • length是表示 要生成的键的长度（以位为单位）：、 、 或number128192256

extractable

是布尔值 指示是否可以导出密钥

keyUsages

是一个 ，指示可以使用派生的键执行哪些作。 算法必须允许密钥用法 嵌。 可能的值：ArrayderivedKeyAlgorithm

encrypt

用于加密消息的密钥

decrypt

用于解密消息的密钥

sign

用于对消息进行签名的密钥

verify

验证签名的密钥

deriveKey

key 用于派生新密钥

deriveBits

用于派生位的密钥

wrapKey

key 用于包装 key

unwrapKey

key 用于解包密钥

сrypto.subtle.digest(算法， 数据)

生成给定数据的摘要。 将摘要算法要使用的标识符作为其参数 以及要消化的数据。 返回 a ，该 ID 将与摘要一起完成。 可能的值：Promise

algorithm

是一个字符串，用于定义要使用的哈希函数：（不适用于加密应用程序）、、 或SHA-1SHA-256SHA-384SHA-512

data

是 ， 或 ，其中包含要摘要的数据ArrayBufferTypedArrayDataView

сrypto.subtle.exportKey(格式， 键)

导出 key：将 key 作为 一个 CryptoKey 对象 并以外部可移植格式返回密钥 （自 0.7.10 起）。 如果 是 ， 然后 fulfills with a JSON 对象 包含密钥。 否则，promise 将执行包含 key 的 action。 可能的值：formatjwkPromiseArrayBuffer

format

一个字符串，用于描述应用于导出键的数据格式， 可以是以下内容：

raw

原始数据格式

pkcs8

PKCS #8 格式

spki

SubjectPublicKeyInfo 格式

jwk

JSON Web Key （JWK） 格式（自 0.7.10 起)

key

包含需要导出的密钥的 CryptoKey

сrypto.subtle.generateKey(算法， 可提取， 用法)

为对称算法生成新密钥 或公钥算法的密钥对 （自 0.7.10 起）。 返回一个 fulfilled 的 key 如 一个 CryptoKey 或 CryptoKeyPair 对象。 可能的值：Promise

algorithm

定义要生成的 Key 类型的 Dictionary 对象 并提供额外的特定于算法的参数：

• 对于 、 或 、 、 使用以下键传递对象：RSASSA-PKCS1-v1_5RSA-PSSRSA-OAEP
  • name是一个字符串，应设置为 、 、 或 、 取决于使用的算法RSASSA-PKCS1-v1_5RSA-PSSRSA-OAEP
  • hash是一个字符串，表示 要使用的函数的名称可以是 、 或digestSHA-256SHA-384SHA-512
• 为 使用以下键传递对象：ECDSA
  • name是一个字符串，则应设置为ECDSA
  • namedCurve是一个字符串，表示 要使用的椭圆曲线的名称可以是 、 或P-256P-384P-521
• 为 使用以下键传递对象：HMAC
  • name是一个字符串，则应设置为HMAC
  • hash是一个字符串，表示 要使用的函数的名称可以是 、 或digestSHA-256SHA-384SHA-512
  • length（可选） 是一个数字，表示 键的长度（以位为单位）。 如果省略，则键的长度等于摘要的长度 由所选的 Digest 函数生成。
• 对于 、 或 、 、 传递标识算法或对象的字符串 的形式为 ， 其中 是算法的名称AES-CTRAES-CBCAES-GCM{ "name": "ALGORITHM" }ALGORITHM

extractable

boolean 值，该值指示是否可以导出键

usage

一个，它指示可能的作，键为：array

encrypt

用于加密消息的密钥

decrypt

用于解密消息的密钥

sign

用于对消息进行签名的密钥

verify

验证签名的密钥

deriveKey

key 用于派生新密钥

deriveBits

用于派生位的密钥

wrapKey

key 用于包装 key

unwrapKey

key 用于解包密钥

сrypto.subtle.importKey(format， keyData， algorithm， extractable， keyUsages)

导入密钥：将外部可移植格式的密钥作为输入 并给出一个 CryptoKey 对象。 返回使用导入的 key 实现的 作为 CryptoKey 对象。 可能的值：Promise

format

描述要导入的 Key 的数据格式的字符串， 可以是以下内容：

raw

原始数据格式

pkcs8

PKCS #8 格式

spki

SubjectPublicKeyInfo 格式

jwk

JSON Web Key （JWK） 格式（自 0.7.10 起)

keyData

包含给定格式的键的 ， 或 对象ArrayBufferTypedArrayDataView

algorithm

定义要导入的键类型的 Dictionary 对象 并提供额外的特定于算法的参数：

• 对于 、 或 、 、 使用以下键传递对象：RSASSA-PKCS1-v1_5RSA-PSSRSA-OAEP
  • name是一个字符串，应设置为 、 、 或 、 取决于使用的算法RSASSA-PKCS1-v1_5RSA-PSSRSA-OAEP
  • hash是一个字符串，表示 要使用的函数的名称可以是 、 或digestSHA-1SHA-256SHA-384SHA-512
• 为 使用以下键传递对象：ECDSA
  • name是一个字符串，则应设置为ECDSA
  • namedCurve是一个字符串，表示 要使用的椭圆曲线的名称可以是 、 或P-256P-384P-521
• 为 使用以下键传递对象：HMAC
  • name是一个字符串，则应设置为HMAC
  • hash是一个字符串，表示 要使用的函数的名称可以是 、 或digestSHA-256SHA-384SHA-512
  • length（可选） 是一个数字，表示 键的长度（以位为单位）。 如果省略，则键的长度等于摘要的长度 由所选的 Digest 函数生成。
• 对于 、 或 、 、 传递标识算法或对象的字符串 的形式为 ， 其中 是算法的名称AES-CTRAES-CBCAES-GCM{ "name": "ALGORITHM" }ALGORITHM
• 为 传递字符串PBKDF2PBKDF2
• 为 传递字符串HKDFHKDF

extractable

boolean 值，该值指示是否可以导出键

keyUsages

一个，它指示可能的作，键为：array

encrypt

用于加密消息的密钥

decrypt

用于解密消息的密钥

sign

用于对消息进行签名的密钥

verify

验证签名的密钥

deriveKey

key 用于派生新密钥

deriveBits

用于派生位的密钥

wrapKey

key 用于包装 key

unwrapKey

key 用于解包密钥

сrypto.subtle.sign(算法， 键， 数据)

返回 a ，该 a 满足 包含签名。 可能的值：signaturePromiseArrayBuffer

algorithm

是指定要使用的签名算法的字符串或对象 及其参数：

• 为 传递标识算法或对象的字符串 的形式RSASSA-PKCS1-v1_5{ "name": "ALGORITHM" }
• 为 使用以下键传递对象：RSA-PSS
  • name是一个字符串，则应设置为RSA-PSS
  • saltLength是一个 long，表示要使用的随机盐的长度（以字节为单位）integer
• 为 使用以下键传递对象：ECDSA
  • name是一个字符串，则应设置为ECDSA
  • hash是摘要算法要使用的标识符， 可以是 、 或SHA-256SHA-384SHA-512
• 为 传递标识算法或对象的字符串 的形式HMAC{ "name": "ALGORITHM" }

key

是一个 CryptoKey 对象 用于签名的密钥。 如果 algorithm 标识了公钥加密系统，则此密钥是私钥。

data

是包含要签名的数据的 ， 或 ObjectArrayBufferTypedArrayDataView

сrypto.subtle.verify(算法、密钥、签名、数据)

验证数字签名， 返回一个 fulfills，该 FULFILLS 具有布尔值：如果签名有效，则 否则。 可能的值：Promisetruefalse

algorithm

是指定要使用的算法的字符串或对象 及其参数：

• 为 传递标识算法或对象的字符串 的形式RSASSA-PKCS1-v1_5{ "name": "ALGORITHM" }
• 为 使用以下键传递对象：RSA-PSS
  • name是一个字符串，则应设置为RSA-PSS
  • saltLength是一个 long，表示要使用的随机盐的长度（以字节为单位）integer
• 为 使用以下键传递对象：ECDSA
  • name是一个字符串，则应设置为ECDSA
  • hash是摘要算法要使用的标识符， 可以是 、 或SHA-256SHA-384SHA-512
• 为 传递标识算法或对象的字符串 的形式HMAC{ "name": "ALGORITHM" }

key

是一个 CryptoKey 对象 该密钥用于验证。 它是对称算法的密钥 以及公钥系统的公钥。

signature

是包含要验证的签名的 ， 或ArrayBufferTypedArrayDataView

data

是 ， ， 或 对象，其中包含要验证其签名的数据ArrayBufferTypedArrayDataView

加密密钥

CryptoKey.algorithm

CryptoKey.extractable

CryptoKey.type

CryptoKey.usages

对象 表示获取的加密 从以下方法之一：сrypto.subtle.generateKey（）、сrypto.subtle.deriveKey（）、сrypto.subtle.importKey（）中。CryptoKeykeySubtleCrypto

CryptoKey.algorithm

返回一个对象，描述此键可用于的算法 和任何关联的额外参数 （自 0.8.0 起）， 只读

CryptoKey.extractable

布尔值（如果键可以导出） （自 0.8.0 起）， 只读true

CryptoKey.type

一个字符串值，指示对象表示哪种键， 只读。 可能的值：

secret

此密钥是用于对称算法的密钥。

private

此密钥是非对称算法的 CryptoKeyPair 的私有部分

public

此密钥是非对称算法的 CryptoKeyPair 的公有部分。

CryptoKey.usages

一个字符串数组，指示此键的用途 （自 0.8.0 起）， 只读。 可能的数组值：

encrypt

用于加密消息的密钥

decrypt

用于解密消息的密钥

sign

用于对消息进行签名的密钥

verify

验证签名的密钥

deriveKey

key 用于派生新密钥

deriveBits

用于派生位的密钥

加密密钥对

CryptoKeyPair.privateKey

CryptoKeyPair.publicKey

is a dictionary 对象 表示非对称密钥对的 WebCrypto API。CryptoKeyPair

CryptoKeyPair.privateKey

一个 CryptoKey 对象 表示私钥。

CryptoKeyPair.publicKey

一个 CryptoKey 对象 表示公钥。

新泽西州

njs.version

njs.version_number

njs.dump()

njs.memoryStats

njs.on()

对象是全局对象 表示当前 VM 实例 （自 0.2.0 起）。njs

njs.version

返回具有当前 njs 版本的字符串 （例如，“0.7.4”）。

njs.version_number

返回一个包含当前版本 njs 的数字。 例如，“0.7.4” 返回为 （自 0.7.4 起）。0x000704

njs.dump(value)

返回值的 pretty-print 字符串表示形式。

njs.memoryStats

包含当前 VM 实例的内存统计信息的对象 （自 0.7.8 起）。

size

从作系统申请的 NJS 内存池的内存量（以字节为单位）。

njs.on(event, callback)

为指定的 VM 事件注册回调 （自 0.5.2 起）。 事件可以是以下字符串之一：

exit

在 VM 销毁之前调用。 调用 callback 时不带参数。

过程

process.argv

process.env

process.kill()

process.pid

process.ppid

对象是全局对象 ，提供有关当前进程的信息 （0.3.3） 的process

process.argv

返回包含命令行参数的数组 在启动当前进程时传递。

process.env

返回包含用户环境的对象。

默认情况下，nginx 会删除所有继承的环境变量 从其父进程（TZ 变量除外）。 使用 env 指令 以保留一些继承的变量。

process.kill(pid, number | string)

将信号发送到由 标识的进程。 信号名称是数字或字符串，例如 'SIGINT' 或 'SIGHUP'。 有关更多信息，请参见 kill（2）。pid

process.pid

返回当前进程的 PID。

process.ppid

返回当前父进程的 PID。

字符串

默认情况下，njs 中的所有字符串都是 Unicode 字符串。 它们对应于包含 Unicode 字符的 ECMAScript 字符串。 在 0.8.0 之前， 还支持字节字符串。

字节字符串

从 0.8.0 开始， 删除了对字节字符串和字节字符串方法的支持。 使用字节序列时， Buffer 对象 以及 r.requestBuffer、r.rawVariables 等属性， 应该使用。Buffer

字节字符串包含字节序列 和 用于序列化 Unicode 字符串 添加到外部数据并从外部源反序列化。 例如，toUTF8（） 方法将 serialize 将 Unicode 字符串转换为使用 UTF-8 编码的字节字符串：

>> '£'.toUTF8().toString('hex')
'c2a3'  /* C2 A3 is the UTF-8 representation of 00A3 ('£') code point */

toBytes（） 方法序列化 一个 Unicode 字符串，代码点最多 255 个字节字符串， 否则，返回：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）、 编码可以是 、 和 。hexbase64base64url

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 之前， 将字符串编码为 、 或 ：hexbase64base64url

>>  'αβγδ'.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 之前， 序列化 Unicode 字符串 转换为使用 UTF-8 编码的字节字符串：

>> 'αβγδ'.toUTF8().length
8
>> 'αβγδ'.length
4

Web API

文本解码器

TextDecoder()

TextDecoder.prototype.encoding

TextDecoder.prototype.fatal

TextDecoder.prototype.ignoreBOM

TextDecoder.prototype.decode()

这会产生一个码位流 从字节流 （0.4.3） 的日志。TextDecoder

TextDecoder([[encoding], options])

创建新对象 对于指定的 ， 目前仅支持 UTF-8。 具有以下属性的 is 字典：TextDecoderencodingoptionsTextDecoderOptions

fatal

boolean 标志，指示 TextDecoder.decode（） 是否必须在 发现编码错误，默认情况下为 。TypeErrorfalse

TextDecoder.prototype.encoding

返回一个字符串，其中包含 TextDecoder（） 使用的编码名称， 只读。

TextDecoder.prototype.fatal

boolean 标志，如果 错误模式是致命的， 只读。true

TextDecoder.prototype.ignoreBOM

boolean 标志，如果 字节顺序标记被忽略， 只读。true

TextDecoder.prototype.decode(buffer, [options])

返回一个字符串，其中包含文本 从 TextDecoder（） 解码。 缓冲区可以是 。 具有以下属性的 is 字典：bufferArrayBufferoptionsTextDecodeOptions

stream

布尔标志，指示 if 在后续调用 ： 如果以块为单位处理数据，则后续将执行其他数据，并且对于最后一个块 或者如果数据未分块。 默认情况下为 。decode()truefalsefalse

>> (new TextDecoder()).decode(new Uint8Array([206,177,206,178]))
αβ

文本编码器

TextEncoder()

TextEncoder.prototype.encode()

TextEncoder.prototype.encodeInto()

对象 生成具有 UTF-8 编码的字节流 从代码点流 （0.4.3） 的日志。TextEncoder

TextEncoder()

返回一个新构造的，该 JSON 将生成一个 UTF-8 编码的字节流。TextEncoder

TextEncoder.prototype.encode(string)

编码为 具有 UTF-8 编码文本的 。stringUint8Array

TextEncoder.prototype.encodeInto(string, uint8Array)

将 a 编码为 UTF-8， 将结果放入 destination 中，并将 返回一个 Dictionary 对象，该对象显示编码的进度。 dictionary 对象包含两个成员：stringUint8Array

read

源中转换为 UTF-8 的 UTF-16 代码单位数string

written

目标中修改的字节数Uint8Array

定时器

clearTimeout()

setTimeout()

clearTimeout(timeout)

取消对象 由 setTimeout（） 创建。timeout

setTimeout(function, milliseconds[, argument1, argumentN])

在指定数量的 后调用 。 可以将一个或多个 optional 传递给指定的函数。 返回一个对象。functionmillisecondsargumentstimeout

function handler(v)
{
    // ...
}

t = setTimeout(handler, 12);

// ...

clearTimeout(t);

全局函数

atob()

btoa()

atob(encodedData)

解码已编码的数据字符串 使用编码。 该参数是一个二进制字符串 ，其中包含 Base64 编码的数据。 返回一个字符串，其中包含来自 的解码数据。Base64encodedDataencodedData

类似的 btoa（） 方法 可用于编码和传输数据 否则可能会导致通信问题， 然后传输它并使用 再次解码数据。 例如，您可以对控制字符进行编码、传输和解码 例如 ASCII 值到 .atob()031

const encodedData = btoa("text to encode"); // encode a string
const decodedData = atob(encodedData); // decode the string

btoa(stringToEncode)

从二进制字符串创建 Base64 编码的 ASCII 字符串。 该参数是要编码的二进制字符串。 返回一个 ASCII 字符串，其中包含 的 Base64 表示形式。stringToEncodestringToEncode

该方法可用于对数据进行编码 否则可能会导致通信问题，传输它， 然后使用 atob（） 方法 再次解码数据。 例如，您可以对控制字符进行编码 例如 ASCII 值到 .031

const encodedData = btoa("text to encode"); // encode a string
const decodedData = atob(encodedData); // decode the string

内置模块

缓冲区

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]]))

分配指定 的新 Buffer。 如果未指定，则 Buffer 将填充为零。 如果指定，则 分配的 Buffer 将通过调用 buf.fill（fill） 进行初始化。 如果指定了 and，则 分配的 Buffer 将通过调用 buf.fill（fill， 编码）的sizefillfillfillencoding

参数可以是 、 、 或 。fillstringBufferUint8Arrayinteger

Buffer.allocUnsafe(size)

与 Buffer.alloc（） 相同， 不同之处在于，分配给缓冲区的内存未初始化， 新缓冲区的内容未知，可能包含敏感数据。

Buffer.byteLength(value[, encoding])

返回指定值的字节长度， 使用 . 该值可以是 、 、 、 或 。 如果值为 ， 参数是它的编码，可以是 、 ; 默认情况下为 。encodingstringBufferTypedArrayDataViewArrayBufferstringencodingutf8hexbase64base64urlutf8

Buffer.compare(buffer1, buffer2)

与对 Buffer 实例的数组进行排序时进行比较。 返回 if 与 相同，如果排序时应排在前面，或者排序时应排在后面。buffer1buffer20buffer1buffer21buffer2buffer1-1buffer2buffer1

Buffer.concat(list[, totalLength])

返回新的 Buffer 这是连接列表中所有 Buffer 实例的结果。 如果列表中没有项或总长度为 0， 返回一个新的零长度 Buffer。 如果未指定，则 它是从 Buffer instances in 列表中计算的，方法是将它们的长度相加。 如果指定，则 它被强制转换为无符号整数。 如果 Buffers in 列表的组合长度超过 ， 结果被截断为 。totalLengthtotalLengthtotalLengthtotalLength

Buffer.from(array)

使用字节数组分配新的 Buffer 在范围 – 中。 超出该范围的数组条目将被截断。0255

Buffer.from(arrayBuffer, byteOffset[, length]])

在不复制底层内存的情况下创建 的视图。 可选 and 参数 指定 Buffer 将共享的内存范围。ArrayBufferbyteOffsetlengtharrayBuffer

Buffer.from(buffer)

将传递的缓冲区数据复制到新的 Buffer 实例上。

Buffer.from(object[, offsetOrEncoding[, length]])

对于函数 返回一个不严格等于 object 的值， 返回 、 、 ）。valueOf()Buffer.from(object.valueOf()offsetOrEncodinglength

Buffer.from(string[, encoding])

创建一个具有 . 该参数标识字符编码 在将字符串转换为字节时使用。 编码可以是 、 、 、 ; 默认情况下为 。stringencodingutf8hexbase64base64urlutf8

Buffer.isBuffer(object)

布尔值 如果是 Buffer，则返回。trueobject

Buffer.isEncoding(encoding)

布尔值 如果 encoding 是支持的字符编码的名称，则返回。true

buffer[index]

可用于获取和设置八位字节的索引运算符 在 中的位置。 这些值是指单个字节， 因此，合法值范围介于 0 和 255 （十进制） 之间。indexbuffer

buf.buffer

底层对象 此 Buffer 对象创建的基础。ArrayBuffer

buf.byteOffset

整数 指定 Buffer 的 底层对象。byteOffsetArrayBuffer

buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])

将缓冲区与数字进行比较并返回一个数字 指示缓冲区是位于 Cellout 之前、之后还是相同 如按排序顺序。 比较基于每个 Buffer 中的实际字节序列。 是一个整数，指定 开始比较的偏移量， 默认为 0。 是一个整数，指定 结束比较的偏移量， 默认情况下为 。 是一个整数，指定 缓冲区内开始比较的偏移量， 默认为 0。 是一个整数，指定 缓冲区中结束比较的偏移量（不包括）， 默认情况下为 。targettargettargetStarttargettargetEndtargettarget.lengthsourceStartsourceEndbuf.length

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])

将数据从缓冲区区域复制到 中的 区域 。 即使目标内存区域与 buffer 重叠。 参数是 a 或 要复制到。targettargetBufferUint8Array

是一个整数，指定 目标中开始写入的偏移量， 默认为 0。 是一个整数，指定 缓冲区中要开始复制的偏移量， 默认为 0。 是一个整数，指定 缓冲区中要停止复制的偏移量 （不包括） 默认情况下为 。targetStartsourceStartsourceEndbuf.length

buf.equals(otherBuffer)

布尔值 如果 Buffer 和 的字节完全相同，则返回。trueotherBuffer

buf.fill(value[, offset[, end]][, encoding])

使用指定的 . 如果未指定 and，则 将填充整个 Buffer。 如果 不是 、 、 或 ，则强制为 。 如果生成的整数大于 255，则 Buffer 将填充 和 255。valueoffsetendvalueuint32stringBufferintegervalue

buf.includes(value[, byteOffset][, encoding])

相当于 buf.indexOf（） ， 如果找到 在 Buffer 中。!== -1truevalue

buf.indexOf(value[, byteOffset][, encoding])

返回一个整数，该整数是 Buffer 中首次出现的索引，或者如果 Buffer 不包含 value。 可以是指定（默认）、、 、 或介于 0 和 255 之间的数字。value-1valuestringencodingutf8BufferUnit8Array

buf.lastIndexOf(value[, byteOffset][, encoding])

与 buf.indexOf（） 相同， 除了找到 the 的最后一个匹配项 而不是第一次出现。 可以是 string、Buffer 或 介于 1 和 255 之间的整数。 如果 是空字符串或空 Buffer，则返回。valuevaluevaluebyteOffset

buf.length

返回 Buffer 中的字节数。

buf.readIntBE(offset, byteLength)

在指定的位置读取 from 并将结果解释为 big-endian， 二进制补码有符号值，支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthbufoffsetbyteLength

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

buf.readIntLE(offset, byteLength)

在指定的位置读取 from 并将结果解释为 little-endian， 二进制补码有符号值，支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthbufoffsetbyteLength

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

buf.readUIntBE(offset, byteLength)

在指定的位置读取 from 并将结果解释为 big-endian 整数，支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthbufoffsetbyteLength

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

buf.readUIntLE(offset, byteLength)

在指定的位置读取 from 并将结果解释为 little-endian 整数，支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthbufoffsetbyteLength

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

buf.readDoubleBE([offset])

从指定的 .bufoffset

buf.readDoubleLE([offset])

从指定的 处读取 64 位小端双精度值。bufoffset

buf.readFloatBE([offset])

从指定的 处读取 32 位大端浮点数。bufoffset

buf.readFloatLE([offset])

从指定的 处读取 32 位小端浮点数。bufoffset

buf.subarray([start[, end]])

返回引用与原始内存相同的 new 内存， 但 offset 并被 和 裁剪。 如果大于 buf.length，则 返回的结果与 end 等于 buf.length 的结果相同。bufstartendend

buf.slice([start[, end]])

返回引用与原始内存相同的 new 内存， 但 offset 和 cropped by the and 值。 该方法与 不兼容 ， 它是 Buffer 的超类。 要复制切片，请使用 .bufstartendUint8Array.prototype.slice()Uint8Array.prototype.slice()

buf.swap16()

解释为无符号 16 位数字数组 并就地交换字节顺序。 如果 buf.length 不是 2 的倍数，则引发错误。buf

buf.swap32()

解释为无符号 32 位数字数组 并就地交换字节顺序。 如果 buf.length 不是 4 的倍数，则引发错误。buf

buf.swap64()

解释为 64 位数字数组 并就地交换字节顺序。 如果 buf.length 不是 8 的倍数，则引发错误。buf

buf.toJSON()

返回在字符串化 Buffer 实例时隐式调用此函数的 JSON 表示形式。buf.JSON.stringify()

buf.toString([encoding[, start[, end]]])

解码为字符串 根据指定的字符可以是 、 。 和 参数 可以传递以仅解码 Buffer 的子集。bufencodingutf8hexbase64base64urlstartend

buf.write(string[, offset[, length]][, encoding])

根据字符 将 to at 写入 。 该参数是要写入的字节数。 如果 Buffer 不包含足够的空间来容纳整个字符串，则 只会写入 String 的一部分， 但是，不会写入部分编码的字符。 可以是 、 、 、 。stringbufoffsetencodinglengthencodingutf8hexbase64base64url

buf.writeIntBE(value, offset, byteLength)

在指定为 big-endian 的位置写入 to 的字节。 支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthvaluebufoffsetbyteLength

还支持以下类似的方法：、、 、 .buf.writeInt8buf.writeInt16BEbuf.writeInt32BE

buf.writeIntLE(value, offset, byteLength)

将 的字节数写入指定的 little-endian。 支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthvaluebufoffsetbyteLength

还支持以下类似的方法：、、 、 .buf.writeInt8buf.writeInt16LEbuf.writeInt32LE

buf.writeUIntBE(value, offset, byteLength)

在指定为 big-endian 的位置写入 to 的字节。 支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthvaluebufoffsetbyteLength

还支持以下类似的方法：、、 、 .buf.writeUInt8buf.writeUInt16BEbuf.writeUInt32BE

buf.writeUIntLE(value, offset, byteLength)

将 的字节数写入指定的 little-endian。 支持高达 48 位的精度。 该参数是介于 1 和 6 之间的整数 指定要读取的字节数。byteLengthvaluebufoffsetbyteLength

还支持以下类似的方法：、、 、 .buf.writeUInt8buf.writeUInt16LEbuf.writeUInt32LE

buf.writeDoubleBE(value, [offset])

将 to 写入指定的 big-endian。valuebufoffset

buf.writeDoubleLE(value, [offset])

将 to 写入指定的 little-endian。valuebufoffset

buf.writeFloatBE(value, [offset])

将 to 写入指定的 big-endian。valuebufoffset

buf.writeFloatLE(value, [offset])

将 to 写入指定的 little-endian。valuebufoffset

加密

crypto.createHash()

crypto.createHmac()

从 0.7.0 开始， 扩展加密 API 可用作全局加密对象。

Crypto 模块提供加密功能支持。 Crypto 模块对象由 返回。require('crypto')

crypto.createHash(algorithm)

创建并返回 Hash 对象 可用于生成哈希摘要 使用给定的 . 算法可以是 、 和 。algorithmmd5sha1sha256

crypto.createHmac(algorithm, secret key)

创建并返回一个 HMAC 对象，该对象使用 给定的 和 . 算法可以是 、 和 。algorithmsecret keymd5sha1sha256

散 列

hash.update()

hash.digest()

hash.update(data)

使用给定的 .data

hash.digest([encoding])

计算使用 传递的所有数据的摘要。 编码可以是 、 和 。 如果未提供编码，则 Buffer 对象 （0.4.4） 返回。hash.update()hexbase64base64url

在 0.4.4 版本之前， 返回字节字符串，而不是 Buffer 对象。

hash.copy()

复制哈希的当前状态 （自 0.7.12 起）。

>> var cr = require('crypto')
undefined

>> cr.createHash('sha1').update('A').update('B').digest('base64url')
'BtlFlCqiamG-GMPiK_GbvKjdK10'

HMAC

hmac.update()

hmac.digest()

hmac.update(data)

使用给定的 .data

hmac.digest([encoding])

计算使用 传递的所有数据的 HMAC 摘要。 编码可以是 、 和 。 如果未提供编码，则 Buffer 对象 （0.4.4） 返回。hmac.update()hexbase64base64url

在 0.4.4 版本之前， 返回字节字符串，而不是 Buffer 对象。

>> var cr = require('crypto')
undefined

>> cr.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

File Access Constants

File System Flags

File System 模块提供文件作。

module 对象由 返回。 从 0.3.9 开始， 文件系统方法的 Promissified 版本可通过 Object 获得：require('fs')require('fs').promises

> var fs = require('fs').promises;
undefined
> fs.readFile("/file/path").then((data)=>console.log(data))
<file data>

accessSync(path[, mode])

同步测试文件或目录的权限 在 （0.3.9） 中指定。 如果检查失败，将返回错误。 否则，该方法将返回 undefined。path

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])

将指定的 . 这应该是一个字符串 或 Buffer 对象 （0.4.4）。 如果该文件不存在，则将创建该文件。 该参数应为 具有以下键的对象：datafilenamedataoptions

mode

mode 选项，默认情况下为0o666

flag

文件系统标志、 默认情况下为a

closeSync(fd)

关闭由整数表示的文件描述符 由 method 使用。 返回。fdundefined

existsSync(path)

布尔值，如果指定的值存在，则返回。 （0.8.2truepath)

fstatSync(fd)

检索 fs。Stats 对象 对于文件描述符 （0.7.7） 的。 参数为整数 表示该方法使用的文件描述符。fd

lstatSync(path[, options])

同步检索 FS.Stats 对象 对于 （0.7.1） 引用的符号链接。 该参数应为 具有以下键的对象：pathoptions

throwIfNoEntry

一个布尔值，指示 如果不存在文件系统条目，是否引发异常， 而不是返回， 默认情况下为 。undefinedfalse

mkdirSync(path[, options])

在指定的 （0.4.2） 同步创建一个目录。 该参数应为指定 众数、 或具有以下键的对象：pathoptionsinteger

mode

mode 选项，默认情况下为 。0o777

openSync(path[, flags[, mode]])

返回一个整数 表示打开的文件的文件描述符 （0.7.7）。path

flags

文件系统标志、 默认情况下为r

mode

mode 选项，默认情况下为0o666

promises.open(path[, flags[, mode]])

返回 FileHandle 对象 表示打开的文件 （0.7.7）。path

flags

文件系统标志、 默认情况下为r

mode

mode 选项，默认情况下为0o666

readdirSync(path[, options])

同步读取目录的内容 设置为指定的 （0.4.2）。 该参数应为 指定 encoding 的字符串或具有以下键的对象：pathoptions

encoding

encoding 的默认值为 . 编码可以是 and （0.4.4）。utf8utf8buffer

withFileTypes

如果设置为 ，则 files 数组将包含 fs。不同的对象， 默认情况下为 。truefalse

readFileSync(filename[, options])

同步返回文件的内容 与提供的 . 指定编码的参数 hold。 如果指定了编码，则返回一个字符串， 否则，为 Buffer 对象 （0.4.4） 返回。filenameoptionsstring

在 0.4.4 版本之前， 返回了字节字符串 如果未指定编码。

否则，应为 具有以下键的对象：options

encoding

encoding 时，默认情况下未指定。 编码可以是 、 （0.4.4）、 （0.4.4）、 （0.4.4）。utf8hexbase64base64url

flag

文件系统标志、 默认情况下为r

>> var fs = require('fs')
undefined
>> var file = fs.readFileSync('/file/path.tar.gz')
undefined
>> var gzipped = file.slice(0,2).toString('hex') === '1f8b'; gzipped
true

readlinkSync(path[, options])

使用 readlink（2） 同步获取符号链接的内容 （0.8.7）。 参数可以是指定编码的字符串， 或具有属性 指定要使用的字符编码。 如果 为 ， 结果以对象 否则为 string。pathoptionsencodingencodingbufferBuffer

readSync(fd, buffer, offset[, length[, position]])

使用 file descriptor 读取文件路径的内容 返回读取的字节数 （0.7.7） 的。fd

buffer

该值可以是 、 或bufferBufferTypedArrayDataView

offset

是一个表示 缓冲区中要写入数据的位置integer

length

是一个表示 要读取的字节数integer

position

指定从文件中开始读取的位置， 值可以是 或 ， 默认情况下为 。 如果 是 ， data 将从当前文件位置读取， ，文件位置将更新。 如果 position 为 ， 文件位置将保持不变integernullnullpositionnullinteger

realpathSync(path[, options])

通过使用 realpath（3） 解析 和 符号链接来同步计算规范路径名。 参数可以是指定编码的字符串， 或具有指定字符编码的 encoding 属性的对象 用于传递给回调的路径 （0.3.9） 的。...options

renameSync(oldPath, newPath)

同步将文件的名称或位置从 更改为 （0.3.4）。oldPathnewPath

>> var fs = require('fs')
undefined
>> var file = fs.renameSync('hello.txt', 'HelloWorld.txt')
undefined

rmdirSync(path)

同步删除指定 （0.4.2） 的目录。path

statSync(path,[ options])

同步检索 FS.Stats 对象 对于指定的 （0.7.1）。 可以是 a 或 . 该参数应为 具有以下键的对象：pathpathstringbufferoptions

throwIfNoEntry

一个布尔值，指示 如果不存在文件系统条目，则会引发异常 而不是返回 ， 默认情况下为 。undefinedtrue

symlinkSync(target, path)

使用 symlink（2） 同步创建名为 指向 的链接 （0.3.9）。 相对目标是相对于链接的父目录。pathtarget

unlinkSync(path)

通过 （0.3.9） 同步取消链接文件。path

writeFileSync(filename, data[, options])

同步写入文件 与提供的 . 这应该是一个字符串 或 Buffer 对象 （0.4.4）。 如果文件不存在，则会创建该文件， 如果文件存在，则将被替换。 该参数应为 具有以下键的对象：datafilenamedataoptions

mode

mode 选项，默认情况下为0o666

flag

文件系统标志、 默认情况下为w

>> var fs = require('fs')
undefined
>> var file = fs.writeFileSync('hello.txt', 'Hello world')
undefined

writeSync(fd, buffer, offset[, length[, position]])

使用文件描述符将缓冲区写入文件， 返回写入的字节数 （0.7.7） 的。number

fd

表示文件描述符的 aninteger

buffer

该值可以是 、 或bufferBufferTypedArrayDataView

offset

是一个确定 要写入的缓冲区部分， 默认情况下integer0

length

是指定要写入的字节数， 默认情况下是 Buffer.byteLength 的偏移量integer

position

指距文件开头的偏移量 此数据应写入何处， 可以是 或 ， 默认情况下为 。 另请参见 pwrite（2）。integernullnull

writeSync(fd, string[, position[, encoding]])

将 写入文件 使用 File Descriptor ， 返回写入的字节数 （0.7.7） 的。stringfdnumber

fd

是表示文件描述符的integer

position

指距文件开头的偏移量 此数据应写入何处， 可以是 或 ，默认情况下为 。 参见 pwrite（2）integernullnull

encoding

是 ， 默认情况下为stringutf8

司 司长。迪伦特

fs.Dirent是目录条目的表示形式 — 文件或子目录。 当使用 withFileTypes 选项调用 readdirSync（） 时， 生成的数组包含对象。fs.Dirent

• dirent.isBlockDevice()— 如果对象描述 块设备。truefs.Dirent
• dirent.isCharacterDevice()— 如果对象描述 字符设备。truefs.Dirent
• dirent.isDirectory()— 如果对象描述 文件系统目录。truefs.Dirent
• dirent.isFIFO()— 如果对象描述 先进先出 （FIFO） 管道。truefs.Dirent
• dirent.isFile()— 如果对象描述 常规文件。truefs.Dirent
• dirent.isSocket()— 如果对象描述 一个 socket。truefs.Dirent
• dirent.isSymbolicLink()— 如果对象描述 一个符号链接。truefs.Dirent
• dirent.name— 文件对象引用的名称。fs.Dirent

司 司长。文件句柄

filehandle.close()

filehandle.fd

filehandle.read()

filehandle.stat()

filehandle.write(buf)

filehandle.write(str)

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

filehandle.close()

在等待句柄上的任何待处理作后关闭文件句柄 以完成。 返回 ， 成功后 fulfills with undefined。promise

filehandle.fd

数字文件描述符 managed 的 MANAGED 对象。FileHandle

filehandle.read(buffer, offset[, length[, position]])

从文件中读取数据并将其存储在给定的缓冲区中。

buffer

一个缓冲区，将填充读取的文件数据， 该值可以是 、 或BufferTypedArrayDataView

offset

是一个 表示缓冲区中开始填充的位置integer

length

是一个 表示要读取的字节数integer

position

开始从文件中读取数据的位置， 该值可以是 ， 。 如果 ，将从当前文件位置读取数据 ，并且位置将更新。 如果 position 为 ， 当前文件位置将保持不变。integernullnullinteger

返回一个 成功后满足 替换为具有两个属性的对象：Promise

bytesRead

是一个 表示读取的字节数integer

buffer

是对 buffer 中传递的参数的引用，可以是 、 、 或BufferTypedArrayDataView

filehandle.stat()

使用 fs 完成。文件的 Stats、 返回 .promise

filehandle.write(buffer, offset[, length[, position]])

将缓冲区写入文件。

buffer

该值可以是 、 或bufferBufferTypedArrayDataView

offset

是一个表示 缓冲区中要写入的数据开始的起始位置integer

length

是一个表示 默认情况下，要从缓冲区写入的字节数 是 Buffer.byteLength 的偏移量integer

position

距文件开头的偏移量 其中应写入 buffer 中的数据， 可以是 或 ， 默认情况下为 。 如果不是 ， 数据将写入当前位置。 有关详细信息，请参阅 POSIX pwrite（2） 文档。integernullnullpositionnumber

返回 a ，该 a 通过对象解析 包含两个属性：Promise

bytesWritten

是一个 表示写入的字节数integer

buffer

对写入的缓冲区的引用可以是 、 、 或BufferTypedArrayDataView

多次使用不安全 在同一个文件上，而无需等待 Promise 被解决或拒绝。filehandle.write()

filehandle.write(string[, position[, encoding]])

将 a 写入文件。string

position

距文件开头的偏移量 其中应写入 buffer 中的数据， 可以是 或 ， 默认情况下为 。 如果不是 ， 数据将写入当前位置。 有关详细信息，请参阅 POSIX pwrite（2） 文档。integernullnullpositionnumber

encoding

默认情况下，字符串的预期编码utf8

返回 a ，该 a 通过对象解析 包含两个属性：Promise

bytesWritten

是一个 表示写入的字节数integer

buffer

对写入的缓冲区的引用可以是 、 、 或BufferTypedArrayDataView

多次使用不安全 在同一个文件上，而无需等待 Promise 被解决或拒绝。filehandle.write()

司 司长。统计

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

• stats.isBlockDevice()— 如果对象描述 块设备。truefs.Stats
• stats.isDirectory()— 如果对象描述 文件系统目录。truefs.Stats
• stats.isFIFO()— 如果对象描述 先进先出 （FIFO） 管道。truefs.Stats
• stats.isFile()— 如果对象描述 常规文件。truefs.Stats
• stats.isSocket()— 如果对象描述 一个 socket。truefs.Stats
• stats.isSymbolicLink()— 如果对象描述 一个符号链接。truefs.Stats
• 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— 表示的指示上次访问此文件的时间戳 以毫秒为单位。
• stats.mtimeMs— 表示的指示上次修改此文件的时间戳 以毫秒为单位。
• stats.ctimeMs— 表示的指示上次更改此文件的时间戳 以毫秒为单位。
• stats.birthtimeMs— 表示此文件的创建时间的 timestamp 以毫秒为单位。
• stats.atime— 指示上次访问此文件的时间戳。
• stats.mtime— 指示上次修改此文件的时间戳。
• stats.ctime— 指示上次更改此文件的时间戳。
• stats.birthtime— 表示此文件的创建时间的时间戳。

文件访问常量

access（） 方法 可以接受以下标志。 这些标志由以下机构导出：fs.constants

• F_OK— 表示文件 对调用进程可见， 如果未指定模式，则默认使用
• R_OK— 表示文件可以是 由调用进程读取
• W_OK— 表示文件可以是 由调用进程写入
• X_OK— 表示文件可以是 由调用进程执行

文件系统标志

该选项可以接受以下值：flag

• a- 打开要追加的文件。 如果文件不存在，则创建该文件
• ax— 与文件已存在时相同，但失败a
• a+- 打开一个文件进行读取和附加。 如果该文件不存在，则将创建该文件
• ax+— 与文件已存在时相同，但失败a+
• as- 打开文件以进行附加 在同步模式下。 如果该文件不存在，则将创建该文件
• as+- 打开文件进行读取和附加 在同步模式下。 如果该文件不存在，则将创建该文件
• r— 打开文件进行读取。 如果文件不存在，则会发生异常
• r+— 打开文件进行读取和写入。 如果文件不存在，则会发生异常
• rs+— 打开文件进行读取和写入 在同步模式下。 指示作系统绕过本地文件系统缓存
• w— 打开文件进行写入。 如果该文件不存在，则将创建该文件。 如果文件存在，它将被替换
• wx— 与文件已存在时相同，但失败w
• w+— 打开文件进行读取和写入。 如果该文件不存在，则将创建该文件。 如果文件存在，它将被替换
• wx+— 与文件已存在时相同，但失败w+

查询字符串

querystring.decode()

querystring.encode()

querystring.escape()

querystring.parse()

querystring.stringify()

querystring.unescape()

Query String 模块提供支持 用于解析和格式化 URL 查询字符串 （0.4.3） 的日志。 Query String 模块对象由 返回。require('querystring')

querystring.decode()

是 querystring.parse（） 的别名。

querystring.encode()

是 querystring.stringify（） 的别名。

querystring.escape(string)

执行给定 的 URL 编码 ， 返回转义的查询字符串。 该方法由 querystring.stringify（） 使用，不应直接使用。string

querystring.parse(string[, separator[, equal[, options]]])

解析查询字符串 URL 并返回一个对象。

参数是一个子字符串 用于分隔查询字符串中的键和值对， 默认为 “”。separator&

参数是一个子字符串 用于分隔查询字符串中的键和值， 默认为 “”。equal=

该参数应为 具有以下键的对象：options

decodeURIComponent function

使用的功能 要解码查询字符串中的百分号编码字符，请执行以下作： 默认情况下为 queryString.unescape（）

maxKeys number

要解析的最大键数， 默认情况下为 。 该值消除了对键进行计数的限制。10000

默认情况下，假定查询字符串中的百分号编码字符 要使用 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 unsafe 字符设置为查询字符串中的百分号编码， 默认情况下为 queryString.escape（）。

默认情况下，查询字符串中需要百分比编码的字符 编码为 UTF-8。 如果需要其他编码，则应指定 option。encodeURIComponent

例如，对于以下命令

querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], 123: '' });

查询字符串将为：

'foo=bar&baz=qux&baz=quux&123='

querystring.unescape(string)

执行 URL 百分比编码字符的解码 的 ， 返回未转义的查询字符串。 该方法由 querystring.parse（） 使用，不应直接使用。string

XML 格式

xml.parse()

xml.c14n()

xml.exclusiveC14n()

xml.serialize()

xml.serializeToString()

XMLDoc

XMLNode

XMLAttr

XML 模块允许使用 XML 文档 （自 0.7.10 起）。 XML 模块对象由 返回。require('xml')

例：

const xml = require("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， 返回一个 XMLDoc 包装器对象 表示已解析的 XML 文档。

c14n(root_node[, excluding_node])

根据 Canonical XML Version 1.1 进行 Canonicalize 及其子项。 可以是 XMLNode 或 XMLDoc 包装器对象 围绕 XML 结构。 返回包含规范化输出的 Buffer 对象。root_noderoot_node

excluding_node

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

exclusiveC14n(root_node[, excluding_node[, withComments [,prefix_list]]])

根据 Exclusive XML 规范化及其子项 规范化版本 1.0。root_node

root_node

是 XMLNode 或 XMLDoc 包装器对象 围绕 XML 结构

excluding_node

允许从输出中省略文档的一部分 对应于 Node 及其子节点

withComments

默认情况下为 Boolean 值。 如果 ，则规范化对应于 Exclusive XML 规范化版本 1.0。 返回包含规范化输出的 Buffer 对象。falsetrue

prefix_list

带有空格分隔的命名空间前缀的可选字符串 对于也应包含在输出中的命名空间

serialize()

与 xml.c14n（） 相同（自 0.7.11 起）。

serializeToString()

与 xml.c14n（） 相同，只是它以 a 形式返回结果（自 0.7.11 起）。string

XMLDoc

围绕 XML 结构的 XMLDoc 包装器对象， 文档的根节点。

doc.$root

文档的根名称或 undefined

doc.abc

名为 XMLNode 包装器对象的第一个根标记abc

XMLNode

围绕 XML 标记节点的 XMLNode 包装对象。

node.abc

与 node.$tag$abc 相同

node.$attr$abc

节点的属性值 ， 写 自 0.7.11 起abc

node.$attr$abc=xyz

与 node.setAttribute（'abc'， xyz） 相同（自 0.7.11 起)

node.$attrs

一个 XMLAttr 包装器对象 对于节点的所有属性

node.$name

节点的名称

node.$ns

节点的命名空间

node.$parent

当前节点的父节点

node.$tag$abc

名为 的节点的第一个子标签 写 自 0.7.11 起abc

node.$tags

所有 children 标签的数组

node.$tags = [node1, node2, ...]

与 node.removeChildren（） 相同;node.addChild（node1）的node.addChild（node2）（自 0.7.11 起）。

node.$tags$abc

节点命名的所有 children 标签， 写 自 0.7.11 起abc

node.$text

节点的内容， 写 自 0.7.11 起

node.$text = 'abc'

与 node.setText（'abc'） 相同（自 0.7.11 起)

node.addChild(nd)

将 XMLNode 作为子节点添加到 Node （自 0.7.11 起）。 在添加到节点之前递归复制nd

node.removeAllAttributes()

删除节点的所有属性 （自 0.7.11 起)

node.removeAttribute(attr_name)

删除名为 （从 0.7.11 开始attr_name)

node.removeChildren(tag_name)

删除所有名为 （自 0.7.11 起） 的 children 标签。 如果不存在，则删除所有 children 标记tag_nametag_name

node.removeText()

删除节点的文本值 （0.7.11)

node.setAttribute(attr_name, value)

为 an 设置一个值（从 0.7.11 开始）。 当值为 时， 名为 deleted 的属性attr_namenullattr_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 模块对象由 返回。require('zlib')

deflateRawSync(string | Buffer[, options])

使用以字符串或 Buffer 形式提供的 “deflate” 算法压缩数据 并且不会附加 zlib 标头。 缓冲区值可以是 、 或 。 是包含 zlib_options 的可选对象。 返回包含压缩数据的 Buffer 实例。BufferTypedArrayDataViewOptions

deflateSync(string | Buffer[, options])

使用以 String 或 Buffer 形式提供的 “deflate” 算法压缩数据。 Buffer 值可以是 、 或 。 是包含 zlib_options 的可选对象。 返回包含压缩数据的 Buffer 实例。BufferTypedArrayDataViewOptions

inflateRawSync(string | Buffer)

使用 “deflate” 算法解压缩原始流。 返回包含解压缩数据的 Buffer 实例。

inflateSync(string | Buffer)

使用 “deflate” 算法解压缩流。 返回包含解压缩数据的 Buffer 实例。

zlib 选项

• chunkSize— 是一个整数， 默认情况下为1024
• dictionary— 是 、 或 。 默认情况下为空BufferTypedArrayDataView
• level— 是一个整数，仅压缩， 请参阅 zlib_compression_levels
• memLevel— 是一个整数 from to 、 仅压缩19
• strategy— 是一个整数，仅压缩， 请参阅 zlib_compression_strategy
• windowBits— 是一个整数 from to 表示原始数据， from to 表示普通流-15-9915

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	Filtered strategy：对于过滤器或预测器生成的数据
zlib.constants.Z_HUFFMAN_ONLY	仅 Huffman 策略：仅 Huffman 编码，无字符串匹配
zlib.constants.Z_RLE	游程编码策略：将匹配距离限制为 1，更好地压缩 PNG 图像数据
zlib.constants.Z_FIXED	固定表策略：防止使用动态霍夫曼码，为特殊应用提供更简单的解码器
zlib.constants.Z_DEFAULT_STRATEGY	默认策略，适用于通用压缩