TypeScript タイプツール

TypeScript には、さまざまな型を簡単に処理し、新しい型を生成するための組み込みの型ツールがいくつか用意されています。

これらのタイプのツールは言語自体によって提供されており、直接使用できます。

Awaited<Type>

Awaited<Type> は、Promise の戻り値の型を取得するために使用されます。これは、then() メソッドや await コマンドのパラメーターの型を記述するのに適しています。

// 弦
type A = Awaited<Promise<string>>;

上記の例では、Awaited<Type> は戻り値の型として Promise (文字列) を返します。

複数の Promise 戻り値の型を返すこともできます。

// 番号
type B = Awaited<Promise<Promise<number>>>;

その型パラメータが Promise 型でない場合は、変更されずに返されます。

// 数値 |
type C = Awaited<ブール値<数値>>;

上記の例では、type パラメータは共用体型であり、boolean が変更されずに返されるため、最終的な戻り値は number|boolean になります。

Awaited<Type>の実装は以下の通りです。

タイプ Awaited<T> =
  T は未定義の T を拡張しますか?
  T はオブジェクト & { を拡張します
    それから（
      満たされた場合: 推測 F、
      ...引数: _ を推測する
    ）： どれでも;
  } ? F は拡張します (
    値: 推定 V、
    ...引数: _ を推測する
  ) => 任意の ? Awaited<V> : 決して:
  T;

ConstructorParameters<Type>

ConstructorParameters<Type> は、コンストラクター Type のパラメーターの型を抽出し、それをタプル型として返します。

type T1 = コンストラクターパラメータ<
  new (x: 文字列、y: 数値) => オブジェクト
>; // [x: 文字列、y: 数値]

type T2 = コンストラクターパラメータ<
  new (x?: 文字列) => オブジェクト
>; // [x?: 文字列が未定義]

一部の組み込みコンストラクターのパラメーターの型を返すことができます。

type T1 = コンストラクターパラメータ<
  エラーコンストラクター
>; // [メッセージ?: 文字列]

type T2 = コンストラクターパラメータ<
  関数コンストラクター
>; // 文字列[]

type T3 = コンストラクターパラメータ<
  RegExpConstructor
>; // [パターン:文字列|RegExp, フラグ?:文字列]

パラメーターの型がコンストラクターではない場合、エラーが報告されます。

type T1 = ConstructorParameters<string> // エラーレポート

type T2 = ConstructorParameters<Function> // エラーレポート

「any」タイプと「never」タイプは 2 つの特別な値で、それぞれ「unknown[]」と「never」を返します。

type T1 = ConstructorParameters<any> // 不明[];

type T2 = ConstructorParameters<never> // 決してない

ConstructorParameters<Type>の実装は以下の通りです。

type ConstructorParameters<
  T extends abstract new (...args: any) => any
> = T extend abstract new (...args: infer P)
  => 任意の P : 決して

Exclude<UnionType, ExcludedMembers>

Exclude<UnionType, ExcludedMembers> は、特定の型 ExcludedMembers を共用体型 UnionType から削除し、返す新しい型を形成するために使用されます。

type T1 = 除外<'a'|'b'|'c', 'a'> // 'b'|'c';
type T2 = 除外<'a'|'b'|'c', 'a'|'b'> // 'c';
type T3 = Exclude<string|(() => void), // string;
type T4 = 除外<string | 任意の[]>;
type T5 = Exclude<(() => void) | null, Function>;
type T6 = 除外<200 | 201>;
type T7 = Exclude<number, boolean> // 数値;

Exclude<UnionType, ExcludedMembers> の実装は以下の通りです。

type Exclude<T, U> = T は U を拡張しません : T;

上記のコードでは、等号の右側の部分は、まず T が U と互換性があるかどうかを判断し、互換性がある場合は never 型を返し、それ以外の場合は現在の型 T を返します。 never 型は他の型のサブタイプであるため、他の型と共用体型を形成する場合、never 型は共用体型から直接「削除」できるため、 Exclude<T, U> は次のようになります。互換性のあるタイプに相当するものが削除され、互換性のないタイプが残ります。

Extract<Type, Union>

Extract<UnionType, Union> は、指定された型 Union を共用体型 UnionType から抽出して新しい型を形成し、それを返すために使用されます。これは、「Exclude<T, U>」の正反対です。

