Aller au contenu
For the complete documentation index, see llms.txt. This page is also available as Markdown.

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 nœud, et le expression de condition (JEXL) champ d'un Logique 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.

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 insère. value() à la place. Voir Lecture par nom ou avec 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 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 noma0:

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 manquanta0:

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

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 :

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

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.

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.

  • 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.

  • geofenceName() n'a aucun nom à renvoyer. Voir Ce que vous obtenez en retour.

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 :

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 :

?? 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 :

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:

  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.

  6. Réécrivez chaque partie qui pourrait être vide. Utilisez == true, == false, ou une ?? solution de repli.

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

Mis à jour

Ce contenu vous a-t-il été utile ?