原型链上封装深度克隆

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function type (obj) {
          	var cache = {
          	  '[object Number]': 'number',
          	  '[object Array]' : 'array',
          	  '[object Object]' : 'object',
          	  '[object String]' : 'string',
          	  '[object Boolean]' : 'boolean',
          	  '[object Null]' : 'null',
          	  '[object Undefined]' : 'undefined',
          	  '[object Function]' : 'function'
          	}
          	
          	return cache[Object.prototype.toString.call(obj)];
          }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function clone (origin, target) {
      	var target = target || {};
      	  for(var key in origin){
      	    if(origin[key] !== null && origin.hasOwnProperty(key)){
      	    if(typeof(origin[key]) == 'object'){
      	        console.log(origin.hasOwnProperty(key),key);
      	        if(Object.prototype.toString.call(origin[key]) == '[object Array]'){
      	          target[key] = [];
      	        }else{
      	          target[key] = {};
      	        }
      	        clone(origin[key],target[key]);
      	    }else {
      	      target[key] = origin[key];
      	    }
      	  }
      	 }
      	return target;
      }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Object.prototype.deepcolone = function (){
  Object.prototype.deepColon = function (target) {
          	var self = this;
          	var typ = type(self);
          	switch (typ){
          		case 'object':
          		  return clone(self,{});
          		case 'array':
          		  return clone(self,[]);
          		 default :
          		  return self;
          	}
          }
}

有个缺陷,当他是原始值的时候,也能返回数据,但返回的是包装类的数据.

不过在Object.prototype上封装方法,只要原型链上不重名, 基本所有对象都能用得上.