▷ Hướng dẫn về vòng lặp Golang [With Examples]

Tìm hiểu tất cả về vòng lặp Golang bằng cách viết mã một số ví dụ hữu ích.

Gần đây, các ngôn ngữ lập trình như Rust, Golang và TypeScript đã trở nên rất phổ biến đối với các lập trình viên. Nếu bạn quan tâm đến phát triển back-end và DevOps, bạn nên xem việc học Golang là một lựa chọn tuyệt vời!

Nếu bạn chưa quen với kiến thức cơ bản về ngôn ngữ lập trình, thì cấu trúc vòng lặp là một trong những khái niệm đầu tiên bạn nên hiểu.

Golang chỉ cung cấp cấu trúc vòng lặp for. Chúng ta cũng sẽ tìm hiểu về vòng lặp for cũng như cách mô phỏng các vòng lặp khác bằng vòng lặp for.

Hãy bắt đầu!

Cú pháp vòng lặp Golang For

Trong Golang, bạn có thể tạo vòng lặp for bằng cú pháp sau:

for initialization; condition; update {
    // do something
}

Đây,

khởi tạo có nghĩa là khởi tạo biến vòng lặp.
điều kiện là điều kiện vòng lặp xác định việc thực hiện thân vòng lặp. Miễn là điều kiện vòng lặp đúng thì các câu lệnh trong thân vòng lặp sẽ được thực thi. Và khi điều kiện trở thành sai, điều khiển sẽ rời khỏi vòng lặp.
cập nhật có nghĩa là cập nhật biến vòng lặp – thường là tăng hoặc giảm.

💡 Lưu ý rằng điều này chỉ tương tự như vòng lặp C for mà không có dấu ngoặc đơn.

Đây là luồng điều khiển trong Golang cho vòng lặp:

Đã đến lúc viết mã một số ví dụ!⏰ Để cùng nhau viết mã, bạn có thể sử dụng cài đặt cục bộ Golang hoặc chạy các ví dụ trên Go Playground.

Ví dụ về vòng lặp Golang For

Hãy sử dụng cú pháp mà chúng ta vừa học để viết vòng lặp for đầu tiên. Đây là một vòng lặp for đơn giản để in các số từ 1 xuống 5 trong các bước của một.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
}

Chúng ta khởi tạo biến lặp và na 1chúng ta đặt điều kiện thành i <= 5 và chúng ta tăng biến được lặp lên một sau mỗi lần lặp. Và đây là đầu ra:

//Output
For loop:
1
2
3
4
5

Hãy viết một vòng lặp for khác. Vòng lặp này bắt đầu bằng 5 và đếm ngược đến 1; điều này tiếp tục cho đến khi biến vòng lặp lớn hơn hoặc bằng 1. Vì vậy, chúng tôi giảm biến vòng lặp đi một sau mỗi lần lặp.

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := num; i >= 1; i-- {
		fmt.Println(i)
	}
}

Và chúng ta nhận được kết quả như mong đợi:

//Output
For loop:
5
4
3
2
1

Phạm vi của biến vòng lặp là gì?

Phạm vi của biến vòng lặp được giới hạn trong khối vòng lặp for và không có sẵn bên ngoài vòng lặp.

Để xác minh điều này, hãy thử truy cập giá trị của biến được lặp và bên ngoài vòng lặp:

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		fmt.Println(i)
	}
	fmt.Println(i)

}

Đúng như dự đoán, chúng tôi đã gặp phải lỗi cho biết i không xác định (và phạm vi của nó bị giới hạn trong vòng lặp for):

// Output
./prog.go:11:14: undefined: i

Vòng lặp vô hạn ở Golang

Chúng ta có thể có vòng lặp for vô hạn trong Go không? Vâng, chúng tôi chắc chắn có thể!

Nếu bạn nhìn vào luồng điều khiển vòng lặp for:

