Lua also have hybrid array, maps and object. It does work well when implemented in a sane way. Lua has different way of iterating the table if you want an array or maps.

... though I wouldn't necessarily call Lua's way of doing things "sane". E.g. if Lua encounters a `nil` somewhere in your table, it will stop iterating.

It's certainly sane in the sense that it was an intentional, if perhaps unusual, design decision. I personally like it since it results in an efficient implementation of sparse arrays.

In any event, Lua 5.2 will respect the __len, __pairs and __ipairs metamethods, so you can tweak this behavior if you need to store nils in your tables and iterate over them.

The world would be a beautiful place if everything intentional were sane :-) It's bitten me a couple of times (e.g. when unpacking arguments in a function to feed them to another function, where one of the arguments is nil) but I can see how it could be the desired behavior in some cases.

> My complaint is that PHP's only first-class array type is a weird array/map combo. Have you ever seen anything like that in another language?

Um, Javascript?

Javascript's arrays cannot be used as maps or associative arrays. Arrays require numeric, consecutive keys. Otherwise it's an Object.

--

Clarification edit: Creating a new key on an array using arr['key']=1 creates a property on the arr Object but does not add an element to the standard array.

http://stackoverflow.com/questions/8630471/strings-as-keys-o...

Arrays are always objects in JavaScript, and they can be extended like any other object or used as maps (barring key conflicts).

Adding non-numeric keys does not remove an Array's "arrayness" in JavaScript

  var x = [];
  console.log(Object.prototype.toString.call(x));
  //[object Array]
  
  x[0] = 1;
  console.log(x[0]);
  //1
  
  x["test"] = 2;
  console.log(x["test"]);
  //2
  
  console.log(Object.prototype.toString.call(x));
  //[object Array]
  
  x.map
  //function map() { [native code] }

  var y = {};
  
  console.log(Object.prototype.toString.call(y));
  //[object Object]
  
  y.map
  //undefined

His point was:

    x = [1]; x["test"] = 555; x.map(function (y) { return y; });
    // [1]

That's [1], not [1, 555]. You can access the array from the map interface, but not the other way around.

The array prototype functions are only specified by the standard to deal solely with numeric keys, but the lines between and object and array are still pretty blurry. The use case for each is different, but the original question far above was "array/map combo. Have you ever seen anything like that in another language?", and clearly JavaScript is very similar even if not exact.

  var x = {};
  x[0] = 1;
  x.length = 1;
  x.map = Array.prototype.map;
  x.map(function(y) {return y;});
  //[1]

It does internally. Pretty sure that's even defined in the standard.

No, it doesn't. The only magic per spec is about the "length" property (which is essentially a getter/setter pair, despite being a data property and not an accessor pair). That's the only thing special about arrays in JS.

If you can't observe a difference, does it matter?

Arrays are full objects e.g. function(){ var x = []; x.foo = "bar"; return x.foo;} returns "bar".

That is the whole reason prototype.js library broke the use of for (var x in somearray) because the library set properties on Array.prototype.

Nope.

Array are objects,but all objects aren't Arrays.

    var a={};

    a instanceof Array // false

Furthermore,Javascript objects aren't maps.