Week 1/ Day 1

Haftanın ilk gününde freecodecamp üzerinden Basic Data Structures bölümünü tamamladım.Yazının devamında bu bölümde öğrendiğim konuları özetleyeceğim.

1)Using an Array to Store a Collection of Data

JavaScript’te bir dizi (array) kullanarak veri koleksiyonunu nasıl saklayabileceğinizi açıklayalım. JavaScript’te bir dizi, birden fazla öğeyi saklamak için kullanılan bir veri yapısıdır. İşte bir dizi oluşturmanın ve kullanmanın basit bir örneği:

Dizi Oluşturma:

Bir dizi oluşturmak için [] (köşeli parantez) kullanabiliriz.

let meyveler = ["elma", "armut", "muz", "çilek"];

Bu örnekte, meyveler adında bir dizi oluşturduk ve içine dört farklı meyve ekledik.

Diziye Erişim:

Dizi içindeki öğelere erişmek için indeks numaralarını kullanabiliriz. JavaScript’te indeksler 0'dan başlar.

console.log(meyveler[0]); // Çıktı: "elma"
console.log(meyveler[2]); // Çıktı: "muz"

Diziye Öğe Ekleme ve Kaldırma:

Dizilere öğe eklemek için push() metodunu kullanabiliriz:

meyveler.push("portakal");
console.log(meyveler); // Çıktı: ["elma", "armut", "muz", "çilek", "portakal"]

Diziden öğe kaldırmak için pop() metodunu kullanabiliriz:

meyveler.pop();
console.log(meyveler); // Çıktı: ["elma", "armut", "muz", "çilek"]

Dizi Uzunluğu:

Bir dizinin uzunluğunu öğrenmek için length özelliğini kullanabiliriz:

console.log(meyveler.length); // Çıktı: 4

2)Access an Array’s Contents Using Bracket Notation

JavaScript’te dizilerin içeriğine erişmek için köşeli parantez notasyonunu ([]) kullanabiliriz. Bu notasyon, bir dizinin belirli bir indeksindeki değere erişmemize olanak tanır. İşte köşeli parantez notasyonunu kullanarak bir dizinin içeriğine nasıl erişebileceğimizi gösteren birkaç örnek:

Dizinin İndeksine Göre Erişim:

let renkler = ["kırmızı", "mavi", "yeşil", "sarı"];

// İlk öğeye erişim (0 indeks numarasıyla)
console.log(renkler[0]);  // Çıktı: "kırmızı"

// İkinci öğeye erişim (1 indeks numarasıyla)
console.log(renkler[1]);  // Çıktı: "mavi"

// Dördüncü öğeye erişim (3 indeks numarasıyla)
console.log(renkler[3]);  // Çıktı: "sarı"

Dizinin Uzunluğunu Kullanarak Erişim:

let meyveler = ["elma", "armut", "muz", "çilek"];

// Dizinin uzunluğunu kullanarak son öğeye erişim
let sonMeyve = meyveler[meyveler.length - 1];
console.log(sonMeyve);  // Çıktı: "çilek"

Yukarıdaki örnekte, meyveler dizisinin uzunluğunu kullanarak dizinin son öğesine erişim sağlanmıştır. Bu, dizinin boyutunu bilmediğiniz durumlar için kullanışlı bir tekniktir.

Dizilerde köşeli parantez notasyonu kullanarak, belirli bir indeksteki değeri alabilir, değeri değiştirebilir veya yeni değer ekleyebiliriz. Bu notasyon, dizilerle çalışırken oldukça yaygın bir şekilde kullanılır.

3)Add Items to an Array with push() and unshift()

JavaScript’te, bir dizinin sonuna eleman eklemek için push() yöntemini kullanabiliriz. Ayrıca, bir dizinin başına eleman eklemek için unshift() yöntemini de kullanabiliriz. İşte bu yöntemleri örneklerle açıklayan kodlar:

push() Yöntemi (Dizinin Sonuna Eleman Ekleme):

let meyveler = ["elma", "armut", "muz"];

// `push()` yöntemi ile dizinin sonuna yeni bir meyve ekleyelim
meyveler.push("çilek");

console.log(meyveler);
// Çıktı: ["elma", "armut", "muz", "çilek"]

Yukarıdaki örnekte, push() yöntemini kullanarak meyveler dizisinin sonuna "çilek" öğesini ekledik.

