Top 20 React.js面试题

作者头像东城·2026-01-31 23:45:20·
概述
作为React开发者，对框架的关键概念和原则有扎实的理解是很重要的。考虑到这一点，我整理了一份包含20个重要问题的清单，每个React开发者都应该知道，无论他们是在面试工作还是只是想提高技能。
在深入探讨问题和答案之前，我建议在查看提供的答案之前先尝试自己回答每个问题。这将帮助您评估当前的理解水平并识别可能需要进一步改进的领域。
让我们开始吧！
01. 什么是React，它有什么好处？
答案： React是一个用于构建用户界面的JavaScript库。它用于构建Web应用程序，因为它允许开发者创建可重用的UI组件并以高效和有组织的方式管理应用程序的状态。
React的主要好处：
组件化开发：可重用的UI组件
虚拟DOM：提高性能
单向数据流：易于调试和维护
丰富的生态系统：大量第三方库和工具
跨平台：支持Web、移动端和桌面应用
02. 什么是虚拟DOM，它是如何工作的？
答案： 虚拟DOM（文档对象模型）是浏览器中实际DOM的表示。它使React能够只更新需要更改的网页特定部分，而不是重写整个页面，从而提高性能。
当组件的状态或props发生变化时，React首先创建一个反映更新状态或props的虚拟DOM新版本。然后它将这个新版本与之前的版本进行比较，以确定发生了什么变化。
一旦识别出变化，React就会用最少的操作更新实际DOM，使其与新版本的虚拟DOM保持一致。这个过程被称为"协调"。
使用虚拟DOM可以实现更高效的更新，因为它减少了直接操作实际DOM的次数，而直接操作DOM可能是一个缓慢且资源密集的过程。通过只更新实际发生变化的部分，React可以提高应用程序的性能，特别是在慢速设备上或处理大量数据时。
03. React如何处理更新和渲染？
答案： React通过虚拟DOM和基于组件的架构处理更新和渲染。当组件的状态或props发生变化时，React创建一个反映更新状态或props的虚拟DOM新版本，然后将其与之前的版本进行比较以确定发生了什么变化。React用最少的操作更新实际DOM，使其与新版本的虚拟DOM保持一致，这个过程称为"协调"。React还使用基于组件的架构，其中每个组件都有自己的状态和渲染方法。它只重新渲染实际发生变化的组件。它高效且快速地执行此操作，这就是为什么React以其性能而闻名。
04. 解释React中组件的概念？
答案： React组件是一个JavaScript函数或类，它返回一个React元素，该元素描述了应用程序一部分的UI。组件可以接受称为"props"的输入，并管理自己的状态。
函数组件示例：
  1. function Welcome({ name }) {
  2. return <h1>Hello, {name}!h1>;
  3. }
jsx
类组件示例：
  1. class Welcome extends React.Component {
  2. render() {
  3. return <h1>Hello, {this.props.name}!h1>;
  4. }
  5. }
jsx
05. 什么是JSX，为什么在React中使用它？
答案： JSX是JavaScript的语法扩展，允许在JavaScript中嵌入类似HTML的语法。它在React中用于描述UI，并通过Babel等构建工具转换为纯JavaScript。
JSX示例：
  1. // JSX语法
  2. const element = (
  3. <div className="container">
  4. <h1>Hello Worldh1>
  5. <p>Welcome to Reactp>
  6. div>
  7. );

  9. // 编译后的JavaScript
  10. const element = React.createElement(
  11. 'div',
  12. { className: 'container' },
  13. React.createElement('h1', null, 'Hello World'),
  14. React.createElement('p', null, 'Welcome to React')
  15. );
jsx
06. state和props之间有什么区别？
答案： State和props都用于在React组件中存储数据，但它们服务于不同的目的并具有不同的特征。
Props（"properties"的缩写）是从父组件向子组件传递数据的一种方式。它们是只读的，不能被子组件修改。
另一方面，State是一个对象，它保存组件中可以随时间变化的数据。可以使用setState()方法更新它，用于控制组件的行为和渲染。
对比示例：
  1. // Props - 从父组件传递，只读
  2. function ChildComponent({ name, age }) {
  3. return (
  4. <div>
  5. <p>Name: {name}p>
  6. <p>Age: {age}p>
  7. div>
  8. );
  9. }

  11. // State - 组件内部管理，可修改
  12. function ParentComponent() {
  13. const [count, setCount] = useState(0);
  15. return (
  16. <div>
  17. <p>Count: {count}p>
  18. <button onClick={() => setCount(count + 1)}>
  19. Increment
  20. button>
  21. <ChildComponent name="John" age={25} />
  22. div>
  23. );
  24. }
