参考 - Nginx 服务器

参考

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

NJS 提供了用于扩展 Nginx 功能的对象、方法和属性。

此参考仅包含不符合 ECMAScript 的 NJS 特定属性、方法和模块。符合 ECMAScript 的 NJS 属性和方法的定义可以在ECMAScript 规范中找到。可以在兼容性中找到所有 NJS 属性和方法的列表。

Nginx 对象

HTTP 请求

r.internalRedirect()

r.log()

r.uri

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"}

可以使用查询字符串模块和$args 变量来实现更高级的解析场景，例如

import qs from 'querystring';

function args(r) {
    return qs.parse(r.variables.args);
}

如果只需要单个参数，例如 foo，则可以使用Nginx 变量

r.variables.arg_foo

在这里，Nginx 变量对象返回给定键的第一个值，不区分大小写，不进行百分比解码。

要将 r.args 转换回字符串，可以使用查询字符串stringify 方法。

r.done()

调用此函数后，后续数据块将传递给客户端，而无需调用js_body_filter（0.5.2）。只能从js_body_filter 函数中调用

r.error(string)

将string 写入错误日志的 error 日志级别。

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

r.finish()

完成向客户端发送响应。

r.headersIn{}

传入头部对象，只读。

可以使用以下语法访问 Foo 请求头部：headersIn.foo 或 headersIn['Foo']。

“Authorization”、“Content-Length”、“Content-Range”、“Content-Type”、“ETag”、“Expect”、“From”、“Host”、“If-Match”、“If-Modified-Since”、“If-None-Match”、“If-Range”、“If-Unmodified-Since”、“Max-Forwards”、“Proxy-Authorization”、“Referer”、“Transfer-Encoding” 和 “User-Agent” 请求头部只能有一个字段值（0.4.1）。“Cookie” 头部中的重复字段值用分号 (;) 分隔。所有其他请求头部中的重复字段值用逗号分隔。

r.headersOut{}

主请求的传出头部对象，可写。

如果 r.headersOut{} 是子请求的响应对象，则它表示响应头部。在这种情况下，可以省略“Accept-Ranges”、“Connection”、“Content-Disposition”、“Content-Encoding”、“Content-Length”、“Content-Range”、“Date”、“Keep-Alive”、“Server”、“Transfer-Encoding”、“X-Accel-*” 响应头部中的字段值。

可以使用以下语法访问 Foo 响应头部：headersOut.foo 或 headersOut['Foo']。

在将响应头部发送到客户端之前应设置传出头部，否则将忽略头部更新。这意味着 r.headersOut{} 在以下情况下实际上是可写的：

js_content 处理程序在调用r.sendHeader() 或r.return() 之前
js_header_filter 处理程序

可以使用以下语法设置多值响应头部（0.4.0）的字段值：

r.headersOut['Foo'] = ['a', 'b']

输出将为

Foo: a
Foo: b

将删除“Foo” 响应头部之前的所有字段值。

对于仅接受单个字段值的标准响应头部（例如“Content-Type”，只有数组的最后一个元素才会生效。“Set-Cookie” 响应头部的字段值始终作为数组返回。“Age”、“Content-Encoding”、“Content-Length”、“Content-Type”、“ETag”、“Expires”、“Last-Modified”、“Location”、“Retry-After” 响应头部中的重复字段值将被忽略。所有其他响应头部中的重复字段值用逗号分隔。

r.httpVersion

HTTP 版本，只读。

r.internal

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

r.internalRedirect(uri)

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

重定向后，将在目标位置启动一个新的 NJS VM，原始位置中的 VM 将停止。将保留Nginx 变量的值，并可用于将信息传递到目标位置。自0.5.3 起，可以使用为http 或stream 使用 js_var 指令声明的变量。

自0.7.4 起，该方法接受转义的 URI。

r.log(string)

将string 写入错误日志的 info 日志级别。

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

r.method

HTTP 方法，只读。

r.parent

引用父请求对象。

r.remoteAddress

客户端地址，只读。

r.requestBody

此属性在0.5.0 中已弃用，并在0.8.0 中已删除。应改用r.requestBuffer 或r.requestText 属性。

r.requestBuffer

如果客户端请求正文尚未写入临时文件（自0.5.0 起），则为客户端请求正文。为了确保客户端请求正文位于内存中，其大小应受client_max_body_size 限制，并且应使用client_body_buffer_size 设置足够的缓冲区大小。此属性仅在js_content 指令中可用。

r.requestText

与r.requestBuffer 相同，但返回 string。请注意，它可能会将 UTF-8 编码中无效的字节转换为替换字符。

r.rawHeadersIn[]

返回键值对数组，与从客户端接收的完全相同（0.4.1）。

例如，使用以下请求头部

Host: localhost
Foo:  bar
foo:  bar2

r.rawHeadersIn 的输出将为

[
    ['Host', 'localhost'],
    ['Foo', 'bar'],
    ['foo', 'bar2']
]

可以使用以下语法收集所有 foo 头部

r.rawHeadersIn.filter(v=>v[0].toLowerCase() == 'foo').map(v=>v[1])

输出将为

['bar', 'bar2']

头部字段名称不会转换为小写，重复字段值不会合并。

r.rawHeadersOut[]

返回响应头部的键值对数组（0.4.1）。头部字段名称不会转换为小写，重复字段值不会合并。

r.responseBody

此属性在0.5.0 中已弃用，并在0.8.0 中已删除。应改用r.responseBuffer 或r.responseText 属性。

r.responseBuffer

保存子请求响应正文，只读（自0.5.0 起）。r.responseBuffer 的大小受subrequest_output_buffer_size 指令限制。

r.responseText

与r.responseBuffer 相同，但返回字符串（自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

状态，可写。

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接收一个子请求响应对象，其方法和属性与父请求对象相同。

从0.3.8版本开始，如果没有提供callback，则返回解析为子请求响应对象的Promise对象。

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

