函数与作用域

基本使用

package main

import "fmt"

//函数的定义
func sum(x int, y int) (ret int) {
    return x + y
}

func main() {
    r := sum(1, 2)
    fmt.Println(r)
}

go语言的函数不支持重载,并且没有默认参数这个概念

package main

import "fmt"

//函数的定义
func sum(x int, y int) int {
    return x + y
}

//没有参数
func f1(x int, y int) {
    fmt.Println(x + y)
}

//没有参数有返回值

func f2() (ret int) {
    return 3
}

//参数可以命名也可以不命名,函数的返回值就相当于在函数中声明一个变量
//可以在函数内部使用ret,并且return默认返回的值就是ret,可以不写
func f3() (ret int) {
    return 3
}

//多个返回值,一定要用括号括起来
func f5() (int, string) {
    return 1, "2"
}

//参数的类型简写,当参数中连续俩个类型一致时,我们可以将非最后一个参数类型省略
func f6(x, y, z int, m, n string) int {
    return x + y

}

//可边长参数
func f7(x string, y ...int) {
    fmt.Println(x)
    fmt.Println(y) //这里的y是一个切片
}

func main() {
    r := sum(1, 2)
    fmt.Println(r) //3
    f1(2, 5)       //7
    println(f2())  //3
    m, n := f5()
    fmt.Println(m, n)           //1,2
    f7("下雨了", 1, 123, 3, 45, 6) //下雨了 [1 123 3 45 6]
}

defer,多用在资源释放,defer只能执行函数

在函数中,return不是一部的操作,首先赋值再执行return指令 defer执行在返回值赋值之后,return之前

defer语句将会将其后面跟随的语句进行延迟处理,在defer归属的函数即将返回时,将延迟处理的语句按defer定义的顺序运行,也就是说,先被defer的语句最后执行,最后被defer的语句最先执行

package main

import "fmt"

func hanshu() {
    fmt.Println("start")
    defer fmt.Println("666")   //在函数最后会调用defer语句的执行内容
    defer fmt.Println("23333") //一个函数照中可以有多个defer修饰符
    defer fmt.Println("999")   //多个defer按照先进后出的顺序执行
    fmt.Println("end")
}

func main() {
    x := 1
    func() {
        x++
    }()
    hanshu() //start end 999 23333 666
}

小测试

package main

import "fmt"

func f1() int {
    x := 5
    defer func() {
        x++
    }()
    return x
}
func f2() (x int) {
    defer func() {
        x++
    }()
    return 5
}
func f4(x int){
    defer func(x int){
        x++
    }(x)//其实这里传入的x和函数外的x不是同一个函数
    return 5
}
func main() {
    fmt.Println(f1()) //5
    fmt.Println(f2()) //6
    fmt.Println(f4()) //5
}

作用域

函数中定义的变量不能再外部使用,只能在该函数的内部使用

package main

import "fmt"

var x = 2

func f1() {
    //函数中查找变量的顺序
    //先在内部寻找
    //找不到就往函数的外面查找,一直找到全局
    x := 10
    fmt.Println(x)
}

func main() {
    
}

函数还可以直接作为参数

package main

import "fmt"

func f2(a int) int { //定义一个接收参数为int的函数
    return 2
}
func f3(x func(a int) int) { //接收一个返回值为int的函数
    ret := x(2) //在这里进行传参
    fmt.Println(ret)
}

func main() {
    f3(f2)
    fmt.Printf("%T\n", f2) //这里加了括号是int 不加是func()int
}

匿名函数

package main

import "fmt"

//把匿名函数给到f1
var f1 = func(x, y int) {
    fmt.Println(x + y)
}

func main() {
    f2 := func(x, y int) {
        fmt.Println(x + y)
    }
    f2(1, 2)
    //如果只是调用一次的函数,海阔有简写成立即执行函数
    func(x, y int) {
        fmt.Println(x + y)
    }(1, 2)
}