Thursday, June 13, 2024
HomeJavaScriptFind out how to Improve to React 18 – React Weblog

Find out how to Improve to React 18 – React Weblog

As we shared within the launch publish, React 18 introduces options powered by our new concurrent renderer, with a gradual adoption technique for current functions. On this publish, we are going to information you thru the steps for upgrading to React 18.

Please report any points you encounter whereas upgrading to React 18.

Word for React Native customers: React 18 will ship in a future model of React Native. It is because React 18 depends on the New React Native Structure to learn from the brand new capabilities introduced on this blogpost. For extra data, see the React Conf keynote right here.

Putting in

To put in the newest model of React:

npm set up react react-dom

Or when you’re utilizing yarn:

Updates to Consumer Rendering APIs

If you first set up React 18, you will notice a warning within the console:

ReactDOM.render is not supported in React 18. Use createRoot as an alternative. Till you turn to the brand new API, your app will behave as if it’s working React 17. Be taught extra:

React 18 introduces a brand new root API which offers higher ergonomics for managing roots. The brand new root API additionally allows the brand new concurrent renderer, which lets you opt-into concurrent options.

import { render } from 'react-dom';
const container = doc.getElementById('app');
render(<App tab="house" />, container);

import { createRoot } from 'react-dom/shopper';
const container = doc.getElementById('app');
const root = createRoot(container); 
root.render(<App tab="house" />);

We’ve additionally modified unmountComponentAtNode to root.unmount:



We’ve additionally eliminated the callback from render, because it normally doesn’t have the anticipated consequence when utilizing Suspense:

