Go语言-函数func,方法method

函数属于包，通过包调用函数。方法属于结构体，通过结构体变量调用
如果方法的修改内容需要调用者跟随变化，接收者使用指针

函数不支持重载,嵌套和默认参数
一个指针类型拥有它以及它的基底类型为接收者类型的所有方法，而它的基底类型却只能拥有以它本身为接收者类型的方法

一.函数的定义

• 1 表达式作为返回值

func minus(a int,b int) int{
    return  a-b
}

• 2 定义变量接收返回值

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

• 3 在函数定义时定义接收变量

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

• 4.不定参函数...

func minus(args ...int){
//1.
    //for i := 0; i < len(args); i++ {
       // fmt.Println("下标",i,"值",args[i])
    result:=0
        for i := 0; i < len(args); i++ {
            result+=args[i]
    }
//第2种for循环
      for _,data:=range args{
        result+=data
    }
    fmt.Println(result)
}
func main() {
    minus(1,2,3)
    minus(1)
}

不定参函数传递它的不定参给函数时,传递方式为a[0:]...(传递所有参数),a[:3]...(从0开始传递到第3位(不含第3位))

二.函数的类型

• 1 无参有返回值.

func minus()(a,b,c int){
    a,b,c=1,2,3
    return
}
func main() {
//函数的返回值可以为主调函数赋值,可以通过返回值改变实参数据
a,b,c:=minus()
fmt.Println(a,b,c)
}

• 2 type自定义函数类型

package main

import "fmt"

func test1(){
    fmt.Println("hello")
}
func test2(a int, b int)  {
    fmt.Println(a+b)
}
func test3(){
    fmt.Println("你好")
}
//type定义函数类型
type NULL func()
type YOU func(int,int)
func main() {
    //定义函数类型变量
    var f NULL
     f= test1
     //通过函数变量调用函数
     f()
     var f1 YOU
     f1=test2
     f1(10,20)
     //相同类型函数,无需再次定义函数类型
     f2:=test3
     f2()
}

1. defer函数属延迟执行，延迟到调用者函数执行 return 命令前被执行。多个defer之间按LIFO先进后出顺序执行。通常用于释放资源
2. Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。
3. 如果同时有多defer，那么异常会被最近的recover()捕获并正常处理。
   4.无参匿名函数可以简写，如
   {fmt.Println("hello")}

三、闭包

func test() func() int {
    var a int
    return func() int {
        a++
        return a * a
    }
}
func main() {
    f := test()
    fmt.Println(f())      //1
    fmt.Println(f())      //4
    fmt.Println(f())     //9
    fmt.Println(f())     //16
    fmt.Println(f())     //25
}

    a := 10
    str := "lucy"
    func() {
        a = 666
        str = "go"
        fmt.Println(a, str)   //666,"go"
    }()
    fmt.Println(a, str)          //666,"go"

4. 扩展方法

type A int

func (a *A) print()  {
    fmt.Println("A")
}

func main() {
    var a A
    a.print()  //Method Value
    (*A).print(&a) //Method Expressions
}