async function handler(r) {
    const reply = await r.subrequest('/path');

    for (const h in reply.headersOut) {
        r.log(`${h}: ${reply.headersOut[h]}`);
    }

    r.return(200);
}

r.uri

请求中的当前URI，已规范化，只读

r.rawVariables{}

nginx 变量作为缓冲区，可写（从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)

将string写入错误日志的warning级别

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

流会话

s.log()

s.off()

s.on()

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

将发送的string写入错误日志的error级别

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

s.log(string)

将发送的string写入错误日志的info级别

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

s.off(eventName)

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

s.on(event, callback)

为指定的event注册一个callback（0.2.4）。

event可以是以下字符串之一

upload: 来自客户端的新数据（字符串）
下载: 到客户端的新数据（字符串）
upstream: 来自客户端的新数据（缓冲区）（从0.5.0版本开始）
downstream: 到客户端的新数据（缓冲区）（从0.5.0版本开始）

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

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

s.remoteAddress

客户端地址，只读。

s.rawVariables

nginx 变量作为缓冲区，可写（从0.5.0版本开始）

s.send(data[, options])

将数据添加到数据块链中，这些数据块将向前转发：在下载回调中转发到客户端；在上传中转发到上游服务器（0.2.4）。实际的转发稍后发生，当当前链的所有数据块都处理完毕时。

数据可以是字符串或缓冲区（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)

将发送的string写入错误日志的warning级别

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

周期性会话

PeriodicSession.rawVariables{}

PeriodicSession.variables{}

Periodic Session对象作为http和stream的js_periodic处理程序的第一个参数提供（从0.8.1版本开始）。

PeriodicSession.rawVariables{}: nginx 变量作为缓冲区，可写。
PeriodicSession.variables{}: nginx变量对象，可写。

头部

从0.5.1版本开始，可以使用Fetch API的Headers接口。

可以使用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

从0.7.10版本开始，可以使用Fetch API的Request接口。

可以使用Request()构造函数创建一个新的Request对象

Request[resource[, options]])

创建一个Request对象以进行获取，稍后可以将其传递给ngx.fetch()。resource可以是URL或现有的Request对象。options是一个可选参数，它应该是一个具有以下键的对象

body: 请求体，默认为空。
headers: 响应头对象 — 包含用于预填充Headers对象的HTTP头的对象，可以是string、array（名称-值对）或现有的Headers对象。
method: HTTP方法，默认为GET方法。

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

arrayBuffer(): 返回一个Promise，该Promise解析为ArrayBuffer。
bodyUsed: 布尔值，如果请求中使用了主体，则为true。
cache: 包含请求的缓存模式。
credentials: 包含请求的凭据，默认为same-origin。
headers: 与Request关联的Headers只读对象。
json(): 返回一个Promise，该Promise解析为将请求体作为JSON解析的结果。
method: 包含请求方法。
mode: 包含请求的模式。
text(): 返回一个Promise，该Promise解析为请求体的字符串表示形式。
url: 包含请求的URL。

响应

Response()

Response.arrayBuffer()

Response.redirected

Response.status

Response.statusText

Response.text()

Response.type

Response.url

Response 接口自 0.5.1 版本起可用。

可以使用 Response() 构造函数（自 0.7.10 版本起）创建一个新的 Response 对象。

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 全局对象自 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:// 方案，则应为 resource 的 HTTPS 服务器的身份验证配置 js_fetch_trusted_certificate 指令。

options 参数预期为一个包含以下键的对象

body: 请求体，默认为空
buffer_size: 读取响应的缓冲区大小，默认为 4096
headers: 请求 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.type

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

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

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

仅当键尚不存在时，才为字典中指定的 key 设置 value。key 是表示要添加的项目的键的字符串，value 是要添加的项目的 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。

返回新值。如果 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 字典（用于方法链）。

ngx.shared.SharedDict.size()

返回 SharedDict 字典的项目数。

ngx.shared.SharedDict.type

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

内置对象

控制台

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 ...]): 输出一个或多个警告消息。消息可以是字符串或对象。

加密

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

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

сrypto.getRandomValues(typedArray)

获取密码学强随机值。返回与作为typedArray传递的相同数组，但其内容被替换为新生成的随机数。可能的值

typedArray: 可以是Int8Array、Int16Array、Uint16Array、Int32Array 或 Uint32Array

сrypto.subtle.encrypt(algorithm, key, data)

使用提供的algorithm 和 key 对data 进行加密。返回一个Promise，该Promise 以包含密文的ArrayBuffer 作为结果完成。可能的值

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 块大小）。此块的最右边的长度位用于计数器，其余部分用于 nonce。例如，如果长度设置为 64，则计数器的前半部分是 nonce，后半部分用于计数器
- length 是用于实际计数器的计数器块中的位数。计数器必须足够大，以至于不会溢出。
对于AES-CBC，传递具有以下键的对象
- name 是一个字符串，应设置为AES-CBC
- iv 或初始化向量，是一个ArrayBuffer、TypedArray 或 DataView，必须为 16 字节，不可预测，最好是密码学随机的。但是，它不必保密，例如，它可以与密文一起未加密地传输。
对于AES-GCM，传递具有以下键的对象
- name 是一个字符串，应设置为AES-GCM
- iv 或初始化向量，是一个ArrayBuffer、TypedArray 或 DataView，必须为 16 字节，并且对于使用给定密钥执行的每个加密操作都必须唯一
- additionalData（可选）是一个ArrayBuffer、TypedArray 或 DataView，包含不会被加密但会与加密数据一起进行身份验证的附加数据。如果指定了additionalData，则必须在对decrypt() 的相应调用中指定相同的数据：如果提供给decrypt() 调用的数据与原始数据不匹配，则解密将抛出异常。additionalData 的位长度必须小于2^64 - 1。
- tagLength（可选，默认为128） - 一个number，确定在加密操作中生成的认证标记的大小（以位为单位），并在相应的解密中用于认证。可能的值：32、64、96、104、112、120 或 128。AES-GCM 规范建议它应该是96、104、112、120 或 128，尽管在某些应用程序中，32 或 64 位可能是可以接受的。

