<!-- review: finished -->

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

# JS

El módulo se utiliza para implementar manejadores en njs — un subconjunto del lenguaje JavaScript.

En nuestros repositorios, el módulo se compila de forma [dinámica](https://es.angie.software//angie/docs/installation/index.md#install-dynamicmodules) y está disponible como un paquete independiente llamado
`angie-module-njs` o `angie-pro-module-njs`.

#### NOTE
También está disponible una versión ligera del paquete, llamada `...-njs-light`;
sin embargo, no se puede utilizar junto con la versión normal.

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

## Ejemplo de Configuración

```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;
        }
    }
}
```

El archivo `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>

## Directivas

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

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

### js_access

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_access` función | módulo.función;   |
|--------------------------------------------------------------------------------------------|-----------------------------------------|
| Predeterminado                                                                             | —                                       |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                          |

Establece una función njs que será llamada en la [fase de acceso](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions). Se pueden referenciar funciones de módulos.

La función se llama una vez en el momento en que la sesión de stream alcanza la [fase de acceso](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions) por primera vez. La función se llama con los siguientes argumentos:

| `s`   | el objeto [sesión de stream](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|-------------------------------------------------------------------------------------------------------------------------|

En esta fase, es posible realizar la inicialización o registrar un callback con el método [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada fragmento de datos entrante hasta que se llame a uno de los siguientes métodos: [s.done()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-done), [s.decline()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-decline), [s.allow()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-allow). Tan pronto como se llama a uno de estos métodos, el procesamiento de la sesión de stream cambia a la [siguiente fase](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions) y se eliminan todos los callbacks actuales de [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on).

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

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

### js_context_reuse

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_context_reuse` número;   |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado                                                                             | `js_context_reuse 128;`      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server               |

Establece el número máximo de contextos JS que se reutilizarán para el motor QuickJS. Cada contexto se utiliza para una única sesión de stream. El contexto finalizado se coloca en un pool de contextos reutilizables. Si el pool está lleno, el contexto se destruye.

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

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

### js_engine

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_engine` `njs` | `qjs`;   |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado                                                                             | `js_engine njs;`             |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server               |

Establece el motor JavaScript que se utilizará para los scripts njs. El parámetro `njs` establece el motor njs, también utilizado por defecto. El parámetro `qjs` establece el motor QuickJS.

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

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

### js_fetch_buffer_size

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_buffer_size` tamaño;   |
|--------------------------------------------------------------------------------------------|----------------------------------|
| Predeterminado                                                                             | `js_fetch_buffer_size 16k;`      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                   |

Establece el tamaño del búfer utilizado para leer y escribir con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_ciphers` cifrados;         |
|--------------------------------------------------------------------------------------------|--------------------------------------|
| Predeterminado                                                                             | `js_fetch_ciphers HIGH:!aNULL:!MD5;` |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                       |

Especifica los cifrados habilitados para conexiones HTTPS con [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). Los cifrados se especifican en el formato entendido por la biblioteca OpenSSL.

La lista de cifrados depende de la versión de OpenSSL instalada.
La lista completa se puede ver usando el comando `openssl ciphers`.

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

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

### js_fetch_max_response_buffer_size

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_max_response_buffer_size` tamaño;   |
|--------------------------------------------------------------------------------------------|-----------------------------------------------|
| Predeterminado                                                                             | `js_fetch_max_response_buffer_size 1m;`       |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                                |

Establece el tamaño máximo de la respuesta recibida con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_protocols` [`TLSv1`] [`TLSv1.1`] [`TLSv1.2`] [`TLSv1.3`];   |
|--------------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
| Predeterminado                                                                             | `js_fetch_protocols TLSv1 TLSv1.1 TLSv1.2;`                           |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                                                        |

Habilita los protocolos especificados para conexiones HTTPS con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_timeout` tiempo;   |
|--------------------------------------------------------------------------------------------|------------------------------|
| Predeterminado                                                                             | `js_fetch_timeout 60s;`      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server               |

Define un tiempo de espera para lectura y escritura para [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). El tiempo de espera se establece solo entre dos operaciones de lectura/escritura sucesivas, no para toda la respuesta. Si no se transmiten datos dentro de este tiempo, la conexión se cierra.

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

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

### js_fetch_trusted_certificate

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_trusted_certificate` archivo;   |
|--------------------------------------------------------------------------------------------|-------------------------------------------|
| Predeterminado                                                                             | —                                         |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                            |

Especifica un archivo con certificados CA de confianza en formato PEM utilizados para verificar el certificado HTTPS con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_verify` `on` | `off`;   |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado                                                                             | `js_fetch_verify on;`             |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                    |

Habilita o deshabilita la verificación del certificado del servidor HTTPS con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_verify_depth` número;   |
|--------------------------------------------------------------------------------------------|-----------------------------------|
| Predeterminado                                                                             | `js_fetch_verify_depth 100;`      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                    |

Establece la profundidad de verificación en la cadena de certificados del servidor HTTPS con [Fetch API](https://es.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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive` conexiones;   |
|--------------------------------------------------------------------------------------------|------------------------------------|
| Predeterminado                                                                             | `js_fetch_keepalive 0;`            |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                     |

Activa la caché para conexiones a servidores de destino. Cuando el valor es mayor que `0`, habilita conexiones keepalive para [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

El parámetro conexiones establece el número máximo de conexiones keepalive inactivas a servidores de destino que se conservan en la caché de cada proceso worker. Cuando se excede este número, se cierran las conexiones utilizadas menos recientemente.

Ejemplo:

```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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_requests` número;   |
|--------------------------------------------------------------------------------------------|-----------------------------------------|
| Predeterminado                                                                             | `js_fetch_keepalive_requests 1000;`     |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                          |

Establece el número máximo de solicitudes que se pueden servir a través de una conexión keepalive con [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). Después de realizar el número máximo de solicitudes, la conexión se cierra.

Cerrar conexiones periódicamente es necesario para liberar asignaciones de memoria por conexión. Por lo tanto, usar un número máximo de solicitudes demasiado alto podría resultar en un uso excesivo de memoria y no se recomienda.

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

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

### js_fetch_keepalive_time

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_time` tiempo;   |
|--------------------------------------------------------------------------------------------|-------------------------------------|
| Predeterminado                                                                             | `js_fetch_keepalive_time 1h;`       |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                      |

Limita el tiempo máximo durante el cual las solicitudes se pueden procesar a través de una conexión keepalive con [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch). Después de alcanzar este tiempo, la conexión se cierra tras el procesamiento de la solicitud subsiguiente.

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

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

### js_fetch_keepalive_timeout

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_fetch_keepalive_timeout` tiempo;   |
|--------------------------------------------------------------------------------------------|----------------------------------------|
| Predeterminado                                                                             | `js_fetch_keepalive_timeout 60s;`      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                         |

Establece un tiempo de espera durante el cual una conexión keepalive inactiva a un servidor de destino permanecerá abierta con [Fetch API](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch).

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

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

### js_filter

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_filter` función | módulo.función;   |
|--------------------------------------------------------------------------------------------|-----------------------------------------|
| Predeterminado                                                                             | —                                       |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                          |

Establece un filtro de datos. Se pueden referenciar funciones de módulos.

La función de filtro se llama una vez en el momento en que la sesión de stream alcanza la [fase de contenido](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions). La función de filtro se llama con los siguientes argumentos:

| `s`   | el objeto [sesión de stream](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|-------------------------------------------------------------------------------------------------------------------------|

En esta fase, es posible realizar la inicialización o registrar un callback con el método [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada fragmento de datos entrante. El método [s.off()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-off) puede utilizarse para desregistrar un callback y detener el filtrado.

#### NOTE
Como el manejador js_filter devuelve su resultado inmediatamente, solo admite operaciones síncronas. Por lo tanto, las operaciones asíncronas como [ngx.fetch()](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch) o [setTimeout()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) no son compatibles.

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

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

### js_import

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_import` module.js | export_name from module.js;   |
|--------------------------------------------------------------------------------------------|-------------------------------------------------------|
| Predeterminado                                                                             | —                                                     |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                                        |

Importa un módulo que implementa manejadores de ubicación y variables en njs. El export_name se utiliza como espacio de nombres para acceder a las funciones del módulo. Si no se especifica export_name, el nombre del módulo se utilizará como espacio de nombres.

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

Aquí, el nombre del módulo stream se utiliza como espacio de nombres al acceder a las exportaciones. Si el módulo importado exporta foo(), entonces se utiliza stream.foo para acceder a él.

Se pueden especificar varias directivas js_import.

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

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

### js_path

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_path` path;   |
|--------------------------------------------------------------------------------------------|-------------------|
| Predeterminado                                                                             | —                 |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server    |

Establece una ruta adicional para los módulos njs.

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

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

### js_periodic

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_periodic` module.function [`interval=`\\ time] [`jitter=`\\ number] [`worker_affinity=`\\ mask];   |
|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------|
| Predeterminado                                                                             | —                                                                                                      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | server                                                                                                 |

Especifica un manejador de contenido para ejecutarse a intervalos regulares. El manejador recibe un objeto de sesión como su primer argumento, también tiene acceso a objetos globales como `ngx`.

El parámetro opcional `interval` establece el intervalo entre dos ejecuciones consecutivas, por defecto, 5 segundos.

El parámetro opcional `jitter` establece el tiempo dentro del cual el manejador de contenido de la ubicación se retrasará aleatoriamente, por defecto, no hay retraso.

Por defecto, el `js_handler` se ejecuta en el proceso worker 0. El parámetro opcional `worker_affinity` permite especificar procesos worker particulares donde el manejador de contenido de ubicación debe ejecutarse. Cada conjunto de procesos worker se representa mediante una máscara de bits de procesos worker permitidos. La máscara `all` permite que el manejador se ejecute en todos los procesos worker.

Ejemplo:

```nginx
example.conf:

location @periodics {
    # para ejecutarse a intervalos de 1 minuto en el proceso worker 0
    js_periodic main.handler interval=60s;

    # para ejecutarse a intervalos de 1 minuto en todos los procesos worker
    js_periodic main.handler interval=60s worker_affinity=all;

    # para ejecutarse a intervalos de 1 minuto en los procesos worker 1 y 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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_preload_object` name.json | name from file.json;   |
|--------------------------------------------------------------------------------------------|--------------------------------------------------------|
| Predeterminado                                                                             | —                                                      |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                                         |

Precarga un objeto inmutable en tiempo de configuración. El name se utiliza como nombre de la variable global a través de la cual el objeto está disponible en el código njs. Si no se especifica name, se utilizará el nombre del archivo.

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

Aquí, map se usa como nombre al acceder al objeto precargado.

Se pueden especificar varias directivas js_preload_object.

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

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

### js_preread

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_preread` function | module.function;   |
|--------------------------------------------------------------------------------------------|--------------------------------------------|
| Predeterminado                                                                             | —                                          |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                             |

Establece una función njs que se llamará en la [fase preread](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions). Se pueden referenciar funciones de módulos.

La función se llama una vez en el momento en que la sesión de stream alcanza la [fase preread](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions) por primera vez. La función se llama con los siguientes argumentos:

| `s`   | el objeto [sesión de stream](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session)   |
|-------|-------------------------------------------------------------------------------------------------------------------------|

En esta fase, es posible realizar la inicialización o registrar un callback con el método [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on) para cada fragmento de datos entrante hasta que se llame a uno de los siguientes métodos: [s.done()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-done), [s.decline()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-decline), [s.allow()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-s-allow). Cuando se llama a uno de estos métodos, la sesión de stream cambia a la [siguiente fase](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions) y se eliminan todos los callbacks actuales de [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on).

#### NOTE
Como el manejador js_preread devuelve su resultado inmediatamente, solo admite operaciones síncronas. Por lo tanto, las operaciones asíncronas como [ngx.fetch()](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch) o [setTimeout()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) no son compatibles. Sin embargo, las operaciones asíncronas son compatibles en los callbacks de [s.on()](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-on) en la [fase preread](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions).

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

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

### js_set

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_set` $variable function | module.function [`nocache`];   |
|--------------------------------------------------------------------------------------------|--------------------------------------------------------------|
| Predeterminado                                                                             | —                                                            |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                                               |

Establece una función njs para la variable especificada. Se pueden referenciar funciones de módulos.

La función se llama cuando la variable se referencia por primera vez para una solicitud dada. El momento exacto depende de la [fase](https://es.angie.software//angie/docs/configuration/processing.md#stream-sessions) en la que se haga referencia a la variable. Esto se puede utilizar para realizar alguna lógica no relacionada con la evaluación de variables. Por ejemplo, si la variable se referencia solo en la directiva [log_format](https://es.angie.software//angie/docs/configuration/modules/stream/stream_log.md#s-log-format), su manejador no se ejecutará hasta la fase de registro. Este manejador se puede utilizar para realizar alguna limpieza justo antes de que se libere la solicitud.

Desde njs 0.8.6, cuando se proporciona el argumento opcional `nocache`, el manejador se llama cada vez que se hace referencia a él. Debido a las limitaciones actuales del módulo rewrite, cuando una variable `nocache` es referenciada por la directiva set, su manejador siempre debe devolver un valor de longitud fija.

#### NOTE
Como el manejador js_set devuelve su resultado inmediatamente, solo admite operaciones síncronas. Por lo tanto, las operaciones asíncronas como [ngx.fetch()](https://es.angie.software//angie/docs/configuration/njs-reference.md#ngx-fetch) o [setTimeout()](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-timers) no son compatibles.

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

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

### js_shared_dict_zone

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_shared_dict_zone` `zone=`name:size [`timeout=`time] [`type=``string` | `number`] [`evict`] [`state=`file];   |
|--------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
| Predeterminado                                                                             | —                                                                                                                |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream                                                                                                           |

Establece el nombre y tamaño de la zona de memoria compartida que mantiene el diccionario clave-valor compartido entre los procesos de trabajo.

| `type`    | parámetro opcional, permite redefinir el tipo de valor a `number`, por defecto el diccionario compartido utiliza un `string` como clave y valor                  |
|-----------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `timeout` | parámetro opcional, establece el tiempo después del cual todas las entradas del diccionario compartido se eliminan de la zona                                    |
| `evict`   | parámetro opcional, elimina el par clave-valor más antiguo cuando el almacenamiento de la zona está agotado                                                      |
| `state`   | parámetro opcional, especifica un archivo que mantiene el estado del diccionario compartido en formato JSON y lo hace persistente a través de reinicios de nginx |

Ejemplos:

```nginx
example.conf:
    # Crea un diccionario de 1Mb con valores de cadena,
    # elimina pares clave-valor después de 60 segundos de inactividad:
    js_shared_dict_zone zone=foo:1M timeout=60s;

    # Crea un diccionario de 512Kb con valores de cadena,
    # elimina forzosamente los pares clave-valor más antiguos cuando la zona está agotada:
    js_shared_dict_zone zone=bar:512K timeout=30s evict;

    # Crea un diccionario permanente de 32Kb con valores numéricos:
    js_shared_dict_zone zone=num:32k type=number;

    # Crea un diccionario de 1Mb con valores de cadena y 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

| [Sintaxis](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | `js_var` $variable [value];   |
|--------------------------------------------------------------------------------------------|-------------------------------|
| Predeterminado                                                                             | —                             |
| [Contexto](https://es.angie.software//angie/docs/configuration/configfile.md#configfile)   | stream, server                |

Declara una variable [escribible](https://es.angie.software//angie/docs/configuration/njs-reference.md#s-variables). El valor puede contener texto, variables y su combinación.

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

## Propiedades del Objeto de Sesión

Cada manejador njs de stream recibe un argumento, un objeto [sesión de stream](https://es.angie.software//angie/docs/configuration/njs-reference.md#njs-stream-session).