JavaScript hashmap equivalent

Question

As made clear in update 3 on this answer, this notation:

var hash = {};
hash[X]

does not actually hash the object X; it actually just converts X to a string (via .toString() if it's an object, or some other built-in conversions for various primitive types) and then looks that string up, without hashing it, in "hash". Object equality is also not checked - if two different objects have the same string conversion, they will just overwrite each other.

Given this - are there any efficient implementations of hashmaps in JavasScript?

(For example, the second Google result of javascript hashmap yields an implementation which is O(n) for any operation. Various other results ignore the fact that different objects with equivalent string representations overwrite each other.

User · Answer

Adding yet another solution  HashMap is pretty much the first class I ported from Java to JavaScript  You could say there is a lot of overhead  but the implementation is almost 100  equal to Java s implementation and includes all interfaces and subclasses  The project can be found here  https   github com Airblader jsava I ll also attach the  current  source code for the HashMap class  but as stated it also depends on the super class  etc  The OOP framework used is qooxdoo  Please note that this code is already out-dated and refer to the GitHub project for the current work  As of writing this  there is also an ArrayList implementation  qx Class define   jsava util HashMap         extend  jsava util AbstractMap      implement   jsava util Map  jsava io Serializable  jsava lang Cloneable        construct  function              var args   Array prototype slice call  arguments                initialCapacity   this self  arguments   DEFAULT INITIAL CAPACITY              loadFactor   this self  arguments   DEFAULT LOAD FACTOR           switch  args length                 case 1                  if  qx Class implementsInterface  args 0   jsava util Map                           initialCapacity   Math max    args 0  size     this self  arguments   DEFAULT LOAD FACTOR    0    1                          this self  arguments   DEFAULT INITIAL CAPACITY                        loadFactor   this self  arguments   DEFAULT LOAD FACTOR                    else                       initialCapacity   args 0                                     break              case 2                  initialCapacity   args 0                   loadFactor   args 1                   break                     if  initialCapacity  lt  0                 throw new jsava lang IllegalArgumentException   Illegal initial capacity      initialCapacity                      if  initialCapacity  gt  this self  arguments   MAXIMUM CAPACITY                 initialCapacity   this self  arguments   MAXIMUM CAPACITY                    if  loadFactor  lt   0    isNaN  loadFactor                   throw new jsava lang IllegalArgumentException   Illegal load factor      loadFactor                       var capacity   1          while  capacity  lt  initialCapacity                 capacity  lt  lt   1                     this  loadFactor   loadFactor          this  threshold    capacity   loadFactor    0          this  table   jsava JsavaUtils emptyArrayOfGivenSize  capacity  null            this  init                statics            serialVersionUID  1           DEFAULT INITIAL CAPACITY  16          MAXIMUM CAPACITY  1  lt  lt  30          DEFAULT LOAD FACTOR  0 75            hash  function  hash                hash     hash  gt  gt  gt  20     hash  gt  gt  gt  12               return hash    hash  gt  gt  gt  7     hash  gt  gt  gt  4                        indexFor  function  hashCode  length                return hashCode  amp   length - 1                       Entry  qx Class define   jsava util HashMap Entry                 extend  jsava lang Object              implement   jsava util Map Entry                construct  function  hash  key  value  nextEntry                    this  value   value                  this  next   nextEntry                  this  key   key                  this  hash   hash                              members                     key  null                   value  null                       type jsava util HashMap Entry                     next  null                       type Number                     hash  0                   getKey  function                          return this  key                                      getValue  function                          return this  value                                      setValue  function  newValue                        var oldValue   this  value                      this  value   newValue                      return oldValue                                      equals  function  obj                        if  obj     null     qx Class implementsInterface  obj  jsava util HashMap Entry                               return false                                                  type jsava util HashMap Entry                        var entry   obj                          key1   this getKey                            key2   entry getKey                        if  key1     key2     key1     null  amp  amp  key1 equals  key2                                var value1   this getValue                                value2   entry getValue                            if  value1     value2     value1     null  amp  amp  value1 equals  value2                                    return true                                                                       return false                                      hashCode  function                          return  this  key     null   0   this  key hashCode                               this  value     null   0   this  value hashCode                                         toString  function                          return this getKey           this getValue                                                               This method is invoked whenever the value in an entry is                    overwritten by an invocation of put k v  for a key k that s already                    in the HashMap                                       recordAccess  function  map                                                               This method is invoked whenever the entry is                    removed from the table                                       recordRemoval  function  map                                                            members                 type jsava util HashMap Entry               table  null               type Number             size  0               type Number             threshold  0               type Number             loadFactor  0               type Number             modCount  0               implements jsava util Set              entrySet  null                          Initialization hook for subclasses  This method is called            in all constructors and pseudo-constructors  clone  readObject             after HashMap has been initialized but before any entries have            been inserted    In the absence of this method  readObject would            require explicit knowledge of subclasses                        init  function                          size  function                  return this  size                      isEmpty  function                  return this  size     0                      get  function  key                if  key     null                     return this   getForNullKey                               var hash   this self  arguments    hash  key hashCode                  for  var entry   this  table this self  arguments    indexFor  hash  this  table length                      entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash  amp  amp    k   entry  key      key    key equals  k                            return entry  value                                               return null                        getForNullKey  function                  for  var entry   this  table 0   entry     null  entry   entry  next                     if  entry  key     null                         return entry  value                                               return null                      containsKey  function  key                return this  getEntry  key       null                       getEntry  function  key                var hash    key     null    0   this self  arguments    hash  key hashCode                  for  var entry   this  table this self  arguments    indexFor  hash  this  table length                      entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash                      amp  amp      k   entry  key       key      key     null  amp  amp  key equals  k                               return entry                                               return null                      put  function  key  value                if  key     null                     return this   putForNullKey  value                               var hash   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                for  var entry   this  table i   entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash  amp  amp     k   entry  key      key    key equals  k                             var oldValue   entry  value                      entry  value   value                      entry  recordAccess  this                        return oldValue                                               this  modCount                this  addEntry  hash  key  value  i                return null                        putForNullKey  function  value                for  var entry   this  table 0   entry     null  entry   entry  next                     if  entry  key     null                         var oldValue   entry  value                      entry  value   value                      entry  recordAccess  this                        return oldValue                                               this  modCount                this  addEntry  0  null  value  0                return null                        putForCreate  function  key  value                var hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                for  var entry   this  table i   entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash                      amp  amp     k   entry  key      key      key     null  amp  amp  key equals  k                               entry  value   value                      return                                               this  createEntry  hash  key  value  i                          putAllForCreate  function  map                var iterator   map entrySet   iterator                while  iterator hasNext                       var entry   iterator next                    this   putForCreate  entry getKey    entry getValue                                         resize  function  newCapacity                var oldTable   this  table                  oldCapacity   oldTable length              if  oldCapacity     this self  arguments   MAXIMUM CAPACITY                     this  threshold   Number MAX VALUE                  return                             var newTable   jsava JsavaUtils emptyArrayOfGivenSize  newCapacity  null                this  transfer  newTable                this  table   newTable              this  threshold    newCapacity   this  loadFactor    0                       transfer  function  newTable                var src   this  table                  newCapacity   newTable length              for  var j   0  j  lt  src length  j                       var entry   src j                   if  entry     null                         src j    null                      do                           var next   entry  next                              i   this self  arguments    indexFor  entry  hash  newCapacity                            entry  next   newTable i                           newTable i    entry                          entry   next                        while  entry     null                                                        putAll  function  map                var numKeyToBeAdded   map size                if  numKeyToBeAdded     0                     return                             if  numKeyToBeAdded  gt  this  threshold                     var targetCapacity    numKeyToBeAdded   this  loadFactor   1    0                  if  targetCapacity  gt  this self  arguments   MAXIMUM CAPACITY                         targetCapacity   this self  arguments   MAXIMUM CAPACITY                                     var newCapacity   this  table length                  while  newCapacity  lt  targetCapacity                         newCapacity  lt  lt   1                                    if  newCapacity  gt  this  table length                         this  resize  newCapacity                                                 var iterator   map entrySet   iterator                while  iterator hasNext                       var entry   iterator next                    this put  entry getKey    entry getValue                                        remove  function  key                var entry   this  removeEntryForKey  key                return entry     null   null   entry  value                       removeEntryForKey  function  key                var hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                    prev   this  table i                   entry   prev               while  entry     null                     var next   entry  next                           type jsava lang Object                            k                  if  entry  hash     hash                      amp  amp     k   entry  key      key      key     null  amp  amp  key equals  k                               this  modCount                        this  size--                      if  prev     entry                             this  table i    next                        else                           prev  next   next                                            entry  recordRemoval  this                        return entry                                    prev   entry                  entry   next                             return entry                       removeMapping  function  obj                if  obj     null     qx Class implementsInterface  obj  jsava util Map Entry                       return null                                  implements jsava util Map Entry                var entry   obj                  key   entry getKey                    hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                    prev   this  table i                   e   prev               while  e     null                     var next   e  next                  if  e  hash     hash  amp  amp  e equals  entry                           this  modCount                        this  size--                      if  prev     e                             this  table i    next                        else                           prev  next   next                                            e  recordRemoval  this                        return e                                    prev   e                  e   next                             return e                      clear  function                  this  modCount                var table   this  table              for  var i   0  i  lt  table length  i                       table i    null                            this  size   0                      containsValue  function  value                if  value     null                     return this   containsNullValue                               var table   this  table              for  var i   0  i  lt  table length  i                       for  var entry   table i   entry     null  entry   entry  next                         if  value equals  entry  value                               return true                                                                     return false                        containsNullValue  function                  var table   this  table              for  var i   0  i  lt  table length  i                       for  var entry   table i   entry     null  entry   entry  next                         if  entry  value     null                             return true                                                                     return false                      clone  function                       type jsava util HashMap                var result   null              try                   result   this base  arguments                  catch  e                     if   qx Class isSubClassOf  e constructor  jsava lang CloneNotSupportedException                           throw e                                               result  table   jsava JsavaUtils emptyArrayOfGivenSize  this  table length  null                result   entrySet   null              result  modCount   0              result  size   0              result  init                result   putAllForCreate  this                 return result                       addEntry  function  hash  key  value  bucketIndex                var entry   this  table bucketIndex               this  table bucketIndex    new  this self  arguments   Entry   hash  key  value  entry                if  this  size    gt   this  threshold                     this  resize  2   this  table length                                       createEntry  function  hash  key  value  bucketIndex                var entry   this  table bucketIndex               this  table bucketIndex    new  this self  arguments   Entry   hash  key  value  entry                this  size                        keySet  function                  var keySet   this  keySet              return keySet     null   keySet     this  keySet   new this KeySet  this                          values  function                  var values   this  values              return values     null   values     this  values   new this Values  this                          entrySet  function                  return this   entrySet0                          entrySet0  function                  var entrySet   this   entrySet              return entrySet     null   entrySet     this   entrySet   new this EntrySet  this                               private            HashIterator  qx Class define   jsava util HashMap HashIterator                 extend  jsava lang Object              implement   jsava util Iterator                type   abstract                     protected                construct  function  thisHashMap                    this   thisHashMap   thisHashMap                  this  expectedModCount   this   thisHashMap  modCount                  if  this   thisHashMap  size  gt  0                         var table   this   thisHashMap  table                      while  this  index  lt  table length  amp  amp    this  next   table this  index          null                                do nothing                                                                     members                      thisHashMap  null                        type jsava util HashMap Entry                     next  null                       type Number                     expectedModCount  0                       type Number                     index  0                       type jsava util HashMap Entry                     current  null                   hasNext  function                          return this  next     null                                       nextEntry  function                          if  this   thisHashMap  modCount     this  expectedModCount                             throw new jsava lang ConcurrentModificationException                                               var entry   this  next                      if  entry     null                             throw new jsava lang NoSuchElementException                                               if   this  next   entry  next      null                             var table   this   thisHashMap  table                          while  this  index  lt  table length  amp  amp    this  next   table this  index          null                                    do nothing                                                                      this  current   entry                      return entry                                      remove  function                          if  this  current     null                             throw new jsava lang IllegalStateException                                               if  this   thisHashMap  modCount     this  expectedModCount                             throw new jsava lang ConcurrentModificationException                                               var key   this  current  key                      this  current   null                      this   thisHashMap  removeEntryForKey  key                        this  expectedModCount   this   thisHashMap  modCount                                                         newKeyIterator  function                  return new this KeyIterator  this                         newValueIterator  function                  return new this ValueIterator  this                         newEntryIterator  function                  return new this EntryIterator  this                             private            ValueIterator  qx Class define   jsava util HashMap ValueIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry    value                                                             private            KeyIterator  qx Class define   jsava util HashMap KeyIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry   getKey                                                               private            EntryIterator  qx Class define   jsava util HashMap EntryIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry                                                               private            KeySet  qx Class define   jsava util HashMap KeySet                 extend  jsava util AbstractSet               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newKeyIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        return this   thisHashMap containsKey  obj                                        remove  function  obj                        return this   thisHashMap  removeEntryForKey  obj       null                                      clear  function                          this   thisHashMap clear                                                               private            Values  qx Class define   jsava util HashMap Values                 extend  jsava util AbstractCollection               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newValueIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        return this   thisHashMap containsValue  obj                                        clear  function                          this   thisHashMap clear                                                               private            EntrySet  qx Class define   jsava util HashMap EntrySet                 extend  jsava util AbstractSet               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newEntryIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        if  obj     null     qx Class implementsInterface  obj  jsava util Map Entry                               return false                                                  implements jsava util Map Entry                        var entry   obj                          candidate   this   thisHashMap  getEntry  entry getKey                          return candidate     null  amp  amp  candidate equals  entry                                        remove  function  obj                        return this   thisHashMap  removeMapping  obj       null                                      clear  function                          this   thisHashMap clear

User · Answer

Hash your objects yourself manually  and use the resulting strings as keys for a regular JavaScript dictionary  After all  you are in the best position to know what makes your objects unique  That s what I do  Example  var key   function obj        Some unique object-dependent key   return obj totallyUniqueEmployeeIdKey     Just an example     var dict        dict key obj1     obj1  dict key obj2     obj2   This way you can control indexing done by JavaScript without heavy lifting of memory allocation  and overflow handling  Of course  if you truly want the  quot industrial-grade solution quot   you can build a class parameterized by the key function  and with all the necessary API of the container  but     we use JavaScript  and trying to be simple and lightweight  so this functional solution is simple and fast  The key function can be as simple as selecting right attributes of the object  e g   a key  or a set of keys  which are already unique  a combination of keys  which are unique together  or as complex as using some cryptographic hashes like in DojoX encoding  or DojoX UUID  While the latter solutions may produce unique keys  personally I try to avoid them at all costs  especially  if I know what makes my objects unique  Update in 2014  Answered back in 2008 this simple solution still requires more explanations  Let me clarify the idea in a Q amp A form  Your solution doesn t have a real hash  Where is it    JavaScript is a high-level language  Its basic primitive  Object  includes a hash table to keep properties  This hash table is usually written in a low-level language for efficiency  Using a simple object with string keys we use an efficiently implemented hash table without any efforts on our part  How do you know they use a hash  There are three major ways to keep a collection of objects addressable by a key   Unordered  In this case to retrieve an object by its key we have to go over all keys stopping when we find it  On average it will take n 2 comparisons  Ordered   Example  1  a sorted array     doing a binary search we will find our key after  log2 n  comparisons on average  Much better  Example  2  a tree  Again it ll be  log n  attempts    Hash table  On average  it requires a constant time  Compare  O n  vs  O log n  vs  O 1   Boom   Obviously JavaScript objects use hash tables in some form to handle general cases  Do browser vendors really use hash tables    Really   Chrome node js V8  JSObject  Look for NameDictionary and NameDictionaryShape with pertinent details in objects cc and objects-inl h  Firefox Gecko  JSObject  NativeObject  and PlainObject with pertinent details in jsobj cpp and vm NativeObject cpp   Do they handle collisions  Yes  See above  If you found a collision on unequal strings  please do not hesitate to file a bug with a vendor  So what is your idea  If you want to hash an object  find what makes it unique and use it as a key  Do not try to calculate a real hash or emulate hash tables     it is already efficiently handled by the underlying JavaScript object  Use this key with JavaScript s Object to leverage its built-in hash table while steering clear of possible clashes with default properties  Examples to get you started   If your objects include a unique user name     use it as a key  If it includes a unique customer number     use it as a key   If it includes unique government-issued numbers like US SSNs  or a passport number  and your system doesn t allow duplicates     use it as a key    If a combination of fields is unique     use it as a key   US state abbreviation   driver license number makes an excellent key  Country abbreviation   passport number is an excellent key too    Some function on fields  or a whole object  can return a unique value     use it as a key   I used your suggestion and cached all objects using a user name  But some wise guy is named  quot toString quot   which is a built-in property  What should I do now  Obviously  if it is even remotely possible that the resulting key will exclusively consists of Latin characters  you should do something about it  For example  add any non-Latin Unicode character you like at the beginning or at the end to un-clash with default properties   quot  toString quot    quot  MarySmith quot   If a composite key is used  separate key components using some kind of non-Latin delimiter   quot name city state quot   In general  this is the place where we have to be creative and select the easiest keys with given limitations  uniqueness  potential clashes with default properties   Note  unique keys do not clash by definition  while potential hash clashes will be handled by the underlying Object  Why don t you like industrial solutions  IMHO  the best code is no code at all  it has no errors  requires no maintenance  easy to understand  and executes instantaneously  All  quot hash tables in JavaScript quot  I saw were  gt 100 lines of code  and involved multiple objects  Compare it with  dict key    value  Another point  is it even possible to beat a performance of a primordial object written in a low-level language  using JavaScript and the very same primordial objects to implement what is already implemented  I still want to hash my objects without any keys  We are in luck  ECMAScript 6  released in June 2015  defines map and set  Judging by the definition  they can use an object s address as a key  which makes objects instantly distinct without artificial keys  OTOH  two different  yet identical objects  will be mapped as distinct  Comparison breakdown from MDN   Objects are similar to Maps in that both let you set keys to values  retrieve those values  delete keys  and detect whether something is stored at a key  Because of this  and because there were no built-in alternatives   Objects have been used as Maps historically  however  there are important differences that make using a Map preferable in certain cases   The keys of an Object are Strings and Symbols  whereas they can be any value for a Map  including functions  objects  and any primitive  The keys in Map are ordered while keys added to object are not  Thus  when iterating over it  a Map object returns keys in order of insertion  You can get the size of a Map easily with the size property  while the number of properties in an Object must be determined manually  A Map is an iterable and can thus be directly iterated  whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them  An Object has a prototype  so there are default keys in the map that could collide with your keys if you re not careful  As of ES5 this can be bypassed by using map   Object create null   but this is seldom done  A Map may perform better in scenarios involving frequent addition and removal of key pairs

User · Answer

This looks like a pretty robust solution: https://github.com/flesler/hashmap

It will even work well for functions and objects that look identical. The only hack it uses is adding an obscure member to an object to identify it. If your program doesn't overwrite that obscure variable (it's something like hashid), you're golden.

User · Answer

Problem description

JavaScript has no built-in general map type (sometimes called associative array or dictionary) which allows to access arbitrary values by arbitrary keys. JavaScript's fundamental data structure is the object, a special type of map which only accepts strings as keys and has special semantics like prototypical inheritance, getters and setters and some further voodoo.

When using objects as maps, you have to remember that the key will be converted to a string value via toString(), which results in mapping 5 and '5' to the same value and all objects which don't overwrite the toString() method to the value indexed by '[object Object]'. You might also involuntarily access its inherited properties if you don't check hasOwnProperty().

JavaScript's built-in array type does not help one bit: JavaScript arrays are not associative arrays, but just objects with a few more special properties. If you want to know why they can't be used as maps, look here.

Eugene's Solution

Eugene Lazutkin already described the basic idea of using a custom hash function to generate unique strings which can be used to look up the associated values as properties of a dictionary object. This will most likely be the fastest solution, because objects are internally implemented as hash tables.

Note: Hash tables (sometimes called hash maps) are a particular implementation of the map concept using a backing array and lookup via numeric hash values. The runtime environment might use other structures (such as search trees or skip lists) to implement JavaScript objects, but as objects are the fundamental data structure, they should be sufficiently optimised.

In order to get a unique hash value for arbitrary objects, one possibility is to use a global counter and cache the hash value in the object itself (for example, in a property named __hash).

A hash function which does this is and works for both primitive values and objects is:

function hash(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
}

hash.current = 0;

This function can be used as described by Eugene. For convenience, we will further wrap it in a Map class.

My `Map` implementation

The following implementation will additionally store the key-value-pairs in a doubly linked list in order to allow fast iteration over both keys and values. To supply your own hash function, you can overwrite the instance's hash() method after creation.

// Linking the key-value-pairs is optional.
// If no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
    this.current = undefined;
    this.size = 0;

    if(linkItems === false)
        this.disableLinking();
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// Map initialisation from an existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
    var map = new Map;

    for(var prop in obj) {
        if(foreignKeys || obj.hasOwnProperty(prop))
            map.put(prop, obj[prop]);
    }

    return map;
};

