Eine Zusammenfassung einiger Orte, an denen ich Zeit mit TypeScript verbracht habe

Typ Typ = {
  Schlüssel: „Wert“
}
Schnittstelle Schnittstelle {
  Schlüssel: „Wert“
}

Der Typ scheint nicht unterschiedlich zu sein, beide sind wahr = Typ erweitert Schnittstelle? Typ erweitert Schnittstelle? wahr : falsch : falsch

Typ Grubenpunkt = {
  [Schlüssel: Zeichenfolge]: Grubenpunkt} | Zeichenfolge

Typtest<T> = T erweitert Fallstrick? true : false
Typ Dies ist wahr = Test <Typ>
Typ Dies ist falsch = Test <Schnittstelle>

//Das ist alles. Ich bin zu faul, den folgenden Code tatsächlich zu testen 🙃

//fns ist eine Funktionsindextabelle, TFns ist der Konstantentyp der Indextabelle. Funktionsüberladung fehlgeschlagen <T extends keyof TFns>(fn:T, params: Parameters<fns[T]>){
    fns[fn](...params) //Bei der Implementierung wird der Union-Typ nicht eingegrenzt, daher wird ein Fehler gemeldet //Der Fehler sollte etwa lauten: „Die Parameter von Methode 1 konnten nicht an Methode 2 übergeben werden“}
//Aber bei externer Verwendung spielt es keine Rolle, ob die Semantik des Typs erfüllt ist

// Erforderliche Typen: [...number[], "middle-element", ...boolean[]] 
//Das Obige ist ungültig, es gibt nur an, wofür der folgende Typcode verwendet wird (um die oben angegebenen Typbeschränkungen zu implementieren)

Typ Elem = Zahl | Boolesch | „mittleres Element“;

Typ Last<T erweitert beliebig[]> = T erweitert [infer _]
  ? niemals
  : T erweitert [...schließe _, schließe Tl]
  ? Tl
  : niemals

Typ HandleEmpty<T erweitert beliebig[], ​​Daten> = T['Länge'] erweitert 0 ? nie : Daten

Typ Validierung<Params erweitert beliebig[], ​​Cache erweitert Elem[] = []> =
  Parameter erweitert []
  ? Cache['Länge'] erstreckt sich 0
  ? niemals
  : Zwischenspeicher
  : Parameter erweitert [Fst ableiten, ...Rest ableiten]
  ? Cache erweitert []
  ? Fst erweitert Nummer
  ? HandleEmpty<Rest, Validierung<Rest, [...Cache, Fst]>>
  : niemals
  : Fst erweitert Nummer
  ? Last<Cache> erweitert Nummer
  ? HandleEmpty<Rest, Validierung<Rest, [...Cache, Fst]>>
  : niemals
  : Fst erweitert "Mittelelement"
  ? Last<Cache> erweitert Nummer
  ? HandleEmpty<Rest, Validierung<Rest, [...Cache, Fst]>>
  : niemals
  : "mittleres Element" erweitert Cache[Zahl]
  ? Fst erweitert Boolean
  ? Validierung<Rest, [...Cache, Fst]>
  : niemals
  : niemals
  : niemals

Typ IsNever<T> = [T] erweitert [nie]? true : false;

Funktionskontrolle<
  Params erweitert Elem[],
  IsValid erweitert Validation<Params>
>(...arr: IsNever<IsValid> erweitert true ? [nie] : [...Params]) {
  Rückflug an
}

const normal = check(1, 'Mittelelement', false)
const error = check(false, "mittleres Element", 2)

//{ "new-a":beliebig; "new-b":beliebig }
Typ neu zuordnen = {
    [K in "a" | "b" als `new-${K}`]: beliebig
}

//"a1"|"b2"
Typaufteilung erfolgreich <_Keys = keyof { a: 1, b: 2 }> = _Keys erweitert Infer K?
    `${Extrahieren<K, string>}${{ a: 1, b: 2 }[Extrahieren<K, _Keys>]}`
    : niemals

// Hinweis: (ab ts4.4.4) Direkt kann „keyof Obj extends infer K“ den Union-Typ nicht aufteilen, der Grund ist unbekannt (zu faul, das zu überprüfen 😁).
//Das Ergebnis ist "a1"|"a2"|"b1"|"b2"
Typaufteilung fehlgeschlagen = keyof { a: 1, b: 2 } erweitert Infer K?
    `${Extrahieren<K, string>}${{ a: 1, b: 2 }[Extrahieren<K, "a" | "b">]}`
    : niemals

Typ Konverter<T> = T erweitert Zeichenfolge ? "str" ​​​​: null
//Es geht als [Zeichenfolge,Zahl,Zeichenfolge] hinein und kommt als ["str",null,"str"] heraus.
Typrekursion<
        Eingabequelle erweitert any[],
        Der interne Typcache erweitert any[] = []
    > = Eingabequelle erweitert [beliebig, ... verbleibende Elemente ableiten]?
        Rekursion <restliche Elemente, [...interner Typcache, Konverter <Eingabequelle [0]>]>
        : Eingangsquelle