> 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/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

# Valores ausentes em expressões

Entenda por que uma fórmula ou condição do IoT Logic não produz valor quando falta um valor de que ela precisa, e quais padrões de comparação evitam isso.

Fórmulas e condições em IoT Logic funcionam sobre os valores que um dispositivo GPS envia. Quando um valor de que uma fórmula precisa está ausente, a maioria dos operadores não consegue produzir um resultado, e a fórmula não produz nada: nem `falso`, e não zero. Esta página explica quando um valor desaparece, como é a falha e como escrever fórmulas e condições que continuam funcionando. Ela é para qualquer pessoa que configure um fluxo do IoT Logic, e pressupõe nenhum conhecimento de programação.

A página se aplica aos dois locais em que você escreve uma expressão: o **Fórmula** campo de um [Iniciar Atributo](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node.md) nó, e o **campo Expressão de condição (JEXL)** campo de um [Lógica](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/logic-node.md) nó.

## Quando uma expressão não consegue produzir um valor

Um valor vazio interrompe a expressão inteira. Isso se aplica em qualquer lado de um cálculo, de uma comparação de tamanho, de um teste de prefixo de texto ou de um operador lógico `!`, `&&`, ou `||`. Em uma fórmula e no Analisador de dados, um valor vazio aparece como `null`.

Ler um atributo que um dispositivo GPS nunca enviou não é um erro por si só. O que para é o operador que então precisa trabalhar com o valor vazio. Um único valor vazio interrompe a expressão inteira, inclusive as partes que tinham valores. Uma condição que testa quatro geocercas para na primeira que não consegue responder, e as outras três nunca são testadas. A exceção é um termo anterior na expressão que já tenha definido o resultado.

## O que você vê quando uma expressão não produz nada

Nada indica a falha. O resultado depende de qual nó contém a expressão:

| Onde a expressão é executada                                     | O que acontece com esse pacote de dados                                                                        |
| ---------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| **Fórmula** campo de um **Iniciar Atributo** Nó                  | O atributo não tem valor para esse pacote, e o Analisador de dados o exibe como `null`.                        |
| **campo Expressão de condição (JEXL)** campo de um **Lógica** Nó | Os dados saem pela conexão ELSE, e o nó armazena seu próprio atributo como um valor vazio, e não como `falso`. |

{% hint style="warning" %}
Nada informa a falha. Nenhum erro aparece no fluxo, nenhum contador muda, e todos os outros atributos continuam sendo calculados normalmente. O único sinal é o próprio valor ausente, então um fluxo pode parecer saudável enquanto um atributo não produz valor por semanas.

Salvar um fluxo também não prova que uma fórmula funciona. A verificação que é executada quando você salva confirma que a expressão foi escrita corretamente. Ela não executa a expressão em relação aos dados do seu dispositivo GPS, então uma fórmula que não produz nada em cada pacote ainda é salva sem aviso.
{% endhint %}

## Como cada operador lida com um valor vazio

Quatro operadores sempre continuam funcionando com um valor vazio: `==`, `!=`, `=~`, e `!~`. Os operadores `&&` e `||` continuam funcionando apenas quando o lado lido primeiro define a resposta. Todos os outros operadores param.

