// 2 func merge(chans ...chan int) <-chan int { panic("not implemented") } func main() { a,b,c := make(chan int), make(chan int), make(chan int) out := merge(a,b,c) go func(){ for v := range out { println(v) } }() a <- 1 a <- 2 a <- 3 b <- 4 c <- 5 close(c) a <- 6 } შეასრულეთ merge ფუნქცია, რომელიც იღებს რამდენიმე მთელ რიცხვს არხებს და აბრუნებს ერთ არხს, რომელიც აერთიანებს ყველა შესვლის არხის მნიშვნელობებს. გაერთიანებული არხი უნდა დაიხუროს, როდესაც ყველა შესვლის არხი დაიხურება.

merge ფუნქცია უნდა მიიღოს რამდენიმე chan int არხი და დაბრუნდეს ერთი არხი, რომელშიც ყველა შესვლის არხის მნიშვნელობა გადაეცემა. როდესაც ყველა შესვლის არხი დახურულია, ასევე უნდა დაიხუროს გამოსვლის არხი.

საშუალოდ, ეს მიდგომა ეფუძნება sync.WaitGroup-ის გამოყენებას, რათა თვალყური ადევნოს ყველა არხის დახურვას და დაიწყოს goroutine-ები თითოეული არხიდან წასაკითხად.

მოჩვენებითი მაგალითი:

func merge(chans ...chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)

    // ფუნქცია მნიშვნელობების კოპირებისთვის ერთ არხიდან მეორეში
    output := func(c chan int) {
        defer wg.Done()
        for v := range c {
            out <- v
        }
    }

    wg.Add(len(chans))
    for _, c := range chans {
        go output(c)
    }

    // დახურვა out-ის ყველა goroutine-ის დასრულების შემდეგ
    go func() {
        wg.Wait()
        close(out)
    }()

    return out
}

ეს მიდგომა უზრუნველყოფს, რომ ყველა შესვლის არხის მნიშვნელობა მიაღწევს გამოსვლის არხს, და რომ გამოსვლის არხი დაიხურება ყველა შესვლის არხის დახურვის შემდეგ.