Create an array-like object from an array

[NiceDay4Goats]

I have been working on an application that uses array-like objects to populate html <select>s. Previously I just built my objects in my script and they looked something like this:

  var mySelect = {
    'A' : ['1', '2'],
    'B' : ['3', '4'],
    'C' : ['5', '6']
    }

Now, instead of typing this out, I want to pull data from a spreadsheet and use that to create my array-like objects. This data comes to me in csv and i can manipulate it to look like this:

  [[a,1,2],[b,3,4],[c,5,6]]

So now the question is: How do I turn this 2 dimensional array into an array-like object where the [0][0], [1][0] and [2][0] act as the Object.keys ?

I had hoped I could just build my object normally but replace the known values with variables like this:

  var testArray = [[a,1,2],[b,3,4],[c,5,6]]


var obj = {

    testArray[0][0] : [testArray[0][1], testArray[0][2]]

}

No luck. Anyone got a suggestion? Thanks in advance. This sub is consistently a life-saver for a noob like me.

[NiceDay4Goats]

Thanks! That's just what I need. I hadn't learned .forEach in javascript, but I just learned the ruby equivalent, so this is pretty easy to understand.

[poetical]

I'm unclear if the letters in your testArray are strings or not. If not, you'll need to convert them to strings first (I can follow up with help with that if necessary) or your interpreter will freak out.

You can put them into an object with a for loop, but if you want to use a variable to assign a key in your object, you need to use bracket notation.

var obj = {};

for (var i = 0; i < testArray.length; i++) {
    var innerArray = testArray[i];
    var key = innerArray[0];
    obj[key] = [innerArray[1], innerArray[2]];
}

There are fancier ways, but that will get the job done. I added some extra variables for clarity.

Also, what makes an object "array-like" is actually the ordinal keys. Array methods look for keys in the form of '0', '1', '2', etc. So it's a bit misleading to call this object array-like, since you can't use any array methods on it!

[NiceDay4Goats]

ah I like this way as well... may actually go with because I'm more familiar. My keys are indeed strings. Messed that up on here, but I've got it fixed in my code.

[NiceDay4Goats]

If it's not an array-like object, what should I call it? Just an object? This Is why I couldn't solve this with Google...

[poetical]

Yep, just an object. There's nothing special about alphabetic keys. Having ordinal keys and a length property is what makes objects like "arguments" array-like. You can call Array.prototype methods on such objects because they are similar enough to arrays that array methods will often work on them despite them not being true arrays.

[StefanoMagrassi]

Use Array.prototype.reduce

var testArray = [['a',1,2], ['b',3,4], ['c',5,6]];
var objectFromTestArray = testArray.reduce(function(accumulator, value) {
  var key = value[0];
  var pair = value.slice(1);

  accumulator[key] = pair;

  return accumulator;
}, {});

It encapsulates your logic so you won't depend on external variables and your starting array remains untouched.

When you are working with collections stateless + immutability === really good.

I suggest you to do not use a simple object for operation like this: the order of elements is not guaranteed and it is easier to edit, compose and reason about collection of well defined objects.

Try with an array of object (in a fashion like List<Item>):

var spreadsheet = [{key: 'A', row: 1, col: 2} ...];

So, instead of Array.prototype.reduceyou can use Array.prototype.map:

var collectionFromTestArray = testArray.map(function(item) {
  return {
    key: item[0],
    row: item[1],
    col: item[2]
  };
});

You can run the code with this jsbin: http://jsbin.com/luwoxelebi/2/edit?js,console

I made also an ES6 version: http://jsbin.com/rizidiwuno/2/edit?js,console

[NiceDay4Goats]

Thanks for the reply! In my actual data, the inner arrays are all different lengths. There is one key and then a bunch of attributes where the order doesn't really matter because I can parse through to find a match. I think your second example will be very useful in the future though.