javascript array sorting / array match sorted array [duplicate] - javascript
For example, if I have these arrays:
var name = ["Bob","Tom","Larry"];
var age = ["10", "20", "30"];
And I use name.sort() the order of the "name" array becomes:
var name = ["Bob","Larry","Tom"];
But, how can I sort the "name" array and have the "age" array keep the same order? Like this:
var name = ["Bob","Larry","Tom"];
var age = ["10", "30", "20"];
You can sort the existing arrays, or reorganize the data.
Method 1:
To use the existing arrays, you can combine, sort, and separate them:
(Assuming equal length arrays)
var names = ["Bob","Tom","Larry"];
var ages = ["10", "20", "30"];
//1) combine the arrays:
var list = [];
for (var j = 0; j < names.length; j++)
list.push({'name': names[j], 'age': ages[j]});
//2) sort:
list.sort(function(a, b) {
return ((a.name < b.name) ? -1 : ((a.name == b.name) ? 0 : 1));
//Sort could be modified to, for example, sort on the age
// if the name is the same. See Bonus section below
});
//3) separate them back out:
for (var k = 0; k < list.length; k++) {
names[k] = list[k].name;
ages[k] = list[k].age;
}
This has the advantage of not relying on string parsing techniques, and could be used on any number of arrays that need to be sorted together.
Method 2: Or you can reorganize the data a bit, and just sort a collection of objects:
var list = [
{name: "Bob", age: 10},
{name: "Tom", age: 20},
{name: "Larry", age: 30}
];
list.sort(function(a, b) {
return ((a.name < b.name) ? -1 : ((a.name == b.name) ? 0 : 1));
});
for (var i = 0; i<list.length; i++) {
alert(list[i].name + ", " + list[i].age);
}
For the comparisons,-1 means lower index, 0 means equal, and 1 means higher index. And it is worth noting that sort() actually changes the underlying array.
Also worth noting, method 2 is more efficient as you do not have to loop through the entire list twice in addition to the sort.
http://jsfiddle.net/ghBn7/38/
Bonus Here is a generic sort method that takes one or more property names.
function sort_by_property(list, property_name_list) {
list.sort((a, b) => {
for (var p = 0; p < property_name_list.length; p++) {
prop = property_name_list[p];
if (a[prop] < b[prop]) {
return -1;
} else if (a[prop] !== a[prop]) {
return 1;
}
}
return 0;
});
}
Usage:
var list = [
{name: "Bob", age: 10},
{name: "Tom", age: 20},
{name: "Larry", age: 30},
{name: "Larry", age: 25}
];
sort_by_property(list, ["name", "age"]);
for (var i = 0; i<list.length; i++) {
console.log(list[i].name + ", " + list[i].age);
}
Output:
Bob, 10
Larry, 25
Larry, 30
Tom, 20
You could get the indices of name array using Array.from(name.keys()) or [...name.keys()]. Sort the indices based on their value. Then use map to get the value for the corresponding indices in any number of related arrays
const indices = Array.from(name.keys())
indices.sort( (a,b) => name[a].localeCompare(name[b]) )
const sortedName = indices.map(i => name[i]),
const sortedAge = indices.map(i => age[i])
Here's a snippet:
const name = ["Bob","Tom","Larry"],
age = ["10", "20", "30"],
indices = Array.from(name.keys())
.sort( (a,b) => name[a].localeCompare(name[b]) ),
sortedName = indices.map(i => name[i]),
sortedAge = indices.map(i => age[i])
console.log(indices)
console.log(sortedName)
console.log(sortedAge)
This solution (my work) sorts multiple arrays, without transforming the data to an intermediary structure, and works on large arrays efficiently. It allows passing arrays as a list, or object, and supports a custom compareFunction.
Usage:
let people = ["john", "benny", "sally", "george"];
let peopleIds = [10, 20, 30, 40];
sortArrays([people, peopleIds]);
[["benny", "george", "john", "sally"], [20, 40, 10, 30]] // output
sortArrays({people, peopleIds});
{"people": ["benny", "george", "john", "sally"], "peopleIds": [20, 40, 10, 30]} // output
Algorithm:
Create a list of indexes of the main array (sortableArray)
Sort the indexes with a custom compareFunction that compares the values, looked up with the index
For each input array, map each index, in order, to its value
Implementation:
/**
* Sorts all arrays together with the first. Pass either a list of arrays, or a map. Any key is accepted.
* Array|Object arrays [sortableArray, ...otherArrays]; {sortableArray: [], secondaryArray: [], ...}
* Function comparator(?,?) -> int optional compareFunction, compatible with Array.sort(compareFunction)
*/
function sortArrays(arrays, comparator = (a, b) => (a < b) ? -1 : (a > b) ? 1 : 0) {
let arrayKeys = Object.keys(arrays);
let sortableArray = Object.values(arrays)[0];
let indexes = Object.keys(sortableArray);
let sortedIndexes = indexes.sort((a, b) => comparator(sortableArray[a], sortableArray[b]));
let sortByIndexes = (array, sortedIndexes) => sortedIndexes.map(sortedIndex => array[sortedIndex]);
if (Array.isArray(arrays)) {
return arrayKeys.map(arrayIndex => sortByIndexes(arrays[arrayIndex], sortedIndexes));
} else {
let sortedArrays = {};
arrayKeys.forEach((arrayKey) => {
sortedArrays[arrayKey] = sortByIndexes(arrays[arrayKey], sortedIndexes);
});
return sortedArrays;
}
}
See also https://gist.github.com/boukeversteegh/3219ffb912ac6ef7282b1f5ce7a379ad
If performance matters, there is sort-ids package for that purpose:
var sortIds = require('sort-ids')
var reorder = require('array-rearrange')
var name = ["Bob","Larry","Tom"];
var age = [30, 20, 10];
var ids = sortIds(age)
reorder(age, ids)
reorder(name, ids)
That is ~5 times faster than the comparator function.
It is very similar to jwatts1980's answer (Update 2).
Consider reading Sorting with map.
name.map(function (v, i) {
return {
value1 : v,
value2 : age[i]
};
}).sort(function (a, b) {
return ((a.value1 < b.value1) ? -1 : ((a.value1 == b.value1) ? 0 : 1));
}).forEach(function (v, i) {
name[i] = v.value1;
age[i] = v.value2;
});
You are trying to sort 2 independet arrays by only calling sort() on one of them.
One way of achieving this would be writing your own sorting methd which would take care of this, meaning when it swaps 2 elements in-place in the "original" array, it should swap 2 elements in-place in the "attribute" array.
Here is a pseudocode on how you might try it.
function mySort(originals, attributes) {
// Start of your sorting code here
swap(originals, i, j);
swap(attributes, i, j);
// Rest of your sorting code here
}
inspired from #jwatts1980's answer, and #Alexander's answer here I merged both answer's into a quick and dirty solution;
The main array is the one to be sorted, the rest just follows its indexes
NOTE: Not very efficient for very very large arrays
/* #sort argument is the array that has the values to sort
#followers argument is an array of arrays which are all same length of 'sort'
all will be sorted accordingly
example:
sortMutipleArrays(
[0, 6, 7, 8, 3, 4, 9],
[ ["zr", "sx", "sv", "et", "th", "fr", "nn"],
["zero", "six", "seven", "eight", "three", "four", "nine"]
]
);
// Will return
{
sorted: [0, 3, 4, 6, 7, 8, 9],
followed: [
["zr", th, "fr", "sx", "sv", "et", "nn"],
["zero", "three", "four", "six", "seven", "eight", "nine"]
]
}
*/
You probably want to change the method signature/return structure, but that should be easy though. I did it this way because I needed it
var sortMultipleArrays = function (sort, followers) {
var index = this.getSortedIndex(sort)
, followed = [];
followers.unshift(sort);
followers.forEach(function(arr){
var _arr = [];
for(var i = 0; i < arr.length; i++)
_arr[i] = arr[index[i]];
followed.push(_arr);
});
var result = {sorted: followed[0]};
followed.shift();
result.followed = followed;
return result;
};
var getSortedIndex = function (arr) {
var index = [];
for (var i = 0; i < arr.length; i++) {
index.push(i);
}
index = index.sort((function(arr){
/* this will sort ints in descending order, change it based on your needs */
return function (a, b) {return ((arr[a] > arr[b]) ? -1 : ((arr[a] < arr[b]) ? 1 : 0));
};
})(arr));
return index;
};
I was looking for something more generic and functional than the current answers.
Here's what I came up with: an es6 implementation (with no mutations!) that lets you sort as many arrays as you want given a "source" array
/**
* Given multiple arrays of the same length, sort one (the "source" array), and
* sort all other arrays to reorder the same way the source array does.
*
* Usage:
*
* sortMultipleArrays( objectWithArrays, sortFunctionToApplyToSource )
*
* sortMultipleArrays(
* {
* source: [...],
* other1: [...],
* other2: [...]
* },
* (a, b) => { return a - b })
* )
*
* Returns:
* {
* source: [..sorted source array]
* other1: [...other1 sorted in same order as source],
* other2: [...other2 sorted in same order as source]
* }
*/
export function sortMultipleArrays( namedArrays, sortFn ) {
const { source } = namedArrays;
if( !source ) {
throw new Error('You must pass in an object containing a key named "source" pointing to an array');
}
const arrayNames = Object.keys( namedArrays );
// First build an array combining all arrays into one, eg
// [{ source: 'source1', other: 'other1' }, { source: 'source2', other: 'other2' } ...]
return source.map(( value, index ) =>
arrayNames.reduce((memo, name) => ({
...memo,
[ name ]: namedArrays[ name ][ index ]
}), {})
)
// Then have user defined sort function sort the single array, but only
// pass in the source value
.sort(( a, b ) => sortFn( a.source, b.source ))
// Then turn the source array back into an object with the values being the
// sorted arrays, eg
// { source: [ 'source1', 'source2' ], other: [ 'other1', 'other2' ] ... }
.reduce(( memo, group ) =>
arrayNames.reduce((ongoingMemo, arrayName) => ({
...ongoingMemo,
[ arrayName ]: [
...( ongoingMemo[ arrayName ] || [] ),
group[ arrayName ]
]
}), memo), {});
}
You could append the original index of each member to the value, sort the array, then remove the index and use it to re-order the other array. It will only work where the contents are strings or can be converted to and from strings successfuly.
Another solution is keep a copy of the original array, then after sorting, find where each member is now and adjust the other array appropriately.
I was having the same issue and came up with this incredibly simple solution. First combine the associated ellements into strings in a seperate array then use parseInt in your sort comparison function like this:
<html>
<body>
<div id="outPut"></div>
<script>
var theNums = [13,12,14];
var theStrs = ["a","b","c"];
var theCombine = [];
for (var x in theNums)
{
theCombine[x] = theNums[x] + "," + theStrs;
}
var theSorted = theAr.sort(function(a,b)
{
var c = parseInt(a,10);
var d = parseInt(b,10);
return c-d;
});
document.getElementById("outPut").innerHTML = theS;
</script>
</body>
</html>
How about:
var names = ["Bob","Tom","Larry"];
var ages = ["10", "20", "30"];
var n = names.slice(0).sort()
var a = [];
for (x in n)
{
i = names.indexOf(n[x]);
a.push(ages[i]);
names[i] = null;
}
names = n
ages = a
Simplest explantion is the best, merge the arrays, and then extract after sorting:
create an array
name_age=["bob#10","Tom#20","Larry#30"];
sort the array as before, then extract the name and the age, you can use # to reconise where
name ends and age begins. Maybe not a method for the purist, but I have the same issue and this my approach.
Related
How to create array of objects through map?
I would like to have multiple arrays of objects like this. E.g: const pets = [ { name: "cat", age: 4 }, { name: "dog", age: 6 } ] But I want to create it using a map. So I was trying something like this. let pets = []; pets.map((item) => { return ( item.push({ name: "cat", age: 4 }, { name: "dog", age: 6 }) ) }) By this method, I'm getting an empty array. So assuming this is incorrect, how would I go on and make this through a map. Please any help would be appreciated.
first of all map works by looping through an array but you have empty array let pets = []; so the loop doesn't even start ! that's why you are getting empty array Secondly map essentially is a method through which we can create a new array with the help of an existing array so you have chosen a wrong way! example of map const fruits = ["Mango", "Apple", "Banana", "Pineapple", "Orange"]; console.log(fruits); const uppercaseFruits = fruits.map((fruit)=>{ return fruit.toUpperCase(); // this thing will be added to new array in every iteration }); console.log(uppercaseFruits); but still .... let pets = [""]; // an item so that loop can start const myPets = pets.map((item) => { return ( ([{ name: "cat", age: 4 },{ name: "dog", age: 6 }]) ) }) console.log(myPets)
//Usage of map: for example let array = [1, 2, 3, 4, 5]; let newArray = array.map((item) => { return item * item; }) console.log(newArray) // [1, 4, 9, 16, 25] map will not change the original array, if you don't assign a value to it, the original array will never be affected And if you want to get what you want you use RANDOM like this //random String function randomString(e) { e = e || 32; var t = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678", a = t.length, n = ""; for (i = 0; i < e; i++) n += t.charAt(Math.floor(Math.random() * a)); return n } //random Number function GetRandomNum(Min,Max) { var Range = Max - Min; var Rand = Math.random(); return(Min + Math.round(Rand * Range)); } var num = GetRandomNum(10000,999999); alert(num); Then you can combine random strings and random numbers into a new Object through a function
Can't sort array containing int
I'm unable to sort an array containing int. Here's my code for the sort : var asr = []; function sortNumber(a, b) { return b - a; } asr.sort(sortNumber); The function sort doesn't do anything, here is a sample of my array when I made a console.log(asr) on chrome : by: 3 de: 2 ds: 14 sr: 2 vi: 1 proto: Array(0)
Based on your recent update, it seems asr is an array with properties you've added. That's not generally a good idea unless you know what you're doing, and sort() won't touch those properties. Instead, I would use a normal object, with the caveat that objects in JavaScript aren't really meant to contain an ordered collection of values. With that caveat out of the way, this is how I'd store the data, and how I'd sort the keys: const asr = {by: 3, ds: 14, de: 2, vi: 1, sr: 2} console.log( Object.fromEntries( Object.entries(asr).sort( ([ak, av], [bk, bv]) => av > bv ? 1 : -1 ) ) ) I'll keep the rest here, even though it isn't relevant to your question. asr is most likely an array of objects, in which case asr.sort() has sorted the array by the result of the contained objects' toString method: const asr = [{vi: 1}, {sr: 2}, {by: 3}, {ds: 14}, {de: 2}] console.log(asr.sort()) If you want to sort it by object values, this will do the trick: const asr = [{vi: 1}, {sr: 2}, {by: 3}, {ds: 14}, {de: 2}] console.log(asr.sort( (a, b) => Object.values(a)[0] > Object.values(b)[0] ? 1 : -1 )) If you want to sort by object keys, this should work: const asr = [{vi: 1}, {sr: 2}, {by: 3}, {ds: 14}, {de: 2}] console.log(asr.sort( (a, b) => Object.keys(a)[0] > Object.keys(b)[0] ? 1 : -1 ))
Your sort function is correct, check with: console.log([51,2,13,4,5].sort(function(a,b) {return b-a})); asr doesn't seem to be an array but an object.
Properties in arrays remain in the order that you define them, if you want to have them sorted then you need to define them sorted from the beginning, that being said you can get all the properties of your array, sort the values for this properties from your array and insert this sorted properties into a new array. const asr = []; asr.by = 3; asr.de = 2; asr.ds = 14; asr.sr = 2; asr.vi = 1; function sortNumber(a, b) { return b - a; } let asr2 = [...asr]; Object.keys(asr) .map(key => ({ key, value: asr[key] })) .sort((a, b) => b.value - a.value) .forEach(a => asr2[a.key] = a.value); console.log(asr2) /* // if asr contains values and you also // want to sort those values you need // to sort them separately asr2 = asr2.sort((a, b) => b - a) console.log(asr2) */ If what you what is to keep the properties in the same position but sort only the values then try this const asr = []; asr.by = 3; asr.de = 2; asr.ds = 14; asr.sr = 2; asr.vi = 1; function sortNumber(a, b) { return b - a; } const asrKeys = Object.keys(asr); const asrSortedValues = asrKeys.map(key => asr[key]) .sort((a, b) => b - a); asrKeys.forEach((key, index) => asr[key] = asrSortedValues[index]); console.log(asr)
Sorting a numeric array along with an array of objects in JavaScript
Suppose I generate two arrays One that holds Array of numbers: [5.65, 3.25, 4.34, 6.78] And another array that holds objects with some information in them [car.object1, car.object2, car.object3, car.object4] And the objects in second array are related to the numbers in first array. So object1 is related to 5.65, object2 to 3.25 and so on. So I want to sort the array 1 in an ascending order and at the same time sort the array 2 also. So the result should be: [3.25, 4.34, 5.65, 6.78] & [car.object2, car.object3, car.object1, car.object4] My Approach: (You can just ignore the below answer as I think it is wrong. It does not work.) var all = []; var A = [5.65, 3.25, 4.34, 6.78]; var B = ['store.object1', 'store.object2', 'store.object3', 'store.object4']; for (var i = 0; i < B.length; i++) { all.push({ 'A': A[i], 'B': B[i] }); } all.sort(function(a, b) { return a.A - b.A; }); A = []; B = []; for (var i = 0; i < all.length; i++) { A.push(all[i].A); B.push(all[i].B); } console.log(A, B);
You could use a temporary array with the indices and sort it with the values of the first array. Then map the sorted array with the values of array1 and array2. I use strings for the second array, instead of missing objects. var array1 = [5.65, 3.25, 4.34, 6.78], array2 = ['car.object1', 'car.object2', 'car.object3', 'car.object4'], temp = array1.map(function (_, i) { return i; }); temp.sort(function (a, b) { return array1[a] - array1[b]; }); array1 = temp.map(function (a) { return array1[a]; }); array2 = temp.map(function (a) { return array2[a]; }); console.log(temp); console.log(array1); console.log(array2); .as-console-wrapper { max-height: 100% !important; top: 0; }
Unless you want to implement the sort yourself, one simple way is to combine the entries from the number array with the entries from the object array (at least briefly), sort that, and then (if necessary) extract the result: // Setup var car = { object1: {name: "object1"}, object2: {name: "object2"}, object3: {name: "object3"}, object4: {name: "object4"} }; var nums = [5.65, 3.25, 4.34, 6.78]; var objs = [car.object1, car.object2, car.object3, car.object4]; // Combine var joined = []; nums.forEach(function(num, index) { joined[index] = {num: num, object: objs[index]}; }); // Sort joined.sort(function(a, b) { return a.num - b.num; }); // Extract nums = []; objs = []; joined.forEach(function(entry, index) { nums[index] = entry.num; objs[index] = entry.object; }); console.log(nums); console.log(objs); .as-console-wrapper { max-height: 100% !important; } But rather than combine, sort, and extract, I'd probably just maintain a single array and add each number to its relevant object, so they always travel together.
Here is an ES6 way to do it: let a = [5.65, 3.25, 4.34, 6.78]; let b = [{ x:1 }, { x:2 }, { x:3 }, { x: 4}]; [a, b] = a.map( (n, i) => [n, b[i]] ) // zip the two arrays together .sort( ([n], [m]) => n-m ) // sort the zipped array by number .reduce ( ([a,b], [n, o]) => [[...a, n], [...b, o]], [[],[]] ); // unzip console.log(JSON.stringify(a)); console.log(JSON.stringify(b));
I've helped myself with an object containing car.object as the key and it's number as the value. Seems easy&quick solution. var obj = [{'car.object1': 5.65}, {'car.object2': 3.25}, {'car.object3': 4.34}, {'car.object4': 6.78}], objs = obj.sort((a,b) => a[Object.keys(a)] - b[Object.keys(b)]); console.log(objs.map(v => Object.keys(v)[0])); console.log(objs.map(v => v[Object.keys(v)])); console.log(objs); .as-console-wrapper { max-height: 100% !important; }
Trying to sort array by key [duplicate]
I have a multidimensional array. The primary array is an array of [publicationID][publication_name][ownderID][owner_name] What I am trying to do is sort the array by owner_name and then by publication_name. I know in JavaScript you have Array.sort(), into which you can put a custom function, in my case i have: function mysortfunction(a, b) { var x = a[3].toLowerCase(); var y = b[3].toLowerCase(); return ((x < y) ? -1 : ((x > y) ? 1 : 0)); } This is fine for just sorting on the one column, namely owner_name, but how do I modify it to sort on owner_name, then publication_name?
If owner names differ, sort by them. Otherwise, use publication name for tiebreaker. function mysortfunction(a, b) { var o1 = a[3].toLowerCase(); var o2 = b[3].toLowerCase(); var p1 = a[1].toLowerCase(); var p2 = b[1].toLowerCase(); if (o1 < o2) return -1; if (o1 > o2) return 1; if (p1 < p2) return -1; if (p1 > p2) return 1; return 0; }
I think what you're looking for is thenBy.js: https://github.com/Teun/thenBy.js It allows you to use the standard Array.sort, but with firstBy().thenBy().thenBy() style. An example can be seen here.
A good way to sort on many fields that are strings is to use toLocaleCompare and the boolean operator ||. Something like: // Sorting record releases by name and then by title. releases.sort((oldRelease, newRelease) => { const compareName = oldRelease.name.localeCompare(newRelease.name); const compareTitle = oldRelease.title.localeCompare(newRelease.title); return compareName || compareTitle; }) If you wanted to sort on more fields, you could simply chain them off the return statement with more boolean operators.
Came across a need to do SQL-style mixed asc and desc object array sorts by keys. kennebec's solution above helped me get to this: Array.prototype.keySort = function(keys) { keys = keys || {}; // via // https://stackoverflow.com/questions/5223/length-of-javascript-object-ie-associative-array var obLen = function(obj) { var size = 0, key; for (key in obj) { if (obj.hasOwnProperty(key)) size++; } return size; }; // avoiding using Object.keys because I guess did it have IE8 issues? // else var obIx = function(obj, ix){ return Object.keys(obj)[ix]; } or // whatever var obIx = function(obj, ix) { var size = 0, key; for (key in obj) { if (obj.hasOwnProperty(key)) { if (size == ix) return key; size++; } } return false; }; var keySort = function(a, b, d) { d = d !== null ? d : 1; // a = a.toLowerCase(); // this breaks numbers // b = b.toLowerCase(); if (a == b) return 0; return a > b ? 1 * d : -1 * d; }; var KL = obLen(keys); if (!KL) return this.sort(keySort); for ( var k in keys) { // asc unless desc or skip keys[k] = keys[k] == 'desc' || keys[k] == -1 ? -1 : (keys[k] == 'skip' || keys[k] === 0 ? 0 : 1); } this.sort(function(a, b) { var sorted = 0, ix = 0; while (sorted === 0 && ix < KL) { var k = obIx(keys, ix); if (k) { var dir = keys[k]; sorted = keySort(a[k], b[k], dir); ix++; } } return sorted; }); return this; }; sample usage: var obja = [ {USER:"bob", SCORE:2000, TIME:32, AGE:16, COUNTRY:"US"}, {USER:"jane", SCORE:4000, TIME:35, AGE:16, COUNTRY:"DE"}, {USER:"tim", SCORE:1000, TIME:30, AGE:17, COUNTRY:"UK"}, {USER:"mary", SCORE:1500, TIME:31, AGE:19, COUNTRY:"PL"}, {USER:"joe", SCORE:2500, TIME:33, AGE:18, COUNTRY:"US"}, {USER:"sally", SCORE:2000, TIME:30, AGE:16, COUNTRY:"CA"}, {USER:"yuri", SCORE:3000, TIME:34, AGE:19, COUNTRY:"RU"}, {USER:"anita", SCORE:2500, TIME:32, AGE:17, COUNTRY:"LV"}, {USER:"mark", SCORE:2000, TIME:30, AGE:18, COUNTRY:"DE"}, {USER:"amy", SCORE:1500, TIME:29, AGE:19, COUNTRY:"UK"} ]; var sorto = { SCORE:"desc",TIME:"asc", AGE:"asc" }; obja.keySort(sorto); yields the following: 0: { USER: jane; SCORE: 4000; TIME: 35; AGE: 16; COUNTRY: DE; } 1: { USER: yuri; SCORE: 3000; TIME: 34; AGE: 19; COUNTRY: RU; } 2: { USER: anita; SCORE: 2500; TIME: 32; AGE: 17; COUNTRY: LV; } 3: { USER: joe; SCORE: 2500; TIME: 33; AGE: 18; COUNTRY: US; } 4: { USER: sally; SCORE: 2000; TIME: 30; AGE: 16; COUNTRY: CA; } 5: { USER: mark; SCORE: 2000; TIME: 30; AGE: 18; COUNTRY: DE; } 6: { USER: bob; SCORE: 2000; TIME: 32; AGE: 16; COUNTRY: US; } 7: { USER: amy; SCORE: 1500; TIME: 29; AGE: 19; COUNTRY: UK; } 8: { USER: mary; SCORE: 1500; TIME: 31; AGE: 19; COUNTRY: PL; } 9: { USER: tim; SCORE: 1000; TIME: 30; AGE: 17; COUNTRY: UK; } keySort: { } (using a print function from here) here is a jsbin example. edit: cleaned up and posted as mksort.js on github.
This is handy for alpha sorts of all sizes. Pass it the indexes you want to sort by, in order, as arguments. Array.prototype.deepSortAlpha= function(){ var itm, L=arguments.length, order=arguments; var alphaSort= function(a, b){ a= a.toLowerCase(); b= b.toLowerCase(); if(a== b) return 0; return a> b? 1:-1; } if(!L) return this.sort(alphaSort); this.sort(function(a, b){ var tem= 0, indx=0; while(tem==0 && indx<L){ itm=order[indx]; tem= alphaSort(a[itm], b[itm]); indx+=1; } return tem; }); return this; } var arr= [[ "Nilesh","Karmshil"], ["Pranjal","Deka"], ["Susants","Ghosh"], ["Shiv","Shankar"], ["Javid","Ghosh"], ["Shaher","Banu"], ["Javid","Rashid"]]; arr.deepSortAlpha(1,0);
I suggest to use a built in comparer and chain the wanted sort order with logical or ||. function customSort(a, b) { return a[3].localeCompare(b[3]) || a[1].localeCompare(b[1]); } Working example: var array = [ [0, 'Aluminium', 0, 'Francis'], [1, 'Argon', 1, 'Ada'], [2, 'Brom', 2, 'John'], [3, 'Cadmium', 3, 'Marie'], [4, 'Fluor', 3, 'Marie'], [5, 'Gold', 1, 'Ada'], [6, 'Kupfer', 4, 'Ines'], [7, 'Krypton', 4, 'Joe'], [8, 'Sauerstoff', 3, 'Marie'], [9, 'Zink', 5, 'Max'] ]; array.sort(function (a, b) { return a[3].localeCompare(b[3]) || a[1].localeCompare(b[1]); }); document.write('<pre>'); array.forEach(function (a) { document.write(JSON.stringify(a) + '<br>'); });
You could concat the 2 variables together into a sortkey and use that for your comparison. list.sort(function(a,b){ var aCat = a.var1 + a.var2; var bCat = b.var1 + b.var2; return (aCat > bCat ? 1 : aCat < bCat ? -1 : 0); });
I found multisotr. This is simple, powerfull and small library for multiple sorting. I was need to sort an array of objects with dynamics sorting criteria: const criteria = ['name', 'speciality'] const data = [ { name: 'Mike', speciality: 'JS', age: 22 }, { name: 'Tom', speciality: 'Java', age: 30 }, { name: 'Mike', speciality: 'PHP', age: 40 }, { name: 'Abby', speciality: 'Design', age: 20 }, ] const sorted = multisort(data, criteria) console.log(sorted) <script src="https://cdn.rawgit.com/peterkhayes/multisort/master/multisort.js"></script> This library more mutch powerful, that was my case. Try it.
String Appending Method You can sort by multiple values simply by appending the values into a string and comparing the strings. It is helpful to add a split key character to prevent runoff from one key to the next. Example const arr = [ { a: 1, b: 'a', c: 3 }, { a: 2, b: 'a', c: 5 }, { a: 1, b: 'b', c: 4 }, { a: 2, b: 'a', c: 4 } ] function sortBy (arr, keys, splitKeyChar='~') { return arr.sort((i1,i2) => { const sortStr1 = keys.reduce((str, key) => str + splitKeyChar+i1[key], '') const sortStr2 = keys.reduce((str, key) => str + splitKeyChar+i2[key], '') return sortStr1.localeCompare(sortStr2) }) } console.log(sortBy(arr, ['a', 'b', 'c'])) Recursion Method You can also use Recursion to do this. It is a bit more complex than the String Appending Method but it allows you to do ASC and DESC on the key level. I'm commenting on each section as it is a bit more complex. There are a few commented out tests to show and verify the sorting works with a mixture of order and default order. Example const arr = [ { a: 1, b: 'a', c: 3 }, { a: 2, b: 'a', c: 5 }, { a: 1, b: 'b', c: 4 }, { a: 2, b: 'a', c: 4 } ] function sortBy (arr, keys) { return arr.sort(function sort (i1,i2, sKeys=keys) { // Get order and key based on structure const compareKey = (sKeys[0].key) ? sKeys[0].key : sKeys[0]; const order = sKeys[0].order || 'ASC'; // ASC || DESC // Calculate compare value and modify based on order let compareValue = i1[compareKey].toString().localeCompare(i2[compareKey].toString()) compareValue = (order.toUpperCase() === 'DESC') ? compareValue * -1 : compareValue // See if the next key needs to be considered const checkNextKey = compareValue === 0 && sKeys.length !== 1 // Return compare value return (checkNextKey) ? sort(i1, i2, sKeys.slice(1)): compareValue; }) } // console.log(sortBy(arr, ['a', 'b', 'c'])) console.log(sortBy(arr, [{key:'a',order:'desc'}, 'b', 'c'])) // console.log(sortBy(arr, ['a', 'b', {key:'c',order:'desc'}])) // console.log(sortBy(arr, ['a', {key:'b',order:'desc'}, 'c'])) // console.log(sortBy(arr, [{key:'a',order:'asc'}, {key:'b',order:'desc'}, {key:'c',order:'desc'}]))
Try this: t.sort( (a,b)=> a[3].localeCompare(b[3]) || a[1].localeCompare(b[1]) ); let t = [ //[publicationID, publication_name, ownderID, owner_name ] [1, 'ZBC', 3, 'John Smith'], [2, 'FBC', 5, 'Mike Tyson'], [3, 'ABC', 7, 'Donald Duck'], [4, 'DBC', 1, 'Michael Jackson'], [5, 'XYZ', 2, 'Michael Jackson'], [6, 'BBC', 4, 'Michael Jackson'], ]; // owner_name subarrray index = 3 // publication_name subarrray index = 1 t.sort( (a,b)=> a[3].localeCompare(b[3]) || a[1].localeCompare(b[1]) ); console.log(t.join('\n')); I assume that your data in array let t = [ [publicationID, publication_name, ownderID, owner_name ], ... ] where index of owner_name = 3 and publication_name =1.
I was working with ng-grid and needed to to multiple column sorting on an array of records returned from an API, so I came up with this nifty, dynamic multi-sort function. First of all, ng-grid fires an "event" for "ngGridSorted" and passes this structure back, describing the sort: sortData = { columns: DOM Element, directions: [], //Array of string values desc or asc. Each index relating to the same index of fields fields: [], //Array of string values }; So I built a function that will dynamically generate a sort function based on the sortData as shown above (Don't be scared by the scroll bar! It's only about 50 lines long! Also, I'm sorry about the slop. It prevented a horizontal scrollbar!): function SortingFunction(sortData) { this.sortData = sortData; this.sort = function(a, b) { var retval = 0; if(this.sortData.fields.length) { var i = 0; /* Determine if there is a column that both entities (a and b) have that are not exactly equal. The first one that we find will be the column we sort on. If a valid column is not located, then we will return 0 (equal). */ while( ( !a.hasOwnProperty(this.sortData.fields[i]) || !b.hasOwnProperty(this.sortData.fields[i]) || (a.hasOwnProperty(this.sortData.fields[i]) && b.hasOwnProperty(this.sortData.fields[i]) && a[this.sortData.fields[i]] === b[this.sortData.fields[i]]) ) && i < this.sortData.fields.length){ i++; } if(i < this.sortData.fields.length) { /* A valid column was located for both entities in the SortData. Now perform the sort. */ if(this.sortData.directions && i < this.sortData.directions.length && this.sortData.directions[i] === 'desc') { if(a[this.sortData.fields[i]] > b[this.sortData.fields[i]]) retval = -1; else if(a[this.sortData.fields[i]] < b[this.sortData.fields[i]]) retval = 1; } else { if(a[this.sortData.fields[i]] < b[this.sortData.fields[i]]) retval = -1; else if(a[this.sortData.fields[i]] > b[this.sortData.fields[i]]) retval = 1; } } } return retval; }.bind(this); } I then sort the results of my API (results) like so: results.sort(new SortingFunction(sortData).sort); I hope somebody else enjoys this solution as much as I do! Thanks!
I had a similar problem while displaying memory pool blocks from the output of some virtual DOM h-functions composition. Basically I faced to the same problem as sorting multi-criteria data like scoring results from players around the world. I have noticed that multi-criteria sorting is: - sort by the first column - if equal, sort by the second - if equal, sort by the third - etc... nesting and nesting if-else And if you don't care, you could fail quickly in a if-else nesting hell... like callback hell of promises... What about if we write a "predicate" function to decide if which part of alternative using ? The predicate is simply : // useful for chaining test const decide = (test, other) => test === 0 ? other : test Now after having written your classifying tests (byCountrySize, byAge, byGameType, byScore, byLevel...) whatever who need, you can weight your tests (1 = asc, -1 = desc, 0 = disable), put them in an array, and apply a reducing 'decide' function like this: const multisort = (s1, s2) => { const bcs = -1 * byCountrySize(s1, s2) // -1 = desc const ba = 1 *byAge(s1, s2) const bgt = 0 * byGameType(s1, s2) // 0 = doesn't matter const bs = 1 * byScore(s1, s2) const bl = -1 * byLevel(s1, s2) // -1 = desc // ... other weights and criterias // array order matters ! return [bcs, ba, bgt, bs, bl].reduce((acc, val) => decide(val, acc), 0) } // invoke [].sort with custom sort... scores.sort(multisort) And voila ! It's up to you to define your own criterias / weights / orders... but you get the idea. Hope this helps ! EDIT: * ensure that there is a total sorting order on each column * be aware of not having dependencies between columns orders, and no circular dependencies if, not, sorting can be unstable !
function multiSort() { var args =$.makeArray( arguments ), sortOrder=1, prop='', aa='', b=''; return function (a, b) { for (var i=0; i<args.length; i++){ if(args[i][0]==='-'){ prop=args[i].substr(1) sortOrder=-1 } else{sortOrder=1; prop=args[i]} aa = a[prop].toLowerCase() bb = b[prop].toLowerCase() if (aa < bb) return -1 * sortOrder; if (aa > bb) return 1 * sortOrder; } return 0 } } empArray.sort(multiSort( 'lastname','firstname')) Reverse with '-lastname'
My own library for working with ES6 iterables (blinq) allows (among other things) easy multi-level sorting const blinq = window.blinq.blinq // or import { blinq } from 'blinq' // or const { blinq } = require('blinq') const dates = [{ day: 1, month: 10, year: 2000 }, { day: 1, month: 1, year: 2000 }, { day: 2, month: 1, year: 2000 }, { day: 1, month: 1, year: 1999 }, { day: 1, month: 1, year: 2000 } ] const sortedDates = blinq(dates) .orderBy(x => x.year) .thenBy(x => x.month) .thenBy(x => x.day); console.log(sortedDates.toArray()) // or console.log([...sortedDates]) <script src="https://cdn.jsdelivr.net/npm/blinq#2.0.2"></script>
I have just published to npm a micro-library called sort-helper (source on github). The idea is to import the helper by to create the comparison function for sort array method through the syntax items.sort(by(column, ...otherColumns)), with several way to express the columns to sort by: By key: persons.sort(by('lastName', 'firstName')), By selector: dates.sort(by(x => x.toISOString())), In descending order: [3, 2, 4, 1].sort(by(desc(n => n))) → [3, 2, 1, 0], Ignoring case: ['B', 'D', 'c', 'a'].sort(by(ignoreCase(x => x))).join('') → 'aBcD'. It's similar to the nice thenBy mentioned in this answer but with the following differences that may be more to the taste of some: An approach more functional than object-oriented (see thenBy fluent API), A syntax a bit terser and still as much readable, natural almost like SQL. Fully implemented in TypeScript, to benefit from type safety and type expressivity.
Sourced from GitHub function sortMethodAsc(a, b) { return a == b ? 0 : a > b ? 1 : -1; } function sortMethodWithDirection(direction) { if (direction === undefined || direction == "asc") { return sortMethodAsc; } else { return function(a, b) { return -sortMethodAsc(a, b); } } } function sortMethodWithDirectionByColumn(columnName, direction){ const sortMethod = sortMethodWithDirection(direction) return function(a, b){ return sortMethod(a[columnName], b[columnName]); } } function sortMethodWithDirectionMultiColumn(sortArray) { //sample of sortArray // sortArray = [ // { column: "column5", direction: "asc" }, // { column: "column3", direction: "desc" } // ] const sortMethodsForColumn = (sortArray || []).map( item => sortMethodWithDirectionByColumn(item.column, item.direction) ); return function(a,b) { let sorted = 0; let index = 0; while (sorted === 0 && index < sortMethodsForColumn.length) { sorted = sortMethodsForColumn[index++](a,b); } return sorted; } } //============================================= //============================================= //============================================= //test var data = [ {"CountryName":"Aruba","CountryCode":"ABW","GNI":280},{ "CountryName":"Afghanistan","CountryCode":"ABW","GNI":280},{"CountryName":"Angola","CountryCode":"AGO","GNI":280},{"CountryName":"Albania","CountryCode":"ALB","GNI":4320}, {"CountryName":"Arab World","CountryCode":"ARB","GNI":280},{"CountryName":"United Arab Emirates","CountryCode":"ARE","GNI":39130}, {"CountryName":"Argentina","CountryCode":"ARG","GNI":13030},{"CountryName":"Armenia","CountryCode":"ARM","GNI":3990},{"CountryName":"American Samoa","CountryCode":"ASM","GNI":280}, {"CountryName":"Antigua and Barbuda","CountryCode":"ATG","GNI":13810},{"CountryName":"Australia","CountryCode":"AUS","GNI":51360}, {"CountryName":"Austria","CountryCode":"AUT","GNI":45440},{"CountryName":"Azerbaijan","CountryCode":"AZE","GNI":4080},{"CountryName":"Burundi","CountryCode":"BDI","GNI":280}, {"CountryName":"Belgium","CountryCode":"BEL","GNI":41790},{"CountryName":"Benin","CountryCode":"BEN","GNI":800},{"CountryName":"Burkina Faso","CountryCode":"BFA","GNI":590}, {"CountryName":"Bangladesh","CountryCode":"BGD","GNI":1470},{"CountryName":"Bulgaria","CountryCode":"BGR","GNI":7860},{"CountryName":"Bahrain","CountryCode":"BHR","GNI":21150}, {"CountryName":"Bosnia and Herzegovina","CountryCode":"BIH","GNI":4910},{"CountryName":"Belarus","CountryCode":"BLR","GNI":5280}, {"CountryName":"Belize","CountryCode":"BLZ","GNI":4390},{"CountryName":"Bolivia","CountryCode":"BOL","GNI":3130},{"CountryName":"Brazil","CountryCode":"BRA","GNI":8600}, {"CountryName":"Barbados","CountryCode":"BRB","GNI":15270},{"CountryName":"Brunei Darussalam","CountryCode":"BRN","GNI":29600}, {"CountryName":"Bhutan","CountryCode":"BTN","GNI":2660},{"CountryName":"Botswana","CountryCode":"BWA","GNI":6730}, {"CountryName":"Central African Republic","CountryCode":"CAF","GNI":390},{"CountryName":"Canada","CountryCode":"CAN","GNI":42870}, {"CountryName":"Central Europe and the Baltics","CountryCode":"CEB","GNI":13009},{"CountryName":"Switzerland","CountryCode":"CHE","GNI":80560}, {"CountryName":"Chile","CountryCode":"CHL","GNI":13610},{"CountryName":"China","CountryCode":"CHN","GNI":8690},{"CountryName":"Cote d'Ivoire","CountryCode":"CIV","GNI":1580}, {"CountryName":"Cameroon","CountryCode":"CMR","GNI":1370},{"CountryName":"Colombia","CountryCode":"COL","GNI":5890},{"CountryName":"Comoros","CountryCode":"COM","GNI":1280}, {"CountryName":"Cabo Verde","CountryCode":"CPV","GNI":3030},{"CountryName":"Costa Rica","CountryCode":"CRI","GNI":11120}, {"CountryName":"Caribbean small states","CountryCode":"CSS","GNI":8909},{"CountryName":"Cyprus","CountryCode":"CYP","GNI":23720}, {"CountryName":"Czech Republic","CountryCode":"CZE","GNI":18160},{"CountryName":"Germany","CountryCode":"DEU","GNI":43490}, {"CountryName":"Djibouti","CountryCode":"DJI","GNI":1880},{"CountryName":"Dominica","CountryCode":"DMA","GNI":6590},{"CountryName":"Denmark","CountryCode":"DNK","GNI":55220}, {"CountryName":"Dominican Republic","CountryCode":"DOM","GNI":6630},{"CountryName":"Algeria","CountryCode":"DZA","GNI":3940}, {"CountryName":"East Asia & Pacific (excluding high income)","CountryCode":"EAP","GNI":6987},{"CountryName":"Early-demographic dividend","CountryCode":"EAR","GNI":3352}, {"CountryName":"East Asia & Pacific","CountryCode":"EAS","GNI":10171},{"CountryName":"Europe & Central Asia (excluding high income)","CountryCode":"ECA","GNI":7375}, {"CountryName":"Europe & Central Asia","CountryCode":"ECS","GNI":22656},{"CountryName":"Ecuador","CountryCode":"ECU","GNI":5920}, {"CountryName":"Euro area","CountryCode":"EMU","GNI":35645},{"CountryName":"Spain","CountryCode":"ESP","GNI":27180},{"CountryName":"Estonia","CountryCode":"EST","GNI":18190}, {"CountryName":"Ethiopia","CountryCode":"ETH","GNI":740},{"CountryName":"European Union","CountryCode":"EUU","GNI":32784}, {"CountryName":"Fragile and conflict affected situations","CountryCode":"FCS","GNI":1510},{"CountryName":"Finland","CountryCode":"FIN","GNI":44580}, {"CountryName":"Fiji","CountryCode":"FJI","GNI":4970},{"CountryName":"France","CountryCode":"FRA","GNI":37970},{"CountryName":"Gabon","CountryCode":"GAB","GNI":6650}, {"CountryName":"United Kingdom","CountryCode":"GBR","GNI":40530},{"CountryName":"Georgia","CountryCode":"GEO","GNI":3780},{"CountryName":"Ghana","CountryCode":"GHA","GNI":1880}, {"CountryName":"Guinea","CountryCode":"GIN","GNI":790},{"CountryName":"Guinea-Bissau","CountryCode":"GNB","GNI":660}, {"CountryName":"Equatorial Guinea","CountryCode":"GNQ","GNI":7050},{"CountryName":"Greece","CountryCode":"GRC","GNI":18090}, {"CountryName":"Grenada","CountryCode":"GRD","GNI":9180},{"CountryName":"Guatemala","CountryCode":"GTM","GNI":4060},{"CountryName":"Guyana","CountryCode":"GUY","GNI":4500}, {"CountryName":"High income","CountryCode":"HIC","GNI":40142},{"CountryName":"Honduras","CountryCode":"HND","GNI":2250},{"CountryName":"Heavily indebted poor countries (HIPC)","CountryCode":"HPC","GNI":904},{"CountryName":"Croatia","CountryCode":"HRV","GNI":12570},{"CountryName":"Haiti","CountryCode":"HTI","GNI":760},{"CountryName":"Hungary","CountryCode":"HUN","GNI":12870},{"CountryName":"IBRD only","CountryCode":"IBD","GNI":5745},{"CountryName":"IDA & IBRD total","CountryCode":"IBT","GNI":4620},{"CountryName":"IDA total","CountryCode":"IDA","GNI":1313},{"CountryName":"IDA blend","CountryCode":"IDB","GNI":1791}, {"CountryName":"Indonesia","CountryCode":"IDN","GNI":3540},{"CountryName":"IDA only","CountryCode":"IDX","GNI":1074},{"CountryName":"India","CountryCode":"IND","GNI":1800},{"CountryName":"Ireland","CountryCode":"IRL","GNI":55290},{"CountryName":"Iraq","CountryCode":"IRQ","GNI":4630},{"CountryName":"Iceland","CountryCode":"ISL","GNI":60830},{"CountryName":"Israel","CountryCode":"ISR","GNI":37270},{"CountryName":"Italy","CountryCode":"ITA","GNI":31020},{"CountryName":"Jamaica","CountryCode":"JAM","GNI":4760},{"CountryName":"Jordan","CountryCode":"JOR","GNI":3980},{"CountryName":"Japan","CountryCode":"JPN","GNI":38550},{"CountryName":"Kazakhstan","CountryCode":"KAZ","GNI":7970},{"CountryName":"Kenya","CountryCode":"KEN","GNI":1460},{"CountryName":"Kyrgyz Republic","CountryCode":"KGZ","GNI":1130}, {"CountryName":"Cambodia","CountryCode":"KHM","GNI":1230},{"CountryName":"Kiribati","CountryCode":"KIR","GNI":3010},{"CountryName":"St. Kitts and Nevis","CountryCode":"KNA","GNI":16240},{"CountryName":"Kuwait","CountryCode":"KWT","GNI":31430},{"CountryName":"Latin America & Caribbean (excluding high income)","CountryCode":"LAC","GNI":7470},{"CountryName":"Lao PDR","CountryCode":"LAO","GNI":2270},{"CountryName":"Lebanon","CountryCode":"LBN","GNI":8400},{"CountryName":"Liberia","CountryCode":"LBR","GNI":620},{"CountryName":"Libya","CountryCode":"LBY","GNI":5500},{"CountryName":"St. Lucia","CountryCode":"LCA","GNI":8830},{"CountryName":"Latin America & Caribbean","CountryCode":"LCN","GNI":8251},{"CountryName":"Least developed countries: UN classification","CountryCode":"LDC","GNI":1011},{"CountryName":"Low income","CountryCode":"LIC","GNI":774},{"CountryName":"Sri Lanka","CountryCode":"LKA","GNI":3850},{"CountryName":"Lower middle income","CountryCode":"LMC","GNI":2118},{"CountryName":"Low & middle income","CountryCode":"LMY","GNI":4455},{"CountryName":"Lesotho","CountryCode":"LSO","GNI":1210},{"CountryName":"Late-demographic dividend","CountryCode":"LTE","GNI":8518},{"CountryName":"Lithuania","CountryCode":"LTU","GNI":15200},{"CountryName":"Luxembourg","CountryCode":"LUX","GNI":70260},{"CountryName":"Latvia","CountryCode":"LVA","GNI":14740},{"CountryName":"Morocco","CountryCode":"MAR","GNI":2860},{"CountryName":"Moldova","CountryCode":"MDA","GNI":2200},{"CountryName":"Madagascar","CountryCode":"MDG","GNI":400},{"CountryName":"Maldives","CountryCode":"MDV","GNI":9760}, {"CountryName":"Middle East & North Africa","CountryCode":"MEA","GNI":7236},{"CountryName":"Mexico","CountryCode":"MEX","GNI":8610},{"CountryName":"Marshall Islands","CountryCode":"MHL","GNI":4840},{"CountryName":"Middle income","CountryCode":"MIC","GNI":4942},{"CountryName":"Mali","CountryCode":"MLI","GNI":770}, {"CountryName":"Malta","CountryCode":"MLT","GNI":24080},{"CountryName":"Myanmar","CountryCode":"MMR","GNI":1210},{"CountryName":"Middle East & North Africa (excluding high income)","CountryCode":"MNA","GNI":3832},{"CountryName":"Montenegro","CountryCode":"MNE","GNI":7400},{"CountryName":"Mongolia","CountryCode":"MNG","GNI":3270},{"CountryName":"Mozambique","CountryCode":"MOZ","GNI":420},{"CountryName":"Mauritania","CountryCode":"MRT","GNI":1100},{"CountryName":"Mauritius","CountryCode":"MUS","GNI":10130},{"CountryName":"Malawi","CountryCode":"MWI","GNI":320},{"CountryName":"Malaysia","CountryCode":"MYS","GNI":9650},{"CountryName":"North America","CountryCode":"NAC","GNI":56721},{"CountryName":"Namibia","CountryCode":"NAM","GNI":4570},{"CountryName":"Niger","CountryCode":"NER","GNI":360},{"CountryName":"Nigeria","CountryCode":"NGA","GNI":2100}, {"CountryName":"Nicaragua","CountryCode":"NIC","GNI":2130},{"CountryName":"Netherlands","CountryCode":"NLD","GNI":46180},{"CountryName":"Norway","CountryCode":"NOR","GNI":75990},{"CountryName":"Nepal","CountryCode":"NPL","GNI":800},{"CountryName":"Nauru","CountryCode":"NRU","GNI":10220},{"CountryName":"New Zealand","CountryCode":"NZL","GNI":38970},{"CountryName":"OECD members","CountryCode":"OED","GNI":37273},{"CountryName":"Oman","CountryCode":"OMN","GNI":14440},{"CountryName":"Other small states","CountryCode":"OSS","GNI":12199},{"CountryName":"Pakistan","CountryCode":"PAK","GNI":1580},{"CountryName":"Panama","CountryCode":"PAN","GNI":13280},{"CountryName":"Peru","CountryCode":"PER","GNI":5960},{"CountryName":"Philippines","CountryCode":"PHL","GNI":3660},{"CountryName":"Palau","CountryCode":"PLW","GNI":12700},{"CountryName":"Papua New Guinea","CountryCode":"PNG","GNI":2340},{"CountryName":"Poland","CountryCode":"POL","GNI":12730},{"CountryName":"Pre-demographic dividend","CountryCode":"PRE","GNI":1379},{"CountryName":"Portugal","CountryCode":"PRT","GNI":19820},{"CountryName":"Paraguay","CountryCode":"PRY","GNI":5470},{"CountryName":"West Bank and Gaza","CountryCode":"PSE","GNI":3180},{"CountryName":"Pacific island small states","CountryCode":"PSS","GNI":3793},{"CountryName":"Post-demographic dividend","CountryCode":"PST","GNI":41609},{"CountryName":"Qatar","CountryCode":"QAT","GNI":60510},{"CountryName":"Romania","CountryCode":"ROU","GNI":10000},{"CountryName":"Russian Federation","CountryCode":"RUS","GNI":9230},{"CountryName":"Rwanda","CountryCode":"RWA","GNI":720},{"CountryName":"South Asia","CountryCode":"SAS","GNI":1729},{"CountryName":"Saudi Arabia","CountryCode":"SAU","GNI":20090},{"CountryName":"Sudan","CountryCode":"SDN","GNI":2380},{"CountryName":"Senegal","CountryCode":"SEN","GNI":1240},{"CountryName":"Singapore","CountryCode":"SGP","GNI":54530},{"CountryName":"Solomon Islands","CountryCode":"SLB","GNI":1920},{"CountryName":"Sierra Leone","CountryCode":"SLE","GNI":510},{"CountryName":"El Salvador","CountryCode":"SLV","GNI":3560},{"CountryName":"Serbia","CountryCode":"SRB","GNI":5180},{"CountryName":"Sub-Saharan Africa (excluding high income)","CountryCode":"SSA","GNI":1485},{"CountryName":"Sub-Saharan Africa","CountryCode":"SSF","GNI":1486},{"CountryName":"Small states","CountryCode":"SST","GNI":11099},{"CountryName":"Sao Tome and Principe","CountryCode":"STP","GNI":1770},{"CountryName":"Suriname","CountryCode":"SUR","GNI":5150},{"CountryName":"Slovak Republic","CountryCode":"SVK","GNI":16610},{"CountryName":"Slovenia","CountryCode":"SVN","GNI":22000},{"CountryName":"Sweden","CountryCode":"SWE","GNI":52590},{"CountryName":"Eswatini","CountryCode":"SWZ","GNI":2950},{"CountryName":"Seychelles","CountryCode":"SYC","GNI":14170},{"CountryName":"Chad","CountryCode":"TCD","GNI":640},{"CountryName":"East Asia & Pacific (IDA & IBRD countries)","CountryCode":"TEA","GNI":7061}, {"CountryName":"Europe & Central Asia (IDA & IBRD countries)","CountryCode":"TEC","GNI":7866},{"CountryName":"Togo","CountryCode":"TGO","GNI":610},{"CountryName":"Thailand","CountryCode":"THA","GNI":5950},{"CountryName":"Tajikistan","CountryCode":"TJK","GNI":990},{"CountryName":"Turkmenistan","CountryCode":"TKM","GNI":6380},{"CountryName":"Latin America & the Caribbean (IDA & IBRD countries)","CountryCode":"TLA","GNI":8179},{"CountryName":"Timor-Leste","CountryCode":"TLS","GNI":1790},{"CountryName":"Middle East & North Africa (IDA & IBRD countries)","CountryCode":"TMN","GNI":3839},{"CountryName":"Tonga","CountryCode":"TON","GNI":4010},{"CountryName":"South Asia (IDA & IBRD)","CountryCode":"TSA","GNI":1729}, {"CountryName":"Sub-Saharan Africa (IDA & IBRD countries)","CountryCode":"TSS","GNI":1486},{"CountryName":"Trinidad and Tobago","CountryCode":"TTO","GNI":15340},{"CountryName":"Tunisia","CountryCode":"TUN","GNI":3490},{"CountryName":"Turkey","CountryCode":"TUR","GNI":10940},{"CountryName":"Tuvalu","CountryCode":"TUV","GNI":4970},{"CountryName":"Tanzania","CountryCode":"TZA","GNI":910},{"CountryName":"Uganda","CountryCode":"UGA","GNI":600},{"CountryName":"Ukraine","CountryCode":"UKR","GNI":2390},{"CountryName":"Upper middle income","CountryCode":"UMC","GNI":8197},{"CountryName":"Uruguay","CountryCode":"URY","GNI":15250},{"CountryName":"United States","CountryCode":"USA","GNI":58270},{"CountryName":"Uzbekistan","CountryCode":"UZB","GNI":2000},{"CountryName":"St. Vincent and the Grenadines","CountryCode":"VCT","GNI":7390},{"CountryName":"Vietnam","CountryCode":"VNM","GNI":2160},{"CountryName":"Vanuatu","CountryCode":"VUT","GNI":2920},{"CountryName":"World","CountryCode":"WLD","GNI":10371},{"CountryName":"Samoa","CountryCode":"WSM","GNI":4090},{"CountryName":"Kosovo","CountryCode":"XKX","GNI":3900}, {"CountryName":"South Africa","CountryCode":"ZAF","GNI":5430},{"CountryName":"Zambia","CountryCode":"ZMB","GNI":1290},{"CountryName":"Zimbabwe","CountryCode":"ZWE","GNI":1170}, {"CountryName":"Zimbabwe","CountryCode":"ZWE","GNI":1171}]; const sortMethod = sortMethodWithDirectionMultiColumn( [ { column: "GNI", direction: "asc" }, { column: "CountryCode", direction: "desc" } ] ); let sortedData = data.sort(sortMethod); console.log("sorted by: 1)column:GNI-asc, 2)column:CountryCode-desc") console.table(sortedData); console.log(sortedData);
I need this for a small project I'm working on, so performance is not a priority. I have two arrays, main array I want to be sorted, and array of sorting rules. I loop that rules array inside sorting callback function, and try to exit that loop as soon as possible. I use multiplier in order to convert -1 to 1 depending on weather I'm sorting a property in ascending or descending order. let array = [ {fullName: 'Michael Schumacher', sport: 'Formula 1'}, {fullName: 'Michael Jordan', sport: 'Basketball'}, {fullName: 'Damon Hill', sport: 'Formula 1'}, {fullName: 'Kobe Bryant', sport: 'Basketball'}, {fullName: 'Lebron James', sport: 'Basketball'}, {fullName: 'Lewis Hamilton', sport: 'Formula 1'}, ]; const sortArray = (array, options) => { if (!Array.isArray(options)) { options = [{ key: options, order: 'asc' }]; } options.forEach(item => { item.multiplier = item.order != 'desc' ? -1 : 1; }); return array.sort((firstItem, secondItem) => { for (item of options) { const { key, multiplier } = item; const firstValue = firstItem[key]; const secondValue = secondItem[key]; if (firstValue != secondValue) { return multiplier * (firstValue < secondValue ? 1 : -1); } } return 0; }); } console.log('Original array'); console.log([...array]); sortArray(array, 'sport'); console.log('Sorted by sport only (ascending, implicit, keeping the same order of athletes)'); console.log([...array]); sortArray(array, [{key: 'sport'}, {key: 'fullName', order: 'desc'}]); console.log('Sorted by sport (ascending, implicit), and by fullName (descending)'); console.log(array);
To simplify the understanding The sort method compares numbers, if below 0, it sorts it to the let, if above zero it sorts it to the right. So to add multi level sorting, check if the match === 0, then further sort it. See example below ['a/b/c', 'a long piece of text/b', 'apple/b'].sort((a, b) => { const asc = a.split('/').length - b.split('/').length return asc }) // outputs ['a long piece of text/b', 'apple/b', 'a/b/c'] ['a/b/c', 'a long piece of text/b', 'apple/b'].sort((a, b) => { const asc = a.split('/').length - b.split('/').length return asc === 0 ? a.length - b.length : asc }) // outputs: 'apple/b', 'a long piece of text/b', 'a/b/c'
I see a lot of complicated solutions, so I'll paste here what I'm using: assignedIssues.sort((a, b) => { let order = sortByText(a.assignee?.username, b.assignee?.username) if (order === 0) order = sort(a.labels, b.labels, statusLabels) if (order === 0) order = sort(a.labels, b.labels, priorityLabels) if (order === 0) order = sortByText(a.web_url, b.web_url) return order }) I think that this is much more readable, let you implement any custom sorting function for each level, without calling all unnecessarily.
Assuming you want to sort by multiple indexes, and assuming that you don't know the type of each field (string, number, or null). You can create a function to sort with as many indexes as you like. const compareWithType = (a, b) => { if (typeof a === 'string') return a.localeCompare(b); if (typeof a === 'number') return a - b; return (!!a) - (!!b); // to sort non-string non-number falsy or null values, modify as you like. } const compareWithIndexes = (...indexes) => { return (a, b) => { for (let i in indexes) { let diff = 0; while (!diff) { compareWithType(a[i], b[i]); } return diff; } } } [[1, 2, 3, 4, 5], [0, 2, 3, 4, 6]].sort(compareWithIndexes(2, 3, 4)); // compares (3 - 3) then (4 - 4) then (5 - 6)
Despite a lot of complicated answers here, I still like the basic way to do it var arr = [ [3, 'pub2', 1, 'ownA'], [1, 'pub1', 2, 'ownA'], [2, 'pub1', 3, 'ownC'] ]; // sorting priority is bottom to top, in this case owner name then publication name // sort publication name arr.sort((a,b) => a[1].localeCompare(b[1])); // sort owner name arr.sort((a,b) => a[3].localeCompare(b[3])); console.log(arr);
Comparing arrays of strings for similarity
I have available to me hundreds of JSON strings. Each of these contains an array of 15-20 words sorted by some predetermined weight. This weight, if it's worth noting, is the amount of times these words are found in some chunk of text. What's the best way of finding similarity between arrays of words that are structured like this? First idea that came to my head was to create a numerical hash of all the words together and basically compare these values to determine similarity. I wasn't very successful with this, since the resulting hash values of very similar strings were not very close. After some research regarding string comparison algorithms, I come to Stackoverflow in hopes of receiving more guidance. Thanks in advance, and please let me know if you need more details of the problem. Edit 1: Clarifying what I'm trying to do: I want to determine how similar two arrays are according to the words each of these have. I would also like to take into consideration the weight each word carries in each array. For example: var array1 = [{"word":"hill","count":5},{"word":"head","count":5}]; var array2 = [{"word":"valley","count":7},{"word":"head","count":5}]; var array3 = [{"word":"head", "count": 6}, {"word": "valley", "count": 5}]; var array4 = [{"word": "valley", "count": 7}, {"word":"head", "count": 5}]; In that example, array 4 and array 2 are more similar than array 2 and array 3 because, even though both have the same words, the weight is the same for both of them in array 4 and 2. I hope that makes it a little bit easier to understand. Thanks in advance.
I think that what you want is "cosine similarity", and you might also want to look at vector space models. If you are coding In Java, you can use the open source S-space package. (added on 31 Oct) Each element of the vector is the count of one particular string. You just need to transform your arrays of strings into such vectors. In your example, you have three words - "hill", "head", "valley". If your vector is in that order, the vectors corresponding to the arrays would be // array: #hill, #head, #valley array1: {5, 5, 0} array2: {0, 5, 7} array3: {0, 6, 5} array4: {0, 5, 7}
Given that each array has to be compared to every other array, you are looking at a serious amount of processing along the lines of ∑(n-1) times the average number of "words" in each array. You'll need to store the score for each comparison, then make some sense of it. e.g. var array1 = [{"word":"hill","count":5},{"word":"head","count":5}]; var array2 = [{"word":"valley","count":7},{"word":"head","count":5}]; var array3 = [{"word":"head", "count": 6}, {"word": "valley", "count": 5}]; var array4 = [{"word": "valley", "count": 7}, {"word":"head", "count": 5}]; // Comparison score is summed product of matching word counts function compareThings() { var a, b, i = arguments.length, j, m, mLen, n, nLen; var word, score, result = []; if (i < 2) return; // For each array while (i--) { a = arguments[i]; j = i; // Compare with every other array while (j--) { b = arguments[j]; score = 0; // For each word in array for (m=0, mLen = b.length; m<mLen; m++) { word = b[m].word // Compare with each word in other array for (n=0, nLen=a.length; n<nLen; n++) { // Add to score if (a[n].word == word) { score += a[n].count * b[m].count; } } } // Put score in result result.push(i + '-' + j + ':' + score); } } return result; } var results = compareThings(array1, array2, array3, array4); alert('Raw results:\n' + results.join('\n')); /* Raw results: 3-2:65 3-1:74 3-0:25 2-1:65 2-0:30 1-0:25 */ results.sort(function(a, b) { a = a.split(':')[1]; b = b.split(':')[1]; return b - a; }); alert('Sorted results:\n' + results.join('\n')); /* Sorted results: 3-1:74 3-2:65 2-1:65 2-0:30 3-0:25 1-0:25 */ So 3-1 (array4 and array2) have the highest score. Fortunately the comparison need only be one way, you don't have to compare a to b and b to a.
Here is an attempt. The algorithm is not very smart (a difference > 20 is the same as not having the same words), but could be a useful start: var wordArrays = [ [{"word":"hill","count":5},{"word":"head","count":5}] , [{"word":"valley","count":7},{"word":"head","count":5}] , [{"word":"head", "count": 6}, {"word": "valley", "count": 5}] , [{"word": "valley", "count": 7}, {"word":"head", "count": 5}] ] function getSimilarTo(index){ var src = wordArrays[index] , values if (!src) return null; // compare with other arrays weighted = wordArrays.map(function(arr, i){ var diff = 0 src.forEach(function(item){ arr.forEach(function(other){ if (other.word === item.word){ // add the absolute distance in count diff += Math.abs(item.count - other.count) } else { // mismatches diff += 20 } }) }) return { arr : JSON.stringify(arr) , index : i , diff : diff } }) return weighted.sort(function(a,b){ if (a.diff > b.diff) return 1 if (a.diff < b.diff) return -1 return 0 }) } /* getSimilarTo(3) [ { arr: '[{"word":"valley","count":7},{"word":"head","count":5}]', index: 1, diff: 100 }, { arr: '[{"word":"valley","count":7},{"word":"head","count":5}]', index: 3, diff: 100 }, { arr: '[{"word":"head","count":6},{"word":"valley","count":5}]', index: 2, diff: 103 }, { arr: '[{"word":"hill","count":5},{"word":"head","count":5}]', index: 0, diff: 150 } ] */
Sort the arrays by word before attempting comparison. Once this is complete, comparing two arrays will require exactly 1 pass through each array. After sorting the arrays, here is a compare algorithm (psuedo-java): int compare(array1, array2) { returnValue = 0; array1Index = 0 array2Index = 0; while (array1Index < array1.length) { if (array2Index < array2.length) { if (array1[array1Index].word == array2[array2Index].word) // words match. { returnValue += abs(array1[array1Index].count - array2[array2Index].count); ++array1Index; ++array2Index; } else // account for the unmatched array2 word. { // 100 is just a number to give xtra weight to unmatched numbers. returnValue += 100 + array2[array2Index].count; ++array2Index; } } else // array2 empty and array1 is not empty. { // 100 is just a number to give xtra weight to unmatched numbers. returnValue += 100 + array1[array1Index].count; } } // account for any extra unmatched array 2 values. while (array2Index < array2.length) { // 100 is just a number to give xtra weight to unmatched numbers. returnValue += 100 + array2[array2Index].count; } return returnValue; }