值为切片的map

var sliceM1 = make(map[string][]string, 4)
sliceM1["names"] = make([]string, 4)
sliceM1["names"] = append(sliceM1["names"], "小王","小黄","小李")
fmt.Println(sliceM1)
复制代码

练习题

写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。

// 我的解法
var words string = "how do you do"
var wordsSlice []string = strings.Split(words, " ")
var wordCountMap map[string]int = make(map[string]int)
for _, word := range wordsSlice{
   var _, isIn = wordCountMap[word]
   if isIn {
      wordCountMap[word]++
   } else {
      wordCountMap[word] = 1
   }
}
var printMsg = "在"how do you do"中"
for key,val := range wordCountMap {
   str:= key + "=" + strconv.Itoa(val) + ";"
   printMsg += str
}
fmt.Print(printMsg)
复制代码

观察下面代码，写出最终的打印结果。

type Map map[string][]int
m := make(Map) //[]
s := []int{1,2} // [1 2] len 2 cap 2 x001
s = append(s,3) [1 2 3] len 3 cap 4 x002
fmt.Printf("%+v \n", s) //[1 2 3] len3 cap4 x002
m["q1mi"] = s // [q1mi: [1 2 3] len3 cap4 x002]
s = append(s[:1], s[2:]...) //[1 3] len 2 cap4 x002
fmt.Printf("%+v\n",s) //len2 cap4 x002 [1 3]
fmt.Printf("%+v\n",m["q1mi"])// len3 cap4 //[1 3 3] x002
[1 2 3] [1 3] [1 3 3]
复制代码

函数

Go语言中支持函数、匿名函数和闭包。

函数定义

格式如下：

func 函数名(参数)(返回值){
    函数体
}
复制代码

举个🌰

func main(){
    fmt.Println(intSum(1,2)) //3
}
func intSum(x int, y int)(int) {
    return x + y
}
复制代码

参数

类型简写

函数参数中相邻变量的类型相同，则可以省略类型，举个🌰

func intSum(x,y int) int {
    return x + y
}
复制代码

可变参数

指函数的参数数量不固定，通过在参数名后面加...来表示。

注意：可变参数通常要作为函数的最后一个参数，举个🌰

func intSum(x ...int) int {
    sum := 0
    for _,v := range x {
        x += sum
    }
    return sum
}
复制代码

也可以与固定参数搭配使用

func intSum(x int, y ...int) int {
    sum := x
    for _,v := range x {
        x += sum
    }
    return sum
}
复制代码

本质上，函数的可变参数是通过切片来实现的。

返回值

Go语言通过return关键字向外输出返回值，这一点与JavaScript相同，但也有不同点。

多个返回值

func calc(x, y int) (int, int) {
    sum := x + y
    sub := x - y
    return sub, sum
}
复制代码

返回值命名

函数在定义时可以给返回值命名，并在函数体重使用这些变量，最后用return返回

func calc(x, y int) (sub, sum int) {
    sum = x + y
    sub = x - y
    return
}
复制代码

返回值补充

当函数返回值类型为slice是，nil可以看做是一个有效的slice，没必要返回一个长度为0的切片。

func someFunc(x string) []int {
    if x == "" {
        return nil
    } else {
        res := make([]int,4)
        return res
    }
}
复制代码

变量作用域

全局变量

全局变量指的是定义在函数外部的变量，程序运行期间一直都可以有效访问，与JavaScript的全局变量类似。

var commonNum int = 100 // 全局变量 commonNum
func main() {
    fmt.Println("num:", num) //100
}
func testCommonVar() {
    fmt.Println("num": num) //100
}
复制代码

局部变量

如果全局变量与局部变量重名，那么优先访问局部变量。

var num = 1
func main() {
 num := 10
 fmt.Println(num) // 10
}
复制代码

语句块定义的变量（类似JavaScript中的块级作用域），比如for， if等，举个🌰

func testLocalVar(x, y int) {
    fmt.Println(x,y)// 函数的参数也只在函数内生效
    if x>0 {
      z := 10
      fmt.Println(z)// z只能在此处生效
    }
    fmt.Println(z) //不生效
}
复制代码

函数类型与变量

定义函数类型

可以使用type关键字定义一个函数的类型，格式如下：

type calculation func(int, int) int
复制代码

上面语句定义了一个calculation类型，是一种函数类型，这种函数接受两个int类型的参数并返回一个int类型的返回值。

