Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Stato del workflow di scelta
**Gestione dello stato e trasformazione dei dati**
Scopri come [passare dati tra stati con variabili](workflow-variables.md) e [trasformare i dati con](transforming-data.md) JSonata.
Uno `Choice` stato (`"Type": "Choice"`) aggiunge logica condizionale a una macchina a stati.
Oltre alla maggior parte dei [campi di stato comuni](statemachine-structure.md#amazon-states-language-common-fields), `Choice` states contiene i seguenti campi aggiuntivi.
**`Choices` (Obbligatorio)**
Un array di [regole Choice](#state-choice-rules) che determina lo stato successivo della macchina a stati. È necessario definire almeno una regola nello `Choice` stato.
Quando viene eseguito uno `Choice` stato, Step Functions valuta ogni **regola di scelta** come true o false. In base al risultato, Step Functions passa allo stato successivo del flusso di lavoro.
**`Default` (Facoltativo, Consigliato)**
Il nome dello stato verso cui passare se nessuna **regola di scelta** restituisce vero.
**Importante**
Gli stati `Choice` non supportano il campo `End`. Inoltre, utilizzano `Next` solo nel relativo campo `Choices`.
Se nessun valore **Choices** restituisce true durante l'esecuzione del flusso di lavoro e non viene fornito alcun **valore di default**, la macchina a stati genererà un **errore** dovuto *alla mancata transizione verso l'esterno dello stato*.
## Regole di scelta (JSonata)
Uno `Choice` stato deve avere un `Choices` campo il cui valore è un array non vuoto di Choice Rules, che contiene i seguenti campi quando si utilizza JSonata:
+ **`Condition`field**: un'espressione JSonata che restituisce a. true/false
+ **`Next`field** — un valore che deve corrispondere al nome di uno stato nella macchina a stati.
+ **`Assign`field** (Facoltativo): assegna le variabili quando questa regola di scelta specifica corrisponde. Ogni regola di scelta può avere il proprio `Assign` blocco, che consente di impostare variabili diverse a seconda del percorso seguito. Puoi anche specificare un `Assign` blocco a livello di stato, che si applica indipendentemente dalla regola di scelta corrispondente.
L'esempio seguente verifica se il valore numerico è uguale a `1`.
```
{
"Condition": "{% $foo = 1 %}",
"Next": "NumericMatchState"
}
```
L'esempio seguente verifica se la `type` variabile è uguale a`local`.
```
{
"Condition": "{% $type = 'local' %}",
"Next": "StringMatchState"
}
```
L'esempio seguente verifica se la stringa è maggiore di `MyStringABC`.
```
{
"Condition": "{% $foo > 'MyStringABC' %}",
"Next": "StringGreaterMatchState"
}
```
L'esempio seguente verifica se la stringa non è nulla.
```
{
"Condition" : "{% $possiblyNullValue != null and $possiblyNullValue = 42 %}",
"Next": "NotNullAnd42"
}
```
L'esempio seguente mostra uno `Choice` stato con `Assign` blocchi per regola che impostano variabili diverse in base alla condizione corrispondente:
```
{
"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
}
}
```
## L'utilizzo degli stati Assign with Choice
È possibile utilizzare il `Assign` campo a due livelli in uno stato Choice:
+ **Livello superiore**: definito direttamente nello stato di scelta, al di fuori di qualsiasi regola di scelta.
+ **All'interno di una regola di scelta**: definita all'interno di una singola regola dell'`Choices`array.
Questi due posizionamenti si escludono a vicenda in fase di esecuzione. Se una regola di scelta corrisponde, Step Functions valuta solo il `Assign` campo di quella regola e non valuta il campo di primo livello`Assign`. Step Functions valuta il livello superiore `Assign` solo quando nessuna regola di scelta corrisponde e il flusso di lavoro passa allo stato. `Default`
L'esempio seguente mostra entrambi i posizionamenti.
```
{
"Type": "Choice",
"Assign": {
"outputValue": "{% 'default path taken' %}"
},
"Choices": [
{
"Condition": "{% $score > 90 %}",
"Assign": {
"outputValue": "{% 'high score' %}"
},
"Next": "HighScoreState"
},
{
"Condition": "{% $score > 50 %}",
"Next": "MediumScoreState"
}
],
"Default": "LowScoreState"
}
```
In questo esempio, se `$score` è maggiore di 90, Step Functions `outputValue` assegna a `"high score"` e transizioni a. `HighScoreState` Il livello superiore non `Assign` viene valutato. Se nessuna regola corrisponde, Step Functions valuta il livello superiore `Assign` e passa a. `LowScoreState`
## Regole di scelta (JsonPath)
Uno `Choice` stato deve avere un `Choices` campo il cui valore è una matrice non vuota di Choice Rules, che contiene i seguenti campi quando si utilizza JsonPath:
+ Un **confronto**: due campi che specificano una variabile di input da confrontare, il tipo di confronto e il valore con cui confrontare la variabile. Le regole di scelta supportano il confronto tra due variabili. All'interno di una regola di scelta, il valore della variabile può essere confrontato con un altro valore dello stato immesso aggiungendolo `Path` al nome degli operatori di confronto supportati. I valori dei campi `Variable` e Path in un confronto devono essere [percorsi di riferimento](amazon-states-language-paths.md#amazon-states-language-reference-paths) validi.
+ Un **`Next`campo**: il valore di questo campo deve corrispondere al nome di uno stato nella macchina a stati.
L'esempio seguente verifica se il valore numerico è uguale a `1`.
```
{
"Variable": "$.foo",
"NumericEquals": 1,
"Next": "FirstMatchState"
}
```
L'esempio seguente verifica se la stringa è uguale a `MyString`.
```
{
"Variable": "$.foo",
"StringEquals": "MyString",
"Next": "FirstMatchState"
}
```
L'esempio seguente verifica se la stringa è maggiore di `MyStringABC`.
```
{
"Variable": "$.foo",
"StringGreaterThan": "MyStringABC",
"Next": "FirstMatchState"
}
```
L'esempio seguente verifica se la stringa è nulla.
```
{
"Variable": "$.possiblyNullValue",
"IsNull": true
}
```
L'esempio seguente mostra come la StringEquals regola viene valutata solo quando `$.keyThatMightNotExist` esiste a causa della precedente Choice Rule. `IsPresent`
```
"And": [
{
"Variable": "$.keyThatMightNotExist",
"IsPresent": true
},
{
"Variable": "$.keyThatMightNotExist",
"StringEquals": "foo"
}
]
```
L'esempio seguente verifica se un pattern con un carattere jolly corrisponde.
```
{
"Variable": "$.foo",
"StringMatches": "log-*.txt"
}
```
L'esempio seguente verifica se il timestamp è uguale a `2001-01-01T12:00:00Z`.
```
{
"Variable": "$.foo",
"TimestampEquals": "2001-01-01T12:00:00Z",
"Next": "FirstMatchState"
}
```
L'esempio seguente confronta una variabile con un altro valore dell'input di stato.
```
{
"Variable": "$.foo",
"StringEqualsPath": "$.bar"
}
```
Step Functions esamina ciascuna delle regole di scelta nell'ordine elencato nel `Choices` campo. Quindi passa allo stato specificato nel campo `Next` della prima regola Choice in cui la variabile corrisponde al valore in base all'operatore di confronto.
Sono supportati i seguenti operatori di confronto:
+ `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`
Per ciascuno di questi operatori, il valore corrispondente deve essere del tipo appropriato: stringa, numero, booleano o timestamp. Step Functions non tenta di abbinare un campo numerico a un valore stringa. Tuttavia, poiché i campi timestamp sono logicamente delle stringhe, è possibile che un campo considerato come timestamp possa corrispondere a un comparatore `StringEquals`.
**Nota**
Per l'interoperabilità, non supporre che i confronti numerici funzionino con valori al di fuori della grandezza o della precisione che il tipo di dati [IEEE 754-2008`binary64`](https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats) rappresenta. In particolare, gli interi che non rientrano nell'intervallo `[-253+1, 253-1]` potrebbero non essere confrontati come previsto.
I timestamp (ad esempio, `2016-08-18T17:33:00Z`) devono essere conformi al [profilo RFC3339 ISO 8601](https://www.ietf.org/rfc/rfc3339.txt), con ulteriori limitazioni:
Una `T` maiuscola deve separare la parte della data dalla parte dell'ora.
Una `Z` maiuscola indica che al momento non è disponibile l'offset del fuso orario numerico.
Per comprendere il funzionamento dei confronti di stringhe, consultare la [documentazione di `compareTo`](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String-).
I valori degli operatori `And` e `Or` devono essere array non vuoti di regole Choice che non devono contenere campi `Next`. Inoltre, il valore di un operatore `Not` deve essere una singola regola Choice che non deve contenere campi `Next`.
Puoi creare regole Choice nidificate complesse utilizzando `And`, `Not` e `Or`. Tuttavia, il campo `Next` può essere visualizzato solo in una regola Choice di livello superiore.
Il confronto tra stringhe e modelli con uno o più caratteri jolly («\*») può essere eseguito con l'operatore di StringMatches confronto. Il carattere jolly viene eliminato utilizzando lo standard. `\\ (Ex: “\\*”)` Nessun carattere diverso da «\*» ha un significato speciale durante la corrispondenza.