Étude approfondie des types de données dans le langage Go

1 Introduction aux types de données en langage Go

En langage Go, les types de données sont la base de la programmation, déterminant la forme des données que les variables peuvent stocker. Les types de données de base fournis par le langage Go sont principalement divisés en les catégories suivantes :

Ces types peuvent être choisis en fonction des besoins différents, tels que les calculs numériques, le traitement de texte ou le contrôle logique.

2 Types de données entières

2.1 Aperçu des types entiers

Le langage Go dispose de plusieurs types entiers intégrés, classés comme suit :

• Entiers signés : int8, int16, int32 (ou rune), int64 et int
• Entiers non signés : uint8 (ou byte), uint16, uint32, uint64 et uint

Les tailles de int et uint sont de 4 octets sur les systèmes 32 bits et de 8 octets sur les systèmes 64 bits. Les plages de valeurs des types de données entières sont indiquées dans le tableau ci-dessous :

2.2 Utilisation des variables entières

La syntaxe de base pour déclarer une variable entière est la suivante :

var nom_variable type_de_données = valeur_initiale

Exemple de code :

package main
import "fmt"

func main() {
    var a int = 10 // Variable entière signée
    var b uint = 20 // Variable entière non signée
    var c int8 = -128 // Plus petite valeur de int8
    fmt.Println(a, b, c)
}

2.3 Opérations entières

Le langage Go prend en charge les opérateurs arithmétiques courants, tels que l'addition (+), la soustraction (-), la multiplication (*), la division (/) et le modulo (%), ainsi que les opérateurs bit à bit tels que ET bit à bit (&), OU (|), XOR (^), décalage à gauche (<<) et décalage à droite (>>).

package main
import "fmt"

func main() {
    x := 10
    y := 3

    // Opérations arithmétiques
    fmt.Println(x + y) // Addition
    fmt.Println(x - y) // Soustraction
    fmt.Println(x * y) // Multiplication
    fmt.Println(x / y) // Division
    fmt.Println(x % y) // Modulo

    // Opérations bit à bit
    fmt.Println(x & y)  // ET bit à bit
    fmt.Println(x | y)  // OU bit à bit
    fmt.Println(x ^ y)  // XOR bit à bit
    fmt.Println(x << 1) // Décalage à gauche de 1
    fmt.Println(x >> 1) // Décalage à droite de 1
}

3 Types de données à virgule flottante

3.1 Aperçu des types de données à virgule flottante

En langage Go, les types à virgule flottante comprennent float32 et float64, correspondant aux données à virgule flottante sur 32 bits et 64 bits. En général, il est recommandé d'utiliser float64 car il offre une plus grande plage et une précision plus précise.

• float32 comporte environ 23 bits significatifs, offrant environ 7 chiffres décimaux de précision.
• float64 comporte environ 52 bits significatifs, offrant environ 16 chiffres décimaux de précision.

3.2 Utilisation des variables à virgule flottante

Les variables à virgule flottante peuvent être déclarées en fournissant directement des littéraux ou en utilisant le mot-clé var :

package main
import "fmt"

func main() {
    var f1 float32 = 3.14 // Spécifiez explicitement le type float32
    f2 := 3.14            // Inféré automatiquement comme un type float64
    fmt.Println(f1, f2)
}

3.3 Arithmétique à Virgule Flottante et Problèmes associés

L'arithmétique à virgule flottante peut entraîner une perte de précision. Effectuer des opérations avec une très grande précision est un problème courant, notamment lors de la soustraction de deux nombres très proches.

package main
import "fmt"

func main() {
    f1 := .1
    f2 := .2
    f3 := f1 + f2
    fmt.Println(f3) // Le résultat peut ne pas être le .3 attendu en raison de problèmes de précision

    // Correction des problèmes de précision en utilisant un affichage formaté
    fmt.Printf("%.1f\n", f3) // Résultat corrigé à .3
}

4 Type de Données Booléen

4.1 Aperçu du type de données booléen

Le booléen est le type de données le plus simple et ne peut avoir que deux valeurs : true (vrai) et false (faux). Il occupe une position très importante dans les déclarations conditionnelles et les structures de contrôle de boucle.

4.2 Utilisation des variables booléennes

Déclaration et utilisation de variables booléennes :

package main
import "fmt"

func main() {
    var reussite bool = true
    var echec bool = false
    fmt.Println("Opération réussie :", reussite)
    fmt.Println("Opération échouée :", echec)
}

Les valeurs booléennes sont souvent utilisées dans les déclarations conditionnelles :

package main
import "fmt"

func main() {
    a := 10
    b := 20
    fmt.Println("a == b :", a == b) // false
    fmt.Println("a < b :", a < b)   // true
}

5 Type de Données Chaîne de Caractères

