Creating an multidimensional associative array in javascript [duplicate] - javascript

This question already has answers here:
Sorting object property by values
(44 answers)
Closed 6 years ago.
I have a list of strings, I want to check if the string contains a specific word, and if it does split all the words in the string and add it to an associative array.
myString = ['RT #Arsenal: Waiting for the international', 'We’re hungry for revenge #_nachomonreal on Saturday\'s match and aiming for a strong finish']
wordtoFind = ['#Arsenal']
I want to loop through the wordtoFind and if it is in myString, split up myString into individual words and create an object like
newWord = {#Arsenal:{RT:1},{Waiting:1},{for:1},{the:1},{international:1}}
for(z=0; z <wordtoFind.length; z++){
for ( i = 0 ; i < myString.length; i++) {
if (myString[i].indexOf(wordtoFind[z].key) > -1){
myString[i].split(" ")
}
I am currently stuck and I am not sure how to continue.

You can't do it. key value objects are not sorted by keys.
take a look at Does JavaScript Guarantee Object Property Order
you can turn it into a sorted array.
// Turn to array
var arr = [];
for(var key in mydict) {
arr.push({key: key, val: mydict[key]})
}
// Sort
arr.sort(function(a, b) {
return a.val - b.val;
})

Use temporary array for sorting your values
var dict = { a: 5, b: 9, z: 21, n: 1, y: 0, g: 3, q: 6 }
var a = Object.keys(dict).map(e => ({ key: e, val: dict[e] }))
.sort((a, b) => a.val - b.val).slice(0, 5);
var r = {};
a.forEach(e => r[e.key] = e.val);
document.write(JSON.stringify(r));

Related

change index in one array in accordance with another one js [duplicate]

This question already has answers here:
Sort two arrays the same way
(12 answers)
Closed 18 days ago.
I need to change indexes of elements in arr a due to their indexes in arr b.
const a = [4,3,2,1,5];
const b = [1,2,3,4,5];
console.log(a) [1,2,3,4,5]
If you mean ordering array a according to array b, then you can do like this:
a.forEach((element,i) => {
// first get the index of a[i] from array b
const index = b.indexOf(a[i])
// then swap them
const temp = a[index];
a[index] = a[i];
a[i] = temp;
})
You could sort by using the other array as index. If this daoes not work with real data, please andd a small amount of data to highlight the problem.
const
a = [4, 3, 2, 1, 5],
b = [1, 2, 3, 4, 5];
a.sort((l, r) => b[l - 1] - b[r - 1]);
console.log(...a);

Sort object based on value highest to lowest [duplicate]

This question already has answers here:
Sorting object property by values
(44 answers)
Closed 3 years ago.
I'm trying to sort an object and rebuild it based on highest to lowest values in Javascript. I've built a function which takes an array of numbers, counts them adds them up and then creates an object, my function for sorting doesn't seem to be working correctly,
const numbersToCount = [10, 10, 10, 5, 4, 3, 2, 2, 1]
function sort () {
var counts = {}
for (var i = 0; i < numbersToCount.length; i++) {
var num = numbersToCount[i];
counts[num] = counts[num] ? counts[num] + 1 : 1;
}
var numbersToSort = []
for (var sort in counts) {
numbersToSort.push([sort , counts[sort]])
}
numbersToSort.sort((a, b) => {
return a[1] - b[1]
})
counts = {}
numbersToSort.forEach((item) => {
counts[item[0]]=item[1]
})
console.log(counts)
}
Currently, counts would output initally:
{
'1': 1,
'2': 2,
'3': 1,
'4': 1,
'5': 1,
'10': 3
}
Object property iteration has separate rules for properties that look like array indexes: in that case they are always ordered in numerical, ascending order.
A quick fix is to agree with yourself to have those properties prefixed with some non-digit character, like an underscore:
Change:
counts[item[0]] =
to:
counts["_" + item[0]] =
Most would advise against using plain objects for keeping a certain order. Alternatively, use a Map, which always sticks to insertion order:
counts = new Map(numbersToSort);
const numbersToCount = [10, 10, 10, 5, 4, 3, 2, 2, 1];
const distinctNumbersToCount = [...new Set(numbersToCount)];
const sortNumbersToCount = distinctNumbersToCount.sort((a, b) => a - b);
const response = sortNumbersToCount.map((number, index) =>{
return { [index]: number }
})
console.log(response);
Output should be:

How do you print the names of variables inside of an array?

I have made an array and placed some variables in it, and I want to get the name of the variable using the index number.
var a = 0;
var b = 0;
var c = 0;
var letters = [a,b,c]
console.log(letters)
I want to have it output "[ a, b, c ]" but this code actually outputs "[0, 0, 0]"
For more context, I plan to take the values of a, b, and c and then sort them based on their values, but then I still want to be able to see their variable names in the new order after they have been sorted.
You can use a object instead, You can get keys as an array using Object.keys and later you sort them
const obj = {
a: 0,
b: 2,
c: 1
};
console.log(Object.keys(obj));
//sort keys based on values
const sorted = Object.keys(obj).sort((a,b)=> obj[a]-obj[b])
console.log(sorted)
Use an object indexed by those variable names instead, and then you can take that object's Object.keys, which will give you an array of the properties:
const obj = {
a: 0,
b: 0,
c: 0
};
console.log(Object.keys(obj));
I want to get the name of the variable using the index number.
Access that index in the Object.keys array, eg Object.keys(obj)[1] will evaluate to b.
To sort, take the Object.entries of the object (which will give you both the key and value at once):
const obj = {
a: 0,
b: 2,
c: 1
};
console.log(
Object.entries(obj)
.sort((a, b) => a[1] - b[1])
);
You can't do it with an array - you'd have to use an object. You can get the keys with Object.keys, and the values with Object.values:
var a = 0;
var b = 0;
var c = 0;
var letters = {a, b, c};
console.log(Object.keys(letters));
console.log(Object.values(letters));
.as-console-wrapper { max-height: 100% !important; top: auto; }
This might resolve your problem:
var variableName = 0;
console.log(Object.keys({
variableName
})[0]);

convert number to array in javascript | typescript for angular7 [duplicate]

This question already has answers here:
How to initialize an array's length in JavaScript?
(20 answers)
How to create an array containing 1...N
(77 answers)
Closed 4 years ago.
i have a number 10 how to convert to this to number array in java script.
answer should be [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
OR How to convert number(10) to number of items in array in javascript
A simple for loop will easily accomplish this task.
var number = 10;
var arr = [];
for(var i = 0; i < number; i++) arr.push(i+1);
console.log(arr)
You can also use:
Array.from(new Array(number), (x,i) => i+1)
var number = 10;
var arr = Array.from(new Array(number), (x,i) => i+1)
console.log(arr)
Lets say you have a variable let a which implies your last number in array and at the same time number of elements in array.
let a = 10;
Now initialize an array which you will populate with numbers
let arr = [];
Now do a for loop and push the numbers in the array.
for (let i = 0; i < a; i++)
arr.push(i+1);
This will populate array arr with numbers from 1 to 10.

javascript array sorting / array match sorted array [duplicate]

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.

Categories

Resources