Backbone.js 0.9.2 Commentaires sur le code source Version de traduction chinoise_Connaissances de base

// Backbone.js 0.9.2



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

// Backbone peut être distribué librement sous la licence MIT.

// Pour tous les détails et la documentation :

// http://backbonejs.org

(fonction() {



  // Crée un objet global, représenté comme un objet fenêtre dans le navigateur et un objet global dans Node.js

  var racine = ceci ;



  // Sauvegarde la valeur de la variable "Backbone" avant son écrasement

  // S'il y a un conflit de nom ou compte tenu de la spécification, vous pouvez utiliser la méthode Backbone.noConflict() pour restaurer la valeur de la variable avant qu'elle ne soit occupée par Backbone et renvoyer l'objet Backbone pour le renommer.

  var previousBackbone = root.Backbone;



  // Mettre en cache les méthodes slice et splice dans Array.prototype dans des variables locales pour l'appel

  var slice = Array.prototype.slice;

  var splice = Array.prototype.splice;



  var Colonne vertébrale ;

  if( type d'exportations !== 'indéfini') {

    Backbone = exportations ;

  } autre {

    Backbone = root.Backbone = {};

  }



  //Définir la version du Backbone

  Backbone.VERSION = '0.9.2';



  // Importer automatiquement Underscore dans l'environnement serveur Certaines méthodes de Backbone dépendent ou héritent de Underscore.

  var _ = racine._;

  if(!_ && ( typeof require !== 'indéfini'))

    _ = require('trait de soulignement');



  // Définir la bibliothèque tierce comme une variable unifiée "$", qui est utilisée pour appeler les méthodes de la bibliothèque lors de l'affichage (View), du traitement des événements et de la synchronisation avec les données du serveur (sync)

  // Les bibliothèques prises en charge incluent jQuery, Zepto, etc. Elles ont la même syntaxe, mais Zepto est plus adapté au développement mobile. Il est principalement destiné aux navigateurs principaux de Webkit.

  // Vous pouvez également personnaliser une bibliothèque personnalisée avec une syntaxe similaire à jQuery pour une utilisation par Backbone (parfois nous pouvons avoir besoin d'une version personnalisée plus légère que jQuery ou Zepto)

  // Le "$" défini ici est une variable locale, il n'affectera donc pas l'utilisation normale des bibliothèques tierces en dehors du framework Backbone.

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



  // Configurer manuellement les bibliothèques tierces

  // Si vous n'avez pas importé de bibliothèque tierce avant d'importer Backbone, vous pouvez définir la variable locale "$" via la méthode setDomLibrary

  // La méthode setDomLibrary est également couramment utilisée pour importer dynamiquement des bibliothèques personnalisées dans Backbone.

  Backbone.setDomLibrary = fonction (lib) {

    $ = lib;

  } ;

  //Abandonner le nom du framework après "Backbone" et renvoyer l'objet Backbone, généralement utilisé pour éviter les conflits de noms ou standardiser les méthodes de nommage

  // Par exemple:

  // var bk = Backbone.noConflict(); // Annule le nom "Backbone" et stocke l'objet Backbone dans la variable bk

  // console.log(Backbone); // Cette variable ne peut plus accéder à l'objet Backbone et est restaurée à la valeur avant la définition de Backbone.

  // var MyBackbone = bk; // Et bk stocke l'objet Backbone, nous le renommeons MyBackbone

  Backbone.noConflict = fonction() {

    root.Backbone = précédentBackbone;

    rends ceci ;

  } ;

  // Pour les navigateurs qui ne prennent pas en charge REST, vous pouvez définir Backbone.emulateHTTP = true

  // La requête du serveur sera envoyée en mode POST, et le paramètre _method sera ajouté aux données pour identifier le nom de l'opération, et les informations d'en-tête X-HTTP-Method-Override seront également envoyées.

  Backbone.emulateHTTP = faux ;



  // Pour les navigateurs qui ne prennent pas en charge le codage application/json, vous pouvez définir Backbone.emulateJSON = true;

  //Définissez le type de requête sur application/x-www-form-urlencoded et placez les données dans le paramètre de modèle pour obtenir la compatibilité

  Backbone.emulateJSON = faux ;



  // Backbone.Events liés aux événements personnalisés

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



  // eventSplitter spécifie les règles d'analyse des noms d'événements lors du traitement de plusieurs événements.

  var eventSplitter = /s /;



  // Gestionnaire d'événements personnalisé

  // En liant les méthodes liées aux événements dans l'objet, il est autorisé d'ajouter, de supprimer et de déclencher des événements personnalisés à l'objet.

  var Événements = Backbone.Events = {



    // Lier les événements personnalisés et les fonctions de rappel à l'objet actuel

    //L'objet contextuel dans la fonction de rappel est le contexte spécifié. Si le contexte n'est pas défini, l'objet contextuel est par défaut l'objet de l'événement lié actuel.

    // Cette méthode est similaire à la méthode addEventListener dans DOM Level2

    // événements permet de spécifier plusieurs noms d'événements, séparés par des espaces (tels que des espaces, des tabulations, etc.)

    // Lorsque le nom de l'événement est "all", lorsqu'un événement est déclenché en appelant la méthode trigger, toutes les fonctions de rappel liées à l'événement "all" seront appelées.

    on : fonction (événements, rappel, contexte) {

      //Définit les variables locales utilisées dans certaines fonctions

      appels var, événement, nœud, queue, liste ;

      //La fonction de rappel doit être définie

      si(!rappel)

        rends ceci ;

      // Analyse les noms d'événements via eventSplitter, utilise split pour diviser plusieurs noms d'événements dans un tableau

      // Utilisez généralement des caractères vides pour spécifier plusieurs noms d'événements

      événements = événements.split(eventSplitter);

      // les appels enregistrent la liste des événements et des fonctions de rappel liés à l'objet actuel

      appels = this._callbacks || (this._callbacks = {});



      // Parcourez la liste des noms d'événements et stockez les noms d'événements dans la variable d'événement du début à la fin.

      while( événement = événements.shift()) {

        // Récupère la fonction de rappel qui a été liée à l'événement event

        // list stocke la liste des fonctions de rappel liées à un seul nom d'événement

        // La liste de fonctions n'est pas stockée dans un tableau, mais est liée séquentiellement via les attributs suivants de plusieurs objets.

        /**数据格式如:

         * {

         * queue : {Objet},

         *   suivant: {

         * rappel : {Fonction},

         * contexte : {Objet},

         *     suivant: {

         * rappel : {Fonction},

         * contexte : {Objet},

         * suivant : {Objet}

         * }

         * }

         * }*/

        // L'objet suivant à chaque niveau de la liste stocke les informations liées à un événement de rappel (corps de la fonction, contexte et prochain événement de rappel)

        // Le niveau supérieur de la liste d'événements stocke un objet tail, qui stocke l'identifiant du dernier événement de rappel lié (le même objet que le suivant du dernier événement de rappel)

        // Grâce à l'identifiant de queue, vous pouvez savoir que la dernière fonction de rappel a été atteinte lors du parcours de la liste de rappel

        list = appels[événement] ;

        // La variable node est utilisée pour enregistrer les informations liées à cette fonction de rappel.

        // tail stocke uniquement l'identifiant de la dernière fonction de rappel liée

        // Par conséquent, si la fonction de rappel a déjà été liée, attribuez la queue précédente au nœud en tant qu'objet, puis créez un nouvel identifiant d'objet pour la queue

        // La raison pour laquelle cet événement de rappel est ajouté à l'objet de queue du rappel précédent est d'organiser la hiérarchie des objets de la liste des fonctions de rappel dans l'ordre de liaison (le dernier événement lié sera placé en bas)

        nœud = liste ? list.tail : {};

        node.next = tail = {};

        //Enregistre le corps de la fonction et les informations contextuelles de ce rappel

        node.context = contexte ;

        node.callback = rappel ;

        //Réassembler la liste de rappel de l'événement en cours, cet événement de rappel a été ajouté à la liste

        appels[événement] = {

          queue : queue,

          suivant : liste ? liste.suivant : nœud

        } ;

      }

      // Renvoie l'objet courant pour faciliter les appels de chaîne de méthodes

      rends ceci ;

    },

    // Supprime les événements liés ou les fonctions de rappel dans l'objet. Vous pouvez filtrer les événements ou les fonctions de rappel qui doivent être supprimés via les événements, le rappel et le contexte.

    // - Si le contexte est vide, supprime toutes les fonctions spécifiées par le rappel

    // - Si le rappel est vide, supprime toutes les fonctions de rappel dans l'événement

    // - Si les événements sont vides, mais que le rappel ou le contexte est spécifié, supprimez la fonction de rappel spécifiée par le rappel ou le contexte (les noms d'événements ne sont pas distingués)

    // - Si aucun paramètre n'est passé, supprimez tous les événements et fonctions de rappel liés à l'objet

    off : fonction (événements, rappel, contexte) {

      événement var, appels, nœud, queue, cb, ctx ;



      // Aucun événement ou suppression de *tous* les événements.

      // L'objet actuel n'est lié à aucun événement

      if(!( appels = this._callbacks))

        retour;

      // Si aucun paramètre n'est spécifié, supprimez tous les événements et fonctions de rappel (supprimez l'attribut _callbacks)

      if(!(événements || rappel || contexte)) {

        supprimez this._callbacks ;

        rends ceci ;

      }



      // Analyse la liste des événements qui doivent être supprimés

      // - Si des événements sont spécifiés, le nom de l'événement est analysé selon eventSplitter

      // - Si les événements ne sont pas spécifiés, analyse la liste de noms de tous les événements liés

      événements = événements ? événements.split(eventSplitter) : _.keys(appels);



      // Liste des noms d'événements de boucle

      while( événement = événements.shift()) {

        // Supprime l'objet événement actuel de la liste et le met en cache dans la variable de nœud

        nœud = appels[événement] ;

        supprimer des appels[événement] ;

        // Si l'objet événement actuel n'existe pas (ou si aucune condition de filtre de suppression n'est spécifiée, on considère que l'événement courant et toutes les fonctions de rappel seront supprimés), alors terminez cette opération (l'objet événement a été supprimé à l'étape précédente )

        if(!node || !(rappel || contexte))

          continuer;

        // Crée une nouvelle liste en omettant les rappels indiqués.

        // Selon la fonction de rappel ou les conditions du filtre contextuel, assemblez un nouvel objet événement et reliez-le

        tail = noeud.tail;

        // Parcourt tous les objets de rappel dans l'événement

        while(( node = node.next) !== tail) {

          cb = node.callback;

          ctx = node.context;

          // En fonction de la fonction de rappel et du contexte dans les paramètres, filtrez la fonction de rappel et reliez la fonction de rappel qui ne répond pas aux conditions de filtrage à l'événement (car toutes les fonctions de rappel de l'événement ont été supprimées ci-dessus)

          if((rappel && cb !== rappel) || (context && ctx !== contexte)) {

            this.on(événement, cb, ctx);

          }

        }

      }



      rends ceci ;

    },

    // Déclenche un ou plusieurs événements qui ont été définis et exécute la liste de fonctions de rappel liée dans l'ordre

    déclencheur : fonction (événements) {

      var événement, nœud, appels, queue, arguments, tout, repos ;

      // L'objet actuel n'est lié à aucun événement

      if(!( appels = this._callbacks))

        rends ceci ;

      // Récupère la liste d'événements "tous" liée à la liste des fonctions de rappel

      all = appelle.all;

      // Analyse le nom de l'événement qui doit être déclenché dans un tableau selon les règles eventSplitter

      événements = événements.split(eventSplitter);

      // Enregistre les paramètres du déclencheur de la seconde à la variable rest, qui seront à leur tour transmis à la fonction de rappel.

      reste = tranche.call(arguments, 1);



      // Parcourez la liste des événements qui doivent être déclenchés

      while( événement = événements.shift()) {

        // La variable node enregistre ici une liste de toutes les fonctions de rappel de l'événement en cours

        if(noeud = appels[événement]) {

          //La variable tail enregistre l'ID d'objet du dernier événement de liaison

          tail = noeud.tail;

          //La valeur de la variable de nœud est attribuée à l'objet d'événement de rappel unique lié dans l'ordre en fonction de l'ordre de liaison de l'événement.

          // La propriété suivante du dernier événement lié fait référence au même objet que tail, qui est utilisé comme base pour juger si la fin de la liste a été atteinte.

          while(( node = node.next) !== tail) {

            // Exécute tous les événements liés et transmet les paramètres lors de l'appel du déclencheur à la fonction de rappel

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

          }

        }

        // La variable all enregistre l'événement "all" lors de la liaison, c'est-à-dire que lorsqu'un événement est appelé, la fonction de rappel dans l'événement "all" sera exécutée.

        // - Les fonctions de rappel dans l'événement "all", quel que soit l'ordre de liaison, seront exécutées séquentiellement après que toutes les listes de fonctions de rappel de l'événement en cours auront été exécutées.

        // - L'événement "all" doit être automatiquement appelé lorsqu'un événement normal est déclenché. Si l'événement "all" est forcé à être déclenché, la fonction de rappel dans l'événement sera exécutée deux fois.

        if(noeud ​​= tous) {

          tail = noeud.tail;

          //La différence avec l'appel de la fonction de rappel d'un événement normal est que l'événement all transmettra le nom de l'événement actuellement appelé comme premier paramètre à la fonction de rappel.

          args = [événement].concat(rest);

          // Parcourez et exécutez la liste des fonctions de rappel dans l'événement "all"

          while(( node = node.next) !== tail) {

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

          }

        }

      }



      rends ceci ;

    }

  } ;



  // Alias ​​pour les événements de liaison et les événements de publication, également pour la compatibilité avec les versions précédentes de Backbone

  Événements.bind = Événements.on ;

  Événements.unbind = Événements.off ;



  // Modèle d'objet de données Backbone.Model

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



  // Model est la classe de base de tous les modèles d'objets de données dans Backbone, utilisée pour créer un modèle de données

  // Les attributs @param {Object} spécifient les données d'initialisation lors de la création du modèle

  // Options @param {Objet}

  /***Options @format

   * {

   * analyser : {Booléen},

   *collection : {Collection}

   * }*/

  var Model = Backbone.Model = function (attributs, options) {

    // La variable defaults est utilisée pour stocker les données par défaut du modèle

    var valeurs par défaut ;

    // Si le paramètre d'attributs n'est pas spécifié, définit les attributs sur un objet vide

    attributs || ( attributs = {});

    //Définissez la méthode d'analyse des données par défaut des attributs. Par exemple, les données par défaut sont obtenues à partir du serveur (ou les données originales sont au format XML Afin d'être compatibles avec le format de données requis par la méthode set, l'analyse). La méthode peut être utilisée pour l’analyse.

    si(options && options.parse)

      attributs = this.parse(attributs);

    if( valeurs par défaut = getValue (this, 'valeurs par défaut')) {

      // Si le modèle définit les données par défaut lors de sa définition, les données d'initialisation utilisent les données fusionnées avec les paramètres par défaut et les attributs (les données dans les attributs écraseront les données du même nom dans les valeurs par défaut)

      attributs = _.extend({}, valeurs par défaut, attributs);

    }

    // Spécifiez explicitement l'objet Collection auquel appartient le modèle (lors de l'appel des méthodes add, push et autres de Collection pour ajouter le modèle à la collection, l'objet Collection auquel appartient le modèle sera automatiquement défini)

    si (options && options.collection)

      this.collection = options.collection;

    //L'attributattributs stocke les données objectivées JSON du modèle actuel et est vide par défaut lors de la création du modèle.

    this.attributes = {} ;

    // Définissez l'objet de cache _escapedAttributes, qui mettra en cache les données traitées via la méthode d'échappement

    this._escapedAttributes = {};

    // Configurer un identifiant unique pour chaque modèle

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

    //Définissez une série d'objets utilisés pour enregistrer l'état des données. Veuillez vous référer aux commentaires lors de la définition de l'objet pour des significations spécifiques.

    ceci.changed = {};

    this._silent = {};

    this._pendant = {} ;

    // Définit les données d'initialisation lors de la création d'une instance. Utilisez le paramètre quiet pour la première fois et l'événement de changement ne sera pas déclenché.

    this.set (attributs, {

      silencieux : vrai

    });

    // Les données d'initialisation ont été définies ci-dessus. Le statut des objets modifiés, _silent, _pendant peut avoir changé ici.

    ceci.changed = {};

    this._silent = {};

    ceci._en attente = {};

    // La variable _previousAttributes stocke une copie des données du modèle

    // Utilisé pour obtenir l'état avant que les données du modèle ne soient modifiées dans l'événement de changement. Les données de l'état précédent peuvent être obtenues via la méthode previous ou previousAttributes.

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

    //Appelle la méthode d'initialisation initialize

    this.initialize.apply(this, arguments);

  } ;

  // Utilisez la méthode extend pour définir une série de propriétés et de méthodes pour le prototype du modèle

  _.extend(Modèle.prototype, Événements, {



    // L'attribut modifié enregistre la collection de clés des données modifiées à chaque fois que la méthode set est appelée.

    modifié : nul,



    // // Lorsque l'attribut silencieux est spécifié, l'événement de changement ne sera pas déclenché et les données modifiées seront enregistrées jusqu'au déclenchement du prochain événement de changement.

    // L'attribut _silent est utilisé pour enregistrer les données modifiées lorsque le mode silencieux est utilisé

    _silent : nul,



    _en attente : nul,



    // L'attribut d'identification unique de chaque modèle (la valeur par défaut est "id", le nom de l'attribut id peut être personnalisé en modifiant idAttribute)

    // Si l'attribut id est inclus lors de la définition des données, l'identifiant remplacera l'identifiant du modèle.

    // L'identifiant est utilisé pour rechercher et identifier le modèle dans la Collection. Lors de la communication avec l'interface backend, l'identifiant sera également utilisé comme identifiant d'un enregistrement.

    idAttribut : 'id',



    // Méthode d'initialisation du modèle, appelée automatiquement après la construction du modèle

    initialiser : function() {

    },

    // Renvoie une copie des données dans le modèle courant (format objet JSON)

    toJSON : fonction (options) {

      return _.clone(this.attributes);

    },

    //Selon le nom de l'attribut attr, obtenez la valeur des données dans le modèle

    obtenir : fonction (attr) {

      renvoie this.attributes[attr] ;

    },

    //Selon le nom de l'attribut attr, obtenez la valeur des données dans le modèle. Les caractères spéciaux HTML contenus dans la valeur des données seront convertis en entités HTML, y compris & <

    // Implémenté via la méthode _.escape

    évasion : fonction (attr) {

      varhtml;

      // Recherche les données de l'objet de cache _escapedAttributes et renvoie directement si les données ont été mises en cache

      if(html = this._escapedAttributes[attr])

        renvoyer du HTML ;

      // Aucune donnée trouvée dans l'objet cache _escapedAttributes

      // Ensuite, récupérez d'abord les données du modèle

      var val = this.get(attr);

      // Convertissez le code HTML des données en entités à l'aide de la méthode _.escape et mettez-le en cache dans l'objet _escapedAttributes pour une récupération facile la prochaine fois

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

    },

    // Vérifiez si un certain attribut existe dans le modèle. Lorsque la valeur de l'attribut est convertie en type booléen et que la valeur est fausse, elle est considérée comme n'existant pas.

    // Si la valeur est fausse, nulle, non définie, 0, NaN ou une chaîne vide, elle sera convertie en faux

    a : fonction(attr) {

      return this.get(attr) != null;

    },

    //Définissez les données dans le modèle. Si la valeur clé n'existe pas, elle sera ajoutée au modèle en tant que nouvel attribut. Si la valeur clé existe déjà, elle sera modifiée par la nouvelle valeur.

    set : fonction (clé, valeur, options) {

      // Enregistrez les objets de données qui doivent être définis dans la variable attrs

      var attrs, attr, val;



      // Le formulaire de paramètre permet la forme d'un objet clé-valeur ou des paramètres séparés via des paramètres clé et valeur.

      // Si key est un objet, il est considéré comme défini sous forme d'objet, et le deuxième paramètre sera considéré comme le paramètre options.

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

        attributs = clé ;

        options = valeur ;

      } autre {

        // Définissez les deux paramètres key et value séparément et placez les données dans l'objet attrs pour un traitement unifié.

        attributs = {} ;

        attrs[clé] = valeur ;

      }



      // L'élément de configuration des options doit être un objet. Si les options ne sont pas définies, la valeur par défaut est un objet vide.

      options || (options = {});

      // Aucune action n'est effectuée lorsqu'aucun paramètre n'est défini.

      si(!attrs)

        rends ceci ;

      // Si l'objet de données en cours de définition appartient à une instance de la classe Model, attribuez l'objet de données d'attributs de l'objet Model à attrs

      // Généralement, cette action sera effectuée lors de la copie de données d'un objet Model vers un autre objet Model.

      if (attrs instance du modèle)

        attrs = attrs.attributes;

      // Si l'attribut unset est défini dans l'objet de configuration des options, réinitialise tous les attributs de l'objet de données attrs sur non défini

      // Généralement, cette opération est effectuée lors de la copie de données d'un objet Model vers un autre objet Model, mais seules les données du Model doivent être copiées sans copier la valeur.

      si (options.unset)

        pour (attr dans attrs)

        attrs[attr] =

        vide 0 ;



      //Vérifie les données actuelles et arrête l'exécution si la vérification échoue

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

        renvoie faux ;



      // Si le nom de l'attribut set id est inclus dans la collection de données, écrasez l'id par l'attribut id du modèle

      // Ceci permet de garantir qu'après avoir personnalisé le nom de l'attribut id, l'identifiant est accessible correctement lors de l'accès à l'attribut id du modèle.

      if(this.idAttribute dans les attributs)

        this.id = attrs[this.idAttribute];



      var changements = options.changes = {};

      // enregistre désormais les objets de données dans le modèle actuel

      var maintenant = this.attributes;

      // escaped enregistre les données mises en cache par escape dans le modèle actuel

      var escaped = this._escapedAttributes;

      // prev enregistre la valeur avant que les données du modèle ne soient modifiées

      var précédent = this._previousAttributes || {};



      // Parcourez les objets de données qui doivent être définis

      pour (attr dans attrs) {

        // attr stocke le nom de l'attribut actuel, val stocke la valeur de l'attribut actuel

        val = attrs[attr];



        // Si les données actuelles n'existent pas dans le modèle, ou ont changé, ou si la suppression de l'attribut non défini est spécifiée dans les options, supprimez les données qui ont été remplacées par les données dans _escapedAttributes.

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

          // Supprimez uniquement les données mises en cache via l'échappement. Ceci permet de garantir que les données du cache sont synchronisées avec les données réelles du modèle.

          supprimer échappé[attr] ;

          // Si l'attribut Silent est spécifié, l'événement change ne sera pas déclenché par cet appel de méthode set, donc les données modifiées seront enregistrées dans l'attribut _silent afin que la prochaine fois que l'événement change sera déclenché, la fonction d'écoute d'événement sera informé que les données ont changé.

          // Si l'attribut Silent n'est pas spécifié, définissez directement les données actuelles dans l'attribut changes sur l'état modifié.

          (options.silent ? this._silent : changements)[attr] = true;

        }



        // Si unset est défini dans les options, supprimez les données (y compris la clé) du modèle

        // Si l'attribut unset n'est pas spécifié, on considère que des données nouvelles ou modifiées seront ajoutées, et de nouvelles données seront ajoutées à l'objet de données du modèle.

        options.unset ?

        supprimer maintenant[attr] : maintenant[attr] = val;



        // Si les données du modèle sont incohérentes avec les nouvelles données, cela signifie que les données ont changé

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

          // Enregistre le statut modifié de l'attribut actuel dans l'attribut modifié

          this.changed[attr] = val;

          si(!options.silent)

            this._ending[attr] = true;

        } autre {

          // Si les données n'ont pas changé, supprimez le statut modifié de l'attribut modifié

          supprimez this.changed[attr];

          supprimez this._ending[attr];

        }

      }



      // Appelez la méthode change, qui déclenchera la fonction liée à l'événement change

      si(!options.silent)

        this.change(options);

      rends ceci ;

    },

    //Supprime les données spécifiées du modèle actuel (les attributs seront également supprimés en même temps)

    unset : fonction (attr, options) {

      (options || ( options = {})).unset = true;

      // Informe la méthode set d'effectuer l'opération de suppression via l'élément de configuration options.unset

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

    },

    // Efface toutes les données et attributs du modèle actuel

    clair : fonction (options) {

      (options || ( options = {})).unset = true;

      // Clonez une copie des propriétés du modèle actuel et indiquez à la méthode set d'effectuer l'opération de suppression via l'élément de configuration options.unset

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

    },

    // Obtenez les données du modèle par défaut du serveur.Après avoir obtenu les données, utilisez la méthode set pour remplir les données dans le modèle. Par conséquent, si les données obtenues sont incohérentes avec les données du modèle actuel, l'événement de changement sera déclenché. .

    récupérer : fonction (options) {

      // Assurez-vous que les options sont un nouvel objet, puis modifiez les propriétés dans les options

      options = options ? _.clone(options) : {};

      var modèle = ceci ;

      // Dans les options, vous pouvez spécifier une fonction de rappel personnalisée une fois les données obtenues avec succès.

      var success = options.success;

      // Lorsque les données sont obtenues avec succès, remplissez les données et appelez la fonction de rappel de réussite personnalisée

      options.success = fonction (resp, statut, xhr) {

        // Convertit les données renvoyées par le serveur via la méthode parse

        // Remplissez les données converties dans le modèle via la méthode set, afin que l'événement de changement puisse être déclenché (lorsque les données changent)

        // Si la validation échoue lors du remplissage des données, la fonction de rappel de réussite personnalisée ne sera pas appelée

        if(!model.set(model.parse(resp, xhr), options))

          renvoie faux ;

        //Appelle la fonction de rappel de réussite personnalisée

        si (succès)

          succès(modèle, resp);

      } ;

      // Gère l'événement d'erreur via wrapError lorsqu'une erreur se produit dans la requête

      options.error = Backbone.wrapError(options.error, modèle, options);

      // Appelez la méthode sync pour récupérer les données du serveur

      return (this.sync || Backbone.sync).call(this, 'read', this, options);

    },

    //Enregistre les données du modèle sur le serveur

    save : fonction (clé, valeur, options) {

      // attrs stocke les objets de données qui doivent être enregistrés sur le serveur

      var attrs, actuel ;



      //Prend en charge la définition d'une seule clé d'attribut : valeur

      // Prise en charge de la méthode de configuration par lots sous forme d'objet {clé : valeur}

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

        // Si la clé est un objet, elle est considérée comme définie via la méthode objet

        // A ce moment, le deuxième paramètre est considéré comme des options

        attributs = clé ;

        options = valeur ;

      }autre {

        // Si un seul attribut est défini sous la forme de key: value, définissez directement attrs

        attributs = {} ;

        attrs[clé] = valeur ;

      }

      // L'objet de configuration doit être un nouvel objet

      options = options ? _.clone(options) : {};



      // Si l'option d'attente est définie dans les options, les données modifiées seront vérifiées à l'avance, et lorsque le serveur ne répond pas aux nouvelles données (ou que la réponse échoue), les données locales seront restaurées à l'état avant la modification.

      // Si l'option d'attente n'est pas définie, les données locales seront modifiées au dernier état, que le serveur soit défini avec succès ou non.

      si (options. attendre) {

        // Vérifiez les données qui doivent être enregistrées à l'avance

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

          renvoie faux ;

        //Enregistre les données dans le modèle actuel, utilisé pour restaurer les données après les avoir envoyées au serveur

        // Si la réponse du serveur échoue ou si aucune donnée n'est renvoyée, l'état avant la modification peut être maintenu

        actuel = _.clone(this.attributes);

      }



      // SilentOptions ajoute le silence à l'objet options (pas de vérification des données)

      // Utilisez l'élément de configuration SilentOptions lors de l'utilisation du paramètre wait, car les données ont été vérifiées ci-dessus

      // Si le paramètre wait n'est pas défini, les éléments de configuration des options d'origine sont toujours utilisés

      var SilentOptions = _.extend({}, options, {

        silencieux : vrai

      });

      // Enregistrez les dernières données modifiées sur le modèle, afin que les données du modèle puissent être obtenues dans la méthode de synchronisation et enregistrées sur le serveur.

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

        renvoie faux ;

      }



      var modèle = ceci ;

      // Dans les options, vous pouvez spécifier une fonction de rappel personnalisée après avoir enregistré avec succès les données.

      var success = options.success;

      //Exécuter avec succès une fois que le serveur a répondu avec succès

      options.success = fonction (resp, statut, xhr) {

        // Récupère les dernières données d'état de la réponse du serveur

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

        // Si le paramètre wait est utilisé, l'état des données modifiées sera d'abord défini directement sur le modèle.

        si (options. attendre) {

          supprimer options.wait ;

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

        }

        //Définit le dernier statut des données dans le modèle

        // Si la vérification échoue lors de l'appel de la méthode set, la fonction de rappel de réussite personnalisée ne sera pas appelée.

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

          renvoie faux ;

        si (succès) {

          //Appelle la fonction de rappel de réussite personnalisée une fois la réponse réussie

          succès(modèle, resp);

        } autre {

          // Si aucun rappel personnalisé n'est spécifié, l'événement de synchronisation est déclenché par défaut

          model.trigger('sync', modèle, resp, options);

        }

      } ;

      // Gère l'événement d'erreur via wrapError lorsqu'une erreur se produit dans la requête

      options.error = Backbone.wrapError(options.error, modèle, options);

      //Enregistre les données du modèle sur le serveur

      // Si le modèle actuel est un modèle nouvellement créé (sans identifiant), utilisez la méthode create (new), sinon il est considéré comme la méthode update (modifiée)

      var méthode = this.isNew() ? 'create' : 'update';

      var xhr = (this.sync || Backbone.sync).call(this, méthode, this, options);

      // Si options.wait est défini, restaure les données à l'état avant la modification

      // La requête enregistrée n'a pas reçu de réponse pour le moment, donc si la réponse échoue, le modèle restera dans l'état avant la modification. Si le serveur répond avec succès, les données du modèle seront définies au dernier état de réussite. .

      si (options.attendre)

        this.set (actuel, options silencieuses);

      retourner xhr ;

    },

    //Supprimez le modèle, le modèle sera supprimé de la Collection à laquelle il appartient.

    // Si le modèle est créé sur le client, supprimez-le directement du client.

    // Si les données du modèle existent sur le serveur en même temps, les données côté serveur seront supprimées en même temps.

    détruire : fonction (options) {

      // L'élément de configuration doit être un nouvel objet

      options = options ? _.clone(options) : {};

      var modèle = ceci ;

      // Dans les options, vous pouvez spécifier une fonction de rappel personnalisée une fois les données supprimées avec succès.

      var success = options.success;

      // Appelé avec succès pour supprimer des données, l'événement destroy est déclenché. Si le modèle existe dans la collection, la collection écoutera l'événement destroy et supprimera le modèle de la collection lorsqu'il sera déclenché.

      // Lors de la suppression d'un modèle, les données du modèle n'ont pas été effacées, mais le modèle a été supprimé de la collection, donc lorsqu'il n'y a aucune référence au modèle nulle part, il sera automatiquement libéré de la mémoire.

      // Il est recommandé de définir la variable de référence de l'objet modèle sur null lors de la suppression du modèle.

      var triggerDestroy = fonction() {

        model.trigger('destroy', model, model.collection, options);

      } ;

      // Si le modèle est un modèle nouvellement créé par le client, appelez directement triggerDestroy pour supprimer le modèle de la collection.

      si(this.isNew()) {

        triggerDestroy();

        renvoie faux ;

      }// Lorsque la suppression des données du serveur est réussie

      options.succès = fonction (resp) {

        // Si l'élément d'attente est configuré dans l'objet options, cela signifie que les données du modèle dans la mémoire locale seront supprimées une fois les données du serveur supprimées avec succès.

        // Si la réponse du serveur échoue, les données locales ne seront pas supprimées

        si (options.attendre)

          triggerDestroy();

        si (succès) {

          //Appelle la fonction de rappel de réussite personnalisée

          succès(modèle, resp);

        } autre {

          // S'il n'y a pas de rappel personnalisé, l'événement de synchronisation est déclenché par défaut

          model.trigger('sync', modèle, resp, options);

        }

      } ;

      // Gère l'événement d'erreur via wrapError lorsqu'une erreur se produit dans la requête

      options.error = Backbone.wrapError(options.error, modèle, options);

      //Envoyer une demande de suppression de données via la méthode de synchronisation

      var xhr = (this.sync || Backbone.sync).call(this, 'delete', this, options);

      // Si l'élément d'attente n'est pas configuré dans l'objet options, les données locales seront d'abord supprimées, puis une demande sera envoyée pour supprimer les données du serveur.

      // À ce stade, que la suppression du serveur ait réussi ou non, les données du modèle local ont été supprimées.

      si(!options.attendre)

        triggerDestroy();

      retourner xhr ;

    },

    // Récupère l'URL correspondant au modèle dans l'interface du serveur. Lors de l'appel des méthodes save, fetch, destroy et autres pour interagir avec le serveur, cette méthode sera utilisée pour obtenir l'URL.

    // L'URL générée est similaire au mode "PATHINFO". Le serveur n'a qu'une seule URL pour les opérations de modèle. Pour les opérations de modification et de suppression, l'ID du modèle sera ajouté à l'URL pour une identification facile.

    // Si urlRoot est défini dans le modèle, l'interface du serveur doit être sous la forme [urlRoot/id]

    // Si la Collection à laquelle appartient le modèle définit la méthode ou l'attribut url, utilisez le formulaire url dans la collection : [collection.url/id]

    // Lors de l'accès à l'URL du serveur, l'identifiant du modèle sera ajouté à l'URL pour permettre au serveur d'identifier un enregistrement, de sorte que l'identifiant dans le modèle doit correspondre à l'enregistrement du serveur.

    // Si l'url du modèle ou de la collection ne peut pas être obtenue, la méthode urlError sera appelée et une exception sera levée.

    // Si l'interface du serveur n'est pas organisée selon "PATHINFO", vous pouvez obtenir une interaction transparente avec le serveur en surchargeant la méthode url.

    URL : fonction() {

      //Définit le chemin url correspondant au serveur

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

      // Si le modèle actuel est un modèle nouvellement créé par le client, il n'y a pas d'attribut id et l'URL du serveur utilise directement base.

      si(this.isNew())

        base de retour ;

      // Si le modèle actuel a un attribut id, la méthode save ou destroy peut être appelée et l'identifiant du modèle sera ajouté à la base.

      // Ce qui suit déterminera si le dernier caractère de la base est "/" et si le format de l'URL générée est [base/id]

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

    },

    // La méthode parse est utilisée pour analyser les données obtenues du serveur et renvoyer des données de modèle qui peuvent être analysées par la méthode set.

    // Généralement, la méthode parse sera surchargée en fonction des données renvoyées par le serveur afin d'établir une connexion transparente avec le serveur.

    // Lorsque la structure de données renvoyée par le serveur est incohérente avec la structure de données requise par la méthode set (par exemple, lorsque le serveur renvoie des données au format XML), la méthode parse peut être utilisée pour la conversion.

    analyser : fonction (resp, xhr) {

      retour resp;

    },

    // Crée un nouveau modèle avec les mêmes données que le modèle actuel

    cloner : fonction() {

      return new this.constructor(this.attributes);

    },

    // Vérifiez si le modèle actuel est un nouveau modèle créé par le client

    // La méthode de vérification est basée sur le fait que le modèle a un identifiant id. Le nouveau modèle créé par le client n'a pas d'identifiant id.

    // Par conséquent, les données du modèle répondues par le serveur doivent contenir l'identifiant id. Le nom d'attribut de l'identifiant est par défaut "id". Vous pouvez également personnaliser l'identifiant en modifiant l'attribut idAttribute.

    estNouveau : function() {

      renvoie this.id == null ;

    },

    // Fonction qui déclenche la liaison d'événement de changement lorsque les données sont mises à jour

    // Lorsque la méthode set est appelée, la méthode change sera appelée automatiquement. Si la configuration silencieuse est spécifiée lors de l'appel de la méthode set, la méthode change doit être appelée manuellement.

    changement : fonction(options) {

      // les options doivent être un objet

      options || ( options = {});

      // Il y a quelques problèmes avec la logique liée à this._changing

      // this._changing est défini sur false à la fin de la méthode, donc la valeur de la variable changeante au-dessus de la méthode est toujours fausse (la première fois n'est pas définie)

      // L'intention initiale de l'auteur devrait être d'utiliser cette variable pour indiquer si la méthode de changement a été exécutée. Cela n'a aucun sens pour les scripts monothread côté navigateur car cette méthode bloquera d'autres scripts lors de son exécution.

      // la modification obtient le statut de la dernière exécution. Si le dernier script n'a pas été exécuté, la valeur est vraie.

      var changeant = this._changing;

      // Commencez à exécuter l'indicateur. La valeur est toujours vraie pendant l'exécution, this._changing est modifié en false.

      this._changing = vrai;



      //Ajouter un statut de données autre que cette modification à l'objet _ending

      pour (var attr dans this._silent)

      this._ending[attr] = true;



      // L'objet changes contient toutes les données qui ont été modifiées depuis la dernière fois que l'événement change a été exécuté sur les données actuelles.

      // Si l'événement change n'a pas été déclenché en utilisant quiet auparavant, il sera cette fois placé dans l'objet changes.

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

      //Réinitialiser l'objet _silent

      this._silent = {};

      // Parcourez l'objet changes et déclenchez des événements de changement distincts pour chaque attribut.

      pour (var attr dans les modifications) {

        // Passe l'objet Model, les valeurs d'attribut et les éléments de configuration en tant que paramètres à la fonction d'écoute d'événements

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

      }



      //Si la méthode est en cours d'exécution, arrêtez l'exécution

      si (changeant)

        rends ceci ;



      // Déclenchez l'événement de changement. Après la modification d'une donnée, l'événement "change:property" et l'événement "change" seront déclenchés en séquence.

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

        this._pendant = {} ;

        // Déclenchez l'événement de changement et transmettez l'instance de modèle et les éléments de configuration en tant que paramètres à la fonction d'écoute

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

        // Parcourez les données dans l'objet modifié et supprimez à son tour le statut des données modifiées de modifié

        // Après cela, si vous appelez hasChanged pour vérifier l'état des données, vous obtiendrez false (inchangé)

        pour (var attr dans this.changed) {

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

            continuer;

          // Supprime l'état des données modifiées

          supprimez this.changed[attr];

        }

        // Une fois l'événement de changement exécuté, l'attribut _previousAttributes enregistrera la dernière copie de données du modèle actuel

        // Par conséquent, si vous avez besoin d'obtenir l'état précédent des données, vous ne pouvez généralement l'obtenir que via la méthode previous ou previousAttributes dans l'événement de changement déclenché.

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

      }



      //Drapeau d'exécution terminée

      this._changing = faux ;

      rends ceci ;

    },

    // Vérifiez si certaines données ont été modifiées depuis l'exécution du dernier événement de modification

    /*** Généralement utilisé en conjonction avec la méthode previous ou previousAttributes dans l'événement de changement, tel que :

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

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

     * }*/

    hasChanged : fonction (attr) {

      si(!arguments.longueur)

        return !_.isEmpty(this.changed);

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

    },

    // Récupère la collecte de données dans le modèle actuel et les données qui ont changé dans les dernières données

    // (Généralement, la méthode change n'est pas appelée lors de l'utilisation de l'attribut silencieux, les données seront donc temporairement stockées dans l'attribut modifié. Les dernières données peuvent être obtenues via la méthode previousAttributes)

    // Si un ensemble de différences est transmis, les dernières données du modèle seront comparées aux données de l'ensemble de différences et un ensemble de données incohérent sera renvoyé.

    // S'il n'y a pas de différence dans le résultat de la comparaison, renvoie false

    Attributs modifiés : fonction (diff) {

      // Si diff n'est pas spécifié, la collection de données du modèle actuel qui a changé par rapport à l'état précédent sera renvoyée. Ces données ont été stockées dans l'attribut modifié, donc une copie de la collection modifiée est renvoyée.

      si(!diff)

        return this.hasChanged() ? _.clone(this.changed) : false;

      // L'ensemble de différences qui doit être comparé est spécifié et le résultat de la comparaison entre les dernières données et l'ensemble de différences sera renvoyé.

      //L'ancienne variable stocke les données du modèle de l'état précédent

      var val, modifié = faux, ancien = this._previousAttributes ;

      // Parcourez la collection diff et comparez chaque élément avec la collection des états précédents

      pour (var attr dans diff) {

        // Stocke temporairement les données avec des résultats de comparaison incohérents dans la variable modifiée

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

          continuer;

        (changé || (changé = {}))[attr] = val;

      }

      // Renvoie le résultat de la comparaison

      retour modifié ;

    },

    // Dans l'événement de changement déclenché par le modèle, obtenez les données de l'état précédent avant la modification d'un attribut, qui est généralement utilisé pour la comparaison ou la restauration des données.

    // Cette méthode est généralement appelée dans l'événement change. Une fois l'événement change déclenché, l'attribut _previousAttributes stocke les dernières données.

    précédent : fonction(attr) {

      // attr spécifie le nom de l'attribut qui doit obtenir l'état précédent

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

        renvoie null ;

      renvoie this._previousAttributes[attr];

    },

    // Lorsque le modèle déclenche l'événement de changement, obtenez la collecte de données de l'état précédent de tous les attributs

    // Cette méthode est similaire à la méthode previous(). Elle est généralement appelée dans l'événement change et est utilisée pour la comparaison ou la restauration des données.

    Attributs précédents : function() {

      // Cloner l'objet de données de l'état précédent dans un nouvel objet et renvoyer

      return _.clone(this._previousAttributes);

    },

    // Vérifiez si le modèle est actuellement dans un état valide. Il est uniquement possible de le faire.

    // passe dans un état *invalide* si vous utilisez des modifications silencieuses.

    // Vérifiez si les données du modèle actuel peuvent être vérifiées par la méthode validate. Veuillez vous assurer que la méthode validate est définie avant d'appeler.

    estValide : fonction() {

      return !this.validate(this.attributes);

    },

    // La méthode de vérification des données est automatiquement exécutée lors de l'appel des méthodes set, save, add et autres méthodes de mise à jour des données.

    // L'échec de la vérification déclenchera l'événement "erreur" de l'objet modèle. Si une fonction de traitement d'erreur est spécifiée dans les options, seule la fonction options.error sera exécutée.

    // @param {Object} attrs attributs du modèle de données, qui stocke les données objectivées du modèle

    // @param {Object} éléments de configuration des options

    // @return {Boolean} Renvoie vrai si la vérification réussit, faux si elle échoue.

    _valider : fonction (attrs, options) {

      // Si l'attribut options.silent est défini lors de l'appel des méthodes set, save, add et autres méthodes de mise à jour des données, la vérification est ignorée

      // Si la méthode validate n'est pas ajoutée au Modèle, la validation est ignorée

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

        renvoie vrai ;

      // Récupère toutes les valeurs d'attribut​​dans l'objet et les place dans la méthode de validation pour vérification

      //La méthode validate contient deux paramètres, qui sont l'objet de collecte de données et de configuration dans le modèle. Si la validation réussit, aucune donnée ne sera renvoyée (la valeur par défaut est indéfinie). Si la validation échoue, les données contenant des informations d'erreur seront renvoyées. .

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

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

      //Vérification réussie

      si (! erreur)

        renvoie vrai ;

      // La vérification a échoué

      // Si la méthode de gestion des erreurs d'erreur est définie dans l'objet de configuration, appelez cette méthode et transmettez les données d'erreur et l'objet de configuration à cette méthode

      si(options && options.erreur) {

        options.error(ceci, erreur, options);

      } autre {

        // Si un écouteur d'événement d'erreur est lié au modèle, l'événement de liaison sera déclenché.

        this.trigger('erreur', ceci, erreur, options);

      }

      // La vérification du retour a échoué à l'identification

      renvoie faux ;

    }

  });



  // Collection de modèles de données Backbone.Collection liée

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



  // La collection stocke une série de modèles de données de la même classe et fournit des méthodes associées pour faire fonctionner les modèles

  var Collection = Backbone.Collection = function (modèles, options) {

    //Objet de configuration

    options || (options = {});

    //Définissez la classe modèle de la collection dans les paramètres de configuration

    si (options.modèle)

      this.model = options.model;

    // Si l'attribut comparator est défini, les données de la collection seront triées selon l'algorithme de tri dans la méthode comparateur (elles seront automatiquement appelées dans la méthode add)

    si (options.comparateur)

      this.comparator = options.comparator;

    //Réinitialise l'état interne de la collection lors de son instanciation (le premier appel peut être compris comme l'état de définition)

    this._reset();

    // Appelez la méthode d'initialisation personnalisée. Si nécessaire, la méthode initialize sera généralement surchargée.

    this.initialize.apply(this, arguments);

    // Si les données du modèle sont spécifiées, appelez la méthode reset pour ajouter les données à la collection.

    // Le paramètre Silent est défini lors du premier appel, donc l'événement "reset" ne sera pas déclenché.

    si (modèles)

      this.reset (modèles, {

        silencieux : vrai,

        analyser : options.parse

      });

  } ;

  // Définir la méthode prototype de la classe de collection via la méthode extend

  _.extend(Collection.prototype, Événements, {



    // Définissez la classe modèle de la collection. La classe modèle doit être une sous-classe de Backbone.Model.

    // Lors de l'utilisation de méthodes liées à la collection (telles que l'ajout, la création, etc.), les objets de données peuvent être transmis. La méthode de collection créera automatiquement l'instance correspondante en fonction de la classe de modèle définie.

    //Les modèles de données stockés dans la collection doivent tous être des instances de la même classe de modèle

    modèle : Modèle,



    // Méthode d'initialisation, cette méthode est automatiquement appelée après la création de l'instance de collection

    // Cette méthode est généralement surchargée lors de la définition de la classe de collection

    initialiser : function() {

    },

    // Renvoie un tableau contenant les objets de données de chaque modèle de la collection

    toJSON : fonction (options) {

      // Utilisez la méthode map d'Undersocre pour former un tableau de résultats toJSON pour chaque modèle de la collection, et retournez

      renvoyer this.map (fonction (modèle) {

        // Appelez tour à tour la méthode toJSON de chaque objet modèle. Cette méthode renverra l'objet de données du modèle (copie copiée) par défaut.

        // Si vous devez renvoyer une chaîne ou d'autres formulaires, vous pouvez surcharger la méthode toJSON

        return model.toJSON(options);

      });

    },

    //Ajouter un ou plusieurs objets modèle à la collection

    // L'événement "add" sera déclenché par défaut. Si l'attribut silencieux est défini dans les options, ce déclenchement d'événement peut être désactivé.

    // Les modèles transmis peuvent être un ou une série d'objets de modèle (instances de la classe Model). Si l'attribut model est défini dans la collection, les objets de données (tels que {name : 'test'}) sont autorisés à être. transmis directement. Instancier automatiquement l'objet de données dans l'objet modèle pointé par le modèle.

    ajouter : fonction (modèles, options) {

      //Définition des variables locales

      var i, index, longueur, modèle, cid, id, cids = {}, ids = {}, dups = [];

      options || (options = {});

      // Les modèles doivent être un tableau, si un seul modèle est transmis, convertissez-le en tableau

      models = _.isArray(models) ? models.slice() : [modèles];



      // Parcourez la liste des modèles qui doivent être ajoutés. Pendant le processus de parcours, les opérations suivantes seront effectuées :

      // - Convertir l'objet de données en objet modèle

      // - Etablir une référence entre le modèle et la collection

      // - Enregistre les modèles invalides et en double et les filtre plus tard

      pour( je = 0, longueur = modèles.longueur; je < longueur; je ) {

        //Convertissez l'objet de données en objet modèle, reprenez la référence du modèle et de la collection et stockez-le dans le modèle (en même temps, le modèle correspondant dans les modèles a été remplacé par un objet modèle)

        if(!( model = models[i] = this._prepareModel(models[i], options))) {

          throw new Error("Impossible d'ajouter un modèle invalide à une collection");

        }

        //Cid et identifiant du modèle actuel

        cid = modèle.cid;

        identifiant = modèle.id;

        //Les index de modèle invalides ou en double (index dans le tableau models) sont enregistrés dans le tableau dups et seront filtrés et supprimés à l'étape suivante.

        // Si l'index du modèle existe déjà dans les variables cids et ids, on considère que le même modèle a été déclaré plusieurs fois dans le tableau models passé.

        // Si l'index du modèle existe déjà dans l'objet _byCid, _byId, le même modèle est considéré comme existant déjà dans la collection courante.

        // Pour les deux situations ci-dessus, enregistrez l'index du modèle dans les dups pour le filtrage et la suppression

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

          dups.push(i);

          continuer;

        }

        // Enregistre les modèles qui ont été parcourus dans les modèles pour une inspection répétée lors du cycle suivant

        cids[cid] = ids[id] = modèle ;

      }



      // Supprime les modèles invalides ou en double des modèles et conserve la liste des modèles qui doivent réellement être ajoutés à la collection actuelle.

      je = dups.longueur;

      tandis que(i--) {

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

      }



      // Parcourez les modèles qui doivent être ajoutés, écoutez les événements du modèle et enregistrez la liste _byCid, _byId, qui est utilisée comme index lors de l'appel des méthodes get et getByCid.

      pour( je = 0, longueur = modèles.longueur; je < longueur; je ) {

        // Écoute tous les événements du modèle et exécute la méthode _onModelEvent

        // La méthode _onModelEvent traitera les événements d'ajout, de suppression, de destruction et de modification lancés par le modèle pour maintenir le modèle synchronisé avec l'état de la collection.

        (model = models[i]).on('all', this._onModelEvent, this);

        //Enregistrez le modèle dans l'objet _byCid basé sur cid pour faciliter la recherche basée sur cid

        this._byCid[model.cid] = modèle ;

        //Enregistrez le modèle dans l'objet _byId en fonction de l'identifiant pour faciliter la recherche basée sur l'identifiant

        si(modèle.id != null)

          this._byId[model.id] = modèle ;

      }



      //Modifie l'attribut length de la collection. L'attribut length enregistre le nombre de modèles dans la collection actuelle.

      this.length = longueur;

      //Définissez la position où la nouvelle liste de modèles est insérée dans la collection. Si le paramètre at est défini dans les options, insérez-le à la position at de la collection.

      // Sera inséré à la fin de la collection par défaut

      // Si une méthode de tri personnalisée du comparateur est définie, alors après avoir défini at, elle sera également triée selon la méthode dans le comparateur, donc l'ordre final peut ne pas être à la position spécifiée par at

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

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

      // Si la méthode du comparateur est définie, les données seront triées selon l'algorithme du comparateur

      // Le tri automatique utilise l'attribut silence pour empêcher le déclenchement de l'événement de réinitialisation.

      si (ce.comparateur)

        ceci.sort({

          silencieux : vrai

        });

      // Déclenchez l'événement "add" pour chaque objet du modèle tour à tour. Si l'attribut silencieux est défini, empêchez le déclenchement de l'événement.

      si (options.silent)

        rends ceci ;

      // Parcourez la liste de modèles nouvellement ajoutée

      pour (i = 0, longueur = this.models.length; i < longueur; i ) {

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

          continuer;

        options.index = i;

        // Déclenche l'événement "add" du modèle, car la collection écoute l'événement "all" du modèle, donc dans la méthode _onModelEvent, la collection déclenchera également l'événement "add"

        // Pour des informations détaillées, veuillez vous référer à la méthode Collection.prototype._onModelEvent

        model.trigger('ajouter', modèle, ceci, options);

      }

      rends ceci ;

    },

    //Supprimer les objets modèle de la collection (prend en charge la suppression de plusieurs modèles)

    //Les modèles transmis peuvent être l'objet modèle qui doit être supprimé, ou le cid du modèle et l'identifiant du modèle

    // La suppression du modèle n'appellera pas la méthode destroy du modèle

    // Si le paramètre options.silent n'est pas défini, l'événement Remove du modèle sera déclenché, et l'événement Remove de la collection sera déclenché (la collection écoute tous les événements du modèle via la méthode _onModelEvent)

    supprimer : fonction (modèles, options) {

      var i, l, index, modèle ;

      // les options sont par défaut un objet vide

      options || (options = {});

      // les modèles doivent être de type tableau, lorsqu'un seul modèle est supprimé, placez-le dans un tableau

      models = _.isArray(models) ? models.slice() : [modèles];

      // Parcourez la liste des modèles qui doivent être supprimés

      pour( je = 0, l = modèles.longueur; je < l; je ) {

        // La liste des modèles transmis peut être l'objet modèle qui doit être supprimé, ou le cid du modèle et l'identifiant du modèle

        // (Dans les méthodes getByCid et get, le modèle peut être obtenu via cid et id. Si un objet modèle est transmis, le modèle lui-même est renvoyé)

        modèle = this.getByCid(modèles[i]) || this.get(modèles[i]);

        //Le modèle n'a pas été obtenu

        si(!modèle)

          continuer;

        // Supprime la référence id du modèle de la liste _byId

        supprimez this._byId[model.id] ;

        // Supprime la référence cid du modèle de la liste _byCid

        supprimez this._byCid[model.cid] ;

        // indexOf est une méthode dans l'objet Underscore. Ici, la méthode indexOf est utilisée pour obtenir la position où le modèle apparaît pour la première fois dans la collection.

        index = this.indexOf(modèle);

        //Supprimer le modèle de la liste de collections

        this.models.splice(index, 1);

        // Réinitialise la propriété length de la collection actuelle (enregistre le nombre de modèles dans la collection)

        cette.longueur--;

        // Si l'attribut Silent n'est pas défini, l'événement Remove du modèle est déclenché.

        si(!options.silent) {

          //Ajoute la position du modèle actuel dans la collection à l'objet options et passe-la à l'événement d'écoute Remove afin qu'il puisse être utilisé dans la fonction événement.

          options.index = index;

          model.trigger('remove', modèle, this, options);

        }

        //Résoudre la relation entre le modèle et la collection, y compris les références au modèle et la surveillance des événements dans la collection

        this._removeReference(modèle);

      }

      rends ceci ;

    },

    //Ajouter un objet modèle à la fin de la collection

    // Si la méthode de tri du comparateur est définie dans la classe de collection, les modèles ajoutés via la méthode push seront triés selon l'algorithme défini par le comparateur, l'ordre des modèles pourra donc être modifié.

    push : fonction (modèle, options) {

      // Instancier le modèle dans un objet modèle via la méthode _prepareModel Ce code est redondant, car le modèle sera également obtenu via _prepareModel dans la méthode add appelée ci-dessous.

      model = this._prepareModel(modèle, options);

      //Appelez la méthode add pour ajouter le modèle à la collection (par défaut, il est ajouté à la fin de la collection)

      this.add(modèle, options);

      modèle de retour ;

    },

    //Supprimer le dernier objet modèle de la collection

    pop : fonction(options) {

      // Récupère le dernier modèle de la collection

      var modèle = this.at(this.length - 1);

      //Supprimez le modèle via la méthode Remove

      this.remove(modèle, options);

      modèle de retour ;

    },

    //Insérer le modèle en première position de la collection

    // Si la méthode de tri du comparateur est définie dans la classe de collection, les modèles ajoutés via la méthode unshift seront triés selon l'algorithme défini par le comparateur, l'ordre des modèles pourra donc être modifié.

    unshift : fonction (modèle, options) {

      // Instancie le modèle en un objet modèle via la méthode _prepareModel

      model = this._prepareModel(modèle, options);

      //Appelle la méthode add pour insérer le modèle dans la première position de la collection (fixée à 0)

      // Si la méthode de tri du comparateur est définie, l'ordre de la collection sera réorganisé

      this.add(modèle, _.extend({

        à : 0

      }, options));

      modèle de retour ;

    },

    // Supprime et renvoie le premier objet modèle de la collection

    décalage : fonction (options) {

      // Récupère le premier modèle de la collection

      var modèle = this.at(0);

      //Supprimer le modèle de la collection

      this.remove(modèle, options);

      // Retourne l'objet modèle

      modèle de retour ;

    },

    //Trouver le modèle de la collection en fonction de l'identifiant et le renvoyer

    obtenir : fonction (identifiant) {

      si (identifiant == nul)

        retour

        vide 0 ;

      return this._byId[id.id != null ?

    },

    //Trouver le modèle de la collection basé sur cid et le renvoyer

    getByCid : fonction(cid) {

      return cid && this._byCid[cid.cid ||

    },

    // Recherche le modèle de la collection selon l'index (indice, commençant à 0) et retourne

    à : fonction (index) {

      renvoie this.models[index] ;

    },

    // Filtrer les modèles de la collection en fonction des valeurs

    // attrs est un objet filtre, tel que {name: 'Jack'}, qui renverra tous les modèles (tableau) portant le nom "Jack" dans la collection

    où : fonction(attrs) {

      // les attributs ne peuvent pas être vides

      si (_.isEmpty (attrs))

        retour [];

      // Filtrer les modèles de la collection via la méthode filter

      // La méthode filter est une méthode dans Underscore, qui est utilisée pour parcourir les éléments de la collection et renvoyer les éléments qui peuvent passer la vérification du processeur (la valeur de retour est vraie) sous forme de tableau

      renvoyer this.filter (fonction (modèle) {

        // Parcours des règles de validation dans l'objet attrs

        pour (clé var dans les attributs) {

          // Faites correspondre les règles de validation dans attrs avec les modèles de la collection

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

            renvoie faux ;

        }

        renvoie vrai ;

      });

    },

    // Trie les modèles de la collection selon la méthode spécifiée par l'attribut comparateur

    // Si le paramètre Silent n'est pas défini dans les options, l'événement Reset sera déclenché après le tri

    trier : fonction (options) {

      // les options sont par défaut un objet

      options || (options = {});

      // L'attribut comparateur (méthode de l'algorithme de tri) doit être spécifié lors de l'appel de la méthode de tri, sinon une erreur sera générée

      si(!this.comparator)

        throw new Error('Impossible de trier un ensemble sans comparateur');

      //boundComparator stocke la méthode de l'algorithme de tri du comparateur liée à l'objet de contexte de collection actuel.

      varboundComparator = _.bind(this.comparator, this);

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

        this.models = this.sortBy(boundComparator);

      } autre {

        //Appelez Array.prototype.sort pour trier les données via l'algorithme de comparaison

        this.models.sort(boundComparator);

      }

      // Si le paramètre Silent n'est pas spécifié, l'événement Reset est déclenché

      si(!options.silent)

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

      rends ceci ;

    },

    // Stocke les valeurs d'attribut attr de tous les modèles de la collection dans un tableau et renvoie

    plumer : fonction (attr) {

      // map est une méthode dans Underscore, utilisée pour parcourir une collection et renvoyer les valeurs de retour de tous les processeurs sous forme de tableau

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

        // Renvoie la valeur de l'attribut attr du modèle actuel

        return model.get(attr);

      });

    },

    // Remplacer toutes les données de modèle (modèles) dans la collection

    // Cette opération supprimera toutes les données et statuts actuels de la collection et réinitialisera les données aux modèles

    // Les modèles doivent être un tableau pouvant contenir une série d'objets de modèle modèle ou d'objets originaux (seront automatiquement créés en tant qu'objets de modèle dans la méthode add)

    réinitialiser : fonction (modèles, options) {

      // models est le tableau de modèles (ou de données) à remplacer

      modèles || ( modèles = []);

      // les options sont par défaut un objet vide

      options || (options = {});

      // Parcourt les modèles de la collection actuelle, supprime et libère tour à tour leurs relations de référence avec la collection

      pour (var je = 0, l = this.models.length; je < l; je ) {

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

      }

      //Supprimer les données de collection et réinitialiser l'état

      this._reset();

      //Ajouter de nouvelles données de modèle à la collection via la méthode add

      // Ici, l'élément de configuration est écrasé par un nouvel objet via la méthode exnted. La valeur silencieuse par défaut de cet objet est true, donc l'événement "add" ne sera pas déclenché.

      // Si l'attribut quiet n'est pas défini lors de l'appel de la méthode reset, l'événement reset sera déclenché. S'il est défini sur true, aucun événement ne sera déclenché. S'il est défini sur false, les événements "add" et "reset" seront déclenchés. en séquence.

      this.add(modèles, _.extend({

        silencieux : vrai

      }, options));

      // Si l'attribut Silent n'est pas défini lors de l'appel de la méthode Reset, l'événement Reset est déclenché.

      si(!options.silent)

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

      rends ceci ;

    },

    // Récupère les données d'initialisation de la collection depuis le serveur

    // Si le paramètre add=true est défini dans les options, les données obtenues seront ajoutées à la collection, sinon les données actuelles de la collection seront remplacées par les données renvoyées par le serveur

    récupérer : fonction (options) {

      // Copiez l'objet options, car l'objet options sera modifié ultérieurement pour le stockage temporaire des données

      options = options ? _.clone(options) : {};

      if(options.parse === non défini)

        options.parse = true ;

      // la collection enregistre l'objet de collection actuel pour l'utiliser dans la fonction de rappel de réussite

      var collection = ceci;

      // Fonction de rappel personnalisée, une fois la demande de données réussie et l'ajout terminé, la fonction de réussite personnalisée sera appelée

      var success = options.success;

      // Exécute options.success lors de la demande réussie de données au serveur. Cette fonction analysera et ajoutera des données.

      options.success = fonction (resp, statut, xhr) {

        // Utilisez la méthode parse pour analyser les données renvoyées par le serveur. Si vous devez personnaliser la structure des données, vous pouvez surcharger la méthode parse.

        // Si add=true est défini dans les options, la méthode add est appelée pour ajouter des données à la collection, sinon les données de la collection seront remplacées par les données renvoyées par le serveur via la méthode reset

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

        // Si un rappel de réussite personnalisé est défini, exécutez

        si (succès)

          succès(collection, resp);

      } ;

      // Lorsque le serveur renvoie une erreur d'état, gérez l'événement d'erreur via la méthode wrapError

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

      // Appelez la méthode Backbone.sync pour envoyer une requête pour obtenir des données du serveur

      // Si les données requises ne sont pas obtenues du serveur, ou si la méthode d'acquisition n'utilise pas AJAX, vous pouvez surcharger la méthode Backbone.sync

      return (this.sync || Backbone.sync).call(this, 'read', this, options);

    },

    // Ajoutez et créez un modèle à la collection et enregistrez le modèle sur le serveur

    // Si vous créez un modèle via un objet de données, vous devez déclarer la classe de modèle correspondant à l'attribut de modèle dans la collection.

    // Si l'attribut wait est déclaré dans les options, le modèle sera ajouté à la collection une fois le serveur créé avec succès. Sinon, le modèle sera d'abord ajouté à la collection puis enregistré sur le serveur (que la sauvegarde soit ou non). réussi ou non)

    créer : fonction (modèle, options) {

      varcoll = ceci;

      //Définir l'objet d'options

      options = options ? _.clone(options) : {};

      // Récupère l'instance de la classe modèle via _prepareModel

      model = this._prepareModel(modèle, options);

      // La création du modèle a échoué

      si(!modèle)

        renvoie faux ;

      // Si l'attribut wait n'est pas déclaré, ajoutez le modèle à la collection via la méthode add

      si(!options.attendre)

        coll.add(modèle, options);

      // Success stocke la fonction de rappel personnalisée après un enregistrement réussi sur le serveur (déclaré via options.success)

      var success = options.success;

      // Écoutez la fonction de rappel une fois les données du modèle enregistrées avec succès.

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

        // Si l'attribut wait est déclaré, le modèle sera ajouté à la collection uniquement après l'enregistrement réussi du serveur.

        si (options.attendre)

          coll.add(nextModel, options);

        // Si un rappel de réussite personnalisé est déclaré, la fonction personnalisée sera exécutée, sinon l'événement de synchronisation du modèle sera déclenché par défaut

        si (succès) {

          succès (nextModel, resp);

        } autre {

          nextModel.trigger('sync', modèle, resp, options);

        }

      } ;

      // Appelez la méthode save du modèle pour enregistrer les données du modèle sur le serveur

      model.save(null, options);

      modèle de retour ;

    },

    // Méthode d'analyse des données, utilisée pour analyser les données du serveur en données structurées utilisables par les modèles et les collections

    // Par défaut, resp lui-même sera renvoyé. Cela doit définir le format de données pris en charge par Backbone avec le serveur. Si vous devez personnaliser le format de données, vous pouvez surcharger la méthode d'analyse.

    analyser : fonction (resp, xhr) {

      retour resp;

    },

    // La chaîne est utilisée pour créer une opération en chaîne de données de collection. Elle convertit les données de la collection en un objet Underscore et utilise la méthode de chaîne de Underscore pour les convertir en une structure de chaîne.

    // Concernant la méthode de conversion de la méthode chaîne, veuillez vous référer aux commentaires sur la méthode chaîne dans Underscore.

    chaîne : fonction() {

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

    },

    //Supprime tous les éléments de la collection et réinitialise l'état des données dans la collection

    _reset : fonction(options) {

      //Supprimer les éléments de la collection

      this.length = 0;

      this.models = [];

      //Réinitialiser l'état de la collection

      this._byId = {};

      this._byCid = {};

    },

    // Quelques préparations avant d'ajouter le modèle à la collection

    // Y compris l'instanciation des données en tant qu'objet de modèle et le référencement de la collection à la propriété collection du modèle

    _prepareModel : fonction (modèle, options) {

      options || (options = {});

      // Vérifiez si le modèle est un objet modèle (c'est-à-dire une instance de la classe Model)

      if(!(instance de modèle de modèle)) {

        //Le modèle transmis est un objet de données de modèle, pas un objet de modèle

        // Passe les données en tant que paramètres au modèle pour créer un nouvel objet modèle

        var attrs = modèle ;

        //Définit la collection de références de modèle

        options.collection = ceci;

        // Convertir les données en modèle

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

        // Valide les données dans le modèle

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

          modèle = faux ;

      }sinon si(!model.collection) {

        // Si un objet modèle est transmis mais qu'aucune référence à la collection n'est établie, définissez la propriété collection du modèle sur la collection actuelle.

        modèle.collection = ceci ;

      }

      modèle de retour ;

    },

    //Dissocie la relation entre un modèle et la collection, y compris les références à la collection et la surveillance des événements

    // Généralement appelé automatiquement lorsque la méthode Remove est appelée pour supprimer le modèle ou que la méthode Reset est appelée pour réinitialiser l'état.

    _removeReference : fonction (modèle) {

      // Si le modèle fait référence à la collection actuelle, supprimez la référence (vous devez vous assurer que toutes les références au modèle ont été libérées, sinon le modèle risque de ne pas être libéré de la mémoire)

      if(this == model.collection) {

        supprimer model.collection ;

      }

      // Annule tous les événements de modèle surveillés dans la collection

      model.off('all', this._onModelEvent, this);

    },

    // Appelé automatiquement lors de l'ajout d'un modèle à la collection

    // Utilisé pour surveiller les événements des modèles de la collection. Lorsque le modèle déclenche un événement (événement d'ajout, de suppression, de destruction, de modification), la collection effectue le traitement associé.

    _onModelEvent : fonction (événement, modèle, collection, options) {

      // Lors de l'ajout et de la suppression d'événements de modèle, vous devez vous assurer que la collection à laquelle appartient le modèle est l'objet de collection actuel.

      if((event == 'ajouter' || event == 'supprimer') && collection != this)

        retour;

      //Lorsque le modèle déclenche l'événement de destruction, il est supprimé de la collection

      if(événement == 'détruire') {

        this.remove(modèle, options);

      }

      // Lorsque l'identifiant du modèle est modifié, la référence au modèle est stockée dans la collection modification _byId pour maintenir la synchronisation avec l'identifiant du modèle, facilitant ainsi l'obtention de l'objet modèle à l'aide de la méthode get().

      if(modèle && événement === 'change:' model.idAttribute) {

        // Récupère l'identifiant du modèle avant le changement et le supprime de la liste _byId de la collection en fonction de cet identifiant

        supprimez this._byId[model.previous(model.idAttribute)] ;

        // Utilise le nouvel identifiant du modèle comme clé et stocke la référence au modèle dans la liste _byId

        this._byId[model.id] = modèle ;

      }

      // Déclenche l'événement correspondant au modèle dans la collection. Quel que soit l'événement déclenché par le modèle, la collection déclenchera l'événement correspondant.

      // (Par exemple, lorsqu'un modèle est ajouté à une collection, l'événement "add" du modèle sera déclenché, et l'événement "add" de la collection sera également déclenché dans cette méthode)

      // Ceci est très utile pour écouter et gérer les modifications apportées à l'état du modèle dans une collection

      // Dans l'événement de collection surveillé, le modèle qui a déclenché l'événement correspondant sera passé en paramètre à la fonction d'écoute de la collection.

      this.trigger.apply(this, arguments);

    }

  });



  // Définir les méthodes associées pour les opérations de collection dans Underscore

  // Copiez une série de méthodes d'opération de collection dans Underscore vers l'objet prototype de la classe Collection

  // De cette façon, vous pouvez appeler les méthodes de collection liées au soulignement directement via l'objet de collection.

  //Les données de collection exploitées par ces méthodes lorsqu'elles sont appelées sont les données de modèles de l'objet Collection actuel.

  var méthodes = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect', 'filter', 'select', 'reject', 'every', 'all ', 'some', 'any', 'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size', 'first', 'initial', 'rest', 'last', 'sans', 'indexOf', 'shuffle', 'lastIndexOf', 'isEmpty', 'groupBy'];



  // Parcourt la liste des méthodes définies

  _.each(méthodes, fonction(méthode) {

    // Copiez la méthode dans l'objet prototype de la classe Collection

    Collection.prototype[méthode] = fonction() {

      // Utilisez la méthode Underscore directement lors de l'appel, et l'objet contextuel reste l'objet Underscore.

      // Il convient de noter que le paramètre de collection passé ici à la méthode Underscore est this.models, donc lors de l'utilisation de ces méthodes, l'objet de collection exploité est les données de modèles de l'objet Collection actuel.

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

    } ;

  });

  // Routeur URL Backbone.Router

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



  // Implémentation d'un routeur personnalisé en héritant de la classe Backbone.Router

  // Le routeur vous permet de définir des règles de routage, de naviguer dans les fragments d'URL et de mapper chaque règle à une méthode qui sera automatiquement exécutée lorsque l'URL correspond à une certaine règle.

  // Le routeur navigue dans l'URL. Les méthodes de navigation sont divisées en méthodes pushState, Hash et listening (pour plus de détails, veuillez vous référer à la classe Backbone.History)

  // Lors de la création d'une instance de routeur, définissez la méthode d'écoute correspondant à une certaine règle de routage via options.routes

  // Les règles de routage dans options.routes sont organisées selon {nom de la règle : nom de la méthode} La méthode correspondant à chaque règle de routage doit être une méthode déclarée dans l'instance du routeur.

  // Les règles de routage définies par options.routes sont mises en correspondance dans l'ordre. Si l'URL actuelle peut correspondre à plusieurs règles, seule la première méthode d'événement correspondante sera exécutée.

  var Routeur = Backbone.Router = fonction (options) {

    // les options sont par défaut un objet vide

    options || (options = {});

    // Si l'objet routes (règle de routage) est défini dans les options, attribuez-le à l'attribut routes de l'instance actuelle

    // L'attribut routes enregistre la relation de liaison entre les règles de routage et les méthodes d'événement. Lorsque l'URL correspond à une certaine règle, la méthode d'événement associée sera automatiquement appelée.