blocks|key|1000270|text|修改您的比较器函数以返回一些反比的值，而不是返回您当前所在的数据。来自：http://documentcloud.github.com/backbone/#Collection-comparator的一些代码|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1000271|示例：|1000272|var+Chapter++=+Backbone.Model;
var+chapters+=+new+Backbone.Collection;

/*+Method+1:+This+sorts+by+page+number+*/
chapters.comparator+=+function(chapter)+{
++return+chapter.get("page");
};

/*+Method+2:+This+sorts+by+page+number+in+reverse+*/
chapters.comparator+=+function(chapter)+{
++return+-chapter.get("page");
};

chapters.add(new+Chapter({page:+9,+title:+"The+End"}));
chapters.add(new+Chapter({page:+5,+title:+"The+Middle"}));
chapters.add(new+Chapter({page:+1,+title:+"The+Beginning"}));|code-block|syntax|javascript|1000273|entityMap|0|LINK|mutability|MUTABLE|url|http://documentcloud.github.com/backbone/#Collection-comparator^0|10|1R|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Modify your comparator function to return some reversely proporitional value instead of returning the data that you are currently.
Some code from : <a href="http://documentcloud.github.com/backbone/#Collection-comparator" rel="noreferrer">http://documentcloud.github.com/backbone/#Collection-comparator</a>

Example:

<pre><code>var Chapter = Backbone.Model;
var chapters = new Backbone.Collection;

/* Method 1: This sorts by page number */
chapters.comparator = function(chapter) {
 return chapter.get("page");
};

/* Method 2: This sorts by page number in reverse */
chapters.comparator = function(chapter) {
 return -chapter.get("page");
};

chapters.add(new Chapter({page: 9, title: "The End"}));
chapters.add(new Chapter({page: 5, title: "The Middle"}));
chapters.add(new Chapter({page: 1, title: "The Beginning"}));
</code></pre>

blocks|key|1000349|text|嗯，你可以从比较器返回负值。例如，如果我们以Backbone的站点为例，并希望颠倒顺序，它将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000350|var+Chapter++=+Backbone.Model;
var+chapters+=+new+Backbone.Collection;

chapters.comparator+=+function(chapter)+{
++return+-chapter.get("page");+//+Note+the+minus!
};

chapters.add(new+Chapter({page:+9,+title:+"The+End"}));
chapters.add(new+Chapter({page:+5,+title:+"The+Middle"}));
chapters.add(new+Chapter({page:+1,+title:+"The+Beginning"}));

alert(chapters.pluck('title'));|code-block|syntax|javascript|1000351|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Well, you can return negative values from comparator. If we take, for example, the example from Backbone's site and want to reverse the order, it will look like this:

<pre><code>var Chapter = Backbone.Model;
var chapters = new Backbone.Collection;

chapters.comparator = function(chapter) {
 return -chapter.get("page"); // Note the minus!
};

chapters.add(new Chapter({page: 9, title: "The End"}));
chapters.add(new Chapter({page: 5, title: "The Middle"}));
chapters.add(new Chapter({page: 1, title: "The Beginning"}));

alert(chapters.pluck('title'));
</code></pre>

blocks|key|1000424|text|‘s的集合比较器依赖于Underscore.js方法_.sortBy。sortBy的实现方式最终“包装”了javascript+.sort()，这使得反向排序字符串变得很困难。对字符串进行简单的否定操作会返回NaN并破坏排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000425|如果您需要对字符串执行反向排序，例如按字母顺序反向排序，这里有一种非常老套的方法：|1000426|comparator:+function+(Model)+{
++var+str+=+Model.get("name");
++str+=+str.toLowerCase();
++str+=+str.split("");
++str+=+_.map(str,+function(letter)+{+
++++return+String.fromCharCode(-(letter.charCodeAt(0)));
++});
++return+str;
}|code-block|syntax|javascript|1000427|它一点也不漂亮，但它是一个“字符串负值器”。如果你对在javascript中修改原生对象类型没有任何顾虑，你可以通过提取字符串求反器并将其作为一个方法添加到String.Prototype中来使你的代码更清晰。然而，您可能只在知道自己在做什么的情况下才想这样做，因为在javascript中修改原生对象类型可能会产生不可预见的后果。|1000428|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Backbone.js's collection comparator relies on the Underscore.js method _.sortBy. The way sortBy is implemented ends up "wrapping" up javascript .sort() in a way that makes sorting strings in reverse difficult. Simple negation of the string ends up returning NaN and breaks the sort. 

