> 今日问题：如何理解事件循环？





**Q：如果在前端面试中，有人问你如何理解事件循环，怎么回答最好？**

**A：在前端面试中，对于事件循环`（Event Loop）`的理解是一个重要的面试点。以下是一个较为全面的回答，可以帮助你展示对事件循环的理解：**

**回答示例：**

事件循环是浏览器或`Node.js`执行`JavaScript代码`的一种机制，它确保异步任务（例如回调函数、定时器等）按照特定的顺序执行，而不会阻塞主线程。理解事件循环的关键点包括以下几个方面：

1. **调用栈（Call Stack）**： JavaScript代码的执行是通过调用栈来管理的，每个函数调用都会被推入调用栈，而函数执行完毕后将被弹出。
2. **任务队列（Task Queue）**： 任务队列存储异步任务和事件，例如定时器回调、事件处理函数等。当异步任务完成时，会被推入任务队列。
3. **事件循环的阶段（Event Loop Phases）**： 事件循环分为不同的阶段，其中包括宏任务队列（MacroTask Queue）和微任务队列（MicroTask Queue）。宏任务队列包括整体的script代码、setTimeout、setInterval等，而微任务队列包括Promise、MutationObserver等。
4. **执行顺序**： 在事件循环的每一轮中，首先执行当前调用栈中的代码，然后检查微任务队列，依次执行微任务。接下来，从宏任务队列中取出一个任务执行，再次检查微任务队列。这样循环执行，直到所有的任务都被执行完毕。

**实际例子：**

```js
console.log("Start");

setTimeout(function () {
  console.log("Timeout");
}, 0);

Promise.resolve().then(function () {
  console.log("Promise");
});

console.log("End");
```

上述例子中，首先打印`"Start"`，打印`"End"`，然后进入事件循环。微任务队列中有一个`Promise`，因此执行`Promise`中的回调函数，打印`"Promise"`。接着，检查宏任务队列，发现`setTimeout`任务，将其推入调用栈执行，打印`"Timeout"`。这展示了事件循环中微任务和宏任务的执行顺序。

通过清晰地解释调用栈、任务队列、事件循环的不同阶段和执行顺序，你可以向面试官展示对事件循环的深刻理解。

如何理解事件循环

> 在比特币ETF通过后，比特币冲高4.9w后跳水回落，随着灰度GBTC持续的抛售，进入为期两周的回调。触及3.85w左右反弹，目前价格4.33w。这轮回调的底被我抄到了。





## 这轮回调的原因？

