39-事件的绑定和事件对象Event

绑定事件的两种方式/DOM事件的级别

我们在之前的一篇文章《04-JavaScript/22-DOM简介和DOM操作》中已经讲过事件的概念。这里讲一下绑定（注册）事件的两种方式，我们以onclick事件为例。

DOM0的写法：onclick

  1.     element.onclick = function () {
  3.     }

举例：

  1. <body>
  2. <button>点我</button>
  3. <script>
  4.     var btn = document.getElementsByTagName("button")[0];
  6.     //这种事件绑定的方式，如果绑定多个，则后面的会覆盖掉前面的
  7.     btn.onclick = function () {
  8.         console.log("事件1");
  9.     }
  11.     btn.onclick = function () {
  12.         console.log("事件2");
  13.     }
  15. </script>
  16. </body>

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

  1. 事件2

我们可以看到，DOM对象.事件 = 函数的这种绑定事件的方式：一个元素的一个事件只能绑定一个响应函数。如果绑定了多个响应函数，则后者会覆盖前者。

DOM2的写法：addEventListener（高版本浏览器）

  1.     element.addEventListener('click', function () {
  3.     }, false);

参数解释：

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

  • 参数2：回调函数：当事件触发时，该函数会被执行

  • 参数3：true表示捕获阶段触发，false表示冒泡阶段触发（默认）。如果不写，则默认为false。【重要】

举例：

  1. <body>
  2. <button>按钮</button>
  3. <script>
  4.     var btn = document.getElementsByTagName("button")[0];
  6.     // addEventListener: 事件监听器。 原事件被执行的时候，后面绑定的事件照样被执行
  7.     // 这种写法不存在响应函数被覆盖的情况。（更适合团队开发）
  8.     btn.addEventListener("click", fn1);
  9.     btn.addEventListener("click", fn2);
  11.     function fn1() {
  12.         console.log("事件1");
  13.     }
  15.     function fn2() {
  16.         console.log("事件2");
  17.     }
  19. </script>
  20. </body>

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

  1.     事件1
  2.     事件2

我们可以看到，addEventListener()这种绑定事件的方式：

  • 一个元素的一个事件，可以绑定多个响应函数。不存在响应函数被覆盖的情况。执行顺序是：事件被触发时，响应函数会按照函数的绑定顺序执行。

  • addEventListener()中的this，是绑定事件的对象。

  • addEventListener()不支持 IE8 及以下的浏览器。在IE8中可以使用attachEvent来绑定事件（详见下一小段）。

DOM2的写法：attachEvent（IE8及以下版本浏览器）

  1.     element.attachEvent('onclick', function () {
  3.     });

参数解释：

  • 参数1：事件名的字符串(注意，有on)

  • 参数2：回调函数：当事件触发时，该函数会被执行

举例：

  1.     <body>
  2.         <button>按钮</button>
  3.         <script>
  4.             var btn = document.getElementsByTagName('button')[0];
  6.             btn.attachEvent('onclick', function() {
  7.                 console.log('事件1');
  8.             });
  10.             btn.attachEvent('onclick', function() {
  11.                 console.log('事件2');
  12.             });
  13.         </script>
  14.     </body>

在低版本的IE浏览器上，点击按钮后，上方代码的打印结果：

  1.     事件2
  2.     事件1

我们可以看到，attachEvent()这种绑定事件的方式：

  • 一个元素的一个事件，可以绑定多个响应函数。不存在响应函数被覆盖的情况。注意：执行顺序是，后绑定的先执行。

  • attachEvent()中的this，是window

兼容性写法

上面的内容里，需要强调的是：

  • addEventListener()中的this，是绑定事件的对象。

  • attachEvent()中的this，是window。

既然这两个写法的this不同，那么，有没有一种兼容性的写法可以确保这两种绑定方式的this是相同的呢？我们可以封装一下。代码如下：

  1.     <body>
  2.         <button>按钮</button>
  3.         <script>
  4.             var btn = document.getElementsByTagName('button')[0];
  6.             myBind(btn , "click" , function(){
  7.                 alert(this);
  8.             });
  12.             //定义一个函数，用来为指定元素绑定响应函数
  13.             /*
  14.              * addEventListener()中的this，是绑定事件的对象
  15.              * attachEvent()中的this，是window
  16.              *  需要统一两个方法this
  17.              */
  18.             /*
  19.              * 参数：
  20.              *  element 要绑定事件的对象
  21.              *  eventStr 事件的字符串(不要on)
  22.              *  callback 回调函数
  23.              */
  24.             function myBind(element , eventStr , callback){
  25.                 if(element.addEventListener){
  26.                     //大部分浏览器兼容的方式
  27.                     element.addEventListener(eventStr , callback , false);
  28.                 }else{
  29.                     /*
  30.                      * this是谁，由调用方式决定
  31.                      * callback.call(element)
  32.                      */
  33.                     //IE8及以下
  34.                     element.attachEvent("on"+eventStr , function(){
  35.                         //在匿名函数 function 中调用回调函数callback
  36.                         callback.call(element);
  37.                     });
  38.                 }
  39.             }
  41.         </script>
  42.     </body>

