0Pricing
Go Academy · Leçon

Direction des canaux et modèles de pipeline

Canaux en lecture seule, en écriture seule et pipelines

Direction des canaux et modèles de pipeline 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.

Types de canaux directionnels

Go vous permet de restreindre les canaux à l'envoi uniquement ou à la réception uniquement dans les signatures de types. Cela documente l'intention et empêche les utilisations incorrectes :

package main

// send-only: can only send, not receive or close (close is allowed by sender)
func sender(out chan<- int) {
    out <- 42
}

// receive-only: can only receive, not send or close
func receiver(in <-chan int) int {
    return <-in
}

// bidirectional: can do both
func relay(in <-chan int, out chan<- int) {
    out <- <-in
}

Conversion des directions d'un canal

Un canal bidirectionnel peut être converti implicitement en l'un ou l'autre des types directionnels, mais l'inverse n'est pas possible :

package main
import "fmt"

func produce(out chan<- int) { out <- 1; close(out) }
func consume(in <-chan int)  { fmt.Println(<-in) }

func main() {
    ch := make(chan int)   // bidirectional
    go produce(ch)         // auto-converts to chan<- int
    consume(ch)            // auto-converts to <-chan int
    // chan<- int cannot be converted back to <-chan int
}

Chaîne de traitement : étape 1 — Générateur

Une chaîne de traitement enchaîne des goroutines, chaque étape lisant depuis le canal de sortie de l'étape précédente. Le générateur est la première étape :

package main
import "fmt"

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func main() {
    ch := generate(2, 3, 4, 5)
    for v := range ch { fmt.Println(v) }
}

Chaîne de traitement : étape 2 — Transformation

Les étapes intermédiaires reçoivent des valeurs depuis un canal, les transforment, puis les envoient vers un autre :

package main
import "fmt"

func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for v := range in { out <- v * v }
        close(out)
    }()
    return out
}

func main() {
    for v := range square(generate(2, 3, 4, 5)) {
        fmt.Println(v)  // 4, 9, 16, 25
    }
}

Chaîne de traitement : exemple complet en trois étapes

Enchaînement de trois étapes — generate, transformer et filtrer :

package main
import "fmt"

func gen(nums ...int) <-chan int {
    c := make(chan int)
    go func() { for _, n := range nums { c <- n }; close(c) }()
    return c
}

func double(in <-chan int) <-chan int {
    c := make(chan int)
    go func() { for v := range in { c <- v * 2 }; close(c) }()
    return c
}

func evens(in <-chan int) <-chan int {
    c := make(chan int)
    go func() { for v := range in { if v%2 == 0 { c <- v } }; close(c) }()
    return c
}

func main() {
    for v := range evens(double(gen(1,2,3,4,5))) {
        fmt.Println(v)  // 2, 4, 6, 8, 10
    }
}

Annulation d'une chaîne de traitement avec le canal done

Transmettez un canal done pour permettre aux étapes de la chaîne de traitement de se terminer plus tôt lorsqu'elle est annulée :

package main
import "fmt"

func gen(done <-chan struct{}, nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, n := range nums {
            select {
            case out <- n:
            case <-done:  // cancel signal
                return
            }
        }
    }()
    return out
}

func main() {
    done := make(chan struct{})
    ch := gen(done, 1, 2, 3, 4, 5)
    fmt.Println(<-ch)  // 1
    close(done)        // cancel remaining work
    fmt.Println("pipeline cancelled")
}

Répartition : distribution du travail

La répartition distribue le travail d'un canal à plusieurs goroutines pour permettre un traitement parallèle :

package main
import ("fmt"; "sync")

func fanOut(in <-chan int, workers int) []<-chan int {
    outs := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        out := make(chan int)
        outs[i] = out
        go func() {
            for v := range in { out <- v * v }  // each worker processes
            close(out)
        }()
    }
    return outs
}

func main() {
    fmt.Println("fan-out distributes work to multiple goroutines")
    _ = sync.WaitGroup{}
}

Regroupement : fusion de canaux

L’agrégation de plusieurs canaux en un seul :

package main
import ("fmt"; "sync")

func merge(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, c := range cs {
        wg.Add(1)
        c := c
        go func() { defer wg.Done(); for v := range c { out <- v } }()
    }
    go func() { wg.Wait(); close(out) }()
    return out
}

func gen(nums ...int) <-chan int {
    c := make(chan int)
    go func() { for _, n := range nums { c <- n }; close(c) }()
    return c
}

func main() {
    for v := range merge(gen(1,2), gen(3,4), gen(5,6)) {
        fmt.Println(v)
    }
}

Bonnes pratiques des chaînes de traitement

Principes de conception d’une chaîne de traitement :

  • Chaque étape : une routine Go lit depuis <-chan, écrit vers chan<- et ferme la sortie une fois terminée
  • Seul le producteur ferme le canal — jamais le récepteur
  • Transmettez un canal done (ou un contexte) pour gérer l’annulation
  • Utilisez des types de canaux directionnels dans toutes les signatures de fonctions
  • Videz les canaux lors de l’annulation pour éviter les fuites de routines Go

Chaîne de traitement en pratique : traitement de fichiers CSV

Les chaînes de traitement sont particulièrement efficaces pour traiter les données : lire les lignes, les analyser, les filtrer et les transformer :

package main
import ("fmt"; "strings")

func splitLines(data string) <-chan string {
    out := make(chan string)
    go func() {
        for _, line := range strings.Split(data, "\n") {
            if line != "" { out <- line }
        }
        close(out)
    }()
    return out
}

func main() {
    csv := "alice,30\nbob,25\ncarol,35"
    for line := range splitLines(csv) {
        parts := strings.Split(line, ",")
        fmt.Printf("name=%s age=%s\n", parts[0], parts[1])
    }
}

Vérification rapide

Quel est le rôle des types de canaux directionnels dans les signatures de fonctions ?

Récapitulatif : direction des canaux et chaînes de traitement

Résumé :

  • chan<- T permet uniquement l’envoi, <-chan T uniquement la réception — intention documentée et sécurité vérifiée à la compilation
  • Chaînes de traitement : enchaînez des routines Go, chacune lisant depuis un canal et écrivant vers un autre
  • Répartition : un canal d’entrée → plusieurs routines Go
  • Agrégation : plusieurs canaux → un canal fusionné
  • Fermez toujours les canaux depuis l’émetteur ; utilisez un canal d’achèvement pour l’annulation

Questions Fréquemment Posées

La leçon « Direction des canaux et modèles de pipeline » est-elle gratuite ?

Oui — le texte complet de « Direction des canaux et modèles de pipeline » 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 « Direction des canaux et modèles de pipeline » ?

Canaux en lecture seule, en écriture seule et pipelines 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 « Direction des canaux et modèles de pipeline » ?

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

  1. Lancer des goroutines
  2. Canaux non tamponnés
  3. Canaux tamponnés
  4. Direction des canaux et modèles de pipeline
← Retour à Go Academy