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

# Valeurs manquantes dans les expressions

Comprenez pourquoi une formule ou une condition IoT Logic ne produit aucune valeur lorsqu’une valeur nécessaire est manquante, et quels modèles de comparaison l’empêchent.

Les formules et les conditions dans IoT Logic fonctionnent sur les valeurs qu'un appareil GPS envoie. Lorsqu'une valeur dont une formule a besoin est manquante, la plupart des opérateurs ne peuvent pas produire de résultat, et la formule ne produit rien du tout : ni `false`, et non zéro. Cette page explique quand une valeur manque, à quoi ressemble l'échec, et comment écrire des formules et des conditions qui continuent de fonctionner. Elle s'adresse à toute personne qui configure un flux IoT Logic, et elle ne suppose aucune connaissance en programmation.

La page s'applique aux deux endroits où vous écrivez une expression : le **Formule** champ d'un [Initialiser un Attribut](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node.md) nœud, et le **expression de condition (JEXL)** champ d'un [Logique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/logic-node.md) nœud.

## Lorsqu'une expression ne peut pas produire de valeur

Une valeur vide arrête toute l'expression. Cela s'applique de part et d'autre d'un calcul, d'une comparaison de taille, d'un test de préfixe de texte ou d'un opérateur logique `!`, `&&`, ou `||`. `null`.

Lire un attribut qu'un appareil GPS n'a jamais envoyé n'est pas une erreur en soi. Ce qui s'arrête, c'est l'opérateur qui doit alors travailler avec la valeur vide. Une seule valeur vide arrête toute l'expression, y compris les parties qui avaient des valeurs. Une condition qui teste quatre géofences s'arrête à la première qui ne peut pas répondre, et les trois autres ne sont jamais testées. L'exception est un terme plus tôt dans l'expression qui a déjà déterminé le résultat.

## Ce que vous voyez lorsqu'une expression ne produit rien

Rien n'indique l'échec. Le résultat dépend du nœud qui contient l'expression :

| Où l'expression s'exécute                                      | Ce qui se passe pour ce paquet de données                                                                                         |
| -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| **Formule** champ d'un **Initialiser un Attribut** nœud        | L'attribut n'a pas de valeur pour ce paquet, et Analyseur de données l'affiche comme `null`.                                      |
| **expression de condition (JEXL)** champ d'un **Logique** nœud | Les données sortent par la connexion ELSE, et le nœud enregistre son propre attribut comme une valeur vide, et non comme `false`. |

{% hint style="warning" %}
Rien ne signale l'échec. Aucune erreur n'apparaît dans le flux, aucun compteur ne change, et tous les autres attributs sont toujours calculés normalement. Le seul signe est la valeur manquante elle-même, si bien qu'un flux peut sembler sain alors qu'un attribut ne produit aucune valeur pendant des semaines.

L'enregistrement d'un flux ne prouve pas non plus qu'une formule fonctionne. La vérification qui s'exécute lorsque vous enregistrez confirme que l'expression est rédigée correctement. Elle n'exécute pas l'expression sur les données de votre appareil GPS, donc une formule qui ne produit rien pour chaque paquet s'enregistre quand même sans avertissement.
{% endhint %}

## Comment chaque opérateur gère une valeur vide

Quatre opérateurs continuent toujours de fonctionner avec une valeur vide : `==`, `!=`, `=~`, et `!~`. Les opérateurs `&&` et `||` continuent de fonctionner uniquement lorsque le côté lu en premier détermine la réponse. Tous les autres opérateurs s'arrêtent.

