문제 설명

JavaScript에는 임의의 키로 임의의 값에 액세스 할 수있는 내장 된 일반 맵 유형 ( 연관 배열 또는 사전 이라고도 함 )이 없습니다. JavaScript의 기본 데이터 구조는 객체로 , 문자열을 키로 만 받아들이고 프로토 타입 상속, getter 및 setter 및 추가 부두와 같은 특수 의미를 갖는 특수 유형의 맵입니다.

객체를 맵으로 사용하는 경우 키가를 통해 문자열 값으로 변환 toString()되어 매핑 5및 '5'동일한 값으로 변환되고 toString()색인이 생성 된 값으로 메서드를 덮어 쓰지 않는 모든 객체가 생성됩니다 '[object Object]'. 확인하지 않으면 상속 된 속성에 무의식적으로 액세스 할 수도 있습니다 hasOwnProperty().

JavaScript의 내장 배열 유형은 1 비트에 도움이되지 않습니다. JavaScript 배열은 연관 배열이 아니라 몇 가지 특별한 속성을 가진 객체 일뿐입니다. 지도로 사용할 수없는 이유를 알고 싶으면 여기를 참조하십시오 .

유진의 솔루션

Eugene Lazutkin은 이미 커스텀 해시 함수를 사용하여 딕셔너리 객체의 속성으로 연관된 값을 찾는 데 사용할 수있는 고유 한 문자열을 생성하는 기본 아이디어를 설명했습니다. 객체는 내부적으로 해시 테이블 로 구현되므로 가장 빠른 솔루션 일 것 입니다.

• 참고 : 해시 테이블 (때로는 해시 맵 이라고도 함 )은 백업 배열 및 숫자 해시 값을 통한 조회를 사용하여 맵 개념의 특정 구현입니다. 런타임 환경은 다른 구조 (예 : 검색 트리 또는 건너 뛰기 목록 )를 사용하여 JavaScript 오브젝트를 구현할 수 있지만 오브젝트가 기본 데이터 구조이므로 충분히 최적화되어야합니다.

임의의 개체에 대해 고유 한 해시 값을 얻으려면 전역 카운터를 사용하고 개체 자체 (예 : 속성 __hash)에 해시 값을 캐시 할 수 있습니다.

이를 수행하는 해시 함수는 기본 값과 객체 모두에서 작동하며 다음과 같습니다.

function hash(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
}

hash.current = 0;

이 기능은 Eugene에서 설명한대로 사용할 수 있습니다. 편의를 위해 Map클래스를 추가로 포장합니다 .

내 Map구현

다음 구현에서는 키와 값을 빠르게 반복 할 수 있도록 키-값 쌍을 이중 연결 목록에 추가로 저장합니다. 고유 한 해시 함수를 제공하기 위해 hash()생성 후 인스턴스의 메서드를 덮어 쓸 수 있습니다 .

// linking the key-value-pairs is optional
// if no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
    this.current = undefined;
    this.size = 0;

    if(linkItems === false)
        this.disableLinking();
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// map initialisation from existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
    var map = new Map;

    for(var prop in obj) {
        if(foreignKeys || obj.hasOwnProperty(prop))
            map.put(prop, obj[prop]);
    }

    return map;
};

Map.prototype.disableLinking = function() {
    this.link = Map.noop;
    this.unlink = Map.noop;
    this.disableLinking = Map.noop;
    this.next = Map.illegal;
    this.key = Map.illegal;
    this.value = Map.illegal;
    this.removeAll = Map.illegal;

    return this;
};

// overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
    return (typeof value) + ' ' + (value instanceof Object ?
        (value.__hash || (value.__hash = ++arguments.callee.current)) :
        value.toString());
};

Map.prototype.hash.current = 0;

// --- mapping functions

Map.prototype.get = function(key) {
    var item = this[this.hash(key)];
    return item === undefined ? undefined : item.value;
};

Map.prototype.put = function(key, value) {
    var hash = this.hash(key);

    if(this[hash] === undefined) {
        var item = { key : key, value : value };
        this[hash] = item;

        this.link(item);
        ++this.size;
    }
    else this[hash].value = value;

    return this;
};

Map.prototype.remove = function(key) {
    var hash = this.hash(key);
    var item = this[hash];

    if(item !== undefined) {
        --this.size;
        this.unlink(item);

        delete this[hash];
    }

    return this;
};

