Hooks与事件绑定

这篇具有很好参考价值的文章主要介绍了Hooks与事件绑定。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Hooks与事件绑定

React中,我们经常需要为组件添加事件处理函数,例如处理表单提交、处理点击事件等。通常情况下,我们需要在类组件中使用this关键字来绑定事件处理函数的上下文,以便在函数中使用组件的实例属性和方法。React HooksReact 16.8引入的一个新特性,其出现让React的函数组件也能够拥有状态和生命周期方法。Hooks的优势在于可以让我们在不编写类组件的情况下,复用状态逻辑和副作用代码,Hooks的一个常见用途是处理事件绑定。

描述

React中使用类组件时,我们可能会被大量的this所困扰,例如this.propsthis.state以及调用类中的函数等。此外,在定义事件处理函数时,通常需要使用bind方法来绑定函数的上下文,以确保在函数中可以正确地访问组件实例的属性和方法,虽然我们可以使用箭头函数来减少bind,但是还是使用this语法还是没跑了。

那么在使用Hooks的时候,可以避免使用类组件中的this关键字,因为Hooks是以函数的形式来组织组件逻辑的,我们通常只需要定义一个普通函数组件,并在函数组件中使用useStateuseEffectHooks来管理组件状态和副作用,在处理事件绑定的时候,我们也只需要将定义的事件处理函数传入JSX就好了,也不需要this也不需要bind

那么问题来了,这个问题真的这么简单吗,我们经常会听到类似于Hooks的心智负担很重的问题,从我们当前要讨论的事件绑定的角度上,那么心智负担就主要表现在useEffectuseCallback以及依赖数组上。其实类比来看,类组件类似于引入了thisbind的心智负担,而Hooks解决了类组件的心智负担,又引入了新的心智负担,但是其实换个角度来看,所谓的心智负担也只是需要接受的新知识而已,我们需要了解React推出新的设计,新的组件模型,当我们掌握了之后那就不会再被称为心智负担了,而应该叫做语法,当然其实叫做负担也不是没有道理的,因为很容易在不小心的情况下出现隐患。那么接下来我们就来讨论下Hooks与事件绑定的相关问题,所有示例代码都在https://codesandbox.io/s/react-ts-template-forked-z8o7sv

事件绑定

使用Hooks进行普通的合成事件绑定是一件很轻松的事情,在这个例子中,我们使用了普通的合成事件onClick来监听按钮的点击事件,并在点击时调用了add函数来更新count状态变量的值,这样每次点击按钮时,count就会加1

// https://codesandbox.io/s/hooks-event-z8o7sv
import { useState } from "react";

export const CounterNormal: React.FC = () => {
  const [count, setCount] = useState(0);
  const add = () => {
    setCount(count + 1);
  };
  return (
    <div>
      {count}
      <div>
        <button onClick={add}>count++</button>
      </div>
    </div>
  );
};

这个例子看起来非常简单,我们就不再过多解释了,其实从另一个角度想一下,这不是很类似于原生的DOM0事件流模型,每个对象只能绑定一个DOM事件的话,就不需要像DOM2事件流模型一样还得保持原来的处理函数引用才能进行卸载操作,否则是卸载不了的,如果不能保持引用的地址是相同的,那就会造成无限的绑定,进而造成内存泄漏,如果是DOM0的话,我们只需要覆盖即可,而不需要去保持之前的函数引用。实际上我们接下来要说的一些心智负担,就与引用地址息息相关。

另外有一点我们需要明确一下,当我们点击了这个count按钮,React帮我们做了什么。其实对于当前这个<CounterNormal />组件而言,当我们点击了按钮,那么肯定就是需要刷新视图,React的策略是会重新执行这个函数,由此来获得返回的JSX,然后就是常说的diff等流程,最后才会去渲染,只不过我们目前关注的重点就是这个函数组件的重新执行。Hooks实际上无非就是个函数,React通过内置的use为函数赋予了特殊的意义,使得其能够访问Fiber从而做到数据与节点相互绑定,那么既然是一个函数,并且在setState的时候还会重新执行,那么在重新执行的时候,点击按钮之前的add函数地址与点击按钮之后的add函数地址是不同的,因为这个函数实际上是被重新定义了一遍,只不过名字相同而已,从而其生成的静态作用域是不同的,那么这样便可能会造成所谓的闭包陷阱,接下来我们就来继续探讨相关的问题。

