<!-- review: finished -->

<a id="http-js"></a>

# JS

O módulo é usado para implementar manipuladores em njs — um subconjunto da linguagem JavaScript.

Em nossos repositórios, o módulo é construído
[dinamicamente](https://pt.angie.software//angie/docs/installation/index.md#install-dynamicmodules)
e está disponível como um pacote separado chamado `angie-module-njs` ou `angie-pro-module-njs`.

#### NOTE
Uma versão leve do pacote, chamada `...-njs-light`, também está
disponível; no entanto, ela não pode ser usada junto com a versão regular.

<a id="configuration-example-90"></a>

## Exemplo de Configuração

```nginx
http {
    js_import http.js;

    js_set $foo     http.foo;
    js_set $summary http.summary;
    js_set $hash    http.hash;

    resolver 10.0.0.1;

    server {
        listen 8000;

        location / {
            add_header X-Foo $foo;
            js_content http.baz;
        }

        location = /summary {
            return 200 $summary;
        }

        location = /hello {
            js_content http.hello;
        }

        location = /fetch {
            js_content                   http.fetch;
            js_fetch_trusted_certificate /path/to/ISRG_Root_X1.pem;
        }

        location = /crypto {
            add_header Hash $hash;
            return     200;
        }
    }
}
```

O arquivo `http.js`:

```javascript
function foo(r) {
    r.log("hello from foo() handler");
    return "foo";
}

function summary(r) {
    var a, s, h;

    s = "JS summary\n\n";

    s += "Method: " + r.method + "\n";
    s += "HTTP version: " + r.httpVersion + "\n";
    s += "Host: " + r.headersIn.host + "\n";
    s += "Remote Address: " + r.remoteAddress + "\n";
    s += "URI: " + r.uri + "\n";

    s += "Headers:\n";
    for (h in r.headersIn) {
        s += "  header '" + h + "' is '" + r.headersIn[h] + "'\n";
    }

    s += "Args:\n";
    for (a in r.args) {
        s += "  arg '" + a + "' is '" + r.args[a] + "'\n";
    }

    return s;
}

function baz(r) {
    r.status = 200;
    r.headersOut.foo = 1234;
    r.headersOut['Content-Type'] = "text/plain; charset=utf-8";
    r.headersOut['Content-Length'] = 15;
    r.sendHeader();
    r.send("nginx");
    r.send("java");
    r.send("script");

    r.finish();
}

function hello(r) {
    r.return(200, "Hello world!");
}

async function fetch(r) {
    let results = await Promise.all([ngx.fetch('https://example.com/'),
                                     ngx.fetch('https://example.org/')]);

    r.return(200, JSON.stringify(results, undefined, 4));
}

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    r.setReturnValue(Buffer.from(hash).toString('hex'));
}

export default {foo, summary, baz, hello, fetch, hash};
```

<a id="directives-87"></a>

## Diretivas

<a id="index-0"></a>

<a id="js-body-filter"></a>

### js_body_filter

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_body_filter` function | module.function [`buffer_type=``string` | `buffer`];   |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------|
| Padrão                                                                                    | —                                                                                  |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location, if in location, limit_except                                             |

Define uma função njs como filtro do corpo da resposta. A função de filtro é chamada para cada bloco de dados do corpo da resposta com os seguintes argumentos:

| `r`     | o objeto [requisição HTTP](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-http-request)   |
|---------|---------------------------------------------------------------------------------------------------------------------|
| `data`  | o bloco de dados recebido, pode ser uma string ou Buffer dependendo do valor buffer_type, por padrão é uma string.  |
| `flags` | um objeto com as seguintes propriedades:<br/>- `last` — um valor booleano, `true` se data é o último buffer         |

A função de filtro pode passar sua própria versão modificada do bloco de dados de entrada para o próximo filtro de corpo chamando [r.sendBuffer()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-sendbuffer). Por exemplo, para transformar todas as letras minúsculas no corpo da resposta:

```javascript
function filter(r, data, flags) {
    r.sendBuffer(data.toLowerCase(), flags);
}
```

Para parar a filtragem (os blocos de dados seguintes serão passados para o cliente sem chamar js_body_filter), [r.done()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-done) pode ser usado.

Se a função de filtro alterar o comprimento do corpo da resposta, então é necessário limpar o cabeçalho de resposta `Content-Length` (se houver) em [js_header_filter](#js-header-filter) para forçar a codificação de transferência em blocos.

#### NOTE
Como o manipulador js_body_filter retorna seu resultado imediatamente, ele suporta apenas operações síncronas. Assim, operações assíncronas como [r.subrequest()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-subrequest) ou [setTimeout()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) não são suportadas.

<a id="index-1"></a>

<a id="js-content"></a>

### js_content

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_content` function | module.function;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | —                                          |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location, if in location, limit_except     |

Define uma função njs como manipulador de conteúdo de localização. Funções de módulo podem ser referenciadas.

<a id="index-2"></a>

<a id="js-context-reuse"></a>

### js_context_reuse

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_context_reuse` number;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão                                                                                    | `js_context_reuse 128;`      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location       |

Define o número máximo de contextos JS a serem reutilizados para o mecanismo QuickJS. Cada contexto é usado para uma única requisição. O contexto finalizado é colocado em um pool de contextos reutilizáveis. Se o pool estiver cheio, o contexto é destruído.

<a id="index-3"></a>

<a id="js-engine"></a>

### js_engine

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_engine` `njs` | `qjs`;   |
|-------------------------------------------------------------------------------------------|------------------------------|
| Padrão                                                                                    | `js_engine njs;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location       |

Define o mecanismo JavaScript a ser usado para scripts njs. O parâmetro `njs` define o mecanismo njs, também usado por padrão. O parâmetro `qjs` define o mecanismo QuickJS.

<a id="index-4"></a>

<a id="js-fetch-buffer-size"></a>

### js_fetch_buffer_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_buffer_size` size;   |
|-------------------------------------------------------------------------------------------|--------------------------------|
| Padrão                                                                                    | `js_fetch_buffer_size 16k;`    |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location         |

Define o tamanho do buffer usado para leitura e escrita com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-5"></a>

<a id="js-fetch-ciphers"></a>

### js_fetch_ciphers

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_ciphers` ciphers;          |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão                                                                                    | `js_fetch_ciphers HIGH:!aNULL:!MD5;` |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location               |

Especifica as cifras habilitadas para conexões HTTPS com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). As cifras são especificadas no formato compreendido pela biblioteca OpenSSL.

A lista de cifras depende da versão do OpenSSL instalada.
A lista completa pode ser visualizada usando o comando `openssl ciphers`.

<a id="index-6"></a>

<a id="js-fetch-max-response-buffer-size"></a>

### js_fetch_max_response_buffer_size

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_max_response_buffer_size` size;   |
|-------------------------------------------------------------------------------------------|---------------------------------------------|
| Padrão                                                                                    | `js_fetch_max_response_buffer_size 1m;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                      |

Define o tamanho máximo da resposta recebida com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-7"></a>

<a id="js-fetch-protocols"></a>

### js_fetch_protocols

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_protocols` [`TLSv1`] [`TLSv1.1`] [`TLSv1.2`] [`TLSv1.3`];   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
| Padrão                                                                                    | `js_fetch_protocols TLSv1 TLSv1.1 TLSv1.2;`                           |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                                |

Habilita os protocolos especificados para conexões HTTPS com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-8"></a>

<a id="js-fetch-timeout"></a>

### js_fetch_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_timeout` time;   |
|-------------------------------------------------------------------------------------------|----------------------------|
| Padrão                                                                                    | `js_fetch_timeout 60s;`    |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location     |

Define um timeout para leitura e escrita para [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). O timeout é definido apenas entre duas operações sucessivas de leitura/escrita, não para toda a resposta. Se nenhum dado for transmitido dentro deste tempo, a conexão é fechada.

<a id="index-9"></a>

<a id="js-fetch-trusted-certificate"></a>

### js_fetch_trusted_certificate

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_trusted_certificate` file;   |
|-------------------------------------------------------------------------------------------|----------------------------------------|
| Padrão                                                                                    | —                                      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                 |

Especifica um arquivo com certificados CA confiáveis no formato PEM usado para verificar o certificado HTTPS com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-10"></a>

<a id="js-fetch-verify"></a>

### js_fetch_verify

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_verify` `on` | `off`;   |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão                                                                                    | `js_fetch_verify on;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location            |

Habilita ou desabilita a verificação do certificado do servidor HTTPS com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-11"></a>

<a id="js-fetch-verify-depth"></a>

### js_fetch_verify_depth

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_verify_depth` number;   |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão                                                                                    | `js_fetch_verify_depth 100;`      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location            |

Define a profundidade de verificação na cadeia de certificados HTTPS com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-12"></a>

<a id="js-fetch-keepalive"></a>

### js_fetch_keepalive

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive` connections;   |
|-------------------------------------------------------------------------------------------|-------------------------------------|
| Padrão                                                                                    | `js_fetch_keepalive 0;`             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location              |

Ativa o cache para conexões com servidores de destino. Quando o valor é maior que `0`, habilita conexões keepalive para [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

O parâmetro connections define o número máximo de conexões keepalive ociosas para servidores de destino que são preservadas no cache de cada processo worker. Quando esse número é excedido, as conexões usadas menos recentemente são fechadas.

Exemplo:

```nginx
location /fetch {
    js_fetch_keepalive 32;
    js_fetch_trusted_certificate /path/to/ISRG_Root_X1.pem;
    js_content main.fetch_handler;
}
```

<a id="index-13"></a>

<a id="js-fetch-keepalive-requests"></a>

### js_fetch_keepalive_requests

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_requests` number;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------|
| Padrão                                                                                    | `js_fetch_keepalive_requests 1000;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                  |

Define o número máximo de requisições que podem ser atendidas através de uma conexão keepalive com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). Após o número máximo de requisições ser feito, a conexão é fechada.

Fechar conexões periodicamente é necessário para liberar alocações de memória por conexão. Portanto, usar um número máximo de requisições muito alto pode resultar em uso excessivo de memória e não é recomendado.

<a id="index-14"></a>

<a id="js-fetch-keepalive-time"></a>

### js_fetch_keepalive_time

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_time` time;   |
|-------------------------------------------------------------------------------------------|-----------------------------------|
| Padrão                                                                                    | `js_fetch_keepalive_time 1h;`     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location            |

Limita o tempo máximo durante o qual as requisições podem ser processadas através de uma conexão keepalive com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). Após esse tempo ser atingido, a conexão é fechada após o processamento da requisição subsequente.

