TypeScript Tekrar İfadeleri

Bu makale, TypeScript'teki tekrar ifadelerini açıklar.

YouTube Video

TypeScript'te for ifadesi

TypeScript'teki for ifadesi, tekrarlı işlemler yapmak için temel bir döngü yapısıdır. for döngüsünde, belirli bir sayıya veya koşula dayalı olarak aynı kod bloğu tekrar tekrar çalıştırılabilir.

Temel Sözdizimi

1for (initialization; condition; update) {
2    // Code to execute repeatedly while the condition is true
3}

• inalizasyon: Bu, döngüye başlamadan önce sadece bir kez idam edilen kısımdır. döngü sayacı gibi başlangıç değişkenleri.
• Conditions (' conditions'): döngünün devam ettirip devam etmeyeceğini belirler. Eğer doğruysa, döngüye devam edin ve eğer sahte, çıkış.
• Güncelleme (tarihi): Her döngünün sonunda hareket edin ve döngü sayacı güncelleştirme.

Örnek 1: Temel for döngüsü

Aşağıdaki örnekte, 0 ile 4 arasındaki sayıları sırayla çıktılar.

1for (let i = 0; i < 5; i++) {
2    console.log("The value of i is: " + i);
3}
4// Outputs:
5// The value of i is: 0
6// The value of i is: 1
7// The value of i is: 2
8// The value of i is: 3
9// The value of i is: 4

Örnek 2: Dizi ile for döngüsü

Bir for döngüsünü kullanarak bir dizinin elemanlarını sırayla işleyebilirsiniz.

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

Örnek 3: for-in döngüsü

for-in döngüsü, bir nesnenin özelliklerini veya bir dizinin dizinlerini sırayla dolaşmak için kullanılır.

1let car = { brand: "Toyota", model: "Corolla", year: 2020 };
2
3for (let key in car) {
4    console.log(key + ": " + car[key]);
5}
6// Outputs:
7// brand: Toyota
8// model: Corolla
9// year: 2020

Örnek 4: for-of döngüsü

for-of döngüsü, diziler veya metinler gibi yinelenebilir nesnelerden her bir elemanın değerini sırayla almak için kullanılır.

1let colors: string[] = ["red", "green", "blue"];
2
3for (let color of colors) {
4    console.log("Color: " + color);
5}
6// Outputs:
7// Color: red
8// Color: green
9// Color: blue

Örnek 5: İç içe for Döngüsü

Bir başka for döngüsünün içinde bir for döngüsü kullanmak da mümkündür, buna iç içe döngü denir. Bu, diğer şeylerin yanı sıra, çift döngüler oluşturmanıza olanak tanır.

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

Özet

• for ifadesi, belirtilen sayılara veya koşullara dayalı olarak tekrarlı işlem gerçekleştirir.
• for-in, bir nesnenin özelliklerini veya bir dizinin indekslerini almak için kullanılır.
• for-of, diziler gibi tekrarlanabilir nesnelerin öğelerinin değerlerini alır.
• İç içe for döngüleri ile karmaşık tekrarlı işlemler de mümkündür.

TypeScript'teki for ifadesi, diğer döngülerle benzer şekilde güçlü ve esnek tekrarlı işlemler sağlar.

TypeScript'te While İfadeleri

TypeScript'te, bir while ifadesi, belirtilen koşul true olduğu sürece tekrarlı bir işlemi gerçekleştiren bir döngü yapısıdır. for döngüsüne benzer şekilde, while döngüsü, yineleme sayısının önceden belirlenmediği veya tekrarı bir koşula dayalı olarak kontrol etmek istediğiniz durumlar için uygundur.

Temel Sözdizimi

1while (condition) {
2    // Code to execute repeatedly while the condition is true
3}

• Koşul: Döngünün çalıştığı durum. Bu koşul true olduğu sürece döngü devam eder ve false olduğunda durur.

Örnek 1: Temel while Döngüsü

Aşağıdaki örnekte, i 5'ten küçük olduğu sürece i değerini çıktılar.

 1let i: number = 0;
 2
 3while (i < 5) {
 4    console.log("The value of i is: " + i);
 5    i++;
 6}
 7// Outputs:
 8// The value of i is: 0
 9// The value of i is: 1
