Explanation: React.memo is a higher-order component that will "memoize" a functional component. This means it will only re-render the component if its props have changed, which can be an important performance optimization.

Explanation: The useEffect hook is the primary tool for managing "side effects," which are actions that interact with the outside world, like fetching data, subscriptions, or manual DOM updates. The other Hooks have different purposes related to state and performance

Explanation: React is a JavaScript library specifically designed for building user interfaces (UIs).

Explanation: The <Switch> component is a core part of React Router. It ensures that only the first <Route> in its child list that matches the current URL is rendered, preventing multiple routes from being displayed at once

Explanation: Props (short for properties) are how data is passed from a parent component to a child component.

Explanation: ReactDOM.destroy() is not a standard function in the ReactDOM library.

Explanation: The useState hook is a fundamental Hook that provides stateful logic to functional components.

Explanation: A React Fragment allows you to group multiple elements without introducing an unnecessary wrapper <div> or other DOM element. This is useful for improving performance and styling, and it is not a tool for conditional rendering or data fetching.

Explanation: The Context API is best used for managing state that is needed by many components but is not frequently updated or complex, such as a user's theme or language settings. For large, complex applications, Redux provides better tools for debugging, and handling asynchronous logic.

Explanation: A React component is a self-contained, reusable block of code that encapsulates a piece of a user interface. It can be a function or a class that returns a React element to be rendered to the DOM.

Explanation: "Prop drilling" is the colloquial term for passing data as props through intermediate components until it reaches the desired destination.

Explanation: Hydration is the process that happens after a server has rendered a static HTML page. React takes over in the browser and attaches the necessary JavaScript event handlers and state to that static markup, "hydrating" it and making it interactive.

Explanation: The render() method is a required part of every class component and is responsible for describing what the component's UI should look like. It returns a React element (usually JSX) that will be rendered to the DOM.

Explanation: The dangerouslySetInnerHTML prop is used for rendering raw HTML directly into a component. As the name implies, it can be dangerous because it bypasses React's security features and can expose the application to cross-site scripting (XSS) attacks if not handled carefully.

Explanation: A key advantage of React Server Components is their ability to fetch data directly on the server, eliminating the need for a separate API layer for data fetching. They are rendered on the server, not the client, and do not support Hooks.

Explanation: JSX (JavaScript XML) is a syntax extension that allows developers to write HTML-like code within a JavaScript file.

Explanation: A controlled component is an input form element (like <input>, <textarea>, or <select>) whose value is always synchronized with a piece of state in your React application. This makes the state the single source of truth for the input's value.

Explanation: npx create-react-app is the correct command for creating a new React application with the standard project structure.

: A Higher-Order Component (HOC) is a design pattern in React. It is a function that takes an existing component and returns a new, enhanced component. They are a way to reuse component logic without changing the component hierarchy

Explanation: React Router is a dedicated library that enables navigation between different components or pages within a single-page application, synchronizing the UI with the browser's URL.

Fetching data is a classic side effect because it involves interacting with an external resource. Actions like rendering JSX or updating a state variable directly are part of the component's normal render cycle and do not require the useEffect hook.

Explanation: The key prop is a special attribute that provides a stable identity to each item in a list. React uses this key to efficiently determine which items in the list have changed, been added, or removed, which is crucial for performance.

Explanation: componentDidMount is a lifecycle method called during the "mounting" phase of a class component. It is guaranteed to be executed only once, after the component and its content have been rendered to the browser's DOM.

Explanation: The useMemo hook is specifically used for memoizing the value of an expensive computation. It caches the result and only re-runs the calculation if the dependencies specified in its array change.

Explanation: The Virtual DOM is a lightweight, in-memory representation of the real DOM. When the state changes, React updates the Virtual DOM first, then calculates the most efficient way to update the real DOM, minimizing expensive and slow direct DOM manipulation.