it-swarm.com.de

Array nach Wert kopieren

Wenn Sie ein Array in JavaScript in ein anderes Array kopieren:

var arr1 = ['a','b','c'];
var arr2 = arr1;
arr2.Push('d');  //Now, arr1 = ['a','b','c','d']

Mir wurde klar, dass arr2 sich auf dasselbe Array bezieht wie arr1 und nicht auf ein neues, unabhängiges Array. Wie kann ich das Array kopieren, um zwei unabhängige Arrays zu erhalten?

1501
Dan

Benutze das:

var newArray = oldArray.slice();

Grundsätzlich wird mit der Operation slice() das Array geklont und ein Verweis auf ein neues Array zurückgegeben. Beachten Sie auch Folgendes:

Für Referenzen, Strings und Zahlen (und nicht für das eigentliche Objekt) kopiert slice() Objektreferenzen in das neue Array. Sowohl das ursprüngliche als auch das neue Array beziehen sich auf dasselbe Objekt. Wenn sich ein Objekt, auf das verwiesen wird, ändert, sind die Änderungen sowohl für das neue als auch für das ursprüngliche Array sichtbar.

Grundelemente wie Zeichenfolgen und Zahlen sind unveränderlich. Änderungen an der Zeichenfolge oder Zahl sind daher nicht möglich. 

2408
Saket

In Javascript hängen die Techniken des tiefen Kopierens von den Elementen in einem Array ab.
Wir fangen dort an.

Drei Arten von Elementen

Elemente können sein: Literalwerte, Literalstrukturen oder Prototypen.

// 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 () {}"

Aus diesen Elementen können wir drei Arten von Arrays erstellen.

// 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 () {}];

Deep Copy-Techniken hängen von den drei Array-Typen ab

