Go语言的函数

go 函数式编程范式的语言

由函数组织程序结构

可以把函数作为参数传递，也能返回函数

函数可以模块化管理代码

函数方便排错

函数可以重复调用

函数 -- 对功能进行封装 关注接收什么参数，返回什么结果

func function_name([参数列表])([返回值列表]){

函数体

}

支持：

支持多个返回值

支持命名参数返回

支持可变长参数

支持匿名参数，支持闭包

可以把函数作为参数传递、赋值、返回

不支持：

不支持有名函数的嵌套

不支持重载

不支持默认参数

packing 和 unpacking

函数传参 packing test5(1,2,3) -->test5(nums ...int)

1,2,3 -->切片[1 2 3] -->nums

切片后面 unpacking [6 7 8]... -->6,7,8

package mainimport "fmt"/*
go 函数式编程范式的语言
由函数组织程序结构
可以把函数作为参数传递，也能返回函数函数可以模块化管理代码
函数方便排错
函数可以重复调用函数 -- 对功能进行封装  关注接收什么参数，返回什么结果func function_name([参数列表])([返回值列表]){函数体
}支持：支持多个返回值支持命名参数返回支持可变长参数支持匿名参数，支持闭包可以把函数作为参数传递、赋值、返回不支持：不支持有名函数的嵌套不支持重载不支持默认参数
*/func main() {test1() //调用函数，运行result := test2(10, 20)fmt.Println(result)result1, result2 := test3(40, 10) //返回多个值使用多个变量接收fmt.Println(result1, result2)fmt.Println(test4(23, 34))
}// 没有参数，也没有返回值的函数
func test1() {fmt.Println("this is test1")
}// 函数接收参数，返回数据
func test2(a, b uint8) uint8 {return a + b //return返回  碰到return函数就退出了//fmt.Println("test2 end...") //不会输出
}// 支持多个返回值
func test3(a int, b int) (int, int) {result1 := a + bresult2 := a - breturn result1, result2
}// 支持命名参数返回
func test4(a, b int) (result int) {result = a * breturn
}

package mainimport "fmt"func main() {//调用可变长参数函数result1 := test5()result2 := test5(1)result3 := test5(1, 2)result4 := test5(1, 2, 3)fmt.Println(result1, result2, result3, result4)
}// 支持可变长参数
func test5(nums ...int) int {fmt.Printf("%T --> %v \n", nums, nums)// fmt.Println(1,2,3)//Println()函数也是可变长函数，可以传多个参数result := 0for _, v := range nums {result += v}return result
}/*
packing 和 unpacking
函数传参  packing   test5(1,2,3)  -->test5(nums ...int)1,2,3  -->切片[1 2 3] -->nums
切片后面  unpacking  [6 7 8]...  -->6,7,8
*///不支持有名函数的嵌套  -->       函数里面不能再嵌套一个有名函数
func test6(){fmt.Println("this is test6")func test7(){fmt.Println("this is test7 ")}
}//不支持重载  -->一个包中的函数的名字不能重复
func test5(){fmt.Println("this is test5")
}//不支持默认函数
func test8(a int = 10){fmt.Println(a)
}

支持把函数作为参数传递、赋值、返回

package mainimport "fmt"func main() {//匿名函数  --  没有名字的函数//把函数作为一种类型去使用  赋值、返回、  通常使用匿名函数//有名函数中可以嵌套匿名函数x := func() {fmt.Println("这是匿名函数")}x()//定义时调用y := func(num1, num2 int) int {return num1 + num2}(10, 20)fmt.Println(y)z := myfunc()fmt.Printf("z type is :%T\n", z) //输出 this is myfunc,return a func   z type is :func() intz() //输出  把函数作为参数返回...  当前函数返回一个整型result := z()fmt.Println(result)//输出  把函数作为参数返回...  当前函数返回一个整型  10
}// 把函数作为参数返回
func myfunc() func() int {fmt.Println("this is myfunc,return a func")return func() int {fmt.Println("把函数作为参数返回...")fmt.Println("当前函数返回一个整型")return 10}
}//func myfunc2(num1,num2 int) func(num3 int ,str1 string )(result int) {}
//定义了一个myfunc2，需传递两个参数num1和num2，返回一个函数，这个函数需要传递两个参数num3和str1，这个函数返回一个int类型
func myfunc2(outerNum1, outerNum2 int) func(innerNum1 int, str1 string) int {// 函数体实现return func(innerNum1 int, str1 string) int {// 内层函数逻辑return 0 // 示例返回值}
}

自定义类型

package mainimport "fmt"func main() {result := myfunc3(test4, 10, 20)fmt.Println(result)//自定义类型测试// x = 10// y = 20// fmt.Println(x + y) //go语言同类型才能计算
}// 支持命名参数返回
func test4(a, b int) (result int) {result = a * breturn
}// 把函数作为参数传递
func myfunc3(f func(int, int) int, num1, num2 int) int { //传递三个参数，f（一个需要传递两个int参数并返回一个int的函数），num1，num2（int类型 ）return f(num1, num2)
}/*
go语言支持自定义类型 --type
type name 指定类型
*/type a intvar x a
var y inttype Myfunc func(int, int) int//定义一个函数类型
func myfunc4(f Myfunc , num1, num2 int) int { //传递三个参数，f（一个需要传递两个int参数并返回一个int的函数），num1，num2（int类型 ）return f(num1, num2)
}

练习1：

从键盘接收一串密码的输入，判断它是否符合要求

1.长度在8-18之间

2.密码必须包含大小写、数字

返回真假

package mainimport "fmt"func main() {fmt.Println("请输入密码：")var passwd stringfmt.Scan(&passwd)fmt.Println(passwd_check(passwd))}/*
练习：
从键盘接收一串密码的输入，判断它是否符合要求
1.长度在8-18之间
2.密码必须包含大小写、数字
返回真假
*/func passwd_check(passwd string) bool {lenth := len(passwd)if lenth >= 8 && lenth <= 18 {// 密码长度符合要求，继续后续检查flag1 := 0flag2 := 0flag3 := 0for _, v := range passwd {if v > 'a' && v < 'z' {flag1 = 1}if v > 'A' && v < 'Z' {flag2 = 1}if v > '0' && v < '9' {flag3 = 1}}if flag1 == 1 && flag2 == 1 && flag3 == 1 {fmt.Println("密码输入正确，密码设置成功！")return true} else {fmt.Println("密码输入错误，密码必须包含大小写、数字！")return false}} else {fmt.Println("密码输入错误，密码长度必须在8到18之间！")return false}}

闭包

//闭包
/*
一般情况下函数内的局部变量，调用的时候生成，结束的时候释放
*/
func clouser(x int) {y := 10fmt.Println(x + y)
}/*
在闭包条件下，局部变量不会随着调用的结束而释放
闭包：
1.有内外函数
2.外函数要返回内函数
3.内函数要引用外函数的变量
*/func outer(x int) func(int) int {fmt.Println("x is :", x)return func(y int) int {fmt.Println("innner x is :", x)fmt.Println("innner y is :", y)return x + y}
}func main() {inner := outer(100)fmt.Println(inner(200))
}