Zum Inhalt

JSON mit JMESPath abfragen#

JMESPath ist eine Abfragesprache für JSON, mit der Sie Elemente aus einem JSON-Dokument extrahieren und transformieren können. Ausführliche Informationen zur Verwendung von JMESPath finden Sie in der JMESPath-Dokumentation.

Die jmespath() Methode#

Localmind Automate bietet eine benutzerdefinierte Methode, jmespath(). Verwenden Sie diese Methode, um eine Suche in einem JSON-Objekt mit der JMESPath-Abfragesprache durchzuführen.

Die grundlegende Syntax lautet:

1
$jmespath(object, searchString)

1
_jmespath(object, searchString)

Um besser zu verstehen, was die Methode bewirkt, hier die äquivalente längere JavaScript-Version:

1
2
var jmespath = require('jmespath');
jmespath.search(object, searchString);

Ausdrücke müssen einzeilig sein

Das längere Codebeispiel funktioniert nicht in Ausdrücken, da diese einzeilig sein müssen.

object ist ein JSON-Objekt, z. B. die Ausgabe eines vorherigen Knotens. searchString ist ein Ausdruck in der JMESPath-Abfragesprache. Die JMESPath-Spezifikation enthält eine Liste der unterstützten Ausdrücke, während ihr Tutorial und ihre Beispiele interaktive Beispiele bieten.

Suchparameterreihenfolge

Die Beispiele in der JMESPath-Spezifikation folgen dem Muster search(searchString, object). Die JMESPath-JavaScript-Bibliothek, die Localmind Automate verwendet, unterstützt stattdessen search(object, searchString). Dies bedeutet, dass Sie bei der Verwendung von Beispielen aus der JMESPath-Dokumentation möglicherweise die Reihenfolge der Suchfunktionsparameter ändern müssen.

Häufige Aufgaben#

Dieser Abschnitt enthält Beispiele für einige häufige Operationen. Weitere Beispiele und detaillierte Anleitungen finden Sie in der JMESPath eigenen Dokumentation.

Wenn Sie diese Beispiele ausprobieren, müssen Sie den Modus des Code-Knotens auf Einmal für jedes Element ausführen einstellen.

Anwenden eines JMESPath-Ausdrucks auf eine Sammlung von Elementen mit Projektionen#

Aus der JMESPath-Dokumentation zu Projektionen:

Projektionen sind eines der Hauptmerkmale von JMESPath. Verwenden Sie sie, um einen Ausdruck auf eine Sammlung von Elementen anzuwenden. JMESPath unterstützt fünf Arten von Projektionen:

  • Listenprojektionen
  • Slice-Projektionen
  • Objektprojektionen
  • Flatten-Projektionen
  • Filterprojektionen

Das folgende Beispiel zeigt die grundlegende Verwendung von Listen-, Slice- und Objektprojektionen. Ausführliche Erklärungen zu den einzelnen Projektionstypen und weitere Beispiele finden Sie in der JMESPath-Dokumentation zu Projektionen.

Gegeben dieses JSON von einem Webhook-Knoten:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
[
  {
    "headers": {
      "host": "Localmind Automate.instance.address",
      ...
    },
    "params": {},
    "query": {},
    "body": {
      "people": [
        {
          "first": "James",
          "last": "Green"
        },
        {
          "first": "Jacob",
          "last": "Jones"
        },
        {
          "first": "Jayden",
          "last": "Smith"
        }
      ],
      "dogs": {
        "Fido": {
          "color": "brown",
          "age": 7
        },
        "Spot": {
          "color": "black and white",
          "age": 5
        }
      }
    }
  }
]

Abrufen einer Liste aller Vornamen der Personen:

