Web—React框架

2026/11/09

Web—React框架

React 的思想是通过声明式、组件化方法构建复杂 UI,并且状态驱动 UI。

更新机制

React 核心基于虚拟DOM 与 Diff算法

组件

**组件(component)**是React的基本单元,内部维护的数据叫state,外部传入的数据叫props。当state或props变化时,React就会进行更新。 父组件通过props向子组件传递数据,子组件只能通过父组件传递的回调函数传递数据。

类组件与函数组件

这是两种写 React 组件的方式。示例如下:

  1. 类组件:核心是通过定义class 类并继承React.Component。返回的组件元素写在render()方法里。
class App extends React.Component {
    constructor() {
        super();
        this.state = {
            name: '',
        };
    }

    render() {
        return (
            //...html标签
        )
    }
}
  1. 函数组件:核心是直接定义**“一个函数变量 + Hook函数”**,return返回的就是组件元素。
const App = () => {
    const [name,setName] = React.useState('');

    return (
        //...html标签
    )
}

生命周期

生命周期 = 组件从 创建 → 挂载到页面 → 更新 → 卸载销毁 整个过程,React 在不同阶段自动执行的回调函数。

组件的生命周期可以分成3个状态:

挂载

当组件实例被创建并插入 DOM 中时,其生命周期调用顺序如下:

render() 方法是 class 组件中唯一必须实现的方法,其他方法可以根据自己的需要来实现。

更新

每当组件的 state 或 props 发生变化时,组件就会更新。

当组件的 props 或 state 发生变化时会触发更新。组件更新的生命周期调用顺序如下:

卸载

当组件从 DOM 中移除时会调用如下方法:

componentWillUnmount(): 在组件卸载及销毁之前直接调用。

相关联的 hooks

class 与 hooks 的联系

Class 生命周期 Hooks 替代方案
constructor 直接 const [x, setX] = useState(初始值)
componentDidMount useEffect(fn, [])
componentDidUpdate useEffect (fn, [依赖])
componentWillUnmount useEffect 返回的清理函数
shouldComponentUpdate React.memo(浅层对比 props)
getDerivedStateFromProps 很少用,一般在渲染里直接计算 /useMemo

setState

setState :class 组件里更新的状态API; setState 是异步更新的,不会立即更新状态,而是收集一批后统一更新,渲染,提升性能。

要拿到更新后的state,可以通过setState方法的第二个参数(回调函数),渲染完后执行:

this.setState({ count: 1}, () => {
    console.log('更新完成,最新值:', this.state.count)
})

坑:因为是收集一批再更新,如果对象氏setState设置中,key同名会覆盖。可以通过函数式 setState 避免:

// 对象式:连续写两次,只会 +1,不是 +2
this.setState({ count: this.state.count + 1 })
this.setState({ count: this.state.count + 1 })

// 函数式:基于前一次状态
this.setState(p => ({count: p.count +1}))
this.setState(p => ({count: p.count +1})) // 最终 +2

什么时候异步消失? 在原生 DOM 事件、定时器里,setState 会变成同步更新

useState 、 useEffect 等 hooks

Hooks 是 React 16.8 推出的,只在函数组件里使用;目的:让函数组件拥有状态、生命周期、上下文、ref 等能力。

  1. 只能在函数组件 / 自定义 Hook 内部调用,不能在 class、普通函数里用
  2. 只能在最顶层调用,不能放在 if、for、while、嵌套函数里;React 靠调用顺序绑定状

下面是常见的 hooks。

useState

函数组件的状态钩子,替代 class 的 state + setState 因为函数组件没有 this 和内置的 state,所以靠 useState 声明状态。

class 的 setState:传入对象,自动和旧 state 合并。而useState 如果存对象:setCount 是直接替换,需要手动展开。例如:

const [info,setInfo] = React.useState({name:'a',age:18})
// 新对象,会丢掉 name
setInfo({age:19})
// 合并旧对象
setInfo(prev => ({...prev, age:19}))

