Sắp xếp một mảng các đối tượng theo các giá trị thuộc tính


1334

Tôi đã có các đối tượng sau bằng AJAX và lưu trữ chúng trong một mảng:

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

Làm cách nào để tạo một hàm để sắp xếp các đối tượng theo thuộc pricetính theo thứ tự tăng dần hoặc giảm dần chỉ bằng JavaScript?


cách nhanh nhất là sử dụng mô đun mảng sắp xếp đẳng cấu , hoạt động tự nhiên trong cả trình duyệt và nút, hỗ trợ mọi loại đầu vào, trường được tính toán và thứ tự sắp xếp tùy chỉnh.
Lloyd

Câu trả lời:


1674

Sắp xếp nhà theo giá theo thứ tự tăng dần:

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

Hoặc sau phiên bản ES6:

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

Một số tài liệu có thể được tìm thấy ở đây .


184
Bạn có thể sử dụng string1.localeCompare(string2)để so sánh chuỗi
bradvido

62
Hãy nhớ rằng đó localeCompare()là trường hợp không nhạy cảm . Nếu bạn muốn trường hợp nhạy cảm, bạn có thể sử dụng (string1 > string2) - (string1 < string2). Các giá trị boolean được ép buộc thành số nguyên 0 và 1 để tính chênh lệch.
Don Kirkby

2
Cảm ơn đã cập nhật, @Pointy, tôi không nhớ đã gặp phải vấn đề này, nhưng có lẽ hành vi đã thay đổi trong vài năm qua. Bất kể, localeCompare()tài liệu cho thấy rằng bạn có thể nói rõ rằng bạn muốn phân biệt chữ hoa chữ thường, sắp xếp số và các tùy chọn khác.
Don Kirkby

2
@ sg28 Tôi nghĩ bạn đã hiểu nhầm lời giải thích MDN. Nó không nói rằng chức năng sắp xếp là không đáng tin cậy , nó nói rằng nó không ổn định . Tôi hiểu tại sao điều này có thể gây nhầm lẫn, nhưng đó không phải là một tuyên bố rằng nó không phù hợp để sử dụng. Trong ngữ cảnh sắp xếp các thuật toán, thuật ngữ ổn định có một ý nghĩa cụ thể - rằng các phần tử "bằng nhau" trong danh sách được sắp xếp theo thứ tự như trong đầu vào . Điều này hoàn toàn không liên quan đến ý tưởng về mã không ổn định (tức là chưa sẵn sàng để sử dụng).
Stobor

1
Nếu bạn muốn sắp xếp theo một giá trị chuỗi cụ thể, ví dụ theo thành phố, bạn có thể sử dụng: this.homes.sort ((current, next) => {return current.city.localeCompare (next.city)});
Jorge Valvert

675

Đây là phiên bản linh hoạt hơn, cho phép bạn tạo các hàm sắp xếp có thể sử dụng lại và sắp xếp theo bất kỳ trường nào.

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


7
nickb - bạn đang đọc sai mã. sort_bychạy trong O (1) và trả về một hàm được sử dụng bởi sắp xếp tích hợp (O (N log N)) để so sánh các mục trong danh sách. Tổng độ phức tạp là O (n log n) * O (1) làm giảm xuống O (n log n), hoặc giống như sắp xếp nhanh.
Triptych

1
Một vấn đề tôi gặp phải là với Reverse = false, nó sẽ sắp xếp các số là 1,2,3,4 ... nhưng Chuỗi là z, y, x ...
Abby

4
Một cải tiến nhỏ:var key = primer ? function (x) { return primer(x[field]); } : function (x) { return x[field]; }
ErikE

6
Trong khi [1,-1][+!!reverse]trông mát mẻ, đó là một điều khủng khiếp để làm. Nếu người dùng không thể gọi phương thức của bạn đúng cách, hãy trừng phạt anh ta, không cố gắng bằng cách nào đó có ý nghĩa với nó, bất kể điều gì.
Ingo Bürk

