【譯】Go 語言基礎(chǔ)-類型

下面這些是 Go 語言可用的基本類型：

1、bool（布爾）；

2、數(shù)值類型：

int8、int16、int32、int64、int

uint8、uint16、uint32、uint64、uint

float32、float64

complex64、complex128

byte、rune

3、string（字符串）；

bool

bool 類型表示布爾值，只有兩個(gè)值：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)
}

執(zhí)行^[1]

上面的代碼中，a 和 b 分別賦值為 true 和 false。

a && b 的結(jié)果賦給了 c，&& 操作符只有在 a 和 b 都為 true 時(shí)才返回 true，所以 c 的值是 false。

只要 a、b 有一個(gè)為 true，|| 操作符返回 true，所以這里 d 的值為 true。

上面的代碼輸出：

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

有符號整型

int8: 8 位有符號整型
size: 8 位
范圍: -128 ~ 127

int16: 16 位有符號整型
size: 16 位
范圍: -32768 ~ 32767

int32: 32 位有符號整型
size: 32 位
范圍: -2147483648 ~ 2147483647

int64: 64 位有符號整型
size: 64 位
范圍: -9223372036854775808 ~ 9223372036854775807

int: int 表示 32 或 64 位整型，具體位數(shù)取決于機(jī)器位數(shù)，除非需要使用特定大小的整數(shù)，否則通常使用 int 來表示整數(shù)
size: 32 位系統(tǒng)上為 32 位，64 位系統(tǒng)上為 64 位；
范圍: 32 位系統(tǒng) -2147483648 to 2147483647，64 位系統(tǒng) -9223372036854775808 to 9223372036854775807

package main

import "fmt"

func main() {
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
}

執(zhí)行^[2]

輸出：value of a is 89 and b is 95.

上面的代碼中，a 顯式地聲明為 int 類型，從賦給 b 的值來看，b 也是 int 類型。從上面我們知道，int 類型在 32 位系統(tǒng)上為 32 bit，在 64 位系統(tǒng)上是 64 bit。

我們一起來驗(yàn)證下。

變量的類型可以使用 Printf() 函數(shù)和 %T 格式化輸出。Sizeof() 函數(shù)是 unsafe 包里的函數(shù)，它以字節(jié)為單位返回變量的大小。應(yīng)該小心使用 unsafe 包，因?yàn)槭褂盟拇a可能存在可移植性問題，但出于教程目的，我們可以使用它。

下面的代碼輸出變量 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)) //type and size of a
    fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //type and size of b
}

執(zhí)行^[3]

從上面的輸出中，我們可以推斷出 a 和 b 的類型是 int 并且都是 32 位大?。? 字節(jié)）。如果你是在 64 位系統(tǒng)上運(yùn)行上述程序，輸出會有所不同。在 64 位系統(tǒng)中，a 和 b 占用 64 位（8 字節(jié)）。

無符號整型

uint8: 8 位無符號整型
size: 8 位
范圍: 0 ~ 255

uint16: 16 位無符號整型
size: 16 位
范圍: 0 ~ 65535

uint32: 32 位無符號整型
size: 32 位
范圍: 0 ~ 4294967295

uint64: 64 位無符號整型
size: 64 位
范圍: 0 ~ 18446744073709551615

uint : 32 位或 64 位無符號整型，具體位數(shù)取決于系統(tǒng)位數(shù)
size : 32 位或 64 位
范圍 : 32 位系統(tǒng) 0 ~ 4294967295，64 位系統(tǒng) 0 ~ 18446744073709551615

浮點(diǎn)型

float32: 32 位浮點(diǎn)數(shù)
float64: 64 位浮點(diǎn)數(shù)

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)
}

執(zhí)行^[4]

上面的代碼，a 和 b 的類型可以從分配給它們的值推斷出來。在上面這種情況下，a 和 b 是 float64 類型（float64 是浮點(diǎn)值的默認(rèn)類型）。我們將變量 a、b 相加之和賦給 sum，a 減 b 的結(jié)果賦給 diff，并且打印變量 sum、diff。使用變量 no1 和 no2 執(zhí)行相同的操作，上面的代碼輸出：

