自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

[]*T *[]T *[]*T 傻傻分不清楚

作者： crossoverJie
開發(fā) 后端
相信使用過(guò)切片會(huì)發(fā)現(xiàn)非常類似于 Java 中的 ArrayList，同樣是基于數(shù)組實(shí)現(xiàn)，也會(huì)擴(kuò)容發(fā)生數(shù)據(jù)拷貝；這樣看來(lái)語(yǔ)言只是上層使用的選擇，一些通用的底層實(shí)現(xiàn)大家都差不多。

[[413416]]

本文轉(zhuǎn)載自微信公眾號(hào)「crossoverJie」，作者crossoverJie。轉(zhuǎn)載本文請(qǐng)聯(lián)系crossoverJie公眾號(hào)。

前言

作為一個(gè) Go 語(yǔ)言新手，看到一切”詭異“的代碼都會(huì)感到好奇;比如我最近看到的幾個(gè)方法;偽代碼如下：

  1. func FindA() ([]*T,error) { 
  2. } 
  3.  
  4. func FindB() ([]T,error) { 
  5. } 
  6.  
  7. func SaveA(data *[]T) error { 
  8. } 
  9.  
  10. func SaveB(data *[]*T) error { 
  11. } 

相信大部分剛?cè)腴T Go 的新手看到這樣的代碼也是一臉懵逼，其中最讓人疑惑的就是：

  1. []*T 
  2. *[]T 
  3. *[]*T 

這樣對(duì)切片的聲明，先不看后面兩種寫法;單獨(dú)看 []*T 還是很好理解的：該切片中存放的是所有 T 的內(nèi)存地址，會(huì)比存放 T 本身來(lái)說(shuō)要更省空間，同時(shí) []*T 在方法內(nèi)部是可以修改 T 的值，而[]T 是修改不了。

  1. func TestSaveSlice(t *testing.T) { 
  2.  a := []T{{Name: "1"}, {Name: "2"}} 
  3.  for _, t2 := range a { 
  4.   fmt.Println(t2) 
  5.  } 
  6.  _ = SaveB(a) 
  7.  for _, t2 := range a { 
  8.   fmt.Println(t2) 
  9.  } 
  10.  
  11. } 
  12. func SaveB(data []T) error { 
  13.  t := data[0] 
  14.  t.Name = "1233" 
  15.  return nil 
  16. } 
  17.  
  18. type T struct { 
  19.  Name string 
  20. } 

比如以上例子打印的是

  1. {1} 
  2. {2} 
  3. {1} 
  4. {2} 

只有將方法修改為

  1. func SaveB(data []*T) error { 
  2.  t := data[0] 
  3.  t.Name = "1233" 
  4.  return nil 
  5. } 

才能修改 T 的值:

  1. &{1} 
  2. &{2} 
  3. &{1233} 
  4. &{2} 

示例

下面重點(diǎn)來(lái)看看 []*T 與 *[]T 的區(qū)別，這里寫了兩個(gè) append 函數(shù)：

  1. func TestAppendA(t *testing.T) { 
  2.  x:=[]int{1,2,3} 
  3.  appendA(x) 
  4.  fmt.Printf("main %v\n", x) 
  5. } 
  6. func appendA(x []int) { 
  7.  x[0]= 100 
  8.  fmt.Printf("appendA %v\n", x) 
  9. } 

先看第一種，輸出是結(jié)果是：

  1. appendA [1000 2 3] 
  2. main [1000 2 3] 

說(shuō)明在函數(shù)傳遞過(guò)程中，函數(shù)內(nèi)部的修改能夠影響到外部。

下面我們?cè)倏匆粋€(gè)例子：

  1. func appendB(x []int) { 
  2.  x = append(x, 4) 
  3.  fmt.Printf("appendA %v\n", x) 
  4. } 

最終結(jié)果卻是：

  1. appendA [1 2 3 4] 
  2. main [1 2 3] 

沒(méi)有影響到外部。

