What is the difference between a class and an interface in TypeScript, and when should each be used?

That's a great choice! To give you the best chance at a high-scoring question, I will structure the body using clear headings, an MRE (Minimal, Reproducible Example), and a detailed explanation of the confusion points.

Here is the full text body for the question: "What is the difference between a class and an interface in TypeScript, and when should each be used?"

---

What is the Difference Between class and interface in TypeScript, and When Should Each Be Used?

I'm working on a large-scale application in TypeScript, and while I understand the basic purpose of both class and interface, I'm struggling with the best practices for choosing between them in common scenarios.

In traditional OOP languages (like Java or C#), the distinction is often clearer: interfaces define contracts, and classes define implementations. However, in TypeScript, both seem to define a "shape" or a "contract," and both can be used with the implements keyword.

This ambiguity makes it confusing to decide which construct is appropriate for different design tasks.

Minimal, Reproducible Example (MRE)

Consider the following two snippets. Both appear to enforce the same structural contract on an implementing class, yet they use different constructs:

Option 1: Using an interface

TypeScript

// Define the contract as an Interface interface ICar { model: string; startEngine(): void; } // Implement the interface class Sedan implements ICar { constructor(public model: string) {} startEngine() { console.log(`${this.model} engine started.`); } }

Option 2: Using an abstract class

TypeScript

// Define the contract as an Abstract Class abstract class AbstractCar { abstract model: string; abstract startEngine(): void; } // Extend/Implement the abstract class class Coupe extends AbstractCar { constructor(public model: string) { super(); } startEngine() { console.log(`${this.model} engine started.`); } }

Specific Points of Confusion

Compile-Time vs. Run-Time: I've read that interface is a compile-time concept that disappears in the compiled JavaScript, while class is a run-time concept. What are the practical implications of this difference? For example, if I need to check the type at runtime, does that immediately rule out using an interface?

Using implements: When a class uses implements ICar versus implements AbstractCar (or just extends AbstractCar), what is the fundamental difference in what TypeScript is checking or enforcing?

Use Cases and Best Practice: In a clean architecture or design pattern context:

Should interfaces always be used for defining data shapes (DTOs)?

Should classes only be used when including business logic, dependency injection, or run-time features (like new MyClass())?

I am looking for a definitive, best-practice answer that clearly outlines the technical distinctions and provides strong architectural guidance for real-world TypeScript applications.