Golang 函数

为什么需要函数

  1. 完成一个这样的需求：
    • 输入两个数，再输入一个运算符(+, -, *, /)，得到结果。
    • 对比传统的解决方法与使用函数方法的不同。
  2. 传统方法的代码 ```go package main

import “fmt”

func main() { /*

  1. 1. 请大家完成这样一个需求：
  2.     输入两个数，再输入一个运算符(+, -, *, /)，得到结果。
  3. */
  6. var n1 float64 = 1.2
  7. var n2 float64 = 2.3
  8. var operator byte = '+'
  9. var res float64
  11. switch operator {
  12.     case '+':
  13.         res = n1 + n2
  14.     case '-':
  15.         res = n1 - n2
  16.     case '*':
  17.         res = n1 * n2
  18.     case '/':
  19.         res = n1 / n2
  20.     default:
  21.         fmt.Println("操作符输入有误...")
  22. }
  23. fmt.Println("res =", res)

}

  2. 3. 上面代码的问题 
  3.    - 上面的写法是可以完成功能，但是代码冗余。 
  4.    - 同时不利于代码维护。 
  5.    - 函数可以解决这个问题。 
  6. <a name="LJ6WJ"></a>
  7. ## 函数
  9. 1. 为了完成某一功能的程序指令(语句)的集合，称为函数。在 Go 中，函数分为：自定义函数、系统函数。
  10. <a name="MvKcg"></a>
  11. ## 基本语法
  13. 1. 语法
  14. ```go
  15. func 函数名 (形参列表) (返回值列表) {
  16.   执行语句
  17.   return 返回值列表
  18. }
  1. 说明：
    • 形参列表：表示函数的输入。
    • 函数中的语句：表示为了实现某一功能代码块。
    • 函数可以有返回值，也可以没有。

      快速入门案例

      ```go package main

import “fmt”

func cal(n1 float64, n2 float64, operator byte) float64 { //将计算功能，放到一个函数中，在需要使用时，调用即可。

  1. var res float64
  3. switch operator {
  4.     case '+':
  5.         res = n1 + n2
  6.     case '-':
  7.         res = n1 - n2
  8.     case '*':
  9.         res = n1 * n2
  10.     case '/':
  11.         res = n1 / n2
  12.     default:
  13.         fmt.Println("操作符输入有误...")
  14. }
  15. return res

}

func main() { /*

  1.     1. 请大家完成这样一个需求：
  2.         输入两个数，再输入一个运算符(+, -, *, /)，得到结果。
  3. */
  6. //进行参数传递
  7. var n1 float64 = 1.2
  8. var n2 float64 = 2.3
  9. var operator byte = '+'
  11. result := cal(n1, n2, operator) //函数调用
  13. fmt.Println("result =", result)

}

  1. <a name="gm9Ka"></a>
  2. ## 包的引出
  4. 1. 在实际开发中，我们往往需要在不同的文件中，去调用其他文件的定义的函数，比如 main.go 中，去使用 utils.go 文件中的函数，如何实现？==> 包
  5. 1. 现在有两个程序员共同开发一个 Go 项目，程序员小明希望定义函数 Cal ，程序员小北也想定义函数也叫 Cal ，两个程序员为此还吵了起来，怎么办？==> 包
  6. <a name="cL5A9"></a>
  7. ### 包的原理
  9. 1. 包的本质实际上就是创建不同的文件夹，来存放程序文件。
  10. <a name="CPkLV"></a>
  11. ### 包的介绍
  12. <a name="fe9Dq"></a>
  13. #### 包的基本概念
  15. 1. Golang 的每一个文件都是属于一个包的，也就是说 Golang 是以包的形式来管理文件和项目目录结构的。
  16. <a name="Vt7E0"></a>
  17. #### 包的三大作用
  19. 1. 区分相同名字的函数、变量等标识符。
  20. 1. 当程序文件很多时，可以很好地管理项目。
  21. 1. 控制函数、变量等访问范围，即作用域。
  22. <a name="uGt0S"></a>
  23. #### 包的相关说明
  25. 1. 打包基本语法
  26. ```go
  27. package util

  1. 引入包基本语法

    1. import "包的路径"

    快速入门案例

  2. 说明：我们将 func Cal 定义到文件 utils.go ，将 utils.go 放到一个包中，当其他文件需要使用到 utils.go 的方法时，可以使用 import 该包，就可以使用了。

  3. util 包中 util.go 内容 ```go package utils

import “fmt”

// 为了让其他包的文件使用 cal 函数，需要将 c 大写类似于其他语言的 public func Cal(n1 float64, n2 float64, operator byte) float64 { //将计算功能，放到一个函数中，在需要使用时，调用即可。

  1. var res float64
  3. switch operator {
  4. case '+':
  5.     res = n1 + n2
  6. case '-':
  7.     res = n1 - n2
  8. case '*':
  9.     res = n1 * n2
  10. case '/':
  11.     res = n1 / n2
  12. default:
  13.     fmt.Println("操作符输入有误...")
  14. }
  15. return res

}

  2. 3. main 包中 main.go 的内容
  3. ```go
  4. package main
  6. import (
  7.     "GoProject/src/go_code/chapter06/function_case_03/utils" //导包
  8.     "fmt"
  9. )
  11. func main() {
  12.     /*
  13.         1. 请大家完成这样一个需求：
  14.            输入两个数，再输入一个运算符(+, -, *, /)，得到结果。
  15.     */
  18.     //进行参数传递
  19.     var n1 float64 = 1.2
  20.     var n2 float64 = 2.3
  21.     var operator byte = '+'
  23.     result := utils.Cal(n1, n2, operator) //函数调用
  25.     fmt.Println("result = ", result)
  26. }

