JavaScript'te Tekrar İşleme

Bu makalede, JavaScript'teki tekrar işleme sürecini açıklayacağız.

YouTube Video

JavaScript'te for Ifadesi

Temel Sözdizimi

1for (initialization; condition; update) {
2  // Code to repeat
3}

for ifadesi, JavaScript'te döngü işlemleri gerçekleştirmek için kullanılan bir sözdizimidir. Belirli bir koşul karşılandığı sürece belirtilen bir kod bloğunu tekrar tekrar çalıştırır. for ifadesini kullanarak, aynı işlem verimli bir şekilde birden çok kez çalıştırılabilir.

• Başlatma (initialization): Döngü başlamadan önce yalnızca bir kez çalışan kısım. Döngü sayacı gibi değişkenleri başlatın.
• Koşul (condition): Döngünün devam edip etmeyeceğini belirleyen koşul. true ise döngü devam eder; false ise sona erer.
• Güncelleme (update): Döngü sayacını güncellemek için her döngünün sonunda çalıştırılır.

Örnek

1for (let i = 0; i < 5; i++) {
2    console.log(i);
3}

Bu durumda, i 0'dan başlar ve i < 5 true olduğu sürece döngü çalışır. i++, döngünün her yinelemesinde i'yi 1 artırır. Sonuç olarak, 0 ile 4 arasındaki sayılar görüntülenir.

Döngü Sayacının Kapsamı

for ifadesinin başlatma kısmında değişkenleri tanımlayın veya başlatın. Burada tanımlanan değişkenler yalnızca döngü içinde geçerlidir.

1for (let i = 0; i < 3; i++) {
2    console.log(i); // Outputs 0, 1, 2
3}
4console.log(i);  // ReferenceError

• Bu örnekte gösterildiği gibi, for ifadesinin dışındaki bir değişkene başvurmak bir hataya neden olur.

Sonsuz Döngü

Döngüyü sonlandırmayan bir koşul ayarlamak sonsuz bir döngüye neden olur. Bu, tarayıcı veya sistem üzerinde yük oluşturabilir, bu nedenle dikkatli olunmalıdır.

1for (;;) {
2    console.log("Infinite loop");
3    break; // Exits the infinite loop with break
4}

Diziler ve for Ifadesi

for ifadesinin dizilerle birlikte kullanılması yaygındır. Bir dizinin her bir öğesini işlemek için kullanışlıdır.

Örnek

1let fruits = ["apple", "banana", "cherry"];
2
3for (let i = 0; i < fruits.length; i++) {
4    console.log(fruits[i]);
5}
6// Outputs "apple", "banana", "cherry"

Bu şekilde, bir dizinin her bir öğesini indeksleri kullanarak işleyebilirsiniz.

Diğer Döngü Yapıları

for...of İfadesi

for...of ifadesi, diziler ve dizgiler gibi yinelenebilir nesneler için kullanılır.

1let fruits = ["apple", "banana", "cherry"];
2
3for (let fruit of fruits) {
4    console.log(fruit);
5}
6// Outputs "apple", "banana", "cherry"

Bu, her bir öğeyi indeks kullanmadan işlemenizi sağlar.

for...in İfadesi

for...in ifadesi, bir nesnenin özelliklerini yinelemek için kullanılır.

1let person = { name: "John", age: 30, city: "Tokyo" };
2
3for (let key in person) {
4    console.log(key + ": " + person[key]);
5}
6// Outputs "name: John", "age: 30", "city: Tokyo"

Bu şekilde, anahtarları kullanarak her bir öğe üzerinde işlemler gerçekleştirebilirsiniz.

Özet

• for ifadesi, başlatma, koşul ve güncelleme olmak üzere üç parçadan oluşan bir döngü yapısıdır.
• break veya continue kullanarak döngülerin davranışlarını kontrol edebilirsiniz.
• Diziler veya nesnelerle birleştirildiğinde, öğeler veya özellikler verimli bir şekilde işlenebilir.

JavaScript'teki while İfadesi

Temel Sözdizimi

1while (condition) {
2    // Code that repeats while the condition is true
3}

JavaScript'teki while ifadesi, belirtilen koşul true olduğu sürece tekrarlayan işlemleri gerçekleştiren bir döngü yapısıdır. for ifadesine benzer şekilde, while ifadesi yalnızca koşulu belirtir.

• Koşul: Döngünün devam edip etmeyeceğini belirleyen koşullu ifadeyi yazın. Döngü, değer true iken devam eder ve false olduğunda sona erer.

Örnek

1let i = 0;
2
3while (i < 5) {
4    console.log(i);
5    i++;
6}
7console.log(i);  // 5

Bu örnekte, döngü i değişkeni 0 değerinden başlar ve i < 5 true olduğu sürece çalışır. Her döngü yinelemesinde, i 1 artırılır ve i 5 olduğunda koşul false olur ve döngü sona erer. Sonuç olarak, while ifadesi 0'dan 4'e kadar olan değerleri gösterir.

