4. 類型
下面是 Go 支持的基本類型：
- bool
- 數字類型
- int8, int16, int32, int64, int
- uint8, uint16, uint32, uint64, uint
- float32, float64
- complex64, complex128
- byte
- rune
- string
bool
bool 類型表示一個布爾值，值爲 true 或者 false。
package main
import "fmt"
func main() {
a := true
b := false
fmt.Println("a:", a, "b:", b)
c := a && b
fmt.Println("c:", c)
d := a || b
fmt.Println("d:", d)
}在上面的程序中，a 賦值爲 true，b 賦值爲 false。
c 賦值爲 a && b。僅當 a 和 b 都爲 true 時，操作符 && 才返回 true。因此，在這裏 c 爲 false。
當 a 或者 b 爲 true 時，操作符 || 返回 true。在這裏，由於 a 爲 true，因此 d 也爲 true。我們將得到程序的輸出如下。
a: true b: false
c: false
d: true有符號整型
int8：表示 8 位有符號整型
大小：8 位
範圍：-128～127
int16：表示 16 位有符號整型
大小：16 位
範圍：-32768～32767
int32：表示 32 位有符號整型
大小：32 位
範圍：-2147483648～2147483647
int64：表示 64 位有符號整型
大小：64 位
範圍：-9223372036854775808～9223372036854775807
int：根據不同的底層平臺（Underlying Platform），表示 32 或 64 位整型。除非對整型的大小有特定的需求，否則你通常應該使用 int 表示整型。
大小：在 32 位系統下是 32 位，而在 64 位系統下是 64 位。
範圍：在 32 位系統下是 -2147483648～2147483647，而在 64 位系統是 -9223372036854775808～9223372036854775807。
package main
import "fmt"
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
}上面程序會輸出 value of a is 89 and b is 95。
在上述程序中，a 是 int 類型，而 b 的類型通過賦值（95）推斷得出。上面我們提到，int 類型的大小在 32 位系統下是 32 位，而在 64 位系統下是 64 位。接下來我們會證實這種說法。
在 Printf 方法中，使用 %T 格式說明符（Format Specifier），可以打印出變量的類型。Go 的 unsafe 包提供了一個 Sizeof 函數，該函數接收變量並返回它的字節大小。unsafe 包應該小心使用，因爲使用 unsafe 包可能會帶來可移植性問題。不過出於本教程的目的，我們是可以使用的。
下面程序會輸出變量 a 和 b 的類型和大小。格式說明符 %T 用於打印類型，而 %d 用於打印字節大小。
package main
import (
"fmt"
"unsafe"
)
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的類型和大小
fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的類型和大小
}以上程序會輸出：
value of a is 89 and b is 95
type of a is int, size of a is 4
type of b is int, size of b is 4從上面的輸出，我們可以推斷出 a 和 b 爲 int 類型，且大小都是 32 位（4 字節）。如果你在 64 位系統上運行上面的代碼，會有不同的輸出。在 64 位系統下，a 和 b 會佔用 64 位（8 字節）的大小。
無符號整型
uint8：表示 8 位無符號整型
大小：8 位
範圍：0～255
uint16：表示 16 位無符號整型
大小：16 位
範圍：0～65535
uint32：表示 32 位無符號整型
大小：32 位
範圍：0～4294967295
uint64：表示 64 位無符號整型
大小：64 位
範圍：0～18446744073709551615
uint：根據不同的底層平臺，表示 32 或 64 位無符號整型。
大小：在 32 位系統下是 32 位，而在 64 位系統下是 64 位。
範圍：在 32 位系統下是 0～4294967295，而在 64 位系統是 0～18446744073709551615。
浮點型
float32：32 位浮點數
float64：64 位浮點數
下面一個簡單程序演示了整型和浮點型的運用。
package main
import (
"fmt"
)
func main() {
a, b := 5.67, 8.97
fmt.Printf("type of a %T b %T\n", a, b)
sum := a + b
diff := a - b
fmt.Println("sum", sum, "diff", diff)
no1, no2 := 56, 89
fmt.Println("sum", no1+no2, "diff", no1-no2)
}a 和 b 的類型根據賦值推斷得出。在這裏，a 和 b 的類型爲 float64（float64 是浮點數的默認類型）。我們把 a 和 b 的和賦值給變量 sum，把 b 和 a 的差賦值給 diff，接下來打印 sum 和 diff。no1 和 no2 也進行了相同的計算。上述程序將會輸出：
type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33複數類型
complex64：實部和虛部都是 float32 類型的的複數。
complex128：實部和虛部都是 float64 類型的的複數。
內建函數 complex用於創建一個包含實部和虛部的複數。complex 函數的定義如下：
func complex(r, i FloatType) ComplexType該函數的參數分別是實部和虛部，並返回一個複數類型。實部和虛部應該是相同類型，也就是 float32 或 float64。如果實部和虛部都是 float32 類型，則函數會返回一個 complex64 類型的複數。如果實部和虛部都是 float64 類型，則函數會返回一個 complex128 類型的複數。
還可以使用簡短語法來創建複數：
c := 6 + 7i下面我們編寫一個簡單的程序來理解複數。
package main
import (
"fmt"
)
func main() {
c1 := complex(5, 7)
c2 := 8 + 27i
cadd := c1 + c2
fmt.Println("sum:", cadd)
cmul := c1 * c2
fmt.Println("product:", cmul)
}在上面的程序裏，c1 和 c2 是兩個複數。c1的實部爲 5，虛部爲 7。c2 的實部爲8，虛部爲 27。c1 和 c2 的和賦值給 cadd ，而 c1 和 c2 的乘積賦值給 cmul。該程序將輸出：
sum: (13+34i)
product: (-149+191i)其他數字類型
byte 是 uint8 的別名。
rune 是 int32 的別名。
在學習字符串的時候，我們會詳細討論 byte 和 rune。
string 類型
在 Golang 中，字符串是字節的集合。如果你現在還不理解這個定義，也沒有關係。我們可以暫且認爲一個字符串就是由很多字符組成的。我們後面會在一個教程中深入學習字符串。 下面編寫一個使用字符串的程序。
package main
import (
"fmt"
)
func main() {
first := "Naveen"
last := "Ramanathan"
name := first +" "+ last
fmt.Println("My name is",name)
}上面程序中，first 賦值爲字符串 "Naveen"，last 賦值爲字符串 "Ramanathan"。+ 操作符可以用於拼接字符串。我們拼接了 first、空格和 last，並將其賦值給 name。上述程序將打印輸出 My name is Naveen Ramanathan。
還有許多應用於字符串上面的操作，我們將會在一個單獨的教程裏看見它們。
類型轉換
Go 有着非常嚴格的強類型特徵。Go 沒有自動類型提升或類型轉換。我們通過一個例子說明這意味着什麼。
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + j //不允許 int + float64
fmt.Println(sum)
}上面的代碼在 C 語言中是完全合法的，然而在 Go 中，卻是行不通的。i 的類型是 int ，而 j 的類型是 float64 ，我們正試圖把兩個不同類型的數相加，Go 不允許這樣的操作。如果運行程序，你會得到 main.go:10: invalid operation: i + j (mismatched types int and float64)。
要修復這個錯誤，i 和 j 應該是相同的類型。在這裏，我們把 j 轉換爲 int 類型。把 v 轉換爲 T 類型的語法是 T(v)。
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + int(j) //j is converted to int
fmt.Println(sum)
}現在，當你運行上面的程序時，會看見輸出 122。
賦值的情況也是如此。把一個變量賦值給另一個不同類型的變量，需要顯式的類型轉換。下面程序說明了這一點。
package main
import (
"fmt"
)
func main() {
i := 10
var j float64 = float64(i) // 若沒有顯式轉換，該語句會報錯
fmt.Println("j", j)
}在第 9 行，i 轉換爲 float64 類型，接下來賦值給 j。如果不進行類型轉換，當你試圖把 i 賦值給 j 時，編譯器會拋出錯誤。