Go的基本語法總結

這篇文章主要講解了“Go的基本語法總結”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Go的基本語法總結”吧！

目錄

• 1. 變量與常量

• Golang 中的標識符與關鍵字

• Golang 中的變量

• Golang 中的常量

• Golang 中的iota常量計數器

• 2. 基本數據類型

• Golang 中的整型

• Golang 中的浮點型

• Golang 中的復數

• Golang 中的布爾值

• Golang 中的字符串

• Golang 中的byte和rune類型

• Golang 中的類型轉換

• 3. if 判斷和 for 循環

• for(循環結構)

• for range(鍵值循環)

• switch case

• goto(跳轉到指定標簽)

• break(跳出循環)

• continue(繼續下次循環)

1. 變量與常量

Golang 中的標識符與關鍵字

標識符

Go語言中標識符由字母數字和_(下劃線）組成，并且只能以字母和_開頭。 舉幾個例子：abc, _, _123, a123。

關鍵字

關鍵字和保留字都不建議用作變量名：

Go語言中有25個關鍵字：

break        default      func         interface    select
    case         defer        go           map          struct
    chan         else         goto         package      switch
    const        fallthrough  if           range        type
    continue     for          import       return       var

此外，Go語言中還有37個保留字。

Constants:    true  false  iota  nil
        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error
    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

Golang 中的變量

Go語言中的每一個變量都有自己的類型，并且變量必須經過聲明才能開始使用，同一作用域內不支持重復聲明。 并且Go語言的變量聲明后必須使用。

標準聲明

Go語言的變量聲明格式為：(Golang中變量的聲明推薦駝峰式命名法)

變量聲明以關鍵字var開頭，變量類型放在變量的后面，行尾無需分號。 舉個例子：

var 變量名 變量類型

批量聲明

每聲明一個變量就需要寫var關鍵字會比較繁瑣，go語言中還支持批量變量聲明：

var name string
var age int
var flag bool

變量的初始化

Go語言在聲明變量的時候，會自動對變量對應的內存區域進行初始化操作。每個變量會被初始化成其類型的默認值，例如： 整型和浮點型變量的默認值為0。 字符串變量的默認值為空字符串。 布爾型變量默認為false。 切片、函數、指針變量的默認為nil。

當然我們也可在聲明變量的時候為其指定初始值。變量初始化的標準格式如下：

var 變量名 類型 = 表達式

舉個例子：

var name string = "csp"
var age int = 22

或者一次初始化多個變量

var name, age = "csp", 22

類型推導(根據值自動判斷變量的類型)

有時候我們會將變量的類型省略，這個時候編譯器會根據等號右邊的值來推導變量的類型完成初始化。

var name = "csp" //自動識別為string
var age = 18 //自動識別為int

短變量聲明

在函數內部，可以使用更簡略的 := 方式聲明并初始化變量。

package main
import "fmt"
// 全局變量m
var m = 100
func main() {
	n := 10
	m := 200 // 此處聲明局部變量m
	fmt.Println(m, n)
}

匿名變量

在使用多重賦值時，如果想要忽略某個值，可以使用匿名變量（anonymous variable）。 匿名變量用一個下劃線_表示，例如：

func foo() (int, string) {
	return 10, "csp"
}
func main() {
	x, _ := foo() //只接收foo 函數的第一個返回值
	_, y := foo() //只接收foo 函數的第二個返回值
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

匿名變量不占用命名空間，不會分配內存，所以匿名變量之間不存在重復聲明。 (在Lua等編程語言里，匿名變量也被叫做啞元變量。)

注意事項：

• 函數外的每個語句都必須以關鍵字開始（var、const、func等）

• :=不能使用在函數外。

• _多用于占位，表示忽略值。

Golang 中的常量

相對于變量，常量是恒定不變的值，多用于定義程序運行期間不會改變的那些值。 常量的聲明和變量聲明非常類似，只是把var換成了const，常量在定義的時候必須賦值。

const pi = 3.1415
const e = 2.7182

聲明了pi和e這兩個常量之后，在整個程序運行期間它們的值都不能再發生變化了。

多個常量也可以一起聲明：

const (
    pi = 3.1415
    e = 2.7182
)

const同時聲明多個常量時，如果省略了值則表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

Golang 中的iota常量計數器

iota是go語言的常量計數器，只能在常量的表達式中使用。

iota在const關鍵字出現時將被重置為0。const中每新增一行常量聲明將使iota計數累加一次(iota可理解為const語句塊中的行索引)。 使用iota能簡化定義，在定義枚舉時很有用。

舉個例子：

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

幾個常見的iota示例

使用_跳過某些值

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)

iota聲明中間插隊

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0

定義數量級 （這里的<<表示左移操作，1<<10表示將1的二進制表示向左移10位，也就是由1變成了10000000000，也就是十進制的1024。同理2<<2表示將2的二進制表示向左移2位，也就是由10變成了1000，也就是十進制的8。）

const (
		_  = iota
		KB = 1 << (10 * iota)// 1 左移動 10 位 == 2^10 == 1024B = 1KB
		MB = 1 << (10 * iota)// 在原來基礎上再左移動10位，2^20 == 1MB
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

多個iota定義在一行

const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)

2. 基本數據類型

Golang 中的整型

整型分為以下兩個大類：

按長度分為：int8、int16、int32、int64

對應的無符號整型：uint8、uint16、uint32、uint64

其中，uint8就是我們熟知的byte型，int16對應C語言中的short型，int64對應C語言中的long型。

特殊整型

注意： 在使用int和 uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。

注意事項 獲取對象的長度的內建len()函數返回的長度可以根據不同平臺的字節長度進行變化。實際使用中，切片或 map 的元素數量等都可以用int來表示。在涉及到二進制傳輸、讀寫文件的結構描述時，為了保持文件的結構不會受到不同編譯目標平臺字節長度的影響，不要使用int和 uint。

數字進制的表示

Go1.13版本之后引入了數字字面量語法，這樣便于開發者以二進制、八進制或十六進制浮點數的格式定義數字，例如：

v := 0b00101101， 代表二進制的 101101，相當于十進制的 45。 v := 0o377，代表八進制的 377，相當于十進制的 255。 v := 0x1p-2，代表十六進制的 1 除以 2²，也就是 0.25。

而且還允許我們用 _ 來分隔數字，比如說： v := 123_456 表示 v 的值等于 123456。

我們可以借助fmt函數來將一個整數以不同進制形式展示。

package main
import "fmt"
func main(){
	// 十進制
	var a int = 10
	fmt.Printf("%d \n", a)  // 10
	fmt.Printf("%b \n", a)  // 1010  占位符%b表示二進制
	// 八進制  以0開頭
	var b int = 077
	fmt.Printf("%o \n", b)  // 77
	// 十六進制  以0x開頭
	var c int = 0xff
	fmt.Printf("%x \n", c)  // ff
	fmt.Printf("%X \n", c)  // FF
}

Golang 中的浮點型

Go語言支持兩種浮點型數：float32和float64(默認)。這兩種浮點型數據格式遵循IEEE 754標準： float32 的浮點數的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數的最大范圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。

打印浮點數時，可以使用fmt包配合動詞%f，代碼如下：

package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

Golang 中的復數

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

復數有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

Golang 中的布爾值

Go語言中以bool類型進行聲明布爾型數據，布爾型數據只有true（真）和false（假）兩個值。

注意：

布爾類型變量的默認值為false。

Go 語言中不允許將整型強制轉換為布爾型.

布爾型無法參與數值運算，也無法與其他類型進行轉換。

Golang 中的字符串

Go語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣。 Go 語言里的字符串的內部實現使用UTF-8編碼。 字符串的值為雙引號(")中的內容，可以在Go語言的源碼中直接添加非ASCII碼字符，例如：

s1 := "hello"
s2 := "你好"

字符串轉義符

Go 語言的字符串常見轉義符包含回車、換行、單雙引號、制表符等，如下表所示。

舉個例子，我們要打印一個Windows平臺下的一個文件路徑：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Code\\hello_golang\\go.exe\"")
}

