Tiefgreifendes Verständnis der Verwendung des Schlüsselworts „infer“ in Typescript

Typ ReturnType<T> = T erweitert (...args: beliebig[]) => folgere R? R: beliebig;

Typ fn = () => Zahl
Typ fnReturnType = ReturnType<fn> // Zahl

// Versprechen-Antworttyp Typ PromiseResType<T> = T erweitert Promise<infer R> ? R : T

// Asynchrone Funktion strPromise() überprüfen {
  gib „String-Versprechen“ zurück
}

Schnittstelle Person {
  Name: Zeichenfolge;
  Alter: Anzahl;
}
asynchrone Funktion personPromise() {
  zurückkehren {
    Name: "p",
    Alter: 12
  } als Person
}

Typ StrPromise = ReturnType<Typ von strPromise> // Promise<Zeichenfolge>
// Inverser Typ StrPromiseRes = PromiseResType<StrPromise> // str

Typ PersonPromise = ReturnType<Typ von PersonPromise> // Promise<Person>
// Inverser Typ PersonPromiseRes = PromiseResType<PersonPromise> // Person

Typ Fn<A erweitert beliebig[]> = (...args: A) => beliebig
Typ FnArgs<T> = T erweitert Fn<infer A> ? A : beliebig

Funktion strFn (Name: Zeichenfolge) {

}

Typ StrFn = FnArgs<Typ von strFn> // [Zeichenfolge]

Typ ElementOf<T> = T erweitert Array<infer E>? E: nie

Typ TTuple = [Zeichenfolge, Zahl];

Typ ToUnion = ElementOf<ATuple>; // Zeichenfolge | Zahl

// Parametertyp abrufen Typ ConstructorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;

// Instanztyp abrufen Typ InstanceType<T extends new (...args: any[]) => any> = T extends new (...args: any[]) => R ableiten? R : any;

Klasse TestClass {

  Konstruktor(
    öffentlicher Name: Zeichenfolge,
    öffentliche Zeichenfolge: Nummer
  ) {}
}

Typ Parameter = KonstruktorParameter<Typ der Testklasse>; // [Zeichenfolge, Nummer]

Typ Instanz = Instanztyp<Typ der Testklasse>; // Testklasse

//Funktion useReducer<R extends Reducer<any, any>, I> definieren(
  Reduzierstück: R,
  // ReducerState abgeleiteter Typ initializerArg: I ​​& ReducerState<R>,
  Initialisierer: (Argument: I & ReducerState<R>) => ReducerState<R>
): [ReducerState<R>, Dispatch<ReducerAction<R>>];

// folgert, Typ ReducerState<R erweitert Reducer<beliebig, beliebig>> = R erweitert Reducer<folgert S, beliebig>
  ? S
  : niemals;
// Reducer-Typ Typ Reducer<S, A> = (prevState: S, action: A) => S;


// Reduzierer verwenden
const Reducer = (x: Zahl) => x + 1;
const [Status, Versand] = useReducer(Reducer, '');
// Argument vom Typ "" kann nicht dem Parameter vom Typ ‚Zahl‘ zugewiesen werden.

Exportschnittstelle Ref<T = any> {
  [isRefSymbol]: wahr
  Wert: T
}

Exportfunktion ref<T>(Wert: T): T erweitert Ref ? T : Ref<UnwrapRef<T>>

Exporttyp UnwrapRef<T> = {
  cRef : T erweitert ComputedRef<infer V> ? UnwrapRef<V> : T
  ref: T erweitert Ref<infer V> ? UnwrapRef<V> : T
  Array: T
  Objekt: { [K in keyof T]: UnwrapRef<T[K]> }
}[T erweitert ComputedRef<any>
  ? 'cRef'
  : T erweitert Array<beliebig>
    ? 'Reihe'
    : T erweitert Ref | Funktion | Sammlungstypen | Basistypen
      ? 'ref' // Bailout bei Typen, die nicht ausgepackt werden sollten
      : T erweitert Objekt? 'Objekt' : 'Ref']


// Verwenden von const count = ref({
  foo: ref('1'),
  Balken: ref(2)
})

// Abgeleitete konstante Anzahl: Ref<{
  foo: Zeichenfolge;
  Balken: Zahl;
}>

const count = ref(2) // Ref<Zahl>

const count = ref(ref(2)) // Ref<Zahl>