unshift() Yöntemi (Dizinin Başına Eleman Ekleme):

let meyveler = ["elma", "armut", "muz"];

// `unshift()` yöntemi ile dizinin başına yeni bir meyve ekleyelim
meyveler.unshift("portakal");

console.log(meyveler);
// Çıktı: ["portakal", "elma", "armut", "muz"]

Yukarıdaki örnekte, unshift() yöntemini kullanarak meyveler dizisinin başına "portakal" öğesini ekledik.

Her iki yöntem de dizinin uzunluğunu otomatik olarak günceller. push() ile elemanlar dizinin sonuna eklenirken, unshift() ile elemanlar dizinin başına eklenir. Bu yöntemler, dinamik olarak büyüyen veya küçülen dizilerle çalışırken oldukça kullanışlıdır.

4)Remove Items from an Array with pop() and shift()

JavaScript’te, bir diziden elemanları kaldırmak için pop() ve shift() yöntemlerini kullanabiliriz.

pop() Yöntemi (Dizinin Sonundan Eleman Kaldırma):

pop() yöntemi, bir dizinin sonundan bir öğe kaldırır ve kaldırılan öğeyi döndürür. Bu yöntem dizinin uzunluğunu azaltır.

let meyveler = ["elma", "armut", "muz"];

// `pop()` yöntemi ile dizinin sonundan bir meyve çıkaralım
let sonMeyve = meyveler.pop();

console.log(sonMeyve);  // Çıktı: "muz" (kaldırılan öğe)
console.log(meyveler);  // Çıktı: ["elma", "armut"] (güncellenmiş dizi)

shift() Yöntemi (Dizinin Başından Eleman Kaldırma):

shift() yöntemi, bir dizinin başından bir öğe kaldırır ve kaldırılan öğeyi döndürür. Bu yöntem dizinin uzunluğunu azaltır ve dizinin tüm elemanlarını bir pozisyon sola kaydırır.

let meyveler = ["elma", "armut", "muz"];

// `shift()` yöntemi ile dizinin başından bir meyve çıkaralım
let ilkMeyve = meyveler.shift();

console.log(ilkMeyve);  // Çıktı: "elma" (kaldırılan öğe)
console.log(meyveler);  // Çıktı: ["armut", "muz"] (güncellenmiş dizi)

Yukarıdaki örnekte, shift() yöntemini kullanarak meyveler dizisinin başından "elma" öğesini kaldırdık.

Hem pop() hem de shift() yöntemleri, dizinin elemanlarını güncellerken ve kaldırılan öğeleri döndürürken oldukça kullanışlıdır. Bu yöntemler, dizinin sonundan veya başından elemanları kaldırmak istediğinizde kullanılabilir.

5)Remove Items Using splice( )

splice() metodu, JavaScript'teki dizilerde belirli bir indeksten başlayarak belirli bir sayıda öğeyi kaldırmak veya yeni öğeler eklemek için kullanılır. splice() metodu aşağıdaki şekilde kullanılır:

Diziden Öğe Kaldırma:

Belirli bir indeksten başlayarak belirli sayıda öğeyi kaldırmak için splice() metodu kullanılır. İlk parametre olarak başlangıç indeksini ve ikinci parametre olarak kaldırılacak öğe sayısını alır.

let meyveler = ["elma", "armut", "muz", "çilek"];
meyveler.splice(1, 2); // 1. indeksten başlayarak 2 öğeyi kaldır
console.log(meyveler); // Çıktı: ["elma", "çilek"]

Yukarıdaki örnekte, splice(1, 2) ifadesiyle diziden "armut" ve "muz" öğeleri kaldırıldı.

Yeni Öğeler Eklemek:

splice() metodunu kullanarak belirli bir indekse yeni öğeler ekleyebiliriz. İlk parametre olarak başlangıç indeksini, ikinci parametre olarak 0 (kaç öğe kaldırılacağını belirten değer) ve ardından eklemek istediğimiz öğeleri ekleyebiliriz.

let meyveler = ["elma", "çilek"];
meyveler.splice(1, 0, "armut", "muz"); // 1. indekse "armut" ve "muz" eklenir
console.log(meyveler); // Çıktı: ["elma", "armut", "muz", "çilek"]