而當(dāng)我們?cè)僬{(diào)整一下會(huì)發(fā)現(xiàn)又有所不同：

  1. func TestAppendC(t *testing.T) { 
  2.  x:=[]int{1,2,3} 
  3.  appendC(&x) 
  4.  fmt.Printf("main %v\n", x) 
  5. } 
  6. func appendC(x *[]int) { 
  7.  *x = append(*x, 4) 
  8.  fmt.Printf("appendA %v\n", x) 
  9. } 

最終的結(jié)果：

  1. appendA &[1 2 3 4] 
  2. main [1 2 3 4] 

可以發(fā)現(xiàn)如果傳遞切片的指針時(shí)，使用 append 函數(shù)追加數(shù)據(jù)時(shí)會(huì)影響到外部。

slice 原理

在分析上面三種情況之前，我們先來(lái)了解下 slice 的數(shù)據(jù)結(jié)構(gòu)。

直接查看源碼會(huì)發(fā)現(xiàn) slice 其實(shí)就是一個(gè)結(jié)構(gòu)體，只是不能直接對(duì)外訪問(wèn)。

源碼地址 runtime/slice.go

其中有三個(gè)重要的屬性：

屬性 含義
array 底層存放數(shù)據(jù)的數(shù)組，是一個(gè)指針。
len 切片長(zhǎng)度
cap 切片容量 cap>=len

提到切片就不得不想到數(shù)組，可以這么理解：

切片是對(duì)數(shù)組的抽象，而數(shù)組則是切片的底層實(shí)現(xiàn)。

其實(shí)通過(guò)切片這個(gè)名字也不難看出，它就是從數(shù)組中切了一部分;相對(duì)于數(shù)組的固定大小，切片可以根據(jù)實(shí)際使用情況進(jìn)行擴(kuò)容。

所以切片也可以通過(guò)對(duì)數(shù)組"切一刀"獲得：

  1. x1:=[6]int{0,1,2,3,4,5} 
  2. x2 := x[1:4] 
  3. fmt.Println(len(x2), cap(x2)) 

其中 x1 的長(zhǎng)度與容量都是6。

  • x2 的長(zhǎng)度與容量則為3和5。
  • x2 的長(zhǎng)度很容易理解。

容量等于5可以理解為，當(dāng)前這個(gè)切片最多可以使用的長(zhǎng)度。

因?yàn)榍衅?x2 是對(duì)數(shù)組 x1 的引用，所以底層數(shù)組排除掉左邊一個(gè)沒(méi)有被引用的位置則是該切片最大的容量，也就是5。

同一個(gè)底層數(shù)組

以剛才的代碼為例：

  1. func TestAppendA(t *testing.T) { 
  2.  x:=[]int{1,2,3} 
  3.  appendA(x) 
  4.  fmt.Printf("main %v\n", x) 
  5. } 
  6. func appendA(x []int) { 
  7.  x[0]= 100 
  8.  fmt.Printf("appendA %v\n", x) 
  9. } 

在函數(shù)傳遞過(guò)程中，main 中的 x 與 appendA 函數(shù)中的 x 切片所引用的是同個(gè)數(shù)組。

所以在函數(shù)中對(duì) x[0]=100，main函數(shù)中也能獲取到。

本質(zhì)上修改的就是同一塊內(nèi)存數(shù)據(jù)。

值傳遞帶來(lái)的誤會(huì)

在上述例子中，在 appendB 中調(diào)用 append 函數(shù)追加數(shù)據(jù)后會(huì)發(fā)現(xiàn) main 函數(shù)中并沒(méi)有受到影響，這里我稍微調(diào)整了一下示例代碼：

  1. func TestAppendB(t *testing.T) { 
  2.  //x:=[]int{1,2,3} 
  3.  x := make([]int, 3,5) 
  4.  x[0] = 1 
  5.  x[1] = 2 
  6.  x[2] = 3 
  7.  appendB(x) 
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  9. } 
  10. func appendB(x []int) { 
  11.  x = append(x, 444) 
  12.  fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  13. } 

主要是修改了切片初始化方式，使得容量大于了長(zhǎng)度，具體原因后續(xù)會(huì)說(shuō)明。

輸出結(jié)果如下：

  1. appendB [1 2 3 444] len=4,cap=5 
  2. main [1 2 3] len=3,cap=5 

main 函數(shù)中的數(shù)據(jù)看樣子確實(shí)沒(méi)有受到影響;但細(xì)心的朋友應(yīng)該會(huì)注意到 appendB 函數(shù)中的 x 在 append() 之后長(zhǎng)度 +1 變?yōu)榱?。

而在 main 函數(shù)中長(zhǎng)度又變回了3.

這個(gè)細(xì)節(jié)區(qū)別就是為什么 append() "看似" 沒(méi)有生效的原因;至于為什么要說(shuō)“看似”，再次調(diào)整了代碼：

  1. func TestAppendB(t *testing.T) { 
  2.  //x:=[]int{1,2,3} 
  3.  x := make([]int, 3,5) 
  4.  x[0] = 1 
  5.  x[1] = 2 
  6.  x[2] = 3 
  7.  appendB(x) 
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  9.  
  10.  y:=x[0:cap(x)] 
  11.  fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y)) 
  12. } 

