Interface vs type alias decision in Typescript - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of extending interfaces vs type aliases

What is the output of this TypeScript code when compiled and run in a JavaScript environment?

Typescript

interface A {
  x: number;
}

type B = {
  y: string;
}

interface C extends A {
  z: boolean;
}

type D = B & {
  z: boolean;
}

const objC: C = { x: 10, z: true };
const objD: D = { y: "hello", z: false };

console.log(objC.x, objC.z);
console.log(objD.y, objD.z);

A 10 true\nhello false

B 10 true\nundefined false

C 10 undefined\nhello false

D undefined true\nhello false

💡 Hint

Interfaces can extend other interfaces, and type aliases can use intersection types (&) to combine types.

Interface C extends A, so objC has properties x and z. Type alias D combines B and an object with z, so objD has y and z. The console.log prints the values of these properties correctly.

🧠 Conceptual

intermediate

Choosing between interface and type alias for object shapes

Which statement best describes when to prefer an interface over a type alias for defining object shapes in TypeScript?

A Use an interface when you need to extend or implement it later; use a type alias for unions or primitives.

B Use a type alias only for classes; interfaces are for functions.

C Use a type alias when you want to extend it; interfaces cannot be extended.

D Use interfaces only for primitive types; type aliases only for objects.

💡 Hint

Think about how interfaces and type aliases behave with extension and implementation.

Interfaces are designed to be extended and implemented, making them ideal for object shapes that may grow. Type aliases are more flexible for unions, primitives, and complex types but cannot be implemented or reopened.

🔧 Debug

advanced

Why does this type alias cause an error?

This TypeScript code causes an error. What is the reason?

Typescript

type Person = {
  name: string;
}

type Person = {
  age: number;
};

A Type aliases must always be declared with the keyword 'interface'.

B Type aliases cannot contain more than one property.

C Type aliases cannot be redeclared with the same name; this causes a duplicate identifier error.

D The second type alias must use 'extends' keyword to add properties.

💡 Hint

Consider how TypeScript treats multiple declarations of the same type alias name.

Unlike interfaces, type aliases cannot be reopened or redeclared with the same name. This code tries to declare 'Person' twice, causing a duplicate identifier error.

❓ Predict Output

advanced

Output of intersection types vs interface merging

What is the output of this TypeScript code when compiled and run?

Typescript

interface X {
  a: number;
}

interface X {
  b: string;
}

type Y = { a: number } & { b: string };

const objX: X = { a: 5, b: "hello" };
const objY: Y = { a: 5, b: "hello" };

console.log(objX.b);
console.log(objY.b);

A hello\nundefined

B 5\nhello

C undefined\nhello

D hello\nhello

💡 Hint

Interfaces with the same name merge their properties automatically.

Interfaces with the same name merge, so interface X has both a and b. The intersection type Y combines two object types with a and b. Both objX and objY have property b with value 'hello'.

🧠 Conceptual

expert

When does a type alias support features interfaces do not?

Which of the following features can a type alias support but an interface cannot in TypeScript?

A Extending multiple interfaces

B Union and intersection types

C Declaration merging

D Implementing by classes

💡 Hint

Think about the flexibility of type aliases with complex types.

Type aliases can represent union and intersection types, which interfaces cannot. Interfaces support declaration merging and can be implemented by classes, but cannot represent unions.