Comment les interfaces sont-elles définies et implémentées en langage Go ?

Comment les interfaces sont-elles définies et implémentées en langage Go ?

Le langage Go est un langage de programmation moderne. Il est conçu pour être simple et facile à comprendre, et il est également efficace, rapide et fiable. En langage Go, l’interface est un concept très important. Grâce aux interfaces, nous pouvons définir une collection de méthodes, puis laisser d'autres types implémenter ces méthodes. Dans cet article, nous explorerons en profondeur la définition et l’implémentation des interfaces dans le langage Go.

1. Définition de l'interface

Dans Go, une interface est un ensemble de méthodes. Concrètement, l'interface contient plusieurs méthodes, dont chacune doit avoir une signature fixe. Ces méthodes peuvent être des méthodes vides ou avoir des codes d’implémentation spécifiques. L'ensemble de méthodes définies via l'interface est associé à l'implémentation de type spécifique et peut être utilisé pour implémenter le polymorphisme.

La façon de définir une interface est très simple, utilisez simplement la syntaxe suivante :

type 接口名 interface {
    方法1(参数列表) 返回值列表
    方法2(参数列表) 返回值列表
    ...
}

Parmi eux, le nom de l'interface est le nom que nous spécifions pour l'interface, et la méthode 1, la méthode 2, etc. sont toutes des méthodes incluses dans l'interface.

Par exemple, nous définissons un gestionnaire d'interface, qui contient deux méthodes : Ajouter et Supprimer. Le code est le suivant :

type Manager interface {
    Add(name string) error
    Remove(name string) error
}

Ici, nous définissons une interface Manager, qui contient les méthodes Add et Remove. Les deux méthodes acceptent un nom de paramètre de type chaîne et renvoient une valeur de type d'erreur.

2. Implémentation d'interfaces

Dans Go, n'importe quel type peut implémenter une interface. Les types ici peuvent être des structures, des types de données de base, des fonctions, etc. Tant qu'un type implémente toutes les méthodes définies par l'interface, alors le type peut être considéré comme implémentant l'interface.

L'implémentation de l'interface peut être effectuée n'importe où, c'est-à-dire qu'elle peut être effectuée dans le package actuel ou dans d'autres packages. Lorsqu'un type implémente une interface, il peut être utilisé dans le code de l'appelant sans se soucier du type spécifique.

Par exemple, nous pouvons définir un type MysqlManager pour implémenter l'interface Manager :

type MysqlManager struct {}

func (mm *MysqlManager) Add(name string) error {
    // Add logic handling here
    return nil
}
func (mm *MysqlManager) Remove(name string) error {
    // Remove logic handling here
    return nil
}

Dans le code ci-dessus, nous définissons un type MysqlManager, qui implémente l'interface Manager, et implémente la logique d'ajout de données dans la méthode Add. la logique de suppression des données est implémentée dans la méthode Remove. De cette façon, nous pouvons utiliser le type MysqlManager au lieu de l'interface Manager et utiliser l'interface Manager dans le code de l'appelant.

Bien sûr, nous pouvons également définir un type RedisManager pour implémenter l'interface Manager :

type RedisManager struct {}

func (rm *RedisManager) Add(name string) error {
    // Add logic handling here
    return nil
}
func (rm *RedisManager) Remove(name string) error {
    // Remove logic handling here
    return nil
}

Dans le code ci-dessus, nous avons défini un type RedisManager, qui implémente également l'interface Manager, et ajoute des données dans la méthode Add Logic. la logique de suppression des données est implémentée dans la méthode Remove. De cette façon, nous pouvons choisir d'utiliser différentes sources de données en fonction de différentes situations lors de leur utilisation réelle, sans nous soucier du type spécifique de source de données.

3. Conversion de type

Étant donné que l'interface n'est pas un type spécifique, il s'agit simplement d'un ensemble de méthodes, donc lorsque nous l'utilisons, nous devons effectuer une conversion de type. La conversion de type ici consiste à convertir le type qui implémente l'interface en type d'interface.

Dans Go, il existe deux formes de conversion de type : l'une est une conversion et l'autre est une assertion de type.

1. Conversion de type forcée

Lorsque nous convertissons un type qui implémente une interface en type d'interface, nous pouvons utiliser la conversion de type forcée. Le format de syntaxe de cette méthode est le suivant :

var i interface{} = MysqlManager{}
mm := i.(Manager)

Dans le code ci-dessus, nous définissons une variable i, son type est interface{}, puis lui attribuons une instance de MysqlManager. Ensuite, nous utilisons cast pour convertir i en variable mm du type d'interface Manager.

2. Assertion de type

En plus de la conversion de type forcée, Go fournit également une autre méthode de conversion de type appelée assertion de type. Le format syntaxique de l'assertion de type est le suivant :

var i interface{} = MysqlManager{}
mm, ok := i.(Manager)

Dans cet exemple, nous définissons une variable i, son type est interface{}, puis lui attribuons une instance de MysqlManager. Ensuite, nous utilisons des assertions de type pour essayer de convertir i en variable mm du type d'interface Manager, et utilisons la variable ok pour déterminer si la conversion a réussi. Si la conversion réussit, la valeur de ok est vraie, sinon elle est fausse.

4. Résumé

Dans cet article, nous avons une discussion approfondie de la définition et de la mise en œuvre des interfaces dans le langage Go. On peut voir que l'interface est un concept très important dans Go, qui peut être utilisé pour implémenter le polymorphisme. Dans Go, n'importe quel type peut implémenter une interface, à condition qu'il implémente toutes les méthodes définies par l'interface. Lorsqu'un type implémente une interface, il peut être utilisé dans le code de l'appelant sans se soucier du type spécifique. Lors de l'utilisation d'interfaces, nous devons effectuer une conversion de type, qui inclut la conversion et l'assertion de type.

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!