Mustache.js: Mengembalikan nama variabel template

Jika saya memahami Anda dengan benar, Anda menginginkan sesuatu seperti ini

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

Itu dengan asumsi VariableNames pergi dan mengembalikan semua nama variabel dari template. Jika itu yang Anda inginkan maka Anda mungkin dapat meretas implementasi menggunakan fungsi parse yang terbuka pada penulis kumis.

Berikut beberapa kode untuk Anda mulai:

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"]

Perhatikan bahwa meskipun mungkin untuk mengimplementasikan versi naif ini, tidak ada cara untuk mengekstrak semua nama tag dengan jelas, karena hal-hal seperti ini:

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

… bisa berarti {foo: {bar: 'baz'}} _or_ {foo: true, bar: 'baz'}} .

@bobthecow sepenuhnya benar dalam situasi ini. Contoh yang saya berikan hanya akan mengeluarkan semua simpul pengenal, itu juga akan menghapus semua struktur yang secara efektif meratakan pohon.

@Romanx @bobthecow terima kasih atas bantuan Anda!

Tidak masalah. Semoga beruntung :)

Saya memiliki permintaan serupa, tetapi perlu melintasi pohon untuk menemukan semua nama variabel. Saya pikir saya akan membagikan solusi yang saya gunakan jika ada yang membutuhkan referensi.

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 apakah ini juga mengalami masalah ambiguitas?

Ya. Itu melekat dalam spesifikasi bahasa.

Masalah ambiguitas menarik, dokumen menyebutkan bahwa ia akan mencoba menemukan nilai dalam konteks ini dan kemudian mencari konteks induk jika tidak ada nilai yang ditemukan. Sedikit investigasi membawa saya ke dalam ini:

{{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

Contohnya sangat dibuat-buat, dan ada banyak trik yang digunakan untuk tetap ringkas, tetapi itu harus menunjukkan betapa sulitnya saya menemukan kembali roda. Bersulang

@Immortalin Bisakah Anda menguraikan/memberikan definisi masalah yang lebih baik? Apa yang terjadi dengan properti yang bersarang di objek? Bisakah Anda memberikan input dan output yang lebih lengkap?

@dasilvacontin proyek yang membutuhkan fitur ini sedang hiatus jadi saya akan menutup ini untuk sementara waktu

Solusi sederhana untuk mendapatkan level teratas saja:

Mustache.parse(template).filter(function(v) { return v[0] === 'name' || v[0] === '#' || v[0] === '&' } ).peta(fungsi(v) { kembali v[1]; });