var dict = {};

dict['key'] = "testing";

console.log(dict);

就像python一样工作:)

控制台输出:

Object {key: "testing"} 

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
}

小提琴

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

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

还有一些迭代器函数，比如reduce，可以动态地将数组转换为字典

Var选项= [ {key: "foo"，值:1}， {key: "bar"，值:{id: 2，名称:"two"}}， {key: "baz"， value: {["active"]: true}}， ]; Var result = options。Reduce((累加器，电流)=> { 蓄电池(电流。键]= current.value; 返回蓄电池; }, {}); console.log(结果);

我碰巧在寻找类似的东西时遇到了这个问题。它给了我足够的信息来进行测试，以得到我想要的答案。因此，如果有人想知道如何动态地添加或查找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' }

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

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

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

但是，但是，如果你想要一个普通的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实现(如果有的话)，或者使用默认的字符串表示。

我遇到了这个问题。但是在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];