Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Verwendung von Amazon States Language zur Definition von Step Functions Functions-Workflows Die Amazon States Language ist eine JSON-basierte, strukturierte Sprache, die verwendet wird, um Ihre Zustandsmaschine zu definieren, eine Sammlung von [Zuständen](workflow-states.md), die funktionieren können (`Task`Status), bestimmen, zu welchen Status Sie als Nächstes übergehen sollen (`Choice`Status), eine Ausführung mit einem Fehler beenden können (`Fail`Status) und so weiter. Weitere Informationen finden Sie in der [Amazon States Language Specification](https://states-language.net/spec.html) und in [Statelint](https://github.com/awslabs/statelint), einem Tool, das Amazon States Language-Code validiert. Informationen zum Erstellen eines Zustandsmaschinen in der [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) mithilfe der Amazon States Language finden Sie unter [Erste Schritte](getting-started.md). **Anmerkung** *Wenn Sie Ihre Zustandsmaschinen außerhalb der Step Functions Functions-Konsole definieren, z. B. in einem Editor Ihrer Wahl, müssen Sie Ihre Zustandsmaschinendefinitionen mit der Erweiterung .asl.json speichern.* ## Beispiel für eine Amazon States-Sprachspezifikation (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 } } } ``` # Zustandsmaschinenstruktur in Amazon States Language für Step Functions Functions-Workflows **Status verwalten und Daten transformieren** Erfahren Sie mehr über das [Übergeben von Daten zwischen Zuständen mithilfe von Variablen](workflow-variables.md) und das [Transformieren von Daten mit JSONata](transforming-data.md). Zustandsautomaten werden mit Hilfe von JSON-Text definiert, der eine Struktur repräsentiert, die folgende Felder enthält. ** `Comment` (Optional)** Eine für Menschen lesbare Beschreibung des Zustandsautomaten. ** `QueryLanguage`(Optional; wenn es weggelassen wird, ist standardmäßig) `JSONPath`** + Der Name der Abfragesprache, die von der Zustandsmaschine verwendet wird. Zulässige Werte sind `JSONPath` und `JSONata`. + Falls nicht für den Zustandsmaschine angegeben, ist der Standardwert für jeden Status JSONPath. + Wenn die Abfragesprache für Zustandsmaschinen der obersten Ebene aktiviert ist`JSONPath`, können einzelne Staaten die Abfragesprache überschreiben, indem sie QueryLanguage auf `JSONata` setzen. Bei diesem Ansatz können Sie eine Zustandsmaschine schrittweise von JSONPath einem Zustand in JSONata einen Zustand umwandeln. + **Hinweis:** Sie können eine Zustandsmaschine auf oberster Ebene nicht JSONata in eine Kombination aus beiden Zuständen zurückversetzen. JSONata JSONPath ** `StartAt` (Erforderlich)** Eine Zeichenfolge, die exakt (auch in Groß-/Kleinschreibung) mit dem Namen eines der Zustandsautomaten übereinstimmen muss. **`TimeoutSeconds`(Optional)** Die maximale Anzahl von Sekunden, die ein Zustandsautomat ausgeführt werden kann. Wenn sie länger als die angegebene Zeit ausgeführt wird, schlägt die Ausführung mit einem `States.Timeout`-[-Fehlernamen](concepts-error-handling.md#error-handling-error-representation) fehl. ** `Version` (Optional)** Die Version der Amazon States-Sprache, die in der Zustandsmaschine verwendet wird (Standard ist „1.0"). ** `States` (Erforderlich)** Ein Objekt, das eine durch Kommata getrennte Gruppe von Zuständen umfasst. Das Feld `States` enthält [Zustände](workflow-states.md). ``` { "State1" : { }, "State2" : { }, ... } ``` Ein Zustandsautomat wird definiert durch die Zustände, die er umfasst, und die Beziehungen zwischen ihnen. Im Folgenden wird ein Beispiel gezeigt. ``` { "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 } } } ``` Wenn eine Ausführung dieses Zustandsautomaten gestartet wird, beginnt das System mit dem Zustand, auf den das Feld `StartAt` verweist (`"HelloWorld"`). Wenn dieser Zustand ein Feld `"End": true` hat, stoppt die Ausführung und ein Ergebnis wird zurückgegeben. Andernfalls sucht das System nach einem Feld `"Next":` und fährt mit diesem Zustand fort. Dieser Vorgang wird wiederholt, bis das System einen Beendigungszustand erreicht (einen Zustand mit `"Type": "Succeed"`, `"Type": "Fail"` oder `"End": true`) oder ein Laufzeitfehler auftritt. Die folgenden Regeln gelten für Zustände in einem Zustandsautomaten: + Zustände können in beliebiger Reihenfolge innerhalb des umschließenden Blocks auftreten. Die Reihenfolge, in der sie aufgelistet werden, wirkt sich jedoch nicht auf die Reihenfolge aus, in der sie ausgeführt werden. Die Reihenfolge wird durch die Inhalte der Zustände bestimmt. + Innerhalb eines Zustandsautomaten kann nur ein Zustand als `start`-Zustand bezeichnet werden, und zwar durch den Wert des Felds `StartAt` in der Top-Level-Struktur. Dieser Zustand ist derjenige, der als erster ausgeführt wird, wenn die Ausführung startet. + Jeder Zustand, für den das `End`-Feld `true` ist, gilt als ein `end`- (oder `terminal`-)Zustand. Abhängig von Ihrer Zustandsmaschinen-Logik — wenn Ihre Zustandsmaschine beispielsweise mehrere Ausführungszweige hat — haben Sie möglicherweise mehr als einen Status. `end` + Wenn Ihr Zustandsautomat nur aus einem Zustand besteht, kann das sowohl der `start`- als auch der `end`-Zustand sein. ## Allgemeine Statusfelder in Workflows Die folgenden Felder sind allen Zustandselementen gemeinsam. ** `Type` (Erforderlich)** Der Typ des Status: Task, Choice, Parallel, Map, Passed, Wait, Succeed, Fail. **`QueryLanguage`(Optional; wenn es weggelassen wird, wird standardmäßig der Wert verwendet) `JSONPath`** + Der Name der vom Staat verwendeten Abfragesprache. Zulässige Werte sind `JSONPath` und `JSONata`. + Wenn die Abfragesprache der obersten Ebene der Zustandsmaschine ist`JSONPath`, können einzelne Staaten die Abfragesprache überschreiben, indem sie QueryLanguage auf `JSONata` setzen. Bei diesem Ansatz können Sie eine Zustandsmaschine schrittweise von JSONPath einem Zustand in JSONata einen Zustand umwandeln. ** `Next` ** Der Name des nächsten Zustands, der ausgeführt wird, wenn der aktuelle Zustand beendet ist. Einige Zustandstypen, z. B. `Choice`, erlauben mehrere Übergangszustände. Wenn es sich bei dem aktuellen Status um den letzten Status in Ihrem Workflow oder um einen Endstatus wie [Workflow-Status erfolgreich](state-succeed.md) oder handelt[Workflow-Status „Fehlgeschlagen“](state-fail.md), müssen Sie das `Next` Feld nicht angeben. ** `End` ** Gibt an, ob dieser Zustand ein Beendigungszustand ist (er beendet die Ausführung), wenn auf `true` gesetzt. Es kann eine beliebige Anzahl von Beendigungszuständen pro Zustandsautomaten geben. Von `Next` oder `End` kann nur einer in einem Zustand verwendet werden. Einige Zustandstypen`Choice`, wie z. B. oder Endstatus, wie [Workflow-Status erfolgreich](state-succeed.md) und[Workflow-Status „Fehlgeschlagen“](state-fail.md), unterstützen oder verwenden das `End` Feld nicht. ** `Comment` (Optional)** Enthält eine für Menschen lesbare Beschreibung des Zustands. ** `Assign` (Optional)** Wird zum Speichern von Variablen verwendet. Das `Assign` Feld akzeptiert ein JSON-Objekt mit key/value Paaren, die Variablennamen und die ihnen zugewiesenen Werte definieren. Jeder Zeichenkettenwert, auch solche innerhalb von Objekten oder Arrays, wird so ausgewertet, JSONata als ob er von Zeichen umgeben `{% %}` wäre Weitere Informationen finden Sie unter [Übergeben von Daten zwischen Staaten mit Variablen](workflow-variables.md). ** `Output`( JSONata Nur optional)** Wird verwendet, um die Ausgabe des Status zu spezifizieren und zu transformieren. Wenn angegeben, überschreibt der Wert die Standardeinstellung für die Statusausgabe. Das Ausgabefeld akzeptiert jeden JSON-Wert (Objekt, Array, Zeichenfolge, Zahl, boolescher Wert, Null). Jeder Zeichenkettenwert, einschließlich solcher innerhalb von Objekten oder Arrays, wird so ausgewertet, als JSONata ob er von \$1%%\$1 Zeichen umgeben wäre. Output akzeptiert auch direkt einen JSONata Ausdruck, zum Beispiel: „Output“: „\$1% jsonata expression%\$1“ Weitere Informationen finden Sie unter [Verarbeitung von Eingabe und Ausgabe](concepts-input-output-filtering.md). ** `InputPath`(Nur optional) JSONPath ** Ein [Pfad](concepts-input-output-filtering.md) der einen Teil der Eingabe des Zustands auswählt, der an die Aufgabe des Zustands zur Verarbeitung übergeben werden soll. Wenn dieses Attribut nicht angegeben wird, hat es den Wert `$`, der die gesamte Eingabe bezeichnet. Weitere Informationen finden Sie unter [Verarbeitung von Eingabe und Ausgabe](concepts-input-output-filtering.md). ** `OutputPath`( JSONPath Nur optional)** Ein [Pfad](concepts-input-output-filtering.md), der einen Teil der Ausgabe des Status auswählt, der an den nächsten Status übergeben werden soll. Wenn es weggelassen wird, hat es den Wert`$`, der die gesamte Ausgabe bezeichnet. Weitere Informationen finden Sie unter [Verarbeitung von Eingabe und Ausgabe](concepts-input-output-filtering.md). # Intrinsische Funktionen für JSONPath Zustände in Step Functions **Verwaltung des Zustands und Transformation von Daten** Erfahren Sie mehr über das [Übergeben von Daten zwischen Zuständen mithilfe von Variablen](workflow-variables.md) und das [Transformieren von Daten mit JSONata](transforming-data.md). **Warnung** Systeminterne Funktionen sind nur für Staaten verfügbar, die die **JSONPath**Abfragesprache verwenden. Näheres dazu finden Sie JSONata unter. [Transformieren von Daten mit JSONata In-Step-Funktionen](transforming-data.md) Die Sprache von Amazon States bietet mehrere systeminterne Funktionen, die auch als *intrinsische Funktionen bezeichnet werden und in Feldern verwendet werden* können, die akzeptiert werden. JSONPath Mit systeminternen Funktionen können Sie grundlegende Datenverarbeitungsvorgänge ausführen, ohne einen Status zu verwenden. `Task` Intrinsics ähneln Funktionen in Programmiersprachen. Sie können verwendet werden, um Payload Builder bei der Verarbeitung der Daten zu unterstützen, die zu und aus dem `Resource` Feld eines `Task` Bundesstaates übertragen werden, der die JSONPath Abfragesprache verwendet. In Amazon States Language werden systeminterne Funktionen je nach Art der Datenverarbeitungsaufgabe, die Sie ausführen möchten, in die folgenden Kategorien eingeteilt: + [Intrinsische Eigenschaften für Arrays](#asl-intrsc-func-arrays) + [Intrinsische Funktionen für die Datenkodierung und -dekodierung](#asl-intrsc-func-data-encode-decode) + [Intrinsisch für die Hash-Berechnung](#asl-intrsc-func-hash-calc) + [Intrinsische Eigenschaften für die Manipulation von JSON-Daten](#asl-intrsc-func-json-manipulate) + [Intrinsik für mathematische Operationen](#asl-intrsc-func-math-operation) + [Systemimmanent für die String-Operation](#asl-intrsc-func-string-operation) + [Intrinsisch für die Generierung eindeutiger Identifikatoren](#asl-intrsc-func-uuid-generate) + [Intrinsisch für den generischen Betrieb](#asl-intrsc-func-generic) Um systeminterne Funktionen verwenden zu können, müssen Sie den Schlüsselwert `.$` in Ihren Zustandsmaschinendefinitionen angeben, wie im folgenden Beispiel gezeigt: ``` "KeyId.$": "States.Array($.Id)" ``` Sie können in Ihren Workflows bis zu 10 systeminterne Funktionen innerhalb eines Felds verschachteln. Das folgende Beispiel zeigt ein Feld mit dem Namen`myArn`, das neun verschachtelte systeminterne Funktionen enthält: ``` "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 für intrinsische Funktionen erforderlich** **Um intrinsische Funktionen verwenden zu können, muss die Zustandsmaschine die Abfragesprache verwenden. JSONPath** Staaten, die verwenden, JSONata können keine systemeigenen Funktionen verwenden; Step Functions bieten jedoch JSONata äquivalente Optionen. ## Felder, die systeminterne Funktionen unterstützen Die folgenden Staaten unterstützen intrinsische Funktionen in den folgenden Bereichen: + **Status übergeben**: Parameter + **Status der Aufgabe**: Parameter ResultSelector, Anmeldeinformationen + **Paralleler Status**: Parameter, ResultSelector + **Kartenstatus**: Parameter, ResultSelector ## Intrinsische Eigenschaften für Arrays Verwenden Sie die folgenden systeminternen Merkmale, um Array-Manipulationen durchzuführen. **`States.Array`** 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 verwenden ``` "BuildId.$": "States.Array($.Id)" ``` Was das folgende Ergebnis zurückgeben würde: `` ``` “BuildId”: [123456] ``` **`States.ArrayPartition`** Verwenden Sie die `States.ArrayPartition` intrinsische 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** + Sie müssen ein Array als Eingabewert für das erste Argument der Funktion angeben. + Sie müssen für das zweite Argument, das den Chunk-Größenwert darstellt, eine positive Ganzzahl ungleich Null angeben. Wenn Sie für das zweite Argument einen Wert angeben, der keine Ganzzahl ist, rundet Step Functions ihn auf die nächste Ganzzahl ab. + Das Eingabearray darf die Payload-Größenbeschränkung von Step Functions von 256 KiB nicht überschreiten. 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. **`States.ArrayContains`** 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** + Sie müssen ein Array als Eingabewert für das erste Argument der Funktion angeben. + Sie müssen ein gültiges JSON-Objekt als zweites Argument angeben. + Das Eingabearray darf die Payload-Größenbeschränkung von Step Functions von 256 KiB nicht überschreiten. 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 finden`inputArray`: ``` "contains.$": "States.ArrayContains($.inputArray, $.lookingFor)" ``` Da der in gespeicherte Wert in enthalten `lookingFor` ist`inputArray`, wird das folgende Ergebnis `States.ArrayContains` zurückgegeben: ``` {"contains": true } ``` **`States.ArrayRange`** Verwenden Sie die `States.ArrayRange` systeminterne Funktion, um ein neues Array mit einem bestimmten Bereich von Elementen zu erstellen. 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** + Sie müssen für alle Argumente Ganzzahlwerte angeben. Wenn Sie für eines der Argumente einen Wert angeben, der keine Ganzzahl ist, rundet Step Functions ihn auf die nächste Ganzzahl ab. + Sie müssen für das dritte Argument einen Wert ungleich Null angeben. + Das neu generierte Array kann nicht mehr als 1000 Elemente enthalten. 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] } ``` **`States.ArrayGetItem`** 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 } ``` **`States.ArrayLength`** 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 verwenden`States.ArrayLength`, um die Länge zurückzugeben von`inputArray`: ``` "length.$": "States.ArrayLength($.inputArray)" ``` In diesem Beispiel `States.ArrayLength` würde das folgende JSON-Objekt zurückgegeben, das die Array-Länge darstellt: ``` { "length": 9 } ``` **`States.ArrayUnique`** 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] } ``` ## Intrinsische Funktionen für die Datenkodierung und -dekodierung Verwenden Sie die folgenden systemeigenen Funktionen, um Daten auf der Grundlage des Base64-Kodierungsschemas zu codieren oder zu dekodieren. **`States.Base64Encode`** Verwenden Sie die `States.Base64Encode` systeminterne Funktion, um Daten auf der Grundlage des MIME Base64-Kodierungsschemas zu codieren. 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. Stellen Sie sich zum Beispiel die folgende `input` Zeichenfolge vor: ``` {"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=" } ``` **`States.Base64Decode`** Verwenden Sie die `States.Base64Decode` systeminterne Funktion, um Daten auf der Grundlage des MIME Base64-Dekodierungsschemas zu dekodieren. 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" } ``` ## Intrinsisch für die Hash-Berechnung **`States.Hash`** 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: + `MD5` + `SHA-1` + `SHA-256` + `SHA-384` + `SHA-512` 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" } ``` ## Intrinsische Eigenschaften für die Manipulation von JSON-Daten Verwenden Sie diese Funktionen, um grundlegende Datenverarbeitungsvorgänge an JSON-Objekten durchzuführen. **`States.JsonMerge`** 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, überschreibt der Schlüssel des letzteren Objekts denselben Schlüssel im ersten Objekt. Außerdem werden Objekte, die in einem JSON-Objekt verschachtelt sind, nicht zusammengeführt, wenn Sie 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 `json2` Schlüssel des `json1` Objekts den Schlüssel des Objekts`a`. 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 } } ``` ** `States.StringToJson` ** Die `States.StringToJson` Funktion verwendet als einziges Argument einen Referenzpfad zu einer maskierten JSON-Zeichenfolge. Der Interpreter wendet einen JSON-Parser an und gibt das geparste JSON-Formular 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" } ``` ** `States.JsonToString` ** 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 Escape-Wert enthält: ``` { "unescapedJson": { "foo": "bar" } } ``` Stellen Sie der `States.JsonToString` Funktion die darin enthaltenen Daten zur Verfügung`unescapedJson`: ``` States.JsonToString($.unescapedJson) ``` Die `States.JsonToString` Funktion gibt die folgende Antwort zurück: ``` {\"foo\": \"bar\"} ``` ## Intrinsik für mathematische Operationen Verwenden Sie diese Funktionen, um mathematische Operationen auszuführen. **`States.MathRandom`** 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. Da die `States.MathRandom` Funktion keine kryptografisch sicheren Zufallszahlen zurückgibt, empfehlen wir, sie nicht für sicherheitsrelevante Anwendungen zu verwenden. **Überprüfung von Eingaben** + Sie müssen Ganzzahlwerte für die Argumente Startnummer und Endnummer angeben. Wenn Sie für das Argument Startzahl oder Endnummer einen Wert angeben, der keine Ganzzahl ist, rundet Step Functions diesen Wert auf die nächste Ganzzahl ab. 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 } ``` **`States.MathAdd`** 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 müssen Ganzzahlwerte für alle Argumente angeben. Wenn Sie für eines oder beide Argumente einen Wert angeben, der keine Ganzzahl ist, rundet Step Functions ihn auf die nächste Ganzzahl ab. + Sie müssen Ganzzahlwerte im Bereich von -2147483648 und 2147483647 angeben. 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 } ``` ## Systemimmanent für die String-Operation **`States.StringSplit`** 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. **Example - Teilt eine Eingabezeichenfolge mit einem einzigen Trennzeichen** Verwenden Sie in diesem Beispiel, `States.StringSplit` um Folgendes zu teilen`inputString`, das eine Reihe von durch Kommas getrennten Werten enthält: ``` { "inputString": "1,2,3,4,5", "splitter": "," } ``` Verwenden Sie die `States.StringSplit` Funktion und definieren Sie `inputString` als erstes Argument und das Trennzeichen `splitter` als zweites Argument: ``` "array.$": "States.StringSplit($.inputString, $.splitter)" ``` Die `States.StringSplit` Funktion gibt als Ergebnis das folgende String-Array zurück: ``` {"array": ["1","2","3","4","5"] } ``` **Example - Teilt eine Eingabezeichenfolge mit mehreren Trennzeichen auf** Verwenden Sie in diesem Beispiel, `States.StringSplit` um Folgendes zu unterteilen`inputString`, das mehrere Trennzeichen enthält: ``` { "inputString": "This.is+a,test=string", "splitter": ".+,=" } ``` Verwenden Sie die `States.StringSplit` Funktion wie folgt: ``` { "myStringArray.$": "States.StringSplit($.inputString, $.splitter)" } ``` Die `States.StringSplit` Funktion gibt als Ergebnis das folgende String-Array zurück: ``` {"myStringArray": [ "This", "is", "a", "test", "string" ]} ``` ## Intrinsisch für die Generierung eindeutiger Identifikatoren **`States.UUID`** Verwenden Sie die `States.UUID` systeminterne Funktion, um einen mit Zufallszahlen generierten Universally Unique Identifier (v4-UUID) 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 eine zufällig generierte UUID zurück, wie im folgenden Beispiel: ``` {"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" } ``` ## Intrinsisch für den generischen Betrieb **`States.Format`** 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 intrinsische Funktionsaufruf 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 verwenden`name`, 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) ``` oder ``` 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. ``` ## Reservierte Zeichen in systemeigenen Funktionen Die folgenden Zeichen sind für systeminterne Funktionen reserviert und müssen mit einem umgekehrten Schrägstrich ('\$1') maskiert werden, wenn sie im Wert vorkommen sollen:, und. ' \$1 \$1 \$1 Wenn das Zeichen als Teil des Werts erscheinen `\` soll, ohne als Escape-Zeichen zu dienen, müssen Sie es mit einem umgekehrten Schrägstrich maskieren. Die folgenden Escape-Zeichenfolgen werden mit systemeigenen Funktionen verwendet: + Die Literalzeichenfolge steht für. `\'` `'` + Die Literalzeichenfolge `\{` steht für. `{` + Die Literalzeichenfolge `\}` steht für. `}` + Die Literalzeichenfolge `\\` steht für. `\` In JSON müssen Backslashes, die in einem Zeichenfolgenliteralwert enthalten sind, mit einem anderen Backslash maskiert werden. Die entsprechende Liste für JSON lautet: + Die maskierte Zeichenfolge `\\\'` steht für`\'`. + Die maskierte Zeichenfolge `\\\{` steht für`\{`. + Die maskierte Zeichenfolge `\\\}` steht für`\}`. + Die maskierte Zeichenfolge `\\\\` steht für`\\`. **Anmerkung** Wenn in der systemeigenen Aufrufzeichenfolge ein offener Escape-Backslash gefunden `\` wird, gibt der Interpreter einen Laufzeitfehler zurück. [Sie müssen eckige Klammern für einen **Pfad** verwenden, der als Argument an eine systeminterne Funktion übergeben wird, wenn der Feldname ein Zeichen enthält, das nicht in der Definition der ABNF-Regel enthalten ist. `member-name-shorthand` JsonPath ](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf) Wenn Ihr **Pfad** nicht-alphanumerische Zeichen enthält, müssen Sie außerdem die Notation mit eckigen `_` Klammern verwenden. Beispiel, `$.abc.['def ghi']`.