Phần thân của vòng lặp sẽ được thực thi miễn là điều kiện còn đúng.
Khi điều kiện trở thành sai, điều khiển sẽ thoát khỏi vòng lặp.
Vì vậy, nếu điều kiện không bao giờ sai (hoặc luôn đúng), chúng ta có một vòng lặp vô hạn.

Nhưng bạn cũng có thể sử dụng vòng lặp for mà không cần khởi tạo, điều kiện và cập nhật—mà không mắc lỗi cú pháp. Vì vậy, nếu bạn có thể làm cho vòng lặp chạy vô thời hạn ngay cả khi sử dụng cấu trúc vòng lặp for như thế này:

package main

import "fmt"

func main() {
	for {
	   fmt.Println("running...")
	}
}

//Output
running...
running...
running...
running...
running...
//and it goes on forever!

Trong ví dụ này, chúng tôi đặt biến num thành 5. Điều kiện vòng lặp là num >= 5. Vì vậy, vòng lặp sẽ chạy miễn là num lớn hơn hoặc bằng 0.

package main

import "fmt"

func main() {
	num := 5
	for num > 0 {
		fmt.Println(num)
	}
}

Vì num không bao giờ thay đổi nên điều kiện luôn có giá trị đúng và vòng lặp sẽ tiếp tục mãi mãi!

//Output
5
5
5
5
5
5
//and it goes on forever!

Tất cả Golang chỉ có chức năng xây dựng vòng lặp, chúng ta có thể thử bắt chước các vòng lặp while và do-while bằng vòng lặp for. Vậy hãy cùng học cách thực hiện nhé!

Mô phỏng vòng lặp while bằng vòng lặp For

Vòng lặp while thường có dạng sau:

// initialize looping var
while (condition){
    // do something
    // update looping var
}

Nếu bạn còn nhớ, trong vòng lặp for vô hạn đầu tiên, chúng tôi đã viết: Chúng tôi đã sử dụng vòng lặp for sau – không khởi tạo, điều kiện và cập nhật.

for {
// the simplest infinite loop
}

Vì vậy, chúng ta có thể sửa đổi vòng lặp for để chỉ chứa một điều kiện (ở dạng sau) để mô phỏng vòng lặp while:

//initialize looping var
for condition {
 // do something
 // update looping var
}

Đây là vòng lặp while tương đương với vòng lặp for đầu tiên mà chúng tôi đã viết:

package main

import "fmt"

func main() {
	fmt.Println("Emulating while loop")
	num := 5
	for num > 0 {
		fmt.Println(num)
		num--
	}
}

//Output
Emulating while loop
5
4
3
2
1

Mô phỏng vòng lặp Do-while với vòng lặp For

Nếu bạn đã viết mã bằng một ngôn ngữ như C, bạn sẽ biết rằng cấu trúc của vòng lặp do-while trông như thế này:

// initialize looping var
do {
//something
// update looping var
} while(condition);

Sự khác biệt chính giữa vòng lặp while và vòng lặp do while là vòng lặp while kiểm tra điều kiện khi nó vào vòng lặp. Mặt khác, vòng lặp do-while kiểm tra điều kiện sau khi thoát khỏi vòng lặp.

Vì vậy, trong vòng lặp while, nếu điều kiện sai thì phần thân vòng lặp sẽ không bao giờ được thực thi. Tuy nhiên, trong vòng lặp do-while, phần thân vòng lặp vẫn được thực thi ngay cả khi điều kiện sai.

Sử dụng thông tin này, chúng ta có thể bắt chước hành vi của vòng lặp do-while:

Viết vòng lặp for vô hạn
Sử dụng điều kiện if với điều kiện hợp lệ để thoát khỏi vòng lặp

Giả sử bạn muốn viết một vòng lặp do-while trong đó điều kiện để thực thi phần thân vòng lặp là num < 0. Vì vậy, bạn có thể viết một vòng lặp for và thoát khỏi vòng lặp if num >= 0.

package main

import "fmt"

