go语言学习记录2
目錄
go語言數組
數組的聲明
語法：
語法說明：
訪問數組
判斷數組是否相等
go語言多維數組
聲明多維數組的語法：
二維數組：
聲明二維數組:
賦值二維數組：
賦值多維數組：
使用索引為多維數組賦值：
go語言切片
從數組或切片中生成新的切片
直接聲明新的切片
使用make（）函數構造切片
go語言append()為切片添加元素
go語言copy（）：切片復制
go語言從切片中刪除元素
從開頭刪除：
從中間位置刪除：
從尾部刪除：
go語言range：循環迭代切片
多維切片
go語言map
概念：
map容量
遍歷map
map元素的刪除和清空（delete）
go語言list
初始化列表：
在列表中插入元素：
從列表中刪除元素：
遍歷列表：
go語言的零值/空值
go語言數組
數組的聲明
語法：
var 數組變量名 [元素數量]Type
語法說明：
- 數組變量名：數組聲明及使用時的變量名。
- 元素數量：數組的元素數量，可以是一個表達式，但最終通過編譯期計算的結果必須是整型數值，元素數量不能含有到運行時才能確認大小的數值。
- Type：可以是任意基本類型，包括數組本身，類型為數組本身時，可以實現多維數組。
訪問數組
1.數組的每個元素都可以通過索引下標來訪問，索引下標的范圍是從 0 開始到數組長度減 1 的位置，內置函數 len() 可以返回數組中元素的個數。
package mainimport "fmt"func main() {var a [3]int // 定義三個整數的數組fmt.Println(a[0]) // 打印第一個元素fmt.Println(a[len(a)-1]) // 打印最后一個元素// 打印索引和元素for i, v := range a {fmt.Printf("%d %d\n", i, v)}// 僅打印元素for _, v := range a {fmt.Printf("%d\n", v)} } /* 0 0 0 0 1 0 2 0 0 0 0 */2.默認情況下，數組的每個元素都會被初始化為元素類型對應的零值，對于數字類型來說就是 0，同時也可以使用數組字面值語法，用一組值來初始化數組：
var q [3]int = [3]int{1, 2, 3} var r [3]int = [3]int{1, 2} fmt.Println(r[2]) // "0"3.在數組的定義中，如果在數組長度的位置出現“...”省略號，則表示數組的長度是根據初始化值的個數來計算，因此，上面數組?q 的定義可以簡化為：
q := [...]int{1, 2, 3} fmt.Printf("%T\n", q) // "[3]int"4.數組的長度是數組類型的一個組成部分，因此 [3]int 和 [4]int 是兩種不同的數組類型，數組的長度必須是常量表達式，因為數組的長度需要在編譯階段確定。
q := [3]int{1, 2, 3} q = [4]int{1, 2, 3, 4} // 編譯錯誤：無法將 [4]int 賦給 [3]int判斷數組是否相等
通過比較運算符（==和!=）判斷兩數組是否相等（包括數組長度和數組中元素的類型），類型不同的兩個數組無法通過編譯。
go語言多維數組
聲明多維數組的語法：
var array_name [size1][size2]...[sizen] array_type
其中，array_name 為數組的名字，array_type 為數組的類型，size1、size2 等等為數組每一維度的長度。
二維數組：
二維數組是最簡單的多維數組，二維數組本質上是由多個一維數組組成的。
聲明二維數組:
// 聲明一個二維整型數組，兩個維度的長度分別是 4 和 2 var array [4][2]int // 使用數組字面量來聲明并初始化一個二維整型數組 array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}} // 聲明并初始化數組中索引為 1 和 3 的元素 array = [4][2]int{1: {20, 21}, 3: {40, 41}} // 聲明并初始化數組中指定的元素 array = [4][2]int{1: {0: 20}, 3: {1: 41}}賦值二維數組：
為了訪問單個元素，需要反復組合使用[ ]方括號。
// 聲明一個二維整型數組，兩個維度的長度分別是 4 和 2 var array [4][2]int // 使用數組字面量來聲明并初始化一個二維整型數組 array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}} // 聲明并初始化數組中索引為 1 和 3 的元素 array = [4][2]int{1: {20, 21}, 3: {40, 41}} // 聲明并初始化數組中指定的元素 array = [4][2]int{1: {0: 20}, 3: {1: 41}}賦值多維數組：
只要類型一致，就可以將多維數組互相賦值，如下所示，多維數組的類型包括每一維度的長度以及存儲在元素中數據的類型。
// 聲明兩個二維整型數組 var array1 [2][2]int var array2 [2][2]int // 為array2的每個元素賦值 array2[0][0] = 10 array2[0][1] = 20 array2[1][0] = 30 array2[1][1] = 40 // 將 array2 的值復制給 array1 array1 = array2使用索引為多維數組賦值：
// 將 array1 的索引為 1 的維度復制到一個同類型的新數組里 var array3 [2]int = array1[1] // 將數組中指定的整型值復制到新的整型變量里 var value int = array1[1][0]go語言切片
從數組或切片中生成新的切片
從連續內存區域生成切片，格式如下：
slice [開始位置 : 結束位置]
語法說明如下：
- slice：表示目標切片對象；
- 開始位置：對應目標切片對象的索引；
- 結束位置：對應目標切片的結束索引。
從數組或切片生成新的切片擁有如下特性：
- 取出的元素數量為：結束位置 - 開始位置；
- 取出元素不包含結束位置對應的索引，切片最后一個元素使用 slice[len(slice)] 獲取；
- 當缺省開始位置時，表示從連續區域開頭到結束位置；
- 當缺省結束位置時，表示從開始位置到整個連續區域末尾；
- 兩者同時缺省時，與切片本身等效；
- 兩者同時為 0 時，等效于空切片，一般用于切片復位；
- 根據索引位置取切片 slice 元素值時，取值范圍是（0～len(slice)-1），超界會報運行時錯誤，生成切片時，結束位置可以填寫 len(slice) 但不會報錯。
從數組生成切片，代碼如下：
var a = [3]int{1, 2, 3} fmt.Println(a, a[1:2]) //運行結果為：[1 2 3] [2]直接聲明新的切片
切片類型的聲明格式：
var name []Type
（其中， name 表示切片的變量名，Type 表示切片對應的元素類型。）
注意：切片是動態結構，只能與 nil 判定相等，不能互相判定相等。聲明新的切片后，可以使用?append()?函數向切片中添加元素。
切片聲明的使用：
// 聲明字符串切片 var strList []string// 聲明整型切片 var numList []int// 聲明一個空切片 var numListEmpty = []int{}// 輸出3個切片 fmt.Println(strList, numList, numListEmpty)// 輸出3個切片大小 fmt.Println(len(strList), len(numList), len(numListEmpty))// 切片判定空的結果 fmt.Println(strList == nil) fmt.Println(numList == nil) fmt.Println(numListEmpty == nil) /* [] [] [] 0 0 0 true true false（numListEmpty 已經被分配到了內存，但沒有元素，因此和 nil 比較時是 false。） */使用make（）函數構造切片
如果需要動態地創建一個切片，可以使用 make() 內建函數，格式如下：
make( []Type, size, cap )
（其中， Type 是指切片的元素類型，size 指的是為這個類型分配多少個元素，cap 為預分配的元素數量，這個值設定后不影響 size，只是能提前分配空間，降低多次分配空間造成的性能問題。）
a := make([]int, 2) b := make([]int, 2, 10)fmt.Println(a, b) fmt.Println(len(a), len(b)) /* 代碼輸出如下： [0 0] [0 0] 2 2 */注意：
使用 make() 函數生成的切片一定發生了內存分配操作，但給定開始與結束位置（包括切片復位）的切片只是將新的切片結構指向已經分配好的內存區域，設定開始與結束位置，不會發生內存分配操作。
go語言append()為切片添加元素
尾部追加
var a []int a = append(a, 1) // 追加1個元素 a = append(a, 1, 2, 3) // 追加多個元素, 手寫解包方式 a = append(a, []int{1,2,3}...) // 追加一個切片, 切片需要解包注意：
在使用 append() 函數為切片動態添加元素時，如果空間不足以容納足夠多的元素，切片就會進行“擴容”，此時新切片的長度會發生改變。
?
切片在擴容時，容量的擴展規律是按容量的 2 倍數進行擴充，例如 1、2、4、8、16……，代碼如下：
var numbers []intfor i := 0; i < 10; i++ {numbers = append(numbers, i)fmt.Printf("len: %d cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers) } /* len: 1 cap: 1 pointer: 0xc0420080e8 len: 2 cap: 2 pointer: 0xc042008150 len: 3 cap: 4 pointer: 0xc04200e320 len: 4 cap: 4 pointer: 0xc04200e320 len: 5 cap: 8 pointer: 0xc04200c200 len: 6 cap: 8 pointer: 0xc04200c200 len: 7 cap: 8 pointer: 0xc04200c200 len: 8 cap: 8 pointer: 0xc04200c200 len: 9 cap: 16 pointer: 0xc042074000 len: 10 cap: 16 pointer: 0xc042074000 */ //規律：切片長度 len 并不等于切片的容量 cap。開頭添加：
在切片開頭添加元素一般都會導致內存的重新分配，而且會導致已有元素全部被復制 1 次，因此，從切片的開頭添加元素的性能要比從尾部追加元素的性能差很多。
var a = []int{1,2,3} a = append([]int{0}, a...) // 在開頭添加1個元素 a = append([]int{-3,-2,-1}, a...) // 在開頭添加1個切片因為 append 函數返回新切片的特性，所以切片也支持鏈式操作，我們可以將多個 append 操作組合起來，實現在切片中間插入元素：
var a []int a = append(a[:i], append([]int{x}, a[i:]...)...) // 在第i個位置插入x a = append(a[:i], append([]int{1,2,3}, a[i:]...)...) // 在第i個位置插入切片每個添加操作中的第二個 append 調用都會創建一個臨時切片，并將 a[i:] 的內容復制到新創建的切片中，然后將臨時創建的切片再追加到 a[:i] 中。
go語言copy（）：切片復制
Go語言的內置函數 copy() 可以將一個數組切片復制到另一個數組切片中，如果加入的兩個數組切片不一樣大，就會按照其中較小的那個數組切片的元素個數進行復制。
copy() 函數的使用格式如下：
copy( destSlice, srcSlice []T) int
其中 ，srcSlice 為數據來源切片，destSlice 為復制的目標（也就是將 srcSlice 復制到 destSlice），目標切片必須分配過空間且足夠承載復制的元素個數，并且來源和目標的類型必須一致，copy() 函數的返回值表示實際發生復制的元素個數。
示例：
package mainimport "fmt"func main() {// 設置元素總量為1000const elementCount = 1000// 預分配足夠多的元素切片1000srcData := make([]int, elementCount)// 將切片賦值0~999for i := 0; i < elementCount; i++ {srcData[i] = i}// 引用切片數據，切片不會因為等號操作進行元素的復制。refData := srcData// 預分配足夠多的元素切片copyData := make([]int, elementCount)// 將數據復制到新的copyData切片空間中copy(copyData, srcData)// 修改原始數據的第一個元素srcData[0] = 999// 打印引用切片的第一個元素，會發生變化fmt.Println(refData[0])// 打印復制切片的第一個和最后一個元素，由于數據是復制的，因此不會發生變化fmt.Println(copyData[0], copyData[elementCount-1])// 復制原始數據從4到6(不包含)copy(copyData, srcData[4:6])for i := 0; i < 5; i++ {fmt.Printf("%d ", copyData[i])} }go語言從切片中刪除元素
根據切片本身特性來刪除元素，根據不同位置刪除元素有三種情況：
????????從開頭位置刪除
????????從中間位置刪除
????????從尾部刪除（其中刪除切片尾部的元素速度最快）
代碼的刪除過程可以使用下圖來描述：
Go語言中刪除切片元素的本質是，以被刪除元素為分界點，將前后兩個部分的內存重新連接起來。
從開頭刪除：
1.直接移動數據指針：
a = []int{1, 2, 3} a = a[1:] // 刪除開頭1個元素 a = a[N:] // 刪除開頭N個元素2.使用append原地完成，是后面的數據向開頭移動（（所謂原地完成是指在原有的切片數據對應的內存區間內完成，不會導致內存空間結構的變化）：
a = []int{1, 2, 3} a = append(a[:0], a[1:]...) // 刪除開頭1個元素 a = append(a[:0], a[N:]...) // 刪除開頭N個元素3.使用cope（）函數來刪除開頭元素：
a = []int{1, 2, 3} a = a[:copy(a, a[1:])] // 刪除開頭1個元素 a = a[:copy(a, a[N:])] // 刪除開頭N個元素從中間位置刪除：
對于刪除中間的元素，需要對剩余的元素進行一次整體挪動，同樣可以用 append 或 copy 原地完成：
a = []int{1, 2, 3, ...} a = append(a[:i], a[i+1:]...) // 刪除中間1個元素 a = append(a[:i], a[i+N:]...) // 刪除中間N個元素 a = a[:i+copy(a[i:], a[i+1:])] // 刪除中間1個元素 a = a[:i+copy(a[i:], a[i+N:])] // 刪除中間N個元素從尾部刪除：
a = []int{1, 2, 3} a = a[:len(a)-1] // 刪除尾部1個元素 a = a[:len(a)-N] // 刪除尾部N個元素提示:
連續容器的元素刪除無論在任何語言中，都要將刪除點前后的元素移動到新的位置，隨著元素的增加，這個過程將會變得極為耗時，因此，當業務需要大量、頻繁地從一個切片中刪除元素時，如果對性能要求較高的話，就需要考慮更換其他的容器了（如雙鏈表等能快速從刪除點刪除元素）。
go語言range：循環迭代切片
切片其實就是多個相同類型元素的連續集合，既然切片是一個集合，那么我們就可以迭代其中的元素，Go語言有個特殊的關鍵字 range，它可以配合關鍵字 for 來迭代切片里的每一個元素，如下所示：
// 創建一個整型切片，并賦值 slice := []int{10, 20, 30, 40} // 迭代每一個元素，并顯示其值 for index, value := range slice {fmt.Printf("Index: %d Value: %d\n", index, value) } /*第 4 行中的 index 和 value 分別用來接收 range 關鍵字返回的切片中每個元素的索引和值，這里的 index 和 value 不是固定的，讀者也可以定義成其它的名字。*/ /* Index: 0 Value: 10 Index: 1 Value: 20 Index: 2 Value: 30 Index: 3 Value: 40 */可以使用傳統的for循環對切片進行迭代：
// 創建一個整型切片，并賦值 slice := []int{10, 20, 30, 40} // 從第三個元素開始迭代每個元素 for index := 2; index < len(slice); index++ {fmt.Printf("Index: %d Value: %d\n", index, slice[index]) } /* Index: 2 Value: 30 Index: 3 Value: 40 */對于切片，函數 len() 可以返回切片的長度，函數 cap() 可以返回切片的容量，在上面的示例中，使用到了函數 len() 來控制循環迭代的次數。range 關鍵字不僅僅可以用來遍歷切片，它還可以用來遍歷數組、字符串、map 或者通道等。
多維切片
聲明一個多維數組的語法格式如下：
var sliceName [][]...[]sliceType
其中，sliceName 為切片的名字，sliceType為切片的類型，每個[ ]代表著一個維度，切片有幾個維度就需要幾個[ ]。
//聲明一個二維切片 var slice [][]int //為二維切片賦值 slice = [][]int{{10}, {100, 200}} /* // 聲明一個二維整型切片并賦值 slice := [][]int{{10}, {100, 200}} */【示例】組合切片的切片
// 聲明一個二維整型切片并賦值 slice := [][]int{{10}, {100, 200}} // 為第一個切片追加值為 20 的元素 slice[0] = append(slice[0], 20)go語言map
概念：
Go語言中 map 是一種特殊的數據結構，一種元素對（pair）的無序集合，pair 對應一個 key（索引）和一個 value（值），所以這個結構也稱為關聯數組或字典，這是一種能夠快速尋找值的理想結構，給定 key，就可以迅速找到對應的 value。
map 這種數據結構在其他編程語言中也稱為字典（Python）、hash 和 HashTable 等。
map 是引用類型，可以使用如下方式聲明：
var mapname map[keytype]valuetype
其中：- mapname 為 map 的變量名。
- keytype 為鍵類型。
- valuetype 是鍵對應的值類型。
提示：
[keytype] 和 valuetype 之間允許有空格。
在聲明的時候不需要知道 map 的長度，因為 map 是可以動態增長的，未初始化的 map 的值是 nil，使用函數 len() 可以獲取 map 中 pair 的數目。
?
示例：
package main import "fmt"func main() {var mapLit map[string]int//var mapCreated map[string]float32var mapAssigned map[string]intmapLit = map[string]int{"one": 1, "two": 2} /*mapLit 演示了使用{key1: value1, key2: value2}的格式來初始化 map ，就像數組和結構體一樣。*/mapCreated := make(map[string]float32) /* mapCreated 的創建方式mapCreated := make(map[string]float)等價于mapCreated := map[string]float{} */mapAssigned = mapLitmapCreated["key1"] = 4.5mapCreated["key2"] = 3.14159mapAssigned["two"] = 3fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"]) } /* 輸出結果： Map literal at "one" is: 1 Map created at "key2" is: 3.14159 Map assigned at "two" is: 3 Map literal at "ten" is: 0 */map容量
和數組不同，map 可以根據新增的 key-value 動態的伸縮，因此它不存在固定長度或者最大限制，但是也可以選擇標明 map 的初始容量 capacity，格式如下：
make(map[keytype]valuetype, cap)
例如：
map2 := make(map[string]float, 100)
示例：
//map 的具體例子，即將音階和對應的音頻映射起來 noteFrequency := map[string]float32 { "C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83, "G0": 24.50, "A0": 27.50, "B0": 30.87, "A4": 440}遍歷map
map 的遍歷過程使用 for range 循環完成：
scene := make(map[string]int)scene["route"] = 66 scene["brazil"] = 4 scene["china"] = 960for k, v := range scene {fmt.Println(k, v) }遍歷對于Go語言的很多對象來說都是差不多的，直接使用 for range 語法即可，遍歷時，可以同時獲得鍵和值。
1.只遍歷值，可以使用下面的形式：
for _, v := range scene {
將不需要的鍵使用_改為匿名變量形式。
2.只遍歷鍵時，使用下面的形式：
for k := range scene {
無須將值改為匿名變量形式，忽略值即可。
注意：遍歷輸出元素的順序與填充順序無關，不能期望 map 在遍歷時返回某種期望順序的結果。
如果需要特定順序的遍歷結果，正確的做法是先排序，代碼如下：
scene := make(map[string]int)// 準備map數據 scene["route"] = 66 scene["brazil"] = 4 scene["china"] = 960// 聲明一個切片保存map數據 var sceneList []string// 將map數據遍歷復制到切片中 for k := range scene {sceneList = append(sceneList, k) }// 對切片進行排序 sort.Strings(sceneList)// 輸出 fmt.Println(sceneList) /* 代碼輸出如下： [brazil china route] */提醒：
sort.Strings 的作用是對傳入的字符串切片進行字符串字符的升序排列。
map元素的刪除和清空（delete）
使用delete（）內建函數從map刪除一組鍵值對的格式如下：
????????delete(map, 鍵)
其中 map 為要刪除的 map 實例，鍵為要刪除的 map 中鍵值對的鍵。
scene := make(map[string]int)// 準備map數據 scene["route"] = 66 scene["brazil"] = 4 scene["china"] = 960delete(scene, "brazil")for k, v := range scene {fmt.Println(k, v) } /* route 66 china 960 */注意：
Go語言中并沒有為 map 提供任何清空所有元素的函數、方法，清空 map 的唯一辦法就是重新 make 一個新的 map，不用擔心垃圾回收的效率，Go語言中的并行垃圾回收效率比寫一個清空函數要高效的多。
go語言list
列表是一種非連續的存儲容器，由多個節點組成，節點通過一些變量記錄彼此之間的關系，列表有多種實現方法，如單鏈表、雙鏈表等。
初始化列表：
1) 通過 container/list 包的 New() 函數初始化 list
變量名 := list.New()
2) 通過 var 關鍵字聲明初始化 list
var 變量名 list.List
注意：
列表與切片和 map 不同的是，列表并沒有具體元素類型的限制，因此，列表的元素可以是任意類型，這既帶來了便利，也引來一些問題，例如給列表中放入了一個 interface{} 類型的值，取出值后，如果要將 interface{} 轉換為其他類型將會發生宕機。
在列表中插入元素：
在前方插入：PushFront
在后方插入：PushBack
提示
這兩個方法都會返回一個 *list.Element 結構，如果在以后的使用中需要刪除插入的元素，則只能通過 *list.Element 配合 Remove() 方法進行刪除，這種方法可以讓刪除更加效率化，同時也是雙鏈表特性之一。
l := list.New()//創建一個列表實例。 l.PushBack("fist")//將 fist 字符串插入到列表的尾部，此時列表是空的，插入后只有一個元素。 l.PushFront(67) /*將數值 67 放入列表，此時，列表中已經存在 fist 元素，67 這個元素將被放在 fist 的前面。*/列表插入元素的方法如下表所示：
?
| InsertAfter(v interface {}, mark * Element) * Element | 在 mark 點之后插入元素，mark 點由其他插入函數提供 |
| InsertBefore(v interface?{}, mark * Element) *Element | 在 mark 點之前插入元素，mark 點由其他插入函數提供 |
| PushBackList(other *List) | 添加 other 列表元素到尾部 |
| PushFrontList(other *List) | 添加 other 列表元素到頭部 |
從列表中刪除元素：
package mainimport "container/list"func main() {l := list.New()// 尾部添加l.PushBack("canon")// 頭部添加l.PushFront(67)// 尾部添加后保存元素句柄element := l.PushBack("fist")// 在fist之后添加highl.InsertAfter("high", element)// 在fist之前添加noonl.InsertBefore("noon", element)// 使用l.Remove(element) }代碼說明如下：
第 6 行，創建列表實例。
第 9 行，將字符串?canon 插入到列表的尾部。
第 12 行，將數值?67 添加到列表的頭部。
第 15 行，將字符串?fist 插入到列表的尾部，并將這個元素的內部結構保存到 element 變量中。
第 18 行，使用 element 變量，在 element 的位置后面插入 high 字符串。
第 21 行，使用 element 變量，在 element 的位置前面插入 noon 字符串。
第 24 行，移除 element 變量對應的元素。
| l.PushBack("canon") | canon |
| l.PushFront(67) | 67,?canon |
| element := l.PushBack("fist") | 67, canon, fist |
| l.InsertAfter("high", element) | 67, canon, fist, high |
| l.InsertBefore("noon", element) | 67, canon, noon, fist, high |
| l.Remove(element) | 67, canon, noon, high |
遍歷列表：
遍歷雙鏈表需要配合 Front() 函數獲取頭元素，遍歷時只要元素不為空就可以繼續進行，每一次遍歷都會調用元素的 Next() 函數，示例如下：
l := list.New()// 尾部添加 l.PushBack("canon")// 頭部添加 l.PushFront(67)for i := l.Front(); i != nil; i = i.Next() {fmt.Println(i.Value) } /* 67 canon */代碼說明如下：
- 第 1 行，創建一個列表實例。
- 第 4 行，將 canon 放入列表尾部。
- 第 7 行，在隊列頭部放入 67。
- 第 9 行，使用 for 語句進行遍歷，其中 i:=l.Front() 表示初始賦值，只會在一開始執行一次，每次循環會進行一次 i != nil 語句判斷，如果返回 false，表示退出循環，反之則會執行 i = i.Next()。
- 第 10 行，使用遍歷返回的 *list.Element 的 Value 成員取得放入列表時的原值。
go語言的零值/空值
在Go語言中，布爾類型的零值（初始值）為 false，數值類型的零值為 0，字符串類型的零值為空字符串""，而指針、切片、映射、通道、函數和接口的零值則是 nil。
注意：
- nil 是Go語言中一個預定義好的標識符，有過其他編程語言開發經驗的開發者也許會把 nil 看作其他語言中的 null（NULL），其實這并不是完全正確的，因為Go語言中的 nil 和其他語言中的 null 有很多不同點。
- 不同于python等動態語言的兩個none值永遠相等，這里的nil標識符是不能比較的。
- nil 并不是Go語言的關鍵字或者保留字，也就是說我們可以定義一個名稱為 nil 的變量。
- nil沒有默認類型。
- 不同類型nil的指針是一樣的。
- 不同類型的nil是不能比較的，兩個相同類型的nil值也可能無法比較。
- nil是map、slice、pointer、channel、func、interface的零值。
- 不同類型的nil值占用的內存大小可能是不一樣的。（不同類型的 nil 值的大小可能不同）
????????
總結
- 上一篇： 博客优化--ping让博客文章发表就有可
- 下一篇： server manager无法打开