Go語(yǔ)言中常用的基礎(chǔ)方法總結(jié)

更新時(shí)間：2022年09月28日 10:29:32 作者：任沫

這篇文章主要為大家詳細(xì)介紹了Go語(yǔ)言中常用的一些基礎(chǔ)方法，例如：使用正則表達(dá)式驗(yàn)證字符串、格式化字符串、時(shí)間的比較等等，需要的可以參考一下

字符串

1.使用正則表達(dá)式驗(yàn)證字符串

使用regexp包中的Match函數(shù)：

func Match(pattern string, b []byte) (matched bool, err error)

Match函數(shù)返回一個(gè)表示在b中是否包含和pattern匹配的項(xiàng)的布爾值和一個(gè)錯(cuò)誤。

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // 正則表達(dá)式模式"^[\u4e00-\u9fa5]+$"表示從頭到尾包含的內(nèi)容是一個(gè)或多個(gè)中文字符串
    // 從\u4e00到\u9fa5是中文的Unicode編碼，使用雙引號(hào)，對(duì)應(yīng)的編碼會(huì)被解析為相應(yīng)的中文
    matched, err := regexp.Match("^[\u4e00-\u9fa5]+$", []byte(`匹配中文字符`))

    // 不能使用反引號(hào)，因?yàn)榉匆?hào)引用的是原生的字符，而正則表達(dá)式本身沒有\(zhòng)u這種寫法（有\(zhòng)s等寫法，詳情可以專門看正則表達(dá)式了解）
    // matched, err = regexp.Match(`^[\u4e00-\u9fa5]+$`, []byte(`匹配中文字符`))
    if err != nil {
        fmt.Println("正則表達(dá)式匹配出錯(cuò)1", err)
    } else {
        fmt.Println("正則表達(dá)式匹配的結(jié)果1:", matched)
    }

    // 正則表達(dá)式模式匹配英文大小寫字母和下劃線
    matched, err = regexp.Match(`^[a-zA-Z_]+$`, []byte(`AAZ123`))

    if err != nil {
        fmt.Println("正則表達(dá)式匹配出錯(cuò)2", err)
    } else {
        fmt.Println("正則表達(dá)式匹配的結(jié)果2:", matched)
    }

    matched, err = regexp.Match(`^[a-zA-Z_]+$`, []byte(`abc_DEF`))

    if err != nil {
        fmt.Println("正則表達(dá)式匹配出錯(cuò)3", err)
    } else {
        fmt.Println("正則表達(dá)式匹配的結(jié)果3:", matched)
    }
}

在go中，單引號(hào) '' 用來(lái)引用單個(gè)字符，雙引號(hào) "" 用來(lái)引用可解析的字符，反引號(hào) `` 用來(lái)引用原生的字符，比如"\n"會(huì)被解析為一個(gè)換行符，但是反引號(hào)引用的\n就是一個(gè)反斜杠和字符n。

2.字符串和數(shù)字的相互轉(zhuǎn)換

使用strconv包中的函數(shù)。

（1）string類型int類型的相互轉(zhuǎn)換

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 字符串轉(zhuǎn)整型
    aStr := "123"
    if i, err := strconv.Atoi(aStr); err == nil {
        fmt.Println("字符串轉(zhuǎn)換為整型后的值", i)
    }

    // 整型轉(zhuǎn)字符串
    aInt := -123
    anotherStr := strconv.Itoa(aInt)
    fmt.Println("整型轉(zhuǎn)字符串之后的值", anotherStr)
}

Atoi等同于ParseInt(s, 10, 0)，將字符串轉(zhuǎn)換為基數(shù)為10進(jìn)制的int類型。

func ParseInt(s string, base int, bitSize int) (i int64, err error)

將一個(gè)字符串解析為整數(shù)，base是給定的基數(shù)（0、2到36），bitSize是位的大?。?到64），返回的值是和bitSize以及符號(hào)匹配的最大的整數(shù)。

當(dāng)基數(shù)（base參數(shù)）為0的時(shí)候，函數(shù)會(huì)根據(jù)字符串的前綴來(lái)判斷使用的是幾進(jìn)制，"0b"前綴對(duì)應(yīng)2進(jìn)制，"0" 或者"0o"前綴對(duì)應(yīng)8進(jìn)制， "0x"前綴對(duì)應(yīng)16 進(jìn)制，其他前綴對(duì)應(yīng)10進(jìn)制。

