I have an object called assignments which contains arrays as such;
assignments = {
'version_1': [1,2,3,4,5],
'version_2': [6,7,8,9,0],
'version_3': [3,4,5,6,7]
}
if I want to get the values of a particular version I can simply say something like console.log(assignments.version_2);
But what if I have an integer set in a variable? How would I reference the values dynamically. e.g.
var version_id = 2;
console.log(assignments.version_[version_id]);
You can use this :
var version_id = 2;
console.log(assignments["version_" + version_id]);
Or, if you know you only have to support browsers that have es6, you can do :
assignments[`version_${version_id}`]
Es6 template strings make things nicer
Try following
var assignments = {
'version_1': [1, 2, 3, 4, 5],
'version_2': [6, 7, 8, 9, 0],
'version_3': [3, 4, 5, 6, 7]
};
var version_id = 2;
console.log(assignments["version_" + version_id]);
assignments = {
'version_1': [1,2,3,4,5],
'version_2': [6,7,8,9,0],
'version_3': [3,4,5,6,7]
}
console.log(assignments['version_2'])
Related
I've got 50 different lists, called list1, list2, and so forth. I also have a function which rolls a random number between 1 and 50 and then stores the value in a variable called randomNumber, and what I want to do is to access the list with a matching number.
My attempt at access the list looked like this:
document.getElementById("demo").innerHTML = list + randomNumber;
One solution would be to put all 50 lists into one list, and then use the randomNumber to access the right list through index. I am however still curious if this can be done in a way similar to what I was decribing above the code though.
Inserting the arrays into another array and accessing them by their indexes (or assigning them to property values on an object and accessing them by their associated property names) is the right approach.
The only way to reference scoped variables by strings representing their names is by using eval().
However, I will echo the linked MDN article: Don't do this.
⚠️ Warning: Executing JavaScript from a string is an enormous security risk. It is far too easy for a bad actor to run arbitrary code when you use eval(). See Never use eval()!, below.
Here's an example of using eval to reference each of the arrays below:
const list1 = [1, 2, 3];
const list2 = [4, 5, 6];
console.log(eval('list' + '1')); // [1, 2, 3]
console.log(eval('list' + '2')); // [4, 5, 6]
And here's an example of the recommended approach:
const list1 = [1, 2, 3];
const list2 = [4, 5, 6];
// As an object:
const listNames = {
list1,
list2,
};
// As an array:
const lists = [
list1,
list2,
];
console.log(listNames['list' + '1']); // [1, 2, 3]
console.log(lists[0]); // [1, 2, 3]
console.log(listNames['list' + '2']); // [4, 5, 6]
console.log(lists[1]); // [4, 5, 6]
I am learning Javascript on a book and have to practice reversing an array by creating my own reverse function. The array must be reversed without creating a new variable to hold the reversed array. I thought I found a solution, but when I try to output my answer in 2 different ways (see below), I get different outputs:
function reverseArrayInPlace(array) {
for (var i = 0; i < array.length; i += 1) {
array = array.slice(0, i).concat(array.pop()).concat(array.slice(i));
}
console.log(array);
}
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
Here are the outputs:
reverseArrayInPlace(array);
console.log(array);
> [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
> [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
When console.log() is used within the function, I get my desired answer.
When console.log() is used outside the function, I get the original array with the last element missing. I would like an explanation to this phenomenon.
The array in the function is on a different scope than that at the global / window level -- the global array is never touched; the function changes a local copy of it instead.
If you didn't pass array as a parameter to the function, then it would act on the now unmasked global array variable:
function reverseArrayInPlace() { // <-- no parameter
for (var i = 0; i < array.length; i += 1) {
array = array.slice(0, i).concat(array.pop()).concat(array.slice(i));
}
console.log(array);
}
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
reverseArrayInPlace();
console.log(array);
(...although it is generally bad practice to use globals like that, partly because it's easy to accidentally mask them with local variables just as you did here. A better pattern would be for functions to receive their data as params and return a value, so you can decide, when you call the function, what to assign that returned value to.)
Inside reverseArrayInPlace you are reassigning the array variable, not changing (mutating) it. The array you pass in, therefore, is not changed. The inside console.log sees the new array while the one outside sees the original.
Perhaps you want something like this instead
function reverseArrayInPlace(array) {
for (var i = 0; i < array.length; i += 1) {
array = array.slice(0, i).concat(array.pop()).concat(array.slice(i));
}
return array;
}
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var newArray = reverseArrayInPlace(array)
console.log(newArray)
Just a different approach by using the function stack for storing an item of the array by popping the value, check the length of the array and call the function again with the same object reference and then unshift the temporary stored value.
While working for a small amount of values and because of the limited stack, it is not advisable to use this beside of educational purpose.
function reverseArrayInPlace(array) {
var temp = array.pop();
if (array.length) {
reverseArrayInPlace(array);
}
array.unshift(temp);
}
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
reverseArrayInPlace(array);
console.log(array);
.as-console-wrapper { max-height: 100% !important; top: 0; }
In the first loop of your for you are calling array.pop() which modifies the array passed as argument, but then you are creating a new array storing it in the same variable, so the reference to the original array is lost, and then in the subsequent loops the modified array is the one being generated inside your function.
Look at this code, I added a line to copy the original array, thus not modificating the original passed as argument.
function reverseArrayInPlace(array) {
array = array.slice(); //copying the passed array to not change the original
for (var i = 0; i < array.length; i += 1) {
array = array.slice(0, i).concat(array.pop()).concat(array.slice(i));
}
console.log(array);
}
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
reverseArrayInPlace(array);
console.log(array);
Is there a function in lodash which makes a union of two arrays by modifying the first one? Union should add the element only if there are no duplicates.
Something along the lines of
a=[1,2,3,4,5,6]; _.mergeArrays(a, [6,7]);
[1,2,3,4,5,6,7]
This can be easily done with "vanilla" JavaScript. It requires ES5 (2009) only, which is implemented by all the major web browsers.
var array = [1,2,3,4,5];
var anotherArray = [6,7];
anotherArray.forEach(function(val) {
if (array.indexOf(val) === -1) {
array.push(val);
}
});
You can use spread element, Set which does not allow duplicate entries
var a = [1, 2, 3, 4, 5];
var add = [6, 7, 3, 5];
a = [...new Set([...a, ...add])];
console.log(a);
I found many posts on stack overflow about that similar subject but none of them solve this issue here.
<script>
//Array GanginaA contains duplicated values.
//Array GanginaB contains only unique values that have been fetched from GanginaA
GanginaA=[0,1,2,3,4,5,5,6,7,8,9,9];
GanginaB=[0,1,2,3,4,5,6,7,8,9];
var hezi=<!--The Magic Goes Here-->
console.log(hezi);
/*
* Expected Output:
* 5,9
*/
</script>
GanginaA will always be longer or identical to GanginaB so there is no reason to calculate by the value of the longer array length.
GanginaB will always contains unique values that taken from GanginaA so it will always be the shorter array length or identical to GanginaA array.
Now it makes it a lot easier to find doubles.
You can use filter to get the elements like below
GanginaA = [0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9];
GanginaB = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var hezi = GanginaB.filter(function (item, index) {
return GanginaA.indexOf(item) !== GanginaA.lastIndexOf(item)
});
console.log(hezi.join(" , ")); // 5, 9
the easier I can think of :
var hezi=[];
for (var i=0;i<GanginaA.length;i++){
hezi[GanginaA[i]] = GanginaA[i];
hezi[GanginaB[i]] = GanginaB[i];
}
hezi = hezi.filter (function(el){return el!=undefined;});
does everything in O(n) actions and not O(n^2)
Javascript's objects have hashmap like behaviour, so you can use them kind of like a set. If you iterate over all the values and set them to be keys within an object, you can use the Object.keys method to get an array of unique values out.
function uniqueValues() {
var unique = {};
[].forEach.call(arguments, function(array) {
array.forEach(function(value) {
unique[value] = true;
});
});
return Object.keys(unique);
};
This function will return the unique elements in any number of arrays, passed as arguments.
uniqueValues([1, 2, 3], [ 1, 1, 1], [2, 2, 2], [3, 3, 3]); // [ 1, 2 3 ]
One drawback to this method is that Javascript coerces all keys to strings, you can turn them back into numbers by changing the return statement to:
return Object.keys(unique).map(Number);
Assuming this JSON object:
var obj = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
The "set2" property may be retrieved like so:
obj["set2"]
Is there a way to retrieve the "set2" property by index? It is the second property of the JSON object. This does not work (of course):
obj[1]
So, let's say that I want to retrieve the second property of the JSON object, but I don't know its name - how would I do it then?
Update: Yes, I understand that objects are collections of unordered properties. But I don't think that the browsers mess with the "original" order defined by the JSON literal / string.
Objects in JavaScript are collections of unordered properties. Objects are hashtables.
If you want your properties to be in alphabetical order, one possible solution would be to create an index for your properties in a separate array. Just a few hours ago, I answered a question on Stack Overflow which you may want to check out:
Iterating over a JavaScript object in sort order based on particular key value of a child object
Here's a quick adaptation for your object1:
var obj = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
var index = [];
// build the index
for (var x in obj) {
index.push(x);
}
// sort the index
index.sort(function (a, b) {
return a == b ? 0 : (a > b ? 1 : -1);
});
Then you would be able to do the following:
console.log(obj[index[1]]);
The answer I cited earlier proposes a reusable solution to iterate over such an object. That is unless you can change your JSON to as #Jacob Relkin suggested in the other answer, which could be easier.
1 You may want to use the hasOwnProperty() method to ensure that the properties belong to your object and are not inherited from Object.prototype.
I know this is an old question but I found a way to get the fields by index.
You can do it by using the Object.keys method.
When you call the Object.keys method it returns the keys in the order they were assigned (See the example below). I tested the method below in the following browsers:
Google Chrome version 43.0
Firefox version 33.1
Internet Explorer version 11
I also wrote a small extension to the object class so you can call the nth key of the object using getByIndex.
// Function to get the nth key from the object
Object.prototype.getByIndex = function(index) {
return this[Object.keys(this)[index]];
};
var obj1 = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
var obj2 = {
"set2": [4, 5, 6, 7, 8],
"set1": [1, 2, 3],
"set3": [9, 10, 11, 12]
};
log('-- Obj1 --');
log(obj1);
log(Object.keys(obj1));
log(obj1.getByIndex(0));
log('-- Obj2 --');
log(obj2);
log(Object.keys(obj2));
log(obj2.getByIndex(0));
// Log function to make the snippet possible
function log(x) {
var d = document.createElement("div");
if (typeof x === "object") {
x = JSON.stringify(x, null, 4);
}
d.textContent= x;
document.body.appendChild(d);
}
No, there is no way to access the element by index in JavaScript objects.
One solution to this if you have access to the source of this JSON, would be to change each element to a JSON object and stick the key inside of that object like this:
var obj = [
{"key":"set1", "data":[1, 2, 3]},
{"key":"set2", "data":[4, 5, 6, 7, 8]},
{"key":"set3", "data":[9, 10, 11, 12]}
];
You would then be able to access the elements numerically:
for(var i = 0; i < obj.length; i++) {
var k = obj[i]['key'];
var data = obj[i]['data'];
//do something with k or data...
}
Simple solution, just one line..
var obj = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
obj = Object.values(obj);
obj[1]....
Here you can access "set2" property following:
var obj = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
var output = Object.keys(obj)[1];
Object.keys return all the keys of provided object as Array..
Jeroen Vervaeke's answer is modular and the works fine, but it can cause problems if it is using with jQuery or other libraries that count on "object-as-hashtables" feature of Javascript.
I modified it a little to make usable with these libs.
function getByIndex(obj, index) {
return obj[Object.keys(obj)[index]];
}
You could iterate over the object and assign properties to indexes, like this:
var lookup = [];
var i = 0;
for (var name in obj) {
if (obj.hasOwnProperty(name)) {
lookup[i] = obj[name];
i++;
}
}
lookup[2] ...
However, as the others have said, the keys are in principle unordered. If you have code which depends on the corder, consider it a hack. Make sure you have unit tests so that you will know when it breaks.
"""
This could be done in python as follows.
Form the command as a string and then execute
"""
context = {
"whoami": "abc",
"status": "0",
"curStep": 2,
"parentStepStatus": {
"step1":[{"stepStatus": 0, "stepLog": "f1.log"}],
"step2":[{"stepStatus": 0, "stepLog": "f2.log"}]
}
}
def punc():
i = 1
while (i < 10):
x = "print(" + "context" + "['parentStepStatus']" + "['%s']"%("step%s")%(i) + ")"
exec(x)
i+=1
punc()
There is no "second property" -- when you say var obj = { ... }, the properties inside the braces are unordered. Even a 'for' loop walking through them might return them in different orders on different JavaScript implementations.
it is quite simple...
var obj = {
"set1": [1, 2, 3],
"set2": [4, 5, 6, 7, 8],
"set3": [9, 10, 11, 12]
};
jQuery.each(obj, function(i, val) {
console.log(i); // "set1"
console.log(val); // [1, 2, 3]
});
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
var obj = {
"set1": [
1,
2,
3
],
"set2": [
4,
5,
6,
7,
8
],
"set3": [
9,
10,
11,
12
]
};
var outputKeys = Object.keys(obj)[1];
var outputValues = Object.values(obj)[1];
//outputKeys would be "set2"`enter code here`
//outPutValues would be [4,5,6,7,8]
My solution:
Object.prototype.__index=function(index)
{var i=-1;
for (var key in this)
{if (this.hasOwnProperty(key) && typeof(this[key])!=='function')
{++i;
}
if (i>=index)
{return this[key];
}
}
return null;
}
aObj={'jack':3, 'peter':4, '5':'col', 'kk':function(){alert('hell');}, 'till':'ding'};
alert(aObj.__index(4));