关于php:不优雅的-React-Hooks

时至 2021 年年底，React Hooks 已在 React 生态中大放异彩，席卷了简直所有的 React 利用。而其又与 Function Component 以及 Fiber 架构几近天作之合，在当下，咱们如同毫无回绝它的情理。

诚然，Hooks 解决了 React Mixins 这个老大难的问题，但从它各种奇怪的应用体验上来说，我认为现阶段的 Hooks 并不是一个好的形象。

红脸太常见，也来唱个黑脸，本文将站在一个「挑刺儿」的视角，聊聊我眼中的 React Hooks ~

「奇怪的」规矩
React 官网制订了一些 Hooks 书写标准用来躲避 Bug，但这也恰好裸露了它存在的问题。

命名
Hooks 并非一般函数，咱们个别用 use 结尾命名，以便与其余函数辨别。

但相应地，这也毁坏了函数命名的语义。固定的 use 前缀使 Hooks 很难命名，你既为 useGetState 这样的命名感到困惑，也无奈了解 useTitle 到底是怎么个 use 法儿。

相比较而言，以_结尾的公有成员变量和 $ 尾缀的流，则没有相似的困扰。当然，这只是应用习惯上的差别，并不是什么大问题。

调用时序
在应用 useState 的时候，你有没有过这样的纳闷：useState 尽管每次 render()都会调用，但却能够为我放弃住 State，如果我写了很多个，那它怎么晓得我想要的是什么 State 呢？

const [name, setName] = useState(‘xiaoming’)
console.log(‘some sentences’)
const [age, setAge] = useState(18)
复制代码
两次 useState 只有参数上的区别，而且也没有语义上的辨别（咱们仅仅是给返回值赋予了语义），站在 useState 的视角，React 怎么晓得我什么时候想要 name 而什么时候又想要 age 的呢？

以下面的示例代码来看，为什么第 1 行的 useState 会返回字符串 name，而第 3 行会返回数字 age 呢? 毕竟看起来，咱们只是「平平无奇」地调用了两次 useState 而已。

答案是「时序」。useState 的调用时序决定了后果，也就是，第一次的 useState「保留」了 name的状态，而第二次「保留」了 age 的状态。

// Class Component 中通过字面量申明与更新 State，无一致性问题
this.setState({
name: ‘xiaoming’, // State 字面量 name,age
age: 18,
})
复制代码
React 简略粗犷地用「时序」决定了这所有（背地的数据结构是链表），这也导致 Hooks 对调用时序的严格要求。也就是要防止所有的分支构造，不能让 Hooks「时有时无」。

// ❌ 典型谬误
if (some) {
const [name, setName] = useState(‘xiaoming’)
}
复制代码
这种要求齐全依赖开发者的教训抑或是 Lint，而站在个别第三方 Lib 的角度看，这种要求调用时序的 API 设计是极为常见的，十分反直觉。

最现实的 API 封装该当是给开发者认知累赘最小的。好比封装一个纯函数 add()，不管开发者是在什么环境调用、在如许深的层级调用、用什么样的调用时序，只有传入的参数符合要求，它就能够失常运作，简略而纯正。

function add(a: number, b: number) {
return a + b
}

function outer() {
const m = 123;
setTimeout(() => {

request('xx').then((n) => {const result = add(m, n)         // 合乎直觉的调用：无环境要求
})

}, 1e3)
}
复制代码
能够说「React 的确没方法让 Hooks 不要求环境」，但也不能否定这种形式的怪异。

相似的状况在 redux-saga 里也有，开发者很容易写出上面这种「合乎直觉」的代码，而且怎么也「看」不出有问题。

import {call} from ‘redux-saga/effects’

function* fetch() {
setTimeout(function* () {

const user = yield call(fetchUser) 
console.log('hi', user)                  // 不会执行到这儿

}, 1e3)
}
复制代码
yield call() 在 Generator 里调用，看起来真的很「正当」。但实际上，function* 须要 Generator 执行环境，而 call 也须要 redux-saga 的执行环境。双重要求之下，实例代码天然无奈失常运行。

useRef 的「排除万难」
从转义上来说，useRef 其实是 Class Component 时代 React.createRef()的等价代替。

官网文档中最开始的示例代码能够佐证这一点（如下所示，有删减）：

