Interface (Interfaces) du langage Go

O (opérations sur les fichiers)

Les interfaces en langage Go diffèrent des autres langages. En langage Go, une interface est un type personnalisé utilisé pour spécifier un ensemble de signatures de méthodes, et l'interface est abstraite, ce qui ne vous permet pas de créer des instances de cette interface. Cependant, vous pouvez créer des variables de type interface et assigner à ces variables des valeurs de types spécifiques qui ont les méthodes requises par l'interface. En d'autres termes, l'interface est à la fois un ensemble de méthodes et un type personnalisé.

Comment créer une interface ?

En langage Go, vous pouvez utiliser la syntaxe suivante pour créer une interface :
　　　　//type interface_name interface{
}

Signature de la méthode

//Créer une interface
Par exemple :
　　　　//　Méthode
　　　　() int1type myinterface interface{
　　　　() int2fun64
}

Dans ce cas, le nom de l'interface est inclus entre les mots-clés type et interface, et la signature de la méthode est comprise entre des crochets. () float

Comment implémenter une interface ?

En langage Go, pour implémenter une interface, il faut implémenter toutes les méthodes déclarées dans l'interface. Le langage Go utilise une implémentation implicite des interfaces. Comme dans d'autres langages, il n'utilise pas de mot-clé spécifique pour implémenter une interface. Voici un exemple :

//　Explication du programme Golang sur la manière de
//Implémenter l'interface
package　main
import　"fmt"
//Créer une interface
type tank interface {
　　　　//　Méthode
　　　　Tarea() float64
　　　　Volume() float64
}
type myvalue struct {
　　　　radius float64
　　　　height float64
}
//Méthode d'implémentation
//Le (Tank) interface
func (m myvalue) Tarea() float64　{
　　　　return　2*m.radius*m.height　+　2*3.14*m.radius*m.radius
}
func (m myvalue) Volume() float64　{
　　　　return　3.14　*　m.radius　*　m.radius　*　m.height
}
func　main()　{
　　　　//　Accès à l'interface du réservoir
　　　　var t tank
　　　　t = myvalue{10,　14}
　　　　fmt.Println("La surface du réservoir:", t.Tarea())
　　　　fmt.Println("La capacité du réservoir:", t.Volume())
}

Sortie :

La surface du réservoir :　908
La capacité du réservoir:　4396

Remarques

• La valeur zéro de l'interface est nil.

• Lorsque l'interface contient zéro méthode, ce type d'interface est appelé interface vide. Par conséquent, tous les types implémentent l'interface vide.

  Syntaxe :

  interface{}

• Type d'interface :L'interface a deux types, l'un est statique, et l'autre est dynamique. Le type statique est l'interface elle-même, par exemple tank dans l'exemple suivant. Mais l'interface n'a pas de valeur statique, donc elle pointe toujours vers une valeur dynamique.
  Les variables de type interface, qui contiennent des valeurs de types implémentant l'interface, donc cette valeur de type est appelée valeur dynamique, et ce type est le type dynamique. Ils sont également appelés valeurs spécifiques et types spécifiques.

  Exemple

  //Explication des concepts du programme Go
  //Valeur dynamique et type
  package　main
  import　"fmt"
  //Création d'interface
  type tank interface {
  　　　　//　Méthode
  　　　　Tarea() float64
  　　　　Volume() float64
  }
  func　main()　{
  　　　　var t tank
  　　　　fmt.Println("La valeur de l'interface tank est: ", t)
  　　　　fmt.Printf("Le type de tank est: %T ", t)
  }

  Sortie :

  La valeur de l'interface tank est: <nil>
  Le type de tank est: <nil>

  Dans l'exemple ci-dessus, il y a un interface nommé tank. Dans cet exemple,fmt.Println("La valeur de l'interface tank est: ", t) La déclaration retourne la valeur dynamique de cet interface, tandis que la déclaration fmt.Printf("Le type de tank est: %T ", t) retourne le type dynamique de l'interface, c'est-à-dire nil, car l'interface ici ne sait pas qui l'implémente.

