Bài viết này xem xét sâu về cú pháp điều khiển luồng trong ngôn ngữ Go, bao gồm các nhánh có điều kiện if-else cơ bản, vòng lặp for, nhánh đa điều kiện trong trường hợp chuyển đổi và điều khiển luồng liên quan đến các loại dữ liệu cụ thể, chẳng hạn như for- vòng lặp phạm vi và chuyển đổi loại. Bài viết cũng mô tả chi tiết cách sử dụng các câu lệnh nhảy như goto và fallthrough, đồng thời cung cấp cho người đọc hướng dẫn trực quan thông qua các ví dụ mã rõ ràng.
Theo dõi tài khoản công khai WeChat [TechLeadCloud] để chia sẻ kiến thức toàn diện về kiến trúc Internet và công nghệ dịch vụ đám mây. Tác giả có hơn 10 năm kinh nghiệm về kiến trúc dịch vụ Internet, kinh nghiệm nghiên cứu và phát triển sản phẩm AI cũng như kinh nghiệm quản lý nhóm. Ông có bằng thạc sĩ tại Đại học Tongji thuộc Đại học Fudan, thành viên của Phòng thí nghiệm Trí tuệ Robot Fudan, kiến trúc sư cấp cao được chứng nhận bởi Alibaba Cloud. , chuyên gia quản lý dự án, nghiên cứu và phát triển các sản phẩm AI với doanh thu hàng trăm triệu người phụ trách.
giới thiệu
Trong lập trình máy tính, điều khiển luồng là thành phần cốt lõi xác định cách chương trình sẽ thực hiện hoặc đưa ra quyết định dựa trên một tình huống nhất định. Sau đây là tổng quan ngắn gọn về các cấu trúc điều khiển luồng được hỗ trợ bởi ngôn ngữ Go:
Loại điều khiển quá trình |
mã số |
nhánh có điều kiện if-else |
nếu điều kiện { } nếu không { } |
vòng lặp for |
để khởi tạo; điều kiện; bài đăng { } |
trường hợp chuyển đổi nhiều nhánh có điều kiện |
chuyển đổi giá trị { trường hợp v1: ... mặc định: ... } |
Vòng lặp kiểu vùng chứa |
đối với khóa, giá trị := phạm vi container { } |
Chuyển đổi kiểu nhiều nhánh có điều kiện của các loại giao diện |
chuyển đổi v := giá trị.(kiểu) { trường hợp T: ... } |
Trường hợp chọn nhiều nhánh của loại kênh |
chọn { trường hợp <-ch: ... mặc định: ... } |
tuyên bố nhảy break |
phá vỡ |
tiếp tục tuyên bố nhảy |
Tiếp tục |
câu lệnh nhảy goto |
đi đến nhãn |
tuyên bố bước nhảy thất bại |
sự sụp đổ |
Trong các phần tiếp theo, chúng ta sẽ đi sâu vào chi tiết và các trường hợp ứng dụng của từng cấu trúc điều khiển tiến trình để giúp bạn hiểu rõ hơn và nắm vững hơn các công cụ điều khiển tiến trình của ngôn ngữ Go.
nhánh có điều kiện if-else
Trong Go, cấu trúc if-else cung cấp cách cơ bản để phán đoán có điều kiện. Tương tự như nhiều ngôn ngữ lập trình khác, cú pháp cơ bản của nó bao gồm kiểm tra một điều kiện và thực thi khối mã tương ứng tùy thuộc vào điều kiện đó là đúng hay sai.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
nếu như |
nếu điều kiện { } |
nếu-nếu-khác |
nếu điều kiện { } nếu không { } |
nếu-nếu-nếu-nếu-nếu |
nếu điều kiện1 { } nếu không nếu điều kiện2 { } nếu không { } |
Ví dụ và giải thích
-
nếu như .
x := 10 nếu x > 5 { fmt.Println("x lớn hơn 5") }
Khi điều kiện x > 5 đúng, mã sẽ xuất ra "x lớn hơn 5".
-
nếu-nếu-khác 。
x := 3 nếu x > 5 { fmt.Println("x lớn hơn 5") } else { fmt.Println("x không lớn hơn 5") }
Vì điều kiện cho x > 5 không đúng nên mã sẽ xuất ra "x không lớn hơn 5".
-
nếu-nếu-nếu-nếu-nếu 。
x := 5 nếu x > 10 { fmt.Println("x lớn hơn 10") } else nếu x < 5 { fmt.Println("x nhỏ hơn 5") } else { fmt.Println("x bằng 5") }
Trong ví dụ này, vì x bằng 5 nên mã sẽ in "x là 5".
nếu nhánh có điều kiện với câu lệnh khởi tạo
Trong Go, câu lệnh if có thể chứa câu lệnh khởi tạo, thường được sử dụng để xác định các biến tạm thời được sử dụng trong các bài kiểm tra có điều kiện.
Loại điều khiển quá trình |
mã số |
nếu với khởi tạo |
nếu stmt; điều kiện { } |
Ví dụ và giải thích
nếu y := computeValue(); y > 10 { fmt.Println("y lớn hơn 10") } nếu không { fmt.Println("y không lớn hơn 10") }
Trong ví dụ này, trước tiên chúng ta gọi hàm CalculateValue() (giả sử nó trả về một số nguyên) và gán kết quả cho biến y. Sau đó, chúng tôi quyết định xuất cái gì dựa trên điều kiện y > 10. Cấu trúc này cho phép chúng ta hoàn thành việc khởi tạo và kiểm tra có điều kiện trong một câu lệnh ngắn gọn.
vòng lặp for
Vòng lặp for là cấu trúc vòng lặp duy nhất trong ngôn ngữ Go, nhưng nó đủ linh hoạt để bao quát nhiều cấu trúc vòng lặp khác nhau trong các ngôn ngữ lập trình khác. Thông qua các kết hợp khác nhau, vòng lặp for của Go có thể mô phỏng các vòng lặp while và do-while truyền thống.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
Vòng lặp cơ bản |
để khởi tạo; điều kiện; bài đăng { } |
Vòng lặp while |
cho điều kiện { } |
Vòng lặp vô hạn |
vì { } |
Ví dụ và giải thích
-
Vòng lặp cơ bản 。
đối với i := 0; i < 5; i++ { fmt.Println(i) }
Đây là dạng vòng lặp for phổ biến nhất. Đoạn mã trên sẽ xuất ra 0 đến 4.
-
Vòng lặp while 。
x := 5 đối với x > 0 { fmt.Println(x) x-- }
Cấu trúc này mô phỏng vòng lặp while truyền thống. Đoạn mã trên sẽ xuất ra các số từ 5 đến 1.
-
Vòng lặp vô hạn.
đối với { fmt.Println("Điều này sẽ chạy vô thời hạn!") }
Trừ khi có lệnh ngắt hoặc câu lệnh điều khiển khác, vòng lặp này sẽ chạy vô thời hạn. Trong một số trường hợp, điều này có thể được sử dụng để liên tục chờ đầu vào bên ngoài hoặc các ngắt khác.
mang đến phạm vi
Vòng lặp for
Ngôn ngữ Go cung cấp cấu trúc dành cho phạm vi để lặp qua các phần tử của một mảng, lát, chuỗi hoặc bản đồ.
Loại điều khiển quá trình |
mã số |
Vòng lặp phạm vi |
đối với khóa, giá trị := phạm vi container { } |
Ví dụ và giải thích
nums := []int{1, 2, 3, 4, 5} cho idx, num := phạm vi nums { fmt.Printf("Chỉ số: %d, Giá trị: %d\n", idx, num) }
Trong ví dụ này, vòng lặp for-range lặp qua một lát số nguyên và xuất ra từng phần tử cũng như chỉ mục của nó. Tương tự, for-range có thể được sử dụng để lặp qua các loại vùng chứa khác.
trường hợp chuyển đổi nhiều nhánh có điều kiện
Trong ngôn ngữ Go, cấu trúc switch-case cung cấp một cách rõ ràng để thực hiện phán đoán đa điều kiện. Hơi khác một chút so với cấu trúc chuyển đổi trong các ngôn ngữ khác, chuyển đổi của Go linh hoạt hơn và có thể được sử dụng không chỉ cho các hằng số và giá trị số nguyên mà còn cho các phán đoán có điều kiện phức tạp hơn.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
Công tắc cơ bản |
chuyển đổi biểu thức { trường hợp giá trị1: ... mặc định: ... } |
Nhiều giá trị |
chuyển đổi biểu thức { trường hợp val1, val2: ... } |
Không có biểu hiện |
chuyển đổi { trường hợp điều kiện1: ... } |
Ví dụ và giải thích
-
Công tắc cơ bản 。
fruit := "apple" switch fruit { case "chuối": fmt.Println("Đây là một quả chuối.") case "apple": fmt.Println("Đây là một quả táo.") default: fmt.Println("Không xác định loại quả.") }
Đoạn mã trên sẽ xuất ra "Đây là một quả táo" vì giá trị của trái cây là "táo".
-
Nhiều giá trị 。
ngày := 2 chuyển ngày { trường hợp 1, 7: fmt.Println("Cuối tuần") trường hợp 2, 3, 4, 5, 6: fmt.Println("Ngày trong tuần") mặc định: fmt.Println("Ngày không hợp lệ") }
Trong ví dụ này, chúng tôi kiểm tra xem ngày là ngày làm việc hay cuối tuần. Đoạn mã trên sẽ xuất ra "Ngày trong tuần".
-
Không có biểu hiện gì.
x := 10 chuyển đổi { trường hợp x > 5: fmt.Println("x lớn hơn 5") trường hợp x < 5: fmt.Println("x nhỏ hơn 5") mặc định: fmt.Println("x bằng 5") }
Ở dạng này, switch không có biểu thức đi kèm mà chỉ đánh giá điều kiện sau trường hợp. Đoạn mã trên sẽ xuất ra "x lớn hơn 5".
sự sụp đổ
Từ khóa
Trong Go, các trường hợp chuyển đổi sẽ không "chạy qua" theo mặc định (nghĩa là khi một trường hợp được khớp, nó sẽ thoát khỏi chuyển đổi và các trường hợp tiếp theo sẽ không được thực thi). Nếu muốn tiếp tục thực hiện trường hợp tiếp theo, bạn cần sử dụng từ khóa fallthrough.
Loại điều khiển quá trình |
mã số |
Sử dụng fallthrough |
giá trị trường hợp: ... fallthrough ... |
Ví dụ và giải thích
giá trị := 5 chuyển đổi giá trị { trường hợp 5: fmt.Println("Giá trị là 5") chuyển tiếp trường hợp 6: fmt.Println("Giá trị là 6 hoặc chuyển tiếp từ 5") mặc định: fmt.Println("Giá trị khác") }
Đoạn mã trên sẽ liên tục xuất ra "Giá trị là 5" và "Giá trị là 6 hoặc giảm từ 5" vì dự phòng khiến chương trình tiếp tục thực hiện trường hợp tiếp theo.
Vòng lặp kiểu vùng chứa
Trong Go, cấu trúc for-range là một công cụ mạnh mẽ để làm việc với các loại vùng chứa như mảng, lát, chuỗi và bản đồ. Nó rất thuận tiện để lặp lại tất cả các phần tử trong một vùng chứa mà không cần phải xử lý các chỉ mục hoặc khóa theo cách thủ công.
Mảng và lát
Loại điều khiển quá trình |
mã số |
Lặp lại trên một mảng hoặc lát cắt |
đối với idx, giá trị := phạm vi arrayOrSlice { } |
Ví dụ và giải thích
nums := []int{1, 2, 3, 4, 5} cho idx, num := phạm vi nums { fmt.Printf("Chỉ số: %d, Giá trị: %d\n", idx, num) }
Mã này lặp qua từng phần tử của lát cắt số và đưa ra chỉ số và giá trị của nó.
Ví dụ và hướng dẫn.
str := "hello" cho idx, char := phạm vi str { fmt.Printf("Chỉ mục: %d, Ký tự: %c\n", idx, char) }
Mã này lặp qua từng ký tự trong chuỗi str và xuất ra giá trị chỉ mục và ký tự của nó.
m := map[string]int{"a": 1, "b": 2, "c": 3} cho khóa, giá trị := phạm vi m { fmt.Printf("Khóa: %s, Giá trị: %d\n", khóa, giá trị) }
Mã này lặp qua từng cặp khóa-giá trị trong bản đồ m, xuất ra khóa và giá trị của nó. Nhìn chung, cấu trúc for-range cung cấp cho các lập trình viên Go một cách đơn giản nhưng mạnh mẽ để duyệt và thao tác dữ liệu loại vùng chứa. Với cú pháp ngắn gọn, chúng ta có thể xử lý hiệu quả nhiều vùng chứa khác nhau mà không phải lo lắng về các chỉ mục và điều kiện biên phức tạp.
Chuyển đổi kiểu nhiều nhánh có điều kiện của các loại giao diện
Trong ngôn ngữ Go, các loại giao diện cho phép chúng ta xử lý nhiều loại dữ liệu khác nhau, nhưng đôi khi chúng ta cần biết loại biến giao diện cụ thể. Tại thời điểm này, cấu trúc chuyển đổi kiểu cung cấp một cách tinh tế để thực hiện phán đoán kiểu và xử lý nhánh.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
loại chuyển đổi |
chuyển đổi v := i.(kiểu) { trường hợp T: ... mặc định: ... } |
Ví dụ và giải thích
-
Công tắc loại cơ bản.
var i interface{} = "hello" switch v := i.(type) { case int: fmt.Printf("Đây là một int có giá trị %d\n", v) case string: fmt.Printf("Đây là một chuỗi có giá trị %s\n", v) default: fmt.Printf("Kiểu không xác định: %T\n", v) }
Mã này trước tiên khai báo một biến i thuộc loại giao diện và gán nó cho chuỗi "hello". Sau đó, sử dụng công tắc loại để kiểm tra loại động của i. Đoạn mã trên sẽ xuất ra: "Đó là một chuỗi có giá trị xin chào".
loại chuyển đổi
Công dụng khác trong
chuyển đổi loại không chỉ giới hạn ở các loại cơ bản mà còn có thể được sử dụng cho các loại, cấu trúc tùy chỉnh, v.v.
Loại điều khiển quá trình |
mã số |
Loại tùy chỉnh |
trường hợp CustomType: ... |
Kết cấu |
trường hợp structType: ... |
Ví dụ và giải thích
-
Các loại và cấu trúc tùy chỉnh.
kiểu MyString chuỗi kiểu MyStruct struct { Trường int } var i giao diện{} = MyString("hello") chuyển đổi v := i.(kiểu) { trường hợp MyString: fmt.Printf("Đây là MyString có giá trị %s\n", chuỗi(v)) trường hợp MyStruct: fmt.Printf("Đây là MyStruct có giá trị trường %d\n", v.Field) mặc định: fmt.Printf("Kiểu không xác định: %T\n", v) }
Trong ví dụ này, chúng tôi xác định loại tùy chỉnh MyString và cấu trúc MyStruct. Sau đó, chúng ta sử dụng lại type-switch để kiểm tra loại biến giao diện i. Mã đã cho sẽ xuất ra: "Đó là MyString có giá trị xin chào".
Nhìn chung, cấu trúc chuyển đổi loại cung cấp cho các nhà phát triển Go một cách rõ ràng và ngắn gọn để xác định loại động của các biến giao diện và thực hiện phân nhánh. Nắm vững cấu trúc này là rất quan trọng để xử lý chính xác các giao diện và tính đa hình trong Go.
Trường hợp chọn nhiều nhánh của loại kênh
Từ khóa select trong ngôn ngữ Go được sử dụng để xử lý các thao tác đọc/ghi trên nhiều kênh. Khi chúng ta cần nhận dữ liệu từ hoặc gửi dữ liệu đến nhiều kênh cùng một lúc, cấu trúc chọn cung cấp cách xử lý các thao tác này, cho phép chúng ta thực hiện các thao tác tương ứng khi một kênh đã sẵn sàng.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
chọn trường hợp |
chọn { trường hợp hoạt động 1: ... trường hợp hoạt động 2: ... } |
Ví dụ và giải thích
-
Trường hợp chọn cơ bản.
ch1 := make(chan int, 1) ch2 := make(chan string, 1) ch1 <- 1 ch2 <- "hello" select { case i := <-ch1: fmt.Printf("Đã nhận từ ch1: %d\n", i) case s := <-ch2: fmt.Printf("Đã nhận từ ch2: %s\n", s) default: fmt.Println("Không nhận được dữ liệu") }
Mã này xác định hai kênh, gửi một số nguyên và một chuỗi tương ứng. Sử dụng cấu trúc chọn, chương trình cố gắng nhận dữ liệu từ ch1 và ch2. Mã này có thể xuất dữ liệu từ ch1 hoặc ch2 vì select chọn ngẫu nhiên một trường hợp có sẵn để thực thi.
sử dụng mặc định
Trong cấu trúc chọn, bạn có thể sử dụng câu lệnh mặc định để xử lý tình huống khi tất cả các kênh đều không khả dụng.
Ví dụ và giải thích
-
Sử dụng mặc định.
ch := make(chan int, 1) select { case i := <-ch: fmt.Printf("Đã nhận từ ch: %d\n", i) default: fmt.Println("Không có dữ liệu nào khả dụng") }
Trong ví dụ này, chúng tôi đang cố gắng nhận dữ liệu từ kênh ch. Nhưng do không có dữ liệu nào được gửi đến kênh nên chương trình sẽ xuất ra "Không có dữ liệu".
sử dụng lựa chọn
Xử lý thời gian chờ
Sử dụng cấu trúc chọn, chúng ta cũng có thể dễ dàng thực hiện cơ chế hết thời gian chờ.
Ví dụ và giải thích
-
Xử lý thời gian chờ.
ch := make(chan int, 1) go func() { time.Sleep(2 * time.Second) ch <- 1 }() select { case i := <-ch: fmt.Printf("Đã nhận từ ch: %d\n", i) case <-time.After(1 * time.Second): fmt.Println("Hết giờ!") }
Trong mã này, chúng tôi đang cố gắng nhận dữ liệu từ kênh ch, nhưng chúng tôi chỉ đợi 1 giây. Sử dụng hàm time.After, chúng ta có thể dễ dàng triển khai logic hết thời gian chờ. Nếu không nhận được dữ liệu từ ch trong vòng 1 giây, chương trình sẽ xuất ra "Hết giờ!".
Tóm lại, cấu trúc trường hợp chọn cung cấp một cách rất thuận tiện cho các nhà phát triển Go xử lý nhiều kênh. Nó không chỉ cho phép chúng tôi xử lý đồng thời nhiều kênh mà còn cho phép dễ dàng thực hiện thời gian chờ và hành động mặc định, giúp việc lập trình đồng thời trở nên đơn giản và mạnh mẽ.
tuyên bố nhảy break
Trong ngôn ngữ Go, câu lệnh break chủ yếu được sử dụng để kết thúc trước việc thực thi vòng lặp hoặc chuyển đổi, chọn và các khối mã khác. Nó cho phép chúng ta thoát ra khỏi khối mã hiện đang thực thi khi đáp ứng một số điều kiện nhất định.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
phá vỡ |
phá vỡ |
Ví dụ và giải thích
-
Sử dụng break trong vòng lặp for.
đối với i := 0; i < 10; i++ { nếu i == 5 { ngắt } fmt.Println(i) }
Mã này sẽ in các số từ 0 đến 4. Khi i bằng 5, câu lệnh break sẽ được kích hoạt, do đó vòng lặp sẽ kết thúc sớm.
-
Sử dụng công tắc ngắt.
công tắc 2 { trường hợp 1: fmt.Println("Trường hợp 1") trường hợp 2: fmt.Println("Trường hợp 2") nếu đúng { ngắt } fmt.Println("Điều này sẽ không được in") trường hợp 3: fmt.Println("Trường hợp 3") }
Trong ví dụ này, khi trường hợp 2 khớp, chương trình sẽ xuất ra "Trường hợp 2" và sau đó fmt.Println("Điều này sẽ không được in") sẽ không được thực thi do câu lệnh break.
nghỉ được gắn thẻ
Trong Go, bạn cũng có thể sử dụng các câu lệnh ngắt có gắn nhãn để thoát ra khỏi các vòng lặp bên ngoài hoặc các khối mã khác.
Ví dụ và giải thích
-
Sử dụng thời gian nghỉ có nhãn.
outerLoop: đối với i := 0; i < 5; i++ { đối với j := 0; j < 5; j++ { nếu i*j == 6 { ngắt outerLoop } fmt.Println(i, j) } }
Trong đoạn mã trên, chúng ta có hai vòng lặp for lồng nhau. Khi i*j bằng 6, câu lệnh break có nhãn sẽ được kích hoạt, điều này sẽ khiến vòng lặp for bên ngoài kết thúc sớm.
Nhìn chung, câu lệnh break cung cấp một cách linh hoạt để kiểm soát luồng thực thi của một khối mã trong Go. Nó được sử dụng rộng rãi trong các cấu trúc như vòng lặp, chuyển đổi và chọn, cho phép chúng ta kết thúc sớm việc thực thi khối mã dựa trên các điều kiện cụ thể.
tiếp tục tuyên bố nhảy
Trong ngôn ngữ Go, câu lệnh continue được sử dụng để bỏ qua các câu lệnh còn lại của vòng lặp hiện tại và bắt đầu vòng lặp tiếp theo. Không giống như câu lệnh break, nó không kết thúc toàn bộ vòng lặp mà chỉ bỏ qua lần lặp hiện tại.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
Tiếp tục |
Tiếp tục |
Ví dụ và giải thích
-
Sử dụng continue trong vòng lặp for.
đối với i := 0; i < 10; i++ { nếu i%2 == 0 { tiếp tục } fmt.Println(i) }
Đoạn mã trên sẽ in ra tất cả các số lẻ từ 0 đến 9. Khi i là số chẵn, câu lệnh continue được kích hoạt, bỏ qua phần còn lại của vòng lặp hiện tại.
-
Sử dụng continue trong vòng lặp for-range.
arr := []int{1, 2, 3, 4, 5} đối với idx, val := phạm vi arr { nếu val == 3 { tiếp tục } fmt.Printf("arr[%d] = %d\n", idx, val) }
Mã này lặp lại trên một lát số nguyên và in chỉ mục và giá trị của tất cả các phần tử ngoại trừ 3. Khi giá trị phần tử là 3, câu lệnh continue được kích hoạt, bỏ qua lần lặp hiện tại.
được dán nhãn tiếp tục
Tương tự như câu lệnh break, continue cũng hỗ trợ một biểu mẫu được gắn nhãn, cho phép bạn chỉ định lần lặp tiếp theo của vòng lặp bên ngoài để nhảy tới trong các vòng lặp lồng nhau nhiều cấp.
Ví dụ và giải thích
-
Sử dụng nhãn tiếp tục.
outerLoop: đối với i := 0; i < 3; i++ { đối với j := 0; j < 3; j++ { nếu i == 1 && j == 1 { tiếp tục outerLoop } fmt.Println(i, j) } }
Trong ví dụ này chúng ta có hai vòng lặp for lồng nhau. Khi i bằng 1 và j bằng 1, câu lệnh continue được gắn nhãn sẽ được kích hoạt, điều này gây ra bước nhảy trực tiếp đến lần lặp tiếp theo của vòng lặp bên ngoài, trong khi các lần lặp còn lại của vòng lặp bên trong bị bỏ qua.
Tóm lại, câu lệnh continue cung cấp cho các nhà phát triển Go một cách để bỏ qua một lần lặp nhất định của vòng lặp khi đáp ứng một số điều kiện nhất định. Điều này cho phép chúng ta kiểm soát luồng thực thi của vòng lặp một cách linh hoạt hơn.
câu lệnh nhảy goto
Trong ngôn ngữ Go, câu lệnh goto cho phép chương trình nhảy tới một nhãn được chỉ định trong khi thực thi. Mặc dù câu lệnh goto ít được sử dụng hơn trong lập trình hiện đại và có thể gây nhầm lẫn hoặc khiến mã khó đọc trong một số trường hợp, nhưng nó có thể hữu ích trong một số trường hợp cụ thể.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
đi đến |
đi đến |
Ví dụ và giải thích
-
Sử dụng goto đơn giản.
func main() { fmt.Println("Bắt đầu") chuyển đến kết thúc fmt.Println("Điều này sẽ không được in") kết thúc: fmt.Println("Kết thúc") }
Trong ví dụ này, đầu tiên chương trình in "Bắt đầu", sau đó nhảy đến nhãn kết thúc và tiếp tục thực thi mã bên dưới. Do đó, fmt.Println("Điều này sẽ không được in") sẽ không được thực thi.
-
Sử dụng goto để xử lý lỗi.
func divide(x, y int) (int, error) { if y == 0 { return 0, errors.New("Không thể chia cho số không") } return x / y, nil } func main() { result, err := divide(10, 0) if err != nil { goto handleErr } fmt.Println("Kết quả:", result) return handleErr: fmt.Println("Lỗi:", err) }
Trong ví dụ này, chúng tôi sử dụng câu lệnh goto để chuyển sang phần xử lý lỗi. Cách tiếp cận này có thể khiến việc xử lý lỗi trở nên tập trung hơn trong một số trường hợp.
Mặc dù câu lệnh goto có sẵn trong Go nhưng các nhà phát triển thường khuyên chỉ nên sử dụng nó khi thực sự cần thiết, vì việc sử dụng không đúng cách có thể dẫn đến mã khó hiểu và khó bảo trì. Tốt nhất nên tránh goto khi bạn có thể sử dụng các cấu trúc khác (chẳng hạn như if, for hoặc switch) để đạt được kết quả tương tự.
tuyên bố bước nhảy thất bại
Trong câu lệnh switch của Go, khi một trường hợp khớp thành công, các trường hợp tiếp theo sẽ không còn được kiểm tra hoặc thực thi nữa. Tuy nhiên, Go cung cấp một từ khóa duy nhất: fallthrough, có thể buộc thực thi trường hợp ngay sau nó, bất kể trường hợp đó có khớp hay không.
Cách sử dụng cơ bản
Loại điều khiển quá trình |
mã số |
sự sụp đổ |
sự sụp đổ |
Ví dụ và giải thích
-
Cách sử dụng dự phòng cơ bản.
x := 10 chuyển đổi x { trường hợp 10: fmt.Println("x là 10") trường hợp dự phòng 20: fmt.Println("x là 20") mặc định: fmt.Println("x không phải là 10 cũng không phải là 20") }
Trong ví dụ này, giá trị của x là 10 nên đầu tiên chương trình sẽ in ra "x is 10". Vì có câu lệnh dự phòng sau trường hợp đầu tiên nên chương trình vẫn tiếp tục thực hiện trường hợp tiếp theo, ngay cả khi giá trị của x không phải là 20 thì “x là 20” sẽ được in ra.
-
Việc sử dụng dự phòng trong các trường hợp không liên tiếp.
y := "táo" chuyển đổi y { trường hợp "chuối": fmt.Println("y là chuối") trường hợp "táo": fmt.Println("y là táo") trường hợp "cam": fmt.Println("y là cam") mặc định: fmt.Println("y không phải là chuối, táo hay cam") }
Trong ví dụ này, khi giá trị của y là "apple", "y is apple" sẽ được in. Sau đó, do tuyên bố dự phòng, "y có màu cam" sẽ được in ngay cả khi giá trị của y không phải là "màu cam".
Cần lưu ý rằng mặc dù dự phòng cung cấp một luồng điều khiển đặc biệt, nhưng trong hầu hết các trường hợp, việc sử dụng quá mức hoặc không phù hợp có thể khiến mã khó đọc và khó hiểu. Do đó, chỉ nên sử dụng nó khi thực sự cần thiết và đảm bảo mục đích của mã rõ ràng.
Theo dõi tài khoản công khai WeChat [TechLeadCloud] để chia sẻ kiến thức toàn diện về kiến trúc Internet và công nghệ dịch vụ đám mây. Tác giả có hơn 10 năm kinh nghiệm về kiến trúc dịch vụ Internet, kinh nghiệm nghiên cứu và phát triển sản phẩm AI cũng như kinh nghiệm quản lý nhóm. Ông có bằng thạc sĩ tại Đại học Tongji thuộc Đại học Fudan, thành viên của Phòng thí nghiệm Trí tuệ Robot Fudan, kiến trúc sư cấp cao được chứng nhận bởi Alibaba Cloud. , chuyên gia quản lý dự án, nghiên cứu và phát triển các sản phẩm AI với doanh thu hàng trăm triệu người phụ trách.
Nếu hữu ích, vui lòng chú ý hơn đến tài khoản công khai WeChat cá nhân: [TechLeadCloud] để chia sẻ kiến thức toàn diện về AI và nghiên cứu và phát triển dịch vụ đám mây, đồng thời nói về những hiểu biết sâu sắc độc đáo của tôi về công nghệ với tư cách là một TechLead. TeahLead KrisChang, Hơn 10 năm kinh nghiệm trong ngành Internet và trí tuệ nhân tạo, Hơn 10 năm kinh nghiệm trong quản lý nhóm kỹ thuật và kinh doanh, bằng cử nhân về công nghệ phần mềm tại Tongji, bằng thạc sĩ về quản lý kỹ thuật tại Đại học Fudan, kiến trúc sư cấp cao được chứng nhận của Alibaba Cloud dịch vụ đám mây, kinh doanh sản phẩm AI với doanh thu hàng trăm triệu người phụ trách.
Cuối cùng, bài viết này về bách khoa toàn thư về kiểm soát quy trình của Go: chi tiết, ví dụ và các phương pháp hay nhất kết thúc ở đây. Nếu bạn muốn biết thêm về bách khoa toàn thư về kiểm soát quy trình của Go: chi tiết, ví dụ và các phương pháp hay nhất, vui lòng tìm kiếm các bài viết của CFSDN hoặc tiếp tục duyệt qua các bài viết liên quan. mong bạn sẽ ủng hộ blog của mình trong tương lai nhé! .
Tôi là một lập trình viên xuất sắc, rất giỏi!