Basierend auf den Elementtypen im Array können wir verschiedene Techniken zum Tiefkopieren verwenden.

 Javascript deep copy techniques by element types

  • Array von Literalwerten (type1)
    . Die Techniken [...myArray], myArray.splice(0), myArray.slice() und myArray.concat() können verwendet werden, um Arrays mit Literalwerten (boolean, number und string) nur tief zu kopieren. wobei der Spread-Operator [...myArray] die beste Leistung aufweist ( https://measurethat.net/Benchmarks/Show/4281/0/spread-array-performance-vs-slice-splice-concat ).

  • Array von Literal-Werten (Typ 1) und Literal-Strukturen (Typ 2)
    .__ Die JSON.parse(JSON.stringify(myArray))-Technik kann verwendet werden, um Literalwerte (boolean, number, string) und Literalstrukturen (Array, Objekt) tief zu kopieren, nicht jedoch Prototypobjekte.

  • Alle Arrays (type1, type2, type3)
    Die jQuery $.extend(myArray)-Technik kann verwendet werden, um alle Array-Typen tief zu kopieren. Bibliotheken wie Underscore und Lo-Bindestrich bieten ähnliche Deep-Copy-Funktionen wie jQuery$.extend(), weisen jedoch eine geringere Leistung auf. Überraschenderweise hat $.extend() eine höhere Leistung als die JSON.parse(JSON.stringify(myArray))-Technik http://jsperf.com/js-deep-copy/15 .
    Und für Entwickler, die Bibliotheken von Drittanbietern (wie jQuery) scheuen, können Sie die folgende benutzerdefinierte Funktion verwenden. Das hat eine höhere Leistung als $ .extend und kopiert alle Arrays tief.

function copy(aObject) {
  if (!aObject) {
    return aObject;
  }

  let v;
  let bObject = Array.isArray(aObject) ? [] : {};
  for (const k in aObject) {
    v = aObject[k];
    bObject[k] = (typeof v === "object") ? copy(v) : v;
  }

  return bObject;
}

Um die Frage zu beantworten ...

Frage 

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

Mir wurde klar, dass sich arr2 auf dasselbe Array bezieht wie arr1 und nicht auf ein neues, unabhängiges Array. Wie kann ich das Array kopieren, um zwei unabhängige Arrays?

Antworten 

Da arr1 ein Array von Literalwerten ist (boolesche Werte, Zahlen oder Zeichenfolgen), können Sie jede der oben beschriebenen Deep Copy-Techniken verwenden, bei denen der Spread-Operator ... die höchste Leistung aufweist.

// Highest performance for deep copying literal values
arr2 = [...arr1];

// Any of these techniques will deep copy literal values as well,
//   but with lower performance.
arr2 = arr1.slice();
arr2 = arr1.splice(0);
arr2 = arr1.concat();
arr2 = JSON.parse(JSON.stringify(arr1));
arr2 = $.extend(true, [], arr1); // jQuery.js needed
arr2 = _.extend(arr1); // Underscore.js needed
arr2 = _.cloneDeep(arr1); // Lo-dash.js needed
arr2 = copy(arr1); // Custom-function needed - as provided above
435
tfmontague

Sie können Array-Spreads ... verwenden, um Arrays zu kopieren.

const itemsCopy = [...items];

Auch wenn Sie ein neues Array erstellen möchten, wobei das vorhandene Array Teil davon ist:

var parts = ['shoulders', 'knees'];
var lyrics = ['head', ...parts, 'and', 'toes'];

Array-Spreads sind jetzt wird in allen gängigen Browsern unterstützt , wenn Sie jedoch ältere Unterstützung benötigen, verwenden Sie TypeScript oder Babel und kompilieren Sie es mit ES5.

Weitere Informationen zu Spreads

169
Luke Femur

Keine jQuery erforderlich ... Funktionsbeispiel

var arr2 = arr1.slice()

Dadurch wird das Array von der Startposition 0 bis zum Ende des Arrays kopiert.

Es ist wichtig zu beachten, dass es für Grundtypen (Zeichenfolge, Anzahl usw.) wie erwartet funktioniert und auch das erwartete Verhalten für Referenztypen erläutert wird.

Wenn Sie ein Array von Referenztypen haben, sagen Sie zum Beispiel Object. Das Array will wird kopiert, aber beide Arrays enthalten Verweise auf dieselben Object's. In diesem Fall scheint es, als würde das Array durch Verweis kopiert, obwohl das Array tatsächlich kopiert wird.

150
jondavidjohn

Eine Alternative zu slice ist concat , die auf zwei Arten verwendet werden kann. Die erste davon ist vielleicht lesbarer, da das beabsichtigte Verhalten sehr klar ist:

var array2 = [].concat(array1);

Die zweite Methode ist:

var array2 = array1.concat();

Cohen (in den Kommentaren) wies darauf hin, dass diese letztere Methode eine bessere Leistung hat .

Das funktioniert so, dass die concat-Methode ein neues Array erstellt, das aus den Elementen des Objekts besteht, für das es aufgerufen wird, gefolgt von den Elementen aller Arrays, die als Argumente an es übergeben werden. Wenn keine Argumente übergeben werden, wird das Array einfach kopiert.

Lee Penkman weist auch in den Kommentaren darauf hin, dass, falls die Möglichkeit besteht, dass array1undefined ist, ein leeres Array wie folgt zurückgegeben werden kann:

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

Oder für die zweite Methode:

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

Beachten Sie, dass dies auch mit slice: var array2 = (array1 || []).slice(); möglich ist.

70
Ninjakannon

So habe ich es gemacht, nachdem ich viele Ansätze ausprobiert hatte:

var newArray = JSON.parse(JSON.stringify(orgArray));

Dadurch wird eine neue tiefe Kopie erstellt, die nicht mit der ersten zusammenhängt (nicht mit einer flachen Kopie).

Natürlich werden dadurch auch keine Ereignisse und Funktionen geklont, aber Sie können dies in einer Zeile tun, und es kann für alle Arten von Objekten (Arrays, Strings, Zahlen, Objekte ...) verwendet werden.

51
Chtiwi Malek

Einige der genannten Methoden funktionieren gut, wenn mit einfachen Datentypen wie number oder string gearbeitet wird. Wenn das Array jedoch andere Objekte enthält, schlagen diese Methoden fehl. Wenn wir versuchen, ein Objekt von einem Array an ein anderes zu übergeben, wird es als Referenz und nicht als Objekt übergeben.

Fügen Sie den folgenden Code in Ihre JavaScript-Datei ein:

Object.prototype.clone = function() {
    var newObj = (this instanceof Array) ? [] : {};
    for (i in this) {
        if (i == 'clone') 
            continue;
        if (this[i] && typeof this[i] == "object") {
            newObj[i] = this[i].clone();
        } 
        else 
            newObj[i] = this[i]
    } return newObj;
};

Und einfach verwenden

var arr1 = ['val_1','val_2','val_3'];
var arr2 = arr1.clone()

Es wird klappen.

18
sarvesh singh

Ab ES2015

var arr2 = [...arr1];
15
Boopathi Rajaa

Ich persönlich denke, dass Array.from eine lesbarere Lösung ist. Übrigens, hüten Sie sich vor der Browser-Unterstützung.

//clone
let x = [1,2,3];
let y = Array.from(x);

//deep clone
let clone = arr => Array.from(arr,item => Array.isArray(item) ? clone(item) : item);
let x = [1,[],[[]]];
let y = clone(x);
14
Lewis

Wichtig!

Die meisten Antworten hier gelten für besondere Fälle.

Wenn Sie sich nicht für tief verschachtelte Objekte und Requisiten interessieren, verwenden Sie ( ES6 ):

let clonedArray = [...array]

aber wenn du Deep Clone machen willst, benutze dies stattdessen:

let cloneArray = JSON.parse(JSON.stringify(array))


Für Benutzer von lodash:

let clonedArray = _.clone(array)Dokumentation

und

let clonedArray = _.cloneDeep(array)Dokumentation

13
ulou

Wenn Sie sich in einer Umgebung von ECMAScript 6 befinden und den Spread-Operator verwenden, können Sie dies folgendermaßen tun:

var arr1 = ['a','b','c'];
var arr2 = [...arr1]; //copy arr1
arr2.Push('d');

console.log(arr1)
console.log(arr2)
<script src="http://www.wzvang.com/snippet/ignore_this_file.js"></script>

Hinzufügen zur Lösung von array.slice (); Seien Sie sich bewusst, dass bei mehrdimensionalem Array Sub-Arrays durch Verweise kopiert werden .. Was Sie tun können, ist, jedes Sub-Array einzeln zu schleifen und zu schneiden 

var arr = [[1,1,1],[2,2,2],[3,3,3]];
var arr2 = arr.slice();

arr2[0][1] = 55;
console.log(arr2[0][1]);
console.log(arr[0][1]);

function arrCpy(arrSrc, arrDis){
 for(Elm in arrSrc){
  arrDis.Push(arrSrc[Elm].slice());
}
}

var arr3=[];
arrCpy(arr,arr3);

arr3[1][1] = 77;

console.log(arr3[1][1]);
console.log(arr[1][1]);

dasselbe gilt für ein Array von Objekten, diese werden durch Verweis kopiert. Sie müssen sie manuell kopieren

9
A.Zaben

Wie wir in Javascript wissen, sind Arrays und Objekte referenziert, aber wie können wir das Array kopieren, ohne das ursprüngliche Array später zu ändern? 

Hier sind einige Möglichkeiten, dies zu tun:

Stellen Sie sich vor, wir haben dieses Array in Ihrem Code:

var arr = [1, 2, 3, 4, 5];

1) Durchlaufen Sie das Array in einer Funktion und geben Sie ein neues Array wie folgt zurück:

 function newArr(arr) {
      var i=0, res = [];
      while(i<arr.length){
       res.Push(arr[i]);
        i++;
       }
   return res;
 }

2) Mit der Slice-Methode wird mit slice ein Teil des Arrays in Scheiben geschnitten. Dabei wird ein Teil des Arrays in Scheiben geschnitten, ohne dass das Original berührt wird Array und im Grunde eine vollständige Kopie des Arrays, so können wir leicht sagen:

var arr2 = arr.slice(); // make a copy of the original array

3) Auch die Kontaktmethode, dies ist das Zusammenführen von zwei Arrays, aber wir können nur eines von Arrays angeben und dies macht im Grunde eine Kopie der Werte im neuen kontaktierten Array:

var arr2 = arr.concat();

4) Auch die Methode "stringify" und "parse" wird nicht empfohlen, kann jedoch eine einfache Methode zum Kopieren von Arrays und Objekten sein:

var arr2 = JSON.parse(JSON.stringify(arr));

5) Array.from-Methode, dies wird nicht allgemein unterstützt. Überprüfen Sie vor der Verwendung die Unterstützung in verschiedenen Browsern:

const arr2 = Array.from(arr);

6) ECMA6-Methode, auch nicht vollständig unterstützt, aber babelJs kann Ihnen helfen, wenn Sie transpilieren möchten:

const arr2 = [...arr];
6
Alireza

Kopie eines mehrdimensionalen Arrays/Objekts erstellen:

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;
}

Vielen Dank an James Padolsey für diese Funktion.

Quelle: Hier

4
ink

