Conditional Statements

This documentation covers the concept of Conditional Statements in Go, including if, if-else, if-else-if, and switch statements. It provides in-depth explanations and practical examples to help beginners understand and implement them effectively.

Overview of Conditional Statements

Understanding Conditional Statements

What are Conditional Statements?

Conditional statements are a fundamental part of programming that allow a program to make decisions based on specific conditions. They act like traffic signals, directing the flow of the program to execute different blocks of code depending on whether certain conditions are true or false. This enables the program to handle different scenarios, which is crucial for creating dynamic and responsive applications.

For example, imagine a scenario in a weather application. The application might use conditional statements to alert users to different weather conditions:

  • If the temperature is above 90 degrees, alert the user: "It's hot outside."
  • If the temperature is between 60 and 90 degrees, alert the user: "It's a nice day."
  • If the temperature is below 60 degrees, alert the user: "It's cold outside."

In this case, the application makes decisions based on the temperature and executes the appropriate block of code.

Importance of Conditional Statements in Programming

Conditional statements are essential because they allow programs to handle various situations and respond appropriately. They enable control flow, which means the program can adapt its behavior based on the input or state of the application. Without conditional statements, programs would be inflexible and unable to perform tasks that require decision-making.

In real-life terms, think of a vending machine. The vending machine uses conditional logic to determine whether to dispense a product or not. It checks if you've inserted enough money, whether the product you requested is available, and whether the transaction is valid before proceeding.

In programming, the same logic applies. Conditional statements help in making the program versatile and capable of handling different inputs and situations.

Types of Conditional Statements in Go

If Statement

Basic If Statement Syntax

In Go, the if statement is used to execute a block of code only if a specified condition is true. The basic syntax for an if statement in Go is:

if condition {
    // Code to execute if condition is true
}

Here, condition is a boolean expression. If the condition is true, the code inside the curly braces {} will execute. If the condition is false, this block will be skipped.

Examples of If Statements

Simple Comparison

Let's look at a simple example where we check if a number is positive:

package main

import (
    "fmt"
)

func main() {
    number := 10
    if number > 0 {
        fmt.Println("The number is positive.")
    }
}

In this example:

  • We declare a variable number and assign it the value 10.
  • We use an if statement to check if number is greater than 0.
  • Since number is 10, which is greater than 0, the condition is true, and the program outputs: The number is positive.
Multiple Conditions

We can also use logical operators to combine multiple conditions. Let's check if a number is within a range (e.g., between 10 and 20):

package main

import (
    "fmt"
)

func main() {
    number := 15
    if number >= 10 && number <= 20 {
        fmt.Println("The number is between 10 and 20.")
    }
}

In this example:

  • We declare a variable number and assign it the value 15.
  • We use an if statement with the condition number >= 10 && number <= 20, which checks if number is between 10 and 20.
  • The condition is true because 15 is indeed between 10 and 20, so the program outputs: The number is between 10 and 20.

If-Else Statement

Basic If-Else Statement Syntax

The if-else statement is an extension of the if statement. It allows us to execute a different block of code if the condition in the if part is false. The syntax is:

