1.標識符

在編程語言中標識符就是程序員定義的具有特殊意義的詞，比如變量名，常量名，函數 .bc，_123，a1232

2.關鍵字

關鍵字是指編程語言中預先定義好的具有特殊含義的標識符，關鍵字和保留字都不建議用作變量名

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

還有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

3.變量

變量的功能是存儲數據，不同的變量保存的數據類型可能會不一樣，經過半個多世紀的發展，編程語言已經基本形成了一套固定的類型，常見變量的數據類型有：整型、浮點型、布爾型等

Go語言中的每一個變量都有自己的類型，并且變量必須經過聲明才能開始使用

3.1 Go語言中變量的聲明

聲明格式

var 變量名 變量類型

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

var name string
var age int
var isOk bool

3.2 批量聲明

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

var (
    a string
    b int
    c bool
    d float32
)

3.3 變量的初始化

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

func main() {
	var (
		test01 string
		test02 int
		test03 bool
		test04 float32
	)
	fmt.Println(test01, test02, test03, test04)
}

 0 false 0

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

var 變量名 類型=表達式

例子

var name string="wql"
var age int =18

或者一次初始化多個變量

var name,age="wql",20

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

var name = "wql"
var age = 18

3.4 短變量聲明

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

package main

//告訴程序需要fmt包，fmt具有打印輸出的函數
import "fmt"

var n int

func main() {
	b := 123
	fmt.Println(b)
}

3.5匿名變量

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

package main

//告訴程序需要fmt包，fmt具有打印輸出的函數
import "fmt"

func main() {


	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)

}

func foo() (int, string) {
	return 10, "wql"
}

123 123
hello wql
x= 10
y= wql

匿名變量不占用命名空間，不會分配內存，所以匿名變量之間不存在重復聲明

注意事項

• 函數外的每個語句必須以關鍵字開始（var、const、func等）
• :=不能用在函數外
• _多用于占位，表示忽略值

4.常量

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

?? ?const pi = 3.12
?? ?const e = 2.7
?? ?fmt.Println(pi, e)
1
2
3
在聲明了pi和e這兩個常量之后，在整個程序運行期間它們的值都不能再發生變化了

多個常量也可以一起聲明

    const(
        p1 = 2
        p2 = 4
    )

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

    const(
        p3 = 200
        p4
        p5
    )

上面的實例中p3，p4，p5的值都是200

5.iota

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

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

    const (
        n1 = iota //0
        n2        //1
        n3        //2
        n4        //3
    )
    fmt.Println(n1, n2, n3, n4)

0 1 2 3

`幾個常見的iota實例：

`使用下劃線跳過某些值

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

iota聲明中間插隊
    const (
        n1 = iota //0
        n2 = 100  //100
        n3 = iota //2
        n4        //3
    )

也就是說有無初始值，iota都+1，常量有初始值就是初始值，沒有初始值為iota+1

    const (
        _  = iota
        KB = 1 << (10 * iota)
        MB = 1 << (10 * iota)
        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
    )

所以iota有兩個特點

• 當遇見const出現被置為0
• 每新增一行就+1

總結