制作多维数组/对象的副本：

function deepCopy(obj) {
   if (Object.prototype.toString.call(obj) === '[object Array]') {
      var out = [], i = 0, len = obj.length;
      for ( ; i < len; i++ ) {
         out[i] = arguments.callee(obj[i]);
      }
      return out;
   }
   if (typeof obj === 'object') {
      var out = {}, i;
      for ( i in obj ) {
         out[i] = arguments.callee(obj[i]);
      }
      return out;
   }
   return obj;
}

感谢詹姆斯·帕多尔西担任这一职务。

来源：此处

不需要jQuery。。。工作示例

var arr2 = arr1.slice()

这将从起始位置0到阵列末端复制阵列。

重要的是要注意，它将按照原始类型（字符串、数字等）的预期工作，并解释引用类型的预期行为。。。

如果您有一个引用类型数组，那么就说Object类型。将复制该数组，但这两个数组都将包含对同一对象的引用。因此，在这种情况下，即使实际复制了数组，也似乎通过引用复制了数组。

切片的另一种选择是凹面，可以用两种方式。第一个可能更容易理解，因为预期行为非常清楚：

var array2 = [].concat(array1);

第二种方法是：

var array2 = array1.concat();

科恩（在评论中）指出，后一种方法具有更好的性能。

其工作方式是concat方法创建一个新数组，该数组由调用它的对象中的元素组成，后跟作为参数传递给它的任何数组的元素。因此，当没有传递参数时，它只是复制数组。

Lee Penkman也在评论中指出，如果array1有可能未定义，可以返回一个空数组，如下所示：

var array2 = [].concat(array1 || []);

或者，对于第二种方法：

var array2 = (array1 || []).concat();

请注意，您也可以使用slice:var array2=（array1||[]）.slice（）；执行此操作；。

对于包含对象的ES6阵列

cloneArray(arr) {
    return arr.map(x => ({ ...x }));
}

在Javascript中，深度复制技术依赖于数组中的元素。让我们从这里开始。

三种类型的元素

元素可以是：文字值、文字结构或原型。

// Literal values (type1)
const booleanLiteral = true;
const numberLiteral = 1;
const stringLiteral = 'true';

// Literal structures (type2)
const arrayLiteral = [];
const objectLiteral = {};

// Prototypes (type3)
const booleanPrototype = new Bool(true);
const numberPrototype = new Number(1);
const stringPrototype = new String('true');
const arrayPrototype = new Array();
const objectPrototype = new Object(); // or `new function () {}

从这些元素中，我们可以创建三种类型的数组。

// 1) Array of literal-values (boolean, number, string) 
const type1 = [ true, 1, "true" ];

// 2) Array of literal-structures (array, object)
const type2 = [ [], {} ];

// 3) Array of prototype-objects (function)
const type3 = [ function () {}, function () {} ];

深度复制技术取决于三种阵列类型

根据数组中元素的类型，我们可以使用各种技术进行深度复制。

深度复制技术

基准

https://www.measurethat.net/Benchmarks/Show/17502/0/deep-copy-comparison

文字值数组（类型1）[…myArray]、myArray.splice（0）、myArrax.slice（）和myArray.concat（）技术可用于深度复制仅具有文字值（布尔值、数字和字符串）的数组；其中slice（）在Chrome中具有最高的性能，并且扩展。。。在Firefox中具有最高的性能。文本值（类型1）和文本结构（类型2）的数组JSON.parse（JSON.stringify（myArray））技术可用于深度复制文本值（布尔值、数字、字符串）和文本结构（数组、对象），但不能复制原型对象。所有数组（类型1、类型2、类型3）Lo-dash-cloneDeep（myArray）或jQuery-extend（true，[]，myArray）技术可用于深度复制所有数组类型。其中Lodash cloneDeep（）技术具有最高的性能。对于那些避免使用第三方库的用户，下面的自定义函数将深度复制所有数组类型，性能低于cloneDeep（），性能高于extend（true）。

function copy(aObject) {
  // Prevent undefined objects
  // if (!aObject) return aObject;

  let bObject = Array.isArray(aObject) ? [] : {};

  let value;
  for (const key in aObject) {

    // Prevent self-references to parent object
    // if (Object.is(aObject[key], aObject)) continue;
    
    value = aObject[key];

    bObject[key] = (typeof value === "object") ? copy(value) : value;
  }

  return bObject;
}

所以要回答这个问题。。。

问题

var arr1 = ['a','b','c'];
var arr2 = arr1;

我意识到arr2指的是与arr1相同的数组，而不是一个新的独立数组。如何复制阵列以获得两个独立的阵列？

答复

因为arr1是一个文本值数组（布尔值、数字或字符串），所以可以使用上面讨论的任何深度复制技术，其中slice（）和spread。。。具有最高的性能。

arr2 = arr1.slice();
arr2 = [...arr1];
arr2 = arr1.splice(0);
arr2 = arr1.concat();
arr2 = JSON.parse(JSON.stringify(arr1));
arr2 = copy(arr1); // Custom function needed, and provided above
arr2 = _.cloneDeep(arr1); // Lo-dash.js needed
arr2 = jQuery.extend(true, [], arr1); // jQuery.js needed

如果要创建对象或数组的新副本，必须显式复制对象或数组元素的财产，例如：

var arr1 = ['a','b','c'];
var arr2 = [];

for (var i=0; i < arr1.length; i++) {
   arr2[i] = arr1[i];
}

您可以在Google上搜索有关不可变原始值和可变对象引用的更多信息。