使用值為 nil 的 slice、map 會發(fā)生什么？

允許對值為 nil 的 slice 添加元素，但是對值為 nil 的 map 添加元素時會造成運行時 panic。

// map錯誤示例
func main() {var m map[string]intm["one"] = 1  // error: panic: assignment to entry in nil map// m := make(map[string]int) // map的正確聲明, 分配了實際的內(nèi)存
}    // slice正確示例
func main() {var s []ints = append(s, 1)
}

訪問 map 中的 key，需要注意什么？

當訪問 map 中不存在的 key 時，Go 會返回元素對應數(shù)據(jù)類型的零值，比如 nil、“” 、false 和 0，即取值操作總是有值返回的，故不能通過取出來的值來判斷 key 是否存在。

檢查 key 是否存在可以用 map 直接訪問，檢查返回的第二個參數(shù)即可。

// 錯誤的key檢測方式
func main() {x := map[string]string{"one": "2", "two": "", "three": "3"}if v := x["two"]; v == "" {fmt.Println("key two is no entry") // 不管鍵two存不存在都會返回的空字符串}
}// 正確示例
func main() {x := map[string]string{"one": "2", "two": "", "three": "3"}if _, ok := x["two"]; !ok {fmt.Println("key two is no entry")}
}

string 類型的值可以修改嗎？

不能，嘗試使用索引遍歷字符串，來更新字符串中的個別字符時，是不允許的。

string 類型的值是只讀的二進制字節(jié)切片，如果真要修改字符串中的字符，先將 string 轉為 []byte 修改后，再轉為 string 即可。

// 修改字符串的錯誤示例
func main() {x := "text"x[0] = "T"  // error: cannot assign to x[0]fmt.Println(x)
}// 修改示例
func main() {x := "text"xBytes := []byte(x)xBytes[0] = 'T' // 注意此時的T是rune類型x = string(xBytes)fmt.Println(x) // Text
}

switch 中如何強制執(zhí)行下一個 case 代碼塊？

switch 語句中的 case 代碼塊會默認帶上 break，但可以使用 fallthrough 來強制執(zhí)行下一個 case 代碼塊。

func main() {isSpace := func(char byte) bool {switch char {case ' ': // 空格符會直接break, 返回 false// fallthrough // 返回truecase '\t':return true}return false}fmt.Println(isSpace('\t')) // truefmt.Println(isSpace(' ')) // false
}

切片和數(shù)組的區(qū)別？

• 數(shù)組是具有固定長度，且擁有零個或者多個，相同數(shù)據(jù)類型元素的序列
• 數(shù)組的長度是數(shù)組類型的一部分，所以 [3]int 和 [4]int 是兩種不同的數(shù)組類型
• 數(shù)組需要指定大小，不指定也會根據(jù)初始化的自動推算出大小，在初始化后長度是固定的，無法修改其長度
• 數(shù)組是值傳遞，數(shù)組是內(nèi)置類型，是一組同類型數(shù)據(jù)的集合，它是值類型，通過從 0 開始的下標索引訪問元素值

var array [10]int
var array =[5]int{1,2,3,4,5}

• 切片表示一個擁有相同類型元素的可變長度的序列
• 切片是一種輕量級的數(shù)據(jù)結構，它有三個屬性：指針、長度和容量
• 切片不需要指定大小
• 切片是地址傳遞
• 切片可以通過數(shù)組來初始化，也可以通過內(nèi)置函數(shù) make() 來初始化 ，初始化時 len=cap，在追加元素時如果容量 cap 不足，將按 len 的 2 倍擴容

var slice []type = make([]type, len)

new 和 make 的區(qū)別？

• new 的作用是初始化一個指向類型的指針（*T）
• new 函數(shù)是內(nèi)建函數(shù)，函數(shù)定義：func new(Type) *Type
• 使用 new 函數(shù)來分配空間
• 傳遞給 new 函數(shù)的是一個類型，不是一個值，返回值是指向這個新分配的零值的指針
• make 的作用是為 slice、map 或 chan 初始化，并返回引用 （T）
• make 函數(shù)是內(nèi)建函數(shù)，函數(shù)定義：func make(Type, size IntegerType) Type，第一個參數(shù)是一個類型，第二個參數(shù)是長度，返回值是一個類型
• make(T, args) 函數(shù)的目的與 new(T) 不同，它僅僅用于創(chuàng)建 Slice、Map 和 Channel，并且返回類型是 T（不是 *T）的一個初始化的（不是零值）的實例

go 語言中的 for 循環(huán)

for 循環(huán)支持 continue 和 break 來控制循環(huán)，但是它提供了一個更高級的 break，可以選擇中斷哪一個循環(huán)。for 循環(huán)不支持以逗號為間隔的多個賦值語句，必須使用平行賦值的方式來初始化多個變量。

outerloop:
for i := 0; i < 3; i++ {for j := 0; j < 3; j++ {if j == 2 {break outerloop}fmt.Println(i, j)}
}
// 在上述示例中, 我們使用了break outerloop來指定要中斷的是外層循環(huán)。當內(nèi)部循環(huán)中的j的值等于2時, 執(zhí)行 break outerloop, 這樣整個循環(huán)就會被完全中斷, 不再繼續(xù)執(zhí)行。for i, j := 0, 0; i < 3; i, j = i+1, j+1 {fmt.Println(i, j)
}
// 在這個示例中, 我們使用了平行賦值的方式來初始化i和j兩個變量。每次循環(huán)迭代, i和j分別會自增1, 并通過平行賦值將新的值重新關聯(lián)給它們。

go 語言中的引用類型包含哪些？

數(shù)組切片（slice）、字典（map）、通道（channel）、接口（interface）。

go 語言的 main 函數(shù)

• main 函數(shù)不能帶參數(shù)
• main 函數(shù)不能定義返回值
• main 函數(shù)所在的包必須為 main 包
• main 函數(shù)中可以使用 flag 包來獲取和解析命令行參數(shù)

go 語言中的靜態(tài)類型聲明

在 Go 語言中，靜態(tài)類型聲明是指在聲明變量、函數(shù)或方法時顯式指定其類型。靜態(tài)類型聲明是 Go 語言的一個重要特性，它使得變量在編譯階段就能夠被確定其類型，并且在編譯過程中進行靜態(tài)類型檢查。

靜態(tài)類型聲明的語法格式通常是在變量名或函數(shù)名后面加上類型標識符，用于明確指定變量的類型。

var count int // 聲明一個名為count的整數(shù)類型變量
var message string // 聲明一個名為message的字符串類型變量
func add(a int, b int) int { // 聲明一個名為add的函數(shù), 接收兩個整數(shù)類型參數(shù), 返回一個整數(shù)類型結果return a + b
}

在上述示例中，使用了 int 和 string 來顯式聲明變量 count 和 message 的類型，以及函數(shù) add 的參數(shù)類型和返回值類型。

靜態(tài)類型聲明的優(yōu)勢在于可以提供強類型檢查。編譯器可以在編譯階段對類型信息進行檢查，包括類型的兼容性、正確的方法調(diào)用等，從而減少在運行時出現(xiàn)類型錯誤的可能性。這有助于提高代碼的可靠性和安全性。

此外，靜態(tài)類型聲明還使代碼更易于理解和維護。通過明確指定變量的類型，可以對變量的用途有更好的描述，減少了對類型的猜測和理解上的困惑。

總而言之，Go 語言中的靜態(tài)類型聲明是一種為變量、函數(shù)和方法顯式指定類型的機制，它提供了靜態(tài)類型檢查和更好的代碼可讀性、可維護性。

Slice 的底層實現(xiàn)

切片是基于數(shù)組實現(xiàn)的，它的底層是數(shù)組，它自己本身非常小，可以理解為是對底層數(shù)組的抽象。因為基于數(shù)組實現(xiàn)，所以它的底層的內(nèi)存是連續(xù)分配的，效率非常高，還可以通過索引獲得數(shù)據(jù)，可以迭代以及垃圾回收優(yōu)化。

切片本身并不是動態(tài)數(shù)組或者數(shù)組指針。它內(nèi)部實現(xiàn)的數(shù)據(jù)結構通過指針引用底層數(shù)組，設定相關屬性，將數(shù)據(jù)讀寫操作限定在指定的區(qū)域內(nèi)。切片本身是一個只讀對象，其工作機制類似于數(shù)組指針的一種封裝。

切片對象非常小，是因為它是只有 3 個字段的數(shù)據(jù)結構，這 3 個字段就是 Go 語言操作底層數(shù)組的元數(shù)據(jù)。

• 指向底層數(shù)組的指針
• 切片的長度
• 切片的容量

Slice 的擴容機制

1. 判斷新申請的容量是否大于舊容量的兩倍。如果是，則最終容量就是新申請的容量
2. 如果新申請的容量不滿足上一步的條件，判斷舊切片長度是否小于 1024。如果是，則最終容量就是舊容量的兩倍
3. 如果舊切片長度大于等于 1024，則進入循環(huán)計算最終容量。從舊容量開始，每次增加原來容量的 1/4，直到最終容量大于等于新申請的容量
4. 如果計算出的最終容量超出了限制（即溢出），則最終容量就是新申請的容量

• 情況一：當原數(shù)組還有容量可以擴容時，擴容后的數(shù)組仍然指向原來的數(shù)組。這就意味著對一個切片的操作可能會影響到多個指針，因為它們指向的是同一個地址的切片
• 情況二：如果原來數(shù)組的容量已經(jīng)達到最大值，再次擴容會導致 Go 語言默認先開辟一片新的內(nèi)存區(qū)域，并將原來的值復制過去，然后執(zhí)行 append() 操作。這種情況不會對原數(shù)組造成任何影響

要復制一個 Slice，最好使用 Copy 函數(shù)。

Map底層實現(xiàn)

Go 中 map 的底層實現(xiàn)是一個散列表，因此實現(xiàn) map 的過程實際上就是實現(xiàn)散列表的過程。

在這個散列表中，主要出現(xiàn)的結構體有兩個，一個叫 hmap（a header for a go map），一個叫 bmap（a bucket for a Go map，通常稱為 bucket）。

我們只需關注標紅的字段：buckets 數(shù)組。Go 的 map 中用于存儲的結構是 bucket 數(shù)組（即 bmap）。

相比于 hmap，bucket 的結構顯得簡單一些，標橙的字段依然是核心，我們使用的 map 中的 key 和 value 就存儲在這里。

“高位哈希值”數(shù)組記錄的是當前 bucket 中 key 相關的“索引”，還有一個字段是一個指向擴容后的 bucket 的指針，使得 bucket 會形成一個鏈表結構。

Go 把求得的哈希值按照用途一分為二：高位和低位。低位用于尋找當前 key 屬于 hmap 中的哪個 bucket，而高位用于尋找 bucket 中的哪個 key。

注意：map 中的 key/value 值都是存到同一個數(shù)組中的。這樣做的好處是，在 key 和 value 的長度不同時，可以消除 padding 帶來的空間浪費。

map 的擴容：當 Go 的 map 長度增長到大于加載因子所需的 map 長度時，Go 語言就會產(chǎn)生一個新的 bucket 數(shù)組，然后把舊的 bucket 數(shù)組移到一個屬性字段 oldbucket 中。

注意：并不是立刻把舊的數(shù)組中的元素轉移到新的 bucket 中，而是只有當訪問到具體的某個 bucket 的時候，才會把 bucket 中的數(shù)據(jù)轉移到新的 bucket 中。

在 range 迭代 slice 時，如何修改值?

在 range 迭代中，得到的值其實是元素的一份值拷貝，更新拷貝并不會更改原來的元素，即拷貝的地址并不是原有元素的地址。

func main() {data := []int{1, 2, 3}for _, v := range data {v *= 10  // data中原有元素是不會被修改的}fmt.Println("data: ", data) // data: [1 2 3]
}

如果要修改原有元素的值，應該使用索引直接訪問。

func main() {data := []int{1, 2, 3}for i, v := range data {data[i] = v * 10 }fmt.Println("data: ", data) // data: [10 20 30]
}

如果你的集合保存的是指向值的指針，需稍作修改。依舊需要使用索引訪問元素，不過可以使用 range 出來的元素直接更新原有值。

func main() {data := []*struct{ num int }{{1}, {2}, {3}}for _, v := range data {v.num *= 10 // 直接使用指針更新}fmt.Println(data[0], data[1], data[2]) // &{10} &{20} &{30}
}