在剛才的基礎(chǔ)之上，以 append 之后的 x 為基礎(chǔ)再做了一個(gè)切片;該切片的范圍為 x 所引用數(shù)組的全部數(shù)據(jù)。

再來(lái)看看執(zhí)行結(jié)果如何：

  1. appendB [1 2 3 444] len=4,cap=5 
  2. main [1 2 3] len=3,cap=5 
  3. y [1 2 3 444 0] len=5,cap=5 

會(huì)神奇的發(fā)現(xiàn) y 將所有數(shù)據(jù)都打印出來(lái)，在 appendB 函數(shù)中追加的數(shù)據(jù)其實(shí)已經(jīng)寫入了數(shù)組中，但為什么 x 本身沒(méi)有獲取到呢?

看圖就很容易理解了：

  • 在appendB中確實(shí)是對(duì)原始數(shù)組追加了數(shù)據(jù)，同時(shí)長(zhǎng)度也增加了。
  • 但由于是值傳遞，所以 slice 這個(gè)結(jié)構(gòu)體即便是修改了長(zhǎng)度為4，也只是對(duì)復(fù)制的那個(gè)對(duì)象修改了長(zhǎng)度，main 中的長(zhǎng)度依然為3.
  • 由于底層數(shù)組是同一個(gè)，所以基于這個(gè)底層數(shù)組重新生成了一個(gè)完整長(zhǎng)度的切片便能看到追加的數(shù)據(jù)了。

所以這里本質(zhì)的原因是因?yàn)?slice 是一個(gè)結(jié)構(gòu)體，傳遞的是值，不管方法里如何修改長(zhǎng)度也不會(huì)影響到原有的數(shù)據(jù)(這里指的是長(zhǎng)度和容量這兩個(gè)屬性)。

切片擴(kuò)容

還有一個(gè)需要注意：

剛才特意提到這里的例子稍有改變，主要是將切片的容量設(shè)置超過(guò)了數(shù)組的長(zhǎng)度;

如果不做這個(gè)特殊設(shè)置會(huì)怎么樣呢?

  1. func TestAppendB(t *testing.T) { 
  2.  x:=[]int{1,2,3} 
  3.  //x := make([]int, 3,5) 
  4.  x[0] = 1 
  5.  x[1] = 2 
  6.  x[2] = 3 
  7.  appendB(x) 
  8.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  9.  
  10.  y:=x[0:cap(x)] 
  11.  fmt.Printf("y %v len=%v,cap=%v\n", y,len(y),cap(y)) 
  12. } 
  13. func appendB(x []int) { 
  14.  x = append(x, 444) 
  15.  fmt.Printf("appendB %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  16. } 

輸出結(jié)果：

  1. appendB [1 2 3 444] len=4,cap=6 
  2. main [1 2 3] len=3,cap=3 
  3. y [1 2 3] len=3,cap=3 

這時(shí)會(huì)發(fā)現(xiàn) main 函數(shù)中的 y 切片數(shù)據(jù)也沒(méi)有發(fā)生變化，這是為什么呢?

這是因?yàn)槌跏蓟?x 切片時(shí)長(zhǎng)度和容量都為3，當(dāng)在 appendB 函數(shù)中追加數(shù)據(jù)時(shí)，會(huì)發(fā)現(xiàn)沒(méi)有位置了。

  • 這時(shí)便會(huì)進(jìn)行擴(kuò)容：
  • 將老數(shù)據(jù)復(fù)制一份到新的數(shù)組中。
  • 追加數(shù)據(jù)。

將新的數(shù)據(jù)內(nèi)存地址返回給 appendB 中的 x .

同樣的由于是值傳遞，所以 appendB 中的切片換了底層數(shù)組對(duì) main 函數(shù)中的切片沒(méi)有任何影響，也就導(dǎo)致最終 main 函數(shù)的數(shù)據(jù)沒(méi)有任何變化了。

傳遞切片指針

有沒(méi)有什么辦法即便是在擴(kuò)容時(shí)也能對(duì)外部產(chǎn)生影響呢?

  1. func TestAppendC(t *testing.T) { 
  2.  x:=[]int{1,2,3} 
  3.  appendC(&x) 
  4.  fmt.Printf("main %v len=%v,cap=%v\n", x,len(x),cap(x)) 
  5. } 
  6. func appendC(x *[]int) { 
  7.  *x = append(*x, 4) 
  8.  fmt.Printf("appendC %v\n", x) 
  9. } 

輸出結(jié)果為：

  1. appendC &[1 2 3 4] 
  2. main [1 2 3 4] len=4,cap=6 

這時(shí)外部的切片就能受到影響了，其實(shí)原因也很簡(jiǎn)單;

剛才也說(shuō)了，因?yàn)?slice 本身是一個(gè)結(jié)構(gòu)體，所以當(dāng)我們傳遞指針時(shí)，就和平時(shí)自定義的 struct 在函數(shù)內(nèi)部通過(guò)指針修改數(shù)據(jù)原理相同。