包的注意事项和细节说明

  1. 在给一个文件打包时，该包对应一个文件，比如这里的 utils 文件夹对应的包名就是 utils ，文件的包名通常和文件所在文件夹一致，一般为小写字母。

  2. 当一个文件要使用其他包函数或变量时，需要先引入对应的包。

    • 引入方式1：import “包名”

    • 引入方式2： 

      1. import (
      2. "包名"
      3. "包名"
      4. )

    • package 指令在文件第一行，然后是 import 指令。

    • 在 import 包时，路径从 $GOPATH 的 src 下开始，不用带 src ，编译器会自动从 src 下开始引入。
  3. 为了让其他包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其他语言的 public ，这样才能跨包访问。
  4. 在访问其他包函数时，其语法是包名.函数名。
  5. 如果包名较长，Go 支持给包取别名，注意细节，取别名后，原来的包名就不能使用了。
  6. 在同一个包下，不能有相同的函数名(也不能有相同的全局变量名)，负责报重复定义。

  7. 如果你要编译成一个可执行程序文件，就需要将这个包声明为 main ，即 package main 。这个就是一个语法规范，如果你是写一个库，包名可以自行定义。

    函数的调用机制

    函数调用机制的底层分析

  8. 栈区：基本数据类型一般分配到栈区，编译器存在一个逃逸分析。

  9. 堆区：引用数据类型一般分配到堆区，编译器存在一个逃逸分析。

  10. 代码区：代码的存放位置。

    快速入门案例

  11. 案例代码一 ```go package main

import “fmt”

func test(n1 int) { n1 = n1 + 1 fmt.Println(“n1 =”, n1) }

func main() { //定于变量 n1 := 10 //调用 test test(n1) fmt.Println(“n1 =”, n1) }

  2. 2. 代码说明 
  3.    - 在调用一个函数时，会给该函数分配一个新的空间。编译器会通过自身的处理让这个新的空间和其他的栈的空间区分开来。 
  4.    - 在每个函数对应的栈中，数据空间式独立的，不会混淆。 
  5.    - 当一个函数调用完毕(执行完毕)，程序会销毁这个函数对应的栈空间。 
  6. 3. 案例代码二 
  7. ```go
  8. package main
  10. import "fmt"
  12. //一个函数 getSum
  13. func getSum(n1 int, n2 int) int {
  14.     sum := n1 + n2 // 30
  15.     fmt.Println("getSum sum =", sum)
  16.     //当函数有 return 语句是，就是将结果返回给调用者
  17.     //即谁调用我，就返回给谁
  18.     return sum
  19. }
  21. func main() {
  22.     n1 := 10
  23.     n2 := 20
  24.     sum := getSum(n1, n2)
  25.     fmt.Println("main sum = ", sum)
  26. }

return 语句

基本介绍

  1. Go 语言支持返回多个值，这一点是其他编程语言没有的。

  2. 基本语法

    1. func 函数名 (形参列表) (返回值类型列表) {
    2.  语句...
    3.  return 返回值列表
    4. }

  3. 如果返回多个值时，在接收时，希望忽略某个返回值，则使用 _ 符号表示占位忽略。

  4. 如果返回值只有一个，(返回值类型列表)可以不写()。

    快速入门案例

  5. 案例代码 ```go package main

import “fmt”

//请编写一个函数，可以计算两个数的和与差，并返回结果。 func getSumAndSub(n1 int, n2 int) (int, int) { sum := n1 + n2 sub := n1 - n2 return sum, sub }

func main() { //调用getSumAndSub res1, res2 := getSumAndSub(1, 2) // res1 = 3, res2 = -1 fmt.Printf(“res1 = %v res2 = %v \n”, res1, res2) }

  1. <a name="DQ2Fe"></a>
  2. ## 函数的递归调用
  3. <a name="FYdmN"></a>
  4. ### 基本介绍
  6. 1. 一个函数在函数体内又调用了本身，我们成为递归调用。
  7. <a name="qmfD2"></a>
  8. ### 快速入门案例
  10. 1. 案例代码一
  11. ```go
  12. package main
  14. import "fmt"
  16. func test(n int) {
  17.     if n > 2 {
  18.         n--
  19.         test(n)
  20.     }
  21.     fmt.Println("n =", n)
  22. }
  25. func main() {
  26.     //看一段代码
  27.     test(4)
  28. }
  1. 案例代码二 ```go package main

import “fmt”

func test2(n int) { if n > 2 { n— test2(n) } else { fmt.Println(“n =”, n) }

}

func main() { //看一段代码 test2(4) }

  1. <a name="fy3Mq"></a>
  2. ### 递归调用的总结
  4. 1. 函数递归需要遵守的重要守则： 
  5.    - 执行一个函数式，就创建一个新的受保护的独立空间(新函数栈)。 
  6.    - 函数的局部变量是独立的，不会相互影响的。 
  7.    - 递归必须向退出递归的条件逼近，否则就是无限递归。 
  8.    - 当一个函数执行完毕，或者遇到 return ，就会返回，遵守谁调用，就将结果返回给谁，同时当函数执行完毕或者返回时，该函数本身也会被系统销毁了。 
  9. <a name="DZH9E"></a>
  10. ### 课堂练习
  12. 1. 练习一
  13. ```go
  14. package main
  16. import "fmt"
  18. /*
  19.     请使用递归的方式，求出斐波那契数列1，1，2，3，5，8，13...
  20.     给你一个整数 n ，求出它的斐波那契数是多少？
  21. */
  23. func fbn(n int) int {
  24.     if (n == 1 || n == 2) {
  25.         return 1
  26.     } else {
  27.         return fbn(n-1) + fbn(n-2)
  28.     }
  29. }
  31. func main() {
  32.     //测试
  33.     res := fbn(3)
  34.     fmt.Println("res =", res)
  35.     fmt.Println("res =", fbn(4)) // 3
  36.     fmt.Println("res =", fbn(5)) // 5
  37.     fmt.Println("res =", fbn(6)) // 8
  38. }
  1. 练习二 ```go package main

import “fmt”

/ 求函数值：已知 f(1) = 3；f(n) = 2 f(n-1) + 1; 请使用递归的思想编程，求出 f(n) 的值 */

func f(n int) int { if n == 1 { return 3 } else { return 2 * f(n - 1) + 1 } }

func main() { //测试一下 fmt.Println(“f(1) =”, f(1)) fmt.Println(“f(5) =”, f(5)) }

  2. 3. 练习三
  3. ```go
  4. package main
  6. import "fmt"
  8. /*
  9.     猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一般，并再多吃了一个！以后每天猴子都吃其中的一半，
  10.     然后再多吃一个。当到第十天时，想再吃时(还没吃)，发现只有一个桃子了。
  11.     问题：最初共有多少个桃子？
  12. */
  14. /*
  15.     思路分析：
  16.     1. 第十天只有一个桃子
  17.     2. 第九天有几个桃子 = (第十天桃子数量 + 1) * 2
  18.     3. 规律：第 n 天的桃子数量 peach(n) = (peach(n + 1) + 1) * 2
  19. */
  21. //n 范围是 1--10 之间
  22. func peach(n int) int {
  23.     if n > 10 || n < 1 {
  24.         fmt.Println("输入天数不对")
  25.         return 0 //表示没有得到正确数量
  26.     } else if n == 10 {
  27.         return 1
  28.     } else {
  29.         return (peach(n + 1) + 1) * 2
  30.     }
  31. }
  33. func main() {
  34.     //测试一下
  35.     fmt.Println("peach(1) =", peach(1))
  36.     fmt.Println("peach(9) =", peach(9))
  37. }

