Go Academy · Leçon

Conversions de types en Go

Conversions explicites, alias de types et types définis

Conversions de types en Go est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Pourquoi des conversions explicites ?

Go n'effectue jamais de conversion implicite entre les types. Cela évite les bogues subtils, par exemple lorsqu'un petit entier déborde silencieusement dans un type plus grand ou qu'un flottant perd en précision.

Les conversions doivent être écrites explicitement : T(value)
Le compilateur détecte les types incompatibles lors de la compilation
Le code Go devient ainsi prévisible et sûr

Conversions numériques

Convertissez des types numériques en utilisant le type cible comme appel de fonction :

package main

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    _ = u
}

Risque de troncature

La conversion d'un type plus grand vers un type plus petit tronque la valeur. Aucune erreur n'est signalée — vous devez donc être prudent :

package main

func main() {
    big := int64(300)
    small := int8(big) // 300 % 256 = 44 — silent truncation!
    _ = small
}

Conversions entre string et []byte

La conversion entre string et []byte copie les données :

package main

func main() {
    s := "hello"
    b := []byte(s)   // string to byte slice
    b[0] = 'H'
    s2 := string(b)  // byte slice to string
    _ = s2
}

string et []rune

Pour manipuler des caractères tout en préservant Unicode, convertissez en []rune :

package main

func main() {
    s := "Merhaba"
    runes := []rune(s)
    _ = len(runes) // character count, not byte count
}

Paquet strconv

Pour convertir des chaînes en nombres et inversement, utilisez le paquet strconv :

import "strconv"

func main() {
    n, err := strconv.Atoi("42")   // string -> int
    s := strconv.Itoa(123)          // int -> string
    _ = n; _ = err; _ = s
}

strconv.ParseFloat et FormatFloat

Analysez et formatez les chaînes à virgule flottante en toute sécurité :

import "strconv"

func main() {
    f, err := strconv.ParseFloat("3.14", 64)
    if err != nil { return }
    s := strconv.FormatFloat(f, 'f', 2, 64) // "3.14"
    _ = s
}

Alias de types ou types définis

Go distingue les alias de types des types définis :

type Celsius float64 — nouveau type défini ; nécessite une conversion explicite vers ou depuis float64
type Celsius = float64 — alias ; interchangeable avec float64

Exemple de type défini

Les types définis améliorent la clarté de l’API et empêchent les mélanges accidentels :

type Celsius float64
type Fahrenheit float64

func CtoF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func main() {
    boiling := Celsius(100)
    _ = CtoF(boiling)
}

Conversions d’interfaces

Toute valeur peut être convertie vers un type d’interface auquel elle satisfait. La conversion inverse nécessite une assertion de type :

var i interface{} = "hello"
s, ok := i.(string) // type assertion
if ok {
    _ = s // safe to use
}

Vérification rapide

Quelle fonction convertit une chaîne en entier dans Go ?

Récapitulatif : conversions de types

Points essentiels concernant les conversions de types dans Go :

Go n’effectue jamais de conversion implicite : utilisez la syntaxe T(value)
Les conversions numériques peuvent tronquer les valeurs : soyez explicite quant au risque
[]byte(s) et string(b) copient les données
Utilisez strconv.Atoi / strconv.Itoa pour convertir des chaînes en nombres et inversement
Les types définis nécessitent des conversions explicites contrairement aux alias

Prochain cours : contrôle du flux avec if, for et switch.

Questions Fréquemment Posées

La leçon « Conversions de types en Go » est-elle gratuite ?

Oui — le texte complet de « Conversions de types en Go » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Conversions de types en Go » ?

Conversions explicites, alias de types et types définis Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Conversions de types en Go » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy