Heim >Web-Frontend >js-Tutorial >Optional vs. undefiniert: So prüfen Sie, ob optionale Eigenschaften vorhanden sind
In TypeScript gilt eine Eigenschaft als optional, wenn sie in einem Objekt weggelassen werden kann, was bedeutet, dass sie entweder undefiniert oder überhaupt nicht bereitgestellt werden kann. Optionale Eigenschaften werden mit dem ? gekennzeichnet. Suffix auf dem Eigenschaftsschlüssel. Es kann ziemlich schwierig sein, festzustellen, ob eine Eigenschaft optional oder explizit mit undefiniert als Typ definiert ist.
Betrachten wir das folgende Beispiel mit fünf möglichen Kombinationen:
type Example = { required: number; optional?: number; requiredAsUndefined: undefined; requiredWithUndefined: number | undefined; optionalWithUndefined?: number | undefined; }
Die letzten vier Eigenschaften dürfen undefiniert sein, aber nur die zweite und fünfte sind tatsächlich optional. Interessanterweise werden die Eigenschaften „optional“, „requiredWithUndefined“ und „optionalWithUndefined“ alle in die gleiche Union-Typ-Nummer | aufgelöst undefiniert.
Was wir also wollen, ist ein Typ, der für optional und optionalWithUndefiniert „true“ und für den Rest „false“ zurückgibt. So kann ein solcher Dienstprogrammtyp aussehen:
type IsOptional<T, K extends keyof T> = undefined extends T[K] ? ({} extends Pick<T, K> ? true : false) : false; type Required = IsOptional<Example, 'required'>; // false type Optional = IsOptional<Example, 'optional'>; // true type RequiredAsUndefined = IsOptional<Example, 'requiredAsUndefined'>; // false type RequiredWithUndefined = IsOptional<Example, 'requiredWithUndefined'>; // false type OptionalWithUndefined = IsOptional<Example, 'optionalWithUndefined'>; // true
Bei diesem Dienstprogrammtyp gibt es zwei Einschränkungen. Die erste Einschränkung, undefiniert erweitert T[K], prüft, ob undefiniert Teil des Typs sein kann, auf den T[K] zugreift. Im Wesentlichen wird gefragt, ob der Typ T[K] undefiniert enthalten kann. Die zweite Einschränkung {} erweitert Pick
Aus diesem Dienstprogrammtyp können wir einen neuen zugeordneten Typ erstellen, der nur optionale Eigenschaften auswählt. Die nicht optionalen Eigenschaften werden auf nie gesetzt:
type OptionalProperties<T> = { [K in keyof T]: IsOptional<T, K> extends true ? T[K] : never } type OnlyOptionals = OptionalProperties<Example>; // type OnlyOptionals = { // required: never; // optional?: number; // requiredAsUndefined: never; // requiredWithUndefined: never; // optionalWithUndefined?: number | undefined; // }
Für die Typsicherheit reicht es normalerweise aus, die Eigenschaften mit dem Typ nie zu haben, aber falls wir diese Eigenschaften aus stilistischen Gründen wirklich weglassen möchten, können wir die IsOptional
type OnlyOptionals<T> = { [K in keyof T as IsOptional<T, K> extends true ? K : never]: T[K] } type OnlyOptionals = OnlyOptionals<Example>; // type OnlyOptionals = { // optional?: number; // optionalWithUndefined?: number | undefined; // }
Hier ist der Playground zum Ausprobieren direkt im Browser: TypeScript Playground
Das obige ist der detaillierte Inhalt vonOptional vs. undefiniert: So prüfen Sie, ob optionale Eigenschaften vorhanden sind. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!