Go Academy · Leçon

L’instruction select

Multiplexer des canaux avec select

Leçon 1 sur 413 étapes

L’instruction select est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu’est-ce que la sélection ?

L’instruction select permet à une routine Go d’attendre simultanément plusieurs opérations sur des canaux. Elle choisit le premier cas prêt à s’exécuter, de façon comparable à un switch, mais pour les canaux.

Syntaxe de base

Chaque case d’une select correspond à un envoi ou à une réception sur un canal :

select {
case msg := <-ch1:
    fmt.Println("ch1:", msg)
case msg := <-ch2:
    fmt.Println("ch2:", msg)
}

Fonctionnement non bloquant avec le cas par défaut

Ajouter un cas default rend la sélection non bloquante : si aucun canal n’est prêt, l’exécution passe immédiatement au cas par défaut.

select {
case v := <-ch:
    fmt.Println(v)
default:
    fmt.Println("no value ready")
}

Sélection aléatoire

Lorsque plusieurs cas sont prêts en même temps, Go en choisit un au hasard : chaque cas prêt a la même probabilité d’être sélectionné. Cela évite la famine.

Envoi dans une sélection

Les cas peuvent également être des envois sur un canal. Un cas d’envoi est prêt lorsque le canal dispose d’espace dans son tampon (ou qu’un récepteur attend).

select {
case ch1 <- val1:
    fmt.Println("sent to ch1")
case ch2 <- val2:
    fmt.Println("sent to ch2")
}

Une sélection vide se bloque indéfiniment

Une select{} sans aucun cas bloque indéfiniment la routine Go actuelle. Il s’agit d’une construction courante pour maintenir la routine Go principale active pendant l’exécution d’autres routines Go.

func main() {
    go serve()
    select {} // block forever
}

Boucle avec sélection

Placez une select dans une boucle for pour multiplexer continuellement les canaux. Ajoutez un canal d’achèvement pour sortir proprement de la boucle.

for {
    select {
    case v := <-data:
        process(v)
    case <-done:
        return
    }
}

Canaux nuls

Un canal nul bloque indéfiniment dans un cas de sélection, ce qui désactive de fait ce cas. Vous pouvez vous en servir pour activer ou désactiver dynamiquement des cas lors de l’exécution.

var ch chan int // nil
select {
case v := <-ch: // never selected
    _ = v
case v := <-other:
    fmt.Println(v)
}

Sélection avec des canaux fermés

Une réception depuis un canal fermé réussit toujours immédiatement et renvoie la valeur nulle. Utilisez la forme à deux valeurs pour détecter la fermeture.

select {
case v, ok := <-ch:
    if !ok { return } // channel closed
    use(v)
}

Schémas de priorité

L’instruction de sélection de Go ne prend pas nativement en charge les priorités. Pour donner la priorité à un canal, imbriquez des instructions de sélection ou utilisez une boucle qui vérifie d’abord le canal hautement prioritaire avec un cas par défaut.

for {
    select {
    case v := <-highPriority:
        handle(v)
    default:
        select {
        case v := <-lowPriority:
            handle(v)
        }
    }
}

Récapitulatif intermédiaire

La sélection attend plusieurs canaux, choisit aléatoirement un cas prêt, prend en charge le cas par défaut pour un fonctionnement non bloquant et les canaux nuls désactivent les cas correspondants. Schéma courant : boucle + sélection + canal d’achèvement.

Vérification rapide

Que se passe-t-il lorsque plusieurs cas d’une sélection sont prêts en même temps ?

Réponds-y dans la leçon interactive

Récapitulatif : l’instruction de sélection

Points essentiels :

La sélection se bloque jusqu’à ce qu’un cas de canal soit prêt
Plusieurs cas prêts → sélection aléatoire
Le cas par défaut rend la sélection non bloquante
Un canal nul désactive son cas
La combinaison boucle + sélection + canal d’achèvement constitue la boucle de multiplexage standard

Gratuit pour commencer

Apprends Go avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 51
Leçons: 203

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « L’instruction select » est-elle gratuite ?

Oui — le texte complet de « L’instruction select » 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 « L’instruction select » ?

Multiplexer des canaux avec select 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 1 sur 4.

Combien de temps prend la leçon « L’instruction select » ?

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