Switch expression behavior in Go - Step-by-Step Execution

Concept Flow - Switch expression behavior

Start switch expression

↓

Evaluate expression once

↓

Compare expression to case values

↓

Match found?

No→Execute default case if present

↓

Execute matched case block

↓

Exit switch

The switch expression is evaluated once, then compared to each case value in order. When a match is found, its block runs and the switch exits.

Execution Sample

Go

package main
import "fmt"
func main() {
  x := 2
  switch x {
  case 1: fmt.Println("One")
  case 2: fmt.Println("Two")
  default: fmt.Println("Other")
  }
}

This code checks the value of x and prints the matching case's message.

Execution Table

Step	Expression Value	Case Checked	Match?	Action	Output
1	2	case 1	No	Skip case 1
2	2	case 2	Yes	Execute case 2 block	Two
3	2	default	Skipped	Switch exits after match

💡 Switch exits after executing the matched case block (case 2).

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
x	2	2	2	2

Key Moments - 2 Insights

Why does the switch stop after matching case 2 and not check the default case?

Because once a matching case is found (step 2 in execution_table), the switch executes that case block and exits immediately without checking further cases.

Is the switch expression evaluated multiple times for each case?

No, the expression is evaluated once at the start (step 1), then compared to each case value.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output at step 2?

A One

B Other

C Two

D No output

💡 Hint

Check the 'Output' column for step 2 in the execution_table.

At which step does the switch expression get evaluated?

A Step 1

B Step 2

C Step 3

D It is evaluated multiple times

💡 Hint

Look at the 'Expression Value' column in the execution_table.

If x was 3, which case would execute according to the execution_table logic?

A case 1

B default

C case 2

D No case executes

💡 Hint

Recall that if no case matches, the default case runs.

Concept Snapshot

switch expression {
  case value1:
    // runs if expression == value1
  case value2:
    // runs if expression == value2
  default:
    // runs if no case matches
}

- Expression evaluated once
- Cases checked in order
- Executes first matching case and exits
- Default runs if no match

Full Transcript

In Go, a switch expression is evaluated once at the start. Then, each case is checked in order to see if it matches the expression's value. When a match is found, the corresponding case block runs and the switch exits immediately. If no case matches, the default block runs if it exists. For example, if x equals 2, the switch checks case 1 (no match), then case 2 (match), runs that block, and stops without checking default. This behavior helps write clear multi-way decisions without repeated expression evaluation.

Practice

1. What does a switch statement do in Go?

easy

A. It runs all cases one after another.

B. It chooses one case to run based on a value or condition.

C. It only works with numbers, not strings.

D. It repeats the same case multiple times automatically.

Solution

1. Step 1: Understand switch purpose

   A switch statement selects one matching case based on a value or condition.

2. Step 2: Confirm behavior

   It stops after the first matching case, so only one case runs.

3. Final Answer:

   It chooses one case to run based on a value or condition. -> Option B

4. Quick Check:

   Switch picks one matching case [OK]

Hint: Switch picks only the first matching case [OK]

Common Mistakes:

• Thinking switch runs all cases
• Believing switch only works with numbers
• Assuming switch repeats cases automatically

2. Which of the following is the correct syntax for a basic switch statement in Go?

easy

A. switch (value) { case 1: doSomething() default: doDefault() }

B. switch value do { case 1: doSomething() default: doDefault() }

C. switch value then { case 1: doSomething() default: doDefault() }

D. switch value { case 1: doSomething() default: doDefault() }

Solution

1. Step 1: Recall Go switch syntax

   Go uses switch value { case ... } without parentheses or extra keywords.

2. Step 2: Check options

   switch value { case 1: doSomething() default: doDefault() } matches correct syntax; others add invalid keywords or parentheses.

3. Final Answer:

   switch value { case 1: doSomething() default: doDefault() } -> Option D

4. Quick Check:

   Go switch uses braces, no parentheses [OK]

Hint: No parentheses around switch value in Go [OK]

Common Mistakes:

• Adding parentheses around switch value
• Using 'then' or 'do' keywords incorrectly
• Misplacing braces or colons

3. What is the output of this Go code?

package main
import "fmt"
func main() {
  x := 3
  switch x {
  case 1:
    fmt.Println("One")
  case 2, 3:
    fmt.Println("Two or Three")
  default:
    fmt.Println("Other")
  }
}

medium

A. One

B. Other

C. Two or Three

D. No output

Solution

1. Step 1: Identify switch value and cases

   Variable x is 3. The switch checks cases 1, then 2 or 3, then default.

2. Step 2: Match case

   Case 2, 3 matches because x is 3, so it prints "Two or Three".

3. Final Answer:

   Two or Three -> Option C

4. Quick Check:

   3 matches case 2,3 [OK]

Hint: Check all case values including multiple ones [OK]

Common Mistakes:

• Ignoring multiple values in one case
• Choosing default instead of matching case
• Assuming case 3 is separate from case 2

4. Identify the error in this Go switch code:

package main
import "fmt"
func main() {
  x := 5
  switch {
  case x == 1:
    fmt.Println("One")
  case x == 5:
    fmt.Println("Five")
  case x == 10:
    fmt.Println("Ten")
  }
}

medium

A. No error; code runs and prints "Five"

B. Switch expression is missing a value but cases use conditions

C. Missing default case causes error

D. Case statements must be constants, not conditions

Solution

1. Step 1: Understand switch without expression

   Switch without a value allows cases to be conditions (boolean expressions).

2. Step 2: Check cases and output

   x is 5, so case x == 5 is true, printing "Five". No error occurs.

3. Final Answer:

   No error; code runs and prints "Five" -> Option A

4. Quick Check:

   Switch without value uses conditions [OK]

Hint: Switch without value uses boolean cases [OK]

Common Mistakes:

• Thinking default is mandatory
• Assuming switch must have a value
• Believing case conditions are invalid

5. Given this Go code, what will be printed?

package main
import "fmt"
func main() {
  score := 75
  switch {
  case score >= 90:
    fmt.Println("Grade A")
  case score >= 80:
    fmt.Println("Grade B")
  case score >= 70:
    fmt.Println("Grade C")
  default:
    fmt.Println("Fail")
  }
}

hard

A. Grade C

B. Grade B

C. Fail

D. Grade A

Solution

1. Step 1: Analyze switch without expression

   Switch uses conditions in cases, evaluated top to bottom.

2. Step 2: Evaluate conditions for score = 75

   score >= 90 is false, score >= 80 is false, score >= 70 is true, so prints "Grade C" and stops.

3. Final Answer:

   Grade C -> Option A

4. Quick Check:

   First true case runs, here score >= 70 [OK]

Hint: Switch stops at first true condition [OK]

Common Mistakes:

• Ignoring order of cases
• Assuming all true cases print
• Confusing >= with >