Esta tabela cobre um atributo que você referencia pelo nome, que é o formato que [preenchimento automático](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insere. Quatro operadores se comportam de forma diferente quando o valor vem de `value()` em vez disso. Veja [Leitura por nome ou com value()](#reading-by-name-or-with-value).

| Operador                                                           | Com um valor vazio em qualquer um dos lados                                                                        |
| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------ |
| `==`, `!=` (igual a, diferente de)                                 | Retorna um sim ou não de fato. `null == null` é `true`, e `null != null` é `falso`.                                |
| `=~`, `!~` (está em uma lista ou corresponde a um padrão de texto) | Retorna um sim ou não de fato. Um valor vazio nunca corresponde, então `=~` retorna `falso` e `!~` retorna `true`. |
| `??` (use um valor alternativo)                                    | Retorna o valor à direita. Ele substitui apenas um valor vazio.                                                    |
| `?:` (use um valor alternativo)                                    | Retorna o valor à direita. Também substitui por `falso`, por `0`, e por texto vazio.                               |
| `a ? b : c` (escolha entre dois valores)                           | Segue o `c` ramo c, o mesmo que faz para `falso`.                                                                  |
| `=^`, `!^`, `=$`, `!$` (começa com, termina com)                   | A expressão não produz nada.                                                                                       |
| `<`, `<=`, `>`, `>=` (comparações de tamanho)                      | A expressão não produz nada.                                                                                       |
| `+`, `-`, `*`, `/`, `%` (aritmética)                               | A expressão não produz nada.                                                                                       |
| `&`, `\|`, `^` (operações bit a bit)                               | A expressão não produz nada.                                                                                       |
| `!` (não)                                                          | A expressão não produz nada.                                                                                       |
| `&&`, `\|\|` (e, ou)                                               | A expressão não produz nada, a menos que o lado lido primeiro defina a resposta.                                   |

Os seis operadores de texto se dividem em dois. `=~` e `!~` suporta um valor vazio, mas `=^`, `!^`, `=$`, e `!$` não quando o atributo é referenciado pelo nome. Uma condição como `hardware_key !^ 'AB'` parece uma forma segura de excluir um prefixo, mas não produz nada em cada pacote sem `hardware_key`.

O `math:` as funções não produzem nada quando recebem um valor vazio, então `math:round(engine_temp)` não produz nada quando `engine_temp` está ausente. A `util:` as funções são mais tolerantes e retornam um valor vazio em vez disso, então `util:join` e `util:joinNonNull` ainda produzem um resultado quando um de seus argumentos está ausente. Concatenar texto com `+` não é tolerante: `'Zona: ' + zone_label` não produz nada.

## Operadores lógicos com um valor vazio

A ordem importa para ambos `&&` e `||`. Cada operador lê primeiro o lado esquerdo e para ali quando o lado esquerdo já determina o resultado. A `falso` o lado esquerdo determina `&&`, e um `true` o lado esquerdo determina `||`.

| Expressão                     | Resultado                                                                              |
| ----------------------------- | -------------------------------------------------------------------------------------- |
| `falso && (vazio)`            | `falso`. Um lado esquerdo falso determina o AND, então o lado direito nunca é lido.    |
| `verdadeiro && (vazio)`       | Não produz nada.                                                                       |
| `(vazio) && qualquer coisa`   | Não produz nada. O lado esquerdo é lido primeiro.                                      |
| `verdadeiro \|\| (vazio)`     | `true`. Um lado esquerdo verdadeiro determina o OR, então o lado direito nunca é lido. |
| `false \|\| (vazio)`          | Não produz nada.                                                                       |
| `(vazio) \|\| qualquer coisa` | Não produz nada. O lado esquerdo é lido primeiro.                                      |

Colocar o termo que pode estar vazio por último só ajuda quando o lado esquerdo define o resultado naquele pacote. Raramente você pode garantir esse resultado, então compare o valor explicitamente em vez disso.

## Leitura por nome ou com value()

Quatro operadores fornecem resultados diferentes para o mesmo valor ausente, dependendo de como a fórmula o interpreta. Os operadores são `=^`, `!^`, `=$` e `!$`, os que testam o início ou o fim de um valor de texto.

| Fórmula                                | Resultado quando `motorista_id` nunca foi enviado |
| -------------------------------------- | ------------------------------------------------- |
| `motorista_id !^ 'AB'`                 | Não produz nada                                   |
| `value('driver_id', 0, 'all') !^ 'AB'` | `true`                                            |

Fazer referência ao atributo pelo nome é o Formulário que [preenchimento automático](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) inserções, então uma condição criada com o seletor de atributos segue o primeiro caminho. Escreva a comparação com `value()` quando você precisar `!^` ou `!$` relatar `true` em um pacote que não contém o atributo.

Todos os demais operadores se comportam da mesma forma em ambas as formas. Uma comparação de tamanho, aritmética e `!` todos não produzem nada de qualquer forma, e `==`, `!=`, `=~` e `!~` todos dão um sim ou não de verdade, de qualquer forma.

A mesma divisão se aplica às duas formas de fallback. `??` e `? :` pode conter um cálculo com falha quando o valor vier de `value()`, e não pode quando vem de um nome:

| Fórmula                                  | Resultado quando `Odômetro` nunca foi enviado |
| ---------------------------------------- | --------------------------------------------- |
| `(odômetro + 1) ?? 0`                    | Não produz nada                               |
| `(value('odômetro', 0, 'all') + 1) ?? 0` | `0`                                           |

Um valor simples `??` em um nome ainda funciona, porque nenhum cálculo acontece antes dele. Apenas um cálculo encapsulado dentro `??` ou `? :` se comporta de maneira diferente.

## Compare um valor explicitamente

Para tornar seguro em uma condição um valor que pode estar vazio, compare-o com `== true` ou `== false` em vez de usá-lo sozinho. Ambos `==` e `!=` fornecem um verdadeiro sim ou não para um valor vazio, de modo que um termo sem dados não interrompa mais toda a condição.

Esta condição para em qualquer pacote em que um dos dois atributos esteja ausente:

```jexl
door_open || hood_open
```

Esta condição continua funcionando e retorna "sim" quando qualquer uma das portas estiver aberta:

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

As funções de geocerca se comportam da mesma forma, porque retornam um valor vazio quando um pacote não contém posição. Esta condição para assim que uma função não consegue responder:

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

Esta condição verifica ambas as geocercas em cada pacote:

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

Escolha a comparação que corresponde ao que um pacote sem dados deve contabilizar como:

* `== true` significa "sabidamente sim". Um valor vazio gera `falso`, então um pacote sem dados não corresponde.
* `== false` significa "sabidamente não". Um valor vazio gera `falso`, então um pacote sem dados não corresponde.
* `!= true` significa "não se sabe que seja verdadeiro". Um valor vazio retorna `true`, então um pacote sem dados corresponde.

{% hint style="warning" %}
Não use `!` em um valor que possa estar vazio. `!inGeocerca(35229)` não produz nada quando a posição é desconhecida, então não consegue detectar um dispositivo fora da geocerca. Escreva `inGeocerca(35229) == false` para "sabidamente fora", ou `inGeocerca(35229) != true` para "não se saber se está dentro".
{% endhint %}

## De onde vêm os valores vazios

Um atributo em uma fórmula assume um valor vazio nestes casos:

* O atributo nunca foi enviado para esse dispositivo GPS.
* O pacote atual não traz o atributo, embora um pacote anterior o tivesse trazido.
* A posição do histórico que você solicitou com `value()` ainda não existe, porque o dispositivo enviou menos pacotes do que a posição exige.
* O dispositivo não enviou nada por mais de 30 dias, então a Navixy descartou o histórico armazenado. Consulte [Sintaxe completa](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).
* `inGeofence()`, `enterGeofence()`, ou `leaveGeofence()` não pode responder, porque o pacote não contém coordenadas ou a geocerca não existe mais na conta. Consulte [Quando uma função de geocerca não retorna resposta](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md#when-a-geofence-function-gives-no-answer).
* `geofenceName()` não tem nome a retornar. Consulte [O que é retornado](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md#what-you-get-back).

Todas essas causas parecem iguais em uma fórmula. Uma fórmula que precisa continuar funcionando deve tratar o valor vazio, e não a causa.

## Fórmulas que devem sempre produzir um valor

Proteja o cálculo com `!= null`, e coloque a guarda em primeiro lugar. A guarda usa `!=`, o que fornece um verdadeiro sim ou não para um valor vazio, então a própria guarda nunca para:

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

A ordem é o que faz a guarda funcionar. Se você inverter os termos, a comparação é executada antes da guarda, e a condição inteira não produz nada.

Para substituir por um valor de fallback em vez disso, use `??`. Ele retorna o lado direito somente quando o lado esquerdo estiver vazio:

```jexl
can_speed ?? 0
```

`??` substitui um valor ausente, não um cálculo que falhou. `(can_speed * 1.1) ?? 0` não produz nada quando `can_speed` está ausente, porque a multiplicação para antes de `??` ser alcançado. Coloque `??` ao redor do atributo em vez de ao redor do cálculo:

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

{% hint style="warning" %}
`?:` e `??` parecem semelhantes e se comportam de forma diferente. `??` substitui o lado direito apenas por um valor vazio. `?:` substitui-o por um valor vazio e também por `falso`, por `0`, e para texto vazio. A fórmula `ignição ?: true` portanto, informa `true` quando a ignição está realmente desligada. Use `??` quando você quer dizer "se o valor estiver ausente".
{% endhint %}

Você também pode condicionar o cálculo fora da fórmula. Coloque um **Lógica** nó antes do **Iniciar Atributo** nó e teste os atributos quanto à presença em sua condição. Conecte o caminho THEN ao nó de cálculo, para que ele receba apenas os pacotes que carregam os valores de que ele precisa.

Conecte o caminho ELSE a um **Ponto de Extremidade de Saída** nó também. Um ramo que termina sem um deles descarta todos os pacotes que chegam a ele, então os pacotes que falharam no teste de presença nunca saem do fluxo.

Quando nenhum valor é melhor do que um valor incorreto, um atributo sem valor é o resultado correto. Adicione um valor alternativo somente quando um sistema mais adiante no fluxo precisar de um valor em cada pacote.

## Verifique se uma expressão não produz nada

Trabalhe com o que você pode ver em [Analisador de dados](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/data-stream-analyzer.md):

1. Selecione o fluxo, depois o dispositivo GPS e o atributo calculado.
2. Desative o **botão de alternância Excluir nulos** botão de alternância. Um cálculo com falha aparece como um `null` valor. O botão de alternância oculta esses valores quando está ativado.
3. Aumente a profundidade se o pacote que você está procurando for mais antigo do que os valores na tela.
4. Compare o atributo com os atributos que a sua fórmula lê. Um pacote em que as entradas da fórmula têm valores e o atributo calculado é `null` aponta para a fórmula.
5. Verifique cada operador na fórmula em relação a [Como cada operador lida com um valor vazio](#how-each-operator-handles-an-empty-value).
6. Reescreva cada parte que possa estar vazia. Use `== true`, `== false`, ou uma `??` alternativa.

{% hint style="warning" %}
Quando **botão de alternância Excluir nulos** estiver ativado, o último valor que a fórmula produziu permanece na tela com seu próprio carimbo de data/hora mais antigo. A leitura parece atual, mas pertence a um pacote anterior. Desative a chave antes de julgar se o IoT Logic ainda calcula um atributo.
{% endhint %}

## Perguntas frequentes

#### Um valor vazio é o mesmo que `falso`?

Não. Uma condição que seja genuinamente `falso` armazena `falso`, e uma condição que não pôde ser avaliada armazena um valor vazio. Ambas enviam os dados pela conexão ELSE de um Nó **Lógica** Nó, então a ramificação sozinha não informa o que aconteceu. Uma expressão posterior que testa o atributo com `my_flag == false` corresponde apenas ao primeiro caso.

#### Por que um dispositivo GPS parou de corresponder a uma condição que ainda funciona para os outros?

Dispositivos de modelos diferentes nem sempre enviam os mesmos atributos, e um dispositivo pode parar de informar um atributo que os outros ainda enviam. Uma condição que lê esse atributo sem uma comparação então não produz nada apenas para esse dispositivo. Compare cada termo explicitamente com `== true` ou `== false`.

## Veja também

* [expressões e sintaxe da Lógica](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md#missing-values-and-null-routing) para saber qual ramificação um Nó Logic segue e o que ele armazena.
* [Funções de Geocerca](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md) para os casos em que uma função de Geocerca não consegue responder.
* [Gerenciamento de atributos](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#expression-language) para a `value()` função e as duas opções de sintaxe.
* [Exemplos de cálculo](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/calculation-examples.md) para exemplos de fórmula.


---

# 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/pt-br/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.
