参考

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'

转换为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 对象 在首次访问r.args. 如果只需要一个参数，例如foo，可以使用 nginx 变量：

r.variables.arg_foo

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

转换r.args返回到字符串， 查询字符串stringify方法。

r.done()
调用此函数后， next 数据块将传递给 client，而不调用 js_body_filter （0.5.2）。 只能从 js_body_filter 函数调用
r.error(string)
编写一个string到错误日志 在error日志记录级别

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

r.finish()
完成向客户端发送响应
r.headersIn{}
incoming headers 对象，只读。

这Foo请求标头 可以使用以下语法访问：headersIn.foo或headersIn['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。

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

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

应在将响应标头发送到客户端之前设置传出标头， 否则，将忽略 header update。 这意味着r.headersOut{}可以有效地写入：

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

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

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

r.log(string)
编写一个string到错误日志 在info日志记录级别

由于 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, 但返回一个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
保存 SubRequest 响应正文， 只读 （从 0.5.0 开始）。 的大小r.responseBuffer受 subrequest_output_buffer_size 指令限制。
r.responseText
与r.responseBuffer但返回一个字符串 （从 0.5.0 开始）。 请注意， 它可以将 UTF-8 编码中无效的字节转换为替换字符。
r.return(status[, string | Buffer])
发送整个响应 替换为指定的status到客户端。 响应可以是 String 或 Buffer （0.5.0 版本）。

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

r.send(string | Buffer)
将响应正文的一部分发送到客户端。 发送的数据可以是字符串或 Buffer （0.5.0)
r.sendBuffer(data[, options])
将数据添加到要转发到下一个 body 过滤器的数据块链中 （0.5.2 的）。 实际的转发发生在稍后， 当当前链的所有数据块都被处理时。

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

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

该方法只能从 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]])
使用给定的uri和options，并安装 可选补全callback.

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

如果options是一个字符串，那么它 保存 subrequest arguments 字符串。 否则options预计为 具有以下键的对象：

args
arguments 字符串，默认情况下使用空字符串
body
请求正文、 默认情况下，使用父请求对象的请求正文
method
HTTP 方法，默认情况下，GETmethod 的
detached
布尔标志 （0.3.9）、 如果true，则创建的子请求是分离的子请求。 对分离的子请求的响应将被忽略。 与普通子请求不同，分离的子请求 可以在变量处理程序中创建。 这detachedflag 和 callback 参数 是互斥的。

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

从 0.3.8 开始， 如果callback未提供、 这Promise对象 ，该响应对象解析为 SubRequest 响应对象。

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

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 处理nginx.conf和未引用的变量。 当一个变量被引用时，它可以是可缓存的， 但是当它未被引用时，它总是不可缓存的。 例如，当 $request_id 变量仅从 njs 访问时， 每次评估时，它都有一个新值。 但是，当引用 $request_id 时，例如：

proxy_set_header X-Request-Id $request_id;

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

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

  • 它是使用js_varhttp 或 stream 的指令（自 0.5.3 起)
  • 它在 nginx 配置文件中引用

即便如此，一些嵌入的变量仍然无法被赋值（例如$http_).

r.warn(string)
编写一个string到错误日志 在warning日志记录级别

由于 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对于当前阶段处理程序 设置为 code 值0. 实际的终结发生在 js 处理程序完成时 以及所有待处理事件，例如，从ngx.fetch()或setTimeout(), 被处理 （0.2.4） 的

可能的 code 值：

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

只能从 phase handler 函数中调用：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)
注册一个callback对于指定的event (0.2.4） 的

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

upload
来自客户端的新数据 （string）
download
新数据 （string） 到客户端
upstream
来自客户端的新数据 （Buffer） （自 0.5.0 起)
downstream
新数据 （Buffer） 到客户端 （自 0.5.0 起)

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

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 版本）。 这options是使用的对象 覆盖从传入数据块缓冲区派生的 nginx 缓冲区标志。 可以使用以下标志覆盖这些标志：

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

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

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

周期性会话

PeriodicSession.rawVariables{}
PeriodicSession.variables{}

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

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

头

Headers()
Headers.append()
Headers.delete()
Headers.get()
Headers.getAll()
Headers.forEach()
Headers.has()
Headers.set()

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

新的HeadersObject 可以使用Headers()构造 函数： （自 0.7.10 起）：

Headers([init])
init
一个包含 HTTP 标头的对象 预先填充Headers对象 可以是string, 一array名称-值对， 或现有的Headers对象。

新的HeadersObject 可以创建 具有以下属性和方法：

append()
将新值附加到Headers对象 或者添加标头（如果尚不存在） （自 0.7.10 起）。
delete()
从Headers对象 （自 0.7.10 起）。
get()
返回一个字符串，其中包含具有指定名称的所有标头的值 用逗号和空格分隔。
getAll(name)
返回一个数组，其中包含具有指定名称的所有标头的值。
forEach()
为每个键/值对执行一次提供的函数 在Headers对象 （自 0.7.10 起）。
has()
返回布尔值 指示是否存在具有指定名称的 Header。
set()
为 这Headers对象 或者添加标头（如果尚不存在） （自 0.7.10 起）。

请求

Request()
Request.arrayBuffer()
Request.bodyUsed
Request.cache
Request.credentials
Request.headers
Request.json()
Request.method
Request.mode
Request.text()
Request.url

这Request接口的Fetch API自 0.7.10 起可用。

新的RequestObject 可以使用Request()构造 函数：

Request[resource[, options]])
创建一个Request要获取的对象 稍后可以传递给ngx.fetch(). 这resource可以是 URL 或现有的Request对象。 这options是可选参数 该对象应为具有以下键的对象：
body
默认情况下，请求正文为空。
headers
响应 headers 对象 — 包含 HTTP 标头的对象 预先填充Headers对象 可以是string, 一array名称-值对， 或现有的Headers对象。
method
HTTP 方法，默认情况下使用 GET 方法。

新的RequestObject 可以创建 具有以下属性和方法：

