參考資料

nginx 物件
     HTTP 請求
     串流連線
     週期性連線
     標頭
     請求
     回應
     ngx
     ngx.shared
內建物件
     主控台
     加密
     CryptoKey
     CryptoKeyPair
     njs
     程序
     字串
網頁 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);
}

引數物件會在第一次存取r.args時進行評估。如果只需要單一引數，例如foo，則可以使用nginx 變數

r.variables.arg_foo

在此，nginx 變數物件會傳回給定鍵的第一個值，不區分大小寫，並且不進行百分比解碼。

若要將 r.args 轉換回字串，可以使用查詢字串 stringify 方法。

r.done()

呼叫此函式後，下一個資料區塊將會傳遞給客戶端，而不會呼叫js_body_filter（0.5.2）。只能從js_body_filter函式中呼叫

r.error(字串)

將字串寫入錯誤日誌，記錄等級為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或串流的js_var指令宣告的變數。

從0.7.4開始，此方法接受逸出的 URI。

r.log(字串)

將字串寫入錯誤日誌，記錄等級為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相同，但會傳回 字串。請注意，它可能會將 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[, 字串 | 緩衝區])

將具有指定 status 的完整回應傳送至客戶端。回應可以是字串或緩衝區（0.5.0）。

可以指定重新導向 URL（對於代碼 301、302、303、307 和 308）或回應本文文字（對於其他代碼）作為第二個引數

r.send(字串 | 緩衝區)

將回應本文的一部分傳送至客戶端。傳送的資料可以是字串或緩衝區（0.5.0）

r.sendBuffer(資料[, 選項])

將資料新增至要轉送至下一個本文篩選器的資料區塊鏈（0.5.2）。實際轉送稍後才會發生，屆時會處理目前鏈的所有資料區塊。

資料可以是字串或 Buffer。 options 是一個物件，用於覆寫從傳入的資料區塊緩衝區衍生的 nginx 緩衝區旗標。這些旗標可以使用下列旗標覆寫：

last: 布林值，如果緩衝區是最後一個緩衝區，則為 true
flush: 布林值，如果緩衝區應該具有 flush 旗標，則為 true

此方法只能從 js_body_filter 函式中呼叫。

r.sendHeader()

將 HTTP 標頭傳送到用戶端

r.setReturnValue(value)

設定 js_set 處理常式的回傳值 (0.7.0)。與一般 return 陳述式不同，當處理常式是 JS 非同步函式時，應該使用此方法。例如：

async function js_set(r) {
    const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host);
    r.setReturnValue(digest);
}

r.status

status，可寫入

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

使用指定的 uri 和 options 建立子請求，並安裝一個可選的完成 callback。

子請求與用戶端請求共用其輸入標頭。若要將與原始標頭不同的標頭傳送至代理伺服器，可以使用 proxy_set_header 指令。若要將一組全新的標頭傳送至代理伺服器，可以使用 proxy_pass_request_headers 指令。

如果 options 是字串，則它會包含子請求引數字串。否則，預期 options 是一個具有下列鍵的物件：

args: 引數字串，預設使用空字串
body: 請求主體，預設使用父請求物件的請求主體
method: HTTP 方法，預設使用 GET 方法
detached: 布林旗標 (0.3.9)，如果 true，則建立的子請求是一個分離的子請求。會忽略對分離子請求的回應。與一般子請求不同，分離的子請求可以在變數處理常式內建立。detached 旗標和 callback 引數是互斥的。

完成 callback 接收一個子請求回應物件，其中包含與父請求物件相同的方法和屬性。

自 0.3.8 起，如果未提供 callback，則會傳回解析為子請求回應物件的 Promise 物件。

例如，若要檢視子請求中的所有回應標頭：

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

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

    r.return(200);
}

r.uri

請求中目前的 URI，已正規化，唯讀

r.rawVariables{}

nginx 變數作為 Buffer，可寫入（自 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 中參照的變數和未參照的變數。當變數被參照時，它可能是可快取的，但是當它未被參照時，它始終是不可快取的。例如，當只有從 njs 存取 $request_id 變數時，它每次評估時都會有一個新值。但是，當參照 $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: 來自用戶端的新資料 (Buffer) (自 0.5.0 起)
downstream: 給用戶端的新資料 (Buffer) (自 0.5.0 起)

完成回呼具有下列原型：callback(data, flags)，其中 data 是字串或 Buffer (取決於事件類型)，而 flags 是一個具有下列屬性的物件

last: 布林值，如果資料是最後一個緩衝區，則為 true。

s.remoteAddress

客戶端位址，唯讀

s.rawVariables

nginx 變數作為 Buffer，可寫入（自 0.5.0 起）

s.send(data[, options])

將資料新增到資料區塊的鏈中，這些區塊將以正向轉送：在下載回呼中轉送給用戶端；在上傳中轉送給上游伺服器 (0.2.4)。實際的轉送稍後才會發生，當目前鏈的所有資料區塊都處理完成時。

資料可以是字串或 Buffer (0.5.0)。options 是一個物件，用於覆寫從傳入的資料區塊緩衝區衍生的 nginx 緩衝區旗標。這些旗標可以使用下列旗標覆寫：

