2.1 命名

Go語言中的函數名、變量名、常量名、類型名、語句標號和包名等所有的命名，都遵循一個簡單的命名規則：一個名字必須以一個字母（Unicode字母）或下劃線開頭，后面可以跟任意數量的字母、數字或下劃線。大寫字母和小寫字母是不同的：heapSort和Heapsort是兩個不同的名字。

Go語言中類似if和switch的關鍵字有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

此外，還有大約30多個預定義的名字，比如int和true等，主要對應內建的常量、類型和函數。
內建常量:

    true false iota nil

內建類型:

        int int8 int16 int32 int64
        uint uint8 uint16 uint32 uint64 uintptr
        float32 float64 complex128 complex64
        bool byte rune string error

內建函數:

    make len cap new append copy close delete
    complex real imag
    panic recover

2.2 變量

變量是幾乎所有編程語言中最基本的組成元素，變量是程序運行期間可以改變的量。

從根本上說，變量相當于是對一塊數據存儲空間的命名，程序可以通過定義一個變量來申請一塊數據存儲空間，之后可以通過引用變量名來使用這塊存儲空間。

2.2.1 變量聲明

Go語言的變量聲明方式與C和C++語言有明顯的不同。對于純粹的變量聲明， Go語言引入了關鍵字var，而類型信息放在變量名之后，示例如下：

var v1 int
var v2 int

//一次定義多個變量
var v3, v4 int 

var (
    v5 int
    v6 int
)

2.2.2 變量初始化

對于聲明變量時需要進行初始化的場景， var關鍵字可以保留，但不再是必要的元素，如下所示：

var v1 int = 10  // 方式1
var v2 = 10       // 方式2，編譯器自動推導出v2的類型
v3 := 10           // 方式3，編譯器自動推導出v3的類型
fmt.Println("v3 type is ", reflect.TypeOf(v3)) //v3 type is  int

//出現在 := 左側的變量不應該是已經被聲明過，:=定義時必須初始化
var v4 int
v4 := 2 //err

2.2.3 變量賦值

var v1 int
v1 = 123

var v2, v3, v4 int
v2, v3, v4 = 1, 2, 3    //多重賦值

i := 10
j := 20
i, j = j, i    //多重賦值

2.2.4 匿名變量

_（下劃線）是個特殊的變量名，任何賦予它的值都會被丟棄：

_, i, _, j := 1, 2, 3, 4

func test() (int, string) {
    return 250, "sa"
}

_, str := test()

2.3 常量

在Go語言中，常量是指編譯期間就已知且不可改變的值。常量可以是數值類型（包括整型、浮點型和復數類型）、布爾類型、字符串類型等。

2.3.1 字面常量(常量值)

所謂字面常量（literal），是指程序中硬編碼的常量，如：

123
3.1415  // 浮點類型的常量
3.2+12i // 復數類型的常量
true  // 布爾類型的常量
"foo" // 字符串常量

2.3.2 常量定義

const Pi float64 = 3.14
const zero = 0.0 // 浮點常量, 自動推導類型

const ( // 常量組
    size int64 = 1024
    eof        = -1 // 整型常量, 自動推導類型
)
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重賦值
const a, b, c = 3, 4, "foo"
// a = 3, b = 4, c = "foo"    //err, 常量不能修改

2.3.3 iota枚舉

常量聲明可以使用iota常量生成器初始化，它用于生成一組以相似規則初始化的常量，但是不用每行都寫一遍初始化表達式。

在一個const聲明語句中，在第一個聲明的常量所在的行，iota將會被置為0，然后在每一個有常量聲明的行加一。

const (
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w  // 這里隱式地說w = iota，因此w == 3。其實上面y和z可同樣不用"= iota"
)

const v = iota // 每遇到一個const關鍵字，iota就會重置，此時v == 0

const (
    h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)

const (
    a       = iota //a=0
    b       = "B"
    c       = iota             //c=2
    d, e, f = iota, iota, iota //d=3,e=3,f=3
    g       = iota             //g = 4
)

