Comment créer un dictionnaire et ajouter dynamiquement des paires clé-valeur?

De la poste:

Envoi d'un tableau JSON à recevoir en tant que dictionnaire <chaîne, chaîne>

J'essaie de faire la même chose que ce post. Le seul problème est que je ne sais pas quelles sont les clés et les valeurs initiales. J'ai donc besoin de pouvoir ajouter dynamiquement les paires clé / valeur et je ne sais pas comment faire.

Quelqu'un sait-il comment créer cet objet et ajouter dynamiquement des paires valeur / clé?

J'ai essayé:

var vars = [{key:"key", value:"value"}];
vars[0].key = "newkey";
vars[0].value = "newvalue";

Mais ça ne marche pas.

var dict = []; // create an empty array

dict.push({
    key:   "keyName",
    value: "the value"
});
// repeat this last part as needed to add more key/value pairs

Fondamentalement, vous créez un littéral d'objet avec 2 propriétés (appelées keyet value) et vous l'insérez (en utilisant push()) dans le tableau.

Edit: Donc, près de 5 ans plus tard, cette réponse obtient des votes négatifs car elle ne crée pas un littéral d'objet JS "normal" (alias carte, alias hachage, alias dictionnaire).
Il est cependant de créer la structure qui a demandé OP (et qui est illustrée dans l'autre question liée à), qui est un tableau de littéraux d'objets , chacun avec keyet valuepropriétés. Ne me demandez pas pourquoi cette structure était nécessaire, mais c'est celle qui a été demandée.

Mais, mais, si ce que vous voulez dans un objet JS simple - et non la structure demandée par OP - voir la réponse de tcll , bien que la notation entre crochets soit un peu lourde si vous n'avez que des clés simples qui sont des noms JS valides. Vous pouvez simplement faire ceci:

// object literal with properties
var dict = {
  key1: "value1",
  key2: "value2"
  // etc.
};

Ou utilisez la notation par points régulière pour définir les propriétés après avoir créé un objet:

// empty object literal with properties added afterward
var dict = {};
dict.key1 = "value1";
dict.key2 = "value2";
// etc.

Vous ne voulez que la notation de support si vous avez des clés qui ont des espaces en eux, des caractères spéciaux, ou des choses comme ça. Par exemple:

var dict = {};

// this obviously won't work
dict.some invalid key (for multiple reasons) = "value1";

// but this will
dict["some invalid key (for multiple reasons)"] = "value1";

Vous souhaitez également la notation des parenthèses si vos clés sont dynamiques:

dict[firstName + " " + lastName] = "some value";

Notez que les clés (noms de propriété) sont toujours des chaînes et que les valeurs non-chaîne seront contraintes à une chaîne lorsqu'elles seront utilisées comme clé. Par exemple, un Dateobjet est converti en sa représentation sous forme de chaîne:

dict[new Date] = "today's value";

console.log(dict);
// => {
//      "Sat Nov 04 2016 16:15:31 GMT-0700 (PDT)": "today's value"
//    }

Notez cependant que cela ne fonctionne pas nécessairement "simplement", car de nombreux objets auront une représentation sous forme de chaîne comme celle "[object Object]"qui ne donne pas une clé non unique. Méfiez-vous donc de quelque chose comme:

var objA = { a: 23 },
    objB = { b: 42 };

dict[objA] = "value for objA";
dict[objB] = "value for objB";

console.log(dict);
// => { "[object Object]": "value for objB" }

En dépit objAet objBétant des éléments complètement différents et uniques, ils ont tous deux la même représentation de chaîne de base: "[object Object]".

La raison Datene se comporte pas comme ceci est que le Dateprototype a une toStringméthode personnalisée qui remplace la représentation de chaîne par défaut. Et vous pouvez faire de même:

// a simple constructor with a toString prototypal method
function Foo() {
  this.myRandomNumber = Math.random() * 1000 | 0;
}

Foo.prototype.toString = function () {
  return "Foo instance #" + this.myRandomNumber;
};

dict[new Foo] = "some value";

console.log(dict);
// => {
//      "Foo instance #712": "some value"
//    }

(Notez que comme ce qui précède utilise un nombre aléatoire , les collisions de noms peuvent toujours se produire très facilement. C'est juste pour illustrer une implémentation detoString .)

Ainsi, lorsque vous essayez d'utiliser des objets comme clés, JS utilise la propre toStringimplémentation de l'objet , le cas échéant, ou utilise la représentation de chaîne par défaut.

var dict = {};

dict['key'] = "testing";

console.log(dict);

fonctionne comme python :)

sortie console:

Object {key: "testing"} 

C'est aussi simple que:

var blah = {}; // make a new dictionary (empty)

ou

var blah = {key: value, key2: value2}; // make a new dictionary with two pairs 

puis

blah.key3 = value3; // add a new key/value pair
blah.key2; // returns value2
blah['key2']; // also returns value2

Puisque vous avez déclaré que vous vouliez un objet dictionnaire (et non un tableau comme je suppose que certains l'ont compris), je pense que c'est ce que vous recherchez:

var input = [{key:"key1", value:"value1"},{key:"key2", value:"value2"}];

var result = {};

for(var i = 0; i < input.length; i++)
{
    result[input[i].key] = input[i].value;
}

console.log(result); // Just for testing

JavaScript Object est en soi comme un dictionnaire. Pas besoin de réinventer la roue.

var dict = {};

// Adding key-value -pairs
dict['key'] = 'value'; // Through indexer
dict.anotherKey = 'anotherValue'; // Through assignment

// Looping through
for (var item in dict) {
  console.log('key:' + item + ' value:' + dict[item]);
  // Output
  // key:key value:value
  // key:anotherKey value:anotherValue
}

// Non existent key
console.log(dict.notExist); // undefined

// Contains key?
if (dict.hasOwnProperty('key')) {
  // Remove item
  delete dict.key;
}

// Looping through
for (var item in dict) {
  console.log('key:' + item + ' value:' + dict[item]);
  // Output
  // key:anotherKey value:anotherValue
}

Violon

Vous pouvez utiliser des cartes avec Map, comme ceci:

var sayings = new Map();
sayings.set('dog', 'woof');
sayings.set('cat', 'meow');

Je suis tombé sur cette question à la recherche de quelque chose de similaire. Cela m'a donné suffisamment d'informations pour effectuer un test afin d'obtenir la réponse que je voulais. Donc, si quelqu'un d'autre veut savoir comment ajouter ou rechercher dynamiquement une paire {key: 'value'} dans un objet JavaScript, ce test devrait vous dire tout ce que vous pourriez avoir besoin de savoir.

var dictionary = {initialkey: 'initialValue'};
var key = 'something';
var key2 =  'somethingElse';
var value = 'value1';
var value2 = 'value2';
var keyInitial = 'initialkey';

console.log(dictionary[keyInitial]);

dictionary[key] =value;
dictionary[key2] = value2;
console.log(dictionary);

production

initialValue
{ initialkey: 'initialValue',
  something: 'value1',
  somethingElse: 'value2' }

var dictionary = {};//create new object
dictionary["key1"] = value1;//set key1
var key1 = dictionary["key1"];//get key1

Vous pouvez créer un dictionnaire de classe pour pouvoir interagir facilement avec la liste des dictionnaires:

class Dictionary {
  constructor() {
    this.items = {};
  }
  has(key) {
    return key in this.items;
  }
  set(key,value) {
    this.items[key] = value;
  }
  delete(key) {
    if( this.has(key) ){
      delete this.items[key]
      return true;
    }
    return false;
  }
}

var d = new Dictionary();
d.set(1, "value1")
d.set(2, "value2")
d.set(3, "value3")
console.log(d.has(2));
d.delete(2);
console.log(d.has(2));

que diriez-vous du liner pour créer une paire de valeurs clés?

let result = { ["foo"]: "some value" };

et une fonction d'itérateur comme reduceconvertir dynamiquement un tableau en dictionnaire

var options = [
  { key: "foo", value: 1 },
  { key: "bar", value: {id: 2, name: "two"} },
  { key: "baz", value: {["active"]: true} },
];

var result = options.reduce((accumulator, current) => {
  accumulator[current.key] = current.value;
  return accumulator;
}, {});

console.log(result);

Dans le javascript moderne (ES6 / ES2015), il faut utiliser la structure de données Map pour le dictionnaire. La structure des données de carte dans ES6 vous permet d'utiliser des valeurs arbitraires comme clés.

const map = new Map();
map.set("true", 1);
map.set("false", 0);

Si vous utilisez toujours ES5, la façon correcte de créer un dictionnaire consiste à créer un objet sans prototype de la manière suivante.

var map = Object.create(null);
map["true"]= 1;
map["false"]= 0;

Il existe de nombreux avantages à créer un dictionnaire sans objet prototype. Les blogs ci-dessous méritent d'être lus sur ce sujet.

dict-pattern

objets en tant que cartes

Cela aiderait une tonne de savoir quel est votre résultat final souhaité, mais je pense que c'est ce que vous voulez:

var vars = [{key:"key", value:"value"}];

vars.push({key: "newkey", value: "newvalue"})

J'ai rencontré ce problème .. mais dans une boucle for. La solution supérieure ne fonctionnait pas (lors de l'utilisation de variables (et non de chaînes) pour les paramètres de la fonction push), et les autres ne tenaient pas compte des valeurs clés basées sur des variables. J'ai été surpris que cette approche (qui est courante en php) fonctionne ..

  // example dict/json                  
  var iterateDict = {'record_identifier': {'content':'Some content','title':'Title of my Record'},
    'record_identifier_2': {'content':'Some  different content','title':'Title of my another Record'} };

  var array = [];

  // key to reduce the 'record' to
  var reduceKey = 'title';

  for(key in iterateDict)
   // ultra-safe variable checking...
   if(iterateDict[key] !== undefined && iterateDict[key][reduceKey] !== undefined)
    // build element to new array key
     array[key]=iterateDict[key][reduceKey];

Une amélioration var dict = {}consiste à utiliservar dict = Object.create(null) .

Cela va créer un objet vide qui ne pas avoir Object.prototypecomme prototype de lui.

var dict1 = {};
if (dict1["toString"]){
    console.log("Hey, I didn't put that there!")
}
var dict2 = Object.create(null);
if (dict2["toString"]){
    console.log("This line won't run :)")
}

Première initialisation d'un tableau à l'échelle mondiale

var dict = []

Ajouter un objet dans le dictionnaire

dict.push(
     { key: "One",value: false},
     { key: "Two",value: false},
     { key: "Three",value: false});

Output : 
   [0: {key: "One", value: false}
    1: {key: "Two", value: false}
    2: {key: "Three", value: false}]

Mettre à jour l'objet à partir du dictionnaire

Object.keys(dict).map((index) => {        
  if (index == 1){
    dict[index].value = true
  }
});

Output : 
   [0: {key: "One", value: false},
    1: {key: "Two", value: true},
    2: {key: "Three", value: false}]

Supprimer un objet du dictionnaire

Object.keys(dict).map((index) => {              
      if (index == 2){
        dict.splice(index)
      }
    });

Output : 
    [0: {key: "One", value: false},
     1: {key: "Two", value: true}]