Let’s Talk about Re-renders

Hi everyone. My name is Nadia. So, first a little bit of introduction. I am a front-end architect. I am a coder. I am a writer. I used to work in Atlassian for a few years. So I worked on Jira front-end, and now I am a founding engineer in a small startup that is called PIN in Australia.

So, the topic of React performance and especially how re-renders affect React performance is something like a passion of mine. I find it fascinating that just one tiny change in the right place can either completely destroy or vastly improve performance of a huge application. So, all the knowledge about this topic is what I want to share with you today.

But first, what exactly is a re-render and why do we want to talk about re-renders in the context of performance. Generally speaking, we have two major stages of a React lifecycle that we need to care about. The first one is initial render when an app first mounted and appears on the screen, and then re-render. A re-render is second and all of them, all the consecutive renders of an app that is already on the screen. And from a code perspective, we have at least three ways to trigger re-render of a component. First is the most known one is when a state or props change, this is when a component will be re-rendered. Second one if we use a context, then when a value changes, every component that uses this value will also re-render. And the third and most under appreciated one is when a parent component re-renders or if we look from the top, that means that when a component re-renders itself, it will re-render every single child that it has. If we want to visualize the last one, because it's the most important one, it will look something like this. We have a tree of components, the top one will re-render, and then this re-render will trigger a re-render of all the children there, and then all the children underneath, so it will be a whole chain of re-renders that triggers from the top.

And generally speaking, a re-render itself is not something that we would want to fight with, because it's an essential part of a React lifecycle, it's when React updates all the data that has changed. What we want to avoid at all cost is unnecessary re-renders. And by unnecessary re-render, I mean something like this. So imagine we have an input component somewhere at the bottom, we type something there, and then this component naturally will re-render itself. That is good, and that is expected. What we don't want is when we type in this tiny input component, to re-render the entire app. This, depending on the size of the app, can be extremely slow. And in today's world, users will expect all the interactions on the page to be really, really fast. So unnecessary re-renders is a performance killer.

And to demonstrate to you how bad those can be, I even implemented a little bit of an app. So this is an app that renders a list of components, and has a little bit of interactivity. So take a look. On the right, Performance tab, I click everywhere, and everything is instantaneous. On the left, exactly the same app, but I made a couple mistakes there, and look how unbearably slow all of this is. Just a few tiny mistakes in the right places, and I just destroyed this app. And it's just a list of components.

So common mistakes that lead to performance like that, and also useful performance tips and tricks to avoid re-renders of the entire app, is what I want to share with you today. Let's start with mistakes. The very first one is one of my favorite, is what I call the myth of useMemo and useCallback. So as probably most of you know, React uses referential equality when it compares props or dependencies in all the various hooks. And referential equality is basically this. We have two arrays or two objects. If we want to compare them, if we do it like this, the result will be false, because we're comparing them by the reference, not by the actual value.

And from React's perspective, it sounds like this. We have a component, it renders a child component. I pass a value to this child component that is an array. If I do it like this, during a rerender, this value will become a completely different value. So if React compares those props, React will think that value of the prop has changed. And if I write a memo and use callback hooks, hooks that allow you to memoize this value, and basically to preserve reference to this value between rerenders. So if I extract this array into useMemo hook, then when a rerender happens, React will think that value in a child component will be exactly the same. And the fact that one of the most important reasons why a component rerenders is a state or prop change, in combination with how those hooks work, lead to the widespread belief that if we memoize all the props on a component, that will prevent this component from re-rendering. And this results in something that I call a useMemo or useCallback hook hell, because memoizing absolutely everything leads to your app becoming, having useMemo, you wrap in useCallback, and then another useCallback, it's just useMemo and useCallbacks everywhere, and the app becomes incomprehensible and completely not readable and not debuggable. So I think those become really horrible.