原生事件绑定

虽然React为我们提供了合成事件,但是在实际开发中因为各种各样的原因我们无法避免的会用到原生的事件绑定,例如ReactDOMPortal传送门,其是遵循合成事件的事件流而不是DOM的事件流,比如将这个组件直接挂在document.body下,那么事件可能并不符合看起来DOM结构应该遵循的事件流,这可能不符合我们的预期,此时可能就需要进行原生的事件绑定了。此外,很多库可能都会有类似addEventListener的事件绑定,那么同样的此时也需要在合适的时机去添加和解除事件的绑定。由此,我们来看下边这个原生事件绑定的例子:

// https://codesandbox.io/s/react-ts-template-forked-z8o7sv?file=/src/counter-native.tsx
import { useEffect, useRef, useState } from "react";

export const CounterNative: React.FC = () => {
  const ref1 = useRef<HTMLButtonElement>(null);
  const ref2 = useRef<HTMLButtonElement>(null);
  const [count, setCount] = useState(0);

  const add = () => {
    setCount(count + 1);
  };

  useEffect(() => {
    const el = ref1.current;
    const handler = () => console.log(count);
    el?.addEventListener("click", handler);
    return () => {
      el?.removeEventListener("click", handler);
    };
  }, []);

  useEffect(() => {
    const el = ref2.current;
    const handler = () => console.log(count);
    el?.addEventListener("click", handler);
    return () => {
      el?.removeEventListener("click", handler);
    };
  }, [count]);

  return (
    <div>
      {count}
      <div>
        <button onClick={add}>count++</button>
        <button ref={ref1}>log count 1</button>
        <button ref={ref2}>log count 2</button>
      </div>
    </div>
  );
};

在这个例子中,我们分别对ref1ref2两个button进行了原生事件绑定,其中ref1的事件绑定是在组件挂载的时候进行的,而ref2的事件绑定是在count发生变化的时候进行的,看起来代码上只有依赖数组[][count]的区别,但实际的效果上差别就很大了。在上边在线的CodeSandbox中我们首先点击三次count++这个按钮,然后分别点击log count 1按钮和log count 2按钮,那么输出会是如下的内容:

0 // log count 1
3 // log count 2

此时我们可以看出,页面上的count值明明是3,但是我们点击log count 1按钮的时候,输出的值却是0,只有点击log count 2按钮的时候,输出的值才是3,那么点击log count 1的输出肯定是不符合我们的预期的。那么为什么会出现这个情况呢,其实这就是所谓的React Hooks闭包陷阱了,其实我们上边也说了为什么会发生这个问题,我们再重新看一下,Hooks实际上无非就是个函数,React通过内置的use为函数赋予了特殊的意义,使得其能够访问Fiber从而做到数据与节点相互绑定,那么既然是一个函数,并且在setState的时候还会重新执行,那么在重新执行的时候,点击按钮之前的add函数地址与点击按钮之后的add函数地址是不同的,因为这个函数实际上是被重新定义了一遍,只不过名字相同而已,从而其生成的静态作用域是不同的,那么在新的函数执行时,假设我们不去更新新的函数,也就是不更新函数作用域的话,那么就会保持上次的count引用,就会导致打印了第一次绑定的数据。

那么同样的,useEffect也是一个函数,我们那么我们定义的事件绑定那个函数也其实就是useEffect的参数而已,在state发生改变的时候,这个函数虽然也被重新定义,但是由于我们的第二个参数即依赖数组的关系,其数组内的值在两次render之后是相同的,所以useEffect就不会去触发这个副作用的执行。那么实际上在log count 1中,因为依赖数组是空的[],两次render或者说两次执行依次比较数组内的值没有发生变化,那么便不会触发副作用函数的执行;那么在log count 2中,因为依赖的数组是[count],在两次render之后依次比较其值发现是发生了变化的,那么就会执行上次副作用函数的返回值,在这里就是清理副作用的函数removeEventListener,然后再执行传进来的新的副作用函数addEventListener。另外实际上也就是因为React需要返回一个清理副作用的函数,所以第一个函数不能直接用async装饰,否则执行副作用之后返回的就是一个Promise对象而不是直接可执行的副作用清理函数了。

useCallback

