remove null or undefined from properties of a type

Question

I need to declare a type such that removes the undefined from its property types.

Suppose we have:

type Type1{
  prop?: number;
}

type Type2{
  prop: number | undefined;
}

type Type3{
  prop: number;
}

I need to define a generic type called NoUndefinedField<T> such that NoUndefinedField<Type1> gives the same type as Type3 and the same type as NoUndefinedField<Type2>.

I tried this

type NoUndefinedField<T> = { [P in keyof T]: Exclude<T[P], null | undefined> };

But it only works for Type2.

For Type1 you need [to remove optional modifier](https://stackoverflow.com/questions/49655419/mapped-types-removing-optional-modifier) — artem, Oct 29 '18 at 16:55

score 225 · Answer 1 · edited Dec 03 '22 at 09:33

225

Use the NonNullable built-in type:

type NonNullable<T> = Exclude<T, null | undefined>;  // Remove null and undefined from T

See TypeScript: Documentation - Utility Types

edited Dec 03 '22 at 09:33

Boris Verkhovskiy

14,854
11
100
103

answered Feb 01 '19 at 16:34

DShook

14,833
9
45
55

So sad that it does not exclude `null` from the type if you don't have `--strictNullChecks` enabled... – Klesun Mar 02 '21 at 13:49
5

Downvoted because this removes `null` and `undefined` from the type itself, not from its properties, does it? Hence it does not answer the question. – zbr Dec 13 '22 at 11:53
Indeed! https://www.typescriptlang.org/play?#code/JYOwLgpgTgZghgYwgAgJLIN4Chm+XALmRAFcBbAI2mQB9iSAbBgbhzwqIGcwpQBzWshIgAJhBigII1nmQIA-EQoB7ZQwhwQrAL5YsYAJ4AHFADllAVVHjJIgGLAIDEQB4AKgD5kAXkzIA2gAKyKDIANYQBsowyG4AugC0isjmVmISIFIOTq7mIKaMDHAU6u5BcR5e2qxYCMog3PhEAKIAHggMJGIuqAA09EyCwum2Xr7YsoQDDL1suBzIAESLs7IIRDwkELO6tfWNC3kFTMWlqGOYc03Tq+xEy7e468ib21i7dQ1gckSp1hlZRzOHoXCZ4KakJiPZALB5XZ6vHZYIA – Antoine Dec 16 '22 at 10:47

score 61 · Accepted Answer · edited Aug 02 '19 at 09:15

61

Thanks to @artem, the solution is:

type NoUndefinedField<T> = { [P in keyof T]-?: NoUndefinedField<NonNullable<T[P]>> };

Notice the -? syntax in [P in keyof T]-? which removes optionality

edited Aug 02 '19 at 09:15

Simon_Weaver

140,023
84
646
689

answered Oct 29 '18 at 17:12

Fartab

4,725
2
26
39

This is exactly the answer I expected, filtering an existing interface. Thank you! – Lancer.Yan Aug 21 '20 at 09:36
Thank you very much. I was wondering what does the `-?`. Where did you find this specification? I always read the documentation of TS first, but I think that there isn't easy to find stuff. – Nikolas Freitas Mr Nik Nov 19 '20 at 17:50
Hi Nikolas. Yeah, that was hard to find. Two year ago, @artem told me such an operator exists. – Fartab Nov 20 '20 at 23:40
There is something missing, I get `Type 'NoUndefinedField' is missing the following properties from type 'Uint8Array': [Symbol.iterator], [Symbol.toStringTag]` -- this one worked: https://stackoverflow.com/a/61766383/544779 – Mörre Apr 07 '21 at 14:40

score 16 · Answer 3 · answered Mar 06 '22 at 19:39

16

Nowadays you can use Required to do exactly what you need:

Required<Type1>

That will result in all the fields becoming non-optional. More details can be found here

answered Mar 06 '22 at 19:39

Parsa Nasirimehr

362
2
6

score 13 · Answer 4 · answered Jul 20 '19 at 05:02

@DShook's answer is incorrect (or rather incomplete) because the OP is asking to remove null and undefined from the types properties, not from the type itself (a distinct difference).

While @Fartab's answer is correct, I'll add to it, as there is now the built-in Required type, and the solution can be re-written as:

type RequiredProperty<T> = { [P in keyof T]: Required<NonNullable<T[P]>>; };

This will map the types properties (not the type itself), and ensure that each one is neither; null or undefined.

An example of the difference between removing null and undefined from the type, versus removing them from a types properties (using the above RequiredProperty type):

type Props = {
  prop?: number | null;
};

type RequiredType = NonNullable<Props>; // { prop?: number | null }
type RequiredProps = RequiredProperty<Props>; // { prop: Required<number> } = { prop: number }

The re-written solution won't be recursive though, will it? – Qwerty Aug 21 '19 at 14:14 — Qwerty, Aug 21 '19 at 14:14

score 12 · Answer 5 · answered Mar 07 '20 at 04:39

Something in both @Fartab's and @tim.stasse's answers is messing up a property of type Date for me:

// both:
type NoUndefinedField<T> = {
  [P in keyof T]-?: NoUndefinedField<NonNullable<T[P]>>;
};
type NoUndefinedField<T> = {
  [P in keyof T]-?: NoUndefinedField<Exclude<T[P], null | undefined>>;
};
// throw:
Property '[Symbol.toPrimitive]' is missing in type 'NoUndefinedField<Date>' but required in type 'Date'.ts(2345)
// and
type NoUndefinedField<T> = { [P in keyof T]: Required<NonNullable<T[P]>> };
// throws:
Property '[Symbol.toPrimitive]' is missing in type 'Required<Date>' but required in type 'Date'.ts(2345)

I'm having success with this solution without recursion:

type NoUndefinedField<T> = {
  [P in keyof T]-?: Exclude<T[P], null | undefined>;
};

Thanks, this works well. I was having problems using the other answers as well when having user defined types for properties. — Krisztián Balla, Nov 05 '21 at 17:57

score 5 · Answer 6 · answered Jan 14 '22 at 18:07

Some of the answers were not working for me, I ended up with a similar solution based on the top answers:

type RequiredNonNullableObject<T extends object> = { [P in keyof Required<T>]: NonNullable<T[P]>; };

This results in the following:

type ObjectType = {

  startDateExpr?: string | null;
  endDateExpr?: string | null;

  startDate?: Date | null;
  endDate?: Date | null;

}

type Result = RequiredNonNullableObject<ObjectType>;

With the Result type being equal to:

type Result = {
  startDateExpr: string;
  endDateExpr: string;
  startDate: Date;
  endDate: Date;
}

TypeScript Playground Example

I was looking for a solution to make all properties of a type non-nullable. This works, thanks — Tris, Jun 15 '22 at 06:57

Jerboas86 · Answer 7 · 2023-04-18T08:04:16.230

1

The following utility type will:

Remove optional property modifier (?) from each field
Remove null and undefined from each field
Accept only object type

type RequiredProperty<T extends object> = { [P in keyof T]-?: Required<NonNullable<T[P]>>; };

Typescript playground

edited Apr 18 '23 at 08:04

answered Apr 18 '23 at 07:19

Jerboas86

596
4
12

I like this one. It takes the best parts of all the other answers. It even covers the distinction between an optional property (`?`) and `| undefined` in a type (removes both) which is helpful if you have the `exactOptionalPropertyTypes` TS config option turned on. – RcoderNY Aug 21 '23 at 02:33

remove null or undefined from properties of a type

7 Answers7