資料型別: 資料型別有哪些？

Swenson1992發表於2021-02-01
資料型別

變數宣告

變數代表可變的資料型別，也就是說，它在程式執行的過程中可能會被一次甚至多次修改。

在 Go 語言中，通過 var 宣告語句來定義一個變數，定義的時候需要指定這個變數的型別，然後再為它起個名字，並且設定好變數的初始值。所以 var 宣告一個變數的格式如下：

var 變數名 型別 = 表示式

現在通過一個示例來演示如何定義一個變數，並且設定它的初始值：
main.go

package main
import "fmt"
func main() {
    var i int = 10
    fmt.Println(i)
}

觀察上面例子中 main 函式的內容，其中 var i int = 10 就是定義一個型別為 int（整數）、變數名為 i 的變數，它的初始值為 10

這裡為了執行程式，加了一行 fmt.Println(i)列印出變數 i 的值。

這樣做一方面是因為 Go 語言中定義的變數必須使用，否則無法編譯通過，這也是 Go 語言比較好的特性，防止定義了變數不使用，導致浪費記憶體的情況；另一方面，在執行程式的時候可以檢視變數 i 的結果。

通過輸入 go run main.go 命令回車執行，即可看到如下結果：

$ go run main.go
10

列印的結果是10，和變數的初始值一樣。

因為 Go 語言具有型別推導功能，所以也可以不去刻意地指定變數的型別，而是讓 Go 語言自己推導，比如變數 i 也可以用如下的方式宣告：

var i = 10

這樣變數 i 的型別預設是 int 型別。

你也可以一次宣告多個變數，把要宣告的多個變數放到一個括號中即可，如下面的程式碼所示：

var (
    j int= 0
    k int= 1
)

同理因為型別推導，以上多個變數宣告也可以用以下程式碼的方式書寫：

var (
    j = 0
    k = 1
)

這樣就更簡潔了。

其實不止 int 型別，還有 float64、bool、string 等基礎型別都可以被自動推導，也就是可以省略定義型別。

基礎型別

任何一門語言都有對應的基礎型別，這些基礎型別和現實中的事物一一對應，比如整型對應著 1、2、3、100 這些整數，浮點型對應著 1.1、3.4 這些小數等。Go 語言也不例外，它也有自己豐富的基礎型別，常用的有：整型、浮點數、布林型和字串。

整型

在 Go 語言中，整型分為：

有符號整型：如 int、int8、int16、int32 和 int64。

無符號整型：如 uint、uint8、uint16、uint32 和 uint64。

它們的差別在於，有符號整型表示的數值可以為負數、零和正數，而無符號整型只能為零和正數。

除了有用“位”（bit）大小表示的整型外，還有 int 和 uint 這兩個沒有具體 bit 大小的整型，它們的大小可能是 32bit，也可能是 64bit，和硬體裝置 CPU 有關。

在整型中，如果能確定 int 的 bit 就選擇比較明確的 int 型別，因為這會讓你的程式具備很好的移植性。

在 Go 語言中，還有一種位元組型別 byte，它其實等價於 uint8 型別，可以理解為 uint8 型別的別名，用於定義一個位元組，所以位元組 byte 型別也屬於整型。

浮點數

浮點數就代表現實中的小數。Go 語言提供了兩種精度的浮點數，分別是 float32 和 float64。專案中最常用的是 float64，因為它的精度高，浮點計算的結果相比 float32 誤差會更小。

下面的程式碼示例定義了兩個變數 f32 和 f64，它們的型別分別為 float32 和 float64。

var f32 float32 = 2.2
var f64 float64 = 10.3456
fmt.Println("f32 is",f32,",f64 is",f64)

執行這段程式，會看到如下結果：

$ go run main.go
f32 is 2.2 ,f64 is 10.3456

布林型

一個布林型的值只有兩種：true 和 false，它們代表現實中的“是”和“否”。它們的值會經常被用於一些判斷中，比如 if 語句等。Go 語言中的布林型使用關鍵字 bool 定義。

下面的程式碼宣告瞭兩個變數，你可以自己執行，看看列印輸出的結果。
main.go

var bf bool =false
var bt bool = true
fmt.Println("bf is",bf,",bt is",bt)

布林值可以用於一元操作符 !，表示邏輯非的意思，也可以用於二元操作符 &&、||，它們分別表示邏輯和、邏輯或。

字串

Go 語言中的字串可以表示為任意的資料，比如以下程式碼，在 Go 語言中，字串通過型別 string 宣告：

var s1 string = "Hello"
var s2 string = "Golang"
fmt.Println("s1 is",s1,",s2 is",s2)

執行程式就可以看到列印的字串結果。

$ go run main.go
s1 is Hello,s2 is Golang

在 Go 語言中，可以通過操作符 + 把字串連線起來，得到一個新的字串，比如將上面的 s1 和 s2 連線起來，如下所示：

fmt.Println("s1+s2=",s1+s2)

由於 s1 表示字串“Hello”，s2 表示字串“Golang”，在終端輸入 go run main.go 後，就可以列印出它們連線起來的結果“HelloGolang”，如以下程式碼所示：

s1+s2=HelloGolang

字串也可以通過 += 運算子操作，可以試試 s1+=s2 會得到什麼新的字串。

零值

零值其實就是一個變數的預設值，在 Go 語言中，如果我們宣告瞭一個變數，但是沒有對其進行初始化，那麼 Go 語言會自動初始化其值為對應型別的零值。比如數字類的零值是 0，布林型的零值是 false，字串的零值是 “” 空字串等。

通過下面的程式碼示例，就可以驗證這些基礎型別的零值：

