Bir projede çalışırken birden fazla veriye aynı anda ulaşmak gerekebilir. Bir nesnenin özelliklerine erişmek ya da bir diziden değer almak için uzun, karmaşık satırlara ihtiyacınız yok. İşte burada destructuring devreye giriyor.
Diyelim ki şöyle bir nesnemiz var:
```javascript
const user = { name: "Ahmet", age: 25, country: "Türkiye" };
```
Eğer `name` ve `country` değerlerine hızlıca erişmek istiyorsanız, aşağıdaki gibi yazabilirsiniz:
```javascript
const { name, country } = user;
console.log(name, country); // Ahmet Türkiye
```
Bu yöntem, kodunuzu daha kısa ve anlaşılır hale getirir. Bu basit ama güçlü özellik, özellikle büyük nesnelerde çok faydalıdır.
Birçok JavaScript geliştiricisi, derin nesne erişimlerinde hata alır. Mesela, bir API’den gelen verilerde bazen bazı nesneler eksik olabilir. Bu da "TypeError: Cannot read property of undefined" hatalarına yol açar. Optional chaining sayesinde, derin nesnelere güvenle erişebilirsiniz.
Bir örnek üzerinden gidelim:
```javascript
const user = { profile: { name: "Ahmet", address: { city: "İstanbul" } } };
console.log(user?.profile?.address?.city); // İstanbul
console.log(user?.profile?.phone?.number); // undefined
```
Burada `?.` operatörü, değer mevcutsa o özelliğe erişmeye çalışır, yoksa `undefined` döner. Böylece kodunuzu hata almadan çok daha güvenli hale getirebilirsiniz.
JavaScript’te string birleştirmek her zaman kolay değildir, özellikle uzun ve dinamik metinlerde. Fakat template literals (backtick ile tanımlanan stringler), çok daha temiz ve okunabilir bir kod yazmanızı sağlar.
Örneğin, aşağıdaki gibi bir string birleştirmeyi düşünün:
```javascript
const name = "Ahmet";
const age = 25;
const message = "Benim adım " + name + " ve yaşım " + age + "!";
console.log(message); // Benim adım Ahmet ve yaşım 25!
```
Bunun yerine template literals kullanarak şu şekilde yazabilirsiniz:
```javascript
const message = `Benim adım ${name} ve yaşım ${age}!`;
console.log(message); // Benim adım Ahmet ve yaşım 25!
```
Bu yöntem, hem okunabilirliği artırır hem de dinamik stringler oluşturmayı çok daha kolay hale getirir.
JavaScript, değerleri kontrol etmek için çeşitli operatörler sunar. Ancak bazen `null` ve `undefined` arasında fark yapmak gereklidir. İşte nullish coalescing operator (??) burada devreye giriyor. Bu operatör, sadece `null` veya `undefined` değerlerini kontrol eder, `0`, `false` veya `NaN` gibi değerleri görmezden gelir.
Bir örnek verelim:
```javascript
const userAge = 0;
const age = userAge ?? 18;
console.log(age); // 0
```
Burada, `userAge` `null` veya `undefined` olsaydı, `18` değerini alırdık. Fakat, `0` değeri olduğu için değişken olduğu gibi kullanılıyor.
Asenkron JavaScript kodları yazarken, bazen birden fazla asenkron işlem yapılır ve her birinin sonucunu beklemek gerekir. Promise.allSettled, tüm işlemlerin bitmesini bekler ve her birinin sonucunu size bildirir.
Örneğin, iki API isteği yapalım:
```javascript
const request1 = fetch("https://api.example.com/data1");
const request2 = fetch("https://api.example.com/data2");
Promise.allSettled([request1, request2])
.then(results => {
results.forEach(result => {
if (result.status === "fulfilled") {
console.log("Başarı:", result.value);
} else {
console.log("Hata:", result.reason);
}
});
});
```
Bu yöntemle, hem başarılı hem de başarısız işlemleri tek bir yerde yönetebiliriz. Böylece asenkron kodları daha temiz ve verimli bir şekilde yazabilirsiniz.
