Golang中常用的基本數據類型有哪些

這篇文章主要講解了“Golang中常用的基本數據類型有哪些”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Golang中常用的基本數據類型有哪些”吧！

Golang 是一種強類型語言，變量使用時需要進行強制類型定義，一旦某一個變量被定義，如果不經強制轉換，那么它永遠就是該類型。

變量聲明及初始化

Golang 推薦使用駝峰式命名，如 QuoteRuneToASCII 和 parseRequestLine 等。

定義變量的幾種形式：

// 第一種，先聲明類型，再進行初始化賦值
// 如果沒有初始化，則變量默認為零值。
var a int
a = 3

// 第二種, 根據賦值自動適配類型
b := 3   // 這種寫法只能在函數體中出現
         // 效果等價于 var b = 3， 但后者可以在函數體之外的地方使用

// 第三種，聲明類型的同時進行賦值
var c int = 3

// 第四種，使用 new 創建變量，然后返回變量的地址，類型為 *type
p := new(int)
*p = 3

// 與 python 相同，交換兩個變量的值，可以使用 a, b = b, a 
// 但與 python 不同的是兩個變量的類型必須是相同的。

注意：

• Golang 中不允許出現未使用的變量，否則會報錯 a declared and not used。但是全局變量是允許聲明但不使用。

• Golang 的封裝性由變量名第一個字母決定，大寫字母開頭的變量是可導出的變量，可以在包外使用，小寫字母或者下劃線開頭的變量只能在本包內使用。

• “:=” 是一個變量聲明語句，而 “=‘ 是一個變量賦值操作，一行中簡短聲明多個變量時，":=" 語句中必須至少要聲明一個新的變量。

基本數據類型

獲取元素類型

// 方法一，創建 reflect 變量
import "reflect"

var a int
typeOfA := reflect.TypeOf(a)
fmt.Println(typeOfA)
// 或者直接 fmt.Println(reflect.TypeOf(a))

// 方法二，使用 fmt 查看
import "fmt"
var a int
fmt.Printf("%T", a)   // 注意不能用 Println

整型

數字表示類型的比特長度，不同長度的類型是獨立的，混合計算會報錯

int 的長度由硬件決定：

也可以指定 int 的固定長度類型：

浮點類型

Golang 支持兩種浮點型數值：float32 和 float64。可以使用 math 包中的常量獲取浮點類型的邊界值

const (
    MaxFloat32             = 3.40282346638528859811704183484516925440e+38  // 2**127 * (2**24 - 1) / 2**23
    SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45 // 1 / 2**(127 - 1 + 23)

    MaxFloat64             = 1.797693134862315708145274237317043567981e+308 // 2**1023 * (2**53 - 1) / 2**52
    SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324 // 1 / 2**(1023 - 1 + 52)
)

注意：浮點類型有精度限制，計算結果不準確，不推薦使用
需要進行浮點計算時，可以使用放大 100 倍的整數計算，計算完成再將結果縮小 100 倍

復數

Golang 自帶了復數類型，分別為 complex64, complex128，定義時需要制定實部和虛部，如：

var c1, c2 complex64
c1 = 1 + 2i
c2 = 2 + 3i
fmt.Println(c1 + c2) // out: 3 + 5i

布爾

bool 類型，有 true 和 false 兩種類型，要注意的是，和 python 不同，Golang 不會自動對變量識別 true or false，因此 if 1 這種方式是會報錯的

錯誤

error，error 實際上是一種接口類型，后續會單獨介紹，可以先參考官網文檔 error document

字符

rune, byte 可用于表示單個字符，字符串，rune 數組，byte 數組之間可以相互轉換，讓我們從源碼看看 byte 和 rune 的區別：

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8


// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

可以看出，byte 為 1 字節的 uint8 數值，rune 為 4 字節的 int32 數值，通過下面的代碼，可以看出一個中文字符占了三個字節，在 []byte{} 中長度為 3，string 和 []byte{} 的長度相等，string 實際上就是由 byte 數組實現的。

a := "測試T"
aRune := []rune(a)
aByte := []byte(a)
fmt.Println(a, aRune, aByte)
fmt.Println(len(a), len(aRune), len(aByte))
  
// output：
// 測試T [27979 35797 84] [230 181 139 232 175 149 84]
// 7 3 7

字符串

string 類型，與 python 不同，go 的字符串只能用 “” 或者 原始字符串引號 ``(重音符號)

// 普通字符串
s1 := "hello\nworld"    // 里面的 \n 會被轉義為回車

// 原始字符串，相當于 python 中在字符串前面加 r
s2 := `hello\nworld`    // 所有內容都是字符，不會被轉義

字符串是不可修改的，對字符串進行修改操作時，會創建一個新的字符串賦值給當前字符串

s := "hello"
s += " world" // 這樣不會報錯，會把 "hello world" 整個重新分配給 s

s[0] = "a"    // 這樣寫就會報錯

因此，如果涉及到大批量的字符串拼接或者修改的操作，效率會很低且耗費資源，推薦使用 bytes 包的 Buffer 來進行操作

import "bytes"

bs := bytes.NewBufferString("")
bs.WriteString("hello ")
bs.WriteString("world")
s := bs.String()  // out: hello world

更多內容可查看官網文檔 bytes document

字符串常用操作

獲取字符串長度

