一、绑定事件的两种方式

（一）、方式一：onclick

举例：

  1. <body>
  2. <button>点我</button>
  3. <script>
  4.     var btn = document.getElementsByTagName("button")[0];
  5.  
  6.     //这种事件绑定的方法容易被层叠。
  7.     btn.onclick = function () {
  8.         console.log("事件1");
  9.     }
  10.  
  11.     btn.onclick = function () {
  12.         console.log("事件2");
  13.     }
  14.  
  15. </script>
  16. </body>

点击按钮后，上方代码的打印结果：

  1. 事件2

我们可以看到，这种绑定事件的方式，会层叠掉之前的事件。

（二）、方式二：addEventListener

addEventListener()里的参数：

  • 参数1：事件名(注意，没有on)

  • 参数2：事件名(执行函数)

  • 参数3：事件名(捕获或者冒泡)

举例：

  1. <body>
  2. <button>按钮</button>
  3. <script>
  4.     var btn = document.getElementsByTagName("button")[0];
  5.  
  6.     //addEventListener: 事件监听器。 原事件被执行的时候，后面绑定的事件照样被执行
  7.     //第二种事件绑定的方法不会出现层叠。（更适合团队开发）
  8.     btn.addEventListener("click", fn1);
  9.     btn.addEventListener("click", fn2);
  10.  
  11.     function fn1() {
  12.         console.log("事件1");
  13.     }
  14.  
  15.     function fn2() {
  16.         console.log("事件2");
  17.     }
  18.  
  19. </script>
  20. </body>

点击按钮后，上方代码的打印结果：

  1.     事件1
  2.     事件2

我们可以看到，这种绑定事件的方式，不会层叠掉之前的事件。

二、事件对象

在触发DOM上的某个事件时，会产生一个事件对象event，这个对象中包含着所有与事件有关的信息。比如鼠标操作时候，会添加鼠标位置的相关信息到事件对象中。

所有浏览器都支持event对象，但支持的方式不同。如下。

（1）普通浏览器支持 event。比如：

（2）ie 678 支持 window.event。

于是，我们可以采取一种兼容性的写法。如下：

  1.     event = event || window.event; ////兼容性写法

代码举例：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6. </head>
  7. <body>
  8. <script>
  9.     //点击页面的任何部分
  10.     document.onclick = function (event) {
  11.         event = event || window.event; ////兼容性写法
  12.  
  13.         console.log(event);
  14.         console.log(event.timeStamp);
  15.         console.log(event.bubbles);
  16.         console.log(event.button);
  17.         console.log(event.pageX);
  18.         console.log(event.pageY);
  19.         console.log(event.screenX);
  20.         console.log(event.screenY);
  21.         console.log(event.target);
  22.         console.log(event.type);
  23.         console.log(event.clientX);
  24.         console.log(event.clientY);
  25.     }
  26. </script>
  27. </body>
  28. </html>

（二）、event 属性

event 有很多属性，比如：

由于pageX 和 pageY的兼容性不好，我们可以这样做：

  • 鼠标在页面的位置 = 被卷去的部分+可视区域部分。

三、Event举例

（一）、举例1：鼠标跟随

