作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.init初始化函数

1 初始化函数作用

- 1.init初始化函数可以用来进行初始化操作
    每个"*.go"源文件都可以包含一个init函数，该函数会在main函数执行前，被Go运行框架调用。

- 2.全局变量定义，init函数，main函数的执行流程？
    顺序依次是: 全局变量定义，init函数，main函数。

- 3.多个源文件都有init函数，如何执行？

2 初始化函数定义案例

2.1 初始化项目

yinzhengjie@localhost 03-init % go mod init yinzhengjie-utlis
go: creating new go.mod: module yinzhengjie-utlis
go: to add module requirements and sums:
        go mod tidy
yinzhengjie@localhost 03-init %

2.2 utils.go源代码

package utils

import "fmt"

var (
    Name   string
    Age    int
    Gender string
)

func init() {

    fmt.Println("in utils package ... init ")
    Age = 18
    Name = "Jason Yin"
    Gender = "boy"
}

2.3 main.go源代码

package main

import (
    "fmt"
    // 第1步: 先导入第三方包
    "yinzhengjie-utlis/utils"
)

// 第2步: 全局变量定义
var number int = demo()

func demo() int {
    fmt.Println("in demo ...")
    return 100
}

// 第3步: 调用init函数
func init() {
    fmt.Println("init函数被调用...")
}

// 第4步: 调用main函数
func main() {
    fmt.Println("main函数被调用...")
    fmt.Printf("姓名:%s 年龄:%d 性别: %s\n", utils.Name, utils.Age, utils.Gender)
}

二.匿名函数

1 匿名函数概述

- Go支持匿名函数，如果我们某个函数只是希望使用一次，可以考虑使用匿名函数。

- 匿名函数使用方式:
        - 1.在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次;
        - 2.将匿名函数赋给一个变量(该变量就是函数变量了)，再通过该变量来调用匿名函数;

- 如何让一个匿名函数，可以在整个程序中有效呢？将匿名函数给一个全局变量就可以了。

2 匿名函数案例

package main

import "fmt"

// 3.如果匿名函数是全局变量则可以被全局调用哟~
var mul = func(a, b int) int {
    return a * b
}

func main() {

    var (
        x int = 7
        y     = 5
    )

    // 1.定义匿名函数，定义的同时调用
    sum := func(a int, b int) int {
        return a + b
    }(x, y)

    // 2.将匿名函数赋值给一个变量，这个变量实际就是函数类型的变量
    sub := func(a, b int) int {
        return a - b
    }

    result01 := sub(x, y)

    result02 := mul(x, y)

    fmt.Printf("sum = %d\n", sum)
    fmt.Printf("sub = %d\n", result01)
    fmt.Printf("mul = %d\n", result02)
}

三.闭包函数

1 闭包函数概述

- 什么是闭包函数:
    闭包就是一个函数和其他相关的引用环境组合的一个整体。

- 闭包的本质:
    闭包本质依旧是一个匿名函数，只是这个函数引用外界的变量/参数，因此我们说: "匿名函数 + 引用外界的变量/参数 = 闭包"。

- 闭包函数特点:
    - 1.返回的是一个匿名函数，但是这个匿名函数引用到函数外的变量/参数，因此这个匿名函数就和变量/参数形成一个整体，构成闭包;
    - 2.闭包中使用的变量/参数会一直保存在内存中，所以会一直使用，意味着闭包不可滥用;

- 闭包的应用场景:
    闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了。

2 闭包函数案例之返回上级函数内部变量

package main

import (
    "fmt"
)

// 闭包指的是一个函数和与其相关的引用环境组合而成的实体。
func getSum() func(int) int {

    // 此变量属于getSum函数
    var sum int = 0

    // 此处的闭包： "返回的是一个匿名函数+函数以外的变量sum"
    return func(x int) int {
        sum += x
        return sum
    }
}

func getSum2(sum, x int) int {
    sum += x
    return sum
}

func main() {

    // 不使用闭包的时候，想要保留sum值，但不可以反复使用，因此每次调用都需要重新传入sum的值
    fmt.Println(getSum2(0, 10))
    fmt.Println(getSum2(10, 20))
    fmt.Println(getSum2(30, 30))

    fmt.Println("----- 分割线 -----")

    // 定义了一个函数变量，闭包返回的匿名函数引用的那个变量会一直保存在内存中，可以一直使用。
    var f1 = getSum()

    // 闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了。
    fmt.Println(f1(10))
    fmt.Println(f1(20))
    fmt.Println(f1(30))

    fmt.Println("----- 分割线 -----")

    // 此处重新定义了一个函数变量哟，注意，f2和上面的f1函数是两个独立的匿名函数哟~
    f2 := getSum()
    fmt.Println(f2(40))
    fmt.Println(f2(50))

}

3 闭包函数案例之返回上级函数形参变量

package main

import (
    "fmt"
)

// 闭包函数不仅仅可以返回函数内部变量，也可以直接返回形参变量
func getSum(sum int) func(int) int {

    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {

    // 定义了一个函数变量，闭包返回的匿名函数引用的那个变量会一直保存在内存中，可以一直使用。
    var f1 = getSum(0)

    // 闭包可以保留上次引用的某个值，我们传入一次就可以反复使用了。
    fmt.Println(f1(10))
    fmt.Println(f1(20))
    fmt.Println(f1(30))

}

4 闭包函数返回多个匿名函数案例

package main

import (
    "fmt"
)

func calc(base int) (func(int) int, func(int) int) {
    add := func(i int) int {
        base += i
        return base
    }

    sub := func(i int) int {
        base -= i
        return base
    }
    return add, sub
}

func main() {
    // 闭包其实并不复杂，只要牢记闭包=函数+引用环境。
    f1, f2 := calc(10)
    fmt.Println(f1(1), f2(2))
    fmt.Println(f1(3), f2(4))
    fmt.Println(f1(5), f2(6))
}

5 闭包函数实现给文件加后缀

package main

import (
    "fmt"
    "strings"
)

// 我们可以利用闭包函数，给文件加后缀
func makeSuffixFunc(suffix string) func(string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            return name + suffix
        }
        return name
    }
}

func main() {
    jpgFunc := makeSuffixFunc(".jpg")
    txtFunc := makeSuffixFunc(".txt")
    fmt.Println(jpgFunc("yinzhengjie"))
    fmt.Println(txtFunc("yinzhengjie"))
}

四.高阶函数

1 高阶函数概述

- 什么是高阶函数指的是: 
    一个函数的参数是函数，或者返回值是函数，满足其中一个就是高阶函数。
    闭包函数由于返回值是"匿名函数"，因此我们说闭包也算得上是高阶函数的一个分支，但"高阶函数"不一定是匿名函数哟~

- 高阶函数的应用场景:
     - 1.函数的参数或返回值可以使用函数，用于实现回调函数等功能;
     - 2.高阶函数可以用于实现递归函数，比如斐波拉契数列;
     - 3.高阶函数常常用于函数式编程，如列表的map，filter，reduce等函数; 
     - 3.可用于实现柯力化函数，比如: 技术实现函数的复用和参数的延迟传递;
     - 4.部分应用(partial application)，比如:将一个函数的参数固定下来，得到一个新的函数，继续调用;
     - 5.函数可以接受一个函数作为参数，然后根据这个函数的不同实现进行不同的处理;
     - 6.可以用函数组合技术将多个函数组合成一个新的函数;

2 高阶函数案例之函数作为参数案例

package main

import (
    "fmt"
)

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

// 定义的形参中，要求传递的op变量是一个函数哟~
func calc(x, y int, op func(int, int) int) int {
    return op(x, y)
}

func main() {
    var (
        a int = 100
        b int = 20
    )

    // 函数可以作为参数
    sum := calc(a, b, add)
    sub := calc(a, b, sub)

    fmt.Printf("%d + %d = %d\n", a, b, sum)
    fmt.Printf("%d - %d = %d\n", a, b, sub)
}

3 高阶函数案例之函数作为返回值

package main

import (
    "errors"
    "fmt"
)

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

// 函数也可以作为返回值
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 main() {
    var (
        a int = 100
        b int = 20
    )

    // 注意，此处返回的sum和sub都是函数哟~
    sum, _ := do("+")
    sub, _ := do("-")

    fmt.Printf("%d + %d = %d\n", a, b, sum(a, b)) // 调用sum函数
    fmt.Printf("%d - %d = %d\n", a, b, sub(a, b)) // 调用sub函数
}