Yukarıdaki örnekte, splice(1, 0, "armut", "muz") ifadesiyle dizinin 1. indeksine "armut" ve "muz" öğeleri eklendi.

splice() metodu, dizilerde öğe eklemek ve kaldırmak için oldukça güçlü ve esnek bir yöntemdir. Bu metot, bir dizinin içeriğini dinamik bir şekilde değiştirmek için yaygın olarak kullanılır.

6)Copy an Array with the Spread Operator

JavaScript’te dizileri kopyalamak için Spread Operatörü (genellikle üç nokta ... olarak gösterilir) kullanılabilir. Spread operatörü, bir dizi içindeki öğeleri ayrıştırarak veya açarak yeni bir dizi oluşturur. İşte Spread Operatörü ile dizi kopyalama konusunda detaylı bir açıklama ve örnekler:

1. Dizi Kopyalama:

Spread operatörü ile bir dizi kopyalamak için aşağıdaki şekilde kullanabiliriz:

let orijinalDizi = [1, 2, 3, 4, 5];
let kopyaDizi = [...orijinalDizi];
console.log(kopyaDizi); // Çıktı: [1, 2, 3, 4, 5]

Yukarıdaki örnekte, ...orijinalDizi ifadesi, orijinalDizi içindeki tüm öğeleri açarak yeni bir dizi oluşturur. Bu yeni dizi kopyaDizi değişkenine atanır.

2. Diziye Yeni Öğeler Ekleme:

Spread operatörü ile yeni öğeler eklemek istiyorsak şu şekilde kullanabiliriz:

let orijinalDizi = [1, 2, 3];
let yeniDizi = [...orijinalDizi, 4, 5, 6];
console.log(yeniDizi); // Çıktı: [1, 2, 3, 4, 5, 6]

Yukarıdaki örnekte, ...orijinalDizi ifadesi ile orijinalDizi'nin tüm öğeleri yeni diziye eklenir, ardından 4, 5 ve 6 öğeleri de eklenir.

3. Nesneleri Kopyalama:

Spread operatörü, nesneleri de kopyalarken kullanılabilir:

let orijinalNesne = { ad: 'John', yaş: 30 };
let kopyaNesne = { ...orijinalNesne };
console.log(kopyaNesne); // Çıktı: { ad: 'John', yaş: 30 }

Burada da, ...orijinalNesne ifadesi ile orijinalNesne'nin tüm özellikleri (ad ve yaş) yeni bir nesneye kopyalanır.

Spread operatörü, dizi ve nesnelerdeki öğeleri kopyalamak, yeni öğeler eklemek veya mevcut öğeleri birleştirmek için oldukça kullanışlıdır. Bu yöntemle, orijinal verileri koruyarak yeni veri yapıları oluşturabiliriz.

7)Combine Arrays with the Spread Operator

JavaScript’te, Spread Operatörü (...) kullanılarak diziler birleştirilebilir. Spread Operatörü, dizileri sadece kopyalamakla kalmaz, aynı zamanda birden fazla diziyi birleştirmek veya bir diziye eklemek için de kullanılır

Dizileri Birleştirme:

let dizi1 = [1, 2, 3];
let dizi2 = [4, 5, 6];
let birlesikDizi = [...dizi1, ...dizi2];
console.log(birlesikDizi);
// Çıktı: [1, 2, 3, 4, 5, 6]

Yukarıdaki örnekte, Spread Operatörü, dizi1 ve dizi2'yi yeni bir dizi olan birlesikDizi içinde birleştirmek için kullanılmıştır. ...dizi1 ifadesi dizi1'in öğelerini yayarak, ...dizi2 ifadesi ise dizi2'nin öğelerini yayarak, her iki dizinin öğelerini içeren tek bir dizi oluşturur.

Dizilere Ek Öğeler Ekleyerek Birleştirme:

Spread Operatörü kullanarak dizilere ek öğeler eklemek de mümkündür:

let dizi1 = [1, 2, 3];
let ekOge = 4;
let birlesikDizi = [...dizi1, ekOge];
console.log(birlesikDizi);
// Çıktı: [1, 2, 3, 4]

Bu örnekte, Spread Operatörü, dizi1'in öğelerini yayarak yeni bir dizi oluşturur, ardından ek öğe 4'ü bu dizinin sonuna ekler.

Nesnelerin Dizilerini Birleştirme:

