NA

What it does

NA()

NA() returns the error value #N/A. That is the entire specification.

The reason it exists is that #N/A in Excel does not mean "something went wrong". It means value not available — a first-class statement about data. Writing NA() into a cell is a deliberate assertion that the number belongs there but is not known, and it has two concrete consequences that a blank or a zero does not:

1. It propagates. Any formula that consumes the cell inherits #N/A, so a total computed from incomplete data announces its incompleteness instead of quietly under-reporting.
2. Charts skip it. A data point of #N/A is omitted from a line rather than plotted at zero, which is the difference between a gap in a series and a spike to the axis.

Zero lies, blank is ambiguous, NA() is honest. That is the design.

Arguments

None. The signature is NA(), arity exactly zero.

The empty parentheses are required — the name NA on its own is a defined-name reference, not a function call, and will produce #NAME? if no such name exists. This is the same rule that applies to TRUE(), TODAY() and RAND(), but NA is the one people most often type without parentheses, because #N/A is what they are thinking of and it has no parentheses in it.

Supplying an argument is an arity failure; see "Errors".

Try it

NA deliberately returns the #N/A worksheet error.

Quirks

Result and edge cases

Returns the Error value #N/A, always, on every call.

• It is a value, not an exception. #N/A flows through arithmetic and function calls like any other scalar (the value universe); nothing is thrown and nothing is caught.
• Deterministic and non-volatile. NA() does not force recalculation and does not depend on the calling cell — unlike CELL or INFO, the other members of the Information category that take little or no input.
• In array formulas it is a scalar and broadcasts like any constant.
• Typing #N/A directly into a cell is a recognised way to enter the same value in Excel's user interface; NA() is the formula form. Whether the two produce values that are equal in every respect has not been checked here, though the value model offers no way for them to differ.

Errors

NA() returns an error by design; it does not fail.

Note the distinction the Handbook keeps: #N/A as the result of NA() is success. #VALUE! from NA(1) is failure. Two error values, two entirely different meanings, in the same function's row.

How to implement

Notes for implementers

1. NA() is a constant kernel, so it needs no evaluation context, no resolver and no host. An engine that routes it through a general dispatch path with argument preparation is doing work that cannot affect the answer.
2. Arity zero, exactly. Minimum and maximum are both 0. A function whose declared arity is "at most zero" and whose battery cannot express "no arguments" will produce a confusing row; this is a known shape wrinkle in mechanical probing, not a behaviour.
3. NA() must not be optimised into a blank or a zero by any constant-folding pass; the error value is the result.

Rust code

CatalogueEntry {
    id: NA,
    spelling: "NA",
    notation: Notation::Call,
    arity: CallableArityShape::exact(0),
    parameters: &[],
    demand: ArgumentDemand::Eager,
    kernel: Kernel::Eager(na),
}

/// NA: the error #N/A. It takes no argument; the arity refuses any.
fn na(_: &[CalcValue], _: &mut EvalServices<'_>) -> Result<CalcValue, FunctionFault> {
    Ok(CalcValue::error(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

• ISNA is the predicate that tests for exactly what NA() produces. ISNA(NA()) is TRUE, and it is the one-line smoke test for both functions.
• IFNA(value, value_if_na) is the modern branch on this value, and IFERROR is the broader one that also catches everything else. If a workbook deliberately writes NA() to mark missing data, wrapping downstream formulas in IFERROR destroys the signal; IFNA is not the culprit because it at least catches only the intended value, but the same caution applies.
• ISERR deliberately excludes #N/A, which is the complement of what NA() does: NA() makes the value that ISERR is defined to ignore.
• ERROR.TYPE(NA()) is 7.
• NA() versus a blank cell is a modelling choice. A blank is skipped by aggregates and treated as zero in scalar arithmetic; NA() stops the aggregate. If a total must not be published from incomplete inputs, NA() is the mechanism.
• XLOOKUP's if_not_found and VLOOKUP's natural #N/A are the functions that produce this value without being asked; NA() is how you produce it on purpose.

Named variants

No named variants are recorded yet.