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

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

我还处理了一些评级和多个字段排序：

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

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

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

        }));
    }


}

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

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

注意localCompare不区分大小写

有了ECMAScript 6，StoBor的答案可以更加简洁：

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

虽然我知道OP想要对一组数字进行排序，但这个问题已经被标记为字符串相关类似问题的答案。事实上，上面的答案没有考虑对大小写很重要的文本数组进行排序。大多数答案采用字符串值并将其转换为大写/小写，然后以某种方式进行排序。我遵守的要求很简单：

按字母顺序A-Z排序同一单词的大写值应在小写值之前应将相同字母（A/A、B/B）的值分组在一起

我期望的是[A，A，B，B，C，C]，但上面的答案返回A，B，C，A，B，C。实际上，我在这个问题上花了比我想要的时间更长的时间（这就是为什么我发布这个消息，希望它能帮助至少一个人）。虽然两个用户在注释中提到了localeCompare函数，但直到我在四处搜索时偶然发现了该函数之后，我才发现这一点。在阅读了String.product.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函数中的第二个参数是定义语言环境，但如果您将其保留为未定义，它会自动为您计算语言环境。

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

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