《The anatomy of Functions in Go》学习笔记
《Variadic functions in Go》学习笔记
**

函数

函数的定义

  • 函数的关键字是func
  • 函数可以有返回值也可以没有返回值
  • 函数可以是传入蚕食也可以是多传入参数
  • 函数可以使单返回值也可以是多返回值
  • 函数的返回值可以声明为函数体内的变量
    1. func add(a, b int)(sum int) {
    2.   sum = a + b
    3.   return 
    4. }

defer 关键字

  • defer关键字后跟函数
  • defer关键字后函数会在父函数体最后执行
  • 如果父函数中存在多个refer关键字函数，运行时将多个refer函数放到栈中，在函数体最后执行的时候按照LIFO的顺序

代码建议：
将下面的代码

  1. if cond1 {
  2.     ...
  3.     fs.Close(file)
  4. } else if cond2 {
  5.     ...
  6.     fs.Close(file)
  7. } else if cond3 {
  8.     ...
  9.     fs.Close(file)
  10. } else {
  11.     ...
  12.     fs.Close(file)
  13. }

替换成

  1. defer fs.Close(file)
  2. if cond1 {
  3.     ...
  4. } else if cond2 {
  5.     ...
  6. } else if cond3 {
  7.     ...
  8. } else {
  9.     ...
  10. }

Function as type

诸如函数 func append(slice []Type, elems …Type) []Type
的函数类型是 func (slice []Type, elems …Type) []Type

  1. package main
  2. import "fmt"
  4. func add(a, b int) int {
  5.     return a + b
  6. }
  8. func subtract(a, b int) int {
  9.     return a - b
  10. }
  12. func calc(a, b int, f func(int, int) int ) int {
  13.     return f(a, b)
  14. }
  16. func main() {
  17.     ret := calc(5, 3, add)
  18.     fmt.Println(ret)
  19. }

上面的代码可以对函数类型设置一个别名，代码如下：

  1. package main
  2. import "fmt"
  4. func add(a, b int) int {
  5.     return a + b
  6. }
  8. func subtract(a, b int) int {
  9.     return a - b
  10. }
  12. type CalcFunc func(int, int) int
  14. func calc(a, b int, f CalcFunc ) int {
  15.     return f(a, b)
  16. }
  18. func main() {
  19.     ret := calc(5, 3, add)
  20.     fmt.Println(ret)
  21. }

Function as value

  • 匿名函数变量 ```go package main import “fmt”

var add = func(a, b int) int { return a + b }

func main() { ret := add(5, 3) fmt.Println(ret) }

  2. <a name="uQVRc"></a>
  3. ### 立即执行函数
  4. ```go
  5. package main
  6. import "fmt"
  8. func main() {
  9.     sum := func(a, b int) int {
  10.         return a + b
  11.     }(3, 5)
  12.     fmt.Println(sum)
  13. }

可变变量函数

可变变量函数append：
func append(slice []Type, elems …Type) []Type
调用append函数：
append(s1, s2…)
_

aslice… 用于解构slice， …Type 用于构建slice

  1. package main
  2. import "fmt"
  4. func getMultiples(factor int, args ...int) []int{
  5.     multiplies := make([]int, len(args))
  6.     for index, value := range args {
  7.         multiplies[index] = value * factor
  8.     }
  9.     return multiplies
  10. }
  12. func main() {
  13.     origin := []int{1,2,3}
  14.     ret := getMultiples(5, origin...)
  15.     fmt.Println(ret)
  16. }

_
注意：
切片是数组的引用，
当把切片作为可变变量函数的参数时，在函数中修改切片的值后，
这个修改结果会作用到原数组
**