json - जेएसओएन के लिए एक्सएसएलटी समकक्ष




xslt equivalent (16)

XSLT के मिलान अभिव्यक्तियों और पुनरावर्ती टेम्पलेट्स के पीछे परिचित और घोषणात्मक पैटर्न के साथ शुद्ध जावास्क्रिप्ट का उपयोग करने के दृष्टिकोण के एक कार्यशील डूडल / प्रमाण के प्रमाण के लिए, https://gist.github.com/brettz9/0e661b3093764f496e36

(JSON के लिए एक समान दृष्टिकोण लिया जा सकता है।)

ध्यान दें कि डेमो फ़ायरफ़ॉक्स में टेम्पलेट्स को व्यक्त करने में सुविधा के लिए जावास्क्रिप्ट 1.8 अभिव्यक्ति क्लोजर पर भी निर्भर करता है (कम से कम जब तक विधियों के लिए ES6 लघु रूप लागू नहीं किया जा सकता)।

अस्वीकरण: यह मेरा अपना कोड है।

क्या JSON के लिए एक XSLT समतुल्य है? जेएसओएन जैसे एक्सएसएलटी जैसे ट्रांसफॉर्मेशन करने के लिए मुझे कुछ एक्सएमएल करना है।


अभी तक एक दृष्टिकोण नहीं दिया गया है जो एक्सएसएलटी में पार्सर बनाने के लिए एक पार्सर जेनरेटर का उपयोग करना है जो जेएसओएन को पार करता है और एक्सएमएल आउटपुट बनाता है।