useEffect

函数组件的副作用钩子,替代 class 的生命周期(componentDidMount /componentDidUpdate/componentWillUnmount)

示例:

useEffect(() => {
  // 执行逻辑:挂载 / 依赖变更时执行
  return () => {
    // 清理函数:依赖变化前、组件卸载前执行
  }
}, [dep1, dep2]) // 依赖数组

依赖数组的三种模式:

*想要数据变了之后,去做别的事情(请求、存缓存、订阅) → 用 useEffect

useRef

存可变数据,改了不触发渲染;也用来拿 DOM

// 返回一个固定不变的对象
const ref = useRef(初始值)

useContext

跨多层组件共享数据,避开 props 层层传递 useContext 解决 props 层层透传(props drilling),用 Context 全局分发。

操作步骤:

  1. createContext 创建上下文
  2. 外层用 Context.Provider 提供值
  3. 内层任意组件用 useContext(上下文) 读取
import { createContext, useContext } from 'react'

// 1. 创建context
const ThemeContext = createContext('light);

// 父组件(顶层)
App = () => {
    return (
        <ThemeContext.Provider value='dark'>
            <Child />
        </ThemeContext.Provider>
    )
}

// 深层子组件,不需要中间组件传props
Child = () => {
    const theme = useContext(ThemeContext)
    return <div>当前主题:{theme}</div>
}

Provider 的 value 变化时,所有使用 useContext 的组件都会重新渲染。 适合:主题、登录用户信息、全局配置。

useMemo:

缓存计算结果(值),避免重复昂贵计算

示例:

const result = useMemo(() => 计算函数,[依赖数组])

只有依赖数组里的值发生变化,才会重新执行里面的计算函数;否则直接复用上次的结果。

应用场景示例(大数据过滤,计算开销大):

import { useMemo, useState } from 'react'

const ListDemo = () => {
    const [list,setList] = useState([1,2,3,4,5])
    const [count,setCount] = useState(0)

    // 只有list变了,才重新过滤;count变化不会重新执行过滤
    const filterList = useMemo(() => {
        console.log('执行过滤计算')
        return list.filter(item => item > 2)
    },[list])

    return (
        <div>
            {filterList.map(i => <div key={i}>{i}</div>)}
            <button onClick={() => setCount(c => c+1)}>{count}</button>
        </div>
    )
}
// 效果就是点击按钮修改 count,组件会重新渲染,但是**不会重新执行 filter**,直接拿缓存好的 filterList。

*它优化的是昂贵计算,不是优化渲染 *想要基于现有 state 算出一个新值,直接给页面渲染 → 用 useMemo(派生数据)

useCallback

useCallback 用来缓存函数本身,保证依赖不变时函数引用不变。

const fn = useCallback(函数,[依赖数组])

应用场景:父组件每次渲染,都会生成一个全新的函数,传给子组件,memo 对比发现 props 变了,子组件就会无意义刷新。示例如下:

import { useCallback, useState } from 'react'

// 子组件用memo缓存
const Child = React.memo(({ onChange }) => {
  console.log('子渲染了')
  return <input onChange={onChange} />
})

function Parent() {
  const [keyword, setKeyword] = useState('')
  const [count, setCount] = useState(0)

  // useCallback:keyword不变,函数引用永远不变
  const handleChange = useCallback((e) => {
    setKeyword(e.target.value)
  }, [keyword])

  return (
    <div>
      <Child onChange={handleChange} />
      <button onClick={() => setCount(c => c+1)}>{count}</button>
    </div>
  )
}

对比 useCallback /useMemo:useCallback(fn, deps) 等价于 useMemo(()=>fn, deps)

扩展

React-Native 可以用来开发移动应用

函数组件示例

下面是一个通过 React 函数组件创建一个页面的完整示例,包括根、首页、搜索、列表组件

启动步骤:

  1. 进入 root 根目录
  2. 执行npx vite 启动项目

目录层级:

root:
    -index
    src:
        -index.tsx
        -App.tsx
        componets:
            -InputComponent.tsx
            -LiComponent.tsx
            -SourceComponent.tsx
            -li.css

源代码如下:

  1. 目录层级:
root:
    -index
    src:
        -index.tsx
        -App.tsx
        componets:
            -InputComponent.tsx
            -LiComponent.tsx
            -SourceComponent.tsx
            -li.css
  1. html入口页面:index.html
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8" />
    <link rel="stylesheet" href="/src/components/li.css" />
</head>
<body>
    <div id="root"></div>
    <script type="module" src="/src/index.tsx"></script>
</body>
</html>
  1. 样式页:li.css
.ul-container {
    display: grid;
    grid-template-columns: 1fr 1fr 1fr;
    text-align: center;
    background-color: lightcyan;
    list-style: none;
}

.imgCSS {
    width: 160px;
    height: 100px;
    border: 1px solid darkorange;
    border-radius: 10px;
}
  1. index.tsx:React根
import ReactDOM from 'react-dom/client';
import App from './App';

const root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement);

