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 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 }

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)
}

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)
}

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)
} 

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
}

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()
}

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

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

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