JMESPath语言

2023-12-17 18:40:55

JMESPath（JSON Matching Expression Path）

一种查询语言。

主要用于从JSON文档中检索和过滤数据。

通过写表达式提取和处理JSON数据，而无需编写复杂的代码。

功能：数据提取、过滤、转换、排序。

场景：处理API响应、数据分析、数据转换 etc。

数据提取：从复杂的JSON文档中提取所需的信息。例如，从包含多个嵌套对象和数组的JSON文档中提取特定属性。

数据过滤：基于特定条件过滤JSON数据。例如，从一个包含多个对象的数组中过滤出满足特定属性值条件的对象。

数据转换：将JSON数据转换为其他格式。例如，将一个包含多个属性的对象转换为一个只包含部分属性的新对象，或将一个数组转换为一个新的数组，其中的元素经过特定计算或操作。

数据排序：根据特定属性对JSON数据进行排序。

JMESPath — JMESPathicon-default.png?t=N7T8https://jmespath.org/

本文主要以 JMESPath Tutorial and?Examples 为操作示例，还有包括一些其他常用示例：

目录

一些常用调用方式

一些常用表达式

一些常用嵌套语句

一些常用调用方式

源jmespath结果备注
{
? "demo": "hello world"
}		demo"hello world"str
{
? "demo": 1
}		demo1int
{
? "demo": ["1", "2"]
}

demo /?demo[*] /?demo[:] / demo[]

 
[
  "1",
  "2"
]
array
{
? "demo": {
? ? "key": "value",
? ? "k": "v",
? ? "a": {"b": "c"}
? }
}		demo 
{
  "key": "value",
  "k": "v",
  "a": {
    "b": "c"
  }
}
object
{}demonullnull

元素获取

源jmespath结果备注
{
? "demo": {
? ? "key": "value",
? ? "k": "v",
? ? "a": {"b": "c"}
? }
}		demo.key / demo."key""value"
同上demo.a.b"c"
同上demo.[key, k] 
[
"value",
  "v"
]
同上demo.{"k1": key, "k2": k} /?demo.{k1: key, k2: k} 
{
  "k1": "value",
  "k2": "v"
}
{"d":{}}d{}
{
? "demo": [1, 2, 3]
}		demo[0] /?demo[:1]1
{"d":[]}d[]
同上demo[2:]3slice：[start:stop:step]或[start:stop]，step为负则倒取
同上demo[3]null
同上demo[1:3][2, 3]slice
同上demo[::-1] 
[3, 2, 1]
slice
同上demo[::2] 
[1,3]
slice

一些常用表达式

源jmespath结果备注
{
? "demo": [1, 2, 3]
}		to_string(demo) 
"[1,2,3]"
转字符串 to_string（打平显示使用）
同上length(demo)3长度 length
同上type(demo) 
"array"
{
? "demo": {
? ? "key": "value",
? ? "k": "v",
? ? "a": {"b": "c"}
? }
}		to_string(demo)

"{\"key\":\"value\",\"k\":\"v\",\"a\":{\"b\":\"c\"}}"

同上length(demo)3
同上type(demo) 
"object"
{"a": "1.1"}to_number(a)1.1to number转数字
{
? "demo": [1, 2, 19]
}		max(demo)19max最大值
同上min(demo)1min最小值
同上avg(demo) 
7.333333333333333
avg平均数（显示长度控制在16位）
同上sum(demo)22sum和
同上hhh || demo[0]1|| ??
同上demo[1] || demo[2]2
同上demo[1] && demo[2]19&&?
{
? "a": [
? ? {
? ? ? "b1": "James",
? ? ? "b2": "d",
? ? ? "c": 30
? ? },
? ? {
? ? ? "b1": "Jacob",
? ? ? "b2": "e",
? ? ? "c": 35
? ? },
? ? {
? ? ? "b1": "Jayden",
? ? ? "b2": "f",
? ? ? "c": 25
? ? }
? ]
}		a[?c > `18`] 
[
  {
    "b1": "Jacob",
    "b2": "e",
    "c": 20
  },
  {
    "b1": "Jayden",
    "b2": "f",
    "c": 23
  }
]
条件选择 filter
同上a[?c > `18`].{b1: b1, age: c} 
[
  {
    "b1": "Jacob",
    "age": 20
  },
  {
    "b1": "Jayden",
    "age": 23
  }
]
同上a[?c==`18`] 
[
  {
    "b1": "James",
    "b2": "d",
    "c": 18
  }
]
同上a[?c==`18`].{b1: b1, age: c} 
[
  {
    "b1": "James",
    "age": 18
  }
]
???????
同上a[?c==`20`].[b1, b2] 
[
  [
    "Jacob",
    "e"
  ]
]
同上a[?c==`20`].[b1, b2] | [] /?a[?c==`20`].[b1, b2] | [0] 
[
  "Jacob",
  "e"
]

