欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Golang切片Slice功能操作詳情

 更新時(shí)間:2022年09月30日 09:55:37   作者:Leefs???????  
這篇文章主要介紹了Golang切片功能操作詳情,切片是一個(gè)擁有相同類型元素的可變長度的序列。它是基于數(shù)組類型做的一層封,切片是一個(gè)引用類型,它的內(nèi)部結(jié)構(gòu)包含地址、長度和容量

一、概述

切片(Slice)是一個(gè)擁有相同類型元素的可變長度的序列。它是基于數(shù)組類型做的一層封裝。它非常靈活,支持自動(dòng)擴(kuò)容。

切片是一個(gè)引用類型,它的內(nèi)部結(jié)構(gòu)包含地址、長度容量。切片一般用于快速地操作一塊數(shù)據(jù)集合。

二、切片

2.1 切片的定義

聲明切片類型的基本語法如下:

var name []T

說明

  • name:表示變量名
  • T:表示切片中的元素類型

示例:

func main() {
	// 聲明切片類型
	var a []string              //聲明一個(gè)字符串切片
	var b = []int{}             //聲明一個(gè)整型切片并初始化
	var c = []bool{false, true} //聲明一個(gè)布爾切片并初始化
	var d = []bool{false, true} //聲明一個(gè)布爾切片并初始化
	fmt.Println(a)              //[]
	fmt.Println(b)              //[]
	fmt.Println(c)              //[false true]
	fmt.Println(a == nil)       //true
	fmt.Println(b == nil)       //false
	fmt.Println(c == nil)       //false
	// fmt.Println(c == d)   //切片是引用類型,不支持直接比較,只能和nil比較
}

2.2 切片的長度和容量

一個(gè) slice 由三個(gè)部分構(gòu)成:指針 、 長度 和 容量 。

指針指向第一個(gè) slice 元素對應(yīng)的底層數(shù)組元素的地址,要注意的是 slice 的第一個(gè)元素并不一定就是數(shù)組的第一個(gè)元素。

長度對應(yīng) slice 中元素的數(shù)目;長度不能超過容量,容量一般是從 slice 的開始位置到底層數(shù)據(jù)的結(jié)尾位置。

簡單的講,容量就是從創(chuàng)建切片索引開始的底層數(shù)組中的元素個(gè)數(shù),而長度是切片中的元素個(gè)數(shù)。

內(nèi)置的 len 和 cap 函數(shù)分別返回 slice 的長度和容量。

s := make([]string, 3, 5)
fmt.Println(len(s)) // 3
fmt.Println(cap(s)) // 5

如果切片操作超出上限將導(dǎo)致一個(gè) panic 異常。

s := make([]int, 3, 5)
fmt.Println(s[10]) //panic: runtime error: index out of range [10] with length 3

2.3 切片表達(dá)式

切片表達(dá)式從字符串、數(shù)組、指向數(shù)組或切片的指針構(gòu)造子字符串或切片。

它有兩種變體:

  • 一種指定low和high兩個(gè)索引界限值的簡單的形式
  • 另一種是除了low和high索引界限值外還指定容量完整的形式。

簡單切片表達(dá)式

切片的底層就是一個(gè)數(shù)組,所以我們可以基于數(shù)組通過切片表達(dá)式得到切片。

切片表達(dá)式中的lowhigh表示一個(gè)索引范圍(左包含,右不包含),也就是下面代碼中從數(shù)組a中選出1<=索引值<4的元素組成切片s,得到的切片長度=high-low容量等于得到的切片的底層數(shù)組的容量。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  // s := a[low:high]
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
}

運(yùn)行結(jié)果:

s:[2 3] len(s):2 cap(s):4

為了方便起見,可以省略切片表達(dá)式中的任何索引。

省略了low則默認(rèn)為0;省略了high則默認(rèn)為切片操作數(shù)的長度:

a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]

注意:

對于數(shù)組或字符串,如果0 <= low <= high <= len(a),則索引合法,否則就會(huì)索引越界(out of range)。

對切片再執(zhí)行切片表達(dá)式時(shí)(切片再切片),high的上限邊界是切片的容量cap(a),而不是長度。

