当前位置：首页 > article >正文

2024React面试精选——持续更新

article 2024/11/16 16:57:30

React中为什么要设计Hook，为了解决什么问题
组件的生命周期方法
状态（state）和属性（props）
高阶组件（Higher-Order Component，简称 HOC）
受控组件和非受控组件
展示组件(Presentational component)和容器组件(Containercomponent)区别
类组件(Class component) 和函数式组件(Functional component)的区别
何划分技术组件和业务组件
什么是 React 中的上下文(Context)？它有什么作用？
React是mvvm框架吗
React 如何实现 mvvm
redux 主要解决什么问题及优缺点
React 性能优化方案，所关联周期函数
虚拟 DOM 的意义
react DOM Diff 算法
关于 Fiber 架构
关于 Flux
React 项目脚手架
React 组件可请求数据生命周期钩子
refs 的作用
key 在渲染列表时的作用
如何使用 useState Hook 来管理状态
如何使用 useEffect Hook 执行副作用操作
如何使用自定义Hook来共享逻辑
react中useMemo的原理是什么，底层怎么实现的
谈一谈你对react router的理解
react如何实现路由守卫
如何使用hooks封装防抖和节流

1. React中为什么要设计Hook，为了解决什么问题

复用逻辑：
- 在 Class 组件中，复用逻辑通常需要借助高阶组件（HOC）或 Render Props 等模式，这些模式虽然有效，但会使组件层级变深，增加复杂性。
- Hooks 提供了一种更简洁的方式来复用组件逻辑，使得逻辑可以在函数组件之间共享。
减少生命周期方法的混乱：
- Class 组件中的生命周期方法（如 componentDidMount、componentDidUpdate 等）容易导致代码分散和难以维护。
- Hooks 将相关逻辑集中在一起，使得代码更加直观和易读。例如，useEffect 可以将副作用逻辑集中处理。
简化组件：
- Class 组件需要定义 class 并实现 render 方法，增加了不必要的复杂性和冗余代码。
- Hooks 允许使用函数组件，减少了样板代码，使组件更加轻量和易于理解。
更好的类型支持：
- 函数组件比类组件更容易进行静态类型检查，特别是在使用 TypeScript 时。
- Hooks 使得类型推断更加准确，提高了代码的可维护性和健壮性。
性能优化：
- Hooks 通过 useMemo 和 useCallback 等 Hook 提供了更细粒度的性能优化手段，避免不必要的重新渲染。
更好的测试支持：
- 函数组件和 Hooks 的组合使得测试更加简单和直接，因为可以更容易地隔离和模拟组件的行为。

总结来说，Hooks 的引入使得 React 组件更加模块化、可复用和易维护，同时减少了代码的复杂性和冗余。这对于大型项目的开发和维护具有重要意义。

2. 组件的生命周期方法

组件的生命周期方法

在 React 中，组件的生命周期可以分为三个主要阶段：挂载（Mounting）、更新（Updating）和卸载（Unmounting）。每个阶段都有一系列的生命周期方法，帮助开发者在特定的时间点执行特定的操作。以下是一些常见的生命周期方法：

挂载阶段（Mounting）

constructor(props)

构造函数，用于初始化 state 和绑定事件处理函数。

示例：

constructor(props) {
  super(props);
  this.state = { count: 0 };
  this.handleClick = this.handleClick.bind(this);
}

static getDerivedStateFromProps(props, state)
- 静态方法，用于在组件实例被创建和插入 DOM 前，根据 props 更新 state。
- 返回值会作为新的 state。
- 示例：
```
static getDerivedStateFromProps(props, state) {
  return { count: props.initialCount };
}
```
render()
- 必须实现的方法，返回 JSX 或 null。
- 示例：
```
render() {
  return <div>{this.state.count}</div>;
}
```

componentDidMount()

组件被渲染到 DOM 后调用，适合发起网络请求、设置定时器等操作。

示例：

componentDidMount() {
  fetch('/api/data')
    .then(response => response.json())
    .then(data => this.setState({ data }));
}

更新阶段（Updating）

static getDerivedStateFromProps(props, state)
- 在每次渲染前都会调用，包括首次渲染。
- 用于根据新的 props 更新 state。
- 示例同上。
shouldComponentUpdate(nextProps, nextState)
- 决定组件是否需要重新渲染。
- 返回布尔值，如果返回 false，则不会触发后续的生命周期方法。
- 示例：
```
shouldComponentUpdate(nextProps, nextState) {
  return this.state.count !== nextState.count;
}
```
render()
- 重新渲染组件时调用。
- 示例同上。
getSnapshotBeforeUpdate(prevProps, prevState)
- 在最近一次渲染输出（提交到 DOM 节点）之前调用。
- 可以捕获一些 DOM 信息，如滚动位置。
- 返回的值会作为 componentDidUpdate 的第三个参数。
- 示例：
```
getSnapshotBeforeUpdate(prevProps, prevState) {
  return document.getElementById('myDiv').scrollTop;
}
```
componentDidUpdate(prevProps, prevState, snapshot)
- 组件更新后调用，适合执行 DOM 操作或发起网络请求。
- 可以访问 getSnapshotBeforeUpdate 返回的值。
- 示例：
```
componentDidUpdate(prevProps, prevState, snapshot) {
  if (snapshot) {
    document.getElementById('myDiv').scrollTop = snapshot;
  }
}
```

卸载阶段（Unmounting）

componentWillUnmount()
- 组件被卸载前调用，适合清理工作，如取消网络请求、清除定时器等。
- 示例：
```
componentWillUnmount() {
  clearTimeout(this.timer);
}
```

错误处理

static getDerivedStateFromError(error)
- 在后代组件抛出错误后调用，用于更新 state 以展示错误界面。
- 返回值会作为新的 state。
- 示例：
```
static getDerivedStateFromError(error) {
  return { hasError: true };
}
```
componentDidCatch(error, info)
- 在后代组件抛出错误后调用，适合记录错误信息。
- 示例：
```
componentDidCatch(error, info) {
  console.error('Error:', error, 'Info:', info);
}
```

这些生命周期方法帮助开发者在不同的阶段对组件进行控制和优化，确保应用的高效和稳定运行。

3. 状态（state）和属性（props）

状态（state）和属性（props）

在 React 中，state 和 props 是两个非常重要的概念，它们分别用于管理和传递数据。理解它们的区别和用途对于编写高效的 React 应用至关重要。

状态（state）

定义：
- state 是组件内部的状态对象，用于存储组件的动态数据。
- state 是私有的，只能在组件内部修改。
特点：
- 可变性：state 可以在组件的生命周期中发生变化，变化会触发组件的重新渲染。
- 局部性：state 只能在定义它的组件内部访问和修改。
- 初始化：通常在组件的构造函数中初始化 state。

使用示例：

class Counter extends React.Component {
  constructor(props) {
    super(props);
    this.state = { count: 0 }; // 初始化 state
  }

  increment = () => {
    this.setState({ count: this.state.count + 1 }); // 修改 state
  };

  render() {
    return (
      <div>
        <p>Count: {this.state.count}</p>
        <button onClick={this.increment}>Increment</button>
      </div>
    );
  }
}

属性（props）

定义：
- props 是组件的属性对象，用于从父组件向子组件传递数据。
- props 是只读的，不能在组件内部修改。
特点：
- 不可变性：props 是只读的，任何尝试修改 props 的操作都会导致错误。
- 全局性：props 可以在多个组件之间传递，实现数据共享。
- 传递性：父组件可以通过 props 向子组件传递任意类型的数据（字符串、数字、对象、函数等）。

使用示例：

class ParentComponent extends React.Component {
  constructor(props) {
    super(props);
    this.state = { message: 'Hello from Parent' };
  }

  render() {
    return <ChildComponent message={this.state.message} />;
  }
}

function ChildComponent(props) {
  return <p>{props.message}</p>; // 使用 props
}

主要区别

可变性：
- state 是可变的，可以在组件内部通过 setState 方法修改。
- props 是不可变的，只能由父组件传递，子组件不能修改。
作用范围：
- state 是组件内部的状态，只能在定义它的组件内部访问和修改。
- props 是组件之间的通信方式，可以从父组件传递到子组件。
初始化：
- state 通常在组件的构造函数中初始化。
- props 由父组件传递，不需要在子组件中初始化。
使用场景：
- state 用于管理组件的内部状态，如表单输入、计数器等。
- props 用于从父组件向子组件传递数据，实现组件间的通信。

总结

state：组件内部的状态，可变，局部。
props：组件之间的数据传递，不可变，全局。

理解 state 和 props 的区别和使用场景，有助于编写更清晰、更高效的 React 应用。

4. 高阶组件（Higher-Order Component，简称 HOC）

高阶组件

高阶组件（Higher-Order Component，简称 HOC）是 React 中一种常见的设计模式，用于复用组件逻辑。高阶组件本身不是 React 的 API，而是一种基于 React 的组合特性实现的模式。通过高阶组件，可以增强现有组件的功能，而无需修改组件本身的代码。

定义

高阶组件是一个函数，它接受一个组件作为参数，并返回一个新的组件。这个新的组件通常会添加一些额外的逻辑或属性。

特点

复用逻辑：
- 高阶组件可以封装和复用组件的逻辑，如数据获取、权限校验等。
不改变原组件：
- 高阶组件不会修改传入的组件，而是返回一个新的组件。
透明性：
- 高阶组件保持原组件的接口不变，使用者仍然可以像使用普通组件一样使用高阶组件返回的新组件。

基本用法

1. 创建高阶组件

function withLogging(WrappedComponent) {
  return class extends React.Component {
    componentDidMount() {
      console.log('Component mounted');
    }

    componentDidUpdate() {
      console.log('Component updated');
    }

    render() {
      return <WrappedComponent {...this.props} />;
    }
  };
}

2. 使用高阶组件

class MyComponent extends React.Component {
  render() {
    return <div>Hello, World!</div>;
  }
}

const EnhancedComponent = withLogging(MyComponent);

ReactDOM.render(<EnhancedComponent />, document.getElementById('root'));

常见应用场景

数据获取：

从 API 获取数据并传递给组件。

示例：

function withData(WrappedComponent, url) {
  return class extends React.Component {
    state = { data: null };

    async componentDidMount() {
      const response = await fetch(url);
      const data = await response.json();
      this.setState({ data });
    }

    render() {
      return <WrappedComponent data={this.state.data} {...this.props} />;
    }
  };
}

权限校验：

根据用户权限决定是否渲染组件。

示例：

function withAuth(WrappedComponent, authChecker) {
  return class extends React.Component {
    state = { isAuthenticated: false };

    async componentDidMount() {
      const isAuthenticated = await authChecker();
      this.setState({ isAuthenticated });
    }

    render() {
      return this.state.isAuthenticated ? (
        <WrappedComponent {...this.props} />
      ) : (
        <div>You are not authorized to view this content.</div>
      );
    }
  };
}

日志记录：

记录组件的生命周期事件。

示例：

function withLogging(WrappedComponent) {
  return class extends React.Component {
    componentDidMount() {
      console.log('Component mounted');
    }

    componentDidUpdate() {
      console.log('Component updated');
    }

    componentWillUnmount() {
      console.log('Component will unmount');
    }

    render() {
      return <WrappedComponent {...this.props} />;
    }
  };
}

注意事项

静态方法：

高阶组件可能会覆盖原组件的静态方法，可以使用 hoist-non-react-statics 库来保留静态方法。

示例：

import hoistNonReactStatic from 'hoist-non-react-statics';

function withLogging(WrappedComponent) {
  class LoggingComponent extends React.Component {
    componentDidMount() {
      console.log('Component mounted');
    }

    render() {
      return <WrappedComponent {...this.props} />;
    }
  }

  hoistNonReactStatic(LoggingComponent, WrappedComponent);

  return LoggingComponent;
}

默认 Props 和 Prop 类型：

高阶组件可能会覆盖原组件的 defaultProps 和 propTypes，需要手动传递。

示例：

function withLogging(WrappedComponent) {
  class LoggingComponent extends React.Component {
    componentDidMount() {
      console.log('Component mounted');
    }

    render() {
      return <WrappedComponent {...this.props} />;
    }
  }

  LoggingComponent.defaultProps = WrappedComponent.defaultProps;
  LoggingComponent.propTypes = WrappedComponent.propTypes;

  return LoggingComponent;
}

命名冲突：

高阶组件可能会引入新的 props，需要注意命名冲突。

示例：

function withLogging(WrappedComponent) {
  return class extends React.Component {
    componentDidMount() {
      console.log('Component mounted');
    }

    render() {
      const { logMessage, ...passThroughProps } = this.props;
      return <WrappedComponent {...passThroughProps} />;
    }
  };
}