五.defer关键字

1 defer执行时机

- 什么是defer:
    - 1.Go语言中的"defer"语句会将其后面跟随的语句进行延迟处理;
    - 2.在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行,先被defer的语句最后被执行，最后被defer的语句，最先被执行。
    - 3.在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。

- defer的作用:
    在函数中，程序员经常需要创建资源，为了在函数执行完毕后，及时的释放资源，Go的设计者提供defer关键字。

- defer的执行机制:
    defer语句执行的时机就在返回值赋值操作后，RET指令执行前。具体如上图所示。

- defer应用场景:
    比如你想关闭某个使用的资源，因为defer有延迟执行机制(函数执行完毕再执行defer压入栈的语句)，所以你用完随手写了关闭，比较省心，省事。

2 defer案例

package main

import "fmt"

func getSum(a, b int) (sum int) {
    /*
        1.在Golang中，程序遇到defer关键字，不会立即执行defer后的语句，而是将defer后的语句压入一个栈中，然后继续执行函数后面的代码；

        2.将defer语句压入栈中的同时，也会将相关的值同时拷贝到栈中，不会随着函数后面的变化而变化;

        3.栈的特点: 先进后出；

        4.在函数执行完毕以后，从栈中取出语句开始执行，按照先进后出的的规则执行语句；
    */
    defer fmt.Printf("a = %d\n", a)
    defer fmt.Printf("b = %d\n", b)

    // 此处我们将a和b的值进行修改，但是并不会影响到defer语句中里的a和b变量对应的值哟~
    a += 100
    b += 200

    sum = a + b
    fmt.Printf("a = %d, b = %d, sum = %d\n", a, b, sum)

    return sum

}

func main() {
    fmt.Println(getSum(10, 20))
}

3 defer面试题

3.1 观察代码手写运算结果1

package main

import (
    "fmt"
)

func f1() int {
    x := 100
    defer func() {
        x++
        fmt.Println("in f1 x = ", x)
    }()
    return x
}

func f2() (x int) {
    defer func() {
        x++
        fmt.Println("in f2 x = ", x)
    }()
    return 200
}

func f3() (y int) {
    x := 300
    defer func() {
        x++
        fmt.Println("in f3 x = ", x)
    }()
    return x
}

func f4() (x int) {
    defer func(x int) {
        x++
        fmt.Println("in f4 x = ", x)
    }(x)
    return 400
}

func main() {
    fmt.Println(f1())
    fmt.Println(f2())
    fmt.Println(f3())
    fmt.Println(f4())
}

3.2 观察代码手写运算结果2

package main

import (
    "fmt"
)

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
}

六.系统函数

1.字符串相关函数

推荐阅读:
    https://developer.aliyun.com/article/1604773

2.日期和时间相关函数

推荐阅读:
    https://developer.aliyun.com/article/1604899

3.内置函数

3.1.常见的内置函数介绍

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

3.2 make和new函数案例

推荐阅读:
    https://developer.aliyun.com/article/1604781

3.3 错误处理机制

推荐阅读:
   https://developer.aliyun.com/article/1604901

Golang语言之函数(func)进阶篇

一.init初始化函数

1 初始化函数作用

2 初始化函数定义案例

2.1 初始化项目

2.2 utils.go源代码

2.3 main.go源代码

二.匿名函数

1 匿名函数概述

2 匿名函数案例

三.闭包函数

1 闭包函数概述

2 闭包函数案例之返回上级函数内部变量

3 闭包函数案例之返回上级函数形参变量

4 闭包函数返回多个匿名函数案例

5 闭包函数实现给文件加后缀

四.高阶函数

1 高阶函数概述

2 高阶函数案例之函数作为参数案例

3 高阶函数案例之函数作为返回值

五.defer关键字

1 defer执行时机

2 defer案例

3 defer面试题

3.1 观察代码手写运算结果1

3.2 观察代码手写运算结果2

六.系统函数

1.字符串相关函数

2.日期和时间相关函数

3.内置函数

3.1.常见的内置函数介绍

3.2 make和new函数案例

3.3 错误处理机制

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像