Backbone.js 0.9.2 Ulasan Kod Sumber Terjemahan Bahasa Cina Versi_Pengetahuan Asas

// Backbone.js 0.9.2

 

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

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

// Untuk semua butiran dan dokumentasi:

// http://backbonejs.org

(fungsi() {

 

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

  var root = ini;

 

  // Simpan nilai pembolehubah "Backbone" sebelum ia ditimpa

  // Jika terdapat konflik penamaan atau mempertimbangkan spesifikasi, anda boleh menggunakan kaedah Backbone.noConflict() untuk memulihkan nilai pembolehubah sebelum ia diduduki oleh Backbone dan mengembalikan objek Backbone untuk menamakan semula

  var previousBackbone = akar.Backbone;

 

  //Cache kaedah slice dan splice dalam Array.prototype kepada pembolehubah tempatan untuk membuat panggilan

  var slice = Array.prototype.slice;

  var splice = Array.prototype.splice;

 

  var Tulang belakang;

  jika( jenis eksport !== 'tidak ditentukan') {

    Tulang belakang = eksport;

  } lain {

    Tulang belakang = akar. Tulang belakang = {};

  }

 

  //Tentukan versi Backbone

  Backbone.VERSION = '0.9.2';

 

  // Import Underscore secara automatik dalam persekitaran pelayan Beberapa kaedah dalam Backbone bergantung pada atau mewarisi daripada Underscore.

  var _ = akar._;

  jika(!_ && ( jenis memerlukan !== 'tidak ditentukan'))

    _ = memerlukan('garis bawah');

 

  // Tentukan perpustakaan pihak ketiga sebagai pembolehubah bersatu "$", yang digunakan untuk memanggil kaedah dalam pustaka semasa paparan (Lihat), pemprosesan acara dan penyegerakan dengan data pelayan (segerak)

  // Pustaka yang disokong termasuk jQuery, Zepto, dsb. Mereka mempunyai sintaks yang sama, tetapi Zepto lebih sesuai untuk pembangunan mudah alih Ia ditujukan terutamanya kepada pelayar teras Webkit.

  // Anda juga boleh menyesuaikan perpustakaan tersuai dengan sintaks yang serupa dengan jQuery untuk digunakan oleh Backbone (kadangkala kami mungkin memerlukan versi tersuai yang lebih ringan daripada jQuery atau Zepto)

  // "$" yang ditakrifkan di sini ialah pembolehubah tempatan, jadi ia tidak akan menjejaskan penggunaan biasa perpustakaan pihak ketiga di luar rangka kerja Backbone.

  var $ = root.jQuery ||. root. Zepto ||.

 

  // Sediakan perpustakaan pihak ketiga secara manual

  // Jika anda belum mengimport perpustakaan pihak ketiga sebelum mengimport Backbone, anda boleh menetapkan pembolehubah setempat "$" melalui kaedah setDomLibrary

  // Kaedah setDomLibrary juga biasa digunakan untuk mengimport perpustakaan tersuai secara dinamik dalam Backbone.

  Backbone.setDomLibrary = function(lib) {

    $ = lib;

  };

  // Abaikan penamaan rangka kerja selepas "Backbone" dan kembalikan objek Backbone, biasanya digunakan untuk mengelakkan konflik penamaan atau menyeragamkan kaedah penamaan

  // Contohnya:

  // var bk = Backbone.noConflict(); // Batalkan penamaan "Backbone" dan simpan objek Backbone dalam pembolehubah bk

  // console.log(Backbone); // Pembolehubah ini tidak lagi boleh mengakses objek Backbone dan dipulihkan kepada nilai sebelum Backbone ditakrifkan.

  // var MyBackbone = bk; // Dan bk menyimpan objek Backbone, kami menamakannya kepada MyBackbone

  Backbone.noConflict = function() {

    akar.Backbone = sebelumnyaBackbone;

    pulangkan ini;

  };

  // Untuk pelayar yang tidak menyokong REST, anda boleh menetapkan Backbone.emulateHTTP = true

  // Permintaan pelayan akan dihantar dalam mod POST, dan parameter _method akan ditambahkan pada data untuk mengenal pasti nama operasi, dan maklumat pengepala X-HTTP-Method-Override juga akan dihantar.

  Backbone.emulateHTTP = palsu;

 

  // Untuk penyemak imbas yang tidak menyokong pengekodan aplikasi/json, anda boleh menetapkan Backbone.emulateJSON = true;

  //Tetapkan jenis permintaan kepada application/x-www-form-urlencoded, dan letakkan data dalam parameter model untuk mencapai keserasian

  Backbone.emulateJSON = palsu;

 

  // Backbone.Events berkaitan dengan acara tersuai

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

 

  // eventSplitter menentukan peraturan penghuraian untuk nama acara apabila memproses berbilang acara.

  var eventSplitter = /s /;

 

  // Pengurus acara tersuai

  // Dengan mengikat kaedah berkaitan Peristiwa dalam objek, ia dibenarkan untuk menambah, memadam dan mencetuskan peristiwa tersuai pada objek.

  var Acara = Tulang Belakang.Acara = {

 

    // Ikat peristiwa tersuai dan fungsi panggil balik pada objek semasa

    //Objek konteks dalam fungsi panggil balik ialah konteks yang ditentukan Jika konteks tidak ditetapkan, objek konteks lalai kepada objek peristiwa terikat semasa.

    // Kaedah ini serupa dengan kaedah addEventListener dalam DOM Level2

    // acara membenarkan penentuan berbilang nama acara, dipisahkan oleh aksara ruang putih (seperti ruang, tab, dll.)

    // Apabila nama acara ialah "semua", apabila sebarang peristiwa dicetuskan dengan memanggil kaedah pencetus, semua fungsi panggil balik yang terikat dalam acara "semua" akan dipanggil.

    on : function(events, callback, context) {

      //Tentukan pembolehubah tempatan yang digunakan dalam beberapa fungsi

      var panggilan, acara, nod, ekor, senarai;

      //Fungsi panggil balik mesti ditetapkan

      jika(!panggilan balik)

        pulangkan ini;

      // Menghuraikan nama acara melalui eventSplitter, gunakan split untuk memisahkan berbilang nama acara ke dalam tatasusunan

      // Biasanya menggunakan aksara kosong untuk menentukan berbilang nama acara

      peristiwa = events.split(eventSplitter);

      // panggilan merekodkan senarai peristiwa dan fungsi panggil balik yang terikat dalam objek semasa

      panggilan = ini._panggilan balik ||. (ini._panggilan balik = {});

 

      // Gelung senarai nama acara dan simpan nama acara dalam pembolehubah acara dari awal hingga akhir.

      while( event = events.shift()) {

        // Dapatkan fungsi panggil balik yang telah terikat pada acara acara

        // list menyimpan senarai fungsi panggil balik yang terikat pada satu nama acara

        // Senarai fungsi tidak disimpan dalam tatasusunan, tetapi dikaitkan secara berurutan melalui atribut seterusnya bagi berbilang objek.

        /**数据格式如:

         * {

         * ekor: {Objek},

         * seterusnya: {

         * panggil balik: {Fungsi},

         * konteks: {Objek},

         * seterusnya: {

         * panggil balik: {Fungsi},

         * konteks: {Objek},

         * seterusnya: {Objek}

         * }

         * }

         * }*/

        // Objek seterusnya pada setiap peringkat senarai menyimpan maklumat yang berkaitan dengan acara panggil balik (badan fungsi, konteks dan acara panggil balik seterusnya)

        // Tahap atas senarai acara menyimpan objek ekor, yang menyimpan pengecam acara panggil balik terikat terakhir (objek yang sama dengan acara panggil balik terakhir yang seterusnya)

        // Melalui pengecam ekor, anda boleh mengetahui bahawa fungsi panggil balik terakhir telah dicapai apabila melintasi senarai panggilan balik

        senarai = panggilan[acara];

        // Pembolehubah nod digunakan untuk merekod maklumat yang berkaitan dengan fungsi panggil balik ini.

        //tail hanya menyimpan pengecam bagi fungsi panggil balik terikat terakhir

        // Oleh itu, jika fungsi panggil balik telah diikat sebelum ini, tetapkan ekor sebelumnya kepada nod sebagai objek, dan kemudian buat pengecam objek baharu untuk ekor

        // Sebab mengapa peristiwa panggil balik ini ditambahkan pada objek ekor panggilan balik sebelumnya adalah untuk mengatur hierarki objek senarai fungsi panggil balik dalam susunan mengikat (peristiwa terikat terbaru akan diletakkan di bawah)

        nod = senarai ? list.tail : {};

        node.next = ekor = {};

        //Rekodkan badan fungsi dan maklumat konteks panggilan balik ini

        node.context = konteks;

        node.callback = panggil balik;

        //Himpunkan semula senarai panggilan balik acara semasa, acara panggil balik ini telah ditambahkan pada senarai

        panggilan[acara] = {

          ekor: ekor,

          seterusnya : senarai ? list.next : nod

        };

      }

      // Kembalikan objek semasa untuk memudahkan panggilan rantai kaedah

      pulangkan ini;

    },

    // Alih keluar acara terikat atau fungsi panggil balik dalam objek Anda boleh menapis acara atau fungsi panggil balik yang perlu dipadamkan melalui acara, panggilan balik dan konteks.

    // - Jika konteks kosong, alih keluar semua fungsi yang ditentukan oleh panggil balik

    // - Jika panggilan balik kosong, alih keluar semua fungsi panggil balik dalam acara tersebut

    // - Jika acara kosong, tetapi panggilan balik atau konteks ditentukan, alih keluar fungsi panggil balik yang ditentukan oleh panggilan balik atau konteks (nama acara tidak dibezakan)

    // - Jika tiada parameter diluluskan, alih keluar semua peristiwa dan fungsi panggil balik yang terikat dalam objek

    off : function(events, callback, context) {

      acara var, panggilan, nod, ekor, cb, ctx;

 

      // Tiada acara, atau mengalih keluar *semua* acara.

      //Objek semasa tidak mempunyai sebarang peristiwa yang terikat kepadanya

      jika(!( panggilan = ini._panggilan balik))

        kembali;

      // Jika tiada parameter dinyatakan, alih keluar semua acara dan fungsi panggil balik (alih keluar atribut _callbacks)

      if(!(peristiwa || panggil balik || konteks)) {

        padam ini._callbacks;

        pulangkan ini;

      }

 

      // Parse senarai acara yang perlu dialih keluar

      // - Jika peristiwa ditentukan, nama acara dihuraikan mengikut eventSplitter

      // - Jika peristiwa tidak dinyatakan, huraikan senarai nama semua acara terikat

      peristiwa = peristiwa ? events.split(eventSplitter): _.keys(panggilan);

 

      // Gelung senarai nama acara

      while( event = events.shift()) {

        // Alih keluar objek peristiwa semasa daripada senarai dan cache dalam pembolehubah nod

        nod = panggilan[peristiwa];

        padamkan panggilan[acara];

        // Jika objek peristiwa semasa tidak wujud (atau tiada syarat penapis penyingkiran ditentukan, acara semasa dan semua fungsi panggil balik dianggap sebagai dialih keluar), kemudian tamatkan operasi ini (objek acara telah dialih keluar dalam langkah sebelumnya )

        if(!nod || !(panggilan balik || konteks))

          teruskan;

        // Cipta senarai baharu, meninggalkan panggilan balik yang ditunjukkan.

        // Mengikut fungsi panggil balik atau keadaan penapis konteks, kumpulkan objek acara baharu dan ikat semula

        ekor = node.tail;

        // Lintas semua objek panggil balik dalam acara tersebut

        while(( nod = nod.next) !== ekor) {

          cb = node.panggilan balik;

          ctx = node.context;

          // Berdasarkan fungsi panggil balik dan konteks dalam parameter, tapis fungsi panggil balik dan ikat semula fungsi panggil balik yang tidak memenuhi syarat penapisan kepada acara (kerana semua fungsi panggil balik dalam acara telah dialih keluar di atas)

          if((panggilan balik && cb !== panggil balik) || (konteks && ctx !== konteks)) {

            this.on(acara, cb, ctx);

          }

        }

      }

 

      pulangkan ini;

    },

    // Cetuskan satu atau lebih peristiwa yang telah ditakrifkan, dan laksanakan senarai fungsi panggil balik terikat dalam urutan

    pencetus : fungsi(peristiwa) {

      acara var, nod, panggilan, ekor, args, semua, rehat;

      //Objek semasa tidak mempunyai sebarang peristiwa yang terikat kepadanya

      jika(!( panggilan = ini._panggilan balik))

        pulangkan ini;

      // Dapatkan senarai acara "semua" terikat dalam senarai fungsi panggil balik

      semua = panggilan.semua;

      // Parsing nama acara yang perlu dicetuskan ke dalam tatasusunan mengikut peraturan eventSplitter

      peristiwa = events.split(eventSplitter);

      // Rekod parameter pencetus dari pemboleh ubah kedua ke selebihnya, yang akan dihantar ke fungsi panggil balik secara bergilir.

      rehat = slice.call(argumen, 1);

 

      // Gelung senarai acara yang perlu dicetuskan

      while( event = events.shift()) {

        // Pembolehubah nod di sini merekodkan senarai semua fungsi panggil balik peristiwa semasa

        if( nod = panggilan [peristiwa]) {

          //Pembolehubah ekor merekodkan ID objek peristiwa mengikat terakhir

          ekor = node.tail;

          //Nilai pembolehubah nod diberikan kepada objek acara panggilan balik tunggal terikat dalam urutan mengikut susunan pengikatan acara.

          // Sifat seterusnya bagi peristiwa terikat terakhir merujuk kepada objek yang sama seperti ekor, yang digunakan sebagai asas untuk menilai sama ada penghujung senarai telah dicapai.

          while(( nod = nod.next) !== ekor) {

            // Laksanakan semua peristiwa terikat dan lulus parameter apabila memanggil pencetus ke fungsi panggil balik

            node.callback.apply(node.context || ini, rehat);

          }

        }

        // Pembolehubah semua merekodkan acara "semua" semasa mengikat, iaitu, apabila sebarang acara dipanggil, fungsi panggil balik dalam acara "semua" akan dilaksanakan.

        // - Fungsi panggil balik dalam acara "semua", tanpa mengira susunan yang mengikat, akan dilaksanakan secara berurutan selepas semua senarai fungsi panggil balik acara semasa telah dilaksanakan.

        // - Peristiwa "semua" harus dipanggil secara automatik apabila peristiwa biasa dicetuskan Jika acara "semua" dipaksa untuk dicetuskan, fungsi panggil balik dalam acara itu akan dilaksanakan dua kali.

        if(nod = semua) {

          ekor = node.tail;

          //Perbezaan daripada memanggil fungsi panggil balik acara biasa ialah semua peristiwa akan menghantar nama acara yang dipanggil sebagai parameter pertama kepada fungsi panggil balik.

          args = [event].concat(rehat);

          // Lintas dan laksanakan senarai fungsi panggil balik dalam acara "semua".

          while(( nod = nod.next) !== ekor) {

            node.callback.apply(node.context || this, args);

          }

        }

      }

 

      pulangkan ini;

    }

  };

 

  // Alias ​​untuk acara mengikat dan acara keluaran, juga untuk keserasian dengan versi Backbone sebelumnya

  Events.bind = Events.on;

  Events.unbind = Events.off;

 

  // Model objek data Tulang Belakang.Model

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

 

  // Model ialah kelas asas bagi semua model objek data dalam Backbone, digunakan untuk mencipta model data

  // @param {Object} atribut menentukan data permulaan apabila mencipta model

  // @param {Objek} pilihan

  /*** Pilihan @format

   * {

   * menghuraikan: {Boolean},

   * koleksi: {Collection}

   * }*/

  var Model = Tulang Belakang.Model = fungsi(atribut, pilihan) {

    // Pembolehubah lalai digunakan untuk menyimpan data lalai model

    lalai var;

    // Jika parameter atribut tidak ditentukan, tetapkan atribut kepada objek kosong

    atribut ||. ( atribut = {});

    //Tetapkan kaedah penghuraian data lalai atribut Sebagai contoh, data lalai diperoleh daripada pelayan (atau data asal dalam format XML agar serasi dengan format data yang diperlukan oleh kaedah yang ditetapkan, parse kaedah boleh digunakan untuk menghurai.

    if(options && options.parse)

      atribut = this.parse(atribut);

    if( lalai = getValue(ini, 'lalai')) {

      // Jika Model menetapkan data lalai apabila ia ditakrifkan, data permulaan menggunakan data yang digabungkan dengan parameter lalai dan atribut (data dalam atribut akan menimpa data dengan nama yang sama dalam lalai)

      atribut = _.extend({}, lalai, atribut);

    }

    // Nyatakan secara eksplisit objek Koleksi yang dimiliki oleh model (apabila memanggil tambah, tolak dan kaedah Koleksi lain untuk menambah model pada koleksi, objek Koleksi yang dimiliki model akan ditetapkan secara automatik)

    if(options && options.collection)

      this.collection = pilihan.koleksi;

    //Atribut atribut menyimpan data objek JSON bagi model semasa dan kosong secara lalai apabila mencipta model.

    this.attributes = {};

    // Define _escapedAttributes cache object, yang akan cache data diproses melalui kaedah escape

    this._escapedAttributes = {};

    // Konfigurasikan pengecam unik untuk setiap model

    this.cid = _.uniqueId('c');

    //Tentukan satu siri objek yang digunakan untuk merekodkan status data Sila rujuk komen semasa mentakrifkan objek untuk maksud tertentu.

    this.changed = {};

    ini._senyap = {};

    ini._pending = {};

    // Tetapkan data pemulaan apabila membuat contoh Gunakan parameter senyap untuk kali pertama dan peristiwa perubahan tidak akan dicetuskan.

    this.set(atribut, {

      senyap : benar

    });

    // Data pemulaan telah ditetapkan di atas Status objek yang diubah, _senyap, _pending mungkin telah berubah Mulakan semula di sini.

    this.changed = {};

    ini._senyap = {};

    ini._pending = {};

    // Pembolehubah _previousAttributes menyimpan salinan data model

    // Digunakan untuk mendapatkan keadaan sebelum data model diubah dalam peristiwa perubahan Data keadaan sebelumnya boleh diperolehi melalui kaedah Atribut sebelumnya atau sebelumnya.

    this._previousAttributes = _.clone(this.attributes);

    //Kaedah permulaan permulaan panggilan

    this.initialize.apply(this, arguments);

  };

  // Gunakan kaedah lanjutan untuk menentukan satu siri sifat dan kaedah untuk prototaip Model

  _.extend(Model.prototype, Events, {

 

    //Atribut yang diubah merekodkan koleksi kunci data yang diubah setiap kali kaedah yang ditetapkan dipanggil.

    berubah: null,

 

    // // Apabila atribut senyap ditentukan, peristiwa perubahan tidak akan dicetuskan dan data yang diubah akan direkodkan sehingga peristiwa perubahan seterusnya dicetuskan.

    // Atribut _silent digunakan untuk merekod data yang diubah apabila senyap digunakan

    _senyap : null,

 

    _pending : null,

 

    // Atribut pengenalan unik bagi setiap model (lalai ialah "id", nama atribut id boleh disesuaikan dengan mengubah suai idAttribute)

    // Jika atribut id disertakan semasa menetapkan data, id akan mengatasi id model.

    // Id digunakan untuk mencari dan mengenal pasti model dalam Koleksi Apabila berkomunikasi dengan antara muka bahagian belakang, id juga akan digunakan sebagai pengecam rekod.

    idAttribute: 'id',

 

    // Kaedah permulaan model, dipanggil secara automatik selepas model dibina

    mulakan : function() {

    },

    // Kembalikan salinan data dalam model semasa (format objek JSON)

    toJSON : fungsi(pilihan) {

      return _.clone(this.attributes);

    },

    //Mengikut nama atribut attr, dapatkan nilai data dalam model

    dapatkan : function(attr) {

      kembalikan this.attributes[attr];

    },

    //Mengikut nama atribut attr, dapatkan nilai data dalam model Aksara khas HTML yang terkandung dalam nilai data akan ditukar kepada entiti HTML, termasuk & >

    // Dilaksanakan melalui kaedah _.escape

    melarikan diri : function(attr) {

      varhtml;

      // Cari data daripada objek cache _escapedAttributes dan kembalikan terus jika data telah dicache

      if(html = this._escapedAttributes[attr])

        kembalikan html;

      // Tiada data ditemui dalam objek cache _escapedAttributes

      // Kemudian dapatkan data daripada model dahulu

      var val = this.get(attr);

      // Tukar HTML dalam data kepada entiti menggunakan kaedah _.escape, dan cache ia ke objek _escapedAttributes untuk mendapatkan semula dengan mudah pada masa akan datang

      kembalikan ini._escapedAttributes[attr] = _.escape(val == null ? '' : '' val);

    },

    // Semak sama ada atribut tertentu wujud dalam model Apabila nilai atribut ditukar kepada jenis Boolean dan nilainya palsu, ia dianggap tidak wujud.

    // Jika nilai adalah palsu, batal, tidak ditentukan, 0, NaN atau rentetan kosong, ia akan ditukar kepada palsu

    mempunyai : function(attr) {

      return this.get(attr) != null;

    },

    //Tetapkan data dalam model Jika nilai kunci tidak wujud, ia akan ditambahkan pada model sebagai atribut baharu Jika nilai kunci sudah wujud, ia akan diubah suai kepada nilai baharu.

    set : fungsi(kunci, nilai, pilihan) {

      // Rekod objek data yang perlu ditetapkan dalam pembolehubah attr

      var attrs, attr, val;

 

      // Borang parameter membenarkan bentuk objek nilai kunci, atau tetapan berasingan melalui parameter kunci dan nilai.

      // Jika kunci ialah objek, ia dianggap ditetapkan dalam bentuk objek, dan parameter kedua akan dianggap sebagai parameter pilihan.

      if(_.isObject(key) || key == null) {

        attrs = kunci;

        pilihan = nilai;

      } lain {

        // Tetapkan dua parameter kunci dan nilai secara berasingan, dan letakkan data ke dalam objek attrs untuk pemprosesan bersatu.

        attrs = {};

        attrs[key] = nilai;

      }

 

      // Item konfigurasi pilihan mestilah objek Jika pilihan tidak ditetapkan, nilai lalai ialah objek kosong.

      pilihan ||. ( pilihan = {});

      // Tiada tindakan dilakukan apabila tiada parameter ditetapkan.

      jika(!attrs)

        pulangkan ini;

      // Jika objek data yang ditetapkan adalah milik contoh kelas Model, tetapkan objek data atribut objek Model kepada attrs

      // Secara amnya, tindakan ini akan dilakukan apabila menyalin data dari satu objek Model ke objek Model yang lain.

      if(attrs instanceof Model)

        attrs = attrs.attributes;

      // Jika atribut unset ditetapkan dalam objek konfigurasi pilihan, tetapkan semula semua atribut dalam objek data attrs kepada undefined

      // Secara amnya, operasi ini dilakukan apabila menyalin data dari satu objek Model ke objek Model yang lain, tetapi hanya data dalam Model perlu disalin tanpa menyalin nilai.

      if(options.unset)

        untuk(attr dalam attrs)

        attrs[attr] =

        batal 0;

 

      //Sahkan data semasa dan hentikan pelaksanaan jika pengesahan gagal

      if(!this._validate(attrs, options))

        kembali palsu;

 

      // Jika nama atribut id yang ditetapkan disertakan dalam pengumpulan data, tulis ganti id kepada atribut id model

      // Ini adalah untuk memastikan bahawa selepas menyesuaikan nama atribut id, id boleh diakses dengan betul apabila mengakses atribut id model.

      if(this.idAttribute in attrs)

        this.id = attrs[this.idAttribute];

 

      var changes = options.changes = {};

      // kini merekodkan objek data dalam model semasa

      var now = this.attributes;

      // escaped merekodkan data yang dicache oleh escape dalam model semasa

      var escaped = ini._escapedAttributes;

      // prev merekodkan nilai sebelum data dalam model ditukar

      var prev = this._previousAttributes ||.

 

      // Lintas objek data yang perlu ditetapkan

      for(attr in attrs) {

        // attr menyimpan nama atribut semasa, val menyimpan nilai atribut semasa

        val = attrs[attr];

 

        // Jika data semasa tidak wujud dalam model, atau telah berubah, atau pemadaman atribut yang tidak ditetapkan ditentukan dalam pilihan, padamkan data yang digantikan oleh data dalam _escapedAttributes.

        if(!_.isEqual(now[attr], val) || (options.unset && _.has( now, attr))) {

          // Hanya padam data yang dicache melalui escape Ini adalah untuk memastikan bahawa data dalam cache disegerakkan dengan data sebenar dalam model.

          delete escaped[attr];

          // Jika atribut senyap ditentukan, peristiwa perubahan tidak akan dicetuskan oleh panggilan kaedah yang ditetapkan ini, jadi data yang diubah akan direkodkan dalam atribut _senyap supaya pada kali seterusnya peristiwa perubahan dicetuskan, fungsi mendengar acara akan dimaklumkan bahawa data telah berubah.

          // Jika atribut senyap tidak ditentukan, tetapkan data semasa dalam atribut perubahan kepada keadaan berubah.

          (pilihan.senyap ? ini._senyap : berubah)[attr] = benar;

        }

 

        // Jika tidak ditetapkan ditetapkan dalam pilihan, padamkan data (termasuk kunci) daripada model

        // Jika atribut yang tidak ditetapkan tidak ditentukan, ia dianggap bahawa data baharu atau diubah suai akan ditambah dan data baharu akan ditambahkan pada objek data model.

        pilihan.tidak ditetapkan?

        padam sekarang[attr] : sekarang[attr] = val;

 

        // Jika data dalam model tidak konsisten dengan data baharu, ini bermakna data telah berubah

        if(!_.isEqual(prev[attr], val) || (_.has( now, attr) != _.has(prev, attr))) {

          // Rekodkan status yang diubah bagi atribut semasa dalam atribut yang diubah

          this.changed[attr] = val;

          jika(!pilihan.senyap)

            this._pending[attr] = benar;

        } lain {

          // Jika data tidak berubah, alih keluar status yang diubah daripada atribut yang diubah

          delete this.changed[attr];

          delete this._pending[attr];

        }

      }

 

      // Panggil kaedah perubahan, yang akan mencetuskan fungsi terikat kepada peristiwa perubahan

      jika(!pilihan.senyap)

        this.change(options);

      pulangkan ini;

    },

    //Padam data yang ditentukan daripada model semasa (atribut juga akan dipadamkan pada masa yang sama)

    unset : function(attr, pilihan) {

      (pilihan || ( pilihan = {})).tidak ditetapkan = benar;

      // Maklumkan kaedah yang ditetapkan untuk melaksanakan operasi pemadaman melalui item konfigurasi options.unset

      kembalikan this.set(attr, null, options);

    },

    // Kosongkan semua data dan atribut dalam model semasa

    jelas : fungsi(pilihan) {

      (pilihan || ( pilihan = {})).tidak ditetapkan = benar;

      // Klon salinan sifat model semasa dan beritahu kaedah yang ditetapkan untuk melaksanakan operasi pemadaman melalui item konfigurasi options.unset

      kembalikan this.set(_.clone(this.attributes), options);

    },

    // Dapatkan data model lalai daripada pelayan Selepas mendapatkan data, gunakan kaedah yang ditetapkan untuk mengisi data ke dalam model Oleh itu, jika data yang diperoleh tidak konsisten dengan data dalam model semasa, peristiwa perubahan akan dicetuskan .

    ambil : function(pilihan) {

      // Pastikan pilihan ialah objek baharu, dan kemudian tukar sifat dalam pilihan

      pilihan = pilihan _.klon(pilihan): {};

      model var = ini;

      // Dalam pilihan, anda boleh menentukan fungsi panggil balik tersuai selepas data berjaya diperoleh.

      var success = options.success;

      // Apabila data berjaya diperolehi, isikan data dan panggil fungsi panggil balik kejayaan tersuai

      options.success = function(resp, status, xhr) {

        // Tukar data yang dikembalikan oleh pelayan melalui kaedah parse

        // Isikan data yang ditukar ke dalam model melalui kaedah yang ditetapkan, jadi peristiwa perubahan mungkin dicetuskan (apabila data berubah)

        // Jika pengesahan gagal semasa mengisi data, fungsi panggil balik kejayaan tersuai tidak akan dipanggil

        jika(!model.set(model.parse(resp, xhr), pilihan))

          kembali palsu;

        //Panggil fungsi panggil balik kejayaan tersuai

        jika (berjaya)

          kejayaan(model, resp);

      };

      // Kendalikan peristiwa ralat melalui wrapError apabila ralat berlaku dalam permintaan

      options.error = Backbone.wrapError(options.error, model, options);

      // Panggil kaedah penyegerakan untuk mendapatkan data daripada pelayan

      return (this.sync || Backbone.sync).panggilan(ini, 'baca', ini, pilihan);

    },

    //Simpan data dalam model ke pelayan

    simpan : fungsi(kunci, nilai, pilihan) {

      // attrs menyimpan objek data yang perlu disimpan ke pelayan

      var attrs, semasa;

 

      //Menyokong menetapkan kunci atribut tunggal: nilai

      // Menyokong kaedah tetapan kelompok dalam bentuk objek {key: value}

      if(_.isObject(key) || key == null) {

        // Jika kunci ialah objek, ia dianggap ditetapkan melalui kaedah objek

        // Pada masa ini parameter kedua dianggap sebagai pilihan

        attrs = kunci;

        pilihan = nilai;

      }lain {

        // Jika satu atribut ditetapkan dalam bentuk kunci: nilai, tetapkan attrs secara langsung

        attrs = {};

        attrs[key] = nilai;

      }

      // Objek konfigurasi mestilah objek baharu

      pilihan = pilihan _.klon(pilihan): {};

 

      // Jika pilihan tunggu ditetapkan dalam pilihan, data yang diubah akan disahkan terlebih dahulu, dan apabila pelayan tidak bertindak balas kepada data baharu (atau respons gagal), data tempatan akan dipulihkan kepada keadaan sebelum pengubahsuaian.

      // Jika pilihan tunggu tidak ditetapkan, data setempat akan diubah suai kepada status terkini tanpa mengira sama ada pelayan berjaya ditetapkan.

      if(options.wait) {

        // Sahkan data yang perlu disimpan terlebih dahulu

        if(!this._validate(attrs, options))

          kembali palsu;

        //Rekod data dalam model semasa, digunakan untuk memulihkan data selepas menghantarnya ke pelayan

        // Jika respons pelayan gagal atau tiada data dikembalikan, keadaan sebelum pengubahsuaian boleh dikekalkan

        semasa = _.clone(this.attributes);

      }

 

      // silentOptions menambah senyap pada objek pilihan (tiada pengesahan data)

      // Gunakan item konfigurasi silentOptions apabila menggunakan parameter tunggu, kerana data telah disahkan di atas

      // Jika parameter tunggu tidak ditetapkan, item konfigurasi pilihan asal masih digunakan

      var silentOptions = _.lanjutkan({}, pilihan, {

        senyap : benar

      });

      // Simpan data terbaharu yang diubah suai pada model, supaya data model boleh diperolehi dalam kaedah penyegerakan dan disimpan ke pelayan.

      if(attrs && !this.set(attrs, options.wait ? silentOptions : options)) {

        kembali palsu;

      }

 

      model var = ini;

      // Dalam pilihan, anda boleh menentukan fungsi panggil balik tersuai selepas berjaya menyimpan data.

      var success = options.success;

      //Laksanakan kejayaan selepas pelayan bertindak balas dengan jayanya

      options.success = function(resp, status, xhr) {

        // Dapatkan data status terkini bagi respons pelayan

        var serverAttrs = model.parse(resp, xhr);

        // Jika parameter tunggu digunakan, status data yang diubah suai akan ditetapkan terus kepada model terlebih dahulu.

        if(options.wait) {

          padam pilihan.tunggu;

          serverAttrs = _.extend(attrs || {}, serverAttrs);

        }

        //Tetapkan status data terkini ke dalam model

        // Jika pengesahan gagal semasa memanggil kaedah yang ditetapkan, fungsi panggil balik kejayaan tersuai tidak akan dipanggil.

        if(!model.set(serverAttrs, options))

          kembali palsu;

        jika(berjaya) {

          //Panggil fungsi panggil balik kejayaan tersuai selepas respons berjaya

          kejayaan(model, resp);

        } lain {

          // Jika tiada panggilan balik tersuai ditentukan, peristiwa penyegerakan dicetuskan secara lalai

          model.trigger('sync', model, resp, options);

        }

      };

      // Kendalikan peristiwa ralat melalui wrapError apabila ralat berlaku dalam permintaan

      options.error = Backbone.wrapError(options.error, model, options);

      //Simpan data dalam model ke pelayan

      // Jika model semasa ialah model yang baru dibuat (tanpa id), gunakan kaedah cipta (baru), jika tidak, ia dianggap sebagai kaedah kemas kini (diubah suai)

      kaedah var = this.isNew() 'create' : 'update';

      var xhr = (this.sync || Backbone.sync).panggilan(ini, kaedah, ini, pilihan);

      // Jika options.wait ditetapkan, pulihkan data kepada keadaan sebelum pengubahsuaian

      // Permintaan yang disimpan belum menerima respons pada masa ini, jadi jika respons gagal, model akan kekal dalam keadaan sebelum pengubahsuaian Jika pelayan bertindak balas dengan jayanya, data dalam model akan ditetapkan kepada keadaan terkini dalam kejayaan .

      jika(pilihan.tunggu)

        this.set(current, silentOptions);

      pulangkan xhr;

    },

    //Padam model, model akan dipadamkan daripada Koleksi yang dimilikinya.

    // Jika model dibuat pada klien, padamkannya terus daripada klien.

    // Jika data model wujud pada pelayan pada masa yang sama, data sebelah pelayan akan dipadamkan pada masa yang sama.

    musnahkan : fungsi(pilihan) {

      // Item konfigurasi mestilah objek baharu

      pilihan = pilihan _.klon(pilihan): {};

      model var = ini;

      // Dalam pilihan, anda boleh menentukan fungsi panggil balik tersuai selepas data berjaya dipadamkan.

      var success = options.success;

      // Berjaya dipanggil untuk memadam data, peristiwa musnah dicetuskan Jika model wujud dalam Koleksi, koleksi akan mendengar peristiwa musnah dan mengalih keluar model daripada koleksi apabila dicetuskan.

      // Apabila memadamkan model, data dalam model belum dikosongkan, tetapi model telah dialih keluar daripada koleksi, jadi apabila tiada rujukan kepada model di mana-mana sahaja, ia akan dikeluarkan secara automatik daripada memori.

      // Adalah disyorkan untuk menetapkan pembolehubah rujukan objek model kepada null apabila memadam model.

      var triggerDestroy = function() {

        model.trigger('musnahkan', model, model.collection, pilihan);

      };

      // Jika model ialah model yang baru dicipta oleh pelanggan, hubungi terus triggerDestroy untuk mengalih keluar model daripada koleksi.

      if(this.isNew()) {

        triggerDestroy();

        kembali palsu;

      }// Apabila memadam data daripada pelayan berjaya

      options.success = function(resp) {

        // Jika item tunggu dikonfigurasikan dalam objek pilihan, ini bermakna data model dalam memori tempatan akan dipadamkan selepas data pelayan berjaya dipadamkan.

        // Jika respons pelayan gagal, data tempatan tidak akan dipadamkan

        jika(pilihan.tunggu)

          triggerDestroy();

        jika(berjaya) {

          //Panggil fungsi panggil balik kejayaan tersuai

          kejayaan(model, resp);

        } lain {

          // Jika tiada panggilan balik tersuai, peristiwa penyegerakan dicetuskan secara lalai

          model.trigger('sync', model, resp, options);

        }

      };

      // Kendalikan peristiwa ralat melalui wrapError apabila ralat berlaku dalam permintaan

      options.error = Backbone.wrapError(options.error, model, options);

      //Hantar permintaan untuk memadam data melalui kaedah penyegerakan

      var xhr = (this.sync || Backbone.sync).panggilan(ini, 'padam', ini, pilihan);

      // Jika item tunggu tidak dikonfigurasikan dalam objek pilihan, data tempatan akan dipadamkan dahulu, dan kemudian permintaan akan dihantar untuk memadam data pelayan.

      // Pada masa ini, tidak kira sama ada pemadaman pelayan berjaya atau tidak, data model tempatan telah dipadamkan.

      jika(!pilihan.tunggu)

        triggerDestroy();

      pulangkan xhr;

    },

    // Dapatkan URL yang sepadan dengan model dalam antara muka pelayan Apabila memanggil save, fetch, destroy dan kaedah lain untuk berinteraksi dengan pelayan, kaedah ini akan digunakan untuk mendapatkan URL.

    // URL yang dijana adalah serupa dengan mod "PATHINFO" Pelayan hanya mempunyai satu URL untuk operasi model Untuk operasi pengubahsuaian dan pemadaman, ID model akan dilampirkan pada URL untuk pengenalan mudah.

    // Jika urlRoot ditakrifkan dalam model, antara muka pelayan hendaklah dalam bentuk [urlRoot/id]

    // Jika Koleksi yang dimiliki oleh model mentakrifkan kaedah atau atribut url, gunakan borang url dalam koleksi: [collection.url/id]

    // Apabila mengakses url pelayan, id model akan dilampirkan pada url untuk memudahkan pelayan mengenal pasti rekod, jadi id dalam model perlu sepadan dengan rekod pelayan.

    // Jika url model atau koleksi tidak dapat diperoleh, kaedah urlError akan dipanggil dan pengecualian akan dibuang.

    // Jika antara muka pelayan tidak disusun mengikut "PATHINFO", anda boleh mencapai interaksi lancar dengan pelayan dengan melebihkan kaedah url.

    url : function() {

      //Tentukan laluan url yang sepadan dengan pelayan

      var base = getValue(ini, 'urlRoot') ||. getValue(this.collection, 'url') ||.

      // Jika model semasa ialah model yang baru dicipta oleh klien, tiada atribut id dan url pelayan terus menggunakan pangkalan.

      if(this.isNew())

        pangkalan balik;

      // Jika model semasa mempunyai atribut id, kaedah simpan atau musnah boleh dipanggil dan id model akan dilampirkan pada pangkalan.

      //Perkara berikut akan menentukan sama ada aksara terakhir asas ialah "/", dan format URL yang dijana ialah [base/id]

      return base (base.charAt(base.length - 1) == '/' ? '' : '/') encodeURIComponent(this.id);

    },

    // Kaedah parse digunakan untuk menghuraikan data yang diperoleh daripada pelayan dan mengembalikan data model yang boleh dihuraikan oleh kaedah yang ditetapkan.

    // Secara amnya, kaedah parse akan dibebankan berdasarkan data yang dikembalikan oleh pelayan untuk membina sambungan yang lancar dengan pelayan.

    // Apabila struktur data yang dikembalikan oleh pelayan tidak konsisten dengan struktur data yang diperlukan oleh kaedah yang ditetapkan (contohnya, apabila pelayan mengembalikan data format XML), kaedah parse boleh digunakan untuk penukaran.

    parse : function(resp, xhr) {

      balas balas;

    },

    // Cipta model baharu dengan data yang sama seperti model semasa

    klon : function() {

      kembalikan this.constructor(this.attributes);

    },

    // Semak sama ada model semasa ialah model baharu yang dicipta oleh klien

    // Kaedah semakan adalah berdasarkan sama ada model mempunyai pengecam id Model baharu yang dibuat oleh klien tidak mempunyai pengecam id.

    // Oleh itu, data model yang dijawab oleh pelayan mesti mengandungi pengecam id Nama atribut pengecam secara lalai kepada "id".

    isNew : function() {

      kembalikan this.id == null;

    },

    // Fungsi yang mencetuskan perubahan peristiwa mengikat apabila data dikemas kini

    // Apabila kaedah set dipanggil, kaedah perubahan akan dipanggil secara automatik Jika konfigurasi senyap ditentukan apabila kaedah set dipanggil, kaedah perubahan perlu dipanggil secara manual.

    tukar : fungsi(pilihan) {

      // pilihan mestilah objek

      pilihan ||. ( pilihan = {});

      // Terdapat beberapa masalah dengan logik yang berkaitan dengan ini._mengubah

      // this._changing ditetapkan kepada false pada penghujung kaedah, jadi nilai pembolehubah yang berubah di atas kaedah sentiasa palsu (kali pertama tidak ditentukan)

      // Niat asal pengarang adalah untuk menggunakan pembolehubah ini untuk menunjukkan sama ada kaedah perubahan telah dilaksanakan. Ia tidak bermakna untuk skrip berutas tunggal pada bahagian pelayar kerana kaedah ini akan menyekat skrip lain apabila dilaksanakan.

      // menukar mendapat status pelaksanaan terakhir Jika skrip terakhir belum dilaksanakan, nilainya adalah benar.

      var berubah = ini._berubah;

      //Mula melaksanakan bendera Nilai sentiasa benar semasa pelaksanaan Selepas pelaksanaan, ini._changing diubah menjadi palsu.

      ini._berubah = benar;

 

      //Tambah status data selain daripada perubahan ini pada objek _pending

      for(var attr in this._silent)

      this._pending[attr] = benar;

 

      // Objek perubahan mengandungi semua data yang telah diubah sejak kali terakhir peristiwa perubahan dilaksanakan pada data semasa.

      // Jika peristiwa perubahan tidak dicetuskan dengan menggunakan senyap sebelum ini, ia akan diletakkan dalam objek perubahan kali ini.

      var changes = _.extend({}, options.changes, this._silent);

      //Tetapkan semula objek _senyap

      ini._senyap = {};

      // Lintas objek perubahan dan cetuskan peristiwa perubahan berasingan untuk setiap atribut.

      for(var attr dalam perubahan) {

        // Lulus objek Model, nilai atribut dan item konfigurasi sebagai parameter kepada fungsi mendengar acara

        this.trigger('change:' attr, this, this.get(attr), options);

      }

 

      //Jika kaedah sedang dilaksanakan, hentikan pelaksanaan

      jika (berubah)

        pulangkan ini;

 

      // Cetuskan peristiwa perubahan Selepas sebarang data ditukar, peristiwa "ubah: harta" dan peristiwa "perubahan" akan dicetuskan mengikut urutan.

      while(!_.isEmpty(this._pending)) {

        ini._pending = {};

        // Cetuskan peristiwa perubahan, dan hantar contoh Model dan item konfigurasi sebagai parameter kepada fungsi mendengar

        this.trigger('change', this, options);

        // Lintas data dalam objek yang diubah, dan alih keluar status data yang diubah daripada berubah secara bergilir

        // Selepas ini, jika anda memanggil hasChanged untuk menyemak status data, anda akan mendapat palsu (tidak berubah)

        for(var attr in this.changed) {

          if(this._pending[attr] || this._silent[attr])

            teruskan;

          //Alih keluar status data dalam ditukar

          delete this.changed[attr];

        }

        // Selepas peristiwa perubahan dilaksanakan, atribut _previousAttributes akan merekodkan salinan data terkini model semasa

        // Oleh itu, jika anda perlu mendapatkan keadaan sebelumnya data, anda biasanya hanya boleh mendapatkannya melalui kaedah sebelumnya atau sebelumnyaAttributes dalam peristiwa perubahan yang dicetuskan.

        this._previousAttributes = _.clone(this.attributes);

      }

 

      //Bendera pelaksanaan selesai

      ini._mengubah = palsu;

      pulangkan ini;

    },

    // Semak sama ada data tertentu telah ditukar sejak peristiwa perubahan terakhir dilaksanakan

    /*** Biasanya digunakan bersama dengan kaedah Atribut sebelumnya atau sebelumnya dalam peristiwa perubahan, seperti:

     * if(model.hasChanged('attr')) {

     * var attrPrev = model.previous('attr');

     * }*/

    hasChanged : function(attr) {

      if(!arguments.length)

        return !_.isEmpty(this.changed);

      return _.has(this.changed, attr);

    },

    // Dapatkan pengumpulan data dalam model semasa dan data yang telah berubah dalam data terakhir

    // (Secara amnya, kaedah perubahan tidak dipanggil apabila menggunakan atribut senyap, jadi data akan disimpan sementara dalam atribut yang diubah. Data terakhir boleh diperoleh melalui kaedah Atribut sebelumnya)

    // Jika set perbezaan diluluskan, data model terakhir akan dibandingkan dengan data dalam set perbezaan dan set data yang tidak konsisten akan dikembalikan.

    // Jika tiada perbezaan dalam hasil perbandingan, kembalikan palsu

    changedAttributes : function(diff) {

      // Jika perbezaan tidak dinyatakan, pengumpulan data model semasa yang telah berubah daripada keadaan sebelumnya akan dikembalikan.

      jika(!diff)

        kembalikan this.hasChanged() _.clone(this.changed) : false;

      // Set perbezaan yang perlu dibandingkan ditentukan, dan hasil perbandingan antara data terakhir dan set perbezaan akan dikembalikan.

      //Pembolehubah lama menyimpan data model keadaan sebelumnya

      var val, berubah = palsu, lama = ini._previousAttributes;

      // Lintas koleksi perbezaan dan bandingkan setiap item dengan koleksi keadaan sebelumnya

      for(var attr in diff) {

        // Simpan sementara data dengan hasil perbandingan yang tidak konsisten ke dalam pembolehubah yang diubah

        if(_.isEqual(old[attr], ( val = diff[attr])))

          teruskan;

        (berubah || (berubah = {}))[attr] = val;

      }

      // Kembalikan hasil perbandingan

      pulangan berubah;

    },

    // Dalam peristiwa perubahan yang dicetuskan oleh model, dapatkan data keadaan sebelumnya sebelum atribut ditukar, yang biasanya digunakan untuk perbandingan data atau rollback.

    // Kaedah ini biasanya dipanggil dalam peristiwa perubahan Selepas peristiwa perubahan dicetuskan, atribut _previousAttributes menyimpan data terkini.

    sebelumnya : function(attr) {

      // attr menentukan nama atribut yang perlu mendapatkan keadaan sebelumnya

      if(!arguments.length || !this._previousAttributes)

        kembali null;

      kembalikan ini._previousAttributes[attr];

    },

    // Apabila model mencetuskan peristiwa perubahan, dapatkan pengumpulan data keadaan sebelumnya bagi semua atribut

    // Kaedah ini serupa dengan kaedah sebelumnya() Ia biasanya dipanggil dalam peristiwa perubahan dan digunakan untuk perbandingan data atau rollback.

    Atribut sebelumnya : function() {

      // Klon objek data keadaan sebelumnya ke dalam objek baru dan kembalikan

      return _.clone(this._previousAttributes);

    },

    // Semak sama ada model berada dalam keadaan sah pada masa ini

    // masuk ke dalam keadaan *tidak sah* jika anda menggunakan perubahan senyap.

    // Sahkan sama ada data dalam model semasa boleh disahkan dengan kaedah pengesahan Sila pastikan kaedah pengesahan ditakrifkan sebelum membuat panggilan.

    isValid : function() {

      kembalikan !this.validate(this.attributes);

    },

    // Kaedah pengesahan data dilaksanakan secara automatik apabila memanggil set, simpan, tambah dan kaedah kemas kini data lain.

    // Kegagalan dalam pengesahan akan mencetuskan peristiwa "ralat" objek model Jika fungsi pemprosesan ralat dinyatakan dalam pilihan, hanya fungsi options.error akan dilaksanakan.

    // @param {Object} attrs atribut model data, yang menyimpan data objek model

    // @param {Object} item konfigurasi pilihan

    // @return {Boolean} Mengembalikan benar jika pengesahan lulus, palsu jika gagal.

    _validate : function(attrs, options) {

      // Jika atribut options.silent ditetapkan semasa memanggil tetapkan, simpan, tambah dan kaedah kemas kini data lain, pengesahan diabaikan

      // Jika kaedah pengesahan tidak ditambahkan pada Model, pengesahan diabaikan

      if(options.silent || !this.validate)

        kembali benar;

      // Dapatkan semua nilai atribut dalam objek dan masukkannya ke dalam kaedah pengesahan untuk pengesahan

      //Kaedah pengesahan mengandungi dua parameter, iaitu pengumpulan data dan objek konfigurasi dalam model Jika pengesahan lulus, tiada data akan dikembalikan (lalai tidak ditentukan Jika pengesahan gagal, data dengan maklumat ralat akan dikembalikan .

      attrs = _.extend({}, this.attributes, attrs);

      var error = this.validate(attrs, options);

      //Pengesahan lulus

      jika(!error)

        kembali benar;

      // Pengesahan gagal

      // Jika kaedah pengendalian ralat ralat ditetapkan dalam objek konfigurasi, panggil kaedah ini dan hantar data ralat dan objek konfigurasi kepada kaedah ini

      if(options && options.error) {

        options.error(this, error, options);

      } lain {

        // Jika pendengar peristiwa ralat terikat pada model, peristiwa mengikat akan dicetuskan.

        this.trigger('error', this, error, options);

      }

      // Pengesahan pengembalian gagal pengenalan

      kembali palsu;

    }

  });

 

  // Backbone.Collection pengumpulan model data berkaitan

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

 

  // Koleksi menyimpan satu siri model data kelas yang sama dan menyediakan kaedah berkaitan untuk mengendalikan model

  var Koleksi = Tulang Belakang.Koleksi = fungsi(model, pilihan) {

    //Objek konfigurasi

    pilihan ||. ( pilihan = {});

    //Tetapkan kelas model koleksi dalam parameter konfigurasi

    jika(options.model)

      this.model = pilihan.model;

    // Jika atribut pembanding ditetapkan, data dalam koleksi akan diisih mengikut algoritma pengisihan dalam kaedah pembanding (ia akan dipanggil secara automatik dalam kaedah tambah)

    if(options.comparator)

      this.comparator = options.comparator;

    // Tetapkan semula keadaan dalaman koleksi apabila digunakan (panggilan pertama boleh difahami sebagai keadaan definisi)

    this._reset();

    // Panggil kaedah pemulaan tersuai Jika perlu, kaedah permulaan biasanya akan terlebih beban.

    this.initialize.apply(this, arguments);

    // Jika data model ditentukan, panggil kaedah tetapan semula untuk menambah data pada koleksi.

    // Parameter senyap ditetapkan apabila dipanggil buat kali pertama, jadi acara "set semula" tidak akan dicetuskan.

    jika(model)

      this.reset(models, {

        senyap: benar,

        parse : pilihan.parse

      });

  };

  // Tentukan kaedah prototaip kelas koleksi melalui kaedah lanjutan

  _.extend(Collection.prototype, Events, {

 

    // Tentukan kelas model koleksi Kelas model mestilah subkelas Backbone.Model

    // Apabila menggunakan kaedah berkaitan koleksi (seperti tambah, cipta, dsb.), objek data dibenarkan untuk dihantar masuk. Kaedah pengumpulan akan secara automatik mencipta contoh yang sepadan mengikut kelas model yang ditentukan.

    //Model data yang disimpan dalam koleksi hendaklah semua contoh kelas model yang sama

    model: Model,

 

    // Kaedah permulaan, kaedah ini dipanggil secara automatik selepas contoh koleksi dibuat

    // Kaedah ini biasanya terlebih beban apabila menentukan kelas koleksi

    mulakan : function() {

    },

    // Kembalikan tatasusunan yang mengandungi objek data setiap model dalam koleksi

    toJSON : fungsi(pilihan) {

      // Gunakan kaedah peta Undersocre untuk membentuk tatasusunan hasil toJSON bagi setiap model dalam koleksi dan kembalikan

      kembalikan this.map(function(model) {

        // Panggil kaedah toJSON bagi setiap objek model secara bergilir-gilir Kaedah ini akan mengembalikan objek data model (salinan yang disalin) secara lalai.

        // Jika anda perlu mengembalikan rentetan atau borang lain, anda boleh membebankan kaedah toJSON

        return model.toJSON(options);

      });

    },

    //Tambah satu atau lebih objek model pada koleksi

    // Acara "tambah" akan dicetuskan secara lalai Jika atribut senyap ditetapkan dalam pilihan, pencetusan acara ini boleh dimatikan.

    // Model yang diluluskan boleh menjadi satu atau satu siri objek model (contoh kelas Model Jika atribut model ditetapkan dalam koleksi, objek data (seperti {name: 'test'}) dibenarkan untuk menjadi. dihantar secara langsung secara automatik objek data ke dalam objek model yang ditunjukkan oleh model

    tambah : fungsi(model, pilihan) {

      // Definisi pembolehubah setempat

      var i, indeks, panjang, model, cid, id, cids = {}, id = {}, dups = [];

      pilihan ||. ( pilihan = {});

      // model mestilah array, jika hanya satu model diluluskan, tukarkannya kepada array

      models = _.isArray(models) ? models.slice() : [model];

 

      // Traverse senarai model yang perlu ditambah Semasa proses traversal, operasi berikut akan dilakukan.

      // - Tukar objek data kepada objek model

      // - Wujudkan rujukan antara model dan koleksi

      // - Log model yang tidak sah dan pendua dan tapis kemudian

      untuk( i = 0, panjang = model.panjang; i < panjang; i ) {

        //Tukar objek data kepada objek model, sambung semula rujukan model dan koleksi, dan simpannya dalam model (pada masa yang sama, model yang sepadan dalam model telah digantikan dengan objek model)

        jika(!( model = model[i] = ini._prepareModel(model[i], pilihan))) {

          throw new Error("Tidak boleh menambah model yang tidak sah pada koleksi");

        }

        //Cid dan id model semasa

        cid = model.cid;

        id = model.id;

        //Indeks model tidak sah atau pendua (indeks dalam tatasusunan model) direkodkan dalam tatasusunan dups dan akan ditapis dan dipadamkan dalam langkah seterusnya.

        // Jika indeks model sudah wujud dalam pembolehubah cid dan id, model yang sama dianggap telah diisytiharkan beberapa kali dalam tatasusunan model yang diluluskan.

        // Jika indeks model sudah wujud dalam objek _byCid, _byId, model yang sama dianggap sudah wujud dalam koleksi semasa.

        // Untuk dua situasi di atas, rekodkan indeks model kepada salinan untuk penapisan dan pemadaman

        if(cids[cid] || this._byCid[cid] || ((id != null) && (ids[id] || this._byId[id]))) {

          dups.push(i);

          teruskan;

        }

        // Rekod model yang telah dilalui dalam model untuk pemeriksaan berulang dalam kitaran seterusnya

        cids[cid] = id[id] = model;

      }

 

      // Padam model tidak sah atau pendua daripada model dan simpan senarai model yang benar-benar perlu ditambah pada koleksi semasa.

      i = dups.length;

      manakala(i--) {

        models.splice(dups[i], 1);

      }

 

      // Lintas model yang perlu ditambah, dengar acara model dan rekod _byCid, _byId senarai, yang digunakan sebagai indeks apabila memanggil kaedah get dan getByCid.

      untuk( i = 0, panjang = model.panjang; i < panjang; i ) {

        // Dengar semua acara dalam model dan laksanakan kaedah _onModelEvent

        // Kaedah _onModelEvent akan memproses acara tambah, buang, musnah dan tukar yang dilemparkan oleh model untuk memastikan model disegerakkan dengan keadaan dalam koleksi.

        (model = model[i]).on('semua', ini._onModelEvent, ini);

        //Rekod model ke objek _byCid berdasarkan cid untuk memudahkan carian berdasarkan cid

        this._byCid[model.cid] = model;

        //Rekod model ke objek _byId berdasarkan id untuk memudahkan carian berdasarkan id

        if(model.id != null)

          this._byId[model.id] = model;

      }

 

      //Tukar atribut panjang koleksi Atribut panjang merekodkan bilangan model dalam koleksi semasa.

      ini.panjang = panjang;

      //Tetapkan kedudukan di mana senarai model baharu dimasukkan ke dalam koleksi Jika parameter at ditetapkan dalam pilihan, masukkannya pada kedudukan pada koleksi.

      // Akan disisipkan pada penghujung koleksi secara lalai

      // Jika kaedah pengisihan tersuai pembanding ditetapkan, maka selepas menetapkan di, ia juga akan diisih mengikut kaedah dalam pembanding, jadi susunan akhir mungkin tidak berada pada kedudukan yang ditentukan oleh di

      index = options.at != null ? options.at : this.models.length;

      splice.apply(this.models, [index, 0].concat(models));

      // Jika kaedah pembanding ditetapkan, data akan diisih mengikut algoritma dalam pembanding

      // Pengisihan automatik menggunakan atribut senyap untuk menghalang peristiwa tetapan semula daripada dicetuskan.

      jika(this.comparator)

        this.sort({

          senyap : benar

        });

      // Cetuskan acara "tambah" untuk setiap objek model secara bergilir-gilir Jika atribut senyap ditetapkan, halang acara daripada dicetuskan.

      jika(pilihan.senyap)

        pulangkan ini;

      // Lintas senarai model yang baru ditambah

      untuk( i = 0, panjang = ini.model.panjang; i < panjang; i ) {

        if(!cids[( model = this.models[i]).cid])

          teruskan;

        options.index = i;

        // Cetuskan acara "tambah" model, kerana koleksi mendengar acara "semua" model, jadi dalam kaedah _onModelEvent, koleksi juga akan mencetuskan acara "tambah"

        // Untuk maklumat terperinci, sila rujuk kaedah Collection.prototype._onModelEvent

        model.trigger('tambah', model, ini, pilihan);

      }

      pulangkan ini;

    },

    //Alih keluar objek model daripada koleksi (menyokong mengalih keluar berbilang model)

    //Model yang diluluskan boleh menjadi objek model yang perlu dialih keluar, atau cid model dan id model

    // Mengalih keluar model tidak akan memanggil kaedah memusnahkan model

    // Jika parameter options.silent tidak ditetapkan, peristiwa alih keluar model akan dicetuskan dan peristiwa alih keluar koleksi akan dicetuskan (koleksi mendengar semua peristiwa model melalui kaedah _onModelEvent)

    keluarkan : fungsi(model, pilihan) {

      var i, l, indeks, model;

      // pilihan lalai kepada objek kosong

      pilihan ||. ( pilihan = {});

      // model mestilah daripada jenis tatasusunan, apabila hanya satu model dikeluarkan, masukkannya ke dalam tatasusunan

      models = _.isArray(models) ? models.slice() : [model];

      // Lintas senarai model yang perlu dialih keluar

      untuk( i = 0, l = models.length; i < l; i ) {

        // Senarai model yang diluluskan boleh menjadi objek model yang perlu dialih keluar, atau cid model dan id model

        // (Dalam kaedah getByCid dan get, model boleh diperolehi melalui cid dan id. Jika objek model dimasukkan, model itu sendiri dikembalikan)

        model = this.getByCid(models[i]) ||. this.get(models[i]);

        //Model tidak diperolehi

        jika(!model)

          teruskan;

        // Alih keluar rujukan id model daripada senarai _byId

        padam ini._byId[model.id];

        // Alih keluar rujukan cid model daripada senarai _byCid

        padam ini._byCid[model.cid];

        // indexOf ialah kaedah dalam objek Underscore Di sini, kaedah indexOf digunakan untuk mendapatkan kedudukan di mana model pertama kali muncul dalam koleksi.

        indeks = ini.indexOf(model);

        //Alih keluar model daripada senarai koleksi

        this.models.splice(index, 1);

        // Tetapkan semula sifat panjang koleksi semasa (catat bilangan model dalam koleksi)

        ini.panjang--;

        // Jika atribut senyap tidak ditetapkan, acara alih keluar model akan dicetuskan.

        if(!options.silent) {

          //Tambahkan kedudukan model semasa dalam koleksi ke objek pilihan dan hantar ke acara alih keluar mendengar supaya ia boleh digunakan dalam fungsi acara

          options.index = indeks;

          model.trigger('buang', model, ini, pilihan);

        }

        //Selesaikan hubungan antara model dan koleksi, termasuk rujukan kepada model dan pemantauan acara dalam koleksi

        this._removeReference(model);

      }

      pulangkan ini;

    },

    //Tambah objek model pada penghujung koleksi

    // Jika kaedah pengisihan pembanding ditakrifkan dalam kelas koleksi, model yang ditambah melalui kaedah tolak akan diisih mengikut algoritma yang ditakrifkan oleh pembanding, jadi susunan model boleh diubah.

    push : function(model, pilihan) {

      // Instantiate model menjadi objek model melalui kaedah _prepareModel Kod ini adalah berlebihan, kerana model juga akan diperolehi melalui _prepareModel dalam kaedah tambah yang dipanggil di bawah.

      model = this._prepareModel(model, pilihan);

      //Panggil kaedah tambah untuk menambah model pada koleksi (secara lalai, ia ditambahkan pada penghujung koleksi)

      this.add(model, pilihan);

      model pulangan;

    },

    //Alih keluar objek model terakhir dalam koleksi

    pop : fungsi(pilihan) {

      // Dapatkan model terakhir dalam koleksi

      var model = this.at(this.length - 1);

      //Alih keluar model melalui kaedah keluarkan

      this.remove(model, pilihan);

      model pulangan;

    },

    //Masukkan model ke kedudukan pertama koleksi

    // Jika kaedah pengisihan pembanding ditakrifkan dalam kelas koleksi, model yang ditambah melalui kaedah unshift akan diisih mengikut algoritma yang ditakrifkan oleh pembanding, jadi susunan model boleh diubah.

    unshift : function(model, pilihan) {

      // Instantite model menjadi objek model melalui kaedah _prepareModel

      model = this._prepareModel(model, pilihan);

      //Panggil kaedah tambah untuk memasukkan model ke kedudukan pertama koleksi (tetapkan pada 0)

      // Jika kaedah pengisihan pembanding ditakrifkan, susunan koleksi akan disusun semula

      this.add(model, _.extend({

        pada: 0

      }, pilihan));

      model pulangan;

    },

    // Alih keluar dan kembalikan objek model pertama dalam koleksi

    shift : fungsi(pilihan) {

      // Dapatkan model pertama dalam koleksi

      model var = this.at(0);

      //Alih keluar model daripada koleksi

      this.remove(model, pilihan);

      // Kembalikan objek model

      model pulangan;

    },

    //Cari model daripada koleksi berdasarkan id dan kembalikannya

    dapatkan : function(id) {

      if(id == null)

        kembali

        batal 0;

      kembalikan ini._byId[id.id != null ?

    },

    //Cari model daripada koleksi berdasarkan cid dan kembalikannya

    getByCid : function(cid) {

      pulangkan cid && ini._byCid[cid.cid ||.

    },

    // Cari model dari koleksi mengikut indeks (subskrip, bermula dari 0) dan kembali

    di : function(index) {

      kembalikan this.models[index];

    },

    // Tapis model dalam koleksi berdasarkan nilai

    // attrs ialah objek penapis, seperti {name: 'Jack'}, yang akan mengembalikan semua model (array) dengan nama "Jack" dalam koleksi

    di mana : function(attrs) {

      // attrs tidak boleh kosong

      if(_.isEmpty(attrs))

        kembali [];

      // Tapis model dalam koleksi melalui kaedah penapis

      // Kaedah penapis ialah kaedah dalam Underscore, yang digunakan untuk melintasi elemen dalam koleksi dan mengembalikan elemen yang boleh lulus pengesahan pemproses (nilai pulangan adalah benar) sebagai tatasusunan

      kembalikan this.filter(function(model) {

        // Lintas peraturan pengesahan dalam objek attrs

        for(var key in attrs) {

          // Padankan peraturan pengesahan dalam attrs dengan model dalam koleksi

          if(attrs[key] !== model.get(key))

            kembali palsu;

        }

        kembali benar;

      });

    },

    // Isih model dalam koleksi mengikut kaedah yang ditentukan oleh atribut pembanding

    // Jika parameter senyap tidak ditetapkan dalam pilihan, acara set semula akan dicetuskan selepas mengisih

    sort : function(pilihan) {

      // pilihan lalai kepada objek

      pilihan ||. ( pilihan = {});

      // Atribut pembanding (kaedah algoritma pengisihan) mesti ditentukan semasa memanggil kaedah isihan, jika tidak ralat akan dilemparkan

      jika(!this.comparator)

        throw new Error('Tidak boleh menyusun set tanpa pembanding');

      // boundComparator menyimpan kaedah algoritma pengisihan pembanding yang terikat pada objek konteks koleksi semasa.

      var boundComparator = _.bind(this.comparator, this);

      if(this.comparator.length == 1) {

        this.models = this.sortBy(boundComparator);

      } lain {

        //Panggil Array.prototype.sort untuk mengisih data tersuai melalui algoritma pembanding

        this.models.sort(boundComparator);

      }

      // Jika parameter senyap tidak dinyatakan, peristiwa set semula akan dicetuskan

      jika(!pilihan.senyap)

        this.trigger('set semula', ini, pilihan);

      pulangkan ini;

    },

    // Simpan nilai atribut attr semua model dalam koleksi ke dalam tatasusunan dan kembalikan

    pluck : function(attr) {

      // map ialah kaedah dalam Underscore, digunakan untuk melintasi koleksi dan mengembalikan nilai pulangan semua pemproses sebagai tatasusunan

      return _.map(this.models, function(model) {

        // Kembalikan nilai atribut attr model semasa

        return model.get(attr);

      });

    },

    //Gantikan semua data model (model) dalam koleksi

    // Operasi ini akan memadam semua data dan status semasa dalam koleksi dan menetapkan semula data kepada model

    // model hendaklah berupa tatasusunan, yang boleh mengandungi satu siri objek model Model, atau objek asal (akan dibuat secara automatik sebagai objek model dalam kaedah tambah)

    set semula : fungsi(model, pilihan) {

      // models ialah tatasusunan model (atau data) untuk penggantian

      model ||. ( model = []);

      // pilihan lalai kepada objek kosong

      pilihan ||. ( pilihan = {});

      // Lintas model dalam koleksi semasa, padam dan lepaskan hubungan rujukannya dengan koleksi secara bergilir-gilir

      untuk(var i = 0, l = this.models.length; i < l; i ) {

        this._removeReference(this.models[i]);

      }

      //Padam data pengumpulan dan tetapkan semula keadaan

      this._reset();

      //Tambah data model baharu pada koleksi melalui kaedah tambah

      // Di sini, item konfigurasi ditimpa kepada objek baharu melalui kaedah exnted Nilai senyap lalai objek ini adalah benar, jadi peristiwa "tambah" tidak akan dicetuskan.

      // Jika atribut senyap tidak ditetapkan semasa memanggil kaedah tetapan semula, peristiwa tetapan semula akan dicetuskan. Jika ditetapkan kepada benar, tiada peristiwa akan dicetuskan mengikut urutan.

      this.add(models, _.extend({

        senyap : benar

      }, pilihan));

      // Jika atribut senyap tidak ditetapkan semasa memanggil kaedah tetapan semula, peristiwa tetapan semula dicetuskan.

      jika(!pilihan.senyap)

        this.trigger('set semula', ini, pilihan);

      pulangkan ini;

    },

    // Dapatkan data permulaan koleksi daripada pelayan

    // Jika parameter add=true ditetapkan dalam pilihan, data yang diperoleh akan dilampirkan pada koleksi, jika tidak, data semasa dalam koleksi akan digantikan dengan data yang dikembalikan oleh pelayan

    ambil : function(pilihan) {

      //Salin objek pilihan, kerana objek pilihan akan diubah suai kemudian untuk penyimpanan data sementara

      pilihan = pilihan _.klon(pilihan) : {};

      if(options.parse === undefined)

        options.parse = benar;

      // koleksi merekodkan objek koleksi semasa untuk digunakan dalam fungsi panggil balik kejayaan

      koleksi var = ini;

      // Fungsi panggil balik tersuai, selepas permintaan data berjaya dan penambahan selesai, fungsi kejayaan tersuai akan dipanggil

      var success = options.success;

      // Laksanakan options.success apabila meminta data daripada pelayan berjaya Fungsi ini akan menghuraikan dan menambah data.

      options.success = function(resp, status, xhr) {

        // Gunakan kaedah parse untuk menghuraikan data yang dikembalikan oleh pelayan Jika anda perlu menyesuaikan struktur data, anda boleh membebankan kaedah parse.

        // Jika add=true ditetapkan dalam pilihan, kaedah tambah dipanggil untuk menambah data pada koleksi, jika tidak, data dalam koleksi akan digantikan dengan data yang dikembalikan oleh pelayan melalui kaedah tetapan semula

        collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options);

        // Jika panggilan balik kejayaan tersuai ditetapkan, laksanakan

        jika (berjaya)

          kejayaan (pengumpulan, resp);

      };

      // Apabila pelayan mengembalikan ralat status, kendalikan peristiwa ralat melalui kaedah wrapError

      options.error = Backbone.wrapError(options.error, collection, options);

      // Panggil kaedah Backbone.sync untuk menghantar permintaan untuk mendapatkan data daripada pelayan

      // Jika data yang diperlukan tidak diperoleh daripada pelayan, atau kaedah pemerolehan tidak menggunakan AJAX, anda boleh membebankan kaedah Backbone.sync

      return (this.sync || Backbone.sync).panggilan(ini, 'baca', ini, pilihan);

    },

    // Tambah dan cipta model pada koleksi dan simpan model pada pelayan

    // Jika anda mencipta model melalui objek data, anda perlu mengisytiharkan kelas model yang sepadan dengan atribut model dalam koleksi.

    // Jika atribut tunggu diisytiharkan dalam pilihan, model akan ditambahkan pada koleksi selepas pelayan berjaya dibuat, jika tidak, model akan ditambahkan pada koleksi dahulu dan kemudian disimpan ke pelayan (tidak kira sama ada simpanan itu berjaya atau tidak)

    buat : fungsi(model, pilihan) {

      var coll = ini;

      //Tentukan objek pilihan

      pilihan = pilihan _.klon(pilihan): {};

      // Dapatkan contoh kelas model melalui _prepareModel

      model = this._prepareModel(model, pilihan);

      // Penciptaan model gagal

      jika(!model)

        kembali palsu;

      // Jika atribut tunggu tidak diisytiharkan, tambahkan model pada koleksi melalui kaedah tambah

      jika(!pilihan.tunggu)

        coll.add(model, pilihan);

      // Kejayaan menyimpan fungsi panggil balik tersuai selepas berjaya menyimpan ke pelayan (diisytiharkan melalui options.success)

      var success = options.success;

      // Dengar fungsi panggil balik selepas data model berjaya disimpan.

      options.success = function(nextModel, resp, xhr) {

        // Jika atribut tunggu diisytiharkan, model akan ditambahkan pada koleksi hanya selepas pelayan berjaya menyimpan.

        jika(pilihan.tunggu)

          coll.add(nextModel, options);

        // Jika panggilan balik kejayaan tersuai diisytiharkan, fungsi tersuai akan dilaksanakan, jika tidak, peristiwa penyegerakan model akan dicetuskan secara lalai

        jika(berjaya) {

          kejayaan(nextModel, resp);

        } lain {

          nextModel.trigger('sync', model, resp, options);

        }

      };

      // Panggil kaedah simpan model untuk menyimpan data model ke pelayan

      model.save(null, options);

      model pulangan;

    },

    // Kaedah penghuraian data, digunakan untuk menghuraikan data pelayan kepada data berstruktur yang boleh digunakan oleh model dan koleksi

    // Secara lalai, resp sendiri akan dikembalikan Ini perlu menentukan format data yang disokong oleh Backbone dengan pelayan Jika anda perlu menyesuaikan format data, anda boleh membebankan kaedah parse.

    parse : function(resp, xhr) {

      balas balas;

    },

    // rantai digunakan untuk membina operasi rantaian data pengumpulan Ia menukar data dalam koleksi menjadi objek Underscore, dan menggunakan kaedah rantai Underscore untuk menukarnya menjadi struktur rantai.

    // Berkenaan kaedah penukaran kaedah rantaian, sila rujuk ulasan tentang kaedah rantai dalam Underscore.

    rantai : function() {

      return _(this.models).chain();

    },

    //Padam semua elemen koleksi dan tetapkan semula keadaan data dalam koleksi

    _set semula : fungsi(pilihan) {

      //Padam elemen koleksi

      ini.panjang = 0;

      this.models = [];

      //Tetapkan semula keadaan koleksi

      this._byId = {};

      ini._byCid = {};

    },

    // Beberapa persediaan sebelum menambah model pada koleksi

    // Termasuk membuat instantiate data sebagai objek model, dan merujuk koleksi kepada sifat koleksi model

    _prepareModel : fungsi(model, pilihan) {

      pilihan ||. ( pilihan = {});

      // Semak sama ada model ialah objek model (iaitu contoh kelas Model)

      if(!( model instanceof Model)) {

        //Model yang diluluskan ialah objek data model, bukan objek model

        // Hantar data sebagai parameter kepada Model untuk mencipta objek model baharu

        var attrs = model;

        //Tetapkan koleksi rujukan model

        options.collection = ini;

        // Tukar data kepada model

        model = new this.model(attrs, options);

        // Sahkan data dalam model

        if(!model._validate(model.attributes, options))

          model = palsu;

      }else if(!model.collection) {

        // Jika objek model dihantar tetapi tiada rujukan kepada koleksi ditetapkan, tetapkan sifat koleksi model kepada koleksi semasa.

        model.collection = ini;

      }

      model pulangan;

    },

    //Lepaskan hubungan antara model dan koleksi, termasuk rujukan kepada pengumpulan dan pemantauan acara

    // Secara amnya dipanggil secara automatik apabila kaedah alih keluar dipanggil untuk memadam model atau kaedah tetapan semula dipanggil untuk menetapkan semula keadaan.

    _removeReference : function(model) {

      // Jika model merujuk kepada koleksi semasa, alih keluar rujukan (anda mesti memastikan bahawa semua rujukan kepada model telah dikeluarkan, jika tidak, model mungkin tidak dikeluarkan daripada memori)

      if(this == model.collection) {

        delete model.collection;

      }

      // Batalkan semua acara model yang dipantau dalam koleksi

      model.off('semua', ini._onModelEvent, ini);

    },

    // Dipanggil secara automatik apabila menambah model pada koleksi

    // Digunakan untuk memantau peristiwa model dalam koleksi Apabila model mencetuskan peristiwa (menambah, mengalih keluar, memusnahkan, menukar acara), koleksi melakukan pemprosesan yang berkaitan.

    _onModelEvent : fungsi(acara, model, koleksi, pilihan) {

      // Apabila menambah dan mengalih keluar acara model, anda mesti memastikan bahawa koleksi yang dimiliki model ialah objek koleksi semasa.

      if((acara == 'tambah' || acara == 'alih keluar') && koleksi != ini)

        kembali;

      //Apabila model mencetuskan peristiwa pemusnahan, ia dialih keluar daripada koleksi

      if(event == 'musnahkan') {

        this.remove(model, pilihan);

      }

      // Apabila id model diubah suai, rujukan kepada model disimpan dalam pengubahsuaian koleksi _byId untuk mengekalkan penyegerakan dengan id model, menjadikannya lebih mudah untuk mendapatkan objek model menggunakan kaedah get().

      if(model && acara === 'change:' model.idAttribute) {

        // Dapatkan id model sebelum perubahan, dan keluarkannya daripada senarai _byId koleksi berdasarkan id ini

        padam ini._byId[model.previous(model.idAttribute)];

        // Gunakan id baharu model sebagai kunci dan simpan rujukan kepada model dalam senarai _byId

        this._byId[model.id] = model;

      }

      // Cetuskan peristiwa yang sepadan dengan model dalam koleksi Tidak kira apa peristiwa yang dicetuskan oleh model, koleksi akan mencetuskan peristiwa yang sepadan.

      // (Sebagai contoh, apabila model ditambahkan pada koleksi, peristiwa "tambah" model akan dicetuskan dan peristiwa "tambah" koleksi juga akan dicetuskan dalam kaedah ini)

      // Ini sangat berguna untuk mendengar dan mengendalikan perubahan kepada keadaan model dalam koleksi

      // Dalam acara koleksi yang dipantau, model yang mencetuskan peristiwa yang sepadan akan dihantar sebagai parameter kepada fungsi mendengar koleksi.

      this.trigger.apply(this, arguments);

    }

  });

 

  // Tentukan kaedah berkaitan untuk operasi pengumpulan dalam Underscore

  //Salin satu siri kaedah operasi pengumpulan dalam Underscore ke objek prototaip kelas Koleksi

  // Dengan cara ini anda boleh memanggil kaedah pengumpulan berkaitan Underscore secara terus melalui objek koleksi.

  //Data pengumpulan yang dikendalikan oleh kaedah ini apabila dipanggil ialah data model objek Koleksi semasa.

  kaedah var = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'cari', 'detect', 'filter', 'select', 'reject', 'every', 'semua ', 'beberapa', 'mana-mana', 'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size', 'first', 'awal', 'rehat', 'terakhir', 'tanpa', 'indexOf', 'shuffle', 'lastIndexOf', 'isKosong', 'groupBy'];

 

  // Lintas senarai kaedah yang ditentukan

  _.setiap(kaedah, fungsi(kaedah) {

    //Salin kaedah ke objek prototaip kelas Koleksi

    Collection.prototype[method] = function() {

      // Gunakan kaedah Underscore secara langsung apabila memanggil, dan objek konteks kekal sebagai objek Underscore.

      // Perlu diingat bahawa parameter pengumpulan yang dihantar kepada kaedah Underscore di sini ialah this.models, jadi apabila menggunakan kaedah ini, objek koleksi yang dikendalikan ialah data model objek Koleksi semasa.

      return _[method].apply(_, [this.models].concat(_.toArray(arguments)));

    };

  });

  // Penghala URL Backbone.Router

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

 

  // Laksanakan penghala tersuai dengan mewarisi kelas Backbone.Router

  // Penghala membenarkan anda mentakrifkan peraturan penghalaan, menavigasi melalui serpihan URL dan memetakan setiap peraturan kepada kaedah yang akan dilaksanakan secara automatik apabila URL sepadan dengan peraturan tertentu.

  // Penghala menavigasi melalui URL Kaedah navigasi dibahagikan kepada kaedah pushState, Hash dan mendengar (untuk butiran, sila rujuk kelas Backbone.History).

  // Apabila membuat tika Penghala, tetapkan kaedah mendengar yang sepadan dengan peraturan penghalaan tertentu melalui options.routes

  // Peraturan penghalaan dalam options.routes disusun mengikut {rule name: method name}. Kaedah yang sepadan dengan setiap peraturan penghalaan mestilah kaedah yang diisytiharkan dalam contoh Penghala.

  // Peraturan penghalaan yang ditakrifkan oleh options.routes dipadankan mengikut urutan Jika URL semasa boleh dipadankan dengan berbilang peraturan, hanya kaedah acara padanan pertama akan dilaksanakan.

  var Penghala = Tulang Belakang.Penghala = fungsi(pilihan) {

    // pilihan lalai kepada objek kosong

    pilihan ||. ( pilihan = {});

    // Jika objek laluan (peraturan penghalaan) ditetapkan dalam pilihan, tetapkan ia kepada atribut laluan bagi contoh semasa

    // Atribut laluan merekodkan hubungan mengikat antara peraturan penghalaan dan kaedah acara Apabila URL sepadan dengan peraturan tertentu, kaedah acara yang berkaitan akan dipanggil secara automatik.