wanneer we een array moeten kopiëren, gebruikten we vaak slice. Maar met ES6 kunt u ook de spread operator gebruiken om een array te dupliceren. Vrij handig, juist 🤩

const sheeps = ;// Old wayconst cloneSheeps = sheeps.slice();// ES6 wayconst cloneSheepsES6 = ;

# Waarom kan ik = niet gebruiken om een Array te kopiëren?

omdat arrays in JS referentiewaarden zijn, dus als je probeert het te kopiëren met behulp van de zal het alleen de verwijzing naar de originele array kopiëren en niet de waarde van de array. Om een echte kopie van een array te maken, moet je over de waarde van de array kopiëren onder een nieuwe waardevariabele. Op die manier verwijst deze nieuwe array niet naar het oude array adres in het geheugen.

const sheeps = ;const fakeSheeps = sheeps;const cloneSheeps = ;console.log(sheeps === fakeSheeps);// true --> it's pointing to the same memory spaceconsole.log(sheeps === cloneSheeps);// false --> it's pointing to a new memory space

# probleem met referentiewaarden

Als u ooit Redux of een state management framework hebt behandeld. Je zult weten dat onveranderlijkheid super belangrijk is. Ik zal het kort uitleggen. Een onveranderlijk object is een object waarvan de toestand niet kan worden gewijzigd nadat het is gemaakt. Het probleem met JavaScript is dat arrays veranderlijk zijn. Dus dit kan gebeuren:

const sheeps = ;const sheeps2 = sheeps;sheeps2.push('🐺');console.log(sheeps2);// // Ahhh 😱 , our original sheeps have changed?!console.log(sheeps);// 

daarom moeten we een array klonen:

const sheeps = ;const sheeps2 = ;// Let's change our sheeps2 arraysheeps2.push('🐺');console.log(sheeps2);// // ✅ Yay, our original sheeps is not affected!console.log(sheeps);// 

# Mutable vs Immutable Data Types

Mutable:

• object
• array
• functie

onveranderlijk:

alle primitieven zijn onveranderlijk.

• string
• number
• boolean
• null
• undefined
• symbool

# alleen ondiep kopiëren

let op spread gaat slechts één niveau diep bij het kopiëren van een array. Dus als je probeert een multi-dimensionale arrays te kopiëren, zul je andere alternatieven moeten gebruiken.

const nums = , ];const cloneNums = ;// Let's change the first item in the first nested item in our cloned array.cloneNums = '👻';console.log(cloneNums);// , , ]// NOOooo, the original is also affectedconsole.log(nums);// , , ]

🤓 Hier is iets interessants wat ik geleerd heb. Ondiepe kopie betekent dat het eerste niveau wordt gekopieerd, er wordt verwezen naar diepere niveaus.

# communautaire invoer

# Array.from is een andere manier om Array te klonen

const sheeps = ;const cloneSheeps = Array.from(sheeps);

_dankt: @hakankaraduman _

• _@hakankaraduman :_ Ja, ik probeer geen spread te gebruiken, het verwart me bij het lezen van de code omdat het twee dingen doet, verspreiden of verzamelen volgens context

• CJ J : ik denk dat de beste manier is die het meest overeenkomt met de semantiek van de operatie. Ik geef de voorkeur aan Array.from