Intrinsische Funktionen in Amazon States Language for Step Functions Functions-Workflows

Die States.Array systeminterne Funktion benötigt null oder mehr Argumente. Der Interpreter gibt ein JSON Array zurück, das die Werte der Argumente in der angegebenen Reihenfolge enthält. Beispielsweise angesichts der folgenden Eingabe:

{
  "Id": 123456
}

Du könntest benutzen

"BuildId.$": "States.Array($.Id)"

Was das folgende Ergebnis zurückgeben würde:

“BuildId”: [123456]

Verwenden Sie die States.ArrayPartition systemeigene Funktion, um ein großes Array zu partitionieren. Sie können diese systeminterne Funktion auch verwenden, um die Daten zu segmentieren und dann die Nutzdaten in kleinere Teile zu senden.

Diese systeminterne Funktion benötigt zwei Argumente. Das erste Argument ist ein Array, während das zweite Argument die Chunk-Größe definiert. Der Interpreter teilt das Eingabearray in mehrere Arrays der durch die Chunk-Größe angegebenen Größe auf. Die Länge des letzten Array-Chunks kann geringer sein als die Länge der vorherigen Array-Chunks, wenn die Anzahl der verbleibenden Elemente im Array kleiner als die Chunk-Größe ist.

Überprüfung von Eingaben

Nehmen wir zum Beispiel das folgende Eingabe-Array:

{"inputArray": [1,2,3,4,5,6,7,8,9] }

Sie könnten die States.ArrayPartition Funktion verwenden, um das Array in Blöcke mit vier Werten zu unterteilen:

"inputArray.$": "States.ArrayPartition($.inputArray,4)"

Was die folgenden Array-Blöcke zurückgeben würde:

{"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }

Im vorherigen Beispiel gibt die States.ArrayPartition Funktion drei Arrays aus. Die ersten beiden Arrays enthalten jeweils vier Werte, die durch die Chunk-Größe definiert sind. Ein drittes Array enthält den verbleibenden Wert und ist kleiner als die definierte Chunk-Größe.

Verwenden Sie die States.ArrayContains systeminterne Funktion, um festzustellen, ob ein bestimmter Wert in einem Array vorhanden ist. Sie können diese Funktion beispielsweise verwenden, um festzustellen, ob in einer Map Status-Iteration ein Fehler aufgetreten ist.

Diese systeminterne Funktion benötigt zwei Argumente. Das erste Argument ist ein Array, während das zweite Argument der Wert ist, nach dem innerhalb des Arrays gesucht werden soll.

Überprüfung von Eingaben

Nehmen wir zum Beispiel das folgende Eingabe-Array:

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "lookingFor": 5
}

Sie könnten die States.ArrayContains Funktion verwenden, um den lookingFor Wert innerhalb von zu findeninputArray:

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

Da der in gespeicherte Wert in enthalten lookingFor istinputArray, wird das folgende Ergebnis States.ArrayContains zurückgegeben:

{"contains": true }

Verwenden Sie die States.ArrayRange systeminterne Funktion, um ein neues Array zu erstellen, das einen bestimmten Bereich von Elementen enthält. Das neue Array kann bis zu 1000 Elemente enthalten.

Diese Funktion benötigt drei Argumente. Das erste Argument ist das erste Element des neuen Arrays, das zweite Argument ist das letzte Element des neuen Arrays und das dritte Argument ist der Inkrementwert zwischen den Elementen im neuen Array.

Überprüfung von Eingaben

Bei der folgenden Verwendung der States.ArrayRange Funktion wird beispielsweise ein Array mit einem ersten Wert von 1 und einem Endwert von 9 erstellt, und die Werte zwischen dem ersten und dem letzten Wert werden für jedes Element um zwei erhöht:

"array.$": "States.ArrayRange(1, 9, 2)"

Was das folgende Array zurückgeben würde:

{"array": [1,3,5,7,9] }

Diese intrinsische Funktion gibt den Wert eines angegebenen Indexes zurück. Diese Funktion benötigt zwei Argumente. Das erste Argument ist ein Array von Werten und das zweite Argument ist der Array-Index des zurückzugebenden Werts.

