Comment créer le dictionnaire et ajouter des paires clé–valeur dynamiquement?

var dict = {};

dict['key'] = "testing";

console.log(dict);

fonctionne comme python:)

sortie de la 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 voulez un objet de dictionnaire (et pas un tableau comme je suppose que certains ont compris) je pense que c'est ce que vous êtes après:

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

il se trouve que j'ai marché à travers cette question à la recherche de quelque chose de similaire. Ça m'a donné assez d'infos pour faire un test pour avoir la réponse que je voulais. Donc, si quelqu'un d'autre veut savoir comment ajouter dynamiquement ou rechercher 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);

sortie

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 utiliser des cartes avec Map , comme ceci:

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

vous pouvez créer un dictionnaire de classe de sorte que vous pouvez interagir avec la liste de dictionnaire facilement:

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));

j'ai rencontré ce problème.. mais à l'intérieur d'une boucle for. La solution top ne fonctionnait pas (lorsqu'on utilisait des variables (et non des chaînes) pour les paramètres de la fonction push), et les autres ne tenaient pas compte des valeurs clés basées sur les variables. J'ai été surpris que cette approche (qui est commune dans php) ait fonctionné..

  // 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];

qu'en est-il de la doublure unique pour créer une paire de valeurs clés?

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

et une fonction d'itérateur comme reduce pour convertir dynamiquement un tableau en un 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);

ça aiderait une tonne de savoir quel est votre résultat final désiré, mais je pense que c'est ce que vous voulez:

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

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

une amélioration par rapport à var dict = {} est d'utiliser var dict = Object.create(null) .

cela créera un objet vide qui ne pas ont Object.prototype comme prototype.

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 :)")
}