常量索引必須是非負(fù)的,并且可以用int類型的值表示;對于數(shù)組或常量字符串,常量索引也必須在有效范圍內(nèi)。

如果lowhigh兩個(gè)指標(biāo)都是常數(shù),它們必須滿足low <= high。如果索引在運(yùn)行時(shí)超出范圍,就會(huì)發(fā)生運(yùn)行時(shí)panic。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  // s := a[low:high]
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
	s2 := s[3:4]  // 索引的上限是cap(s)而不是len(s)
	fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))
}

輸出:

s:[2 3] len(s):2 cap(s):4
s2:[5] len(s2):1 cap(s2):1

完整切片表達(dá)式

對于數(shù)組,指向數(shù)組的指針,或切片a(注意不能是字符串)支持完整切片表達(dá)式:

a[low : high : max]

上面的代碼會(huì)構(gòu)造與簡單切片表達(dá)式a[low: high]相同類型、相同長度和元素的切片。另外,它會(huì)將得到的結(jié)果切片的容量設(shè)置為max-low。在完整切片表達(dá)式中只有第一個(gè)索引值(low)可以省略;它默認(rèn)為0。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	t := a[1:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t, len(t), cap(t))
}

運(yùn)行結(jié)果:

t:[2 3] len(t):2 cap(t):4

完整切片表達(dá)式需要滿足的條件是0 <= low <= high <= max <= cap(a),其他條件和簡單切片表達(dá)式相同。

2.4 使用make()函數(shù)構(gòu)造切片

上面都是基于數(shù)組來創(chuàng)建的切片,如果需要?jiǎng)討B(tài)的創(chuàng)建一個(gè)切片,就需要使用內(nèi)置的make()函數(shù),

格式如下:

make([]T, size, cap)

說明:

  • T:切片的元素類型
  • size:切片中元素的數(shù)量
  • cap:切片的容量

示例:

func main() {
	a := make([]int, 2, 10)
	fmt.Println(a)      //[0 0]
	fmt.Println(len(a)) //2
	fmt.Println(cap(a)) //10
}

上面代碼中a的內(nèi)部存儲(chǔ)空間已經(jīng)分配了10個(gè),但實(shí)際上只用了2個(gè)。 容量并不會(huì)影響當(dāng)前元素的個(gè)數(shù),所以len(a)返回2,cap(a)則返回該切片的容量。

提示:

使用 make() 函數(shù)生成的切片一定發(fā)生了內(nèi)存分配操作,但給定開始與結(jié)束位置(包括切片復(fù)位)的切片只是將新的切片結(jié)構(gòu)指向已經(jīng)分配好的內(nèi)存區(qū)域,設(shè)定開始與結(jié)束位置,不會(huì)發(fā)生內(nèi)存分配操作。

2.5 for range循環(huán)迭代切片

for range可以用來迭代切片里的每一個(gè)元素,如下所示:

func main(){
	// 創(chuàng)建一個(gè)整型切片,并賦值
	slice := []int{10, 20, 30, 40}
	// 迭代每一個(gè)元素,并顯示其值
	for index, value := range slice {
		fmt.Printf("Index: %d Value: %d\n", index, value)
	}
}

運(yùn)行結(jié)果:

Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40

  • index:表示每一個(gè)元素的索引
  • value:表示每一個(gè)元素的值

當(dāng)?shù)衅瑫r(shí),for range 會(huì)返回兩個(gè)值,第一個(gè)值是當(dāng)前迭代到的索引位置,第二個(gè)值是該位置對應(yīng)元素值的一份副本,如下圖所示。

注意 for range 返回的是每個(gè)元素的副本,而不是直接返回對該元素的引用。

示例:

func main(){
	// 創(chuàng)建一個(gè)整型切片,并賦值
	slice := []int{10, 20, 30, 40}
	// 迭代每個(gè)元素,并顯示值和地址
	for index, value := range slice {
		fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n", value, &value, &slice[index])
	}
}

運(yùn)行結(jié)果:

Value: 10 Value-Addr: C00009E058 ElemAddr: C00009C120
Value: 20 Value-Addr: C00009E058 ElemAddr: C00009C128
Value: 30 Value-Addr: C00009E058 ElemAddr: C00009C130
Value: 40 Value-Addr: C00009E058 ElemAddr: C00009C138

