golang receiving method

Golang is a very popular programming language with efficiency and concurrency. In Golang, we can use receiver methods to implement object-oriented programming, which allows us to define methods and implement interfaces on structure types. Receiver methods allow us to easily implement custom operations on data types, thereby providing more flexibility and extensibility to our applications.

This article will introduce the receiver method in Golang, including the basic syntax, usage and application cases of the receiver method in practice.

Basic syntax

The receiver method in Golang is a method defined on a type. Its syntax is as follows:

func (t Type) methodName(parameter1 type1, parameter2 type2) returnType {
   // method body
}

Among them, the keyword func is used to define a function; the t Type in brackets indicates that this is a receiver method on type t, also called a method receiver; the name of the receiver method is methodName; parameter1 type1, parameter2 type2 in brackets is the parameter list of the method; finally, the return value is a returnType.

It should be noted that when we define the receiver method in the method header, we can use any name representing the type, not just t. For example:

func (x MyType) MethodName() {
   // method body
}

Receiver method parameters

A receiver method can have one or more parameters, and these parameters can be of any data type. Usually, the first parameter is the receiver itself, and the following parameters are the parameters required by the method.

The receiver is an object, which can be a pointer type or a non-pointer type. If we use non-pointer type as receiver then we will not be able to modify its value in the method whereas if we use pointer type as receiver then we can modify its value.

The following is an example of using a non-pointer type as a receiver:

type MyInt int

func (m MyInt) Add(val int) int {
   return int(m) + val
}

func main() {
   num := MyInt(5)
   newNum := num.Add(2)
   fmt.Println(newNum)
}

In the above example, we define a type of type MyInt, and then we There is a receiver method Add defined on this type. This method has a parameter val of type int, which takes a value of type val and MyInt m Add up.

In the main function, we create a value num of type MyInt and call its Add method. This method will return a new MyInt type value and assign it to newNum, and then we will newNum print it out. We can see that the output result is 7, which means that we successfully called the Add method and got a new value.

Next, let’s look at an example of using a pointer type as a receiver:

type Rectangle struct {
   width, height int
}

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

func main() {
   rect := &Rectangle{width: 10, height: 5}
   fmt.Println(rect.Area())
}

In the above example, we define a Rectangle structure, which has Two integer fields width and height. We define a receiver method Area on this structure, which has no parameters and a return type of int.

In the main function, we create a Rectangle type pointer rect and call its Areamethod. The output result is 50, which shows that we successfully called the Area method and calculated the area of ​​the rectangle.

It should be noted that in this example we use a pointer type as the receiver. This allows us to modify the value of the Rectangle structure in the method to achieve more flexible operations.

Selection of method receiver type

When selecting the method receiver type, we need to consider the following factors:

1. Achievement purpose: If our purpose is to modify For the value of an object, we need to use pointer types; if our purpose is only to access an object, we can use non-pointer types. Therefore, the choice of receiver needs to be made on a case-by-case basis.
2. Performance considerations: Using a non-pointer type receiver can improve performance because it avoids the overhead of pointer dereferences. Conversely, using a pointer type receiver avoids the performance overhead of copying large data structures.

In practice, we need to choose which type of receiver to use according to the specific situation. If our purpose is to modify the value of the object, and the object is large, then we should use a pointer type as the receiver; if our purpose is to access the object, and the object is small, then we can use a non-pointer type as the receiver.

Application Case

Through the receiver method, we can easily implement custom operations on data types. Here are some application cases using receiver methods:

1. Defining receiver methods on string types

type MyString string

func (s MyString) Reverse() string {
   str := string(s)
   runes := []rune(str)
   for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
      runes[i], runes[j] = runes[j], runes[i]
   }
   return string(runes)
}

func main() {
   str := MyString("hello world")
   reversed := str.Reverse()
   fmt.Println(reversed)
}

In the above example, we defined a MyString type, and a receiver method Reverse is defined on it. This method returns a string in reverse order. In the main function, we create a value of type MyString and call the Reverse method. The final output result is dlrow olleh.

2. 在时间类型上定义接收器方法

type MyTime time.Time

func (t MyTime) Format(format string) string {
   return time.Time(t).Format(format)
}

func main() {
   t := MyTime(time.Now())
   fmt.Println(t.Format("2006-01-02"))
}

在上面的例子中，我们定义了一个MyTime类型，并在它上面定义了一个接收器方法Format。该方法使用给定的格式将MyTime类型的值转换为字符串。在main函数中，我们创建一个MyTime类型的值并调用Format方法，最终输出结果是当前日期的字符串表示形式，例如2021-06-15。

总结

在Golang中，接收器方法是实现面向对象编程的核心机制，它可以在结构体类型上定义方法以及实现接口。接收器方法可以让我们方便地在数据类型上实现自定义操作，从而为我们的应用程序提供更多的灵活性和扩展性。我们需要根据具体情况选择接收器类型，并在实践中灵活运用接收器方法，实现自己的需求。

The above is the detailed content of golang receiving method. For more information, please follow other related articles on the PHP Chinese website!