Free tools Windows power users keep installed
One-click scans. No signup required.
Use interface extends to define an object-shaped contract that should be checked for compatibility and may be extended. Use a type alias with & to compose existing types or describe a broader type expression, such as a union or tuple. The key difference is how conflicting properties behave: extends reports incompatible inherited members, while an intersection requires a value to satisfy both types.
Quick comparison
| Choose | When it fits | What to watch for |
|---|---|---|
interface Child extends Parent |
You are naming an object contract or building a hierarchy of compatible object shapes. | Incompatible inherited members produce a declaration error. |
type Combined = A & B |
You are composing types already defined, or need an alias for a union, tuple, primitive, or other type expression. | Same-name properties impose both constraints; they do not take turns or override one another. |
Both forms can describe an object that has the members of two compatible inputs. The choice is not simply stylistic when members conflict. The TypeScript Object Types handbook treats conflict handling as the principal distinction between interface extension and an intersection alias.
What happens when properties conflict?
With extends, incompatible inherited properties are rejected
interface HasId { id: string }
interface NumericId { id: number }
interface RecordWithId extends HasId, NumericId {} // ErrorThe compiler checks whether inherited members are compatible and flags this declaration. That makes extends useful when a child is intended to refine a contract but should not silently contradict it.
With &, both property requirements remain
type HasId = { id: string }
type NumericId = { id: number }
type RecordWithId = HasId & NumericIdThis does not mean the right-hand type wins. A value of RecordWithId must have an id satisfying both string and number, which no ordinary value can do. Intersections involving incompatible discriminant properties can be reduced to never by the compiler.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute#1 Best Overall
For ordinary compatible members, either composition can work. Use the one that makes the relationship and intended checks clearest; do not use an intersection to simulate an override.
When an interface is the better fit
- You are defining an object contract. Interfaces are natural for named object shapes and interface hierarchies.
- You want compatibility checked at the declaration. Extending interfaces makes incompatible inherited members an explicit error.
- You need intentional declaration merging. Separate declarations with the same interface name can add members, a capability used for designed extension points and some library augmentations.
- You want to implement the contract with a class. A class can implement an object-shaped interface, and its implementation must satisfy the declared members.
Declaration merging is distinct from extends: repeating an interface declaration is what merges members. Non-function members must have distinct names or compatible same-name types; incompatible same-name property types cause an error. Treat merging as part of an API design, not as a way to overwrite a declaration. See the TypeScript Declaration Merging handbook.
Rank #2
- TypeScript implements a superset of syntax for strictly typed development, facilitating deep static analysis and enhanced development environment integration. The compiler translates source into standard script formats, ensuring parity across any runtime.
- TypeScript is ideal for front-end developers, full-stack engineers, and software architects who build large-scale web applications. It serves those looking to improve code excellence, reduce bugs through static checking, and maintain complex projects more.
- Lightweight, Classic fit, Double-needle sleeve and bottom hem
When a type alias and intersection are the better fit
- You are composing existing types.
type View = Base & Auditedcan name a fixed composition. - The result is not just an object shape. Type aliases can name unions, primitives, tuples, intersections, and other type expressions.
- You do not want the declaration reopened. A type alias cannot be augmented later through declaration merging.
Interfaces and aliases overlap for object shapes, but aliases cover a wider range of type expressions. The Everyday Types handbook recommends choosing based on preference where neither form provides a needed capability, while noting that aliases cannot be reopened to add properties.
Does one form improve compiler performance?
The TypeScript handbook says interface extension can often be more performant for the compiler than intersection aliases. It gives no benchmark figure, so this is a qualified consideration, not a guarantee of a measurable speedup in every project. Prefer the clearer, accurate model first; investigate performance in your own project if type checking is a concern.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
How TypeScript version affects edge cases
Subtle intersection assignability behavior can depend on the compiler version. The TypeScript 3.9 release notes document stricter checks in some intersection cases and the reduction of incompatible discriminated intersections to never. Those notes describe changes in TypeScript 3.9, not a full behavior matrix for every release. When an example depends on such an edge case, check it with the TypeScript version your project actually uses.
A practical decision rule
- For a named object contract, start with an interface.
- If one object contract should build on another, use
extendsand let the compiler verify compatibility. - If you need to combine type expressions or represent a union, tuple, primitive, or other non-interface shape, use a type alias.
- Use
&only when the result should satisfy all constituent types. If same-name properties disagree, fix the model rather than expecting one side to override the other. - Use interface declaration merging only when consumers are meant to augment that contract.
These are defaults rather than rigid rules: for a compatible object shape, either syntax may express the relationship. Choose the form whose capabilities and conflict behavior match the design.
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