Map.prototype.disableLinking = function() {
    this.link = Map.noop;
    this.unlink = Map.noop;
    this.disableLinking = Map.noop;
    this.next = Map.illegal;
    this.key = Map.illegal;
    this.value = Map.illegal;
    this.removeAll = Map.illegal;

    return this;
};

// Overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
};

Map.prototype.hash.current = 0;

// --- Mapping functions

Map.prototype.get = function(key) {
    var item = this[this.hash(key)];
    return item === undefined ? undefined : item.value;
};

Map.prototype.put = function(key, value) {
    var hash = this.hash(key);

    if(this[hash] === undefined) {
        var item = { key : key, value : value };
        this[hash] = item;

        this.link(item);
        ++this.size;
    }
    else this[hash].value = value;

    return this;
};

Map.prototype.remove = function(key) {
    var hash = this.hash(key);
    var item = this[hash];

    if(item !== undefined) {
        --this.size;
        this.unlink(item);

        delete this[hash];
    }

    return this;
};

// Only works if linked
Map.prototype.removeAll = function() {
    while(this.size)
        this.remove(this.key());

    return this;
};

// --- Linked list helper functions

Map.prototype.link = function(item) {
    if(this.size == 0) {
        item.prev = item;
        item.next = item;
        this.current = item;
    }
    else {
        item.prev = this.current.prev;
        item.prev.next = item;
        item.next = this.current;
        this.current.prev = item;
    }
};

Map.prototype.unlink = function(item) {
    if(this.size == 0)
        this.current = undefined;
    else {
        item.prev.next = item.next;
        item.next.prev = item.prev;
        if(item === this.current)
            this.current = item.next;
    }
};

// --- Iterator functions - only work if map is linked

Map.prototype.next = function() {
    this.current = this.current.next;
};

Map.prototype.key = function() {
    return this.current.key;
};

Map.prototype.value = function() {
    return this.current.value;
};

Example

The following script,

var map = new Map;

map.put('spam', 'eggs').
    put('foo', 'bar').
    put('foo', 'baz').
    put({}, 'an object').
    put({}, 'another object').
    put(5, 'five').
    put(5, 'five again').
    put('5', 'another five');

for(var i = 0; i++ < map.size; map.next())
    document.writeln(map.hash(map.key()) + ' : ' + map.value());

generates this output:

string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five

Further considerations

PEZ suggested to overwrite the toString() method, presumably with our hash function. This is not feasible, because it doesn't work for primitive values (changing toString() for primitives is a very bad idea). If we want toString() to return meaningful values for arbitrary objects, we would have to modify Object.prototype, which some people (myself not included) consider verboten.

The current version of my Map implementation as well as other JavaScript goodies can be obtained from here.

User · Answer

According to ECMAScript 2015  ES6   standard JavaScript has a Map implementation  More about which could be found here  Basic usage  var myMap   new Map    var keyString    quot a string quot       keyObj           keyFunc   function            Setting the values myMap set keyString   quot value associated with  a string  quot    myMap set keyObj   quot value associated with keyObj quot    myMap set keyFunc   quot value associated with keyFunc quot     myMap size     3     Getting the values myMap get keyString          quot value associated with  a string  quot  myMap get keyObj             quot value associated with keyObj quot  myMap get keyFunc            quot value associated with keyFunc quot

User · Answer

You can use ECMAScript  6 WeakMap or Map   WeakMaps are key value maps in which keys are objects      Map objects are simple key value maps  Any value  both objects and primitive values  may be used as either a key or a value   Be aware that neither is widely supported  but you can use ECMAScript  6 Shim  requires native ECMAScript  5 or ECMAScript  5 Shim  to support Map  but not WeakMap  see why