Eğer nesnelerin dizileriniz varsa, onları da Spread Operatörü ile birleştirebilirsiniz:

let dizi1 = [{ id: 1, ad: 'Alice' }];
let dizi2 = [{ id: 2, ad: 'Bob' }];
let birlesikDizi = [...dizi1, ...dizi2];
console.log(birlesikDizi);
// Çıktı: [{ id: 1, ad: 'Alice' }, { id: 2, ad: 'Bob' }]

Burada, birlesikDizi hem dizi1 hem de dizi2'nin nesnelerini içerir.

Spread Operatörü, JavaScript’te dizileri ve nesneleri kolayca manipüle etmenizi sağlayan güçlü bir araçtır. Bu sayede veri yapılarını kolayca birleştirebilir, kopyalayabilir ve değiştirebilirsiniz.

8) Check For The Presence of an Element With indexOf( )

indexOf() metodu, bir dizide belirli bir öğenin var olup olmadığını kontrol etmek için kullanılır. Bu metot, aranan öğenin indeksini döndürür. Eğer öğe dizide bulunmuyorsa -1 değerini döndürür. İşte indexOf() metodunun kullanımıyla ilgili birkaç örnek:

Öğenin Varlığını Kontrol Etme:

let dizi = [1, 2, 3, 4, 5];
let arananOge = 3;

if (dizi.indexOf(arananOge) !== -1) {
    console.log("Öğe dizide bulunuyor.");
} else {
    console.log("Öğe dizide bulunmuyor.");
}
// Çıktı: Öğe dizide bulunuyor.

Yukarıdaki örnekte, indexOf() metodu ile arananOge değeri olan 3'ün dizide olup olmadığı kontrol edilir. Eğer öğe dizide bulunuyorsa, metot -1 değerinden farklı bir değer döndüreceği için "Öğe dizide bulunuyor." mesajı yazdırılır. Aksi halde "Öğe dizide bulunmuyor." mesajı yazdırılır.

Öğenin İlk İndeksini Bulma:

Ayrıca, indexOf() metodu ile öğenin dizideki ilk indeksini bulabiliriz:

let dizi = [1, 2, 3, 4, 5, 3];
let arananOge = 3;
let ilkIndeks = dizi.indexOf(arananOge);

if (ilkIndeks !== -1) {
    console.log(`Öğe ${ilkIndeks}. indekste bulunuyor.`);
} else {
    console.log("Öğe dizide bulunmuyor.");
}
// Çıktı: Öğe 2. indekste bulunuyor.

Yukarıdaki örnekte, indexOf() metodu ile arananOge değeri olan 3'ün ilk indeksi bulunur ve eğer öğe dizide varsa indeks değeri yazdırılır.

Bu şekilde indexOf() metodu, belirli bir öğenin bir dizide var olup olmadığını kontrol etmek veya öğenin indeksini bulmak için kullanılabilir. Ancak, öğenin dizide var olup olmadığını kontrol etmeden önce indexOf()'in döndüğü değeri -1 ile karşılaştırarak doğru sonuçları almanız önemlidir.

9)Iterate Through All an Array’s Items Using For Loops

Tabii ki! Bir dizideki tüm öğeleri döngüler (for döngüsü gibi) kullanarak gezme işlemine iterasyon denir. JavaScript’te, bir dizideki tüm öğeleri dolaşmak için for döngüsü yaygın bir yöntemdir. İşte bir dizi içindeki öğeleri for döngüsü kullanarak gezme örneği:

Dizi İterasyonu Using for Döngüsü:

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

for (let i = 0; i < dizi.length; i++) {
    console.log(dizi[i]);
}

Yukarıdaki kodda, for döngüsü ile i değişkeni 0'dan başlayarak dizi.length - 1'e kadar artırılır. dizi[i] ifadesi, dizinin her bir elemanına erişim sağlar ve bu öğeleri ekrana yazdırır.

Bu for döngüsü, dizideki her öğeyi birer birer gezerek işlem yapmanıza olanak tanır.

for...of Döngüsü ile Dizi İterasyonu:

Ayrıca, modern JavaScript’te for...of döngüsü, bir dizi veya başka bir veri yapısındaki öğeleri dolaşmak için daha basit bir alternatiftir:

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

for (let eleman of dizi) {
    console.log(eleman);
}