2
Sẽ không tốt hơn để chuẩn bị dữ liệu nguồn, điều này sẽ gây ra phân tích cú pháp liên tiếp khi rõ ràng dữ liệu nguồn cần một số điều chỉnh.
Gerrit Brink

134

Để sắp xếp nó, bạn cần tạo một hàm so sánh lấy hai đối số. Sau đó gọi hàm sort với hàm so sánh đó như sau:

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

Nếu bạn muốn sắp xếp tăng dần, hãy chuyển các biểu thức ở mỗi bên của dấu trừ.


3
Và đây là một tài liệu tham khảo thực sự giải thích chủ đề thay vì nói "nó quá phức tạp, dù sao bạn cũng sẽ không hiểu về nó": developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/
tựa

51

để sắp xếp chuỗi trong trường hợp ai đó cần nó,

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


38

Nếu bạn có trình duyệt tuân thủ ES6, bạn có thể sử dụng:

Sự khác biệt giữa thứ tự sắp xếp tăng dần và giảm dần là dấu hiệu của giá trị được trả về bởi hàm so sánh của bạn:

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

Đây là một đoạn mã làm việc:

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


22

Bạn muốn sắp xếp nó trong Javascript, phải không? Những gì bạn muốn là sort()chức năng . Trong trường hợp này, bạn cần viết một hàm so sánh và chuyển nó tới sort(), vì vậy một cái gì đó như thế này:

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

Bộ so sánh của bạn lấy một trong các giá trị băm lồng nhau bên trong mảng và quyết định giá trị nào cao hơn bằng cách kiểm tra trường "giá".


21

Tôi khuyên dùng GitHub: Array sortBy - một sortByphương thức triển khai tốt nhất sử dụng biến đổi Schwartzian

Nhưng bây giờ chúng ta sẽ thử phương pháp này Gist: sortBy-old.js .
Hãy tạo một phương thức để sắp xếp các mảng có khả năng sắp xếp các đối tượng theo một số thuộc tính.

Tạo chức năng sắp xếp

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 : +(a > b));
    });
  };

}());

Đặt dữ liệu chưa sắp xếp

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

Sử dụng nó

Sắp xếp mảng, bởi "date"như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"}

Nếu bạn muốn bỏ qua trường hợp nhạy cảm, hãy đặt cuộc parsergọi lại:

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

Nếu bạn muốn chuyển đổi "date"trường dưới Datedạng:

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

Tại đây bạn có thể chơi với mã: jsbin.com/lesebi

Nhờ @Ozesh bởi phản hồi của mình, các vấn đề liên quan đến bất động sản với falsy giá trị đã được cố định.


Điều này dường như bị phá vỡ khi một trường là null.
TSNev

Trong trường hợp bạn đang sắp xếp qua các số và bạn gặp '0' ở giữa mảng các đối tượng, bạn có thể nhận thấy rằng đoạn mã trên bị hỏng .. Dưới đây là cách khắc phục nhanh cho điều đó: var checkNaN = function (value) { return Number.isNaN(Number(value)) ? 0 : value; } theo sau: hàm return (mảng, o) { .... a = _getItem.call (o, a); a = checkNaN (a); b = _getItem.call (o, b); b = kiểm traNaN (b); trả về o.desc * (a <b? -1: + (a> b)); });
Ozesh

18

Sử dụng lodash.sortBy , (hướng dẫn sử dụng commonjs, bạn cũng có thể chỉ cần đặt tập lệnh bao gồm tập lệnh cho cdn ở đầu html của bạn)

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

Thứ tự giảm dần

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

Thứ tự tăng dần

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

1
Hoặcconst sortBy = require('lodash/sortBy'); let calendars = sortBy(calendarListResponse.items, cal => cal.summary);
mở

không chắc chắn liệu loadash có thay đổi gần đây hay không, bây giờ nó có tên là OrderByimport { orderBy } from 'lodash'; ... ... return orderBy ( rows, 'fieldName' ).reverse();
montelof

