javascript - recorrer - lista de diccionarios python

¿Cómo crear un diccionario y agregar dinámicamente pares clave-valor?

Question

Desde la publicación:

Enviar una matriz JSON para que se reciba como diccionario <cadena, cadena>

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

¿Alguien sabe cómo crear ese objeto y agregar dinámicamente pares de valores clave?

He intentado:

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

Pero eso no funciona.

Answer 1

¿qué tal el trazador de líneas para crear un par de valores clave?

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

y alguna función de iterador como reduce para convertir dinámicamente una matriz a un diccionario

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

Answer 2

Ayudaría a una tonelada saber cuál es el resultado final deseado, pero creo que esto es lo que quiere:

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

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

Answer 3

El Object de JavaScript 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
}

Fiddle

Answer 4

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

Answer 5

Me encontré con esta pregunta en busca de algo similar. Me dio suficiente información para realizar una prueba para obtener la respuesta que quería. Por lo tanto, si alguien más quiere saber cómo agregar o buscar dinámicamente un par {clave: ''valor''} en un objeto de JavaScript, esta prueba debe informarle todo lo que necesita saber.

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

salida

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

Answer 6

Me encontré con este problema ... pero dentro de un bucle for. La solución principal no funcionó (al usar variables (y no cadenas) para los parámetros de la función de inserción), y las otras no tuvieron en cuenta los valores clave basados ​​en las variables. Me sorprendió este enfoque (que es común en php) funcionó ..

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

Answer 7

Puede crear un diccionario de clase para que pueda interactuar con la lista de diccionarios fácilmente:

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

Answer 8

Puedes usar mapas con el Map , así:

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

Answer 9

Una mejora en var dict = {} es usar var dict = Object.create(null) .

Esto creará un objeto vacío que no tiene Object.prototype como su 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 :)")
}

Answer 10

Ya que ha declarado que desea un objeto de diccionario (y no una matriz como supongo que se entiende algo), creo que esto es lo que está buscando:

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

Answer 11

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á creando un objeto literal con 2 propiedades (llamado key y value ) e insertándolo (usando push() ) en la matriz.

Edit: Entonces, casi 5 años después, esta respuesta está obteniendo votos hacia abajo porque no está creando un objeto literal "normal" JS (también conocido como mapa, también conocido como hash, también conocido como diccionario).
Sin embargo, está creando la estructura que solicitó OP (y que se ilustra en la otra pregunta vinculada a), que es una matriz de objetos literales , cada uno con propiedades de key y value . No me preguntes por qué se requería esa estructura, pero es la que se pidió.

Pero, pero si lo que quiere en un objeto JS simple (y no la estructura OP solicitada), vea la respuesta de tcll , aunque la notación del corchete es un poco incómoda si solo tiene claves simples que son nombres válidos de JS. Solo 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.

Desea la notación de corchete si tiene claves 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 quieres notación de corchete si tus claves son dinámicas:

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

Tenga en cuenta que las claves (nombres de propiedades) siempre son cadenas, y los valores que no son de cadena serán obligados a una cadena cuando se utilizan como una clave. Por ejemplo, un objeto Date 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 "solo funciona", ya que muchos objetos tendrán una representación de cadena como "[object Object]" que no conforma 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 que objA y objB son elementos completamente diferentes y únicos, ambos tienen la misma representación de cadena básica: "[object Object]" .

La razón por la que Date no se comporta de esta manera es que el prototipo Date tiene un método toString personalizado 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 usa un número aleatorio , las colisiones de nombres pueden ocurrir muy fácilmente. Es solo para ilustrar una implementación de toString ).

Por lo tanto, al tratar de usar objetos como claves, JS usará la implementación toString del objeto, si la hubiera, o la representación de cadena predeterminada.

Answer 12

var dict = {};

dict[''key''] = "testing";

console.log(dict);

Funciona igual que Python :)

salida de consola:

Object {key: "testing"} 

Answer 13

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