Tôi muốn loại trừ một thuộc tính duy nhất khỏi loại. Làm thế nào tôi có thể làm điều đó?

Ví dụ tôi có

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

Và tôi muốn loại trừ tài sản zđể có được

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

Đối với các phiên bản TypeScript ở mức hoặc trên 3,5

Trong TypeScript 3.5, Omitloại đã được thêm vào thư viện chuẩn. Xem các ví dụ dưới đây để biết cách sử dụng nó.

Đối với các phiên bản TypeScript dưới 3,5

Trong TypeScript 2.8, Excludeloại đã được thêm vào thư viện chuẩn, cho phép loại bỏ sót được viết đơn giản là:

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

Đối với các phiên bản TypeScript dưới 2.8

Bạn không thể sử dụng Excludeloại trong các phiên bản dưới 2.8, nhưng bạn có thể tạo một thay thế cho nó để sử dụng cùng một định nghĩa như trên. Tuy nhiên, sự thay thế này sẽ chỉ hoạt động đối với các loại chuỗi, vì vậy nó không mạnh bằng 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>>

Và một ví dụ về loại đang sử dụng:

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}

Với bản in 2.8, bạn có thể sử dụng loại tích hợp mới Exclude. Các ghi chú 2.8 phát hành thực sự đề cập đến điều này trong phần "định trước loại có điều kiện":

Lưu ý: Loại Loại trừ là cách triển khai đúng loại Diff được đề xuất ở đây. [...] Chúng tôi không bao gồm loại Omit vì nó được viết một cách tầm thường là Pick<T, Exclude<keyof T, K>>.

Áp dụng điều này vào ví dụ của bạn, loại XY có thể được định nghĩa là:

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

Tôi đã tìm thấy giải pháp với việc khai báo một số biến và sử dụng toán tử trải rộng để suy ra kiểu:

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

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

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

Nó hoạt động, nhưng tôi sẽ rất vui khi thấy một giải pháp tốt hơn.

Nếu bạn thích sử dụng thư viện, hãy sử dụng ts-Essential .

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)

PS: Bạn sẽ tìm thấy rất nhiều thứ hữu ích khác ở đó;)

Bản thảo 3.5

Kể từ Bản mô tả 3.5, trình trợ giúp Omit sẽ được bao gồm: TypeScript 3.5 RC - Loại Trình trợ giúp Omit

Bạn có thể sử dụng nó trực tiếp và bạn nên xóa định nghĩa của chính bạn về trình trợ giúp Omit khi cập nhật.

Trong bản đánh máy 3.5+ :

interface TypographyProps {
    variant: string
    fontSize: number
}

type TypographyPropsMinusVariant = Omit<TypographyProps, "variant">

Tôi làm như thế:

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);