Verwenden Sie beispielsweise die folgenden index Werte inputArray und:

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "index": 5
}

Aus diesen Werten können Sie die States.ArrayGetItem Funktion verwenden, um den Wert an der index Position 5 innerhalb des Arrays zurückzugeben:

"item.$": "States.ArrayGetItem($.inputArray, $.index)"

In diesem Beispiel States.ArrayGetItem würde das folgende Ergebnis zurückgegeben werden:

{ "item": 6 }

Die States.ArrayLength systeminterne Funktion gibt die Länge eines Arrays zurück. Sie hat ein Argument, das Array, dessen Länge zurückgegeben werden soll.

Zum Beispiel bei dem folgenden Eingabe-Array:

{
   "inputArray": [1,2,3,4,5,6,7,8,9]
}

Sie können verwendenStates.ArrayLength, um die Länge zurückzugeben voninputArray:

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

In diesem Beispiel States.ArrayLength würde das folgende JSON Objekt zurückgegeben werden, das die Länge des Arrays darstellt:

{ "length": 9 }

Die States.ArrayUnique systeminterne Funktion entfernt doppelte Werte aus einem Array und gibt ein Array zurück, das nur eindeutige Elemente enthält. Diese Funktion verwendet ein Array, das unsortiert sein kann, als einziges Argument.

Der folgende Code inputArray enthält beispielsweise eine Reihe von doppelten Werten:

{"inputArray": [1,2,3,3,3,3,3,3,4] }

Sie könnten die States.ArrayUnique Funktion als verwenden und das Array angeben, aus dem Sie doppelte Werte entfernen möchten:

"array.$": "States.ArrayUnique($.inputArray)"

Die States.ArrayUnique Funktion würde das folgende Array zurückgeben, das nur eindeutige Elemente enthält, und alle doppelten Werte entfernen:

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

Verwenden Sie die States.Base64Encode systeminterne Funktion, um Daten auf der Grundlage des Base64-Kodierungsschemas zu codieren. MIME Sie können diese Funktion verwenden, um Daten an andere AWS Dienste zu übergeben, ohne eine Funktion zu verwenden. AWS Lambda

Diese Funktion benötigt als einziges Argument eine Datenzeichenfolge mit bis zu 10.000 Zeichen zum Kodieren.

Betrachten Sie zum Beispiel die folgende input Zeichenfolge:

{"input": "Data to encode" }

Sie können die States.Base64Encode Funktion verwenden, um die input Zeichenfolge als MIME Base64-Zeichenfolge zu codieren:

"base64.$": "States.Base64Encode($.input)"

Die States.Base64Encode Funktion gibt als Antwort die folgenden codierten Daten zurück:

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Verwenden Sie die States.Base64Decode systeminterne Funktion, um Daten auf der Grundlage des Base64-Dekodierungsschemas zu dekodieren. MIME Sie können diese Funktion verwenden, um Daten an andere AWS Dienste zu übergeben, ohne eine Lambda-Funktion zu verwenden.

Diese Funktion verwendet als einziges Argument eine Base64-kodierte Datenzeichenfolge mit bis zu 10.000 Zeichen für die Dekodierung.

Beispielsweise angesichts der folgenden Eingabe:

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Sie können die States.Base64Decode Funktion verwenden, um die Base64-Zeichenfolge in eine für Menschen lesbare Zeichenfolge zu dekodieren:

"data.$": "States.Base64Decode($.base64)"

Das States.Base64Decode function würde als Antwort die folgenden dekodierten Daten zurückgeben:

{"data": "Decoded data" }

Verwenden Sie die States.Hash systeminterne Funktion, um den Hashwert einer bestimmten Eingabe zu berechnen. Sie können diese Funktion verwenden, um Daten an andere AWS Dienste zu übergeben, ohne eine Lambda-Funktion zu verwenden.

Diese Funktion benötigt zwei Argumente. Das erste Argument sind die Daten, deren Hashwert Sie berechnen möchten. Das zweite Argument ist der Hash-Algorithmus, der zur Durchführung der Hash-Berechnung verwendet werden soll. Bei den von Ihnen angegebenen Daten muss es sich um eine Objektzeichenfolge mit 10.000 Zeichen oder weniger handeln.

