> 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/missing-values-in-expressions.md).

# Valores faltantes en expresiones

Comprenda por qué una fórmula o condición de IoT Logic no genera ningún valor cuando falta un valor que necesita, y qué patrones de comparación lo evitan.

Las fórmulas y condiciones en IoT Logic trabajan con los valores que envía un dispositivo GPS. Cuando falta un valor que una fórmula necesita, la mayoría de los operadores no pueden producir un resultado, y la fórmula no produce nada en absoluto: no `falso`, y no cero. Esta página explica cuándo falta un valor, cómo se ve la falla y cómo escribir fórmulas y condiciones que sigan funcionando. Está dirigida a cualquiera que configure un flujo de IoT Logic y no presupone conocimientos de programación.

La página se aplica a ambos lugares donde escribe una expresión: el **Fórmula** campo de un [Iniciar atributo](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node.md) nodo, y el **Expresión de condición (JEXL)** campo de un [IF/THEN Lógica](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/logic-node.md) nodo.

## Cuando una expresión no puede producir un valor

Un valor vacío detiene toda la expresión. Eso se aplica a cualquiera de los lados de un cálculo, una comparación de tamaño, una prueba de prefijo de texto o una operación lógica `!`, `&&`, o `||`. En una fórmula y en Analizador de datos, un valor vacío aparece como `null`.

Leer un atributo que un dispositivo GPS nunca ha enviado no es un error por sí mismo. Lo que se detiene es el operador que luego debe trabajar con el valor vacío. Un solo valor vacío detiene toda la expresión, incluidas las partes que tenían valores. Una condición que prueba cuatro geocercas se detiene en la primera que no puede responder, y las otras tres nunca se prueban. La excepción es un término anterior en la expresión que ya ha determinado el resultado.

## Qué ve cuando una expresión no produce nada

Nada marca la falla. El resultado depende de qué nodo contiene la expresión:

| Dónde se ejecuta la expresión                                         | Qué sucede con ese paquete de datos                                                                               |
| --------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| **Fórmula** campo de un **Iniciar atributo** Nodo                     | El atributo no tiene valor para ese paquete, y Analizador de datos lo muestra como `null`.                        |
| **Expresión de condición (JEXL)** campo de un **IF/THEN Lógica** Nodo | Los datos salen por la conexión ELSE, y el nodo almacena su propio atributo como un valor vacío, no como `falso`. |

{% hint style="warning" %}
Nada informa la falla. No aparece ningún error en el flujo, no cambia ningún contador y todos los demás atributos siguen calculándose con normalidad. La única señal es el valor faltante en sí, de modo que un flujo puede parecer saludable mientras un atributo no produce ningún valor durante semanas.

Guardar un flujo tampoco demuestra que una fórmula funcione. La comprobación que se ejecuta al guardar confirma que la expresión esté escrita correctamente. No ejecuta la expresión con los datos de su dispositivo GPS, por lo que una fórmula que no produce nada en cada paquete aún se guarda sin advertencia.
{% endhint %}

## Cómo maneja cada operador un valor vacío

Cuatro operadores siempre siguen funcionando con un valor vacío: `==`, `!=`, `=~`, y `!~`. Los operadores `&&` y `||` siguen funcionando solo cuando el lado que se lee primero determina la respuesta. Todos los demás operadores se detienen.