jsx
07. React中受控组件和非受控组件之间有什么区别？
答案： 在React中，受控组件和非受控组件指的是处理表单的方式。受控组件是表单状态由React控制的组件，表单输入的更新由事件处理程序处理。另一方面，非受控组件依赖于浏览器的默认行为来处理表单输入的更新。
受控组件是输入字段的值由状态设置，变化由React的事件处理程序管理的组件，这允许更好地控制表单的行为和验证，并且使处理表单提交变得容易。
另一方面，非受控组件是输入字段的值由默认值属性设置，变化由浏览器的默认行为管理的组件，这种方法性能较差，处理表单提交和验证更困难。
受控组件示例：
  1. function ControlledComponent() {
  2. const [value, setValue] = useState('');
  4. const handleChange = (event) => {
  5. setValue(event.target.value);
  6. };
  8. return (
  9. <input
  10. type="text"
  11. value={value}
  12. onChange={handleChange}
  13. />
  14. );
  15. }
jsx
非受控组件示例：
  1. function UncontrolledComponent() {
  2. const inputRef = useRef();
  4. const handleSubmit = (event) => {
  5. event.preventDefault();
  6. console.log('Value:', inputRef.current.value);
  7. };
  9. return (
  10. <form onSubmit={handleSubmit}>
  11. <input
  12. type="text"
  13. ref={inputRef}
  14. defaultValue=""
  15. />
  16. <button type="submit">Submitbutton>
  17. form>
  18. );
  19. }
jsx
08. 什么是Redux，它如何与React一起工作？
答案： Redux是一个用于JavaScript应用程序的可预测状态管理库，通常与React一起使用。它为应用程序的状态提供集中存储，并使用称为reducers的纯函数来响应actions更新状态。
在React应用程序中，Redux通过react-redux库与React集成，该库提供connect函数来连接组件到Redux存储并分发actions。组件可以通过connect函数提供的props访问存储中的状态，并分发actions来更新状态。
Redux基本概念：
  1. // Action
  2. const addTodo = (text) => ({
  3. type: 'ADD_TODO',
  4. payload: { text, completed: false }
  5. });

  7. // Reducer
  8. const todoReducer = (state = [], action) => {
  9. switch (action.type) {
  10. case 'ADD_TODO':
  11. return [...state, action.payload];
  12. default:
  13. return state;
  14. }
  15. };

  17. // Store
  18. const store = createStore(todoReducer);

  20. // 在React组件中使用
  21. function TodoList() {
  22. const todos = useSelector(state => state);
  23. const dispatch = useDispatch();
  25. const handleAddTodo = (text) => {
  26. dispatch(addTodo(text));
  27. };
  29. return (
  30. <div>
  31. {todos.map((todo, index) => (
  32. <div key={index}>{todo.text}div>
  33. ))}
  34. div>
  35. );
  36. }
jsx
09. 你能解释React中高阶组件（HOC）的概念吗？
答案： React中的高阶组件（HOC）是一个接受组件并返回具有额外props的新组件的函数。HOC用于在多个组件之间重用逻辑，例如添加通用行为或样式。
HOC通过将组件包装在HOC内来使用，HOC返回具有添加props的新组件。原始组件作为参数传递给HOC，并通过解构接收额外的props。HOC是纯函数，这意味着它们不修改原始组件，而是返回一个新的、增强的组件。
例如，HOC可用于向组件添加身份验证行为，例如在渲染组件之前检查用户是否已登录。HOC将处理检查用户是否已登录的逻辑，并将指示登录状态的prop传递给包装的组件。
HOC是React中的一个强大模式，允许代码重用和抽象，同时保持组件的模块化和易于维护。
HOC示例：
  1. // 高阶组件
  2. function withAuth(WrappedComponent) {
  3. return function AuthenticatedComponent(props) {
  4. const [isAuthenticated, setIsAuthenticated] = useState(false);
  6. useEffect(() => {
  7. // 检查用户是否已登录
  8. checkAuthStatus().then(setIsAuthenticated);
  9. }, []);
  11. if (!isAuthenticated) {
  12. return <div>请先登录div>;
  13. }
  15. return <WrappedComponent {...props} />;
  16. };
  17. }

  19. // 使用HOC
  20. const ProtectedComponent = withAuth(UserProfile);

  22. function UserProfile() {
  23. return <div>用户资料页面div>;
  24. }