也就是说，凡是满足这个条件的函数，都是calculation类型的函数，举个🌰

func add(x, y int) int {
    return x + y
}
func sub(x, y int) int {
    return x - y
}
复制代码

add和sub都能赋值给calculation类型的变量。

var c calculation
c = add
c(3,4) //7
复制代码

函数类型变量

可以声明函数类型的变量并且为该变量赋值

var c calculation
c = add
fmt.Printf("type of c: %T\n", c) // main.calculation
fmt.Println(c(1,2))
f := add
fmt.Printf("type of f: %T\n", f) // func(int, int) int
fmt.Println(c(2,3))
复制代码

高阶函数

高阶函数分为函数作为参数和函数作为返回值两部分

函数作为参数

func add(x, y int) int {
    return x+y
}
func calc(x, y int, callback func(int, int) int) int {
    return callback(10, 20)
}
func main() {
    res := calc(10, 20, add)
    fmt.Println(res) //30
}
复制代码

函数作为返回值

func do(s string) (func(int, int) int, error) {
   switch s {
   case "+":
      return add, nil
   case "-":
      return sub, nil
   default:
      err := errors.New("无法识别的操作符")
      return nil, err
   }
}
复制代码

匿名函数和闭包

匿名函数

格式如下：

func(参数)(返回值){
    函数体
}
复制代码

匿名函数因为没有函数名，所以不能直接调用，需要保存到某个变量里，或者作为立即执行函数。

add := func(x, y) int {
    return x + y
}
add(10, 20)
func(x, y) {
    fmt.Println(x + y)
}(1, 2)
复制代码

匿名函数多用于实现回调函数或者闭包

闭包

闭包值得是一个函数与其相关的引用环境组合而成的实体。简单来说就是：闭包=函数+引用环境，举个🌰

func add() func(int) int {
   var x int
   return func(y int) int {
       x += y
       return x
   }
}
f := add()
fmt.Println(f(10))//10
fmt.Println(f(20))//30
f1 := add()
fmt.Println(f1(20))//20
fmt.Println(f1(40))//60
复制代码

与JavaScript相似，函数体内的变量如果被函数体以外的环境引用，就会形成闭包，该变量不会销毁。

闭包示例2：

func makeSuffixFunc(suffix string) func(string) string {
    return func(fileName string) string {
        if !strings.HasSuffix(fileName, suffix) {
            return fileName + suffix
        }
        return fileName
    }
}
复制代码

闭包示例3：

func calc(base int) (func(int) int, func(int) int) {
    add := func(num int) int {
        base += num
        return base
    }
    sub := func(num int) int {
        base -= num
        return base
    }
    return add, sub
}
add, sub := calc(10)
fmt.Println(add(1)) // 11
fmt.Println(add(2)) // 9
复制代码

defer语句

defer语句会将其后面跟孙的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先defer的后执行，后defer的先执行，举个🌰

fmt.Println("start")
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println(4)
fmt.Println("end")
// start 4 end 3 2 1
复制代码

多用于处理资源释放问题，例如：资源清理，文件关闭，解锁，记录时间等。

defer的执行时机

返回值=x --> 运行defer --> ret指令

牢记defer的三条规则

延迟函数的参数在defer语句出现的时候就已经确定下来了
后进先出的规则
延迟函数可能会影响主函数的具名返回值

defer案例

// 主函数拥有匿名返回值，返回变量
//一个主函数拥有一个匿名的返回值，返回使用本地或全局变量，这种情况下defer语句可以引用到返回值，但不会改变返回值。
// 返回5
func f1() int {
  x := 5
  defer func() {
    x++
  }()
  return x 
}
// 主函数拥有具名返回值
// 主函声明语句中带名字的返回值，会被初始化成一个局部变量，函数内部可以像使用局部变量一样使用该返回值。如果defer语句操作该返回值，可能会改变返回结果。
// x =5
// x++
// return
func f2() (x int) {
  defer func() {
    x++
  }()
  return 5
}
// 主函数拥有具名返回值
// x = 5
// y = x
// x++
// return
func f3() (y int) {
  x := 5
  defer func() {
    x++
  }()
  return x
}
// 主函数拥有具名返回值，但是延迟函数的参数从defer开始就确定了，相当于拷贝一份，所以后面的x++是自执行函数x的++
func f4() (x int) {
  defer func(x int) {
    x++
  }(x)
  return 5
}
func main() {
  fmt.Println(f1()) // 5
  fmt.Println(f2()) // 6
  fmt.Println(f3()) // 5
  fmt.Println(f4()) // 5
}
复制代码