函数注意事项和细节讨论

  1. 函数的形参列表可以是多个，返回值列表也可以是多个。
  2. 形参列表和返回值列表的数据类型可以是值类型和引用类型。
  3. 函数的命名遵循表示符命名规范，首字母不能是数字，首字母大写该函数可以被本包文件和其他包文件使用，类似 public ，首字母小写，只能被本报文件使用，其他包文件不能使用，类似 private 。
  4. 函数中的变量是局部的，函数外不生效。 ```go package main

import “fmt”

//函数中的变量是局部的，函数外不生效。 func test() { //n1 是 test 函数的局部变量，只能在 test 函数中使用 var n1 int = 10 fmt.Println(n1) } func main() { // 这里不能使用 n1 ，因为 n1 是 test 函数的局部变量 //fmt.Println(“n1 =”, n1) test() }

  2. 5. 基本数据类型和数组默认都是值传递，即进行值拷贝。在函数内修改，不会影响到原来的值。
  3. ```go
  4. package main
  6. import "fmt"
  9. func test02(n1 int) {
  10.     n1 = n1 + 10
  11.     fmt.Println("test02 n1 =", n1)
  12. }
  15. func main() {
  16.     n1 := 20
  17.     test02(n1)
  18.     fmt.Println("main() n1 =", n1)
  19. }
  1. 如果希望函数内的变量能修改函数外的变量，可以传入变量的地址，函数内以指针的方式操作变量。 ```go package main

import “fmt”

func test03(n1 *int) {

  1. fmt.Printf("n1的地址 %v \n", &n1)
  2. *n1 = *n1 + 10
  3. fmt.Println("test03() n1 =", *n1) // 30

}

func main() {

  1. num := 20
  2. fmt.Printf("num的地址=%v \n", &num)
  3. test03(&num)
  4. fmt.Println("main() num =", num)  // 30

}

  2. 7. Go 函数不支持传统函数重载。
  3. 7. 在 Go 中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。
  4. ```go
  5. package main
  7. import "fmt"
  10. //在 Go 中，函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。
  12. func getSum(n1 int, n2 int) int {
  13.     return n1 + n2
  14. }
  17. func main() {
  19.     a := getSum
  21.     fmt.Printf("a的类型%T, getSum类型是%T \n", a, getSum)
  23.     res := a(10, 40) // 等价 res := getSum(10, 40)
  24.     fmt.Println("res =", res)
  25. }
  1. 函数既然是一种数据类型，因此在 Go 中，函数可以作为形参，并且调用！ ```go package main

import “fmt”

//函数既然是一种数据类型，因此在 Go 中，函数可以作为形参，并且调用！

func getSum(n1 int, n2 int) int { return n1 + n2 }

func myFun(funvar func(int, int) int, num1 int, num2 int) int { return funvar(num1, num2) }

func main() {

  1. //看案例
  2. res2 := myFun(getSum, 50, 60)
  3. fmt.Println("res2 =", res2)

}

  2. 10. 为了简化数据类型定义，Go 支持自定义数据类型。
  3. - 基本语法：type 自定义数据类型名 数据类型 // 理解：相当于一个别名 
  4.    - 案例：type myInt int // 这是 myInt 就等价 int 来使用了。 
  5.    - 案例：type mySum func(int, int) int //这是 mySum 就等价于一个函数类型 func(int, int) int 
  6. - 案例一 
  7. ```go
  8. package main
  10. import "fmt"
  13. func main() {
  15.     type myInt int //给 int 取了别名，在 Golang 中 myInt 和 int 虽然都是 int 类型，但是 Golang 认为 myInt 和 int 是两个类型
  17.     var num1 myInt
  18.     var num2 int
  19.     num1 = 40
  20.     // num2 = num1  Golang 认为类型不同
  21.     num2 = int(num1)
  22.     fmt.Println("num1 =", num1)
  23.     fmt.Println("num2 =", num2)
  24. }
  • 案例二 ```go package main

import “fmt”

func getSum(n1 int, n2 int) int { return n1 + n2 }

type myFunType func(int, int) int //这是 myFunType 就是 func(int, int) int

func myFun(funvar myFunType, num1 int, num2 int) int { return funvar(num1, num2) }

func main() {

  1. //看案例
  2. res3 := myFun(getSum, 50, 60)
  3. fmt.Println("res3 =", res3)

}

  2. 11. 支持对函数返回值命名
  3. ```go
  4. package main
  6. import "fmt"
  9. func getSumAndSub(n1 int, n2 int) (sum int, sub int) {
  10.     sum = n1 + n2
  11.     sub = n1 - n2
  12.     return
  13. }
  15. func main() {
  16.     sum, sub := getSumAndSub(10, 20)
  17.     fmt.Printf("sum = %v sub= %v \n", sum, sub)
  18. }
  1. 使用 _ 标识符，忽略返回值 ```go package main

import “fmt”

func getSumAndSub(n1 int, n2 int) (sum int, sub int) { sum = n1 + n2 sub = n1 - n2 return }

func main() { sum, _ := getSumAndSub(10, 20) fmt.Printf(“sum = %v \n”, sum) }

  2. 13. Go 支持可变参数
  3. - 语法
  4. ```go
  5. //支持 0 到多个参数
  6. func sum(arg...int) sum int {
  7. }
  8. //支持 1 到多个参数
  9. func sum(n1 int, arg...int) sum int {
  10. }
  • 说明：
    • args 是 slice ，通过 arg[index] 可以访问到各个值。
    • 如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表。
  • 案例一 ```go package main

import “fmt”

//案例编写：编写一个函数 sum，可以求出 1 到多个 int 的和 func sum(n1 int, args…int) int { sum := n1 //遍历 args for i := 0; i < len(args); i++ { sum += args[i] // args[0] 表示取出 args 切片的第一个元素值，其他依次类推。 } return sum }

func main() { //测试一下可变参数的使用 res4 := sum(10, 11, 13, 16) fmt.Println(“res4 =”, res4) }

  1. <a name="rMjaN"></a>
  2. ## init 函数
  3. <a name="VwGDM"></a>
  4. ### 基本介绍
  6. 1. 每一个源文件都可以包含一个 init 函数，该函数会在 main 函数执行前，被 Go 运行框架调用，也就是说 init 会在 main 函数前被调用。
  7. <a name="Mqdim"></a>
  8. ### 快速入门案例
  10. 1. 案例一
  11. ```go
  12. package main
  14. import "fmt"
  17. // init 函数，通常可以在 init 函数中完成初始化工作
  18. func init() {
  19.     fmt.Println("init()...")
  20. }
  23. func main() {
  24.     fmt.Println("main()...")
  25. }

