Come creare un dizionario e aggiungere dinamicamente coppie chiave-valore?

Dalla posta:

Invio di un array JSON da ricevere come dizionario <stringa, stringa>

Sto cercando di fare la stessa cosa di quel post. L'unico problema è che non so quali siano le chiavi e i valori in anticipo. Quindi devo essere in grado di aggiungere dinamicamente le coppie chiave e valore e non so come farlo.

Qualcuno sa come creare quell'oggetto e aggiungere dinamicamente coppie di valori-chiave?

Ho provato:

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

Ma questo non funziona.

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

Fondamentalmente, stai creando un oggetto letterale con 2 proprietà (chiamato keye value) e inserendolo (usando push()) nell'array.

Modifica: Quindi quasi 5 anni dopo, questa risposta sta ricevendo voti negativi perché non sta creando un oggetto JS "normale" letterale (aka mappa, aka hash, aka dizionario).
Si è tuttavia creando la struttura che OP chiesto (e che è illustrata in altra questione legata a), che è una matrice di letterali oggetto , ognuno con keye valueproprietà. Non chiedermi perché era richiesta quella struttura, ma è quella che è stata chiesta.

Ma, tuttavia, se quello che vuoi in un semplice oggetto JS - e non la struttura richiesta da OP - vedi la risposta di tcll , sebbene la notazione tra parentesi sia un po 'ingombrante se hai solo chiavi semplici che sono nomi JS validi. Puoi fare solo questo:

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

Oppure usa la notazione regolare per impostare le proprietà dopo aver creato un oggetto:

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

È cosa vuole la notazione staffa se hai le chiavi che hanno spazi tra loro, caratteri speciali, o cose del genere. Per esempio:

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

Vuoi anche la notazione tra parentesi se le tue chiavi sono dinamiche:

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

Si noti che le chiavi (nomi delle proprietà) sono sempre stringhe e che i valori non stringa verranno convertiti in una stringa quando utilizzati come chiave. Ad esempio un Dateoggetto viene convertito nella sua rappresentazione di stringa:

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

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

Si noti tuttavia che ciò non "funziona", poiché molti oggetti avranno una rappresentazione in forma di stringa "[object Object]"che non costituisce una chiave non univoca. Quindi diffidare di qualcosa come:

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

Nonostante objAe objBessendo elementi completamente diversi e unici, entrambi hanno la stessa rappresentazione di base stringa: "[object Object]".

La ragione per cui Datenon si comporta in questo modo è che il Dateprototipo ha un'abitudinetoString metodo che sovrascrive la rappresentazione di stringa predefinita. E puoi fare lo stesso:

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

(Si noti che poiché quanto sopra utilizza un numero casuale , le collisioni di nomi possono comunque verificarsi molto facilmente. È solo per illustrare un'implementazione di toString.)

Pertanto, quando si tenta di utilizzare gli oggetti come chiavi, JS utilizzerà l' toStringimplementazione dell'oggetto stesso , se presente, o utilizzerà la rappresentazione di stringa predefinita.

var dict = {};

dict['key'] = "testing";

console.log(dict);

funziona proprio come Python :)

uscita console:

Object {key: "testing"} 

È semplice come:

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

o

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

poi

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

Dal momento che hai affermato che vuoi un oggetto dizionario (e non una matrice come suppongo che alcuni abbiano capito), penso che questo sia ciò che stai cercando:

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 è di per sé come un dizionario. Non c'è bisogno di reinventare la ruota.

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
}

Violino

Puoi usare le mappe con Map, in questo modo:

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

Mi è capitato di passare attraverso questa domanda alla ricerca di qualcosa di simile. Mi ha dato informazioni sufficienti per eseguire un test per ottenere la risposta che volevo. Quindi, se qualcun altro vuole sapere come aggiungere o cercare dinamicamente una coppia {chiave: 'valore'} in un oggetto JavaScript, questo test dovrebbe dirti tutto ciò che potresti aver bisogno di sapere.

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

produzione

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

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

È possibile creare un dizionario di classe in modo da poter interagire facilmente con l'elenco dei dizionari:

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

che ne dite dell'unico liner per la creazione di una coppia chiave-valore?

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

e alcune funzioni dell'iteratore gradiscono reduceconvertire dinamicamente un array in un dizionario

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

Nel javascript moderno (ES6 / ES2015), si dovrebbe usare la struttura dei dati della mappa per il dizionario. La struttura dei dati della mappa in ES6 consente di utilizzare valori arbitrari come chiavi.

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

Se stai ancora utilizzando ES5, il modo corretto di creare un dizionario è quello di creare un oggetto senza prototipo nel modo seguente.

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

Ci sono molti vantaggi nella creazione di un dizionario senza un oggetto prototipo. Di seguito vale la pena leggere i blog su questo argomento.

dict-pattern

oggetti-as-mappe

Aiuterebbe molto a sapere qual è il risultato finale desiderato, ma penso che questo sia quello che vuoi:

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

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

Ho riscontrato questo problema ... ma all'interno di un ciclo for. La soluzione principale non ha funzionato (quando si utilizzano le variabili (e non le stringhe) per i parametri della funzione push), e le altre non hanno tenuto conto dei valori chiave basati sulle variabili. Sono stato sorpreso che questo approccio (che è comune in php) ha funzionato ..

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

Un miglioramento var dict = {}è da usarevar dict = Object.create(null) .

Questo creerà un oggetto vuoto che non ha Object.prototypecome prototipo.

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

Prima inizializzazione di array a livello globale

var dict = []

Aggiungi oggetto nel dizionario

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}]

Aggiorna oggetto dal dizionario

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}]

Elimina oggetto dal dizionario

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

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