root.render(<App />)
  1. App.tsx:首页组件:搜索 + 列表
import React from 'react';
import InputComponent from './components/InputComponent';
import LiComponent, { HotItem } from './components/LiComponent';

const App = () => {
    const [hotSearchs, setHotSearchs] = React.useState<HotItem[]>([]);
    const [filteredSearchs, setFilteredSearchs] = React.useState<HotItem[]>([]);

    React.useEffect(() => {
        console.log('执行useEffect')
        fetchData(selectedSource);
    }, []);

    const fetchData = () => {
        fetch(`https://uapis.cn/api/v1/misc/hotboard?type=bilibili`)
            .then(response => response.json())
            .then(json => {
                setHotSearchs(json.list);
                setFilteredSearchs(json.list);
            })
            .catch(error => console.error('请求热搜接口失败:',error));
    }

    const onChangeSearchHandler = (event: React.ChangeEvent<HTMLInputElement>) => {
        const comparedSearchs = hotSearchs.filter(search => search.title.includes(event.target.value));
        setFilteredSearchs(comparedSearchs);
    }

    return (
        <div>
            <h1>Hello, React!</h1>
            <label>搜索:</label>
            <InputComponent onChangeSearchHandler={onChangeSearchHandler} />
            <LiComponent filteredSearchs={filteredSearchs} />
        </div>
    );
};

export default App;
  1. LiComponent.tsx:列表
import React from 'react';

export interface HotItem {
    index: number;
    title: string;
    extra: { pic: string };
}

const LiComponent = ({ filteredSearchs }: { 
    filteredSearchs: { index: number, title: string, extra: { pic: string } }[] 
}) => {
    return (
        <ul className="ul-container">
            {
                filteredSearchs.map(search => {
                    return (
                        <div key={search.index}>
                            <li key={search.index}>{search.title}</li>
                            <img src={search.extra.pic} className='imgCSS' referrerPolicy="no-referrer" />
                        </div>
                    )
                })
            }
        </ul>
    );
};

export default LiComponent;
  1. InputComponent.tsx:搜索
import React from 'react';

const InputComponent = ({ onChangeSearchHandler }: { 
    onChangeSearchHandler: (event: React.ChangeEvent<HTMLInputElement>) => void 
}) => {
    return (
        <input type="search" onChange={onChangeSearchHandler} />
    );
};

export default InputComponent;

总结

来自React官网:

当你使用 React 构建用户界面时,你首先会把它分解成一个个组件。然后,你需要把这些组件连接在一起,使数据流经它们。在本教程中,我们将引导你使用 React 构建一个可搜索的产品数据表。

参考

  1. React入门应该是这样的!!!
  2. React 组件生命周期