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 flusso di lavoro di scelta **Gestione dello stato e trasformazione dei dati** Scopri come [passare dati tra stati con variabili](workflow-variables.md) e [Trasformare dati](transforming-data.md) con. 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 è una matrice non vuota di Choice Rules, che contiene i seguenti campi quando si utilizza JSONata: + **`Condition`field**: un' JSONata espressione che restituisce vero/falso. + **`Next`field** — un valore che deve corrispondere al nome di uno stato nella macchina a stati. 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" } ``` ## 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 [RFC3339 profilo ISO 8601](https://www.ietf.org/rfc/rfc3339.txt), con ulteriori restrizioni: 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 («\$1») può essere eseguito con l'operatore di confronto. StringMatches Il carattere jolly viene eliminato utilizzando lo standard. `\\ (Ex: “\\*”)` Nessun carattere diverso da «\$1» ha un significato speciale durante la corrispondenza.