if Expressions in Rust

Beginner ~20 min read

Control flow is essential in any programming language. Rust's if expressions allow you to execute code conditionally based on boolean conditions. What makes Rust unique is that if is an expression, meaning it can return a value!

Basic if Syntax

The simplest form of if checks a condition and executes a block of code if it's true:

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

Important: The condition must be a bool. Rust will not automatically convert other types to boolean. You must use explicit comparison operators.

fn main() {
    // Basic if statement
    let number = 5;
    
    if number < 10 {
        println!("Number is less than 10");
    }
    
    // if-else
    let temperature = 25;
    
    if temperature > 30 {
        println!("It's hot outside!");
    } else {
        println!("It's comfortable outside.");
    }
    
    // if-else if-else
    let score = 85;
    
    if score >= 90 {
        println!("Grade: A");
    } else if score >= 80 {
        println!("Grade: B");
    } else if score >= 70 {
        println!("Grade: C");
    } else if score >= 60 {
        println!("Grade: D");
    } else {
        println!("Grade: F");
    }
    
    // Multiple conditions with logical operators
    let age = 25;
    let has_license = true;
    
    if age >= 18 && has_license {
        println!("You can drive!");
    } else {
        println!("You cannot drive.");
    }
    
    // Using || (OR)
    let is_weekend = true;
    let is_holiday = false;
    
    if is_weekend || is_holiday {
        println!("Time to relax!");
    } else {
        println!("Time to work!");
    }
    
    // Negation with !
    let is_raining = false;
    
    if !is_raining {
        println!("Let's go outside!");
    }
}

Output

Click Run to execute your code

if-else Statements

Use else to provide an alternative block of code when the condition is false:

if condition {
    // Execute if true
} else {
    // Execute if false
}

Multiple Conditions with else if

Chain multiple conditions using else if:

if condition1 {
    // Execute if condition1 is true
} else if condition2 {
    // Execute if condition2 is true
} else {
    // Execute if all conditions are false
}

Tip: Rust evaluates conditions from top to bottom and stops at the first true condition. Order your conditions from most specific to most general.

Logical Operators

Combine multiple conditions using logical operators:

Operator	Name	Example	Description
`&&`	AND	`a && b`	True if both are true
`\|\|`	OR	`a \|\| b`	True if either is true
`!`	NOT	`!a`	Inverts the boolean

let age = 25;
let has_license = true;

// Both conditions must be true
if age >= 18 && has_license {
    println!("You can drive!");
}

// At least one condition must be true
if is_weekend || is_holiday {
    println!("Time to relax!");
}

// Negate a condition
if !is_raining {
    println!("Let's go outside!");
}

if as an Expression

This is where Rust shines! Since if is an expression, it can return a value:

let condition = true;
let number = if condition { 5 } else { 6 };
println!("The number is: {}", number);

Type Consistency: When using if as an expression, both branches must return the same type. This won't compile:

let result = if condition { 5 } else { "six" }; // Error!

fn main() {
    // if is an expression - it returns a value!
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The number is: {}", number);
    
    // Using if expression for assignment
    let temperature = 25;
    let weather = if temperature > 30 {
        "hot"
    } else if temperature > 20 {
        "warm"
    } else if temperature > 10 {
        "cool"
    } else {
        "cold"
    };
    println!("The weather is: {}", weather);
    
    // if expression in function return
    fn get_discount(is_member: bool) -> i32 {
        if is_member {
            20  // 20% discount
        } else {
            0   // No discount
        }
    }
    
    println!("Member discount: {}%", get_discount(true));
    println!("Non-member discount: {}%", get_discount(false));
    
    // Ternary-like usage
    let age = 17;
    let status = if age >= 18 { "adult" } else { "minor" };
    println!("Status: {}", status);
    
    // Both branches must return the same type!
    let score = 85;
    let result = if score >= 60 {
        "Pass"
    } else {
        "Fail"
        // "0"  // Error: expected &str, found integer
    };
    println!("Result: {}", result);
    
    // Using if expression in calculations
    let x = 10;
    let y = 20;
    let max = if x > y { x } else { y };
    println!("Max of {} and {}: {}", x, y, max);
    
    // Nested if expressions
    let num = 15;
    let description = if num > 0 {
        if num % 2 == 0 {
            "positive even"
        } else {
            "positive odd"
        }
    } else if num < 0 {
        "negative"
    } else {
        "zero"
    };
    println!("{} is {}", num, description);
}

Output

Click Run to execute your code

Comparison Operators

Use these operators to create conditions:

Operator	Meaning	Example
`==`	Equal to	`x == 5`
`!=`	Not equal to	`x != 5`
`<`	Less than	`x < 5`
`>`	Greater than	`x > 5`
`<=`	Less than or equal	`x <= 5`
`>=`	Greater than or equal	`x >= 5`

Common Mistakes

1. Using non-boolean conditions

Wrong:

let number = 5;
if number {  // Error: expected bool, found integer
    println!("Number exists");
}

Correct:

let number = 5;
if number != 0 {  // Explicit comparison
    println!("Number is non-zero");
}

