ISNONTEXT

What it does

ISNONTEXT(value)

ISNONTEXT(value) returns TRUE when the value it receives does not have kind Text, and FALSE when it does.

Microsoft states it as "Value refers to any item that is not text", and adds a parenthetical that carries more weight than its size suggests: "(Note that this function returns TRUE if the value refers to a blank cell.)"

That note is the page. ISNONTEXT is a negation, so it inherits everything the Text kind excludes:

The trap is reading ISNONTEXT as "has a proper value in it". It does not mean that. It is TRUE for a blank cell and TRUE for #REF!, which are two of the least value-bearing things a cell can hold.

Arguments

value — required, exactly one.

Not converted. Microsoft's remark: "The value arguments of the IS functions are not converted." Since ISNONTEXT is defined by negating a kind test, non-conversion means the negation is over the kind delivered, not over any parse attempt.

Try it

Quirks

Result and edge cases

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

• A blank cell is TRUE. Documented by Microsoft in the function table itself, so this is not an inference.
• The zero-length string is FALSE, because it is Text. ISNONTEXT("") and ISNONTEXT(<blank cell>) therefore disagree — the pair is a compact way to distinguish Empty from Text("") without using ISBLANK.
• Errors are TRUE and do not propagate. ISNONTEXT is one of the declared per-family exceptions to the propagation discipline in coercion and lifting. An error input is classified, not forwarded — which means ISNONTEXT(#VALUE!) is the Logical TRUE, not #VALUE!.
• Arrays are classified elementwise into a same-shaped mask.

Errors

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

How to implement

Notes for implementers

1. Derive it from ISTEXT. One predicate, one negation. Writing ISNONTEXT independently guarantees an eventual divergence on some kind added later — and the divergence will be silent, because both functions return a plausible boolean either way.
2. Include Empty on the TRUE side deliberately, with the Microsoft parenthetical cited in the code comment. It looks like a bug to anyone reading the implementation cold, and someone will eventually "fix" it.
3. Errors must reach the kernel, or ISNONTEXT will forward the error instead of returning TRUE.
4. Reference arguments. ISNONTEXT sees values, not references, so the Reference row above is reachable only through a path that hands the function an unresolved reference — which values-only preparation is supposed to prevent. If it happens, something upstream is wrong.

Rust code

unary(ISNONTEXT, "ISNONTEXT", VALUE, isnontext)

/// ISNONTEXT: TRUE for anything but text: a blank cell and an error included.
fn isnontext(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    predicate(ISNONTEXT, arguments, services, scalar, |core| {
        !matches!(core, CoreRef::Text(_))
    })
}

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

• ISTEXT is the exact complement, and the two should always be thought of as one function with a sign. If you find yourself writing NOT(ISTEXT(x)), write ISNONTEXT(x); if you find yourself writing NOT(ISNONTEXT(x)), write ISTEXT(x).
• ISBLANK overlaps but is far narrower: ISBLANK is TRUE only for Empty, whereas ISNONTEXT is TRUE for Empty and five other kinds. ISNONTEXT is not a blank test, despite the parenthetical that makes it look like one.
• ISNUMBER is what people usually mean when they reach for ISNONTEXT. If the question is "is this a usable number?", ISNUMBER is the predicate; ISNONTEXT will happily say TRUE about #DIV/0!.
• T(value) returns the empty string for exactly the values ISNONTEXT calls TRUE.
• TYPE distinguishes what ISNONTEXT lumps together: 1 number, 4 logical, 16 error, 64 array. If you need to know which non-text thing you have, TYPE is the function.

Named variants

No named variants are recorded yet.