JavaScript에서 연관지을 수 있는 어레이/해시를 실행하는 방법

JavaScript에서 연관지을 수 있는 어레이/해시를 실행하는 방법

C#과 같은 방법으로 JavaScript를 사용하여 통계를 저장해야 합니다.

Dictionary<string, int> statistics;

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

Hashtable 거 있잖아요Dictionary<TKey, TValue>JavaScript?
어떻게 그런 식으로 값을 저장할 수 있을까요?

JavaScript 개체를 연관 배열로 사용합니다.

어소시에이션 어레이:쉽게 말해 연관 배열은 인덱스로 정수 대신 문자열을 사용합니다.

오브젝트를 만듭니다.

var dictionary = {};

JavaScript를 사용하면 다음 구문을 사용하여 개체에 속성을 추가할 수 있습니다.

Object.yourProperty = value;

같은 구문은 다음과 같습니다.

Object["yourProperty"] = value;

가능한 경우 다음 구문을 사용하여 키/값 객체 맵도 만듭니다.

var point = { x:3, y:2 };

point["x"] // returns 3
point.y // returns 2

for를 사용하여 관련 어레이를 반복할 수 있습니다.다음과 같이 루프 구성으로

for(var key in Object.keys(dict)){
  var value = dict[key];
  /* use key/value for intended purpose */
}

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

객체 지향 언어에서 온 경우 이 문서를 확인해야 합니다.

최신 브라우저는 모두 JavaScript 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"

다른 개체에서 참조되지 않는 키를 가비지 수집하려면 맵 대신 WeakMap을 사용하는 것이 좋습니다.

특별한 이유가 없는 한 일반 개체를 사용하십시오.JavaScript의 객체 속성은 해시 테이블 형식의 구문을 사용하여 참조할 수 있습니다.

var hashtable = {};
hashtable.foo = "bar";
hashtable['bar'] = "foo";

다.foo ★★★★★★★★★★★★★★★★★」bar이제 요소를 다음과 같이 참조할 수 있습니다.

hashtable['foo'];
hashtable['bar'];

// Or
hashtable.foo;
hashtable.bar;

물론 열쇠는 끈이어야 합니다.문자열이 아닌 경우 내부적으로 문자열로 변환되므로 계속 작동할 수 있습니다.마일리지가 다를 수 있습니다.

JavaScript의 모든 오브젝트는 해시 테이블처럼 동작하며 일반적으로 구현되기 때문에, 저는 그냥 그렇게 하겠습니다.

var hashSweetHashTable = {};

C#의 코드는 다음과 같습니다.

Dictionary<string,int> dictionary = new Dictionary<string,int>();
dictionary.add("sample1", 1);
dictionary.add("sample2", 2);

또는

var dictionary = new Dictionary<string, int> {
    {"sample1", 1},
    {"sample2", 2}
};

JavaScript의 경우:

var dictionary = {
    "sample1": 1,
    "sample2": 2
}

오브젝트에는 C#의 한 메서드: C#의 경우)가되어 있습니다.dictionary.ContainsKey()

JavaScript에서는, 「」를 할 수 .hasOwnProperty들면 다음과 같습니다.

if (dictionary.hasOwnProperty("sample1"))
    console.log("sample1 key found and its value is"+ dictionary["sample1"]);

키가 문자열이 아닌 임의의 오브젝트여야 하는 경우 jshashtable을 사용할 수 있습니다.

주의:

년했는데, 해시테이블에는 몇.이 해시 테이블에는 몇 가지 부족한 기능이 있습니다.Map 지금은 그렇지 다시 한 번 수 .이제, 이 엔트리에 대해 반복할 수 있습니다.Map키 또는 값의 배열 또는 둘 다 가져옵니다(단, 이러한 조작은 새로 할당된 어레이에 복사하여 구현됩니다).메모리의 낭비가 심하고, 시간의 복잡성은 항상 다음과 같이 느려집니다.O(n)키를 지정하면 특정 아이템을 삭제하고 맵 전체를 클리어합니다.
따라서 해시테이블 구현은 호환성 목적으로만 유용하며, 이 경우 이를 기반으로 적절한 폴리필을 작성하는 것이 보다 현명한 접근법이 될 것입니다.

---

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 값: 인덱스를 가져올 값입니다.

  ★★★★
  값은 아이덴티티별로 비교됩니다.

---

• entryAt(index)

  다음 값이 포함된 개체를 반환합니다.key a. a. a.value지정된 인덱스의 엔트리를 나타내는 속성.

  ★★★★★★★★★★★★★★★★★★:
  index 츠미야

---

• containsKey(key)

  해시 테이블에 지정된 키가 포함되어 있는지 여부를 반환합니다.

  ★★★★★★★★★★★★★★★★★★: key 찾는 열쇠.

---

• containsValue(value)

  해시 테이블에 지정된 값이 포함되어 있는지 여부를 반환합니다.

  ★★★★★★★★★★★★★★★★★★:
  value 는는값 。

---

• forEach(iterator)

  테이블 엔트리를 된 엔트리를 합니다.iterator.

  ★★★★★★★★★★★★★★★★★★:
  iterator: 3개의 파라미터,key,value ★★★★★★★★★★★★★★★★★」index서, snowledge.index는 추가된 순서에 따른 엔트리의 인덱스를 나타냅니다.

속성:

• length(읽기 전용)

  해시 테이블 내의 엔트리 수를 가져옵니다.

• keys(읽기 전용)

  해시 테이블의 모든 키 배열을 가져옵니다.

• values(읽기 전용)

  해시 테이블의 모든 값 배열을 가져옵니다.

