知らないかもしれない実用的なTypeScriptのヒント

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

定数ユーザー = {
  名前: 'ジャック',
  年齢: 123
};

クラス SomeClass {

  パブリックテスト(para: User): number;
  パブリックテスト(para: number, flag: boolean): number;

  パブリックテスト(para: ユーザー | 数値、フラグ?: ブール値): 数値 {
    // 特定の実装 return 1;
  }
}

const someClass = 新しい SomeClass();

// わかりました
someClass.test(ユーザー);
someClass.test(123, false);

// エラー
// someClass.test(123); 
// 'number' 型の引数は 'User' 型のパラメータに割り当てることができません。
// someClass.test(user, false);
// '{ name: string; age: number; }' 型の引数は 'number' 型のパラメータに割り当てることができません。

インターフェースポイント{
    x: 数値;
    y: 数値;
}

// タイプキー = "x" | "y"
タイプ keys = keyof Point;

// 例: 包括的なコンパイル時チェックを実行する type Foo = string | number;

関数 controlFlowAnalysisWithNever(foo: Foo) {
  if (typeof foo === "文字列") {
    // ここで foo は文字列型に絞り込まれます } else if (typeof foo === "number") {
    // ここで foo は number 型に絞り込まれます } else {
    // foo はここには決して存在しません
    const チェック: never = foo;
  }
}

定数a: 数値 = 3

// 次と同等: const b: number = 4
定数 b: 型 a = 4

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

インターフェースB {
  y: 文字列;
}

関数doStuff(q: A | B) {
  （'x'がqにある場合）{
    // 質問: A
  } それ以外 {
    // 質問: B
  }
}

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

型 Readonly<T> = {
    読み取り専用[P in keyof T]: T[P];
}

Nullable<T>型 = { 
  [T のキーの P]: T[P] | null 
}

型 Required<T> = {
  [TのキーのP]-?: T[P]
}

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

PersonPartial と入力します。
PersonReadonly = Readonly<Person> と入力します。
PersonNullable 型 = Nullable<Person>;

タイプ PersonPartial = {
    名前?: 文字列 | 未定義;
    年齢?: 数値 | 未定義;
}

タイプ PersonReadonly = {
    読み取り専用の名前: 文字列;
    読み取り専用 age: 数値;
}

タイプ PersonNullable = {
      名前: 文字列 | null;
      年齢: 数値 | null;
}

インターフェースProps{
  a?: 数値;
  b?: 文字列;
}

定数obj: Props = { a: 5 };

const obj2: 必須<Props> = { a: 5 };
// プロパティ 'b' はタイプ '{ a: number; }' では欠落していますが、タイプ 'Required<Props>' では必須です。

型 Pick<T, K は keyof T> を拡張します = {
  [KのP]：T[P];
}

型 Record<K extends keyof any, T> = {
  [K 内の P]: T;
}

インターフェースTodo {
  タイトル: 文字列;
  説明: 文字列;
  完了: ブール値;
}

type TodoPreview = Pick<Todo, "title" | "completed">;

定数todo: TodoPreview = {
  タイトル: 「クリーンルーム」
  完了: 偽、
};

todo; // = const todo: TodoPreview


インターフェース PageInfo {
  タイトル: 文字列;
}

Page = "home" | "about" | "contact" と入力します。

const nav: レコード<ページ、ページ情報> = {
  について: { タイトル: "title1" },
  連絡先: { タイトル: "title2" },
  ホーム: { タイトル: "title3" },
};

nav.about; // = const nav: レコード

型 Exclude<T, U> = T は U を拡張しますか? 決して: T
タイプ Omit = Pick<T, Exclude<keyof T, K>>

// 次と同等: type A = 'a'
タイプ A = 除外<'x' | 'a', 'x' | 'y' | 'z'>

インターフェースTodo {
  タイトル: 文字列;
  説明: 文字列;
  完了: ブール値;
}

type TodoPreview = Omit<Todo, "description">;

定数todo: TodoPreview = {
  タイトル: "a",
  完了: 偽、
};

型 ReturnType<T extends (...args: any) => any>
  = T は (...args: any) を拡張します => R ? R : any を推論します。

関数 f1() を宣言します: { a: 数値; b: 文字列 };
型 T1 = ReturnType<typeof f1>;
// タイプ T1 = {
// a: 数値;
// b: 文字列;
// }

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