管道表达式。

?| [] 或 | [0]的写法能消除嵌套下的外[]

同上a | [0] / a | [] 
{
  "b1": "James",
  "b2": "d",
  "c": 18
}
同上a | [1] 
{
  "b1": "Jacob",
  "b2": "e",
  "c": 20
}
{"a":[{"b1":"詹姆斯","b2":"d","c":30},{"b1":"雅各布","b2":"e","c":35},{"b1":"杰登","b2":"f","c":25}]}sort_by(a, &c) 
[
  {
    "b1": "杰登",
    "b2": "f",
    "c": 25
  },
  {
    "b1": "詹姆斯",
    "b2": "d",
    "c": 30
  },
  {
    "b1": "雅各布",
    "b2": "e",
    "c": 35
  }
]
sort_by排序
{
? "a": [
? ? "foo",
? ? "foobar",
? ? "barfoo",
? ? "bar",
? ? "barbaz",
? ? "barfoobaz"
? ]
}		a[?contains(@, 'foo') == `true`] 
["foo"，"foobar"，"barfoo"，barfoobaz]
字符匹配 contains与匿名@

一些常用嵌套语句

嵌套调用

源jmespath结果备注
{"a": {
? ? "c": [
? ? ? {"d": [0, [1, 2]]}
? ? ]
}}		a.c[0].d[1][0]1
{
? "a": [
? ? {
? ? ? "b1": "James",
? ? ? "b2": "d",
? ? ? "c": 30
? ? },
? ? {
? ? ? "b1": "Jacob",
? ? ? "b2": "e",
? ? ? "c": 35
? ? },
? ? {
? ? ? "b1": "Jayden",
? ? ? "b2": "f",
? ? ? "c": 25
? ? }
? ]
}		a[*].b1 / a[].b1 / a[:].b1 
[
  "James",
  "Jacob",
  "Jayden"
]
同上a[*].[b1, b2]

[

? ["James", "d"],

? ["Jacob", "e"],

? ["Jayden", "f"]

]

同上a[*].[*]

[

? [["James", "d", 30]],

? [["Jacob", "e", 35]],

? [["Jayden", "f", 25]]

]

同上a[*].{b1: b1, "b2": `1`} 
[
  {
    "b1": "James",
    "b2": 1
  },
  {
    "b1": "Jacob",
    "b2": 1
  },
  {
    "b1": "Jayden",
    "b2": 1
  }
]
同上a[::2].{b1: b1, "b2": `1`} 
[
  {
    "b1": "James",
    "b2": 1
  },
  {
    "b1": "Jayden",
    "b2": 1
  }
]
{
? ? "a": {
? ? ? ? "a1": {
? ? ? ? ? ? "b1": "James",
? ? ? ? ? ? "b2": "d",
? ? ? ? ? ? "c": 30
? ? ? ? },
? ? ? ? "a2": {
? ? ? ? ? ? "b1": "Jacob",
? ? ? ? ? ? "b2": "e",
? ? ? ? ? ? "c": 35
? ? ? ? },
? ? ? ? "a3": {
? ? ? ? ? ? "b1": "Jayden",
? ? ? ? ? ? "b2": "f",
? ? ? ? ? ? "c": 25
? ? ? ? }
? ? }
}		a.*.c 
[
  30,
  35,
  25
]
同上a.*.*

[

? ["James", "d", 30],

? ["Jacob", "e", 35],

? ["Jayden", "f", 25]

]

???????

文章来源:https://blog.csdn.net/lxd_max/article/details/135006599
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。