arrayBuffer()
返回一个Promise，以 一ArrayBuffer.
bodyUsed
布尔值true如果请求中使用了 body。
cache
包含请求的缓存模式。
credentials
包含请求的凭证， 默认情况下为same-origin.
headers
这Headers只读对象 与Request.
json()
返回一个Promise，以 将请求正文解析为 JSON 的结果。
method
包含请求方法。
mode
包含请求的模式。
text()
返回一个Promise解析为 请求正文的 string 表示形式。
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

这Responseinterface 从 0.5.1 开始可用。

新的ResponseObject 可以使用Response()构造 函数 （自 0.7.10 起）：

Response[body[, options]])
创建一个Response对象。 这body是可选参数， 可以是string或buffer, 默认情况下为null. 这options是可选参数 该对象应为具有以下键的对象：
headers
响应 headers 对象 — 包含 HTTP 标头的对象 预先填充Headers对象 可以是string, 一array名称-值对， 或现有的Headers对象。
status
响应的状态代码。
statusText
与状态代码对应的状态消息。

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

arrayBuffer()
采用Responsestream 并读取它直到完成。 返回一个Promise，以 一ArrayBuffer.
bodyUsed
布尔值true如果正文被读取。
headers
这Headers只读对象 与Response.
json()
采用Responsestream 并读取它直到完成。 返回一个Promise，以 将正文文本解析为 JSON 的结果。
ok
布尔值true如果响应成功（状态代码介于 200-299 之间）。
redirected
布尔值true如果响应是重定向的结果。
status
响应的状态代码。
statusText
与状态代码对应的状态消息。
text()
采用Responsestream 并读取它直到完成。 返回一个Promise，它以字符串解析。
type
响应的类型。
url
响应的 URL。

NGX

ngx.build
ngx.conf_file_path
ngx.conf_prefix
ngx.error_log_path
ngx.fetch()
ngx.log()
ngx.prefix
ngx.version
ngx.version_number
ngx.worker_id

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

ngx.build
包含可选 nginx 构建名称的字符串，对应于--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 的）。 返回一个Promise，以 这Response对象。 从 0.7.0 开始， 这https://方案， 不处理重定向。

如果resource指定为域名， 它是使用 Resolver 确定的。 如果https://scheme 时，应配置 js_fetch_trusted_certificate 指令 用于对resource的 HTTPS 服务器。

这optionsparameter 应为对象 使用以下键：

body
请求正文、 默认情况下为空
buffer_size
用于读取响应的缓冲区大小， 默认情况下为4096
headers
Request Headers 对象
max_response_body_size
响应正文的最大大小（以字节为单位）， 默认情况下为32768
method
HTTP 方法， 默认情况下，GETmethod 的
verify
启用或禁用 HTTPS 服务器证书的验证， 默认情况下为true (0.7.0)

例：

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

r.return(200, body);

ngx.log(level,message)
将消息写入具有指定日志记录级别的错误日志。 这levelparameter 指定其中一个日志级别， 这messageparameter 可以是 String 或 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 内部 worker id 对应的数字， 该值介于0和 worker_processes 指令中指定的值 （0.8.0)

ngx.shared

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

共享字典

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 开始。 共享词典名称、类型和大小 使用js_shared_dict_zone指令。

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

ngx.shared.SharedDict.add(key, value [,timeout])
设置value对于指定的key在字典中 仅当 key 尚不存在时。 这key是一个字符串，表示 要添加的项的键， 这value是要添加的项的值。

可选的timeout参数以毫秒为单位指定 并覆盖timeout参数的js_shared_dict_zone指令（从 0.8.5 开始）。 当某些键预期具有唯一超时时，它可能很有用。

返回true如果该值已成功添加 到SharedDict字典false如果 key 已存在于字典中。 抛出SharedMemoryError如果 的SharedDict字典。 抛出TypeError如果value是 的类型与此词典预期的类型不同。

ngx.shared.SharedDict.capacity
返回SharedDict字典 对应于size参数js_shared_dict_zone指令。
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是数字 以递增或递减值。 如果 key 不存在，则 该 Item 将被初始化为可选的init论点 默认情况下为0.

可选的timeout参数以毫秒为单位指定 并覆盖timeout参数的js_shared_dict_zone指令（从 0.8.5 开始）。 当某些键预期具有唯一超时时，它可能很有用。

返回新值。 抛出SharedMemoryError如果 的SharedDict字典。 抛出TypeError如果此字典不需要数字。

仅当字典类型使用type=number参数的js_shared_dict_zone指令。

ngx.shared.SharedDict.items([maxCount])
返回SharedDict字典 键值项（自 0.8.1 起）。 这maxCount参数 设置要检索的最大项目数， 默认情况下为1024.
ngx.shared.SharedDict.keys([maxCount])
返回SharedDict字典键。 这maxCount参数 设置要检索的最大键数， 默认情况下为1024.
ngx.shared.SharedDict.name
返回SharedDict字典 对应于zone=参数js_shared_dict_zone指令。
ngx.shared.SharedDict.pop(key)
删除与指定key从SharedDict字典 返回与key或undefined如果没有。
ngx.shared.SharedDict.replace(key, value)
将value对于指定的key仅当密钥已存在时， 返回true如果该值被成功替换，则false如果密钥不存在 在SharedDict字典。 抛出SharedMemoryError如果 的SharedDict字典。 抛出TypeError如果value是 的类型与此词典预期的类型不同。
ngx.shared.SharedDict.set(key, value [,timeout])
设置value对于指定的key, 返回 thisSharedDictdictionary （用于方法链接）。

可选的timeout参数以毫秒为单位指定 并覆盖timeout参数的js_shared_dict_zone指令（从 0.8.5 开始）。 当某些键预期具有唯一超时时，它可能很有用。

ngx.shared.SharedDict.size()
返回SharedDict字典。
ngx.shared.SharedDict.type
返回string或number那 对应于SharedDict字典类型 set 由type=参数js_shared_dict_zone指令。

内置对象

安慰

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

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

