Golang 中的方法和函数有什么区别？

In Golang, methods and functions are two distinct executable code blocks, but they have several key differences:

1. Association:

   • Function: is independent and does not depend on any object or type. Functions can be defined and called anywhere.
   • Method: must be associated with a specific type. In other words, methods are functions defined on types (such as structs or type aliases). This means method calls must be made through an instance of that type.

2. Definition:

   • Function definition does not require a type context. For example:

     go
     func Add(x, y int) int {
         return x + y
     }

   • Method definition requires specifying a receiver, which is declared before the method name as a parameter. For example:

     go
     type Point struct {
         X, Y float64
     }
     
     func (p Point) Distance(q Point) float64 {
         return math.Hypot(q.X-p.X, q.Y-p.Y)
     }

3. Invocation:

   • Function invocation is performed directly using the function name. For example:

     go
     result := Add(1, 2)

   • Method invocation must be performed through an instance of the type. For example:

     go
     p := Point{1, 2}
     q := Point{4, 6}
     distance := p.Distance(q)

4. Purpose:

   • Function is typically used for operations that do not depend on object state.
   • Method is typically used for operations closely tied to object state. It can access and modify the properties of the receiver object.

5. Namespace:

   • Function belongs to the package-level namespace.
   • Method belongs to the type-level namespace. This means different types can have methods with the same name, while functions must remain unique within the same package.

These differences indicate that when designing your Go program, you should choose between methods and functions based on whether you need to bind to a specific data structure type. For example, if you need to write a function to calculate the distance between two points and this calculation depends on the specific positions of the points, using a method is more natural. If you only need a function for mathematical operations, using a function is more appropriate.