5.1 Aperçu des chaînes de caractères

Une chaîne de caractères est une collection de caractères. En langage Go, les chaînes de caractères sont immuables. Chaque chaîne de caractères se compose de deux parties : un pointeur vers le tableau d'octets sous-jacent et une longueur. Les chaînes de caractères peuvent contenir n'importe quelle donnée, y compris des octets.

5.2 Utilisation des variables de type chaîne de caractères

Les variables de type chaîne de caractères sont généralement déclarées en utilisant des guillemets doubles " pour les créer, mais vous pouvez également utiliser des backticks ` pour créer des chaînes de plusieurs lignes :

package main
import "fmt"

func main() {
    var s1 string = "bonjour"
    s2 := "monde"
    s3 := `Ceci est une
    chaîne de
    plusieurs lignes`
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
}

Une fois qu'une chaîne de caractères est créée, son contenu ne peut pas être modifié. L'opération suivante est illégale et entraînera une erreur de compilation :

s := "bonjour"
s[] = 'H` // Erreur de compilation : le contenu de la chaîne est immuable

5.3 Opérations sur les chaînes de caractères

Les chaînes de caractères sont très courantes et importantes en programmation. Le langage Go fournit un ensemble riche de fonctions intégrées pour la manipulation des chaînes de caractères. Voici quelques opérations couramment utilisées.

5.3.1 Concaténation de chaînes de caractères

En langage Go, vous pouvez utiliser l'opérateur plus (+) pour concaténer des chaînes de caractères, ce qui est la méthode la plus directe. De plus, lorsqu'il s'agit de concaténer fréquemment plusieurs chaînes de caractères, il est recommandé d'utiliser strings.Builder pour de meilleures performances.

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Concaténation de chaînes de caractères en utilisant +
    bonjour := "Bonjour, "
    monde := "Monde !"
    resultat := bonjour + monde
    fmt.Println(resultat) // Sortie : Bonjour, Monde !

    // Concaténation de chaînes de caractères en utilisant strings.Builder
    var sb strings.Builder
    sb.WriteString("Bonjour, ")
    sb.WriteString("Monde !")
    fmt.Println(sb.String()) // Sortie : Bonjour, Monde !
}

5.3.2 Fractionnement de chaîne

Le fractionnement de chaîne peut être effectué en utilisant la fonction strings.Split, qui divise la chaîne en une tranche en fonction du délimiteur spécifié.

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Définir une chaîne
    sentence := "Go est un langage de programmation open source"

    // Fractionner la chaîne par espace
    words := strings.Split(sentence, " ")
    for _, word := range words {
        fmt.Printf("%s\n", word)
    }
    // Résultat :
    // Go
    // est
    // un
    // langage
    // de
    // programmation
    // open
    // source
}

5.3.3 Accès à l'index

En Go, une chaîne est une séquence immuable d'octets. Vous pouvez utiliser l'indexation pour accéder à des octets spécifiques dans une chaîne. Cependant, il est important de noter que puisqu'une chaîne peut contenir des caractères multioctets (comme des caractères encodés en UTF-8), l'indexation directe peut ne pas donner le caractère unique attendu.

package main

import "fmt"

func main() {
    s := "Bonjour, 世界"
    for i := range s {
        fmt.Printf("%d: %x\n", i, s[i])
    }
    // Remarque : cela affichera la représentation hexadécimale des octets, pas des caractères
}

Pour parcourir la chaîne par caractère, vous pouvez utiliser la boucle range.

package main

import "fmt"

func main() {
    s := "Bonjour, 世界"
    for index, runeValue := range s {
        fmt.Printf("%d: %U '%c'\n", index, runeValue, runeValue)
    }
    // Sortie : index, encodage Unicode et le caractère lui-même pour chaque caractère
}

5.3.4 Obtenir la longueur

La fonction len peut obtenir la longueur d'une chaîne, c'est-à-dire la longueur de la séquence d'octets sous-jacente. Pour les chaînes UTF-8, si vous avez besoin d'obtenir le nombre de caractères (runes), vous devriez utiliser la fonction utf8.RuneCountInString. Cela peut gérer correctement les caractères multioctets.

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "Bonjour, 世界"
    fmt.Println("Longueur des octets :", len(s)) // Afficher la longueur en octets
    fmt.Println("Longueur des caractères :", utf8.RuneCountInString(s)) // Afficher la longueur des caractères
}

À partir de l'exemple ci-dessus, nous pouvons voir que le langage Go fournit des fonctions de bibliothèque riches pour les opérations de chaînes, ce qui facilite l'accomplissement de diverses tâches de traitement de chaînes. Lors de la programmation, il est important de faire attention à la distinction entre les octets et les caractères, en particulier lors de la manipulation d'ensembles de caractères non-ASCII.