Bu for...of döngüsü ile de aynı sonuca ulaşabiliriz. for...of döngüsü, dizideki her öğeyi doğrudan bir değişkene atayarak gezme işlemini basitleştirir.

Hem for döngüsü hem de for...of döngüsü, dizideki öğeleri gezmenin yaygın ve etkili yollarıdır. Hangi döngüyü kullanırsanız kullanın, her iki yöntem de bir dizideki öğeleri tek tek işlemlemek için kullanışlıdır.

#BONUS every( ), forEach( ), map( ) metodlarının kullanımları ve farkları nelerdir?

JavaScript’teki every(), forEach(), ve map() metotları, dizilerde dolaşmak ve öğelerle işlem yapmak için kullanılan farklı yöntemlerdir. İşlevleri ve farkları şu şekildedir:

every() Metodu:

every() metodu, bir dizi içindeki tüm öğelerin belirli bir koşulu karşılayıp karşılamadığını kontrol eder. Eğer dizi içindeki tüm öğeler belirtilen koşulu sağlıyorsa true, aksi halde false döndürür.

Örnek:

let dizi = [2, 4, 6, 8, 10];
let sonuc = dizi.every(function(eleman) {
    return eleman % 2 === 0;
});

console.log(sonuc);  // Çıktı: true (Tüm elemanlar çift sayıdır)

Yukarıdaki örnekte, every() metodu ile dizideki tüm elemanların çift sayı olup olmadığını kontrol ediyoruz. Bu koşul dizideki tüm elemanlar için geçerli olduğu için true döner.

forEach() Metodu:

forEach() metodu, dizideki her bir öğe için belirtilen bir işlemi gerçekleştirir. Bu metot, dizi elemanlarını değiştirmek veya yeni bir dizi oluşturmak gibi işlemler için kullanılır. forEach() metodu, her eleman için bir işlem gerçekleştirir, ancak dönüş değeri yoktur (undefined).

Örnek:

let dizi = [1, 2, 3, 4, 5];
dizi.forEach(function(eleman) {
    console.log(eleman * 2);
});
// Çıktı: 2, 4, 6, 8, 10

Yukarıdaki örnekte, forEach() metodu ile dizideki her elemanı 2 ile çarpıp ekrana yazdırıyoruz.

map() Metodu:

map() metodu, bir dizideki her eleman için belirli bir işlemi gerçekleştirir ve sonuçları yeni bir dizi olarak döndürür. map() metodu, orijinal diziyi değiştirmez, yeni bir dizi oluşturur.

Örnek:

let dizi = [1, 2, 3, 4, 5];
let yeniDizi = dizi.map(function(eleman) {
    return eleman * 2;
});

console.log(yeniDizi);  // Çıktı: [2, 4, 6, 8, 10]

Yukarıdaki örnekte, map() metodu ile dizideki her elemanı 2 ile çarpıp yeni bir dizi oluşturuyoruz.

Farklar:

• every() metodu, belirtilen koşulun tüm dizi elemanlarına uygulanıp uygulanmadığını kontrol ederken, forEach() ve map() metotları her eleman için belirli işlemleri gerçekleştirir.
• forEach() metodu işlemleri gerçekleştirirken herhangi bir değer döndürmezken, map() metodu işlemleri gerçekleştirirken sonuçları yeni bir dizi olarak döndürür.

Bu metotlar, farklı senaryolarda kullanılabilecek kullanışlı dizi yöntemleridir.

10)Adding Key-Value Pairs to JavaScript Objects

JavaScript’teki nesneler (objects), anahtar-değer (key-value) çiftlerini saklamak için kullanılır. Anahtarlar bir nesnenin özelliklerini temsil ederken, değerler bu özelliklere atanmış değerleri temsil eder. Nesnelere yeni anahtar-değer çiftleri eklemek için iki yaygın yöntem vardır: nokta notasyonu ve köşeli parantez notasyonu. İşte bu konsepti açıklayan örnekler:

Nokta Notasyonu ile Anahtar-Değer Ekleme:

let kullanici = {
    ad: "John",
    soyad: "Doe"
};

// Yeni bir anahtar-değer çifti ekleyelim
kullanici.yas = 30;

console.log(kullanici);
// Çıktı: { ad: "John", soyad: "Doe", yas: 30 }

Yukarıdaki örnekte, kullanici nesnesine yas adında yeni bir özellik ekledik.

