golang non-exported methods

Golang is a very popular programming language. One of its features is that it supports object-oriented programming. In object-oriented programming, we usually divide methods into exported methods and non-exported methods. Exported methods are methods that can be called and used by code outside the package, while non-exported methods can only be called by code within the same package. This article will focus on non-exported methods in Golang.

In Golang, we define non-exported methods by using the first letter of the method name in lowercase. For example, the following is a non-exported method defined inside the Person structure:

type Person struct {
    name string
}

func (p Person) work() {
    fmt.Printf("%s is working.", p.name)
}

In the above code, we define a non-exported method named work. This method can only be called within the same package because the first letter of its method name is lowercase. Inside this method, we can use the structure variable p to call the person's name attribute, and then print out that the person is working.

The difference between non-exported methods and exported methods is that the first letter of the method name of the exported method is capitalized, so it can be used by code outside the package. Non-exported methods are usually used as internal implementation details because they cannot be used by code outside the package, making the logic of the code clearer and more concise.

In addition, in Golang, non-exported methods can also be used to hide data. For example, we can define a structure whose private variables can only be accessed inside the structure. In this way, code outside the structure cannot directly access these private variables. We can only operate these private variables by defining methods. This approach can further ensure the security and maintainability of the code.

type Person struct {
    name string
    age  int
}

func NewPerson(name string, age int) Person {
    return Person{name: name, age: age}
}

func (p Person) GetName() string {
    return p.name
}

func (p *Person) SetAge(age int) {
    p.age = age
}

func main() {
    person := NewPerson("Alice", 20)
    fmt.Printf("name: %s age: %d", person.GetName(), person.age)
    person.SetAge(21)
    fmt.Printf("name: %s age: %d", person.GetName(), person.age)
}

In the above code, we define a Person structure, in which name and age are private and therefore cannot be accessed directly. We operate these two private variables by defining two methods: GetName and SetAge. In this way we can hide these private variables and ensure the maintainability and security of the code.

In short, non-exported methods are a very important concept in Golang. They are usually used as internal implementation details or to hide data to ensure the logic and maintainability of the code. Whether you are building large software or small applications, non-export methods are very useful.

The above is the detailed content of golang non-exported methods. For more information, please follow other related articles on the PHP Chinese website!