key

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

data

一个ArrayBuffer、TypedArray 或 DataView，包含要加密的数据（也称为明文）

сrypto.subtle.decrypt(algorithm, key, data)

解密加密数据。返回一个包含解密数据的Promise。可能的值

algorithm

一个对象，指定要使用的算法以及所需的任何额外参数。为额外参数提供的值必须与传递给相应encrypt() 调用的值匹配。

对于RSA-OAEP，传递具有以下键的对象
- name 是一个字符串，应设置为RSA-OAEP
```
crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)
```
对于AES-CTR，传递具有以下键的对象
- name 是一个字符串，应设置为AES-CTR
- counter 是一个ArrayBuffer、TypedArray 或 DataView - 计数器块的初始值，必须为 16 字节长（AES 块大小）。此块的最右边的长度位用于计数器，其余部分用于 nonce。例如，如果长度设置为 64，则计数器的前半部分是 nonce，后半部分用于计数器。
- length 是用于实际计数器的计数器块中的位数。计数器必须足够大，以至于不会溢出。
对于AES-CBC，传递具有以下键的对象
- name 是一个字符串，应设置为AES-CBC
- iv 或初始化向量，是一个ArrayBuffer、TypedArray 或 DataView，必须为 16 字节，不可预测，最好是密码学随机的。但是，它不必保密（例如，它可以与密文一起未加密地传输）。
对于AES-GCM，传递具有以下键的对象
- name 是一个字符串，应设置为AES-GCM
- iv 或初始化向量，是一个ArrayBuffer、TypedArray 或 DataView，必须为 16 字节，并且对于使用给定密钥执行的每个加密操作都必须唯一
- additionalData（可选）是一个ArrayBuffer、TypedArray 或 DataView，包含不会被加密但会与加密数据一起进行身份验证的附加数据。如果指定了additionalData，则必须在对decrypt() 的相应调用中指定相同的数据：如果提供给decrypt() 调用的数据与原始数据不匹配，则解密将抛出异常。additionalData 的位长度必须小于2^64 - 1。
- tagLength（可选，默认为128） - 一个number，确定在加密操作中生成的认证标记的大小（以位为单位），并在相应的解密中用于认证。可能的值：32、64、96、104、112、120 或 128。AES-GCM 规范建议它应该是96、104、112、120 或 128，尽管在某些应用程序中，32 或 64 位可能是可以接受的。

key

一个CryptoKey，包含用于解密的密钥。如果使用RSA-OAEP，则为CryptoKeyPair 对象的privateKey 属性。

data

一个ArrayBuffer、TypedArray 或 DataView，包含要解密的数据（也称为密文）

сrypto.subtle.deriveBits(algorithm, baseKey, length)

从基本密钥派生一系列位。返回一个Promise，该Promise 将以包含派生位的ArrayBuffer 作为结果完成。可能的值

algorithm

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

对于HKDF，传递具有以下键的对象
- name 是一个字符串，应设置为HKDF
- hash 是一个字符串，包含要使用的摘要算法：SHA-1、SHA-256、SHA-384 或 SHA-512
- salt 是一个ArrayBuffer、TypedArray 或 DataView，表示与digest 函数的输出长度相同的随机或伪随机值。与传递给deriveKey() 的输入密钥材料不同，salt 不需要保密。
- info 是一个ArrayBuffer、TypedArray 或 DataView，表示用于将派生密钥绑定到应用程序或上下文的应用程序特定上下文信息，并允许在使用相同的输入密钥材料时为不同的上下文派生不同的密钥。此属性是必需的，但可以是空缓冲区。
对于PBKDF2，传递具有以下键的对象
- name 是一个字符串，应设置为PBKDF2
- hash 是一个字符串，包含要使用的摘要算法：SHA-1、SHA-256、SHA-384 或 SHA-512
- salt 是一个ArrayBuffer、TypedArray 或 DataView，表示至少为16 字节的随机或伪随机值。与传递给deriveKey() 的输入密钥材料不同，salt 不需要保密。
- iterations 是一个number，表示在deriveKey() 中哈希函数将执行的次数

baseKey

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

length

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

сrypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)

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

algorithm

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

对于HKDF，传递具有以下键的对象
- name 是一个字符串，应设置为HKDF
- hash 是一个字符串，包含要使用的摘要算法：SHA-1、SHA-256、SHA-384 或 SHA-512
- salt 是一个ArrayBuffer、TypedArray 或 DataView，表示与digest 函数的输出长度相同的随机或伪随机值。与传递给deriveKey() 的输入密钥材料不同，salt 不需要保密。
- info 是一个ArrayBuffer、TypedArray 或 DataView，表示用于将派生密钥绑定到应用程序或上下文的应用程序特定上下文信息，并允许在使用相同的输入密钥材料时为不同的上下文派生不同的密钥。此属性是必需的，但可以是空缓冲区。
对于PBKDF2，传递具有以下键的对象
- name 是一个字符串，应设置为PBKDF2
- hash 是一个字符串，包含要使用的摘要算法：SHA-1、SHA-256、SHA-384 或 SHA-512
- salt 是一个ArrayBuffer、TypedArray 或 DataView，表示至少为16 字节的随机或伪随机值。与传递给deriveKey() 的输入密钥材料不同，salt 不需要保密。
- iterations 是一个number，表示在deriveKey() 中哈希函数将执行的次数

baseKey

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

derivedKeyAlgorithm

是一个对象，定义派生密钥将用于的算法