总结

高阶组件是 React 中一种强大的设计模式，可以帮助开发者复用组件逻辑，提升代码的可维护性和可读性。通过合理使用高阶组件，可以有效地管理组件的复杂性，提高开发效率。

5. 受控组件和非受控组件

在React中，表单元素可以分为两种类型：受控组件（Controlled Components）和非受控组件（Uncontrolled Components）。下面是它们的区别：

受控组件：

表单数据由React组件的state管理。
每当用户输入数据时，会触发一个事件处理器来更新state。
通过这种方式，React组件的state总是与表单元素的值保持同步。

示例代码：

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.state = {value: ''};

    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleChange(event) {
    this.setState({value: event.target.value});
  }

  handleSubmit(event) {
    alert('提交的名字: ' + this.state.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          名字:
          <input type="text" value={this.state.value} onChange={this.handleChange} />
        </label>
        <input type="submit" value="提交" />
      </form>
    );
  }
}

非受控组件：

表单数据由DOM节点直接管理。
使用ref来获取表单元素的值。
更接近传统的HTML表单处理方式，但在某些情况下可能更简单或更高效。

示例代码：

class NameForm extends React.Component {
  constructor(props) {
    super(props);
    this.handleSubmit = this.handleSubmit.bind(this);
    this.input = React.createRef();
  }

  handleSubmit(event) {
    alert('提交的名字: ' + this.input.current.value);
    event.preventDefault();
  }

  render() {
    return (
      <form onSubmit={this.handleSubmit}>
        <label>
          名字:
          <input type="text" ref={this.input} />
        </label>
        <input type="submit" value="提交" />
      </form>
    );
  }
}

总结

受控组件更适合需要频繁更新状态的应用场景，如实时验证或动态更新UI。
非受控组件适用于简单的表单处理，尤其是在不需要频繁更新状态的情况下。

6. 展示组件(Presentational component)和容器组件(Containercomponent)区别

在React应用开发中，将组件分为展示组件（Presentational Component）和容器组件（Container Component）是一种常见的设计模式，有助于更好地组织和维护代码。以下是它们的主要区别：

展示组件（Presentational Component）

职责：
- 负责UI的展示。
- 不关心数据从哪里来，只负责如何展示数据。
特点：
- 接收数据和回调函数作为props。
- 通常是纯函数组件（Pure Function Component），不包含任何状态管理逻辑。
- 可以复用，因为它们只关注UI的呈现。
- 通常没有副作用，如数据获取、订阅或路由导航。

示例代码：

const UserCard = ({ user, onEdit }) => (
  <div className="user-card">
    <h2>{user.name}</h2>
    <p>{user.email}</p>
    <button onClick={onEdit}>编辑</button>
  </div>
);

容器组件（Container Component）

职责：
- 负责数据的获取和业务逻辑的处理。
- 将数据和行为传递给展示组件。
特点：
- 通常包含状态管理和生命周期方法。
- 与Redux、MobX等状态管理库集成，或者使用React的上下文（Context）API。
- 不直接操作DOM，而是通过props将数据和回调函数传递给展示组件。
- 可能包含副作用，如数据获取、订阅或路由导航。

示例代码：

import React, { useState, useEffect } from 'react';
import { fetchUser } from './api';
import UserCard from './UserCard';

const UserContainer = () => {
  const [user, setUser] = useState(null);

  useEffect(() => {
    fetchUser().then(setUser);
  }, []);

  const handleEdit = () => {
    // 处理编辑逻辑
  };

  return (
    <div>
      {user && <UserCard user={user} onEdit={handleEdit} />}
    </div>
  );
};

总结

展示组件专注于UI的展示，接收数据和回调函数作为props，通常为纯函数组件。
容器组件负责数据的获取和业务逻辑的处理，将数据和行为传递给展示组件，通常包含状态管理和生命周期方法。

这种分离模式有助于提高代码的可维护性和可测试性，使组件更加模块化和易于复用。通过将展示逻辑和业务逻辑分开，可以使代码结构更加清晰，便于团队协作和代码管理。

7. 类组件(Class component) 和函数式组件(Functional component)的区别

在React中，组件可以分为两大类：类组件（Class Component）和函数式组件（Functional Component）。以下是它们的主要区别：

1. 定义方式

类组件：

使用ES6类语法定义。
继承自React.Component。
需要实现render方法来返回JSX。

class MyComponent extends React.Component {
  render() {
    return <div>Hello, {this.props.name}</div>;
  }
}

函数式组件：

使用JavaScript函数定义。
直接返回JSX。

const MyComponent = (props) => {
  return <div>Hello, {props.name}</div>;
}

2. 状态管理

类组件：

可以使用state来管理组件的内部状态。
通过this.state访问状态，通过this.setState更新状态。

class Counter extends React.Component {
  constructor(props) {
    super(props);
    this.state = { count: 0 };
  }

  increment = () => {
    this.setState({ count: this.state.count + 1 });
  }

  render() {
    return (
      <div>
        <p>Count: {this.state.count}</p>
        <button onClick={this.increment}>Increment</button>
      </div>
    );
  }
}

函数式组件：

使用React Hooks（如useState、useEffect等）来管理状态和生命周期。

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

  const increment = () => {
    setCount(count + 1);
  };

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

3. 生命周期方法

类组件：

支持React的生命周期方法，如componentDidMount、componentDidUpdate、componentWillUnmount等。

class MyComponent extends React.Component {
  componentDidMount() {
    console.log('Component did mount');
  }

  componentDidUpdate(prevProps, prevState) {
    console.log('Component did update');
  }

  componentWillUnmount() {
    console.log('Component will unmount');
  }

  render() {
    return <div>Hello, {this.props.name}</div>;
  }
}

函数式组件：

使用React Hooks（如useEffect）来处理生命周期逻辑。

const MyComponent = (props) => {
  useEffect(() => {
    console.log('Component did mount');

    return () => {
      console.log('Component will unmount');
    };
  }, []);

  useEffect(() => {
    console.log('Component did update');
  });

  return <div>Hello, {props.name}</div>;
}

4. 性能优化

类组件：

可以使用shouldComponentUpdate生命周期方法来优化性能。

class MyComponent extends React.Component {
  shouldComponentUpdate(nextProps, nextState) {
    return nextProps.name !== this.props.name;
  }

  render() {
    return <div>Hello, {this.props.name}</div>;
  }
}

函数式组件：

使用React.memo高阶组件来优化性能。

const MyComponent = React.memo((props) => {
  return <div>Hello, {props.name}</div>;
});

5. 上下文（Context）

类组件：

可以使用static contextType或this.context来消费上下文。

class MyComponent extends React.Component {
  static contextType = MyContext;

  render() {
    return <div>Hello, {this.context.name}</div>;
  }
}

函数式组件：

使用useContext Hook来消费上下文。

const MyComponent = () => {
  const name = useContext(MyContext);

  return <div>Hello, {name}</div>;
}

总结

类组件：
- 适合复杂的组件，需要管理状态和生命周期。
- 语法相对复杂，需要继承React.Component并实现render方法。
- 支持生命周期方法。
函数式组件：
- 适合简单的组件，主要负责UI展示。
- 语法简洁，直接返回JSX。
- 使用React Hooks来管理状态和生命周期。

通过合理选择组件类型，可以使代码更加简洁、易读和易于维护。

8. 何划分技术组件和业务组件

在React应用开发中，将组件划分为技术组件（Technical Component）和业务组件（Business Component）是一种常见的做法，有助于提高代码的可维护性和复用性。以下是它们的主要区别和划分方法：

1. 技术组件（Technical Component）

定义：
- 技术组件主要关注通用的技术功能，不涉及具体的业务逻辑。
- 这些组件通常具有较高的复用性，可以在多个项目中使用。
特点：
- 与具体业务无关，专注于解决技术问题。
- 常见的技术组件包括表单组件、模态框、按钮、输入框、表格等。
- 通常封装了一些常见的UI交互和样式。

示例：

Button：通用的按钮组件，可以接受不同的样式和点击事件。

const Button = ({ children, onClick, className }) => (
  <button className={className} onClick={onClick}>
    {children}
  </button>
);

Modal：通用的模态框组件，可以显示和隐藏内容。

const Modal = ({ isOpen, onClose, children }) => (
  <div className={`modal ${isOpen ? 'open' : ''}`}>
    <div className="modal-content">
      {children}
      <button onClick={onClose}>关闭</button>
    </div>
  </div>
);

2. 业务组件（Business Component）

定义：
- 业务组件主要关注具体的业务逻辑，解决特定业务需求。
- 这些组件通常与特定的业务场景紧密相关，复用性较低。
特点：
- 与具体业务相关，包含业务逻辑和数据处理。
- 通常包含状态管理和数据获取。
- 可能与其他业务组件或技术组件组合使用。

示例：

UserProfile：展示用户个人信息的组件，包含用户头像、姓名、邮箱等。

const UserProfile = ({ user }) => (
  <div className="user-profile">
    <img src={user.avatar} alt={user.name} />
    <h2>{user.name}</h2>
    <p>{user.email}</p>
  </div>
);

OrderSummary：展示订单摘要的组件，包含订单号、总价、商品列表等。

const OrderSummary = ({ order }) => (
  <div className="order-summary">
    <h3>订单号: {order.id}</h3>
    <p>总价: {order.total}</p>
    <ul>
      {order.items.map(item => (
        <li key={item.id}>{item.name} - {item.price}</li>
      ))}
    </ul>
  </div>
);

划分方法

功能分离：
- 技术组件：关注通用的技术功能，如表单、按钮、模态框等。
- 业务组件：关注具体的业务逻辑，如用户信息展示、订单摘要等。
复用性：
- 技术组件：具有较高的复用性，可以在多个项目中使用。
- 业务组件：复用性较低，通常与特定的业务场景紧密相关。
依赖关系：
- 技术组件：尽量减少对外部业务逻辑的依赖，保持独立性。
- 业务组件：可能依赖于其他业务组件或技术组件，组合使用以完成复杂的业务需求。
命名规范：
- 技术组件：使用通用的命名，如Button、Modal、Input等。
- 业务组件：使用与业务相关的命名，如UserProfile、OrderSummary等。

总结

技术组件专注于通用的技术功能，具有较高的复用性。
业务组件专注于具体的业务逻辑，与特定的业务场景紧密相关。

通过合理划分技术组件和业务组件，可以使代码结构更加清晰，提高代码的可维护性和复用性，便于团队协作和代码管理。

9. 什么是 React 中的上下文(Context)？它有什么作用？

什么是上下文（Context）？

React 中的上下文（Context）是一种在组件树中传递数据的方式，而无需手动将 props 逐层传递。它允许在一个组件树中共享一些全局的状态，例如当前用户的认证信息、主题配置等。

主要作用

避免 prop-drilling：
- 在大型组件树中，手动将 props 逐层传递（prop-drilling）会导致代码冗余和难以维护。使用 Context 可以避免这种情况，直接在需要的地方访问共享的数据。
全局状态管理：
- Context 提供了一种全局状态管理的机制，适用于那些需要在多个组件之间共享的状态。例如，主题切换、用户认证信息等。
简化组件通信：
- 通过 Context，父组件可以向其任意子组件传递数据，而不需要通过中间的组件。这使得组件之间的通信更加灵活和简单。

如何使用 Context？

创建 Context：
- 使用 React.createContext 方法创建一个 Context 对象。
```
const MyContext = React.createContext(defaultValue);
```

提供 Context：

使用 Context.Provider 组件将数据传递给其子组件。

<MyContext.Provider value={{ /* 数据 */ }}>
  {/* 子组件 */}
</MyContext.Provider>

消费 Context：

在需要使用 Context 的组件中，可以通过 Context.Consumer 或 useContext Hook 来访问 Context 中的数据。

// 使用 Context.Consumer
<MyContext.Consumer>
  {value => /* 使用 value */}
</MyContext.Consumer>

// 使用 useContext Hook
const value = useContext(MyContext);

示例代码

创建 Context：

const ThemeContext = React.createContext('light'); // 默认值为 'light'

提供 Context：

const App = () => {
  const [theme, setTheme] = useState('light');

  const toggleTheme = () => {
    setTheme(theme === 'light' ? 'dark' : 'light');
  };

  return (
    <ThemeContext.Provider value={{ theme, toggleTheme }}>
      <Toolbar />
    </ThemeContext.Provider>
  );
};

消费 Context：

const Toolbar = () => {
  return (
    <div>
      <ThemedButton />
    </div>
  );
};

const ThemedButton = () => {
  const { theme, toggleTheme } = useContext(ThemeContext);

  return (
    <button onClick={toggleTheme}>
      当前主题: {theme}
    </button>
  );
};

