Go基礎教學系列之資料型別詳細說明

2022-04-16 19:00:21

每一個變數都有資料型別，Go中的資料型別有：

簡單資料型別：int、float、complex、bool和string
資料結構或組合(composite)：struct、array、slice、map和channel
介面(interface)

當宣告變數的時候，會做預設的賦0初始化。每種資料型別的預設賦0初始化的0值不同，例如int型別的0值為數值0，float的0值為0.0，string型別的0值為空""，bool型別的0值為false，資料結構的0值為nil，struct的0值為欄位全部賦0。

其實函數也有型別，不過一般稱之為返回型別。例如，下面的函數foo的返回型別是int：

func foo() int {
    ...CODE...
    return INT_TYPE_VALUE
}

函數允許有多個返回值，它們使用逗號分隔，括號包圍：

func foo() (int,bool)

Number型別

Integer

Integer型別是整型資料，例如3 22 0 1 -3 -22等。

Go中的Integer有以下幾種細分的型別：

int8,int16,int32,int64
uint8,uint16,uint32,uint64
byte
rune
int,uint

其中8 16 32 64表示該資料型別能儲存的bit位數。例如int8表示能儲存8位元數值，所以這個型別佔用1位元組，也表示最大能儲存的整型數共2^8=256個，所以int8型別允許的最大正數為127，允許的最小負數為-128，共256個數值。

uint中的u表示unsigned，即無符號整數，只儲存0和正數。所以uint8能儲存256個數的時候，允許的最小值為0，允許的最大值為255。

額外的兩種Integer是byte和rune，它們分別等價於uint8(即一個位元組大小的正數)、int32。從builtin包中的定義就可以知道：

$ go doc builtin | grep -E "byte|rune"
type byte = uint8
type rune = int32

byte型別後面會詳細解釋。

還有兩種依賴於CPU位數的型別int和uint，它們分別表示一個機器字長。在32位元CPU上，一個機器字長為32bit，共4位元組，在64位元CPU上，一個機器字長為64bit，共8位元組。除了int和uint依賴於CPU架構，還有一種uintptr也是依賴於機器字長的。

一般來說，需要使用整型資料的時候，指定int即可，有明確的額外需求時再考慮是否換成其它整數型別。

在整數加上0字首表示這是8進位制，例如077。加上字首0x表示這是16進位制，例如0x0c，使用e符號可以表示這是一個科學計數法，如1e3 = 1000,6.023e23 = 6.023 x 10^23。

可以使用TYPE(N)的方式來生成一個數值，例如a := uint64(5)。實際上這是型別轉換，將int型別的5轉換成int64型別的5。

byte型別

Go中沒有專門提供字元型別char，Go內部的所有字元型別(無論是ASCII字元還是其它多位元組字元)都使用整數值儲存，所以字元可以存放到byte、int等資料型別變數中。byte型別等價於uint8型別，表示無符號的1位元組整數。

Go中的字元都使用單引號包圍，例如'a'、'我'，但單引號中包含了多個字元是錯誤的(如'aA')，因為字元型別就是一個字元。

例如，ASCII的字母a表示97。下面這種定義方式是允許的：

var a byte = 'A'  // a=65
var b uint8 = 'a' // b=97

注意，字元必須使用單引號，且必須只能是單個字元。所以byte型別經常被稱為character型別。

以下也都是允許的：

var a = 'A'
var a uint32 = 'A'
var a int64 = 'A'

所以，Integer型別當儲存的是以單引號包圍的字元時，它會將字元轉換成它二進位制值對應的數值。同樣適用於unicode字元，它將用來存放各位元組對應的二進位制的數值：

var a int64 = '我'  // a=25105

由於我在Go中佔用3位元組，所以儲存到byte中是報錯的：

var a byte = '我'

可以儲存它的unicode字元的程式碼點：

var a byte = 'u0041'  // a=65，代表的字元A

如果不知道程式碼點的值，可以將其以int型別儲存並輸出。

fmt.Printf("%d", '我')  // 25105

如果想將byte值轉換為字元，可以使用string()函數做簡單的型別轉換：

var a = 'A'
println(string(a))     // 輸出:A

float和complex

float是浮點數(俗稱小數)，例如0.0 3.0 -3.12 -3.120等。