对于HMAC，传递具有以下键的对象
- name 是一个字符串，应设置为HMAC
- hash 是一个字符串，包含要使用的摘要函数的名称：SHA-1、SHA-256、SHA-384 或 SHA-512
- length（可选）是一个number，表示密钥的长度（以位为单位）。如果未指定，则密钥的长度等于所选哈希函数的块大小
对于AES-CTR、AES-CBC或AES-GCM，传递包含以下键的对象
- name是一个字符串，应设置为AES-CTR、AES-CBC或AES-GCM，具体取决于使用的算法
- length是一个表示要生成的密钥长度（以位为单位）的number：128、192或256

extractable

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

keyUsages

是一个Array，指示可以使用派生密钥执行的操作。密钥用途必须由derivedKeyAlgorithm中设置的算法允许。可能的值

encrypt: 用于加密消息的密钥
decrypt: 用于解密消息的密钥
sign: 用于签名消息的密钥
verify: 用于验证签名的密钥
deriveKey: 用于派生新密钥的密钥
deriveBits: 用于派生位的密钥
wrapKey: 用于包装密钥的密钥
unwrapKey: 用于解包密钥的密钥

сrypto.subtle.digest(algorithm, data)

生成给定数据的摘要。它接受用于摘要算法的标识符和要摘要的数据作为参数。返回一个Promise，该Promise将以摘要为结果完成。可能的值

algorithm: 是一个字符串，定义要使用的哈希函数：SHA-1（不适用于加密应用）、SHA-256、SHA-384或SHA-512
data: 是一个ArrayBuffer、TypedArray或DataView，包含要摘要的数据

сrypto.subtle.exportKey(format, key)

导出密钥：将密钥作为CryptoKey对象，并以外部可移植格式返回密钥（自0.7.10版本起）。如果format为jwk，则Promise将以包含密钥的JSON对象为结果完成。否则，promise将以包含密钥的ArrayBuffer为结果完成。可能的值

format

一个字符串，描述应导出密钥的数据格式，可以是以下格式

raw: 原始数据格式
pkcs8: PKCS #8格式
spki: SubjectPublicKeyInfo格式
jwk: JSON Web Key (JWK) 格式（自0.7.10版本起）

key

要导出的密钥所在的CryptoKey

сrypto.subtle.generateKey(algorithm, extractable, usage)

为对称算法生成新密钥或为公钥算法生成密钥对（自0.7.10版本起）。返回一个Promise，该Promise将以生成的密钥（作为CryptoKey或CryptoKeyPair对象）为结果完成。可能的值

algorithm

一个字典对象，定义要生成的密钥类型并提供额外的算法特定参数

对于RSASSA-PKCS1-v1_5、RSA-PSS或RSA-OAEP，传递包含以下键的对象
- name是一个字符串，应设置为RSASSA-PKCS1-v1_5、RSA-PSS或RSA-OAEP，具体取决于使用的算法
- hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256、SHA-384或SHA-512
对于ECDSA，传递包含以下键的对象
- name是一个字符串，应设置为ECDSA
- namedCurve是一个字符串，表示要使用的椭圆曲线的名称，可以是P-256、P-384或P-521
对于HMAC，传递具有以下键的对象
- name 是一个字符串，应设置为HMAC
- hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256、SHA-384或SHA-512
- length（可选）是一个数字，表示密钥的长度（以位为单位）。如果省略，则密钥的长度等于所选摘要函数生成的摘要的长度。
对于AES-CTR、AES-CBC或AES-GCM，传递标识算法的字符串或表单为{ "name": "ALGORITHM" }的对象，其中ALGORITHM是算法的名称

extractable

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

usage

一个array，指示可以使用密钥执行的操作

encrypt: 用于加密消息的密钥
decrypt: 用于解密消息的密钥
sign: 用于签名消息的密钥
verify: 用于验证签名的密钥
deriveKey: 用于派生新密钥的密钥
deriveBits: 用于派生位的密钥
wrapKey: 用于包装密钥的密钥
unwrapKey: 用于解包密钥的密钥

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

导入密钥：将以外部可移植格式输入的密钥作为输入，并提供CryptoKey对象。返回一个Promise，该Promise将以导入的密钥（作为CryptoKey对象）为结果完成。可能的值

format

一个字符串，描述要导入的密钥的数据格式，可以是以下格式

raw: 原始数据格式
pkcs8: PKCS #8格式
spki: SubjectPublicKeyInfo格式
jwk: JSON Web Key (JWK) 格式（自0.7.10版本起）

keyData

包含以给定格式表示的密钥的ArrayBuffer、TypedArray或DataView对象

algorithm

一个字典对象，定义要导入的密钥类型并提供额外的算法特定参数

对于RSASSA-PKCS1-v1_5、RSA-PSS或RSA-OAEP，传递包含以下键的对象
- name是一个字符串，应设置为RSASSA-PKCS1-v1_5、RSA-PSS或RSA-OAEP，具体取决于使用的算法
- hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-1、SHA-256、SHA-384或SHA-512
对于ECDSA，传递包含以下键的对象
- name是一个字符串，应设置为ECDSA
- namedCurve是一个字符串，表示要使用的椭圆曲线的名称，可以是P-256、P-384或P-521
对于HMAC，传递具有以下键的对象
- name 是一个字符串，应设置为HMAC
- hash是一个字符串，表示要使用的digest函数的名称，可以是SHA-256、SHA-384或SHA-512
- length（可选）是一个数字，表示密钥的长度（以位为单位）。如果省略，则密钥的长度等于所选摘要函数生成的摘要的长度。
对于AES-CTR、AES-CBC或AES-GCM，传递标识算法的字符串或表单为{ "name": "ALGORITHM" }的对象，其中ALGORITHM是算法的名称
对于PBKDF2，传递PBKDF2字符串
对于HKDF，传递HKDF字符串

extractable

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

keyUsages

一个array，指示可以使用密钥执行的操作

encrypt: 用于加密消息的密钥
decrypt: 用于解密消息的密钥
sign: 用于签名消息的密钥
verify: 用于验证签名的密钥
deriveKey: 用于派生新密钥的密钥
deriveBits: 用于派生位的密钥
wrapKey: 用于包装密钥的密钥
unwrapKey: 用于解包密钥的密钥