last: 布林值，如果緩衝區是最後一個緩衝區，則為 true
flush: 布林值，如果緩衝區應該具有 flush 旗標，則為 true

此方法可以在每次回呼調用中呼叫多次。

s.sendDownstream()

與 s.send() 相同，但它總是將資料傳送給用戶端 (自 0.7.8 起)。

s.sendUpstream()

與 s.send() 相同，但它總是將資料從用戶端傳送 (自 0.7.8 起)。

s.status

會話狀態碼，是 $status 變數的別名，唯讀 (自 0.5.2 起)

s.setReturnValue(value)

設定 js_set 處理常式的回傳值 (0.7.0)。與一般 return 陳述式不同，當處理常式是 JS 非同步函式時，應該使用此方法。例如：

async function js_set(r) {
    const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host);
    r.setReturnValue(digest);
}

s.variables{}

nginx 變數物件，可寫入（自 0.2.8 起）。只有在 nginx 組態檔中參照變數時，該變數才是可寫入的。即使如此，某些內嵌變數仍然無法指派值。

s.warn(string)

將傳送的 string 寫入錯誤日誌，記錄層級為 warning

由於 nginx 具有硬式編碼的最大行長度限制，因此只能記錄字串的前 2048 個位元組。

週期性連線

PeriodicSession.rawVariables{}

PeriodicSession.variables{}

Periodic Session 物件會作為 http 和 stream 的 js_periodic 處理常式的第一個引數提供 (自 0.8.1 起)。

PeriodicSession.rawVariables{}: nginx 變數作為 Buffer，可寫入。
PeriodicSession.variables{}: nginx 變數物件，可寫入。

標頭

自 0.5.1 起，可以使用 Fetch API 的 Headers 介面。

可以使用 Headers() 建構函式建立新的 Headers 物件：（自 0.7.10 起）

Headers([init])

init: 一個包含 HTTP 標頭的物件，用於預先填入 Headers 物件，可以是 string、名稱-值配對的 array 或現有的 Headers 物件。

可以使用下列屬性和方法建立新的 Headers 物件

append(): 將新值附加到 Headers 物件中現有的標頭，或新增該標頭 (如果它還不存在) (自 0.7.10 起)。
delete(): 從 Headers 物件中刪除標頭 (自 0.7.10 起)。
get(): 傳回一個字串，其中包含以逗號和空格分隔的所有具有指定名稱的標頭值。
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: 回應標頭物件 — 包含 HTTP 標頭的物件，用於預先填入 Headers 物件，可以是 string、名稱-值配對的 array 或現有的 Headers 物件。
method: HTTP 方法，預設使用 GET 方法。

可以使用下列屬性和方法建立新的 Request 物件

arrayBuffer(): 傳回一個解析為 ArrayBuffer 的 Promise。
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() 建構子來建立新的 Response 物件（從 0.7.10 版本開始）。

Response[body[, options]]

建立一個 Response 物件。body 是一個可選參數，可以是 string 或 buffer，預設為 null。options 是一個可選參數，預期為一個具有以下鍵的物件：

headers: 回應標頭物件 — 包含 HTTP 標頭的物件，用於預先填入 Headers 物件，可以是 string、名稱-值配對的 array 或現有的 Headers 物件。
status: 回應的狀態碼。
statusText: 與狀態碼相對應的狀態訊息。

可以使用以下屬性和方法建立新的 Response() 物件：

arrayBuffer(): 接收 Response 資料流並讀取至完成。返回一個 Promise，該 Promise 將解析為 ArrayBuffer。
bodyUsed: 一個布林值，如果已讀取主體則為 true。
headers: 與 Response 關聯的唯讀 Headers 物件。
json(): 接收 Response 資料流並讀取至完成。返回一個 Promise，該 Promise 將解析主體文字為 JSON 的結果。
ok: 一個布林值，如果回應成功（狀態碼介於 200–299 之間）則為 true。
redirected: 一個布林值，如果回應是重新導向的結果則為 true。
status: 回應的狀態碼。
statusText: 與狀態碼相對應的狀態訊息。
text(): 接收 Response 資料流並讀取至完成。返回一個 Promise，該 Promise 將解析為字串。
type: 回應的類型。
url: 回應的 URL。

ngx

ngx 全域物件從 0.5.0 版本開始可用。

ngx.build

一個字串，包含一個可選的 nginx 建置名稱，對應於 --build=name 參數，它是 configure 指令碼的參數，預設為 ""（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，該 Promise 將解析為 Response 物件。從 0.7.0 版本開始，支援 https:// 協定，不處理重新導向。

如果 resource 中的 URL 指定為網域名稱，則會使用解析器決定。如果指定 https:// 協定，則應設定 js_fetch_trusted_certificate 指令，以驗證 resource 的 HTTPS 伺服器。

預期 options 參數是一個具有以下鍵的物件：

body: 請求主體，預設為空。
buffer_size: 讀取回應的緩衝區大小，預設為 4096。
headers: 請求標頭物件。
max_response_body_size: 回應主體的最大大小（以位元組為單位），預設為 32768。
method: HTTP 方法，預設使用 GET 方法
verify: 啟用或停用 HTTPS 伺服器憑證的驗證，預設為 true（0.7.0）。

範例

let reply = await ngx.fetch('https://nginx.dev.org.tw/');
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 是要新增項目的值。