• Assertion de type :En langage Go, l'assertion de type est une opération appliquée aux valeurs d'interface. Autrement dit, l'assertion de type est un processus d'extraction de valeurs d'interface.

  Syntaxe :
  

  a.(T)

  Ici, a est la valeur ou l'expression de l'interface, T est ce que l'on appelle une assertion de type. L'assertion de type est utilisée pour vérifier si le type dynamique de l'opérande correspond au type assertions. Si T est un type spécifique, l'assertion de type vérifie si le type dynamique de a est égal à T, ici, si le contrôle réussit, l'assertion de type retourne la valeur dynamique de a. Sinon, si le contrôle échoue, une exception panic se produira. Si T est un type d'interface, l'assertion de type vérifie si le type dynamique satisfait T, ici, si le contrôle réussit, aucune valeur dynamique n'est extraite.

  Exemple

  //Assertion de type　
  package　main　
  　　
  import　"fmt"
  　　
  func　myfun(a　interface{})　{　
  　　
  　　　　//Extraire la valeur de a
  　　　　val　:=　a.(string)　
  　　　　fmt.Println("valeur :　",　val)　
  }　
  func　main()　{　
  　　
  　　　　var　val　interface　{　
  　　　　}　=　"w3codebox"
  　　　　　　
  　　　　myfun(val)　
  }

  Sortie :

  valeur :　　w3codebox

  Dans l'exemple ci-dessus, si vous changezval：= a。（string）La phrase est modifiée enval：= a。（int），le programme lèvera une exception panic. Par conséquent, pour éviter ce problème, nous utilisons la syntaxe suivante :

  value,　ok　:=　a.(T)

  Ici, si le type de a est égal à T, cette valeur contient la valeur dynamique de a et ok est définie sur true. Et si le type de a n'est pas égal à T, ok est défini sur false et la valeur contient la valeur zéro, et le programme ne lève pas d'exception panic. Voici le programme suivant :

  Exemple

  package　main
  import　"fmt"
  func　myfun(a　interface{})　{
  　　　　value,　ok　:=　a.(float64)
  　　　　fmt.Println(value,　ok)
  }
  func　main()　{
  　　　　var　a1　interface　{
  　　　　}　=　98.09
  　　　　myfun(a1)
  　　　　var　a2　interface　{
  　　　　}　=　"w3codebox"
  　　　　myfun(a2)
  }

  Sortie :

  98.09　true
  0　false

• Détermination du type :Dans les interfaces Go, la détermination du type est utilisée pour comparer le type spécifique de l'interface avec les types fournis dans les instructions case. C'est similaire à une déclaration de type, mais avec une distinction, c'est-à-dire que les types sont spécifiés en majuscules, pas en valeurs. Vous pouvez également comparer les types avec les types d'interface. Voici un exemple :

  Exemple

  package　main
  import　"fmt"
  func　myfun(a　interface{})　{
  　　　　//Utilisation de la détermination du type
  　　　　switch　a.(type)　{
  　　　　case　int:
  　　　　　　　　fmt.Println("Type :　int, valeur :",　a.(int))
  　　　　case　string:
  　　　　　　　　fmt.Println("\nType :　string, valeur :　",　a.(string))
  　　　　case　float64:
  　　　　　　　　fmt.Println("\nType :　float64，valeur :　",　a.(float64))
  　　　　default :
  　　　　　　　　fmt.Println("\nType introuvable")
  　　　　}
  }

  Sortie :

  Type :　string, valeur :　　w3codebox
  Type :　float64，valeur :　　67.9
  Type introuvable

• Utilisation de l'interface :Lorsque vous souhaitez passer différents types de paramètres dans une méthode ou une fonction, vous pouvez utiliser une interface, comme le fonction Println(). Ou, vous pouvez également utiliser une interface lorsque plusieurs types implémentent le même interface.