Penyataan Ulangan TypeScript

Artikel ini menerangkan penyataan ulangan dalam TypeScript.

YouTube Video

Penyataan for dalam TypeScript

Penyataan for dalam TypeScript adalah struktur gelung asas untuk melaksanakan operasi berulang. Dalam gelung for, blok kod yang sama boleh dilaksanakan berulang kali berdasarkan bilangan kali tertentu atau keadaan tertentu.

Sintaks Asas

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

• inisialisasi: Ini adalah bagian yang dieksekusi hanya sekali sebelum memulai loop. Menginisialisasikan variabel seperti penghitung loop.
• Kondisi (kondisi): Menentukan apakah loop berlanjut. Jika benar, terus ke loop, dan jika salah, keluar.
• *Update (update): Jalankan di akhir setiap loop dan update loop counter.

Contoh 1: Gelung for asas

Dalam contoh di bawah, ia mengeluarkan nombor dari 0 hingga 4 secara berurutan.

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

Contoh 2: Gelung for dengan tatasusunan

Anda juga boleh menggunakan gelung for untuk memproses elemen-elemen dalam tatasusunan secara berurutan.

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

Contoh 3: Gelung for-in

Gelung for-in digunakan untuk mengulang melalui sifat-sifat objek atau indeks tatasusunan dalam urutan.

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

Contoh 4: Gelung for-of

Gelung for-of digunakan untuk mendapatkan nilai setiap elemen secara berurutan daripada objek yang boleh diiterasi seperti tatasusunan atau rentetan.

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

Contoh 5: Gelung for Tertanam

Ia juga boleh menggunakan gelung for di dalam gelung for lain, yang dikenali sebagai gelung bersarang. Ini membolehkan anda mencipta gelung ganda, antara lain.

 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

Ringkasan

• Pernyataan for melaksanakan pemprosesan berulang berdasarkan kiraan atau syarat yang ditentukan.
• for-in digunakan untuk mendapatkan sifat-sifat objek atau indeks tatasusunan.
• for-of mendapatkan nilai elemen daripada objek yang boleh diiterasi seperti tatasusunan.
• Pemprosesan berulang yang kompleks juga boleh dilakukan dengan gelung for tertanam.

Penyataan for dalam TypeScript memberikan pemprosesan ulangan yang berkuasa dan fleksibel, serupa dengan gelung lain.

Pernyataan While dalam TypeScript

Dalam TypeScript, pernyataan while adalah satu struktur gelung yang melaksanakan proses berulang selagi keadaan yang ditentukan adalah true. Sama seperti gelung for, gelung while sesuai untuk kes-kes di mana bilangan ulangan tidak ditentukan terlebih dahulu, atau apabila anda ingin mengawal pengulangan berdasarkan suatu keadaan.

Sintaks Asas

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

• Keadaan: Keadaan yang menentukan bila gelung dilaksanakan. Gelung akan terus berjalan selagi keadaan ini adalah true, dan berhenti apabila ia menjadi false.

Contoh 1: Gelung while Asas

Dalam contoh di bawah, ia terus menghasilkan nilai i selagi i kurang daripada 5.

 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

Dalam contoh ini, gelung akan berakhir apabila i menjadi 5 atau lebih kerana keadaan menjadi false.

Contoh 2: Contoh Gelung Tak Berpenghujung

Jika keadaan dalam gelung while sentiasa true, ia boleh menjadi gelung tak berpenghujung. Ini biasanya menyebabkan program gagal berhenti seperti yang dimaksudkan, jadi berhati-hatilah.

 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

Anda boleh menggunakan pernyataan break untuk memaksa keluar dari gelung apabila suatu keadaan dipenuhi.

Contoh 3: Gelung do-while

Gelung do-while ialah satu struktur di mana proses gelung dilaksanakan sekurang-kurangnya sekali. Oleh kerana keadaan dinilai selepas proses, proses itu tetap berjalan sekurang-kurangnya sekali walaupun keadaan adalah false.

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

Dalam contoh ini, j adalah 5 sejak awal, dan j < 5 adalah false, tetapi dalam gelung do-while, ia tetap berjalan sekurang-kurangnya sekali tanpa mengira keadaan.

Ringkasan

• Gelung while mengulangi pemprosesan selagi keadaan adalah true.
• Jika keadaan penamatan gelung tidak jelas, anda perlu berhati-hati terhadap gelung tak berpenghujung.
• Gelung do-while berbeza daripada gelung while biasa kerana pemprosesan dilaksanakan sekurang-kurangnya sekali.

Pernyataan while dalam TypeScript berguna untuk pemprosesan gelung dengan bilangan ulangan yang tidak pasti atau apabila penilaian keadaan secara dinamik diperlukan.

