Comment utiliser les types map, slice, struct et interface des fonctions Golang

Golang est un langage de programmation open source développé par Google. Il utilise des mécanismes de typage statique et de garbage collection et prend en charge la programmation simultanée. Les fonctions sont un composant important dans Golang, et map, slice, struct et interface sont des types de données couramment utilisés dans les fonctions. Cet article présentera l'utilisation de ces types de données dans Golang.

1. Le type de carte

map est une structure de données de paire clé-valeur dans Golang, son utilisation est très simple. Voici un exemple :

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    fmt.Println(m)
}

Dans l'exemple ci-dessus, nous utilisons d'abord la fonction make pour créer une carte vide, puis ajoutons des paires clé-valeur à la carte dans l'ordre. Enfin, la carte est générée à l'aide de la fonction println du package fmt.

En plus d'utiliser la fonction make pour créer une carte, nous pouvons également utiliser des littéraux pour créer une carte non vide, comme indiqué ci-dessous :

package main

import "fmt"

func main() {
    m := map[string]int{"apple": 1, "banana": 2, "orange": 3}
    fmt.Println(m)
}

Nous pouvons également déclarer Lorsque vous utilisez des variables, déclarez la carte ensemble, comme indiqué ci-dessous :

package main

import "fmt"

func main() {
    var m map[string]int
    m = make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    fmt.Println(m)
}

Bien sûr, si une paire clé-valeur n'existe pas dans la carte, nous pouvons utiliser la fonction delete pour la supprimer, comme indiqué ci-dessous :

package main

import "fmt"

func main() {
    m := make(map[string]int)
    m["apple"] = 1
    m["banana"] = 2
    m["orange"] = 3
    delete(m, "banana")
    fmt.Println(m)
}

2. Le type de tranche

slice est un tableau dynamique qui peut ajouter ou supprimer des éléments à tout moment. Voici un exemple :

package main

import "fmt"

func main() {
    s := make([]string, 3)
    s[0] = "apple"
    s[1] = "banana"
    s[2] = "orange"
    s = append(s, "grape")
    fmt.Println(s)
}

Dans l'exemple ci-dessus, nous utilisons la fonction make pour créer une tranche avec un type d'élément chaîne et une longueur de 3. Ensuite, nous avons ajouté 3 éléments à la tranche, et enfin ajouté un nouvel élément à la tranche à l'aide de la fonction append.

Bien sûr, nous pouvons également utiliser des littéraux pour créer une tranche non vide, comme indiqué ci-dessous :

package main

import "fmt"

func main() {
    s := []string{"apple", "banana", "orange"}
    s = append(s, "grape")
    fmt.Println(s)
}

Nous pouvons également déclarer une tranche ensemble lors de la déclaration de variables, comme indiqué ci-dessous :

package main

import "fmt"

func main() {
    var s []string
    s = make([]string, 3)
    s[0] = "apple"
    s[1] = "banana"
    s[2] = "orange"
    s = append(s, "grape")
    fmt.Println(s)
}

3. Le type de structure

struct est un type composite personnalisé qui peut stocker plusieurs types de données. Voici un exemple :

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{"Tom", 18}
    fmt.Println(p)
}

Dans l'exemple ci-dessus, nous utilisons le mot-clé type pour créer un type de structure nommé Person. Ensuite, nous créons une variable p, dont le type est Personne, et lui attribuons une valeur.

De plus, nous pouvons également utiliser des pointeurs de structure pour accéder aux champs de type struct, comme indiqué ci-dessous :

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    p := &Person{"Tom", 18}
    p.Name = "Jerry"
    fmt.Println(p)
}

4. interface est un type abstrait qui peut être utilisé pour représenter n’importe quel type. Voici un exemple :

package main

import "fmt"

type Animal interface {
    Eat()
}

type Cat struct {
    Name string
}

func (c *Cat) Eat() {
    fmt.Printf("%s is eating
", c.Name)
}

func main() {
    var a Animal
    a = &Cat{"Tom"}
    a.Eat()
}

Dans l'exemple ci-dessus, nous avons utilisé le mot-clé type pour créer un type d'interface nommé Animal, qui n'a qu'une seule méthode Eat. Ensuite, nous utilisons le mot-clé type pour créer un type struct nommé Cat, qui implémente la méthode Eat de type Animal. Enfin, nous créons une variable a dont le type est Animal et l'attribuons à une variable de type Cat. Lorsque nous appelons la méthode Eat de a, une phrase est affichée indiquant que Cat mange.

De plus, nous pouvons également utiliser des assertions de type pour déterminer si une variable implémente une certaine interface, comme indiqué ci-dessous :

package main

import "fmt"

type Animal interface {
    Eat()
}

type Cat struct {
    Name string
}

func (c *Cat) Eat() {
    fmt.Printf("%s is eating
", c.Name)
}

func main() {
    var a Animal
    a = &Cat{"Tom"}
    _, ok := a.(*Cat)
    fmt.Println(ok)
}

Dans l'exemple ci-dessus, nous utilisons le mot-clé type crée un type d'interface nommé Animal, qui n'a qu'une seule méthode Eat. Ensuite, nous utilisons le mot-clé type pour créer un type struct nommé Cat, qui implémente la méthode Eat de type Animal. Enfin, nous créons une variable a dont le type est Animal et l'attribuons à une variable de type Cat. Nous utilisons des assertions de type pour déterminer si a implémente le type Cat et affiche true.

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!