Mustache.js: रिटर्निंग टेम्प्लेट वैरिएबल नाम

अगर मैं आपको सही ढंग से समझ रहा हूं तो आपको ऐसा कुछ चाहिए

var myTemplate = "{{foo}} is {{bar}}";
var variableNames = Mustache.VariableNames(myTemplate) // ['foo', 'bar']

यह मान रहा है कि VariableNames गया और टेम्पलेट से सभी चर नाम वापस कर दिए। यदि आप यही चाहते हैं तो आप शायद मूंछ लेखक पर उजागर parse फ़ंक्शन का उपयोग करके कार्यान्वयन को हैक कर सकते हैं।

शुरू करने के लिए यहां कुछ कोड दिया गया है:

var results = Mustache.parse('{{foo}} is {{bar}}')
                       .filter(function(v) { return v[0] === 'name' })
                       .map(function(v) { return v[1]; });

console.log(results) // ["foo", "bar"]

ध्यान दें कि इसके एक अनुभवहीन संस्करण को लागू करना संभव है, लेकिन सभी टैग नामों को स्पष्ट रूप से निकालने का कोई तरीका नहीं है, क्योंकि इस तरह की चीजें:

{{# foo }}
  * {{ bar }}
{{/ foo }}

... का मतलब या तो {foo: {bar: 'baz'}} _or_ {foo: true, bar: 'baz'}} हो सकता है।

@bobthecow इस परिस्थिति में पूरी तरह से सही है। मैंने जो उदाहरण दिया है वह केवल सभी पहचानकर्ता नोड्स को खींचेगा, यह पेड़ को प्रभावी ढंग से समतल करने वाली सभी संरचना को भी हटा देगा।

@Romanx @bobthecow आपकी मदद के लिए धन्यवाद!

कोई दिक्कत नहीं है। आपको कामयाबी मिले :)

मेरे पास एक समान अनुरोध था, लेकिन सभी परिवर्तनीय नामों को खोजने के लिए पेड़ को पार करने की आवश्यकता थी। सोचा कि अगर किसी को संदर्भ की आवश्यकता है तो मैं उस समाधान को साझा करूंगा जिसका मैंने उपयोग किया था।

var parseTree = Mustache.parse('{{#foo}}{{bar}}{{/foo}} {{baz}}');
var variableList = parseTree.reduce(function flattenVariablesFromParseTree(acc, v){
                    if(v[0] === 'name'){
                      return acc.concat([v]);
                    } else if (v[0] === '#') {
                      return acc.concat(v[4].reduce(flattenVariablesFromParseTree, []));
                    } else {
                      return acc;
                    }
                  }, [])
                  .map(function(v){ return v[1]; });
//variableList: ["bar", "baz"]

@nicluo क्या यह भी अस्पष्टता की समस्या से ग्रस्त है?

हां। यह भाषा की कल्पना में निहित है।

अस्पष्टता समस्या दिलचस्प है, दस्तावेज़ों का उल्लेख है कि यह इस संदर्भ में मूल्य खोजने का प्रयास करेगा और फिर कोई मान नहीं मिलने पर माता-पिता के संदर्भ को खोजेगा। थोड़ी जांच ने मुझे इसमें मिला:

{{bar}} 
{{#foo}}
  {{bar}} 
  {{#foo}}
    {{bar}} 
    {{#baz}}
      {{no}} 
      {{yes}}
    {{/baz}}
  {{/foo}}
{{/foo}}

var renderString = '{{bar}} {{#foo}}{{bar}} {{#foo}}{{bar}} {{#baz}}{{no}} {{yes}}{{/baz}}{{/foo}}{{/foo}}';
var renderContext = new Mustache.Context({
  bar: 'bar',
  baz: {
    no: 'no'
  },
  foo: {
    bar: 'y',
    foo: {
      bar: 'z',
      yes: 'yes'
    }
  }});

var parseTree = Mustache.parse(renderString);
var variableRefList = [];
var variableNameList = parseTree.reduce(function flattenVariablesFromParseTree(acc, v){
                    // Skip non-name or non-# tags
                    if(v[0] !== 'name' && v[0] !== '#'){
                      return acc;
                    }

                    var paths = [v[1]].concat(this.parents.slice(0).map(function(e){
                      return [e, v[1]].join('.');
                    }));

                    // Pops available context until a value is found
                    var path;
                    while(path = paths.pop()){
                      if(renderContext.lookup(path)){
                        //push to advanced list
                        variableRefList.push(path);
                        contextFound = true;
                        break;
                      }
                    }

                    if(v[0] === 'name'){
                      return acc.concat([v]);
                    } else if (v[0] === '#')  {
                      if(typeof renderContext.lookup(path) === 'object'){
                        this.parents = this.parents.concat([path]);
                      }

                      return acc.concat(v[4].reduce(
                        flattenVariablesFromParseTree.bind({
                          parents: this.parents
                        }), []));
                    }
                  }.bind({parents: []}), [])
                  .map(function(v){ return v[1]; });

//variableNameList: ["bar", "bar", "bar", "no", "yes"]
//variableRefList: ["bar", "foo", "foo.bar", "foo.foo", "foo.foo.bar", "baz", "baz.no", "foo.foo.yes"]
//Mustache.render(renderString, renderContext): bar y z no yes

उदाहरण बहुत ही काल्पनिक है, और संक्षिप्त रहने के लिए कई तरकीबों का उपयोग किया जाता है, लेकिन यह दिखाना चाहिए कि पहिया को फिर से शुरू करना मुझे कितना मुश्किल लगता है। चियर्स

@Immortalin क्या आप समस्या की बेहतर परिभाषा विस्तृत/प्रदान कर सकते हैं? वस्तुओं में नेस्टेड गुणों के साथ क्या होता है? क्या आप अधिक संपूर्ण इनपुट और आउटपुट प्रदान कर सकते हैं?

@dasilvacontin जिस परियोजना के लिए इस सुविधा की आवश्यकता है वह वर्तमान में अंतराल पर है इसलिए मैं इसे कुछ समय के लिए बंद करने जा रहा हूं

केवल शीर्ष स्तर प्राप्त करने का सरल उपाय:

Mustache.parse(template).filter(function(v) { return v[0] === 'name' || v[0] === '#' || v[0] === '&' } मैप (फ़ंक्शन (वी) {रिटर्न वी [1];});