break dan continue

Anda boleh menggunakan break dan continue dalam gelung.

• break digunakan untuk menamatkan gelung lebih awal.
• continue digunakan untuk melangkau ulang kitaran semasa dan bergerak ke kitaran seterusnya.

Contoh penggunaan break

 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

Dalam kes ini, break dilaksanakan apabila i menjadi 5. Akibatnya, nombor dari 0 hingga 4 dipaparkan.

Contoh penggunaan continue

 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

Dalam kes ini, continue dilaksanakan apabila i ialah 2. Akibatnya, nombor kecuali 2 dipaparkan.

Gelung bersarang dalam TypeScript

Gelung bersarang ialah struktur di mana gelung digunakan di dalam gelung yang lain. Dalam TypeScript, pembinaan gelung seperti for, while, dan do-while disokong. Dengan menggunakan gelung bersarang, anda boleh memproses tatasusunan dua dimensi (matriks) dan merampingkan pemprosesan berdasarkan pelbagai syarat.

Sintaks Asas

Sintaks asas bagi gelung bersarang adalah seperti berikut.

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}

Untuk setiap pelaksanaan gelung luar, gelung dalam menyelesaikan semua ulangkitarannya. Struktur ini sangat berguna apabila mengendalikan pelbagai gelung atau struktur data.

Contoh gelung bersarang dalam TypeScript

Melalui tatasusunan dua dimensi

Gelung bersarang sering digunakan apabila memanipulasi struktur data pelbagai dimensi seperti tatasusunan dua dimensi. Dalam contoh berikut, elemen tatasusunan dua dimensi dilalui, dan nilainya dipaparkan di konsol.

 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

Dalam contoh ini, kita sedang melalui tatasusunan dua dimensi matrix. Gelung luar mengendalikan baris, dan gelung dalam mengendalikan lajur, memaparkan setiap elemen dalam susunan yang betul.

Gabungan dua tatasusunan

Seterusnya, kami memperkenalkan contoh pengiraan semua gabungan dua tatasusunan. Sebagai contoh, anda boleh mengambil satu elemen daripada setiap dua tatasusunan dan menghasilkan semua pasangan yang mungkin.

 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)

Dalam contoh ini, semua pasangan antara tatasusunan rentetan array1 dan tatasusunan nombor array2 dicipta. Gelung luar mengeluarkan elemen daripada array1, dan gelung dalam mengeluarkan elemen daripada array2, memaparkan setiap pasangan.

Menjana koordinat dengan gelung tiga kali

Dengan menggunakan gelung bersarang tiga kali, anda boleh menjana koordinat dalam ruang tiga dimensi, sebagai contoh.

 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)

Dengan cara ini, penggunaan gelung bersarang tiga kali membolehkan anda menjana koordinat dalam ruang tiga dimensi dengan mudah.

Prestasi gelung bersarang

Gelung bersarang adalah mudah, tetapi kos pengiraan meningkat dengan cepat apabila kedalaman gelung meningkat. Sebagai contoh, jika terdapat n ulangan gelung luar dan m ulangan gelung dalam, jumlah keseluruhan ulangan akan menjadi n * m. Apabila ini menjadi lebih bersarang, kerumitan pengiraan meningkat secara eksponen, yang mungkin menjejaskan prestasi program.

Di bawah adalah kerumitan pengiraan apabila melalui tiga tatasusunan.

 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}

Dalam kes ini, anda perlu mengira array1.length * array2.length * array3.length, menghasilkan 3 * 3 * 3 = 27 ulangan untuk memproses semua gabungan.

Pengoptimuman gelung bersarang

Apabila menggunakan gelung bersarang, anda boleh meningkatkan prestasi dengan mempertimbangkan pengoptimuman berikut.

1. Perkenalkan penamatan awal: Keluar daripada gelung lebih awal apabila matlamat tercapai untuk mengelakkan ulangan yang tidak perlu.
2. Cache pembolehubah gelung: Simpan terlebih dahulu nilai pembolehubah yang digunakan dalam gelung (terutamanya panjang dan julat) untuk mengurangkan kos pengiraan setiap kali.
3. Ubah struktur data: Menyemak semula struktur tatasusunan dan objek boleh menjadi berkesan untuk mempercepatkan proses berulang tertentu.

Kesimpulan

Gelung bersarang adalah alat yang ampuh dalam pemprosesan data kompleks dan algoritma. Walau bagaimanapun, apabila kedalaman gelung dan bilangan ulangan meningkat, isu prestasi mungkin timbul. Dengan pengoptimuman yang sesuai dan reka bentuk yang teliti, anda boleh menggunakan gelung bersarang dengan berkesan dalam TypeScript.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video