Les structures (partie I)

C'est quoi une structure?

Une structure est un type défini pour l'utilisateur qui représente une collection de champs. Une structure peut être utilisée pour regrouper des informations dans une seule unité au lieu de maintenir chaque information de type différente séparée de l'autre.

Par exemple, un employé a un nom, prénom et un âge, il est plus judicieux de regrouper ces informations dans une seule structure employee.

La déclaration d'une structure

type Employee struct {  
    nom string
    prenom  string
    age       int
}

Le fragment de code ci-dessus déclare une structure qui contient le nom, prénom et l'âge d'un employé, On peut réécrire autrement le code ci-dessus en déclarant les champs de même type dans une seule structure comme suivant:

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

Employee struct est nommée structure car elle crée un nouveau type appelé Employee qui peut être utilisé pour créer des structures de type Employee .

Il est possible de déclarer des structures sans déclarer un nouveau type et ce type de structures est appelé structures anonymes.

var employee struct {  
        nom, prenom string
        age int
}

Création des structures nommées

On va définir une structure nommée Employee en utilisant un programme simple.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

func main() {

    //creation d'une structure en utilisant les noms des champsc
    emp1 := Employee{
        prenom: "Sam",
        age:       25,
        salaire:    500,
        nom:  "Anderson",
    }

    //creation d'une structure sans utiliser les noms des champs
    emp2 := Employee{"Thomas", "Paul", 29, 800}

    fmt.Println("Employee 1", emp1)
    fmt.Println("Employee 2", emp2)
}

Dans le programme ci-dessus, on a créé une structure Employee . La structure emp1 est définie en indiquant la valeur de chaque nom de champ. Il n'est pas nécessaire de garder un ordre des noms de champs similaire à la déclaration de la structure.

emp2 est défini en omettant les noms de champs, c'est là où on doit maintenir un ordre similaire à celui de la déclaration de la structure.

La sortie du programme ci-dessus est:

Employee 1 {Sam Anderson 25 500}  
Employee 2 {Thomas Paul 29 800}  

Création des structures anonymes

package main

import (  
    "fmt"
)

func main() {  
    emp3 := struct {
        nom, prenom string
        age, salaire         int
    }{
        nom: "Andreah",
        prenom:  "Nikola",
        age:       31,
        salaire:    5000,
    }

    fmt.Println("Employee 3", emp3)
}

Dans le programme ci-dessus, une variable de structure anonyme emp3 est définie. Cette structure est appelée anonyme car elle crée une nouvelle variable struct emp3 et ne définie aucun nouveau type struct.

La sortie du programme ci-dessus est:

Employee 3 {Andreah Nikola 31 5000} 

La valeur zéro d'une structure

Quand une structure est définie et n'est pas initialisée explicitement à une valeur, Les champs de la structure sont initialisés par défaut à la valeur zéro de chaque type de champ.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

func main() {  
    var emp4 Employee //la valeur zéro de la structure
    fmt.Println("Employee 4", emp4)
}

La programme ci-dessus définie emp4 mais ne l'initialise pas à une valeur. Par conséquent, les valeurs zéros de string("") sont attribuées à nom et prénom, la valeur zéro(0) est affectée aux deux champs âge et salaire.

La sortie du programme est:

Employee 4 {  0 0}

Il est possible d'indiquer des valeurs pour quelques champs et ignorer le reste. Dans ce cas, les valeurs zéro sont attribuées aux champs ignorés.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

func main() {  
    emp5 := Employee{
        nom: "John",
        prenom:  "Paul",
    }
    fmt.Println("Employee 5", emp5)
}

Dans le programme ci-dessus, nom et prenom sont initialisés alors que age et salaire ne le sont pas. Par conséquent, la valeur zéro est attribuée aux deux champs non initialisés.

La sortie du programme est:

Employee 5 {John Paul 0 0} 

L'accès individuel aux champs d'une struct

L'opérateur . nous permet l'accès à un champ d'une structure.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire        int
}

func main() {  
    emp6 := Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("First Name:", emp6.firstName)
    fmt.Println("Last Name:", emp6.lastName)
    fmt.Println("Age:", emp6.age)
    fmt.Printf("Salary: $%d", emp6.salary)
}

Dans le programme ci-dessus, emp6.firstName accède au champ nom de struct emp6. La sortie du programme est:

nom: Sam  
prenom: Anderson  
Age: 55  
Salaire: $6000

Il est possible de créer un zéro struct puis affecter plus tard les valeurs aux champs de la structure comme suivant.

package main

import (  
    "fmt"
)

type Employee struct {  
    nom, prenom string
    age, salaire         int
}

func main() {  
    var emp7 Employee
    emp7.nom = "Jack"
    emp7.prenom = "Adams"
    fmt.Println("Employee 7:", emp7)
}

Dans le programme ci-dessus, emp7 est définie, on a attribué des valeurs à ces deux champs nom et prenom.

La sortie du programme est:

Employee 7: {Jack Adams 0 0}

---

Posted on Utopian.io - Rewarding Open Source Contributors

---