init 函数的注意事项和细节

  1. 如果一个文件同时包含全局变量定义，init 函数和 main 函数，则执行的流程是变量定义 -> init 函数 -> main 函数。 ```go package main

import “fmt”

var age = test()

//为了看到全局变量是先被初始化的，我们这里先写函数 func test() int { fmt.Println(“test()”) return 90 } //init 函数，通常可以在 init 函数中完成初始化工作 func init() { fmt.Println(“init()…”) }

func main() { fmt.Println(“main()…”) }

  2. 2. init 函数最主要的作用，就是完成一些初始化的工作。
  3. <a name="duhL5"></a>
  4. ## 匿名函数
  5. <a name="qX4ai"></a>
  6. ### 基本介绍
  8. 1. Go 支持匿名函数，如果我们某个函数只是希望使用一次，可以考虑使用匿名函数，匿名函数也可以实现多次调用。
  9. 1. 匿名函数使用方式一：在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次。
  10. ```go
  11. package main
  13. import "fmt"
  16. func main() {
  17.     //在定义匿名函数时就直接调用，这种方式匿名函数智能调用一次
  19.     //案例演示，求来两个数的和，使用匿名函数的方式完成
  20.     res1 := func (n1 int, n2 int) int {
  21.         return n1 + n2
  22.     }(10,20)
  24.     fmt.Println("res1 =", res1)
  25. }
  1. 匿名函数使用方式二：将匿名函数赋给一个变量(函数变量，在通过该变量来调用匿名函数) ```go package main

import “fmt”

func main() { //在定义匿名函数时就直接调用，这种方式匿名函数智能调用一次

  1. //案例演示，求来两个数的和，使用匿名函数的方式完成
  2. res1 := func (n1 int, n2 int) int {
  3.     return n1 + n2
  4. }(10,20)
  6. fmt.Println("res1 =", res1)
  8. //将匿名函数 func (n1 int, n2 int) int 赋给 a 变量。
  9. //则 a 的数据类型就是函数类型，此时，我们可以通过 a 完成调用。
  11. a := func (n1 int, n2 int) int {
  12.     return n1 - n2
  13. }
  15. res2 :=a(10, 30)
  17. fmt.Println("res2 =", res2)
  19. res3 :=a(90, 30)
  21. fmt.Println("res3 =", res3)

}

  2. 4. 全局匿名函数：如果将匿名函数赋给一个全局变量，那么这个匿名函数，就成为一个全局匿名函数，可以在程序有效。
  3. ```go
  4. package main
  6. import "fmt"
  8. var (
  9.     //Fun1就是一个全局匿名函数
  10.     Fun1 = func (n1 int, n2 int) int {
  11.         return n1 * n2
  12.     }
  13. )
  15. func main() {
  16.     //全局匿名函数的使用
  17.     res4 := Fun1(4, 9)
  18.     fmt.Println("res4 =", res4)
  19. }

闭包

基本介绍

  1. 闭包就是一个函数与其相关的引用环境组合的一个整体。

    快速入门案例

  2. 案例一 ```go package main

import “fmt”

//累加器 func AddUpper() func (int) int { var n int = 10 return func (x int) int { n = n + x return n } }

func main() { //使用前面的代码 f := AddUpper() fmt.Println(f(1)) // 11 fmt.Println(f(2)) // 13 fmt.Println(f(3)) // 13

}

  2. 2. 案例说明
  3.    - AddUpper 是一个函数，犯规的数据类型是 fun(int) int
  4.    - 闭包的说明：返回的是一个函数，但是这个匿名函数引用到函数外的 n ，因此这个匿名函数就和 n 形成一个整体，构成了闭包。
  5.    - 大家可以这样理解：闭包是类，函数是操作，n 是字段。函数和它使用到的 n 构成闭包。
  6.    - 当我们反复的调用 f 函数时，因为这个 n 是初始化，因此每调用一次就进行累计。
  7.    - 我们要搞清楚闭包的关键，就是要分析出返回的函数它使用(引用)到哪些变量，因为函数和它引用到的变量共同构成闭包。
  8. 3. 案例二
  9. ```go
  10. package main
  12. import "fmt"
  14. //累加器
  15. func AddUpper() func (int) int {
  16.     var n int = 10
  17.     var str = "hello"
  18.     return func (x int) int {
  19.         n = n + x
  20.         str += "a"
  21.         fmt.Println("str =", str) // 1. str="helloa" 2. str = "helloaa" 3. str = "helloaaa"
  22.         return n
  23.     }
  24. }
  27. func main() {
  28.     //使用前面的代码
  29.     f := AddUpper()
  30.     fmt.Println(f(1)) //11
  31.     fmt.Println(f(2)) //13
  32.     fmt.Println(f(3)) //13
  34. }
  1. 案例三 ```go package main

import ( “fmt” “strings” )

/* 请编写一个程序，具体要求如下：

  1. 1. 编写一个函数 makeSuffix(suffix string) 可以接受一个文件后缀名(比如.jpg)，并返回一个闭包。
  2. 2. 调用闭包，可以传入一个文件名，如果该文件名没有指定的后缀(比如.jpg)，则返回文件名 .jpg ，如果已经
  3. 有 .jpg 后缀，则返回原文件名。
  4. 3. 要求使用必报的方式完成。
  5. 4. strings.HasSuffix，该函数可以判断某个字符串是否有指定的后缀。

*/

func makeSuffix(suffix string) func (string) string { return func (name string) string { //如果 name 没有指定的后缀，则加上，否则就返回原来的名字 if strings.HasSuffix(name, suffix) == false { return name + suffix } else { return name } } }

func main() { //测试 makeSuffix 的使用 //返回一个闭包 f := makeSuffix(“.jpg”) fmt.Println(“文件名处理后 =”, f(“winter”)) // winter.jpg fmt.Println(“文件名处理后 =”, f(“bird.jpg”)) }

  2. 5. 案例说明
  3.    - 返回的匿名函数和 makeSuffix(suffix string) 的 suffix 变量组合成一个闭包，因为返回的函数引用到 suffix 这个变量。
  4.    - 我们体会一下闭包的好处，如果使用传统的方法，也可以轻松实现这个功能。
  5. <a name="Tmduf"></a>
  6. ## 函数中 - defer
  7. <a name="T1PCO"></a>
  8. ### 为什么需要 defer
  10. 1. 在函数中，程序员经常需要创建资源(比如：数据库连接、文件句柄、锁等)，为了爱函数执行完毕后，及时的释放资源，Go 的设计者提供 defer(延时机制)。
  11. <a name="PWRqH"></a>
  12. ### 快速入门案例
  14. 1. 案例一
  15. ```go
  16. package main
  18. import "fmt"
  21. func sum(n1 int, n2 int) int {
  23.     //当执行到 defer 时，暂时不执行，会将 defer 后面的语句压入到独立的栈(defer 栈)。
  24.     //当函数执行完毕后，再从 defer 栈，按照先入后出的方式出栈，执行。
  25.     defer fmt.Println("ok1 n1 =", n1)
  26.     defer fmt.Println("ok2 n2 =", n2)
  28.     res := n1 + n2
  29.     fmt.Println("ok3 res =", res)
  30.     return res
  31. }
  34. func main() {
  35.     res := sum(1, 2)
  36.     fmt.Println("res =", res)
  37. }