Köşeli Parantez Notasyonu ile Anahtar-Değer Ekleme:

let kullanici = {
    ad: "John",
    soyad: "Doe"
};

// Yeni bir anahtar-değer çifti ekleyelim
kullanici["email"] = "john.doe@example.com";

console.log(kullanici);
// Çıktı: { ad: "John", soyad: "Doe", email: "john.doe@example.com" }

Yukarıdaki örnekte, köşeli parantez notasyonunu kullanarak kullanici nesnesine email adında yeni bir özellik ekledik.

Değişken Kullanarak Anahtar-Değer Ekleme:

let anahtar = "telefon";
let deger = "555-1234";

let kullanici = {
    ad: "Jane"
};

// Değişkenleri kullanarak yeni bir anahtar-değer çifti ekleyelim
kullanici[anahtar] = deger;

console.log(kullanici);
// Çıktı: { ad: "Jane", telefon: "555-1234" }

Yukarıdaki örnekte, anahtar ve deger değişkenlerini kullanarak dinamik olarak yeni bir anahtar-değer çifti ekledik.

Bu yöntemlerle JavaScript nesnelerine dinamik olarak yeni özellikler ekleyebilirsiniz. Bu esneklik, verileri organize etme ve yönetme süreçlerinde çok kullanışlıdır.

11)Modifying and adding an Object Nested Within an Object

Bir nesnenin içindeki başka bir nesneyi değiştirmek veya yeni bir nesne eklemek oldukça yaygın bir durumdur. Bu işlemi gerçekleştirmek için nesne içindeki iç içe geçmiş nesnelere erişebiliriz. İşte bir nesne içindeki iç içe geçmiş nesneyi değiştirmek ve yeni bir nesne eklemek için örnekler:

İç İçe Geçmiş Nesneyi Değiştirmek:

let kullanici = {
    ad: "John",
    bilgiler: {
        yas: 30,
        email: "john@example.com"
    }
};

// İç içe geçmiş nesnedeki bir özelliği değiştirelim
kullanici.bilgiler.yas = 35;

console.log(kullanici);
// Çıktı: { ad: "John", bilgiler: { yas: 35, email: "john@example.com" } }

Yukarıdaki örnekte, kullanici nesnesinin içindeki bilgiler nesnesindeki yas özelliğini değiştirdik.

Yeni İç İçe Geçmiş Nesne Eklemek:

let kullanici = {
    ad: "John",
    bilgiler: {
        yas: 30,
        email: "john@example.com"
    }
};

// Yeni bir iç içe geçmiş nesne ekleyelim
kullanici.bilgiler.adres = {
    sehir: "New York",
    postaKodu: "10001"
};

console.log(kullanici);
/* Çıktı: 
{ 
  ad: "John", 
  bilgiler: { 
    yas: 30, 
    email: "john@example.com", 
    adres: { sehir: "New York", postaKodu: "10001" } 
  } 
}
*/

Yukarıdaki örnekte, kullanici nesnesinin içindeki bilgiler nesnesine yeni bir adres nesnesi ekledik.

Bu örneklerde görüldüğü gibi, iç içe geçmiş nesnelere erişmek ve onları değiştirmek oldukça basittir. Bu, daha karmaşık veri yapıları oluştururken oldukça güçlü ve yaygın bir tekniktir.

12)Accessing Property Names with Bracket Notation

JavaScript’te, nesne özelliklerine (property) erişim için iki farklı yöntem bulunur: nokta notasyonu ve köşeli parantez notasyonu. Köşeli parantez notasyonu kullanıldığında, dinamik olarak özelliklere erişmek ve özellik isimlerini değişkenlerle kullanmak mümkün olur. İşte bu konsepti açıklayan örnekler:

Köşeli Parantez Notasyonu ile Özelliklere Erişim:

let kullanici = {
    ad: "John",
    soyad: "Doe",
    email: "john@example.com"
};

let ozellikAdi = "ad";

console.log(kullanici[ozellikAdi]);
// Çıktı: "John" (kullanici["ad"] ile aynı sonuca ulaşır)

Yukarıdaki örnekte, ozellikAdi değişkeni "ad" değerine sahip olduğu için kullanici nesnesinin "ad" özelliğine eriştik. Köşeli parantez içindeki ifade, özelliğin adını içerir ve bu ifade dinamik olarak değerlendirilir.