console.error(msg[, msg2 ...])
输出一条或多条错误消息。 消息可以是字符串或对象。
console.info(msg[, msg2 ...])
输出一个或多个 info 消息。 消息可以是字符串或对象。
console.log(msg[, msg2 ...])
输出一条或多条日志消息。 消息可以是字符串或对象。
console.time(label)
启动一个计时器，该计时器可以跟踪作所花费的时间。 这labelparameter 允许命名不同的计时器。 如果console.timeEnd()的 将输出自计时器启动以来经过的时间， 以毫秒为单位。
console.timeEnd(label)
停止之前由console.time()这labelparameter 允许命名不同的计时器。
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()

这cryptoobject 是一个全局对象 允许使用加密功能 （自 0.7.0 起）。

сrypto.getRandomValues(typedArray)
获取加密性强的随机值。 返回作为typedArray但其内容被新生成的随机数替换。 可能的值：
typedArray
可以是Int8Array,Int16Array,Uint16Array,Int32Array或Uint32Array
сrypto.subtle.encrypt(algorithm,key,data)
加密data使用提供的algorithm和key. 返回一个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— counter 块的初始值 长度必须为 16 字节（AES 块大小）。 此块最右边的长度位用于计数器 其余的用于 nonce。 例如，如果 length 设置为 64，则 那么 counter 的前半部分是 nonce 而后半部分则用于计数器
    • length是 counter 块中的位数 用于实际计数器。 计数器必须足够大，以至于它不会换行。
  • 为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
对象 ，该参数指定要使用的算法以及所需的任何额外参数。 为 extra 参数给出的值必须匹配 传递到相应的encrypt()叫。
  • 为RSA-OAEP, 使用以下键传递对象：
    • name是一个字符串， 应设置为RSA-OAEP:

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

  • 为AES-CTR, 使用以下键传递对象：
    • name是一个字符串， 应设置为AES-CTR
    • counter是一个ArrayBuffer,TypedArray或DataView— counter 块的初始值 长度必须为 16 字节（AES 块大小）。 此块最右边的长度位用于计数器 其余的用于 nonce。 例如，如果 length 设置为 64，则 那么 counter 的前半部分是 nonce 后半部分用于计数器。
    • length是 counter 块中的位数 用于实际计数器。 计数器必须足够大，以至于它不会换行。
  • 为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，则为privateKey属性的CryptoKeyPair对象。
data
一ArrayBuffer,TypedArray或DataView，其中包含要解密的数据（也称为密文）
сrypto.subtle.deriveBits(algorithm,baseKey,length)
从基键派生位数组。 返回一个Promise这将通过ArrayBuffer，其中包含派生的位。 可能的值：
algorithm
是一个对象，用于定义要使用的派生算法：
  • 为HKDF, 使用以下键传递对象：
    • name是一个字符串， 应设置为HKDF
    • hash是一个字符串，其中包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512
    • salt是一个ArrayBuffer,TypedArray或DataView表示 random 或伪 random 值 的长度与digest功能。 与传入的输入键材料不同deriveKey(), 盐不需要保密。
    • info是一个ArrayBuffer,TypedArray或DataView表示特定于应用程序的上下文信息 用于将派生的 key 绑定到应用程序或上下文， 并支持为不同的上下文派生不同的键 同时使用相同的输入键材料。 此属性是必需的，但可以是空缓冲区。
  • 为PBKDF2, 使用以下键传递对象：
    • name是一个字符串， 应设置为PBKDF2
    • hash是一个字符串，其中包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512
    • salt是一个ArrayBuffer,TypedArray或DataView表示 random 或伪 random 值 至少16字节。 与传入的输入键材料不同deriveKey(), 盐不需要保密。
    • iterations是一个number表示哈希函数将被执行的次数 在deriveKey()
baseKey
是一个CryptoKey，这表示派生算法的输入 - 派生函数的初始密钥材料： 例如，对于PBKDF2它可能是一个密码， 导入为CryptoKey用сrypto.subtle.importKey()
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表示 random 或伪 random 值 的长度与digest功能。 与传入的输入键材料不同deriveKey(), 盐不需要保密。
    • info是一个ArrayBuffer,TypedArray或DataView表示特定于应用程序的上下文信息 用于将派生的 key 绑定到应用程序或上下文， 并支持为不同的上下文派生不同的键 同时使用相同的输入键材料。 此属性是必需的，但可以是空缓冲区。
  • 为PBKDF2, 使用以下键传递对象：
    • name是一个字符串， 应设置为PBKDF2
    • hash是一个字符串，其中包含要使用的摘要算法：SHA-1,SHA-256,SHA-384或SHA-512
    • salt是一个ArrayBuffer,TypedArray或DataView表示 random 或伪 random 值 至少16字节。 与传入的输入键材料不同deriveKey(), 盐不需要保密。
    • iterations是一个number表示哈希函数将被执行的次数 在deriveKey()
baseKey
是一个CryptoKey，这表示派生算法的输入 - 派生函数的初始密钥材料： 例如，对于PBKDF2它可能是一个密码， 导入为CryptoKey用сrypto.subtle.importKey().
derivedKeyAlgorithm
是一个对象 ，它定义了派生键将用于的算法：
  • 为HMAC, 使用以下键传递对象：
    • name是一个字符串， 应设置为HMAC
    • hash是一个字符串，其中包含要使用的摘要函数的名称：SHA-1,SHA-256,SHA-384或SHA-512
    • length（可选） 是number这表示密钥的长度（以位为单位）。 如果未指定，则 key 的长度等于 Chozen Hash 函数的区块大小
  • 为AES-CTR,AES-CBC或AES-GCM, 使用以下键传递对象：
    • name是一个字符串， 应设置为AES-CTR,AES-CBC或AES-GCM, 取决于使用的算法
    • length是一个number，代表 要生成的密钥的长度（以位为单位）：128,192或256
