There could be little doubt that React has revolutionized the best way we construct person interfaces. It’s simple to study and drastically facilitates creating reusable elements that supply your web site a constant feel and look.

Nevertheless, as React solely takes care of the view layer of an software, it doesn’t implement any particular structure (equivalent to MVC or MVVM). This will make it tough to maintain your codebase organized as your React undertaking grows.

Key Takeaways

  1. React’s Flexibility and Challenges: Whereas React is user-friendly and enhances the creation of reusable UI elements, its flexibility in structure can pose organizational challenges in massive tasks.

  2. Efficient Methods in Giant-Scale React Purposes: The article outlines finest practices and environment friendly methods for managing large-scale React purposes, as exemplified by the event of PhotoEditorSDK at 9elements.

  3. Key Practices for Scalable React Improvement: It delves into important practices equivalent to listing structure optimization, CSS in JavaScript strategies, and superior ideas like customized hooks, the “Operate as Kids” sample, and render props, offering insights into scalable and maintainable React improvement.

Sensible Classes Realized

At 9elements, considered one of our flagship merchandise is PhotoEditorSDK — a totally customizable photograph editor that simply integrates into your HTML5, iOS or Android app. PhotoEditorSDK is a large-scale React app aimed toward builders. It requires excessive efficiency, small builds, and must be very versatile as regards to styling and particularly theming.

All through the various iterations of PhotoEditorSDK, my workforce and I’ve picked up numerous finest practices for organizing a big React app, a few of which we’d wish to share with you on this article:

  1. Directory Layout
  2. CSS in JavaScript
  3. Custom Hooks
  4. Function as Children Pattern
  5. Render Props

1. Listing Format

Initially, the styling and the code for our elements have been separated. All types lived in a shared CSS file (we use SCSS for preprocessing). The precise part (on this case FilterSlider), was decoupled from the types:

├── elements
│   └── FilterSlider
│       ├──  __tests__
│       │   └── FilterSlider-test.js
│       └── FilterSlider.jsx
└── types
    └── photo-editor-sdk.scss

Over a number of refactorings, we discovered that this method didn’t scale very effectively. Sooner or later, our elements would have to be shared between a number of inner tasks, just like the SDK and an experimental textual content instrument we’re presently growing. So we switched to a component-centric file structure:

    └── FilterSlider
        ├── __tests__
        │   └── FilterSlider-test.js
        ├── FilterSlider.jsx
        └── FilterSlider.scss

The concept was that each one the code that belongs to a part (equivalent to JavaScript, CSS, property, assessments) is situated in a single folder. This makes it very simple to extract the code into an npm module or, in case you’re in a rush, to easily share the folder with one other undertaking.

Importing elements

One of many drawbacks of this listing construction is that importing elements requires you to import the totally certified path, like so:

import FilterSlider from 'elements/FilterSlider/FilterSlider'

However what we’d actually like to put in writing is that this:

import FilterSlider from 'elements/FilterSlider'

To unravel this drawback, you’ll be able to create an index.js and instantly export the default:

export { default } from './FilterSlider';

One other answer is a little bit bit extra intensive, however it makes use of a Node.js customary resolving mechanism, making it rock strong and future-proof. All we do is add a package deal.json file to the file construction:

    └── FilterSlider
        ├── __tests__
        │   └── FilterSlider-test.js
        ├── FilterSlider.jsx
        ├── FilterSlider.scss
        └── package deal.json

And inside package deal.json, we use the main property to set our entry level to the part, like so:

  "fundamental": "FilterSlider.jsx"

With that addition, we are able to import a part like this:

import FilterSlider from 'elements/FilterSlider'

2. CSS in JavaScript

Styling, and particularly theming, has all the time been a little bit of an issue. As talked about above, in our first iteration of the app we had a giant CSS (SCSS) file, through which all of our courses lived. To keep away from identify collisions, we used a worldwide prefix and adopted the BEM conventions to craft CSS rule names. When our software grew, this method didn’t scale very effectively, so we looked for a alternative. First we evaluated CSS modules, however at the moment they’d some efficiency points. Additionally, extracting the CSS through webpack’s Extract Text plugin didn’t work that effectively (though it needs to be OK on the time of writing). Moreover, this method created a heavy dependency on webpack and made testing fairly tough.

