关于datetime：按日期排序Javascript对象数组


Sort Javascript Object Array By Date

假设我有一些对象的数组：

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

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

我会使用排序函数和自定义比较器吗？

更新

在我的具体案例中，我想把日期从最近的安排到最早的安排。最后我不得不颠倒简单函数的逻辑：

1
2
3
4
5
array.sort(function(a, b) {
    a = new Date(a.dateModified);
    b = new Date(b.dateModified);
    return a>b ? -1 : a<b ? 1 : 0;
});

这将对最近的日期进行排序。

相关讨论

最简单的答案

1
2
3
4
5
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);
});

更一般的答案

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

或者更简洁地说：

2通用、有力的回答

在所有数组上使用Schwartzian转换定义自定义不可枚举的sortBy函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(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;
  }
})();

像这样使用它：

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

如果你的日期不是直接可比的，就从中找出可比的日期，例如

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

如果返回值数组，还可以使用此选项按多个条件排序：

1
2
// 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。

相关讨论

@Phrogz answers are both great, but here is a great, more concise answer:

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

在这里找到：在javascript中排序日期

相关讨论

更正JSON之后，应该可以工作了。

1
2
3
4
5
6
7
8
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;
});

您的数据需要更正：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
var array = [{id: 1, date:"Mar 12 2012 10:00:00 AM
<div class="suo-content">[collapse title=""]<ul><li>我喜欢这个答案，因为它考虑的是时间，而不仅仅是日期(更准确)。此外，这个答案是全面的，显示了数组的构建和函数的使用。前面的其他答案缺少如何使用的示例。</li><li>必要时别忘了归还<wyn>0</wyn>！</li></ul>[/collapse]</div><hr><P>我推荐Github:array sortby-使用Schwartzian转换的<wyn>sortBy</wyn>方法的最佳实现</P><P>但是现在我们要尝试这个方法：sortby old.js.<br/>让我们创建一个方法来排序数组，使其能够按某些属性排列对象。</P>创建排序功能[cc lang="javascript"]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));
    });
  };

}());

设置未排序的数据

1
2
3
4
5
6
7
var data = [
  {date:"2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: 0,   type:"cash
<div class="suo-content">[collapse title=""]<ul><li>IE11的线路有问题：如果(tostring.call(cfg)！="[对象对象]")cfg=；如果用if(object.prototype.toString.call(cfg)替换它！="[对象对象]")cfg=；您也将很好地使用IE11。</li></ul>[/collapse]</div><hr><P>您可以在下划线JS中使用sortby。</P><P>http://underlinejs.org/排序</P><P>Sample：</P>[cc lang="javascript"]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'));

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

1
2
3
4
5
6
7
  sortByDate(arr) {
    arr.sort(function(a,b){
      return Number(new Date(a.readableDate)) - Number(new Date(b.readableDate));
    });

    return arr;
  }

sortByDate(myArr);

相关讨论

我将在这里添加这个，因为有些用法可能无法解决如何反转这个排序方法。

为了按"即将到来"排序，我们可以简单地交换A&B，如下所示：

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

注意，a现在在左边，b在右边，：d！

1
2
3
4
5
6
7
8
Adding absolute will give better results

var datesArray =[
      {"some":"data1","date":"2018-06-30T13:40:31.493Z
<hr><P>我能够使用以下行实现排序：</P>[cc lang="javascript"]array.sort(function(a, b) {
if (a.AffiliateDueDate > b.AffiliateDueDate) return 1;
if (a.AffiliateDueDate < b.AffiliateDueDate) return -1;
                                   })

您也可以使用此链接。它提供回调函数，这些函数可以传递给通用的sort()函数。

如果像我一样，您有一个日期格式为YYYY[-MM[-DD]]的数组，您希望在不太具体的日期之前订购更具体的日期，那么我想出了这个方便的函数：

1
2
3
4
5
6
7
const 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)
}

我刚刚接受了上面描述的施瓦兹变换，并将其作为函数。它以array、排序function和布尔值作为输入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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));

相关讨论

For anyone who is wanting to sort by date (UK format), I used the following:

1
2
3
4
5
6
7
8
9
10
//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;
    });
}
1
2
3
["12 Jan 2018" ,"1 Dec 2018","04 May 2018"].sort(function(a,b) {
    return new Date(a).getTime() - new Date(b).getTime()
})
相关讨论