if condition {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

If the condition is true, the first block executes. If the condition is false, the code inside the else block executes.

Examples of If-Else Statements

Using Logical Operators

Let's expand on our previous example to include an else block:

package main

import (
    "fmt"
)

func main() {
    number := 5
    if number > 0 {
        fmt.Println("The number is positive.")
    } else {
        fmt.Println("The number is not positive.")
    }
}

In this example:

  • We declare a variable number and assign it the value 5.
  • The if block checks if number is greater than 0.
  • Since number is 5, which is greater than 0, the condition is true, and the program outputs: The number is positive.

Now, let's modify the value of number to see the else block in action:

package main

import (
    "fmt"
)

func main() {
    number := -5
    if number > 0 {
        fmt.Println("The number is positive.")
    } else {
        fmt.Println("The number is not positive.")
    }
}

In this modified example:

  • We declare a variable number and assign it the value -5.
  • The if block checks if number is greater than 0.
  • Since number is -5, which is not greater than 0, the condition is false, and the program executes the code in the else block, outputting: The number is not positive.
Nested If-Else Statements

Nested if-else statements occur when an if or else block contains another if or else statement. This allows a program to handle multiple conditions in a structured manner:

package main

import (
    "fmt"
)

func main() {
    age := 18
    if age < 13 {
        fmt.Println("You are a child.")
    } else if age < 20 {
        fmt.Println("You are a teenager.")
    } else {
        fmt.Println("You are an adult.")
    }
}

In this example:

  • We declare a variable age and assign it the value 18.
  • The first if block checks if age is less than 13. It is not, so this block is skipped.
  • The else if block checks if age is less than 20. It is, so this block executes, and the program outputs: You are a teenager.

If-Else-If Statement

When to Use If-Else-If

The if-else-if statement is useful when you have multiple conditions to check, and you want to execute different blocks of code based on which condition is true. It is particularly handy when you have more than two possible outcomes.

Basic Syntax of If-Else-If

The syntax for an if-else-if statement in Go is:

if condition1 {
    // Code to execute if condition1 is true
} else if condition2 {
    // Code to execute if condition2 is true
} else {
    // Code to execute if all conditions are false
}

Examples of If-Else-If Statements

Multiple Conditions and Logic

Here's an example where we check the grade of a student based on their score:

package main

import (
    "fmt"
)

func main() {
    score := 85
    if score >= 90 {
        fmt.Println("Grade: A")
    } else if score >= 80 {
        fmt.Println("Grade: B")
    } else if score >= 70 {
        fmt.Println("Grade: C")
    } else if score >= 60 {
        fmt.Println("Grade: D")
    } else {
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 85.
  • The first if block checks if score is greater than or equal to 90. It is not, so this block is skipped.
  • The next else if block checks if score is greater than or equal to 80. It is, so this block executes, and the program outputs: Grade: B.

Switch Statement

What is a Switch Statement?

A switch statement is another form of conditional statement that is used to execute different blocks of code based on the value of a variable or expression. It is more readable and concise than a series of if-else-if statements.

Key Benefits of Using Switch

  • Readability: Switch statements are easier to read and maintain, especially when dealing with multiple conditions.
  • Performance: Switch statements can be more efficient than a series of if-else-if statements because the compiler can optimize them better.
  • Conciseness: Switch statements allow you to handle multiple conditions in a more compact form.

Basic Syntax of Switch Statement

Using a Single Variable

The basic syntax for a switch statement in Go is:

switch variable {
case value1:
    // Code to execute if variable == value1
case value2:
    // Code to execute if variable == value2
default:
    // Code to execute if none of the above cases match
}

Let's see an example where we assign a grade to a student based on their score:

package main

import (
    "fmt"
)

func main() {
    score := 82
    switch score / 10 {
    case 10, 9:
        fmt.Println("Grade: A")
    case 8:
        fmt.Println("Grade: B")
    case 7:
        fmt.Println("Grade: C")
    case 6:
        fmt.Println("Grade: D")
    default:
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 82.
  • The switch statement uses score / 10 to determine the grade range.
  • Since 82 / 10 equals 8, the program matches the value with the case 8 and outputs: Grade: B.
Using Multiple Variables

Go also supports switch statements with no expression, where the cases act as if-else-if conditions:

package main

import (
    "fmt"
)

func main() {
    number := 5
    switch {
    case number < 0:
        fmt.Println("The number is negative.")
    case number == 0:
        fmt.Println("The number is zero.")
    case number > 0:
        fmt.Println("The number is positive.")
    }
}

In this example:

  • We declare a variable number and assign it the value 5.
  • The switch statement without an expression acts like a series of if-else-if statements.
  • Since number is 5, which is greater than 0, the program outputs: The number is positive.
Using Type Switch

Type switch is a special form of switch that is used to determine the type of a variable. It is particularly useful when working with interfaces:

package main

import (
    "fmt"
)

func main() {
    var i interface{} = "Hello"
    switch i.(type) {
    case string:
        fmt.Println("The type is string.")
    case int:
        fmt.Println("The type is int.")
    case bool:
        fmt.Println("The type is bool.")
    default:
        fmt.Println("Unknown type.")
    }
}

In this example:

  • We declare a variable i of type interface{} and assign it the string "Hello".
  • The type switch statement checks the type of i.
  • Since i is a string, the program outputs: The type is string.

Fallthrough Keyword

How Fallthrough Works

By default, a switch statement will terminate after executing the matched case. The fallthrough keyword allows the next case to execute as well, regardless of whether its condition is true or not.

Example Without Fallthrough
package main

import (
    "fmt"
)

func main() {
    score := 85
    switch score / 10 {
    case 10, 9:
        fmt.Println("Grade: A")
    case 8:
        fmt.Println("Grade: B")
    case 7:
        fmt.Println("Grade: C")
    case 6:
        fmt.Println("Grade: D")
    default:
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 85.
  • The switch statement uses score / 10.
  • Since 85 / 10 equals 8, the program executes the case 8 and outputs: Grade: B.
Example With Fallthrough
package main

import (
    "fmt"
)

func main() {
    score := 85
    switch {
    case score >= 90:
        fmt.Println("Grade: A")
    fallthrough
    case score >= 80:
        fmt.Println("Grade: B")
    fallthrough
    case score >= 70:
        fmt.Println("Grade: C")
    case score >= 60:
        fmt.Println("Grade: D")
    default:
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 85.
  • The switch statement without an expression uses fallthrough.
  • Since score is 85, it meets the first two conditions score >= 90 and score >= 80.
  • The fallthrough keyword ensures that the program executes both matching cases, outputting: 
    Grade: B
Grade: C

Control Flow with Conditional Statements

Breaking Loops with Conditions

Using Break Statement

The break statement is used to exit a switch or loop prematurely. In switch statements, break is implicit, meaning you don't need to use it to exit a case. However, you can still use it to exit a switch statement prematurely if needed.

Example with Break

package main

import (
    "fmt"
)

func main() {
    score := 95
    switch score / 10 {
    case 10, 9:
        fmt.Println("Grade: A")
        break
        fmt.Println("Excellent job!")
    case 8:
        fmt.Println("Grade: B")
    case 7:
        fmt.Println("Grade: C")
    case 6:
        fmt.Println("Grade: D")
    default:
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 95.
  • The switch statement uses score / 10.
  • Since 95 / 10 equals 9, the program executes the case 10, 9, outputs: Grade: A, and then encounters the break statement.
  • The break statement exits the switch block, so the phrase Excellent job! is not printed. The final output is Grade: A.

Continuing Iterations with Conditions

Using Continue Statement

The continue statement is used to skip the rest of the current iteration in a loop and move to the next iteration. Although continue is primarily used with loops, it can be useful within switch statements to skip certain cases.

Example with Continue

package main

import (
    "fmt"
)

func main() {
    score := 85
    switch score / 10 {
    case 10, 9:
        fmt.Println("Grade: A")
        continue
        fmt.Println("Excellent job!") // This line is unreachable
    case 8:
        fmt.Println("Grade: B")
    case 7:
        fmt.Println("Grade: C")
    default:
        fmt.Println("Grade: F")
    }
}

In this example:

  • We declare a variable score and assign it the value 85.
  • The switch statement uses score / 10.
  • Since 85 / 10 equals 8, the program executes the case 8, outputs: Grade: B, and the loop continues to the next iteration (since there are no more cases or a loop, the program ends).
  • The continue statement is typically used within loops, but in this example, it's shown to demonstrate its presence.

Returning Values in Conditional Statements

Using Return Statement in If Statements

The return statement is used to exit a function and optionally return a value. You can use return within conditional statements to exit the function immediately when a condition is met.

Example with Return

package main

import (
    "fmt"
)

func checkGrade(score int) string {
    if score >= 90 {
        return "Grade: A"
    } else if score >= 80 {
        return "Grade: B"
    } else if score >= 70 {
        return "Grade: C"
    } else if score >= 60 {
        return "Grade: D"
    } else {
        return "Grade: F"
    }
}

func main() {
    fmt.Println(checkGrade(85))
}

In this example:

  • The function checkGrade takes an integer score as an argument.
  • It uses an if-else-if statement to determine the grade.
  • When the score is 85, the condition score >= 80 is true, and the function returns Grade: B.
  • The main function calls checkGrade with 85 and prints: Grade: B.

Best Practices for Using Conditional Statements

Writing Readable Code

Naming Conventions

Using clear and descriptive names for variables and functions helps make the code more readable. For example, instead of using n as a variable name for a student's score, use score.

// Good practice
score := 85
// Bad practice
n := 85

Commenting Practices

Adding comments to your code helps other developers (and yourself) understand the purpose of the conditional statements. For example:

package main

import (
    "fmt"
)

func main() {
    score := 85
    // Check the grade based on the score
    if score >= 90 {
        fmt.Println("Grade: A")
    } else if score >= 80 {
        fmt.Println("Grade: B")
    } else if score >= 70 {
        fmt.Println("Grade: C")
    } else if score >= 60 {
        fmt.Println("Grade: D")
    } else {
        fmt.Println("Grade: F")
    }
}

Proper Indentation

Proper indentation makes the structure of the code clear. Go's tab-based indentation system helps in maintaining a consistent code style.

Avoiding Deep Nesting

Deeply nested conditional statements can be difficult to read and understand. Try to keep your conditional statements as flat and simple as possible.

// Avoid deeply nested conditions
if condition1 {
    if condition2 {
        if condition3 {
            fmt.Println("Deeply nested")
        }
    }
}

// Flatter alternatives
if condition1 && condition2 && condition3 {
    fmt.Println("Flatter code")
}

Performance Considerations

Efficient Use of Conditions

Make sure to use conditions efficiently to avoid unnecessary computations. Avoid using complex conditions that can be simplified:

// Inefficient condition
if (score >= 0 && score <= 100) && (score >= 80 && score <= 100) {
    fmt.Println("Valid score, Grade: A")
}

// Efficient condition
if score >= 80 && score <= 100 {
    fmt.Println("Valid score, Grade: A")
}

Minimizing Calculation in Conditions

Avoid recalculating the same expression multiple times within conditions. Assign the result to a variable instead.

// Recalculating expression
if complexCalculation() == result1 {
    // Do something
}
if complexCalculation() == result2 {
    // Do something else
}

// Minimizing calculation
result := complexCalculation()
if result == result1 {
    // Do something
}
if result == result2 {
    // Do something else
}

Avoiding Unnecessary Comparisons

Avoid comparing the same variable to different values unless necessary. Combine conditions using logical operators to make the code more efficient.

// Unnecessary comparison
if score == 90 {
    // Do something
} else if score == 91 {
    // Do something else
}

// Combined condition
if score >= 90 && score <= 91 {
    // Do something
}

Debugging Tips

Common Mistakes to Avoid

  • Off-by-One Errors: These occur when the comparison operators are not used correctly, leading to incorrect results. For example, using >= instead of > can lead to unexpected behavior.
  • Logical Errors: Ensure that logical operators (&& and ||) are used correctly to avoid incorrect results. Mixing the wrong logical operators can lead to unexpected conditions being true or false.
  • Infinite Loops: Although not directly related to switch statements, ensure that conditions for for loops do not inadvertently create infinite loops.

Tips for Troubleshooting Complex Conditions

  • Simplify Complex Conditions: Break down complex conditions into smaller, simpler expressions.
  • Use Parentheses: Use parentheses to clearly specify the order of operations in complex conditions.
  • Logging and Debugging: Use fmt.Println or logging to print the values of variables at different points in the program to understand the flow.

Exercises and Challenges

Practice Problems

Easy Level Problems

Problem 1: Simple If

Write a program that checks if a number is even or odd. If the number is even, print "Even", otherwise print "Odd".

Problem 2: If-Else

Write a program that checks if a number is positive, negative, or zero. Print "Positive", "Negative", or "Zero" accordingly.

Problem 3: If-Else-If

Write a program that checks the grade of a student based on their score. Print "Grade: A" if the score is 90 or above, "Grade: B" if the score is between 80 and 89, "Grade: C" if the score is between 70 and 79, "Grade: D" if the score is between 60 and 69, and "Grade: F" otherwise.

Intermediate Level Problems

Problem 4: Switch Case

Write a program that prints the day of the week based on an integer (1 for Monday, 2 for Tuesday, ..., 7 for Sunday). If the integer is not between 1 and 7, print "Invalid day".

Problem 5: Nested Conditions

Write a program that checks if a number is in a specific range (e.g., 10-20, 21-30, 31-40) and prints the corresponding range. If the number is outside these ranges, print "Number is out of range".

Advanced Level Problems

Problem 6: Combining If with Loops

Write a program that iterates through numbers from 1 to 100 and prints whether each number is "Even" or "Odd". Use a combination of if statements and a for loop.

Problem 7: Complex Conditions

Write a program that checks if a number is a prime number. Print "Prime" if it is a prime number, otherwise print "Not Prime". Use a combination of if-else statements and a for loop.

Sample Solutions

Solution to Problem 1

package main

import (
    "fmt"
)

func main() {
    number := 10
    if number%2 == 0 {
        fmt.Println("Even")
    } else {
        fmt.Println("Odd")
    }
}

Solution to Problem 2

package main

import (
    "fmt"
)

func main() {
    number := -5
    if number > 0 {
        fmt.Println("Positive")
    } else if number < 0 {
        fmt.Println("Negative")
    } else {
        fmt.Println("Zero")
    }
}

Solution to Problem 3

package main

import (
    "fmt"
)

func main() {
    score := 85
    if score >= 90 {
        fmt.Println("Grade: A")
    } else if score >= 80 {
        fmt.Println("Grade: B")
    } else if score >= 70 {
        fmt.Println("Grade: C")
    } else if score >= 60 {
        fmt.Println("Grade: D")
    } else {
        fmt.Println("Grade: F")
    }
}

Solution to Problem 4

package main

import (
    "fmt"
)

func main() {
    day := 3
    switch day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday")
    case 3:
        fmt.Println("Wednesday")
    case 4:
        fmt.Println("Thursday")
    case 5:
        fmt.Println("Friday")
    case 6:
        fmt.Println("Saturday")
    case 7:
        fmt.Println("Sunday")
    default:
        fmt.Println("Invalid day")
    }
}

Solution to Problem 5

package main

import (
    "fmt"
)

func main() {
    number := 25
    if number >= 10 && number <= 20 {
        fmt.Println("Number is between 10 and 20")
    } else if number >= 21 && number <= 30 {
        fmt.Println("Number is between 21 and 30")
    } else if number >= 31 && number <= 40 {
        fmt.Println("Number is between 31 and 40")
    } else {
        fmt.Println("Number is out of range")
    }
}

Solution to Problem 6

package main

import (
    "fmt"
)

func main() {
    for i := 1; i <= 100; i++ {
        if i%2 == 0 {
            fmt.Printf("%d is Even\n", i)
        } else {
            fmt.Printf("%d is Odd\n", i)
        }
    }
}

Solution to Problem 7

package main

import (
    "fmt"
)

func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i <= n/2; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    number := 13
    if isPrime(number) {
        fmt.Println("Prime")
    } else {
        fmt.Println("Not Prime")
    }
}

Summary

Recap of Key Points

Summary of If Statements

  • An if statement executes a block of code if a condition is true.
  • It allows the program to make decisions based on the truth of a condition.

Summary of If-Else Statements

  • An if-else statement is used to execute different blocks of code based on the truth of a condition.
  • If the condition in the if block is false, the else block executes.

Summary of If-Else-If Statements

  • An if-else-if statement is useful for checking multiple conditions.
  • It helps in handling more than two possible outcomes in a structured manner.

Summary of Switch Statements

  • A switch statement evaluates an expression and executes the corresponding case.
  • It is more readable and concise compared to multiple if-else-if statements.
  • The fallthrough keyword can be used to allow the next case to execute.

Next Steps

Introduction to Loops in Go

Understanding loops is crucial for writing programs that need to repeat operations. Go has for loops, for loops with range, for as a while loop, and for loop as an infinite loop.

Further Reading and Resources

By mastering conditional statements, you add a powerful tool to your programming arsenal. They enable your programs to handle different scenarios and make decisions, which is essential for creating dynamic and responsive applications. Keep practicing with different types of conditions and scenarios to become proficient in using conditional statements in Go.