for ifadesinden farklı olarak, while ifadesinde değişkenlerin başlatılması ve güncellenmesi ayrı ifadeler olarak yazılır. while ifadesinden sonra da değişkene başvurabilirsiniz. Bu durumda, while ifadesi sona erdikten sonra 5 görüntülenir.

Sonsuz Döngü

Koşul her zaman true olursa, sona ermeyen bir sonsuz döngü oluşur. Sonsuz döngülerden kaçınılmalıdır, ancak kasıtlı olarak kullanıldığında bir break ifadesiyle döngüyü sonlandırabilirsiniz.

Örnek

1while (true) {
2    console.log("Infinite loop");
3    break;  // Ends the loop with `break`
4}

while Döngüsü ile Dizileri İşleme

Diziler bir while ifadesi ile de işlenebilir.

Örnek

1let fruits = ["apple", "banana", "cherry"];
2let i = 0;
3
4while (i < fruits.length) {
5    console.log(fruits[i]);
6    i++;
7}
8// Outputs "apple", "banana", "cherry"

do...while İfadesi

Temel Sözdizimi

1do {
2    // Code that is executed at least once
3} while (condition);

do...while ifadesi, while ifadesinin bir çeşididir ve döngüyü en az bir kez çalıştırdıktan sonra koşulu kontrol eder. while ifadesi önce koşulu kontrol ederken, do...while ifadesi koşulu doğrulamadan önce işlemi bir kez çalıştırır.

Örnek

1let i = 0;
2
3do {
4    console.log(i);
5    i++;
6} while (i < 5);

Bu örnekte, i 0 ile 4 arasında görüntülenir. do...while ifadesi, koşul false olsa bile her zaman bir kez çalıştırıldığı için while ifadesinden farklıdır.

Özet

• while ifadesi, koşul true olduğu sürece kodu tekrar tekrar çalıştırmak için kullanılır.
• Sonsuz döngülere karşı dikkatli olun, ancak döngülerin akışını break ve continue ile kontrol edebilirsiniz.
• do...while ifadesi, döngüyü en az bir kez çalıştırmak istediğinizde kullanışlıdır.

break ve continue

break ve continue ifadelerini döngü içinde kullanabilirsiniz.

• break, döngüyü erken sonlandırmak için kullanılır.
• continue, mevcut yinelemeyi atlayarak bir sonraki yinelemeye geçer.

