English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base en Golang

Instructions de contrôle en Golang

Fonction & Méthode en Golang

Structure en Golang

Coupe & Tableau en Golang

Chaîne (String) en Golang

Pointeur en Golang

Interface en Golang

Concurrence en Golang

Exceptions (Error) de Golang

Autres éléments divers de Golang

Structure de type (struct) du langage Go

La structure (struct) en Golang est un type utilisateur défini, qui permet de regrouper des éléments de types différents/Composé en un seul type. Tout objet réel qui possède un ensemble d'attributs/Les entités de champ peuvent être représentées comme une structure. Ce concept est souvent comparé à la classe en programmation orientée objet. Il peut être appelé une classe légère qui ne supporte pas l'héritage mais la composition.

Par exemple, une adresse a des attributs name, street, city, state, Pincode. Voici comment ces trois attributs peuvent être combinés dans une structureAdressea un sens.

Déclaration de structure :

 type Address struct {
      name string 
      street string
      city string
      state string
      Pincode int
}

Sur cette page,typeLe mot-clé introduit un nouveau type. Après cela, vient le nom du type (Adresse) et le mot-cléstruct,Pour expliquer la structure que nous définissons. Cette structure contient une liste des champs à l'intérieur des crochets. Chaque champ a un nom et un type.

Attention :Nous pouvons également, comme dans l'exemple suivant, groupés les champs de même type pour les rendre plus compacts :}}

type Address struct {
    nom, rue, ville, état string
    Pincode int
}

Définir la structure :Syntaxe de déclaration de structure :

var a Address

Le code ci-dessus crée uneType AddressLes variables, par défaut, elles sont définies sur zéro. Pour les structures, zéro signifie que tous les champs sont définis sur leur valeur zéro correspondante. Par conséquent, les champs name, street, city, state sont définis sur "", et Pincode sur 0.

Vous pouvez égalementInitialiser une variable de type structure en utilisant un littéral structurauxComme suit :

var a = Address{"Akshay", "PremNagar", "Dehradun", "Uttarakhand", 252636}

Attention :

Toujours transmettre les valeurs des champs dans l'ordre où ils sont déclarés dans la structure. De plus, vous ne pouvez pas initialiser un sous-ensemble de champs uniquement en utilisant la syntaxe ci-dessus.

Go prend également en chargeNom : valeurSyntaxe, utilisée pour initialiser la structure (l'ordre des champs n'est pas important lorsque cette syntaxe est utilisée). De plus, cela ne vous permet d'initialiser qu'un sous-ensemble de champs. Tous les champs non initialisés sont définis sur leur valeur zéro correspondante.

Par exemple :

var a = Address{"Akshay", "PremNagar", "Dehradun", "Uttarakhand", 252636}
package main 
  
import "fmt"
  
//Définir le type de structure
type Address struct { 
    Name string 
    city string 
    Pincode int
} 
  
func main() { 
  
        //Déclarer une variable de type "struct"
        //Initialiser tous les champs struct
        //Ses valeurs sont zéro
    var a Address  
    fmt.Println(a) 
  
        //Déclaration et initialisation
        // L'utilisation de littéraux structuraux dans struct
    a1 := Adresse{"Akshay", "Dehradun", 3623572} 
  
    fmt.Println("Adresse1: "1) 
  
        //Lors de l'appel des champs
        //Initialiser une structure
    a2 := Adresse{Name: "Anikaa", city: "Ballia", Pincode: 277001} 
  
    fmt.Println("Adresse2: "2) 
  
        //Les champs non initialisés sont définis
        //Leurs valeurs zéro
    a3 := Adresse{Name: "Delhi"} 
    fmt.Println("Adresse3: "3) 
}

Sortie :

{ 0}
Adresse1: {Akshay Dehradun} 3623572}
Adresse2: {Anikaa Ballia} 277001}
Adresse3: {Delhi 0}

Comment accéder aux champs de la structure ?

Pour accéderDe la structureChamps individuels, vous devez utiliser le point(.)Opérateurs.

package main 
  
import "fmt"
  
//Définir la structure 
type Car struct { 
    Nom, Modèle, Couleur string 
    WeightInKg         float64 
} 
  
func main() { 
    c := Car{Name: "Ferrari", Model: "GTC4", Color: "Red", WeightInKg: 1920} 
  
        //Accéder aux champs de la structure
        //Utiliser l'opérateur point pour
    fmt.Println("Nom de la voiture: ", c.Name) 
    fmt.Println("Couleur de la voiture: ", c.Color) 
        //Affecter une nouvelle valeur
        //Pointeur vers un champ de structure
    c.Color = "Black"
      
    //Afficher le résultat
    fmt.Println("Voiture: ", c) 
}

Sortie :

Nom de la voiture:  Ferrari
Couleur de la voiture:  Rouge
Voiture:  {Ferrari GTC4 Noir 1920}

Pointeur vers la structure

Un pointeur en Golang est une variable utilisée pour stocker l'adresse en mémoire d'une autre variable. Vous pouvez également créer un pointeur vers une structure, comme dans l'exemple suivant :

// Pointeur vers la structure
package main 
  
import "fmt"
  
// Définir une structure
type Employee struct { 
    firstName, lastName string 
    age, salary int
} 
  
func main() { 
  
        //
        // emp8
    emp8 := &Employee{"Sam", "Anderson", 55, 6000} 
  
        //* emp8accès",
    "第34段": “(",
    "第35段": "Est un pointeur vers la structure Employee",
    "第36段": "Transmettre l
        // emp8Le champ firstName de la structure
    fmt.Println("Nom: ", (*emp8).firstName) 
    fmt.Println("Age:", (*emp8).age) 
}

Sortie :

Nom:  Sam
Age: 55

Golang nous fournit l'utilisation de emp8* emp8

//Pointeur vers la structure
package main 
  
import "fmt"
  
//Définir une structure
type Employee struct { 
    firstName, lastName string 
    age, salary         int
} 
  
func main() { 
  
    //Obtenir un pointeur vers une structure
    emp8 := &Employee{"Sam", "Anderson", 55, 6000} 
  
        // emp8utilise firstName pour accéder à
        //Champ firstName
    fmt.Println("Nom: ", emp8.firstName) 
    fmt.Println("Age: ", emp8.age) 
}

Sortie :

Nom:  Sam
Age:  55