https://github.com/scaraveos/keyval.js#readme

It uses

- an object to store the keys, which allows for fast delete and value retrieval operations and
- a linked list to allow for really fast value iteration

Hope it helps :)

String.prototype.trim = function() { return this.replace(/^\s+|\s+$/g, ”); }
String.prototype.startsWith = function(s) { return this.substring(0,s.length – 1) == s; }
String.prototype.endsWith = function(s) { return this.length >= s.length && this.substring(this.length – s.length) == s; }
function AssocArray(){
}
AssocArray.prototype.size = function() {
var result = 0;
for(i in this){
if(this[i].startsWith)
result++;
}
return result;
}
AssocArray.prototype.keys = function(){
var result = new Array();
for(i in this){
if(this[i].startsWith)
result[result.length] = i;
}
return result;
}
AssocArray.prototype.values = function(){
var result = new Array();
for(i in this){
if(this[i].startsWith)
result[result.length] = this[i];
}
return result;
}

And some test to the above:

var taa = new AssocArray();
taa.testa = ‘value1a’; // or taa['testa'] = ‘value1a’;
taa.testb = ‘value2a’; // …
alert(‘taa.size = ‘ + taa.size());
var s = ”;
var k = taa.keys();
for(i in k){
s += ‘;’ + k[i];
}
alert(‘Keys are ‘ + s);
s = ”;
var v = taa.values();
for(i in taa.values()){
s += ‘;’ + v[i];
}
alert(‘Values are ‘ + s);
for(i in taa){
if(taa[i].startsWith)
alert(i + ‘=’ + taa[i]);
}

Note the test for startsWith function in the for..in loops (otherwise the functions themselves are also counted, so I test to the current value to be a String, so it has my added startsWith function)
The trim() and endsWith() functions are not used here, but might also be useful.

Hope this can be useful :)


Array.prototype.size = function() {
  var i = 0;
  for (var j in this) {
    if (this.propertyIsEnumerable(j)) {
      i++;
    }
  }
  return i;
}


That’s fine for getting the number of elements, but you’re still buggered on the loops. Each and every for…in loop has to have the same this.propertyIsEnumerable(var) test unless you want breakage. Being the lazy person that I am, I’d rather save myself the trouble of writing all those extra, needless lines of code. But that’s just me.

See my article linked above for more details.

I think using an object is a worse approach because it consumes more memory on the client machine.

No one can be wrond when it comes to opinions, especially concerning Javascript. Let’s keep the unprovable blanket statements to a minimum.

My blanket statement was meant to be in jest, I realize there are contexts where changing the global objects is dangerous. In general, on small, experienced teams, extending builtins can be a very good thing – if you are on a corporate team who is just learning javascript, then I think it might not be such a good idea.

var c = new Object();
c.a = 0;
c.b = 1;
c.c = 2;

So how can one be better than the other?

why make such a big issue out of this… arrays are objects as well… they deserve to be abused just like regular objects… whether or not it’s smart to do so… no, but I guess people are doing far more stupid things than this.

Some might argue extending any of the built-in objects’ prototypes is bad form, but those people are wrong.

No one can be wrond when it comes to opinions, especially concerning Javascript. Let’s keep the unprovable blanket statements to a minimum. Everyone is entitled to their opinion, and the fact that its so easy for people who don’t know what they’re doing (and even people that do) to break functions that other people rely on is a legitimate concern.
Just because you decide to override the Object class to output your Mom’s name when toString() is called, doen’t mean everyone likes your Mom.

Tim: true, its like a limited version of a HashTable I suppose.