var arr = ["One","Two","Three"];

var arrto = arr;

arrto[1] = "test";

document.writeln("数组的原始值：" + arr + "<br />");//Export:数组的原始值：One,test,Three

document.writeln("数组的新值：" + arrto + "<br />");//Export:数组的新值：One,test,Three

对于array对象的slice函数，

返回一个数组的一段。（仍为数组）

arrayObj.slice(start, [end])

参数

arrayObj

必选项。一个 Array 对象。

start

必选项。arrayObj 中所指定的部分的开始元素是从零开始计算的下标。

end

可选项。arrayObj 中所指定的部分的结束元素是从零开始计算的下标。

说明

slice 方法返回一个 Array 对象，其中包含了 arrayObj 的指定部分。

slice 方法一直复制到 end 所指定的元素，但是不包括该元素。如果 start 为负，将它作为 length + start处理，此处 length 为数组的长度。如果 end 为负，就将它作为 length + end 处理，此处 length 为数组的长度。如果省略 end ，那么 slice 方法将一直复制到 arrayObj 的结尾。如果 end 出现在 start 之前，不复制任何元素到新数组中。

var arr = ["One","Two","Three"];

var arrtoo = arr.slice(0);

arrtoo[1] = "set Map";

document.writeln("数组的原始值：" + arr + "<br />");//Export:数组的原始值：One,Two,Three

document.writeln("数组的新值：" + arrtoo + "<br />");//Export:数组的新值：One,set Map,Three

concat() 方法用于连接两个或多个数组。

该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

语法

arrayObject.concat(arrayX,arrayX,......,arrayX)

说明

返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。

var arr = ["One","Two","Three"];

var arrtooo = arr.concat();

arrtooo[1] = "set Map To";

document.writeln("数组的原始值：" + arr + "<br />");//Export:数组的原始值：One,Two,Three

document.writeln("数组的新值：" + arrtooo + "<br />");//Export:数组的新值：One,set Map To,Three

var a={name:'yy',age:26};

var b=new Object();

b.name=a.name;

b.age=a.age;

a.name='xx';

console.log(b);//Object { name="yy", age=26}

console.log(a);//Object { name="xx", age=26}

var deepCopy= function(source) {

var result={};

for (var key in source) {

      result[key] = typeof source[key]===’object’? deepCoyp(source[key]): source[key];

   }

   return result;

}

const newObj = JSON.parse(JSON.stringify(oldObj));

// 构造函数

function person(pname) {

  this.name = pname;

}

const Messi = new person('Messi');

// 函数

function say() {

  console.log('hi');

};

const oldObj = {

  a: say,

  b: new Array(1),

  c: new RegExp('ab+c', 'i'),

  d: Messi

};

const newObj = JSON.parse(JSON.stringify(oldObj));

// 无法复制函数

console.log(newObj.a, oldObj.a); // undefined [Function: say]

// 稀疏数组复制错误

console.log(newObj.b[0], oldObj.b[0]); // null undefined

// 无法复制正则对象

console.log(newObj.c, oldObj.c); // {} /ab+c/i

// 构造函数指向错误

console.log(newObj.d.constructor, oldObj.d.constructor); // [Function: Object] [Function: person]

/**

 * deep clone

 * @param  {[type]} parent object 需要进行克隆的对象

 * @return {[type]}        深克隆后的对象

 */

const clone = parent => {

  // 判断类型

  const isType = (obj, type) => {

    if (typeof obj !== "object") return false;

    const typeString = Object.prototype.toString.call(obj);

    let flag;

    switch (type) {

      case "Array":

        flag = typeString === "[object Array]";

        break;

      case "Date":

        flag = typeString === "[object Date]";

        break;

      case "RegExp":

        flag = typeString === "[object RegExp]";

        break;

      default:

        flag = false;

    }

    return flag;

  };

  // 处理正则

  const getRegExp = re => {

    var flags = "";

    if (re.global) flags += "g";

    if (re.ignoreCase) flags += "i";

    if (re.multiline) flags += "m";

    return flags;

  };

  // 维护两个储存循环引用的数组

  const parents = [];

  const children = [];

  const _clone = parent => {

    if (parent === null) return null;

    if (typeof parent !== "object") return parent;

    let child, proto;

    if (isType(parent, "Array")) {

      // 对数组做特殊处理

      child = [];

    } else if (isType(parent, "RegExp")) {

      // 对正则对象做特殊处理

      child = new RegExp(parent.source, getRegExp(parent));

      if (parent.lastIndex) child.lastIndex = parent.lastIndex;

    } else if (isType(parent, "Date")) {

      // 对Date对象做特殊处理

      child = new Date(parent.getTime());

    } else {

      // 处理对象原型

      proto = Object.getPrototypeOf(parent);

      // 利用Object.create切断原型链

      child = Object.create(proto);

    }

    // 处理循环引用

    const index = parents.indexOf(parent);

    if (index != -1) {

      // 如果父数组存在本对象,说明之前已经被引用过,直接返回此对象

      return children[index];

    }

    parents.push(parent);

    children.push(child);

    for (let i in parent) {

      // 递归

      child[i] = _clone(parent[i]);

    }

    return child;

  };

  return _clone(parent);

};