可選的 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 字典中不存在該 key，則返回 false。如果 SharedDict 字典中沒有足夠的可用空間，則會拋出 SharedMemoryError 錯誤。如果 value 的類型與此字典預期的類型不同，則會拋出 TypeError 錯誤。

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

為指定的 key 設定 value，並返回此 SharedDict 字典（用於方法鏈）。

ngx.shared.SharedDict.size()

返回 SharedDict 字典中的項目數量。

ngx.shared.SharedDict.type

返回與 js_shared_dict_zone 指令在 http 或 stream 中使用 type= 參數所設定的 SharedDict 字典類型對應的 string 或 number。

內建物件

主控台

console 物件自 0.8.2 版本起在 nginx 中可用，自 0.2.6 版本起在 CLI 中可用。

console.error(msg[, msg2 ...]): 輸出一個或多個錯誤訊息。訊息可以是字串或物件。
console.info(msg[, msg2 ...]): 輸出一個或多個資訊訊息。訊息可以是字串或物件。
console.log(msg[, msg2 ...]): 輸出一個或多個日誌訊息。訊息可以是字串或物件。
console.time(label): 啟動一個計時器，用於追蹤操作所花費的時間。label 參數允許命名不同的計時器。如果呼叫具有相同名稱的 console.timeEnd()，則會輸出自計時器啟動以來經過的時間（以毫秒為單位）。
console.timeEnd(label): 停止先前由 console.time() 啟動的計時器。label 參數允許命名不同的計時器。
console.warn(msg[, msg2 ...]): 輸出一個或多個警告訊息。訊息可以是字串或物件。

加密

с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。

長度

是一個數字，表示要衍生的位元數。為了瀏覽器的相容性，該數字應為 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

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() 方法會將程式碼點高達 255 的 Unicode 字串序列化為位元組字串，否則，傳回 null

>> '£'.toBytes().toString('hex')
'a3'  /* a3 is a byte equal to 00A3 ('£') code point  */

String.bytesFrom(array | string, encoding)

此方法在 0.4.4 中已過時，並在 0.8.0 中移除。應改用 Buffer.from 方法

>> Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]).toString()
'buffer'

>> Buffer.from('YnVmZmVy', 'base64').toString()
'buffer'

在 0.4.4 之前，可以從包含八位元的陣列，或從已編碼的字串 (0.2.3) 建立位元組字串，編碼可以是 hex、base64 和 base64url。

String.prototype.fromBytes(start[, end])

此屬性在 0.7.7 中已過時，並在 0.8.0 中移除。在 0.7.7 之前，會從位元組字串傳回新的 Unicode 字串，其中每個位元組都會被替換為對應的 Unicode 程式碼點。

String.prototype.fromUTF8(start[, end])

此屬性在 0.7.7 中已過時，並在 0.8.0 中移除。應改用 TextDecoder 方法。在 0.7.7 之前，會將包含有效 UTF-8 字串的位元組字串轉換為 Unicode 字串，否則會傳回 null。

String.prototype.toBytes(start[, end])

此屬性在 0.7.7 中已過時，並在 0.8.0 中移除。在 0.7.7 之前，會將 Unicode 字串序列化為位元組字串，如果在字串中找到大於 255 的字元，則會傳回 null。

String.prototype.toString(encoding)

此屬性在 0.7.7 中已過時，並在 0.8.0 中移除。在 0.7.7 之前，會將字串編碼為 hex、base64 或 base64url

>>  'αβγδ'.toString('base64url')
'zrHOss6zzrQ'

在 0.4.3 版之前，只能編碼位元組字串

>>  'αβγδ'.toUTF8().toString('base64url')
'zrHOss6zzrQ'

String.prototype.toUTF8(start[, end])

此屬性在 0.7.7 中已過時，並在 0.8.0 中移除。應改用 TextEncoder 方法。在 0.7.7 之前，會使用 UTF-8 編碼將 Unicode 字串序列化為位元組字串

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

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

傳回一個字串，其中包含從 buffer 解碼的文字，由 TextDecoder() 解碼。緩衝區可以是 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 編碼為包含 UTF-8 編碼文字的 Uint8Array。

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 參數是要編碼的二進位字串。傳回一個 ASCII 字串，其中包含 stringToEncode 的 Base64 表示法。

此方法可用於編碼可能導致通訊問題的資料、傳輸該資料，然後使用 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 實例上。

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

對於其 valueOf() 函式返回的值與物件不完全相等的物件，返回 Buffer.from(object.valueOf(), offsetOrEncoding, length)。

Buffer.from(string[, encoding])

使用 string 建立新的 Buffer。encoding 參數識別將字串轉換為位元組時要使用的字元編碼。編碼可以是 utf8、hex、base64、base64url；預設為 utf8。

Buffer.isBuffer(object)

一個布林值，如果 object 是 Buffer，則返回 true。

Buffer.isEncoding(encoding)

一個布林值，如果編碼是受支援的字元編碼的名稱，則返回 true。

buffer[index]

索引運算子，可用於取得和設定 buffer 中位置 index 的八位元組。這些值是指個別位元組，因此合法的值範圍介於 0 和 255 之間（十進位）。

buf.buffer