var zi int
var zf float64
var zb bool
var zs string
fmt.Println(zi,zf,zb,zs)

變數

變數簡短宣告

上面示例都有一個 var 關鍵字，但是這樣寫程式碼很煩瑣。藉助型別推導，Go 語言提供了變數的簡短宣告 :=，結構如下：

變數名:=表示式

藉助 Go 語言簡短宣告功能，變數宣告就會非常簡潔，比如以上示例中的變數，可以通過如下程式碼簡短宣告：

i:=10
bf:=false
s1:="Hello"

在實際的專案實戰中，如果你能為宣告的變數初始化，那麼就選擇簡短宣告方式，這種方式也是使用最多的。

指標

在 Go 語言中，指標對應的是變數在記憶體中的儲存位置，也就說指標的值就是變數的記憶體地址。通過 & 可以獲取一個變數的地址，也就是指標。

在以下的程式碼中，pi 就是指向變數 i 的指標。要想獲得指標 pi 指向的變數值，通過*pi這個表示式即可。嘗試執行這段程式，會看到輸出結果和變數 i 的值一樣。

pi:=&i
fmt.Println(*pi)

賦值

變數是可以修改的，那麼怎麼修改呢？這就是賦值語句要做的事情。最常用也是最簡單的賦值語句就是 =，如下程式碼所示：

i = 20
fmt.Println("i的新值是",i)

這樣變數 i 就被修改了，它的新值是 20。

常量

一門程式語言，有變數就有常量，Go 語言也不例外。在程式中，常量的值是指在編譯期就確定好的，一旦確定好之後就不能被修改，這樣就可以防止在執行期被惡意篡改。

常量的定義

常量的定義和變數類似，只不過它的關鍵字是 const。

下面的示例定義了一個常量 name，它的值是“Golang”。因為 Go 語言可以型別推導，所以在常量宣告時也可以省略型別。

const name = "Golang"

在 Go 語言中，只允許布林型、字串、數字型別這些基礎型別作為常量。

iota

iota 是一個常量生成器，它可以用來初始化相似規則的常量，避免重複的初始化。假設我們要定義 one、two、three 和 four 四個常量，對應的值分別是 1、2、3 和 4，如果不使用 iota，則需要按照如下程式碼的方式定義：

const(
    one = 1
    two = 2
    three =3
    four =4
)

以上宣告都要初始化，會比較煩瑣，因為這些常量是有規律的（連續的數字），所以可以使用 iota 進行宣告，如下所示：

const(
    one = iota+1
    two
    three
    four
)
fmt.Println(one,two,three,four)

執行程式，會發現列印的值和上面初始化的一樣，也是 1、2、3、4。

iota 的初始值是 0，它的能力就是在每一個有常量宣告的行後面 +1，下面來分解上面的常量：

  • one=(0)+1，這時候 iota 的值為 0，經過計算後，one 的值為 1。
  • two=(0+1)+1，這時候 iota 的值會 +1，變成了 1，經過計算後，two 的值為 2。
  • three=(0+1+1)+1，這時候 iota 的值會再 +1，變成了 2，經過計算後，three 的值為 3。
  • four=(0+1+1+1)+1，這時候 iota 的值會繼續再 +1，變成了 3，經過計算後，four 的值為 4。

如果你定義更多的常量，就依次類推，其中 () 內的表示式，表示 iota 自身 +1 的過程。

字串

字串是 Go 語言中常用的型別

字串和數字互轉

Go 語言是強型別的語言，也就是說不同型別的變數是無法相互使用和計算的，這也是為了保證Go 程式的健壯性，所以不同型別的變數在進行賦值或者計算前，需要先進行型別轉換。涉及型別轉換的知識點非常多，這裡先介紹這些基礎型別之間的轉換。

以字串和數字互轉這種最常見的情況為例，如下面的程式碼所示：

i2s:=strconv.Itoa(i)
s2i,err:=strconv.Atoi(i2s)
fmt.Println(i2s,s2i,err)

通過包 strconv 的 Itoa 函式可以把一個 int 型別轉為 string，Atoi 函式則用來把 string 轉為 int。

同理對於浮點數、布林型，Go 語言提供了 strconv.ParseFloat、strconv.ParseBool、strconv.FormatFloat 和 strconv.FormatBool 進行互轉，你可以自己試試。

對於數字型別之間，可以通過強制轉換的方式，如以下程式碼所示：

i2f:=float64(i)
f2i:=int(f64)
fmt.Println(i2f,f2i)

這種使用方式比簡單，採用“型別（要轉換的變數）”格式即可。採用強制轉換的方式轉換數字型別，可能會丟失一些精度，比如浮點型轉為整型時，小數點部分會全部丟失。

把變數轉換為相應的型別後，就可以對相同型別的變數進行各種表示式運算和賦值了。

Strings 包

講到基礎型別，尤其是字串，不得不提 Go SDK 為我們提供的一個標準包 strings。它是用於處理字串的工具包，裡面有很多常用的函式，幫助我們對字串進行操作，比如查詢字串、去除字串的空格、拆分字串、判斷字串是否有某個字首或者字尾等。掌握好它，有利於我們的高效程式設計。

以下程式碼是我寫的關於 strings 包的一些例子，你自己可以根據strings 文件自己寫一些示例，多練習熟悉它們。

//判斷s1的字首是否是H
fmt.Println(strings.HasPrefix(s1,"H"))
//在s1中查詢字串o
fmt.Println(strings.Index(s1,"o"))
//把s1全部轉為大寫
fmt.Println(strings.ToUpper(s1))
本作品採用《CC 協議》，轉載必須註明作者和本文連結
?

相關文章