![824690c26f5e3e45479b87be0446785.png](https://creatorblog.cn/static/img/2f71a7f656ff01117917d9b6164eac4d.824690c26f5e3e45479b87be0446785.webp)

比特币现货ETF的利好兑现后，获利盘套利，本就无可厚非，但是大家盯着每个交易日灰度的GBTC持续转出数以万计的BTC到CoinBase交易所，陷入了沉思...

灰度究竟要干嘛？难道灰度不玩了，要砸盘到底？

灰度是聪哥之下的第二大BTC持仓主体，在抛售前持仓约60w枚BTC，经历两周持续的抛售后，已不足50w枚。

其实并不是灰度执意要卖，灰度只是一个机构，不是个人，他持仓的60W枚BTC大部分都不是自己的钱，是投资者真金白银买入的，只是让灰度代持有而已。

这轮灰度的抛售其实有三个主要原因。

1. 原GBTC信托基金低成本买家套利离场。

投资者的常用手段，没什么好评价的，我之前低位入场的，现在已知利好兑现完了，我的获利达到了顶峰，卖掉落袋为安，很合理。

2. GBTC转现货ETF后，手续费太高，投资者离场寻找其它低手续费的ETF机构。

SEC在2024年1月11日通过了11家比特币现货ETF的申请，在这11家机构里，GBTC的手续费是最高的。在现货ETF通过之前，灰度具有其机构垄断性，贵点也合理，但是现在这么多像贝莱德这种大机构都入场了，而且人家手续费比你低好几倍，这种条件下，似乎GBTC不具备优势。

3. 暴雷的FTX交易所抛售其持有的所有GBTC持仓股票。

FTX作为前龙头交易所，在暴雷后，这些监管机构天天都在想，怎么让FTX吐出更多的钱偿还投资者，FTX自己也在想，怎么获得更多的现金储备，蓄意东山再起。

除了FTX持有的大量加密资产，其在位时投资的东西，都可以在合适的时机利益最大化变卖。FTX曾持有2200万股GBTC的股票，在前几天已清零。所以，灰度这轮抛售最大的背后推手是FTX的破产清算。

随着其余几年ETF机构，近期交易日的资金持续流入，加上灰度流出的量在逐渐变少。市场似乎已经可以完全消化掉这轮抛售了。

## 什么时候抄底？

在这两周回调的中后期，BTC其实一直在4w左右的价位上，上上下下了几天，最低到了3.85w，我看着灰度每个交易日都在转出，雷打不动，我也尝试做空了几天，发现BTC站稳4w后形成底背离的局面，我其实就看出来多头的底线就到这里了，ETF的买盘还是很给力的，我就立刻出掉了空单，观察准备抄底。

我观察了几个自选的优质Token的K线发现，似乎都到了上涨趋势箱体内的底部。可以对照BTC的K线来观察。


![1706622510237.png](https://creatorblog.cn/static/img/c6eb21ba1b3ad6c004a43e992baeafce.1706622510237.webp)


![1706622548836.png](https://creatorblog.cn/static/img/b2a7ae58454af867cfa558fb99606a24.1706622548836.webp)


我分别抄底了JTO、Inj、Storj、ADA、CRV。基本都在3天内浮盈10个点到接近30个点。


![1706622864441.png](https://creatorblog.cn/static/img/a92115018b9cb1ca026c537c1f68a054.1706622864441.webp)


![1706622883618.png](https://creatorblog.cn/static/img/47c795238d75eccc2b5f28aa863f66a7.1706622883618.webp)



![1706622903504.png](https://creatorblog.cn/static/img/a1cce0f3c597419898d12c0c0e564b98.1706622903504.webp)



![1706622916108.png](https://creatorblog.cn/static/img/685804badbc009136754091e44f90ae5.1706622916108.webp)


我们在买一些优质山寨Token时，一定要密切观察BTC的走势，BTC有2个点以上的浮动，95%的Token都要受影响。如果买的ETH系的，如SSV、OP、ARB，就同理密切观察ETH的走势。

大盘不稳（BTC/ETH）时，不要冒险买入，比如BTC突然短时间涨了2个点，但是你看到其它Token还没动，你这个时间抄底，就是在赌博，因为BTC很可能在你抄底其它山寨后，再闪跌回去，所以重点是走势稳定。


## 对后续走势怎么看？

其实最近BTC的回调，没有任何其它利空，就是单纯的市场抛售，只不过灰度带着兄弟们力度稍微大了一点。

现在BTC再次站到4.3w左右的关卡，两个月内我不认为他会再次冲击上波4.9w的高点，因为没有动力。应该是一个缓慢上涨的时期，在4.2—4.8之间上上下下游荡，再次冲高至少得等ETH的坎昆升级结束。

这段时期是山寨井喷的时期，因为BTC站稳了一个上涨区间，那些观望大盘的山寨资金会陆续买入其喜欢的山寨。

在选择性购入山寨的时，一定要密切观察大盘的走向，因为近期BTC的ETF在持续流入可观的资金，这是好事也是坏事，有新资金入场能带来市场流动性尝试冲高，但是BTC价格回到可观价位后，这些机构可能会一起收割继续抛售。因为投资者买ETF也是要赚钱的，有流入就会有流出，现在流入的越多，后面抛售的压力越大。最近只是一家灰度在抛，如果11家都抛是什么局面呢？

在市场进入贪婪的时期后，要保持理性，价位越高危机越大。

## 总结

投资有风险，入市需谨慎，Token风险巨大，建议还是相信国运，持续买入A股~

这轮回调的底被我抄到了

> 本文将重点介绍useRef这个Hook，它可以让你在组件的整个生命周期中访问一个可变的引用对象。





`useRef`的主要用途是直接访问`DOM`子元素，但这并不是它的唯一用途。`useRef`也可以用来保存一个在不同渲染中不变的可变值，例如在使用一些非`React`的外部库时很有用。本文将介绍`useRef`的基本使用，实现原理，最佳实践和一些常见的问题。

## 基本使用

要在组件中创建一个新的引用，可以使用以下代码：

```js
// 创建一个引用
const yourRef = useRef();
```

你也可以选择用一个默认值来初始化它，只需将它作为参数传递给`useRef`即可：

```js
// 创建一个引用
const yourRef = useRef('hello world');
```

`useRef`是一个`Hook`，因此只能在函数组件中使用！

要获取和设置引用的值，你可以访问对象的`.current`属性，如下所示：

```js
// 创建一个引用
const exampleRef = useRef();

// 设置引用的值
exampleRef.current = "Hello World";

// 访问引用的值：
// 这会在控制台打印"Hello World"
console.log(exampleRef.current);
```

要访问一个`DOM`元素，你可以创建一个引用，然后使用它的`ref`属性将它分配给你想要目标的`DOM`元素，然后你就可以使用它了。

例如，假设你想要获取一个`DOM`元素的像素高度。要做到这一点，你必须访问`DOM`元素的`offsetHeight`属性。但是如何获取`DOM`元素呢？当然是用一个引用。

```js
import { useEffect, useRef } from "react";

export default function App() {
  // 创建一个引用
  const divElement = useRef();

  // 在组件第一次渲染时触发
  useEffect(() => {
    // 获取div元素的高度
    console.log("The height of the div is: ", divElement.current.offsetHeight);
  }, []);

  return (
    <div ref={divElement}>
      <h1>Learn about useRef!</h1>
    </div>
  );
}
```


在上面的例子中，我使用了`useEffect`来确保只有在组件第一次渲染后才调用`divElement.current.offsetHeight`。事实上，一开始，引用是`undefined`的，只有当组件渲染并且`div`被创建后，它才会持有它的`DOM`元素值。你可以看到，使用引用可能有些棘手，你必须记住一些事情。

## 实现原理

要理解`useRef`的工作原理，我们需要先了解一些`React`的基础知识。

`React`是一个用于构建用户界面的库，它通过一个虚拟的`DOM`来管理真实的`DOM`。虚拟`DOM`是一个`JavaScript`对象，它表示真实的`DOM`结构，但是更轻量级和高效。`React`使用虚拟`DOM`来跟踪组件的状态和属性，然后根据需要更新真实的`DOM`。

当你在组件中使用`useState`或`useReducer`等`Hook`来管理状态时，你实际上是在更新虚拟`DOM`中的状态。每当状态发生变化时，`React`都会重新渲染组件，并将新的虚拟`DOM`与旧的虚拟`DOM`进行比较，找出差异，然后将这些差异应用到真实的`DOM`上。这个过程被称为协调`（reconciliation）`。

但是，有时候你可能不想让`React`管理你的状态，而是想直接操作真实的`DOM`。这可能是因为你需要使用一些非`React`的库，或者你需要访问一些`React`无法提供的`DOM`属性或方法。这时候，你就可以使用引用`（ref）`来实现。

`useRef`的基本实现原理其实很简单，它就是利用了`JavaScript`的闭包和对象引用的特性，来创建一个只有一个`current`属性的对象，然后将这个对象保存在一个变量中，这个变量在每次渲染时都会被复用，而不会被重新赋值。我们可以用下面的伪代码来模拟`useRef`的实现：

```js
// 定义一个变量，用来存储ref对象
let ref;

// 定义useRef函数，接收一个初始值作为参数
function useRef(initialValue) {
  // 如果ref不存在，就创建一个新的对象，将初始值赋给它的current属性
  if (!ref) {
    ref = { current: initialValue };
  }
  // 返回ref对象
  return ref;
}
```

可以看到，`useRef`函数只会在第一次调用时创建一个新的对象，然后将它赋值给`ref`变量，之后的调用都会返回这个变量，而不会创建新的对象。这样，我们就可以在组件的不同渲染之间保持一个可变的值，而不用担心它会被重新创建或销毁。

引用是一个对象，它有一个`.current`属性，可以指向任何你想要的值。当你创建一个引用时，`React`会将它保存在一个内部的数据结构中，这个数据结构不会随着组件的重新渲染而改变。这意味着，你可以在组件的整个生命周期中访问同一个引用对象，而不用担心它会丢失或改变。

当你将一个引用分配给一个`DOM`元素时，`React`会在渲染时将该元素的实例赋值给引用的`.current`属性。这样，你就可以通过引用来直接访问该元素，而不需要通过虚拟`DOM`或其他方式。你也可以在任何时候修改引用的值，而不会触发组件的重新渲染，因为引用不是一个状态，而是一个可变的容器。


## 最佳实践

`useRef`是一个非常有用的`Hook`，但是也有一些注意事项和最佳实践，我们应该遵守，以避免一些潜在的问题和错误。下面列举了一些常见的最佳实践：

- 尽量避免直接操作DOM，除非React没有提供相应的API。直接操作DOM会破坏React的声明式编程范式，导致组件的状态和DOM的状态不一致，可能引发一些难以发现和解决的bug。如果我们需要对DOM元素进行一些操作，我们应该优先考虑使用React提供的API，比如ref、state、props、effect等，只有当这些API都不能满足我们的需求时，我们才可以使用useRef来直接操作DOM。
- 使用useRef来存储一些不会触发组件重新渲染的值，比如定时器、订阅、外部库的实例等。这些值在组件的不同渲染之间保持不变，而且不会影响组件的渲染，因此使用useRef来存储它们是合适的。如果我们使用useState来存储这些值，那么每次修改它们的值都会触发组件的重新渲染，这是不必要的，而且会影响性能。
- 不要使用useRef来存储一些会触发组件重新渲染的值，比如状态、数据、计算结果等。这些值在组件的不同渲染之间可能会发生变化，而且会影响组件的渲染，因此使用useRef来存储它们是不合适的。如果我们使用useRef来存储这些值，那么当它们的值发生变化时，组件不会重新渲染，这会导致组件的状态和界面不一致，可能引发一些难以发现和解决的bug。我们应该使用useState或useReducer来存储这些值，这样当它们的值发生变化时，组件会重新渲染，保持状态和界面的一致性。
- 在组件卸载时，清除使用useRef存储的一些需要清理的值，比如定时器、订阅、外部库的实例等。这些值在组件卸载后，可能会继续运行或占用资源，导致内存泄漏或其他问题。我们应该使用useEffect来在组件卸载时，清除这些值，释放资源，避免潜在的问题。例如，如果我们使用useRef来存储一个定时器，我们应该在useEffect的返回函数中，清除这个定时器，代码如下：

```js
// 使用useRef存储一个定时器
const timer = useRef();

// 在组件卸载时，清除定时器
useEffect(() => {
  return () => {
    clearInterval(timer.current);
  };
}, []);
```

- 不要混淆useRef和createRef。useRef和createRef都可以用来创建ref对象，但它们的行为和用途有一些区别。useRef是一个Hook，只能在函数组件中使用，它会在每次渲染时返回同一个ref对象，因此可以用来在组件的不同渲染之间保持一个可变的值。createRef是一个方法，可以在类组件和函数组件中使用，它会在每次调用时返回一个新的ref对象，因此只能用来访问DOM元素或子组件的实例，不能用来在组件的不同渲染之间保持一个可变的值。我们应该根据不同的场景，选择合适的方法来创建ref对象，避免混淆它们的行为和用途。


## 总结

`useRef`是一个非常强大和有用的`Hook`，它可以让我们直接访问和操作`DOM`元素，以及在组件的不同渲染之间保持一个可变的值。

它的实现原理很简单，就是利用了`JavaScript`的闭包和对象引用的特性，来创建一个只有一个`current`属性的对象，然后将这个对象保存在一个变量中，这个变量在每次渲染时都会被复用，而不会被重新赋值。

我们在使用`useRef`时，应该遵守一些注意事项和最佳实践，以避免一些潜在的问题和错误。`useRef`与其他`Hook`，比如`useState`、`useEffect`、`useCallback`等，有着不同的功能和优势，我们应该根据不同的场景，选择合适的`Hook`来实现我们的需求，从而提高我们的代码的可读性、可维护性和性能。

React Hooks大全—useRef

> 2023年是难过的一年，在经济下行周期内，作为互联网打工人，很明显感觉到时过境迁、物是人非，互联网行业究竟为何变得如何这般？




## 前言

先自我介绍一下，我是一名00后前端程序员，在北京工作，全职工作经验一年半左右，全网2.5w+粉丝，博文访问量500w+。

互联网行业在最近两年发生了巨变，我的感受很深刻。2021年还在实习的时候，试着找校招工作，给我的感觉就是，投简历就有人约面试，参加了面试就能过，很轻松就能获得一些还不错的offer，也通过了京东和滴滴的技术面。

但是，在疫情中的2022年，我离开实习公司，正式开始找校招工作的时候，就发现似乎市场变了。面试不好约了，offer价格也低了，甚至市场掀起了大规模的毁约潮，我也被各种形式的毁约了n次。后来去了一家初创公司，先安于现状。

2022年下半年到2023年底，市场变的疯狂，裁员成为了热词，上到超级大厂，下到初创公司，似乎每天都在经历着裁员。

所有人似乎都想知道，why？为什么互联网一夜之间成了这样？

## 什么原因导致了现在的互联网市场

我说一下我的看法，我觉得影响最大的就两点：

1. 经济不好。

虽然2023年官方统计GDP增速5.2%，但是似乎资本和大家普通人都不买账。

CPI降了，PPI降了，出口降了，楼市降了，股市崩了，但是GDP稳步增长，其实从这里就可以看出，5.2%的GDP增速，并没有对大家带来实际利好。也不要看着这5.2%的基本面增速，觉得以后的生活会慢慢变好。5.2%统计的是2023年，2023年的生活有没有变好，身处一线的大家都能感受到。

所以，经济不好，导致很多的中小公司的运作坚持不下去，纷纷离场，或者裁员保本。`（可以查下官方数据，2023年倒闭的公司是历史新高。）`然后大公司为了保证自己的利润和市场竞争力，选择留存更多的现金，进行规模不等的裁员，削减成本。

2. 没有增量业务。

这个是我认为对互联网行业的必杀技。

互联网高速发展了10多年，前中期是有做不完的业务，因为所有东西都是新的，社交、游戏、电商、短视频，在当时都是新赛道、新业务、新需求，这些都需要堆巨量的人来完成，同时为了和竞品竞争，会自己卷自己，所以更需要更多人来卷速度了。

但是，到了2023年，除了ChatGPT的出现，没有任何其它的大规模增量业务`（小规模的局部业务不谈，因为无法对整个市场造成影响）`。各大电商卷“百亿补贴”，各大短视频平台卷推荐算法，社交平台卷重构`（据说QQ各个端的UI、业务代码、系统架构都重构一遍了）`都是在现有业务内卷细节，几乎不需要新鲜人力。

ChatGPT这个确实是个体量很大的增量业务，但是因为众所周知的原因，无法来到国内市场，无法落地应用，所以带不来对国内市场实际的增量需求，至于像百度这些公司在卷的大模型，不过多评价，市场会给出答案，影响很小。

没有增量业务，就意味着不需要堆巨量的人力来写需求和卷速度了，那之前十多年招进来的这么多人，怎么处理？当然是裁掉了，因为这拨人无法带来与其体量相匹配的增长了。

比如某公司5年招聘了1w个员工来写业务，写到现在没有新业务写了，经济不好导致现金流又吃紧，可能留下来1000人维护现有系统和小业务迭代就足矣。`（1000人都说多了，后期的维护和早期的赶进度，所需要的人力是天差地别的）`。

以上两点，是我总结目前对互联网行业影响最大的因素，小因素肯定还有很多。

## 对2024年的预期

我的看法是，会长期通缩，不会比2023年好，依然看不到互联网行业有新鲜血液进来，无法带来有效的岗位需求。经济上，只可能更差，从美国那边的选举来看，川普这次很稳`（除非被刺杀）`，近些年国内经济变差很大的原因，就是当初川普在任时发动的对中国贸易战，对国内经济影响很大，但是对美国的影响可控，美元还是太强了。`（PS：美股QQQ（纳斯达克指数）在前几天又创下了历史新高，经济好的不要太好，反观国内A股，跌跌不休）`。

## 对已经进入和即将进入互联网的人有什么建议

已经进入的：心态保持稳定，多攒钱`（因为国内在通缩）`，少投资`（除非你能买美股或Token）`，没事出去旅旅游，房子车子没上车的这几年先不要考虑了，晚买一年就少亏一年，多找时间学习提升自己，无论在什么时期，高级开发都是有绝对市场的。现在对高级开发的界定，可不是只有工作年限了，倚老卖老不好使，得有让市场认可的实力。

即将进入的：先问问自己是否真的适合这个行业，不要硬进，不要光看光鲜亮丽的工资。这个时期不要花过万的钱去培训，早几年培训出来会写个vue，能写写管理系统就有人要，现在行情天差地别，时代不同了。及时止损，发现不合适早点转行。


## 互联网行业还有第二春吗

这个不好评价，即使互联网目前身处寒冬，平均薪资依然是众行业的龙头。我认为互联网行业的第二春什么时候来，取决于我上面提到的`【经济、增量业务】`。

等经济好了，什么虾兵蟹将都敢出来创创业、烧烧钱了，也就能带动岗位的需求。

有影响整个市场的增量业务，资本就会买单`（美股英伟达、微软受2023年AI元年影响，日日都是新高）`，会有新钱进入市场，同样能带来岗位的的需求。

## 总结

临近春节，身处互联网一线的打工人，要在茶余饭后，对行业有个整体的判断和认识，给自己留好充足的容错率`（大不了就淀粉肠搞起来，滴滴已经饱和了~~~）`。


> 个人博客：https://creatorblog.cn
最近比较看好Web3市场，有在职或门路的欢迎私聊讨论
WX：18331092918

互联网为何变得如此这般

> 在本文中，我们将重点介绍useContext这个Hook，它可以让你在函数组件中轻松地访问React Context，从而实现跨组件的状态共享。我们将从基本使用，实现原理，最佳实践，以及一些常见的问题和解决方案来探讨useContext的用法和优势。我们还将给出一些必要的代码示例，帮助你更好地理解和应用useContext。




## 基本使用

`React Context`是一种在组件树中传递数据的机制，它可以让你在任何层级的组件中访问同一个数据，而不需要通过`props`逐层传递。这对于一些全局的状态，比如主题，语言，用户信息等，非常有用。

要使用`React Context`，你需要先创建一个`Context`对象，然后在根组件中使用`Context.Provider`组件来提供一个`Context`值，最后在任何子组件中使用`Context.Consumer`组件来消费这个值。例如：

```js
// 创建一个Context对象
const ThemeContext = React.createContext('light');

// 在根组件中使用Provider提供一个Context值
class App extends React.Component {
  render() {
    return (
      <ThemeContext.Provider value="dark">
        <Toolbar />
      </ThemeContext.Provider>
    );
  }
}

// 在子组件中使用Consumer消费Context值
function Toolbar(props) {
  return (
    <div>
      <ThemedButton />
    </div>
  );
}

function ThemedButton() {
  return (
    <ThemeContext.Consumer>
      {value => <Button theme={value} />}
    </ThemeContext.Consumer>
  );
}
```

这种方式虽然可以实现`Context`的访问，但是有一些缺点：

- 每次使用Context值，都需要引入一个Consumer组件，这会增加组件树的层级和复杂度。
- 如果一个组件需要访问多个Context，那么就需要嵌套多个Consumer组件，这会导致代码的可读性和维护性降低。
- Consumer组件需要使用一个函数作为子元素，这会导致每次渲染都会创建一个新的函数，这会影响性能和内存的使用。

为了解决这些问题，`React Hooks`提供了一个`useContext`这个`Hook`，它可以让你在函数组件中直接访问`Context`值，而不需要使用`Consumer`组件。

`useContext`的用法非常简单，只需要传入一个`Context`对象，就可以返回这个`Context`的当前值。例如：

```js
// 创建一个Context对象
const ThemeContext = React.createContext('light');

// 在根组件中使用Provider提供一个Context值
function App() {
  return (
    <ThemeContext.Provider value="dark">
      <Toolbar />
    </ThemeContext.Provider>
  );
}

// 在子组件中使用useContext访问Context值
function Toolbar(props) {
  return (
    <div>
      <ThemedButton />
    </div>
  );
}

function ThemedButton() {
  // 使用useContext获取Context值
  const theme = useContext(ThemeContext);
  return <Button theme={theme} />;
}
```


可以看到，使用`useContext`后，代码变得更加简洁，清晰，易读。`useContext`的优点有：

- 不需要使用Consumer组件，减少了组件树的层级和复杂度。
- 可以在一个组件中访问多个Context，只需要多次调用useContext即可，不需要嵌套Consumer组件。
- 不需要使用函数作为子元素，避免了每次渲染都创建新的函数的问题，提高了性能和内存的使用。

## 实现原理

要理解`useContext`的实现原理，我们首先需要了解一下`React Context`的实现原理。`React Context`是基于发布订阅模式的，它的核心思想是：

- 创建一个Context对象，它包含了一个Provider组件和一个Consumer组件，以及一些内部的属性和方法。
- Provider组件接收一个value属性，它会将这个value保存在Context对象的内部属性中，并且将自己的实例添加到Context对象的订阅者列表中。
- Consumer组件会从Context对象的内部属性中读取value，并且将自己的实例添加到Context对象的订阅者列表中。
- 当Provider组件的value属性发生变化时，它会触发Context对象的更新方法，这个方法会遍历订阅者列表，通知所有的订阅者重新渲染，从而获取最新的value。

基于这个原理，我们可以简单地实现一个自定义的`Context`，代码如下：

```js
// 创建一个自定义的Context对象
function createContext(defaultValue) {
  // 定义一个Context类，它的实例就是一个Context对象
  class Context {
    // 构造函数，接收一个默认值
    constructor(defaultValue) {
      // 初始化内部属性
      this.value = defaultValue; // 保存当前的Context值
      this.subscribers = []; // 保存订阅者列表
    }

    // 定义一个Provider组件，它接收一个value属性
    Provider = props => {
      // 将value属性保存在Context对象的内部属性中
      this.value = props.value;
      // 将Provider组件的实例添加到订阅者列表中
      this.subscribers.push(this);
      // 返回一个普通的div元素，渲染子元素
      return <div>{props.children}</div>;
    };

    // 定义一个Consumer组件，它接收一个函数作为子元素
    Consumer = props => {
      // 从Context对象的内部属性中读取value
      const value = this.value;
      // 将Consumer组件的实例添加到订阅者列表中
      this.subscribers.push(this);
      // 返回一个普通的div元素，渲染子元素，传入value作为参数
      return <div>{props.children(value)}</div>;
    };

    // 定义一个更新方法，它会遍历订阅者列表，通知所有的订阅者重新渲染
    update = () => {
      for (let subscriber of this.subscribers) {
        subscriber.forceUpdate();
      }
    };
  }

  // 返回一个Context对象的实例
  return new Context(defaultValue);
}
```


有了这个自定义的`Context`，我们就可以像使用`React Context`一样使用它，例如：

```js
// 创建一个自定义的Context对象
const ThemeContext = createContext('light');

// 在根组件中使用Provider提供一个Context值
function App() {
  const [theme, setTheme] = useState('light');
  return (
    <ThemeContext.Provider value={theme}>
      <h1>Current theme: {theme}</h1>
      <button onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}>
        Toggle theme
      </button>
      <Toolbar />
    </ThemeContext.Provider>
  );
}

// 在子组件中使用useContext访问Context值
function Toolbar(props) {
  return (
    <div>
      <ThemedButton />
    </div>
  );
}

function ThemedButton() {
  // 使用useContext获取Context值
  const theme = useContext(ThemeContext);
  return <Button theme={theme} />;
}

```

可以看到，这个自定义的`useContext`也可以正常地工作，当我们点击切换主题的按钮时，`ThemedButton`组件会根据`Context`值的变化而重新渲染。

## 最佳实践

使用`useContext`可以让你在函数组件中轻松地访问`Context`值，但是也有一些注意事项和最佳实践，我们在这里总结一下：

- 尽量避免在Context中存储过多的数据，因为每次Context值变化，所有的订阅者都会重新渲染，这会影响性能。如果你需要存储一些复杂的状态，可以考虑使用useReducer或者Redux等状态管理库。
- 尽量避免在Context中存储一些不稳定的数据，比如函数，对象，数组等，因为每次渲染都会创建新的引用，这会导致Context值的不必要的变化，从而触发订阅者的重新渲染。如果你需要在Context中传递一些函数，可以考虑使用useCallback来缓存函数的引用，避免每次渲染都创建新的函数。
- 尽量避免在Context中存储一些不相关的数据，比如主题，语言，用户信息等，因为这些数据的变化可能是独立的，但是如果放在同一个Context中，就会导致所有的订阅者都重新渲染，即使他们只关心其中的一部分数据。如果你需要在Context中传递一些不相关的数据，可以考虑使用多个Context，每个Context只负责一种数据，这样可以减少不必要的渲染。

## 总结

`useContext`是`React Hooks`提供的一个强大的`Hook`，它可以让你在函数组件中直接访问`Context`值，而不需要使用`Consumer`组件。`useContext`的用法非常简单，只需要传入一个`Context`对象，就可以返回这个`Context`的当前值。`useContext`的优点有：

- 不需要使用Consumer组件，减少了组件树的层级和复杂度。
- 可以在一个组件中访问多个Context，只需要多次调用useContext即可，不需要嵌套Consumer组件。
- 不需要使用函数作为子元素，避免了每次渲染都创建新的函数的问题，提高了性能和内存的使用。

`useContext`的实现原理也非常简单，它只需要做两件事：

- 从Context对象的内部属性中读取value，并返回给函数组件。
- 在函数组件的渲染过程中，将函数组件的实例添加到Context对象的订阅者列表中，以便在Context值变化时，能够触发函数组件的重新渲染。

使用`useContext`时，也有一些注意事项和最佳实践，我们总结了一下：

- 尽量避免在Context中存储过多的数据，因为每次Context值变化，所有的订阅者都会重新渲染，这会影响性能。
- 尽量避免在Context中存储一些不稳定的数据，比如函数，对象，数组等，因为每次渲染都会创建新的引用，这会导致Context值的不必要的变化，从而触发订阅者的重新渲染。
- 尽量避免在Context中存储一些不相关的数据，比如主题，语言，用户信息等，因为这些数据的变化可能是独立的，但是如果放在同一个Context中，就会导致所有的订阅者都重新渲染，即使他们只关心其中的一部分数据。

React Hooks大全—useContext

欢迎来到我的博客，这里是我分享前端、web3、理财、互联网等方面的知识和心得的地方。我是一名热爱编程的前端程序员，我希望通过我的博客能够帮助更多的人学习和进步。在这里，你可以找到最新最实用的前端技术教程，了解最前沿的互联网动态和趋势，掌握最有效的理财方法和策略。我也会不定期地发布一些个人项目和作品，展示我的创意和能力。如果你对我的博客感兴趣，欢迎你留言、评论、收藏、关注，也可以通过邮箱或社交媒体与我联系，交流学习和合作。谢谢你的支持！