2. Type mismatch in if expression

Wrong:

let result = if condition {
    5
} else {
    "six"  // Error: type mismatch
};

Correct:

let result = if condition {
    "five"
} else {
    "six"  // Both branches return &str
};

3. Forgetting else when using if as expression

Wrong:

let number = if condition { 5 };  // Error: missing else branch

Correct:

let number = if condition { 5 } else { 0 };

Best Practices

Keep conditions simple: Complex conditions are hard to read. Extract them into variables:
```
let is_eligible = age >= 18 && has_license && !is_suspended;
if is_eligible {
    // ...
}
```

Use if expressions: Prefer if expressions over mutable variables:

// Good
let status = if age >= 18 { "adult" } else { "minor" };

// Less idiomatic
let mut status = "minor";
if age >= 18 {
    status = "adult";
}

Consider match: For many conditions, match is often clearer than multiple else if

Exercise: Practice if Expressions

Task: Fix the code to make it compile and work correctly.

Requirements:

Fix boolean conditions
Complete if-else chains
Use if as expression
Handle type consistency
Use logical operators

// Exercise: if Expressions
// Fix the code to make it compile and run correctly

fn main() {
    // TODO: Fix this if statement to check if number is positive
    let number = 42;
    if number {  // Fix this condition
        println!("Number is positive");
    }
    
    // TODO: Complete the if-else to categorize the age
    let age = 25;
    if age >= 65 {
        println!("Senior");
    }
    // Add else if for adult (18-64)
    // Add else for minor (under 18)
    
    // TODO: Use if as an expression to assign a value
    let score = 85;
    let grade;  // Fix: use if expression to assign grade
    if score >= 90 {
        grade = "A";
    } else {
        grade = "B";
    }
    println!("Grade: {}", grade);
    
    // TODO: Fix the type mismatch error
    let is_even = true;
    let result = if is_even {
        2
    } else {
        "odd"  // Error: type mismatch!
    };
    println!("Result: {}", result);
    
    // TODO: Write an if expression that returns the absolute value
    let num = -15;
    let absolute = 0;  // Fix: use if expression
    println!("Absolute value of {}: {}", num, absolute);
    
    // TODO: Check multiple conditions
    let temperature = 25;
    let is_sunny = true;
    // Write an if statement: if temp > 20 AND sunny, print "Perfect day!"
    
    // TODO: Use if expression to find the maximum of three numbers
    let a = 10;
    let b = 25;
    let c = 15;
    let max = 0;  // Fix: use nested if expressions
    println!("Max of {}, {}, {}: {}", a, b, c, max);
}

// Hints:
// 1. Conditions must be boolean (true/false)
// 2. Use comparison operators: >, <, >=, <=, ==, !=
// 3. Use logical operators: && (AND), || (OR), ! (NOT)
// 4. if expressions must return the same type in all branches
// 5. Use if-else if-else for multiple conditions
// 6. For absolute value: if num < 0 { -num } else { num }

Output

Click Run to execute your code

Show Solution

fn main() {
    // Fixed: Check if number is positive
    let number = 42;
    if number > 0 {
        println!("Number is positive");
    }
    
    // Complete age categorization
    let age = 25;
    if age >= 65 {
        println!("Senior");
    } else if age >= 18 {
        println!("Adult");
    } else {
        println!("Minor");
    }
    
    // Use if as expression
    let score = 85;
    let grade = if score >= 90 {
        "A"
    } else {
        "B"
    };
    println!("Grade: {}", grade);
    
    // Fix type mismatch
    let is_even = true;
    let result = if is_even {
        "even"
    } else {
        "odd"
    };
    println!("Result: {}", result);
    
    // Absolute value
    let num = -15;
    let absolute = if num < 0 { -num } else { num };
    println!("Absolute value of {}: {}", num, absolute);
    
    // Multiple conditions
    let temperature = 25;
    let is_sunny = true;
    if temperature > 20 && is_sunny {
        println!("Perfect day!");
    }
    
    // Max of three numbers
    let a = 10;
    let b = 25;
    let c = 15;
    let max = if a > b && a > c {
        a
    } else if b > c {
        b
    } else {
        c
    };
    println!("Max of {}, {}, {}: {}", a, b, c, max);
}

Summary

if expressions allow conditional execution of code
Conditions must be boolean (true or false)
Use else if for multiple conditions
Logical operators: && (AND), || (OR), ! (NOT)
if is an expression - it can return a value
Both branches of an if expression must return the same type
When using if as expression, else is required
Comparison operators: ==, !=, <, >, <=, >=

What's Next?

Now that you understand if expressions, you're ready to learn about loops. In the next lesson, you'll learn about Rust's three types of loops: loop, while, and for, and how to control their execution with break and continue.

Previous Comments

Next Loops

Basic if Syntax

if-else Statements

Multiple Conditions with else if

Logical Operators

if as an Expression

Comparison Operators

Common Mistakes

1. Using non-boolean conditions

2. Type mismatch in if expression

3. Forgetting else when using if as expression

Best Practices

Exercise: Practice if Expressions

Summary

What's Next?

Enjoying these tutorials?