body { background: white; color: black; font-family: sans-serif; line-height: 1.4em; text-align: center; margin: 0; padding: 0; } #banner { background: black; color: #F2F2F2; line-height: 1.2em; padding: .3em 0; box-shadow: 0 5px 10px black; } #banner a { color: #00B140; } #main { text-align: left; margin: 0 auto; min-width: 32em; max-width: 64em; } #menu { float: right; width: 11em; padding: 0 .5em 1em .5em; border-left: 2px solid #DDD; } #content { margin-right: 13.5em; padding: 0 .2em 0 1.5em; } h1 { display: block; font-size: 3em; text-align: left; height: .7em; margin: 0; margin-bottom: .5em; } h1 img { width: 100%; } h2 { text-align: center; } p { text-align: justify; } table.news p { margin-top: 0; } table.news td { vertical-align: baseline; } table.news .date { text-align: right; padding-right: 0.5em; white-space: nowrap; } table.donors td { vertical-align: baseline; } table.donors li { text-align: left; } div.directive { background: #F2F2F2; line-height: 1em; margin: 1em 0 1em -1em; padding: .7em .7em .7em 1em; border-top: 2px solid #DDD; } div.directive th { padding-left: 0; padding-right: .5em; vertical-align: baseline; text-align: left; font-weight: normal; } div.directive td { vertical-align: baseline; } div.directive pre { padding: 0; margin: 0; } div.directive p { margin: .5em 0 0 .1em; font-size: .8em; } a.notrans { color: gray; text-decoration:none; } span.initial { font-size: 200%; float: left; padding-right: 10pt;} ul, ol { margin: .5em 0 1em 1em; padding: 0 .5em; } ol { list-style-position: inside; } li { text-align: justify; padding: .5em 0 0 1px; } .compact li { padding-top: 0; } dl { margin: .5em 0 1em 0; } dt { margin: .5em 0; } .compact dt { margin-bottom: .2em; } dd { margin-left: 1.5em; padding-left: 1px; text-align: justify; } td.list { background: #F2F2F2; } blockquote { margin: 1em 0 1em 1em; padding: .5em; } li blockquote, dd blockquote { margin: .7em 0; } blockquote.note { border: 1px dotted #999; line-height: 1.2em; text-align: justify; } blockquote.example { line-height: 1em; border-left: 1px solid #BBB; } blockquote.example pre { padding: 0; margin: 0; } sup { font-size: 50%; } .video { position: relative; padding-bottom: 56.25%; overflow: hidden; } .video iframe, .video object, .video embed { position: absolute; top:0; left:0; width:100%; height:100%; }
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.
r.args{}
r.done()
r.error()
r.finish()
r.headersIn{}
r.headersOut{}
r.httpVersion
r.internal
r.internalRedirect()
r.log()
r.method
r.parent
r.remoteAddress
r.requestBody
r.requestBuffer
r.requestText
r.rawHeadersIn[]
r.rawHeadersOut[]
r.responseBody
r.responseBuffer
r.responseText
r.return()
r.send()
r.sendBuffer()
r.sendHeader()
r.setReturnValue()
r.status
r.subrequest()
r.uri
r.rawVariables{}
r.variables{}
r.warn()
The HTTP request object is available only in the ngx_http_js_module module. All string properties of the object are 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.httpVersion
r.internal
r.internalRedirect(uri
)
uri
.
If the uri starts with the “@
” prefix,
it is considered a named location.
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.method
r.parent
r.remoteAddress
r.requestBody
r.requestBuffer
or
r.requestText
property
should be used instead.
r.requestBuffer
r.requestText
r.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.responseBody
r.responseBuffer
or
the r.responseText
property
should be used instead.
r.responseBuffer
r.responseBuffer
is limited by the
subrequest_output_buffer_size
directive.
r.responseText
r.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:
last
flush
flush
flag
The method may be called only from the js_body_filter function.
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.status
r.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:
args
body
method
GET
method is used
detached
true
, 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.uri
r.rawVariables{}
r.variables{}
For example, to get the $foo
variable,
one of the following syntax can be used:
r.variables['foo'] r.variables.foo
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.
s.allow()
s.decline()
s.deny()
s.done()
s.error()
s.log()
s.off()
s.on()
s.remoteAddress
s.rawVariables{}
s.send()
s.sendDownstream()
s.sendUpstream()
s.status
s.setReturnValue()
s.variables{}
s.warn()
The stream session object is available only in the ngx_stream_js_module module. All string properties of the object are 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
May be called only from a phase handler function:
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:
upload
download
upstream
downstream
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:
last
s.remoteAddress
s.rawVariables
s.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:
last
flush
flush
flag
The method can be called multiple times per callback invocation.
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
])
init
Headers
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:
body
headers
Headers
object,
can be a string
,
an array
of name-value pairs,
or an existing Headers
object.
method
A new Request
object can be created
with the following properties and methods:
arrayBuffer()
Promise
that resolves with
an ArrayBuffer
.
bodyUsed
true
if the body was used in the request.
cache
credentials
same-origin
.
headers
Headers
read-only object
associated with the
Request
.
json()
Promise
that resolves with
the result of parsing the request body as JSON.
method
mode
text()
Promise
that resolves with a
string representation of the request body.
url
Response()
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:
headers
Headers
object,
can be a string
,
an array
of name-value pairs,
or an existing Headers
object.
status
statusText
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
.
bodyUsed
true
if the body was read.
headers
Headers
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.
ok
true
if the response was successful (status codes between 200–299).
redirected
true
if the response is the result of a redirect.
status
statusText
text()
Response
stream and reads it to completion.
Returns a Promise
that resolves with a string.
type
url
ngx.build
ngx.conf_file_path
ngx.conf_prefix
ngx.error_log_path
ngx.fetch()
ngx.log()
ngx.prefix
ngx.version
ngx.version_number
ngx.worker_id
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_path
ngx.conf_prefix
ngx.error_log_path
ngx.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:
body
buffer_size
4096
headers
max_response_body_size
32768
method
GET
method is used
verify
true
(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.prefix
ngx.version
1.25.0
(0.8.0)
ngx.version_number
1025000
(0.8.0)
ngx.worker_id
0
and the value specified in the
worker_processes directive
(0.8.0)
The ngx.shared
global object is available
since 0.8.0.
ngx.shared.SharedDict.add()
ngx.shared.SharedDict.capacity
ngx.shared.SharedDict.clear()
ngx.shared.SharedDict.delete()
ngx.shared.SharedDict.freeSpace()
ngx.shared.SharedDict.get()
ngx.shared.SharedDict.has()
ngx.shared.SharedDict.incr()
ngx.shared.SharedDict.items()
ngx.shared.SharedDict.keys()
ngx.shared.SharedDict.name
ngx.shared.SharedDict.pop()
ngx.shared.SharedDict.replace()
ngx.shared.SharedDict.set()
ngx.shared.SharedDict.size()
ngx.shared.SharedDict.type
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
)
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.
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.capacity
SharedDict
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
])
key
by delta
.
If the key does not exist,
the item will be initialized to init
.
The key
is a string,
the delta
is the number
to increment or decrement the value by,
the init
is a number to initialize the item with
if it does not exist, by default is 0
.
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=number
parameter of thejs_shared_dict_zone
directive 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.name
SharedDict
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
)
value
for the specified key
,
returns this SharedDict
dictionary (for method chaining).
ngx.shared.SharedDict.size()
SharedDict
dictionary.
ngx.shared.SharedDict.type
string
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
...])
с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()
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:
typedArray
Int8Array
,
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:
algorithm
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.
key
CryptoKey
that contains
the key to be used for encryption
data
ArrayBuffer
,
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:
algorithm
encrypt()
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.
key
CryptoKey
that contains the key to be used for decryption.
If RSA-OAEP
is used, this is the
privateKey
property of the
CryptoKeyPair
object.
data
ArrayBuffer
,
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:
algorithm
HKDF
,
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()
baseKey
CryptoKey
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()
length
8
сrypto.subtle.deriveKey
(algorithm
,
baseKey
,
derivedKeyAlgorithm
,
extractable
,
keyUsages
)algorithm
HKDF
,
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()
baseKey
CryptoKey
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()
.
derivedKeyAlgorithm
HMAC
,
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
extractable
keyUsages
Array
that indicates what can be done with the derived key.
The key usages must be allowed by the algorithm
set in derivedKeyAlgorithm
.
Possible values:
encrypt
decrypt
sign
verify
deriveKey
deriveBits
wrapKey
unwrapKey
сrypto.subtle.digest
(algorithm
,
data
)Promise
which will be fulfilled with the digest.
Possible values:
algorithm
SHA-1
(not for cryptographic applications),
SHA-256
,
SHA-384
, or
SHA-512
data
ArrayBuffer
,
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:
format
raw
pkcs8
spki
jwk
key
CryptoKey
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:
algorithm
RSASSA-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
extractable
usage
array
that indicates possible actions with the key:
encrypt
decrypt
sign
verify
deriveKey
deriveBits
wrapKey
unwrapKey
с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:
format
raw
pkcs8
spki
jwk
keyData
ArrayBuffer
,
TypedArray
, or
DataView
object that contains the key in the given format
algorithm
RSASSA-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
extractable
keyUsages
array
that indicates possible actions with the key:
encrypt
decrypt
sign
verify
deriveKey
deriveBits
wrapKey
unwrapKey
сrypto.subtle.sign
(algorithm
,
key
,
data
)signature
as a Promise
that fulfills with an ArrayBuffer
containing the signature.
Possible values:
algorithm
RSASSA-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" }
key
CryptoKey
object
that the key to be used for signing.
If algorithm identifies a public-key cryptosystem, this is the private key.
data
ArrayBuffer
,
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:
algorithm
RSASSA-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" }
key
CryptoKey
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.
signature
ArrayBuffer
,
TypedArray
, or
DataView
that contains the signature to verify
data
ArrayBuffer
,
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.algorithm
CryptoKey.extractable
true
if the key can be exported
(since 0.8.0),
read-only
CryptoKey.type
secret
private
CryptoKeyPair
public
CryptoKeyPair
.
CryptoKey.usages
encrypt
decrypt
sign
verify
deriveKey
deriveBits
CryptoKeyPair.privateKey
CryptoKeyPair.publicKey
The CryptoKeyPair
is a dictionary object
of the WebCrypto API
that represents an asymmetric key pair.
CryptoKeyPair.privateKey
CryptoKey
object
representing the private key.
CryptoKeyPair.publicKey
CryptoKey
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.version
njs.version_number
0x000704
(since 0.7.4).
njs.dump(value
)
njs.memoryStats
size
njs.on(event
,
callback
)
exit
process.argv
process.env
process.pid
process.ppid
The process
object is a global object
that provides information about the current process
(0.3.3).
process.argv
process.env
By 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.pid
process.ppid
By 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 andBuffer
properties, 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:
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>> Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]).toString() 'buffer' >> Buffer.from('YnVmZmVy', 'base64').toString() 'buffer'
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:
fatal
TextDecoder.decode()
must throw the TypeError
exception when
a coding error is found, by default is false
.
TextDecoder.prototype.encoding
TextDecoder()
,
read-only.
TextDecoder.prototype.fatal
true
if
the error mode is fatal,
read-only.
TextDecoder.prototype.ignoreBOM
true
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:
stream
decode()
:
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:
read
string
converted to UTF-8
written
Uint8Array
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(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()
Buffer.allocUnsafe()
Buffer.byteLength()
Buffer.compare()
Buffer.concat()
Buffer.from(array)
Buffer.from(arrayBuffer)
Buffer.from(buffer)
Buffer.from(object)
Buffer.from(string)
Buffer.isBuffer()
Buffer.isEncoding()
buffer[]
buf.buffer
buf.byteOffset
buf.compare()
buf.copy()
buf.equals()
buf.fill()
buf.includes()
buf.indexOf()
buf.lastIndexOf()
buf.length
buf.readIntBE()
buf.readIntLE()
buf.readUIntBE()
buf.readUIntLE()
buf.readDoubleBE
buf.readDoubleLE()
buf.readFloatBE()
buf.readFloatLE()
buf.subarray()
buf.slice()
buf.swap16()
buf.swap32()
buf.swap64()
buf.toJSON()
buf.toString()
buf.write()
buf.writeIntBE()
buf.writeIntLE()
buf.writeUIntBE()
buf.writeUIntLE()
buf.writeDoubleBE()
buf.writeDoubleLE()
buf.writeFloatBE()
buf.writeFloatLE()
Buffer.alloc(size
[,
fill
[,
encoding
]]))
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.buffer
ArrayBuffer
object
based on which this Buffer object is created.
buf.byteOffset
byteOffset
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.length
buf.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 returned by require('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(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()
>> var cr = require('crypto') undefined >> cr.createHash('sha1').update('A').update('B').digest('base64url') 'BtlFlCqiamG-GMPiK_GbvKjdK10'
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.
>> var cr = require('crypto') undefined >> cr.createHmac('sha1', 'secret.key').update('AB').digest('base64url') 'Oglm93xn23_MkiaEq_e9u8zk374'
fs.accessSync()
fs.appendFileSync()
fs.closeSync()
fs.existsSync()
fs.fstatSync()
fs.lstatSync()
fs.mkdirSync()
fs.openSync()
fs.promises.open()
fs.readdirSync()
fs.readFileSync()
fs.readSync()
fs.realpathSync()
fs.renameSync()
fs.rmdirSync()
fs.statSync()
fs.symlinkSync()
fs.unlinkSync()
fs.writeFileSync()
fs.writeSync()
fs.writeSync()
fs.Dirent
fs.FileHandle
fs.Stats
File Access Constants
File System Flags
The File System module provides operations with files.
The module object is returned by require('fs')
.
Since 0.3.9,
promissified versions of file system methods are available through
require('fs').promises
object:
> var fs = require('fs').promises; undefined > fs.readFile("/file/path").then((data)=>console.log(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.
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
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:
mode
0o666
flag
a
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:
throwIfNoEntry
undefined
,
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:
mode
0o777
.
openSync(path
[,
flags
[, mode
]])
path
(0.7.7).
flags
r
mode
0o666
promises.open(path
[,
flags
[, mode
]])
FileHandle
object
representing the opened file path
(0.7.7).
flags
r
mode
0o666
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:
encoding
utf8
.
The encoding can be utf8
and buffer
(0.4.4).
withFileTypes
true
, the files array will contain
fs.Dirent
objects,
by default is false
.
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:
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
readSync(fd
,
buffer
, offset
[,
length
[, position
]])
fd
,
returns the number of bytes read
(0.7.7).
buffer
buffer
value can be a
Buffer
,
TypedArray
, or
DataView
offset
integer
representing
the position in buffer to write the data to
length
integer
representing
the number of bytes to read
position
integer
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).
>> var fs = require('fs') undefined >> var file = fs.renameSync('hello.txt', 'HelloWorld.txt') undefined
rmdirSync(path
)
path
(0.4.2).
statSync(path
,[
options
])
fs.Stats
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:
throwIfNoEntry
undefined
,
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:
mode
0o666
flag
w
>> var fs = require('fs') undefined >> var file = fs.writeFileSync('hello.txt', 'Hello world') undefined
writeSync(fd
,
buffer
, offset
[,
length
[, position
]])
number
of bytes written
(0.7.7).
fd
integer
representing the file descriptor
buffer
buffer
value can be a
Buffer
,
TypedArray
, or
DataView
offset
integer
that determines
the part of the buffer to be written,
by default 0
length
integer
specifying the number of bytes to write,
by default is an offset of
Buffer.byteLength
position
integer
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).
fd
integer
representing a file descriptor
position
integer
or
null
, by default is null
.
See also
pwrite(2)
encoding
string
,
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.fd
FileHandle
object.
filehandle.read(buffer
,
offset
[,
length
[,
position
]])
buffer
Buffer
,
TypedArray
, or
DataView
offset
integer
representing the location in the buffer at which to start filling
length
integer
representing the number of bytes to read
position
integer
,
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:
bytesRead
integer
representing the number of bytes read
buffer
Buffer
,
TypedArray
, or
DataView
filehandle.stat()
promise
.
filehandle.write(buffer
,
offset
[,
length
[,
position
]])
buffer
buffer
value can be a
Buffer
,
TypedArray
, or
DataView
offset
integer
representing
the start position from within buffer where the data to write begins
length
integer
representing
the number of bytes from buffer to write, by default
is an offset of
Buffer.byteLength
position
integer
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:
bytesWritten
integer
representing the number of bytes written
buffer
Buffer
,
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.
position
integer
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.
encoding
utf8
Promise
which is resolved with an object
containing two properties:
bytesWritten
integer
representing the number of bytes written
buffer
Buffer
,
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 returned by
require('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 returned by
require('xml')
.
Example:
const xml = require("xml"); let data = `<note><to b="bar" a= "foo" >Tove</to><from>Jani</from></note>`; let doc = xml.parse(data); console.log(doc.note.to.$text) /* 'Tove' */ console.log(doc.note.to.$attr$b) /* 'bar' */ console.log(doc.note.$tags[1].$text) /* 'Jani' */ let dec = new TextDecoder(); let c14n = dec.decode(xml.exclusiveC14n(doc.note)); console.log(c14n) /* '<note><to a="foo" b="bar">Tove</to><from>Jani</from></note>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note.to)); console.log(c14n) /* '<to a="foo" b="bar">Tove</to>' */ c14n = dec.decode(xml.exclusiveC14n(doc.note, doc.note.to /* excluding 'to' */)); console.log(c14n) /* '<note><from>Jani</from></note>' */
parse(string
|
Buffer
)
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_node
exclusiveC14n(root_node
[,
excluding_node
[,
withComments
[,prefix_list
]]])
root_node
and its children according to
Exclusive XML
Canonicalization Version 1.0.
root_node
XMLNode
or
XMLDoc
wrapper object
around XML structure
excluding_node
withComments
false
by default.
If true
, canonicalization corresponds to
Exclusive XML
Canonicalization Version 1.0.
Returns Buffer object that contains canonicalized output.
prefix_list
serialize()
xml.c14n()
(since 0.7.11).
serializeToString()
xml.c14n()
except it returns the result as a string
(since 0.7.11).
XMLDoc
doc.$root
doc.abc
abc
as
XMLNode
wrapper object
XMLNode
node.abc
node.$tag$abc
node.$attr$abc
abc
,
writable
since 0.7.11
node.$attr$abc
=xyz
node.setAttribute('abc
',
xyz
)
(since 0.7.11)
node.$attrs
XMLAttr
wrapper object
for all attributes of the node
node.$name
node.$ns
node.$parent
node.$tag$abc
abc
,
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.$text
node.$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.
XMLAttr
attr.abc
abc
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 returned by
require('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
NameDescription
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
NameDescription
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