Golang教程：（十七）方法

Go 前端之家
前端之家收集整理的这篇文章主要介绍了Golang教程：（十七）方法，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

原文：https://golangbot.com/methods/

欢迎来到Golang系列教程的第十七篇。

什么是方法

一个方法只是一个函数，它有一个特殊的接收者（receiver）类型，该接收者放在 func 关键字和函数名之间。接收者可以是结构体类型或非结构体类型。可以在方法内部访问接收者。

通过下面的语法创建一个方法：

func (t Type) methodName(parameter list) {  
}

上面的代码片段创建了一个名为 methodName 的方法，该方法有一个类型为 Type 的接收者。

例子

让我们编写一个简单的程序，它创建一个结构体类型的方法并调用它。

package main

import (  
    "fmt"
)

type Employee struct {  
    name     string
    salary   int
    currency string
}

/* displaySalary() method has Employee as the receiver type */
func (e Employee) displaySalary() {  
    fmt.Printf("Salary of %s is %s%d",e.name,e.currency,e.salary)
}

func main() {  
    emp1 := Employee {
        name:     "Sam Adolf",salary:   5000,currency: "$",}
    emp1.displaySalary() //Calling displaySalary() method of Employee type
}

在 Playground 中运行

上面程序的第 6 行，我们创建了 Employee 的一个名为 displaySalary 的方法。在 displaySalary() 方法内部可以访问它的接收者 e （类型为 Employee）。在第 17 行，我们使用接收者 e，并打印它的 name，currency 以及 salary。

在第26行，我们使用 emp1.displaySalary() 这样的语法来调用方法。

程序的输出为：Salary of Sam Adolf is $5000。

为什么使用方法而不是函数？

上面的程序可以使用函数而不是方法重写如下：

package main

import (  
    "fmt"
)

type Employee struct {  
    name     string
    salary   int
    currency string
}

/* displaySalary() method converted to function with Employee as parameter */
func displaySalary(e Employee) {  
    fmt.Printf("Salary of %s is %s%d",e.salary)
}

func main() {  
    emp1 := Employee{
        name:     "Sam Adolf",}
    displaySalary(emp1)
}

在 Playground 中运行

在上面的程序中，我们使用 displaySalary 函数替换了方法，并将 Employee 结构体作为参数传给它。该程序的输出与上面的程序输出一样：Salary of Sam Adolf is $5000。

那么为什么我们可以用函数完成同样的工作，却还要使用方法呢？这里有几个原因，我们一个一个地看。

package main

import (  
    "fmt"
    "math"
)

type Rectangle struct {  
    length int
    width  int
}

type Circle struct {  
    radius float64
}

func (r Rectangle) Area() int {  
    return r.length * r.width
}

func (c Circle) Area() float64 {  
    return math.Pi * c.radius * c.radius
}

func main() {  
    r := Rectangle{
        length: 10,width:  5,}
    fmt.Printf("Area of rectangle %d\n",r.Area())
    c := Circle{
        radius: 12,}
    fmt.Printf("Area of circle %f",c.Area())
}

在 Playground 中运行

程序的输出为：

Area of rectangle 50  
Area of circle 452.389342

接口正是应用了这一点（译者注：相同的方法名可以用在不同的接收者类型上）。我们将在下面的教程中讨论接口的细节。

指针接收者 vs. 值接收者

目前为止我们看到的都是以值作为接收者。以指针为接收者也是可以的。两者的区别在于，以指针作为接收者时，方法内部对其的修改对于调用者是可见的，但是以值作为接收者却不是。让我们通过下面的程序帮助理解。

package main

import (  
    "fmt"
)

type Employee struct {  
    name string
    age  int
}

/* Method with value receiver */
func (e Employee) changeName(newName string) {  
    e.name = newName
}

/* Method with pointer receiver */
func (e *Employee) changeAge(newAge int) {  
    e.age = newAge
}

func main() {  
    e := Employee{
        name: "Mark Andrew",age:  50,}
    fmt.Printf("Employee name before change: %s",e.name)
    e.changeName("Michael Andrew")
    fmt.Printf("\nEmployee name after change: %s",e.name)

    fmt.Printf("\n\nEmployee age before change: %d",e.age)
    (&e).changeAge(51)
    fmt.Printf("\nEmployee age after change: %d",e.age)
}

在 Playground 中运行

上面的程序中， changeName 方法有一个值接收者 (e Employee)，而 changeAge 方法有一个指针接收者 (e *Employee)。在 changeName 中改变 Employee 的字段 name 的值对调用者而言是不可见的，因此程序在调用 e.changeName("Michael Andrew") 方法之前和之后，打印的 name 是一致的。而因为 changeAge 的接受者是一个指针 (e *Employee)，因此通过调用方法 (&e).changeAge(51) 来修改 age 对于调用者是可见的。 程序的输出如下：

