Fix 'argument is of length zero' in R

The error argument is of length zero means if() or while() received a condition that contains no value at all: a zero-length object such as NULL, integer(0), or logical(0). It usually traces back to a misspelled column name, a missing list element, or a filter that matched nothing.

if (length(x) > 0) mean(x)            # guard a possibly-empty vector
if (!is.null(x) && x > 5) "big"       # rule out NULL before comparing
if (isTRUE(x > 5)) "big"              # one call absorbs NULL, NA, empty
"profit" %in% names(df)               # df$profit NULL? check the spelling
x <- x %||% 0                         # swap NULL for a default (R 4.4+)
if (NROW(res) > 0) summary(res)       # row guard for vectors and frames

What this error means

if() needs exactly one TRUE or FALSE, and you handed it nothing. A zero-length object has no first element to test, so R stops instead of guessing. Despite the word "argument", the message is almost never about a function you wrote: the condition inside if() is technically the argument it refers to.

The shortest way to trigger it is to test NULL directly:

Real code rarely writes NULL by hand. Instead, an expression evaluates to something zero-length before it reaches if(). Comparisons keep the length of their inputs, so an empty input produces an empty result:

logical(0) is a logical vector with zero elements. When if() receives it, there is no value to branch on, and the error fires.

The four causes and their fixes

Almost every occurrence comes from one of four patterns. Each subsection reproduces the failure, then shows the repair.

1. A misspelled column or missing list element

The $ operator returns NULL silently when the name does not exist. No warning, no error, just NULL flowing downstream until if() chokes on it:

The fix is to check the spelling against names() before trusting the column:

2. A function that returned NULL

An if() without an else returns NULL invisibly when the condition is false. Code that compares that return value inherits the problem:

Give every branch an explicit value so callers always receive something testable:

3. A subset or which() that matched nothing

which() returns integer(0) when no element satisfies the test. Indexing with an empty vector yields an empty vector, and the comparison collapses:

Guard on the count of matches before using them:

The && operator short-circuits: when length(i) > 0 is FALSE, R never evaluates the risky right-hand side.

4. Shiny inputs that are NULL at startup

Two of the top ten search results for this error are Shiny threads, because reactive inputs are NULL for a moment before the UI delivers a value. A plain list reproduces the mechanics:

Inside a real Shiny server, put req(input$bins) at the top of the reactive so it waits for the value. In plain R, the same defense is an explicit NULL check:

What if() accepts: the full picture

Zero-length is only one of several condition values that stop if(). Knowing which message maps to which input turns a cryptic error into a direct pointer at the bug:

The NA row is this error's closest sibling. An empty condition and a missing condition look similar in source code but fail differently:

Zero-length means the value is absent from the object entirely. NA means a slot exists but holds an unknown. Fixing the first is about where the value got lost; fixing the second is about handling missing data.

Write conditions that never break

Three defensive patterns make a condition safe against NULL, empty vectors, and NA at once. Use them at the boundaries of your code, where values arrive from files, user input, or someone else's functions.

isTRUE() is the broadest guard. It returns TRUE only for a single TRUE, and FALSE for everything else, including all the values that would crash if():

For replacing NULL with a fallback, base R 4.4.0 added the %||% operator (older versions can use if (is.null(x)) default else x, or the same operator from rlang):

For "did I get any rows back" checks, NROW() works uniformly on vectors, data frames, and NULL, so one guard covers every return type:

Try it yourself

FAQ

Why does R say "argument" when I am not calling a function?

Because if is a function under the hood. The parser rewrites if (cond) x into a call where the condition is the first argument, and the error message describes that argument. So "argument is of length zero" translates to "the expression inside if() evaluated to a zero-length object". The wording confuses almost everyone the first time.

Is this the same as "missing value where TRUE/FALSE needed"?

No, and the difference matters for debugging. "Argument is of length zero" means the condition has no elements at all, typically from NULL or an empty subset. "Missing value where TRUE/FALSE needed" means the condition has exactly one element and it is NA. The first sends you hunting for a lost value; the second for missing data in a value that arrived.

How do I find which line causes it in a long script?

Run traceback() immediately after the error to see the call stack, innermost call first. The top entries show the exact if() that failed. Then print the condition's ingredients with length() and is.null() right before that line. In RStudio, setting "Debug > On Error > Break in Code" drops you into the failing frame automatically.

Is this the same as "attempt to use zero-length variable name"?

No. That error comes from the parser, not from if(). It fires when code contains an empty name, most often a stray pair of backticks, an empty string in assign(""), or an imported data frame whose column header is blank. "Argument is of length zero" happens later, at evaluation, when a condition turns out to be empty. Fix the first by finding the empty name; fix the second with the guards above.

Can this error happen in a while loop?

Yes, while() applies the same rule as if(): its condition must evaluate to a single TRUE or FALSE. A loop like while (x > 0) fails with "argument is of length zero" the moment x becomes NULL or empty, for example after a subset that removed every element. The fixes are identical: guard with length(), is.null(), or isTRUE().

Related R errors

Start with the parent guide, common R errors and how to read them. The official R control-flow documentation specifies exactly what if() and while() accept. For the building blocks, see control flow in R for if, else, and while mechanics, R lists for why $ returns NULL on missing names, subsetting in R for how empty indexes produce empty results, and object not found for the error you get when the variable itself, not its value, is missing.