go語言的10種數據類型介紹

今天小編給大家分享的是go語言的10種數據類型介紹，相信很多人都不太了解，為了讓大家更加了解，所以給大家總結了以下內容，一起往下看吧。一定會有所收獲的哦。

go語言的數據類型有：1、布爾型，值只可以是常量true或false；2、數字類型，支持整型和浮點型數字，并且支持復數；3、字符串類型，是一串固定長度的字符連接起來的字符序列；4、指針類型；5、數組類型；6、結構化類型；7、Channel類型；8、函數類型；9、切片類型；10、接口類型；11、Map類型。

Go 語言數據類型

在 Go 編程語言中，數據類型用于聲明函數和變量。

數據類型的出現是為了把數據分成所需內存大小不同的數據，編程的時候需要用大數據的時候才需要申請大內存，就可以充分利用內存。

Go 語言按類別有以下幾種數據類型：

Go語言中有豐富的數據類型，除了基本的整型、浮點型、布爾型、字符串外，還有數組、切片、結構體、函數、map、通道（channel）等

1.整形

• 整數

1.1.整型分為兩類

• 按占用的內存長度劃分

int8、int16、int32、int64

• 按照是否有正負號劃分-無符號整型

uint8、uint16、uint32、uint64

• 與 C 語言對比

uint8 對應 byte 型
int16 對應 C 語言中的 short 型
int64 對應 C 語言中的 long 型

1.2.整形描述

1.3.特殊整型

1.4.注意

1.在使用 int 和 uint 類型時，不能假定它是 32 位或 64 位的整型，而是考慮 int 和 uint 可能在不同平臺上的差異
2.獲取對象的長度的內建 len() 函數返回的長度可以根據不同平臺的字節長度進行變化
3.實際使用中，切片或 map 的元素數量等都可以用 int 來表示
4.在涉及到二進制傳輸，讀寫文件的結構描述時，為了保持文件的結構不會受到不同編譯目標平臺字節長度的影響，不要使用 int 和 uint

1.5.數字字面量語法

• Number literals syntax

• Go1.13 版本之后引入了 數字字面量語法，這樣便于開發者以二進制、八進制或十六進制浮點數的格式定義數字

• 內存地址是以十六進制數進行保存的

v := 0b00101101， 代表二進制的 101101，相當于十進制的 45
v := 0o377，代表八進制的 377，相當于十進制的 255
v := 0x1p-2，代表十六進制的 1 除以 22，也就是 0.25

• 允許用下劃線 _ 來分隔數字

v := 123_456 表示 v 的值等于 123456。

• 可以借助 fmt 函數來將一個整數以不同進制形式展示

package main

import "fmt"

func main() {
    // 定義十進制數
    var a int = 10
    fmt.Printf("%d \n", a) // 占位符 %d 表示使用十進制顯示為 10
    fmt.Printf("%b \n", a) // 占位符 %b 表示使用二進制顯示為 1010

    // 定義八進制數，需要以 0 開頭
    var b int = 077
    fmt.Printf("%o \n", b) // 占位符 %o 表示使用八進制顯示為 77

    // 定義十六進制數，需要以 0x 開頭
    var c int = 0xff
    fmt.Printf("%x \n", c) // 占位符 %x 表示使用十六進制顯示為 ff，小寫字母顯示
    fmt.Printf("%X \n", c) // 占位符 %X 表示使用十六進制顯示為 FF，大寫字母顯示
}

2.浮點型

• Go 語言支持兩種浮點型數：float32 和 float64 ，這兩種浮點型數據格式遵循 IEEE 754 標準

float32 的浮點數的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32
float64 的浮點數的最大范圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64
打印浮點數時，可以使用 fmt 包配合 %f

• 實例演示：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
}

3.復數

• complex64 和 complex128

• 復數有實部和虛部，complex64 的實部和虛部為 32 位，complex128 的實部和虛部為 64 位

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

4.布爾值

• Go 語言中以 bool 類型進行聲明布爾型數據

1.布爾型數據只有 true 和 false 兩個值,布爾類型變量的默認值為 false。
2.Go 語言中不允許將整型強制轉換為布爾型.
3.布爾型無法參與數值運算，也無法與其他類型進行轉換

5.字符串

• Go 語言中的字符串以原生數據類型出現，使用字符串就像使用其他原生數據類型（int、bool、float32、float64 等）一樣

• Go 語言字符串使用 UTF-8 編碼,可以在 Go 語言的源碼中直接添加非 ASCII 碼字符

5.1.定義一個字符串類型的變量

• 使用 雙引號 定義 單行字符串 變量

• 使用 反引號 定義 多行字符串 變量

• 使用 單引號 定義 單個字符 變量

• 實例演示

package main

import "fmt"

func main() {
    // 使用 雙引號 定義 單行字符串 變量
    s1 := "hello" //定義英文字符串
    s2 := "你好"    // 可以識別非 ASCII 碼，默認支持 utf-8 編碼

    // 使用 反引號 定義 多行字符串 變量
    s3 := `
11111
22222   // 多行字符串里的雙斜杠也表示注釋
33333
`

    // 使用 單引號 定義 單個字符 變量
    s4 := 'h'

    fmt.Println("\n單行字符串01", s1)
    fmt.Println("\n單行字符串02", s2)
    fmt.Println("\n多行字符串", s3)
    fmt.Println("\n字符定義", s4)
}

