Go語言中循環(huán)語句使用的示例詳解
一、概述
在不少實際問題中有許多具有規(guī)律性的重復操作，因此在程序中就需要重復執(zhí)行某些語句。
循環(huán)程序的流程圖：
Go 語言提供了以下幾種類型循環(huán)處理語句：
| 循環(huán)類型 | 描述 |
|---|---|
| for 循環(huán) | 重復執(zhí)行語句塊 |
| 循環(huán)嵌套 | 循環(huán)中嵌套一個或多個 for 循環(huán) |
1. 循環(huán)控制語句
循環(huán)控制語句可以控制循環(huán)體內語句的執(zhí)行過程。
GO 語言支持以下幾種循環(huán)控制語句：
| 控制語句 | 描述 |
|---|---|
| break 語句 | 經常用于中斷當前 for 循環(huán)或跳出 switch 語句 |
| continue 語句 | 跳過當前循環(huán)的剩余語句，然后繼續(xù)進行下一輪循環(huán) |
| goto 語句 | 將控制轉移到被標記的語句 |
2. 無限循環(huán)
如果循環(huán)中條件語句永遠不為 false 則會進行無限循環(huán)，我們可以通過 for 循環(huán)語句中只設置一個條件表達式來執(zhí)行無限循環(huán)：
示例
package main
import (
"fmt"
"time"
)
func main() {
i := 0
for true { //for后面true為可選，若不加，默認為true
fmt.Printf("i: %v\n", i)
i++
time.Sleep(time.Second)
}
}
輸出結果如下
i: 0
i: 1
i: 2
i: 3
i: 4
i: 5
i: 6
i: 7
二、Go 語言 for 循環(huán)
1. 語法
for 循環(huán)是一個循環(huán)控制結構，可以執(zhí)行指定次數的循環(huán)
語法：
//Go 語言的 For 循環(huán)有 3 種形式，只有其中的一種使用分號
//和 C 語言的 for 一樣：
for init; condition; post { }
//和 C 的 while 一樣：
for condition { }
//和 C 的 for(;;) 一樣：
for { }
init： 一般為賦值表達式，給控制變量賦初值
condition： 關系表達式或邏輯表達式，循環(huán)控制條件
post：一般為賦值表達式，給控制變量增量或減量。
2. for語句執(zhí)行過程
① 先對表達式 1 賦初值；
② 判別賦值表達式 init 是否滿足給定條件，若其值為真，滿足循環(huán)條件，則執(zhí)行循環(huán)體內語句，然后執(zhí)行 post，進入第二次循環(huán)，再判別 condition；否則判斷 condition 的值為假，不滿足條件，就終止for循環(huán)，執(zhí)行循環(huán)體外語句。
for 循環(huán)的 range 格式可以對 slice、map、數組、字符串等進行迭代循環(huán)。
格式如下：
for key, value := range oldMap {
newMap[key] = value
}for 語句語法流程如下圖所示：
3. 示例
計算 1 到 10 的數字之和
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Printf("sum: %v\n", sum)
}
輸出結果為：
55
int 和 post 參數是可選的，我們可以直接省略他，類型while語句
package main
import "fmt"
func main() {
sum := 0
i := 1
for i <= 10 {
sum += i
i++
}
fmt.Printf("sum: %v\n", sum)
} 計算0-100間偶數的和
//求出0-100的偶數和
package main
import "fmt"
func main() {
a := 0
for i := 1; i <= 100; i++ {
if i%2 == 0 {
a += i
}
}
fmt.Printf("a: %v\n", a)
}
輸出結果如下
2550
//方法二
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 100; i += 2 {
sum += i
}
fmt.Printf("sum: %v\n", sum)
} 4. For-each range 循環(huán)
這種格式的循環(huán)可以對字符串、數組、切片等進行迭代輸出元素
示例
//循環(huán)數組
package main
import "fmt"
func main() {
names := []int{20, 30, 40, 50, 60}
//a獲取key,b獲取value
for a, b := range names {
fmt.Print("key:", a, " value:", b, "\n")
}
}
輸出結果如下
key:0 value:20
key:1 value:30
key:2 value:40
key:3 value:50
key:4 value:60
//使用空白標識符直接獲取value
package main
import "fmt"
func main() {
names := []int{20, 30, 40, 50, 60}
//a獲取key,b獲取value
for _, b := range names {
fmt.Print("value:", b, "\n")
}
}
輸出結果
value:20
value:30
value:40
value:50
value:60
三、循環(huán)嵌套
Go 語言允許用戶在循環(huán)內使用循環(huán)
1. 語法
以下為 Go 語言嵌套循環(huán)的格式：
for [condition | ( init; condition; increment ) | Range]
{
for [condition | ( init; condition; increment ) | Range]
{
statement(s);
}
statement(s);
}2. 示例
以下實例使用循環(huán)嵌套來輸出 2 到 100 間的素數：
package main
import "fmt"
func main() {
/* 定義局部變量 */
var i, j int
for i=2; i < 100; i++ {
for j=2; j <= (i/j); j++ {
if(i%j==0) {
break; // 如果發(fā)現因子，則不是素數
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素數\n", i);
}
}
}
輸出結果如下
2 是素數
3 是素數
5 是素數
7 是素數
11 是素數
13 是素數
17 是素數
19 是素數
23 是素數
29 是素數
31 是素數
37 是素數
41 是素數
43 是素數
47 是素數
53 是素數
59 是素數
61 是素數
67 是素數
71 是素數
73 是素數
79 是素數
83 是素數
89 是素數
97 是素數
99乘法表：
package main
import "fmt"
func main() {
for i := 1; i < 10; i++ {
for j := 1; j < i+1; j++ {
fmt.Printf("%d * %d = %d\t", i, j, j*i)
}
fmt.Println()
}
}
輸出結果如下
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
四、break 語句
1. 語法
Go 語言中 break 語句用于以下兩方面：
用于循環(huán)語句中跳出循環(huán)，并開始執(zhí)行循環(huán)之后的語句。
break 在 switch（開關語句）中在執(zhí)行一條 case 后跳出語句的作用。
在多重循環(huán)中，可以用標號 label 標出想 break 的循環(huán)。
break 語法格式如下：
break;
流程如圖：
2. 示例
在變量 a 大于 15 的時候跳出循環(huán)：
package main
import "fmt"
func main() {
var a int = 10
for a < 20 {
fmt.Printf("a: %v\n", a)
a++
if a > 15 {
break
}
}
}
執(zhí)行結果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 15
演示使用標記和不使用標記的區(qū)別
package main
import "fmt"
func main() {
//不適用標記
fmt.Println("----break----")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %v\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %v\n", a)
break
}
}
//使用標記
fmt.Println("----break label----")
fla:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %v\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %v\n", a)
break fla
}
}
}
輸出結果如下
----break----
i: 1
a: 11
i: 2
a: 11
i: 3
a: 11
----break label----
i: 1
a: 11
五、 continue 語句
1. 語法
Go 語言的 continue 語句 有點像 break 語句。但是 continue 不是跳出循環(huán)，而是跳過當前循環(huán)執(zhí)行下一次循環(huán)語句。
for 循環(huán)中，執(zhí)行 continue 語句會觸發(fā) for 增量語句的執(zhí)行。
在多重循環(huán)中，可以用標號 label 標出想 continue 的循環(huán)。
continue 語法格式如下：
continue;
continue 語句流程圖如下：
2. 示例
在變量 a 等于 15 的時候跳過本次循環(huán)執(zhí)行下一次循環(huán)：
package main
import "fmt"
func main() {
var a int = 10
for a < 20 {
if a == 15 {
a = a + 1
continue
}
fmt.Printf("a: %v\n", a)
a++
}
}
輸出結果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 16
a: 17
a: 18
a: 19
用多重循環(huán)演示使用標記和不使用標記的區(qū)別：
package main
import "fmt"
func main() {
// 不使用標記
fmt.Println("---- continue ---- ")
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %d\n", a)
continue
}
}
// 使用標記
fmt.Println("---- continue label ----")
re:
for i := 1; i <= 3; i++ {
fmt.Printf("i: %d\n", i)
for a := 11; a <= 13; a++ {
fmt.Printf("a: %d\n", a)
continue re
}
}
}
輸出結果如下
---- continue ----
i: 1
a: 11
a: 12
a: 13
i: 2
a: 11
a: 12
a: 13
i: 3
a: 11
a: 12
a: 13
---- continue label ----
i: 1
a: 11
i: 2
a: 11
i: 3
a: 11
六、goto 語句
1. 語法
Go 語言的 goto 語句可以無條件地轉移到過程中指定的行
goto 語句通常與條件語句配合使用，可用來實現條件轉移， 構成循環(huán)，跳出循環(huán)體等功能。
但是，在結構化程序設計中一般不主張使用 goto 語句， 以免造成程序流程的混亂，使理解和調試程序都產生困難。
goto 語法格式如下：
goto label;
..
.
label: statement;
goto 語句流程圖如下：
2. 示例
在變量 a 等于 15 的時候跳過本次循環(huán)并回到循環(huán)的開始語句 LOOP 處：
package main
import "fmt"
func main() {
/* 定義局部變量 */
var a int = 10
/* 循環(huán) */
LOOP:
for a < 20 {
if a == 15 {
/* 跳過迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值為 : %d\n", a)
a++
}
}
輸出結果如下
a的值為 : 10
a的值為 : 11
a的值為 : 12
a的值為 : 13
a的值為 : 14
a的值為 : 16
a的值為 : 17
a的值為 : 18
a的值為 : 19
goto 語句打印九九乘法表:
package main
import "fmt"
//for循環(huán)配合goto打印九九乘法表
func main() {
for m := 1; m < 10; m++ {
n := 1
LOOP:
if n <= m {
fmt.Printf("%dx%d=%d ", n, m, m*n)
n++
goto LOOP
} else {
fmt.Println("")
}
n++
}
}到此這篇關于Go語言中循環(huán)語句使用的示例詳解的文章就介紹到這了,更多相關Go語言循環(huán)語句內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
本文主要介紹了Go語言中map的擴縮容機制,包括grow和hashGrow方法的處理,具有一定的參考價值,感興趣的可以了解一下2025-03-03
基于golang channel實現的輕量級異步任務分發(fā)器示例代碼
這篇文章主要給大家介紹了關于基于golang channel實現的輕量級異步任務分發(fā)器的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2018-07-07
本文主要介紹了Go語言滑動窗口最大值的實現示例,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2025-08-08
本文將介紹首先為什么需要主動關閉goroutine，并介紹如何在Go語言中關閉goroutine的常見套路,包括傳遞終止信號和協程內部捕捉終止信號，之后，文章列舉了需要主動關閉協程運行的常見場景，希望通過本文的介紹，讀者能夠掌握如何在適當的時候關閉goroutine2023-05-05
Go語言實現百萬級WebSocket連接架構設計及服務優(yōu)化
本文將詳細介紹如何在Go中構建一個能夠支持百萬級WebSocket連接的服務,包括系統(tǒng)架構設計、性能優(yōu)化策略以及具體的實現步驟和代碼示例2024-01-01
這篇文章主要介紹了Golang哈希算法實現配置文件的監(jiān)控功能，哈希和加密類似，唯一區(qū)別是哈希是單項的，即哈希后的數據無法解密，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習吧2023-03-03
這篇文章主要為大家介紹了go語法入門any類型的使用場景示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2023-09-09
這篇文章主要給大家介紹了關于Golang中如何使用lua進行擴展的相關資料，這是最近在工作中遇到的一個問題，覺著有必要分享出來給大家學習，文中給出了詳細的示例，需要的朋友可以參考借鑒，下面來一起看看吧。2017-10-10
這篇文章主要為大家詳細介紹了Golang中校驗字符串是否JSON格式的方法，文中的示例代碼講解詳細，感興趣的小伙伴可以跟隨小編一起了解一下2023-04-04
面向對象中的多態(tài)（Polymorphism）是指一個對象可以具有多種不同的形態(tài)或表現方式，本文將通過一些簡單的示例為大家講解一下多態(tài)的實現，需要的可以參考下2023-07-07