Sắp xếp mảng các đối tượng theo khóa đơn với giá trị ngày

Tôi có một mảng các đối tượng với một vài cặp giá trị chính và tôi cần sắp xếp chúng dựa trên 'update_at':

[
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
]

Cách hiệu quả nhất để làm như vậy là gì?

Bạn có thể sử dụng Array.sort.

Đây là một ví dụ:

var arr = [{
    "updated_at": "2012-01-01T06:25:24Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-09T11:25:13Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-05T04:13:24Z",
    "foo": "bar"
  }
]

arr.sort(function(a, b) {
  var keyA = new Date(a.updated_at),
    keyB = new Date(b.updated_at);
  // Compare the 2 dates
  if (keyA < keyB) return -1;
  if (keyA > keyB) return 1;
  return 0;
});

console.log(arr);

Tôi đã trả lời một câu hỏi thực sự tương tự ở đây: Hàm đơn giản để sắp xếp một mảng các đối tượng

Đối với câu hỏi đó, tôi đã tạo ra chức năng nhỏ này có thể làm những gì bạn muốn:

function sortByKey(array, key) {
    return array.sort(function(a, b) {
        var x = a[key]; var y = b[key];
        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    });
}

Phương thức Array.sort () sắp xếp các phần tử của một mảng tại chỗ và trả về mảng. Hãy cẩn thận với Array.sort () vì nó không phải là bất biến . Đối với loại bất biến sử dụng bất biến - sắp xếp .

Phương pháp này là sắp xếp mảng bằng updated_atđịnh dạng ISO hiện tại của bạn . Chúng tôi sử dụngnew Data(iso_string).getTime() để chuyển đổi thời gian ISO sang dấu thời gian Unix. Dấu thời gian Unix là một số mà chúng ta có thể làm toán đơn giản. Chúng tôi trừ dấu thời gian thứ nhất và thứ hai kết quả là; nếu dấu thời gian đầu tiên lớn hơn dấu thứ hai, số trả về sẽ dương. Nếu số thứ hai lớn hơn số thứ nhất, giá trị trả về sẽ âm. Nếu hai cái giống nhau thì lợi nhuận sẽ bằng không. Điều này hoàn toàn phù hợp với các giá trị trả về cần thiết cho hàm nội tuyến.

Đối với ES6 :

arr.sort((a,b) => new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime());

Đối với ES5 :

arr.sort(function(a,b){ 
 return new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime();
});

Nếu bạn thay đổi updated_atdấu thời gian unix của bạn, bạn có thể làm điều này:

Đối với ES6 :

arr.sort((a,b) => a.updated_at - b.updated_at);

Đối với ES5 :

arr.sort(function(a,b){ 
 return a.updated_at - b.updated_at;
});

Tại thời điểm của bài đăng này, các trình duyệt hiện đại không hỗ trợ ES6. Để sử dụng ES6 trong các trình duyệt hiện đại, hãy sử dụng babel để dịch mã sang ES5. Mong đợi trình duyệt hỗ trợ cho ES6 trong tương lai gần.

Array.sort () sẽ lấy lại giá trị trả về của một trong 3 kết quả có thể xảy ra:

• Số dương (mục đầu tiên> mục thứ hai)
• Số âm (mục đầu tiên <mục thứ hai)
• 0 nếu hai mục bằng nhau

Lưu ý rằng giá trị trả về trên hàm nội tuyến có thể là bất kỳ số dương hoặc âm. Array.Sort () không quan tâm số trả về là gì. Nó chỉ quan tâm nếu giá trị trả về là dương, âm hoặc bằng không.

Đối với loại không thay đổi: (ví dụ trong ES6)

const sort = require('immutable-sort');
const array = [1, 5, 2, 4, 3];
const sortedArray = sort(array);

Bạn cũng có thể viết nó theo cách này:

import sort from 'immutable-sort';
const array = [1, 5, 2, 4, 3];
const sortedArray = sort(array);

Nhập - từ bạn thấy là một cách mới để đưa javascript vào ES6 và làm cho mã của bạn trông rất sạch sẽ. Yêu thích cá nhân của tôi.

Sắp xếp không thay đổi không làm thay đổi mảng nguồn thay vì trả về một mảng mới. Sử dụng constđược khuyến nghị trên dữ liệu bất biến.

Đây là phiên bản sửa đổi một chút của câu trả lời @David Brainer-Bankers sắp xếp theo thứ tự abc theo chuỗi hoặc số theo số và đảm bảo rằng các từ bắt đầu bằng chữ in hoa không sắp xếp các từ bắt đầu bằng chữ in thường (ví dụ: "apple, Early" sẽ được hiển thị theo thứ tự đó).

