由于自己是搞python开发的，所以在学习go时，当看到函数和方法时，顿时还是挺蒙的，因为在python中并没有明显的区别，但是在go中却是两个完全不同的东西。在官方的解释中，方法是包含了接收者的函数。
函数的格式是固定的
Func+函数名+参数+返回值(可选)+函数体 Funcmain(a,bint)(int){ }而方法会在方法在func关键字后是接收者而不是函数名，接收者可以是自己定义的一个类型，这个类型可以是struct，interface，甚至我们可以重定义基本数据类型。不过需要注意的是接收者是指针和非指针的区别，我们可以看到当接收者为指针式，我们可以通过方法改变该接收者的属性，但是非指针类型缺做不到。
func (p myint) mysquare() int { p = p * p fmt.Println("mysquare p = ", p) return 0 }函数的值(闭包)
在Go中，函数被看作第一类值（first-classvalues）：函数像其他值一样，拥有类型，可以被赋值给其他变量，传递给函数，从函数返回。函数类型的零值是nil。调用值为nil的函数值会引起panic错误：
varffunc(int)intf(3)//此处f的值为nil,会引起panic错误
函数值不仅仅是一串代码，还记录了状态。Go使用闭包（closures）技术实现函数值，Go程序员也把函数值叫做闭包。我们看个闭包的例子 funcf1(limitint)(func(vint)bool){ //编译器发现limit逃逸了，自动在堆上分配 returnfunc(limitint)bool{returnv>limit} } funcmain(){ closure:=f1(5) fmt.Printf("%v\n",closure(1))//false fmt.Printf("%v\n",closure(5))//false fmt.Printf("%v\n",closure(10))//true }在这个例子中，f1函数传入limit参数，返回一个闭包，闭包接受一个参数v，判断v是否大于之前设置进去的limit。
在go中函数提供可变参数，对那些封装不确定参数个数是一个不错的选择。声明如下
func函数名(变量名...类型)返回值 packagemain import( "fmt" ) funcf1(namestring,vals...int)(sumint){ for_,v:=rangevals{ sum+=v } sum+=len(name) return } funcmain(){ fmt.Printf("%d\n",f1("abc",1,2,3,4))//13 }在函数中提供延迟执行即defer
包含defer语句的函数执行完毕后(例如return、panic)，释放堆栈前会调用被声明defer的语句，常用于释放资源、记录函数执行耗时等，有一下几个特点：
当defer被声明时，其参数就会被实时解析
执行顺序和声明顺序相反
defer可以读取有名返回值
运用最典型的场景及关闭资源，如操作文件，数据库操作等。如下例子 funcdo()error{ f,err:=os.Open("book.txt") iferr!=nil{ returnerr } deferfunc(fio.Closer){ iferr:=f.Close();err!=nil{ //logetc } }(f) //..code... f,err=os.Open("another-book.txt") iferr!=nil{ returnerr } deferfunc(fio.Closer){ iferr:=f.Close();err!=nil{ //logetc } }(f) returnnil }在开始闭包中提到过返回panic，那什么是panic。Go有别于那些将函数运行失败看作是异常的语言。虽然Go有各种异常机制，但这些机制仅仅用于严重的错误，而不是那些在健壮程序中应该被避免的程序错误。runtime在一些情况下会抛出异常，例如除0，我们也能使用panic关键字自己抛出异常。
出现异常，默认程序退出并打印堆栈。如下函数 packagemain funcf6(){ func(){ func()int{ x:=0 y:=5/x returny }() }() } funcmain(){ f6() }如果不想程序退出的话，也有办法，就是使用recover捕捉异常，然后返回error。在没发生panic的情况下，调用recover会返回nil，发生了panic，那么就是panic的值。看个例子：
packagemain import( "fmt" ) typeshouldRecoverstruct{} typeemptyStructstruct{} funcf6()(errerror){ deferfunc(){ switchp:=recover();p{ casenil://donoting caseshouldRecover{}: err=fmt.Errorf("occurpanicbuthadrecovered") default: panic(p) } }() func(){ func()int{ panic(shouldRecover{}) //panic(emptyStruct{}) x:=0 y:=5/x returny }() }() return } funcmain(){ err:=f6() iferr!=nil{ fmt.Printf("fail%v\n",err) }else{ fmt.Printf("success\n") } }也许有人会问，方法和函数差不多，为什么还要多此一举使用方法呢?
Golang不是一个纯粹的面向对象的编程语言，它不支持类。因此通过在一个类型上建立方法来实现与class相似的行为。 同名方法可以定义在不同的类型上，但是Golang不允许同名函数。假设有两个结构体Square和Circle。在Square和Circle上定义同名的方法是合法的。如下一个函数就很明了了
packagemain import( "fmt" "math" ) typeRectanglestruct{ lengthint widthint } typeCirclestruct{ radiusfloat64 } func(rRectangle)Area()int{ returnr.length*r.width } func(cCircle)Area()float64{ returnmath.Pi*c.radius*c.radius } funcmain(){ r:=Rectangle{ length:10, width:5, } fmt.Printf("Areaofrectangle%d\n",r.Area()) c:=Circle{ radius:12, } fmt.Printf("Areaofcircle%f",c.Area()) }两者区别在于，以指针作为接收者时，方法内部进行的修改对于调用者是可见的，但是以值作为接收者却不是。
packagemain import( "fmt" ) typeEmployeestruct{ namestring ageint } /* Methodwithvaluereceiver */ func(eEmployee)changeName(newNamestring){ e.name=newName } /* Methodwithpointerreceiver */ func(e*Employee)changeAge(newAgeint){ e.age=newAge } funcmain(){ e:=Employee{ name:"MarkAndrew", age:50, } fmt.Printf("Employeenamebeforechange:%s",e.name) e.changeName("MichaelAndrew") fmt.Printf("\nEmployeenameafterchange:%s",e.name) fmt.Printf("\n\nEmployeeagebeforechange:%d",e.age) (&e).changeAge(51) fmt.Printf("\nEmployeeageafterchange:%d",e.age) }上面的程序中，changeName方法有一个值接收者(eEmployee)，而changeAge方法有一个指针接收者(e*Employee)。在changeName中改变Employee的name的值对调用者而言是不可见的，因此程序在调用e.changeName("MichaelAndrew")方法之前和之后，打印的name是一样的。而changeAge的接受者是一个指针(e*Employee)，因此通过调用方法(&e).changeAge(51)来修改age对于调用者是可见的。
使用(&e).changeAge(51)来调用changeAge方法不是必须的，Golang允许我们省略&符号，因此可以写为e.changeAge(51)。Golang将e.changeAge(51)解析为(&e).changeAge(51)。现在我们定义的都是结构体类型的方法，同样可以定义非结构体类型的方法，不过需要注意一点。为了定义某个类型的方法，接收者类型的定义与方法的定义必须在同一个包中。
packagemain import"fmt" typemyIntint func(amyInt)add(bmyInt)myInt{ returna+b } funcmain(){ num1:=myInt(5) num2:=myInt(10) sum:=num1.add(num2) fmt.Println("Sumis",sum) }在函数和方法中都会接收值参数和指针参数，那么两者又有什么却别?
当一个函数有一个值参数时，它只接受一个值参数。
当一个方法有一个值接收者时，它可以接受值和指针接收者。
如下一个例子 packagemain import( "fmt" ) typerectanglestruct{ lengthint widthint } funcarea(rrectangle){ fmt.Printf("AreaFunctionresult:%d\n",(r.length*r.width)) } func(rrectangle)area(){ fmt.Printf("AreaMethodresult:%d\n",(r.length*r.width)) } funcmain(){ r:=rectangle{ length:10, width:5, } area(r) r.area() p:=&r /* compilationerror,cannotusep(type*rectangle)astyperectangle inargumenttoarea */ //area(p)//会报错 p.area()//callingvaluereceiverwithapointer }我们创建了一个指向r的指针p。如果我们试图将这个指针传递给只接受值的area函数那么编译器将报错。
p.area()使用指针接收者p调用一个值接收者方法area。这是完全合法的。原因是对于p.area()，由于area方法必须接受一个值接收者，所以Golang将其解析为(*p).area()。具有指针参数的函数将仅接受指针，而具有指针接收者的方法将接受值和指针接收者
packagemain import( "fmt" ) typerectanglestruct{ lengthint widthint } funcperimeter(r*rectangle){ fmt.Println("perimeterfunctionoutput:",2*(r.length+r.width)) } func(r*rectangle)perimeter(){ fmt.Println("perimetermethodoutput:",2*(r.length+r.width)) } funcmain(){ r:=rectangle{ length:10, width:5, } p:=&r//pointertor perimeter(p) p.perimeter() /* cannotuser(typerectangle)astype*rectangleinargumenttoperimeter */ //perimeter(r) r.perimeter()//callingpointerreceiverwithavalue }试图以一个值参数r调用perimeter函数，这是非法的。因为一个接受指针为参数的函数不能接受一个值作为参数。如果去掉注释，则编译报错。
通过一个值接收者r调用一个指针接收者perimeter方法，这是合法的。r.perimeter()将被Golang解析为(&r).perimeter()。
本文内容总结：定义，函数，2可变参数列表，异常panic，方法，值接收者和指针接收者，非结构体类型的方法，方法的值接收者和函数的值参数，方法的指针接收者和函数的指针参数，
原文链接：https://www.cnblogs.com/flash55/p/10546501.html相关推荐
数学中有许多类型的级数，可以在C编程中轻松解决。该程序是在C程序中找到系列后继的和。Tn = n2 - (n-1 2...
要从全部四列中找到最低分，请使用MySQLLEAST( 函数。让我们首先创建一个表-create table DemoTable( Score1 int,...
