What is a nil channel in Go, and what happens if you try to read or write data to it?

Nil channel is a channel that is declared but not initialized with make.

What happens when working with a nil channel:

• Reading from a nil channel (<-ch): The read operation without blocking will always block the goroutine performing the read. The program will not crash, but the goroutine will remain blocked forever unless the channel is closed (which is impossible for a nil channel) or cancellation occurs via context.
• Writing to a nil channel (ch <- value): The write operation without blocking will also block the goroutine performing the write. Similarly to reading, the program will not crash, but the goroutine will remain blocked.
• Closing a nil channel (close(ch)): Attempting to close a nil channel will cause a panic at runtime.

Example:

package main

import "fmt"
import "time"

func main() {  
	var ch chan int // Nil channel

	// Attempt to read (will block)
	go func() {
		fmt.Println("Attempting to read...")
		<-ch
		fmt.Println("Read (will never happen)")
	}()

	// Attempt to write (will block)
	go func() {
		fmt.Println("Attempting to write...")
		ch <- 1
		fmt.Println("Written (will never happen)")
	}()

	// Attempt to close (will cause panic)
	// close(ch) // Uncomment to demonstrate panic

	time.Sleep(time.Second) // Give goroutines time to start

	fmt.Println("Program ends. Read and write are blocked.")
}

Using nil channels can be useful in select statements for dynamically disabling a channel branch if the channel is not ready or no longer needed.

package main

import "fmt"
import "time"

func main() {
	var ch1 chan int // Initially nil

	ch2 := make(chan string)

	go func() {
		time.Sleep(time.Millisecond * 100)
		// Simulate channel activation
		ch1 = make(chan int)
		go func() {
			time.Sleep(time.Millisecond * 50)
			ch1 <- 10
		}()
	}()

	go func() {
		time.Sleep(time.Millisecond * 200)
		ch2 <- "Hello"
	}()

	// Select with nil channel
	select {
	case val1, ok := <-ch1: // This branch will be blocked until ch1 becomes non-nil and ready to read
		if ok {
			fmt.Printf("Received from ch1: %d\n", val1)
		} else {
			fmt.Println("ch1 closed") // Cannot be closed while nil
		}
	case val2 := <-ch2:
		fmt.Printf("Received from ch2: %s\n", val2)
	case <-time.After(time.Second):
		fmt.Println("Timeout")
	}

	time.Sleep(time.Second)
}

In this example, the <-ch1 branch in select will be ignored until ch1 is initialized. After its initialization, this branch becomes active.