Underscore.js 1.3.3 Arahan terjemahan anotasi bahasa Cina_Pengetahuan asas

// Underscore.js 1.3.3

// (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.

// Underscore boleh diedarkan secara bebas di bawah lesen MIT.

// Bahagian Garis Bawah diilhamkan atau dipinjam daripada Prototaip,

// Oliver Steele's Functional, dan John Resig's Micro-Templating.

// Untuk semua butiran dan dokumentasi:

// http://documentcloud.github.com/underscore

(fungsi() {

 

  // Cipta objek global, diwakili sebagai objek tetingkap dalam penyemak imbas dan objek global dalam Node.js

  var root = ini;

 

  //Simpan nilai sebelum "_" (pembolehubah garis bawah) ditimpa

  // Jika terdapat konflik penamaan atau mempertimbangkan spesifikasi, kaedah _.noConflict() boleh digunakan untuk memulihkan nilai "_" sebelum ia diduduki oleh Underscore dan mengembalikan objek Underscore untuk menamakan semula

  var previousUnderscore = root._;

 

  //Buat pemalar objek kosong untuk perkongsian dan penggunaan dalaman

  pemutus var = {};

 

  //Cache rantai prototaip objek terbina dalam dalam pembolehubah tempatan untuk memudahkan panggilan pantas

  var ArrayProto = Array.prototype, //

  ObjProto = Object.prototype, //

  FuncProto = Function.prototype;

 

  //Cache kaedah biasa dalam prototaip objek terbina dalam dalam pembolehubah tempatan untuk panggilan pantas

  var slice = ArrayProto.slice, //

  unshift = ArrayProto.unshift, //

  toString = ObjProto.toString, //

  hasOwnProperty = ObjProto.hasOwnProperty;

 

  // Ini mentakrifkan beberapa kaedah baharu yang disediakan oleh JavaScript 1.6

  // Jika persekitaran hos menyokong kaedah ini, kaedah ini akan dipanggil terlebih dahulu Jika persekitaran hos tidak menyediakannya, ia akan dilaksanakan oleh Underscore.

  var nativeForEach = ArrayProto.forEach, //

  nativeMap = ArrayProto.map, //

  nativeReduce = ArrayProto.reduce, //

  nativeReduceRight = ArrayProto.reduceRight, //

  nativeFilter = ArrayProto.filter, //

  nativeEvery = ArrayProto.every, //

  nativeSome = ArrayProto.some, //

  nativeIndexOf = ArrayProto.indexOf, //

  nativeLastIndexOf = ArrayProto.lastIndexOf, //

  nativeIsArray = Array.isArray, //

  nativeKeys = Object.keys, //

  nativeBind = FuncProto.bind;

 

  // Cipta kaedah panggilan gaya objek, yang akan mengembalikan pembungkus Underscore Prototaip objek pembalut mengandungi semua kaedah Underscore (serupa dengan membungkus objek DOM ke dalam objek jQuery).

  var _ = function(obj) {

    // Semua objek Underscore dibina secara dalaman melalui objek pembalut

    kembalikan pembalut baharu(obj);

  };

  // Untuk persekitaran hos yang berbeza, simpan pembolehubah bernama Undersocre dalam objek berbeza.

  if( typeof exports !== 'undefined') {// Persekitaran Node.js

    if( typeof module !== 'undefined' && module.exports) {

      eksport = modul.eksport = _;

    }

    eksport._ = _;

  } else {//Pembolehubah Underscore yang dinamakan dalam persekitaran penyemak imbas digantung dalam objek tetingkap

    akar ['_'] = _;

  }

 

  // pernyataan versi

  _.VERSION = '1.3.3';

 

  // Kaedah berkaitan koleksi (kaedah pemprosesan am untuk data dan objek)

  //----------------------------------

 

  // Ulang pemproses dan laksanakan kaedah pemproses pada setiap elemen dalam koleksi

  var each = _.each = _.forEach = function(obj, iterator, context) {

    //Jangan kendalikan nilai nol

    if(obj == null)

      kembali;

    if(nativeForEach && obj.forEach === nativeForEach) {

      // Jika persekitaran hos menyokongnya, kaedah forEach yang disediakan oleh JavaScript 1.6 akan dipanggil dahulu.

      obj.forEach(iterator, konteks);

    } else if(obj.length === obj.length) {

      //Laksanakan kaedah pemproses untuk setiap elemen dalam <array>

      untuk(var i = 0, l = obj.panjang; i 

      untuk(kunci var dalam obj) {

        if(_.has(obj, key)) {

          if(iterator.call(context, obj[key], key, obj) === pemutus)

            kembali;

        }

      }

    }

  };

  // Pemproses lelaran, perbezaan daripada setiap kaedah ialah peta akan menyimpan nilai pulangan setiap lelaran dan mengembalikannya sebagai tatasusunan baharu

  _.map = _.collect = fungsi(obj, iterator, konteks) {

    //Array digunakan untuk menyimpan nilai pulangan

    var keputusan = [];

    if(obj == null)

      pulangan hasil;

    // Utamakan memanggil kaedah peta yang disediakan oleh persekitaran hos

    if(NativeMap && obj.map === nativeMap)

      kembalikan obj.map(iterator, konteks);

    // Lelaran melalui elemen dalam koleksi

    setiap (obj, fungsi (nilai, indeks, senarai) {

      // Simpan nilai pulangan setiap lelaran ke dalam tatasusunan hasil

      keputusan[results.length] = iterator.call(konteks, nilai, indeks, senarai);

    });

    //Kembalikan hasil pemprosesan

    if(obj.length === obj.length)

      hasil.panjang = obj.panjang;

    pulangan hasil;

  };

  // Letakkan setiap elemen dalam koleksi ke dalam pemproses lelaran, dan hantar nilai pulangan lelaran ini sebagai "memo" kepada lelaran seterusnya, biasanya digunakan untuk mengumpul hasil atau menyambung data

  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {

    // Semak sama ada terdapat nilai awal dengan bilangan parameter

    var initial = arguments.length >

    if(obj == null)

      obj = [];

    // Utamakan memanggil kaedah pengurangan yang disediakan oleh persekitaran hos

    if(nativeReduce && obj.reduce === nativeReduce && false) {

      jika(konteks)

        iterator = _.bind(iterator, context);

      kembalikan awal ? obj.reduce(iterator, memo): obj.reduce(iterator);

    }

    // Lelaran melalui elemen dalam koleksi

    setiap (obj, fungsi (nilai, indeks, senarai) {

      if(!initial) {

        // Jika tiada nilai awal, elemen pertama digunakan sebagai nilai awal jika koleksi objek diproses, nilai lalai ialah nilai atribut pertama

        memo = nilai;

        awal = benar;

      } lain {

        // Rekodkan hasil pemprosesan dan hantar hasilnya ke lelaran seterusnya

        memo = iterator.call(konteks, memo, nilai, indeks, senarai);

      }

    });

    jika(!awal)

      buang TypeError baru('Kurangkan tatasusunan kosong tanpa nilai awal');

    pulangkan memo;

  };

  // Sama seperti mengurangkan, ia akan mengulangi elemen dalam koleksi dalam arah terbalik (iaitu, bermula dari elemen terakhir hingga elemen pertama)

  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {

    var initial = arguments.length >

    if(obj == null)

      obj = [];

    // Utamakan memanggil kaedah reduceRight yang disediakan oleh persekitaran hos

    if(nativeReduceRight && obj.reduceRight === nativeReduceRight) {

      jika(konteks)

        iterator = _.bind(iterator, context);

      kembalikan awal ? obj.reduceRight(iterator, memo): obj.reduceRight(iterator);

    }

    //Terbalikkan susunan unsur dalam koleksi

    var terbalik = _.toArray(obj).reverse();

    if(konteks && !initial)

      iterator = _.bind(iterator, context);

    //Proses data melalui kaedah pengurangan

    kembalikan awal ? _.reduce(terbalikkan, iterator, memo, konteks): _.reduce(terbalikkan, iterator);

  };

  // Lintas elemen dalam koleksi dan kembalikan elemen pertama yang boleh lulus pengesahan pemproses

  _.cari = _.detect = fungsi(obj, iterator, konteks) {

    // result menyimpan elemen pertama yang boleh lulus pengesahan

    hasil var;

    // Lintas data melalui sebarang kaedah dan rekod elemen yang lulus pengesahan

    // (Jika anda menyemak status pengembalian pemproses semasa lelaran, adalah lebih sesuai untuk menggunakan setiap kaedah di sini)

    sebarang(obj, fungsi(nilai, indeks, senarai) {

      // Jika hasil yang dikembalikan oleh pemproses ditukar kepada jenis Boolean dan nilainya adalah benar, maka elemen semasa direkodkan dan dikembalikan

      if(iterator.call(konteks, nilai, indeks, senarai)) {

        hasil = nilai;

        kembali benar;

      }

    });

    pulangan hasil;

  };

  // Sama seperti kaedah cari, tetapi kaedah penapis akan merekodkan semua elemen yang disahkan dalam koleksi

  _.filter = _.select = function(obj, iterator, context) {

    // Digunakan untuk menyimpan tatasusunan elemen yang lulus pengesahan

    var keputusan = [];

    if(obj == null)

      pulangan hasil;

    // Beri keutamaan untuk memanggil kaedah penapis yang disediakan oleh persekitaran hos

    if(nativeFilter && obj.filter === nativeFilter)

      kembalikan obj.filter(iterator, konteks);

    // Ulangi elemen dalam koleksi dan letakkan elemen yang disahkan oleh pemproses ke dalam tatasusunan dan kembalikan

    setiap (obj, fungsi (nilai, indeks, senarai) {

      if(iterator.call(konteks, nilai, indeks, senarai))

        keputusan[hasil.panjang] = nilai;

    });

    pulangan hasil;

  };

  // Kesan bertentangan kaedah penapis, iaitu, mengembalikan senarai elemen yang belum lulus pengesahan pemproses

  _.reject = fungsi(obj, iterator, konteks) {

    var keputusan = [];

    if(obj == null)

      pulangan hasil;

    setiap (obj, fungsi (nilai, indeks, senarai) {

      if(!iterator.call(konteks, nilai, indeks, senarai))

        keputusan[hasil.panjang] = nilai;

    });

    pulangan hasil;

  };

  //Jika semua elemen dalam koleksi boleh lulus pengesahan pemproses, kembalikan benar

  _.every = _.all = fungsi(obj, iterator, konteks) {

    var keputusan = benar;

    if(obj == null)

      pulangan hasil;

    // Berikan keutamaan untuk memanggil setiap kaedah yang disediakan oleh persekitaran hos

    if(nativeEvery && obj.every === nativeEvery)

      kembalikan obj.every(iterator, konteks);

    //Lelaran pada elemen dalam koleksi

    setiap (obj, fungsi (nilai, indeks, senarai) {

      // Ini difahami sebagai hasil = (hasil && iterator.call(konteks, nilai, indeks, senarai))

      // Sahkan sama ada hasil pemproses adalah nilai sebenar selepas ditukar kepada jenis Boolean

      if(!( result = result && iterator.call(konteks, nilai, indeks, senarai)))

        pemutus pulangan;

    });

    pulangan !!hasil;

  };

  // Semak sama ada mana-mana elemen dalam koleksi mempunyai nilai sebenar apabila ia ditukar kepada jenis Boolean Atau sama ada ia mempunyai nilai sebenar selepas diproses oleh pemproses?

  var any = _.some = _.any = function(obj, iterator, context) {

    // Jika tiada parameter pemproses dinyatakan, fungsi pemproses lalai akan mengembalikan elemen itu sendiri dan menentukan sama ada ia adalah nilai sebenar dengan menukar elemen kepada jenis Boolean semasa lelaran

    iterator ||. ( iterator = _.identity);

    var keputusan = palsu;

    if(obj == null)

      pulangan hasil;

    // Berikan keutamaan untuk memanggil beberapa kaedah yang disediakan oleh persekitaran hos

    if(nativeSome && obj.some === nativeSome)

      kembalikan obj.some(iterator, konteks);

    //Lelaran pada elemen dalam koleksi

    setiap (obj, fungsi (nilai, indeks, senarai) {

      jika(hasil || ( hasil = iterator.panggilan(konteks, nilai, indeks, senarai)))

        pemutus pulangan;

    });

    pulangan !!hasil;

  };

  // Semak sama ada terdapat nilai dalam koleksi yang betul-betul sepadan dengan parameter sasaran (jenis data juga akan dipadankan)

  _.include = _.contains = function(obj, target) {

    var dijumpai = palsu;

    if(obj == null)

      pulangan ditemui;

    // Utamakan memanggil kaedah Array.prototype.indexOf yang disediakan oleh persekitaran hos

    if(nativeIndexOf && obj.indexOf === nativeIndexOf)

      kembalikan obj.indexOf(sasaran) != -1;

    // Ulangi elemen dalam koleksi melalui sebarang kaedah dan sahkan sama ada nilai dan jenis elemen sepadan sepenuhnya dengan sasaran.

    dijumpai = sebarang(obj, fungsi(nilai) {

      nilai pulangan === sasaran;

    });

    pulangan ditemui;

  };

  // Panggil kaedah yang dinamakan sama untuk semua elemen dalam koleksi dalam urutan, bermula dari parameter ketiga, yang akan dihantar ke kaedah panggilan elemen.

  // Kembalikan tatasusunan yang menyimpan hasil pemprosesan semua kaedah

  _.invoke = fungsi(obj, kaedah) {

    // Parameter diluluskan apabila memanggil kaedah dengan nama yang sama (bermula dari parameter ke-3)

    var args = slice.call(argumen, 2);

    // Panggil kaedah setiap elemen secara bergilir-gilir dan letakkan hasilnya ke dalam tatasusunan dan kembalikannya

    return _.map(obj, function(value) {

      return (_.isFunction(kaedah) ? kaedah || nilai : nilai[kaedah]).apply(nilai, args);

    });

  };

  // Melintasi tatasusunan yang terdiri daripada senarai objek dan kembalikan senarai nilai untuk atribut yang ditentukan dalam setiap objek

  _.pluck = function(obj, key) {

    // Jika harta itu tidak wujud dalam objek, kembalikan tidak ditentukan

    return _.map(obj, function(value) {

      nilai pulangan[kunci];

    });

  };

  //Kembalikan nilai maksimum dalam koleksi, jika tiada nilai setanding, kembalikan tidak ditentukan

  _.maks = fungsi(obj, iterator, konteks) {

    // Jika koleksi ialah tatasusunan dan tiada pemproses digunakan, gunakan Math.max untuk mendapatkan nilai maksimum

    // Secara amnya, satu siri data jenis Nombor disimpan dalam tatasusunan.

    if(!iterator && _.isArray(obj) && obj[0] === obj[0])

      kembalikan Math.max.apply(Math, obj);

    // Untuk nilai nol, kembalikan infiniti negatif secara langsung

    if(!iterator && _.isEmpty(obj))

      kembali -Infiniti;

    // Objek sementara, dikira digunakan untuk menyimpan nilai maksimum semasa proses perbandingan (sementara)

    hasil var = {

      dikira: -Infiniti

    };

    //Lelaran pada elemen dalam koleksi

    setiap (obj, fungsi (nilai, indeks, senarai) {

      // Jika parameter pemproses ditentukan, data yang dibandingkan ialah nilai yang dikembalikan oleh pemproses, jika tidak nilai lalai semasa setiap traversal digunakan secara langsung.

      var dikira = iterator ? iterator.call(konteks, nilai, indeks, senarai): nilai;

      // Jika nilai perbandingan lebih besar daripada nilai sebelumnya, masukkan nilai semasa ke dalam result.value

      dikira >= hasil.dikira && ( hasil = {

        nilai: nilai,

        dikira : dikira

      });

    });

    // Kembalikan nilai maksimum

    pulangan hasil.nilai;

  };

  //Kembalikan nilai minimum dalam set, proses pemprosesan adalah konsisten dengan kaedah maks

  _.min = fungsi(obj, iterator, konteks) {

    if(!iterator && _.isArray(obj) && obj[0] === obj[0])

      kembalikan Math.min.apply(Math, obj);

    if(!iterator && _.isEmpty(obj))

      kembali Infiniti;

    hasil var = {

      dikira: Infiniti

    };

    setiap (obj, fungsi (nilai, indeks, senarai) {

      var dikira = iterator ? iterator.call(konteks, nilai, indeks, senarai): nilai;

      dikira 

      rand = Math.floor(Math.random() * (indeks 1));

      // Letakkan elemen yang diperoleh secara rawak di hujung tatasusunan yang dikocok

      dikocok[indeks] = dikocok[rand];

      //Masukkan nilai terkini pada kedudukan nombor rawak yang diperoleh sebelum ini

      dikocok[rand] = nilai;

    });

    // Kembalikan tatasusunan yang menyimpan elemen koleksi yang dikocok secara rawak.

    kembali dikocok;

  };

  // Susun elemen dalam koleksi mengikut medan atau nilai tertentu

  // Berbanding dengan kaedah Array.prototype.sort, kaedah sortBy menyokong pengisihan objek.

  _.sortBy = fungsi(obj, val, konteks) {

    // val harus menjadi sifat objek, atau fungsi pemproses Jika ia adalah pemproses, ia harus mengembalikan data yang perlu dibandingkan.

    var iterator = _.isFunction(val) val : function(obj) {

      kembalikan obj[val];

    };

    // Urutan panggilan: _.pluck(_.map().sort());

    // Panggil kaedah _.map() untuk merentasi koleksi, letakkan elemen dalam koleksi ke dalam nod nilai, dan letakkan data yang perlu dibandingkan dalam elemen ke dalam atribut kriteria

    //Panggil kaedah sort() untuk mengisih elemen dalam koleksi mengikut data dalam atribut kriteria.

    // Panggil pluck untuk mendapatkan koleksi objek yang diisih dan mengembalikannya

    return _.pluck(_.map(obj, function(value, index, list) {

      kembali {

        nilai: nilai,

        kriteria: iterator.call(konteks, nilai, indeks, senarai)

      };

    }).sort(function(kiri, kanan) {

      var a = kiri.kriteria, b = kanan.kriteria;

      jika(a ===

        batal 0)

        pulangan 1;

      jika(b ===

        batal 0)

        pulangan -1;

      kembalikan a >

      iterator(array[mid]) = 0;

      });

    });

  };

  // Tapis dan kembalikan data perbezaan dalam tatasusunan semasa yang tidak sama dengan data yang ditentukan

  // Fungsi ini biasanya digunakan untuk memadam data yang ditentukan dalam tatasusunan dan mendapatkan tatasusunan baharu selepas pemadaman

  // Fungsi kaedah ini bersamaan dengan tanpa Parameter kaedah tanpa tidak membenarkan data dimasukkan dalam tatasusunan, manakala parameter kaedah perbezaan disyorkan untuk menjadi tatasusunan (anda juga boleh menggunakan parameter yang sama seperti tanpa).

  _.perbezaan = fungsi(tatasusunan) {

    // Gabungkan semua parameter bermula dari parameter kedua sebagai tatasusunan (hanya gabungkan tahap pertama, bukan cantum dalam)

    // Pembolehubah selebihnya menyimpan data pengesahan, yang digunakan dalam kaedah ini untuk membandingkan dengan data asal.

    var rest = _.flatten(slice.call(arguments, 1), true);

    // Tapis data tatasusunan yang digabungkan Syarat penapis ialah tatasusunan semasa tidak mengandungi data pengesahan yang ditentukan oleh parameter.

    // Gabungkan data yang memenuhi syarat penapis ke dalam tatasusunan baharu dan kembalikannya

    return _.filter(array, function(value) {

      return !_.include(rehat, nilai);

    });

  };

  //Kembalikan data pada kedudukan yang sama bagi setiap tatasusunan sebagai tatasusunan dua dimensi yang baru Panjang tatasusunan yang dikembalikan adalah berdasarkan panjang tatasusunan maksimum dalam parameter yang dilalui.

  // Kaedah zip hendaklah mengandungi berbilang parameter, dan setiap parameter hendaklah berupa tatasusunan

  _.zip = function() {

    //Tukar parameter kepada tatasusunan, pada masa ini args ialah tatasusunan dua dimensi

    var args = slice.call(argumen);

    // Kira panjang setiap tatasusunan dan kembalikan nilai panjang maksimum

    var length = _.max(_.pluck(args, 'length'));

    //Buat tatasusunan kosong baharu mengikut nilai panjang maksimum, yang digunakan untuk menyimpan hasil pemprosesan

    var keputusan = new Array(panjang);

    //Panjang maksimum gelung, dalam setiap gelung kaedah pluck akan dipanggil untuk mendapatkan data pada kedudukan yang sama dalam setiap tatasusunan (dari 0 hingga kedudukan terakhir dalam urutan)

    // Simpan data yang diperoleh dalam tatasusunan baharu, masukkan ke dalam hasil dan kembalikan

    untuk(var i = 0; i = 0; i--) {

        args = [funcs[i].apply(this, args)];

      }

      //Kembalikan nilai pulangan bagi panggilan fungsi terakhir

      kembalikan args[0];

    };

  };

  // Kembalikan fungsi yang berfungsi sebagai pembilang panggilan Apabila fungsi dipanggil kali masa (atau melebihi masa kali), fungsi fungsi akan dilaksanakan.

  // Kaedah selepas biasanya digunakan sebagai pembilang tak segerak Contohnya, jika anda perlu melaksanakan fungsi selepas berbilang permintaan AJAX selesai, anda boleh menggunakan selepas untuk memanggilnya selepas setiap permintaan AJAX selesai.

  _.after = function(times, func) {

    // Jika tiada atau masa tidak sah dinyatakan, func dipanggil terus

    jika(kali 

  _.escape = function(string) {

    return ('' string).replace(/&/g, '&').replace(/, '/g, '>').replace(/ "/g, '"').replace(/'/g, ''').replace(///g, '/');

  };

  //Geben Sie das Attribut eines Objekts an und geben Sie den dem Attribut entsprechenden Wert zurück. Wenn das Attribut einer Funktion entspricht, wird die Funktion ausgeführt und das Ergebnis zurückgegeben.

  _.result = function(object, property) {

    if(object == null)

      null zurückgeben;

    // Den Wert des Objekts abrufen

    var value = object[property];

    // Wenn der Wert eine Funktion ist, führen Sie ihn aus und geben Sie ihn zurück, andernfalls wird er direkt zurückgegeben

    return _.isFunction(value) ? value.call(object) : value;

  };

  //Fügen Sie dem Underscore-Objekt eine Reihe benutzerdefinierter Methoden hinzu, um das Underscore-Plug-In zu erweitern

  _.mixin = function(obj) {

    //obj ist ein Objekt, das eine Reihe benutzerdefinierter Methoden sammelt. Die Methode zum Durchlaufen des Objekts erfolgt hier jeweils

    every(_.functions(obj), function(name) {

      //Fügen Sie benutzerdefinierte Methoden zu Objekten hinzu, die von Underscore über die Funktion addToWrapper erstellt wurden, um objektbasierte Aufrufe zu unterstützen

      // Fügen Sie außerdem Methoden zu _ selbst hinzu, um Funktionsaufrufe zu unterstützen

      addToWrapper(name, _[name] = obj[name]);

    });

  };

  // Einen global eindeutigen Bezeichner erhalten, der Bezeichner beginnt bei 0 und wird akkumuliert

  var idCounter = 0;

  // Präfix stellt das Präfix des Bezeichners dar. Wenn kein Präfix angegeben ist, wird der Bezeichner im Allgemeinen zum Erstellen einer eindeutigen ID für ein Objekt oder DOM zurückgegeben.

  _.uniqueId = function(prefix) {

    var id = idCounter;

    Präfix zurückgeben? Präfix-ID: id;

  };

  // Definieren Sie das Begrenzungssymbol der Vorlage, das in der Vorlagenmethode verwendet wird

  _.templateSettings = {

    //Trennzeichen des ausführbaren JavaScript-Codes

    auswerten: //g,

    // Das Trennzeichen der Variablen direkt ausgeben

    interpolieren: //g,

    //Trennzeichen erforderlich, um HTML als String auszugeben (spezielle Symbole in String-Form umwandeln)

    Escape: //g

  };

 

  var noMatch = /.^/;

 

  // Das Escape-Objekt zeichnet die Entsprechung zwischen Sonderzeichen und Zeichenfolgenformen auf, die ineinander konvertiert werden müssen, und wird als Index verwendet, wenn die beiden ineinander konvertiert werden.

  // Definieren Sie zunächst Sonderzeichen entsprechend der Zeichenfolgenform

  var escapes = {

    '\' : '\',

    "'" : "'",

    'r': 'r',

    'n': 'n',

    't': 't',

    'u2028': 'u2028',

    'u2029': 'u2029'

  };

  // Alle Sonderzeichenketten durchlaufen und die Zeichenfolgenform mit Sonderzeichen als Schlüssel aufzeichnen

  for(var p in Escapezeichen)

  entkommt[escapes[p]] = p;

  // Definieren Sie die Sonderzeichen, die in der Vorlage ersetzt werden müssen, einschließlich Backslash, einfaches Anführungszeichen, Wagenrücklauf, Zeilenvorschub, Tabulator, Zeilentrennzeichen, Absatztrennzeichen

  // Wird beim Konvertieren spezieller Symbole in einer Zeichenfolge in eine Zeichenfolgenform verwendet

  var escaper = /\|'|r|n|t|u2028|u2029/g;

  // Wird beim Umkehren (Ersetzen) von Sonderzeichen in Stringform verwendet

  var unescaper = /\(\|'|r|n|t|u2028|u2029)/g;

 

  //Spezielle Symbole im String umkehren

  // Der JavaScript-Quellcode, der in der Vorlage ausgeführt werden muss, muss mit speziellen Symbolen umgekehrt werden. Andernfalls wird ein Syntaxfehler ausgegeben, wenn er in Form von HTML-Entitäten oder Zeichenfolgen angezeigt wird

  var unescape = function(code) {

    Rückgabecode.replace(unescaper, function(match, escape) {

      return escapes[escape];

    });

  };

  // Analysemethode für Unterstrichvorlagen, die zum Füllen von Daten in eine Vorlagenzeichenfolge verwendet wird

  // Template-Parsing-Prozess:

  // 1. Konvertieren Sie spezielle Symbole in der Vorlage in Zeichenfolgen

  // 2. Analysieren Sie das Escape-Formular-Tag und analysieren Sie den Inhalt in HTML-Entitäten

  // 3. Analysieren Sie interpolierte Formular-Tags und Ausgabevariablen

  // 4. Analysieren Sie das Evalue-Formular-Tag und erstellen Sie ausführbaren JavaScript-Code

  // 5. Generieren Sie eine Verarbeitungsfunktion, die die Vorlage nach dem Abrufen der Daten direkt ausfüllen und die ausgefüllte Zeichenfolge zurückgeben kann

  // 6. Den gefüllten String oder das Handle der Verarbeitungsfunktion gemäß den Parametern zurückgeben

  //------------------

  // Im Vorlagenkörper können zwei Parameter über Argumente abgerufen werden, nämlich die Fülldaten (benannt obj) und das Underscore-Objekt (benannt _).

  _.template = Funktion(Text, Daten, Einstellungen) {

    // Vorlagenkonfiguration, wenn kein Konfigurationselement angegeben ist, wird das in templateSettings angegebene Konfigurationselement verwendet.

    Settings = _.defaults(settings || {}, _.templateSettings);

 

    // Beginnen Sie mit dem Parsen der Vorlage in ausführbaren Quellcode

    var source = "__p ='" text.replace(escaper, function(match) {

      //Konvertieren Sie spezielle Symbole in String-Form

      return '\' escapes[match];

    }).replace(settings.escape || noMatch, function(match, code) {

      // Analysieren Sie das Escape-Formular-Tag  und konvertieren Sie den in der Variablen enthaltenen HTML-Code über die Funktion _.escape in eine HTML-Entität

      return "' n_.escape(" unescape(code) ") n'";

    }).replace(settings.interpolate || noMatch, function(match, code) {

      // Analysieren Sie das interpolierte Formular-Tag , verbinden Sie den Vorlageninhalt als Variable mit anderen Zeichenfolgen und er wird als Variable ausgegeben

      return "' n(" unescape(code) ") n'";

    }).replace(settings.evaluate || noMatch, function(match, code) {

      // Analysieren Sie das Evaluierungsformular-Tag . Der auszuführende JavaScript-Code wird im Evaluierungs-Tag gespeichert. Das aktuelle String-Splicing endet hier und wird als JavaScript-Syntax in einer neuen Zeile und dem folgenden Inhalt ausgeführt wird wieder als Zeichen verwendet, damit der JavaScript-Code im Evaluierungs-Tag normal ausgeführt werden kann.

      return "';n" unescape(code) "n;__p ='";

    }) "';N";

    if(!settings.variable)

      source = 'with(obj||{}){n' source '}n';

    source = "var __p='';" "var print=function(){__p =Array.prototype.join.call(arguments, '')};n" source "return __p;n";

 

    // Erstellen Sie eine Funktion, verwenden Sie den Quellcode als Funktionsausführungskörper und übergeben Sie obj und Underscore als Parameter an die Funktion

    var render = new Function(settings.variable || 'obj', '_', source);

    // Wenn die Fülldaten der Vorlage angegeben sind, ersetzen Sie den Vorlageninhalt und geben Sie das ersetzte Ergebnis zurück

    if(Daten)

      return render(data, _);

    // Wenn keine Fülldaten angegeben sind, wird eine Funktion zurückgegeben, die die empfangenen Daten in der Vorlage ersetzt

    // Wenn dieselbe Vorlage im Programm mehrmals ausgefüllt wird, wird empfohlen, die Fülldaten nicht beim ersten Aufruf anzugeben. Nachdem Sie die Referenz der Verarbeitungsfunktion erhalten haben, verbessert ein direkter Aufruf die Betriebseffizienz.

    var template = function(data) {

      return render.call(this, data, _);

    };

    // Fügen Sie die erstellte Quellcodezeichenfolge zum Funktionsobjekt hinzu, das im Allgemeinen zum Debuggen und Testen verwendet wird

    template.source = 'function(' (settings.variable || 'obj') '){n' source '}';

    //Wenn keine Fülldaten angegeben sind, wird das Handle der Verarbeitungsfunktion zurückgegeben

    Rücksendevorlage;

  };

  // Unterstützt den Methodenkettenbetrieb des Underscore-Objekts, siehe wrapper.prototype.chain

  _.chain = function(obj) {

    return _(obj).chain();

  };

  // Unterstrich-Objekt kapselt verwandte Methoden

  // ---------------

 

  //Erstelle einen Wrapper, um einige Rohdaten zu verpacken

  // Alle Undersocre-Objekte werden intern durch die Wrapper-Funktion erstellt und gekapselt

  //Die interne Beziehung zwischen Underscore und Wrapper:

  // - Definieren Sie die Variable _ intern und fügen Sie Unterstrich-bezogene Methoden zu _ hinzu, damit Funktionsaufrufe unterstützt werden können, z. B. _.bind()

  // - Definieren Sie die Wrapper-Klasse intern und verweisen Sie das Prototypobjekt von _ auf den Prototyp der Wrapper-Klasse

  // -Fügen Sie Underscore-bezogene Methoden zum Wrapper-Prototyp hinzu, und das erstellte _-Objekt verfügt über Underscore-Methoden

  // – Array.prototype-bezogene Methoden zum Wrapper-Prototyp hinzufügen, und das erstellte _-Objekt verfügt über die Methoden in Array.prototype

  // -new _() erstellt tatsächlich ein Wrapper()-Objekt und gibt es zurück, speichert das ursprüngliche Array in der Variablen _wrapped und ruft die entsprechende Methode mit dem Originalwert als erstem Parameter auf.

  var wrapper = function(obj) {

    //Die Originaldaten werden im _wrapped-Attribut des umschlossenen Objekts gespeichert

    this._wrapped = obj;

  };

  // Das Prototypobjekt von Underscore auf den Prototyp des Wrappers verweisen, sodass durch das Hinzufügen von Methoden wie dem Wrapper-Prototyp auch das Underscore-Objekt über dieselbe Methode verfügt.

  _.prototype = wrapper.prototype;

 

  //Ein Objekt zurückgeben. Wenn der aktuelle Underscore die Methode chain() aufruft (d. h. das _chain-Attribut ist wahr), wird ein umschlossenes Underscore-Objekt zurückgegeben, andernfalls wird das Objekt selbst zurückgegeben.

  // Ergebnisfunktion</array>