defer面试题

func calc(index string, a, b int) int {
  ret := a + b
  fmt.Println(index, a, b, ret)
  return ret
}
func main() {
  x := 1
  y := 2
  defer calc("AA", x, calc("A", x, y))
  x = 10
  defer calc("BB", x, calc("B", x, y))
  y = 20
}
// A 1 2 3
// B 10 2 12
// BB 10 12 22
// AA 1 3 4
复制代码

内置函数

函数名	介绍
close	用来关闭channel
len	用来求长度，比如string array slice map channel
new	用来分配内存，主要用来分配值类型，比如int, struct。返回的是指针
make	用来分配内存，主要用来分配引用类型，比如chan map slice
append	用来追加元素到数组中、slice中
panic和recover	用来做错误处理

panic/recover

panic用来处理错误，可以在任何地方引发，但recover只有在defer调用的函数中有效，举个🌰

func funcA() {
    fmt.Println("func A")
}
func funcB() {
    panic("func B error")
}
func funcC() {
    fmt.Println("func C")
}
func main() {
    funcA()
    funcB()
    funC()
}
复制代码

这时候程序就会崩溃，因为funcB中引发了panic，但是，我们可以通过recover让程序起死回生！只需要对funcB做一下修改举个🌰

func funcB() {
    defer func(){
        err := recover()
        if err != nil {
            fmt.Println("func B")
        }
    }()
    panic("func B error")
}
复制代码

注意

recover必须搭配defer使用
defer一定要再可能发panic的语句之前定义

练习题

分金币

/*
你有50枚金币，需要分配给以下几个人：Matthew,Sarah,Augustus,Heidi,Emilie,Peter,Giana,Adriano,Aaron,Elizabeth。
分配规则如下：
a. 名字中每包含1个'e'或'E'分1枚金币
b. 名字中每包含1个'i'或'I'分2枚金币
c. 名字中每包含1个'o'或'O'分3枚金币
d: 名字中每包含1个'u'或'U'分4枚金币
写一个程序，计算每个用户分到多少金币，以及最后剩余多少金币？
程序结构如下，请实现 ‘dispatchCoin’ 函数
*/
var (
  coins = 50
  users = []string{
    "Matthew", "Sarah", "Augustus", "Heidi", "Emilie", "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
  }
  distribution = make(map[string]int, len(users))
)
func main() {
  left := dispatchCoin()
  fmt.Println("剩下：", left)
}
// 我的解法
func dispatchCoin() int {
   coinSum := coins
   for _,person := range users{
      distribution[person] = 0
      nameLower := strings.ToLower(person)
      nameSlice := strings.Split(nameLower, "")
      for _,nameWord := range nameSlice {
         switch nameWord {
            case "e":
               distribution[person] += 1
               coinSum-=1
            case "i":
               distribution[person] += 2
               coinSum-=2
            case "o":
               distribution[person] += 3
               coinSum-=3
            case "u":
               distribution[person] += 4
               coinSum-=4
            default:
               break
         }
      }
   }
   for key,value := range distribution{
      fmt.Printf("%v分到了：%v个\n",key, value)
   }
   return coinSum
}

【Go】Go语言学习笔记--Go语言基础【下】

值为切片的map

练习题

函数

函数定义

参数

类型简写

可变参数

返回值

多个返回值

返回值命名

返回值补充

变量作用域

全局变量

局部变量

函数类型与变量

定义函数类型

函数类型变量

高阶函数

函数作为参数

函数作为返回值

匿名函数和闭包

匿名函数

闭包

defer语句

defer的执行时机

牢记defer的三条规则

defer案例

defer面试题

内置函数

panic/recover

练习题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【Go】Go语言学习笔记--Go语言基础【下】

值为切片的map

练习题

函数

函数定义

参数

类型简写

可变参数

返回值

多个返回值

返回值命名

返回值补充

变量作用域

全局变量

局部变量

函数类型与变量

定义函数类型

函数类型变量

高阶函数

函数作为参数

函数作为返回值

匿名函数和闭包

匿名函数

闭包

defer语句

defer的执行时机

牢记defer的三条规则

defer案例

defer面试题

内置函数

panic/recover

练习题

热门文章

最新文章

相关课程

相关电子书

相关实验场景