Sözlük nasıl oluşturulur ve dinamik olarak anahtar / değer çiftleri nasıl eklenir?

Gönderiden:

Sözlük olarak alınacak bir JSON dizisi gönderme <string, string>

Bu yazı ile aynı şeyi yapmaya çalışıyorum. Tek sorun, anahtarların ve değerlerin ne olduğunu bilmiyorum. Bu yüzden anahtar ve değer çiftlerini dinamik olarak ekleyebilmem gerekiyor ve bunu nasıl yapacağımı bilmiyorum.

Herkes bu nesneyi oluşturmak ve dinamik olarak anahtar değer çiftleri eklemek biliyor mu?

Denedim:

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

Ama bu işe yaramıyor.

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

Temel olarak, 2 özellikli ( keyve olarak adlandırılır value) bir nesne hazır bilgisi oluşturuyor push()ve diziye (kullanarak ) ekliyorsunuz .

Düzenleme: Neredeyse 5 yıl sonra, bir "normal" JS nesne değişmezi (aka harita, aka hash, aka sözlük) oluşturmuyor çünkü bu cevap downvotes oluyor. Edilir ancak OP istedi yapısı oluşturmak (ve buna bağlı diğer söz gösterilmektedir) olup, nesne değişmezleri bir dizi her biri, ve
keyvalue özellikleri. Bana bu yapının neden gerekli olduğunu sorma, ama istenen yapı bu.

Ancak, düz bir JS nesnesinde istediğiniz şey - ve OP'nin istediği yapıda değilse - tcll'nin cevabına bakın , ancak geçerli JS adları olan basit anahtarlarınız varsa, parantez notasyonu biraz hantal. Bunu sadece yapabilirsiniz:

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

Veya bir nesne oluşturduktan sonra özellikleri ayarlamak için normal nokta gösterimini kullanın:

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

Sen yok böyle bunları boşluklar, özel karakterler veya şeylere sahip anahtarlar sende eğer köşeli parantez açıklaması istiyorum. Örneğin:

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

Anahtarlarınız dinamikse köşeli ayraç notasyonu da istersiniz:

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

Anahtarların (özellik adları) her zaman dize olduğunu ve dize olmayan değerlerin anahtar olarak kullanıldığında bir dizeye zorlanacağını unutmayın. Örneğin, bir Datenesne dize temsiline dönüştürülür:

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

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

Bununla birlikte, bunun pek çok nesnenin "[object Object]"benzersiz olmayan bir anahtar üretmediği gibi bir dize temsiline sahip olacağından, bunun yalnızca "işe yaramadığını" unutmayın. Bu yüzden şuna dikkat edin:

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

Rağmen objAve objBtamamen farklı ve benzersiz unsurları olmanın, ikisi de aynı temel dize temsilini vardır: "[object Object]".

Bunun nedeni Date, Dateprototipin toStringvarsayılan dize temsilini geçersiz kılan özel bir yöntemi olmasıdır. Ve aynısını yapabilirsiniz:

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

(Yukarıdakiler rastgele bir sayı kullandığından , isim çakışmalarının yine de çok kolay bir şekilde gerçekleşebileceğini unutmayın. Bu yalnızca bir uygulamasını göstermek içindir toString.)

Bu nedenle, nesneleri anahtar olarak kullanmaya çalışırken JS, nesnenin kendi toStringuygulamasını (varsa) veya varsayılan dize temsilini kullanır.

var dict = {};

dict['key'] = "testing";

console.log(dict);

tıpkı python gibi çalışır :)

konsol çıkışı:

Object {key: "testing"} 

Bu kadar basit:

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

veya

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

sonra

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

Bir sözlük nesnesi istediğinizi belirttiğiniz için (ve bazı anlaşıldığını varsaydığım gibi bir dizi değil ) Ben sonra ne olduğunu düşünüyorum:

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 en Object olduğu bir sözlük gibi kendi içinde. Tekerleği yeniden icat etmeye gerek yok.

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
}

Vaktini boşa harcamak

Haritaları şu şekilde kullanabilirsiniz Map:

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

Benzer bir şey aramak için bu soru üzerinde yürüdüm. İstediğim cevabı almak için bir test yapmam için yeterli bilgi verdi. Dolayısıyla, bir başkası bir JavaScript nesnesine {key: 'value'} çiftini dinamik olarak nasıl ekleyeceğinizi veya arayacağınızı bilmek istiyorsa, bu test size bilmeniz gereken her şeyi söylemelidir.

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

çıktı

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

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

Sözlük listesiyle kolayca etkileşim kurabilmek için bir sınıf sözlüğü oluşturabilirsiniz:

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

bir anahtar değer çifti oluşturmak için bir astar ne dersiniz?

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

ve bazı yineleyici işlevi, reducebir diziyi sözlüğe dinamik olarak dönüştürmeyi sever

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

Modern javascriptte (ES6 / ES2015) sözlük için Harita veri yapısını kullanmalısınız. ES6'daki Harita veri yapısı, anahtar olarak rastgele değerler kullanmanıza olanak tanır.

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

Hala ES5 kullanıyorsanız, sözlük oluşturmanın doğru yolu, prototipsiz nesne aşağıdaki şekilde oluşturmaktır.

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

Prototip nesnesi olmadan sözlük oluşturmanın birçok avantajı vardır. Aşağıdaki bloglar bu konuda okumaya değer.

dict desen

nesneler-as-haritalar

İstediğiniz son sonucun ne olduğunu bilmek bir ton yardımcı olacaktır, ancak bence bu istediğiniz şeydir:

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

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

Bu sorunla karşılaştım .. ama bir for döngüsü içinde. En iyi çözüm işe yaramadı (push işlevinin parametreleri için değişkenler (dizeler değil) kullanılırken) ve diğerleri değişkenlere dayalı anahtar değerleri hesaba katmadı. (Bu php yaygındır) çalıştı bu yaklaşım şaşırdım ..

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

Üzerinde bir gelişme var dict = {}kullanmakvar dict = Object.create(null) .

Bu vermez boş bir nesne oluşturur değil var Object.prototype's prototip olarak.

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

İlk Diziyi Global Olarak Başlat

var dict = []

Sözlüğe Nesne Ekle

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

Nesneyi Sözlükten Güncelle

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

Nesneyi Sözlükten Sil

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

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