Go Academy · Pelajaran

Peringkat Pipeline

Rangkaikan peringkat saluran

Pelajaran 3 daripada 413 langkah

Peringkat Pipeline ialah pelajaran Go Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Go Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Go Academy merangkumi sejumlah 4 pelajaran.

Apakah Saluran Paip

Saluran paip ialah siri stage yang disambungkan oleh saluran. Setiap stage menerima nilai, melakukan kerja dan menghantar hasil ke hiliran. Data mengalir seperti di barisan pemasangan.

Setiap stage ialah gorutin
Stage berkomunikasi hanya melalui saluran
Boleh digabungkan dan mudah difahami

Konvensyen Tandatangan Stage

Mengikut konvensyen, setiap stage menerima satu atau lebih saluran masukan yang hanya boleh menerima dan mengembalikan saluran keluaran yang hanya boleh menerima. Hal ini membolehkan stage dirangkaikan.

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

Stage Sumber

Stage pertama menghasilkan data. Lazimnya, stage ini menerima hirisan atau argumen variadik dan menyalurkannya ke dalam saluran.

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

Stage Transformasi

Stage ini mendarab setiap nilai dengan sepuluh. Ia membaca daripada in dan menulis nilai yang diubah kepada 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
}

Stage Penapis

Penapis hanya meneruskan nilai yang memenuhi sesuatu syarat. Di sini, kita mengekalkan nombor genap dan membuang yang lain.

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
}

Merangkaikan Stage

Gabungkan stage dengan menghantar satu keluaran sebagai masukan seterusnya. Rangkaian ini hampir kelihatan seperti sebuah ayat.

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

defer close(out)

Menggunakan defer close(out) menjamin saluran keluaran ditutup apabila gorutin stage kembali, walaupun anda menambah pemulangan awal kemudian. Hal ini menyebarkan isyarat tamat aliran ke hiliran.

Saluran Paip Lengkap

Sumber kemudian penapis kemudian transformasi. Jalankannya untuk melihat hanya tenfold bagi masukan genap.

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

Penstriman, Bukan Pengumpulan Kelompok

Nilai mengalir melalui saluran paip satu demi satu apabila dihasilkan. Stage transformasi boleh mula memproses item pertama sebelum sumber mengeluarkan item terakhir. Hal ini mengekalkan penggunaan memori pada tahap rendah dan kependaman pada tahap kecil.

Saluran Paip Bersifat Malas

Stage tidak melakukan kerja sehingga sesuatu membaca daripada keluarannya. Jika pengguna berhenti melakukan lelaran, stage hulu akan tersekat ketika menghantar. Tekanan balik semula jadi ini menghalang pengiraan yang membazir.

Menambah Keserentakan

Untuk mempercepatkan stage yang perlahan, agihkannya keluar kepada beberapa tika yang membaca masukan yang sama dan gabungkan keluaran mereka. Tandatangan stage kekal sama; hanya penyambungannya yang berubah.

Semakan Pantas

Uji pengetahuan anda tentang saluran paip.

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari stage saluran paip:

Setiap stage: masukan yang hanya boleh menerima, mengembalikan keluaran yang hanya boleh menerima
defer close(out) menyebarkan tamat aliran
Rangkaikan stage dengan menyarang panggilan
Saluran paip menstrim secara malas dengan tekanan balik

Percuma untuk bermula

Pelajari Go dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 51
Pelajaran: 203

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Peringkat Pipeline” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Go Academy, termasuk “Peringkat Pipeline”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Go Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Peringkat Pipeline”?

Rangkaikan peringkat saluran Anda berlatih Go Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Go Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Go Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Peringkat Pipeline” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy