blocks|key|2753867|text|要对其进行排序，需要创建一个带有两个参数的比较器函数。然后使用该比较器函数调用排序函数，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2753868|//+a+and+b+are+object+elements+of+your+array
function+mycomparator(a,b)+{
++return+parseInt(a.price,+10)+-+parseInt(b.price,+10);
}
homes.sort(mycomparator);|code-block|syntax|javascript|2753869|如果要升序排序，请切换减号两边的表达式。|2753870|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|$]]

<p>To sort it you need to create a comparator function taking two arguments. Then call the sort function with that comparator function as follows:</p>

<pre class="lang-js prettyprint-override"><code>// a and b are object elements of your array
function mycomparator(a,b) {
  return parseInt(a.price, 10) - parseInt(b.price, 10);
}
homes.sort(mycomparator);
</code></pre>

<p>If you want to sort ascending switch the expressions on each side of the minus sign.</p>


blocks|key|56072|text|按价格升序对房屋进行排序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56073|homes.sort(function(a,+b)+{
++++return+parseFloat(a.price)+-+parseFloat(b.price);
});|code-block|syntax|javascript|56074|或在ES6版本之后：|56075|homes.sort((a,+b)+=>+parseFloat(a.price)+-+parseFloat(b.price));|56076|一些文档可以在here上找到。|offset|length|56077|对于降序，您可以使用|56078|homes.sort((a,+b)+=>+parseFloat(b.price)+-+parseFloat(a.price));|56079|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/sort^0|0|0|0|0|7|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

<p>Sort homes by price in ascending order:</p>

<pre class="lang-js prettyprint-override"><code>homes.sort(function(a, b) {
    return parseFloat(a.price) - parseFloat(b.price);
});
</code></pre>

<p>Or after ES6 version:</p>

<pre><code>homes.sort((a, b) =&gt; parseFloat(a.price) - parseFloat(b.price));
</code></pre>

<p>Some documentation can be found <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/sort" rel="noreferrer">here</a>.</p>

<p>For descending order, you may use </p>

<pre><code>homes.sort((a, b) =&gt; parseFloat(b.price) - parseFloat(a.price));
</code></pre>


blocks|key|2753913|text|您想在Javascript中对其进行排序，对吗？你想要的是sort()+function。在这种情况下，您需要编写一个比较器函数并将其传递给sort()，因此如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2753914|function+comparator(a,+b)+{
++++return+parseInt(a["price"],+10)+-+parseInt(b["price"],+10);
}

var+json+=+{+"homes":+[+/*+your+previous+data+*/+]+};
console.log(json["homes"].sort(comparator));|code-block|syntax|javascript|2753915|您的比较器获取数组中的每个嵌套哈希中的一个，并通过检查“价格”字段来决定哪个哈希值更高。|2753916|entityMap|0|LINK|mutability|MUTABLE|url|http://www.javascriptkit.com/javatutors/arraysort.shtml^0|T|6|1Y|6|T|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

<p>You want to sort it in Javascript, right?  What you want is the <a href="http://www.javascriptkit.com/javatutors/arraysort.shtml" rel="noreferrer"><code>sort()</code> function</a>.  In this case you need to write a comparator function and pass it to <code>sort()</code>, so something like this:</p>

<pre><code>function comparator(a, b) {
    return parseInt(a["price"], 10) - parseInt(b["price"], 10);
}

var json = { "homes": [ /* your previous data */ ] };
console.log(json["homes"].sort(comparator));
</code></pre>

<p>Your comparator takes one of each of the nested hashes inside the array and decides which one is higher by checking the "price" field.</p>


blocks|key|56104|text|您可以将JavaScript+sort方法与回调函数一起使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|56105|function+compareASC(homeA,+homeB)
{
++++return+parseFloat(homeA.price)+-+parseFloat(homeB.price);
}

function+compareDESC(homeA,+homeB)
{
++++return+parseFloat(homeB.price)+-+parseFloat(homeA.price);
}

//+Sort+ASC
homes.sort(compareASC);

//+Sort+DESC
homes.sort(compareDESC);|code-block|syntax|javascript|56106|entityMap^0|F|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>You can use the JavaScript <code>sort</code> method with a callback function:</p>

<pre><code>function compareASC(homeA, homeB)
{
    return parseFloat(homeA.price) - parseFloat(homeB.price);
}

function compareDESC(homeA, homeB)
{
    return parseFloat(homeB.price) - parseFloat(homeA.price);
}

// Sort ASC
homes.sort(compareASC);

// Sort DESC
homes.sort(compareDESC);
</code></pre>


blocks|key|2753948|text|这是一个更灵活的版本，它允许您创建可重用的排序函数，并按任何字段排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2753949|​|2753950|const+sort_by+=+(field,+reverse,+primer)+=>+{

++const+key+=+primer+?
++++function(x)+{
++++++return+primer(x[field])
++++}+:
++++function(x)+{
++++++return+x[field]
++++};

++reverse+=+!reverse+?+1+:+-1;

++return+function(a,+b)+{
++++return+a+=+key(a),+b+=+key(b),+reverse+*+((a+>+b)+-+(b+>+a));
++}
}


//Now+you+can+sort+by+any+field+at+will...

const+homes=[{h_id:"3",city:"Dallas",state:"TX",zip:"75201",price:"162500"},{h_id:"4",city:"Bevery+Hills",state:"CA",zip:"90210",price:"319250"},{h_id:"5",city:"New+York",state:"NY",zip:"00010",price:"962500"}];

//+Sort+by+price+high+to+low
console.log(homes.sort(sort_by('price',+true,+parseInt)));

//+Sort+by+city,+case-insensitive,+A-Z
console.log(homes.sort(sort_by('city',+false,+(a)+=>++a.toUpperCase()
)));|code-block|syntax|javascript|2753951|2753952|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|$]]

<p>Here's a more flexible version, which allows you to create 
reusable sort functions, and sort by any field.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const sort_by = (field, reverse, primer) =&gt; {

  const key = primer ?
    function(x) {
      return primer(x[field])
    } :
    function(x) {
      return x[field]
    };

  reverse = !reverse ? 1 : -1;

  return function(a, b) {
    return a = key(a), b = key(b), reverse * ((a &gt; b) - (b &gt; a));
  }
}


//Now you can sort by any field at will...

const homes=[{h_id:"3",city:"Dallas",state:"TX",zip:"75201",price:"162500"},{h_id:"4",city:"Bevery Hills",state:"CA",zip:"90210",price:"319250"},{h_id:"5",city:"New York",state:"NY",zip:"00010",price:"962500"}];

// Sort by price high to low
console.log(homes.sort(sort_by('price', true, parseInt)));

// Sort by city, case-insensitive, A-Z
console.log(homes.sort(sort_by('city', false, (a) =&gt;  a.toUpperCase()
)));</code></pre>
</div>
</div>
</p>


blocks|key|2542505|text|用于字符串排序，以防有人需要它，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2542506|​|2542507|const+dataArr+=+{

++"hello":+[{
++++"id":+114,
++++"keyword":+"zzzzzz",
++++"region":+"Sri+Lanka",
++++"supportGroup":+"administrators",
++++"category":+"Category2"
++},+{
++++"id":+115,
++++"keyword":+"aaaaa",
++++"region":+"Japan",
++++"supportGroup":+"developers",
++++"category":+"Category2"
++}]

};
const+sortArray+=+dataArr['hello'];

console.log(sortArray.sort((a,+b)+=>+{
++if+(a.region+<+b.region)
++++return+-1;
++if+(a.region+>+b.region)
++++return+1;
++return+0;
}));|code-block|syntax|javascript|2542508|2542509|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|$]]

<p>for string sorting in case some one needs it,</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const dataArr = {

  "hello": [{
    "id": 114,
    "keyword": "zzzzzz",
    "region": "Sri Lanka",
    "supportGroup": "administrators",
    "category": "Category2"
  }, {
    "id": 115,
    "keyword": "aaaaa",
    "region": "Japan",
    "supportGroup": "developers",
    "category": "Category2"
  }]

};
const sortArray = dataArr['hello'];

console.log(sortArray.sort((a, b) =&gt; {
  if (a.region &lt; b.region)
    return -1;
  if (a.region &gt; b.region)
    return 1;
  return 0;
}));</code></pre>
</div>
</div>
</p>


blocks|key|2542545|text|要对数组进行排序，必须定义一个比较器函数。此函数在您所需的排序模式或顺序(即升序或降序)上总是不同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2542546|让我们创建一些函数，对包含对象、字符串或数值的数组进行升序或降序排序。|2542547|function+sorterAscending(a,b)+{
++++return+a-b;
}

function+sorterDescending(a,b)+{
++++return+b-a;
}

function+sorterPriceAsc(a,b)+{
++++return+parseInt(a['price'])+-+parseInt(b['price']);
}

function+sorterPriceDes(a,b)+{
++++return+parseInt(b['price'])+-+parseInt(b['price']);
}|code-block|syntax|javascript|2542548|排序编号(按字母和升序)：|offset|length|style|BOLD|2542549|var+fruits+=+["Banana",+"Orange",+"Apple",+"Mango"];
fruits.sort();|2542550|排序编号(按字母和降序)：|2542551|var+fruits+=+["Banana",+"Orange",+"Apple",+"Mango"];
fruits.sort();
fruits.reverse();|2542552|排序号(数字和升序)：|2542553|var+points+=+[40,100,1,5,25,10];
points.sort(sorterAscending());|2542554|排序号(数字和降序)：|2542555|var+points+=+[40,100,1,5,25,10];
points.sort(sorterDescending());|2542556|如上所述，对具有所需键的数组使用sorterPriceAsc和sorterPriceDes方法。|2542557|homes.sort(sorterPriceAsc())+or+homes.sort(sorterPriceDes())|2542558|entityMap^0|0|0|0|0|D|0|0|0|D|0|0|0|B|0|0|0|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@$K|1C|L|1D|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1F|8|@$K|1G|L|1H|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1J|8|@$K|1K|L|1L|M|N]]|9|@]|A|$]]|$1|W|3|X|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1N|8|@$K|1O|L|1P|M|N]]|9|@]|A|$]]|$1|10|3|11|5|F|7|1Q|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|1R|8|@]|9|@]|A|$]]|$1|14|3|15|5|F|7|1S|8|@]|9|@]|A|$G|H]]|$1|16|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|17|$]]

<p>For sorting a array you must define a comparator function. This function always be different on your desired sorting pattern or order(i.e. ascending or descending).</p>

