按属性值对对象数组进行排序

要对其进行排序，您需要创建一个带有两个参数的比较器函数。然后使用该比较器函数调用排序函数，如下所示：

// a and b are object elements of your arrayfunction mycomparator(a,b) {return parseInt(a.price, 10) - parseInt(b.price, 10);}homes.sort(mycomparator);

如果要进行升序排序，请切换减号两边的表达式。

按价格升序排序房屋：

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

在ES6版本之后：

homes.sort((a, b) => parseFloat(a.price) - parseFloat(b.price));

一些留档可以找到这里。

对于降序，您可以使用

homes.sort((a, b) => parseFloat(b.price) - parseFloat(a.price));

你想用Javascript对它进行排序，对吧？你想要的是#0函数。在这种情况下，你需要编写一个比较器函数并将其传递给sort()，所以像这样：

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

您的比较器获取数组中每个嵌套哈希中的一个，并通过检查“价格”字段来决定哪个更高。

您可以将JavaScriptsort方法与回调函数一起使用：

function compareASC(homeA, homeB){return parseFloat(homeA.price) - parseFloat(homeB.price);}
function compareDESC(homeA, homeB){return parseFloat(homeB.price) - parseFloat(homeA.price);}
// Sort ASChomes.sort(compareASC);
// Sort DESChomes.sort(compareDESC);

这是一个更灵活的版本，它允许您创建可重用的排序函数，并按任何字段排序。

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 lowconsole.log(homes.sort(sort_by('price', true, parseInt)));
// Sort by city, case-insensitive, A-Zconsole.log(homes.sort(sort_by('city', false, (a) =>  a.toUpperCase())));

用于字符串排序，以防有人需要它，

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

要对数组进行排序，您必须定义一个比较器函数。此函数始终与您所需的排序模式或顺序（即升序或降序）不同。

让我们创建一些函数，对包含对象或字符串或数值的数组进行升序或降序排序。

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']);}

排序数字（按字母顺序和升序）：

var fruits = ["Banana", "Orange", "Apple", "Mango"];fruits.sort();

排序数字（按字母顺序和降序）：

var fruits = ["Banana", "Orange", "Apple", "Mango"];fruits.sort();fruits.reverse();

排序数字（数字和升序）：

var points = [40,100,1,5,25,10];points.sort(sorterAscending());

排序数字（数字和降序）：

var points = [40,100,1,5,25,10];points.sort(sorterDescending());

如上所述，使用sorterPriceAsc和sorterPriceDes方法与您的数组一起使用所需的键。

homes.sort(sorterPriceAsc()) or homes.sort(sorterPriceDes())

这是上面所有答案的高潮。

小提琴验证：http://jsfiddle.net/bobberino/4qqk3/

var sortOn = function (arr, prop, reverse, numeric) {
// Ensure there's a propertyif (!prop || !arr) {return arr}
// Set up sort functionvar sort_by = function (field, rev, primer) {
// Return the required a,b functionreturn function (a, b) {
// Reset a, b to the fielda = primer(a[field]), b = primer(b[field]);
// Do actual sorting, reverse as neededreturn ((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 functionarr.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 functionarr.sort(sort_by(prop, reverse, function (a) {
// - Force value to string.return String(a).toUpperCase();
}));}

}

我还使用了某种评级和多个字段排序：

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>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>a.note)?'1':'0';return parseInt(_a) - parseInt(_b);});

结果

