如何按日期属性对对象数组进行排序?

How to sort an object array by date property?

提问人:ryandlf 提问时间:4/12/2012 最后编辑:leonheessryandlf 更新时间:10/27/2023 访问量:1533761

问:

假设我有一个包含几个对象的数组:

var array = [{id: 1, date: Mar 12 2012 10:00:00 AM}, {id: 2, date: Mar 8 2012 08:00:00 AM}];

如何按日期元素对这个数组进行排序,从最接近当前日期和时间的日期开始?请记住,数组可能有很多对象,但为了简单起见,我使用了 2。

我会使用排序功能和自定义比较器吗?

JavaScript 日期时间

评论

0赞 toshi 8/17/2019
如果使用 Date 构造函数,请检查第一个 stackoverflow.com/questions/5619202/...
2赞 Lloyd 10/22/2019
最快的方法是使用同构排序数组模块,该模块在浏览器和节点中都本地工作,支持任何类型的输入、计算字段和自定义排序顺序。
3赞 d13 11/19/2021
似乎这个问题还没有得到解答。以下答案均未解释如何“从最接近当前日期的日期订购”。
0赞 Fed 10/8/2022
没有直接关系,但如果有人试图对从数据库获取的数据进行排序,则应在 SQL 查询中完成。
0赞 glennsl 6/26/2023
@Fed 不,不应该。这完全取决于具体情况。在很多情况下,即使此特定数据来自数据库,对客户端进行排序也是有意义的。

答:

2165赞 Phrogz 4/12/2012 #1

最简单的答案

array.sort(function(a,b){
  // Turn your strings into dates, and then subtract them
  // to get a value that is either negative, positive, or zero.
  return new Date(b.date) - new Date(a.date);
});

更通用的答案

array.sort(function(o1,o2){
  if (sort_o1_before_o2)    return -1;
  else if(sort_o1_after_o2) return  1;
  else                      return  0;
});

或者更简洁地说:

array.sort(function(o1,o2){
  return sort_o1_before_o2 ? -1 : sort_o1_after_o2 ? 1 : 0;
});

通用的、有力的答案

在所有数组上使用 Schwartzian 变换定义一个自定义的不可枚举函数:sortBy

(function(){
  if (typeof Object.defineProperty === 'function'){
    try{Object.defineProperty(Array.prototype,'sortBy',{value:sb}); }catch(e){}
  }
  if (!Array.prototype.sortBy) Array.prototype.sortBy = sb;

  function sb(f){
    for (var i=this.length;i;){
      var o = this[--i];
      this[i] = [].concat(f.call(o,o,i),o);
    }
    this.sort(function(a,b){
      for (var i=0,len=a.length;i<len;++i){
        if (a[i]!=b[i]) return a[i]<b[i]?-1:1;
      }
      return 0;
    });
    for (var i=this.length;i;){
      this[--i]=this[i][this[i].length-1];
    }
    return this;
  }
})();

像这样使用它:

array.sortBy(function(o){ return o.date });

如果您的日期不能直接比较,请从中制作一个可比较的日期,例如

array.sortBy(function(o){ return new Date( o.date ) });

如果返回值数组,还可以使用它按多个条件进行排序:

