Nested conditional statements in Go

Introduction

Nested conditional statements help you make decisions inside other decisions. This lets your program check many things step by step.

When you want to check if a number is positive, and then check if it is even or odd.

When you need to decide a price discount based on customer type and purchase amount.

When you want to check if a user is logged in, and then check their role to show different pages.

When you want to check weather conditions and then decide what clothes to wear.

Syntax

Go

if condition1 {
    if condition2 {
        // code if both condition1 and condition2 are true
    } else {
        // code if condition1 is true but condition2 is false
    }
} else {
    // code if condition1 is false
}

Each if or else block can contain another if statement.

Indent your code inside blocks to keep it clear and easy to read.

Examples

This checks if a person is 18 or older, then inside that it checks if they are 21 or older for drinking.

Go

if age >= 18 {
    if age >= 21 {
        fmt.Println("You can drink alcohol in the US.")
    } else {
        fmt.Println("You can vote but not drink alcohol in the US.")
    }
} else {
    fmt.Println("You are too young to vote or drink alcohol.")
}

This checks if a score is passing, then inside that it checks if the score is excellent.

Go

if score >= 50 {
    if score >= 90 {
        fmt.Println("Grade: A")
    } else {
        fmt.Println("Grade: Pass")
    }
} else {
    fmt.Println("Grade: Fail")
}

Sample Program

This program checks a person's age. It first checks if the person is 18 or older. If yes, it then checks if the person is 21 or older to decide what message to print.

Go

package main

import "fmt"

func main() {
    age := 20

    if age >= 18 {
        if age >= 21 {
            fmt.Println("You can drink alcohol in the US.")
        } else {
            fmt.Println("You can vote but not drink alcohol in the US.")
        }
    } else {
        fmt.Println("You are too young to vote or drink alcohol.")
    }
}

Important Notes

Remember to use curly braces {} to group your code blocks.

Nested conditions can get hard to read if too deep. Try to keep them simple.

Summary

Nested conditionals let you check one condition inside another.

Use them to make detailed decisions step by step.

Keep your code clean and well indented for easy reading.

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