When using range to traverse channels in Go, the channel must be closed by the sender to avoid panic. The specific steps are as follows: 1. Create a channel and start a goroutine to send data to it; 2. Use the close function to close the channel after the sending is completed; 3. Use the for range loop to receive data, and the loop will automatically end after the channel is closed. Be careful not to close the channel multiple times or send data to the closed channel, which can cause runtime errors. If there are multiple senders, the shutdown operation should be coordinated through sync.WaitGroup or additional signal channels to ensure the safety and stability of the program.

In Go, the range keyword is commonly used to iterate over channels when you want to receive values ??until the channel is closed. This approach is clean and avoids manually managing loop conditions for receiving.

Here's how it works in practice.

How to Use range with a Channel

When you use range on a channel in a for loop, it will keep pulling values ??from the channel until it's closed. You don't need to check for a second return value like you might with maps or slices — the loop simply stops once the channel is closed.

 ch := make(chan int)
go func() {
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch)
}()

for val := range ch {
    fmt.Println(val)
}

This will print:

 1
2
3

The loop ends after the channel is closed. Note that you must close the channel ; otherwise, the loop will hang forever waiting for more input.

When to Close the Channel

Closing a channel signals that no more values ??will be sent. It's important to ensure only the sending side closes the channel — not the receiver. Closing from the receiver side can lead to panic if another sender is still active.

A common pattern:

• One or more goroutines send data.
• Once all sends are done, the sender closes the channel.
• The receiver uses range to process all incoming data safely.

For example:

 ch := make(chan string)
go func() {
    names := []string{"Alice", "Bob", "Charlie"}
    for _, name := range names {
        ch <- name
    }
    close(ch)
}()

for name := range ch {
    fmt.Println("Received:", name)
}

This ensures the loop exits cleanly after all names are printed.

Common Pitfalls to Avoid

Here are a few gotchas when using range over channels:

• Don't close a channel multiple times. Doing so will cause a runtime panic.
• Don't send on a closed channel. This also causes a panic.
• If you're unsure whether a channel should be closed, consider using a sync.WaitGroup instead to coordinate completion without closing the channel.

If you're working with multiple senders, coordinating closure gets trickier. In those cases, you may want to use a separate signal (like a done channel) or reference counting via sync.WaitGroup .

Summary

Using range on a channel is a neighbor way to consume all values ??sent on it until it's closed. Just remember to close the channel from the sender side, avoid common mistakes like double-closing or sending on a closed channel, and you'll be good to go.

That's basically how it works — straightforward but easy to misuse if you're not careful.

The above is the detailed content of How do I use the range keyword to iterate over a channel in Go?. For more information, please follow other related articles on the PHP Chinese website!