jsonpath-plus/jsonpathJSONPath का एक फोर्क, http://goessner.net/articles/JsonPath/ से
(यह भी देखें डेवलपमेंट निर्भरताओं के लाइसेंस)
JSON दस्तावेज़ों (और JavaScript ऑब्जेक्ट्स) से डेटा का विश्लेषण, रूपांतरण और चयनात्मक निष्कर्षण करें।
jsonpath-plus मूल विनिर्देश का विस्तार करते हुए कुछ अतिरिक्त ऑपरेटर जोड़ता है और कुछ व्यवहारों को स्पष्ट करता है जिन्हें मूल विनिर्देश ने स्पष्ट नहीं किया था।
ब्राउज़र डेमो या Runkit (Node) आज़माएँ।
कृपया ध्यान दें: यह प्रोजेक्ट वर्तमान में सक्रिय रूप से अनुरक्षित नहीं है। हम अच्छी तरह से प्रलेखित PR या कुछ सरल अपडेट स्वीकार कर सकते हैं, लेकिन हम स्वयं सुधार करने या नई सुविधाएँ जोड़ने के लिए तत्पर नहीं हैं।
^~@null(), @boolean(), @number(), @string(), @array(), @object()@integer()@scalar() (जो JavaScript ऑब्जेक्ट्स पर क्वेरी करते समय undefined और
गैर-परिमित संख्याओं के साथ-साथ सभी मूल गैर-ऑब्जेक्ट/गैर-फ़ंक्शन प्रकारों को भी स्वीकार करता है)@other() जो उपयोगकर्ता-परिभाषित otherTypeCallback के साथ संयोजन में उपयोग योग्य है@undefined(), @function(), @nonFinite())@path/@parent/@property/@parentProperty/@root शॉर्टहैंड सेलेक्टर`@['...']/?@['...'] सिंटैक्स$.. दस्तावेज़ (सभी पैरेंट घटक प्राप्त करना)jsonpath-plus json-querying-performance-testing के अनुसार अन्य json क्वेरी लाइब्रेरीज़ की तुलना में बड़े और छोटे दोनों डेटासेट के साथ लगातार प्रभावशाली प्रदर्शन करता है। आप प्रोजेक्ट को स्वयं चलाकर और अधिक परफॉर्मेंस मामले जोड़कर इन निष्कर्षों को सत्यापित कर सकते हैं।
npm install jsonpath-plus
## सेटअप
### Node.js```js
const {JSONPath} = require('jsonpath-plus');
const result = JSONPath({path: '...', json});
ब्राउज़र उपयोग के लिए आप सीधे dist/index-browser-umd.cjs शामिल कर सकते हैं; कोई
Browserify जादू आवश्यक नहीं है:```html
### ESM (आधुनिक ब्राउज़र)
आप आधुनिक ब्राउज़रों के लिए ES6 मॉड्यूल imports का भी उपयोग कर सकते हैं:```html
<script type="module">
import {
JSONPath
} from './node_modules/jsonpath-plus/dist/index-browser-esm.js';
const result = JSONPath({path: '...', json: {}});
</script>
या यदि आप अपने JavaScript को बंडल कर रहे हैं (जैसे, Rollup के साथ), तो बस उपयोग करें,
यह ध्यान रखते हुए कि mainFields
को ब्राउज़र बिल्ड के लिए browser शामिल करना चाहिए (Node के लिए, डिफ़ॉल्ट, जो
module की जाँच करता है, ठीक होना चाहिए):```js
import {JSONPath} from 'jsonpath-plus';
const result = JSONPath({path: '...', json});
## उपयोग
पूर्ण हस्ताक्षर उपलब्ध है:```
const result = JSONPath([options,] path, json, callback, otherTypeCallback);
The arguments path, json, callback, और otherTypeCallback
को वैकल्पिक रूप से (उपलब्ध अन्य किसी भी गुण के साथ) options पर
व्यक्त किया जा सकता है।
ध्यान दें कि result में मिली सभी वस्तुएँ होंगी (वैकल्पिक रूप से
एक सरणी में लपेटी गई) जबकि callback का उपयोग तब किया जा सकता है यदि आप
प्रत्येक वस्तु की खोज होने पर कोई कार्य करना चाहते हैं, जिसमें
callback फ़ंक्शन को परिणाम में मिलने वाली स्वतंत्र वस्तुओं की संख्या के
आधार पर 0 से N बार निष्पादित किया जाता है।
JSONPath के उपलब्ध तर्कों के बारे में अधिक जानकारी के लिए नीचे दिए गए दस्तावेज़ देखें।
API दस्तावेज़ भी देखें।
options ऑब्जेक्ट या evaluate विधि (पहले तर्क के रूप में) पर आपूर्ति किए जा सकने वाले गुणों में शामिल हैं:
false के रूप में आपूर्ति की जाती है, तो कोई व्यक्ति evaluate विधि को मैन्युअल रूप से कॉल कर सकता है।wrap को false पर सेट किया जाता है और कोई परिणाम नहीं मिलता है, तो undefined लौटाया जाएगा (जब wrap को true पर सेट किया जाता है तो खाली सरणी के विपरीत)। यदि wrap को false पर सेट किया जाता है और एक एकल गैर-सरणी परिणाम मिलता है, तो वह परिणाम ही लौटाया जाने वाला एकमात्र item होगा (किसी सरणी के भीतर नहीं)। हालाँकि, यदि कई परिणाम मिलते हैं तो एक सरणी अभी भी लौटाई जाएगी। अस्पष्टताओं से बचने के लिए (ऐसे मामले में जहाँ किसी विफलता वाले परिणाम और खाली सरणी वाले परिणाम के बीच अंतर करना आवश्यक हो), डिफ़ॉल्ट को false पर स्विच करने की अनुशंसा की जाती है।safe: ब्राउज़र में, यह एक न्यूनतम स्क्रिप्टिंग इंजन का उपयोग करेगा जो eval या Function का उपयोग नहीं करता है और Content Security Policy को संतुष्ट करता है। NodeJS में, इसका कोई प्रभाव नहीं होता है और यह native के समतुल्य है क्योंकि वहाँ स्क्रिप्टिंग सुरक्षित है।
native: देशी स्क्रिप्टिंग क्षमताओं का उपयोग करता है। अर्थात् ब्राउज़र में असुरक्षित eval या Function और nodejs में vm.Script। false: JavaScript मूल्यांकन एक्सप्रेशनों को अक्षम करें और इन एक्सप्रेशनों के प्रयास किए जाने पर अपवाद (exceptions) फेंकें।
callback [ (code, context) => value]: एक कस्टम कार्यान्वयन जिसे मूल्यांकित मान लौटाने के लिए तर्कों के रूप में code और context के साथ कॉल किया जाता है।
class: एक क्लास जो code को कंस्ट्रक्टर तर्क के रूप में बनाई जाती है और के साथ को कॉल करके कोड का मूल्यांकन किया जाता है।
``parentProperty को परिणामों में लौटाने की अनुमति देता है। यह एक स्ट्रिंग property नाम या संख्यात्मक सरणी अनुक्रमणिका हो सकता है।resultType के अनुसार), payload का प्रकार (चाहे वह सामान्य "value" हो या "property" नाम), और एक पूर्ण payload ऑब्जेक्ट (सभी resultTypes के साथ)।@other() ऑपरेटर जोड़कर अंतर्निहित प्रकारों से परे प्रकार निर्धारित कर सकता है। यदि ऐसा कोई path सामने आता है, तो otherTypeCallback को item के मान, उसके path, उसके parent, और उसके parent की property नाम के साथ लागू किया जाएगा, और इसे एक boolean लौटाना चाहिए जो दर्शाता है कि आपूर्ति किया गया मान "other" प्रकार का है या नहीं (या यह परिवर्तनों को संभाल सकता है और false लौटा सकता है)।autostart गुण false पर सेट हो। इसका उपयोग समान कॉन्फ़िगरेशन का उपयोग करके बार-बार मूल्यांकन के लिए किया जा सकता है। सूचीबद्ध गुणों के अलावा, बाद वाला विधि पैटर्न अन्य अनुमत इंस्टेंस गुणों में से किसी को भी स्वीकार कर सकता है (सिवाय autostart के जिसका यहाँ कोई प्रासंगिकता नहीं होगी)।['$', 'aProperty', 'anotherProperty']।$['aProperty']['anotherProperty][0]. JSONPath टर्मिनल निर्माण ~ और ^ और @string() जैसे प्रकार ऑपरेटरों को मौन रूप से हटा दिया जाता है।/aProperty/anotherProperty/0 (किसी भी ~ और / आंतरिक वर्णों को JSON Pointer विनिर्देश के अनुसार एस्केप किया गया)। JSONPath टर्मिनल निर्माण ~ और ^ और @string() जैसे प्रकार ऑपरेटरों को मौन रूप से हटा दिया जाता है।निम्नलिखित JSON दिया गया है, जो http://goessner.net/articles/JsonPath/ से लिया गया है:```json { "store": { "book": [ { "category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95 }, { "category": "fiction", "author": "Evelyn Waugh", "title": "Sword of Honour", "price": 12.99 }, { "category": "fiction", "author": "Herman Melville", "title": "Moby Dick", "isbn": "0-553-21311-3", "price": 8.99 }, { "category": "fiction", "author": "J. R. R. Tolkien", "title": "The Lord of the Rings", "isbn": "0-395-19395-8", "price": 22.99 } ], "bicycle": { "color": "red", "price": 19.95 } } }
और निम्नलिखित XML निरूपण:```xml
<store>
<book>
<category>reference</category>
<author>Nigel Rees</author>
<title>Sayings of the Century</title>
<price>8.95</price>
</book>
<book>
<category>fiction</category>
<author>Evelyn Waugh</author>
<title>Sword of Honour</title>
<price>12.99</price>
</book>
<book>
<category>fiction</category>
<author>Herman Melville</author>
<title>Moby Dick</title>
<isbn>0-553-21311-3</isbn>
<price>8.99</price>
</book>
<book>
<category>fiction</category>
<author>J. R. R. Tolkien</author>
<title>The Lord of the Rings</title>
<isbn>0-395-19395-8</isbn>
<price>22.99</price>
</book>
<bicycle>
<color>red</color>
<price>19.95</price>
</bicycle>
</store>
कृपया ध्यान दें कि नीचे दिए गए XPath उदाहरण एलिमेंट्स को पुनः प्राप्त करने और
उनकी टेक्स्ट सामग्री के बीच अंतर नहीं करते हैं (तुलना के लिए या अस्पष्टता
रोकने के लिए उपयोगी होने को छोड़कर)। नोट: XPath उदाहरणों का परीक्षण करने के लिए
(2.0 वाले सहित), यह डेमो
सहायक हो सकता है (इसे xml या xml-strict पर सेट करें)।| XPath | JSONPath | परिणाम | टिप्पणियाँ |
|-------------------------------------------------------------------------------------|---------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| /store/book/author | $.store.book[*].author | स्टोर में सभी पुस्तकों के लेखक | इसे $. के बिना भी store.book[*].author के रूप में दर्शाया जा सकता है (हालाँकि यह मूल स्पेक में मौजूद नहीं है); ध्यान दें कि कुछ वर्ण लिटरल ($ और @) को एस्केप करने की आवश्यकता होती है |
| //author | $..author | सभी लेखक | |
| /store/* | $.store.* | स्टोर में मौजूद सभी चीज़ें, जो इसकी पुस्तकें (एक पुस्तक ऐरे) और एक लाल साइकिल (एक साइकिल ऑब्जेक्ट) हैं। | |
| /store//price | $.store..price | स्टोर में मौजूद हर चीज़ की कीमत। | |
| //book[3] | $..book[2] | तीसरी पुस्तक (पुस्तक ऑब्जेक्ट) | |
| //book[last()] | $..book[(@.length-1)]
$..book[-1:] | क्रम में अंतिम पुस्तक। | विशेष वर्ण वाली प्रॉपर्टी तक पहुँचने के लिए, फ़िल्टर हेतु [(@['...'])] का उपयोग करें (यह विशेष सुविधा मूल स्पेक में मौजूद नहीं है) |
| //book[position()<3] | $..book[0,1]
$..book[:2] | पहली दो पुस्तकें | |
| //book/*[self::category\|self::author] या //book/(category,author) XPath 2.0 में | $..book[0][category,author] | सभी पुस्तकों की श्रेणियाँ और लेखक | |
| //book[isbn] | $..book[?(@.isbn)] | ISBN संख्या वाली सभी पुस्तकों को फ़िल्टर करें | विशेष वर्ण वाली प्रॉपर्टी तक पहुँचने के लिए, फ़िल्टर हेतु [?@['...']] का उपयोग करें (यह विशेष सुविधा मूल स्पेक में मौजूद नहीं है) |
| //book[price<10] | $..book[?(@.price<10)] | 10 से सस्ती सभी पुस्तकों को फ़िल्टर करें | |
| //*[name() = 'price' and . != 8.95] | $..*[?(@property === 'price' && @ !== 8.95)] | उन ऑब्जेक्ट्स के सभी प्रॉपर्टी मान प्राप्त करें जिनकी प्रॉपर्टी price है और जो 8.95 के बराबर नहीं है | बेयर @ के साथ ऑब्जेक्ट्स को प्रॉपर्टी मान द्वारा फ़िल्टर करने की अनुमति मिलती है (जरूरी नहीं कि ऐरे के भीतर), आप फ़िल्टर की गई प्रॉपर्टीज़ वाले ऑब्जेक्ट को प्राप्त करने के लिए एक्सप्रेशन के बाद ^ जोड़ सकते हैं |
| / | $ | JSON ऑब्जेक्ट का रूट (यानी, संपूर्ण ऑब्जेक्ट स्वयं) | लिटरल $ प्राप्त करने के लिए (अकेले या पाथ में कहीं भी), आपको बैकटिक एस्केप का उपयोग करना होगा |
| //*/*\|//*/*/text() | $..* | XML दस्तावेज़ में रूट के नीचे के सभी एलिमेंट्स (और टेक्स्ट)। रूट के नीचे JSON संरचना के सभी सदस्य। | |
| //* | $.. | XML दस्तावेज़ में सभी एलिमेंट्स। रूट सहित JSON संरचना के सभी पैरेंट घटक। | यह व्यवहार मूल स्पेक में सीधे निर्दिष्ट नहीं किया गया था |
| //*[price>19]/.. | $..[?(@.price>19)]^ | उन विशिष्ट आइटम्स का पैरेंट जिनकी कीमत 19 से अधिक है (यानी, साइकिल के पैरेंट के रूप में स्टोर मान और एक व्यक्तिगत पुस्तक के पैरेंट के रूप में पुस्तक ऐरे) | पैरेंट (केरेट) मूल स्पेक में मौजूद नहीं है |
| /store/*/name() (XPath 2.0 में) | $.store.*~ | स्टोर सब-ऑब्जेक्ट के प्रॉपर्टी नाम ("book" और "bicycle")। वाइल्डकार्ड प्रॉपर्टीज़ के साथ उपयोगी। | प्रॉपर्टी नाम (टिल्ड) मूल स्पेक में मौजूद नहीं है |
| /store/book[not(. is /store/book[1])] (XPath 2.0 में) | $.store.book[?(@path !== "$['store']['book'][0]")] | पहली पुस्तक की ओर इशारा करने वाले पाथ पर स्थित पुस्तक के अलावा अन्य सभी पुस्तकें | @path मूल स्पेक में मौजूद नहीं है |
| //book[parent::*/bicycle/color = "red"]/category | $..book[?(@parent.bicycle && @parent.bicycle.color === "red")].category | उन पुस्तकों की सभी श्रेणियाँ प्राप्त करता है जहाँ पुस्तक के पैरेंट ऑब्जेक्ट में साइकिल चाइल्ड है जिसका रंग लाल है (यानी, सभी पुस्तकें) | @parent मूल स्पेक में मौजूद नहीं है |
| //book/*[name() != 'category'] | $..book.*[?(@property !== "category")] | "book" के सभी चाइल्ड्स को प्राप्त करता है, सिवाय "category" वाले | @property मूल स्पेक में मौजूद नहीं है |
| //book[position() != 1] | $..book[?(@property !== 0)] | उन सभी पुस्तकों को प्राप्त करता है जिनकी प्रॉपर्टी (जो, चूँकि हम ऐरे के भीतर पहुँच रहे हैं, संख्यात्मक इंडेक्स है) 0 नहीं है | @property मूल स्पेक में मौजूद नहीं है |
| /store/*/*[name(parent::*) != 'book'] | $.store.*[?(@parentProperty !== "book")] | स्टोर के उन ग्रैंडचाइल्ड्स को प्राप्त करता है जिनकी पैरेंट प्रॉपर्टी book नहीं है (यानी, साइकिल के चाइल्ड्स, "color" और "price") | @parentProperty मूल स्पेक में मौजूद नहीं है |
| //book[count(preceding-sibling::*) != 0]/*/text() | $..book.*[?(@parentProperty !== 0)] | सभी पुस्तक इंस्टेंस के प्रॉपर्टी मान प्राप्त करें, जहाँ इन मानों की पैरेंट प्रॉपर्टी (यानी, पुस्तक आइटम पैरेंट ऑब्जेक्ट को धारण करने वाला ऐरे इंडेक्स) 0 नहीं है | @parentProperty मूल स्पेक में मौजूद नहीं है |
| //book[price = /store/book[3]/price] | $..book[?(@.price === @root.store.book[2].price)] | उन सभी पुस्तकों को फ़िल्टर करें जिनकी कीमत तीसरी पुस्तक की कीमत के बराबर है | @root मूल स्पेक में मौजूद नहीं है |
| //book/../*[. instance of element(*, xs:decimal)] (XPath 2.0 में) | $..book..*@number() | पुस्तक ऐरे के भीतर संख्यात्मक मान प्राप्त करें | @number(), अन्य बुनियादी प्रकार (@boolean(), @string()), अन्य निम्न-स्तरीय व्युत्पन्न प्रकार (@null(), @object(), @array()), JSONSchema-जोड़ा गया प्रकार @integer(), यौगिक प्रकार @scalar() (जो JavaScript ऑब्जेक्ट्स के लिए undefined और गैर-परिमित संख्याओं के साथ-साथ सभी बुनियादी गैर-ऑब्जेक्ट/गैर-फंक्शन प्रकारों को भी स्वीकार करता है), प्रकार @other(), जिसका उपयोग उपयोगकर्ता-परिभाषित कॉलबैक के साथ किया जाता है (देखें otherTypeCallback), और निम्नलिखित गैर-JSON प्रकार जिनका उपयोग गैर-JSON JavaScript ऑब्जेक्ट्स को क्वेरी करते समय JSONPath के साथ किया जा सकता है (@undefined(), @function(), @nonFinite()) मूल स्पेक में मौजूद नहीं हैं |
| //book/*[name() = 'category' and matches(., 'tion$')] (XPath 2.0) | $..book.*[?(@property === "category" && @.match(/TION$/i))] | पुस्तकों की वे सभी श्रेणियाँ जो रेगेक्स से मेल खाती हैं ('TION' पर समाप्त होती हैं, केस-इनसेंसिटिव) | @property मूल स्पेक में मौजूद नहीं है। |
| //book/*[matches(name(), 'bn$')]/parent::* (XPath 2.0) | $..book.*[?(@property.match(/bn$/i))]^ | वे सभी पुस्तकें जिनमें रेगेक्स से मेल खाने वाली प्रॉपर्टी है ('TION' पर समाप्त होती है, केस-इनसेंसिटिव) | @property मूल स्पेक में मौजूद नहीं है। नोट: पैरेंट ऑब्जेक्ट पर लौटने के लिए एक्सप्रेशन के अंत में पैरेंट सेलेक्टर ^ का उपयोग करता है; पैरेंट सेलेक्टर के बिना, यह दो isbn कुंजी मानों से मेल खाता है। |
| | ` (जैसे, `$ का प्रयोग $ नामक प्रॉपर्टी का शाब्दिक मिलान करने के लिए करें) | बाद के संपूर्ण अनुक्रम को एस्केप करता है (लिटरल के रूप में माने जाने के लिए) | ` मूल स्पेक में मौजूद नहीं है; लिटरल बैकटिक प्राप्त करने के लिए, एस्केप करने हेतु एक अतिरिक्त बैकटिक का उपयोग करें |Any additional variables supplied as properties on the optional "sandbox" object option are also available to (parenthetical-based) evaluations.
@ के बच्चों (children) के संदर्भ में होने के अलावा, वास्तव में तत्काल बच्चों का चयन भी करता है, जबकि XPath में, फ़िल्टर शर्तें बच्चों का चयन नहीं करतीं बल्कि यह निर्धारित करती हैं कि परिणाम में उसके पैरेंट नोड्स में से कौन से प्राप्त होंगे।एक बुनियादी कमांड लाइन इंटरफ़ेस (CLI) प्रदान किया गया है। इसे npx jsonpath-plus <json-file> <jsonpath-query> का उपयोग करके एक्सेस करें।
|) और समूहीकरण।Node पर परीक्षण चलाना:```shell npm test
ब्राउज़र में परीक्षणों के लिए:
- js/html फ़ाइलों को सर्व करें:```shell
npm run browser-test
कृपया महत्वपूर्ण सुरक्षा विचारों और भेद्यताओं की रिपोर्ट करने के निर्देशों के लिए SECURITY.md देखें।
contextrunInNewContext