Go語言中循環(huán)語句使用的示例詳解
一、概述
在不少實際問題中有許多具有規(guī)律性的重復(fù)操作，因此在程序中就需要重復(fù)執(zhí)行某些語句。
循環(huán)程序的流程圖：
Go 語言提供了以下幾種類型循環(huán)處理語句：
| 循環(huán)類型 | 描述 |
|---|---|
| for 循環(huán) | 重復(fù)執(zhí)行語句塊 |
| 循環(huán)嵌套 | 循環(huán)中嵌套一個或多個 for 循環(huán) |
1. 循環(huán)控制語句
循環(huán)控制語句可以控制循環(huán)體內(nèi)語句的執(zhí)行過程。
GO 語言支持以下幾種循環(huán)控制語句：
| 控制語句 | 描述 |
|---|---|
| break 語句 | 經(jīng)常用于中斷當(dāng)前 for 循環(huán)或跳出 switch 語句 |
| continue 語句 | 跳過當(dāng)前循環(huán)的剩余語句，然后繼續(xù)進行下一輪循環(huán) |
| goto 語句 | 將控制轉(zhuǎn)移到被標(biāo)記的語句 |
2. 無限循環(huán)
如果循環(huán)中條件語句永遠不為 false 則會進行無限循環(huán)，我們可以通過 for 循環(huán)語句中只設(shè)置一個條件表達式來執(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)
}
}
輸出結(jié)果如下
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)控制結(jié)構(gòu)，可以執(zhí)行指定次數(shù)的循環(huán)
語法：
//Go 語言的 For 循環(huán)有 3 種形式，只有其中的一種使用分號
//和 C 語言的 for 一樣：
for init; condition; post { }
//和 C 的 while 一樣：
for condition { }
//和 C 的 for(;;) 一樣：
for { }
init： 一般為賦值表達式，給控制變量賦初值
condition： 關(guān)系表達式或邏輯表達式，循環(huán)控制條件
post：一般為賦值表達式，給控制變量增量或減量。
2. for語句執(zhí)行過程
① 先對表達式 1 賦初值；
② 判別賦值表達式 init 是否滿足給定條件，若其值為真，滿足循環(huán)條件，則執(zhí)行循環(huán)體內(nèi)語句，然后執(zhí)行 post，進入第二次循環(huán)，再判別 condition；否則判斷 condition 的值為假，不滿足條件，就終止for循環(huán)，執(zhí)行循環(huán)體外語句。
for 循環(huán)的 range 格式可以對 slice、map、數(shù)組、字符串等進行迭代循環(huán)。
格式如下：
for key, value := range oldMap {
newMap[key] = value
}for 語句語法流程如下圖所示：
3. 示例
計算 1 到 10 的數(shù)字之和
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 10; i++ {
sum += i
}
fmt.Printf("sum: %v\n", sum)
}
輸出結(jié)果為：
55
int 和 post 參數(shù)是可選的，我們可以直接省略他，類型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間偶數(shù)的和
//求出0-100的偶數(shù)和
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)
}
輸出結(jié)果如下
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)可以對字符串、數(shù)組、切片等進行迭代輸出元素
示例
//循環(huán)數(shù)組
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")
}
}
輸出結(jié)果如下
key:0 value:20
key:1 value:30
key:2 value:40
key:3 value:50
key:4 value:60
//使用空白標(biāo)識符直接獲取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")
}
}
輸出結(jié)果
value:20
value:30
value:40
value:50
value:60
三、循環(huán)嵌套
Go 語言允許用戶在循環(huán)內(nèi)使用循環(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 間的素數(shù)：
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ā)現(xiàn)因子，則不是素數(shù)
}
}
if(j > (i/j)) {
fmt.Printf("%d 是素數(shù)\n", i);
}
}
}
輸出結(jié)果如下
2 是素數(shù)
3 是素數(shù)
5 是素數(shù)
7 是素數(shù)
11 是素數(shù)
13 是素數(shù)
17 是素數(shù)
19 是素數(shù)
23 是素數(shù)
29 是素數(shù)
31 是素數(shù)
37 是素數(shù)
41 是素數(shù)
43 是素數(shù)
47 是素數(shù)
53 是素數(shù)
59 是素數(shù)
61 是素數(shù)
67 是素數(shù)
71 是素數(shù)
73 是素數(shù)
79 是素數(shù)
83 是素數(shù)
89 是素數(shù)
97 是素數(shù)
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()
}
}
輸出結(jié)果如下
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（開關(guān)語句）中在執(zhí)行一條 case 后跳出語句的作用。
在多重循環(huán)中，可以用標(biāo)號 label 標(biāo)出想 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í)行結(jié)果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 15
演示使用標(biāo)記和不使用標(biāo)記的區(qū)別
package main
import "fmt"
func main() {
//不適用標(biāo)記
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
}
}
//使用標(biāo)記
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
}
}
}
輸出結(jié)果如下
----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)，而是跳過當(dāng)前循環(huán)執(zhí)行下一次循環(huán)語句。
for 循環(huán)中，執(zhí)行 continue 語句會觸發(fā) for 增量語句的執(zhí)行。
在多重循環(huán)中，可以用標(biāo)號 label 標(biāo)出想 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++
}
}
輸出結(jié)果如下
a: 10
a: 11
a: 12
a: 13
a: 14
a: 16
a: 17
a: 18
a: 19
用多重循環(huán)演示使用標(biāo)記和不使用標(biāo)記的區(qū)別：
package main
import "fmt"
func main() {
// 不使用標(biāo)記
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
}
}
// 使用標(biāo)記
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
}
}
}
輸出結(jié)果如下
---- 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 語句可以無條件地轉(zhuǎn)移到過程中指定的行
goto 語句通常與條件語句配合使用，可用來實現(xiàn)條件轉(zhuǎn)移， 構(gòu)成循環(huán)，跳出循環(huán)體等功能。
但是，在結(jié)構(gòu)化程序設(shè)計中一般不主張使用 goto 語句， 以免造成程序流程的混亂，使理解和調(diào)試程序都產(chǎn)生困難。
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++
}
}
輸出結(jié)果如下
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++
}
}到此這篇關(guān)于Go語言中循環(huán)語句使用的示例詳解的文章就介紹到這了,更多相關(guān)Go語言循環(huán)語句內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Golang實現(xiàn)自己的Redis(pipeline客戶端)實例探索
這篇文章主要為大家介紹了Golang實現(xiàn)自己的Redis(pipeline客戶端)實例探索,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪2024-01-01
這篇文章主要為大家介紹了從Context到go設(shè)計理念輕松上手教程詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-09-09
這篇文章主要給大家介紹了關(guān)于Golang中time.After的使用理解與釋放問題，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2018-08-08
這篇文章主要為大家詳細介紹了gorm如何和數(shù)據(jù)庫建立連接,文中的示例代碼講解詳細,對我們深入了解GO語言有一定的幫助,需要的小伙伴可以參考下2023-11-11
這篇文章主要介紹了go實現(xiàn)整型的二進制轉(zhuǎn)化的方法，本文給大家介紹的非常詳細，具有一定的參考借鑒價值 ,需要的朋友可以參考下2019-07-07
在Go語言中,匿名嵌套結(jié)構(gòu)體和與類型同名的嵌套結(jié)構(gòu)體不是完全等價的,它們有一些重要的區(qū)別,這篇文章主要介紹了Go語言中匿名嵌套和類型嵌套的區(qū)別,需要的朋友可以參考下2023-09-09
Go?實戰(zhàn)單隊列到優(yōu)先級隊列實現(xiàn)圖文示例