const (
    x1 = iota * 10 // x1 == 0
    y1 = iota * 10 // y1 == 10
    z1 = iota * 10 // z1 == 20
)

2.4 基礎數據類型

2.4.1 分類

Go語言內置以下這些基礎類型：

圖片.png

2.4.2 布爾類型

var v1 bool
v1 = true
v2 := (1 == 2) // v2也會被推導為bool類型

//布爾類型不能接受其他類型的賦值，不支持自動或強制的類型轉換
var b bool
b = 1 // err, 編譯錯誤
b = bool(1) // err, 編譯錯誤

2.4.3 整型

var v1 int32
v1 = 123
v2 := 64 // v1將會被自動推導為int類型

2.4.4 浮點型

var f1 float32
f1 = 12
f2 := 12.0 // 如果不加小數點， fvalue2會被推導為整型而不是浮點型，float64

2.4.5 字符類型

在Go語言中支持兩個字符類型，一個是byte（實際上是uint8的別名），代表utf-8字符串的單個字節的值；另一個是rune，代表單個unicode字符。

package main

import (
    "fmt"
)

func main() {
    var ch1, ch2, ch3 byte
    ch1 = 'a'  //字符賦值
    ch2 = 97   //字符的ascii碼賦值
    ch3 = '\n' //轉義字符
    fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3)
}

2.4.6 字符串

在Go語言中，字符串也是一種基本類型：

    var str string                                    // 聲明一個字符串變量
    str = "abc"                                       // 字符串賦值
    ch := str[0]                                      // 取字符串的第一個字符
    fmt.Printf("str = %s, len = %d\n", str, len(str)) //內置的函數len()來取字符串的長度
    fmt.Printf("str[0] = %c, ch = %c\n", str[0], ch)

    //`(反引號)括起的字符串為Raw字符串，即字符串在代碼中的形式就是打印時的形式，它沒有字符轉義，換行也將原樣輸出。
    str2 := `hello
    mike \n \r測試
    `
    fmt.Println("str2 = ", str2)
    /*
        str2 =  hello
              mike \n \r測試
    */

2.4.7 復數類型

復數實際上由兩個實數（在計算機中用浮點數表示）構成，一個表示實部（real），一個表示虛部（imag）。

var v1 complex64 // 由2個float32構成的復數類型
v1 = 3.2 + 12i
v2 := 3.2 + 12i        // v2是complex128類型
v3 := complex(3.2, 12) // v3結果同v2

fmt.Println(v1, v2, v3)
//內置函數real(v1)獲得該復數的實部
//通過imag(v1)獲得該復數的虛部
fmt.Println(real(v1), imag(v1))

2.5 fmt包的格式化輸出輸入

2.5.1 格式說明

圖片.png

2.5.2 輸出

//整型
a := 15
fmt.Printf("a = %b\n", a) //a = 1111
fmt.Printf("%%\n")        //只輸出一個%

//字符
ch := 'a'
fmt.Printf("ch = %c, %c\n", ch, 97) //a, a

//浮點型
f := 3.14
fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14
fmt.Printf("f type = %T\n", f)   //f type = float64

//復數類型
v := complex(3.2, 12)
fmt.Printf("v = %f, %g\n", v, v) //v = (3.200000+12.000000i), (3.2+12i)
fmt.Printf("v type = %T\n", v)   //v type = complex128

//布爾類型
fmt.Printf("%t, %t\n", true, false) //true, false

//字符串
str := "hello go"
fmt.Printf("str = %s\n", str) //str = hello go

2.5.3 輸人

var v int
fmt.Println("請輸入一個整型：")
fmt.Scanf("%d", &v)
//fmt.Scan(&v)
fmt.Println("v = ", v)

2.6 類型轉換

Go語言中不允許隱式轉換，所有類型轉換必須顯式聲明，而且轉換只能發生在兩種相互兼容的類型之間。

var ch byte = 97
//var a int = ch //err, cannot use ch (type byte) as type int in assignment
var a int = int(ch)

2.7 類型別名

type bigint int64 //int64類型改名為bigint
var x bigint = 100

type (
    myint int    //int改名為myint
    mystr string //string改名為mystr
)