因?yàn)榈祷氐淖兞渴且粋€(gè)在迭代過程中根據(jù)切片依次賦值的新變量,所以 value 的地址總是相同的,要想獲取每個(gè)元素的地址,需要使用切片變量和索引值(例如上面代碼中的 &slice[index])。

如果不需要索引值,也可以使用下劃線_來忽略這個(gè)值,

代碼如下所示:

func main(){
	// 創(chuàng)建一個(gè)整型切片,并賦值
	slice := []int{10, 20, 30, 40}
	// 迭代每個(gè)元素,并顯示其值
	for _, value := range slice {
		fmt.Printf("Value: %d\n", value)
	}
}

運(yùn)行結(jié)果;

Value: 10
Value: 20
Value: 30
Value: 40

for range 總是會(huì)從切片頭部開始迭代。如果想對迭代做更多的控制,則可以使用傳統(tǒng)的 for 循環(huán),

代碼如下所示:

func main(){
	// 創(chuàng)建一個(gè)整型切片,并賦值
	slice := []int{10, 20, 30, 40}
	// 從第三個(gè)元素開始迭代每個(gè)元素
	for index := 2; index < len(slice); index++ {
		fmt.Printf("Index: %d Value: %d\n", index, slice[index])
	}
}

運(yùn)行結(jié)果:

Index: 2 Value: 30
Index: 3 Value: 40

for range不僅僅可以用來遍歷切片,它還可以用來遍歷數(shù)組、字符串、map 或者通道等。

2.6 切片的本質(zhì)

切片的本質(zhì)就是對底層數(shù)組的封裝,它包含了三個(gè)信息:底層數(shù)組的指針、切片的長度(len)和切片的容量(cap)。

舉個(gè)例子,現(xiàn)在有一個(gè)數(shù)組a := [8]int{0, 1, 2, 3, 4, 5, 6, 7},切片s1 := a[:5],

相應(yīng)示意圖如下:

切片s2 := a[3:6],相應(yīng)示意圖如下:

2.7 判斷切片是否為空

要檢查切片是否為空,請始終使用len(s) == 0來判斷,而不應(yīng)該使用s == nil來判斷。

三、切片功能操作

3.1 切片不能直接比較

切片之間是不能比較的,我們不能使用==操作符來判斷兩個(gè)切片是否含有全部相等元素。 切片唯一合法的比較操作是和nil比較。 一個(gè)nil值的切片并沒有底層數(shù)組,一個(gè)nil值的切片的長度和容量都是0。

但是我們不能說一個(gè)長度和容量都是0的切片一定是nil

例如下面的示例:

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判斷一個(gè)切片是否是空的,要是用len(s) == 0來判斷,不應(yīng)該使用s == nil來判斷。

3.2 切片的賦值拷貝

下面的代碼中演示了拷貝前后兩個(gè)變量共享底層數(shù)組,對一個(gè)切片的修改會(huì)影響另一個(gè)切片的內(nèi)容,這點(diǎn)需要特別注意。

func main() {
	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //將s1直接賦值給s2,s1和s2共用一個(gè)底層數(shù)組
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]
}

由于切片是引用類型,所以s1和s2其實(shí)都指向了同一塊內(nèi)存地址。修改s2的同時(shí)s1的值也會(huì)發(fā)生變化。

3.3 使用copy()函數(shù)復(fù)制切片

Go語言內(nèi)建的copy()函數(shù)可以迅速地將一個(gè)切片的數(shù)據(jù)復(fù)制到另外一個(gè)切片空間中,copy()函數(shù)的使用格式如下:

copy( destSlice, srcSlice []T) int
  • srcSlice: 數(shù)據(jù)來源切片
  • destSlice: 目標(biāo)切片

copy()函數(shù)就是將 srcSlice 復(fù)制到 destSlice,目標(biāo)切片必須分配過空間且足夠承載復(fù)制的元素個(gè)數(shù),并且來源和目標(biāo)的類型必須一致,copy() 函數(shù)的返回值表示實(shí)際發(fā)生復(fù)制的元素個(gè)數(shù)。

示例