1
2
{{$jmespath($json.body.people, "[*].first" )}}
// Gibt ["James", "Jacob", "Jayden"] zurück

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let firstNames = $jmespath($json.body.people, "[*].first" )
return {firstNames};
/* Gibt zurück:
[
	{
		"firstNames": [
			"James",
			"Jacob",
			"Jayden"
		]
	}
]
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
firstNames = _jmespath(_json.body.people, "[*].first" )
return {"firstNames":firstNames}
"""
Gibt zurück:
[
 	{
		"firstNames": [
			"James",
			"Jacob",
			"Jayden"
		]
	}
]
"""

Abrufen eines Slice der Vornamen:

1
2
{{$jmespath($json.body.people, "[:2].first")}}
// Gibt ["James", "Jacob"] zurück

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let firstTwoNames = $jmespath($json.body.people, "[:2].first");
return {firstTwoNames};
/* Gibt zurück:
[
	{
		"firstNames": [
			"James",
			"Jacob",
			"Jayden"
		]
	}
]
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
firstTwoNames = _jmespath(_json.body.people, "[:2].first" )
return {"firstTwoNames":firstTwoNames}
"""
Gibt zurück:
[
	{
		"firstTwoNames": [
		"James",
		"Jacob"
		]
	}
]
"""

Abrufen einer Liste der Altersangaben der Hunde mithilfe von Objektprojektionen:

1
2
{{$jmespath($json.body.dogs, "*.age")}}
// Gibt [7,5] zurück

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let dogsAges = $jmespath($json.body.dogs, "*.age");
return {dogsAges};
/* Gibt zurück:
[
	{
		"dogsAges": [
			7,
			5
		]
	}
]
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
dogsAges = _jmespath(_json.body.dogs, "*.age")
return {"dogsAges": dogsAges}
"""
Gibt zurück:
[
	{
		"dogsAges": [
			7,
			5
		]
	}
]
"""

Auswählen mehrerer Elemente und Erstellen einer neuen Liste oder eines neuen Objekts#

Verwenden Sie Multiselect, um Elemente aus einem JSON-Objekt auszuwählen und zu einer neuen Liste oder einem neuen Objekt zusammenzufassen.

Gegeben dieses JSON von einem Webhook-Knoten:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
[
  {
    "headers": {
      "host": "Localmind Automate.instance.address",
      ...
    },
    "params": {},
    "query": {},
    "body": {
      "people": [
        {
          "first": "James",
          "last": "Green"
        },
        {
          "first": "Jacob",
          "last": "Jones"
        },
        {
          "first": "Jayden",
          "last": "Smith"
        }
      ],
      "dogs": {
        "Fido": {
          "color": "brown",
          "age": 7
        },
        "Spot": {
          "color": "black and white",
          "age": 5
        }
      }
    }
  }
]

Verwenden Sie die Multiselect-Liste, um die Vor- und Nachnamen abzurufen und neue Listen zu erstellen, die beide Namen enthalten:

1
2
{{$jmespath($json.body.people, "[].[first, last]")}}
// Gibt [["James","Green"],["Jacob","Jones"],["Jayden","Smith"]] zurück

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
let newList = $jmespath($json.body.people, "[].[first, last]");
return {newList};
/* Gibt zurück:
[
	{
		"newList": [
			[
				"James",
				"Green"
			],
			[
				"Jacob",
				"Jones"
			],
			[
				"Jayden",
				"Smith"
			]
		]
	}
]
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
newList = _jmespath(_json.body.people, "[].[first, last]")
return {"newList":newList}
"""
Gibt zurück:
[
	{
		"newList": [
			[
				"James",
				"Green"
			],
			[
				"Jacob",
				"Jones"
			],
			[
				"Jayden",
				"Smith"
			]
		]
	}
]
"""

Eine Alternative zu Pfeilfunktionen in Ausdrücken#

Erzeugen Sie beispielsweise einige Eingabedaten, indem Sie den folgenden Code vom Code-Knoten zurückgeben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
return[
  {
    "json": {      
      "num_categories": "0",
      "num_products": "45",
      "category_id": 5529735,
      "parent_id": 1407340,
      "pos_enabled": 1,
      "pos_favorite": 0,
      "name": "HP",
      "description": "",
      "image": ""
    }
  },
  {
    "json": {
      "num_categories": "0",
      "num_products": "86",
      "category_id": 5529740,
      "parent_id": 1407340,
      "pos_enabled": 1,
      "pos_favorite": 0,
      "name": "Lenovo",
      "description": "",
      "image": ""
    }
  }  
]

Sie könnten eine Suche wie "Finde das Element mit dem Namen Lenovo und nenne mir die Kategorie-ID" durchführen.

1
{{ $jmespath($("Code").all(), "[?json.name=='Lenovo'].json.category_id") }}