如何在 Typescript 中返回 NonNullable 类型？

Question

I have code similar to the following:

interface Stuff {
  foo: number | null;
  bar: string | null;
}

let stuff: Stuff;

function getStuff(): Stuff;
function getStuff<K extends keyof Stuff>(key: K): NonNullable<Stuff[K]>;
function getStuff<K extends keyof Stuff>(key?: K): Stuff | NonNullable<Stuff[K]> {
  if (key == null)
    return stuff;

  const value = stuff[key];
  if (value == null)
    throw new Error(`${key} is null`);

  return value;
}


const myStuff = getStuff('foo');

Clearly, when you get to the last line of getStuff , value cannot be null or undefined there, but Typescript gives this error:

Type 'Stuff[K]' is not assignable to type 'Stuff | NonNullable<Stuff[K]>'.
  Type 'string | number | null' is not assignable to type 'Stuff | NonNullable<Stuff[K]>'.
    Type 'null' is not assignable to type 'Stuff | NonNullable<Stuff[K]>'.
      Type 'Stuff[K]' is not assignable to type 'Stuff'.
        Type 'string | number | null' is not assignable to type 'Stuff'.
          Type 'null' is not assignable to type 'Stuff'.(2322)

If I remove NonNullable , then it works correctly, but of course myStuff will then require a null check instead, which is what I'm trying to avoid here. Ie I know value cannot be null here, but how do I properly let Typescript know that, without "cheating", eg via return value! ?

---

Typescript Playground

---

Solution based on accepted answer

Ended up adding the following util to our project, with the assertions and a helper type (so we can write Null instead of null | undefined a bunch of places in our code)

// util/null
type Null = null | undefined;

export default Null;

export function isNotNull<T>(value: T)
: value is NonNullable<T> {
  return value != null;
}

export function assertNotNull<T>(value: T, throwError: (value: T) => never)
: asserts value is NonNullable<T> {
  if (value == null) throwError(value);
}

Answer 1

You can just simply do type assertion - return value as NonNullable<Stuff[K]> , or introduce the custom type guard.

The issue you are facing is that TS is not narrowing your control flow null check to NonNullable , but by custom type guard you can force it. Consider:

// type guard narrows to NonNullable
function isNonNullable<T>(a: T): a is NonNullable<T> {
  return a !== null
}
function getStuff(): Stuff;
function getStuff<K extends keyof Stuff>(key: K): NonNullable<Stuff[K]>;
function getStuff<K extends keyof Stuff>(key?: K): Stuff | NonNullable<Stuff[K]> {
  if (key == null)
    return stuff;

  const value = stuff[key];
  if (isNonNullable(value)) {
    return value;
  }
  throw new Error(`${key} is null`);
}

Pay attention that isNonNullable is generic type-guard which you can use with any other value.

---

Reversed condition will also work correctly:

if (!isNonNullable(value)) {
  throw new Error(`${key} is null`);
}
return value;