const container = doc.getElementById('app');
render(<App tab="house" />, container, () => {

perform AppWithCallbackAfterRender() {
  useEffect(() => {

  return <App tab="house" />

const container = doc.getElementById('app');
const root = createRoot(container);
root.render(<AppWithCallbackAfterRender />);


There isn’t a one-to-one substitute for the outdated render callback API — it is dependent upon your use case. See the working group publish for Changing render with createRoot for extra data.

Lastly, in case your app makes use of server-side rendering with hydration, improve hydrate to hydrateRoot:

import { hydrate } from 'react-dom';
const container = doc.getElementById('app');
hydrate(<App tab="house" />, container);

import { hydrateRoot } from 'react-dom/shopper';
const container = doc.getElementById('app');
const root = hydrateRoot(container, <App tab="house" />);

For extra data, see the working group dialogue right here.


In case your app doesn’t work after upgrading, verify whether or not it’s wrapped in <StrictMode>. Strict Mode has gotten stricter in React 18, and never all of your parts could also be resilient to the brand new checks it provides in growth mode. If eradicating Strict Mode fixes your app, you’ll be able to take away it in the course of the improve, after which add it again (both on the prime or for part of the tree) after you repair the problems that it’s declaring.

Updates to Server Rendering APIs

On this launch, we’re revamping our react-dom/server APIs to totally help Suspense on the server and Streaming SSR. As a part of these adjustments, we’re deprecating the outdated Node streaming API, which doesn’t help incremental Suspense streaming on the server.

Utilizing this API will now warn:

  • renderToNodeStream: Deprecated ⛔️️

As an alternative, for streaming in Node environments, use:

  • renderToPipeableStream: New ✨

We’re additionally introducing a brand new API to help streaming SSR with Suspense for contemporary edge runtime environments, comparable to Deno and Cloudflare staff:

  • renderToReadableStream: New ✨

The next APIs will proceed working, however with restricted help for Suspense:

  • renderToString: Restricted ⚠️
  • renderToStaticMarkup: Restricted ⚠️

Lastly, this API will proceed to work for rendering e-mails:

For extra data on the adjustments to server rendering APIs, see the working group publish on Upgrading to React 18 on the server, a deep dive on the brand new Suspense SSR Structure, and Shaundai Individual’s discuss on Streaming Server Rendering with Suspense at React Conf 2021.

Updates to TypeScript definitions

In case your undertaking makes use of TypeScript, you will want to replace your @varieties/react and @varieties/react-dom dependencies to the newest variations. The brand new varieties are safer and catch points that was once ignored by the kind checker. Probably the most notable change is that the youngsters prop now must be listed explicitly when defining props, for instance:

interface MyButtonProps {
  colour: string;
  youngsters?: React.ReactNode;}

See the React 18 typings pull request for a full record of type-only adjustments. It hyperlinks to instance fixes in library varieties so you’ll be able to see find out how to modify your code. You should utilize the automated migration script to assist port your utility code to the brand new and safer typings quicker.

For those who discover a bug within the typings, please file a difficulty within the DefinitelyTyped repo.

Computerized Batching

React 18 provides out-of-the-box efficiency enhancements by doing extra batching by default. Batching is when React teams a number of state updates right into a single re-render for higher efficiency. Earlier than React 18, we solely batched updates inside React occasion handlers. Updates within guarantees, setTimeout, native occasion handlers, or some other occasion weren’t batched in React by default:

perform handleClick() {
  setCount(c => c + 1);
  setFlag(f => !f);

setTimeout(() => {
  setCount(c => c + 1);
  setFlag(f => !f);
}, 1000);

Beginning in React 18 with createRoot, all updates will probably be routinely batched, irrespective of the place they originate from. Because of this updates within timeouts, guarantees, native occasion handlers or some other occasion will batch the identical manner as updates within React occasions:

perform handleClick() {
  setCount(c => c + 1);
  setFlag(f => !f);

setTimeout(() => {
  setCount(c => c + 1);
  setFlag(f => !f);
}, 1000);

This can be a breaking change, however we count on this to end in much less work rendering, and due to this fact higher efficiency in your functions. To opt-out of automated batching, you should utilize flushSync:

import { flushSync } from 'react-dom';

perform handleClick() {
  flushSync(() => {
    setCounter(c => c + 1);
  flushSync(() => {
    setFlag(f => !f);

For extra data, see the Computerized batching deep dive.

New APIs for Libraries

Within the React 18 Working Group we labored with library maintainers to create new APIs wanted to help concurrent rendering to be used circumstances particular to their use case in areas like kinds, and exterior shops. To help React 18, some libraries may have to modify to one of many following APIs:

  • useSyncExternalStore is a brand new hook that permits exterior shops to help concurrent reads by forcing updates to the shop to be synchronous. This new API is advisable for any library that integrates with state exterior to React. For extra data, see the useSyncExternalStore overview publish and useSyncExternalStore API particulars.
  • useInsertionEffect is a brand new hook that permits CSS-in-JS libraries to deal with efficiency problems with injecting kinds in render. Except you’ve already constructed a CSS-in-JS library we don’t count on you to ever use this. This hook will run after the DOM is mutated, however earlier than format results learn the brand new format. This solves a difficulty that already exists in React 17 and under, however is much more vital in React 18 as a result of React yields to the browser throughout concurrent rendering, giving it an opportunity to recalculate format. For extra data, see the Library Improve Information for <model>.

React 18 additionally introduces new APIs for concurrent rendering comparable to startTransition, useDeferredValue and useId, which we share extra about within the launch publish.

Updates to Strict Mode

Sooner or later, we’d like so as to add a characteristic that permits React so as to add and take away sections of the UI whereas preserving state. For instance, when a person tabs away from a display screen and again, React ought to be capable to instantly present the earlier display screen. To do that, React would unmount and remount timber utilizing the identical part state as earlier than.

This characteristic will give React higher efficiency out-of-the-box, however requires parts to be resilient to results being mounted and destroyed a number of occasions. Most results will work with none adjustments, however some results assume they’re solely mounted or destroyed as soon as.

To assist floor these points, React 18 introduces a brand new development-only verify to Strict Mode. This new verify will routinely unmount and remount each part, every time a part mounts for the primary time, restoring the earlier state on the second mount.

Earlier than this variation, React would mount the part and create the consequences:

* React mounts the part.
    * Structure results are created.
    * Impact results are created.

With Strict Mode in React 18, React will simulate unmounting and remounting the part in growth mode:

* React mounts the part.
    * Structure results are created.
    * Impact results are created.
* React simulates unmounting the part.
    * Structure results are destroyed.
    * Results are destroyed.
* React simulates mounting the part with the earlier state.
    * Structure impact setup code runs
    * Impact setup code runs

For extra data, see the Working Group posts for Including Reusable State to StrictMode and Find out how to help Reusable State in Results.

Configuring Your Testing Setting

If you first replace your assessments to make use of createRoot, you may even see this warning in your check console:

The present testing atmosphere is just not configured to help act(…)

To repair this, set globalThis.IS_REACT_ACT_ENVIRONMENT to true earlier than working your check:


The aim of the flag is to inform React that it’s working in a unit test-like atmosphere. React will log useful warnings when you overlook to wrap an replace with act.

You too can set the flag to false to inform React that act isn’t wanted. This may be helpful for end-to-end assessments that simulate a full browser atmosphere.

Finally, we count on testing libraries will configure this for you routinely. For instance, the subsequent model of React Testing Library has built-in help for React 18 with none further configuration.

Extra background on the the act testing API and associated adjustments is accessible within the working group.

Dropping Help for Web Explorer

On this launch, React is dropping help for Web Explorer, which is going out of help on June 15, 2022. We’re making this variation now as a result of new options launched in React 18 are constructed utilizing trendy browser options comparable to microtasks which can’t be adequately polyfilled in IE.

If it’s essential help Web Explorer we suggest you stick with React 17.


  • react-dom: ReactDOM.render has been deprecated. Utilizing it’s going to warn and run your app in React 17 mode.
  • react-dom: ReactDOM.hydrate has been deprecated. Utilizing it’s going to warn and run your app in React 17 mode.
  • react-dom: ReactDOM.unmountComponentAtNode has been deprecated.
  • react-dom: ReactDOM.renderSubtreeIntoContainer has been deprecated.
  • react-dom/server: ReactDOMServer.renderToNodeStream has been deprecated.

Different Breaking Adjustments

  • Constant useEffect timing: React now at all times synchronously flushes impact capabilities if the replace was triggered throughout a discrete person enter occasion comparable to a click on or a keydown occasion. Beforehand, the habits wasn’t at all times predictable or constant.
  • Stricter hydration errors: Hydration mismatches because of lacking or further textual content content material are actually handled like errors as an alternative of warnings. React will not try and “patch up” particular person nodes by inserting or deleting a node on the shopper in an try and match the server markup, and can revert to shopper rendering as much as the closest <Suspense> boundary within the tree. This ensures the hydrated tree is constant and avoids potential privateness and safety holes that may be attributable to hydration mismatches.
  • Suspense timber are at all times constant: If a part suspends earlier than it’s absolutely added to the tree, React is not going to add it to the tree in an incomplete state or hearth its results. As an alternative, React will throw away the brand new tree fully, look forward to the asynchronous operation to complete, after which retry rendering once more from scratch. React will render the retry try concurrently, and with out blocking the browser.
  • Structure Results with Suspense: When a tree re-suspends and reverts to a fallback, React will now clear up format results, after which re-create them when the content material contained in the boundary is proven once more. This fixes a difficulty which prevented part libraries from appropriately measuring format when used with Suspense.
  • New JS Setting Necessities: React now is dependent upon trendy browsers options together with Promise, Image, and Object.assign. For those who help older browsers and units comparable to Web Explorer which don’t present trendy browser options natively or have non-compliant implementations, take into account together with a world polyfill in your bundled utility.

Different Notable Adjustments


  • Elements can now render undefined: React not warns when you return undefined from a part. This makes the allowed part return values according to values which are allowed in the course of a part tree. We advise to make use of a linter to forestall errors like forgetting a return assertion earlier than JSX.
  • In assessments, act warnings are actually opt-in: For those who’re working end-to-end assessments, the act warnings are pointless. We’ve launched an opt-in mechanism so you’ll be able to allow them just for unit assessments the place they’re helpful and useful.
  • No warning about setState on unmounted parts: Beforehand, React warned about reminiscence leaks if you name setState on an unmounted part. This warning was added for subscriptions, however folks primarily run into it in situations the place setting state is okay, and workarounds make the code worse. We’ve eliminated this warning.
  • No suppression of console logs: If you use Strict Mode, React renders every part twice that can assist you discover sudden unwanted effects. In React 17, we’ve suppressed console logs for one of many two renders to make the logs simpler to learn. In response to neighborhood suggestions about this being complicated, we’ve eliminated the suppression. As an alternative, when you’ve got React DevTools put in, the second log’s renders will probably be displayed in gray, and there will probably be an possibility (off by default) to suppress them fully.
  • Improved reminiscence utilization: React now cleans up extra inner fields on unmount, making the affect from unfixed reminiscence leaks that will exist in your utility code much less extreme.

React DOM Server

  • renderToString: Will not error when suspending on the server. As an alternative, it’s going to emit the fallback HTML for the closest <Suspense> boundary after which retry rendering the identical content material on the shopper. It’s nonetheless advisable that you just change to a streaming API like renderToPipeableStream or renderToReadableStream as an alternative.
  • renderToStaticMarkup: Will not error when suspending on the server. As an alternative, it’s going to emit the fallback HTML for the closest <Suspense> boundary.


You possibly can view the full changelog right here.



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments