go语言学习（函数）

函数定义

先简单实现一个加法函数

go 复制代码

//标准写法
func add(x int, y int) int {
	return x + y
}

//等价简写,x和y类型都是int
func add(x,y int) int {
	return x + y
}

可变参数，参数个数不一致：

go 复制代码

package main

import "fmt"

// 可变参数，传进来什么就打印什么
func add(numList ...int) {
    fmt.Println(numList)
}

func main() {
    add(1, 2, 3)//[1 2 3]
    add(1, 2, 3, 4, 5)//[1 2 3 4 5]
}

返回值

Go语言特色：Go中的函数的返回值可以有多个。

go 复制代码

package main

import "fmt"

// 多返回值
func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    x, y := swap("Hello", "World")
    fmt.Println(x, y)//World Hello
}

命令返回值，可直接定义返回值，函数中做修改，return 时会直接返回命名的返回值，提高代码简洁性。

go 复制代码

package main

import "fmt"

func split(sum int) (x, y int) {
    x = sum + 10
    y = sum - x
    return
}

func main() {
    x, y := split(5)
    fmt.Println(x, y) // 15 -10
}

函数特性

Go语言中，函数和其他数据类型一样，具有相同的权力和地位，可以作为参数，也可作为返回值等等。

go 复制代码

//add 函数声明
type add func(int, int) int

//函数作为参数
func applyOperator(x,y int,op add) int {
    return op(x,y)
}

//函数作为返回值
func getMultiplier(factor int) func(int) int {
    return func(x int) int {
       return x * factor
    }
}

init函数

基本特性

自动执行 ：init()函数在包导入时自动执行，无需显式调用
执行时机 ：在 main()函数之前执行
数量限制 ：一个包可以有多个 init()函数
执行顺序：按照依赖关系和声明顺序执行

go 复制代码

package main

import "fmt"

func init() {
    fmt.Println("init1")
}

func init() {
    fmt.Println("init2")
}

func main() {
    fmt.Println("main")
}

输出如下：

defer函数

注意defer和init函数不同，defer是关键字。

基本特性

延迟执行：函数执行结束后执行，无论是否发生 panic
栈式结构：多个 defer 按照 LIFO（后进先出）顺序执行
作用域：在函数返回前执行

defer是关键字，后面必须跟一个函数调用

go 复制代码

package main

import "fmt"

func main() {

    defer fmt.Println("defer1")
    defer fmt.Println("defer2")

    fmt.Println("defer3")
}

输出如下：