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