The Case Against React.FC
You'll learn why the React community has largely moved away from React.FC and what problems it causes.
While React.FC seems convenient at first, it has several drawbacks that make explicit typing the preferred approach among experienced React developers.
The Implicit Children Problem
The biggest issue: React.FC historically included children in props automatically, even when your component didn't use them. This created a type lie — TypeScript said children were allowed when they weren't actually handled:
const Button: React.FC<{ onClick: () => void }> = ({ onClick }) => {
return <button onClick={onClick}>Click me</button>;
};
// This compiles but ignores the children:
<Button onClick={handleClick}>I'm ignored!</Button>
Think of it like a restaurant menu listing desserts when the kitchen doesn't actually make any — misleading information.
Verbosity Without Benefits
React.FC doesn't save typing anymore. Compare:
// With React.FC
const Button: React.FC<{ label: string }> = ({ label }) => {
return <button>{label}</button>;
};
// Explicit typing (preferred)
function Button({ label }: { label: string }) {
return <button>{label}</button>;
}
The explicit version is clearer and just as concise.
Friction with Modern Patterns
React.FC awkwardly handles generics, default props, and component composition patterns. It adds ceremony without corresponding value, forcing you to fight TypeScript rather than work with it naturally.
The Modern Consensus
Most React teams now explicitly type props where needed and let TypeScript infer return types. It's more straightforward, honest about what components accept, and aligns with how you already write JavaScript functions.
Key Takeaway: Avoid React.FC in favor of explicit props typing — it's clearer, more honest about children, and causes less friction with TypeScript's type inference.