Go Academy · Leçon

Analyser les entrées

Lire des entrées formatées

Analyser les entrées 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.

Lire l'entrée avec fmt

Le paquet fmt peut lire des valeurs, et pas seulement les afficher. Les fonctions de lecture analysent le texte pour le convertir en variables typées.

Elles sont l'équivalent inverse des fonctions d'affichage.

package main

import "fmt"

func main() {
    var n int
    fmt.Sscan("42", &n)
    fmt.Println(n + 1)
}

Les pointeurs sont obligatoires

Les fonctions de lecture doivent stocker un résultat ; vous devez donc fournir l'adresse de chaque variable à l'aide de &.

Oublier & est l'erreur la plus courante lors de la lecture.

package main

import "fmt"

func main() {
    var a, b int
    fmt.Sscan("3 4", &a, &b)
    fmt.Println(a + b)
}

Sscan sépare selon les espaces

fmt.Sscan lit dans une chaîne des valeurs séparées par des espaces et les stocke dans plusieurs variables, en déduisant le type de chacune à partir de son pointeur.

package main

import "fmt"

func main() {
    var name string
    var age int
    fmt.Sscan("Ada 36", &name, &age)
    fmt.Println(name, age)
}

Sscanf utilise un format

fmt.Sscanf analyse le texte selon une chaîne de format, exactement comme Printf à l'envers. Les caractères littéraux du format doivent correspondre à ceux de l'entrée.

package main

import "fmt"

func main() {
    var h, m int
    fmt.Sscanf("09:05", "%d:%d", &h, &m)
    fmt.Println(h, m)
}

Vérifier le nombre d'éléments lus

Les fonctions de lecture renvoient le nombre d'éléments analysés avec succès ainsi qu'une erreur. Vérifiez ce nombre pour savoir si l'analyse a entièrement réussi.

package main

import "fmt"

func main() {
    var a, b int
    count, _ := fmt.Sscan("7", &a, &b)
    fmt.Println("parsed:", count)
}

Gérer les erreurs d'analyse

Si l'entrée ne correspond pas au type attendu, une erreur est renvoyée. Examinez-la toujours avec une véritable entrée.

package main

import "fmt"

func main() {
    var n int
    _, err := fmt.Sscan("notanumber", &n)
    if err != nil {
        fmt.Println("error:", err)
    }
}

Analyser des types mixtes

Vous pouvez lire plusieurs types différents en un seul appel. Le type de chaque pointeur détermine la manière dont son élément est analysé.

package main

import "fmt"

func main() {
    var word string
    var price float64
    var ok bool
    fmt.Sscan("apple 1.50 true", &word, &price, &ok)
    fmt.Println(word, price, ok)
}

Sscanf avec du texte littéral

Sscanf est idéal pour les formats fixes, comme les coordonnées ou les paires clé-valeur, où la ponctuation sépare les nombres.

package main

import "fmt"

func main() {
    var x, y int
    fmt.Sscanf("(3,8)", "(%d,%d)", &x, &y)
    fmt.Println(x, y)
}

Lire des nombres à virgule flottante

Utilisez %f dans Sscanf ou un *float64 dans Sscan pour lire des nombres décimaux.

package main

import "fmt"

func main() {
    var temp float64
    fmt.Sscanf("21.5C", "%fC", &temp)
    fmt.Println(temp)
}

Lecture avec Scan ou depuis l'entrée standard

fmt.Scan et fmt.Scanf lisent depuis l'entrée standard de la même manière que Sscan lit depuis une chaîne. Les règles d'analyse sont identiques ; seule la source change.

package main

import "fmt"

func main() {
    line := "100 200"
    var a, b int
    fmt.Sscan(line, &a, &b)
    fmt.Println(a * b)
}

Un petit analyseur

Combinez la lecture et un calcul pour analyser un enregistrement et produire un résultat.

package main

import "fmt"

func main() {
    var name string
    var qty int
    var unit float64
    fmt.Sscanf("pen 3 1.25", "%s %d %f", &name, &qty, &unit)
    fmt.Printf("%s total: $%.2f\n", name, float64(qty)*unit)
}

Vérification rapide

Que devez-vous transmettre à une fonction de lecture pour stocker le résultat ?

Récapitulatif : lire l'entrée

Vous avez appris à lire une entrée formatée :

Sscan sépare selon les espaces blancs ; Sscanf suit une chaîne de format.
Passez des pointeurs avec & pour chaque cible.
Vérifiez le nombre et l'erreur renvoyés pour détecter une entrée incorrecte.

package main

import "fmt"

func main() {
    var d, mo, y int
    fmt.Sscanf("30/05/2026", "%d/%d/%d", &d, &mo, &y)
    fmt.Println(y, mo, d)
}

Questions Fréquemment Posées

La leçon « Analyser les entrées » est-elle gratuite ?

Oui — le texte complet de « Analyser les entrées » 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 « Analyser les entrées » ?

Lire des entrées formatées 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 « Analyser les entrées » ?

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