JS实现clone()方法，对五种主要数据类型进行值复制

// 方法一：
Object.prototype.clone = function() {
    var o = this.constructor === Array ? [] : {};
    for (var e in this) {
o[e] = typeof this[e] === "object" ? this[e].clone() : this[e];}
    return o;
};
//方法二：
/**
 * 克隆一个对象
 * @param Obj
 * @returns
 */
function clone(Obj) {
    var buf;
    if (Obj instanceof Array) {
        buf = []; //创建一个空的数组
        var i = Obj.length;
        while (i--) {
            buf[i] = clone(Obj[i]);
        }
        return buf;
    } else if (Obj instanceof Object) {
        buf = {}; //创建一个空对象
        for (var k in Obj) {
            //为这个对象添加新的属性
            buf[k] = clone(Obj[k]);
        }
        return buf;
    } else {
        //普通变量直接赋值
        return Obj;
    }
}

　　//各种类型的返回值; call 和 apply 返回值相同; 只是参数不同
　　 console.log("string" +toString.apply(str))// string[object String]    console.log("number" +toString.apply(num))// number[object Number]    console.log("object" +toString.apply(obj))// object[object Object]    console.log("array" + toString.apply(arr))// array[object Array]    console.log("boolean" + toString.apply(bool))// boolean[object Boolean]    console.log("undefined" + toString.apply(undefined))      　　//undefined[object Undefined]    console.log("null" + toString.apply(null))              　　  //  null[object Null]

//第一个参数是被克隆的对象，第二个参数是需要克隆的属性列表
function cloneOwn() {
  var obj = arguments[0];
  if (typeof obj === 'undefined' || obj === null)
      return {};
  if (typeof obj !== 'object')
      return obj;
  //第二个参数是属性名称列表，就采用该列表进行刷选
  //否则就克隆所有属性
  var attrs = arguments[1];
  var enable_spec_attr = true;
  if (!(attrs instanceof Array)) {
      //console.log(attrs);
      attrs = obj;
      enable_spec_attr = false;
  }
  var result = {};
  var i;
  for (i in attrs) {
      attr = enable_spec_attr? attrs[i]: i;
      //console.log(attr);
      if (obj.hasOwnProperty(attr)) {
          if (obj[attr] instanceof Array) {
              result[attr] = cloneArray(obj[attr]);
          }
          else if (typeof obj[attr] === 'object') {
              result[attr] = cloneOwn(obj[attr]);
          } else {
              result[attr] = obj[attr];
          }
      }
  }
  return result;
}
//克隆数组
function cloneArray(array) {
  if (typeof array === 'undefined' || array === null)
    return [];
  if (!(array instanceof Array))
    return [];
  result = [];
  var i;
  for(i in array) {
    if (typeof array[i] !== 'object') {
      result[i] = array[i];
      continue;
    }
    //clone object
    result[i] = cloneOwn(array[i]);
  }
  return result;
}

var a = {
    name:'frank',
    age:20
};
var b= cloneOwn(a);
2.指定克隆的属性

var a = {
    name:'frank',
    age:20,
    address:'any where'
};
var b = cloneOwne(a, ['name', 'age']);

var a = {
    name: 'kxh',
    age: 20,
    books: ['hai','ho','ali'],
    likes: [
        {wname: 'kaili', wage: 81, fav: "aaaaa"},
        {wname: 'seli', wage: 82, fav: "bbb"},
        {wname: 'ailun', wage: 83, fav: "ccc"},]
};
var b = cloneOwne(a);

var a = [
   {
      name:'frank',
      age:20
    },
    {
       name:'leon',
       age:30
     }
];
var b = cloneArray(a);

// 要实现深复制有很多办法，比如最简单的办法有：
var cloneObj = JSON.parse(JSON.stringify(obj));
   /* 上面这种方法好处是非常简单易用，但是坏处也显而易见，这会抛弃对象的constructor，也就是深复制之后，无论这个对象原本的构造函数是什么，在深复制之后都会变成Object。另外诸如RegExp对象是无法通过这种方式深复制的。
所以这里我将介绍一种，我自认为很优美的深复制方法，当然可能也存在问题。如果你发现了我的实现方法有什么问题，请及时让我知道~
        先决条件：1. 对于任何对象，它可能的类型有Boolean, Number, Date, String, RegExp, Array 以及 Object（所有自定义的对象全都继承于Object）2. 我们必须保留对象的构造函数信息（从而使新对象可以使用定义在prototype上的函数）
最重要的一个函数：*/
Object.prototype.clone = function () {
    var Constructor = this.constructor;
    var obj = new Constructor();
    for (var attr in this) {
        if (this.hasOwnProperty(attr)) {
            if (typeof(this[attr]) !== "function") {
                if (this[attr] === null) {
                    obj[attr] = null;
                }
                else {
                    obj[attr] = this[attr].clone();
                }
            }
        }
    }
    return obj;
};
    // 定义在Object.prototype上的clone()函数是整个方法的核心，对于任意一个非js预定义的对象，都会调用这个函数。而对于所有js预定义的对象，如Number,Array等，我们就要实现一个辅助clone()函数来实现完整的克隆过程：
    /* Method of Array*/
    Array.prototype.clone = function () {
        var thisArr = this.valueOf();
        var newArr = [];
        for (var i=0; i<thisArr.length; i++) {
            newArr.push(thisArr[i].clone());
        }
        return newArr;
    };
    /* Method of Boolean, Number, String*/
    Boolean.prototype.clone = function() { return this.valueOf(); };
    Number.prototype.clone = function() { return this.valueOf(); };
    String.prototype.clone = function() { return this.valueOf(); };
    /* Method of Date*/
    Date.prototype.clone = function() { return new Date(this.valueOf()); };
    /* Method of RegExp*/
    RegExp.prototype.clone = function() {
        var pattern = this.valueOf();
        var flags = '';
        flags += pattern.global ? 'g' : '';
        flags += pattern.ignoreCase ? 'i' : '';
        flags += pattern.multiline ? 'm' : '';
        return new RegExp(pattern.source, flags);
    };
   /* 可能直接定义在预定义对象的方法上，让人感觉会有些问题。但在我看来这是一种优美的实现方式。
同时我也在开发一个插件，主要的思想也就是扩展预定义对象的方法。
这个插件叫JustJS（Github项目地址）
有以下一些特性：1. 同时支持Web前端和node.js使用。2. 直接对预定义对象的方法进行扩展*/