我的Go+語言初體驗——（3）Go+ 語言數據類型

“我的Go+語言初體驗” | 征文活動進行中…

Go+ 語言剛剛發布，網絡上還很難找到各種的支持文檔和編程指南，使初學者很難深入地進行學習。
本文結合官方文檔與 Go 語言的技術資料，介紹 Go+ 數據類型與基本運算符。全文內容已在 Go+ 環境下進行了測試。

1. Go+ 基本數據類型

數據類型是程序設計中重要的基本概念。在程序設計語言中，采用數據類型來描述程序中的數據結構、數據范圍和數據在內存中的存儲分配。

Go+ 對于數據類型有嚴格的定義，相同類型的值才能進行比較，兼容類型的值才能進行運算。

• 如果值的類型是接口（interface），必須實現相同的接口。
• 如果一個值是常量，那么另一個值必須與該常量的類型兼容。

1.1 布爾類型

布爾型的值只能是常量 true 或者 false。未初始化的布爾變量的初值為 false。

布爾型無法參與數值運算，也無法與其他類型進行轉換。

【例程 1】

var v1 bool = true

1.2 數字類型

Go+ 語言支持整型和浮點型數字，數字類型包括：整型 int 和浮點型 float32、float64。

Go+ 語言引入了有理數類型，用后綴 “r” 表示有理數，可以支持大整數運算，包括：bigint、bigrat、bigfloat。

例如： (1r << 200) 表示 bigint ，其值等于 2 的 65 次冪；4/5r 表示有理常數 4/5。

// 有符號整數 int8 (-128 ~ 127) int16 (-32768 ~ 32767) int32 (-2,147,483,648 ~ 2,147,483,647) int64 (-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807) int (32位操作系統上 32 位，64位操作系統 64 位)// 無符號整數 uint8 (0 ~ 255) uint16 (0 ~ 65,535) uint32 (0 ~ 4,294,967,295) uint64 (0 ~ 18,446,744,073,709,551,615) uint (32位操作系統上 32 位，64位操作系統 64 位)// 浮點型 float32 (+/- 1e-45 ~ +/- 3.4*1e38) float64 (+/- 5*1e-324 ~ +/- 107*1e308）// 復數，用 "re+im I" 表示 complex64 (32 位實數和虛數) complex128 (64 位實數和虛數)// 有理數，用后綴 "r" 表示 bigint // 有理數整數 bigrat //有理數分數 bigfloat //有理數浮點數

Go+ 語言使用 var 關鍵字進行變量聲明。

【例程 2】

