JavaScript - Sort Array again using another index if there are duplicates

Question

I have an Array like this one:

var arrValues1 = [
    [11, 58],
    [18, 45],
    [13, 23],
    [15, 68],
    [23, 32],
    [45, 45],
    [19, 68],
    [88, 68]
];

In order to sort it by the index 1, I have used the following function:

  sortIn(arr, prop) {
    return arr.sort((a, b) => {
        if (a[prop] > b[prop]) {
            return 1;
        } else if (a[prop] < b[prop]) {
            return -1;
        } else {
            return 0;
        }
    });
  } 

arrValues2.push(sortIn(arrValues1, 1));

So, I get this result:

var arrValues2 = [
  [13, 23],
  [23, 32],
  [45, 45],
  [18, 45],
  [11, 58],
  [19, 68],
  [88, 68],
  [15, 68]
];

My problem is about the duplicate values (45 and 68 in this example). If I have duplicate values, I need to sort these considering the index 0 value. So, the final result would be:

var arrValues2 = [
  [13, 23],
  [23, 32],
  [18, 45],// > these 2 cases were reordered 
  [45, 45],//
  [11, 58],
  [15, 68],// > these 3 cases were reordered 
  [19, 68],//
  [88, 68] //
];

It's important keeping all the positions, changing only the duplicate values ordering. How can I achieve that?

VLAZ · Accepted Answer · 2020-12-08 14:19:29Z

You can add any number of fallback sorting properties as rest parameters for your function. So, you'll try to sort by each and only if they all match, then you return 0 for equality:

var arrValues = [
    [11, 58],
    [18, 45],
    [13, 23],
    [15, 68],
    [23, 32],
    [45, 45],
    [19, 68],
    [88, 68]
];


function sortIn(arr, ...props) {
//                   ^^^^^^^^ take any amount of properties to sort by
  return arr.sort((a, b) => {
   //try sorting by each. If no `return` is reached
   //the comparison will continue with the next
    for (const prop of props) {
      if (a[prop] > b[prop]) {
          return 1;
      } else if (a[prop] < b[prop]) {
          return -1;
      }
    }
    return 0; //if no return was hit for each property, then the items are equal
  });
} 

const result = sortIn(arrValues, 1, 0);
// pass secondary sorting property  ^

//more compact display in the console
const displayResult = result.map(x => JSON.stringify(x));
console.log( displayResult );

.as-console-wrapper {max-height: 100% !important; top: 0}

You retain the genericness of your sorting because you can still sort anything that obeys the > and < operators:

var data = [
  {foo: 3, bar: "a", baz: new Date("2020-01-01")},
  {foo: 2, bar: "b", baz: new Date("2020-03-03")},
  {foo: 1, bar: "b", baz: new Date("2020-03-03")},
  {foo: 1, bar: "a", baz: new Date("2020-01-01")},
  {foo: 3, bar: "b", baz: new Date("2020-03-03")},
  {foo: 2, bar: "a", baz: new Date("2020-01-01")},
];


function sortIn(arr, ...props) {
  return arr.sort((a, b) => {
    for (const prop of props) {
      if (a[prop] > b[prop]) {
          return 1;
      } else if (a[prop] < b[prop]) {
          return -1;
      }
    }
    return 0;
  });
} 

console.log( "foo --> bar --> baz" );
console.log( sortIn(data, "foo", "bar", "baz") );
console.log( "--------" );

console.log( "bar --> foo --> baz" );
console.log( sortIn(data, "bar", "foo", "baz") );
console.log( "--------" );

console.log( "baz --> foo --> bar" );
console.log( sortIn(data, "baz", "foo", "bar") );
console.log( "--------" );

.as-console-wrapper {max-height: 100% !important; top: 0}

Scott Sauyet · Accepted Answer · 2020-12-08 14:12:42Z

We can write a generic sorter that accepts any number of property names, like this:

const sorter = (...props) => (a, b) => 
  props .reduce (
    (result, p) => result || (a[p] < b[p] ? -1 : a[p] > b[p] ? 1 : 0), 
    0
  )

// rearranged to demonstrate second-level sorting
const arrValues1 = [[11, 58], [45, 45], [13, 23], [19, 68], [15, 68], [23, 32], [18, 45], [88, 68]]
  
console .log (  
  arrValues1 .sort (sorter (1, 0))
)

.as-console-wrapper {max-height: 100% !important; top: 0}

If you want the same interface you can use that sorter inside sortIn, like this:

const sortIn = (arr, ...props) => 
  arr .sort (sorter (...props))

sortIn (arrValues1, 1, 0)

Or you can fold it in directly like this:

const sortIn = (arr, ...props) => 
  arr .sort ((a, b) => 
    props .reduce (
      (result, p) => result || (a[p] < b[p] ? -1 : a[p] > b[p] ? 1 : 0), 
      0
    )
  )

I find the first version the most useful. I often want to create sorters to be used in multiple places. But any of them should work.