If you need to perform a reverse sort with Strings, such as reverse alphabetical sort, here's a really hackish way of doing it:

<pre><code>comparator: function (Model) {
 var str = Model.get("name");
 str = str.toLowerCase();
 str = str.split("");
 str = _.map(str, function(letter) { 
 return String.fromCharCode(-(letter.charCodeAt(0)));
 });
 return str;
}
</code></pre>

It's by no means pretty, but it is a "string negator". If you don't have any qualms with modifying native object types in javascript, you could make you code clearer by extracting the string negator and adding it as a method on String.Prototype. However you probably only want to do this if you know what you are doing, because modifying native object types in javascript can have unforeseen consequences.

blocks|key|786225|text|我的解决方案是在排序后反转结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|786226|为了防止双重渲染，首先使用静默进行排序，然后触发“reset”。|786227|collections.sort({silent:true})
collections.models+=+collections.models.reverse();
collections.trigger('reset',+collections,+{});|code-block|syntax|javascript|786228|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My solution was to reverse results after sort. 

To prevent double rendering first sort with silent, then trigger 'reset'.

<pre><code>collections.sort({silent:true})
collections.models = collections.models.reverse();
collections.trigger('reset', collections, {});
</code></pre>

blocks|key|786256|text|这可以通过覆盖sortBy方法来很好地完成。下面是一个例子|type|unstyled|depth|inlineStyleRanges|entityRanges|data|786257|var+SortedCollection+=+Backbone.Collection.extend({

+++initialize:+function+()+{
+++++++//+Default+sort+field+and+direction
+++++++this.sortField+=+"name";
+++++++this.sortDirection+=+"ASC";
+++},

+++setSortField:+function+(field,+direction)+{
+++++++this.sortField+=+field;
+++++++this.sortDirection+=+direction;
+++},

+++comparator:+function+(m)+{
+++++++return+m.get(this.sortField);
+++},

+++//+Overriding+sortBy+(copied+from+underscore+and+just+swapping+left+and+right+for+reverse+sort)
+++sortBy:+function+(iterator,+context)+{
+++++++var+obj+=+this.models,
+++++++++++direction+=+this.sortDirection;

+++++++return+_.pluck(_.map(obj,+function+(value,+index,+list)+{
+++++++++++return+{
+++++++++++++++value:+value,
+++++++++++++++index:+index,
+++++++++++++++criteria:+iterator.call(context,+value,+index,+list)
+++++++++++};
+++++++}).sort(function+(left,+right)+{
+++++++++++//+swap+a+and+b+for+reverse+sort
+++++++++++var+a+=+direction+===+"ASC"+?+left.criteria+:+right.criteria,
+++++++++++++++b+=+direction+===+"ASC"+?+right.criteria+:+left.criteria;

+++++++++++if+(a+!==+b)+{
+++++++++++++++if+(a+>+b+%7C%7C+a+===+void+0)+return+1;
+++++++++++++++if+(a+<+b+%7C%7C+b+===+void+0)+return+-1;
+++++++++++}
+++++++++++return+left.index+<+right.index+?+-1+:+1;
+++++++}),+'value');
+++}

});|code-block|syntax|javascript|786258|所以你可以这样使用它：|786259|var+collection+=+new+SortedCollection([
++{+name:+"Ida",+age:+26+},
++{+name:+"Tim",+age:+5+},
++{+name:+"Rob",+age:+55+}
]);

//sort+by+"age"+asc
collection.setSortField("age",+"ASC");
collection.sort();