10// The value of i is: 2
11// The value of i is: 3
12// The value of i is: 4

Bu örnekte, i 5'e eşit veya daha büyük olduğunda döngü sona erer çünkü koşul false olur.

Örnek 2: Sonsuz Döngü Örneği

Bir while döngüsündeki koşul her zaman true ise, bu sonsuz bir döngüye dönüşebilir. Bu genellikle programın planlandığı şekilde durmasını engeller, bu yüzden dikkat edilmelidir.

 1let x: number = 0;
 2
 3while (true) {
 4    console.log("The value of x is: " + x);
 5    x++;
 6    if (x >= 5) {
 7        break; // Exit the loop when the condition is met
 8    }
 9}
10// Outputs:
11// The value of x is: 0
12// The value of x is: 1
13// The value of x is: 2
14// The value of x is: 3
15// The value of x is: 4

Bir koşul sağlandığında döngüden zorla çıkmak için break ifadesini kullanabilirsiniz.

Örnek 3: do-while Döngüsü

do-while döngüsü, döngü işleminin en az bir kez gerçekleştirildiği bir yapıdır. Koşul işlemden sonra değerlendirildiğinden, koşul false olsa bile işlem en az bir kez çalışır.

1let j: number = 5;
2
3do {
4    console.log("The value of j is: " + j);
5    j++;
6} while (j < 5);
7// Outputs: The value of j is: 5

Bu örnekte, j başından beri 5tir ve j < 5 falsetur, ancak bir do-while döngüsünde, koşula bakılmaksızın en az bir kez çalışır.

Özet

• while döngüsü, koşul true olduğu sürece işlemi tekrar eder.
• Döngü sonlandırma koşul belirsizse, sonsuz döngülere dikkat etmeniz gerekir.
• do-while döngüsü, işlemin en az bir kez gerçekleştirildiği noktada normal bir while döngüsünden farklıdır.

TypeScript'teki while ifadesi, belirsiz yineleme sayılarıyla döngü işlemleri için ya da dinamik koşul kontrolü gerektiğinde yararlıdır.

break ve continue

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

• break, bir döngüyü erken sonlandırmak için kullanılır.
• continue, mevcut tekrarı atlamak ve bir sonraki tekrara geçmek için kullanılır.

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 değeri 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;
10
11while (i < 5) {
12    i++;
13    if (i === 3) {
14        continue;  // Skips when i is 3
15    }
16    console.log(i);
17}
18// Outputs 1, 2, 4, 5

Bu durumda, i değeri 2 olduğunda continue çalıştırılır. Sonuç olarak, 2 hariç diğer sayılar görüntülenir.

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

İç içe döngü, bir döngünün başka bir döngü içinde kullanıldığı bir yapıdır. TypeScript'te for, while, ve do-while gibi döngü yapıları desteklenir. İç içe döngüler kullanarak iki boyutlu dizileri (matrisleri) işleyebilir ve birden fazla koşula dayalı işlemleri kolaylaştırabilirsiniz.

Temel Sözdizimi

İç içe bir döngünün temel söz dizimi şu şekildedir.

1for (let i: number = 0; i < n; i++) {
2  for (let j: number = 0; j < m; j++) {
3    // Processing for the inner loop
4  }
5}

Dış döngünün her çalıştırılmasında, iç döngü tüm tekrarlarını tamamlar. Bu yapı, birden fazla döngü veya veri yapısını işlerken oldukça kullanışlıdır.

TypeScript'te İç İçe Döngü Örneği

İki Boyutlu Bir Diziyi Gezme

İç içe döngüler, iki boyutlu diziler gibi çok boyutlu veri yapılarını işlerken sıklıkla kullanılır. Aşağıdaki örnekte, iki boyutlu bir dizinin elemanları gezilir ve değerleri konsola yazdırılır.

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

Bu örnekte, matrix isimli iki boyutlu bir dizi gezilmektedir. Dış döngü satırları, iç döngü ise sütunları işler ve her bir elemanı sırayla görüntüler.

İki dizinin kombinasyonu