User · Answer

Unfortunately  none of the previous answers were good for my case  different key objects may have the same hash code  Therefore  I wrote a simple Java-like HashMap version  function HashMap         this buckets          HashMap prototype put   function key  value        var hashCode   key hashCode        var bucket   this buckets hashCode       if   bucket            bucket   new Array            this buckets hashCode    bucket            for  var i   0  i  lt  bucket length    i            if  bucket i  key equals key                 bucket i  value   value              return                      bucket push   key  key  value  value        HashMap prototype get   function key        var hashCode   key hashCode        var bucket   this buckets hashCode       if   bucket            return null            for  var i   0  i  lt  bucket length    i            if  bucket i  key equals key                 return bucket i  value                     HashMap prototype keys   function         var keys   new Array        for  var hashKey in this buckets            var bucket   this buckets hashKey           for  var i   0  i  lt  bucket length    i                keys push bucket i  key                       return keys     HashMap prototype values   function         var values   new Array        for  var hashKey in this buckets            var bucket   this buckets hashKey           for  var i   0  i  lt  bucket length    i                values push bucket i  value                       return values     Note  key objects must  quot implement quot  the hashCode   and equals   methods

User · Answer

You d have to store couplets of object value pairs in some internal state  HashMap   function      this  dict          HashMap prototype  get   function key     for var i 0  couplet  couplet   this  dict i   i         if couplet 0      key         return couplet               HashMap prototype put   function key  value     var couplet   this  get key     if couplet       couplet 1    value     else      this  dict push  key  value          return this     for chaining   HashMap prototype get   function key     var couplet   this  get key     if couplet       return couplet 1          And use it as such  var color          Unique object instance var shape          Unique object instance var map   new HashMap    map put color   quot blue quot    map put shape   quot round quot    console log  quot Item is quot   map get color    quot and quot   map get shape     Of course  this implementation is also somewhere along the lines of O n   Eugene s examples are the only way to get a hash that works with any sort of speed you d expect from a real hash  Another approach  along the lines of Eugene s answer is to somehow attach a unique ID to all objects  One of my favorite approaches is to take one of the built-in methods inherited from the Object superclass  replace it with a custom function passthrough and attach properties to that function object  If you were to rewrite my HashMap method to do this  it would look like  HashMap   function      this  dict          HashMap prototype  shared    id  1   HashMap prototype put   function put key  value     if typeof key     quot object quot        if  key hasOwnProperty  id         key hasOwnProperty   function key           return Object prototype hasOwnProperty call this  key                 key hasOwnProperty  id   this  shared id              this  dict key hasOwnProperty  id    value     else      this  dict key    value        return this     for chaining    HashMap prototype get   function get key     if typeof key     quot object quot        return this  dict key hasOwnProperty  id         return this  dict key      This version appears to be only slightly faster  but in theory it will be significantly faster for large data sets

User · Answer

This looks like a pretty robust solution: https://github.com/flesler/hashmap

It will even work well for functions and objects that look identical. The only hack it uses is adding an obscure member to an object to identify it. If your program doesn't overwrite that obscure variable (it's something like hashid), you're golden.

User · Answer

In ECMAScript  6 you can use WeakMap  Example  var wm1   new WeakMap        wm2   new WeakMap        wm3   new WeakMap    var o1           o2   function          o3   window   wm1 set o1  37   wm1 set o2   quot azerty quot    wm2 set o1  o2      A value can be anything  including an object or a function wm2 set o3  undefined   wm2 set wm1  wm2      Keys and values can be any objects  Even WeakMaps   wm1 get o2       quot azerty quot  wm2 get o2      Undefined  because there is no value for o2 on wm2 wm2 get o3      Undefined  because that is the set value  wm1 has o2      True wm2 has o2      False wm2 has o3      True  even if the value itself is  undefined    wm3 set o1  37   wm3 get o1      37 wm3 clear    wm3 get o1      Undefined  because wm3 was cleared and there is no value for o1 anymore  wm1 has o1        True wm1 delete o1   wm1 has o1        False  But  Because of references being weak  WeakMap keys are not enumerable  i e  there is no method giving you a list of the keys

User · Answer

JavaScript does not have a built-in map hashmap  It should be called an associative array  hash  quot X quot   is equal to hash X  but it allows  quot X quot  as a string variable  In other words  hash x  is functionally equal to eval  quot hash  quot  x toString     It is more similar to object properties rather than key-value mapping  If you are looking for a better key value mapping in JavaScript  please use the Map object

User · Answer

Problem description

JavaScript has no built-in general map type (sometimes called associative array or dictionary) which allows to access arbitrary values by arbitrary keys. JavaScript's fundamental data structure is the object, a special type of map which only accepts strings as keys and has special semantics like prototypical inheritance, getters and setters and some further voodoo.

When using objects as maps, you have to remember that the key will be converted to a string value via toString(), which results in mapping 5 and '5' to the same value and all objects which don't overwrite the toString() method to the value indexed by '[object Object]'. You might also involuntarily access its inherited properties if you don't check hasOwnProperty().

JavaScript's built-in array type does not help one bit: JavaScript arrays are not associative arrays, but just objects with a few more special properties. If you want to know why they can't be used as maps, look here.

Eugene's Solution

Eugene Lazutkin already described the basic idea of using a custom hash function to generate unique strings which can be used to look up the associated values as properties of a dictionary object. This will most likely be the fastest solution, because objects are internally implemented as hash tables.

Note: Hash tables (sometimes called hash maps) are a particular implementation of the map concept using a backing array and lookup via numeric hash values. The runtime environment might use other structures (such as search trees or skip lists) to implement JavaScript objects, but as objects are the fundamental data structure, they should be sufficiently optimised.

In order to get a unique hash value for arbitrary objects, one possibility is to use a global counter and cache the hash value in the object itself (for example, in a property named __hash).

A hash function which does this is and works for both primitive values and objects is:

function hash(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
}

hash.current = 0;

This function can be used as described by Eugene. For convenience, we will further wrap it in a Map class.

My `Map` implementation

The following implementation will additionally store the key-value-pairs in a doubly linked list in order to allow fast iteration over both keys and values. To supply your own hash function, you can overwrite the instance's hash() method after creation.

// Linking the key-value-pairs is optional.
// If no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
    this.current = undefined;
    this.size = 0;

    if(linkItems === false)
        this.disableLinking();
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// Map initialisation from an existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
    var map = new Map;

    for(var prop in obj) {
        if(foreignKeys || obj.hasOwnProperty(prop))
            map.put(prop, obj[prop]);
    }

    return map;
};

Map.prototype.disableLinking = function() {
    this.link = Map.noop;
    this.unlink = Map.noop;
    this.disableLinking = Map.noop;
    this.next = Map.illegal;
    this.key = Map.illegal;
    this.value = Map.illegal;
    this.removeAll = Map.illegal;

    return this;
};

// Overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
};

Map.prototype.hash.current = 0;

// --- Mapping functions

Map.prototype.get = function(key) {
    var item = this[this.hash(key)];
    return item === undefined ? undefined : item.value;
};

Map.prototype.put = function(key, value) {
    var hash = this.hash(key);

    if(this[hash] === undefined) {
        var item = { key : key, value : value };
        this[hash] = item;

        this.link(item);
        ++this.size;
    }
    else this[hash].value = value;

    return this;
};

Map.prototype.remove = function(key) {
    var hash = this.hash(key);
    var item = this[hash];

    if(item !== undefined) {
        --this.size;
        this.unlink(item);

        delete this[hash];
    }

    return this;
};

// Only works if linked
Map.prototype.removeAll = function() {
    while(this.size)
        this.remove(this.key());

    return this;
};

// --- Linked list helper functions

Map.prototype.link = function(item) {
    if(this.size == 0) {
        item.prev = item;
        item.next = item;
        this.current = item;
    }
    else {
        item.prev = this.current.prev;
        item.prev.next = item;
        item.next = this.current;
        this.current.prev = item;
    }
};

Map.prototype.unlink = function(item) {
    if(this.size == 0)
        this.current = undefined;
    else {
        item.prev.next = item.next;
        item.next.prev = item.prev;
        if(item === this.current)
            this.current = item.next;
    }
};

// --- Iterator functions - only work if map is linked

Map.prototype.next = function() {
    this.current = this.current.next;
};

Map.prototype.key = function() {
    return this.current.key;
};

Map.prototype.value = function() {
    return this.current.value;
};

Example

The following script,

var map = new Map;

map.put('spam', 'eggs').
    put('foo', 'bar').
    put('foo', 'baz').
    put({}, 'an object').
    put({}, 'another object').
    put(5, 'five').
    put(5, 'five again').
    put('5', 'another five');

for(var i = 0; i++ < map.size; map.next())
    document.writeln(map.hash(map.key()) + ' : ' + map.value());

generates this output:

string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five

Further considerations

PEZ suggested to overwrite the toString() method, presumably with our hash function. This is not feasible, because it doesn't work for primitive values (changing toString() for primitives is a very bad idea). If we want toString() to return meaningful values for arbitrary objects, we would have to modify Object.prototype, which some people (myself not included) consider verboten.

The current version of my Map implementation as well as other JavaScript goodies can be obtained from here.

User · Answer

Yet another map implementation by me  With randomizer   generics  and  iterator      var HashMap   function  TKey  TValue        var db           var keyType  valueType        function              keyType   TKey          valueType   TValue                 var getIndexOfKey   function  key            if  typeof key     keyType              throw new Error  Type of key should be     keyType           for  var i   0  i  lt  db length  i                  if  db i  0     key                  return i                    return -1             this add   function  key  value            if  typeof key     keyType                throw new Error  Type of key should be     keyType             else if  typeof value     valueType                throw new Error  Type of value should be     valueType                     var index   getIndexOfKey key           if  index     -1              db push  key  value            else             db index  1    value          return this             this get   function  key            if  typeof key     keyType    db length     0              return null          for  var i   0  i  lt  db length  i                  if  db i  0     key                  return db i  1                     return null             this size   function              return db length             this keys   function              if  db length     0              return             var result               for  var i   0  i  lt  db length  i                  result push db i  0                      return result             this values   function              if  db length     0              return             var result               for  var i   0  i  lt  db length  i                  result push db i  1                      return result             this randomize   function              if  db length     0              return this          var currentIndex   db length  temporaryValue  randomIndex          while  0     currentIndex                randomIndex   Math floor Math random     currentIndex               currentIndex--              temporaryValue   db currentIndex               db currentIndex    db randomIndex               db randomIndex    temporaryValue                    return this             this iterate   function  callback            if  db length     0              return false          for  var i   0  i  lt  db length  i                  callback db i  0   db i  1                      return true            Example   var a   new HashMap  string    number    a add  test   1132    add  test14   666    add  1421test14   12312666    iterate function  key  value   console log  a   key      value        a test  1132 a test14  666 a 1421test14  12312666     a randomize       a 1421test14  12312666 a test  1132 a test14  666

User · Answer

Try my JavaScript hash table implementation: http://www.timdown.co.uk/jshashtable

It looks for a hashCode() method of key objects, or you can supply a hashing function when creating a Hashtable object.

User · Answer

Yet another map implementation by me  With randomizer   generics  and  iterator      var HashMap   function  TKey  TValue        var db           var keyType  valueType        function              keyType   TKey          valueType   TValue                 var getIndexOfKey   function  key            if  typeof key     keyType              throw new Error  Type of key should be     keyType           for  var i   0  i  lt  db length  i                  if  db i  0     key                  return i                    return -1             this add   function  key  value            if  typeof key     keyType                throw new Error  Type of key should be     keyType             else if  typeof value     valueType                throw new Error  Type of value should be     valueType                     var index   getIndexOfKey key           if  index     -1              db push  key  value            else             db index  1    value          return this             this get   function  key            if  typeof key     keyType    db length     0              return null          for  var i   0  i  lt  db length  i                  if  db i  0     key                  return db i  1                     return null             this size   function              return db length             this keys   function              if  db length     0              return             var result               for  var i   0  i  lt  db length  i                  result push db i  0                      return result             this values   function              if  db length     0              return             var result               for  var i   0  i  lt  db length  i                  result push db i  1                      return result             this randomize   function              if  db length     0              return this          var currentIndex   db length  temporaryValue  randomIndex          while  0     currentIndex                randomIndex   Math floor Math random     currentIndex               currentIndex--              temporaryValue   db currentIndex               db currentIndex    db randomIndex               db randomIndex    temporaryValue                    return this             this iterate   function  callback            if  db length     0              return false          for  var i   0  i  lt  db length  i                  callback db i  0   db i  1                      return true            Example   var a   new HashMap  string    number    a add  test   1132    add  test14   666    add  1421test14   12312666    iterate function  key  value   console log  a   key      value        a test  1132 a test14  666 a 1421test14  12312666     a randomize       a 1421test14  12312666 a test  1132 a test14  666