extractable
是布尔值 指示是否可以导出密钥
keyUsages
是一个Array，这表示可以使用派生的 Key 执行哪些作。 算法必须允许密钥用法 嵌derivedKeyAlgorithm. 可能的值：
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于对消息进行签名的密钥
verify
验证签名的密钥
deriveKey
key 用于派生新密钥
deriveBits
用于派生位的密钥
wrapKey
key 用于包装 key
unwrapKey
key 用于解包密钥
сrypto.subtle.digest(algorithm,data)
生成给定数据的摘要。 将摘要算法要使用的标识符作为其参数 以及要消化的数据。 返回一个Promise这将通过摘要来实现。 可能的值：
algorithm
是一个字符串，用于定义要使用的哈希函数：SHA-1（不适用于加密应用程序）、SHA-256,SHA-384或SHA-512
data
是一个ArrayBuffer,TypedArray或DataView，其中包含要摘要的数据
сrypto.subtle.exportKey(format,key)
导出 key：将 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包含要导出的 Key
сrypto.subtle.generateKey(algorithm,extractable,usage)
为对称算法生成新密钥 或公钥算法的密钥对 （自 0.7.10 起）。 返回一个Promise，该 API 使用生成的 Key 实现 如 一个CryptoKey或CryptoKeyPair对象。 可能的值：
algorithm
定义要生成的 Key 类型的 Dictionary 对象 并提供额外的特定于算法的参数：
  • 为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（可选） 是一个数字，表示 键的长度（以位为单位）。 如果省略，则键的长度等于摘要的长度 由所选的 Digest 函数生成。
  • 为AES-CTR,AES-CBC或AES-GCM, 传递标识算法或对象的字符串 的形式{ "name": "ALGORITHM" }, 哪里ALGORITHM是算法的名称
extractable
boolean 值，该值指示是否可以导出键
usage
一array，指示可能使用 key 执行的作：
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于对消息进行签名的密钥
verify
验证签名的密钥
deriveKey
key 用于派生新密钥
deriveBits
用于派生位的密钥
wrapKey
key 用于包装 key
unwrapKey
key 用于解包密钥
сrypto.subtle.importKey(format,keyData,algorithm,extractable,keyUsages)
导入密钥：将外部可移植格式的密钥作为输入 并给出一个CryptoKey对象。 返回一个Promise，该 key 使用 import key 实现 作为CryptoKey对象。 可能的值：
format
描述要导入的 Key 的数据格式的字符串， 可以是以下内容：
raw
原始数据格式
pkcs8
PKCS #8 格式
spki
SubjectPublicKeyInfo 格式
jwk
JSON Web Key （JWK） 格式（自 0.7.10 起)
keyData
这ArrayBuffer,TypedArray或DataView包含给定格式的键的对象
algorithm
定义要导入的键类型的 Dictionary 对象 并提供额外的特定于算法的参数：
  • 为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（可选） 是一个数字，表示 键的长度（以位为单位）。 如果省略，则键的长度等于摘要的长度 由所选的 Digest 函数生成。
  • 为AES-CTR,AES-CBC或AES-GCM, 传递标识算法或对象的字符串 的形式{ "name": "ALGORITHM" }, 哪里ALGORITHM是算法的名称
  • 为PBKDF2, 将PBKDF2字符串
  • 为HKDF, 将HKDF字符串
extractable
boolean 值，该值指示是否可以导出键
keyUsages
一array，指示可能使用 key 执行的作：
encrypt
用于加密消息的密钥
decrypt
用于解密消息的密钥
sign
用于对消息进行签名的密钥
verify
验证签名的密钥
deriveKey
key 用于派生新密钥
deriveBits
用于派生位的密钥
wrapKey
key 用于包装 key
unwrapKey
key 用于解包密钥
сrypto.subtle.sign(algorithm,key,data)
返回signature作为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对象 用于签名的密钥。 如果 algorithm 标识了公钥加密系统，则此密钥是私钥。
data
是一个ArrayBuffer,TypedArray或DataView包含待签名数据的对象
сrypto.subtle.verify(algorithm,key,signature,data)
验证数字签名， 返回Promise，它以布尔值实现：true如果签名有效， 否则false. 可能的值：
algorithm
是指定要使用的算法的字符串或对象 及其参数：
  • 为RSASSA-PKCS1-v1_5, 传递标识算法或对象的字符串 的形式{ "name": "ALGORITHM" }
  • 为RSA-PSS, 使用以下键传递对象：
    • name是一个字符串，则应设置为RSA-PSS
    • saltLength是长integer，表示要使用的随机盐的长度（以字节为单位）
  • 为ECDSA, 使用以下键传递对象：
    • name是一个字符串，则应设置为ECDSA
    • hash是摘要算法要使用的标识符， 可以是SHA-256,SHA-384或SHA-512
  • 为HMAC, 传递标识算法或对象的字符串 的形式{ "name": "ALGORITHM" }
key
是一个CryptoKey对象 该密钥用于验证。 它是对称算法的密钥 以及公钥系统的公钥。
signature
是一个ArrayBuffer,TypedArray或DataView，其中包含要验证的签名
data
是一个ArrayBuffer,TypedArray或DataView包含要验证其签名的数据的对象

加密密钥

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

这CryptoKey对象 表示加密key获得 从SubtleCrypto方法：с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
key 用于派生新密钥
deriveBits
用于派生位的密钥

加密密钥对

CryptoKeyPair.privateKey
CryptoKeyPair.publicKey

这CryptoKeyPair是一个 Dictionary 对象 表示非对称密钥对的 WebCrypto API。

CryptoKeyPair.privateKey
一个CryptoKey对象 表示私钥。
CryptoKeyPair.publicKey
一个CryptoKey对象 表示公钥。

新泽西州

njs.version
njs.version_number
njs.dump()
njs.memoryStats
njs.on()

这njsobject 是一个全局对象 表示当前 VM 实例 （自 0.2.0 起）。

njs.version
返回具有当前 njs 版本的字符串 （例如，“0.7.4”）。
njs.version_number
返回一个包含当前版本 njs 的数字。 例如，“0.7.4” 返回为0x000704（自 0.7.4 起）。
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

