DEV Community: Christiana Uloma

Creating CSS-Only Parallax Effects: Step-by-Step Guide

Christiana Uloma — Thu, 08 Feb 2024 13:13:28 +0000

Parallax effects make elements on a webpage move at different speeds, creating a sense of depth. It's a way to make things look more interesting.

Parallax effects are popular in web design because they make websites more engaging. They capture people's attention and make the website look better.

This article will show you how to create parallax effects using only CSS. You don't need JavaScript or other fancy technologies.

Let's get started!

What's parallax effect?

As said earlier, parallax effects involve moving elements on a webpage at different speeds, creating a sense of depth and immersion. It's like giving the illusion of objects in the foreground and background moving at different rates as you scroll or interact with the website.

Types: There are various types of parallax effects commonly used in web design, but in this case we will examine just two them:

One type is the "scrolling parallax" where different layers move at different speeds as you scroll.
Another type is the "mouse movement parallax" where elements respond to your mouse movement, creating an interactive effect.

Step1: To begin, create a new HTML file by opening a text editor (in this case, vs code) and saving the file with a ".html" extension. Here's a template to start with:



<!DOCTYPE html>
<html>
<head>
  <title>Your Page Title</title>
  <link rel="stylesheet" type="text/css" href="styles.css">
</head>
<body>
  <!-- Your content goes here -->
</body>
</html>

Next, organize the elements that you want to apply the parallax effect to. Typically, you will have multiple elements to create the illusion of depth.

Example:



<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="style.css">
  <title>Document</title>
</head>
<body>
  <!-- Create a parallax container with a background image -->
<div class="parallax bg-1"></div>

<!-- Add some content inside a white container -->
<div class="content">
  <h1>Parallax Example</h1>
  <p>This is a simple demonstration of how to create a parallax effect using html and css.</p>
</div>

<!-- Create another parallax container with a different background image -->
<div class="parallax bg-2"></div>

<!-- Add some more content inside a white container -->
<div class="content">
  <h1>Another Parallax Example</h1>
  <p>You can use different images and styles to create different parallax effects.</p>
</div>

<!-- Create a third parallax container with another background image -->
<div class="parallax bg-3"></div>

<!-- Add some final content inside a white container -->
<div class="content">
  <h1>Final Parallax Example</h1>
  <p>Hope you enjoyed this simple tutorial on how to create a parallax effect using html and css.</p>
</div>
</body>
</html>

Step2: To begin styling the parallax elements, you will start by defining the parallax container and adding the necessary background properties to create the scrolling effect.

Example:



/* Define the parallax container */
.parallax {
  /* Set a specific height */
  height: 500px;

  /* Create the parallax scrolling effect */
  background-attachment: fixed;
  background-position: center;
  background-repeat: no-repeat;
  background-size: cover;
}

In the above code, the height property determines the height of the parallax container, which can be adjusted to fit your design requirements. The background-attachment property set to fixed ensures that the background image remains fixed while the content scrolls.

The background-position property centers the background image, background-repeat is set to no-repeat to prevent the image from repeating, and background-size set to cover ensures the image covers the entire container.

Step3: Here, we will define the background image.

Example:



/* Define the background images */
.bg-1 {
  background-image: url("neom-4AADxUsnufQ-unsplash\ \(1\).jpg");
}

.bg-2 {
  background-image: url("aleksandr-popov--DhozujVOF8-unsplash.jpg");
}

.bg-3 {
  background-image: url("neom-4AADxUsnufQ-unsplash\ \(1\).jpg");
}

The provided code includes three classes: .bg-1, .bg-2, and .bg-3, each representing a different background image.

Note, you can replace the image URLs with the paths to your desired images.

Step4: To style the content within the parallax container, follow this steps:



/* Define the content style */
.content {
  position: relative;
  background-color: white;
  padding: 20px;
}

Here, the .content class is positioned relative and has a white background color with a padding of 20px. As said earlier, you can modify the styles within the .content class to match your design preferences.

Step5: Here, we will define the animations for the background images.

Example:



/* Define the animation for the background image */
@keyframes move-bg-1 {
  from {background-position: 0% 50%;}
  to {background-position: 100% 50%;}
}

/* Define the animation for the midground image */
@keyframes move-bg-2 {
  from {background-position: 0% 50%;}
  to {background-position: 50% 50%;}
}

