php 不确定参数个数,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 协议》，转载必须注明作者和本文链接