

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.

# Utiliser des expressions de formule
<a name="formula-expressions"></a>

Avec les expressions de formule, vous pouvez définir les fonctions mathématiques permettant de transformer et d'agréger vos données industrielles brutes afin d'obtenir des informations sur votre opération. Les expressions de formule combinent des littéraux, des opérateurs, des fonctions et des variables pour traiter les données. Pour plus d'informations sur la façon de définir les propriétés des actifs qui utilisent des expressions de formule, reportez-vous [Transformer les données (transformations)](transforms.md) aux sections et[Données agrégées provenant de propriétés et d'autres actifs (métriques)](metrics.md). Les transformations et les métriques sont des propriétés de formule.

**Topics**
+ [Utiliser des variables dans les expressions de formule](expression-variables.md)
+ [Utiliser des littéraux dans les expressions de formule](expression-literals.md)
+ [Utiliser des opérateurs dans les expressions de formule](expression-operators.md)
+ [Utiliser des constantes dans les expressions de formule](expression-constants.md)
+ [Utiliser des fonctions dans des expressions de formule](expression-functions.md)
+ [Tutoriels d'expression de formules](expression-tutorials.md)

# Utiliser des variables dans les expressions de formule
<a name="expression-variables"></a>

Les variables représentent les propriétés des AWS IoT SiteWise actifs dans les expressions de formule. Utilisez des variables pour saisir des valeurs provenant d'autres propriétés d'actifs dans vos expressions, afin de pouvoir traiter les données issues de propriétés constantes ([attributs](attributes.md)), de flux de données brutes ([mesures](measurements.md)) et d'autres propriétés de formule.

Les variables peuvent représenter les propriétés des actifs à partir du même modèle d'actif ou à partir de modèles d'actifs enfants associés. Seules les formules métriques peuvent saisir des variables à partir de modèles d'actifs enfants.

Vous identifiez les variables sous différents noms dans la console et dans l'API.
+ **AWS IoT SiteWise console** — Utilisez les noms des propriétés des actifs comme variables dans vos expressions.
+ **AWS IoT SiteWise API (AWS CLI, AWS SDKs)** — Définissez les variables avec la [ExpressionVariable](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExpressionVariable.html)structure, qui nécessite un nom de variable et une référence à une propriété d'actif. Le nom de la variable peut contenir des lettres minuscules, des chiffres et des traits de soulignement. Utilisez ensuite des noms de variables pour référencer les propriétés des actifs dans vos expressions.

Les noms de variables distinguent les majuscules et minuscules.

Pour plus d'informations, consultez les [sections Définition des transformations](transforms.md) et [Définition des métriques](metrics.md).

## Utiliser des variables pour référencer les propriétés
<a name="variable-values"></a>

La *valeur* d'une variable définit la propriété à laquelle elle fait référence. AWS IoT SiteWise propose différentes manières de le faire.
+ **Par identifiant de propriété :** vous pouvez spécifier l'identifiant unique (UUID) de la propriété pour l'identifier.
+ **Par nom :** si la propriété utilise le même modèle d'actif, vous pouvez spécifier son nom dans le champ ID de propriété.
+ **Par chemin :** la valeur d'une variable peut faire référence à une propriété par son *chemin.* Pour de plus amples informations, veuillez consulter [Utiliser des chemins pour référencer les propriétés personnalisées du modèle composite](custom-composite-models.md#property-paths).

**Note**  
 Les variables ne sont pas prises en charge par AWS IoT SiteWise la console. Ils sont utilisés par AWS IoT SiteWise l'API, notamment le AWS Command Line Interface AWS CLI) et AWS SDKs. 

 Une variable que vous recevez dans une réponse AWS IoT SiteWise inclut des informations complètes sur la valeur, notamment l'ID et le chemin.

 Toutefois, lorsque vous transmettez une variable à AWS IoT SiteWise (par exemple, lors d'un appel « créer » ou « mettre à jour »), il vous suffit de spécifier l'une de ces variables. Par exemple, si vous spécifiez le chemin, vous n'avez pas besoin de fournir l'ID. 

# Utiliser des littéraux dans les expressions de formule
<a name="expression-literals"></a>

AWS IoT SiteWise prend en charge l'utilisation de littéraux dans les expressions et les formules. Les littéraux sont des valeurs fixes qui représentent un type de données spécifique. Dans AWS IoT SiteWise, vous pouvez définir des nombres et des littéraux de chaîne dans les expressions de formule. Les littéraux peuvent être utilisés dans différents contextes, notamment les transformations de données, les conditions d'alarme et les calculs de visualisation.


+ <a name="number-literal-definition"></a>**Chiffres**

  Utilisez les nombres et la notation scientifique pour définir des nombres entiers et des doubles. Vous pouvez utiliser la [notation E](https://en.wikipedia.org/wiki/Scientific_notation#E_notation) pour exprimer des nombres en notation scientifique.

  Exemples : `1``2.0`,`.9`,`-23.1`,`7.89e3`, `3.4E-5`
+ <a name="string-literal-definition"></a>**Chaînes**

  Utilisez les caractères `'` (guillemets) et `"` (guillemets doubles) pour définir les chaînes. Le type de devis pour le début et la fin doit correspondre. Pour éviter un guillemet correspondant à celui que vous utilisez pour déclarer une chaîne, incluez ce guillemet deux fois. Il s'agit du seul caractère d'échappement dans AWS IoT SiteWise les chaînes.

  Exemples : `'active'`, `"inactive"`, `'{"temp": 52}'`, `"{""temp"": ""high""}"`

# Utiliser des opérateurs dans les expressions de formule
<a name="expression-operators"></a>

Vous pouvez utiliser les opérateurs courants suivants dans les expressions de formule.


| Opérateur | Description | 
| --- | --- | 
|  `+`  |  Si les deux opérandes sont des nombres, cet opérateur ajoute les opérandes gauche et droit. Si l'un des opérandes est une chaîne, cet opérateur concatène les opérandes gauche et droit sous forme de chaînes. Par exemple, l'expression est `1 + 2 + " is three"` évaluée à. `"3 is three"` La chaîne concaténée peut comporter jusqu'à 1024 caractères. Si la chaîne dépasse 1024 caractères, elle AWS IoT SiteWise ne produit aucun point de données pour ce calcul.  | 
|  `-`  |  Il soustrait l'opérande droit de l'opérande gauche. <a name="operator-numbers-only"></a>Vous ne pouvez utiliser cet opérateur qu'avec des opérandes numériques.  | 
|  `/`  |  Il divise l'opérande gauche par l'opérande droit. <a name="operator-numbers-only"></a>Vous ne pouvez utiliser cet opérateur qu'avec des opérandes numériques.  | 
|  `*`  |  Il multiplie les opérandes gauche et droit. <a name="operator-numbers-only"></a>Vous ne pouvez utiliser cet opérateur qu'avec des opérandes numériques.  | 
|  `^`  |  Il élève l'opérande gauche à la puissance de l'opérande droit (élévation de la puissance). <a name="operator-numbers-only"></a>Vous ne pouvez utiliser cet opérateur qu'avec des opérandes numériques.  | 
|  `%`  |  Il renvoie le reste résultant de la division de l'opérande gauche par l'opérande droit. Le résultat a le même signe que l'opérande gauche. Ce comportement est différent de celui de l'opération modulo. <a name="operator-numbers-only"></a>Vous ne pouvez utiliser cet opérateur qu'avec des opérandes numériques.  | 
|  `x < y`  |  Renvoie `1` si la valeur `x` est inférieure à`y`, sinon`0`.  | 
|  `x > y`  |  Renvoie `1` si la valeur `x` est supérieure à`y`, sinon`0`.  | 
|  `x <= y`  |  Renvoie `1` si la valeur `x` est inférieure ou égale à`y`, sinon`0`.  | 
|  `x >= y`  |  Renvoie `1` si la valeur `x` est supérieure ou égale à`y`, sinon`0`.  | 
|  `x == y`  |  Renvoie `1` si `x` c'est égal à`y`, sinon`0`.  | 
|  `x != y`  |  Renvoie `1` si `x` ce n'est pas égal à`y`, sinon`0`.  | 
|  `!x`  |  Renvoie `1` si la valeur `x` est évaluée à `0` (faux), sinon`0`. `x`est évalué à faux si :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-operators.html)  | 
|  `x and y`  |  Renvoie `0` si la valeur `x` est évaluée à `0` (faux). Sinon, renvoie le résultat évalué de`y`. `x`ou `y` est évalué à faux si :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-operators.html)  | 
|  `x or y`  |  Renvoie `1` si la valeur `x` est évaluée à `1` (vrai). Sinon, renvoie le résultat évalué de`y`. `x`ou `y` est évalué à faux si :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-operators.html)  | 
|  `not x`  |  Renvoie `1` si la valeur `x` est évaluée à `0` (faux), sinon`0`. `x`est évalué à faux si :  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-operators.html)  | 
|   `[]` `s[index]`  |  Renvoie le caractère à un index `index` de la chaîne`s`. Ceci est équivalent à la syntaxe d'index en Python. 

**Example Exemples**  
+ `"Hello!"[1]` renvoie `e`.
+ `"Hello!"[-2]` renvoie `o`.  | 
|   `[]` `s[start:end:step]`  |  Renvoie une tranche de la chaîne`s`. Ceci est équivalent à la syntaxe des tranches en Python. Cet opérateur possède les arguments suivants : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-operators.html) Vous pouvez omettre l'`step`argument pour utiliser sa valeur par défaut. Par exemple, `s[1:4:1]` équivaut à `s[1:4]`. Les arguments doivent être des entiers ou la constante [none](expression-constants.md#none-definition). Si vous le spécifiez`none`, AWS IoT SiteWise utilise la valeur par défaut pour cet argument. 

**Example Exemples**  
+ `"Hello!"[1:4]` renvoie `"ell"`.
+ `"Hello!"[:2]` renvoie `"He"`.
+ `"Hello!"[3:]` renvoie `"lo!"`.
+ `"Hello!"[:-4]` renvoie `"He"`.
+ `"Hello!"[::2]` renvoie `"Hlo"`.
+ `"Hello!"[::-1]` renvoie `"!olleH"`.  | 

# Utiliser des constantes dans les expressions de formule
<a name="expression-constants"></a>

Dans AWS IoT SiteWise, vous pouvez utiliser des constantes dans vos expressions et formules pour représenter des valeurs fixes ou des paramètres prédéfinis. Les constantes peuvent être utilisées dans différents contextes, tels que les transformations de données, les conditions d'alarme ou les calculs de visualisation. En utilisant des constantes, vous pouvez simplifier vos expressions et les rendre plus lisibles et faciles à gérer.

Vous pouvez utiliser les constantes mathématiques courantes suivantes dans vos expressions. Toutes les constantes ne distinguent pas les majuscules et minuscules.

**Note**  
Si vous définissez une variable portant le même nom qu'une constante, la variable remplace la constante.


| Constant | Description | 
| --- | --- | 
|  `pi`  |  Le nombre pi (`π`) : `3.141592653589793`  | 
|  `e`  |  Le chiffre e : `2.718281828459045`  | 
|  `true`  |  C'est l'équivalent du chiffre 1. Dans AWS IoT SiteWise, les booléens sont convertis en équivalents numériques.  | 
|  `false`  |  Équivalent au chiffre 0. Dans AWS IoT SiteWise, les booléens sont convertis en équivalents numériques.  | 
|   `none`  |  C'est équivalent à aucune valeur. Vous pouvez utiliser cette constante pour ne rien afficher à la suite d'une [expression conditionnelle](expression-conditional-functions.md).  | 

# Utiliser des fonctions dans des expressions de formule
<a name="expression-functions"></a>

Vous pouvez utiliser les fonctions suivantes pour agir sur les données de vos expressions de formule.

Les transformations et les métriques prennent en charge différentes fonctions. Le tableau suivant indique les types de fonctions compatibles avec chaque type de propriété de formule.

**Note**  
Vous pouvez inclure un maximum de 10 fonctions dans une expression de formule.