Esta tabla cubre un atributo al que usted hace referencia por nombre, que es la forma que [autorrelleno](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) inserta. Cuatro operadores se comportan de manera diferente cuando el valor proviene de `value()` en su lugar. Véase [Lectura por nombre o con value()](#reading-by-name-or-with-value).

| Operador                                                         | Con un valor vacío en cualquiera de los lados                                                                     |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `==`, `!=` (igual a, distinto de)                                | Devuelve un sí o no real. `null == null` es `true`, y `null != null` es `falso`.                                  |
| `=~`, `!~` (está en una lista o coincide con un patrón de texto) | Devuelve un sí o no real. Un valor vacío nunca coincide, por lo que `=~` devuelve `falso` y `!~` devuelve `true`. |
| `??` (usar un valor alternativo)                                 | Devuelve el valor de la derecha. Solo sustituye un valor vacío.                                                   |
| `?:` (usar un valor alternativo)                                 | Devuelve el valor de la derecha. También sustituye por `falso`, para `0`, y para texto vacío.                     |
| `a ? b : c` (elegir entre dos valores)                           | Toma la `c` rama, igual que lo hace para `falso`.                                                                 |
| `=^`, `!^`, `=$`, `!$` (empieza con, termina con)                | La expresión no produce nada.                                                                                     |
| `<`, `<=`, `>`, `>=` (comparaciones de tamaño)                   | La expresión no produce nada.                                                                                     |
| `+`, `-`, `*`, `/`, `%` (aritmética)                             | La expresión no produce nada.                                                                                     |
| `&`, `\|`, `^` (operaciones a nivel de bits)                     | La expresión no produce nada.                                                                                     |
| `!` (no)                                                         | La expresión no produce nada.                                                                                     |
| `&&`, `\|\|` (y, o)                                              | La expresión no produce nada, a menos que el lado que se lee primero determine la respuesta.                      |

Los seis operadores de texto se dividen en dos. `=~` y `!~` admiten un valor vacío, pero `=^`, `!^`, `=$`, y `!$` no lo hacen cuando el atributo se referencia por nombre. Una condición como `hardware_key !^ 'AB'` parece una forma segura de excluir un prefijo, pero no produce nada en cada paquete que no tenga `hardware_key`.

El `matemáticas:` las funciones no producen nada cuando reciben un valor vacío, así que `math:round(engine_temp)` no produce nada cuando `engine_temp` falta. El `útil:` las funciones son más tolerantes y devuelven un valor vacío en su lugar, por lo que `util:join` y `util:joinNonNull` siguen produciendo un resultado cuando falta uno de sus argumentos. Al unir texto con `+` no es tolerante: `'Zone: ' + zone_label` no produce nada.

## Operadores lógicos con un valor vacío

El orden importa en ambos `&&` y `||`. Cada operador lee primero el lado izquierdo y se detiene allí cuando el lado izquierdo ya determina el resultado. Un `falso` el lado izquierdo determina el resultado `&&`, y un `true` el lado izquierdo determina el resultado `||`.

| Expresión                     | Resultado                                                                                  |
| ----------------------------- | ------------------------------------------------------------------------------------------ |
| `false && (vacío)`            | `falso`. Un lado izquierdo falso determina AND, por lo que el lado derecho nunca se lee.   |
| `true && (vacío)`             | No produce nada.                                                                           |
| `(vacío) && cualquier cosa`   | No produce nada. El lado izquierdo se lee primero.                                         |
| `true \|\| (vacío)`           | `true`. Un lado izquierdo verdadero determina OR, por lo que el lado derecho nunca se lee. |
| `false \|\| (vacío)`          | No produce nada.                                                                           |
| `(vacío) \|\| cualquier cosa` | No produce nada. El lado izquierdo se lee primero.                                         |

Colocar al final el término que podría estar vacío solo ayuda cuando el lado izquierdo fija el resultado en ese paquete. Rara vez puede garantizar ese resultado, así que, en su lugar, compare explícitamente el valor.

## Lectura por nombre o con value()

Cuatro operadores proporcionan resultados diferentes para el mismo valor faltante, según cómo lo lea la fórmula. Los operadores son `=^`, `!^`, `=$` y `!$`, los que comprueban el inicio o el final de un valor de texto.

| Fórmula                                | Resultado cuando `id_del_conductor` nunca se envió |
| -------------------------------------- | -------------------------------------------------- |
| `conductor_id !^ 'AB'`                 | No produce nada                                    |
| `value('driver_id', 0, 'all') !^ 'AB'` | `true`                                             |

Referenciar el atributo por nombre es el Formulario que [autorrelleno](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) inserciones, por lo que una condición creada con el selector de atributos toma la primera ruta. Escriba la comparación con `value()` cuando necesite `!^` o `!$` reportar `true` en un paquete que no contiene el atributo.

Todos los demás operadores se comportan igual en ambas formas. Una comparación de tamaño, aritmética y `!` todos no producen nada de ninguna manera, y `==`, `!=`, `=~` y `!~` todos dan un sí o un no real, de todas formas.

La misma división se aplica a los dos formularios de respaldo. `??` y `? :` puede contener un cálculo fallido cuando el valor proviene de `value()`, y no puede cuando proviene de un nombre:

| Fórmula                                  | Resultado cuando `odómetro` nunca se envió |
| ---------------------------------------- | ------------------------------------------ |
| `(odómetro + 1) ?? 0`                    | No produce nada                            |
| `(value('odómetro', 0, 'all') + 1) ?? 0` | `0`                                        |

Una simple `??` sobre un nombre sigue funcionando, porque no se realiza ningún cálculo antes de ello. Solo un cálculo envuelto dentro de `??` o `? :` se comporta de forma diferente.

## Comparar un valor explícitamente

Para que un valor que podría estar vacío sea seguro en una condición, compárelo con `== true` o `== false` en lugar de usarlo por sí solo. Ambas `==` y `!=` devuelven un sí o no reales para un valor vacío, por lo que un término que no tiene datos ya no detiene toda la condición.

Esta condición se detiene en cualquier paquete en el que falte uno de los dos atributos:

```jexl
door_open || hood_open
```

Esta condición sigue funcionando y devuelve sí cuando cualquiera de las puertas está abierta:

```jexl
door_open == true || hood_open == true
```

Las funciones de zona se comportan igual, porque devuelven un valor vacío cuando un paquete no contiene posición. Esta condición se detiene en cuanto una función no puede responder:

```jexl
leaveGeofence(51577 /* Austin Warehouse */) || leaveGeofence(85269 /* Construction site 1 */)
```

Esta condición prueba ambas zonas en cada paquete:

```jexl
leaveGeofence(51577 /* Almacén de Austin */) == true || leaveGeofence(85269 /* Sitio de construcción 1 */) == true
```

Elija la comparación que corresponda a lo que debe contar un paquete sin datos:

* `== true` significa «conocido como sí». Un valor vacío da `falso`, por lo que un paquete sin datos no coincide.
* `== false` significa «conocido como no». Un valor vacío da `falso`, por lo que un paquete sin datos no coincide.
* `!= true` significa «no conocido como sí». Un valor vacío da `true`, por lo que un paquete sin datos sí coincide.

{% hint style="warning" %}
No use `!` en un valor que podría estar vacío. `!inGeofence(35229)` no produce nada cuando la posición es desconocida, por lo que no puede detectar un dispositivo fuera de la zona. Escriba `inGeofence(35229) == false` para «conocido como fuera», o `inGeofence(35229) != true` para «no conocido como dentro».
{% endhint %}

## De dónde provienen los valores vacíos

Un atributo en una fórmula se resuelve como un valor vacío en estos casos:

* El atributo nunca se ha enviado para ese dispositivo GPS.
* El paquete actual no contiene el atributo, aunque un paquete anterior sí lo contenía.
* La posición del historial que solicitó con `value()` aún no existe, porque el dispositivo ha enviado menos paquetes de los que requiere la posición.
* El dispositivo no envió nada durante más de 30 días, así que Navixy descartó su historial almacenado. Consulte [Sintaxis completa](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).
* `inGeofence()`, `enterGeofence()`, o `leaveGeofence()` no puede responder, porque el paquete no contiene coordenadas o la zona ya no existe en la cuenta. Consulte [Cuando una función de zona no da respuesta](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md#when-a-geofence-function-gives-no-answer).
* `geofenceName()` no tiene ningún nombre que devolver. Consulte [Lo que devuelve](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md#what-you-get-back).

Todas estas causas se ven iguales en una fórmula. Una fórmula que debe seguir funcionando tiene que manejar el valor vacío en lugar de la causa.

## Fórmulas que siempre deben producir un valor

Proteja el cálculo con `!= null`, y coloque la protección primero. La protección usa `!=`, que devuelve un sí o no reales para un valor vacío, por lo que la protección misma nunca se detiene:

```jexl
value('odómetro', 0, 'all') != null && value('odómetro', 0, 'all') > 100
```

El orden es lo que hace que la protección funcione. Si invierte los términos, la comparación se ejecuta antes de la protección, y toda la condición no produce nada.

Para sustituir en su lugar un valor de reserva, use `??`. Devuelve el lado derecho solo cuando el lado izquierdo está vacío:

```jexl
can_speed ?? 0
```

`??` sustituye un valor ausente, no un cálculo fallido. `(can_speed * 1.1) ?? 0` no produce nada cuando `can_speed` falta, porque la multiplicación se detiene antes de `??` que se alcance. Coloque `??` alrededor del atributo en lugar de alrededor del cálculo:

```jexl
(can_speed ?? 0) * 1.1
```

{% hint style="warning" %}
`?:` y `??` se ven similares y se comportan de manera diferente. `??` sustituye el lado derecho solo para un valor vacío. `?:` lo sustituye por un valor vacío y también por `falso`, para `0`, y para texto vacío. La fórmula `ignición ?: true` por lo tanto devuelve `true` cuando la ignición está realmente apagada. Use `??` cuando quiera decir "si el valor falta".
{% endhint %}

También puede condicionar el cálculo desde fuera de la fórmula. Coloque un **IF/THEN Lógica** nodo antes del **Iniciar atributo** nodo, y pruebe los atributos para verificar si están presentes en su condición. Conecte la ruta THEN al nodo de cálculo, para que reciba solo los paquetes que contienen los valores que necesita.

Conecte la ruta ELSE a un **Nodo de Salida** nodo también. Una rama que termina sin uno descarta todos los paquetes que llegan a ella, de modo que los paquetes que no pasaron la prueba de presencia nunca salen del flujo.

Cuando no tener un valor es mejor que tener uno incorrecto, un atributo sin valor es el resultado correcto. Agregue un valor de respaldo solo cuando un sistema más adelante en el flujo necesite un valor en cada paquete.

## Compruebe si una expresión no produce nada

Trabaje a partir de lo que puede ver en [Analizador de datos](https://navixy.com/docs/user/es/guide/account/iot-logic/data-stream-analyzer.md):

1. Seleccione el flujo, luego el dispositivo GPS y el atributo calculado.
2. Desactive el **Excluir nulos** interruptor. Un cálculo fallido aparece como un `null` valor. El interruptor oculta esos valores cuando está activado.
3. Aumente la profundidad si el paquete que busca es más antiguo que los valores en pantalla.
4. Compare el atributo con los atributos que su fórmula lee. Un paquete en el que las entradas de la fórmula tienen valores y el atributo calculado es `null` apunta a la fórmula.
5. Verifique cada operador de la fórmula con [Cómo maneja cada operador un valor vacío](#how-each-operator-handles-an-empty-value).
6. Reescriba cada parte que podría estar vacía. Use `== true`, `== false`, o un `??` valor de respaldo.

{% hint style="warning" %}
Cuando **Excluir nulos** está activado, el último valor que produjo la fórmula permanece en pantalla con su propia marca de tiempo anterior. La lectura parece actual, pero pertenece a un paquete anterior. Desactive el interruptor antes de juzgar si IoT Logic sigue calculando un atributo.
{% endhint %}

## Preguntas frecuentes

#### ¿Un valor vacío es lo mismo que `falso`?

No. Una condición que realmente está vacía `falso` almacena `falso`, y una condición que no pudo evaluarse almacena un valor vacío. Ambas envían los datos a través de la conexión ELSE de un **IF/THEN Lógica** nodo, así que la rama por sí sola no le indica cuál ocurrió. Una expresión posterior que pruebe el atributo con `my_flag == false` solo coincide con el primer caso.

#### ¿Por qué un dispositivo GPS dejó de coincidir con una condición que sigue funcionando para los demás?

Los dispositivos de diferentes modelos no envían todos los mismos atributos, y un dispositivo puede dejar de reportar un atributo que los demás aún envían. Una condición que lee ese atributo sin una comparación entonces no produce nada solo para ese dispositivo. Compare cada término explícitamente con `== true` o `== false`.

## Véase también

* [Expresiones y sintaxis de IF/THEN Lógica](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md#missing-values-and-null-routing) qué rama toma un nodo Logic y qué almacena.
* [Funciones de Zona](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/geofence-functions.md) para los casos en que una función de zona no puede responder.
* [Administrar atributos](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#expression-language) para la `value()` función y las dos opciones de sintaxis.
* [Ejemplos de cálculos](https://navixy.com/docs/user/es/guide/account/iot-logic/nodes/initiate-attribute-node/calculation-examples.md) para ejemplos de fórmulas.


---

# 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/missing-values-in-expressions.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.
