TypeScript NonNullable Utility Type

`NonNullable< T >` removes `null` and `undefined` from type `T`, leaving only valid values.

Basic Usage

type MaybeString = string | null | undefined;
  
  let value1: MaybeString = "hello";
  value1 = null;         // OK
  value1 = undefined;    // OK
  
  type NonNullString = NonNullable<MaybeString>;
  
  let value2: NonNullString = "world";
  // value2 = null;      // Error: Type 'null' is not assignable
  // value2 = undefined; // Error: Type 'undefined' is not assignable

From `string | null | undefined`, `NonNullable` creates safer types by excluding `null` and `undefined`.

Using in Functions

function processValue(value: string | null | undefined) {
    if (value == null) {
      console.log("Value is null or undefined");
    } else {
      // After check, 'value' is string (non-nullable)
      const trimmed = value.trim();
      console.log(trimmed);
    }
  }
  
  function processNonNullValue(value: NonNullable<string | null | undefined>) {
    // No need to check for null or undefined here
    const trimmed = value.trim();
    console.log(trimmed);
  }

Using `NonNullable` on function parameters eliminates null checks, allowing direct usage of valid types.

Applying to Object Properties

type OptionalUser = {
    name?: string | null;
    age?: number | null;
  };
  
  type RequiredUser = {
    [K in keyof OptionalUser]: NonNullable<OptionalUser[K]>;
  };
  
  const user1: OptionalUser = { name: null, age: 25 };
  // const user2: RequiredUser = { name: null, age: 25 }; // Error: name cannot be null

Optional or nullable fields can be converted to required, non-nullable fields using `NonNullable`.

Why Use NonNullable?

`NonNullable` improves type safety, reduces unnecessary null checks, and helps write cleaner, error-free code.