Typescript での infer キーワードの使用に関する詳細な理解

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

タイプ fn = () => 数値
type fnReturnType = ReturnType<fn> // 数値

// プロミスレスポンス型 type PromiseResType<T> = T extends Promise<infer R> ? R : T

// 非同期関数 strPromise() { を検証する
  '文字列プロミス' を返す
}

インターフェース Person {
  名前: 文字列;
  年齢: 番号;
}
非同期関数 personPromise() {
  戻る {
    名前: 'p',
    年齢: 12
  } を人として
}

type StrPromise = ReturnType<typeof strPromise> // Promise<string>
// 逆型 StrPromiseRes = PromiseResType<StrPromise> // str

type PersonPromise = ReturnType<typeof personPromise> // Promise<Person>
// 逆型 PersonPromiseRes = PromiseResType<PersonPromise> // Person

型 Fn<A extends any[]> = (...args: A) => any
型 FnArgs<T> = T は Fn<infer A> ? A を拡張します: any

関数 strFn (名前: 文字列) {

}

type StrFn = FnArgs<typeof strFn> // [文字列]

type ElementOf<T> = T extends Array<infer E> ? E : なし

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

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

// パラメータの型を取得します。 type ConstructorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;

// インスタンス型を取得します。 type InstanceType<T extends new (...args: any[]) => any> = T extends new (...args: any[]) => infer R ? R : any;

クラス TestClass {

  コンストラクタ（
    公開名: 文字列、
    公開文字列: 数値
  ）{}
}

type Params = ConstructorParameters<typeof TestClass>; // [文字列、数値]

type Instance = InstanceType<typeof TestClass>; // TestClass

//関数 useReducer<R extends Reducer<any, any>, I>( を定義します。
  減速機: R、
  // ReducerState推論型initializerArg: I​​ ​​& ReducerState<R>,
  初期化子: (引数: I ​​& ReducerState<R>) => ReducerState<R>
): [ReducerState<R>、Dispatch<ReducerAction<R>>];

// 推論 推論 type ReducerState<R extends Reducer<any, any>> = R extends Reducer<infer S, any>
  ? S
  ： 一度もない;
// リデューサー型 type Reducer<S, A> = (prevState: S, action: A) => S;


// リデューサーを使用する
const リデューサー = (x: 数値) => x + 1;
const [状態、ディスパッチ] = useReducer(リデューサー、'');
// "" 型の引数は 'number' 型のパラメータに割り当てることができません。

エクスポートインターフェースRef<T = any> {
  [isRefSymbol]: 真
  値: T
}

関数 ref<T>(値: T): T は Ref を拡張します ? T: Ref<UnwrapRef<T>>

エクスポート型UnwrapRef<T> = {
  cRef : T は ComputedRef<infer V> ? を拡張します UnwrapRef<V> : T
  ref: T は Ref<infer V> を拡張しますか? UnwrapRef<V> : T
  配列: T
  オブジェクト: { [T のキーの K]: UnwrapRef<T[K]> }
}[TはComputedRef<any>を拡張します
  ? 'cRef'
  : T は Array<any> を拡張します
    ？ '配列'
    : T は Ref | 関数 | コレクションタイプ | 基本タイプを拡張します
      ? 'ref' // アンラップすべきでない型を除外する
      : T はオブジェクトを拡張しますか? 'object' : 'ref']


// const count = ref({ を使用
  foo: ref('1')、
  バー: ref(2)
})

// 推論されたconst count: Ref<{
  foo: 文字列;
  バー: 番号;
}>

const count = ref(2) // Ref<数値>

const count = ref(ref(2)) // Ref<数値>