总结

上下文（Context） 是 React 中用于在组件树中传递数据的一种机制。
主要作用 包括避免 prop-drilling、提供全局状态管理和简化组件通信。
使用方法 包括创建 Context、提供 Context 和消费 Context。

通过合理使用 Context，可以有效简化组件间的通信，提高代码的可维护性和可读性。

10. React是mvvm框架吗

简短回答

React 并不是一个 MVVM（Model-View-ViewModel）框架，而是一个用于构建用户界面的库，通常被称为“V”（视图）层。

详细解释

1. React 的定位

React 是一个用于构建用户界面的 JavaScript 库，主要关注视图层（View）。
React 的核心理念是通过声明式编程来构建用户界面，使得代码更易于理解和维护。

2. MVVM 框架的特点

MVVM（Model-View-ViewModel） 是一种软件架构设计模式，常用于简化用户界面的开发。
Model：表示应用程序的数据模型。
View：表示用户界面。
ViewModel：充当 Model 和 View 之间的桥梁，负责处理业务逻辑和数据绑定。

3. React 与 MVVM 的区别

React：
- 视图层：React 主要关注视图层，通过 JSX 和组件化的方式来构建用户界面。
- 状态管理：React 本身不提供完整的状态管理解决方案，但可以通过状态提升、Context API、Redux、MobX 等第三方库来管理应用状态。
- 数据流：React 采用单向数据流（One-Way Data Flow），数据从父组件流向子组件，通过 props 传递。
MVVM 框架（如 Vue.js、Knockout.js）：
- 双向数据绑定：MVVM 框架通常支持双向数据绑定，即视图的变化会自动反映到 ViewModel，反之亦然。
- 完整的架构：MVVM 框架通常提供完整的架构，包括 Model、View 和 ViewModel，使得开发者可以更方便地管理应用的各个部分。
- 数据流：MVVM 框架支持双向数据流，数据可以在视图和 ViewModel 之间自由流动。

4. React 的生态系统

状态管理：虽然 React 本身不提供完整的状态管理解决方案，但有多种第三方库可以满足这一需求，如 Redux、MobX 等。
路由管理：React 通常与 React Router 结合使用，来管理应用的路由。
表单管理：React 有多种方式来处理表单，如受控组件和非受控组件，也可以使用 Formik 等第三方库来简化表单管理。

总结

React 是一个用于构建用户界面的库，主要关注视图层。
MVVM 框架 提供完整的架构，包括 Model、View 和 ViewModel，支持双向数据绑定。
React 通过其生态系统中的各种工具和库，可以实现类似 MVVM 框架的功能，但本质上它并不是一个 MVVM 框架。

通过理解 React 和 MVVM 框架的区别，可以帮助开发者更好地选择合适的工具和技术栈来构建应用。

11. React 如何实现 mvvm

虽然 React 本身并不是一个完整的 MVVM 框架，但可以通过一些技术和库来实现类似 MVVM 的架构。以下是一些常用的方法和步骤：

1. 理解 MVVM 架构

Model：表示应用程序的数据模型。
View：表示用户界面。
ViewModel：充当 Model 和 View 之间的桥梁，负责处理业务逻辑和数据绑定。

2. 使用 React 实现 MVVM

2.1. 使用 State 和 Props

Model：可以使用 React 的状态（State）来表示数据模型。
View：React 组件本身就是视图，通过 JSX 渲染 UI。
ViewModel：可以使用组件的逻辑部分（如 useState、useEffect 等 Hooks）来实现 ViewModel 的功能。

2.2. 使用 Context API

Context API 可以用来在组件树中传递数据，类似于 ViewModel 的角色。
通过 React.createContext 创建上下文，使用 Provider 提供数据，使用 useContext 消费数据。

2.3. 使用 Redux 或 MobX

Redux 和 MobX 是两个流行的全局状态管理库，可以用来实现 ViewModel 的功能。
Redux：通过 Reducers 和 Actions 来管理状态，使用 connect 或 useSelector、useDispatch 来连接组件和状态。
MobX：通过可观察对象（Observable）和反应器（Reactions）来管理状态，使用 observer 和 @observable、@computed 等装饰器来实现数据绑定。

示例代码

2.4. 使用 State 和 Props

// Model
const initialData = {
  name: 'John Doe',
  age: 30,
};

// ViewModel
const App = () => {
  const [data, setData] = useState(initialData);

  const handleNameChange = (e) => {
    setData({ ...data, name: e.target.value });
  };

  const handleAgeChange = (e) => {
    setData({ ...data, age: parseInt(e.target.value) });
  };

  return (
    <div>
      <UserForm data={data} onNameChange={handleNameChange} onAgeChange={handleAgeChange} />
      <UserInfo data={data} />
    </div>
  );
};

// View
const UserForm = ({ data, onNameChange, onAgeChange }) => (
  <form>
    <label>
      Name:
      <input type="text" value={data.name} onChange={onNameChange} />
    </label>
    <label>
      Age:
      <input type="number" value={data.age} onChange={onAgeChange} />
    </label>
  </form>
);

const UserInfo = ({ data }) => (
  <div>
    <p>Name: {data.name}</p>
    <p>Age: {data.age}</p>
  </div>
);

2.5. 使用 Context API

// Model
const initialData = {
  name: 'John Doe',
  age: 30,
};

// Context
const DataContext = React.createContext();

// ViewModel
const App = () => {
  const [data, setData] = useState(initialData);

  const handleNameChange = (e) => {
    setData({ ...data, name: e.target.value });
  };

  const handleAgeChange = (e) => {
    setData({ ...data, age: parseInt(e.target.value) });
  };

  return (
    <DataContext.Provider value={{ data, handleNameChange, handleAgeChange }}>
      <UserForm />
      <UserInfo />
    </DataContext.Provider>
  );
};

// View
const UserForm = () => {
  const { data, handleNameChange, handleAgeChange } = useContext(DataContext);

  return (
    <form>
      <label>
        Name:
        <input type="text" value={data.name} onChange={handleNameChange} />
      </label>
      <label>
        Age:
        <input type="number" value={data.age} onChange={handleAgeChange} />
      </label>
    </form>
  );
};

const UserInfo = () => {
  const { data } = useContext(DataContext);

  return (
    <div>
      <p>Name: {data.name}</p>
      <p>Age: {data.age}</p>
    </div>
  );
};

2.6. 使用 Redux

// Model
const initialState = {
  name: 'John Doe',
  age: 30,
};

// Redux Store
import { createStore } from 'redux';

const reducer = (state = initialState, action) => {
  switch (action.type) {
    case 'UPDATE_NAME':
      return { ...state, name: action.payload };
    case 'UPDATE_AGE':
      return { ...state, age: action.payload };
    default:
      return state;
  }
};

const store = createStore(reducer);

// ViewModel
const App = () => {
  const data = useSelector((state) => state);
  const dispatch = useDispatch();

  const handleNameChange = (e) => {
    dispatch({ type: 'UPDATE_NAME', payload: e.target.value });
  };

  const handleAgeChange = (e) => {
    dispatch({ type: 'UPDATE_AGE', payload: parseInt(e.target.value) });
  };

  return (
    <div>
      <UserForm data={data} onNameChange={handleNameChange} onAgeChange={handleAgeChange} />
      <UserInfo data={data} />
    </div>
  );
};

// View
const UserForm = ({ data, onNameChange, onAgeChange }) => (
  <form>
    <label>
      Name:
      <input type="text" value={data.name} onChange={onNameChange} />
    </label>
    <label>
      Age:
      <input type="number" value={data.age} onChange={onAgeChange} />
    </label>
  </form>
);

const UserInfo = ({ data }) => (
  <div>
    <p>Name: {data.name}</p>
    <p>Age: {data.age}</p>
  </div>
);

总结

React 本身不是 MVVM 框架，但可以通过 State、Props、Context API、Redux 或 MobX 等技术来实现类似 MVVM 的架构。
State 和 Props：适用于简单的应用，通过组件的状态和属性来管理数据和视图。
Context API：适用于中等复杂度的应用，通过上下文来传递数据。
Redux 和 MobX：适用于复杂的应用，提供强大的状态管理功能。

通过这些方法，可以在 React 中实现 MVVM 架构，从而更好地管理和组织应用的各个部分。

12. redux 主要解决什么问题及优缺点

主要解决的问题

全局状态管理：
- 问题：在大型应用中，多个组件需要共享和操作相同的数据，传统的 props 传递方式会导致 prop-drilling（props 逐层传递），使代码变得冗余和难以维护。
- 解决方案：Redux 提供了一个集中式的存储（Store），所有组件都可以从中读取状态，通过派发动作（Actions）来改变状态。
状态一致性：
- 问题：多个组件对同一状态进行修改时，容易导致状态不一致和难以调试的问题。
- 解决方案：Redux 通过单一数据源（Single Source of Truth）和纯函数（Reducers）来确保状态的一致性和可预测性。
异步操作管理：
- 问题：异步操作（如 API 请求）的管理复杂，容易导致代码难以理解和维护。
- 解决方案：Redux 提供了中间件（如 Redux Thunk、Redux Saga）来处理异步操作，使异步逻辑更加清晰和可控。

优点

单一数据源：
- 优点：整个应用的状态被存储在单一的 store 中，使得状态管理更加集中和透明，便于调试和维护。
可预测的状态管理：
- 优点：通过纯函数（Reducers）来处理状态变化，确保状态的更新是可预测的，减少了副作用的影响。
良好的开发工具支持：
- 优点：Redux 生态系统提供了丰富的开发工具，如 Redux DevTools，可以方便地查看和调试状态变化。
社区和生态：
- 优点：Redux 拥有庞大的社区和丰富的生态，提供了大量的中间件、库和最佳实践，帮助开发者解决各种问题。
可扩展性：
- 优点：Redux 设计灵活，可以通过中间件和自定义逻辑来扩展功能，适应不同规模和复杂度的应用。

缺点

学习曲线：
- 缺点：Redux 的概念和工作原理相对复杂，对于初学者来说有一定的学习曲线，需要时间来掌握。
样板代码多：
- 缺点：使用 Redux 需要编写大量的样板代码，如 actions、reducers、store 配置等，增加了代码量和复杂度。
过度工程：
- 缺点：对于小型或简单的应用，使用 Redux 可能会显得过于复杂，增加不必要的开销。
性能问题：
- 缺点：由于 Redux 采用了单一数据源和纯函数的设计，可能会导致不必要的重新渲染。虽然可以通过优化（如 reselect）来缓解，但在某些情况下仍然会影响性能。
调试难度：
- 缺点：虽然 Redux 提供了强大的调试工具，但在处理复杂的状态变化时，调试仍然可能变得困难，特别是当涉及到异步操作时。

总结

Redux 主要解决的问题包括全局状态管理、状态一致性和异步操作管理。
优点包括单一数据源、可预测的状态管理、良好的开发工具支持、社区和生态丰富以及可扩展性。
缺点包括学习曲线陡峭、样板代码多、可能过度工程、性能问题和调试难度。

通过权衡这些优缺点，开发者可以根据项目的实际需求决定是否使用 Redux。对于大型、复杂的应用，Redux 可以带来显著的好处；而对于小型、简单的应用，可能有更轻量级的替代方案。

13. React 性能优化方案，所关联周期函数

避免不必要的渲染
- React.memo (函数组件)
  - 通过 React.memo 包裹函数组件，只有当 props 发生变化时才会重新渲染。
- PureComponent (类组件)
  - 继承自 PureComponent 的组件会进行浅比较，如果 props 和 state 没有变化，则不会重新渲染。
使用 useMemo 和 useCallback
- useMemo
  - 用于缓存计算结果，避免在每次渲染时都执行昂贵的计算。
- useCallback
  - 用于缓存函数，避免因函数引用变化导致的不必要的重新渲染。
优化状态管理
- useState 和 useReducer
  - 使用 useState 和 useReducer 管理状态，确保状态更新的粒度尽可能小，减少不必要的渲染。
- useContext
  - 使用 useContext 传递状态，避免通过 props 逐层传递，减少组件树的深度。
懒加载和代码分割
- React.lazy 和 Suspense
  - 使用 React.lazy 动态导入组件，并用 Suspense 进行懒加载，减少初始加载时间。
虚拟化长列表
- react-window 或 react-virtualized
  - 使用虚拟化库处理长列表，只渲染可见区域的组件，提高性能。
优化事件处理
- 事件委托
  - 使用事件委托减少事件处理器的数量，提高性能。
- 防抖和节流
  - 对频繁触发的事件（如滚动、窗口调整大小）使用防抖和节流技术，减少不必要的处理。