<a id="index-15"></a>

<a id="js-fetch-keepalive-timeout"></a>

### js_fetch_keepalive_timeout

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_timeout` time;   |
|-------------------------------------------------------------------------------------------|--------------------------------------|
| Padrão                                                                                    | `js_fetch_keepalive_timeout 60s;`    |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location               |

Define um timeout durante o qual uma conexão keepalive ociosa para um servidor de destino permanecerá aberta com [Fetch API](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

<a id="index-16"></a>

<a id="js-header-filter"></a>

### js_header_filter

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_header_filter` function | module.function;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------|
| Padrão                                                                                    | —                                                |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location, if in location, limit_except           |

Define uma função njs como filtro de cabeçalho de resposta. A diretiva permite alterar campos de cabeçalho arbitrários de um cabeçalho de resposta.

#### NOTE
Como o manipulador js_header_filter retorna seu resultado imediatamente, ele suporta apenas operações síncronas. Assim, operações assíncronas como [r.subrequest()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-subrequest) ou [setTimeout()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) não são suportadas.

<a id="index-17"></a>

<a id="js-import"></a>

### js_import

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_import` módulo.js | nome_exportação from módulo.js;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------------|
| Padrão                                                                                    | —                                                         |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                    |

Importa um módulo que implementa manipuladores de location e variável em njs. O nome_exportação é usado como namespace para acessar funções do módulo. Se o nome_exportação não for especificado, o nome do módulo será usado como namespace.

```nginx
js_import http.js;
```

Aqui, o nome do módulo `http` é usado como namespace ao acessar
exportações. Se o módulo importado exporta `foo()`, `http.foo` é usado
para se referir a ele.

Várias diretivas `js_import` podem ser especificadas.

<a id="index-18"></a>

<a id="js-path"></a>

### js_path

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_path` caminho;     |
|-------------------------------------------------------------------------------------------|------------------------|
| Padrão                                                                                    | —                      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location |

