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

# Passaggio di dati tra stati con variabili
<a name="workflow-variables"></a>

**Gestione dello stato con variabili e JSONata**  
Step Functions ha recentemente aggiunto variabili e JSONata per gestire lo stato e trasformare i dati.  
Scopri di più nel post sul blog [Semplificare l'esperienza degli sviluppatori con le variabili e JSONata ](https://aws.amazon.com/blogs/compute/simplifying-developer-experience-with-variables-and-jsonata-in-aws-step-functions/) in AWS Step Functions  
 Il video seguente descrive le variabili e JSONata in Step Functions con un esempio di DynamoDB:   




 Con le variabili e l'output dello stato, puoi passare i dati tra le fasi del flusso di lavoro. 

 Utilizzando le variabili del flusso di lavoro, puoi archiviare i dati in un passaggio e recuperarli nelle fasi future. Ad esempio, è possibile archiviare una risposta API che contiene dati che potrebbero essere necessari in un secondo momento. Al contrario, lo state output può essere utilizzato solo come input per la fase successiva. 

## Panoramica concettuale delle variabili
<a name="conceptual-overview-of-variables"></a>

 Con le variabili del flusso di lavoro, è possibile archiviare dati a cui fare riferimento in un secondo momento. Ad esempio, il passaggio 1 potrebbe memorizzare il risultato di una richiesta API in modo che una parte di tale richiesta possa essere riutilizzata in un secondo momento nel passaggio 5. 

 Nello scenario seguente, la macchina a stati recupera i dati da un'API una sola volta. Nel passaggio 1, il flusso di lavoro archivia i dati API restituiti (fino a 256 KB per stato) in una variabile 'x' da utilizzare nei passaggi successivi. 

 Senza variabili, è necessario passare i dati all'output dalla fase 1 alla fase 2, dalla fase 3 alla fase 4 per utilizzarli nella fase 5. E se questi passaggi intermedi non richiedessero i dati? Il passaggio dei dati da uno stato all'altro tramite output e input sarebbe uno sforzo inutile. 

 Con le variabili, puoi archiviare i dati e utilizzarli in qualsiasi fase futura. Puoi anche modificare, riorganizzare o aggiungere passaggi senza interrompere il flusso dei dati. Data la flessibilità delle variabili, potrebbe essere necessario utilizzare **Output** solo per restituire i dati dai flussi di lavoro secondari Parallel e Map e al termine dell'esecuzione della macchina a stati. 

 ![\[Diagram showing step 1 assigning a value to $x, used in step 5.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/vars-diag-opt1.png)

 **Stati che supportano le variabili**

 I seguenti tipi di stato supportano `Assign` la dichiarazione e l'assegnazione di valori alle variabili: *Pass, Task, Map, Parallel, Choice, Wait*.

 Per impostare una variabile, fornisci a un oggetto JSON nomi e valori delle variabili: 

```
"Assign": {
  "productName": "product1",
  "count" : 42,
  "available" : true
}
```

 Per fare riferimento a una variabile, anteponete al nome il simbolo del dollaro (`$`), ad esempio. `$productName` 

## Variabile riservata: \$1states
<a name="reserved-variable-states"></a>

 Step Functions definisce una singola variabile riservata chiamata **`$states`**. Negli JSONata stati, le seguenti strutture vengono assegnate `$states` per essere utilizzate nelle JSONata espressioni: 

```
# Reserved $states variable in JSONata states
$states = {
  "input":       // Original input to the state
  "result":      // API or sub-workflow's result (if successful)
  "errorOutput": // Error Output (only available in a Catch)
  "context":     // Context object
}
```

 All'ingresso dello stato, Step Functions assegna l'input di stato a **`$states.input`**. Il valore di `$states.input` può essere utilizzato in tutti i campi che accettano JSONata espressioni. `$states.input`si riferisce sempre all'input di stato originale. 

 Per `Task``Parallel`, e `Map` afferma:
+ **`$states.result`**fa riferimento al risultato non elaborato dell'API o del flusso di lavoro secondario in caso di successo. 
+ **`$states.errorOutput`**fa riferimento all'Error Output se l'API o il sottoflusso di lavoro non sono riusciti.

  `$states.errorOutput`può essere utilizzato nel `Catch` campo `Assign` o`Output`. 

Il tentativo di accedere `$states.result` a campi e stati `$states.errorOutput` in cui non sono accessibili verrà interrotto al momento della creazione, dell'aggiornamento o della convalida della macchina a stati. 

L'`$states.context`oggetto fornisce ai flussi di lavoro informazioni sulla loro esecuzione specifica, ad esempio il token dell'attività e l'input iniziale del flusso di lavoro. `StartTime` Per ulteriori informazioni, consulta [Accesso ai dati di esecuzione dall'oggetto Context in Step Functions](input-output-contextobject.md).

## Sintassi del nome della variabile
<a name="variable-name-syntax"></a>

 I nomi delle variabili seguono le regole per gli identificatori Unicode come descritto nell'allegato \$131 dello standard [Unicode®](https://unicode.org/reports/tr31/). Il primo carattere del nome di una variabile deve essere un carattere Unicode ID\$1Start, mentre il secondo carattere e i successivi devono essere caratteri Unicode ID\$1Continue. La lunghezza massima del nome di una variabile è 80. 

 La convenzione sui nomi delle variabili è simile a Rules for JavaScript e ad altri linguaggi di programmazione. 

## Ambito variabile
<a name="variable-scope"></a>

 I flussi di lavoro Step Functions evitano le condizioni di gara con le variabili utilizzando un ambito locale del *flusso di lavoro*. 

L'ambito locale del flusso di lavoro include tutti gli stati all'interno del campo States di una macchina a stati, ma non **gli stati** all'interno degli stati Parallel o Map. Gli stati all'interno degli stati Parallel o Map possono fare riferimento a variabili di ambito esterno, ma creano e mantengono variabili e valori locali del flusso di lavoro separati.

`Parallel`i rami e `Map` le iterazioni possono accedere ai valori delle variabili da **ambiti esterni**, ma non hanno accesso ai valori variabili di altri rami o iterazioni concorrenti. Quando si gestiscono gli errori, il `Assign` campo in a `Catch` può assegnare valori alle variabili nell'ambito esterno, ovvero l'ambito in cui esiste lo stato. Parallel/Map 

 Eccezione: **gli stati della mappa distribuita** non possono attualmente fare riferimento a variabili negli ambiti esterni. 

 Una variabile esiste in un ambito se uno stato dell'ambito le assegna un valore. Per evitare errori comuni, una variabile assegnata in un ambito interno non può avere lo stesso nome di una variabile assegnata in un ambito esterno. Ad esempio, se l'ambito di primo livello assegna un valore a una variabile chiamata`myVariable`, nessun altro ambito (all'interno di un`Map`,`Parallel`) può assegnarlo anche a`myVariable`. 

 L'accesso alle variabili dipende dall'ambito corrente. Gli stati Parallel e Map hanno un proprio ambito, ma possono accedere alle variabili negli ambiti esterni. 

 Al termine di uno stato Parallel o Map, tutte le relative variabili non rientrano nell'ambito di applicazione e non sono più accessibili. Usa il **campo Output** per trasferire i dati dai rami paralleli e dalle iterazioni della mappa. 

## Assegna campo in ASL
<a name="assign-field-in-asl"></a>

 Il `Assign` campo in ASL viene utilizzato per assegnare valori a una o più variabili. Il `Assign` campo è disponibile al livello più alto di ogni stato (tranne `Succeed` e`Fail`), all'interno delle regole `Choice` dello stato e all'interno `Catch` dei campi. Per esempio: 

```
# Example of Assign with JSONata
"Store inputs": {
    "Type": "Pass",
    "Next": "Get Current Price",
    "Comment": "Store the input desired price into a variable: $desiredPrice",
    "Assign": {
       "desiredPrice": "{% $states.input.desired_price %}",
       "maximumWait": "{% $states.input.max_days %}"
    }
},
```

 Il `Assign` campo accetta un oggetto JSON. Ogni campo di primo livello nomina una variabile da assegnare. Negli esempi precedenti, i nomi delle variabili sono `desiredPrice` e. `maximumWait` Quando si utilizza JSONata, `{% ... %}` indica un' JSONata espressione che potrebbe contenere variabili o espressioni più complesse. Per ulteriori informazioni sulle JSONata espressioni, consulta la [JSONatadocumentazione.org](https://docs.jsonata.org/overview.html). 

 Quando si utilizza **JSONata**come linguaggio di interrogazione, il diagramma seguente mostra come i campi **Assign** e **Output** vengono elaborati in parallelo. Nota l'implicazione: l'*assegnazione di valori variabili non influirà* sull'output dello stato.

 ![\[Diagram showing a comparison of JSONPath and JSONata flow.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/vars-jsonata.png)

 L' JSONata esempio seguente recupera `order.product` dall'input dello stato. La variabile `currentPrice` viene impostata su un valore derivante dal risultato dell'attività. 

```
# Example of Task with JSONata assignment from result
{
   "Type": "Task",
   ...
   "Assign": {
      "product": "{% $states.input.order.product %}",
      "currentPrice": "{% $states.result.Payload.current_price %}"
   },
   "Next": "the next state"
}
```

 Nota: **non** è possibile assegnare un valore a una parte di una variabile. Ad esempio, puoi`"Assign":{"x":42}`, ma non puoi `"Assign":{"x.y":42}` o`"Assign":{"x[2]":42}`. 

## Ordine di valutazione in un campo di assegnazione
<a name="evaluation-order-in-an-assign-field"></a>

Tutti i riferimenti alle variabili negli stati di Step Functions utilizzano i valori così come erano all'**immissione dello stato**. 

Il fatto precedente è importante per capire come il `Assign` campo assegna valori a una o più variabili. Innanzitutto, vengono calcolati i nuovi valori, quindi Step Functions assegna i nuovi valori alle variabili. I nuovi valori delle variabili saranno disponibili a partire dallo stato **successivo**. Ad esempio, considera il seguente `Assign` campo: 

```
# Starting values: $x=3, $a=6

"Assign": {
  "x": "{% $a %}",
  "nextX": "{% $x %}"
}

# Ending values: $x=6, $nextX=3
```

Nell'esempio precedente, la variabile `x` è sia assegnata che referenziata. 

Ricorda che tutte le espressioni vengono ***prima valutate***, quindi vengono effettuate le assegnazioni. E i nuovi valori assegnati saranno disponibili nello stato **successivo**. 

Esaminiamo l'esempio in dettaglio. Supponiamo che in uno stato precedente sia `$x` stato assegnato un valore di tre (3) e che sia `$a` stato assegnato un valore di sei (6). I passaggi seguenti descrivono il processo:

1. Tutte le espressioni vengono valutate utilizzando i valori **correnti** di tutte le variabili.

   L'espressione `"{% $a %}"` verrà valutata fino a 6 e `"{% $x %}"` restituirà fino a 3.

1. Successivamente, vengono assegnati gli incarichi:

   `$x`verrà assegnato il valore sei (6) 

   `$nextX`ne verranno assegnati tre (3)

 Nota: se non `$x` fosse stato assegnato in precedenza, l'esempio **fallirebbe perché non `$x`** *sarebbe definito*. 

 In sintesi, Step Functions valuta **tutte le** espressioni e quindi esegue le assegnazioni. L'ordine in cui le variabili si presentano nel `Assign` campo **non** ha importanza. 

## Limiti
<a name="limits"></a>

 La dimensione massima di una singola variabile è 256 KiB, sia per i flussi di lavoro Standard che Express. 

 Anche la dimensione massima combinata per tutte le variabili in un singolo `Assign` campo è di 256 KiB. Ad esempio, è possibile assegnare X e Y a 128 KiB, ma non è possibile assegnare sia X che Y a 256 KiB nello stesso campo. `Assign` 

 La dimensione totale di tutte le variabili memorizzate non può superare i 10 MiB per esecuzione. 

## Utilizzo di variabili negli stati JSONPath
<a name="using-variables-in-jsonpath-states"></a>

 Le variabili sono disponibili anche negli stati che utilizzano come linguaggio JSONPath di interrogazione. 

 È possibile fare riferimento a una variabile in qualsiasi campo che accetta un' JSONpath espressione (`$.`o `$$.` sintassi), ad eccezione di`ResultPath`, che specifica una posizione nell'input dello stato in cui inserire il risultato dello stato. Le variabili non possono essere utilizzate in. `ResultPath` 

 In JSONPath, il `$` simbolo si riferisce al valore «corrente» e `$$` rappresenta l'oggetto Context dello stato. JSONPath le espressioni possono iniziare con `$.` as in`$.customer.name`. È possibile accedere al contesto con `$$.` as in`$$.Execution.Id`. 

 Per fare riferimento a una variabile, si utilizza anche il `$` simbolo prima del nome di una variabile, ad esempio `$x` o`$order.numItems`. 

 Nei ** JSONPath**campi che accettano funzioni intrinseche, le variabili possono essere utilizzate negli argomenti, ad esempio. `States.Format('The order number is {}', $order.number)` 

 Il diagramma seguente illustra come la fase di assegnazione di un'**JSONPath**attività avviene contemporaneamente a: ResultSelector 

 ![\[Logical diagram of a state that uses JSONPath query language.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/vars-jsonpath.png)

 **Assegnazione di variabili in JSONPath**

 JSONPath le assegnazioni delle variabili si comportano in modo simile ai modelli di payload. I campi che terminano con `.$` indicano che il valore è un' JSONPath espressione che Step Functions restituisce in un valore durante l'esecuzione della macchina a stati (ad esempio: `$.order..product` and`$.order.total`). 

```
# Example of Assign with JSONPath
{
  "Type": "Task",
  ...
  "Assign": {
    "products.$": "$.order..product",
    "orderTotal.$": "$.order.total"
  },
  "Next": "the next state"
}
```

 Per JSONPath gli stati, il valore di `$` in un `Assign` campo dipende dal tipo di stato. Negli `Parallel` stati `Task,``Map`, `$` si riferisce al risultato dell'API/Sub-Workflow. In `Choice` and `Wait` state, `$` si riferisce all'*input effettivo*, che è il valore dopo che è `InputPath` stato applicato all'input di stato. Per`Pass`, `$` si riferisce al risultato, indipendentemente dal fatto che sia generato dal `Result` campo o dai `Parameters` campi`InputPath`/. 

 L' JSONPath esempio seguente assegna un oggetto JSON alla `details` variabile, il risultato dell' JSONPath espressione `$.result.code` a `resultCode` e il risultato dell' JSONPath espressione `States.Format('Hello {}', $customer.name)` a. `message` Se si trovava in uno `Task` stato, allora `$` in `$.order.items` e `$.result.code` si riferisce al risultato dell'API. Alla `startTime` variabile viene assegnato un valore dall'oggetto Context,`$$.Execution.StartTime`. 

```
"Assign": {
   "details": {
      "status": "SUCCESS",
      "lineItems.$": "$.order.items"
   },
   "resultCode.$": "$.result.code",
   "message.$": "States.Format('Hello {}', $customer.name)",
   "startTime.$": "$$.Execution.StartTime"
}
```