Assuming your date format is consistently DD/MM/YYYY:

dates.sort(function(a, b){
    var aa = a.split('/').reverse().join(),
        bb = b.split('/').reverse().join();
    return aa < bb ? -1 : (aa > bb ? 1 : 0);
});

... otherwise you will have to compare Date objects if you require more flexibility.

Hey Abhijit, looks like a couple of things were wrong. The best way to correct the issue is to target the data-timestamp attribute in your JavaScript code initialization, instead of the date-month class name. From the List.js API docs (http://listjs.com/api/#valueNames), your options variable should look like this: js var options = { valueNames: [ 'number', 'name', { name: 'date-month', attr: 'data-timestamp' } ] }; It still wasn't working when I made this correction, so after a bit I noticed that you had the same timestamp in all of the list item date cells, so even if the JavaScript code was setup properly, it wouldn't know how to sort them! I forked your Pen here: https://codepen.io/mattpbrock/pen/bYVwgX?editors=1010 (https://codepen.io/mattpbrock/pen/bYVwgX?editors=1010) so you could see how I got it working. Hope this helps!

UPDATE: You can run performance tests I prepared based on various code samples from the answers to this question: https://jsperf.com/cr-se-date-array-sorting/1. When I ran them, I see that my code is second best performing. The best is the one by @Kevin Cline (up voted!).

---

Here's my take on it. The following code uses the same idea about the string representation of date that is directly comparable for sorting.

It is not possible to tell in advance how performant will this solution be compared to one you presented above. It all depends a lot on how many dates are being sorted. If you deal with tons of dates, there will be many more invocations to the arrow function we're passing to sort(...). Therefore, it's not good to keep translating the date via split() every time our arrow function is being used.

Instead, I recommend three steps:

1. Translate dates into a sortable representation (one time). Use .map().
2. Do the sorting with .sort(). The values will be put in a lexicographical order.
3. Translate the sorted dates back into original representation.

This will guarantee that each date is translated at most twice, which makes the entire solution more performant for large Ns.

Also, Notice that steps #1 and #3 can use same exact implementation, which I extracted.

---

const reverseDateRepresentation = date => {
  let parts = date.split('-');
  return `${parts[2]}-${parts[1]}-${parts[0]}`;
};

const sortedDates = ['01-02-2018', '02-01-2018', '01-01-2018', '31-12-2017']
  .map(reverseDateRepresentation)
  .sort()
  .map(reverseDateRepresentation);

console.log(sortedDates);

Produces result:

["31-12-2017", "01-01-2018", "02-01-2018", "01-02-2018"]

---

Little note. I think, that from the "big O" point of view we haven't improve the algorithm. Since .map(reverseDateRepresentation) is \, the performance of the entire solution is limited by the .sort() (which is probably \). The way we're potentially improving solution is by making sure that the constants in our "big O" cost are as small as we can achieve.

Nevertheless, if we'd put the performance as top criteria of the solution, I'd learn as much as I can about the real data being processed; as well as conducted a thorough performance test.

In real life scenario, however, I personally never put performance above readability, because I believe that lack of readability is eventually the same thing as lack of correctness ...and correctness is almost always more important than performance (few exceptions are known though).

Never use the new Date(string) constructor nor Date.parse() to parse a date string as neither method lets you supply a specific format or locale information. (Annoyingly, JavaScript's built-in Intl does not support parsing, only formatting).

JavaScript's new Date(string) and Date.parse(string) functions use tend to use the user's computer's regional settings to parse a date - if a user is using Windows' en-US settings without realising it then Date.parse(string) and new Date(string) will interpret dates as MM/dd/yyyy instead of their correct regional settings. However browsers tend to try to parse anything you throw at them and if they see 12/31/2019 or 31/12/2019 then they'll both be parsed as 2019-12-31 regardless of their computer regional settings - things only fall-apart if they're given 5/7/2019, for example which will be interpreted as 2019-05-07 if they're in the US or 2019-07-05 if they're in the UK.

Unfortunately you'll need to parse them manually or use a peer-reviewed library like Moment.JS (because writing date libraries is hard).

let dates = [ "03/12/2019", "17/10/2020", "02/12/2019", ... ];

function parseDate( ddMMyyyy ) {

    const components = ddMMyyyy.split( '/' );
    if( components.length != 3 ) return null; 

    const dd   = parseInt( components[0] );
    const MM   = parseInt( components[1] );
    const yyyy = parseInt( components[2] );

    // Component range checking:
    if( dd >= 1 && dd <= 31 && MM >= 1 && MM <= 12 && yyyy >= 0 && yyyy <= 9999 ) {
        return new Date( yyyy, MM - 1, dd ); // `MM - 1` because JavaScript months are 0-based.
    } 
    else {
        return null;
    }
}

let sortedParsedDates = dates
    .map( parseDate )
    .filter( dt => dt instanceof Date )
    .sort( ( x, y ) => x.getTime() - y.getTime() );

The sort needs date.getTime()-date.getTime()

In this case you can leave off the getTime since it will be used anyway

var contributions = [
  {paymentDate: "9/2/2014"},
  {paymentDate: "9/7/2014"},
  {paymentDate: "10/8/2015"},
  {paymentDate: "1/9/2014"},
  {paymentDate: "3/9/2015"}
]
contributions.sort(function(a, b) {
  return new Date(a.paymentDate) - new Date(b.paymentDate)
})
console.log(contributions)

since info is an array, apply sort method to info and info.date and inside the comparator function compare date value of each object inside the array. something like this:

var info = [
  {
name : 'a',
date : '01/05/2017'
  },
  {
name : 'b',
date : '23/12/2013'
  },
  {
name : 'c',
date : '22/01/2015'
  }
]

info.sort(function(a, b){
  var aa = a.date.split('/').reverse().join(),
      bb = b.date.split('/').reverse().join();
  return aa < bb ? -1 : (aa > bb ? 1 : 0);
  });
console.log(info);

To sort an array of object by dates of format (DD.MM.YYYY)

datesObject.sort(function(a, b){
    let curr = a.date.split('.').reverse().join();
    let prev = b.date.split('.').reverse().join();
    return curr < prev ? -1 : (curr > prev ? 1 : 0);
});

It's not interpreting the date the way you think it is. For example,

console.log(new Date("05/01/2015 12:35"));

produces for me:

Date 2017-05-01T19:35:00.000Z

which shows that it's expecting the date to be in MM/dd/yyyy format.

---

You can either roll your own solution or use one of the libraries out there. There are a lot of solutions available. I personally like moment.js which allows date format strings.

Another example, quoted from this answer, adds date parsing format control to strings:

String.prototype.toDate = function(format)
{
  var normalized      = this.replace(/[^a-zA-Z0-9]/g, '-');
  var normalizedFormat= format.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');
  var formatItems     = normalizedFormat.split('-');
  var dateItems       = normalized.split('-');

  var monthIndex  = formatItems.indexOf("mm");
  var dayIndex    = formatItems.indexOf("dd");
  var yearIndex   = formatItems.indexOf("yyyy");
  var hourIndex     = formatItems.indexOf("hh");
  var minutesIndex  = formatItems.indexOf("ii");
  var secondsIndex  = formatItems.indexOf("ss");

  var today = new Date();

  var year  = yearIndex>-1  ? dateItems[yearIndex]    : today.getFullYear();
  var month = monthIndex>-1 ? dateItems[monthIndex]-1 : today.getMonth()-1;
  var day   = dayIndex>-1   ? dateItems[dayIndex]     : today.getDate();

  var hour    = hourIndex>-1      ? dateItems[hourIndex]    : today.getHours();
  var minute  = minutesIndex>-1   ? dateItems[minutesIndex] : today.getMinutes();
  var second  = secondsIndex>-1   ? dateItems[secondsIndex] : today.getSeconds();

  return new Date(year,month,day,hour,minute,second);
};

Example:

"22/03/2016 14:03:01".toDate("dd/mm/yyyy hh:ii:ss");
"2016-03-29 18:30:00".toDate("yyyy-mm-dd hh:ii:ss");