Golang教程：類型

下面是 Go 支持的基本類型：

• bool
• Numeric Types 
  
  • int8, int16, int32, int64, int
  • uint8,uint16,uin32,uint64, uint
  • float32, float64
  • complex64, complex128
  • byte
  • rune
• string

bool

bool 類型表示真假值，只能為 true 或 false。

import "fmt"

func main() {  
    var a bool = 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，因此 a || b 的結果為true，因此 d 為 true）。我們將會得到如下輸出：

a: true b: false  
c: false  
d: true 

有符號整型

int8：表示8位有符號整數 
size：8 bits 
range：-128 ~ 127

int16：表示16位有符號整數 
size：16 bits 
range：-32768 ~ 32767

int32： 表示32位有符號整數 
size： 32 bits 
range： -2147483648 ~ 2147483647

int64： 表示64位有符號整數 
size： 64 bits 
range： -9223372036854775808 ~ 9223372036854775807

int： 根據底層平台（underlying platform）不同，表示32或64位整數。在實際編程中，除非對大小有明確的要求，否則一般應該使用 int 表示整數。 
size： 在32位系統下 32 bits，在64位系統下 64 bits 
range： 在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

無符號整型

uint8： 表示8位無符號整型 
size： 8 bits 
range： 0 ~ 255

uint16： 表示16位無符號整型 
size： 16 bits 
range： 0 ~ 65535

uint32： 表示32位無符號整型 
size： 32 bits 
range： 0 ~ 4294967295

uint64： 表示64位無符號整型 
size： 64 bits 
range： 0 ~ 18446744073709551615

uint ： 根據底層平台不同表示32或64位無符號整型 
size ： 32位系統下是32 bits，64位系統下64 bits 
range ：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。將 a 與 b 的差賦值給 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 來構造一個包含實部和虛部的復數。它的原型為：

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 的別稱

我們將在學習 string 類型時詳細討論 byte 和 rune。

字符串類型

在Go中字符串（String）是 byte 的集合。如果你覺得這個定義沒有任何意義也沒關系。我們可以暫且假定一個字符串就是一串字符的集合。在后面的教程中我們將通過一整篇的篇幅來介紹字符串的細節。

讓我們寫一個程序來了解字符串：

package main

import (  
    "fmt"
)

func main() {  
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

在上面的程序中，first 被賦值為 "Naveen"，last 被賦值為 "Ramanathan"。字符串可以通過 + 操作符連接在一起。name 被賦值為 first 、空格與 last 三者連接后的結果。上面的程序將得到如下輸出：

My name is Naveen Ramanathan

還有許多操作可應用於字符串。我們將用單獨的一篇教程來介紹它們。

字符串的長度

utf8 包 提供了 func RuneCountInString(s string) (n int) 來獲取字符串的長度，該方法接受一個字符串作為參數，並返回該字符串中 rune 的數量。

（譯者注： RuneCountInString 返回字符串中 Unicode 字符的個數，而 len 返回字符串中 byte 的個數，注意兩者的區別。 ）

package main

import (  
    "fmt"
    "unicode/utf8"
)



func length(s string) {  
    fmt.Printf("length of %s is %d\n", s, utf8.RuneCountInString(s))
}
func main() {  

    word1 := "Señor" 
    length(word1)
    word2 := "Pets"
    length(word2)
}

上面程序的輸出為：

length of Señor is 5  
length of Pets is 4  

 

類型轉換

Go是強類型的語言，沒有隱式的類型提升和轉換。讓我們通過一個例子說明這意味着什么：

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //int + float64 not allowed
    fmt.Println(sum)
}

上面的代碼在C語言中是完全合法的，但是在Go中卻不是。i 的類型是 int 而 j 的類型是 float64，將這兩個類型不同的數字相加是非法的。運行這個程序將會報錯：main.go:10: invalid operation: i + j (mismatched types int and float64)。

為了修復這個錯誤，我們應該將 i 和 j 轉換為同樣的類型，在這里讓我們將 j 轉換為 int。通過 T(v)可以將 v 的值轉換為 T 類型 。

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) //this statement will not work without explicit conversion
    fmt.Println("j", j)
}

在 var j float64 = float64(i) 這一行，i 被轉換為 float64，然后賦值給 j。當你嘗試將 i 不進行轉換直接賦值給 j時，編譯器將報錯。