break Örneği

 1for (let i = 0; i < 10; i++) {
 2    if (i === 5) {
 3        break;  // Exits the loop when i is 5
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 2, 3, 4
 8
 9let i = 0;
10
11while (i < 10) {
12    if (i === 5) {
13        break;  // Ends the loop when i is 5
14    }
15    console.log(i++);
16}
17// Outputs 0, 1, 2, 3, 4

Bu durumda, i 5 olduğunda break çalıştırılır. Sonuç olarak, 0 ile 4 arasındaki sayılar görüntülenir.

continue Örneği

 1for (let i = 0; i < 5; i++) {
 2    if (i === 2) {
 3        continue;  // Skips when i is 2
 4    }
 5    console.log(i);
 6}
 7// Outputs 0, 1, 3, 4
 8
 9let i = 0;
10while (i < 5) {
11    i++;
12    if (i === 3) {
13        continue;  // Skips when i is 3
14    }
15    console.log(i);
16}
17// Outputs 1, 2, 4, 5

Bu durumda, i 2 olduğunda continue çalıştırılır. Sonuç olarak, 2 dışındaki sayılar görüntülenir.

JavaScript'te İç İçe Döngüler

JavaScript programlamasında, bir döngünün başka bir döngünün içinde bulunduğu yapıya iç içe döngü denir. Bu tür döngüler, belirli algoritmalar veya süreçler birden fazla boyut ya da katmana yayıldığında çok etkilidir. Örneğin, içinde diziler bulunan çok boyutlu bir diziyi işlemek tipik bir durumdur.

Burada iç içe döngülerin temel yapısını, kullanım örneklerini, dikkat edilmesi gereken noktaları ve optimizasyon değerlendirmelerini açıklayacağız.

İç İçe Döngülerin Temel Yapısı

İç içe döngülerin temel yapısı, bir veya daha fazla döngünün başka bir döngünün içinde yer aldığı bir formdur. Dış döngü her çalıştırıldığında, iç döngü o kadar kez çalıştırılır.

Aşağıda, iç içe geçmiş iki döngünün temel bir örneği verilmiştir.

 1for (let i = 0; i < 3; i++) {
 2    console.log(`Outer loop iteration: ${i}`);
 3
 4    for (let j = 0; j < 2; j++) {
 5        console.log(`  Inner loop iteration: ${j}`);
 6    }
 7}
 8// Output:
 9// Outer loop iteration: 0
10//   Inner loop iteration: 0
11//   Inner loop iteration: 1
12// Outer loop iteration: 1
13//   Inner loop iteration: 0
14//   Inner loop iteration: 1
15// Outer loop iteration: 2
16//   Inner loop iteration: 0
17//   Inner loop iteration: 1

Yukarıdaki kodda, i dış döngüde, j ise iç döngüde sayılmaktadır. Dış döngü her çalıştırıldığında, iç döngü iki kez çalıştırılır.

İç İçe Döngülerin Pratik Örneği

İç içe döngüler, özellikle çok boyutlu dizilerin işlenmesi için oldukça kullanışlıdır. Örneğin, iki boyutlu bir dizi işlerken hem satırları (dış döngü) hem de sütunları (iç döngü) yönetmeniz gerekir.

Aşağıdaki örnekte, iki boyutlu bir dizi işlenmiş ve her bir eleman yazdırılmıştır.

 1const matrix = [
 2  [1, 2, 3],
 3  [4, 5, 6],
 4  [7, 8, 9]
 5];
 6
 7for (let row = 0; row < matrix.length; row++) {
 8    for (let col = 0; col < matrix[row].length; col++) {
 9        console.log(`Element at [${row}][${col}] is: ${matrix[row][col]}`);
10    }
11}
12// Output:
13// Element at [0][0] is: 1
14// Element at [0][1] is: 2
15// Element at [0][2] is: 3
16// Element at [1][0] is: 4
17// Element at [1][1] is: 5
18// Element at [1][2] is: 6
19// Element at [2][0] is: 7
20// Element at [2][1] is: 8
21// Element at [2][2] is: 9

Bu şekilde, iç içe döngüler kullanılarak iki boyutlu bir dizinin her bir elemanına erişim sağlanır.

Notlar

İç içe döngüler kullanırken dikkat edilmesi gereken bazı noktalar vardır.

1. Performans Sorunları

   İç içe döngüler derinleştikçe, çalışma süresi keskin bir şekilde artar. Örneğin, dış döngü 100 kez, iç döngü de 100 kez çalıştırılırsa toplam 10.000 işlem gerçekleştirilir. Bu nedenle, çok sayıda döngü tekrarı varsa, verimlilik için döngü optimizasyonu düşünmelisiniz.

2. Karmaşık Algoritmalara Uygulama

   İç içe döngüler çok güçlüdür, ancak işlemler karmaşık hale geldikçe kod anlaşılması zor hale gelebilir. Bu nedenle, kod okunabilirliğini korumak için işlemleri uygun açıklamalar ve fonksiyonlarla düzenlemek önemlidir.

Optimizasyon Düşünceleri

İç içe döngüler kullanıldığında, aşağıdaki optimizasyonlar düşünülebilir.

1. Erken Döngü Sonlandırma

   Döngü içinde belirli bir koşul sağlandığında, break ifadesini kullanarak döngüden çıkabilirsiniz. Bu, gereksiz döngüleri önleyebilir ve performansı artırabilir.

1for (let i = 0; i < 5; i++) {
2    for (let j = 0; j < 5; j++) {
3        if (i + j > 5) {
4            break;
5        }
6        console.log(`i: ${i}, j: ${j}`);
7    }
8}

2. Hesaplamaları Dışarı Taşıma

   Aynı hesaplamayı her seferinde döngü içinde yapmak yerine, hesaplamayı bir kez döngü dışında gerçekleştirebilir ve sonucu süreci daha verimli hale getirmek için kullanabilirsiniz.

 1let array = [1, 2, 3, 4, 5];
 2
 3// Inefficient example (calculating every time)
 4for (let i = 0; i < array.length; i++) {
 5    for (let j = 0; j < array.length; j++) {
 6        let sum = array[i] + array[j];
 7        console.log(sum);
 8    }
 9}
10
11// Efficient example (calculating outside)
12let arrayLength = array.length;
13for (let i = 0; i < arrayLength; i++) {
14    for (let j = 0; j < arrayLength; j++) {
15        let sum = array[i] + array[j];
16        console.log(sum);
17    }
18}

Özet

İç içe döngüler, JavaScript'te karmaşık veri yapıları ve algoritmaları işlemek için çok kullanışlıdır. Ancak, düzgün kullanılmazsa, performans düşüklüğüne ve kod okunabilirliğinin azalmasına yol açabilirler. İç içe döngüleri etkili bir şekilde kullanmak için, döngü optimizasyonu ve kod organizasyonu sağlamak ve duruma göre uygun yaklaşımlar benimsemek önemlidir.

Yukarıdaki makaleyi, YouTube kanalımızda Visual Studio Code'u kullanarak takip edebilirsiniz. Lütfen YouTube kanalını da kontrol edin.

YouTube Video