- 1、Go 語言結構
- Go Hello World 執行個體
- 執行 Go 程式
- 2、Go 語言基礎文法
- Go 标記
- 行分隔符
- 注釋
- 辨別符
- 字元串連接配接
- Go 語言的空格
- 格式化字元串
- 3、Go 語言資料類型
- 數字類型
- 浮點型
- 其他數字類型
- 4、Go 語言變量
- 變量聲明
- 多變量聲明
- 值類型和引用類型簡短形式，使用 := 指派操作符
- 5、Go 語言常量
- const
- iota
- 6、Go 語言運算符
- 算術運算符
- 關系運算符
- 邏輯運算符
- 位運算符
- 指派運算符
- 其他運算符
- 運算符優先級
- 7、Go 語言條件語句
- Go 語言循環語句
- 循環控制語句
- 無限循環
1、Go 語言結構
1.1、Go Hello World 執行個體
Go 語言的基礎組成有以下幾個部分：
- 包聲明
- 引入包
- 函數
- 變量
- 語句 & 表達式
- 注釋
接下來讓我們來看下簡單的代碼，該代碼輸出了”Hello World!”:
package main
import "fmt"
func main() {
/* 這是我的第一個簡單的程式 */
fmt.Println("Hello, World!")
} 讓我們來看下以上程式的各個部分：
- 第一行代碼 package main 定義了包名。你必須在源檔案中非注釋的第一行指明這個檔案屬于哪個包，如：package main。package main表示一個可獨立執行的程式，每個 Go 應用程式都包含一個名為 main 的包。
- 下一行 import “fmt” 告訴 Go 編譯器這個程式需要使用 fmt 包（的函數，或其他元素），fmt 包實作了格式化 IO（輸入/輸出）的函數。
- 下一行 func main() 是程式開始執行的函數。main 函數是每一個可執行程式所必須包含的，一般來說都是在啟動後第一個執行的函數（如果有 init() 函數則會先執行該函數）。
- 下一行 /*…*/ 是注釋，在程式執行時将被忽略。單行注釋是最常見的注釋形式，你可以在任何地方使用以 // 開頭的單行注釋。多行注釋也叫塊注釋，均已以 /* 開頭，并以 */ 結尾，且不可以嵌套使用，多行注釋一般用于包的文檔描述或注釋成塊的代碼片段。
-
下一行 fmt.Println(…) 可以将字元串輸出到控制台，并在最後自動增加換行字元 \n。
使用 fmt.Print(“hello, world\n”) 可以得到相同的結果。Print 和 Println 這兩個函數也支援使用變量，如：fmt.Println(arr)。如果沒有特别指定，它們會以預設的列印格式将變量 arr 輸出到控制台。
- 當辨別符（包括常量、變量、類型、函數名、結構字段等等）以一個大寫字母開頭，如：Group1，那麼使用這種形式的辨別符的對象就可以被外部包的代碼所使用（用戶端程式需要先導入這個包），這被稱為導出（像面向對象語言中的 public）；辨別符如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的内部是可見并且可用的（像面向對象語言中的 protected ）。
需要注意的是 { 不能單獨放在一行，是以以下代碼在運作時會産生錯誤：
package main
import "fmt"
func main()
{ // 錯誤，{ 不能在單獨的行上
fmt.Println("Hello, World!")
} 1.2、執行 Go 程式
方式一：輸入指令 go run hello.go 并按回車執行代碼
$ go run hello.go
Hello, World! 方式二：還可以使用 go build 指令來生成二進制檔案，然後直接執行二進制檔案
$ go build hello.go
$ ls
hello hello.go
$ ./hello
Hello, World! 2、Go 語言基礎文法
2.1、Go 标記
Go 程式可以由多個标記組成，可以是關鍵字，辨別符，常量，字元串，符号。如以下 GO 語句由 6 個标記組成：
fmt.Println("Hello, World!") 6 個标記是(每行一個)：
1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. ) 2.2、行分隔符
在 Go 程式中，一行代表一個語句結束。每個語句不需要像 C 家族中的其它語言一樣以分号 ; 結尾，因為這些工作都将由 Go 編譯器自動完成。
如果你打算将多個語句寫在同一行，它們則必須使用 ; 人為區分，但在實際開發中我們并不鼓勵這種做法。
以下為兩個語句：
fmt.Println("Hello, World!")
fmt.Println("菜鳥教程：runoob.com") 2.3、注釋
注釋不會被編譯，每一個包應該有相關注釋。
單行注釋是最常見的注釋形式，你可以在任何地方使用以 // 開頭的單行注釋。多行注釋也叫塊注釋，均已以 /* 開頭，并以 */ 結尾。如：
// 單行注釋
/*
Author by 菜鳥教程
我是多行注釋
*/ 2.4、辨別符
辨別符用來命名變量、類型等程式實體。一個辨別符實際上就是一個或是多個字母(A~Z和a~z)數字(0~9)、下劃線_組成的序列，但是第一個字元必須是字母或下劃線而不能是數字。
以下是有效的辨別符：
mahesh kumar abc move_name a_123
myname50 _temp j a23b9 retVal 以下是無效的辨別符：
- 1ab（以數字開頭）
- case（Go 語言的關鍵字）
- a+b（運算符是不允許的）
2.5、字元串連接配接
Go 語言的字元串可以通過 + 實作：
package main
import "fmt"
func main() {
fmt.Println("Google" + "Runoob")
} 2.6、Go 語言的空格
Go 語言中變量的聲明必須使用空格隔開，如：
var age int; 語句中适當使用空格能讓程式更易閱讀。
無空格：
fruit=apples+oranges; 在變量與運算符間加入空格，程式看起來更加美觀，如：
fruit = apples + oranges; 2.7、格式化字元串
Go 語言中使用 fmt.Sprintf 格式化字元串并指派給新串：
package main
import (
"fmt"
)
func main() {
// %d 表示整型數字，%s 表示字元串
var stockcode=123
var enddate="2020-12-31"
var url="Code=%d&endDate=%s"
var target_url=fmt.Sprintf(url,stockcode,enddate)
fmt.Println(target_url)
} 輸出結果為：
Code=123&endDate=2020-12-31 3、Go 語言資料類型
在 Go 程式設計語言中，資料類型用于聲明函數和變量。
資料類型的出現是為了把資料分成所需記憶體大小不同的資料，程式設計的時候需要用大資料的時候才需要申請大記憶體，就可以充分利用記憶體。
Go 語言按類别有以下幾種資料類型：
| 類型 | 描述 |
| 布爾型 | 布爾型的值隻可以是常量 true 或者 false。一個簡單的例子：var b bool = true。 |
| 數字類型 | 整型 int 和浮點型 float32、float64，Go 語言支援整型和浮點型數字，并且支援複數，其中位的運算采用補碼。 |
| 字元串類型 | 字元串就是一串固定長度的字元連接配接起來的字元序列。Go 的字元串是由單個位元組連接配接起來的。Go 語言的字元串的位元組使用 UTF-8 編碼辨別 Unicode 文本。 |
| 派生類型 | 包括： (a) 指針類型（Pointer） (b) 數組類型 (c) 結構化類型(struct) (d) Channel 類型 (e) 函數類型 (f) 切片類型 (g) 接口類型（interface） (h) Map 類型 |
3.1、數字類型
Go 也有基于架構的類型，例如：int、uint 和 uintptr。
| 序号 | 類型和描述 |
| 1 | uint8 無符号 8 位整型 (0 到 255) |
| 2 | uint16 無符号 16 位整型 (0 到 65535) |
| 3 | uint32 無符号 32 位整型 (0 到 4294967295) |
| 4 | uint64 無符号 64 位整型 (0 到 18446744073709551615) |
| 5 | int8 有符号 8 位整型 (-128 到 127) |
| 6 | int16 有符号 16 位整型 (-32768 到 32767) |
| 7 | int32 有符号 32 位整型 (-2147483648 到 2147483647) |
| 8 | int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807) |
3.2、浮點型
| 序号 | 類型和描述 |
| 1 | float32 IEEE-754 32位浮點型數 |
| 2 | float64 IEEE-754 64位浮點型數 |
| 3 | complex64 32 位實數和虛數 |
| 4 | complex128 64 位實數和虛數 |
3.3、其他數字類型
以下列出了其他更多的數字類型：
| 序号 | 類型和描述 |
| 1 | byte 類似 uint8 |
| 2 | rune 類似 int32 |
| 3 | uint 32 或 64 位 |
| 4 | int 與 uint 一樣大小 |
| 5 | uintptr 無符号整型，用于存放一個指針 |
4、Go 語言變量
變量來源于數學，是計算機語言中能儲存計算結果或能表示值抽象概念。
變量可以通過變量名通路。
Go 語言變量名由字母、數字、下劃線組成，其中首個字元不能為數字。
聲明變量的一般形式是使用 var 關鍵字：
var identifier type 可以一次聲明多個變量：
var identifier1, identifier2 type package main
import "fmt"
func main() {
var a string = "Runoob"
fmt.Println(a) // 輸出：Runoob
var b, c int = 1, 2
fmt.Println(b, c) // 輸出：1 2
} 4.1、變量聲明
第一種，指定變量類型，如果沒有初始化，則變量預設為零值。
var v_name v_type
v_name = value 零值就是變量沒有做初始化時系統預設設定的值。
package main
import "fmt"
func main() {
// 聲明一個變量并初始化
var a = "RUNOOB"
fmt.Println(a)
// 沒有初始化就為零值
var b int
fmt.Println(b)
// bool 零值為 false
var c bool
fmt.Println(c)
} 以上執行個體執行結果為：
RUNOOB
0
false - 數值類型（包括complex64/128）為 0
- 布爾類型為 false
- 字元串為 “”（空字元串）
- 以下幾種類型為 nil：
- var a *int var a []int var a map[string] int var a chan int var a func(string) int var a error // error 是接口
第二種，根據值自行判定變量類型。
var v_name = value package main
import "fmt"
func main() {
var d = true
fmt.Println(d) //輸出：true
} 第三種，省略 var, 注意 := 左側如果沒有聲明新的變量，就産生編譯錯誤，格式：
v_name := value 例如：
var intVal int
intVal := 1 // 這時候會産生編譯錯誤，因為 intVal 已經聲明，不需要重新聲明 直接使用下面的語句即可：
intVal := 1 // 此時不會産生編譯錯誤，因為有聲明新的變量，因為 := 是一個聲明語句 intVal := 1 相等于：
var intVal int
intVal =1 可以将 var f string = “Runoob” 簡寫為 f := “Runoob”：
package main
import "fmt"
func main() {
f := "Runoob" // var f string = "Runoob"
fmt.Println(f) //輸出：Runoob
} 4.2、多變量聲明
// 類型相同多個變量, 非全局變量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要顯示聲明類型，自動推斷
vname1, vname2, vname3 := v1, v2, v3 // 出現在 := 左側的變量不應該是已經被聲明過的，否則會導緻編譯錯誤
// 這種因式分解關鍵字的寫法一般用于聲明全局變量
var (
vname1 v_type1
vname2 v_type2
) package main
var x, y int
var ( // 這種因式分解關鍵字的寫法一般用于聲明全局變量
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
// 這種不帶聲明格式的隻能在函數體中出現
// g, h := 123, "hello"
func main(){
g, h := 123, "hello"
println(x, y, a, b, c, d, e, f, g, h)
} 4.3、值類型和引用類型
所有像 int、float、bool 和 string 這些基本類型都屬于值類型，使用這些類型的變量直接指向存在記憶體中的值。
- golang預設都是采用值傳遞，即拷貝傳遞
- 有些值天生就是指針（slice、map、channel）
當使用等号 = 将一個變量的值指派給另一個變量時，如：j = i，實際上是在記憶體中将 i 的值進行了拷貝。
可以通過 &i 來擷取變量 i 的記憶體位址，例如：0xf840000040（每次的位址都可能不一樣）。值類型的變量的值存儲在棧中。
記憶體位址會根據機器的不同而有所不同，甚至相同的程式在不同的機器上執行後也會有不同的記憶體位址。因為每台機器可能有不同的存儲器布局，并且位置配置設定也可能不同。
更複雜的資料通常會需要使用多個字，這些資料一般使用引用類型儲存。
一個引用類型的變量 r1 存儲的是 r1 的值所在的記憶體位址（數字），或記憶體位址中第一個字所在的位置。
這個記憶體位址稱之為指針，這個指針實際上也被存在另外的某一個值中。
同一個引用類型的指針指向的多個字可以是在連續的記憶體位址中（記憶體布局是連續的），這也是計算效率最高的一種存儲形式；也可以将這些字分散存放在記憶體中，每個字都訓示了下一個字所在的記憶體位址。
當使用指派語句 r2 = r1 時，隻有引用（位址）被複制。
如果 r1 的值被改變了，那麼這個值的所有引用都會指向被修改後的内容，在這個例子中，r2 也會受到影響。
4.4、簡短形式，使用 := 指派操作符
我們知道可以在變量的初始化時省略變量的類型而由系統自動推斷，聲明語句寫上 var 關鍵字其實是顯得有些多餘了，是以我們可以将它們簡寫為 a := 50 或 b := false。
a 和 b 的類型（int 和 bool）将由編譯器自動推斷。
這是使用變量的首選形式，但是它隻能被用在函數體内，而不可以用于全局變量的聲明與指派。使用操作符 := 可以高效地建立一個新的變量，稱之為初始化聲明。
注意事項
如果在相同的代碼塊中，我們不可以再次對于相同名稱的變量使用初始化聲明，例如：a := 20 就是不被允許的，編譯器會提示錯誤 no new variables on left side of :=，但是 a = 20 是可以的，因為這是給相同的變量賦予一個新的值。
如果你在定義變量 a 之前使用它，則會得到編譯錯誤 undefined: a。
如果你聲明了一個局部變量卻沒有在相同的代碼塊中使用它，同樣會得到編譯錯誤，例如下面這個例子當中的變量 a：
package main
import "fmt"
func main() {
var a string = "abc"
fmt.Println("hello, world")
} 嘗試編譯這段代碼将得到錯誤 a declared and not used。
此外，單純地給 a 指派也是不夠的，這個值必須被使用，是以使用
fmt.Println("hello, world", a) 會移除錯誤。
但是全局變量是允許聲明但不使用的。 同一類型的多個變量可以聲明在同一行：
var a, b, c int 多變量可以在同一行進行指派，如：
var a, b int
var c string
a, b, c = 5, 7, "abc" 上面這行假設了變量 a，b 和 c 都已經被聲明，否則的話應該這樣使用：
a, b, c := 5, 7, "abc" 右邊的這些值以相同的順序指派給左邊的變量，是以 a 的值是 5， b 的值是 7，c 的值是 “abc”。
這被稱為 并行 或 同時 指派。
如果你想要交換兩個變量的值，則可以簡單地使用 a, b = b, a，兩個變量的類型必須是相同。
空白辨別符 _ 也被用于抛棄值，如值 5 在：_, b = 5, 7 中被抛棄。
_ 實際上是一個隻寫變量，你不能得到它的值。這樣做是因為 Go 語言中你必須使用所有被聲明的變量，但有時你并不需要使用從一個函數得到的所有傳回值。
并行指派也被用于當一個函數傳回多個傳回值時，比如這裡的 val 和錯誤 err 是通過調用 Func1 函數同時得到：val, err = Func1(var1)。
空白辨別符在函數傳回值時的使用：
package main
import "fmt"
func main() {
_,numb,strs := numbers() //隻擷取函數傳回值的後兩個
fmt.Println(numb,strs)
}
//一個可以傳回多個值的函數
func numbers()(int,int,string){
a , b , c := 1 , 2 , "str"
return a,b,c
} 輸出結果：2 str
5、Go 語言常量
常量是一個簡單值的辨別符，在程式運作時，不會被修改的量。
常量中的資料類型隻可以是布爾型、數字型（整數型、浮點型和複數）和字元串型。
5.1、const
常量的定義格式：
const identifier [type] = value 你可以省略類型說明符 [type]，因為編譯器可以根據變量的值來推斷其類型。
- 顯式類型定義： const b string = “abc”
- 隐式類型定義： const b = “abc”
多個相同類型的聲明可以簡寫為：
const c_name1, c_name2 = value1, value2 常量還可以用作枚舉：
const (
Unknown = 0
Female = 1
Male = 2
) 數字 0、1 和 2 分别代表未知性别、女性和男性。
常量可以用len(), cap(), unsafe.Sizeof()函數計算表達式的值。常量表達式中，函數必須是内置函數，否則編譯不過：
package main
import "unsafe"
const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)
func main(){
println(a, b, c)
} 以上執行個體運作結果為：
abc 3 16 5.2、iota
iota，特殊常量，可以認為是一個可以被編譯器修改的常量。
iota 在 const關鍵字出現時将被重置為 0(const 内部的第一行之前)，const 中每新增一行常量聲明将使 iota 計數一次(iota 可了解為 const 語句塊中的行索引)。
iota 可以被用作枚舉值：
const (
a = iota
b = iota
c = iota
) 第一個 iota 等于 0，每當 iota 在新的一行被使用時，它的值都會自動加 1；是以 a=0, b=1, c=2 可以簡寫為如下形式：
const (
a = iota
b
c
) iota 用法
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //獨立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢複計數
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
} 以上執行個體運作結果為：
0 1 2 ha ha 100 100 7 8 再看個有趣的的 iota 執行個體：
package main
import "fmt"
const (
i=1<<iota
j=3<<iota
k
l
)
func main() {
fmt.Println("i=",i)
fmt.Println("j=",j)
fmt.Println("k=",k)
fmt.Println("l=",l)
} 以上執行個體運作結果為：
i= 1
j= 6
k= 12
l= 24 iota 表示從 0 開始自動加 1，是以 i=1<<0, j=3<<1（<< 表示左移的意思），即：i=1, j=6，這沒問題，關鍵在 k 和 l，從輸出結果看 k=3<<2，l=3<<3。
簡單表述:
- i=1：左移 0 位，不變仍為 1。
- j=3：左移 1 位，變為二進制 110，即 6。
- k=3：左移 2 位，變為二進制 1100，即 12。
- l=3：左移 3 位，變為二進制 11000，即 24。
6、Go 語言運算符
運算符用于在程式運作時執行數學或邏輯運算。
Go 語言内置的運算符有：
- 算術運算符
- 關系運算符
- 邏輯運算符
- 位運算符
- 指派運算符
- 其他運算符
6.1、算術運算符
假定 A 值為 10，B 值為 20。
| 運算符 | 描述 | 執行個體 |
| + | 相加 | A + B 輸出結果 30 |
| – | 相減 | A – B 輸出結果 -10 |
| * | 相乘 | A * B 輸出結果 200 |
| / | 相除 | B / A 輸出結果 2 |
| % | 求餘 | B % A 輸出結果 0 |
| ++ | 自增 | A++ 輸出結果 11 |
| — | 自減 | A– 輸出結果 9 |
6.2、關系運算符
假定 A 值為 10，B 值為 20。
| 運算符 | 描述 | 執行個體 |
| == | 檢查兩個值是否相等，如果相等傳回 True 否則傳回 False。 | (A == B) 為 False |
| != | 檢查兩個值是否不相等，如果不相等傳回 True 否則傳回 False。 | (A != B) 為 True |
| > | 檢查左邊值是否大于右邊值，如果是傳回 True 否則傳回 False。 | (A > B) 為 False |
| < | 檢查左邊值是否小于右邊值，如果是傳回 True 否則傳回 False。 | (A < B) 為 True |
| >= | 檢查左邊值是否大于等于右邊值，如果是傳回 True 否則傳回 False。 | (A >= B) 為 False |
| <= | 檢查左邊值是否小于等于右邊值，如果是傳回 True 否則傳回 False。 | (A <= B) 為 True |
6.3、邏輯運算符
假定 A 值為 True，B 值為 False。
| 運算符 | 描述 | 執行個體 |
| && | 邏輯 AND 運算符。 如果兩邊的操作數都是 True，則條件 True，否則為 False。 | (A && B) 為 False |
| || | 邏輯 OR 運算符。 如果兩邊的操作數有一個 True，則條件 True，否則為 False。 | (A || B) 為 True |
| ! | 邏輯 NOT 運算符。 如果條件為 True，則邏輯 NOT 條件 False，否則為 True。 | !(A && B) 為 True |
6.4、位運算符
位運算符對整數在記憶體中的二進制位進行操作。
假定 A 為60，B 為13：
| 運算符 | 描述 | 執行個體 |
| & | 按位與運算符”&”是雙目運算符。 其功能是參與運算的兩數各對應的二進位相與。 | (A & B) 結果為 12, 二進制為 0000 1100 |
| | | 按位或運算符”|”是雙目運算符。 其功能是參與運算的兩數各對應的二進位相或 | (A | B) 結果為 61, 二進制為 0011 1101 |
| ^ | 按位異或運算符”^”是雙目運算符。 其功能是參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。 | (A ^ B) 結果為 49, 二進制為 0011 0001 |
| << | 左移運算符”<<“是雙目運算符。左移n位就是乘以2的n次方。 其功能把”<<“左邊的運算數的各二進位全部左移若幹位，由”<<“右邊的數指定移動的位數，高位丢棄，低位補0。 | A << 2 結果為 240 ，二進制為 1111 0000 |
| >> | 右移運算符”>>”是雙目運算符。右移n位就是除以2的n次方。 其功能是把”>>”左邊的運算數的各二進位全部右移若幹位，”>>”右邊的數指定移動的位數。 | A >> 2 結果為 15 ，二進制為 0000 1111 |
6.5、指派運算符
| 運算符 | 描述 | 執行個體 |
| = | 簡單的指派運算符，将一個表達式的值賦給一個左值 | C = A + B 将 A + B 表達式結果指派給 C |
| += | 相加後再指派 | C += A 等于 C = C + A |
| -= | 相減後再指派 | C -= A 等于 C = C – A |
| *= | 相乘後再指派 | C *= A 等于 C = C * A |
| /= | 相除後再指派 | C /= A 等于 C = C / A |
| %= | 求餘後再指派 | C %= A 等于 C = C % A |
| <<= | 左移後指派 | C <<= 2 等于 C = C << 2 |
| >>= | 右移後指派 | C >>= 2 等于 C = C >> 2 |
| &= | 按位與後指派 | C &= 2 等于 C = C & 2 |
| ^= | 按位異或後指派 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或後指派 | C |= 2 等于 C = C | 2 |
6.6、其他運算符
| 運算符 | 描述 | 執行個體 |
| & | 傳回變量存儲位址 | &a; 将給出變量的實際位址。 |
| * | 指針變量。 | *a; 是一個指針變量 |
6.7、運算符優先級
有些運算符擁有較高的優先級，二進制運算符的運算方向均是從左至右。下表列出了所有運算符以及它們的優先級，由上至下代表優先級由高到低：
| 優先級 | 運算符 |
| 5 | * / % << >> & &^ |
| 4 | + – | ^ |
| 3 | == != < <= > >= |
| 2 | && |
| 1 | || |
當然，你可以通過使用括号來臨時提升某個表達式的整體運算優先級。
7、Go 語言條件語句
條件語句需要開發者通過指定一個或多個條件，并通過測試條件是否為 true 來決定是否執行指定語句，并在條件為 false 的情況在執行另外的語句。
下圖展示了程式語言中條件語句的結構：
Go 語言提供了以下幾種條件判斷語句：
| 語句 | 描述 |
| if 語句 | if 語句 由一個布爾表達式後緊跟一個或多個語句組成。 |
| if…else 語句 | if 語句 後可以使用可選的 else 語句, else 語句中的表達式在布爾表達式為 false 時執行。 |
| if 嵌套語句 | 你可以在 if 或 else if 語句中嵌入一個或多個 if 或 else if 語句。 |
| switch 語句 | switch 語句用于基于不同條件執行不同動作。 |
| select 語句 | select 語句類似于 switch 語句，但是select會随機執行一個可運作的case。如果沒有case可運作，它将阻塞，直到有case可運作。 |
注意：Go 沒有三目運算符，是以不支援 ?: 形式的條件判斷。
7.1、Go 語言循環語句
在不少實際問題中有許多具有規律性的重複操作，是以在程式中就需要重複執行某些語句。
以下為大多程式設計語言循環程式的流程圖：
Go 語言提供了以下幾種類型循環處理語句：
| 循環類型 | 描述 |
| for 循環 | 重複執行語句塊 |
| 循環嵌套 | 在 for 循環中嵌套一個或多個 for 循環 |
7.2、循環控制語句
循環控制語句可以控制循環體内語句的執行過程。
GO 語言支援以下幾種循環控制語句：
| 控制語句 | 描述 |
| break 語句 | 經常用于中斷目前 for 循環或跳出 switch 語句 |
| continue 語句 | 跳過目前循環的剩餘語句，然後繼續進行下一輪循環。 |
| goto 語句 | 将控制轉移到被标記的語句。 |
7.3、無限循環
如果循環中條件語句永遠不為 false 則會進行無限循環，我們可以通過 for 循環語句中隻設定一個條件表達式來執行無限循環：
package main
import "fmt"
func main() {
for true {
fmt.Printf("這是無限循環。\n");
}
}