8

Điều này có thể đã đạt được thông qua hàm sắp xếp một dòng valueof () đơn giản . Chạy đoạn mã dưới đây để xem demo.

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


8

Tôi đến bữa tiệc muộn một chút nhưng dưới đây là logic của tôi để sắp xếp.

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

6

Mặc dù tôi biết rằng OP muốn sắp xếp một dãy số, câu hỏi này đã được đánh dấu là câu trả lời cho các câu hỏi tương tự liên quan đến chuỗi. Trong thực tế đó, các câu trả lời ở trên không xem xét việc sắp xếp một mảng văn bản trong đó vỏ là quan trọng. Hầu hết các câu trả lời lấy các giá trị chuỗi và chuyển đổi chúng thành chữ hoa / chữ thường và sau đó sắp xếp theo cách này hay cách khác. Các yêu cầu mà tôi tuân thủ rất đơn giản:

  • Sắp xếp theo thứ tự abc AZ
  • Các giá trị chữ hoa của cùng một từ phải xuất hiện trước các giá trị chữ thường
  • Các giá trị chữ cái (A / a, B / b) phải được nhóm lại với nhau

Những gì tôi mong đợi là [ A, a, B, b, C, c ]nhưng câu trả lời ở trên trở lại A, B, C, a, b, c. Tôi thực sự gãi đầu về điều này lâu hơn tôi muốn (đó là lý do tại sao tôi đăng bài này với hy vọng rằng nó sẽ giúp ít nhất một người khác). Mặc dù hai người dùng đề cập đến localeComparechức năng trong các nhận xét cho câu trả lời được đánh dấu, tôi đã không thấy điều đó cho đến khi tôi tình cờ thấy chức năng này trong khi tìm kiếm xung quanh. Sau khi đọc tài liệu String.prototype.localeCompare () tôi đã có thể đưa ra điều này:

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

Điều này cho biết hàm sắp xếp các giá trị chữ hoa trước các giá trị chữ thường. Tham số thứ hai trong localeComparehàm là xác định miền địa phương nhưng nếu bạn để nó vì undefinednó sẽ tự động tìm ra miền địa phương cho bạn.

Điều này cũng hoạt động tương tự để sắp xếp một mảng các đối tượng:

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

5

Bạn có thể sử dụng sortphương thức JavaScript với chức năng gọi lại:

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

4

Đây là một đỉnh cao của tất cả các câu trả lời ở trên.

Xác thực 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();

        }));
    }


}

bạn có thể giải thích ý nghĩa của việc có * (rev? -1: 1);
TechTurtle

Đó là để đảo ngược thứ tự (tăng dần so với giảm dần), phần rev chỉ lật kết quả bình thường khi đối số rev là đúng. Nếu không, nó sẽ chỉ nhân với 1 mà không làm gì, khi được đặt, nó sẽ nhân kết quả với -1, từ đó đảo ngược kết quả.
bob

3

Để sắp xếp một mảng, bạn phải xác định hàm so sánh. Hàm này luôn khác nhau trên mẫu sắp xếp hoặc thứ tự mong muốn của bạn (nghĩa là tăng dần hoặc giảm dần).

Hãy tạo một số hàm sắp xếp một mảng tăng dần hoặc giảm dần và có chứa các giá trị đối tượng hoặc chuỗi hoặc số.

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

Sắp xếp số (theo thứ tự abc và tăng dần):

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

Sắp xếp số (theo thứ tự abc và giảm dần):

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

Sắp xếp số (số và tăng dần):

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

Sắp xếp số (số và giảm dần):

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

Như trên, sử dụng phương thức sorterpriceAsc và sorterpriceDes với mảng của bạn với khóa mong muốn.

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

3

Tôi cũng đã làm việc với một số loại xếp hạng và nhiều lĩnh vực sắp xếp:

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

Kết quả

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

3