デフォルトクラス someClass をエクスポートします。 
    プライベートユーザー = {} をユーザーとして;
} 

列挙型動物フラグ{
    なし = 0、 
    爪あり = 1 << 0, 
    カンフライ = 1 << 1、 
    HasClawsOrCanFly = HasClaws | CanFly 
}

インターフェース動物{ 
    フラグ: AnimalFlags; 
   [キー: 文字列]: 任意; 
}

関数 printAnimalAbilities(animal: Animal) { 
    var animalFlags = animal.flags; 
    動物フラグと動物フラグ.爪がある場合 
        console.log('動物には爪があります'); 
    } 
    動物フラグと動物フラグ.CanFly の場合 { 
        console.log('動物は飛べる'); 
    } 
    動物フラグ == 動物フラグ.None の場合 { 
        console.log('何もない'); 
    } 
}

var animal = { flags: AnimalFlags.None }; 
printAnimalAbilities(animal); // なし 
animal.flags |= AnimalFlags.HasClaws; 
printAnimalAbilities(animal); // 動物には爪がある 
animal.flags &= ~AnimalFlags.HasClaws; 
printAnimalAbilities(animal); // なし 
animal.flags |= AnimalFlags.HasClaws | AnimalFlags.CanFly; 
printAnimalAbilities(animal); // 動物には爪があり、動物は飛べます 

定数列挙型TODO_STATUS {
  TODO = 'TODO'、
  完了 = '完了'、
  行う = '行う'
}

関数 todos (ステータス: TODO_STATUS): Todo[];

やること(TODO_STATUS.TODO)

let x: [文字列, 数値];
x = ['こんにちは', 10]; 

const requestList: any[] = [http.get<A>('http://some.1')]; // any[]型に設定 if (flag) { 
    リクエストリスト[1] = (http.get<B>('http://some.2')); 
} 
const [ { data: a }, response ] = [Response<A>, Response<B>?] として Promise.all(requestList) を待機します。

関数 fn<T>(arg: T): T; // ジェネリック関数を定義します。const fn1 = fn<string>('hello'); // 最初の方法は、ジェネリック型文字列を渡します。const fn2 = fn(1); // 2 番目の方法は、パラメータ arg によって渡された型 number から、ジェネリック T の型が number であると推論します。 

// 変換前のデータ const arr = [ 
{ id: 1、親ID: 0、名前: 'test1'}, 
{ id: 2、親ID: 1、名前: 'test2'}, 
{ id: 3、親 ID: 0、名前: 'test3'} 
]; 
// 変換後 [{ id: 1, parentId: 0, name: 'test1', 
    子供リスト: [ { id: 2, 親ID: 1, 名前: 'test2', 子供リスト: [] } ] }, 
    { id: 3、親ID: 0、名前: 'test3'、子リスト: [] } 
]


インターフェースアイテム{ 
    id: 番号; 
    親ID: 数値; 
    名前: 文字列; 
}

// 渡されたオプションパラメータからchildrenKeyの型を取得し、それをTreeItemに渡します

インターフェースOptions<T extends string> { 
    子供のキー: T; 
} 
type TreeItem<T extends string> = Item & { [T のキー]: TreeItem<T>[] | [] }; 
関数 listToTree<T extends string = 'children'>(list: Item[], options: Options<T>): TreeItem<T>[] を宣言します。 
listToTree(arr, { childrenKey: 'childrenList' }).forEach(i => i.childrenList) 

型 ParamType<T> = T は (param: infer P) => any ? P : T を拡張します。 

インターフェース ユーザー { 
    名前: 文字列; 
    年齢: 番号; 
} 
型 Func = (user: User) => void 
type Param = ParamType<Func>; // Param = User 
type AA = ParamType<string>; // 文字列

// [文字列, 数値] -> 文字列 | 数値
type ElementOf<T> = T は Array<infer E> を拡張します。E : never;

タイプTTuple = [文字列、数値];

type ToUnion = ElementOf<TTuple>; // 文字列 | 数値


// T1 | T2 -> T1 & T2
型 UnionToIntersection<U> = (U は any ? (k: U) => void : never) を拡張し ((k: infer I) => void) ? I : never;

type Result = UnionToIntersection<T1 | T2>; // T1 & T2