jsonpath-plus/jsonpathJSONPath का एक फोर्क, http://goessner.net/articles/JsonPath/ से
[](https://www.npmjs.com/package/jsonpath-plus)
[](badges/tests-badge.svg)
[](badges/coverage-badge.svg)
[](https://snyk.io/test/github/s3u/JSONPath)
<!--[](LICENSE-MIT.txt)-->
[](badges/licenses-badge.svg)
[](https://github.com/JSONPath-Plus/JSONPath/actions/workflows/node.js.yml)
<small>(देव डिपेंडेंसीज़ के लिए [लाइसेंस भी देखें।](https://raw.githubusercontent.com/s3u/JSONPath/master/badges/licenses-badge-dev.svg?sanitize=true))</small>
# JSONPath Plus
JSON दस्तावेज़ों (और JavaScript ऑब्जेक्ट्स) से डेटा का विश्लेषण करें, रूपांतरण करें, और चुनिंदा रूप से निकालें।
`jsonpath-plus` मूल विनिर्देश का विस्तार करते हुए कुछ अतिरिक्त ऑपरेटर जोड़ता है और कुछ ऐसे व्यवहारों को स्पष्ट करता है जिन्हें मूल विनिर्देश में स्पष्ट नहीं किया गया था।
[ब्राउज़र डेमो](https://jsonpath-plus.github.io/JSONPath/demo/) या [Runkit (Node)](https://npm.runkit.com/jsonpath-plus) आज़माएँ।
***कृपया ध्यान दें: यह प्रोजेक्ट वर्तमान में सक्रिय रूप से अनुरक्षित नहीं है। हम अच्छी तरह से प्रलेखित PRs या कुछ सरल अपडेट स्वीकार कर सकते हैं, लेकिन स्वयं समाधान या नई सुविधाएँ जोड़ने की तलाश में नहीं हैं।***
## विशेषताएँ
* मूल jsonpath विनिर्देश के साथ **अनुरूप**
* मूल विनिर्देश में प्रदान नहीं की गई सुविधाजनक **वृद्धियाँ या विस्तार**:
* मेल खाने वाले आइटम के **पैरेंट** को प्राप्त करने के लिए `^`
* मेल खाने वाले आइटम के **प्रॉपर्टी नाम** (सरणी के रूप में) प्राप्त करने के लिए `~`
* निम्नलिखित प्राप्त करने के लिए **प्रकार चयनकर्ता**:
* बुनियादी JSON प्रकार: `@null()`, `@boolean()`, `@number()`, `@string()`, `@array()`, `@object()`
* `@integer()`
* संयुक्त प्रकार `@scalar()` (जो JavaScript ऑब्जेक्ट्स को क्वेरी करते समय `undefined` और गैर-परिमित संख्याओं के साथ-साथ सभी बुनियादी गैर-ऑब्जेक्ट/गैर-फ़ंक्शन प्रकारों को भी स्वीकार करता है)
* `@other()` जिसका उपयोग उपयोगकर्ता-परिभाषित `otherTypeCallback` के साथ किया जा सकता है
* गैर-JSON प्रकार जिनका उपयोग गैर-JSON JavaScript ऑब्जेक्ट्स को क्वेरी करते समय किया जा सकता है (`@undefined()`, `@function()`, `@nonFinite()`)
* फ़िल्टर के भीतर `@path`/`@parent`/`@property`/`@parentProperty`/`@root` **शॉर्टहैंड चयनकर्ता**
* **एस्केपिंग**
* शेष अनुक्रम से बचने के लिए `` ` ``
* फ़िल्टर में प्रॉपर्टी नामों के भीतर विशेष वर्णों से बचने के लिए `@['...']`/`?@['...']` सिंटैक्स
* `$..` को प्रलेखित करता है (**सभी पैरेंट घटक प्राप्त करना**)
* **ESM** और **UMD** निर्यात प्रारूप
* क्वेरी किए गए मानों के अतिरिक्त, **विभिन्न मेटा-जानकारी लौटा सकता है** जिसमें मान के पथ या पॉइंटर, साथ ही पैरेंट ऑब्जेक्ट और पैरेंट प्रॉपर्टी नाम (संशोधन की अनुमति देने के लिए) शामिल हैं।
* पथ, सरणियों और पॉइंटर्स के बीच **रूपांतरण के लिए उपयोगिताएँ**
* मूल विनिर्देश में अनुमत **मूल्यांकनों को रोकने** या मूल्यांकित मानों के लिए **सैंडबॉक्स** प्रदान करने का विकल्प।
* परिणाम प्राप्त होते ही **उन्हें संभालने के लिए कॉलबैक** का विकल्प।
## बेंचमार्किंग
[json-querying-performance-testing](https://github.com/andykais/json-querying-performance-testing) के अनुसार, अन्य json क्वेरी लाइब्रेरीज़ की तुलना में `jsonpath-plus` बड़े और छोटे दोनों डेटासेट के साथ लगातार प्रदर्शनकारी है। आप [प्रोजेक्ट को स्वयं चलाकर](https://github.com/andykais/json-querying-performance-testing#how-to-run) और अधिक परफ़ केस जोड़कर इन निष्कर्षों को सत्यापित कर सकते हैं।
## इंस्टॉल
```shell
npm install jsonpath-plus
```
## सेटअप
### Node.js
```js
const {JSONPath} = require('jsonpath-plus');
const result = JSONPath({path: '...', json});
```
### ब्राउज़र
ब्राउज़र उपयोग के लिए आप सीधे `dist/index-browser-umd.cjs` शामिल कर सकते हैं; किसी
Browserify जादू की आवश्यकता नहीं है:
```html
<script src="node_modules/jsonpath-plus/dist/index-browser-umd.cjs"></script>
<script>
const result = JSONPath.JSONPath({path: '...', json: {}});
</script>
```
### ESM (आधुनिक ब्राउज़र)
आप ES6 मॉड्यूल इम्पोर्ट्स (आधुनिक ब्राउज़रों के लिए) का भी उपयोग कर सकते हैं:
```html
<script type="module">
import {
JSONPath
} from './node_modules/jsonpath-plus/dist/index-browser-esm.js';
const result = JSONPath({path: '...', json: {}});
</script>
```
### ESM (बंडलर)
या यदि आप अपनी JavaScript को बंडल कर रहे हैं (उदाहरण के लिए, Rollup के साथ), तो बस इसका उपयोग करें,
यह ध्यान में रखते हुए कि [`mainFields`](https://github.com/rollup/plugins/tree/master/packages/node-resolve#mainfields)
में ब्राउज़र बिल्ड्स के लिए `browser` शामिल होना चाहिए (Node के लिए, डिफ़ॉल्ट, जो
`module` की जाँच करता है, ठीक होना चाहिए):
```js
import {JSONPath} from 'jsonpath-plus';
const result = JSONPath({path: '...', json});
```
## उपयोग
उपलब्ध पूर्ण सिग्नेचर यह है:
```
const result = JSONPath([options,] path, json, callback, otherTypeCallback);
```
तर्क `path`, `json`, `callback`, और `otherTypeCallback`
को वैकल्पिक रूप से `options` पर (उपलब्ध अन्य किसी भी
प्रॉपर्टी के साथ) व्यक्त किया जा सकता है।
ध्यान दें कि `result` में पाए गए सभी आइटम होंगे (वैकल्पिक रूप से
एक array में लपेटे गए) जबकि `callback` का उपयोग तब किया जा सकता है जब आप
प्रत्येक आइटम के मिलने पर कोई ऑपरेशन करना चाहते हैं, callback फ़ंक्शन
परिणाम में पाए जाने वाले स्वतंत्र आइटमों की संख्या के आधार पर
0 से N बार निष्पादित होता है।
`JSONPath` के उपलब्ध तर्कों के बारे में अधिक जानकारी के लिए नीचे दिए गए दस्तावेज़ देखें।
[API docs](https://jsonpath-plus.github.io/JSONPath/docs/ts/) भी देखें।
### Properties
वे प्रॉपर्टीज़ जो options ऑब्जेक्ट पर या
evaluate मेथड पर (पहले तर्क के रूप में) दी जा सकती हैं, उनमें शामिल हैं:
- ***path*** (**required**) - JSONPath एक्सप्रेशन एक (normalized
या unnormalized) string या array के रूप में
- ***json*** (**required**) - मूल्यांकन करने के लिए JSON ऑब्जेक्ट (चाहे
null, boolean, number, string, object, या array प्रकार का हो)।
- ***autostart*** (**default: true**) - यदि इसे `false` के रूप में दिया जाए,
तो कोई `evaluate` मेथड को मैन्युअल रूप से कॉल कर सकता है।
- ***flatten*** (**default: false**) - क्या लौटाए गए परिणामों की array
को एकल आयामी array में flatten किया जाएगा।
- ***resultType*** (**default: "value"**) - "value", "path", "pointer", "parent", या "parentProperty" का case-insensitive रूप हो सकता है ताकि
क्रमशः यह निर्धारित किया जा सके कि परिणामों को पाए गए आइटमों के मानों के रूप में,
उनके absolute paths के रूप में, absolute paths के [JSON Pointers](https://tools.ietf.org/html/rfc6901)
के रूप में, उनके parent objects के रूप में, या उनके parent की
property name के रूप में लौटाया जाए। यदि "all" पर सेट किया जाए, तो ये सभी प्रकार
एक ऑब्जेक्ट पर key name के रूप में type के साथ लौटाए जाएंगे।
- ***sandbox*** (**default: {}**) - filtering expressions जैसे code evaluations के लिए
उपलब्ध variables का key-value map। (ध्यान दें
कि वर्तमान path और value भी उन
expressions के लिए उपलब्ध होंगे; विवरण के लिए Syntax अनुभाग देखें।)
- ***wrap*** (**default: true**) - क्या परिणामों को
एक array में लपेटना है या नहीं। यदि `wrap` को `false` पर सेट किया जाए, और कोई परिणाम नहीं मिलता,
तो `undefined` लौटाया जाएगा (जबकि `wrap` को true पर सेट करने पर
एक खाली array लौटाई जाती है)। यदि `wrap` को `false` पर सेट किया जाए और एक
गैर-array परिणाम मिलता है, तो वह परिणाम ही एकमात्र लौटाया गया आइटम होगा
(array के भीतर नहीं)। हालांकि, यदि कई
परिणाम मिलते हैं तो भी एक array लौटाई जाएगी। अस्पष्टताओं से बचने के लिए (उस स्थिति में जहां
एक परिणाम जो विफलता है और एक जो खाली array है, के बीच अंतर करना आवश्यक हो),
default को `false` पर स्विच करने की सिफारिश की जाती है।
- ***eval*** (**default: "safe"**) - Script evaluation मेथड।
`safe`: ब्राउज़र में, यह एक न्यूनतम scripting engine का उपयोग करेगा जो `eval` या `Function` का उपयोग नहीं करता
और Content Security Policy को संतुष्ट करता है। NodeJS में,
इसका कोई प्रभाव नहीं है और यह native के समतुल्य है क्योंकि वहां scripting सुरक्षित है।
`native`: native scripting क्षमताओं का उपयोग करता है। अर्थात् ब्राउज़र में असुरक्षित `eval` या
`Function` और nodejs में `vm.Script`। `false`: JavaScript
evaluation expressions को अक्षम करता है और जब इन expressions का प्रयास किया जाता है तो exceptions फेंकता है।
`callback [ (code, context) => value]`: एक कस्टम कार्यान्वयन जिसे
मूल्यांकित मान लौटाने के लिए `code` और `context` को तर्क के रूप में कॉल किया जाता है।
`class`: एक class जो `code` को constructor तर्क के रूप में बनाई जाती है और code
का मूल्यांकन `context` के साथ `runInNewContext` को कॉल करके किया जाता है।
``
- ***ignoreEvalErrors*** (**default: false**) - script evaluation के दौरान आने वाली
त्रुटियों को अनदेखा करें।
- ***parent*** (**default: null**) - उस स्थिति में जब एक query
root node को लौटाने के लिए बनाई जा सकती है, यह उस root node के parent को
परिणामों के भीतर लौटाने की अनुमति देता है।
- ***parentProperty*** (**default: null**) - उस स्थिति में जब एक query
root node को लौटाने के लिए बनाई जा सकती है, यह उस root node की `parentProperty`
को परिणामों के भीतर लौटाने की अनुमति देता है। यह एक string
property name या एक numeric array index हो सकता है।
- ***callback*** (**default: (none)**) - यदि दिया जाए, तो एक callback
end point value प्राप्त होने पर तुरंत कॉल किया जाएगा। दिए गए तीन तर्क
payload का मान (`resultType` के अनुसार),
payload का प्रकार (चाहे यह एक सामान्य "value" हो या एक "property"
name), और एक पूर्ण payload ऑब्जेक्ट (सभी `resultType`s के साथ) होंगे।
- ***otherTypeCallback*** (**default: \<A function that throws an error**
**when @other() is encountered\>**) - JSON
Schema समर्थन के वर्तमान अभाव में, कोई अपनी query के अंत में
`@other()` ऑपरेटर जोड़कर built-in प्रकारों से परे प्रकारों का निर्धारण कर सकता है। यदि ऐसा
path सामने आता है, तो `otherTypeCallback` को आइटम के मान, उसके path, उसके parent, और उसके parent की property name के साथ
आमंत्रित किया जाएगा, और इसे एक boolean लौटाना चाहिए जो दर्शाता है कि दिया गया मान
"other" प्रकार से संबंधित है या नहीं (या यह transformations को संभाल सकता है और
false लौटा सकता है)।
- ***customTypes*** (**default: {}**) - type names से functions का key-value map।
यह कस्टम type operators बनाने की अनुमति देता है जिनका उपयोग queries में किया जा सकता है
(जैसे, `@myType()`)। फ़ंक्शन को आइटम के मान,
उसके path, उसके parent, और उसके parent की property name के साथ आमंत्रित किया जाएगा। इसे एक
boolean लौटाना चाहिए जो दर्शाता है कि दिया गया मान कस्टम प्रकार से मेल खाता है या नहीं। इसे
निम्न पर भी सेट किया जा सकता है:
1. import `jsonpath-plus/src/structuredCloningTypes.js` का मान जो निम्नलिखित प्रकारों को पूर्वनिर्धारित करता है:
@NaN(), @BigIntObject(), @Date(), @Set(), @Map(), @RegExp(),
@Blob(optionalMimeType), @File(optionalMimeType), @Boolean(), @Number(),
@String(), @Infinity(), @negativeInfinity(), @negativeZero(),
@DOMException(), @Error(), @EvalError(), @RangeError(), @ReferenceError(),
@SyntaxError(), @TypeError(), @URIError(), @AggregateError(),
@QuotaExceededError(), @WebTransportError(), @FileList, @ArrayBuffer(),
@DataView(), @ImageData(), @ImageBitmap(), @Int8Array(), @Uint8Array(),
@Uint8ClampedArray(), @Int16Array(), @Uint16Array(), @Int32Array(),
@Uint32Array(), @Float32Array(), @Float64Array(), @BigInt64Array(),
@BigUint64Array(), @Float16Array, @DOMMatrix(), @DOMMatrixReadOnly(),
@DOMPoint(), @DOMPointReadOnly(), @DOMRect, @DOMRectReadOnly(),
@DOMQuad(), @CryptoKey(), @AudioData(), @EncodedAudioChunk(),
@EncodedVideoChunk(), @VideoFrame(), @CropTarget,
@FileSystemDirectoryHandle(), @FileSystemFileHandle(),
@GPUCompilationInfo(), @GPUCompilationMessage(),
@GPUPipelineError(), @RTCCertificate(), @RTCEncodedAudioFrame(),
@RTCEncodedVideoFrame()
2. import `jsonpath-plus/src/javascriptTypes.js` का मान जो निम्नलिखित प्रकारों को पूर्वनिर्धारित करता है:
@Generator(), @AsyncGenerator(), @GeneratorFunction(),
@AsyncGeneratorFunction(), @Iterable(), @AsyncIterable(), @Iterator()
### Instance methods
- ***evaluate(path, json, callback, otherTypeCallback)*** OR
***evaluate({path: \<path\>, json: \<json object\>, callback:***
***\<callback function\>, otherTypeCallback:***
***\<otherTypeCallback function\>})*** - यह मेथड केवल
तब आवश्यक है जब `autostart` प्रॉपर्टी `false` पर सेट हो। इसका
उपयोग समान कॉन्फ़िगरेशन का उपयोग करके बार-बार मूल्यांकन के लिए किया जा सकता है।
सूचीबद्ध प्रॉपर्टीज़ के अलावा, बाद वाला मेथड पैटर्न
किसी भी अन्य अनुमत instance प्रॉपर्टीज़ को स्वीकार कर सकता है (`autostart` को छोड़कर
जिसका यहां कोई महत्व नहीं होगा)।
### Class properties and methods
- ***JSONPath.clearCache()*** - आंतरिक रूप से cached parsed paths और
compiled scripts को साफ़ करता है। Cache सामग्री उजागर नहीं की जाती; जब
cache invalidation की आवश्यकता हो तो इस मेथड को कॉल करें।
- ***JSONPath.toPathArray(pathAsString)*** - एक normalized या
unnormalized path को string के रूप में स्वीकार करता है और array में परिवर्तित करता है: उदाहरण के लिए,
`['$', 'aProperty', 'anotherProperty']`।
- ***JSONPath.toPathString(pathAsArray)*** - एक path array स्वीकार करता है और
इसे एक normalized path string में परिवर्तित करता है। String इस रूप में होगी:
`$['aProperty']['anotherProperty][0]`। JSONPath terminal
constructions `~` और `^` और `@string()` जैसे type operators
चुपचाप हटा दिए जाते हैं।
- ***JSONPath.toPointer(pathAsArray)*** - एक path array स्वीकार करता है और
इसे एक [JSON Pointer](https://tools.ietf.org/html/rfc6901) में परिवर्तित करता है।
String इस रूप में होगी: `/aProperty/anotherProperty/0`
(JSON Pointer spec के अनुसार किसी भी `~` और `/` आंतरिक वर्णों को escaped किया गया)। JSONPath terminal constructions `~` और `^` और
`@string()` जैसे type operators चुपचाप हटा दिए जाते हैं।
## Syntax through examples
निम्नलिखित 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 वाले सहित) का परीक्षण करने के लिए, [यह डेमो](http://videlibri.sourceforge.net/cgi-bin/xidelcgi) सहायक हो सकता है (`xml` या `xml-strict` पर सेट करें)।
| XPath | JSONPath | परिणाम | नोट्स |
|-------------------------------------------------------------------------------------|---------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `/store/book/author` | `$.store.book[*].author` | स्टोर में सभी पुस्तकों के लेखक | इसे `$.` के बिना भी `store.book[*].author` के रूप में दर्शाया जा सकता है (हालाँकि यह मूल स्पेक में मौजूद नहीं है); ध्यान दें कि कुछ वर्ण लिटरल (`$` और `@`) को एस्केप करने की आवश्यकता होती है, तथापि |
| `//author` | `$..author` | सभी लेखक | |
| `/store/*` | `$.store.*` | स्टोर में सभी चीज़ें, जो इसकी पुस्तकें (एक पुस्तक ऐरे) और एक लाल साइकिल (एक साइकिल ऑब्जेक्ट) हैं। | |
---
[Read more](https://github.com/jsonpath-plus/jsonpath)