Approaches to Styling React Components, Best Use Cases
Tags: react, css, scss
Published: 2024-04-24 07:00:20

In this article, we revisit the varied approaches for styling components in React, an extensively covered topic. However, this article is distinctively structured to outline the methods and dissect the advantages, disadvantages, and optimal use cases for each.

## TOC
- [Inline Styling](#inlinestyling)
- [Normal CSS](#normalcss)
- [CSS-in-JS](#cssinjs)
- [CSS Modules](#cssmodules)

<a name="inlinestyling"></a>
## Inline Styling

### Description

Inline styling refers to directly assigning styles to elements as attributes within the JSX markup. This is achieved using the `style` attribute, which takes an object with style properties written in camelCase notation.

### Example
**Button.jsx**
```jsx
function Button() {
  const buttonStyle = {
    backgroundColor: 'blue',
    color: 'white',
    padding: '10px 20px',
    border: 'none',
    borderRadius: '5px',
    fontSize: '16px',
    cursor: 'pointer'
  };

  return (
    <button style={buttonStyle}>
      Click Me
    </button>
  );
}
```

### Advantages
1. **Immediate Scope and Isolation:** Inline styles are scoped directly to the element they are applied to, which avoids conflicts with other styles across the application.
 
2. **Dynamic Styling Simplicity:** It is straightforward to dynamically adjust styles based on the component's state or props directly within the JSX. This allows for real-time style updates, which are beneficial for interactive elements that react to user inputs.

3. **Reduced Overhead for Small Components:** For small scale projects or components with minimal styling needs, inline styling eliminates the need for additional files or styling systems, simplifying the development process.

4. **Useful in Prototyping:** It allows for rapid prototyping and visual adjustments directly within the code, which can speed up the development and design process when experimenting with layouts and styles.

### Disadvantages
1. **Limited Styling Capabilities:** Inline styles do not support pseudo-classes such as `:hover` or `:active`, media queries, or keyframe animations, which limits their use in more sophisticated design requirements.

2. **Maintenance Challenges:** As applications scale, maintaining inline styles can become cumbersome and lead to cluttered code, making it harder to manage and refactor compared to centralized styling solutions.

3. **Performance Concerns:** Using inline styles excessively can lead to slower rendering times because each element needs to process its style attributes individually, which is less efficient than stylesheet-based CSS which is parsed once and applied universally.

4. **Lack of Global Styling:** Inline styles do not lend themselves well to global styling strategies (e.g. theming), where changes are made centrally and propagated throughout the application. Each style change needs to be applied individually, which can be labor-intensive.

### Best Use Cases

1. **Rapid Prototyping and Development:** Inline styling is excellent for quick prototyping and development where speed is critical, and the focus is on functionality rather than long-term maintainability. It allows developers to apply styles directly within JavaScript code, reducing the need to manage separate CSS files and speeding up the iteration process.

2. **Dynamic Styling Based on State or Props:** Applications that require styles to change dynamically based on component state or props are well-suited for inline styling. Since styles are applied directly within the component's logic, it's straightforward to modify them based on runtime conditions, such as changing colors, sizes, or animations in response to user interactions.

3. **Conditional Rendering Scenarios:** Inline styling is particularly useful in scenarios where conditional rendering is frequent. For instance, displaying different styles based on user permissions, device capabilities, or other environmental conditions can be easily handled within the component’s render logic.

4. **Small Scale Applications with Minimal Styling Needs:** For small-scale applications or individual components that don't require complex stylesheets, inline styling can be a simple and effective solution. It avoids the overhead of setting up and maintaining a styling system that might be unnecessary for small projects.

5. **Isolating Critical Styles to Prevent FOUC (Flash of Unstyled Content):** When critical styles need to be applied immediately to ensure components render correctly on initial load (for instance, to prevent layout shifts or a flash of unstyled content), inline styles can be very useful. They are processed directly with HTML, making them faster to render than external stylesheets.

<a name="normalcss"></a>
## Normal CSS

### Description
When using normal CSS for styling React components, styles are defined in separate CSS files and linked to components using className properties or standard CSS selectors that target HTML elements within the component.


### Example
**Button.css**
```css
.my-button {
  background-color: blue;
  color: white;
  padding: 10px 20px;
  border: none;
  border-radius: 5px;
  font-size: 16px;
  cursor: pointer;
}
.my-button:hover {
  background-color: darkblue;
}
```

**Button.jsx**
```jsx
import './Button.css';

function Button() {
  return <button className="my-button">Click Me</button>;
}
```

### Extending to SCSS

I am currently utilizing [Vite](https://vitejs.dev):

> Vite does provide built-in support for `.scss`, `.sass`, `.less`, `.styl`, and `.stylus` files. There is no need to install Vite-specific plugins for them, however, the corresponding pre-processor itself must be installed.

Given this built-in support, the only setup required on my part is to install the pre-processor. For SCSS and Sass, this is done simply by running the following command:

```bash
bun add -D sass
```

### Advantages

1. **Clear Separation of Concerns:** Normal CSS maintains a distinct separation between the styling and the JavaScript logic, which helps in organizing code better. This separation simplifies collaboration, allowing designers to focus on CSS and developers on JavaScript, thereby enhancing productivity and reducing the chances of code entanglement.

2. **Comprehensive CSS Features:** Utilizing Normal CSS enables the full use of CSS features including pseudo-classes, media queries, and animations. These features are critical for creating responsive, interactive, and visually engaging websites.

3. **Efficiency through Caching:** Browsers can cache CSS files independently of HTML and JavaScript, which can significantly speed up load times during subsequent visits. This not only improves performance but also conserves bandwidth.

4. **Scalability and Maintainability:** With methodologies like BEM (Block, Element, Modifier), CSS becomes more manageable and scalable in large-scale projects. These methodologies organize CSS to minimize conflicts and maximize reusability.

5. **Integration with Preprocessors:** CSS preprocessors (like SASS or LESS) enhance the capabilities of Normal CSS by allowing variables, mixins, nested rules, and more. This increases the maintainability and modularity of stylesheets.

### Disadvantages

1. **Global Scope Issues:** The global nature of CSS can lead to styling conflicts and maintenance challenges. Styles defined in one part of the application can unintentionally affect other parts, necessitating careful management and naming conventions like BEM to avoid conflicts.

2. **Initial Load Overhead:** Large CSS files can slow down the initial page load time, impacting user experience and performance, especially if the styles are not optimized or if the CSS isn't split into smaller chunks relevant to the rendered components.

3. **Dynamic Styling Limitations:** Compared to CSS-in-JS or inline styles, Normal CSS is less adept at handling dynamic styling that depends on JavaScript states or props. Implementing reactive styles typically requires more complex solutions, such as employing CSS variables that are manipulated via JavaScript.

4. **Less Isolation:** Unlike CSS-in-JS, which scopes styles tightly around components, Normal CSS has a broader impact which might lead to unintended side effects if not properly managed. This requires a disciplined approach to stylesheet organization to ensure styles are applied as intended.

### Best Use Cases
1. **Static Sites and Simple User Interfaces:** Normal CSS is particularly useful for projects that feature static content and simple user interfaces. When components do not require frequent stylistic changes based on state or real-time user interactions, normal CSS provides a straightforward, efficient styling approach.

2. **Large-Scale Applications with Structured Stylesheets:** For large applications that benefit from a clear and organized stylesheet architecture, normal CSS, especially when paired with methodologies like BEM, offers an excellent solution. It allows teams to maintain consistency and scalability in the design, making it easier to manage large amounts of styles without much overlap or conflicts.

3. **Projects with Separate Design and Development Teams:** When project roles are clearly divided between designers and developers, using normal CSS can enhance workflow efficiency. Designers can focus on CSS files to implement visual design independently of the JavaScript code, facilitating a more parallel and segmented approach to development.

4. **Applications that Require Extensive Use of CSS Features:** Applications that make heavy use of CSS features such as animations, pseudo-classes, and media queries are ideal scenarios for using normal CSS. These features are fully supported and can be more cumbersome to implement correctly with other styling methods like inline styles or CSS-in-JS.

5. **Sites Where SEO is a Priority:** For projects where search engine optimization (SEO) is crucial, such as landing pages and content-focused websites, normal CSS is advantageous. Since CSS files can be cached by the browser independently of the JavaScript, this can lead to faster loading times upon return visits, enhancing the user experience and potentially boosting SEO performance.

## CSS-in-JS
<a name="cssinjs"></a>

### Description
CSS-in-JS is a styling technique wherein CSS is composed using JavaScript instead of defined in external files. This method allows CSS to be scoped locally to components rather than globally, reducing the probability of style conflicts. Utilizing JavaScript also enables dynamic styling easily aligned with the component's state or props. Libraries like [Styled Components](https://styled-components.com) and [Emotion](https://emotion.sh/docs/introduction) are popular choices in the React ecosystem for adopting this method.

### Example
**Button.jsx**
```jsx
import styled from 'styled-components';

const StyledButton = styled.button`
  background-color: blue;
  color: white;
  padding: 10px 20px;
  border: none;
  border-radius: 5px;
  font-size: 16px;
  cursor: pointer;

  &:hover {
    background-color: darkblue;
  }
`;

function Button() {
  return <StyledButton>Click Me</StyledButton>;
}
```

### Extending to Adopt TypeScript

When using CSS-in-JS with TypeScript, types are used to ensure that the props and style rules are correctly applied. For instance, Styled Components can be set up with TypeScript as follows:

```jsx
import styled from 'styled-components';

interface ButtonProps {
  primary: boolean;
}

const Button = styled.button<ButtonProps>`
  background-color: ${props => props.primary ? 'blue' : 'gray'};
  color: white;
  /* other styles */
`;

function App() {
  return <Button primary>Primary Button</Button>;
}
```

This example demonstrates how TypeScript interface is used to ensure that the `primary` prop is properly typed.

### Advantages
1. **Component-Level Scope:** CSS-in-JS tightly scopes styles to components, greatly reducing the risk of style leakage and conflicts across the application. This local scoping ensures that styles do not inadvertently affect unrelated parts of your project.

2. **Dynamic and Conditional Styling:** Leveraging JavaScript's capabilities allows CSS-in-JS to apply styles dynamically based on the component's state, props, or context changes.

3. **Developer Experience and Tooling:** Many CSS-in-JS libraries provide advanced development features such as automatic vendor prefixing, critical CSS generation, and server-side rendering capabilities. These features can enhance the development workflow and optimize the performance of the final application.

### Disadvantages
1. **Performance Considerations:** Since styles are processed at runtime, CSS-in-JS can introduce a performance penalty, particularly with server-side rendering or in complex dynamic applications. The computational cost to parse and inject CSS via JavaScript can be significant compared to static CSS files.

2. **Increased Bundle Size:** Incorporating CSS in JavaScript often results in larger bundle sizes, as style information must be included alongside component logic. This can lead to longer load times and reduced performance, especially in network-limited scenarios.

3. **Complexity and Overhead:** While CSS-in-JS offers powerful capabilities, it also adds complexity to the project. Developers must understand both CSS and JavaScript intricacies, manage additional dependencies, and potentially deal with frequent updates and changes in the libraries used.

4. **Dependency on JavaScript:** This approach makes styling wholly dependent on JavaScript, which might not be ideal for scenarios where JavaScript is disabled on the user’s browser. It also couples the design too tightly to the application logic, which might complicate separation of concerns.

5. **Tooling Dependency:** Developers need to stay updated with the libraries' ecosystems and handle potential breaking changes or deprecations.

### Best Use Cases
1. **Applications Requiring Integrated Styling and Logic:** When applications need to integrate styling closely with JavaScript logic — such as for data-driven style changes — CSS-in-JS provides a robust solution.

2. **Need for JavaScript-Powered Styling Capabilities:** When the styling logic requires the capabilities of JavaScript, such as handling arrays or objects for styles, conditionally applying styles based on complex computations, or integrating with other JavaScript-based libraries and frameworks, CSS-in-JS is exceptionally well-suited. This integration allows for more sophisticated styling dynamics that are difficult to achieve with traditional CSS.

<a name="cssmodules"></a>
## CSS Modules

### Description
CSS Modules offer a styling solution that combines the benefits of traditional CSS with the modular scoping of CSS-in-JS. In this method, CSS classes are locally scoped by default, meaning the styles defined in one module are not accessible in another unless explicitly imported. This scoping is achieved at the build time through Webpack, Vite, or other bundlers that process the CSS files and generate unique class names. This approach helps to avoid class name collisions and promotes better organization and reusability of styles without global side effects.

### Example
Button.module.css
```css
.button {
  background-color: blue;
  color: white;
  padding: 10px 20px;
  border: none;
  border-radius: 5px;
  font-size: 16px;
  cursor: pointer;
}

.button:hover {
  background-color: darkblue;
}
```

Button.jsx
```jsx
import styles from './Button.module.css';

function Button() {
  return <button className={styles.button}>Click Me</button>;
}
```

In this setup, the CSS class button is automatically scoped to the Button component, and the class name in the final stylesheet is typically transformed into something unique like `Button_button__3jN4s`.

### Advantages
1. **Local Scoping:** CSS Modules automatically scope class names to the component, preventing style leakage and ensuring that styles defined in one component do not affect others unintentionally.

2. **Composability and Reusability:** Classes from CSS Modules can be composed together and reused across different components. This modular approach enhances maintainability and scalability.

3. **Familiar Workflow:** Developers can use standard CSS syntax and leverage existing CSS knowledge without needing to learn a new syntax or library, unlike CSS-in-JS solutions.

4. **No Runtime Overhead:** Since styles are processed during the build time, CSS Modules do not introduce any runtime overhead, which is beneficial for performance compared to CSS-in-JS.

5. **Integration with Preprocessors:** CSS Modules can be used in conjunction with CSS preprocessors like SASS or LESS, allowing developers to use variables, mixins, and nested rules for more powerful and efficient styling.

### Advantages
1. **Limited Dynamic Styling:** While CSS Modules support dynamic class names via conditional class bindings in JavaScript, they do not inherently support styling based on component state or props as directly as CSS-in-JS.

2. **Global Styles Management:** Managing global styles can be awkward with CSS Modules, as global styles need to be explicitly defined or included through different mechanisms, which might not be as straightforward as using traditional CSS.

### Best Use Cases
1. **Medium to Large-Scale Projects:** CSS Modules are ideal for projects that require clean, maintainable styles without the overhead of runtime style computations. They provide a good balance between global CSS and inline styles, suitable for medium to large-scale applications.

2. **Applications with Complex Component Libraries:** When building applications that utilize a complex set of reusable components, CSS Modules help maintain styles encapsulated and prevent conflicts across components.

3. **Microfrontend Architectures:** For organizations employing a microfrontend architecture, where different teams develop discrete parts of a web application independently, CSS Modules are an excellent tool. They ensure style encapsulation within each microfrontend, preventing CSS clashes between disparate teams or sections of the application. This isolation helps maintain a clean and organized codebase, allows independent updates, and supports a more modular and scalable application structure. CSS Modules facilitate this by generating unique class names that are confined to their respective components, thereby enhancing development efficiency in a distributed team environment.