字符串本質上是字符數組，所以可以使用 len(s) 獲取長度。
要注意的是對用戶名等可能包含中文或其他字符的字符串進行判斷時，使用 utf8 長度判斷而不是 len() 判斷，否則識別出來的長度是不正確的

fmt.Println(len("測試"))							// 6
fmt.Println(utf8.RuneCountInString("測試"))			// 2
fmt.Println(utf8.RuneCountInString("混合測試,fight!"))  // 11

數值和字符串的相互轉換

• int 轉換為 string

int 轉換為 string 不能直接 string(i)，這樣轉完會變成空值

s := strconv.Itoa(i)

• int64 轉換為 string

var i64 int64s := strconv.FormatInt(i64,10)  // 第二個參數為基數（2~36），如十進制二進制等

• string 轉換為 int 型

使用非數值的字符串轉換為數值時會發生錯誤，比如 “abc” 轉為數字或者使用空字符串，因此需要接收 error。

i, err := strconv.Atoi(s)
if err != nil {
	return err
}

• string 轉換為 int64

//第二個參數為基數（2~36），
//第三個參數位大小表示期望轉換的結果類型，其值可以為0, 8, 16, 32和64，
//分別對應 int, int8, int16, int32和int64
i64, err := strconv.ParseInt(s, 10, 64)

string 和 slice 相互轉換

• slice 轉換為 string

import "strings"

sli := []string{"111","2222","333","4444"}
ss := strings.Join(s,"--")  // 輸出為 111--2222--333--4444

• string 轉換為 slice

ss := "a,b,c"
sli := strings.Split("a,b,c", ",")

字符串替換

使用 strings 包的 Replace 函數進行字符串替換

// Replace
// 如果最后一個參數為正整數，表示將前 n 個 old 替換為 new
// 如果最后一個參數為負數，一般為-1，表示全局替換，相當于 ReplaceAll
func Replace(s, old, new string, n int) string
// 例：
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
// output: moo moo moo
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", 2))
// output: moo moo oink

// ReplaceAll
func ReplaceAll(s, old, new string) string

指針

如果用“var x int”聲明語句聲明一個x變量，那么 &x 表達式（取x變量的內存地址）將產生一個指向該整數變量的指針，指針對應的數據類型是 *int ，指針被稱之為“指向int類型的指針”。同時 *p 表達式對應p指針指向的變量的值。

x := 1
p := &x     // p 為指向 x 的指針   
/* 等價于：
var p *int
p = &x
*/
fmt.Println(*p)   // 輸出 1
*p = 2     // 修改 *p 指向對象的值
fmt.Println(x)   // 輸出 2

任何類型的指針的零值都是 nil。如果 p != nil 測試為真，那么 p 是指向某個有效變量。指針之間也是可以進行相等測試的，只有當它們指向同一個變量或全部是nil時才相等。

自定義類型

type 類型名字 底層類型

這種操作的意義在于賦予相同基本類型（比如 float64）的變量不同的含義，比如華氏溫度和攝氏溫度，這兩種溫度被定義成不同的數據類型，可以避免混用不同的溫度單位，產生錯誤的計算結果。

// Package tempconv performs Celsius and Fahrenheit temperature computations.
package tempconv
import "fmt"

type Celsius float64 // 攝氏溫度
type Fahrenheit float64 // 華氏溫度

const (
    AbsoluteZeroC Celsius = -273.15 // 絕對零度
    FreezingC Celsius = 0 // 結冰點溫度
    BoilingC Celsius = 100 // 沸水溫度
)

func CToF(c Celsius) Fahrenheit { 
    return Fahrenheit(c*9/5 + 32) 
}

func FToC(f Fahrenheit) Celsius { 
    return Celsius((f - 32) * 5 / 9) 
}

常量

go 使用 const 創建常量，它們在編譯時被創建，只能是數字、字符串或布爾
值。

// 常量用的是 = 而不是 :=
const x = 42

可以使用 iota 生成枚舉值，第一個iota 表示為0，當iota 再次在新的一行使用時，它的值累加 1。第一行之外的 = iota 可以省略，只要出現了一次 iota， 當前 const 結構中后面每一行 iota的值加1。

package main

import "fmt"

func main() {
    const (
        a = iota  // 0
        b		 // 1
        c		 // 2
        d = "ha"  // "ha", iota += 1, iota = 3
        e		 // "ha", iota += 1, iota = 4
        f = 100   // 100, iota += 1, iota = 5
        g		 // 100, iota += 1, iota = 6
        h = iota  // 7
        i		 // 8
    )
    
    fmt.Println(a,b,c,d,e,f,g,h,i)
    // 結果為 0 1 2 ha ha 100 100 7 8
    
    // 另一個有趣的示例
    const (
        x = 1 << iota  // 1 << 0
        y = 3 << iota  // 3 << 1
        z			  // 3 << 2
        q			  // 3 << 3
    )
    
    fmt.Println(x,y,z,q)
    // 結果為 1 6 12 24
}

格式化輸出

使用 fmt 包進行格式化輸出，可參考鏈接
格式化輸出方式

強制類型轉換

type_name(expression)
// 如 
f := float32(3)
i := int64(2)

注意：將長類型強制轉換為短類型時會發生截斷

感謝各位的閱讀，以上就是“Golang中常用的基本數據類型有哪些”的內容了，經過本文的學習后，相信大家對Golang中常用的基本數據類型有哪些這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！