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á.
# Usar a Amazon States Language para definir fluxos de trabalho do Step Functions
A Amazon States Language é uma linguagem estruturada baseada em JSON que é usada para definir a máquina de estado, um conjunto de [estados](workflow-states.md), que podem realizar trabalhos (estados `Task`), determinar para quais estados fazer transição (estados `Choice`), interromper uma execução com erro (estados `Fail`) e assim por diante.
Para obter mais informações, consulte [Especificação da Amazon States Language](https://states-language.net/spec.html) e [Statelint](https://github.com/awslabs/statelint), uma ferramenta que valida o código da Amazon States Language.
Para criar uma máquina de estado no [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) usando a Amazon States Language, consulte [Conceitos básicos](getting-started.md).
**nota**
Se você definir as máquinas de estado fora do console do Step Functions, como em um editor de sua escolha, será necessário salvar as definições de máquina de estado com a extensão *.asl.json*.
## Exemplo de especificação de idioma dos estados da Amazon (JSONata)
```
{
"Comment": "An example of the Amazon States Language using a choice state.",
"QueryLanguage": "JSONata",
"StartAt": "FirstState",
"States": {
"FirstState": {
"Type": "Task",
"Assign": {
"foo" : "{% $states.input.foo_input %}"
},
"Resource": "arn:aws:lambda:region:123456789012:function:FUNCTION_NAME",
"Next": "ChoiceState"
},
"ChoiceState": {
"Type": "Choice",
"Default": "DefaultState",
"Choices": [
{
"Next": "FirstMatchState",
"Condition": "{% $foo = 1 %}"
},
{
"Next": "SecondMatchState",
"Condition": "{% $foo = 2 %}"
}
]
},
"FirstMatchState": {
"Type" : "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:OnFirstMatch",
"Next": "NextState"
},
"SecondMatchState": {
"Type" : "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:OnSecondMatch",
"Next": "NextState"
},
"DefaultState": {
"Type": "Fail",
"Error": "DefaultStateError",
"Cause": "No Matches!"
},
"NextState": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:FUNCTION_NAME",
"End": true
}
}
}
```
# Estrutura da máquina de estado na Amazon States Language para fluxos de trabalho do Step Functions
**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).
As máquinas de estado são definidas por meio de um texto JSON que representa uma estrutura que contém os campos a seguir.
** `Comment` (opcional)**
Uma descrição humanamente legível da máquina de estado.
** `QueryLanguage` (opcional; quando omitido, o padrão é `JSONPath`)**
+ O nome da linguagem de consulta usada pela máquina de estado. Os valores permitidos são `JSONPath` e `JSONata`.
+ Se não for fornecido para a máquina de estado, o valor padrão para cada estado será JSONPath.
+ Quando a linguagem de consulta da máquina de estado de nível superior é `JSONPath`, estados individuais podem substituir a linguagem de consulta definindo QueryLanguage como `JSONata`. Com essa abordagem, você pode converter de forma incremental uma máquina de estado de JSONPath para JSONata, um estado por vez.
+ **Observação: **não é possível reverter uma máquina de estado de nível superior baseada em JSONata para uma combinação de estados JSONata e JSONPath.
** `StartAt` (obrigatório)**
Uma string que deve corresponder exatamente (faz distinção de maiúsculas e minúsculas) ao nome de um dos objetos de estado.
** `TimeoutSeconds` (Opcional)**
O número máximo de segundos que uma execução da máquina de estado pode durar. Se a execução durar mais do que o tempo especificado, ela falhará com um `States.Timeout` [Nome de erro](concepts-error-handling.md#error-handling-error-representation).
** `Version` (opcional)**
A versão da Amazon States Language usada na máquina de estado (o padrão é "1.0").
** `States` (obrigatório)**
Um objeto que contém um conjunto de estados separados por vírgula.
O campo `States` contém [estados](workflow-states.md).
```
{
"State1" : {
},
"State2" : {
},
...
}
```
A máquina de estado é definida pelos estados que ela contém e pelos relacionamentos entre eles.
Veja um exemplo a seguir.
```
{
"Comment": "A Hello World example of the Amazon States Language using a Pass state",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Pass",
"Result": "Hello World!",
"End": true
}
}
}
```
Quando uma execução dessa máquina de estado é iniciada, o sistema começa com o estado mencionado no campo `StartAt` (`"HelloWorld"`). Se esse estado tiver um campo `"End": true`, a execução será interrompida e retornará um resultado. Do contrário, o sistema procurará um campo `"Next":` e passará para o estado seguinte. Esse processo é repetido até que o sistema alcance um estado final (um estado com `"Type": "Succeed"`, `"Type": "Fail"` ou `"End": true`) ou até que ocorra um erro de tempo de execução.
As regras a seguir aplicam-se a estados dentro de uma máquina de estado:
+ Os estados podem ocorrer em qualquer ordem dentro do bloco delimitador, mas a ordem na qual eles são listados não afeta a ordem na qual eles são executados. O conteúdo dos estados determina essa ordem.
+ Dentro de uma máquina de estado, pode haver somente um estado designado como estado `start`, que é indicado pelo valor do campo `StartAt` na estrutura de nível superior. Esse é o primeiro estado executado quando a execução se inicia.
+ Qualquer estado para o qual o campo `End` seja `true` é considerado um estado `end` (ou `terminal`). Dependendo da lógica da máquina de estado (por exemplo, se sua máquina de estado tiver várias ramificações de execução), você pode ter mais de um estado `end`.
+ Se sua máquina de estado tiver somente um estado, esse estado poderá ser `start` ou `end`.
## Campos de estado comuns em fluxos de trabalho
Os campos a seguir são comuns a todos os elementos do estado.
** `Type` (obrigatório)**
O tipo de estado: tarefa, escolha, paralelo, mapa, passagem, espera, sucesso, falha.
**`QueryLanguage` (opcional; quando omitido, o padrão é `JSONPath`)**
+ O nome da linguagem de consulta usada pelo estado. Os valores permitidos são `JSONPath` e `JSONata`.
+ Quando a linguagem de consulta da máquina de estado de nível superior é `JSONPath`, estados individuais podem substituir a linguagem de consulta definindo QueryLanguage como `JSONata`. Com essa abordagem, você pode converter de forma incremental uma máquina de estado de JSONPath para JSONata, um estado por vez.
** `Next` **
O nome do próximo estado que será executado quando o estado atual for concluído. Alguns tipos de estado, como `Choice`, permitem vários estados de transição.
Se o estado atual for o último estado no fluxo de trabalho ou um estado terminal, como [Estado de sucesso do fluxo de trabalho](state-succeed.md) ou [Estado de falha do fluxo de trabalho](state-fail.md), não será necessário especificar o campo `Next`.
** `End` **
Designa o estado como um estado terminal (encerra a execução) caso seja definido como `true`. Pode haver qualquer quantidade de estados finais por máquina de estado. Apenas um `Next` ou `End` pode ser usado em um estado. Alguns tipos de estado, como `Choice`, ou estados terminais, como [Estado de sucesso do fluxo de trabalho](state-succeed.md) e[Estado de falha do fluxo de trabalho](state-fail.md), não são compatíveis nem usam o campo `End`.
** `Comment` (opcional)**
Apresenta uma descrição humanamente legível da máquina de estado.
** `Assign` (opcional)**
Usado para armazenar variáveis. O campo `Assign` aceita um objeto JSON com pares de chave/valor que definem nomes de variáveis e seus valores atribuídos. Qualquer valor de string, incluindo aqueles em objetos ou matrizes, será avaliado como JSONata se estiver entre caracteres `{% %}`
Para obter mais informações, consulte [Transmitir dados entre estados com variáveis](workflow-variables.md).
** `Output` (opcional, somente JSONata)**
Usado para especificar e transformar a saída do estado. Quando especificado, o valor substitui o padrão de saída de estado.
O campo de saída aceita qualquer valor JSON (objeto, matriz, string, número, booleano, nulo). Qualquer valor de string, incluindo aqueles em objetos ou matrizes, será avaliado como JSONata se estiver entre caracteres \$1% %\$1.
A saída também aceita uma expressão JSONata direta, por exemplo: “Output”: “\$1% jsonata expression %\$1”
Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md).
** `InputPath` (opcional, somente JSONPath)**
Um [caminho](concepts-input-output-filtering.md) que seleciona uma parte da entrada do estado a ser passada para a tarefa do estado para processamento. Se omitido, terá o valor `$`, que designa a entrada completa. Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md).
** `OutputPath` (opcional, somente JSONPath)**
Um [caminho](concepts-input-output-filtering.md) que seleciona uma parte da saída do estado a ser transmitida para o próximo estado. Se omitido, terá o valor `$`, que designa a saída completa. Para obter mais informações, consulte [Processamento de entrada e saída](concepts-input-output-filtering.md).
# Funções intrínsecas para JSONPath estados em Step Functions
**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).
**Atenção**
As funções intrínsecas só estão disponíveis para estados que usam a linguagem de **JSONPath**consulta. Para JSONata, veja[Transformando dados com Step JSONata Functions](transforming-data.md).
A Amazon States Language fornece várias funções intrínsecas, também conhecidas como *intrínsecas*, para uso em campos que aceitam. JSONPath Com intrínsecas, é possível realizar operações básicas de processamento de dados sem usar um estado `Task`.
As intrínsecas se parecem com funções em linguagens de programação. Eles podem ser usados para ajudar os criadores de carga a processar os dados que entram e saem do `Resource` campo de um `Task` estado que usa a linguagem de JSONPath consulta.
Na Amazon States Language, as funções intrínsecas são agrupadas nas seguintes categorias, com base no tipo de tarefa de processamento de dados que você deseja realizar:
+ [Funções intrínsecas para matrizes](#asl-intrsc-func-arrays)
+ [Funções intrínsecas para codificação e decodificação de dados](#asl-intrsc-func-data-encode-decode)
+ [Função intrínseca para cálculo de hash](#asl-intrsc-func-hash-calc)
+ [função intrínseca para manipulação de dados JSON](#asl-intrsc-func-json-manipulate)
+ [Funções intrínsecas para operações matemáticas](#asl-intrsc-func-math-operation)
+ [Função intrínseca para operação de strings](#asl-intrsc-func-string-operation)
+ [Função intrínseca para geração de identificadores exclusivos](#asl-intrsc-func-uuid-generate)
+ [Função intrínseca para operação genérica](#asl-intrsc-func-generic)
Para usar funções intrínsecas, é necessário especificar `.$` no valor da chave nas definições da máquina de estado, conforme mostrado no seguinte exemplo:
```
"KeyId.$": "States.Array($.Id)"
```
Você pode agrupar até 10 funções intrínsecas em um campo em seus fluxos de trabalho. O seguinte exemplo mostra um campo chamado `myArn` que inclui nove funções intrínsecas aninhadas:
```
"myArn.$": "States.Format('{}.{}.{}', States.ArrayGetItem(States.StringSplit(States.ArrayGetItem(States.StringSplit($.ImageRecipe.Arn, '/'), 2), '.'), 0), States.ArrayGetItem(States.StringSplit(States.ArrayGetItem(States.StringSplit($.ImageRecipe.Arn, '/'), 2), '.'), 1))"
```
**QueryLanguage necessário para funções intrínsecas**
Para usar funções intrínsecas, a máquina de estado deve usar a linguagem de **JSONPathconsulta**.
Os estados que usam JSONata não podem usar funções intrínsecas; no entanto, JSONata e Step Functions fornecem opções equivalentes.
## Campos compatíveis com funções intrínsecas
Os seguintes estados comportam funções intrínsecas nestes campos:
+ **Estado de passagem**: parâmetros
+ **Estado da tarefa**: parâmetros ResultSelector, credenciais
+ **Estado paralelo**: parâmetros, ResultSelector
+ **Estado do mapa**: Parâmetros, ResultSelector
## Funções intrínsecas para matrizes
Use as funções intrínsecas a seguir para realizar manipulações de matriz.
**`States.Array`**
A função intrínseca `States.Array` aceita zero ou mais argumentos. O interpretador retorna uma matriz JSON que contém os valores dos argumentos na ordem fornecida. Por exemplo, dada a seguinte entrada:
```
{
"Id": 123456
}
```
Você poderia usar
```
"BuildId.$": "States.Array($.Id)"
```
Que retornaria o seguinte resultado:``
```
“BuildId”: [123456]
```
**`States.ArrayPartition`**
Use a função intrínseca `States.ArrayPartition` para particionar uma matriz grande. Você também pode usar essa função intrínseca para dividir os dados e, em seguida, enviar a carga em blocos menores.
Essa função intrínseca usa dois argumentos. O primeiro argumento é uma matriz, enquanto o segundo argumento define o tamanho do bloco. O interpretador divide a matriz de entrada em várias matrizes do tamanho especificado pelo tamanho do bloco. O comprimento do último bloco da matriz pode ser menor que o comprimento dos blocos anteriores se o número de itens restantes na matriz for menor que o tamanho do bloco.
**Validação de entrada**
+ Você deve especificar uma matriz como o valor de entrada para o primeiro argumento da função.
+ Você deve especificar um número inteiro positivo diferente de zero para o segundo argumento que representa o valor do tamanho do bloco.
Se você especificar um valor não inteiro para o segundo argumento, o Step Functions o arredondará para o número inteiro mais próximo.
+ A matriz de entrada não pode exceder o limite de tamanho de carga útil de 256 KiB do Step Functions.
Por exemplo, dada a seguinte matriz de entrada:
```
{"inputArray": [1,2,3,4,5,6,7,8,9] }
```
Você pode usar a função `States.ArrayPartition` para dividir a matriz em blocos de quatro valores:
```
"inputArray.$": "States.ArrayPartition($.inputArray,4)"
```
O que retornaria os seguintes blocos de matriz:
```
{"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }
```
No exemplo anterior, a função `States.ArrayPartition` gera três matrizes. Cada uma das duas primeiras matrizes contém quatro valores, conforme definido pelo tamanho do bloco. Uma terceira matriz contém o valor restante e é menor que o tamanho do bloco definido.
**`States.ArrayContains`**
Use a função intrínseca `States.ArrayContains` para determinar se um valor específico está presente em uma matriz. Por exemplo, você pode usar essa função para detectar se houve um erro em uma iteração do estado `Map`.
Essa função intrínseca usa dois argumentos. O primeiro argumento é uma matriz, enquanto o segundo argumento é o valor a ser pesquisado dentro da matriz.
**Validação de entrada**
+ Você deve especificar uma matriz como o valor de entrada para o primeiro argumento da função.
+ Você deve especificar um objeto JSON válido como segundo argumento.
+ A matriz de entrada não pode exceder o limite de tamanho de carga útil de 256 KiB do Step Functions.
Por exemplo, dada a seguinte matriz de entrada:
```
{
"inputArray": [1,2,3,4,5,6,7,8,9],
"lookingFor": 5
}
```
Você pode usar a função `States.ArrayContains` para encontrar o valor de `lookingFor` na `inputArray`:
```
"contains.$": "States.ArrayContains($.inputArray, $.lookingFor)"
```
Uma vez que o valor armazenado em `lookingFor` está incluído na `inputArray`, `States.ArrayContains` retorna o seguinte resultado:
```
{"contains": true }
```
**`States.ArrayRange`**
Use a função intrínseca `States.ArrayRange` para criar uma nova matriz contendo um intervalo específico de elementos. A nova matriz pode conter até mil elementos.
Essa função usa três argumentos. O primeiro argumento é o primeiro elemento da nova matriz, o segundo argumento é o elemento final da nova matriz e o terceiro argumento é o valor do incremento entre os elementos na nova matriz.
**Validação de entrada**
+ É necessário especificar valores inteiros para todos os argumentos.
Se você especificar um valor não inteiro para qualquer um dos argumentos, o Step Functions o arredondará para o número inteiro mais próximo.
+ É necessário especificar um valor diferente de zero para o terceiro argumento.
+ A matriz recém-gerada não pode conter mais de mil itens.
Por exemplo, o seguinte uso da função `States.ArrayRange` criará uma matriz com o primeiro valor de 1, um valor final de 9 e os valores entre o primeiro e o valor final aumentarão em dois para cada item:
```
"array.$": "States.ArrayRange(1, 9, 2)"
```
O que retornaria a seguinte matriz:
```
{"array": [1,3,5,7,9] }
```
**`States.ArrayGetItem`**
Essa função intrínseca retorna o valor de um índice especificado. Essa função usa dois argumentos. O primeiro argumento é uma matriz de valores e o segundo argumento é o índice da matriz do valor a ser retornado.
Por exemplo, use os seguintes valores de `inputArray` e `index`:
```
{
"inputArray": [1,2,3,4,5,6,7,8,9],
"index": 5
}
```
A partir desses valores, você pode usar a função `States.ArrayGetItem` para retornar o valor na posição 5 do `index` dentro da matriz:
```
"item.$": "States.ArrayGetItem($.inputArray, $.index)"
```
Neste exemplo, `States.ArrayGetItem` deverá retornar o seguinte resultado:
```
{ "item": 6 }
```
**`States.ArrayLength`**
A função intrínseca `States.ArrayLength` retorna o comprimento de uma matriz. Ela tem um argumento: a matriz cujo comprimento deverá ser retornado.
Por exemplo, dada a seguinte matriz de entrada:
```
{
"inputArray": [1,2,3,4,5,6,7,8,9]
}
```
Você pode usar `States.ArrayLength` para retornar o comprimento da `inputArray`:
```
"length.$": "States.ArrayLength($.inputArray)"
```
Neste exemplo, `States.ArrayLength` deverá retornar o seguinte objeto JSON que representa o comprimento da matriz:
```
{ "length": 9 }
```
**`States.ArrayUnique`**
A função intrínseca `States.ArrayUnique` remove valores duplicados de uma matriz e retorna uma matriz contendo somente elementos exclusivos. Essa função usa uma matriz, que pode ser desclassificada, como seu único argumento.
Por exemplo, a seguinte `inputArray` contém uma série de valores duplicados:
```
{"inputArray": [1,2,3,3,3,3,3,3,4] }
```
Você pode usar a função `States.ArrayUnique` e especificar a matriz da qual deseja remover valores duplicados:
```
"array.$": "States.ArrayUnique($.inputArray)"
```
A função `States.ArrayUnique` retornaria a seguinte matriz contendo somente elementos exclusivos, removendo todos os valores duplicados:
```
{"array": [1,2,3,4] }
```
## Funções intrínsecas para codificação e decodificação de dados
Use as funções intrínsecas a seguir para codificar ou decodificar dados com base no esquema de codificação Base64.
**`States.Base64Encode`**
Use a função intrínseca `States.Base64Encode` para codificar dados com base no esquema de codificação MIME Base64. Você pode usar essa função para passar dados para outros AWS serviços sem usar uma AWS Lambda função.
Essa função usa uma sequência de dados de até 10 mil caracteres para codificar como seu único argumento.
Por exemplo, considere a seguinte string de `input`:
```
{"input": "Data to encode" }
```
Você pode usar a função `States.Base64Encode` para codificar a string de `input` como uma string MIME Base64:
```
"base64.$": "States.Base64Encode($.input)"
```
A função `States.Base64Encode` retorna os seguintes dados codificados como resposta:
```
{"base64": "RGF0YSB0byBlbmNvZGU=" }
```
**`States.Base64Decode`**
Use a função intrínseca `States.Base64Decode` para decodificar dados com base no esquema de decodificação MIME Base64. Você pode usar essa função para passar dados para outros AWS serviços sem usar uma função Lambda.
Essa função usa uma sequência de dados codificados com Base64 de até 10 mil caracteres para decodificar como seu único argumento.
Por exemplo, dada a seguinte entrada:
```
{"base64": "RGF0YSB0byBlbmNvZGU=" }
```
Você pode usar a função `States.Base64Decode` para decodificar a string base64 em uma string legível:
```
"data.$": "States.Base64Decode($.base64)"
```
A `States.Base64Decode function` retornaria os seguintes dados decodificados em resposta:
```
{"data": "Decoded data" }
```
## Função intrínseca para cálculo de hash
**`States.Hash`**
Use a função intrínseca `States.Hash` para calcular o valor de hash de uma determinada entrada. Você pode usar essa função para transmitir dados para outros serviços da AWS sem usar uma função do Lambda.
Essa função usa dois argumentos. O primeiro argumento são os dados dos quais você deseja calcular o valor de hash. O segundo argumento é o algoritmo de hash a ser usado para realizar o cálculo de hash. Os dados fornecidos devem ser uma sequência de objetos contendo 10 mil caracteres ou menos.
O algoritmo de hash especificado pode ser qualquer um dos seguintes algoritmos:
+ `MD5`
+ `SHA-1`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
Por exemplo, você pode usar essa função para calcular o valor de hash da string `Data` usando o `Algorithm` especificado:
```
{
"Data": "input data",
"Algorithm": "SHA-1"
}
```
Você pode usar a função `States.Hash` para calcular o valor do hash:
```
"output.$": "States.Hash($.Data, $.Algorithm)"
```
A função do `States.Hash` retorna o seguinte valor de hash em resposta:
```
{"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }
```
## função intrínseca para manipulação de dados JSON
Use essas funções para realizar operações básicas de processamento de dados em objetos JSON.
**`States.JsonMerge`**
Use a função intrínseca `States.JsonMerge` para mesclar dois objetos JSON em um único objeto. Essa função usa três argumentos. Os dois primeiros argumentos são os objetos JSON que você deseja mesclar. O terceiro argumento é um valor booleano de `false`. Esse valor booleano determina se o modo de mesclagem profunda está ativado.
Atualmente, o Step Functions é compatível apenas com o modo de mesclagem superficial; portanto, você deve especificar o valor booleano como `false`. No modo superficial, se a mesma chave existir nos dois objetos JSON, a chave do último objeto substituirá a mesma chave no primeiro objeto. Além disso, objetos aninhados em um objeto JSON não são mesclados ao usar a mesclagem superficial.
Por exemplo, você pode usar a função `States.JsonMerge` para mesclar os seguintes objetos JSON que compartilham a chave `a`.
```
{
"json1": { "a": {"a1": 1, "a2": 2}, "b": 2 },
"json2": { "a": {"a3": 1, "a4": 2}, "c": 3 }
}
```
Você pode especificar os objetos json1 e json2 como entradas na função `States.JsonMerge` para mesclá-los:
```
"output.$": "States.JsonMerge($.json1, $.json2, false)"
```
Como resultado, `States.JsonMerge` retorna o seguinte objeto JSON mesclado. Na `output` do objeto JSON mesclado, a chave `a` do objeto `json2` substitui a chave `a` do objeto `json1`. Além disso, o objeto aninhado na chave `a` do objeto `json1` é descartado porque o modo superficial não é compatível com mesclagem de objetos aninhados.
```
{
"output": {
"a": {"a3": 1, "a4": 2},
"b": 2,
"c": 3
}
}
```
** `States.StringToJson` **
A função `States.StringToJson` usa um caminho de referência para uma string JSON com escape como seu único argumento.
O interpretador aplica um analisador JSON e retorna o formulário JSON analisado da entrada. Por exemplo, você pode usar essa função para efetuar o escape da seguinte string de entrada:
```
{
"escapedJsonString": "{\"foo\": \"bar\"}"
}
```
Use a função `States.StringToJson` e especifique a `escapedJsonString` como argumento de entrada:
```
States.StringToJson($.escapedJsonString)
```
A função `States.StringToJson` retorna o seguinte resultado:
```
{ "foo": "bar" }
```
** `States.JsonToString` **
A função `States.JsonToString` usa apenas um argumento, que é o caminho que contém os dados JSON a serem exibidos como uma string sem escape. O interpretador retorna uma string que contém texto JSON representando os dados especificados pelo caminho. Por exemplo, você pode fornecer o seguinte caminho JSON contendo um valor de escape:
```
{
"unescapedJson": {
"foo": "bar"
}
}
```
Forneça à função `States.JsonToString` os dados contidos em `unescapedJson`:
```
States.JsonToString($.unescapedJson)
```
A função `States.JsonToString` retorna a seguinte resposta:
```
{\"foo\": \"bar\"}
```
## Funções intrínsecas para operações matemáticas
Use essas funções para realizar operações matemáticas.
**`States.MathRandom`**
Use a função intrínseca `States.MathRandom` para retornar um número aleatório entre o número inicial especificado (inclusivo) e o número final (exclusivo).
Você pode usar essa função para distribuir uma tarefa específica entre dois ou mais recursos.
Essa função usa três argumentos. O primeiro argumento é o número inicial, o segundo é o número final e o último controla o valor inicial opcional. Observe que, se você usar essa função com o mesmo valor inicial, ela exibirá números idênticos.
Como a função `States.MathRandom` não exibe números aleatórios com criptografia segura, recomendamos não usá-la para aplicações com informações confidenciais.
**Validação de entrada**
+ É necessário especificar valores inteiros para os argumentos do número inicial e do número final.
Se você especificar um valor não inteiro para o argumento do número inicial ou final, o Step Functions o arredondará para o número inteiro mais próximo.
Por exemplo, para gerar um número aleatório entre um e 999, você pode usar os seguintes valores de entrada:
```
{
"start": 1,
"end": 999
}
```
Para gerar o número aleatório, forneça os valores `start` e `end` para a função `States.MathRandom`:
```
"random.$": "States.MathRandom($.start, $.end)"
```
A função `States.MathRandom` retorna o seguinte número aleatório como resposta:
```
{"random": 456 }
```
**`States.MathAdd`**
Use a função intrínseca `States.MathAdd` para retornar a soma de dois números. Por exemplo, você pode usar essa função para incrementar valores dentro de um loop sem invocar uma função do Lambda.
**Validação de entrada**
+ É necessário especificar valores inteiros para todos os argumentos.
Se você especificar um valor não inteiro para um ou ambos os argumentos, o Step Functions o arredondará para o número inteiro mais próximo.
+ É necessário especificar valores inteiros no intervalo de -2147483648 e 2147483647.
Por exemplo, você pode usar os seguintes valores para subtrair um de 111:
```
{
"value1": 111,
"step": -1
}
```
Em seguida, usar a função `States.MathAdd` definindo `value1` como o valor inicial e `step` como o valor de aumento do `value1`:
```
"value1.$": "States.MathAdd($.value1, $.step)"
```
A função `States.MathAdd` retornaria o seguinte número como resposta:
```
{"value1": 110 }
```
## Função intrínseca para operação de strings
**`States.StringSplit`**
Use a função intrínseca `States.StringSplit` para dividir uma string em uma matriz de valores. Essa função usa dois argumentos. O primeiro argumento é uma string e o segundo argumento é o caractere delimitador que a função usará para dividir a string.
**Example - Divida uma string de entrada usando um único caractere delimitador**
Neste exemplo, use `States.StringSplit` para dividir a seguinte `inputString`, que contém uma série de valores separados por vírgula:
```
{
"inputString": "1,2,3,4,5",
"splitter": ","
}
```
Use a função `States.StringSplit` e defina `inputString` como o primeiro argumento e o caractere delimitador `splitter` como o segundo argumento:
```
"array.$": "States.StringSplit($.inputString, $.splitter)"
```
A função `States.StringSplit` retorna a seguinte matriz de string como resultado:
```
{"array": ["1","2","3","4","5"] }
```
**Example - Divida uma string de entrada usando vários caracteres delimitadores**
Neste exemplo, use `States.StringSplit` para dividir a seguinte `inputString`, que contém vários caracteres delimitadores:
```
{
"inputString": "This.is+a,test=string",
"splitter": ".+,="
}
```
Use a função `States.StringSplit` da seguinte forma:
```
{
"myStringArray.$": "States.StringSplit($.inputString, $.splitter)"
}
```
A função `States.StringSplit` retorna a seguinte matriz de string como resultado:
```
{"myStringArray": [
"This",
"is",
"a",
"test",
"string"
]}
```
## Função intrínseca para geração de identificadores exclusivos
**`States.UUID`**
Use a função intrínseca `States.UUID` para retornar um identificador exclusivo universal da versão 4 (UUID v4) gerado usando números aleatórios. Por exemplo, você pode usar essa função para chamar outros AWS serviços ou recursos que precisam de um parâmetro UUID ou inserir itens em uma tabela do DynamoDB.
A função `States.UUID` é chamada sem nenhum argumento especificado:
```
"uuid.$": "States.UUID()"
```
A função retorna um UUID gerado aleatoriamente, como no exemplo a seguir.
```
{"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" }
```
## Função intrínseca para operação genérica
**`States.Format`**
Use a função intrínseca `States.Format` para construir uma string a partir de valores literais e interpolados. Essa função usa um ou mais argumentos. O valor do primeiro argumento deve ser uma string e pode incluir zero ou mais instâncias da sequência de caracteres `{}`. É necessário que haja o mesmo número de argumentos restantes na invocação da função intrínseca que o número de ocorrências de `{}`. O interpretador retorna a string definida no primeiro argumento, com cada `{}` substituída pelo valor do argumento correspondente posicionalmente na invocação da função intrínseca.
Por exemplo, você pode usar as seguintes entradas do `name` de uma pessoa e uma frase `template` para inserir o nome dela:
```
{
"name": "Arnav",
"template": "Hello, my name is {}."
}
```
Use a função `States.Format` e especifique a string `template` e a string a ser inserida no lugar dos caracteres `{}`:
```
States.Format('Hello, my name is {}.', $.name)
```
or
```
States.Format($.template, $.name)
```
Com qualquer uma das entradas anteriores, a função `States.Format` retorna a string completa como resposta:
```
Hello, my name is Arnav.
```
## Caracteres reservados em funções intrínsecas
Os caracteres a seguir são reservados para funções intrínsecas e seu escape deve ser efetuado com uma barra invertida ('\$1') se você quiser que eles apareçam no Valor: '\$1\$1 e \$1.
Se o caractere `\` precisar aparecer como parte do valor sem servir como um caractere de escape, você deverá efetuar o escape dele com uma barra invertida. As seguintes sequências de caracteres com escape são usadas com funções intrínsecas:
+ A string literal `\'` representa `'`.
+ A string literal `\{` representa `{`.
+ A string literal `\}` representa `}`.
+ A string literal `\\` representa `\`.
Em JSON, o escape de barras invertidas contidas em um valor literal de string deve ser efetuado com outra barra invertida. A lista equivalente para JSON é:
+ A string de escape `\\\'` representa `\'`.
+ A string de escape `\\\{` representa `\{`.
+ A string de escape `\\\}` representa `\}`.
+ A string de escape `\\\\` representa `\\`.
**nota**
Se uma barra invertida de escape aberta `\` for encontrada na string de invocação da função intrínseca, o interpretador retornará um erro de runtime.
[Você deve usar a notação de colchetes para um **caminho** passado como argumento para uma função intrínseca se o nome do campo contiver algum caractere que não esteja incluído na `member-name-shorthand` definição da regra ABNF. JsonPath ](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf) Além disso, se o **caminho** contiver caracteres não alfanuméricos, além de `_`, você deverá usar a notação de colchetes. Por exemplo, .`$.abc.['def ghi']`