package main import "fmt"func main() {// 變量聲明和初始化var v1 int = -1 //聲明一個整型變量 v1var v2 uint = 10 //聲明一個無符號整型變量 v2var v3 float64 = 3.14 //聲明一個浮點型變量 v3var v4 complex64 = -1.0 + 3.14i //聲明一個復數變量 v4var v5 bigint = 1r << 65 // 聲明一個有理數變量 v5var v6 bigrat = 4/5r // 聲明一個有理數變量 v6// 輸出fmt.Println("整型變量 v1: ", v1)fmt.Println("無符號整型變量 v2: ", v2)fmt.Println("浮點型變量 v3: ", v3)fmt.Println("復數變量 v4: ", v4)fmt.Println("有理數變量 v5: ", v5)fmt.Println("有理數變量 v6: ", v6) }

程序運行結果：

整型變量 v1: -1
無符號整型變量 v2: 10
浮點型變量 v3: 3.14
復數變量 v4: (-1+3.14i)
有理數變量 v5: 36893488147419103232
有理數變量 v6: 4/5

1.3 字符類型

Go+ 語言的字符類型包括： byte 類型（uint8 類型）和 rune 類型（int32 類型）。

uint8 類型（ byte 類型）用 “\x” + 2位16進制數表示，表示 ASCII 碼字符；rune 類型用"\u" + 4位16進制數表示，表示 UTF-8 碼字符，可以處理中文、日文或復合字符。

【例程 3】

package main import "fmt"func main() {// 變量聲明和初始化var ch1 byte = '\x4C' // "\x" + 2位16進制數表示var ch2 uint = 36 // 等價于 ASCII 數字var ch3 rune = '\u004C' // "\u" + 4位16進制數表示var ch4 int32 = '\u03B3'var ch5 int = '\U00101024'// 輸出fmt.Printf("%d - %d\n", ch1, ch2) // integerfmt.Printf("%c - %c\n", ch1, ch2) // characterfmt.Printf("%d - %d - %d\n", ch3, ch4, ch5) // integerfmt.Printf("%c - %c - %c\n", ch3, ch4, ch5) // characterfmt.Printf("%X - %X - %X\n", ch3, ch4, ch5) // UTF-8 bytesfmt.Printf("%U - %U - %U", ch3, ch4, ch5) // UTF-8 code point }

程序運行結果：

76 - 36
L - $
76 - 947 - 1052708
L - γ - 􁀤
4C - 3B3 - 101024
U+004C - U+03B3 - U+101024

1.4 字符串類型

字符串是一串固定長度的字符連接而成的字符序列。

字符串的值是用雙引號中 ” ” 包括的內容，多行字符串使用反括號 ``表示。

【例程 4】

package main import "fmt"func main() {// 變量聲明和初始化var s1 string = "hello Go+!"var s2 string = "你好"var s3 string = ` Line 1 Line 2 Line 3`// 輸出fmt.Printf("%s\n", s1)fmt.Printf("%s\n", s2)fmt.Printf("%s\n", s3) }

程序運行結果：

hello Go+!
你好

Line 1
Line 2
Line 3

---

2. Go+ 擴展數據類型

2.1 指針類型

Go+ 語言的指針類型和 C/C++的指針類型用法相同，使用 “&(普通變量)” 對普通變量取內存地址后，得到指針變量，其類型為 *T，即 T 的指針類型。

針對 C/C++ 在指針運算和內存釋放上的問題，Go+ 語言對指針增加了一些限制：

• 不同類型的指針不能互相轉換，例如 int, int32 與 int64 類型的指針不能互相轉換
• 任何普通指針類型 *T和 uintptr 之間不能互相轉換
• 指針變量不能進行運算，例如不能對指針進行 ++, – 操作

【例程 5】

package main import "fmt"func main() {// 定義指針變量vint := 1 // 定義普通變量ptr := &vint // 定義指針變量fmt.Println("普通變量 vint：", vint)fmt.Println("普通變量 *ptr：", *ptr)fmt.Println("指針變量 &vint：", &vint)fmt.Println("指針變量 ptr：", ptr)vstr := "hello Go+"vbool := falsevrune := 'y'vfloat := 3.14fmt.Printf("vstr 的指針類型：%T\n", &vstr)fmt.Printf("vint 指針類型是：%T\n", &vint)fmt.Printf("vbool 指針類型是：%T\n", &vbool)fmt.Printf("vrune 指針類型是：%T\n", &vrune)fmt.Printf("vfloat 指針類型是：%T\n", &vfloat)// 空指針var p *stringfmt.Println(p)fmt.Printf("p的值是: %v\n", p) }

程序運行結果：

普通變量 vint： 1
普通變量 *ptr： 1
指針變量 &vint： 0xc00000a088
指針變量 ptr： 0xc00000a088
vstr 的指針類型：*string
vint 指針類型是：*int
vbool 指針類型是：*bool
vrune 指針類型是：*int32
vfloat 指針類型是：*float64
<nil>
p的值是: <nil>

2.2 數組類型

數組是一系列同一類型數據的集合。數組也是一種數據類型，在 Go+ 語言中數組是值類型。

在 Go+ 語言中，數組類型由元素類型和數組長度兩部分組成，數組長度在定義后不可更改。

數組類型定義的基本語法如下：

var 數組名 [數組大小]值的數據類型

【例程 6】

package main import "fmt"func main() {// 數組聲明var arrayBytes [10]byte // 聲明長度為5的數組，每個元素為一個字節；var arrayPointer [2]*int // 指針數組var array2Dimensional [2][3]int // 二維數組var array3Dimensional [2][3][4]int // 三維數組，等同于[2]([3]([4]int))var arrayString [5]string // 字符串數組var arrayDynamic = [...]int{1, 2, 3, 4} // 動態數組聲明時需要賦值fmt.Println(arrayBytes) // [0 0 0 0 0 0 0 0 0 0]fmt.Println(arrayPointer) // [<nil> <nil>]fmt.Println(array2Dimensional) // [[0 0 0] [0 0 0]]fmt.Println(array3Dimensional) // [[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]fmt.Println(arrayString) // [ ]fmt.Println(arrayDynamic) // [1 2 3 4] }

程序運行結果：

[0 0 0 0 0 0 0 0 0 0]
[<nil> <nil>]
[[0 0 0] [0 0 0]]
[[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]
[ ]
[1 2 3 4]

2.3 切片類型

切片是 Go+ 中的數據類型，切片是基于數組類型的抽象，其長度可以改變，也稱為可變數組。

切片類型定義的基本語法如下：

var 類型名[]值的數據類型

切片的原型為：

type Slice struct { base *elemType // 指向0th元素的指針 len int // 切片中元素的數量 cap int // 切片可以容納元素的數量 }

【例程 7】

func main() {// 切片類型var slice []int // 定義 int 類型切片slice = make([]int, 5) // 初始化切片，切片長度為5slice[0] = 9 // 向切片元素賦值var slice2 = []int{1, 2, 3, 4, 5} // 定義 int 類型切片并賦值var v [10]int // 定義int類型長度為 10 的數組var slice3 []int = v[2:5] // 將數組 v 中的 2:5 元素賦值給切片array := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}slice4 := array[1:5] //[]int{1,2,3,4}slice5 := slice4[4:7] //[]int{6,7,8}fmt.Println(slice) // [9 0 0 0 0]fmt.Println(slice2) // [1 2 3 4 5]fmt.Println(slice3) // [0 0 0]fmt.Printf("slice4:%v,len:%d,cap:%d\n", slice4, len(slice4), cap(slice4)) // slice4:[2 3 4 5],len:4,cap:9fmt.Printf("slice5:%v,len:%d,cap:%d\n", slice5, len(slice5), cap(slice5)) // slice5:[6 7 8],len:3,cap:5 }

程序運行結果：

[9 0 0 0 0]
[1 2 3 4 5]
[0 0 0]
slice4:[2 3 4 5],len:4,cap:9
slice5:[6 7 8],len:3,cap:5

2.4 字典類型（map）

字典類型是由若干個 key:value 鍵值對組合形成的數據類型，key 和 value 可以有各自的數據類型。

字典類型的變量要經過初始化后才能賦值。

字典類型使用 map 關鍵字來聲明，字典類型定義的基本語法如下：

var 類型名 map[key的數據類型]value的數據類型

【例程 8】

package main import "fmt"func main() {// 字典類型var scores1 map[string]int = map[string]int{"student1": 90, "student2": 80}scores2 := map[string]int{"student1": 90, "student2": 80}scores3 := make(map[string]int)scores3["student1"] = 80scores3["student2"] = 85var scores4 map[string]int // 聲明字典類型 scoresscores4 = make(map[string]int) // 初始化字典scores4["student1"] = 90fmt.Println(scores1) // map[student1:90 student2:80]fmt.Println(scores2) // map[student1:90 student2:80]fmt.Println(scores3) // map[student1:90 student2:80]fmt.Println(scores4) // map[student1:90] }

程序運行結果：

map[student1:90 student2:80]
map[student1:90 student2:80]
map[student1:90 student2:80]
map[student1:90]

2.5 結構體類型（struct）

與 C/C++ 語言類似，在 Go+ 語言中可以聲明新的結構體類型，作為其它類型的屬性或字段的容器。

結構體是由一系列具有相同類型或不同類型的數據構成的數據集合。結構體類型是由一些列屬性組成的復合數據類型 ，每個屬性都具有名稱、類型和值，結構體將屬性組合在一起進行由程序進行處理。

結構體定義使用 type 和 struct 關鍵字來聲明，需要指定其包含的屬性（名和類型）。結構體類型定義的基本語法如下：

type 類型名 struct {

字段1 類型1

字段2 類型2

… }

其中 “類型名” 標識自定義結構體的名稱，“字段1…” 表示結構體中的字段名，“類型1…” 表示結構體中的各個字段的類型。 同一個包內的類型名不能重復，一個結構體中的字段名不能重復。

在定義結構體時可以為結構體指定結構體名（命名結構體），用于后續聲明結構體變量使用。

【例程 9】

package main import "fmt" type Book struct {title stringauthor stringpress stringprice float64 }func main() {var book1 Book // 初始化一個 Boook 實例, book1 是一本具體的書(Object)fmt.Println("book1: ", book1) // {title: author: press: price}book1 = Book{"Go+語言", "author", "GoPress", 80.0}fmt.Println("book1: ", book1) // {Go+語言 author GoPress 80}var book2 Book = Book{title: "C語言程序設計",author: "譚浩強",press: "高等教育出版社",price: 50.0, // 最后一個逗號","不能省略}fmt.Println("book2: ", book2) // {C語言程序設計 譚浩強 高等教育出版社 50}fmt.Println("book3: ", Book{title: "Go+ Programming Language", press: "IT Press"})// {Go+ Programming Language IT Press 0}, 缺少的字段為 0 或 空 }

程序運行結果：

book1: { 0}
book1: {Go+語言 author GoPress 80}
book2: {C語言程序設計 譚浩強 高等教育出版社 50}
book3: {Go+ Programming Language IT Press 0}

2.6 接口類型（interface）

接口類型是 Go語言的一種數據類型。 接口類型是其它類型行為的概括與抽象， 它把所有的具有共性的方法定義在一起，任何其它類型只要實現了這些方法就是實現了這個接口。

接口是用來定義行為的類型。這些被定義的行為不由接口直接實現，而是由用戶定義的類型實現，一個實現了這些方法的具體類型是這個接口類型的實例。

接口類型使用 type 和 interface 關鍵字來聲明。接口類型定義的基本語法如下：

/* 定義接口 */ type interface_name interface { method_name1 [return_type] ... method_namen [return_type] } /* 定義結構體 */ type struct_name struct { /* variables */ } /* 實現接口方法 */ func (struct_name_variable struct_name) method_name1() [return_type] { /* 方法實現 */ } ... func (struct_name_variable struct_name) method_namen() [return_type] { /* 方法實現*/ }

2.7 nil 類型

任何類型的變量在初始化前都對應一個初值：布爾類型的初值為 false，整型的初值為 0，字符串類型的初值為""，而指針、數組、切片、字典、結構體和接口類型的初值都是 nil。

---

3. 總結

本文結合官方文檔與 Go 語言的技術資料，介紹 Go+ 數據類型與基本運算符。

本文的大部分內容參考 Go 語言教程進行整理。全文內容和例程都已在 Go+ 環境下進行調試和運行測試。

【本節完】

版權聲明：

原創作品，轉載必須標注原文鏈接：(https://blog.csdn.net/youcans/article/details/121619284)

Copyright 2021 youcans, XUPT

Crated：2021-11-29

歡迎關注『我的Go+語言初體驗』系列，持續更新中…

我的Go+語言初體驗——（1）超詳細安裝教程
我的Go+語言初體驗——（2） IDE 詳細安裝教程
我的Go+語言初體驗——（3）Go+ 數據類型

“我的Go+語言初體驗” | 征文活動進行中…

總結

以上是生活随笔為你收集整理的我的Go+语言初体验——（3）Go+ 语言数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。