Dynamically creating keys in a JavaScript associative array

Initializing dynamic objects

JavaScript objects are your best friend for creating associative arrays of key-value pairs. Unmask them using object literal {} or new Object() syntax:

let dictionary = {}; // "Lightweight champion"
// or
let dictionary = new Object(); // "Heavyweight, but packing the same punch"


The temptation to use new Array() for this purpose is an illusion. Despite JavaScript arrays being able to function as associative arrays, this path leads to the dark side — unforeseen inconsistencies and bizarre behavior.

Dealing with key-value assignment

When generating a dynamic dictionary, your key-value pairs can originate from several formats, such as an innocent-looking string. Here's how to tame this wild beast:

• Slice and dice your strings into key-value pairs using String.split(), ensuring your formatting is on point.
• Clean up with String.replace() and your regex broom to sweep away unwanted characters.
• Trim your keys with trim(), so you don't end up with a space oddity.

let keyValueString = "key1=value1;key2=value2";
keyValueString.split(';').forEach(pair => {
  let [key, value] = pair.split('=').map(str => str.trim()); // "Shaken, not stirred"
  dictionary[key] = value;
});


Manipulating and inspecting dictionary contents

Whether you're a detective inspecting or an editor altering dynamic keys within a dictionary, these stunts are for you:

• Roll out the red carpet for each key with a for...in loop:

  for (let key in dictionary) {
    console.log(key, dictionary[key]); // "Key and value, reporting for duty!"
  }
  

• Evict unwelcome keys quietly using delete:

  delete dictionary['unwantedKey']; // "Adios, unwantedKey!"
  

• The old hasOwnProperty() trick to check whether a key is in town:

  if (dictionary.hasOwnProperty(key)) {
    // "Key's home!"
  }
  

Keys to verification

After the wild ride of additions or deletions, you want to ensure your dictionary has the right inhabitants. Here's how to turn on the house lights and take a good look:

• Ring the bell using alert(dictionary[key]) or shoot up a flare with console.log(dictionary[key]).
• Swap out the dictionary's entire occupant list as needed:

  dictionary = { 'freshKey': 'freshValue', 'anotherFreshKey': 'anotherFreshValue' }; // "Out with the old, in with the new!"
  

Advanced uses of dynamic keys

Stripping keys for neatness

Trim the unnecessary fringes of your keys:

• Have unwanted characters walk the plank with String.replace().
• Use spaces judiciously around equals signs and delimiters for a neatly-written novel.

Hash tables for efficiency

Time is money! Use a hash table by employing objects for swift data operations. JavaScript engines rev up their horses for these, ensuring top speed access and retrieval.

Functions for code cleanliness

Keep your code neat and tidy with functions:

function setKeyValuePair(obj, key, value) { 
  obj[key] = value; 
  return obj; // "Here's your brand new object, hot off the press!"
}