这processobject 是一个全局对象 ，提供有关当前进程的信息 （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（） 方法将 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.frommethod 应改用：
>> 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 字符串序列化为字节字符串， 返回null如果大于 255 的字符为 在字符串中找到。
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 之前， 序列化 Unicode 字符串 转换为使用 UTF-8 编码的字节字符串：
>> 'αβγδ'.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])
创建一个新的TextDecoder对象 对于指定encoding, 目前仅支持 UTF-8。 这options是TextDecoderOptionsdictionary 的 Dictionary 中具有以下属性：
fatal
布尔标志，指示 ifTextDecoder.decode()必须抛出TypeErrorexception 时 发现编码错误，默认情况下为false.
TextDecoder.prototype.encoding
返回一个字符串，其编码名称为TextDecoder(), 只读。
TextDecoder.prototype.fatal
布尔标志、true如果 错误模式是致命的， 只读。
TextDecoder.prototype.ignoreBOM
布尔标志、true如果 字节顺序标记被忽略， 只读。
TextDecoder.prototype.decode(buffer, [options])
返回一个字符串，其中包含文本 从buffer由TextDecoder(). 缓冲区可以是ArrayBuffer. 这options是TextDecodeOptionsdictionary 的 Dictionary 中具有以下属性：
stream
布尔标志，指示 if 后续调用decode():true如果以块的形式处理数据，并且false对于最后一个 chunk 或者如果数据未分块。 默认情况下为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和 返回一个 Dictionary 对象，该对象显示编码的进度。 dictionary 对象包含两个成员：
read
来自源的代码的 UTF-16 单位数string转换为 UTF-8
written
目标中修改的字节数Uint8Array

定时器

clearTimeout()
setTimeout()

clearTimeout(timeout)
取消timeout对象 创建者setTimeout().
setTimeout(function, milliseconds[, argument1, argumentN])
调用function在指定数量的milliseconds. 一个或多个可选arguments可以传递给指定的函数。 返回一个timeout对象。
function handler(v)
{
    // ...
}

t = setTimeout(handler, 12);

// ...

clearTimeout(t);

全局函数

atob()
btoa()

atob(encodedData)
解码已编码的数据字符串 用Base64编码。 这encodedDataparameter 是二进制字符串 ，其中包含 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 字符串。 这stringToEncodeparameter 是要编码的二进制字符串。 返回一个 ASCII 字符串，其中包含 的 Base64 表示形式stringToEncode.

该方法可用于对数据进行编码 否则可能会导致通信问题，传输它， 然后使用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()
buffer[]
buf.buffer
buf.byteOffset
buf.compare()
buf.copy()
buf.equals()
buf.fill()
buf.includes()
buf.indexOf()
buf.lastIndexOf()
buf.length
buf.readIntBE()
buf.readIntLE()
buf.readUIntBE()
buf.readUIntLE()
buf.readDoubleBE
buf.readDoubleLE()
buf.readFloatBE()
buf.readFloatLE()
buf.subarray()
buf.slice()
buf.swap16()
buf.swap32()
buf.swap64()
buf.toJSON()
buf.toString()
buf.write()
buf.writeIntBE()
buf.writeIntLE()
buf.writeUIntBE()
buf.writeUIntLE()
buf.writeDoubleBE()
buf.writeDoubleLE()
buf.writeFloatBE()
buf.writeFloatLE()

Buffer.alloc(size[, fill[, encoding]]))

分配指定size. 如果fill未指定，则 Buffer 将填充零。 如果fill指定， 分配的 Buffer 将通过调用buf.fill(fill). 如果fill和encoding指定， 分配的 Buffer 将通过调用buf.fill(fill, encoding).

这fillparameter 可以是string,Buffer,Uint8Array或integer.

Buffer.allocUnsafe(size)

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

Buffer.byteLength(value[, encoding])
返回指定值的字节长度， 当使用encoding. 该值可以是string,Buffer,TypedArray,DataView或ArrayBuffer. 如果值为string, 这encodingparameter 是它的编码，可以是utf8,hex,base64,base64url; 默认情况下为utf8.
Buffer.compare(buffer1, buffer2)
比较buffer1跟buffer2对 Buffer 实例的数组进行排序时。 返回0如果buffer1与buffer2,1如果buffer2应该在之前buffer1排序时，或-1如果buffer2应该在之后buffer1排序时。
Buffer.concat(list[, totalLength])
返回新的 Buffer 这是连接列表中所有 Buffer 实例的结果。 如果列表中没有项或总长度为 0， 返回一个新的零长度 Buffer。 如果totalLength未指定， 它是从 Buffer instances in 列表中计算的，方法是将它们的长度相加。 如果totalLength指定， 它被强制转换为无符号整数。 如果 Buffers in （缓冲区） 列表的总长度超过totalLength, 结果被截断为totalLength.
Buffer.from(array)
使用字节数组分配新的 Buffer 在范围0–255. 超出该范围的数组条目将被截断。
Buffer.from(arrayBuffer, byteOffset[, length]])
创建ArrayBuffer而无需复制底层内存。 可选的byteOffset和length参数 在arrayBuffer将由 Buffer 共享。
Buffer.from(buffer)
将传递的缓冲区数据复制到新的 Buffer 实例上。
Buffer.from(object[, offsetOrEncoding[, length]])
对于其valueOf()功能 返回一个不严格等于 object 的值， 返回Buffer.from(object.valueOf(),offsetOrEncoding,length).
Buffer.from(string[, encoding])
使用string. 这encoding参数标识字符编码 在将字符串转换为字节时使用。 编码可以是utf8,hex,base64,base64url; 默认情况下为utf8.
Buffer.isBuffer(object)
布尔值 返回true如果object是一个 Buffer。
Buffer.isEncoding(encoding)
布尔值 返回true如果 encoding 是支持的字符编码的名称。
buffer[index]
可用于获取和设置八位字节的索引运算符 at 位置index在buffer. 这些值是指单个字节， 因此，合法值范围介于 0 和 255 （十进制） 之间。
buf.buffer
底层ArrayBuffer对象 此 Buffer 对象创建的基础。
buf.byteOffset
整数 指定byteOffset缓冲区 底层ArrayBuffer对象。
buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
将 buffer 与target并返回一个数字 指示缓冲区是位于 Cellout 之前、之后还是相同 如target按排序顺序。 比较基于每个 Buffer 中的实际字节序列。 这targetStart是一个整数，指定 其中的偏移量target从哪个位置开始比较， 默认为 0。 这targetEnd是一个整数，指定 其中的偏移量target在哪个位置结束比较， 默认情况下为target.length. 这sourceStart是一个整数，指定 缓冲区内开始比较的偏移量， 默认为 0。 这sourceEnd是一个整数，指定 缓冲区中结束比较的偏移量（不包括）， 默认情况下为buf.length.
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
将数据从缓冲区区域复制到target, 即使目标内存区域与 buffer 重叠。 这targetparameter 是Buffer或Uint8Array复制到

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

