JavaScript’te Nesneleri Kopyalama: Derinlemesine Bir Rehber
JavaScript’te nesnelerle çalışırken, bazen bir nesnenin tamamen bağımsız bir kopyasına ihtiyaç duyarız. Bu, orijinal nesnenin değiştirilmeden kalmasını sağlamak, olası yan etkileri önlemek veya immutability (değişmezlik) prensiplerine uymak için kritik öneme sahiptir. Ancak JavaScript’te nesneleri kopyalamak, basit bir atama işlemi kadar düz değildir. Bunun nedeni, JavaScript’in veri türlerini ele alış biçimindeki temel bir ayrımdır: ilkel (primitive) türler ve referans (reference) türler. Bu makalede, JavaScript’te nesneleri kopyalamanın inceliklerini, sığ (shallow) ve derin (deep) kopyalama arasındaki farkları, çeşitli kopyalama yöntemlerini ve her birinin avantajlarını, dezavantajlarını ve kullanım senaryolarını ayrıntılı olarak inceleyeceğiz.
JavaScript’te Veri Türleri ve Kopyalamanın Temelleri
JavaScript’te kopyalama kavramını anlamak için, ilkel ve referans veri türlerinin nasıl çalıştığını bilmek esastır.
İlkel (Primitive) Veri Türleri
string, number, boolean, null, undefined, symbol ve bigint gibi ilkel veri türleri, değerleriyle doğrudan bellekte saklanır. Bir ilkel değeri başka bir değişkene atadığınızda, o değerin tam bir kopyası oluşturulur.
let sayi1 = 10;
let sayi2 = sayi1; // sayi1'in değeri olan 10'un bir kopyası sayi2'ye atanır.
sayi2 = 20;
console.log(sayi1); // Çıktı: 10 (sayi1 değişmedi)
console.log(sayi2); // Çıktı: 20Burada sayi2‘yi değiştirmek sayi1‘i etkilemez, çünkü sayi2 kendi bağımsız 10 kopyasına sahiptir.
Referans (Reference) Veri Türleri
Nesneler (Object), diziler (Array) ve fonksiyonlar (Function) gibi referans veri türleri ise doğrudan değeri değil, değerin bellekteki adresini (referansını) tutar. Bir referans türünü başka bir değişkene atadığınızda, kopyalanan şey nesnenin kendisi değil, bellekteki adresidir. Bu, her iki değişkenin de aynı temel nesneyi işaret ettiği anlamına gelir.
let nesne1 = { ad: "Ali", yas: 30 };
let nesne2 = nesne1; // nesne1'in referansı (bellek adresi) nesne2'ye atanır.
nesne2.yas = 31;
console.log(nesne1.yas); // Çıktı: 31 (nesne1 de değişti!)
console.log(nesne2.yas); // Çıktı: 31Bu örnekte, nesne2‘nin yas özelliğini değiştirdiğimizde, nesne1‘in yas özelliği de değişir. Çünkü nesne1 ve nesne2 aslında bellekteki aynı nesneyi gösteren iki farklı etikettir. Bu durum, beklenmeyen yan etkilere yol açabilir ve özellikle büyük uygulamalarda hatalara neden olabilir. Bu nedenle, nesnelerin bağımsız kopyalarını oluşturmak için özel yöntemlere ihtiyaç duyarız. İşte burada sığ ve derin kopyalama devreye girer.
Sığ (Shallow) Kopyalama
Sığ kopyalama, bir nesnenin yalnızca en üst düzeydeki özelliklerini kopyalar. Eğer nesnenin içinde başka nesneler (iç içe geçmiş nesneler) veya diziler varsa, bu iç içe geçmiş yapılar orijinal nesneyle aynı referansı paylaşmaya devam eder. Yani, sığ bir kopyanın içindeki bir alt nesneyi değiştirirseniz, orijinal nesnedeki karşılık gelen alt nesne de değişir.
Sığ kopyalama için JavaScript’te çeşitli yöntemler bulunur:
1. Object.assign()
Object.assign() metodu, bir veya daha fazla kaynak nesnenin tüm numaralandırılabilir kendi özelliklerini hedef nesneye kopyalamak için kullanılır. İlk argüman hedef nesne, diğerleri ise kaynak nesnelerdir. Yeni bir nesne oluşturmak için boş bir nesneyi hedef olarak kullanabiliriz:
const orijinalNesne = {
a: 1,
b: { c: 2 },
d: [3, 4]
};
const sığKopya = Object.assign({}, orijinalNesne);
console.log(sığKopya); // { a: 1, b: { c: 2 }, d: [3, 4] }
// En üst düzey özellik değişimi
sığKopya.a = 10;
console.log(orijinalNesne.a); // 1 (orijinal değişmedi)
console.log(sığKopya.a); // 10
// İç içe geçmiş nesne değişimi (sorun burada başlar)
sığKopya.b.c = 20;
console.log(orijinalNesne.b.c); // 20 (orijinal de değişti!)
console.log(sığKopya.b.c); // 20
// İç içe geçmiş dizi değişimi
sığKopya.d.push(5);
console.log(orijinalNesne.d); // [3, 4, 5] (orijinal de değişti!)
console.log(sığKopya.d); // [3, 4, 5]Görüldüğü gibi, a özelliği ilkel bir değer olduğu için bağımsız kopyalandı. Ancak b ve d özellikleri referans türleri olduğu için, sığKopya ve orijinalNesne hala aynı iç içe geçmiş nesneleri ve dizileri paylaşıyorlar.
2. Spread Söz Dizimi (...)
ES6 ile birlikte gelen spread söz dizimi (yayma operatörü), nesneleri ve dizileri sığ bir şekilde kopyalamak için popüler ve kısa bir yoldur.
Nesneler için:
const orijinalNesne = {
a: 1,
b: { c: 2 },
d: [3, 4]
};
const sığKopya = { ...orijinalNesne };
console.log(sığKopya); // { a: 1, b: { c: 2 }, d: [3, 4] }
// Aynı Object.assign() örneğindeki gibi davranır:
sığKopya.a = 10;
sığKopya.b.c = 20;
sığKopya.d.push(5);
console.log(orijinalNesne.a); // 1
console.log(orijinalNesne.b.c); // 20 (değişti)
console.log(orijinalNesne.d); // [3, 4, 5] (değişti)Diziler için:
Dizileri kopyalamak için de spread söz dizimi kullanılabilir.
const orijinalDizi = [1, 2, { a: 3 }];
const sığKopyaDizi = [...orijinalDizi];
sığKopyaDizi[0] = 10;
sığKopyaDizi[2].a = 30;
console.log(orijinalDizi[0]); // 1
console.log(sığKopyaDizi[0]); // 10
console.log(orijinalDizi[2].a); // 30 (değişti)
console.log(sığKopyaDizi[2].a); // 30Spread söz dizimi, Object.assign()‘e göre daha okunabilir ve modern bir yaklaşımdır. Ancak sığ kopyalama sınırlamaları aynı şekilde geçerlidir.
3. Array.prototype.slice()
slice() metodu, bir dizinin sığ bir kopyasını oluşturmak için kullanılabilir. Parametre belirtilmezse, tüm dizinin bir kopyasını döndürür.
const orijinalDizi = [1, 2, { a: 3 }];
const sığKopyaDizi = orijinalDizi.slice();
sığKopyaDizi[0] = 10;
sığKopyaDizi[2].a = 30;
console.log(orijinalDizi[0]); // 1
console.log(sığKopyaDizi[0]); // 10
console.log(orijinalDizi[2].a); // 30 (değişti)
console.log(sığKopyaDizi[2].a); // 30slice() da tıpkı diğer sığ kopyalama yöntemleri gibi, iç içe geçmiş referans türlerini kopyalamaz, sadece referanslarını kopyalar.
4. Array.from()
Array.from() metodu da bir dizi benzeri veya yinelenebilir bir nesneden yeni, sığ kopyalanmış bir Array örneği oluşturur.
const orijinalDizi = [1, 2, { a: 3 }];
const sığKopyaDizi = Array.from(orijinalDizi);
sığKopyaDizi[0] = 10;
sığKopyaDizi[2].a = 30;
console.log(orijinalDizi[0]); // 1
console.log(sığKopyaDizi[0]); // 10
console.log(orijinalDizi[2].a); // 30 (değişti)
console.log(sığKopyaDizi[2].a); // 30Array.from() da slice() gibi sığ bir kopyalama yapar.
Sığ Kopyalamanın Özeti:
Sığ kopyalama, yalnızca en üst düzeydeki ilkel değerleri bağımsız olarak kopyalar. İç içe geçmiş nesneler veya diziler varsa, bunlar orijinal nesneyle referans olarak paylaşılmaya devam eder. Bu, basit nesneler veya iç içe geçmiş yapılarının değiştirilmesinin orijinali etkilemesinin sorun olmadığı durumlar için uygundur. Ancak çoğu zaman, tamamen bağımsız bir kopya isteriz. İşte bu noktada derin kopyalama devreye girer.
Derin (Deep) Kopyalama
Derin kopyalama, bir nesnenin tüm özelliklerini, iç içe geçmiş tüm nesneler ve diziler dahil olmak üzere, tamamen bağımsız yeni kopyalar oluşturarak kopyalar. Derin bir kopyanın herhangi bir bölümünü değiştirmek, orijinal nesnenin hiçbir bölümünü etkilemez. Bu, tam bağımsızlık gerektiren durumlar için idealdir.
Derin kopyalama, sığ kopyalamaya göre daha karmaşıktır ve JavaScript’te yerleşik, tek bir “derin kopyala” fonksiyonu uzun süre bulunmamıştır (yakın zamana kadar structuredClone gelene kadar).
1. JSON.parse(JSON.stringify(obj))
Bu yöntem, derin kopyalama için yaygın olarak kullanılan basit bir hiledir. Nesneyi önce bir JSON dizesine dönüştürür, ardından bu dizeyi tekrar bir JavaScript nesnesine ayrıştırır.
const orijinalNesne = {
a: 1,
b: { c: 2, d: { e: 3 } },
f: [4, { g: 5 }],
h: new Date(),
i: undefined,
j: function() { console.log('Merhaba'); },
k: Symbol('sembol')
};
const derinKopya = JSON.parse(JSON.stringify(orijinalNesne));
console.log(derinKopya);
/*
Çıktı:
{
a: 1,
b: { c: 2, d: { e: 3 } },
f: [4, { g: 5 }],
h: "2023-10-27T10:00:00.000Z" // Date objesi stringe dönüştü!
}
*/
// Derin kopyalamanın avantajı:
derinKopya.b.c = 20;
derinKopya.f[1].g = 50;
console.log(orijinalNesne.b.c); // 2 (orijinal değişmedi)
console.log(derinKopya.b.c); // 20
console.log(orijinalNesne.f[1].g); // 5 (orijinal değişmedi)
console.log(derinKopya.f[1].g); // 50Bu yöntem, basit veri nesneleri için hızlı ve etkilidir. Ancak önemli sınırlamaları vardır:
* Fonksiyonları yok sayar: Nesnedeki fonksiyonlar kopyalanmaz.
* undefined değerlerini yok sayar: undefined değerleri kopyalanmaz.
* Symbol değerlerini yok sayar: Symbol değerleri kopyalanmaz.
* Date nesnelerini string’e dönüştürür: Date nesneleri, ISO 8601 formatında bir dizeye dönüştürülür ve orijinal Date nesnesi olarak geri alınmaz.
* RegExp (Düzenli İfade) nesnelerini yok sayar: Düzenli ifade nesneleri kopyalanmaz.
* Map, Set, WeakMap, WeakSet gibi türleri desteklemez: Bu veri yapıları kopyalanmaz veya boş nesnelere dönüştürülür.
* Dairesel referansları (circular references) desteklemez: Eğer nesnenin içinde kendisine veya üst düzey bir atasına referans veren bir özellik varsa, JSON.stringify() bir hata (TypeError: Converting circular structure to JSON) fırlatır.
Bu sınırlamalar nedeniyle, JSON.parse(JSON.stringify(obj)) yöntemi, yalnızca basit, veri odaklı nesneler ve dairesel referans içermeyen durumlar için uygundur.
2. structuredClone()
Modern JavaScript’te (tarayıcılarda ve Node.js 17+ sürümlerinde mevcut), HTML Living Standard’ın bir parçası olan Structured Clone Algorithm’i uygulayan structuredClone() global fonksiyonu, derin kopyalama için en iyi yerleşik çözümdür.
const orijinalNesne = {
a: 1,
b: { c: 2, d: { e: 3 } },
f: [4, { g: 5 }],
h: new Date(),
i: undefined, // undefined kopyalanır!
j: function() { console.log('Merhaba'); }, // Fonksiyonlar kopyalanmaz
k: Symbol('sembol'), // Semboller kopyalanmaz
reg: /abc/gi, // RegExp kopyalanır
map: new Map([['key', 'value']]), // Map kopyalanır
set: new Set([1, 2, 3]), // Set kopyalanır
};
// Dairesel referans örneği
orijinalNesne.self = orijinalNesne;
try {
const derinKopya = structuredClone(orijinalNesne);
console.log(derinKopya);
/*
Çıktı:
{
a: 1,
b: { c: 2, d: { e: 3 } },
f: [4, { g: 5 }],
h: Date Sun Oct 27 2023..., // Date objesi doğru kopyalandı
i: undefined, // undefined doğru kopyalandı
reg: /abc/gi, // RegExp doğru kopyalandı
map: Map(1) { 'key' => 'value' }, // Map doğru kopyalandı
set: Set(3) { 1, 2, 3 }, // Set doğru kopyalandı
self: [Circular] // Dairesel referans doğru ele alındı
}
*/
// Derin kopyalamanın avantajı:
derinKopya.b.c = 20;
derinKopya.f[1].g = 50;
derinKopya.h.setFullYear(2024);
derinKopya.map.set('newKey', 'newValue');
console.log(orijinalNesne.b.c); // 2
console.log(derinKopya.b.c); // 20
console.log(orijinalNesne.f[1].g); // 5
console.log(derinKopya.f[1].g); // 50
console.log(orijinalNesne.h.getFullYear()); // 2023
console.log(derinKopya.h.getFullYear()); // 2024
console.log(orijinalNesne.map.has('newKey')); // false
console.log(derinKopya.map.has('newKey')); // true
} catch (e) {
console.error("Hata:", e.message);
}structuredClone()‘un avantajları:
* Birçok yerleşik türü destekler: Date, RegExp, Map, Set, ArrayBuffer, TypedArray, Blob, File, ImageData, Error nesneleri ve daha fazlasını doğru bir şekilde kopyalar.
* Dairesel referansları ele alır: Dairesel referanslar içeren nesneleri hatasız kopyalayabilir.
* undefined değerleri kopyalar.
Ancak, structuredClone()‘un da bazı sınırlamaları vardır:
* Fonksiyonları kopyalamaz: Fonksiyonlar kopyalandığında atılır.
* Symbol değerlerini kopyalamaz: Semboller kopyalandığında atılır.
* DOM düğümleri gibi bazı türleri kopyalamaz: Kopyalanmaya çalışıldığında hata fırlatır.
* Sınıf örneklerini (class instances) tamamen doğru kopyalamaz: Sınıf örneklerinin prototip zincirini korumaz, sadece özelliklerini kopyalar.
Genel olarak, structuredClone() birçok senaryo için en iyi yerleşik derin kopyalama çözümüdür.
3. Özel Derin Kopyalama Fonksiyonu (Recursive)
Yukarıdaki yerleşik yöntemlerin sınırlamaları nedeniyle, özellikle çok karmaşık nesnelerle çalışırken veya belirli veri türlerini özel olarak ele almanız gerektiğinde kendi derin kopyalama fonksiyonunuzu yazmanız gerekebilir. Bu genellikle özyinelemeli (recursive) bir yaklaşım gerektirir.
Basit bir özyinelemeli derin kopyalama fonksiyonu şöyle görünebilir:
function derinKopyala(obj, hash = new WeakMap()) {
// Primitive değerler veya null ise doğrudan döndür
if (obj === null || typeof obj !== 'object') {
return obj;
}
// Dairesel referansları kontrol et
if (hash.has(obj)) {
return hash.get(obj);
}
// Tarih ve RegExp nesnelerini özel olarak ele al
if (obj instanceof Date) {
return new Date(obj.getTime());
}
if (obj instanceof RegExp) {
return new RegExp(obj);
}
// Diğer yerleşik nesneler (Map, Set vb.) için de benzer kontroller eklenebilir.
// Yeni bir nesne veya dizi oluştur
const kopya = Array.isArray(obj) ? [] : {};
// Dairesel referansları izlemek için kopyayı hash'e ekle
hash.set(obj, kopya);
// Özellikleri özyinelemeli olarak kopyala
for (const key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
kopya[key] = derinKopyala(obj[key], hash);
}
}
return kopya;
}
const orijinalNesne = {
ad: "Ayşe",
bilgiler: {
yas: 25,
hobiler: ["kitap", "müzik", { spor: "yüzme" }]
},
tarih: new Date(),
fonk: () => console.log("Test")
};
// Dairesel referans oluşturalım
orijinalNesne.kendisi = orijinalNesne;
const derinKopya = derinKopyala(orijinalNesne);
console.log(derinKopya);
derinKopya.bilgiler.yas = 26;
derinKopya.bilgiler.hobiler[2].spor = "koşu";
derinKopya.tarih.setFullYear(2024);
console.log(orijinalNesne.bilgiler.yas); // 25
console.log(derinKopya.bilgiler.yas); // 26
console.log(orijinalNesne.bilgiler.hobiler[2].spor); // yüzme
console.log(derinKopya.bilgiler.hobiler[2].spor); // koşu
console.log(orijinalNesne.tarih.getFullYear()); // 2023
console.log(derinKopya.tarih.getFullYear()); // 2024
console.log(derinKopya.kendisi.bilgiler.yas); // 26 (dairesel referans doğru kopyalandı)Bu özel fonksiyon, Date ve RegExp gibi bazı yerleşik nesneleri doğru şekilde ele alır ve WeakMap kullanarak dairesel referansları yönetir. Ancak, bu fonksiyon hala Symbol‘leri veya fonksiyonları doğru şekilde kopyalamaz (fonksiyonlar değer olarak kopyalanır, ancak referans olarak değil, bu da genellikle istenen davranıştır). Ayrıca, Map, Set, ArrayBuffer gibi diğer karmaşık türler için de özel mantık eklenmesi gerekir. Kendi derin kopyalama fonksiyonunuzu yazmak, esneklik sağlar ancak tüm kenar durumları (edge cases) ele almak oldukça karmaşık olabilir.
4. Kütüphaneler (Örn: Lodash _.cloneDeep)
JavaScript ekosisteminde, derin kopyalama gibi karmaşık görevleri güvenilir ve performanslı bir şekilde yerine getiren birçok yardımcı kütüphane bulunmaktadır. Bunlardan en popüler olanlarından biri Lodash’tir. Lodash’in _.cloneDeep() metodu, neredeyse tüm veri türlerini, dairesel referansları ve diğer kenar durumları doğru bir şekilde ele alarak sağlam bir derin kopyalama çözümü sunar.
// npm install lodash
import _ from 'lodash';
const orijinalNesne = {
a: 1,
b: { c: 2 },
d: [3, { e: 4 }],
f: new Date(),
g: /test/g,
h: function() { console.log('Hello'); }
};
// Dairesel referans
orijinalNesne.self = orijinalNesne;
const derinKopya = _.cloneDeep(orijinalNesne);
console.log(derinKopya);
derinKopya.b.c = 20;
derinKopya.d[1].e = 40;
derinKopya.f.setFullYear(2025);
console.log(orijinalNesne.b.c); // 2
console.log(derinKopya.b.c); // 20
console.log(orijinalNesne.d[1].e); // 4
console.log(derinKopya.d[1].e); // 40
console.log(orijinalNesne.f.getFullYear()); // 2023
console.log(derinKopya.f.getFullYear()); // 2025
console.log(derinKopya.self.b.c); // 20 (dairesel referans doğru ele alındı)Lodash _.cloneDeep(), Date, RegExp, Map, Set, ArrayBuffer, TypedArray gibi birçok yerleşik nesneyi ve dairesel referansları sorunsuz bir şekilde kopyalar. Fonksiyonlar için ise genellikle referansları kopyalar, çünkü fonksiyonların kendisinin derin kopyalanması nadiren istenir ve genellikle mantıksızdır. Üretim ortamlarında veya karmaşık nesnelerle çalışırken, kütüphaneler genellikle en güvenli ve en az hataya açık çözümdür.
Hangi Kopyalama Yöntemi Ne Zaman Kullanılmalı?
Doğru kopyalama yöntemini seçmek, nesnenizin yapısına ve ihtiyaçlarınıza bağlıdır:
* Sığ Kopyalama (Object.assign(), Spread Söz Dizimi, Array.slice(), Array.from()):
* Ne zaman: Nesnenizin içinde iç içe geçmiş nesneler veya diziler yoksa, veya iç içe geçmiş yapıların orijinal ile aynı referansı paylaşması sorun yaratmıyorsa. Genellikle yalnızca en üst düzeyde değişiklik yapmanız gerektiğinde veya immutability’yi en üst düzeyde korumanız yeterliyse kullanılır.
* Örnek: Bir React bileşeninin state‘ini güncellerken, yeni bir nesne referansı oluşturmak ancak alt nesnelerin değişmediğini varsaymak.
* JSON.parse(JSON.stringify(obj)):
* Ne zaman: Nesneniz yalnızca ilkel değerler, basit nesneler ve dizilerden oluşuyorsa ve Date nesneleri, fonksiyonlar, undefined, Symbol veya dairesel referanslar içermiyorsa. Hızlı ve basit bir çözüm arıyorsanız.
* Örnek: API’den gelen basit bir JSON verisini kopyalamak.
* structuredClone():
* Ne zaman: Modern tarayıcı veya Node.js ortamında çalışıyorsanız ve çoğu yerleşik JavaScript türünü (Date, RegExp, Map, Set vb.) ve dairesel referansları destekleyen güvenilir bir yerleşik derin kopyalama çözümüne ihtiyacınız varsa. Fonksiyonların veya Symbol‘lerin kopyalanmasına ihtiyacınız yoksa.
* Örnek: Web Worker’lar arasında veri aktarımı (burada zaten structuredClone kullanılır) veya modern bir uygulamada genel amaçlı derin kopyalama.
* Özel Özyinelemeli Derin Kopyalama Fonksiyonu:
* Ne zaman: structuredClone()‘un desteklemediği özel türleri (örn. belirli sınıf örnekleri, DOM düğümleri) kopyalamanız gerekiyorsa veya çok özel kopyalama mantığına ihtiyacınız varsa. Tüm kenar durumları kendiniz ele almanın getirdiği karmaşıklığı ve bakım yükünü kabul ediyorsanız.
* Örnek: Karmaşık, özel sınıf örnekleri içeren bir veri modelini kopyalamak.
* Kütüphaneler (Örn: Lodash _.cloneDeep):
* Ne zaman: Sağlam, iyi test edilmiş, performanslı ve tüm kenar durumları (dairesel referanslar, çeşitli yerleşik nesne türleri vb.) ele alan bir çözüme ihtiyacınız varsa. Özellikle karmaşık ve büyük ölçekli uygulamalarda en güvenilir seçenektir.
* Örnek: Karmaşık bir uygulama durumunu (state) kopyalamak, bir veri tabanı modelini klonlamak.
Immutability (Değişmezlik) ve Nesne Kopyalama
JavaScript’te nesneleri kopyalama konusu, özellikle modern ön uç geliştirme (React, Redux, Vuex gibi kütüphanelerle) bağlamında immutability (değişmezlik) prensibiyle yakından ilişkilidir. Değişmezlik, bir veri yapısı oluşturulduktan sonra değiştirilemeyeceği anlamına gelir. Bunun yerine, bir değişiklik gerektiğinde, orijinal veri yapısının değiştirilmiş bir kopyası oluşturulur.
Immutability’nin faydaları şunlardır:
* Daha tahmin edilebilir kod: Verinin nerede ve ne zaman değiştiğini takip etmek daha kolaydır.
* Hata ayıklamayı kolaylaştırır: Yan etkileri azaltır, hataların kaynağını bulmayı basitleştirir.
* Performans optimizasyonları: Değişmez verilerle, bir nesnenin değişip değişmediğini kontrol etmek için sadece referans karşılaştırması yeterlidir (===). Bu, özellikle React gibi kütüphanelerde gereksiz yeniden render işlemlerini önlemek için kullanılır.
* Eşzamanlılık (concurrency) sorunlarını azaltır: Aynı veriye erişen birden fazla iş parçacığı veya asenkron işlem olduğunda, verinin değişmez olması çakışmaları önler.
Bu nedenlerle, JavaScript uygulamalarında nesneleri kopyalamak, immutability’yi sürdürmenin temel bir yoludur. Bir nesneyi doğrudan değiştirmek yerine, onun sığ veya derin bir kopyasını oluşturup bu kopya üzerinde değişiklik yapmak, uygulamanın durumunu daha güvenli ve yönetilebilir hale getirir.
Sonuç
JavaScript’te nesneleri kopyalama, ilk bakışta basit görünse de, ilkel ve referans türleri arasındaki farklar nedeniyle önemli inceliklere sahiptir. Sığ kopyalama, yalnızca en üst düzeydeki özellikleri bağımsız hale getirirken, iç içe geçmiş referans türlerini orijinal ile paylaşmaya devam eder. Derin kopyalama ise nesnenin tüm yapısını, iç içe geçmiş tüm bileşenleri dahil olmak üzere tamamen bağımsız hale getirir.
Object.assign() ve spread söz dizimi gibi yöntemler sığ kopyalama için pratik çözümler sunarken, JSON.parse(JSON.stringify()) veya daha modern structuredClone() gibi yöntemler derin kopyalama için farklı avantaj ve dezavantajlara sahiptir. Karmaşık senaryolarda veya tüm kenar durumları kapsayan bir çözüm arayışında, Lodash gibi kütüphanelerin _.cloneDeep() fonksiyonu gibi sağlam ve test edilmiş çözümlere başvurmak en doğrusudur.
Uygulamanızın gereksinimlerine, nesnelerinizin karmaşıklığına ve performans beklentilerinize göre doğru kopyalama yöntemini seçmek, daha güvenilir, bakımı kolay ve tahmin edilebilir JavaScript kodu yazmanın anahtarıdır. Immutability prensiplerini benimsemek, bu kopyalama tekniklerini etkili bir şekilde kullanmayı gerektiren modern geliştirme yaklaşımlarının temelini oluşturur. Bu konudaki derinlemesine bilgi, her JavaScript geliştiricisinin araç setinde bulunması gereken kritik bir beceridir.