我使用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属性按升序或降序对对象进行排序?


当前回答

这里是以上所有答案的顶点。

Fiddle验证:http://jsfiddle.net/bobberino/4qqk3/

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 < 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(/[^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();

        }));
    }


}

其他回答

有了ECMAScript 6,StoBor的答案可以更加简洁:

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

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

const sort_by=(字段,反转,引物)=>{常量键=引物?函数(x){返回底漆(x[字段])} :函数(x){返回x[字段]};反转=!颠倒1 : -1;返回函数(a,b){返回a=键(a),b=键(b),反转*((a>b)-(b>a));}}//现在您可以随意按任何字段排序。。。const homes=[{h_id:“3”,城市:“达拉斯”,州:“TX”,邮编:“75201”,价格:“162500”},{h_id:“4”,城市“贝弗利山”,州“CA”,邮编“90210”,价格“319250”},{h_id:”5“,城市:”纽约“,州:”NY“,邮编:”00010“,价格:”962500“}];//按价格从高到低排序console.log(homes.sort(sort_by('price',true,parseInt)));//按城市排序,不区分大小写,A-Zconsole.log(homes.sort(sort_by('city',false,(a)=>a.toUpperCase())));

更像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=函数(选择器,desc=false){return[…this].sort((a,b)=>{a=选择器(a);b=选择器(b);如果(a==b)返回0;返回(desc?a>b:a<b)-1 : 1;});};var家=[{“h_id”:“3”,“城市”:“达拉斯”,“状态”:“TX”,“zip”:“75201”,“价格”:“162500”}, {“h_id”:“4”,“城市”:“贝弗利山”,“状态”:“CA”,“zip”:“90210”,“price”:“319250”}, {“h_id”:“5”,“城市”:“纽约”,“州”:“NY”,“zip”:“00010”,“价格”:“962500”}];let sorted_homes=homes.orderBy(h=>parseFloat(h.price));console.log(“按价格排序”,sorted_homes);let sorted_homes_desc=homes.orderBy(h=>h.city,true);console.log(“按城市降序排序”,sorted_home_desc);

要对数组进行排序,必须定义一个比较器函数。此函数始终根据您所需的排序模式或顺序(即升序或降序)而不同。

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

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