1. map

　　1. 類似其它語言中的哈希表活著字典，以 key-value 形式存儲數據

　　2. key 必須是支持 == 或 != 比較運算的類型，不可以是函數、map 或 slice

　　3. map 查找比線性搜索快很多，但比使用索引訪問數據的類型慢100倍

　　4. map使用 make() 創建，支持 := 這種簡寫方式

　　5. make([keyType]valueType, cap)，cap表示容量，可省略。超出容量時會自動擴容，但盡量提供一個合理的初始值? make([int]string, 10)

　　6. 使用 len() 獲取元素個數

　　7. 鍵值對兒不存在時自動添加，使用 delete() 刪除某鍵值對兒，使用 for range 對 map 和 slice 進行迭代操作

package mainimport ("fmt" )func main() {// map正常初始化m := make(map[string]string)m["k1"] = "a"m["k2"] = "b"fmt.Println("map:", m)v1 := m["k1"] // map中獲取數據fmt.Println("get map k1:", v1)fmt.Println("map len:", len(m)) // 取得map對長度delete(m, "k2") // 刪除map中指定對key值fmt.Println("deleted map:", m)_, prs := m["k2"] // map通過key取對應對value會返回多值,其中第一個為value值，第二個為狀態碼(有值返回tru，無值為false)fmt.Println("prs:", prs)// map初始化的時候進行賦值n := map[string]int{"foo":1, "bar":2}fmt.Println("map:", n) }

以上代碼運行結果如下所示：

1 2 3 4 5 6

map: map[k1:a k2:b] get map k1: a map len: 2 deleted map: map[k1:a] prs:?false map: map[foo:1 bar:2]

2. 使用 range 遍歷 slice 和 map

使用for range 對 slice 和 map進行遍歷舉例

1 package main2 3 import "fmt"4 5 // for ... range 類似與其他語言中對foreach6 func main() {7 // 對切片的循環遍歷8 s := []int{1, 3, 5}9 fmt.Println("loop slice begin:=================") 10 // i為切片的下標值,v為對應的值。其中v是對應slice的副本值，對它的修改不會影響原始內容，要想修改原始內容通過指定下標進行覆蓋:s[1] = 9 11 for i, v := range s { 12 fmt.Println(i, v) 13 } 14 15 // 對map對循環遍歷 16 m := map[string]string{"a" : "liang", "b" : "xuli", "c" : "liguang"} 17 fmt.Println("loop map begin:===================") 18 for k, v := range m { // k為map對key值，v為對應對value值。其中都為map對拷貝，改變它們對值不會對原始內容造成影響 19 fmt.Println(k, v) 20 } 21 22 // 對slice-map進行循環遍歷（終極版） 23 sm := make([]map[int]string, 5) //創建了有5個長度對slice，其中值類型為 map[int]string 24 fmt.Println("loop slice-map warn begin:========") 25 for _, v := range sm { // 此時i為slice對下標，v為對應內容即map.這里不需要取key值故使用 _ 表示空白 26 v = make(map[int]string, 1) // 初始化長度為 1 的map 27 v[1] = "OK" 28 fmt.Println(v) 29 } 30 fmt.Println(sm) // 這里打印的結果和循環體中打印的結果有差別，是因為循環體中對應的 v 為slice的拷貝，這點一定要注意 31 32 fmt.Println("loop slice-map normal begin:======") 33 for i := range sm { // 要想改變其中slice內容，則只需要得到下標值通過對下標內容賦值改變原始slice內容，故這里沒有去取value 34 sm[i] = make(map[int]string, 1) 35 sm[i][0] = "OK" 36 fmt.Println(sm[i]) 37 } 38 fmt.Println(sm) 39 }

以上代碼運行結果如下所示：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

loop slice begin:================= 0 1 1 3 2 5 loop map begin:=================== a liang b xuli c liguang loop slice-map warn begin:======== map[1:OK] map[1:OK] map[1:OK] map[1:OK] map[1:OK] [map[] map[] map[] map[] map[]] loop slice-map normal begin:====== map[0:OK] map[0:OK] map[0:OK] map[0:OK] map[0:OK] [map[0:OK] map[0:OK] map[0:OK] map[0:OK] map[0:OK]]

2.1 對map進行排序

那我們直接上代碼，具體的解釋和上面一樣，在代碼中做了詳細的介紹，具體代碼示例如下：

package mainimport ("fmt""sort" )func main() {// 對map的排序m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}s := make([]int, len(m))i := 0for k, _ := range m {s[i] = ki++}fmt.Println("排序前順序為：", s)sort.Ints(s)fmt.Println("排序后順序為：", s) }

以上代碼運行結果如下：

1 2	排序前順序為： [3 4 5 1 2] 排序后順序為： [1 2 3 4 5]

2.2

　　使用 for range 嘗試將類型為 map[int]string 的鍵和值進行交換，變為類型 map[string]int

package mainimport "fmt"func main() {m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d", 5: "e"}fmt.Println("對調前的map為：", m)exchangeMap := make(map[string]int, len(m))for k, v := range m {exchangeMap[v] = k}fmt.Println("對調后的map為：", exchangeMap) }

以上運行代碼結果如下所示：

1 2	對調前的map為： map[1:a 2:b 3:c 4:d 5:e] 對調后的map為： map[e:5 a:1 b:2 c:3 d:4]

Slice在應用中可能遇到的坑

　　我們說過 Slice 是一個可變數組，當容量不夠的時候系統會自動擴容一倍之后將原始數據拷貝到新的數組中。那么問題來了，新創建出的類型和之前的類型是不一樣的，我們在使用的時候如果還一直使用這個類型取操作里面的數據就會出現問題，具體的問題可以通過以下代碼實例看出：

package mainimport "fmt"func main() {s := make([]int, 0)fmt.Println(s)BulkAdd(s)fmt.Println(s) }func BulkAdd(s []int) {s = append(s, 3)
　　 fmt.Println("BulkAdd:", s) }

運行結果：

1 2	[]<br>BulkAdd: [3] []

　　從以上結果可以看出新增加的內容并未修改了原始的內容，而是作為一個新的類型存在。這種情況下，建議最好使用返回值的方式，這樣不論你怎么修改，即使返回的是一個新的類型我在計算的時候也是使用最新的類型來計算的，這樣在復雜的程序代碼中尤為重要，具體改進如下：

package mainimport "fmt"func main() {s := make([]int, 0)fmt.Println(s)s = BulkAdd(s)fmt.Println(s) }func BulkAdd(s []int) []int {s = append(s, 3)fmt.Println("BulkAdd:", s)return s }

打印結果：

1 2 3

[] BulkAdd: [3] [3]

3. 函數 function

　　1. Go 函數?不支持?嵌套、重載?和?默認參數

　　2. Go 函數支持一下特性：

　　　<1. 無需聲明原型

　　　<2. 不定長度變參

　　?? <3. 可以返回多個值

　　　<4. 命名返回值參數

　　　<5. 匿名函數

　　　<6. 閉包

　　3. 定義函數使用關鍵字 func，且左大括號不能另起一行

　　4. 函數也可以作為一種類型使用

先來看一個正常使用func的示例：

package mainimport "fmt"/** 兩個參數都為int類型，返回值類型也為int類型*/ func plus (a int, b int) int {return a + b }/** 3個參數都為int型，那么就可以簡寫如下形式；返回值可以多個值，并且可以指定返回的類型*/ func plusPlus (a, b, c int) (int, int) {return a + b + c, a * b * c }/** 這里的參數為可變參數列表，其實它就是一個slice 強制規定：可變參數必須放在參互列表的最后位，如果還有其他參數請將其他參數放置其前面*/ func changeParam (a ...int) int {fmt.Println(a)res := 0for _, k := range a {res += k}return res }func changeParmTwo (value string, a ...int) (string, int) {fmt.Println(value, a)res := 0for _, k := range a {res += k}return value, res }func main() {res := plus(1, 3)fmt.Println(res)res_m, res_n := plusPlus(1, 2, 4)fmt.Println(res_m, res_n)result := changeParam(1, 3, 4, 6, 8, 9, 17)fmt.Println(result)value, resultTwo := changeParmTwo("liang", 1, 5, 7, 9, 21, 39)fmt.Println(value, resultTwo)// 匿名函數的使用a := func() {fmt.Println("func A() 將其中A省略將函數類型賦給了a，則函數A就變成了匿名函數")}a() }

以上代碼運行結果如下所示：

1 2 3 4 5 6 7

4 7 8 [1 3 4 6 8 9 17] 48 liang [1 5 7 9 21 39] liang 82 func A() 將其中A省略將函數類型賦給了a，則函數A就變成了匿名函數

那么讓我們來解一道數學題，求給定整數的斐波那契數列值

package mainimport "fmt"//求指定一個數的斐波那契數列 func fact(n int) int {if n == 0 {return 1}return n * fact(n - 1) }func main() {fmt.Println(fact(9)) }

1

362880

4. 閉包

　　閉包（closure）是 javascript 的一大難點，也是它的特色。很多高級應用都是依靠閉包來實現的。

　4.1 變量作用域

　　要理解閉包，首先要理解javascript的特殊的變量作用域。變量的作用域無非就兩種：全局變量?和?局部變量。

　　注意語法規則：函數內部可以直接讀取全局變量，但是在函數外部無法讀取函數內部的局部變量。

　4.2?如何從外部讀取函數內部的局部變量？

　　出于種種原因，我們有時候需要獲取到函數內部的局部變量。但是，上面已經說過了，正常情況下，這是辦不到的！只有通過變通的方法才能實現。那就是在函數內部，再定義一個函數。

　　function f1(){var n=999;function f2(){alert(n); // 999}}

　　在上面的代碼中，函數 f2 就被包括在函數 f1 內部，這時 f1 內部的所有局部變量，對 f2 都是可見的。但是反過來就不行，f2 內部的局部變量，對 f1 就是不可見的。

　　子對象會一級一級地向上尋找所有父對象的變量。所以，父對象的所有變量，對子對象都是可見的，反之則不成立。

　　既然f2可以讀取f1中的局部變量，那么只要把f2作為返回值，我們不就可以在f1外部讀取它的內部變量了嘛。

　4.3 閉包的概念

　　　上面代碼中的f2函數，就是閉包。各種專業文獻的閉包定義都非常抽象，我的理解是:?閉包就是能夠讀取其他函數內部變量的函數。所以說，閉包可以簡單理解成 "定義在一個函數內部的函數"。

　　　所以，在本質上，閉包是將函數內部和函數外部連接起來的橋梁。

　4.4 閉包的用途

　　　閉包可以用在許多地方。它的最大用處有兩個，一個是前面提到的可以讀取函數內部的變量，另一個就是讓這些變量的值始終保持在內存中，不會在f1調用后被自動清除。

　　　為什么會這樣呢？

　　　原因就在于 f1 是 f2 的父函數，而 f2 被賦給了一個全局變量，這導致 f2 始終在內存中，而 f2 的存在依賴于 f1，因此 f1 也始終在內存中，不會在調用結束后，被垃圾回收機制（garbage collection）回收。

　　　這段代碼中另一個值得注意的地方，就是 "nAdd=function(){n+=1}" 這一行，首先在 nAdd 前面沒有使用 var 關鍵字，因此 nAdd 是一個全局變量，而不是局部變量。其次，nAdd的值是一個匿名函數（anonymous function），而這個匿名函數本身也是一個閉包，所以nAdd相當于是一個setter，可以在函數外部對函數內部的局部變量進行操作。

　4.5 使用閉包注意事項

　　（1）由于閉包會使得函數中的變量都被保存在內存中，內存消耗很大，所以不能濫用閉包，否則會造成網頁的性能問題，在IE中可能導致內存泄露。解決方法是，在退出函數之前，將不使用的局部變量全部刪除。

　　（2）閉包會在父函數外部，改變父函數內部變量的值。所以，如果你把父函數當作對象（object）使用，把閉包當作它的公用方法（Public Method），把內部變量當作它的私有屬性（private value），這時一定要小心，不要隨便改變父函數內部變量的值。

　　上面說了一大堆關于 javascript 閉包的概念，是因為閉包的概念最先是由 javascript 提出來的，由于這個功能強大故在 Go 中也被引入，那么接下來我們看一下用 Go 怎么實現閉包的效果呢，其實很簡單，就是使用我們上面介紹的匿名函數實現：

package mainimport "fmt"/** 定義了一個閉包函數（closure），傳入一個整型參數 聲明返回類型為：func(int) int 即返回一個函數*/ func closure(x int) func(int) int {return func(y int) int {return x + y} }func main() {f := closure(9)fmt.Println(f(7))fmt.Println(f(2)) }

以上代碼運行結果如下：

16 11

?

　　函數 defer、panic 和 recover 詳情請查看我另外一篇博客：http://www.cnblogs.com/liang1101/p/6842230.html

總結

以上是生活随笔為你收集整理的GO语言基础map与函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。