Özellik Ekleme veya Değiştirme:

Köşeli parantez notasyonu, nesnelerde yeni özellikler eklemek veya var olan özellikleri değiştirmek için de kullanılabilir:

let kullanici = {};

let ozellikAdi = "ad";
let ozellikDegeri = "John";

// Yeni özelliği ekleyelim
kullanici[ozellikAdi] = ozellikDegeri;

console.log(kullanici);
// Çıktı: { ad: "John" }

// Var olan özelliği değiştirelim
ozellikAdi = "soyad";
ozellikDegeri = "Doe";
kullanici[ozellikAdi] = ozellikDegeri;

console.log(kullanici);
// Çıktı: { ad: "John", soyad: "Doe" }

Yukarıdaki örnekte, kullanici nesnesine dinamik olarak özellikler ekledik ve var olan bir özelliği değiştirdik.

Köşeli parantez notasyonu, özellik adlarını dinamik olarak belirlemek istediğinizde ve özellikleri değiştirmek veya yeni özellikler eklemek istediğinizde kullanışlıdır. Bu notasyon, genellikle dışarıdan gelen verilerle çalışırken veya dinamik olarak özelliklere erişim gerektiğinde kullanılır.

13)Using the delete Keyword to Remove Object Properties

JavaScript’te, delete anahtar kelimesi nesne özelliklerini silmek için kullanılır. İşte delete anahtar kelimesini kullanarak nesne özelliklerini nasıl sileceğinizi açıklayan örnekler:

Nesne Özelliklerini Silme:

let kullanici = {
    ad: "John",
    soyad: "Doe",
    email: "john@example.com"
};

// `delete` anahtar kelimesi ile özellikleri silebiliriz
delete kullanici.soyad;

console.log(kullanici);
// Çıktı: { ad: "John", email: "john@example.com" }

Yukarıdaki örnekte, kullanici nesnesindeki soyad özelliğini delete anahtar kelimesi ile sildik.

Dikkat Edilmesi Gerekenler:

delete anahtar kelimesi ile silinen özellik tamamen nesneden kaldırılır. Bu, özellik artık nesnenin bir parçası olmadığı anlamına gelir.

delete anahtar kelimesi ile dizilerdeki elemanları silmek genellikle önerilmez. Dizilerdeki elemanları silmek yerine, elemanları null veya undefined gibi değerlerle güncellemek daha güvenli bir yaklaşımdır.

delete anahtar kelimesi ile sadece nesne özellikleri silinebilir. Global değişkenleri, fonksiyonları veya değişkenleri silemez.

delete anahtar kelimesi, nesnelerin dinamik olarak yönetilmesine yardımcı olur. Ancak, dikkatli kullanılmalıdır çünkü yanlışlıkla önemli verileri silme riski taşır. Bu nedenle, silme işleminden önce özelliğin gerçekten silinmesi gerekip gerekmediğini doğrulamak önemlidir.

14) Check if an Object has a Property with hasOwnProperty( )

JavaScript’te, bir nesnenin belirli bir özelliğe sahip olup olmadığını kontrol etmek için hasOwnProperty() yöntemini kullanabiliriz. Bu yöntem, belirtilen özellik nesnenin doğrudan kendisine aitse true, başka bir nesne tarafından miras alınmışsa false döndürür. İşte hasOwnProperty() yöntemini kullanarak nesnenin bir özelliğe sahip olup olmadığını kontrol etme örnekleri:

hasOwnProperty() Yöntemi Kullanımı:

let kullanici = {
    ad: "John",
    soyad: "Doe"
};

// `ad` özelliği kullanıcı nesnesinin doğrudan bir özelliğidir
console.log(kullanici.hasOwnProperty("ad"));  // Çıktı: true

// `yas` özelliği kullanıcı nesnesine ait değil, bu yüzden false döner
console.log(kullanici.hasOwnProperty("yas"));  // Çıktı: false

// `toString` özelliği, nesnelerin temel prototipinden miras alınmıştır
console.log(kullanici.hasOwnProperty("toString"));  // Çıktı: false

Yukarıdaki örnekte, hasOwnProperty() yöntemini kullanarak kullanici nesnesinin "ad" özelliğine doğrudan sahip olup olmadığını kontrol ettik. "ad" özelliği doğrudan nesnenin kendisine ait olduğu için true dönerken, "yas" özelliği nesneye ait olmadığı için false döndü.

