1. Unutulan `await` Anahtar Kelimesi
Birçok geliştirici asenkron kod yazarken, `await` anahtar kelimesini unutmak çok kolay. Bu hatanın sonucunda, fonksiyonlar beklenmedik şekilde çalışabilir veya asenkron işlemler sırasız gerçekleşebilir. Ama merak etme, çözümü oldukça basit!
async function getData() {
let data = fetch("https://api.example.com/data");
console.log(data); // Hata: Promise gösteriliyor, veriye ulaşılmıyor!
}
```
Çözüm: `await` anahtar kelimesini eklemeyi unutma!
```javascript
async function getData() {
let data = await fetch("https://api.example.com/data");
console.log(data); // Doğru: Veriyi aldıktan sonra konsola yazdırıyoruz.
}
```
Not: `await`, yalnızca `async` fonksiyonları içinde çalışır. Yani, fonksiyonunun başına `async` eklemeyi de unutma!
2. Hataları Yöneten `catch` Bloğunun Eksikliği
Asenkron işlemlerde hata yönetimi çok önemli. Bir `Promise`'in başarısız olması durumunda, hatayı düzgün bir şekilde yakalamazsan, kodun patlayabilir. Her asenkron işlemde `catch` bloğu kullanarak bu hatalardan kaçınabilirsin.
async function getData() {
let data = await fetch("https://api.example.com/data");
let json = await data.json(); // Eğer API hatalıysa, burası çöker.
console.log(json);
}
```
Çözüm: Hata yakalama bloğu ekleyelim!
```javascript
async function getData() {
try {
let data = await fetch("https://api.example.com/data");
let json = await data.json();
console.log(json);
} catch (error) {
console.error("Bir hata oluştu:", error); // Hata mesajını daha iyi yönetiyoruz.
}
}
```
Not: `try-catch` bloğu kullanmak, asenkron işlemlerin hata yönetiminde olmazsa olmazdır!
3. Promise Zinciri ve `async/await` Karışıklığı
`async/await` kullanmanın amacı, kodu daha okunabilir ve senkron gibi yazmaktır. Ancak bazen geliştiriciler, `Promise` zincirini kullanmaya devam ederler, bu da kodun karmaşıklaşmasına neden olabilir.
function getData() {
return fetch("https://api.example.com/data")
.then(response => response.json())
.then(json => console.log(json));
}
async function handleData() {
let data = await getData();
}
```
Çözüm: Sadece bir yaklaşımı tercih etmelisin. Ya `Promise` zinciri ya da `async/await`!
```javascript
async function getData() {
let response = await fetch("https://api.example.com/data");
let json = await response.json();
console.log(json);
}
```
Bu şekilde, kodun çok daha temiz ve anlaşılır olur.
4. Yanlış Yerleştirilen `await` Anahtar Kelimesi
`await` sadece `Promise` döndüren fonksiyonlar için kullanılmalıdır. Eğer bir fonksiyon normal bir değer döndürüyorsa, `await` gereksiz olur ve hata mesajları alabilirsin.
async function calculate() {
let result = await 5 + 5; // Burada `await` gereksiz!
console.log(result);
}
```
Çözüm: `await`, yalnızca `Promise` döndüren işlemlerde kullanılmalıdır!
```javascript
async function calculate() {
let result = 5 + 5; // Sadece işlem yapıyoruz, `await` gereksiz.
console.log(result);
}
```
Bu şekilde kodun daha verimli çalışır!
5. Asenkron Fonksiyonlarda Döngü ve `await` Kullanımı
Asenkron fonksiyonları döngü içinde kullanırken, her `await` işleminin sırasını beklemek yerine, tüm işlemleri aynı anda başlatmak daha hızlı olabilir.
async function getAllData() {
let data1 = await fetch("https://api.example.com/data1");
let data2 = await fetch("https://api.example.com/data2");
console.log(data1, data2); // Bu, sırayla gerçekleşir ve zaman alır.
}
```
Çözüm: Asenkron işlemleri paralel hale getirebilirsin!
```javascript
async function getAllData() {
let data1Promise = fetch("https://api.example.com/data1");
let data2Promise = fetch("https://api.example.com/data2");
let data1 = await data1Promise;
let data2 = await data2Promise;
console.log(data1, data2); // Bu, paralel çalışır ve daha hızlıdır.
}
```
Bu sayede, veriler paralel olarak çekilir ve uygulaman daha hızlı çalışır!
