Hooks in React.js

In React.js, hooks are functions that enable functional components to use state and other React features without writing a class. They were introduced in React 16.8 as a way to use stateful logic in functional components, thereby simplifying component logic and promoting reusability.

Here are some of the most commonly used React hooks:

1. useState: useState hook allows functional components to manage state. It returns a stateful value and a function to update it. This hook replaces the need for this.state and this.setState in class components. Example:

   import React, { useState } from 'react';

   function Counter() {
       const [count, setCount] = useState(0);

       return (
           <div>
               <p>Count: {count}</p>
               <button onClick={() => setCount(count + 1)}>Increment</button>
           </div>
       );
   }

2. useEffect: useEffect hook is used to perform side effects in functional components. It runs after every render and allows you to perform operations like data fetching, subscriptions, or manually changing the DOM. Example:

   import React, { useState, useEffect } from 'react';

   function Example() {
       const [count, setCount] = useState(0);

       useEffect(() => {
           document.title = `You clicked ${count} times`;
       });

       return (
           <div>
               <p>Count: {count}</p>
               <button onClick={() => setCount(count + 1)}>Increment</button>
           </div>
       );
   }

3. useContext: useContext hook is used to access the value of a context object created by React.createContext. It allows you to consume values from context without nesting. Example:

   import React, { useContext } from 'react';
   import MyContext from './MyContext';

   function MyComponent() {
       const value = useContext(MyContext);
       return <p>{value}</p>;
   }

4. useReducer: useReducer hook is an alternative to useState for managing complex state logic. It is used when state transitions depend on the previous state. Example:

   import React, { useReducer } from 'react';

   const initialState = { count: 0 };

   function reducer(state, action) {
       switch (action.type) {
           case 'increment':
               return { count: state.count + 1 };
           case 'decrement':
               return { count: state.count - 1 };
           default:
               throw new Error();
       }
   }

   function Counter() {
       const [state, dispatch] = useReducer(reducer, initialState);

       return (
           <div>
               <p>Count: {state.count}</p>
               <button onClick={() => dispatch({ type: 'increment' })}>Increment</button>
               <button onClick={() => dispatch({ type: 'decrement' })}>Decrement</button>
           </div>
       );
   }

React hooks enable functional components to have state and lifecycle features previously only available in class components, making them more powerful and flexible. They encourage a more functional style of programming in React and facilitate the creation of cleaner and more modular code.