Go語言中常用的基礎方法總結
更新時間：2022年09月28日 10:29:32 作者：任沫
這篇文章主要為大家詳細介紹了Go語言中常用的一些基礎方法，例如：使用正則表達式驗證字符串、格式化字符串、時間的比較等等，需要的可以參考一下
字符串
1.使用正則表達式驗證字符串
使用regexp包中的Match函數(shù)：
func Match(pattern string, b []byte) (matched bool, err error)
Match函數(shù)返回一個表示在b中是否包含和pattern匹配的項的布爾值和一個錯誤。
package main
import (
"fmt"
"regexp"
)
func main() {
// 正則表達式模式"^[\u4e00-\u9fa5]+$"表示從頭到尾包含的內容是一個或多個中文字符串
// 從\u4e00到\u9fa5是中文的Unicode編碼，使用雙引號，對應的編碼會被解析為相應的中文
matched, err := regexp.Match("^[\u4e00-\u9fa5]+$", []byte(`匹配中文字符`))
// 不能使用反引號，因為反引號引用的是原生的字符，而正則表達式本身沒有\(zhòng)u這種寫法（有\(zhòng)s等寫法，詳情可以專門看正則表達式了解）
// matched, err = regexp.Match(`^[\u4e00-\u9fa5]+$`, []byte(`匹配中文字符`))
if err != nil {
fmt.Println("正則表達式匹配出錯1", err)
} else {
fmt.Println("正則表達式匹配的結果1:", matched)
}
// 正則表達式模式匹配英文大小寫字母和下劃線
matched, err = regexp.Match(`^[a-zA-Z_]+$`, []byte(`AAZ123`))
if err != nil {
fmt.Println("正則表達式匹配出錯2", err)
} else {
fmt.Println("正則表達式匹配的結果2:", matched)
}
matched, err = regexp.Match(`^[a-zA-Z_]+$`, []byte(`abc_DEF`))
if err != nil {
fmt.Println("正則表達式匹配出錯3", err)
} else {
fmt.Println("正則表達式匹配的結果3:", matched)
}
}在go中，單引號 '' 用來引用單個字符，雙引號 "" 用來引用可解析的字符，反引號 `` 用來引用原生的字符，比如"\n"會被解析為一個換行符，但是反引號引用的\n就是一個反斜杠和字符n。
2.字符串和數(shù)字的相互轉換
使用strconv包中的函數(shù)。
（1）string類型int類型的相互轉換
package main
import (
"fmt"
"strconv"
)
func main() {
// 字符串轉整型
aStr := "123"
if i, err := strconv.Atoi(aStr); err == nil {
fmt.Println("字符串轉換為整型后的值", i)
}
// 整型轉字符串
aInt := -123
anotherStr := strconv.Itoa(aInt)
fmt.Println("整型轉字符串之后的值", anotherStr)
}Atoi等同于ParseInt(s, 10, 0)，將字符串轉換為基數(shù)為10進制的int類型。
func ParseInt(s string, base int, bitSize int) (i int64, err error)
將一個字符串解析為整數(shù)，base是給定的基數(shù)（0、2到36），bitSize是位的大?。?到64），返回的值是和bitSize以及符號匹配的最大的整數(shù)。
當基數(shù)（base參數(shù)）為0的時候，函數(shù)會根據(jù)字符串的前綴來判斷使用的是幾進制，"0b"前綴對應2進制，"0" 或者"0o"前綴對應8進制， "0x"前綴對應16 進制，其他前綴對應10進制。
位的大?。╞itSize參數(shù)）0，8，16，32，和 64 對應 int，int8，nt16，int32，和int64。
Itoa等同于FormatInt(int64(i), 10)，將整型按照10進制轉換為字符串。
func FormatInt(i int64, base int) string
基數(shù)大于等于2小于等于23，小寫的字母'a'到'z'表示大于等于10的位的值（比如對于16進制來說，'a'表示10，'f'表示15）。
（2）string類型和bool類型，float類型，uint類型的相互轉換
浮點數(shù)轉字符串：
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
fmt是格式（format），有以下這些格式：
'b'表示二進制指數(shù)，-ddddp±ddd'e'表示十進制指數(shù)，-d.dddde±dd'E'表示十進制指數(shù)，-d.ddddE±dd；(大寫的'E'和小寫的'e'都表示的是是十進制指數(shù))'f'表示沒有指數(shù)，-ddd.dddd'g'，對于大指數(shù)來說，'g'表示'e'，否則'g'表示f'G'，對于大指數(shù)來說，'G'表示'e'，否則'G'表示f'x'表示十六進制分數(shù)和二進制指數(shù)，-0xd.ddddp±ddd'X'表示十六進制分數(shù)和二進制指數(shù)，-0Xd.ddddP±ddd
prec是精度：對于'e'， 'E'，'f'， 'x'， 和 'X'，它是小數(shù)點后的位數(shù)。對于'g' 和 'G'，是最大的有效數(shù)字的位數(shù)（刪除了末尾的0）。-1表示使用必須的位數(shù)的最小數(shù)字。
bitSize是位的大小：32 表示 float32， 64 表示 float64
// 整型轉字符串
aInt := -123
anotherStr := strconv.Itoa(aInt)
fmt.Println("整型轉字符串之后的值", anotherStr)
// 字符串轉bool值
aBool, _ := strconv.ParseBool("false")
// 布爾值轉字符串
strA := strconv.FormatBool(false)
// 字符串轉浮點數(shù)，ParseFloat的第2個參數(shù)是位的大小，32 表示 float32，64 表示 float64
aFloat, _ := strconv.ParseFloat("1.23", 64)
// 浮點數(shù)轉字符串
// 'E'表示十進制指數(shù)，-1表示必須的最小位數(shù)，64表示float64
strB := strconv.FormatFloat(1.23, 'E', -1, 64)
// 字符串轉無符號整型
aUint, _ := strconv.ParseUint("123", 10, 64)
//無符號整型轉字符串，將10進制表示的123轉換為字符串
strC := strconv.FormatUint(123, 10)
fmt.Println(aBool, strA, aFloat, strB, aUint, strC)
3.格式化字符串
使用fmt包中的函數(shù)打印指定格式的字符串到標準輸出中，以及將字符串整理為指定格式。
package main
import (
"fmt"
)
func main() {
fmt.Printf("%6.2f", 12.3) // 打印出的內容是12.30
s := fmt.Sprintf("%6.2f", 12.3)
fmt.Println(s) // 打印出的內容是12.30
}Printf根據(jù)指定的格式打印字符串到標準輸出中。Printf后面不會自帶換行符，如果需要換行符的時候，手動在字符串末尾加上。
func Printf(format string, a ...any) (n int, err error)
Println打印內容到標準輸出中，參數(shù)之間會加上空格，末尾會加上換行符。
func Println(a ...any) (n int, err error)
Sprintf根據(jù)指定的格式返回字符串。
func Sprintf(format string, a ...any) string
在format中的一些特殊符號的含義：
- %v 值的默認格式，當打印結構體的時候，使用加號標識 (%+v)會將字段名稱也打印出
- %#v go語法的值的表示
- %T go語法的值的類型的表示
- %% 表示一個百分號符號
- %t 單詞true或者false
- %b 二進制的數(shù)
- %c 打印Unicode代碼點對應的字符
- %d 打印10進制數(shù)
- %o 打印8進制數(shù)
- %s 字符串或者切片未解析的字節(jié)
還有更多符號的含義，查看fmt包了解更多。
type A struct {
A1 string
}
a := A{
A1: "aaa",
}
fmt.Printf("%v\n", a) // 打印內容 {aaa}
fmt.Printf("%+v\n", a) // 打印內容 {A1:aaa}
fmt.Printf("%#v\n", a) // 打印內容 main.A{A1:"aaa"}
fmt.Printf("%T\n", a) // 打印內容 main.A
fmt.Printf("%t\n", true) // 打印內容 true
fmt.Printf("%b\n", 8) // 打印內容 1000
fmt.Printf("%c, %c, %c, %c\n", 65, 90, 97, 122) // 打印內容 A, Z, a, z
fmt.Printf("%d\n", 123) // 打印內容 123
fmt.Printf("%o\n", 123) // 打印內容 173
時間
使用time包中的函數(shù)。
1.字符串和時間的相互轉換
package main
import (
"fmt"
"time"
)
func main() {
// 時間轉字符串
now := time.Now()
strA := now.Format("2006-01-02 15:04:05")
fmt.Println(strA)
// 字符串轉時間
timeA, _ := time.Parse("2006-01-02 15:04:05", strA)
fmt.Println(timeA) // 打印的值是 2022-09-25 17:58:26 +0000 UTC，UTC是世界標準時間
local, _ := time.LoadLocation("Local") // 本地時區(qū)
timeB, _ := time.ParseInLocation("2006-01-02 15:04:05", strA, local)
fmt.Println(timeB) // 打印的值是 2022-09-25 17:58:26 +0800 CST，CST是中國標準時間（北京時間），比UTC晚8個小時
}2.時間的比較
// 時間的加減
tenMinute, _ := time.ParseDuration("-10m") // 有效的時間單位是 "ns", "us" (或者 "μs"), "ms", "s", "m", "h"。
timeC := timeA.Add(tenMinute) // 拿到距離timeA 10分鐘之前的時間
duration := timeC.Sub(timeA)
// 時間的比較
fmt.Println(duration.Minutes()) // 打印的值為-10
fmt.Println(timeA.Equal(timeB)) // 判斷 timeA 是否等于 timeB，值為false，timeA和timeB因為時區(qū)不同，所以這兩個時間不相等
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ù)組的長度，是切片的初始長度
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]
// 獲取切片的部分內容
fmt.Println(slice1[:]) // [1 2 3]，slice[low:high]，省略low之后low的默認值是0，省略high之后，high的默認值是切片的長度
fmt.Println(slice1[2:]) // [3]
fmt.Println(slice1[:1]) // [1]
// 將slice1中的元素復制到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，聲明的切片的默認值是nil
fmt.Println(len(slice4)) // 0，空的切片的默認長度是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]
// 從映射中獲取對應鍵的值
fmt.Println(map3["a"]) // [1 2]
// 修改映射中對應鍵的值
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的默認值是nil
fmt.Println(len(map4)) // 0，空map的長度為0
接口
接口類型定義了類型的集合。一個接口對象可以存儲一個值，這個值是接口的類型集合中的任意一個類型。
一個類型通過實現(xiàn)接口的方法的方式來實現(xiàn)接口。
可以通過A Tour of Go的接口部分進行練習。
package main
import (
"fmt"
)
func main() {
aPerson := Person{
Name: "沫沫",
}
fmt.Println(aPerson.Dream("夢想成為閑人")) // 沫沫夢想成為閑人
}
type Behavior interface {
Dream(content string) string
}
type Person struct {
Name string
}
// 類型Person實現(xiàn)了接口Behavior
func (t Person) Dream(content string) string {
return fmt.Sprintf("%s%s", t.Name, content)
}空接口interface{}（別名為any）表示任意類型，對于未知類型的值可以使用空接口。
類型斷言語句斷言接口類型包含指定的類型。
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ù)會在函數(shù)返回之前被調用。
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")
}打印的內容：
要執(zhí)行的邏輯1
要執(zhí)行的邏輯2
c
b
a
指針
結構體
并發(fā)
以上就是Go語言中常用的基礎方法總結的詳細內容，更多關于Go語言常用方法的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要為大家介紹了Beego AutoRouter工作原理解析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-08-08
這篇文章主要介紹了golang定時器和超時的使用詳解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
傳統(tǒng)意義上來說,指針是一個指向某個確切的內存地址的值,這個內存地址可以是任何數(shù)據(jù)或代碼的起始地址,在Go語言中有幾種東西可以代表"指針",本文給大家介紹的是關于golang指針的有限操作,感興趣的同學可以參考一下2023-08-08
這篇文章主要介紹了Go語言實現(xiàn)websocket推送程序，WebSocket是基于TCP的一個雙向傳輸數(shù)據(jù)的協(xié)議，和HTTP協(xié)議一樣，是在應用層的，他的出現(xiàn)，是為了解決網(wǎng)頁進行持久雙向傳輸數(shù)據(jù)的問題2023-01-01
Go語言中的sync.RWMutex提供了讀寫鎖機制,允許多個協(xié)程并發(fā)讀取共享資源,但在寫操作時保持獨占性,本文主要介紹了Golang 并發(fā)讀寫鎖的具體實現(xiàn),感興趣的可以了解一下2025-02-02
這篇文章主要為大家介紹了Go Java算法之單詞規(guī)律示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-08-08
Golang基于sync.Once實現(xiàn)單例的操作代碼
這篇文章主要介紹了golang實現(xiàn)單例的操作代碼,本文介紹基于sync.Once的方式來實現(xiàn)單例，熟練掌握這種模式，并理解其底層原理，對大部分人來講已經(jīng)完全夠用了，需要的朋友可以參考下2022-10-10
設計模式是軟件工程中各種常見問題的經(jīng)典解決方案，，本文主要介紹了Go語言實現(xiàn)23種設計模式的使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-05-05
go?1.21.0?版本引入了一個新的包?log/slog,該包提供了結構化日志的功能,本文小編就來和大家聊聊log/slog?包的使用,感興趣的小伙伴可以跟隨小編一起學習一下2023-10-10
MatrixOne由Go語言所開發(fā)是一個新一代超融合異構數(shù)據(jù)庫，致力于打造單一架構處理TP、AP、流計算等多種負載的極簡大數(shù)據(jù)引擎，今天通過本文給大家介紹Go匯編語法和MatrixOne使用，感興趣的朋友一起看看吧2022-04-04