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.
# Transformieren von Daten mit JSONata in Step Functions
Mit JSonata erhalten Sie eine leistungsstarke Open-Source-Abfrage- und Ausdruckssprache, mit der Sie Daten in Ihren Workflows **auswählen** und **transformieren können**. [Eine kurze Einführung und eine vollständige JSonata-Referenz finden Sie in der Dokumentation. JSONata.org ](https://docs.jsonata.org/overview.html)
**Unterstützte JSonata-Version**
Step Functions unterstützt JSONata Version 2.0.6.
Das folgende Video beschreibt Variablen und JSONata in Step Functions anhand eines DynamoDB-Beispiels:
Sie müssen sich anmelden, um die Abfrage- und Transformationssprache JSonata für bestehende Workflows zu verwenden. Wenn Sie einen Workflow in der Konsole erstellen, empfehlen wir, JSONata für die Zustandsmaschine der obersten Ebene zu wählen. `QueryLanguage` Für bestehende oder neue Workflows, die JSONPath verwenden, bietet die Konsole eine Option zum Konvertieren einzelner Status in JSONata.
Nachdem Sie JSONata ausgewählt haben, werden Ihre Workflow-Felder von fünf JSONPath-Feldern (`InputPath`, `Parameters` `ResultSelector``ResultPath`, und) auf nur zwei Felder reduziert: und`OutputPath`. `Arguments` `Output` Außerdem werden Sie **keine** Schlüsselnamen für `.$` JSON-Objekte verwenden.
Wenn Sie mit Step Functions noch nicht vertraut sind, müssen Sie nur wissen, dass JSONata-Ausdrücke die folgende Syntax verwenden:
**JSONata-Syntax:** `"{% %}"`
Die folgenden Codebeispiele zeigen eine Konvertierung von JSONPath zu JSONata:
```
# Original sample using JSONPath
{
"QueryLanguage": "JSONPath", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Parameters": {
"static": "Hello",
"title.$": "$.title",
"name.$": "$customerName", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
```
# Sample after conversion to JSONata
{
"QueryLanguage": "JSONata", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Arguments": { // JSONata states do not have Parameters
"static": "Hello",
"title": "{% $states.input.title %}",
"name": "{% $customerName %}", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
Bei gegebener Eingabe `{ "title" : "Doctor" }` und `customerName` zugewiesener Variablen erzeugen beide Zustandsmaschinen das folgende JSON-Ergebnis: `"María"`
```
{
"static": "Hello",
"title": "Doctor",
"name": "María",
"not-evaluated": "$customerName"
}
```
Im nächsten Diagramm sehen Sie eine grafische Darstellung, die zeigt, wie die Konvertierung von JsonPath (links) in JSONata (rechts) die Komplexität der Schritte in Ihren Zustandsmaschinen reduziert:
Sie können (optional) Daten aus der Statuseingabe auswählen und in **Argumente umwandeln, um sie an Ihre integrierte** Aktion zu senden. **Mit JSONata können Sie dann (optional) die **Ergebnisse** der Aktion für die Zuweisung zu Variablen und für die Statusausgabe auswählen und transformieren.**
Hinweis: Die Schritte **Zuweisen** und **Ausgeben** erfolgen **parallel**. Wenn Sie sich dafür entscheiden, Daten während der Variablenzuweisung zu transformieren, sind diese transformierten Daten im Ausgabeschritt **nicht** verfügbar. Sie müssen die JSONata-Transformation im Ausgabeschritt erneut anwenden.
## QueryLanguage Feld
In Ihren Workflow-ASL-Definitionen gibt es ein `QueryLanguage` Feld auf der obersten Ebene einer Zustandsmaschinen-Definition und in einzelnen Status. Indem Sie die `QueryLanguage` Einstellungen für einzelne Status festlegen, können Sie JSONata schrittweise in eine bestehende Zustandsmaschine übernehmen, anstatt die Zustandsmaschine auf einmal zu aktualisieren.
Das `QueryLanguage` Feld kann auf oder gesetzt werden. `"JSONPath"` `"JSONata"` Wenn das `QueryLanguage` Feld der obersten Ebene weggelassen wird, ist es standardmäßig auf. `"JSONPath"` Wenn ein Bundesstaat ein `QueryLanguage` Feld auf Bundesstaatsebene enthält, verwendet Step Functions die angegebene Abfragesprache für diesen Status. Wenn der Bundesstaat kein Feld enthält, wird die `QueryLanguage` im Feld der obersten Ebene `QueryLanguage` angegebene Abfragesprache verwendet.
## Schreiben von JSONata-Ausdrücken in JSON-Zeichenketten
Wenn eine Zeichenfolge im Wert eines ASL-Felds, eines JSON-Objektfeldes oder eines JSON-Array-Elements von `{% %}` Zeichen umgeben ist, wird diese Zeichenfolge als JSONata ausgewertet. Beachten Sie, dass die Zeichenfolge `{%` ohne führende Leerzeichen beginnen und ohne abschließende Leerzeichen `%}` enden muss. Ein unsachgemäßes Öffnen oder Schließen des Ausdrucks führt zu einem Validierungsfehler.
Hier einige Beispiele:
+ `"TimeoutSeconds" : "{% $timeout %}"`
+ `"Arguments" : {"field1" : "{% $name %}"}`in einem Bundesstaat `Task`
+ `"Items": [1, "{% $two %}", 3]`in einem `Map` Staat
Nicht alle ASL-Felder akzeptieren JSONata. Beispielsweise muss das `Type` Feld jedes Bundesstaates auf eine konstante Zeichenfolge gesetzt werden. In ähnlicher Weise muss das `Resource` Feld des `Task` Bundesstaates eine konstante Zeichenfolge sein. Das `Map` `Items` Statusfeld akzeptiert ein JSON-Array, ein JSON-Objekt oder einen JSONata-Ausdruck, der zu einem Array oder Objekt ausgewertet werden muss.
## Reservierte Variable: $states
Step Functions definiert eine einzelne reservierte Variable namens **`$states`**. In JSonata-Zuständen werden die folgenden Strukturen `$states` zur Verwendung in JSonata-Ausdrücken zugewiesen:
```
# Reserved $states variable in JSONata states
$states = {
"input": // Original input to the state
"result": // API or sub-workflow's result (if successful)
"errorOutput": // Error Output (only available in a Catch)
"context": // Context object
}
```
Bei der Zustandseingabe weist Step Functions die Statuseingabe zu **`$states.input`**. Der Wert von `$states.input` kann in allen Feldern verwendet werden, die JSONata-Ausdrücke akzeptieren. `$states.input`bezieht sich immer auf die ursprüngliche Statuseingabe.
Für `Task``Parallel`, und gibt `Map` an:
+ **`$states.result`**bezieht sich auf das Rohergebnis der API oder des Unterworkflows, falls der Vorgang erfolgreich war.
+ **`$states.errorOutput`**bezieht sich auf die Fehlerausgabe, wenn die API oder der Unterworkflow fehlgeschlagen sind.
`$states.errorOutput`kann im `Catch` Feld `Assign` oder `Output` verwendet werden.
Der Versuch, auf Felder und Zustände zuzugreifen`$states.result`, auf die nicht zugegriffen werden kann, wird bei der Erstellung, Aktualisierung oder Überprüfung der Zustandsmaschine abgefangen. `$states.errorOutput`
Das `$states.context` Objekt stellt Ihren Workflows Informationen über deren spezifische Ausführung zur Verfügung, z. B. `StartTime` Aufgabentoken und erste Workflow-Eingaben. Weitere Informationen finden Sie unter[Zugreifen auf Ausführungsdaten aus dem Context-Objekt in Step Functions](input-output-contextobject.md).
## Behandlung von Ausdrucksfehlern
Zur Laufzeit kann die Auswertung von JSONata-Ausdrücken aus verschiedenen Gründen fehlschlagen, z. B.:
+ **Typfehler** — Ein Ausdruck, wie z. B., schlägt fehl`{% $x + $y %}`, wenn es sich um eine `$x` Zahl `$y` handelt oder nicht.
+ **Typinkompatibilität** — Ein Ausdruck kann einen Typ ergeben, den das Feld nicht akzeptiert. Das Feld `TimeoutSeconds` erfordert beispielsweise eine numerische Eingabe, sodass der Ausdruck `{% $timeout %}` fehlschlägt, wenn er eine Zeichenfolge `$timeout` zurückgibt.
+ **Wert außerhalb des zulässigen Bereichs** — Ein Ausdruck, der einen Wert erzeugt, der außerhalb des akzeptablen Bereichs für ein Feld liegt, schlägt fehl. Beispielsweise schlägt ein Ausdruck wie `{% $evaluatesToNegativeNumber %}` wird in dem `TimeoutSeconds` Feld fehl.
+ **Fehler beim Zurückgeben eines Ergebnisses** — JSON kann keinen Ausdruck mit undefiniertem Wert darstellen, daher `{% $data.thisFieldDoesNotExist %}` würde der Ausdruck zu einem Fehler führen.
+ **Speicherlimit überschritten** — Ein JSONata-Ausdruck, der während der Auswertung zu viel Speicher verbraucht, schlägt mit einem Fehler fehl. `Expression evaluation memory limit exceeded` Dies kann bei Ausdrücken der Fall sein, die große Datenmengen verarbeiten oder transformieren. Um diese Einschränkung zu umgehen, sollten Sie erwägen, die Datentransformation auf eine Lambda-Funktion umzustellen.
+ **Timeout für Ausdrücke** — Ein JSONata-Ausdruck, dessen Auswertung länger als 1 Sekunde dauert, schlägt mit einem Fehler fehl. `Expression evaluation timeout` Dies kann bei Ausdrücken auftreten, die Endlosschleifen oder sehr teure Operationen enthalten.
+ **Stack-Overflow** — Ein JSONata-Ausdruck, der die maximale Rekursionstiefe überschreitet, schlägt mit einer fehl. `Stack overflow error` Wenn die Rekursion nicht beendet wird, stellen Sie sicher, dass die Funktion einen korrekten Basisfall oder eine korrekte Abschlussbedingung hat. Wenn die Rekursion beendet wird, der Aufruf-Stack jedoch zu tief wird, sollten Sie erwägen, die Funktion als Tail-rekursiv umzuschreiben, um die Stapeltiefe zu verringern.
In jedem Fall gibt der Interpreter den Fehler aus:. `States.QueryEvaluationError` Ihre Status „Task“, „Map“ und „Parallel“ können ein `Catch` Feld catch Erfassung des Fehlers und ein `Retry` Feld zur Wiederholung des Fehlers bereitstellen.
## Konvertierung von JSONPath nach JSONata
In den folgenden Abschnitten werden die Unterschiede zwischen Code, der mit JSONPath und JSONata geschrieben wurde, verglichen und erklärt.
### Keine Pfadfelder mehr
ASL verlangt von Entwicklern, bei der Verwendung von JSONPath beispielsweise `Path` Feldversionen zu verwenden`TimeoutSecondsPath`, um einen Wert aus den Statusdaten auszuwählen. Wenn Sie JSONata verwenden, verwenden Sie keine Felder mehr, da ASL JSONata-Ausdrücke in `Path` Feldern, die nicht im `{% %}` Pfad enthalten sind, automatisch für Sie interpretiert, z. B. `TimeoutSeconds`
+ Beispiel für eine ältere Version von JSONPath: `"TimeoutSecondsPath": "$timeout"`
+ JSONata: `"TimeoutSeconds": "{% $timeout %}"`
Ebenso `ItemsPath` wurde der `Map` Status durch das `Items` Feld ersetzt, das ein JSON-Array, ein JSON-Objekt oder einen JSONata-Ausdruck akzeptiert, der zu einem Array oder Objekt ausgewertet werden muss.
### JSON-Objekte
ASL verwendet den Begriff *Payload-Vorlage*, um ein JSON-Objekt zu beschreiben, das JSONPath-Ausdrücke für `Parameters` und Feldwerte enthalten kann. `ResultSelector` ASL verwendet den Begriff Payload-Vorlage nicht für JSONata, da die JSONata-Auswertung für alle Zeichenketten erfolgt, unabhängig davon, ob sie eigenständig oder innerhalb eines JSON-Objekts oder eines JSON-Arrays vorkommen.
### Nicht mehr. $
ASL verlangt, dass Sie '`.$`' an Feldnamen in Payload-Vorlagen anhängen, um JSONPath und systeminterne Funktionen verwenden zu können. Wenn Sie angeben`"QueryLanguage":"JSONata"`, verwenden Sie nicht mehr die Konvention '`.$`' für Feldnamen von JSON-Objekten. Stattdessen schließen Sie JSONata-Ausdrücke in Zeichen ein. `{% %}` Sie verwenden dieselbe Konvention für alle Felder mit Zeichenkettenwerten, unabhängig davon, wie tief das Objekt in anderen Arrays oder Objekten verschachtelt ist.
### Argumente und Ausgabefelder
Wenn das auf gesetzt `QueryLanguage` ist`JSONata`, werden die alten I/O Verarbeitungsfelder deaktiviert (`InputPath`, `Parameters``ResultSelector`, `ResultPath` und`OutputPath`) und die meisten Staaten erhalten zwei neue Felder: `Arguments` und`Output`.
JSONata bietet im Vergleich zu den Feldern, die mit JsonPath verwendet werden, eine einfachere Methode zur Durchführung von I/O Transformationen. Die Funktionen von JSONata machen es `Output` leistungsfähiger als die `Arguments` vorherigen fünf Felder mit JSONPath. Diese neuen Feldnamen helfen auch dabei, Ihre ASL zu vereinfachen und das Modell für die Übergabe und Rückgabe von Werten zu verdeutlichen.
Die `Output` Felder `Arguments` und (und andere ähnliche Felder wie die des `Map` Bundesstaates`ItemSelector`) akzeptieren entweder ein JSON-Objekt wie:
```
"Arguments": {
"field1": 42,
"field2": "{% jsonata expression %}"
}
```
Oder Sie können einen JSONata-Ausdruck direkt verwenden, zum Beispiel:
```
"Output": "{% jsonata expression %}"
```
Die Ausgabe kann auch jede Art von JSON-Wert akzeptieren, zum Beispiel:`"Output":true`,. `"Output":42`
Die `Output` Felder `Arguments` und unterstützen nur JSONata, daher ist es ungültig, sie mit Workflows zu verwenden, die JSONPath verwenden. Umgekehrt werden,`InputPath`, `Parameters` `ResultSelector` `ResultPath``OutputPath`, und andere JSONPath-Felder nur in JSONPath unterstützt. Daher ist es nicht zulässig, pfadbasierte Felder zu verwenden, wenn Sie JSONata als oberste Workflow-Sprache oder Statusabfragesprache verwenden.
### Übergabezustand
*Der optionale Status **Result** in a Pass wurde bisher als Ausgabe einer virtuellen Aufgabe behandelt.* Wenn JSONata als Workflow- oder Statusabfragesprache ausgewählt ist, können Sie jetzt das neue **Ausgabefeld** verwenden.
### Status „Auswahl“
Bei der Verwendung von JSONPath haben Auswahlstatus eine Eingabe `Variable` und zahlreiche Vergleichspfade, wie z. B. die folgenden: `NumericLessThanEqualsPath`
```
# JSONPath choice state sample, with Variable and comparison path
"Check Price": {
"Type": "Choice",
"Default": "Pause",
"Choices": [
{
"Variable": "$.current_price.current_price",
"NumericLessThanEqualsPath": "$.desired_price",
"Next": "Send Notification"
} ],
}
```
Bei JSonata gibt es im Auswahlstatus eine Option, `Condition` in der Sie einen JSONata-Ausdruck verwenden können:
```
# Choice state after JSONata conversion
"Check Price": {
"Type": "Choice",
"Default": "Pause"
"Choices": [
{
"Condition": "{% $current_price <= $states.input.desired_priced %}",
"Next": "Send Notification"
} ]
```
Hinweis: Variablen und Vergleichsfelder sind nur für JSONPath verfügbar. Condition ist nur für JSONata verfügbar.
## JSonata-Beispiele
Die folgenden Beispiele können in Workflow Studio erstellt werden, um mit JSonata zu experimentieren. Sie können die Zustandsmaschinen erstellen und ausführen oder den **Teststatus** verwenden, um Daten zu übergeben und sogar die Zustandsmaschinen-Definition zu ändern.
### Beispiel: Eingabe und Ausgabe
Dieses Beispiel zeigt, wie Sie `$states.input` die Statuseingabe und das `Output` Feld verwenden, um die Statusausgabe anzugeben, wenn Sie sich für JSONata entscheiden.
```
{
"Comment": "Input and Output example using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "Basic Input and Output",
"States": {
"Basic Input and Output": {
"QueryLanguage": "JSONata",
"Type": "Succeed",
"Output": {
"lastName": "{% 'Last=>' & $states.input.customer.lastName %}",
"orderValue": "{% $states.input.order.total %}"
}
}
}
}
```
Wenn der Workflow mit dem Folgenden als Eingabe ausgeführt wird:
```
{
"customer": {
"firstName": "Martha",
"lastName": "Rivera"
},
"order": {
"items": 7,
"total": 27.91
}
}
```
Bei der Ausführung des Teststatus oder der Zustandsmaschine wird die folgende JSON-Ausgabe zurückgegeben:
```
{
"lastName": "Last=>Rivera",
"orderValue": 27.91
}
```
### Beispiel: Filterung mit JSonata
[Sie können Ihre Daten mit JSONata Path-Operatoren filtern.](https://docs.jsonata.org/path-operators) Stellen Sie sich beispielsweise vor, Sie haben eine Liste von Produkten zur Eingabe und möchten nur Produkte verarbeiten, die keine Kalorien enthalten. Sie können eine Zustandsmaschinen-Definition mit der folgenden ASL erstellen und den `FilterDietProducts` Status mit der folgenden Beispieleingabe testen.
**State-Machine-Definition für die Filterung mit JSonata**
```
{
"Comment": "Filter products using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "FilterDietProducts",
"States": {
"FilterDietProducts": {
"Type": "Pass",
"Output": {
"dietProducts": "{% $states.input.products[calories=0] %}"
},
"End": true
}
}
}
```
**Beispieleingabe für den Test**
```
{
"products": [
{
"calories": 140,
"flavour": "Cola",
"name": "Product-1"
},
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 160,
"flavour": "Orange",
"name": "Product-3"
},
{
"calories": 100,
"flavour": "Orange",
"name": "Product-4"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
**Ergebnis des Testens des Schritts in Ihrer Zustandsmaschine**
```
{
"dietProducts": [
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
### Beispiel: Verwendung der vorherigen Statusausgabe in einem Map-Status
Dieses Beispiel zeigt, wie die Ausgabe eines vorherigen Status als Eingabe für einen Map-Status mit JSONata verwendet wird. Der folgende Workflow verwendet den Status Pass, um eine Aufgabe zu simulieren, die eine Bestellung mit einer Liste von Elementen zurückgibt. Anschließend wählt ein Map-Status das Artikel-Array aus dieser Ausgabe aus und iteriert darüber.
**Zustandsmaschine (Definition)**
```
{
"Comment": "Example: Using previous state output in a Map state with JSONata",
"QueryLanguage": "JSONata",
"StartAt": "GetOrder",
"States": {
"GetOrder": {
"Type": "Pass",
"Output": {
"orderId": "{% $states.input.orderId %}",
"items": "{% $states.input.items %}"
},
"Next": "ProcessItems"
},
"ProcessItems": {
"Type": "Map",
"Items": "{% $states.input.items %}",
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "CalculateItemTotal",
"States": {
"CalculateItemTotal": {
"Type": "Pass",
"Output": {
"name": "{% $states.input.name %}",
"total": "{% $states.input.price * $states.input.quantity %}"
},
"End": true
}
}
},
"End": true
}
}
}
```
In dieser Definition gibt der `GetOrder` Staat die Auftragsdaten unverändert aus. Der `ProcessItems` Map-Status wird verwendet`"Items": "{% $states.input.items %}"`, um das `items` Array aus der Ausgabe von auszuwählen`GetOrder`. Jede Iteration erhält einen Artikel aus dem Array und berechnet den Gesamtwert des Artikels, indem der Preis mit der Menge multipliziert wird.
**Beispieleingabe**
```
{
"orderId": "ORD-1234",
"items": [
{
"name": "Widget",
"price": 4.99,
"quantity": 3
},
{
"name": "Gadget",
"price": 12.50,
"quantity": 2
},
{
"name": "Bolt",
"price": 0.75,
"quantity": 10
}
]
}
```
**Erwartete Ausgabe**
```
[
{
"name": "Widget",
"total": 14.97
},
{
"name": "Gadget",
"total": 25
},
{
"name": "Bolt",
"total": 7.5
}
]
```
### Beispiel: Reduzieren der Ausgabe im parallelen Zustand
Wenn Sie den Status Parallel verwenden, wird ein Array zurückgegeben, in dem jedes Element die Ausgabe eines Zweigs ist. Mit JSONata können Sie das `Output` Feld im Parallel-Status verwenden, um diese Ergebnisse zu reduzieren oder zu einem einzigen Objekt zusammenzuführen. Dieser Ansatz ersetzt das Feld JSONPath. `ResultSelector`
Im folgenden Beispiel wird ein Parallelstatus mit zwei Verzweigungen verwendet. Jeder Zweig simuliert einen GetItem DynamoDB-Aufruf mithilfe eines Pass-Zustands. Der Parallel-Status verwendet `$merge($states.result)` in seinem `Output` Feld, um die Verzweigungsergebnisse zu einem einzigen Objekt zusammenzuführen.
**Zustandsmaschine (Definition)**
```
{
"Comment": "Example: Flattening Parallel state output with JSONata",
"QueryLanguage": "JSONata",
"StartAt": "GetOrderAndCustomer",
"States": {
"GetOrderAndCustomer": {
"Type": "Parallel",
"Output": "{% $merge($states.result) %}",
"Branches": [
{
"StartAt": "Get Order",
"States": {
"Get Order": {
"Type": "Pass",
"Output": {
"orderId": "{% $states.input.orderId %}",
"orderDate": "2024-11-20",
"total": 35.99
},
"End": true
}
}
},
{
"StartAt": "Get Customer",
"States": {
"Get Customer": {
"Type": "Pass",
"Output": {
"customerId": "{% $states.input.customerId %}",
"customerName": "Martha Rivera",
"email": "martha@example.com"
},
"End": true
}
}
}
],
"Next": "Done"
},
"Done": {
"Type": "Succeed"
}
}
}
```
**Beispieleingabe**
```
{
"orderId": "12345",
"customerId": "C-100"
}
```
**Erwartete Ausgabe**
```
{
"orderId": "12345",
"orderDate": "2024-11-20",
"total": 35.99,
"customerId": "C-100",
"customerName": "Martha Rivera",
"email": "martha@example.com"
}
```
Die `$merge()` Funktion kombiniert eine Reihe von Objekten zu einem einzigen Objekt. Wenn Verzweigungen Objekte mit überlappenden Schlüsseln zurückgeben, haben spätere Array-Elemente Vorrang. Die Verzweigungsergebnisse sind konsistent angeordnet — sie entsprechen der Reihenfolge des `Branches` Arrays in der State-Machine-Definition.
## Von Step Functions bereitgestellte JSONata-Funktionen
JSONata enthält Funktionsbibliotheken für Funktionen vom Typ String, Numeric, Aggregation, Boolean, Array, Object und High Order. Date/Time Step Functions bietet zusätzliche JSonata-Funktionen, die Sie in Ihren JSonata-Ausdrücken verwenden können. Diese integrierten Funktionen dienen als Ersatz für die intrinsischen Funktionen von Step Functions. Systeminterne Funktionen sind nur in Staaten verfügbar, die die JSONPath-Abfragesprache verwenden.
Hinweis: Built-in JSONata-Funktionen, die Ganzzahlwerte als Parameter benötigen, runden automatisch alle angegebenen Zahlen ab, die keine Ganzzahlen sind.
**$partition —** JSONata-Äquivalent einer `States.ArrayPartition` systemeigenen Funktion zur Partitionierung eines großen Arrays.
Der erste Parameter ist das zu partitionierende Array, der zweite Parameter ist eine Ganzzahl, die die Chunk-Größe darstellt. Der Rückgabewert wird ein zweidimensionales Array sein. 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.
```
"Assign": {
"arrayPartition": "{% $partition([1,2,3,4], $states.input.chunkSize) %}"
}
```
**$range** — JSONata-Äquivalent zur systemeigenen Funktion zur Generierung eines `States.ArrayRange` Wertearrays.
Diese Funktion benötigt drei Argumente. Das erste Argument ist eine Ganzzahl, die das erste Element des neuen Arrays darstellt, das zweite Argument ist eine Ganzzahl, die das letzte Element des neuen Arrays darstellt, und das dritte Argument ist die Ganzzahl mit Deltawert für die Elemente im neuen Array. Der Rückgabewert ist ein neu generiertes Array von Werten, das vom ersten Argument der Funktion bis zum zweiten Argument der Funktion reicht, wobei die dazwischen liegenden Elemente durch das Delta angepasst werden. Der Deltawert kann positiv oder negativ sein, wodurch jedes Element vom letzten Element bis zum Erreichen oder Überschreiten des Endwerts erhöht oder verringert wird.
```
"Assign": {
"arrayRange": "{% $range(0, 10, 2) %}"
}
```
**$hash** — JSONata-Äquivalent der `States.Hash` systemeigenen Funktion zur Berechnung des Hashwerts einer bestimmten Eingabe.
Diese Funktion benötigt zwei Argumente. Das erste Argument ist die Quellzeichenfolge, die gehasht werden soll. Das zweite Argument ist eine Zeichenfolge, die den Hash-Algorithmus für die Hash-Berechnung darstellt. Der Hash-Algorithmus muss einen der folgenden Werte haben:`"MD5"`,,, `"SHA-1"``"SHA-256"`,`"SHA-384"`. `"SHA-512"` Der Rückgabewert ist eine Zeichenfolge mit dem berechneten Hash der Daten.
Diese Funktion wurde erstellt, weil JSONata die Fähigkeit zur Berechnung von Hashes nicht nativ unterstützt.
```
"Assign": {
"myHash": "{% $hash($states.input.content, $hashAlgorithmName) %}"
}
```
**$random** — JSONata-Äquivalent der systemeigenen Funktion zur Rückgabe einer `States.MathRandom` Zufallszahl n where. `0 ≤ n < 1`
Die Funktion verwendet ein *optionales* Integer-Argument, das den Startwert der Zufallsfunktion darstellt. Wenn Sie diese Funktion mit demselben Ausgangswert verwenden, gibt sie eine identische Zahl zurück.
Diese überladene Funktion wurde erstellt, weil die integrierte JSONata-Funktion [https://docs.jsonata.org/numeric-functions#random](https://docs.jsonata.org/numeric-functions#random)keinen Startwert akzeptiert.
```
"Assign": {
"randNoSeed": "{% $random() %}",
"randSeeded": "{% $random($states.input.seed) %}"
}
```
**$uuid** — JSONata-Version der systemeigenen Funktion. `States.UUID`
Die Funktion akzeptiert keine Argumente. Diese Funktion gibt eine v4-UUID zurück.
Diese Funktion wurde erstellt, weil JSONata die Fähigkeit, UUIDs zu generieren, nicht nativ unterstützt.
```
"Assign": {
"uniqueId": "{% $uuid() %}"
}
```
**$parse** - JSONata-Funktion zum Deserialisieren von JSON-Strings.
Die Funktion verwendet ein stringifiziertes JSON als einziges Argument.
JSonata unterstützt diese Funktionalität über`$eval`; `$eval` wird jedoch in Step Functions Functions-Workflows nicht unterstützt.
```
"Assign": {
"deserializedPayload": "{% $parse($states.input.json_string) %}"
}
```