Desafio TypeScript

Mesclando objetos com tipos precisos

Enunciado

Crie uma função mergeObjects que recebe dois objetos e retorna um novo objeto com as propriedades de ambos. Use múltiplos parâmetros genéricos com constraints extends object e o tipo de interseção T & U.

Requisitos

  • A função deve se chamar mergeObjects e aceitar obj1: T e obj2: U.
  • Os genéricos devem ter a constraint extends object.
  • O retorno deve ser T & U.
  • Deve mesclar as propriedades, com as do segundo objeto sobrescrevendo as do primeiro em caso de conflito.

Código inicial

// Complete a função mergeObjects
function mergeObjects<T extends object, U extends object>(obj1: T, obj2: U): T & U {
  // Seu código aqui
}

const obj1 = { a: 1, b: "texto" };
const obj2 = { b: 2, c: true };
const merged = mergeObjects(obj1, obj2);
console.log(merged); // { a: 1, b: 2, c: true }

Saída esperada

{ a: 1, b: 2, c: true }
Ver dica

Use o spread operator: { ...obj1, ...obj2 }. O TypeScript infere o tipo como T & U.

Mostrar solução 
// mergeObjects: combina dois objetos em um novo, com tipo de interseção.
function mergeObjects<T extends object, U extends object>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 }; // Spread: propriedades de obj2 sobrescrevem as de obj1
}

const obj1 = { a: 1, b: "texto" };
const obj2 = { b: 2, c: true };
const merged = mergeObjects(obj1, obj2);
console.log(merged); // { a: 1, b: 2, c: true }

Passo a passo

  1. mergeObjects recebe dois genéricos T e U, ambos com constraint extends object.
  2. Isso garante que só passamos objetos, não primitivos.
  3. O retorno é anotado como T & U, a interseção dos dois tipos.
  4. Usamos spread { ...obj1, ...obj2 } para criar um novo objeto.
  5. Propriedades de obj2 sobrescrevem as de obj1 se tiverem o mesmo nome.
  6. O resultado é impresso, mostrando b: 2 (do segundo objeto).

Por que funciona

A constraint extends object impede tipos primitivos. O tipo de interseção T & U combina as propriedades de ambos, e o spread faz a mesclagem em tempo de execução. O TypeScript infere corretamente o tipo resultante.

Erros comuns

  • Não usar extends object: permitiria mergeObjects(1, 2), causando erro em tempo de execução.
  • Esquecer o spread: retornar obj1 ou obj2 diretamente não mescla.
  • Anotar retorno como any: perde a precisão do tipo.

Outra forma de resolver

Poderia usar Object.assign({}, obj1, obj2), mas o spread é mais moderno e igualmente tipado.

Saída esperada

{ a: 1, b: 2, c: true }