、數(shù)組
讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領域值得信任、有價值的長期合作伙伴，公司提供的服務項目有：域名注冊、虛擬空間、營銷軟件、網(wǎng)站建設、蒙自網(wǎng)站維護、網(wǎng)站推廣。
與其他大多數(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語言的切片本質(zhì)是一個數(shù)組。容量固定是因為數(shù)組的長度是固定的，切片的容量即隱藏數(shù)組的長度。長度可變指的是在數(shù)組長度的范圍內(nèi)可變。
（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)
}
追加、復制切片，用的是內(nèi)置函數(shù)append和copy，copy函數(shù)返回的是最后所復制的元素的數(shù)量。
（5）、內(nèi)置函數(shù)append
內(nèi)置函數(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]
1、數(shù)組是多個 相同類型 的數(shù)據(jù)的組合，一個數(shù)組一旦聲明/定義了，其 長度是固定的，不能動態(tài)變化 。
2、var arr []int? ? 這時arr就是一個slice 切片 。
3、數(shù)組中的元素可以是任何數(shù)據(jù)類型，包括值類型和引用類型，但是 不能混用 。
4、數(shù)組創(chuàng)建后，如果沒有賦值，有默認值如下：
? ? 數(shù)值類型數(shù)組：????默認值為 0
? ? 字符串數(shù)組：? ? ? ?默認值為 ""
? ? bool數(shù)組：? ? ? ? ? ?默認值為 false
5、使用數(shù)組的步驟：
? ? (1)聲明數(shù)組并開辟空間
? ? (3)給數(shù)組各個元素賦值
? ? (3)使用數(shù)組
6、數(shù)組的下標是從0開始的。
7、數(shù)組下標必須在指定范圍內(nèi)使用，否則報panic:數(shù)組越界，比如var arr [5]int的有效下標為0~4.
8、Go的數(shù)組屬于 值類型 ，在默認情況下是 值傳遞 ，因此會進行值拷貝。 數(shù)組間不會相互影響。
9、如想在其他函數(shù)中去修改原來的數(shù)組，可以使用 引用傳遞 (指針方式)。
10、長度是數(shù)組類型的一部分，在傳遞函數(shù)參數(shù)時，需要考慮數(shù)組的長度，看以下案例：
題1：編譯錯誤，因為不能把[3]int類型傳遞給[]int類型，前者是數(shù)組，后者是切片；
題2：編譯錯誤，因為不能把[3]int類型傳遞給[4]int類型；
題3：編譯正確，因為[3]int類型傳給[3]int類型合法。
題目: 給定兩個數(shù)組，編寫一個函數(shù)來計算它們的交集.(來自 leecode(349) )
示例 1：
輸入：nums1 = [1,2,2,1], nums2 = [2,2] 輸出：[2] 示例 2：
輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 輸出：[9,4]
說明：
我的解法:
題目同上,只不過在輸出的時候
輸出結果中每個元素出現(xiàn)的次數(shù)，應與元素在兩個數(shù)組中出現(xiàn)的次數(shù)一致。
示例 1：
輸入：nums1 = [1,2,2,1], nums2 = [2,2] 輸出：[2,2] 示例 2：
輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 輸出：[9,4]
解法
如果給定的數(shù)組是排好序的,
arr1 = [1,2,3,4,4,13]，arr2 = [1,2,3,9,10]
那這個返回值該如何獲取得兩個數(shù)組的交集呢?
解法
Go 中的分片數(shù)組，實際上有點類似于Java中的ArrayList,是一個可以擴展的數(shù)組，但是Go中的切片由比較靈活，它和數(shù)組很像，也是基于數(shù)組，所以在了解Go切片前我們先了解下數(shù)組。
數(shù)組簡單描述就由相同類型元素組成的數(shù)據(jù)結構, 在創(chuàng)建初期就確定了長度，是不可變的。
但是Go的數(shù)組類型又和C與Java的數(shù)組類型不一樣， NewArray 用于創(chuàng)建一個數(shù)組，從源碼中可以看出最后返回的是 Array{}的指針，并不是第一個元素的指針，在Go中數(shù)組屬于值類型，在進行傳遞時，采取的是值傳遞，通過拷貝整個數(shù)組。Go語言的數(shù)組是一種有序的struct。
Go 語言的數(shù)組有兩種不同的創(chuàng)建方式，一種是顯示的初始化，一種是隱式的初始化。
注意一定是使用 [...]T 進行創(chuàng)建，使用三個點的隱式創(chuàng)建，編譯器會對數(shù)組的大小進行推導，只是Go提供的一種語法糖。
其次，Go中數(shù)組的類型，是由數(shù)值類型和長度兩個一起確定的。[2]int 和 [3]int 不是同一個類型，不能進行傳參和比較，把數(shù)組理解為類型和長度兩個屬性的結構體，其實就一目了然了。
Go中的數(shù)組屬于值類型，通常應該存儲于棧中，局部變量依然會根據(jù)逃逸分析確定存儲棧還是堆中。
編譯器對數(shù)組函數(shù)中做兩種不同的優(yōu)化：
在靜態(tài)區(qū)完成賦值后復制到棧中。
總結起來，在不考慮逃逸分析的情況下，如果數(shù)組中元素的個數(shù)小于或者等于 4 個，那么所有的變量會直接在棧上初始化，如果數(shù)組元素大于 4 個，變量就會在靜態(tài)存儲區(qū)初始化然后拷貝到棧上。
由于數(shù)組是值類型，那么賦值和函數(shù)傳參操作都會復制整個數(shù)組數(shù)據(jù)。
不管是賦值或函數(shù)傳參，地址都不一致，發(fā)生了拷貝。如果數(shù)組的數(shù)據(jù)較大，則會消耗掉大量內(nèi)存。那么為了減少拷貝我們可以主動的傳遞指針呀。
地址是一樣的，不過傳指針會有一個弊端，從打印結果可以看到，指針地址都是同一個，萬一原數(shù)組的指針指向更改了，那么函數(shù)里面的指針指向都會跟著更改。
同樣的我們將數(shù)組轉換為切片，通過傳遞切片，地址是不一樣的，數(shù)組值相同。
切片是引用傳遞，所以它們不需要使用額外的內(nèi)存并且比使用數(shù)組更有效率。
所以，切片屬于引用類型。
通過這種方式可以將數(shù)組轉換為切片。
中間不加三個點就是切片,使用這種方式創(chuàng)建切片，實際上是先創(chuàng)建數(shù)組，然后再通過第一種方式創(chuàng)建。
使用make創(chuàng)建切片，就不光編譯期了，make創(chuàng)建切片會涉及到運行期。1. 切片的大小和容量是否足夠?。?/p>
切片是否發(fā)生了逃逸，最終在堆上初始化。如果切片小的話會先在?；蜢o態(tài)區(qū)進行創(chuàng)建。
切片有一個數(shù)組的指針，len是指切片的長度, cap指的是切片的容量。
cap是在初始化切片是生成的容量。
發(fā)現(xiàn)切片的結構體是數(shù)組的地址指針array unsafe.Pointer，而Go中數(shù)組的地址代表數(shù)組結構體的地址。
slice 中得到一塊內(nèi)存地址，array[0]或者unsafe.Pointer(array[0])。
也可以通過地址構造切片
nil切片：指的unsafe.Pointer 為nil
空切片：
創(chuàng)建的指針不為空，len和cap為空
當一個切片的容量滿了，就需要擴容了。怎么擴，策略是什么？
如果原來數(shù)組切片的容量已經(jīng)達到了最大值，再想擴容， Go 默認會先開一片內(nèi)存區(qū)域，把原來的值拷貝過來，然后再執(zhí)行 append() 操作。這種情況對現(xiàn)數(shù)組的地址和原數(shù)組地址不相同。
從上面結果我們可以看到，如果用 range 的方式去遍歷一個切片，拿到的 Value 其實是切片里面的值拷貝,即淺拷貝。所以每次打印 Value 的地址都不變。
由于 Value 是值拷貝的，并非引用傳遞，所以直接改 Value 是達不到更改原切片值的目的的，需要通過 slice[index] 獲取真實的地址。
按值傳遞函數(shù)參數(shù)，是拷貝參數(shù)的實際值到函數(shù)的形式參數(shù)的方法調(diào)用。在這種情況下，參數(shù)在函數(shù)內(nèi)變化對參數(shù)不會有影響。
默認情況下，Go編程語言使用調(diào)用通過值的方法來傳遞參數(shù)。在一般情況下，這意味著，在函數(shù)內(nèi)碼不能改變用來調(diào)用所述函數(shù)的參數(shù)?？紤]函數(shù)swap()的定義如下。
代碼如下:
/* function definition to swap the values */
func swap(int x, int y) int {
var temp int
temp = x /* save the value of x */
x = y /* put y into x */
y = temp /* put temp into y */
return temp;
}
現(xiàn)在，讓我們通過使實際值作為在以下示例調(diào)用函數(shù)swap()：
代碼如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values */
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x, y int) int {
var temp int
temp = x /* save the value of x */
x = y /* put y into x */
y = temp /* put temp into y */
return temp;
}
讓我們把上面的代碼放在一個C文件，編譯并執(zhí)行它，它會產(chǎn)生以下結果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200
這表明，參數(shù)值沒有被改變，雖然它們已經(jīng)在函數(shù)內(nèi)部改變。
通過傳遞函數(shù)參數(shù)，即是拷貝參數(shù)的地址到形式參數(shù)的參考方法調(diào)用。在函數(shù)內(nèi)部，地址是訪問調(diào)用中使用的實際參數(shù)。這意味著，對參數(shù)的更改會影響傳遞的參數(shù)。
要通過引用傳遞的值，參數(shù)的指針被傳遞給函數(shù)就像任何其他的值。所以，相應的，需要聲明函數(shù)的參數(shù)為指針類型如下面的函數(shù)swap()，它的交換兩個整型變量的值指向它的參數(shù)。
代碼如下:
/* function definition to swap the values */
func swap(x *int, y *int) {
var temp int
temp = *x /* save the value at address x */
*x = *y /* put y into x */
*y = temp /* put temp into y */
}
現(xiàn)在，讓我們調(diào)用函數(shù)swap()通過引用作為在下面的示例中傳遞數(shù)值：
代碼如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int= 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values.
* a indicates pointer to a ie. address of variable a and
* b indicates pointer to b ie. address of variable b.
*/
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x /* save the value at address x */
*x = *y /* put y into x */
*y = temp /* put temp into y */
}
讓我們把上面的代碼放在一個C文件，編譯并執(zhí)行它，它會產(chǎn)生以下結果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100
這表明變化的功能以及不同于通過值調(diào)用的外部體現(xiàn)的改變不能反映函數(shù)之外。
GO是編譯性語言，所以函數(shù)的順序是無關緊要的，為了方便閱讀，建議入口函數(shù) main 寫在最前面，其余函數(shù)按照功能需要進行排列
GO的函數(shù) 不支持嵌套，重載和默認參數(shù)
GO的函數(shù) 支持 無需聲明變量，可變長度，多返回值，匿名，閉包等
GO的函數(shù)用 func 來聲明，且左大括號 { 不能另起一行
一個簡單的示例：
輸出為：
參數(shù)：可以傳0個或多個值來供自己用
返回：通過用 return 來進行返回
輸出為：
上面就是一個典型的多參數(shù)傳遞與多返回值
對例子的說明：
按值傳遞：是對某個變量進行復制，不能更改原變量的值
引用傳遞：相當于按指針傳遞，可以同時改變原來的值，并且消耗的內(nèi)存會更少，只有4或8個字節(jié)的消耗
在上例中，返回值 (d int, e int, f int) { 是進行了命名，如果不想命名可以寫成 (int,int,int){ ,返回的結果都是一樣的，但要注意:
當返回了多個值，我們某些變量不想要，或?qū)嶋H用不到，我們可以使用 _ 來補位，例如上例的返回我們可以寫成 d,_,f := test(a,b,c) ，我們不想要中間的返回值，可以以這種形式來舍棄掉
在參數(shù)后面以 變量 ... type 這種形式的，我們就要以判斷出這是一個可變長度的參數(shù)
輸出為：
在上例中， strs ...string 中， strs 的實際值是b,c,d,e,這就是一個最簡單的傳遞可變長度的參數(shù)的例子，更多一些演變的形式，都非常類似
在GO中 defer 關鍵字非常重要，相當于面相對像中的析構函數(shù)，也就是在某個函數(shù)執(zhí)行完成后，GO會自動這個；
如果在多層循環(huán)中函數(shù)里，都定義了 defer ,那么它的執(zhí)行順序是先進后出；
當某個函數(shù)出現(xiàn)嚴重錯誤時， defer 也會被調(diào)用
輸出為
這是一個最簡單的測試了，當然還有更復雜的調(diào)用，比如調(diào)試程序時，判斷是哪個函數(shù)出了問題，完全可以根據(jù) defer 打印出來的內(nèi)容來進行判斷，非?？焖?，這種留給你們?nèi)崿F(xiàn)
一個函數(shù)在函數(shù)體內(nèi)自己調(diào)用自己我們稱之為遞歸函數(shù)，在做遞歸調(diào)用時，經(jīng)常會將內(nèi)存給占滿，這是非常要注意的，常用的比如，快速排序就是用的遞歸調(diào)用
本篇重點介紹了GO函數(shù)(func)的聲明與使用，下一篇將介紹GO的結構 struct
重慶分公司
重慶分公司
