Intrinsische Funktionen - AWS Step Functions

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.

Intrinsische Funktionen

Die Sprache von Amazon States bietet mehrere systeminterne Funktionen, auch als systeminterne Funktionen bezeichnet, mit denen Sie grundlegende Datenverarbeitungsvorgänge durchführen können, ohne einen Status zu verwenden. Task Intrinsics sind Konstrukte, die Funktionen in Programmiersprachen ähneln. Sie können verwendet werden, um Payload Builder bei der Verarbeitung der Daten zu unterstützen, die zum und vom Resource Feld eines Bundesstaates gesendet werden. Task

In Amazon States Language werden systeminterne Funktionen je nach Art der Datenverarbeitungsaufgabe, die Sie ausführen möchten, in die folgenden Kategorien eingeteilt:

Anmerkung
  • Um systeminterne Funktionen verwenden zu können, müssen Sie den Schlüsselwert .$ in Ihren State-Machine-Definitionen 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 NamenmyArn, 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))"
Tipp

Wenn Sie Step Functions in einer lokalen Entwicklungsumgebung verwenden, stellen Sie sicher, dass Sie Version 1.12.0 oder höher verwenden, um alle intrinsischen Funktionen in Ihre Workflows aufnehmen zu können.

Felder, die systeminterne Funktionen unterstützen

Die folgende Tabelle zeigt, welche Felder systemeigene Funktionen für jeden Status unterstützen.

Felder, die systeminterne Funktionen unterstützen
State
Passieren Aufgabe Wahl Wait Erfolgreich sein Scheitern Parallel Zuordnung
InputPath
Parameter
ResultSelector
ResultPath
OutputPath
Variable
<Comparison Operator>Pfad
TimeoutSecondsPath
HeartbeatSecondsPath
Anmeldeinformationen

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 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 der Eingabe

  • 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 KB nicht überschreiten.

Nehmen wir zum Beispiel das folgende Eingabe-Array an:

{"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 bei 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 der Eingabe

  • 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 KB nicht überschreiten.

Nehmen wir zum Beispiel das folgende Eingabe-Array an:

{ "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 }
States.ArrayRange

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 der Eingabe

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

Intrinsik 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 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 } }
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ügungunescapedJson:

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 Endnummer und das letzte Argument steuert den Startwert. Das Startwert-Argument ist optional. Wenn Sie diese Funktion mit demselben Ausgangswert verwenden, gibt sie eine identische Zahl zurück.

Wichtig

Da die States.MathRandom Funktion keine kryptografisch sicheren Zufallszahlen zurückgibt, empfehlen wir, sie nicht für sicherheitsrelevante Anwendungen zu verwenden.

Überprüfung der Eingabe

  • Sie müssen Ganzzahlwerte für die Argumente Startnummer und Endnummer angeben.

    Wenn Sie für das Argument Startnummer 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 der Eingabe

  • 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.

Beispiel - Teilt eine Eingabezeichenfolge mit einem einzigen Trennzeichen

Verwenden Sie in diesem Beispiel, States.StringSplit um Folgendes zu teileninputString, 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"] }
Beispiel - Teilt eine Eingabezeichenfolge mit mehreren Trennzeichen auf

Verwenden Sie in diesem Beispiel, States.StringSplit um Folgendes zu unterteileninputString, 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 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)

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 ('\') maskiert werden, wenn sie im Wert vorkommen sollen:, und. ' { } \

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.