/* Define the animation for the foreground image */
@keyframes move-bg-3 {
  from {background-position: 0% 50%;}
  to {background-position: 25% 50%;}
}

In the above code, three separate keyframe animations move-bg-1, move-bg-2, and move-bg-3 were defined. Each of them specifies the background-position property to control the movement of the background images.

Also, the from keyword sets the initial position of the background image, while the to keyword sets the final position.

Step6: In this section, we will trigger the animations on hover. Here's how:



/* Trigger the animation when the user hovers over the container */
.parallax:hover {
  animation: move-bg-1 5s linear infinite;
}

.bg-2:hover {
  animation: move-bg-2 5s linear infinite;
}

.bg-3:hover {
  animation: move-bg-3 5s linear infinite;
}

In the above code, when the .parallax container is hovered over, the move-bg-1 animation is applied, creating a parallax effect on the background image with a duration of 5 seconds and a linear timing function. Similarly, when the .bg-2 or .bg-3 classes are hovered over, the move-bg-2 or move-bg-3 animations are applied respectively, creating parallax effects on the midground and foreground images.

Step7: In this section, we combine the overall CSS code and display the output.



/* Define the parallax container */
.parallax {
  /* Set a specific height */
  height: 500px;

  /* Create the parallax scrolling effect */
  background-attachment: fixed;
  background-position: center;
  background-repeat: no-repeat;
  background-size: cover;
}

/* Define the background images */
.bg-1 {
  background-image: url("neom-4AADxUsnufQ-unsplash\ \(1\).jpg");
}

.bg-2 {
  background-image: url("aleksandr-popov--DhozujVOF8-unsplash.jpg");
}

.bg-3 {
  background-image: url("neom-4AADxUsnufQ-unsplash\ \(1\).jpg");
}

/* Define the content style */
.content {
  position: relative;
  background-color: white;
  padding: 20px;
}

/* Define the animation for the background image */
@keyframes
 move-bg-1 {
  from {background-position: 0% 50%;}
  to {background-position: 100% 50%;}
}

/* Define the animation for the midground image */
@keyframes
 move-bg-2 {
  from {background-position: 0% 50%;}
  to {background-position: 50% 50%;}
}

/* Define the animation for the foreground image */
@keyframes
 move-bg-3 {
  from {background-position: 0% 50%;}
  to {background-position: 25% 50%;}
}

/* Trigger the animation when the user hovers over the container */
.parallax:hover {
  animation: move-bg-1 5s linear infinite;
}

.bg-2:hover {
  animation: move-bg-2 5s linear infinite;
}

.bg-3:hover {
  animation: move-bg-3 5s linear infinite;
}

Output:

Conclusion

Implementing a parallax effect in your HTML and CSS can add depth and visual interest to your website. By organizing the necessary elements, applying appropriate classes, and styling the parallax elements, you can create a captivating scrolling experience.

Thank you for reading! Feel free to say something in the comment section.

10 React Libraries for Building Powerful Web Applications

Christiana Uloma — Fri, 02 Feb 2024 19:49:17 +0000

When building web applications using React, the choice of libraries is important. React libraries offer pre-built components and tools that can make the development process easier and more efficient.

They save time and effort, while also ensuring that your web application works well and provides a great user experience. Choosing the right React libraries can help you create feature-rich, scalable, and user-friendly web applications.

In this article, we will introduce 10 React libraries that can help improve your web application development. Each library has its own set of features and benefits. We will explain what each library does, why it is useful, and provide examples to help you understand how they can enhance your web application development. By the end of this article, you will have a good understanding of the libraries and be more prepared to use them in your projects.

Let's begin!

React Router

React Router is a tool that helps you navigate between different pages or sections of your web application. It ensures that when you click on a link, the right content shows up without having to reload the entire page. React Router makes your web application feel smooth and interactive.

Features and Functionalities

Declarative Routing:

React Router allows you to specify the routes in your web application using simple instructions. It's like giving directions to your website on how to show different pages based on the URL.

Nested Routing:

With React Router, you can create complex page structures with different sections inside each other. This helps organize your website and makes it easier for users to navigate through different parts of your application.

URL Parameters:

