下麵是 Go 支持的基本類型： bool 數字類型 int8, int16, int32, int64, int uint8, uint16, uint32, uint64, uint float32, float64 complex64, complex128 byte rune string b ...
下麵是 Go 支持的基本類型：
bool 數字類型 int8, int16, int32, int64, int uint8, uint16, uint32, uint64, uint float32, float64 complex64, complex128 byte rune string bool
1、bool 類型表示一個布爾值，值為 true 或者 false。
2、有符號整型
int8：表示 8 位有符號整型
大小：8 位
範圍：-128～127
int16：表示 16 位有符號整型
大小：16 位
範圍：-32768～32767
int32：表示 32 位有符號整型
大小：32 位
範圍：-2147483648～2147483647
int32：表示 32 位有符號整型
大小：32 位
範圍：-2147483648～2147483647
int：根據不同的底層平臺（Underlying Platform），表示 32 或 64 位整型。除非對整型的大小有特定的需求，否則你通常應該使用 int 表示整型。
大小：在 32 位系統下是 32 位，而在 64 位系統下是 64 位。
範圍：在 32 位系統下是 -2147483648～2147483647，而在 64 位系統是 -9223372036854775808～9223372036854775807。
package main import ( "fmt" "unsafe" ) func main() { var a int = 89 b := 95 fmt.Sprintf("value of a is", a, "and is b\n", b) // a 的類型和大小 fmt.Printf("type of a is %T, size of a is %d\n", a, unsafe.Sizeof(a)) // b 的類型和大小 fmt.Printf("type of b is %T, size of b is %d\n", b, unsafe.Sizeof(b)) }
線上運行程式
value of a is 89 and is 95 type of a is int, size of a is 8 type of b is int, size of b is 8
從上面的輸出，我們可以推斷出 a 和 b 為 int 類型，且大小都是 64 位（8 位元組）。
如果你在 32 位系統上運行上面的代碼，會有不同的輸出。在 32 位系統下，a 和 b 會占用 32 位（4 位元組）的大小。
3、無符號整型
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。
4、浮點型
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) }
線上運行程式
type of a float64 b float64 sum 14.64 diff -3.3000000000000007 sum 145 diff -33
a 和 b 的類型根據賦值推斷得出。在這裡，a 和 b 的類型為 float64（float64 是浮點數的預設類型）。
我們把 a 和 b 的和賦值給變數 sum，把 b 和 a 的差賦值給 diff，接下來列印 sum 和 diff。no1 和 no2 也進行了相同的計算
5、複數
在電腦中，複數是由兩個浮點數表示的，其中一個表示實部（real），一個表示虛部（imag）
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) }
線上運行程式
sum: (13+34i) product: (-149+191i)
如果大家對複數的運演算法則不是很瞭解，可以查閱《複數運演算法則》，其中詳細的講解了複數的加減乘除操作 。
複數也可以用==和!=進行相等比較，只有兩個複數的實部和虛部都相等的時候它們才是相等的。
Go語言內置的 math/cmplx 包中提供了很多操作複數的公共方法，實際操作中建議大家使用複數預設的 complex128 類型，因為這些內置的包中都使用 complex128 類型作為參數
6、其他數字類型
byte 是 uint8 的別名。
rune 是 int32 的別名。
7、string 類型
在golang中，字元串是位元組的集合，其中每一個元素叫做字元。具體內容參看《go系統教程-字元串》
8、類型轉換
Go 有著非常嚴格的強類型特征。Go 沒有自動類型提升或類型轉換
package main import "fmt" func main() { a := 1 b := 5.5 sum := a + b fmt.Println(sum) }
線上運行程式
invalid operation: a + b (mismatched types int and float64)
上面的代碼在 C 語言中是完全合法的，然而在 Go 中，卻是行不通的。a的類型是 int ，而 b 的類型是 float64 ，
我們正試圖把兩個不同類型的數相加，Go 不允許這樣的操作。
如果運行程式，你會得到: invalid operation: i + j (mismatched types int and float64)
要修複這個錯誤，i 和 j 應該是相同的類型。在這裡，我們把 j 轉換為 int 類型。把 v 轉換為 T 類型的語法是 T(v)
package main import "fmt" func main() { a := 1 b := 5.5 sum := a + int(b) fmt.Println(sum) }
線上運行程式
6