func main(){
	slice1 := []int{1, 2, 3, 4, 5}
	slice2 := []int{5, 4, 3}
	//copy(slice2, slice1) // 只會(huì)復(fù)制slice1的前3個(gè)元素到slice2中
	copy(slice1, slice2) // 只會(huì)復(fù)制slice2的3個(gè)元素到slice1的前3個(gè)位置
	for _, value := range slice1 {
		fmt.Printf("%d \t", value)
	}
	//for _, value := range slice2 {
	//	fmt.Printf("%d \t", value)
	//}
}

雖然通過循環(huán)復(fù)制切片元素更直接,不過內(nèi)置的 copy() 函數(shù)使用起來更加方便,copy() 函數(shù)的第一個(gè)參數(shù)是要復(fù)制的目標(biāo) slice,第二個(gè)參數(shù)是源 slice,兩個(gè) slice 可以共享同一個(gè)底層數(shù)組,甚至有重疊也沒有問題。

示例:

func main() {
	// 設(shè)置元素?cái)?shù)量為1000
	const elementCount = 1000
	// 預(yù)分配足夠多的元素切片
	srcData := make([]int, elementCount)
	// 將切片賦值
	for i := 0; i < elementCount; i++ {
		srcData[i] = i
	}
	// 引用切片數(shù)據(jù)
	refData := srcData
	// 預(yù)分配足夠多的元素切片
	copyData := make([]int, elementCount)
	// 將數(shù)據(jù)復(fù)制到新的切片空間中
	copy(copyData, srcData)
	// 修改原始數(shù)據(jù)的第一個(gè)元素
	srcData[0] = 999
	// 打印引用切片的第一個(gè)元素
	fmt.Println(refData[0])
	// 打印復(fù)制切片的第一個(gè)和最后一個(gè)元素
	fmt.Println(copyData[0], copyData[elementCount-1])
	// 復(fù)制原始數(shù)據(jù)從4到6(不包含)
	copy(copyData, srcData[4:6])
	for i := 0; i < 5; i++ {
		fmt.Printf("%d ", copyData[i])
	}
}

運(yùn)行結(jié)果:

999
0 999
4 5 2 3 4 

3.4 append()方法為切片添加元素

Go語言的內(nèi)建函數(shù)append()可以為切片動(dòng)態(tài)添加元素。 可以一次添加一個(gè)元素,可以添加多個(gè)元素,也可以添加另一個(gè)切片中的元素(后面加…)。

func main(){
	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4]
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]
}

注意:通過var聲明的零值切片可以在append()函數(shù)直接使用,無需初始化。

var s []int
s = append(s, 1, 2, 3)

沒有必要像下面的代碼一樣初始化一個(gè)切片再傳入append()函數(shù)使用。

s := []int{}  // 沒有必要初始化
s = append(s, 1, 2, 3)

var s = make([]int)  // 沒有必要初始化
s = append(s, 1, 2, 3)

每個(gè)切片會(huì)指向一個(gè)底層數(shù)組,這個(gè)數(shù)組的容量夠用就添加新增元素。當(dāng)?shù)讓訑?shù)組不能容納新增的元素時(shí),切片就會(huì)自動(dòng)按照一定的策略進(jìn)行“擴(kuò)容”,此時(shí)該切片指向的底層數(shù)組就會(huì)更換。“擴(kuò)容”操作往往發(fā)生在append()函數(shù)調(diào)用時(shí),所以我們通常都需要用原變量接收append函數(shù)的返回值。

示例:

func main() {
	//append()添加元素和切片擴(kuò)容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

運(yùn)行結(jié)果:

[0]  len:1  cap:1  ptr:0xc00009e058
[0 1]  len:2  cap:2  ptr:0xc00009e0a0
[0 1 2]  len:3  cap:4  ptr:0xc00009c140
[0 1 2 3]  len:4  cap:4  ptr:0xc00009c140
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b2100
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000d0080
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000d0080

從上面的結(jié)果可以看出:

  • append()函數(shù)將元素追加到切片的最后并返回該切片。
  • 切片numSlice的容量按照1,2,4,8,16這樣的規(guī)則自動(dòng)進(jìn)行擴(kuò)容,每次擴(kuò)容后都是擴(kuò)容前的2倍。

append()函數(shù)還支持一次性追加多個(gè)元素。

示例

var citySlice []string
// 追加一個(gè)元素
citySlice = append(citySlice, "北京")
// 追加多個(gè)元素
citySlice = append(citySlice, "上海", "廣州", "深圳")
// 追加切片
a := []string{"成都", "重慶"}
citySlice = append(citySlice, a...)
fmt.Println(citySlice) //[北京 上海 廣州 深圳 成都 重慶]

3.5 從切片中刪除元素

Go語言并沒有對刪除切片元素提供專用的語法或者接口,需要使用切片本身的特性來刪除元素,根據(jù)要?jiǎng)h除元素的位置有三種情況,分別是從開頭位置刪除、從中間位置刪除和從尾部刪除,其中刪除切片尾部的元素速度最快。