React Router allows you to use specific information in the URL to show different content. For example, if you have an online store, React Router can help you display the details of a specific product when the user clicks on its link.

Route Guarding:

React Router provides a way to protect certain parts of your web application. For example, if you have a user login system, React Router can make sure that only authorized users can access certain pages or sections.

Now, let's move on to the use cases and examples of React Router in web application development.

There are several use cases of React Router, but we will be looking at a few of them.

Navigation and Page Display

Imagine you have a website with different sections like Home, About, and Products. When a user clicks on a link, you want the correct page to show up without refreshing the whole website.

React Router helps you set up the routes for each section of your website. It ensures that when a user clicks on a link, the right page loads without any delays or interruptions.

For instance, Let's say you have a link to the About page. With React Router, you can easily set it up so that when the user clicks on the link, the About page shows up without the need to reload the entire website.

Example:

   import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';

   function App() {
     return (
       <Router>
         <Switch>
           <Route exact path="/" component={Home} />
           <Route path="/about" component={About} />
           <Route path="/products" component={Products} />
         </Switch>
       </Router>
     );
   }

In the above code, the react-router-dom library is imported, and the App component sets up routing using the BrowserRouter, Route, and Switch components. Different routes are defined for the home, about, and products pages of the application.

Showing Dynamic Content

Suppose you have an online store, and you want to show the details of a specific product when a user clicks on its link. React Router lets you use the information in the URL to determine which product details to display. It helps you show the right content based on the product the user wants to see.

Let's say you have a link to a product with a unique ID in the URL. With React Router, you can extract that ID and use it to fetch and display the correct product details on the page.

Example:

   import { useParams } from 'react-router-dom';

   function ProductDetails() {
     const { productId } = useParams();
     // Fetch and render product details based on the productId
     // ...
   }

In the above code, the useParams hook from react-router-dom is imported to access route parameters from the URL. By using this hook, the productId is dynamically retrieved and used to fetch and render specific product details. The useParams hook simplifies parameter extraction and facilitates dynamic component creation based on the URL.

Redux

Redux is a predictable state container for JavaScript applications. It is often used with libraries like React to manage the global state of an application.

Redux follows a unidirectional data flow pattern, making it easier to understand and debug application state changes. The library provides a centralized store to hold the application state and uses pure functions called reducers to handle state modifications.

To demonstrate how Redux works, let's consider an example of managing a simple counter state.

To use Redux in your project, you need to install it. You can do this by running the following command in your terminal:

npm install redux

In your application's main file, import the necessary functions from Redux and create the Redux store.

import { createStore } from 'redux';

// Reducer function to handle state changes
const counterReducer = (state = 0, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return state + 1;
    case 'DECREMENT':
      return state - 1;
    default:
      return state;
  }
};

// Create the Redux store
const store = createStore(counterReducer);

In the example above, we import the createStore function from Redux. We define a reducer function called counterReducer that handles state changes for our counter. The reducer takes the current state and an action as parameters and returns a new state based on the action type. We create the Redux store using createStore and pass in the reducer function.

To access and modify the state, components need to subscribe to the Redux store and dispatch actions.

import React from 'react';
import { useSelector, useDispatch } from 'react-redux';

function Counter() {
  const counter = useSelector((state) => state);
  const dispatch = useDispatch();

  const increment = () => {
    dispatch({ type: 'INCREMENT' });
  };

  const decrement = () => {
    dispatch({ type: 'DECREMENT' });
  };

  return (
    <div>
      <h1>Counter: {counter}</h1>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
    </div>
  );
}

export default Counter;

In the above code, we import the useSelector and useDispatch hooks from react-redux. These hooks allow us to access the state from the Redux store and dispatch actions to modify the state.

Axios

Axios is a popular JavaScript library used for making HTTP requests from web browsers or Node.js. It provides a simple and intuitive API for sending asynchronous HTTP requests and handling responses. Axios supports features like automatic request and response transformations, interceptors for request and response handling, and more.

To demonstrate how Axios works, let's consider a basic example of making an HTTP GET request to retrieve data from an API.

To use Axios in your project, you need to install it. You can do this by running the following command in your terminal:

npm install axios

In your JavaScript file, import Axios and use it to send an HTTP GET request to an API endpoint.

import axios from 'axios';

axios.get('https://api.example.com/data')
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