位的大?。╞itSize參數(shù)）0，8，16，32，和 64 對(duì)應(yīng) int，int8，nt16，int32，和int64。

Itoa等同于FormatInt(int64(i), 10)，將整型按照10進(jìn)制轉(zhuǎn)換為字符串。

func FormatInt(i int64, base int) string

基數(shù)大于等于2小于等于23，小寫的字母'a'到'z'表示大于等于10的位的值（比如對(duì)于16進(jìn)制來(lái)說(shuō)，'a'表示10，'f'表示15）。

（2）string類型和bool類型，float類型，uint類型的相互轉(zhuǎn)換

浮點(diǎn)數(shù)轉(zhuǎn)字符串：

func FormatFloat(f float64, fmt byte, prec, bitSize int) string

fmt是格式（format），有以下這些格式：

'b'表示二進(jìn)制指數(shù)，-ddddp±ddd
'e'表示十進(jìn)制指數(shù)，-d.dddde±dd
'E'表示十進(jìn)制指數(shù)，-d.ddddE±dd；(大寫的'E'和小寫的'e'都表示的是是十進(jìn)制指數(shù))
'f'表示沒有指數(shù)，-ddd.dddd
'g'，對(duì)于大指數(shù)來(lái)說(shuō)，'g'表示'e'，否則'g'表示f
'G'，對(duì)于大指數(shù)來(lái)說(shuō)，'G'表示'e'，否則'G'表示f
'x'表示十六進(jìn)制分?jǐn)?shù)和二進(jìn)制指數(shù)，-0xd.ddddp±ddd
'X'表示十六進(jìn)制分?jǐn)?shù)和二進(jìn)制指數(shù)，-0Xd.ddddP±ddd

prec是精度：對(duì)于'e'， 'E'，'f'， 'x'，和 'X'，它是小數(shù)點(diǎn)后的位數(shù)。對(duì)于'g' 和 'G'，是最大的有效數(shù)字的位數(shù)（刪除了末尾的0）。-1表示使用必須的位數(shù)的最小數(shù)字。

bitSize是位的大小：32 表示 float32， 64 表示 float64

    // 整型轉(zhuǎn)字符串
    aInt := -123
    anotherStr := strconv.Itoa(aInt)
    fmt.Println("整型轉(zhuǎn)字符串之后的值", anotherStr)

    // 字符串轉(zhuǎn)bool值
    aBool, _ := strconv.ParseBool("false")
    // 布爾值轉(zhuǎn)字符串
    strA := strconv.FormatBool(false)

    // 字符串轉(zhuǎn)浮點(diǎn)數(shù)，ParseFloat的第2個(gè)參數(shù)是位的大小，32 表示 float32，64 表示 float64
    aFloat, _ := strconv.ParseFloat("1.23", 64)
    // 浮點(diǎn)數(shù)轉(zhuǎn)字符串
    // 'E'表示十進(jìn)制指數(shù)，-1表示必須的最小位數(shù)，64表示float64
    strB := strconv.FormatFloat(1.23, 'E', -1, 64)

    // 字符串轉(zhuǎn)無(wú)符號(hào)整型
    aUint, _ := strconv.ParseUint("123", 10, 64)
    //無(wú)符號(hào)整型轉(zhuǎn)字符串，將10進(jìn)制表示的123轉(zhuǎn)換為字符串
    strC := strconv.FormatUint(123, 10)

    fmt.Println(aBool, strA, aFloat, strB, aUint, strC)

3.格式化字符串

使用fmt包中的函數(shù)打印指定格式的字符串到標(biāo)準(zhǔn)輸出中，以及將字符串整理為指定格式。

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("%6.2f", 12.3) // 打印出的內(nèi)容是12.30
    s := fmt.Sprintf("%6.2f", 12.3)
    fmt.Println(s) // 打印出的內(nèi)容是12.30
}

Printf根據(jù)指定的格式打印字符串到標(biāo)準(zhǔn)輸出中。Printf后面不會(huì)自帶換行符，如果需要換行符的時(shí)候，手動(dòng)在字符串末尾加上。

func Printf(format string, a ...any) (n int, err error)