代码实现：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         body {
  8.             height: 5000px;
  9.         }
  10.  
  11.         img {
  12.             position: absolute;
  13.             padding: 10px 0;
  14.             border: 1px solid #ccc;
  15.             cursor: pointer;
  16.             background-color: yellowgreen;
  17.         }
  18.     </style>
  19. </head>
  20. <body>
  21. <img src="" width="100" height="100"/>
  22.  
  23. <script>
  24.     //需求：点击页面的任何地方，图片跟随鼠标移动到点击位置。
  25.     //思路：获取鼠标在页面中的位置，然图片缓慢运动到鼠标点击的位置。
  26.     //  兼容ie67做pageY和pageX；
  27.     //  原理：     鼠标在页面的位置 = 被卷去的部分+可视区域部分。
  28.     //步骤：
  29.     //1.老三步。
  30.     //2.获取鼠标在页面中的位置。
  31.     //3.利用缓动原理，慢慢的运动到指定位置。（包括左右和上下）
  32.  
  33.     //1.老三步。
  34.     var img = document.getElementsByTagName("img")[0];
  35.     var timer = null;
  36.     var targetx = 0;
  37.     var targety = 0;
  38.     var leaderx = 0;
  39.     var leadery = 0;
  40.     //给整个文档绑定点击事件获取鼠标的位置。
  41.     document.onclick = function (event) {
  42.         //新五步
  43.         //兼容获取事件对象
  44.         event = event || window.event;
  45.         //鼠标在页面的位置 = 被卷去的部分+可视区域部分。
  46.         var pagey = event.pageY || scroll().top + event.clientY;
  47.         var pagex = event.pageX || scroll().left + event.clientX;
  48.  
  49.         targety = pagey - 30;
  50.         targetx = pagex - 50;
  51.  
  52.         //要用定时器，先清定时器
  53.         clearInterval(timer);
  54.         timer = setInterval(function () {
  55.             //为盒子的位置获取值
  56.             leaderx = img.offsetLeft;
  57.             //获取步长
  58.             var stepx = (targetx - leaderx) / 10;
  59.             //二次处理步长
  60.             stepx = stepx > 0 ? Math.ceil(stepx) : Math.floor(stepx);
  61.             leaderx = leaderx + stepx;
  62.             //赋值
  63.             img.style.left = leaderx + "px";
  64.  
  65.             //为盒子的位置获取值
  66.             leadery = img.offsetTop;
  67.             //获取步长
  68.             var stepy = (targety - leadery) / 10;
  69.             //二次处理步长
  70.             stepy = stepy > 0 ? Math.ceil(stepy) : Math.floor(stepy);
  71.             leadery = leadery + stepy;
  72.             //赋值
  73.             img.style.top = leadery + "px";
  74.  
  75.             //清定时器
  76.             if (Math.abs(targety - img.offsetTop) <= Math.abs(stepy) && Math.abs(targetx - img.offsetLeft) <= Math.abs(stepx)) {
  77.                 img.style.top = targety + "px";
  78.                 img.style.left = targetx + "px";
  79.                 clearInterval(timer);
  80.             }
  81.         }, 30);
  82.     }
  83.  
  84. </script>
  85.  
  86. </body>
  87. </html>

实现效果：

（二）、event应用举例：获取鼠标距离所在盒子的距离

关键点：

  1.     鼠标距离所在盒子的距离 = 鼠标在整个页面的位置 - 所在盒子在整个页面的位置

代码演示：

  1. <!DOCTYPE html>
  2. <html>
  3. <head lang="en">
  4.     <meta charset="UTF-8">
  5.     <title></title>
  6.     <style>
  7.         .box {
  8.             width: 300px;
  9.             height: 200px;
  10.             padding-top: 100px;
  11.             background-color: pink;
  12.             margin: 100px;
  13.             text-align: center;
  14.             font: 18px/30px "simsun";
  15.             cursor: pointer;
  16.         }
  17.     </style>
  18. </head>
  19. <body>
  20. <div class="box">
  21.  
  22. </div>
  23.  
  24. <script src="animate.js"></script>
  25. <script>
  26.     //需求：鼠标进入盒子之后只要移动，哪怕1像素，随时显示鼠标在盒子中的坐标。
  27.     //技术点：新事件，onmousemove：在事件源上，哪怕鼠标移动1像素也会触动这个事件。
  28.     //一定程度上，模拟了定时器
  29.     //步骤：
  30.     //1.老三步和新五步
  31.     //2.获取鼠标在整个页面的位置
  32.     //3.获取盒子在整个页面的位置
  33.     //4.用鼠标的位置减去盒子的位置赋值给盒子的内容。
  34.  
  35.     //1.老三步和新五步
  36.     var div = document.getElementsByTagName("div")[0];
  37.  
  38.     div.onmousemove = function (event) {
  39.  
  40.         event = event || window.event;
  41.         //2.获取鼠标在整个页面的位置
  42.         var pagex = event.pageX || scroll().left + event.clientX;
  43.         var pagey = event.pageY || scroll().top + event.clientY;
  44.         //3.获取盒子在整个页面的位置
  45.         // var xx =
  46.         // var yy =
  47.         //4.用鼠标的位置减去盒子的位置赋值给盒子的内容。
  48.         var targetx = pagex - div.offsetLeft;
  49.         var targety = pagey - div.offsetTop;
  50.         this.innerHTML = "鼠标在盒子中的X坐标为：" + targetx + "px;<br>鼠标在盒子中的Y坐标为：" + targety + "px;"
  51.     }
  52.  
  53. </script>
  54. </body>
  55. </html>

