TypeScript notation for both "is object" and non-null

Question

I have a utility function like this, mainly to get around the annoyance that typedef null is 'object'.

export function isObject(a: any): a is object {
  return a && (typeof a === 'function' || typeof a === 'object');
}

Instead of declaring the return type of this function boolean, you can use a is object, which is essentially a boolean too, but it assists type inference so that TypeScript knows that, if this function is true, a can be treated as an object without further type checking or casting.

I'd like to additionally declare that a is not null, but I can't find syntax that works.

export function isObject(a: any): a is NonNullable<object> {
  return a && (typeof a === 'function' || typeof a === 'object');
}

This at least has the advantage that it parses, but it doesn't help TypeScript infer that a is non-null.

I've tried other things that don't parse, like a is object & !null or a is object & null: never -- none of things work.

Is there a way to declare what I want to declare?

Answer 1

With --strictNullChecks turned off, there's no way to have the compiler help you guard against null or undefined, since any possibly-null value will be treated the same as if it were non-null:

function foo(x: {a: string} | null) {
  x.a.toUpperCase(); // error if and only if --strictNullChecks is enabled
}

So the only way to proceed is to turn --strictNullChecks on so that the compiler can actually tell the difference between null and non-null values. I will assume from here on out that this is the case.

---

The type guard function you are using is already guarding against null by returning a is object. The object type in TypeScript (which starts with a lowercase o, not to be confused with the Object type) refers only to non-null and non-undefined object types:

const bar: object = null; // error!
//    ~~~ <-- null is not assignable to object

Please note the difference between the string "object" returned by the JavaScript typeof operator at runtime and the TypeScript type object. At runtime, typeof null returns "object", whereas in the type system typeof null is null, not object. It's potentially confusing because identical or similar identifiers can mean quite different things depending on whether you are looking at values or types. You can read one of my other diatribes answers for more details about that.

---

Again, if --strictNullChecks is enabled, the object type already excludes null. Therefore you should be able to just use your original type guard function returning a is object. Here's an example:

function baz(x: {a: string} | null) {
  if (isObject(x)) {
    x.a.toUpperCase(); // no error now
  } else {
    const y: null = x; // also no error
  }
}

Playground link to code

Answer 2

Here's a way using Exclude with a generic type parameter:

function nonNullObject<T>(x: T): x is Exclude<T, null | undefined> & object {
    return x && (typeof x === 'object' || typeof x === 'function');
}

Example usage: inside the if statement, number and null are eliminated from the type of x by control-flow type narrowing.

declare let x: Record<string, number> | number | null;

if(nonNullObject(x)) {
    x // Record<string, number>
}

Playground link

Answer 3

I finally found notation that does what I want:

export function isObject(a: any): a is Record<string | number | symbol, any> {
  return a && (typeof a === 'function' || typeof a === 'object');
}

Not only does this express the non-nullness of a when the function returns true, but it allows me to access arbitrary properties on a without getting errors that the properties don't exist, which happens with a is object as the function return type.

if (isObject(a)) {
  console.log(a.foo); // No error that property `foo` doesn't exist on `a`
}