Introduction
La structure (struct) est un type composite qui peut être utilisé pour stocker différents types de données. Elle peut être utilisée pour implémenter des structures de données plus complexes. Par exemple, les articles d'un magasin de proximité ont des attributs tels que le nom du produit, la catégorie et le prix. Nous pouvons utiliser une structure pour les représenter.
Dans ce labo (LabEx), nous allons apprendre à définir et à utiliser des structures.
Points clés de connaissance :
- Définition d'une structure
- Méthodes d'une instance de structure
Définition d'une structure
Nous pouvons utiliser les mots-clés type et struct pour définir une structure. La syntaxe est la suivante :
type StructName struct {
FieldName Type
//...
}
Où :
- Type représente le type spécifique du nom de champ, qui peut être un entier, une chaîne de caractères, etc.
- StructName doit être unique au sein du même package.
- Les noms de champ doivent être uniques au sein de la même structure.
Essayons cela. Définissons un magasin de proximité :
type Store struct {
ProductType string // product type
ProductName string // product name
Price int // product price
}
Dans le code ci-dessus, nous définissons une structure nommée Store pour le magasin de proximité, qui inclut le type, le nom et le prix du produit.
Étant donné que les champs de type de produit et de nom de produit sont du même type, nous pouvons simplifier le code comme suit :
type Store struct {
ProductName, ProductType string
Price int
}
Instanciation avec var
Dans la section précédente, nous avons défini une structure Store pour un magasin de proximité, qui décrit l'espace mémoire. Elle ne sera allouée en mémoire et utilisera les champs de la structure qu'après instanciation.
Nous pouvons utiliser le mot-clé var pour instancier une structure :
var InstanceName Structure
Examinons un exemple d'instanciation. Créez un fichier nommé struct.go et écrivez le code suivant :
cd ~/project
touch struct.go
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
// Instantiate a structure using `var`
var store1 Store
// Assign values to the fields related to the instance store1
store1.productType = "Drinks"
store1.productName = "Coca-Cola"
store1.price = 3
fmt.Printf("store1:\n\t%s\n\t%s\n\t%d\n",
store1.productType, store1.productName, store1.price)
}
Exécutez le programme :
go run struct.go
Après exécution, le résultat suivant s'affiche :
store1:
Drinks
Coca-Cola
3
Dans ce programme, nous avons instancié un magasin de proximité à l'aide de var, puis nous avons assigné des valeurs à ses champs à l'aide de l'opérateur ..
Valeur initiale d'une structure
Quelle sera la valeur d'une structure instanciée si nous ne la faisons que créer sans lui assigner de valeur? Examinons le code suivant :
package main
import "fmt"
type Store struct {
ProductName string
ProductType string
Price int
}
func main() {
// Instantiate a structure using `var`
var lan1 Store
// Print the structure value using %#v
fmt.Printf("lan1: %#v\n", lan1)
}
Exécutez le programme :
go run struct.go
Le résultat est le suivant :
lan1: main.Store{ProductName:"", ProductType:"", Price:0}
Nous pouvons constater que lorsqu'aucune valeur initiale n'est spécifiée, la valeur de la structure instanciée est la valeur nulle du type correspondant. Par exemple, la chaîne de caractères est vide et l'entier est égal à 0.
Instanciation avec new
En plus d'utiliser le mot-clé var pour l'instanciation, nous pouvons également utiliser le mot-clé new :
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
store := new(Store)
// Use %T to output the type
fmt.Printf("Type of store: %T\n", store)
store.productType = "Daily Necessities"
store.productName = "Umbrella"
store.price = 20
fmt.Printf("store:\n\t%s\n\t%s\n\t%d\n",
store.productType, store.productName, store.price)
}
Exécutez le programme :
go run struct.go
Le résultat est le suivant :
Type of store: *main.Store
store:
Daily Necessities
Umbrella
20
Lorsque nous utilisons le mot-clé new pour l'instanciation, l'"instance" qu'il crée est en fait un pointeur vers l'instance. L'opération d'assignation d'une valeur au pointeur de structure est la même que celle d'assignation d'une valeur à une structure normale.
Instanciation avec :=
De même, nous pouvons utiliser := pour instancier une structure :
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{}
lan3.productType = "Fresh Food"
lan3.productName = "Taiwanese Meatballs"
lan3.price = 20
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Exécutez le programme :
go run struct.go
Le résultat est le suivant :
lan3:
Fresh Food
Taiwanese Meatballs
20
Nous pouvons écrire l'initialisation et l'affectation ensemble, comme ceci :
package main
import "fmt"
type Store struct {
productName string
productType string
price int
}
func main() {
lan3 := Store{
productType: "Fresh Food",
productName: "Taiwanese Meatballs",
price: 4,
}
fmt.Printf("lan3:\n\t%s\n\t%s\n\t%d\n",
lan3.productType, lan3.productName, lan3.price)
}
Exécutez le programme :
go run struct.go
Le résultat est le suivant :
lan3:
Fresh Food
Taiwanese Meatballs
4
Lorsque nous devons assigner des valeurs à tous les champs d'une structure, nous pouvons écrire les valeurs dans l'ordre dans lequel ils sont définis dans la structure.
Par exemple, nous réécrivons l'instance lan3 comme suit :
lan3 := Store{
"Fresh Food",
"Taiwanese Meatballs",
4,
}
Note : Cette syntaxe n'est adaptée que pour les cas où des valeurs sont assignées à tous les champs.
Résumé
Dans ce laboratoire (lab), nous avons présenté les structures et résumé les points de connaissances suivants :
- Les structures sont des types de données composites qui peuvent contenir plusieurs types de données différents.
- La valeur d'une structure non initialisée est la valeur nulle du type correspondant.
- Trois méthodes pour instancier une structure.
