[Javascript] 자바 스크립트에서 연관 배열 / 해시하는 법


Answers

var associativeArray = {};
associativeArray["one"] = "First";
associativeArray["two"] = "Second";
associativeArray["three"] = "Third";

객체 지향 언어에서오고 있다면 이 기사를 확인해야한다.

Question

내가 계산 / 자바 스크립트를 사용하여 일부 통계 정보를 저장하려면 C #에서 이에 상응하는 코드는 (내가 필요로하는 기능 - 키 - 값 쌍, 문자열 / int 키 값 쌍, 키 값을 조작 등), 모든 아이디어를 어떻게 자바 스크립트에서 동일한 기능을 구현할 수 있습니까? Dictionary 나 Hashtable이 내장되어 있지 않은 것 같습니다.

Dictionary<string, int> statistics;

statistics["Foo"] = 10;
statistics["Goo"] = statistics["Goo"] + 1;
statistics.Add("Zoo", 1);



당신의 키가 단지 문자열이 아닌 객체가되어야한다면, jshashtable을 사용할 수 있습니다.




개체 키 매핑, 열거 형 ( forEach() 메서드 사용) 및 지우기와 같은 문제를 해결하기 위해이 함수를 만들었습니다.

function Hashtable() {
    this._map = new Map();
    this._indexes = new Map();
    this._keys = [];
    this._values = [];
    this.put = function(key, value) {
        var newKey = !this.containsKey(key);
        this._map.set(key, value);
        if (newKey) {
            this._indexes.set(key, this.length);
            this._keys.push(key);
            this._values.push(value);
        }
    };
    this.remove = function(key) {
        if (!this.containsKey(key))
            return;
        this._map.delete(key);
        var index = this._indexes.get(key);
        this._indexes.delete(key);
        this._keys.splice(index, 1);
        this._values.splice(index, 1);
    };
    this.indexOfKey = function(key) {
        return this._indexes.get(key);
    };
    this.indexOfValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.get = function(key) {
        return this._map.get(key);
    };
    this.entryAt = function(index) {
        var item = {};
        Object.defineProperty(item, "key", {
            value: this.keys[index],
            writable: false
        });
        Object.defineProperty(item, "value", {
            value: this.values[index],
            writable: false
        });
        return item;
    };
    this.clear = function() {
        var length = this.length;
        for (var i = 0; i < length; i++) {
            var key = this.keys[i];
            this._map.delete(key);
            this._indexes.delete(key);
        }
        this._keys.splice(0, length);
    };
    this.containsKey = function(key) {
        return this._map.has(key);
    };
    this.containsValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.forEach = function(iterator) {
        for (var i = 0; i < this.length; i++)
            iterator(this.keys[i], this.values[i], i);
    };
    Object.defineProperty(this, "length", {
        get: function() {
            return this._keys.length;
        }
    });
    Object.defineProperty(this, "keys", {
        get: function() {
            return this._keys;
        }
    });
    Object.defineProperty(this, "values", {
        get: function() {
            return this._values;
        }
    });
    Object.defineProperty(this, "entries", {
        get: function() {
            var entries = new Array(this.length);
            for (var i = 0; i < entries.length; i++)
                entries[i] = this.entryAt(i);
            return entries;
        }
    });
}


Hashtable 클래스의 문서

행동 양식:

  • get(key)
    지정된 키에 관련 지을 수 있었던 값을 돌려줍니다.
    매개 변수 :
    key : 값을 검색하는 키입니다.

  • put(key, value)
    지정된 값을 지정된 키와 연관시킵니다.
    매개 변수 :
    key : 값을 연결할 키입니다.
    value : 키에 연결할 값입니다.

  • remove(key)
    값으로 지정된 키를 제거합니다.
    매개 변수 :
    key : 제거 할 키.

  • clear()
    모든 해시 테이블을 지우고 키와 값을 제거합니다.

  • indexOfKey(key)
    추가 순서에 따라, 지정된 키의 인덱스를 돌려줍니다.
    매개 변수 :
    key : 키를 얻는 인덱스.

  • indexOfValue(value)
    추가 순서에 따라, 지정된 값의 인덱스를 리턴합니다.
    매개 변수 :
    value : 인덱스를 얻는 값.
    노트:
    이 정보는 배열의 indexOf() 메서드에서 검색하므로 객체를 toString() 메서드와 그냥 비교합니다.

  • entryAt(index)
    지정된 인덱스에서 항목을 나타내는 key 및 value의 두 가지 속성을 가진 객체를 반환합니다.
    매개 변수 :
    index : 가져올 항목의 색인입니다.

  • containsKey(key)
    해시 테이블에 지정된 키가 포함되어 있는지를 리턴합니다.
    매개 변수 :
    key : 확인할 키.

  • containsValue(value)
    해시 테이블에 지정된 값이 포함되어 있는지를 리턴합니다.
    매개 변수 :
    value : 확인할 값입니다.

  • forEach(iterator)
    지정된 iterator 모든 항목을 반복 iterator .
    매개 변수 :
    value : key , valueindex 세 가지 매개 변수가있는 메소드. 여기서 index 는 항목의 색인을 나타냅니다.

    등록 정보 :

  • length ( 읽기 전용 )
    해시 테이블에있는 항목의 수를 가져옵니다.

  • keys ( 읽기 전용 )
    해시 테이블에있는 모든 키의 배열을 가져옵니다.

  • values ( 읽기 전용 )
    해시 테이블의 모든 값의 배열을 가져옵니다.

  • entries ( 읽기 전용 )
    해시 테이블의 모든 엔트리의 배열을 가져옵니다. 그것들은 entryAt() 메소드와 같은 형식으로 표현됩니다.




최신의 모든 브라우저는 javascript Map 객체를 지원합니다. Object보다 Map을 사용하는 몇 가지 이유가 있습니다.

  • Object에는 프로토 타입이 있으므로지도에 기본 키가 있습니다.
  • Object의 키는 String이며, Map의 값이 될 수 있습니다.
  • Object의 크기를 추적해야하는 동안 Map의 크기를 쉽게 얻을 수 있습니다.

예:

var myMap = new Map();

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

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

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

다른 객체에서 참조되지 않은 키를 가비지 수집하려면 Map 대신 WeakMap을 사용하십시오.




function HashTable() {
    this.length = 0;
    this.items = new Array();
    for (var i = 0; i < arguments.length; i += 2) {
        if (typeof (arguments[i + 1]) != 'undefined') {
            this.items[arguments[i]] = arguments[i + 1];
            this.length++;
        }
    }

    this.removeItem = function (in_key) {
        var tmp_previous;
        if (typeof (this.items[in_key]) != 'undefined') {
            this.length--;
            var tmp_previous = this.items[in_key];
            delete this.items[in_key];
        }

        return tmp_previous;
    }

    this.getItem = function (in_key) {
        return this.items[in_key];
    }

    this.setItem = function (in_key, in_value) {
        var tmp_previous;
        if (typeof (in_value) != 'undefined') {
            if (typeof (this.items[in_key]) == 'undefined') {
                this.length++;
            } else {
                tmp_previous = this.items[in_key];
            }

            this.items[in_key] = in_value;
        }

        return tmp_previous;
    }

    this.hasItem = function (in_key) {
        return typeof (this.items[in_key]) != 'undefined';
    }

    this.clear = function () {
        for (var i in this.items) {
            delete this.items[i];
        }

        this.length = 0;
    }
}