Go Academy · Ders

Kanal Yönü ve Pipeline Örüntüleri

Q: “Kanal Yönü ve Pipeline Örüntüleri” dersi ücretsiz mi?

Evet — “Kanal Yönü ve Pipeline Örüntüleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Go Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Go Academy kursu toplamda 4 dersten oluşur.

Q: “Kanal Yönü ve Pipeline Örüntüleri” dersinde ne öğreneceğim?

Salt okunur, salt yazılır kanallar ve pipeline'lar Go Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Q: Go Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Go Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

Q: “Kanal Yönü ve Pipeline Örüntüleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu Go Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Go Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Salt okunur, salt yazılır kanallar ve pipeline'lar

4. ders / 412 adım

Kanal Yönü ve Pipeline Örüntüleri, CoddyKit'te ücretsiz bir Go Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Go Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Go Academy kursu toplamda 4 dersten oluşur.

Yönlü Kanal Türleri

Go, tür imzalarında kanalları yalnızca gönderme veya yalnızca alma yönüyle sınırlandırmanıza olanak tanır. Bu, amacı belgelendirir ve yanlış kullanımı önler:

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
}

Kanal Yönlerini Dönüştürme

Çift yönlü bir kanal örtük olarak iki yönlü türden herhangi birine dönüştürülebilir; ancak bunun tersi mümkün değildir:

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
}

İşlem Hattı: 1. Aşama — Üretici

Bir işlem hattı, her aşamanın önceki aşamanın çıkış kanalından okuduğu goroutine'leri birbirine bağlar. Üretici ilk aşamadır:

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) }
}

İşlem Hattı: 2. Aşama — Dönüştürme

Orta aşamalar bir kanaldan alır, dönüştürür ve başka bir kanala gönderir:

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
    }
}

İşlem Hattı: Üç Aşamalı Tam Örnek

Üç aşamayı birbirine bağlama — üretme, dönüştürme, filtreleme:

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
    }
}

tamamlanma Kanalıyla İşlem Hattını İptal Etme

İptal edildiğinde işlem hattı aşamalarının erkenden sona ermesine olanak tanımak için bir tamamlanma kanalı aktarın:

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")
}

Dağıtım: İşleri Paylaştırma

Dağıtım, işleri paralel olarak işlemek üzere tek bir kanaldan birden çok goroutine'e paylaştırır:

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{}
}

Birleştirme: Kanalları Birleştirme

Birleştirme, birden fazla kanalı tek kanalda birleştirir:

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)
    }
}

İşlem Hattı İçin En İyi Uygulamalar

İşlem hattı tasarım ilkeleri:

Her aşamada: <-chan kanalından okuyan, chan<- kanalına yazan eşzamanlı bir rutin kullanın; iş tamamlandığında çıkış kanalını kapatın
Kanalı yalnızca üretici kapatır; tüketici asla kapatmaz
İptal için bir done kanalı (veya bağlam) iletin
Tüm işlev imzalarında yönlü kanal türlerini kullanın
Eşzamanlı rutin sızıntılarını önlemek için iptal sırasında kanalları boşaltın

Gerçek Dünya İşlem Hattı: CSV İşleme

İşlem hatları veri işleme konusunda öne çıkar: read ile satırları okuyun, ayrıştırın, filtreleyin ve dönüştürün:

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])
    }
}

Hızlı Kontrol

İşlev imzalarında yönlü kanal türlerini kullanmanın amacı nedir?

İnteraktif derste cevapla

Özet: Kanal Yönü ve İşlem Hatları

Özet:

chan<- T yalnızca gönderme, <-chan T yalnızca alma içindir; amacı belgeler ve derleme zamanı güvenliği sağlar
İşlem hatları: Her eşzamanlı rutinin bir kanaldan okuyup başka bir kanala yazdığı zincirlerdir
Dağıtma: Bir giriş kanalı → birden fazla eşzamanlı rutin
Birleştirme: Birden fazla kanal → tek kanalda birleştirme
Kanalları her zaman gönderici tarafından kapatın; iptal için tamamlanma kanalını kullanın

Başlamak ücretsiz

Yapay zeka eğitmeniyle Go öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 51
Dersler: 203

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular