方法接收器上的golang函数别名（golang 方法接收者）

25-02-13 13

以上就是给各位分享方法接收器上的golang函数别名，其中也会对golang方法接收者进行解释，同时本文还将给你拓展Go函数中的方法接收器和接口实现？、golang中的nil接收器、Golang方法接

以上就是给各位分享方法接收器上的golang函数别名，其中也会对golang 方法接收者进行解释，同时本文还将给你拓展Go 函数中的方法接收器和接口实现？、golang 中的 nil 接收器、Golang 方法接收者是值还是指针问题、golang中方法接收器的概念和使用方法等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

方法接收器上的golang函数别名（golang 方法接收者）
Go 函数中的方法接收器和接口实现？
golang 中的 nil 接收器
Golang 方法接收者是值还是指针问题
golang中方法接收器的概念和使用方法

方法接收器上的golang函数别名（golang 方法接收者）

我可以为常用方法创建方法别名：

func method1() {    fmt.Println("method1")}var Method1 = method1

但是不能对方法接收者做同样的事情：

type Person struct {    Name string}func (p *Person) methodReciver() {    fmt.Println("method reciver")}var MethodReciver = methodReciver

在这种情况下，我在网上出现了错误var MethodReciver = methodReciver：

undefined: methodReciver

完整代码：

package mainimport (    "fmt")type Person struct {    Name string}func method1() {    fmt.Println("method1")}var Method1 = method1func (p *Person) methodReceiver() {    fmt.Println("method receiver")}var MethodReceiver = methodReceiverfunc main() {    method1()    Method1()    p := Person{"Nick"}    p.methodReceiver()    p.MethodReceiver()}

操场

是否可以为其创建方法别名methodReceiver？

答案1

小编典典

是。您可以这样命名：

var MethodReceiver = (*Person).methodReceiver

调用它时，必须提供一个指向人员对象的指针作为第一个参数：

MethodReceiver(&p)

您可以在Go Playground上看到这一点。

Go 函数中的方法接收器和接口实现？

方法接收器和接口实现：方法接收器：指定函数调用时接收的类型，允许根据接收类型定制函数行为。接口实现：定义类型必须实现的一组方法，确保类型符合特定行为合约。使用方法：定义方法接收器，指定接收的类型和方法行为。定义接口，列出类型必须实现的方法。实现接口，为类型提供接口中声明的方法的实现。实战案例：自定义类型 person 实现 sort.interface 接口以基于姓名或年龄对人员进行排序。

Go 函数中的方法接收器和接口实现？

Go 函数中的方法接收器和接口实现

简介

Go 中的函数接收器和接口实现允许我们定义函数行为并定义类型合约。接收器指定调用函数时将传递给它的类型，而接口实现定义了实现给定接口所需实现的方法。

方法接收器

方法接收器定义了函数在被特定类型调用时如何行为。语法如下：

func (receiverType) methodName(parameters) returnType

登录后复制

receiverType：指定调用函数时要传入的类型。
methodName：函数的名称。
parameters：函数的参数列表。
returnType：函数的返回值类型。

示例：String 类型上的 ToUpper() 方法

以下是一个在 String 类型上定义的 ToUpper() 方法：

func (s String) ToUpper() String {
    return String(strings.ToUpper(string(s)))
}

登录后复制

在调用 ToUpper() 方法时，接收器 s 是一个 String 类型的值。方法将 String 类型转换成一个正常的 string 类型，然后将其转换为大写，最后将其转换回 String 类型并返回。

接口实现

接口指定了类型必须实现的一组方法。语法如下：

type interfaceName interface {
    methodName1() returnType1
    methodName2() returnType2
}

登录后复制

interfaceName：接口的名称。
methodName1 和 methodName2：接口中声明的方法。
returnType1 和 returnType2：方法的返回值类型。

示例：sort.Interface 接口

sort.Interface 接口定义了一个类型必须实现的排序方法：

Less(i, j int) bool
Len() int
Swap(i, j int)

为了实现 sort.Interface 接口，一个类型必须为上述三个方法提供实现。

实战案例：自定义排序类型

考虑一个 Person 类型，其中包含姓名和年龄字段。我们可以定义一个自定义的 sort.Interface 实现，以便根据姓名或年龄对人员进行排序：

