Composition vs Inheritance

React has a powerful composition model, and we recommend using composition instead of inheritance to reuse code between components.
In this section, we will consider a few problems where developers new to React often reach for inheritance, and show how we can solve them with composition.
Containment
Some components don’t know their children ahead of time. This is especially common for components like Sidebar or Dialog that represent generic “boxes”.
We recommend that such components use the special children prop to pass children elements directly into their output:
1
function FancyBorder(props) {
2
  return (
3
    <div className={'FancyBorder FancyBorder-' + props.color}>
4
      {props.children}    </div>
5
  );
6
}
Copied!
This lets other components pass arbitrary children to them by nesting the JSX:
1
function WelcomeDialog() {
2
  return (
3
    <FancyBorder color="blue">
4
      <h1 className="Dialog-title">        Welcome      </h1>      <p className="Dialog-message">        Thank you for visiting our spacecraft!      </p>    </FancyBorder>
5
  );
6
}
Copied!
​Try it on CodePen​
Anything inside the <FancyBorder> JSX tag gets passed into the FancyBorder component as a children prop. Since FancyBorder renders {props.children} inside a <div>, the passed elements appear in the final output.
While this is less common, sometimes you might need multiple “holes” in a component. In such cases you may come up with your own convention instead of using children:
1
function SplitPane(props) {
2
  return (
3
    <div className="SplitPane">
4
      <div className="SplitPane-left">
5
        {props.left}      </div>
6
      <div className="SplitPane-right">
7
        {props.right}      </div>
8
    </div>
9
  );
10
}
11
​
12
function App() {
13
  return (
14
    <SplitPane
15
      left={
16
        <Contacts />      }
17
      right={
18
        <Chat />      } />
19
  );
20
}
Copied!
​Try it on CodePen​
​
React elements like <Contacts /> and <Chat /> are just objects, so you can pass them as props like any other data. This approach may remind you of “slots” in other libraries but there are no limitations on what you can pass as props in React.
Specialization
Sometimes we think about components as being “special cases” of other components. For example, we might say that a WelcomeDialog is a special case of Dialog.
In React, this is also achieved by composition, where a more “specific” component renders a more “generic” one and configures it with props:
1
function Dialog(props) {
2
  return (
3
    <FancyBorder color="blue">
4
      <h1 className="Dialog-title">
5
        {props.title}      </h1>
6
      <p className="Dialog-message">
7
        {props.message}      </p>
8
    </FancyBorder>
9
  );
10
}
11
​
12
function WelcomeDialog() {
13
  return (
14
    <Dialog      title="Welcome"      message="Thank you for visiting our spacecraft!" />  );
15
}
Copied!
​Try it on CodePen​
Composition works equally well for components defined as classes:
1
function Dialog(props) {
2
  return (
3
    <FancyBorder color="blue">
4
      <h1 className="Dialog-title">
5
        {props.title}
6
      </h1>
7
      <p className="Dialog-message">
8
        {props.message}
9
      </p>
10
      {props.children}    </FancyBorder>
11
  );
12
}
13
​
14
class SignUpDialog extends React.Component {
15
  constructor(props) {
16
    super(props);
17
    this.handleChange = this.handleChange.bind(this);
18
    this.handleSignUp = this.handleSignUp.bind(this);
19
    this.state = {login: ''};
20
  }
21
​
22
  render() {
23
    return (
24
      <Dialog title="Mars Exploration Program"
25
              message="How should we refer to you?">
26
        <input value={this.state.login}               onChange={this.handleChange} />        <button onClick={this.handleSignUp}>          Sign Me Up!        </button>      </Dialog>
27
    );
28
  }
29
​
30
  handleChange(e) {
31
    this.setState({login: e.target.value});
32
  }
33
​
34
  handleSignUp() {
35
    alert(`Welcome aboard, ${this.state.login}!`);
36
  }
37
}
Copied!
​Try it on CodePen​
So What About Inheritance?
At Facebook, we use React in thousands of components, and we haven’t found any use cases where we would recommend creating component inheritance hierarchies.
Props and composition give you all the flexibility you need to customize a component’s look and behavior in an explicit and safe way. Remember that components may accept arbitrary props, including primitive values, React elements, or functions.
If you want to reuse non-UI functionality between components, we suggest extracting it into a separate JavaScript module. The components may import it and use that function, object, or a class, without extending it.

REACT-RESOURCES - Previous

Thinking in React

Next - REACT-RESOURCES

Using Web Components in React

Last modified 1mo ago

Copy link

Contents

Containment

Specialization

So What About Inheritance?