type T1 = 抽出<'a'|'b'|'c', 'a'>;
type T2 = 抽出<'a'|'b'|'c', 'a'|'b'> // 'a'|'b';
type T3 = 抽出<'a'|'b'|'c', 'a'|'d'> // 'a';
type T4 = 抽出<文字列[], 任意[]>;
type T5 = 抽出<(() => void) | // () => void
タイプ T6 = 抽出<200, 201>;

パラメータ型 Union が共用体型 UnionType に含まれていない場合、never 型が返されます。

type T = Extract<string|number, boolean> // 決して行わない

Extract<UnionType, Union>の実装は以下の通りです。

type Extract<T, U> = T は U T を拡張します ? 決して;

InstanceType<タイプ>

InstanceType<Type> はコンストラクターの戻り値の型 (つまり、インスタンスの型) を抽出します。パラメーター Type はコンストラクターであり、コンストラクターの ReturnType<Type> と同等です。

タイプ T = インスタンスタイプ<
  新しい() => オブジェクト
>; // オブジェクト

上記の例では、型パラメータはコンストラクタ new() => object であり、戻り値はコンストラクタのインスタンス型 (object) です。

以下にいくつかの例を示します。

type A = InstanceType<ErrorConstructor> // エラー
type B = InstanceType<FunctionConstructor> // 関数
type C = InstanceType<RegExpConstructor>; // RegExp

上記の例では、InstanceType<T> のパラメータはすべて TypeScript の組み込みネイティブ オブジェクトのコンストラクター型であり、InstanceType<T> の戻り値はこれらのコンストラクターのインスタンス型です。

Class は型であるため、インスタンスの型を表します。コンストラクターを取得するには、それを値として扱い、typeof 演算子を使用してコンストラクターの型を取得する必要があります。

クラスC {
  x = 0;
  y = 0;
}

type T = InstanceType<typeof C>;

上記の例では、typeof C は C のコンストラクター型であり、InstanceType はインスタンス型、つまり C 自体を取得できます。

type パラメーターがコンストラクターではない場合、エラーが報告されます。

type T1 = InstanceType<string> // エラーレポート

type T2 = InstanceType<Function> // エラーレポート

type パラメータが 2 つの特別な値 any または never の場合、それぞれ any と never が返されます。

type T1 = InstanceType<any> // 任意;

type T2 = InstanceType<never> // 決してしない

InstanceType<Type>の実装は以下の通りです。

typeInstanceType<
  T extends abstract new (...args:any) => any
> = T extends abstract new (...args: any) => R R を推論します :
  どれでも;

Nullable<Type>

NonNullable<Type> は、共用体型 Type から null 型と unknown 型を削除し、返す新しい型を形成するために使用されます。つまり、Type の非 null 型バージョンを返します。 。

// 文字列|数値
type T1 = NonNullable<文字列|数値|未定義>;

// 弦[]
type T2 = NonNullable<文字列[]|null|未定義>;

type T3 = NonNullable<boolean> // ブール値;
type T4 = NonNullable<number|null> // 数値;
type T5 = NonNullable<文字列|未定義> // 文字列
type T6 = NonNullable<null|unknown>; // 決してしない

NonNullable<Type> の実装は以下の通りです。

型 NonNullable<T> = T & {}

上記のコードでは、T & {} は、T & Object の交差タイプを見つけることと同じです。 TypeScript の null 以外の値はすべて Object のサブタイプであるため、それらはそれ自体を返しますが、null と unknown は Object に属さず、never 型を返します。

<タイプ、キー> を省略します

Omit<Type, Keys> は、オブジェクト タイプ Type から指定された属性 Keys を削除し、返される新しいオブジェクト タイプを形成するために使用されます。

インターフェース A {
  x: 数値。
  y: 数値。
}

type T1 = 省略<A, 'x'> // { y: 数値 }
type T2 = 省略<A, 'y'> // { x: 数値 }
type T3 = 省略<A, 'x' > // { }

上の例では、Omit<Type, Keys> は、オブジェクト タイプ A から指定された属性を削除し、残りの属性を返します。

削除対象として指定されたキー名 Keys は、オブジェクト タイプ Type に存在しない属性であってもかまいませんが、string|number|symbol と互換性がある必要があります。

インターフェース A {
  x: 数値。
  y: 数値。
}

type T = 省略<A, 'z'> // { x: 数値; y: 数値 }

上記の例では、オブジェクト型 'A' には属性 'z' が存在しないため、そのまま返されます。

Omit<Type, Keys>の実装は以下の通りです。

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

OmitThisParameter<Type>

OmitThisParameter<Type> は、関数タイプから this パラメータを削除します。

関数 toHex(this: Number) {
  this.toString(16) を返します。
}

type T = OmitThisParameter<typeof toHex>; // () => 文字列

上の例では、OmitThisParameter<T> は関数 toHex() の型を与え、this パラメータを削除します。

関数にこのパラメータがない場合は、元の関数タイプが返されます。

OmitThisParameter<Type>の実装は以下の通りです。

タイプ OmitThisParameter<T> =
  不明は ThisParameterType<T> T を拡張しますか?
  T extends (...args: Aを推測) => Rを推測?
  (...引数: A) => R : T;

パラメータ<タイプ>

Parameters<Type> は、関数型 Type からパラメータの型を抽出し、それをタプルとして返します。

type T1 = パラメータ<() => 文字列> // []

type T2 = パラメータ<(s:string) => void> // [s:string];

type T3 = パラメータ<<T>(arg: T) => T> // [arg: 不明];

type T4 = パラメータ<
  (x:{ a: 数値; b: 文字列 }) => void
>; // [x: { a: 数値, b: 文字列 }]

type T5 = パラメータ<
  (a:数値、b:数値) => 数値
>; // [a:数値, b:数値]

上記の例では、Parameters<Type> の戻り値に関数のパラメータ名が含まれることに注意してください。

パラメータの型 Type がパラメータを持つ関数形式ではない場合、エラーが報告されます。

// エラーを報告する
type T1 = パラメータ<文字列>;

// エラーを報告する
type T2 = パラメータ<関数>;

any と never は 2 つの特別な値であるため、unknown[] と never が返されます。

type T1 = パラメータ<任意> // 不明[];

type T2 = パラメータ<never> // 決してしない

Parameters<Type> は主に外部モジュールが提供する関数型からパラメータ型を取得するために使用されます。

インターフェース SecretName {
  最初: 文字列;
  最後: 文字列;
}

インターフェース SecretSanta {
  名前: 秘密名;
  ギフト: 文字列;
}

エクスポート関数 getギフト(
  名前: 秘密の名前、
  ギフト:文字列
): シークレットサンタ {
 // ...
}

上記の例では、モジュールは関数 get Gift() のみを出力し、出力パラメーター SecretName と戻り値 SecretSanta はありません。現時点では、これら 2 つのインターフェイス タイプは Parameters<T> と ReturnType<T> を通じて取得できます。

type ParaT = パラメータ<typeof get Gift>[0]; // SecretName

type ReturnT = ReturnType<typeof get Gift> // SecretSanta;

Parameters<Type> の実装は以下の通りです。

type Parameters<T extends (...args: any) => any> =
  T を拡張します (...引数: P を推測します)
  => 任意の P : 決して

部分的な<タイプ>

Partial<Type> は新しい型を返し、パラメータ型 Type のすべてのプロパティをオプションにします。

インターフェース A {
  x: 数値。
  y: 数値。
}
 
type T = 部分<A>; // { x?: 数値; }

Partial<Type> の実装は以下の通りです。

type Partial<T> = {
  [T のキーの P]?: T[P];
};

Pick<Type, Keys>

Pick<Type, Keys> は新しいオブジェクト タイプを返します。最初のパラメータ Type はオブジェクト タイプで、2 番目のパラメータ Keys は Type で選択されたキー名です。

インターフェース A {
  x: 数値。
  y:数値;
}

type T1 = Pick<A, 'x'> // { x: 数値 };
type T2 = Pick<A, 'y'> // { y: 数値 };
type T3 = Pick<A, 'x'|'y'> // { x: 数値;

上の例では、Pick<Type, Keys> は、オブジェクト タイプ A から指定されたキー名を取り出して、新しいオブジェクト タイプを形成します。

指定したキー名 Keys は、オブジェクト キー名 Type にすでに存在するキー名である必要があります。そうでない場合は、エラーが報告されます。

インターフェース A {
  x: 数値。
  y:数値;
}

type T = Pick<A, 'z'> // エラーレポート

上の例では、オブジェクト タイプ A にキー名 z がないため、エラーが報告されます。

Pick<Type, Keys>の実装は以下の通りです。

type Pick<T, K extends keyof T> = {
  [K の P]: T[P];
};

読み取り専用<タイプ>

Readonly<Type> は、パラメータ型 Type のすべてのプロパティを読み取り専用にする新しい型を返します。

インターフェース A {
  x: 数値。
  y?: 数値;
}

