Cómo crear un diccionario y agregar pares de valores clave dinámicamente en JavaScript

De la publicación:

Envío de una matriz JSON para que se reciba como Dictionary,

Estoy tratando de hacer lo mismo que esa publicación. El único problema es que no sé cuáles son las claves y los valores por adelantado. Entonces, necesito poder agregar dinámicamente los pares de clave y valor y no sé cómo hacerlo.

¿Cómo puedo crear ese objeto y agregar pares de valores clave dinámicamente?

He intentado:

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

Pero eso no funciona.

Usar:

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

Básicamente, estás creando un objeto literal con dos propiedades (llamadas key y value) e insertarlo (usando push()) en la matriz.

Esto no crea un literal de objeto JavaScript “normal” (también conocido como mapa, también conocido como hash, también conocido como diccionario). Él es sin embargo, crear la estructura que solicitó OP (y que se ilustra en la otra pregunta vinculada), que es una matriz de objetos literalescada uno con key y value propiedades. No me pregunten por qué se requería esa estructura, pero es la que se pidió.

Pero, pero, si lo que desea en un objeto JavaScript simple, y no la estructura que OP solicitó: consulte la respuesta de tcll, aunque la notación entre paréntesis es un poco engorrosa si solo tiene claves simples que son nombres de JavaScript válidos. Puedes hacer esto:

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

O use la notación de puntos regular para establecer propiedades después de crear un objeto:

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

Tú hacer desea la notación de corchetes si tiene teclas que tienen espacios, caracteres especiales o cosas por el estilo. P.ej:

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

También desea la notación de corchetes si sus claves son dinámicas:

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

Tenga en cuenta que las claves (nombres de propiedad) son siempre cadenas, y los valores que no son cadenas se coaccionarán a una cadena cuando se usen como clave. por ejemplo, un Date el objeto se convierte a su representación de cadena:

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

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

Sin embargo, tenga en cuenta que esto no necesariamente “simplemente funciona”, ya que muchos objetos tendrán una representación de cadena como "[object Object]" lo que no hace para una clave no única. Así que ten cuidado con algo como:

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

A pesar de objA y objB siendo elementos completamente diferentes y únicos, ambos tienen la misma representación de cadena básica: "[object Object]".

La razón Date no se comporta así es que el Date prototipo tiene una costumbre toString método que anula la representación de cadena predeterminada. Y tu puedes hacer lo mismo:

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

(Tenga en cuenta que dado que lo anterior utiliza un aleatorio número, las colisiones de nombre aún pueden ocurrir muy fácilmente. Es solo para ilustrar una implementación de toString.)

Entonces, cuando intente usar objetos como claves, JavaScript usará el propio objeto toString implementación, si la hay, o utilice la representación de cadena predeterminada.

Usar:

var dict = {};

dict['key'] = "testing";

console.log(dict);

Funciona igual que Python 🙂

Salida de la consola:

Object {key: "testing"}

Es tan simple como:

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

o

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

Entonces

blah.key3 = value3; // Add a new key/value pair
blah.key2; // Returns value2
blah['key2']; // Also returns value2

Dado que ha declarado que desea un objeto de diccionario (y no una matriz como supongo que algunos entendieron) Creo que esto es lo que buscas:

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 es en sí mismo como un diccionario. No hay necesidad de reinventar la rueda.

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
}

Violín

Puedes usar mapas con Mapcomo esto:

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

Con ES6Puedes hacerlo:

let cake="🍰";

let pan = {
  [cake]: '🥞',
};

// Output -> { '🍰': '🥞' }

Vieja forma (vainilla JavaScript)

let cake="🍰";
let pan = {};
pan[cake] = '🥞';

// Output -> { '🍰': '🥞' }