ISERROR

What it does

ISERROR(value)

ISERROR(value) returns TRUE when the value it receives has kind Error, and FALSE for every other kind.

The Handbook states the rule as membership in the Error kind rather than membership in that list of seven, because Excel's modern extended codes (#SPILL!, #CALC!, #FIELD!, #BLOCKED!, #CONNECT!, #BUSY!, #GETTING_DATA) exist on the worksheet and did not exist when that documentation sentence was written. Which of the extended codes ISERROR answers TRUE for is not established here. The kind-membership reading predicts TRUE for all of them; the documentation's enumeration predicts nothing about them either way. That gap is real and is listed below rather than papered over.

The one thing that is definite and is the reason both this function and ISERR exist: ISERROR includes #N/A. ISERR excludes it. See "Relationships".

Arguments

value — required, exactly one.

Not converted. Microsoft's IS-functions remark applies: "The value arguments of the IS functions are not converted." Text that reads as a number stays Text, and text that reads as an error name — the literal string "#N/A" typed into a cell as text — stays Text and is therefore FALSE. An error value and the text that spells an error are different kinds, and ISERROR separates them.

Try it

Quirks

Result and edge cases

Returns a Logical, or an array of Logical when the argument is an array.

• Errors do not propagate through this function. ISERROR is one of the declared per-family exceptions to the propagation discipline in coercion and lifting: the error is the subject of the test, not a failure to forward. An error input yields TRUE, never the error itself.
• Empty cells are FALSE. Empty is not an error kind.
• Text, numbers, logicals, references are all FALSE.

Errors

Microsoft's IS-functions page documents no error return for ISERROR.

How to implement

Notes for implementers

1. Do not implement ISERROR as a list membership test against the seven legacy codes. A list will silently return FALSE for #SPILL! and #CALC! on a modern build. Test the kind. Then record, separately and honestly, whether Excel agrees — that is a measurement, not a design decision.
2. The error must reach the kernel. Any layer that short-circuits on an error input before dispatch will make ISERROR return the error instead of TRUE. The propagation exception has to be declared at the function, not hoped for.
3. ISERROR and ISNA classify arrays elementwise while some sibling predicates route through a generic lift path. They reach the same shape, but the two routes are not the same code, so an array-shape divergence would show up in one and not the other. Test both.
4. Do not confuse the C-API error enumeration with the worksheet code set. The extended family does not map one-to-one onto the legacy enumerations, and whether a code survives a boundary crossing is a per-code, per-version fact.

Rust code

unary(ISERROR, "ISERROR", VALUE, iserror)

/// ISERROR: TRUE for every worksheet error, the newer ones as ISERR reads them.
fn iserror(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    predicate(ISERROR, arguments, services, known, |core| {
        matches!(core, CoreRef::Error(_))
    })
}

No implementation has been published with a Handbook test suite for this function.

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

The record contains no same-input comparison between these environments. Reading different inputs on different builds does not establish either a version change or cross-build agreement.

Recorded environments and comparison details.

Alternatives

Relationships

This is the classic Excel trap, and it is worth stating in one line before anything else:

ISERROR is TRUE for #N/A. ISERR is FALSE for #N/A. ISNA is TRUE only for #N/A.

Which means, over the Error kind, ISERROR = ISERR OR ISNA, and the three functions partition the error space into exactly the two halves that matter in practice: the lookup found nothing (#N/A) versus the formula is broken (everything else).

• ISERR — use it when a missing lookup is a legitimate outcome you want to let through while still catching genuine faults. Using ISERROR there silently swallows the "not found" signal, and that is how bad numbers get published.
• ISNA — the narrow test; the complement of ISERR within the error kind.
• IFERROR(x, y) supersedes the IF(ISERROR(x), y, x) idiom, evaluates x once, and is the modern form. IFNA(x, y) is the #N/A-only counterpart, paired with ISNA the way IFERROR is paired with ISERROR.
• ERROR.TYPE answers which error rather than whether; it returns a code 1–8 for an error input and #N/A for anything else.
• AGGREGATE with the appropriate option skips errors during a scan instead of testing them — the other declared way to mask errors named in coercion and lifting.

Named variants

No named variants are recorded yet.