In meinem speziellen Fall musste ich sicherstellen, dass das Array intakt blieb. Dies funktionierte für mich:

// Empty array
arr1.length = 0;
// Add items from source array to target array
for (var i = 0; i < arr2.length; i++) {
    arr1.Push(arr2[i]);
}
4
Brent Keller

Wenn Sie ein Array mit dem Zuweisungsoperator (=) kopieren möchten, erstellt es keine Kopie, es kopiert lediglich den Zeiger/die Referenz auf das Array. Zum Beispiel:

const oldArr = [1,2,3];

const newArr = oldArr;  // now oldArr points to the same place in memory 

console.log(oldArr === newArr);  // Points to the same place in memory thus is true

const copy = [1,2,3];

console.log(copy === newArr);  // Doesn't point to the same place in memory and thus is false

Wenn wir Daten transformieren, möchten wir oft, dass unsere ursprüngliche Datenstruktur (z. B. Array) intakt bleibt. Wir machen dies, indem wir eine exakte Kopie unseres Arrays erstellen, damit dieses umgewandelt werden kann, während das ursprüngliche Array intakt bleibt.

Möglichkeiten zum Kopieren eines Arrays:

const oldArr = [1,2,3];

// Uses the spread operator to spread out old values into the new array literal
const newArr1 = [...oldArr];

// Slice with no arguments returns the newly copied Array
const newArr2 = oldArr.slice();

// Map applies the callback to every element in the array and returns a new array
const newArr3 = oldArr.map((el) => el);

// Concat is used to merge arrays and returns a new array. Concat with no args copies an array
const newArr4 = oldArr.concat();

// Object.assign can be used to transfer all the properties into a new array literal
const newArr5 = Object.assign([], oldArr);

// Creating via the Array constructor using the new keyword
const newArr6 = new Array(...oldArr);

// For loop
function clone(base) {
	const newArray = [];
    for(let i= 0; i < base.length; i++) {
	    newArray[i] = base[i];
	}
	return newArray;
}

const newArr7 = clone(oldArr);

console.log(newArr1, newArr2, newArr3, newArr4, newArr5, newArr6, newArr7);

Seien Sie vorsichtig, wenn Arrays oder Objekte verschachtelt sind:

Wenn Arrays verschachtelt sind, werden die Werte als Referenz kopiert. Hier ein Beispiel, wie dies zu Problemen führen kann:

let arr1 = [1,2,[1,2,3]]

let arr2 = [...arr1];

arr2[2][0] = 5;  // we change arr2

console.log(arr1);  // arr1 is also changed because the array inside arr1 was copied by reference

Verwenden Sie diese Methoden daher nicht, wenn sich Objekte oder Arrays in Ihrem Array befinden, die Sie kopieren möchten. Verwenden Sie diese Methoden nur für Arrays von Primitiven. 

Wenn Sie ein Javascript-Array tiefklonen möchten, verwenden Sie JSON.parse in Verbindung mit JSON.stringify wie folgt:

let arr1 = [1,2,[1,2,3]]

let arr2 = JSON.parse(JSON.stringify(arr1)) ;

arr2[2][0] = 5;

console.log(arr1);  // now I'm not modified because I'm a deep clone

Leistung beim Kopieren:

Welches wählen wir also für eine optimale Leistung. Es stellt sich heraus, dass die for-Schleife mit der umfassendsten Methode die höchste Leistung aufweist. Verwenden Sie die for-Schleife für wirklich CPU-intensives Kopieren (große/viele Arrays). 

Danach hat die .slice()-Methode auch eine anständige Leistung und ist weniger ausführlich und für den Programmierer einfacher zu implementieren. Ich schlage vor, .slice() für das tägliche Kopieren von Arrays zu verwenden, die nicht sehr CPU-intensiv sind. Vermeiden Sie auch die Verwendung von JSON.parse(JSON.stringify(arr)) (viel Overhead), wenn kein tiefer Klon erforderlich ist und Leistung ein Problem ist.

Quellenleistungsprüfung

3

Dan, du musst keine ausgefallenen Tricks anwenden. Dazu müssen Sie lediglich eine Kopie von arr1 erstellen.

var arr2 = new Array(arr1);

Jetzt arr1 und arr2 sind zwei verschiedene Arrayvariablen, die in getrennten Stapeln gespeichert sind. Checkt dies auf jsfiddle aus .

3
DragoRaptor

