Silly Javascript (blog.learnr.org)

No way to avoid it, I think. Javascript calls Object.toString() to determinate the key. But yes, kind of silly...

See http://news.ycombinator.com/item?id=602004

Actually there may be a way to avoid it: redefine the toString() method of the String prototype or something like that (just an idea in the wild, haven't tried it)...

Yes, JavaScript arrays are not true arrays. Yes, all property names are strings. If you use an integer as an index, it'll be converted to a string.

I suppose it's silly at first, but hopefully at some point, you grow used to it. Crockford's book JavaScript: The Good Parts is a good book that explains many of the oddities in JS.

First of all, I would strongly recommend you read Doug Crockford’s, JavaScript: the Good Parts. JavaScript has a lot of quirks and rough edges, but please do not try to use a language in a professional capacity without learning it first. To be fair, JavaScript pretends to be Java just enough to invite all this ill-advised behavior.

To answer the question fully: JavaScript arrays are really just plain objects. All objects in JavaScript are simply associative arrays, and all associative arrays are string indexed. So, subscripting always causes a string conversion. The Array class provides some convenience methods with .push() .pop() to gloss over this fact, but arrays are really no different than other objects.

Arrays are not hashes

This functionality makes perfect sense as soon as you realise that at its core JavaScript only has a single data structure, and that is objects (aka dictionaries, associative arrays or hashmaps), and arrays are simply a special case with some syntactic sugar built on top of it

I actually think that it's one of JavaScript's better ideas, it's just a shame that the JavaScript doesn't have very strong getter/setter/subscripting functionality so you could implement data structures like JavaScript arrays completely in native JavaScript.

Try to use additional single quotes:

  var x = [];
  x['3'] = 3;
  x['"3"'] = "three";	    
  alert(x);

x is an Array (which should only accept numerics for keys). E.g. you cannot have a String be a "key" in an Array.

However, for an Object (if they used {} instead of []), the property gets converted using String() before being assigned, so you cannot have duplicate values with the same String value. This actually makes sense when you consider that JavaScript isn't a hard typed language and you often don't need to type cast (which comes in handy more often than it fails a programmer).

My opinion: this guy is complaining just to complain, he could throw a _ before that 1 String and it solves his type problem completely.

  >>> x = ["1"];
  ["1"]
  >>> x = {"1": "1"};
  Object 1=1

  var arr = [];
  arr["hello"] = 57;
  arr.world = function() {};
  arr[999.99] = "flibble!";
  arr[54] = 9;
  // arr.length now equals 55

This is the danger of syntax minimalism; using the same operator to refer to elements of both arrays and dictionaries.

Perl has implicit type conversions similar to those of JavaScript, but the syntax of the dereference operation makes it clear what's going on:

    $array[$number] $array[0] $array['0']
    $hash{$key} $hash{'42'} $hash{42}

Even without the obvious variable names, you can tell from the syntax what is going to be converted to a number and what is going to be converted to a string; [] means number and {} means string.

Javascript is stuck with the same syntax for both:

    array[number] array[42] array["42"]
    hash[key] hash[42] hash["42"]

which is apparently somewhat confusing. I know what is going to happen, but the language doesn't help me; it's easy to write code that's misleading.

  sgraham@gerard:~$ lua
  Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
  > a = {}
  > a[0] = "wee"
  > a[1] = "waa"
  > a["1"] = "str"
  > print(a[0])
  wee
  > print(a[1])
  waa
  > print(a["1"])
  str
  > 
  > a["x"] = "wee"
  > a.x = "waa"
  > print(a["x"])
  waa
  > print(a.x)
  waa
  > 

  var baz = "foo";
  foo.bar == foo["bar"] == foo[baz]

Read a book on javascript.

"Javascript: The definitive guide" by O'Reily is the best.

This is not a quirk, Arrays are just objects with a special property 'length' which is set to the highest key that can be converted to an integer, plus one, and the array functions. All keys are however, strings, as with all objects.

For example,

  var arr = [];
  arr.foo = "hello";
  arr["hello"] = function() {};
  arr[40] = 56;
  // arr.length = 41

It's much easier when you understand that arrays in javascript don't exist as a separate data type. They are, as I say, just objects with a couple of convenience methods+length property.