But the worst part of all of this is that it's actually sometimes, it's actually useless, because we're forgetting one key component in all of this construction. So if we take a look, for example, at this code, we see a component, it has a child component and then onClick, Prop, and we want to prevent child component from re-rendering by wrapping onClick in a useCallback hook. But what exactly can trigger child components to re-render? We prevented Prop from changes. The only thing that is left when a parent component re-renders. So we will trigger a state, for example, a child component will re-render, and React will not actually check whether Prop has changed or not at this stage, because React's natural way of dealing with components is components re-render, and then re-render every single child. Wrapping onClick here in useCallback is just completely useless, we are doing nothing here.

The only way to prevent the child component from re-rendering when the parent component re-renders is actually wrapped in React.memo. And only in this scenario, when a parent component re-renders, the re-render of this child will be stopped. In this case, the component react will stop, and then we will start comparing all the Props with the previous value, and if all of them are the same, then nothing will be re-rendered. So, from code perspective, this, when we have just the child component, and then a use callback that is, wraps a Prop, it's useless. It does nothing. It just consumes a little bit of computational power. It should be something like this, or just remember use callback. wrapped in React.memo, and then, and only then, a use callback will be actually useful.

Second mistake, and this one is the major performance killer in React applications. Creating components in render functions. Again remember the app. The app is just a list. Apps, it accepts countries as a prop, and then we iterate over those countries and render something. In real life, obviously we would want this button to have some styles, to have some functionality, so in real life I would want to extract this button and make it a component. And what people often do is they extract it as a component and create it inside this exact component, it creates inside a parent component. Usually the reason for this is it's just much easier to pass additional data to it that is derived from state, but still. But when we do something like this, during every single rerender of the big list component, React will recreate the item component completely from scratch. React will just unmount everything that is already rendered and then remount all those list components. This is not only going to be really, really slow, mounting is twice as slow as just a render. It is also going to be visible on the screen, because what will happen is a list component with items, lists the renders. React will think that all the item created inside the list is a new component now, so it will destroy all those items, remove them from the screen, and then recreate them back. Sometimes we will see a visible flash on the screen. And also numerous bugs with focus. So the way to fix this, of course, is just never do something like this, and just create item components outside of big components, never create components in line.

Third mistake that is probably the most important source for all those spontaneous and unnoticeable error renders across the entire app is context provider. So context is a really useful tool when we need to pass some data and avoid props trilling. So with context, we can do this. We can just escape all the components in between and pass data from the top component to the bottom component. Without context, what we would have to do is pass data through every single component in between the top one and the bottom one, which will cause all the middle components just explode with props and unnecessary data and just turns into a nightmare of refactoring in six months.

But there is one caveat with context. When a context value changes, React would also need to update everything that is using the context value. And that means that React needs to rerender every single component that uses context value. And from a coding perspective, it looks something like this. We have a component, we have context provider, and we need to pass value there. What will happen if this component rerenders by some reason? Remember, differential equality. We have an object that we pass to context provider. Component rerenders. React thinks that object is a different object. It changes, it thinks that a value changes, and then it will unnecessarily rerender every single component that uses this context. And the way to fix it would be just to use memo on this value always. I would say this is one of the very cases of premature optimization that you actually want, because debugging rerenders that are happening because of the changes in context is just a nightmare to do.

Okay. So let's now stop depressing ourselves over the mistakes and talk a little bit about the actual tricks. One of the most important ones in your arsenal against unnecessary rerenders is the pattern that is called Moving State Down. So if we look at the code, we have a component, it renders a lot of stuff, it's very heavy, and at some point we implemented a button there, click on the button, opens a model dialogue. Super simple functionality this whole implementation. So what will happen in this big component from a rerender's perspective? We click on a button, we update state, and then this entire thing rerenders, because when state is updated, every single child in the component will rerender. And of course, something like this is going to be really, really slow. If it's a really big app, click on a button and then opening a model dialogue could cause a visible delay, because React needs to re-render everything first before actually opening the dialogue. Our users will be very disappointed. The way to fix it is what is called moving state down. This state is actually quite separated from the actual functionality of this big app, so what we can do is just extract all of this and wrap it in a component itself. And then use it back in this big component. So now from ReRender's perspective what will happen? We click on a button, state is updated, children are re-rendered, but in this case children are just a button and a model dialogue.

The big component will just sit there and do nothing. That is exactly what we want. And opening of the dialogue will be now as fast as possible. Second pattern and this one probably is the most underappreciated pattern from the series and also the least known one. That's wrapping state around children. It's a little bit similar to moving state down. So again, we have a component. In this case we want to for example listen for a scroll event. So what we will do here, from a re-render perspective again, user scrolls. We are triggering state updates. Update is triggered. That triggers a re-render of entire big component. And again, everything re-renders. But in this case, we cannot just move the state outside because this div is actually wrapping the entire component. But what we can do is we still can extract it outside, create a new component out of all of this, and then pass everything that was between those divs as children.

What will happen here from a re-render perspective and how to use it? So now, we scroll. We trigger state update. Update is triggered. It triggers re-renders. The scroll component re-renders itself. But everything that is inside here belongs to the parent. The child component doesn't know about all of this. From the scroll component perspective, all of this is just a prop. All of this will not re-render. Now this app becomes as fast as possible again, without any memorizations, without anything.

And last but not least, memorizing part of the render stream. So when you have a big component, you use some state here and there. But you cannot either move a state down or just wrap it around children, because it's just scattered across the app. But also, if you want to improve performance of this app a little bit, and you have a big chunk of the stream that is not dependent on the state, what you can do is just memoize this entire stream. In this case, again, update is triggered, re-render is triggered, no dependency in this memo, so useMemo will just return exactly the same value that was before.

It will not update anything. And performance of this big app still is going to be much better than without this.

That was a lot of information, I hope you found some of it at least useful. A little bit of a recap for everyone. If you're not using useMemo and useCallbacks the correct way, which is trapping component in react.memo and memoizing every single one of them, they become useless. You can just remove them. Creating components inside render functions is the biggest performance killer ever. Never do it. It just should be your mantra. Always memoize values in the context provider. That will prevent React context consumers from re-rendering unnecessarily. Wrapping state down and wrapping state around children are the most important tools in your fight against unnecessary re-renders. If both of those are not possible for some reason, you can also memoize expensive parts of render chain.

If you want to read a little bit more about all of this, or play around with the bad app and the good app, here are the links. Feel free to do it. I write a lot about all of those stuff and all different various patterns in my blog. Feel free to connect with me on Twitter or LinkedIn. Always happy to chat and answer questions. Thank you! Thank you so much Nadia, that was a really amazing talk. I had to take a picture of that slide at the end, because there's some of those takeaways that I want to make sure I am using myself.

Let's jump into some questions. If you are in the audience and maybe you're quickly going off to another talk, that's totally fine. Let's just keep the noise down so that we can hear all these questions, even in the back. All right, let's just jump straight into it. What will happen if we pass the object to a child component, which is exported with React memo? I'm not sure if I've read that correctly. If a child component is wrapped in React memo, I assume, and we're just rendering it, then we need to memoize this object. Otherwise, if object is not memoized, the component that is wrapped in React memo will still be rendered. Because React thinks that props are different, so it will trigger a render. That makes sense. That makes sense.

And one thing, this is also something that popped into my head. Why is React memo with the child not just the default behavior for rendering children? Because it makes so much sense to use it that way. It makes so much sense. But as far as I know, React team, I'm not part of it, so I just use the internet. They experimented with doing exactly that during build. But just memoizing everything also has its costs. So if you just memoize everything, it might make your app slightly slower. Because again, if everything is wrapped in React memo, but you're not wrapping everything in the used memo and used callback, those are useless, but you're still doing stuff during that. So it can increase your initial render. It may or may not save you from re-renders, but will definitely increase your initial render. Makes sense as well.