React Hooks 指南

React Hooks 是 React 新增的特性，可以让我们在函数组件中使用状态和生命周期方法等与类组件相同的功能。本文将介绍 React Hooks 的用法和常见的应用场景。

useState

useState 是 React Hooks 中被使用最多的方法之一，它使我们能够在函数式组件中使用 state。调用 useState 方法返回一个数组，包括当前状态和一个更新状态的函数。例如：

import React, { useState } from "react";

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

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

在以上代码中，我们使用 useState 方法声明了 count 和 setCount 两个变量，初始状态是 0。然后，我们更新 state 的方式是在按钮点击时调用 setCount 方法，并传入新的 count 值。

useEffect

useEffect 允许我们更新组件渲染以后执行一些副作用操作，如请求数据、订阅事件等。它接收一个回调函数和一个数组作为参数，用于控制 useEffect 方法何时执行。

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

function Timer() {
  const [seconds, setSeconds] = useState(0);

  useEffect(() => {
    const intervalId = setInterval(() => {
      setSeconds((seconds) => seconds + 1);
    }, 1000);

    return () => clearInterval(intervalId);
  }, []);

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

在以上代码中，我们用 setInterval 方法实现了一个计时器，并在组件渲染以后开始计时。然后，我们使用 useEffect 来清除计时器，以防止内存泄漏和不必要的资源消耗。空数组 [] 意味着回调函数仅执行一次。

useContext

useContext 允许我们在组件层次结构中共享数据，避免了 props 层层传递的麻烦，也可以保持代码整洁。

import React, { useContext } from "react";

const MyContext = React.createContext();

function Child() {
  const { count, setCount } = useContext(MyContext);

  return (
    <div>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>Click me</button>
    </div>
  );
}

function Parent() {
  const [count, setCount] = useState(0);

  return (
    <MyContext.Provider value={{ count, setCount }}>
      <Child />
    </MyContext.Provider>
  );
}

在以上代码中，我们使用 createContext 方法创建了一个 context 对象，然后在 Parent 组件中声明状态 count 和方式 setCount。最后，将这些值传递给 Child 组件并在其中使用 useContext 方法获取。

useReducer

useReducer 另一种管理状态的 Hook，在处理复杂 state，如嵌套和多个子状态时可以使用。

import React, { useReducer } from "react";

const initialState = { count: 0 };

function reducer(state, action) {
  switch (action.type) {
    case "increment":
      return { count: state.count + 1 };
    case "decrement":
      return { count: state.count - 1 };
    default:
      throw new Error();
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, initialState);

  return (
    <div>
      <p>Count: {state.count}</p>
      <button onClick={() => dispatch({ type: "increment" })}>+</button>
      <button onClick={() => dispatch({ type: "decrement" })}>-</button>
    </div>
  );
}

在以上代码中，我们定义了一个 reducer 函数，接收两个参数 state 和 action，并返回一个状态对象。然后，我们提供了一个初始状态 initialState、调用 useReducer 的方式和两个按钮，可以分别增加或减少 count 的值。

useCallback 和 useMemo

useCallback 和 useMemo 在性能优化方面非常有用。当我们需要对函数进行性能优化时，可以使用 useCallback 和 useMemo。

useCallback

用于缓存函数，以避免重新渲染时的函数重新创建。以一个示例来说明：

import React, { useState, useCallback } from "react";

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

  const handleIncrement = useCallback(() => {
    setCount(count + 1);
  }, [count]);

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

在以上代码中，我们使用 useCallback 缓存了 handleIncrement 函数，并将 count 作为依赖项传递。这样，在 count 改变时，handleIncrement 函数才会重新创建。由于函数变化往往会导致组件重新渲染，因此使用 useCallback 可以避免不必要的重新渲染。

useMemo

也是类似的，但它用于缓存值而不是函数。例如：

import React, { useMemo } from "react";

function computeExpensiveValue(a, b) {
  // 一些复杂的计算
  return a * b;
}

function MyComponent({ a, b }) {
  const result = useMemo(() => {
    return computeExpensiveValue(a, b);
  }, [a, b]);

  return <p>{result}</p>;
}

在以上代码中，我们使用 useMemo 缓存了 result，以避免每次重新渲染时重新计算。这在处理复杂计算时可以提高性能。

总结：使用 React Hooks 提供的 useState、useEffect、useContext、useReducer、useCallback 和 useMemo 等方法，可以使函数式组件更加灵活和可维护，提高代码效率和性能。为了更好地应用这些方法，我们需要了解其基本原理和应用场景，并结合实际情况进行选择和使用。

React 常用 Hooks 指南