User · Answer

Problem description

JavaScript has no built-in general map type (sometimes called associative array or dictionary) which allows to access arbitrary values by arbitrary keys. JavaScript's fundamental data structure is the object, a special type of map which only accepts strings as keys and has special semantics like prototypical inheritance, getters and setters and some further voodoo.

When using objects as maps, you have to remember that the key will be converted to a string value via toString(), which results in mapping 5 and '5' to the same value and all objects which don't overwrite the toString() method to the value indexed by '[object Object]'. You might also involuntarily access its inherited properties if you don't check hasOwnProperty().

JavaScript's built-in array type does not help one bit: JavaScript arrays are not associative arrays, but just objects with a few more special properties. If you want to know why they can't be used as maps, look here.

Eugene's Solution

Eugene Lazutkin already described the basic idea of using a custom hash function to generate unique strings which can be used to look up the associated values as properties of a dictionary object. This will most likely be the fastest solution, because objects are internally implemented as hash tables.

Note: Hash tables (sometimes called hash maps) are a particular implementation of the map concept using a backing array and lookup via numeric hash values. The runtime environment might use other structures (such as search trees or skip lists) to implement JavaScript objects, but as objects are the fundamental data structure, they should be sufficiently optimised.

In order to get a unique hash value for arbitrary objects, one possibility is to use a global counter and cache the hash value in the object itself (for example, in a property named __hash).

A hash function which does this is and works for both primitive values and objects is:

function hash(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
}

hash.current = 0;

This function can be used as described by Eugene. For convenience, we will further wrap it in a Map class.

My `Map` implementation

The following implementation will additionally store the key-value-pairs in a doubly linked list in order to allow fast iteration over both keys and values. To supply your own hash function, you can overwrite the instance's hash() method after creation.

// Linking the key-value-pairs is optional.
// If no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
    this.current = undefined;
    this.size = 0;

    if(linkItems === false)
        this.disableLinking();
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// Map initialisation from an existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
    var map = new Map;

    for(var prop in obj) {
        if(foreignKeys || obj.hasOwnProperty(prop))
            map.put(prop, obj[prop]);
    }

    return map;
};

Map.prototype.disableLinking = function() {
    this.link = Map.noop;
    this.unlink = Map.noop;
    this.disableLinking = Map.noop;
    this.next = Map.illegal;
    this.key = Map.illegal;
    this.value = Map.illegal;
    this.removeAll = Map.illegal;

    return this;
};

// Overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
};

Map.prototype.hash.current = 0;

// --- Mapping functions

Map.prototype.get = function(key) {
    var item = this[this.hash(key)];
    return item === undefined ? undefined : item.value;
};

Map.prototype.put = function(key, value) {
    var hash = this.hash(key);

    if(this[hash] === undefined) {
        var item = { key : key, value : value };
        this[hash] = item;

        this.link(item);
        ++this.size;
    }
    else this[hash].value = value;

    return this;
};

Map.prototype.remove = function(key) {
    var hash = this.hash(key);
    var item = this[hash];

    if(item !== undefined) {
        --this.size;
        this.unlink(item);

        delete this[hash];
    }

    return this;
};

// Only works if linked
Map.prototype.removeAll = function() {
    while(this.size)
        this.remove(this.key());

    return this;
};

// --- Linked list helper functions

Map.prototype.link = function(item) {
    if(this.size == 0) {
        item.prev = item;
        item.next = item;
        this.current = item;
    }
    else {
        item.prev = this.current.prev;
        item.prev.next = item;
        item.next = this.current;
        this.current.prev = item;
    }
};

Map.prototype.unlink = function(item) {
    if(this.size == 0)
        this.current = undefined;
    else {
        item.prev.next = item.next;
        item.next.prev = item.prev;
        if(item === this.current)
            this.current = item.next;
    }
};

// --- Iterator functions - only work if map is linked

Map.prototype.next = function() {
    this.current = this.current.next;
};

Map.prototype.key = function() {
    return this.current.key;
};

Map.prototype.value = function() {
    return this.current.value;
};

Example

The following script,

var map = new Map;

map.put('spam', 'eggs').
    put('foo', 'bar').
    put('foo', 'baz').
    put({}, 'an object').
    put({}, 'another object').
    put(5, 'five').
    put(5, 'five again').
    put('5', 'another five');

for(var i = 0; i++ < map.size; map.next())
    document.writeln(map.hash(map.key()) + ' : ' + map.value());

generates this output:

string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five

Further considerations

PEZ suggested to overwrite the toString() method, presumably with our hash function. This is not feasible, because it doesn't work for primitive values (changing toString() for primitives is a very bad idea). If we want toString() to return meaningful values for arbitrary objects, we would have to modify Object.prototype, which some people (myself not included) consider verboten.

The current version of my Map implementation as well as other JavaScript goodies can be obtained from here.

User · Answer

Try my JavaScript hash table implementation: http://www.timdown.co.uk/jshashtable

It looks for a hashCode() method of key objects, or you can supply a hashing function when creating a Hashtable object.

User · Answer

Hash your objects yourself manually  and use the resulting strings as keys for a regular JavaScript dictionary  After all  you are in the best position to know what makes your objects unique  That s what I do  Example  var key   function obj        Some unique object-dependent key   return obj totallyUniqueEmployeeIdKey     Just an example     var dict        dict key obj1     obj1  dict key obj2     obj2   This way you can control indexing done by JavaScript without heavy lifting of memory allocation  and overflow handling  Of course  if you truly want the  quot industrial-grade solution quot   you can build a class parameterized by the key function  and with all the necessary API of the container  but     we use JavaScript  and trying to be simple and lightweight  so this functional solution is simple and fast  The key function can be as simple as selecting right attributes of the object  e g   a key  or a set of keys  which are already unique  a combination of keys  which are unique together  or as complex as using some cryptographic hashes like in DojoX encoding  or DojoX UUID  While the latter solutions may produce unique keys  personally I try to avoid them at all costs  especially  if I know what makes my objects unique  Update in 2014  Answered back in 2008 this simple solution still requires more explanations  Let me clarify the idea in a Q amp A form  Your solution doesn t have a real hash  Where is it    JavaScript is a high-level language  Its basic primitive  Object  includes a hash table to keep properties  This hash table is usually written in a low-level language for efficiency  Using a simple object with string keys we use an efficiently implemented hash table without any efforts on our part  How do you know they use a hash  There are three major ways to keep a collection of objects addressable by a key   Unordered  In this case to retrieve an object by its key we have to go over all keys stopping when we find it  On average it will take n 2 comparisons  Ordered   Example  1  a sorted array     doing a binary search we will find our key after  log2 n  comparisons on average  Much better  Example  2  a tree  Again it ll be  log n  attempts    Hash table  On average  it requires a constant time  Compare  O n  vs  O log n  vs  O 1   Boom   Obviously JavaScript objects use hash tables in some form to handle general cases  Do browser vendors really use hash tables    Really   Chrome node js V8  JSObject  Look for NameDictionary and NameDictionaryShape with pertinent details in objects cc and objects-inl h  Firefox Gecko  JSObject  NativeObject  and PlainObject with pertinent details in jsobj cpp and vm NativeObject cpp   Do they handle collisions  Yes  See above  If you found a collision on unequal strings  please do not hesitate to file a bug with a vendor  So what is your idea  If you want to hash an object  find what makes it unique and use it as a key  Do not try to calculate a real hash or emulate hash tables     it is already efficiently handled by the underlying JavaScript object  Use this key with JavaScript s Object to leverage its built-in hash table while steering clear of possible clashes with default properties  Examples to get you started   If your objects include a unique user name     use it as a key  If it includes a unique customer number     use it as a key   If it includes unique government-issued numbers like US SSNs  or a passport number  and your system doesn t allow duplicates     use it as a key    If a combination of fields is unique     use it as a key   US state abbreviation   driver license number makes an excellent key  Country abbreviation   passport number is an excellent key too    Some function on fields  or a whole object  can return a unique value     use it as a key   I used your suggestion and cached all objects using a user name  But some wise guy is named  quot toString quot   which is a built-in property  What should I do now  Obviously  if it is even remotely possible that the resulting key will exclusively consists of Latin characters  you should do something about it  For example  add any non-Latin Unicode character you like at the beginning or at the end to un-clash with default properties   quot  toString quot    quot  MarySmith quot   If a composite key is used  separate key components using some kind of non-Latin delimiter   quot name city state quot   In general  this is the place where we have to be creative and select the easiest keys with given limitations  uniqueness  potential clashes with default properties   Note  unique keys do not clash by definition  while potential hash clashes will be handled by the underlying Object  Why don t you like industrial solutions  IMHO  the best code is no code at all  it has no errors  requires no maintenance  easy to understand  and executes instantaneously  All  quot hash tables in JavaScript quot  I saw were  gt 100 lines of code  and involved multiple objects  Compare it with  dict key    value  Another point  is it even possible to beat a performance of a primordial object written in a low-level language  using JavaScript and the very same primordial objects to implement what is already implemented  I still want to hash my objects without any keys  We are in luck  ECMAScript 6  released in June 2015  defines map and set  Judging by the definition  they can use an object s address as a key  which makes objects instantly distinct without artificial keys  OTOH  two different  yet identical objects  will be mapped as distinct  Comparison breakdown from MDN   Objects are similar to Maps in that both let you set keys to values  retrieve those values  delete keys  and detect whether something is stored at a key  Because of this  and because there were no built-in alternatives   Objects have been used as Maps historically  however  there are important differences that make using a Map preferable in certain cases   The keys of an Object are Strings and Symbols  whereas they can be any value for a Map  including functions  objects  and any primitive  The keys in Map are ordered while keys added to object are not  Thus  when iterating over it  a Map object returns keys in order of insertion  You can get the size of a Map easily with the size property  while the number of properties in an Object must be determined manually  A Map is an iterable and can thus be directly iterated  whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them  An Object has a prototype  so there are default keys in the map that could collide with your keys if you re not careful  As of ES5 this can be bypassed by using map   Object create null   but this is seldom done  A Map may perform better in scenarios involving frequent addition and removal of key pairs

User · Answer

You d have to store couplets of object value pairs in some internal state  HashMap   function      this  dict          HashMap prototype  get   function key     for var i 0  couplet  couplet   this  dict i   i         if couplet 0      key         return couplet               HashMap prototype put   function key  value     var couplet   this  get key     if couplet       couplet 1    value     else      this  dict push  key  value          return this     for chaining   HashMap prototype get   function key     var couplet   this  get key     if couplet       return couplet 1          And use it as such  var color          Unique object instance var shape          Unique object instance var map   new HashMap    map put color   quot blue quot    map put shape   quot round quot    console log  quot Item is quot   map get color    quot and quot   map get shape     Of course  this implementation is also somewhere along the lines of O n   Eugene s examples are the only way to get a hash that works with any sort of speed you d expect from a real hash  Another approach  along the lines of Eugene s answer is to somehow attach a unique ID to all objects  One of my favorite approaches is to take one of the built-in methods inherited from the Object superclass  replace it with a custom function passthrough and attach properties to that function object  If you were to rewrite my HashMap method to do this  it would look like  HashMap   function      this  dict          HashMap prototype  shared    id  1   HashMap prototype put   function put key  value     if typeof key     quot object quot        if  key hasOwnProperty  id         key hasOwnProperty   function key           return Object prototype hasOwnProperty call this  key                 key hasOwnProperty  id   this  shared id              this  dict key hasOwnProperty  id    value     else      this  dict key    value        return this     for chaining    HashMap prototype get   function get key     if typeof key     quot object quot        return this  dict key hasOwnProperty  id         return this  dict key      This version appears to be only slightly faster  but in theory it will be significantly faster for large data sets

User · Answer

