Quando você não quer se repetir, às vezes um tipo precisa ser baseado em outro tipo.
Tipos mapeados são construídos sobre a sintaxe de assinaturas de índice, que servem para declarar os tipos de propriedades que não foram declaradas antecipadamente:
tsTrytypeOnlyBoolsAndHorses = {[key : string]: boolean |Horse ;};constconforms :OnlyBoolsAndHorses = {del : true,rodney : false,};
Um tipo mapeado é um tipo genérico que usa uma união de PropertyKeys (geralmente criada via keyof) para percorrer as chaves e criar um tipo:
tsTrytypeOptionsFlags <Type > = {[Property in keyofType ]: boolean;};
Neste exemplo, OptionsFlags pega todas as propriedades do tipo Type e muda os valores delas para booleano.
tsTrytypeFeatures = {darkMode : () => void;newUserProfile : () => void;};typeFeatureOptions =OptionsFlags <Features >;
Modificadores de mapeamento
Existem dois modificadores adicionais que podem ser aplicados durante o mapeamento: readonly e ?, que afetam, respectivamente, a mutabilidade e a opcionalidade.
Você pode remover ou adicionar esses modificadores com o prefixo - ou +. Se você não colocar um prefixo, o + é assumido.
tsTry// Removes 'readonly' attributes from a type's propertiestypeCreateMutable <Type > = {-readonly [Property in keyofType ]:Type [Property ];};typeLockedAccount = {readonlyid : string;readonlyname : string;};typeUnlockedAccount =CreateMutable <LockedAccount >;
tsTry// Removes 'optional' attributes from a type's propertiestypeConcrete <Type > = {[Property in keyofType ]-?:Type [Property ];};typeMaybeUser = {id : string;name ?: string;age ?: number;};typeUser =Concrete <MaybeUser >;
Remapeamento de chaves via as
A partir do TypeScript 4.1, você pode remapear chaves em tipos mapeados com uma cláusula as dentro do tipo mapeado:
tstype MappedTypeWithNewProperties<Type> = {[Properties in keyof Type as NewKeyType]: Type[Properties]}
Você pode usar recursos como tipos de template literal para criar novos nomes de propriedade a partir dos anteriores:
tsTrytypeGetters <Type > = {[Property in keyofType as `get${Capitalize <string &Property >}`]: () =>Type [Property ]};interfacePerson {name : string;age : number;location : string;}typeLazyPerson =Getters <Person >;
Você pode filtrar chaves produzindo never por meio de um tipo condicional:
tsTry// Remove the 'kind' propertytypeRemoveKindField <Type > = {[Property in keyofType asExclude <Property , "kind">]:Type [Property ]};interfaceCircle {kind : "circle";radius : number;}typeKindlessCircle =RemoveKindField <Circle >;
Você pode mapear sobre uniões arbitrárias, não apenas uniões de string | number | symbol, mas uniões de qualquer tipo:
tsTrytypeEventConfig <Events extends {kind : string }> = {[E inEvents asE ["kind"]]: (event :E ) => void;}typeSquareEvent = {kind : "square",x : number,y : number };typeCircleEvent = {kind : "circle",radius : number };typeConfig =EventConfig <SquareEvent |CircleEvent >
Exploração adicional
Tipos mapeados funcionam bem com outros recursos desta seção de manipulação de tipos. Por exemplo, aqui está um tipo mapeado que usa um tipo condicional, que retorna true ou false dependendo de o objeto ter a propriedade pii definida com o literal true:
tsTrytypeExtractPII <Type > = {[Property in keyofType ]:Type [Property ] extends {pii : true } ? true : false;};typeDBFields = {id : {format : "incrementing" };name : {type : string;pii : true };};typeObjectsNeedingGDPRDeletion =ExtractPII <DBFields >;