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>
     





  • 相关阅读:
    Css几个兼容性问题
    一些常用的正则表达式
    超链接hover切换效果
    读取根目录src下的指定配置properties文件内容
    SQL Server查询表结构语句
    单独使用ibatis做事物控制。
    ibatis调用存储过程(无返回参数)
    oracle split函数
    Jquery调用Ajax实现联动使用json
    简单分页插件
  • 原文地址:https://www.cnblogs.com/CafeMing/p/6555331.html
Copyright © 2011-2022 走看看