多行字符串

Go語言中要定義一個多行字符串時，就必須使用反引號字符：

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引號間換行將被作為字符串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出。

字符串的常用操作

Golang 中的byte和rune類型

組成每個字符串的元素叫做“字符”，可以通過遍歷或者單個獲取字符串元素獲得字符。 字符用單引號（'）包裹起來，如：

var a := '中'
var b := 'x'

Go 語言的字符有以下兩種：

• uint8類型，或者叫 byte 型，代表了ASCII碼的一個字符。

• rune類型，代表一個 UTF-8字符。

當需要處理中文、日文或者其他復合字符時，則需要用到rune類型。rune類型實際是一個int32。

Go 使用了特殊的 rune 類型來處理 Unicode，讓基于 Unicode 的文本處理更為方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。

// 遍歷字符串
func traversalString() {
	s := "hello沙河"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

輸出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河)

因為UTF8編碼下一個中文漢字由3~4個字節組成，所以我們不能簡單的按照字節去遍歷一個包含中文的字符串，否則就會出現上面輸出中第一行的結果。

字符串底層是一個byte數組，所以可以和[]byte類型相互轉換。字符串是不能修改的 字符串是由byte字節組成，所以字符串的長度是byte字節的長度。 rune類型用來表示utf8字符，一個rune字符由一個或多個byte組成。

