web-dev-qa-db-fra.com

Trier les objets Javascript par date

Disons que j'ai un tableau de quelques objets:

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

Comment puis-je trier ce tableau par l'élément de date dans l'ordre, de la date la plus proche de la date et de l'heure actuelles? Gardez à l'esprit que le tableau peut avoir de nombreux objets, mais par souci de simplicité, j'ai utilisé 2.

Est-ce que j'utiliserais la fonction de tri et un comparateur personnalisé?

METTRE À JOUR

Dans mon cas particulier, je voulais les dates arrangées du plus récent au plus ancien. En fin de compte, j'ai dû inverser la logique de la fonction simple de la manière suivante:

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

Ceci trie les dates des plus récentes.

javascriptdatetime
486
ryandlf

Réponse la plus simple

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

Réponse plus générique

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

Ou plus simplement:

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

Réponse générique et puissante

Définissez une fonction personnalisée sortBy non énumérable à l’aide de la transformation Schwartzian sur tous les tableaux:

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

Utilisez-le comme suit:

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

Si votre date n’est pas directement comparable, définissez-en une date comparable, par exemple,.

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

Vous pouvez également l'utiliser pour trier selon plusieurs critères si vous retournez un tableau de valeurs:

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

Voir http://phrogz.net/JS/Array.prototype.sortBy.js pour plus de détails.

1043
Phrogz

Les réponses de @Phrogz sont bonnes, mais voici une excellente réponse, plus concise:

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

trouvé ici: Trier la date en Javascript

83
Gal

Après avoir corrigé le JSON, cela devrait fonctionner.

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

Vos données nécessitent des corrections:

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

Après avoir corrigé les données, vous pouvez utiliser ce morceau de code:

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);​
25
gabitzish

Je recommande GitHub: Array sortBy - une meilleure implémentation de la méthode sortBy qui utilise la transformation de Schwartzian

Mais pour le moment, nous allons essayer cette approche Gist: sortBy-old.js .
Créons une méthode pour trier des tableaux pouvant arranger des objets selon certaines propriétés.

Création de la fonction de tri

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

}());

Définition de données non triées

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

En l'utilisant

Enfin, nous organisons le tableau, par la propriété "date" sous la forme string

//sort the object by a property (ascending)
//sorting takes into account uppercase and lowercase
sortBy(data, { prop: "date" });

Si vous souhaitez ignorer la casse des lettres, définissez le rappel "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();
    }
});

Si vous souhaitez traiter le champ "date" comme étant une variable 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);
    }
});

Ici, vous pouvez jouer avec l'exemple ci-dessus:
jsbin.com/lesebi

16
jherax

Vous pouvez utiliser sortBy dans soulignement js. 

http://underscorejs.org/#sortBy

Échantillon:

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

Cela devrait faire lorsque votre date est dans ce format (jj/mm/aaaa).

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

    return arr;
  }

sortByDate(myArr);

6
Edison D'souza

Je vais ajouter ceci ici, car certaines utilisations pourraient ne pas être en mesure de déterminer comment inverser cette méthode de tri.

Pour trier par "à venir", nous pouvons simplement échanger a & b, comme suit:

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

Notez que a est maintenant à gauche et b est à droite: D!

3
James111

J'utilise personnellement l'approche suivante pour trier les dates.

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;
})
3
Aravinda Meewalaarachchi

vous pouvez aussi utiliser ce link . il fournit des fonctions de rappel qui peuvent être transmises à la fonction générique sort() 

2
Thesane

j'ai pu réaliser le tri en utilisant les lignes ci-dessous:

array.sort(function(a, b) {
if (a.AffiliateDueDate > b.AffiliateDueDate) return 1;
if (a.AffiliateDueDate < b.AffiliateDueDate) return -1;
                                   })
2
Amay Kulkarni

Pour ceux qui souhaitent trier par date (format UK), j'ai utilisé les éléments suivants:

//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;
    }); 
}
0
Andi

Je viens de prendre la transformation Schwartzian décrite ci-dessus et réalisée en tant que fonction. Il faut array, le tri function et un booléen en entrée:

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

0
loretoparisi
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
Rajiv Shrivastava

Si, comme moi, vous avez un tableau avec des dates au format YYYY[-MM[-DD]] où vous souhaitez commander des dates plus spécifiques avant des dates moins spécifiques, j'ai créé cette fonction pratique:

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