JavaScript--封装方法（一）

JavaScript–封装方法（一）

1.type方法

function type(target) { 
     var ret = typeof (target); 
     var template = { 
     "[object Array]": "array", 
     "[object Object]": "object", 
     "[object Number]": "number - object", 
     "[object Boolean]": "boolean - object", 
     "[object String]": "string - object" 
     } 
     if (target === null) { 
     return "null"; 
     } else if (ret == "object") { 
     var str = Object.prototype.toString.call(target); 
     return template[str]; 
     } else { 
     return ret; 
     } }
    //步骤
    第一步：区分开是原始值还是引用值，如果是原始值就直接返回 typeof 结果，如果是引用值的话就再用 Object.prototype.toString.call 
    第二步：区分是数组还是对象还是包装类， var 一个对象把返回的结果存好，再 var 一个 str 等于 toSring 的返回结果，然后 return 的时候直接返回 template 对应的属性值
    有两点特殊的：null 是原始值，但是 typeof 的时候却把它归到 object 里了，我们单独把他摘出来即可；还有 function 是引用值，但是 typeof 后还是他，我们就把 function 和原始值写在一起，这样代码量能少点儿。

2.数组去重

  Array.prototype.unique = function () { 
     var temp = {}, 
     arr = [], 
     len = this.length; 
     for (var i = 0; i < len; i++){ 
     if(!temp[this[i]]){ 
     temp[this[i]] = "abc"; 
     arr.push(this[i]); 
     } 
     } 
     return arr; }

3.克隆

 function deepClone(origin, target) { 
     var target = target || {}, 
     toStr = Object.prototype.toString, 
     arrStr = "[object Array]"; 
     for (var prop in origin) { 
     if (origin.hasOwnProperty(prop)) { 
     if (origin[prop] !== "null" && typeof (origin[prop]) == "object"){ 
     if (toStr.call(origin[prop]) == arrStr) { 
     target[prop] = []; 
     } else { 
     target[prop] = {}; 
     } 
     deepClone(origin[prop], target[prop]); 
     } else { 
     target[prop] = origin[prop]; 
     } 
     } 
     } 
     return target; }
    //步骤：
    第一步：先用 for in 循环遍历对象，看看每一个属性是原始值还是引用值（用 typeof()判断，如果是引用值就返回 object，否则就是原始值），如果是原始值就直接拷贝。
    第二步：如果是引用值就看看是数组还是对象（建议使用 toString，另外两个instanceof 和 constructor 会有个跨父子域的问题，后期会讲到），如果是数组就建立空数组，如果是对象就建立空对象。
    第三步：把原来的引用值和要被拷贝的引用值当做一对新的克隆对象，然后再一次进行新的循环判断的步骤。（递归）

4.圣杯模式

  //通俗写法：
    function inherit(Target,Origin){ 
     function F(){}; 
     F.prototype = Origin.prototype; 
     Target.prototype = new F(); 
     Target.prototype.constructor = Target; 
     Target.prototype.uber = Origin.prototype; 
    }
    
    //YUI 库写法：
    var inherit = function () { 
     var f = function () {}; 
     return function (Target,Origin) { 
     F.prototype = Origin.prototype; 
     Target.prototype = new F(); 
     Target.prototype.constructor = Target; 
     Target.prototype.uber = Origin.prototype; 
     } 
    }())