Go語言 切片

因為陣列的長度是固定的並且陣列長度屬於型別的一部分，所以陣列有很多的侷限性。 例如：

func arraysum(x [3]int) int

return
sum}

a := [3]int

切片（slice）是乙個擁有相同型別元素的可變長度的序列。它是基於陣列型別做的一層封裝。它非常靈活，支援自動擴容。

切片是乙個引用型別，它的內部結構包含位址、長度和容量。切片一般用於快速地操作一塊資料集合。

//切片擁有陣列的所有特性

package main

import "fmt"func main()  
fmt.println(s)  //
[1 2 3]
fmt.printf("%t \n", s)  //
int    // 切片宣告方式二 從陣列中得到切片
var a = [3]int
c := a[0:3]
fmt.println(c)  //
[1 2 3]
fmt.printf("%t \n", c)  //
int}

package main

import "fmt"func main()  
s1 := a1[1:4]
//切片的大小 (切片內目前元素的數量)
fmt.println(len(s1))  //
3    // 切片的容量 (底層陣列最大能放多少元素)
fmt.println(cap(s1))  //
5  }

舉個例子，現在有乙個陣列a := [8]int，切片s1 := a[:5]，相應示意圖如下。

s2 := a[3:6]，相應示意圖如下：

func main() 

}

[0]  len:1  cap:1  ptr:0xc0000a8000[0 1]  len:2  cap:2  ptr:0xc0000a8040[0 1 2]  len:3  cap:4  ptr:0xc0000b2020[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

newcap := old.cap

doublecap := newcap +newcap
if cap >doublecap  
else
else
//set newcap to the requested cap when
// the newcap calculation overflowed.
if newcap <= 0}}

需要注意的是，切片擴容還會根據切片中元素的型別不同而做不同的處理，比如int和string型別的處理方式就不一樣

go語言內建的copy()函式可以迅速地將乙個切片的資料複製到另外乙個切片空間中，copy()函式的使用格式如下：

copy(destslice, srcslice t)

package main

import "fmt"func main
func test()  
b := a  //
直接賦值
var c int  //
定義乙個切片,還沒有申請記憶體
c = make(int, 3, 3)  //
為c切片申請記憶體 make(t, len, cap)
copy(c, a)  //
引數2是被copy物件
b[0] = 100fmt.println(a)  //
[100 2 3]
fmt.println(b)  //
[100 2 3]
fmt.println(c)  //
[1 2 3]
}

var c int  // 只定義,沒初始化,沒有記憶體

var c = int{}  // 定義,初始化,有記憶體

package main

import "fmt"func main
func test1()  
fmt.println(a)  //
[1 2 4 5 6 7]
}

package main

import "fmt"func main
func test2()  
b := a[:]
b[0] = 100fmt.println(a[0])  //
100  因為切片是引用型別
c := a[2:5]
d := c[:5]
fmt.println(c)  //
[3 4 5]
fmt.println(len(c))  //
3    fmt.println(cap(c))  //
5    fmt.println(d)  //
[3 4 5 6 7]
fmt.println(len(d))  //
5    fmt.println(cap(d))  //5}
c與d記憶體位址一樣,因為c與d的第乙個元素是同乙個
				
Go語言切片
go語言切片 go語言切片是對陣列的抽象 go 陣列的長度不可改變，在特定場景中這樣的集合就不太適用，go中提供了一種靈活，功能強悍的內建型別切片 動態陣列 與陣列相比切片的長度是不固定的，可以追加元素，在追加時可能使切片的容量增大。宣告乙個未指定大小的陣列來定義切片 var identifier ...
				
go語言  切片
一 概述 low 陣列下標的起點 high 陣列下標的結束點 不包括此點 arr low arr high len 長度 high low cap 容量 max low 二 切片的長度與容量 package main import fmt func main slice arr 0 3 5 fmt....
				
go語言切片
切片 slice 是乙個擁有相同型別元素的可變長度的序列，他是基於陣列型別做的一層封裝，非常靈活，支援自動擴容。切片是乙個引用型別，他的內容結構包含位址 長度 容量。用於快速操作一塊資料集合。切片的本質 對底層陣列的封裝，包含三個資訊 底層陣列的指標 切片的長度 切片的容量。1.切片定義 var n...