修改字符串

要修改字符串，需要先將其轉換成[]rune或[]byte，完成后再轉換為string。無論哪種轉換，都會重新分配內存，并復制字節數組。

func changeString() {
	s1 := "big"
	// 強制類型轉換
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))
	s2 := "白蘿卜"
	runeS2 := []rune(s2)
	runeS2[0] = '紅'
	fmt.Println(string(runeS2))
}

Golang 中的類型轉換

Go語言中只有強制類型轉換，沒有隱式類型轉換。該語法只能在兩個類型之間支持相互轉換的時候使用。

強制類型轉換的基本語法如下：

T(表達式)

其中，T表示要轉換的類型。表達式包括變量、復雜算子和函數返回值等.

比如計算直角三角形的斜邊長時使用math包的Sqrt()函數，該函數接收的是float64類型的參數，而變量a和b都是int類型的，這個時候就需要將a和b強制類型轉換為float64類型。

func sqrtDemo() {
	var a, b = 3, 4
	var c int
	// math.Sqrt()接收的參數是float64類型，需要強制轉換
	c = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)
}

練習題

• 編寫代碼分別定義一個整型、浮點型、布爾型、字符串型變量，使用fmt.Printf()搭配%T分別打印出上述變量的值和類型。

• 編寫代碼統計出字符串"hello沙河小王子"中漢字的數量。

3. if 判斷和 for 循環

Go語言中最常用的流程控制有if和for，而switch和goto主要是為了簡化代碼、降低重復代碼而生的結構，屬于擴展類的流程控制。

if else(分支結構)

if 條件判斷基本寫法

Go語言中if條件判斷的格式如下：

if 表達式1 {
    分支1
} else if 表達式2 {
    分支2
} else{
    分支3
}

當表達式1的結果為true時，執行分支1，否則判斷表達式2，如果滿足則執行分支2，都不滿足時，則執行分支3。 if判斷中的else if和else都是可選的，可以根據實際需要進行選擇。