<p>Let create some functions that sort an array ascending or descending and that contains object or string or numeric values.</p>

<pre><code>function sorterAscending(a,b) {
    return a-b;
}

function sorterDescending(a,b) {
    return b-a;
}

function sorterPriceAsc(a,b) {
    return parseInt(a['price']) - parseInt(b['price']);
}

function sorterPriceDes(a,b) {
    return parseInt(b['price']) - parseInt(b['price']);
}
</code></pre>

<p><strong>Sort numbers (alphabetically and ascending):</strong></p>

<pre><code>var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
</code></pre>

<p><strong>Sort numbers (alphabetically and descending):</strong></p>

<pre><code>var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();
</code></pre>

<p><strong>Sort numbers (numerically and ascending):</strong></p>

<pre><code>var points = [40,100,1,5,25,10];
points.sort(sorterAscending());
</code></pre>

<p><strong>Sort numbers (numerically and descending):</strong></p>

<pre><code>var points = [40,100,1,5,25,10];
points.sort(sorterDescending());
</code></pre>

<p>As above use sorterPriceAsc and sorterPriceDes method with your array with desired key.</p>

<pre><code>homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())
</code></pre>


blocks|key|55170|text|下面是上面所有答案的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55171|小提琴验证：http://jsfiddle.net/bobberino/4qqk3/|offset|length|55172|var+sortOn+=+function+(arr,+prop,+reverse,+numeric)+{

++++//+Ensure+there's+a+property
++++if+(!prop+%7C%7C+!arr)+{
++++++++return+arr
++++}

++++//+Set+up+sort+function
++++var+sort_by+=+function+(field,+rev,+primer)+{

++++++++//+Return+the+required+a,b+function
++++++++return+function+(a,+b)+{

++++++++++++//+Reset+a,+b+to+the+field
++++++++++++a+=+primer(a[field]),+b+=+primer(b[field]);

++++++++++++//+Do+actual+sorting,+reverse+as+needed
++++++++++++return+((a+<+b)+?+-1+:+((a+>+b)+?+1+:+0))+*+(rev+?+-1+:+1);
++++++++}

++++}

++++//+Distinguish+between+numeric+and+string+to+prevent+100's+from+coming+before+smaller
++++//+e.g.
++++//+1
++++//+20
++++//+3
++++//+4000
++++//+50

++++if+(numeric)+{

++++++++//+Do+sort+"in+place"+with+sort_by+function
++++++++arr.sort(sort_by(prop,+reverse,+function+(a)+{

++++++++++++//+-+Force+value+to+a+string.
++++++++++++//+-+Replace+any+non+numeric+characters.
++++++++++++//+-+Parse+as+float+to+allow+0.02+values.
++++++++++++return+parseFloat(String(a).replace(/[%5E0-9.-]%2B/g,+''));

++++++++}));
++++}+else+{

++++++++//+Do+sort+"in+place"+with+sort_by+function
++++++++arr.sort(sort_by(prop,+reverse,+function+(a)+{

++++++++++++//+-+Force+value+to+string.
++++++++++++return+String(a).toUpperCase();

++++++++}));
++++}


}|code-block|syntax|javascript|55173|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/bobberino/4qqk3/^0|0|6|10|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@$D|U|E|V|1|W]]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>Here is a culmination of all answers above. </p>

<p>Fiddle validation: <a href="http://jsfiddle.net/bobberino/4qqk3/" rel="noreferrer">http://jsfiddle.net/bobberino/4qqk3/</a></p>

<pre><code>var sortOn = function (arr, prop, reverse, numeric) {

    // Ensure there's a property
    if (!prop || !arr) {
        return arr
    }

    // Set up sort function
    var sort_by = function (field, rev, primer) {

        // Return the required a,b function
        return function (a, b) {

            // Reset a, b to the field
            a = primer(a[field]), b = primer(b[field]);

            // Do actual sorting, reverse as needed
            return ((a &lt; b) ? -1 : ((a &gt; b) ? 1 : 0)) * (rev ? -1 : 1);
        }

    }

    // Distinguish between numeric and string to prevent 100's from coming before smaller
    // e.g.
    // 1
    // 20
    // 3
    // 4000
    // 50

    if (numeric) {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to a string.
            // - Replace any non numeric characters.
            // - Parse as float to allow 0.02 values.
            return parseFloat(String(a).replace(/[^0-9.-]+/g, ''));

        }));
    } else {

        // Do sort "in place" with sort_by function
        arr.sort(sort_by(prop, reverse, function (a) {

            // - Force value to string.
            return String(a).toUpperCase();

        }));
    }


}
</code></pre>


blocks|key|2542577|text|我还使用了某种评分和多个字段排序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2542578|arr+=+[
++++{type:'C',+note:834},
++++{type:'D',+note:732},
++++{type:'D',+note:008},
++++{type:'F',+note:474},
++++{type:'P',+note:283},
++++{type:'P',+note:165},
++++{type:'X',+note:173},
++++{type:'Z',+note:239},
];

arr.sort(function(a,b){++++++++
++++var+_a+=+((a.type==='C')?'0':(a.type==='P')?'1':'2');
++++_a+%2B=+(a.type.localeCompare(b.type)===-1)?'0':'1';
++++_a+%2B=+(a.note>b.note)?'1':'0';
++++var+_b+=+((b.type==='C')?'0':(b.type==='P')?'1':'2');
++++_b+%2B=+(b.type.localeCompare(a.type)===-1)?'0':'1';
++++_b+%2B=+(b.note>a.note)?'1':'0';
++++return+parseInt(_a)+-+parseInt(_b);
});|code-block|syntax|javascript|2542579|结果|2542580|[
++++{"type":"C","note":834},
++++{"type":"P","note":165},
++++{"type":"P","note":283},
++++{"type":"D","note":8},
++++{"type":"D","note":732},
++++{"type":"F","note":474},
++++{"type":"X","note":173},
++++{"type":"Z","note":239}
]|2542581|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|$]]

<p>I also worked with some kind of rating and multiple fields sort:</p>

<pre><code>arr = [
    {type:'C', note:834},
    {type:'D', note:732},
    {type:'D', note:008},
    {type:'F', note:474},
    {type:'P', note:283},
    {type:'P', note:165},
    {type:'X', note:173},
    {type:'Z', note:239},
];

arr.sort(function(a,b){        
    var _a = ((a.type==='C')?'0':(a.type==='P')?'1':'2');
    _a += (a.type.localeCompare(b.type)===-1)?'0':'1';
    _a += (a.note&gt;b.note)?'1':'0';
    var _b = ((b.type==='C')?'0':(b.type==='P')?'1':'2');
    _b += (b.type.localeCompare(a.type)===-1)?'0':'1';
    _b += (b.note&gt;a.note)?'1':'0';
    return parseInt(_a) - parseInt(_b);
});
</code></pre>

<p>Result</p>

<pre><code>[
    {"type":"C","note":834},
    {"type":"P","note":165},
    {"type":"P","note":283},
    {"type":"D","note":8},
    {"type":"D","note":732},
    {"type":"F","note":474},
    {"type":"X","note":173},
    {"type":"Z","note":239}
]
</code></pre>


blocks|key|2542591|text|我最近写了一个通用函数来管理它，如果你想使用它的话。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2542592|/**
+*+Sorts+an+object+into+an+order
+*
+*+@require+jQuery
+*
+*+@param+object+Our+JSON+object+to+sort
+*+@param+type+Only+alphabetical+at+the+moment
+*+@param+identifier+The+array+or+object+key+to+sort+by
+*+@param+order+Ascending+or+Descending
+*
+*+@returns+Array
+*/
function+sortItems(object,+type,+identifier,+order){

++++var+returnedArray+=+[];
++++var+emptiesArray+=+[];+//+An+array+for+all+of+our+empty+cans

++++//+Convert+the+given+object+to+an+array
++++$.each(object,+function(key,+object){

++++++++//+Store+all+of+our+empty+cans+in+their+own+array
++++++++//+Store+all+other+objects+in+our+returned+array
++++++++object[identifier]+==+null+?+emptiesArray.push(object)+:+returnedArray.push(object);

++++});

++++//+Sort+the+array+based+on+the+type+given
++++switch(type){

++++++++case+'alphabetical':

++++++++++++returnedArray.sort(function(a,+b){

++++++++++++++++return(a[identifier]+==+b[identifier])+?+0+:+(

++++++++++++++++++++//+Sort+ascending+or+descending+based+on+order+given
++++++++++++++++++++order+==+'asc'+?+a[identifier]+>+b[identifier]+:+a[identifier]+<+b[identifier]

++++++++++++++++)+?+1+:+-1;

++++++++++++});

++++++++++++break;

++++++++default:

++++}

++++//+Return+our+sorted+array+along+with+the+empties+at+the+bottom+depending+on+sort+order
++++return+order+==+'asc'+?+returnedArray.concat(emptiesArray)+:+emptiesArray.concat(returnedArray);

}|code-block|syntax|javascript|2542593|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|$]]

<p>I recently wrote a universal function to manage this for you if you want to use it.</p>

<pre><code>/**
 * Sorts an object into an order
 *
 * @require jQuery
 *
 * @param object Our JSON object to sort
 * @param type Only alphabetical at the moment
 * @param identifier The array or object key to sort by
 * @param order Ascending or Descending
 *
 * @returns Array
 */
function sortItems(object, type, identifier, order){

    var returnedArray = [];
    var emptiesArray = []; // An array for all of our empty cans

    // Convert the given object to an array
    $.each(object, function(key, object){

        // Store all of our empty cans in their own array
        // Store all other objects in our returned array
        object[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object);

    });

    // Sort the array based on the type given
    switch(type){

        case 'alphabetical':

            returnedArray.sort(function(a, b){

                return(a[identifier] == b[identifier]) ? 0 : (

                    // Sort ascending or descending based on order given
                    order == 'asc' ? a[identifier] &gt; b[identifier] : a[identifier] &lt; b[identifier]

                ) ? 1 : -1;

            });

            break;

        default:

    }

    // Return our sorted array along with the empties at the bottom depending on sort order
    return order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray);

}
</code></pre>


