• 【React源码】(十四）Hook 原理(副作用 Hook)

    Hook 原理(副作用 Hook)

    本节建立在前文Hook 原理(概览)和Hook 原理(状态 Hook)的基础之上, 重点讨论useEffect, useLayoutEffect等标准的副作用Hook.

    创建 Hook

    在fiber初次构造阶段, useEffect对应源码mountEffect, useLayoutEffect对应源码mountLayoutEffect

    mountEffect:

     

    1. function mountEffect(
    3. create: () => (() => void) | void,
    5. deps: Array | void | null,
    7. ): void {
    8.  
    9. return mountEffectImpl(
    10.  
    11. UpdateEffect | PassiveEffect, // fiberFlags
    12.  
    13. HookPassive, // hookFlags
    14.  
    15. create,
    16.  
    17. deps,
    18.  
    19. );
    20.  
    21. }
     

    mountLayoutEffect:
     

     

    1. function mountLayoutEffect(
    3. create: () => (() => void) | void,
    5. deps: Array | void | null,
    7. ): void {
    8.  
    9. return mountEffectImpl(
    10.  
    11. UpdateEffect, // fiberFlags
    12.  
    13. HookLayout, // hookFlags
    14.  
    15. create,
    16.  
    17. deps,
    18.  
    19. );
    20.  
    21. }
     

    可见mountEffect和mountLayoutEffect内部都直接调用mountEffectImpl, 只是参数不同.
     

    mountEffectImpl:
     

     

    1. function mountEffectImpl(fiberFlags, hookFlags, create, deps): void {
    2.  
    3. // 1. 创建hook
    4.  
    5. const hook = mountWorkInProgressHook();
    6.  
    7. const nextDeps = deps === undefined ? null : deps;
    8.  
    9. // 2. 设置workInProgress的副作用标记
    10.  
    11. currentlyRenderingFiber.flags |= fiberFlags; // fiberFlags 被标记到workInProgress
    12.  
    13. // 2. 创建Effect, 挂载到hook.memoizedState上
    14.  
    15. hook.memoizedState = pushEffect(
    16.  
    17. HookHasEffect | hookFlags, // hookFlags用于创建effect
    18.  
    19. create,
    20.  
    21. undefined,
    22.  
    23. nextDeps,
    24.  
    25. );
    26.  
    27. }
     

    mountEffectImpl逻辑:
     

    1. 创建hook
    2. 设置workInProgress的副作用标记: flags |= fiberFlags
    3. 创建effect(在pushEffect中), 挂载到hook.memoizedState上, 即 hook.memoizedState = effect 
  
      • 注意: 状态Hook中hook.memoizedState = state
     

    创建 Effect
     

    pushEffect:
     

     

    1. function pushEffect(tag, create, destroy, deps) {
    2.  
    3. // 1. 创建effect对象
    4.  
    5. const effect: Effect = {
    6.  
    7. tag,
    8.  
    9. create,
    10.  
    11. destroy,
    12.  
    13. deps,
    14.  
    15. next: (null: any),
    16.  
    17. };
    18.  
    19. // 2. 把effect对象添加到环形链表末尾
    20.  
    21. let componentUpdateQueue: null | FunctionComponentUpdateQueue = (currentlyRenderingFiber.updateQueue: any);
    22.  
    23. if (componentUpdateQueue === null) {
    24.  
    25. // 新建 workInProgress.updateQueue 用于挂载effect对象
    26.  
    27. componentUpdateQueue = createFunctionComponentUpdateQueue();
    28.  
    29. currentlyRenderingFiber.updateQueue = (componentUpdateQueue: any);
    30.  
    31. // updateQueue.lastEffect是一个环形链表
    32.  
    33. componentUpdateQueue.lastEffect = effect.next = effect;
    34.  
    35. } else {
    36.  
    37. const lastEffect = componentUpdateQueue.lastEffect;
    38.  
    39. if (lastEffect === null) {
    40.  
    41. componentUpdateQueue.lastEffect = effect.next = effect;
    42.  
    43. } else {
    44.  
    45. const firstEffect = lastEffect.next;
    46.  
    47. lastEffect.next = effect;
    48.  
    49. effect.next = firstEffect;
    50.  
    51. componentUpdateQueue.lastEffect = effect;
    52.  
    53. }
    54.  
    55. }
    56.  
    57. // 3. 返回effect
    58.  
    59. return effect;
    60.  
    61. }
     

    pushEffect逻辑:
     

    1. 创建effect.
    2. 把effect对象添加到环形链表末尾.
    3. 返回effect.
     

    effect的数据结构:
     

     

    1. export type Effect = {|
    2.  
    3. tag: HookFlags,
    4.  
    5. create: () => (() => void) | void,
    6.  
    7. destroy: (() => void) | void,
    8.  
    9. deps: Array | null,
    10.  
    11. next: Effect,
    12.  
    13. |};
     

    •  
      effect.tag: 二进制属性, 代表effect的类型(源码).
       
       
      1. export const NoFlags = /* */ 0b000;
      2.  
      3. export const HasEffect = /* */ 0b001; // 有副作用, 可以被触发
      4.  
      5. export const Layout = /* */ 0b010; // Layout, dom突变后同步触发
      6.  
      7. export const Passive = /* */ 0b100; // Passive, dom突变前异步触发
      8.  
      9. effect.create: 实际上就是通过useEffect()所传入的函数.
      10.  
      11. effect.deps: 依赖项, 如果依赖项变动, 会创建新的effect.
       
       
     

    renderWithHooks执行完成后, 我们可以画出fiber,hook,effect三者的引用关系:
     

     

    现在workInProgress.flags被打上了标记, 最后会在fiber树渲染阶段的commitRoot函数中处理. (这期间的所有过程可以回顾前文fiber树构造/fiber树渲染系列, 此处不再赘述)
     

    useEffect & useLayoutEffect
     

    站在fiber,hook,effect的视角, 无需关心这个hook是通过useEffect还是useLayoutEffect创建的. 只需要关心内部fiber.flags,effect.tag的状态.
     

    所以useEffect与useLayoutEffect的区别如下:
     

    1. fiber.flags不同
     

    • 使用useEffect时: fiber.flags = UpdateEffect | PassiveEffect.
    • 使用useLayoutEffect时: fiber.flags = UpdateEffect.
     

    1. effect.tag不同
     

    • 使用useEffect时: effect.tag = HookHasEffect | HookPassive.
    • 使用useLayoutEffect时: effect.tag = HookHasEffect | HookLayout.
     

    处理 Effect 回调
     

    完成fiber树构造后, 逻辑会进入渲染阶段. 通过fiber 树渲染中的介绍, 在commitRootImpl函数中, 整个渲染过程被 3 个函数分布实现:
     

    1. commitBeforeMutationEffects
    2. commitMutationEffects
    3. commitLayoutEffects
     

    这 3 个函数会处理fiber.flags, 也会根据情况处理fiber.updateQueue.lastEffect
     

    commitBeforeMutationEffects
     

    第一阶段: dom 变更之前, 处理副作用队列中带有Passive标记的fiber节点.
     

     

    1. function commitBeforeMutationEffects() {
    2.  
    3. while (nextEffect !== null) {
    4.  
    5. // ...省略无关代码, 只保留Hook相关
    6.  
    7. // 处理`Passive`标记
    8.  
    9. const flags = nextEffect.flags;
    10.  
    11. if ((flags & Passive) !== NoFlags) {
    12.  
    13. if (!rootDoesHavePassiveEffects) {
    14.  
    15. rootDoesHavePassiveEffects = true;
    16.  
    17. scheduleCallback(NormalSchedulerPriority, () => {
    18.  
    19. flushPassiveEffects();
    20.  
    21. return null;
    22.  
    23. });
    24.  
    25. }
    26.  
    27. }
    28.  
    29. nextEffect = nextEffect.nextEffect;
    30.  
    31. }
    32.  
    33. }
     

    注意: 由于flushPassiveEffects被包裹在scheduleCallback回调中, 由调度中心来处理, 且参数是NormalSchedulerPriority, 故这是一个异步回调(具体原理可以回顾React 调度原理(scheduler)).
     

    由于scheduleCallback(NormalSchedulerPriority,callback)是异步的, flushPassiveEffects并不会立即执行. 此处先跳过flushPassiveEffects的分析, 继续跟进commitRoot.
     

    commitMutationEffects
     

    第二阶段: dom 变更, 界面得到更新.
     

     

    1. function commitMutationEffects(
    3. root: FiberRoot,
    5. renderPriorityLevel: ReactPriorityLevel,
    7. ) {
    8.  
    9. // ...省略无关代码, 只保留Hook相关
    10.  
    11. while (nextEffect !== null) {
    12.  
    13. const flags = nextEffect.flags;
    14.  
    15. const primaryFlags = flags & (Placement | Update | Deletion | Hydrating);
    16.  
    17. switch (primaryFlags) {
    18.  
    19. case Update: {
    20.  
    21. // useEffect,useLayoutEffect都会设置Update标记
    22.  
    23. // 更新节点
    24.  
    25. const current = nextEffect.alternate;
    26.  
    27. commitWork(current, nextEffect);
    28.  
    29. break;
    30.  
    31. }
    32.  
    33. }
    34.  
    35. nextEffect = nextEffect.nextEffect;
    36.  
    37. }
    38.  
    39. }
    40.  
    41. function commitWork(current: Fiber | null, finishedWork: Fiber): void {
    42.  
    43. // ...省略无关代码, 只保留Hook相关
    44.  
    45. switch (finishedWork.tag) {
    46.  
    47. case FunctionComponent:
    48.  
    49. case ForwardRef:
    50.  
    51. case MemoComponent:
    52.  
    53. case SimpleMemoComponent:
    54.  
    55. case Block: {
    56.  
    57. // 在突变阶段调用销毁函数, 保证所有的effect.destroy函数都会在effect.create之前执行
    58.  
    59. commitHookEffectListUnmount(HookLayout | HookHasEffect, finishedWork);
    60.  
    61. return;
    62.  
    63. }
    64.  
    65. }
    66.  
    67. }
    68.  
    69. // 依次执行: effect.destroy
    70.  
    71. function commitHookEffectListUnmount(tag: number, finishedWork: Fiber) {
    72.  
    73. const updateQueue: FunctionComponentUpdateQueue | null = (finishedWork.updateQueue: any);
    74.  
    75. const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
    76.  
    77. if (lastEffect !== null) {
    78.  
    79. const firstEffect = lastEffect.next;
    80.  
    81. let effect = firstEffect;
    82.  
    83. do {
    84.  
    85. if ((effect.tag & tag) === tag) {
    86.  
    87. // 根据传入的tag过滤 effect链表.
    88.  
    89. const destroy = effect.destroy;
    90.  
    91. effect.destroy = undefined;
    92.  
    93. if (destroy !== undefined) {
    94.  
    95. destroy();
    96.  
    97. }
    98.  
    99. }
    100.  
    101. effect = effect.next;
    102.  
    103. } while (effect !== firstEffect);
    104.  
    105. }
    106.  
    107. }
     

    调用关系: commitMutationEffects->commitWork->commitHookEffectListUnmount.
     

    • 注意在调用commitMutationEffects(HookLayout | HookHasEffect, finishedWork)时, 参数是HookLayout | HookHasEffect, 所以只处理由useLayoutEffect()创建的effect.
    • 根据上文的分析HookLayout | HookHasEffect是通过useLayoutEffect创建的effect. 所以commitMutationEffects函数只能处理由useLayoutEffect()创建的effect.
    • 同步调用effect.destroy().
     

    commitLayoutEffects
     

    第三阶段: dom 变更后
     

     

    1. function commitLayoutEffects(root: FiberRoot, committedLanes: Lanes) {
    2.  
    3. // ...省略无关代码, 只保留Hook相关
    4.  
    5. while (nextEffect !== null) {
    6.  
    7. const flags = nextEffect.flags;
    8.  
    9. if (flags & (Update | Callback)) {
    10.  
    11. // useEffect,useLayoutEffect都会设置Update标记
    12.  
    13. const current = nextEffect.alternate;
    14.  
    15. commitLayoutEffectOnFiber(root, current, nextEffect, committedLanes);
    16.  
    17. }
    18.  
    19. nextEffect = nextEffect.nextEffect;
    20.  
    21. }
    22.  
    23. }
    24.  
    25. function commitLifeCycles(
    27. finishedRoot: FiberRoot,
    29. current: Fiber | null,
    31. finishedWork: Fiber,
    33. committedLanes: Lanes,
    35. ): void {
    36.  
    37. // ...省略无关代码, 只保留Hook相关
    38.  
    39. switch (finishedWork.tag) {
    40.  
    41. case FunctionComponent:
    42.  
    43. case ForwardRef:
    44.  
    45. case SimpleMemoComponent:
    46.  
    47. case Block: {
    48.  
    49. // 在此之前commitMutationEffects函数中, effect.destroy已经被调用, 所以effect.destroy永远不会影响到effect.create
    50.  
    51. commitHookEffectListMount(HookLayout | HookHasEffect, finishedWork);
    52.  
    53. schedulePassiveEffects(finishedWork);
    54.  
    55. return;
    56.  
    57. }
    58.  
    59. }
    60.  
    61. }
    62.  
    63. function commitHookEffectListMount(tag: number, finishedWork: Fiber) {
    64.  
    65. const updateQueue: FunctionComponentUpdateQueue | null = (finishedWork.updateQueue: any);
    66.  
    67. const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
    68.  
    69. if (lastEffect !== null) {
    70.  
    71. const firstEffect = lastEffect.next;
    72.  
    73. let effect = firstEffect;
    74.  
    75. do {
    76.  
    77. if ((effect.tag & tag) === tag) {
    78.  
    79. const create = effect.create;
    80.  
    81. effect.destroy = create();
    82.  
    83. }
    84.  
    85. effect = effect.next;
    86.  
    87. } while (effect !== firstEffect);
    88.  
    89. }
    90.  
    91. }
     

    1. 调用关系: commitLayoutEffects->commitLayoutEffectOnFiber(commitLifeCycles)->commitHookEffectListMount.
     

    • 注意在调用commitHookEffectListMount(HookLayout | HookHasEffect, finishedWork)时, 参数是HookLayout | HookHasEffect,所以只处理由useLayoutEffect()创建的effect.
    • 调用effect.create()之后, 将返回值赋值到effect.destroy.
     

    1.  
      为flushPassiveEffects做准备
       
  
      •  
        commitLifeCycles中的schedulePassiveEffects(finishedWork), 其形参finishedWork实际上指代当前正在被遍历的有副作用的fiber
         
      •  
        schedulePassiveEffects比较简单, 就是把带有Passive标记的effect筛选出来(由useEffect创建), 添加到一个全局数组(pendingPassiveHookEffectsUnmount和pendingPassiveHookEffectsMount).
         
         
        1. function schedulePassiveEffects(finishedWork: Fiber) {
        2.  
        3. // 1. 获取 fiber.updateQueue
        4.  
        5. const updateQueue: FunctionComponentUpdateQueue | null = (finishedWork.updateQueue: any);
        6.  
        7. // 2. 获取 effect环形队列
        8.  
        9. const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
        10.  
        11. if (lastEffect !== null) {
        12.  
        13. const firstEffect = lastEffect.next;
        14.  
        15. let effect = firstEffect;
        16.  
        17. do {
        18.  
        19. const { next, tag } = effect;
        20.  
        21. // 3. 筛选出由useEffect()创建的`effect`
        22.  
        23. if (
        24.  
        25. (tag & HookPassive) !== NoHookEffect &&
        26.  
        27. (tag & HookHasEffect) !== NoHookEffect
        28.  
        29. ) {
        30.  
        31. // 把effect添加到全局数组, 等待`flushPassiveEffects`处理
        32.  
        33. enqueuePendingPassiveHookEffectUnmount(finishedWork, effect);
        34.  
        35. enqueuePendingPassiveHookEffectMount(finishedWork, effect);
        36.  
        37. }
        38.  
        39. effect = next;
        40.  
        41. } while (effect !== firstEffect);
        42.  
        43. }
        44.  
        45. }
        46.  
        47. export function enqueuePendingPassiveHookEffectUnmount(
        49. fiber: Fiber,
        51. effect: HookEffect,
        53. ): void {
        54.  
        55. // unmount effects 数组
        56.  
        57. pendingPassiveHookEffectsUnmount.push(effect, fiber);
        58.  
        59. }
        60.  
        61. export function enqueuePendingPassiveHookEffectMount(
        63. fiber: Fiber,
        65. effect: HookEffect,
        67. ): void {
        68.  
        69. // mount effects 数组
        70.  
        71. pendingPassiveHookEffectsMount.push(effect, fiber);
        72.  
        73. }
         
         
     

    综上commitMutationEffects和commitLayoutEffects2 个函数, 带有Layout标记的effect(由useLayoutEffect创建), 已经得到了完整的回调处理(destroy和create已经被调用).
     

    如下图: 其中第一个effect拥有Layout标记, 所以有effect.destroy(); effect.destroy = effect.create()
     

     

    flushPassiveEffects
     

    在上文commitBeforeMutationEffects阶段, 异步调用了flushPassiveEffects. 在这期间带有Passive标记的effect已经被添加到pendingPassiveHookEffectsUnmount和pendingPassiveHookEffectsMount全局数组中.
     

    接下来flushPassiveEffects就可以脱离fiber节点, 直接访问effects
     

     

    1. export function flushPassiveEffects(): boolean {
    2.  
    3. // Returns whether passive effects were flushed.
    4.  
    5. if (pendingPassiveEffectsRenderPriority !== NoSchedulerPriority) {
    6.  
    7. const priorityLevel =
    8.  
    9. pendingPassiveEffectsRenderPriority > NormalSchedulerPriority
    10.  
    11. ? NormalSchedulerPriority
    12.  
    13. : pendingPassiveEffectsRenderPriority;
    14.  
    15. pendingPassiveEffectsRenderPriority = NoSchedulerPriority;
    16.  
    17. // `runWithPriority`设置Schedule中的调度优先级, 如果在flushPassiveEffectsImpl中处理effect时又发起了新的更新, 那么新的update.lane将会受到这个priorityLevel影响.
    18.  
    19. return runWithPriority(priorityLevel, flushPassiveEffectsImpl);
    20.  
    21. }
    22.  
    23. return false;
    24.  
    25. }
    26.  
    27. // ...省略无关代码, 只保留Hook相关
    28.  
    29. function flushPassiveEffectsImpl() {
    30.  
    31. if (rootWithPendingPassiveEffects === null) {
    32.  
    33. return false;
    34.  
    35. }
    36.  
    37. rootWithPendingPassiveEffects = null;
    38.  
    39. pendingPassiveEffectsLanes = NoLanes;
    40.  
    41. // 1. 执行 effect.destroy()
    42.  
    43. const unmountEffects = pendingPassiveHookEffectsUnmount;
    44.  
    45. pendingPassiveHookEffectsUnmount = [];
    46.  
    47. for (let i = 0; i < unmountEffects.length; i += 2) {
    48.  
    49. const effect = ((unmountEffects[i]: any): HookEffect);
    50.  
    51. const fiber = ((unmountEffects[i + 1]: any): Fiber);
    52.  
    53. const destroy = effect.destroy;
    54.  
    55. effect.destroy = undefined;
    56.  
    57. if (typeof destroy === 'function') {
    58.  
    59. destroy();
    60.  
    61. }
    62.  
    63. }
    64.  
    65. // 2. 执行新 effect.create(), 重新赋值到 effect.destroy
    66.  
    67. const mountEffects = pendingPassiveHookEffectsMount;
    68.  
    69. pendingPassiveHookEffectsMount = [];
    70.  
    71. for (let i = 0; i < mountEffects.length; i += 2) {
    72.  
    73. const effect = ((mountEffects[i]: any): HookEffect);
    74.  
    75. const fiber = ((mountEffects[i + 1]: any): Fiber);
    76.  
    77. effect.destroy = create();
    78.  
    79. }
    80.  
    81. }
     

    其核心逻辑:
     

    1. 遍历pendingPassiveHookEffectsUnmount中的所有effect, 调用effect.destroy(). 
  
      • 同时清空pendingPassiveHookEffectsUnmount
    2. 遍历pendingPassiveHookEffectsMount中的所有effect, 调用effect.create(), 并更新effect.destroy. 
  
      • 同时清空pendingPassiveHookEffectsMount
     

    所以, 带有Passive标记的effect, 在flushPassiveEffects函数中得到了完整的回调处理.
     

    如下图: 其中拥有Passive标记的effect, 都会执行effect.destroy(); effect.destroy = effect.create()
     

     

    更新 Hook
     

    假设在初次调用之后, 发起更新, 会再次执行function, 这时function只使用的useEffect, useLayoutEffect等api也会再次执行.
     

    在更新过程中useEffect对应源码updateEffect, useLayoutEffect对应源码updateLayoutEffect.它们内部都会调用updateEffectImpl, 与初次创建时一样, 只是参数不同.
     

    更新 Effect
     

    updateEffectImpl:
     

     

    1. function updateEffectImpl(fiberFlags, hookFlags, create, deps): void {
    2.  
    3. // 1. 获取当前hook
    4.  
    5. const hook = updateWorkInProgressHook();
    6.  
    7. const nextDeps = deps === undefined ? null : deps;
    8.  
    9. let destroy = undefined;
    10.  
    11. // 2. 分析依赖
    12.  
    13. if (currentHook !== null) {
    14.  
    15. const prevEffect = currentHook.memoizedState;
    16.  
    17. // 继续使用先前effect.destroy
    18.  
    19. destroy = prevEffect.destroy;
    20.  
    21. if (nextDeps !== null) {
    22.  
    23. const prevDeps = prevEffect.deps;
    24.  
    25. // 比较依赖是否变化
    26.  
    27. if (areHookInputsEqual(nextDeps, prevDeps)) {
    28.  
    29. // 2.1 如果依赖不变, 新建effect(tag不含HookHasEffect)
    30.  
    31. pushEffect(hookFlags, create, destroy, nextDeps);
    32.  
    33. return;
    34.  
    35. }
    36.  
    37. }
    38.  
    39. }
    40.  
    41. // 2.2 如果依赖改变, 更改fiber.flag, 新建effect
    42.  
    43. currentlyRenderingFiber.flags |= fiberFlags;
    44.  
    45. hook.memoizedState = pushEffect(
    46.  
    47. HookHasEffect | hookFlags,
    48.  
    49. create,
    50.  
    51. destroy,
    52.  
    53. nextDeps,
    54.  
    55. );
    56.  
    57. }
     

    updateEffectImpl与mountEffectImpl逻辑有所不同: - 如果useEffect/useLayoutEffect的依赖不变, 新建的effect对象不带HasEffect标记.
     

    注意: 无论依赖是否变化, 都复用之前的effect.destroy. 等待commitRoot阶段的调用(上文已经说明).
     

    如下图:
     

    • 图中第 1,2 个hook其deps没变, 故effect.tag中不会包含HookHasEffect.
    • 图中第 3 个hook其deps改变, 故effect.tag中继续含有HookHasEffect. 
       
     

     

    处理 Effect 回调
     

    新的hook以及新的effect创建完成之后, 余下逻辑与初次渲染完全一致. 处理 Effect 回调时也会根据effect.tag进行判断: 只有effect.tag包含HookHasEffect时才会调用effect.destroy和effect.create()
     

    组件销毁
     

    当function组件被销毁时, fiber节点必然会被打上Deletion标记, 即fiber.flags |= Deletion. 带有Deletion标记的fiber在commitMutationEffects被处理:
     

     

    1. // ...省略无关代码
    2.  
    3. function commitMutationEffects(
    5. root: FiberRoot,
    7. renderPriorityLevel: ReactPriorityLevel,
    9. ) {
    10.  
    11. while (nextEffect !== null) {
    12.  
    13. const primaryFlags = flags & (Placement | Update | Deletion | Hydrating);
    14.  
    15. switch (primaryFlags) {
    16.  
    17. case Deletion: {
    18.  
    19. commitDeletion(root, nextEffect, renderPriorityLevel);
    20.  
    21. break;
    22.  
    23. }
    24.  
    25. }
    26.  
    27. }
    28.  
    29. }
     

    在commitDeletion函数之后, 继续调用unmountHostComponents->commitUnmount, 在commitUnmount中, 执行effect.destroy(), 结束整个闭环.
     

    总结
     

    本节分析了副作用Hook从创建到销毁的全部过程, 在react内部, 依靠fiber.flags和effect.tag实现了对effect的精准识别. 在commitRoot阶段, 对不同类型的effect进行处理, 先后调用effect.destroy()和effect.create()
    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
SqlBoy:间隔连续问题                            
    
小程序开发平台源码系统+万能门店小程序功能+完整的搭建教程                            
    
Python爬虫(十八)_多线程糗事百科案例                            
    
解决报错：fatal: in unpopulated submodule *                            
    
腾讯云2023年双十一活动时间、活动入口、活动内容详细解读                            
    
redis缓存一致性以及解决方案                            
    
K8S配置管理---secret与configmap                            
    
GBase 8c 创建和管理Schema （二）                            
    
Unity InputField宽度自适应内容                            
    
Echarts设置饼状图保证你看的明明白白                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/weixin_44828588/article/details/126545752
                
    •