Go中的浮點數型別float有兩種：float32和float64。

complex表示複數型別(虛數)，有complex64和complex128。

浮點數在計算機系統中非常複雜，對於學習來說，只需將其認為是數學中的一種小數即可。但以下幾個注意點需要謹記心中：

浮點數是不精確的。例如1.01-0.99從數學運算的角度上得到的值是0.02，但實際上的結果是0.020000000000000018(python運算的結果)，在Go中會將其表示為+2.000000e-002。這個結果是一種極限趨近於我們期待值的結果。
float32的精度(7個小數位)低於float64(15個小數位)，所以float64型別的值比float32型別的值更精確。
因為浮點數不精確，所以儘量不要對兩個浮點數數進行等值==和不等值!=比較，例如(3.2-2.8) == 0.4返回Flase。如果非要比較，應該通過它們的減法求絕對值，再與一個足夠小(不會影響結果)的值做不等比較，例如abs((3.2-2.8)-0.4) < 0.0002返回True。

一般來說，在程式中需要使用浮點數的時候都使用float64型別，不僅因為精確，更因為幾乎所有包中需要float引數的型別都是float64。

在Go的數學運算中，預設取的是整型資料，如果想要得到浮點數結果，必須至少讓運算的一方寫成浮點數格式：

var a := 3/2     // a得到截斷的整數：a=1
var b := 3/2.0   // b為浮點數b=+1.500000e+000
var c := 3 + 2.0 // c為浮點數

string型別

Go中的string用於儲存UTF-8字元序列，它是動態大小的。對於字母和英文字母，它佔用一個位元組，對於其它unicode字元，按需佔用2-4個位元組。例如中文字元佔用3個位元組。

Go中的string型別要使用雙引號或反引號包圍，它們的區別是：

雙引號是弱參照，其內可以使用反斜線跳脫符號，如abncd表示ab後換行加cd
反引號是強參照，其內任何符號都被強制解釋為字面意義，包括字面的換行。也就是所謂的裸字串。

func main() {
    println("abcndef")
    println(`ABC
    DEF`)
}

上面的結果將輸出：

abc
def
ABC
    DEF

不能使用單引號包圍，單引號包圍的表示它的二進位制值轉換成十進位制的數值。例如字母對應的是ASCII碼。這個在前面byte型別中介紹過。所以，使用單引號包圍的字元實際上是整數數值。例如'a'等價於97。

string的底層是byte陣列，每個string其實只佔用兩個機器字長：一個指標和一個長度。只不過這個指標在Go中完全不可見，所以對我們來說，string是一個底層byte陣列的值型別而非指標型別。

所以，可以將一個string使用append()或copy()拷貝到一個給定的byte slice中，也可以使用slice的切片功能擷取string中的片段。

func main() {
	var a = "Hello Gaoxiaofang"
	println(a[2:3])      // 輸出：l

	s1 := make([]byte,30)
	copy(s1,a)          // 將字串儲存到slice中
	println(string(s1)) // 輸出"Hello Gaoxiaofang"
}

字串串接

使用加號+連線兩段字串："Hello" + "World"等價於"HelloWorld"。

可以通過+的方式將多行連線起來。例如：

str := "Beginning string "+
       "second string"

字串連線+操作符強制認為它兩邊的都是string型別，所以"abcd" + 2將報錯。需要先將int型別的2轉換為字串型別(不能使用string(2)的方式轉換，因為這種轉換方式不能跨大型別轉換，只能使用strconv包中的函數轉換)。

另一種更高效的字串串接方式是使用strings包中的Join()函數，它可以在緩衝中將字串串接起來。

字串長度

使用len()取位元組數量(不是字元數量)。

例如len("abcde")返回5，size(我是中國人)返回15。

字串擷取

可以將字串當作陣列，使用索引號取部分字串(按位元組計算)，索引號從0開始計算，如"abcd"[1]。

從字串取字元的時候，需要注意的是index按位元組計算而非按字元計算。兩種取資料方式：

"string"[x]
"string"[x:y]

第一種方式將返回第(x+1)個位元組對應字元的二進位制數值，例如字母將轉換為ASCII碼，unicode將取對應位元組的二進位制轉換為數值。

