Início / coding / Perguntas / 78665052
Accepted
dwjohnston
Asked: 2024-06-25 09:18:24 +0800 CST

Renomear as propriedades de um objeto usando um mapa de conversão em TypeScript?

  • 772

Estou tentando conseguir algo assim:

const input = {a: 1, b: "hello"}; 
const result = renameProperties(input,{a: "alpha", b: "beta"}); 
result.alpha // number
result.beta // string
result.foo //Property 'foo' does not exist on type...

Então minha função de conversão está assim:


export function renameProperties<
  TInput extends Record<string, unknown>,
  TConversionMap extends Record<keyof TInput, string>,
  TOutput extends // heres where I get stuck 
>(input: TInput, conversionMap: TConversionMap): TOutput {

}

Como primeiro passo, tenho:

TOutput extends {[K in TConversionMap[keyof TInput]] : string}

Isso não se comporta exatamente como eu quero - eu esperava que o resultado contivesse apenas chaves convertidas.

result.alpha // string
result.beta // string

result.foo //string  - but really was hoping to see an error here

A segunda parte envolveria reter o valor da entrada, eu estava pensando em algo como:

TOutput extends {[K in TConversionMap[keyof TInput]] : TInput[The Input key, if we can retain a reference to it]}

Como eu faria isso? Isso é possível?

typescript

1 respostas

  1. Best Answer

    Você deseja usar principalmente o remapeamento de chaves em tipos mapeados . Sua renameProperties()função deve ser genérica em T, o tipo de entrada e M, o tipo de mapeamento de teclas. Então, para cada key Kin keyof T, você cria uma propriedade com key M[K]:

    declare function renameProperties<
  T extends object,
  const M extends Record<keyof T, PropertyKey>
>(input: T, mapping: M):
  { [K in keyof T as M[K]]: T[K] }

    Aqui você pode ver que Mfoi restringido a algo com as mesmas chaves Te cujas propriedades são todas semelhantes a chaves ( PropertyKey).

    Isso lhe dá tudo que você precisa tecnicamente para que isso funcione.

    O único problema é que, se você escrever o objeto de mapeamento como um objeto literal para o mapeamento, o TypeScript, por padrão, não acompanhará os tipos literais dos valores das propriedades. Se você escrever {a: "x", b: "y"}, o TypeScript irá inferir isso como {a: string, b: string}, o que não ajuda você. Você gostaria de uma constafirmação em {a: "x", b: "y"} as constvez disso.

    Uma melhoria é criar M um constparâmetro de tipo , para que se o argumento de mapeamento for um objeto literal, o TypeScript irá tratá-lo como se a constafirmação estivesse lá, para que o chamador possa deixá-lo de fora:

    const input = { a: 1, b: "hello" };
const result = renameProperties(input, { a: "alpha", b: "beta" });
//    ^? const result: { alpha: number; beta: string; }

    Então isso funciona conforme desejado. Observe que se o mapeamento não for passado em linha, você precisará dessa constafirmação. Nada pode magicamente fazer isso funcionar para você:

    const mapping = { a: "x", b: "y" };
//    ^? const mapping: {a: string, b: string}
const r2 = renameProperties(input, mapping);
//    ^? const r2: { [k: string]: string | number }

    Então você iria querer

    const mapping = { a: "x", b: "y" } as const;
const r2 = renameProperties(input, mapping);
//    ^? const r2: { x: number; y: string }

    Link do Playground para o código

    • 1

relate perguntas