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

我使用AJAX获得了以下对象并将它们存储在数组中：

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

如何创建仅使用JavaScript 按 price属性按升序 或降序对对象进行排序的函数？

#1楼

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

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

#2楼

为了对数组排序，必须定义一个比较器函数。此功能始终在您所需的排序模式或顺序（即升序或降序）上有所不同。

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

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

#3楼

这是以上所有答案的总结。

小提琴验证： 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// 50if (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();}));}}

#4楼

我还使用某种等级和多个字段进行排序：

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

#5楼

我最近编写了一个通用函数来为您管理此功能。

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

#6楼

我推荐GitHub：Array sortBy-使用Schwartzian变换的sortBy方法的最佳实现

但是现在我们将尝试这种方法Gist：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-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" }

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

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

在这里您可以使用以下代码： jsbin.com/lesebi

感谢@Ozesh的反馈，解决了与伪造属性有关的问题。

#7楼

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

#8楼

如果你使用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);});

#9楼

尽管仅对单个数组进行排序有点过头，但是该原型函数允许使用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

#10楼

在阅读本文之后，您好，我为我的需要做了一个sortComparator，它具有比较多个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 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);
});

结果是

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

还有另一种

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

结果

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

#11楼

使用lodash.sortBy （使用commonjs的指令，您也可以将cdn的脚本include-tag放在html的顶部）

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

降序

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

升序

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

#12楼

使用ECMAScript 6，StoBor的答案可以更加简洁：

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

#13楼

如果您拥有符合ES6的浏览器，则可以使用：

箭头功能
Number（）函数
sort（）函数

升序和降序排序之间的区别是您的compare函数返回的值的符号：

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

#14楼

这是“ 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 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"} // ]

#15楼

用于对多个数组对象字段进行排序。在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;
}

#16楼

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

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

#17楼

仅对于元素的普通数组，值：

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

#18楼

您将需要两个功能

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 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>' + JSON.stringify(data) +'</pre>' ); // ASC data.sort((a, b) => asc(a.value, b.value)); document.body.insertAdjacentHTML( 'beforeend', '<strong>ASCending sorted</strong><pre>' + JSON.stringify(data) +'</pre>' );

#19楼

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

按字母AZ排序
同一单词的大写值应位于小写值之前
相同的字母（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" }));

#20楼

我参加聚会的时间不晚，但下面是我排序的逻辑。

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

#21楼

使用下面的代码创建一个函数并基于输入进行排序

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

#22楼

价格降序：

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

价格升序：

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

#23楼

一个简单的代码：

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

#24楼

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

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

如果要升序排序，请在减号的每一侧切换表达式。

#25楼

按价格升序对房屋进行排序：

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

或在ES6版本之后：

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

一些文档可以在这里找到。

#26楼

您想用Javascript排序吗？您想要的是sort()函数。在这种情况下，您需要编写一个比较器函数并将其传递给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));

您的比较器将数组内的每个嵌套哈希值之一作为对象，然后通过检查“价格”字段来确定哪个更高。

#27楼

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

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

#28楼

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

 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, AZ console.log(homes.sort(sort_by('city', false, (a) => a.toUpperCase() )));