此 Buffer 物件所依據建立的底層 ArrayBuffer 物件。

buf.byteOffset

一個整數，指定 Buffer 底層 ArrayBuffer 物件的 byteOffset。

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

將 buffer 與 target 進行比較，並返回一個數字，指示 buffer 在排序順序中是在 target 之前、之後，還是與 target 相同。比較是基於每個 Buffer 中的實際位元組序列。targetStart 是一個整數，指定從 target 中開始比較的偏移量，預設為 0。targetEnd 是一個整數，指定在 target 中結束比較的偏移量，預設為 target.length。sourceStart 是一個整數，指定從 buffer 中開始比較的偏移量，預設為 0。sourceEnd 是一個整數，指定在 buffer 中結束比較的偏移量（不包含），預設為 buf.length。

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

將 buffer 的一個區域中的資料複製到 target 的一個區域中，即使目標記憶體區域與 buffer 重疊。target 參數是要複製到的 Buffer 或 Uint8Array。

targetStart 是一個整數，指定在 target 中開始寫入的偏移量，預設為 0。sourceStart 是一個整數，指定從 buffer 中開始複製的偏移量，預設為 0。sourceEnd 是一個整數，指定在 buffer 中停止複製的偏移量（不包含），預設為 buf.length。

buf.equals(otherBuffer)

一個布林值，如果 Buffer 和 otherBuffer 具有完全相同的位元組，則返回 true。

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

使用指定的 value 填滿 Buffer。如果未指定 offset 和 end，則將填滿整個 Buffer。如果 value 不是 string、Buffer 或 integer，則會強制轉換為 uint32。如果結果整數大於 255，則 Buffer 將填滿 value 和 255。

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

等效於 buf.indexOf() !== -1，如果 value 在 Buffer 中找到，則返回 true。

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

返回一個整數，該整數是 value 在 Buffer 中第一次出現的索引，如果 Buffer 不包含 value，則返回 -1。value 可以是具有指定 encoding (預設為 utf8)、Buffer、Unit8Array 的 string，或介於 0 和 255 之間的數字。

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

與 buf.indexOf() 相同，只是找到 value 的最後一次出現，而不是第一次出現。value 可以是字串、Buffer 或介於 1 和 255 之間的整數。如果 value 是空字串或空 Buffer，則會傳回 byteOffset。

buf.length

返回 Buffer 中的位元組數。

buf.readIntBE(offset, byteLength)

從 buf 中指定的 offset 讀取 byteLength，並將結果解譯為大端序、二補數帶符號值，最多支援 48 位元的精確度。byteLength 參數是一個介於 1 和 6 之間的整數，指定要讀取的位元組數。

也支援類似的方法：buf.readInt8([offset])、buf.readInt16BE([offset])、buf.readInt32BE([offset])。

buf.readIntLE(offset, byteLength)

從 buf 中指定的 offset 讀取 byteLength，並將結果解譯為小端序、二補數帶符號值，最多支援 48 位元的精確度。byteLength 參數是一個介於 1 和 6 之間的整數，指定要讀取的位元組數。

也支援類似的方法：buf.readInt8([offset])、buf.readInt16LE([offset])、buf.readInt32LE([offset])。

buf.readUIntBE(offset, byteLength)

從 buf 中指定的 offset 讀取 byteLength，並將結果解譯為最多支援 48 位元精確度的大端序整數。byteLength 參數是一個介於 1 和 6 之間的整數，指定要讀取的位元組數。

也支援類似的方法：buf.readUInt8([offset])、buf.readUInt16BE([offset])、buf.readUInt32BE([offset])。

buf.readUIntLE(offset, byteLength)

從 buf 中指定的 offset 讀取 byteLength，並將結果解譯為最多支援 48 位元精確度的小端序整數。byteLength 參數是一個介於 1 和 6 之間的整數，指定要讀取的位元組數。

也支援類似的方法：buf.readUInt8([offset])、buf.readUInt16LE([offset])、buf.readUInt32LE([offset])。

buf.readDoubleBE([offset])

從 buf 中指定的 offset 讀取一個 64 位元、大端序雙精度浮點數。

buf.readDoubleLE([offset])

從 buf 中指定的 offset 讀取一個 64 位元、小端序雙精度浮點數。

buf.readFloatBE([offset])

從 buf 中指定的 offset 讀取一個 32 位元、大端序浮點數。

buf.readFloatLE([offset])

從 buf 中指定的 offset 讀取一個 32 位元、小端序浮點數。

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

返回一個新的 buf，它引用與原始記憶體相同的記憶體，但會由 start 和 end 進行偏移和裁剪。如果 end 大於 buf.length，則會傳回與 end 等於 buf.length 相同結果。

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

返回一個新的 buf，它引用與原始記憶體相同的記憶體，但會由 start 和 end 值進行偏移和裁剪。此方法與 Uint8Array.prototype.slice() 不相容，後者是 Buffer 的超類別。若要複製切片，請使用 Uint8Array.prototype.slice()。

buf.swap16()

將 buf 解譯為一個無符號 16 位元數字的陣列，並就地交換位元組順序。如果 buf.length 不是 2 的倍數，則會擲回錯誤。

buf.swap32()

將 buf 解譯為一個無符號 32 位元數字的陣列，並就地交換位元組順序。如果 buf.length 不是 4 的倍數，則會擲回錯誤。