实现效果：

（三）、举例：商品放大镜

代码实现：

  1. （1）index.html:
  2.  
  3. <!DOCTYPE html>
  4. <html>
  5. <head lang="en">
  6.     <meta charset="UTF-8">
  7.     <title></title>
  8.     <style>
  9.         * {
  10.             margin: 0;
  11.             padding: 0;
  12.         }
  13.  
  14.         .box {
  15.             width: 350px;
  16.             height: 350px;
  17.             margin: 100px;
  18.             border: 1px solid #ccc;
  19.             position: relative;
  20.         }
  21.  
  22.         .big {
  23.             width: 400px;
  24.             height: 400px;
  25.             position: absolute;
  26.             top: 0;
  27.             left: 360px;
  28.             border: 1px solid #ccc;
  29.             overflow: hidden;
  30.             display: none;
  31.         }
  32.  
  33.         /*mask的中文是：遮罩*/
  34.         .mask {
  35.             width: 175px;
  36.             height: 175px;
  37.             background: rgba(255, 255, 0, 0.4);
  38.             position: absolute;
  39.             top: 0;
  40.             left: 0;
  41.             cursor: move;
  42.             display: none;
  43.         }
  44.  
  45.         .small {
  46.             position: relative;
  47.         }
  48.  
  49.         img {
  50.             vertical-align: top;
  51.         }
  52.     </style>
  53.  
  54.     <script src="tools.js"></script>
  55.     <script>
  56.         window.onload = function () {
  57.             //需求：鼠标放到小盒子上，让大盒子里面的图片和我们同步等比例移动。
  58.             //技术点：onmouseenter==onmouseover 第一个不冒泡
  59.             //技术点：onmouseleave==onmouseout  第一个不冒泡
  60.             //步骤：
  61.             //1.鼠标放上去显示盒子，移开隐藏盒子。
  62.             //2.老三步和新五步（黄盒子跟随移动）
  63.             //3.右侧的大图片，等比例移动。
  64.  
  65.             //0.获取相关元素
  66.             var box = document.getElementsByClassName("box")[0];
  67.             var small = box.firstElementChild || box.firstChild;
  68.             var big = box.children[1];
  69.             var mask = small.children[1];
  70.             var bigImg = big.children[0];
  71.  
  72.             //1.鼠标放上去显示盒子，移开隐藏盒子。(为小盒子绑定事件)
  73.             small.onmouseenter = function () {
  74.                 //封装好方法调用：显示元素
  75.                 show(mask);
  76.                 show(big);
  77.             }
  78.             small.onmouseleave = function () {
  79.                 //封装好方法调用：隐藏元素
  80.                 hide(mask);
  81.                 hide(big);
  82.             }
  83.  
  84.             //2.老三步和新五步（黄盒子跟随移动）
  85.             //绑定的事件是onmousemove，而事件源是small(只要在小盒子上移动1像素，黄盒子也要跟随)
  86.             small.onmousemove = function (event) {
  87.                 //新五步
  88.                 event = event || window.event;
  89.  
  90.                 //想要移动黄盒子，必须要知道鼠标在small小图中的位置。
  91.                 var pagex = event.pageX || scroll().left + event.clientX;
  92.                 var pagey = event.pageY || scroll().top + event.clientY;
  93.  
  94.                 //x：mask的left值，y：mask的top值。
  95.                 var x = pagex - box.offsetLeft - mask.offsetWidth / 2; //除以2，可以保证鼠标mask的中间
  96.                 var y = pagey - box.offsetTop - mask.offsetHeight / 2;
  97.  
  98.                 //限制换盒子的范围
  99.                 //left取值为大于0，小盒子的宽-mask的宽。
  100.                 if (x < 0) {
  101.                     x = 0;
  102.                 }
  103.                 if (x > small.offsetWidth - mask.offsetWidth) {
  104.                     x = small.offsetWidth - mask.offsetWidth;
  105.                 }
  106.                 //top同理。
  107.                 if (y < 0) {
  108.                     y = 0;
  109.                 }
  110.                 if (y > small.offsetHeight - mask.offsetHeight) {
  111.                     y = small.offsetHeight - mask.offsetHeight;
  112.                 }
  113.  
  114.                 //移动黄盒子
  115.                 console.log(small.offsetHeight);
  116.                 mask.style.left = x + "px";
  117.                 mask.style.top = y + "px";
  118.  
  119.                 //3.右侧的大图片，等比例移动。
  120.                 //如何移动大图片？等比例移动。
  121.                 //    大图片/大盒子 = 小图片/mask盒子
  122.                 //    大图片走的距离/mask走的距离 = （大图片-大盒子）/（小图片-黄盒子）
  123. //                var bili = (bigImg.offsetWidth-big.offsetWidth)/(small.offsetWidth-mask.offsetWidth);
  124.  
  125.                 //大图片走的距离/mask盒子都的距离 = 大图片/小图片
  126.                 var bili = bigImg.offsetWidth / small.offsetWidth;
  127.  
  128.                 var xx = bili * x;  //知道比例，就可以移动大图片了
  129.                 var yy = bili * y;
  130.  
  131.                 bigImg.style.marginTop = -yy + "px";
  132.                 bigImg.style.marginLeft = -xx + "px";
  133.             }
  134.         }
  135.     </script>
  136. </head>
  137. <body>
  138. <div class="box">
  139.     <div class="small">
  140.         <img src="data:images/001.jpg" alt=""/>
  141.         <div class="mask"></div>
  142.     </div>
  143.     <div class="big">
  144.         <img src="data:images/0001.jpg" alt=""/>
  145.     </div>
  146. </div>
  147. </body>
  148. </html>

（2）tools.js:

  1. /**
  2.  * Created by smyhvae on 2018/02/03.
  3.  */
  4.  
  5. //显示和隐藏
  6. function show(ele) {
  7.     ele.style.display = "block";
  8. }
  9.  
  10. function hide(ele) {
  11.     ele.style.display = "none";
  12. }
  13.  
  14. function scroll() {  // 开始封装自己的scrollTop
  15.     if (window.pageYOffset != null) {  // ie9+ 高版本浏览器
  16.         // 因为 window.pageYOffset 默认的是  0  所以这里需要判断
  17.         return {
  18.             left: window.pageXOffset,
  19.             top: window.pageYOffset
  20.         }
  21.     }
  22.     else if (document.compatMode === "CSS1Compat") {    // 标准浏览器   来判断有没有声明DTD
  23.         return {
  24.             left: document.documentElement.scrollLeft,
  25.             top: document.documentElement.scrollTop
  26.         }
  27.     }
  28.     return {   // 未声明 DTD
  29.         left: document.body.scrollLeft,
  30.         top: document.body.scrollTop
  31.     }
  32. }

效果演示：

四、事件冒泡

事件传播的三个阶段是：事件捕获、事件冒泡和目标。

  • 事件捕获阶段：事件从最上一级标签开始往下查找，直到捕获到事件目标 target。（从祖先元素往子元素查找，DOM树结构）。在这个过程中，事件相应的监听函数是不会被触发的。

  • 事件目标：当到达目标元素之后，执行目标元素该事件相应的处理函数。如果没有绑定监听函数，那就不执行。

  • 事件冒泡阶段：事件从事件目标 target 开始，往上冒泡直到页面的最上一级标签。（从子元素到祖先元素冒泡）

如下图所示：

PS：这个概念类似于 Android 里的 touch 事件传递。

（一）、事件冒泡的概念

事件冒泡: 当一个元素上的事件被触发的时候（比如说鼠标点击了一个按钮），同样的事件将会在那个元素的所有祖先元素中被触发。这一过程被称为事件冒泡；这个事件从原始元素开始一直冒泡到DOM树的最上层。

通俗来讲，冒泡指的是：子元素的事件被触发时，父盒子的同样的事件也会被触发。取消冒泡就是取消这种机制。

