If Else in R: if, else if, ifelse() and switch()

The if Statement

An if statement in R runs a block of code only when a condition is TRUE. The condition goes in parentheses, the code in braces, and an optional else supplies what happens otherwise:

score <- 72

if (score >= 60) {
  print("You passed")
} else {
  print("Try again")
}

The condition score >= 60 evaluates to a single TRUE, so the first branch runs. The comparison and logical operators - ==, >=, &&, %in% and friends - are what you build these conditions from.

For more than two outcomes, chain checks with else if. R walks the chain from the first condition down and runs the first branch whose condition is TRUE, skipping the rest:

score <- 85

if (score >= 90) {
  grade <- "A"
} else if (score >= 80) {
  grade <- "B"
} else if (score >= 70) {
  grade <- "C"
} else {
  grade <- "F"
}

print(grade)

Order matters: because 85 >= 80 is checked before 85 >= 70, the grade is "B". If you sorted the checks the other way, every score above 70 would get a "C".

The Brace Pitfall: Where else Must Go

This is the error that bites almost everyone's first R script. In a script (or anything run with Rscript), else must appear on the same line as the closing brace of the branch before it. This fails:

if (score >= 60) {
  print("You passed")
}
else {              # Error: unexpected 'else'
  print("Try again")
}

Why: R parses statement by statement. When it reaches the } at the start of a line, the if statement is syntactically complete, and R evaluates it then and there. The else on the next line arrives as the start of a new statement - and a statement can't begin with else. The fix is the pattern used throughout this page:

if (score >= 60) {
  print("You passed")
} else {            # brace and else on the same line
  print("Try again")
}

Inside a function body or any outer set of braces the strict rule relaxes (R keeps reading until the outer brace closes), but don't rely on that - the } else { style works everywhere and is what R style guides prescribe.

The Condition Must Be One TRUE or FALSE

if() demands exactly one logical value. Two things violate that, and both are errors:

if (NA) print("hi")
# Error: missing value where TRUE/FALSE needed

if (c(TRUE, FALSE)) print("hi")
# Error: the condition has length > 1

The NA case matters in practice because comparisons with missing data produce NA: if x is NA, then x > 10 is NA, and an if fed that condition stops your script. The defensive pattern uses short-circuiting &&:

x <- NA

if (!is.na(x) && x > 10) {
  print("big")
} else {
  print("small or missing")
}

Because !is.na(x) is FALSE, the x > 10 part is never evaluated and no NA reaches the condition. How NA propagates through comparisons is covered in missing values.

The length-greater-than-1 error (enforced since R 4.2; before that R silently used the first element) usually means you meant one of these instead: any(v > 5) if one match is enough, all(v > 5) if every element must pass, or ifelse() if you wanted a per-element answer - which is the next section.

ifelse(): Vectorized If Else

if decides once. ifelse(test, yes, no) decides for every element of a vector and returns a vector of the same length:

temps <- c(31, 18, 24, 35, 12)

label <- ifelse(temps >= 25, "hot", "mild")
print(label)

Each element of temps is tested independently: "hot" "mild" "mild" "hot" "mild". This is the tool for deriving a new vector or data-frame column from an existing one - no loop needed.

Unlike if, ifelse() handles missing values gracefully: an NA in the test yields an NA in the result rather than an error:

temps <- c(31, NA, 12)
print(ifelse(temps >= 25, "hot", "mild"))

You can nest ifelse() calls for three-way splits, and at that depth it's still readable:

temps <- c(31, 18, 24, 35, 12)

band <- ifelse(temps >= 30, "hot",
        ifelse(temps >= 20, "warm", "cool"))
print(band)

But stop there. Three or more nested ifelse() calls become a bracket-matching puzzle; at that point reach for cut() (for numeric ranges) or dplyr::case_when(), which lays each condition on its own line.

switch() for Multi-Way Choices

When you're matching one value against a list of known names - not testing ranges - a long else if chain is the clumsy tool. switch() says it directly:

weekday_type <- function(day) {
  switch(day,
    sat = ,
    sun = "weekend",
    "weekday"
  )
}

print(weekday_type("sun"))
print(weekday_type("tue"))

Three behaviors to know:

• Matching: switch() compares the character value against the argument names and returns the matching result.
• Fall-through: a name with an empty right side (sat = ,) falls through to the next case's result - that's how "sat" and "sun" share "weekend" without repeating it.
• Default: the final unnamed argument ("weekday") is returned when nothing matches. Without a default, an unmatched value makes switch() return NULL invisibly - your function silently returns nothing, which is a confusing bug. Always supply a default (or make it an explicit stop()).

switch() shines inside functions that dispatch on a mode or method argument; for anything based on numeric thresholds, stick with else if or cut().

What You Take Away

• if (condition) { } else { } - condition in parentheses, one branch runs; chain with else if, first match wins.
• In scripts, write } else { on one line - else at the start of a line is a syntax error.
• if() needs exactly one TRUE/FALSE: NA is an error, a longer vector is an error (since R 4.2). Guard with !is.na(x) &&, or reduce with any()/all().
• ifelse(test, yes, no) is the vectorized version - use it to compute new vectors, and don't nest it more than twice.
• switch() handles multi-way dispatch on names, with fall-through via empty cases - always give it a default.

Next up: doing something more than once - for loops, and when a loop is (and isn't) the right tool.