func main() {
	fmt.Println("Emulating do-while loop")
	num := 5
	for {
		fmt.Println("loop runs...")
		if num >= 0 {
			break
		}
	}
}

💡 Lưu ý thực hiện vòng lặp nếu num < 0 và ngắt vòng lặp nếu num >= 0là những điều kiện tương đương

Mặc dù điều kiện num > 0 ban đầu là sai (num là 5), phần thân của vòng lặp được thực thi một lần, mô phỏng vòng lặp do-while.

//Output
Emulating do-while loop
loop runs...

Lặp mảng bằng vòng lặp For

Khi lặp qua các mảng trong Golang bằng cách sử dụng vòng lặp for và range, cả chỉ mục và phần tử đều có thể được truy cập. Điều này hoạt động tương tự như hàm liệt kê trong Python.

Ở đây chúng ta tạo một numArray, một mảng các số nguyên. Và thực hiện nó bằng vòng lặp for:

package main

import "fmt"

func main() {
	fmt.Println("Looping through an array")
	numArray := []int{3, 7, 0, 10, 8, 9}
	for idx, num := range numArray {
		fmt.Println("At index", idx, ": ", num)
	}
}

Như bạn có thể thấy, chúng ta có thể truy cập cả chỉ mục và mục trong mỗi chỉ mục cùng một lúc:

//Output
Looping through an array
At index 0 :  3
At index 1 :  7
At index 2 :  0
At index 3 :  10
At index 4 :  8
At index 5 :  9

Sử dụng trì hoãn trong Golang For Loop

Trong Golang bạn có thể sử dụng từ khóa defer để trì hoãn các lệnh gọi hàm.

Mặc dù nó được sử dụng trong các ứng dụng như dọn dẹp tài nguyên và xử lý lỗi, nhưng việc hiểu cách sử dụng defer bên trong vòng lặp for có thể hữu ích. Hãy xem điều gì xảy ra khi chúng ta sử dụng defer bên trong vòng lặp for để trì hoãn các lệnh gọi tới Println().

package main

import "fmt"

func main() {
	fmt.Println("For loop:")
	num := 5
	for i := 1; i <= num; i++ {
		defer fmt.Println(i)
	}
}

💬 Khi lệnh gọi hàm bị trì hoãn, lệnh gọi hàm sẽ được đưa vào ngăn xếp và thực thi theo thứ tự LIFO. Việc thực thi này chỉ diễn ra sau khi hàm xung quanh câu lệnh defer trả về.

Vậy fmt.Println(5) được thực thi trước tiên và fmt.Println(1) cuối cùng:

//Output
For loop:
5
4
3
2
1

Ứng dụng

Dưới đây là tóm tắt những gì bạn đã học được trong hướng dẫn này:

Trong Golang bạn có thể tạo vòng lặp for với cú pháp: for khởi tạo; tình trạng: bệnh tật; cập nhật { //thân vòng lặp}.
Luồng điều khiển trong vòng lặp for khá đơn giản. Biến vòng lặp được khởi tạo một lần, điều kiện tìm kiếm xác định xem có thực thi phần thân vòng lặp hay không và cập nhật đề cập đến việc cập nhật biến vòng lặp sau mỗi lần lặp.
Phạm vi của biến vòng lặp được giới hạn trong phần thân của vòng lặp và không có sẵn bên ngoài vòng lặp.
Mặc dù Golang chỉ cung cấp cấu trúc vòng lặp for, nhưng bạn có thể mô phỏng các hành vi while và do-while bằng vòng lặp for.
Một số cách sử dụng khác của vòng lặp for bao gồm duyệt mảng và trì hoãn lệnh gọi hàm bên trong phần thân của vòng lặp for.

Sau đó tìm hiểu cách sử dụng vòng lặp for trong Python. Chúc bạn học tập vui vẻ!🎉

Mục lục

Hướng dẫn về vòng lặp Golang [With Examples]