Sending and receiving values in Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a channel in Go?

A channel is a way to send and receive values between goroutines safely and synchronously.

beginner

How do you send a value to a channel in Go?

Use the syntax channel <- value to send a value into the channel.

beginner

How do you receive a value from a channel in Go?

Use the syntax value := <-channel to receive a value from the channel.

intermediate

What happens if you try to receive from an empty channel?

The receiving goroutine waits (blocks) until a value is sent to the channel.

intermediate

What happens if you try to send to a full buffered channel?

The sending goroutine waits (blocks) until there is space available in the channel buffer.

How do you send the integer 5 to a channel named ch in Go?

A send(ch, 5)

B 5 <- ch

C ch <- 5

D ch.send(5)

The correct syntax to send a value to a channel is channel <- value.

What does the expression value := <-ch do?

A Receives a value from channel ch and stores it in value

B Sends value to channel ch

C Closes the channel ch

D Creates a new channel ch

The syntax value := <-ch receives a value from channel ch.

What happens if you send to an unbuffered channel but no goroutine is ready to receive?

A The send operation fails immediately

B The send operation blocks until a receiver is ready

C The value is lost

D The channel buffers the value automatically

Unbuffered channels block the sender until a receiver is ready to receive.

Which of these is true about buffered channels?

A They never block on send

B They block on send only when the buffer is full

C They block on receive only when the buffer is empty

D Both B and D

Buffered channels block on send if full and block on receive if empty.

How do you declare a channel of integers in Go?

A var ch chan int

B var ch int chan

C chan int ch

D int chan ch

The correct declaration is var ch chan int.

Explain how sending and receiving values on channels works in Go.

Think about how goroutines communicate safely using channels.

Describe what happens when you send to or receive from a channel that is not ready.

Consider what happens if no goroutine is ready to receive or send.

Practice

1. What is the correct way to send a value 5 to a channel named ch in Go?

easy

A. ch <- 5

B. 5 <- ch

C. send(ch, 5)

D. ch = 5

Solution

1. Step 1: Understand channel send syntax

   In Go, to send a value to a channel, you write channel <- value.

2. Step 2: Apply syntax to given variables

   Here, the channel is ch and the value is 5, so the correct send is ch <- 5.

3. Final Answer:

   ch <- 5 -> Option A

4. Quick Check:

   Send syntax = channel <- value [OK]

Hint: Remember: channel <- value sends data [OK]

Common Mistakes:

• Reversing send syntax as value <- channel
• Using assignment operator instead of send
• Calling a non-existent send function

2. Which of the following is the correct syntax to receive a value from a channel ch and store it in variable v?

easy

A. v := ch <-

B. v = ch <-

C. v = ch.receive()

D. v := <- ch

Solution

1. Step 1: Recall channel receive syntax

   To receive a value from a channel, Go uses value := <- channel.

2. Step 2: Match syntax with variables

   Here, v receives from ch, so v := <- ch is correct.

3. Final Answer:

   v := <- ch -> Option D

4. Quick Check:

   Receive syntax = v := <- ch [OK]

Hint: Use := <- channel to receive value [OK]

Common Mistakes:

• Placing <- after channel name
• Using method calls like receive()
• Using assignment = instead of := for declaration

3. What will be the output of the following Go program?

package main
import "fmt"
func main() {
    ch := make(chan int)
    go func() {
        ch <- 10
    }()
    val := <-ch
    fmt.Println(val)
}

medium

A. 0

B. Compilation error

C. 10

D. Deadlock error

Solution

1. Step 1: Understand channel creation and goroutine

   The channel ch is created and a goroutine sends 10 to it.

2. Step 2: Receive value and print

   The main goroutine receives the value from ch and prints it.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   Send and receive work correctly, output = 10 [OK]

Hint: Send in goroutine, receive in main prints sent value [OK]

Common Mistakes:

• Expecting zero value instead of sent value
• Thinking channel blocks forever causing deadlock
• Confusing send and receive syntax

4. Identify the error in this Go code snippet:

package main
func main() {
    ch := make(chan int)
    ch <- 5
    val := <- ch
    println(val)
}

medium

A. Channel is not created properly

B. Sending to channel blocks forever causing deadlock

C. Receiving from channel is incorrect syntax

D. Variable val is not declared

Solution

1. Step 1: Analyze channel usage without goroutine

   The code sends to ch but no goroutine is receiving yet, so send blocks forever.

2. Step 2: Understand deadlock cause

   Since the send blocks and main goroutine waits, program deadlocks before receiving.

3. Final Answer:

   Sending to channel blocks forever causing deadlock -> Option B

4. Quick Check:

   Send blocks without concurrent receiver [OK]

Hint: Send blocks if no goroutine receives concurrently [OK]

Common Mistakes:

• Assuming send works without concurrent receive
• Thinking channel creation is wrong
• Confusing syntax errors with runtime deadlock

5. You want to send multiple values 1, 2, 3 to a channel ch and receive them in order. Which code snippet correctly does this without causing deadlock?

hard

A. ch := make(chan int)
go func() {
ch <- 1
ch <- 2
ch <- 3
}()
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

B. ch := make(chan int)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

C. ch := make(chan int, 1)
ch <- 1
ch <- 2
ch <- 3
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

D. ch := make(chan int)
for i := 1; i <= 3; i++ {
ch <- i
}
for i := 0; i < 3; i++ {
fmt.Println(<-ch)
}

Solution

1. Step 1: Check for deadlock prevention

   ch := make(chan int)
   go func() {
       ch <- 1
       ch <- 2
       ch <- 3
   }()
   for i := 0; i < 3; i++ {
       fmt.Println(<-ch)
   }

   uses a goroutine to send values, so sending won't block the main goroutine.

2. Step 2: Confirm receiving order and printing

   Main goroutine receives three values in order and prints them correctly.

3. Final Answer:

   This code runs without deadlock and prints 1, 2, 3 -> Option A

4. Quick Check:

   Use goroutine to send multiple values safely [OK]

Hint: Send in goroutine or use buffered channel to avoid deadlock [OK]

Common Mistakes:

• Sending multiple values on unbuffered channel without goroutine
• Assuming unbuffered channel allows multiple sends without receive
• Forgetting to import fmt for printing