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à.
# Esempio: manipolazione dei dati di stato con percorsi nei flussi di lavoro Step Functions
**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
Questo argomento contiene esempi di come manipolare l'input e l'output dello stato JSON utilizzando i campi InputPath ResultPath, e. OutputPath
Qualsiasi stato diverso da uno [Stato del flusso di lavoro fallito](state-fail.md) stato o da uno [Stato del flusso di lavoro Success](state-succeed.md) stato può includere i campi di elaborazione di input e output, ad esempio `InputPath``ResultPath`, o. `OutputPath` Inoltre, gli [Stato del flusso di lavoro di scelta](state-choice.md) stati [Attendi lo stato del workflow](state-wait.md) and non supportano il `ResultPath` campo. Con questi campi, puoi utilizzare [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)a per filtrare i dati JSON man mano che si spostano nel flusso di lavoro.
Puoi anche utilizzare il `Parameters` campo per manipolare i dati JSON mentre si spostano nel flusso di lavoro. Per ulteriori informazioni sull'uso di `Parameters`, consultare [Manipolazione dei parametri nei flussi di lavoro di Step Functions](input-output-inputpath-params.md).
Ad esempio, iniziate con la AWS Lambda funzione e la macchina a stati descritte nel [Creazione di una macchina a stati Step Functions che utilizza Lambda](tutorial-creating-lambda-state-machine.md) tutorial. Modifica la macchina a stati affinché includa i seguenti `InputPath`, `ResultPath` e `OutputPath`.
```
{
"Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:HelloFunction",
"InputPath": "$.lambda",
"ResultPath": "$.data.lambdaresult",
"OutputPath": "$.data",
"End": true
}
}
}
```
Avvia un'esecuzione utilizzando i seguenti input.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Si supponga che i `extra` nodi `comment` and possano essere scartati, ma che si desideri includere l'output della funzione Lambda e conservare le informazioni nel nodo. `data`
Nella macchina a stati aggiornata, lo stato `Task` viene modificato in modo da elaborare l'input al task.
```
"InputPath": "$.lambda",
```
Questa riga nella definizione della macchina a stati limita l'input del task al nodo `lambda` dall'input dello stato. La funzione Lambda riceve solo l'oggetto `{"who": "AWS Step Functions"}` JSON come input.
```
"ResultPath": "$.data.lambdaresult",
```
Questo `ResultPath` dice alla macchina a stati di inserire il risultato della funzione Lambda in un nodo denominato`lambdaresult`, come figlio del `data` nodo nell'input originale della macchina a stati. Poiché non state eseguendo altre manipolazioni sull'input originale e sul risultato utilizzato`OutputPath`, l'output dello stato ora include il risultato della funzione Lambda con l'input originale.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Tuttavia, il nostro obiettivo era preservare solo il `data` nodo e includere il risultato della funzione Lambda. `OutputPath`filtra questo JSON combinato prima di passarlo all'output di stato.
```
"OutputPath": "$.data",
```
Questo seleziona solo il nodo `data` dall'input originale (tra cui il figlio `lambdaresult` inserito da `ResultPath`) da trasmettere all'output. L'output dello stato viene filtrato come segue.
```
{
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
}
```
In questo stato `Task`:
1. `InputPath`invia solo il `lambda` nodo dall'input alla funzione Lambda.
1. `ResultPath` inserisce il risultato come figlio del nodo `data` nell'input originale.
1. `OutputPath`filtra l'input dello stato (che ora include il risultato della funzione Lambda) in modo che passi solo il `data` nodo all'output dello stato.
**Example per manipolare l'input, il risultato e l'output finale della macchina a stati originali utilizzando JsonPath**
Considerate la seguente macchina a stati che verifica l'identità e l'indirizzo di un richiedente di assicurazione.
Per visualizzare l'esempio completo, vedi [Come usare JSON Path in Step Functions](https://github.com/aws-samples/serverless-account-signup-service).
```
{
"Comment": "Sample state machine to verify an applicant's ID and address",
"StartAt": "Verify info",
"States": {
"Verify info": {
"Type": "Parallel",
"End": true,
"Branches": [
{
"StartAt": "Verify identity",
"States": {
"Verify identity": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-identity:$LATEST"
},
"End": true
}
}
},
{
"StartAt": "Verify address",
"States": {
"Verify address": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-address:$LATEST"
},
"End": true
}
}
}
]
}
}
}
```
Se si esegue questa macchina a stati utilizzando l'input seguente, l'esecuzione non riesce perché le funzioni Lambda che eseguono la verifica si aspettano solo i dati che devono essere verificati come input. Pertanto, è necessario specificare i nodi che contengono le informazioni da verificare utilizzando un codice appropriato JsonPath.
```
{
"data": {
"firstname": "Jane",
"lastname": "Doe",
"identity": {
"email": "jdoe@example.com",
"ssn": "123-45-6789"
},
"address": {
"street": "123 Main St",
"city": "Columbus",
"state": "OH",
"zip": "43219"
},
"interests": [
{
"category": "home",
"type": "own",
"yearBuilt": 2004
},
{
"category": "boat",
"type": "snowmobile",
"yearBuilt": 2020
},
{
"category": "auto",
"type": "RV",
"yearBuilt": 2015
},
]
}
}
```
Per specificare il nodo che la funzione `check-identity` Lambda deve utilizzare, usa il `InputPath` campo come segue:
```
"InputPath": "$.data.identity"
```
E per specificare il nodo che deve utilizzare la funzione `check-address` Lambda, usa il `InputPath` campo come segue:
```
"InputPath": "$.data.address"
```
Ora, se vuoi memorizzare il risultato della verifica all'interno dell'input originale della macchina a stati, usa il `ResultPath` campo come segue:
```
"ResultPath": "$.results"
```
Tuttavia, se ti servono solo i risultati dell'identità e della verifica e scarti l'input originale, utilizza il `OutputPath` campo come segue:
```
"OutputPath": "$.results"
```
Per ulteriori informazioni, consulta [Elaborazione di input e output in Step Functions](concepts-input-output-filtering.md).
## Filtraggio dell'output dello stato utilizzando OutputPath
Con `OutputPath` puoi selezionare una parte dell'output dello stato da passare allo stato successivo. Con questo approccio, puoi filtrare le informazioni indesiderate e passare solo la parte di JSON di cui hai bisogno.
Se non si specifica un `OutputPath`, il valore di default è `$`. Questo trasferisce l'intero nodo JSON (stabilito dallo stato dell’input, il risultato dell’attività e `ResultPath`) allo stato successivo.