Türden tek bir özelliği çıkarmak istiyorum. Bunu nasıl yapabilirim?

Örneğin bende var

interface XYZ {
  x: number;
  y: number;
  z: number;
}

Ve mülkiyeti zalmak için dışlamak istiyorum

type XY = { x: number, y: number };

TypeScript sürümleri 3.5 veya üstü için

TypeScript 3.5'te, Omittür standart kitaplığa eklenmiştir. Nasıl kullanılacağını öğrenmek için aşağıdaki örneklere bakın.

TypeScript'in 3.5'in altındaki sürümleri için

TypeScript 2.8'de Excludetür, standart kitaplığa eklenmiştir ve bu, bir ihmal türünün basitçe şu şekilde yazılmasına olanak tanır:

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

TypeScript'in 2.8'in altındaki sürümleri için

ExcludeTürü 2.8'in altındaki sürümlerde kullanamazsınız , ancak yukarıdaki ile aynı türden tanımlamayı kullanmak için onun yerine bir yedek oluşturabilirsiniz. Bununla birlikte, bu değiştirme yalnızca dizge türleri için işe yarayacaktır, bu nedenle Exclude.

// Functionally the same as Exclude, but for strings only.
type Diff<T extends string, U extends string> = ({[P in T]: P } & {[P in U]: never } & { [x: string]: never })[T]
type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>

Ve kullanımda olan bu türün bir örneği:

interface Test {
    a: string;
    b: number;
    c: boolean;
}

// Omit a single property:
type OmitA = Omit<Test, "a">; // Equivalent to: {b: number, c: boolean}

// Or, to omit multiple properties:
type OmitAB = Omit<Test, "a"|"b">; // Equivalent to: {c: boolean}

TypeScript 2.8 ile yeni yerleşik Excludetürü kullanabilirsiniz. 2.8 sürüm notları aslında bölümünde "Önceden tanımlanmış koşullu türleri" bu söz:

Not: Hariç tutma türü, burada önerilen Diff türünün uygun bir uygulamasıdır. [...] Olarak önemsiz şekilde yazıldığı için Atlama türünü dahil etmedik Pick<T, Exclude<keyof T, K>>.

Bunu örneğinize uygularsanız, XY türü şu şekilde tanımlanabilir:

type XY = Pick<XYZ, Exclude<keyof XYZ, "z">>

Bazı değişkenleri bildirmek ve türü çıkarmak için yayılma operatörünü kullanmakla çözüm buldum :

interface XYZ {
  x: number;
  y: number;
  z: number;
}

declare var { z, ...xy }: XYZ;

type XY = typeof xy; // { x: number; y: number; }

Çalışıyor, ancak daha iyi bir çözüm görmekten memnuniyet duyarım.

İçinde 3.5+ typescript :

interface TypographyProps {
    variant: string
    fontSize: number
}

type TypographyPropsMinusVariant = Omit<TypographyProps, "variant">

Kitaplık kullanmayı tercih ediyorsanız, ts-essentials kullanın .

import { Omit } from "ts-essentials";

type ComplexObject = {
  simple: number;
  nested: {
    a: string;
    array: [{ bar: number }];
  };
};

type SimplifiedComplexObject = Omit<ComplexObject, "nested">;

// Result:
// {
//  simple: number
// }

// if you want to Omit multiple properties just use union type:
type SimplifiedComplexObject = Omit<ComplexObject, "nested" | "simple">;

// Result:
// { } (empty type)

Not: Orada pek çok yararlı şey bulacaksınız;)

Typescript 3.5

Typescript 3.5'ten itibaren, Atlama yardımcısı dahil edilecektir: TypeScript 3.5 RC - Atlama Yardımcı Türü

Doğrudan kullanabilirsiniz ve güncelleme sırasında kendi Atlama yardımcısı tanımınızı kaldırmanız gerekir.

Çıkarmak

tek mülk

type T1 = Omit<XYZ, "z"> // { x: number; y: number; }

birden çok özellik

type T2 = Omit<XYZ, "y" | "z"> // { x: number; } 

şartlı özellikler

type Keys_StringExcluded<T> = { [K in keyof T]: T[K] extends string ? never : K }[keyof T]

type XYZ = { x: number; y: string; z: number; }
type T3a = Pick<XYZ, Keys_StringExcluded<XYZ>> // { x: number; z: number; }

type T3b = { [K in keyof XYZ as XYZ[K] extends string ? never : K]: XYZ[K] } 
// { x: number; z: number; }

stringdesene göre özellikler

type OmitGet<T> = { [K in keyof T as K extends `get${infer _}` ? never : K]: T[K] }

type XYZ2 = { getA: number; b: string; getC: boolean; }
type T4 = OmitGet<XYZ2> //  { b: string; }

Not: Yukarıdaki şablon değişmez türleri TS 4.1 ile desteklenir

Oyun alanı örneği

Bunu beğendim:

interface XYZ {
  x: number;
  y: number;
  z: number;
}
const a:XYZ = {x:1, y:2, z:3};
const { x, y, ...last } = a;
const { z, ...firstTwo} = a;
console.log(firstTwo, last);