zoukankan      html  css  js  c++  java
  • 事件类型

    事件:当发生一个动作的时候,会触发一个函数

    一、鼠标事件

       1.click:鼠标点击事件,在一个元素上鼠标的左键(只能是左键,mac上可以是滚轮)点击(按下去并抬起)下去就会触发
        2.dbclick:鼠标双击事件,在一个元素上鼠标左键(只能是左键,mac上可以是滚轮)双击下去就会触发 
        3.mousedown:鼠标按下事件,在一个元素上鼠标左中右按下去(不需要抬起)的时候就会触发
        4.mouseup:鼠标抬起事件,在一个元素上鼠标左中右(mac下右键不行)按下去并抬起来的时候就会触发
        5.mousemove:鼠标移动事件,在一个元素上鼠标只要移动的时候就会触发 
        6.mouseover:鼠标移入事件,鼠标移到一个元素身上的时候就会触发
        7.mouseout:鼠标移出事件,鼠标从一个元素身上移出的时候就会触发
                            mouseover和mouseout会将事件传递给子级
        8.mouseenter:鼠标移入事件,鼠标移到一个元素身上的时候就会触发
        9.mouseleave:鼠标移出事件,鼠标从一个元素身上移出的时候就会触发
                               mouseenter和mouseleave不会将事件传递给子级(低版本ie不兼容)
    二、键盘事件
      键盘事件    :不是所有的元素都会有键盘事件,只有有焦点的元素才会有
        1.keydown: 当键盘按下去的时候就会触发,如果按下不抬起,这个事件会一直触发 
        2.keyup:   当键盘抬起的时候就会触发 
    1. <div></div> //div不是焦点元素,所以没有键盘事件
    2. <inputtype="text"/> //有键盘事件
    3. <textarea></textarea>    //有键盘事件
    三、焦点事件
        只有焦点元素才有焦点事件
     
                 *     focus            有焦点事件的元素获取焦点后就会触发
                 *     blur            有焦点事件的元素失去焦点后就会触发
                 * 
                 *     tabindex            用来改变tab键切换的顺序
                 * 
                 * 
                 * 设置焦点的方法
                 *         .focus();            让元素获取到焦点
                 *         .blur();                让元素失去焦点        
    1. <inputtype="text"value="kaivon"tabindex="3"/>        没有tabindex的话:点击tab键如果没有的话就按照顺序找html,
    2. <textareatabindex="2"></textarea>                        给html标上tabindex就会在按tab得时候找对应html的index.
    3. <buttontabindex="1">kaivon</button>
    4. <selectname=""id=""tabindex="4">
    5. <optionvalue="">123</option>
    6. <optionvalue="">456</option>
    7. </select>
    8. <inputtype="checkbox"tabindex="6"/>
    9. <inputtype="radio"tabindex="5"/>
    10. <inputtype="text"id="tex"/>         
                   //                tex.focus(); 让该元素主动获取到了焦点,(被动被选中)
                   //                tex.blur();
    四、.select()方法
     
    1. <script>
    2. /*
    3. * select();
    4. * 在表单元素里,选中用户输入的内容
    5. */
    6. window.onload=function(){
    7. var input=document.querySelector("input");
    8. var btn=document.querySelector("button");
    9. var textarea=document.querySelector("textarea");
    10. btn.onclick=function(){
    11. //同时出现两个方法,后面会把前面的覆盖了
    12. input.select(); //被覆盖了
    13. textarea.select(); //把te在xtarea的所有字符串都选中
    14. };
    15. };
    16. </script>
    17. </head>
    18. <body>
    19. <inputtype="text"/>
    20. <button>点击选中文字</button>
    21. <textarea></textarea>
    22. </body>
     
    五、事件对象
     
                 * event对象
                 *     记录了事件发生时的一些关于事件详细的信息
                 *     当一个事件发生的时候,和当前这个事件有关第的细节信息都会保存在一个对象当中,这个对象我们称他为事件对象
                 * 
                 * event对象是事件处理函数里第一个参数,不同的事件有不同的事件对象,事件对象里的内容是不一样的
    1. document.onclick=function(ev){
    2. console.dir(ev);
    3. }
    4. /*function fn(ev){
    5. console.log(ev);
    6. }
    7. fn(); */ //这个函数不是事件调用的,所以没有事件对象
    六、事件对象获取鼠标坐标-event.clientX   event.clentY
     
                 *     event.clientX/event.clientY            事件发生的时候,鼠标的位置信息
                 *     坐标的值是根据可视区的左上角进行计算
        1. window.onload=function(){
    1. var div=document.getElementById("div1");
    2. document.onmousemove=function(ev){
    3.                            ev是event的缩写
    4. div.style.left=ev.clientX+'px';
    5. div.style.top=ev.clientY+'px';
    6. };
    7. };
    8.     <divid="div1" style="position:absolute;"></div>
    9. 该div会跟随鼠标的位置移动
    七、事件对象获取对象源  -event.target
     *     它会一层一层往里面去找,直到找到最里层的那个元素  (相当于this)
    1. window.onload=function(){
    2. var list=document.getElementById("list");
    3. var lis=document.querySelectorAll("li");
    4. /*for(var i=0;i<lis.length;i++){
    5. lis[i].onclick=function(){
    6. console.log(this.innerHTML);
    7. };
    8. }*/
    9. //事件委托(代理)
    10. list.onclick=function(ev){
    11. //console.log(ev.target)
    12. if(ev.target.tagName=='LI'){
    13. console.log(ev.target.innerHTML);
    14. }
    15. //console.log(ev.target.tagName)
    16. };
    17. list.innerHTML+='<li>yellow</li>';      //因为innerHTML的原因,上面for的功能会失效,这样使用事件委托能够实现想要的功能。
    18. };
    19. </script>
    20. </head>
    21. <body>
    22. <ulid="list">
    23. <li>red</li>
    24. <li>green</li>
    25. <li>blue</li>
    26. <li>pink</li>
    27. <li>black</li>
    28. </ul>
    29. </body>
    八、事件对象获取-键盘事件属性  
       1.  event.keyCode      按下的是哪个键,返回这个键对应的Unicode
                
                 *     注意:以下三个不只是键盘事件才会有,其它的事件也会有这些属性
                 *     event.ctrlKey        事件发生的时候ctrl是否被按下去了,如果按下去了就是true,否则是false
                 *     event.shiftKey        事件发生的时候shift是否被按下去了,如果按下去了就是true,否则是false
                 *     event.altKey            事件发生的时候alt是否被按下去了,如果按下去了就是true,否则是false
    1. <script>
    2. window.onload=function(){
    3. var text=document.querySelector("input");
    4. var ul=document.querySelector("ul");
    5. text.onkeydown=function(ev){
    6. if(ev.keyCode==13&& ev.altKey){
    7. //这个条件成立,说明用户按下了回车键
    8. //console.log('回车键');
    9. var li=document.createElement("li");
    10. li.innerHTML=this.value;
    11. ul.appendChild(li);
    12. this.value='';
    13. }
    14. };
    15. };
    16. </script>
    17. </head>
    18. <body>
    19. <inputtype="text"/>
    20. <ul></ul>
    21. </body>
    九、事件绑定与移除
       
                 *     1、on事件绑定
                 *             方法
                 *             对象.on事件名称=函数;
                                        on事件只有冒泡阶段
                 *             注意:on只能给元素添加一个事件。如果说有多个同样的事件,那后面的会把前面的给覆盖了
                              
                 *     1、移除on添加的事件
                 *         对象.on事件名称=null;
    1. var btn1=document.getElementById("btn1");
    2. //on的方式添加事件
    3. btn1.onclick=function(){
    4. console.log('这是按钮一的第一次点击');
    5. };
    6. btn1.onclick=function(){
    7. console.log('这是按钮一的第二次点击'); //只会打印出这个
    8. };
    9. <inputtype="button"id="btn1"value="按钮1"/>
    10.  
    11. //移除on事件 
          1. btn1.onclick=null;
     
                
                 *     2、addEventListener
                 *         方法
                 *             对象.addEventListener(事件名称,事件绑定函数,boolean);
                 *         参数
                 *             参数1:事件名称,不加on,它是一个字符串
                 *             参数2:事件绑定函数,这个事件绑定函数可以是匿名函数也可以是命名函数
                 *             参数3:布尔值
                 *                 true            事件是在捕获的阶段发生的
                 *                 false        事件是在冒泡的阶段发生的(默认为false)
                 *            
                 *             注意:事件绑定函数里的this是指向事件触发的那个对象的,不是指向window
     
                 *     2、移除addEventListener添加的事件
                 *         对象.removeEventListener(事件名称,事件绑定函数,boolean);
                 *         注意:1、不能移除掉addEventListener添加的匿名函数

                 *             2、只能移除同一阶段的绑定函数(所有参数都要一样)


       
    1. var btn2=document.getElementById("btn2");
    2. //addEventListener方式添加的事件(匿名函数)
    3. btn2.addEventListener('click',function(){
    4. console.log('这是按钮二的第一次点击');
    5. console.log(this); //指向事件发生的那个对象
    6. },false);
    7. btn2.addEventListener('click',function(){
    8. console.log('这是按钮二的第二次点击');
    9. },false);
    10. //当点击btn2 两个click事件的内容都被打印出来
    11.                 //removeEventListener移除不了匿名函数
                      /*btn2.removeEventListener('click',function(){
                          console.log('这是按钮二的第一次点击');
                          console.log(this);            //指向事件发生的那个对象
      1. },false);*/
    1. //addEventListener方式添加的事件(命名函数)
    2. btn2.addEventListener('mouseover',fn1,false);
    3. btn2.addEventListener('mouseover',fn2,false);
    4. function fn1(){
    5. console.log('这是按钮二的第一个mouseover事件');
    6. console.log(this); //指向事件发生的那个对象
    7. }
    8. function fn2(){
    9. console.log('这是按钮二的第二个mouseover事件');
    10. }
                            //removeEventListener移除命名函数
                            btn2.removeEventListener('mouseover',fn1,true);
                      btn2.removeEventListener('mouseover',fn2,false);
    1. <inputtype="button"id="btn2"value="按钮2"/>
    十、事件流
     
                 *     事件流指事件在触发时的一个流程,就像for循环一样有一个执行的过程。
                 *     在事件触发时,会先执行一个阶段叫做“捕获阶段”,从最外层向触发该事件元素寻找的一个过程。最终找到触发该事件的元素,如果                    该元素有绑定事件处理函数则执行该函数。
                 *     在找到触发该事件的元素之后,如果这元素身上有事件,就会执行他的事件,称为“目标阶段”
                 *     接下来会进行下一个阶段“冒泡阶段”,冒泡阶段是从目标元素的上一层开始往外层寻找,直到最外层时结束整个事件流程。
                 *     不论是捕获阶段还是冒泡阶段,在寻找目标元素的过程和向外返回的过程中,所遇到每一个元素身上如果有相同事件的事件处理函数都会被调用。
                 *     
                 *     注意:低版本IE浏览器的事件只能绑定在冒泡阶段
     
    1. window.onload=function(){
    2. var div=document.getElementById("div");
    3. var span=document.getElementById("span");
    4. var html=document.getElementById("html");
    5. var body=document.getElementById("body");
    6. window.id='window1';
    7. function fn(){
    8. console.log(this.id);
    9. }
    10. //用on的方法给元素添加事件,所有的浏览器都是一样的,先触发事件源对象,然后再往外执行(冒泡的阶段)
    11. window.onclick=fn; //window1
    12. html.onclick=fn; //html window1
    13. body.onclick=fn; //body html window1
    14. div.onclick=fn; //div body html window1
    15. span .onclick=fn; //span div body html window1
    16. };
    17. </script>
    18. </head>
    19. <bodyid="body">
    20. <divid="div">div
    21. <spanid="span">span</span>
    22. </div>
    23. </body>
       在目标阶段,如果目标事件有多个同样的事件,会按照书写的顺序先后执行。
    1. <script>
    2. window.onload=function(){
    3. var btn=document.getElementById("btn");
    4. //btn就是一个目标元素,因为他没有发生嵌套。他身上的事件就是按书写顺序来执行
    5. btn.addEventListener('click',function(){
    6. alert('冒泡');
    7. },false);
    8. btn.addEventListener('click',function(){
    9. alert('捕获');
    10. },true);
    11. //因为btn具有两个click事件,当在目标阶段的时候,不受执行阶段(true)和冒泡阶段(false)影响,
    12.                 只受书写顺序先后影响,先后执行。
    13. };
    14. </script>
    15. </head>
    16. <body>
    17. <inputtype="button"id="btn"value="按钮"/>
    18. </body>
    十一、防止事件冒泡
                 *     1、on添加的事件
                 *         在函数中将event对象身上的cancelBubble的值设为true
                 *         他有一个默认值为false,代表事件可以冒泡
                 *         在哪一层上添加这个属性,那事件就会停在这里,不会往外冒泡
    1. var box1=document.getElementById("box1");
    2. var box2=document.getElementById("box2");
    3. var box3=document.getElementById("box3");
    4. //用on添加事件
    5. box1.onclick=function(ev){
    6. console.log('box1点击了');
    7. ev.cancelBubble=true;
    8. };
    9. box2.onclick=function(ev){
    10. console.log('box2点击了');
    11. ev.cancelBubble=true;
    12. };
    13. box3.onclick=function(ev){
    14. console.log('box3点击了');
    15. ev.cancelBubble=true;
    16. };
    17. };
    18. <divid="box1">box1
    19. <divid="box2">box2
    20. <divid="box3">box3</div>
    21. </div>
    22. </div>
                 *     2、用addeventListener添加的事件
                 *         在事件函数内调用event身上的stopPropagation()方法
                 *         在哪一层上添加这个方法,那事件就会停在这里,不会往外冒泡
    1. //用addeventListener添加的事件
    2. var box4=document.getElementById("box4");
    3. var box5=document.getElementById("box5");
    4. var box6=document.getElementById("box6");
    5. box4.addEventListener('click',function(ev){
    6. console.log('box4点击了');
    7. ev.stopPropagation();
    8. });
    9. box5.addEventListener('click',function(ev){
    10. console.log('box5点击了');
    11. ev.stopPropagation();
    12. });
    13. box6.addEventListener('click',function(ev){
    14. console.log('box6点击了');
    15. ev.stopPropagation();
    16. });
    17. <divid="box4">box4
    18. <divid="box5">box5
    19. <divid="box6">box6</div>
    20. </div>
    21. </div>
    十二、阻止浏览器默认行为
       
                 *     需要知道这些默认行为什么时候发生
                 *     1、on添加的的
                 *         在函数里写上一句return false
                 *     2、addEventListener添加的
                 *         在函数里调用event身上的preventDefault();
    1. //阻止右键菜单
    2. document.oncontextmenu=function(){
    3. return false;
    4. };
    5. document.addEventListener('contextmenu',function(ev){
    6. ev.preventDefault();
    7. },false);
    十三、滚轮事件(不兼容)
                 *     mousewheel            IE/Chrome
                 *         滚动的方向        event.wheelDelta
                 *                         上:120(正数)
                 *                         下:-120(负数)
                 * 
                 *     DOMMouseScroll        FF(必需要用addEventListener添加)
                 *         滚动的方向        event.detail
                 *                         上:-3(负数)
                 *                         下:3(正数)
    1. document.onmousewheel=function(ev){
    2. console.log('鼠标滚动了-Chrom',ev.wheelDelta);
    3. };
    4. document.addEventListener('DOMMouseScroll',function(ev){
    5. console.log('鼠标滚动了-FF',ev.detail);
    6. });
    十四、拖拽原理以及需要注意的问题
                 *     1、鼠标在元素身上按下
                 *         这里需要算出鼠标点击的地方离元素边界的距离
                 *         鼠标起始X轴的位置=鼠标的clientX-元素的offsetLeft
                 *         鼠标起始Y轴的位置=鼠标的clientY-元素的offsetTop
                 * 
                 *     2、鼠标移动
                 *         这里需要算出来元素的真正left与top值
                 *         元素的left=鼠标的clientX-鼠标起始X轴的位置
                 *         元素的top=鼠标的clientY-鼠标起始Y轴的位置
                 * 
                 *     3、鼠标抬起
                 *         清除掉鼠标身上的事件
                 * 
                 * 
                 * 问题:
                 *     1、只能拖拽一次
                 *         解决方法1:声明一个变量,用来判断用户有没有点击方块
                 *         解决方法2:把所有的要处理的整改放在mousedown里面去做,就可以解决。
                 *     2、鼠标拖动的速度非常快的时候,就会脱离方块
                 *         原因是因为mousemove事件的发生是根据浏览器的频率决定的,如果鼠标移动的非常快,那mousemove事件有可能没有发生,所以就会断了
                 *         解决方法:把move事件加给document
                 *     3、有文字的时候会选中文字
                 *         解决方法:return false;   (阻止浏览器默认行为)
                 *     4、拖动图片的时候会复制一张图片
                 *         解决方法:return false;
    1. var box=document.getElementById("box");
    2. //鼠标按下
    3. box.onmousedown=function(ev){
    4. var disX=ev.clientX-box.offsetLeft;
    5. var disY=ev.clientY-box.offsetTop;
    6. //console.log(disX,disY);
    7. //鼠标移动
    8. document.onmousemove=function(ev){
    9. box.style.left=ev.clientX-disX+'px';
    10. box.style.top=ev.clientY-disY+'px';
    11. };
    12. //鼠标抬起
    13. document.onmouseup=function(){
    14. document.onmousemove=null;
    15. };
    16. //阻止默认选中文字
    17. return false;
    18. };
    19. };
    20. </script>
    21. </head>
    22. <body>
    23. kaivon
    24. <divid="box"></div>
     





  • 相关阅读:
    vue自定义指令
    ZOJ Problem Set–2104 Let the Balloon Rise
    ZOJ Problem Set 3202 Secondprice Auction
    ZOJ Problem Set–1879 Jolly Jumpers
    ZOJ Problem Set–2405 Specialized FourDigit Numbers
    ZOJ Problem Set–1874 Primary Arithmetic
    ZOJ Problem Set–1970 All in All
    ZOJ Problem Set–1828 Fibonacci Numbers
    要怎么样调整状态呢
    ZOJ Problem Set–1951 Goldbach's Conjecture
  • 原文地址:https://www.cnblogs.com/CafeMing/p/6555331.html
Copyright © 2011-2022 走看看