{"componentChunkName":"component---src-templates-docs-js","path":"/docs/code-splitting.html","result":{"data":{"markdownRemark":{"html":"
\n
\n

These docs are old and won’t be updated. Go to react.dev for the new React docs.

\n

These new documentation pages teach modern React and include live examples:

\n\n
\n
\n

Bundling

\n

Most React apps will have their files “bundled” using tools like Webpack, Rollup or Browserify. Bundling is the process of following imported files and merging them into a single file: a “bundle”. This bundle can then be included on a webpage to load an entire app at once.

\n

Example

\n

App:

\n
// app.js\nimport { add } from './math.js';\n\nconsole.log(add(16, 26)); // 42
\n
// math.js\nexport function add(a, b) {\n  return a + b;\n}
\n

Bundle:

\n
function add(a, b) {\n  return a + b;\n}\n\nconsole.log(add(16, 26)); // 42
\n
\n

Note:

\n

Your bundles will end up looking a lot different than this.

\n
\n

If you’re using Create React App, Next.js, Gatsby, or a similar tool, you will have a Webpack setup out of the box to bundle your app.

\n

If you aren’t, you’ll need to set up bundling yourself. For example, see the Installation and Getting Started guides on the Webpack docs.

\n

Code Splitting

\n

Bundling is great, but as your app grows, your bundle will grow too. Especially if you are including large third-party libraries. You need to keep an eye on the code you are including in your bundle so that you don’t accidentally make it so large that your app takes a long time to load.

\n

To avoid winding up with a large bundle, it’s good to get ahead of the problem and start “splitting” your bundle. Code-Splitting is a feature\nsupported by bundlers like Webpack, Rollup and Browserify (via factor-bundle) which can create multiple bundles that can be dynamically loaded at runtime.

\n

Code-splitting your app can help you “lazy-load” just the things that are currently needed by the user, which can dramatically improve the performance of your app. While you haven’t reduced the overall amount of code in your app, you’ve avoided loading code that the user may never need, and reduced the amount of code needed during the initial load.

\n

import()

\n

The best way to introduce code-splitting into your app is through the dynamic import() syntax.

\n

Before:

\n
import { add } from './math';\n\nconsole.log(add(16, 26));
\n

After:

\n
import(\"./math\").then(math => {\n  console.log(math.add(16, 26));\n});
\n

When Webpack comes across this syntax, it automatically starts code-splitting your app. If you’re using Create React App, this is already configured for you and you can start using it immediately. It’s also supported out of the box in Next.js.

\n

If you’re setting up Webpack yourself, you’ll probably want to read Webpack’s guide on code splitting. Your Webpack config should look vaguely like this.

\n

When using Babel, you’ll need to make sure that Babel can parse the dynamic import syntax but is not transforming it. For that you will need @babel/plugin-syntax-dynamic-import.

\n

React.lazy

\n

The React.lazy function lets you render a dynamic import as a regular component.

\n

Before:

\n
import OtherComponent from './OtherComponent';
\n

After:

\n
const OtherComponent = React.lazy(() => import('./OtherComponent'));
\n

This will automatically load the bundle containing the OtherComponent when this component is first rendered.

\n

React.lazy takes a function that must call a dynamic import(). This must return a Promise which resolves to a module with a default export containing a React component.

\n

The lazy component should then be rendered inside a Suspense component, which allows us to show some fallback content (such as a loading indicator) while we’re waiting for the lazy component to load.

\n
import React, { Suspense } from 'react';\n\nconst OtherComponent = React.lazy(() => import('./OtherComponent'));\n\nfunction MyComponent() {\n  return (\n    <div>\n      <Suspense fallback={<div>Loading...</div>}>\n        <OtherComponent />\n      </Suspense>\n    </div>\n  );\n}
\n

The fallback prop accepts any React elements that you want to render while waiting for the component to load. You can place the Suspense component anywhere above the lazy component. You can even wrap multiple lazy components with a single Suspense component.

\n
import React, { Suspense } from 'react';\n\nconst OtherComponent = React.lazy(() => import('./OtherComponent'));\nconst AnotherComponent = React.lazy(() => import('./AnotherComponent'));\n\nfunction MyComponent() {\n  return (\n    <div>\n      <Suspense fallback={<div>Loading...</div>}>\n        <section>\n          <OtherComponent />\n          <AnotherComponent />\n        </section>\n      </Suspense>\n    </div>\n  );\n}
\n

Avoiding fallbacks

\n

Any component may suspend as a result of rendering, even components that were already shown to the user. In order for screen content to always be consistent, if an already shown component suspends, React has to hide its tree up to the closest <Suspense> boundary. However, from the user’s perspective, this can be disorienting.

\n

Consider this tab switcher:

\n
import React, { Suspense } from 'react';\nimport Tabs from './Tabs';\nimport Glimmer from './Glimmer';\n\nconst Comments = React.lazy(() => import('./Comments'));\nconst Photos = React.lazy(() => import('./Photos'));\n\nfunction MyComponent() {\n  const [tab, setTab] = React.useState('photos');\n  \n  function handleTabSelect(tab) {\n    setTab(tab);\n  };\n\n  return (\n    <div>\n      <Tabs onTabSelect={handleTabSelect} />\n      <Suspense fallback={<Glimmer />}>\n        {tab === 'photos' ? <Photos /> : <Comments />}\n      </Suspense>\n    </div>\n  );\n}
\n

In this example, if tab gets changed from 'photos' to 'comments', but Comments suspends, the user will see a glimmer. This makes sense because the user no longer wants to see Photos, the Comments component is not ready to render anything, and React needs to keep the user experience consistent, so it has no choice but to show the Glimmer above.

\n

However, sometimes this user experience is not desirable. In particular, it is sometimes better to show the “old” UI while the new UI is being prepared. You can use the new startTransition API to make React do this:

\n
function handleTabSelect(tab) {\n  startTransition(() => {\n    setTab(tab);\n  });\n}
\n

Here, you tell React that setting tab to 'comments' is not an urgent update, but is a transition that may take some time. React will then keep the old UI in place and interactive, and will switch to showing <Comments /> when it is ready. See Transitions for more info.

\n

Error boundaries

\n

If the other module fails to load (for example, due to network failure), it will trigger an error. You can handle these errors to show a nice user experience and manage recovery with Error Boundaries. Once you’ve created your Error Boundary, you can use it anywhere above your lazy components to display an error state when there’s a network error.

\n
import React, { Suspense } from 'react';\nimport MyErrorBoundary from './MyErrorBoundary';\n\nconst OtherComponent = React.lazy(() => import('./OtherComponent'));\nconst AnotherComponent = React.lazy(() => import('./AnotherComponent'));\n\nconst MyComponent = () => (\n  <div>\n    <MyErrorBoundary>\n      <Suspense fallback={<div>Loading...</div>}>\n        <section>\n          <OtherComponent />\n          <AnotherComponent />\n        </section>\n      </Suspense>\n    </MyErrorBoundary>\n  </div>\n);
\n

Route-based code splitting

\n

Deciding where in your app to introduce code splitting can be a bit tricky. You want to make sure you choose places that will split bundles evenly, but won’t disrupt the user experience.

\n

A good place to start is with routes. Most people on the web are used to page transitions taking some amount of time to load. You also tend to be re-rendering the entire page at once so your users are unlikely to be interacting with other elements on the page at the same time.

\n

Here’s an example of how to setup route-based code splitting into your app using libraries like React Router with React.lazy.

\n
import React, { Suspense, lazy } from 'react';\nimport { BrowserRouter as Router, Routes, Route } from 'react-router-dom';\n\nconst Home = lazy(() => import('./routes/Home'));\nconst About = lazy(() => import('./routes/About'));\n\nconst App = () => (\n  <Router>\n    <Suspense fallback={<div>Loading...</div>}>\n      <Routes>\n        <Route path=\"/\" element={<Home />} />\n        <Route path=\"/about\" element={<About />} />\n      </Routes>\n    </Suspense>\n  </Router>\n);
\n

Named Exports

\n

React.lazy currently only supports default exports. If the module you want to import uses named exports, you can create an intermediate module that reexports it as the default. This ensures that tree shaking keeps working and that you don’t pull in unused components.

\n
// ManyComponents.js\nexport const MyComponent = /* ... */;\nexport const MyUnusedComponent = /* ... */;
\n
// MyComponent.js\nexport { MyComponent as default } from \"./ManyComponents.js\";
\n
// MyApp.js\nimport React, { lazy } from 'react';\nconst MyComponent = lazy(() => import(\"./MyComponent.js\"));
","frontmatter":{"title":"Code-Splitting","next":null,"prev":null},"fields":{"path":"content/docs/code-splitting.md","slug":"docs/code-splitting.html"}}},"pageContext":{"slug":"docs/code-splitting.html"}},"staticQueryHashes":[]}