сrypto.subtle.sign(algorithm, key, data)

返回signature，作为一个Promise，该Promise将以包含签名的ArrayBuffer为结果完成。可能的值

algorithm

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

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

key

是一个CryptoKey对象，用于签名的密钥。如果算法标识公钥密码系统，则为私钥。

data

是一个ArrayBuffer、TypedArray或DataView对象，包含要签名的数据

сrypto.subtle.verify(algorithm, key, signature, data)

验证数字签名，返回一个Promise，该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" }的对象

key

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

signature

是一个ArrayBuffer、TypedArray或DataView，包含要验证的签名

data

是一个ArrayBuffer、TypedArray或DataView对象，包含要验证其签名的数据

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对象是一个全局对象，表示当前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对象是一个全局对象，提供有关当前进程的信息（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。

字符串

默认情况下，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() 方法将 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）创建字节字符串，编码可以是 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

文本解码器

TextDecoder()

TextDecoder.prototype.encoding

TextDecoder.prototype.fatal

TextDecoder.prototype.ignoreBOM

TextDecoder.prototype.decode()

TextDecoder 从字节流中生成码点流（0.4.3）。

TextDecoder([[encoding], options])

为指定的 encoding 创建一个新的 TextDecoder 对象，目前仅支持 UTF-8。options 是一个 TextDecoderOptions 字典，包含以下属性：

fatal: 布尔标志，指示当发现编码错误时，TextDecoder.decode() 是否必须抛出 TypeError 异常，默认为 false。

TextDecoder.prototype.encoding

返回 TextDecoder() 使用的编码名称的字符串，只读。

TextDecoder.prototype.fatal

布尔标志，如果错误模式为致命模式，则为 true，只读。

TextDecoder.prototype.ignoreBOM

布尔标志，如果忽略字节顺序标记，则为 true，只读。

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

返回 TextDecoder() 从 buffer 解码的文本字符串。buffer 可以是 ArrayBuffer。options 是一个 TextDecodeOptions 字典，包含以下属性：

stream: 布尔标志，指示后续对 decode() 的调用是否会跟随更多数据：如果分块处理数据，则为 true；对于最终块或数据未分块，则为 false。默认为 false。

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

文本编码器

TextEncoder()

TextEncoder.prototype.encode()

TextEncoder.prototype.encodeInto()

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

TextEncoder()

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

TextEncoder.prototype.encode(string)

将 string 编码为 Uint8Array，其中包含 UTF-8 编码的文本。

TextEncoder.prototype.encodeInto(string, uint8Array)

将 string 编码为 UTF-8，将结果放入目标 Uint8Array 中，并返回一个显示编码进度的字典对象。该字典对象包含两个成员：

read: 从源 string 转换为 UTF-8 的 UTF-16 代码单元的数量。
written: 在目标 Uint8Array 中修改的字节数。

定时器

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

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 参数指定 arrayBuffer 内的内存范围，该范围将由 Buffer 共享。

Buffer.from(buffer)

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

Buffer.from(对象[, 偏移量或编码[, 长度]])

对于其 valueOf() 函数返回的值不严格等于对象的那些对象，返回 Buffer.from(object.valueOf(), offsetOrEncoding, length)。

Buffer.from(字符串[, 编码])

使用 字符串 创建一个新的 Buffer。编码 参数标识在将字符串转换为字节时要使用的字符编码。编码可以是 utf8、hex、base64、base64url；默认为 utf8。

Buffer.isBuffer(对象)

一个布尔值，如果 对象 是一个 Buffer，则返回 true。

Buffer.isEncoding(编码)

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

buffer[索引]

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

buf.buffer

基于其创建此 Buffer 对象的基础 ArrayBuffer 对象。

buf.byteOffset

一个整数，指定 Buffers 基础 ArrayBuffer 对象的 byteOffset。

buf.compare(目标[, 目标起始位置[, 目标结束位置[, 源起始位置[, 源结束位置]]]])

比较 buffer 与 目标，并返回一个数字，指示 buffer 在排序顺序中是在 目标 之前、之后还是与 目标 相同。比较基于每个 Buffer 中实际的字节序列。targetStart 是一个整数，指定在 目标 中开始比较的偏移量，默认为 0。targetEnd 是一个整数，指定在 目标 中结束比较的偏移量，默认为 target.length。sourceStart 是一个整数，指定在 buffer 中开始比较的偏移量，默认为 0。sourceEnd 是一个整数，指定在 buffer 中结束比较的偏移量（不包括），默认为 buf.length。

buf.copy(目标[, 目标起始位置[, 源起始位置[, 源结束位置]]])

将数据从 buffer 的一个区域复制到 目标 中的一个区域，即使目标内存区域与 buffer 重叠。target 参数是要复制到的 Buffer 或 Uint8Array。

targetStart 是一个整数，指定在 target 中开始写入的偏移量，默认为 0。sourceStart 是一个整数，指定在 buffer 中开始复制的偏移量，默认为 0。sourceEnd 是一个整数，指定在 buffer 中停止复制的偏移量（不包括），默认为 buf.length。

buf.equals(其他Buffer)

一个布尔值，如果 Buffer 和 其他Buffer 的字节完全相同，则返回 true。

buf.fill(值[, 偏移量[, 结束位置]][, 编码])

用指定的 值 填充 Buffer。如果未指定 偏移量 和 结束位置，则将填充整个 Buffer。如果 值 不是 字符串、Buffer 或 整数，则将其强制转换为 uint32。如果生成的整数大于 255，则 Buffer 将用 值 和 255 填充。

buf.includes(值[, 字节偏移量][, 编码])

等效于 buf.indexOf() !== -1，如果在 Buffer 中找到 值，则返回 true。

buf.indexOf(值[, 字节偏移量][, 编码])