In the above snippet, we import Axios and use the get method to send an HTTP GET request to the specified URL (https://api.example.com/data). The get method returns a promise that resolves to the response object. We use .then to handle the successful response and log the data to the console. If there is an error, we use .catch to handle and log the error.

Axios provides additional methods and options to customize requests and send data.

To send data in a POST request, you can pass an object as the second argument to the post method.

axios.post('https://api.example.com/data', { name: 'John', age: 25 })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

In this example, we use the post method to send a POST request to the specified URL and include an object with data ({ name: 'John', age: 25 }). The data object will be sent in the request body.

You can customize request headers by passing an object containing headers as an optional third argument.

axios.get('https://api.example.com/data', {
  headers: {
    'Authorization': 'Bearer YOUR_TOKEN',
    'Content-Type': 'application/json'
  }
})
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

In this example, we pass an object as the second argument to the get method, which contains the headers property. We define headers such as Authorization and Content-Type to customize the request headers.

Note: Axios provides many more features, such as interceptors for request and response handling, request cancellation, and support for progress events.

Material-UI

Material-UI is a popular React UI framework that implements the Material Design guidelines created by Google. It provides a set of reusable and customizable UI components, styles, and icons, allowing developers to build modern and visually appealing user interfaces. Material-UI follows a component-based approach, making it easy to compose UI elements and create consistent designs across an application.

To use Material-UI, let's consider an example of creating a simple button component using Material-UI.

But first, you need to install it. You can do this by running the following command in your terminal:

npm install @mui/material

In your JavaScript or TypeScript file, import the necessary components from Material-UI and create a button component.

import React from 'react';
import Button from '@mui/material/Button';

function MyButton() {
  return (
    <Button variant="contained" color="primary">
      Click Me
    </Button>
  );
}

export default MyButton;

In the example above, we import the Button component from @mui/material/Button. The Button component is a part of Material-UI's core library. We create a functional component called MyButton that renders a Material-UI button. The variant prop is set to "contained" to display a filled button, and the color prop is set to "primary" to use the primary color theme.

To use the MyButton component in your application, import it and include it in your JSX code.

import React from 'react';
import MyButton from './MyButton';

function App() {
  return (
    <div>
      <h1>Welcome to My App</h1>
      <MyButton />
    </div>
  );
}

export default App;

In this example, we import the MyButton component and include it in the App component's JSX code. When the App component is rendered, it will display the heading "Welcome to My App" and the MyButton component.

Formik

Formik is a form library for React applications that helps with form management, validation, and handling form submission. It simplifies the process of building complex forms by providing a set of reusable form components and utilities. Formik integrates well with other libraries and validation tools, making it a powerful tool for managing forms in React applications.

To demonstrate how Formik works, let's consider an example of creating a simple form with validation using Formik.

To use Formik, you need to install it. Follow this step:

npm install formik

In your JavaScript file, import the necessary components from Formik and create a form component.

import React from 'react';
import { Formik, Form, Field, ErrorMessage } from 'formik';

function MyForm() {
  const initialValues = {
    name: '',
    email: '',
  };

  const validate = (values) => {
    const errors = {};

    if (!values.name) {
      errors.name = 'Name is required';
    }

    if (!values.email) {
      errors.email = 'Email is required';
    } else if (!/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i.test(values.email)) {
      errors.email = 'Invalid email address';
    }

    return errors;
  };

  const handleSubmit = (values) => {
    console.log(values);
  };

  return (
    <Formik initialValues={initialValues} validate={validate} onSubmit={handleSubmit}>
      <Form>
        <div>
          <label htmlFor="name">Name:</label>
          <Field type="text" id="name" name="name" />
          <ErrorMessage name="name" component="div" />
        </div>

        <div>
          <label htmlFor="email">Email:</label>
          <Field type="email" id="email" name="email" />
          <ErrorMessage name="email" component="div" />
        </div>

        <button type="submit">Submit</button>
      </Form>
    </Formik>
  );
}

export default MyForm;

In the example above, we import the necessary components from Formik (Formik, Form, Field, ErrorMessage). We create a functional component called MyForm that renders a form using Formik. Inside the MyForm component, we define the initial values for the form fields in the initialValues object. We also define a validate function that validates the form values and returns an object containing any validation errors.

The handleSubmit function is called when the form is submitted. In this example, we simply log the form values to the console, but you can perform any desired action, such as making an API request. The form is wrapped inside the Formik component, which takes the initialValues, validate, and onSubmit props. The Field component is used to render form fields, and the ErrorMessage component is used to display any validation errors.

To use the MyForm component in your application, import it and include it in your JSX code.

import React from 'react';
import MyForm from './MyForm';

function App() {
  return (
    <div>
      <h1>My App</h1>
      <MyForm />
    </div>
  );
}

export default App;

In this example, we import the MyForm component and include it in the App component's JSX code. When the App component is rendered, it will display the heading "My App" and the MyForm component.

React Query

React Query is a library that provides a set of hooks and utilities for managing and synchronizing data in React applications. It simplifies the process of fetching, caching, and updating remote data by abstracting away the complexities of handling async operations and managing the state of data.

To show how React Query works, let's consider an example of fetching and displaying data from an API using React Query.

To use React Query in your project, you need to install it. You can do this by running the following command in your terminal:

npm install react-query

In your JavaScript, import the necessary components and hooks from React Query and use them to fetch and display data from an API.

import React from 'react';
import { useQuery } from 'react-query';

function MyComponent() {
  const { data, isLoading, error } = useQuery('todos', () =>
    fetch('https://api.example.com/todos').then((res) => res.json())
  );

  if (isLoading) {
    return <div>Loading...</div>;
  }

  if (error) {
    return <div>Error: {error.message}</div>;
  }

  return (
    <div>
      <h1>Todos</h1>
      <ul>
        {data.map((todo) => (
          <li key={todo.id}>{todo.title}</li>
        ))}
      </ul>
    </div>
  );
}

export default MyComponent;

In the example above, we import the useQuery hook from react-query. Inside the MyComponent functional component, we call the useQuery hook and pass two arguments - a unique key for the query ('todos' in this case) and a function that fetches the data from the API.

The useQuery hook automatically handles the fetching and caching of data. It returns an object with properties such as data, isLoading, and error. When the data is still loading, we display a loading message. If there's an error, we display an error message. Otherwise, we display the fetched data, assuming it's an array of todos.

To use the MyComponent in your application, import it and include it in your JSX code.

import React from 'react';
import MyComponent from './MyComponent';

function App() {
  return (
    <div>
      <h1>My App</h1>
      <MyComponent />
    </div>
  );
}

export default App;

In the above code, we import the MyComponent and include it in the App component's JSX code. When the App component is rendered, it will display the heading "My App" and the MyComponent component, which will fetch and display the todos from the API.

React Helmet

React Helmet is a lightweight library that allows you to dynamically manage the head section of your React application. It provides an easy way to modify the meta tags, title, and other elements within the <head> of your HTML document. React Helmet helps with SEO optimization, handling social media sharing, and managing the appearance of your application in search engine results.

To use React Helmet, you need to install it and import the necessary components. Then, you can use the components to modify the document's head section.

Here's a short example demonstrating the usage of React Helmet:

import React from 'react';
import { Helmet } from 'react-helmet';

function MyComponent() {
  return (
    <div>
      <Helmet>
        <title>My Page Title</title>
        <meta name="description" content="This is the description of my page" />
        <link rel="canonical" href="https://www.example.com/my-page" />
      </Helmet>
      <h1>Welcome to My Page</h1>
      {/* Rest of the component */}
    </div>
  );
}

export default MyComponent;

In the example above, we import the Helmet component from react-helmet. Inside the MyComponent component, we wrap the desired elements with the <Helmet> component. Within the <Helmet> component, you can modify the head section by adding <title>, <meta>, and other tags as needed. These changes will be reflected in the rendered HTML document.

Note: Using React Helmet helps ensure that your application has proper meta tags, title, and other important elements that contribute to SEO and social media sharing. It allows you to control how your application is perceived by search engines and social platforms, enhancing the overall user experience.

React Spring

React Spring is a library for creating smooth and interactive animations in React applications. It provides a straightforward API that allows you to animate components and properties using a declarative approach. React Spring supports different types of animations, including transitions, physics-based animations, etc.

To use React Spring, you need to install it by running the following command in your terminal:

npm install react-spring

In your JavaScript, import the necessary components and hooks from React Spring and use them to create animations.

import React from 'react';
import { useSpring, animated } from 'react-spring';

function MyComponent() {
  const props = useSpring({ opacity: 1, from: { opacity: 0 } });

  return (
    <animated.div style={props}>
      <h1>Hello, React Spring!</h1>
    </animated.div>
  );
}

export default MyComponent;

In this example, we import the useSpring and animated components from react-spring. Inside the MyComponent function, we call the useSpring hook and pass an object with the desired animation properties. Here, we animate the opacity property from 0 to 1.

The useSpring hook returns an object with animated values, which we apply to components using the animated wrapper. In this case, we wrap the <h1> element with the animated.div component and apply the animated props to it.

Note: React Spring will handle the animation and smoothly transition the opacity of the component from 0 to 1.

To use the MyComponent in your application, import it and include it in your JSX code.

import React from 'react';
import MyComponent from './MyComponent';

function App() {
  return (
    <div>
      <h1>My App</h1>
      <MyComponent />
    </div>
  );
}

export default App;

React Testing

React Testing Library is a testing utility for React applications. It provides a set of tools and methods to write tests that simulate user interactions and verify the behavior of React components. React Testing Library encourages testing from the user's perspective by focusing on testing the application's output and behavior rather than implementation details.

To use React Testing Library in your project, you need to install it. You can do this by running the following command in your terminal:

npm install --save-dev @testing-library/react

In your test file, import the necessary functions and components from React Testing Library and write your tests.

import React from 'react';
import { render, screen, fireEvent } from '@testing-library/react';
import MyComponent from './MyComponent';

test('renders MyComponent and interacts with it', () => {
  // Render the component
  render(<MyComponent />);

  // Find an element on the rendered component
  const button = screen.getByRole('button', { name: 'Click Me' });

  // Simulate a user click on the button
  fireEvent.click(button);

  // Verify the expected behavior or output
  expect(screen.getByText('Button clicked!')).toBeInTheDocument();
});

In this example, we import the render, screen, and fireEvent functions from @testing-library/react. We also import the MyComponent that we want to test. Inside the test function, we render the MyComponent using the render function from React Testing Library. We then use the screen.getByRole function to find an element on the rendered component based on its role and name.

Next, we simulate a user click on the button by calling fireEvent.click and passing the button element. This triggers the click event on the button. Finally, we use the expect function to verify that the expected behavior or output is present. In this case, we check if the text 'Button clicked!' is present in the document.

To run the test, you can use a testing framework like Jest. Running the tests will execute the test function and output the results.

React Icons

React Icons is a popular library that provides a collection of customizable icons for React applications. It offers a wide range of icon sets, including popular sets like Font Awesome, Material Design Icons, and many more. React Icons simplifies the process of adding icons to your application by providing pre-built components that can be easily integrated and styled.

To use React Icons, you need to install it. You can do that by running this in your terminal:

npm install react-icons

In your JavaScript, import the necessary icon component from React Icons and use it in your code.

import React from 'react';
import { FaReact } from 'react-icons/fa';

function MyComponent() {
  return (
    <div>
      <h1>Welcome to My App</h1>
      <FaReact size={50} />
    </div>
  );
}

export default MyComponent;

In this example, we import the FaReact icon component from react-icons/fa, which represents the React logo from the Font Awesome icon set. Inside the MyComponent component, we include the <FaReact /> component to render the React logo. We can also customize the size of the icon by passing a size prop, which is set to 50 in this example.

Also, React Icons allow you to style the icons using CSS-in-JS libraries or inline styles. Here's an example of using inline styles to change the color of the icon:

import React from 'react';
import { FaReact } from 'react-icons/fa';

function MyComponent() {
  return (
    <div>
      <h1>Welcome to My App</h1>
      <FaReact size={50} style={{ color: 'blue' }} />
    </div>
  );
}

export default MyComponent;

Here, we add an inline style to the <FaReact /> component by passing a style prop with a JavaScript object defining the desired CSS properties.

Conclusion

The libraries covered in this article offer valuable tools for React development. They simplify complex tasks, promote best practices, and save time for developers. These libraries provide reusable components, utility functions, and abstractions that enhance state management, routing, form handling, styling, animations, testing, and icon integration in React applications.