buf.swap64()

將 buf 解譯為一個 64 位元數字的陣列，並就地交換位元組順序。如果 buf.length 不是 8 的倍數，則會擲回錯誤。

buf.toJSON()

返回 buf 的 JSON 表示法。當字串化 Buffer 實例時，JSON.stringify() 會隱式呼叫此函式。

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

根據指定的字元 encoding 將 buf 解碼為字串，該編碼可以是 utf8、hex、base64、base64url。可以傳遞 start 和 end 參數，以便僅解碼 Buffer 的子集。

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

根據字元 encoding，在 offset 處將 string 寫入 buf。length 參數是要寫入的位元組數。如果 Buffer 沒有足夠的空間來容納整個字串，則只會寫入部分字串，但是，不會寫入部分編碼的字元。encoding 可以是 utf8、hex、base64、base64url。

buf.writeIntBE(value, offset, byteLength)

以大端序將 byteLength 位元組的 value 寫入 buf 中指定的 offset。最多支援 48 位元的精確度。byteLength 參數是一個介於 1 和 6 之間的整數，指定要讀取的位元組數。

也支援以下類似的方法：buf.writeInt8、buf.writeInt16BE、buf.writeInt32BE。

buf.writeIntLE(value, offset, byteLength)

以小端序將 value 的 byteLength 位元組寫入 buf 中指定的 offset 位置。支援最高 48 位元的精確度。 byteLength 參數是一個介於 1 到 6 之間的整數，表示要讀取的位元組數。

也支援以下類似的方法：buf.writeInt8、buf.writeInt16LE、buf.writeInt32LE。

buf.writeUIntBE(value, offset, byteLength)

也支援以下類似的方法：buf.writeUInt8、buf.writeUInt16BE、buf.writeUInt32BE。

buf.writeUIntLE(value, offset, byteLength)

也支援以下類似的方法：buf.writeUInt8、buf.writeUInt16LE、buf.writeUInt32LE。

buf.writeDoubleBE(value, [offset])

以大端序將 value 寫入 buf 中指定的 offset 位置。

buf.writeDoubleLE(value, [offset])

以小端序將 value 寫入 buf 中指定的 offset 位置。

buf.writeFloatBE(value, [offset])

以大端序將 value 寫入 buf 中指定的 offset 位置。

buf.writeFloatLE(value, [offset])

以小端序將 value 寫入 buf 中指定的 offset 位置。

加密

crypto.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: 檔案系統旗標，預設為 a。

closeSync(fd)

關閉該方法使用的整數表示的 fd 檔案描述符。返回 undefined。

existsSync(path)

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

fstatSync(fd)

檢索檔案描述符的 fs.Stats 物件 (0.7.7)。 fd 參數是一個整數，表示該方法使用的檔案描述符。

lstatSync(path[, options])

同步檢索由 path 引用的符號連結的 fs.Stats 物件 (0.7.1)。 options 參數應為具有以下鍵的物件：

throwIfNoEntry: 一個布林值，指示如果沒有檔案系統項目存在，是否拋出例外狀況，而不是返回 undefined，預設為 false。

mkdirSync(path[, options])

同步在指定的 path 建立目錄 (0.4.2)。 options 參數應為指定 mode 的 integer，或具有以下鍵的物件：

mode: 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)。 options 參數應為指定 encoding 的字串或具有以下鍵的物件：

encoding: 編碼，預設為 utf8。編碼可以是 utf8 和 buffer (0.4.4)。
withFileTypes: 如果設定為 true，則檔案陣列將包含 fs.Dirent 物件，預設為 false。

readFileSync(filename[, options])

同步返回具有指定 filename 的檔案的內容。 options 參數包含指定編碼的 string。如果指定了編碼，則返回字串，否則返回 Buffer 物件 (0.4.4)。

在 0.4.4 版本之前，如果未指定編碼，則返回位元組字串。

否則，options 預期為具有以下鍵的物件：

encoding: 編碼，預設為未指定。編碼可以是 utf8、hex (0.4.4)、base64 (0.4.4)、base64url (0.4.4)。
flag: 檔案系統旗標，預設為 r。

>> 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: 是一個 integer，表示要將資料寫入的緩衝區中的位置。
長度: 是一個 integer，表示要讀取的位元組數。
position: 指定從檔案中開始讀取的位置，該值可以是 integer 或 null，預設為 null。如果 position 為 null，則將從目前檔案位置讀取資料，並且檔案位置將會更新。如果 position 是 integer，則檔案位置將保持不變。

realpathSync(path[, options])

同步使用 realpath(3) 解析 .、.. 和符號連結來計算規範路徑名稱。 options 引數可以是指定編碼的字串，也可以是具有編碼屬性的物件，該屬性指定要用於傳遞給回呼的路徑的字元編碼 (0.3.9)。

renameSync(oldPath, newPath)

同步將檔案的名稱或位置從 oldPath 變更為 newPath (0.3.4)。

>> 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 可以是 string 或 buffer。 options 參數應為具有以下鍵的物件：

throwIfNoEntry: 一個布林值，指示如果沒有檔案系統項目存在，是否拋出例外狀況，而不是返回 undefined，預設為 true。

