Skip to main content

React’s flexibility is both its strength and its challenge. One area where this flexibility shines is in how components can be passed as props. Let’s dive into this concept, exploring various methods and their implications.

Note: We are creating FrontSage to help you ace your frontend-interviews. Subscription to the waiting list are now open, limited spots are available, give it a look!

The Motivation: Why Even Bother?

In React, components are the building blocks of our applications. Sometimes, we want these blocks to be dynamic, interchangeable, or even composable. Passing components as props allows us to achieve this dynamic composition. It’s like giving a painter different brushes to choose from; each brush (or component) can change the outcome of the painting (or UI).

Different Approaches to Passing Components

While there are numerous ways to pass components, we’ll focus on three primary methods:

  1. Passing as an Element
  2. Passing as a Component Reference
  3. Passing as a Render Prop

1. Passing as an Element: The Direct Approach

This is the most straightforward method. You directly pass a React element as a prop.

Example: Let’s consider a Dashboard component where we want to pass a Header element.

interface DashboardProps {
  headerElement: React.ReactElement;

function Dashboard({ headerElement }: DashboardProps) {
  return (
      {/* Rest of the dashboard content */}

// Usage:
<Dashboard headerElement={<CustomHeader title="My Dashboard" />} />

2. Passing as a Component Reference: The Flexible Approach

Here, instead of passing an instantiated element, we pass the component itself. This method offers more flexibility, especially when the parent component wants to inject some props.

Example: A Profile component where we want to pass a dynamic Avatar component.

interface ProfileProps {
  AvatarComponent: React.ComponentType<{ size: string }>;

function Profile({ AvatarComponent }: ProfileProps) {
  return (
      <AvatarComponent size="large" />
      {/* Rest of the profile details */}

// Usage:
<Profile AvatarComponent={UserAvatar} />

3. Passing as a Render Prop: The Controlled Approach

A more advanced pattern, the render prop technique involves passing a feature that returns a React element. This approach presents the parent aspect with more manage over the rendering method.

Example: A Gallery component wherein we need to bypass a custom render feature for each Image.

interface GalleryProps {
  renderImage: (img: { src: string }) => React.ReactElement;

function Gallery({ renderImage }: GalleryProps) {
  const images = getGalleryImages(); // Some function to fetch images

  return (
      { => renderImage(img))}

// Usage:
<Gallery renderImage={(img) => <CustomImage src={img.src} />} />

Comparative Analysis

  • Passing as an Element: Best for when you have a pre-configured component ready to be placed in the parent. It’s direct but offers less flexibility.
  • Passing as a Component Reference: Offers more flexibility than the direct approach. The parent can inject additional props, making it suitable for more dynamic scenarios.
  • Passing as a Render Prop: The most flexible but also the most complex. It’s perfect for scenarios where the parent needs significant control over how the child component renders.

Best Practices and Recommendations

While all methods have their place, it’s essential to choose the right approach for the right scenario:

  • For static components that don’t require additional props, Passing as an Element is concise and clear.
  • When you need to ensure consistency across the app, like theming or styling, Passing as a Component Reference is beneficial.
  • For highly dynamic components, where the parent dictates rendering based on complex logic, Passing as a Render Prop shines.

Bonus Tip: The Power of React.cloneElement

While we have mentioned numerous techniques of passing additives, there is a effective utility in React’s arsenal that deserves unique mention: React.CloneElement.

What is React.cloneElement?

React.cloneElement permits you to clone a React element and bypass new props to the cloned element. This can be surprisingly useful when you want to extend or modify the props of a child component without completely understanding its internal structure.

Imagine you have a wrapper that receives a child element. You want to give a few extra props to this child or modify its existing props based on conditions, without altering the authentic child aspect. This is in which React.cloneElement shines.

Example: Let’s say we have a TooltipWrapper component that wraps any component and provides a tooltip. We want to add a hover prop to the child to show the tooltip when hovered

interface TooltipWrapperProps {
  children: React.ReactElement;
  tooltipText: string;

function TooltipWrapper({ children, tooltipText }: TooltipWrapperProps) {
  const [isHovered, setIsHovered] = useState(false);

  const handleMouseOver = () => setIsHovered(true);
  const handleMouseOut = () => setIsHovered(false);

  const enhancedChild = React.cloneElement(children, {
    onMouseOver: handleMouseOver,
    onMouseOut: handleMouseOut,

  return (
      {isHovered && <div className="tooltip">{tooltipText}</div>}

// Usage:
<TooltipWrapper tooltipText="Hello!">
  <Button>Hover me!</Button>

In the example above, we’ve cloned the Button component and added onMouseOver and onMouseOut handlers to it. This allows the TooltipWrapper to display a tooltip when the button is hovered, without the Button component needing any knowledge of the tooltip logic.


While React.cloneElement is powerful, it should be used judiciously. Overusing it can make the component structure harder to understand and debug. It’s best suited for scenarios where you need to enhance or modify children in generic wrapper components.


For more insightful content and to master frontend interviews, explore our comprehensive resource at FrontSage. Stay tuned for more exercises in this series, and let’s continue our journey towards frontend mastery together!

React’s flexibility in component composition is a double-edged sword. While it offers immense power, it also demands careful consideration. By understanding the nuances of each method, developers can make informed decisions, leading to cleaner, more maintainable code.