Storing variables' names in an array

Question

I have four variables and I want to change their values using a function where I just can put in an array storing the variables. I'm making a game which uses a coordinate system and therefore I have four coordinates that I want to constantly update with y-axis and x-axis. I have one array, yAxis, with all y values and one array, xAxis, with all x values. I want to combine them into the coordinates. Of course, I can update them using the following code:

yAxis = [10, 10, 9, 9];
xAxis = [4, 4, 5, 5];

coordinate1 = "" + yAxis[0] + xAxis[0];
coordinate2 = "" + yAxis[1] + xAxis[1];
coordinate3 = "" + yAxis[2] + xAxis[2];
coordinate4 = "" + yAxis[3] + xAxis[3];

But instead of changing their values like earlier I would like to do something like this: This function will take the array below, coordinatesArray as a, yAxis as b, and xAxis as c. Then x is just an integer.

test(a, b, c){
  for(x = 0; x < 4; x++){
    a[x] = "" + b[x] + c[x];
  }
}

and then I would call this function like this:

coordinatesArray = [coordinate1, coordinate2, coordinate3, coordinate4];
test(coordinatesArray, yAxis, xAxis);

What it then should do with whatever array I run the test function with:

coordinatesArray[0] = "" + yAxis[0] + xAxis[0];
coordinatesArray[1] = "" + yAxis[1] + xAxis[1];
coordinatesArray[2] = "" + yAxis[2] + xAxis[2];
coordinatesArray[3] = "" + yAxis[3] + xAxis[3];

And for example coordinatesArray[0] should then represent coordinate1.

So I would create an array to store the variables so I can easily change which variable to target. The problem though, when I run this, a[x] isn't the variable name, instead, it is their values which means this doesn't work. So my question is, is there any way to store the variables' names in an array so I can target them using a function similar to the one I showed? I want to store the names of the variables in an array and then be able to use the name to target the variable so I can change their values.

Answer 1

Arrays in Javascript has only indices not names, that's why you need Object:

yAxis = [10, 10, 9, 9];
xAxis = [4, 4, 5, 5];
coordinatesArray = ['coordinate1', 'coordinate2', 'coordinate3', 'coordinate4'];

function test(a, b, c){
    let arrOfObj = [];
    for(let i=0; i < a.length; i++){
        let obj = {};    
        obj[a[i]] = [b[i], c[i]];
        arrOfObj.push(obj);
    }
    return arrOfObj;
}

console.log(test(coordinatesArray,yAxis,xAxis));

Answer 2

So this is what you're trying to do...

yAxis = [10, 10, 9, 9];
xAxis = [4, 4, 5, 5];

coordinate1 = "magic";
coordinate2 = "will";
coordinate3 = "happen";
coordinate4 = "here";

function test(a, b, c) {
  for(x = 0; x < 4; x++){
    window[a[x]] = "" + b[x] + c[x];
  }
}

function log(a) {
  let output = [];
  for(x = 0; x < 4; x++){
    output.push(window[a[x]]);
  }
  console.log(output);
};

coordinatesArray = ["coordinate1", "coordinate2", "coordinate3", "coordinate4"];

log(coordinatesArray);
test(coordinatesArray, xAxis, yAxis);
log(coordinatesArray);

...but the comments at your question are trying to say that you don't need the variables coordinate1, coordinate2 etc, you can just ALWAYS use one array, like this:

yAxis = [10, 10, 9, 9];
xAxis = [4, 4, 5, 5];

coordinatesArray = ["magic", "will", "happen", "here"];

function test(a, b, c) {
  for(x = 0; x < 4; x++){
    a[x] = "" + b[x] + c[x];
  }
}

console.log(coordinatesArray);
test(coordinatesArray, xAxis, yAxis);
console.log(coordinatesArray);

right?

Answer 3

To me it looks like the OP asks for a simple object based key value store. But I might have gotten this wrong.

Thus the answer first puts the focus on how to generate a list of concatenated pairs of x-y coordinates, which in my opinion is the most pragmatic approach ...

const yAxis = [10, 10, 9, 9];
const xAxis = [4, 4, 5, 5];

const coordinatesList = yAxis.map((y, idx) => `${ y }${ xAxis[idx] }`);

console.log('(...coordinatesList) =>', coordinatesList);

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

If one is not in need of assigning the list's coordinate values, each to a variable-name that could not already be generically created, this list already is a good enough storage.

On the other hand, a destructuring assignment of such a list allows the creation of tailored variables exactly within the scope that is needed (the example code of this approach does also refactor the mapping function from the first provided example) ...

function concatinateCorrespondingBoundArrayItem(partial, idx) {
  return [partial, this[idx]].join('');
}
const yAxis = [10, 10, 9, 9];
const xAxis = [4, 4, 5, 5];

const [
  foo,
  bar,
  baz,
  biz
] = yAxis.map(concatinateCorrespondingBoundArrayItem, xAxis);

console.log('foo bar baz biz :', foo, bar, baz, biz);

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

Finally, the storage the OP might have asked for, has to be object/map based. A possible approach could then look similar to this last provided example ...

function createCoordinateRecord(collector, coordinateName, idx) {
  collector.storage[coordinateName] = [
    collector.yCoordList[idx],
    collector.xCoordList[idx]
  ].join('');
  return collector;
}
const yAxis = [10, 10, 9, 9];
const xAxis = [4, 4, 5, 5];

const coordinateNameList = ['foo', 'bar', 'baz', 'biz']

const coordinatesMap = coordinateNameList.reduce(createCoordinateRecord, {

  xCoordList: xAxis,
  yCoordList: yAxis,
  storage: {}

}).storage;

console.log('coordinatesMap :', coordinatesMap);

console.log('coordinatesMap.foo :', coordinatesMap.foo);
console.log('coordinatesMap.bar :', coordinatesMap.bar);
console.log('coordinatesMap[coordinateNameList[2]] :', coordinatesMap[coordinateNameList[2]]);
console.log('coordinatesMap[coordinateNameList[3]] :', coordinatesMap[coordinateNameList[3]]);

console.log('Object.keys(coordinatesMap) :', Object.keys(coordinatesMap));
console.log('Object.values(coordinatesMap) :', Object.values(coordinatesMap));
console.log('Object.entries(coordinatesMap) :', Object.entries(coordinatesMap));

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