//sort+by+"age"+desc
collection.setSortField("age",+"DESC");
collection.sort();|786260|此解决方案不依赖于字段类型。|786261|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This can be done elegantly by overriding sortBy method. Here is an example 

<pre><code>var SortedCollection = Backbone.Collection.extend({

 initialize: function () {
 // Default sort field and direction
 this.sortField = "name";
 this.sortDirection = "ASC";
 },

 setSortField: function (field, direction) {
 this.sortField = field;
 this.sortDirection = direction;
 },

 comparator: function (m) {
 return m.get(this.sortField);
 },

 // Overriding sortBy (copied from underscore and just swapping left and right for reverse sort)
 sortBy: function (iterator, context) {
 var obj = this.models,
 direction = this.sortDirection;

 return _.pluck(_.map(obj, function (value, index, list) {
 return {
 value: value,
 index: index,
 criteria: iterator.call(context, value, index, list)
 };
 }).sort(function (left, right) {
 // swap a and b for reverse sort
 var a = direction === "ASC" ? left.criteria : right.criteria,
 b = direction === "ASC" ? right.criteria : left.criteria;

 if (a !== b) {
 if (a &gt; b || a === void 0) return 1;
 if (a &lt; b || b === void 0) return -1;
 }
 return left.index &lt; right.index ? -1 : 1;
 }), 'value');
 }

});
</code></pre>

So you can use it like this: 

<pre><code>var collection = new SortedCollection([
 { name: "Ida", age: 26 },
 { name: "Tim", age: 5 },
 { name: "Rob", age: 55 }
]);

//sort by "age" asc
collection.setSortField("age", "ASC");
collection.sort();

//sort by "age" desc
collection.setSortField("age", "DESC");
collection.sort();
</code></pre>

This solution does not depend on the field type.

blocks|key|1000557|text|//+For+numbers,+dates,+and+other+number-like+things
var+things+=+new+Backbone.Collection;
things.comparator+=+function+(a,+b)+{+return+b+-+a+};