在上边的场景中,我们通过为useEffect添加依赖数组的方式似乎解决了这个问题,但是设想一个场景,如果一个函数需要被多个地方引入,也就是说类似于我们上一个示例中的handler函数,如果我们需要在多个位置引用这个函数,那么我们就不能像上一个例子一样直接定义在useEffect的第一个参数中。那么如果定义在外部,这个函数每次re-render就会被重新定义,那么就会导致useEffect的依赖数组发生变化,进而就会导致副作用函数的重新执行,显然这样也是不符合我们的预期的。此时就需要将这个函数的地址保持为唯一的,那么就需要useCallback这个Hook了,当使用React中的useCallback Hook时,其将返回一个memoized记忆化的回调函数,这个回调函数只有在其依赖项发生变化时才会重新创建,否则就会被缓存以便在后续的渲染中复用。通过这种方式可以帮助我们在React组件中优化性能,因为其可以防止不必要的重渲染,当将这个memoized回调函数传递给子组件时,就可以避免在每次渲染时重新创它,这样可以提高性能并减少内存的使用。由此,我们来看下边这个使用useCallback进行事件绑定的例子:

// https://codesandbox.io/s/react-ts-template-forked-z8o7sv?file=/src/counter-callback.tsx
import { useCallback, useEffect, useRef, useState } from "react";

export const CounterCallback: React.FC = () => {
  const ref1 = useRef<HTMLButtonElement>(null);
  const ref2 = useRef<HTMLButtonElement>(null);
  const [count, setCount] = useState(0);

  const add = () => {
    setCount(count + 1);
  };

  const logCount1 = () => console.log(count);

  useEffect(() => {
    const el = ref1.current;
    el?.addEventListener("click", logCount1);
    return () => {
      el?.removeEventListener("click", logCount1);
    };
  }, []);

  const logCount2 = useCallback(() => {
    console.log(count);
  }, [count]);

  useEffect(() => {
    const el = ref2.current;
    el?.addEventListener("click", logCount2);
    return () => {
      el?.removeEventListener("click", logCount2);
    };
  }, [logCount2]);

  return (
    <div>
      {count}
      <div>
        <button onClick={add}>count++</button>
        <button ref={ref1}>log count 1</button>
        <button ref={ref2}>log count 2</button>
      </div>
    </div>
  );
};

在这个例子中我们的logCount1没有useCallback包裹,每次re-render都会重新定义,此时useEffect也没有定义数组,所以在re-render时并没有再去执行新的事件绑定。那么对于logCount2而言,我们使用了useCallback包裹,那么每次re-render时,由于依赖数组是[count]的存在,因为count发生了变化useCallback返回的函数的地址也改变了,在这里如果有很多的状态的话,其他的状态改变了,count不变的话,那么这里的logCount2便不会改变,当然在这里我们只有count这一个状态,所以在re-render时,useEffect的依赖数组发生了变化,所以会重新执行事件绑定。在上边在线的CodeSandbox中我们首先点击三次count++这个按钮,然后分别点击log count 1按钮和log count 2按钮,那么输出会是如下的内容:

0 // log count 1
3 // log count 2

那么实际上我们可以看出来,在这里如果的log count 1与原生事件绑定例子中的log count 1一样,都因为没有及时更新而保持了上一次render的静态作用域,导致了输出0,而由于log count 2及时更新了作用域,所以正确输出了3,实际上这个例子并不全,我们可以很明显的发现实际上应该有其他种情况的,我们同样先点击count++三次,然后再分情况看输出:

  • logCount函数不用useCallback包装。
    • useEffect依赖数组为[]: 输出0
    • useEffect依赖数组为[count]: 输出3
    • useEffect依赖数组为[logCount]: 输出3
  • logCount函数使用useCallback包装,依赖为[]
    • useEffect依赖数组为[]: 输出0
    • useEffect依赖数组为[count]: 输出0
    • useEffect依赖数组为[logCount]: 输出0
  • logCount函数使用useCallback包装,依赖为[count]
    • useEffect依赖数组为[]: 输出0
    • useEffect依赖数组为[count]: 输出3
    • useEffect依赖数组为[logCount]: 输出3

虽然看起来情况这么多,但是实际上如果接入了react-hooks/exhaustive-deps规则的话,发现其实际上是会建议我们使用3.3这个方法来处理依赖的,这也是最标准的解决方案,其他的方案要不就是存在不必要的函数重定义,要不就是存在应该重定义但是依然存在旧的函数作用域引用的情况,其实由此看来React的心智负担确实是有些重的,而且useCallback能够完全解决问题吗,实际上并没有,我们可以接着往下聊聊useCallback的缺陷。

