Hoe een woordenboek maken en sleutel-waardeparen dynamisch toevoegen?

Van bericht:

Een JSON verzenden array die moet worden ontvangen als een Dictionary<string,string>

Ik probeer hetzelfde te doen als dat bericht. Het enige probleem is dat ik niet weet wat de sleutels en de waarden zijn. Dus ik moet de sleutel- en waardeparen dynamisch kunnen toevoegen en ik weet niet hoe ik dat moet doen.

Weet iemand hoe je dat object kunt maken en dynamisch sleutelwaardeparen kunt toevoegen?

Ik heb het geprobeerd:

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

Maar dat werkt niet.

Antwoord 1, autoriteit 100%

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

Kortom, u maakt een letterlijk object met 2 eigenschappen (genaamd keyen value) en voegt deze in (met behulp van push()) in de array.

Bewerken:Dus bijna 5 jaar later krijgt dit antwoord minnetjes omdat het geen “normaal” JS-object creëert (ook wel map, oftewel hash, oftewel woordenboek).
Het isechter het creëren van de structuur waar OP om vroeg (en die wordt geïllustreerd in de andere vraag waarnaar wordt gelinkt), die een array van letterlijke objectenis, elk met keyen valueeigenschappen. Vraag me niet waarom die structuur nodig was, maar het is degene waar om werd gevraagd.

Maar, maar, als wat je wilt in een gewoon JS-object – en nietde structuur waar OP om vroeg – zie tcll’s antwoord, hoewel de haakjesnotatie een beetje omslachtig is als je alleen eenvoudige sleutels hebt die geldige JS-namen zijn. Je kunt dit gewoon doen:

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

Of gebruik gewone puntnotatie om eigenschappen in te stellen na het maken van een object:

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

Je wilde haakjesnotatie gebruiken als je toetsen hebt met spaties, speciale tekens of dergelijke. Bijv.:

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

U wilt ook haakjesnotatie als uw sleutels dynamisch zijn:

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

Houd er rekening mee dat sleutels (eigenschapsnamen) altijd tekenreeksen zijn en dat niet-tekenreekswaarden tot een tekenreeks worden gedwongen wanneer ze als sleutel worden gebruikt. bijv. een Dateobject wordt geconverteerd naar zijn tekenreeksrepresentatie:

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

Houd er echter rekening mee dat dit niet noodzakelijk “gewoon werkt”, aangezien veel objecten een tekenreeksrepresentatie hebben zoals "[object Object]", wat niet zorgt voor een niet-unieke sleutel. Dus wees op uw hoede voor iets als:

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

Ondanks dat objAen objBtotaal verschillende en unieke elementen zijn, hebben ze allebei dezelfde basistekenreeksrepresentatie: "[object Object]".

De reden waarom Datezich niet zo gedraagt, is dat het prototype Dateeen aangepaste toString-methode heeft die de standaardtekenreeksrepresentatie overschrijft. En jij kunt hetzelfde doen:

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

(Merk op dat aangezien het bovenstaande een willekeuriggetal gebruikt, naamconflicten nog steeds heel gemakkelijk kunnen optreden. Het is alleen om een implementatie van toStringte illustreren.)

Dus wanneer u objecten als sleutels probeert te gebruiken, zal JS de eigen toString-implementatie van het object gebruiken, indien aanwezig, of de standaard tekenreeksrepresentatie gebruiken.

Antwoord 2, autoriteit 71%

var dict = {};
dict['key'] = "testing";
console.log(dict);

werkt net als python 🙂

console-uitvoer:

Object {key: "testing"} 

Antwoord 3, autoriteit 9%

Het is zo simpel als:

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

of

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

dan

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

Antwoord 4, autoriteit 5%

Aangezien je hebt aangegeven dat je een woordenboekobject wilt (en geen arrayzoals ik aanneem dat sommigen het begrepen), denk ik dat je dit zoekt:

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

Antwoord 5, autoriteit 4%

JavaScript’s Objectisop zich als een woordenboek. U hoeft het wiel niet opnieuw uit te vinden.

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

Antwoord 6, Autoriteit 2%

U kunt kaarten gebruiken met Map, zoals dit:

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

Antwoord 7

Ik was toevallig over deze vraag op zoek naar iets vergelijkbaars. Het gaf me genoeg informatie om een ​​test uit te voeren om het antwoord dat ik wilde krijgen. Dus als iemand anders wil weten hoe ze dynamisch een { -toets moeten toevoegen of opzoeken: ‘VALUE’} Pair in een JavaScript-object, moet deze test u vertellen wat u misschien moet weten.

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

Uitgang

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

Antwoord 8

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

Antwoord 9

Je zou een klasse Woordenboek kunnen maken, zodat je gemakkelijk met de Woordenboeklijst kunt werken:

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

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

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

let cake = '🍰';
let pan = {
  [cake]: '🥞',
};
// Output -> { '🍰': '🥞' }

let cake = '🍰';
let pan = {};
pan[cake] = '🥞';
// Output -> { '🍰': '🥞' }

var dict = []

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

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

Object.keys(dict).map((index) => {              
      if (index == 2){
        dict.splice(index)
      }
    });
Output : 
    [0: {key: "One", value: false},
     1: {key: "Two", value: true}]

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

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

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

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

  let vars = [{key:"key", value:"value"},{key:"key2", value:"value2"}];
     let dict={}
     vars.map(varItem=>{
              dict[varItem.key]=varItem.value
            })
    console.log(dict)

dict = {}
dict['name'] = 'Name';
dict['id'] = 'f16el160'