Define um caminho adicional para módulos njs.

<a id="index-19"></a>

<a id="js-periodic"></a>

### js_periodic

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_periodic` module.function [`interval=`\\ time] [`jitter=`\\ number] [`worker_affinity=`\\ mask];   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | —                                                                                                      |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | location                                                                                               |

Especifica um manipulador de conteúdo a ser executado em intervalos regulares. O manipulador recebe um objeto de sessão como seu primeiro argumento, e também tem acesso a objetos globais como ngx.

O parâmetro opcional `interval` define o intervalo entre duas execuções consecutivas, por padrão, 5 segundos.

O parâmetro opcional `jitter` define o tempo dentro do qual o manipulador de conteúdo da localização será atrasado aleatoriamente, por padrão, não há atraso.

Por padrão, o `js_handler` é executado no processo worker 0. O parâmetro opcional `worker_affinity` permite especificar processos worker particulares onde o manipulador de conteúdo da localização deve ser executado. Cada conjunto de processos worker é representado por uma máscara de bits de processos worker permitidos. A máscara `all` permite que o manipulador seja executado em todos os processos worker.

Exemplo:

```nginx
example.conf:

location @periodics {
    # para ser executado em intervalos de 1 minuto no processo worker 0
    js_periodic main.handler interval=60s;

    # para ser executado em intervalos de 1 minuto em todos os processos worker
    js_periodic main.handler interval=60s worker_affinity=all;

    # para ser executado em intervalos de 1 minuto nos processos worker 1 e 3
    js_periodic main.handler interval=60s worker_affinity=0101;

    resolver 10.0.0.1;
    js_fetch_trusted_certificate /path/to/ISRG_Root_X1.pem;
}
```

```javascript
example.js:

