函数定义
/*
函数定义关键字 func
func 函数名 (参数 参数类型) 函数返回值的类型
*/
func getInfo(name string, age int) string {
return name
}
// 函数返回多个返回值:则返回类型括号包裹(返回值类型,类型..)，即时返回两个int，也需要(int,int)
func getNum(x int, status bool) (int, bool) {
return x, status
}
// 函数返回值命名:函数定义时给返回值命名，并在函数体内可以直接使用这些变量，最后通过return返回
// 返回值是int类型，给返回值命名为num，并且可以直接调用
func sumNumber(x, y int) (sum int) {
sum = x + y
return sum
}
// 函数参数简写:如果参数的类型一样，可以只写一个类型
func setName(name, nickname string, age, height int) string {
return nickname
}
// 函数可变参数：可变参数是指函数的参数数量不固定，在参数名后加...来标识
func getParam(x ...int) []int {
// 传递可变参数，传递的参数类型是一个切片
return x
}
// 函数可以没有参数和返回值
func test(){
fmt.Println("t")
}
函数类型
可以使用type关键字来定义一个函数类型
/* 语法 */
// 类型的名字 该函数类型要传递的参数、该函数类型要返回的类型
type name func(string,string) string
// 自定义一个name类型
type name func(string, string) string
// 定义一个yoyo函数
func yoyo(a, b string) string {
return a
}
func main() {
// 定义一个test变量，是一个name类型
var test name
// 给test赋值的时候，因为上面声明了name类型，如果参数和返回值不符合name类型的条件，就会报错
test = yoyo
fmt.Printf("%T", test) // main.name main文件里面的name类型
// yoyo赋值给test，可以通过test()来当函数调用
test("1", "1")
}
/*
也可以自定义其他类型，比如自定义一个myInt类型，需要是int
type myInt int
*/
函数当做参数传递和返回值
当参数传递:
/* 语法一 */
func a(num int) int {
return num
}
func b(num int) int {
return num
}
// 定义c方法，传递num参数，然后传递一个函数，这个函数是有一个int参数，返回也是int
func c(num int, f func(int) int) int {
return f(num)
}
func main() {
fmt.Println(c(1, a))
}
/* 语法二 */
// 自定义Number类型
type number func(int) int
// 定义c方法，传递num参数，然后传递一个函数，符合Number类型
func c(num int, f number) int {
return f(num)
}
func main() {
fmt.Println(c(1, a))
}
函数当做返回值:
/* 语法一 */
func b(num int) int {
return num
}
// 自定义Number类型
type number func(int) int
// 定义c方法 返回类型是number
func c(num int) number {
return b
}
/* 语法二 */
func b(num int) int {
return num
}
// 定义c方法 指定返回值类型为 一个int参数且返回值值为int的函数
func c() func(int) int {
return b
}
func main() {
fmt.Println(c()(1))
}
匿名函数
匿名函数就是没有函数名的函数
func main() {
// 匿名自执行函数,可以传递参数也可以不传
func() {
fmt.Println("test")
}() // 在后面+()调用
// 匿名函数赋值变量
var fn = func(x int, y int) int {
return x + y
}
// 调用匿名函数变量
fn(1, 1)
}
函数递归
func A(n int) {
fmt.Println("n")
n--
// n大于1的时候递归调用自身， 递归调用需要注意死循环问题
if n > 1 {
A(n)
}
}
函数闭包
// 写法：函数里面嵌套一个函数，最后返回里面的函数
func testA() func() int {
i := 10
return func() int {
i++
return i
}
}
func main() {
// testA 赋值给a testA返回的是匿名函数
var a = testA()
// 调用a(),调用的是testA中的匿名函数 i常驻内存中，依次++
fmt.Println(a()) // 11
fmt.Println(a()) // 12
fmt.Println(a()) // 13
}
defer语句
// 执行顺序 1、4、3、2
fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
fmt.Println(4)
// eeee、aaa
func testA() {
defer func() {
fmt.Println("aaa")
}()
fmt.Println("eeee")
}
defer在命名返回值和匿名返回函数中的区别:
defer注册要延迟执行的函数时该函数所有的参数都要确定其他值，然后执行的时候按照执行顺序
// 匿名返回值
func testA() int {
var a int
defer func() {
a++
}()
return a
}
// 命名返回值
func testB() (b int) {
defer func() {
b++
}()
return b
}
func main() {
fmt.Println(testA()) // 0
fmt.Println(testB()) // 1
}
内置函数panic/recover
panic的作用是主动抛出异常并终止程序执行
-
recover()必须放在defer里面执行,recover的作用是监听panic抛出的异常，如果panic没有抛出异常，则是nil,可以以此来判断
-
recover()必须搭配 defer 使用。
-
defer 一定要在可能引发 panic 的语句之前定义
func testA() {
fmt.Println("A")
// 使用defer延迟执行
defer func() {
// recover 监听panic抛出的异常，如果!=nil,说明panic有抛出的异常,可以进行对应的处理，不终止程序执行
err := recover()
if err != nil {
fmt.Println(err)
}
}()
// 主动使用panic 抛出异常
panic("抛出异常")
}
func testB() {
fmt.Println("B")
}
func main() {
testA()
testB()
}
func sum(a, b int) int {
defer func() {
err := recover()
if err != nil {
fmt.Println(err) // runtime error: integer divide by zero
}
}()
// 10 不能 / 0 ，所以会发生错误，go本身会使用panic抛出异常
return a / b
}
func main() {
fmt.Println(sum(10, 0))
}
搭配使用:
import (
"errors"
"fmt"
)
func name(n string) error {
if n == "li"{
return nil
}
return errors.New("名字错误")
}
func main() {
defer func() {
// 3. 监听到抛出的异常
err := recover()
if err!=nil{
fmt.Println("err")
}
}()
// 1.调用name，如果返回nil 说明没有异常，不是nil则有异常
nick := name("1")
// 2. 如果有异常 则使用panic主动抛出
if nick != nil{
panic("error")
}
}