请解释 React 中的 Hooks，何时使用 Hooks 更合适？

一、Hooks 核心理解

1. 什么是 Hooks？

Hooks 是 React 16.8 引入的函数式编程范式，允许在函数组件中使用状态管理和生命周期能力。就像给函数组件装上了"智能芯片"，让原本只能做简单展示的组件具备了处理复杂逻辑的能力。

2. 类组件 vs 函数组件对比

// 类组件实现计时器
class Timer extends React.Component {
  constructor(props) {
    super(props);
    this.state = { seconds: 0 };
    this.timerId = null;
  }

  componentDidMount() {
    this.timerId = setInterval(() => {
      this.setState({ seconds: this.state.seconds + 1 });
    }, 1000);
  }

  componentWillUnmount() {
    clearInterval(this.timerId);
  }

  render() {
    return <div>Seconds: {this.state.seconds}</div>;
  }
}

// 函数组件+Hooks实现
function Timer() {
  const [seconds, setSeconds] = useState(0);

  useEffect(() => {
    const timerId = setInterval(() => {
      setSeconds(s => s + 1); // 使用函数式更新确保最新值
    }, 1000);
    
    return () => clearInterval(timerId); // 清理副作用
  }, []); // 空依赖数组表示只在挂载时执行

  return <div>Seconds: {seconds}</div>;
}

关键优势：

代码量减少40%（从23行→14行）
避免this绑定问题
生命周期逻辑集中管理

二、Hooks 适用场景

1. 状态管理场景

function LoginForm() {
  const [username, setUsername] = useState('');
  const [password, setPassword] = useState('');
  
  // 实时验证逻辑
  const isValid = useMemo(() => {
    return username.length >= 5 && password.length >= 8;
  }, [username, password]);

  const handleSubmit = useCallback((e) => {
    e.preventDefault();
    // 提交逻辑...
  }, [username, password]);

  return (
    <form onSubmit={handleSubmit}>
      <input 
        value={username}
        onChange={(e) => setUsername(e.target.value.slice(0, 20))} // 限制长度
      />
      <input
        type="password"
        value={password}
        onChange={(e) => setPassword(e.target.value.replace(/\s/g, ''))} // 禁止空格
      />
      <button disabled={!isValid}>登录</button>
    </form>
  );
}

最佳实践：

表单控制优先使用受控组件
复杂验证使用useMemo缓存计算结果
事件处理使用useCallback避免重复创建

2. 副作用管理场景

function DataFetcher({ userId }) {
  const [data, setData] = useState(null);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true; // 防止组件卸载后更新状态
    
    const fetchData = async () => {
      try {
        const response = await fetch(`/api/users/${userId}`);
        const result = await response.json();
        if (isMounted) setData(result);
      } catch (err) {
        if (isMounted) setError(err);
      }
    };

    fetchData();
    
    return () => {
      isMounted = false; // 清理函数取消异步操作
    };
  }, [userId]); // userId变化时重新获取

  if (error) return <ErrorDisplay message={error} />;
  if (!data) return <LoadingSpinner />;
  return <UserProfile data={data} />;
}

注意事项：

使用清理函数避免内存泄漏
异步操作配合状态检查
正确设置依赖数组避免无限请求

三、高级使用模式

1. 自定义 Hooks

// 封装鼠标位置跟踪逻辑
function useMousePosition() {
  const [position, setPosition] = useState({ x: 0, y: 0 });

  useEffect(() => {
    const handleMove = (e) => {
      setPosition({ x: e.clientX, y: e.clientY });
    };
    
    window.addEventListener('mousemove', handleMove);
    return () => window.removeEventListener('mousemove', handleMove);
  }, []);

  return position; // 返回当前鼠标坐标
}

// 使用自定义Hook
function CursorTracker() {
  const { x, y } = useMousePosition();
  return (
    <div>
      当前鼠标位置：({x}, {y})
    </div>
  );
}

复用技巧：

以use开头的命名约定
组合基础Hooks构建复杂逻辑
适用于跨组件共享状态逻辑

四、性能优化策略

1. 减少不必要的渲染

const ExpensiveComponent = React.memo(({ list }) => {
  // 复杂计算...
});

function Parent() {
  const [items, setItems] = useState([]);
  const [filter, setFilter] = useState('');

  // 缓存处理后的数据
  const filteredItems = useMemo(() => {
    return items.filter(item => item.includes(filter));
  }, [items, filter]);

  // 缓存回调函数
  const handleAdd = useCallback((newItem) => {
    setItems(prev => [...prev, newItem]);
  }, []);

  return (
    <>
      <input 
        value={filter}
        onChange={(e) => setFilter(e.target.value)}
      />
      <ExpensiveComponent list={filteredItems} />
      <ItemAdder onAdd={handleAdd} />
    </>
  );
}

优化要点：

React.memo 缓存组件
useMemo 缓存计算结果
useCallback 缓存函数引用

五、开发注意事项

1. 遵守Hooks规则

// 错误示例：条件语句中使用Hook
function BrokenComponent({ isActive }) {
  if (isActive) {
    const [value, setValue] = useState(''); // 违反Hook调用顺序
  }
  // ...
}

// 正确做法：保持顶层调用
function FixedComponent({ isActive }) {
  const [value, setValue] = useState('');
  const displayValue = isActive ? value : '';
  // ...
}

强制要求：

只在函数组件顶层调用Hooks
不要在循环/条件中使用Hooks
自定义Hook必须使用use前缀

2. 正确管理依赖数组

function DangerousComponent({ id }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetchData(id).then(setData);
  }, []); // 缺少id依赖，数据不会更新

  // 正确方式应该包含id依赖
  useEffect(() => {
    fetchData(id).then(setData);
  }, [id]); 
}

常见陷阱：

遗漏依赖导致陈旧闭包
不必要的依赖导致频繁执行
复杂对象依赖需使用useMemo

六、适用场景总结

推荐使用Hooks的场景：

新功能开发：首选函数组件+Hooks模式
组件重构：将类组件逐步迁移到函数式
逻辑复用：通过自定义Hooks共享业务逻辑
状态管理：配合Context API或Redux使用
动态效果：实现复杂的交互和动画逻辑

不适用场景：

尚未升级到React 16.8+的老项目
需要继承实现的复杂类组件
需要精确控制生命周期的特殊场景（但99%的场景Hooks都能覆盖）

七、最佳实践建议

渐进式迁移：老项目不要一次性全改，逐步替换
逻辑分层：将业务逻辑抽离到自定义Hooks
性能监控：配合React DevTools分析渲染次数
类型安全：使用TypeScript增强代码可靠性
测试策略：

// 使用@testing-library/react测试Hooks
test('should update counter', () => {
const { result } = renderHook(() => useCounter());

act(() => {
result.current.increment();
});

expect(result.current.count).toBe(1);
});

通过合理运用Hooks，开发者可以构建出更简洁、更易维护的React应用。关键要理解Hooks的设计哲学------用声明式的方式管理副作用和状态，同时保持组件的高度可组合性。