> For the complete documentation index, see [llms.txt](https://navixy.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md).

# expresiones y sintaxis de IF/THEN Lógica

Escriba expresiones de IF/THEN Lógica usando el lenguaje de expresiones de Navixy basado en JEXL. Las expresiones dirigen los datos al evaluarse como verdadero o falso, aunque un valor faltante puede comportarse de forma diferente.

## Fundamentos de las expresiones

El nodo IF/THEN Lógica usa la [Lenguaje de expresiones de Navixy IoT Logic](https://navixy.com/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), basada en Java Expression Language (JEXL). Las expresiones están diseñadas para devolver `true` o `falso`, pero un valor faltante no siempre sigue esa regla. Algunos operadores envían un valor faltante a THEN en lugar de ELSE, y algunos dejan el atributo almacenado `null` en lugar de `falso`. Vea [Valores faltantes y enrutamiento nulo](#missing-values-and-null-routing) antes de confiar en que una comparación falle de forma segura.

**Evaluación de expresiones**: Las expresiones se evalúan de izquierda a derecha, y puede usar paréntesis para controlar el orden de las operaciones.

**Ejemplo básico de sintaxis**:

```jexl
condition1 && (condition2 || condition3 > condition4)
```

## Operadores disponibles

### Operadores de comparación

<table><thead><tr><th width="138.54547119140625">Operador</th><th>Descripción</th></tr></thead><tbody><tr><td><code>==</code></td><td>Comprueba si dos operandos son iguales. Si los operandos son de tipos diferentes, JEXL los convierte en uno solo si es posible</td></tr><tr><td><code>!=</code></td><td>Comprueba la desigualdad de dos operandos. Devuelve true si los operandos no son iguales</td></tr><tr><td><code>&#x3C;</code></td><td>Comprueba que el operando izquierdo sea menor que el operando derecho</td></tr><tr><td><code>&#x3C;=</code></td><td>Comprueba que el operando izquierdo sea menor o igual que el operando derecho</td></tr><tr><td><code>></code></td><td>Comprueba que el operando izquierdo sea mayor que el operando derecho</td></tr><tr><td><code>>=</code></td><td>Comprueba que el operando izquierdo sea mayor o igual que el operando derecho</td></tr></tbody></table>

Para saber cómo los valores faltantes afectan el enrutamiento, consulte [Valores faltantes y enrutamiento nulo](#missing-values-and-null-routing).

### Operadores lógicos

<table><thead><tr><th width="139.45458984375">Operador</th><th>Descripción</th></tr></thead><tbody><tr><td><code>&#x26;&#x26;</code> o <code>y</code></td><td>AND lógico: comprueba si dos condiciones son verdaderas. Devuelve true si ambas condiciones son verdaderas</td></tr><tr><td><code>||</code> o <code>o</code></td><td>OR lógico: comprueba la veracidad de al menos una de las dos condiciones</td></tr><tr><td><code>!</code> o <code>no</code></td><td>NOT lógico: convierte el resultado de la condición al valor opuesto</td></tr></tbody></table>

### Operadores de coincidencia de patrones

<table><thead><tr><th width="138.54547119140625">Operador</th><th>Descripción</th></tr></thead><tbody><tr><td><code>=~</code></td><td>Comprueba si el valor del operando izquierdo está en el conjunto del operando derecho. Para cadenas, comprueba si coincide con un patrón de expresión regular</td></tr><tr><td><code>!~</code></td><td>Comprueba si el valor del operando izquierdo no está en el conjunto del operando derecho. Para cadenas, comprueba si no coincide con un patrón de expresión regular</td></tr><tr><td><code>=^</code></td><td>Comprueba que el operando de cadena izquierdo comience con el operando de cadena derecho</td></tr><tr><td><code>!^</code></td><td>Comprueba que el operando de cadena izquierdo no comience con el operando de cadena derecho</td></tr><tr><td><code>=$</code></td><td>Comprueba que el operando de cadena izquierdo termine con el operando de cadena derecho</td></tr><tr><td><code>!$</code></td><td>Comprueba que el operando de cadena izquierdo no termine con el operando de cadena derecho</td></tr></tbody></table>

### Funciones de Zona

Tres funciones evalúan la posición de un dispositivo con respecto a una zona de Navixy con nombre, y una cuarta devuelve el nombre de la zona en la que se encuentra el dispositivo. Para ver instrucciones de uso y ejemplos, consulte [Funciones de Zona](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md).

<table><thead><tr><th width="194">Función</th><th width="137">Parámetro</th><th>Devuelve true cuando</th></tr></thead><tbody><tr><td><code>inGeofence(id)</code></td><td>ID de la zona</td><td>El dispositivo se encuentra actualmente dentro de la zona</td></tr><tr><td><code>enterGeofence(id)</code></td><td>ID de la zona</td><td>El dispositivo acaba de entrar en la zona</td></tr><tr><td><code>leaveGeofence(id)</code></td><td>ID de la zona</td><td>El dispositivo acaba de salir de la zona</td></tr></tbody></table>

**Posición actual:**

```jexl
inGeofence(35229 /* Zona de entrega #4 */)
```

El nombre de la zona aparece como comentario para facilitar la lectura y no afecta la evaluación. El selector de zonas inserta este formato automáticamente.

**Posición histórica:**

```jexl
inGeofence(35229 /* zona de entrega #4 */, 1, 'valid')
```

El segundo parámetro es el índice del paquete de datos (0 para el actual, 1 para el anterior, hasta 11), y el tercero es el filtro de validez, siguiendo la misma convención que `value()`. Ambos son opcionales, y ambos se aplican a `inGeofence()` solamente. `enterGeofence()` y `leaveGeofence()` tome solo el ID de la zona y nada más. No envuelva una función de zona dentro de `value()`: el primer parámetro de `value()` es un nombre de atributo, no una expresión.

## Ejemplos de expresiones

<details>

<summary>Ejemplos básicos de condiciones</summary>

**Comprobaciones de igualdad**:

```
value('lock_state', 0, 'valid') == 'sealed'
door_state_2 == 0
```

**Comprobaciones de desigualdad**:

```
value('lock_state', 1, 'valid') != 'unknown'
avl_io_221 != null
```

**Precaución por valores faltantes**: `!=` contra un literal no nulo, enruta los valores faltantes a THEN, no a ELSE.

Seguro: una verificación de presencia limita la comprobación a los paquetes que llevan el atributo.

```
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

No seguro: esto se activa en `temperature`los primeros paquetes de 's antes de que tenga historial, ya que `!=` trata un valor faltante como distinto de cualquier literal.

```
value('temperature', 1, 'all') != 75
```

**Comparaciones numéricas**:

```
value('humidity', 1, 'all') < 80
value('humidity', 1, 'all') <= 80
value('humidity', 0, 'valid') > 80
value('humidity', 0, 'valid') >= 80
```

**Monitoreo de temperatura**:

```
value('temperature', 0, 'valid') > 75
```

Esta expresión se activa cuando la temperatura supera los 75 grados, útil para alertas de sobrecalentamiento.

**Detección de Violación de velocidad**:

```
value('speed', 0, 'valid') > 80
```

Esta expresión identifica cuándo la Gestión de vehículos supera los límites de velocidad de 80 km/h.

**Monitoreo del estado del dispositivo**:

```
value('battery_voltage', 0, 'valid') < 11.5
```

Esta expresión detecta condiciones de Batería baja que requieren atención de Mantenimiento.

**Alertas de nivel de combustible**:

```
value('fuel_level', 0, 'valid') < 20
```

Esta expresión identifica cuándo los niveles de Combustible bajan por debajo del 20 %, lo que permite reabastecer antes de tiempo.

</details>

<details>

<summary>Ejemplos de operadores lógicos</summary>

**operaciones AND**:

```
value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80
value('temperature', 0, 'valid') > 15 y value('humidity', 0, 'valid') > 80
```

**Operaciones OR**:

```
temperature < 10 || humidity > 80
temperature < 10 o humidity > 80
```

**Operaciones NOT**:

```
!condition
no condition
```

</details>

<details>

<summary>Ejemplos de coincidencia de patrones</summary>

**Pertenencia a un conjunto**:

```
value('lock_state', 0, 'valid') =~ ['bloqueado','desbloqueado']
value('driver_name', 0, 'valid') !~ ['John', 'Steve']
```

**Coincidencia de patrones de cadenas**:

```
driver_id =^ 'cc6f8216'
conductor_id !^ 'cc6f8216'
value('engine_hours', 0, 'valid') =$ '1000'
value('driver_id', 0, 'valid') !$ '8b38851c3c68'
```

</details>

<details>

<summary>Ejemplos complejos de múltiples condiciones</summary>

**Alerta fuera del horario laboral por sobre exceso de velocidad**:

```
value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6)
```

Esto combina la supervisión de la velocidad con condiciones basadas en el tiempo para mejorar la seguridad durante los turnos nocturnos.

**Diagnóstico integral del dispositivo**:

```
value('gps_satellites', 0, 'valid') >= 4 && value('battery_voltage', 0, 'valid') > 11.5 && value('signal_strength', 0, 'valid') > -80
```

Esto valida simultáneamente múltiples parámetros de estado del dispositivo para garantizar un funcionamiento confiable.

**Monitoreo de seguridad del conductor**:

```
value('harsh_braking', 0, 'valid') == true && value('driver_identified', 0, 'valid') == false
```

Esto identifica un comportamiento de manejo inseguro cuando el conductor no está debidamente identificado en el sistema.

**Programación del mantenimiento de equipos**:

```
value('engine_hours', 0, 'valid') > 250 && value('last_Mantenimiento', 0, 'valid') > 30
```

Esto activa Alertas de Mantenimiento cuando las Horas de motor superan los umbrales y el Mantenimiento está vencido.

**Cumplimiento del rango de temperatura**:

```
value('cargo_temperature', 0, 'valid') < -18 || value('cargo_temperature', 0, 'valid') > 4
```

Esto detecta cuándo las temperaturas de la carga refrigerada salen del rango aceptable.

</details>

<details>

<summary>Complejidad de la expresión y paréntesis</summary>

Puede crear expresiones complejas combinando varias condiciones con paréntesis para controlar el orden de evaluación:

**Validación de seguridad compleja**:

```
driver_identified == false && (vibration_active == true || speed > 3)
```

**Comprobación multiparamétrica de equipos**:

{% code overflow="wrap" %}

```
(value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true
```

{% endcode %}

</details>

## Valores faltantes y enrutamiento nulo

**Síntoma común:** Una condición se activa en los primeros paquetes de un dispositivo, antes de que el atributo referenciado haya llegado alguna vez. Esto normalmente significa que la condición usa `!=` (o un operador de patrón negado) contra un valor ausente. Consulte [Operadores de comparación con operandos nulos](#comparison-operators-with-null-operands) y [Operadores lógicos con operandos nulos](#logical-operators-with-null-operands) para ver qué operadores son seguros de forma predeterminada y cuáles requieren una comprobación.

Un atributo referenciado se resuelve en `null` en cuatro casos:

* Nunca se ha enviado para este dispositivo.
* Está ausente del paquete actual, pero un paquete anterior aún contiene un valor.
* El índice de historial solicitado aún no existe.
* El dispositivo no envió nada durante más de 30 días, por lo que Navixy eliminó su historial almacenado.

JEXL trata a los cuatro de la misma manera, como `null`, por lo que el comportamiento de un operador ante un valor faltante no depende de cuál de los cuatro lo haya provocado. Un atributo que nunca se envió no genera un error en el flujo. Para la retención de 30 días de los valores almacenados, consulte [Sintaxis completa](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).

Para conocer por qué un valor faltante detiene una expresión y los patrones de comparación que lo evitan en ambos tipos de nodo, consulte [Valores faltantes en expresiones](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

Cada mensaje entrante sale del Nodo de lógica por exactamente una rama, THEN o ELSE, incluso cuando la condición hace referencia a datos faltantes. Si el resultado global de la condición es cualquier cosa distinta de `true` (incluido `null`, o un valor que el nodo no puede evaluar), el mensaje se enruta a ELSE. Por lo tanto, la ruta ELSE lleva tanto «la condición es falsa» como «la condición no se pudo satisfacer con los datos disponibles».

### Patrones de condiciones seguros frente a valores nulos

**Verificación de presencia** (recomendado cuando una condición debe aplicarse solo a los paquetes que contienen el atributo). El atributo almacenado es un valor real `true`/`falso` aquí, no `null`:

```jexl
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

**Comprobación explícita de datos faltantes**: `null` se aceptan literales en las condiciones.

```jexl
value('attribute', 0, 'all') == null
```

**`||` orden de la cadena**: Coloque al final el término que pueda ser nulo. El ordenamiento solo ayuda en los paquetes en los que el operando izquierdo es verdadero, así que considérelo una mejora y no una solución.

Inseguro: el operando izquierdo nulo se enruta a ELSE aunque `speed > 50` es verdadero en el mismo paquete.

```jexl
value('attribute', 0, 'all') > 5 || value('speed', 0, 'all') > 50
```

Mejor: un operando izquierdo verdadero interrumpe la evaluación antes de que se evalúe el operando derecho nulo. En un paquete donde la velocidad es 20, el operando derecho nulo aún se evalúa, y la condición sigue redirigiendo a ELSE.

```jexl
value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5
```

Para un formulario que funciona en cada paquete, compare cada término explícitamente. Consulte [Comparar un valor explícitamente](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly).

**No dependa de `!()` para detectar datos faltantes**: Cuando `x` es nulo, ambos `x > 5` y `!(x > 5)` redirige a ELSE.

**`'todos'` vs `'válido'`**: `value(attr, 0, 'valid')` puede devolver la última lectura no nula de un paquete anterior. La condición aún puede evaluarse contra un valor real incluso cuando el paquete actual no lo tenga. Use `'todos'` cuando la condición deba reflejar solo el paquete actual.

### Operadores de comparación con operandos nulos

| Situación                                                                                     | Redirige a | Valor del atributo almacenado |
| --------------------------------------------------------------------------------------------- | ---------- | ----------------------------- |
| `<`, `<=`, `>`, o `>=` contra un valor faltante                                               | ELSE       | `null`                        |
| `!=` contra un valor faltante y un literal no nulo (por ejemplo, `value('a', 0, 'all') != 1`) | THEN       | `true`                        |
| `==` contra un valor faltante y un literal no nulo                                            | ELSE       | `falso`                       |
| `== null` contra un valor faltante                                                            | THEN       | `true`                        |
| `!= null` cuando el atributo está ausente                                                     | ELSE       | `falso`                       |
| `!= null` cuando el atributo está presente                                                    | THEN       | `true`                        |
| `=~` contra un valor faltante y un literal de cadena o una lista                              | ELSE       | `falso`                       |
| `!~` contra un valor faltante y un literal de cadena o una lista                              | THEN       | `true`                        |
| `=^` o `=$` contra un valor faltante `value()` resultado                                      | ELSE       | `falso`                       |
| `!^` o `!$` contra un valor faltante `value()` resultado                                      | THEN       | `true`                        |
| `=^`, `!^`, `=$`, o `!$` contra un atributo faltante referido por nombre                      | ELSE       | `null`                        |

{% hint style="warning" %}
`!=` contra un valor faltante y un literal no nulo se evalúa como `true` y redirige a THEN. Una condición como `value('attribute', 1, 'all') != 1` puede activarse en los primeros paquetes de un dispositivo, antes de que ese atributo tenga historial. Esto puede ocurrir incluso cuando la intención es redirigir los valores desconocidos a ELSE.

Para fallar de forma segura cuando es posible que un valor aún no exista, use una verificación de presencia o una comprobación explícita `== null` :

```jexl
value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1
```

`null == null` es `true`, y `null != null` es `falso`. La verificación comprueba si el atributo tiene un valor en este paquete, no si difiere de un literal.
{% endhint %}

{% hint style="warning" %}
`=~` y `!~` se resuelven como un valor real `true` o `falso` en un valor faltante, cualquiera sea la sintaxis que use. En un valor faltante, `=~` cuenta como «no coincide» y termina en ELSE, y `!~` termina en THEN.

Los operadores starts-with y ends-with (`=^`, `!^`, `=$`, `!$`) son el único caso en que las dos opciones de sintaxis difieren. Con `value()`, se comportan como `=~` y `!~`: `value('a', 0, 'all') =^ 'AB'` se resuelve como `falso` y cae en ELSE, y `!^` se resuelve como `true` y cae en THEN. Con el atributo referenciado por nombre, `a =^ 'AB'` se resuelve como `null` en su lugar, y tanto la forma positiva como la negada caen en ELSE.

La forma abreviada es lo que [autorrelleno](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) inserta, por lo que una condición construida con el selector de atributos toma la segunda ruta. Escriba la comparación con `value()` cuando necesite `!^` o `!$` activarse en un paquete que no lleva el atributo.

`!~` llegar a THEN es un mecanismo diferente de `!=` llegar a THEN. `!~` cae allí porque un valor ausente cuenta como "no coincide", y `!=` cae allí porque un valor ausente es "desigual" al literal. No asuma que una cosa explica la otra.
{% endhint %}

### Operadores lógicos con operandos nulos

| Situación                                                                          | Redirige a | Valor del atributo almacenado                                   |
| ---------------------------------------------------------------------------------- | ---------- | --------------------------------------------------------------- |
| `!(x > 5)` cuando `x` falta                                                        | ELSE       | `null`                                                          |
| Operando nulo en \`                                                                |            | \` evaluado antes que un operando verdadero en el mismo paquete |
| Operando verdadero en \`                                                           |            | \` evaluado antes que un operando nulo (corta la evaluación)    |
| Operando nulo en `&&` con un operando verdadero, en cualquier orden                | ELSE       | `null`                                                          |
| `falso` operando en `&&` evaluado antes que un operando nulo (corta la evaluación) | ELSE       | `falso`                                                         |
| `falso` operando en \`                                                             |            | \` evaluado antes que un operando nulo                          |

El orden importa para ambos operadores. Cada uno evalúa primero el operando izquierdo y se detiene allí cuando el operando izquierdo ya determina el resultado. Un `falso` el operando izquierdo determina `&&`, y un `true` el operando izquierdo determina `||`. En cualquier otra combinación, se evalúa el operando nulo, la condición se resuelve como `null`, y el mensaje se enruta a ELSE.

Un operando verdadero no puede saltarse uno nulo en `&&`, ya que AND todavía necesita saber si el lado nulo haría fallar la condición. Un `falso` operando sí puede, y el nodo entonces almacena un valor real `falso` en lugar de `null`. [Valores faltantes en expresiones](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

## Escenarios de manejo de errores

| Escenario                                                                     | Resultado               | Ruta del flujo | Valor del atributo |
| ----------------------------------------------------------------------------- | ----------------------- | -------------- | ------------------ |
| La expresión se evalúa como `true`                                            | Éxito                   | Conexión THEN  | `true`             |
| La expresión se evalúa como `falso`                                           | Éxito                   | Conexión ELSE  | `falso`            |
| El atributo referenciado es `null` y se usa solo, sin operador de comparación | Se resuelve como `null` | Conexión ELSE  | `null`             |
| Valor ausente comparado con `<`, `<=`, `>`, o `>=`                            | Se resuelve como `null` | Conexión ELSE  | `null`             |
| Valor ausente comparado con `==` y un literal no nulo                         | Se evalúa como `falso`  | Conexión ELSE  | `falso`            |
| Valor ausente comparado con `== null`                                         | Se evalúa como `true`   | Conexión THEN  | `true`             |
| Valor ausente comparado con `!=` y un literal no nulo                         | Se evalúa como `true`   | Conexión THEN  | `true`             |
| Error de sintaxis en la expresión                                             | Se resuelve como `null` | Conexión ELSE  | `null`             |

{% hint style="warning" %}
Una fila que se enruta a ELSE no siempre significa que el atributo se almacene como `falso`. Una referencia nula aislada y los operadores relacionales (`<`, `<=`, `>`, `>=`) se enrutan a ELSE, pero almacenan el atributo como `null`. Una expresión posterior que verifica el atributo directamente (`my_flag == false` o `my_flag == 0`) necesita una protección segura ante nulos para detectar ese caso, ya que no coincidirá con un `null` valor.

En un **Iniciar atributo** En el nodo, esos mismos fallos dejan el atributo fuera del paquete de datos saliente. Consulte [Valores faltantes en expresiones](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md).
{% endhint %}

## Ejemplos prácticos de implementación

<details>

<summary>Monitoreo de temperatura de la flota</summary>

**Requisito de negocio**: Monitoree los vehículos refrigerados para garantizar el cumplimiento de la temperatura de la carga

```
value('cargo_temperature', 0, 'valid') > 4 || value('cargo_temperature', 0, 'valid') < -18
```

* **Ruta entonces**: Envíe alertas inmediatas al despacho, registre las infracciones de cumplimiento y active acciones correctivas
* **Ruta de lo contrario**: Continúe el procesamiento normal para temperaturas conformes, actualice los paneles de estado

</details>

<details>

<summary>Cumplimiento de seguridad del conductor</summary>

**Requisito de negocio**: Identifique patrones de manejo inseguros durante las horas de turno activas

```
value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true
```

* **Ruta entonces**: Genere reportes de capacitación para conductores, envíe notificaciones de seguridad y registre incidentes
* **Ruta de lo contrario**: Procese los datos normales del comportamiento de manejo, actualice las métricas de rendimiento

</details>

<details>

<summary>Alertas de mantenimiento predictivo</summary>

**Requisito de negocio**: Detecte posibles fallas del equipo antes de que ocurran

```
value('engine_temperature', 0, 'valid') > 95 && value('oil_pressure', 0, 'valid') < 30
```

* **Ruta entonces**: Programe citas de mantenimiento, envíe alertas al técnico y registre datos de diagnóstico
* **Ruta de lo contrario**: Continúe el monitoreo rutinario, actualice los paneles de estado del equipo

</details>

<details>

<summary>Monitoreo de cumplimiento de zona</summary>

**Requisito de negocio**: Asegúrese de que los vehículos operen dentro de las áreas autorizadas durante el horario laboral

```jexl
inGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true
```

Esta expresión usa la `inGeofence()` función para verificar si un dispositivo está dentro de una zona con nombre, combinada con un atributo de horario laboral. Los límites de la zona se gestionan en la interfaz de zonas de Navixy, por lo que no es necesario mantener valores de coordenadas en la expresión.

El `== true` comparación mantiene la condición funcionando en paquetes donde la función de zona no puede decidir, como un paquete que no lleva posición. Sin ella, un valor vacío detiene toda la condición y el mensaje se enruta a ELSE.

* **Ruta entonces**: Continúe las operaciones normales; el dispositivo está en el área autorizada durante el horario laboral.
* **Ruta de lo contrario**: Genere una alerta de ubicación no autorizada, notifique a seguridad y registre la infracción.

Para detectar el momento en que un vehículo sale del área autorizada en lugar de verificar continuamente, use `leaveGeofence()` en su lugar:

```jexl
leaveGeofence(51577 /* Almacén de Austin */) == true && value('business_hours', 0, 'valid') == true
```

Para consultar la referencia completa de las funciones de zona, incluidas `enterGeofence()`, `geofenceName()`, y probar una posición anterior con `inGeofence()`, consulte [Funciones de Zona](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md).

</details>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
