Answer:
React is a JavaScript library for building user interfaces, developed by Facebook.
Answer:
Key features include virtual DOM, JSX, components, one-way data flow (unidirectional data binding), and React hooks.
Answer:
JSX (JavaScript XML) is a syntax extension for JavaScript that allows HTML to be written within JavaScript code. It provides the ability to write HTML structures in React applications, making it easier to visualize and understand component structure.
Answer:
Components are reusable building blocks for UI elements in React that encapsulate the logic and structure of a piece of the user interface.
Answer:
Functional components are simpler, functional (stateless) components that use function syntax and are typically used for presenting UI. Class components are ES6 classes that extend from React.Component, maintain their own private data state, and provide more features such as lifecycle methods.
Answer:
React hooks are functions that let you use state and other React features without writing a class component. They allow functional components to manage state and side effects.
Example Code:
const [count, setCount] = useState(0);
Answer:
The virtual DOM is a lightweight copy of the actual DOM (Document Object Model). React uses the virtual DOM to optimize updating the UI by batch updating the real DOM only when necessary.
Answer:
State in React is an object that represents the parts of a component's data that can change over time. It is managed internally by the component itself and can be updated using the `setState` method.
Example Code:
class Counter extends React.Component {
constructor(props) {
super(props);
this.state = { count: 0 };
}
render() {
return (
<div>
<p>{this.state.count}</p>
<button onClick={() => this.setState({ count: this.state.count + 1 })}>Increment</button>
</div>
);
}
}Answer:
Props (short for properties) are inputs to components that allow the passing of data from parent to child components. They are read-only and should not be modified within the component.
Example Code:
<ChildComponent name='John' />
Answer:
Keys are special string attributes used to give elements in arrays a stable identity. They help React identify which items have changed, are added, or are removed.
Example Code:
<ul>
{items.map((item) => (
<li key={item.id}>{item.name}</li>
))}
</ul>Answer:
Lifting state up is the process of moving state from child components to their closest common ancestor (parent) component in React. It allows sharing state between multiple child components.
Answer:
Controlled components in React are components where form data is controlled by React state. The input field value is controlled by state and updates only when the state changes.
Answer:
React lifecycle methods are methods that are invoked at specific phases in a component's lifecycle. They include mounting, updating, and unmounting phases and allow developers to execute code at specific points in the component's lifecycle.
Answer:
`componentDidMount` is a lifecycle method in React that is invoked immediately after a component is mounted (inserted into the DOM tree). It is commonly used for initializations that require DOM nodes or data fetching from external sources.
Answer:
`React.Fragment` is a built-in component in React that allows wrapping multiple elements without adding extra nodes to the DOM. It helps avoid unnecessary div wrappers in the component tree.
Example Code:
<React.Fragment> <Child1 /> <Child2 /> </React.Fragment>
Answer:
Higher-order components are functions that take a component and return a new component with enhanced functionality. They are a common pattern for code reuse, logic abstraction, and component composition.
Answer:
`setState()` is a method provided by React.Component used to update a component's state. When `setState()` is called, React re-renders the component and its children with the updated state.
Example Code:
this.setState({ count: this.state.count + 1 });Answer:
Forms in React can be handled by using controlled components, where form data is controlled by React state, or by using uncontrolled components, where form data is handled by the DOM itself. React also provides form validation and submission handling using event handlers and state management.
Example Code:
class Form extends React.Component {
constructor(props) {
super(props);
this.state = { value: '' };
}
handleChange = (event) => {
this.setState({ value: event.target.value });
};
handleSubmit = (event) => {
alert('A name was submitted: ' + this.state.value);
event.preventDefault();
};
render() {
return (
<form onSubmit={this.handleSubmit}>
<label>
Name:
<input type='text' value={this.state.value} onChange={this.handleChange} />
</label>
<input type='submit' value='Submit' />
</form>
);
}
}Answer:
React hooks are functions that let you use state and other React features without writing a class component. They solve the problem of sharing stateful logic between components, improving code reuse and readability in functional components.
Answer:
Context in React provides a way to pass data through the component tree without having to pass props down manually at every level. It is useful for sharing data that is considered global for a tree of React components, such as themes, user preferences, or authentication status.
Answer:
React Router is a library that provides routing capabilities for single-page applications built with React. It enables navigation between different components or pages in the application without a full page reload.
Example Code:
import { BrowserRouter as Router, Route, Link } from 'react-router-dom';
function App() {
return (
<Router>
<div>
<nav>
<ul>
<li>
<Link to='/'>Home</Link>
</li>
<li>
<Link to='/about'>About</Link>
</li>
</ul>
</nav>
<Route path='/' exact component={Home} />
<Route path='/about' component={About} />
</div>
</Router>
);
}Answer:
`React.Component` is a class-based component that extends the base `Component` class from React, allowing the component to have state and lifecycle methods. Functional components are simpler, functional (stateless) components that use function syntax and cannot have state or lifecycle methods until the introduction of React hooks.
Answer:
Performance optimization in React can be achieved by using shouldComponentUpdate lifecycle method for preventing unnecessary re-renders, memoization with React.memo and useMemo hooks, code splitting and lazy loading with React.lazy and Suspense, optimizing images and assets, and using production build optimizations.
Answer:
`useEffect` is a hook in React that allows performing side effects in functional components. It replaces lifecycle methods like componentDidMount, componentDidUpdate, and componentWillUnmount.
Answer:
Portals in React provide a way to render children into a DOM node that exists outside the DOM hierarchy of the parent component. They are useful for scenarios like modals or tooltips where the content needs to break out of the parent container.
Answer:
React fragments (or `<>...</>` syntax) allow grouping a list of children without adding extra nodes to the DOM. They are used to avoid unnecessary wrapper elements when returning multiple elements from a component.
Answer:
`useState` is a hook used for adding state to functional components with simpler state management. `useReducer` is a hook that provides a way to handle more complex state logic and state transitions in functional components.
Answer:
Context in React provides a way to pass data through the component tree without having to pass props down manually at every level. It is used with `React.createContext` and `Context.Provider` to provide data to nested components.
Answer:
Hooks in React have rules that must be followed: Hooks can only be called at the top level of a functional component or custom hook, not inside loops, conditions, or nested functions. Hooks should always be called in the same order.
Answer:
`useContext` is a hook in React that allows functional components to consume data from a context created with `React.createContext`. It provides an alternative to manually passing props through multiple levels of the component tree.
Example Code:
const ThemeContext = React.createContext('light');
function App() {
const theme = useContext(ThemeContext);
return <div>Current theme: {theme}</div>;
}Answer:
Controlled components are components where form data is controlled by React state. Changes to the input value are handled by state, and the input value is set by the state. Uncontrolled components allow the form data to be handled by the DOM itself.
Answer:
Conditional rendering in React involves rendering different components or elements based on a condition. It can be done using JavaScript conditional operators like if statements or ternary operators inside the JSX.
Answer:
`React.PureComponent` is similar to `React.Component`, but it implements `shouldComponentUpdate` with a shallow prop and state comparison. It prevents unnecessary renders when props and state do not change.
Answer:
Keys are special string attributes used by React to identify which items have changed, are added, or are removed. They help React optimize the rendering process by minimizing re-renders and keeping track of component identities in lists.
Answer:
`React.forwardRef` is a function that creates a React component that forwards the ref attribute to a child component. It allows passing refs through component hierarchies, useful for cases like focus management or integrating with third-party libraries.
Example Code:
const MyComponent = React.forwardRef((props, ref) => (
<input ref={ref} {...props} />
));Answer:
Server-side rendering (SSR) is the process of rendering React components on the server instead of the browser. It improves initial load time, SEO, and performance by sending fully rendered HTML to the client.
Answer:
Portals in React provide a way to render children into a DOM node that exists outside the DOM hierarchy of the parent component. They are useful for scenarios like modals, tooltips, or notifications where the content needs to break out of the parent container.
Answer:
React Hooks are functions that let you use state and other React features without writing a class. They provide a more concise and readable way to manage state, side effects, and lifecycle in functional components compared to class components.
Answer:
`React.memo` is a higher-order component in React that memoizes the rendered output of a functional component. It prevents unnecessary re-renders by caching the result and re-rendering only when props change.
Example Code:
const MyComponent = React.memo(function MyComponent(props) {
/* render using props */
});Answer:
TypeScript adds static typing to JavaScript, providing better tooling, improved code quality through type checking, easier refactoring, and improved documentation for React components and props.
Answer:
Performance optimization in React can be achieved by using React.memo and useMemo for memoization, using shouldComponentUpdate, PureComponent, or React.memo for preventing unnecessary re-renders, optimizing component renders with useMemo and useCallback, code splitting with React.lazy and Suspense, and optimizing images and assets.
Answer:
`useReducer` is a hook in React that provides a way to handle more complex state logic and state transitions in functional components. It is an alternative to `useState` for managing state in components that have more intricate state logic.
Example Code:
const [state, dispatch] = useReducer(reducer, initialState);
Answer:
Forms in React can be handled using controlled components, where form data is controlled by React state, or uncontrolled components, where form data is handled by the DOM itself. React provides event handlers like `onChange` and `onSubmit` to manage form input and submission.
Answer:
`useEffect` is a hook in React that allows performing side effects in functional components. It replaces lifecycle methods like `componentDidMount`, `componentDidUpdate`, and `componentWillUnmount` in class components.
Example Code:
useEffect(() => {
// effect code
return () => {
// cleanup code
};
}, [dependencies]);Answer:
Lazy loading in React involves dynamically loading components or assets only when they are needed, typically used for optimizing performance by reducing the initial bundle size and deferring loading of non-critical resources.
Answer:
`React.Fragment` and the shorthand `<>...</>` syntax both allow grouping multiple elements without adding extra nodes to the DOM. However, `<>...</>` is shorter and doesn't support keys or attributes, while `React.Fragment` does.
Answer:
`useContext` is a hook in React that allows functional components to consume data from a context created with `React.createContext`. It provides an alternative to manually passing props through multiple levels of the component tree.
Example Code:
const ThemeContext = React.createContext('light');
function App() {
const theme = useContext(ThemeContext);
return <div>Current theme: {theme}</div>;
}Answer:
Controlled components are components where form data is controlled by React state. Changes to the input value are handled by state, and the input value is set by the state. Uncontrolled components allow the form data to be handled by the DOM itself.
Answer:
Conditional rendering in React involves rendering different components or elements based on a condition. It can be done using JavaScript conditional operators like if statements or ternary operators inside the JSX.
Example Code:
function Greeting({ isLoggedIn }) {
return (
<div>
{isLoggedIn ? <UserGreeting /> : <GuestGreeting />}
</div>
);
}Answer:
`React.PureComponent` is similar to `React.Component`, but it implements `shouldComponentUpdate` with a shallow prop and state comparison. It prevents unnecessary renders when props and state do not change.
Answer:
Keys are special string attributes used by React to identify which items have changed, are added, or are removed. They help React optimize the rendering process by minimizing re-renders and keeping track of component identities in lists.
Answer:
Portals in React provide a way to render children into a DOM node that exists outside the DOM hierarchy of the parent component. They are useful for scenarios like modals, tooltips, or notifications where the content needs to break out of the parent container.
Answer:
React Hooks are functions that let you use state and other React features without writing a class. They provide a more concise and readable way to manage state, side effects, and lifecycle in functional components compared to class components.
Answer:
`React.memo` is a higher-order component in React that memoizes the rendered output of a functional component. It prevents unnecessary re-renders by caching the result and re-rendering only when props change.
Example Code:
const MyComponent = React.memo(function MyComponent(props) {
/* render using props */
});Answer:
TypeScript adds static typing to JavaScript, providing better tooling, improved code quality through type checking, easier refactoring, and improved documentation for React components and props.
Answer:
Performance optimization in React can be achieved by using React.memo and useMemo for memoization, using shouldComponentUpdate, PureComponent, or React.memo for preventing unnecessary re-renders, optimizing component renders with useMemo and useCallback, code splitting with React.lazy and Suspense, and optimizing images and assets.
Answer:
`useReducer` is a hook in React that provides a way to handle more complex state logic and state transitions in functional components. It is an alternative to `useState` for managing state in components that have more intricate state logic.
Example Code:
const [state, dispatch] = useReducer(reducer, initialState);
Answer:
Forms in React can be handled using controlled components, where form data is controlled by React state, or uncontrolled components, where form data is handled by the DOM itself. React provides event handlers like `onChange` and `onSubmit` to manage form input and submission.
Example Code:
class Form extends React.Component {
constructor(props) {
super(props);
this.state = { value: '' };
}
handleChange = (event) => {
this.setState({ value: event.target.value });
};
handleSubmit = (event) => {
alert('A name was submitted: ' + this.state.value);
event.preventDefault();
};
render() {
return (
<form onSubmit={this.handleSubmit}>
<label>
Name:
<input type='text' value={this.state.value} onChange={this.handleChange} />
</label>
<input type='submit' value='Submit' />
</form>
);
}
}