Funzioni intrinseche

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]

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

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.

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

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 diinputArray:

"contains.$": "States.ArrayContains($.inputArray, $.lookingFor)"

Poiché il valore memorizzato in lookingFor è incluso ininputArray, States.ArrayContains restituisce il seguente risultato:

{"contains": true }

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

Ad esempio, il seguente utilizzo della States.ArrayRange funzione creerà una matrice 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] }

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 }

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 diinputArray:

"length.$": "States.ArrayLength($.inputArray)"

In questo esempio, States.ArrayLength restituirebbe il seguente oggetto JSON che rappresenta la lunghezza dell'array:

{ "length": 9 }

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] }

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=" }

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 codificati 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" }

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:

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" }

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.JsonMergerestituisce come risultato il seguente oggetto JSON unito. Nell'oggetto JSON unitooutput, la chiave dell'oggetto a sostituisce la chiave dell'json2oggetto. json1 a Inoltre, l'oggetto nidificato nella chiave dell'json1oggetto a viene scartato perché la modalità superficiale non supporta l'unione di oggetti nidificati.

{
   "output": {
      "a": {"a3": 1, "a4": 2},
      "b": 2, 
      "c": 3 
   }
}

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" }

La States.JsonToString funzione accetta un solo argomento, ovvero il Path 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 all'interno di: unescapedJson

States.JsonToString($.unescapedJson)
                

La States.JsonToString funzione restituisce la seguente risposta:

{\"foo\": \"bar\"}

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. L'argomento del valore iniziale è facoltativo. Se si utilizza questa funzione con lo stesso valore iniziale, restituisce un numero identico.

Convalida dell'input

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 }

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

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 }

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.

{
    "inputString": "1,2,3,4,5",
    "splitter": ","
}

"array.$": "States.StringSplit($.inputString, $.splitter)"

{"array":  ["1","2","3","4","5"] }

{
  "inputString": "This.is+a,test=string",
  "splitter": ".+,="
}

{
  "myStringArray.$": "States.StringSplit($.inputString, $.splitter)"
}

{"myStringArray": [
  "This",
  "is",
  "a",
  "test",
  "string"
]}

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" }

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 dell'intrinseco devono esserci tanti argomenti rimanenti quante sono le occorrenze di. {} L'interprete restituisce la stringa definita nel primo argomento, ciascuna {} sostituita dal valore dell'argomento corrispondente alla posizione nell'invocazione Intrinsic.

Ad esempio, è possibile utilizzare i seguenti input di una persona e una frase in cui inserire il nomename: 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)

oppure

States.Format($.template, $.name)

Con uno degli input precedenti, la States.Format funzione restituisce la stringa completata in risposta:

Hello, my name is Arnav.