[comment]: # translation:outdated

[comment]: # ({96feb912-d3accdff})
# 1 Objetos JavaScript adicionales

[comment]: # ({/96feb912-d3accdff})

[comment]: # ({0a6cded7-ab8bd378})
### Descripción general

Esta sección describe las adiciones de Zabbix al lenguaje JavaScript implementadas con Duktape y las [funciones globales de JavaScript] admitidas (#global-javascript-functions).

[comment]: # ({/0a6cded7-ab8bd378})

[comment]: # ({c73f2449-c73f2449})
### Objetos integrados

[comment]: # ({/c73f2449-c73f2449})

[comment]: # ({500e2fca-e5dc8dd0})
#### Zabbix

El objeto Zabbix proporciona interacción con la funcionalidad interna de Zabbix.

|Método|Descripción|
|--|--------|
|`log(loglevel, mensaje)`|Escribe el <mensaje> en el registro de Zabbix usando el nivel de registro <loglevel> (consulte el parámetro DebugLevel del archivo de configuración).|

Ejemplo:

    Zabbix.log(3, "esta es una entrada de registro escrita con el nivel de registro 'Advertencia'")

Puede utilizar los siguientes alias:

|Alias|Alias de|
|-----|--------|
|console.log(objeto)|Zabbix.log(4, JSON.stringify(objeto))|
|console.warn(objeto)|Zabbix.log(3, JSON.stringify(objeto))|
|console.error(objeto)|Zabbix.log(2, JSON.stringify(objeto))|

::: noteimportant
El tamaño total de todos los mensajes registrados está limitado a 8 MB por cada ejecución del script.
:::

|Método|Descripción|
|--|--------|
|`sleep(delay)`|Retrasa la ejecución de JavaScript en `delay` milisegundos.|

Ejemplo (retrasar la ejecución 15 segundos):

    Zabbix.sleep(15000)
  

[comment]: # ({/500e2fca-e5dc8dd0})

[comment]: # ({57c385b7-413974f8})
#### HttpRequest

Este objeto encapsula el identificador cURL que permite realizar solicitudes HTTP simples.
Los errores se lanzan como excepciones.

::: noteimportant
La inicialización de múltiples objetos `HttpRequest` está limitada a 10 por cada ejecución del script.
:::

|Método|Descripción|
|--|--------|
|`addHeader(value)`|Agrega el campo de encabezado HTTP. Este campo se utiliza para todas las solicitudes siguientes hasta que se borre con el método `clearHeader()`.<br>La longitud total de los campos de encabezado que se pueden agregar a un único objeto `HttpRequest` está limitada a 128 Kbytes (caracteres especiales y nombres de encabezado incluidos). |
|`clearHeader()`|Borra el encabezado HTTP. Si no se establecen campos de encabezado, `HttpRequest` establecerá el tipo de contenido en aplicación/json si los datos que se publican tienen formato JSON; texto/sin formato en caso contrario.|
|`connect(url)`|Envía la solicitud HTTP CONNECT a la URL y devuelve la respuesta.|
|`customRequest(método, url, datos)`|Permite especificar cualquier método HTTP en el primer parámetro. Envía la solicitud del método a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`delete(url, datos)`|Envía la solicitud HTTP DELETE a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`getHeaders(<asArray>)`|Devuelve el objeto de los campos de encabezado HTTP recibidos.<br>El parámetro `asArray` puede establecerse en "true" (por ejemplo, `getHeaders(true)`), "false" o no estar definido . Si se establece en "verdadero", los valores del campo de encabezado HTTP recibidos se devolverán como matrices; esto debe usarse para recuperar los valores de los campos de múltiples encabezados con el mismo nombre.<br>Si no se establece o se establece en "falso", los valores de los campos del encabezado HTTP recibidos se devolverán como cadenas.|
|`get(url, datos)`|Envía una solicitud HTTP GET a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`head(url)`|Envía la solicitud HTTP HEAD a la URL y devuelve la respuesta.|
|`options(url)`|Envía la solicitud HTTP OPTIONS a la URL y devuelve la respuesta.|
|`patch(url, datos)`|Envía la solicitud HTTP PATCH a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`put(url, datos)`|Envía la solicitud HTTP PUT a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`post(url, datos)`|Envía la solicitud HTTP POST a la URL con la carga útil *datos* opcional y devuelve la respuesta.|
|`getStatus()`|Devuelve el código de estado de la última solicitud HTTP.|
|`setProxy(proxy)`|Establece el proxy HTTP al valor "proxy". Si este parámetro está vacío, no se utiliza ningún proxy.|
|`setHttpAuth(máscara de bits, nombre de usuario, contraseña)`|Establece los métodos de autenticación HTTP habilitados (HTTPAUTH\_BASIC, HTTPAUTH\_DIGEST, HTTPAUTH\_NEGOTIATE, HTTPAUTH\_NTLM, HTTPAUTH\_NONE) en el parámetro 'bitmask'.<br>HTTPAUTH El indicador \_NONE permite deshabilitar la autenticación HTTP.<br>Ejemplos:<br>`request.setHttpAuth(HTTPAUTH_NTLM \| HTTPAUTH_BASIC, nombre de usuario, contraseña)`<br>`request.setHttpAuth(HTTPAUTH_NONE)`|
|`trace(url, datos)`|Envía la solicitud HTTP TRACE a la URL con la carga útil *datos* opcional y devuelve la respuesta.|

Ejemplo:

```javascript
try {
    Zabbix.log(4, 'valor del script de jira webhook='+valor);
  
    var result = {
        'tags': {
            'endpoint': 'jira'
        }
    },
    params = JSON.parse(value),
    req = new HttpRequest(),
    fields = {},
    resp;
  
    req.addHeader('Content-Type: application/json');
    req.addHeader('Authorization: Basic '+params.authentication);
  
    fields.summary = params.summary;
    fields.description = parámetros.description;
    fields.project = {"key": params.project_key};
    fields.issuetype = {"id": params.issue_id};
    resp = req.post('https://jira.example.com/rest/api/2/issue/',
        JSON.stringify({"fields": fields})
    );
  
    if ( (req.getStatus() != 201) {
        throw 'Código de respuesta: '+req.getStatus();
    }
  
    resp = JSON.parse(resp);
    result.tags.issue_id = resp.id;
    result.tags.issue_key = resp.key;
} catch (error) {
    Zabbix.log(4, 'falló la creación del problema de jira json: '+JSON.stringify({"fields": fields}));
    Zabbix.log(4, 'Error al crear el problema de Jira: '+error);
  
    result = {};
}
  
return JSON.stringify(result);
```

[comment]: # ({/57c385b7-413974f8})

[comment]: # ({73df7bc5-06cac1ca})
#### XML

El objeto XML permite el procesamiento de datos XML en la métrica y el
preprocesamiento del descubrimiento de bajo nivel y webhooks.

::: noteimportant
 Para utilizar un objeto XML, el servidor/proxy debe estar
compilado con soporte libxml2.
:::

|Método|Descripción|
|--|--------|
|`XML.query(datos, expresión)`|Recupera el contenido del nodo usando XPath. Devuelve nulo si no se encuentra el nodo.<br>**expresión**: una expresión XPath;<br>**datos**: datos XML como una cadena.|
|`XML.toJson(data)`|Convierte datos en formato XML a JSON.|
|`XML.fromJson(object)`|Convierte datos en formato JSON a XML.|

Ejemplo:

*Entrada:*

    <menu>
        <food type = "breakfast">
            <name>Chocolate</name>
            <price>$5.95</price>
            <description></description>
            <calories>650</calories>
        </food>
    </menu>

*Salida:*

```json
{
    "menu": {
        "food": {
            "@type": "breakfast",
            "name": "Chocolate",
            "price": "$5.95",
            "description": null,
            "calories": "650"
        }
    }
}
```

[comment]: # ({/73df7bc5-06cac1ca})

[comment]: # ({9e03c929-a12fbdc2})
##### Reglas de serialización

La conversión de XML a JSON se procesará de acuerdo con las siguientes
reglas (para conversiones de JSON a XML se aplican reglas invertidas):

1\. Los atributos XML se convertirán en claves que tendrán sus nombres
antepuestos por "@".

Ejemplo:

*Entrada:*

     <xml foo="FOO">
       <bar>
         <baz>BAZ</baz>
       </bar>
     </xml>

*Producción:*

```json
 {
   "xml": {
     "@Foo Foo",
     "bar": {
       "baz": "BAZ"
     }
   }
 }
```

2\. Los elementos de cierre automático (<foo/>) se convertirán como si tuvieran
valor nulo.

Ejemplo:

*Entrada:*

    <xml>
      <foo/>
    </xml>

*Salida:*

```json
{
  "xml": {
    "foo": null
  }
}
```

3\. Los atributos vacíos (con valor "") se convertirán como si tuvieran un
valor de cadena vacía.

Ejemplo:

*Entrada:*

    <xml>
      <foo bar="" />
    </xml>

*Salida:*

```json
{
  "xml": {
    "foo": {
      "@bar": ""
    }
  }
}
```

4\. Varios nodos secundarios con el mismo nombre de elemento se convertirán en
una única clave que tiene una matriz de valores como valor.

Ejemplo:

*Entrada:*

    <xml>
      <foo>BAR</foo>
      <foo>BAZ</foo>
      <foo>QUX</foo>
    </xml>

*Salida:*

```json
{
  "xml": {
    "foo": ["BAR", "BAZ", "QUX"]
  }
}
```

5\. Si un elemento de texto no tiene atributos ni hijos, será
convertido como una cadena.

Ejemplo:

*Entrada:*

    <xml>
        <foo>BAZ</foo>
    </xml>

*Salida:*

```json
{
  "xml": {
    "foo": "BAZ"
   }
}
```

6\. Si un elemento de texto no tiene hijos, pero tiene atributos: el contenido de texto
se convertirá en un elemento con la clave '\#text' y el contenido como
valor; Los atributos se convertirán como se describe en la 
regla 1 de serialización.

Ejemplo:

*Entrada:*

    <xml>
      <foo bar="BAR">
        BAZ
      </foo>
    </xml>

*Salida:*

```json
{
  "xml": {
    "foo": {
      "@bar": "BAR",
      "#text": "BAZ"
    }
  }
}
```

[comment]: # ({/9e03c929-a12fbdc2})

[comment]: # ({d2d360b4-1368a2b0})
### Funciones globales de JavaScript

Se han implementado funciones globales adicionales de JavaScript con
Cinta adhesiva:

- btoa(datos) - codifica los datos en una cadena base64
- atob(base64\_string) - decodifica cadena base64

```javascript
intentar {
    b64 = btoa("cadena utf8");
    utf8 = atob(b64);
} 
atrapar (error) {
    return {'error.nombre': error.nombre, 'error.mensaje': error.mensaje}
}
```

- md5(datos) - calcula el hash MD5 de los datos
- sha256(datos) - calcula el hash SHA256 de los datos
- hmac('\<tipo de hash\>',key,data) - devuelve el hash HMAC como una cadena con formato hexadecimal;
    Se admiten los tipos de hash MD5 y SHA256;
    Los parámetros clave y de datos admiten datos binarios. Ejemplos:
    - `hmac('md5',clave,datos)`
    - `hmac('sha256',clave,datos)`
- sign(hash,key,data) - devuelve la firma calculada (firma RSA con SHA-256) como una cadena, donde:<br>
    **hash**: solo se permite 'sha256'; de lo contrario, se genera un error;<br>
    **clave** - la clave privada. Debe corresponder al estándar PKCS#1 o PKCS#8. La clave se puede proporcionar de diferentes formas:<br>
    - con espacios en lugar de nuevas líneas;
    - con '\n's con o sin escape en lugar de nuevas líneas;
    - sin nuevas líneas como una cadena de una sola línea;
    - como una cadena con formato JSON.

    La clave también se puede cargar desde una macro de usuario/macro secreta/bóveda.

    **datos**: los datos que se firmarán. Puede ser una cadena (también se admiten datos binarios) o un búfer (Uint8Array/ArrayBuffer).<br>
    Se utiliza OpenSSL o GnuTLS para calcular las firmas. Si Zabbix se creó sin ninguna de estas bibliotecas de cifrado, se generará un error ("falta la biblioteca OpenSSL o GnuTLS").

[comment]: # ({/d2d360b4-1368a2b0})