• entries(읽기 전용)

  해시 테이블의 모든 엔트리의 배열을 가져옵니다.은 똑같이 되어 있어요.entryAt().

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

https://gist.github.com/alexhawkins/f6329420f40e5cafa0a4

var HashTable = function() {
  this._storage = [];
  this._count = 0;
  this._limit = 8;
}


HashTable.prototype.insert = function(key, value) {

  // Create an index for our storage location by passing
  // it through our hashing function
  var index = this.hashFunc(key, this._limit);

  // Retrieve the bucket at this particular index in
  // our storage, if one exists
  //[[ [k,v], [k,v], [k,v] ] , [ [k,v], [k,v] ]  [ [k,v] ] ]
  var bucket = this._storage[index]

  // Does a bucket exist or do we get undefined
  // when trying to retrieve said index?
  if (!bucket) {
    // Create the bucket
    var bucket = [];
    // Insert the bucket into our hashTable
    this._storage[index] = bucket;
  }

  var override = false;

  // Now iterate through our bucket to see if there are any conflicting
  // key value pairs within our bucket. If there are any, override them.
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {

      // Override value stored at this key
      tuple[1] = value;
      override = true;
    }
  }

  if (!override) {
    // Create a new tuple in our bucket.
    // Note that this could either be the new empty bucket we created above
    // or a bucket with other tupules with keys that are different than
    // the key of the tuple we are inserting. These tupules are in the same
    // bucket because their keys all equate to the same numeric index when
    // passing through our hash function.
    bucket.push([key, value]);
    this._count++

    // Now that we've added our new key/val pair to our storage
    // let's check to see if we need to resize our storage
    if (this._count > this._limit * 0.75) {
      this.resize(this._limit * 2);
    }
  }
  return this;
};


HashTable.prototype.remove = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];
  if (!bucket) {
    return null;
  }

  // Iterate over the bucket
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];

    // Check to see if key is inside bucket
    if (tuple[0] === key) {

      // If it is, get rid of this tuple
      bucket.splice(i, 1);
      this._count--;
      if (this._count < this._limit * 0.25) {
        this._resize(this._limit / 2);
      }
      return tuple[1];
    }
  }
};


HashTable.prototype.retrieve = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];

  if (!bucket) {
    return null;
  }

  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {
      return tuple[1];
    }
  }

  return null;
};


HashTable.prototype.hashFunc = function(str, max) {
  var hash = 0;
  for (var i = 0; i < str.length; i++) {
    var letter = str[i];
    hash = (hash << 5) + letter.charCodeAt(0);
    hash = (hash & hash) % max;
  }
  return hash;
};


HashTable.prototype.resize = function(newLimit) {
  var oldStorage = this._storage;

  this._limit = newLimit;
  this._count = 0;
  this._storage = [];

  oldStorage.forEach(function(bucket) {
    if (!bucket) {
      return;
    }
    for (var i = 0; i < bucket.length; i++) {
      var tuple = bucket[i];
      this.insert(tuple[0], tuple[1]);
    }
  }.bind(this));
};


HashTable.prototype.retrieveAll = function() {
  console.log(this._storage);
  //console.log(this._limit);
};

/******************************TESTS*******************************/

var hashT = new HashTable();

hashT.insert('Alex Hawkins', '510-599-1930');
//hashT.retrieve();
//[ , , , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Boo Radley', '520-589-1970');
//hashT.retrieve();
//[ , [ [ 'Boo Radley', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Vance Carter', '120-589-1970').insert('Rick Mires', '520-589-1970').insert('Tom Bradey', '520-589-1970').insert('Biff Tanin', '520-589-1970');
//hashT.retrieveAll();
/*
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '520-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '520-589-1970' ] ] ]
*/

// Override example (Phone Number Change)
//
hashT.insert('Rick Mires', '650-589-1970').insert('Tom Bradey', '818-589-1970').insert('Biff Tanin', '987-589-1970');
//hashT.retrieveAll();

/*
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '818-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '650-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]

*/

hashT.remove('Rick Mires');
hashT.remove('Tom Bradey');
//hashT.retrieveAll();

/*
[ ,
  [ [ 'Boo Radley', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]


*/

hashT.insert('Dick Mires', '650-589-1970').insert('Lam James', '818-589-1970').insert('Ricky Ticky Tavi', '987-589-1970');
hashT.retrieveAll();


/* NOTICE HOW THE HASH TABLE HAS NOW DOUBLED IN SIZE UPON REACHING 75% CAPACITY, i.e. 6/8. It is now size 16.
 [,
  ,
  [ [ 'Vance Carter', '120-589-1970' ] ],
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Dick Mires', '650-589-1970' ],
    [ 'Lam James', '818-589-1970' ] ],
  ,
  ,
  ,
  ,
  ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Ricky Ticky Tavi', '987-589-1970' ] ],
  ,
  ,
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]

*/

console.log(hashT.retrieve('Lam James'));  // 818-589-1970
console.log(hashT.retrieve('Dick Mires')); // 650-589-1970
console.log(hashT.retrieve('Ricky Ticky Tavi')); //987-589-1970
console.log(hashT.retrieve('Alex Hawkins')); // 510-599-1930
console.log(hashT.retrieve('Lebron James')); // null

다음과 같이 작성할 수 있습니다.

var dictionary = { Name:"Some Programmer", Age:24, Job:"Writing Programs"  };

// Iterate over using keys
for (var key in dictionary) {
  console.log("Key: " + key + " , " + "Value: "+ dictionary[key]);
}

// Access a key using object notation:
console.log("Her name is: " + dictionary.Name)

언급URL : https://stackoverflow.com/questions/1208222/how-to-do-associative-array-hashing-in-javascript