defer 的细节说明

  1. 当 Golang 执行到一个 defer 时，不会立即执行 defer 后的语句，而是将 defer 后的语句压入到一个栈中(暂时将该栈称为 defer 栈)，然后继续执行函数下一个语句。
  2. 当函数执行完毕后，在从 defer 栈中，一次从栈顶取出语句执行(注：遵守栈先入后出的机制)。
  3. 在 defer 将语句放入到栈时，也会将相关的值拷贝同时入栈。 ```go package main

import “fmt”

func sum(n1 int, n2 int) int {

  1. //当执行到 defer 时，暂时不执行，会将 defer 后面的语句压入到独立的栈。
  2. //当函数执行完毕后，再从 defer 栈，按照先入后出的方式出栈，执行。
  3. defer fmt.Println("ok1 n1 =", n1) // 1
  4. defer fmt.Println("ok2 n2 =", n2) // 2
  5. //增加一句话
  6. n1++ //2
  7. n2++ //3
  9. res := n1 + n2
  10. fmt.Println("ok3 res =", res)
  11. return res

}

func main() { res := sum(1, 2) fmt.Println(“res =”, res) }

  1. <a name="uU3cr"></a>
  2. ### defer 的最佳实践
  4. 1. defer 最主要的价值是在，当函数执行完毕后，可以及时的释放函数创建的资源。 
  5. 1. defer 的最佳实践 
  6.    - 在 Golang 编程中的通常做法是，创建资源后，比如(打开了文件，获取了数据库的连接，或者是锁资源)，可以利用 defer 延时机制。 
  7.    - 在 defer 后，可以继续使用创建资源。 
  8.    - 当函数完毕后，系统会依次从 defer 栈中，取出语句，关闭资源。 
  9.    - 这种机制，非常简洁，程序元不用再为在什么时机关闭资源而烦心了。 
  10. <a name="lkrbL"></a>
  11. ## 函数参数的传递方式
  12. <a name="TdoZb"></a>
  13. ### 基本介绍
  15. 1. 我们在讲解函数注意事项和使用细节时，已经讲过值类型和引用类型了，这里再系统总结一下。值类型参数默认就是值传递，而引用类型参数默认就是引用传递。
  16. <a name="DXuJh"></a>
  17. ### 两种传递方式
  19. 1. 值传递 
  20. 1. 引用传递 
  21.    - 说明：其实，不管是值传递还是引用传递，传递给函数的都是变量的副本，不同的是，值传递的是值的拷贝，引用传递的是地址的拷贝，一般来说，地址拷贝效率高，因为数据量小，而值拷贝决定拷贝的数据大小，数据越大，效率越低。
  22. <a name="B3imh"></a>
  23. ### 值类型和引用类型
  25. 1. 值类型：基本数据类型 int 系列，float 系列，bool，string、数组和结构体 struct 。
  26. 1. 引用类型：指针、slice 切片、map、管道 chan、interface 等都是引用类型。
  27. <a name="aVT8f"></a>
  28. ### 值传递和引用传递使用特点
  30. 1. 值类型默认是值传递：变量直接存储值，内存通常在栈中分配。
  31. 1. 引用类型默认是引用传递：变量存储的是一个地址，这个地址对应的空间才真正存储数据，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收。
  32. 1. 如果希望函数内的变量能修改函数外的变量，可以传入变量的地址，函数内指针的方式操作变量。
  33. <a name="RAeYs"></a>
  34. ## 变量的作用域
  35. <a name="tJ7iP"></a>
  36. ### 基本介绍
  38. 1. 函数内部声明/定义的变量叫局部变量，作用域仅限于函数内部。
  39. ```go
  40. package main
  42. import "fmt"
  45. //函数
  46. func test() {
  47.     //age 和 Name 的作用域就只在 test 函数内部
  48.     age := 10
  49.     Name := "tom~"
  51.     fmt.Println("age =", age)
  52.     fmt.Println("Name =", Name)
  53. }
  56. func main() {
  57.     age := 11
  58.     Name := "tom"
  59.     test()
  60.     fmt.Println("age =", age)
  61.     fmt.Println("Name =", Name)
  62. }
  1. 函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母为大写，则作用域在整个程序有效。 ```go package main

import “fmt”

// 函数外部声明/定义的变量叫全局变量，作用域在整个包都有效，如果其首字母为大写，则作用域在整个程序有效。 var age int = 50 var Name string = “jack~”

//函数 func test() { //age 和 Name 的作用域就只在 test 函数内部 age := 10 Name := “tom~”

  1. fmt.Println("age =", age)
  2. fmt.Println("Name =", Name)

}

func main() { test() fmt.Println(“age =”, age) fmt.Println(“Name =”, Name) }

  2. 3. 如果变量是在一个代码块，比如 for/if 中，那么这个变量的作用域就在该代码块。
  3. ```go
  4. package main
  6. import "fmt"
  9. func main() {
  10.     //如果变量是在一个代码块，比如 for/if 中，那么这个变量的作用域就在该代码块。
  12.     for i := 0; i <= 10; i++ {
  13.         fmt.Println("i =", i)
  14.     }
  16.     for i := 0; i <= 10; i++ {
  17.         fmt.Println("i =", i)
  18.     }
  20.     // fmt.Println("i =", i) 用不了
  22.     var j int //局部变量
  23.     for j = 0; j <= 10; j++ {
  24.         fmt.Println("j =", j)
  25.     }
  26.     fmt.Println("j =", j)
  27. }
  1. 案例入门 ```go package main

import “fmt”

/ 变量的作用域 /

var name = “Tom” //全局变量

// Name := “mary” //这种写法不能用于全部变量

func test01() { fmt.Println(name) // Tom }

func test02() { name := “Jack” //如果去掉冒号相当于给全局变量重新赋值。 fmt.Println(name) // Jack }

func main() { fmt.Println(name) // Tom test01() // Tom test02() // Jack test01() // Tom }

  1. <a name="c9fpA"></a>
  2. ## 字符串常用的系统函数
  3. <a name="GJL51"></a>
  4. ### 基本介绍
  6. 1. 说明：字符串在我们程序开发中，使用的是非常多。 
  7. 1. 基本用法 
  8.    - 统计字符串的长度，按字节 
  9. ```go
  10. len(str)

  • 字符串遍历，同时处理有中文的问题 

    1. r := []rune(str)

  • 字符串转整数： 

    1. n, err := strconv.Atoi("12")

  • 整数转字符串 

    1. str = strconv.Itoa(12345)

  • 字符串转[]byte: 

    1. var bytes = []byte("hello go")

  • []byte 转字符串： 

    1. str = string([]byte{97,98,99})

  • 10 进制转 2, 8, 16 进制： 

    1. str = strconv.FormatInt(123, 2) // 2->8,16

  • 查找子串是否在指定的字符串中： 

    1. strings.Contains("seafood", "foo") // true

  • 统计一个字符串有几个指定的子串： 

    1. strings.Count("ceheese","e") // 4

  • 不区分大小写的字符串比较( == 是区分字母大小写的)： 

    1. fmt.Println(strings.EqualFold("abc", "Abc")) // true

  • 返回子串在字符串第一次出现的 index 值，如果没有返回 -1： 

    1. strings.Index("NLT_abc", "abc") // 4

  • 返回子串在字符串最后一次出现的 index ，如果没有返回 -1： 

    1. strings.LastIndex("go golang", "go")

  • 将指定的子串替换成另一个子串： 

    1. strings.Replace("go go Hello", "go", "go语言", n) // n 可以指定你希望替换几个，如果 n=-1 表示全部替换。

  • 按照指定的某个字符为分割表示，将一个字符串拆分成字符串数组： 

    1. strings.Split("hello,world,ok", ",")

  • 将字符串的字母进行大小写的转换： 

    1. strings.ToLower("GO") // go
    2. strings.ToUpper("Go") // GO

  • 将字符串左右两边的空格去掉： 

    1. strings.TrimSpace(" tn a lone gopher ntyn  ")

  • 将字符串左右两边指定的字符去掉： 

    1. strings.Trim("! hello! ", " !")

  • 将字符串左边指定的字符去掉： 

    1. strings.TrimLeft("! hello! ", " !")

  • 将字符串右边指定的字符去掉： 

    1. strings.TrimRight("! hello! ", " !")

  • 判断字符串是否以指定的字符串开头： 

    1. strings.HasPrefix("ftp://192.168.10.1", "ftp") // true

  • 判断字符串是否以指定的字符串结束： 

    1. strings.HasSuffix("NLT_abd.jpg", "abc") // false
  1. 快速入门案例 ```go package main

import ( “fmt” “strconv” “strings” )

func main() { //统计字符串的长度，按字节 len(str) str := “hello” fmt.Println(“str len =”, len(str))

  1. str1 := "hello北" // Golang 的编码统一为 utf-8 (ascii 的字符(字母和数字)占一个字节，汉字占用 3 个字节)
  2. fmt.Println("str len =", len(str1))
  4. str2 := "hello北京"
  5. // 字符串遍历，同时处理有中文的问题 r := []rune(str)
  6. r := []rune(str2)
  7. for i := 0; i < len(r); i++ {
  8.     fmt.Printf("字符 = %c \n", r[i])
  9. }
  11. //字符串转整数：n, err := strconv.Atoi("12")
  12. n, err := strconv.Atoi("123")
  13. if err != nil {
  14.     fmt.Println("转换错误：", err)
  15. } else {
  16.     fmt.Println("转成的结果是：", n)
  17. }
  19. //整数转字符串 str = strconv.Itoa(12345)
  20. str3 := strconv.Itoa(12345)
  21. fmt.Printf("str3 = %v, str3 = %T\n", str3, str3)
  23. //字符串转 []byte: var bytes = []byte("hello go")
  24. var bytes = []byte("hello go")
  25. fmt.Printf("bytes = %v\n", bytes)
  27. //[]byte 转字符串：str=string([]byte{97,98,99})
  28. str4 := string([]byte{97,98,99})
  29. fmt.Printf("str4 = %v\n", str4)
  31. //10 进制转2, 8, 16进制：str = strconv.FormatInt(123, 2) // 2->8,16
  32. str5 := strconv.FormatInt(123, 2)
  33. fmt.Printf("123对应的二进制是 = %v\n", str5)
  35. str6 := strconv.FormatInt(123, 16)
  36. fmt.Printf("123对应的十六进制是 = %v\n", str6)
  38. //查找子串是否在指定的字符串中：strings.Contains("seafood", "foo") //true
  39. b := strings.Contains("seafood", "foo")
  40. fmt.Printf("b = %v\n", b)
  42. //统计一个字符串有几个指定的子串：strings.Count("ceheese","e") //4
  43. num := strings.Count("ceheese","e")
  44. fmt.Printf("num = %v\n", num)
  46. //不区分大小写的字符串比较(==是区分字母大小写的)：fmt.Println(strings.EqualFold("abc", "Abc")) // true
  47. b1 := strings.EqualFold("abc", "Abc")
  48. fmt.Printf("b1 = %v\n", b1) //true
  50. fmt.Println("结果：","abc" == "Abc") //false
  52. //返回子串在字符串第一次出现的 index 值，如果没有返回-1：strings.Index("NLT_abc", "abc") //4
  53. index := strings.Index("NLT_abc", "abc")
  54. fmt.Printf("index = %v\n", index)
  56. //返回子串在字符串最后一次出现的 index，如果没有返回 -1：strings.LastIndex("go golang", go)
  57. index1 := strings.LastIndex("go golang", "go")
  58. fmt.Printf("index1 = %v\n", index1)
  60. //将指定的子串替换成另一个子串：strings.Replace("go go Hello", "go", "go语言", n) // n 可以指定你希望替换几个，如果 n=-1 表示全部替换。
  61. str7 := strings.Replace("go go Hello", "go", "go语言", -1)
  62. fmt.Printf("str7 = %v\n", str7)
  64. //按照指定的某个字符为分割表示，将一个字符串拆分成字符串数组：strings.Split("hello,world,ok", ",")
  65. strArr := strings.Split("hello,world,ok", ",")
  66. for i := 0; i < len(strArr); i++ {
  67.     fmt.Printf("str[%v] = %v\n", i, strArr[i])
  68. }
  69. fmt.Printf("strArr = %v\n", strArr)
  71. //将字符串的字母进行大小写的转换：
  72. //strings.ToLower("GO") // go
  73. //strings.ToUpper("Go") // GO
  74. str8 := "golang Hello"
  75. str8 = strings.ToLower(str8)
  76. fmt.Printf("str8 = %v\n", str8)
  78. str9 := strings.ToUpper(str8)
  79. fmt.Printf("str9 = %v\n", str9)
  81. //将字符串左右两边的空格去掉：strings.TrimSpace(" tn a lone gopher ntyn  ")
  82. str10 := strings.TrimSpace(" tn a lone gopher ntyn  ")
  83. fmt.Printf("str10 = %q\n", str10)
  85. //将字符串左右两边指定的字符去掉：strings.Trim("! hello! ", " !")
  86. str11 := strings.Trim("! hello! ", " !")
  87. fmt.Printf("str11 = %q\n", str11)
  89. //将字符串左边指定的字符去掉：strings.TrimLeft("! hello! ", " !")
  90. str12 := strings.TrimLeft("! hello! ", " !")
  91. fmt.Printf("str12 = %q\n", str12)
  93. //将字符串右边指定的字符去掉：strings.TrimRight("! hello! ", " !")
  94. str13 := strings.TrimRight("! hello! ", " !")
  95. fmt.Printf("str13 = %q\n", str13)
  97. //判断字符串是否以指定的字符串开头：strings.HasPrefix("ftp://192.168.10.1", "ftp") // true
  98. b2 := strings.HasPrefix("ftp://192.168.10.1", "ftp") // true
  99. fmt.Printf("b2 = %v\n", b2)
  101. //判断字符串是否以指定的字符串结束：strings.HasSuffix("NLT_abd.jpg", "abc") // false
  102. b3 := strings.HasSuffix("NLT_abd.jpg", "abc") // false
  103. fmt.Printf("b3 = %v\n", b3)

}

  1. <a name="UIZNX"></a>
  2. ## 时间和日期相关函数
  3. <a name="bKqoN"></a>
  4. ### 基本介绍
  6. 1. 说明：在编程中，程序员会经常使用到日期相关的函数，比如：统计某段代码执行花费的时间等等。
  7. 1. 时间和日期相关函数，需要导入 time 包。
  8. 1. time.Time 类型，用于表示时间。
  9. 1. 获取当前时间
  10. ```go
  11. now := time.Now()
  12. fmt.Printf("now = %v, now = %T\n", now, now)

  1. 通过 now 可以获取到年月日时分秒

    1. fmt.Printf("年 = %v\n", now.Year())
    2. fmt.Printf("月 = %v\n", int(now.Month()))
    3. fmt.Printf("日 = %v\n", now.Day())
    4. fmt.Printf("时 = %v\n", now.Hour())
    5. fmt.Printf("分 = %v\n", now.Minute())
    6. fmt.Printf("秒 = %v\n", now.Second())

  2. 格式化日期时间 ```go //第一种方式 fmt.Printf(“当前年月 %02d-%02d-%02d %02d:%02d:%02d \n”, now.Year(), int(now.Month()), now.Day(), now.Hour(), now.Minute(), now.Second())

// Sprintf 返回对应的字符串 dataStr := fmt.Sprintf(“当前年月 %02d-%02d-%02d %02d:%02d:%02d \n”, now.Year(), int(now.Month()), now.Day(), now.Hour(), now.Minute(), now.Second())

fmt.Printf(“dataStr = %v\n”, dataStr)

//第二种方式 fmt.Printf(now.Format(“2006/01/02 15:04:05”)) fmt.Println()

fmt.Printf(now.Format(“2006/01/02”)) fmt.Println()

fmt.Printf(now.Format(“15:04:05”)) fmt.Println()

  2. 7. 时间的常量
  3. ```go
  4. conset (
  5.     Nanosecond Duration = 1 // 纳秒
  6.     MicroSecond = 1000 * Nanosecond // 微秒
  7.     Millisecond = 1000 * Microsecond // 毫秒
  8.     Second = 1000 * Millisecond // 秒
  9.     Minute = 60 * Second // 分钟
  10.     Hour = 60 * Minute // 小时
  11. )
  12. 常量的作用：在程序中可用于获取指定时间单位的时间，比如想得到 100 毫秒
  13. 100 * time.Millisecond
  1. 休眠
    1. func Sleep(d Duration)g
  1. //需求：每隔 1 秒中打印一个数字，打印到 10 时退出
  2. i := 0
  3. for {
  4.     i ++
  5.     fmt.Println(i)
  6.     //休眠
  7.     time.Sleep(time.Second)
  8.     if i >= 10 {
  9.         break
  10.     }
  11. }
  13. //需求：每隔 0.1 秒中打印一个数字，打印到10时退出
  14. j := 0
  15. for {
  16.     j ++
  17.     fmt.Println(j)
  18.     //休眠
  19.     time.Sleep(time.Millisecond * 100)
  20.     if j >= 10 {
  21.         break
  22.     }
  23. }

  1. 获取当前 unix 时间戳和 unixnano 时间戳。(作用是可以获取随机数字)

    1. // Unix 和 UnixNano 的使用
    2. fmt.Printf("unix 时间戳 = %v unixnano 时间戳 = %v", now.Unix(), now.UnixNano())

  2. 快速入门案例 ```go package main

import ( “fmt” “strconv” “time” )

/ 编写一段代码来统计函数 test 03 执行的时间。 / func test03() { str := “” for i := 0; i < 100000; i++ { str += “hello” + strconv.Itoa(i) } }

func main() { //在执行 test03 前，先获取到当前的 unix 时间戳 start := time.Now().Unix() test03() end := time.Now().Unix() fmt.Printf(“执行 test03() 耗费时间为%v秒\n”, end - start) }

  1. <a name="FF3SQ"></a>
  2. ## 内置函数
  3. <a name="Sn03X"></a>
  4. ### 基本介绍
  6. 1. Golang 设计者为了编程方便，提供了一些函数，这些函数可以直接使用，我们称为 Go 的内置函数。
  7. <a name="PDZIe"></a>
  8. ### 内置函数详解
  10. 1. len: 用来求长度，比如 string、array、slice、map、channel 。
  11. 1. new: 用来分配内存，主要用来分配值类型，比如 int、float32、struct... 返回的是指针。
  12. ```go
  13. package main
  15. import "fmt"
  17. /*
  18.     new: 用来分配内存，主要用来分配值类型，比如 int、float32、struct...返回的是指针。(值类型分配内存)
  19. */
  22. func main() {
  23.     num1 := 100
  24.     fmt.Printf("num1的类型 = %T num1的值 = %v num1的地址 = %v\n", num1, num1, &num1)
  26.     num2 := new(int) // *int
  27.     //num2的类型%T => *int
  28.     //num2的值 0xc000094008
  29.     //num2的地址%v = 地址 0xc000094008
  30.     //num2指向的值 = 0
  31.     *num2 = 100
  32.     fmt.Printf("num2的类型 = %T num2的值 = %v num2的地址 = %v num2这个指针指向的值 = %v\n", num2, num2, &num2, *num2)
  33. }

  1. make: 用来分配内存，主要用来分配引来类型，比如 chan、map、slice 。

    错误处理

    错误处理引入

  2. 在默认情况下，当发生错误后(panic)，程序就会退出(程序崩溃)。

  3. 如果我们希望，当发生错误后，我们可以捕获到错误，并进行处理，保证程序可以继续执行。还可以在捕获到错误后，给管理员一个提示(邮件或者是短信)。

    基本说明

  4. Go 语言追求简洁优雅，所以，Go 语言不支持传统的 try…catch…finally 这种处理。

  5. Go 中引入的处理方式为：defer，panic，recover

  6. 这几个异常的使用场景可以这么简单描述：Go 中可以抛出一个 panic 的异常，然后在 defer 中通过 recover 捕获这个异常，然后正常处理。

    错误处理实践

  7. 案例一 ```go package main

import ( “fmt” “time” )

func test() { //使用 defer + recover 来捕获和处理异常 defer func() { err := recover() // recover() 内置函数，可以捕获到异常 if err != nil { //说明捕获到异常/错误 fmt.Println(“err =”, err) } }()

  1. num1 := 10
  2. num2 := 0
  3. res := num1 / num2
  4. fmt.Println("res =", res)

}

func main() { //测试 test() for { fmt.Println(“main() 下面的代码…”) time.Sleep(time.Second) } }

  1. <a name="zRHEX"></a>
  2. ### 错误处理的好处
  4. 1. 进行错误处理后，程序不会轻易挂掉，如果加入预警代码就可以让程序更加健壮。
  5. ```go
  6. package main
  8. import (
  9.     "fmt"
  10.     "time"
  11. )
  13. func test() {
  14.     //使用defer + recover 来捕获和处理异常
  15.     defer func() {
  16.         err := recover() // recover() 内置函数，可以捕获到异常
  17.         if err != nil { //说明捕获到异常/错误
  18.             fmt.Println("err =", err)
  19.             //这里就可以将错误信息发送给管理员
  20.             fmt.Println("发送邮件给 admin@sohu.com")
  21.         }
  22.     }()
  24.     num1 := 10
  25.     num2 := 0
  26.     res := num1 / num2
  27.     fmt.Println("res =", res)
  29. }
  31. func main() {
  32.     //测试
  33.     test()
  34.     for {
  35.         fmt.Println("main() 下面的代码...")
  36.         time.Sleep(time.Second)
  37.     }
  38. }

自定义错误

  1. Go 程序中，也支持自定义错误，使用 errors.New 和 panic 内置函数。
    • errors.New(“错误说明”)，会返回一个 error 类型的值，表示一个错误。
    • panic 内置函数，接受一个 interface{} 类型的值(也就是任何值)作为参数。可以接受 error 类型的变量，输出错误信心，并退出程序。
  2. 快速入门案例 ```go package main

import ( “errors” “fmt” )

/ 函数去读取一个配置文件 init.conf 的信息：如果文件名传入不正确，我们就返回一个自定义的错误。 /

func readConf(name string) (err error) { if name == “config.ini” { //读取… return nil } else { //返回一个自定义错误 return errors.New(“读取文件错误…”) } }

func test02() { err := readConf(“config2.ini”) if err != nil { //如果读取文件发送错误，就输出这个错误，并终止程序。 panic(err) }

  1. fmt.Println("test02() 继续执行...")

}

func main() { //测试自定义错误的使用 test02() fmt.Println(“main() 下面的代码…”) } ```

课程来源