Go起步:3、變數、常量和基礎類型

這是一個建立於 的文章，其中的資訊可能已經有所發展或是發生改變。

在此之前，搭建了Go的開發環境，並且瞭解的Go程式的基本結構。選擇了一款Go的開發工具。有了這些，現在可以繼續探索Go的魅力了。

變數

聲明、初始化

在Go中對於變數的聲明使用關鍵字var，這和JavaScript，Pascal一樣。在Swift 中var 也用來定義變數，似乎新的語言都傾向使用特別關鍵字聲明變數了。不過變數聲明的格式和JavaScript還是有很大的區別，到是有些類似Pascal和Swift–都是類型資訊放在變數名之後，區別在於不需要使用：分割。

var v1 int          //定義類型為int的變數v1var v2 string       //定義類型為string的變數v2

還可以看出，變數聲明語句不需要使用分號作為結束符。現在很多語言在語句結束都摒棄了分號，像Python，Swift，R等等。這點不知道是什麼趨勢。
Go作為一個比較新的語言，在一些寫法上還是有一些比較特殊的做法。像var關鍵字的另一種用法是可以將若干個需要聲明的變數放置在一起。
比如像上面，同時聲明v1和v2可以這麼寫：

var(          v1 int          v2 string )

在變數聲明時可以直接初始化的，這時var關鍵字甚至可以省略。

var v1 int = 100 //  var v2 = 100    // 編譯器可以自動推匯出v2的類型 v3 := 100       // 編譯器可以自動推匯出v3的類型 

這裡可以看出，第一種方式給出一條警告，滑鼠放上去是提示警告資訊是“should omit type int from declaration of var v1; it will be inferred from the right-hand side”。意思是應該省略VAR V1的類型為int;它將從右側來推斷。可以看出指定類型已不再是必需的，Go可以從初始設定式的右值推匯出該變數類型，這讓Go看起來有點像JavaScript這樣的動態類型語言，但Go實際上是一種像java一樣的靜態類型語言。
第三種引入了一種“：=”符號。這在初始設定變數是可以省略var關鍵字。這個符號應該是Go的獨創吧。需要注意的是函數外的每個語句都必須以關鍵字開始（ var 、 func 等等）， 因此 := 結構不能在函數外使用。
以上三種方式都是Go支援的，具體使用哪種可以自己選擇。

賦值

在Go文法中，變數初始化和變數賦值是兩個不同的概念。就像：

var v1 int //定義類型為int的變數v1v1 = 100   //給v1賦值100

Go語言的變數賦值與其他的程式設計語言一致，但Go語言中提供多重賦值功能，如要實現交換v1和v2變數的語句。一般做法是需要一個中間變數來完成。temp=v1,v1=v2,v2=temp。但Go可以向下面這樣操作。