blocks|key|2754084|text|我推荐GitHub:+Array+sortBy+-使用Schwartzian+transform的sortBy方法的最佳实现|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2754085|但现在我们将尝试这种方法Gist:+sortBy-old.js。|2754086|让我们创建一个对数组进行排序的方法，该方法能够按某些属性排列对象。|2754087|创建排序函数|2754088|var+sortBy+=+(function+()+{
++var+toString+=+Object.prototype.toString,
++++++//+default+parser+function
++++++parse+=+function+(x)+{+return+x;+},
++++++//+gets+the+item+to+be+sorted
++++++getItem+=+function+(x)+{
++++++++var+isObject+=+x+!=+null+&&+typeof+x+===+"object";
++++++++var+isProp+=+isObject+&&+this.prop+in+x;
++++++++return+this.parser(isProp+?+x[this.prop]+:+x);
++++++};
++++++
++/**
+++*+Sorts+an+array+of+elements.
+++*
+++*+@param++{Array}+array:+the+collection+to+sort
+++*+@param++{Object}+cfg:+the+configuration+options
+++*+@property+{String}+++cfg.prop:+property+name+(if+it+is+an+Array+of+objects)
+++*+@property+{Boolean}++cfg.desc:+determines+whether+the+sort+is+descending
+++*+@property+{Function}+cfg.parser:+function+to+parse+the+items+to+expected+type
+++*+@return+{Array}
+++*/
++return+function+sortby+(array,+cfg)+{
++++if+(!(array+instanceof+Array+&&+array.length))+return+[];
++++if+(toString.call(cfg)+!==+"[object+Object]")+cfg+=+{};
++++if+(typeof+cfg.parser+!==+"function")+cfg.parser+=+parse;
++++cfg.desc+=+!!cfg.desc+?+-1+:+1;
++++return+array.sort(function+(a,+b)+{
++++++a+=+getItem.call(cfg,+a);
++++++b+=+getItem.call(cfg,+b);
++++++return+cfg.desc+*+(a+<+b+?+-1+:+%2B(a+>+b));
++++});
++};
++
}());|code-block|syntax|javascript|2754089|设置未排序的数据|2754090|var+data+=+[
++{date:+"2011-11-14T16:30:43Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"tab"},
++{date:+"2011-11-14T17:22:59Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"Tab"},
++{date:+"2011-11-14T16:28:54Z",+quantity:+1,+total:+300,+tip:+200,+type:+"visa"},
++{date:+"2011-11-14T16:53:41Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"tab"},
++{date:+"2011-11-14T16:48:46Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"tab"},
++{date:+"2011-11-14T17:25:45Z",+quantity:+2,+total:+200,+tip:+0,+++type:+"cash"},
++{date:+"2011-11-31T17:29:52Z",+quantity:+1,+total:+200,+tip:+100,+type:+"Visa"},
++{date:+"2011-11-14T16:58:03Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"tab"},
++{date:+"2011-11-14T16:20:19Z",+quantity:+2,+total:+190,+tip:+100,+type:+"tab"},
++{date:+"2011-11-01T16:17:54Z",+quantity:+2,+total:+190,+tip:+100,+type:+"tab"},
++{date:+"2011-11-14T17:07:21Z",+quantity:+2,+total:+90,++tip:+0,+++type:+"tab"},
++{date:+"2011-11-14T16:54:06Z",+quantity:+1,+total:+100,+tip:+0,+++type:+"Cash"}
];|2754091|使用它|2754092|Arrange+the+array，by+"date"+as+String|2754093|//+sort+by+@date+(ascending)
sortBy(data,+{+prop:+"date"+});

//+expected:+first+element
//+{+date:+"2011-11-01T16:17:54Z",+quantity:+2,+total:+190,+tip:+100,+type:+"tab"+}

//+expected:+last+element
//+{+date:+"2011-11-31T17:29:52Z",+quantity:+1,+total:+200,+tip:+100,+type:+"Visa"}|2754094|如果您想忽略区分大小写，请设置parser回调：|2754095|//+sort+by+@type+(ascending)+IGNORING+case-sensitive
sortBy(data,+{
++++prop:+"type",
++++parser:+(t)+=>+t.toUpperCase()
});

//+expected:+first+element
//+{+date:+"2011-11-14T16:54:06Z",+quantity:+1,+total:+100,+tip:+0,+type:+"Cash"+}

//+expected:+last+element
//+{+date:+"2011-11-31T17:29:52Z",+quantity:+1,+total:+200,+tip:+100,+type:+"Visa"+}|2754096|如果要将"date"字段转换为Date类型：|2754097|//+sort+by+@date+(descending)+AS+Date+object
sortBy(data,+{
++++prop:+"date",
++++desc:+true,
++++parser:+(d)+=>+new+Date(d)
});

//+expected:+first+element
//+{+date:+"2011-11-31T17:29:52Z",+quantity:+1,+total:+200,+tip:+100,+type:+"Visa"}

//+expected:+last+element
//+{+date:+"2011-11-01T16:17:54Z",+quantity:+2,+total:+190,+tip:+100,+type:+"tab"+}|2754098|在这里您可以使用以下代码：jsbin.com/lesebi|2754099|多亏了@Ozesh的反馈，修复了与falsy值的属性相关的问题。|BOLD|2754100|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/jherax/array-sort-by|1|https://en.wikipedia.org/wiki/Schwartzian_transform|2|https://gist.github.com/jherax/8781f45dcd068a9e3e37|3|http://jsbin.com/lesebi/edit?js,console^0|1D|6|3|K|0|R|L|1|0|C|J|2|0|0|0|0|0|0|0|L|6|V|6|0|0|F|6|0|0|4|6|F|4|0|0|D|G|3|0|3|6|H|5|0^^$0|@$1|2|3|4|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@$9|1U|A|1V|1|1W]|$9|1X|A|1Y|1|1Z]]|E|$]]|$1|F|3|G|5|6|7|20|8|@]|D|@$9|21|A|22|1|23]]|E|$]]|$1|H|3|I|5|6|7|24|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|25|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|26|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|27|8|@]|D|@]|E|$]]|$1|S|3|T|5|N|7|28|8|@]|D|@]|E|$O|P]]|$1|U|3|V|5|6|7|29|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2A|8|@$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|N|7|2F|8|@]|D|@]|E|$O|P]]|$1|10|3|11|5|6|7|2G|8|@$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|12|3|13|5|N|7|2J|8|@]|D|@]|E|$O|P]]|$1|14|3|15|5|6|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|16|3|17|5|N|7|2P|8|@]|D|@]|E|$O|P]]|$1|18|3|19|5|6|7|2Q|8|@]|D|@$9|2R|A|2S|1|2T]]|E|$]]|$1|1A|3|1B|5|6|7|2U|8|@$9|2V|A|2W|B|1C]|$9|2X|A|2Y|B|1C]]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2Z|8|@]|D|@]|E|$]]]|1E|$1F|$5|1G|1H|1I|E|$1J|1K]]|1L|$5|1G|1H|1I|E|$1J|1M]]|1N|$5|1G|1H|1I|E|$1J|1O]]|1P|$5|1G|1H|1I|E|$1J|1Q]]]]

<p>I recommend <a href="https://github.com/jherax/array-sort-by" rel="noreferrer">GitHub: Array sortBy</a> - a best implementation of <code>sortBy</code> method which uses the <a href="https://en.wikipedia.org/wiki/Schwartzian_transform" rel="noreferrer">Schwartzian transform</a></p>
<p>But for now we are going to try this approach <a href="https://gist.github.com/jherax/8781f45dcd068a9e3e37" rel="noreferrer">Gist: sortBy-old.js</a>.<br/>
Let's create a method to sort arrays being able to arrange objects by some property.</p>
<h2>Creating the sorting function</h2>

<pre class="lang-js prettyprint-override"><code>var sortBy = (function () {
  var toString = Object.prototype.toString,
      // default parser function
      parse = function (x) { return x; },
      // gets the item to be sorted
      getItem = function (x) {
        var isObject = x != null &amp;&amp; typeof x === &quot;object&quot;;
        var isProp = isObject &amp;&amp; this.prop in x;
        return this.parser(isProp ? x[this.prop] : x);
      };
      
  /**
   * Sorts an array of elements.
   *
   * @param  {Array} array: the collection to sort
   * @param  {Object} cfg: the configuration options
   * @property {String}   cfg.prop: property name (if it is an Array of objects)
   * @property {Boolean}  cfg.desc: determines whether the sort is descending
   * @property {Function} cfg.parser: function to parse the items to expected type
   * @return {Array}
   */
  return function sortby (array, cfg) {
    if (!(array instanceof Array &amp;&amp; array.length)) return [];
    if (toString.call(cfg) !== &quot;[object Object]&quot;) cfg = {};
    if (typeof cfg.parser !== &quot;function&quot;) cfg.parser = parse;
    cfg.desc = !!cfg.desc ? -1 : 1;
    return array.sort(function (a, b) {
      a = getItem.call(cfg, a);
      b = getItem.call(cfg, b);
      return cfg.desc * (a &lt; b ? -1 : +(a &gt; b));
    });
  };
  
}());
</code></pre>
<h2>Setting unsorted data</h2>
<pre class="lang-js prettyprint-override"><code>var data = [
  {date: &quot;2011-11-14T16:30:43Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;tab&quot;},
  {date: &quot;2011-11-14T17:22:59Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;Tab&quot;},
  {date: &quot;2011-11-14T16:28:54Z&quot;, quantity: 1, total: 300, tip: 200, type: &quot;visa&quot;},
  {date: &quot;2011-11-14T16:53:41Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;tab&quot;},
  {date: &quot;2011-11-14T16:48:46Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;tab&quot;},
  {date: &quot;2011-11-14T17:25:45Z&quot;, quantity: 2, total: 200, tip: 0,   type: &quot;cash&quot;},
  {date: &quot;2011-11-31T17:29:52Z&quot;, quantity: 1, total: 200, tip: 100, type: &quot;Visa&quot;},
  {date: &quot;2011-11-14T16:58:03Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;tab&quot;},
  {date: &quot;2011-11-14T16:20:19Z&quot;, quantity: 2, total: 190, tip: 100, type: &quot;tab&quot;},
  {date: &quot;2011-11-01T16:17:54Z&quot;, quantity: 2, total: 190, tip: 100, type: &quot;tab&quot;},
  {date: &quot;2011-11-14T17:07:21Z&quot;, quantity: 2, total: 90,  tip: 0,   type: &quot;tab&quot;},
  {date: &quot;2011-11-14T16:54:06Z&quot;, quantity: 1, total: 100, tip: 0,   type: &quot;Cash&quot;}
];
</code></pre>
<h2>Using it</h2>
<p>Arrange the array, by <code>&quot;date&quot;</code> as <code>String</code></p>
<pre class="lang-js prettyprint-override"><code>// sort by @date (ascending)
sortBy(data, { prop: &quot;date&quot; });

// expected: first element
// { date: &quot;2011-11-01T16:17:54Z&quot;, quantity: 2, total: 190, tip: 100, type: &quot;tab&quot; }

// expected: last element
// { date: &quot;2011-11-31T17:29:52Z&quot;, quantity: 1, total: 200, tip: 100, type: &quot;Visa&quot;}
</code></pre>
<p>If you want to ignore case sensitive, set the <code>parser</code> callback:</p>
<pre class="lang-js prettyprint-override"><code>// sort by @type (ascending) IGNORING case-sensitive
sortBy(data, {
    prop: &quot;type&quot;,
    parser: (t) =&gt; t.toUpperCase()
});

// expected: first element
// { date: &quot;2011-11-14T16:54:06Z&quot;, quantity: 1, total: 100, tip: 0, type: &quot;Cash&quot; }

// expected: last element
// { date: &quot;2011-11-31T17:29:52Z&quot;, quantity: 1, total: 200, tip: 100, type: &quot;Visa&quot; }
</code></pre>
<p>If you want to convert the <code>&quot;date&quot;</code> field as <code>Date</code> type:</p>
<pre class="lang-js prettyprint-override"><code>// sort by @date (descending) AS Date object
sortBy(data, {
    prop: &quot;date&quot;,
    desc: true,
    parser: (d) =&gt; new Date(d)
});

// expected: first element
// { date: &quot;2011-11-31T17:29:52Z&quot;, quantity: 1, total: 200, tip: 100, type: &quot;Visa&quot;}

// expected: last element
// { date: &quot;2011-11-01T16:17:54Z&quot;, quantity: 2, total: 190, tip: 100, type: &quot;tab&quot; }
</code></pre>
<p>Here you can play with the code:
<a href="http://jsbin.com/lesebi/edit?js,console" rel="noreferrer">jsbin.com/lesebi</a></p>
<p>Thanks to <strong>@Ozesh</strong> by his feedback, the issue related to properties with <em><strong>falsy</strong></em> values was fixed.</p>


blocks|key|56194|text|homes.sort(function(a,+b){
++var+nameA=a.prices.toLowerCase(),+nameB=b.prices.toLowerCase()
++if+(nameA+<+nameB)+//sort+string+ascending
++++return+-1+
++if+(nameA+>+nameB)
++++return+1
++return+0+//default+return+value+(no+sorting)
})|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|56195|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>homes.sort(function(a, b){
  var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase()
  if (nameA &lt; nameB) //sort string ascending
    return -1 
  if (nameA &gt; nameB)
    return 1
  return 0 //default return value (no sorting)
})
</code></pre>


blocks|key|2754119|text|如果您使用Underscore.js，请尝试sortBy：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2754120|//+price+is+of+an+integer+type
_.sortBy(homes,+"price");+

//+price+is+of+a+string+type
_.sortBy(homes,+function(home)+{return+parseInt(home.price);});+|code-block|syntax|javascript|2754121|entityMap|0|LINK|mutability|MUTABLE|url|http://underscorejs.org/^0|5|D|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>If you use <a href="http://underscorejs.org/" rel="nofollow">Underscore.js</a>, try sortBy:</p>

<pre><code>// price is of an integer type
_.sortBy(homes, "price"); 

// price is of a string type
_.sortBy(homes, function(home) {return parseInt(home.price);}); 
</code></pre>


blocks|key|56222|text|虽然只对单个数组进行排序有点夸张，但这个原型函数允许使用dot语法按任何键以升序或降序排序，包括嵌套的键。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|56223|(function(){
++++var+keyPaths+=+[];

++++var+saveKeyPath+=+function(path)+{
++++++++keyPaths.push({
++++++++++++sign:+(path[0]+===+'%2B'+%7C%7C+path[0]+===+'-')?+parseInt(path.shift()%2B1)+:+1,
++++++++++++path:+path
++++++++});
++++};

++++var+valueOf+=+function(object,+path)+{
++++++++var+ptr+=+object;
++++++++for+(var+i=0,l=path.length;+i<l;+i%2B%2B)+ptr+=+ptr[path[i]];
++++++++return+ptr;
++++};

++++var+comparer+=+function(a,+b)+{
++++++++for+(var+i+=+0,+l+=+keyPaths.length;+i+<+l;+i%2B%2B)+{
++++++++++++aVal+=+valueOf(a,+keyPaths[i].path);
++++++++++++bVal+=+valueOf(b,+keyPaths[i].path);
++++++++++++if+(aVal+>+bVal)+return+keyPaths[i].sign;
++++++++++++if+(aVal+<+bVal)+return+-keyPaths[i].sign;
++++++++}
++++++++return+0;
++++};

++++Array.prototype.sortBy+=+function()+{
++++++++keyPaths+=+[];
++++++++for+(var+i=0,l=arguments.length;+i<l;+i%2B%2B)+{
++++++++++++switch+(typeof(arguments[i]))+{
++++++++++++++++case+"object":+saveKeyPath(arguments[i]);+break;
++++++++++++++++case+"string":+saveKeyPath(arguments[i].match(/[%2B-]%7C[%5E.]%2B/g));+break;
++++++++++++}
++++++++}
++++++++return+this.sort(comparer);
++++};++++
})();|code-block|syntax|javascript|56224|用法：|56225|var+data+=+[
++++{+name:+{+first:+'Josh',+last:+'Jones'+},+age:+30+},
++++{+name:+{+first:+'Carlos',+last:+'Jacques'+},+age:+19+},
++++{+name:+{+first:+'Carlos',+last:+'Dante'+},+age:+23+},
++++{+name:+{+first:+'Tim',+last:+'Marley'+},+age:+9+},
++++{+name:+{+first:+'Courtney',+last:+'Smith'+},+age:+27+},
++++{+name:+{+first:+'Bob',+last:+'Smith'+},+age:+30+}
]

data.sortBy('age');+//+"Tim+Marley(9)",+"Carlos+Jacques(19)",+"Carlos+Dante(23)",+"Courtney+Smith(27)",+"Josh+Jones(30)",+"Bob+Smith(30)"|56226|使用点语法或数组语法按嵌套属性排序：|56227|data.sortBy('name.first');+//+"Bob+Smith(30)",+"Carlos+Dante(23)",+"Carlos+Jacques(19)",+"Courtney+Smith(27)",+"Josh+Jones(30)",+"Tim+Marley(9)"
data.sortBy(['name',+'first']);+//+"Bob+Smith(30)",+"Carlos+Dante(23)",+"Carlos+Jacques(19)",+"Courtney+Smith(27)",+"Josh+Jones(30)",+"Tim+Marley(9)"|56228|按多个键排序：|56229|data.sortBy('name.first',+'age');+//+"Bob+Smith(30)",+"Carlos+Jacques(19)",+"Carlos+Dante(23)",+"Courtney+Smith(27)",+"Josh+Jones(30)",+"Tim+Marley(9)"
data.sortBy('name.first',+'-age');+//+"Bob+Smith(30)",+"Carlos+Dante(23)",+"Carlos+Jacques(19)",+"Courtney+Smith(27)",+"Josh+Jones(30)",+"Tim+Marley(9)"|56230|您可以派生代码库：https://github.com/eneko/Array.sortBy|56231|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/eneko/Array.sortBy^0|S|3|19|7|0|0|0|0|0|0|0|0|9|11|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|1C|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|1D|8|@]|E|@]|F|$]]|$1|N|3|O|5|I|7|1E|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|1F|8|@]|E|@]|F|$]]|$1|R|3|S|5|I|7|1G|8|@]|E|@]|F|$J|K]]|$1|T|3|U|5|6|7|1H|8|@]|E|@]|F|$]]|$1|V|3|W|5|I|7|1I|8|@]|E|@]|F|$J|K]]|$1|X|3|Y|5|6|7|1J|8|@]|E|@$9|1K|A|1L|1|1M]]|F|$]]|$1|Z|3|-4|5|6|7|1N|8|@]|E|@]|F|$]]]|10|$11|$5|12|13|14|F|$15|16]]]]

<p>While it is a bit of an overkill for just sorting a single array, this prototype function allows to sort Javascript arrays by any key, in ascending or descending order, <strong>including nested keys</strong>, using <code>dot</code> syntax.</p>

<pre><code>(function(){
    var keyPaths = [];

    var saveKeyPath = function(path) {
        keyPaths.push({
            sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1,
            path: path
        });
    };

    var valueOf = function(object, path) {
        var ptr = object;
        for (var i=0,l=path.length; i&lt;l; i++) ptr = ptr[path[i]];
        return ptr;
    };

    var comparer = function(a, b) {
        for (var i = 0, l = keyPaths.length; i &lt; l; i++) {
            aVal = valueOf(a, keyPaths[i].path);
            bVal = valueOf(b, keyPaths[i].path);
            if (aVal &gt; bVal) return keyPaths[i].sign;
            if (aVal &lt; bVal) return -keyPaths[i].sign;
        }
        return 0;
    };

    Array.prototype.sortBy = function() {
        keyPaths = [];
        for (var i=0,l=arguments.length; i&lt;l; i++) {
            switch (typeof(arguments[i])) {
                case "object": saveKeyPath(arguments[i]); break;
                case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
            }
        }
        return this.sort(comparer);
    };    
})();
</code></pre>

<p>Usage:</p>

<pre><code>var data = [
    { name: { first: 'Josh', last: 'Jones' }, age: 30 },
    { name: { first: 'Carlos', last: 'Jacques' }, age: 19 },
    { name: { first: 'Carlos', last: 'Dante' }, age: 23 },
    { name: { first: 'Tim', last: 'Marley' }, age: 9 },
    { name: { first: 'Courtney', last: 'Smith' }, age: 27 },
    { name: { first: 'Bob', last: 'Smith' }, age: 30 }
]

data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)"
</code></pre>

<p>Sorting by nested properties with dot-syntax or array-syntax:</p>

<pre><code>data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
</code></pre>

<p>Sorting by multiple keys:</p>

<pre><code>data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
</code></pre>

<p>You can fork the repo: <a href="https://github.com/eneko/Array.sortBy" rel="noreferrer">https://github.com/eneko/Array.sortBy</a></p>


blocks|key|56246|text|嗨，在读完这篇文章后，我根据自己的需要制作了一个sortComparator，它具有比较多个json属性的功能，我想与您分享它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56247|此解决方案仅按升序比较字符串，但该解决方案可以很容易地扩展到每个属性以支持:反向排序、其他数据类型、使用区域设置、强制转换等|56248|var+homes+=+[{

++++"h_id":+"3",
++++"city":+"Dallas",
++++"state":+"TX",
++++"zip":+"75201",
++++"price":+"162500"

},+{

++++"h_id":+"4",
++++"city":+"Bevery+Hills",
++++"state":+"CA",
++++"zip":+"90210",
++++"price":+"319250"

},+{

++++"h_id":+"5",
++++"city":+"New+York",
++++"state":+"NY",
++++"zip":+"00010",
++++"price":+"962500"

}];

//+comp+=+array+of+attributes+to+sort
//+comp+=+['attr1',+'attr2',+'attr3',+...]
function+sortComparator(a,+b,+comp)+{
++++//+Compare+the+values+of+the+first+attribute
++++if+(a[comp[0]]+===+b[comp[0]])+{
++++++++//+if+EQ+proceed+with+the+next+attributes
++++++++if+(comp.length+>+1)+{
++++++++++++return+sortComparator(a,+b,+comp.slice(1));
++++++++}+else+{
++++++++++++//+if+no+more+attributes+then+return+EQ
++++++++++++return+0;
++++++++}
++++}+else+{
++++++++//+return+less+or+great
++++++++return+(a[comp[0]]+<+b[comp[0]]+?+-1+:+1)
++++}
}

//+Sort+array+homes
homes.sort(function(a,+b)+{
++++return+sortComparator(a,+b,+['state',+'city',+'zip']);
});

//+display+the+array
homes.forEach(function(home)+{
++++console.log(home.h_id,+home.city,+home.state,+home.zip,+home.price);
});|code-block|syntax|javascript|56249|结果就是|56250|$+node+sort
4+Bevery+Hills+CA+90210+319250
5+New+York+NY+00010+962500
3+Dallas+TX+75201+162500|56251|和另一种类型|56252|homes.sort(function(a,+b)+{
++++return+sortComparator(a,+b,+['city',+'zip']);
});|56253|有结果|56254|$+node+sort
4+Bevery+Hills+CA+90210+319250
3+Dallas+TX+75201+162500
5+New+York+NY+00010+962500|56255|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

<p>Hi after reading this article, I made a sortComparator for my needs, with the functionality to compare more than one json attributes, and i want to share it with you.</p>

<p>This solution compares only strings in ascending order, but the solution can be easy extended for each attribute to support: reverse ordering, other data types, to use locale, casting etc</p>

<pre><code>var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

}, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

}, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

}];