事件对象

当事件的响应函数被触发时，会产生一个事件对象event。浏览器每次都会将这个事件event作为实参传进之前的响应函数。

这个对象中包含了与当前事件相关的一切信息。比如鼠标的坐标、键盘的哪个按键被按下、鼠标滚轮滚动的方向等。

获取 event 对象（兼容性问题）

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

（1）普通浏览器的写法是 event。比如：

50-事件的绑定和事件对象Event - 图1

（2）ie 678 的写法是 window.event。此时，事件对象 event 是作为window对象的属性保存的。

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

  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; ////兼容性写法
  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 有很多属性，比如：

50-事件的绑定和事件对象Event - 图2

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

  • 鼠标在页面的位置 = 滚动条滚动的距离 + 可视区域的坐标。

Event举例

举例1：使 div 跟随鼠标移动

代码实现：

  1. <!DOCTYPE html>
  2. <html>
  3.   <head>
  4.     <meta charset="UTF-8" />
  5.     <title></title>
  6.     <style type="text/css">
  7.       #box1 {
  8.         width: 100px;
  9.         height: 100px;
  10.         background-color: red;
  11.         /*
  12.         * 开启box1的绝对定位
  13.         */
  14.         position: absolute;
  15.       }
  16.     </style>
  18.     <script type="text/javascript">
  19.       window.onload = function() {
  20.         /*
  21.          * 使div可以跟随鼠标移动
  22.          */
  24.         //获取box1
  25.         var box1 = document.getElementById("box1");
  27.         //给整个页面绑定：鼠标移动事件
  28.         document.onmousemove = function(event) {
  29.           //兼容的方式获取event对象
  30.           event = event || window.event;
  32.           // 鼠标在页面的位置 = 滚动条滚动的距离 + 可视区域的坐标。
  33.           var pagex = event.pageX || scroll().left + event.clientX;
  34.           var pagey = event.pageY || scroll().top + event.clientY;
  36.           //   设置div的偏移量（相对于整个页面）
  37.           // 注意，如果想通过 style.left 来设置属性，一定要给 box1开启绝对定位。
  38.           box1.style.left = pagex + "px";
  39.           box1.style.top = pagey + "px";
  40.         };
  41.       };
  43.       // scroll 函数封装
  44.       function scroll() {
  45.         return {
  46.           //此函数的返回值是对象
  47.           left: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop,
  48.           right:
  49.             window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft
  50.         };
  51.       }
  52.     </script>
  53.   </head>
  54.   <body style="height: 1000px;width: 2000px;">
  55.     <div id="box1"></div>
  56.   </body>
  57. </html>

举例2：获取鼠标距离所在盒子的距离

关键点：

  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">
  22. </div>
  24. <script src="animate.js"></script>
  25. <script>
  26.     //需求：鼠标进入盒子之后只要移动，哪怕1像素，随时显示鼠标在盒子中的坐标。
  27.     //技术点：新事件，onmousemove：在事件源上，哪怕鼠标移动1像素也会触动这个事件。
  28.     //一定程度上，模拟了定时器
  29.     //步骤：
  30.     //1.老三步和新五步
  31.     //2.获取鼠标在整个页面的位置
  32.     //3.获取盒子在整个页面的位置
  33.     //4.用鼠标的位置减去盒子的位置赋值给盒子的内容。
  35.     //1.老三步和新五步
  36.     var div = document.getElementsByTagName("div")[0];
  38.     div.onmousemove = function (event) {
  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.     }
  53. </script>
  54. </body>
  55. </html>

实现效果：

50-事件的绑定和事件对象Event - 图3

举例3：商品放大镜

代码实现：

（1）index.html:

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

（2）tools.js:

  1. /**
  2.  * Created by smyhvae on 2018/02/03.
  3.  */
  5. //显示和隐藏
  6. function show(ele) {
  7.     ele.style.display = "block";
  8. }
  10. function hide(ele) {
  11.     ele.style.display = "none";
  12. }
  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. }

效果演示：

50-事件的绑定和事件对象Event - 图4

我的公众号

想学习更多技能？不妨关注我的微信公众号：千古壹号（id：qianguyihao）。

扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：

50-事件的绑定和事件对象Event - 图5