Início / coding / Perguntas / 79584188
Accepted
Ibrahim.Sluma
Asked: 2025-04-21 15:22:07 +0800 CST

Converter todas as propriedades de um tipo para outro [duplicado]

  • 772

Estou tentando criar um tipo genérico que altere qualquer tipo de propriedade de um para outro. Funciona se eu criar um novo objeto com o novo tipo convertido, mas gera erros se eu tentar convertê-lo dinamicamente usando o tipo de interface antigo:

Código:

export type ConvertTypes<B, F, T> = { [K in keyof B]: B[K] extends F ? T : B[K] }
export type ConvertStringToDate<T> = ConvertTypes<T, string, Date>

interface ITest {
  aa: number;
  bb: string;
  cc: Date;
}

// Working
const test :ITest = {
  aa: 1,
  bb: 'test',
  cc: new Date()
}

// Working
const test2: ConvertStringToDate<ITest> = {
  aa: 1,
  bb: new Date(),
  cc: new Date()
}

let test3: ConvertStringToDate<ITest>

// Not Working
for (let field of Object.keys(test)) {
  test3[field] = typeof test[field] === 'string' ? new Date() : test[field]
}

Erros:

Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ConvertTypes<ITest, string, Date>'.
  No index signature with a parameter of type 'string' was found on type 'ConvertTypes<ITest, string, Date>'.
Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ITest'.
  No index signature with a parameter of type 'string' was found on type 'ITest'.
Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'ITest'.
  No index signature with a parameter of type 'string' was found on type 'ITest'.

O código testado deve funcionar bem e converter valores de testvariáveis ​​para novas variáveis test3.

typescript

1 respostas

  1. Best Answer

    À primeira vista, pode parecer bobo que o TS não lide com a iteração de chaves facilmente. Mas, ao se aprofundar, você perceberá que iterar chaves de objetos é inseguro em geral, pois um objeto pode conter quaisquer chaves adicionais não presentes em seu tipo. É por isso que o tipo da chave é inferido para stringrefletir isso. Portanto, uma maneira segura seria operar apenas com chaves conhecidas pertencentes ao tipo.

    No nosso caso, podemos verificar se as chaves estão associadas a um tipo de valor apropriado com proteções de tipo personalizadas:

    Parque infantil

    let test3 = {} as ConvertStringToDate<ITest>

const objKeys = Object.keys(test) as Array<keyof ITest>;

type KeysOfType<T, P> = keyof {[K in keyof T as T[K] extends P ? K : never]: any}

const isStringKey = <T, K extends keyof T>(obj:T, key: K): key is KeysOfType<T, string> => typeof obj[key] === 'string';
const isNumberKey = <T, K extends keyof T>(obj:T, key: K): key is KeysOfType<T, number> => typeof obj[key] === 'number';
const isDateKey = <T, K extends keyof T>(obj:T, key: K): key is KeysOfType<T, Date> => obj[key] instanceof Date;

for (let field of objKeys) {
  if(isStringKey(test, field))
    test3[field] = new Date() // bb
  else if(isDateKey(test, field))
    test3[field] = test[field] // cc
  else if(isNumberKey(test, field))
    test3[field] = test[field] // aa
}

    Em código real eu não me incomodaria, pois o tempo de execução é simples e basta usar any:

    for (let field of objKeys) {
  (test3 as any)[field] = typeof test[field] === 'string' ? new Date(test[field]) : test[field];
}
    • 1

relate perguntas