JavaScript dictionnaire avec des noms

Question

Je veux créer un dictionnaire en javascript comme suit:

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

Je veux remplir un tableau html plus tard et que vous voulez définir les titres de la table à la première colonne de myMappings et la largeur des colonnes à la seconde. Comme je suis nouveau sur le JS, avoir de la difficulté à trouver le moyen propre. Certains pls proposer?

Merci

Answer 1

Une autre approche serait d'avoir un tableau d'objets, chaque objet holding les propriétés d'une colonne. Cela modifie légèrement la structure de "myMappings", mais il est facile de travailler avec:

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

Ensuite, vous pouvez facilement parcourir toutes les "colonnes" avec une boucle for:

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

Answer 2

Le principal problème que je vois avec ce que vous avez, c'est qu'il est difficile de faire une boucle par, pour le remplissage d'une table.

Simplement utiliser un tableau de tableaux:

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

... ce qui simplifie l'accès:

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

---

Sinon:

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

Et l'accès à:

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

Answer 3

Êtes-vous essayer d'utiliser un objet JSON?

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

Pour y accéder:

myMappings.name;
myMappings.phone;
etc..

Answer 4

Essayez:

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

Voici un joli Hastable mise en œuvre en JS. http://www.mojavelinux.com/articles/javascript_hashes.html

C'états de l'approche: "En JavaScript, tous les non-scalaire objets se comportent comme des tableaux associatifs, une cartographie de la propriété des clés à des valeurs. Les clés et les valeurs peuvent être des scalaires, des objets ou des fonctions."

Ce lien est partagé dans d'autres articles qui pourront vous aider. Comme celui là.

Edit>>

Ont créé un simple dictionnaire en JS ici:

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";
        }
    }
}

Ci-dessus la mise en œuvre peut maintenant être utilisé pour simuler un dictionnaire comme:

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!"

C'est juste une simulation de base. Il peut être optimisée par la mise en œuvre d'un meilleur temps d'exécution de l'algorithme de travailler dans au moins O(nlogn) le temps de la complexité, voire moins. Comme de fusion/tri rapide sur les tableaux et puis certains B-recherche pour les recherches. Je N'ai pas essayer une recherche sur le mappage d'une fonction de hachage en JS.

Aussi, une Clé et une Valeur pour la JSdict obj peut être transformées en variables privées à être sournois.

Espérons que cette aide!

Edit>> Bonne nouvelle, ici, est maintenant plus facile, natif et plus efficace de l'émulation d'un dict en JS: Aussi exploiter que le JS est faiblement typé. Plutôt que l'inférence de type. De toute façon..

Voici comment (un extrait de Google Chrome de la 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