Go Academy · Lección

Etapas de pipeline

Encadene etapas mediante canales

Etapas de pipeline es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 3 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.

Qué es un pipeline

Un pipeline es una serie de etapas conectadas mediante canales. Cada etapa recibe valores, realiza un trabajo y envía los resultados a la siguiente etapa. Los datos fluyen como en una cadena de montaje.

Cada etapa es una goroutine
Las etapas se comunican únicamente mediante canales
Es componible y fácil de entender

Convención para la firma de las etapas

Por convención, cada etapa recibe uno o más canales de entrada de solo lectura y devuelve un canal de salida de solo lectura. Esto permite encadenar las etapas.

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

La etapa de origen

La primera etapa produce datos. A menudo recibe un slice o argumentos variádicos y los transmite a un canal.

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, v := range vals {
            out <- v
        }
    }()
    return out
}

Una etapa de transformación

Esta etapa multiplica cada valor por diez. Lee de in y escribe el valor transformado en out.

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

Una etapa de filtrado

Un filtro solo reenvía los valores que cumplen una condición. Aquí conservamos los números pares y descartamos el resto.

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

Encadenar etapas

Componga las etapas pasando una salida como entrada de la siguiente. La cadena se lee casi como una oración.

pipe := tenfold(evens(numbers(1, 2, 3, 4)))
for v := range pipe {
    fmt.Println(v)
}

defer close(out)

Usar defer close(out) garantiza que el canal de salida se cierre cuando la goroutine de la etapa termine, incluso si más adelante añade retornos anticipados. Esto propaga la señal de fin de flujo a las etapas posteriores.

Un pipeline completo

Primero el origen, después el filtro y, por último, la transformación. Ejecútelo para ver únicamente el décuplo de las entradas pares.

package main

import "fmt"

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, v := range vals { out <- v } }()
    return out
}

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

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

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

Transmisión, no procesamiento por lotes

Los valores recorren el pipeline uno a uno a medida que se producen. La etapa de transformación puede empezar a trabajar en el primer elemento antes de que el origen haya emitido el último. Esto mantiene baja la memoria y reduce la latencia.

Los pipelines son perezosos

Una etapa no realiza ningún trabajo hasta que algo lee de su salida. Si el consumidor deja de iterar, las etapas ascendentes se bloquean al enviar. Esta contrapresión natural evita cálculos innecesarios.

Añadir concurrencia

Para acelerar una etapa lenta, haga fan-out en varias instancias que lean de la misma entrada y combine sus salidas. La firma de la etapa no cambia; solo cambia la conexión entre ellas.

Comprobación rápida

Compruebe cuánto sabe sobre pipelines.

Recapitulación

Ha aprendido sobre las etapas de un pipeline:

Cada etapa recibe una entrada de solo lectura y devuelve una salida de solo lectura
defer close(out) propaga el fin de flujo
Encadene las etapas anidando llamadas
Los pipelines transmiten datos de forma perezosa y aplican contrapresión

Preguntas frecuentes

¿La lección «Etapas de pipeline» es gratis?

Sí — el texto completo de «Etapas de pipeline» 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 «Etapas de pipeline»?

Encadene etapas mediante canales 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 3 de 4.

¿Cuánto tiempo toma la lección «Etapas de pipeline»?

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

← Volver a Go Academy