// comp = array of attributes to sort
// comp = ['attr1', 'attr2', 'attr3', ...]
function sortComparator(a, b, comp) {
    // Compare the values of the first attribute
    if (a[comp[0]] === b[comp[0]]) {
        // if EQ proceed with the next attributes
        if (comp.length &gt; 1) {
            return sortComparator(a, b, comp.slice(1));
        } else {
            // if no more attributes then return EQ
            return 0;
        }
    } else {
        // return less or great
        return (a[comp[0]] &lt; b[comp[0]] ? -1 : 1)
    }
}

// Sort array homes
homes.sort(function(a, b) {
    return sortComparator(a, b, ['state', 'city', 'zip']);
});

// display the array
homes.forEach(function(home) {
    console.log(home.h_id, home.city, home.state, home.zip, home.price);
});
</code></pre>

<p>and the result is</p>

<pre><code>$ node sort
4 Bevery Hills CA 90210 319250
5 New York NY 00010 962500
3 Dallas TX 75201 162500
</code></pre>

<p>and another sort</p>

<pre><code>homes.sort(function(a, b) {
    return sortComparator(a, b, ['city', 'zip']);
});
</code></pre>

<p>with result</p>

<pre><code>$ node sort
4 Bevery Hills CA 90210 319250
3 Dallas TX 75201 162500
5 New York NY 00010 962500
</code></pre>


blocks|key|55320|text|使用lodash.sortBy+(使用commonjs的指令，您也可以将script+include-tag+for+the+cdn放在html的顶部)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|55321|var+sortBy+=+require('lodash.sortby');
//+or
sortBy+=+require('lodash').sortBy;|code-block|syntax|javascript|55322|降序|55323|var+descendingOrder+=+sortBy(+homes,+'price'+).reverse();|55324|升序|55325|var+ascendingOrder+=+sortBy(+homes,+'price'+);|55326|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs#sortBy|1|https://www.jsdelivr.com/projects/lodash^0|2|D|0|10|U|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

<p>Use <a href="https://lodash.com/docs#sortBy" rel="noreferrer">lodash.sortBy</a>, (instructions using commonjs, you can also just put the <a href="https://www.jsdelivr.com/projects/lodash" rel="noreferrer">script include-tag for the cdn</a> at the top of your html)</p>

<pre><code>var sortBy = require('lodash.sortby');
// or
sortBy = require('lodash').sortBy;
</code></pre>

<p>Descending order</p>

<pre><code>var descendingOrder = sortBy( homes, 'price' ).reverse();
</code></pre>

<p>Ascending order</p>

<pre><code>var ascendingOrder = sortBy( homes, 'price' );
</code></pre>


blocks|key|2754266|text|有了ECMAScript+6，StoBor的答案可以做得更简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2754267|homes.sort((a,+b)+=>+a.price+-+b.price)|code-block|syntax|javascript|2754268|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|$]]

<p>With ECMAScript 6 StoBor's answer can be done even more concise:</p>

<pre><code>homes.sort((a, b) =&gt; a.price - b.price)
</code></pre>


blocks|key|2542836|text|如果您有一个兼容ES6的浏览器，您可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2542837|2542838|Arrow+functions|unordered-list-item|2542839|Number()+function|2542840|sort()+function|2542841|2542842|升序和降序排序顺序的不同在于比较函数返回的值的符号：|2542843|var+ascending+=+homes.sort((a,+b)+=>+Number(a.price)+-+Number(b.price));
var+descending+=+homes.sort((a,+b)+=>+Number(b.price)+-+Number(a.price));|code-block|syntax|javascript|2542844|下面是一个有效的代码片段：|2542845|​|2542846|var+homes+=+[{
++"h_id":+"3",
++"city":+"Dallas",
++"state":+"TX",
++"zip":+"75201",
++"price":+"162500"
},+{
++"h_id":+"4",
++"city":+"Bevery+Hills",
++"state":+"CA",
++"zip":+"90210",
++"price":+"319250"
},+{
++"h_id":+"5",
++"city":+"New+York",
++"state":+"NY",
++"zip":+"00010",
++"price":+"962500"
}];

homes.sort((a,+b)+=>+Number(a.price)+-+Number(b.price));
console.log("ascending",+homes);

homes.sort((a,+b)+=>+Number(b.price)+-+Number(a.price));
console.log("descending",+homes);|2542847|2542848|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla|1|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number%2520%2522Number%2520function|3|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/sort^0|8|3|0|0|0|0|F|1|0|0|H|2|0|0|F|3|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|D|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1J|8|@]|9|@$A|1K|B|1L|1|1M]]|C|$]]|$1|H|3|I|5|G|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|J|3|K|5|G|7|1R|8|@]|9|@$A|1S|B|1T|1|1U]]|C|$]]|$1|L|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1W|8|@]|9|@]|C|$]]|$1|O|3|P|5|Q|7|1X|8|@]|9|@]|C|$R|S]]|$1|T|3|U|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|V|3|W|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|X|3|Y|5|Q|7|20|8|@]|9|@]|C|$R|S]]|$1|Z|3|W|5|6|7|21|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|22|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]|18|$5|13|14|15|C|$16|19]]|1A|$5|13|14|15|C|$16|1B]]|1C|$5|13|14|15|C|$16|1D]]]]

<p>If you have an <a href="https://developer.mozilla.org/en/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla" rel="noreferrer" title="ES6">ES6</a> compliant browser you can use:</p>

<ul>
<li><a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions" rel="noreferrer" title="Arrow functions">Arrow functions</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number%20%22Number%20function" rel="noreferrer">Number() function</a></li>
<li><a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/sort" rel="noreferrer" title="sort function">sort() function</a></li>
</ul>

<p>The difference between ascending and descending sort order is the sign of the value returned by your compare function:</p>

<pre><code>var ascending = homes.sort((a, b) =&gt; Number(a.price) - Number(b.price));
var descending = homes.sort((a, b) =&gt; Number(b.price) - Number(a.price));
</code></pre>

<p>Here's a working code snippet:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var homes = [{
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

homes.sort((a, b) =&gt; Number(a.price) - Number(b.price));
console.log("ascending", homes);

homes.sort((a, b) =&gt; Number(b.price) - Number(a.price));
console.log("descending", homes);</code></pre>
</div>
</div>
</p>


blocks|key|2754324|text|这里是"JavaScript:好的部分“一书中优雅实现的一个稍微修改的版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2754325|注意:这个版本的by是稳定的。它在执行下一个链式排序时保留第一个排序的顺序。|offset|length|style|BOLD|CODE|2754326|我已经给它添加了isAscending参数。也按照作者的建议，将其转换为ES6标准和“较新”的好部件。|2754327|您可以按多个属性进行升序和降序排序，也可以按链排序。|2754328|​|2754329|const+by+=+function+(name,+minor,+isAscending=true)+{
++++const+reverseMutliplier+=+isAscending+?+1+:+-1;
++++return+function+(o,+p)+{
++++++++let+a,+b;
++++++++let+result;
++++++++if+(o+&&+p+&&+typeof+o+===+"object"+&&+typeof+p+===+"object")+{
++++++++++++a+=+o[name];
++++++++++++b+=+p[name];
++++++++++++if+(a+===+b)+{
++++++++++++++++return+typeof+minor+===+'function'+?+minor(o,+p)+:+0;
++++++++++++}
++++++++++++if+(typeof+a+===+typeof+b)+{
++++++++++++++++result+=+a+<+b+?+-1+:+1;
++++++++++++}+else+{
++++++++++++++++result+=+typeof+a+<+typeof+b+?+-1+:+1;
++++++++++++}
++++++++++++return+result+*+reverseMutliplier;
++++++++}+else+{
++++++++++++throw+{
++++++++++++++++name:+"Error",
++++++++++++++++message:+"Expected+an+object+when+sorting+by+"+%2B+name
++++++++++++};
++++++++}
++++};
};

let+s+=+[
++++{first:+'Joe',+++last:+'Besser'},
++++{first:+'Moe',+++last:+'Howard'},
++++{first:+'Joe',+++last:+'DeRita'},
++++{first:+'Shemp',+last:+'Howard'},
++++{first:+'Larry',+last:+'Fine'},
++++{first:+'Curly',+last:+'Howard'}
];

//+Sort+by:+first+ascending,+last+ascending
s.sort(by("first",+by("last")));++++
console.log("Sort+by:+first+ascending,+last+ascending:+",+s);+++++//+"[
//+++++{"first":"Curly","last":"Howard"},
//+++++{"first":"Joe","last":"Besser"},+++++<======
//+++++{"first":"Joe","last":"DeRita"},+++++<======
//+++++{"first":"Larry","last":"Fine"},
//+++++{"first":"Moe","last":"Howard"},
//+++++{"first":"Shemp","last":"Howard"}
//+]

//+Sort+by:+first+ascending,+last+descending
s.sort(by("first",+by("last",+0,+false)));++
console.log("sort+by:+first+ascending,+last+descending:+",+s);++++//+"[
//+++++{"first":"Curly","last":"Howard"},
//+++++{"first":"Joe","last":"DeRita"},+++++<========
//+++++{"first":"Joe","last":"Besser"},+++++<========
//+++++{"first":"Larry","last":"Fine"},
//+++++{"first":"Moe","last":"Howard"},
//+++++{"first":"Shemp","last":"Howard"}
//+]|code-block|syntax|javascript|2754330|2754331|entityMap^0|0|0|12|8|2|0|0|1F|8|B|10|3|0|0|Q|0|0|1|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|H]|$D|17|E|18|F|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1C|8|@$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1F|8|@]|9|@]|A|$R|S]]|$1|T|3|N|5|6|7|1G|8|@$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|V|$]]

<p>Here is a slightly modified version of elegant implementation from the book "JavaScript: The Good Parts".</p>

<p><strong>NOTE</strong>: This version of <code>by</code> is <strong>stable</strong>. It preserves the order of the first sort while performing the next chained sort.</p>

<p>I have added <code>isAscending</code> parameter to it. Also converted it to <code>ES6</code> standards and "newer" good parts as recommended by the author.</p>

<p>You can sort ascending as well as descending and chain sort by multiple properties.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const by = function (name, minor, isAscending=true) {
    const reverseMutliplier = isAscending ? 1 : -1;
    return function (o, p) {
        let a, b;
        let result;
        if (o &amp;&amp; p &amp;&amp; typeof o === "object" &amp;&amp; typeof p === "object") {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 0;
            }
            if (typeof a === typeof b) {
                result = a &lt; b ? -1 : 1;
            } else {
                result = typeof a &lt; typeof b ? -1 : 1;
            }
            return result * reverseMutliplier;
        } else {
            throw {
                name: "Error",
                message: "Expected an object when sorting by " + name
            };
        }
    };
};

let s = [
    {first: 'Joe',   last: 'Besser'},
    {first: 'Moe',   last: 'Howard'},
    {first: 'Joe',   last: 'DeRita'},
    {first: 'Shemp', last: 'Howard'},
    {first: 'Larry', last: 'Fine'},
    {first: 'Curly', last: 'Howard'}
];

// Sort by: first ascending, last ascending
s.sort(by("first", by("last")));    
console.log("Sort by: first ascending, last ascending: ", s);     // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"Besser"},     &lt;======
//     {"first":"Joe","last":"DeRita"},     &lt;======
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]

// Sort by: first ascending, last descending
s.sort(by("first", by("last", 0, false)));  
console.log("sort by: first ascending, last descending: ", s);    // "[
//     {"first":"Curly","last":"Howard"},
//     {"first":"Joe","last":"DeRita"},     &lt;========
//     {"first":"Joe","last":"Besser"},     &lt;========
//     {"first":"Larry","last":"Fine"},
//     {"first":"Moe","last":"Howard"},
//     {"first":"Shemp","last":"Howard"}
// ]</code></pre>
</div>
</div>
</p>


blocks|key|2754346|text|用于对多个数组对象字段进行排序。在arrprop数组中输入您的字段名，如["a","b","c"]，然后传入第二个参数arrsource，我们想要排序的实际源。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2754347|function+SortArrayobject(arrprop,arrsource){
arrprop.forEach(function(i){
arrsource.sort(function(a,b){
return+((a[i]+<+b[i])+?+-1+:+((a[i]+>+b[i])+?+1+:+0));
});
});
return+arrsource;
}|code-block|syntax|javascript|2754348|entityMap^0|H|7|10|D|1N|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

<p>For sort on multiple array object field.
Enter your field name in <code>arrprop</code> array like <code>["a","b","c"]</code>
then pass in second parameter <code>arrsource</code> actual source we want to sort.</p>

<pre><code>function SortArrayobject(arrprop,arrsource){
arrprop.forEach(function(i){
arrsource.sort(function(a,b){
return ((a[i] &lt; b[i]) ? -1 : ((a[i] &gt; b[i]) ? 1 : 0));
});
});
return arrsource;
}
</code></pre>


blocks|key|55439|text|这可以通过一个简单的一行valueof()排序函数来实现。运行下面的代码片段以查看演示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55440|​|55441|var+homes+=+[
++++{
++++++++"h_id":+"3",
++++++++"city":+"Dallas",
++++++++"state":+"TX",
++++++++"zip":+"75201",
++++++++"price":+"162500"
++++},+{
++++++++"h_id":+"4",
++++++++"city":+"Bevery+Hills",
++++++++"state":+"CA",
++++++++"zip":+"90210",
++++++++"price":+"319250"
++++},+{
++++++++"h_id":+"5",
++++++++"city":+"New+York",
++++++++"state":+"NY",
++++++++"zip":+"00010",
++++++++"price":+"962500"
++++}
];

console.log("To+sort+descending/highest+first,+use+operator+'<'");

homes.sort(function(a,b)+{+return+a.price.valueOf()+<+b.price.valueOf();});

console.log(homes);

console.log("To+sort+ascending/lowest+first,+use+operator+'>'");

homes.sort(function(a,b)+{+return+a.price.valueOf()+>+b.price.valueOf();});

console.log(homes);|code-block|syntax|javascript|55442|55443|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|$]]

<p>This could have been achieved through a simple one line <strong>valueof()</strong> sort function. Run code snippet below to see demo.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];

console.log("To sort descending/highest first, use operator '&lt;'");

homes.sort(function(a,b) { return a.price.valueOf() &lt; b.price.valueOf();});

console.log(homes);

console.log("To sort ascending/lowest first, use operator '&gt;'");

homes.sort(function(a,b) { return a.price.valueOf() &gt; b.price.valueOf();});

console.log(homes);</code></pre>
</div>
</div>
</p>


blocks|key|55346|text|仅对于元素值的普通数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55347|function+sortArrayOfElements(arrayToSort)+{
++++function+compareElements(a,+b)+{
++++++++if+(a+<+b)
++++++++++++return+-1;
++++++++if+(a+>+b)
++++++++++++return+1;
++++++++return+0;
++++}

++++return+arrayToSort.sort(compareElements);
}

e.g.+1:
var+array1+=+[1,2,545,676,64,2,24]
output+:+[1,+2,+2,+24,+64,+545,+676]

var+array2+=+["v","a",545,676,64,2,"24"]
output:+["a",+"v",+2,+"24",+64,+545,+676]|code-block|syntax|javascript|55348|对于对象数组：|55349|function+sortArrayOfObjects(arrayToSort,+key)+{
++++function+compareObjects(a,+b)+{
++++++++if+(a[key]+<+b[key])
++++++++++++return+-1;
++++++++if+(a[key]+>+b[key])
++++++++++++return+1;
++++++++return+0;
++++}

++++return+arrayToSort.sort(compareObjects);
}

e.g.+1:+var+array1=+[{"name":+"User4",+"value":+4},{"name":+"User3",+"value":+3},{"name":+"User2",+"value":+2}]

output+:+[{"name":+"User2",+"value":+2},{"name":+"User3",+"value":+3},{"name":+"User4",+"value":+4}]|55350|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|$]]

<p>For a normal array of elements values only:</p>

<pre><code>function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a &lt; b)
            return -1;
        if (a &gt; b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
output : [1, 2, 2, 24, 64, 545, 676]

var array2 = ["v","a",545,676,64,2,"24"]
output: ["a", "v", 2, "24", 64, 545, 676]
</code></pre>

<p>For an array of objects:</p>

<pre><code>function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] &lt; b[key])
            return -1;
        if (a[key] &gt; b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]
</code></pre>


blocks|key|55461|text|您将需要两个函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|55462|function+desc(a,+b)+{
+return+b+<+a+?+-1+:+b+>+a+?+1+:+b+>=+a+?+0+:+NaN;
}

function+asc(a,+b)+{
++return+a+<+b+?+-1+:+a+>+b+?+1+:+a+>=+b+?+0+:+NaN;
}|code-block|syntax|javascript|55463|然后，您可以将其应用于任何对象属性：|55464|+data.sort((a,+b)+=>+desc(parseFloat(a.price),+parseFloat(b.price)));|55465|​|55466|let+data+=+[
++++{label:+"one",+value:10},
++++{label:+"two",+value:5},
++++{label:+"three",+value:1},
];

//+sort+functions
function+desc(a,+b)+{
+return+b+<+a+?+-1+:+b+>+a+?+1+:+b+>=+a+?+0+:+NaN;
}

function+asc(a,+b)+{
+return+a+<+b+?+-1+:+a+>+b+?+1+:+a+>=+b+?+0+:+NaN;
}

//+DESC
data.sort((a,+b)+=>+desc(a.value,+b.value));

document.body.insertAdjacentHTML(
+'beforeend',+
+'<strong>DESCending+sorted</strong><pre>'+%2B+JSON.stringify(data)+%2B'</pre>'
);

//+ASC
data.sort((a,+b)+=>+asc(a.value,+b.value));

document.body.insertAdjacentHTML(
+'beforeend',+
+'<strong>ASCending+sorted</strong><pre>'+%2B+JSON.stringify(data)+%2B'</pre>'
);|55467|55468|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|V|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|O|3|L|5|6|7|X|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

<p>You will need two function</p>

<pre><code>function desc(a, b) {
 return b &lt; a ? -1 : b &gt; a ? 1 : b &gt;= a ? 0 : NaN;
}

function asc(a, b) {
  return a &lt; b ? -1 : a &gt; b ? 1 : a &gt;= b ? 0 : NaN;
}
</code></pre>

<p>Then you can apply this to any object property:</p>

