Implementation example of structure slice in go

In Go language, structure slices are a very commonly used data structure. It combines the characteristics of structures and slices, and can easily store and operate multiple structure instances. The following is a detailed introduction to Go structure slices:

1. Definition of structure slices

Syntax form:
The basic syntax for defining a structure slice is as follows: first define a structure type, and then declare the slice of that structure type through [].

For example, define a Student struct that represents student information, and then define a slice of the structure:

type Student struct {
    Name    string
    Age     int
    Grade   string
}

func main() {
    var students []Student
}

In the above code, students is a slice of Student structure type. It is initially empty and can be used to store multiple Student structure instances.

Create and initialize using the make function:

• In addition to the above-mentioned direct declaration, you can also use the make function to create structure slices and initialize them, specifying the initial length and capacity of the slice (if you do not specify the capacity, the capacity defaults and length are equal).

For example:

students := make([]Student, 3)
// At this time, the slice length and capacity are both 3, and you can access and assign values ​​through the indexstudents[0] = Student{
    Name:  "Alice",
    Age:   12,
    Grade: "Sixth Grade",
}

2. Add elements to the structure slice

Use the append function to add a single element:

• The append function is a common method used in Go language to add elements to slices.

For example, continue to add new student information to the students slice defined above:

newStudent := Student{
    Name:  "Bob",
    Age:   11,
    Grade: "Fifth Grade",
}
students = append(students, newStudent)

The above code first creates a new Student structure instance, and then adds it to the end of the students slice through the append function, and needs to reassign the return value of the append function to the original slice variable, because the append operation may cause memory reassignment of the underlying array of the slice (when the slice capacity is insufficient).

Add elements in batches (add elements from another slice):

• You can add all elements in an existing structure slice to another slice, using the append function as shown below:

moreStudents := []Student{
    {Name: "Cathy", Age: 10, Grade: "Fourth Grade"},
    {Name: "David", Age: 13, Grade: "Seventh Grade"},
}
students = append(students, moreStudents...)

Note that after moreStudents, this is a syntax requirement of Go, which means that all elements in the moreStudents slice are expanded and added to the students slice.

3. Access elements in the structure slice

Access members of a single element through indexes:

• You can access a structure instance in a structure slice through indexing just like accessing a normal slice element, and then access its member variables.

For example:

(students[0].Name) // Output the name of the first student in the slice

Traversing the structure slice:

• Using a for loop to traverse structure slices is a common operation. There are two common traversal methods:

Method 1: Normal for loop combined with index access:

for i := 0; i < len(students); i++ {
    ("Student name: %s, age: %d, grade: %s\n", students[i].Name, students[i].Age, students[i].Grade)
}

Method 2: Use a for range loop:

for _, student := range students {
    ("Student name: %s, age: %d, grade: %s\n", , , )
}

The for range loop will automatically assign each element in the slice to the student variable in sequence (the _ here means ignore the index value, because we usually only care about the element itself, and if we need to use the index, we can also assign it to a variable), which is more concise and convenient to use and is often used to traverse and read elements in the structure slice.

4. Structure slices as function parameters and return values

Pass as function parameters:

• Structural slices can be passed as parameters of functions like other data types, passing a copy of the slice (but the structure instances in the slice are still the same as the original ones, because the bottom layer of the slice is the reference type in Go).

For example:

func printStudents(students []Student) {
    for _, student := range students {
        ("Student name: %s, age: %d, grade: %s\n", , , )
    }
}

func main() {
    students := []Student{
        {Name: "Alice", Age: 12, Grade: "Sixth Grade"},
    }
    printStudents(students)
}

In the above code, the printStudents function receives a Student structure slice parameter and traversal prints the element information therein.

Return as function return value:

• Functions can also return structure slices, for example, the following function is used to create and return a set of student information:

func createStudents() []Student {
    return

This is the end of this article about the implementation example of structure slices in go. For more related structure slice content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!