Println打印內(nèi)容到標(biāo)準(zhǔn)輸出中，參數(shù)之間會(huì)加上空格，末尾會(huì)加上換行符。

func Println(a ...any) (n int, err error)

Sprintf根據(jù)指定的格式返回字符串。

func Sprintf(format string, a ...any) string

在format中的一些特殊符號(hào)的含義：

%v 值的默認(rèn)格式，當(dāng)打印結(jié)構(gòu)體的時(shí)候，使用加號(hào)標(biāo)識(shí) (%+v)會(huì)將字段名稱也打印出
%#v go語(yǔ)法的值的表示
%T go語(yǔ)法的值的類型的表示
%% 表示一個(gè)百分號(hào)符號(hào)
%t 單詞true或者false
%b 二進(jìn)制的數(shù)
%c 打印Unicode代碼點(diǎn)對(duì)應(yīng)的字符
%d 打印10進(jìn)制數(shù)
%o 打印8進(jìn)制數(shù)
%s 字符串或者切片未解析的字節(jié)

還有更多符號(hào)的含義，查看fmt包了解更多。

    type A struct {
        A1 string
    }
    a := A{
        A1: "aaa",
    }
    fmt.Printf("%v\n", a)  // 打印內(nèi)容 {aaa}
    fmt.Printf("%+v\n", a) // 打印內(nèi)容 {A1:aaa}
    fmt.Printf("%#v\n", a) // 打印內(nèi)容 main.A{A1:"aaa"}
    fmt.Printf("%T\n", a)  // 打印內(nèi)容 main.A

    fmt.Printf("%t\n", true)                        // 打印內(nèi)容 true
    fmt.Printf("%b\n", 8)                           // 打印內(nèi)容 1000
    fmt.Printf("%c, %c, %c, %c\n", 65, 90, 97, 122) // 打印內(nèi)容 A, Z, a, z
    fmt.Printf("%d\n", 123)                         // 打印內(nèi)容 123
    fmt.Printf("%o\n", 123)                         // 打印內(nèi)容 173

時(shí)間

使用time包中的函數(shù)。

1.字符串和時(shí)間的相互轉(zhuǎn)換

package main

import (
    "fmt"
    "time"
)

func main() {
    // 時(shí)間轉(zhuǎn)字符串
    now := time.Now()
    strA := now.Format("2006-01-02 15:04:05")
    fmt.Println(strA)

    // 字符串轉(zhuǎn)時(shí)間
    timeA, _ := time.Parse("2006-01-02 15:04:05", strA)
    fmt.Println(timeA) // 打印的值是 2022-09-25 17:58:26 +0000 UTC，UTC是世界標(biāo)準(zhǔn)時(shí)間

    local, _ := time.LoadLocation("Local") // 本地時(shí)區(qū)
    timeB, _ := time.ParseInLocation("2006-01-02 15:04:05", strA, local)
    fmt.Println(timeB) // 打印的值是 2022-09-25 17:58:26 +0800 CST，CST是中國(guó)標(biāo)準(zhǔn)時(shí)間（北京時(shí)間），比UTC晚8個(gè)小時(shí)
}

2.時(shí)間的比較

    // 時(shí)間的加減
    tenMinute, _ := time.ParseDuration("-10m") // 有效的時(shí)間單位是 "ns", "us" (或者 "μs"), "ms", "s", "m", "h"。
    timeC := timeA.Add(tenMinute)              // 拿到距離timeA 10分鐘之前的時(shí)間
    duration := timeC.Sub(timeA)

    // 時(shí)間的比較
    fmt.Println(duration.Minutes())  // 打印的值為-10
    fmt.Println(timeA.Equal(timeB))  // 判斷 timeA 是否等于 timeB，值為false，timeA和timeB因?yàn)闀r(shí)區(qū)不同，所以這兩個(gè)時(shí)間不相等
    fmt.Println(timeC.Before(timeA)) // 判斷 timeA 是否小于 timeB，值為true
    fmt.Println(timeA.After(timeB))  // 判斷 timeA 是否大于 timeB，值為true
    fmt.Println(timeB.After(timeA))  // 判斷 timeA 是否大于 timeB，值為false