Employee @H_968_301@name before change: Mark Andrew  
Employee @H_968_301@name after change: Mark Andrew

Employee age before change: 50  
Employee age after change: 51

在上面的程序第36行，我们用 (&e).changeAge(51) 来调用 changeAge 方法。因为 changeAge 有一个指针类型的接收者我们必须使用 (&e) 来调用。这不是必须的，Go允许我们省略 & 符号，因此可以只写为 e.changeAge(51)。Go 将 e.changeAge(51) 解析为 (&e).changeAge(51)。

下面的程序使用 e.changeAge(51) 来替代 (&e).changeAge(51)。它与上面的程序的打印结果是一样的。

package main

import (  
    "fmt"
)

type Employee struct {  
    name string
    age  int
}

/* Method with value receiver */
func (e Employee) changeName(newName string) {  
    e.name = newName
}

/* Method with pointer receiver */
func (e *Employee) changeAge(newAge int) {  
    e.age = newAge
}

func main() {  
    e := Employee{
        name: "Mark Andrew",e.age)
    e.changeAge(51)
    fmt.Printf("\nEmployee age after change: %d",e.age)
}

在 Playground 运行

何时使用指针接收者，何时使用值接收者？

一般来讲，指针接收者可用于对接收者的修改应该对调用者可以见的场合。

指针接收者也可用于拷贝结构体代价较大的场合。考虑一个包含较多字段的结构体，若使用值作为接收者则必须拷贝整个结构体，这样的代价很大。这种情况下使用指针接收者将避免结构体的拷贝，而仅仅是指向结构体指针的拷贝。

其他情况下可以使用值接收者。

匿名字段函数

匿名字段的方法可以被包含该匿名字段的结构体的变量调用，就好像该匿名字段的方法属于包含该字段的结构体一样。

package main

import (  
    "fmt"
)

type address struct {  
    city  string
    state string
}

func (a address) fullAddress() {  
    fmt.Printf("Full address: %s,%s",a.city,a.state)
}

type person struct {  
    firstName string
    lastName  string
    address
}

func main() {  
    p := person{
        firstName: "Elon",lastName:  "Musk",address: address {
            city:  "Los Angeles",state: "California",},}

    p.fullAddress() //accessing fullAddress method of address struct

}

在 Playground 中运行

在上面的程序中，第32行，我们通过 p.fullAddress() 调用了 address 的方法 fullAddress()。像 p.address.fullAddress() 这样的直接调用是不必要的。程序输出为：

Full address: Los Angeles,California

方法的值接收者 vs. 函数的值参数

这是很多新手遇到的问题。我们将尽可能把它说明白。

当一个函数有一个值参数时，它只接受一个值参数。

当一个方法有一个值接收者时，它可以接受值和指针接收者。

让我们通过程序说明这一点。

package main

import (  
    "fmt"
)

type rectangle struct {  
    length int
    width  int
}

func area(r rectangle) {  
    fmt.Printf("Area Function result: %d\n",(r.length * r.width))
}

func (r rectangle) area() {  
    fmt.Printf("Area Method result: %d\n",(r.length * r.width))
}

func main() {  
    r := rectangle{
        length: 10,}
    area(r)
    r.area()

    p := &r
    /* compilation error,cannot use p (type *rectangle) as type rectangle in argument to area */
    //area(p)

    p.area()//calling value receiver with a pointer
}

在 Playground 中运行

第12行，函数 func area(r rectangle) 接受一个值参数，而方法 func (r rectangle) area() 接受一个值接收者。

在第25行，我们传递了一个值来调用 area 函数 area(r)，它将工作。同样地，我们通过值接收者调用 area 方法 r.area() 它也可以工作。

在第28行，我们创建了一个指向 r 的指针 p。如果我们试图将这个指针传递给只接受值的 area 函数那么编译器将报错：compilation error,cannot use p (type *rectangle) as type rectangle in argument to area.。这是我们预期的。

现在来到了微妙的地方，第35行 p.area() 使用指针接收者 p 调用了接受一个值接收者的方法 area 。这是完全合法的。原因是对于 p.area()，Go 将其解析为 (&p).area()，因为 area 方法必须接受一个值接收者。这是为了方便 Go 给我们提供的语法糖。

程序的输出为：

Area Function result: 50  
Area Method result: 50  
Area Method result: 50

方法的指针接收者 vs. 函数的指针参数

与值参数相似，一个接受指针参数的函数只能接受指针，而一个接收者为指针的方法可以接受值接收者和指针接收者。

package main

import (  
    "fmt"
)

type rectangle struct {  
    length int
    width  int
}