type Person struct {
    Name string
    Age  int
}

// ByName implements sort.Interface for []Person based on Name field.
type ByName []Person

func (a ByName) Len() int           { return len(a) }
func (a ByName) Less(i, j int) bool  { return a[i].Name < a[j].Name }
func (a ByName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

// ByAge implements sort.Interface for []Person based on Age field.
type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool  { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

登录后复制

使用这些自定义类型，我们可以通过以下方式对人员进行排序：

people := []Person{
    {"Alice", 25},
    {"Bob", 30},
    {"Charlie", 22},
}

sort.Sort(ByName(people)) // Sort by name
sort.Sort(ByAge(people))  // Sort by age

登录后复制

以上就是Go 函数中的方法接收器和接口实现？的详细内容，更多请关注php中文网其它相关文章！

golang 中的 nil 接收器

索引：https://waterflow.link/articles/1666534616841

我们先看一个简单的例子，我们自定义一个错误，用来把多个错误放在一起输出：

type CustomError struct {
	errors []string
}

func (c *CustomError) Add(err string) {
	c.errors = append(c.errors, err)
}

func (c *CustomError) Error() string {
	return strings.Join(c.errors, ";")
}

因为实现了 Error() string 方法，所以它实现了 error 接口。

现在我们要实现一个添加课件的功能，但是添加之前需要验证参数的合法性，所以我们创建了一个 Validate 方法，我们可能会这么写：

package main

import (
	"errors"
	"fmt"
	"strings"
)

type CustomError struct {
	errors []string
}

func (c *CustomError) Add(err error) {
	c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {
	return strings.Join(c.errors, ";")
}

type Courseware struct {
	Name string
	Code string
}

func (c *Courseware) Validate() error {
	var m *CustomError // 1
	if c.Name == "" { // 2
		m = &CustomError{}
		m.Add(errors.New("课件名不能为空"))
	}
	if c.Code == "" { // 3
		if m == nil {
			m = &CustomError{}
		}
		m.Add(errors.New("课件编号不能为空"))
	}

	return m // 4
}

func main() {
	m := Courseware{
		Name: "多媒体课件",
		Code: "CW330",
	}
	if err := m.Validate(); err != nil {
		fmt.Println("valid err: ", err)
	}
}

看上去好像一点问题都没有：

定义一个 CustomError 类型的指针
如果 Name 为空，初始化 m，调用 Add 方法把错误添加到 CustomError.errors
如果 Code 为空，如果 m 还没有初始化，先初始化，调用 Add 方法把错误添加到 CustomError.errors
最后返回自定义错误

但是当我们执行上面的代码时，会发现结果并不是我们想要的：

go run 8.go
valid err:  <nil>

我们发现居然走到了打印错误的判断里，但是打印出来的错误居然是一个 nil。

在 Go 中，我们必须知道指针接收器可以为 nil。我们看一个简单的例子：

package main

import (
	"fmt"
)

type Demo struct {
}

func (d *Demo) Print() string {
	return "demo"
}

func main() {
	var d *Demo
	fmt.Println(d)
	fmt.Println(d.Print())
}

go run 8.go
<nil>
demo

Demo 被初始化为 nil，但是这段代码可以正常运行。说明 nil 指针也可以作为接收器。

其实上面的 Print 方法等价于：

func Print(d *Demo) string {
	return "demo"
}

因为将 nil 指针传递给函数是有效的。所以使用 nil 指针作为接收器也是有效的。

我们继续回到上面的自定义错误。

m 被初始化为指针的零值：nil。如果所有验证都通过，return 语句返回的结果不是 nil，而是一个 nil 指针。因为 nil 指针是一个有效的接收器，所以将结果转换为 error 接口不会产生 nil 值。

所以我们虽然返回了一个 nil 指针，但是转换为 error 接口时并不是一个 nil 的接口（虽然是 nil 指针，但是是 * CustomError 类型，并实现了 error）。

要解决这个问题，我们只要直接返回 nil 值，不返回 nil 的指针：

package main

import (
	"errors"
	"fmt"
	"strings"
)

type CustomError struct {
	errors []string
}

func (c *CustomError) Add(err error) {
	c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {
	return strings.Join(c.errors, ";")
}

type Courseware struct {
	Name string
	Code string
}

func (c *Courseware) Validate() error {
	var m *CustomError
	if c.Name == "" {
		m = &CustomError{}
		m.Add(errors.New("课件名不能为空"))
	}
	if c.Code == "" {
		if m == nil {
			m = &CustomError{}
		}
		m.Add(errors.New("课件编号不能为空"))
	}

  // 这里如果m指针为nil，直接返回nil
	if m == nil {
		return nil
	}

	return m
}

func main() {
	m := Courseware{
		Name: "多媒体课件",
		Code: "CW330",
	}

	if err := m.Validate(); err != nil {
		fmt.Println("valid err: ", err)
	}
}

或者我们直接返回 * CustomError 类型的错误：

package main

import (
	"errors"
	"fmt"
	"strings"
)

type CustomError struct {
	errors []string
}

func (c *CustomError) Add(err error) {
	c.errors = append(c.errors, err.Error())
}

func (c *CustomError) Error() string {
	return strings.Join(c.errors, ";")
}

type Courseware struct {
	Name string
	Code string
}

// 返回*CustomError
func (c *Courseware) Validate() *CustomError {
	var m *CustomError
	if c.Name == "" {
		m = &CustomError{}
		m.Add(errors.New("课件名不能为空"))
	}
	if c.Code == "" {
		if m == nil {
			m = &CustomError{}
		}
		m.Add(errors.New("课件编号不能为空"))
	}

	return m
}

func main() {
	m := Courseware{
		Name: "多媒体课件",
		Code: "CW330",
	}

	if err := m.Validate(); err != nil {
		fmt.Println("valid err: ", err)
	}
}

但这并不是可取的，为了扩展我们实现了 error 接口，也需要返回 error 类型的错误。

Golang 方法接收者是值还是指针问题

对于普通结构体作为接收者，值和指针并没有区别。

（以下代码摘抄自Go In Action 中文版）

type defaultMatcher struct{}

// 方法声明为使用 defaultMatcher 类型的值作为接收者
func (m defaultMatcher) Search(feed *Feed, searchTerm string)

// 声明一个指向 defaultMatcher 类型值的指针
dm := new(defaultMatch)

// 编译器会解开 dm 指针的引用，使用对应的值调用方法
dm.Search(feed, "test")

// 方法声明为使用指向 defaultMatcher 类型值的指针作为接收者
func (m *defaultMatcher) Search(feed *Feed, searchTerm string)

// 声明一个 defaultMatcher 类型的值
var dm defaultMatch

// 编译器会自动生成指针引用 dm 值，使用指针调用方法
dm.Search(feed, "test")使用一个空结构声明了一个名叫 defaultMatcher 的结构类型。空结构

在创建实例时，不会分配任何内存。这种结构很适合创建没有任何状态的类型。对于默认匹配器
来说，不需要维护任何状态，所以我们只要实现对应的接口就行。

因为大部分方法在被调用后都需要维护接收者的值的状态，所以，一个最佳实践是，将方法的接收者声明为指针。对于 defaultMatcher 类型来说，使用值作为接收者是因为创建一个defaultMatcher 类型的值不需要分配内存。由于 defaultMatcher 不需要维护状态，所以不需要指针形式的接收者。

与直接通过值或者指针调用方法不同，如果通过接口类型的值调用方法，规则有很大不同，使用指针作为接收者声明的方法，只能在接口类型的值是一个指针的时候被调用。使用值作为接收者声明的方法，在接口类型的值为值或者指针时，都可以被调用。

// 方法声明为使用指向 defaultMatcher 类型值的指针作为接收者
func (m *defaultMatcher) Search(feed *Feed, searchTerm string)

// 通过 interface 类型的值来调用方法
var dm defaultMatcher
var matcher Matcher = dm // 将值赋值给接口类型
matcher.Search(feed, "test") // 使用值来调用接口方法

> go build
cannot use dm (type defaultMatcher) as type Matcher in assignment

// 方法声明为使用 defaultMatcher 类型的值作为接收者
func (m defaultMatcher) Search(feed *Feed, searchTerm string)

// 通过 interface 类型的值来调用方法
var dm defaultMatcher
var matcher Matcher = &dm // 将指针赋值给接口类型
matcher.Search(feed, "test") // 使用指针来调用接口方法

> go build
Build Successful

golang中方法接收器的概念和使用方法

go语言是一个开源的编程语言，被设计成一种非常高效的编程方式。与其他编程语言相比，go语言具有很多独特的特性，其中之一就是方法接收器（method receiver）。本文将主要介绍go语言中方法接收器的概念和使用方法。

什么是方法接收器？

在Go语言中，方法接收器是一种特殊的函数，它们被用于绑定到一个具体的类型上，并允许该类型上的值来调用方法。方法接收器也被称为接收器函数或者简单地称为接收器。接收器围绕着类型定义，它允许开发人员在类型上定义方法。方法接收器指定了方法的参数，以及参数的类型。

方法接收器的语法

方法的接收器是指定在函数名之前的一个（或一组）参数。下面给出的是一个接收器为类型 T 方法的完整格式：

func (t T) methodName(parameter_list)(return_type_list){
    //Code Block
}

登录后复制

其中，接收器要在函数名之前指定，并且有一个参数，类型为 T。可以使用指针类型 T 的值作为接收器。如果 methodName 是一个指向类型 T 的指针的方法，则可以使用 T 或 *T 类型的值作为其接收器。

关于接收器，需要知道的几个概念如下所述。

立即学习“go语言免费学习笔记（深入）”；

T ：类型，即方法接收器的参数类型。
methodName ：方法名。
parameter_list ：参数列表，与函数参数列表一样。
return_type_list ：返回值列表，与函数返回值列表一样。

例如，在Go语言中，可以这样定义一个Person类型，然后定义一个接收器为 Person 类型的 GetAge() 方法：

// Person with name and age as attributes.
type Person struct {
    name string
    age  int
}

// Method to get person''s age
func (p Person) GetAge() int {
    return p.age
}

func main() {
    // Create a person object
    person := Person{"Alice", 25}

    // Calling GetAge() Method.
    fmt.Println("Age of the person is:", person.GetAge()) // Output: Age of the person is: 25
}

登录后复制

在上面的例子中，我们定义了一个类型 Person，并将其作为一个接收器传递给了一个 GetAge() 方法。使用 GetAge() 方法可以获取 Person类型的对象的年龄。

使用指针类型作为接收器

可以使用指针类型 T 的值作为接收器。如果 methodName 是一个指向类型 T（即 T）的指针的方法，则可以使用 T 或 T 类型的值作为其接收器。例如，在Go语言中，可以像这样定义一个 Person 类型，并定义一个接收器为 Person 类型指针的 SetName() 方法：

// Person with name and age as attributes.
type Person struct {
    name string
    age  int
}

// Method to set person''s name
func (p *Person) SetName(name string) {
    p.name = name
}

func main() {
    // Create person object
    person := &amp;Person{"Alice", 25}

    // Calling SetName() method
    person.SetName("Bob")

    // Retrieved person''s name
    fmt.Println("The person''s name is:", person.name) // Output: The person''s name is: Bob
}

登录后复制

在上面的例子中，我们定义了一个类型 Person，并将其作为一个指针类型 *Person 的接收器传递给方法 SetName()。使用 SetName() 方法可以设置 Person 类型对象的名称。

总结

在Go语言中，方法接收器是一种特殊的函数，用于绑定到特定的类型上，并允许该类型上的值来调用方法。在定义一个接收器方法时，需要在函数名之前指定一个接收器类型。语法如下：

func (t T) methodName(parameter_list)(return_type_list){
    //Code Block
}

登录后复制

其中，T 是接收器类型，可以是任何类型。方法接收器包括类型定义、方法名称、参数和返回类型。在使用指针类型 T 作为接收器时，可以使用 T 或 *T 类型的值作为其接收器。在Go语言中定义和使用方法接收器能够提高程序的可读性和可重用性。

以上就是golang中方法接收器的概念和使用方法的详细内容，更多请关注php中文网其它相关文章！

关于方法接收器上的golang函数别名和golang 方法接收者的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Go 函数中的方法接收器和接口实现？、golang 中的 nil 接收器、Golang 方法接收者是值还是指针问题、golang中方法接收器的概念和使用方法的相关信息，请在本站寻找。

本文标签：