Hier sind einige weitere Möglichkeiten zum Kopieren:

const array = [1,2,3,4];

const arrayCopy1 = Object.values(array);
const arrayCopy2 = Object.assign([], array);
const arrayCopy3 = array.map(i => i);
const arrayCopy4 = Array.of(...array );

2
ganesh phirke

Kurze Beispiele:

  1. Bei Elementen im Array handelt es sich um primitive Typen (Zeichenfolge, Anzahl usw.).

var arr1 = ['a','b','c'];
// arr1 and arr2 are independent and primitive elements are stored in 
// different places in the memory
var arr2 = arr1.slice(); 
arr2.Push('d');
console.log(arr1); // [ 'a', 'b', 'c' ]
console.log(arr2); // [ 'a', 'b', 'c', 'd' ]

  1. Wenn Elemente im Array Objektliterale sind, wird ein anderes Array ({}, [])

var arr1 = [{ x: 'a', y: 'b'}, [1, 2], [3, 4]];
// arr1 and arr2 are independent and reference's/addresses are stored in different
// places in the memory. But those reference's/addresses points to some common place
// in the memory.
var arr2 = arr1.slice(); 
arr2.pop();      // OK - don't affect arr1 bcos only the address in the arr2 is
                 // deleted not the data pointed by that address
arr2[0].x = 'z'; // not OK - affect arr1 bcos changes made in the common area 
                 // pointed by the addresses in both arr1 and arr2
arr2[1][0] = 9;	 // not OK - same above reason

console.log(arr1); // [ { x: 'z', y: 'b' }, [ 9, 2 ], [ 3, 4 ] ]
console.log(arr2); // [ { x: 'z', y: 'b' }, [ 9, 2 ] ]

  1. Lösung für 2 : Deep Copy von Element nach Element

var arr1 = [{ x: 'a', y: 'b'}, [1, 2], [3, 4]];
arr2 = JSON.parse(JSON.stringify(arr1));
arr2.pop();	  // OK - don't affect arr1
arr2[0].x = 'z';  // OK - don't affect arr1
arr2[1][0] = 9;	  // OK - don't affect arr1

console.log(arr1); // [ { x: 'a', y: 'b' }, [ 1, 2 ], [ 3, 4 ] ]
console.log(arr2); // [ { x: 'z', y: 'b' }, [ 9, 2 ] ]

2
SridharKritha

Die jQuery-Tiefkopie kann wie folgt erstellt werden:

var arr2 = $.extend(true, [], arr1);
2
Alex Tsurika
let a = [1,2,3];

Jetzt können Sie eine der folgenden Aktionen ausführen, um eine Kopie eines Arrays zu erstellen.

let b = Array.from(a); 

OR

let b = [...a];

OR

let b = new Array(...a); 

OR

let b = a.slice(); 

OR

let b = a.map(e => e);

Nun, wenn ich a ändere,

a.Push(5); 

Dann ist a [1,2,3,5], aber b ist immer noch [1,2,3], da es eine andere Referenz hat.

Aber ich denke, in allen oben genannten Methoden Array.from ist besser und hauptsächlich zum Kopieren eines Arrays gedacht.

2
Nitesh Ranjan

Sie können den ES6-Spread-Operator auch zum Kopieren von Arrays verwenden

var arr=[2,3,4,5];
var copyArr=[...arr];
2
ankur kushwaha

Wenn Ihr Array Elemente des primitiven Datentyps enthält, wie int, char oder string usw., können Sie eine dieser Methoden verwenden, die eine Kopie des ursprünglichen Arrays zurückgibt, z. slice () oder .map () oder Spread-Operator (dank ES6).

new_array = old_array.slice()

oder

new_array = old_array.map((elem) => elem)

oder

const new_array = new Array(...old_array);

ABER Wenn Ihr Array komplexe Elemente enthält, z. B. Objekte (oder Arrays) oder mehr verschachtelte Objekte, müssen Sie sicherstellen, dass dies der Fall ist Wenn Sie eine Kopie aller Elemente von der obersten Ebene bis zur letzten Ebene erstellen, wird ansonsten die Referenz der inneren Objekte verwendet. Dies bedeutet, dass das Ändern von Werten in object_elements in new_array immer noch das old_array beeinflusst. Sie können diese Kopiermethode auf jeder Ebene als DEEP COPY Des alten Arrays aufrufen.