Hash your objects yourself manually  and use the resulting strings as keys for a regular JavaScript dictionary  After all  you are in the best position to know what makes your objects unique  That s what I do  Example  var key   function obj        Some unique object-dependent key   return obj totallyUniqueEmployeeIdKey     Just an example     var dict        dict key obj1     obj1  dict key obj2     obj2   This way you can control indexing done by JavaScript without heavy lifting of memory allocation  and overflow handling  Of course  if you truly want the  quot industrial-grade solution quot   you can build a class parameterized by the key function  and with all the necessary API of the container  but     we use JavaScript  and trying to be simple and lightweight  so this functional solution is simple and fast  The key function can be as simple as selecting right attributes of the object  e g   a key  or a set of keys  which are already unique  a combination of keys  which are unique together  or as complex as using some cryptographic hashes like in DojoX encoding  or DojoX UUID  While the latter solutions may produce unique keys  personally I try to avoid them at all costs  especially  if I know what makes my objects unique  Update in 2014  Answered back in 2008 this simple solution still requires more explanations  Let me clarify the idea in a Q amp A form  Your solution doesn t have a real hash  Where is it    JavaScript is a high-level language  Its basic primitive  Object  includes a hash table to keep properties  This hash table is usually written in a low-level language for efficiency  Using a simple object with string keys we use an efficiently implemented hash table without any efforts on our part  How do you know they use a hash  There are three major ways to keep a collection of objects addressable by a key   Unordered  In this case to retrieve an object by its key we have to go over all keys stopping when we find it  On average it will take n 2 comparisons  Ordered   Example  1  a sorted array     doing a binary search we will find our key after  log2 n  comparisons on average  Much better  Example  2  a tree  Again it ll be  log n  attempts    Hash table  On average  it requires a constant time  Compare  O n  vs  O log n  vs  O 1   Boom   Obviously JavaScript objects use hash tables in some form to handle general cases  Do browser vendors really use hash tables    Really   Chrome node js V8  JSObject  Look for NameDictionary and NameDictionaryShape with pertinent details in objects cc and objects-inl h  Firefox Gecko  JSObject  NativeObject  and PlainObject with pertinent details in jsobj cpp and vm NativeObject cpp   Do they handle collisions  Yes  See above  If you found a collision on unequal strings  please do not hesitate to file a bug with a vendor  So what is your idea  If you want to hash an object  find what makes it unique and use it as a key  Do not try to calculate a real hash or emulate hash tables     it is already efficiently handled by the underlying JavaScript object  Use this key with JavaScript s Object to leverage its built-in hash table while steering clear of possible clashes with default properties  Examples to get you started   If your objects include a unique user name     use it as a key  If it includes a unique customer number     use it as a key   If it includes unique government-issued numbers like US SSNs  or a passport number  and your system doesn t allow duplicates     use it as a key    If a combination of fields is unique     use it as a key   US state abbreviation   driver license number makes an excellent key  Country abbreviation   passport number is an excellent key too    Some function on fields  or a whole object  can return a unique value     use it as a key   I used your suggestion and cached all objects using a user name  But some wise guy is named  quot toString quot   which is a built-in property  What should I do now  Obviously  if it is even remotely possible that the resulting key will exclusively consists of Latin characters  you should do something about it  For example  add any non-Latin Unicode character you like at the beginning or at the end to un-clash with default properties   quot  toString quot    quot  MarySmith quot   If a composite key is used  separate key components using some kind of non-Latin delimiter   quot name city state quot   In general  this is the place where we have to be creative and select the easiest keys with given limitations  uniqueness  potential clashes with default properties   Note  unique keys do not clash by definition  while potential hash clashes will be handled by the underlying Object  Why don t you like industrial solutions  IMHO  the best code is no code at all  it has no errors  requires no maintenance  easy to understand  and executes instantaneously  All  quot hash tables in JavaScript quot  I saw were  gt 100 lines of code  and involved multiple objects  Compare it with  dict key    value  Another point  is it even possible to beat a performance of a primordial object written in a low-level language  using JavaScript and the very same primordial objects to implement what is already implemented  I still want to hash my objects without any keys  We are in luck  ECMAScript 6  released in June 2015  defines map and set  Judging by the definition  they can use an object s address as a key  which makes objects instantly distinct without artificial keys  OTOH  two different  yet identical objects  will be mapped as distinct  Comparison breakdown from MDN   Objects are similar to Maps in that both let you set keys to values  retrieve those values  delete keys  and detect whether something is stored at a key  Because of this  and because there were no built-in alternatives   Objects have been used as Maps historically  however  there are important differences that make using a Map preferable in certain cases   The keys of an Object are Strings and Symbols  whereas they can be any value for a Map  including functions  objects  and any primitive  The keys in Map are ordered while keys added to object are not  Thus  when iterating over it  a Map object returns keys in order of insertion  You can get the size of a Map easily with the size property  while the number of properties in an Object must be determined manually  A Map is an iterable and can thus be directly iterated  whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them  An Object has a prototype  so there are default keys in the map that could collide with your keys if you re not careful  As of ES5 this can be bypassed by using map   Object create null   but this is seldom done  A Map may perform better in scenarios involving frequent addition and removal of key pairs

User · Answer

I ve implemented a JavaScript HashMap which code can be obtained from http   github com lambder HashMapJS tree master Here is the code                                                                              license MIT   author Lambder   copyright 2009 Lambder    end                                                                            var HashMap   function       this initialize       HashMap prototype       hashkey prefix   quot  lt  HashMapHashkeyPerfix gt  quot     hashcode field   quot  lt  HashMapHashkeyPerfix gt  quot      initialize  function         this backing hash           this code   0               Maps value to key returning previous association         put  function key  value        var prev      if  key  amp  amp  value          var hashCode   key this hashcode field         if  hashCode            prev   this backing hash hashCode           else           this code    1          hashCode   this hashkey prefix   this code          key this hashcode field    hashCode                this backing hash hashCode    value            return prev               Returns value associated with given key         get  function key        var value      if  key          var hashCode   key this hashcode field         if  hashCode            value   this backing hash hashCode                     return value               Deletes association by given key     Returns true if the association existed  false otherwise         del  function key        var success   false      if  key          var hashCode   key this hashcode field         if  hashCode            var prev   this backing hash hashCode           this backing hash hashCode    undefined          if prev     undefined            success   true                    return success              Usage     Creation  var my map   new HashMap        Insertion  var a key       var a value    struct   quot structA quot    var b key       var b value    struct   quot structB quot    var c key       var c value    struct   quot structC quot     my map put a key  a value   my map put b key  b value   var prev b   my map put b key  c value       Retrieval  if my map get a key      a value     throw  quot fail1 quot     if my map get b key      c value     throw  quot fail2 quot     if prev b     b value     throw  quot fail3 quot         Deletion  var a existed   my map del a key   var c existed   my map del c key   var a2 existed   my map del a key    if a existed     true     throw  quot fail4 quot     if c existed     false     throw  quot fail5 quot     if a2 existed     false     throw  quot fail6 quot

User · Answer

