njs provides objects, methods and properties for extending nginx functionality.
This reference contains only njs specific properties, methods and modules not compliant with ECMAScript. Definitions of njs properties and methods compliant with ECMAScript can be found in ECMAScript specification. List of all njs properties and methods can be found in Compatibility.
The HTTP request object is available only in the ngx_http_js_module module. Before 0.8.5, all string properties of the object were byte strings.
r.args{}The query string is returned as an object. Since 0.7.6, duplicate keys are returned as an array, keys are case-sensitive, both keys and values are percent-decoded.
For example, the query string
'a=1&b=%32&A=3&b=4&B=two%20words'
is converted to r.args as:
{a: "1", b: ["2", "4"], A: "3", B: "two words"}
More advanced parsing scenarios can be achieved with the Query String module and with the $args variable, for example:
import qs from 'querystring';
function args(r) {
return qs.parse(r.variables.args);
}
The argument object is evaluated at the first access to r.args. If only a single argument is needed, for example foo, nginx variables can be used:
r.variables.arg_foo
Here, nginx variables object returns the first value for a given key, case-insensitive, without percent-decoding.
To convert r.args back to a string, the Query String stringify method can be used.
r.done()r.error(string)string to the error log on the error level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
r.finish()r.headersIn{} The Foo request header can be accessed with the syntax: headersIn.foo or headersIn['Foo'].
The “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”, and “User-Agent” request headers can have only one field value (0.4.1). Duplicate field values in “Cookie” headers are separated by semicolon (;). Duplicate field values in all other request headers are separated by commas.
r.headersOut{} If r.headersOut{} is the response object of a subrequest, it represents response headers. In this case, field values in “Accept-Ranges”, “Connection”, “Content-Disposition”, “Content-Encoding”, “Content-Length”, “Content-Range”, “Date”, “Keep-Alive”, “Server”, “Transfer-Encoding”, “X-Accel-*” response headers may be omitted.
The “Foo” response header can be accessed with the syntax: headersOut.foo or headersOut['Foo'].
Outgoing headers should be set before a response header is sent to a client, otherwise header update will be ignored. This means that r.headersOut{} is effectively writable in:
r.sendHeader() or r.return() are called Field values of multi-value response headers (0.4.0) can be set with the syntax:
r.headersOut['Foo'] = ['a', 'b']
where the output will be:
Foo: a Foo: b
All previous field values of the “Foo” response header will be deleted.
For standard response headers that accept only a single field value such as “Content-Type”, only the last element of the array will take effect. Field values of the “Set-Cookie” response header are always returned as an array. Duplicate field values in “Age”, “Content-Encoding”, “Content-Length”, “Content-Type”, “ETag”, “Expires”, “Last-Modified”, “Location”, “Retry-After” response headers are ignored. Duplicate field values in all other response headers are separated by commas.
r.httpVersionr.internalr.internalRedirect(uri)uri. If the uri starts with the “@” prefix, it is considered a named location. In a new location, all request processing is repeated starting from NGX_HTTP_SERVER_REWRITE_PHASE for ordinary locations and from NGX_HTTP_REWRITE_PHASE for named locations. As a result, a redirect to a named location does not check client_max_body_size limit. See dev guide for more details. Redirected requests become internal and can access the internal locations. The actual redirect happens after the handler execution is completed. After redirect, a new njs VM is started in the target location, the VM in the original location is stopped. Values of nginx variables are kept and can be used to pass information to the target location. Since 0.5.3, the variable declared with the js_var directive for http or stream can be used.
Since 0.7.4, the method accepts escaped URIs.
r.log(string)string to the error log on the info level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
r.methodr.parentr.remoteAddressr.requestBodyr.requestBuffer or r.requestText property should be used instead. r.requestBufferr.requestTextr.requestBuffer, but returns a string. Note that it may convert bytes invalid in UTF-8 encoding into the replacement character. r.rawHeadersIn[]For example, with the following request headers:
Host: localhost Foo: bar foo: bar2
the output of r.rawHeadersIn will be:
[
['Host', 'localhost'],
['Foo', 'bar'],
['foo', 'bar2']
]
All foo headers can be collected with the syntax:
r.rawHeadersIn.filter(v=>v[0].toLowerCase() == 'foo').map(v=>v[1])
the output will be:
['bar', 'bar2']
Header field names are not converted to lower case, duplicate field values are not merged.
r.rawHeadersOut[]r.responseBodyr.responseBuffer or the r.responseText property should be used instead. r.responseBufferr.responseBuffer is limited by the subrequest_output_buffer_size directive. r.responseTextr.responseBuffer but returns a string (since 0.5.0). Note that it may convert bytes invalid in UTF-8 encoding into the replacement character. r.return(status[,
string | Buffer])status to the client. The response can be a string or Buffer (0.5.0). It is possible to specify either a redirect URL (for codes 301, 302, 303, 307, and 308) or the response body text (for other codes) as the second argument
r.send(string
| Buffer)r.sendBuffer(data[,
options]) The data can be a string or Buffer. The options is an object used to override nginx buffer flags derived from an incoming data chunk buffer. The flags can be overridden with the following flags:
lastflushflush flag r.sendHeader()r.setReturnValue(value)
async function js_set(r) {
const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host);
r.setReturnValue(digest);
}
r.statusr.subrequest(uri[,
options[, callback]])uri and options, and installs an optional completion callback. A subrequest shares its input headers with the client request. To send headers different from original headers to a proxied server, the proxy_set_header directive can be used. To send a completely new set of headers to a proxied server, the proxy_pass_request_headers directive can be used.
If options is a string, then it holds the subrequest arguments string. Otherwise, options is expected to be an object with the following keys:
argsbodymethodGET method is used detachedtrue, the created subrequest is a detached subrequest. Responses to detached subrequests are ignored. Unlike ordinary subrequests, a detached subrequest can be created inside a variable handler. The detached flag and callback argument are mutually exclusive. The completion callback receives a subrequest response object with methods and properties identical to the parent request object.
Since 0.3.8, if a callback is not provided, the Promise object that resolves to the subrequest response object is returned.
For example, to view all response headers in the 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.urir.rawVariables{}r.variables{} For example, to get the $foo variable, one of the following syntax can be used:
r.variables['foo'] r.variables.foo
Since 0.8.6, regular expression captures can be accessed using the following syntax:
r.variables['1'] r.variables[1]
nginx treats variables referenced in nginx.conf and unreferenced variables differently. When a variable is referenced, it may be cacheable, but when it is unreferenced it is always uncacheable. For example, when the $request_id variable is only accessed from njs, it has a new value every time it is evaluated. But, when the $request_id is referenced, for example:
proxy_set_header X-Request-Id $request_id;
the r.variables.request_id returns the same value every time.
A variable is writable if:
js_var directive for http or stream (since 0.5.3) Even so, some embedded variables still cannot be assigned a value (for example, $http_).
r.warn(string)string to the error log on the warning level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
The stream session object is available only in the ngx_stream_js_module module. Before 0.8.5, all string properties of the object were byte strings.
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 for the current phase handler to a code value, by default 0. The actual finalization happens when the js handler is completed and all pending events, for example, from ngx.fetch() or setTimeout(), are processed (0.2.4). Possible code values:
0 — successful finalization, passing control to the next phase -5 — undecided, passing control to the next handler of the current phase (if any) 403 — access is forbidden js_access or js_preread. s.error(string)string to the error log on the error level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
s.log(string)string to the error log on the info level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
s.off(eventName)s.on(event,
callback)callback for the specified event (0.2.4). An event may be one of the following strings:
uploaddownloadupstreamdownstream The completion callback has the following prototype: callback(data, flags), where data is string or Buffer (depending on the event type) flags is an object with the following properties:
lasts.remoteAddresss.rawVariabless.send(data[,
options]) The data can be a string or Buffer (0.5.0). The options is an object used to override nginx buffer flags derived from an incoming data chunk buffer. The flags can be overridden with the following flags:
lastflushflush flag s.sendDownstream()s.sendUpstream()s.status$status variable, read only (since 0.5.2) s.setReturnValue(value)
async function js_set(r) {
const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host);
r.setReturnValue(digest);
}
s.variables{}s.warn(string)string to the error log on the warning level of logging As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
PeriodicSession.rawVariables{} |
PeriodicSession.variables{} |
The Periodic Session object is provided as the first argument for the js_periodic handler for http and stream (since 0.8.1).
PeriodicSession.rawVariables{}PeriodicSession.variables{}Headers() |
Headers.append() |
Headers.delete() |
Headers.get() |
Headers.getAll() |
Headers.forEach() |
Headers.has() |
Headers.set() |
The Headers interface of the Fetch API is available since 0.5.1.
A new Headers object can be created using the Headers() constructor: (since 0.7.10):
Headers([init])initHeaders object, can be a string, an array of name-value pairs, or an existing Headers object. A new Headers object can be created with the following properties and methods:
append()Headers object, or adds the header if it does not already exist (since 0.7.10). delete()Headers object (since 0.7.10). get()getAll(name)forEach()Headers object (since 0.7.10). has()set()Headers object, or adds the header if it does not already exist (since 0.7.10). Request() |
Request.arrayBuffer() |
Request.bodyUsed |
Request.cache |
Request.credentials |
Request.headers |
Request.json() |
Request.method |
Request.mode |
Request.text() |
Request.url |
The Request interface of the Fetch API is available since 0.7.10.
A new Request object can be created using the Request() constructor:
Request[resource[,
options]])Request object to fetch that can be passed later to ngx.fetch(). The resource can be a URL or an existing Request object. The options is an optional argument that is expected to be an object with the following keys: A new Request object can be created with the following properties and methods:
arrayBuffer()Promise that resolves with an ArrayBuffer. bodyUsedtrue if the body was used in the request. cachecredentialssame-origin. headersHeaders read-only object associated with the Request. json()Promise that resolves with the result of parsing the request body as JSON. methodmodetext()Promise that resolves with a string representation of the request body. urlResponse() |
Response.arrayBuffer() |
Response.bodyUsed |
Response.headers |
Response.json() |
Response.ok |
Response.redirected |
Response.status |
Response.statusText |
Response.text() |
Response.type |
Response.url |
The Response interface is available since 0.5.1.
A new Response object can be created using the Response() constructor (since 0.7.10):
Response[body[,
options]])Response object. The body is an optional argument, can be a string or a buffer, by default is null. The options is an optional argument that is expected to be an object with the following keys: A new Response() object can be created with the following properties and methods:
arrayBuffer()Response stream and reads it to completion. Returns a Promise that resolves with an ArrayBuffer. bodyUsedtrue if the body was read. headersHeaders read-only object associated with the Response. json()Response stream and reads it to completion. Returns a Promise that resolves with the result of parsing the body text as JSON. oktrue if the response was successful (status codes between 200–299). redirectedtrue if the response is the result of a redirect. statusstatusTexttext()Response stream and reads it to completion. Returns a Promise that resolves with a string. typeurlngx.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 |
The ngx global object is available since 0.5.0.
ngx.build--build=name argument of the configure script, by default is "" (0.8.0) ngx.conf_file_pathngx.conf_prefixngx.error_log_pathngx.fetch(resource,
[options]) Makes a request to fetch a resource (0.5.1), which can be an URL or the Request object (0.7.10). Returns a Promise that resolves with the Response object. Since 0.7.0, the https:// scheme is supported, redirects are not handled.
If the URL in the resource is specified as a domain name, it is determined using a resolver. If the https:// scheme is specified, the js_fetch_trusted_certificate directive should be configured for the authentication of the resource's HTTPS server.
The options parameter is expected to be an object with the following keys:
bodybuffer_size4096 headersmax_response_body_size32768 methodGET method is used verifytrue (0.7.0) Example:
let reply = await ngx.fetch('http://nginx.org/');
let body = await reply.text();
r.return(200, body);
ngx.log(level, message)level parameter specifies one of the log levels, the message parameter can be a string or Buffer. The following log levels can be specified: ngx.INFO, ngx.WARN, and ngx.ERR. As nginx has a hardcoded maximum line length limit, only first 2048 bytes of the string can be logged.
ngx.prefixngx.version1.25.0 (0.8.0) ngx.version_number1025000 (0.8.0) ngx.worker_id0 and the value specified in the worker_processes directive (0.8.0) The ngx.shared global object is available since 0.8.0.
The shared dictionary object is available since 0.8.0. The shared dictionary name, type, and size are set with the js_shared_dict_zone directive in http or stream.
A SharedDict() object has the following properties and methods:
ngx.shared.SharedDict.add(key,
value [,timeout])value for the specified key in the dictionary only if the key does not exist yet. The key is a string representing the key of the item to add, the value is the value of the item to add. The optional timeout argument is specified in milliseconds and overrides the timeout parameter of the js_shared_dict_zone directive in http or stream (since 0.8.5). It can be useful when some keys are expected to have unique timeouts.
Returns true if the value has been successfully added to the SharedDict dictionary, false if the key already exists in the dictionary. Throws SharedMemoryError if there is not enough free space in the SharedDict dictionary. Throws TypeError if the value is of a different type than expected by this dictionary.
ngx.shared.SharedDict.capacitySharedDict dictionary, corresponds to the size parameter of js_shared_dict_zone directive in http or stream. ngx.shared.SharedDict.clear()SharedDict dictionary. ngx.shared.SharedDict.delete(key)SharedDict dictionary, true if the item in the dictionary existed and was removed, false otherwise. ngx.shared.SharedDict.freeSpace()SharedDict dictionary will still accept new values if there is space in the occupied pages. ngx.shared.SharedDict.get(key)key, returns the value associated with the key or undefined if there is none. ngx.shared.SharedDict.has(key)key, returns true if such item exists or false otherwise. ngx.shared.SharedDict.incr(key,delta[[,init], timeout]))key by delta. The key is a string, the delta is the number to increment or decrement the value by. If the key does not exist, the item will be initialized to an optional init argument, by default is 0. The optional timeout argument is specified in milliseconds and overrides the timeout parameter of the js_shared_dict_zone directive in http or stream (since 0.8.5). It can be useful when some keys are expected to have unique timeouts.
Returns the new value. Throws SharedMemoryError if there is not enough free space in the SharedDict dictionary. Throws TypeError if this dictionary does not expect numbers.
This method can be used only if the dictionary type was declared withtype=numberparameter of thejs_shared_dict_zonedirective in http or stream.
ngx.shared.SharedDict.items([maxCount])SharedDict dictionary key-value items (since 0.8.1). The maxCount parameter sets maximum number of items to retrieve, by default is 1024. ngx.shared.SharedDict.keys([maxCount])SharedDict dictionary keys. The maxCount parameter sets maximum number of keys to retrieve, by default is 1024. ngx.shared.SharedDict.nameSharedDict dictionary, corresponds to the zone= parameter of js_shared_dict_zone directive in http or stream. ngx.shared.SharedDict.pop(key)key from the SharedDict dictionary, returns the value associated with the key or undefined if there is none. ngx.shared.SharedDict.replace(key,
value)value for the specified key only if the key already exists, returns true if the value was successfully replaced, false if the key does not exist in the SharedDict dictionary. Throws SharedMemoryError if there is not enough free space in the SharedDict dictionary. Throws TypeError if the value is of a different type than expected by this dictionary. ngx.shared.SharedDict.set(key,
value [,timeout])value for the specified key, returns this SharedDict dictionary (for method chaining). The optional timeout argument is specified in milliseconds and overrides the timeout parameter of the js_shared_dict_zone directive in http or stream (since 0.8.5). It can be useful when some keys are expected to have unique timeouts.
ngx.shared.SharedDict.size()SharedDict dictionary. ngx.shared.SharedDict.typestring or number that corresponds to the SharedDict dictionary type set by the type= parameter of js_shared_dict_zone directive in http or stream. console.error() |
console.info() |
console.log() |
console.time() |
console.timeEnd() |
console.warn() |
The console object is available in nginx since 0.8.2, in CLI since 0.2.6.
console.error(msg[, msg2 ...])console.info(msg[, msg2 ...])console.log(msg[, msg2 ...])console.time(label)label parameter allows naming different timers. If console.timeEnd() with the same name is called, the time that elapsed since the timer was started will be output, in milliseconds. console.timeEnd(label)console.time() The label parameter allows naming different timers. console.warn(msg[, msg2 ...]) The crypto object is a global object that allows using cryptographic functionality (since 0.7.0).
сrypto.getRandomValues(typedArray)typedArray but with its contents replaced with the newly generated random numbers. Possible values: typedArrayInt8Array, Int16Array, Uint16Array, Int32Array, or Uint32Array сrypto.subtle.encrypt(algorithm, key, data)data using the provided algorithm and key. Returns a Promise that fulfills with an ArrayBuffer containing the ciphertext. Possible values: algorithmRSA-OAEP, pass the object with the following keys: name is a string, should be set to RSA-OAEP:
crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)
AES-CTR, pass the object with the following keys: name is a string, should be set to AES-CTR counter is an ArrayBuffer, TypedArray, or DataView — the initial value of the counter block, must be 16 bytes long (the AES block size). The rightmost length bits of this block are used for the counter, and the rest is used for the nonce. For example, if length is set to 64, then the first half of counter is the nonce and the second half is used for the counter length is the number of bits in the counter block that are used for the actual counter. The counter must be big enough that it doesn't wrap. AES-CBC, pass the object with the following keys: name is a string, should be set to AES-CBC iv or the initialization vector, is an ArrayBuffer, TypedArray, or DataView, must be 16 bytes, unpredictable, and preferably cryptographically random. However, it need not be secret, for example, it may be transmitted unencrypted along with the ciphertext. AES-GCM, pass the object with the following keys: name is a string, should be set to AES-GCM iv or the initialization vector, is an ArrayBuffer, TypedArray, or DataView, must be 16 bytes, and must be unique for every encryption operation carried out with a given key additionalData (optional) is an ArrayBuffer, TypedArray, or DataView that contains additional data that will not be encrypted but will be authenticated along with the encrypted data. If additionalData is specified, then the same data must be specified in the corresponding call to decrypt(): if the data given to the decrypt() call does not match the original data, the decryption will throw an exception. The bit length of additionalData must be smaller than 2^64 - 1. tagLength (optional, default is 128) - a number that determines the size in bits of the authentication tag generated in the encryption operation and used for authentication in the corresponding decryption Possible values: 32, 64, 96, 104, 112, 120, or 128. The AES-GCM specification recommends that it should be 96, 104, 112, 120, or 128, although 32 or 64 bits may be acceptable in some applications. keyCryptoKey that contains the key to be used for encryption dataArrayBuffer, TypedArray, or DataView that contains the data to be encrypted (also known as the plaintext) сrypto.subtle.decrypt(algorithm, key, data)Promise with the decrypted data. Possible values: algorithmencrypt() call. RSA-OAEP, pass the object with the following keys: name is a string, should be set to RSA-OAEP:
crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data)
AES-CTR, pass the object with the following keys: name is a string, should be set to AES-CTR counter is an ArrayBuffer, TypedArray, or DataView — the initial value of the counter block, must be 16 bytes long (the AES block size). The rightmost length bits of this block are used for the counter, and the rest is used for the nonce. For example, if length is set to 64, then the first half of counter is the nonce and the second half is used for the counter. length is the number of bits in the counter block that are used for the actual counter. The counter must be big enough that it doesn't wrap. AES-CBC, pass the object with the following keys: name is a string, should be set to AES-CBC iv or the initialization vector, is an ArrayBuffer, TypedArray, or DataView, must be 16 bytes, unpredictable, and preferably cryptographically random. However, it need not be secret (for example, it may be transmitted unencrypted along with the ciphertext). AES-GCM, pass the object with the following keys: name is a string, should be set to AES-GCM iv or the initialization vector, is an ArrayBuffer, TypedArray, or DataView, must be 16 bytes, and must be unique for every encryption operation carried out with a given key additionalData (optional) is an ArrayBuffer, TypedArray, or DataView that contains additional data that will not be encrypted but will be authenticated along with the encrypted data. If additionalData is specified, then the same data must be specified in the corresponding call to decrypt(): if the data given to the decrypt() call does not match the original data, the decryption will throw an exception. The bit length of additionalData must be smaller than 2^64 - 1. tagLength (optional, default is 128) - a number that determines the size in bits of the authentication tag generated in the encryption operation and used for authentication in the corresponding decryption. Possible values: 32, 64, 96, 104, 112, 120, or 128. The AES-GCM specification recommends that it should be 96, 104, 112, 120, or 128, although 32 or 64 bits may be acceptable in some applications. keyCryptoKey that contains the key to be used for decryption. If RSA-OAEP is used, this is the privateKey property of the CryptoKeyPair object. dataArrayBuffer, TypedArray, or DataView that contains the data to be decrypted (also known as ciphertext) сrypto.subtle.deriveBits(algorithm, baseKey, length)Promise which will be fulfilled with an ArrayBuffer that contains the derived bits. Possible values: algorithmHKDF, pass the object with the following keys: name is a string, should be set to HKDF hash is a string with the digest algorithm to use: SHA-1, SHA-256, SHA-384, or SHA-512 salt is an ArrayBuffer, TypedArray, or DataView that represents random or pseudo-random value with the same length as the output of the digest function. Unlike the input key material passed into deriveKey(), salt does not need to be kept secret. info is an ArrayBuffer, TypedArray, or DataView that represents application-specific contextual information used to bind the derived key to an application or context, and enables deriving different keys for different contexts while using the same input key material. This property is required but may be an empty buffer. PBKDF2, pass the object with the following keys: name is a string, should be set to PBKDF2 hash is a string with the digest algorithm to use: SHA-1, SHA-256, SHA-384, or SHA-512 salt is an ArrayBuffer, TypedArray, or DataView that represents random or pseudo-random value of at least 16 bytes. Unlike the input key material passed into deriveKey(), salt does not need to be kept secret. iterations is a number that represents the number of times the hash function will be executed in deriveKey() ECDH, pass the object with the following keys (since 0.9.1): name is a string, should be set to ECDH public is a CryptoKey that represents the public key of the other party. The key must be generated using the same curve as the base key. baseKeyCryptoKey that represents the input to the derivation algorithm - the initial key material for the derivation function: for example, for PBKDF2 it might be a password, imported as a CryptoKey using сrypto.subtle.importKey() length8 сrypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)algorithmHKDF, pass the object with the following keys: name is a string, should be set to HKDF hash is a string with the digest algorithm to use: SHA-1, SHA-256, SHA-384, or SHA-512 salt is an ArrayBuffer, TypedArray, or DataView that represents random or pseudo-random value with the same length as the output of the digest function. Unlike the input key material passed into deriveKey(), salt does not need to be kept secret. info is an ArrayBuffer, TypedArray, or DataView that represents application-specific contextual information used to bind the derived key to an application or context, and enables deriving different keys for different contexts while using the same input key material. This property is required but may be an empty buffer. PBKDF2, pass the object with the following keys: name is a string, should be set to PBKDF2 hash is a string with the digest algorithm to use: SHA-1, SHA-256, SHA-384, or SHA-512 salt is an ArrayBuffer, TypedArray, or DataView that represents random or pseudo-random value of at least 16 bytes. Unlike the input key material passed into deriveKey(), salt does not need to be kept secret. iterations is a number that represents the number of times the hash function will be executed in deriveKey() ECDH, pass the object with the following keys (since 0.9.1): name is a string, should be set to ECDH publicKey is a CryptoKey that represents the public key of the other party. The key must be generated using the same curve as the base key. baseKeyCryptoKey that represents the input to the derivation algorithm - the initial key material for the derivation function: for example, for PBKDF2 it might be a password, imported as a CryptoKey using сrypto.subtle.importKey(). derivedKeyAlgorithmHMAC, pass the object with the following keys: name is a string, should be set to HMAC hash is a string with the name of the digest function to use: SHA-1, SHA-256, SHA-384, or SHA-512 length (optional) is a number that represents the length in bits of the key. If not specified, the length of the key is equal to the block size of the chozen hash function AES-CTR, AES-CBC, or AES-GCM, pass the object with the following keys: name is a string, should be set to AES-CTR, AES-CBC, or AES-GCM, depending on the algorithm used length is a number that represents the length in bits of the key to generate: 128, 192, or 256 extractablekeyUsagesArray that indicates what can be done with the derived key. The key usages must be allowed by the algorithm set in derivedKeyAlgorithm. Possible values: encryptdecryptsignverifyderiveKeyderiveBitswrapKeyunwrapKeyсrypto.subtle.digest(algorithm, data)Promise which will be fulfilled with the digest. Possible values: algorithmSHA-1 (not for cryptographic applications), SHA-256, SHA-384, or SHA-512 dataArrayBuffer, TypedArray, or DataView that contains the data to be digested сrypto.subtle.exportKey(format, key)CryptoKey object and returns the key in an external, portable format (since 0.7.10). If the format was jwk, then the Promise fulfills with a JSON object containing the key. Otherwise, the promise fulfills with an ArrayBuffer containing the key. Possible values: formatrawpkcs8spkijwkkeyCryptoKey that contains the key to be exported сrypto.subtle.generateKey(algorithm, extractable, usage)Promise that fulfills with the generated key as a CryptoKey or CryptoKeyPair object. Possible values: algorithmRSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP, pass the object with the following keys: name is a string, should be set to RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP, depending on the used algorithm hash is a string that represents the name of the digest function to use, can be SHA-256, SHA-384, or SHA-512 ECDSA, pass the object with the following keys: name is a string, should be set to ECDSA namedCurve is a string that represents the name of the elliptic curve to use, may be P-256, P-384, or P-521 HMAC, pass the object with the following keys: name is a string, should be set to HMAC hash is a string that represents the name of the digest function to use, can be SHA-256, SHA-384, or SHA-512 length (optional) is a number that represents the length in bits of the key. If omitted, the length of the key is equal to the length of the digest generated by the chosen digest function. AES-CTR, AES-CBC, or AES-GCM, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" }, where ALGORITHM is the name of the algorithm ECDH, pass the object with the following keys (since 0.9.1): name is a string, should be set to ECDH namedCurve is a string that represents the name of the elliptic curve to use, may be P-256, P-384, or P-521 extractableusagearray that indicates possible actions with the key: encryptdecryptsignverifyderiveKeyderiveBitswrapKeyunwrapKeyсrypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages)CryptoKey object. Returns a Promise that fulfills with the imported key as a CryptoKey object. Possible values: formatrawpkcs8spkijwkkeyDataArrayBuffer, TypedArray, or DataView object that contains the key in the given format algorithmRSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP, pass the object with the following keys: name is a string, should be set to RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP, depending on the used algorithm hash is a string that represents the name of the digest function to use, can be SHA-1, SHA-256, SHA-384, or SHA-512 ECDSA, pass the object with the following keys: name is a string, should be set to ECDSA namedCurve is a string that represents the name of the elliptic curve to use, may be P-256, P-384, or P-521 HMAC, pass the object with the following keys: name is a string, should be set to HMAC hash is a string that represents the name of the digest function to use, can be SHA-256, SHA-384, or SHA-512 length (optional) is a number that represents the length in bits of the key. If omitted, the length of the key is equal to the length of the digest generated by the chosen digest function. AES-CTR, AES-CBC, or AES-GCM, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" }, where ALGORITHM is the name of the algorithm PBKDF2, pass the PBKDF2 string HKDF, pass the HKDF string ECDH, pass the object with the following keys (since 0.9.1): name is a string, should be set to ECDH namedCurve is a string that represents the name of the elliptic curve to use, may be P-256, P-384, or P-521 extractablekeyUsagesarray that indicates possible actions with the key: encryptdecryptsignverifyderiveKeyderiveBitswrapKeyunwrapKeyсrypto.subtle.sign(algorithm, key, data)signature as a Promise that fulfills with an ArrayBuffer containing the signature. Possible values: algorithmRSASSA-PKCS1-v1_5, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" } RSA-PSS, pass the object with the following keys: name is a string, should be set to RSA-PSS saltLength is a long integer that represents the length of the random salt to use, in bytes ECDSA, pass the object with the following keys: name is a string, should be set to ECDSA hash is an identifier for the digest algorithm to use, can be SHA-256, SHA-384, or SHA-512 HMAC, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" } keyCryptoKey object that the key to be used for signing. If algorithm identifies a public-key cryptosystem, this is the private key. dataArrayBuffer, TypedArray, or DataView object that contains the data to be signed сrypto.subtle.verify(algorithm, key, signature, data)Promise that fulfills with a boolean value: true if the signature is valid, otherwise false. Possible values: algorithmRSASSA-PKCS1-v1_5, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" } RSA-PSS, pass the object with the following keys: name is a string, should be set to RSA-PSS saltLength is a long integer that represents the length of the random salt to use, in bytes ECDSA, pass the object with the following keys: name is a string, should be set to ECDSA hash is an identifier for the digest algorithm to use, can be SHA-256, SHA-384, or SHA-512 HMAC, pass the string identifying the algorithm or an object of the form { "name": "ALGORITHM" } keyCryptoKey object that the key to be used for verifying. It is the secret key for a symmetric algorithm and the public key for a public-key system. signatureArrayBuffer, TypedArray, or DataView that contains the signature to verify dataArrayBuffer, TypedArray, or DataView object that contains the data whose signature is to be verified CryptoKey.algorithm |
CryptoKey.extractable |
CryptoKey.type |
CryptoKey.usages |
The CryptoKey object represents a cryptographic key obtained from one of the SubtleCrypto methods: сrypto.subtle.generateKey(), сrypto.subtle.deriveKey(), сrypto.subtle.importKey().
CryptoKey.algorithmCryptoKey.extractabletrue if the key can be exported (since 0.8.0), read-only CryptoKey.typesecretprivateCryptoKeyPair publicCryptoKeyPair. CryptoKey.usagesencryptdecryptsignverifyderiveKeyderiveBitsCryptoKeyPair.privateKey |
CryptoKeyPair.publicKey |
The CryptoKeyPair is a dictionary object of the WebCrypto API that represents an asymmetric key pair.
CryptoKeyPair.privateKeyCryptoKey object representing the private key. CryptoKeyPair.publicKeyCryptoKey object representing the public key. njs.version |
njs.version_number |
njs.dump() |
njs.memoryStats |
njs.on() |
The njs object is a global object that represents the current VM instance (since 0.2.0).
njs.versionnjs.version_number0x000704 (since 0.7.4). njs.dump(value)njs.memoryStatssizenjs.on(event,
callback)exitprocess.argv |
process.env |
process.kill() |
process.pid |
process.ppid |
The process object is a global object that provides information about the current process (0.3.3).
process.argvprocess.envBy default, nginx removes all environment variables inherited from its parent process except the TZ variable. Use the env directive to preserve some of the inherited variables.
process.kill(pid,
number | string)pid. Signal names are numbers or strings such as 'SIGINT' or 'SIGHUP'. See kill(2) for more information. process.pidprocess.ppidBy default all strings in njs are Unicode strings. They correspond to ECMAScript strings that contain Unicode characters. Before 0.8.0, byte strings were also supported.
Since 0.8.0, the support for byte strings and byte string methods were removed. When working with byte sequence, the Buffer object andBufferproperties, such asr.requestBuffer,r.rawVariables, should be used.
Byte strings contain a sequence of bytes and are used to serialize Unicode strings to external data and deserialize from external sources. For example, the toUTF8() method serializes a Unicode string to a byte string using UTF-8 encoding:
>> '£'.toUTF8().toString('hex')
'c2a3' /* C2 A3 is the UTF-8 representation of 00A3 ('£') code point */
The toBytes() method serializes a Unicode string with code points up to 255 into a byte string, otherwise, null is returned:
>> '£'.toBytes().toString('hex')
'a3' /* a3 is a byte equal to 00A3 ('£') code point */
String.bytesFrom(array
| string, encoding)Buffer.from method should be used instead:
>> Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]).toString()
'buffer'
>> Buffer.from('YnVmZmVy', 'base64').toString()
'buffer'
Before 0.4.4, created a byte string either from an array that contained octets, or from an encoded string (0.2.3), the encoding could be hex, base64, and base64url. String.prototype.fromBytes(start[,
end])String.prototype.fromUTF8(start[,
end])TextDecoder method should be used instead. Before 0.7.7, converted a byte string containing a valid UTF-8 string into a Unicode string, otherwise null was returned. String.prototype.toBytes(start[,
end])null if a character larger than 255 was found in the string. String.prototype.toString(encoding) the property was made obsolete in 0.7.7 and was removed in 0.8.0. Before 0.7.7, encoded a string to hex, base64, or base64url:
>> 'αβγδ'.toString('base64url')
'zrHOss6zzrQ'
Before version 0.4.3, only a byte string could be encoded:
>> 'αβγδ'.toUTF8().toString('base64url')
'zrHOss6zzrQ'
String.prototype.toUTF8(start[,
end])TextEncoder method should be used instead. Before 0.7.7, serialized a Unicode string to a byte string using UTF-8 encoding: >> 'αβγδ'.toUTF8().length 8 >> 'αβγδ'.length 4
TextDecoder() |
TextDecoder.prototype.encoding |
TextDecoder.prototype.fatal |
TextDecoder.prototype.ignoreBOM |
TextDecoder.prototype.decode() |
The TextDecoder produces a stream of code points from a stream of bytes (0.4.3).
TextDecoder([[encoding],
options])TextDecoder object for specified encoding, currently, only UTF-8 is supported. The options is TextDecoderOptions dictionary with the property: fatalTextDecoder.decode() must throw the TypeError exception when a coding error is found, by default is false. TextDecoder.prototype.encodingTextDecoder(), read-only. TextDecoder.prototype.fataltrue if the error mode is fatal, read-only. TextDecoder.prototype.ignoreBOMtrue if the byte order marker is ignored, read-only. TextDecoder.prototype.decode(buffer,
[options])buffer by TextDecoder(). The buffer can be ArrayBuffer. The options is TextDecodeOptions dictionary with the property: streamdecode(): true if processing the data in chunks, and false for the final chunk or if the data is not chunked. By default is false. >> (new TextDecoder()).decode(new Uint8Array([206,177,206,178])) αβ
TextEncoder() |
TextEncoder.prototype.encode() |
TextEncoder.prototype.encodeInto() |
The TextEncoder object produces a byte stream with UTF-8 encoding from a stream of code points (0.4.3).
TextEncoder()TextEncoder that will generate a byte stream with UTF-8 encoding. TextEncoder.prototype.encode(string)string into a Uint8Array with UTF-8 encoded text. TextEncoder.prototype.encodeInto(string,
uint8Array)string to UTF-8, puts the result into destination Uint8Array, and returns a dictionary object that shows the progress of the encoding. The dictionary object contains two members: readstring converted to UTF-8 writtenUint8Array clearTimeout() |
setTimeout() |
clearTimeout(timeout)timeout object created by setTimeout(). setTimeout(function,
milliseconds[,
argument1,
argumentN])function after a specified number of milliseconds. One or more optional arguments can be passed to the specified function. Returns a timeout object.
function handler(v)
{
// ...
}
t = setTimeout(handler, 12);
// ...
clearTimeout(t);
atob() |
btoa() |
atob(encodedData)Base64 encoding. The encodedData parameter is a binary string that contains Base64-encoded data. Returns a string that contains decoded data from encodedData. The similar btoa() method can be used to encode and transmit data which may otherwise cause communication problems, then transmit it and use the atob() method to decode the data again. For example, you can encode, transmit, and decode control characters such as ASCII values 0 through 31.
const encodedData = btoa("text to encode"); // encode a string
const decodedData = atob(encodedData); // decode the string
btoa(stringToEncode)stringToEncode parameter is a binary string to encode. Returns an ASCII string containing the Base64 representation of stringToEncode. The method can be used to encode data which may otherwise cause communication problems, transmit it, then use the atob() method to decode the data again. For example, you can encode control characters such as ASCII values 0 through 31.
const encodedData = btoa("text to encode"); // encode a string
const decodedData = atob(encodedData); // decode the string
Buffer.alloc(size[,
fill[,
encoding]])) Allocates a new Buffer of a specified size. If fill is not specified, the Buffer will be zero-filled. If fill is specified, the allocated Buffer will be initialized by calling buf.fill(fill). If fill and encoding are specified, the allocated Buffer will be initialized by calling buf.fill(fill,
encoding).
The fill parameter may be a string, Buffer, Uint8Array, or integer.
Buffer.allocUnsafe(size) The same as Buffer.alloc(), with the difference that the memory allocated for the buffer is not initialized, the contents of the new buffer is unknown and may contain sensitive data.
Buffer.byteLength(value[,
encoding])encoding. The value can be a string, Buffer, TypedArray, DataView, or ArrayBuffer. If the value is a string, the encoding parameter is its encoding, can be utf8, hex, base64, base64url; by default is utf8. Buffer.compare(buffer1,
buffer2)buffer1 with buffer2 when sorting arrays of Buffer instances. Returns 0 if buffer1 is the same as buffer2, 1 if buffer2 should come before buffer1 when sorted, or -1 if buffer2 should come after buffer1 when sorted. Buffer.concat(list[,
totalLength])totalLength is not specified, it is calculated from the Buffer instances in list by adding their lengths. If totalLength is specified, it is coerced to an unsigned integer. If the combined length of the Buffers in list exceeds totalLength, the result is truncated to totalLength. Buffer.from(array)0 – 255. Array entries outside that range will be truncated. Buffer.from(arrayBuffer,
byteOffset[,
length]])ArrayBuffer without copying the underlying memory. The optional byteOffset and length arguments specify a memory range within the arrayBuffer that will be shared by the Buffer. Buffer.from(buffer)Buffer.from(object[,
offsetOrEncoding[,
length]])valueOf() function returns a value not strictly equal to object, returns Buffer.from(object.valueOf(), offsetOrEncoding, length). Buffer.from(string[,
encoding])string. The encoding parameter identifies the character encoding to be used when converting a string into bytes. The encoding can be utf8, hex, base64, base64url; by default is utf8. Buffer.isBuffer(object)true if object is a Buffer. Buffer.isEncoding(encoding)true if encoding is the name of a supported character encoding. buffer[index]index in buffer. The values refer to individual bytes, so the legal value range is between 0 and 255 (decimal). buf.bufferArrayBuffer object based on which this Buffer object is created. buf.byteOffsetbyteOffset of the Buffers underlying ArrayBuffer object. buf.compare(target[,
targetStart[,
targetEnd[,
sourceStart[,
sourceEnd]]]])target and returns a number indicating whether buffer comes before, after, or is the same as target in sort order. Comparison is based on the actual sequence of bytes in each Buffer. The targetStart is an integer specifying the offset within target at which to begin comparison, by default is 0. The targetEnd is an integer specifying the offset within target at which to end comparison, by default is target.length. The sourceStart is an integer specifying the offset within buffer at which to begin comparison, by default is 0. The sourceEnd is an integer specifying the offset within buffer at which to end comparison (not inclusive), by default is buf.length. buf.copy(target[,
targetStart[,
sourceStart[,
sourceEnd]]])target, even if the target memory region overlaps with buffer. The target parameter is a Buffer or Uint8Array to copy into. The targetStart is an integer specifying the offset within target at which to begin writing, by default is 0. The sourceStart is an integer specifying the offset within buffer from which to begin copying, by default is 0. The sourceEnd is an integer specifying the offset within buffer at which to stop copying (not inclusive) by default is buf.length.
buf.equals(otherBuffer)true if both Buffer and otherBuffer have exactly the same bytes. buf.fill(value[,
offset[,
end]][,
encoding])value. If the offset and end are not specified, the entire Buffer will be filled. The value is coerced to uint32 if it is not a string, Buffer, or integer. If the resulting integer is greater than 255, the Buffer will be filled with value and 255. buf.includes(value[,
byteOffset][,
encoding])buf.indexOf() !== -1, returns true if the value was found in Buffer. buf.indexOf(value[,
byteOffset][,
encoding])value in Buffer, or -1 if Buffer does not contain value. The value can be a string with specified encoding (by default utf8), Buffer, Unit8Array, or a number between 0 and 255. buf.lastIndexOf(value[,
byteOffset][,
encoding])buf.indexOf(), except the last occurrence of the value is found instead of the first occurrence. The value can be a string, Buffer, or integer between 1 and 255. If the value is an empty string or empty Buffer, byteOffset will be returned. buf.lengthbuf.readIntBE(offset,
byteLength)byteLength from buf at the specified offset and interprets the result as a big-endian, two's complement signed value supporting up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The similar methods are also supported: buf.readInt8([offset]), buf.readInt16BE([offset]), buf.readInt32BE([offset]).
buf.readIntLE(offset,
byteLength)byteLength from buf at the specified offset and interprets the result as a little-endian, two's complement signed value supporting up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The similar methods are also supported: buf.readInt8([offset]), buf.readInt16LE([offset]), buf.readInt32LE([offset]).
buf.readUIntBE(offset,
byteLength)byteLength from buf at the specified offset and interprets the result as a big-endian integer supporting up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The similar methods are also supported: buf.readUInt8([offset]), buf.readUInt16BE([offset]), buf.readUInt32BE([offset]).
buf.readUIntLE(offset,
byteLength)byteLength from buf at the specified offset and interprets the result as a little-endian integer supporting up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The similar methods are also supported: buf.readUInt8([offset]), buf.readUInt16LE([offset]), buf.readUInt32LE([offset]).
buf.readDoubleBE([offset])buf at the specified offset. buf.readDoubleLE([offset])buf at the specified offset. buf.readFloatBE([offset])buf at the specified offset. buf.readFloatLE([offset])buf at the specified offset. buf.subarray([start[,
end]])buf that references the same memory as the original, but offset and cropped by start and end. If end is greater than buf.length, the same result as that of end equal to buf.length is returned. buf.slice([start[,
end]])buf that references the same memory as the original, but offset and cropped by the start and end values. The method is not compatible with the Uint8Array.prototype.slice(), which is a superclass of Buffer. To copy the slice, use Uint8Array.prototype.slice(). buf.swap16()buf as an array of unsigned 16-bit numbers and swaps the byte order in-place. Throws an error if buf.length is not a multiple of 2. buf.swap32()buf as an array of unsigned 32-bit numbers and swaps the byte order in-place. Throws an error if buf.length is not a multiple of 4. buf.swap64()buf as an array of 64-bit numbers and swaps byte order in-place. Throws an error if buf.length is not a multiple of 8. buf.toJSON()buf. JSON.stringify() implicitly calls this function when stringifying a Buffer instance. buf.toString([encoding[,
start[,
end]]])buf to a string according to the specified character encoding which can be utf8, hex, base64, base64url. The start and end parameters may be passed to decode only a subset of Buffer. buf.write(string[,
offset[,
length]][,
encoding])string to buf at offset according to the character encoding. The length parameter is the number of bytes to write. If Buffer did not contain enough space to fit the entire string, only part of string will be written, however, partially encoded characters will not be written. The encoding can be utf8, hex, base64, base64url. buf.writeIntBE(value,
offset,
byteLength)byteLength bytes of value to buf at the specified offset as big-endian. Supports up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The following similar methods are also supported: buf.writeInt8, buf.writeInt16BE, buf.writeInt32BE.
buf.writeIntLE(value,
offset,
byteLength)byteLength bytes of value to buf at the specified offset as little-endian. Supports up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The following similar methods are also supported: buf.writeInt8, buf.writeInt16LE, buf.writeInt32LE.
buf.writeUIntBE(value,
offset,
byteLength)byteLength bytes of value to buf at the specified offset as big-endian. Supports up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The following similar methods are also supported: buf.writeUInt8, buf.writeUInt16BE, buf.writeUInt32BE.
buf.writeUIntLE(value,
offset,
byteLength)byteLength bytes of value to buf at the specified offset as little-endian. Supports up to 48 bits of accuracy. The byteLength parameter is an integer between 1 and 6 specifying the number of bytes to read. The following similar methods are also supported: buf.writeUInt8, buf.writeUInt16LE, buf.writeUInt32LE.
buf.writeDoubleBE(value,
[offset])value to buf at the specified offset as big-endian. buf.writeDoubleLE(value,
[offset])value to buf at the specified offset as little-endian. buf.writeFloatBE(value,
[offset])value to buf at the specified offset as big-endian. buf.writeFloatLE(value,
[offset])value to buf at the specified offset as little-endian. crypto.createHash() |
crypto.createHmac() |
Since 0.7.0, extended crypto API is available as a global crypto object.
The Crypto module provides cryptographic functionality support. The Crypto module object is imported using import crypto from 'crypto'.
crypto.createHash(algorithm)algorithm. The algorithm can be md5, sha1, and sha256. crypto.createHmac(algorithm,
secret key)algorithm and secret key. The algorithm can be md5, sha1, and sha256. hash.update() |
hash.digest() |
hash.update(data)data. hash.digest([encoding])hash.update(). The encoding can be hex, base64, and base64url. If encoding is not provided, a Buffer object (0.4.4) is returned. Before version (0.4.4), a byte string was returned instead of a Buffer object.
hash.copy()
import crypto from 'crypto';
crypto.createHash('sha1').update('A').update('B').digest('base64url');
/* BtlFlCqiamG-GMPiK_GbvKjdK10 */
hmac.update() |
hmac.digest() |
hmac.update(data)data. hmac.digest([encoding])hmac.update(). The encoding can be hex, base64, and base64url. If encoding is not provided, a Buffer object (0.4.4) is returned. Before version 0.4.4, a byte string was returned instead of a Buffer object.
import crypto from 'crypto';
crypto.createHmac('sha1', 'secret.key').update('AB').digest('base64url');
/* Oglm93xn23_MkiaEq_e9u8zk374 */
fs.Dirent |
fs.FileHandle |
fs.Stats |
File Access Constants |
File System Flags |
The File System module provides operations with files.
The module object is imported using import fs from 'fs'. Since 0.3.9, promissified versions of file system methods are available through fs.promises object after importing with import fs from 'fs':
import fs from 'fs';
fs.promises.readFile("/file/path").then((data) => {
/* <file data> */
});
accessSync(path[,
mode])path (0.3.9). If the check fails, an error will be returned, otherwise, the method will return undefined. modefs.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 to a file with provided filename. The data is expected to be a string or a Buffer object (0.4.4). If the file does not exist, it will be created. The options parameter is expected to be an object with the following keys: mode0o666 flaga closeSync(fd)fd file descriptor represented by an integer used by the method. Returns undefined. existsSync(path)true if the specified path exists. (0.8.2) fstatSync(fd)fs.Stats object for the file descriptor (0.7.7). The fd parameter is an integer representing the file descriptor used by the method. lstatSync(path[,
options])fs.Stats object for the symbolic link referred to by path (0.7.1). The options parameter is expected to be an object with the following keys: throwIfNoEntryundefined, by default is false. mkdirSync(path[,
options])path (0.4.2). The options parameter is expected to be an integer that specifies the mode, or an object with the following keys: mode0o777. openSync(path[,
flags[, mode]])path (0.7.7). flagsr mode0o666 promises.open(path[,
flags[, mode]])FileHandle object representing the opened file path (0.7.7). flagsr mode0o666 readdirSync(path[,
options])path (0.4.2). The options parameter is expected to be a string that specifies encoding or an object with the following keys: readFileSync(filename[,
options])filename. The options parameter holds string that specifies encoding. If an encoding is specified, a string is returned, otherwise, a Buffer object (0.4.4) is returned. Before version 0.4.4, a byte string was returned if encoding was not specified.Otherwise,
options is expected to be an object with the following keys: encodingutf8, hex (0.4.4), base64 (0.4.4), base64url (0.4.4). flagr
import fs from 'fs';
var file = fs.readFileSync('/file/path.tar.gz');
console.log(file.slice(0,2).toString('hex')) /* '1f8b' */
readlinkSync(path[,
options])path using readlink(2) (0.8.7). The options argument can be a string specifying an encoding, or an object with encoding property specifying the character encoding to use. If the encoding is buffer, the result is returned as a Buffer object, otherwise as a string. readSync(fd,
buffer, offset[,
length[, position]])fd, returns the number of bytes read (0.7.7). bufferbuffer value can be a Buffer, TypedArray, or DataView offsetinteger representing the position in buffer to write the data to lengthinteger representing the number of bytes to read positioninteger or null, by default is null. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will be unchanged realpathSync(path[,
options])., .. and symbolic links using realpath(3). The options argument can be a string specifying an encoding, or an object with an encoding property specifying the character encoding to use for the path passed to the callback (0.3.9). renameSync(oldPath,
newPath)oldPath to newPath (0.3.4).
import fs from 'fs';
fs.renameSync('hello.txt', 'HelloWorld.txt');
rmdirSync(path)path (0.4.2). statSync(path,[
options])fs.Stats object for the specified path (0.7.1). The path can be a string or buffer. The options parameter is expected to be an object with the following keys: throwIfNoEntryundefined, by default is true. symlinkSync(target,
path)path pointing to target using symlink(2) (0.3.9). Relative targets are relative to the link’s parent directory. unlinkSync(path)path (0.3.9). writeFileSync(filename,
data[,
options])data to a file with provided filename. The data is expected to be a string or a Buffer object (0.4.4). If the file does not exist, it will be created, if the file exists, it will be replaced. The options parameter is expected to be an object with the following keys: mode0o666 flagw
import fs from 'fs';
fs.writeFileSync('hello.txt', 'Hello world');
writeSync(fd,
buffer, offset[,
length[, position]])number of bytes written (0.7.7). fdinteger representing the file descriptor bufferbuffer value can be a Buffer, TypedArray, or DataView offsetinteger that determines the part of the buffer to be written, by default 0 lengthinteger specifying the number of bytes to write, by default is an offset of Buffer.byteLength positioninteger or null, by default is null. See also pwrite(2). writeSync(fd,
string[,
position[,
encoding]])string to a file using file descriptor fd, returns the number of bytes written (0.7.7). fdinteger representing a file descriptor positioninteger or null, by default is null. See also pwrite(2) encodingstring, by default is utf8 fs.Dirent is a representation of a directory entry — a file or a subdirectory. When readdirSync() is called with the withFileTypes option, the resulting array contains fs.Dirent objects.
dirent.isBlockDevice() — returns true if the fs.Dirent object describes a block device. dirent.isCharacterDevice() — returns true if the fs.Dirent object describes a character device. dirent.isDirectory() — returns true if the fs.Dirent object describes a file system directory. dirent.isFIFO() — returns true if the fs.Dirent object describes a first-in-first-out (FIFO) pipe. dirent.isFile() — returns true if the fs.Dirent object describes a regular file. dirent.isSocket() — returns true if the fs.Dirent object describes a socket. dirent.isSymbolicLink() — returns true if the fs.Dirent object describes a symbolic link. dirent.name — the name of the file fs.Dirent object refers to. filehandle.close() |
filehandle.fd |
filehandle.read() |
filehandle.stat() |
filehandle.write(buf) |
filehandle.write(str) |
The FileHandle object is an object wrapper for a numeric file descriptor (0.7.7). Instances of the FileHandle object are created by the fs.promises.open() method. If a FileHandle is not closed using the filehandle.close() method, it will try to automatically close the file descriptor, helping to prevent memory leaks. Please do not rely on this behavior because it can be unreliable. Instead, always explicitly close a FileHandle.
filehandle.close()promise, fulfills with undefined upon success. filehandle.fdFileHandle object. filehandle.read(buffer,
offset[,
length[,
position]])bufferBuffer, TypedArray, or DataView offsetinteger representing the location in the buffer at which to start filling lengthinteger representing the number of bytes to read positioninteger, null. If null, data will be read from the current file position and the position will be updated. If position is an integer, the current file position will remain unchanged. Promise which fulfills upon success with an object with two properties: bytesReadinteger representing the number of bytes read bufferBuffer, TypedArray, or DataView filehandle.stat()promise. filehandle.write(buffer,
offset[,
length[,
position]])bufferbuffer value can be a Buffer, TypedArray, or DataView offsetinteger representing the start position from within buffer where the data to write begins lengthinteger representing the number of bytes from buffer to write, by default is an offset of Buffer.byteLength positioninteger or null, by default is null. If position is not a number, the data will be written at the current position. See the POSIX pwrite(2) documentation for details. Promise which is resolved with an object containing two properties: bytesWritteninteger representing the number of bytes written bufferBuffer, TypedArray, or DataView It is unsafe to use filehandle.write() multiple times on the same file without waiting for the promise to be resolved or rejected.
filehandle.write(string[,
position[,
encoding]])string to the file. positioninteger or null, by default is null. If position is not a number, the data will be written at the current position. See the POSIX pwrite(2) documentation for details. encodingutf8 Promise which is resolved with an object containing two properties: bytesWritteninteger representing the number of bytes written bufferBuffer, TypedArray, or DataView It is unsafe to use filehandle.write() multiple times on the same file without waiting for the promise to be resolved or rejected.
The fs.Stats object provides information about a file. The object is returned from fs.statSync() and fs.lstatSync().
stats.isBlockDevice() — returns true if the fs.Stats object describes a block device. stats.isDirectory() — returns true if the fs.Stats object describes a file system directory. stats.isFIFO() — returns true if the fs.Stats object describes a first-in-first-out (FIFO) pipe. stats.isFile() — returns true if the fs.Stats object describes a regular file. stats.isSocket() — returns true if the fs.Stats object describes a socket. stats.isSymbolicLink() — returns true if the fs.Stats object describes a symbolic link. stats.dev — the numeric identifier of the device containing the file. stats.ino — the file system specific Inode number for the file. stats.mode — a bit-field describing the file type and mode. stats.nlink — the number of hard-links that exist for the file. stats.uid — the numeric user identifier of the user that owns the file (POSIX). stats.gid — the numeric group identifier of the group that owns the file (POSIX). stats.rdev — the numeric device identifier if the file represents a device. stats.size — the size of the file in bytes. stats.blksize — the file system block size for i/o operations. stats.blocks — the number of blocks allocated for this file. stats.atimeMs — the timestamp indicating the last time this file was accessed expressed in milliseconds since the POSIX Epoch. stats.mtimeMs — the timestamp indicating the last time this file was modified expressed in milliseconds since the POSIX Epoch. stats.ctimeMs — the timestamp indicating the last time this file was changed expressed in milliseconds since the POSIX Epoch. stats.birthtimeMs — the timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. stats.atime — the timestamp indicating the last time this file was accessed. stats.mtime — the timestamp indicating the last time this file was modified. stats.ctime — the timestamp indicating the last time this file was changed. stats.birthtime — the timestamp indicating the creation time of this file. The access() method can accept the following flags. These flags are exported by fs.constants:
F_OK — indicates that the file is visible to the calling process, used by default if no mode is specified R_OK — indicates that the file can be read by the calling process W_OK — indicates that the file can be written by the calling process X_OK — indicates that the file can be executed by the calling process The flag option can accept the following values:
a — open a file for appending. The file is created if it does not exist ax — the same as a but fails if the file already exists a+ — open a file for reading and appending. If the file does not exist, it will be created ax+ — the same as a+ but fails if the file already exists as — open a file for appending in synchronous mode. If the file does not exist, it will be created as+ — open a file for reading and appending in synchronous mode. If the file does not exist, it will be created r — open a file for reading. An exception occurs if the file does not exist r+ — open a file for reading and writing. An exception occurs if the file does not exist rs+ — open a file for reading and writing in synchronous mode. Instructs the operating system to bypass the local file system cache w — open a file for writing. If the file does not exist, it will be created. If the file exists, it will be replaced wx — the same as w but fails if the file already exists w+ — open a file for reading and writing. If the file does not exist, it will be created. If the file exists, it will be replaced wx+ — the same as w+ but fails if the file already exists querystring.decode() |
querystring.encode() |
querystring.escape() |
querystring.parse() |
querystring.stringify() |
querystring.unescape() |
The Query String module provides support for parsing and formatting URL query strings (0.4.3). The Query String module object is imported using import qs from 'querystring'.
querystring.decode()querystring.parse(). querystring.encode()querystring.stringify(). querystring.escape(string) Performs URL encoding of the given string, returns an escaped query string. The method is used by querystring.stringify() and should not be used directly.
querystring.parse(string[,
separator[,
equal[,
options]]])Parses the query string URL and returns an object.
The separator parameter is a substring for delimiting key and value pairs in the query string, by default is “&”.
The equal parameter is a substring for delimiting keys and values in the query string, by default is “=”.
The options parameter is expected to be an object with the following keys:
decodeURIComponent function
querystring.unescape() maxKeys number
1000. The 0 value removes limitations for counting keys. By default, percent-encoded characters within the query string are assumed to use the UTF-8 encoding, invalid UTF-8 sequences will be replaced with the U+FFFD replacement character.
For example, for the following query string
'foo=bar&abc=xyz&abc=123'
the output will be:
{
foo: 'bar',
abc: ['xyz', '123']
}
querystring.stringify(object[,
separator[,
equal[,
options]]])Serializes an object and returns a URL query string.
The separator parameter is a substring for delimiting key and value pairs in the query string, by default is “&”.
The equal parameter is a substring for delimiting keys and values in the query string, by default is “=”.
The options parameter is expected to be an object with the following keys:
encodeURIComponent function
querystring.escape(). By default, characters that require percent-encoding within the query string are encoded as UTF-8. If other encoding is required, then encodeURIComponent option should be specified.
For example, for the following command
querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], 123: '' });
the query string will be:
'foo=bar&baz=qux&baz=quux&123='
querystring.unescape(string) Performs decoding of URL percent-encoded characters of the string, returns an unescaped query string. The method is used by querystring.parse() and should not be used directly.
xml.parse() |
xml.c14n() |
xml.exclusiveC14n() |
xml.serialize() |
xml.serializeToString() |
XMLDoc |
XMLNode |
XMLAttr |
The XML module allows working with XML documents (since 0.7.10). The XML module object is imported using import xml from 'xml'.
Example:
import xml from 'xml'; let data = `<note><to b="bar" a= "foo" >Tove</to><from>Jani</from></note>`; let doc = xml.parse(data); console.log(doc.note.to.$text) /* 'Tove' */ console.log(doc.note.to.$attr$b) /* 'bar' */ console.log(doc.note.$tags[1].$text) /* 'Jani' */ let dec = new TextDecoder(); let c14n = dec.decode(xml.exclusiveC14n(doc.note)); console.log(c14n) /* '<note><to a="foo" b="bar">Tove</to><from>Jani</from></note>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note.to)); console.log(c14n) /* '<to a="foo" b="bar">Tove</to>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note, doc.note.to /* excluding 'to' */)); console.log(c14n) /* '<note><from>Jani</from></note>' */
parse(string |
Buffer)XMLDoc wrapper object representing the parsed XML document. c14n(root_node[,
excluding_node])root_node and its children according to Canonical XML Version 1.1. The root_node can be XMLNode or XMLDoc wrapper object around XML structure. Returns Buffer object that contains canonicalized output. excluding_nodeexclusiveC14n(root_node[,
excluding_node[,
withComments
[,prefix_list]]])root_node and its children according to Exclusive XML Canonicalization Version 1.0. root_nodeXMLNode or XMLDoc wrapper object around XML structure excluding_nodewithCommentsfalse by default. If true, canonicalization corresponds to Exclusive XML Canonicalization Version 1.0. Returns Buffer object that contains canonicalized output. prefix_listserialize()xml.c14n() (since 0.7.11). serializeToString()xml.c14n() except it returns the result as a string (since 0.7.11). XMLDocdoc.$rootdoc.abcabc as XMLNode wrapper object XMLNodenode.abcnode.$tag$abc node.$attr$abcabc, writable since 0.7.11 node.$attr$abc=xyz
node.setAttribute('abc',
xyz) (since 0.7.11) node.$attrsXMLAttr wrapper object for all attributes of the node node.$namenode.$nsnode.$parentnode.$tag$abcabc, writable since 0.7.11 node.removeChildren(); node.addChild(node1); node.addChild(node2) (since 0.7.11). abc of the node, writable since 0.7.11 node.$textnode.$text = 'abc' node.setText('abc') (since 0.7.11) node.addChild(nd)nd is recursively copied before adding to the node node.removeAllAttributes()node.removeAttribute(attr_name)attr_name (since 0.7.11) node.removeChildren(tag_name)tag_name (since 0.7.11). If tag_name is absent, all children tags are removed node.removeText()node.setAttribute(attr_name,
value)attr_name (since 0.7.11). When the value is null, the attribute named attr_name is deleted node.setText(value)null, the text of the node is deleted. XMLAttrattr.abcabc zlib.deflateRawSync() |
zlib.deflateSync() |
zlib.inflateRawSync() |
zlib.inflateSync() |
The zlib module provides compression functionality using the “deflate” and “inflate” algorithms (since 0.7.12). The zlib module object is imported using import zlib from 'zlib'.
deflateRawSync(string |
Buffer[,
options])Buffer, TypedArray, or DataView. Options is an optional object that contains zlib_options. Returns Buffer instance that contains the compressed data. deflateSync(string |
Buffer[,
options])Buffer, TypedArray, or DataView. Options is an optional object that contains zlib_options. Returns Buffer instance that contains the compressed data. inflateRawSync(string |
Buffer)inflateSync(string |
Buffer)chunkSize — is an integer, by default is 1024 dictionary — is a Buffer, TypedArray, or DataView. by default is empty level — is an integer, compression only, see zlib_compression_levels memLevel — is an integer from 1 to 9, compression only strategy — is an integer, compression only, see zlib_compression_strategy windowBits — is an integer from -15 to -9 for raw data, from 9 to 15 for an ordinary stream | Name | Description |
zlib.constants.Z_NO_COMPRESSION |
no compression |
zlib.constants.Z_BEST_SPEED |
fastest, produces the least compression |
zlib.constants.Z_DEFAULT_COMPRESSION |
trade-off between speed and compression |
zlib.constants.Z_BEST_COMPRESSION |
slowest, produces the most compression |
| Name | Description |
zlib.constants.Z_FILTERED |
Filtered strategy: for the data produced by a filter or predictor |
zlib.constants.Z_HUFFMAN_ONLY |
Huffman-only strategy: only Huffman encoding, no string matching |
zlib.constants.Z_RLE |
Run Length Encoding strategy: limit match distances to one, better compression of PNG image data |
zlib.constants.Z_FIXED |
Fixed table strategy: prevents the use of dynamic Huffman codes, a simpler decoder for special applications |
zlib.constants.Z_DEFAULT_STRATEGY |
Default strategy, suitable for general purpose compression |
© 2002-2021 Igor Sysoev
© 2011-2025 Nginx, Inc.
Licensed under the BSD License.
https://nginx.org/en/docs/njs/reference.html