class_based_javascript.js

var HashTable = function(name){
  this.name = name;
  this.table = {};
}

HashTable.prototype.get = function(key){
  return this.table[key];
}

HashTable.prototype.set = function(key, value){
  return this.table[key] = value;
}

var table = new HashTable("my table");
table.set("foo", "bar");
console.log(table.get("foo"));

functional_javascript.js

/*
This isn't truly functional since in Javascript
objects/arrays are mutable and functions can
have side effects. But this is generally how
functional code would be written assuming immutability.
*/

var HashTable = {
  new: function(name){
    return {table: {}, name: name}
  },
  get: function(state, key){
    return state.table[key];
  },
  set: function(state, key, value){
    state.table[key] = value;
    return state
  }
}

var table = HashTable.new("my table");
table = HashTable.set(table, "foo", "bar");
console.log(HashTable.get(table, "foo"));

/*
Instead of using a `this` keyword, object state
is stored externally and we use our `HashTable`
object to update it. In each function we make a change
to the state and return the new state at the end.

Functional programming is great because saving and loading
state of objects is dead simple. In this case we can just do
JSON.stringify(table) and save the resulting string to a file
or send it over HTTP. Then JSON.parse(table) to load it.
You can't do this as easily with class based code.
*/