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

一.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 错误处理机制

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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 错误处理机制

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像