Amardeep Bhowmick · Accepted Answer · 2020-12-08 13:42:17Z

2

You can pass the two keys as the params to your custom function. Then sort using the second prop, if they are equal then check the first prop in the sort callback function:

var arrValues1 = [
    [11, 58],
    [18, 45],
    [13, 23],
    [15, 68],
    [23, 32],
    [45, 45],
    [19, 68],
    [88, 68]
];
const sortIn = (arr, prop1, prop2) => {
  return arr.sort((a, b) => a[prop1] - b[prop1] === 0 ? 
         a[prop2] - b[prop2] :
         a[prop1] - b[prop1]);
}

console.log(sortIn(arrValues1, 1, 0))

answered Dec 8, 2020 at 13:42

Amardeep Bhowmick

17k3 gold badges33 silver badges46 bronze badges

Comments

Nina Scholz · Accepted Answer · 2020-12-08 14:22:50Z

2

Beside the given answers, this approach takes some closures over the neede simplified comparing function and an array of keys for sorting along with a comparing of the keys with a short circuit if the return value is different from a falsy, in this case zero value.

const
    sortBy = fn => keys => (a, b) => {
        let r;
        keys.some(k => r = fn(a[k], b[k]));
        return r;
    }
    array = [[11, 58], [18, 45], [13, 23], [15, 68], [23, 32], [45, 45], [19, 68], [88, 68]],
    ascBy = sortBy((a, b) => a - b);

array.sort(ascBy([0, 1]));
console.log(array);

array.sort(ascBy([1, 0]));
console.log(array);

.as-console-wrapper { max-height: 100% !important; top: 0; }

answered Dec 8, 2020 at 14:22

Nina Scholz

388k26 gold badges367 silver badges417 bronze badges

1 Comment

Scott Sauyet Over a year ago

Nice. I didn't bother with the short-circuiting in my answer, although the reduce is somewhat short-circuited by the ||. A more complete solution would probably use arbitrary functions that return an ordered type alongside ascend/descend helpers, perhaps with an API something like: const mySorter = sortBy(descend(prop('age')), ascend(prop('lastName')), ascend(prop('firstName'))), with room for other functions than just simple object properties. But that's for another question...

Alan Omar · Accepted Answer · 2020-12-08 14:02:40Z

1

take advantage of array destruction:

let arrValues1=[[11,58],[18,45],[13,23],[15,68],[23,32],[45,45],[19,68],[88,68]];

let result = arrValues1.sort(([i,j],[k,l]) => j === l?i-k:j-l)

console.log(result)

answered Dec 8, 2020 at 14:02

Alan Omar

4,2871 gold badge13 silver badges26 bronze badges

Comments

adir abargil · Accepted Answer · 2020-12-08 13:40:44Z

0

you can keep sorting after you the values are equal...:

const arrValues2 = [
    [11, 58],
    [18, 45],
    [13, 23],
    [15, 68],
    [23, 32],
    [45, 45],
    [19, 68],
    [88, 68]
];
function sort_vals(a ,b){
    if (a[1] > b[1]) {
        return 1;
    } else if (a[1] < b[1]) {
        return -1;
    } else {
        if(a[0] > b[0]){
            return 1;
        }else if(a[0] < b[0]){
            return -1;
        } 
        return 0
    }
}
console.log(arrValues2.sort(sort_vals))

answered Dec 8, 2020 at 13:40

adir abargil

5,7453 gold badges23 silver badges29 bronze badges

Comments

George Pandurov · Accepted Answer · 2020-12-08 13:43:33Z

0

You can order them by adding more logic into your else block like so:

sortIn(arr, prop) {
  return arr.sort((a, b) => {
    if (a[prop] > b[prop]) {
        return 1;
    } else if (a[prop] < b[prop]) {
        return -1;
    } else {
        if (a[0] > b[0]) {
           return 1
        } else {
          return -1
        }
    }
  });
}

arrValues2.push(sortIn(arrValues1, 1));

answered Dec 8, 2020 at 13:43

George Pandurov

3904 silver badges15 bronze badges

Comments

Vishal · Accepted Answer · 2020-12-08 13:43:35Z

0

You can compare again in case of equals like

    sortIn(arr, prop) {
    return arr.sort((a, b) => {
        if (a[prop] > b[prop]) {
            return 1;
        } else if (a[prop] < b[prop]) {
            return -1;
        } else {
            // Compare Again
            // return 0;
           if (a[0] > b[0]) {
            return 1;
        } else if (a[0] < b[0]) {
            return -1;
        } else {
            return 0;
         }
        }
    });
  } 

arrValues2.push(sortIn(arrValues1, 1));

answered Dec 8, 2020 at 13:43

Vishal

1952 silver badges11 bronze badges

Collectives™ on Stack Overflow

JavaScript - Sort Array again using another index if there are duplicates

8 Answers 8

Comments

Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

8 Answers 8

Comments

Comments

Comments

1 Comment

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related