type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33

復(fù)數(shù)

complex64:由 float32 類型的實(shí)部和虛部組成的復(fù)數(shù)。complex128:由 float64 類型的實(shí)部和虛部組成的復(fù)數(shù)。

內(nèi)置函數(shù) complex() 根據(jù)給定的實(shí)數(shù)和虛數(shù)創(chuàng)建復(fù)數(shù)，該函數(shù)定義如下：

func complex(r, i FloatType) ComplexType

實(shí)部和虛部分別作為參數(shù)，返回一個(gè)復(fù)數(shù)。實(shí)部和虛部必須是同種類型，float32 或 float64。如果實(shí)部和虛部都是 float32，則返回類型為 complex64 的復(fù)數(shù)；如果實(shí)部和虛部都是 float64，則返回 complex128 類型的復(fù)數(shù)。

短變量聲明也可以創(chuàng)建復(fù)數(shù)：

c := 6 + 7i

我們一起來看個(gè) demo：

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)
}

執(zhí)行^[5]

上面的代碼中，c1 和 c2 是兩個(gè)復(fù)數(shù)，c1 的實(shí)部是 5、虛部是 7。c2 的實(shí)部是 8、虛部是 27。c1 和 c2 相加之和賦給 cadd，乘積賦給 cmul，程序輸出如下：

sum: (13+34i)
product: (-149+191i)

其他數(shù)值類型

byte 是 uint8 的別名，rune 是 int32 的別名。我們將在后面的章節(jié)展開講解這兩個(gè)概念。

字符串

Go 語言里面，字符串可以理解成是 byte（字節(jié)）的集合。

我們用 string 編寫一個(gè)程序:

package main

import (
    "fmt"
)

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

執(zhí)行^[6]

在上面的程序中，將字符串 "Naveen" 賦給了變量 first、"Ramanathan" 賦給了變量 last。字符串可以通過 + 操作符連接，將字符串變量 first、last 以空字符相連，結(jié)果賦給變量 name。

上面的代碼輸出：

My name is Naveen Ramanathan

還有一些關(guān)于字符串其他的操作方法，我們將在后面的章節(jié)單獨(dú)講解。

類型轉(zhuǎn)換

Go 是強(qiáng)類型語言，沒有類型的自動提升、轉(zhuǎn)換。我們來看下什么意思：

package main

import (
    "fmt"
)

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

執(zhí)行^[7]

上面的代碼，i 和 j 相加在 C 語言中是完全合法的，但在 Go 語言里卻是行不通的。i 是 int 類型，j 是 float64 類型，將這兩個(gè)不同類型的變量相加是不允許的。

執(zhí)行上面的代碼會報(bào)錯(cuò)：./prog.go:10:11: invalid operation: i + j (mismatched types int and float64)

將 i 和 j 轉(zhuǎn)換成相同的類型才能解決上面的問題，我們將 j 轉(zhuǎn)換成 int 類型，T(v) 是將 v 轉(zhuǎn)換為類型 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)
}

執(zhí)行^[8]

現(xiàn)在執(zhí)行上面的程序，將會輸出 122。

賦值的時(shí)候也是如此，需要顯式類型轉(zhuǎn)換才能將一種類型的變量分配給另一種類型，下面的程序很好地說明了這點(diǎn)：

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)
}

執(zhí)行^[9]

上面代碼的第 9 行，將 i 轉(zhuǎn)換成 float64 然后賦值給 j，如果不經(jīng)過類型轉(zhuǎn)換而直接賦值，編譯器將會報(bào)錯(cuò)。

via: https://golangbot.com/variables/ >
作者：Naveen R

參考資料

這是持續(xù)翻譯的第 29/100 篇優(yōu)質(zhì)文章。
如果你有想交流的話題，歡迎留言。