Sonrasında, iki dizinin tüm kombinasyonlarını hesaplamaya yönelik bir örnek sunacağız. Örneğin, iki diziden birer eleman seçerek tüm olası çiftleri üretebilirsiniz.

 1const array1: string[] = ['A', 'B', 'C'];
 2const array2: number[] = [1, 2, 3];
 3
 4for (let i: number = 0; i < array1.length; i++) {
 5  for (let j: number = 0; j < array2.length; j++) {
 6    console.log(`Pair: (${array1[i]}, ${array2[j]})`);
 7  }
 8}
 9// Output
10// Pair: (A, 1)
11// Pair: (A, 2)
12// Pair: (A, 3)
13// Pair: (B, 1)
14// Pair: (B, 2)
15// Pair: (B, 3)
16// Pair: (C, 1)
17// Pair: (C, 2)
18// Pair: (C, 3)

Bu örnekte, array1 dizisi (metin) ile array2 dizisi (sayı) arasındaki tüm çiftler oluşturulmaktadır. Dış döngü array1'den elemanları alırken, iç döngü array2'den elemanları alır ve her bir çifti görüntüler.

Üçlü bir döngü ile koordinatların üretilmesi

Örneğin, üçlü iç içe geçmiş döngüler kullanarak üç boyutlu bir alanda koordinatlar oluşturabilirsiniz.

 1for (let x: number = 0; x < 3; x++) {
 2  for (let y: number = 0; y < 3; y++) {
 3    for (let z: number = 0; z < 3; z++) {
 4      console.log(`Coordinate: (${x}, ${y}, ${z})`);
 5    }
 6  }
 7}
 8// Output
 9// Coordinate: (0, 0, 0)
10// Coordinate: (0, 0, 1)
11// Coordinate: (0, 0, 2)
12// ...
13// Coordinate: (2, 2, 1)
14// Coordinate: (2, 2, 2)

Bu şekilde, üçlü iç içe geçmiş döngüler, üç boyutlu bir alanda kolayca koordinatlar oluşturmanıza olanak sağlar.

İç içe döngülerin performansı

İç içe döngüler kullanışlıdır ancak döngülerin derinliği arttıkça hesaplama maliyeti de hızla artar. Örneğin, dış döngü n yineleme ve iç döngü m yineleme yapıyorsa, toplam yineleme sayısı n * m olacaktır. Bu daha da iç içe hale geldiğinde, hesaplama karmaşıklığı üstel olarak artar ve bu durum programın performansını etkileyebilir.

Üç diziyi dolaşırken oluşan hesaplama karmaşıklıkları aşağıda verilmiştir.

 1const array1: number[] = [1, 2, 3];
 2const array2: number[] = [4, 5, 6];
 3const array3: number[] = [7, 8, 9];
 4
 5for (let i: number = 0; i < array1.length; i++) {
 6  for (let j: number = 0; j < array2.length; j++) {
 7    for (let k: number = 0; k < array3.length; k++) {
 8      console.log(`Combination: (${array1[i]}, ${array2[j]}, ${array3[k]})`);
 9    }
10  }
11}

Bu durumda, array1.length * array2.length * array3.length hesaplanmalı ve tüm kombinasyonları işlemek için 3 * 3 * 3 = 27 yineleme yapılmalıdır.

İç içe döngülerin optimizasyonu

İç içe döngüler kullanırken, aşağıdaki optimizasyonları dikkate alarak performansı artırabilirsiniz.

1. Erken çıkışlar ekleyin: Hedefe ulaşıldığında döngüden erken çıkış yaparak gereksiz yinelemeleri önleyin.
2. Döngü değişkenlerini önbelleğe alın: Döngü içinde kullanılan değişkenlerin (özellikle uzunluklar ve aralıklar) değerlerini önceden önbelleğe alarak her defasında aynı hesaplama maliyetini düşürün.
3. Veri yapısını değiştirin: Dizilerin ve nesnelerin yapısını gözden geçirerek belirli tekrarlamalı işlemleri hızlandırmak etkili olabilir.

Sonuç

İç içe döngüler, karmaşık veri işleme ve algoritmalar için güçlü bir araçtır. Ancak, döngü derinliği ve yineleme sayısı arttıkça performans sorunları meydana gelebilir. Uygun optimizasyonlar ve dikkatli bir tasarımla, iç içe döngüler TypeScript'te etkili bir şekilde kullanılabilir.

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

YouTube Video