Golang 函数

package main

import "fmt"

// 函数
func main(){

    // Go 语言的函数（Function）是构建程序的基本单元之一。函数封装了某些行为或操作，并且通过参数传递数据，最终通过返回值将结果返回给调用者。
    // Go 的函数具备简洁和灵活的特性，例如支持多返回值、匿名函数、闭包等

    // 定义函数基本语法
    // func FunctionName(parameterList) returnType {
    //  // 函数体
    //  return returnValue
    // }

    num1 := 10
    num2 := 20

    //无返回值函数
    tfunc(num1,num2)

    //单个返回值函数
    fmt.Println(add(num1,num2))

    //多返回值函数
    q,r := divide(num1,num2)
    fmt.Println("q,r",q,r)

    // 命名返回值
    // 如果函数的返回值具名，可以在函数声明中指定返回值的变量名，这样可以省略 return 中的变量名，直接返回值。
    // func divideTo(a, b int) (quotient, remainder int) {
    //  quotient = a / b
    //  remainder = a % b
    //  return
    // }

    // 参数传递
    //Go 中的参数传递默认是 值传递，即函数内对参数的修改不会影响外部变量。也就是说，函数接收到的是参数的副本，修改副本不会影响原始数据

    numa := 5
    modifyValue(numa) // 给参数 + 1
    fmt.Println("numa",numa) // 返回5 不会改变

    //引用传递 (要使用&传递内存地址)
    modifyPointer(&numa) // 参数 * 2
    fmt.Println("numa",numa) // 返回10 会修改numa数据

    //变长参数
    //Go 函数支持变长参数（variadic function），允许传递任意数量的参数。变长参数在函数定义中使用 ... 来表示，变长参数会被当作一个切片处理
    // 变长参数函数
    // func sum(nums ...int) int {
    //  total := 0
    //  for _, num := range nums {
    //      total += num
    //  }
    //  return total
    // }
    // fmt.Println(sum(1, 2, 3)) 
    fmt.Println(addsnum(1,2,3,4,5))

    // 匿名函数
    // 匿名函数（Lambdas）是没有名字的函数，通常用于传递给其他函数或者作为闭包使用。
    func(a, b int) {
        fmt.Println(a + b)
    }(5, 7) // 输出 12

    // 匿名函数可以赋值给变量,并且可以像普通函数一样调用
    oneaddfunc := func(a,b int) int {
        return a + b
    }
    fmt.Println(oneaddfunc(1,2)) // 输出 3

    // 闭包(Closure)
    // 闭包是一个函数，它“记住”并且可以访问它被创建时的作用域中的变量，即使外部函数已经返回。Go 的匿名函数通常是闭包
    // func adder() func(int) int {
    //  sum := 0
    //  return func(x int) int {
    //      sum += x
    //      return sum
    //  }
    // }
    // 函数 adder 返回了一个闭包，闭包可以访问 sum 变量并且修改它。
    // 即使 adder 函数已经返回，闭包仍然记住了 sum 的值。

    add := adder() // 返回一个闭包
    fmt.Println(add(5)) // 返回 5
    fmt.Println(add(10)) // 返回 15

    add2 := adder()
    fmt.Println(add2(5)) // 返回 5
    fmt.Println(add2(10)) // 返回 15

    // 递归函数
    // 递归是指函数直接或间接调用自身。Go 支持递归，递归的基本形式和其他编程语言一样
    // 递归函数，计算阶乘
    // func factorial(n int) int {
    //  if n == 0 {
    //      return 1
    //  }
    //  return n * factorial(n-1)
    // }
    fmt.Println(factorial(10))

    // defer 关键字
    // Go 语言中的 defer 语句用于确保在函数执行结束时（无论是正常返回还是异常终止）执行某些操作。defer 语句会被推迟到函数执行结束时才执行。

    deferfunc1 := func(){
        defer fmt.Println("最后执行这里")
        fmt.Println("优先执行这里")
    }

    deferfunc1()

    // 多个defer语句
    // 如果函数中有多个 defer 语句，它们会按 后进先出（LIFO） 的顺序执行。

    deferfunc2 := func(){
        defer fmt.Println("1")
        defer fmt.Println("2")
        defer fmt.Println("3")
    }

    deferfunc2()
    // 1
    // 2
    // 3

    // 总结
    // 多返回值：函数可以返回多个值，常用于返回多个计算结果。
    // 参数传递：Go 的函数采用值传递，可以通过传递指针实现引用传递。
    // 变长参数：可以传递任意数量的参数，参数在函数内部以切片形式处理。
    // 匿名函数：可以定义没有名字的函数，通常用于回调或闭包。
    // 闭包：函数可以捕获并记住外部变量的状态，即使外部函数已经返回。
    // 递归：函数可以调用自身，以解决一些递归问题。
    // defer 语句：用于延迟执行某些操作，通常用于资源清理工作。

}
// func：关键字，表示定义函数。
// FunctionName：函数的名称。
// parameterList：参数列表，多个参数用逗号分隔。
// returnType：返回类型，如果函数没有返回值，返回类型是 void。
// return：返回的值，返回值的类型要与声明的返回类型匹配。

// 一个简单的加法函数
func add(a int,b int) int {
    return a + b
}

//一个没有返回值的函数
func tfunc(a int,b int) {
    fmt.Println("a,b",a,b)
}

//多个返回值函数
func divide(a,b int)(int,int){
    quotient := a / b
    remainder := a % b
    return quotient, remainder
}

//值传递函数
func modifyValue(x int) {
    x += 1
}

// 引用传递（指针传递）
func modifyPointer(x *int) {
    *x = *x * 2
}

// 变长函数
// nums ...int 表示一个变长参数，它是一个切片
// 在函数体内，nums 可以像普通切片一样使用
func addsnum(nums ...int) int {
    total := 0

    for _,num := range nums{
        total += num
    }

    return total
}

// 闭包函数
func adder() func(int) int {
    num := 0
    return func(x int) int {
        num += x
        return num
    }
}

//递归函数
func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}