Câu lệnh lặp trong TypeScript

Bài viết này giải thích các câu lệnh lặp trong TypeScript.

YouTube Video

Câu lệnh for trong TypeScript

Câu lệnh for trong TypeScript là một cấu trúc vòng lặp cơ bản để thực hiện các thao tác lặp lại. Trong một vòng lặp for, cùng một khối mã có thể được thực thi nhiều lần dựa trên số lần hoặc điều kiện xác định.

Cú pháp Cơ bản

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

• ..
• ..
• .

Ví dụ 1: Vòng lặp for cơ bản

Trong ví dụ dưới đây, nó xuất ra các số từ 0 đến 4 theo thứ tự.

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

Ví dụ 2: Vòng lặp for với một mảng

Bạn cũng có thể sử dụng vòng lặp for để xử lý các phần tử của một mảng theo thứ tự.

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

Ví dụ 3: Vòng lặp for-in

Vòng lặp for-in được sử dụng để lặp qua các thuộc tính của một đối tượng hoặc chỉ số của một mảng theo thứ tự.

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

Ví dụ 4: Vòng lặp for-of

Vòng lặp for-of được sử dụng để lấy giá trị của từng phần tử theo thứ tự từ các đối tượng có thể lặp lại như mảng hoặc chuỗi.

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

Ví dụ 5: Vòng lặp for lồng nhau

Cũng có thể sử dụng một vòng lặp for bên trong một vòng lặp for khác, được gọi là vòng lặp lồng nhau. Điều này cho phép bạn tạo các vòng lặp kép, cùng với nhiều thứ khác.

 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

Tóm tắt

• Câu lệnh for thực hiện xử lý lặp lại dựa trên số lần hoặc điều kiện được chỉ định.
• for-in được sử dụng để lấy các thuộc tính của một đối tượng hoặc các chỉ số của một mảng.
• for-of truy xuất các giá trị của các phần tử từ các đối tượng có thể lặp lại như mảng.
• Xử lý lặp lại phức tạp cũng có thể thực hiện bằng cách sử dụng các vòng lặp for lồng nhau.

Câu lệnh for trong TypeScript cung cấp khả năng xử lý lặp lại mạnh mẽ và linh hoạt, tương tự như các vòng lặp khác.

Câu lệnh While trong TypeScript

Trong TypeScript, câu lệnh while là một cấu trúc vòng lặp thực hiện một quy trình lặp lại khi điều kiện đã chỉ định là true. Tương tự như vòng lặp for, vòng lặp while phù hợp với các trường hợp mà số lần lặp không được xác định trước, hoặc khi bạn muốn kiểm soát sự lặp lại dựa trên một điều kiện.

Cú pháp Cơ bản

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

• Điều kiện: Điều kiện mà vòng lặp sẽ thực hiện. Vòng lặp sẽ tiếp tục miễn là điều kiện này là true và dừng lại khi điều kiện trở thành false.

Ví dụ 1: Vòng lặp while cơ bản

Trong ví dụ dưới đây, vòng lặp tiếp tục xuất giá trị của i khi i nhỏ hơn 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

Trong ví dụ này, vòng lặp sẽ kết thúc khi i đạt đến 5 hoặc lớn hơn do điều kiện trở thành false.

Ví dụ 2: Ví dụ về vòng lặp vô hạn

Nếu điều kiện trong vòng lặp while luôn là true, nó có thể trở thành một vòng lặp vô hạn. Điều này thường khiến chương trình không thể dừng lại như ý định ban đầu, vì vậy cần thận trọng.

 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

Bạn có thể sử dụng câu lệnh break để cưỡng ép thoát khỏi vòng lặp khi một điều kiện được thỏa mãn.

Ví dụ 3: Vòng lặp do-while

Vòng lặp do-while là một cấu trúc mà quá trình vòng lặp được thực hiện ít nhất một lần. Vì điều kiện được đánh giá sau khi xử lý, quá trình vẫn chạy ít nhất một lần ngay cả khi điều kiện là 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

Trong ví dụ này, j là 5 ngay từ đầu, và j < 5 là false, nhưng trong vòng lặp do-while, nó sẽ được thực thi ít nhất một lần bất kể điều kiện như thế nào.

Tóm tắt

• Vòng lặp while lặp lại xử lý miễn là điều kiện là true.
• Nếu điều kiện kết thúc vòng lặp không rõ ràng, bạn cần cẩn thận với vòng lặp vô hạn.
• Vòng lặp do-while khác với vòng lặp while thông thường ở chỗ quá trình xử lý được thực hiện ít nhất một lần.

Câu lệnh while trong TypeScript hữu ích cho việc xử lý vòng lặp với số lượt lặp không chắc chắn hoặc khi cần kiểm tra điều kiện động.

break và continue

Bạn có thể sử dụng break và continue trong vòng lặp.

• break được sử dụng để kết thúc vòng lặp sớm.
• continue được sử dụng để bỏ qua lần lặp hiện tại và chuyển sang lần lặp tiếp theo.

Ví dụ về 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

