JSONPath क्या है?
JSONPath एक query language है जो JSON दस्तावेज़ों से मान निकालने के लिए उपयोग की जाती है। इसे मूल रूप से 2007 में Stefan Goessner ने XML के लिए XPath के समकक्ष के रूप में प्रस्तावित किया था। JSONPath आपको $.store.book[*].author जैसे एक्सप्रेशन लिखने देता है जो लूप या मैन्युअल traversal कोड लिखे बिना book array के अंदर सभी author फ़ील्ड चुनता है। इस भाषा को फरवरी 2024 में IETF द्वारा RFC 9535 के रूप में मानकीकृत किया गया।
एक JSONPath एक्सप्रेशन हमेशा $ से शुरू होता है जो document का root node दर्शाता है। वहाँ से आप selectors को जोड़ते हैं: object keys के लिए dot notation, array indices के लिए bracket notation, सभी children के लिए wildcards, और nesting के हर स्तर पर खोज के लिए recursive descent operator (..)। [?(@.price < 10)] जैसे filter expressions आपको उनकी values के आधार पर conditions लगाकर elements चुनने देते हैं।
JSONPath का उपयोग Postman जैसे API testing tools, Datadog और Splunk जैसे observability platforms, Apache NiFi जैसे workflow engines, और JavaScript, Python, Go, Java, और C# में programming libraries में किया जाता है। कोड या config files में एम्बेड करने से पहले अपने एक्सप्रेशन को real data पर टेस्ट करने से silent failures से बचा जा सकता है जब JSON structure आपकी assumptions से मेल नहीं खाती।
इस JSONPath Tester का उपयोग क्यों करें?
JSONPath एक्सप्रेशन हाथ से लिखना त्रुटि-प्रवण है। एक गुम dot, गलत bracket type, या गलत filter syntax खाली परिणाम बिना किसी error message के दे सकता है। यह tool आपको तुरंत visual feedback देता है कि आपका एक्सप्रेशन क्या match करता है।
JSONPath के उपयोग के मामले
JSONPath Syntax संदर्भ
RFC 9535 मानक JSONPath syntax को परिभाषित करता है। नीचे की तालिका उन operators को cover करती है जिनका उपयोग आप अधिकांश queries में करेंगे। सभी एक्सप्रेशन $ (root node) से शुरू होते हैं और document structure को navigate करने के लिए एक या अधिक selectors जोड़ते हैं।
| Operator | विवरण | उदाहरण |
|---|---|---|
| $ | Root element | $.store |
| .key | Child property | $.store.book |
| [n] | Array index (zero-based) | $.store.book[0] |
| [*] | All elements in array/object | $.store.book[*] |
| .. | Recursive descent | $..author |
| [start:end] | Array slice | $.store.book[0:2] |
| [?()] | Filter expression | $.store.book[?(@.price<10)] |
| @ | Current node (inside filter) | $.store.book[?(@.isbn)] |
JSONPath बनाम jq बनाम XPath
JSONPath, jq, और XPath अलग-अलग formats और use cases के लिए एक ही समस्या (structured data query करना) हल करते हैं। JSONPath JSON को target करता है और अधिकांश languages में library के रूप में उपलब्ध है। jq एक standalone CLI tool है जिसकी अपनी Turing-complete filter language है। XPath XML पर काम करता है और W3C specification stack का हिस्सा है।
| विशेषता | JSONPath | jq | XPath |
|---|---|---|---|
| Data format | JSON | JSON | XML |
| पहला element access करना | $.store.book[0] | .store.book[0] | /store/book[1] |
| Recursive search | $..price | .. | .price? | //price |
| Filter expression | [?(@.price<10)] | select(.price < 10) | [price<10] |
| Specification | RFC 9535 | stedolan.github.io | W3C XPath 3.1 |
Code उदाहरण
लोकप्रिय languages और tools में JSONPath एक्सप्रेशन evaluate करने का तरीका। तुलना के लिए प्रत्येक उदाहरण एक ही bookstore JSON structure का उपयोग करता है।
import { JSONPath } from 'jsonpath-plus';
const data = {
store: {
book: [
{ title: 'Moby Dick', price: 8.99 },
{ title: 'The Great Gatsby', price: 12.99 }
]
}
};
// Get all book titles
JSONPath({ path: '$.store.book[*].title', json: data });
// → ['Moby Dick', 'The Great Gatsby']
// Recursive descent — find every price in the document
JSONPath({ path: '$..price', json: data });
// → [8.99, 12.99]
// Filter — books under $10
JSONPath({ path: '$.store.book[?(@.price < 10)]', json: data });
// → [{ title: 'Moby Dick', price: 8.99 }]from jsonpath_ng.ext import parse
import json
data = {
"store": {
"book": [
{"title": "Moby Dick", "price": 8.99},
{"title": "The Great Gatsby", "price": 12.99}
]
}
}
# Get all book titles
expr = parse("$.store.book[*].title")
titles = [match.value for match in expr.find(data)]
# → ['Moby Dick', 'The Great Gatsby']
# Recursive descent — all prices
expr = parse("$..price")
prices = [match.value for match in expr.find(data)]
# → [8.99, 12.99]
# Filter — books under $10
expr = parse("$.store.book[?price < 10]")
cheap = [match.value for match in expr.find(data)]
# → [{"title": "Moby Dick", "price": 8.99}]package main
import (
"fmt"
"github.com/ohler55/ojg/jp"
"github.com/ohler55/ojg/oj"
)
func main() {
src := `{
"store": {
"book": [
{"title": "Moby Dick", "price": 8.99},
{"title": "The Great Gatsby", "price": 12.99}
]
}
}`
obj, _ := oj.ParseString(src)
// Get all book titles
expr, _ := jp.ParseString("$.store.book[*].title")
results := expr.Get(obj)
fmt.Println(results)
// → [Moby Dick The Great Gatsby]
// Recursive descent — all prices
expr2, _ := jp.ParseString("$..price")
fmt.Println(expr2.Get(obj))
// → [8.99 12.99]
}# jq uses its own syntax, not JSONPath, but solves the same problem.
# Mapping common JSONPath patterns to jq:
# $.store.book[*].title → get all titles
echo '{"store":{"book":[{"title":"Moby Dick"},{"title":"Gatsby"}]}}' | \
jq '.store.book[].title'
# → "Moby Dick"
# → "Gatsby"
# $..price → recursive descent for "price" keys
echo '{"a":{"price":1},"b":{"price":2}}' | \
jq '.. | .price? // empty'
# → 1
# → 2
# Filter: books where price < 10
echo '{"store":{"book":[{"title":"A","price":8},{"title":"B","price":12}]}}' | \
jq '.store.book[] | select(.price < 10)'
# → {"title":"A","price":8}