Go Send and Receive (<-) 🎯

Welcome to our Go (Golang) tutorial on Send and Receive! In this lesson, we'll learn how to send and receive data in Go, which is essential for creating network applications. Let's dive right in!

Introduction 📝

In Go, communication between processes and network clients is done using channels. Channels are a powerful feature in Go that enable the exchange of data between concurrent goroutines and between goroutines and the main function.

Channels Basics 💡

Channels are typed. A channel of type int can only send or receive int values.
A channel is created using the make function.

ch := make(chan int)

Sending Data to Channels ✅

To send data to a channel, we use the send operator <-. Here's an example:

func main() {
	ch := make(chan int)

	go func() {
		ch <- 42  // sending data to the channel
	}()

	fmt.Println(<-ch)  // receiving data from the channel
}

In this example, we create a goroutine that sends the number 42 to the channel. Then, we receive the data from the channel in the main function and print it out.

Receiving Data from Channels ✅

To receive data from a channel, we also use the send operator <-. Here's an example:

func main() {
	ch := make(chan int)

	go func() {
		ch <- 42  // sending data to the channel
	}()

	result := <-ch  // receiving data from the channel
	fmt.Println(result)
}

Buffered Channels 📝

By default, Go uses unbuffered channels. This means that a goroutine sending data to an unbuffered channel will be blocked until another goroutine is available to receive the data. To avoid blocking, you can create buffered channels using the make function and specifying a buffer size.

ch := make(chan int, 3)

In this example, the channel can store up to 3 values before blocking.

Sending to a Full Buffered Channel 💡

When a buffered channel reaches its maximum capacity, sending data will block the goroutine until there is space available.

func main() {
	ch := make(chan int, 2)

	go func() {
		ch <- 1
		ch <- 2
		ch <- 3  // this will block until space is available in the buffer
	}()

	// other goroutines can continue executing while the channel is blocked
}

Closing Channels 📝

To close a channel and prevent further sends, we use the close function. A closed channel can still be received from, but it will return the zero value of the channel's type once there's no more data.

func main() {
	ch := make(chan int)

	go func() {
		ch <- 42
		close(ch)
	}()

	_, ok := <-ch
	fmt.Println(ok)  // true because the channel has been closed
}

Quiz 🎯

By understanding channels and their usage, you'll be well on your way to building powerful network applications in Go. Stay tuned for more Golang lessons here at CodeYourCraft! 🎉