function TextInputWithFocusButton() {
const inputEl = useRef(null);
return (

<input ref={inputEl} type="text" />

);
}
复制代码
但因为其实现非凡，也常作他用。

React Hooks 源码中，useRef 仅在 Mount 期间初始化对象，而 Update 期间返回 Mount 期间的后果（memoizedState）。这意味着一次残缺的生命周期中，useRef保留的援用始终不会扭转。

而这一特点却让它成为了 Hooks 闭包救星。

「遇事不决，useRef！」（useRef 存在许多滥用的状况，本文不多赘述）

每一个 Function 的执行都有与之相应的 Scope，对于面向对象来说，this 援用即是连贯了所有 Scope 的 Context（当然前提是在同一个 Class 下）。

class Runner {
runCount = 0

run() {

console.log('run')
this.runCount += 1

}

xrun() {

this.run()
this.run()
this.run()

}

output() {

this.xrun()
// 即使是「间接调用」`run`，这里「依然」能获取 `run` 的执行信息
console.log(this.runCount) // 3

}
}
复制代码
在 React Hooks 中，每一次的 Render 由彼时的 State 决定，Render 实现 Context 即刷新。优雅的 UI 渲染，洁净而利落。

但 useRef 多少违反了设计者的初衷，useRef 能够横跨屡次 Render 生成的 Scope，它能保留下已执行的渲染逻辑，却也能使已渲染的 Context 得不到开释，威力无穷却也作恶多端。

而如果说 this 援用是面向对象中最次要的副作用，那么 useRef 亦同。从这一点来说，领有 useRef 写法的 Function Component 注定难以达成「函数式」。

小心应用
有缺点的生命周期
结构时
Class Component 和 Function Component 之间还有一个很大的「Bug」，Class Component 仅实例化一次后续仅执行render()，而 Function Component 却是在一直执行本身。

这导致 Function Component 相较 Class Component 理论缺失了对应的 constructor 结构时。当然如果你有方法只让 Function 里的某段逻辑只执行一遍，倒是也能够模拟出 constructor。

// 比方应用 useRef 来结构
function useConstructor(callback) {
const init = useRef(true)
if (init.current) {

callback()
init.current = false

}
}
复制代码
生命周期而言，constructor 不能类同 useEffect，如果理论节点渲染时长较长，二者会有很大时差。

也就是说，Class Component 和 Function Component 的生命周期 API 并不能齐全一一对应，这是一个很引发谬误的中央。

设计凌乱的 useEffect
在理解 useEffect 的根本用法后，加上对其字面意思的了解（监听副作用），你会误以为它等同于 Watcher。

useEffect(() => {
// watch 到 a 的变动
doSomething4A()
}, [a])
复制代码
但很快你就会发现不对劲，如果变量 a 未能触发 re-render，监听并不会失效。也就是说，理论还是应该用于监听 State 的变动，即 useStateEffect。但参数 deps 却并未限度仅输出 State。如果不是为了某些非凡动作，很难不让人认为是设计缺点。

const [a] = useState(0)
const [b] = useState(0)

useEffect(() => {

// 假设此处为 `a` 的监听

}, [a])

useEffect(() => {

// 假设此处为 `b` 的监听

// 理论即使 b 未变动也并未监听 a，但此处依然因为会因为 a 变动而执行
}, [b, Date.now()]) // 因为 Date.now() 每次都是新的值
复制代码
useStateEffect 的了解也并不到位，因为 useEffect 理论还负责了 Mount 的监听，你须要用「空依赖」来辨别 Mount 和 Update。

useEffect(onMount, [])
复制代码
繁多 API 反对的能力越多，也意味着其设计越凌乱。简单的性能不仅考验开发者的记忆，也难于了解，更容易因谬误了解而引发故障。

useCallback
性能问题?
在 Class Component 中咱们经常把函数绑在 this 上，放弃其的惟一援用，以缩小子组件不必要的重渲染。

class App {
constructor() {

// 办法一
this.onClick = this.onClick.bind(this)

}
onClick() {

console.log('I am `onClick`')

}

// 办法二
onChange = () => {}

render() {

return (<Sub onClick={this.onClick} onChange={this.onChange} />
)

}
}
复制代码
在 Function Component 中对应的计划即useCallback：