// { 読み取り専用 x: 数値; 読み取り専用 y?: 数値;
タイプ T = 読み取り専用<A>;

上の例では、「y」はオプションの属性です。「Readonly」はこれを変更せず、「y」を読み取り専用にするだけです。

Readonly<Type> の実装は以下の通りです。

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

型ツール Mutable<Type> をカスタマイズして、パラメーター型のすべてのプロパティを可変プロパティに変えることができます。

型 Mutable<T> = {
  -readonly [keyof T の P]: T[P];
};

上記のコードで、「-readonly」は属性の読み取り専用フラグを削除することを意味します。

同様に、「+readonly」は読み取り専用フラグを追加することを意味し、「readonly」と同等です。したがって、Readonly<Type> の実装は次のように書くこともできます。

type Readonly<T> = {
  +readonly [P in keyof T]: T[P];
};

Readonly<Type> を Partial<Type> と組み合わせて使用​​すると、すべてのプロパティを読み取り専用のオプション プロパティに変えることができます。

インターフェイス 人 {
  名前: 文字列;
  年齢: 番号;
}

const ワーカー: Readonly<Partial<person>>
  = { 名前: '張三' };

worker.name = '李思' // エラーレポート

レコード<キー、タイプ>

Record<Keys, Type> はオブジェクト タイプを返します。パラメータ Keys はキー名として使用され、パラメータ Type はキー値のタイプとして使用されます。

// { a: 数値 }
type T = レコード<'a', 数値>;

上記の例では、「Record<Keys, Type>」の最初のパラメータ「a」はオブジェクトのキー名として使用され、2 番目のパラメータ「number」は「a」のキー値の型です。

パラメータ Keys は共用体タイプにすることができ、その場合は複数のキーに順番に展開されます。

// { a: 数値、b: 数値 }
type T = レコード<'a'|'b', 数値>;

上記の例では、最初のパラメータは共用体型 'a'|'b' であり、これは 2 つのキー名 a と b に展開されます。

パラメータ Type が共用体型の場合、キー値が共用体型であることを示します。

// { a: 数値|文字列 }
type T = レコード<'a', 数値|文字列>;

パラメータ Keys のタイプは string|number|symbol と互換性がある必要があります。そうでない場合はキー名として使用できず、エラーが報告されます。

Record<Keys, Type>の実装は以下の通りです。

