从类型的属性中删除 null 或未定义的

我需要声明一个类型，以便从其属性类型中移除未定义的类型。

假设我们有:

type Type1{
prop?: number;
}


type Type2{
prop: number | undefined;
}


type Type3{
prop: number;
}

我需要定义一个名为 NoUndefinedField<T>的泛型类型，使得 NoUndefinedField<Type1>提供与 Type3相同的类型和与 NoUndefinedField<Type2>相同的类型。

我试过了

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

但它只适用于 Type2。

50224 次浏览
小开
最佳答案

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

小开

Use the NonNullable built-in type:

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

See TypeScript: Documentation - Utility Types

小开

@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 }
小开

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>;
};
小开

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

小开

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


提交答案