Assertions de type et switch de type
Assertions de type sûres et modèles de switch
Assertions de type et switch de type est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Assertions de type
Une assertion de type extrait la valeur concrète d'une interface. Sa syntaxe est x.(T) :
package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string) // panics if wrong type
fmt.Println(s, len(s)) // hello 5
}Assertion sûre à deux valeurs
Utilisez la forme virgule-ok pour éviter les paniques en cas de type incorrect :
package main
import "fmt"
func main() {
var i interface{} = 42
s, ok := i.(string)
fmt.Println(s, ok) // "" false
n, ok := i.(int)
fmt.Println(n, ok) // 42 true
}Sélection de type
Une sélection de type compare le type dynamique d'une valeur d'interface à plusieurs types :
package main
import "fmt"
func describe(i interface{}) string {
switch v := i.(type) {
case int: return fmt.Sprintf("int: %d", v)
case string: return fmt.Sprintf("string: %q", v)
case bool: return fmt.Sprintf("bool: %v", v)
default: return fmt.Sprintf("unknown: %T", v)
}
}
func main() {
fmt.Println(describe(42))
fmt.Println(describe("hi"))
fmt.Println(describe(3.14))
}Sélection de type sur error
Les sélections de type sont particulièrement utiles pour catégoriser les erreurs :
package main
import ("errors"; "fmt")
type NotFoundError struct{ Name string }
func (e *NotFoundError) Error() string { return e.Name + " not found" }
type PermError struct{}
func (e *PermError) Error() string { return "permission denied" }
func handle(err error) {
switch e := err.(type) {
case *NotFoundError: fmt.Println("missing:", e.Name)
case *PermError: fmt.Println("perm error")
default: fmt.Println("other:", e)
}
}
func main() {
handle(&NotFoundError{"user"})
handle(errors.New("generic"))
}Assertion vers une interface
Vous pouvez effectuer une assertion vers un autre type d'interface, et pas uniquement vers des types concrets. C'est utile pour vérifier si un objet prend en charge un comportement facultatif :
package main
import "fmt"
type Flusher interface{ Flush() }
type Writer interface{ Write(string) }
type BufferedWriter struct{ buf string }
func (b *BufferedWriter) Write(s string) { b.buf += s }
func (b *BufferedWriter) Flush() { fmt.Println(b.buf); b.buf = "" }
func maybeFlush(w Writer) {
if f, ok := w.(Flusher); ok { f.Flush() }
}
func main() {
bw := &BufferedWriter{}
bw.Write("hello")
maybeFlush(bw)
}Assertion sur une interface nil
Effectuer une assertion sur une interface nil provoque une panique. Vérifiez toujours que l'interface n'est pas nulle avant d'effectuer l'assertion :
package main
import "fmt"
func safePrint(i interface{}) {
if i == nil {
fmt.Println("nil")
return
}
fmt.Printf("%T: %v\n", i, i)
}
func main() {
safePrint(nil)
safePrint(42)
}Alternative avec reflect.TypeOf
Pour afficher le type sans effectuer d'assertion, utilisez fmt.Sprintf("%T", v) ou reflect.TypeOf(v) :
package main
import ("fmt"; "reflect")
func main() {
v := []int{1, 2, 3}
fmt.Printf("%T\n", v) // []int
fmt.Println(reflect.TypeOf(v)) // []int
}Assertion de type ou conversion
Assertion de type : extraire le type concret d'une interface. Conversion de type : transformer un type concret en un autre type compatible. Il s'agit de deux opérations différentes :
package main
import "fmt"
func main() {
var i interface{} = int32(5)
n := i.(int32) // assertion — OK
big := int64(n) // conversion — OK
fmt.Println(n, big)
}Syntaxe comma-ok dans select
La syntaxe comma-ok fonctionne également lors de la réception sur un canal pour détecter qu'il est fermé. Cette même forme concise est utilisée de manière cohérente en Go.
Quand utiliser les commutateurs de types
Cas d'utilisation courants :
- Désérialisation JSON avec des champs
interface{} - Catégorisation des erreurs
- Distribution des messages d'un protocole
- Vérification facultative d'interfaces (Flusher, Closer, etc.)
Vérification rapide
Quel est le résultat d'une assertion de type non sécurisée qui échoue ?
Récapitulatif
Points essentiels :
x.(T)déclenche une panique si le type est incorrect ;x, ok := x.(T)est sûr- Les commutateurs de types gèrent proprement plusieurs types
- Effectuez une assertion vers des interfaces pour vérifier des capacités facultatives
- Ne faites jamais d'assertion sur une interface nil
Exercice
Écrivez une fonction sum(values []any) float64 qui utilise un commutateur de types pour gérer les valeurs int, float64 et string (en analysant la chaîne), et ignore les autres.
Questions Fréquemment Posées
La leçon « Assertions de type et switch de type » est-elle gratuite ?
Oui — le texte complet de « Assertions de type et switch de type » 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 « Assertions de type et switch de type » ?
Assertions de type sûres et modèles de switch 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 3 sur 4.
Combien de temps prend la leçon « Assertions de type et switch de type » ?
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
- Définir et implémenter des interfaces
- Interfaces essentielles de la bibliothèque standard
- Assertions de type et switch de type
- Composition d’interfaces et bonnes pratiques