这篇文章主要为大家介绍了 javascript 实现自定义事件的方法,自定义事件,顾名思义,就是自己定义事件类型,自己定义事件处理函数,javascript 如何实现自定义事件, 需要了解的朋友可以参考下
Javascript 是一种由 Netscape 的 LiveScript 发展而来的原型化继承的基于对象的动态类型的区分大小写的客户端脚本语言,主要目的是为了解决服务器端语言,比如 Perl,遗留的速度问题,为客户提供更流畅的浏览效果。
我们平时在操作 dom 时候经常会用到 onclick,onmouseover 等一系列浏览器特定行为的事件,
那么自定义事件,顾名思义,就是自己定义事件类型,自己定义事件处理函数,在合适的时候需要哪个事件类型,就去调用哪个处理程序
1.js 所支持的浏览器默认事件
浏览器特定行为的事件,或者叫系统事件,js 默认事件等等都行,大家知道我指的什么就行,下文我叫他 js 默认事件。
js 默认事件的事件绑定,事件移出等一系列操作,相信大家都有用到过,如:
- //DOM0级事件处理程序
- var oDiv = document.getElementById('oDiv');
- oDiv.onclick = function(){
- alert("你点击了我");
- }
又或者
- //DOM2级事件处理程序
- var oDiv = document.getElementById('oDiv');
- //非ie
- oDiv.addEventListener("click",
- function() {
- alert("你点击了我");
- },
- false);
- //ie
- oDiv.attachEvent("onclick",
- function() {
- alert("你点击了我");
- });
所有我就不做过多的研究,毕竟我们来讨论 js 自定义事件,这里给出一个我之前封装过的处理 js 默认事件的代码:
- //跨浏览器的事件处理程序
- //调用时候直接用domEvent.addEvent( , , );直接调用
- //使用时候,先用addEvent添加事件,然后在handleFun里面直接写其他函数方法,如getEvent;
- //addEventListener和attachEvent---都是dom2级事件处理程序
- var domEvent = {
- //element:dom对象,event:待处理的事件,handleFun:处理函数
- //事件名称,不含"on",比如"click"、"mouseover"、"keydown"等
- addEvent:function(element,event,handleFun){
- //addEventListener----应用于mozilla
- if(element.addEventListener){
- element.addEventListener(event,handleFun,false);
- }//attachEvent----应用于IE
- else if(element.attachEvent){
- element.attachEvent("on"+event,handleFun);
- }//其他的选择dom0级事件处理程序
- else{
- //element.onclick===element["on"+event];
- element["on"+event] = handleFun;
- }
- },
- //事件名称,含"on",比如"onclick"、"onmouseover"、"onkeydown"等
- removeEvent:function(element,event,handleFun){
- //removeEventListener----应用于mozilla
- if (element.removeEventListener) {
- element.removeEventListener(event,handleFun,false);
- }//detachEvent----应用于IE
- else if (element.detachEvent) {
- element.detachEvent("on"+event,handleFun);
- }//其他的选择dom0级事件处理程序
- else {
- element["on"+event] = null;
- }
- },
- //阻止事件冒泡
- stopPropagation:function(event){
- if(event.stopPropagation){
- event.stopPropagation();
- }else{
- event.cancelBubble = true;//IE阻止事件冒泡,true代表阻止
- }
- },
- //阻止事件默认行为
- preventDefault:function(event){
- if(event.preventDefault){
- event.preventDefault();
- }else{
- event.returnValue = false;//IE阻止事件冒泡,false代表阻止
- }
- },
- //获得事件元素
- //event.target--非IE
- //event.srcElement--IE
- getElement:function(event){
- return event.target || event.srcElement;
- },
- //获得事件
- getEvent:function(event){
- return event? event : window.event;
- },
- //获得事件类型
- getType:function(event){
- return event.type;
- }
- };
接下类我们不如正题,js 自定义事件
2. 对象直接量封装 js 自定义事件
根据上面的封装,我们可以这样构思
- var eventTarget = {
- addEvent: function(){
- //添加事件
- },
- fireEvent: function(){
- //触发事件
- },
- removeEvent: function(){
- //移除事件
- }
- };
相信这样大家还是比较好理解的,然后又有一个问题大家可以想到,那就是,js 默认事件,js 可以一一对应,知道那个是那个,那么我们的自定义事件呢,这个一一对应的映射表只能我们自己去建立,然后我这样
- var eventTarget = {
- //保存映射
- handlers:{},
- addEvent: function(){
- //处理代码
- },
- fireEvent: function(){
- //触发代码
- },
- removeEvent: function(){
- //移出代码
- }
- };
我是这样构建这个映射关系的
- handlers = {
- "type1":[
- "fun1",
- "fun2",
- // "..."
- ],
- "type2":[
- "fun1",
- "fun2"
- // "..."
- ]
- //"..."
- }
这样每一个类型可以有多个处理函数,以便于我们以后扩充
接下来就是代码方面的实战的,编写具体的处理代码了…
相信大家对于这个思路已经很清楚了,我直接附上代码
- //直接量处理js自定义事件
- var eventTarget = {
- //保存事件类型,处理函数数组映射
- handlers:{},
- //注册给定类型的事件处理程序,
- //type -> 自定义事件类型, handler -> 自定义事件回调函数
- addEvent: function(type, handler){
- //判断事件处理数组是否有该类型事件
- if(eventTarget.handlers[type] == undefined){
- eventTarget.handlers[type] = [];
- }
- //将处理事件push到事件处理数组里面
- eventTarget.handlers[type].push(handler);
- },
- //触发一个事件
- //event -> 为一个js对象,属性中至少包含type属性,
- //因为类型是必须的,其次可以传一些处理函数需要的其他变量参数。(这也是为什么要传js对象的原因)
- fireEvent: function(event){
- //判断是否存在该事件类型
- if(eventTarget.handlers[event.type] instanceof Array){
- var _handler = eventTarget.handlers[event.type];
- //在同一个事件类型下的可能存在多种处理事件,找出本次需要处理的事件
- for(var i = 0; i < _handler.length; i++){
- //执行触发
- _handler[i](event);
- }
- }
- },
- //注销事件
- //type -> 自定义事件类型, handler -> 自定义事件回调函数
- removeEvent: function(type, handler){
- if(eventTarget.handlers[type] instanceof Array){
- var _handler = eventTarget.handlers[type];
- //在同一个事件类型下的可能存在多种处理事件,找出本次需要处理的事件
- for(var i = 0; i < _handler.length; i++){
- //找出本次需要处理的事件下标
- if(_handler[i] == handler){
- break;
- }
- }
- //删除处理事件
- _handler.splice(i, 1);
- }
- }
- };
这是一种调用运行的方法
- eventTarget.addEvent("eat",
- function() {
- console.log(123); //123
- });
- eventTarget.fireEvent({
- type: "eat"
- });
这种方法有一个缺点,不能删除该处理事件,因为我们是用映射表做的,而且也不提倡,直接给映射表里面存这么多数据,有点多。
另一种方法,将处理事件提取出来(推荐)
- function b() {
- console.log(123);
- }
- eventTarget.addEvent("eat", b);
- eventTarget.fireEvent({
- type: "eat"
- }); //123
- eventTarget.removeEvent("eat", b);
- eventTarget.fireEvent({
- type: "eat"
- }); //空
也可以这样,传递更多的参数
- eventTarget.fireEvent({
- type: "eat",
- food: "banana"
- });
- function b(data){
- console.log(data.food); //banana
- }
总结:字面量这种方法,有点儿缺点,就是万一一不小心,把某个属性在 handler 函数里面,赋值 null,这样会造成我们的的 eventTarget 方法崩盘。看来原型应该是个好方法,更安全一点。
3. 对象原型封装 js 自定义事件
由于前面思路基本都讲清楚了,这里我直接附上代码,大家可以研究下其中的利弊,或许你可以找到更好的方法解决 Ta…
- //自定义事件构造函数
- function EventTarget(){
- //事件处理程序数组集合
- this.handlers = {};
- }
- //自定义事件的原型对象
- EventTarget.prototype = {
- //设置原型构造函数链
- constructor: EventTarget,
- //注册给定类型的事件处理程序,
- //type -> 自定义事件类型, handler -> 自定义事件回调函数
- addEvent: function(type, handler){
- //判断事件处理数组是否有该类型事件
- if(typeof this.handlers[type] == 'undefined'){
- this.handlers[type] = [];
- }
- //将处理事件push到事件处理数组里面
- this.handlers[type].push(handler);
- },
- //触发一个事件
- //event -> 为一个js对象,属性中至少包含type属性,
- //因为类型是必须的,其次可以传一些处理函数需要的其他变量参数。(这也是为什么要传js对象的原因)
- fireEvent: function(event){
- //模拟真实事件的event
- if(!event.target){
- event.target = this;
- }
- //判断是否存在该事件类型
- if(this.handlers[event.type] instanceof Array){
- var handlers = this.handlers[event.type];
- //在同一个事件类型下的可能存在多种处理事件,找出本次需要处理的事件
- for(var i = 0; i < handlers.length; i++){
- //执行触发
- handlers[i](event);
- }
- }
- },
- //注销事件
- //type -> 自定义事件类型, handler -> 自定义事件回调函数
- removeEvent: function(type, handler){
- //判断是否存在该事件类型
- if(this.handlers[type] instanceof Array){
- var handlers = this.handlers[type];
- //在同一个事件类型下的可能存在多种处理事件
- for(var i = 0; i < handlers.length; i++){
- //找出本次需要处理的事件下标
- if(handlers[i] == handler){
- break;
- }
- }
- //从事件处理数组里面删除
- handlers.splice(i, 1);
- }
- }
- };
调用方法
- function b(){
- console.log(123);
- }
- var target = new EventTarget();
- target.addEvent("eat", b);
- target.fireEvent({
- type: "eat"
- }); //123
原型这种方法,与直接量方法功能是一样的…
来源: