How to use structs in Go?

When designing a program, using structures is a very common way. In Go language, structure is a very powerful concept that can help us better organize and manage code. In this article, we will explain in detail how to use structs in Go.

What is a structure?

Structure is a custom data type, which consists of multiple data fields. Each field can be any basic data type, such as a number, string, or Boolean value, or a combination of other structures. Fields in a structure can be accessed using dot notation, similar to object properties.

In Go, you can use types to define structures.

type Person struct {

name     string
age      int
language []string

}

This example defines a structure named Person, which has three fields: name, age and language. name is of string type, age is of int type, and language is a string slice. We can use the following command to create a new Person structure.

person := Person{name: "Tom", age: 25, language: []string{"Chinese", "English"}}

Dots can be used in the fields of the structure To access:

fmt.Println(person.name)

Anonymous fields in Go structures

In Go, you can also use anonymous fields to make the structure more compact. Anonymous fields are structure fields and have no names. When two or more fields have the same type, they can be defined as anonymous fields.

The following is an example that supports anonymous fields:

type Person struct {

name string
address

}

type address struct {

street string
city   string
state  string

}

In the above code, the Person structure contains an anonymous field named address. The structure also defines an address type, which has three fields: street, city, and state. We can access nested fields like this.

person := Person{name: "Tom", address: address{street: "Main St.", city: "New York", state: "NY"}}

fmt .Println(person.address.city)

Nested structures in Go structures

Structures can be nested within each other, which allows us to create more complex data structures. A structure can be embedded within another structure.

type Person struct {

name    string
contact Contact

}

type Contact struct {

email   string
phone   string
address string

}

In the above code, the Person structure There is a Contact structure nested in the body. A new Person structure can be created in the following way.

person := Person{name: "Tom", contact: Contact{email: "tom@gmail.com", phone: "888-888-8888", address: "Main St."}}

fmt.Println(person.contact.phone)

Methods in Go structures

In Go, structures can define methods, and these methods can be passed through the structure instance to call. A method is a special function that can only be called through a structure.

We can add methods using the following code.

type Person struct {

name string
age  int

}

func (p Person) sayHello() {

fmt.Printf("Hello, my name is %s, I'm %d years old.

", p.name, p.age)
}

In the above code, sayHello() is a method of a structure named Person.

We can use the following code to call this method.

person := Person{name: "Tom", age: 25}
person.sayHello()

In the above example, we created a Person object and called the sayHello() method. This method will output a greeting to the console.

Conclusion

Go structure is a very important concept in object-oriented programming, which provides a more A good way to organize and manage code. In this article we introduced in detail how to use structures in Go. We learned about the definition of structures, the use of anonymous fields and nested structures, and the definition and calling of methods. Hope This article will be helpful to you and help you better master Go language programming.

The above is the detailed content of How to use structs in Go?. For more information, please follow other related articles on the PHP Chinese website!