第二種方式將返回第(x+1)位元組到第y位元組中間的字元，Go中採取"左閉右開"的方式，所以所擷取部分包括index=x，但不包括index=y。

例如：

func main() {
    println("abcde"[1])          // (1).輸出"98"
    println("我是中國人"[1])       // (2).輸出"136"
    println("abcde"[0:2])        // (3).輸出"ab"
    println("我是中國人"[0:3])     // (4).輸出"我"
    println("abcde"[3:4])        // (5).輸出"d"
}

分析每一行語句：

(1).取第2個位元組的二進位制值，即字元b對應的值，其ASCII為98
(2).取第2個位元組的二進位制值，因為中文佔用3個位元組，所以取第一個字元"我"的第二個位元組部分，轉換為二進位制值，為136
(3).取第1個位元組到第3個位元組(不包括)中間的字元，所以輸出"ab"
(4).取前三個位元組對應的字元，所以輸出"我"
(5).取第4個位元組對應的字元，所以輸出d

字串遍歷

字串是字元陣列，如果字串中全是ASCII字元，直接遍歷即可，但如果包含了多位元組字元，則可以[]rune(str)轉換後後再遍歷。

package main

import "fmt"

func main() {
	str := "Hello 你好"
	r := []rune(str)  // 8
	for i := 0; i < len(r); i++ {
		fmt.Printf("%c", r[i])
	}
}

字串比較

可以使用< <= > >= == !=對字串進行比較，它將一個字元一個字元地比對。字母以A-Za-z的ASCII方式排列。

// 字串比較
println("a" < "B")  // false

// 數值比較，不是字串比較
println('a' == 97)  // true

修改字串

字串是一個不可變物件，所以對字串s擷取後賦值的方式s[1]="c"會報錯。

要想修改字串中的字元，必須先將字串拷貝到一個byte slice中，然後修改指定索引位置的字元，最後將byte slice轉換回string型別。

例如，將"gaoxiaofang"改為"maoxiaofang"：

s := "gaoxiaofang"
bs := []byte(s)
bs[0] = 'm'     // 必須使用單引號
s = string(bs)
println(s)

注意修改字元的時候，必須使用單引號，因為它是byte型別。

布林型別(bool)

bool型別的值只有兩種：true和false。

有3種布林運算運運算元：&& || !，分別別是邏輯與，邏輯或，取反。

func main() {
    println(true && true)    // true
    println(true && false)   // false
    println(true || true)    // true
    println(true || false)   // true
    println(!true)           // false
}

Go是一門非常嚴格的怨言，在使用==進行等值比較的時候，要求兩邊的資料型別必須相同，否則報錯。如果兩邊資料型別是介面型別，則它們必須實現相同的介面函數。如果是常數比較，則兩邊必須是能夠相容的資料型別。

在printf類的函數的格式中，預留位置%t用於代表布林值。

布林型別的變數、函數名應該以is或Is的方式開頭來表明這是一個布林型別的東西。例如isSorted()函數用於檢測內容是否已經排序，IsFinished()用於判斷是否完成。

type關鍵字：型別別名

可以使用type定義自己的資料型別，例如struct、interface。

還可以使用type定義型別的別名。例如，定義一個int型別的別名INT：

type INT int

這樣INT型別的底層資料結構還是int型別。可以將它和int一樣使用：

var a INT = 5

type中可以一次性宣告多個別名：

type (
    CT int
    IT int32
    DT float32
)

獲取資料型別

reflect包的TypeOf()，或者Printf/Sprintf的"%T"。

package main

import (
	"reflect"
	"fmt"
)

type IT int32
func main() {
	var a IT = 322
	var b = 22
	fmt.Println(reflect.TypeOf(a))   // main.IT
	fmt.Println(reflect.TypeOf(b))   // int
	fmt.Println(fmt.Sprintf("%T", a)) // main.IT
}

資料型別的大小

unsafe包的Sizeof()檢視變數或常數所屬資料型別佔用空間的大小。

package main

import (
	"unsafe"
	"fmt"
)

type IT int32
func main() {
	var a IT = 322
	var b = 22
	fmt.Println(unsafe.Sizeof(a)) // 4
	fmt.Println(unsafe.Sizeof(b)) // 8
}

更多關於Go語言的資料型別請檢視下面的相關連結