Aynı zamanda, JavaScript nesneleri varsayılan olarak Object prototipinden özellikleri miras alır. Bu yüzden "toString" gibi yaygın metotlar da nesnelerin özellikleridir, ancak doğrudan nesneye ait değillerse hasOwnProperty() false döndürür.

Bu yöntem, bir nesnenin kendi özelliklerini kontrol etmek ve prototipten miras alınan özellikleri ayırt etmek için kullanılır.

15)Iterate Through the Keys of an Object with a for…in Statement

JavaScript’te, bir nesnenin özelliklerini (keys) dolaşmak için for...in döngüsü kullanılır. for...in döngüsü, nesnenin tüm enumerable (gezilebilir) özelliklerini dolaşır. Bu döngü, bir nesnenin tüm anahtarlarını almanızı sağlar. İşte for...in döngüsünü kullanarak bir nesnenin anahtarlarını dolaşma örneği:

let kullanici = {
    ad: "John",
    soyad: "Doe",
    yas: 30
};

// `for...in` döngüsü ile nesnenin anahtarlarını dolaşıyoruz
for (let anahtar in kullanici) {
    console.log(anahtar);  // Anahtarları yazdır
    console.log(kullanici[anahtar]);  // Her anahtarın değerini yazdır
}

Yukarıdaki örnekte, for...in döngüsünü kullanarak kullanici nesnesinin anahtarlarını dolaşıyoruz. Döngü, her döngü adımında anahtar değişkenine nesnenin bir özelliği olan anahtarı atar. Ardından, kullanici[anahtar] ifadesi ile her bir anahtarın değerine erişebiliriz.

Bu döngü, nesnenin özelliklerini dolaşmanın yaygın bir yoludur ve özellikle dinamik olarak değişen nesnelerle çalışırken kullanışlıdır. Ancak, dikkat etmeniz gereken birkaç nokta vardır:

1. for...in döngüsü, nesnenin kendi özelliklerini ve prototip zincirinden miras alınan özellikleri de dolaşır. Bu yüzden hasOwnProperty() metodu ile nesnenin kendi özelliklerini kontrol etmek önemlidir.
2. for...in döngüsü sadece enumerable (gezilebilir) özellikleri dolaşır. Bazı özellikler varsayılan olarak enumerable olmayabilir (örneğin, Object.prototype'deki özellikler). Bu durumda, Object.keys() veya Object.entries() gibi yöntemlerle dolaşılabilir enumerable özellikler elde edilebilir.

Dolayısıyla, for...in döngüsünü kullanırken dikkatli olmanız ve gerekirse hasOwnProperty() gibi yöntemlerle kontrol yapmanız önemlidir.

16 )Generate an Array of All Object Keys with Object.keys( )

JavaScript’te, bir nesnenin tüm anahtarlarını içeren bir dizi oluşturmak için Object.keys() yöntemini kullanabiliriz. Object.keys() yöntemi, bir nesnenin kendi özelliklerini ve enumerable (gezilebilir) olan tüm anahtarlarını içeren bir dizi döndürür. Bu yöntemle nesnenin anahtarlarını elde edebiliriz. İşte Object.keys() yöntemini kullanarak bir nesnenin anahtarlarını dizi olarak elde etme örneği:

let kullanici = {
    ad: "John",
    soyad: "Doe",
    yas: 30
};

// `Object.keys()` yöntemi ile nesnenin anahtarlarını dizi olarak elde ediyoruz
let anahtarlarDizisi = Object.keys(kullanici);

console.log(anahtarlarDizisi);
// Çıktı: ["ad", "soyad", "yas"]

Yukarıdaki örnekte, Object.keys(kullanici) ifadesi ile kullanici nesnesinin tüm anahtarlarını içeren bir dizi oluşturduk. Daha sonra bu dizi anahtarlarDizisi değişkenine atandı.

Bu yöntem, genellikle bir nesnenin içeriğini dinamik olarak incelemek, döngülerde nesnenin anahtarlarını dolaşmak veya nesneyle çalışırken belirli anahtarların varlığını kontrol etmek için kullanılır. Bu yöntemle elde edilen dizi, nesnenin anahtarlarını içerir ve bu anahtarlar üzerinde döngüler veya diğer dizi işlemleri gerçekleştirebiliriz.