如何在Javascript中创建字典和动态添加键值对

从文章:

发送JSON数组作为Dictionary<string,string>

我试图做同样的事情，因为那篇文章，唯一的问题是，我不知道什么键和值是前面。我需要动态添加键和值对，我不知道怎么做。

有人知道如何创建对象并动态添加键值对吗?

我试过了:

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

但这行不通。

1121454 次浏览
小开
最佳答案 
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

基本上，你是在创建一个具有两个属性的对象文字(称为key和value)，并将其插入(使用push())到数组中。

所以差不多5年后，这个答案被否决了，因为它没有创建一个“正常的”JS对象文字(又名map，又名hash，又名dictionary) 然而，它是创建了OP要求的结构(在链接到的另一个问题中有说明)，即对象字面量的数组，每个结构都具有key和value属性。不要问我为什么需要这个结构，但这就是需要的结构

但是，但是，如果你想在一个普通的JS对象中——以及OP要求的结构不——参见tcll的回答，尽管如果你只有有效的JS名称的简单键，括号符号有点麻烦。你可以这样做:

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

或者在创建对象后使用常规的点符号来设置属性:

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

你做需要括号符号，如果你的键中有空格，特殊字符，或类似的东西。例句:

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

如果你的键是动态的，你也需要括号:

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

注意，键(属性名)总是字符串，当用作键时，非字符串值将被强制转换为字符串。例如，Date对象被转换为它的字符串表示形式:

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


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

但请注意，这并不一定“只是工作”，因为许多对象将具有像"[object Object]"这样的字符串表示形式，这不会产生非唯一键。所以要警惕以下情况:

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

尽管objA和objB是完全不同且唯一的元素，但它们都具有相同的基本字符串表示形式:"[object Object]"。

Date不这样做的原因是Date原型有一个自定义的toString方法，该方法覆盖默认的字符串表示形式。你也可以这样做:

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

(请注意，由于上面使用了随机数字，名称冲突仍然很容易发生。这只是为了说明toString的实现。)

因此，当试图使用对象作为键时，JS将使用对象自己的toString实现(如果有的话)，或使用默认的字符串表示形式。

小开

很简单:

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

或

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

然后

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

既然你已经声明你想要一个字典对象(和不是数组，就像我假设一些理解)，我认为这是你想要的:

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
小开

我遇到了这个问题。但是在for循环中。上面的解决方案不起作用(当使用变量(而不是字符串)作为push函数的参数时)，其他解决方案没有考虑基于变量的键值。我很惊讶这种方法(这是常见的php)工作..

  // 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];
小开 
var dict = {};


dict['key'] = "testing";


console.log(dict);

就像python一样工作:)

控制台输出:

Object {key: "testing"}
小开 
var dictionary = {};//create new object
dictionary["key1"] = value1;//set key1
var key1 = dictionary["key1"];//get key1
小开

我碰巧在寻找类似的东西时遇到了这个问题。它给了我足够的信息来进行测试，以得到我想要的答案。因此，如果有人想知道如何动态地添加或查找JavaScript对象中的{key: 'value'}对，这个测试应该会告诉你所有你可能需要知道的东西。

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

输出

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

JavaScript的Object 是本身就像一个字典。没有必要重新发明轮子。

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
}

< a href = " https://jsfiddle.net/wka4heap/1/ " >小提琴< / >

小开

对var dict = {}的改进是使用var dict = Object.create(null)。

这将创建一个空对象，该对象不的原型为Object.prototype。

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

你可以用Map来使用映射，像这样:

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

创建键值对的一行代码怎么样?

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

和一些迭代器函数，如reduce，动态地将数组转换为字典

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

小开

你可以创建一个类Dictionary，这样你就可以轻松地与Dictionary列表交互:

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

小开

在现代javascript (ES6/ES2015)中，字典应该使用Map数据结构。ES6中的Map数据结构允许您使用任意值作为键。

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

在你仍在使用ES5的情况下，正确的创建字典的方法是按照下面的方法创建没有原型的对象。

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

在没有原型对象的情况下创建字典有很多优点。下面的博客值得一读。

dict-pattern

objects-as-maps

小开

首先全局初始化数组

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

使用ES6，你可以这样做:

let cake = '🍰';


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


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

老方法 (vanilla js)

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


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

如果有人需要动态创建字典对象，可以使用下面的代码片段

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


console.log(dict)

小开

你可以像这样初始化字典

var vars = {
"key1": "Search",
"key2": "View"
};

像这样访问它

console.log(vars["key1"]);

提交答案