弁言

在后端语言中存在HashTable数据构造，他能够以一种key/value的情势保留数据，同时也能够经由过程key疾速猎取value的值。这是一种很便利也很经常运用的功用。
原生JS中一样也没有完成HashTable的数据范例（注重是范例，并非构造），有与它相似的数据构造——Object，JS的Object实在本质上就是一种key/value的情势，他能够看作是一种HashTable的数据构造。
下面，我会用到Object的特征来完成HashTable这类数据范例。

完成

//trim要领自创jQuery
var whitespace = "[\\x20\\t\\r\\n\\f]",
    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g");
//直接在string的原型上做了扩大
String.prototype.trim = String.prototype.trim || function () {
    return this.treplace(rtrim, "");
};

//HashTable完成
function HashTable() {
    var self = this,
        hash = {},
        count = 0,
        keys = [],
        values = [];
    self.checkKey = function (key) {
        if ((typeof key === "string" && key.trim !== "") || typeof key === "number" || typeof key === "boolean") {
            return key;
        } else {
            /*本来想完成一个key也能够是庞杂范例（如Object）的了，然则斟酌下，
            现实开辟中，庞杂范例当作key的状况并不多，而且假如完成，能够会影响
            如今这类应用object特征疾速取值的体式格局，影响机能；故限定key采用必需是
            基础范例的体式格局。*/
            throw new Error("Key必需是一个存在值的基础范例，而且值不可为空");
        }
    };
    self.add = function (key, value) {
        key = this.checkKey(key);
        hash[key] = value;//保证key唯一，反复key，value会被掩盖
        count++;
        if (keys.indexOf(key) == -1) {
            keys.push(key);
        }
        if (values.indexOf(value) == -1) {
            values.push(value);
        }
        return self;
    };
    self.remove = function (key) {
        key = this.checkKey(key);
        if (hash.hasOwnProperty(key)) {
            var value = hash[key];
            delete hash[key];
            count--;
            if (count < 0) {
                count = 0;
            }
            var kIndex = keys.indexOf(key),
                vIndex = values.indexOf(value);
            if (kIndex != -1) {
                keys.splice(kIndex, 1);
            }
            if (vIndex != -1) {
                values.splice(vIndex, 1);
            }
        }
        return self;
    };
    self.clear = function () {
        for (var i = 0; i < keys.length; i++) {
            if (hash.hasOwnProperty(keys[i])) {
                delete hash[keys[i]];
            }
        }
        keys.splice(0, keys.length);
        values.splice(0, values.length);
        return self;
    };
    self.count = function () {
        return count;
    };
    self.contains = function (key) {
        return keys.indexOf(key) !== -1;;
    };
    self.containsKey = function (key) {
        return keys.indexOf(key) !== -1;
    };
    self.containsValue = function (value) {
        return values.indexOf(value) !== -1;
    };
    self.getKeys = function () {
        return keys.concat([]);
    };
    self.getValues = function () {
        return values.concat([]);
    };
    //依据key猎取值
    self.getValue = function (key) {
        if (hash.hasOwnProperty(key)) {
            return hash[key];
        }
    };
    //供应快速遍历函数
    self.each = function (fun) {
        if (typeof fun === "function") {
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i],
                    value = hash[key];
                var stop = fun.call({
                    key: key,
                    value: value
                }, key, value);
                if (stop === false) break;
            }
        }
    };
    self.toList = function () {
        var result = [];
        for (var i = 0; i < keys.length; i++) {
            var key = keys[i],
                value = hash[key];
            result.push({
                key: key,
                value: value
            });
        }
        return result;
    };
};

革新

初版完成中，我是在add要领中，直接将key加载了HashTable这个类的实例上的，如许做的优点是：能够更靠近相似的后端运用体式格局，以下：

var ht = new HashTable();
ht.add("key1","value1");
ht["key2"]="value2";
ht.getValue("key2");//value2
ht["key1"];//value1

如许的完成会在运用时供应更大便利，然则数据有效性不能保证，如：假如key是HashTable实例的一个要领名，那就有能够被掩盖，要领会失灵。
所以综合斟酌后，编写了正文【完成】中的代码。
假如人人有更好的完成体式格局也能够分享，人人一同进修~~