Subsequent, we evaluated a few of the different CSS-in-JS options that had not too long ago arrived on the scene:

Selecting considered one of these libraries closely is determined by your use case:

  • Do you want the library to spit out a compiled CSS file for manufacturing? EmotionJS and Linaria can do this! Linaria even doesn’t require a runtime. It maps props to CSS through CSS variables, which guidelines out IE11 assist — however who wants IE11 anyhow?
  • Does it have to run on the server? That’s no drawback for current variations of all libraries!

For the listing construction we wish to put all of the types in a types.js:

export const Part = styled.part`
  padding: 4em;
  background: papayawhip;

This manner, pure front-end of us are additionally in a position to edit some types with out coping with React, however they need to study minimal JavaScript and the way to map props to CSS attributes:

    └── FilterSlider
        ├── __tests__
        │   └── FilterSlider-test.js
        ├── types.js
        ├── FilterSlider.jsx
        └── index.js

It’s a very good apply to declutter your fundamental part file from HTML.

Striving for the Single Accountability of React Elements

Whenever you develop extremely summary UI elements, it’s generally exhausting to separate the issues. At some factors, your part will want a sure area logic out of your mannequin, after which issues get messy. Within the following sections, we’d like to point out you sure strategies for DRYing up your elements. The next strategies overlap in performance, and selecting the best one on your structure is extra a desire in fashion quite than primarily based on exhausting information. However let me introduce the use instances first:

  • We needed to introduce a mechanism to take care of elements which can be context-aware of the logged-in person.
  • We needed to render a desk with a number of collapsible <tbody> parts.
  • We needed to show totally different elements relying on totally different states.

Within the following part, I’ll present totally different options for the issues described above.

3. Customized Hooks

Typically you must be sure that a React part is just displayed when a person has logged in to your software. Initially, you’ll do some sanity checks whereas rendering till you uncover that you simply’re repeating your self rather a lot. In your mission to DRY up that code, you’ll eventually have to put in writing custom hooks. Don’t be afraid: it’s not that arduous. Check out the next instance:

import { useEffect } from 'react';
import { useAuth } from './use-auth-from-context-or-state-management.js';
import { useHistory } from 'react-router-dom';

operate useRequireAuth(redirectUrl = "/signup") {
  const auth = useAuth();
  const historical past = useHistory();

  useEffect(() => {
    if (auth.person === false) {
      historical past.push(redirectUrl);
  }, [auth, history]);
  return auth;

The useRequireAuth hook will examine if a person is logged in and in any other case redirect to a distinct web page. The logic within the useAuth hook could be supplied through context or a state administration system like MobX or Redux.

4. Operate as Kids Sample

Making a collapsible desk row will not be a really simple job. How do you render the collapse button? How will we show the youngsters when the desk isn’t collapsed? I do know that with JSX 2.0 issues have develop into a lot simpler, as you’ll be able to return an array as a substitute of a single tag, however I’ll increase on this instance, because it illustrates a very good use case for the operate as youngsters sample. Think about the next desk:

export default operate Desk({ youngsters }) {
  return (
          <th>Only a desk</th>

And a collapsible desk physique:

import { useState } from 'react';

export default operate CollapsibleTableBody({ youngsters }) {
  const [collapsed, setCollapsed] = useState(false);

  const toggleCollapse = () => {

  return (
      {youngsters(collapsed, toggleCollapse)}

You’d use this part within the following means:

    {(collapsed, toggleCollapse) => {
      if (collapsed) {
        return (
              <button onClick={toggleCollapse}>Open</button>
      } else {
        return (
              <button onClick={toggleCollapse}>Closed</button>

You merely go a operate as youngsters, which will get known as in mum or dad part. You may also have seen this method known as a “render callback” or, in particular instances, as a “render prop”.

5. Render Props

The time period “render prop” was coined by Michael Jackson, who recommended that the higher-order component pattern could be replaced 100% of the time with a regular component with a “render prop”. The essential concept right here is that each one React elements are capabilities and capabilities could be handed as props. So why not go React elements through props?! Simple!

The next code tries to generalize the way to fetch knowledge from an API. (Please be aware that this instance is only for demonstration functions. In actual tasks, you’d even summary this fetch logic right into a useFetch hook to decouple it even farther from the UI.) Right here’s the code:

import { useEffect, useState } from "react";

export default operate Fetch({ render, url }) {

  const [state, setState] = useState({
    knowledge: {},
    isLoading: false

  useEffect(() => {
    setState({ knowledge: {}, isLoading: true });

    const _fetch = async () => {
      const res = await fetch(url);
      const json = await res.json();

        knowledge: json,
        isLoading: false,


  return render(state);

As you’ll be able to see, there’s a property known as render, which is a operate known as through the rendering course of. The operate known as inside it will get the whole state as its parameter, and returns JSX. Now have a look at the next utilization:

  render={({ knowledge, isLoading }) => (
      <h2> repos</h2>
      {isLoading && <h2>Loading...</h2>}

        {knowledge.size > 0 && => (
          <li key={}>
  )} />

As you’ll be able to see, the knowledge and isLoading parameters are destructured from the state object and can be utilized to drive the response of the JSX. On this case, so long as the promise hasn’t been fulfilled, a “Loading” headline is proven. It’s as much as you which of them components of the state you go to the render prop and the way you employ them in your person interface. Total, it’s a really highly effective mechanism to extract frequent UI conduct. The operate as youngsters sample described above is mainly the identical sample the place the property is youngsters.

Protip: Because the render prop sample is a generalization of the operate as youngsters sample, there’s nothing to cease you from having a number of render props on one part. For instance, a Desk part might get a render prop for the header after which one other one for the physique.

Let’s Maintain the Dialogue Going

I hope you loved this put up about architectural React patterns. If you happen to’re lacking one thing on this article (there are undoubtedly extra finest practices), or in the event you’d identical to to get in contact, please ping me on Twitter.

FAQs About React Structure

What’s the structure of React?

React is a JavaScript library for constructing person interfaces with a component-based structure. It employs a digital DOM to optimize efficiency by minimizing direct DOM manipulation, and knowledge flows in a one-way course from mum or dad to little one elements. JSX is used for describing UI elements, and React permits elements to handle their very own state. Moreover, React affords lifecycle strategies for dealing with part occasions, and client-side routing could be managed with libraries like React Router in single-page purposes.

Is React a MVC?

No, React will not be a Mannequin-View-Controller (MVC) framework. React is a library for constructing person interfaces, and it focuses totally on the “View” a part of the MVC structure. It supplies a strategy to create person interface elements and handle their rendering effectively. React, whereas it may be used to create person interfaces, doesn’t prescribe a particular mannequin or controller layer. It may be built-in with different libraries or frameworks to deal with these elements, like Redux for state administration or customized JavaScript code for dealing with software logic (controller). So, React is extra targeted on the “V” (View) a part of the MVC sample and could be mixed with different instruments and patterns to implement the total MVC structure in an online software.

Is React a component-based structure?

Sure, React is primarily recognized for its component-based structure. It encourages builders to interrupt down the person interface into reusable and self-contained elements. Every part represents part of the person interface and may have its personal logic and state. This method promotes modularity, reusability, and maintainability in constructing internet purposes. React’s component-based structure is considered one of its key options and is central to how builders construction and construct person interfaces with React.

Is there a really helpful strategy to construction React tasks?

Sure, there are a number of frequent patterns and really helpful methods to construction React tasks, though the particular construction can range relying on the undertaking’s dimension and complexity. Here’s a common really helpful undertaking construction for organizing a React software:
├── src/
│ ├── elements/
│ │ ├── Component1.js
│ │ ├── Component2.js
│ │ └── …
│ ├── pages/
│ │ ├── House.js
│ │ ├── About.js
│ │ ├── Contact.js
│ │ └── …
│ ├── property/
│ │ ├── photographs/
│ │ ├── types/
│ │ └── …
│ ├── App.js
│ ├── index.js
│ └── …
├── public/
│ ├── index.html
│ ├── manifest.json
│ └── …
├── package deal.json
├── package-lock.json
└── …

src: That is the place the primary supply code of your React software resides.
elements: Retailer your reusable UI elements on this listing.
pages: Create separate recordsdata for every main web page or route of your software. Every file can signify a particular view or web page of your app.
property: Place property like photographs, stylesheets, fonts, or every other static recordsdata right here.
App.js: The foundation part of your software, the place you sometimes outline your routes and general software construction.
index.js: The entry level on your React software, the place you render the foundation part and join it to the DOM.
public: This listing incorporates static property which can be publicly accessible.
index.html: The principle HTML file that serves because the entry level on your software.
package deal.json: The file that incorporates undertaking metadata and dependencies. A documentation file on your undertaking.

This can be a primary construction, and for bigger tasks, chances are you’ll need to additional manage your code into subdirectories primarily based on performance or options. Moreover, you need to use instruments like Create React App or different customized construct setups to scaffold your undertaking construction robotically.

Keep in mind that the particular construction can range relying in your workforce’s preferences, undertaking necessities, and the instruments and libraries you’re utilizing (equivalent to Redux for state administration or React Router for routing). It’s necessary to maintain your undertaking organized and maintainable because it grows.

What Is the distinction between React and React Native structure?

The architectures of React and React Native exhibit each similarities and variations, primarily stemming from their distinct goal platforms and rendering mechanisms.

Platform Goal: React is primarily meant for constructing internet purposes and person interfaces that run in internet browsers. It operates by rendering elements to a digital DOM, which is then reconciled with the precise DOM in internet purposes. However, React Native is tailor-made for cellular software improvement, focusing on iOS and Android platforms. It permits builders to leverage React’s component-based method to create native cellular person interfaces. React Native achieves a local feel and look by rendering elements on to native person interface parts, equivalent to native buttons and textual content views.
Rendering: React depends on rendering elements to a digital DOM, a illustration of the particular DOM in reminiscence. This digital DOM optimization minimizes direct manipulation of the actual DOM, enhancing efficiency. In distinction, React Native bypasses the net’s DOM fully and renders elements on to native UI parts. It makes use of a bridge to facilitate communication between JavaScript and native code for rendering, leading to true native efficiency and look.
Elements: React affords a set of elements that map to HTML parts (e.g., divs, spans, inputs), permitting builders to create customized elements. React Native, alternatively, supplies a distinct set of elements (e.g., View, Textual content, Button) that correspond to native person interface parts. Builders can lengthen and elegance these elements utilizing a CSS-like styling system tailored for native elements.
Styling: Styling in React is usually achieved utilizing customary CSS, CSS-in-JS options, or CSS pre-processors. React Native employs a distinct styling system that resembles CSS however is personalized for native elements. Styling is achieved by JavaScript objects, and types are platform-specific, making certain a local feel and look on every goal platform.
API Entry: React can entry internet APIs straight, which is helpful for duties like making HTTP requests. In distinction, React Native abstracts device-specific APIs utilizing a set of JavaScript modules, permitting builders to work together with native options, entry system sensors, and carry out community operations in a cross-platform method.
Third-Get together Libraries: React has an enormous ecosystem of third-party libraries and elements primarily tailor-made for internet improvement. React Native, in distinction, maintains its personal ecosystem of third-party libraries and elements personalized for cellular app improvement. These libraries usually wrap native performance and supply mobile-specific options.

In abstract, whereas React and React Native each adhere to a component-based structure and share an identical programming mannequin, their architectural variations come up from their distinctive rendering engines and elements optimized for his or her respective goal platforms—internet for React and native cellular for React Native. Understanding these distinctions is essential for choosing the suitable instrument on your undertaking and transitioning between internet and cellular improvement with React.