代码演示：

  1.     //事件冒泡
  2.     box3.onclick = function () {
  3.         alert("child");
  4.     }
  6.     box2.onclick = function () {
  7.         alert("father");
  8.     }
  10.     box1.onclick = function () {
  11.         alert("grandfather");
  12.     }
  14.     document.onclick = function () {
  15.         alert("body");
  16.     }

上图显示，当我点击儿子 box3的时候，它的父亲box2、box1、body都依次被触发了。即使我改变代码的顺序，也不会影响效果的顺序。

冒泡顺序：

一般的浏览器: （除IE6.0之外的浏览器）

  • div -> body -> html -> document -> window

IE6.0：

  • div -> body -> html -> document

（二）、事件捕获

addEventListener可以捕获事件：

  1.    box1.addEventListener("click", function () {
  2.         alert("捕获 box3");
  3.     }, true);

上面的方法中，参数为true，代表捕获；参数为false或者不写参数，代表冒泡。

代码演示：

  1.  //参数为true，代表捕获；参数为false或者不写参数，代表冒泡
  2.     box3.addEventListener("click", function () {
  3.         alert("捕获 child");
  4.     }, true);
  5.  
  6.     box2.addEventListener("click", function () {
  7.         alert("捕获 father");
  8.     }, true);
  9.  
  10.     box1.addEventListener("click", function () {
  11.         alert("捕获 grandfather");
  12.     }, true);
  13.  
  14.     document.addEventListener("click", function () {
  15.         alert("捕获 body");
  16.     }, true);

效果演示：

不是所有的事件都能冒泡

以下事件不冒泡：blur、focus、load、unload、onmouseenter、onmouseleave。意思是，事件不会往父元素那里传递。

我们检查一个元素是否会冒泡，可以通过事件的以下参数：

event.bubbles

如果返回值为true，说明该事件会冒泡；反之则相反。

举例：

  1.     box1.onclick = function (event) {
  2.         alert("冒泡 child");
  3.  
  4.         event = event || window.event;
  5.         console.log(event.bubbles); //打印结果：true
  6.     }

阻止冒泡的方法

w3c的方法：（火狐、谷歌、IE11）

  1. event.stopPropagation();

IE10以下则是：

  1. event.cancelBubble = true

兼容代码如下：

  1.   box3.onclick = function (event) {
  2.  
  3.         alert("child");
  4.  
  5.         //阻止冒泡
  6.         event = event || window.event;
  7.  
  8.         if (event && event.stopPropagation) {
  9.             event.stopPropagation();
  10.         } else {
  11.             event.cancelBubble = true;
  12.         }
  13.     }

上方代码中，我们对box3进行了阻止冒泡，产生的效果是：事件不会继续传递到 father、grandfather、body了。

五、事件委托

事件委托，通俗地来讲，就是把一个元素响应事件（click、keydown......）的函数委托到另一个元素。

比如说有一个列表 ul，列表之中有大量的列表项 li，我们需要在点击列表项li的时候响应一个事件。如果给每个列表项一一都绑定一个函数，那对于内存消耗是非常大的，效率上需要消耗很多性能。

因此，比较好的方法就是把这个点击事件绑定到他的父层，也就是 ul 上，然后在执行事件的时候再去匹配判断目标元素。

所以事件委托可以减少大量的内存消耗，节约效率。

事件委托的参考链接：JavaScript 事件委托详解

参考资料：https://www.cnblogs.com/qianguyihao/p/8413602.html