Bei dem von Ihnen angegebenen Hash-Algorithmus kann es sich um einen der folgenden Algorithmen handeln:

Sie können diese Funktion beispielsweise verwenden, um den Hashwert der Data Zeichenfolge anhand der angegebenen Algorithm Werte zu berechnen:

{
   "Data": "input data", 
   "Algorithm": "SHA-1" 
}

Sie können die States.Hash Funktion verwenden, um den Hashwert zu berechnen:

"output.$": "States.Hash($.Data, $.Algorithm)"

Die States.Hash Funktion gibt als Antwort den folgenden Hashwert zurück:

{"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }

Verwenden Sie die States.JsonMerge systeminterne Funktion, um zwei JSON Objekte zu einem einzigen Objekt zusammenzuführen. Diese Funktion benötigt drei Argumente. Die ersten beiden Argumente sind die JSON Objekte, die Sie zusammenführen möchten. Das dritte Argument ist ein boolescher Wert von. false Dieser boolesche Wert bestimmt, ob der Deep Merging-Modus aktiviert ist.

Derzeit unterstützt Step Functions nur den Shallow-Merging-Modus. Daher müssen Sie den booleschen Wert als angeben. false Wenn im Shallow-Modus derselbe Schlüssel in beiden JSON Objekten vorhanden ist, hat der Schlüssel des letzteren Objekts Vorrang vor demselben Schlüssel im ersten Objekt. Darüber hinaus werden Objekte, die in einem JSON Objekt verschachtelt sind, nicht zusammengeführt, wenn Sie die Option „Shallow Merging“ verwenden.

Sie können die States.JsonMerge Funktion beispielsweise verwenden, um die folgenden JSON Objekte zusammenzuführen, die den Schlüssel gemeinsam haben. a

{
   "json1": { "a": {"a1": 1, "a2": 2}, "b": 2 },
   "json2": { "a": {"a3": 1, "a4": 2}, "c": 3 }
}

Sie können die Objekte json1 und json2 als Eingaben in der States.JsonMerge Funktion angeben, um sie zusammenzuführen:

"output.$": "States.JsonMerge($.json1, $.json2, false)"

Das States.JsonMerge gibt das folgende zusammengeführte JSON Objekt als Ergebnis zurück. Im zusammengeführten JSON Objekt output a ersetzt der Schlüssel des json2 Objekts den Schlüssel des json1 Objektsa. Außerdem a wird das verschachtelte Objekt im json1 Objektschlüssel verworfen, da der flache Modus das Zusammenführen verschachtelter Objekte nicht unterstützt.

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

Die States.StringToJson Funktion verwendet als einziges Argument einen Referenzpfad zu einer maskierten JSON Zeichenfolge.

Der Interpreter wendet einen JSON Parser an und gibt die JSON geparste Form der Eingabe zurück. Sie können diese Funktion beispielsweise verwenden, um die folgende Eingabezeichenfolge zu maskieren:

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

Verwenden Sie die States.StringToJson Funktion und geben Sie das escapedJsonString als Eingabeargument an:

States.StringToJson($.escapedJsonString)

Die States.StringToJson Funktion gibt das folgende Ergebnis zurück:

{ "foo": "bar" }

Die States.JsonToString Funktion benötigt nur ein Argument, nämlich den Pfad, der die JSON Daten enthält, die als Zeichenfolge ohne Escape-Zeichen zurückgegeben werden sollen. Der Interpreter gibt eine Zeichenfolge zurück, die JSON Text enthält, der die durch den Pfad angegebenen Daten darstellt. Sie können beispielsweise den folgenden JSON Pfad angeben, der einen maskierten Wert enthält:

{
  "unescapedJson": {
     "foo": "bar"
  }
}

Stellen Sie der States.JsonToString Funktion die darin enthaltenen Daten zur VerfügungunescapedJson:

States.JsonToString($.unescapedJson)
                

Die States.JsonToString Funktion gibt die folgende Antwort zurück:

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

Verwenden Sie die States.MathRandom systeminterne Funktion, um eine Zufallszahl zwischen der angegebenen Startzahl (einschließlich) und der Endzahl (ausschließlich) zurückzugeben.

Sie können diese Funktion verwenden, um eine bestimmte Aufgabe auf zwei oder mehr Ressourcen zu verteilen.

Diese Funktion benötigt drei Argumente. Das erste Argument ist die Startnummer, das zweite Argument ist die Endzahl und das letzte Argument steuert den optionalen Startwert. Beachten Sie, dass, wenn Sie diese Funktion mit demselben Startwert verwenden, identische Zahlen zurückgegeben werden.

Überprüfung von Eingaben

Um beispielsweise eine Zufallszahl zwischen eins und 999 zu generieren, können Sie die folgenden Eingabewerte verwenden:

{
   "start": 1,
   "end": 999
}

Um die Zufallszahl zu generieren, geben Sie die end Werte start und für die States.MathRandom Funktion ein:

"random.$": "States.MathRandom($.start, $.end)"

Die States.MathRandom Funktion gibt die folgende Zufallszahl als Antwort zurück:

{"random": 456 }

Verwenden Sie die States.MathAdd systeminterne Funktion, um die Summe zweier Zahlen zurückzugeben. Sie können diese Funktion beispielsweise verwenden, um Werte innerhalb einer Schleife zu erhöhen, ohne eine Lambda-Funktion aufzurufen.

Überprüfung von Eingaben

Sie können beispielsweise die folgenden Werte verwenden, um eins von 111 zu subtrahieren:

{
   "value1": 111,
   "step": -1
}

Verwenden Sie dann die States.MathAdd Funktion definierend value1 als Startwert und step als Wert, um den Sie erhöht werden sollen: value1

"value1.$": "States.MathAdd($.value1, $.step)"

Die States.MathAdd Funktion würde als Antwort die folgende Zahl zurückgeben:

{"value1": 110 }

Verwenden Sie die States.StringSplit systeminterne Funktion, um eine Zeichenfolge in ein Array von Werten aufzuteilen. Diese Funktion benötigt zwei Argumente. Das erste Argument ist eine Zeichenfolge und das zweite Argument ist das Trennzeichen, mit dem die Funktion die Zeichenfolge teilt.

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

Verwenden Sie die States.UUID systeminterne Funktion, um einen mit Zufallszahlen generierten Universally Unique Identifier (v4UUID) der Version 4 zurückzugeben. Sie können diese Funktion beispielsweise verwenden, um andere AWS Dienste oder Ressourcen aufzurufen, die einen UUID Parameter benötigen, oder Elemente in eine DynamoDB-Tabelle einzufügen.

Die States.UUID Funktion wird ohne Angabe von Argumenten aufgerufen:

"uuid.$": "States.UUID()"

Die Funktion gibt einen zufällig generierten Wert zurückUUID, wie im folgenden Beispiel:

{"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" }

Verwenden Sie die States.Format systeminterne Funktion, um eine Zeichenfolge sowohl aus literalen als auch aus interpolierten Werten zu erstellen. Diese Funktion benötigt ein oder mehrere Argumente. Der Wert des ersten Arguments muss eine Zeichenfolge sein und kann null oder mehr Instanzen der Zeichenfolge enthalten{}. Der Aufruf des intrinsischen Elements muss so viele verbleibende Argumente enthalten, wie es vorkommen kann. {} Der Interpreter gibt die im ersten Argument definierte Zeichenfolge zurück, wobei jedes Argument im systeminternen Aufruf durch den Wert des der Position entsprechenden Arguments {} ersetzt wird.

Sie können beispielsweise die folgenden Eingaben einer Person und einen template Satz verwendenname, in den ihr Name eingefügt werden soll:

{
 "name": "Arnav",
 "template": "Hello, my name is {}."
}

Verwenden Sie die States.Format Funktion und geben Sie die template Zeichenfolge und die Zeichenfolge an, die anstelle der {} Zeichen eingefügt werden sollen:

States.Format('Hello, my name is {}.', $.name)

or

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

Bei einer der vorherigen Eingaben gibt die States.Format Funktion als Antwort die vollständige Zeichenfolge zurück:

Hello, my name is Arnav.