最終在 appendC 中的 x 的指針指向了擴(kuò)容后的結(jié)構(gòu)體，因?yàn)閭鬟f的是 main 函數(shù)中 x 的指針，所以同樣的 main 函數(shù)中的 x 也指向了該結(jié)構(gòu)體。

總結(jié)

所以總結(jié)一下：

  • 切片是對(duì)數(shù)組的抽象，同時(shí)切片本身也是一個(gè)結(jié)構(gòu)體。
  • 參數(shù)傳遞時(shí)函數(shù)內(nèi)部與外部引用的是同一個(gè)數(shù)組，所以對(duì)切片的修改會(huì)影響到函數(shù)外部。
  • 如果發(fā)生擴(kuò)容，情況會(huì)發(fā)生變化，同時(shí)擴(kuò)容會(huì)導(dǎo)致數(shù)據(jù)拷貝;所以要盡量預(yù)估切片大小，避免數(shù)據(jù)拷貝。
  • 對(duì)切片或數(shù)組重新生成切片時(shí)，由于共享的是同一個(gè)底層數(shù)組，所以數(shù)據(jù)會(huì)互相影響，這點(diǎn)需要注意。
  • 切片也可以傳遞指針，但場(chǎng)景很少，還會(huì)帶來(lái)不必要的誤解;建議值傳值就好，長(zhǎng)度和容量占用不了多少內(nèi)存。

相信使用過(guò)切片會(huì)發(fā)現(xiàn)非常類似于 Java 中的 ArrayList，同樣是基于數(shù)組實(shí)現(xiàn)，也會(huì)擴(kuò)容發(fā)生數(shù)據(jù)拷貝;這樣看來(lái)語(yǔ)言只是上層使用的選擇，一些通用的底層實(shí)現(xiàn)大家都差不多。

 

這時(shí)我們?cè)倏礃?biāo)題中的 []*T *[]T *[]*T 就會(huì)發(fā)現(xiàn)這幾個(gè)并沒(méi)有什么聯(lián)系，只是看起來(lái)很像容易唬人。

 

責(zé)任編輯：武曉燕 來(lái)源： crossoverJie
JavaArrayList數(shù)組
相關(guān)推薦

2021-03-10 08:56:37

Zookeeper

2022-05-15 21:52:04

typeTypeScriptinterface

2024-02-29 09:08:56

Encoding算法加密

2020-10-30 08:20:04

SD卡TF卡存儲(chǔ)

2018-12-17 12:30:05

Kubernetes存儲(chǔ)存儲(chǔ)卷

2018-05-22 16:24:20

HashMapJavaJDK

2020-03-03 17:35:09

Full GCMinor

2023-02-27 15:46:19

數(shù)據(jù)元元數(shù)據(jù)

2023-09-03 21:18:07

Python編程語(yǔ)言

2021-02-08 23:47:51

文件存儲(chǔ)塊存儲(chǔ)對(duì)象存儲(chǔ)

2016-11-04 12:51:46

Unix網(wǎng)絡(luò)IO 模型

2022-02-25 09:14:33

類變量共享實(shí)例變量

2021-11-09 06:01:35

前端JITAOT

2024-11-04 00:00:03

viewportDOMSPA

2021-01-13 08:10:26

接口IEnumeratorIEnumerable

2020-11-11 07:32:18

MySQL InnoDB 存儲(chǔ)

2023-04-11 15:57:49

JavaScriptCSSHTML

2021-02-14 22:33:23

Java字符字段

2019-11-21 14:22:12

WiFiWLAN區(qū)別

2021-11-01 13:10:48

私有云混合云行業(yè)云
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號(hào)