PHP->GO 基础-函数

//go语言以包作为管理单位
//每个文件必须先声明包
//程序必须有一个main(包)重要
package main

import "fmt"

//入口函数
func main() { //左括号必须和函数名同行
    //调用函数，大部分都需要导入包
    //go语言语句结束没有分号
    fmt.Println("hello word")
}

无参无返回值函数

package main

import "fmt"
//无参无返回值函数的定义
func MyFunc(){
    a := 666
    fmt.Println("a = ",a)
}

func main() {
    MyFunc() //调用函数
}

有参无返回值函数

package main
`
import "fmt"
//有参无返回值函数的定义
//MyFunc2(a int, b string ,c bool) //多个参数
//MyFunc2(a,b,c,d int ) //多个同一类型的参数
//MyFunc2(a,b, int ,c string) //不建议使用此方式定义多个参数
func MyFunc(a int){
    fmt.Println("a = ",a)
}

func main() {
    MyFunc(666) //调用函数
}

不定参数类型的函数

package main

import "fmt"

//...int 这样的的类型 ...type 不定参数类型
//注意：不定参数，一定只能放在形参的最后一个参数
//func MyFunc(a int,arge ...int) { 传递参数可以是1个或者多个
func MyFunc(arge ...int) { //传递参数可以是0个或者多个
    for i := 0; i < len(arge); i++ {
        fmt.Println("value = ", arge[i])
    }

    for i, data := range arge {
        fmt.Println("value = ", i, data)
    }

}

func main() {
    MyFunc(1, 2, 23) //调用函数
}

只有一个返回值函数

package main

import "fmt"

//无参 有一个返回值
//有返回值得函数需要通过return 中断函数，通过return 返回
func MyFunc01() int {
    return 666
}

//给返回值起一个变量名。go推荐写法
func MyFunc02() (result int) {
    return 666
}

func MyFunc03() (result int) {
    result = 666
    return result
}

func main() {
    var a int
    //调用函数
    a = MyFunc01()
    fmt.Println("a =", a)
    b := MyFunc02()
    fmt.Println("b =", b)
    c := MyFunc03()
    fmt.Println("c =", c)
}

有多个返回值函数

package main

import "fmt"

//多个返回值
func MyFunc01() (int, int, int) {
    return 666, 222, 777
}

//官方推荐写法
//func MyFunc02() (a,b,c int){
func MyFunc02() (a int, b int, c int) {
    a, b, c = 1, 2, 3
    return
}

func main() {
    a, b, c := MyFunc01()
    fmt.Printf("a= %d,b=%d,c=%d\n", a, b, c)
}

函数的使用案例

package main

import "fmt"

//定义函数
func MaxAndMin(a, b int) (max, min int) {
    if a > b {
        max = a
        min = b
    } else {
        max = b
        min = a
    }
    return //有返回值的函数，必须通过 return 返回
}

func main() {
    max, min := MaxAndMin(25, 36)
    fmt.Printf("max = %d,min = %d", max, min)
    a, _ := MaxAndMin(36, 99) //只取一个值
    fmt.Printf("max = %d", a)
}

函数类型

package main

import "fmt"

//定义函数
func Test(a, b int) (sum int) {
    sum = a + b
    return
}

//函数也是一种数据了下，通过type给函数类型起名
//FuncType 它是一个函数类型
type FuncType func(int, int) int //没有函数名字，没有{}

func main() {
    //传统调用方式
    sum := Test(10, 20)
    fmt.Println("result = ", sum)
    // 声明一个函数类型的变量，变量名叫fTest
    var fTest FuncType
    fTest = Test
    sum = fTest(30, 40) //等价于 Test(10,20)
    fmt.Println("result = ", sum)
}

回调函数

package main

import "fmt"

func Add(a, b int) (result int) {
    result = a + b
    return
}

func Sub(a, b int) (result int) {
    result = a - b
    return
}

//回调函数，函数有一个参数是函数类型，这个函数就是回调函数
//计算器，可以进行四则运算
//多态，多种形态，调用同一个接口，可以实现不同的表现
//定义函数
func Calc(a, b int, Ftest FuncType) (result int) {
    result = Ftest(a, b)
    return
}

//函数也是一种数据了下，通过type给函数类型起名
//FuncType 它是一个函数类型
type FuncType func(int, int) int //没有函数名字，没有{}

func main() {
    //传统调用方式
    result := Calc(10, 20, Add)
    fmt.Println("result = ", result)

    result = Calc(10, 20, Sub)
    fmt.Println("result = ", result)
}

闭包捕获外部变量特点

package main

import "fmt"

func main() {

    a := 10
    str := "mian"
    func() {
        //闭包以引用方式捕获外部变量
        a = 666
        str = "go"
        fmt.Printf("a = %d ,str = %s\n", a, str)
    }() //最后的（） 代表直接调用
    fmt.Printf("a = %d ,str = %s", a, str) //a = 666 ,str = go

}

闭包的特点

package main

import "fmt"

//函数的返回值是一个匿名函数，返回一个函数类型
func test02() func() int {
    var x int
    return func() int {
        x++
        return x * x
    }
}

func main() {
//返回值为一个匿名函数，返回一个函数类型，通过f来调用闭包函数
//他不关心这些捕获了的变量和常量是否已经超出了作用域
//所以只有闭包还在使用它，这些变量就还会存在
    f := test02()
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
    fmt.Println(f())
}

defer的使用

package main

import "fmt"

func main() {
    //defer 延迟调用，main 函数结束前调用
    //  有多个defer  语句  他们会以  LIFO  （现进后出）的顺序执行，哪怕函数或某个领域出现错误，这些调用依旧会被执行
    defer fmt.Println("bbbb") //最后输出
    fmt.Println("aaaaa")

}

defer同匿名函数的使用

package main

import "fmt"

func main() {
    a := 10
    b := 20
    defer func(a, b int) {
        fmt.Printf("a = %d,b = %d\n", a, b) //后执行 输出111,222
    }(a, b) //传参时  defer 是先传当前参数（a = 10,b=20），最后执行  所以输出 a = 10 b =20
    a = 111
    b = 222
    fmt.Printf("a = %d,b = %d\n", a, b) //先执行 输出111,222

}

func main01() {
    a := 10
    b := 20
    defer func() {
        fmt.Printf("a = %d,b = %d\n", a, b) //后执行 输出111,222
    }()
    a = 111
    b = 222
    fmt.Printf("a = %d,b = %d\n", a, b) //先执行 输出111,222

}

本作品采用《CC 协议》，转载必须注明作者和本文链接