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á.

# Especificando a saída de estado usando ResultPath em Step Functions
<a name="input-output-resultpath"></a>

**Gerenciar estados e transformar dados**  
Esta página se refere JSONPath a. Recentemente, o Step Functions adicionou variáveis JSONata para gerenciar dados de estado e transformação.  
Saiba mais sobre como [transmitir dados com variáveis](workflow-variables.md) e [transformar dados com JSONata](transforming-data.md).

A saída de um estado pode ser uma cópia de sua entrada, o resultado que ele produz (por exemplo, a saída da função do Lambda de um estado `Task`) ou uma combinação da entrada e do resultado. Use `ResultPath` para controlar qual combinação desses itens são passadas para o estado de saída. 

Os seguintes tipos de estado podem gerar um resultado e podem incluir `ResultPath:`
+ [Estado de passagem do fluxo de trabalho](state-pass.md)
+ [Estado de tarefa do fluxo de trabalho](state-task.md)
+ [Estado paralelo do fluxo de trabalho](state-parallel.md)
+ [Estado de mapa do fluxo de trabalho](state-map.md)

Use `ResultPath` para combinar um resultado de tarefa com entrada de tarefa, ou para selecionar um desses. O caminho que você fornece para `ResultPath` controla quais informações passam para a saída. 

**nota**  
 `ResultPath` é limitado a usar [caminhos de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths), que limitam o escopo para que o caminho possa identificar somente um nó em JSON. Consulte [Caminhos de referência](amazon-states-language-paths.md#amazon-states-language-reference-paths) no [Linguagem de estados da Amazon](concepts-amazon-states-language.md).

## Use ResultPath para substituir a entrada pelo resultado da tarefa
<a name="input-output-resultpath-default"></a>

Se você não especificar um `ResultPath`, o comportamento padrão será o mesmo de `"ResultPath": "$"`. O estado substituirá toda a entrada do estado pelo resultado da tarefa.

```
# State Input
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions"
}

# Path 
"ResultPath": "$"

# Task result
"Hello, Step Functions!"

# State Output
"Hello, Step Functions!"
```

**nota**  
`ResultPath` é usado para incluir conteúdo do resultado com a entrada, antes de transmiti-lo para a saída. No entanto, se `ResultPath` não for especificado, a ação padrão será substituir a entrada completa.

## Descartar o resultado e manter a entrada original
<a name="input-output-resultpath-null"></a>

Se você definir `ResultPath` como `null`, o estado passará a **entrada original** para a saída. A carga útil de entrada do estado será copiada diretamente para a saída, sem considerar o resultado da tarefa. 

```
# State Input
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions"
}

# Path 
"ResultPath": null

# Task result
"Hello, Step Functions!"

# State Output
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions"
}
```

## Use ResultPath para incluir o resultado com a entrada
<a name="input-output-resultpath-append"></a>

Se você especificar um caminho para ResultPath, a saída do estado combinará a entrada do estado e o resultado da tarefa:

```
# State Input
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions"
}

# Path 
"ResultPath": "$.taskresult"

# Task result
"Hello, Step Functions!"

# State Output
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions",
 "taskresult" : "Hello, Step Functions!"
}
```

Você também pode inserir o resultado em um nó filho da entrada. Defina o `ResultPath` da seguinte forma.

```
"ResultPath": "$.strings.lambdaresult"
```

Considerando a seguinte entrada: 

```
{
  "comment": "An input comment.",
  "strings": {
    "string1": "foo",
    "string2": "bar",
    "string3": "baz"
  },
  "who": "AWS Step Functions"
}
```

O resultado da tarefa seria inserido como um adicionar do nó `strings` na entrada.

```
{
  "comment": "An input comment.",
  "strings": {
    "string1": "foo",
    "string2": "bar",
    "string3": "baz",
    "lambdaresult": "Hello, Step Functions!"
  },
  "who": "AWS Step Functions"
}
```

A saída de estado JSON agora inclui a entrada original com o resultado como um nó filho.

## Use ResultPath para atualizar um nó na entrada com o resultado
<a name="input-output-resultpath-amend"></a>

Se você especificar um nó existente para ResultPath, o resultado da tarefa substituirá esse nó existente:

```
# State Input
{  
 "comment": "This is a test",
 "details": "Default example",
 "who" : "Step Functions"
}

# Path 
"ResultPath": "$.comment"

# Task result
"Hello, Step Functions!"

# State Output
{  
 "comment": "Hello, Step Functions!",
 "details": "Default example",
 "who" : "Step Functions"
}
```

## Use ResultPath para incluir erro e entrada em um `Catch`
<a name="input-output-resultpath-catch"></a>

Em alguns casos, talvez você queira preservar a entrada original com o erro. Use `ResultPath` em um `Catch` para incluir o erro com a entrada original, em vez de substituí-lo. 

```
"Catch": [{ 
  "ErrorEquals": ["States.ALL"], 
  "Next": "NextTask", 
  "ResultPath": "$.error" 
}]
```

Se a declaração `Catch` anterior detectar um erro, ela incluirá o resultado em um nó `error` dentro da mesma entrada de estado. Por exemplo, com a seguinte entrada:

```
{"foo": "bar"}
```

A saída do estado ao detectar um erro é exibida a seguir.

```
{
  "foo": "bar",
  "error": {
    "Error": "{{Error here}}"
  }
}
```

Para obter mais informações sobre como tratar erros, consulte o seguinte:
+ [Tratar erros em fluxos de trabalho do Step Functions](concepts-error-handling.md)
+ [Tratar condições de erro em uma máquina de estado do Step Functions](tutorial-handling-error-conditions.md)