web-dev-qa-db-fra.com

implémenter correctement les comparateurs de dorsale

Je suis un peu bloqué par la mise en place d’un comparateur dorsal. Je souhaite en principe sélectionner différentes méthodes de tri en fonction de l’itinéraire et utiliser le comparateur pour trier la collection. Idéalement, je veux que la logique de tri soit encapsulée dans la collection, mais que je sois coincée. Par exemple

    Requests = Backbone.Collection.extend({
        model : Request,
        comparator : function(ab) {
            return -ab.id;
        },          
        nooffers : function() {
            return this.sortBy(function(ab) {               
                 return ab.get('offers');
            });
        }
    });

Donc, par défaut, il effectue le tri en fonction du comparateur par défaut - mais dans mon routage, je souhaite pouvoir recourir par exemple à. faire quelque chose comme

   routes : {
        "" : "index",
        '/ordering/:order' : 'ordering'
    },
    ordering : function(theorder) {
        ordering = theorder;
        if(theorder == 'nooffers') {
            Request.comparator = Request.nooffers();
        }
        Request.sort();
        listView.render();  
        howitworksView.render();
    }

Cependant, dans ce cas, j'obtiens une erreur ("c.call n'est pas une fonction") des idées? 

javascriptbackbone.jsunderscore.js
21
Xrender

Vous avez quelques petites choses qui ne vont pas ici.

Cela ne fait pas ce que vous pensez qu'il fait:

if(theorder == 'nooffers') {
    Request.comparator = Request.nooffers();
}

Cela exécute la méthode nooffers et affecte son résultat à Request.comparator. Mais sortBy renvoie la liste triée:

nooffers : function() {
    return this.sortBy(function(ab) {               
        return ab.get('offers');
    });
}

et définir cette liste comme fonction de comparaison ne sert à rien.

Vous voulez changer l'affectation pour utiliser la fonction plutôt que sa valeur de retour:

if(theorder == 'nooffers') {
    Request.comparator = Request.nooffers;
}

et changez la fonction pour qu'elle soit une fonction de comparaison valide:

nooffers : function(ab) {
    return ab.get('offers');
}

Démo (avec la console ouverte): http://jsfiddle.net/ambiguous/AAZCa/

Mais avoir quelqu'un de l'extérieur jouant avec les méthodes de la collection comme ça sent mauvais et vous ne devriez pas le faire. Au lieu de cela, vous devriez demander à la collection de changer son ordre avec quelque chose comme:

var Requests = Backbone.Collection.extend({
    model: Request,
    comparator: function(ab) {
        if(this._order_by == 'offers')
            return ab.get('offers');
        else if(this._order_by == 'id')
            return -ab.id;
        //...
    },
    order_by_offers: function() {
        this._order_by = 'offers';
        this.sort();
    },
    order_by_default: function() {
        this._order_by = 'id';
        this.sort();
    },
    _order_by: 'id'
});
//...
rs.order_by_offers();

Démo: http://jsfiddle.net/ambiguous/uM9av/

Vous pouvez également laisser la collection échanger sa propre comparator pour éviter toute la logique conditionnelle de la comparator:

var Requests = Backbone.Collection.extend({
    model: Request,
    initialize: function() {
        this._order_by_id = this.comparator;
    },
    comparator: function(ab) {
        return -ab.id;
    },
    order_by_offers: function() {
        this.comparator = this._order_by_offers;
        this.sort();
    },
    order_by_default: function() {
        this.comparator = this._order_by_id;
        this.sort();
    },
    _order_by_offers: function(ab) {
        return ab.get('offers');
    }
});

Démo: http://jsfiddle.net/ambiguous/Pjfq2/

50
mu is too short

J'ai écrit une méthode personnalisée dans la collection qui se chargera du tri croissant et décroissant, ainsi que des enregistrements alphanumériques appropriés.

var LetterVariables = Backbone.Collection.extend({



    initialize: function (id) {

        //id of the table
        this.id = id;

        this.sortVar = "id"; //default sorting column
        this.sOrder = "asc" //default sort order
    },
    //comparator function that will create a descending and an ascending order tot he view
    comparator: function (item,itemb) {
        var a=item.get(this.sortVar);
        var b=itemb.get(this.sortVar);
        if (this.sOrder == "asc") {
            return this.SortCustom(a, b);
        }
        return -this.SortCustom(a, b);
    },
    SortCustom:function(a,b){
                if (isNaN(a)) {
                    if (isNaN(b)) {
                        if (a > b) return 1; // before
                        if (b > a) return -1; // after
                        return 0;
                    }
                    return 1;
                }
                if (isNaN(b)) {
                    return -1;
                }
                if (+a > +b) return 1; // before
                if (+b > +a) return -1; // after
                return 0;
    },
    Sort: function (by, order) {

        this.sOrder = order;
        this.sortVar = by;
        this.sort();
    }});

// vous pouvez trier en utilisant la méthode "Sort" (regardez de près la lettre S majuscule pour la méthode Sort)

0
Sabareesh Kkanan