async function handler(s) {
    let reply = await ngx.fetch('https://example.com/');
    let body = await reply.text();

    ngx.log(ngx.INFO, body);
}
```

<a id="index-20"></a>

<a id="js-preload-object"></a>

### js_preload_object

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_preload_object` nome.json | nome from arquivo.json;   |
|-------------------------------------------------------------------------------------------|-----------------------------------------------------------|
| Padrão                                                                                    | —                                                         |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                    |

Pré-carrega um objeto imutável no momento da configuração. O nome é usado como nome da variável global através da qual o objeto está disponível no código njs. Se o nome não for especificado, o nome do arquivo será usado em seu lugar.

```nginx
js_preload_object map.json;
```

Aqui, o map é usado como nome ao acessar o objeto pré-carregado.

Várias diretivas js_preload_object podem ser especificadas.

<a id="index-21"></a>

<a id="js-set"></a>

### js_set

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_set` $variable function | module.function [`nocache`];   |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------|
| Padrão                                                                                    | —                                                            |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location                                       |

Define uma função njs para a variável especificada. Funções de módulo podem ser referenciadas.

A função é chamada quando a variável é referenciada pela primeira vez para uma determinada requisição. O momento exato depende de uma [fase](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions) na qual a variável é referenciada. Isso pode ser usado para executar alguma lógica não relacionada à avaliação de variável. Por exemplo, se a variável é referenciada apenas na diretiva [log_format](https://pt.angie.software//angie/docs/configuration/modules/http/http_log.md#log-format), seu manipulador não será executado até a fase de log. Este manipulador pode ser usado para fazer alguma limpeza logo antes da requisição ser liberada.

Desde o njs 0.8.6, se um argumento opcional `nocache` for especificado, o manipulador é chamado toda vez que é referenciado. Devido às limitações atuais do módulo rewrite, quando uma variável `nocache` é referenciada pela diretiva set, seu manipulador deve sempre retornar um valor de comprimento fixo.

#### NOTE
Como o manipulador js_set retorna seu resultado imediatamente, ele suporta apenas operações síncronas. Assim, operações assíncronas como [r.subrequest()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-subrequest) ou [setTimeout()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) não são suportadas.

<a id="index-22"></a>

<a id="js-shared-dict-zone"></a>

### js_shared_dict_zone

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_shared_dict_zone` `zone=`name:size [`timeout=`time] [`type=``string` | `number`] [`evict`] [`state=`file];   |
|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
| Padrão                                                                                    | —                                                                                                                |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http                                                                                                             |

