JavaScript Symbol 的一些封装

JavaScript Symbol 的一些封装，方便操作。

相关代码如下：

 /**
 * 判断是否是数组
 * @param argument
 * @param {number|boolean} opt 是否用严格模式
 * @return {*}
 */
function is_array(argument, opt) {
    if (opt === 1 || opt === true) {
        return Object.prototype.toString.call(argument) === "[object Array]";
    }
    return argument && (typeof argument === "object") && ("length" in argument) && (typeof argument.length === "number");
}

/**
 * 判断是否是对象
 * @param argument
 * @return {*}
 */
function is_object(argument) {
    if (argument && (typeof argument === "object") && ("length" in argument)) {
        return Object.prototype.toString.call(argument) === "[object Object]";
    }
    return argument && (typeof argument === "object") && !("length" in argument);
}

/**
 * 判断是否是函数
 * @param argument
 * @return {*|boolean}
 */
function is_function(argument) {
    return typeof argument === "function";
}

/**
 * 判断是否是字符串
 * @param argument
 * @return {*|boolean}
 */
function is_string(argument) {
    return typeof argument === "string";
}

/**
 * 判断是否是数字
 * @param argument
 * @return {boolean}
 */
function is_number(argument) {
    return typeof argument === "number";
}

/**
 * 是否存在[true存在，false不存在]
 * @param argument
 * @param {array} opt 这里面的值是代表“不存在”
 * @return {boolean}
 */
function is_exist(argument, opt) {
    opt || (opt = ["", null, false, undefined]);
    for (var k in opt) {
        if (opt[k] === argument) {
            return false;
        }
    }
    return true;
}

/**
 * 判断是否是整数
 * @param vars
 * @return {boolean}
 */
function is_int(vars) {
    return /^[-]{0,1}\d+$/i.test(vars + "");
}

/**
 * 判断是否是小数
 * @param vars
 * @return {boolean}
 */
function is_float(vars) {
    return /^[-]{0,1}[0-9]+\.{0,1}[0-9]*$/i.test(vars + "")
}

/**
 * 是否是 symbol 类型
 * @param argument
 * @return {boolean}
 */
function is_symbol(argument) {
    return typeof argument === "symbol";
}

/**
 * 搜索数组中是否存在指定的值
 * @param {string} needle
 * @param {array} haystack
 * @param {boolean} argStrict
 * @return {boolean}
 */
function in_array(needle, haystack, argStrict) {
    var key = "", strict = !!argStrict;
    if (strict) {
        for (key in haystack) {
            if (haystack[key] === needle) {
                return true
            }
        }
    } else {
        for (key in haystack) {
            if (haystack[key] == needle) {
                return true
            }
        }
    }
    return false
}

/**
 * 设置对象属性不可修改，不可删除，不可枚举等
 * @param {Object|Array|function|Storage} obj
 * @param {array|object|string} attrList
 */
function attrNotEach(obj, attrList) {
    var O = {writable: false, configurable: false, enumerable: false}; //设置对象属性不可修改，不可删除，不可枚举
    var list = ["[object Function]", "[object Storage]", "[object Window]"], val;
    if (is_object(obj) || is_array(obj) || in_array(Object.prototype.toString.call(obj), list, true)) {
        if (is_array(attrList)) {
            for (var i = 0, len = attrList.length; i < len; i++) {
                val = attrList[i];
                is_string(val) && Object.defineProperty(obj, val, O);
            }
        } else if (is_object(attrList)) {
            for (var attr in attrList) {
                val = attrList[attr];
                is_string(val) && Object.defineProperty(obj, val, O);
                is_object(val) && Object.defineProperty(obj, attr, Object.assign({}, O, val));
            }
        } else {
            is_string(attrList) && Object.defineProperty(obj, attrList, O);
        }
    }
}


/**
 * Symbol 相关封装
 * @constructor
 */
function Sym() {
    for (var i = 0, len = arguments.length; i < len; i++) {
        is_function(arguments[i]) && arguments[i].call(this);
    }
    this.__temp__ = {local: {}, global: {}};
    this.lGET = function (key) {
        return this.localGet(key);
    };
    this.gGET = function (key) {
        return this.globalGet(key);
    };
    this.lSET = function (key, value) {
        return this.localSet(key, value);
    };
    this.gSET = function (key, value) {
        return this.globalSet(key, value);
    };
}

Sym.prototype = {
    /**
     * 设置Symbol值
     * @param {Array|Object|String} key
     * @param {Symbol|String|*} value
     * @param {boolean} is_global
     * @return {Sym}
     */
    set: function (key, value, is_global) {
        var k, v, g = this.__temp__.global, lo = this.__temp__.local;
        if (is_array(key) || is_object(key)) {
            for (k in key) {
                this.set(k, key[k], is_global);
            }
        } else {
            if (!is_symbol(key) && this.is_string(key)) {
                if (is_symbol(value)) {
                    this.is_global(value) ? g[key] = value : lo[key] = value;
                } else if (this.is_string(value)) {
                    is_global ? g[value] = Symbol.for(value) : lo[value] = Symbol(value);
                } else {
                    is_global ? g[key] = Symbol.for(key) : lo[key] = Symbol(key);
                }
            }
        }
        return this;
    },
    /**
     * 获取 Symbol
     * @param {String|null} key
     * @param {boolean} is_global
     * @return {*}
     */
    get: function (key, is_global) {
        var g = this.__temp__.global, lo = this.__temp__.local;
        if (this.is_string(key)) {
            return is_global ? g[key] : lo[key];
        }
        return is_global ? g : lo;
    },
    localGet: function (key) {
        return this.get(key, false);
    },
    localSet: function (key, value) {
        return this.set(key, value, false);
    },
    globalGet: function (key) {
        return this.get(key, true);
    },
    globalSet: function (key, value) {
        return this.set(key, value, true);
    },
    is_string: function (arg) {
        return is_exist(arg) && (is_string(arg) || is_float(arg));
    },
    /**
     * 判断Symbol是否是全局的
     * @param {Symbol} arg
     * @return {boolean}
     */
    is_global:function (arg) {
        return is_symbol(arg) && !!Symbol.keyFor(arg);
    }
};

(function(){
    attrNotEach(Sym.prototype, ["get", "set", "localGet", "localSet", "globalGet", "globalSet", "is_string", "is_global"]);
}()); 
var sy = new Sym(); 

使用如图：