Trong trường hợp này, break được thực thi khi i đạt giá trị 5. Kết quả là các số từ 0 đến 4 sẽ được hiển thị.

Ví dụ về 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

Trong trường hợp này, continue được thực thi khi i là 2. Kết quả là các số ngoại trừ 2 sẽ được hiển thị.

Vòng lặp lồng nhau trong TypeScript

Vòng lặp lồng nhau là một cấu trúc trong đó một vòng lặp được sử dụng bên trong một vòng lặp khác. Trong TypeScript, các cấu trúc vòng lặp như for, while và do-while được hỗ trợ. Bằng cách sử dụng vòng lặp lồng nhau, bạn có thể xử lý mảng hai chiều (ma trận) và tối ưu hóa xử lý dựa trên nhiều điều kiện.

Cú pháp Cơ bản

Cú pháp cơ bản của vòng lặp lồng nhau như sau.

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}

Đối với mỗi lần thực thi của vòng lặp bên ngoài, vòng lặp bên trong sẽ hoàn thành tất cả các lần lặp của nó. Cấu trúc này rất hữu ích khi xử lý nhiều vòng lặp hoặc cấu trúc dữ liệu.

Ví dụ về vòng lặp lồng nhau trong TypeScript

Duyệt qua mảng hai chiều

Vòng lặp lồng nhau thường được sử dụng khi thao tác với các cấu trúc dữ liệu đa chiều như mảng hai chiều. Trong ví dụ sau, các phần tử của một mảng hai chiều được duyệt qua, và giá trị của chúng được hiển thị trên bảng điều khiển.

 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

Trong ví dụ này, chúng ta đang duyệt qua mảng hai chiều matrix. Vòng lặp ngoài xử lý các hàng, và vòng lặp trong xử lý các cột, hiển thị từng phần tử theo thứ tự.

Kết hợp hai mảng

Tiếp theo, chúng tôi giới thiệu một ví dụ về việc tính toán tất cả các kết hợp của hai mảng. Ví dụ, bạn có thể lấy một phần tử từ mỗi mảng trong hai mảng và xuất tất cả các cặp khả thi.

 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)

Trong ví dụ này, tất cả các cặp giữa mảng chuỗi array1 và mảng số array2 đều được tạo. Vòng lặp ngoài trích xuất các phần tử từ array1, và vòng lặp trong trích xuất các phần tử từ array2, hiển thị từng cặp.

Tạo tọa độ với ba vòng lặp lồng nhau

Bằng cách sử dụng ba vòng lặp lồng nhau, bạn có thể tạo tọa độ trong không gian ba chiều, ví dụ.

 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)

Theo cách này, việc sử dụng ba vòng lặp lồng nhau giúp bạn dễ dàng tạo tọa độ trong không gian ba chiều.

Hiệu năng của các vòng lặp lồng nhau

Vòng lặp lồng nhau rất tiện lợi, nhưng chi phí tính toán tăng nhanh khi độ sâu của vòng lặp tăng. Ví dụ, nếu có n vòng lặp ngoài và m vòng lặp trong, thì tổng số vòng lặp sẽ là n * m. Khi điều này lồng nhau hơn, độ phức tạp tính toán tăng theo cấp số nhân, có thể ảnh hưởng đến hiệu năng của chương trình.

Dưới đây là độ phức tạp tính toán khi duyệt qua ba mảng.

 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}

Trong trường hợp này, bạn cần tính array1.length * array2.length * array3.length, dẫn đến 3 * 3 * 3 = 27 vòng lặp để xử lý tất cả các kết hợp.

Tối ưu hóa các vòng lặp lồng nhau

Khi sử dụng các vòng lặp lồng nhau, bạn có thể cải thiện hiệu năng bằng cách cân nhắc các tối ưu hóa sau.

1. Giới thiệu thoát sớm: Thoát vòng lặp sớm khi đạt được mục tiêu để tránh các vòng lặp không cần thiết.
2. Lưu bộ nhớ tạm các biến vòng lặp: Lưu trước các giá trị của biến được sử dụng trong vòng lặp (đặc biệt là độ dài và phạm vi) để giảm chi phí tính toán mỗi lần.
3. Thay đổi cấu trúc dữ liệu: Sửa đổi cấu trúc của mảng và đối tượng có thể hiệu quả trong việc tăng tốc các quy trình lặp lại cụ thể.

Kết luận

Vòng lặp lồng nhau là một công cụ mạnh mẽ trong xử lý dữ liệu phức tạp và thuật toán. Tuy nhiên, khi độ sâu của vòng lặp và số vòng lặp tăng lên, có thể phát sinh các vấn đề về hiệu năng. Với các tối ưu hóa thích hợp và thiết kế cẩn thận, bạn có thể tận dụng vòng lặp lồng nhau một cách hiệu quả trong TypeScript.

Bạn có thể làm theo bài viết trên bằng cách sử dụng Visual Studio Code trên kênh YouTube của chúng tôi. Vui lòng ghé thăm kênh YouTube.

YouTube Video