jsx
10. React中服务端渲染和客户端渲染之间有什么区别？
答案： 服务端渲染（SSR）和客户端渲染（CSR）是渲染React应用程序的两种不同方式。
在SSR中，初始HTML在服务器上生成，然后发送到客户端，在那里它被水合（hydrated）成完整的React应用程序。这导致更快的初始加载时间，因为HTML已经存在于页面上，并且可以被搜索引擎索引。
在CSR中，初始HTML是一个最小的、空的文档，React应用程序完全在客户端构建和渲染。客户端进行API调用来获取渲染UI所需的数据。这导致较慢的初始加载时间，但更响应和动态的体验，因为所有渲染都在客户端完成。
SSR vs CSR对比：
特性
SSR
CSR
初始加载速度
快
慢
SEO友好性
好
差
交互性
需要水合
立即
服务器负载
高
低
开发复杂度
高
低
11. 什么是React Hooks，它们是如何工作的？
答案： React Hooks是React中的一个功能，允许函数组件在不使用类组件的情况下拥有状态和其他生命周期方法。它们使在多个组件之间重用状态和逻辑变得更容易，使代码更简洁、更易读。Hooks包括用于添加状态的useState和用于响应状态或props变化执行副作用的useEffect。它们使编写可重用、可维护的代码变得更容易。
常用Hooks示例：
  1. import { useState, useEffect, useContext } from 'react';

  3. function ExampleComponent() {
  4. // useState Hook
  5. const [count, setCount] = useState(0);
  7. // useEffect Hook
  8. useEffect(() => {
  9. document.title = `Count: ${count}`;
  10. }, [count]);
  12. // useContext Hook
  13. const theme = useContext(ThemeContext);
  15. return (
  16. <div style={{ background: theme.background }}>
  17. <p>Count: {count}p>
  18. <button onClick={() => setCount(count + 1)}>
  19. Increment
  20. button>
  21. div>
  22. );
  23. }
jsx
12. React如何处理状态管理？
答案： React通过其状态对象和setState()方法处理状态管理。状态对象是一个数据结构，存储组件内变化的值，可以使用setState()方法更新。状态更新触发组件的重新渲染，允许它动态显示更新的值。React以异步和批处理的方式更新状态，确保多个setState()调用合并为单个更新以获得更好的性能。
状态管理示例：
  1. function StateManagementExample() {
  2. const [user, setUser] = useState({
  3. name: '',
  4. email: '',
  5. age: 0
  6. });
  8. const updateUser = (field, value) => {
  9. setUser(prevUser => ({
  10. ...prevUser,
  11. [field]: value
  12. }));
  13. };
  15. return (
  16. <div>
  17. <input
  18. value={user.name}
  19. onChange={(e) => updateUser('name', e.target.value)}
  20. placeholder="姓名"
  21. />
  22. <input
  23. value={user.email}
  24. onChange={(e) => updateUser('email', e.target.value)}
  25. placeholder="邮箱"
  26. />
  27. <input
  28. type="number"
  29. value={user.age}
  30. onChange={(e) => updateUser('age', parseInt(e.target.value))}
  31. placeholder="年龄"
  32. />
  33. div>
  34. );
  35. }