symlinkSync(target, path)

同步使用 symlink(2) 建立名為 path 的連結，該連結指向 target (0.3.9)。相對目標相對於連結的父目錄。

unlinkSync(path)

同步解除 path 指定的檔案連結 (0.3.9)。

writeFileSync(filename, data[, options])

同步將 data 寫入到指定的 filename 檔案中。data 預期為字串或 Buffer 物件 (0.4.4)。如果檔案不存在，將會建立該檔案；如果檔案存在，則會被取代。options 參數預期為一個包含以下鍵值的物件：

mode: mode 選項，預設為 0o666。
flag: 檔案系統的旗標，預設值為 w

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

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

使用檔案描述符將 buffer 寫入檔案，並返回寫入的位元組 number 數量 (0.7.7)。

fd: 一個代表檔案描述符的 integer 整數
buffer: buffer 值可以是 Buffer、TypedArray 或 DataView。
offset: 是一個 integer 整數，決定要寫入的 buffer 部分，預設為 0
長度: 是一個 integer 整數，指定要寫入的位元組數，預設值為 Buffer.byteLength 的偏移量
position: 指的是從檔案開頭開始計算的偏移量，資料應從該處寫入，可以是 integer 整數或 null，預設為 null。另請參閱 pwrite(2)。

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

使用檔案描述符 fd 將 string 字串寫入檔案，並返回寫入的位元組 number 數量 (0.7.7)。

fd: 一個代表檔案描述符的 integer 整數
position: 指的是從檔案開頭開始計算的偏移量，資料應從該處寫入，可以是 integer 整數或 null，預設為 null。另請參閱 pwrite(2)。
encoding: 是一個 string 字串，預設為 utf8

fs.Dirent

fs.Dirent 是目錄項的表示法，即檔案或子目錄。當使用 withFileTypes 選項呼叫 readdirSync() 時，產生的陣列會包含 fs.Dirent 物件。

dirent.isBlockDevice() — 如果 fs.Dirent 物件描述的是區塊裝置，則返回 true。
dirent.isCharacterDevice() — 如果 fs.Dirent 物件描述的是字元裝置，則返回 true。
dirent.isDirectory() — 如果 fs.Dirent 物件描述的是檔案系統目錄，則返回 true。
dirent.isFIFO() — 如果 fs.Dirent 物件描述的是先進先出 (FIFO) 管道，則返回 true。
dirent.isFile() — 如果 fs.Dirent 物件描述的是一般檔案，則返回 true。
dirent.isSocket() — 如果 fs.Dirent 物件描述的是 socket，則返回 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: 一個將會被讀取的檔案資料填滿的 buffer，值可以是 Buffer、TypedArray 或 DataView
offset: 是一個代表在 buffer 中開始填入的位置的 integer 整數
長度: 是一個 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 寫入檔案。

buffer: buffer 值可以是 Buffer、TypedArray 或 DataView。
offset: 是一個 integer 整數，代表從 buffer 內開始寫入資料的起始位置
長度: 是一個 integer 整數，代表要從 buffer 寫入的位元組數，預設值為 Buffer.byteLength 的偏移量
position: 從檔案開頭開始計算的偏移量，buffer 中的資料應該從該處寫入，可以是 integer 整數或 null，預設為 null。如果 position 不是 number，則資料將會寫入到目前的位置。有關詳細資料，請參閱 POSIX pwrite(2) 文件。

返回一個 Promise，該 Promise 會使用包含兩個屬性的物件解析：

bytesWritten: 是一個代表已寫入位元組數的 integer 整數
buffer: 對已寫入 buffer 的引用，可以是 Buffer、TypedArray 或 DataView

在沒有等待 promise 被解析或拒絕的情況下，多次在同一個檔案上使用 filehandle.write() 是不安全的。

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

將 string 字串寫入檔案。

position: 從檔案開頭開始計算的偏移量，buffer 中的資料應該從該處寫入，可以是 integer 整數或 null，預設為 null。如果 position 不是 number，則資料將會寫入到目前的位置。有關詳細資料，請參閱 POSIX pwrite(2) 文件。
encoding: 字串的預期編碼，預設值為 utf8

返回一個 Promise，該 Promise 會使用包含兩個屬性的物件解析：

bytesWritten: 是一個代表已寫入位元組數的 integer 整數
buffer: 對已寫入 buffer 的引用，可以是 Buffer、TypedArray 或 DataView

在沒有等待 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 物件描述的是 socket，則返回 true。
stats.isSymbolicLink() — 如果 fs.Stats 物件描述的是符號連結，則返回 true。
stats.dev — 包含該檔案的裝置的數字識別碼。
stats.ino — 檔案的檔案系統特定 Inode 數字。
stats.mode — 描述檔案類型和模式的位元欄位。
stats.nlink — 檔案存在的硬連結數量。
stats.uid — 擁有該檔案的使用者的數字使用者識別碼 (POSIX)。
stats.gid — 擁有該檔案的群組的數字群組識別碼 (POSIX)。
stats.rdev — 如果該檔案代表一個裝置，則為數字裝置識別碼。
stats.size — 檔案的大小，以位元組為單位。
stats.blksize — 用於 i/o 操作的檔案系統區塊大小。
stats.blocks — 為此檔案配置的區塊數量。
stats.atimeMs — 指示上次存取此檔案的時間戳記，以自 POSIX Epoch 以來的毫秒數表示。
stats.mtimeMs — 指示上次修改此檔案的時間戳記，以自 POSIX Epoch 以來的毫秒數表示。
stats.ctimeMs — 指示上次變更此檔案的時間戳記，以自 POSIX Epoch 以來的毫秒數表示。
stats.birthtimeMs — 指示此檔案的建立時間的時間戳記，以自 POSIX Epoch 以來的毫秒數表示。
stats.atime — 指示上次存取此檔案的時間戳記。
stats.mtime — 指示上次修改此檔案的時間戳記。
stats.ctime — 指示上次變更此檔案的時間戳記。
stats.birthtime — 指示此檔案的建立時間的時間戳記。

