Details zum TypeScript-Mapping-Typ

// Wenn Sie den Typ der Eigenschaft im Voraus deklarieren müssen, geben Sie OnlyBoolsAndHorses = { ein.
  [Schlüssel: Zeichenfolge]: Boolesch | Pferd;
};
 
const entspricht: OnlyBoolsAndHorses = {
  del: wahr,
  rodney: falsch,
};

Typ OptionsFlags<Typ> = {
  [Eigenschaft im Keyof-Typ]: Boolean;
};

Typ FeatureFlags = {
  dunkler Modus: () => ungültig;
  neuesBenutzerprofil: () => void;
};
 
Typ FeatureOptions = OptionsFlags<FeatureFlags>;
// Typ FeatureOptions = {
// Dunkelmodus: Boolesch;
// neuesBenutzerprofil: boolean;
// }

// Lösche den schreibgeschützten Attributtyp im Attribut CreateMutable<Type> = {
  -readonly [Eigenschaft im Schlüssel des Typs]: Typ[Eigenschaft];
};
 
Typ GesperrtesKonto = {
  schreibgeschützte ID: Zeichenfolge;
  schreibgeschützter Name: Zeichenfolge;
};
 
Typ UnlockedAccount = CreateMutable<LockedAccount>;

// Typ UnlockedAccount = {
// ID: Zeichenfolge;
// Name: Zeichenfolge;
// }
// Lösche das optionale Attribut type im Attribut Concrete<Type> = {
  [Eigenschaft im Schlüssel des Typs]-?: Typ[Eigenschaft];
};
 
Typ VielleichtBenutzer = {
  ID: Zeichenfolge;
  Name?: Zeichenfolge;
  Alter?: Zahl;
};
 
Typ Benutzer = Konkret<VielleichtBenutzer>;
// Typ Benutzer = {
// ID: Zeichenfolge;
// Name: Zeichenfolge;
//Alter: Zahl;
// }

Typ MappedTypeWithNewProperties<Typ> = {
    [Eigenschaften im Schlüssel des Typs als NewKeyType]: Typ [Eigenschaften]
}

Typ Getter<Typ> = {
    [Eigenschaft im Schlüssel des Typs als `get${Capitalize<string & Property>}`]: () => Typ[Eigenschaft]
};
 
Schnittstelle Person {
    Name: Zeichenfolge;
    Alter: Anzahl;
    Standort: Zeichenfolge;
}
 
Typ LazyPerson = Getters<Person>;

// Typ LazyPerson = {
// getName: () => Zeichenfolge;
// getAge: () => Zahl;
// getLocation: () => Zeichenfolge;
// }

// Entfernen Sie die Eigenschaft „kind“
Typ RemoveKindField<Typ> = {
    [Eigenschaft im Schlüssel des Typs als Exclude<Eigenschaft, "kind">]: Typ[Eigenschaft]
};
 
Schnittstelle Kreis {
    Art: "Kreis";
    Radius: Zahl;
}
 
Typ KindlessCircle = RemoveKindField<Kreis>;

// Typ KindlessCircle = {
// Radius: Zahl;
// }

Typ EventConfig<Events erweitert { Art: Zeichenfolge }> = {
    [E in Ereignissen als E["Art"]]: (Ereignis: E) => ungültig;
}
 
Typ SquareEvent = { Art: "Quadrat", x: Zahl, y: Zahl };
Typ CircleEvent = { Art: "Kreis", Radius: Zahl };
 
Typ Konfiguration = EventConfig<Quadratereignis | Kreisereignis>
// Typ Konfiguration = {
// Quadrat: (Ereignis: Quadratereignis) => void;
// Kreis: (Ereignis: Kreisereignis) => void;
// }

Typ ExtractPII<Typ> = {
  [Eigenschaft im Schlüssel des Typs]: Typ [Eigenschaft] erweitert { pii: true } ? true : false;
};
 
Typ DBFields = {
  ID: {Format: "inkrementierend"};
  Name: { Typ: Zeichenfolge; pii: true };
};
 
Typ ObjectsNeedingGDPRDeletion = ExtractPII<DBFields>;
// Typ ObjectsNeedingGDPRDeletion = {
// ID: falsch;
// Name: wahr;
// }