SoFunction
Updated on 2025-03-05

Detailed explanation of the simplicity and efficiency of Go method

1. Introduction

In the world of software development, it is crucial to understand and master the various features of a programming language. Go (also known as Golang) is a modern programming language that attracts a large number of developers with its concise syntax and excellent performance. However, the core feature of Go's methods is often misunderstood or ignored. This not only affects the quality of the code, but can also lead to various problems in more complex systems or frameworks.

This article aims to deeply analyze the concepts and features of the method in Go, while providing practical applications and best practices to help you understand this important topic more comprehensively and in-depth. The article will first introduce the differences between methods and ordinary functions in Go, and then explore in-depth various characteristics of methods, including but not limited to the type of receiver, the differences between value receivers and pointer receivers, and how to use methods for more advanced programming skills.

We will also use a series of meticulous code examples to specifically demonstrate how these concepts and features are applied in actual development, including practical scenarios such as JSON serialization and custom data structure sorting. In addition, considering the importance of the method in large-scale or high-performance applications, this article will also compare and analyze the performance differences between different types of recipients and provide optimization suggestions.

This article is suitable for readers who have a certain foundation in Go language and hope to deepen their understanding of the characteristics of Go methods. Whether you are looking to improve code quality or looking for solutions to improve system performance, this article will provide you with valuable information and practical tips.

2. Basic concepts

Before we dive into the various advanced usages of method characteristics in Go, we need to figure out several basic concepts first. Understanding these concepts not only helps us better understand subsequent advanced topics, but also is the basis for writing robust and efficient code.

What is the method

In Go, a method is a special type of function that is attached to a specific type. This means that this specific type of variable can call the method.

type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return 3.14159 *  * 
}
// Use examplevar myCircle Circle
 = 5
("Area of circle:", ())

In this example,AreaIt's a bound inCircleMethods on type. You can create aCircleType variablemyCircle, and pass()To call this method.

The difference between methods and functions

Although methods in Go seem like functions in form, there are several key differences between the two.

  • Recipient: The first parameter in the method definition is called the receiver, which defines which type the method is associated with.
  • Call method: Methods need to be called through specific variables, while functions can be called directly.
// Functionfunc Add(a, b int) int {
    return a + b
}
// methodtype Integer int
func (a Integer) Add(b Integer) Integer {
    return a + b
}
// Use exampleresult := Add(1, 2)  // Function callvar a Integer = 1
var b Integer = 2
result = (b)  // Method call

In this example,AddFunctions andIntegerType ofAddMethods implement the same function, but their definitions and calling methods are different.

Recipient of the method

Go allows two types of recipients: value recipient and pointer recipient.

  • Value recipient: A copy of the receiver is passed when the method is called.
  • Pointer Receiver: The address of the receiver variable is passed when calling the method.

Both have their own advantages and disadvantages and applicable scenarios, but which type of receiver is chosen mainly depends on whether the receiver needs to be modified in the method or the performance optimization is concerned.

// Value recipientfunc (c Circle) Diameter() float64 {
    return 2 * 
}
// Pointer Receiverfunc (c *Circle) SetRadius(r float64) {
     = r
}
// Use examplevar c Circle
 = 5
("Diameter:", ())  // Value receiver call(10)  // Pointer receiver call("New Radius:", )

In this example,Diameteris a value receiver method that returns the diameter of the circle.SetRadiusis a pointer receiver method used to set the radius of a circle.

The above is a detailed analysis and example display of the basic concepts of methods in Go language. After understanding these basic knowledge, we can more confidently explore more advanced method usage scenarios and performance optimization techniques.

3. Definition and declaration of Go method

After understanding the basic concepts of Go methods, we will explore in more detail how to define and declare methods in Go language. Although this part of the content seems basic, it actually contains many details and traps that are easily overlooked.

Basic statement of the method

In Go, the basic declaration of the method is very intuitive. Similar to functions, methods also have names, parameter lists and return values, but the difference is that methods also have an additional "receiver" parameter.

// Method definition examplefunc (receiver ReceiverType) MethodName(arg1 Type1, arg2 Type2) ReturnType {
    // Method body}
// Practical exampletype Square struct {
    SideLength float64
}
func (s Square) Area() float64 {
    return  * 
}
// Use examplevar mySquare Square
 = 4
("Area of square:", ())

In this example, we define a name calledSquareand a structure namedAreaThe method is used to calculate the area of ​​a square.

Method and receiver type

Go allows adding methods to any user-defined types (including structures and alias types), but does not allow adding methods to built-in types or types imported from other packages.

// Add method to built-in type (wrong practice)func (i int) Double() int {
    return i * 2
}
// Add method to alias type (correct way)type MyInt int
func (i MyInt) Double() MyInt {
    return i * 2
}

In this example, we try to build-in typesintAdd oneDoubleMethod, this is not allowed. But we can define an alias typeMyInt, and add methods to it.