從開頭位置刪除

刪除開頭的元素可以直接移動(dòng)數(shù)據(jù)指針:

a = []int{1, 2, 3}
a = a[1:] // 刪除開頭1個(gè)元素
a = a[N:] // 刪除開頭N個(gè)元素

也可以不移動(dòng)數(shù)據(jù)指針,但是將后面的數(shù)據(jù)向開頭移動(dòng),可以用 append 原地完成(所謂原地完成是指在原有的切片數(shù)據(jù)對應(yīng)的內(nèi)存區(qū)間內(nèi)完成,不會(huì)導(dǎo)致內(nèi)存空間結(jié)構(gòu)的變化):

a = []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 刪除開頭1個(gè)元素
a = append(a[:0], a[N:]...) // 刪除開頭N個(gè)元素

還可以用 copy() 函數(shù)來刪除開頭的元素:

a = []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 刪除開頭1個(gè)元素
a = a[:copy(a, a[N:])] // 刪除開頭N個(gè)元素

從中間位置刪除

對于刪除中間的元素,需要對剩余的元素進(jìn)行一次整體挪動(dòng),同樣可以用 append 或 copy 原地完成:

a = []int{1, 2, 3, ...}
a = append(a[:i], a[i+1:]...) // 刪除中間1個(gè)元素
a = append(a[:i], a[i+N:]...) // 刪除中間N個(gè)元素
a = a[:i+copy(a[i:], a[i+1:])] // 刪除中間1個(gè)元素
a = a[:i+copy(a[i:], a[i+N:])] // 刪除中間N個(gè)元素

從尾部刪除

a = []int{1, 2, 3}
a = a[:len(a)-1] // 刪除尾部1個(gè)元素
a = a[:len(a)-N] // 刪除尾部N個(gè)元素

刪除開頭的元素和刪除尾部的元素都可以認(rèn)為是刪除中間元素操作的特殊情況,下面來看一個(gè)示例。

示例:

刪除切片指定位置的元素

func main(){
	seq := []string{"a", "b", "c", "d", "e"}

	// 指定刪除位置
	index := 2

	// 查看刪除位置之前的元素和之后的元素
	fmt.Println(seq[:index], seq[index+1:])

	// 將刪除點(diǎn)前后的元素連接起來
	seq = append(seq[:index], seq[index+1:]...)

	fmt.Println(seq)
}

運(yùn)行結(jié)果:

[a b] [d e]
[a b d e]

代碼的刪除過程可以使用下圖來描述:

Go語言中刪除切片元素的本質(zhì)是,以被刪除元素為分界點(diǎn),將前后兩個(gè)部分的內(nèi)存重新連接起來。

3.6 切片的擴(kuò)容策略

可以通過查看$GOROOT/src/runtime/slice.go源碼,其中擴(kuò)容相關(guān)代碼如下:

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

從上面的代碼可以看出以下內(nèi)容:

  • 首先判斷,如果新申請容量(cap)大于2倍的舊容量(old.cap),最終容量(newcap)就是新申請的容量(cap)。
  • 否則判斷,如果舊切片的長度小于1024,則最終容量(newcap)就是舊容量(old.cap)的兩倍,即(newcap=doublecap),
  • 否則判斷,如果舊切片長度大于等于1024,則最終容量(newcap)從舊容量(old.cap)開始循環(huán)增加原來的1/4,即(newcap=old.cap,for {newcap += newcap/4})直到最終容量(newcap)大于等于新申請的容量(cap),即(newcap >= cap)
  • 如果最終容量(cap)計(jì)算值溢出,則最終容量(cap)就是新申請容量(cap)。