檔案存取常數

access() 方法可以接受以下旗標。這些旗標由 fs.constants 匯出。

F_OK — 指示呼叫進程可見該檔案，如果未指定模式，則預設使用
R_OK — 指示呼叫進程可以讀取該檔案
W_OK — 指示呼叫進程可以寫入該檔案
X_OK — 指示呼叫進程可以執行該檔案

檔案系統旗標

flag 選項可以接受以下值：

a — 開啟檔案以進行附加。如果檔案不存在，則會建立該檔案
ax — 與 a 相同，但如果檔案已存在則會失敗
a+ — 開啟檔案以進行讀取和附加。如果檔案不存在，則會建立該檔案
ax+ — 與 a+ 相同，但如果檔案已存在則會失敗
as — 以同步模式開啟檔案以進行附加。如果檔案不存在，則會建立該檔案
as+ — 以同步模式開啟檔案以進行讀取和附加。如果檔案不存在，則會建立該檔案
r — 開啟檔案以進行讀取。如果檔案不存在，則會發生例外情況
r+ — 開啟檔案以進行讀取和寫入。如果檔案不存在，則會發生例外情況
rs+ — 以同步模式開啟檔案以進行讀取和寫入。指示作業系統繞過本機檔案系統快取
w — 開啟檔案以進行寫入。如果檔案不存在，則會建立該檔案。如果檔案存在，則會被取代
wx — 與 w 相同，但如果檔案已存在則會失敗
w+ — 開啟檔案以進行讀取和寫入。如果檔案不存在，則會建立該檔案。如果檔案存在，則會被取代
wx+ — 與 w+ 相同，但如果檔案已存在則會失敗

查詢字串

querystring.decode()

querystring.encode()

querystring.escape()

querystring.parse()

querystring.stringify()

querystring.unescape()

Query String 模組提供對 URL 查詢字串進行剖析和格式化的支援 (0.4.3)。Query String 模組物件由 require('querystring') 返回。

querystring.decode()

是 querystring.parse() 的別名。

querystring.encode()

是 querystring.stringify() 的別名。

querystring.escape(string)

執行給定 string 的 URL 編碼，並返回經過轉義的查詢字串。此方法由 querystring.stringify() 使用，不應直接使用。

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

剖析查詢字串 URL 並返回物件。

separator 參數是用於分隔查詢字串中的鍵值對的子字串，預設值為「&」。

equal 參數是用於分隔查詢字串中鍵和值的子字串，預設值為「=」。

預期 options 參數是一個具有以下鍵的物件：

decodeURIComponent 函式: 用於解碼查詢字串中百分比編碼字元的函式，預設值為 querystring.unescape()
maxKeys 數字: 要解析的最大鍵數量，預設值為 1000。值為 0 時會移除鍵計數的限制。

預設情況下，查詢字串中的百分比編碼字元會假設使用 UTF-8 編碼，無效的 UTF-8 序列會被替換為 U+FFFD 替換字元。

例如，對於以下查詢字串

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

輸出會是

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

querystring.stringify(物件[, 分隔符號[, 等於符號[, 選項]]])

序列化一個物件並返回 URL 查詢字串。

separator 參數是用於分隔查詢字串中的鍵值對的子字串，預設值為「&」。

equal 參數是用於分隔查詢字串中鍵和值的子字串，預設值為「=」。

預期 options 參數是一個具有以下鍵的物件：

encodeURIComponent 函式: 當在查詢字串中將 URL 不安全字元轉換為百分比編碼時所使用的函式，預設值為 querystring.escape()。

預設情況下，查詢字串中需要百分比編碼的字元會被編碼為 UTF-8。如果需要其他編碼，則應指定 encodeURIComponent 選項。

例如，對於以下指令

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

查詢字串將會是

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

querystring.unescape(字串)

執行 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(字串 | 緩衝區)

解析 XML 文件的字串或緩衝區，返回一個代表已解析 XML 文件的 XMLDoc 包裝物件。

c14n(根節點[, 排除節點])

根據 Canonical XML Version 1.1 標準化 root_node 及其子節點。root_node 可以是 XMLNode 或圍繞 XML 結構的 XMLDoc 包裝物件。返回包含標準化輸出的 Buffer 物件。

excluding_node: 允許從輸出中省略文件的一部分

exclusiveC14n(根節點[, 排除節點[, 帶註解 [,前綴清單]]])

根據 Exclusive XML Canonicalization Version 1.0 標準化 root_node 及其子節點。