Value receiver and pointer receiver

We have briefly discussed value receivers and pointer receivers before, but what are the differences between these two receivers in the method definition?

  • Value recipientA copy of the receiver is created, so any modifications to the receiver inside the method will not affect the original value.
  • Pointer ReceiverThis is to pass the memory address of the receiver, so modifications to the receiver within the method will affect the original value.
// Value recipientfunc (s Square) SetSideLength(val float64) {
     = val
}
// Pointer Receiverfunc (s *Square) SetSideLengthPtr(val float64) {
     = val
}
// Use examplevar mySquare Square
 = 4
(5)
("Side Length after value receiver:", )  // Output 4(5)
("Side Length after pointer receiver:", )  // Output 5

This example passesSetSideLengthandSetSideLengthPtrThe two methods show the difference between the value recipient and the pointer recipient in modifying the receiver value.

Overload and method name conflict

It should be noted that Go does not support method overloading in the traditional sense, that is, there cannot be two methods with the same name but different parameters.

At the same time, Go does not allow a structure to have the same name method of the value receiver and the pointer receiver at the same time.

type MyStruct struct {
    Field int
}
func (m MyStruct) MyMethod() {
    ("Method with value receiver.")
}
func (m *MyStruct) MyMethod() {  // Compile error    ("Method with pointer receiver.")
}

Doing so will result in a compilation error, as Go will not be able to determine which one should be called in a specific situation.

4. Characteristics of Go method

Although the Go method seems simple on the surface, it actually hides many powerful and flexible features. These features make the Go method not just a simple encapsulation of functions, but a powerful abstraction mechanism. In this section, we will explore these features in detail.

Method values ​​and method expressions

In Go, methods can not only be called by the receiver, but can also be assigned to variables or passed as parameters, which is achieved through method values ​​and method expressions.

type MyInt int
func (i MyInt) Double() MyInt {
    return i * 2
}
// Use examplevar x MyInt = 4
doubleFunc :=   // Method valueresult := doubleFunc()  // Output 8

In this example,is a method value, which is assigned to a variabledoubleFunc, after which you can call it like a normal function.

Combination and embedding of methods

Go does not provide classes and inheritance mechanisms in traditional object-oriented programming languages, but you can easily implement reuse and combination through struct embedding and method combination.

type Shape struct {
    Name string
}
func (s Shape) Display() {
    ("This is a", )
}
type Circle struct {
    Shape  // Embed Shape    Radius float64
}
// Use examplec := Circle{Shape: Shape{Name: "Circle"}, Radius: 5}
()  // Output "This is a Circle"

Here,CircleThe structure is embeddedShapeStructure, thus "inheriting" itsDisplaymethod.

Visibility of the method

The visibility of methods follows the same rules as fields and functions. If the name of a method starts with a capital letter, the method is also visible outside the package; otherwise, it is only visible inside the package.

type myType struct {
    field int
}
// visible in the packagefunc (m myType) privateMethod() {
    ("This is a private method.")
}
// Visible outside the packagefunc (m myType) PublicMethod() {
    ("This is a public method.")
}

This is especially important for packaging, because you can control which methods should be exposed and which should be hidden.

Method coverage

When a structure is embedded in another structure with a certain method, the embedded structure can provide a method of the same name to "overwrite" the method of the embedded structure.

func (c Circle) Display() {
    ("This is not just a shape, but specifically a circle.")
}
// Use examplec := Circle{Shape: Shape{Name: "Circle"}, Radius: 5}
()  // Output "This is not just a shape, but specifically a circle."

In this example,CircleProvides a newDisplayMethods, thus coveringShapeofDisplaymethod.

Method Set

A method set of a type is a collection of all methods that the type can call. This set is different for value type and pointer type. This is particularly important when implementing interfaces and converting types.

type Cube struct {
    SideLength float64
}
func (c *Cube) Volume() float64 {
    return  *  * 
}
// Use examplevar myCube *Cube = &Cube{SideLength: 3}
var cubeVolume float64 = ()

In this example,VolumeOnly one method can be passedCubePointer is called because it is defined using the pointer receiver.

5. Practical application

After understanding the various features of the Go method, we will explore in this section how to use them effectively in practical applications. Here, the practicality of the Go method characteristics will be demonstrated through several specific scenarios and examples.

Use method values ​​for event processing

Method value properties are very useful in event processing models. Suppose we have a web server and we want to perform different logic on different types of HTTP requests.

type Handler struct {
    route map[string]func(, *)
}
func (h *Handler) AddRoute(path string, f func(, *)) {
    [path] = f
}
func (h *Handler) ServeHTTP(w , r *) {
    if f, ok := []; ok {
        f(w, r)
    } else {
        (w, r)
    }
}
// Use exampleh := &Handler{route: make(map[string]func(, *))}
("/hello", func(w , r *) {
    (w, "Hello, world!")
})
(":8080", h)

here,ServeHTTPis a method value, which calls different functions according to different routes.

Implement policy patterns with embedding and method overlay

A policy pattern is a design pattern that allows the behavior of an algorithm to change dynamically at runtime. With Go's embedding and method coverage features, we can easily implement this pattern.

type Sorter struct{}
func (s *Sorter) Sort(arr []int) {
    ("Default sort algorithm")
}
type QuickSorter struct {
    Sorter
}
func (qs *QuickSorter) Sort(arr []int) {
    ("Quick sort algorithm")
}
// Use examples := &Sorter{}
(nil)  // Output "Default sort algorithm"qs := &QuickSorter{}
(nil)  // Output "Quick sort algorithm"

In this example,QuickSorterInheritedSorterall methods and by overwritingSortMethod to provide a different implementation.

Using method set to implement interfaces

Method sets are a key factor in determining whether a type satisfies an interface. For example, consider aDrawableinterface:

type Drawable interface {
    Draw()
}
type Circle struct {
    Radius float64
}
func (c *Circle) Draw() {
    ("Drawing a circle.")
}
func DrawAllShapes(shapes []Drawable) {
    for _, s := range shapes {
        ()
    }
}
// Use exampleshapes := []Drawable{&Circle{Radius: 5}}
DrawAllShapes(shapes)  // Output "Drawing a circle."

Here, becauseCircleThe method set containsDrawmethod, so it satisfiesDrawableinterface.

6. Performance considerations

Performance is an important aspect that cannot be ignored when using Go's method characteristics. This section discusses various considerations related to the performance of Go methods in detail and explains them through examples.

Overhead of method calls and function calls

First, it is important to understand the performance differences between method calls and normal function calls.

func FunctionAdd(a, b int) int {
    return a + b
}
type Adder struct {
    a, b int
}
func (adder Adder) MethodAdd() int {
    return  + 
}
// Use examplefunc BenchmarkFunctionAdd(b *) {
    for i := 0; i < ; i++ {
        _ = FunctionAdd(1, 2)
    }
}
func BenchmarkMethodAdd(b *) {
    adder := Adder{1, 2}
    for i := 0; i < ; i++ {
        _ = ()
    }
}

After benchmarking, you will find that the performance difference between the two is usually very small and is usually not a performance bottleneck.

Pointer Receiver and Value Receiver

Using pointer receivers and value receivers will have different performance effects, especially when the structure is larger or involves modification operations.

type BigStruct struct {
    data [1 << 20]int
}
func (b *BigStruct) PointerReceiverMethod() int {
    return [0]
}
func (b BigStruct) ValueReceiverMethod() int {
    return [0]
}

Using pointer receivers is usually faster because it avoids copying of values.

Method inline

Method inline is an aspect of compiler optimization that affects the performance of method calls. Short and frequently called methods are more likely to be inlined by the compiler.

func (b *BigStruct) LikelyInlined() int {
    return [0]
}
func (b *BigStruct) UnlikelyInlined() int {
    sum := 0
    for _, v := range  {
        sum += v
    }
    return sum
}

LikelyInlinedThe method is more likely to be inlined by the compiler due to its shortness and directness, thus providing better performance.

Delay method and instant method

Go provides delayed execution methods (defer) features, but this usually brings additional performance overhead.

func DeferredMethod() {
    defer ("This is deferred.")
    ("This is not deferred.")
}

Avoid using unless necessary (e.g., perform resource cleaning, etc.)deferCan improve performance.

7. Summary

In this article, we have in-depth discussions on the various features and applications of methods in Go, from basic concepts and definitions to advanced usage and performance considerations, and each aspect is detailed analysis and example demonstration. But beyond all these technical details, one thing may be more important:Methods are a micro-embodied in Go programming philosophy。

Go emphasizes simplicity and efficiency, which is fully reflected in its method design. Compared to other programming languages, Go does not have too much modification and redundancy, and each feature is carefully designed to solve practical problems. For example, Go's method values ​​and method expressions provide limited but efficient support for the first-class citizenship characteristics of functions. This reflects Go's design philosophy, which provides the necessary flexibility while avoiding increased complexity.

Similarly, in terms of performance considerations, the design of the Go method also demonstrates its balanced focus on practicality and performance. Every detail reflects this from compiler optimization (such as method inline) to runtime efficiency (such as different usages of pointer receivers and value receivers).

But ultimately, the key to understanding the Go method is not just to master its grammar or remember various "best practices", but to understand the design philosophy and goals behind it. Only in this way can we use these tools more wisely and write more elegant, efficient and maintainable code.

I hope this article can help you not only learn the specific application of Go methods, but also inspire you to think deeply about programming and software design. This way, whether you are building small applications or designing a huge cloud service architecture, you can make smarter and more efficient decisions.

For more information on the simplicity and efficiency of Go methods, please follow my other related articles!