What is the difference between functions and methods in go language

The difference between functions and methods in the Go language: For ordinary functions, when the receiver is a value type, the pointer type data cannot be passed directly; for methods, when the receiver is a value type, the pointer type can be used directly variable calling method.

The operating environment of this article: windows10 system, Go 1.11.2, thinkpad t480 computer.

Official explanation of the difference between functions and methods: A method is a function that contains a receiver. The receiver can be a value of a named or structure type or a pointer. All methods of a given type belong to that type's method set.

Difference:

1. For ordinary functions: when the receiver (function parameter) is a value type, pointer type data cannot be passed directly, and vice versa.

func function_name([parameter list]) [return_types] {
   函数体
}

2. For methods (such as struct methods): When the receiver is a value type, you can directly call the method with a pointer type variable, and vice versa

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
   }

You can see methods and functions The difference is that the method after the func keyword is the receiver instead of the function name. The receiver can be a type defined by yourself. This type can be struct, interface, or even we can redefine basic data types.

Go functions

Functions are basic blocks of code used to perform a task.

The Go language has at least a main() function.

You can divide different functions through functions. Logically, each function performs a specified task.

The function declaration tells the compiler the name, return type, and parameters of the function.

Go functions can return multiple values.

The Go language standard library provides a variety of built-in functions that can be used. For example, the len() function can accept arguments of different types and return the length of that type. If we pass in a string, the length of the string is returned. If we pass in an array, the number of elements contained in the array is returned.

1. Value transfer: Value transfer refers to copying a copy of the actual parameters to the function when calling the function, so that if the parameters are modified in the function, the actual parameters will not be affected.

2. Passing by reference: Passing by reference means passing the address of the actual parameters to the function when calling the function. Then the modification of the parameters in the function will affect the actual parameters.

Go methods

There are both functions and methods in the Go language. A method is a function that contains a receiver, which can be a value of a named or structure type or a pointer. All methods of a given type belong to that type's method set.

The following defines a structure type and a method of this type:

package mainimport (   "fmt"  )/* 定义结构体 */type Circle struct {
  radius float64
}func main() {  var c1 Circle
  c1.radius = 10.00
  fmt.Println("Area of Circle(c1) = ", c1.getArea())
}//该 method 属于 Circle 类型对象中的方法func (c Circle) getArea() float64 {  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

(Learning video sharing: Introduction to Programming)

and above The code execution result is:

Area of Circle(c1) =  314

Example

 package structTest  
      
    //普通函数与方法的区别（在接收者分别为值类型和指针类型的时候）  
    //Date：2014-4-3 10:00:07  
      
    import (  
        "fmt"  
    )  
      
    func StructTest06Base() {  
        structTest0601()  
        structTest0602()  
    }  
      
    //1.普通函数  
    //接收值类型参数的函数  
    func valueIntTest(a int) int {  
        return a + 10  
    }  
      
    //接收指针类型参数的函数  
    func pointerIntTest(a *int) int {  
        return *a + 10  
    }  
      
    func structTest0601() {  
        a := 2  
        fmt.Println("valueIntTest:", valueIntTest(a))  
        //函数的参数为值类型，则不能直接将指针作为参数传递  
        //fmt.Println("valueIntTest:", valueIntTest(&a))  
        //compile error: cannot use &a (type *int) as type int in function argument  
      
        b := 5  
        fmt.Println("pointerIntTest:", pointerIntTest(&b))  
        //同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递  
        //fmt.Println("pointerIntTest:", pointerIntTest(b))  
        //compile error:cannot use b (type int) as type *int in function argument  
    }  
      
    //2.方法  
    type PersonD struct {  
        id   int  
        name string  
    }  
      
    //接收者为值类型  
    func (p PersonD) valueShowName() {  
        fmt.Println(p.name)  
    }  
      
    //接收者为指针类型  
    func (p *PersonD) pointShowName() {  
        fmt.Println(p.name)  
    }  
      
    func structTest0602() {  
        //值类型调用方法  
        personValue := PersonD{101, "Will Smith"}  
        personValue.valueShowName()  
        personValue.pointShowName()  
      
        //指针类型调用方法  
        personPointer := &PersonD{102, "Paul Tony"}  
        personPointer.valueShowName()  
        personPointer.pointShowName()  
      
        //与普通函数不同，接收者为指针类型和值类型的方法，指针类型和值类型的变量均可相互调用  
    }

Related recommendations: golang tutorial

The above is the detailed content of What is the difference between functions and methods in go language. For more information, please follow other related articles on the PHP Chinese website!