Nested conditional statements in Go - Step-by-Step Execution

Concept Flow - Nested conditional statements

Start

↓

Check Condition 1

↓

Check Condition 2

↓

Execute nested block

↓

End

The program first checks the outer condition. If true, it checks the inner condition. Depending on these checks, it executes different code blocks.

Execution Sample

Go

package main
import "fmt"
func main() {
  x := 10
  if x > 5 {
    if x < 15 {
      fmt.Println("x is between 6 and 14")
    }
  }
}

This code checks if x is greater than 5, then if x is less than 15, and prints a message if both are true.

Execution Table

Step	Condition Checked	Condition Result	Branch Taken	Output
1	x > 5	true	Enter first if
2	x < 15	true	Enter nested if
3	Print message			x is between 6 and 14
4	End		Exit

💡 No more conditions to check, program ends.

Variable Tracker

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

Key Moments - 2 Insights

Why does the program check the second condition only if the first is true?

Because the second if is inside the first if block, it only runs if the first condition is true, as shown in steps 1 and 2 of the execution_table.

What happens if the first condition is false?

The program skips the nested if and any code inside it, going directly to the end, as indicated by the 'No' branch from step 1 in the concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of the condition checked at step 2?

A undefined

B false

C true

D error

💡 Hint

Check the 'Condition Result' column for step 2 in the execution_table.

At which step does the program print the message?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Output' column in the execution_table.

If x was 4, how would the execution_table change at step 1?

A Condition Result would be false

B Condition Result would be true

C Program would print the message

D Program would crash

💡 Hint

Refer to the variable_tracker and condition 'x > 5' in execution_table step 1.

Concept Snapshot

Nested conditional statements in Go:
if condition1 {
  if condition2 {
    // code runs if both true
  }
}
The inner if runs only if the outer if is true.
Use nesting to check multiple conditions step-by-step.

Full Transcript

This example shows nested conditional statements in Go. The program first checks if x is greater than 5. If yes, it then checks if x is less than 15. If both conditions are true, it prints a message. The execution_table traces each step: checking conditions and printing output. The variable_tracker shows x remains 10 throughout. Key moments clarify that the inner condition runs only if the outer is true, and if the first condition fails, the nested block is skipped. The visual quiz tests understanding of condition results and program flow. Nested conditionals help check multiple things in order.

Practice

1.

What does a nested conditional statement in Go allow you to do?

Example: if x > 0 { if x < 10 { ... } }

easy

A. Declare multiple variables in one line

B. Run multiple loops at the same time

C. Check one condition inside another condition

D. Create a function inside another function

Solution

1. Step 1: Understand the structure of nested conditionals

   A nested conditional means putting one if statement inside another to check multiple conditions step by step.

2. Step 2: Identify the purpose of the example code

   The example checks if x is greater than 0, then inside that block checks if x is less than 10.

3. Final Answer:

   Check one condition inside another condition -> Option C

4. Quick Check:

   Nested conditionals = conditions inside conditions [OK]

Hint: Nested means inside another condition [OK]

Common Mistakes:

• Confusing nested conditionals with loops
• Thinking nested means multiple variables
• Mixing nested conditionals with function declarations

2.

Which of the following is the correct syntax for a nested if statement in Go?

if x > 0 {
    if x < 10 {
        fmt.Println("x is between 1 and 9")
    }
}

easy

A. if x > 0 {
if x < 10 {
fmt.Println("x is between 1 and 9")
}
}

B. if x > 0
if x < 10
fmt.Println("x is between 1 and 9")

C. if (x > 0) then if (x < 10) { fmt.Println("x is between 1 and 9") }

D. if x > 0 {
if x < 10 {
fmt.Println("x is between 1 and 9")
}
}

Solution

1. Step 1: Check Go syntax for nested if

   Go requires braces {} around blocks and proper indentation for readability.

2. Step 2: Compare options with correct syntax

   if x > 0 { if x < 10 { fmt.Println("x is between 1 and 9") } } uses braces and indentation correctly, matching Go style.

3. Final Answer:

   if x > 0 { if x < 10 { fmt.Println("x is between 1 and 9") } } -> Option A