避免在渲染过程中进行复杂操作
- 异步操作
  - 将复杂的计算或数据处理移到 useEffect 中，避免阻塞渲染。
优化样式和布局
- CSS-in-JS
  - 使用 CSS-in-JS 库（如 styled-components）管理样式，避免样式冲突和冗余。
- 避免布局抖动
  - 使用 position: absolute 或 transform 进行动画，避免重排和重绘。
使用 shouldComponentUpdate
- 类组件
  - 在类组件中实现 shouldComponentUpdate 方法，手动控制组件是否需要更新。
清理副作用
- useEffect 清理函数
  - 在 useEffect 中返回一个清理函数，确保在组件卸载或依赖项变化时清理副作用。

关联的生命周期函数

componentDidMount
- 用于初始化数据获取、设置定时器等操作。
componentDidUpdate
- 用于在组件更新后进行操作，如数据同步、DOM 操作等。
componentWillUnmount
- 用于清理定时器、取消网络请求等操作，防止内存泄漏。
shouldComponentUpdate
- 用于手动控制组件是否需要更新，避免不必要的渲染。

通过以上方法和生命周期函数的合理使用，可以显著提升 React 应用的性能。

14. 虚拟 DOM 的意义

虚拟 DOM（Virtual DOM）是 React 和其他现代前端框架中的一个重要概念。它通过一种轻量级的数据结构来表示实际的 DOM 结构，从而优化了浏览器的渲染性能。以下是虚拟 DOM 的主要意义：

提高渲染性能
- 批量更新：虚拟 DOM 可以批量处理多个更新操作，减少与实际 DOM 的交互次数，从而提高性能。
- 最小化 DOM 操作：通过对比虚拟 DOM 树的变化，React 只对实际发生变化的部分进行更新，减少了不必要的 DOM 操作。
跨平台支持
- 可移植性：虚拟 DOM 是一个抽象的数据结构，不依赖于具体的浏览器环境，因此可以在不同的平台上运行，如服务器端渲染（SSR）、移动应用等。
简化开发
- 声明式编程：React 通过虚拟 DOM 提供了声明式的编程模型，开发者只需要关注组件的状态变化，而不需要关心具体的 DOM 操作细节。
- 组件化开发：虚拟 DOM 支持组件化开发，使得代码更模块化、易于维护和复用。
优化用户体验
- 平滑的用户界面：通过高效的 DOM 更新机制，虚拟 DOM 可以确保用户界面的平滑性和响应性，提升用户体验。
- 减少闪烁和卡顿：虚拟 DOM 的批量更新和最小化操作可以减少页面的闪烁和卡顿现象。

虚拟 DOM 的工作原理

构建虚拟 DOM 树
- 当组件的状态或属性发生变化时，React 会根据新的状态构建一个新的虚拟 DOM 树。
差异比较（Diffing 算法）
- React 会将新的虚拟 DOM 树与旧的虚拟 DOM 树进行比较，找出其中的差异。
生成最小更新操作
- 基于差异比较的结果，React 会生成一系列最小的更新操作，这些操作仅针对实际发生变化的部分。
应用更新到实际 DOM
- 最后，React 将这些最小的更新操作应用到实际的 DOM 上，完成界面的更新。

总结

虚拟 DOM 是 React 等现代前端框架的核心机制之一，它通过高效地管理和更新 DOM，显著提升了应用的性能和用户体验。通过虚拟 DOM，开发者可以更加专注于业务逻辑的实现，而不用担心复杂的 DOM 操作带来的性能问题。

15. React DOM Diff 算法

React 的 DOM Diff 算法是其性能优化的关键之一。通过高效的算法，React 能够最小化实际 DOM 的操作，从而提高应用的性能。以下是 React DOM Diff 算法的主要内容和步骤：

1. 虚拟 DOM 的构建

虚拟 DOM 树：React 在内存中构建一个虚拟 DOM 树，这个树是一个轻量级的 JavaScript 对象，表示实际的 DOM 结构。
组件状态变化：当组件的状态或属性发生变化时，React 会根据新的状态重新构建虚拟 DOM 树。

2. 差异比较（Diffing）

树的比较：React 会对新旧两棵虚拟 DOM 树进行比较，找出其中的差异。
同层级比较：为了提高效率，React 只在同一层级的节点之间进行比较，不会跨层级比较。

3. 差异比较策略

唯一键（Key）：React 使用 key 属性来标识每个节点，确保每个节点的唯一性。这有助于 React 快速找到节点的变化。
四种基本操作：
- 插入节点：在某个位置插入新的节点。
- 删除节点：从某个位置删除节点。
- 更新节点：更新节点的属性或内容。
- 移动节点：将节点从一个位置移动到另一个位置。

4. 具体算法步骤

顶层比较：
- 从根节点开始，比较新旧两棵树的根节点。
- 如果根节点不同，直接替换整个子树。
同层级节点比较：
- 在同一层级的节点之间进行比较。
- 使用 key 属性来快速定位节点，确保比较的准确性。
最小化操作：
- 通过比较结果生成最小的操作集合。
- 这些操作包括插入、删除、更新和移动节点。
批量更新：
- React 会批量执行这些最小的操作，减少与实际 DOM 的交互次数。
- 批量更新可以显著提高性能，因为浏览器的 DOM 操作是相对昂贵的。

5. 优化策略

静态属性优化：对于静态属性（即不会改变的属性），React 会进行优化，避免不必要的比较。
组件纯度：使用 React.memo 或 PureComponent，确保组件在 props 或 state 没有变化时不会重新渲染。
细粒度状态管理：通过 useState 和 useReducer 管理状态，确保状态更新的粒度尽可能小，减少不必要的渲染。

示例

假设有一个列表组件，初始状态如下：

<ul>
  <li key="1">Item 1</li>
  <li key="2">Item 2</li>
  <li key="3">Item 3</li>
</ul>

状态变化后，新的虚拟 DOM 如下：

<ul>
  <li key="1">Item 1</li>
  <li key="4">Item 4</li>
  <li key="2">Item 2</li>
</ul>

React 的 Diff 算法会进行以下操作：

比较根节点 <ul>，发现没有变化。
比较子节点：
- key="1" 的节点没有变化。
- key="2" 的节点位置发生了变化，需要移动。
- 新增 key="4" 的节点，需要插入。
生成最小的操作集合：
- 移动 key="2" 的节点到新位置。
- 插入 key="4" 的节点。
批量执行这些操作，更新实际 DOM。

总结

React 的 DOM Diff 算法通过高效的比较和最小化操作，显著提高了应用的性能。通过使用 key 属性、批量更新和细粒度的状态管理，React 能够在复杂的 UI 更新中保持高性能。理解这些原理有助于开发者更好地优化 React 应用。

16. 关于 Fiber 架构

React Fiber 是 React 16 引入的一个全新渲染引擎，旨在解决 React 在处理复杂 UI 更新时的性能问题。Fiber 架构通过引入可中断的渲染机制，使得 React 能够更好地利用浏览器的空闲时间，从而提升应用的响应性和性能。

1. 为什么需要 Fiber 架构？

长时间任务：在 React 15 及之前版本中，React 的渲染过程是同步的，这意味着如果一个任务耗时过长，会导致浏览器无法响应用户的其他操作，造成卡顿。
优先级调度：传统的渲染机制无法区分不同任务的优先级，所有任务都会按顺序执行，无法动态调整。

2. Fiber 架构的核心概念

Fiber 节点：Fiber 架构中的每个节点称为一个 Fiber 节点，它是一个 JavaScript 对象，包含当前组件的所有信息，如状态、属性、子节点等。
Fiber 树：所有 Fiber 节点连接起来形成一棵 Fiber 树，这棵树表示了组件的层次结构。
工作单元：每个 Fiber 节点代表一个工作单元，React 可以在这些工作单元之间切换，从而实现任务的可中断和恢复。

3. Fiber 架构的工作流程

初始化：
- 当应用启动时，React 会构建初始的 Fiber 树，表示应用的初始状态。
调度：
- 当组件的状态或属性发生变化时，React 会创建一个新的 Fiber 树（称为“工作 Fiber 树”），并开始执行渲染任务。
- React 会根据任务的优先级进行调度，高优先级的任务会优先执行。
可中断的渲染：
- React 会在每个工作单元之间检查是否有更高优先级的任务需要处理。
- 如果有更高优先级的任务，React 会暂停当前任务，处理高优先级任务。
- 处理完高优先级任务后，React 会恢复之前的任务，继续执行。
提交：
- 当工作 Fiber 树构建完成后，React 会将新的 Fiber 树提交到实际的 DOM 中，完成界面的更新。

4. Fiber 架构的优势

可中断的渲染：通过可中断的渲染机制，React 可以在浏览器的空闲时间内执行任务，避免长时间阻塞主线程。
优先级调度：React 可以根据任务的优先级动态调整任务的执行顺序，确保高优先级的任务优先完成。
更好的性能：通过优化渲染过程，React 能够在处理复杂 UI 更新时保持高性能，提升应用的响应性。

5. 实际应用场景

长列表渲染：在渲染长列表时，Fiber 架构可以分批处理列表项，避免一次性渲染大量数据导致的卡顿。
动画和交互：在处理动画和用户交互时，Fiber 架构可以确保高优先级的任务（如动画帧的更新）优先执行，保证流畅的用户体验。
服务器渲染：在服务器渲染（SSR）中，Fiber 架构可以优化渲染过程，提高服务器的响应速度。

总结

React Fiber 架构通过引入可中断的渲染机制和优先级调度，显著提升了 React 应用的性能和响应性。理解 Fiber 架构的原理和工作机制，有助于开发者更好地优化 React 应用，特别是在处理复杂 UI 更新和高优先级任务时。

17. 关于 Flux

Flux 是 Facebook 推出的一种应用架构模式，主要用于管理 React 应用中的数据流。Flux 强调单向数据流，使得应用的状态管理更加清晰和可预测。以下是关于 Flux 的详细介绍：

1. Flux 的核心概念

Store：存储应用的状态。每个 Store 管理特定类型的业务逻辑和数据。
Action：描述发生的具体事件，通常是一个简单的对象，包含类型和数据。
Dispatcher：中央枢纽，负责将 Action 分发到各个 Store。
View（组件）：React 组件，负责展示数据和触发 Action。

2. Flux 的工作流程

用户交互：
- 用户与应用交互，触发某个事件（如点击按钮）。
创建 Action：
- 视图组件调用 Action Creator 创建一个 Action。Action 是一个普通的 JavaScript 对象，包含类型和数据。
分发 Action：
- Action 通过 Dispatcher 分发到各个 Store。Dispatcher 是一个全局的单例对象，负责管理和调度 Action。
Store 更新：
- Store 接收到 Action 后，根据 Action 的类型和数据更新自身的状态。
- Store 通常会注册到 Dispatcher，监听特定类型的 Action。
视图更新：
- Store 更新状态后，会通知相关的视图组件。
- 视图组件通过订阅 Store 的变化，重新渲染自身，展示最新的数据。

3. Flux 的优点

单向数据流：数据只能从一个方向流动，从 View 到 Action，再到 Store，最后回到 View。这种单向数据流使得应用的状态管理更加清晰和可预测。
可维护性：由于数据流是单向的，调试和维护变得更加容易。可以很容易地追踪数据的变化和状态的更新。
模块化：Store 和 Action 可以独立开发和测试，提高了代码的模块化和可重用性。

4. Flux 的缺点

复杂性：对于小型项目，Flux 的架构可能显得过于复杂，增加了学习和开发的成本。
冗余代码：需要编写大量的 Action 和 Store，可能会增加代码的冗余性。
性能问题：在某些情况下，频繁的 Store 更新和视图重新渲染可能会导致性能问题。

5. Flux 的变种

Redux：Redux 是 Flux 架构的一个流行变种，简化了 Flux 的复杂性，通过单一的全局状态树和纯函数 Reducer 来管理状态。
MobX：MobX 是另一种状态管理库，采用响应式编程的思想，通过观察者模式自动管理状态的变化。

6. 示例

以下是一个简单的 Flux 架构示例：

1. 定义 Action 类型

const ADD_TODO = 'ADD_TODO';

2. 创建 Action Creator

function addTodo(text) {
  return {
    type: ADD_TODO,
    text
  };
}

3. 创建 Dispatcher

import { Dispatcher } from 'flux';

const dispatcher = new Dispatcher();

4. 创建 Store

class TodoStore {
  constructor() {
    this.todos = [];
    this.registerToActions();
  }

  registerToActions() {
    dispatcher.register((action) => {
      switch (action.type) {
        case ADD_TODO:
          this.todos.push({ id: Date.now(), text: action.text });
          this.emitChange();
          break;
        default:
          // do nothing
      }
    });
  }