buf.equals(otherBuffer)
布尔值 返回true如果 Buffer 和otherBuffer具有完全相同的字节。
buf.fill(value[, offset[, end]][, encoding])
使用指定的value. 如果offset和end未指定， 将填充整个 Buffer。 这value被强制uint32如果不是string,Buffer或integer. 如果生成的整数大于 255，则 缓冲区将填充value和 255.
buf.includes(value[, byteOffset][, encoding])
相当于buf.indexOf() !== -1, 返回true如果value已找到 在 Buffer 中。
buf.indexOf(value[, byteOffset][, encoding])
返回一个整数，该整数是第一次出现的valuein Buffer 或-1如果 Buffer 不包含 value。 这value可以是string指定encoding（默认情况下utf8),Buffer,Unit8Array, 或介于 0 和 255 之间的数字。
buf.lastIndexOf(value[, byteOffset][, encoding])
与buf.indexOf(), 除了最后一次出现的value已找到 而不是第一次出现。 这value可以是 string、Buffer 或 介于 1 和 255 之间的整数。 如果value是空字符串或空 Buffer，byteOffset将被返回。
buf.length
返回 Buffer 中的字节数。
buf.readIntBE(offset, byteLength)
读取byteLength从buf在指定的offset并将结果解释为 big-endian， 二进制补码有符号值，支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

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

buf.readIntLE(offset, byteLength)
读取byteLength从buf在指定的offset并将结果解释为 little-endian， 二进制补码有符号值，支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

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

buf.readUIntBE(offset, byteLength)
读取byteLength从buf在指定的offset并将结果解释为 big-endian 整数，支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

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

buf.readUIntLE(offset, byteLength)
读取byteLength从buf在指定的offset并将结果解释为 little-endian 整数，支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

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

buf.readDoubleBE([offset])
从buf在指定的offset.
buf.readDoubleLE([offset])
从 中读取 64 位 little-endian doublebuf在指定的offset.
buf.readFloatBE([offset])
从buf在指定的offset.
buf.readFloatLE([offset])
从buf在指定的offset.
buf.subarray([start[, end]])
返回一个新的buf引用与原始 Memory相同的 Memory， 但 offset 和 cropped bystart和end. 如果end大于buf.length, 与 end 等于 的结果相同buf.length返回。
buf.slice([start[, end]])
返回一个新的buf引用与原始 Memory相同的 Memory， 但被start和end值。 该方法与Uint8Array.prototype.slice(), 它是 Buffer 的超类。 要复制切片，请使用Uint8Array.prototype.slice().
buf.swap16()
解释buf作为无符号 16 位数字数组 并就地交换字节顺序。 如果出现buf.length不是 2 的倍数。
buf.swap32()
解释buf作为无符号 32 位数字数组 并就地交换字节顺序。 如果出现buf.length不是 4 的倍数。
buf.swap64()
解释buf作为 64 位数字数组 并就地交换字节顺序。 如果出现buf.length不是 8 的倍数。
buf.toJSON()
返回 JSON 表示形式buf. JSON.stringify()在字符串化 Buffer 实例时隐式调用此函数。
buf.toString([encoding[, start[, end]]])
解码buf转换为字符串 根据指定的字符encoding可以是utf8,hex,base64,base64url. 这start和end参数 可以传递以仅解码 Buffer 的子集。
buf.write(string[, offset[, length]][, encoding])
写入string自buf在offset根据角色encoding. 这lengthparameter 是要写入的字节数。 如果 Buffer 不包含足够的空间来容纳整个字符串，则 只会写入 String 的一部分， 但是，不会写入部分编码的字符。 这encoding可以是utf8,hex,base64,base64url.
buf.writeIntBE(value, offset, byteLength)
写byteLength字节的value自buf在指定的offset作为 big-endian。 支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

还支持以下类似的方法：buf.writeInt8,buf.writeInt16BE,buf.writeInt32BE.

buf.writeIntLE(value, offset, byteLength)
写byteLength字节的value自buf在指定的offset作为 little-endian。 支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

还支持以下类似的方法：buf.writeInt8,buf.writeInt16LE,buf.writeInt32LE.

buf.writeUIntBE(value, offset, byteLength)
写byteLength字节的value自buf在指定的offset作为 big-endian。 支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

还支持以下类似的方法：buf.writeUInt8,buf.writeUInt16BE,buf.writeUInt32BE.

buf.writeUIntLE(value, offset, byteLength)
写byteLength字节的value自buf在指定的offset作为 little-endian。 支持高达 48 位的精度。 这byteLengthparameter 是介于 1 和 6 之间的整数 指定要读取的字节数。

还支持以下类似的方法：buf.writeUInt8,buf.writeUInt16LE,buf.writeUInt32LE.

buf.writeDoubleBE(value, [offset])
写入value自buf在指定的offset作为 big-endian。
buf.writeDoubleLE(value, [offset])
写入value自buf在指定的offset作为 little-endian。
buf.writeFloatBE(value, [offset])
写入value自buf在指定的offset作为 big-endian。
buf.writeFloatLE(value, [offset])
写入value自buf在指定的offset作为 little-endian。

加密