jsx
13. useEffect Hook在React中是如何工作的？
答案： React中的useEffect Hook允许开发者在函数组件中执行副作用，如数据获取、订阅和设置/清理定时器。它在每次渲染后运行，包括第一次渲染，以及在渲染提交到屏幕之后。useEffect Hook接受两个参数 - 每次渲染后运行的函数和确定何时运行效果的依赖项数组。如果依赖项数组为空或不存在，效果将在每次渲染后运行。
useEffect使用示例：
  1. function UserProfile({ userId }) {
  2. const [user, setUser] = useState(null);
  3. const [loading, setLoading] = useState(true);
  5. // 组件挂载时获取用户数据
  6. useEffect(() => {
  7. const fetchUser = async () => {
  8. try {
  9. const response = await fetch(`/api/users/${userId}`);
  10. const userData = await response.json();
  11. setUser(userData);
  12. } catch (error) {
  13. console.error('获取用户失败:', error);
  14. } finally {
  15. setLoading(false);
  16. }
  17. };
  19. fetchUser();
  20. }, [userId]); // 当userId改变时重新运行
  22. // 清理副作用
  23. useEffect(() => {
  24. const timer = setInterval(() => {
  25. console.log('定时器运行');
  26. }, 1000);
  28. return () => {
  29. clearInterval(timer); // 清理定时器
  30. };
  31. }, []); // 只在组件挂载时运行
  33. if (loading) return <div>加载中...div>;
  34. if (!user) return <div>用户不存在div>;
  36. return (
  37. <div>
  38. <h2>{user.name}h2>
  39. <p>{user.email}p>
  40. div>
  41. );
  42. }
jsx
14. 你能解释React中服务端渲染的概念吗？
答案： React中的服务端渲染（SSR）是在服务器上渲染组件并将完全渲染的HTML发送到浏览器的过程。SSR通过向浏览器提供完全渲染的HTML来改善React应用程序的初始加载性能和SEO，减少需要在客户端解析和执行的JavaScript数量，并改善搜索引擎对网页的索引。在SSR中，React组件在服务器上渲染并作为完全形成的HTML字符串发送到客户端，改善初始加载时间并提供更SEO友好的网页。
SSR实现示例（使用Next.js）：
  1. // pages/users/[id].js
  2. export async function getServerSideProps({ params }) {
  3. try {
  4. const response = await fetch(`https://api.example.com/users/${params.id}`);
  5. const user = await response.json();
  7. return {
  8. props: {
  9. user,
  10. },
  11. };
  12. } catch (error) {
  13. return {
  14. notFound: true,
  15. };
  16. }
  17. }

  19. function UserPage({ user }) {
  20. return (
  21. <div>
  22. <h1>{user.name}h1>
  23. <p>{user.email}p>
  24. div>
  25. );
  26. }

  28. export default UserPage;
jsx
15. React如何处理事件，有哪些常见的事件处理程序？
答案： React通过其事件处理系统处理事件，其中事件处理程序作为props传递给组件。事件处理程序是在特定事件发生时执行的函数，例如用户点击按钮。React中常见的事件处理程序包括onClick、onChange、onSubmit等。事件处理程序接收一个事件对象，该对象包含有关事件的信息，例如目标元素、事件类型以及与事件相关的任何数据。React事件处理程序应该作为props传递给组件，事件处理程序应该在组件内定义或在单独的辅助函数中定义。
事件处理示例：
  1. function EventHandlingExample() {
  2. const [formData, setFormData] = useState({
  3. name: '',
  4. email: ''
  5. });
  7. const handleInputChange = (e) => {
  8. const { name, value } = e.target;
  9. setFormData(prev => ({
  10. ...prev,
  11. [name]: value
  12. }));
  13. };
  15. const handleSubmit = (e) => {
  16. e.preventDefault();
  17. console.log('表单提交:', formData);
  18. };
  20. const handleClick = () => {
  21. console.log('按钮被点击');
  22. };
  24. return (
  25. <form onSubmit={handleSubmit}>
  26. <input
  27. type="text"
  28. name="name"
  29. value={formData.name}
  30. onChange={handleInputChange}
  31. placeholder="姓名"
  32. />
  33. <input
  34. type="email"
  35. name="email"
  36. value={formData.email}
  37. onChange={handleInputChange}
  38. placeholder="邮箱"
  39. />
  40. <button type="submit" onClick={handleClick}>
  41. 提交
  42. button>
  43. form>
  44. );
  45. }
