<!-- review: finished -->

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

# JS

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

Em nossos repositórios, o módulo é compilado [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-100"></a>

## Exemplo de Configuração

```nginx
stream {
    js_import stream.js;

    js_set $bar stream.bar;
    js_set $req_line stream.req_line;

    server {
        listen 12345;

        js_preread stream.preread;
        return     $req_line;
    }

    server {
        listen 12346;

        js_access  stream.access;
        proxy_pass 127.0.0.1:8000;
        js_filter  stream.header_inject;
    }
}

http {
    server {
        listen 8000;
        location / {
            return 200 $http_foo\n;
        }
    }
}
```

O arquivo `stream.js`:

```javascript
var line = '';

function bar(s) {
    var v = s.variables;
    s.log("hello from bar() handler!");
    return "bar-var" + v.remote_port + "; pid=" + v.pid;
}

function preread(s) {
    s.on('upload', function (data, flags) {
        var n = data.indexOf('\n');
        if (n != -1) {
            line = data.substr(0, n);
            s.done();
        }
    });
}

function req_line(s) {
    return line;
}

// Read HTTP request line.
// Collect bytes in 'req' until
// request line is read.
// Inject HTTP header into a client's request

var my_header =  'Foo: foo';
function header_inject(s) {
    var req = '';
    s.on('upload', function(data, flags) {
        req += data;
        var n = req.search('\n');
        if (n != -1) {
            var rest = req.substr(n + 1);
            req = req.substr(0, n + 1);
            s.send(req + my_header + '\r\n' + rest, flags);
            s.off('upload');
        }
    });
}

function access(s) {
    if (s.remoteAddress.match('^192.*')) {
        s.deny();
        return;
    }

    s.allow();
}

export default {bar, preread, req_line, header_inject, access};
```

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

## Diretivas

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

<a id="s-js-access"></a>

### js_access

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_access` function | module.function;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------|
| Padrão                                                                                    | —                                         |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | stream, server                            |

Define uma função njs que será chamada na [fase de acesso](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions). Funções de módulo podem ser referenciadas.

A função é chamada uma vez no momento em que a sessão de stream atinge a [fase de acesso](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions) pela primeira vez. A função é chamada com os seguintes argumentos:

| `s`   | o objeto [sessão de stream](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|------------------------------------------------------------------------------------------------------------------------|

Nesta fase, é possível realizar inicialização ou registrar um callback com o método [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada bloco de dados recebido até que um dos seguintes métodos seja chamado: [s.done()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-done), [s.decline()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-decline), [s.allow()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-allow). Assim que um desses métodos é chamado, o processamento da sessão de stream muda para a [próxima fase](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions) e todos os callbacks [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) atuais são descartados.

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

<a id="s-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)  | stream, server               |

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

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

<a id="s-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)  | stream, server               |

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-3"></a>

<a id="s-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)  | stream, server                 |

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-4"></a>

<a id="s-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)  | stream, server                       |

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-5"></a>

<a id="s-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)  | stream, server                              |

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-6"></a>

<a id="s-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)  | stream, server                                                        |

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-7"></a>

<a id="s-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)  | stream, server             |

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-8"></a>

<a id="s-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)  | stream, server                         |

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-9"></a>

<a id="s-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)  | stream, server                    |

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-10"></a>

<a id="s-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)  | stream, server                    |

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-11"></a>

<a id="s-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)  | stream, server                      |

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
server {
    listen 12345;
    js_fetch_keepalive 32;
    js_fetch_trusted_certificate /path/to/ISRG_Root_X1.pem;
    js_preread main.fetch_handler;
}
```

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

<a id="s-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)  | stream, server                          |

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-13"></a>

<a id="s-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)  | stream, server                    |

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-14"></a>

<a id="s-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)  | stream, server                       |

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-15"></a>

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

### js_filter

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_filter` function | module.function;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------|
| Padrão                                                                                    | —                                         |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | stream, server                            |

Define um filtro de dados. Funções de módulo podem ser referenciadas.

A função de filtro é chamada uma vez no momento em que a sessão de stream atinge a [fase de conteúdo](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions). A função de filtro é chamada com os seguintes argumentos:

| `s`   | o objeto [stream session](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|----------------------------------------------------------------------------------------------------------------------|

Nesta fase, é possível realizar inicialização ou registrar um callback com o método [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada bloco de dados recebido. O método [s.off()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-off) pode ser usado para cancelar o registro de um callback e parar a filtragem.

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

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

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

### js_import

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_import` module.js | export_name from module.js;   |
|-------------------------------------------------------------------------------------------|-------------------------------------------------------|
| Padrão                                                                                    | —                                                     |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | stream, server                                        |

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

```nginx
js_import stream.js;
```

Aqui, o nome do módulo stream é usado como namespace ao acessar as exportações. Se o módulo importado exporta foo(), então stream.foo é usado para acessá-la.

Várias diretivas js_import podem ser especificadas.

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

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

### js_path

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

Define um caminho adicional para módulos njs.

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

<a id="s-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)  | server                                                                                                 |

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-19"></a>

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

### js_preload_object

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

Pré-carrega um objeto imutável no momento da configuração. O name é usado como nome da variável global através da qual o objeto está disponível no código njs. Se o name 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-20"></a>

<a id="s-js-preread"></a>

### js_preread

| [Sintaxe](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_preread` function | module.function;   |
|-------------------------------------------------------------------------------------------|--------------------------------------------|
| Padrão                                                                                    | —                                          |
| [Contexto](https://pt.angie.software//angie/docs/configuration/configfile.md#configfile)  | stream, server                             |

Define uma função njs que será chamada na [fase de pré-leitura](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions). Funções de módulo podem ser referenciadas.

A função é chamada uma vez no momento em que a sessão de stream atinge a [fase de pré-leitura](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions) pela primeira vez. A função é chamada com os seguintes argumentos:

| `s`   | o objeto [stream session](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|----------------------------------------------------------------------------------------------------------------------|

Nesta fase, é possível realizar inicialização ou registrar um callback com o método [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada bloco de dados recebido até que um dos seguintes métodos seja chamado: [s.done()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-done), [s.decline()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-decline), [s.allow()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-s-allow). Quando um desses métodos é chamado, a sessão de stream muda para a [próxima fase](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions) e todos os callbacks [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) atuais são descartados.

#### NOTE
Como o manipulador js_preread retorna seu resultado imediatamente, ele suporta apenas operações síncronas. Assim, operações assíncronas como [ngx.fetch()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch) ou [setTimeout()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) não são suportadas. No entanto, operações assíncronas são suportadas em callbacks [s.on()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-on) na [fase de pré-leitura](https://pt.angie.software//angie/docs/configuration/processing.md#stream-sessions).

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

<a id="s-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)  | stream, server                                               |

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 da variável. Por exemplo, se a variável é referenciada apenas na diretiva [log_format](https://pt.angie.software//angie/docs/configuration/modules/stream/stream_log.md#s-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, quando o argumento opcional `nocache` é fornecido, 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 [ngx.fetch()](https://pt.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch) 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="s-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)  | stream                                                                                                           |

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

| `type`    | parâmetro opcional, permite redefinir o tipo de valor para `number`, por padrão o dicionário compartilhado usa uma `string` como chave e valor                  |
|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `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,
    # remove pares chave-valor após 60 segundos de inatividade:
    js_shared_dict_zone zone=foo:1M timeout=60s;

    # Cria um dicionário de 512Kb com valores string,
    # remove forçadamente os pares chave-valor mais antigos quando a zona está esgotada:
    js_shared_dict_zone zone=bar:512K timeout=30s evict;

    # Cria um dicionário permanente 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="s-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)  | stream, server                |

Declara uma variável [gravável](https://pt.angie.software//angie/docs/configuration/njs-reference.md#s-variables). O valor pode conter texto, variáveis e sua combinação.

<a id="session-object-properties"></a>

## Propriedades do Objeto de Sessão

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