方法：参数和返回值可以省略

复制
func (receive type) method(参数列表)(返回值列表)｛
｝

函数：

复制
func name(参数列表)(返回值列表){
}

函数与方法的区别在于有没有接收者,有接收者就是方法，没有接收者就是函数，这条规则说的是当我们嵌入一个类型的指针， 嵌入类型的接受者为值类型或指针类型的方法将被提升， 可以被外部类型的值或者指针调用。

复制
package main
import "fmt"
type User struct {
   id int
   name string
}
func (self *User) Test() {
   fmt.Printf("%p, %v\n", self, self)
}
func main()  {
   u := User{1, "malina"}
   u.Test()
   mValue := u.Test
   mValue()// 隐式传递 receiver
  mExpress := (*User).Test
   mExpress(&u)// 显式传递 receiver}

不定参数传值

函数的参数不是固定，后面的类型是固定的。 (可变参数)

在参数赋值时可以不用一一的赋值，可以直接传递一个数组或者切片，注意在参数后加上 … 即可。

复制
func myfunc(args ...int) {    //0个或多个参数
}
 
func add(a int, args ...int) int {    //1个或多个参数
}
 
func add(a int, b int, args ...int) int {    //2个或多个参数
}

函数的三种用法

1.将匿名函数赋给变量，在通过变量调用匿名函数

复制
sum := func(a, b int) int {
return a + b
}
fmt.Println(sum(1, 2)) // 输出 3

2.在定义匿名函数的时候直接使用，这种方式只能使用一次传参

复制
sum := func(a, b int) int {
return a + b
}(1,2) // 传入参数
fmt.Println(sum) // 输出 3

3.将匿名函数赋给一个全局变量，匿名函数在当前程序中都可以使用

复制
package main
import "fmt"
var (
// 全局变量必须首字母大写
    Sum = func(a, b int) int {
        return a + b
    }
)
 
    func main() {
    sum := Sum(1, 2)
    fmt.Println("sum=", sum) // 输出 sum= 3
}

n个参数不确定的时候

复制
func sum(s string, n...int) string {
    var x int 
    for _, i := range n{
        x+=i
    }
    return fmt.Sprintf(s, x)
}
 
func main()  {
    s := []int{1,2,3}
    res := sum("sum:%d", s...)
    println(res)
}