需要注意的是,切片擴(kuò)容還會(huì)根據(jù)切片中元素的類型不同而做不同的處理,比如intstring類型的處理方式就不一樣。

到此這篇關(guān)于Golang切片Slice功能操作詳情的文章就介紹到這了,更多相關(guān)Golang切片內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

  • Golang map如何生成有序的json數(shù)據(jù)詳解

    Golang map如何生成有序的json數(shù)據(jù)詳解

    最近在學(xué)習(xí)Golang,發(fā)現(xiàn)了一個(gè)問題,覺著有必要給大家總結(jié)下,下面這篇文章主要給大家介紹了關(guān)于Golang map如何生成有序json數(shù)據(jù)的相關(guān)資料,文中通過示例代碼介紹的非常詳細(xì),需要的朋友們下面來一起看看吧。
    2017-07-07
  • go語言區(qū)塊鏈學(xué)習(xí)調(diào)用以太坊

    go語言區(qū)塊鏈學(xué)習(xí)調(diào)用以太坊

    這篇文章主要為大家介紹了go語言區(qū)塊鏈學(xué)習(xí)如何調(diào)用以太坊的示例實(shí)現(xiàn)過程,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步
    2021-10-10
  • golang?防緩存擊穿singleflight的實(shí)現(xiàn)

    golang?防緩存擊穿singleflight的實(shí)現(xiàn)

    本文主要介紹了golang?防緩存擊穿singleflight的實(shí)現(xiàn),文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2022-08-08
  • Go語言變量創(chuàng)建的五種方法

    Go語言變量創(chuàng)建的五種方法

    這篇文章主要介紹了Go語言五種變量創(chuàng)建的方法,本文給大家提到了匿名變量的優(yōu)點(diǎn),通過實(shí)例代碼給大家介紹的非常詳細(xì),需要的朋友可以參考下
    2020-02-02
  • Go?viper讀取配置文件的示例詳解

    Go?viper讀取配置文件的示例詳解

    這篇文章主要為大家詳細(xì)介紹了Go語言如何利用viper實(shí)現(xiàn)讀取配置文件,文中的示例代碼講解詳細(xì),具有一定的借鑒價(jià)值,需要的可以參考一下
    2023-08-08
  • Go調(diào)用opencv實(shí)現(xiàn)圖片矯正的代碼示例

    Go調(diào)用opencv實(shí)現(xiàn)圖片矯正的代碼示例

    這篇文章主要為大家詳細(xì)介紹了Go調(diào)用opencv實(shí)現(xiàn)圖片矯正的代碼示例,文中的示例代碼簡潔易懂,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下
    2023-09-09
  • 一文帶你掌握Golang中的值類型和引用類型

    一文帶你掌握Golang中的值類型和引用類型

    在?Golang?中,數(shù)據(jù)類型可以分為兩大類:值類型(Value?Types)和引用類型(Reference?Types),理解這兩種類型的區(qū)別對于理解?Golang?中的數(shù)據(jù)傳遞和內(nèi)存管理是很重要的,下面就跟隨小編一起深入了解一下它們吧
    2024-01-01
  • Go的os/exec執(zhí)行超時(shí)導(dǎo)致程序死機(jī)的解決方案

    Go的os/exec執(zhí)行超時(shí)導(dǎo)致程序死機(jī)的解決方案

    這篇文章主要介紹了Go的os/exec執(zhí)行超時(shí)導(dǎo)致程序死機(jī)的幾種解決方案,文中通過代碼示例給大家介紹的非常詳細(xì),對大家的學(xué)習(xí)或工作有一定的幫助,需要的朋友可以參考下
    2024-04-04
  • Go json反序列化“null“的問題解決

    Go json反序列化“null“的問題解決

    本文主要介紹了Go json反序列化“null“的問題解決,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
    2023-03-03
  • go語言中iota和左移右移的使用說明

    go語言中iota和左移右移的使用說明

    這篇文章主要介紹了go語言中iota和左移右移的使用說明,具有很好的參考價(jià)值,希望對大家有所幫助。一起跟隨小編過來看看吧
    2021-05-05

最新評論