Comment faire Backbone.js les articles de la Collection Uniques?

Je voudrais remplacer le add méthode dans votre TruckList collecte et l'utilisation de soulignement pour détecter les doublons il y et de rejeter le double. Quelque chose comme.

TruckList.prototype.add = function(truck) {
    //Using isDupe routine from @Bill Eisenhauer's answer
    var isDupe = this.any(function(_truck) { 
        return _truck.get('brand') === truck.get('brand');
    });

    //Up to you either return false or throw an exception or silently ignore
    //NOTE: DEFAULT functionality of adding duplicate to collection is to IGNORE and RETURN. Returning false here is unexpected. ALSO, this doesn't support the merge: true flag.
    //Return result of prototype.add to ensure default functionality of .add is maintained. 
    return isDupe ? false : Backbone.Collection.prototype.add.call(this, truck);
}

OriginalL'auteur Peter Lyons

De l'essayer. Il utilise le tout caractère de soulignement méthode pour détecter les éventuels doublons et puis se déverse dans l'affirmative. Bien sûr, vous pourriez souhaiter de s'habiller avec une exception pour être plus robuste:

TruckList.prototype.add = function(newTruck) {
  var isDupe = this.any(function(truck) { 
    return truck.get('brand') === newTruck.get('brand');
  }
  if (isDupe) return;
  Backbone.Collection.prototype.add.call(this, truck);
}

En aparté, je serais probablement écrire une fonction sur un Camion pour faire la dupe de vérifier que la collection ne pas trop en savoir sur cette condition.

OriginalL'auteur Bill Eisenhauer

Je suis en train de faire un FileUpload chose avec la même question, et voici comment je l'ai fait (coffeescript):

File = Backbone.Model.extend
    validate: (args) ->
        result
        if !@collection.isUniqueFile(args)
            result = 'File already in list'
        result

Files = Backbone.Collection.extend
    model: File

    isUniqueFile: (file) ->
        found
        for f in @models
            if f.get('name') is file.name
                found = f
                break
        if found
            false
        else
            true

... et c'est tout. L'objet de collection est automatiquement référencé dans le Fichier, et la Validation est automatiquement appelée quand une action est appelée sur la collection qui dans ce cas est d'Ajouter.

OriginalL'auteur George R

Ne sais pas si c'est une mise à jour soit Dorsale ou un trait de soulignement, mais le where() fonction de la colonne vertébrale 0.9.2 pour faire la correspondance pour vous:

TruckList.prototype.add = function(truck) {
    var matches = this.where({name: truck.get('brand')});

    if (matches.length > 0) {
        //Up to you either return false or throw an exception or silently ignore
        return false;
    }

    Backbone.Collection.prototype.add.call(this, truck);
}

OriginalL'auteur jlleblanc

...

var TruckList = Backbone.Collection.extend({
  model: Truck,
  comparator: function(truck) {
     return truck.get("brand");
  },
  wherePartialUnique: function(attrs) {
    //this method is really only tolerant of string values.  you can't do partial
    //matches on arrays, objects, etc.  use collection.where for that
      if (_.isEmpty(attrs)) return [];
      var seen = [];
      return this.filter(function(model) {
        for (var key in attrs) {
          //sometimes keys are empty. that's bad, so let's not include it in a unique result set
          //you might want empty keys though, so comment the next line out if you do.
          if ( _.isEmpty(model.get(key).trim()) ) return false;
          //on to the filtering...
          if (model.get(key).toLowerCase().indexOf(attrs[key].toLowerCase()) >= 0) {
            if (seen.indexOf( model.get(key) ) >= 0 ) return false;
            seen.push(model.get(key));
            return true;
          } else {
            return false;
          }
        }
        return true;
      });
    }
});

Un peu de choses à retenir:

1. ceci est basé sur la dorsale.collection.où la méthode et à la différence de cette méthode, il va tenter correspondances partielles sur les attributs de modèle au sein d'une collection. Si vous ne voulez pas cela, vous aurez besoin de le modifier pour seulement correspondre exactement. Seulement imiter ce que vous voyez dans la méthode originale.

2. il doit être capable d'accepter plusieurs attribut correspond, donc si vous avez des attributs de modèle de foo et bar, vous devriez être en mesure de faire la collecte.wherePartialUnique({foo:"vous",un bar:"dude"}). Je n'ai pas testé. 🙂 Je ne l'ai jamais fait une paire clé/valeur.

3. j'ai aussi bande vide attributs de modèle à partir de l'examen. Je ne m'inquiète pas à ce sujet, mais vous pourriez.

4. cette méthode ne nécessite pas une collection unique de propriétés du modèle que le comparateur dépend. C'est plus comme en sql, la requête distinct, mais je ne suis pas un sql mec afin de ne pas me tirer dessus si c'est un mauvais exemple 🙂

5. votre collection est triée par le comparateur de fonction, ainsi, l'une des hypothèses à ce sujet de ne pas être triés est incorrect.

Je crois que cela permet également de résoudre l'ensemble de vos objectifs:

1. Collection n'est pas triée
2. Le retrait doit être effectué sur la marque valeur de l'attribut
3. Appel Ajax pour remplir chaque instance d'un Camion. Cela signifie que lors de l'ajout à une collection, vous n'avez pas accès pour le Camion propriétés.

OriginalL'auteur Sneaky Wombat

Je suis vraiment malheureux avec la accepté de répondre à cette solution. Il contient de nombreuses erreurs. J'ai édité le solution originale pour souligner mes préoccupations, mais je propose la solution suivante en supposant que vous êtes OK salir votre duplicata de la carte d'identité/cid de propriété:

TruckList.prototype.add = function(truckToAdd, options) {
    // Find duplicate truck by brand:
    var duplicateTruck = this.find(function(truck){
        return truck.get('brand') === truckToAdd.get('brand');
    });

    // Make truck an actual duplicate by ID: 
    // TODO: This modifies truckToAdd's ID. This could be expanded to preserve the ID while also taking into consideration any merge: true options.
    if(duplicateTruck !== undefined){
        if(duplicateTruck.has('id')){
            truckToAdd.set('id', duplicateTruck.get('id'), { silent: true });
        }
        else {
            truckToAdd.cid = duplicateTruck.cid;
        }
    }

    // Allow Backbone to handle the duplicate instead of trying to do it manually.
    return Backbone.Collection.prototype.add.call(this, truckToAdd, options);
}

Le seul défaut avec celui-ci, c'est que truckToAdd ID/cid n'est pas conservé. Toutefois, cela ne veut préserver l'ensemble de la fonctionnalité attendue de l'ajout d'un élément à une collection, y compris en passant de fusion: vrai.

OriginalL'auteur Sean Anderson