Adding yet another solution  HashMap is pretty much the first class I ported from Java to JavaScript  You could say there is a lot of overhead  but the implementation is almost 100  equal to Java s implementation and includes all interfaces and subclasses  The project can be found here  https   github com Airblader jsava I ll also attach the  current  source code for the HashMap class  but as stated it also depends on the super class  etc  The OOP framework used is qooxdoo  Please note that this code is already out-dated and refer to the GitHub project for the current work  As of writing this  there is also an ArrayList implementation  qx Class define   jsava util HashMap         extend  jsava util AbstractMap      implement   jsava util Map  jsava io Serializable  jsava lang Cloneable        construct  function              var args   Array prototype slice call  arguments                initialCapacity   this self  arguments   DEFAULT INITIAL CAPACITY              loadFactor   this self  arguments   DEFAULT LOAD FACTOR           switch  args length                 case 1                  if  qx Class implementsInterface  args 0   jsava util Map                           initialCapacity   Math max    args 0  size     this self  arguments   DEFAULT LOAD FACTOR    0    1                          this self  arguments   DEFAULT INITIAL CAPACITY                        loadFactor   this self  arguments   DEFAULT LOAD FACTOR                    else                       initialCapacity   args 0                                     break              case 2                  initialCapacity   args 0                   loadFactor   args 1                   break                     if  initialCapacity  lt  0                 throw new jsava lang IllegalArgumentException   Illegal initial capacity      initialCapacity                      if  initialCapacity  gt  this self  arguments   MAXIMUM CAPACITY                 initialCapacity   this self  arguments   MAXIMUM CAPACITY                    if  loadFactor  lt   0    isNaN  loadFactor                   throw new jsava lang IllegalArgumentException   Illegal load factor      loadFactor                       var capacity   1          while  capacity  lt  initialCapacity                 capacity  lt  lt   1                     this  loadFactor   loadFactor          this  threshold    capacity   loadFactor    0          this  table   jsava JsavaUtils emptyArrayOfGivenSize  capacity  null            this  init                statics            serialVersionUID  1           DEFAULT INITIAL CAPACITY  16          MAXIMUM CAPACITY  1  lt  lt  30          DEFAULT LOAD FACTOR  0 75            hash  function  hash                hash     hash  gt  gt  gt  20     hash  gt  gt  gt  12               return hash    hash  gt  gt  gt  7     hash  gt  gt  gt  4                        indexFor  function  hashCode  length                return hashCode  amp   length - 1                       Entry  qx Class define   jsava util HashMap Entry                 extend  jsava lang Object              implement   jsava util Map Entry                construct  function  hash  key  value  nextEntry                    this  value   value                  this  next   nextEntry                  this  key   key                  this  hash   hash                              members                     key  null                   value  null                       type jsava util HashMap Entry                     next  null                       type Number                     hash  0                   getKey  function                          return this  key                                      getValue  function                          return this  value                                      setValue  function  newValue                        var oldValue   this  value                      this  value   newValue                      return oldValue                                      equals  function  obj                        if  obj     null     qx Class implementsInterface  obj  jsava util HashMap Entry                               return false                                                  type jsava util HashMap Entry                        var entry   obj                          key1   this getKey                            key2   entry getKey                        if  key1     key2     key1     null  amp  amp  key1 equals  key2                                var value1   this getValue                                value2   entry getValue                            if  value1     value2     value1     null  amp  amp  value1 equals  value2                                    return true                                                                       return false                                      hashCode  function                          return  this  key     null   0   this  key hashCode                               this  value     null   0   this  value hashCode                                         toString  function                          return this getKey           this getValue                                                               This method is invoked whenever the value in an entry is                    overwritten by an invocation of put k v  for a key k that s already                    in the HashMap                                       recordAccess  function  map                                                               This method is invoked whenever the entry is                    removed from the table                                       recordRemoval  function  map                                                            members                 type jsava util HashMap Entry               table  null               type Number             size  0               type Number             threshold  0               type Number             loadFactor  0               type Number             modCount  0               implements jsava util Set              entrySet  null                          Initialization hook for subclasses  This method is called            in all constructors and pseudo-constructors  clone  readObject             after HashMap has been initialized but before any entries have            been inserted    In the absence of this method  readObject would            require explicit knowledge of subclasses                        init  function                          size  function                  return this  size                      isEmpty  function                  return this  size     0                      get  function  key                if  key     null                     return this   getForNullKey                               var hash   this self  arguments    hash  key hashCode                  for  var entry   this  table this self  arguments    indexFor  hash  this  table length                      entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash  amp  amp    k   entry  key      key    key equals  k                            return entry  value                                               return null                        getForNullKey  function                  for  var entry   this  table 0   entry     null  entry   entry  next                     if  entry  key     null                         return entry  value                                               return null                      containsKey  function  key                return this  getEntry  key       null                       getEntry  function  key                var hash    key     null    0   this self  arguments    hash  key hashCode                  for  var entry   this  table this self  arguments    indexFor  hash  this  table length                      entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash                      amp  amp      k   entry  key       key      key     null  amp  amp  key equals  k                               return entry                                               return null                      put  function  key  value                if  key     null                     return this   putForNullKey  value                               var hash   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                for  var entry   this  table i   entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash  amp  amp     k   entry  key      key    key equals  k                             var oldValue   entry  value                      entry  value   value                      entry  recordAccess  this                        return oldValue                                               this  modCount                this  addEntry  hash  key  value  i                return null                        putForNullKey  function  value                for  var entry   this  table 0   entry     null  entry   entry  next                     if  entry  key     null                         var oldValue   entry  value                      entry  value   value                      entry  recordAccess  this                        return oldValue                                               this  modCount                this  addEntry  0  null  value  0                return null                        putForCreate  function  key  value                var hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                for  var entry   this  table i   entry     null  entry   entry  next                          type jsava lang Object                    var k                  if  entry  hash     hash                      amp  amp     k   entry  key      key      key     null  amp  amp  key equals  k                               entry  value   value                      return                                               this  createEntry  hash  key  value  i                          putAllForCreate  function  map                var iterator   map entrySet   iterator                while  iterator hasNext                       var entry   iterator next                    this   putForCreate  entry getKey    entry getValue                                         resize  function  newCapacity                var oldTable   this  table                  oldCapacity   oldTable length              if  oldCapacity     this self  arguments   MAXIMUM CAPACITY                     this  threshold   Number MAX VALUE                  return                             var newTable   jsava JsavaUtils emptyArrayOfGivenSize  newCapacity  null                this  transfer  newTable                this  table   newTable              this  threshold    newCapacity   this  loadFactor    0                       transfer  function  newTable                var src   this  table                  newCapacity   newTable length              for  var j   0  j  lt  src length  j                       var entry   src j                   if  entry     null                         src j    null                      do                           var next   entry  next                              i   this self  arguments    indexFor  entry  hash  newCapacity                            entry  next   newTable i                           newTable i    entry                          entry   next                        while  entry     null                                                        putAll  function  map                var numKeyToBeAdded   map size                if  numKeyToBeAdded     0                     return                             if  numKeyToBeAdded  gt  this  threshold                     var targetCapacity    numKeyToBeAdded   this  loadFactor   1    0                  if  targetCapacity  gt  this self  arguments   MAXIMUM CAPACITY                         targetCapacity   this self  arguments   MAXIMUM CAPACITY                                     var newCapacity   this  table length                  while  newCapacity  lt  targetCapacity                         newCapacity  lt  lt   1                                    if  newCapacity  gt  this  table length                         this  resize  newCapacity                                                 var iterator   map entrySet   iterator                while  iterator hasNext                       var entry   iterator next                    this put  entry getKey    entry getValue                                        remove  function  key                var entry   this  removeEntryForKey  key                return entry     null   null   entry  value                       removeEntryForKey  function  key                var hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                    prev   this  table i                   entry   prev               while  entry     null                     var next   entry  next                           type jsava lang Object                            k                  if  entry  hash     hash                      amp  amp     k   entry  key      key      key     null  amp  amp  key equals  k                               this  modCount                        this  size--                      if  prev     entry                             this  table i    next                        else                           prev  next   next                                            entry  recordRemoval  this                        return entry                                    prev   entry                  entry   next                             return entry                       removeMapping  function  obj                if  obj     null     qx Class implementsInterface  obj  jsava util Map Entry                       return null                                  implements jsava util Map Entry                var entry   obj                  key   entry getKey                    hash    key     null    0   this self  arguments    hash  key hashCode                      i   this self  arguments    indexFor  hash  this  table length                    prev   this  table i                   e   prev               while  e     null                     var next   e  next                  if  e  hash     hash  amp  amp  e equals  entry                           this  modCount                        this  size--                      if  prev     e                             this  table i    next                        else                           prev  next   next                                            e  recordRemoval  this                        return e                                    prev   e                  e   next                             return e                      clear  function                  this  modCount                var table   this  table              for  var i   0  i  lt  table length  i                       table i    null                            this  size   0                      containsValue  function  value                if  value     null                     return this   containsNullValue                               var table   this  table              for  var i   0  i  lt  table length  i                       for  var entry   table i   entry     null  entry   entry  next                         if  value equals  entry  value                               return true                                                                     return false                        containsNullValue  function                  var table   this  table              for  var i   0  i  lt  table length  i                       for  var entry   table i   entry     null  entry   entry  next                         if  entry  value     null                             return true                                                                     return false                      clone  function                       type jsava util HashMap                var result   null              try                   result   this base  arguments                  catch  e                     if   qx Class isSubClassOf  e constructor  jsava lang CloneNotSupportedException                           throw e                                               result  table   jsava JsavaUtils emptyArrayOfGivenSize  this  table length  null                result   entrySet   null              result  modCount   0              result  size   0              result  init                result   putAllForCreate  this                 return result                       addEntry  function  hash  key  value  bucketIndex                var entry   this  table bucketIndex               this  table bucketIndex    new  this self  arguments   Entry   hash  key  value  entry                if  this  size    gt   this  threshold                     this  resize  2   this  table length                                       createEntry  function  hash  key  value  bucketIndex                var entry   this  table bucketIndex               this  table bucketIndex    new  this self  arguments   Entry   hash  key  value  entry                this  size                        keySet  function                  var keySet   this  keySet              return keySet     null   keySet     this  keySet   new this KeySet  this                          values  function                  var values   this  values              return values     null   values     this  values   new this Values  this                          entrySet  function                  return this   entrySet0                          entrySet0  function                  var entrySet   this   entrySet              return entrySet     null   entrySet     this   entrySet   new this EntrySet  this                               private            HashIterator  qx Class define   jsava util HashMap HashIterator                 extend  jsava lang Object              implement   jsava util Iterator                type   abstract                     protected                construct  function  thisHashMap                    this   thisHashMap   thisHashMap                  this  expectedModCount   this   thisHashMap  modCount                  if  this   thisHashMap  size  gt  0                         var table   this   thisHashMap  table                      while  this  index  lt  table length  amp  amp    this  next   table this  index          null                                do nothing                                                                     members                      thisHashMap  null                        type jsava util HashMap Entry                     next  null                       type Number                     expectedModCount  0                       type Number                     index  0                       type jsava util HashMap Entry                     current  null                   hasNext  function                          return this  next     null                                       nextEntry  function                          if  this   thisHashMap  modCount     this  expectedModCount                             throw new jsava lang ConcurrentModificationException                                               var entry   this  next                      if  entry     null                             throw new jsava lang NoSuchElementException                                               if   this  next   entry  next      null                             var table   this   thisHashMap  table                          while  this  index  lt  table length  amp  amp    this  next   table this  index          null                                    do nothing                                                                      this  current   entry                      return entry                                      remove  function                          if  this  current     null                             throw new jsava lang IllegalStateException                                               if  this   thisHashMap  modCount     this  expectedModCount                             throw new jsava lang ConcurrentModificationException                                               var key   this  current  key                      this  current   null                      this   thisHashMap  removeEntryForKey  key                        this  expectedModCount   this   thisHashMap  modCount                                                         newKeyIterator  function                  return new this KeyIterator  this                         newValueIterator  function                  return new this ValueIterator  this                         newEntryIterator  function                  return new this EntryIterator  this                             private            ValueIterator  qx Class define   jsava util HashMap ValueIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry    value                                                             private            KeyIterator  qx Class define   jsava util HashMap KeyIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry   getKey                                                               private            EntryIterator  qx Class define   jsava util HashMap EntryIterator                 extend  jsava util HashMap HashIterator               construct  function  thisHashMap                    this base  arguments  thisHashMap                                members                    next  function                          return this  nextEntry                                                               private            KeySet  qx Class define   jsava util HashMap KeySet                 extend  jsava util AbstractSet               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newKeyIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        return this   thisHashMap containsKey  obj                                        remove  function  obj                        return this   thisHashMap  removeEntryForKey  obj       null                                      clear  function                          this   thisHashMap clear                                                               private            Values  qx Class define   jsava util HashMap Values                 extend  jsava util AbstractCollection               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newValueIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        return this   thisHashMap containsValue  obj                                        clear  function                          this   thisHashMap clear                                                               private            EntrySet  qx Class define   jsava util HashMap EntrySet                 extend  jsava util AbstractSet               construct  function  thisHashMap                    this base  arguments                    this   thisHashMap   thisHashMap                              members                      thisHashMap  null                   iterator  function                          return this   thisHashMap  newEntryIterator                                        size  function                          return this   thisHashMap  size                                      contains  function  obj                        if  obj     null     qx Class implementsInterface  obj  jsava util Map Entry                               return false                                                  implements jsava util Map Entry                        var entry   obj                          candidate   this   thisHashMap  getEntry  entry getKey                          return candidate     null  amp  amp  candidate equals  entry                                        remove  function  obj                        return this   thisHashMap  removeMapping  obj       null                                      clear  function                          this   thisHashMap clear

User · Answer

JavaScript does not have a built-in map hashmap  It should be called an associative array  hash  quot X quot   is equal to hash X  but it allows  quot X quot  as a string variable  In other words  hash x  is functionally equal to eval  quot hash  quot  x toString     It is more similar to object properties rather than key-value mapping  If you are looking for a better key value mapping in JavaScript  please use the Map object

User · Answer

My  Map  implementation  derived from Christoph s example  Example usage  var map   new Map        Creates an  quot in-memory quot  map var map   new Map  quot storageId quot        Creates a map that is loaded persisted using html5 storage   function Map storageId        this current   undefined      this size   0      this storageId   storageId      if  this storageId            this keys   new Array            this disableLinking             Map noop   function         return this      Map illegal   function         throw new Error  quot illegal operation for maps without linking quot           Map initialisation from an existing object    doesn t add inherited properties if not explicitly instructed to     omitting foreignKeys means foreignKeys     undefined  i e     false    -- gt  inherited properties won t be added Map from   function obj  foreignKeys        var map   new Map      for var prop in obj            if foreignKeys    obj hasOwnProperty prop               map put prop  obj prop              return map      Map prototype disableLinking   function         this link   Map noop      this unlink   Map noop      this disableLinking   Map noop       this next   Map illegal      this key   Map illegal      this value   Map illegal        this removeAll   Map illegal        return this         Overwrite in Map instance if necessary Map prototype hash   function value        return  typeof value           value instanceof Object            value   hash     value   hash     arguments callee current             value toString         Map prototype hash current   0      --- Mapping functions  Map prototype get   function key        var item   this this hash key        if  item     undefined            if  this storageId                try                   var itemStr   localStorage getItem this storageId   key                   if  itemStr  amp  amp  itemStr      undefined                         item   JSON parse itemStr                       this this hash key     item                      this keys push key                         this size                                  catch  e                    console log e                                     return item     undefined   undefined   item value      Map prototype put   function key  value        var hash   this hash key        if this hash      undefined            var item     key   key  value   value            this hash    item           this link item             this size            else this hash  value   value      if  this storageId            this keys push key           try               localStorage setItem this storageId   key  JSON stringify this hash               catch  e                console log e                       return this      Map prototype remove   function key        var hash   this hash key       var item   this hash       if item     undefined            --this size          this unlink item            delete this hash             if  this storageId            try               localStorage setItem this storageId   key  undefined             catch  e                console log e                       return this         Only works if linked Map prototype removeAll   function         if  this storageId            for  var i 0  i lt this keys length  i                  this remove this keys i                      this keys length   0        else           while this size              this remove this key               return this         --- Linked list helper functions  Map prototype link   function item        if  this storageId            return            if this size    0            item prev   item          item next   item          this current   item            else           item prev   this current prev          item prev next   item          item next   this current          this current prev   item            Map prototype unlink   function item        if  this storageId            return            if this size    0          this current   undefined      else           item prev next   item next          item next prev   item prev          if item     this current              this current   item next               --- Iterator functions - only work if map is linked  Map prototype next   function         this current   this current next      Map prototype key   function         if  this storageId            return undefined        else           return this current key            Map prototype value   function         if  this storageId            return undefined            return this current value

User · Answer

Unfortunately  none of the previous answers were good for my case  different key objects may have the same hash code  Therefore  I wrote a simple Java-like HashMap version  function HashMap         this buckets          HashMap prototype put   function key  value        var hashCode   key hashCode        var bucket   this buckets hashCode       if   bucket            bucket   new Array            this buckets hashCode    bucket            for  var i   0  i  lt  bucket length    i            if  bucket i  key equals key                 bucket i  value   value              return                      bucket push   key  key  value  value        HashMap prototype get   function key        var hashCode   key hashCode        var bucket   this buckets hashCode       if   bucket            return null            for  var i   0  i  lt  bucket length    i            if  bucket i  key equals key                 return bucket i  value                     HashMap prototype keys   function         var keys   new Array        for  var hashKey in this buckets            var bucket   this buckets hashKey           for  var i   0  i  lt  bucket length    i                keys push bucket i  key                       return keys     HashMap prototype values   function         var values   new Array        for  var hashKey in this buckets            var bucket   this buckets hashKey           for  var i   0  i  lt  bucket length    i                values push bucket i  value                       return values     Note  key objects must  quot implement quot  the hashCode   and equals   methods

User · Answer