root_node: 是圍繞 XML 結構的 XMLNode 或 XMLDoc 包裝物件
excluding_node: 允許從輸出中省略與節點及其子節點對應的文件部分
withComments: 一個布林值，預設為 false。如果為 true，則標準化對應於 Exclusive XML Canonicalization Version 1.0。返回包含標準化輸出的 Buffer 物件。
prefix_list: 一個可選的字串，包含以空格分隔的命名空間前綴，這些命名空間也應包含在輸出中

serialize()

與 xml.c14n() 相同（自 0.7.11 起）。

serializeToString()

與 xml.c14n() 相同，但它以 string 形式返回結果（自 0.7.11 起）。

XMLDoc

圍繞 XML 結構的 XMLDoc 包裝物件，即文件的根節點。

doc.$root: 文件的根節點名稱或未定義
doc.abc: 第一個名為 abc 的根標籤，作為 XMLNode 包裝物件

XMLNode

圍繞 XML 標籤節點的 XMLNode 包裝物件。

node.abc: 與 node.$tag$abc 相同
node.$attr$abc: 節點 abc 的屬性值，自 0.7.11 起可寫入
node.$attr$abc=xyz: 與 node.setAttribute('abc', xyz) 相同（自 0.7.11 起）
node.$attrs: 節點所有屬性的 XMLAttr 包裝物件
node.$name: 節點的名稱
node.$ns: 節點的命名空間
node.$parent: 目前節點的父節點
node.$tag$abc: 節點第一個名為 abc 的子標籤，自 0.7.11 起可寫入
node.$tags: 所有子標籤的陣列
node.$tags = [node1, node2, ...]: 與 node.removeChildren(); node.addChild(node1); node.addChild(node2) 相同（自 0.7.11 起）。
node.$tags$abc: 節點所有名為 abc 的子標籤，自 0.7.11 起可寫入
node.$text: 節點的內容，自 0.7.11 起可寫入
node.$text = 'abc': 與 node.setText('abc') 相同（自 0.7.11 起）
node.addChild(nd): 將 XMLNode 作為子節點添加到節點（自 0.7.11 起）。nd 在添加到節點之前會被遞迴複製
node.removeAllAttributes(): 移除節點的所有屬性（自 0.7.11 起）
node.removeAttribute(屬性名稱): 移除名為 attr_name 的屬性（自 0.7.11 起）
node.removeChildren(標籤名稱): 移除所有名為 tag_name 的子標籤（自 0.7.11 起）。如果沒有 tag_name，則會移除所有子標籤
node.removeText(): 移除節點的文字值（0.7.11）
node.setAttribute(屬性名稱, 值): 設定 attr_name 的值（自 0.7.11 起）。當值為 null 時，將刪除名為 attr_name 的屬性
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」演算法壓縮資料，且不附加 zlib 標頭。buffer 值可以是 Buffer、TypedArray 或 DataView。Options 是一個可選物件，包含 zlib_options。返回包含壓縮資料的 Buffer 實例。
deflateSync(字串 | 緩衝區[, 選項]): 使用以字串或 Buffer 形式提供的「deflate」演算法壓縮資料。Buffer 值可以是 Buffer、TypedArray 或 DataView。Options 是一個可選物件，包含 zlib_options。返回包含壓縮資料的 Buffer 實例。
inflateRawSync(字串 | 緩衝區): 使用「deflate」演算法解壓縮原始串流。返回包含解壓縮資料的 Buffer 實例。
inflateSync(字串 | 緩衝區): 使用「deflate」演算法解壓縮串流。返回包含解壓縮資料的 Buffer 實例。

zlib 選項

chunkSize — 是一個整數，預設值為 1024
dictionary — 是一個 Buffer、TypedArray 或 DataView。預設為空
level — 是一個整數，僅限壓縮，請參閱 zlib_compression_levels
memLevel — 是一個介於 1 到 9 之間的整數，僅限壓縮
strategy — 是一個整數，僅限壓縮，請參閱 zlib_compression_strategy
windowBits — 對於原始資料是一個介於 -15 到 -9 之間的整數，對於一般串流是一個介於 9 到 15 之間的整數

zlib 壓縮級別

名稱	描述
`zlib.constants.Z_NO_COMPRESSION`	不壓縮
`zlib.constants.Z_BEST_SPEED`	最快，產生最少的壓縮
`zlib.constants.Z_DEFAULT_COMPRESSION`	速度和壓縮之間的權衡
`zlib.constants.Z_BEST_COMPRESSION`	最慢，產生最多的壓縮

zlib 壓縮策略

名稱	描述
`zlib.constants.Z_FILTERED`	篩選策略：適用於由篩選器或預測器產生的資料
`zlib.constants.Z_HUFFMAN_ONLY`	僅限霍夫曼策略：僅限霍夫曼編碼，沒有字串匹配
`zlib.constants.Z_RLE`	執行長度編碼策略：將匹配距離限制為 1，更好地壓縮 PNG 圖像資料
`zlib.constants.Z_FIXED`	固定表格策略：防止使用動態霍夫曼編碼，為特殊應用程式提供更簡單的解碼器
`zlib.constants.Z_DEFAULT_STRATEGY`	預設策略，適用於一般用途壓縮