Chapter 19: R Nested If

Part 1: What Are Nested If Statements?

A nested if statement is simply an if statement placed inside another if statement. It allows you to test multiple conditions in a hierarchical way, where the inner condition is only evaluated if the outer condition is true.

The Basic Building Blocks

Before diving into nesting, let’s review the basic if structure in R:

The Nested Structure

A nested if looks like this:

Notice how the second if statement sits completely inside the first if block, with its own indentation showing it belongs to the outer condition.

Part 2: Simple Examples to Build Understanding

Let’s start with a straightforward example to see nesting in action:

Example 1: Number Classification

What happens here:

1. R checks if x > 10 – it’s TRUE (30 > 10)

2. It prints “x is greater than ten”

3. Then it enters the nested if and checks if x > 20 – also TRUE

4. It prints “and also greater than 20!”

Output:

If we changed x to 15, the output would be:

If we changed x to 5, the output would simply be:

The nested condition is never even checked because the outer condition fails first.

Example 2: Voting Eligibility with Multiple Requirements

Let’s model a real-world scenario – checking if someone can vote:

When age = 19 and has_id = TRUE:

When age = 19 but has_id = FALSE:

When age = 16:

This demonstrates the hierarchical nature – the ID check only matters if the age requirement is already satisfied.

Part 3: The else if Ladder – An Alternative to Deep Nesting

While nested ifs are powerful, R also provides the else if construct for checking multiple conditions in sequence. This is often cleaner than deep nesting:

Using else if

Output: [1] "Grade: B"

This is functionally similar to nesting but much more readable. R checks each condition in order and stops at the first TRUE condition.

When to Use Which?

• Use nested ifs when the conditions have a hierarchical relationship – one condition only makes sense if another is true

• Use else if ladders when checking mutually exclusive conditions in a sequence

Part 4: Nested ifelse() for Vectorized Operations

The ifelse() function is R’s vectorized version of if-else. It’s designed to work with entire vectors at once, which is much more efficient than writing loops.

Basic ifelse() Syntax

• test: A logical condition (TRUE/FALSE)

• yes: Value returned when test is TRUE

• no: Value returned when test is FALSE

Simple ifelse() Example

Output: [1] "Pass" "Pass" "Fail" "Pass" "Pass"

The beauty of ifelse() is that it processes all five elements in one go!

Nesting ifelse() for Multiple Categories

When you need more than two categories, you can nest ifelse() statements by putting another ifelse() in the no argument:

Output: [1] "D" "B" "F" "A" "C"

Let’s trace how this works for the first score (65):

1. scores >= 90? FALSE → move to the first no (which contains the next ifelse)

2. scores >= 80? FALSE → move to the next no

3. scores >= 70? FALSE → move to the next no

4. scores >= 60? TRUE → return “D”

The nesting continues through all conditions until finding a TRUE or reaching the final default value.

Practical Example: Customer Segmentation

Let’s use a data frame to see nested ifelse in action with real data:

Output:

Notice how each customer is correctly classified based on their purchase amount, all in a single vectorized operation.

Part 5: Advanced Nested If Examples

Example 1: Student Performance Evaluation

Let’s create a more comprehensive evaluation system:

This example shows three levels of nesting, each making more specific decisions based on previous conditions.

Example 2: Weather Recommendation System

Part 6: Common Mistakes and How to Avoid Them

Mistake 1: Forgetting Braces

Mistake 2: Misaligned else Statements

In R, the else keyword must be on the same line as the closing brace of the previous if:

Mistake 3: Overcomplicating with Deep Nesting

Mistake 4: Not Handling All Cases in Nested ifelse

Part 7: Alternative Approaches for Complex Logic

When nested ifs become too complex, consider these alternatives:

1. The switch() Function for Single Value Checks

2. The case_when() Function from dplyr

For data frames with many conditions, dplyr::case_when() is much cleaner than nested ifelse:

3. Creating Helper Functions

Summary: The Nested If Philosophy

Nested if statements are your tool for hierarchical decision-making. Master these patterns:

1. Simple nesting – One condition inside another

2. else if ladders – Sequential mutually exclusive conditions

3. Nested ifelse – Vectorized operations for data frames

4. Alternative approaches – switch(), case_when(), and helper functions

Key takeaways:

• Always indent nested code for readability

• Use braces even when optional

• Consider else if for sequential checks

• Use ifelse() for vector operations

• Don’t nest too deep – refactor when necessary

When to use each:

• Nested if/else: When conditions have hierarchical relationships

• else if ladder: When checking multiple mutually exclusive conditions

• Nested ifelse: When working with vectors or data frame columns

• case_when: For complex, multi-condition logic in data frames

• switch: For exact matches to a single value

The art of nested ifs is knowing not just how to write them, but when to use them and when to choose a simpler alternative. Start simple, add complexity gradually, and always prioritize code that’s easy for humans to read and understand.

Would you like me to elaborate on any specific aspect of nested ifs or explore more complex real-world examples?