Dirección de channels y patrones de pipelines
Channels de solo lectura, de solo escritura y pipelines
Dirección de channels y patrones de pipelines es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
Tipos de canales direccionales
Go permite restringir los canales a solo envío o solo recepción en las firmas de tipos. Esto documenta la intención y evita usos incorrectos:
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
}Convertir la dirección de los canales
Un canal bidireccional se puede convertir implícitamente a cualquiera de los dos tipos direccionales, pero no al revés:
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
}Pipeline: etapa 1 — Generador
Un pipeline encadena goroutines de modo que cada etapa lee del canal de salida de la etapa anterior. El generador es la primera etapa:
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) }
}Pipeline: etapa 2 — Transformación
Las etapas intermedias reciben datos de un canal, los transforman y los envían a otro:
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
}
}Pipeline: ejemplo completo de tres etapas
Encadenamiento de tres etapas: generar, transformar y filtrar:
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
}
}Cancelación de un pipeline con el canal done
Pase un canal done para permitir que las etapas del pipeline terminen antes cuando se cancelen:
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")
}Fan-out: distribuir el trabajo
Fan-out distribuye el trabajo de un canal entre varias goroutines para procesarlo en paralelo:
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{}
}Fan-in: combinar canales
Fan-in combina varios canales en uno:
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)
}
}Buenas prácticas de las canalizaciones
Principios de diseño de canalizaciones:
- Cada etapa: una goroutine lee desde
<-chan, escribe enchan<-y cierra la salida cuando termina - Solo el productor cierra el canal; nunca el consumidor
- Pase un canal
done(o un contexto) para cancelar - Utilice tipos de canal direccionales en todas las firmas de función
- Drene los canales al cancelar para evitar fugas de goroutines
Canalización del mundo real: procesamiento de CSV
Las canalizaciones son ideales para procesar datos: leer líneas, analizar, filtrar y transformar:
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])
}
}Comprobación rápida
¿Cuál es el propósito de los tipos de canal direccionales en las firmas de función?
Repaso: dirección de canales y canalizaciones
Resumen:
chan<- Tsolo para enviar,<-chan Tsolo para recibir: intención documentada y seguridad en tiempo de compilación- Canalizaciones: encadenan goroutines, donde cada una lee de un canal y escribe en otro
- Fan-out: un canal de entrada → varias goroutines
- Fan-in: varios canales → uno combinado
- Cierre siempre los canales desde el emisor; utilice un canal
donepara cancelar
Aprende Go con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 51
- Lecciones
- 203
Preguntas frecuentes
¿La lección «Dirección de channels y patrones de pipelines» es gratis?
Sí — el texto completo de «Dirección de channels y patrones de pipelines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Dirección de channels y patrones de pipelines»?
Channels de solo lectura, de solo escritura y pipelines Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Go Academy?
No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Dirección de channels y patrones de pipelines»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Go Academy?
Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Lanzamiento de goroutines
- Channels sin búfer
- Channels con búfer
- Dirección de channels y patrones de pipelines