Avis de fin de support : le 20 mai 2026, AWS le support de AWS IoT Events. Après le 20 mai 2026, vous ne pourrez plus accéder à la AWS IoT Events console ni aux AWS IoT Events ressources. Pour plus d'informations, voir [AWS IoT Events fin du support](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html). Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Expressions pour filtrer, transformer et traiter les données d'événements Les expressions sont utilisées pour évaluer les données entrantes, effectuer des calculs et déterminer les conditions dans lesquelles des actions spécifiques ou des transitions d'état doivent se produire. AWS IoT Events propose plusieurs méthodes pour spécifier des valeurs lors de la création et de la mise à jour de modèles de détecteurs. Vous pouvez utiliser des expressions pour spécifier des valeurs littérales ou AWS IoT Events évaluer les expressions avant de spécifier des valeurs particulières. **Topics** + [Syntaxe permettant de filtrer les données de l'appareil et de définir des actions dans AWS IoT Events](#expression-syntax) + [Exemples d'expressions et utilisation pour AWS IoT Events](expression-usage.md) ## Syntaxe permettant de filtrer les données de l'appareil et de définir des actions dans AWS IoT Events Les expressions proposent une syntaxe permettant de filtrer les données des appareils et de définir des actions. Vous pouvez utiliser des littéraux, des opérateurs, des fonctions, des références et des modèles de substitution dans les AWS IoT Events expressions. En combinant ces composants, vous pouvez créer des expressions puissantes et flexibles pour traiter les données IoT, effectuer des calculs, manipuler des chaînes et prendre des décisions logiques au sein de vos modèles de détecteurs. ### Littéraux + Entier + Décimal + String + Booléen ### Opérateurs Unaire + Non (booléen) : `!` + Non (bit à bit) : `~` + Moins (arithmétique) : `-` String + Concaténation : **`+`** Les deux opérandes doivent être des chaînes. Les chaînes littérales doivent être placées entre guillemets simples ('). Par exemple : `'my' + 'string'` -> `'mystring'` Arithmétique + Ajout : **`+`** Les deux opérandes doivent être numériques. + Soustraction : **`-`** + Division : **`/`** Le résultat de la division est un entier arrondi sauf si au moins un des opérandes (diviseur ou dividende) est une valeur décimale. + Multiplication : **`*`** Bit par bit (entier) + OU : **`|`** Par exemple : `13 | 5` -> `13` + ET : **`&`** Par exemple : `13 & 5` -> `5` + PORTE : **`^`** Par exemple : `13 ^ 5` -> `8` + NE PAS : **`~`** Par exemple : `~13` -> `-14` Booléen + Inférieur à : **`<`** + Inférieur ou égal à : **`<=`** + Égal à : **`==`** + Non égal à : **`!=`** + Supérieur ou égal à : **`>=`** + Supérieur à : **`>`** + ET : **`&&`** + OU : **`||`** **Note** Lorsqu'une sous-expression de `||` contient des données non définies, cette sous-expression est traitée comme. `false` Parenthèses Vous pouvez utiliser des parenthèses pour regrouper les termes d'une expression. ### Fonctions à utiliser dans les AWS IoT Events expressions AWS IoT Events fournit un ensemble de fonctions intégrées pour améliorer les capacités des expressions de votre modèle de détecteur. Ces fonctions permettent la gestion du temporisateur, la conversion de type, la vérification nulle, l'identification du type de déclencheur, la vérification des entrées, la manipulation de chaînes et les opérations bit à bit. En tirant parti de ces fonctions, vous pouvez créer une logique de AWS IoT Events traitement réactive, améliorant ainsi l'efficacité globale de vos applications IoT. Fonctions intégrées `timeout("{{timer-name}}")` Indique `true` si le délai spécifié est expiré. Remplacez « {{*timer-name*}} » par le nom d'un temporisateur que vous avez défini, entre guillemets. Dans le cadre d'une action événementielle, vous pouvez définir un chronomètre, puis le démarrer, le réinitialiser ou en effacer un que vous avez défini précédemment. Voir le terrain`detectorModelDefinition.states.onInput|onEnter|onExit.events.actions.setTimer.timerName`. Un temporisateur réglé dans un état peut être référencé dans un état différent. Vous devez consulter l'état dans lequel vous avez créé le chronomètre avant de saisir l'état dans lequel le chronomètre est référencé. Par exemple, un modèle de détecteur possède deux états, `TemperatureChecked` et`RecordUpdated`. Vous avez créé un chronomètre dans l'`TemperatureChecked`État. Vous devez d'abord visiter l'`TemperatureChecked`État avant de pouvoir utiliser le chronomètre de l'`RecordUpdated`État. Pour garantir la précision, la durée minimale pendant laquelle une minuterie doit être réglée est de 60 secondes. `timeout()`renvoie `true` uniquement la première fois qu'il est vérifié après l'expiration réelle du délai et revient `false` par la suite. `convert({{type}}, {{expression}})` Évalue la valeur de l'expression convertie dans le type spécifié. La {{type}} valeur doit être `String``Boolean`, ou`Decimal`. Utilisez l'un de ces mots clés ou une expression qui correspond à une chaîne contenant le mot-clé. Seules les conversions suivantes réussissent et renvoient une valeur valide : + Booléen -> chaîne Renvoie la chaîne `"true"` ou`"false"`. + Décimal -> chaîne + Chaîne -> Booléen + Chaîne -> décimal La chaîne spécifiée doit être une représentation valide d'un nombre décimal, sinon elle `convert()` échoue. S'il `convert()` ne renvoie pas de valeur valide, l'expression dont il fait partie n'est pas non plus valide. Ce résultat est équivalent `false` et ne déclenchera pas le `actions` ou la transition vers le paramètre `nextState` spécifié dans le cadre de l'événement au cours duquel l'expression apparaît. `isNull({{expression}})` Indique `true` si l'expression renvoie la valeur null. Par exemple, si l'entrée `MyInput` reçoit le message`{ "a": null }`, la valeur suivante est évaluée à`true`, mais est `isUndefined($input.MyInput.a)` évaluée à. `false` ``` isNull($input.MyInput.a) ``` `isUndefined({{expression}})` Indique `true` si l'expression n'est pas définie. Par exemple, si l'entrée `MyInput` reçoit le message`{ "a": null }`, la valeur suivante est évaluée à`false`, mais est `isNull($input.MyInput.a)` évaluée à. `true` ``` isUndefined($input.MyInput.a) ``` `triggerType("{{type}}")` La {{type}} valeur peut être `"Message"` ou`"Timer"`. Indique `true` si la condition d'événement dans laquelle il apparaît est en cours d'évaluation parce qu'un délai a expiré, comme dans l'exemple suivant. ``` triggerType("Timer") ``` Ou un message d'entrée a été reçu. ``` triggerType("Message") ``` `currentInput("{{input}}")` Indique `true` si la condition d'événement dans laquelle il apparaît est en cours d'évaluation parce que le message d'entrée spécifié a été reçu. Par exemple, si l'entrée `Command` reçoit le message`{ "value": "Abort" }`, la valeur suivante est évaluée à`true`. ``` currentInput("Command") ``` Utilisez cette fonction pour vérifier que la condition est en cours d'évaluation parce qu'une entrée particulière a été reçue et qu'un délai n'a pas expiré, comme dans l'expression suivante. ``` currentInput("Command") && $input.Command.value == "Abort" ``` Fonctions de correspondance de chaînes `startsWith({{expression1}}, {{expression2}})` Indique `true` si la première expression de chaîne commence par la deuxième expression de chaîne. Par exemple, si input `MyInput` reçoit le message`{ "status": "offline"}`, la valeur suivante est attribuée à`true`. ``` startsWith($input.MyInput.status, "off") ``` Les deux expressions doivent être évaluées à une valeur de chaîne. Si aucune des expressions n'est évaluée à une valeur de chaîne, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. `endsWith({{expression1}}, {{expression2}})` Indique `true` si la première expression sous forme de chaîne se termine par la deuxième expression sous forme de chaîne. Par exemple, si input `MyInput` reçoit le message`{ "status": "offline" }`, la valeur suivante est attribuée à`true`. ``` endsWith($input.MyInput.status, "line") ``` Les deux expressions doivent être évaluées à une valeur de chaîne. Si aucune des expressions n'est évaluée à une valeur de chaîne, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. `contains({{expression1}}, {{expression2}})` Indique `true` si la première expression de chaîne contient la deuxième expression de chaîne. Par exemple, si input `MyInput` reçoit le message`{ "status": "offline" }`, la valeur suivante est attribuée à`true`. ``` contains($input.MyInput.value, "fli") ``` Les deux expressions doivent être évaluées à une valeur de chaîne. Si aucune des expressions n'est évaluée à une valeur de chaîne, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. Fonctions de manipulation d'entiers au niveau du bit `bitor({{expression1}}, {{expression2}})` Évalue le OR au niveau du bit des expressions entières (l'opération binaire OR est effectuée sur les bits correspondants des entiers). Par exemple, si input `MyInput` reçoit le message`{ "value1": 13, "value2": 5 }`, la valeur suivante est attribuée à`13`. ``` bitor($input.MyInput.value1, $input.MyInput.value2) ``` Les deux expressions doivent être évaluées à une valeur entière. Si aucune des expressions n'est évaluée à une valeur entière, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. `bitand({{expression1}}, {{expression2}})` Évalue le ET par bit des expressions entières (l'opération binaire ET est effectuée sur les bits correspondants des entiers). Par exemple, si input `MyInput` reçoit le message`{ "value1": 13, "value2": 5 }`, la valeur suivante est attribuée à`5`. ``` bitand($input.MyInput.value1, $input.MyInput.value2) ``` Les deux expressions doivent être évaluées à une valeur entière. Si aucune des expressions n'est évaluée à une valeur entière, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. `bitxor({{expression1}}, {{expression2}})` Évalue le XOR bit à bit des expressions entières (l'opération XOR binaire est effectuée sur les bits correspondants des entiers). Par exemple, si input `MyInput` reçoit le message`{ "value1": 13, "value2": 5 }`, la valeur suivante est attribuée à`8`. ``` bitxor($input.MyInput.value1, $input.MyInput.value2) ``` Les deux expressions doivent être évaluées à une valeur entière. Si aucune des expressions n'est évaluée à une valeur entière, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. `bitnot({{expression}})` Évalue le NOT par bit de l'expression entière (l'opération binaire NOT est effectuée sur les bits de l'entier). Par exemple, si input `MyInput` reçoit le message`{ "value": 13 }`, la valeur suivante est attribuée à`-14`. ``` bitnot($input.MyInput.value) ``` Les deux expressions doivent être évaluées à une valeur entière. Si aucune des expressions n'est évaluée à une valeur entière, le résultat de la fonction n'est pas défini. Aucune conversion n'est effectuée. ### AWS IoT Events référence pour les entrées et les variables dans les expressions Inputs `$input.{{input-name}}.{{path-to-data}}` `input-name`est une entrée que vous créez à l'aide de l'[CreateInput](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateInput.html)action. Par exemple, si vous avez nommé une entrée `TemperatureInput` pour laquelle vous avez défini des `inputDefinition.attributes.jsonPath` entrées, les valeurs peuvent apparaître dans les champs disponibles suivants. ``` { "temperature": 78.5, "date": "2018-10-03T16:09:09Z" } ``` Pour référencer la valeur du `temperature` champ, utilisez la commande suivante. ``` $input.TemperatureInput.temperature ``` Pour les champs dont les valeurs sont des tableaux, vous pouvez référencer les membres du tableau en utilisant`[{{n}}]`. Par exemple, étant donné les valeurs suivantes : ``` { "temperatures": [ 78.4, 77.9, 78.8 ], "date": "2018-10-03T16:09:09Z" } ``` La valeur `78.8` peut être référencée à l'aide de la commande suivante. ``` $input.TemperatureInput.temperatures[2] ``` Variables `$variable.{{variable-name}}` `{{variable-name}}`Il s'agit d'une variable que vous avez définie à l'aide de l'[CreateDetectorModel](https://docs.aws.amazon.com/iotevents/latest/apireference/API_CreateDetectorModel.html)action. Par exemple, si vous avez défini une variable nommée `TechnicianID` à l'aide de la commande suivante`detectorDefinition.states.onInputEvents.actions.setVariable.variableName`, vous pouvez référencer la dernière valeur (chaîne) donnée à la variable. ``` $variable.TechnicianID ``` Vous pouvez définir les valeurs des variables uniquement à l'aide de cette `setVariable` action. Vous ne pouvez pas attribuer de valeurs aux variables d'une expression. Une variable ne peut pas être désactivée. Par exemple, vous ne pouvez pas lui attribuer la valeur`null`. **Note** Dans les références qui utilisent des identifiants qui ne suivent pas le modèle (expression régulière)`[a-zA-Z][a-zA-Z0-9_]*`, vous devez placer ces identifiants dans des backticks (). ``` Par exemple, une référence à une entrée nommée `MyInput` par un champ `_value` doit spécifier ce champ sous la forme`$input.MyInput.`_value``. Lorsque vous utilisez des références dans des expressions, vérifiez les points suivants : + Lorsque vous utilisez une référence comme opérande avec un ou plusieurs opérateurs, assurez-vous que tous les types de données auxquels vous faites référence sont compatibles. Par exemple, dans l'expression suivante, le nombre entier `2` est un opérande des `&&` opérateurs `==` et. Pour garantir la compatibilité des opérandes, `$variable.testVariable + 1` ils `$variable.testVariable` doivent faire référence à un entier ou à un nombre décimal. De plus, le nombre entier `1` est un opérande de l'`+`opérateur. Par conséquent, `$variable.testVariable` doit faire référence à un entier ou à un nombre décimal. ``` ‘$variable.testVariable + 1 == 2 && $variable.testVariable’ ``` + Lorsque vous utilisez une référence comme argument transmis à une fonction, assurez-vous que celle-ci prend en charge les types de données auxquels vous faites référence. Par exemple, la `timeout("{{time-name}}")` fonction suivante nécessite une chaîne avec des guillemets comme argument. Si vous utilisez une référence pour la {{timer-name}} valeur, vous devez référencer une chaîne entre guillemets. ``` timeout("{{timer-name}}") ``` **Note** Pour la `convert({{type}}, {{expression}})` fonction, si vous utilisez une référence pour la {{type}} valeur, le résultat évalué de votre référence doit être `String``Decimal`, ou`Boolean`. AWS IoT Events les expressions prennent en charge les types de données entiers, décimaux, chaînes et booléens. Le tableau suivant fournit une liste de paires de types incompatibles. | Paires de types incompatibles | | --- | | Entier, chaîne | | Entier, booléen | | Décimal, chaîne | | Décimal, booléen | | Chaîne, booléen | ### Modèles de substitution pour les AWS IoT Events expressions **** `'${{{expression}}}'` `${}`Identifie la chaîne en tant que chaîne interpolée. Il `expression` peut s'agir de n'importe quelle AWS IoT Events expression. Cela inclut les opérateurs, les fonctions et les références. Par exemple, vous avez utilisé cette [SetVariableAction](https://docs.aws.amazon.com/iotevents/latest/apireference/API_SetVariableAction.html)action pour définir une variable. Le `variableName` est `SensorID` et l’`value` est `10`. Vous pouvez créer les modèles de substitution suivants. [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/iotevents/latest/developerguide/iotevents-expressions.html)