> 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](/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), basado en Java Expression Language (JEXL). Las expresiones están pensadas 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 otros dejan el atributo almacenado `null` en lugar de `falso`. Consulte [Valores faltantes y enrutamiento de null](#missing-values-and-null-routing) antes de confiar en que una comparación falle de manera 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

Operador	Descripción
`==`	Comprueba si dos operandos son iguales. Si los operandos son de tipos diferentes, JEXL los convierte a uno solo si es posible
`!=`	Comprueba la desigualdad de dos operandos. Devuelve true si los operandos no son iguales
`<`	Comprueba que el operando izquierdo sea menor que el derecho
`<=`	Comprueba que el operando izquierdo sea menor o igual que el derecho
`>`	Comprueba que el operando izquierdo sea mayor que el derecho
`>=`	Comprueba que el operando izquierdo sea mayor o igual que el derecho

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

Operador	Descripción
`&&` o `y`	AND lógico: comprueba si dos condiciones son verdaderas. Devuelve true si ambas condiciones son verdaderas
`\|\|` o `o`	OR lógico: comprueba si al menos una de las dos condiciones es verdadera
`!` o `no`	NOT lógico: convierte el resultado de la condición en el valor opuesto

### Operadores de coincidencia de patrones

Operador	Descripción
`=~`	Comprueba si el valor del operando izquierdo está en el conjunto del operando derecho. Para cadenas, comprueba si coincide con un patrón regex
`!~`	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 regex
`=^`	Comprueba que la cadena del operando izquierdo comience con la cadena del operando derecho
`!^`	Comprueba que la cadena del operando izquierdo no comience con la cadena del operando derecho
`=$`	Comprueba que la cadena del operando izquierdo termine con la cadena del operando derecho
`!$`	Comprueba que la cadena del operando izquierdo no termine con la cadena del operando derecho

### Funciones de zonas 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 instrucciones de uso y ejemplos, consulte [Funciones de zonas](/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md).

Función	Parámetro	Devuelve true cuando
`inGeofence(id)`	ID de la Zona	El dispositivo se encuentra actualmente dentro de la zona
`enterGeofence(id)`	ID de la Zona	El dispositivo acaba de cruzar hacia el interior de la zona
`leaveGeofence(id)`	ID de la Zona	El dispositivo acaba de cruzar hacia fuera de la zona

**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 solo a `inGeofence()` solo. `enterGeofence()` y `leaveGeofence()` toman 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

Ejemplos de condiciones básicas

**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 sobre valores faltantes**: `!=` comparar con un literal no nulo dirige los valores faltantes a THEN, no a ELSE. Seguro: un control de presencia limita la comprobación a los paquetes que contienen el atributo. ``` value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50 ``` No seguro: esto se activa en `temperature`'s primeros paquetes 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('combustible_level', 0, 'valid') < 20 ``` Esta expresión identifica cuándo los niveles de Combustible descienden por debajo del 20 %, lo que permite el reabastecimiento proactivo.

Ejemplos de operadores lógicos

**Operaciones AND**: ``` value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80 value('temperature', 0, 'valid') > 15 and value('humidity', 0, 'valid') > 80 ``` **Operaciones OR**: ``` temperature < 10 || humidity > 80 temperature < 10 or humidity > 80 ``` **Operaciones NOT**: ``` !condition not condition ```

Ejemplos de coincidencia de patrones

**Pertenencia a un conjunto**: ``` value('lock_state', 0, 'valid') =~ ['locked','unlocked'] value('driver_name', 0, 'valid') !~ ['John', 'Steve'] ``` **Coincidencia de patrones de cadenas**: ``` Conductor_id =^ 'cc6f8216' conductor_id !^ 'cc6f8216' value('engine_hours', 0, 'valid') =$ '1000' value('driver_id', 0, 'valid') !$ '8b38851c3c68' ```

Ejemplos complejos de múltiples condiciones

**Alerta por sobre exceso de velocidad fuera del horario laboral**: ``` value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6) ``` Esto combina el monitoreo de la velocidad con condiciones basadas en el tiempo para una mejor supervisión de 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 varios parámetros de estado del dispositivo simultáneamente para garantizar un funcionamiento confiable. **Monitoreo de la 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á identificado correctamente en el sistema. **Programación del mantenimiento de equipos**: ``` value('engine_hours', 0, 'valid') > 250 && value('last_maintenance', 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 cuando las temperaturas de la carga refrigerada salen del rango aceptable.

Complejidad de la expresión y paréntesis

Puede crear expresiones complejas combinando varias condiciones con paréntesis para controlar el orden de evaluación: **Validación compleja de seguridad**: ``` driver_identified == false && (vibration_active == true || speed > 3) ``` **Verificación de equipo multiparámetro**: {% code overflow="wrap" %} ``` (value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true ``` {% endcode %}

## Valores faltantes y enrutamiento de null **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 faltante. 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 saber 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 ausente no depende de cuál de los cuatro lo haya causado. 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](/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax). Para saber por qué un valor ausente detiene una expresión y para ver los patrones de comparación que lo evitan en ambos tipos de Nodo, consulte [Valores faltantes en expresiones](/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 ausentes. Si el resultado global de la condición es cualquier cosa distinta de `true` (incluyendo `null`, o un valor que el Nodo no puede evaluar), el mensaje se dirige a ELSE. Por lo tanto, la rama ELSE contiene tanto «la condición es falsa» como «la condición no pudo satisfacerse con los datos disponibles». ### Patrones de condición seguros para null **Comprobación de presencia** (se recomienda cuando una condición debe aplicarse solo a los paquetes que llevan 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 ``` **`||` ordenación de la cadena**: Coloque al final el término que puede ser nulo. La ordenación solo ayuda en los paquetes en los que el operando izquierdo es verdadero, así que tómelo como una mejora y no como una corrección. Inseguro: el operando izquierdo nulo se dirige 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 hace cortocircuito 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 dirigiéndose a ELSE. ```jexl value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5 ``` Para un formulario que funcione en todos los paquetes, compare explícitamente cada término. Consulte [Compare un valor explícitamente](/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly). **No se base en `!()` para detectar datos faltantes**: Cuando `x` es nulo, ambos `x > 5` y `!(x > 5)` van a ELSE. **`'todos'` frente a `'válido'`**: `value(attr, 0, 'valid')` puede devolver la última lectura no nula de un paquete anterior. La condición aún puede evaluarse frente a un valor real incluso cuando el paquete actual no lo incluye. Use `'todos'` cuando la condición deba reflejar solo el paquete actual. ### Operadores de comparación con operandos nulos | Situación | Dirige a | Valor del atributo almacenado | | ----------------------------------------------------------------------------------------------- | -------- | ----------------------------- | | `<`, `<=`, `>`, o `>=` frente a un valor faltante | ELSE | `null` | | `!=` frente a un valor faltante y un literal no nulo (por ejemplo, `value('a', 0, 'all') != 1`) | THEN | `true` | | `==` frente a un valor faltante y un literal no nulo | ELSE | `falso` | | `== null` frente a un valor faltante | THEN | `true` | | `!= null` cuando el atributo está ausente | ELSE | `falso` | | `!= null` cuando el atributo está presente | THEN | `true` | | `=~` frente a un valor faltante y un literal de cadena o una lista | ELSE | `falso` | | `!~` frente a un valor faltante y un literal de cadena o una lista | THEN | `true` | | `=^` o `=$` frente a un `value()` resultado | ELSE | `falso` | | `!^` o `!$` frente a un `value()` resultado | THEN | `true` | | `=^`, `!^`, `=$`, o `!$` frente a un atributo faltante referenciado por nombre | ELSE | `null` | {% hint style="warning" %} `!=` frente a un valor faltante y un literal no nulo se evalúa como `true` y se dirige 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 enviar los valores desconocidos a ELSE. Para fallar de forma segura cuando un valor aún puede no existir, use una verificación de presencia o una `== null` comprobación: ```jexl value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1 ``` `null == null` es `true`, y `null != null` es `falso`. La validación verifica si el atributo tiene un valor en este paquete, no si difiere de un literal. {% endhint %} {% hint style="warning" %} `=~` y `!~` se resuelven a un valor real `true` o `falso` ante un valor faltante, independientemente de la sintaxis que use. Ante un valor faltante, `=~` cuenta como "sin coincidencia" y va a ELSE, y `!~` va a 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 a `falso` y termina en ELSE, y `!^` se resuelve a `true` y termina en THEN. Con el atributo referenciado por nombre, `a =^ 'AB'` se resuelve a `null` en su lugar, y tanto la forma positiva como la negada terminan en ELSE. La forma abreviada es la que [autocompletado](/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) inserta, así 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 contiene el atributo. `!~` llegar a THEN es un mecanismo diferente de `!=` llegar a THEN. `!~` termina allí porque un valor faltante cuenta como "no coincide", y `!=` termina allí porque un valor faltante es "desigual" al literal. No suponga que una cosa explica la otra. {% endhint %} ### Operadores lógicos con operandos nulos | Situación | Dirige 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 (cortocircuita) | | Operando nulo en `&&` con un operando verdadero, en cualquier orden | ELSE | `null` | | `falso` operando en `&&` evaluado antes que un operando nulo (cortocircuita) | 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` operando izquierdo determina `&&`, y un `true` operando izquierdo determina `||`. En cualquier otra combinación, se evalúa el operando nulo, la condición se resuelve en `null`, y el mensaje se enruta a ELSE. Un operando verdadero no puede cortocircuitar más allá de uno nulo en `&&`, ya que AND todavía necesita saber si el lado nulo haría fallar la condición. Un `falso` operando puede hacerlo, y el nodo entonces almacena un verdadero `falso` en lugar de `null`. Para la misma regla aplicada a fórmulas de atributos, y para los patrones de comparación que la evitan, vea [Valores faltantes en expresiones](/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 en `null` | Conexión ELSE | `null` | | Valor faltante comparado con `<`, `<=`, `>`, o `>=` | Se resuelve en `null` | Conexión ELSE | `null` | | Valor faltante comparado con `==` y un literal no nulo | Se evalúa como `falso` | Conexión ELSE | `falso` | | Valor faltante comparado con `== null` | Se evalúa como `true` | Conexión THEN | `true` | | Valor faltante 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 en `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 sola 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 frente a nulos para detectar ese caso, ya que no coincidirá con un `null` valor. En un **Iniciar atributo** nodo, los mismos errores dejan el atributo fuera del paquete de datos saliente en su lugar. Vea [Valores faltantes en expresiones](/docs/user/es/guide/account/iot-logic/nodes/missing-values-in-expressions.md). {% endhint %} ## Ejemplos prácticos de implementación

Monitoreo de temperatura de la flota

**Requisito de negocio**: Supervise 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 THEN**: Envíe alertas inmediatas al despacho, registre las infracciones de cumplimiento y active acciones correctivas * **Ruta ELSE**: Continúe con el procesamiento normal para temperaturas conformes y actualice los paneles de estado

Aplicación de la seguridad del conductor

**Requisito de negocio**: Identifique patrones de manejo inseguro durante las horas activas del turno ``` value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true ``` * **Ruta THEN**: Genere reportes de capacitación para conductores, envíe notificaciones de seguridad y registre incidentes * **Ruta ELSE**: Procese los datos de comportamiento normal de manejo y actualice las métricas de desempeño

Alertas de mantenimiento predictivo

**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 THEN**: Programe citas de mantenimiento, envíe alertas al técnico y registre datos de diagnóstico * **Ruta ELSE**: Continúe con la supervisión rutinaria y actualice los paneles de estado del equipo

Monitoreo de cumplimiento de zona

**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 administran en la interfaz de zonas de Navixy, por lo que no es necesario mantener valores de coordenadas en la expresión. El `== true` La 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 THEN**: Continúe con las operaciones normales; el dispositivo está en el área autorizada durante el horario laboral. * **Ruta ELSE**: 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 la referencia completa sobre las funciones de zona, incluida `enterGeofence()`, `geofenceName()`, y probar una posición anterior con `inGeofence()`, consulte [Funciones de zonas](/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md).

--- # 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=&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.