// only works if linked
Map.prototype.removeAll = function() {
    while(this.size)
        this.remove(this.key());

    return this;
};

// --- linked list helper functions

Map.prototype.link = function(item) {
    if(this.size == 0) {
        item.prev = item;
        item.next = item;
        this.current = item;
    }
    else {
        item.prev = this.current.prev;
        item.prev.next = item;
        item.next = this.current;
        this.current.prev = item;
    }
};

Map.prototype.unlink = function(item) {
    if(this.size == 0)
        this.current = undefined;
    else {
        item.prev.next = item.next;
        item.next.prev = item.prev;
        if(item === this.current)
            this.current = item.next;
    }
};

// --- iterator functions - only work if map is linked

Map.prototype.next = function() {
    this.current = this.current.next;
};

Map.prototype.key = function() {
    return this.current.key;
};

Map.prototype.value = function() {
    return this.current.value;
};

예

다음 스크립트

var map = new Map;

map.put('spam', 'eggs').
    put('foo', 'bar').
    put('foo', 'baz').
    put({}, 'an object').
    put({}, 'another object').
    put(5, 'five').
    put(5, 'five again').
    put('5', 'another five');

for(var i = 0; i++ < map.size; map.next())
    document.writeln(map.hash(map.key()) + ' : ' + map.value());

이 출력을 생성합니다.

string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five

추가 고려 사항

PEZ는 toString()아마도 해시 함수로 메소드 를 덮어 쓸 것을 제안했습니다 . 이것은 프리미티브 값에는 작동하지 않기 때문에 실현 가능하지 않습니다 ( toString()프리미티브를 변경 하는 것은 매우 나쁜 생각입니다). 우리가 원하는 경우 toString()임의의 객체에 대한 의미있는 값을 반환, 우리는 수정해야 할 것입니다 Object.prototype어떤 사람들은 (자신 포함되지 않음)을 고려하는 금지 사항 .

편집 : 내 Map구현 의 현재 버전 과 다른 JavaScript 기능 은 here에서 얻을 수 있습니다 .

답변

var map= {
        'map_name_1': map_value_1,
        'map_name_2': map_value_2,
        'map_name_3': map_value_3,
        'map_name_4': map_value_4
        }

alert( map['map_name_1'] );    // fives the value of map_value_1

......  etc  .....

var myMap = new Map();
var keyString = "a string",
    keyObj = {},
    keyFunc = function () {};

// setting the values
myMap.set(keyString, "value associated with 'a string'");
myMap.set(keyObj, "value associated with keyObj");
myMap.set(keyFunc, "value associated with keyFunc");

myMap.size; // 3

// getting the values
myMap.get(keyString);    // "value associated with 'a string'"
myMap.get(keyObj);       // "value associated with keyObj"
myMap.get(keyFunc);      // "value associated with keyFunc"

HashMap = function(){
  this._dict = [];
}
HashMap.prototype._get = function(key){
  for(var i=0, couplet; couplet = this._dict[i]; i++){
    if(couplet[0] === key){
      return couplet;
    }
  }
}
HashMap.prototype.put = function(key, value){
  var couplet = this._get(key);
  if(couplet){
    couplet[1] = value;
  }else{
    this._dict.push([key, value]);
  }
  return this; // for chaining
}
HashMap.prototype.get = function(key){
  var couplet = this._get(key);
  if(couplet){
    return couplet[1];
  }
}

var color = {}; // unique object instance
var shape = {}; // unique object instance
var map = new HashMap();
map.put(color, "blue");
map.put(shape, "round");
console.log("Item is", map.get(color), "and", map.get(shape));

HashMap = function(){
  this._dict = {};
}
HashMap.prototype._shared = {id: 1};
HashMap.prototype.put = function put(key, value){
  if(typeof key == "object"){
    if(!key.hasOwnProperty._id){
      key.hasOwnProperty = function(key){
        return Object.prototype.hasOwnProperty.call(this, key);
      }
      key.hasOwnProperty._id = this._shared.id++;
    }
    this._dict[key.hasOwnProperty._id] = value;
  }else{
    this._dict[key] = value;
  }
  return this; // for chaining
}
HashMap.prototype.get = function get(key){
  if(typeof key == "object"){
    return this._dict[key.hasOwnProperty._id];
  }
  return this._dict[key];
}