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.
# État du flux de travail de choix
**Gestion de l'état et transformation des données**
Découvrez comment [transmettre des données entre états à l'aide de variables](workflow-variables.md) et [transformer des données avec JSonata](transforming-data.md).
Un `Choice` state (`"Type": "Choice"`) ajoute une logique conditionnelle à une machine à états.
Outre la plupart des [champs d'état courants, les](statemachine-structure.md#amazon-states-language-common-fields) `Choice` états contiennent les champs supplémentaires suivants.
**`Choices` (Obligatoire)**
Tableau des [règles Choice](#state-choice-rules) qui détermine quel est l'état suivant de la machine d'état. Vous devez définir au moins une règle dans l'`Choice`État.
Lorsqu'un `Choice` état est exécuté, Step Functions attribue à chaque **règle de choix** la valeur vraie ou fausse. Sur la base du résultat, Step Functions passe à l'état suivant du flux de travail.
**`Default` (Facultatif, Recommandé)**
Nom de l'état vers lequel passer si aucune **règle de choix** n'est considérée comme vraie.
**Important**
Les états `Choice` ne prennent pas en charge le champ `End`. De plus, ils utilisent `Next` uniquement dans le champ `Choices`.
Si aucun **choix** n'est considéré comme vrai lors de l'exécution du flux de travail et qu'aucune **valeur par défaut** n'est fournie, la machine à états **génère une erreur** en raison de *l'échec de la transition hors de l'état*.
## Règles de choix (JSonata)
Un `Choice` état doit avoir un `Choices` champ dont la valeur est un tableau non vide de règles de choix, qui contient les champs suivants lors de l'utilisation de JSonata :
+ **`Condition`field** — une expression JSonata dont la valeur est égale à. true/false
+ **`Next`field** : valeur qui doit correspondre à un nom d'état dans la machine à états.
+ **`Assign`champ** (facultatif) — assigne des variables lorsque cette règle de choix spécifique correspond. Chaque règle de choix peut avoir son propre `Assign` bloc, ce qui vous permet de définir différentes variables en fonction du chemin emprunté. Vous pouvez également spécifier un `Assign` bloc au niveau de l'État, qui s'applique quelle que soit la règle de choix qui correspond.
L'exemple suivant vérifie si la valeur numérique est égale à `1`.
```
{
"Condition": "{% $foo = 1 %}",
"Next": "NumericMatchState"
}
```
L'exemple suivant vérifie si la `type` variable est égale à`local`.
```
{
"Condition": "{% $type = 'local' %}",
"Next": "StringMatchState"
}
```
L'exemple suivant vérifie si la chaîne est supérieure à `MyStringABC`.
```
{
"Condition": "{% $foo > 'MyStringABC' %}",
"Next": "StringGreaterMatchState"
}
```
L'exemple suivant vérifie si la chaîne n'est pas nulle.
```
{
"Condition" : "{% $possiblyNullValue != null and $possiblyNullValue = 42 %}",
"Next": "NotNullAnd42"
}
```
L'exemple suivant montre un `Choice` état avec des `Assign` blocs par règle qui définissent différentes variables en fonction de la condition correspondante :
```
{
"Type": "Choice",
"Choices": [
{
"Condition": "{% $states.input.category = 'premium' %}",
"Next": "PremiumPath",
"Assign": {
"discount": 20
}
},
{
"Condition": "{% $states.input.category = 'standard' %}",
"Next": "StandardPath",
"Assign": {
"discount": 5
}
}
],
"Default": "DefaultPath",
"Assign": {
"discount": 0
}
}
```
## Utilisation d'Assign with Choice states
Vous pouvez utiliser le `Assign` champ à deux niveaux dans un état Choice :
+ **Niveau supérieur** : défini directement dans l'état Choix, en dehors de toute règle de choix.
+ **À l'intérieur d'une règle de choix** : définie dans une règle individuelle du `Choices` tableau.
Ces deux emplacements s'excluent mutuellement lors de l'exécution. Si une règle de choix correspond, Step Functions évalue uniquement le `Assign` champ de cette règle et n'évalue pas le champ de niveau supérieur`Assign`. Step Functions évalue le niveau supérieur `Assign` uniquement lorsqu'aucune règle de choix ne correspond et que le flux de travail passe à l'`Default`état actuel.
L'exemple suivant montre les deux emplacements.
```
{
"Type": "Choice",
"Assign": {
"outputValue": "{% 'default path taken' %}"
},
"Choices": [
{
"Condition": "{% $score > 90 %}",
"Assign": {
"outputValue": "{% 'high score' %}"
},
"Next": "HighScoreState"
},
{
"Condition": "{% $score > 50 %}",
"Next": "MediumScoreState"
}
],
"Default": "LowScoreState"
}
```
Dans cet exemple, si la `$score` valeur est supérieure à 90, Step Functions affecte `outputValue` à `"high score"` et passe à`HighScoreState`. Le niveau supérieur n'`Assign`est pas évalué. Si aucune règle ne correspond, Step Functions évalue le niveau supérieur `Assign` et passe à. `LowScoreState`
## Règles de choix (JSONPath)
Un `Choice` état doit avoir un `Choices` champ dont la valeur est un tableau non vide de règles de choix, qui contient les champs suivants lors de l'utilisation de JSONPath :
+ Une **comparaison** : deux champs qui spécifient une variable d'entrée à comparer, le type de comparaison et la valeur à laquelle comparer la variable. Les règles de choix permettent de comparer deux variables. Dans une règle de choix, la valeur d'une variable peut être comparée à une autre valeur de l'entrée d'état en ajoutant `Path` au nom des opérateurs de comparaison pris en charge. Les valeurs des champs `Variable` et Chemin d'une comparaison doivent être des [chemins de référence](amazon-states-language-paths.md#amazon-states-language-reference-paths) valides.
+ Un **`Next`champ** — La valeur de ce champ doit correspondre à un nom d'état dans la machine à états.
L'exemple suivant vérifie si la valeur numérique est égale à `1`.
```
{
"Variable": "$.foo",
"NumericEquals": 1,
"Next": "FirstMatchState"
}
```
L'exemple suivant vérifie si la chaîne est égale à `MyString`.
```
{
"Variable": "$.foo",
"StringEquals": "MyString",
"Next": "FirstMatchState"
}
```
L'exemple suivant vérifie si la chaîne est supérieure à `MyStringABC`.
```
{
"Variable": "$.foo",
"StringGreaterThan": "MyStringABC",
"Next": "FirstMatchState"
}
```
L'exemple suivant vérifie si la chaîne est nulle.
```
{
"Variable": "$.possiblyNullValue",
"IsNull": true
}
```
L'exemple suivant montre comment la StringEquals règle n'est évaluée que lorsqu'elle `$.keyThatMightNotExist` existe en raison de la règle de `IsPresent` choix précédente.
```
"And": [
{
"Variable": "$.keyThatMightNotExist",
"IsPresent": true
},
{
"Variable": "$.keyThatMightNotExist",
"StringEquals": "foo"
}
]
```
L'exemple suivant vérifie si un modèle comportant un caractère générique correspond.
```
{
"Variable": "$.foo",
"StringMatches": "log-*.txt"
}
```
L'exemple suivant vérifie si l'horodatage est égal à `2001-01-01T12:00:00Z`.
```
{
"Variable": "$.foo",
"TimestampEquals": "2001-01-01T12:00:00Z",
"Next": "FirstMatchState"
}
```
L'exemple suivant compare une variable avec une autre valeur de l'entrée d'état.
```
{
"Variable": "$.foo",
"StringEqualsPath": "$.bar"
}
```
Step Functions examine chacune des règles de choix dans l'ordre indiqué dans le `Choices` champ. Ensuite, il passe à l'état spécifié dans le champ `Next` de la première règle Choice dans lequel la variable correspond à la valeur en fonction de l'opérateur de comparaison.
Les opérateurs de comparaison suivants sont pris en charge :
+ `And`
+ `BooleanEquals`,`BooleanEqualsPath`
+ `IsBoolean`
+ `IsNull`
+ `IsNumeric`
+ `IsPresent`
+ `IsString`
+ `IsTimestamp`
+ `Not`
+ `NumericEquals`,`NumericEqualsPath`
+ `NumericGreaterThan`,`NumericGreaterThanPath`
+ `NumericGreaterThanEquals`,`NumericGreaterThanEqualsPath`
+ `NumericLessThan`,`NumericLessThanPath`
+ `NumericLessThanEquals`,`NumericLessThanEqualsPath`
+ `Or`
+ `StringEquals`,`StringEqualsPath`
+ `StringGreaterThan`,`StringGreaterThanPath`
+ `StringGreaterThanEquals`,`StringGreaterThanEqualsPath`
+ `StringLessThan`,`StringLessThanPath`
+ `StringLessThanEquals`,`StringLessThanEqualsPath`
+ `StringMatches`
+ `TimestampEquals`,`TimestampEqualsPath`
+ `TimestampGreaterThan`,`TimestampGreaterThanPath`
+ `TimestampGreaterThanEquals`,`TimestampGreaterThanEqualsPath`
+ `TimestampLessThan`,`TimestampLessThanPath`
+ `TimestampLessThanEquals`,`TimestampLessThanEqualsPath`
Pour chacun de ces opérateurs, la valeur correspondante doit être du type approprié : chaîne, nombre, booléen ou horodatage. Step Functions n'essaie pas de faire correspondre un champ numérique à une valeur de chaîne. Cependant, étant donné que les champs d'horodatage sont logiquement des chaînes, il est possible qu'un champ considéré comme un horodatage puisse être rapproché par un comparateur `StringEquals`.
**Note**
Pour l'interopérabilité, ne supposez pas que les comparaisons numériques fonctionnent avec des valeurs en dehors de l'ampleur ou de la précision représentée par le type de données [IEEE 754-2008 `binary64`](https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats). Notez plus particulièrement que les entiers en dehors de la plage `[-253+1, 253-1]` ne pourront pas être comparés comme prévu.
Les horodatages (par exemple, `2016-08-18T17:33:00Z`) doivent respecter [RFC3339 profil ISO 8601](https://www.ietf.org/rfc/rfc3339.txt), avec davantage de restrictions :
Un `T` majuscule doit séparer les parties date et heure.
Un `Z` majuscule doit indiquer qu'un décalage de fuseau horaire numérique n'est pas présent.
Pour comprendre le comportement des comparaisons de chaînes, consultez la documentation [Java`compareTo`](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String-).
Les valeurs des opérateurs `And` et `Or` doivent être des tableaux non vides de règles Choice qui ne doivent pas elles-mêmes contenir des champs `Next`. De la même manière, la valeur d'un opérateur `Not` doit être une seule règle Choice qui ne doit pas contenir de champs `Next`.
Vous pouvez créer des règles Choice imbriquées complexes à l'aide de `And`, `Not` et `Or`. Toutefois, le champ `Next` peut s'afficher uniquement dans une règle Choice de niveau supérieur.
La comparaison de chaînes par rapport à des modèles comportant un ou plusieurs caractères génériques (« \* ») peut être effectuée à l'aide de l'opérateur de StringMatches comparaison. Le caractère générique est évité en utilisant le standard. `\\ (Ex: “\\*”)` Aucun caractère autre que « \* » n'a de signification particulière lors de la mise en correspondance.