jsx
16. 你能解释React Context的概念吗？
答案： React Context是一种在组件之间共享数据的方式，无需手动通过组件树的每个级别传递props。Context通过提供者创建，并使用useContext Hook被多个组件消费。
Context使用示例：
  1. // 创建Context
  2. const ThemeContext = createContext();
  3. const UserContext = createContext();

  5. // 提供者组件
  6. function App() {
  7. const [theme, setTheme] = useState('light');
  8. const [user, setUser] = useState({ name: 'John', role: 'admin' });
  10. return (
  11. <ThemeContext.Provider value={{ theme, setTheme }}>
  12. <UserContext.Provider value={user}>
  13. <Header />
  14. <Main />
  15. <Footer />
  16. UserContext.Provider>
  17. ThemeContext.Provider>
  18. );
  19. }

  21. // 消费Context的组件
  22. function Header() {
  23. const { theme, setTheme } = useContext(ThemeContext);
  24. const user = useContext(UserContext);
  26. return (
  27. <header style={{ background: theme === 'light' ? '#fff' : '#333' }}>
  28. <h1>欢迎, {user.name}!h1>
  29. <button onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}>
  30. 切换主题
  31. button>
  32. header>
  33. );
  34. }
jsx
17. React如何处理路由，有哪些流行的React路由库？
答案： React通过使用React Router库处理路由，该库为React应用程序提供路由功能。一些流行的React路由库包括React Router、Reach Router和Next.js。
React Router示例：
  1. import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';

  3. function App() {
  4. return (
  5. <BrowserRouter>
  6. <nav>
  7. <Link to="/">首页Link>
  8. <Link to="/about">关于Link>
  9. <Link to="/users">用户Link>
  10. nav>
  12. <Routes>
  13. <Route path="/" element={<Home />} />
  14. <Route path="/about" element={<About />} />
  15. <Route path="/users" element={<Users />} />
  16. <Route path="/users/:id" element={<UserDetail />} />
  17. <Route path="*" element={<NotFound />} />
  18. Routes>
  19. BrowserRouter>
  20. );
  21. }

  23. function Home() {
  24. return <h1>首页h1>;
  25. }

  27. function About() {
  28. return <h1>关于我们h1>;
  29. }

  31. function Users() {
  32. return <h1>用户列表h1>;
  33. }

  35. function UserDetail() {
  36. const { id } = useParams();
  37. return <h1>用户详情: {id}h1>;
  38. }

  40. function NotFound() {
  41. return <h1>页面未找到h1>;
  42. }
jsx
18. React中有哪些性能优化的最佳实践？
答案： React性能优化的最佳实践包括使用记忆化、避免不必要的重新渲染、对组件和图像使用懒加载，以及使用正确的数据结构。
性能优化示例：
  1. import { memo, useMemo, useCallback, lazy, Suspense } from 'react';

  3. // 1. 使用React.memo避免不必要的重新渲染
  4. const ExpensiveComponent = memo(function ExpensiveComponent({ data }) {
  5. return (
  6. <div>
  7. {data.map(item => (
  8. <div key={item.id}>{item.name}div>
  9. ))}
  10. div>
  11. );
  12. });

  14. // 2. 使用useMemo记忆化计算结果
  15. function ProductList({ products, filters }) {
  16. const filteredProducts = useMemo(() => {
  17. return products.filter(product =>
  18. product.category === filters.category
  19. );
  20. }, [products, filters.category]);
  22. return (
  23. <div>
  24. {filteredProducts.map(product => (
  25. <ProductCard key={product.id} product={product} />
  26. ))}
  27. div>
  28. );
  29. }

  31. // 3. 使用useCallback记忆化函数
  32. function ParentComponent() {
  33. const [count, setCount] = useState(0);
  35. const handleClick = useCallback(() => {
  36. console.log('按钮被点击');
  37. }, []);
  39. return (
  40. <div>
  41. <p>Count: {count}p>
  42. <button onClick={() => setCount(count + 1)}>
  43. Increment
  44. button>
  45. <ChildComponent onAction={handleClick} />
  46. div>
  47. );
  48. }

  50. // 4. 懒加载组件
  51. const LazyComponent = lazy(() => import('./LazyComponent'));

  53. function App() {
  54. return (
  55. <Suspense fallback={<div>加载中...div>}>
  56. <LazyComponent />
  57. Suspense>
  58. );
  59. }