useMemoizedFn

同样的,我们继续来看一个例子,这个例子可能相对比较复杂,因为会有一个比较长的依赖传递,然后导致看起来比较麻烦。另外实际上这个例子也不能说useCallback是有问题的,只能说是会有相当重的心智负担。

const getTextInfo = useCallback(() => { // 获取一段数据
  return [text.length, dep.length];
}, [text, dep]);

const post = useCallback(() => { // 发送数据
  const [textLen, depLen] = getTextInfo();
  postEvent({ textLen, depLen });
}, [getTextInfo, postEvent]);

useEffect(() => {
  post();
}, [dep, post]);

在这个例子中,我们希望达到的目标是仅当dep发生改变的时候,触发post函数,从而将数据进行发送,在这里我们完全按照了react-hooks/exhaustive-deps的规则去定义了函数。那么看起来似乎并没有什么问题,但是当我们实际去应用的时候,会发现当text这个状态发生变化的时候,同样会触发这个post函数的执行,这是个并不明显的问题,如果text这个状态改变的频率很低的话,甚至在回归的过程中都可能无法发现这个问题。此外,可以看到这个依赖的链路已经很长了,如果函数在复杂一些,那复杂性越来越高,整个状态就会变的特别难以维护。

那么如何解决这个问题呢,一个可行的办法是我们可以将函数定义在useRef上,那么这样的话我们就可以一直拿到最新的函数定义了,实际效果与直接定义一个函数调用无异,只不过不会受到react-hooks/exhaustive-deps规则的困扰了。那么实际上我们并没有减缓复杂性,只是将复杂性转移到了useRef上,这样的话我们就需要去维护这个useRef的值,这样的话就会带来一些额外的心智负担。

const post = useRef(() => void 0);

post.current = () => {
  postEvent({ textLen, depLen });
}

useEffect(() => {
  post.current();
}, [dep]);

那么既然我们可以依靠useRef来解决这个问题,我们是不是可以将其封装为一个自定义的Hooks呢,然后因为实际上我们并没有办法阻止函数的创建,那么我们就使用两个ref,第一个ref保证永远是同一个引用,也就是说返回的函数永远指向同一个函数地址,第二个ref用来保存当前传入的函数,这样发生re-render的时候每次创建新的函数我们都将其更新,也就是说我们即将调用的永远都是最新的那个函数。这样通过两个ref我们就可以保证两点,第一点是无论发生多少次re-render,我们返回的都是同一个函数地址,第二点是无论发生了多少次re-render,我们即将调用的函数都是最新的。由此,我们就来看下ahooks是如何实现的useMemoizedFn

type noop = (this: any, ...args: any[]) => any;

type PickFunction<T extends noop> = (
  this: ThisParameterType<T>,
  ...args: Parameters<T>
) => ReturnType<T>;

function useMemoizedFn<T extends noop>(fn: T) {
  const fnRef = useRef<T>(fn);

  // why not write `fnRef.current = fn`?
  // https://github.com/alibaba/hooks/issues/728
  fnRef.current = useMemo(() => fn, [fn]);

  const memoizedFn = useRef<PickFunction<T>>();
  if (!memoizedFn.current) {
    memoizedFn.current = function (this, ...args) {
      return fnRef.current.apply(this, args);
    };
  }

  return memoizedFn.current as T;
}

那么使用的时候就很简单了,可以看到我们使用useMemoizedFn时是不需要依赖数组的,并且虽然我们在useEffect中定义了post函数的依赖,但是由于我们上边保证了第一点,那么这个在这个组件被完全卸载之前,这个依赖的函数地址是不会变的,由此我们就可以保证只可能由于dep发生的改变才会触发useEffect,而且我们保证的第二点,可以让我们在re-render之后拿到的都是最新的函数作用域,也就是textLendepLen是能够保证是最新的
,不会存在拿到了旧的函数作用域里边值的问题。文章来源地址https://www.toymoban.com/news/detail-415120.html

const post = useMemoizedFn(() => {
  postEvent({ textLen, depLen });
});

useEffect(() => {
  post.current();
}, [dep, post]);

每日一题

https://github.com/WindrunnerMax/EveryDay

参考

https://juejin.cn/post/7194368992025247804
https://juejin.cn/post/7098137024204374030
https://react.dev/reference/react/useCallback