  emitChange() {
    // 通知视图组件更新
  }

  getTodos() {
    return this.todos;
  }
}

const todoStore = new TodoStore();

5. 视图组件

import React, { useState, useEffect } from 'react';
import { addTodo } from './actions';
import { dispatcher, todoStore } from './stores';

function TodoApp() {
  const [todos, setTodos] = useState([]);
  const [text, setText] = useState('');

  useEffect(() => {
    function onChange() {
      setTodos(todoStore.getTodos());
    }

    todoStore.emitChange = onChange;
    onChange();

    return () => {
      todoStore.emitChange = null;
    };
  }, []);

  const handleSubmit = (e) => {
    e.preventDefault();
    dispatcher.dispatch(addTodo(text));
    setText('');
  };

  return (
    <div>
      <form onSubmit={handleSubmit}>
        <input value={text} onChange={(e) => setText(e.target.value)} />
        <button type="submit">Add Todo</button>
      </form>
      <ul>
        {todos.map((todo) => (
          <li key={todo.id}>{todo.text}</li>
        ))}
      </ul>
    </div>
  );
}

export default TodoApp;

总结

Flux 是一种强大的应用架构模式，通过单向数据流和模块化的设计，使得应用的状态管理更加清晰和可维护。虽然 Flux 有一定的复杂性，但对于大型和复杂的 React 应用，它仍然是一个非常有效的解决方案。了解 Flux 的原理和工作机制，有助于开发者更好地设计和优化应用。

18. React 项目脚手架

React 项目脚手架是一种工具，帮助开发者快速搭建和配置 React 应用的基础结构。最常用的 React 项目脚手架是 Create React App (CRA)，它是由 Facebook 开发并维护的，提供了开箱即用的开发环境和最佳实践。以下是关于 React 项目脚手架的详细介绍：

1. Create React App (CRA)

Create React App (CRA) 是最流行的 React 项目脚手架，它简化了项目的初始化过程，提供了丰富的功能和配置选项。

1.1 安装 CRA

npx create-react-app my-app
cd my-app
npm start

1.2 目录结构

CRA 生成的项目目录结构如下：

my-app/
├── node_modules/
├── public/
│   ├── index.html
│   └── favicon.ico
├── src/
│   ├── App.css
│   ├── App.js
│   ├── App.test.js
│   ├── index.css
│   ├── index.js
│   ├── logo.svg
│   └── serviceWorker.js
├── .gitignore
├── package.json
├── README.md
└── yarn.lock

public/：包含公共文件，如 HTML 模板和图标。
src/：包含源代码文件，如组件、样式和测试文件。
node_modules/：包含项目依赖的 npm 包。
package.json：定义项目依赖和脚本。
.gitignore：定义 Git 忽略的文件和目录。
README.md：项目说明文件。
yarn.lock：Yarn 锁定文件，确保依赖的一致性。

1.3 主要文件

index.html：HTML 模板文件，包含应用的入口点。
index.js：应用的入口文件，负责渲染根组件。
App.js：主组件文件，包含应用的主要逻辑。
App.css：主组件的样式文件。
App.test.js：主组件的测试文件。
serviceWorker.js：服务工作者文件，用于离线支持和性能优化。

1.4 常用命令

npm start：启动开发服务器，自动打开浏览器并热重载。
npm run build：构建生产环境的优化版本。
npm test：运行测试用例。
npm run eject：暴露所有配置文件，允许自定义配置（不可逆操作）。

2. 其他 React 项目脚手架

除了 Create React App，还有一些其他流行的 React 项目脚手架：

2.1 Next.js

Next.js 是一个用于构建服务端渲染（SSR）和静态生成（SSG）应用的 React 框架。

安装：

npx create-next-app my-app
cd my-app
npm run dev

特点：
- 自动代码分割
- 服务端渲染和静态生成
- API 路由
- 内置 CSS 支持

2.2 Gatsby

Gatsby 是一个基于 React 的静态站点生成器，适合构建博客、文档网站等。

安装：

npx gatsby-cli new my-site
cd my-site
npm run develop

特点：
- 静态生成
- GraphQL 数据层
- 内置性能优化
- 丰富的插件生态系统

2.3 Razzle

Razzle 是一个用于构建通用 React 应用的脚手架，支持服务端渲染（SSR）。

安装：

npx create-razzle-app my-app
cd my-app
npm start

特点：
- 服务端渲染
- 自动代码分割
- 热重载

3. 自定义脚手架

如果现有的脚手架不能满足需求，可以考虑自定义脚手架。自定义脚手架通常涉及以下几个步骤：

初始化项目：

mkdir my-custom-app
cd my-custom-app
npm init -y

安装依赖：

npm install react react-dom webpack webpack-cli babel-loader @babel/core @babel/preset-env @babel/preset-react

配置 Webpack：

创建 webpack.config.js 文件：

const path = require('path');

module.exports = {
  entry: './src/index.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader'
        }
      }
    ]
  },
  resolve: {
    extensions: ['.js', '.jsx']
  },
  devServer: {
    contentBase: path.join(__dirname, 'dist'),
    hot: true
  }
};

配置 Babel：

创建 .babelrc 文件：

{
  "presets": ["@babel/preset-env", "@babel/preset-react"]
}

创建基本文件结构：

mkdir src
touch src/index.js src/App.js public/index.html

编写基本代码：

public/index.html：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>My Custom App</title>
</head>
<body>
  <div id="root"></div>
  <script src="/bundle.js"></script>
</body>
</html>

src/index.js：

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';

ReactDOM.render(<App />, document.getElementById('root'));

src/App.js：

import React from 'react';

function App() {
  return (
    <div>
      <h1>Hello, World!</h1>
    </div>
  );
}

export default App;

添加脚本：

修改 package.json 文件，添加启动和构建脚本：

{
  "scripts": {
    "start": "webpack serve --mode development",
    "build": "webpack --mode production"
  }
}

启动项目：
```
npm start
```

总结

React 项目脚手架为开发者提供了便捷的工具，帮助快速搭建和配置 React 应用。Create React App 是最常用的选择，适用于大多数场景。对于特定需求，还可以选择其他框架如 Next.js、Gatsby 或自定义脚手架。理解这些工具的原理和使用方法，有助于开发者更高效地开发高质量的 React 应用。

19. React 组件可请求数据生命周期钩子

在 React 中，组件的生命周期钩子是管理组件行为的重要工具。特别是当组件需要在特定时刻请求数据时，选择合适的生命周期钩子至关重要。以下是一些常用的生命周期钩子及其在数据请求中的应用：

1. 类组件中的生命周期钩子

在类组件中，常用的生命周期钩子包括 componentDidMount、componentDidUpdate 和 componentWillUnmount。

1.1 `componentDidMount`

用途：组件挂载后立即调用，通常用于发起初始数据请求。

示例：

import React, { Component } from 'react';
import axios from 'axios';

class MyComponent extends Component {
  state = {
    data: null,
    loading: true,
    error: null
  };

  componentDidMount() {
    this.fetchData();
  }

  fetchData = async () => {
    try {
      const response = await axios.get('https://api.example.com/data');
      this.setState({ data: response.data, loading: false });
    } catch (error) {
      this.setState({ error, loading: false });
    }
  };

  render() {
    const { data, loading, error } = this.state;

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

    return (
      <div>
        <h1>Data</h1>
        <pre>{JSON.stringify(data, null, 2)}</pre>
      </div>
    );
  }
}

export default MyComponent;

1.2 `componentDidUpdate`

用途：组件更新后调用，通常用于在组件接收到新 props 时重新请求数据。

示例：

import React, { Component } from 'react';
import axios from 'axios';

class MyComponent extends Component {
  state = {
    data: null,
    loading: true,
    error: null
  };

  componentDidMount() {
    this.fetchData(this.props.id);
  }

  componentDidUpdate(prevProps) {
    if (this.props.id !== prevProps.id) {
      this.fetchData(this.props.id);
    }
  }

  fetchData = async (id) => {
    try {
      const response = await axios.get(`https://api.example.com/data/${id}`);
      this.setState({ data: response.data, loading: false });
    } catch (error) {
      this.setState({ error, loading: false });
    }
  };

  render() {
    const { data, loading, error } = this.state;

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

    return (
      <div>
        <h1>Data</h1>
        <pre>{JSON.stringify(data, null, 2)}</pre>
      </div>
    );
  }
}

export default MyComponent;

1.3 `componentWillUnmount`

用途：组件卸载前调用，通常用于清理定时器、取消网络请求等。

示例：

import React, { Component } from 'react';
import axios from 'axios';

class MyComponent extends Component {
  state = {
    data: null,
    loading: true,
    error: null
  };

  componentDidMount() {
    this.fetchData();
  }

  componentWillUnmount() {
    if (this.cancelToken) {
      this.cancelToken.cancel('Component unmounted');
    }
  }

  fetchData = async () => {
    const source = axios.CancelToken.source();
    this.cancelToken = source;

    try {
      const response = await axios.get('https://api.example.com/data', {
        cancelToken: source.token
      });
      this.setState({ data: response.data, loading: false });
    } catch (error) {
      if (axios.isCancel(error)) {
        console.log('Request canceled:', error.message);
      } else {
        this.setState({ error, loading: false });
      }
    }
  };

  render() {
    const { data, loading, error } = this.state;

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

    return (
      <div>
        <h1>Data</h1>
        <pre>{JSON.stringify(data, null, 2)}</pre>
      </div>
    );
  }
}

export default MyComponent;

2. 函数组件中的生命周期钩子

在函数组件中，可以使用 useEffect 钩子来管理数据请求。

2.1 `useEffect` 用于初始数据请求

用途：组件挂载后立即调用，通常用于发起初始数据请求。

示例：

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

const MyComponent = () => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await axios.get('https://api.example.com/data');
        setData(response.data);
      } catch (error) {
        setError(error);
      } finally {
        setLoading(false);
      }
    };

    fetchData();
  }, []);

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

  return (
    <div>
      <h1>Data</h1>
      <pre>{JSON.stringify(data, null, 2)}</pre>
    </div>
  );
};

export default MyComponent;

2.2 `useEffect` 用于依赖变化时的数据请求

用途：组件更新后调用，通常用于在组件接收到新 props 时重新请求数据。

示例：

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

const MyComponent = ({ id }) => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await axios.get(`https://api.example.com/data/${id}`);
        setData(response.data);
      } catch (error) {
        setError(error);
      } finally {
        setLoading(false);
      }
    };

    fetchData();
  }, [id]);

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

  return (
    <div>
      <h1>Data</h1>
      <pre>{JSON.stringify(data, null, 2)}</pre>
    </div>
  );
};

export default MyComponent;

2.3 `useEffect` 用于清理操作

用途：组件卸载前调用，通常用于清理定时器、取消网络请求等。

示例：

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

const MyComponent = () => {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;

    const fetchData = async () => {
      try {
        const response = await axios.get('https://api.example.com/data');
        if (isMounted) {
          setData(response.data);
        }
      } catch (error) {
        if (isMounted) {
          setError(error);
        }
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    };

    fetchData();

    return () => {
      isMounted = false;
    };
  }, []);

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

  return (
    <div>
      <h1>Data</h1>
      <pre>{JSON.stringify(data, null, 2)}</pre>
    </div>
  );
};

export default MyComponent;

总结

在 React 中，选择合适的生命周期钩子或 useEffect 钩子来管理数据请求是非常重要的。类组件中的 componentDidMount、componentDidUpdate 和 componentWillUnmount 以及函数组件中的 useEffect 都是常用的方法。通过合理使用这些钩子，可以确保数据请求在正确的时间点进行，并且能够有效地管理组件的生命周期。

20. refs 的作用

在 React 中，refs（引用）是一种访问 DOM 节点或在 React 元素上存储对特定实例的引用的方式。refs 提供了一种在 React 的声明式编程模型中执行命令式操作的方法。以下是 refs 的主要作用和使用场景：

1. 访问 DOM 节点

refs 可以直接访问 DOM 节点，这对于一些需要直接操作 DOM 的场景非常有用，例如聚焦输入框、播放视频等。

1.1 创建和使用 `ref`

在类组件中使用 ref：

import React, { Component } from 'react';

class MyComponent extends Component {
  inputRef = React.createRef();

  focusInput = () => {
    this.inputRef.current.focus();
  };

  render() {
    return (
      <div>
        <input type="text" ref={this.inputRef} />
        <button onClick={this.focusInput}>Focus Input</button>
      </div>
    );
  }
}

export default MyComponent;

在函数组件中使用 ref：

import React, { useRef } from 'react';

const MyComponent = () => {
  const inputRef = useRef(null);

  const focusInput = () => {
    inputRef.current.focus();
  };

  return (
    <div>
      <input type="text" ref={inputRef} />
      <button onClick={focusInput}>Focus Input</button>
    </div>
  );
};

export default MyComponent;

2. 访问子组件实例

refs 还可以用来访问子组件的实例，从而调用子组件的方法或访问其状态。

2.1 在类组件中使用 `ref` 访问子组件

子组件：

import React, { Component } from 'react';

class ChildComponent extends Component {
  showAlert = () => {
    alert('Hello from ChildComponent!');
  };

  render() {
    return <div>Child Component</div>;
  }
}

export default ChildComponent;

父组件：

import React, { Component } from 'react';
import ChildComponent from './ChildComponent';

class ParentComponent extends Component {
  childRef = React.createRef();

  callChildMethod = () => {
    this.childRef.current.showAlert();
  };

  render() {
    return (
      <div>
        <ChildComponent ref={this.childRef} />
        <button onClick={this.callChildMethod}>Call Child Method</button>
      </div>
    );
  }
}

export default ParentComponent;

2.2 在函数组件中使用 `ref` 访问子组件

子组件：

import React from 'react';

const ChildComponent = React.forwardRef((props, ref) => {
  React.useImperativeHandle(ref, () => ({
    showAlert: () => {
      alert('Hello from ChildComponent!');
    }
  }));

  return <div>Child Component</div>;
});

export default ChildComponent;

父组件：

import React, { useRef } from 'react';
import ChildComponent from './ChildComponent';

const ParentComponent = () => {
  const childRef = useRef(null);

  const callChildMethod = () => {
    childRef.current.showAlert();
  };

  return (
    <div>
      <ChildComponent ref={childRef} />
      <button onClick={callChildMethod}>Call Child Method</button>
    </div>
  );
};

export default ParentComponent;

3. 管理动画

refs 可以用于管理动画，特别是在需要精确控制动画效果的情况下。

3.1 使用 `ref` 管理动画

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

const AnimationComponent = () => {
  const boxRef = useRef(null);

  useEffect(() => {
    const animate = () => {
      const box = boxRef.current;
      let position = 0;
      const intervalId = setInterval(() => {
        position += 1;
        box.style.transform = `translateX(${position}px)`;
        if (position >= 200) {
          clearInterval(intervalId);
        }
      }, 10);
    };

    animate();
  }, []);

  return <div ref={boxRef} style={{ width: '50px', height: '50px', backgroundColor: 'red' }}></div>;
};

export default AnimationComponent;

4. 管理表单

refs 可以用于管理表单，特别是在需要手动控制表单元素的情况下。

4.1 使用 `ref` 管理表单

import React, { useRef } from 'react';

const FormComponent = () => {
  const formRef = useRef(null);

  const handleSubmit = (event) => {
    event.preventDefault();
    const formData = new FormData(formRef.current);
    console.log(Object.fromEntries(formData.entries()));
  };

  return (
    <form ref={formRef} onSubmit={handleSubmit}>
      <label>
        Name:
        <input type="text" name="name" />
      </label>
      <br />
      <label>
        Email:
        <input type="email" name="email" />
      </label>
      <br />
      <button type="submit">Submit</button>
    </form>
  );
};

export default FormComponent;

总结

refs 在 React 中主要用于访问 DOM 节点、子组件实例、管理动画和表单。通过合理使用 refs，可以在需要时执行命令式操作，增强组件的功能和灵活性。然而，应尽量避免过度使用 refs，因为它们可能会破坏 React 的声明式编程模型，导致代码难以维护。

21. key 在渲染列表时的作用

在 React 中，key 是一个特殊的字符串属性，用于在渲染列表时帮助 React 识别哪些元素发生了变化、添加或删除。合理使用 key 可以提高性能并确保组件的状态一致性。以下是 key 的主要作用和使用场景：

1. 唯一标识每个列表项

key 的主要作用是为每个列表项提供一个唯一的标识符。这有助于 React 在更新列表时高效地识别和操作 DOM 节点。

1.1 示例

假设我们有一个列表，需要根据数据动态渲染：

import React from 'react';

const ListComponent = ({ items }) => {
  return (
    <ul>
      {items.map(item => (
        <li key={item.id}>{item.name}</li>
      ))}
    </ul>
  );
};

const App = () => {
  const items = [
    { id: 1, name: 'Apple' },
    { id: 2, name: 'Banana' },
    { id: 3, name: 'Cherry' }
  ];

  return <ListComponent items={items} />;
};

export default App;

在这个例子中，key 被设置为每个 item 的 id，这样 React 就可以唯一地标识每个列表项。

2. 提高性能

通过使用 key，React 可以更高效地更新和重渲染列表。当列表发生变化时，React 会根据 key 来判断哪些元素需要更新、添加或删除，而不是简单地重新渲染整个列表。

2.1 没有 `key` 的情况

如果没有 key，React 会按照顺序比较列表中的元素，这可能导致不必要的重新渲染和性能问题。

const ListComponent = ({ items }) => {
  return (
    <ul>
      {items.map(item => (
        <li>{item.name}</li>
      ))}
    </ul>
  );
};

在这种情况下，如果列表中的某个元素被删除或添加，React 可能会重新渲染整个列表，即使其他元素没有变化。

3. 保持状态的一致性

key 还有助于保持组件状态的一致性。当列表项的 key 发生变化时，React 会认为这是一个新的元素，从而重新初始化其状态。相反，如果 key 保持不变，React 会保留其状态。

3.1 示例

假设我们有一个计数器列表，每个计数器都有自己的状态：

import React, { useState } from 'react';

const Counter = ({ id }) => {
  const [count, setCount] = useState(0);

  const increment = () => {
    setCount(count + 1);
  };

  return (
    <div>
      <p>Counter {id}: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
};

const CounterList = ({ counters }) => {
  return (
    <div>
      {counters.map(counter => (
        <Counter key={counter.id} id={counter.id} />
      ))}
    </div>
  );
};

const App = () => {
  const [counters, setCounters] = useState([
    { id: 1 },
    { id: 2 },
    { id: 3 }
  ]);

  const addCounter = () => {
    setCounters([...counters, { id: counters.length + 1 }]);
  };

  return (
    <div>
      <CounterList counters={counters} />
      <button onClick={addCounter}>Add Counter</button>
    </div>
  );
};

export default App;

在这个例子中，每个 Counter 组件都有一个唯一的 key，这样即使添加新的计数器，现有的计数器状态也不会受到影响。

4. 注意事项

唯一性：key 应该在当前兄弟节点中是唯一的，但在整个应用中不需要是唯一的。
稳定性：key 应该是稳定的，避免使用数组索引作为 key，因为当列表项发生增删时，索引会发生变化，导致不必要的重新渲染。
性能：合理使用 key 可以显著提高性能，尤其是在大型列表中。

总结

key 在 React 渲染列表时起着至关重要的作用。它不仅帮助 React 高效地识别和操作列表项，还能保持组件状态的一致性。合理使用 key 可以提高应用的性能和用户体验。

22. 如何使用 useState Hook 来管理状态

useState 是 React 中的一个 Hook，用于在函数组件中添加状态管理功能。通过 useState，你可以声明一个状态变量，并提供一个更新该状态的方法。以下是 useState 的基本用法和一些示例。

1. 基本用法

useState 的基本语法如下：

const [state, setState] = useState(initialState);

state：当前状态的值。
setState：更新状态的函数。
initialState：状态的初始值。

2. 示例

2.1 基本示例

下面是一个简单的计数器组件，展示了如何使用 useState 来管理状态：

import React, { useState } from 'react';

const Counter = () => {
  // 声明一个名为 count 的状态变量，初始值为 0
  const [count, setCount] = useState(0);

  // 增加计数器的值
  const increment = () => {
    setCount(count + 1);
  };

  // 减少计数器的值
  const decrement = () => {
    setCount(count - 1);
  };

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

export default Counter;

在这个示例中，count 是状态变量，setCount 是更新状态的函数。通过点击按钮，可以增加或减少 count 的值。

2.2 复杂状态对象

useState 也可以用于管理复杂的状态对象。例如，一个表单组件可能需要管理多个字段的状态：

import React, { useState } from 'react';

const LoginForm = () => {
  // 声明一个名为 formData 的状态对象，初始值为空对象
  const [formData, setFormData] = useState({
    username: '',
    password: ''
  });

  // 处理输入变化
  const handleChange = (e) => {
    const { name, value } = e.target;
    setFormData((prevData) => ({
      ...prevData,
      [name]: value
    }));
  };

  // 提交表单
  const handleSubmit = (e) => {
    e.preventDefault();
    console.log('Form Data:', formData);
  };

  return (
    <form onSubmit={handleSubmit}>
      <div>
        <label>
          Username:
          <input
            type="text"
            name="username"
            value={formData.username}
            onChange={handleChange}
          />
        </label>
      </div>
      <div>
        <label>
          Password:
          <input
            type="password"
            name="password"
            value={formData.password}
            onChange={handleChange}
          />
        </label>
      </div>
      <button type="submit">Login</button>
    </form>
  );
};

export default LoginForm;

在这个示例中，formData 是一个包含 username 和 password 的对象。handleChange 函数用于处理输入变化，并更新 formData 的相应字段。

3. 注意事项

初始状态：useState 的初始值可以是任何类型，包括对象和数组。
状态更新：setState 是异步的，这意味着状态更新不会立即反映在当前渲染中。如果你需要在状态更新后执行某些操作，可以使用 useEffect。
函数形式的 setState：如果新的状态依赖于前一个状态，可以传递一个函数给 setState，该函数接收前一个状态作为参数并返回新的状态。

3.1 函数形式的 `setState`

import React, { useState } from 'react';

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

  const increment = () => {
    setCount((prevCount) => prevCount + 1);
  };

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

export default Counter;

在这个示例中，setCount 接收一个函数，该函数返回新的状态值。这种方式适用于状态更新依赖于前一个状态的情况。

总结

useState 是 React 中用于在函数组件中管理状态的基本 Hook。通过声明状态变量和更新状态的函数，你可以轻松地在函数组件中实现状态管理。合理使用 useState 可以使你的组件更加灵活和可维护。

23. 如何使用 useEffect Hook 执行副作用操作

useEffect 是 React 中的一个 Hook，用于在函数组件中执行副作用操作，如数据获取、订阅或手动更改 DOM。useEffect 类似于类组件中的 componentDidMount、componentDidUpdate 和 componentWillUnmount 生命周期方法。以下是 useEffect 的基本用法和一些示例。

1. 基本用法

useEffect 的基本语法如下：

useEffect(() => {
  // 副作用操作
  return () => {
    // 清理操作（可选）
  };
}, [dependencies]);

副作用操作：在函数中执行的副作用操作，如数据获取、订阅等。
清理操作：可选的返回函数，用于在组件卸载或依赖项变化时执行清理操作。
依赖项数组：指定依赖项，当这些依赖项发生变化时，useEffect 会重新执行。

2. 示例

2.1 数据获取

下面是一个简单的示例，展示如何使用 useEffect 获取数据：

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

const FetchData = () => {
  const [data, setData] = useState([]);

  useEffect(() => {
    // 数据获取
    fetch('https://api.example.com/data')
      .then((response) => response.json())
      .then((json) => setData(json))
      .catch((error) => console.error('Error fetching data:', error));
  }, []); // 依赖项数组为空，表示只在组件挂载时执行一次

  return (
    <div>
      <h1>Data</h1>
      <ul>
        {data.map((item) => (
          <li key={item.id}>{item.name}</li>
        ))}
      </ul>
    </div>
  );
};

export default FetchData;

在这个示例中，useEffect 在组件挂载时执行一次数据获取操作，并将获取到的数据设置到状态变量 data 中。

2.2 订阅事件

下面是一个示例，展示如何使用 useEffect 订阅和取消订阅事件：

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

const EventListener = () => {
  const [count, setCount] = useState(0);

  useEffect(() => {
    // 订阅事件
    const handleScroll = () => {
      setCount((prevCount) => prevCount + 1);
    };

    window.addEventListener('scroll', handleScroll);

    // 清理操作
    return () => {
      window.removeEventListener('scroll', handleScroll);
    };
  }, []); // 依赖项数组为空，表示只在组件挂载时执行一次

  return (
    <div>
      <h1>Scroll Count: {count}</h1>
    </div>
  );
};

export default EventListener;

在这个示例中，useEffect 在组件挂载时订阅滚动事件，并在组件卸载时取消订阅。

2.3 依赖项变化时执行

下面是一个示例，展示如何在依赖项变化时执行 useEffect：

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

const Counter = () => {
  const [count, setCount] = useState(0);
  const [text, setText] = useState('');

  useEffect(() => {
    // 当 count 变化时执行
    document.title = `You clicked ${count} times`;
  }, [count]); // 依赖项数组包含 count，表示当 count 变化时重新执行

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
      <input
        type="text"
        value={text}
        onChange={(e) => setText(e.target.value)}
      />
    </div>
  );
};

export default Counter;

在这个示例中，useEffect 在 count 变化时更新文档标题。

3. 注意事项

依赖项数组：依赖项数组决定了 useEffect 何时重新执行。如果依赖项数组为空，useEffect 只在组件挂载时执行一次。如果依赖项数组包含某些状态或属性，useEffect 会在这些依赖项变化时重新执行。
清理操作：如果 useEffect 返回一个函数，该函数将在组件卸载或依赖项变化时执行，用于执行清理操作。
性能优化：合理使用依赖项数组可以避免不必要的副作用操作，提高性能。

总结

useEffect 是 React 中用于在函数组件中执行副作用操作的强大工具。通过合理使用 useEffect，你可以轻松地处理数据获取、订阅事件、手动更改 DOM 等操作。理解 useEffect 的工作原理和注意事项，可以帮助你编写更高效和可维护的 React 组件。

24. 如何使用自定义Hook来共享逻辑

自定义 Hook 是 React 中的一种机制，用于在不同的组件之间共享逻辑。通过自定义 Hook，你可以提取和重用复杂的逻辑，使代码更加模块化和可维护。以下是自定义 Hook 的基本用法和一些示例。

1. 基本概念

自定义 Hook 是一个以 use 开头的函数，内部可以调用其他 Hooks，如 useState、useEffect 等。自定义 Hook 的名称通常以 use 开头，以便与普通函数区分开来。

2. 创建自定义 Hook

2.1 示例：共享状态管理逻辑

假设你有一个常见的需求，需要在多个组件中管理一个计数器的状态。你可以创建一个自定义 Hook 来封装这个逻辑。

import { useState, useEffect } from 'react';

// 自定义 Hook
function useCounter(initialValue = 0) {
  const [count, setCount] = useState(initialValue);

  const increment = () => {
    setCount((prevCount) => prevCount + 1);
  };

  const decrement = () => {
    setCount((prevCount) => prevCount - 1);
  };

  useEffect(() => {
    console.log(`Count is now: ${count}`);
  }, [count]);

  return { count, increment, decrement };
}

// 使用自定义 Hook 的组件
const Counter = () => {
  const { count, increment, decrement } = useCounter(0);

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

export default Counter;

在这个示例中，useCounter 是一个自定义 Hook，封装了计数器的状态管理和相关操作。Counter 组件通过调用 useCounter 来使用这些逻辑。

2.2 示例：共享数据获取逻辑

假设你需要在多个组件中获取和显示数据，可以创建一个自定义 Hook 来封装数据获取逻辑。

import { useState, useEffect } from 'react';

// 自定义 Hook
function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await fetch(url);
        if (!response.ok) {
          throw new Error('Network response was not ok');
        }
        const json = await response.json();
        setData(json);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };

    fetchData();
  }, [url]);

  return { data, loading, error };
}

