Golang通脈之數據類型詳情
1、標識符與關鍵字
在瞭解數據類型之前，先瞭解一下go的標識符和關鍵字
1.1 標識符
在編程語言中標識符就是定義的具有某種意義的詞，比如變量名、常量名、函數名等等。 Go語言中標識符允許由字母數字和_(下劃線）組成，並且隻能以字母和_開頭：abc , _ , _123, a123。
1.2 關鍵字
關鍵字是指語言預先定義好的具有特殊含義的標識符。 關鍵字和保留字都不建議用作變量名。
Go語言有25個關鍵字：
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
Go語言中有37個保留字
Constants: true false iota nil
Types: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions: make len cap new append copy close delete
complex real imag
panic recover
2、變量
2.1 什麼是變量
程序運行過程中的數據都是保存在內存中，想要在代碼中操作某個數據時就需要去內存上找到這個變量，但是如果直接在代碼中通過內存地址去操作變量的話，代碼的可讀性會非常差而且還容易出錯，所以就利用變量將這個數據的內存地址保存起來，以後直接通過這個變量就能找到內存上對應的數據瞭。
所以變量的本質就是一小塊內存，用於存儲數據，在程序運行過程中數值可以改變
變量是為存儲特定類型的值而提供給內存位置的名稱。在go中聲明變量有多種語法。
2.2 變量類型
變量（Variable）的功能是存儲數據。不同的變量保存的數據類型可能會不一樣。常見變量的數據類型有：整型、浮點型、佈爾型等。
Go語言中的每一個變量都有自己的類型，並且變量必須經過聲明才能開始使用。
2.3 變量聲明
Go語言中的變量需要聲明後才能使用，同一作用域內不支持重復聲明。 並且Go語言的變量聲明後必須使用，否則無法通過編譯。
標準聲明：
Go語言的變量聲明格式為：
var 變量名 變量類型
變量聲明以關鍵字var開頭，變量類型放在變量的後面，行尾無需分號：
var name string var age int var isTrue bool
批量聲明：
每聲明一個變量就需要寫var關鍵字會比較繁瑣，go語言中還支持批量變量聲明：
var (
a string
b int
c bool
d float32
)
變量的初始化：
Go語言在聲明變量的時候，會自動對變量對應的內存區域進行初始化操作。每個變量會被初始化成其類型的默認值，即零值，例如： 整型和浮點型變量的默認值為0。 字符串變量的默認值為空字符串。 佈爾型變量默認為false。 切片、函數、指針變量的默認為nil。
當然也可在聲明變量的時候為其指定初始值。變量初始化的標準格式如下：
var 變量名 類型 = 表達式 var name string = "golang" var age int = 18
或者一次初始化多個變量
var name, age = "golang", 20
類型推導：
有時候會將變量的類型省略，這個時候編譯器會根據等號右邊的值來推導變量的類型完成初始化。
var name = "golang" var age = 18
短變量聲明：
在函數內部，可以使用更簡略的 := 方式聲明並初始化變量。
// 全局變量m
var m = 100
func main() {
n := 10
m := 200 // 此處聲明局部變量m
fmt.Println(m, n)
}
匿名變量：
在使用多重賦值時，如果想要忽略某個值，可以使用匿名變量（anonymous variable）。 匿名變量用一個下劃線_表示，例如：
func foo() (int, string) {
return 10, "golang"
}
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
匿名變量不占用命名空間，不會分配內存，所以匿名變量之間不存在重復聲明。
註意事項：
- 函數外的每個語句都必須以關鍵字開始（
var、const、func等） :=不能使用在函數外，不能定義全局變量，並且左邊的變量名至少有一個是新的。- _多用於占位，表示忽略值。
- 變量必須先定義才能使用，定義瞭就一定要使用。
- 變量的類型和賦值的類型必須一致。
- 變量名在同一個作用於域內不能沖突。
3、常量
相對於變量，常量是恒定不變的值，多用於定義程序運行期間不會改變的那些值。 常量的聲明和變量聲明非常類似，隻是把var換成瞭const，常量在定義的時候必須賦值。
const pi = 3.1415 const e = 2.7182
聲明瞭pi和e這兩個常量之後，在整個程序運行期間它們的值都不能再發生變化瞭。
多個常量也可以一起聲明：
const (
pi = 3.1415
e = 2.7182
)
const同時聲明多個常量時，如果省略瞭值則表示和上面一行的值相同。 例如：
const (
n1 = 100
n2
n3
)
上面示例中，常量n1、n2、n3的值都是100。
常量可以作為枚舉，常量組
const (
Unknown = 0
Female = 1
Male = 2
)
常量組中如不指定類型和初始化值，則與上一行非空常量右值相同
func main() {
const (
x uint16 = 16
y
s = "abc"
z
)
fmt.Printf("%T,%v\n", y, y) //uint16,16
fmt.Printf("%T,%v\n", z, z) //string,abc
}
常量的註意事項：
- 常量中的數據類型隻可以是佈爾型、數字型（整數型、浮點型和復數）和字符串型
- 不曾使用的常量，在編譯的時候，是不會報錯的
- 顯示指定類型的時候，必須確保常量左右值類型一致，需要時可做顯示類型轉換。這與變量就不一樣瞭，變量是可以是不同的類型值
3.1 iota
iota是go語言的常量計數器，是特殊的常量，隻能在常量的表達式中使用。
iota在const關鍵字出現時將被重置為0。const中每新增一行常量聲明將使iota計數一次(iota可理解為const語句塊中的行索引)。 使用iota能簡化定義，在定義枚舉時很有用。
const ( n1 = iota //0 n2 //1 n3 //2 n4 //3 )
幾個常見的iota示例:
使用_跳過某些值
const ( n1 = iota //0 n2 //1 _ n4 //3 )
iota聲明中間插隊
const ( n1 = iota //0 n2 = 100 //100 n3 = iota //2 n4 //3 ) const n5 = iota //0
定義數量級 （這裡的<<表示左移操作，1<<10表示將1的二進制表示向左移10位，也就是由1變成瞭10000000000，也就是十進制的1024。同理2<<2表示將2的二進制表示向左移2位，也就是由10變成瞭1000，也就是十進制的8。）
const ( _ = iota KB = 1 << (10 * iota) MB = 1 << (10 * iota) GB = 1 << (10 * iota) TB = 1 << (10 * iota) PB = 1 << (10 * iota) )
多個iota定義在一行
const ( a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2 c, d //iota = 1、c = 2, d = 3 e, f //iota = 2、e = 3, f = 4 )
Go語言中有豐富的數據類型，除瞭基本的整型、浮點型、佈爾型、字符串外，還有數組、切片、結構體、函數、map、通道（channel）等。
4、基本數據類型
4.1 整型
整型分為以下兩個大類： 按長度分為：int8、int16、int32、int64 對應的無符號整型：uint8、uint16、uint32、uint64
其中，uint8就是byte型，int16對應C語言中的short型，int64對應C語言中的long型。
| 類型 | 描述 |
|---|---|
| uint8 | 無符號 8位整型 (0 到 255) |
| uint16 | 無符號 16位整型 (0 到 65535) |
| uint32 | 無符號 32位整型 (0 到 4294967295) |
| uint64 | 無符號 64位整型 (0 到 18446744073709551615) |
| int8 | 有符號 8位整型 (-128 到 127) |
| int16 | 有符號 16位整型 (-32768 到 32767) |
| int32 | 有符號 32位整型 (-2147483648 到 2147483647) |
| int64 | 有符號 64位整型 (-9223372036854775808 到 9223372036854775807) |
特殊整型：
| 類型 | 描述 |
|---|---|
| uint | 32位操作系統上就是uint32，64位操作系統上就是uint64 |
| int | 32位操作系統上就是int32，64位操作系統上就是int64 |
| uintptr | 無符號整型，用於存放一個指針 |
註意： 在使用int和 uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。除非需要使用特定大小的整數，否則通常應該使用int來表示整數。 大小:32位系統32位，64位系統64位。 范圍:-2147483648到2147483647的32位系統和-9223372036854775808到9223372036854775807的64位系統。
註意事項 獲取對象的長度的內建len()函數返回的長度可以根據不同平臺的字節長度進行變化。實際使用中，切片或 map 的元素數量等都可以用int來表示。在涉及到二進制傳輸、讀寫文件的結構描述時，為瞭保持文件的結構不會受到不同編譯目標平臺字節長度的影響，不要使用int和 uint。
數字字面量語法（Number literals syntax）
Go1.13版本之後引入瞭數字字面量語法，這樣便於開發者以二進制、八進制或十六進制浮點數的格式定義數字，例如：
v := 0b00101101， 代表二進制的 101101，相當於十進制的 45。 v := 0o377，代表八進制的 377，相當於十進制的 255。 v := 0x1p-2，代表十六進制的 1 除以 2²，也就是 0.25。
而且還允許用 _ 來分隔數字，比如說： v := 123_456 表示 v 的值等於 123456。
將一個整數以不同進制形式展示：
func main(){
// 十進制
var a int = 10
fmt.Printf("%d \n", a) // 10
fmt.Printf("%b \n", a) // 1010 占位符%b表示二進制
// 八進制 以0開頭
var b int = 077
fmt.Printf("%o \n", b) // 77
// 十六進制 以0x開頭
var c int = 0xff
fmt.Printf("%x \n", c) // ff
fmt.Printf("%X \n", c) // FF
}
4.2 浮點型
Go語言支持兩種浮點型數：float32和float64。這兩種浮點型數據格式遵循IEEE 754標準： float32 的浮點數的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數的最大范圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。
打印浮點數時，可以使用fmt包配合動詞%f：
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}
4.3 復數
complex64和complex128
var c1 complex64 c1 = 1 + 2i var c2 complex128 c2 = 2 + 3i fmt.Println(c1) fmt.Println(c2)
復數有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。
4.4 佈爾值
Go語言中以bool類型進行聲明佈爾型數據，佈爾型數據隻有true（真）和false（假）兩個值。
註意：
- 佈爾類型變量的默認值為
false。 - 不允許將整型強制轉換為佈爾型.
- 佈爾型無法參與數值運算，也無法與其他類型進行轉換。
4.5 字符串
Go語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣。字符串的內部實現使用UTF-8編碼。 字符串的值為雙引號(“)中的內容，可以在源碼中直接添加非ASCII碼字符：
s1 := "hello" s2 := "你好"
字符串轉義符：
Go 語言的字符串常見轉義符包含回車、換行、單雙引號、制表符等，如下表所示。
| 轉義符 | 含義 |
|---|---|
| \r | 回車符（返回行首） |
| \n | 換行符（直接跳到下一行的同列位置） |
| \t | 制表符 |
| \’ | 單引號 |
| \” | 雙引號 |
| \\ | 反斜杠 |
打印一個Windows平臺下的一個文件路徑：
func main() {
fmt.Println("str := \"d:\\go\\go.exe\"")
}
多行字符串：
定義一個多行字符串時，就必須使用反引號字符：
s1 := `第一行 第二行 第三行 ` fmt.Println(s1)
反引號間換行將被作為字符串中的換行，但是所有的轉義字符均無效，文本將會原樣輸出。
字符串的常用操作：
| 介紹 | 方法 |
|---|---|
| 求長度 | len(str) |
| 拼接字符串 | +或fmt.Sprintf |
| 分割 | strings.Split |
| 判斷是否包含 | strings.contains |
| 前綴/後綴判斷 | strings.HasPrefix,strings.HasSuffix |
| 子串出現的位置 | strings.Index(),strings.LastIndex() |
| join操作 | strings.Join(a[]string, sep string) |
4.6 byte和rune類型
組成每個字符串的元素叫做“字符”，可以通過遍歷或者單個獲取字符串元素獲得字符。 字符用單引號（’）包裹起來，如：
var a := '中' var b := 'x'
Go 語言的字符有以下兩種：
- uint8類型，或者叫 byte 型，代表瞭ASCII碼的一個字符。
- rune類型，代表一個 UTF-8字符。
當需要處理中文、日文或者其他復合字符時，則需要用到rune類型。rune類型實際是一個int32。
Go 使用瞭特殊的 rune 類型來處理 Unicode，讓基於 Unicode 的文本處理更為方便，也可以使用 byte 型進行默認字符串處理，性能和擴展性都有照顧。
因為UTF8編碼下一個中文漢字由3~4個字節組成，所以不能簡單的按照字節去遍歷一個包含中文的字符串
字符串底層是一個byte數組，所以可以和[]byte類型相互轉換。字符串是不能修改的 字符串是由byte字節組成，所以字符串的長度是byte字節的長度。 rune類型用來表示utf8字符，一個rune字符由一個或多個byte組成。
修改字符串：
要修改字符串，需要先將其轉換成[]rune或[]byte，完成後再轉換為string。無論哪種轉換，都會重新分配內存，並復制字節數組。
func changeString() {
s1 := "big"
// 強制類型轉換
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
s2 := "白蘿卜"
runeS2 := []rune(s2)
runeS2[0] = '紅'
fmt.Println(string(runeS2))
}
4.7 類型轉換
Go語言中隻有強制類型轉換，沒有隱式類型轉換。該語法隻能在兩個類型之間支持相互轉換的時候使用。
強制類型轉換的基本語法如下：
T(表達式)
其中，T表示要轉換的類型。表達式包括變量、復雜算子和函數返回值等.
func sqrtDemo() {
var a, b = 3, 4
var c int
// math.Sqrt()接收的參數是float64類型，需要強制轉換
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)
}
運算符用於在程序運行時執行數學或邏輯運算。
5、運算符
Go 語言內置的運算符有：
- 算術運算符
- 關系運算符
- 邏輯運算符
- 位運算符
- 賦值運算符
5.1 算數運算符
| 運算符 | 描述 |
|---|---|
| + | 相加 |
| – | 相減 |
| * | 相乘 |
| / | 相除 |
| % | 求餘 |
註意： ++ （自增）和--（自減）在Go語言中是單獨的語句，並不是運算符。
5.2 關系運算符
| 運算符 | 描述 |
|---|---|
| == | 檢查兩個值是否相等，如果相等返回 True 否則返回 False。 |
| != | 檢查兩個值是否不相等，如果不相等返回 True 否則返回 False。 |
| > | 檢查左邊值是否大於右邊值，如果是返回 True 否則返回 False。 |
| >= | 檢查左邊值是否大於等於右邊值，如果是返回 True 否則返回 False。 |
| < | 檢查左邊值是否小於右邊值，如果是返回 True 否則返回 False。 |
| <= | 檢查左邊值是否小於等於右邊值，如果是返回 True 否則返回 False。 |
5.3 邏輯運算符
| 運算符 | 描述 |
|---|---|
| && | 邏輯 AND 運算符。 如果兩邊的操作數都是 True，則為 True，否則為 False。 |
| || | 邏輯 OR 運算符。 如果兩邊的操作數有一個 True，則為 True，否則為 False。 |
| ! | 邏輯 NOT 運算符。 如果條件為 True，則為 False，否則為 True。 |
5.4 位運算符
位運算符對整數在內存中的二進制位進行操作。
| 運算符 | 描述 |
|---|---|
| & | 參與運算的兩數各對應的二進位相與。 （兩位均為1才為1） |
| | | 參與運算的兩數各對應的二進位相或。 （兩位有一個為1就為1） |
| ^ | 參與運算的兩數各對應的二進位相異或，當兩對應的二進位相異時，結果為1。 （兩位不一樣則為1） |
| &^ | 二進制位清空&^ |
| << | 左移n位就是乘以2的n次方。 “a<<b”是把a的各二進位全部左移b位，高位丟棄，低位補0。 |
| >> | 右移n位就是除以2的n次方。 “a>>b”是把a的各二進位全部右移b位。 |
| A | B | A&B | A|B | A^B |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
5.5 賦值運算符
| 運算符 | 描述 | 示例 |
|---|---|---|
| = | 簡單的賦值操作符，分配值從右邊的操作數左側的操作數 | C = A + B 將分配A + B的值到C |
| += | 相加並賦值運算符，它增加瞭右操作數左操作數和分配結果左操作數 | C += A 相當於 C = C + A |
| -= | 減和賦值運算符，它減去右操作數從左側的操作數和分配結果左操作數 | C -= A 相當於 C = C – A |
| *= | 乘法和賦值運算符，它乘以右邊的操作數與左操作數和分配結果左操作數 | C *= A 相當於 C = C * A |
| /= | 除法賦值運算符，它把左操作數與右操作數和分配結果左操作數 | C /= A 相當於 C = C / A |
| %= | 模量和賦值運算符，它需要使用兩個操作數的模量和分配結果左操作數 | C %= A 相當於 C = C % A |
| <<= | 左移位並賦值運算符 | C <<= 2 相同於 C = C << 2 |
| >>= | 向右移位並賦值運算符 | C >>= 2 相同於 C = C >> 2 |
| &= | 按位與賦值運算符 | C &= 2 相同於 C = C & 2 |
| ^= | 按位異或並賦值運算符 | C ^= 2 相同於 C = C ^ 2 |
| |= | 按位或並賦值運算符 | C |= 2 相同於 C = C | 2 |
5.6 運算符優先級
有些運算符擁有較高的優先級，二元運算符的運算方向均是從左至右。由上至下代表優先級由高到低：
| 優先級 | 運算符 |
|---|---|
| 7 | ~ ! ++ — |
| 6 | * / % << >> & &^ |
| 5 | + – ^ |
| 4 | == != < <= >= > |
| 3 | <- |
| 2 | && |
| 1 | || |
當然，可以通過使用括號來臨時提升某個表達式的整體運算優先級。
到此這篇關於Golang通脈之數據類型詳情的文章就介紹到這瞭,更多相關Golang 數據類型內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- go語言 bool類型的使用操作
- Go語言基礎類型及常量用法示例詳解
- Go語言中的字符串拼接方法詳情
- Golang 中 omitempty的作用
- golang int 轉float 強轉和高精度轉操作