> 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/logic-node/logic-node-expressions-and-syntax.md).

# Expressions et syntaxe de Logique

Rédigez des expressions de Logique à l'aide du langage d'expression Navixy basé sur JEXL. Les expressions orientent les données en évaluant vrai ou faux, mais une valeur manquante peut se comporter différemment.

## Principes fondamentaux des expressions

Le nœud Logique utilise le [le langage d'expression Navixy IoT Logic](/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), basé sur Java Expression Language (JEXL). Les expressions sont censées renvoyer `true` ou `false`, mais une valeur manquante ne suit pas toujours cette règle. Certains opérateurs orientent une valeur manquante vers THEN au lieu de ELSE, et certains laissent l'attribut stocké `null` plutôt que `false`. Voir [Valeurs manquantes et routage vers null](#missing-values-and-null-routing) avant de compter sur une comparaison pour échouer sans risque.

**Évaluation des expressions** : Les expressions sont évaluées de gauche à droite, et vous pouvez utiliser des parenthèses pour contrôler l'ordre des opérations.

**Exemple de syntaxe de base**:

```jexl
condition1 && (condition2 || condition3 > condition4)
```

## Opérateurs disponibles

### Opérateurs de comparaison

<table><thead><tr><th width="138.54547119140625">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>==</code></td><td>Vérifie si deux opérandes sont égaux. Si les opérandes sont de types différents, JEXL les convertit en un seul type si possible</td></tr><tr><td><code>!=</code></td><td>Vérifie l'inégalité de deux opérandes. Renvoie vrai si les opérandes ne sont pas égaux</td></tr><tr><td><code>&#x3C;</code></td><td>Vérifie que l'opérande de gauche est inférieur à l'opérande de droite</td></tr><tr><td><code>&#x3C;=</code></td><td>Vérifie que l'opérande de gauche est inférieur ou égal à l'opérande de droite</td></tr><tr><td><code>></code></td><td>Vérifie que l'opérande de gauche est supérieur à l'opérande de droite</td></tr><tr><td><code>>=</code></td><td>Vérifie que l'opérande de gauche est supérieur ou égal à l'opérande de droite</td></tr></tbody></table>

Pour savoir comment les valeurs manquantes affectent le routage, consultez [Valeurs manquantes et routage vers null](#missing-values-and-null-routing).

### Opérateurs logiques

<table><thead><tr><th width="139.45458984375">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>&#x26;&#x26;</code> ou <code>et</code></td><td>ET logique - vérifie si deux conditions sont vraies. Renvoie vrai si les deux conditions sont vraies</td></tr><tr><td><code>||</code> ou <code>ou</code></td><td>OU logique - vérifie si au moins l'une des deux conditions est vraie</td></tr><tr><td><code>!</code> ou <code>non</code></td><td>NON logique - convertit le résultat de la condition en sa valeur opposée</td></tr></tbody></table>

### Opérateurs de correspondance de motifs

<table><thead><tr><th width="138.54547119140625">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>=~</code></td><td>Vérifie si la valeur de l'opérande de gauche appartient à l'ensemble de l'opérande de droite. Pour les chaînes, vérifie la correspondance avec un motif d'expression régulière</td></tr><tr><td><code>!~</code></td><td>Vérifie si la valeur de l'opérande de gauche n'appartient pas à l'ensemble de l'opérande de droite. Pour les chaînes, vérifie la non-correspondance avec un motif d'expression régulière</td></tr><tr><td><code>=^</code></td><td>Vérifie que l'opérande de chaîne de gauche commence par l'opérande de chaîne de droite</td></tr><tr><td><code>!^</code></td><td>Vérifie que l'opérande de chaîne de gauche ne commence pas par l'opérande de chaîne de droite</td></tr><tr><td><code>=$</code></td><td>Vérifie que l'opérande de chaîne de gauche se termine par l'opérande de chaîne de droite</td></tr><tr><td><code>!$</code></td><td>Vérifie que l'opérande de chaîne de gauche ne se termine pas par l'opérande de chaîne de droite</td></tr></tbody></table>

### Fonctions de zone géographique

Trois fonctions évaluent la position d'un appareil par rapport à une zone géographique Navixy nommée, et une quatrième renvoie le nom de la zone géographique dans laquelle se trouve l'appareil. Pour des instructions d'utilisation et des exemples, consultez [Fonctions de zone géographique](/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md).

<table><thead><tr><th width="194">Fonction</th><th width="137">Paramètre</th><th>Renvoie vrai lorsque</th></tr></thead><tbody><tr><td><code>inGeofence(id)</code></td><td>ID de zone géographique</td><td>L'appareil se trouve actuellement à l'intérieur de la zone géographique</td></tr><tr><td><code>enterGeofence(id)</code></td><td>ID de zone géographique</td><td>L’appareil vient d’entrer dans la zone géographique</td></tr><tr><td><code>leaveGeofence(id)</code></td><td>ID de zone géographique</td><td>L’appareil vient de sortir de la zone géographique</td></tr></tbody></table>

**Position actuelle :**

```jexl
inGeofence(35229 /* Delivery zone #4 */)
```

Le nom de la zone géographique apparaît comme un commentaire pour la lisibilité et n'a aucun effet sur l'évaluation. Le sélecteur de zone géographique insère automatiquement ce format.

**Position historique :**

```jexl
inGeofence(35229 /* Delivery zone #4 */, 1, 'valid')
```

Le deuxième paramètre est l'indice du paquet de données (0 pour le paquet actuel, 1 pour le précédent, jusqu'à 11), et le troisième est le filtre de validité, selon la même convention que `value()`. Les deux sont facultatifs, et ils s'appliquent tous deux à `inGeofence()` seulement. `enterGeofence()` et `leaveGeofence()` prennent l'ID de la zone géographique et rien d'autre. N'imbriquez pas une fonction de zone géographique dans `value()` : le premier paramètre de `value()` est un nom d'attribut, pas une expression.

## Exemples d'expressions

<details>

<summary>Exemples de conditions de base</summary>

**Vérifications d'égalité**:

```
value('lock_state', 0, 'valid') == 'sealed'
door_state_2 == 0
```

**Vérifications d’inégalité**:

```
value('lock_state', 1, 'valid') != 'unknown'
avl_io_221 != null
```

**Prudence en cas de valeur manquante**: `!=` à l’encontre d’un littéral non nul dirige les valeurs manquantes vers THEN, et non vers ELSE.

Sûr : un garde de présence limite la vérification aux paquets qui portent l’attribut.

```
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

Non sûr : cela se déclenche sur `temperature`ses premiers paquets avant qu’il n’ait un historique, puisque `!=` traite une valeur manquante comme différente de tout littéral.

```
value('temperature', 1, 'all') != 75
```

**Comparaisons numériques**:

```
value('humidity', 1, 'all') < 80
value('humidity', 1, 'all') <= 80
value('humidity', 0, 'valid') > 80
value('humidity', 0, 'valid') >= 80
```

**Surveillance de la température**:

```
value('temperature', 0, 'valid') > 75
```

Cette expression se déclenche lorsque la température dépasse 75 degrés, utile pour les alertes de surchauffe.

**Détection d’Excès de vitesse**:

```
value('speed', 0, 'valid') > 80
```

Cette expression identifie quand les véhicules dépassent les limites de vitesse de 80 km/h.

**Surveillance de l’état de l’appareil**:

```
value('battery_voltage', 0, 'valid') < 11.5
```

Cette expression détecte les conditions de Batterie faible nécessitant une attention d’Entretien.

**Règles d’alertes de niveau de Carburant**:

```
value('fuel_level', 0, 'valid') < 20
```

Cette expression identifie quand les niveaux de carburant descendent en dessous de 20 %, ce qui permet un ravitaillement proactif.

</details>

<details>

<summary>Exemples d’opérateurs logiques</summary>

**Opérations ET**:

```
value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80
value('temperature', 0, 'valid') > 15 and value('humidity', 0, 'valid') > 80
```

**Opérations OR**:

```
temperature < 10 || humidity > 80
temperature < 10 or humidity > 80
```

**Opérations NOT**:

```
!condition
not condition
```

</details>

<details>

<summary>Exemples de correspondance de motifs</summary>

**Appartenance à un ensemble**:

```
value('lock_state', 0, 'valid') =~ ['locked','unlocked']
value('driver_name', 0, 'valid') !~ ['John', 'Steve']
```

**Correspondance de motifs de chaînes**:

```
driver_id =^ 'cc6f8216'
conducteur_id !^ 'cc6f8216'
value('engine_hours', 0, 'valide') =$ '1000'
value('driver_id', 0, 'valid') !$ '8b38851c3c68'
```

</details>

<details>

<summary>Exemples complexes à conditions multiples</summary>

**Alerte d’excès de vitesse en dehors des heures ouvrables**:

```
value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6)
```

Cela combine la surveillance de la vitesse avec des conditions basées sur le temps pour une surveillance renforcée de la Sécurité pendant les quarts de nuit.

**Diagnostics complets de l’appareil**:

```
value('gps_satellites', 0, 'valid') >= 4 && value('battery_voltage', 0, 'valid') > 11.5 && value('signal_strength', 0, 'valid') > -80
```

Cela valide simultanément plusieurs paramètres de santé de l’appareil afin de garantir un fonctionnement fiable.

**Suivi de la sécurité du conducteur**:

```
value('harsh_braking', 0, 'valid') == true && value('driver_identified', 0, 'valid') == false
```

Cela identifie un comportement de conduite dangereuse lorsque le Conducteur n’est pas correctement identifié dans le système.

**Ordonnancement de l’entretien des équipements**:

```
value('engine_hours', 0, 'valid') > 250 && value('last_maintenance', 0, 'valid') > 30
```

Cela déclenche des Règles d’alertes d’Entretien lorsque les Heures moteur dépassent les seuils et que l’Entretien est en retard.

**Conformité à la plage de température**:

```
value('cargo_temperature', 0, 'valid') < -18 || value('cargo_temperature', 0, 'valid') > 4
```

Cela détecte lorsque les températures des marchandises réfrigérées sortent de la plage acceptable.

</details>

<details>

<summary>Complexité de l’expression et parenthèses</summary>

Vous pouvez créer des expressions complexes en combinant plusieurs conditions avec des parenthèses pour contrôler l'ordre d'évaluation :

**Validation de sécurité complexe**:

```
Conducteur_identified == false && (vibration_active == true || speed > 3)
```

**Vérification multi-paramètres des équipements**:

{% code overflow="wrap" %}

```
(value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true
```

{% endcode %}

</details>

## Valeurs manquantes et routage vers null

**Symptôme courant :** Une condition se déclenche sur les tout premiers paquets d’un appareil, avant même que l’attribut référencé ne soit arrivé. Cela signifie généralement que la condition utilise `!=` (ou un opérateur de motif nié) sur une valeur absente. Voir [Opérateurs de comparaison avec des opérandes nuls](#comparison-operators-with-null-operands) et [Opérateurs logiques avec des opérandes nuls](#logical-operators-with-null-operands) pour savoir quels opérateurs sont sûrs par défaut et lesquels nécessitent une vérification.

Un attribut référencé se résout en `null` dans quatre cas :

* Il n’a jamais été envoyé pour cet appareil.
* Il est absent du paquet actuel, mais un paquet précédent contient encore une valeur.
* L’index d’historique demandé n’existe pas encore.
* L'appareil n'a rien envoyé pendant plus de 30 jours, donc Navixy a supprimé son historique stocké.

JEXL les traite tous les quatre de la même manière, comme `null`, donc le comportement d'un opérateur face à une valeur manquante ne dépend pas de laquelle des quatre l'a provoquée. Un attribut jamais envoyé ne génère pas d'erreur dans le flux. Pour la conservation des valeurs stockées pendant 30 jours, voir [Syntaxe complète](/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).

Pour savoir pourquoi une valeur manquante interrompt une expression, et pour les modèles de comparaison qui l'empêchent dans les deux types de nœud, voir [Valeurs manquantes dans les expressions](/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

Chaque message entrant quitte le nœud logique par une seule branche, THEN ou ELSE, même lorsque la condition fait référence à des données manquantes. Si le résultat global de la condition est autre que `true` (y compris `null`, ou une valeur que le nœud ne peut pas évaluer), le message est acheminé vers ELSE. Le chemin ELSE porte donc à la fois « la condition est fausse » et « la condition n'a pas pu être satisfaite à partir des données disponibles ».

### Modèles de conditions tolérants aux valeurs nulles

**Contrôle de présence** (recommandé lorsqu'une condition doit s'appliquer uniquement aux paquets qui portent l'attribut). L'attribut stocké est réel `true`/`false` ici, pas `null`:

```jexl
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

**Vérification explicite des données manquantes**: `null` les littéraux sont acceptés dans les conditions.

```jexl
value('attribute', 0, 'all') == null
```

**`||` ordre de chaînage**: Placez en dernier le terme qui peut être nul. L’ordre n’aide que sur les paquets où l’opérande de gauche est vraie, considérez donc cela comme une amélioration plutôt que comme une correction.

Non sûr : l’opérande gauche null est redirigé vers ELSE même si `speed > 50` est vraie sur le même paquet.

```jexl
value('attribute', 0, 'all') > 5 || value('speed', 0, 'all') > 50
```

Mieux : un véritable opérande gauche court-circuite avant que l’opérande droit nul ne soit évalué. Sur un paquet où la vitesse est de 20, l’opérande droit nul est tout de même évalué, et la condition redirige quand même vers ELSE.

```jexl
value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5
```

Pour un Formulaire qui fonctionne sur chaque paquet, comparez chaque terme explicitement. Voir [Comparer une valeur explicitement](/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly).

**Ne vous fiez pas à `!()` pour détecter des données manquantes**: Lorsque `x` est nul, les deux `x > 5` et `!(x > 5)` redirige vers ELSE.

**`'tous'` vs `'valide'`**: `value(attr, 0, 'valid')` peut renvoyer la dernière lecture non nulle d’un paquet précédent. La condition peut encore être évaluée par rapport à une valeur réelle même lorsque le paquet actuel ne la contient pas. Utilisez `'tous'` lorsque la condition doit refléter uniquement le paquet actuel.

### Opérateurs de comparaison avec des opérandes nuls

| Situation                                                                                  | Achemine vers | Valeur d'attribut stockée |
| ------------------------------------------------------------------------------------------ | ------------- | ------------------------- |
| `<`, `<=`, `>`, ou `>=` sur une valeur manquante                                           | ELSE          | `null`                    |
| `!=` sur une valeur manquante et un littéral non nul (p. ex., `value('a', 0, 'all') != 1`) | THEN          | `true`                    |
| `==` sur une valeur manquante et un littéral non nul                                       | ELSE          | `false`                   |
| `== null` sur une valeur manquante                                                         | THEN          | `true`                    |
| `!= null` lorsque l'attribut est absent                                                    | ELSE          | `false`                   |
| `!= null` lorsque l'attribut est présent                                                   | THEN          | `true`                    |
| `=~` sur une valeur manquante et une chaîne littérale ou une liste                         | ELSE          | `false`                   |
| `!~` sur une valeur manquante et une chaîne littérale ou une liste                         | THEN          | `true`                    |
| `=^` ou `=$` sur une valeur manquante `value()` résultat                                   | ELSE          | `false`                   |
| `!^` ou `!$` sur une valeur manquante `value()` résultat                                   | THEN          | `true`                    |
| `=^`, `!^`, `=$`, ou `!$` sur un attribut manquant référencé par son nom                   | ELSE          | `null`                    |

{% hint style="warning" %}
`!=` sur une valeur manquante et un littéral non nul s'évalue à `true` et redirige vers THEN. Une condition comme `value('attribute', 1, 'all') != 1` peut se déclencher sur les premiers paquets d’un appareil, avant que cet attribut n’ait le moindre historique. Cela peut se produire même lorsque l’intention est de rediriger les valeurs inconnues vers ELSE.

Pour échouer de manière sûre lorsqu’une valeur peut ne pas encore exister, utilisez un test de présence ou un `== null` contrôle explicite :

```jexl
value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1
```

`null == null` est `true` et `null != null` est `false`. Le garde vérifie si l'attribut a une valeur sur ce paquet, et non s'il diffère d'un littéral.
{% endhint %}

{% hint style="warning" %}
`=~` et `!~` se résolvent en une valeur réelle `true` ou `false` sur une valeur manquante, quelle que soit la syntaxe utilisée. Sur une valeur manquante, `=~` compte comme « ne correspond pas » et aboutit à ELSE, et `!~` aboutit à THEN.

Les opérateurs starts-with et ends-with (`=^`, `!^`, `=$`, `!$`) sont le seul cas où les deux options de syntaxe diffèrent. Avec `value()`, ils se comportent comme `=~` et `!~`: `value('a', 0, 'all') =^ 'AB'` se résout en `false` et arrive sur ELSE, et `!^` se résout en `true` et arrive sur THEN. Avec l’attribut référencé par son nom, `a =^ 'AB'` se résout en `null` à la place, et les formes positive et négative arrivent toutes deux sur ELSE.

La forme abrégée est ce que [le remplissage automatique](/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insère, de sorte qu’une condition construite avec le sélecteur d’attributs emprunte le second chemin. Écrivez la comparaison avec `value()` lorsque vous devez `!^` ou `!$` déclencher sur un paquet qui ne contient pas l’attribut.

`!~` atteindre THEN est un mécanisme différent de `!=` atteindre THEN. `!~` arrive là parce qu’une valeur manquante est considérée comme « ne correspondant pas », et `!=` arrive là parce qu’une valeur manquante est « différente » du littéral. Ne supposez pas que l’un explique l’autre.
{% endhint %}

### Opérateurs logiques avec des opérandes nuls

| Situation                                                                    | Achemine vers | Valeur d'attribut stockée                               |
| ---------------------------------------------------------------------------- | ------------- | ------------------------------------------------------- |
| `!(x > 5)` lorsque `x` est absent                                            | ELSE          | `null`                                                  |
| Opérande nulle dans \`                                                       |               | \` évaluée avant une opérande vraie dans le même paquet |
| Opérande vraie dans \`                                                       |               | \` évaluée avant une opérande nulle (court-circuite)    |
| Opérande nulle dans `&&` avec une opérande vraie, dans n’importe quel ordre  | ELSE          | `null`                                                  |
| `false` opérande dans `&&` évaluée avant une opérande nulle (court-circuite) | ELSE          | `false`                                                 |
| `false` opérande dans \`                                                     |               | \` évaluée avant une opérande nulle                     |

L’ordre importe pour les deux opérateurs. Chacun évalue d’abord l’opérande de gauche et s’arrête lorsque l’opérande de gauche détermine déjà le résultat. Une `false` opérande gauche détermine `&&`, et une `true` opérande gauche détermine `||`. Dans toutes les autres combinaisons, l’opérande nulle est évaluée, la condition donne `null`, et le message est routé vers ELSE.

Une opérande vraie ne peut pas court-circuiter une opérande nulle dans `&&`, car AND doit encore savoir si le côté nul ferait échouer la condition. Une `false` opérande peut le faire, et le nœud enregistre alors une véritable `false` plutôt que `null`. Pour la même règle appliquée aux formules d’attributs, ainsi que pour les modèles de comparaison qui l’évitent, consultez [Valeurs manquantes dans les expressions](/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

## Scénarios de gestion des erreurs

| Scénario                                                                       | Résultat         | Chemin du flux | Valeur d’attribut |
| ------------------------------------------------------------------------------ | ---------------- | -------------- | ----------------- |
| L’expression donne `true`                                                      | Réussite         | Connexion THEN | `true`            |
| L’expression donne `false`                                                     | Réussite         | Connexion ELSE | `false`           |
| L’attribut référencé est `null` et utilisé seul, sans opérateur de comparaison | Donne `null`     | Connexion ELSE | `null`            |
| Valeur manquante comparée à `<`, `<=`, `>`, ou `>=`                            | Donne `null`     | Connexion ELSE | `null`            |
| Valeur manquante comparée à `==` et un littéral non nul                        | Évalue à `false` | Connexion ELSE | `false`           |
| Valeur manquante comparée à `== null`                                          | Évalue à `true`  | Connexion THEN | `true`            |
| Valeur manquante comparée à `!=` et un littéral non nul                        | Évalue à `true`  | Connexion THEN | `true`            |
| Erreur de syntaxe dans l’expression                                            | Donne `null`     | Connexion ELSE | `null`            |

{% hint style="warning" %}
Une ligne routée vers ELSE ne signifie pas toujours que l’attribut est enregistré sous la forme `false`. Une référence nulle seule et les opérateurs relationnels (`<`, `<=`, `>`, `>=`) routent vers ELSE, mais enregistrent l’attribut sous la forme `null`. Une expression en aval qui vérifie directement l’attribut (`my_flag == false` ou `my_flag == 0`) nécessite une protection sûre contre les valeurs nulles pour détecter ce cas, car elle ne correspondra pas à une `null` valeur.

Dans un **Initialiser un Attribut** nœud, les mêmes échecs omettent plutôt l’attribut du paquet de données sortant. Consultez [Valeurs manquantes dans les expressions](/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).
{% endhint %}

## Exemples pratiques d’implémentation

<details>

<summary>Surveillance de la température de la Flotte</summary>

**Exigence métier**: Surveiller les véhicules réfrigérés afin d’assurer la conformité de la température du chargement

```
value('cargo_temperature', 0, 'valid') > 4 || value('cargo_temperature', 0, 'valid') < -18
```

* **Branche THEN**: Envoyer immédiatement des Règles d’alertes au service de répartition, consigner les violations de conformité, déclencher des actions correctives
* **Branche ELSE**: Poursuivre le traitement normal pour les températures conformes, mettre à jour les tableaux de bord d’état

</details>

<details>

<summary>Application de la Sécurité du Conducteur</summary>

**Exigence métier**: Identifier les comportements d’Eco conduite dangereux pendant les heures de service actives

```
value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true
```

* **Branche THEN**: Générer des Rapports d’accompagnement des Conducteurs, envoyer des notifications de Sécurité, consigner les incidents
* **Branche ELSE**: Traiter les données de comportement d’Eco conduite normal, mettre à jour les indicateurs de performance

</details>

<details>

<summary>Règles d’alertes d’Entretien prédictif</summary>

**Exigence métier**: Détecter les défaillances potentielles des équipements avant qu’elles ne surviennent

```
value('engine_temperature', 0, 'valid') > 95 && value('oil_pressure', 0, 'valid') < 30
```

* **Branche THEN**: Planifier des rendez-vous d’Entretien, envoyer des Règles d’alertes aux techniciens, consigner les données de diagnostic
* **Branche ELSE**: Poursuivre la surveillance de routine, mettre à jour les tableaux de bord de l’état des équipements

</details>

<details>

<summary>Surveillance de la conformité des zones géographiques</summary>

**Exigence métier**: S’assurer que les véhicules circulent dans les zones autorisées pendant les heures de travail

```jexl
inGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true
```

Cette expression utilise la `inGeofence()` fonction pour vérifier si un appareil se trouve dans une Zone géographique nommée, combinée à un attribut d’heures de travail. Les limites de la Zone géographique sont gérées dans l’interface des zones géographiques Navixy, de sorte qu’aucune valeur de coordonnées ne doit être maintenue dans l’expression.

Le `== true` comparaison maintient le fonctionnement de la condition sur les paquets pour lesquels la fonction de Zone géographique ne peut pas décider, par exemple un paquet ne contenant aucune position. Sans elle, une valeur vide arrête toute la condition et le message est routé vers ELSE.

* **Branche THEN**: Poursuivre les opérations normales ; l’appareil se trouve dans la zone autorisée pendant les heures de travail.
* **Branche ELSE**: Générer une Règle d’alertes de localisation non autorisée, notifier la Sécurité et consigner la violation.

Pour détecter le moment où un véhicule quitte la zone autorisée plutôt que d’effectuer une vérification continue, utilisez `leaveGeofence()` à la place :

```jexl
leaveGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true
```

Pour la référence complète sur les fonctions de Zone géographique, y compris `enterGeofence()`, `geofenceName()`, et le test d’une position antérieure avec `inGeofence()`, voir [Fonctions de zone géographique](/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md).

</details>


---

# 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/logic-node/logic-node-expressions-and-syntax.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.