function sortByKey(array, key) {
    return array.sort(function(a, b) {
        var x = a[key];
        var y = b[key];

        if (typeof x == "string")
        {
            x = (""+x).toLowerCase(); 
        }
        if (typeof y == "string")
        {
            y = (""+y).toLowerCase();
        }

        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    });
}

Sử dụng js gạch dưới hoặc lodash,

var arrObj = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
];

arrObj = _.sortBy(arrObj,"updated_at");

_.sortBy() trả về một mảng mới

tham khảo http://underscorejs.org/#sortBy và tài liệu lưu lại https://lodash.com/docs#sortBy

Với sự hỗ trợ ES2015, nó có thể được thực hiện bằng cách:

foo.sort((a, b) => a.updated_at < b.updated_at ? -1 : 1)

Nhập dữ liệu

[
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    }
]

ĐỂ tăng thứ tự

arr.sort(function(a, b){
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA < keyB) return -1;
    if(keyA > keyB) return 1;
    return 0;
});

Ví dụ cho đơn hàng

[
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    }
]

Để giảm dần thứ tự

arr.sort(function(a, b){
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA > keyB) return -1;
    if(keyA < keyB) return 1;
    return 0;
});

Ví dụ cho thứ tự Desc

[
    {
        "gameStatus": "1",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 11:32:04"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-20 10:54:09"
    },
    {
        "gameStatus": "1",
        "userId": "7118ed61-d8d9-4098-a81b-484158806d21",
        "created_at": "2018-12-20 10:50:48"
    },
    {
        "gameStatus": "0",
        "userId": "1a2fefb0-5ae2-47eb-82ff-d1b2cc27875a",
        "created_at": "2018-12-19 18:46:22"
    },
    {
        "gameStatus": "2",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:35:40"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 18:08:24"
    },
    {
        "gameStatus": "0",
        "userId": "c02cfb18-ae66-430b-9524-67d9dd8f6a50",
        "created_at": "2018-12-19 10:42:53"
    }
]

Như câu trả lời này , bạn có thể sử dụng Array.sort.

arr.sort(function(a,b){return new Date(a.updated_at) - new Date(b.updated_at)})

arr = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }
];
arr.sort(function(a,b){return new Date(a.updated_at) - new Date(b.updated_at)});
console.log(arr);

Chỉ là một cách khác, toán học hơn , cách làm tương tự nhưng ngắn hơn :

arr.sort(function(a, b){
    var diff = new Date(a.updated_at) - new Date(b.updated_at);
    return diff/(Math.abs(diff)||1);
});

hoặc theo kiểu mũi tên lambda bóng mượt:

arr.sort((a, b) => {
    var diff = new Date(a.updated_at) - new Date(b.updated_at);
    return diff/(Math.abs(diff)||1);
});

Phương pháp này có thể được thực hiện với bất kỳ đầu vào số nào

Cho đến hôm nay, câu trả lời của @knbody ( https://stackoverflow.com/a/42418963/6778546 ) và @Rocket Hazmat ( https://stackoverflow.com/a/8837511/6778546 ) có thể được kết hợp để cung cấp cho hỗ trợ ES2015 và xử lý ngày chính xác:

arr.sort((a, b) => {
   const dateA = new Date(a.updated_at);
   const dateB = new Date(b.updated_at);
   return dateA - dateB;
});

Tôi đã tạo ra một hàm sắp xếp trong Bản mô tả mà chúng ta có thể sử dụng để tìm kiếm chuỗi, ngày và số trong mảng các đối tượng. Nó cũng có thể sắp xếp trên nhiều lĩnh vực.

export type SortType = 'string' | 'number' | 'date';
export type SortingOrder = 'asc' | 'desc';

export interface SortOptions {
  sortByKey: string;
  sortType?: SortType;
  sortingOrder?: SortingOrder;
}


class CustomSorting {
    static sortArrayOfObjects(fields: SortOptions[] = [{sortByKey: 'value', sortType: 'string', sortingOrder: 'desc'}]) {
        return (a, b) => fields
          .map((field) => {
            if (!a[field.sortByKey] || !b[field.sortByKey]) {
              return 0;
            }

            const direction = field.sortingOrder === 'asc' ? 1 : -1;

            let firstValue;
            let secondValue;

            if (field.sortType === 'string') {
              firstValue = a[field.sortByKey].toUpperCase();
              secondValue = b[field.sortByKey].toUpperCase();
            } else if (field.sortType === 'number') {
              firstValue = parseInt(a[field.sortByKey], 10);
              secondValue = parseInt(b[field.sortByKey], 10);
            } else if (field.sortType === 'date') {
              firstValue = new Date(a[field.sortByKey]);
              secondValue = new Date(b[field.sortByKey]);
            }
            return firstValue > secondValue ? direction : firstValue < secondValue ? -(direction) : 0;

          })
          .reduce((pos, neg) => pos ? pos : neg, 0);
      }
    }
}

