The latest version of React (version 18) has been officially available since March 2022. It brought along many new features and behind the scenes changes which have made the framework even more powerful. React continues to be the first and preferred framework of choice for JavaScript developers and is always highly sought after in companies.
Many new features were introduced in React 18 and today we will cover some of the more popular ones because those features are likely to get used the most by developers in their projects. I will cover the following:
- React Suspense
- The New Root API
- The New useId hook
- The New useTransition hook
React Suspense
When using a REST API there are two ways to retrieve data. You can do them synchronously or asynchronously. Synchronous API calls are known as blocking calls because they are unable to return anything until the request has completed or there was some error returning the data. This type of API call locks up the application and prevents the user from doing anything until the action is done.
On the other hand an Asynchronous API call does the complete opposite to this. It is non blocking and the response is returned immediately while the request continues to process in the background. Your application remains responsive and does not lock up waiting for something to happen so you can continue to use it while the data is retrieved in the background. This gives the user a much better experience on the frontend.
Essentially React Suspense is asynchronous because it forces your components to wait for something to happen before they can render the data inside of the API or data structure. The components must wait for an asynchronous API call to complete fetching some data before it is rendered on a screen. Behind the scenes the data is loading and it is possible to show a fallback preloader to the user so that they are aware that something is happening on the frontend.
React Suspense Example
This is the the new syntax which uses React Suspense combined with the React.lazy() API.
App.js
// The new syntax for React 18 using React.lazy() to delay loading the component so that Suspense works properly.
import { Suspense, lazy } from 'react';
const Pokemon = lazy(() => {
return import('./Pokemon');
});
const App = () => {
return (
<Suspense fallback={<h1>Loading pokemon...</h1>}>
<Pokemon />
</Suspense>
);
};
export default App;
Pokemon.js
// The new syntax for React 18
import React, { useEffect, useState } from 'react';
const Pokemon = () => {
useEffect(() => {
const getPokemons = () => {
const API = 'http://pokeapi.co/api/v2/pokemon?limit=500';
fetch(API)
.then((response) => {
console.log(response);
return response.json();
})
.then((data) => {
console.log(data.results);
setData(data.results);
})
.catch((err) => {
console.log(err);
});
};
getPokemons();
}, []);
const [data, setData] = useState([]);
return (
<>
{/* You don't need a ternary operator with a variable for loading anymore */}
{data.map((pokemon) => (
<div key={pokemon.name}>
<h2>{pokemon.name}</h2>
</div>
))}
</>
);
};
export default Pokemon;
Ternary Operator Example
This is the old syntax which uses the JavaScript Ternary Operator combined with a variable state that checks if the data is loading or has loaded. It displays a preloader when the data has yet to be loaded and the data when it is complete.
App.js
// The old syntax
import Pokemon from './Pokemon';
const App = () => {
return (
<>
<Pokemon />
</>
);
};
export default App;
Pokemon.js
// The old syntax
import React, { useEffect, useState } from 'react';
const Pokemon = () => {
useEffect(() => {
const getPokemons = () => {
const API = 'http://pokeapi.co/api/v2/pokemon?limit=500';
fetch(API)
.then((response) => {
console.log(response);
return response.json();
})
.then((data) => {
console.log(data.results);
setLoading(false);
setData(data.results);
})
.catch((err) => {
console.log(err);
});
};
getPokemons();
}, []);
const [data, setData] = useState([]);
const [loading, setLoading] = useState(true);
return (
<>
{/* The old syntax using ternary operators with a variable for loading */}
{loading ? (
<h1>Loading pokemon...</h1>
) : (
<div>
{data.map((pokemon) => (
<div key={pokemon.name}>
<h2>{pokemon.name}</h2>
</div>
))}
</div>
)}
</>
);
};
export default Pokemon;
The New Root API
React 18 has new syntax for the root index.js file which gives you access to new features and improvements. The previous syntax will give you a red warning message in the console because ReactDOM.render is no longer supported in React 18. Use the new syntax to clear the warning message.
You are now required to use createRoot instead and until you switch to the new API, your app will behave as if itβs running React 17. The new root API has a cleaner and clearer syntax and the new concurrent renderer becomes enabled so you can now access concurrent features which the previous API could not.
New Syntax
import ReactDOM from 'react-dom/client';
import App from './App';
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);
Old Syntax
import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
ReactDOM.render(<App />, document.getElementById('root'));
The New useId hook
React 18 gives you a useful way for generating id's when creating DOM elements with the new useId hook. If you have multiple id's you can even append a suffix like "twitter" to make it unique.
Bonus Tip: You can make the label clickable by adding the htmlFor tag for example.
App.js
import { useId } from 'react';
const App = () => {
const id = useId();
return (
<>
<div>
<label htmlFor={`${id}-twitter`}>Do you have a Twitter?</label>
<input id={`${id}-twitter`} type="checkbox" name="twitter" />
</div>
<div>
<label>Do you have a Instagram?</label>
<input id={`${id}-instagram`} type="checkbox" name="instagram" />
</div>
<div>
<label>Do you have a YouTube?</label>
<input id={id} type="checkbox" name="youtube" />
</div>
</>
);
};
export default App;
The New useTransition hook
In React 18 you can use the new useTransition hook to load data before rendering it to the screen. When you use the return value isPending you can create a preloader for each loading transition.
You can see it in action in this custom carousel slider.
App.js
import { useState, useEffect, useTransition } from 'react';
const App = () => {
useEffect(() => {
mountain().then((data) => {
console.log(data);
setLoading(false);
setData(data);
});
}, []);
let [data, setData] = useState([]);
let [loading, setLoading] = useState(true);
let [count, setCount] = useState(0);
let [index, setIndex] = useState(0);
let [isPending, startTransition] = useTransition();
const showNext = () => {
startTransition(() => {
setCount(count + 1);
});
setIndex(count + 1);
console.log('Count', count + 1);
};
const showPrevious = () => {
startTransition(() => {
setCount(count - 1);
});
setIndex(count - 1);
console.log('Count', count - 1);
};
const mountain = (loaded) => {
return new Promise((resolve, reject) => {
setTimeout(() => {
if (loaded) {
reject(new Error('Failed to load data'));
} else {
resolve([
{
id: 0,
name: 'Mountain 1',
img: 'https://images.unsplash.com/photo-1570641963303-92ce4845ed4c?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=1587&q=80',
},
{
id: 1,
name: 'Mountain 2',
img: 'https://images.unsplash.com/photo-1434394354979-a235cd36269d?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=2051&q=80',
},
{
id: 2,
name: 'Mountain 3',
img: 'https://images.unsplash.com/photo-1472791108553-c9405341e398?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=2137&q=80',
},
]);
}
}, 2000);
});
};
return (
<>
{loading ? (
<h1>Loading...</h1>
) : (
<div>
{isPending ? (
<div>
<h1>Loading the next image</h1>
</div>
) : (
<div>
<h1>{data[index].name}</h1>
<img src={data[index].img} alt="Mountain" style={{ width: '100%', height: '300px', maxWidth: '500px' }} />
</div>
)}
</div>
)}
<button onClick={showPrevious} disabled={count === 0 ? true : false}>
Previous
</button>
<button onClick={showNext} disabled={count === 2 ? true : false}>
Next
</button>
</>
);
};
export default App;
Final Thoughts
This was a brief introduction into the new features inside of React 18. Take a look at the official blog to see all of the new documentation React v18.0.
Top comments (5)
Your article gives a great overview on React 18, exactly what I needed right now. Thanks for sharing and your detailed explanation on all these new features.
I actually find the React Suspence quite simple and useful too. Atleast, it'll make my code much more neater and boy do I love neat codes. Not quite sure yet what the useTransition does.
Laser hair removal is a relatively new method of removing unwanted hair from the body. The idea behind laser hair removal is that it will target the root of the problem, rather than just damaging the surface of the skin. This can be useful for people who want to slow down or stop their hair loss or those who want to remove hair permanently. You should try this laser removal denver because this will be very useful to remove laser hair. Laser hair removal has been around for over 20 years and is now used in many medical offices throughout the country. It is becoming more popular as time goes on, but there are still many people who do not know what laser hair removal actually is or how it works.
I was just looking for an overview of React 18 and found it in your blog. Your thorough description of these new features and the information you shared geometry dash are much appreciated.
I actually find React Suspense quite simple and useful. At least, it helps make my code much neater, and I really appreciate clean code. I'm not entirely sure what tunnel rush does yet.