// 使用自定义 Hook 的组件
const DataDisplay = () => {
  const { data, loading, error } = useFetch('https://api.example.com/data');

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {error}</p>;

  return (
    <div>
      <h1>Data</h1>
      <ul>
        {data.map((item) => (
          <li key={item.id}>{item.name}</li>
        ))}
      </ul>
    </div>
  );
};

export default DataDisplay;

在这个示例中，useFetch 是一个自定义 Hook，封装了数据获取的逻辑。DataDisplay 组件通过调用 useFetch 来获取和显示数据。

3. 注意事项

命名规范：自定义 Hook 的名称应以 use 开头，以便与其他函数区分开来。
依赖项：在 useEffect 或其他 Hooks 中使用依赖项数组，确保 Hook 在适当的时机重新执行。
逻辑分离：将复杂的逻辑拆分成多个自定义 Hook，每个 Hook 负责一个特定的功能，使代码更加模块化和可维护。
规则遵循：确保自定义 Hook 内部遵循 React Hooks 的规则，如只能在最顶层调用 Hooks，不能在循环、条件判断或嵌套函数中调用 Hooks。

总结

自定义 Hook 是 React 中一种强大的机制，用于在不同组件之间共享逻辑。通过创建自定义 Hook，你可以封装复杂的逻辑，使其在多个组件中重用，从而提高代码的可维护性和复用性。理解自定义 Hook 的基本用法和注意事项，可以帮助你更好地组织和管理 React 应用中的逻辑。

25. react中useMemo的原理是什么，底层怎么实现的

useMemo 是 React 提供的一个 Hook，用于优化性能，避免在每次渲染时都进行昂贵的计算。通过 useMemo，你可以在依赖项没有变化时缓存计算结果，从而减少不必要的计算。

1. `useMemo` 的基本用法

useMemo 的基本语法如下：

const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

计算函数：第一个参数是一个函数，用于执行昂贵的计算。
依赖项数组：第二个参数是一个数组，包含所有依赖项。当这些依赖项发生变化时，useMemo 会重新执行计算函数。

2. `useMemo` 的原理

useMemo 的原理可以分为以下几个步骤：

初始化：在组件首次渲染时，useMemo 会执行传入的计算函数，并缓存结果。
依赖项检查：在后续渲染时，useMemo 会检查依赖项数组中的值是否发生变化。
缓存命中：如果依赖项没有变化，useMemo 会直接返回上次缓存的结果，而不是重新执行计算函数。
重新计算：如果依赖项发生变化，useMemo 会重新执行计算函数，并更新缓存结果。

3. `useMemo` 的底层实现

为了更好地理解 useMemo 的底层实现，我们可以简单模拟一下它的行为。以下是一个简化的 useMemo 实现：

let nextId = 0;

function useMemo<T>(factory: () => T, deps: any[]): T {
  const currentHook = getCurrentHook();

  // 初始化时创建一个 memoizedState
  if (currentHook.memoizedState === null) {
    currentHook.memoizedState = {
      id: nextId++,
      value: factory(),
      lastDeps: deps,
    };
    return currentHook.memoizedState.value;
  }

  const { id, value, lastDeps } = currentHook.memoizedState;

  // 检查依赖项是否发生变化
  let changed = false;
  for (let i = 0; i < deps.length; i++) {
    if (!Object.is(deps[i], lastDeps[i])) {
      changed = true;
      break;
    }
  }

  if (changed) {
    const newValue = factory();
    currentHook.memoizedState = {
      id,
      value: newValue,
      lastDeps: deps,
    };
    return newValue;
  }

  return value;
}

// 模拟 React 的 Hook 调用栈
let currentHook: { memoizedState: any } = { memoizedState: null };

function getCurrentHook() {
  return currentHook;
}

// 示例用法
const MyComponent = () => {
  const [count, setCount] = useState(0);

  const expensiveValue = useMemo(() => {
    console.log('Computing expensive value...');
    return computeExpensiveValue(count);
  }, [count]);

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

function computeExpensiveValue(n) {
  let result = 0;
  for (let i = 0; i < 100000000; i++) {
    result += n * i;
  }
  return result;
}

4. `useMemo` 的注意事项

性能优化：useMemo 主要用于优化性能，避免在每次渲染时都进行昂贵的计算。但它并不是万能的，过度使用可能会增加内存消耗。
依赖项管理：依赖项数组必须包含所有影响计算结果的变量。如果依赖项数组为空，useMemo 会在每次渲染时重新计算。
副作用：useMemo 不应该用于处理副作用操作，如数据获取或订阅事件。这些操作应该使用 useEffect。

5. 示例

以下是一个使用 useMemo 的完整示例：

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

const computeExpensiveValue = (n) => {
  let result = 0;
  for (let i = 0; i < 100000000; i++) {
    result += n * i;
  }
  return result;
};

const MyComponent = () => {
  const [count, setCount] = useState(0);

  const expensiveValue = useMemo(() => {
    console.log('Computing expensive value...');
    return computeExpensiveValue(count);
  }, [count]);

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

export default MyComponent;

在这个示例中，computeExpensiveValue 是一个昂贵的计算函数。通过 useMemo，我们确保只有在 count 发生变化时才重新计算 expensiveValue，从而提高了性能。

总结

useMemo 是 React 提供的一个强大的 Hook，用于优化性能，避免在每次渲染时都进行昂贵的计算。通过缓存计算结果并在依赖项没有变化时返回缓存结果，useMemo 可以显著提高应用的性能。理解 useMemo 的原理和底层实现，可以帮助你更好地使用它来优化 React 应用。

26. 谈一谈你对react router的理解

谈一谈你对 React Router 的理解

React Router 是一个用于 React 应用程序的路由库，它允许你定义和管理应用中的不同页面和路径。通过 React Router，你可以实现单页应用（SPA）中的导航和路由功能，而无需刷新整个页面。以下是关于 React Router 的几个关键点：

1. 基本概念

路由：路由是指将 URL 映射到特定组件的过程。React Router 通过定义路由来确定哪个组件应该在特定的 URL 下显示。
导航：导航是指在应用中从一个页面跳转到另一个页面的过程。React Router 提供了多种方式来实现导航，例如链接和编程式导航。
历史记录：React Router 使用浏览器的历史记录 API 来管理用户的导航历史，确保用户可以使用浏览器的前进和后退按钮。

2. 主要组件

React Router 提供了多个组件来帮助你管理路由和导航：

<BrowserRouter>：使用 HTML5 的 History API 来管理应用的路由。这是最常见的路由器组件。
<HashRouter>：使用 URL 的哈希部分来管理路由，适用于不支持 HTML5 History API 的环境。
<Route>：定义一个路由，当 URL 匹配时，渲染相应的组件。
<Link>：创建一个导航链接，点击时会触发路由切换。
<NavLink>：类似于 <Link>，但提供了激活状态的样式。
<Switch>：用于包裹多个 <Route>，确保只匹配并渲染第一个匹配的路由。
<Redirect>：用于重定向到另一个路由。
<useHistory>：一个 Hook，用于在函数组件中访问路由的历史记录对象。
<useLocation>：一个 Hook，用于在函数组件中访问当前的路由位置对象。
<useParams>：一个 Hook，用于在函数组件中访问 URL 参数。

3. 基本用法

3.1 定义路由

import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Home from './Home';
import About from './About';
import Contact from './Contact';

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

export default App;

3.2 导航链接

import React from 'react';
import { Link } from 'react-router-dom';

function Navigation() {
  return (
    <nav>
      <ul>
        <li><Link to="/">Home</Link></li>
        <li><Link to="/about">About</Link></li>
        <li><Link to="/contact">Contact</Link></li>
      </ul>
    </nav>
  );
}

export default Navigation;

3.3 编程式导航

import React from 'react';
import { useHistory } from 'react-router-dom';

function MyComponent() {
  const history = useHistory();

  const handleNavigate = () => {
    history.push('/about');
  };

  return (
    <button onClick={handleNavigate}>Go to About</button>
  );
}

export default MyComponent;

4. 路由参数

React Router 支持动态路由参数，可以通过 useParams Hook 获取 URL 中的参数。

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

function UserDetail() {
  const { userId } = useParams();

  return (
    <div>
      <h1>User Detail</h1>
      <p>User ID: {userId}</p>
    </div>
  );
}

export default UserDetail;

4.1 定义带参数的路由

import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Home from './Home';
import UserDetail from './UserDetail';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/" exact component={Home} />
        <Route path="/user/:userId" component={UserDetail} />
      </Switch>
    </Router>
  );
}

export default App;

5. 路由保护

你可以使用高阶组件或自定义 Hook 来实现路由保护，确保用户在未登录的情况下无法访问某些页面。

import React from 'react';
import { Redirect, Route } from 'react-router-dom';
import { useAuth } from './auth';

function PrivateRoute({ component: Component, ...rest }) {
  const auth = useAuth();

  return (
    <Route
      {...rest}
      render={(props) =>
        auth.isAuthenticated ? <Component {...props} /> : <Redirect to="/login" />
      }
    />
  );
}

export default PrivateRoute;

5.1 使用 `PrivateRoute`

import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Home from './Home';
import Dashboard from './Dashboard';
import Login from './Login';
import PrivateRoute from './PrivateRoute';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/" exact component={Home} />
        <Route path="/login" component={Login} />
        <PrivateRoute path="/dashboard" component={Dashboard} />
      </Switch>
    </Router>
  );
}

export default App;

6. 嵌套路由

React Router 支持嵌套路由，可以在一个组件中定义多个子路由。