type Record<K extends string|number|symbol, T>
  = { [K の P]: T;

必須<タイプ>

Required<Type> は新しい型を返し、パラメータ型 Type のすべてのプロパティを必須にします。これは、「Partial」とはまったく逆の効果があります。

インターフェース A {
  x?: 数値;
  y: 数値。
}

type T = 必須<A> // { x: 数値; }

Required<Type>の実装は以下の通りです。

typeRequired<T> = {
  [T のキーの P]-?: T[P];
};

上記のコードでは、記号 -? は、オプション属性の「疑問符」を削除して必須属性にすることを意味します。

同様に、記号「+?」はオプションの属性を追加する「疑問符」を表し、「?」と同等です。したがって、先ほどの「Partial」の定義は次のように書くこともできます。

type Partial<T> = {
  [T のキーの P]+?: T[P];
};

ReadonlyArray<Type>

ReadonlyArray<Type> は読み取り専用の配列型を生成するために使用され、型パラメーター Type は配列メンバーの型を表します。

const 値: ReadonlyArray<string>
  = ['a', 'b', 'c'];

value[0] = 'x' // エラーレポート
value.push('x'); // エラーレポート
value.pop(); // エラーを報告します
value.splice(1, 1); // エラーレポート

上記の例では、変数 values の型は読み取り専用の配列であるため、メンバーを変更するとエラーが報告され、メソッド push()、pop()、splice() などはエラーを報告します。ソース配列が存在しない場合に変更します。

ReadonlyArray<Type> の実装は以下の通りです。

インターフェース ReadonlyArray<T> {
  読み取り専用の長さ: 数値;

  読み取り専用 [n: 数値]: T;

  // ...
}

ReturnType<Type>

ReturnType<Type> は関数型 Type の戻り値の型を抽出し、新しい型として返します。

type T1 = ReturnType<() => string> // 文字列

type T2 = ReturnType<() => {
  a: 文字列; b: 数値
}>; // { a: 文字列; b: 数値 }

type T3 = ReturnType<(s:string) => void>; // void

type T4 = ReturnType<() => () => any[]> // () => any[];

type T5 = ReturnType<typeof Math.random> // 数値

type T6 = ReturnType<typeof Array.isArray> // ブール値

引数の型がジェネリック関数の場合、戻り値はジェネリック型によって異なります。ジェネリックに制約がない場合は、「unknown」が返されます。

type T1 = ReturnType<<T>() => T>; // 不明

タイプ T2 = ReturnType<
  <T は U を拡張、U は数値[]>() を拡張 => T
>; // 数値[]

型が関数ではない場合、エラーが報告されます。

type T1 = ReturnType<boolean> // エラーレポート

type T2 = ReturnType<Function> // エラーレポート

「any」と「never」は 2 つの特別な値で、それぞれ「any」と「never」を返します。

type T1 = ReturnType<any> // 任意;

type T2 = ReturnType<never> // 決してしない

ReturnType<Type> の実装は次のとおりです。

型 ReturnType<
  T extends (...args: any) => any
> =
  T extends (...args: any) => R ? R : any; を推測します。

ThisParameterType<Type>

ThisParameterType<Type> は、関数型の this パラメータの型を抽出します。

関数 toHex(this:number) {
  this.toString(16) を返します。
}

type T = ThisParameterType<typeof toHex>; // 数値

関数に「this」パラメータがない場合は、「unknown」が返されます。

ThisParameterType<Type>の実装は以下の通りです。

ThisParameterType<T> を入力 =
  T は拡張します (
    これ: U を推測します、
    ...引数: 決してしない
  ) => 任意の U : 不明。

ThisType<タイプ>

ThisType<Type> は型を返しません。他の型とのクロス型を形成するためにのみ使用され、TypeScript に他の型の 'this' の型を要求するために使用されます。

インターフェース HelperThisValue {
  logError: (error:string) => void;
}

let helperFunctions:
  { [名前: 文字列]: 関数 } &
  ThisType<HelperThisValue>
= {
  こんにちは: function() {
    this.logError("エラー: 何かが間違っています!"); // 正しいです。
    this.update(); // エラーを報告する
  }
}

上記の例では、変数 helperFunctions の型は、通常のオブジェクト型と ThisType<HelperThisValue> から構成されるクロス型です。

ここでの ThisType の機能は、変数 helperFunctions の this が HelperThisValue の条件を満たす必要があることを TypeScript に指示することです。したがって、this.logError() は正しく呼び出すことができますが、HelperThisValue にはそのようなメソッドがないため、this.update() はエラーを報告します。

このタイプのツールを使用する場合は、「noImplicitThis」設定をオンにする必要があることに注意してください。

別の例を示します。

let obj: ThisType<{ x:number }> &
  { getX: () => 数値 };

オブジェクト = {
  getX() {
    return this.x + this.y // エラーレポート
  }、
};

上記の例では、getX() の this.y はエラーを報告します。これは、ThisType<{ x:number }> によれば、このオブジェクトの this には属性 y が含まれていないためです。

ThisType<Type> の実装は空のインターフェイスです。

インターフェース ThisType<T> { }

文字列型ツール

TypeScript には 4 つの組み込みの文字列型ツールがあり、特に文字列型の操作に使用されます。これら 4 つのツール タイプは、TypeScript に付属の .d.ts ファイルで定義されています。

これらの実装は、下部で JavaScript エンジンを呼び出して、JavaScript 文字操作メソッドを提供します。

大文字の<StringType>

Uppercase<StringType> は、文字列型の各文字を大文字に変換します。

タイプ A = 'こんにちは';

// "こんにちは"
タイプ B = 大文字<A>;

上の例では、「Uppercase」は hello を HELLO に変換します。

小文字<StringType>

Lowercase<StringType> は、文字列の各文字を小文字に変換します。

タイプ A = 'HELLO';

// "こんにちは"
タイプ B = 小文字<A>;

上の例では、「Lowercase」は HELLO を hello に変換します。

Capitalize<StringType>

Capitalize<StringType> は、文字列の最初の文字を大文字に変換します。

タイプ A = 'こんにちは';

// "こんにちは"
type B = Capitalize<A>;

上の例では、Capitalize<T> が hello を Hello に変換します。

Uncapitalize<StringType>

Uncapitalize<StringType> 文字列の最初の文字を小文字に変換します。

タイプ A = 'HELLO';

// "こんにちは"
type B = Uncapitalize<A>;

上の例では、「Uncapitalize」によって HELLO が hELLO に変換されます。

参考リンク

• TypeScript の ThisType は何に使用されますか?