| Type de fonction | Transforme | Métriques | 
| --- | --- | --- | 
|  [Utiliser des fonctions courantes dans les expressions de formule](expression-common-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser les fonctions de comparaison dans les expressions de formule](expression-comparison-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser des fonctions conditionnelles dans les expressions de formule](expression-conditional-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser des fonctions de chaîne dans les expressions de formule](expression-string-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser les fonctions d'agrégation dans les expressions de formule](expression-aggregation-functions.md)  |  <a name="polaris-no-para"></a>![\[A red circle with the letter x for no.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-no.png) Non  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser des fonctions temporelles dans les expressions de formules](expression-temporal-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 
|  [Utiliser les fonctions de date et d'heure dans les expressions de formule](expression-date-and-time-functions.md)  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  |  <a name="polaris-yes-para"></a>![\[A green circle with a checkmark for yes.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/icon-yes.png) Oui  | 

## Syntaxe des fonctions
<a name="expression-function-syntax"></a>

Vous pouvez utiliser la syntaxe suivante pour créer des fonctions :

Syntaxe régulière  
Avec la syntaxe normale, le nom de la fonction est suivi de parenthèses contenant zéro argument ou plus.  
`function_name(argument1, argument2, argument3, ...)`. Par exemple, les fonctions dont la syntaxe est normale peuvent ressembler à `log(x)` et`contains(s, substring)`.

Syntaxe uniforme des appels de fonction (UFCS)  
L'UFCS vous permet d'appeler des fonctions en utilisant la syntaxe des appels de méthode dans la programmation orientée objet. Avec UFCS, le premier argument est suivi par point (`.`), puis le nom de la fonction et les autres arguments (le cas échéant) entre parenthèses.  
`argument1.function_name(argument2, argument3, ...)`. Par exemple, les fonctions associées à l'UFCS peuvent ressembler à `x.log()` et`s.contains(substring)`.  
Vous pouvez également utiliser l'UFCS pour enchaîner les fonctions suivantes. AWS IoT SiteWise utilise le résultat de l'évaluation de la fonction en cours comme premier argument de la fonction suivante.  
Par exemple, vous pouvez utiliser à la `message.jp('$.status').lower().contains('fail')` place de`contains(lower(jp(message, '$.status')),'fail')`.  
Pour plus d'informations, consultez le site Web du [langage de programmation D.](https://tour.dlang.org/tour/en/gems/uniform-function-call-syntax-ufcs)

**Note**  
Vous pouvez utiliser l'UFCS pour toutes les AWS IoT SiteWise fonctions.  
AWS IoT SiteWise les fonctions ne distinguent pas les majuscules et minuscules. Par exemple, vous pouvez utiliser `lower(s)` et de `Lower(s)` manière interchangeable.

# Utiliser des fonctions courantes dans les expressions de formule
<a name="expression-common-functions"></a>

Dans les [transformations](transforms.md) et [les métriques](metrics.md), vous pouvez utiliser les fonctions suivantes pour calculer les fonctions mathématiques courantes dans les transformations et les métriques.


| Fonction | Description | 
| --- | --- | 
|  `abs(x)`  |  Renvoie la valeur absolue de `x`.  | 
|  `acos(x)`  |  Renvoie l'arc cosinus de `x`.  | 
|  `asin(x)`  |  Renvoie l'arc sinus de `x`.  | 
|  `atan(x)`  |  Renvoie l'arc tangent de `x`.  | 
|  `cbrt(x)`  |  Renvoie la racine cubique de `x`.  | 
|  `ceil(x)`  |  Renvoie l'entier le plus proche supérieur à `x`.  | 
|  `cos(x)`  |  Renvoie le cosinus de `x`.  | 
|  `cosh(x)`  |  Renvoie le cosinus hyperbolique de `x`.  | 
|  `cot(x)`  |  Renvoie la cotangente de. `x`  | 
|  `exp(x)`  |  Renvoie `e` à la puissance de `x`.  | 
|  `expm1(x)`  |  Renvoie `exp(x) - 1`. Utilisez cette fonction pour calculer avec plus de précision `exp(x) - 1` les petites valeurs de`x`.  | 
|  `floor(x)`  |  Renvoie l'entier le plus proche inférieur à `x`.  | 
|  `log(x)`  |  Renvoie l'élément `loge` (base `e`) de `x`.  | 
|  `log10(x)`  |  Renvoie l'élément `log10` (base `10`) de `x`.  | 
|  `log1p(x)`  |  Renvoie `log(1 + x)`. Utilisez cette fonction pour calculer avec plus de précision `log(1 + x)` les petites valeurs de`x`.  | 
|  `log2(x)`  |  Renvoie l'élément `log2` (base `2`) de `x`.  | 
|  `pow(x, y)`  |  Renvoie `x` à la puissance de `y`. Cela équivaut à`x ^ y`.  | 
|  `signum(x)`  |  Renvoie le signe de `x` (`-1` pour les entrées négatives, `0` pour les entrées nulles et `+1` pour les entrées positives).  | 
|  `sin(x)`  |  Renvoie le sinus de `x`.  | 
|  `sinh(x)`  |  Renvoie le sinus hyperbolique de `x`.  | 
|  `sqrt(x)`  |  Renvoie la racine carrée de `x`.  | 
|  `tan(x)`  |  Renvoie la tangente de `x`.  | 
|  `tanh(x)`  |  Renvoie la tangente hyperbolique de `x`.  | 

# Utiliser les fonctions de comparaison dans les expressions de formule
<a name="expression-comparison-functions"></a>

Dans les [transformations](transforms.md) et [les métriques](metrics.md), vous pouvez utiliser les fonctions de comparaison suivantes pour comparer deux valeurs et obtenir un résultat `1` (vrai) ou `0` (faux). AWS IoT SiteWise compare les chaînes par ordre [lexicographique](https://en.wikipedia.org/wiki/Lexicographic_order).


| Fonction | Description | 
| --- | --- | 
|  `gt(x, y)`  |  Renvoie `1` si `x` est supérieur à `y`, sinon `0` (`x > y`). <a name="comparison-function-incompatible-types"></a>Cette fonction ne renvoie pas de valeur si `x` les types `y` sont incompatibles, tels qu'un nombre et une chaîne.  | 
|  `gte(x, y)`  |  Renvoie `1` si `x` est supérieur ou égal à `y`, sinon `0` (`x ≥ y`). <a name="comparison-function-relative-tolerance"></a>AWS IoT SiteWise considère que les arguments sont égaux s'ils se situent dans une tolérance relative de`1E-9`. Cela se comporte de la même manière que la fonction [isclose](https://docs.python.org/3/library/math.html#math.isclose) en Python. <a name="comparison-function-incompatible-types"></a>Cette fonction ne renvoie pas de valeur si `x` les types `y` sont incompatibles, tels qu'un nombre et une chaîne.  | 
|  `eq(x, y)`  |  Renvoie `1` si `x` est égal à `y`, sinon `0` (`x == y`). <a name="comparison-function-relative-tolerance"></a>AWS IoT SiteWise considère que les arguments sont égaux s'ils se situent dans une tolérance relative de`1E-9`. Cela se comporte de la même manière que la fonction [isclose](https://docs.python.org/3/library/math.html#math.isclose) en Python. <a name="comparison-function-incompatible-types"></a>Cette fonction ne renvoie pas de valeur si `x` les types `y` sont incompatibles, tels qu'un nombre et une chaîne.  | 
|  `lt(x, y)`  |  Renvoie `1` si `x` est inférieur à `y`, sinon `0` (`x < y`). <a name="comparison-function-incompatible-types"></a>Cette fonction ne renvoie pas de valeur si `x` les types `y` sont incompatibles, tels qu'un nombre et une chaîne.  | 
|  `lte(x, y)`  |  Renvoie `1` si `x` est inférieur ou égal à `y`, sinon `0` (`x ≤ y`). <a name="comparison-function-relative-tolerance"></a>AWS IoT SiteWise considère que les arguments sont égaux s'ils se situent dans une tolérance relative de`1E-9`. Cela se comporte de la même manière que la fonction [isclose](https://docs.python.org/3/library/math.html#math.isclose) en Python. <a name="comparison-function-incompatible-types"></a>Cette fonction ne renvoie pas de valeur si `x` les types `y` sont incompatibles, tels qu'un nombre et une chaîne.  | 
|  `isnan(x)`  |  Renvoie `1` si `x` c'est égal à`NaN`, sinon`0`. Cette fonction ne renvoie pas de valeur s'il s'`x`agit d'une chaîne.  | 

# Utiliser des fonctions conditionnelles dans les expressions de formule
<a name="expression-conditional-functions"></a>

Dans les [transformations](transforms.md) et [les métriques](metrics.md), vous pouvez utiliser la fonction suivante pour vérifier une condition et renvoyer différents résultats, que la condition soit vraie ou fausse.


| Fonction | Description | 
| --- | --- | 
|   `if(condition, result_if_true, result_if_false)`  |  Évalue `condition` et renvoie `result_if_true` si la condition est vraie ou `result_if_false` si la condition est évaluée à. `false` `condition`doit être un chiffre. Cette fonction considère `0` une chaîne vide comme `false` et tout le reste (y compris`NaN`) comme`true`. Les booléens sont convertis en `0` (faux) et `1` (vrai). Vous pouvez renvoyer la [constante none](expression-constants.md#none-definition) à partir de cette fonction pour supprimer la sortie pour une condition particulière. Cela signifie que vous pouvez filtrer les points de données qui ne répondent pas à une condition. Pour de plus amples informations, veuillez consulter [Filtrer les points de données](expression-tutorials.md#filter-data). 

**Example Exemples**  
+ `if(0, x, y)`renvoie la variable`y`.
+ `if(5, x, y)`renvoie la variable`x`.
+ `if(gt(temp, 300), x, y)`renvoie la variable `x` si celle-ci `temp` est supérieure à`300`.
+ `if(gt(temp, 300), temp, none)`renvoie la variable `temp` si elle est supérieure ou égale à`300`, ou `none` (aucune valeur) si elle `temp` est inférieure à`300`. Nous vous recommandons d'utiliser l'UFCS pour les fonctions conditionnelles imbriquées dans lesquelles un ou plusieurs arguments sont des fonctions conditionnelles. Vous pouvez l'utiliser `if(condition, result_if_true)` pour évaluer une condition et `elif(condition, result_if_true, result_if_false)` pour évaluer des conditions supplémentaires. Par exemple, vous pouvez utiliser à la `if(condition1, result1_if_true).elif(condition2, result2_if_true, result2_if_false)` place de`if(condition1, result1_if_true, if(condition2, result2_if_true, result2_if_false))`. Vous pouvez également enchaîner des fonctions conditionnelles intermédiaires supplémentaires. Par exemple, vous pouvez utiliser plusieurs `if` instructions `if(condition1, result1_if_true).elif(condition2, result2_if_true).elif(condition3, result3_if_true, result3_if_false)` au lieu de les imbriquer, telles que`if(condition1, result1_if_true, if(condition2, result2_if_true, if(condition3, result3_if_true result3_if_false)))`.  Vous devez l'utiliser `elif(condition, result_if_true, result_if_false)` avec l'UFCS.   | 

# Utiliser des fonctions de chaîne dans les expressions de formule
<a name="expression-string-functions"></a>

Dans les [transformations](transforms.md) et [les métriques](metrics.md), vous pouvez utiliser les fonctions suivantes pour agir sur des chaînes. Pour de plus amples informations, veuillez consulter [Utiliser des chaînes dans les formules](expression-tutorials.md#use-strings-in-formulas).

**Important**  
<a name="formula-output-rules"></a>Les expressions de formule ne peuvent générer que des valeurs doubles ou des valeurs de chaîne. Les expressions imbriquées peuvent générer d'autres types de données, tels que des chaînes, mais la formule dans son ensemble doit être évaluée à un nombre ou à une chaîne. Vous pouvez utiliser la [fonction jp](#jp-definition) pour convertir une chaîne en nombre. La valeur booléenne doit être 1 (vrai) ou 0 (faux). Pour de plus amples informations, veuillez consulter [Valeurs non définies, infinies et en dépassement](expression-tutorials.md#undefined-values).


| Fonction | Description | 
| --- | --- | 
|  `len(s)`  |  Renvoie la longueur de la chaîne`s`.  | 
|  `find(s, substring)`  |  Renvoie l'index de la chaîne `substring` dans la chaîne`s`.  | 
|  `contains(s, substring)`  |  Renvoie `1` si la chaîne `s` contient la chaîne`substring`, sinon`0`.  | 
|  `upper(s)`  |  Renvoie la chaîne `s` en majuscules.  | 
|  `lower(s)`  |  Renvoie la chaîne `s` en minuscules.  | 
|   `jp(s, json_path)`  |  Évalue la chaîne `s` avec l'[JsonPath](https://github.com/json-path/JsonPath)expression `json_path` et renvoie le résultat. Utilisez cette fonction pour effectuer les opérations suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-string-functions.html) Pour extraire une valeur de chaîne d'une structure JSON et la renvoyer sous forme de nombre, vous devez utiliser plusieurs `jp` fonctions imbriquées. La `jp` fonction externe extrait la chaîne de la structure JSON et la `jp` fonction interne convertit la chaîne en nombre. La chaîne `json_path` doit contenir une chaîne littérale. Cela signifie qu'il ne `json_path` peut pas s'agir d'une expression évaluée en chaîne. 

**Example Exemples**  
+ `jp('{"status":"active","value":15}', '$.value')` renvoie `15`.
+ `jp('{"measurement":{"reading":25,"confidence":0.95}}', '$.measurement.reading')` renvoie `25`.
+ `jp('[2,8,23]', '$[2]')` renvoie `23`.
+ `jp('{"values":[3,6,7]}', '$.values[1]')` renvoie `6`.
+ `jp('111', '$')` renvoie `111`.
+ `jp(jp('{"measurement":{"reading":25,"confidence":"0.95"}}', '$.measurement.confidence'), '$')` renvoie `0.95`.  | 
|  `join(s0, s1, s2, s3, ...)`  |  Renvoie une chaîne concaténée avec un délimiteur. Cette fonction utilise la première chaîne d'entrée comme délimiteur et réunit les chaînes d'entrée restantes. Cela se comporte de la même manière que la fonction [join (CharSequence delimiter, CharSequence... elements)](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#join-java.lang.CharSequence-java.lang.CharSequence...-) en Java. 

**Example Exemples**  
+ `join("-", "aa", "bb", "cc")`retours `aa-bb-cc`  | 
|  `format(expression: "format")` ou `format("format", expression)`  |  Renvoie une chaîne au format spécifié. Cette fonction donne `expression` une valeur, puis renvoie la valeur dans le format spécifié. Cela se comporte de la même manière que la fonction [format (String format, Object... args)](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#format-java.lang.String-java.lang.Object...-) en Java. Pour plus d'informations sur les formats pris en charge, consultez la section Conversions sous [Class Formatter](https://docs.oracle.com/javase/7/docs/api/java/util/Formatter.html) dans la *plate-forme Java, spécification de l'API Standard Edition 7*. 

**Example Exemples**  
+ `format(100+1: "d")`renvoie une chaîne,`101`.
+ `format("The result is %d", 100+1)`renvoie une chaîne,`The result is 101`.  | 
|  `f'expression'`  |  Renvoie une chaîne concaténée. Avec cette fonction formatée, vous pouvez utiliser une expression simple pour concaténer et formater des chaînes. Ces fonctions peuvent contenir des expressions imbriquées. Vous pouvez utiliser `{}` (accolades) pour interpoler des expressions. Cela se comporte de la même manière que les [littéraux de chaîne formatés en Python](https://docs.python.org/3/reference/lexical_analysis.html#f-strings). 

**Example Exemples**  
+ `f'abc{1+2: "f"}d'` renvoie `abc3.000000d`. Pour évaluer cet exemple d'expression, procédez comme suit :

  1. `format(1+2: "f")`renvoie un nombre à virgule flottante,`3.000000`.

  1. `join('', "abc", 1+2, 'd')`renvoie une chaîne,`abc3.000000d`.

  Vous pouvez également écrire l'expression de la manière suivante :`join('', "abc", format(1+2: "f"), 'd')`.  | 

# Utiliser les fonctions d'agrégation dans les expressions de formule
<a name="expression-aggregation-functions"></a>

Dans [les métriques](metrics.md) uniquement, vous pouvez utiliser les fonctions suivantes pour agréger les valeurs d'entrée sur chaque intervalle de temps et calculer une valeur de sortie unique. Les fonctions d'agrégation peuvent agréger les données issues de ressources associées.

Les arguments des fonctions d'agrégation peuvent être [des variables](expression-variables.md), [des littéraux numériques, des](expression-literals.md#number-literal-definition) [fonctions temporelles](expression-temporal-functions.md), des expressions imbriquées ou des fonctions d'agrégation. La formule `max(latest(x), latest(y), latest(z))` utilise une fonction d'agrégation comme argument et renvoie la plus grande valeur actuelle des `z` propriétés `x``y`, et.

Vous pouvez utiliser des expressions imbriquées dans les fonctions d'agrégation. Lorsque vous utilisez des expressions imbriquées, les règles suivantes s'appliquent : 
+ Chaque argument ne peut comporter qu'une seule variable.  
**Example**  

  Par exemple, `avg(x*(x-1))` et `sum(x/2 )/avg(y^2 )` sont pris en charge.

  Par exemple, `min(x/y)` n'est pas pris en charge.
+ Chaque argument peut comporter des expressions imbriquées à plusieurs niveaux.  
**Example**  

  Par exemple, `sum(avg(x^2 )/2)` est pris en charge.
+ Les différents arguments peuvent avoir des variables différentes.  
**Example**  

  Par exemple, `sum(x/2, y*2)` est pris en charge.

**Note**  
Si vos expressions contiennent des mesures, AWS IoT SiteWise utilise les dernières valeurs de l'intervalle de temps actuel pour que les mesures calculent les agrégats.
Si vos expressions contiennent des attributs, AWS IoT SiteWise utilise les dernières valeurs des attributs pour calculer les agrégats.


| Fonction | Description | 
| --- | --- | 
|  `avg(x0, ..., xn)`  |  Renvoie la moyenne des valeurs des variables données sur l'intervalle de temps actuel. <a name="aggregation-function-no-output"></a>Cette fonction produit un point de données uniquement si les variables données ont au moins un point de données sur l'intervalle de temps actuel.  | 
|   `sum(x0, ..., xn)`  |  Renvoie la somme des valeurs de variables données sur l'intervalle de temps actuel. <a name="aggregation-function-no-output"></a>Cette fonction produit un point de données uniquement si les variables données ont au moins un point de données sur l'intervalle de temps actuel.  | 
|  `min(x0, ..., xn)`  |  Renvoie la valeur minimale des valeurs des variables données sur l'intervalle de temps actuel. <a name="aggregation-function-no-output"></a>Cette fonction produit un point de données uniquement si les variables données ont au moins un point de données sur l'intervalle de temps actuel.  | 
|  `max(x0, ..., xn)`  |  Renvoie la valeur maximale des valeurs de variables données sur l'intervalle de temps actuel. <a name="aggregation-function-no-output"></a>Cette fonction produit un point de données uniquement si les variables données ont au moins un point de données sur l'intervalle de temps actuel.  | 
|  `count(x0, ..., xn)`  |  Renvoie le nombre total de points de données pour les variables données sur l'intervalle de temps actuel. Pour de plus amples informations sur la comptabilisation du nombre de points de données qui répondent à une condition, veuillez consulter [Compter les points de données qui correspondent à une condition](expression-tutorials.md#count-filtered-data). <a name="aggregation-function-always-output"></a>Cette fonction calcule un point de données pour chaque intervalle de temps.  | 
| `stdev(x0, ..., xn)` | Renvoie l'écart type des valeurs des variables données sur l'intervalle de temps actuel. Cette fonction produit un point de données uniquement si les variables données ont au moins un point de données sur l'intervalle de temps actuel.  | 

# Utiliser des fonctions temporelles dans les expressions de formules
<a name="expression-temporal-functions"></a>

Utilisez des fonctions temporelles pour renvoyer des valeurs basées sur les horodatages des points de données.

## Utiliser des fonctions temporelles dans les métriques
<a name="temporal-functions-in-metrics"></a>

Dans [les métriques](metrics.md) uniquement, vous pouvez utiliser les fonctions suivantes qui renvoient des valeurs basées sur l'horodatage des points de données.

Les arguments des fonctions temporelles doivent être des propriétés du modèle d'actif local ou des expressions imbriquées. Cela signifie que vous ne pouvez pas utiliser les propriétés des modèles d'actifs enfants dans les fonctions temporelles.

Vous pouvez utiliser des expressions imbriquées dans les fonctions temporelles. Lorsque vous utilisez des expressions imbriquées, les règles suivantes s'appliquent : 
+ Chaque argument ne peut comporter qu'une seule variable.

  Par exemple, `latest( t*9/5 + 32 )` est pris en charge.
+ Les arguments ne peuvent pas être des fonctions d'agrégation.

  Par exemple, `first( sum(x) )` n'est pas pris en charge.


| Fonction | Description | 
| --- | --- | 
|  `first(x)`  |  Renvoie la valeur de la variable donnée avec l'horodatage le plus ancien sur l'intervalle de temps actuel.  | 
|   `last(x)` |  Renvoie la valeur de la variable donnée avec l'horodatage le plus récent sur l'intervalle de temps actuel.  | 
|  `earliest(x)`  |  Renvoie la dernière valeur de la variable donnée avant le début de l'intervalle de temps actuel. Cette fonction calcule un point de données pour chaque intervalle de temps, si la propriété d'entrée a au moins un point de données dans son historique. Consultez [time-range-defintion](#time-range-def) pour plus de détails.   | 
|   `latest(x)` |  Renvoie la dernière valeur de la variable donnée avec le dernier horodatage avant la fin de l'intervalle de temps actuel. Cette fonction calcule un point de données pour chaque intervalle de temps, si la propriété d'entrée a au moins un point de données dans son historique. Consultez [time-range-defintion](#time-range-def) pour plus de détails.  | 
|   `statetime(x)`  |  Renvoie la durée, en secondes, pendant laquelle les variables données sont positives sur l'intervalle de temps actuel. Vous pouvez utiliser les [fonctions de comparaison](expression-comparison-functions.md) pour créer une propriété de transformation pour la `statetime` fonction à utiliser.  Par exemple, si vous avez une propriété `Idle` qui est `0` ou `1`, vous pouvez calculer le temps d'inactivité par intervalle de temps avec l'expression suivante : `IdleTime = statetime(Idle)`. Pour plus d'informations, consultez l'[exemple de scénario d'heure d'état](#statetime-example). Cette fonction ne prend pas en charge les propriétés de métriques en tant que variables d'entrée. Cette fonction calcule un point de données pour chaque intervalle de temps, si la propriété d'entrée a au moins un point de données dans son historique.  | 
|   `TimeWeightedAvg(x, [interpolation])`  | Renvoie la moyenne des données d'entrée pondérées par les intervalles de temps entre les points.Voir [Paramètres des fonctions pondérées dans le temps](#timeweighted-parameter) pour plus de détails sur les calculs et les intervalles.L'argument facultatif `interpolaton` doit être une constante de chaîne :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-temporal-functions.html) | 
|   `TimeWeightedStDev(x, [algo])`  |  Renvoie l'écart type des données d'entrée pondéré avec les intervalles de temps entre les points.  Voir [Paramètres des fonctions pondérées dans le temps](#timeweighted-parameter) pour plus de détails sur les calculs et les intervalles.  Le calcul utilise l'algorithme de calcul du dernier report observé pour les intervalles entre les points de données. Dans cette approche, le point de données est calculé comme la dernière valeur observée jusqu'au prochain horodatage du point de données d'entrée. Le poids est calculé sous la forme d'un intervalle de temps en secondes entre les points de données ou les limites des fenêtres.  L'argument facultatif `algo` doit être une constante de chaîne : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-temporal-functions.html) Les formules suivantes sont utilisées pour le calcul où : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-temporal-functions.html) Équation pour l'écart type de la population : ![\[Équation pour l'écart type de la population.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/timeweightedstdev1.png) Équation pour l'écart type de fréquence : ![\[Équation pour l'écart type de fréquence.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/timeweighted-frequency-stdev.png)  | 

Le schéma suivant montre comment AWS IoT SiteWise les fonctions temporelles`first`, `last` `earliest``latest`, et sont calculées par rapport à l'intervalle de temps actuel.

![\[AWS IoT SiteWise les fonctions temporelles renvoient des points de données en fonction de leur horodatage.\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/images/sitewise-temporal-functions.png)
<a name="time-range-def"></a>

**Note**  
L'intervalle de temps pour`first(x)`, `last(x)` est (début de la fenêtre actuelle, fin de la fenêtre actuelle].
L'intervalle de temps pour `latest(x)` est [début du temps, fin de la fenêtre actuelle].
La plage de temps pour `earliest(x)` est (début de l'heure, fin de la fenêtre précédente).

**Paramètres des fonctions pondérés dans le temps**

Les fonctions pondérées dans le temps calculées pour la fenêtre d'agrégation prennent en compte les éléments suivants :
+ Points de données à l'intérieur de la fenêtre
+ Intervalles de temps entre les points de données
+ Dernier point de données avant la fenêtre
+ Premier point de données après la fenêtre (pour certains algorithmes)

**Termes :**
+ Point de **données incorrect : tout point** de données dont la qualité n'est pas bonne ou dont la valeur n'est pas numérique. Cela n'est pas pris en compte dans le calcul des résultats d'une fenêtre.
+ **Intervalle incorrect** — Intervalle après un point de données erroné. L'intervalle avant le premier point de données connu est également considéré comme un mauvais intervalle.
+ **Bon point de données** — Tout point de données présentant une bonne qualité et une bonne valeur numérique.

**Note**  
AWS IoT SiteWise ne consomme des données `GOOD` de qualité que lorsqu'il calcule les transformations et les métriques. Il ignore les points `UNCERTAIN` de `BAD` données.
L'intervalle avant le premier point de données connu est considéré comme un **mauvais intervalle**. Pour plus d’informations, consultez [Tutoriels d'expression de formules](expression-tutorials.md).

L'intervalle après le dernier point de données connu se poursuit indéfiniment, affectant toutes les fenêtres suivantes. Lorsqu'un nouveau point de données arrive, la fonction recalcule l'intervalle.

Conformément aux règles ci-dessus, le résultat agrégé des fenêtres est calculé et limité aux limites des fenêtres. Par défaut, la fonction envoie le résultat de la fenêtre uniquement si l'ensemble de la fenêtre correspond à un **bon intervalle**.

Si l'**intervalle de validité** de la fenêtre est inférieur à la longueur de la fenêtre, la fonction n'envoie pas la fenêtre. 

Lorsque les points de données affectant le résultat de la fenêtre changent, la fonction recalcule la fenêtre, même si les points de données se trouvent en dehors de la fenêtre. 

Si la propriété d'entrée comporte au moins un point de données dans son historique et qu'un calcul a été lancé, la fonction calcule les fonctions d'agrégation pondérées dans le temps pour chaque intervalle de temps.

**Example Exemple de scénario statetime**  
Prenons un exemple où vous avez une ressource avec les propriétés suivantes :  
+ `Idle`— Une mesure qui est `0` ou`1`. Lorsque la valeur est `1`, la machine est inactive.
+ `Idle Time`— Mesure qui utilise la formule `statetime(Idle)` pour calculer la durée en secondes pendant laquelle la machine est inactive, par intervalle d'une minute.
La propriété `Idle` possède les points de données suivants.  


|  |  |  |  |  |  | 
| --- |--- |--- |--- |--- |--- |
| Horodatage | 2:00:00 PM | 2:00:30 PM | 2:01:15 PM | 2:02:45 PM | 2:04:00 PM | 
| Idle | 0 | 1 | 1 | 0 | 0 | 
AWS IoT SiteWise calcule la `Idle Time` propriété toutes les minutes à partir des valeurs de`Idle`. Une fois ce calcul terminé, la propriété `Idle Time` possède les points de données suivants.  


|  |  |  |  |  |  | 
| --- |--- |--- |--- |--- |--- |
| Horodatage | 2:00:00 PM | 2:01:00 PM | 2:02:00 PM | 2:03:00 PM | 2:04:00 PM | 
| Idle Time | N/A | 30 | 60 | 45 | 0 | 
AWS IoT SiteWise effectue les calculs suivants `Idle Time` à la fin de chaque minute.  
+ À 2:00 PM (pour 1:59 PM à 2:00 PM)
  + Il n'y a pas de données pour `Idle` avant 2:00 PM, donc aucun point de données n'est calculé.
+ À 2:01 PM (pour 2:00 PM à 2:01 PM)
  + À 2:00:00 PM, la machine est active (`Idle` est égal à `0`).
  + À 2:00:30 PM, la machine es inactive (`Idle` est égal à `1`).
  + `Idle` ne change plus avant la fin de l'intervalle à 2:01:00 PM, `Idle Time`est donc égal à 30 secondes.
+ À 2:02 PM (pour 2:01 PM à 2:02 PM)
  + À 2:01:00 PM, la machine est inactive (conformément au dernier point de données à 2:00:30 PM).
  + À 2:01:15 PM, la machine est toujours inactive.
  + `Idle` ne change plus non plus avant la fin de l'intervalle à 2:02:00 PM, `Idle Time` est donc égal à 60 secondes.
+ À 2:03 PM (pour 2:02 PM à 2:03 PM)
  + À 2:02:00 PM, la machine est inactive (conformément au dernier point de données à 2:01:15 PM).
  + À 2:02:45 PM, la machine est active.
  + `Idle` ne change plus non plus avant la fin de l'intervalle à 2:03:00 PM, `Idle Time` est donc égal à 45 secondes.
+ À 2:04 PM (pour 2:03 PM à 2:04 PM)
  + À 2:03:00 PM, la machine est active (conformément au dernier point de données à 2:02:45 PM).
  + `Idle` ne change plus non plus avant la fin de l'intervalle à 2:04:00 PM, `Idle Time` est donc égal à 0 seconde.

**Example Exemple TimeWeightedAvg et TimeWeightedStDev scénario**  
Les tableaux suivants fournissent des exemples d'entrées et de sorties pour ces métriques de fenêtre d'une minute :`Avg(x), TimeWeightedAvg(x), TimeWeightedAvg(x, "linear"), stDev(x), timeWeightedStDev(x), timeWeightedStDev(x, 'p')`.  
Exemple de saisie pour une fenêtre agrégée d'une minute :  
Ces points de données sont tous `GOOD` de qualité.


|  |  | 
| --- |--- |
| 03:00:00 | 4.0 | 
| 03:01:00 | 2.0 | 
| 03:01:10 | 8.0 | 
| 03:01:50 | 20.0 | 
| 03:02:00 | 14,0 | 
| 03:02:05 | 10,0 | 
| 03:02:10 | 3.0 | 
| 03:02:30 | 20.0 | 
| 03:03:30 | 0.0 | 
Résultats agrégés en sortie :  
Aucun — Résultat non produit pour cette fenêtre.


| Heure | `Avg(x)` | `TimeWeightedAvg(x)` | `TimeWeightedAvg(X, "linear")` | `stDev(X)` | `timeWeightedStDev(x)` | `timeWeightedStDev(x, 'p')` | 
| --- | --- | --- | --- | --- | --- | --- | 
| 3:00:00 | 4 | Aucune | Aucune | 0 | Aucune | Aucune | 
| 3:01:00 | 2 | 4 | 3 | 0 | 0 | 0 | 
| 3:02:00 | 14 | 9 | 13 | 6 | 5,430610041581775 | 5,385164807134504 | 
| 3:03:00 | 11 | 13 | 12,875 | 8,54400374531753 | 7,724054437220943 | 7,659416862050705 | 
| 3:04:00 | 0 USD | 10 | 2,5 | 0 | 10,084389681792215 | 10 | 
| 3:05:00 | Aucune | 0 | 0 | Aucune | 0 | 0 | 

## Utiliser des fonctions temporelles dans les transformations
<a name="temporal-functions-in-transforms"></a>

Dans les [transformations](transforms.md) uniquement, vous pouvez utiliser la `pretrigger()` fonction pour récupérer la valeur de `GOOD` qualité d'une variable avant la mise à jour de propriété qui a lancé le calcul de transformation en cours.

Prenons l'exemple d'un fabricant AWS IoT SiteWise qui surveille l'état d'une machine. Le fabricant utilise les mesures et les transformations suivantes pour représenter le processus :
+ Une mesure`current_state`, qui peut être 0 ou 1.
  + Si la machine est en état de nettoyage, `current_state` égal à 1.
  + Si la machine est en cours de fabrication, `current_state` est égal à 0.
+ Une transformation`cleaning_state_duration`, c'est égal à ça`if(pretrigger(current_state) == 1, timestamp(current_state) - timestamp(pretrigger(current_state)), none)`. Cette transformation renvoie la durée pendant laquelle la machine est restée en état de nettoyage en secondes, au format Unix Epoch. Pour plus d'informations, consultez [Utiliser des fonctions conditionnelles dans les expressions de formule](expression-conditional-functions.md) et la fonction [timestamp ().](expression-date-and-time-functions.md)

Si la machine reste en état de nettoyage plus longtemps que prévu, le fabricant peut examiner la machine.

Vous pouvez également utiliser la `pretrigger()` fonction dans des transformations multivariées. Par exemple, vous avez deux mesures nommées `x` et`y`, et une transformation`z`, égale à`x + y + pretrigger(y)`. Le tableau suivant indique les valeurs pour `x``y`, et `z` entre 9 h 00 et 9 h 15.

**Note**  
Cet exemple suppose que les valeurs des mesures arrivent par ordre chronologique. Par exemple, la valeur de `x` pour 9 h 00 arrive avant la valeur de `x` pour 9 h 05.
Si les points de données de 9 h 05 arrivent avant les points de données de 9 h 00, cela `z` n'est pas calculé à 9 h 05.
Si la valeur de `x` pour 9 h 05 arrive avant la valeur de `x` pour 9 h 00 et que les valeurs de `y` arrivent chronologiquement, `z` est égale `22 = 20 + 1 + 1` à 9 h 05.


|  | 9 H 00 | 9 H 05 | 9 H 10 | 9 H 15 | 
| --- | --- | --- | --- | --- | 
|  `x`  |  10  |  20  |    |  30  | 
|  `y`  |  1  |  2  |  3  |    | 
|  `z = x + y + pretrigger(y)`  |  `y`ne reçoit aucun point de données avant 9h00. Par conséquent, `z` n'est pas calculé à 9 h 00.  |  23 = 20 \$1 2 \$1 1 `pretrigger(y)`est égal à 1.  |  25 = 20 \$1 3 \$1 2 `x`ne reçoit pas de nouveau point de données. `pretrigger(y)`est égal à 2.  |  36 = 30 \$1 3 \$1 3 `y`ne reçoit pas de nouveau point de données. Par conséquent, `pretrigger(y)` est égal à 3 à 9 h 15.  | 

# Utiliser les fonctions de date et d'heure dans les expressions de formule
<a name="expression-date-and-time-functions"></a>

Dans les [transformations](transforms.md) et [les métriques](metrics.md), vous pouvez utiliser les fonctions de date et d'heure de la manière suivante :
+ Récupérez l'horodatage actuel d'un point de données en UTC ou dans le fuseau horaire local.
+ Construisez des horodatages avec des arguments tels que `year``month`, et. `day_of_month`
+ Extrayez une période telle qu'une année ou un mois avec l'`unix_time`argument.


| Fonction | Description | 
| --- | --- | 
|  `now()`  |  Renvoie la date et l'heure actuelles, en secondes, au format Unix Epoch.  | 
|  `timestamp()`  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html)  | 
|  `mktime(time_zone, year, month, day_of_month, hour, minute, second)`  |  Renvoie le temps d'entrée en secondes, au format Unix Epoch. Les conditions suivantes s'appliquent à l'utilisation de cette fonction : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html) Les limites suivantes s'appliquent à l'utilisation de cette fonction : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html) Exemples : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html)  | 
|  `localtime(unix_time, time_zone)`  |  Renvoie l'année, le jour du mois, le jour de la semaine, le jour de l'année, l'heure, la minute ou la seconde du fuseau horaire spécifié par rapport à l'heure Unix. Les conditions suivantes s'appliquent à l'utilisation de cette fonction : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html) Exemple de réponse : `2007-12-03T10:15:30+01:00[Europe/Paris]` `localtime(unix_time, time_zone)`n'est pas une fonction autonome. Les `sec()` fonctions `year()` `mon()``mday`,`wday()`,`yday()`, `hour()``minute()`,, et prennent `localtime(unix_time, time_zone)` comme argument. Exemples : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/iot-sitewise/latest/userguide/expression-date-and-time-functions.html)  | 
|  `year(localtime(unix_time, time_zone)`  |  Renvoie l'année à partir de`localtime(unix_time, time_zone)`.  | 
|  `mon(localtime(unix_time, time_zone))`  |  Renvoie le mois de`localtime(unix_time, time_zone)`.  | 
|  `mday(localtime(unix_time, time_zone))`  |  Renvoie le jour du mois à partir de`localtime(unix_time, time_zone)`.  | 
|  `wday(localtime(unix_time, time_zone))`  |  Renvoie le jour de la semaine à partir de`localtime(unix_time, time_zone)`.  | 
|  `yday(localtime(unix_time, time_zone))`  |  Renvoie le jour de l'année à partir de`localtime(unix_time, time_zone)`.  | 
|  `hour(localtime(unix_time, time_zone))`  |  Renvoie l'heure de`localtime(unix_time, time_zone)`.  | 
|  `minute(localtime(unix_time, time_zone))`  |  Renvoie la minute de`localtime(unix_time, time_zone)`.  | 
|  `sec(localtime(unix_time, time_zone))`  |  Renvoie le second de`localtime(unix_time, time_zone)`.  | 

## Formats de fuseau horaire pris en charge
<a name="time-zone-expressions"></a>

Vous pouvez spécifier l'argument du fuseau horaire de différentes manières :
+ Décalage de fuseau horaire - Spécifiez `'Z'` un UTC ou un décalage (`'+2'`ou`'-5'`).
+ Décalage IDs - Combinez une abréviation de fuseau horaire et un décalage. Par exemple : `'GMT+2'` et `'UTC-01:00'`. L'abréviation du fuseau horaire ne doit contenir que trois lettres.
+ Basé sur la région IDs - Par exemple, `'Etc/GMT+12'` et`'Pacific/Pago_Pago'`.

### Abréviations de fuseaux horaires prises en charge
<a name="spported-time-zones"></a>

Les fonctions de date et d'heure prennent en charge les abréviations de fuseau horaire à trois lettres suivantes : 
+ EST - 05:00
+ HST - 10:00
+ MARDI - 07:00
+ ACT - Australie/Darwin
+ AET - Australie/Sydney
+ America/Argentina/BuenosAGT-\$1Aires
+ ART - Africa/Le Caire
+ AST - America/Anchorage
+ BET - America/Sao\$1Paulo
+ BST - Asia/Dhaka
+ CAT - Afrique/Harare
+ CET - Europe/Paris
+ CNT - America/St\$1Johns
+ CST - America/Chicago
+ CTT - Asia/Shanghai 
+ EAT - Africa/Addis\$1Abeba
+ JET - America/Indiana/Indianapolis
+ IST - Asia/Kolkata
+ JST - Asia/Tokyo
+ MIT - Pacific/Apia
+ NET - Asia/Yerevan
+ NST - Pacific/Auckland
+ PLT - Asia/Karachi
+ PRT - America/Puerto\$1Rico
+ PST - America/Los\$1Angeles
+ SST - Pacific/Guadalcanal
+ VST - Asia/Ho\$1Chi\$1Minh

### Soutenu en fonction de la région IDs
<a name="supported-region-based-ids"></a>

Les fonctions de date et d'heure prennent en charge les fonctions suivantes basées sur les régions IDs, organisées en fonction de leur relation avec UTC\$1 00:00 :
+ ETC/GMT\$112 (UTC- 12h00)
+ Pacific/Pago\$1Pago (UTC- 11:00)
+ Pacifique/Samoa (UTC- 11:00)
+ Pacifique/Niue (UTC- 11:00)
+ États-Unis/Samoa (UTC- 11:00)
+ ETC/GMT\$111 (UTC- 11:00)
+ Pacifique/Midway (UTC- 11:00)
+ Pacifique/Honolulu (UTC- 10:00)
+ Pacifique/Rarotonga (UTC- 10:00)
+ Pacifique/Tahiti (UTC- 10:00)
+ Pacifique/Johnston (UTC- 10:00)
+ États-Unis/Hawaï (UTC- 10:00)
+ Système V/ HST10 (UTC- 10:00)
+ ETC/GMT\$110 (UTC- 10:00)
+ Pacifique/Marquises (UTC- 09:30)
+ ETC/GMT\$19 (UTC- 09:00)
+ Pacifique/Gambier (UTC- 09:00)
+ Amérique/Atka (UTC- 09:00)
+ Système V/ YST9 (UTC- 09:00)
+ Amérique/Adak (UTC- 09:00)
+ États-Unis/Aléoutiennes (UTC- 09:00)
+ ETC/GMT\$18 (UTC- 08:00)
+ Etats-Unis/Alaska (UTC- 08:00)
+ Amérique/Juneau (UTC- 08:00)
+ Amérique/Metlakatla (UTC- 08:00)
+ Amérique/Yakutat (UTC- 08:00)
+ Pacifique/Pitcairn (UTC- 08:00)
+ Amérique/Sitka (UTC- 08:00)
+ Amérique/Anchorage (UTC- 08:00)
+ Système V/ PST8 (UTC- 08:00)
+ Amérique/Nome (UTC- 08:00)
+ Système YST9 V/YDT (UTC- 08:00)
+ Canada/Yukon (UTC- 07:00)
+ US/Pacific-New (UTC- 07:00)
+ ETC/GMT\$17 (UTC- 07:00)
+ Etats-Unis/Arizona (UTC- 07:00)
+ Amérique/Dawson\$1Creek (UTC- 07:00)
+ Canada/Pacifique (UTC- 07:00)
+ PST8PDT (UTC- 07:00)
+ Système V/ MST7 (UTC- 07:00)
+ Amérique/Dawson (UTC- 07:00)
+ Mexique/ BajaNorte (UTC- 07:00)
+ Amérique/Tijuana (UTC- 07:00)
+ Amérique/Creston (UTC- 07:00)
+ America/Hermosillo (UTC- 07:00)
+ Amérique/Santa\$1Isabel (UTC- 07:00)
+ Amérique/Vancouver (UTC- 07:00)
+ America/Ensenada (UTC- 07:00)
+ Amérique/Phoenix (UTC- 07:00)
+ Amérique/Whitehorse (UTC- 07:00)
+ America/Fort\$1Nelson (UTC- 07:00)
+ Système PST8 V/PDT (UTC- 07:00)
+ Amérique/Los\$1Angeles (UTC- 07:00)
+ États-Unis/Pacifique (UTC- 07:00)
+ America/El Salvador (UTC- 06:00)
+ Amérique/Guatemala (UTC- 06:00)
+ Amérique/Belize (UTC- 06:00)
+ Amérique/Managua (UTC- 06:00)
+ America/Tegucigalpa (UTC- 06:00)
+ ETC/GMT\$16 (UTC- 06:00)
+ Pacifique/Pâques (UTC- 06:00)
+ Mexique/ BajaSur (UTC- 06:00)
+ America/Regina (UTC- 06:00)
+ Amérique/Denver (UTC- 06:00)
+ Pacifique/Galapagos (UTC- 06:00)
+ Amérique/Yellowknife (UTC- 06:00)
+ America/Swift\$1Current (UTC- 06:00)
+ Amérique/Inuvik (UTC- 06:00)
+ Amérique/Mazatlan (UTC- 06:00)
+ Amérique/Boise (UTC- 06:00)
+ Amérique/Costa\$1Rica (UTC- 06:00)
+ MST7MDT (UTC- 06:00)
+ Système V/ CST6 (UTC- 06:00)
+ Amérique/Chihuahua (UTC- 06:00)
+ Amérique/Ojinaga (UTC- 06:00)
+ Chili/ EasterIsland (UTC- 06:00)
+ Etats-Unis/Montagne (UTC- 06:00)
+ Amérique/Edmonton (UTC- 06:00)
+ Canada/Montagne (UTC- 06:00)
+ Amérique/Cambridge\$1Bay (UTC- 06:00)
+ Navajo (UTC- 06:00)
+ Système MST7 V/MDT (UTC- 06:00)
+ Canada/Saskatchewan (UTC- 06:00)
+ Amérique/Shiprock (UTC- 06:00)
+ Amérique/Panama (UTC- 05:00)
+ Amérique/Chicago (UTC- 05:00)
+ America/Eirunepe (UTC- 05:00)
+ ETC/GMT\$15 (UTC- 05:00)
+ Mexique/Général (UTC- 05:00)
+ America/Porto\$1Acre (UTC- 05:00)
+ Amérique/Guayaquil (UTC- 05:00)
+ America/Rankin\$1Inlet (UTC- 05:00)
+ US/Central (UTC- 05:00)
+ Amérique/Rainy\$1River (UTC- 05:00)
+ America/Indiana/Knox(UTC- 05:00)
+ America/North\$1Dakota/Beulah(UTC- 05:00)
+ Amérique/Monterrey (UTC- 05:00)
+ Amérique/Jamaïque (UTC- 05:00)
+ Amérique/Atikokan (UTC- 05:00)
+ America/Coral\$1Harbour (UTC- 05:00)
+ America/North\$1Dakota/Center(UTC- 05:00)
+ Amérique/Cayman (UTC- 05:00)
+ America/Indiana/Tell\$1Ville (UTC- 05:00)
+ America/Mexico\$1City (UTC- 05:00)
+ Amérique/Matamoros (UTC- 05:00)
+ CST6CDT (UTC- 05:00)
+ America/Knox\$1IN (UTC- 05:00)
+ Amérique/Bogota (UTC- 05:00)
+ Amérique/Menominee (UTC- 05:00)
+ America/Resolute (UTC- 05:00)
+ Système V/ EST5 (UTC- 05:00)
+ Canada/Centre (UTC- 05:00)
+ Brésil/Acre (UTC- 05:00)
+ Amérique/Cancun (UTC- 05:00)
+ Amérique/Lima (UTC- 05:00)
+ Amérique/Bahia\$1Banderas (UTC- 05:00)
+ US/Indiana-Starke (UTC- 05:00)
+ America/Rio\$1Branco (UTC- 05:00)
+ Système CST6 V/CDT (UTC- 05:00)
+ Jamaïque (UTC- 05:00)
+ Amérique/Mérida (UTC- 05:00)
+ America/North\$1Dakota/New\$1Salem (UTC- 05:00)
+ Amérique/Winnipeg (UTC- 05:00)
+ Amérique/Cuiabá (UTC- 04:00)
+ Amérique/Marigot (UTC- 04:00)
+ America/Indiana/Petersburg(UTC- 04:00)
+ Chili/Continental (UTC- 04:00)
+ America/Grand\$1Turk (UTC- 04:00)
+ Cuba (UTC- 04:00)
+ ETC/GMT\$14 (UTC- 04:00)
+ Amérique/Manaus (UTC- 04:00)
+ Amérique/Fort\$1Wayne (UTC- 04:00)
+ America/St\$1Thomas (UTC- 04:00)
+ Amérique/Anguilla (UTC- 04:00)
+ Amérique/La Havane (UTC- 04:00)
+ États-Unis/Michigan (UTC- 04:00)
+ Amérique/Barbade (UTC- 04:00)
+ Amérique/Louisville (UTC- 04:00)
+ Amérique/Curaçao (UTC- 04:00)
+ Amérique/Guyana (UTC- 04:00)
+ Amérique/Martinique (UTC- 04:00)
+ Amérique/Porto\$1Rico (UTC- 04:00)
+ Amérique/Port\$1of\$1Spain (UTC- 04:00)
+ Système V/ AST4 (UTC- 04:00)
+ America/Indiana/Vevay(UTC- 04:00)
+ America/Indiana/Vincennes(UTC- 04:00)
+ America/Kralendijk (UTC- 04:00)
+ Amérique/Antigua (UTC- 04:00)
+ Amérique/Indianapolis (UTC- 04:00)
+ Amérique/Iqaluit (UTC- 04:00)
+ America/St\$1Vincent (UTC- 04:00)
+ America/Kentucky/Louisville(UTC- 04:00)
+ Amérique/Dominique (UTC- 04:00)
+ America/Asuncion (UTC- 04:00)
+ EST5HAE (UTC- 04:00)
+ Amérique/Nassau (UTC- 04:00)
+ America/Kentucky/Monticello(UTC- 04:00)
+ Brésil/Ouest (UTC- 04:00)
+ Amérique/Aruba (UTC- 04:00)
+ America/Indiana/Indianapolis(UTC- 04:00)
+ Amérique/Santiago (UTC- 04:00)
+ America/La\$1Paz (UTC- 04:00)
+ America/Thunder\$1Bay (UTC- 04:00)
+ America/Indiana/Marengo(UTC- 04:00)
+ Amérique/Blanc-Sablon (UTC- 04:00)
+ America/Santo\$1Domingo (UTC- 04:00)
+ Etats-Unis/Est (UTC- 04:00)
+ Canada/Est (UTC- 04:00)
+ Amérique/ Port-au-Prince (UTC- 04:00)
+ America/Saint-Barthélemy (UTC- 04:00)
+ Amérique/Nipigon (UTC- 04:00)
+ Etats-Unis/Est de l'Indiana (UTC- 04:00)
+ Amérique/Sainte-Lucie (UTC- 04:00)
+ Amérique/Montserrat (UTC- 04:00)
+ America/Lower\$1Princes (UTC- 04:00)
+ Amérique/Détroit (UTC- 04:00)
+ Amérique/Tortola (UTC- 04:00)
+ America/Porto\$1Velho (UTC- 04:00)
+ America/Campo\$1Grande (UTC- 04:00)
+ America/Virgin (UTC- 04:00)
+ Amérique/Pangnirtung (UTC- 04:00)
+ Amérique/Montréal (UTC- 04:00)
+ America/Indiana/Winamac(UTC- 04:00)
+ America/Boa\$1Vista (UTC- 04:00)
+ Amérique/Grenade (UTC- 04:00)
+ Amérique/New\$1York (UTC- 04:00)
+ America/St\$1Kitts (UTC- 04:00)
+ Amérique/Caracas (UTC- 04:00)
+ Amérique/Guadeloupe (UTC- 04:00)
+ Amérique/Toronto (UTC- 04:00)
+ Système EST5 V/EDT (UTC- 04:00)
+ America/Argentina/Catamarca(UTC- 03:00)
+ Canada/Atlantique (UTC- 03:00)
+ America/Argentina/Cordoba(UTC- 03:00)
+ Amérique/Araguaina (UTC- 03:00)
+ America/Argentina/Salta(UTC- 03:00)
+ ETC/GMT\$13 (UTC- 03:00)
+ Amérique/Montevideo (UTC- 03:00)
+ Brésil/Est (UTC- 03:00)
+ America/Argentina/Mendoza(UTC- 03:00)
+ America/Argentina/Rio\$1Gallegos (UTC- 03:00)
+ Amérique/Catamarca (UTC- 03:00)
+ Amérique/Cordoba (UTC- 03:00)
+ America/Sao\$1Paulo (UTC- 03:00)
+ America/Argentina/Jujuy(UTC- 03:00)
+ Amérique/Cayenne (UTC- 03:00)
+ Amérique/Recife (UTC- 03:00)
+ America/Buenos\$1Aires (UTC- 03:00)
+ Amérique/Paramaribo (UTC- 03:00)
+ Amérique/Moncton (UTC- 03:00)
+ America/Mendoza (UTC- 03:00)
+ Amérique/Santarém (UTC- 03:00)
+ Atlantique/Bermudes (UTC- 03:00)
+ Amérique/Maceio (UTC- 03:00)
+ Atlantic/Stanley (UTC- 03:00)
+ Amérique/Halifax (UTC- 03:00)
+ Antarctique/Rothera (UTC- 03:00)
+ America/Argentina/San\$1Luis (UTC- 03:00)
+ America/Argentina/Ushuaia(UTC- 03:00)
+ Antarctique/Palmer (UTC- 03:00)
+ America/Punta\$1Arenas (UTC- 03:00)
+ Amérique/Glace\$1Bay (UTC- 03:00)
+ America/Fortaleza (UTC- 03:00)
+ Amérique/Thule (UTC- 03:00)
+ America/Argentina/La\$1Rioja (UTC- 03:00)
+ Amérique/Belém (UTC- 03:00)
+ America/Jujuy (UTC- 03:00)
+ Amérique/Bahia (UTC- 03:00)
+ Amérique/Goose\$1Bay (UTC- 03:00)
+ America/Argentina/San\$1Juan (UTC- 03:00)
+ America/Argentina/ComodRivadavia(UTC- 03:00)
+ America/Argentina/Tucuman(UTC- 03:00)
+ America/Rosario (UTC- 03:00)
+ Système AST4 V/ADT (UTC- 03:00)
+ America/Argentina/Buenos\$1Aires (UTC- 03:00)
+ America/St\$1Johns (UTC- 02:30)
+ Canada/Terre-Neuve (UTC- 02:30)
+ Amérique/Miquelon (UTC- 02:00)
+ ETC/GMT\$12 (UTC- 02:00)
+ Amérique/Godthab (UTC- 02:00)
+ America/Noronha (UTC- 02:00)
+ Brésil/ DeNoronha (UTC- 02:00)
+ Atlantique/Géorgie du Sud (UTC- 02:00)
+ Etc/GMT\$11 (UTC- 01:00)
+ Atlantique/Cap-Vert (UTC- 01:00)
+ Pacifique/Kiritimati (UTC\$1 14:00)
+ Etc/GMT-14 (UTC\$1 14:00)
+ Pacifique/Fakaofo (UTC\$1 13:00)
+ Pacifique/Enderbury (UTC\$1 13:00)
+ Pacifique/Apia (UTC\$1 13:00)
+ Pacifique/Tongatapu (UTC\$1 13:00)
+ Etc/GMT-13 (UTC\$1 13:00)
+ NZ-CHAT (UTC\$1 12:45)
+ Pacifique/Chatham (UTC\$1 12:45)
+ Pacifique/Kwajalein (UTC\$1 12:00)
+ Antarctique/ McMurdo (UTC\$1 12:00)
+ Pacifique/Wallis (UTC\$1 12:00)
+ Pacifique/Fidji (UTC\$1 12:00)
+ Pacifique/Funafuti (UTC\$1 12:00)
+ Pacifique/Nauru (UTC\$1 12:00)
+ Kwajalein (UTC\$1 12:00)
+ NOUVELLE-ZÉLANDE (UTC\$1 12:00)
+ Pacific/Wake (UTC\$1 12:00)
+ Antarctique/Pôle Sud (UTC\$1 12:00)
+ Pacifique/Tarawa (UTC\$1 12:00)
+ Pacifique/Auckland (UTC\$1 12:00)
+ Asie/Kamchatka (UTC\$1 12:00)
+ etc/GMT-12 (UTC\$1 12:00)
+ Asie/Anadyr (UTC\$1 12:00)
+ Pacifique/Majuro (UTC\$1 12:00)
+ Pacifique/Ponape (UTC\$1 11:00)
+ Pacifique/Bougainville (UTC\$1 11:00)
+ Antarctique/Macquarie (UTC\$1 11:00)
+ Pacifique/Pohnpei (UTC\$1 11:00)
+ Pacifique/Efate (UTC\$1 11:00)
+ Pacifique/Norfolk (UTC\$1 11:00)
+ Asie/Magadan (UTC\$1 11:00)
+ Pacifique/Kosrae (UTC\$1 11:00)
+ Asie/Sakhaline (UTC\$1 11:00)
+ Pacifique/Nouméa (UTC\$1 11:00)
+ Etc/GMT-11 (UTC\$1 11:00)
+ Asie/Srednekolymsk (UTC\$1 11:00)
+ Pacifique/Guadalcanal (UTC\$1 11:00)
+ Australie/Lord\$1Howe (UTC\$1 10:30)
+ Australie/LHI (UTC\$1 10:30)
+ Australie/Hobart (UTC\$1 10:00)
+ Pacifique/Yap (UTC\$1 10:00)
+ Australie/Tasmanie (UTC\$1 10:00)
+ Pacifique/Port\$1Moresby (UTC\$1 10:00)
+ Australie/ACT (UTC\$1 10:00)
+ Australie/Victoria (UTC\$1 10:00)
+ Pacifique/Chuuk (UTC\$1 10:00)
+ Australie/Queensland (UTC\$1 10:00)
+ Australie/Canberra (UTC\$1 10:00)
+ Australie/Currie (UTC\$1 10:00)
+ Pacifique/Guam (UTC\$1 10:00)
+ Pacifique/Truk (UTC\$1 10:00)
+ Australie/NSW (UTC\$1 10:00)
+ Asie/Vladivostok (UTC\$1 10:00)
+ Pacifique/Saipan (UTC\$1 10:00)
+ Antarctique/Dumont DUrville (UTC\$1 10:00)
+ Australie/Sydney (UTC\$1 10:00)
+ Australie/Brisbane (UTC\$1 10:00)
+ Etc/GMT-10 (UTC\$1 10:00)
+ Asie/Ust-Nera (UTC\$1 10:00)
+ Australie/Melbourne (UTC\$1 10:00)
+ Australie/Lindeman (UTC\$1 10:00)
+ Australie/Nord (UTC\$1 09:30)
+ Australie/Yancowinna (UTC\$1 09:30)
+ Australie/Adélaïde (UTC\$1 09:30)
+ Australie/Broken\$1Hill (UTC\$1 09:30)
+ Australie/Sud (UTC\$1 09:30)
+ Australie/Darwin (UTC\$1 09:30)
+ Etc/GMT-9 (UTC\$1 09:00)
+ Pacifique/Palaos (UTC\$1 09:00)
+ Asie/Chita (UTC\$1 09:00)
+ Asie/Dili (UTC\$1 09:00)
+ Asie/Jayapura (UTC\$1 09:00)
+ Asie/Yakutsk (UTC\$1 09:00)
+ Asie/Pyongyang (UTC\$1 09:00)
+ MERCREDI (UTC\$1 09:00)
+ Asie/Séoul (UTC\$1 09:00)
+ Asie/Khandyga (UTC\$1 09:00)
+ Japon (UTC\$1 09:00)
+ Asie/Tokyo (UTC\$1 09:00)
+ Australie/Eucla (UTC\$1 08:45)
+ Asie/Kuching (UTC\$1 08:00)
+ Asie/Chungking (UTC\$1 08:00)
+ Etc/GMT-8 (UTC\$1 08:00)
+ Australie/Perth (UTC\$1 08:00)
+ Asie/Macao (UTC\$1 08:00)
+ Asie/Macao (UTC\$1 08:00)
+ Asie/Choibalsan (UTC\$1 08:00)
+ Asie/Shanghai (UTC\$1 08:00)
+ Antarctique/Casey (UTC\$1 08:00)
+ Asie/Ulan\$1Bator (UTC\$1 08:00)
+ Asie/Chongqing (UTC\$1 08:00)
+ Asie/Oulan-Bator (UTC\$1 08:00)
+ Asie/Taipei (UTC\$1 08:00)
+ Asie/Manille (UTC\$1 08:00)
+ PRC (UTC\$1 08:00)
+ Asie/Ujung\$1Pandang (UTC\$1 08:00)
+ Asie/Harbin (UTC\$1 08:00)
+ Singapour (UTC\$1 08:00)
+ Asie/Brunei (UTC\$1 08:00)
+ Australie/Ouest (UTC\$1 08:00)
+ Asie/Hong\$1Kong (UTC\$1 08:00)
+ Asie/Makassar (UTC\$1 08:00)
+ Hong Kong (UTC\$1 08:00)
+ Asie/Kuala\$1Lumpur (UTC\$1 08:00)
+ Asie/Irkutsk (UTC\$1 08:00)
+ Asie/Singapour (UTC\$1 08:00)
+ Asie/Pontianak (UTC\$1 07:00)
+ Etc/GMT-7 (UTC\$1 07:00)
+ Asie/Phnom\$1Penh (UTC\$1 07:00)
+ Asie/Novossibirsk (UTC\$1 07:00)
+ Antarctique/Davis (UTC\$1 07:00)
+ Asie/Tomsk (UTC\$1 07:00)
+ Asie/Jakarta (UTC\$1 07:00)
+ Asie/Barnaoul (UTC\$1 07:00)
+ Indien/Noël (UTC\$1 07:00)
+ Asie/Ho\$1Chi\$1Minh (UTC\$1 07:00)
+ Asie/Hovd (UTC\$1 07:00)
+ Asie/Bangkok (UTC\$1 07:00)
+ Asie/Vientiane (UTC\$1 07:00)
+ Asie/Novokuznetsk (UTC\$1 07:00)
+ Asie/Krasnoïarsk (UTC\$1 07:00)
+ Asie/Saigon (UTC\$1 07:00)
+ Asie/Yangon (UTC\$1 06:30)
+ Asie/Rangoon (UTC\$1 06:30)
+ Indien/Cocos (UTC\$1 06:30)
+ Asie/Kachgar (UTC\$1 06:00)
+ Etc/GMT-6 (UTC\$1 06:00)
+ Asie/Almaty (UTC\$1 06:00)
+ Asie/Dacca (UTC\$1 06:00)
+ Asie/Omsk (UTC\$1 06:00)
+ Asie/Dhaka (UTC\$1 06:00)
+ Indien/Chagos (UTC\$1 06:00)
+ Asie/Qyzylorda (UTC\$1 06:00)
+ Asie/Bichkek (UTC\$1 06:00)
+ Antarctique/Vostok (UTC\$1 06:00)
+ Asie/Urumqi (UTC\$1 06:00)
+ Asie/Thimbu (UTC\$1 06:00)
+ Asie/Thimphou (UTC\$1 06:00)
+ Asie/Katmandou (UTC\$1 05:45)
+ Asie/Katmandou (UTC\$1 05:45)
+ Asie/Kolkata (UTC\$1 05:30)
+ Asie/Colombo (UTC\$1 05:30)
+ Asie/Calcutta (UTC\$1 05:30)
+ Asie/Aqtau (UTC\$1 05:00)
+ Etc/GMT-5 (UTC\$1 05:00)
+ Asie/Samarkand (UTC\$1 05:00)
+ Asie/Karachi (UTC\$1 05:00)
+ Asie/Ekaterinbourg (UTC\$1 05:00)
+ Asie/Douchanbé (UTC\$1 05:00)
+ Indien/Maldives (UTC\$1 05:00)
+ Asie/Oral (UTC\$1 05:00)
+ Asie/Tachkent (UTC\$1 05:00)
+ Antarctique/Mawson (UTC\$1 05:00)
+ Asie/Aqtobe (UTC\$1 05:00)
+ Asie/Ashkhabad (UTC\$1 05:00)
+ Asie/Ashgabat (UTC\$1 05:00)
+ Asie/Atyrau (UTC\$1 05:00)
+ Indien/Kerguelen (UTC\$1 05:00)
+ Iran (UTC\$1 04:30)
+ Asie/Téhéran (UTC\$1 04:30)
+ Asie/Kaboul (UTC\$1 04:30)
+ Asie/Yerevan (UTC\$1 04:00)
+ Etc/GMT-4 (UTC\$1 04:00)
+ Etc/GMT-4 (UTC\$1 04:00)
+ Asie/Dubaï (UTC\$1 04:00)
+ Indien/Réunion (UTC\$1 04:00)
+ Europe/Saratov (UTC\$1 04:00)
+ Europe/Samara (UTC\$1 04:00)
+ Indien/Mahé (UTC\$1 04:00)
+ Asie/Bakou (UTC\$1 04:00)
+ Asie/Muscat (UTC\$1 04:00)
+ Europe/Volgograd (UTC\$1 04:00)
+ Europe/Astrakhan (UTC\$1 04:00)
+ Asie/Tbilissi (UTC\$1 04:00)
+ Europe/Oulianovsk (UTC\$1 04:00)
+ Asie/Aden (UTC\$1 03:00)
+ Afrique/Nairobi (UTC\$1 03:00)
+ Europe/Istanbul (UTC\$1 03:00)
+ Etc/GMT-3 (UTC\$1 03:00)
+ Europe/Zaporijia (UTC\$1 03:00)
+ Israël (UTC\$1 03:00)
+ Indien/Comores (UTC\$1 03:00)
+ Antarctique/Syowa (UTC\$1 03:00)
+ Afrique/Mogadiscio (UTC\$1 03:00)
+ Europe/Bucarest (UTC\$1 03:00)
+ Afrique/Asmera (UTC\$1 03:00)
+ Europe/Mariehamn (UTC\$1 03:00)
+ Asie/Istanbul (UTC\$1 03:00)
+ Europe/Tiraspol (UTC\$1 03:00)
+ Europe/Moscou (UTC\$1 03:00)
+ Europe/Chişinău (UTC\$1 03:00)
+ Europe/Helsinki (UTC\$1 03:00)
+ Asie/Beyrouth (UTC\$1 03:00)
+ Asie/Tel\$1Aviv (UTC\$1 03:00)
+ Afrique/Djibouti (UTC\$1 03:00)
+ Europe/Simferopol (UTC\$1 03:00)
+ Europe/Sofia (UTC\$1 03:00)
+ Asie/Gaza (UTC\$1 03:00)
+ Afrique/Asmara (UTC\$1 03:00)
+ Europe/Riga (UTC\$1 03:00)
+ Asie/Bagdad (UTC\$1 03:00)
+ Asie/Damas (UTC\$1 03:00)
+ AFRIQUE/Dar\$1es\$1Salaam (UTC\$1 03:00)
+ Afrique/Addis\$1Abeba (UTC\$1 03:00)
+ Europe/Oujgorod (UTC\$1 03:00)
+ Asie/Jerusalem (UTC\$1 03:00)
+ Asie/Riyadh (UTC\$1 03:00)
+ Asie/Koweït (UTC\$1 03:00)
+ Europe/Kirov (UTC\$1 03:00)
+ Afrique/Kampala (UTC\$1 03:00)
+ Europe/Minsk (UTC\$1 03:00)
+ Asie/Qatar (UTC\$1 03:00)
+ Europe/Kiev (UTC\$1 03:00)
+ Asie/Bahreïn (UTC\$1 03:00)
+ Europe/Vilnius (UTC\$1 03:00)
+ Indien/Antananarivo (UTC\$1 03:00)
+ Indien/Mayotte (UTC\$1 03:00)
+ Europe/Tallinn (UTC\$1 03:00)
+ Turquie (UTC\$1 03:00)
+ Afrique/Juba (UTC\$1 03:00)
+ Asie/Nicosie (UTC\$1 03:00)
+ Asie/Famagouste (UTC\$1 03:00)
+ SAMEDI (UTC\$1 03:00)
+ RENCONTRE (UTC\$1 03:00)
+ Asie/Hébron (UTC\$1 03:00)
+ Asie/Amman (UTC\$1 03:00)
+ Europe/Nicosie (UTC\$1 03:00)
+ Europe/Athènes (UTC\$1 03:00)
+ Afrique/Le Caire (UTC\$1 02:00)
+ Afrique/Mbabane (UTC\$1 02:00)
+ Europe/Bruxelles (UTC\$1 02:00)
+ Europe/Varsovie (UTC\$1 02:00)
+ HEURE DE PARIS (UTC\$1 02:00)
+ Europe/Luxembourg (UTC\$1 02:00)
+ Etc/GMT-2 (UTC\$1 02:00)
+ Libye (UTC\$1 02:00)
+ Afrique/Kigali (UTC\$1 02:00)
+ Afrique/Tripoli (UTC\$1 02:00)
+ Europe/Kaliningrad (UTC\$1 02:00)
+ Afrique/Windhoek (UTC\$1 02:00)
+ Europe/Malte (UTC\$1 02:00)
+ Europe/Büsingen (UTC\$1 02:00)
+ 
+ Europe/Skopje (UTC\$1 02:00)
+ Europe/Sarajevo (UTC\$1 02:00)
+ Europe/Rome (UTC\$1 02:00)
+ Europe/Zürich (UTC\$1 02:00)
+ Europe/Gibraltar (UTC\$1 02:00)
+ Afrique/Lubumbashi (UTC\$1 02:00)
+ Europe/Vaduz (UTC\$1 02:00)
+ Europe/Ljubljana (UTC\$1 02:00)
+ Europe/Berlin (UTC\$1 02:00)
+ Europe/Stockholm (UTC\$1 02:00)
+ Europe/Budapest (UTC\$1 02:00)
+ Europe/Zagreb (UTC\$1 02:00)
+ Europe/Paris (UTC\$1 02:00)
+ Afrique/Ceuta (UTC\$1 02:00)
+ Europe/Praha (UTC\$1 02:00)
+ Antarctique/Troll (UTC\$1 02:00)
+ Afrique/Gaborone (UTC\$1 02:00)
+ Europe/Copenhague (UTC\$1 02:00)
+ Europe/Vienne (UTC\$1 02:00)
+ Europe/Tirana (UTC\$1 02:00)
+ MET (UTC\$1 02:00)
+ Europe/Amsterdam (UTC\$1 02:00)
+ Afrique/Maputo (UTC\$1 02:00)
+ Europe/Saint-Marin (UTC\$1 02:00)
+ Pologne (UTC\$1 02:00)
+ Europe/Andorre (UTC\$1 02:00)
+ Europe/Oslo (UTC\$1 02:00)
+ Europe/Podgorica (UTC\$1 02:00)
+ Afrique/Bujumbura (UTC\$1 02:00)
+ Atlantic/Jan\$1Mayen (UTC\$1 02:00)
+ Afrique/Maseru (UTC\$1 02:00)
+ Europe/Madrid (UTC\$1 02:00)
+ Afrique/Blantyre (UTC\$1 02:00)
+ Afrique/Lusaka (UTC\$1 02:00)
+ Afrique/Harare (UTC\$1 02:00)
+ Afrique/Khartoum (UTC\$1 02:00)
+ Afrique/Johannesburg (UTC\$1 02:00)
+ Europe/Belgrade (UTC\$1 02:00)
+ Europe/Bratislava (UTC\$1 02:00)
+ Arctic/Longyearbyen (UTC\$1 02:00)
+ Égypte (UTC\$1 02:00)
+ Europe/Vatican (UTC\$1 02:00)
+ Europe/Monaco (UTC\$1 02:00)
+ Europe/Londres (UTC\$1 01:00)
+ Etc/GMT-1 (UTC\$1 01:00)
+ Europe/Jersey (UTC\$1 01:00)
+ Europe/Guernesey (UTC\$1 01:00)
+ Europe/Isle\$1of\$1Man (UTC\$1 01:00)
+ Afrique/Tunis (UTC\$1 01:00)
+ Afrique/Malabo (UTC\$1 01:00)
+ GB-Eire (UTC\$1 01:00)
+ Afrique/Lagos (UTC\$1 01:00)
+ Afrique/Alger (UTC\$1 01:00)
+ GB (UTC\$1 01:00)
+ Portugal (UTC\$1 01:00)
+ Afrique/Sao\$1Tome (UTC\$1 01:00)
+ Afrique/Ndjamena (UTC\$1 01:00)
+ Atlantique/Féroé (UTC\$1 01:00)
+ Irlande (UTC\$1 01:00)
+ Atlantique/Féroé (UTC\$1 01:00)
+ Europe/Dublin (UTC\$1 01:00)
+ Afrique/Libreville (UTC\$1 01:00)
+ Afrique/El\$1Aaiun (UTC\$1 01:00)
+ Afrique/El\$1Aaiun (UTC\$1 01:00)
+ Afrique/Douala (UTC\$1 01:00)
+ Afrique/Brazzaville (UTC\$1 01:00)
+ Afrique/Porto-Novo (UTC\$1 01:00)
+ Atlantique/Madère (UTC\$1 01:00)
+ Europe/Lisbonne (UTC\$1 01:00)
+ Atlantique/Canaries (UTC\$1 01:00)
+ Afrique/Casablanca (UTC\$1 01:00)
+ Europe/Belfast (UTC\$1 01:00)
+ Afrique/Luanda (UTC\$1 01:00)
+ Afrique/Kinshasa (UTC\$1 01:00)
+ Afrique/Bangui (UTC\$1 01:00)
+ HUMIDE (UTC\$1 01:00)
+ Afrique/Niamey (UTC\$1 01:00)
+ GMT (UTC\$1 00:00)
+ Etc/GMT-0 (UTC\$1 00:00)
+ Atlantic/Sainte-Hélène (UTC\$1 00:00)
+ Etc/GMT\$10 (UTC\$1 00:00)
+ Afrique/Banjul (UTC\$1 00:00)
+ Etc/GMT (UTC\$1 00:00)
+ Afrique/Freetown (UTC\$1 00:00)
+ Afrique/Bamako (UTC\$1 00:00)
+ Afrique/Conakry (UTC\$1 00:00)
+ Universel (UTC\$1 00:00)
+ Afrique/Nouakchott (UTC\$1 00:00)
+ UTC (UTC\$1 00:00)
+ Etc/Universal (UTC\$1 00:00)
+ Atlantique/Açores (UTC\$1 00:00)
+ Afrique/Abidjan (UTC\$1 00:00)
+ Afrique/Accra (UTC\$1 00:00)
+ Etc/UCT (UTC\$1 00:00)
+ GMT0 (UTC\$1 00:00)
+ Zoulou (UTC\$1 00:00) Zoulou (UTC\$1 00:00)
+ Afrique/Ouagadougou (UTC\$1 00:00)
+ Atlantique/Reykjavik (UTC\$1 00:00)
+ Etc/Zoulou (UTC\$1 00:00)
+ Islande (UTC\$1 00:00)
+ Afrique/Lomé (UTC\$1 00:00)
+ Greenwich (UTC\$1 00:00)
+ Etc/ GMT0 (UTC\$1 00:00)
+ America/Danmarkshavn (UTC\$1 00:00)
+ Afrique/Dakar (UTC\$1 00:00)
+ Afrique/Bissau (UTC\$1 00:00)
+ Etc/Greenwich (UTC\$1 00:00)
+ Afrique/Tombouctou (UTC\$1 00:00)
+ UTC (UTC\$1 00:00)
+ Afrique/Monrovia (UTC\$1 00:00)
+ Etc/UTC (UTC\$1 00:00)

# Tutoriels d'expression de formules
<a name="expression-tutorials"></a>

Vous pouvez suivre ces didacticiels pour utiliser des expressions de formule dans AWS IoT SiteWise.

**Topics**
+ [Utiliser des chaînes dans les formules](#use-strings-in-formulas)
+ [Filtrer les points de données](#filter-data)
+ [Compter les points de données qui correspondent à une condition](#count-filtered-data)
+ [Données tardives dans les formules](#late-data)
+ [Qualité des données dans les formules](#data-quality)
+ [Valeurs non définies, infinies et en dépassement](#undefined-values)

## Utiliser des chaînes dans les formules
<a name="use-strings-in-formulas"></a>

Vous pouvez opérer sur des chaînes dans vos expressions de formule. Vous pouvez également saisir des chaînes à partir de variables qui font référence à des propriétés d'attribut et de mesure.

**Important**  
<a name="formula-output-rules"></a>Les expressions de formule ne peuvent générer que des valeurs doubles ou des valeurs de chaîne. Les expressions imbriquées peuvent générer d'autres types de données, tels que des chaînes, mais la formule dans son ensemble doit être évaluée à un nombre ou à une chaîne. Vous pouvez utiliser la [fonction jp](expression-string-functions.md#jp-definition) pour convertir une chaîne en nombre. La valeur booléenne doit être 1 (vrai) ou 0 (faux). Pour de plus amples informations, veuillez consulter [Valeurs non définies, infinies et en dépassement](#undefined-values).

AWS IoT SiteWise fournit les fonctionnalités d'expression de formule suivantes que vous pouvez utiliser pour agir sur des chaînes :
+ [Littéraux de chaîne](expression-literals.md#string-literal-definition)
+ L'[opérateur d'index](expression-operators.md#index-operator-definition) (`s[index]`)
+ L'[opérateur de tranche](expression-operators.md#slice-operator-definition) (`s[start:end:step]`)
+ [Fonctions de comparaison](expression-comparison-functions.md), que vous pouvez utiliser pour comparer des chaînes par ordre [lexicographique](https://en.wikipedia.org/wiki/Lexicographic_order)
+ [Fonctions de chaîne](expression-string-functions.md), qui incluent la `jp` fonction capable d'analyser des objets JSON sérialisés et de convertir des chaînes en nombres

## Filtrer les points de données
<a name="filter-data"></a>

Vous pouvez utiliser la [fonction if](expression-conditional-functions.md#if-definition) pour filtrer les points de données qui ne répondent pas à une condition. La `if` fonction évalue une condition et renvoie des valeurs `true` et des `false` résultats différents. Vous pouvez utiliser la [constante none](expression-constants.md#none-definition) comme sortie pour un cas de `if` fonction afin de supprimer le point de données correspondant à ce cas.

**Pour filtrer les points de données qui correspondent à une condition**
+ Créez une transformation qui utilise la `if` fonction pour définir une condition qui vérifie si une condition est remplie et renvoie `none` la `result_if_false` valeur `result_if_true` ou.

**Example Exemple : filtrer les points de données où l'eau ne bout pas**  
Imaginons un scénario dans lequel vous avez une mesure qui fournit la température (en degrés Celsius) de l'eau dans une machine. `temp_c` Vous pouvez définir la transformation suivante pour filtrer les points de données où l'eau n'est pas en ébullition :  
+ Transformation : `boiling_temps = if(gte(temp_c, 100), temp_c, none)` — Renvoie la température si elle est supérieure ou égale à 100 degrés Celsius, sinon elle ne renvoie aucun point de données.

## Compter les points de données qui correspondent à une condition
<a name="count-filtered-data"></a>

Vous pouvez utiliser [les fonctions de comparaison](expression-comparison-functions.md) et [sum ()](expression-aggregation-functions.md#sum-definition) pour compter le nombre de points de données pour lesquels une condition est vraie.

**Pour compter les points de données qui correspondent à une condition**

1. Créez une transformation qui utilise une fonction de comparaison pour définir une condition de filtre sur une autre propriété.

1. Créez une métrique qui additionne les points de données lorsque cette condition est remplie.

**Example Exemple : Compter le nombre de points de données où l'eau bout**  
Imaginons un scénario dans lequel vous avez une mesure qui fournit la température (en degrés Celsius) de l'eau dans une machine. `temp_c` Vous pouvez définir les propriétés de transformation et de métrique suivantes pour compter le nombre de points de données où l'eau bout :  
+ Transformation : `is_boiling = gte(temp_c, 100)` — Renvoie `1` si la température est supérieure ou égale à 100 degrés Celsius, sinon elle renvoie la valeur`0`.
+ Métrique : `boiling_count = sum(is_boiling)` — Renvoie le nombre de points de données où l'eau est en ébullition.

## Données tardives dans les formules
<a name="late-data"></a>

AWS IoT SiteWise prend en charge l'ingestion tardive de données datant de moins de 7 jours. Lorsqu'il AWS IoT SiteWise reçoit des données tardives, il recalcule les valeurs existantes pour toute métrique qui saisit les données tardives dans une fenêtre précédente. Ces nouveaux calculs entraînent des frais de traitement des données.

**Note**  
Lorsqu'il AWS IoT SiteWise calcule des propriétés qui entrent des données tardives, il utilise l'expression de formule actuelle de chaque propriété.

Après avoir AWS IoT SiteWise recalculé une fenêtre passée pour une métrique, elle remplace la valeur précédente pour cette fenêtre. Si vous avez activé les notifications pour cette métrique, émet AWS IoT SiteWise également une notification de valeur de propriété. Cela signifie que vous pouvez recevoir une nouvelle notification de mise à jour de valeur de propriété pour la même propriété et le même horodatage que ceux pour lesquels vous avez déjà reçu une notification. Si vos applications ou lacs de données utilisent des notifications de valeur de propriété, vous devez mettre à jour la valeur précédente avec la nouvelle valeur afin que leurs données soient exactes.

## Qualité des données dans les formules
<a name="data-quality"></a>

Dans AWS IoT SiteWise, chaque point de données possède un code de qualité, qui peut être l'un des suivants :
+ `GOOD`— Les données ne sont affectées par aucun problème.
+ `BAD`— Les données sont affectées par un problème tel qu'une défaillance du capteur.
+ `UNCERTAIN`— Les données sont affectées par un problème tel que l'imprécision du capteur.

AWS IoT SiteWise ne consomme que des données `GOOD` de qualité lorsqu'il calcule les transformations et les métriques. AWS IoT SiteWise ne produit que des données `GOOD` de qualité pour des calculs réussis. Si un calcul échoue, aucun point de données AWS IoT SiteWise n'est généré pour ce calcul. Cela peut se produire si un calcul aboutit à une valeur non définie, infinie ou en dépassement.

Pour de plus amples informations sur l'interrogation des données et les filtres par qualité de données, veuillez consulter [Interrogez les données de AWS IoT SiteWise](query-industrial-data.md).

## Valeurs non définies, infinies et en dépassement
<a name="undefined-values"></a>

Certaines expressions de formule (telles que `x / 0``sqrt(-1)`, ou`log(0)`) calculent des valeurs non définies dans un système de nombres réels, infinies ou situées en dehors de la plage prise en charge par AWS IoT SiteWise. Lorsque l'expression d'une propriété d'actif calcule une valeur indéfinie, infinie ou de dépassement, AWS IoT SiteWise elle ne produit aucun point de données pour ce calcul.

AWS IoT SiteWise ne produit pas non plus de point de données s'il calcule une valeur non numérique à la suite d'une expression de formule. Cela signifie que si vous définissez une formule qui calcule une chaîne, un tableau ou la [constante none](expression-constants.md#none-definition), elle AWS IoT SiteWise ne produit aucun point de données pour ce calcul.

**Example Exemples**  
Chacune des expressions de formule suivantes génère une valeur qui ne AWS IoT SiteWise peut pas être représentée sous forme de nombre. AWS IoT SiteWise ne produit pas de point de données lorsqu'il calcule ces expressions de formule.  
+ `x / 0`n'est pas défini.
+ `log(0)`n'est pas défini.
+ `sqrt(-1)`n'est pas défini dans un système de nombres réels.
+ `"hello" + " world"`est une chaîne.
+ `jp('{"values":[3,6,7]}', '$.values')`est un tableau.
+ `if(gte(temp, 300), temp, none)`c'est `none` quand `temp` est inférieur à`300`.