如何用JsonPath合并对象及筛选指定键元素生成单一对象？

Great questions about JsonPath! Let's break them down one by one:

First off, it's important to note that JsonPath is primarily a query language—its core purpose is to extract data from JSON structures, not modify or merge them directly. That said, you can absolutely use JsonPath to target the objects you want to merge, then handle the merging logic in your host programming language (like Python, Java, JavaScript, etc.).

Here's a concrete example using Python and the jsonpath-ng library:

Suppose you have this JSON data:

{
  "user": {
    "profile": {"name": "Alice", "age": 30},
    "settings": {"theme": "dark", "notifications": true}
  }
}

You want to merge the profile and settings objects. Here's how to do it:

import json
from jsonpath_ng import parse

# Load your JSON data
json_str = '''{
  "user": {
    "profile": {"name": "Alice", "age": 30},
    "settings": {"theme": "dark", "notifications": true}
  }
}'''
data = json.loads(json_str)

# Step 1: Use JsonPath to extract the two objects you want to merge
profile = parse("$.user.profile").find(data)[0].value
settings = parse("$.user.settings").find(data)[0].value

# Step 2: Merge them using Python's dictionary unpacking
merged_object = {**profile, **settings}

print(merged_object)
# Output: {'name': 'Alice', 'age': 30, 'theme': 'dark', 'notifications': True}

In Java (using Jayway JsonPath), you'd do something similar: extract the two objects as Maps, then use putAll() to merge them.

This one depends a bit on your exact JSON structure, but the core idea is the same as above: JsonPath can help you extract the relevant key-value pairs, but you'll need to assemble them into a single object using your host language.

Let's walk through two common scenarios:

Scenario 1: Target keys are in a single parent object #

If your JSON looks like this (all target keys live under one object):

{
  "data": {
    "a": "foo",
    "b": "bar",
    "e": "ignore-me",
    "c": "baz",
    "d": "qux",
    "f": "also-ignore"
  }
}

You can use JsonPath to directly select the target keys:

# Extract just the a/b/c/d keys
target_values = parse("$.data['a','b','c','d']").find(data)
# Now map the keys to their values
result = {match.path.right.value: match.value for match in target_values}

print(result)
# Output: {'a': 'foo', 'b': 'bar', 'c': 'baz', 'd': 'qux'}

Scenario 2: Target keys are scattered across an array of objects #

If your JSON has an array where each item might contain some of the target keys (like your mention of filtering objects with key 'c'):

{
  "items": [
    {"a": 1, "x": 99},
    {"b": 2, "y": 88},
    {"c": 3, "z": 77},
    {"d": 4, "w": 66},
    {"e": 5, "v": 55}
  ]
}

Here's how to gather all a/b/c/d keys into one object:

target_keys = {"a", "b", "c", "d"}
result = {}

# Extract all items in the array
items = parse("$.items[*]").find(data)

# Iterate through each item and collect the target keys
for item in items:
    item_data = item.value
    # Only take keys that are in our target list
    for key in target_keys.intersection(item_data.keys()):
        result[key] = item_data[key]

print(result)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

A quick note on pure JsonPath limitations #

You might be wondering if you can do this with just a JsonPath expression—and the short answer is no, not with standard JsonPath implementations. JsonPath returns collections of values or objects, not a single merged object. The assembly step has to happen in your code, where you can handle edge cases like duplicate keys (later values will overwrite earlier ones in the example above).

内容的提问来源于stack exchange，提问作者Semi