एक विकल्प जो एक्सएमएल सम्मेलनों में बहुत कुछ बताता है वह रेक्स पार्सर जनरेटर ( http://www.bottlecaps.de/rex/ ) है - हालांकि साइट पर पूरी तरह से अनियंत्रित, रेसिपी खोज पर उपलब्ध हैं।


उपकरणों की कमी का कहना है कि आवश्यकता की कमी सिर्फ सवाल पूछना है। लिनक्स में एक्स या वाई के समर्थन के लिए इसे लागू किया जा सकता है (ऐसे अल्पसंख्यक ओएस के लिए गुणवत्ता वाले ड्राइवरों और / या गेम को विकसित करने से परेशान क्यों हो? और ओएस पर क्यों ध्यान दें कि बड़े गेम और हार्डवेयर कंपनियां विकसित नहीं होतीं?)। संभवतः जिन लोगों को एक्सएसएलटी और जेएसओएन का उपयोग कुछ हद तक मामूली कामकाज का उपयोग करने की आवश्यकता होगी: जेएसओएन को एक्सएमएल में बदलना। लेकिन यह इष्टतम समाधान नहीं है, है ना?

जब आपके पास मूल JSON प्रारूप होता है और आप इसे ब्राउज़र में "wysywyg" संपादित करना चाहते हैं, तो XSLT समस्या के लिए पर्याप्त समाधान से अधिक होगा। ऐसा करना पारंपरिक जावास्क्रिप्ट प्रोग्रामिंग के साथ गधे में दर्द हो सकता है।

वास्तव में, मैंने एक्सएसएलटी के लिए "पत्थर-युग" दृष्टिकोण लागू किया है, जावास्क्रिप्ट के लिए कुछ बुनियादी आदेशों की व्याख्या करने के लिए सबस्ट्रिंग पार्सिंग का उपयोग करके, टेम्पलेट को कॉल करने, बच्चों को संसाधित करने आदि का उपयोग करके। निश्चित रूप से एक JSON ऑब्जेक्ट के साथ एक रूपांतरण इंजन को कार्यान्वित करना बहुत आसान है एक्सएसएलटी को पार्स करने के लिए एक पूर्ण एक्सएमएल पार्सर को कार्यान्वित करना। समस्या यह है कि टेम्पलेट के एक्सएमएल को पार्स करने के लिए आपको जेएसओएन ऑब्जेक्ट को बदलने के लिए एक्सएमएल टेम्पलेट्स का उपयोग करना है।

एक्सएमएल (या एचटीएमएल, या टेक्स्ट या जो कुछ भी) के साथ एक JSON ऑब्जेक्ट को ट्रैनफॉर्म करने के लिए आपको वाक्यविन्यास के बारे में सावधानी से सोचने की आवश्यकता है और परिवर्तन आदेशों की पहचान करने के लिए आपको किन विशेष वर्णों का उपयोग करने की आवश्यकता है। अन्यथा आप अपनी खुद की कस्टम templating भाषा के लिए एक पार्सर डिजाइन करने के अंत हो जाएगा। उस रास्ते से चलने के बाद, मैं आपको बता सकता हूं कि यह सुंदर नहीं है।

अपडेट (12 नवंबर, 2010): मेरे पार्सर पर काम करने के कुछ हफ्तों के बाद, मैं इसे अनुकूलित करने में सक्षम हूं। टेम्पलेट्स पहले से पार्स किए जाते हैं और कमांड JSON ऑब्जेक्ट्स के रूप में संग्रहीत होते हैं। परिवर्तन नियम भी JSON ऑब्जेक्ट्स हैं, जबकि टेम्पलेट कोड HTML का मिश्रण है और शेल कोड के समान होमब्रू सिंटैक्स है। मैं दस्तावेज़ संपादक बनाने के लिए एक जटिल JSON दस्तावेज़ को HTML में बदलने में सक्षम हूं। यह कोड संपादक के लिए लगभग 1 के लाइनों (यह एक निजी प्रोजेक्ट के लिए है, इसलिए मैं इसे साझा नहीं कर सकता) और JSON रूपांतरण कोड के लिए 9 0 9 लाइनों (पुनरावृत्ति आदेश, सरल तुलना, टेम्पलेट कॉलिंग, परिवर्तनीय बचत और मूल्यांकन) के लिए लगभग 9 0 9 लाइनें हैं। मैं इसे एमआईटी लाइसेंस के तहत जारी करने की योजना बना रहा हूं। यदि आप शामिल होना चाहते हैं तो मुझे एक मेल छोड़ दें।


एक्सएसएलटी का उपयोग कर JSON को कनवर्ट करना बहुत संभव है: आपको JSON2SAX deserializer और SAX2JSON serializer की आवश्यकता है।

जावा में नमूना कोड: http://www.gerixsoft.com/blog/json/xslt4json


जेएसओएन के लिए एक्सएसएलटी समकक्ष - उम्मीदवारों की एक सूची

  1. http://www.w3.org/TR/xslt-30/#json

    आप http://www.w3.org/TR/xslt-30/#json उपयोग fn:json-to-xml के उद्देश्य से कर fn:json-to-xml

    यह खंड XSLT का उपयोग कर JSON डेटा को संसाधित करने की अनुमति देने वाली सुविधाओं का वर्णन करता है।

  2. jq

    जेक जेएसओएन डेटा के लिए sed की तरह है - आप इसे स्लाइस और फ़िल्टर करने और मानचित्रित करने और संरचित डेटा को उसी आसानी से बदलने के लिए उपयोग कर सकते हैं, जो कि sed, awk, grep और friends आपको टेक्स्ट के साथ खेलने देते हैं। विभिन्न ओएस के लिए संकुल स्थापित कर रहे हैं।

  3. jj

    जे जे एक कमांड लाइन उपयोगिता है जो JSON दस्तावेज़ों से मूल्यों को पुनर्प्राप्त करने या अपडेट करने का एक तेज़ और सरल तरीका प्रदान करता है। यह हुज के तहत जीजेसन और एसजेसन द्वारा संचालित है।

  4. fx

    कमांड लाइन JSON प्रसंस्करण उपकरण

    • नए वाक्यविन्यास सीखने की जरूरत नहीं है
    • सादा जावास्क्रिप्ट
    • स्वरूपण और हाइलाइटिंग
    • स्टैंडअलोन बाइनरी
  5. jsawk

    Jsawk अजीब की तरह है, लेकिन JSON के लिए। आप stdin से पढ़े गए JSON ऑब्जेक्ट्स की एक सरणी के साथ काम करते हैं, stdout पर मुद्रित परिणाम सरणी उत्पन्न करने के लिए उन्हें जावास्क्रिप्ट का उपयोग करके फ़िल्टर करें।

  6. json

    JSON JSON के साथ काम करने के लिए एक तेज सीएलआई उपकरण है। यह एक एकल फ़ाइल नोड.जेएस स्क्रिप्ट है जिसमें कोई बाहरी डीपी नहीं है (नोड.जेएस के अलावा)।

  7. jl

    जेएल ("जेएसओएन लैम्ब्डा") JSON पूछताछ और छेड़छाड़ के लिए एक छोटी कार्यात्मक भाषा है।

  8. yate

    टेस्ट का उपयोग docu https://github.com/pasaran/yate/tree/master/tests रूप में किया जा सकता है

  9. https://github.com/ColinEberhardt/json-transforms

    JSON डेटा को बदलने के लिए एक पुनरावर्ती, पैटर्न-मिलान दृष्टिकोण प्रदान करता है।

  10. jsonpath-object-transform

    JSONPath का उपयोग करके किसी ऑब्जेक्ट से शाब्दिक डेटा को डेटा खींचता है और टेम्पलेट के आधार पर एक नई ऑब्जेक्ट उत्पन्न करता है।

  11. JOLT

    जेएसओएन जेएसओएन रूपांतरण पुस्तकालय जावा में लिखा गया है जहां ट्रांसफॉर्म के लिए "विनिर्देशन" स्वयं एक JSON दस्तावेज़ है।

  12. JSONiq

    JSONiq के पीछे प्रेरणा का मुख्य स्रोत XQuery है, जो अब तक अर्ध-संरचित डेटा के लिए एक सफल और उत्पादक क्वेरी भाषा साबित हुआ है

  13. gron

    JSON greppable बनाओ! ग्रोन जेएसओएन को अलग-अलग असाइनमेंट में बदल देता है ताकि आप जो चाहते हैं उसके लिए grep को आसान बना सकें और इसे 'पथ' देखें। यह एपीआई की खोज को आसान बनाता है जो जेएसओएन के बड़े ब्लॉब्स लौटाता है लेकिन भयानक दस्तावेज है।

यह भी देखें:


जेएसओएन के साथ एक्सएसएलटी का उपयोग करना संभव हो सकता है। XPath (3.1) एक्सएसएलटी (3.0) और XQuery (3.1) के वर्सन 3 किसी भी तरह से JSON का समर्थन करता है। ऐसा लगता है कि सैक्सन के वाणिज्यिक संस्करण में उपलब्ध है, और किसी बिंदु पर एचई संस्करण में शामिल किया जा सकता है। https://www.saxonica.com/html/documentation/functions/fn/parse-json.html

-

वैकल्पिक समाधान से मैं क्या उम्मीद करूंगा:

मैं डेटा के मिलान सेट को लाने और जेएसओएन या टेक्स्ट आउटपुट करने के लिए इनपुट जेएसओएन सक्षम होना चाहता हूं।

मनमानी गुणों तक पहुंचें और मूल्यों का मूल्यांकन करें

सशर्त तर्क के लिए समर्थन

मैं चाहता हूं कि रूपांतरण स्क्रिप्ट उपकरण, टेक्स्ट आधारित, और अधिमानतः सामान्य रूप से उपयोग की जाने वाली भाषा से बाहरी हों।

संभावित विकल्प?

मुझे आश्चर्य है कि एसक्यूएल एक उपयुक्त विकल्प हो सकता है। https://docs.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server

यह अच्छा होगा अगर वैकल्पिक उपकरण JSON और XML https://docs.microsoft.com/en-us/sql/relational-databases/xml/openxml-sql-server को संभाल सकता है

मैंने अभी तक एक्सएसएलटी स्क्रिप्ट्स को एसक्यूएल में परिवर्तित करने की कोशिश नहीं की है, या अभी तक इस विकल्प का पूर्ण मूल्यांकन किया है, लेकिन मुझे उम्मीद है कि इसे और जल्द ही देखेंगे। अभी तक कुछ विचार अभी तक।


पुराने सवाल के एक और नए जवाब के रूप में, मैं DefiantJS पर एक नज़र DefiantJS सुझाव DefiantJS । यह जेएसओएन के लिए एक्सएसएलटी समतुल्य नहीं है, यह जेएसओएन के लिए एक्सएसएलटी है। प्रलेखन के "टेम्पलेटिंग" खंड में यह उदाहरण शामिल है:

<!-- Defiant template -->
<script type="defiant/xsl-template">
    <xsl:template name="books_template">
        <xsl:for-each select="//movie">
            <xsl:value-of select="title"/><br/>
        </xsl:for-each>
    </xsl:template>
</script>

<script type="text/javascript">

var data = {
        "movie": [
            {"title": "The Usual Suspects"},
            {"title": "Pulp Fiction"},
            {"title": "Independence Day"}
        ]
    },
    htm = Defiant.render('books_template', data);

console.log(htm);
// The Usual Suspects<br>
// Pulp Fiction<br>
// Independence Day<br>

मैं ऊंट मार्ग उमरल (xmljson) -> से (xlst) -> मार्शल (xmljson) का उपयोग कर रहा हूं। पर्याप्त पर्याप्त (हालांकि 100% सही नहीं), लेकिन सरल, अगर आप पहले से ही ऊंट का उपयोग कर रहे हैं।


मैंने लंबे समय पहले अपने जैक्सन आधारित जेसन प्रसंस्करण ढांचे के लिए एक डोम एडाप्टर लिखा था। यह nu.xom पुस्तकालय का उपयोग करता है। परिणामी डोम पेड़ जावा xpath और xslt सुविधाओं के साथ काम करता है। मैंने कुछ कार्यान्वयन विकल्पों को बनाया जो बहुत सरल हैं। उदाहरण के लिए रूट नोड को हमेशा "रूट" कहा जाता है, एरे ली उप तत्वों (जैसे एचटीएमएल में) के साथ एक ओल नोड में जाते हैं, और बाकी सब कुछ एक मूल मूल्य या अन्य ऑब्जेक्ट नोड के साथ एक उप नोड है।

JsonXmlConverter.java

उपयोग: JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root"); JsonObject sampleJson = sampleJson(); org.w3c.dom.Document domNode = JsonXmlConverter.getW3cDocument(sampleJson, "root");


मैंने हाल ही में अपनी छोटी पुस्तकालय लिखी, जो करीब के करीब रहने की कोशिश करता है

5.1 प्रोसेसिंग मॉडल (एक्सएसएलटी आरईसी) https://www.w3.org/TR/xslt#section-Processing-Model प्रोसेसिंग- मॉडल

जैसा कि संभव है (जैसा कि मैं वैसे भी कर सकता हूं), जावास्क्रिप्ट कोड की कुछ पंक्तियों में।

उपयोग के कुछ गैर-पूरी तरह से तुच्छ उदाहरण हैं ...

1. JSON-to-some-markup:

पहेली: jsfiddle.net/YSharpLanguage/kj9pk8oz/10

( डी .1 दस्तावेज़ उदाहरण (एक्सएसएलटी आरईसी) द्वारा प्रेरित https://www.w3.org/TR/xslt#section-Document-Example दस्तावेज़- उदाहरण )

यह कहां:

var D1document = {
    type: "document", title: [ "Document Title" ],
    "": [
      { type: "chapter", title: [ "Chapter Title" ],
        "": [
        { type: "section", title: [ "Section Title" ],
          "": [
            { type: "para", "": [ "This is a test." ] },
            { type: "note", "": [ "This is a note." ] }
        ] },
        { type: "section", title: [ "Another Section Title" ],
          "": [
            { type: "para", "": [ "This is ", { emph: "another" }, " test." ] },
            { type: "note", "": [ "This is another note." ] }
        ] }
      ] }
    ] };

var D1toHTML = { $: [
  [ [ function(node) { return node.type === "document"; } ],
    function(root) {
      return "<html>\r\n\
  <head>\r\n\
    <title>\r\n\
      {title}\r\n".of(root) + "\
    </title>\r\n\
  </head>\r\n\
  <body>\r\n\
{*}".of(root[""].through(this)) + "\
  </body>\r\n\
</html>";
    }
  ],
  [ [ function(node) { return node.type === "chapter"; } ],
    function(chapter) {
      return "    <h2>{title}</h2>\r\n".of(chapter) + "{*}".of(chapter[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "section"; } ],
    function(section) {
      return "    <h3>{title}</h3>\r\n".of(section) + "{*}".of(section[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "para"; } ],
    function(para) {
      return "    <p>{*}</p>\r\n".of(para[""].through(this));
    }
  ],
  [ [ function(node) { return node.type === "note"; } ],
    function(note) {
      return '    <p class="note"><b>NOTE: </b>{*}</p>\r\n'.of(note[""].through(this));
    }
  ],
  [ [ function(node) { return node.emph; } ],
    function(emph) {
      return "<em>{emph}</em>".of(emph);
    }
  ]
] };

console.log(D1document.through(D1toHTML));

... देता है:

<html>
  <head>
    <title>
      Document Title
    </title>
  </head>
  <body>
    <h2>Chapter Title</h2>
    <h3>Section Title</h3>
    <p>This is a test.</p>
    <p class="note"><b>NOTE: </b>This is a note.</p>
    <h3>Another Section Title</h3>
    <p>This is <em>another</em> test.</p>
    <p class="note"><b>NOTE: </b>This is another note.</p>
  </body>
</html>

तथा

2. JSON-to-JSON:

पहेली: jsfiddle.net/YSharpLanguage/ppfmmu15/10

यह कहां:

// (A "Company" is just an object with a "Team")
function Company(obj) {
  return obj.team && Team(obj.team);
}

// (A "Team" is just a non-empty array that contains at least one "Member")
function Team(obj) {
  return ({ }.toString.call(obj) === "[object Array]") &&
         obj.length &&
         obj.find(function(item) { return Member(item); });
}

// (A "Member" must have first and last names, and a gender)
function Member(obj) {
  return obj.first && obj.last && obj.sex;
}

function Dude(obj) {
  return Member(obj) && (obj.sex === "Male");
}

function Girl(obj) {
  return Member(obj) && (obj.sex === "Female");
}

var data = { team: [
  { first: "John", last: "Smith", sex: "Male" },
  { first: "Vaio", last: "Sony" },
  { first: "Anna", last: "Smith", sex: "Female" },
  { first: "Peter", last: "Olsen", sex: "Male" }
] };

var TO_SOMETHING_ELSE = { $: [

  [ [ Company ],
    function(company) {
      return { some_virtual_dom: {
        the_dudes: { ul: company.team.select(Dude).through(this) },
        the_grrls: { ul: company.team.select(Girl).through(this) }
      } }
    } ],

  [ [ Member ],
    function(member) {
      return { li: "{first} {last} ({sex})".of(member) };
    } ]

] };

console.log(JSON.stringify(data.through(TO_SOMETHING_ELSE), null, 4));

... देता है:

{
    "some_virtual_dom": {
        "the_dudes": {
            "ul": [
                {
                    "li": "John Smith (Male)"
                },
                {
                    "li": "Peter Olsen (Male)"
                }
            ]
        },
        "the_grrls": {
            "ul": [
                {
                    "li": "Anna Smith (Female)"
                }
            ]
        }
    }
}

3. एक्सएसएलटी बनाम जावास्क्रिप्ट:

एक जावास्क्रिप्ट के बराबर ...

एक्सएसएलटी 3.0 आरईसी धारा 14.4 उदाहरण: सामान्य मूल्यों के आधार पर नोड समूहबद्ध करना

(पर: http://jsfiddle.net/YSharpLanguage/8bqcd0ey/1 )

सी एफ https://www.w3.org/TR/xslt-30/#grouping-examples

कहा पे...

var cities = [
  { name: "Milano",  country: "Italia",      pop: 5 },
  { name: "Paris",   country: "France",      pop: 7 },
  { name: "München", country: "Deutschland", pop: 4 },
  { name: "Lyon",    country: "France",      pop: 2 },
  { name: "Venezia", country: "Italia",      pop: 1 }
];

/*
  Cf.
  XSLT 3.0 REC Section 14.4
  Example: Grouping Nodes based on Common Values

  https://www.w3.org/TR/xslt-30/#grouping-examples
*/
var output = "<table>\r\n\
  <tr>\r\n\
    <th>Position</th>\r\n\
    <th>Country</th>\r\n\
    <th>City List</th>\r\n\
    <th>Population</th>\r\n\
  </tr>{*}\r\n\
</table>".of
  (
    cities.select().groupBy("country")(function(byCountry, index) {
      var country = byCountry[0],
          cities = byCountry[1].select().orderBy("name");
      return "\r\n\
  <tr>\r\n\
    <td>{position}</td>\r\n\
    <td>{country}</td>\r\n\
    <td>{cities}</td>\r\n\
    <td>{population}</td>\r\n\
  </tr>".
        of({ position: index + 1, country: country,
             cities: cities.map(function(city) { return city.name; }).join(", "),
             population: cities.reduce(function(sum, city) { return sum += city.pop; }, 0)
           });
    })
  );

... देता है:

<table>
  <tr>
    <th>Position</th>
    <th>Country</th>
    <th>City List</th>
    <th>Population</th>
  </tr>
  <tr>
    <td>1</td>
    <td>Italia</td>
    <td>Milano, Venezia</td>
    <td>6</td>
  </tr>
  <tr>
    <td>2</td>
    <td>France</td>
    <td>Lyon, Paris</td>
    <td>9</td>
  </tr>
  <tr>
    <td>3</td>
    <td>Deutschland</td>
    <td>München</td>
    <td>4</td>
  </tr>
</table>

4. JSONiq बनाम जावास्क्रिप्ट:

एक जावास्क्रिप्ट के बराबर ...

jsfiddle.net/YSharpLanguage/hvo24hmk/3 jsfiddle.net/YSharpLanguage/hvo24hmk/3

(पर: jsfiddle.net/YSharpLanguage/hvo24hmk/3 )

सी एफ http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping

कहा पे...

/*
  1.1.2. Grouping Queries for JSON
  http://jsoniq.org/docs/JSONiq-usecases/html-single/index.html#jsongrouping
*/
var sales = [
  { "product" : "broiler", "store number" : 1, "quantity" : 20  },
  { "product" : "toaster", "store number" : 2, "quantity" : 100 },
  { "product" : "toaster", "store number" : 2, "quantity" : 50 },
  { "product" : "toaster", "store number" : 3, "quantity" : 50 },
  { "product" : "blender", "store number" : 3, "quantity" : 100 },
  { "product" : "blender", "store number" : 3, "quantity" : 150 },
  { "product" : "socks", "store number" : 1, "quantity" : 500 },
  { "product" : "socks", "store number" : 2, "quantity" : 10 },
  { "product" : "shirt", "store number" : 3, "quantity" : 10 }
];

var products = [
  { "name" : "broiler", "category" : "kitchen", "price" : 100, "cost" : 70 },
  { "name" : "toaster", "category" : "kitchen", "price" : 30, "cost" : 10 },
  { "name" : "blender", "category" : "kitchen", "price" : 50, "cost" : 25 },
  {  "name" : "socks", "category" : "clothes", "price" : 5, "cost" : 2 },
  { "name" : "shirt", "category" : "clothes", "price" : 10, "cost" : 3 }
];

var stores = [
  { "store number" : 1, "state" : "CA" },
  { "store number" : 2, "state" : "CA" },
  { "store number" : 3, "state" : "MA" },
  { "store number" : 4, "state" : "MA" }
];

var nestedGroupingAndAggregate = stores.select().orderBy("state").groupBy("state")
( function(byState) {
    var state = byState[0],
        stateStores = byState[1];
    byState = { };
    return (
      (
        byState[state] =
        products.select().orderBy("category").groupBy("category")
        ( function(byCategory) {
            var category = byCategory[0],
                categoryProducts = byCategory[1],
                categorySales = sales.filter(function(sale) {
                  return stateStores.find(function(store) { return sale["store number"] === store["store number"]; }) &&
                         categoryProducts.find(function(product) { return sale.product === product.name; });
                });
            byCategory = { };
            return (
              (
                byCategory[category] =
                categorySales.select().orderBy("product").groupBy("product")
                ( function(byProduct) {
                    var soldProduct = byProduct[0],
                        soldQuantities = byProduct[1];
                    byProduct = { };
                    return (
                      (
                        byProduct[soldProduct] =
                        soldQuantities.reduce(function(sum, sale) { return sum += sale.quantity; }, 0)
                      ),
                      byProduct
                    );
                } ) // byProduct()
              ),
              byCategory
            );
        } ) // byCategory()
      ),
      byState
    );
} ); // byState()

... देता है:

[
  {
    "CA": [
      {
        "clothes": [
          {
            "socks": 510
          }
        ]
      },
      {
        "kitchen": [
          {
            "broiler": 20
          },
          {
            "toaster": 150
          }
        ]
      }
    ]
  },
  {
    "MA": [
      {
        "clothes": [
          {
            "shirt": 10
          }
        ]
      },
      {
        "kitchen": [
          {
            "blender": 250
          },
          {
            "toaster": 50
          }
        ]
      }
    ]
  }
]

JSONPath wrt की सीमाओं को दूर करने के लिए भी उपयोगी है। इस एसओ प्रश्न (और निश्चित रूप से अन्य) द्वारा उठाए गए पूर्वजों अक्ष के खिलाफ पूछताछ।

उदाहरण के लिए, अपने ब्रांड आईडी को जानने के लिए किराने की वस्तु की छूट कैसे प्राप्त करें

{
 "prods": [
    {
        "info": {
              "rate": 85
                },
        "grocery": [
                 {
                  "brand": "C",
                  "brand_id": "984"
                 },
                 {
                  "brand": "D",
                  "brand_id": "254"
                 }
                 ],
         "discount": "15"
    },
    {
        "info": {
              "rate": 100
                },
        "grocery": [
                 {
                  "brand": "A",
                  "brand_id": "983"
                 },
                 {
                  "brand": "B",
                  "brand_id": "253"
                 }
                 ],
         "discount": "20"
     }
 ]
}

?

एक संभावित समाधान है:

var products = {
     "prods": [
        {
            "info": {
                  "rate": 85
                    },
            "grocery": [
                     {
                      "brand": "C",
                      "brand_id": "984"
                     },
                     {
                      "brand": "D",
                      "brand_id": "254"
                     }
                     ],
             "discount": "15"
        },
        {
            "info": {
                  "rate": 100
                    },
            "grocery": [
                     {
                      "brand": "A",
                      "brand_id": "983"
                     },
                     {
                      "brand": "B",
                      "brand_id": "253"
                     }
                     ],
             "discount": "20"
         }
     ]
};

function GroceryItem(obj) {
  return (typeof obj.brand === "string") && (typeof obj.brand_id === "string");
}

    // last parameter set to "true", to grab all the "GroceryItem" instances
    // at any depth:
var itemsAndDiscounts = [ products ].nodeset(GroceryItem, true).
    map(
      function(node) {
        var item = node.value, // node.value: the current "GroceryItem" (aka "$.prods[*].grocery[*]")

            discount = node.parent. // node.parent: the array of "GroceryItem" (aka "$.prods[*].grocery")
                       parent. // node.parent.parent: the product (aka "$.prods[*]")
                       discount; // node.parent.parent.discount: the product discount

        // finally, project into an easy-to-filter form:
        return { id: item.brand_id, discount: discount };
      }
    ),
    discountOfItem983;

discountOfItem983 = itemsAndDiscounts.
  filter
  (
    function(mapped) {
      return mapped.id === "983";
    }
  )
  [0].discount;

console.log("Discount of #983: " + discountOfItem983);

... जो देता है:

Discount of #983: 20

'HTH,


यह भी सुनिश्चित नहीं है कि इसकी आवश्यकता है, और मेरे लिए उपकरणों की कमी की आवश्यकता की कमी का सुझाव है। जेएसओएन ऑब्जेक्ट्स (जिस तरह से यह जेएस में किया गया है) के रूप में सबसे अच्छा संसाधित किया जाता है, और आप आमतौर पर ट्रांसफॉर्मेशन करने के लिए ऑब्जेक्ट्स की भाषा का उपयोग करते हैं (जेएसओएन से बनाए गए जावा ऑब्जेक्ट्स के लिए जावा, पर्ल, पायथन, पर्ल, सी #, पीएचपी और इसी तरह के लिए पर)। सामान्य असाइनमेंट के साथ (या सेट, मिलता है), लूपिंग और इतने पर।

मेरा मतलब है, एक्सएसएलटी सिर्फ एक और भाषा है, और एक कारण यह आवश्यक है कि एक्सएमएल एक ऑब्जेक्ट नोटेशन नहीं है और इस प्रकार प्रोग्रामिंग भाषाओं की वस्तुएं सटीक फिट नहीं हैं (पदानुक्रमित एक्सएमएल मॉडल और ऑब्जेक्ट्स / स्ट्रक्चर के बीच प्रतिबाधा)।


येट ( yate ) विशेष रूप से एक्सएसएलटी के बाद डिज़ाइन किया गया है, जिसमें जेपीएथ (जेएस के लिए एक प्राकृतिक एक्सपीएथ समतुल्य) है, जावास्क्रिप्ट को संकलित करता है और इसका उत्पादन उत्पादन का इतिहास है। यह व्यावहारिक रूप से अनियंत्रित है, लेकिन नमूने और परीक्षणों के माध्यम से पढ़ना पर्याप्त होना चाहिए।


जेक - लाइटवेट और लचीला कमांड लाइन जेएसओएन प्रोसेसर

यह एक्सएसएलटी की तरह टेम्पलेट आधारित नहीं है, लेकिन अधिक संक्षेप में है। उदाहरण के लिए name और address फ़ील्ड को सरणी में निकालने के लिए: [.name, .address]

tutorial ट्विटर के JSON एपीआई को बदलने के उदाहरण के माध्यम से चलता है (और manual में कई उदाहरण हैं)।


JSONiq ऐसा मानक है और Zorba एक ओपन-सोर्स सी ++ कार्यान्वयन है। जेएसओएनआईक को जेएसओएन को मूल डेटा प्रकार के रूप में जोड़ने के साथ XQuery के रूप में भी देखा जा सकता है।


JSON-e में नोड.जेएस, पायथन और गो में कार्यान्वयन है।








equivalent