// ✅ 无效优化
function App() {
const onClick = useCallback(() => {

console.log('I am `onClick`')

}, [])

return ()
}

// ❌ 谬误示范，onClick 在每次 Render 中都是全新的，_{会因而重渲染
function App() {
// … some states
const onClick = () => {}

console.log('I am `onClick`')

}

return ()
}
复制代码
useCallback 能够在多次重渲染中依然放弃函数的援用，第 2 行的 onClick 也始终是同一个，从而防止了子组件_{的重渲染。}

useCallback 源码其实也很简略：

Mount 期间仅保留 callback 及其依赖数组

Update 期间判断如果依赖数组统一，则返回上次的 callback

顺便再看看 useMemo的实现，其实它与 useCallback 的区别仅仅是多一步 Invoke：

有限套娃✓
相比拟未应用 useCallback 带来的性能问题，真正麻烦的是 useCallback 带来的援用依赖问题。

// 当你决定引入 useCallback 来解决反复渲染问题
function App() {
// 申请 A 所须要的参数
const [a1, setA1] = useState(”)
const [a2, setA2] = useState(”)
// 申请 B 所须要的参数
const [b1, setB1] = useState(”)
const [b2, setB2] = useState(”)

// 申请 A，并解决返回后果
const reqA = useCallback(() => {

requestA(a1, a2)

}, [a1, a2])

// 申请 A、B，并解决返回后果
const reqB = useCallback(() => {

reqA()                                             // `reqA` 的援用始终是最开始的那个，requestB(b1, b2)                       // 当 `a1`,`a2` 变动后 `reqB` 中的 `reqA` 其实是过期的。

}, [b1, b2]) // 当然，把 reqA 加到 reqB 的依赖数组里不就好了？

                                                           // 但你在调用 `reqA` 这个函数的时候，// 你怎么晓得「应该」要加到依赖数组里呢？

return (

<>
  <Comp onClick={reqA}></Comp>
  <Comp onClick={reqB}></Comp>
</>

)
}
复制代码
从下面示例能够看到，当 useCallback 之前存在依赖关系时，它们的援用保护也变得复杂。调用某个函数时要小心翼翼，你须要思考它有没有援用过期的问题，如有脱漏又没有将其退出依赖数组，就会产生 Bug。

Use-Universal
Hooks 百花齐放的期间诞生了许多工具库，仅 ahooks就有 62 个自定义 Hooks，真堪称「万物皆可 use」~ 真的有必要封装这么多 Hooks 吗？又或者说咱们真的须要这么多 Hooks 吗？

正当封装？
只管在 React 文档中，官网也倡议封装自定义 Hooks 进步逻辑的复用性。但我感觉这也要看状况，并不是所有的生命周期都有必要封装成 Hooks。

// 1. 封装前
function App() {
useEffect(() => { // useEffect 参数不能是 async function

(async () => {await Promise.all([fetchA(), fetchB()])
  await postC()})()

}, [])
return (<div>123</div>)
}
// ————————————————–

// 2. 自定义 Hooks
function App() {
useABC()
return (<div>123</div>)
}

function useABC() {
useEffect(() => {

(async () => {await Promise.all([fetchA(), fetchB()])
  await postC()})()

}, [])
}
// ————————————————–

// 3. 传统封装
function App() {
useEffect(() => {

requestABC()

}, [])
return (<div>123</div>)
}

async function requestABC() {
await Promise.all([fetchA(), fetchB()])
await postC()
}
复制代码
在下面的代码中，对生命周期中的逻辑封装为 HookuseABC 反而使其耦合了生命周期回调，升高了复用性。即使咱们的封装中不蕴含任何 Hooks，在调用时也仅仅是包一层 useEffect 而已，不算麻烦，而且让这段逻辑也能够在 Hooks 以外的中央应用。

如果自定义 Hooks 中应用到的 useEffect 和 useState 总次数不超过 2 次，真的应该想一想这个 Hook 的必要性了，是否能够不封装。

简略来说，Hook 要么「挂靠生命周期」要么「解决 State」，否则就没必要。

反复调用
Hook 调用很「反直觉」的就是它会随重渲染而不停调用，这要求 Hook 开发者要对这种重复调用有肯定预期。