Für tiefes Kopieren können Sie die oben genannten Methoden für primitive Datentypen auf jeder Ebene verwenden, abhängig vom Datentyp. Sie können diese kostspielige Methode (siehe unten) zum Erstellen einer tiefen Kopie verwenden, ohne viel zu tun Arbeit.

var new_array = JSON.parse(JSON.stringify(old_array));

Es gibt viele andere Methoden, die Sie je nach Ihren Anforderungen verwenden können. Ich habe nur einige davon erwähnt, um eine allgemeine Vorstellung davon zu geben, was passiert, wenn wir versuchen, ein Array in das andere durch Wert zu kopieren.

2
Abhinav1602

Wenn Sie eine neue Kopie eines Objekts oder Arrays erstellen möchten, müssen Sie die Eigenschaften des Objekts oder die Elemente des Arrays explizit kopieren. Beispiel:

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

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

Sie können in Google nach weiteren Informationen zu unveränderlichen primitiven Werten und veränderlichen Objektreferenzen suchen.

2
Sotiris

Ich persönlich würde diesen Weg bevorzugen JSON.parse (JSON.stringify (originalObject));

1
Diemauerdk

Sie könnten ES6 mit Spread Operator verwenden, es ist einfacher.

arr2 = [...arr1];

Es gibt Einschränkungen..check docs Spread Syntax @ Mozilla

1
BluePie

So können Sie Arrays von Primitiven mit variabler Tiefe erstellen:

// If a is array: 
//    then call cpArr(a) for each e;
//    else return a

const cpArr = a => Array.isArray(a) && a.map(e => cpArr(e)) || a;

let src = [[1,2,3], [4, ["five", "six", 7], true], 8, 9, false];
let dst = cpArr(src);

https://jsbin.com/xemazog/edit?js,console

1
G.Denis

Es gibt den neu eingeführten Array.from, aber zum Zeitpunkt der Erstellung dieses Dokuments wird er leider nur von aktuellen Firefox-Versionen (32 und höher) unterstützt. Es kann einfach wie folgt verwendet werden:

var arr1 = [1, 2, 3];
console.log(Array.from(arr1)); // Logs: [1, 2, 3]

Referenz: Hier

Oder Array.prototype.map kann mit einer Identitätsfunktion verwendet werden:

function identity(param)
{
    return param;
}

var arr1 = [1, 2, 3],
    clone = arr1.map(identity);

Referenz: Hier

1
Ashraf Sabry

Sie können das auf folgende Weise tun:
arr2 = arr1.map(x => Object.assign({}, x));

1
Harunur Rashid

Hier ist eine Variante:

var arr1=['a', 'b', 'c'];
var arr2=eval(arr1.toSource());
arr2.Push('d');
console.log('arr1: '+arr1+'\narr2: '+arr2);
/*
 *  arr1: a,b,c
 *  arr2: a,b,c,d
 */
1
Zyox

Einfach schreiben:

arr2 = arr1.concat();

Sie erzeugen ein neues Array mit einer Kopie des ersten. Beachten Sie, dass dies ein funktionaler Weg ist, ein Element in das Array zu schieben.

Wenn Ihr Code auf ES6 basiert, können Sie auch den Spread-Operator verwenden:

arr2 = [...arr1];
0
alejoko

Für ein ES6-Array, das Objekte enthält

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

Primitive Werte werden immer an ihrem Wert übergeben (kopiert). Zusammengesetzte Werte werden jedoch als Referenz übergeben.

Wie kopieren wir diesen Arr? 

let arr = [1,2,3,4,5];

Kopieren Sie ein Array in ES6 

let arrCopy = [...arr]; 

Kopieren Sie ein n-Array in ES5 

let arrCopy = arr.slice(); 
let arrCopy = [].concat(arr);

Warum ist "let arrCopy = arr" nicht am Wert vorbei?

Die Übergabe einer Variablen an eine andere für zusammengesetzte Werte wie Object/Array verhält sich unterschiedlich. Mit einem Operator asign für Copand-Werte übergeben wir einen Verweis auf ein Objekt. Deshalb ändern sich die Werte beider Arrays beim Entfernen/Hinzufügen von Arr-Elementen.

Ausnahmen: 

arrCopy[1] = 'adding new value this way will unreference';

Wenn Sie der Variablen einen neuen Wert zuweisen, ändern Sie den Verweis selbst und er hat keine Auswirkungen auf das ursprüngliche Objekt/Array. 

Weiterlesen

0
DevWL