JavaScript dictionary with names

Question

I want to create a dictionary in javascript as follows:

myMappings = [ { "Name":10%}, { "Phone":10%}, { "Address":50%}, { "Zip":10%}, { "Comments":20%} ] 

I want to populate the html table later and want to set the table headers to the first column of myMappings and the width of the columns to the second. Since I am new to JS, I am having trouble finding a clean path. Can anyone suggest any pls?

thank

Answer 1

The main problem that I see with what you have is that it is difficult to complete in order to populate the table.

Just use an array of arrays:

 var myMappings = [ ["Name", "10%"], // Note the quotes around "10%" ["Phone", "10%"], // etc.. ]; 

... which simplifies access:

 myMappings[0][0]; // column name myMappings[0][1]; // column width 

---

As an alternative:

 var myMappings = { names: ["Name", "Phone", etc...], widths: ["10%", "10%", etc...] }; 

And access using:

 myMappings.names[0]; myMappings.widths[0]; 

Answer 2

Another approach would be to have an array of objects, with each individual object having column properties. This slightly changes the structure of "myMappings", but simplifies working with:

 var myMappings = [ { title: "Name", width: "10%" }, { title: "Phone", width: "10%" }, { title: "Address", width: "50%" }, { title: "Zip", width: "10%" }, { title: "Comments", width: "20%" } ]; 

Then you can easily iterate over all your "columns" using the for loop:

 for (var i = 0; i < myMappings.length; i += 1) { // myMappings[i].title ... // myMappings[i].width ... } 

Answer 3

Are you trying to use a JSON object?

 var myMappings = { "name": "10%", "phone": "10%", "address": "50%", etc.. } 

To access:

 myMappings.name; myMappings.phone; etc.. 

Answer 4

Try:

 var myMappings = {"Name":"10%", "Phone":"10%", "Address":"50%", "Zip":"10%", "Comments":"20%"} //access like this myMappings["Name"] //returns "10%" myMappings.Name //same thing as above //to loop through... for(var title in myMappings){ //do whatever with myMappings[title] } 

Answer 5

The object is technically an adictionary.

 var myMappings = { mykey1: 'myValue', mykey2: 'myValue' }; var myVal = myMappings['myKey1']; alert(myVal); // myValue 

You can even skip it.

 for(var key in myMappings) { var myVal = myMappings[key]; alert(myVal); } 

There is no reason to ever reinvent the wheel. And, of course, the purpose is as follows:

 myMappings['mykey3'] = 'my value'; 

And ContainsKey:

 if (myMappings.hasOwnProperty('myKey3')) { alert('key already exists!'); } 

I suggest you follow this http://javascriptissexy.com/how-to-learn-javascript-properly/

Answer 6

Here is a neat implementation of Hastable in JS. http://www.mojavelinux.com/articles/javascript_hashes.html

He argues that the approach: “In JavaScript, all non-scalar objects behave as associative arrays, mapping from property keys to values. Keys and values ​​can be scalars, objects, or functions.”

This link is also available in other related articles that may help. Like here .

Edit →

Created a simple dictionary in JS here:

 function JSdict() { this.Keys = []; this.Values = []; } // Check if dictionary extensions aren't implemented yet. // Returns value of a key if (!JSdict.prototype.getVal) { JSdict.prototype.getVal = function (key) { if (key == null) { return "Key cannot be null"; } for (var i = 0; i < this.Keys.length; i++) { if (this.Keys[i] == key) { return this.Values[i]; } } return "Key not found!"; } } // Check if dictionary extensions aren't implemented yet. // Updates value of a key if (!JSdict.prototype.update) { JSdict.prototype.update = function (key, val) { if (key == null || val == null) { return "Key or Value cannot be null"; } // Verify dict integrity before each operation if (keysLength != valsLength) { return "Dictionary inconsistent. Keys length don't match values!"; } var keysLength = this.Keys.length; var valsLength = this.Values.length; var flag = false; for (var i = 0; i < keysLength; i++) { if (this.Keys[i] == key) { this.Values[i] = val; flag = true; break; } } if (!flag) { return "Key does not exist"; } } } // Check if dictionary extensions aren't implemented yet. // Adds a unique key value pair if (!JSdict.prototype.add) { JSdict.prototype.add = function (key, val) { // Allow only strings or numbers as keys if (typeof (key) == "number" || typeof (key) == "string") { if (key == null || val == null) { return "Key or Value cannot be null"; } if (keysLength != valsLength) { return "Dictionary inconsistent. Keys length don't match values!"; } var keysLength = this.Keys.length; var valsLength = this.Values.length; for (var i = 0; i < keysLength; i++) { if (this.Keys[i] == key) { return "Duplicate keys not allowed!"; } } this.Keys.push(key); this.Values.push(val); } else { return "Only number or string can be key!"; } } } // Check if dictionary extensions aren't implemented yet. // Removes a key value pair if (!JSdict.prototype.remove) { JSdict.prototype.remove = function (key) { if (key == null) { return "Key cannot be null"; } if (keysLength != valsLength) { return "Dictionary inconsistent. Keys length don't match values!"; } var keysLength = this.Keys.length; var valsLength = this.Values.length; var flag = false; for (var i = 0; i < keysLength; i++) { if (this.Keys[i] == key) { this.Keys.shift(key); this.Values.shift(this.Values[i]); flag = true; break; } } if (!flag) { return "Key does not exist"; } } } 

The above implementation can now be used to simulate a dictionary like:

 var dict = new JSdict(); dict.add(1, "one") dict.add(1, "one more") "Duplicate keys not allowed!" dict.getVal(1) "one" dict.update(1, "onne") dict.getVal(1) "onne" dict.remove(1) dict.getVal(1) "Key not found!" 

This is just basic modeling. It can be further optimized by implementing a more efficient runtime algorithm for working at least in O (nlogn) time complexity or even less. Like merge / quick sort on arrays, and then some B-lookup to search. I have not tried or searched for the mapping of the hash function in JS.

In addition, the key and value for the JSdict obj object can be turned into private variables to be mean.

Hope this helps!

Edit → Good news, now it's a simpler, native and more efficient way to emulate a dict in JS: Also use that JS is weakly typed. Rather, enter the output. Anyway..

Here's how (excerpt from the Google Chrome console):

 var myDict = {}; myDict.one = 1; 1 myDict.two = 2; 2 if (myDict.hasOwnProperty('three')) { console.log(myDict.two); } else { console.log('Key does not exist!'); } Key does not exist! VM361:8 if (myDict.hasOwnProperty('two')) { console.log(myDict.two); } else { console.log('Key does not exist!'); } 2 VM362:4 Object.keys(myDict); ["one", "two"] delete(myDict.two); true myDict.hasOwnProperty('two'); false myDict.two undefined myDict.one 1 

Answer 7

I suggest not using an array if you have several objects to consider. There is nothing wrong with this statement.

 var myMappings = { "Name":0.1, "Phone":0.1, "Address":0.5, "Zip":0.1, "Comments":0.2 }; for (var col in myMappings) { alert((myMappings[col] * 100) + "%"); } 

Answer 8

Here is a dictionary that will use any type of key, while the toString () property returns unique values. The dictionary uses something as a value for a pair of key values.

See http://www.codeproject.com/Articles/684815/Would-JavaScript-Benefit-from-a-Dictionary-Object

To use the dictionary as is:

 var dictFact = new Dict(); var myDict = dictFact.New(); myDict.addOrUpdate("key1", "Value1"); myDict.addOrUpdate("key2", "Value2"); myDict.addOrUpdate("keyN", "ValueN"); 

Dictionary code below:

 /* * Dictionary Factory Object * Holds common object functions. similar to V-Table * this.New() used to create new dictionary objects * Uses Object.defineProperties so won't work on older browsers. * Browser Compatibility (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties) * Firefox (Gecko) 4.0 (2), Chrome 5, IE 9, Opera 11.60, Safari 5 */ function Dict() { /* * Create a new Dictionary */ this.New = function () { return new dict(); }; /* * Return argument f if it is a function otherwise return undefined */ function ensureF(f) { if (isFunct(f)) { return f; } } function isFunct(f) { return (typeof f == "function"); } /* * Add a "_" as first character just to be sure valid property name */ function makeKey(k) { return "_" + k; }; /* * Key Value Pair object - held in array */ function newkvp(key, value) { return { key: key, value: value, toString: function () { return this.key; }, valueOf: function () { return this.key; } }; }; /* * Return the current set of keys. */ function keys(a) { // remove the leading "-" character from the keys return a.map(function (e) { return e.key.substr(1); }); // Alternative: Requires Opera 12 vs. 11.60 // -- Must pass the internal object instead of the array // -- Still need to remove the leading "-" to return user key values // Object.keys(o).map(function (e) { return e.key.substr(1); }); }; /* * Return the current set of values. */ function values(a) { return a.map(function(e) { return e.value; } ); }; /* * Return the current set of key value pairs. */ function kvPs(a) { // remove the leading "-" character from the keys return a.map(function (e) { return newkvp(e.key.substr(1), e.value); }); } /* * Returns true if key exists in the dictionary. * k - Key to check (with the leading "_" character) */ function exists(k, o) { return o.hasOwnProperty(k); } /* * Array Map implementation */ function map(a, f) { if (!isFunct(f)) { return; } return a.map(function (e, i) { return f(e.value, i); }); } /* * Array Every implementation */ function every(a, f) { if (!isFunct(f)) { return; } return a.every(function (e, i) { return f(e.value, i) }); } /* * Returns subset of "values" where function "f" returns true for the "value" */ function filter(a, f) { if (!isFunct(f)) {return; } var ret = a.filter(function (e, i) { return f(e.value, i); }); // if anything returned by array.filter, then get the "values" from the key value pairs if (ret && ret.length > 0) { ret = values(ret); } return ret; } /* * Array Reverse implementation */ function reverse(a, o) { a.reverse(); reindex(a, o, 0); } /** * Randomize array element order in-place. * Using Fisher-Yates shuffle algorithm. */ function shuffle(a, o) { var j, t; for (var i = a.length - 1; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); t = a[i]; a[i] = a[j]; a[j] = t; } reindex(a, o, 0); return a; } /* * Array Some implementation */ function some(a, f) { if (!isFunct(f)) { return; } return a.some(function (e, i) { return f(e.value, i) }); } /* * Sort the dictionary. Sorts the array and reindexes the object. * a - dictionary array * o - dictionary object * sf - dictionary default sort function (can be undefined) * f - sort method sort function argument (can be undefined) */ function sort(a, o, sf, f) { var sf1 = f || sf; // sort function method used if not undefined // if there is a customer sort function, use it if (isFunct(sf1)) { a.sort(function (e1, e2) { return sf1(e1.value, e2.value); }); } else { // sort by key values a.sort(); } // reindex - adds O(n) to perf reindex(a, o, 0); // return sorted values (not entire array) // adds O(n) to perf return values(a); }; /* * forEach iteration of "values" * uses "for" loop to allow exiting iteration when function returns true */ function forEach(a, f) { if (!isFunct(f)) { return; } // use for loop to allow exiting early and not iterating all items for(var i = 0; i < a.length; i++) { if (f(a[i].value, i)) { break; } } }; /* * forEachR iteration of "values" in reverse order * uses "for" loop to allow exiting iteration when function returns true */ function forEachR(a, f) { if (!isFunct(f)) { return; } // use for loop to allow exiting early and not iterating all items for (var i = a.length - 1; i > -1; i--) { if (f(a[i].value, i)) { break; } } } /* * Add a new Key Value Pair, or update the value of an existing key value pair */ function add(key, value, a, o, resort, sf) { var k = makeKey(key); // Update value if key exists if (exists(k, o)) { a[o[k]].value = value; } else { // Add a new Key value Pair var kvp = newkvp(k, value); o[kvp.key] = a.length; a.push(kvp); } // resort if requested if (resort) { sort(a, o, sf); } }; /* * Removes an existing key value pair and returns the "value" If the key does not exists, returns undefined */ function remove(key, a, o) { var k = makeKey(key); // return undefined if the key does not exist if (!exists(k, o)) { return; } // get the array index var i = o[k]; // get the key value pair var ret = a[i]; // remove the array element a.splice(i, 1); // remove the object property delete o[k]; // reindex the object properties from the remove element to end of the array reindex(a, o, i); // return the removed value return ret.value; }; /* * Returns true if key exists in the dictionary. * k - Key to check (without the leading "_" character) */ function keyExists(k, o) { return exists(makeKey(k), o); }; /* * Returns value assocated with "key". Returns undefined if key not found */ function item(key, a, o) { var k = makeKey(key); if (exists(k, o)) { return a[o[k]].value; } } /* * changes index values held by object properties to match the array index location * Called after sorting or removing */ function reindex(a, o, i){ for (var j = i; j < a.length; j++) { o[a[j].key] = j; } } /* * The "real dictionary" */ function dict() { var _a = []; var _o = {}; var _sortF; Object.defineProperties(this, { "length": { get: function () { return _a.length; }, enumerable: true }, "keys": { get: function() { return keys(_a); }, enumerable: true }, "values": { get: function() { return values(_a); }, enumerable: true }, "keyValuePairs": { get: function() { return kvPs(_a); }, enumerable: true}, "sortFunction": { get: function() { return _sortF; }, set: function(funct) { _sortF = ensureF(funct); }, enumerable: true } }); // Array Methods - Only modification to not pass the actual array to the callback function this.map = function(funct) { return map(_a, funct); }; this.every = function(funct) { return every(_a, funct); }; this.filter = function(funct) { return filter(_a, funct); }; this.reverse = function() { reverse(_a, _o); }; this.shuffle = function () { return shuffle(_a, _o); }; this.some = function(funct) { return some(_a, funct); }; this.sort = function(funct) { return sort(_a, _o, _sortF, funct); }; // Array Methods - Modified aborts when funct returns true. this.forEach = function (funct) { forEach(_a, funct) }; // forEach in reverse order this.forEachRev = function (funct) { forEachR(_a, funct) }; // Dictionary Methods this.addOrUpdate = function(key, value, resort) { return add(key, value, _a, _o, resort, _sortF); }; this.remove = function(key) { return remove(key, _a, _o); }; this.exists = function(key) { return keyExists(key, _o); }; this.item = function(key) { return item(key, _a, _o); }; this.get = function (index) { if (index > -1 && index < _a.length) { return _a[index].value; } } , this.clear = function() { _a = []; _o = {}; }; return this; } return this; }