React sub-components Part 2: Using the new Context API
Further simplifying the sub-component pattern using contexts to make flexible, easily testable and reusable React components
A more accessible, readable, mobile-friendly and up to date version of this story is available on my personal blog!
To fully understand this post, please read my original post about React sub-components first.
I’ve received a lot of good feedback after publishing my first article about React sub-components, however, some of them got me thinking about how I could further improve the sub-components pattern in order to make it easier to read and use.
The flaws of the current pattern
Here are some the critiques I got back from some readers:
- Having to import
findByTypefor every component using sub-components is annoying
- It is hard to compose or extend a sub-component to handle specific cases
- It’s not the most readable
- We could easily put the wrong data within the sub-component, it is not aware about what we’re trying to render within it
While I agreed with all these statements, I couldn’t find an elegant way to address them without making the component difficult to use. However one day, one user from the Reactiflux community mentioned that using contexts would remove the necessity of using the
findByType util within each sub-component; which obviously got me curious. Moreover, I was hearing a lot about the upcoming new Context API in React 16.3.0 and I thought that this would be a great way to start experimenting a bit with this new functionality.
What is in the new Context API?
Up until now, I’ve always thought contexts in React were hard to use, and it never felt natural to me to implement components using them except in some rare higher-order components. Plus it always fell in the category of “experimental API” so I’ve never had enough confidence in it to use it for a lot of production components.
The new API, however, takes a new approach to contexts and makes the feature more accessible. It is available in React 16.3.0, you can read a lot more about it and how to use it in this article. For the purpose of this post, I’ll just keep it short and explain the 3 main items that make up this new pattern:
React.CreateContext: a function that returns an object with a
Provider: a component that accepts a value prop
Consumer: a Function as Child component with the value from the
Provideras a parameter
With these new items, we’ll see that it is possible to create a better sub-component pattern that answers all the flaws stated in the first part.
How to build a sub-component like pattern with the context API
For this part, we’ll try to build the same
Article component that we’ve built in my first post, but this time using contexts.
In order to achieve this, we’ll need to create an
ArticleContext. This will give us an
ArticleContext.Provider component that will be our main parent, which we’ll rename
Article, and an
ArticleContext.Consumer, which will help us build all the sub-components we need.
Let’s start this example by implementing a
The example above shows how we can leverage Consumers and Providers to obtain the same sub-component pattern as we had in the first example of my previous article. If you compare this code in the link with the code above, you can see that the latter feels way simpler. Indeed, thanks to the new Context API, there is no need to build and use the
findByType util. Additionally, we don’t rely on the
name property of the sub-component to know how to render them.
In the code below, we can see that the resulting
Article component is much easier to use. Instead of passing children to the
Title sub-component, we just need to pass them in the value prop of
Article, which will make them available to every Consumer of the Article context (i.e. to every sub-component defined as a Consumer of this context).
Moreover, if we want to wrap
Article.Title in another div or component, we can now do that as well. Given that the implementation of the
findByType util in my first post was relying on the direct children of
Article , sub-components were restricted to be direct children and nothing else, which is not the case with this new way of doing sub-components.
Note: You can see above that my
value object passed to the provider is set to the parent’s state. This is to avoid creating a new object for
value all the time which will trigger a re-render of Provider and all of the consumers. See https://reactjs.org/docs/context.html#caveats
Additionally, we can make the piece of code above look even better. By simply exporting the
Title functional component in
Article.js we can give up the
<Article.Title/> notation and simply use instead
This is purely aesthetic though, and I personally prefer the first implementation. It gives more context about where a given sub-component comes from and with which parent component it can be used, and also avoids duplicated name issues.
When showing this new pattern to some other developers who were familiar with using the one described in my first article I got one critique: it’s not possible to whitelist children anymore; anything can go within the parent component. While this new implementation is more flexible, the first one was able to restrict the children of a component to only its sub-components. There are multiple ways to fix this, but so far the only one I’ve explored is by using flow. I’ll detail the process in my next article.
In the code snippets below, you will find:
- The full
Articlecomponent code and all its sub-components in
- An example
App.jswhere you can see how we use the full component and sub-components
If you feel like playing with this pattern I’ve made the example of this article available on Github here, you can set up the dockerized project using
docker-compose build && docker-compose up, or just run
yarn && yarn start if you want to run it directly on your machine.