Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Spécification de la sortie d'état à l'aide ResultPath de in Step Functions
**Gestion de l'état et transformation des données**
Cette page fait référence à JSONPath. Step Functions a récemment ajouté des variables et JSONata permet de gérer l'état et de transformer les données.
Découvrez comment [transmettre des données avec des variables](workflow-variables.md) et [transformer des données avec JSONata](transforming-data.md).
La sortie d'un état peut être une copie de son entrée, le résultat qu'il génère (par exemple, la sortie d'une fonction Lambda pour l'état d'une `Task`) ou une combinaison de l'entrée et du résultat. Utilisez `ResultPath` pour contrôler les combinaisons de ces stratégies transmises à la sortie de l'état.
Les types d'état suivants peuvent générer un résultat et peuvent inclure `ResultPath:`
+ [Passer l'état du flux de travail](state-pass.md)
+ [État du flux de travail des tâches](state-task.md)
+ [État du flux de travail parallèle](state-parallel.md)
+ [État du flux de travail cartographique](state-map.md)
Utilisez `ResultPath` pour combiner un résultat de tâche avec une entrée de tâche ou pour sélectionner l'une de ces règles. Le chemin que vous fournissez à `ResultPath` détermine quelles informations sont transmises à la sortie.
**Note**
`ResultPath`est limité à l'utilisation de [chemins de référence](amazon-states-language-paths.md#amazon-states-language-reference-paths), qui limitent la portée, de sorte que le chemin ne doit identifier qu'un seul nœud en JSON. Voir [Chemins de référence](amazon-states-language-paths.md#amazon-states-language-reference-paths) dans le document [Langage des états d'Amazon](concepts-amazon-states-language.md).
## ResultPath À utiliser pour remplacer l'entrée par le résultat de la tâche
Si vous ne spécifiez pas a`ResultPath`, le comportement par défaut est le même que`"ResultPath": "$"`. L'état remplacera l'intégralité de l'entrée d'état par le résultat de la tâche.
```
# 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!"
```
**Note**
`ResultPath` est utilisé pour inclure du contenu issu du résultat avec les données d'entrée, avant de les transmettre à la sortie. Mais, si `ResultPath` ce n'est pas spécifié, l'action par défaut consiste à remplacer l'intégralité de l'entrée.
## Ignorer le résultat et conserver l'entrée d'origine
Si vous réglez `ResultPath` sur`null`, l'état transmettra l'**entrée d'origine** à la sortie. La charge utile d'entrée de l'état sera copiée directement sur la sortie, sans tenir compte du résultat de la tâche.
```
# 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"
}
```
## ResultPath À utiliser pour inclure le résultat dans l'entrée
Si vous spécifiez un chemin pour ResultPath, la sortie d'état combinera l'entrée d'état et le résultat de la tâche :
```
# 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!"
}
```
Vous pouvez également insérer le résultat dans un nœud enfant de l'entrée. Définissez `ResultPath` comme suit.
```
"ResultPath": "$.strings.lambdaresult"
```
Compte tenu des informations suivantes :
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz"
},
"who": "AWS Step Functions"
}
```
Le résultat de la tâche serait inséré en tant qu'enfant du `strings` nœud dans l'entrée.
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz",
"lambdaresult": "Hello, Step Functions!"
},
"who": "AWS Step Functions"
}
```
La sortie de l'état inclut désormais le JSON d'entrée d'origine avec le résultat sous forme d'un nœud enfant.
## ResultPath À utiliser pour mettre à jour un nœud dans l'entrée avec le résultat
Si vous spécifiez un nœud existant pour ResultPath, le résultat de la tâche remplacera ce nœud existant :
```
# 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"
}
```
## ResultPath À utiliser pour inclure à la fois une erreur et une entrée dans un `Catch`
Dans certains cas, il se peut que vous souhaitiez conserver l'entrée d'origine avec l'erreur. Utilisez `ResultPath` dans un champ `Catch` pour inclure l'erreur avec l'entrée d'origine, au lieu de la remplacer :
```
"Catch": [{
"ErrorEquals": ["States.ALL"],
"Next": "NextTask",
"ResultPath": "$.error"
}]
```
Si l'instruction `Catch` précédente intercepte une erreur, elle inclut le résultat dans un nœud `error` avec l'entrée d'état. Par exemple, pour l'entrée suivante :
```
{"foo": "bar"}
```
La sortie de l'état lors de l'interception de l'erreur est :
```
{
"foo": "bar",
"error": {
"Error": "{{Error here}}"
}
}
```
Pour plus d'informations sur la gestion des erreurs, voir :
+ [Gestion des erreurs dans les flux de travail Step Functions](concepts-error-handling.md)
+ [Gestion des conditions d'erreur dans une machine à états Step Functions](tutorial-handling-error-conditions.md)