Sử dụng:

const sortOptions = [{
      sortByKey: 'anyKey',
      sortType: 'string',
      sortingOrder: 'asc',
    }];

arrayOfObjects.sort(CustomSorting.sortArrayOfObjects(sortOptions));

Sắp xếp theo ngày được định dạng ISO có thể tốn kém, trừ khi bạn giới hạn máy khách ở các trình duyệt mới nhất và tốt nhất, có thể tạo dấu thời gian chính xác bằng cách phân tích chuỗi ngày.

Nếu bạn chắc chắn về đầu vào của mình và bạn biết nó sẽ luôn là yyyy-mm-ddThh: mm: ss và GMT (Z), bạn có thể trích xuất các chữ số từ mỗi thành viên và so sánh chúng như các số nguyên

array.sort(function(a,b){
    return a.updated_at.replace(/\D+/g,'')-b.updated_at.replace(/\D+/g,'');
});

Nếu ngày có thể được định dạng khác nhau, bạn có thể cần thêm một cái gì đó cho những người bị thách thức iso:

Date.fromISO: function(s){
    var day, tz,
    rx=/^(\d{4}\-\d\d\-\d\d([tT ][\d:\.]*)?)([zZ]|([+\-])(\d\d):(\d\d))?$/,
    p= rx.exec(s) || [];
    if(p[1]){
        day= p[1].split(/\D/).map(function(itm){
            return parseInt(itm, 10) || 0;
        });
        day[1]-= 1;
        day= new Date(Date.UTC.apply(Date, day));
        if(!day.getDate()) return NaN;
        if(p[5]){
            tz= (parseInt(p[5], 10)*60);
            if(p[6]) tz+= parseInt(p[6], 10);
            if(p[4]== '+') tz*= -1;
            if(tz) day.setUTCMinutes(day.getUTCMinutes()+ tz);
        }
        return day;
    }
    return NaN;
}
if(!Array.prototype.map){
    Array.prototype.map= function(fun, scope){
        var T= this, L= T.length, A= Array(L), i= 0;
        if(typeof fun== 'function'){
            while(i< L){
                if(i in T){
                    A[i]= fun.call(scope, T[i], i, T);
                }
                ++i;
            }
            return A;
        }
    }
}
}

Để hoàn thiện ở đây là một triển khai chung ngắn có thể có của sortBy:

function sortBy(list, keyFunc) {
  return list.sort((a,b) => keyFunc(a) - keyFunc(b));
}

sortBy([{"key": 2}, {"key": 1}], o => o["key"])

Lưu ý rằng điều này sử dụng phương pháp sắp xếp mảng sắp xếp tại chỗ. đối với một bản sao, bạn có thể sử dụng Array.concat () hoặc Array.slice (0) hoặc phương thức tương tự để tạo một bản sao.

Với điều này, chúng ta có thể truyền một hàm chính để sử dụng cho việc sắp xếp

Array.prototype.sortBy = function(key_func, reverse=false){
    return this.sort( (a, b) => {
        var keyA = key_func(a),
            keyB = key_func(b);
        if(keyA < keyB) return reverse? 1: -1;
        if(keyA > keyB) return reverse? -1: 1;
        return 0;
    }); 
}

Sau đó, ví dụ nếu chúng ta có

var arr = [ {date: "01/12/00", balls: {red: "a8",  blue: 10}},
            {date: "12/13/05", balls: {red: "d6" , blue: 11}},
            {date: "03/02/04", balls: {red: "c4" , blue: 15}} ]

Chúng tôi có thể làm

arr.sortBy(el => el.balls.red)
/* would result in
[ {date: "01/12/00", balls: {red: "a8", blue: 10}},
  {date: "03/02/04", balls: {red: "c4", blue: 15}},
  {date: "12/13/05", balls: {red: "d6", blue: 11}} ]
*/

hoặc là

arr.sortBy(el => new Date(el.date), true)   // second argument to reverse it
/* would result in
[ {date: "12/13/05", balls: {red: "d6", blue:11}},
  {date: "03/02/04", balls: {red: "c4", blue:15}},
  {date: "01/12/00", balls: {red: "a8", blue:10}} ]
*/

