trjhtr

Is this the correct and an elegant way to sort the dates in the format (DD-MM-YYYY) in ascending order?

let dates = ['01-02-2018', '02-01-2018', '01-01-2018', '31-12-2017'];

dates.sort((date1, date2) => 
 date1 = date1.split('-'), date2 = date2.split('-');
 let day1 = parseInt(date1[0]);
 let day2 = parseInt(date2[0]);
 let month1 = parseInt(date1[1]);
 let month2 = parseInt(date2[1]);
 let year1 = parseInt(date1[2]);
 let year2 = parseInt(date2[2]);
 if (year1 !== year2) 
 return year1 - year2;
 else if (month1 !== month2) 
 return month1 - month2;
 else 
 return day1 - day2;
 
);

There is also this way, as Cris Luengo said in the comments, I can directly compare the strings.

let dates = ['01-02-2018', '02-01-2018', '01-01-2018', '31-12-2017'];

dates.sort((date1, date2) => 
 date1 = date1.split('-').reverse().join('-');
 date2 = date2.split('-').reverse().join('-');
 if (date1 < date2) 
 return -1;
 else if (date1 > date2) 
 return 1;
 else 
 return 0;
 
);

Which way is more performant? How do I measure that?

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 $O(n)$, the performance of the entire solution is limited by the .sort() (which is probably $O(n * log n)$). 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).

Looking at your update answer, I would like to offer a couple points. You could minimize the amount of 'custom' logic by using some bult-in functions. For example, your comparisons to determine which integer to return is functionally the same as String.prototype.localeCompare(). Instead of if/elses you could write return date1.localeCompare(date2);.

Also, at the start of your comparison function, in plain English you are essentially joining the array, but in reverse order. Therefore, why not utilize join and reverse? In fact, you could knock out the whole string preparation in a one-liner: date1.split('-').reverse().join('').

So the updated function would look like:

dates.sort((date1, date2) => 
 date1 = date1.split('-').reverse().join('');
 date2 = date2.split('-').reverse().join('');
 return date1.localeCompare(date2);
);

Simply compare the characters in order from most significant to least significant:

let indices = [ 6, 7, 8, 9, 3, 4, 0, 1 ];
var dates = ["02-02-2018", "02-01-2018", "01-02-2018", "01-01-2018", "12-31-2017" ];

dates.sort((a, b) => 
 var r = 0;
 indices.find(i => r = a.charCodeAt(i) - b.charCodeAt(i));
 return r;
);

For each comparison this examines the minimum number of characters. Hard to imagine any other solution being faster, except maybe using a for loop instead of find.

As the code is reviewed in other answers, I'll suggest you to different approach.

let getTimestamp = str => +new Date(...str.split('-').reverse());
dates.sort((a, b) => getTimestamp(a) - getTimestamp(b));

The function getTimestamp will give the timestamp from the given string. This timestamp can be used in the sort function for comparing with other dates.

let dates = ['01-02-2018', '02-01-2018', '01-01-2018', '31-12-2017'];

console.time('tushar');
let getTimestamp = str => +new Date(...str.split('-').reverse());
let sortedDates = dates.sort((a, b) => getTimestamp(a) - getTimestamp(b));

console.log(sortedDates);
console.timeEnd('tushar');

References:

1. Date


2. Array#sort


3. 
   ... Spread syntax

Which way is more performant? How do I measure that?

To measure the performace, you may use jsperf.com. Or simply, use console.time as shown in the demo.