[{"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}]

我最近写了一个通用函数来管理它，如果你想使用它。

/*** 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 arrayobject[identifier] == null ? emptiesArray.push(object) : returnedArray.push(object);
});
// Sort the array based on the type givenswitch(type){
case 'alphabetical':
returnedArray.sort(function(a, b){
return(a[identifier] == b[identifier]) ? 0 : (
// Sort ascending or descending based on order givenorder == '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 orderreturn order == 'asc' ? returnedArray.concat(emptiesArray) : emptiesArray.concat(returnedArray);
}

我推荐GitHub：数组sortBy-使用施瓦茨变换的sortBy方法的最佳实现

但现在我们将尝试这种方法简介：sortBy-old.js。
让我们创建一个方法来对能够按某个属性排列对象的数组进行排序。

创建排序函数

var sortBy = (function () {var toString = Object.prototype.toString,// default parser functionparse = function (x) { return x; },// gets the item to be sortedgetItem = 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 : +(a > b));});};  
}());

设置未排序的数据

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"}];

用它

排列数组，按"date"作为String

// 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"}

如果要忽略区分大小写，请设置parser回调：

// sort by @type (ascending) IGNORING case-sensitivesortBy(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" }

如果要将"date"字段转换为Date类型：

// sort by @date (descending) AS Date objectsortBy(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" }

在这里你可以玩代码：jsbin.com/lesebi

由于@陈志立的反馈，与fa lsy值的属性相关的问题得到了修复。

homes.sort(function(a, b){var nameA=a.prices.toLowerCase(), nameB=b.prices.toLowerCase()if (nameA < nameB) //sort string ascendingreturn -1if (nameA > nameB)return 1return 0 //default return value (no sorting)})

如果您使用Underscore.js，请尝试sortBy：

// price is of an integer type_.sortBy(homes, "price");
// price is of a string type_.sortBy(homes, function(home) {return parseInt(home.price);});

虽然仅对单个数组进行排序有点矫枉过正，但此原型函数允许使用dot语法按升序或降序包括嵌套键按任何键对Javascript数组进行排序。

(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<l; i++) ptr = ptr[path[i]];return ptr;};
var comparer = function(a, b) {for (var i = 0, l = keyPaths.length; i < l; i++) {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++) {switch (typeof(arguments[i])) {case "object": saveKeyPath(arguments[i]); break;case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;}}return this.sort(comparer);};})();

用法：

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)"

使用点语法或数组语法按嵌套属性排序：

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)"

按多键排序：

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)"

您可以分叉存储库：https://github.com/eneko/Array.sortBy

嗨，读完这篇文章后，我为我的需求做了一个sort比较器，具有比较多个json属性的功能，我想与你分享。

此解决方案仅按升序比较字符串，但该解决方案可以轻松扩展为每个属性以支持：反向排序、其他数据类型、使用区域设置、强制转换等

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 attributeif (a[comp[0]] === b[comp[0]]) {// if EQ proceed with the next attributesif (comp.length > 1) {return sortComparator(a, b, comp.slice(1));} else {// if no more attributes then return EQreturn 0;}} else {// return less or greatreturn (a[comp[0]] < b[comp[0]] ? -1 : 1)}}
// Sort array homeshomes.sort(function(a, b) {return sortComparator(a, b, ['state', 'city', 'zip']);});
// display the arrayhomes.forEach(function(home) {console.log(home.h_id, home.city, home.state, home.zip, home.price);});

而结果是

$ node sort4 Bevery Hills CA 90210 3192505 New York NY 00010 9625003 Dallas TX 75201 162500

和另一种

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

有结果

$ node sort4 Bevery Hills CA 90210 3192503 Dallas TX 75201 1625005 New York NY 00010 962500

使用lodash.sortBy，（使用通用js的说明，您也可以将cdn的脚本包含标签放在html的顶部）

var sortBy = require('lodash.sortby');// orsortBy = require('lodash').sortBy;

降序

var descendingOrder = sortBy( homes, 'price' ).reverse();

升序

var ascendingOrder = sortBy( homes, 'price' );

使用ECMAScript 6 StoBor的答案可以更简洁地完成：

homes.sort((a, b) => a.price - b.price)

如果您有ES6兼容的浏览器，您可以使用：

• 箭头函数
• Number（）函数
• 的排序（）函数

升序和降序排序顺序之间的差异是比较函数返回值的符号：

var ascending = homes.sort((a, b) => Number(a.price) - Number(b.price));var descending = homes.sort((a, b) => Number(b.price) - Number(a.price));

这是一个工作代码片段：

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

这是《JavaScript： The Good Parts》一书中优雅实现的略微修改版本。

注：这个版本的by是稳定。它保留了第一个排序的顺序，同时执行下一个链式排序。

我添加了isAscending参数。还将其转换为作者推荐的ES6标准和“更新”的好部件。

您可以按多个属性对升序、降序和链式排序进行排序。

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 " + 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 ascendings.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 descendings.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"}// ]

用于对多个数组对象字段进行排序。在arrprop数组中输入您的字段名称，如["a","b","c"]然后传入第二个参数arrsource我们想要排序的实际来源。

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

这可以通过简单的一行值排序函数来实现。运行下面的代码片段以查看演示。

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

仅对于元素值的正常数组：

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]

对于对象数组：

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}]

你需要两个功能

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

然后你可以将其应用于任何对象属性：

 data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price)));

let data = [{label: "one", value:10},{label: "two", value:5},{label: "three", value:1},];
// sort functionsfunction 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;}
// DESCdata.sort((a, b) => desc(a.value, b.value));
document.body.insertAdjacentHTML('beforeend','<strong>DESCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>');
// ASCdata.sort((a, b) => asc(a.value, b.value));
document.body.insertAdjacentHTML('beforeend','<strong>ASCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>');

虽然我知道OP想要对数字数组进行排序，但此问题已被标记为有关字符串的类似问题的答案。对此，上述答案并未考虑对大小写很重要的文本数组进行排序。大多数答案采用字符串值并将其转换为大写/小写，然后以这种或那种方式进行排序。我坚持的要求很简单：

• 按字母顺序排序A-Z
• 同一个单词的大写值应该在小写值之前
• 相同的字母（A/a，B/b）值应组合在一起

我期望的是[ A, a, B, b, C, c ]，但上面的答案返回A, B, C, a, b, c。实际上，我在这个问题上挠头的时间比我想象的要长（这就是为什么我发布这个，希望它能帮助至少另一个人）。虽然有两个用户在标记答案的评论中提到了localeCompare函数，但直到我在四处搜索时偶然发现了这个函数，我才看到这一点。阅读String.prototype.localeCompare（）留档后，我能够想出这个：

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" ]

这告诉函数在小写值之前对大写值进行排序。localeCompare函数中的第二个参数是定义语言环境，但如果您将其保留为undefined，它会自动为您计算语言环境。

这也适用于对对象数组进行排序：

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

我参加聚会有点晚了，但下面是我的分类逻辑。

function getSortedData(data, prop, isAsc) {return data.sort((a, b) => {return (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 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"
}];
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);

价格降序：

homes.sort((x,y) => {return y.price - x.price})

价格升序：

homes.sort((x,y) => {return x.price - y.price})

一个简单的代码：

    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++){document.write(sortByPrice[i].h_id+' '+sortByPrice[i].city+' '+sortByPrice[i].state+' '+sortByPrice[i].zip+' '+sortByPrice[i].price);document.write("<br>");}

您可以使用string1.localeCompare（string2）进行字符串比较

this.myArray.sort((a,b) => {return a.stringProp.localeCompare(b.stringProp);});

注意localCompare是大小写敏感的

 function compareValues(key, order = 'asc') {return function innerSort(a, b) {if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {// property doesn't exist on either objectreturn 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);};}

http://yazilimsozluk.com/sort-array-in-javascript-by-asc-or-desc

更像LINQ的解决方案：

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

优点：

• 属性自动完成
• 扩展阵列原型
• 不改变数组
• 易于在方法链中使用

用法：

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

如果您不想使用任何sort()方法，您可以使用以下方法

function sortObj(obj) {let numArr = []; //the array which just includes prices as Numberlet 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 objnumArr.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);

使用此功能

const r_sort = (a, b, field, asc) => {let reverse = asc ? 1 : -1;if (a[field] > b[field]) {return 1 * reverse;}else if (b[field] > a[field]) {return -1 * reverse;}else {return 0;} }

使用方法

homes = homes.sort((a,b) => r_sort(a,b,price,true)) // true for ascending and false for descending

Array.prototype.sortBy = function(callback) {return this.sort((a, b) => callback(a) - callback(b))}
[1,2,3,2].sortBy(i => i) // [1, 2, 2, 3][1,2,3,2].sortBy(i => i == 2) // [1, 3, 2, 2]