Define o name e size da zona de memória compartilhada que mantém o dicionário chave-valor compartilhado entre processos worker.

| `type`    | parâmetro opcional, permite redefinir o tipo de valor para `number`;<br/>por padrão, o dicionário compartilhado usa `string` para chaves e valores              |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `timeout` | parâmetro opcional, define o tempo após o qual todas as entradas do dicionário compartilhado são removidas da zona                                              |
| `evict`   | parâmetro opcional, remove o par chave-valor mais antigo quando o armazenamento da zona está esgotado                                                           |
| `state`   | parâmetro opcional, especifica um arquivo que mantém o estado do dicionário compartilhado em formato JSON e o torna persistente entre reinicializações do nginx |

Exemplos:

```nginx
example.conf:
    # Cria um dicionário de 1MB com valores string,
    # pares chave-valor são removidos após 60 segundos de inatividade:
    js_shared_dict_zone zone=foo:1M timeout=60s;

    # Cria um dicionário de 512KB com valores string,
    # par chave-valor mais antigo é removido quando a zona transborda:
    js_shared_dict_zone zone=bar:512K timeout=30s evict;

    # Cria um dicionário persistente de 32KB com valores numéricos:
    js_shared_dict_zone zone=num:32k type=number;

    # Cria um dicionário de 1MB com valores string e estado persistente:
    js_shared_dict_zone zone=persistent:1M state=/tmp/dict.json;
```

```javascript
example.js:
    function get(r) {
        r.return(200, ngx.shared.foo.get(r.args.key));
    }

    function set(r) {
        r.return(200, ngx.shared.foo.set(r.args.key, r.args.value));
    }

    function delete(r) {
        r.return(200, ngx.shared.bar.delete(r.args.key));
    }

    function increment(r) {
        r.return(200, ngx.shared.num.incr(r.args.key, 2));
    }
```

<a id="index-23"></a>

<a id="js-var"></a>

### js_var

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_var` $variável [valor];   |
|-------------------------------------------------------------------------------------------|-------------------------------|
| Padrão                                                                                    | —                             |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | http, server, location        |

Declara uma variável [gravável](https://pt.angie.software//angie/docs/configuration/njs-reference.md#r-variables). O valor pode conter texto, variáveis e sua combinação. A variável não é sobrescrita após um redirecionamento, diferentemente de variáveis criadas com a diretiva set.

<a id="request-argument"></a>

## Argumento de Requisição

Cada manipulador HTTP njs recebe um argumento, um objeto [request](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-http-request).