hoặc là

arr.sortBy(el => el.balls.blue + parseInt(el.balls.red[1]))
/* would result in
[ {date: "12/13/05", balls: {red: "d6", blue:11}},    // red + blue= 17
  {date: "01/12/00", balls: {red: "a8", blue:10}},    // red + blue= 18
  {date: "03/02/04", balls: {red: "c4", blue:15}} ]   // red + blue= 19
*/

Bạn có thể sử dụng thư viện tiện ích Lodash để giải quyết vấn đề này (đây là một thư viện khá hiệu quả):

const data = [{
    "updated_at": "2012-01-01T06:25:24Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-09T11:25:13Z",
    "foo": "bar"
  },
  {
    "updated_at": "2012-01-05T04:13:24Z",
    "foo": "bar"
  }
]

const ordered = _.orderBy(
  data,
  function(item) {
    return item.updated_at;
  }
);

console.log(ordered)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

Bạn có thể tìm tài liệu ở đây: https://lodash.com/docs/4.17.15#orderBy

Bạn có thể tạo một bao đóng và chuyển nó theo cách đó đây là ví dụ của tôi làm việc

$.get('https://data.seattle.gov/resource/3k2p-39jp.json?$limit=10&$where=within_circle(incident_location, 47.594972, -122.331518, 1609.34)', 
  function(responce) {

    var filter = 'event_clearance_group', //sort by key group name
    data = responce; 

    var compare = function (filter) {
        return function (a,b) {
            var a = a[filter],
                b = b[filter];

            if (a < b) {
                return -1;
            } else if (a > b) {
                return 1;
            } else {
                return 0;
            }
        };
    };

    filter = compare(filter); //set filter

    console.log(data.sort(filter));
});

var months = [
    {
        "updated_at" : "2012-01-01T06:25:24Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-09T11:25:13Z",
        "foo" : "bar"
    },
    {
        "updated_at" : "2012-01-05T04:13:24Z",
        "foo" : "bar"
    }];
months.sort((a, b)=>{
    var keyA = new Date(a.updated_at),
        keyB = new Date(b.updated_at);
    // Compare the 2 dates
    if(keyA < keyB) return -1;
    if(keyA > keyB) return 1;
    return 0;
});
console.log(months);

• Sử dụng Array.sort() để sắp xếp một mảng
• Sao chép mảng bằng cách sử dụng toán tử lây lan ( …) để làm cho hàm thuần túy
• Sắp xếp theo khóa mong muốn ( updated_at)
• Chuyển đổi chuỗi ngày thành đối tượng ngày
• Array.sort() hoạt động bằng cách trừ hai thuộc tính từ mục hiện tại và mục tiếp theo nếu đó là số / đối tượng mà bạn có thể thực hiện các thao tác loạn nhịp

const input = [
  {
    updated_at: '2012-01-01T06:25:24Z',
    foo: 'bar',
  },
  {
    updated_at: '2012-01-09T11:25:13Z',
    foo: 'bar',
  },
  {
    updated_at: '2012-01-05T04:13:24Z',
    foo: 'bar',
  }
];

const sortByUpdatedAt = (items) => [...items].sort((itemA, itemB) => new Date(itemA.updated_at) - new Date(itemB.updated_at));

const output = sortByUpdatedAt(input);

console.log(input);
/*
[ { updated_at: '2012-01-01T06:25:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-09T11:25:13Z', foo: 'bar' }, 
  { updated_at: '2012-01-05T04:13:24Z', foo: 'bar' } ]
*/
console.log(output)
/*
[ { updated_at: '2012-01-01T06:25:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-05T04:13:24Z', foo: 'bar' }, 
  { updated_at: '2012-01-09T11:25:13Z', foo: 'bar' } ]
*/

Tôi phải đối mặt với điều tương tự, vì vậy tôi xử lý vấn đề này với lý do chung chung và tôi xây dựng một chức năng cho việc này:

//example:
//array: [{name: 'idan', workerType: '3'}, {name: 'stas', workerType: '5'}, {name: 'kirill', workerType: '2'}]
//keyField: 'workerType'
// keysArray: ['4', '3', '2', '5', '6']

sortByArrayOfKeys = (array, keyField, keysArray) => {
    array.sort((a, b) => {
        const aIndex = keysArray.indexOf(a[keyField])
        const bIndex = keysArray.indexOf(b[keyField])
        if (aIndex < bIndex) return -1;
        if (aIndex > bIndex) return 1;
        return 0;
    })
}