正如上文示例，对申请的封装，很容易依赖 useEffect，毕竟挂靠了生命周期就能确定申请不会重复调。

function useFetchUser(userInfo) {
const [user, setUser] = useState(null)
useEffect(() => {

fetch(userInfo).then(setUser)

}, [])

return user
}
复制代码
但，useEffect 真的适合吗？这个机会如果是 DidMount，那执行的机会还是比拟晚的，毕竟如果渲染结构复杂、层级过深，DidMount 就会很迟。

比方，ul 中渲染了 2000 个 li：

function App() {
const start = Date.now()

useEffect(() => {

console.log('elapsed:', Date.now() - start, 'ms')

}, [])

return (

<ul>
  {Array.from({ length: 2e3}).map((_, i) => (<li key={i}>{i}</li>))}
</ul>

)
}

// output
// elapsed: 242 ms
复制代码
那不挂靠生命周期，而应用状态驱动呢？仿佛是个好主见，如果状态有变更，就从新获取数据，如同很正当。

useEffect(() => {
fetch(userInfo).then(setUser)
}, [userInfo]) // 申请参数变动时，从新获取数据
复制代码
但首次执行机会依然不现实，还是在 DidMount。

let start = 0
let f = false

function App() {
const [id, setId] = useState(‘123’)
const renderStart = Date.now()

useEffect(() => {

const now = Date.now()
console.log('elapsed from start:', now - start, 'ms')
console.log('elapsed from render:', now - renderStart, 'ms')

}, [id]) // 此处监听 id 的变动

if (!f) {

f = true
start = Date.now()
setTimeout(() => {setId('456')
}, 10)

}

return null
}

// output
// elapsed from start: 57 ms
// elapsed from render: 57 ms
// elapsed from start: 67 ms
// elapsed from render: 1 ms
复制代码
这也是上文为什么说 useEffect 设计凌乱，你把它当做 State Watcher 的时候，其实它还暗含了「首次执行在 DidMount」的逻辑。从字面意思 Effect 来看，这个逻辑才是副作用吧。。。

状态驱动的封装除了调用机会以外，其实还有别的问题：

function App() {
const user = useFetchUser({// 乍一看仿佛没什么问题

name: 'zhang',               
age: 20,

})

return (<div>{user?.name}</div>)
}
复制代码
实际上，组件重渲染会导致申请入参从新计算 -> 字面量申明的对象每次都是全新的 -> useFetchUser 因而不停申请 -> 申请变更了 Hook 内的 State user -> 外层组件 <App> 重渲染。

这是一个死循环！

当然，你能够用 Immutable 来解决同一参数反复申请的问题。

useEffect(() => {
// xxxx
}, [Immutable.Map(userInfo) ])
复制代码
但总的看来，封装 Hooks 远远不止是变更了你代码的组织模式而已。比方做数据申请，你可能因而而走上状态驱动的路线，同时，你也要解决状态驱动随之带来的新麻烦。

为了 Mixin？
其实，Mixin 的能力也并非 Hooks 一家独占，咱们齐全能够应用 Decorator 封装一套 Mixin 机制。也就是说，Hooks 不能依仗 Mixin 能力去据理力争。

const HelloMixin = {
componentDidMount() {

console.log('Hello,')

}
}

function mixin(Mixin) {
return function (constructor) {

return class extends constructor {componentDidMount() {Mixin.componentDidMount()
    super.componentDidMount()}
}

}
}

@mixin(HelloMixin)
class Test extends React.PureComponent {
componentDidMount() {

console.log('I am Test')

}

render() {

return null

}
}

render(<Test />) // output: Hello, \n I am Test
复制代码
不过 Hooks 的组装能力更强一些，也容易嵌套应用。但须要警觉层数较深的 Hooks，很可能在某个你不晓得的角落就潜伏着一个有隐患的 useEffect。

最初
如果你感觉此文对你有一丁点帮忙，点个赞。或者能够退出我的开发交换群：1025263163 互相学习，咱们会有业余的技术答疑解惑

如果你感觉这篇文章对你有点用的话，麻烦请给咱们的开源我的项目点点 star: https://gitee.com/ZhongBangKeJi 不胜感激！

PHP 学习手册：https://doc.crmeb.com
技术交换论坛：https://q.crmeb.com