4. Quick Check:

   Correct braces and indentation = if x > 0 { if x < 10 { fmt.Println("x is between 1 and 9") } } [OK]

Hint: Use braces {} and indent nested if blocks [OK]

Common Mistakes:

• Omitting braces {} around if blocks
• Using incorrect keywords like 'then'
• Not indenting nested blocks properly

3.

What will be the output of this Go code?

package main
import "fmt"
func main() {
    x := 7
    if x > 5 {
        if x < 10 {
            fmt.Println("A")
        } else {
            fmt.Println("B")
        }
    } else {
        fmt.Println("C")
    }
}

medium

A. B

B. No output

C. C

D. A

Solution

1. Step 1: Evaluate the first condition (x > 5)

   x is 7, which is greater than 5, so the first if block runs.

2. Step 2: Evaluate the nested condition (x < 10)

   7 is less than 10, so it prints "A" inside the nested if.

3. Final Answer:

   A -> Option D

4. Quick Check:

   7 > 5 and 7 < 10 = "A" [OK]

Hint: Check conditions stepwise from outer to inner [OK]

Common Mistakes:

• Ignoring nested else block
• Confusing output with 'B' or 'C'
• Assuming no output if conditions fail

4.

Find the error in this Go code snippet:

package main
import "fmt"
func main() {
    x := 3
    if x > 0
        if x < 5 {
            fmt.Println("x is between 1 and 4")
        }
}

medium

A. Missing import statement for fmt

B. Missing braces {} around the first if block

C. Incorrect variable declaration for x

D. Using > and < instead of > and <

Solution

1. Step 1: Check syntax of the first if statement

   The first if statement lacks braces {} and a closing brace for the block.

2. Step 2: Understand Go requires braces for if blocks

   In Go, if statements must have braces {} even if the block is one line or nested.

3. Final Answer:

   Missing braces {} around the first if block -> Option B

4. Quick Check:

   Go if statements need braces {} [OK]

Hint: Always use braces {} for if blocks in Go [OK]

Common Mistakes:

• Forgetting braces {} on if statements
• Thinking > and < must be escaped
• Assuming import fmt is missing

5.

Write a nested conditional in Go that prints "Small positive" if a number n is greater than 0 and less than 10, prints "Large positive" if it is 10 or more, and prints "Non-positive" otherwise. What is the correct code?

hard

A. if n > 0 {
if n < 10 {
fmt.Println("Small positive")
} else {
fmt.Println("Large positive")
}
} else {
fmt.Println("Non-positive")
}

B. if n > 0 && n < 10 {
fmt.Println("Small positive")
} else if n > 10 {
fmt.Println("Large positive")
} else {
fmt.Println("Non-positive")
}

C. if n <= 10 {
if n > 0 {
fmt.Println("Small positive")
} else {
fmt.Println("Non-positive")
}
} else {
fmt.Println("Large positive")
}

D. if n > 0 {
if n > 10 {
fmt.Println("Large positive")
} else {
fmt.Println("Small positive")
}
} else {
fmt.Println("Non-positive")
}

Solution

1. Step 1: Understand the conditions to check

   We check if n is greater than 0 first, then inside that check if n is less than 10 for "Small positive" or else "Large positive".

2. Step 2: Match the nested conditional structure

   if n > 0 { if n < 10 { fmt.Println("Small positive") } else { fmt.Println("Large positive") } } else { fmt.Println("Non-positive") } correctly nests the second if inside the first and prints the right messages for each case.

3. Final Answer:

   if n > 0 { if n < 10 { fmt.Println("Small positive") } else { fmt.Println("Large positive") } } else { fmt.Println("Non-positive") } -> Option A

4. Quick Check:

   Nested if for ranges = if n > 0 { if n < 10 { fmt.Println("Small positive") } else { fmt.Println("Large positive") } } else { fmt.Println("Non-positive") } [OK]

Hint: Check outer condition first, then inner for ranges [OK]

Common Mistakes:

• Swapping conditions order
• Using else if instead of nested if
• Mixing up the printed messages