# Referência da API NJS O módulo [NJS](https://pt.angie.software//angie/docs/installation/external-modules/njs.md#external-njs) fornece objetos, métodos e propriedades para estender a funcionalidade do Angie. Esta referência contém apenas propriedades, métodos e módulos específicos do NJS que não são compatíveis com ECMAScript. Definições de propriedades e métodos do NJS compatíveis com ECMAScript podem ser encontradas na [especificação ECMAScript](http://www.ecma-international.org/ecma-262/). ## Objetos do Angie ### Requisição HTTP - `r.args{}` - `r.done()` - `r.error()` - `r.finish()` - `r.headersIn{}` - `r.headersOut{}` - `r.httpVersion` - `r.internal` - `r.internalRedirect()` - `r.log()` - `r.method` - `r.parent` - `r.remoteAddress` - `r.requestBody` - `r.requestBuffer` - `r.requestText` - `r.rawHeadersIn[]` - `r.rawHeadersOut[]` - `r.responseBody` - `r.responseBuffer` - `r.responseText` - `r.return()` - `r.send()` - `r.sendBuffer()` - `r.sendHeader()` - `r.setReturnValue()` - `r.status` - `r.subrequest()` - `r.uri` - `r.rawVariables{}` - `r.variables{}` - `r.warn()` O objeto de requisição HTTP está disponível apenas no módulo [HTTP JS](https://pt.angie.software//angie/docs/installation/external-modules/http_js.md#http-js). Antes da versão 0.8.5, todas as propriedades de string do objeto eram strings de bytes. `r.args{}` > Objeto de argumentos da requisição, somente leitura. > A query string é retornada como um objeto. Desde a versão 0.7.6, chaves duplicadas são retornadas como um array, as chaves diferenciam maiúsculas de minúsculas, tanto as chaves quanto os valores são decodificados por porcentagem. > Por exemplo, a query string > ```text > a=1&b=%32&A=3&b=4&B=two%20words > ``` > é convertida para `r.args` como: > ```javascript > {a: "1", b: ["2", "4"], A: "3", B: "two words"} > ``` > Cenários de análise mais avançados podem ser alcançados com o módulo [Query String](#njs-querystring) e a variável `$args`, por exemplo: > ```javascript > import qs from 'querystring'; > function args(r) { > return qs.parse(r.variables.args); > } > ``` > O objeto de argumentos é avaliado no primeiro acesso a `r.args`. Se apenas um único argumento for necessário, por exemplo `foo`, as variáveis do Angie podem ser usadas: > ```javascript > r.variables.arg_foo > ``` > Aqui, o objeto de variáveis do Angie retorna o primeiro valor para uma determinada chave, sem diferenciar maiúsculas de minúsculas, sem decodificação por porcentagem. > Para converter `r.args` de volta para uma string, o método `stringify` do Query String pode ser usado. `r.done()` : Após chamar esta função, os próximos blocos de dados serão passados ao cliente sem chamar `js_body_filter` (0.5.2). Pode ser chamado apenas da função `js_body_filter`. `r.error(string)` : Escreve uma `string` no log de erros no nível de log `error`.
#### NOTE Como o Angie tem um limite de comprimento máximo de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. `r.finish()` : Finaliza o envio de uma resposta ao cliente. `r.headersIn{}` : Objeto de cabeçalhos de entrada, somente leitura.
O cabeçalho de requisição `Foo` pode ser acessado com a sintaxe: `headersIn.foo` ou `headersIn['Foo']`.
Os cabeçalhos de requisição `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` e `User-Agent` podem ter apenas um valor de campo (0.4.1). Valores de campo duplicados nos cabeçalhos `Cookie` são separados por ponto e vírgula (`;`). Valores de campo duplicados em todos os outros cabeçalhos de requisição são separados por vírgulas. `r.headersOut{}` : Objeto de cabeçalhos de saída para a requisição principal, gravável.
Se `r.headersOut{}` for o objeto de resposta de uma subrequisição, ele representa os cabeçalhos de resposta. Neste caso, valores de campo nos cabeçalhos de resposta `Accept-Ranges`, `Connection`, `Content-Disposition`, `Content-Encoding`, `Content-Length`, `Content-Range`, `Date`, `Keep-Alive`, `Server`, `Transfer-Encoding`, `X-Accel-*` podem ser omitidos.
O cabeçalho de resposta `Foo` pode ser acessado com a sintaxe: `headersOut.foo` ou `headersOut['Foo']`.
Os cabeçalhos de saída devem ser definidos antes que um cabeçalho de resposta seja enviado ao cliente; caso contrário, a atualização do cabeçalho será ignorada. Isso significa que `r.headersOut{}` é efetivamente gravável em:
- o manipulador `js_content` antes que `r.sendHeader()` ou `r.return()` sejam chamados - o manipulador `js_header_filter`
Valores de campo de cabeçalhos de resposta com múltiplos valores (0.4.0) podem ser definidos com a sintaxe:
```javascript r.headersOut['Foo'] = ['a', 'b'] ```
onde a saída será:
```text Foo: a Foo: b ```
Todos os valores de campo anteriores do cabeçalho de resposta `Foo` serão excluídos.
Para cabeçalhos de resposta padrão que aceitam apenas um único valor de campo, como `Content-Type`, apenas o último elemento do array terá efeito. Valores de campo do cabeçalho de resposta `Set-Cookie` são sempre retornados como um array. Valores de campo duplicados nos cabeçalhos de resposta `Age`, `Content-Encoding`, `Content-Length`, `Content-Type`, `ETag`, `Expires`, `Last-Modified`, `Location`, `Retry-After` são ignorados. Valores de campo duplicados em todos os outros cabeçalhos de resposta são separados por vírgulas. `r.httpVersion` : Versão HTTP, somente leitura. `r.internal` : Valor booleano, `true` para localizações internas. `r.internalRedirect(uri)` : Executa um redirecionamento interno para o `uri` especificado. Se o URI começar com o prefixo `@`, ele é considerado uma localização nomeada. Na nova localização, todo o processamento da requisição é repetido começando de `NGX_HTTP_SERVER_REWRITE_PHASE` para localizações comuns e de `NGX_HTTP_REWRITE_PHASE` para localizações nomeadas. Como resultado, um redirecionamento para uma localização nomeada não verifica o limite `client_max_body_size`. Requisições redirecionadas tornam-se internas e podem acessar localizações internas. O redirecionamento real acontece após a conclusão da execução do manipulador.
#### NOTE Após o redirecionamento, uma nova VM NJS é iniciada na localização de destino, e a VM na localização original é interrompida. Os valores das variáveis do Angie são mantidos e podem ser usados para passar informações para a localização de destino. Desde a versão 0.5.3, uma variável declarada com a diretiva `js_var` para HTTP ou Stream pode ser usada.
#### NOTE Desde a versão 0.7.4, o método aceita URIs com escape. `r.log(string)` : Escreve uma `string` no log de erros no nível de log `info`.
#### NOTE Como o Angie tem um limite de comprimento máximo de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. `r.method` : Método HTTP, somente leitura. `r.parent` : Referencia o objeto de requisição pai. `r.remoteAddress` : Endereço do cliente, somente leitura. `r.requestBody` : A propriedade tornou-se obsoleta na versão 0.5.0 e foi removida na versão 0.8.0. A propriedade `r.requestBuffer` ou `r.requestText` deve ser usada em seu lugar. `r.requestBuffer` : Corpo da requisição do cliente se não tiver sido gravado em um arquivo temporário (desde 0.5.0). Para garantir que o corpo da requisição do cliente esteja na memória, seu tamanho deve ser limitado por `client_max_body_size`, e um tamanho de buffer suficiente deve ser definido usando `client_body_buffer_size`. A propriedade está disponível apenas na diretiva `js_content`. `r.requestText` : O mesmo que `r.requestBuffer`, mas retorna uma `string`. Observe que pode converter bytes inválidos na codificação UTF-8 no caractere de substituição. `r.rawHeadersIn[]` : Retorna um array de pares chave-valor exatamente como foram recebidos do cliente (0.4.1).
Por exemplo, com os seguintes cabeçalhos de requisição:
```text Host: localhost Foo: bar foo: bar2 ```
a saída de `r.rawHeadersIn` será:
```javascript [ ['Host', 'localhost'], ['Foo', 'bar'], ['foo', 'bar2'] ] ```
Todos os cabeçalhos `foo` podem ser coletados com a sintaxe:
```javascript r.rawHeadersIn.filter(v=>v[0].toLowerCase() == 'foo').map(v=>v[1]) ```
a saída será:
```javascript ['bar', 'bar2'] ```
Os nomes dos campos de cabeçalho não são convertidos para minúsculas, valores de campo duplicados não são mesclados. `r.rawHeadersOut[]` : Retorna um array de pares chave-valor dos cabeçalhos de resposta (0.4.1). Os nomes dos campos de cabeçalho não são convertidos para minúsculas, valores de campo duplicados não são mesclados. `r.responseBody` : A propriedade foi descontinuada na versão 0.5.0 e foi removida na versão 0.8.0. A propriedade `r.responseBuffer` ou `r.responseText` deve ser usada em seu lugar. `r.responseBuffer` : Contém o corpo da resposta da subrequisição, somente leitura (desde 0.5.0). O tamanho de `r.responseBuffer` é limitado pela diretiva `subrequest_output_buffer_size`. `r.responseText` : O mesmo que `r.responseBuffer`, mas retorna uma string (desde 0.5.0). Note que pode converter bytes inválidos na codificação UTF-8 no caractere de substituição. `r.return(status[, string | Buffer])` : Envia a resposta completa com o `status` especificado para o cliente. A resposta pode ser uma string ou Buffer (0.5.0).
É possível especificar uma URL de redirecionamento (para os códigos 301, 302, 303, 307 e 308) ou o texto do corpo da resposta (para outros códigos) como segundo argumento. `r.send(string | Buffer)` : Envia uma parte do corpo da resposta para o cliente. Os dados enviados podem ser uma string ou Buffer (0.5.0). `r.sendBuffer(data[, options])` : Adiciona dados à cadeia de blocos de dados a serem encaminhados para o próximo filtro de corpo (0.5.2). O encaminhamento real acontece posteriormente, quando todos os blocos de dados da cadeia atual são processados.
Os dados podem ser uma string ou Buffer. O `options` é um objeto usado para substituir as flags de buffer do Angie derivadas de um buffer de bloco de dados de entrada. As flags podem ser substituídas com as seguintes flags:
`last` : Booleano, `true` se o buffer é o último buffer.
`flush` : Booleano, `true` se o buffer deve ter a flag `flush`.
O método pode ser chamado apenas da função `js_body_filter`. `r.sendHeader()` : Envia os cabeçalhos HTTP para o cliente. `r.setReturnValue(value)` : Define o valor de retorno do manipulador `js_set` (0.7.0). Diferentemente de uma instrução return comum, este método deve ser usado quando o manipulador é uma função JS assíncrona. Por exemplo:
```javascript async function js_set(r) { const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host); r.setReturnValue(digest); } ``` `r.status` : Status, gravável. `r.subrequest(uri[, options[, callback]])` : Cria uma subrequisição com o `uri` e `options` fornecidos, e instala um `callback` de conclusão opcional.
Uma subrequisição compartilha seus cabeçalhos de entrada com a requisição do cliente. Para enviar cabeçalhos diferentes dos cabeçalhos originais para um servidor proxy, a diretiva `proxy_set_header` pode ser usada. Para enviar um conjunto completamente novo de cabeçalhos para um servidor proxy, a diretiva `proxy_pass_request_headers` pode ser usada.
Se `options` for uma string, então ela contém a string de argumentos da subrequisição. Caso contrário, espera-se que `options` seja um objeto com as seguintes chaves:
`args` : String de argumentos, por padrão uma string vazia é usada.
`body` : Corpo da requisição, por padrão o corpo da requisição do objeto de requisição pai é usado.
`method` : Método HTTP, por padrão o método `GET` é usado.
`detached` : Flag booleana (0.3.9); se `true`, a subrequisição criada é uma subrequisição desanexada. Respostas a subrequisições desanexadas são ignoradas. Diferentemente de subrequisições comuns, uma subrequisição desanexada pode ser criada dentro de um manipulador de variável. A flag `detached` e o argumento callback são mutuamente exclusivos.
O `callback` de conclusão recebe um objeto de resposta de subrequisição com métodos e propriedades idênticos ao objeto de requisição pai.
Desde 0.3.8, se um `callback` não for fornecido, o objeto `Promise` que resolve para o objeto de resposta de subrequisição é retornado.
Por exemplo, para visualizar todos os cabeçalhos de resposta na subrequisição:
```javascript async function handler(r) { const reply = await r.subrequest('/path');
for (const h in reply.headersOut) { r.log(`${h}: ${reply.headersOut[h]}`); }
r.return(200); } ``` `r.uri` : URI atual na requisição, normalizado, somente leitura. `r.rawVariables{}` : Variáveis do Angie como Buffers, gravável (desde 0.5.0). `r.variables{}` : Objeto de variáveis do Angie, gravável (desde 0.2.8).
Por exemplo, para obter a variável `$foo`, uma das seguintes sintaxes pode ser usada:
```javascript r.variables['foo'] r.variables.foo ```
Desde 0.8.6, capturas de expressão regular podem ser acessadas usando a seguinte sintaxe:
```javascript r.variables['1'] r.variables[1] ```
O Angie trata variáveis referenciadas em `angie.conf` e variáveis não referenciadas de forma diferente. Quando uma variável é referenciada, ela pode ser armazenável em cache, mas quando não é referenciada, ela é sempre não armazenável em cache. Por exemplo, quando a variável `$request_id` é acessada apenas do NJS, ela tem um novo valor toda vez que é avaliada. Mas, quando o `$request_id` é referenciado, por exemplo:
```nginx proxy_set_header X-Request-Id $request_id; ```
o `r.variables.request_id` retorna o mesmo valor toda vez.
Uma variável é gravável se:
- foi criada usando a diretiva `js_var` para HTTP ou Stream (desde 0.5.3) - é referenciada no arquivo de configuração do Angie
Mesmo assim, algumas variáveis incorporadas ainda não podem ter um valor atribuído (por exemplo, `$http_`). `r.warn(string)` : Escreve uma `string` no log de erros no nível de log `warning`.
#### NOTE Como o Angie tem um limite máximo de comprimento de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. ### Sessão Stream - `s.allow()` - `s.decline()` - `s.deny()` - `s.done()` - `s.error()` - `s.log()` - `s.off()` - `s.on()` - `s.remoteAddress` - `s.rawVariables{}` - `s.send()` - `s.sendDownstream()` - `s.sendUpstream()` - `s.status` - `s.setReturnValue()` - `s.variables{}` - `s.warn()` O objeto de sessão stream está disponível apenas no módulo [Stream JS](https://pt.angie.software//angie/docs/installation/external-modules/stream_js.md#stream-js). Antes de 0.8.5, todas as propriedades de string do objeto eram strings de bytes. `s.allow()` : Um alias para `s.done(0)` (0.2.4). `s.decline()` : Um alias para `s.done(-5)` (0.2.4). `s.deny()` : Um alias para `s.done(403)` (0.2.4). `s.done([code])` : Define um `code` de saída para o manipulador de fase atual para um valor de código, por padrão `0`. A finalização real acontece quando o manipulador js é concluído e todos os eventos pendentes, por exemplo, de `ngx.fetch()` ou `setTimeout()`, são processados (0.2.4).
Valores de código possíveis:
- `0` — finalização bem-sucedida, passando controle para a próxima fase - `-5` — indeciso, passando controle para o próximo manipulador da fase atual (se houver) - `403` — acesso negado
Pode ser chamado apenas de uma função de manipulador de fase: `js_access` ou `js_preread`. `s.error(string)` : Escreve uma `string` enviada no log de erros no nível de log `error`.
#### NOTE Como o Angie tem um limite máximo de comprimento de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. `s.log(string)` : Escreve uma `string` enviada no log de erros no nível de log `info`.
#### NOTE Como o Angie tem um limite máximo de comprimento de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. `s.off(eventName)` : Cancela o registro do callback definido pelo método `s.on()` (0.2.4). `s.on(event, callback)` : Registra um `callback` para o `event` especificado (0.2.4).
Um `event` pode ser uma das seguintes strings:
`upload` : Novos dados (string) de um cliente.
`download` : Novos dados (string) para um cliente.
`upstream` : Novos dados (Buffer) de um cliente (desde 0.5.0).
`downstream` : Novos dados (Buffer) para um cliente (desde 0.5.0).
O callback de conclusão tem o seguinte protótipo: `callback(data, flags)`, onde `data` é string ou Buffer (dependendo do tipo de evento); `flags` é um objeto com as seguintes propriedades:
`last` : Um valor booleano, `true` se data é o último buffer. `s.remoteAddress` : Endereço do cliente, somente leitura. `s.rawVariables` : Variáveis do Angie como Buffers, gravável (desde 0.5.0). `s.send(data[, options])` : Adiciona dados à cadeia de blocos de dados que serão encaminhados na direção de avanço: no callback de download para um cliente; no upload para um servidor upstream (0.2.4). O encaminhamento real acontece posteriormente, quando todos os blocos de dados da cadeia atual são processados.
Os dados podem ser uma string ou Buffer (0.5.0). O `options` é um objeto usado para substituir as flags de buffer do Angie derivadas de um buffer de bloco de dados de entrada. As flags podem ser substituídas com as seguintes flags:
`last` : Booleano, `true` se o buffer é o último buffer.
`flush` : Booleano, `true` se o buffer deve ter a flag `flush`.
O método pode ser chamado várias vezes por invocação de callback. `s.sendDownstream()` : Idêntico a `s.send()`, exceto que sempre envia dados para um cliente (desde 0.7.8). `s.sendUpstream()` : Idêntico a `s.send()`, exceto que sempre envia dados de um cliente (desde 0.7.8). `s.status` : Código de status da sessão, um alias para a variável `$status`, somente leitura (desde 0.5.2). `s.setReturnValue(value)` : Define o valor de retorno do manipulador `js_set` (0.7.0). Diferentemente de uma instrução return comum, este método deve ser usado quando o manipulador é uma função JS assíncrona. Por exemplo:
```javascript async function js_set(r) { const digest = await crypto.subtle.digest('SHA-256', r.headersIn.host); r.setReturnValue(digest); } ``` `s.variables{}` : Objeto de variáveis do Angie, gravável (desde 0.2.8). Uma variável pode ser gravável apenas se for referenciada no arquivo de configuração do Angie. Mesmo assim, algumas variáveis incorporadas ainda não podem ter um valor atribuído. `s.warn(string)` : Escreve a `string` enviada no log de erros no nível de registro `warning`.
#### NOTE Como o Angie tem um limite de comprimento máximo de linha codificado, apenas os primeiros 2048 bytes da string podem ser registrados. ### Sessão Periódica - `PeriodicSession.rawVariables{}` - `PeriodicSession.variables{}` O objeto `Periodic Session` é fornecido como o primeiro argumento para o manipulador `js_periodic` para HTTP e Stream (desde 0.8.1). `PeriodicSession.rawVariables{}` : Variáveis do Angie como Buffers, gravável. `PeriodicSession.variables{}` : Objeto de variáveis do Angie, gravável. ### Headers - `Headers()` - `Headers.append()` - `Headers.delete()` - `Headers.get()` - `Headers.getAll()` - `Headers.forEach()` - `Headers.has()` - `Headers.set()` A interface `Headers` da API Fetch está disponível desde 0.5.1. Um novo objeto `Headers` pode ser criado usando o construtor `Headers()` (desde 0.7.10): `Headers([init])` : `init` : Um objeto contendo cabeçalhos HTTP para pré-popular o objeto `Headers`, pode ser uma `string`, um `array` de pares nome-valor, ou um objeto `Headers` existente. Um novo objeto `Headers` pode ser criado com as seguintes propriedades e métodos: `append()` : Adiciona um novo valor a um cabeçalho existente no objeto `Headers`, ou adiciona o cabeçalho se ele ainda não existir (desde 0.7.10). `delete()` : Remove um cabeçalho do objeto `Headers` (desde 0.7.10). `get()` : Retorna uma string contendo os valores de todos os cabeçalhos com o nome especificado separados por vírgula e espaço. `getAll(name)` : Retorna um array contendo os valores de todos os cabeçalhos com o nome especificado. `forEach()` : Executa uma função fornecida uma vez para cada par chave/valor no objeto `Headers` (desde 0.7.10). `has()` : Retorna um valor booleano indicando se existe um cabeçalho com o nome especificado. `set()` : Define um novo valor para um cabeçalho existente dentro do objeto `Headers`, ou adiciona o cabeçalho se ele ainda não existir (desde 0.7.10). ### Request - `Request()` - `Request.arrayBuffer()` - `Request.bodyUsed` - `Request.cache` - `Request.credentials` - `Request.headers` - `Request.json()` - `Request.method` - `Request.mode` - `Request.text()` - `Request.url` A interface `Request` da API Fetch está disponível desde 0.7.10. Um novo objeto `Request` pode ser criado usando o construtor `Request()`: `Request[resource[, options]])` : Cria um objeto `Request` para buscar que pode ser passado posteriormente para `ngx.fetch()`. O `resource` pode ser uma URL ou um objeto `Request` existente. O `options` é um argumento opcional que deve ser um objeto com as seguintes chaves:
`body` : O corpo da requisição, por padrão é vazio.
`headers` : O objeto de cabeçalhos da requisição — o objeto contendo cabeçalhos HTTP para pré-popular o objeto `Headers`, pode ser uma `string`, um `array` de pares nome-valor, ou um objeto `Headers` existente.
`method` : O método HTTP, por padrão o método GET é usado. Um novo objeto `Request` pode ser criado com as seguintes propriedades e métodos: `arrayBuffer()` : Retorna uma `Promise` que resolve com um `ArrayBuffer`. `bodyUsed` : Um valor booleano, `true` se o corpo foi usado na requisição. `cache` : Contém o modo de cache da requisição. `credentials` : Contém as credenciais da requisição, por padrão é `same-origin`. `headers` : O objeto `Headers` somente leitura associado ao `Request`. `json()` : Retorna uma `Promise` que resolve com o resultado da análise do corpo da requisição como JSON. `method` : Contém o método da requisição. `mode` : Contém o modo da requisição. `text()` : Retorna uma `Promise` que resolve com uma representação em string do corpo da requisição. `url` : Contém a URL da requisição. ### Response - `Response()` - `Response.arrayBuffer()` - `Response.bodyUsed` - `Response.headers` - `Response.json()` - `Response.ok` - `Response.redirected` - `Response.status` - `Response.statusText` - `Response.text()` - `Response.type` - `Response.url` A interface `Response` está disponível desde 0.5.1. Um novo objeto `Response` pode ser criado usando o construtor `Response()` (desde 0.7.10): `Response[body[, options]])` : Cria um objeto `Response`. O `body` é um argumento opcional, pode ser uma `string` ou um `buffer`, por padrão é `null`. O `options` é um argumento opcional que deve ser um objeto com as seguintes chaves:
`headers` : O objeto de cabeçalhos de resposta — o objeto contendo cabeçalhos HTTP para pré-popular o objeto `Headers`, pode ser uma `string`, um `array` de pares nome-valor, ou um objeto `Headers` existente.
`status` : O código de status da resposta.
`statusText` : A mensagem de status correspondente ao código de status. Um novo objeto `Response()` pode ser criado com as seguintes propriedades e métodos: `arrayBuffer()` : Pega um fluxo `Response` e o lê até a conclusão. Retorna uma `Promise` que resolve com um `ArrayBuffer`. `bodyUsed` : Um valor booleano, `true` se o corpo foi lido. `headers` : O objeto `Headers` somente leitura associado ao `Response`. `json()` : Pega um fluxo `Response` e o lê até a conclusão. Retorna uma `Promise` que resolve com o resultado da análise do texto do corpo como JSON. `ok` : Um valor booleano, `true` se a resposta foi bem-sucedida (códigos de status entre 200–299). `redirected` : Um valor booleano, `true` se a resposta é o resultado de um redirecionamento. `status` : O código de status da resposta. `statusText` : A mensagem de status correspondente ao código de status. `text()` : Pega um fluxo `Response` e o lê até a conclusão. Retorna uma `Promise` que resolve com uma string. `type` : O tipo da resposta. `url` : A URL da resposta. ### ngx - `ngx.build` - `ngx.conf_file_path` - `ngx.conf_prefix` - `ngx.error_log_path` - `ngx.fetch()` - `ngx.log()` - `ngx.prefix` - `ngx.version` - `ngx.version_number` - `ngx.worker_id` O objeto global `ngx` está disponível desde 0.5.0. `ngx.build` : Uma string contendo um nome de build opcional do Angie, corresponde ao argumento `--build=name` do script configure, por padrão é `""` (0.8.0). `ngx.conf_file_path` : Uma string contendo o caminho do arquivo para o arquivo de configuração atual do Angie (0.8.0). `ngx.conf_prefix` : Uma string contendo o caminho do arquivo para o prefixo de configuração do Angie — o diretório onde o Angie está atualmente procurando pela configuração (0.7.8). `ngx.error_log_path` : Uma string contendo o caminho do arquivo para o arquivo de log de erros atual (0.8.0). `ngx.fetch(resource, [options])` : Faz uma requisição para buscar um `resource` (0.5.1), que pode ser uma URL ou o objeto `Request` (0.7.10). Retorna uma `Promise` que resolve com o objeto `Response`. Desde 0.7.0, o esquema `https://` é suportado; redirecionamentos não são tratados.
Se a URL no `resource` for especificada como um nome de domínio, ela é resolvida usando um resolvedor. Se o esquema `https://` for especificado, a diretiva `js_fetch_trusted_certificate` deve ser configurada para a autenticação do servidor HTTPS do `resource`.
O parâmetro `options` deve ser um objeto com as seguintes chaves:
`body` : Corpo da requisição, por padrão é vazio.
`buffer_size` : O tamanho do buffer para leitura da resposta, por padrão é `4096`.
`headers` : Objeto de cabeçalhos da requisição.
`max_response_body_size` : O tamanho máximo do corpo da resposta em bytes, por padrão é `32768`.
`method` : Método HTTP, por padrão o método `GET` é usado.
`verify` : Habilita ou desabilita a verificação do certificado do servidor HTTPS, por padrão é `true` (0.7.0).
Exemplo:
```javascript let reply = await ngx.fetch('http://example.com/'); let body = await reply.text();
r.return(200, body); ``` `ngx.log(level, message)` : Escreve uma mensagem no log de erros com o nível de log especificado. O parâmetro `level` especifica um dos níveis de log; o parâmetro `message` pode ser uma string ou Buffer. Os seguintes níveis de log podem ser especificados: `ngx.INFO`, `ngx.WARN` e `ngx.ERR`.
#### NOTE Como o Angie tem um limite máximo de comprimento de linha fixo, apenas os primeiros 2048 bytes da string podem ser registrados. `ngx.prefix` : Uma string contendo o caminho do arquivo para o prefixo do Angie — um diretório que mantém os arquivos do servidor (0.8.0). `ngx.version` : Uma string contendo a versão do Angie, por exemplo: `1.25.0` (0.8.0). `ngx.version_number` : Um número contendo a versão do Angie, por exemplo: `1025000` (0.8.0). `ngx.worker_id` : Um número que corresponde ao ID interno do worker do Angie, o valor está entre `0` e o valor especificado na diretiva `worker_processes` (0.8.0). ### ngx.shared O objeto global `ngx.shared` está disponível desde 0.8.0. #### SharedDict - `ngx.shared.SharedDict.add()` - `ngx.shared.SharedDict.capacity` - `ngx.shared.SharedDict.clear()` - `ngx.shared.SharedDict.delete()` - `ngx.shared.SharedDict.freeSpace()` - `ngx.shared.SharedDict.get()` - `ngx.shared.SharedDict.has()` - `ngx.shared.SharedDict.incr()` - `ngx.shared.SharedDict.items()` - `ngx.shared.SharedDict.keys()` - `ngx.shared.SharedDict.name` - `ngx.shared.SharedDict.pop()` - `ngx.shared.SharedDict.replace()` - `ngx.shared.SharedDict.set()` - `ngx.shared.SharedDict.size()` - `ngx.shared.SharedDict.type` O objeto de dicionário compartilhado está disponível desde 0.8.0. O nome, tipo e tamanho do dicionário compartilhado são definidos com a diretiva `js_shared_dict_zone` em HTTP ou Stream. Um objeto `SharedDict()` possui as seguintes propriedades e métodos: `ngx.shared.SharedDict.add(key, value [,timeout])` : Define o `value` para a `key` especificada no dicionário somente se a chave ainda não existir. O argumento `key` é uma string representando a chave do item a ser adicionado; o argumento `value` é o valor do item a ser adicionado.
O argumento opcional `timeout` é especificado em milissegundos e sobrescreve o parâmetro `timeout` da diretiva `js_shared_dict_zone` em HTTP ou Stream (desde 0.8.5). Pode ser útil quando algumas chaves devem ter timeouts únicos.
Retorna `true` se o valor foi adicionado com sucesso ao dicionário `SharedDict`; `false` se a chave já existe no dicionário. Lança `SharedMemoryError` se não houver espaço livre suficiente no dicionário `SharedDict`. Lança `TypeError` se o `value` for de um tipo diferente do esperado por este dicionário. `ngx.shared.SharedDict.capacity` : Retorna a capacidade do dicionário `SharedDict`, corresponde ao parâmetro `size` da diretiva `js_shared_dict_zone` em HTTP ou Stream. `ngx.shared.SharedDict.clear()` : Remove todos os itens do dicionário `SharedDict`. `ngx.shared.SharedDict.delete(key)` : Remove o item associado à chave especificada do dicionário `SharedDict`; `true` se o item no dicionário existia e foi removido, `false` caso contrário. `ngx.shared.SharedDict.freeSpace()` : Retorna o tamanho da página livre em bytes. Se o tamanho for zero, o dicionário `SharedDict` ainda aceitará novos valores se houver espaço nas páginas ocupadas. `ngx.shared.SharedDict.get(key)` : Recupera o item por sua `key`; retorna o valor associado à `key` ou `undefined` se não houver nenhum. `ngx.shared.SharedDict.has(key)` : Procura por um item por sua `key`; retorna `true` se tal item existe ou `false` caso contrário. `ngx.shared.SharedDict.incr(key,delta[[,init], timeout])` : Incrementa o valor inteiro associado à `key` por `delta`. O argumento `key` é uma string; o argumento `delta` é o número para incrementar ou decrementar o valor. Se a chave não existir, o item será inicializado com o argumento opcional `init`, por padrão é `0`.
O argumento opcional `timeout` é especificado em milissegundos e sobrescreve o parâmetro `timeout` da diretiva `js_shared_dict_zone` em HTTP ou Stream (desde 0.8.5). Pode ser útil quando algumas chaves devem ter timeouts únicos.
Retorna o novo valor. Lança `SharedMemoryError` se não houver espaço livre suficiente no dicionário `SharedDict`. Lança `TypeError` se este dicionário não espera números.
#### NOTE Este método pode ser usado apenas se o tipo do dicionário foi declarado com o parâmetro `type=number` da diretiva `js_shared_dict_zone` em HTTP ou Stream. `ngx.shared.SharedDict.items([maxCount])` : Retorna um array dos itens chave-valor do dicionário `SharedDict` (desde 0.8.1). O parâmetro `maxCount` define o número máximo de itens a recuperar, por padrão é `1024`. `ngx.shared.SharedDict.keys([maxCount])` : Retorna um array das chaves do dicionário `SharedDict`. O parâmetro `maxCount` define o número máximo de chaves a recuperar, por padrão é `1024`. `ngx.shared.SharedDict.name` : Retorna o nome do dicionário `SharedDict`, corresponde ao parâmetro `zone=` da diretiva `js_shared_dict_zone` em HTTP ou Stream. `ngx.shared.SharedDict.pop(key)` : Remove o item associado à `key` especificada do dicionário `SharedDict`; retorna o valor associado à `key` ou `undefined` se não houver nenhum. `ngx.shared.SharedDict.replace(key, value)` : Substitui o `value` para a `key` especificada somente se a chave já existir; retorna `true` se o valor foi substituído com sucesso, `false` se a chave não existe no dicionário `SharedDict`. Lança `SharedMemoryError` se não houver espaço livre suficiente no dicionário `SharedDict`. Lança `TypeError` se o `value` for de um tipo diferente do esperado por este dicionário. `ngx.shared.SharedDict.set(key, value [,timeout])` : Define o `value` para a `key` especificada; retorna este dicionário `SharedDict` (para encadeamento de métodos).
O argumento opcional `timeout` é especificado em milissegundos e sobrescreve o parâmetro `timeout` da diretiva `js_shared_dict_zone` em HTTP ou Stream (desde 0.8.5). Pode ser útil quando algumas chaves devem ter timeouts únicos. `ngx.shared.SharedDict.size()` : Retorna o número de itens do dicionário `SharedDict`. `ngx.shared.SharedDict.type` : Retorna `string` ou `number` que corresponde ao tipo do dicionário `SharedDict` definido pelo parâmetro `type=` da diretiva `js_shared_dict_zone` em HTTP ou Stream. ## Objetos Integrados ### console - `console.error()` - `console.info()` - `console.log()` - `console.time()` - `console.timeEnd()` - `console.warn()` O objeto `console` está disponível no Angie desde 0.8.2, no CLI desde 0.2.6. `console.error(msg[, msg2 ...])` : Exibe uma ou mais mensagens de erro. A mensagem pode ser uma string ou um objeto. `console.info(msg[, msg2 ...])` : Exibe uma ou mais mensagens de informação. A mensagem pode ser uma string ou um objeto. `console.log(msg[, msg2 ...])` : Exibe uma ou mais mensagens de log. A mensagem pode ser uma string ou um objeto. `console.time(label)` : Inicia um temporizador que pode rastrear quanto tempo uma operação leva. O parâmetro `label` permite nomear diferentes temporizadores. Se `console.timeEnd()` for chamado com o mesmo nome, o tempo decorrido desde que o temporizador foi iniciado será exibido, em milissegundos. `console.timeEnd(label)` : Para um temporizador iniciado anteriormente por `console.time()`. O parâmetro `label` permite nomear diferentes temporizadores. `console.warn(msg[, msg2 ...])` : Exibe uma ou mais mensagens de aviso. A mensagem pode ser uma string ou um objeto. ### crypto - `crypto.getRandomValues()` - `crypto.subtle.encrypt()` - `crypto.subtle.decrypt()` - `crypto.subtle.deriveBits()` - `crypto.subtle.deriveKey()` - `crypto.subtle.digest()` - `crypto.subtle.exportKey()` - `crypto.subtle.generateKey()` - `crypto.subtle.importKey()` - `crypto.subtle.sign()` - `crypto.subtle.verify()` O objeto `crypto` é um objeto global que permite usar funcionalidades criptográficas (desde 0.7.0). `crypto.getRandomValues(typedArray)` : Obtém valores aleatórios criptograficamente fortes. Retorna o mesmo array passado como `typedArray`, mas com seu conteúdo substituído pelos números aleatórios recém-gerados. Valores possíveis:
`typedArray` : Pode ser `Int8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`. `crypto.subtle.encrypt(algorithm, key, data)` : Criptografa `data` usando o `algorithm` e a `key` fornecidos. Retorna uma `Promise` que é cumprida com um `ArrayBuffer` contendo o texto cifrado. Valores possíveis:
`algorithm` : Um objeto que especifica o algoritmo a ser usado e quaisquer parâmetros extras, se necessário:
- Para `RSA-OAEP`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSA-OAEP`: ```javascript crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data) ``` - Para `AES-CTR`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-CTR`.
`counter` : Um `ArrayBuffer`, `TypedArray` ou `DataView` — o valor inicial do bloco contador, deve ter 16 bytes de comprimento (o tamanho do bloco AES). Os bits de comprimento mais à direita deste bloco são usados para o contador, e o restante é usado para o nonce. Por exemplo, se o comprimento for definido como 64, então a primeira metade do contador é o nonce e a segunda metade é usada para o contador.
`length` : O número de bits no bloco contador que são usados para o contador real. O contador deve ser grande o suficiente para que não ocorra estouro. - Para `AES-CBC`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-CBC`.
`iv` : O vetor de inicialização, é um `ArrayBuffer`, `TypedArray` ou `DataView`, deve ter 16 bytes, ser imprevisível e preferencialmente criptograficamente aleatório. No entanto, não precisa ser secreto, por exemplo, pode ser transmitido sem criptografia junto com o texto cifrado. - Para `AES-GCM`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-GCM`.
`iv` : O vetor de inicialização, é um `ArrayBuffer`, `TypedArray` ou `DataView`, deve ter 16 bytes e deve ser único para cada operação de criptografia realizada com uma determinada chave.
`additionalData` : (opcional) é um `ArrayBuffer`, `TypedArray` ou `DataView` que contém dados adicionais que não serão criptografados, mas serão autenticados junto com os dados criptografados. Se `additionalData` for especificado, então os mesmos dados devem ser especificados na chamada correspondente a `decrypt()`: se os dados fornecidos à chamada `decrypt()` não corresponderem aos dados originais, a descriptografia lançará uma exceção. O comprimento em bits de `additionalData` deve ser menor que `2^64 - 1`.
`tagLength` : (opcional, padrão é `128`) - um `number` que determina o tamanho em bits da tag de autenticação gerada na operação de criptografia e usada para autenticação na descriptografia correspondente. Valores possíveis: `32`, `64`, `96`, `104`, `112`, `120` ou `128`. A especificação AES-GCM recomenda que seja `96`, `104`, `112`, `120` ou `128`, embora `32` ou `64` bits possam ser aceitáveis em algumas aplicações.
`key` : Uma `CryptoKey` que contém a chave a ser usada para criptografia.
`data` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que contém os dados a serem criptografados (também conhecidos como texto simples). `crypto.subtle.decrypt(algorithm, key, data)` : Descriptografa dados criptografados. Retorna uma `Promise` com os dados descriptografados. Valores possíveis:
`algorithm` : Um objeto que especifica o algoritmo a ser usado e quaisquer parâmetros extras conforme necessário. Os valores fornecidos para os parâmetros extras devem corresponder àqueles passados na chamada `encrypt()` correspondente.
- Para `RSA-OAEP`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSA-OAEP`: ```javascript crypto.subtle.encrypt({name: "RSA-OAEP"}, key, data) ``` - Para `AES-CTR`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-CTR`.
`counter` : Um `ArrayBuffer`, `TypedArray` ou `DataView` — o valor inicial do bloco contador, deve ter 16 bytes de comprimento (o tamanho do bloco AES). Os bits de comprimento mais à direita deste bloco são usados para o contador, e o restante é usado para o nonce. Por exemplo, se o comprimento for definido como 64, então a primeira metade do contador é o nonce e a segunda metade é usada para o contador.
`length` : O número de bits no bloco contador que são usados para o contador real. O contador deve ser grande o suficiente para que não ocorra estouro. - Para `AES-CBC`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-CBC`.
`iv` : O vetor de inicialização, é um `ArrayBuffer`, `TypedArray` ou `DataView`, deve ter 16 bytes, ser imprevisível e preferencialmente criptograficamente aleatório. No entanto, não precisa ser secreto (por exemplo, pode ser transmitido sem criptografia junto com o texto cifrado). - Para `AES-GCM`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-GCM`.
`iv` : O vetor de inicialização, é um `ArrayBuffer`, `TypedArray` ou `DataView`, deve ter 16 bytes e deve ser único para cada operação de criptografia realizada com uma determinada chave.
`additionalData` : (opcional) é um `ArrayBuffer`, `TypedArray` ou `DataView` que contém dados adicionais que não serão criptografados, mas serão autenticados junto com os dados criptografados. Se `additionalData` for especificado, então os mesmos dados devem ser especificados na chamada correspondente a `decrypt()`: se os dados fornecidos à chamada `decrypt()` não corresponderem aos dados originais, a descriptografia lançará uma exceção. O comprimento em bits de `additionalData` deve ser menor que `2^64 - 1`.
`tagLength` : (opcional, padrão é `128`) - um `number` que determina o tamanho em bits da tag de autenticação gerada na operação de criptografia e usada para autenticação na descriptografia correspondente. Valores possíveis: `32`, `64`, `96`, `104`, `112`, `120` ou `128`. A especificação AES-GCM recomenda que seja `96`, `104`, `112`, `120` ou `128`, embora `32` ou `64` bits possam ser aceitáveis em algumas aplicações.
`key` : Uma `CryptoKey` que contém a chave a ser usada para descriptografia. Se `RSA-OAEP` for usado, esta é a propriedade `privateKey` do objeto `CryptoKeyPair`.
`data` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que contém os dados a serem descriptografados (também conhecidos como texto cifrado). `crypto.subtle.deriveBits(algorithm, baseKey, length)` : Deriva um array de bits de uma chave base. Retorna uma `Promise` que será cumprida com um `ArrayBuffer` contendo os bits derivados. Valores possíveis:
`algorithm` : Um objeto que define o algoritmo de derivação a ser usado:
- Para `HKDF`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `HKDF`.
`hash` : Uma string com o algoritmo de digest a ser usado: `SHA-1`, `SHA-256`, `SHA-384` ou `SHA-512`.
`salt` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que representa um valor aleatório ou pseudo-aleatório com o mesmo comprimento da saída da função `digest`. Ao contrário do material de chave de entrada passado para `deriveKey()`, o salt não precisa ser mantido em segredo.
`info` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que representa informações contextuais específicas da aplicação usadas para vincular a chave derivada a uma aplicação ou contexto, e permite derivar chaves diferentes para contextos diferentes enquanto usa o mesmo material de chave de entrada. Esta propriedade é obrigatória, mas pode ser um buffer vazio. - Para `PBKDF2`, passe um objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `PBKDF2`.
`hash` : Uma string com o algoritmo de digest a ser usado: `SHA-1`, `SHA-256`, `SHA-384` ou `SHA-512`.
`salt` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que representa um valor aleatório ou pseudo-aleatório de pelo menos `16` bytes. Ao contrário do material de chave de entrada passado para `deriveKey()`, o salt não precisa ser mantido em segredo.
`iterations` : Um `number` que representa o número de vezes que a função hash será executada em `deriveKey()`. - Para `ECDH`, passe o objeto com as seguintes chaves (desde 0.9.1):
`name` : Uma string, deve ser definida como `ECDH`.
`public` : Uma `CryptoKey` que representa a chave pública da outra parte. A chave deve ser gerada usando a mesma curva que a chave base. `iterations` : > > Um `number` que representa o número de vezes que a função hash será executada em `deriveKey()`. > - Para `ECDH`, passe o objeto com as seguintes chaves (desde 0.9.1):
> `name` > : Uma string, deve ser definida como `ECDH`.
> `public` > : Uma `CryptoKey` que representa a chave pública da outra parte. A chave deve ser gerada usando a mesma curva que a chave base.
`baseKey` : Uma `CryptoKey` que representa a entrada para o algoritmo de derivação - o material de chave inicial para a função de derivação: por exemplo, para `PBKDF2` pode ser uma senha, importada como uma `CryptoKey` usando `crypto.subtle.importKey()`.
`length` : Um número que representa o número de bits a derivar. Para compatibilidade com navegadores, o número deve ser um múltiplo de `8`. `crypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)` : Deriva uma chave secreta de uma chave mestra. Valores possíveis:
`algorithm` : Um objeto que define o algoritmo de derivação a ser usado:
- Para `HKDF`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `HKDF`.
`hash` : Uma string com o algoritmo de digest a ser usado: `SHA-1`, `SHA-256`, `SHA-384`, ou `SHA-512`.
`salt` : Um `ArrayBuffer`, `TypedArray`, ou `DataView` que representa um valor aleatório ou pseudo-aleatório com o mesmo comprimento da saída da função `digest`. Diferentemente do material de chave de entrada passado para `deriveKey()`, o salt não precisa ser mantido em segredo.
`info` : Um `ArrayBuffer`, `TypedArray`, ou `DataView` que representa informações contextuais específicas da aplicação usadas para vincular a chave derivada a uma aplicação ou contexto, e permite derivar chaves diferentes para contextos diferentes enquanto usa o mesmo material de chave de entrada. Esta propriedade é obrigatória, mas pode ser um buffer vazio. - Para `PBKDF2`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `PBKDF2`.
`hash` : Uma string com o algoritmo de digest a ser usado: `SHA-1`, `SHA-256`, `SHA-384`, ou `SHA-512`.
`salt` : Um `ArrayBuffer`, `TypedArray`, ou `DataView` que representa um valor aleatório ou pseudo-aleatório de pelo menos `16` bytes. Diferentemente do material de chave de entrada passado para `deriveKey()`, o salt não precisa ser mantido em segredo.
`iterations` : Um `number` que representa o número de vezes que a função hash será executada em `deriveKey()`. - Para `ECDH`, passe o objeto com as seguintes chaves (desde 0.9.1):
`name` : Uma string, deve ser definida como `ECDH`.
`publicKey` : Uma `CryptoKey` que representa a chave pública da outra parte. A chave deve ser gerada usando a mesma curva que a chave base.
`baseKey` : Uma `CryptoKey` que representa a entrada para o algoritmo de derivação - o material de chave inicial para a função de derivação: por exemplo, para `PBKDF2` pode ser uma senha, importada como uma `CryptoKey` usando `crypto.subtle.importKey()`.
`derivedKeyAlgorithm` : Um objeto que define o algoritmo para o qual a chave derivada será usada:
- Para `HMAC`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `HMAC`.
`hash` : Uma string com o nome da função de digest a ser usada: `SHA-1`, `SHA-256`, `SHA-384`, ou `SHA-512`.
`length` : (opcional) é um `number` que representa o comprimento em bits da chave. Se não especificado, o comprimento da chave é igual ao tamanho do bloco da função hash escolhida. - Para `AES-CTR`, `AES-CBC`, ou `AES-GCM`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `AES-CTR`, `AES-CBC`, ou `AES-GCM`, dependendo do algoritmo usado.
`length` : Um `number` que representa o comprimento em bits da chave a ser gerada: `128`, `192`, ou `256`.
`extractable` : Um valor booleano que indica se será possível exportar a chave.
`keyUsages` : Um `Array` que indica o que pode ser feito com a chave derivada. Os usos da chave devem ser permitidos pelo algoritmo definido em `derivedKeyAlgorithm`. Valores possíveis:
`encrypt` : Chave para criptografar mensagens.
`decrypt` : Chave para descriptografar mensagens.
`sign` : Chave para assinar mensagens.
`verify` : Chave para verificar assinaturas.
`deriveKey` : Chave para derivar uma nova chave.
`deriveBits` : Chave para derivar bits.
`wrapKey` : Chave para encapsular uma chave.
`unwrapKey` : Chave para desencapsular uma chave. `crypto.subtle.digest(algorithm, data)` : Gera um digest dos dados fornecidos. Recebe como argumentos um identificador para o algoritmo de digest a ser usado e os dados a serem processados. Retorna uma `Promise` que será cumprida com o digest. Valores possíveis:
`algorithm` : Uma string que define a função hash a ser usada: `SHA-1` (não para aplicações criptográficas), `SHA-256`, `SHA-384`, ou `SHA-512`.
`data` : Um `ArrayBuffer`, `TypedArray`, ou `DataView` que contém os dados a serem processados. `crypto.subtle.exportKey(format, key)` : Exporta uma chave: recebe uma chave como um objeto `CryptoKey` e retorna a chave em um formato externo e portável (desde 0.7.10). Se o `format` for `jwk`, então a `Promise` é cumprida com um objeto JSON contendo a chave. Caso contrário, a promise é cumprida com um `ArrayBuffer` contendo a chave. Valores possíveis:
`format` : Uma string que descreve o formato de dados no qual a chave deve ser exportada, pode ser o seguinte:
`raw` : O formato de dados brutos.
`pkcs8` : O formato [PKCS #8](https://datatracker.ietf.org/doc/html/rfc5208).
`spki` : O formato [SubjectPublicKeyInfo](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
`jwk` : O formato [JSON Web Key](https://datatracker.ietf.org/doc/html/rfc7517) (JWK) (desde 0.7.10).
`key` : A `CryptoKey` que contém a chave a ser exportada. `crypto.subtle.generateKey(algorithm, extractable, usage)` : Gera uma nova chave para algoritmos simétricos ou par de chaves para algoritmos de chave pública (desde 0.7.10). Retorna uma `Promise` que é cumprida com a chave gerada como um objeto `CryptoKey` ou `CryptoKeyPair`. Valores possíveis:
`algorithm` : Um objeto de dicionário que define o tipo de chave a ser gerada e fornece parâmetros extras específicos do algoritmo:
- Para `RSASSA-PKCS1-v1_5`, `RSA-PSS`, ou `RSA-OAEP`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSASSA-PKCS1-v1_5`, `RSA-PSS`, ou `RSA-OAEP`, dependendo do algoritmo usado.
`hash` : Uma string que representa o nome da função `digest` a ser usada, pode ser `SHA-256`, `SHA-384`, ou `SHA-512`. - Para `ECDSA`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `ECDSA`.
`namedCurve` : Uma string que representa o nome da curva elíptica a ser usada, pode ser `P-256`, `P-384`, ou `P-521`. - Para `HMAC`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `HMAC`.
`hash` : Uma string que representa o nome da função `digest` a ser usada, pode ser `SHA-256`, `SHA-384`, ou `SHA-512`.
`length` : (opcional) é um número que representa o comprimento em bits da chave. Se omitido, o comprimento da chave é igual ao comprimento do digest gerado pela função de digest escolhida. - Para `AES-CTR`, `AES-CBC`, ou `AES-GCM`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `, onde `ALGORITHM` é o nome do algoritmo. - Para `ECDH`, passe o objeto com as seguintes chaves (desde 0.9.1):
`name` : Uma string, deve ser definida como `ECDH`.
`namedCurve` : Uma string que representa o nome da curva elíptica a ser usada, pode ser `P-256`, `P-384`, ou `P-521`.
`extractable` : Valor booleano que indica se é possível exportar a chave.
`usage` : Um `array` que indica ações possíveis com a chave:
`encrypt` : Chave para criptografar mensagens.
`decrypt` : Chave para descriptografar mensagens.
`sign` : Chave para assinar mensagens.
`verify` : Chave para verificar assinaturas.
`deriveKey` : Chave para derivar uma nova chave.
`deriveBits` : Chave para derivar bits.
`wrapKey` : Chave para encapsular uma chave.
`unwrapKey` : Chave para desencapsular uma chave. `crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages)` : Importa uma chave: recebe como entrada uma chave em um formato externo e portável e fornece um objeto `CryptoKey`. Retorna uma `Promise` que é cumprida com a chave importada como um objeto `CryptoKey`. Valores possíveis:
`format` : Uma string que descreve o formato de dados da chave a ser importada, pode ser o seguinte:
`raw` : O formato de dados brutos.
`pkcs8` : O formato [PKCS #8](https://datatracker.ietf.org/doc/html/rfc5208).
`spki` : O formato [SubjectPublicKeyInfo](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
`jwk` : O formato [JSON Web Key](https://datatracker.ietf.org/doc/html/rfc7517) (JWK) (desde 0.7.10).
`keyData` : O objeto `ArrayBuffer`, `TypedArray` ou `DataView` que contém a chave no formato fornecido.
`algorithm` : Um objeto de dicionário que define o tipo de chave a ser importada e fornece parâmetros extras específicos do algoritmo:
- Para `RSASSA-PKCS1-v1_5`, `RSA-PSS` ou `RSA-OAEP`, passe o objeto com as seguintes chaves: `crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages)` : Importa uma chave: recebe como entrada uma chave em um formato externo e portável e fornece um objeto `CryptoKey`. Retorna uma `Promise` que é cumprida com a chave importada como um objeto `CryptoKey`. Valores possíveis:
`format` : Uma string que descreve o formato de dados da chave a ser importada, pode ser o seguinte:
`raw` : O formato de dados brutos.
`pkcs8` : O formato [PKCS #8](https://datatracker.ietf.org/doc/html/rfc5208).
`spki` : O formato [SubjectPublicKeyInfo](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
`jwk` : O formato [JSON Web Key](https://datatracker.ietf.org/doc/html/rfc7517) (JWK) (desde 0.7.10).
`keyData` : O objeto `ArrayBuffer`, `TypedArray` ou `DataView` que contém a chave no formato fornecido.
`algorithm` : Um objeto dicionário que define o tipo de chave a ser importada e fornece parâmetros extras específicos do algoritmo:
- Para `RSASSA-PKCS1-v1_5`, `RSA-PSS` ou `RSA-OAEP`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSASSA-PKCS1-v1_5`, `RSA-PSS` ou `RSA-OAEP`, dependendo do algoritmo usado.
`hash` : Uma string que representa o nome da função `digest` a ser usada, pode ser `SHA-1`, `SHA-256`, `SHA-384` ou `SHA-512`. - Para `ECDSA`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `ECDSA`.
`namedCurve` : Uma string que representa o nome da curva elíptica a ser usada, pode ser `P-256`, `P-384` ou `P-521`. - Para `HMAC`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `HMAC`.
`hash` : Uma string que representa o nome da função `digest` a ser usada, pode ser `SHA-256`, `SHA-384` ou `SHA-512`.
`length` : (opcional) é um número que representa o comprimento em bits da chave. Se omitido, o comprimento da chave é igual ao comprimento do digest gerado pela função digest escolhida. - Para `AES-CTR`, `AES-CBC` ou `AES-GCM`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `, onde `ALGORITHM` é o nome do algoritmo. - Para `PBKDF2`, passe a string `PBKDF2`. - Para `HKDF`, passe a string `HKDF`. - Para `ECDH`, passe o objeto com as seguintes chaves (desde 0.9.1):
`name` : Uma string, deve ser definida como `ECDH`.
`namedCurve` : Uma string que representa o nome da curva elíptica a ser usada, pode ser `P-256`, `P-384` ou `P-521`.
`extractable` : Valor booleano que indica se é possível exportar a chave.
`keyUsages` : Um `array` que indica ações possíveis com a chave:
`encrypt` : Chave para criptografar mensagens.
`decrypt` : Chave para descriptografar mensagens.
`sign` : Chave para assinar mensagens.
`verify` : Chave para verificar assinaturas.
`deriveKey` : Chave para derivar uma nova chave.
`deriveBits` : Chave para derivar bits.
`wrapKey` : Chave para empacotar uma chave.
`unwrapKey` : Chave para desempacotar uma chave. `crypto.subtle.sign(algorithm, key, data)` : Retorna `signature` como uma `Promise` que é cumprida com um `ArrayBuffer` contendo a assinatura. Valores possíveis:
`algorithm` : Uma string ou objeto que especifica o algoritmo de assinatura a ser usado e seus parâmetros:
- Para `RSASSA-PKCS1-v1_5`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `. - Para `RSA-PSS`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSA-PSS`.
`saltLength` : Um `integer` longo que representa o comprimento do salt aleatório a ser usado, em bytes. - Para `ECDSA`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `ECDSA`.
`hash` : Um identificador para o algoritmo digest a ser usado, pode ser `SHA-256`, `SHA-384` ou `SHA-512`. - Para `HMAC`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `.
`key` : Um objeto `CryptoKey` que contém a chave a ser usada para assinatura. Se o algoritmo identifica um criptossistema de chave pública, esta é a chave privada.
`data` : Um objeto `ArrayBuffer`, `TypedArray` ou `DataView` que contém os dados a serem assinados. `crypto.subtle.verify(algorithm, key, signature, data)` : Verifica uma assinatura digital; retorna uma `Promise` que é cumprida com um valor booleano: `true` se a assinatura for válida, caso contrário `false`. Valores possíveis:
`algorithm` : Uma string ou objeto que especifica o algoritmo a ser usado e seus parâmetros:
- Para `RSASSA-PKCS1-v1_5`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `. - Para `RSA-PSS`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `RSA-PSS`.
`saltLength` : Um `integer` longo que representa o comprimento do salt aleatório a ser usado, em bytes. - Para `ECDSA`, passe o objeto com as seguintes chaves:
`name` : Uma string, deve ser definida como `ECDSA`.
`hash` : Um identificador para o algoritmo digest a ser usado, pode ser `SHA-256`, `SHA-384` ou `SHA-512`. - Para `HMAC`, passe a string identificando o algoritmo ou um objeto da forma ` *"name": "ALGORITHM"* `.
`key` : Um objeto `CryptoKey` que contém a chave a ser usada para verificação. É a chave secreta para um algoritmo simétrico e a chave pública para um sistema de chave pública.
`signature` : Um `ArrayBuffer`, `TypedArray` ou `DataView` que contém a assinatura a ser verificada.
`data` : Um objeto `ArrayBuffer`, `TypedArray` ou `DataView` que contém os dados cuja assinatura deve ser verificada. #### CryptoKey - `CryptoKey.algorithm` - `CryptoKey.extractable` - `CryptoKey.type` - `CryptoKey.usages` O objeto `CryptoKey` representa uma `chave` criptográfica obtida de um dos métodos `SubtleCrypto`: `crypto.subtle.generateKey()`, `crypto.subtle.deriveKey()`, `crypto.subtle.importKey()`. `CryptoKey.algorithm` : Retorna um objeto descrevendo o algoritmo para o qual esta chave pode ser usada e quaisquer parâmetros extras associados (desde 0.8.0), somente leitura. `CryptoKey.extractable` : Um valor booleano, `true` se a chave pode ser exportada (desde 0.8.0), somente leitura. `CryptoKey.type` : Um valor string que indica qual tipo de chave é representado pelo objeto, somente leitura. Valores possíveis:
`secret` : Esta chave é uma chave secreta para uso com um algoritmo simétrico.
`private` : Esta chave é a metade privada de um `CryptoKeyPair` de algoritmo assimétrico.
`public` : Esta chave é a metade pública de um `CryptoKeyPair` de algoritmo assimétrico. `CryptoKey.usages` : Um array de strings indicando para que esta chave pode ser usada (desde 0.8.0), somente leitura. Valores possíveis do array:
`encrypt` : Chave para criptografar mensagens.
`decrypt` : Chave para descriptografar mensagens.
`sign` : Chave para assinar mensagens.
`verify` : Chave para verificar assinaturas.
`deriveKey` : Chave para derivar uma nova chave.
`deriveBits` : Chave para derivar bits. #### CryptoKeyPair - `CryptoKeyPair.privateKey` - `CryptoKeyPair.publicKey` O `CryptoKeyPair` é um objeto dicionário da API WebCrypto que representa um par de chaves assimétricas. `CryptoKeyPair.privateKey` : Um objeto `CryptoKey` representando a chave privada. `CryptoKeyPair.publicKey` : Um objeto `CryptoKey` representando a chave pública. ### njs - `njs.version` - `njs.version_number` - `njs.dump()` - `njs.memoryStats` - `njs.on()` O objeto `njs` é um objeto global que representa a instância atual da VM (desde 0.2.0). `njs.version` : Retorna uma string com a versão atual do NJS (por exemplo, "0.7.4"). `njs.version_number` : Retorna um número com a versão atual do NJS. Por exemplo, "0.7.4" é retornado como `0x000704` (desde 0.7.4). `njs.dump(value)` : Retorna a representação em string formatada de um valor. `njs.memoryStats` : Objeto contendo estatísticas de memória para a instância atual da VM (desde 0.7.8).
`size` : Quantidade de memória em bytes que o pool de memória do NJS reivindicou do sistema operacional. `njs.on(event, callback)` : Registra um callback para o evento de VM especificado (desde 0.5.2). Um evento pode ser uma das seguintes strings:
`exit` : É chamado antes da VM ser destruída. O callback é chamado sem argumentos. ### process - `process.argv` - `process.env` - `process.kill()` - `process.pid` - `process.ppid` O objeto `process` é um objeto global que fornece informações sobre o processo atual (0.3.3). `process.argv` : Retorna um array que contém os argumentos de linha de comando passados quando o processo atual foi iniciado. `process.env` : Retorna um objeto contendo o ambiente do usuário.
#### NOTE Por padrão, o Angie remove todas as variáveis de ambiente herdadas de seu processo pai, exceto a variável TZ. Use a diretiva `env` para preservar algumas das variáveis herdadas. `process.kill(pid, number | string)` : Envia o sinal para o processo identificado por `pid`. Nomes de sinais são números ou strings como `SIGINT` ou `SIGHUP`. Veja [kill(2)](https://man7.org/linux/man-pages/man2/kill.2.html) para mais informações. `process.pid` : Retorna o PID do processo atual. `process.ppid` : Retorna o PID do processo pai atual. ### String Por padrão, todas as strings no NJS são strings Unicode. Elas correspondem a strings ECMAScript que contêm caracteres Unicode. Antes da versão 0.8.0, strings de bytes também eram suportadas. #### Strings de Bytes (Removidas) #### NOTE Desde a versão 0.8.0, o suporte para strings de bytes e métodos de strings de bytes foi removido. Ao trabalhar com sequências de bytes, o objeto [Buffer](#njs-buffer) e propriedades Buffer, como `r.requestBuffer`, `r.rawVariables`, devem ser usados. Strings de bytes continham uma sequência de bytes e eram usadas para serializar strings Unicode para dados externos e desserializar de fontes externas. Por exemplo, o método `toUTF8()` serializava uma string Unicode para uma string de bytes usando codificação UTF-8. O método `toBytes()` serializava uma string Unicode com pontos de código até 255 em uma string de bytes; caso contrário, `null` era retornado. Os seguintes métodos se tornaram obsoletos e foram removidos na versão 0.8.0: - `String.bytesFrom()` (removido na 0.8.0, use `Buffer.from()`) - `String.prototype.fromBytes()` (removido na 0.8.0) - `String.prototype.fromUTF8()` (removido na 0.8.0, use `TextDecoder`) - `String.prototype.toBytes()` (removido na 0.8.0) - `String.prototype.toString()` com codificação (removido na 0.8.0) - `String.prototype.toUTF8()` (removido na 0.8.0, use `TextEncoder`) ## Web API ### TextDecoder - `TextDecoder()` - `TextDecoder.prototype.encoding` - `TextDecoder.prototype.fatal` - `TextDecoder.prototype.ignoreBOM` - `TextDecoder.prototype.decode()` O `TextDecoder` produz um fluxo de pontos de código a partir de um fluxo de bytes (0.4.3). `TextDecoder([[encoding], options])` : Cria um novo objeto `TextDecoder` para a `codificação` especificada; atualmente, apenas UTF-8 é suportado. O `options` é um dicionário `TextDecoderOptions` com a propriedade:
`fatal` : Flag booleana indicando se `TextDecoder.decode()` deve lançar a exceção `TypeError` quando um erro de codificação é encontrado, por padrão é `false`. `TextDecoder.prototype.encoding` : Retorna uma string com o nome da codificação usada por `TextDecoder()`, somente leitura. `TextDecoder.prototype.fatal` : Flag booleana, `true` se o modo de erro é fatal, somente leitura. `TextDecoder.prototype.ignoreBOM` : Flag booleana, `true` se o marcador de ordem de byte é ignorado, somente leitura. `TextDecoder.prototype.decode(buffer, [options])` : Retorna uma string com o texto decodificado do `buffer` por `TextDecoder()`. O buffer pode ser `ArrayBuffer`. O `options` é um dicionário `TextDecodeOptions` com a propriedade:
`stream` : Flag booleana indicando se dados adicionais seguirão em chamadas subsequentes para `decode()`: `true` se processando os dados em pedaços, e `false` para o pedaço final ou se os dados não estão em pedaços. Por padrão é `false`.
Exemplo:
```javascript >> (new TextDecoder()).decode(new Uint8Array([206,177,206,178])) αβ ``` ### TextEncoder - `TextEncoder()` - `TextEncoder.prototype.encode()` - `TextEncoder.prototype.encodeInto()` O objeto `TextEncoder` produz um fluxo de bytes com codificação UTF-8 a partir de um fluxo de pontos de código (0.4.3). `TextEncoder()` : Retorna um `TextEncoder` recém-construído que gerará um fluxo de bytes com codificação UTF-8. `TextEncoder.prototype.encode(string)` : Codifica `string` em um `Uint8Array` com texto codificado em UTF-8. `TextEncoder.prototype.encodeInto(string, uint8Array)` : Codifica uma `string` para UTF-8, coloca o resultado no `Uint8Array` de destino e retorna um objeto dicionário que mostra o progresso da codificação. O objeto dicionário contém dois membros:
`read` : O número de unidades UTF-16 de código da `string` de origem convertidas para UTF-8.
`written` : O número de bytes modificados no `Uint8Array` de destino. ## Timers - `clearTimeout()` - `setTimeout()` `clearTimeout(timeout)` : Cancela um objeto `timeout` criado por `setTimeout()`. `setTimeout(function, milliseconds[, argument1, argumentN])` : Chama uma `função` após um número especificado de `milissegundos`. Um ou mais `argumentos` opcionais podem ser passados para a função especificada. Retorna um objeto `timeout`.
Exemplo:
```javascript function handler(v) { // ... }
t = setTimeout(handler, 12);
// ...
clearTimeout(t); ``` ### Funções Globais - `atob()` - `btoa()` `atob(encodedData)` : Decodifica uma string de dados que foi codificada usando codificação `Base64`. O parâmetro `encodedData` é uma string binária que contém dados codificados em Base64. Retorna uma string que contém dados decodificados de `encodedData`.
O método similar `btoa()` pode ser usado para codificar e transmitir dados que, de outra forma, poderiam causar problemas de comunicação, depois transmiti-los e usar o método `atob()` para decodificar os dados novamente. Por exemplo, você pode codificar, transmitir e decodificar caracteres de controle como valores ASCII de `0` a `31`.
Exemplo:
```javascript const encodedData = btoa("text to encode"); // encode a string const decodedData = atob(encodedData); // decode the string ``` `btoa(stringToEncode)` : Cria uma string ASCII codificada em Base64 a partir de uma string binária. O parâmetro `stringToEncode` é uma string binária a ser codificada. Retorna uma string ASCII contendo a representação Base64 de `stringToEncode`.
O método pode ser usado para codificar dados que, de outra forma, poderiam causar problemas de comunicação, transmiti-los e depois usar o método `atob()` para decodificar os dados novamente. Por exemplo, você pode codificar caracteres de controle como valores ASCII de `0` a `31`.
Exemplo:
```javascript const encodedData = btoa("text to encode"); // encode a string const decodedData = atob(encodedData); // decode the string ``` ## Módulos Integrados ### Buffer O objeto `Buffer` é uma forma compatível com Node.js de trabalhar com dados binários. Devido ao tamanho extenso do arquivo, esta seção está limitada a uma lista abrangente de métodos Buffer. - `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()` Para documentação detalhada dos métodos Buffer, consulte a [documentação Buffer do Node.js](https://nodejs.org/api/buffer.html). ### Crypto O módulo Crypto fornece suporte à funcionalidade criptográfica. O objeto do módulo Crypto é importado usando `import crypto from 'crypto'`. #### NOTE Desde a versão 0.7.0, a API crypto estendida está disponível como um objeto global [crypto](#njs-builtin-crypto). - `crypto.createHash()` - `crypto.createHmac()` `crypto.createHash(algorithm)` : Cria e retorna um objeto Hash que pode ser usado para gerar resumos hash usando o `algorithm` fornecido. O algoritmo pode ser `md5`, `sha1` e `sha256`. `crypto.createHmac(algorithm, secret key)` : Cria e retorna um objeto HMAC que usa o `algorithm` e a `secret key` fornecidos. O algoritmo pode ser `md5`, `sha1` e `sha256`. #### Hash - `hash.update()` - `hash.digest()` `hash.update(data)` : Atualiza o conteúdo do hash com os `data` fornecidos. `hash.digest([encoding])` : Calcula o resumo de todos os dados passados usando `hash.update()`. A codificação pode ser `hex`, `base64` e `base64url`. Se a codificação não for fornecida, um objeto Buffer é retornado (0.4.4).
#### NOTE Antes da versão 0.4.4, uma string de bytes era retornada em vez de um objeto Buffer. `hash.copy()` : Faz uma cópia do estado atual do hash (desde 0.7.12). Exemplo: ```javascript import crypto from 'crypto'; crypto.createHash('sha1').update('A').update('B').digest('base64url'); /* BtlFlCqiamG-GMPiK_GbvKjdK10 */ ``` #### HMAC - `hmac.update()` - `hmac.digest()` `hmac.update(data)` : Atualiza o conteúdo do HMAC com os `data` fornecidos. `hmac.digest([encoding])` : Calcula o resumo HMAC de todos os dados passados usando `hmac.update()`. A codificação pode ser `hex`, `base64` e `base64url`. Se a codificação não for fornecida, um objeto Buffer é retornado (0.4.4).
#### NOTE Antes da versão 0.4.4, uma string de bytes era retornada em vez de um objeto Buffer. ### fs O módulo `fs` fornece operações com o sistema de arquivos. O objeto do módulo é importado usando `import fs from 'fs'`. - `fs.accessSync()` - `fs.appendFileSync()` - `fs.mkdirSync()` - `fs.readdirSync()` - `fs.readFileSync()` - `fs.realpathSync()` - `fs.renameSync()` - `fs.rmdirSync()` - `fs.symlinkSync()` - `fs.unlinkSync()` - `fs.writeFileSync()` - `fs.promises.readFile()` - `fs.promises.appendFile()` - `fs.promises.writeFile()` - `fs.promises.readdir()` - `fs.promises.mkdir()` - `fs.promises.rmdir()` - `fs.promises.rename()` - `fs.promises.unlink()` - `fs.promises.symlink()` - `fs.promises.access()` - `fs.promises.realpath()` Para documentação detalhada dos métodos fs, consulte a [documentação fs do Node.js](https://nodejs.org/api/fs.html). ### Query String O módulo Query String fornece métodos para analisar e formatar strings de consulta de URL. O objeto do módulo é importado usando `import qs from 'querystring'`. - `querystring.decode()` - `querystring.encode()` - `querystring.escape()` - `querystring.parse()` - `querystring.stringify()` - `querystring.unescape()` `querystring.decode()` : Um alias para `querystring.parse()`. `querystring.encode()` : Um alias para `querystring.stringify()`. `querystring.escape(string)` : Executa a codificação percentual de URL da `string` de maneira otimizada para os requisitos de strings de consulta de URL. O método é usado por `querystring.stringify()` e não deve ser usado diretamente. `querystring.parse(string[, separator[, equal[, options]]])` : Analisa a `string` como uma string de consulta de URL e retorna um objeto. O parâmetro opcional `separator` (padrão: `&`) especifica a substring para delimitar pares chave-valor. O parâmetro opcional `equal` (padrão: `=`) especifica a substring para delimitar chaves e valores. O parâmetro opcional `options` é um objeto que pode conter as seguintes propriedades:
`decodeURIComponent` : Função a ser usada ao decodificar caracteres codificados em percentual na string de consulta, padrão: `querystring.unescape()`.
`maxKeys` : O número máximo de chaves a serem analisadas, padrão: `1000`. O valor `0` remove limitações para contagem de chaves.
Exemplo:
```javascript >> qs.parse('foo=bar&abc=xyz&abc=123') { foo: 'bar', abc: ['xyz', '123'] } ``` `querystring.stringify(object[, separator[, equal[, options]]])` : Produz uma string de consulta de URL a partir do `object` iterando através de suas próprias propriedades. O parâmetro opcional `separator` (padrão: `&`) especifica a substring para delimitar pares chave-valor. O parâmetro opcional `equal` (padrão: `=`) especifica a substring para delimitar chaves e valores. O parâmetro opcional `options` é um objeto que pode conter a seguinte propriedade:
`encodeURIComponent` : Função a ser usada ao converter caracteres inseguros para URL em codificação percentual na string de consulta, padrão: `querystring.escape()`.
Exemplo:
```javascript >> qs.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' }) 'foo=bar&baz=qux&baz=quux&corge=' ``` `querystring.unescape(string)` : Executa a decodificação de caracteres codificados em percentual de URL na `string`. O método é usado por `querystring.parse()` e não deve ser usado diretamente. ### XML - `xml.parse()` - `xml.c14n()` - `xml.exclusiveC14n()` - `xml.serialize()` - `xml.serializeToString()` - `XMLDoc` - `XMLNode` - `XMLAttr` O módulo XML permite trabalhar com documentos XML (desde 0.7.10). O objeto do módulo XML é importado usando `import xml from 'xml'`. Exemplo: ```javascript import xml from 'xml'; let data = `ToveJani`; 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) /* 'ToveJani' */ c14n = dec.decode(xml.exclusiveC14n(doc.note.to)); console.log(c14n) /* 'Tove' */ c14n = dec.decode(xml.exclusiveC14n(doc.note, doc.note.to /* excluding 'to' */)); console.log(c14n) /* 'Jani' */ ``` `parse(string | Buffer)` : Analisa uma string ou Buffer de um documento XML; retorna um objeto wrapper `XMLDoc` representando o documento XML analisado. `c14n(root_node[, excluding_node])` : Canonicaliza `root_node` e seus filhos de acordo com [Canonical XML Version 1.1](https://www.w3.org/TR/xml-c14n). O `root_node` pode ser um objeto wrapper `XMLNode` ou `XMLDoc` em torno da estrutura XML. Retorna um objeto Buffer que contém a saída canonicalizada.
`excluding_node` : Permite omitir da saída uma parte do documento. `exclusiveC14n(root_node[, excluding_node[, withComments[,prefix_list]]])` : Canonicaliza `root_node` e seus filhos de acordo com [Exclusive XML Canonicalization Version 1.0](https://www.w3.org/TR/xml-exc-c14n/).
`root_node` : Um objeto wrapper `XMLNode` ou `XMLDoc` em torno da estrutura XML.
`excluding_node` : Permite omitir da saída uma parte do documento correspondente ao nó e seus filhos.
`withComments` : Um valor booleano, `false` por padrão. Se `true`, a canonicalização corresponde a [Exclusive XML Canonicalization Version 1.0](http://www.w3.org/2001/10/xml-exc-c14n#WithComments). Retorna um objeto Buffer que contém a saída canonicalizada.
`prefix_list` : Uma string opcional com prefixos de namespace separados por espaço para namespaces que também devem ser incluídos na saída. `serialize()` : O mesmo que `xml.c14n()` (desde 0.7.11). `serializeToString()` : O mesmo que `xml.c14n()` exceto que retorna o resultado como uma `string` (desde 0.7.11). `XMLDoc` : Um objeto wrapper XMLDoc em torno da estrutura XML, o nó raiz do documento.
> `doc.$root` > : A raiz do documento por seu nome ou undefined.
> `doc.abc` > : A primeira tag raiz chamada `abc` como um objeto wrapper `XMLNode`. `XMLNode` : Um objeto wrapper XMLNode em torno de um nó de tag XML.
> `node.abc` > : O mesmo que `node.$tag$abc`.
> `node.$attr$abc` > : O valor do atributo `abc` do nó, gravável desde 0.7.11.
> `node.$attr$abc=xyz` > : O mesmo que `node.setAttribute('abc', xyz)` (desde 0.7.11).
> `node.$attrs` > : Um objeto wrapper `XMLAttr` para todos os atributos do nó.
> `node.$name` > : O nome do nó.
> `node.$ns` > : O namespace do nó.
> `node.$parent` > : O nó pai do nó atual.
> `node.$tag$abc` > : A primeira tag filha do nó chamada `abc`, gravável desde 0.7.11.
> `node.$tags` > : Um array de todas as tags filhas.
> `node.$tags = [node1, node2, ...]` > : O mesmo que `node.removeChildren()`; `node.addChild(node1)`; `node.addChild(node2)` (desde 0.7.11).
> `node.$tags$abc` > : Todas as tags filhas chamadas `abc` do nó, gravável desde 0.7.11.
> `node.$text` > : O conteúdo do nó, gravável desde 0.7.11.
> `node.$text = 'abc'` > : O mesmo que `node.setText('abc')` (desde 0.7.11).
> `node.addChild(nd)` > : Adiciona um XMLNode como filho ao nó (desde 0.7.11). `nd` é copiado recursivamente antes de ser adicionado ao nó.
> `node.removeAllAttributes()` > : Remove todos os atributos do nó (desde 0.7.11).
> `node.removeAttribute(attr_name)` > : Remove o atributo chamado `attr_name` (desde 0.7.11).
> `node.removeChildren(tag_name)` > : Remove todas as tags filhas chamadas `tag_name` (desde 0.7.11). Se `tag_name` estiver ausente, todas as tags filhas são removidas.
> `node.removeText()` > : Remove o valor de texto do nó (0.7.11).
> `node.setAttribute(attr_name, value)` > : Define um valor para `attr_name` (desde 0.7.11). Quando o valor é `null`, o atributo chamado `attr_name` é excluído.
> `node.setText(value)` > : Define um valor de texto para o nó (desde 0.7.11). Quando o valor é `null`, o texto do nó é excluído. `XMLAttr` : Um objeto wrapper XMLAttr em torno dos atributos do nó XML.
> `attr.abc` > : O valor do atributo `abc`. ### zlib O módulo `zlib` (0.5.2) fornece funcionalidade de compressão e descompressão usando zlib. O objeto do módulo é importado usando `import zlib from 'zlib'`. - `zlib.constants` - `zlib.deflateRawSync()` - `zlib.deflateSync()` - `zlib.inflateRawSync()` - `zlib.inflateSync()` `zlib.constants` : Retorna um dicionário de constantes zlib. `zlib.deflateRawSync(data[, options])` : Comprime `data` usando o algoritmo Deflate sem o cabeçalho zlib. `zlib.deflateSync(data[, options])` : Comprime `data` usando o algoritmo Deflate. `zlib.inflateRawSync(data[, options])` : Descomprime `data` usando o algoritmo Deflate sem o cabeçalho zlib. `zlib.inflateSync(data[, options])` : Descomprime `data` usando o algoritmo Deflate. O parâmetro `options` é um objeto que pode conter as seguintes propriedades: `level` : Nível de compressão (padrão: `zlib.constants.Z_DEFAULT_COMPRESSION`). `memLevel` : Especifica quanta memória deve ser alocada para o estado de compressão (padrão: `zlib.constants.Z_DEFAULT_MEMLEVEL`). `strategy` : Ajusta o algoritmo de compressão (padrão: `zlib.constants.Z_DEFAULT_STRATEGY`). `windowBits` : Define o tamanho da janela (padrão: `zlib.constants.Z_DEFAULT_WINDOWBITS`). `dictionary` : Buffer contendo o dicionário de compressão predefinido. `info` : Um valor booleano, se `true`, retorna um objeto com buffer e engine. `chunkSize` : Tamanho do bloco para compressão (padrão: `zlib.constants.Z_DEFAULT_CHUNK`). Exemplo: ```javascript import zlib from 'zlib'; const deflated = zlib.deflateSync('Hello World!'); const inflated = zlib.inflateSync(deflated); console.log(inflated.toString()); // 'Hello World!' ```