jsx
19. React如何处理测试，有哪些流行的React测试框架？
答案： React使用Jest、Mocha和Enzyme等测试框架处理测试。Jest是React应用程序的流行测试框架，而Mocha和Enzyme也被广泛使用。
测试示例：
  1. // 使用Jest和React Testing Library
  2. import { render, screen, fireEvent } from '@testing-library/react';
  3. import '@testing-library/jest-dom';
  4. import Counter from './Counter';

  6. describe('Counter Component', () => {
  7. test('renders counter with initial value', () => {
  8. render(<Counter />);
  9. expect(screen.getByText('Count: 0')).toBeInTheDocument();
  10. });
  12. test('increments counter when button is clicked', () => {
  13. render(<Counter />);
  14. const button = screen.getByText('Increment');
  15. fireEvent.click(button);
  16. expect(screen.getByText('Count: 1')).toBeInTheDocument();
  17. });
  18. });

  20. // 使用Enzyme
  21. import { shallow, mount } from 'enzyme';
  22. import Counter from './Counter';

  24. describe('Counter Component', () => {
  25. it('renders without crashing', () => {
  26. const wrapper = shallow(<Counter />);
  27. expect(wrapper.exists()).toBe(true);
  28. });
  30. it('increments counter when button is clicked', () => {
  31. const wrapper = mount(<Counter />);
  32. const button = wrapper.find('button');
  33. button.simulate('click');
  34. expect(wrapper.find('p').text()).toBe('Count: 1');
  35. });
  36. });
jsx
20. 你如何在React中处理异步数据加载？
答案： React中的异步数据加载可以使用fetch API、Axios或其他网络库等各种方法处理。也可以使用useState和useEffect hooks来触发API调用返回数据时的状态更新。正确处理加载和错误状态以提供良好的用户体验很重要。
异步数据加载示例：
  1. function UserList() {
  2. const [users, setUsers] = useState([]);
  3. const [loading, setLoading] = useState(true);
  4. const [error, setError] = useState(null);
  6. useEffect(() => {
  7. const fetchUsers = async () => {
  8. try {
  9. setLoading(true);
  10. const response = await fetch('/api/users');
  12. if (!response.ok) {
  13. throw new Error('获取用户失败');
  14. }
  16. const data = await response.json();
  17. setUsers(data);
  18. setError(null);
  19. } catch (err) {
  20. setError(err.message);
  21. } finally {
  22. setLoading(false);
  23. }
  24. };
  26. fetchUsers();
  27. }, []);
  29. if (loading) {
  30. return <div>加载中...div>;
  31. }
  33. if (error) {
  34. return <div>错误: {error}div>;
  35. }
  37. return (
  38. <div>
  39. <h2>用户列表h2>
  40. {users.map(user => (
  41. <div key={user.id}>
  42. <h3>{user.name}h3>
  43. <p>{user.email}p>
  44. div>
  45. ))}
  46. div>
  47. );
  48. }

  50. // 使用自定义Hook
  51. function useFetch(url) {
  52. const [data, setData] = useState(null);
  53. const [loading, setLoading] = useState(true);
  54. const [error, setError] = useState(null);
  56. useEffect(() => {
  57. const fetchData = async () => {
  58. try {
  59. setLoading(true);
  60. const response = await fetch(url);
  61. const result = await response.json();
  62. setData(result);
  63. } catch (err) {
  64. setError(err.message);
  65. } finally {
  66. setLoading(false);
  67. }
  68. };
  70. fetchData();
  71. }, [url]);
  73. return { data, loading, error };
  74. }

  76. function ProductList() {
  77. const { data: products, loading, error } = useFetch('/api/products');
  79. if (loading) return <div>加载中...div>;
  80. if (error) return <div>错误: {error}div>;
  82. return (
  83. <div>
  84. {products.map(product => (
  85. <ProductCard key={product.id} product={product} />
  86. ))}
  87. div>
  88. );
  89. }
jsx
总结
这个博客文章涵盖了React开发者在2023年应该知道的20个主要问题。这些问题涵盖了从React基础知识、其好处和架构，到更高级的概念，如JSX、状态和props、受控和非受控组件、Redux、高阶组件等广泛的主题。通过在查看答案之前尝试自己回答每个问题，您可以对React框架有更深入的理解，并成为更好的React开发者。