package mainimport "fmt"func main() {    var v1 int //定義類型為int的變數v1    v1 = 100    var v2 = 200    fmt.Println("v1:", v1)    fmt.Println("v2:", v2)    fmt.Println("交換v1,v2")    v2, v1 = v1, v2    fmt.Println("v1:", v1)    fmt.Println("v2:", v2)}

常量

定義、聲明

常量是指編譯期間就已知且不可改變的值。常量的聲明與變數類似，只不過是使用 const 關鍵字。
常量可以是字元、字串、布爾值或數值。
常量不能用 := 文法聲明。

package mainimport "fmt"const Pi = 3.14func main() {    const World = "世界"    fmt.Println("Hello", World)    fmt.Println("Happy", Pi, "Day")    const Truth = true    fmt.Println("Go rules?", Truth)}

預定義常量

Go語言預定義了這些常量：true、false和iota。
iota比較特殊，可以被認為是一個可被編譯器修改的常量，在每一個const關鍵字出現時被重設為0，然後在下一個const出現之前，每出現一次iota，其所代表的數字會自動增1。

package mainimport "fmt"func main() {    const ( // iota被重設為0        c0 = iota // c0 == 0        c1 = iota // c1 == 1        c2 = iota // c2 == 2    )    fmt.Println("c0", c0)    fmt.Println("c1", c1)    fmt.Println("c2", c2)}

如果兩個const的指派陳述式的運算式是一樣的，那麼可以省略後一個賦值運算式。因此，上面的前兩個const語句可簡寫為

const (         // iota被重設為0     c0 = iota       // c0 == 0     c1              // c1 == 1     c2              // c2 == 2 )

上面兩個返回的結果是一樣的。

類型

我開始接觸Go首先就是先瞭解Go有哪些類型。
Go語言內建以下這些基礎類型：

• 布爾類型：bool
• 整型：int8、byte、int16、int、uint、uintptr等
• 浮點類型：float32、float64
• 複數類型：complex64、complex128
• 字串：string
• 字元類型：rune

此外，Go語言也支援以下這些複合類型：

• 指標（pointer）
• 數組（array）
• 切片（slice）
• 字典（map）
• 通道（chan）
• 結構體（struct）
• 介面（interface）
• 錯誤類型：error

布爾類型

在Go語言中的布爾類型與其他語言基本是一致的，關鍵字為bool，值必須為true或false，不支援自動或強制的類型轉換。

整型

整形基本是所有程式設計語言最基礎的類型了。

需要注意的是中，像int和int32在Go語言裡被認為是兩種不同的類型，編譯器也不會幫你自動做類型轉換。如果要轉換需要自己手動做強制轉換，強制轉換時精度會損失。
對於整型的操作主要有數值計算（+、-、*、/、%），比較運算（>、<、==、>=、<=、!=）。這一點與大多數其他語言相 同，與C、java等完全一致。 而且Go的整型也支援位元運算。

浮點型

浮點型用於表示有小數位的資料，Go語言中的浮點類型 採用IEEE-754標準的表達方式。 包括float32和float64兩個類型。其中float32等價於C語言的float類型， float64等價於C語言的double類型。

複數類型

複數實際上由兩個實數構成，在電腦中用浮點數表示，一個表示實部（real），一個表示 虛部（imag）。 對於一個複數z = complex(x, y)，就可以通過Go語言內建函數real(z)獲得該複數的實 部，也就是x，通過imag(z)獲得該複數的虛部，也就是y。

字串

字串是所有程式設計語言的一種基本類型，Go也不例外。

package mainimport "fmt"func main() {    var str1 string    //定義    str1 = "hello"     //賦值    char := str1[0]    //取得第一個字元    fmt.Printf("字串%s長度%d\n", str1, len(str1))  //取得第一個字元    fmt.Printf("c字串%s第一個字元%c\n", str1, char)    str2 := "world"  //初始化    fmt.Println(str1 + str2)  //字串串連操作}

上面對字串的操作有定義，初始化，賦值，計算長度，取得第一個字元，字串串連操作。其中取字串的長度使用了一個Go語言內建的函數len()。還可以看出，Go取字串位元組可以向數組一樣，直接通過下標就可以。

字元類型

在Go語言中支援兩個字元類型，一個是byte（實際上是uint8的別名），代表UTF-8字串的單個位元組的值；另一個是rune，代表單個Unicode字元。出於簡化語言的考慮，Go語言的多數API都假設字串為UTF-8編碼。儘管Unicode字元在標 准庫中有支援，但實際上較少使用。
在Go當中 string底層是用byte數組存的，並且是不可以改變的。用string儲存unicode的話，即如果有中文，按下標是訪問不到的，因為你只能得到一個byte，而漢字需要3個byte。

package mainimport "fmt"func main() {    var str1 string    str1 = "Go語言"    char := str1[2]    fmt.Printf("字串%s長度%d\n", str1, len(str1))    fmt.Printf("c字串%s第3個字元%c\n", str1, char)}

通過輸出結果看出，“Go語言”長度是8，因為漢字是按3位元組儲存的。通過下標取到的也不是想要的“語”字。
這是要想取到想要的結果，就需要使用rune。rune是位元組組合。

package mainimport "fmt"func main() {    var str1 string    str1 = "Go語言"    r := []rune(str1)    fmt.Printf("字串%s長度%d\n", str1, len([]rune(str1)))    fmt.Printf("c字串%s第3個字元%c\n", str1, r[2])}

這樣就取到了想要的結果。

這裡就先到這裡，上面是Go支援的一些基礎類型。關於複合類型下次見。通過到目前的瞭解，可以發現，Go裡還是有很多文法糖的，很多寫法都和java這樣的語言不同，似乎借鑒了很多像python之類的語言，盡量簡單。有時間要去瞭解一下Go語言的設計哲學。