As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Estado de escolha do fluxo de trabalho
**Gerenciar estados e transformar dados**
Saiba mais sobre como [transmitir dados entre estados com variáveis](workflow-variables.md) e [transformar dados com JSONata](transforming-data.md).
Um estado `Choice` (`"Type": "Choice"`) adiciona a lógica condicional a uma máquina de estado.
Além da maioria dos [campos de estado comuns](statemachine-structure.md#amazon-states-language-common-fields), os estados `Choice` contêm os campos adicionais a seguir.
**`Choices` (obrigatório)**
Um conjunto [Choice Rules](#state-choice-rules) que determina para qual estado seguinte a máquina de estado deve mudar. É necessário definir pelo menos uma regra no estado `Choice`.
Quando um estado `Choice` é executado, o Step Functions avalia cada **Regra de escolha** como true ou false. Com base no resultado, o Step Functions muda para o próximo estado no fluxo de trabalho.
**`Default` (Opcional, Recomendado)**
O nome do estado para o qual fazer a transição caso nenhuma **Regra de escolha** seja avaliada como true.
**Importante**
Os estados `Choice` não comportam o campo `End`. Além disso, eles usam `Next` somente dentro do campo `Choices`.
Se nenhuma **escolha** for avaliada como true na execução do fluxo de trabalho e não houver um **padrão** fornecido, a máquina de estado emitirá um **erro** devido a uma *falha na transição de estado*.
## Regras de escolha (JSONata)
Um estado `Choice` deve ter um campo `Choices` cujo valor seja uma matriz não vazia de Regras de escolha, que contenha os seguintes campos ao usar JSONata:
+ **Campo `Condition`**: uma expressão JSONata avaliada como true/false.
+ **Campo `Next`**: um valor que deve corresponder a um nome de estado na máquina de estado.
O exemplo a seguir verifica se o valor numérico é igual a `1`.
```
{
"Condition": "{% $foo = 1 %}",
"Next": "NumericMatchState"
}
```
O exemplo a seguir verifica se a variável `type` é igual a `local`.
```
{
"Condition": "{% $type = 'local' %}",
"Next": "StringMatchState"
}
```
O exemplo a seguir verifica se a string é maior que `MyStringABC`.
```
{
"Condition": "{% $foo > 'MyStringABC' %}",
"Next": "StringGreaterMatchState"
}
```
O exemplo a seguir verifica se a string não é nula.
```
{
"Condition" : "{% $possiblyNullValue != null and $possiblyNullValue = 42 %}",
"Next": "NotNullAnd42"
}
```
## Regras de escolha (JSONPath)
Um estado `Choice` deve ter um campo `Choices` cujo valor seja uma matriz não vazia de Regras de escolha, que contenha os seguintes campos ao usar JSONPath:
+ Uma **comparação**: dois campos que especificam uma variável de entrada para comparação, o tipo de comparação e o valor a ser comparado com a variável. As Regras de escolha permitem a comparação entre duas variáveis. Dentro de uma Regra de escolha, o valor da variável pode ser comparado com outro valor da entrada de estado anexando `Path` ao nome dos operadores de comparação compatíveis. Os valores dos campos `Variable` e Caminho em uma comparação devem ser [caminhos de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths) válidos.
+ Um **campo `Next`**: o valor desse campo deve corresponder a um nome de estado na máquina de estado.
O exemplo a seguir verifica se o valor numérico é igual a `1`.
```
{
"Variable": "$.foo",
"NumericEquals": 1,
"Next": "FirstMatchState"
}
```
O exemplo a seguir verifica se a string é igual a `MyString`.
```
{
"Variable": "$.foo",
"StringEquals": "MyString",
"Next": "FirstMatchState"
}
```
O exemplo a seguir verifica se a string é maior que `MyStringABC`.
```
{
"Variable": "$.foo",
"StringGreaterThan": "MyStringABC",
"Next": "FirstMatchState"
}
```
O exemplo a seguir verifica se a string é nula.
```
{
"Variable": "$.possiblyNullValue",
"IsNull": true
}
```
O exemplo a seguir mostra como a regra StringEquals só é avaliada quando `$.keyThatMightNotExist` existe devido à Regra de escolha `IsPresent` anterior.
```
"And": [
{
"Variable": "$.keyThatMightNotExist",
"IsPresent": true
},
{
"Variable": "$.keyThatMightNotExist",
"StringEquals": "foo"
}
]
```
O exemplo a seguir verifica se um padrão com um caractere curinga corresponde.
```
{
"Variable": "$.foo",
"StringMatches": "log-*.txt"
}
```
O exemplo a seguir verifica se o timestamp é igual a `2001-01-01T12:00:00Z`.
```
{
"Variable": "$.foo",
"TimestampEquals": "2001-01-01T12:00:00Z",
"Next": "FirstMatchState"
}
```
O exemplo a seguir compara uma variável com outro valor da entrada de estado.
```
{
"Variable": "$.foo",
"StringEqualsPath": "$.bar"
}
```
O Step Functions examina cada uma das Regra de escolha na ordem listada no campo `Choices`. Depois disso, ele faz a transição para o estado especificado no campo `Next` do primeiro Choice Rule em que a variável corresponde ao valor, de acordo com o operador de comparação.
Os operadores de comparação a seguir são comportados:
+ `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`
Para cada um desses operadores, o valor correspondente deve ser do tipo apropriado: string, número, booliano ou time stamp. O Step Functions não tenta equiparar um campo numérico com um valor de string. No entanto, como os campos de timestamp são logicamente strings, é possível que um campo considerado um timestamp corresponda a um comparador `StringEquals`.
**nota**
Por motivo de interoperabilidade, não presuma que as comparações numéricas funcionarão com valores fora da magnitude ou precisão que o [tipo de dado `binary64` de IEEE 754-2008](https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats) representa. Mais especificamente, é provável que os inteiros fora do intervalo `[-253+1, 253-1]` não sejam comparados da forma esperada.
Os time stamps (por exemplo, `2016-08-18T17:33:00Z`) devem estar de acordo com o [perfil RFC3339 da ISO 8601](https://www.ietf.org/rfc/rfc3339.txt) e apresentar outras restrições:
Um `T` maiúsculo deve separar as partes de data e hora.
Um `Z` maiúsculo deve indicar que não existe uma compensação de fuso horário numérica.
Para entender o comportamento das comparações de strings, consulte a documentação do [Java`compareTo`](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String-).
Os valores dos operadores `And` e `Or` devem ser matrizes não vazias de Choice Rules que em si não devem conter campos `Next`. Da mesma forma, o valor de um operador `Not` deve ser um Choice Rule único que não deve conter campos `Next`.
Você pode criar Choice Rules complexos e aninhados usando `And`, `Not` e `Or`. No entanto, o campo `Next` pode ser exibido somente em um Choice Rule de nível superior.
A comparação de strings com padrões com um ou mais curingas (“\*”) pode ser realizada com o operador de comparação StringMatches. O escape do caractere curinga é efetuado usando o padrão `\\ (Ex: “\\*”)`. Nenhum caractere além de “\*” tem qualquer significado especial durante a correspondência.