<pre><code> data.sort((a, b) =&gt; desc(parseFloat(a.price), parseFloat(b.price)));
</code></pre>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let data = [
    {label: "one", value:10},
    {label: "two", value:5},
    {label: "three", value:1},
];

// sort functions
function desc(a, b) {
 return b &lt; a ? -1 : b &gt; a ? 1 : b &gt;= a ? 0 : NaN;
}

function asc(a, b) {
 return a &lt; b ? -1 : a &gt; b ? 1 : a &gt;= b ? 0 : NaN;
}

// DESC
data.sort((a, b) =&gt; desc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '&lt;strong&gt;DESCending sorted&lt;/strong&gt;&lt;pre&gt;' + JSON.stringify(data) +'&lt;/pre&gt;'
);

// ASC
data.sort((a, b) =&gt; asc(a.value, b.value));

document.body.insertAdjacentHTML(
 'beforeend', 
 '&lt;strong&gt;ASCending sorted&lt;/strong&gt;&lt;pre&gt;' + JSON.stringify(data) +'&lt;/pre&gt;'
);</code></pre>
</div>
</div>
</p>


blocks|key|2754443|text|虽然我知道OP想要对数字数组进行排序，但这个问题已经被标记为关于字符串的类似问题的答案。因此，上面的答案没有考虑对大小写很重要的文本数组进行排序。大多数答案接受字符串值，并将其转换为大写/小写，然后以某种方式排序。我坚持的要求很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2754444|2754445|按字母顺序排序A-Z|unordered-list-item|2754446|相同单词的大写数值应排在小写数值之前|2754447|相同字母(A/a，B/b)数值应组合在一起|2754448|2754449|我期望的是[+A,+a,+B,+b,+C,+c+]，但上面的答案返回A,+B,+C,+a,+b,+c。实际上，我在这上面挠头的时间比我想要的要长(这就是为什么我发布这篇文章，希望它至少能帮助另一个人)。虽然有两个用户在评论中提到了标记答案的localeCompare函数，但直到我在周围搜索时偶然发现了这个函数，我才看到了这一点。在阅读了the+String.prototype.localeCompare()+documentation之后，我想到了这个：|offset|length|style|CODE|2754450|var+values+=+[+"Delta",+"charlie",+"delta",+"Charlie",+"Bravo",+"alpha",+"Alpha",+"bravo"+];
var+sorted+=+values.sort((a,+b)+=>+a.localeCompare(b,+undefined,+{+caseFirst:+"upper"+}));
//+Result:+[+"Alpha",+"alpha",+"Bravo",+"bravo",+"Charlie",+"charlie",+"Delta",+"delta"+]|code-block|syntax|javascript|2754451|这将告诉函数在小写数值之前对大写数值进行排序。localeCompare函数中的第二个参数是定义区域设置，但是如果您将其保留为undefined，它会自动为您确定区域设置。|2754452|这对于对对象数组进行排序也是一样的：|2754453|var+values+=+[
++++{+id:+6,+title:+"Delta"+},
++++{+id:+2,+title:+"charlie"+},
++++{+id:+3,+title:+"delta"+},
++++{+id:+1,+title:+"Charlie"+},
++++{+id:+8,+title:+"Bravo"+},
++++{+id:+5,+title:+"alpha"+},
++++{+id:+4,+title:+"Alpha"+},
++++{+id:+7,+title:+"bravo"+}
];
var+sorted+=+values
++++.sort((a,+b)+=>+a.title.localeCompare(b.title,+undefined,+{+caseFirst:+"upper"+}));|2754454|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare^0|0|0|0|0|0|0|5|K|Y|G|3C|D|4P|1E|0|0|0|N|D|1R|9|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1B|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1C|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|1D|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1F|8|@$M|1G|N|1H|O|P]|$M|1I|N|1J|O|P]|$M|1K|N|1L|O|P]]|9|@$M|1M|N|1N|1|1O]]|A|$]]|$1|Q|3|R|5|S|7|1P|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1Q|8|@$M|1R|N|1S|O|P]|$M|1T|N|1U|O|P]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1V|8|@]|9|@]|A|$]]|$1|Z|3|10|5|S|7|1W|8|@]|9|@]|A|$T|U]]|$1|11|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]]]

<p>While I am aware that the OP wanted to sort an array of numbers, this question has been marked as the answer for similar questions regarding strings.  To that fact, the above answers do not consider sorting an array of text where casing is important.  Most answers take the string values and convert them to uppercase/lowercase and then sort one way or another.  The requirements that I adhere to are simple:</p>

<ul>
<li>Sort alphabetically A-Z</li>
<li>Uppercase values of the same word should come before lowercase values</li>
<li>Same letter (A/a, B/b) values should be grouped together</li>
</ul>

<p>What I expect is <code>[ A, a, B, b, C, c ]</code> but the answers above return <code>A, B, C, a, b, c</code>.  I actually scratched my head on this for longer than I wanted (which is why I am posting this in hopes that it will help at least one other person).  While two users mention the <code>localeCompare</code> function in the comments for the marked answer, I didn't see that until after I stumbled upon the function while searching around.  After reading <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare" rel="noreferrer">the String.prototype.localeCompare() documentation</a> I was able to come up with this:</p>

<pre class="lang-js prettyprint-override"><code>var values = [ "Delta", "charlie", "delta", "Charlie", "Bravo", "alpha", "Alpha", "bravo" ];
var sorted = values.sort((a, b) =&gt; a.localeCompare(b, undefined, { caseFirst: "upper" }));
// Result: [ "Alpha", "alpha", "Bravo", "bravo", "Charlie", "charlie", "Delta", "delta" ]
</code></pre>

<p>This tells the function to sort uppercase values before lowercase values.  The second parameter in the <code>localeCompare</code> function is to define the locale but if you leave it as <code>undefined</code> it automatically figures out the locale for you.</p>

<p>This works the same for sorting an array of objects as well:</p>

<pre><code>var values = [
    { id: 6, title: "Delta" },
    { id: 2, title: "charlie" },
    { id: 3, title: "delta" },
    { id: 1, title: "Charlie" },
    { id: 8, title: "Bravo" },
    { id: 5, title: "alpha" },
    { id: 4, title: "Alpha" },
    { id: 7, title: "bravo" }
];
var sorted = values
    .sort((a, b) =&gt; a.title.localeCompare(b.title, undefined, { caseFirst: "upper" }));
</code></pre>


blocks|key|2543020|text|我参加聚会有点晚了，但下面是我的排序逻辑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2543021|function+getSortedData(data,+prop,+isAsc)+{
++++return+data.sort((a,+b)+=>+{
++++++++return+(a[prop]+<+b[prop]+?+-1+:+1)+*+(isAsc+?+1+:+-1)
++++});
}|code-block|syntax|javascript|2543022|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|$]]

<p>I'm little late for the party but below is my logic for sorting.</p>

<pre><code>function getSortedData(data, prop, isAsc) {
    return data.sort((a, b) =&gt; {
        return (a[prop] &lt; b[prop] ? -1 : 1) * (isAsc ? 1 : -1)
    });
}
</code></pre>


blocks|key|2754483|text|使用以下代码创建一个函数并根据输入进行排序|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2754484|var+homes+=+[{

++++"h_id":+"3",
++++"city":+"Dallas",
++++"state":+"TX",
++++"zip":+"75201",
++++"price":+"162500"

+},+{

++++"h_id":+"4",
++++"city":+"Bevery+Hills",
++++"state":+"CA",
++++"zip":+"90210",
++++"price":+"319250"

+},+{

++++"h_id":+"5",
++++"city":+"New+York",
++++"state":+"NY",
++++"zip":+"00010",
++++"price":+"962500"

+}];

+function+sortList(list,order){
+++++if(order=="ASC"){
++++++++return+list.sort((a,b)=>{
++++++++++++return+parseFloat(a.price)+-+parseFloat(b.price);
++++++++})
+++++}
+++++else{
++++++++return+list.sort((a,b)=>{
++++++++++++return+parseFloat(b.price)+-+parseFloat(a.price);
++++++++});
+++++}
+}

+sortList(homes,'DESC');
+console.log(homes);|code-block|syntax|javascript|2754485|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|$]]

<p>Create a function and sort based on the input using below code</p>

<pre><code>var homes = [{

    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": "162500"

 }, {

    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": "319250"

 }, {

    "h_id": "5",
    "city": "New York",
    "state": "NY",
    "zip": "00010",
    "price": "962500"

 }];

 function sortList(list,order){
     if(order=="ASC"){
        return list.sort((a,b)=&gt;{
            return parseFloat(a.price) - parseFloat(b.price);
        })
     }
     else{
        return list.sort((a,b)=&gt;{
            return parseFloat(b.price) - parseFloat(a.price);
        });
     }
 }

 sortList(homes,'DESC');
 console.log(homes);
</code></pre>


blocks|key|2543087|text|价格降序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2543088|homes.sort((x,y)+=>+{return+y.price+-+x.price})|code-block|syntax|javascript|2543089|价格升序：|2543090|homes.sort((x,y)+=>+{return+x.price+-+y.price})|2543091|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|$]]

<p>Descending order of price: </p>

<pre><code>homes.sort((x,y) =&gt; {return y.price - x.price})
</code></pre>

<p>Ascending order of price: </p>

<pre><code>homes.sort((x,y) =&gt; {return x.price - y.price})
</code></pre>


blocks|key|2543093|text|一个简单的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2543094|​|2543095|++++var+homes+=+[
++++++++{
++++++++++++"h_id":+"3",
++++++++++++"city":+"Dallas",
++++++++++++"state":+"TX",
++++++++++++"zip":+"75201",
++++++++++++"price":+"162500"
++++++++},+{
++++++++++++"h_id":+"4",
++++++++++++"city":+"Bevery+Hills",
++++++++++++"state":+"CA",
++++++++++++"zip":+"90210",
++++++++++++"price":+"319250"
++++++++},+{
++++++++++++"h_id":+"5",
++++++++++++"city":+"New+York",
++++++++++++"state":+"NY",
++++++++++++"zip":+"00010",
++++++++++++"price":+"962500"
++++++++}
++++];

++++let+sortByPrice+=+homes.sort(function+(a,+b)+
++++{
++++++return+parseFloat(b.price)+-+parseFloat(a.price);
++++});

