Explorez la conversion de la structure en interface dans Golang

Il existe deux méthodes pour convertir une structure en interface : intégrer la structure ou utiliser le modèle d'adaptateur. L'incorporation est une approche plus directe qui crée un nouveau type avec les champs de la structure et les méthodes de l'interface. Le modèle Adaptateur utilise un type intermédiaire qui contient des instances de la structure et implémente l'interface. L'interface convertie contient uniquement des méthodes d'interface et ne contient pas d'autres champs de la structure. Les deux méthodes peuvent être utilisées pour obtenir la réutilisabilité du code orienté objet et offrir une flexibilité dans l'utilisation de différentes interfaces dans le système.

Conversion de structure en interface en langage Go

Que sont les structures et les interfaces ?

• Structure est un type de données qui contient une collection de données associées, et chaque élément de données est appelé un champ.
• Une interface est un type abstrait qui définit une collection de méthodes. Tout type qui implémente ces méthodes peut implémenter l'interface.

Conversion de la structure en interface

1. Incorporation

Le moyen le plus simple est d'intégrer la structure dans l'interface. Cela crée un nouveau type qui possède à la fois les champs de la structure et les méthodes de l'interface.

type Person struct {
    Name string
    Age  int
}

type Personer interface {
    GetName() string
}

// 嵌入 Person 到 Personer 4
type EmbeddedPerson struct {
    Person
}

func (p EmbeddedPerson) GetName() string {
    return p.Name
}

2. Modèle d'adaptateur

Une autre approche consiste à utiliser le modèle d'adaptateur, en créant un nouveau type qui contient une instance de la structure et implémente l'interface.

type Personer interface {
    GetName() string
}

type Person struct {
    Name string
    Age  int
}

// PersonAdapter 适配器
type PersonAdapter struct {
    p *Person
}

func (a *PersonAdapter) GetName() string {
    return a.p.Name
}

func main() {
    p := Person{"John", 30}
    pa := &PersonAdapter{&p}
    fmt.Println(pa.GetName()) // 输出：John
}

Remarque :

• Les champs de structure doivent être publics pour que les méthodes d'interface puissent y accéder.
• Le type d'interface converti contient uniquement des méthodes d'interface et n'inclut pas les autres champs de la structure.

Exemple pratique

Supposons que nous ayons un User 结构体，它包含姓名和电子邮件。我们要创建一个接口 Userer afin que nous puissions trouver des utilisateurs en fonction de leur nom ou de leur adresse e-mail.

Utiliser l'intégration :

type User struct {
    Name string
    Email string
}

type Userer interface {
    GetName() string
    GetEmail() string
}

type EmbeddedUser struct {
    User
}

func (u EmbeddedUser) GetName() string {
    return u.Name
}

func (u EmbeddedUser) GetEmail() string {
    return u.Email
}

Utiliser le mode adaptateur :

type Userer interface {
    GetName() string
    GetEmail() string
}

type User struct {
    Name  string
    Email string
}

type UserAdapter struct {
    user *User
}

func (ua *UserAdapter) GetName() string {
    return ua.user.Name
}

func (ua *UserAdapter) GetEmail() string {
    return ua.user.Email
}

func main() {
    user := User{"John", "john@example.com"}
    userAdapter := &UserAdapter{&user}
    fmt.Println(userAdapter.GetName())  // 输出：John
    fmt.Println(userAdapter.GetEmail()) // 输出：john@example.com
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!