切片

    slice1 := []int{1, 2, 3}
    fmt.Println(slice1) // [1 2 3]

    slice2 := make([]int, 3) // 這里的3是數(shù)組的長(zhǎng)度，是切片的初始長(zhǎng)度
    fmt.Println(slice2)      // [0 0 0]

    // 向切片中添加元素
    slice2 = append(slice2, 1)
    fmt.Println(slice2) // [0 0 0 1]
    slice3 := make([]int, 2)
    slice3 = append(slice3, []int{2, 3, 4}...)
    fmt.Println(slice3) // [0 0 2 3 4]

    // 獲取切片的部分內(nèi)容
    fmt.Println(slice1[:])  // [1 2 3]，slice[low:high]，省略low之后low的默認(rèn)值是0，省略high之后，high的默認(rèn)值是切片的長(zhǎng)度
    fmt.Println(slice1[2:]) // [3]
    fmt.Println(slice1[:1]) // [1]

    // 將slice1中的元素復(fù)制到slice2中
    copy(slice2, slice1)
    fmt.Println(slice2) // [1 2 3 1]

    // 遍歷切片
    for index, value := range slice2 {
        fmt.Printf("索引%d，值%d\n", index, value)
    }

    var slice4 []string
    fmt.Println(slice4 == nil) // true，聲明的切片的默認(rèn)值是nil
    fmt.Println(len(slice4))   // 0，空的切片的默認(rèn)長(zhǎng)度是0

映射

    map1 := map[string]string{
        "a_key": "a_value",
        "b_key": "b_value"}
    fmt.Println(map1) // map[a_key:a_value b_key:b_value]

    map2 := make(map[int]string)
    fmt.Println(map2) // map[]

    map3 := map[string]interface{}{
        "a": []int{1, 2},
        "b": 1.23,
    }
    fmt.Println(map3) // map[a:[1 2] b:1.23]

    // 從映射中獲取對(duì)應(yīng)鍵的值
    fmt.Println(map3["a"]) // [1 2]

    // 修改映射中對(duì)應(yīng)鍵的值
    map3["a"] = 1
    fmt.Println(map3) // map[a:1 b:1.23]

    // 遍歷映射
    for key, value := range map3 {
        fmt.Printf("鍵:%v, 值:%v\n", key, value)
    }

    var map4 map[string]int
    fmt.Println(map4 == nil) // true，聲明的map的默認(rèn)值是nil
    fmt.Println(len(map4))   // 0，空map的長(zhǎng)度為0

接口

接口類型定義了類型的集合。一個(gè)接口對(duì)象可以存儲(chǔ)一個(gè)值，這個(gè)值是接口的類型集合中的任意一個(gè)類型。

一個(gè)類型通過(guò)實(shí)現(xiàn)接口的方法的方式來(lái)實(shí)現(xiàn)接口。

可以通過(guò)A Tour of Go的接口部分進(jìn)行練習(xí)。

package main

import (
    "fmt"
)

func main() {
    aPerson := Person{
        Name: "沫沫",
    }
    fmt.Println(aPerson.Dream("夢(mèng)想成為閑人")) // 沫沫夢(mèng)想成為閑人

}

type Behavior interface {
    Dream(content string) string
}
type Person struct {
    Name string
}

// 類型Person實(shí)現(xiàn)了接口Behavior
func (t Person) Dream(content string) string {
    return fmt.Sprintf("%s%s", t.Name, content)
}

空接口interface{}（別名為any）表示任意類型，對(duì)于未知類型的值可以使用空接口。

類型斷言語(yǔ)句斷言接口類型包含指定的類型。

    var a interface{}
    a = 1
    a = "2"
    fmt.Println(a) // 2

    // 類型斷言
    var s string
    s = a.(string)
    s, ok := a.(string)
    fmt.Println(s, ok) // 2, true
    if !ok {
        fmt.Println("a的值的類型不是string")
    }

延遲函數(shù)

延遲函數(shù)會(huì)在函數(shù)返回之前被調(diào)用。

package main

import (
    "fmt"
)

func main() {
    defer func() {
        fmt.Println("a")
    }()

    defer func() {
        fmt.Println("b")
    }()

    defer func() {
        fmt.Println("c")
    }()

    fmt.Println("要執(zhí)行的邏輯1")
    fmt.Println("要執(zhí)行的邏輯2")
}

打印的內(nèi)容：