Mặc dù hơi quá mức khi chỉ sắp xếp một mảng duy nhất, hàm nguyên mẫu này cho phép sắp xếp các mảng Javascript theo bất kỳ khóa nào, theo thứ tự tăng dần hoặc giảm dần, bao gồm các khóa lồng nhau , sử dụng dotcú pháp.

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

Sử dụng:

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

Sắp xếp theo thuộc tính lồng nhau với cú pháp dấu chấm hoặc cú pháp mảng:

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

Sắp xếp theo nhiều phím:

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

Bạn có thể rẽ nhánh repo: https://github.com/eneko/Array.sortBy


Tôi thích câu trả lời này rất nhiều vì sortBycú pháp ngắn gọn. Sử dụng đơn giản với Mười một với các trường lồng nhau, trong khi vẫn duy trì khả năng đọc mã tuyệt vời. Cảm ơn bạn!
Đô thị Manfred

3

Với ECMAScript 6 Câu trả lời của StoBor có thể được thực hiện thậm chí ngắn gọn hơn:

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

3

Thứ tự giảm giá:

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

Thứ tự tăng giá:

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

2

Nếu bạn sử dụng Underscore.js , hãy thử sortBy:

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

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

2

Đây là một phiên bản sửa đổi nhỏ của triển khai thanh lịch từ cuốn sách "JavaScript: Các bộ phận tốt".

GHI CHÚ : Phiên bản bynày là ổn định . Nó duy trì thứ tự của loại đầu tiên trong khi thực hiện sắp xếp chuỗi tiếp theo.

Tôi đã thêm isAscendingtham số cho nó. Cũng chuyển đổi nó thành ES6tiêu chuẩn và các phần tốt hơn "mới hơn" theo khuyến nghị của tác giả.

Bạn có thể sắp xếp tăng dần cũng như sắp xếp giảm dần và sắp xếp chuỗi theo nhiều thuộc tính.

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


chúng ta có thể sắp xếp {"first":"Curly","last":"Howard", "property" : {"id" : "1"}}loại mảng theo id không?
Sahu V Kumar

vâng, hàm phải được sửa đổi một chút để có một tham số mới, giả sử, NestedName. Sau đó, bạn gọi byvới name = "property", NestedName = "id"
huyền thoại mã hóa

2

Đối với một mảng bình thường chỉ có các giá trị phần tử:

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]

Đối với một mảng các đối tượng:

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

2

Tạo một hàm và sắp xếp dựa trên đầu vào bằng mã bên dưới

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

2

Bạn có thể sử dụng string1.localeCompare (string2) để so sánh chuỗi

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

Lưu ý rằng localComparelà trường hợp trong nhạy cảm


1

Để sắp xếp trên nhiều trường đối tượng mảng. Nhập tên trường của bạn trong arrpropmảng như ["a","b","c"] sau đó chuyển vào arrsourcenguồn thực tế tham số thứ hai mà chúng tôi muốn sắp xếp.

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

1

Bạn sẽ cần hai chức năng

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

Sau đó, bạn có thể áp dụng điều này cho bất kỳ thuộc tính đối tượng:

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


0

Gần đây tôi đã viết một chức năng phổ quát để quản lý điều này cho bạn nếu bạn muốn sử dụng nó.

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

}

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

0

Xin chào sau khi đọc bài viết này, tôi đã tạo một sortComparator cho nhu cầu của mình, với chức năng so sánh nhiều hơn một thuộc tính json và tôi muốn chia sẻ nó với bạn.

Giải pháp này chỉ so sánh các chuỗi theo thứ tự tăng dần, nhưng giải pháp có thể dễ dàng mở rộng cho từng thuộc tính để hỗ trợ: thứ tự ngược, các loại dữ liệu khác, để sử dụng ngôn ngữ, truyền, v.v.

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

và kết quả là

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

và một loại khác

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

với kết quả

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

0

Một mã đơn giản:

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


0
 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 > 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

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.