사전을 만들고 키-값 쌍을 동적으로 추가하는 방법은 무엇입니까?

게시물에서 :

Dictionary <문자열, 문자열>로 수신 할 JSON 배열 보내기

나는 그 게시물과 같은 일을하려고합니다. 유일한 문제는 키와 값이 무엇인지 모르는 것입니다. 따라서 키와 값 쌍을 동적으로 추가 할 수 있어야하며 어떻게해야할지 모르겠습니다.

누구든지 해당 객체를 만들고 키 값 쌍을 동적으로 추가하는 방법을 알고 있습니까?

난 노력 했어:

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

그러나 그것은 작동하지 않습니다.

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 객체 리터럴 (일명 해시, 일명 사전)을 생성하지 않기 때문에 다운 투표를 받고 있습니다.
이 되어 있지만 OP가 요구되는 구조 생성 (그리고 이는 연결된 다른 문제에 도시)이며, 오브젝트 리터럴 배열 각각, key및 value특성. 왜 그 구조가 필요한지 묻지 말고 요청한 구조입니다.

그러나 OP가 요청한 구조가 아닌 일반 JS 객체에서 원하는 것이 있으면 tcll 's answer를 참조하십시오 . 유효한 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이러한 동작이 발생하지 않습니다 . 그리고 당신도 똑같이 할 수 있습니다 :DatetoString

// 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 dict = {};

dict['key'] = "testing";

console.log(dict);

파이썬처럼 작동합니다 :)

콘솔 출력 :

Object {key: "testing"} 

다음과 같이 간단합니다.

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

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
}

깡깡이

다음과 Map같이 지도를 사용할 수 있습니다 .

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

나는이 질문을 가로 질러 비슷한 것을 찾고있었습니다. 그것은 내가 원하는 대답을 얻기 위해 테스트를 실행하기에 충분한 정보를 주었다. 따라서 다른 사람이 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 dictionary = {};//create new object
dictionary["key1"] = value1;//set key1
var key1 = dictionary["key1"];//get key1

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

키 값 쌍을 만들기위한 하나의 라이너는 어떻습니까?

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

현대 자바 스크립트 (ES6 / ES2015)에서는 사전에 맵 데이터 구조를 사용해야합니다. ES6의 맵 데이터 구조를 사용하면 임의의 값을 키로 사용할 수 있습니다.

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

ES5를 계속 사용하는 경우 사전을 작성하는 올바른 방법은 다음과 같은 방법으로 프로토 타입없이 객체를 작성하는 것입니다.

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

프로토 타입 객체없이 사전을 만들면 많은 이점이 있습니다. 아래 블로그는이 주제에 대해 읽을 가치가 있습니다.

딕트 패턴

객체로서의지도

원하는 최종 결과가 무엇인지 아는 것이 도움이되지만, 이것이 당신이 원하는 것이라고 생각합니다.

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

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

나는이 문제에 부딪쳤다. 그러나 for 루프 내에서. 최상위 솔루션은 작동하지 않았으며 (푸시 함수의 매개 변수에 변수를 사용하고 문자열을 사용하지 않는 경우) 다른 변수는 변수를 기반으로 키 값을 고려하지 않았습니다. 나는이 접근법 (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 = {}은 사용하는 것입니다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 :)")
}

배열을 전체적으로 초기화

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