++++for+(var+i=0;+i<sortByPrice.length;+i%2B%2B)
++++{
++++++document.write(sortByPrice[i].h_id%2B'+'%2BsortByPrice[i].city%2B'+'
+++++++%2BsortByPrice[i].state%2B'+'
+++++++%2BsortByPrice[i].zip%2B'+'%2BsortByPrice[i].price);
++++++document.write("<br>");
++++}|code-block|syntax|javascript|2543096|2543097|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|$]]

<p>A simple code :</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>    var homes = [
        {
            "h_id": "3",
            "city": "Dallas",
            "state": "TX",
            "zip": "75201",
            "price": "162500"
        }, {
            "h_id": "4",
            "city": "Bevery Hills",
            "state": "CA",
            "zip": "90210",
            "price": "319250"
        }, {
            "h_id": "5",
            "city": "New York",
            "state": "NY",
            "zip": "00010",
            "price": "962500"
        }
    ];

    let sortByPrice = homes.sort(function (a, b) 
    {
      return parseFloat(b.price) - parseFloat(a.price);
    });

    for (var i=0; i&lt;sortByPrice.length; i++)
    {
      document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '
       +sortByPrice[i].state+' '
       +sortByPrice[i].zip+' '+sortByPrice[i].price);
      document.write("&lt;br&gt;");
    }</code></pre>
</div>
</div>
</p>


blocks|key|56458|text|可以使用string1.localeCompare(string2)进行字符串比较|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56459|this.myArray.sort((a,b)+=>+{+
++++return+a.stringProp.localeCompare(b.stringProp);
});|code-block|syntax|javascript|56460|请注意，localCompare在中区分大小写|offset|length|style|CODE|56461|entityMap^0|0|0|4|C|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|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>You can use string1.localeCompare(string2) for string comparison </p>

<pre><code>this.myArray.sort((a,b) =&gt; { 
    return a.stringProp.localeCompare(b.stringProp);
});
</code></pre>

<p>Note that <code>localCompare</code> is case <strong>in</strong>sensitive</p>


blocks|key|56133|text|+function+compareValues(key,+order+=+'asc')+{
++return+function+innerSort(a,+b)+{
++++if+(!a.hasOwnProperty(key)+%7C%7C+!b.hasOwnProperty(key))+{
++++++//+property+doesn't+exist+on+either+object
++++++return+0;
++++}

++++const+varA+=+(typeof+a[key]+===+'string')
++++++?+a[key].toUpperCase()+:+a[key];
++++const+varB+=+(typeof+b[key]+===+'string')
++++++?+b[key].toUpperCase()+:+b[key];

++++let+comparison+=+0;
++++if+(varA+>+varB)+{
++++++comparison+=+1;
++++}+else+if+(varA+<+varB)+{
++++++comparison+=+-1;
++++}
++++return+(
++++++(order+===+'desc')+?+(comparison+*+-1)+:+comparison
++++);
++};
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|56134|http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc|unstyled|offset|length|56135|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1S|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Q|8|@]|9|@$G|R|H|S|1|T]]|A|$]]|$1|I|3|-4|5|F|7|U|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|E]]]]

<pre><code> function compareValues(key, order = 'asc') {
  return function innerSort(a, b) {
    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
      // property doesn't exist on either object
      return 0;
    }

    const varA = (typeof a[key] === 'string')
      ? a[key].toUpperCase() : a[key];
    const varB = (typeof b[key] === 'string')
      ? b[key].toUpperCase() : b[key];

    let comparison = 0;
    if (varA &gt; varB) {
      comparison = 1;
    } else if (varA &lt; varB) {
      comparison = -1;
    }
    return (
      (order === 'desc') ? (comparison * -1) : comparison
    );
  };
}
</code></pre>

<p><a href="http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc" rel="nofollow noreferrer">http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc</a></p>


blocks|key|56477|text|一个更像LINQ的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|56478|Array.prototype.orderBy+=+function+(selector,+desc+=+false)+{
++++return+[...this].sort((a,+b)+=>+{
++++++++a+=+selector(a);
++++++++b+=+selector(b);

++++++++if+(a+==+b)+return+0;
++++++++return+(desc+?+a+>+b+:+a+<+b)+?+-1+:+1;
++++});
}|code-block|syntax|javascript|56479|优势：|56480|适用于properties|56481|extends阵列原型的|unordered-list-item|56482|autocompletion+|56483|+not+change+array|56484|easy+use+in+method+chaining|56485|56486|56487|用法：|56488|​|56489|Array.prototype.orderBy+=+function(selector,+desc+=+false)+{
++return+[...this].sort((a,+b)+=>+{
++++a+=+selector(a);
++++b+=+selector(b);

++++if+(a+==+b)+return+0;
++++return+(desc+?+a+>+b+:+a+<+b)+?+-1+:+1;
++});
};

var+homes+=+[{
++"h_id":+"3",
++"city":+"Dallas",
++"state":+"TX",
++"zip":+"75201",
++"price":+"162500"
},+{
++"h_id":+"4",
++"city":+"Bevery+Hills",
++"state":+"CA",
++"zip":+"90210",
++"price":+"319250"
},+{
++"h_id":+"5",
++"city":+"New+York",
++"state":+"NY",
++"zip":+"00010",
++"price":+"962500"
}];

let+sorted_homes+=+homes.orderBy(h+=>+parseFloat(h.price));
console.log("sorted+by+price",+sorted_homes);

let+sorted_homes_desc+=+homes.orderBy(h+=>+h.city,+true);
console.log("sorted+by+City+descending",+sorted_homes_desc);|56490|56491|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@]|A|$]]|$1|N|3|O|5|M|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|M|7|1A|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|1B|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1E|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|11|3|Y|5|6|7|1H|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|13|$]]

<p>A more LINQ like solution:</p>
<pre class="lang-js prettyprint-override"><code>Array.prototype.orderBy = function (selector, desc = false) {
    return [...this].sort((a, b) =&gt; {
        a = selector(a);
        b = selector(b);

        if (a == b) return 0;
        return (desc ? a &gt; b : a &lt; b) ? -1 : 1;
    });
}
</code></pre>
<p>Advantages:</p>
<ul>
<li>autocompletion for properties</li>
<li>extends array prototype</li>
<li>does not change array</li>
<li>easy to use in method chaining</li>
</ul>
<p>Usage:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>Array.prototype.orderBy = function(selector, desc = false) {
  return [...this].sort((a, b) =&gt; {
    a = selector(a);
    b = selector(b);

    if (a == b) return 0;
    return (desc ? a &gt; b : a &lt; b) ? -1 : 1;
  });
};

var homes = [{
  "h_id": "3",
  "city": "Dallas",
  "state": "TX",
  "zip": "75201",
  "price": "162500"
}, {
  "h_id": "4",
  "city": "Bevery Hills",
  "state": "CA",
  "zip": "90210",
  "price": "319250"
}, {
  "h_id": "5",
  "city": "New York",
  "state": "NY",
  "zip": "00010",
  "price": "962500"
}];

let sorted_homes = homes.orderBy(h =&gt; parseFloat(h.price));
console.log("sorted by price", sorted_homes);

let sorted_homes_desc = homes.orderBy(h =&gt; h.city, true);
console.log("sorted by City descending", sorted_homes_desc);</code></pre>
</div>
</div>
</p>


blocks|key|2754582|text|如果不想使用任何sort()方法，可以使用以下方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2754583|​|2754584|function+sortObj(obj)+{
++let+numArr+=+[];+//the+array+which+just+includes+prices+as+Number
++let+sortedObj+=+[];
++obj.map((x)+=>+{
++++numArr.push(Number(x["price"]));
++});

++while+(numArr.length+>+0)+{+
++++let+minIndex+=+numArr.indexOf(Math.min(...numArr));+//the+index+of+cheapest+home+in+the+obj
++++numArr.splice(minIndex,+1);+
++++sortedObj.push(obj.splice(minIndex,+1));+//+splicing+cheapest+home+from+Homes+Array+to+sortedObj+Array.
++}

++console.log(sortedObj);
}

var+homes+=+[
++{
++++h_id:+"3",
++++city:+"Dallas",
++++state:+"TX",
++++zip:+"75201",
++++price:+"162500",
++},
++{
++++h_id:+"4",
++++city:+"Bevery+Hills",
++++state:+"CA",
++++zip:+"90210",
++++price:+"319250",
++},
++{
++++h_id:+"5",
++++city:+"New+York",
++++state:+"NY",
++++zip:+"00010",
++++price:+"962500",
++},
];
sortObj(homes);|code-block|syntax|javascript|2754585|2754586|entityMap^0|8|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|T|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|O|$]]

<p>You can use the below approach if you don't want to use any <code>sort()</code> method</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function sortObj(obj) {
  let numArr = []; //the array which just includes prices as Number
  let sortedObj = [];
  obj.map((x) =&gt; {
    numArr.push(Number(x["price"]));
  });

  while (numArr.length &gt; 0) { 
    let minIndex = numArr.indexOf(Math.min(...numArr)); //the index of cheapest home in the obj
    numArr.splice(minIndex, 1); 
    sortedObj.push(obj.splice(minIndex, 1)); // splicing cheapest home from Homes Array to sortedObj Array.
  }

  console.log(sortedObj);
}

var homes = [
  {
    h_id: "3",
    city: "Dallas",
    state: "TX",
    zip: "75201",
    price: "162500",
  },
  {
    h_id: "4",
    city: "Bevery Hills",
    state: "CA",
    zip: "90210",
    price: "319250",
  },
  {
    h_id: "5",
    city: "New York",
    state: "NY",
    zip: "00010",
    price: "962500",
  },
];
sortObj(homes);</code></pre>
</div>
</div>
</p>


<p>I've got the following objects using AJAX and stored them in an array:</p>

<pre><code>var homes = [
    {
        "h_id": "3",
        "city": "Dallas",
        "state": "TX",
        "zip": "75201",
        "price": "162500"
    }, {
        "h_id": "4",
        "city": "Bevery Hills",
        "state": "CA",
        "zip": "90210",
        "price": "319250"
    }, {
        "h_id": "5",
        "city": "New York",
        "state": "NY",
        "zip": "00010",
        "price": "962500"
    }
];
</code></pre>

<p>How do I create a function to sort the objects by the <code>price</code> property in <em>ascending</em> <strong>or</strong> <em>descending</em> order using JavaScript only?</p>


Sorting an array of objects by property values

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我使用AJAX获得了以下对象，并将它们存储在一个数组中：var homes = [    {        "h_id": "3",        "city": "Dallas",        "state": "TX",        "zip": "75201",        "price": "162500...

问按属性值对对象数组排序
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按属性值对对象数组排序EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按属性值对对象数组排序
EN