//+For+strings
things.comparator+=+function+(a,+b)+{
++if+(a+===+b)+return+0;
++return+a+<+b+?+-1+:+1;
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1000558|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// For numbers, dates, and other number-like things
var things = new Backbone.Collection;
things.comparator = function (a, b) { return b - a };

// For strings
things.comparator = function (a, b) {
 if (a === b) return 0;
 return a &lt; b ? -1 : 1;
};
</code></pre>

blocks|key|1000589|text|对于id上的逆序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000590|comparator:+function(object)+{+return+(this.length+-+object.id)+%2B+1;+}|code-block|syntax|javascript|1000591|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For reverse order on id:

<pre><code>comparator: function(object) { return (this.length - object.id) + 1; }
</code></pre>

blocks|key|1000611|text|下面这些方法对我来说效果很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000612|comparator:+function(a,+b)+{
++//+Optional+call+if+you+want+case+insensitive
++name1+=+a.get('name').toLowerCase();
++name2+=+b.get('name').toLowerCase();

++if+name1+<+name2
++++ret+=+-1;
++else+if+name1+>+name2
++++ret+=+1;
++else
++++ret+=+0;

++if+this.sort_dir+===+"desc"
++++ret+=+-ret
++return+ret;
}

collection.sort_dir+=+"asc";
collection.sort();+//+returns+collection+in+ascending+order
collection.sort_dir+=+"desc";
collection.sort();+//+returns+collection+in+descending+order|code-block|syntax|javascript|1000613|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following worked well for me:

<pre><code>comparator: function(a, b) {
 // Optional call if you want case insensitive
 name1 = a.get('name').toLowerCase();
 name2 = b.get('name').toLowerCase();

 if name1 &lt; name2
 ret = -1;
 else if name1 &gt; name2
 ret = 1;
 else
 ret = 0;

 if this.sort_dir === "desc"
 ret = -ret
 return ret;
}

collection.sort_dir = "asc";
collection.sort(); // returns collection in ascending order
collection.sort_dir = "desc";
collection.sort(); // returns collection in descending order
</code></pre>

blocks|key|1000681|text|我有一个稍有不同的要求，因为我在一个表中显示我的模型，我希望能够按任何列(模型属性)以及升序或降序对它们进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000682|它花了相当多的时间来让所有的情况都正常工作(其中值可以是字符串、空字符串、日期、数字。然而，我认为这是相当接近的。|1000683|++++inverseString:+function(str)
++++{
++++++++return+str.split("").map(function+(letter)+{+return+String.fromCharCode(-(letter.charCodeAt(0)));+}).join("");
++++}
++++getComparisonValue:+function+(val,+desc)
++++{
++++++++var+v+=+0;
++++++++//+Is+a+string
++++++++if+(typeof+val+===+"string")
++++++++{
++++++++++++//+Is+an+empty+string,+upgrade+to+a+space+to+avoid+strange+ordering
++++++++++++if(val.length+===+0)
++++++++++++{
++++++++++++++++val+=+"+";
++++++++++++++++return+desc+?+this.inverseString(val)+:+val;
++++++++++++}++++++++++++++++

++++++++++++//+Is+a+(string)+representing+a+number
++++++++++++v+=+Number(val);
++++++++++++if+(!isNaN(v))
++++++++++++{
++++++++++++++++return+desc+?+-1+*+v+:+v;
++++++++++++}
++++++++++++//+Is+a+(string)+representing+a+date
++++++++++++v+=+Date.parse(val);
++++++++++++if+(!isNaN(v))
++++++++++++{
++++++++++++++++return+desc+?+-1+*+v+:+v;
++++++++++++}
++++++++++++//+Is+just+a+string
++++++++++++return+desc+?+this.inverseString(val)+:+val;
++++++++}
++++++++//+Not+a+string
++++++++else
++++++++{
++++++++++++return+desc+?+-1+*+val+:+val;
++++++++}
++++},|code-block|syntax|javascript|1000684|使用：|1000685|++++comparator:+function+(item)
++++{
++++++++//+Store+the+collumn+to+'sortby'+in+my+global+model
++++++++var+property+=+app.collections.global.get("sortby");

++++++++//+Store+the+direction+of+the+sorting+also+in+the+global+model
++++++++var+desc+=+app.collections.global.get("direction")+===+"DESC";

++++++++//+perform+a+comparison+based+on+property+&+direction
++++++++return+this.getComparisonValue(item.get(property),+desc);
++++},|1000686|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I had a slightly different requirement, in that I am displaying my models in a table, and I wanted to be able to sort them by any collumn (model property) and either ascending or descending.

It has taken a fair amount of mucking around to get all the cases working (where values can be strings, empty strings, dates, numbers. However I think this is pretty close.

<pre><code> inverseString: function(str)
 {
 return str.split("").map(function (letter) { return String.fromCharCode(-(letter.charCodeAt(0))); }).join("");
 }
 getComparisonValue: function (val, desc)
 {
 var v = 0;
 // Is a string
 if (typeof val === "string")
 {
 // Is an empty string, upgrade to a space to avoid strange ordering
 if(val.length === 0)
 {
 val = " ";
 return desc ? this.inverseString(val) : val;
 } 

 // Is a (string) representing a number
 v = Number(val);
 if (!isNaN(v))
 {
 return desc ? -1 * v : v;
 }
 // Is a (string) representing a date
 v = Date.parse(val);
 if (!isNaN(v))
 {
 return desc ? -1 * v : v;
 }
 // Is just a string
 return desc ? this.inverseString(val) : val;
 }
 // Not a string
 else
 {
 return desc ? -1 * val : val;
 }
 },
</code></pre>

use:

<pre><code> comparator: function (item)
 {
 // Store the collumn to 'sortby' in my global model
 var property = app.collections.global.get("sortby");

 // Store the direction of the sorting also in the global model
 var desc = app.collections.global.get("direction") === "DESC";

 // perform a comparison based on property &amp; direction
 return this.getComparisonValue(item.get(property), desc);
 },
</code></pre>

blocks|key|1000741|text|我读到一些主干比较器函数使用或模仿JavaScript+Array.prototype.sort()函数的地方。这意味着它使用1、-1或0来决定集合中每个模型的排序顺序。这会不断更新，并且集合会根据比较器保持正确的顺序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000742|在这里可以找到关于Array.prototype.sort()的信息：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort?redirectlocale=en-US&redirectslug=JavaScript%252FReference%252FGlobal_Objects%252FArray%252Fsort|offset|length|1000743|这个问题的许多答案只是在将其呈现到页面之前颠倒顺序。这并不理想。|1000744|使用上面关于Mozilla的文章作为指导，我能够使用以下代码将我的集合以相反的顺序排序，然后我们只需将集合以当前的顺序呈现到页面上，并且可以使用一个标志(reverseSortDirection)来颠倒顺序。|1000745|//Assuming+this+or+similar+will+be+in+your+Backbone.Collection.
sortKey:+'id',+//The+field+name+of+the+item+in+your+collection

reverseSortDirection:+false,

comparator:+function(a,+b)+{

++var+sampleDataA+=+a.get(this.sortKey),
++++++sampleDataB+=+b.get(this.sortKey);

++++++if+(this.reverseSortDirection)+{
++++++++if+(sampleDataA+>+sampleDataB)+{+return+-1;+}
++++++++if+(sampleDataB+>+sampleDataA)+{+return+1;+}
++++++++return+0;
++++++}+else+{
++++++++if+(sampleDataA+<+sampleDataB)+{+return+-1;+}
++++++++if+(sampleDataB+<+sampleDataA)+{+return+1;+}
++++++++return+0;
++++++}

},|code-block|syntax|javascript|1000746|除了的两个模型之外，在更改集合或模型时，比较函数会运行并更改集合的顺序。|1000747|我已经用数字和字符串测试了这种方法，它似乎很适合我。|1000748|我真的希望这个答案能有所帮助，因为我已经在这个问题上挣扎了很多次，通常最终都会使用一个变通的解决方案。|1000749|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort?redirectlocale=en-US&redirectslug=JavaScript%252FReference%252FGlobal_Objects%252FArray%252Fsort^0|0|Z|50|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

I read some where that the Backbone comparator function either uses or mimics the JavaScript Array.prototype.sort() function. This means it uses either 1, -1 or 0 to decide on the sort order of each model in the collection. This constantly updates and the collection stays in the correct order based on the comparator.

Info on Array.prototype.sort() can be found here: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort?redirectlocale=en-US&amp;redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FArray%2Fsort">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort?redirectlocale=en-US&amp;redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FArray%2Fsort</a>

Many answers on this question simply reverse the order just before rending it to the page. This is not ideal.

Using the above article on Mozilla as a guide I was able to keep my collection sorted in reverse order using the following code, then we simply render the collection to page in it's current order and we can use a flag (reverseSortDirection) for reversing the order.

<pre><code>//Assuming this or similar will be in your Backbone.Collection.
sortKey: 'id', //The field name of the item in your collection

reverseSortDirection: false,

comparator: function(a, b) {

 var sampleDataA = a.get(this.sortKey),
 sampleDataB = b.get(this.sortKey);

 if (this.reverseSortDirection) {
 if (sampleDataA &gt; sampleDataB) { return -1; }
 if (sampleDataB &gt; sampleDataA) { return 1; }
 return 0;
 } else {
 if (sampleDataA &lt; sampleDataB) { return -1; }
 if (sampleDataB &lt; sampleDataA) { return 1; }
 return 0;
 }

},
</code></pre>

Comparator except's two models, on changes to the collection or model the compartor function runs and changes the order of the collection. 

I have tested this approach with Numbers and Strings and it seems to be working perfectly for me.

I really hope this answer can help as I have struggled with this problem many times and usually end up using a work around.

blocks|key|1000788|text|对于那些只想颠倒当前顺序的人，这里有一个非常简单的解决方案。如果您有一个表，该表的列可以在两个方向上排序，那么它会很有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000789|collection.models+=+collection.models.reverse()|code-block|syntax|javascript|1000790|如果您对桌子案例(coffeescript)感兴趣，您可以将其与以下内容结合使用：|1000791|++collection.comparator+=+(model)+->
++++model.get(sortByType)

++collection.sort()

++if+reverseOrder
++++collection.models+=+collection.models.reverse()|1000792|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a really simple solution, for those who simply want to flip the current order. It is useful if you have a table whose columns can be ordered in two directions.

<pre><code>collection.models = collection.models.reverse()
</code></pre>

You can combine it with something like this if you are interested in the table case (coffeescript) :

<pre><code> collection.comparator = (model) -&gt;
 model.get(sortByType)

 collection.sort()

 if reverseOrder
 collection.models = collection.models.reverse()
</code></pre>

blocks|key|1000808|text|我只是重写了排序函数，以便在完成时反转模型数组。此外，我推迟了触发“排序”事件，直到反向操作完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000809|++++sort+:+function(options){

++++++++options+=+options+%7C%7C+{};

++++++++Backbone.Collection.prototype.sort.call(this,+{silent:true});
++++++++this.models.reverse();

++++++++if+(!options.silent){
++++++++++++this.trigger('sort',+this,+options);
++++++++}

++++++++return+this;
++++},|code-block|syntax|javascript|1000810|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I just overrode the sort function to reverse the models array upon completion. Also I held off triggering the 'sort' event until after the reverse has been completed.

<pre><code> sort : function(options){

 options = options || {};

 Backbone.Collection.prototype.sort.call(this, {silent:true});
 this.models.reverse();

 if (!options.silent){
 this.trigger('sort', this, options);
 }

 return this;
 },
</code></pre>

blocks|key|786560|text|最近遇到了这个问题，决定添加一个rsort方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|786561|++++Collection+=+Backbone.Collection.extend({
++++++++++++comparator:function(a,+b){
++++++++++++++++return+a>b;
++++++++++++},
++++++++++++rsort:function(){
++++++++++++++++var+comparator+=+this.comparator;

++++++++++++++++this.comparator+=+function(){
++++++++++++++++++++return+-comparator.apply(this,+arguments);
++++++++++++++++}
++++++++++++++++this.sort();

++++++++++++++++this.comparator+=+comparator;

++++++++++++}
++++});|code-block|syntax|javascript|786562|希望有人会觉得这很有用|786563|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Recently ran into this issue and just decided to add an rsort method.

<pre><code> Collection = Backbone.Collection.extend({
 comparator:function(a, b){
 return a&gt;b;
 },
 rsort:function(){
 var comparator = this.comparator;

 this.comparator = function(){
 return -comparator.apply(this, arguments);
 }
 this.sort();

 this.comparator = comparator;

 }
 });
</code></pre>

Hopefully someone will find this useful

blocks|key|1000903|text|下面是使用UnderscoreJS对集合的模型进行反向排序的一种快速而简单的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1000904|​|1000905|+var+reverseCollection+=+_.sortBy(this.models,+function(model)+{
+++return+self.indexOf(model)+*+-1;
+});|code-block|syntax|javascript|1000906|1000907|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

Here's a quick and easy way to reverse-sort a collection's models using UnderscoreJS

<div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code> var reverseCollection = _.sortBy(this.models, function(model) {
 return self.indexOf(model) * -1;
 });</code></pre>
</div>
</div>

With <a href="http://documentcloud.github.com/backbone/" rel="nofollow noreferrer">Backbone.js</a> I've got a collection set up with a comparator function. It's nicely sorting the models, but I'd like to reverse the order. 

How can I sort the models in descending order rather than ascending?

Reverse sort order with Backbone.js

使用，我得到了一个带有比较器函数的集合。它很好地对模型进行了排序，但我想颠倒顺序。如何按降序而不是升序对模型进行排序？

问使用Backbone.js颠倒排序顺序
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Backbone.js颠倒排序顺序EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用Backbone.js颠倒排序顺序
EN