func perimeter(r *rectangle) {  
    fmt.Println("perimeter function output:", 2*(r.length+r.width))

}

func (r *rectangle) perimeter() {  
    fmt.Println("perimeter method output:", 2*(r.length+r.width))
}

func main() {  
    r := rectangle{
        length: 10,}
    p := &r //pointer to r
    perimeter(p)
    p.perimeter()

    /* cannot use r (type rectangle) as type *rectangle in argument to perimeter */
    //perimeter(r)

    r.perimeter()//calling pointer receiver with a value
}

在 Playground 中运行

在上面的程序中，第12行定义了一个函数 perimeter，该函数接受一个指针作为参数，而17行定义了一个方法，有一个指针接收者。

27行我们通过指针参数调用 perimeter 函数，在第28行我们通过一个指针接收者调用 perimeter 方法。一切都好。

在被注释掉的第33行，我们试图通以一个值 r 调用 perimeter 函数。这是非法的，因为一个接受指针为参数的函数不能接受一个值作为参数。如果去掉注释运行程序，则编译将报错：main.go:33: cannot use r (type rectangle) as type *rectangle in argument to perimeter.。

在第35行我们通过一个值接收者 r 调用接受一个指针接收者的 perimeter 方法。这是合法的，r.perimeter() 这一行将被 Go 解析为 (&r).perimeter()。这是为了方便 Go 给我们提供的语法糖。程序的输出为：

perimeter function output: 30  
perimeter method output: 30  
perimeter method output: 30

定义非结构体类型的方法

现在我们定义的都是结构体类型的方法。同样可以定义非结构体类型的方法，不过这里需要注意一点。为了定义某个类型的方法，接收者类型的定义与方法的定义必须在同一个包中。目前为止，我们定义的结构体和相应的方法都是在main包中的，因此没有任何问题。

package main

func (a int) add(b int) {  
}

func main() {

}

在 Playground 中运行

在上面的程序中，第3行我们试图添加一个方法 add 给内置类型 int。这是不允许的，因为定义方法 add 所在的包和定义类型 int 的包不是同一个包。这个程序将会报编译错误：cannot define new methods on non-local type int。

使其工作的方法为定义内置类型的别名，然后以这个新类型为接收者创建方法。

package main

import "fmt"

type myInt int

func (a myInt) add(b myInt) myInt {  
    return a + b
}

func main() {  
    num1 := myInt(5)
    num2 := myInt(10)
    sum := num1.add(num2)
    fmt.Println("Sum is",sum)
}

在 PLayground 中运行

上面的程序中，第5行，我们创建了新的类型，一个 int 的别名 myInt。在第7行，我们定义了一个方法 add，以 myInt 作为接收者。

程序的输出为： Sum is 15。

我已经创建了一个程序，其中包含了目前为止所讨论的所有概念，可以在 github 上找到它。

对于方法的讨论就到这里。感谢阅读！

目录
上一篇：Golang教程：（十六）结构体
下一篇：Golang教程：（十八）接口 - I

原文链接：https://www.f2er.com/go/188217.html

猜你在找的Go相关文章

golang简单实现jwt验证(beego、xorm、jwt)
程序目录结构 简单实现，用户登录后返回一个jwt的token，下次请求带上token请求用户信息接...
【工程实践】利用go语言写一个简单的Pow样例
本篇博客的主要内容是用go写一个简单的Proof-of-Work共识机制，不涉及到网络通信环节，只是...
【工程实践】go语言实现MerkleTree
简介 默克尔树（MerkleTree）是一种典型的二叉树结构，其主要特点为： 最下面的叶节点包含...
第九章 goroutine
接下来学习并发编程, 并发编程是go语言最有特色的地方, go对并发编程是原生支持. goroutin...
第十一章 运用广度优先搜索走迷宫
先普及一下, 什么是广度优先搜索 广度优先搜索类似于树的层次遍历。从图中的某一顶点出发，...
第十三章 go实现分布式网络爬虫---单机版爬虫
爬虫的分类 网络爬虫分为两类 1. 通用爬虫: 类似于baidu, google. 他们会把大量的数据挖下...
第十章 channel select 总结
感觉channel在理解起来还有点费劲的, 尤其是select的使用, 既要可以读数据, 又要可以写数据...
第十五章 并发版爬虫第二版 -- 完结
并发版爬虫, 在上一篇单机版爬虫的基础上演变而来 这里只有并发引擎的代码, 基本的解析器代...
第八章--性能优化--pprof详细研究
接着上次的博客: https://www.cnblogs.com/ITPower/articles/12315637.html ppro...
第八章 测试与性能调优--生成文档和测试示例代码
java也可以生成文档, 就像一个手册一样, 可以用来查看方法, 接口, 下面我们给go项目生成文...
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积