crypto.createHash()
crypto.createHmac()

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

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.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.digest([encoding])
计算使用hmac.update(). 编码可以是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()
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 对象由require('fs'). 从 0.3.9 开始， 文件系统方法的 Promissified 版本可通过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）。 如果该文件不存在，则将创建该文件。 这optionsparameter 应为 具有以下键的对象：
mode
mode 选项，默认情况下为0o666
flag
文件系统标志、 默认情况下为a
closeSync(fd)
关闭fd由整数表示的文件描述符 由 method 使用。 返回undefined.
existsSync(path)
Boolean 值，返回true如果指定了path存在。 （0.8.2)
fstatSync(fd)
检索fs.Stats对象 对于文件描述符 （0.7.7） 的。 这fdparameter 是一个整数 表示该方法使用的文件描述符。
lstatSync(path[, options])
同步检索 这fs.Stats对象 对于path (0.7.1） 的 这optionsparameter 应为 具有以下键的对象：
throwIfNoEntry
一个布尔值，指示 如果不存在文件系统条目，是否引发异常， 而不是返回undefined, 默认情况下为false.
mkdirSync(path[, options])
在指定的path (0.4.2）。 这optionsparameter 应为integer指定 众数、 或具有以下键的对象：
mode
mode 选项，默认情况下为0o777.
openSync(path[, flags[, mode]])
返回一个整数 表示打开的文件的文件描述符path (0.7.7）。
flags
文件系统标志、 默认情况下为r
mode
mode 选项，默认情况下为0o666
promises.open(path[, flags[, mode]])
返回一个FileHandle对象 表示打开的文件path (0.7.7）。
flags
文件系统标志、 默认情况下为r
mode
mode 选项，默认情况下为0o666
readdirSync(path[, options])
同步读取目录的内容 在指定的path (0.4.2）。 这optionsparameter 应为 指定 encoding 的字符串或具有以下键的对象：
encoding
encoding 的默认utf8. 编码可以是utf8和buffer (0.4.4） 的
withFileTypes
如果设置为true，则 files 数组将包含fs.Dirent对象 默认情况下为false.
readFileSync(filename[, options])
同步返回文件的内容 提供filename. 这options参数保持string指定编码。 如果指定了编码，则返回一个字符串， 否则，为 Buffer 对象 （0.4.4） 返回。
在 0.4.4 版本之前， 返回了字节字符串 如果未指定编码。
否则options预计为 具有以下键的对象：
encoding
encoding 时，默认情况下未指定。 编码可以是utf8,hex (0.4.4）、base64 (0.4.4）、base64url (0.4.4） 的
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])
同步获取符号链接的内容path使用 readlink（2） （0.8.7）。 这optionsargument 可以是指定编码的字符串， 或具有encoding财产 指定要使用的字符编码。 如果encoding是buffer, 结果将作为Buffer对象 否则为 string。
readSync(fd, buffer, offset[, length[, position]])
使用文件描述符读取文件路径的内容fd, 返回读取的字节数 （0.7.7） 的。
buffer
这buffervalue 可以是Buffer,TypedArray或DataView
offset
是一个integer代表 缓冲区中要写入数据的位置
length
是一个integer代表 要读取的字节数
position
指定从文件中开始读取的位置， 该值可以是integer或null, 默认情况下为null. 如果position是null, data 将从当前文件位置读取， ，文件位置将更新。 如果 position 是integer, 文件位置将保持不变
realpathSync(path[, options])
通过解析.,..以及使用 realpath（3） 的符号链接。 这optionsargument 可以是指定编码的字符串， 或具有指定字符编码的 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])
同步检索 这fs.Stats对象 对于指定的path (0.7.1） 的 这path可以是string或buffer. 这optionsparameter 应为 具有以下键的对象：
throwIfNoEntry
一个布尔值，指示 如果不存在文件系统条目，则会引发异常 而不是返回undefined, 默认情况下为true.
symlinkSync(target, path)
同步创建名为path指向target使用 symlink（2） （0.3.9）。 相对目标是相对于链接的父目录。
unlinkSync(path)
通过以下方式同步取消链接文件path (0.3.9）。
writeFileSync(filename, data[, options])
同步写入data到文件 提供filename. 这data应为字符串 或 Buffer 对象 （0.4.4）。 如果文件不存在，则会创建该文件， 如果文件存在，则将被替换。 这optionsparameter 应为 具有以下键的对象：
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]])
使用文件描述符将缓冲区写入文件， 返回number写入的字节数 （0.7.7） 的。
fd
一integer表示文件描述符
buffer
这buffervalue 可以是Buffer,TypedArray或DataView
offset
是一个integer这决定了 要写入的缓冲区部分， 默认情况下0
length
是一个integer指定要写入的字节数， 默认情况下是 Buffer.byteLength 的偏移量
position
指距文件开头的偏移量 此数据应写入何处， 可以是integer或null, 默认情况下为null. 另请参见 pwrite（2）。
writeSync(fd, string[, position[, encoding]])
写入string到文件 使用文件描述符fd, 返回number写入的字节数 （0.7.7） 的。
fd
是一个integer表示文件描述符
position
指距文件开头的偏移量 此数据应写入何处， 可以是integer或null，默认情况下为null. 参见 pwrite（2）
encoding
是一个string, 默认情况下为utf8

司 司长。迪伦特

fs.Dirent是目录条目的表示形式 — 文件或子目录。 什么时候readdirSync()使用withFileTypes选择 生成的数组包含fs.Dirent对象。

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

司 司长。文件句柄

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

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

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

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

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

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

司 司长。统计

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

  • stats.isBlockDevice()- 返回true如果fs.Stats对象描述 块设备。
  • stats.isDirectory()- 返回true如果fs.Stats对象描述 文件系统目录。
  • stats.isFIFO()- 返回true如果fs.Stats对象描述 先进先出 （FIFO） 管道。
  • stats.isFile()- 返回true如果fs.Stats对象描述 常规文件。
  • stats.isSocket()- 返回true如果fs.Stats对象描述 一个 socket。
  • stats.isSymbolicLink()- 返回true如果fs.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— 表示文件可以是 由调用进程执行

文件系统标志

这flagoption 可以接受以下值：

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

对给定的string, 返回转义的查询字符串。 该方法由querystring.stringify()，不应直接使用。

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

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

这separatorparameter 是子字符串 用于分隔查询字符串中的键和值对， 默认为 “”。&

这equalparameter 是子字符串 用于分隔查询字符串中的键和值， 默认为 “”。=

这optionsparameter 应为 具有以下键的对象：

decodeURIComponent function
使用的功能 要解码查询字符串中的百分号编码字符，请执行以下作： 默认情况下为querystring.unescape()
maxKeys number
要解析的最大键数， 默认情况下为1000. 这0value 删除对键进行计数的限制。

默认情况下，假定查询字符串中的百分号编码字符 要使用 UTF-8 编码， 无效的 UTF-8 序列将被替换为 这U+FFFD替换字符。

例如，对于以下查询字符串

'foo=bar&abc=xyz&abc=123'

输出将为：

{
  foo: 'bar',
  abc: ['xyz', '123']
}

querystring.stringify(object[, separator[, equal[, options]]])

序列化对象并返回 URL 查询字符串。

这separatorparameter 是子字符串 用于分隔查询字符串中的键和值对， 默认为 “”。&

这equalparameter 是子字符串 用于分隔查询字符串中的键和值， 默认为 “”。=

这optionsparameter 应为 具有以下键的对象：

encodeURIComponent function
转换时使用的函数 URL unsafe 字符设置为查询字符串中的百分号编码， 默认情况下为querystring.escape().

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

例如，对于以下命令

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

查询字符串将为：

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

querystring.unescape(string)

执行 URL 百分比编码字符的解码 的string, 返回未转义的查询字符串。 该方法由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(string | Buffer)
解析 XML 文档的字符串或 Buffer， 返回一个XMLDocwrapper 对象 表示已解析的 XML 文档。
c14n(root_node[, excluding_node])
规范化root_node及其子项根据 Canonical XML 版本 1.1。 这root_node可以是XMLNode或XMLDocwrapper 对象 围绕 XML 结构。 返回包含规范化输出的 Buffer 对象。

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

exclusiveC14n(root_node[, excluding_node[, withComments [,prefix_list]]])
规范化root_node及其子项（根据 Exclusive XML） 规范化版本 1.0。

root_node
是XMLNode或XMLDocwrapper 对象 围绕 XML 结构
excluding_node
允许从输出中省略文档的一部分 对应于 Node 及其子节点
withComments
布尔值false默认情况下。 如果true，则规范化对应于独占 XML 规范化版本 1.0。 返回包含规范化输出的 Buffer 对象。
prefix_list
带有空格分隔的命名空间前缀的可选字符串 对于也应包含在输出中的命名空间

serialize()
与xml.c14n()（自 0.7.11 起）。
serializeToString()
与xml.c14n()但它将结果作为string（自 0.7.11 起）。
XMLDoc
围绕 XML 结构的 XMLDoc 包装器对象， 文档的根节点。

doc.$root
文档的根名称或 undefined
doc.abc
名为abc如XMLNodewrapper 对象

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
一XMLAttrwrapper 对象 对于节点的所有属性
node.$name
节点的名称
node.$ns
节点的命名空间
node.$parent
当前节点的父节点
node.$tag$abc
名为abc, 写 自 0.7.11 起
node.$tags
所有 children 标签的数组
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 作为子节点添加到 Node （自 0.7.11 起）。nd在添加到节点之前递归复制
node.removeAllAttributes()
删除节点的所有属性 （自 0.7.11 起)
node.removeAttribute(attr_name)
删除名为attr_name（自 0.7.11 起)
node.removeChildren(tag_name)
删除所有名为tag_name（自 0.7.11 起）。 如果tag_name不存在，则删除所有 children 标记
node.removeText()
删除节点的文本值 （0.7.11)
node.setAttribute(attr_name, value)
为attr_name（自 0.7.11 起）。 当值为null, 名为attr_name已删除
node.setText(value)
设置节点的文本值 （自 0.7.11 起）。 当值为null时，将删除节点的文本。

XMLAttr
围绕 XML 节点属性的 XMLAttrs 包装对象。

attr.abc
的属性值abc

zlib

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

zlib 模块使用 “deflate” 和 “inflate” 算法 （自 0.7.12 起）。 zlib 模块对象由require('zlib').

deflateRawSync(string | Buffer[, options])
使用以字符串或 Buffer 形式提供的 “deflate” 算法压缩数据 并且不会附加 zlib 标头。 缓冲区值可以是Buffer,TypedArray或DataView.Options是包含 zlib_options 的可选对象。 返回包含压缩数据的 Buffer 实例。
deflateSync(string | Buffer[, options])
使用以 String 或 Buffer 形式提供的 “deflate” 算法压缩数据。 Buffer 值可以是Buffer,TypedArray或DataView.Options是包含 zlib_options 的可选对象。 返回包含压缩数据的 Buffer 实例。
inflateRawSync(string | Buffer)
使用 “deflate” 算法解压缩原始流。 返回包含解压缩数据的 Buffer 实例。
inflateSync(string | Buffer)
使用 “deflate” 算法解压缩流。 返回包含解压缩数据的 Buffer 实例。

zlib 选项

  • chunkSize— 是一个整数， 默认情况下为1024
  • dictionary— 是一个Buffer,TypedArray或DataView. 默认情况下为空
  • level— 是一个整数，仅压缩， 请参阅 zlib_compression_levels
  • memLevel— 是一个整数 从1自9、仅压缩
  • strategy— 是一个整数，仅压缩， 请参阅 zlib_compression_strategy
  • windowBits— 是一个整数 从-15自-9对于原始数据， 从9自15对于普通流

zlib 压缩级别

名字描述
zlib.constants.Z_NO_COMPRESSION无压缩
zlib.constants.Z_BEST_SPEED最快，产生的压缩最少
zlib.constants.Z_DEFAULT_COMPRESSION速度和压缩之间的权衡
zlib.constants.Z_BEST_COMPRESSION最慢，产生的压缩率最高

zlib 压缩策略

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