Que signifie le type Golang ?

Type est un mot-clé important et couramment utilisé dans la grammaire go. Type ne correspond en aucun cas simplement à typedef en C/C++. Il existe deux façons d'utiliser le type, l'une est l'alias de type et l'autre est la définition de type. Est-ce la saveur familière du langage C (define et typedef) ?

Définition du type

type Student struct {
  name String
  age int
}
type I int

Alias ​​du type

type Sdt = Student
type I = int

le type a les utilisations suivantes :

Définir la structure

Définir l'interface

Définition du type

Alias ​​du type

Requête de type

Structure de définition

La structure est une structure de données abstraite définie par l'utilisateur. La structure de Golang est similaire à la classe du langage Java et joue un rôle décisif dans la programmation. L'utilisation des structures sera présentée en détail dans le mot-clé struct. Jetons un coup d'œil au format syntaxique pour définir une structure :

type name struct {
    Field1  dataType
    Field2  dataType
    Field3  dataType
}

Définir une interface

Les points de connaissances liés à l'interface seront introduits en détail dans le mot-clé interface, ci-dessous Regardez le format de syntaxe pour définir une interface :

type name interface{
    Read()
    Write()
}

Définition de type

Le type défini à l'aide de la définition de type est différent du type d'origine, vous ne pouvez donc pas utiliser une nouvelle variable de type à attribuer aux variables de type d'origine, sauf si la conversion est utilisée. Jetons un coup d'œil à un exemple de code pour définir un nouveau type basé sur le type de chaîne. Le nouveau nom du type est name :

type name string

Pourquoi utiliser la définition de type ?

La définition de type peut créer un nouveau type basé sur le type d'origine. Dans certains cas, elle peut rendre le code plus concis, comme l'exemple de code suivant :

package main
import (
  "fmt"
)
// 定义一个接收一个字符串类型参数的函数类型
type handle func(str string)
// exec函数，接收handle类型的参数
func exec(f handle) {
  f("hello")
}
func main() {
  // 定义一个函数类型变量，这个函数接收一个字符串类型的参数
  var p = func(str string) {
    fmt.Println("first", str)
  }
  exec(p)
  // 匿名函数作为参数直接传递给exec函数
  exec(func(str string) {
    fmt.Println("second", str)
  })
}

Les informations de sortie sont :

first hello
second hello

L'exemple ci-dessus est une application simple de définition de type. Si vous n'utilisez pas de définition de type, comment devez-vous écrire ce code si vous souhaitez implémenter les fonctions de l'exemple ci-dessus ?

// exec函数，接收handle类型的参数
func exec(f func(str string)) {
  f("hello")
}

Le type de paramètre dans la fonction exec doit être remplacé par func (str string). Ce n'est pas compliqué à première vue, mais que se passe-t-il si exec reçoit une variable de fonction qui nécessite 5 paramètres ? Avez-vous l’impression que la liste des paramètres sera très longue ?

func exec(f func(str string, str2 string, num int, money float64, flag bool)) {
  f("hello")
}

Comme le montre le code ci-dessus, la lisibilité de la liste des paramètres de la fonction exec est devenue pire. Voyons comment implémenter cette fonction à l'aide des définitions de type :

package main
import (
  "fmt"
)
// 定义一个需要五个参数的函数类型
type handle func(str string, str2 string, num int, money float64, flag bool)
// exec函数，接收handle类型的参数
func exec(f handle) {
  f("hello", "world", 10, 11.23, true)
}
func demo(str string, str2 string, num int, money float64, flag bool) {
  fmt.Println(str, str2, num, money, flag)
}
func main() {
  exec(demo)
}

Alias ​​de type

Alias ​​de type Cette fonctionnalité a été introduite dans golang1.9. Le type défini à l'aide d'un alias de type est le même que le type d'origine, c'est-à-dire qu'il peut être affecté aux variables du type d'origine et possède tous les ensembles de méthodes du type d'origine. Donnez un alias au type chaîne. Le nom de l'alias est name :

type name = string

La différence entre l'alias de type et la définition de type est que l'utilisation de l'alias de type nécessite l'ajout d'un symbole d'affectation (=) entre l'alias et le type d'origine using ; type Le type défini par l'alias est équivalent au type d'origine, tandis que le type défini à l'aide du type est un nouveau type.

L'exemple suivant :

package main
import (
  "fmt"
)
type a = string
type b string
func SayA(str a) {
  fmt.Println(str)
}
func SayB(str b) {
  fmt.Println(str)
}
func main() {
  var str = "test"
  SayA(str)
  
  //错误参数传递，str是字符串类型，不能赋值给b类型变量
  SayB(str)
}

Ce code provoquera l'erreur suivante lors de la compilation :

.\main.go:21:6: cannot use str (type string) as type b in argument to SayB

Comme le montre le message d'erreur, str est un type de chaîne et ne peut pas être considéré comme un type b. Les paramètres sont passés dans la fonction SayB. Cependant, str peut être transmis à la fonction SayA en tant que paramètre de type. On peut voir que le type défini à l'aide de l'alias de type est cohérent avec le type d'origine, tandis que le type défini par la définition de type est un nouveau type.

L'ajout d'une méthode à un alias de type sera ajouté à l'ensemble de méthodes de type d'origine

Après avoir ajouté une méthode à un alias de type, le type d'origine peut également utiliser cette méthode. Veuillez consulter un exemple de code ci-dessous :

package main
import (
  "fmt"
)
// 根据string类型，定义类型S
type S string
func (r *S) Hi() {
  fmt.Println("S hi")
}
// 定义S的类型别名为T
type T = S
func (r *T) Hello() {
  fmt.Println("T hello")
}
// 函数参数接收S类型的指针变量
func exec(obj *S) {
  obj.Hello()
  obj.Hi()
}
func main() {
  t := new(T)
  s := new(S)
  exec(s)
  // 将T类型指针变量传递给S类型指针变量
  exec(t)
}

Les informations de sortie sont :

T hello
S hi
T hello
S hi

Dans l'exemple ci-dessus, S est le type d'origine et T est l'alias de type S. Après avoir ajouté la méthode Hello à T, les variables de type S peuvent également utiliser la méthode Hello. Notez qu'après avoir ajouté une méthode à un alias de type, le type d'origine peut également utiliser cette méthode. Comme le montre l'exemple, la variable t peut être affectée à la variable de type S s, de sorte que l'alias de type est un surnom pour le type d'origine, sans aucun changement en substance.

L'alias de type ne peut affecter que les types personnalisés dans le même package. Par exemple, il existe de nombreux packages dans le SDK Golang. Pouvons-nous utiliser des alias de type pour ajouter de nouvelles méthodes aux types de structure dans le package SDK ? La réponse est : non. Veuillez garder une chose à l'esprit : les alias de type ne peuvent affecter que les types contenus dans le package. Si des alias de type sont utilisés pour des types extérieurs au package, les informations suivantes seront demandées lors de la compilation :

cannot define new methods on non-local type string

Requête de type<. 🎜>

package main
import (
  "fmt"
)
func main() {
    // 定义一个interface{}类型变量，并使用string类型值”abc“初始化
    var a interface{} = "abc"
    
    // 在switch中使用 变量名.(type) 查询变量是由哪个类型数据赋值。
    switch v := a.(type) {
    case string:
      fmt.Println("字符串")
    case int:
        fmt.Println("整型")
    default:
      fmt.Println("其他类型", v)
    }
}

cannot type switch on non-interface value a (type string)

use of .(type) outside type switch

tutoriels d'introduction au Golang gratuits, tout le monde est invité à apprendre !

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!