建站
咨詢
售后
建站咨詢
新聞中心
Golang 中數(shù)組（Array）和切片（Slice）的區(qū)別
Go 中數(shù)組的長度是不可改變的，而 Slice 解決的就是對不定長數(shù)組的需求。他們的區(qū)別主要有兩點。
公司主營業(yè)務：網(wǎng)站建設、成都網(wǎng)站建設、移動網(wǎng)站開發(fā)等業(yè)務。幫助企業(yè)客戶真正實現(xiàn)互聯(lián)網(wǎng)宣傳，提高企業(yè)的競爭能力。創(chuàng)新互聯(lián)建站是一支青春激揚、勤奮敬業(yè)、活力青春激揚、勤奮敬業(yè)、活力澎湃、和諧高效的團隊。公司秉承以“開放、自由、嚴謹、自律”為核心的企業(yè)文化，感謝他們對我們的高要求，感謝他們從不同領域給我們帶來的挑戰(zhàn)，讓我們激情的團隊有機會用頭腦與智慧不斷的給客戶帶來驚喜。創(chuàng)新互聯(lián)建站推出安吉免費做網(wǎng)站回饋大家。
數(shù)組：
切片：
注意 1
雖然數(shù)組在初始化時也可以不指定長度，但 Go 語言會根據(jù)數(shù)組中元素個數(shù)自動設置數(shù)組長度，并且不可改變。切片通過 append 方法增加元素：
如果將 append 用在數(shù)組上，你將會收到報錯：first argument to append must be slice。
注意 2
切片不只有長度（len）的概念，同時還有容量（cap）的概念。因此切片其實還有一個指定長度和容量的初始化方式：
這就初始化了一個長度為3，容量為5的切片。
此外，切片還可以從一個數(shù)組中初始化（可應用于如何將數(shù)組轉換成切片）：
上述例子通過數(shù)組 a 初始化了一個切片 s。
當切片和數(shù)組作為參數(shù)在函數(shù)（func）中傳遞時，數(shù)組傳遞的是值，而切片傳遞的是指針。因此當傳入的切片在函數(shù)中被改變時，函數(shù)外的切片也會同時改變。相同的情況，函數(shù)外的數(shù)組則不會發(fā)生任何變化。
go語言數(shù)組，切片和字典的區(qū)別和聯(lián)系
、數(shù)組
與其他大多數(shù)語言類似，Go語言的數(shù)組也是一個元素類型相同的定長的序列。
（1）數(shù)組的創(chuàng)建。
數(shù)組有3種創(chuàng)建方式：[length]Type 、[N]Type{value1, value2, ... , valueN}、[...]Type{value1, value2, ... , valueN} 如下：
復制代碼代碼如下:
func test5() {
var iarray1 [5]int32
var iarray2 [5]int32 = [5]int32{1, 2, 3, 4, 5}
iarray3 := [5]int32{1, 2, 3, 4, 5}
iarray4 := [5]int32{6, 7, 8, 9, 10}
iarray5 := [...]int32{11, 12, 13, 14, 15}
iarray6 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}
fmt.Println(iarray1)
fmt.Println(iarray2)
fmt.Println(iarray3)
fmt.Println(iarray4)
fmt.Println(iarray5)
fmt.Println(iarray6)
}
結果：
[0 0 0 0 0]
[1 2 3 4 5]
[1 2 3 4 5]
[6 7 8 9 10]
[11 12 13 14 15]
[[1 0 0 0] [1 2 0 0] [1 2 3 0] [0 0 0 0]]
我們看數(shù)組 iarray1，只聲明，并未賦值，Go語言幫我們自動賦值為0。再看 iarray2 和 iarray3 ，我們可以看到，Go語言的聲明，可以表明類型，也可以不表明類型，var iarray3 = [5]int32{1, 2, 3, 4, 5} 也是完全沒問題的。
（2）數(shù)組的容量和長度是一樣的。cap() 函數(shù)和 len() 函數(shù)均輸出數(shù)組的容量（即長度）。如：
復制代碼代碼如下:
func test6() {
iarray4 := [5]int32{6, 7, 8, 9, 10}
fmt.Println(len(iarray4))
fmt.Println(cap(iarray4))
}
輸出都是5。
（3）使用：
復制代碼代碼如下:
func test7() {
iarray7 := [5]string{"aaa", `bb`, "可以啦", "叫我說什么好", "()"}
fmt.Println(iarray7)
for i := range iarray7 {
fmt.Println(iarray7[i])
}
}
二、切片
Go語言中，切片是長度可變、容量固定的相同的元素序列。Go語言的切片本質是一個數(shù)組。容量固定是因為數(shù)組的長度是固定的，切片的容量即隱藏數(shù)組的長度。長度可變指的是在數(shù)組長度的范圍內可變。
（1）切片的創(chuàng)建。
切片的創(chuàng)建有4種方式：
1）make ( []Type ,length, capacity )
2) make ( []Type, length)
3) []Type{}
4) []Type{value1 , value2 , ... , valueN }
從3)、4)可見，創(chuàng)建切片跟創(chuàng)建數(shù)組唯一的區(qū)別在于 Type 前的“ [] ”中是否有數(shù)字，為空，則代表切片，否則則代表數(shù)組。因為切片是長度可變的。如下是創(chuàng)建切片的示例：
復制代碼代碼如下:
func test8() {
slice1 := make([]int32, 5, 8)
slice2 := make([]int32, 9)
slice3 := []int32{}
slice4 := []int32{1, 2, 3, 4, 5}
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
}
輸出為：
[0 0 0 0 0]
[0 0 0 0 0 0 0 0 0]
[]
[1 2 3 4 5]
如上，創(chuàng)造了4個切片，3個空切片，一個有值的切片。
（2）切片與隱藏數(shù)組：
一個切片是一個隱藏數(shù)組的引用，并且對于該切片的切片也引用同一個數(shù)組。如下示例，創(chuàng)建了一個切片slice0，并根據(jù)這個切片創(chuàng)建了2個切片 slice1 和 slice2：
復制代碼代碼如下:
func test9() {
slice0 := []string{"a", "b", "c", "d", "e"}
slice1 := slice0[2 : len(slice0)-1]
slice2 := slice0[:3]
fmt.Println(slice0, slice1, slice2)
slice2[2] = "8"
fmt.Println(slice0, slice1, slice2)
}
輸出為：
[a b c d e] [c d] [a b c]
[a b 8 d e] [8 d] [a b 8]
可見，切片slice0 、 slice1 和 slice2是同一個底層數(shù)組的引用，所以slice2改變了，其他兩個都會變。
（3）遍歷、修改切片：
復制代碼代碼如下:
func test10() {
slice0 := []string{"a", "b", "c", "d", "e"}
fmt.Println("\n~~~~~~元素遍歷~~~~~~")
for _, ele := range slice0 {
fmt.Print(ele, " ")
ele = "7"
}
fmt.Println("\n~~~~~~索引遍歷~~~~~~")
for index := range slice0 {
fmt.Print(slice0[index], " ")
}
fmt.Println("\n~~~~~~元素索引共同使用~~~~~~")
for index, ele := range slice0 {
fmt.Print(ele, slice0[index], " ")
}
fmt.Println("\n~~~~~~修改~~~~~~")
for index := range slice0 {
slice0[index] = "9"
}
fmt.Println(slice0)
}
如上，前三種循環(huán)使用了不同的for range循環(huán)，當for后面，range前面有2個元素時，第一個元素代表索引，第二個元素代表元素值，使用 “_” 則表示忽略，因為go語言中，未使用的值會導致編譯錯誤。
只有一個元素時，該元素代表索引。
只有用索引才能修改元素。如在第一個遍歷中，賦值ele為7，結果沒有作用。因為在元素遍歷中，ele是值傳遞，ele是該切片元素的副本，修改它不會影響原本值，而在第四個遍歷——索引遍歷中，修改的是該切片元素引用的值，所以可以修改。
結果為：
~~~~~~元素遍歷~~~~~~
a b c d e
~~~~~~索引遍歷~~~~~~
a b c d e
~~~~~~元素索引共同使用~~~~~~
aa bb cc dd ee
~~~~~~修改~~~~~~
[9 9 9 9 9]
（4）、追加、復制切片：
復制代碼代碼如下:
func test11() {
slice := []int32{}
fmt.Printf("slice的長度為：%d,slice為：%v\n", len(slice), slice)
slice = append(slice, 12, 11, 10, 9)
fmt.Printf("追加后，slice的長度為：%d,slice為：%v\n", len(slice), slice)
slicecp := make([]int32, (len(slice)))
fmt.Printf("slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
copy(slicecp, slice)
fmt.Printf("復制賦值后，slicecp的長度為：%d,slicecp為：%v\n", len(slicecp), slicecp)
}
追加、復制切片，用的是內置函數(shù)append和copy，copy函數(shù)返回的是最后所復制的元素的數(shù)量。
（5）、內置函數(shù)append
內置函數(shù)append可以向一個切片后追加一個或多個同類型的其他值。如果追加的元素數(shù)量超過了原切片容量，那么最后返回的是一個全新數(shù)組中的全新切片。如果沒有超過，那么最后返回的是原數(shù)組中的全新切片。無論如何，append對原切片無任何影響。如下示例：
復制代碼代碼如下:
func test12() {
slice := []int32{1, 2, 3, 4, 5, 6}
slice2 := slice[:2]
_ = append(slice2, 50, 60, 70, 80, 90)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
_ = append(slice2, 50, 60)
fmt.Printf("slice為：%v\n", slice)
fmt.Printf("操作的切片：%v\n", slice2)
}
如上，append方法用了2次，結果返回的結果完全不同，原因是第二次append方法追加的元素數(shù)量沒有超過 slice 的容量。而無論怎樣，原切片slice2都無影響。結果：
slice為：[1 2 3 4 5 6]
操作的切片：[1 2]
slice為：[1 2 50 60 5 6]
操作的切片：[1 2]
go和python切片的不同
go有切片slice類型，python有列表和元組，這兩種語言都有切片操作。
但是它們的切片操作是完全不同的。
首先說第一個，go的切片，其成員是相同類型的，python的列表和元組則不限制類型。
兩種語言都有[a:b]這種切片操作，意義也類似，但是go的a、b兩個參數(shù)不能是負數(shù)，python可以是負數(shù)，此時就相當于從末尾往前數(shù)。
兩種語言都有[a:b:c]這種切片操作，意義卻是完全不同的。go的c，表示的是容量；而python的c表示的是步長。
但是最大的不同，還是：
python的切片產(chǎn)生的是新的對象，對新對象的成員的操作不影響舊對象；go的切片產(chǎn)生的是舊對象一部分的引用，對其成員的操作會影響舊對象。
究其原因，還是底層實現(xiàn)的不同。
go的切片，底層是一個三元組，一個指針，一個長度，一個容量。指針指向一塊連續(xù)的內存，長度是已有成員數(shù)，容量是最大成員數(shù)。切片時，一般并不會申請新的內存，而是對原指針進行移動，然后和新的長度、容量組成一個切片類型值返回。也就是說，go的切片操作通常會和生成該切片的切片共用內存。
不僅是切片，字符串、數(shù)組的切片也是一樣的，通常會共用內存。
當然也有異常情況，那就是切片時，提供的容量過大，此時會申請新內存并拷貝；或者對切片append超出容量，也會如此。這時，新的切片，才不會和老切片共享內存。（如果你切片/創(chuàng)建時提供的容量小于長度，會panic）
python的列表，其實是個指針數(shù)組。當然在下層也會提供一些空位之類的，但基本就是個數(shù)組。對它們切片，會創(chuàng)建新的數(shù)組，注意，是創(chuàng)建新的數(shù)組！python的列表可沒有容量的概念。
這其實也體現(xiàn)了腳本語言和編譯語言的不同。雖然兩個語言都有類似的切片操作；但是python主要目標是方便；go主要目標卻是快速（并彌補丟棄指針運算的缺陷）。 a
go語言中實現(xiàn)切片(slice)的三種方式
定義一個切片，然后讓切片去引用一個已經(jīng)創(chuàng)建好的數(shù)組。基本語法如下：
索引1：切片引用的起始元素位
索引2：切片只引用該元素位之前的元素
例程如下：
在該方法中，我們未指定容量cap，這里的值為5是系統(tǒng)定義的。
在方法一中，可以用arr數(shù)組名來操控數(shù)組中的元素，也可以通過slice切片來操控數(shù)組中的元素。切片是直接引用數(shù)組，數(shù)組是事先存在的，程序員是可見的。
通過 make 來創(chuàng)建切片，基本語法如下：
make函數(shù)第三個參數(shù)cap即容量是可選的，如果一定要自己注明的話，要注意保證cap≥len。
用該方法可以 指定切片的大小(len)和容量(cap)
例程如下：
由于未賦值系統(tǒng)默認將元素值置為0，即：
數(shù)值類型數(shù)組：????默認值為 0
字符串數(shù)組：? ? ? ?默認值為 ""
bool數(shù)組：? ? ? ? ? ?默認值為 false
在方法二中，通過make方式創(chuàng)建的切片對應的數(shù)組是由make底層維護，對外不可見，即只能通過slice去訪問各個元素。
定義一個切片，直接就指定具體數(shù)組，使用原理類似于make的方式。
例程如下：
GO 語言 切片和底層數(shù)組的關系
//從數(shù)組中獲取 切片
span style="color:#c0c0c0;" /spanspan style="color:#000080;font-weight:600;"var/spanspan style="color:#c0c0c0;" /spansliceArrayspan style="color:#c0c0c0;" /spanspan style="color:#000000;"[/spanspan style="color:#800080;"10/spanspan style="color:#000000;"]/spanspan style="color:#000080;"int/spanspan style="color:#c0c0c0;" /spanspan style="color:#000000;"=/spanspan style="color:#c0c0c0;" /spanspan style="color:#000000;"[/spanspan style="color:#800080;"10/spanspan style="color:#000000;"]/spanspan style="color:#000080;"int/spanspan style="color:#000000;"{/spanspan style="color:#800080;"0/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"1/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"2/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"3/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"4/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"5/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"6/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"7/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"8/spanspan style="color:#000000;",/spanspan style="color:#c0c0c0;" /spanspan style="color:#800080;"9/spanspan style="color:#000000;"}/span
//指定 begin index 和end Index
// begin index 和end index 都指定的情況 包括 begin index， 不包括end index index 從0開始
var slice2 []int = sliceArray[5:9]
// slice3 和slice2 指向同一個底層的數(shù)組
var slice3 []int = sliceArray[:]
//輸出結果 [5 6 7 8] 4 5
fmt.Println(slice2, len(slice2), cap(slice2))
//測試添加元素 and 擴容之后的數(shù)組操作情況
//通過切片直接操作數(shù)組的信息
slice2[0] = 100
sliceArray[6] = 66
//多個切片 操作底層數(shù)組
slice3[7] = 77
//輸出結果 [100 66 77 8] 4 5 三個賦值 都影響了切片的底層數(shù)組
fmt.Println(slice2, len(slice2), cap(slice2))
//輸出結果 [0 1 2 3 4 100 66 77 8 9] 10 10
fmt.Println(slice3, len(slice3), cap(slice3))
//輸出結果 [0 1 2 3 4 100 66 77 8 9] 三個賦值 都影響了 原始數(shù)組
fmt.Println("sliceArray:", sliceArray)
//擴容
// 操作的還是 sliceArray
slice2 = append(slice2, 99)
//輸出結果 [100 66 77 8 99] 5 5
fmt.Println(slice2, len(slice2), cap(slice2))
// 輸出結果 sliceArray: [0 1 2 3 4 100 66 77 8 99]
fmt.Println("sliceArray:", sliceArray)
slice2 = append(slice2, 1000)
//輸出結果 [100 66 77 8 99 1000] 6 10 此處切片已經(jīng)擴容(兩倍擴容)， 并保留了原始的內容
fmt.Println(slice2, len(slice2), cap(slice2))
// 輸出結果 sliceArray: [0 1 2 3 4 100 66 77 8 99] 原來的數(shù)組不再受到影響了
fmt.Println("sliceArray:", sliceArray)
//通過index操作 元素 判斷擴容后的底層數(shù)組是否是部分會在原始的 數(shù)組上面
slice2[1] = 999
//輸出結果 [100 999 77 8 99 1000] 6 10
fmt.Println(slice2, len(slice2), cap(slice2))
// 輸出結果 sliceArray: [0 1 2 3 4 100 66 77 8 99] 說明是 重新找了一塊內存， 和以前的數(shù)組完全沒有關系
fmt.Println("sliceArray:", sliceArray)
Go語言 排序與搜索切片
Go語言標準庫中提供了sort包對整型，浮點型，字符串型切片進行排序，檢查一個切片是否排好序，使用二分法搜索函數(shù)在一個有序切片中搜索一個元素等功能。
關于sort包內的函數(shù)說明與使用，請查看
在這里簡單講幾個sort包中常用的函數(shù)
在Go語言中，對字符串的排序都是按照字節(jié)排序，也就是說在對字符串排序時是區(qū)分大小寫的。
二分搜索算法
Go語言中提供了一個使用二分搜索算法的sort.Search(size,fn)方法：每次只需要比較㏒?n個元素，其中n為切片中元素的總數(shù)。
sort.Search(size,fn)函數(shù)接受兩個參數(shù)：所處理的切片的長度和一個將目標元素與有序切片的元素相比較的函數(shù)，該函數(shù)是一個閉包，如果該有序切片是升序排列，那么在判斷時使用 有序切片的元素 = 目標元素。該函數(shù)返回一個int值，表示與目標元素相同的切片元素的索引。
在切片中查找出某個與目標字符串相同的元素索引
網(wǎng)頁標題：go語言中切片單獨定義 go切片操作
轉載來于：http://fisionsoft.com.cn/article/hgojip.html