5.2.字符串轉義

• Go 語言的字符串常見轉義符包含回車、換行、單雙引號、制表符等

5.3.字符串轉義-實例演示

package main

import (
    "fmt"
)

func main() {
    // 轉義符的使用
    fmt.Println("\n# 轉義符的使用 str := \"c:\\go\"")
}

5.4.字符串操作

5.5.字符串操作-實例演示

package main

import (
    "fmt"
    "strings"
)

// 字符串操作
func main() {
    // 字符串求長度
    s3 := "zhongguojueqi"
    fmt.Println("\n字符串-求長度: ", len(s3))
    
    // 字符串拼接
    s4 := "nihaoshijie"
    fmt.Println("\n字符串-拼接01: ", s3+s4)
    
    s5 := fmt.Sprintf("%s---%s", s3, s4)
    fmt.Println("\n字符串-拼接02: ", s5)
    
    // 字符串分割
    s6 := strings.Split(s3, "o")
    fmt.Println("\n字符串-分割: ", s6)
    
    // 字符串包含判斷
    s7 := strings.Contains(s3, "o")
    fmt.Println("\n字符串-包含判斷01: ", s7)
    fmt.Println("\n字符串-包含判斷02: ", strings.Contains(s3, "o"))
    
    // 字符串前綴， 后綴判斷
    fmt.Println("\n字符串-前綴判斷: ", strings.HasPrefix(s3, "zhong"))
    fmt.Println("\n字符串-后綴判斷: ", strings.HasSuffix(s3, "qi"))
    
    // 字符串索引查找
    fmt.Println("\n字符串-索引查找-第一個字符 o 的索引: ", strings.Index(s3, "o"))
    fmt.Println("\n字符串-索引查找-最后一個字符 o 的索引: ", strings.LastIndex(s3, "o"))
    
    // 字符串-join操作
    s8 := []string{"aaa", "bbb", "ccc", "ddd"}
    fmt.Println("\n字符串-join 操作: ", strings.Join(s8, " + "))
}

6.字符

6.1.定義一個字符變量

• 組成字符串的元素叫做 字符,使用單引號進行定義字符類型變量，字符串使用雙引號定義

• 可以通過遍歷或者單個獲取字符串元素獲得字符

func runeDemo01() { // 字符定義
    a := '中'         // 默認識別為 rune 類型的字符變量
    b := "中"         // 定義一個字符串
    var c byte = 'a' // 定義一個byte類型字符
    var d rune = 'a' // 定義一個rune類型字符
    fmt.Println(a, b)
    fmt.Printf("%v,%T\n", c, c)
    fmt.Printf("%v,%T\n", d, d)
}

6.2.字符類型有兩種

6.2.1.uint8-類型字符

• go 語言中一般的英文數字字符使用 ASCII 碼的一個字符，占據 8 位 bit 的內存空間，也就是常用的 byte 型

6.2.2.rune-類型字符

• go 語言中處理中文日文或者其他復合字符時，需要用到 rune 類型，rune 類型實際是一個 int32，代表一個 UTF-8 字符（Unicode編碼）

7.字符串拓展

7.1.字符串遍歷-方法1-使用循環依次取出字符串中的元素

// 字符串遍歷-traversalString
package main

import (
    "fmt"
)

func traversalString01() {
    s := "hello世界"
    for i := 0; i < len(s); i++ { // 中英文使用 for循環加 len() 方法遍歷循環，但遇到中文會有亂碼
      fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    fmt.Println([]byte(s))
}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 228(?) 184(?) 150() 231(?) 149() 140()
-----------------------

7.2.字符串遍歷-方法2-rune-類型遍歷可以使用 for range 循環

package main

import (
    "fmt"
)

// 遍歷字符串 traversalString
func traversalString02() {
    s := "hello世界"
    fmt.Println()
    for _, r := range s { // 按照 rune 類型遍歷
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
    fmt.Println([]rune(s))

}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 19990(世) 30028(界)
-----------------------

• 結果分析：

1.因為 UTF8 編碼下一個中文漢字由 3~4 個字節組成，所以我們不能簡單的按照字節去遍歷一個包含中文的字符串，否則就會出現上面輸出中第一行的結果
2.字符串底層是一個 byte 數組，所以可以和 []byte 類型相互轉換
3.字符串是不能修改的 字符串是由 byte 字節組成，所以字符串的長度是 byte 字節的長度
4.rune 類型用來表示 utf8 字符，一個 rune 字符由一個或多個 byte 組成。

7.3.字符串修改

• 字符串是固定值無法修改，如果要修改字符串，需要先將其轉換成 []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))
}

8.類型轉換

• Go語言中只有強制類型轉換，沒有隱式類型轉換。該語法只能在兩個類型之間支持相互轉換的時候使用

8.1.類型轉換-語法

T(表達式)

• 其中，T 表示要轉換的類型，表達式包括變量、復雜算子和函數返回值等

8.1.類型轉換-實例演示

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

• 說明

計算直角三角形的斜邊長時使用 math 包的 Sqrt() 函數，該函數接收的是 float64 類型的參數
而變量 a 和 b 都是 int 類型的，這個時候就需要將 a 和 b 強制類型轉換為 float64 類型

關于go語言的10種數據類型介紹就分享到這里了，希望以上內容可以對大家有一定的參考價值，可以學以致用。如果喜歡本篇文章，不妨把它分享出去讓更多的人看到。