How to convert interface type slices into concrete implementation type slices in Go language?

In Go language, convert interface type slices into concrete implementation type slices to avoid asserting one element by element. You can use json package for serialization and deserialization. This article discusses how to safely convert []people to []*man , provided that all elements in the []people slice are guaranteed to be of type *man .

question:

How to efficiently convert []people to []*man , avoid loop assertions one by one?

Solution:

It is not safe to use type assertions directly because there is no guarantee that all elements in the slice are of type *man . If the conversion is forced, it will result in a runtime panic. Therefore, it is recommended to use json package for serialization and deserialization:

 import (
    "encoding/json"
    "fmt"
)

type people interface {
    getname() string
}

type man struct {
    name string
}

func (m *man) getname() string {
    return m.name
}

func main() {
    peopleSlice := []people{&man{name: "John"}, &man{name: "Doe"}}

    jsonData, err := json.Marshal(peopleSlice)
    if err != nil {
        panic(err)
    }

    var manSlice []*man
    err = json.Unmarshal(jsonData, &manSlice)
    if err != nil {
        panic(err)
    }

    for _, m := range manSlice {
        fmt.Println(m.getname())
    }
}

This code first serializes []people into a JSON byte array. Then, deserialize the JSON byte array to []*man . The json package handles type conversion, ensuring that data is safely converted to target types. If peopleSlice contains elements of non- *man type, json.Marshal may fail with an error.

Important note: This method depends on the serialization and deserialization mechanism of json package. This method will fail if the man structure contains fields that cannot be processed by json package (for example, fields that contain custom types or cannot be serialized). In practical applications, it is necessary to select appropriate type conversion methods according to specific circumstances and handle errors well. If performance is a critical factor and the slice element type is guaranteed, it may be more efficient to loop type assert and handle errors.

The above is the detailed content of How to convert interface type slices into concrete implementation type slices in Go language?. For more information, please follow other related articles on the PHP Chinese website!