implementar correctamente los comparadores de la red troncal

Question

Me estoy quedando un poco atascado implementado un comparador de red troncal, básicamente quiero seleccionar diferentes métodos de clasificación basados ​​en la ruta y usar el comparador para ordenar la colección. Idealmente, quiero mantener la lógica de clasificación encapsulada dentro de la colección, pero parece que se está estancando. Por ejemplo

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

lo que por defecto ordena basa en el comparador por defecto - pero en mi enrutamiento deseo de poder recurrir, por ejemplo, hacer algo como

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

Sin embargo, en ese caso, me sale un error ('c.call no es una función') alguna idea?

Answer 1

Tiene algunas cosas mal aquí.

Esto no hace lo que usted cree:

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

que ejecuta el método nooffers y asigna el resultado a Request.comparator. Pero sortBy devuelve la lista ordenada:

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

y el establecimiento de esa lista como la función de comparación no hace nada útil.

desea cambiar la asignación de utilizar la función en lugar de que su valor de retorno:

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

y cambiar la función de ser una función de comparación válida:

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

Demo (correr con su consola abierta): http://jsfiddle.net/ambiguous/AAZCa/

Pero tener a alguien del exterior jugueteando con los métodos de la colección como ese huele mal y no deberías hazlo. En su lugar, usted debe preguntar a la colección de cambiar su ordenación con algo como esto:

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(); 

Demostración: http://jsfiddle.net/ambiguous/uM9av/

O puede dejar que el canje de recogida su propio comparator para evitar toda la lógica condicional dentro 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'); 
    } 
}); 

demostración: http://jsfiddle.net/ambiguous/Pjfq2/

Answer 2

escribí encargo m étodo de la colección que se encargará de clasificar tanto ascendente como descendente y también ordena los registros con alfanumérica apropiada

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(); 
    }}); 

// se puede ordenar mediante el método de "Ordenar" (mirar de cerca S mayúscula para el método de clasificar)