10 React Native Style Best Practices
React Native is a great tool for building native mobile apps, but it has its own set of best practices when it comes to styling. Here are 10 of them.
In this article, we’ll go over 10 style best practices for React Native. These tips are based on our experience with React Native and what we think will help you write cleaner, more maintainable code.
We’ll cover topics like how to use style props, when to use inline styles, how to use StyleSheet, and more. By the end of this article, you should have a better understanding of how to style React Native components.
1. Use Flexbox
Flexbox is a layout system that gives you complete control over the positioning and sizing of your components. With Flexbox, you can make complex layouts with just a few lines of code, and it’s great for responsive design because it automatically adjusts your components to different screen sizes.
If you’re not familiar with Flexbox, I recommend checking out this tutorial from React Native Express. It will teach you everything you need to know about Flexbox so that you can start using it in your own projects.
2. Use Platform-Specific File Extensions
When working with React Native, you’ll often find yourself working with both iOS and Android platforms. And while the majority of your code can be shared between these two platforms, there will inevitably be some platform-specific code that you’ll need to write.
A common way to handle this is to put all of your platform-specific code in separate files and use a different file extension for each platform. For example, you might have a file called MyComponent.ios.js for your iOS-specific code and a file called MyComponent.android.js for your Android-specific code.
This approach has a few benefits. First, it’s easy to see at a glance which files contain platform-specific code. Second, it helps prevent accidental cross-platform bugs (e.g. if you mistakenly include an iOS-specific line of code in your Android file).
So, if you’re not already using platform-specific file extensions in your React Native project, we recommend giving it a try.
3. Use Absolute Units for Font Size
When using absolute units, such as pt or px, the font size will be the same no matter what screen size the app is being used on. This is important because it ensures that your text is legible and easy to read no matter what device it’s being viewed on.
On the other hand, when using relative units, such as em or %, the font size will scale depending on the screen size. This can be problematic because on smaller screens, the text may become too small to read, and on larger screens, the text may become too large.
Absolute units are also more consistent across different devices and browsers, so you don’t have to worry about your text looking different on different devices.
4. Use Pixel Density Independent Pixels (dp)
Different devices have different screen densities, which means that a given physical size will appear differently on each device. For example, an iPhone 6 Plus has a higher pixel density than an iPhone 6, so a given UI element will appear smaller on the 6 Plus than on the 6.
If you use pixels as your unit of measurement, then your UI elements will appear the wrong size on devices with different screen densities. But if you use dp (density-independent pixels), then your UI elements will be sized appropriately for all devices.
So, when defining React Native styles, always use dp instead of px.
5. Use Platform-Specific Stylesheets
If you’re building a React Native app that’s going to be used on both iOS and Android, it’s important to account for the differences in design between the two platforms. Platform-specific stylesheets give you the ability to target specific styles to either iOS or Android, which means you can make sure your app looks and feels native on each platform.
There are a few different ways to structure your platform-specific stylesheets, but one common approach is to create an “ios” and “android” folder within your styles directory. Within each of those folders, you can then create a stylesheet with the same name as the component you’re styling. So, if you’re working on a button component, you would have a “Button.ios.js” and a “Button.android.js” stylesheet.
Within each of those stylesheets, you can then use the StyleSheet.create method to define your styles. The styles you define within the “ios” stylesheet will only be applied to the component when it’s rendered on an iOS device, and the styles defined in the “android” stylesheet will only be applied when the component is rendered on an Android device.
This approach gives you a lot of flexibility in terms of how you style your components, and it also ensures that your app always looks and feels like it belongs on the platform it’s being used on.
6. Use StyleSheet Objects
StyleSheet objects help keep your styles organized and allow you to reference them by name instead of using inline styles. This means that if you need to make a change to one style, you can do it in one place and it will be reflected everywhere that style is used.
Additionally, StyleSheet objects can improve the performance of your app because they are processed by the native renderer before being applied to the UI. This means that the styles are applied more efficiently and don’t have to be recalculated every time the UI is updated.
Finally, StyleSheet objects make it easier to debug your styles because you can see all of the styles that are being applied to a component in one place. This can be helpful when you’re trying to figure out why a certain style is not being applied as expected.
7. Use the Spread Operator to Unpack Styles
If you have a style object that contains a bunch of different styles, and you want to apply all those styles to an element, you would normally have to do something like this:
“`
const styles = {
container: {
backgroundColor: ‘red’,
padding: 10,
},
text: {
color: ‘white’,
fontSize: 20,
},
};
“`
However, if you use the spread operator, you can unpack the styles into individual style properties, which makes for cleaner and more concise code:
“`
const styles = {
container: {
backgroundColor: ‘red’,
padding: 10,
},
text: {
color: ‘white’,
fontSize: 20,
},
};
“`
8. Avoid Inline Styles
Inline styles are those that are written directly into your JSX code.
For example, let’s say you have a component with a couple of paragraphs, and you want to style the paragraphs differently. You could do this:
“`
“`
While this works, it’s not ideal for a few reasons.
First, it’s not very reusable. If you wanted to use this same style elsewhere in your app, you’d have to copy and paste it, or write a new style object that duplicates the one above.
Second, it’s not very readable. Imagine if you had a dozen different styles inline like this. It would be hard to keep track of what’s going on.
Finally, it’s not very flexible. What if you wanted to change the font weight of both paragraphs at the same time? With inline styles, you’d have to go through each instance and make the change individually.
For these reasons, it’s generally best to avoid inline styles altogether. Instead, you should use StyleSheet objects to store your styles.
9. Use Platform-Specific Selectors
Different platforms have different conventions, and what may look good on one platform may not look so great on another. By using platform-specific selectors, you can be sure that your styles will look appropriate on each platform.
For example, on iOS, it’s common to use lowercase letters for button text. But on Android, uppercase letters are more common. So if you want your button text to look good on both platforms, you would use a platform-specific selector to set the text to lowercase on iOS and uppercase on Android.
This may seem like a small thing, but it’s the little details that can make or break your app’s design. And by using platform-specific selectors, you can be sure that your app always looks its best.
10. Use a Linter
A linter is a tool that analyzes code for potential errors. It can be used to enforce coding conventions and find bugs.
React Native has its own linter, called Flow. Flow is a static type checker for JavaScript. It lets you annotate your code with types, so you can catch errors before you run your code.
Flow is not required for React Native development, but it’s highly recommended. If you’re not using Flow, you should at least use a linter like ESLint.
ESLint is a popular JavaScript linter that works with React Native. It can be configured to enforce coding conventions. For example, you can configure ESLint to require semicolons at the end of every statement.
You can install ESLint as a command-line tool, or you can use it within your text editor. If you’re using Visual Studio Code, there’s an ESLint plugin that will highlight errors in your code.