If performance is not critical  e g   the amount of keys is relatively small  and you don t want to pollute your  or maybe not your  objects with additional fields like  hash   id  etc   then you can make use of the fact that Array prototype indexOf employs strict equality  Here is a simple implementation  var Dict    function           Internet Explorer 8 and earlier does not have any Array prototype indexOf     function indexOfPolyfill val          for  var i   0  l   this length  i  lt  l    i            if  this i      val              return i                          return -1             function Dict          this keys             this values             if   this keys indexOf            this keys indexOf   indexOfPolyfill                      Dict prototype has   function key         return this keys indexOf key     -1              Dict prototype get   function key  defaultValue         var index   this keys indexOf key         return index    -1   defaultValue   this values index               Dict prototype set   function key  value         var index   this keys indexOf key         if  index    -1            this keys push key           this values push value           else           var prevValue   this values index           this values index    value          return prevValue                      Dict prototype delete   function key         var index   this keys indexOf key         if  index    -1            this keys splice index  1           return this values splice index  1  0                       Dict prototype clear   function          this keys splice 0  this keys length         this values splice 0  this values length               return Dict         Example of usage  var a       b           c     toString  function    return  1            d   1  s    1   u   undefined  n   null      dict   new Dict        Keys and values can be anything dict set a   a    dict set b   b    dict set c   c    dict set d   d    dict set s   s    dict set u   u    dict set n   n     dict get a       a  dict get b       b  dict get s       s  dict get u       u  dict get n       n     etc   Comparing to ECMAScript  6 WeakMap  it has two issues  O n  search time and non-weakness  i e   it will cause memory leak if you don t use delete or clear to release keys

User · Answer

There are some really great solutions nowadays with external libraries   collections js Immutable js  JavaScript also has its language-provided Map as well   Map

User · Answer

If performance is not critical  e g   the amount of keys is relatively small  and you don t want to pollute your  or maybe not your  objects with additional fields like  hash   id  etc   then you can make use of the fact that Array prototype indexOf employs strict equality  Here is a simple implementation  var Dict    function           Internet Explorer 8 and earlier does not have any Array prototype indexOf     function indexOfPolyfill val          for  var i   0  l   this length  i  lt  l    i            if  this i      val              return i                          return -1             function Dict          this keys             this values             if   this keys indexOf            this keys indexOf   indexOfPolyfill                      Dict prototype has   function key         return this keys indexOf key     -1              Dict prototype get   function key  defaultValue         var index   this keys indexOf key         return index    -1   defaultValue   this values index               Dict prototype set   function key  value         var index   this keys indexOf key         if  index    -1            this keys push key           this values push value           else           var prevValue   this values index           this values index    value          return prevValue                      Dict prototype delete   function key         var index   this keys indexOf key         if  index    -1            this keys splice index  1           return this values splice index  1  0                       Dict prototype clear   function          this keys splice 0  this keys length         this values splice 0  this values length               return Dict         Example of usage  var a       b           c     toString  function    return  1            d   1  s    1   u   undefined  n   null      dict   new Dict        Keys and values can be anything dict set a   a    dict set b   b    dict set c   c    dict set d   d    dict set s   s    dict set u   u    dict set n   n     dict get a       a  dict get b       b  dict get s       s  dict get u       u  dict get n       n     etc   Comparing to ECMAScript  6 WeakMap  it has two issues  O n  search time and non-weakness  i e   it will cause memory leak if you don t use delete or clear to release keys

User · Answer

Problem description

JavaScript has no built-in general map type (sometimes called associative array or dictionary) which allows to access arbitrary values by arbitrary keys. JavaScript's fundamental data structure is the object, a special type of map which only accepts strings as keys and has special semantics like prototypical inheritance, getters and setters and some further voodoo.

When using objects as maps, you have to remember that the key will be converted to a string value via toString(), which results in mapping 5 and '5' to the same value and all objects which don't overwrite the toString() method to the value indexed by '[object Object]'. You might also involuntarily access its inherited properties if you don't check hasOwnProperty().

JavaScript's built-in array type does not help one bit: JavaScript arrays are not associative arrays, but just objects with a few more special properties. If you want to know why they can't be used as maps, look here.

Eugene's Solution

Eugene Lazutkin already described the basic idea of using a custom hash function to generate unique strings which can be used to look up the associated values as properties of a dictionary object. This will most likely be the fastest solution, because objects are internally implemented as hash tables.

Note: Hash tables (sometimes called hash maps) are a particular implementation of the map concept using a backing array and lookup via numeric hash values. The runtime environment might use other structures (such as search trees or skip lists) to implement JavaScript objects, but as objects are the fundamental data structure, they should be sufficiently optimised.

In order to get a unique hash value for arbitrary objects, one possibility is to use a global counter and cache the hash value in the object itself (for example, in a property named __hash).

A hash function which does this is and works for both primitive values and objects is:

function hash(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
}

hash.current = 0;

This function can be used as described by Eugene. For convenience, we will further wrap it in a Map class.

My `Map` implementation

The following implementation will additionally store the key-value-pairs in a doubly linked list in order to allow fast iteration over both keys and values. To supply your own hash function, you can overwrite the instance's hash() method after creation.

// Linking the key-value-pairs is optional.
// If no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
    this.current = undefined;
    this.size = 0;

    if(linkItems === false)
        this.disableLinking();
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// Map initialisation from an existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
    var map = new Map;

    for(var prop in obj) {
        if(foreignKeys || obj.hasOwnProperty(prop))
            map.put(prop, obj[prop]);
    }

    return map;
};

Map.prototype.disableLinking = function() {
    this.link = Map.noop;
    this.unlink = Map.noop;
    this.disableLinking = Map.noop;
    this.next = Map.illegal;
    this.key = Map.illegal;
    this.value = Map.illegal;
    this.removeAll = Map.illegal;

    return this;
};

// Overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
};

Map.prototype.hash.current = 0;

// --- Mapping functions

Map.prototype.get = function(key) {
    var item = this[this.hash(key)];
    return item === undefined ? undefined : item.value;
};

Map.prototype.put = function(key, value) {
    var hash = this.hash(key);

    if(this[hash] === undefined) {
        var item = { key : key, value : value };
        this[hash] = item;

        this.link(item);
        ++this.size;
    }
    else this[hash].value = value;

    return this;
};

Map.prototype.remove = function(key) {
    var hash = this.hash(key);
    var item = this[hash];

    if(item !== undefined) {
        --this.size;
        this.unlink(item);

        delete this[hash];
    }

    return this;
};

// Only works if linked
Map.prototype.removeAll = function() {
    while(this.size)
        this.remove(this.key());

    return this;
};

// --- Linked list helper functions

Map.prototype.link = function(item) {
    if(this.size == 0) {
        item.prev = item;
        item.next = item;
        this.current = item;
    }
    else {
        item.prev = this.current.prev;
        item.prev.next = item;
        item.next = this.current;
        this.current.prev = item;
    }
};

Map.prototype.unlink = function(item) {
    if(this.size == 0)
        this.current = undefined;
    else {
        item.prev.next = item.next;
        item.next.prev = item.prev;
        if(item === this.current)
            this.current = item.next;
    }
};

// --- Iterator functions - only work if map is linked

Map.prototype.next = function() {
    this.current = this.current.next;
};

Map.prototype.key = function() {
    return this.current.key;
};

Map.prototype.value = function() {
    return this.current.value;
};

Example

The following script,

var map = new Map;

map.put('spam', 'eggs').
    put('foo', 'bar').
    put('foo', 'baz').
    put({}, 'an object').
    put({}, 'another object').
    put(5, 'five').
    put(5, 'five again').
    put('5', 'another five');

for(var i = 0; i++ < map.size; map.next())
    document.writeln(map.hash(map.key()) + ' : ' + map.value());

generates this output:

string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five

Further considerations

PEZ suggested to overwrite the toString() method, presumably with our hash function. This is not feasible, because it doesn't work for primitive values (changing toString() for primitives is a very bad idea). If we want toString() to return meaningful values for arbitrary objects, we would have to modify Object.prototype, which some people (myself not included) consider verboten.

The current version of my Map implementation as well as other JavaScript goodies can be obtained from here.

User · Answer

You can use ECMAScript  6 WeakMap or Map   WeakMaps are key value maps in which keys are objects      Map objects are simple key value maps  Any value  both objects and primitive values  may be used as either a key or a value   Be aware that neither is widely supported  but you can use ECMAScript  6 Shim  requires native ECMAScript  5 or ECMAScript  5 Shim  to support Map  but not WeakMap  see why

User · Answer

JavaScript does not have a built-in map hashmap  It should be called an associative array  hash  quot X quot   is equal to hash X  but it allows  quot X quot  as a string variable  In other words  hash x  is functionally equal to eval  quot hash  quot  x toString     It is more similar to object properties rather than key-value mapping  If you are looking for a better key value mapping in JavaScript  please use the Map object

User · Answer

JavaScript does not have a built-in map hashmap  It should be called an associative array  hash  quot X quot   is equal to hash X  but it allows  quot X quot  as a string variable  In other words  hash x  is functionally equal to eval  quot hash  quot  x toString     It is more similar to object properties rather than key-value mapping  If you are looking for a better key value mapping in JavaScript  please use the Map object

User · Answer

Hash your objects yourself manually  and use the resulting strings as keys for a regular JavaScript dictionary  After all  you are in the best position to know what makes your objects unique  That s what I do  Example  var key   function obj        Some unique object-dependent key   return obj totallyUniqueEmployeeIdKey     Just an example     var dict        dict key obj1     obj1  dict key obj2     obj2   This way you can control indexing done by JavaScript without heavy lifting of memory allocation  and overflow handling  Of course  if you truly want the  quot industrial-grade solution quot   you can build a class parameterized by the key function  and with all the necessary API of the container  but     we use JavaScript  and trying to be simple and lightweight  so this functional solution is simple and fast  The key function can be as simple as selecting right attributes of the object  e g   a key  or a set of keys  which are already unique  a combination of keys  which are unique together  or as complex as using some cryptographic hashes like in DojoX encoding  or DojoX UUID  While the latter solutions may produce unique keys  personally I try to avoid them at all costs  especially  if I know what makes my objects unique  Update in 2014  Answered back in 2008 this simple solution still requires more explanations  Let me clarify the idea in a Q amp A form  Your solution doesn t have a real hash  Where is it    JavaScript is a high-level language  Its basic primitive  Object  includes a hash table to keep properties  This hash table is usually written in a low-level language for efficiency  Using a simple object with string keys we use an efficiently implemented hash table without any efforts on our part  How do you know they use a hash  There are three major ways to keep a collection of objects addressable by a key   Unordered  In this case to retrieve an object by its key we have to go over all keys stopping when we find it  On average it will take n 2 comparisons  Ordered   Example  1  a sorted array     doing a binary search we will find our key after  log2 n  comparisons on average  Much better  Example  2  a tree  Again it ll be  log n  attempts    Hash table  On average  it requires a constant time  Compare  O n  vs  O log n  vs  O 1   Boom   Obviously JavaScript objects use hash tables in some form to handle general cases  Do browser vendors really use hash tables    Really   Chrome node js V8  JSObject  Look for NameDictionary and NameDictionaryShape with pertinent details in objects cc and objects-inl h  Firefox Gecko  JSObject  NativeObject  and PlainObject with pertinent details in jsobj cpp and vm NativeObject cpp   Do they handle collisions  Yes  See above  If you found a collision on unequal strings  please do not hesitate to file a bug with a vendor  So what is your idea  If you want to hash an object  find what makes it unique and use it as a key  Do not try to calculate a real hash or emulate hash tables     it is already efficiently handled by the underlying JavaScript object  Use this key with JavaScript s Object to leverage its built-in hash table while steering clear of possible clashes with default properties  Examples to get you started   If your objects include a unique user name     use it as a key  If it includes a unique customer number     use it as a key   If it includes unique government-issued numbers like US SSNs  or a passport number  and your system doesn t allow duplicates     use it as a key    If a combination of fields is unique     use it as a key   US state abbreviation   driver license number makes an excellent key  Country abbreviation   passport number is an excellent key too    Some function on fields  or a whole object  can return a unique value     use it as a key   I used your suggestion and cached all objects using a user name  But some wise guy is named  quot toString quot   which is a built-in property  What should I do now  Obviously  if it is even remotely possible that the resulting key will exclusively consists of Latin characters  you should do something about it  For example  add any non-Latin Unicode character you like at the beginning or at the end to un-clash with default properties   quot  toString quot    quot  MarySmith quot   If a composite key is used  separate key components using some kind of non-Latin delimiter   quot name city state quot   In general  this is the place where we have to be creative and select the easiest keys with given limitations  uniqueness  potential clashes with default properties   Note  unique keys do not clash by definition  while potential hash clashes will be handled by the underlying Object  Why don t you like industrial solutions  IMHO  the best code is no code at all  it has no errors  requires no maintenance  easy to understand  and executes instantaneously  All  quot hash tables in JavaScript quot  I saw were  gt 100 lines of code  and involved multiple objects  Compare it with  dict key    value  Another point  is it even possible to beat a performance of a primordial object written in a low-level language  using JavaScript and the very same primordial objects to implement what is already implemented  I still want to hash my objects without any keys  We are in luck  ECMAScript 6  released in June 2015  defines map and set  Judging by the definition  they can use an object s address as a key  which makes objects instantly distinct without artificial keys  OTOH  two different  yet identical objects  will be mapped as distinct  Comparison breakdown from MDN   Objects are similar to Maps in that both let you set keys to values  retrieve those values  delete keys  and detect whether something is stored at a key  Because of this  and because there were no built-in alternatives   Objects have been used as Maps historically  however  there are important differences that make using a Map preferable in certain cases   The keys of an Object are Strings and Symbols  whereas they can be any value for a Map  including functions  objects  and any primitive  The keys in Map are ordered while keys added to object are not  Thus  when iterating over it  a Map object returns keys in order of insertion  You can get the size of a Map easily with the size property  while the number of properties in an Object must be determined manually  A Map is an iterable and can thus be directly iterated  whereas iterating over an Object requires obtaining its keys in some fashion and iterating over them  An Object has a prototype  so there are default keys in the map that could collide with your keys if you re not careful  As of ES5 this can be bypassed by using map   Object create null   but this is seldom done  A Map may perform better in scenarios involving frequent addition and removal of key pairs

User · Answer

Here is an easy and convenient way of using something similar to the Java map:

var map = {
              'map_name_1': map_value_1,
              'map_name_2': map_value_2,
              'map_name_3': map_value_3,
              'map_name_4': map_value_4
          }

And to get the value:

alert(map['map_name_1']);    // Gives the value of map_value_1

... etc. ...

User · Answer

In ECMAScript  6 you can use WeakMap  Example  var wm1   new WeakMap        wm2   new WeakMap        wm3   new WeakMap    var o1           o2   function          o3   window   wm1 set o1  37   wm1 set o2   quot azerty quot    wm2 set o1  o2      A value can be anything  including an object or a function wm2 set o3  undefined   wm2 set wm1  wm2      Keys and values can be any objects  Even WeakMaps   wm1 get o2       quot azerty quot  wm2 get o2      Undefined  because there is no value for o2 on wm2 wm2 get o3      Undefined  because that is the set value  wm1 has o2      True wm2 has o2      False wm2 has o3      True  even if the value itself is  undefined    wm3 set o1  37   wm3 get o1      37 wm3 clear    wm3 get o1      Undefined  because wm3 was cleared and there is no value for o1 anymore  wm1 has o1        True wm1 delete o1   wm1 has o1        False  But  Because of references being weak  WeakMap keys are not enumerable  i e  there is no method giving you a list of the keys

User · Answer

My  Map  implementation  derived from Christoph s example  Example usage  var map   new Map        Creates an  quot in-memory quot  map var map   new Map  quot storageId quot        Creates a map that is loaded persisted using html5 storage   function Map storageId        this current   undefined      this size   0      this storageId   storageId      if  this storageId            this keys   new Array            this disableLinking             Map noop   function         return this      Map illegal   function         throw new Error  quot illegal operation for maps without linking quot           Map initialisation from an existing object    doesn t add inherited properties if not explicitly instructed to     omitting foreignKeys means foreignKeys     undefined  i e     false    -- gt  inherited properties won t be added Map from   function obj  foreignKeys        var map   new Map      for var prop in obj            if foreignKeys    obj hasOwnProperty prop               map put prop  obj prop              return map      Map prototype disableLinking   function         this link   Map noop      this unlink   Map noop      this disableLinking   Map noop       this next   Map illegal      this key   Map illegal      this value   Map illegal        this removeAll   Map illegal        return this         Overwrite in Map instance if necessary Map prototype hash   function value        return  typeof value           value instanceof Object            value   hash     value   hash     arguments callee current             value toString         Map prototype hash current   0      --- Mapping functions  Map prototype get   function key        var item   this this hash key        if  item     undefined            if  this storageId                try                   var itemStr   localStorage getItem this storageId   key                   if  itemStr  amp  amp  itemStr      undefined                         item   JSON parse itemStr                       this this hash key     item                      this keys push key                         this size                                  catch  e                    console log e                                     return item     undefined   undefined   item value      Map prototype put   function key  value        var hash   this hash key        if this hash      undefined            var item     key   key  value   value            this hash    item           this link item             this size            else this hash  value   value      if  this storageId            this keys push key           try               localStorage setItem this storageId   key  JSON stringify this hash               catch  e                console log e                       return this      Map prototype remove   function key        var hash   this hash key       var item   this hash       if item     undefined            --this size          this unlink item            delete this hash             if  this storageId            try               localStorage setItem this storageId   key  undefined             catch  e                console log e                       return this         Only works if linked Map prototype removeAll   function         if  this storageId            for  var i 0  i lt this keys length  i                  this remove this keys i                      this keys length   0        else           while this size              this remove this key               return this         --- Linked list helper functions  Map prototype link   function item        if  this storageId            return            if this size    0            item prev   item          item next   item          this current   item            else           item prev   this current prev          item prev next   item          item next   this current          this current prev   item            Map prototype unlink   function item        if  this storageId            return            if this size    0          this current   undefined      else           item prev next   item next          item next prev   item prev          if item     this current              this current   item next               --- Iterator functions - only work if map is linked  Map prototype next   function         this current   this current next      Map prototype key   function         if  this storageId            return undefined        else           return this current key            Map prototype value   function         if  this storageId            return undefined            return this current value

User · Answer

According to ECMAScript 2015  ES6   standard JavaScript has a Map implementation  More about which could be found here  Basic usage  var myMap   new Map    var keyString    quot a string quot       keyObj           keyFunc   function            Setting the values myMap set keyString   quot value associated with  a string  quot    myMap set keyObj   quot value associated with keyObj quot    myMap set keyFunc   quot value associated with keyFunc quot     myMap size     3     Getting the values myMap get keyString          quot value associated with  a string  quot  myMap get keyObj             quot value associated with keyObj quot  myMap get keyFunc            quot value associated with keyFunc quot

User · Answer

I ve implemented a JavaScript HashMap which code can be obtained from http   github com lambder HashMapJS tree master Here is the code                                                                              license MIT   author Lambder   copyright 2009 Lambder    end                                                                            var HashMap   function       this initialize       HashMap prototype       hashkey prefix   quot  lt  HashMapHashkeyPerfix gt  quot     hashcode field   quot  lt  HashMapHashkeyPerfix gt  quot      initialize  function         this backing hash           this code   0               Maps value to key returning previous association         put  function key  value        var prev      if  key  amp  amp  value          var hashCode   key this hashcode field         if  hashCode            prev   this backing hash hashCode           else           this code    1          hashCode   this hashkey prefix   this code          key this hashcode field    hashCode                this backing hash hashCode    value            return prev               Returns value associated with given key         get  function key        var value      if  key          var hashCode   key this hashcode field         if  hashCode            value   this backing hash hashCode                     return value               Deletes association by given key     Returns true if the association existed  false otherwise         del  function key        var success   false      if  key          var hashCode   key this hashcode field         if  hashCode            var prev   this backing hash hashCode           this backing hash hashCode    undefined          if prev     undefined            success   true                    return success              Usage     Creation  var my map   new HashMap        Insertion  var a key       var a value    struct   quot structA quot    var b key       var b value    struct   quot structB quot    var c key       var c value    struct   quot structC quot     my map put a key  a value   my map put b key  b value   var prev b   my map put b key  c value       Retrieval  if my map get a key      a value     throw  quot fail1 quot     if my map get b key      c value     throw  quot fail2 quot     if prev b     b value     throw  quot fail3 quot         Deletion  var a existed   my map del a key   var c existed   my map del c key   var a2 existed   my map del a key    if a existed     true     throw  quot fail4 quot     if c existed     false     throw  quot fail5 quot     if a2 existed     false     throw  quot fail6 quot

User · Answer

Here is an easy and convenient way of using something similar to the Java map:

var map = {
              'map_name_1': map_value_1,
              'map_name_2': map_value_2,
              'map_name_3': map_value_3,
              'map_name_4': map_value_4
          }

And to get the value:

alert(map['map_name_1']);    // Gives the value of map_value_1

... etc. ...

User · Answer

You d have to store couplets of object value pairs in some internal state  HashMap   function      this  dict          HashMap prototype  get   function key     for var i 0  couplet  couplet   this  dict i   i         if couplet 0      key         return couplet               HashMap prototype put   function key  value     var couplet   this  get key     if couplet       couplet 1    value     else      this  dict push  key  value          return this     for chaining   HashMap prototype get   function key     var couplet   this  get key     if couplet       return couplet 1          And use it as such  var color          Unique object instance var shape          Unique object instance var map   new HashMap    map put color   quot blue quot    map put shape   quot round quot    console log  quot Item is quot   map get color    quot and quot   map get shape     Of course  this implementation is also somewhere along the lines of O n   Eugene s examples are the only way to get a hash that works with any sort of speed you d expect from a real hash  Another approach  along the lines of Eugene s answer is to somehow attach a unique ID to all objects  One of my favorite approaches is to take one of the built-in methods inherited from the Object superclass  replace it with a custom function passthrough and attach properties to that function object  If you were to rewrite my HashMap method to do this  it would look like  HashMap   function      this  dict          HashMap prototype  shared    id  1   HashMap prototype put   function put key  value     if typeof key     quot object quot        if  key hasOwnProperty  id         key hasOwnProperty   function key           return Object prototype hasOwnProperty call this  key                 key hasOwnProperty  id   this  shared id              this  dict key hasOwnProperty  id    value     else      this  dict key    value        return this     for chaining    HashMap prototype get   function get key     if typeof key     quot object quot        return this  dict key hasOwnProperty  id         return this  dict key      This version appears to be only slightly faster  but in theory it will be significantly faster for large data sets

User · Answer

You d have to store couplets of object value pairs in some internal state  HashMap   function      this  dict          HashMap prototype  get   function key     for var i 0  couplet  couplet   this  dict i   i         if couplet 0      key         return couplet               HashMap prototype put   function key  value     var couplet   this  get key     if couplet       couplet 1    value     else      this  dict push  key  value          return this     for chaining   HashMap prototype get   function key     var couplet   this  get key     if couplet       return couplet 1          And use it as such  var color          Unique object instance var shape          Unique object instance var map   new HashMap    map put color   quot blue quot    map put shape   quot round quot    console log  quot Item is quot   map get color    quot and quot   map get shape     Of course  this implementation is also somewhere along the lines of O n   Eugene s examples are the only way to get a hash that works with any sort of speed you d expect from a real hash  Another approach  along the lines of Eugene s answer is to somehow attach a unique ID to all objects  One of my favorite approaches is to take one of the built-in methods inherited from the Object superclass  replace it with a custom function passthrough and attach properties to that function object  If you were to rewrite my HashMap method to do this  it would look like  HashMap   function      this  dict          HashMap prototype  shared    id  1   HashMap prototype put   function put key  value     if typeof key     quot object quot        if  key hasOwnProperty  id         key hasOwnProperty   function key           return Object prototype hasOwnProperty call this  key                 key hasOwnProperty  id   this  shared id              this  dict key hasOwnProperty  id    value     else      this  dict key    value        return this     for chaining    HashMap prototype get   function get key     if typeof key     quot object quot        return this  dict key hasOwnProperty  id         return this  dict key      This version appears to be only slightly faster  but in theory it will be significantly faster for large data sets

User · Answer

There are some really great solutions nowadays with external libraries   collections js Immutable js  JavaScript also has its language-provided Map as well   Map

[javascript] JavaScript hashmap equivalent

The answer is

Problem description

Eugene's Solution

My `Map` implementation

Example

Further considerations

Problem description

Eugene's Solution

My `Map` implementation

Example

Further considerations

Problem description

Eugene's Solution

My `Map` implementation

Example

Further considerations

Problem description

Eugene's Solution

My `Map` implementation

Example

Further considerations

Examples related to javascript

Examples related to data-structures

Examples related to language-features

Examples related to hashmap

Tags