// Sort by date, then score (reversed), then name
array.sortBy(function(o){ return [ o.date, -o.score, o.name ] };

有关详细信息,请参阅 http://phrogz.net/JS/Array.prototype.sortBy.js

评论

8赞 corbacho 2/3/2014
为什么不在简单答案中?return b-a;
111赞 MikeMurko 7/13/2019
不建议在 sort 方法中创建新的 Date 对象。由于这个原因,专门遇到了生产性能问题。不要在排序方法中分配内存(和 GC)。
19赞 Surendranath Sonawane 1/2/2020
第一个 eg 语法在 angular7 上给出错误:算术运算的左侧必须是 'any'、'number'、'bigint' 或枚举类型
11赞 MikeMurko 5/17/2020
@Sireini 取决于日期属性的类型/格式,但如果它是标准的“日期”对象,那么@Gal的响应速度最快,没有分配。在 Chrome 中,评论实际上非常慢(jsperf.com/date-sort-mm/1)。如果日期只是 ISO 字符串,则最快地比较它们。a-ba > b ? 1 : a < b ? -1 : 0
35赞 Edwardcho Vaklinov 6/24/2020
如果您使用的是 TS 并想按日期属性对对象进行排序,则可以使用第一个选项,如下所示:降序,反转“a”和“b”的升序顺序return +b.date - +a.date;
127赞 qw3n 4/12/2012 #2

更正 JSON 后,这现在应该适合您:

var array = [{id: 1, date:'Mar 12 2012 10:00:00 AM'}, {id: 2, date:'Mar 8 2012 08:00:00 AM'}];


array.sort(function(a, b) {
    var c = new Date(a.date);
    var d = new Date(b.date);
    return c-d;
});
66赞 gabitzish 4/12/2012 #3

您的数据需要一些更正:

var array = [{id: 1, date: "Mar 12 2012 10:00:00 AM"},{id: 2, date: "Mar 28 2012 08:00:00 AM"}];

更正数据后,可以使用以下代码:

function sortFunction(a,b){  
    var dateA = new Date(a.date).getTime();
    var dateB = new Date(b.date).getTime();
    return dateA > dateB ? 1 : -1;  
}; 

var array = [{id: 1, date: "Mar 12 2012 10:00:00 AM"},{id: 2, date: "Mar 28 2012 08:00:00 AM"}];
array.sort(sortFunction);​

评论

9赞 Danchat 1/15/2020
对于任何使用 Typescript 的人,我都能够使用此函数按日期排序,而其他使用日期减法的人则失败了。
0赞 quick007 12/20/2021
有何不同?我看到了不同类型的引号和空格,但这并不重要,还是我遗漏了什么?
354赞 Gal 8/15/2013 #4

@Phrogz答案都很棒,但这里有一个很棒的、更简洁的答案:

array.sort(function(a,b){return a.getTime() - b.getTime()});

使用箭头函数方式

array.sort((a,b)=>a.getTime()-b.getTime());

在这里找到: 在 Javascript 中对日期进行排序

评论

52赞 yckart 2/26/2017
直接做数学运算也行得通。所以,(es6)a - barray.sort((a, b) => a - b)
2赞 aRIEL 2/15/2022
a.getTime() - b.getTime()然后要快得多a - b
0赞 serge 5/23/2022
简明扼要,简明扼要,如果你只有定义的日期......
3赞 Salman A 6/30/2022
澄清一下,减去两个对象就足够了。运算符调用对象的方法进行减法;并返回与 相同的值。Date-valueOfDate.valueOfDate.getTime
11赞 Kepi 8/9/2022
TypeScript 在简单的 “” 解决方案上抛出一个错误,但它适用于该方法。a - bgetTime
30赞 jherax 11/5/2014 #5

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

但现在我们将尝试这种方法 Gist:sortBy-old.js
让我们创建一个对数组进行排序的方法,以便能够按某些属性排列对象。

创建排序函数

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

设置未排序的数据

var data = [
  {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type: "cash"},
  {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
  {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: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-31T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "visa"},
  {date: "2011-11-01T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
  {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-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 the object by a property (ascending)
//sorting takes into account uppercase and lowercase
sortBy(data, { prop: "date" });

如果要忽略字母大小写,请设置回调:"parser"

//sort the object by a property (descending)
//sorting ignores uppercase and lowercase
sortBy(data, {
    prop: "date",
    desc: true,
    parser: function (item) {
        //ignore case sensitive
        return item.toUpperCase();
    }
});

如果要将“日期”字段视为类型:Date

//sort the object by a property (ascending)
//sorting parses each item to Date type
sortBy(data, {
    prop: "date",
    parser: function (item) {
        return new Date(item);
    }
});

在这里,你可以玩上面的例子:
jsbin.com/lesebi

评论

1赞 skribbz14 6/21/2018
IE11 的行有问题: if (toString.call(cfg) !== “[object Object]”) cfg = {};如果将其替换为 if (Object.prototype.toString.call(cfg) !== “[object Object]”) cfg = {};你也会对IE11感到满意。
2赞 Andi 1/2/2015 #6

对于任何想要按日期排序(英国格式)的人,我使用了以下内容:

//Sort by day, then month, then year
for(i=0;i<=2; i++){
    dataCourses.sort(function(a, b){

        a = a.lastAccessed.split("/");
        b = b.lastAccessed.split("/");

        return a[i]>b[i] ? -1 : a[i]<b[i] ? 1 : 0;
    }); 
}
15赞 Robert 5/18/2015 #7

您可以在下划线 js 中使用 sortBy。

http://underscorejs.org/#sortBy

样本:

var log = [{date: '2016-01-16T05:23:38+00:00', other: 'sample'}, 
           {date: '2016-01-13T05:23:38+00:00',other: 'sample'}, 
           {date: '2016-01-15T11:23:38+00:00', other: 'sample'}];

console.log(_.sortBy(log, 'date'));
9赞 Amay Kulkarni 6/17/2015 #8

我能够使用以下行实现排序:

array.sort(function(a, b)
{
   if (a.DueDate > b.DueDate) return 1;
   if (a.DueDate < b.DueDate) return -1;
})
9赞 James111 6/15/2016 #9

我将在这里添加这一点,因为某些用途可能无法解决如何反转这种排序方法。

要按“即将到来”进行排序,我们可以简单地交换 a 和 b,如下所示:

your_array.sort ( (a, b) => {
      return new Date(a.DateTime) - new Date(b.DateTime);
});

请注意,现在在左手边,在右手边,:D!ab

2赞 loretoparisi 5/11/2017 #10

我刚刚采用了上面描述的 Schwartzian 变换并作为函数。它需要 、 排序和布尔值作为输入:arrayfunction

function schwartzianSort(array,f,asc){
    for (var i=array.length;i;){
      var o = array[--i];
      array[i] = [].concat(f.call(o,o,i),o);
    }
    array.sort(function(a,b){
      for (var i=0,len=a.length;i<len;++i){
        if (a[i]!=b[i]) return a[i]<b[i]?asc?-1:1:1;
      }
      return 0;
    });
    for (var i=array.length;i;){
      array[--i]=array[i][array[i].length-1];
    }
    return array;
  }

function schwartzianSort(array, f, asc) {
  for (var i = array.length; i;) {
    var o = array[--i];
    array[i] = [].concat(f.call(o, o, i), o);
  }
  array.sort(function(a, b) {
    for (var i = 0, len = a.length; i < len; ++i) {
      if (a[i] != b[i]) return a[i] < b[i] ? asc ? -1 : 1 : 1;
    }
    return 0;
  });
  for (var i = array.length; i;) {
    array[--i] = array[i][array[i].length - 1];
  }
  return array;
}

arr = []
arr.push({
  date: new Date(1494434112806)
})
arr.push({
  date: new Date(1494434118181)
})
arr.push({
  date: new Date(1494434127341)
})

console.log(JSON.stringify(arr));

arr = schwartzianSort(arr, function(o) {
  return o.date
}, false)
console.log("DESC", JSON.stringify(arr));

arr = schwartzianSort(arr, function(o) {
  return o.date
}, true)
console.log("ASC", JSON.stringify(arr));

21赞 Edison D'souza 12/12/2017 #11

当您的日期采用此格式 (dd/mm/yyyy) 时,应该这样做。

  sortByDate(arr) {
    arr.sort(function(a,b){
      return Number(new Date(a.readableDate)) - Number(new Date(b.readableDate));
    });

    return arr;
  }

然后致电sortByDate(myArr);

2赞 daviestar 1/12/2018 #12

如果像我一样,您有一个日期格式的数组,例如您想在不太具体的日期之前订购更具体的日期,我想出了这个方便的功能:YYYY[-MM[-DD]]

function sortByDateSpecificity(a, b) {
  const aLength = a.date.length
  const bLength = b.date.length
  const aDate = a.date + (aLength < 10 ? '-12-31'.slice(-10 + aLength) : '')
  const bDate = b.date + (bLength < 10 ? '-12-31'.slice(-10 + bLength) : '')
  return new Date(aDate) - new Date(bDate)
}
6赞 Rajiv Shrivastava 6/27/2018 #13
Adding absolute will give better results

var datesArray =[
      {"some":"data1","date": "2018-06-30T13:40:31.493Z"},
      {"some":"data2","date": "2018-07-04T13:40:31.493Z"},
      {"some":"data3","date": "2018-06-27T13:40:54.394Z"}
   ]

var sortedJsObjects = datesArray.sort(function(a,b){ 
    return Math.abs(new Date(a.date) - new Date(b.date)) 
});

评论

0赞 RobG 8/27/2020
与当前日期的比较在哪里?
3赞 Shravan Shetty 10/22/2018 #14
["12 Jan 2018" , "1 Dec 2018", "04 May 2018"].sort(function(a,b) {
    return new Date(a).getTime() - new Date(b).getTime()
})

评论

1赞 dthulke 10/22/2018
请简要说明您的答案并检查您的代码格式。
0赞 Oliver Dixon 1/7/2019
旧日期将失败。
8赞 Aravinda Meewalaarachchi 7/19/2019 #15

我个人使用以下方法来对日期进行排序。

let array = ["July 11, 1960", "February 1, 1974", "July 11, 1615", "October 18, 1851", "November 12, 1995"];

array.sort(function(date1, date2) {
   date1 = new Date(date1);
   date2 = new Date(date2);
   if (date1 > date2) return 1;
   if (date1 < date2) return -1;
})
4赞 Yanov 1/31/2020 #16

谢谢Ganesh Sanap。按日期字段从旧到新对项目进行排序。使用它

 myArray = [{transport: "Air",
             load: "Vatican Vaticano",
             created: "01/31/2020"},
            {transport: "Air",
             load: "Paris",
             created: "01/30/2020"}] 

        myAarray.sort(function(a, b) {
            var c = new Date(a.created);
            var d = new Date(b.created);
            return c-d;
        });

评论

1赞 Yanov 2/1/2020
减去的原因是什么?
0赞 Donald Shahini 3/19/2021
c 和 d 日期转换为时间戳,减号用于比较这些值。这里是排序的文档和排序中使用的比较方法的解释:developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...我希望它能:)
14赞 varad_s 8/24/2020 #17

使用 ES6 箭头函数,您可以进一步编写一行简洁的代码(不包括变量声明)。

例如:

var isDescending = true; //set to false for ascending
console.log(["8/2/2020","8/1/2020","8/13/2020", "8/2/2020"].sort((a,b) => isDescending ? new Date(b).getTime() - new Date(a).getTime() : new Date(a).getTime() - new Date(b).getTime()));

由于上述日期不存在时间,因此 Date 对象将考虑遵循默认时间进行排序:

00:00:00

该代码将适用于升序和降序排序。 只需根据需要更改变量的值即可。isDescending

14赞 sunwarr10r 1/22/2021 #18

带有日期的字符串在 JavaScript 中是可比的(如果它们在语法上相同),例如:

'2020-12-01' < '2020-12-02' == true

这意味着您可以在自定义排序函数中使用此表达式:

var arr = [{id:1, date:'2020-12-01'}, {id:1, date:'2020-12-15'}, {id:1, date:'2020-12-12'}]

function sortByDate(a, b) {
    if (a.date < b.date) {
        return 1;
    }
    if (a.date > b.date) {
        return -1;
    }
    return 0;
}

const sorted = arr.sort(sortByDate);
console.log(sorted);

-1赞 tcf01 2/4/2021 #19

感谢您在上面的精彩回答。我想了一个有点复杂的答案。只适合那些想要比较不同答案的人。

const data = [
    '2-2018', '1-2018',
    '3-2018', '4-2018',
    '1-2019', '2-2019',
    '3-2019', '4-2019',
    '1-2020', '3-2020',
    '4-2020', '1-2021'
]

let eachYearUniqueMonth = data.reduce((acc, elem) => {
    const uniqueDate = Number(elem.match(/(\d+)\-(\d+)/)[1])
    const uniqueYear = Number(elem.match(/(\d+)\-(\d+)/)[2])


    if (acc[uniqueYear] === undefined) {
        acc[uniqueYear] = []        
    } else{    
       if (acc[uniqueYear]  && !acc[uniqueYear].includes(uniqueDate)) {
          acc[uniqueYear].push(uniqueDate)
      }
    }

    return acc;
}, {})


let group = Object.keys(eachYearUniqueMonth).reduce((acc,uniqueYear)=>{
    eachYearUniqueMonth[uniqueYear].forEach(uniqueMonth=>{
    acc.push(`${uniqueYear}-${uniqueMonth}`)
  })
  
  return acc;
},[])

console.log(group);   //["2018-1", "2018-3", "2018-4", "2019-2", "2019-3", "2019-4", "2020-3", "2020-4"]


评论

0赞 contractorwolf 8/21/2023
太矫枉过正了,太复杂了
20赞 Rohan Kumar Thakur 7/6/2021 #20

arr 是一个对象数组,每个对象都有 date_prop 即日期。您可以按降序/降序排序,如下所示

 arr = arr.sort(function (a, b) {
      var dateA = new Date(a.date_prop).getTime();
      var dateB = new Date(b.date_prop).getTime();
      return dateA < dateB ? 1 : -1; // ? -1 : 1 for ascending/increasing order
    });

评论

3赞 Salman A 5/11/2022
如果日期相同,则必须返回 0
78赞 Saran 10/28/2021 #21

以上答案都很好😊,这是我以 ES6 方式对日期进行排序的实现,我正在使用(是全局 Date 对象)这会将 Date 的字符串表示转换为毫秒数。而不是每次都实例化对象。Date.parsenew Date

var array = ["2021-08-10T07:24:30.087+0000" , "2021-09-30T07:24:30.087+0000", "2021-10-13T07:24:30.087+0000"];

// sorting with latest date
array.sort((a,b) => Date.parse(b) - Date.parse(a))

评论

1赞 SAMUEL 11/11/2021
答案片段不适合该问题。您可以更新答案以匹配问题或删除问题。
4赞 Coreus 11/3/2022
这会对常规的日期数组进行排序,而不是对具有日期属性的对象数组进行排序,这就是问题所在。
0赞 fredrivett 11/30/2022
这是唯一适用于 TypeScript 的答案(另请参阅此处的答案:stackoverflow.com/a/54634547/827129)
0赞 Chris Sherriff 9/21/2023
只是一个警告,这似乎不适用于英国日期(格式为 dd/mm/yyyy)。例如:Date.parse("23/05/2023") = NaN
5赞 Daggie Blanqx - Douglas Mwangi 5/5/2022 #22

这是解决问题的最短方法。

  var array = [{id: 1, date: 'Mar 12 2012 10:00:00 AM'}, {id: 2, date: 'Mar 8 2012 08:00:00 AM'}];

  var sortedArray = array.sort((a,b) => Date.parse(new Date(a.date)) - Date.parse(new Date(b.date)));

评论

2赞 Hyzyr 5/13/2022
如果您只解析数据而不是新日期,会更准确:Date.parse(a.date)
12赞 Benjamin Merchin 10/5/2022 #23

简单的一行解决方案,让我对日期进行排序:

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

评论

0赞 Jason 2/11/2023
sort 是三态。它应该返回 -1,0,1,并且返回任何小于此值的内容都会导致排序算法的奇怪行为。
0赞 Benjamin Merchin 2/12/2023
甚至对于排序日期?这对我来说效果很好。
0赞 Kamal Zaitar 8/11/2023 #24

日期表格或YYYY-MM-DDTHH:mm:ss.sssZYYYY-MM-DD HH:mm:ss

  
let timeList = [

  {"date": "2023/08/07 09:15:42"},
  {"date": "2021/11/25 18:34:19"},
  {"date": "2007/05/14 07:56:30"},
  {"date": "2015/09/03 15:22:08"},
  {"date": "2010/03/22 12:47:53"}
 ]


  timeList.sort((a,b)=>new Date(a.date) - new Date(b.date))

  console.log(timeList)

0赞 Avnish Jayaswal 10/27/2023 #25
var array = [
  {id: 1, date: new Date("Mar 12 2012 10:00:00 AM")},
  {id: 2, date: new Date("Mar 8 2012 08:00:00 AM")}
];

array.sort((a, b) => {
  return a.date - b.date;
});

console.log(array);

解决方案 2

const sortedAsc = array .sort(
  (objA, objB) => Number(objA.date) - Number(objB.date),
);