You can start using React 16 today. When you install React in a project or create a new app using the create-react-app tool, it will automatically install the latest version of React and ReactDOM. As mentioned above, React 16 is backwards compatible. So if you are currently running your app on a previous version of React without any console errors or deprecation warnings, updating to React 16 will not break your app. It should be a seamless transition. Now with a complete rewrite of the React Library comes a few minor breaking changes that only affect uncommon use cases. You can view all the breaking changes. A welcome change is that React is now available under the MIT license. The uncertainties created by Facebook’s previous BSD+Patent’s open source license was a concern to many developers, startups and companies using React. So now React licensing is more flexible. You can use React in your project without having to worry about the previous patent’s clause. Now if you are not able to upgrade immediately to version 16, React 15.6.2, was also published under MIT. Also note, the React 16 update does not mean that whatever you have learned so far about React is immediately obsolete. The API itself hasn’t changed, and most of the skills you have learned are still important, fundamental skills you will continue to use. So if you are eager to learn about everything that is new in React 16 next I will cover the new component life cycle method and error handling feature that lets us catch and manage errors when rendering React components.
Take Control of Errors with
componentDidCatch(). This life cycle hook gets triggered whenever a childs component render or life cycle methods throw an error. When an error occurs,
componentDidCatch() catches the error and instead of crashing the entire app, the app continues to run as normal displaying all the UI except for the faulty component. You can even display a fallback UI to replace the component that crashed.
Catching Errors with Error Boundaries
componentDidCatch() lifecycle method comes a new concept of an error boundary. Error boundaries are wrapper components that use
componentDidCatch() to capture errors anywhere in their child component tree and display a fallback UI in its place. They provide an easier way to keep the error catching and conditional rendering logic reusable and maintainable in your app. You create an error boundary as a class component. Any errors caught in the component tree get reported up to the Error Boundary’s
componentDidCatch() method thereby providing a handy way of sending error reports to an error tracking or monitoring service. The
componentDidCatch() method take two arguments to help you track and investigate errors,
error – the error instance itself, and
info which contains the component stack trace or the path in the component tree leading up to the offending component. The component stack trace contains helpful information for sorting and resolving errors. The
componentDidCatch() method and Error Boundary work like
try/catch statements for your React components. They provide a more consistent and dependable way to catch and deal with errors.
Note: Error Boundaries only catch errors in the components below them in the tree. An error boundary can’t catch an error within itself.
New Return Types
React 16 supports new return types that let your render less DOM nodes. For example, React no longer requires that the
render() method returns a single React element. You are able to render multiple sibling elements without a wrapping element by returning an array. The other new return types React 16 supports are strings and numbers. Eliminating
divs or any extra element added just to wrap your React component tree or returned content leads to overall cleaner and smaller components.
Render Children into Other DOM Nodes with Portals
React 16 introduces a new way of rendering into the DOM. You can render children into a DOM element that exists outside of your apps main DOM tree with a new feature called Portals. For example, in your index.html template you will usually have a
div with the id
root which is where your entire app is rendered into the DOM via
ReactDOM.render. To create a portal, you add a second element that’s a sibling of your root
div as shown below.
Then you can render specific parts of your component tree inside the sibling
div with the new
createPortal() function. The
createPortal(child, container) function accepts two arguments, child and container. The first argument
child is the content you want to render. The second argumnet
container is the DOM element where the content is going to render.
createPortal() provides a hook into HTML that’s outside the
div. As mentioned in React docs, portals are useful when a parent component has an
overflow hidden or
z-index style, but you need the
child to visually break out of its container. So a handy use case for portals is when creating modal windows or overlays. What’s interesting about portals is that the components they render are recognized as regular child components of the app. In other words, even though portal can be anywhere in the DOM tree, it behaves like a normal React child in every other way. For example, an event triggered from inside a portal still propagates or bubbles up to the parent component.
Returning null from
React 16 lets you decide if state gets updated via
setState to prevent unnecessary DOM updates. In your events you can check if the new value of the state is the same as the existing one. If the values are the same, you can return
null will not update state and trigger a re-render. React 16 provides state performance improvements that let you prevent an update from being triggered by returning null for
setState if the new value of state is the same as the existing value. Preventing unnecessary state updates and re-renders with null can make your app perform faster.