返回一个整数，它是 Buffer 中 值 首次出现的索引，如果 Buffer 不包含值，则返回 -1。值 可以是带有指定 编码（默认为 utf8）的 字符串、Buffer、Unit8Array 或介于 0 和 255 之间的数字。

buf.lastIndexOf(值[, 字节偏移量][, 编码])

与 buf.indexOf() 相同，但查找 值 的最后一次出现而不是第一次出现。值 可以是字符串、Buffer 或介于 1 和 255 之间的整数。如果 值 是空字符串或空 Buffer，则将返回 byteOffset。

buf.length

返回 Buffer 中的字节数。

buf.readIntBE(偏移量, 字节长度)

从指定 偏移量 处的 buf 读取 字节长度，并将结果解释为一个大端序、二进制补码有符号值，支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

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

buf.readIntLE(偏移量, 字节长度)

从指定 偏移量 处的 buf 读取 字节长度，并将结果解释为一个小端序、二进制补码有符号值，支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

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

buf.readUIntBE(偏移量, 字节长度)

从指定 偏移量 处的 buf 读取 字节长度，并将结果解释为一个大端序整数，支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

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

buf.readUIntLE(偏移量, 字节长度)

从指定 偏移量 处的 buf 读取 字节长度，并将结果解释为一个小端序整数，支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

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

buf.readDoubleBE([偏移量])

从指定 偏移量 处的 buf 读取一个 64 位大端序双精度浮点数。

buf.readDoubleLE([偏移量])

从指定 偏移量 处的 buf 读取一个 64 位小端序双精度浮点数。

buf.readFloatBE([偏移量])

从指定 偏移量 处的 buf 读取一个 32 位大端序单精度浮点数。

buf.readFloatLE([偏移量])

从指定 偏移量 处的 buf 读取一个 32 位小端序单精度浮点数。

buf.subarray([起始位置[, 结束位置]])

返回一个新的 buf，它引用与原始 buf 相同的内存，但由 起始位置 和 结束位置 偏移和裁剪。如果 结束位置 大于 buf.length，则返回与 结束位置 等于 buf.length 相同的结果。

buf.slice([起始位置[, 结束位置]])

返回一个新的 buf，它引用与原始 buf 相同的内存，但由 起始位置 和 结束位置 值偏移和裁剪。该方法与 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([编码[, 起始位置[, 结束位置]]])

根据指定的字符 编码 将 buf 解码为字符串，该编码可以是 utf8、hex、base64、base64url。可以传递 起始位置 和 结束位置 参数以仅解码 Buffer 的一部分。

buf.write(字符串[, 偏移量[, 长度]][, 编码])

根据字符 编码 将 字符串 写入 buf 中的 偏移量 处。长度 参数是要写入的字节数。如果 Buffer 中没有足够的空间来容纳整个字符串，则只会写入字符串的一部分，但是，不会写入部分编码的字符。编码 可以是 utf8、hex、base64、base64url。

buf.writeIntBE(值, 偏移量, 字节长度)

将 值 的 字节长度 字节写入指定 偏移量 处的 buf 中，作为大端序。支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

还支持以下类似方法：buf.writeInt8、buf.writeInt16BE、buf.writeInt32BE。

buf.writeIntLE(值, 偏移量, 字节长度)

将 值 的 字节长度 字节写入指定 偏移量 处的 buf 中，作为小端序。支持最多 48 位的精度。字节长度 参数是一个介于 1 和 6 之间的整数，指定要读取的字节数。

还支持以下类似方法：buf.writeInt8、buf.writeInt16LE、buf.writeInt32LE。

buf.writeUIntBE(值, 偏移量, 字节长度)

还支持以下类似方法：buf.writeUInt8、buf.writeUInt16BE、buf.writeUInt32BE。

buf.writeUIntLE(值, 偏移量, 字节长度)

还支持以下类似方法：buf.writeUInt8、buf.writeUInt16LE、buf.writeUInt32LE。

buf.writeDoubleBE(值, [偏移量])

将 值 写入指定 偏移量 处的 buf 中，作为大端序。

buf.writeDoubleLE(值, [偏移量])

将 值 写入指定 偏移量 处的 buf 中，作为小端序。

buf.writeFloatBE(值, [偏移量])

将 值 写入指定 偏移量 处的 buf 中，作为大端序。

buf.writeFloatLE(value, [offset])

将 值 写入指定 偏移量 处的 buf 中，作为小端序。

加密

crypto.createHash()

crypto.createHmac()

从 0.7.0 版本开始，扩展的加密 API 作为全局 crypto 对象可用。

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

crypto.createHash(algorithm): 创建并返回一个 Hash 对象，该对象可用于使用给定的 algorithm 生成哈希摘要。算法可以是 md5、sha1 和 sha256。
crypto.createHmac(algorithm, secret key): 创建并返回一个 HMAC 对象，该对象使用给定的 algorithm 和 secret key。算法可以是 md5、sha1 和 sha256。

Hash

hash.update()

hash.digest()

hash.update(data): 使用给定的 data 更新哈希内容。
hash.digest([encoding]): 计算使用 hash.update() 传递的所有数据的摘要。编码可以是 hex、base64 和 base64url。如果未提供编码，则返回 Buffer 对象 (0.4.4)。
在 (0.4.4) 版本之前，返回的是字节字符串而不是 Buffer 对象。
hash.copy(): 复制哈希当前状态的副本（自 0.7.12 版本开始）。

>> 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 内容。
hmac.digest([encoding]): 计算使用 hmac.update() 传递的所有数据的 HMAC 摘要。编码可以是 hex、base64 和 base64url。如果未提供编码，则返回 Buffer 对象 (0.4.4)。
在 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()

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

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

> var fs = require('fs').promises;
undefined
> fs.readFile("/file/path").then((data)=>console.log(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: mode 选项，默认为 0o666
flag: 文件系统 flag，默认为 a

closeSync(fd)

关闭由方法使用的整数表示的 fd 文件描述符。返回 undefined。

existsSync(path)

布尔值，如果指定的 path 存在，则返回 true。(0.8.2)

fstatSync(fd)

检索文件描述符的 fs.Stats 对象 (0.7.7)。fd 参数是表示方法使用的文件描述符的整数。

lstatSync(path[, options])

同步检索 path 引用的符号链接的 fs.Stats 对象 (0.7.1)。options 参数预期为一个具有以下键的对象

throwIfNoEntry: 一个布尔值，指示如果不存在文件系统条目是否抛出异常，而不是返回 undefined，默认为 false。

mkdirSync(path[, options])

同步在指定的 path 创建目录 (0.4.2)。options 参数预期为一个指定 mode 的整数，或一个具有以下键的对象

mode: mode 选项，默认为 0o777。

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

返回一个整数，表示已打开的文件 path 的文件描述符 (0.7.7)。

flags: 文件系统 flag，默认为 r
mode: mode 选项，默认为 0o666

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

返回一个 FileHandle 对象，表示已打开的文件 path (0.7.7)。

flags: 文件系统 flag，默认为 r
mode: mode 选项，默认为 0o666

readdirSync(path[, options])

同步读取指定 path 处目录的内容 (0.4.2)。options 参数预期为一个指定 encoding 的字符串，或一个具有以下键的对象

encoding: 编码，默认为 utf8。编码可以是 utf8 和 buffer (0.4.4)。
withFileTypes: 如果设置为 true，则 files 数组将包含 fs.Dirent 对象，默认为 false。

readFileSync(filename[, options])

同步返回具有提供的 filename 的文件的内容。options 参数包含指定编码的字符串。如果指定了编码，则返回字符串，否则返回 Buffer 对象 (0.4.4)。

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

否则，options 预期为一个具有以下键的对象

encoding: encoding，默认为未指定。编码可以是 utf8、hex (0.4.4)、base64 (0.4.4)、base64url (0.4.4)。
flag: 文件系统 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) 同步获取符号链接 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: 是表示要将数据写入到的缓冲区中的位置的整数
length: 是表示要读取的字节数的整数
position: 指定从文件开头开始读取的位置，该值可以是整数或 null，默认为 null。如果 position 为 null，则将从当前文件位置读取数据，并且文件位置将更新。如果 position 是整数，则文件位置将保持不变

realpathSync(path[, options])

通过使用 realpath(3) 解析 .、.. 和符号链接来同步计算规范路径名。options 参数可以是指定编码的字符串，或者是一个包含 encoding 属性的对象，该属性指定要用于传递给回调的路径的字符编码 (0.3.9)。

renameSync(oldPath, newPath)

同步更改文件从 oldPath 到 newPath 的名称或位置 (0.3.4)。

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

rmdirSync(path)

同步删除指定 path 处的目录 (0.4.2)。

statSync(path,[ options])

同步检索指定 path 的 fs.Stats 对象 (0.7.1)。path 可以是字符串或缓冲区。options 参数预期为一个具有以下键的对象

throwIfNoEntry: 一个布尔值，指示如果不存在文件系统条目是否抛出异常，而不是返回 undefined，默认为 true。

symlinkSync(target, path)

使用 symlink(2) 同步创建名为 path 的链接，指向 target (0.3.9)。相对目标相对于链接的父目录。

unlinkSync(path)

同步取消链接 path 指定的文件 (0.3.9)。

writeFileSync(filename, data[, options])

同步将 data 写入具有提供的 filename 的文件。data 预期为字符串或 Buffer 对象 (0.4.4)。如果文件不存在，则会创建它，如果文件存在，则会被替换。options 参数预期为一个具有以下键的对象

mode: mode 选项，默认为 0o666
flag: 文件系统 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)。

fd: 表示文件描述符的整数
buffer: buffer 值可以是 Buffer、TypedArray 或 DataView
offset: 是确定要写入的缓冲区部分的整数，默认为 0
length: 是指定要写入的字节数的整数，默认为 Buffer.byteLength 的偏移量
position: 指的是应将此数据写入到的文件开头的偏移量，可以是整数或 null，默认为 null。另请参阅 pwrite(2)。

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

使用文件描述符 fd 将字符串写入文件，返回写入的字节数 (0.7.7)。

fd: 是表示文件描述符的整数
position: 表示应将数据写入的文件开头处的偏移量，可以是integer或null，默认为null。另请参阅pwrite(2)
encoding: 是string类型，默认为utf8

fs.Dirent

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

dirent.isBlockDevice() — 如果fs.Dirent对象描述的是块设备，则返回true。
dirent.isCharacterDevice() — 如果fs.Dirent对象描述的是字符设备，则返回true。
dirent.isDirectory() — 如果fs.Dirent对象描述的是文件系统目录，则返回true。
dirent.isFIFO() — 如果fs.Dirent对象描述的是先进先出 (FIFO) 管道，则返回true。
dirent.isFile() — 如果fs.Dirent对象描述的是普通文件，则返回true。
dirent.isSocket() — 如果fs.Dirent对象描述的是套接字，则返回true。
dirent.isSymbolicLink() — 如果fs.Dirent对象描述的是符号链接，则返回true。
dirent.name — fs.Dirent对象引用的文件名称。

fs.FileHandle

filehandle.write(buf)

filehandle.write(str)

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

filehandle.close()

等待句柄上任何挂起的操作完成后，关闭文件句柄。返回一个promise，成功时以undefined完成。

filehandle.fd

FileHandle对象管理的数字文件描述符。

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

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

buffer: 将用读取的文件数据填充的缓冲区，其值可以是Buffer、TypedArray或DataView
offset: 表示开始填充缓冲区的缓冲区中的位置的integer
length: 是表示要读取的字节数的整数
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()返回。