JavaScript初探系列（十）——Event的更多相关文章

  1. JavaScript初探系列目录

    一  系列导航 结合各方面的参考资料,整理出来以下主要目录,供方便浏览查看 (一)初探系列           JavaScript初探系列(1)——基本概念 JavaScript初探系列(2)——数 ...

  2. JavaScript初探系列之面向对象

    面向对象的语言有一个标志,即拥有类的概念,抽象实例对象的公共属性与方法,基于类可以创建任意多个实例对象,一般具有封装.继承.多态的特性!但JS中对象与纯面向对象语言中的对象是不同的,ECMA标准定义J ...

  3. JavaScript初探系列之Ajax应用

    一 什么是Ajax Ajax是(Asynchronous JavaScript And XML)是异步的JavaScript和xml.也就是异步请求更新技术.Ajax是一种对现有技术的一种新的应用,不 ...

  4. JavaScript初探系列之基本概念

    JavaScript的核心语言特性在ECMA-262中是以名为ECMAScript(ECMA, EuropeanComputer Manufacturers Association )的伪语言的形式来 ...

  5. JavaScript初探系列之数组的基本操作

    在程序语言中数组的重要性不言而喻,JavaScript中数组也是最常使用的对象之一,数组是值的有序集合,由于弱类型的原因,JavaScript中数组十分灵活.强大,不像是Java等强类型高级语言数组只 ...

  6. JavaScript初探系列之String的基本操作

    1.字符串转换 字符串转换是最基础的要求和工作,你可以将任何类型的数据都转换为字符串,你可以用下面三种方法的任何一种: var myStr = num.toString(); // "19& ...

  7. JavaScript初探系列（十一）——ES6

    一.前言 ECMAScript 6.0(以下简称 ES6)是 JavaScript 语言的下一代标准,已经在 2015 年 6 月正式发布了.它的目标,是使得 JavaScript 语言可以用来编写复 ...

  8. JavaScript初探系列（九）——BOM

    一.什么是BOM? BOM:Browser Object Model 是浏览器对象模型,浏览器对象模型提供了独立与内容的.可以与浏览器窗口进行互动的对象结构,BOM由多个对象构成,其中代表浏览器窗口的 ...

  9. JavaScript初探系列（六）——函数

    一.概述 (一)函数的声明 JavaScript 有三种声明函数的方法. (1)function 命令 function命令声明的代码区块,就是一个函数.function命令后面是函数名,函数名后面是 ...

随机推荐

  1. ReactiveObjC basic

    基础-> https://www.jianshu.com/p/cd4031fbf8ff 在RAC中,万物皆信号. RAC 指的就是 RactiveCocoa ,是 Github 的一个开源框架, ...

  2. Beego学习笔记四:编写Model

    MVC实践一:编写模型 1>     打开mysql数据库,设计表的结构 <1>登录mysql数据库,如下 <2>这三个标注的参数皆有用,需要谨记. <3>创 ...

  3. Vulnhub靶场题解

    Vulnhub简介 Vulnhub是一个提供各种漏洞环境的靶场平台,供安全爱好者学习渗透使用,大部分环境是做好的虚拟机镜像文件,镜像预先设计了多种漏洞,需要使用VMware或者VirtualBox运行 ...

  4. JavaScript API 与 DOM

    一.API 1.API 的概念 API(Application Programming Interface,应用程序编程接口)是一些预先定义的函数,目的是提供引用程序与开发人员基于某软件或硬件得以访问 ...

  5. 英语hawkbillturtle玳瑁

    玳瑁(hawkbillturtle):属爬行纲,海龟科的海洋动物.一般长约0.6米,大者可达1.6米.头顶有两对前额鳞,吻部侧扁,上颚前端钩曲呈鹰嘴状:前额鳞2对:背甲盾片呈覆瓦状排列:背面的角质板覆 ...

  6. mysql设计规范和原则

    DB设计流程: 1,需求分析 2,ER设计 3,物理设计 需求分析的最佳实践是头脑风暴,把需求理解透彻.根据公司的现况和未来的发展,与pm一起来讨论. ER(EntiyRelation)设计阶段要确定 ...

  7. 访问hive显示原数据报错

    访问hive报错如下: FAILED: SemanticException org.apache.hadoop.hive.ql.metadata.HiveException: java.lang.Ru ...

  8. 记python 使用腾讯ocr 识别代码报错 CERTIFICATE_VERIFY_FAILED

    腾讯提供的demo测试通过  写入到代码出现 ClientNetworkError? [TencentCloudSDKException] code:ClientNetworkError messag ...

  9. ELK日志分析

    1. 为什么用到ELK 一般我们需要进行日志分析场景:直接在日志文件中 grep.awk 就可以获取自己想要的信息.但是规模较大的场景中,此方法效率低下,面临问题包括日志量太大如何归档.文本搜索太慢怎 ...

  10. live-pusher属性值的改变

    例如:组件推流过程中,切换前后摄像头时,要改变mirror的值并使其生效: LivePusherContext = wx.createLivePusherContext() 1. LivePusher ...