到了这里,关于Hooks与事件绑定的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 前端react入门day02-React中的事件绑定与组件

    (创作不易,感谢有你,你的支持,就是我前行的最大动力,如果看完对你有帮助,请留下您的足迹) 目录 React中的事件绑定 React 基础事件绑定 使用事件对象参数  传递自定义参数  同时传递事件对象和自定义参数  React中的组件  组件是什么 React组件 useState  修改状态的规

    2024年02月06日
    浏览(86)
  • 工作中,我们经常用到哪些SQL语句呢?

    目录 一、DDL部分(create、drop、alter) 1.1 create 语句上 1.2 drop 语句 1.3 alter 语句 二、DML(数据操纵语言)和DQL(数据查询语言) 2.1 insert 语句 2.2 update 语句 2.3 delete 语句 2.4 select 语句 2.5 其他操纵语言 2.5.1 truncate 语句 2.5.2 merge 语句 三、用户角色权限 3.1 用户相关 3.1.1 创建用户

    2024年02月03日
    浏览(47)
  • React Hooks ——性能优化Hooks

    Hooks从语法上来说是一些函数。这些函数可以用于在函数组件中引入状态管理和生命周期方法。 简洁 从语法上来说,写的代码少了 上手非常简单 基于函数式编程理念,只需要掌握一些JavaScript基础知识 与生命周期相关的知识不用学,react Hooks使用全新的理念来管理组件的运作

    2024年02月06日
    浏览(44)
  • React的hooks---自定义hooks

    通过自定义 Hook,可以将组件逻辑提取到可重用的函数中,在 Hook 特性之前,React 中有两种流行的方式来共享组件之间的状态逻辑: render props 和 高阶组件 ,但此类解决方案会导致组件树的层级冗余等问题。而自定义 Hook 的使用可以很好的解决此类问题 自定义 Hook 是一个函数

    2024年02月15日
    浏览(32)
  • 【React】React Hooks解析

    React 16.8 + 为什么需要Hook? Hook是 React 16.8 的新增特性,它可以让我们在不编写class的情况下使用state以及其他的React特性(比如生命周期) 我们先来思考一下class组件相对于函数式组件有什么优势?比较常见的是下面的优势: class组件可以 定义自己的state ,用来 保存组件自己内

    2024年02月11日
    浏览(55)
  • React Hooks 基本使用

    class 组件如果业务复杂,很难拆分和重构,很难测试;相同业务逻辑分散到各个方法中,逻辑混乱 逻辑复用像 HOC 、 Render Props ,不易理解,学习成本高 React 提倡函数式编程,函数更易拆分,更易测试 但是函数组件太简单,为了增强函数组件的功能,媲美 class 组件: 函数组

    2024年01月21日
    浏览(41)
  • React hooks 大全详情

    hook 是react 16.8的新增特性 ,他可以让你不在编写class的情况下shiystate以及react的特性 Hooks的出现,首先解决了以下问题: 告别了令人疑惑的生命周期 告别类组件中烦人的this 告别繁重的类组件,回归到了熟悉的函数组件 react 整个思想上面的转变,从“面向对象”的思想转为“

    2024年02月08日
    浏览(47)
  • React hooks源码阅读

    一、版本 react:17.0.2 react-dom: 17.0.2 二、代码仓库 react源码的管理方式是monorepo模式,它把react中相对独立的模块分割出来作为一个软件包(例如:react包、react-dom包、react-server包等等),将所有软件包统一放置在/packages中,这样一个react代码仓库就包含了所有的react模块。源码

    2024年02月04日
    浏览(32)
  • React Hooks 钩子特性

    人在身处逆境时,适应环境的能力实在惊人。人可以忍受不幸,也可以战胜不幸,因为人有着惊人的潜力,只要立志发挥它,就一定能渡过难关。 Hooks 是 React 16.8 的新增特性。它可以让你在不编写 class 组件的情况下使用 state 以及其他的 React 特性。 React Hooks 表现形式是以

    2024年02月05日
    浏览(40)
  • React Hooks解析

    1. react使用hook的意义 Hook 是 React 16.8 的新增特性,它可以让我们在不编写class的情况下使用state以及其他的React特性(比如生命周期)。 class组件与函数式组件: class组件可以 定义自己的state ,用来 保存组件自己内部的状态, 函数式组件不可以,因为函数每次调用都会产生新

    2024年02月08日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包