ISERR

What it does

ISERR(value)

ISERR(value) returns TRUE when the value it receives has kind Error and its code is not #N/A. Everything else — including #N/A itself — is FALSE.

Microsoft states it as "Value refers to any error value except #N/A." It is the only member of the IS family whose definition is a set difference rather than a kind membership, and that single exclusion is the whole reason the function is in the product.

The exclusion encodes a semantic distinction Excel makes everywhere else too: #N/A means the value is not available — a legitimate, expected outcome of a lookup that found nothing — while the other error codes mean this formula is wrong. ISERR is the predicate that asks "is something broken?" without treating a legitimately absent value as breakage.

Formally, over the Error kind:

ISERR(v)   = ISERROR(v) AND NOT ISNA(v)
ISERROR(v) = ISERR(v) OR ISNA(v)

and ISERR, ISNA partition the error kind into two disjoint halves.

Arguments

value — required, exactly one.

Not converted. Microsoft's IS-functions remark is explicit: "The value arguments of the IS functions are not converted." A cell containing the text #N/A (entered as text, or produced by TEXT/&) is Text, not Error, and ISERR returns FALSE for it — as does ISERROR, and as does ISNA. If a workbook is behaving as though its errors were invisible to these predicates, the first thing to check is whether they are errors at all or strings that look like them.

Try it

Quirks

Result and edge cases

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

• #N/A is FALSE. This is not an edge case, it is the definition, and it is the single fact readers come to this page for.
• Errors do not propagate. ISERR is one of the declared per-family exceptions to error propagation (coercion and lifting): an error argument is classified, not forwarded.
• Arrays are classified elementwise; the result is an array of the same shape.
• Empty, Text, Number, Logical, Reference are all FALSE.
• Extended error codes. Whether ISERR answers TRUE for #SPILL!, #CALC!, #FIELD!, #BLOCKED! or #CONNECT! is not established here. The exclusion is written against #N/A alone, so the kind-membership reading predicts TRUE for all of them, but that prediction has not been measured and Microsoft's sentence — which enumerates only the legacy seven for ISERROR — does not address it.

Errors

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

How to implement

Notes for implementers

1. Implement the exclusion at the code level, not by string comparison of a rendered error. Error display text is localized in some surfaces; the code is not.
2. Test ISERR and ISERROR against the same error corpus in the same run. The two functions differ by exactly one row, and a bug that gets #N/A wrong in one of them is invisible if the two are tested separately with different inputs.
3. The error must reach the kernel. A dispatch layer that short-circuits on error inputs makes ISERR return the error instead of a Logical. The propagation exception has to be declared at the function.
4. When adding a new error code to an engine, ISERR needs a deliberate decision, not a default. Any code that is not #N/A falls into ISERR's TRUE half automatically under the kind-membership reading — which may or may not be what Excel does for the transient placeholder codes.

Rust code

unary(ISERR, "ISERR", VALUE, iserr)

/// ISERR: TRUE for every worksheet error but #N/A. Microsoft's page names no error; Excel gives
/// TRUE for #GETTING_DATA, #CALC!, #FIELD!, #SPILL! and #BUSY! too.
fn iserr(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    predicate(
        ISERR,
        arguments,
        services,
        known,
        |core| matches!(core, CoreRef::Error(code) if code != WorksheetErrorCode::NA),
    )
}

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

ISERR exists only in contrast, so the contrast is the section:

• Choosing between ISERR and ISERROR is a semantic decision, not a style one. Wrapping a lookup in IFERROR or ISERROR converts "not found" into whatever fallback you supplied, which is often exactly wrong: a missing customer becomes a zero, and the zero is then summed. ISERR (or IFNA, or ISNA) keeps "not found" visible.
• IFNA(x, y) is the modern branch form for the #N/A-only case; there is no built-in IFERR that corresponds to ISERR, so IF(ISERR(x), y, x) remains the idiom when you genuinely want "handle faults, let #N/A through" — at the cost of evaluating x twice.
• ERROR.TYPE gives the code number instead of a two-way split; ERROR.TYPE(v) <> 7 is another way to write the ISERR condition, though it errors rather than returning FALSE on non-error input.
• NA() is the function that manufactures the value ISERR is defined to ignore.

Named variants

No named variants are recorded yet.