import React from 'react';
import { BrowserRouter as Router, Route, Switch, Link } from 'react-router-dom';
import Home from './Home';
import Dashboard from './Dashboard';
import Settings from './Settings';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/" exact component={Home} />
        <Route path="/dashboard" component={Dashboard} />
      </Switch>
    </Router>
  );
}

function Dashboard() {
  return (
    <div>
      <h1>Dashboard</h1>
      <nav>
        <ul>
          <li><Link to="/dashboard/settings">Settings</Link></li>
        </ul>
      </nav>
      <Switch>
        <Route path="/dashboard/settings" component={Settings} />
      </Switch>
    </div>
  );
}

export default App;

总结

React Router 是一个强大且灵活的路由库，它使得在 React 应用中管理路由和导航变得非常方便。通过定义路由、使用导航链接、处理路由参数、实现路由保护和嵌套路由等功能，React Router 帮助你构建复杂且高性能的单页应用。理解 React Router 的基本概念和主要组件，可以帮助你在实际开发中更有效地使用它。

27. react如何实现路由守卫

在 React 中实现路由守卫（也称为路由保护）是一种常见的需求，特别是在需要验证用户身份或权限的情况下。React Router 提供了多种方式来实现路由守卫，以下是一些常见的方法：

1. 使用高阶组件（HOC）

高阶组件是一种常见的模式，可以用来包装和增强现有的组件。通过创建一个高阶组件来实现路由保护，可以在用户未登录或没有权限时重定向到其他页面。

示例

import React from 'react';
import { Redirect, Route } from 'react-router-dom';

const PrivateRoute = ({ component: Component, ...rest }) => {
  const isAuthenticated = localStorage.getItem('isAuthenticated'); // 假设这里存储了用户的认证状态

  return (
    <Route
      {...rest}
      render={(props) =>
        isAuthenticated ? <Component {...props} /> : <Redirect to="/login" />
      }
    />
  );
};

export default PrivateRoute;

使用 `PrivateRoute`

import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Home from './Home';
import Dashboard from './Dashboard';
import Login from './Login';
import PrivateRoute from './PrivateRoute';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/" exact component={Home} />
        <Route path="/login" component={Login} />
        <PrivateRoute path="/dashboard" component={Dashboard} />
      </Switch>
    </Router>
  );
}

export default App;

2. 使用自定义 Hook

自定义 Hook 可以让你在函数组件中复用逻辑。通过创建一个自定义 Hook 来实现路由保护，可以在多个组件中共享相同的逻辑。

示例

import { useEffect } from 'react';
import { useHistory } from 'react-router-dom';

const useAuth = () => {
  const history = useHistory();
  const isAuthenticated = localStorage.getItem('isAuthenticated');

  useEffect(() => {
    if (!isAuthenticated) {
      history.push('/login');
    }
  }, [history, isAuthenticated]);

  return isAuthenticated;
};

export default useAuth;

使用 `useAuth`

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

const Dashboard = () => {
  const isAuthenticated = useAuth();

  if (!isAuthenticated) {
    return null; // 或者显示加载状态
  }

  return (
    <div>
      <h1>Dashboard</h1>
      <p>Welcome to the dashboard!</p>
    </div>
  );
};

export default Dashboard;

3. 使用 `render` 方法

在 Route 组件中使用 render 方法，可以直接在渲染时进行条件判断，实现路由保护。

示例

import React from 'react';
import { Route, Redirect } from 'react-router-dom';

const PrivateRoute = ({ component: Component, ...rest }) => {
  const isAuthenticated = localStorage.getItem('isAuthenticated');

  return (
    <Route
      {...rest}
      render={(props) =>
        isAuthenticated ? <Component {...props} /> : <Redirect to="/login" />
      }
    />
  );
};

export default PrivateRoute;

使用 `PrivateRoute`

import React from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Home from './Home';
import Dashboard from './Dashboard';
import Login from './Login';
import PrivateRoute from './PrivateRoute';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/" exact component={Home} />
        <Route path="/login" component={Login} />
        <PrivateRoute path="/dashboard" component={Dashboard} />
      </Switch>
    </Router>
  );
}

export default App;

4. 使用 `useEffect` 进行导航

在组件内部使用 useEffect 钩子进行导航，可以在组件挂载时检查用户身份并进行重定向。

示例

import React, { useEffect } from 'react';
import { useHistory } from 'react-router-dom';

const Dashboard = () => {
  const history = useHistory();
  const isAuthenticated = localStorage.getItem('isAuthenticated');

  useEffect(() => {
    if (!isAuthenticated) {
      history.push('/login');
    }
  }, [history, isAuthenticated]);

  return (
    <div>
      <h1>Dashboard</h1>
      <p>Welcome to the dashboard!</p>
    </div>
  );
};

export default Dashboard;

总结

在 React 中实现路由守卫有多种方法，包括使用高阶组件、自定义 Hook、render 方法和 useEffect 钩子。选择哪种方法取决于你的具体需求和项目结构。通过这些方法，你可以有效地保护路由，确保只有经过验证的用户才能访问特定的页面。

28. 如何使用hooks封装防抖和节流

在 React 中，使用 Hooks 封装防抖（debounce）和节流（throttle）功能是一种常见且有效的方法。这样可以让你在多个组件中复用这些功能，提高代码的可维护性和可读性。以下是如何使用 Hooks 封装防抖和节流的示例。

1. 封装防抖 Hook

防抖（debounce）是指在一定时间内多次触发某个事件时，只执行最后一次触发的回调函数。这在处理输入框的搜索、窗口的调整大小等场景中非常有用。

示例

import { useState, useEffect } from 'react';

const useDebounce = (value, delay) => {
  // State to store the debounced value
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    // Set a timer to update the debounced value after the delay
    const handler = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Clean up the timer if the component is unmounted or the value changes
    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]); // Only re-run the effect if value or delay changes

  return debouncedValue;
};

export default useDebounce;

使用 `useDebounce`

import React, { useState } from 'react';
import useDebounce from './useDebounce';

const SearchInput = () => {
  const [searchTerm, setSearchTerm] = useState('');
  const debouncedSearchTerm = useDebounce(searchTerm, 500); // Debounce the search term with a 500ms delay

  useEffect(() => {
    // Perform the search when the debounced value changes
    console.log('Performing search:', debouncedSearchTerm);
  }, [debouncedSearchTerm]);

  return (
    <input
      type="text"
      value={searchTerm}
      onChange={(e) => setSearchTerm(e.target.value)}
      placeholder="Search..."
    />
  );
};

export default SearchInput;

2. 封装节流 Hook

节流（throttle）是指在一定时间内多次触发某个事件时，只执行一次回调函数。这在处理滚动事件、鼠标移动事件等高频触发的场景中非常有用。

示例

import { useState, useEffect } from 'react';

const useThrottle = (value, delay) => {
  // State to store the throttled value
  const [throttledValue, setThrottledValue] = useState(value);

  useEffect(() => {
    // Set a timer to update the throttled value after the delay
    const handler = setTimeout(() => {
      setThrottledValue(value);
    }, delay);

    // Clean up the timer if the component is unmounted or the value changes
    return () => {
      clearTimeout(handler);
    };
  }, [value, delay]); // Only re-run the effect if value or delay changes

  return throttledValue;
};

export default useThrottle;

使用 `useThrottle`

import React, { useState, useEffect } from 'react';
import useThrottle from './useThrottle';

const ScrollHandler = () => {
  const [scrollPosition, setScrollPosition] = useState(0);
  const throttledScrollPosition = useThrottle(scrollPosition, 100); // Throttle the scroll position with a 100ms delay

  useEffect(() => {
    const handleScroll = () => {
      setScrollPosition(window.scrollY);
    };

    window.addEventListener('scroll', handleScroll);

    return () => {
      window.removeEventListener('scroll', handleScroll);
    };
  }, []);

  useEffect(() => {
    // Perform some action when the throttled scroll position changes
    console.log('Scroll position:', throttledScrollPosition);
  }, [throttledScrollPosition]);

  return (
    <div>
      <p>Current scroll position: {scrollPosition}</p>
      <p>Throttled scroll position: {throttledScrollPosition}</p>
    </div>
  );
};

export default ScrollHandler;

总结

通过使用 Hooks 封装防抖和节流功能，你可以在多个组件中复用这些逻辑，提高代码的可维护性和可读性。防抖适用于处理输入框的搜索、窗口的调整大小等场景，而节流适用于处理滚动事件、鼠标移动事件等高频触发的场景。希望这些示例能帮助你在 React 应用中更好地实现防抖和节流功能。

查看全文

http://www.kler.cn/a/396086.html

二分搜索的三种方法

【Pikachu】任意文件上传实战

gitHub常用操作

【NLP】医学搜索Query相关性判断【阿里云：天池比赛】

云安全之云计算基础

前端系统设计面试题（二）Javascript\Vue

Pycharm 配置 Poetry

【Android、IOS、Flutter、鸿蒙、ReactNative 】启动页

初始 html

VSCode可以安装最新版，并且可以对应Node 12和npm 6

多智能体系统实现无直接通信协同

Casio推出情感AI宠物机器人Moflin

前后端交互之动态列

[CKS] 使用ingress公开https服务

【大模型实战篇】vLLM的由来以及大模型部署、推理加速实践

跨域总结 CORS

Linux服务器搭建SVN

基于图像处理与机器学习的车牌检测识别系统设计与实现

厦大南洋理工最新开源，一种面向户外场景的特征-几何一致性无监督点云配准方法

PyCharm 中的【控制台】和【终端】的区别

QT中使用图表之QChart绘制饼图

论文阅读 - Causally Regularized Learning with Agnostic Data Selection

【异常记录】Junitmock之InvalidUseOfMatchersException异常

Tomcat 8.5 源码导读

汇编案例之 HEX到ASCII码的转换

超越传统：探索ONLYOFFICE的革命性办公新纪元

目录

1. React中为什么要设计Hook，为了解决什么问题

2. 组件的生命周期方法

组件的生命周期方法

挂载阶段（Mounting）

更新阶段（Updating）

卸载阶段（Unmounting）

错误处理

3. 状态（state）和属性（props）

状态（state）和属性（props）

状态（state）

属性（props）

主要区别

总结

4. 高阶组件（Higher-Order Component，简称 HOC）

高阶组件

定义

特点

基本用法

1. 创建高阶组件

2. 使用高阶组件

常见应用场景

注意事项

总结

5. 受控组件 和 非受控组件

总结

6. 展示组件(Presentational component)和容器组件(Containercomponent)区别

展示组件（Presentational Component）

容器组件（Container Component）

总结

7. 类组件(Class component) 和 函数式组件(Functional component)的区别

1. 定义方式

2. 状态管理

3. 生命周期方法

4. 性能优化

5. 上下文（Context）

总结

8. 何划分 技术组件 和 业务组件

1. 技术组件（Technical Component）

2. 业务组件（Business Component）

划分方法

总结

9. 什么是 React 中的上下文(Context)？它有什么作用？

什么是上下文（Context）？

主要作用

如何使用 Context？

示例代码

总结

10. React是mvvm框架吗

简短回答

详细解释

1. React 的定位

2. MVVM 框架的特点

3. React 与 MVVM 的区别

4. React 的生态系统

总结

11. React 如何实现 mvvm

1. 理解 MVVM 架构

2. 使用 React 实现 MVVM

2.1. 使用 State 和 Props

2.2. 使用 Context API

2.3. 使用 Redux 或 MobX

示例代码

2.4. 使用 State 和 Props

2.5. 使用 Context API

2.6. 使用 Redux

总结

12. redux 主要解决什么问题 及 优缺点

主要解决的问题

优点

缺点

总结

13. React 性能优化方案，所关联周期函数

关联的生命周期函数

14. 虚拟 DOM 的意义

虚拟 DOM 的工作原理

总结

15. React DOM Diff 算法

1. 虚拟 DOM 的构建

2. 差异比较（Diffing）

5. 受控组件和非受控组件

7. 类组件(Class component) 和函数式组件(Functional component)的区别

8. 何划分技术组件和业务组件

12. redux 主要解决什么问题及优缺点

1.1 `componentDidMount`

1.2 `componentDidUpdate`

1.3 `componentWillUnmount`

2.1 `useEffect` 用于初始数据请求

2.2 `useEffect` 用于依赖变化时的数据请求

2.3 `useEffect` 用于清理操作

1.1 创建和使用 `ref`

2.1 在类组件中使用 `ref` 访问子组件

2.2 在函数组件中使用 `ref` 访问子组件

3.1 使用 `ref` 管理动画

4.1 使用 `ref` 管理表单

2.1 没有 `key` 的情况