Ce tableau couvre un attribut que vous référencez par son nom, qui est la forme que [le remplissage automatique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insère. `value()` à la place. Voir [Lecture par nom ou avec value()](#reading-by-name-or-with-value).

| Opérateur                                                         | Avec une valeur vide de part et d'autre                                                                       |
| ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `==`, `!=` (égal à, différent de)                                 | Donne un vrai oui ou non. `null == null` est `true`, et `null != null` est `false`.                           |
| `=~`, `!~` (est dans une liste ou correspond à un motif de texte) | Donne un vrai oui ou non. Une valeur vide ne correspond jamais, donc `=~` donne `false` et `!~` donne `true`. |
| `??` (utiliser une valeur de repli)                               | Donne la valeur de droite. Elle ne remplace qu'une valeur vide.                                               |
| `?:` (utiliser une valeur de repli)                               | Donne la valeur de droite. Elle remplace également `false`, pour `0`, et pour le texte vide.                  |
| `a ? b : c` (choisir entre deux valeurs)                          | Prend la branche `c` de la même manière que pour `false`.                                                     |
| `=^`, `!^`, `=$`, `!$` (commence par, se termine par)             | L'expression ne produit rien.                                                                                 |
| `<`, `<=`, `>`, `>=` (comparaisons de taille)                     | L'expression ne produit rien.                                                                                 |
| `+`, `-`, `*`, `/`, `%` (arithmétique)                            | L'expression ne produit rien.                                                                                 |
| `&`, `\|`, `^` (opérations bit à bit)                             | L'expression ne produit rien.                                                                                 |
| `!` (non)                                                         | L'expression ne produit rien.                                                                                 |
| `&&`, `\|\|` (et, ou)                                             | L'expression ne produit rien, sauf si le côté lu en premier détermine la réponse.                             |

Les six opérateurs de texte se divisent en deux. `=~` et `!~` tolère une valeur vide, mais `=^`, `!^`, `=$`, et `!$` ne le fait pas lorsque l’attribut est référencé par son nom. Une condition telle que `hardware_key !^ 'AB'` semble être un moyen sûr d’exclure un préfixe, mais elle ne produit rien pour chaque paquet sans `hardware_key`.

Le bloc `math :` les fonctions ne produisent rien lorsqu’elles reçoivent une valeur vide, donc `math:round(engine_temp)` ne produit rien lorsque `engine_temp` est manquant. Le `util :` les fonctions sont plus tolérantes et renvoient une valeur vide à la place, donc `util:join` et `util:joinNonNull` produisent toujours un résultat lorsqu’un de leurs arguments est manquant. La concaténation de texte avec `+` n’est pas tolérant : `'Zone: ' + zone_label` ne produit rien.

## Opérateurs logiques avec une valeur vide

L’ordre compte pour les deux `&&` et `||`. Chaque opérateur lit d’abord la partie gauche et s’arrête là lorsque la partie gauche détermine déjà le résultat. Un `false` le côté gauche prévaut `&&`, et un `true` le côté gauche prévaut `||`.

| Expression                   | Résultat                                                                                           |
| ---------------------------- | -------------------------------------------------------------------------------------------------- |
| `false && (empty)`           | `false`. Un faux du côté gauche court-circuite l'opérateur ET, donc le côté droit n'est jamais lu. |
| `true && (empty)`            | Ne produit rien.                                                                                   |
| `(empty) && anything`        | Ne produit rien. Le côté gauche est lu en premier.                                                 |
| `true \|\| (empty)`          | `true`. Un vrai du côté gauche court-circuite l'opérateur OU, donc le côté droit n'est jamais lu.  |
| `false \|\| (vide)`          | Ne produit rien.                                                                                   |
| `(vide) \|\| n’importe quoi` | Ne produit rien. Le côté gauche est lu en premier.                                                 |

Placer en dernier le terme qui pourrait être vide n’aide que lorsque la partie gauche fige le résultat sur ce paquet. Vous pouvez rarement garantir ce résultat, il est donc préférable de comparer la valeur explicitement à la place.

## Lecture par nom ou avec value()

Quatre opérateurs donnent des résultats différents pour la même valeur manquante, selon la manière dont la formule l’interprète. Les opérateurs sont `=^`, `!^`, `=$` et `!$`, celles qui testent le début ou la fin d’une valeur textuelle.

| Formule                                | Résultat lorsque `Conducteur_id` n’a jamais été envoyé |
| -------------------------------------- | ------------------------------------------------------ |
| `conducteur_id !^ 'AB'`                | Ne produit rien                                        |
| `value('driver_id', 0, 'all') !^ 'AB'` | `true`                                                 |

Faire référence à l’attribut par son nom est la forme qui [le remplissage automatique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insertions, de sorte qu’une condition construite avec le sélecteur d’attributs emprunte le premier chemin. Écrivez la comparaison avec `value()` quand vous devez `!^` ou `!$` signaler `true` sur un paquet qui ne comporte pas l'attribut.

Tous les autres opérateurs se comportent de la même manière dans les deux formes. Une comparaison de taille, des opérations arithmétiques et `!` tous ne produisent rien dans les deux cas, et `==`, `!=`, `=~` et `!~` tous donnent un vrai oui ou non, dans un sens ou dans l’autre.

La même répartition s’applique aux deux formulaires de repli. `??` et `? :` peut contenir un calcul échoué lorsque la valeur provient de `value()`, et ce n'est pas possible lorsqu'il provient d'un nom�a0:

| Formule                                               | Résultat lorsque `compteur kilométrique` n’a jamais été envoyé |
| ----------------------------------------------------- | -------------------------------------------------------------- |
| `(Compteur kilométrique + 1) ?? 0`                    | Ne produit rien                                                |
| `(value('Compteur kilométrique', 0, 'all') + 1) ?? 0` | `0`                                                            |

Un simple `??` sur un nom fonctionne toujours, car aucun calcul n'a lieu avant cela. Seul un calcul encapsulé dans `??` ou `? :` se comporte différemment.

## Comparez une valeur explicitement

Pour utiliser en toute sécurité une valeur qui pourrait être vide dans une condition, comparez-la à `== true` ou `== false` au lieu de l'utiliser seule. Les deux `==` et `!=` fournissent un vrai oui ou non pour une valeur vide, de sorte qu'un terme dépourvu de données n'interrompt plus toute la condition.

Cette condition s'arrête sur n'importe quel paquet où l'un des deux attributs est manquant�a0:

```jexl
door_open || hood_open
```

Cette condition continue de fonctionner et renvoie oui lorsque l’une des portes est ouverte :

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

Les fonctions de Zone géographique fonctionnent de la même manière, car elles renvoient une valeur vide lorsqu’un paquet ne contient aucune position. Cette condition s’arrête dès que l’une des fonctions ne peut pas répondre :

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

Cette condition teste les deux zones géographiques à chaque paquet :

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

Choisissez la comparaison qui correspond à la façon dont un paquet sans données doit être considéré :

* `== true` signifie « connu pour être oui ». Une valeur vide donne `false`, donc un paquet sans données ne correspond pas.
* `== false` signifie « connu pour être non ». Une valeur vide donne `false`, donc un paquet sans données ne correspond pas.
* `!= true` signifie « pas connu pour être oui ». Une valeur vide donne `true`, donc un paquet sans données correspond bien.

{% hint style="warning" %}
N’utilisez pas `!` sur une valeur qui pourrait être vide. `!inZone géographique(35229)` ne produit rien lorsque la position est inconnue, il ne peut donc pas détecter un appareil en dehors de la Zone géographique. Écrivez `inZone géographique(35229) == false` pour « connu comme étant à l’extérieur », ou `inZone géographique(35229) != true` pour « non connu comme étant à l'intérieur ».
{% endhint %}

## D'où viennent les valeurs vides

Un attribut dans une formule prend une valeur vide dans les cas suivants :

* L'attribut n'a jamais été envoyé pour cet appareil GPS.
* Le paquet actuel ne contient pas l'attribut, bien qu'un paquet précédent l'ait contenu.
* La position d'historique que vous avez demandée avec `value()` n'existe pas encore, car l'appareil a envoyé moins de paquets que la position ne l'exige.
* L'appareil n'a rien envoyé pendant plus de 30 jours, donc Navixy a supprimé son historique stocké. Voir [Syntaxe complète](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).
* `inGeofence()`, `enterGeofence()`, ou `leaveGeofence()` ne peut pas répondre, car le paquet ne contient aucune coordonnée ou la Zone géographique n'existe plus dans le compte. Voir [Lorsqu’une fonction de zone géographique ne donne pas de réponse](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md#when-a-geofence-function-gives-no-answer).
* `geofenceName()` n'a aucun nom à renvoyer. Voir [Ce que vous obtenez en retour](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md#what-you-get-back).

Toutes ces causes se ressemblent dans une formule. Une formule qui doit continuer à fonctionner doit traiter la valeur vide plutôt que la cause.

## Les formules qui doivent toujours produire une valeur

Sécurisez le calcul avec `!= null`, et placez la protection en premier. La protection utilise `!=`, ce qui fournit un vrai oui ou non pour une valeur vide, de sorte que la protection elle-même ne s’arrête jamais :

```jexl
value('Compteur kilométrique', 0, 'all') != null && value('Compteur kilométrique', 0, 'all') > 100
```

L’ordre est ce qui permet à la protection de fonctionner. Si vous inversez les termes, la comparaison s’exécute avant la protection, et l’ensemble de la condition ne renvoie rien.

Pour substituer plutôt une valeur de repli, utilisez `??`. Elle renvoie la partie de droite uniquement lorsque la partie de gauche est vide :

```jexl
can_speed ?? 0
```

`??` remplace une valeur manquante, pas un calcul qui a échoué. `(can_speed * 1.1) ?? 0` ne produit rien lorsque `can_speed` est manquante, car la multiplication s’arrête avant `??` qu’elle ne soit atteinte. Placez `??` autour de l’attribut plutôt qu’autour du calcul :

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

{% hint style="warning" %}
`?:` et `??` se ressemblent et se comportent différemment. `??` remplace la partie droite uniquement pour une valeur vide. `?:` la remplace pour une valeur vide et aussi pour `false`, pour `0`, et pour le texte vide. La formule `contact ?: true` par conséquent, rapports `true` lorsque le Contact est vraiment coupé. Utilisez `??` lorsque vous voulez dire « si la valeur est manquante ».
{% endhint %}

Vous pouvez également conditionner le calcul depuis l’extérieur de la formule. Placez un **Logique** nœud avant le **Initialiser un Attribut** nœud, puis testez la présence des attributs dans sa condition. Connectez le chemin THEN au nœud de calcul, afin qu’il ne reçoive que les paquets qui portent les valeurs dont il a besoin.

Connectez le chemin ELSE à un **Point de sortie** nœud également. Une branche qui se termine sans l’un d’eux rejette chaque paquet qui l’atteint, de sorte que les paquets ayant échoué au test de présence ne quittent jamais le flux.

Lorsque l’absence de valeur vaut mieux qu’une valeur erronée, un attribut sans valeur est le résultat correct. Ajoutez une valeur de repli uniquement lorsqu’un système plus loin dans le flux a besoin d’une valeur pour chaque paquet.

## Vérifiez si une expression ne produit rien

Travaillez à partir de ce que vous pouvez voir dans [Analyseur de données](https://navixy.com/docs/user/fr/guide/account/iot-logic/data-stream-analyzer.md):

1. Sélectionnez le flux, puis le GPS de l’appareil et l’attribut calculé.
2. Désactivez le **Exclure les valeurs nulles** bascule. Un calcul échoué apparaît comme une `null` valeur. La bascule masque ces valeurs lorsqu’elle est activée.
3. Augmentez la profondeur si le paquet que vous recherchez est plus ancien que les valeurs affichées à l’écran.
4. Comparez l’attribut avec les attributs lus par sa formule. Un paquet dans lequel les entrées de la formule ont des valeurs et l’attribut calculé est `null` pointe vers la formule.
5. Vérifiez chaque opérateur de la formule par rapport à [Comment chaque opérateur gère une valeur vide](#how-each-operator-handles-an-empty-value).
6. Réécrivez chaque partie qui pourrait être vide. Utilisez `== true`, `== false`, ou une `??` solution de repli.

{% hint style="warning" %}
Lorsque **Exclure les valeurs nulles** Lorsque la bascule est activée, la dernière valeur produite par la formule reste à l’écran avec son propre horodatage plus ancien. La lecture semble actuelle, mais elle appartient à un paquet antérieur. Désactivez la bascule avant d’évaluer si IoT Logic calcule toujours un attribut.
{% endhint %}

## Questions fréquemment posées

#### Une valeur vide est-elle la même que `false`?

Non. Une condition qui est réellement `false` stocke `false`, et une condition qui n'a pas pu être évaluée stocke une valeur vide. Les deux envoient les données via la connexion ELSE d'un **Logique** Nœud, donc la branche seule ne vous dit pas lequel s'est produit. Une expression ultérieure qui teste l'attribut avec `my_flag == false` ne correspond qu'au premier cas.

#### Pourquoi un appareil GPS a-t-il cessé de correspondre à une condition qui fonctionne toujours pour les autres ?

Les appareils de modèles différents n'envoient pas tous les mêmes attributs, et un appareil peut cesser de signaler un attribut que les autres envoient toujours. Une condition qui lit cet attribut sans comparaison ne produit alors rien que pour cet appareil. Comparez explicitement chaque terme avec `== true` ou `== false`.

## Voir aussi

* [les expressions et la syntaxe de Logique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md#missing-values-and-null-routing) pour savoir quelle branche un Nœud logique prend et ce qu'il stocke.
* [Fonctions de zone géographique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md) pour les cas où une fonction de Zone géographique ne peut pas répondre.
* [Gestion des attributs](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#expression-language) pour la `value()` fonction et les deux options de syntaxe.
* [Exemples de calcul](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/calculation-examples.md) pour des exemples de formule.


---

# 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/fr/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.