stats.isBlockDevice() — 如果fs.Stats对象描述的是块设备，则返回true。
stats.isDirectory() — 如果fs.Stats对象描述的是文件系统目录，则返回true。
stats.isFIFO() — 如果fs.Stats对象描述的是先进先出 (FIFO) 管道，则返回true。
stats.isFile() — 如果fs.Stats对象描述的是普通文件，则返回true。
stats.isSocket() — 如果fs.Stats对象描述的是套接字，则返回true。
stats.isSymbolicLink() — 如果fs.Stats对象描述的是符号链接，则返回true。
stats.dev — 包含文件的设备的数字标识符。
stats.ino — 文件的文件系统特定Inode编号。
stats.mode — 描述文件类型和模式的位字段。
stats.nlink — 文件存在的硬链接数。
stats.uid — 拥有文件的用户的数字用户标识符 (POSIX)。
stats.gid — 拥有文件的组的数字组标识符 (POSIX)。
stats.rdev — 如果文件表示设备，则为数字设备标识符。
stats.size — 文件的大小（以字节为单位）。
stats.blksize — 用于 i/o 操作的文件系统块大小。
stats.blocks — 为此文件分配的块数。
stats.atimeMs — 表示上次访问此文件的时间戳，以自 POSIX 纪元以来的毫秒数表示。
stats.mtimeMs — 表示上次修改此文件的时间戳，以自 POSIX 纪元以来的毫秒数表示。
stats.ctimeMs — 表示上次更改此文件的时间戳，以自 POSIX 纪元以来的毫秒数表示。
stats.birthtimeMs — 表示此文件创建时间戳，以自 POSIX 纪元以来的毫秒数表示。
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()

查询字符串模块提供对解析和格式化 URL 查询字符串的支持（0.4.3）。查询字符串模块对象由require('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 模块对象可以通过 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(字符串 | Buffer)

解析 XML 文档的字符串或 Buffer，返回一个 XMLDoc 包装对象，表示已解析的 XML 文档。

c14n(根节点[, 排除节点])

根据规范 XML 1.1 版对 根节点 及其子节点进行规范化。根节点 可以是 XMLNode 或 XMLDoc 包装对象，包裹 XML 结构。返回包含规范化输出的 Buffer 对象。

排除节点: 允许从输出中省略文档的一部分

exclusiveC14n(根节点[, 排除节点[, 包含注释 [,前缀列表]]])

根据排他性 XML 规范化 1.0 版对 根节点 及其子节点进行规范化。

根节点: 是 XMLNode 或 XMLDoc 包装对象，包裹 XML 结构
排除节点: 允许从输出中省略对应于节点及其子节点的文档的一部分
包含注释: 布尔值，默认为 false。如果为 true，则规范化对应于排他性 XML 规范化 1.0 版。返回包含规范化输出的 Buffer 对象。
前缀列表: 一个可选的字符串，包含用空格分隔的命名空间前缀，用于指定应包含在输出中的命名空间。

serialize()

与 xml.c14n() 相同（自 0.7.11 版本起）。

serializeToString()

与 xml.c14n() 相同，但返回的结果为 字符串（自 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(属性名称): 移除名为 属性名称 的属性（自 0.7.11 版本起）。
node.removeChildren(标签名称): 移除所有名为 标签名称 的子标签（自 0.7.11 版本起）。如果 标签名称 不存在，则移除所有子标签。
node.removeText(): 移除节点的文本值（自 0.7.11 版本起）。
node.setAttribute(属性名称, 值): 设置 属性名称 的值（自 0.7.11 版本起）。当值为 null 时，名为 属性名称 的属性将被删除。
node.setText(值): 设置节点的文本值（自 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(字符串 | Buffer[, 选项]): 使用“deflate”算法压缩提供为字符串或 Buffer 的数据，并且不附加 zlib 标头。Buffer 值可以是 Buffer、TypedArray 或 DataView。选项 是一个可选对象，包含 zlib_选项。返回包含压缩数据的 Buffer 实例。
deflateSync(字符串 | Buffer[, 选项]): 使用“deflate”算法压缩提供为字符串或 Buffer 的数据。Buffer 值可以是 Buffer、TypedArray 或 DataView。选项 是一个可选对象，包含 zlib_选项。返回包含压缩数据的 Buffer 实例。
inflateRawSync(字符串 | Buffer): 使用“deflate”算法解压缩原始流。返回包含解压缩数据的 Buffer 实例。
inflateSync(字符串 | Buffer): 使用“deflate”算法解压缩流。返回包含解压缩数据的 Buffer 实例。

zlib 选项

chunkSize — 整数，默认为 1024。
dictionary — Buffer、TypedArray 或 DataView，默认为空。
level — 整数，仅压缩，参见 zlib_压缩级别。
memLevel — 整数，范围为 1 到 9，仅压缩。
strategy — 整数，仅压缩，参见 zlib_压缩策略。
windowBits — 整数，对于原始数据，范围为 -15 到 -9；对于普通流，范围为 9 到 15。

zlib 压缩级别

名称	描述
`zlib.constants.Z_NO_COMPRESSION`	不压缩。
`zlib.constants.Z_BEST_SPEED`	最快，压缩率最低。
`zlib.constants.Z_DEFAULT_COMPRESSION`	速度和压缩率之间的折衷。
`zlib.constants.Z_BEST_COMPRESSION`	最慢，压缩率最高。

zlib 压缩策略

名称	描述
`zlib.constants.Z_FILTERED`	过滤策略：适用于由过滤器或预测器生成的数据。
`zlib.constants.Z_HUFFMAN_ONLY`	仅霍夫曼策略：仅霍夫曼编码，不进行字符串匹配。
`zlib.constants.Z_RLE`	游程编码策略：将匹配距离限制为 1，可以更好地压缩 PNG 图像数据。
`zlib.constants.Z_FIXED`	固定表策略：防止使用动态霍夫曼代码，对于特殊应用来说，解码器更简单。
`zlib.constants.Z_DEFAULT_STRATEGY`	默认策略，适用于通用压缩。