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à. # Utilizzo di Amazon States Language per definire i flussi di lavoro Step Functions Amazon States Language è un linguaggio strutturato basato su JSON utilizzato per definire la tua macchina a stati, una raccolta di [stati](workflow-states.md), che può funzionare (`Task`stati), determinare a quali stati passare a quelli successivi (`Choice`stati), interrompere un'esecuzione con un errore (`Fail`stati) e così via. Per ulteriori informazioni, consulta la [Amazon States Language Specification (Specifica del linguaggio degli stati di Amazon)](https://states-language.net/spec.html) e [Statelint](https://github.com/awslabs/statelint), uno strumento che consente di convalidare il codice di Amazon States Language. Per creare una macchina a stati sulla [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) utilizzando Amazon States Language, consulta [Getting Started](getting-started.md). **Nota** Se definisci le tue macchine a stati al di fuori della console di Step Functions, ad esempio in un editor di tua scelta, devi salvare le definizioni delle tue macchine a stati con l'estensione *.asl.json*. ## Esempio di specifica del linguaggio Amazon States (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 } } } ``` # Struttura della macchina a stati nei flussi di lavoro di Amazon States Language for 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 Le macchine a stati vengono definite utilizzando testo JSON che rappresenta una struttura contenente i seguenti campi. ** `Comment` (facoltativo).** Una descrizione leggibile della macchina a stati. ** `QueryLanguage`(Facoltativo; se omesso, il valore predefinito è) `JSONPath`** + Il nome del linguaggio di interrogazione utilizzato dalla macchina a stati. I valori consentiti sono `JSONPath` e `JSONata`. + Se non viene fornito per la macchina a stati, il valore predefinito per ogni stato è JSONPath. + Quando il linguaggio di interrogazione della macchina a stati di primo livello è`JSONPath`, i singoli stati possono sovrascrivere il linguaggio di query QueryLanguage impostando su. `JSONata` Con questo approccio, è possibile convertire in modo incrementale una macchina a stati da JSONata uno stato JSONPath alla volta. + **Nota:** non è possibile ripristinare una macchina a stati JSONata basata su un livello superiore in una combinazione di JSONata stati and. JSONPath ** `StartAt` (Obbligatorio)** Una stringa che deve corrispondere esattamente (con distinzione tra maiuscole e minuscole) al nome di uno degli oggetti di stato. **`TimeoutSeconds`(Facoltativo)** Il numero massimo di secondi durante i quali può essere eseguita la macchina a stati. Se viene eseguita per un tempo superiore a quello specificato, l'esecuzione ha esito negativo con un `States.Timeout` [nome di errore](concepts-error-handling.md#error-handling-error-representation). ** `Version` (facoltativo).** La versione di Amazon States Language utilizzata nella macchina a stati (l'impostazione predefinita è «1.0"). ** `States` (Obbligatorio)** Un oggetto contenente un set di stati delimitati da virgola. Il campo `States` contiene [stati](workflow-states.md). ``` { "State1" : { }, "State2" : { }, ... } ``` Una macchina a stati è definita dagli stati che contiene e dalle relazioni tra gli stessi. Di seguito è riportato un esempio. ``` { "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 viene avviata un'esecuzione di questa macchina a stati, il sistema inizia con lo stato cui viene fatto riferimento nel campo `StartAt` (`"HelloWorld"`). Se questo stato ha un campo `"End": true`, l'esecuzione viene arrestata e restituisce un risultato. In caso contrario, il sistema cerca un campo `"Next":` e continua con quello stato. Questo processo si ripete finché il sistema non raggiunge uno stato terminale, ovvero uno stato con `"Type": "Succeed"`, `"Type": "Fail"` o `"End": true`, oppure finché non si verifica un errore di runtime. Le regole seguenti si applicano agli stati in una macchina a stati: + Gli stati possono verificarsi in qualsiasi ordine nel blocco di inclusione, ma l'ordine in cui sono elencati non influenza l'ordine in cui vengono eseguiti, che dipende dal contenuto degli stati stessi. + Una macchina a stati può includere un solo stato designato come stato `start` tramite il valore del campo `StartAt` nella struttura di livello superiore. Questo stato è quello che viene eseguito per primo quando viene avviata l'esecuzione. + Qualsiasi stato per il quale il campo `End` è `true` viene considerato uno stato `end` (o `terminal`). A seconda della logica della macchina a stati, ad esempio se la macchina a stati ha più rami di esecuzione, potresti avere più di uno stato. `end` + Se la macchina a stati include un solo stato, può essere contemporaneamente lo stato `start` e lo stato `end`. ## Campi di stato comuni nei flussi di lavoro I seguenti campi sono comuni a tutti gli elementi di stato. ** `Type` (Obbligatorio)** Tipo di stato: Task, Choice, Parallel, Map, Pass, Wait, Succeed, Fail. **`QueryLanguage`(Facoltativo; se omesso, il valore predefinito è) `JSONPath`** + Il nome del linguaggio di interrogazione utilizzato dallo stato. I valori consentiti sono `JSONPath` e `JSONata`. + Quando il linguaggio di interrogazione della macchina a stati di primo livello è`JSONPath`, i singoli stati possono sovrascrivere il linguaggio di query QueryLanguage impostando su. `JSONata` Con questo approccio, è possibile convertire in modo incrementale una macchina a stati da JSONata uno stato JSONPath alla volta. ** `Next` ** Il nome dello stato successivo che viene eseguito al termine dello stato corrente. Alcuni tipi di stato, ad esempio `Choice`, consentono più stati di transizione. Se lo stato corrente è l'ultimo stato del flusso di lavoro o uno stato terminale, ad esempio [Stato del flusso di lavoro Success](state-succeed.md) o[Stato del flusso di lavoro fallito](state-fail.md), non è necessario specificare il `Next` campo. ** `End` ** Designa questo stato come stato terminale (termina l'esecuzione) se impostato su `true`. È possibile avere un numero qualsiasi di stati terminali per macchina a stati. Uno solo tra `Next` o `End` può essere utilizzato in uno stato. Alcuni tipi di stato, ad esempio`Choice`, o stati terminali, come [Stato del flusso di lavoro Success](state-succeed.md) e[Stato del flusso di lavoro fallito](state-fail.md), non supportano o utilizzano il `End` campo. ** `Comment` (facoltativo).** Contiene una descrizione leggibile dello stato. ** `Assign` (facoltativo).** Utilizzato per memorizzare variabili. Il `Assign` campo accetta un oggetto JSON con key/value coppie che definiscono i nomi delle variabili e i valori assegnati. Qualsiasi valore di stringa, compresi quelli all'interno di oggetti o matrici, verrà valutato come JSONata se fosse circondato da caratteri `{% %}` Per ulteriori informazioni, consulta [Passaggio di dati tra stati con variabili](workflow-variables.md). ** `Output`(Solo facoltativo) JSONata ** Utilizzato per specificare e trasformare l'output dello stato. Quando specificato, il valore ha la precedenza sullo stato di output predefinito. Il campo di output accetta qualsiasi valore JSON (oggetto, array, stringa, numero, booleano, null). Qualsiasi valore di stringa, inclusi quelli all'interno di oggetti o array, verrà valutato come JSONata se fosse circondato da \$1%%\$1 caratteri. Output accetta anche direttamente un' JSONata espressione, ad esempio: «Output»: «\$1% jsonata expression%\$1» Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md). ** `InputPath`(Solo facoltativo) JSONPath ** Un [percorso](concepts-input-output-filtering.md) che seleziona una parte dell'input dello stato da passare al task dello stato per l'elaborazione. Se non specificato, ha il valore predefinito `$`, che designa l'intero input. Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md). ** `OutputPath`( JSONPath Solo facoltativo)** Un [percorso](concepts-input-output-filtering.md) che seleziona una parte dell'output dello stato da passare allo stato successivo. Se omesso, ha il valore `$` che designa l'intero output. Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md). # Funzioni intrinseche per JSONPath gli stati in 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 **avvertimento** Le funzioni intrinseche sono disponibili solo per gli stati che utilizzano il **JSONPath**linguaggio di interrogazione. Per JSONata, vedi. [Trasformazione dei dati con Step JSONata Functions](transforming-data.md) Amazon States Language fornisce diverse funzioni intrinseche, note anche come *intrinseche, da utilizzare nei* campi che accettano. JSONPath Con intrinsics, puoi eseguire operazioni di elaborazione dei dati di base senza utilizzare uno stato. `Task` Gli elementi intrinseci hanno un aspetto simile alle funzioni dei linguaggi di programmazione. Possono essere usati per aiutare i costruttori di payload a elaborare i dati in entrata e in uscita dal `Resource` campo di uno `Task` stato che utilizza il linguaggio di interrogazione. JSONPath In Amazon States Language, le funzioni intrinseche sono raggruppate nelle seguenti categorie, in base al tipo di attività di elaborazione dei dati che desideri eseguire: + [Elementi intrinseci per gli array](#asl-intrsc-func-arrays) + [Intrinseci per la codifica e la decodifica dei dati](#asl-intrsc-func-data-encode-decode) + [Intrinseco per il calcolo dell'hash](#asl-intrsc-func-hash-calc) + [Caratteristiche intrinseche per la manipolazione dei dati JSON](#asl-intrsc-func-json-manipulate) + [Elementi intrinseci per le operazioni matematiche](#asl-intrsc-func-math-operation) + [Intrinseco per il funzionamento con stringhe](#asl-intrsc-func-string-operation) + [Intrinseco per la generazione di identificatori univoci](#asl-intrsc-func-uuid-generate) + [Intrinseco per operazioni generiche](#asl-intrsc-func-generic) Per utilizzare le funzioni intrinseche, devi specificare il valore chiave `.$` nelle definizioni della tua macchina a stati, come mostrato nell'esempio seguente: ``` "KeyId.$": "States.Array($.Id)" ``` È possibile annidare fino a 10 funzioni intrinseche all'interno di un campo nei flussi di lavoro. L'esempio seguente mostra un campo denominato `myArn` che include nove funzioni intrinseche annidate: ``` "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 richiesto per le funzioni intrinseche** **Per utilizzare le funzioni intrinseche, la macchina a stati deve utilizzare il linguaggio di interrogazione. JSONPath** Gli stati che utilizzano JSONata non possono utilizzare funzioni intrinseche; tuttavia, JSONata e Step Functions forniscono opzioni equivalenti. ## Campi che supportano funzioni intrinseche I seguenti stati supportano le funzioni intrinseche nei seguenti campi: + **Stato del passaggio**: parametri + **Stato dell'attività**: parametri ResultSelector, credenziali + **Stato parallelo**: parametri, ResultSelector + **Stato della mappa**: parametri, ResultSelector ## Elementi intrinseci per gli array Utilizzate i seguenti elementi intrinseci per eseguire manipolazioni degli array. **`States.Array`** La funzione `States.Array` intrinseca accetta zero o più argomenti. L'interprete restituisce un array JSON contenente i valori degli argomenti nell'ordine fornito. Ad esempio, con il seguente input: ``` { "Id": 123456 } ``` Potresti usare ``` "BuildId.$": "States.Array($.Id)" ``` Ciò restituirebbe il seguente risultato: `` ``` “BuildId”: [123456] ``` **`States.ArrayPartition`** Usa la funzione `States.ArrayPartition` intrinseca per partizionare un array di grandi dimensioni. È inoltre possibile utilizzare questa funzionalità intrinseca per suddividere i dati e quindi inviare il payload in blocchi più piccoli. Questa funzione intrinseca richiede due argomenti. Il primo argomento è un array, mentre il secondo argomento definisce la dimensione del blocco. L'interprete suddivide l'array di input in più array della dimensione specificata dalla dimensione del blocco. La lunghezza dell'ultimo blocco dell'array può essere inferiore alla lunghezza dei blocchi dell'array precedente se il numero di elementi rimanenti nell'array è inferiore alla dimensione del blocco. **Convalida dell'input** + È necessario specificare un array come valore di input per il primo argomento della funzione. + È necessario specificare un numero intero positivo diverso da zero per il secondo argomento che rappresenta il valore della dimensione del blocco. Se specificate un valore non intero per il secondo argomento, Step Functions lo arrotonderà al numero intero più vicino. + L'array di input non può superare il limite di dimensione del payload di Step Functions di 256 KB. Ad esempio, dato il seguente array di input: ``` {"inputArray": [1,2,3,4,5,6,7,8,9] } ``` È possibile utilizzare la `States.ArrayPartition` funzione per dividere l'array in blocchi di quattro valori: ``` "inputArray.$": "States.ArrayPartition($.inputArray,4)" ``` Ciò restituirebbe i seguenti blocchi di array: ``` {"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] } ``` Nell'esempio precedente, la `States.ArrayPartition` funzione emette tre array. I primi due array contengono ciascuno quattro valori, come definito dalla dimensione del blocco. Un terzo array contiene il valore rimanente ed è inferiore alla dimensione del blocco definita. **`States.ArrayContains`** Utilizzate la funzione `States.ArrayContains` intrinseca per determinare se un valore specifico è presente in un array. Ad esempio, è possibile utilizzare questa funzione per rilevare se si è verificato un errore in un'iterazione di `Map` stato. Questa funzione intrinseca richiede due argomenti. Il primo argomento è un array, mentre il secondo è il valore da cercare all'interno dell'array. **Convalida dell'input** + È necessario specificare un array come valore di input per il primo argomento della funzione. + È necessario specificare un oggetto JSON valido come secondo argomento. + L'array di input non può superare il limite di dimensione del payload di Step Functions di 256 KB. Ad esempio, dato il seguente array di input: ``` { "inputArray": [1,2,3,4,5,6,7,8,9], "lookingFor": 5 } ``` È possibile utilizzare la `States.ArrayContains` funzione per trovare il `lookingFor` valore all'interno di`inputArray`: ``` "contains.$": "States.ArrayContains($.inputArray, $.lookingFor)" ``` Poiché il valore memorizzato in `lookingFor` è incluso in`inputArray`, `States.ArrayContains` restituisce il seguente risultato: ``` {"contains": true } ``` **`States.ArrayRange`** Utilizzate la funzione `States.ArrayRange` intrinseca per creare un nuovo array contenente un intervallo specifico di elementi. Il nuovo array può contenere fino a 1000 elementi. Questa funzione accetta tre argomenti. Il primo argomento è il primo elemento del nuovo array, il secondo argomento è l'elemento finale del nuovo array e il terzo argomento è il valore di incremento tra gli elementi del nuovo array. **Convalida dell'input** + È necessario specificare valori interi per tutti gli argomenti. Se specificate un valore non intero per uno qualsiasi degli argomenti, Step Functions lo arrotonderà al numero intero più vicino. + È necessario specificare un valore diverso da zero per il terzo argomento. + L'array appena generato non può contenere più di 1000 elementi. Ad esempio, il seguente utilizzo della `States.ArrayRange` funzione creerà un array con un primo valore di 1, un valore finale di 9 e i valori compresi tra il primo e il valore finale aumenteranno di due per ogni elemento: ``` "array.$": "States.ArrayRange(1, 9, 2)" ``` Ciò restituirebbe il seguente array: ``` {"array": [1,3,5,7,9] } ``` **`States.ArrayGetItem`** Questa funzione intrinseca restituisce il valore di un indice specificato. Questa funzione accetta due argomenti. Il primo argomento è una matrice di valori e il secondo argomento è l'indice dell'array del valore da restituire. Ad esempio, utilizzate `inputArray` i seguenti `index` valori: ``` { "inputArray": [1,2,3,4,5,6,7,8,9], "index": 5 } ``` Da questi valori, è possibile utilizzare la `States.ArrayGetItem` funzione per restituire il valore nella `index` posizione 5 all'interno dell'array: ``` "item.$": "States.ArrayGetItem($.inputArray, $.index)" ``` In questo esempio, `States.ArrayGetItem` restituirebbe il seguente risultato: ``` { "item": 6 } ``` **`States.ArrayLength`** La funzione `States.ArrayLength` intrinseca restituisce la lunghezza di un array. Ha un argomento, l'array di cui restituire la lunghezza. Ad esempio, dato il seguente array di input: ``` { "inputArray": [1,2,3,4,5,6,7,8,9] } ``` È possibile utilizzare `States.ArrayLength` per restituire la lunghezza di`inputArray`: ``` "length.$": "States.ArrayLength($.inputArray)" ``` In questo esempio, `States.ArrayLength` restituirebbe il seguente oggetto JSON che rappresenta la lunghezza dell'array: ``` { "length": 9 } ``` **`States.ArrayUnique`** La funzione `States.ArrayUnique` intrinseca rimuove i valori duplicati da una matrice e restituisce una matrice contenente solo elementi unici. Questa funzione accetta come unico argomento un array, che può essere disordinato. Ad esempio, quanto segue `inputArray` contiene una serie di valori duplicati: ``` {"inputArray": [1,2,3,3,3,3,3,3,4] } ``` È possibile utilizzare la `States.ArrayUnique` funzione come e specificare l'array da cui rimuovere i valori duplicati: ``` "array.$": "States.ArrayUnique($.inputArray)" ``` La `States.ArrayUnique` funzione restituirebbe il seguente array contenente solo elementi unici, rimuovendo tutti i valori duplicati: ``` {"array": [1,2,3,4] } ``` ## Intrinseci per la codifica e la decodifica dei dati Utilizzate le seguenti funzioni intrinseche per codificare o decodificare i dati in base allo schema di codifica Base64. **`States.Base64Encode`** Utilizzate la funzione `States.Base64Encode` intrinseca per codificare i dati in base allo schema di codifica MIME Base64. È possibile utilizzare questa funzione per passare dati ad altri servizi senza utilizzare alcuna funzione. AWS AWS Lambda Questa funzione richiede la codifica di una stringa di dati di massimo 10.000 caratteri come unico argomento. Ad esempio, si consideri la seguente `input` stringa: ``` {"input": "Data to encode" } ``` È possibile utilizzare la `States.Base64Encode` funzione per codificare la `input` stringa come stringa MIME Base64: ``` "base64.$": "States.Base64Encode($.input)" ``` La `States.Base64Encode` funzione restituisce i seguenti dati codificati in risposta: ``` {"base64": "RGF0YSB0byBlbmNvZGU=" } ``` **`States.Base64Decode`** Usa la funzione `States.Base64Decode` intrinseca per decodificare i dati in base allo schema di decodifica MIME Base64. È possibile utilizzare questa funzione per passare dati ad altri AWS servizi senza utilizzare una funzione Lambda. Questa funzione accetta come unico argomento una stringa di dati codificata in Base64 contenente fino a 10.000 caratteri da decodificare. Ad esempio, con il seguente input: ``` {"base64": "RGF0YSB0byBlbmNvZGU=" } ``` È possibile utilizzare la `States.Base64Decode` funzione per decodificare la stringa base64 in una stringa leggibile dall'uomo: ``` "data.$": "States.Base64Decode($.base64)" ``` In risposta `States.Base64Decode function` restituirebbe i seguenti dati decodificati: ``` {"data": "Decoded data" } ``` ## Intrinseco per il calcolo dell'hash **`States.Hash`** Usa la funzione `States.Hash` intrinseca per calcolare il valore hash di un dato input. È possibile utilizzare questa funzione per passare dati ad altri AWS servizi senza utilizzare una funzione Lambda. Questa funzione accetta due argomenti. Il primo argomento riguarda i dati di cui si desidera calcolare il valore hash. Il secondo argomento è l'algoritmo di hashing da utilizzare per eseguire il calcolo dell'hash. I dati forniti devono essere una stringa di oggetto contenente al massimo 10.000 caratteri. L'algoritmo di hashing specificato può essere uno dei seguenti algoritmi: + `MD5` + `SHA-1` + `SHA-256` + `SHA-384` + `SHA-512` Ad esempio, è possibile utilizzare questa funzione per calcolare il valore hash della `Data` stringa utilizzando quanto specificato: `Algorithm` ``` { "Data": "input data", "Algorithm": "SHA-1" } ``` È possibile utilizzare la `States.Hash` funzione per calcolare il valore hash: ``` "output.$": "States.Hash($.Data, $.Algorithm)" ``` La `States.Hash` funzione restituisce il seguente valore hash in risposta: ``` {"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" } ``` ## Caratteristiche intrinseche per la manipolazione dei dati JSON Utilizzate queste funzioni per eseguire operazioni di elaborazione dei dati di base sugli oggetti JSON. **`States.JsonMerge`** Utilizzate la funzione `States.JsonMerge` intrinseca per unire due oggetti JSON in un unico oggetto. Questa funzione accetta tre argomenti. I primi due argomenti sono gli oggetti JSON che desiderate unire. Il terzo argomento è un valore booleano di. `false` Questo valore booleano determina se la modalità di fusione profonda è abilitata. Attualmente, Step Functions supporta solo la modalità di fusione superficiale; pertanto, è necessario specificare il valore booleano come. `false` In modalità superficiale, se la stessa chiave esiste in entrambi gli oggetti JSON, la chiave di quest'ultimo oggetto sovrascrive la stessa chiave nel primo oggetto. Inoltre, gli oggetti annidati all'interno di un oggetto JSON non vengono uniti quando si utilizza la fusione superficiale. Ad esempio, è possibile utilizzare la `States.JsonMerge` funzione per unire i seguenti oggetti JSON che condividono la chiave. `a` ``` { "json1": { "a": {"a1": 1, "a2": 2}, "b": 2 }, "json2": { "a": {"a3": 1, "a4": 2}, "c": 3 } } ``` È possibile specificare gli oggetti json1 e json2 come input nella funzione per unirli insieme: `States.JsonMerge` ``` "output.$": "States.JsonMerge($.json1, $.json2, false)" ``` `States.JsonMerge`restituisce come risultato il seguente oggetto JSON unito. Nell'oggetto JSON unito`output`, la chiave dell'oggetto `a` sostituisce la chiave dell'`json2`oggetto. `json1` `a` Inoltre, l'oggetto nidificato nella chiave dell'`json1`oggetto `a` viene scartato perché la modalità superficiale non supporta l'unione di oggetti nidificati. ``` { "output": { "a": {"a3": 1, "a4": 2}, "b": 2, "c": 3 } } ``` ** `States.StringToJson` ** La `States.StringToJson` funzione utilizza come unico argomento un percorso di riferimento a una stringa JSON con escape. L'interprete applica un parser JSON e restituisce il formato JSON analizzato dell'input. Ad esempio, è possibile utilizzare questa funzione per sfuggire alla seguente stringa di input: ``` { "escapedJsonString": "{\"foo\": \"bar\"}" } ``` Utilizzate la `States.StringToJson` funzione e specificate `escapedJsonString` come argomento di input: ``` States.StringToJson($.escapedJsonString) ``` La `States.StringToJson` funzione restituisce il seguente risultato: ``` { "foo": "bar" } ``` ** `States.JsonToString` ** La `States.JsonToString` funzione accetta un solo argomento, che è il percorso che contiene i dati JSON da restituire come stringa senza escape. L'interprete restituisce una stringa che contiene testo JSON che rappresenta i dati specificati dal Path. Ad esempio, puoi fornire il seguente percorso JSON contenente un valore di escape: ``` { "unescapedJson": { "foo": "bar" } } ``` Fornisci alla `States.JsonToString` funzione i dati contenuti in: `unescapedJson` ``` States.JsonToString($.unescapedJson) ``` La `States.JsonToString` funzione restituisce la seguente risposta: ``` {\"foo\": \"bar\"} ``` ## Elementi intrinseci per le operazioni matematiche Utilizzate queste funzioni per eseguire operazioni matematiche. **`States.MathRandom`** Utilizzate la funzione `States.MathRandom` intrinseca per restituire un numero casuale compreso tra il numero iniziale (incluso) e il numero finale specificato (esclusivo). È possibile utilizzare questa funzione per distribuire un'attività specifica tra due o più risorse. Questa funzione richiede tre argomenti. Il primo argomento è il numero iniziale, il secondo argomento è il numero finale e l'ultimo argomento controlla il valore iniziale opzionale. Si noti che se si utilizza questa funzione con lo stesso valore iniziale, restituirà numeri identici. Poiché la `States.MathRandom` funzione non restituisce numeri casuali crittograficamente sicuri, si consiglia di non utilizzarla per applicazioni sensibili alla sicurezza. **Convalida dell'input** + È necessario specificare valori interi per gli argomenti del numero iniziale e del numero finale. Se specificate un valore non intero per l'argomento del numero iniziale o del numero finale, Step Functions lo arrotonderà al numero intero più vicino. Ad esempio, per generare un numero casuale compreso tra uno e 999, è possibile utilizzare i seguenti valori di input: ``` { "start": 1, "end": 999 } ``` Per generare il numero casuale, fornite i `end` valori `start` e alla `States.MathRandom` funzione: ``` "random.$": "States.MathRandom($.start, $.end)" ``` La `States.MathRandom` funzione restituisce il seguente numero casuale come risposta: ``` {"random": 456 } ``` **`States.MathAdd`** Utilizzate la funzione `States.MathAdd` intrinseca per restituire la somma di due numeri. Ad esempio, è possibile utilizzare questa funzione per incrementare i valori all'interno di un ciclo senza richiamare una funzione Lambda. **Convalida dell'input** + È necessario specificare valori interi per tutti gli argomenti. Se specificate un valore non intero per uno o entrambi gli argomenti, Step Functions lo arrotonderà al numero intero più vicino. + È necessario specificare valori interi nell'intervallo di -2147483648 e 2147483647. Ad esempio, è possibile utilizzare i seguenti valori per sottrarre uno da 111: ``` { "value1": 111, "step": -1 } ``` Quindi, utilizzate la `States.MathAdd` funzione di definizione `value1` come valore iniziale e `step` come valore da `value1` incrementare di: ``` "value1.$": "States.MathAdd($.value1, $.step)" ``` La `States.MathAdd` funzione restituirebbe il seguente numero in risposta: ``` {"value1": 110 } ``` ## Intrinseco per il funzionamento con stringhe **`States.StringSplit`** Usa la funzione `States.StringSplit` intrinseca per dividere una stringa in una matrice di valori. Questa funzione accetta due argomenti. Il primo argomento è una stringa e il secondo argomento è il carattere delimitante che la funzione utilizzerà per dividere la stringa. **Example - Divide una stringa di input utilizzando un singolo carattere di delimitazione** Per questo esempio, usa `States.StringSplit` per dividere quanto segue`inputString`, che contiene una serie di valori separati da virgole: ``` { "inputString": "1,2,3,4,5", "splitter": "," } ``` Utilizzate la `States.StringSplit` funzione e definite `inputString` come primo argomento e il carattere delimitante `splitter` come secondo argomento: ``` "array.$": "States.StringSplit($.inputString, $.splitter)" ``` La `States.StringSplit` funzione restituisce come risultato il seguente array di stringhe: ``` {"array": ["1","2","3","4","5"] } ``` **Example - Divide una stringa di input utilizzando più caratteri di delimitazione** Per questo esempio, usa `States.StringSplit` per dividere quanto segue`inputString`, che contiene più caratteri di delimitazione: ``` { "inputString": "This.is+a,test=string", "splitter": ".+,=" } ``` Utilizzate la `States.StringSplit` funzione come segue: ``` { "myStringArray.$": "States.StringSplit($.inputString, $.splitter)" } ``` La `States.StringSplit` funzione restituisce come risultato il seguente array di stringhe: ``` {"myStringArray": [ "This", "is", "a", "test", "string" ]} ``` ## Intrinseco per la generazione di identificatori univoci **`States.UUID`** Utilizza la funzione `States.UUID` intrinseca per restituire un identificatore univoco universale versione 4 (UUID v4) generato utilizzando numeri casuali. Ad esempio, è possibile utilizzare questa funzione per chiamare altri AWS servizi o risorse che richiedono un parametro UUID o inserire elementi in una tabella DynamoDB. La `States.UUID` funzione viene chiamata senza argomenti specificati: ``` "uuid.$": "States.UUID()" ``` La funzione restituisce un UUID generato casualmente, come nell'esempio seguente: ``` {"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" } ``` ## Intrinseco per operazioni generiche **`States.Format`** Usa la funzione `States.Format` intrinseca per costruire una stringa da valori letterali e interpolati. Questa funzione accetta uno o più argomenti. Il valore del primo argomento deve essere una stringa e può includere zero o più istanze della sequenza `{}` di caratteri. Nell'invocazione della funzione intrinseca devono esserci tanti argomenti rimanenti quante sono le occorrenze di. `{}` L'interprete restituisce la stringa definita nel primo argomento, `{}` sostituendo ciascuno con il valore dell'argomento corrispondente alla posizione nell'invocazione intrinseca. Ad esempio, è possibile utilizzare i seguenti input di una persona e una frase in cui inserire il nome`name`: `template` ``` { "name": "Arnav", "template": "Hello, my name is {}." } ``` Utilizzate la `States.Format` funzione e specificate la `template` stringa e la stringa da inserire al posto dei `{}` caratteri: ``` States.Format('Hello, my name is {}.', $.name) ``` or ``` States.Format($.template, $.name) ``` Con uno degli input precedenti, la `States.Format` funzione restituisce la stringa completata in risposta: ``` Hello, my name is Arnav. ``` ## Caratteri riservati nelle funzioni intrinseche I seguenti caratteri sono riservati alle funzioni intrinseche e devono essere eliminati con una barra rovesciata ('\$1') se si desidera che compaiano nel Value:, e. ' \$1 \$1 \$1 Se il carattere `\` deve apparire come parte del valore senza fungere da carattere di escape, devi evitarlo con una barra rovesciata. Le seguenti sequenze di caratteri con escape vengono utilizzate con funzioni intrinseche: + La stringa letterale rappresenta. `\'` `'` + La stringa `\{` letterale rappresenta. `{` + La stringa `\}` letterale rappresenta. `}` + La stringa `\\` letterale rappresenta. `\` In JSON, le barre rovesciate contenute in un valore letterale di stringa devono essere sostituite con un'altra barra rovesciata. L'elenco equivalente per JSON è: + La stringa `\\\'` di escape rappresenta. `\'` + La stringa `\\\{` di escape rappresenta. `\{` + La stringa `\\\}` di escape rappresenta. `\}` + La stringa `\\\\` di escape rappresenta. `\\` **Nota** Se nella stringa di invocazione intrinseca `\` viene trovata una barra rovesciata di escape aperta, l'interprete restituirà un errore di runtime. [È necessario utilizzare la notazione tra parentesi quadre per un **percorso** passato come argomento a una funzione intrinseca se il nome del campo contiene caratteri non inclusi nella definizione della regola ABNF. `member-name-shorthand` JsonPath ](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf) Se il tuo **Path** contiene caratteri non alfanumerici, inoltre, devi usare la notazione tra parentesi quadre. `_` Ad esempio, `$.abc.['def ghi']`.