Go語言規定與if匹配的左括號{必須與if和表達式放在同一行，{放在其他位置會觸發編譯錯誤。 同理，與else匹配的{也必須與else寫在同一行，else也必須與上一個if或else if右邊的大括號在同一行。

舉個例子：

func ifDemo1() {
	score := 65
	if score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

if 條件判斷特殊寫法

if條件判斷還有一種特殊的寫法，可以在 if 表達式之前添加一個執行語句，再根據變量值進行判斷，舉個例子：

func ifDemo2() {
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

思考題： 上下兩種寫法的區別在哪里？

for(循環結構)

Go 語言中的所有循環類型均可以使用for關鍵字來完成。

for循環的基本格式如下：

for 初始語句;條件表達式;結束語句{
    循環體語句
}

條件表達式返回true時循環體不停地進行循環，直到條件表達式返回false時自動退出循環。

func forDemo() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

for循環的初始語句可以被忽略，但是初始語句后的分號必須要寫，例如：

func forDemo2() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
}

for循環的初始語句和結束語句都可以省略，例如：

func forDemo2() {
	i := 0
	for ; i < 10; i++ {
		fmt.Println(i)
	}
}

這種寫法類似于其他編程語言中的while，在while后添加一個條件表達式，滿足條件表達式時持續循環，否則結束循環。

無限循環

for {
    循環體語句
}

for循環可以通過break、goto、return、panic語句強制退出循環。

for range(鍵值循環)

Go語言中可以使用for range遍歷數組、切片、字符串、map 及通道（channel）。 通過for range遍歷的返回值有以下規律：

數組、切片、字符串返回索引和值。map返回鍵和值。通道（channel）只返回通道內的值。

s := "hello 海賊王"
for i,v := range d {
    fmt.Printf("%d %c\n",i,v);
}
// 輸出結果
0 h
1 e
2 l
3 l
4 o
5
7 海
8 賊
9 王

switch case

使用switch語句可方便地對大量的值進行條件判斷。

func switchDemo1() {
	finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("無名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("無效的輸入！")
	}
}

Go語言規定每個switch只能有一個default分支。

一個分支可以有多個值，多個case值中間使用英文逗號分隔。

func testSwitch4() {
	switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇數")
	case 2, 4, 6, 8:
		fmt.Println("偶數")
	default:
		fmt.Println(n)
	}
}

分支還可以使用表達式，這時候switch語句后面不需要再跟判斷變量。例如：

func switchDemo4() {
	age := 30
	switch {
	case age < 25:
		fmt.Println("好好學習吧")
	case age > 25 && age < 35:
		fmt.Println("好好工作吧")
	case age > 60:
		fmt.Println("好好享受吧")
	default:
		fmt.Println("活著真好")
	}
}

fallthrough語法可以執行滿足條件的case的下一個case，是為了兼容C語言中的case設計的。

func switchDemo5() {
	s := "a"
	switch {
	case s == "a":
		fmt.Println("a")
		fallthrough
	case s == "b":
		fmt.Println("b")
	case s == "c":
		fmt.Println("c")
	default:
		fmt.Println("...")
	}
}

輸出：

a b

goto(跳轉到指定標簽)

goto語句通過標簽進行代碼間的無條件跳轉。goto語句可以在快速跳出循環、避免重復退出上有一定的幫助。Go語言中使用goto語句能簡化一些代碼的實現過程。 例如雙層嵌套的for循環要退出時：

func gotoDemo1() {
	var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 設置退出標簽
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外層for循環判斷
		if breakFlag {
			break
		}
	}
}

使用goto語句能簡化代碼：

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 設置退出標簽
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 標簽
breakTag:
	fmt.Println("結束for循環")
}

break(跳出循環)

break語句可以結束for、switch和select的代碼塊。

break語句還可以在語句后面添加標簽，表示退出某個標簽對應的代碼塊，標簽要求必須定義在對應的for、switch和 select的代碼塊上。 舉個例子：

func breakDemo1() {
BREAKDEMO1:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break BREAKDEMO1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")
}

continue(繼續下次循環)

continue語句可以結束當前循環，開始下一次的循環迭代過程，僅限在for循環內使用。

在 continue語句后添加標簽時，表示開始標簽對應的循環。例如：

func continueDemo() {
forloop1:
	for i := 0; i < 5; i++ {
		// forloop2:
		for j := 0; j < 5; j++ {
			if i == 2 && j == 2 {
				continue forloop1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
}

感謝各位的閱讀，以上就是“Go的基本語法總結”的內容了，經過本文的學習后，相信大家對Go的基本語法總結這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！