javascript面试题（下）

61、常见的 HTTP 请求有哪些 ? 他们的区别是什么 ?

常见的有5种，分别是GET、HEAD, POST、PUT、 DELETE

GET：它是最常见的方法，用于获取资源，常用于向服务器查询某些信息。打开网页一般都是用GET方法，因为要从 Web 服务器获取信息

HEAD：类似于 GET请求，只不过返回的响应中没有具体的内容，用于获取报头。

POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）， 数据被包含在请求体中。POST请求可能会导致新的资源的建立和／或对已有资源的修改。

PUT：从客户端向服务器传送的数据取代指定文档的内容。

DELETE：请求服务器删除指定的页面。

最常见的HTTP请求方法是GET 和 POST。GET一般用于获取／查询资源信息，而POST一般用于更新资源信息。GET和POST的区别：

GET提交的数据会放在?之后，以问号（？）分割URL 和传输数据，参数之间以＆相连

GET提交的数据大小有限制（因为浏览器对URL的长度有限制）， 而POST 方法提交的数据大小没有限制。

GET方式提交数据会带来安全问题，比如一个登录页面通过GET方式提交数据时，用户名和密码将出现在URL上，如果页面可以被缓存或者其他人可以访问这台机器，就可以从历史记录获得该用户的账号和密码。

62、 JS 的数据类型有哪些 ? 如何判断数据类型 ?他们的优缺点是什么？

typeof 用来检测数据类型的运算符

检测的不管是数组还是正则都返回的是"object",所以typeof不能判断一个值是否为数组
instanceof/constructor。检测某一个实例是否属于某一个类使用instanceof/constructor可以检测数组和正则

用instanceof检测的时候,只要当前的这个类在实例的原型链上(可以通过原型链__proto__找到它),检测出来的结果都是true。

基本数据类型的值是不能用instanceof来检测的

在类的原型继承中,instanceof检测出来的结果其实是不准确的
Object.prototype.toString.call(value) ->找到Object原型上的toString方法,让方法执行,并且让方法中的this变为value(value->就是我们要检测数据类型的值)。检测的类型比较多，也比较精准。

63、 symbol 你是怎么理解的 ?

Symbol 是 ES6 新推出的一种基本类型，它表示独一无二的值

它可以选择接受一个字符串作为参数或者不传，但是相同参数的两个Symbol值不相等

   //不传参数
    const s1 = Symbol(); 
    const s2 = Symbol(); 
    console.log(s1 === s2); // false 
    
    // 传入参数
    const s3 = Symbol('debug'); 
    const s4 = Symbol('debug'); 
    console.log(s3 === s4); // false 

可以通过typeof判断是否为Symbol类型

    console.log(typeof s1); // symbol 

Symbol.for()：用于将描述相同的Symbol变量指向同一个Symbol值

    let a1 = Symbol.for('a'); 
    let a2 = Symbol.for('a'); 
    a1 === a2  // true 
    typeof a1  // "symbol" 
    typeof a2  // "symbol" 
    
    let a3= Symbol("a"); 
    a1 === a3      // false 

Symbol.keyFor()：用来检测该字符串参数作为名称的 Symbol值是否已被登记，返回一个已登记的 Symbol 类型值的key

    let a1 = Symbol.for("a"); 
    Symbol.keyFor(a1);    // "a" 
    
    let a2 = Symbol("a"); 
    Symbol.keyFor(a2);    // undefined 

description：用来返回Symbol数据的描述：

    // Symbol()定义的数据
    let a = Symbol("acc"); 
    a.description  // "acc" 
    Symbol.keyFor(a);  // undefined 
    
    // Symbol.for()定义的数据
    let a1 = Symbol.for("acc"); 
    a1.description  // "acc" 
    Symbol.keyFor(a1);  // "acc" 
    
    // 未指定描述的数据
    let a2 = Symbol(); 
    a2.description  // undefined 

使用场景一：对象添加属性

    let n = Symbol('N');  
    let obj = {
    
        name: "hello world", 
        age: 11, 
        [n]: 100 
    };

使用场景二：给对象添加私有属性

    const speak = Symbol();  
    class Person {
     
        [speak]() {
     
            console.log(123)
        }
    }
    let person = new Person()  
    console.log(person[speak]())  

64、数组常用方法有那些

数组的常用方法 这样的面试题 算是非常基础的面试题 面试官的目的 也不会只是单纯的让你背诵出 数组的所有方法

这里的关键点 是 常用 这两个字 面试官的 目的是 通过 这个问题 看你平时在项目中 对于 数组函数的应用和理解 然后判断出 你平时在项目中对于数组的应用 然后推测出你真实的技术水平

这里建议的回答方式是 通过一个 自己用的最多的数组函数方法 深入展开的说一说 在 实际项目中的应用

例如谈到 数组单元删除 数组,splice() 除了要说 函数的用法之外 还要谈到 具体的项目中 删除数组单元之后 数组坍塌的影响 以及如何处理

concat() 连接两个或更多的数组，并返回结果。

join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。

pop() 删除并返回数组的最后一个元素。 

shift() 删除并返回数组的第一个元素

push() 向数组的末尾添加一个或更多元素，并返回新的长度。

unshift() 向数组的开头添加一个或更多元素，并返回新的长度。

reverse() 颠倒数组中元素的顺序。

slice() 从某个已有的数组返回选定的元素

sort() 对数组的元素进行排序

splice() 删除元素，并向数组添加新元素。

toSource() 返回该对象的源代码。

toString() 把数组转换为字符串，并返回结果。

toLocaleString() 把数组转换为本地数组，并返回结果。

valueOf() 返回数组对象的原始值

65、JavaScript如何存储cookie

基本语法是 document.cookie = ‘键名=键值;expires=时间对象;path=路径’ ;

时效 如果不设定 默认是 seeion 会话时效路径 如果不设定 默认是 当前文件所在文件夹

设定时效 要 设定一个时间对象 时间对象的时间戳 就是 时效期要注意计算 当前时区 和 世界标砖时间的时间差

路径一般设定为根目录 也就是 ‘/’

66、柯理化函数

所谓的柯里化函数 指的是 把接受多个参数的函数变换成接受一个单一参数的函数 并且返回接受余下的参数而且返回结果的新函数

// 普通的add函数
function add(x, y) {
     
    return x + y  
}

// Currying后  
function curryingAdd(x) {
     
    return function (y) {
     
        return x + y  
    }
}

add(1, 2)           // 3  
curryingAdd(1)(2)   // 3  

优点:

1, 参数复用

例如 一个函数 有两个参数 但是第一个参数会被反复使用 每次都需要输入 一个重复的参数
使用柯里化函数之后 只需要 输入一个参数就可以了

2, 提前确认

提前定义好一个参数 也就 决定了整个函数程序的执行方向 避免每次都执行判断比较等

缺点:

只能提前定义一个参数 如果想要提前定义多个参数 这样的语法是不支持

柯里化函数执行效能上的问题:

存取arguments对象通常要比存取命名参数要慢一点
一些老版本的浏览器在arguments.length的实现上是相当慢的
使用 函数.apply() 和 函数.call() 通常比直接调用 fn() 稍微慢点
创建大量嵌套作用域和闭包函数会带来花销，无论是在内存还是速度上

67、对象遍历方法

JavaScript中 对象的遍历方法

for…in

基本语法是 for( 变量 in 对象 ){ 循环体程序 }

这里要注意的是
1, 变量中存储的键名 通过键名获取对象中存储的键值
因为是变量 点语法取值 不支持解析变量 要使用 对象[键名] 获取键值

2, 循环变量 定义 let 和 var 定义 执行效果是不同的

Object.keys( 对象 )

返回一个数组 是 当前对象 所有键名组成的数组
之后再循环遍历这个数组 再执行操作

Object.value( 对象 )

返回一个数组 是 当前对象 所有键值组成的数组
之后再循环遍历这个数组 再执行操作

68、数组扁平化

数组扁平化

所谓的数组扁平化就是将多维数组转化为一维数组一般数组扁平化,数组中存储的多维数据都是数组 不会是对象或者函数

最常用的方法 就是 数组.toString() 将数组转化为字符串 结果是 获取数组中的每一个单元的数据 组成一个字符串 使用逗号间隔 再 以逗号为间隔 将字符串 转化为数组

function fun1( arr ){
      
   let str = arr.toString();  
   return str.split(',');  
}

还可以使用 数组.some() 方法 判断数组中是不是还存在数组 在使用 展开运算符 赋值

function fun1(arr) {
     
    while (arr.some(item => Array.isArray(item))) {
     
        arr = [].concat(...arr);  
    }
    return arr;  
}

另外 ES6 语法中 新增的 flat函数也可以实现数组的扁平化参数是固定的

const arr = 原始数组.flat( Infinity );   

69、typeof 原理

利用 typeof 是根据返回值的结果来判断数据类型

具体返回值 一共是 number, string, object, boolean, function, undefined

其中 数组 null 对象 的返回值 都是 object这样的话具体的数据类型就不能区分的非常明确 在实际项目中 就不能准确的区分

如果想要具体的 区分 数据类型 需要使用 Object.prototype.toString.call() 方法 返回值是

object String 字符串  
object Number 数值类型
object Boolean 布尔类型
object Undefined undefined类型  
object Null null类型  
object Function 函数类型
object Array 数组类型

70、介绍类型转化

JavaScript 因为是 弱类型计算机语言 存储数据时 对变量储存的数据类型没有设定因此一个变量中可以存储任意类型的数据 在程序的执行过程中 就会遇到需要数据类型转化的情况

自动转化
自动转化为字符串
数据 直接转化为 对应的字符串
自动转化为数值类型 转化为 对应的数值 1 true 0 false null “” ‘’

符合数字规范的字符串
转化为 NaN
不符合数字规范的字符串
undefined

自动转化为数值类型
false:
0 0.0000 ‘’ NaN null undefined
true:
其他情况都转化为 true

强制转化
强制转化为布尔类型
Boolean( 变量 / 表达式 )
转化原则 和 自动转化原则完全相同
false : 0 0.000 ‘’ null NaN undefined
true : 其他情况都转化为true

强制转化为字符串类型
String( 变量 / 表达式 );
转化原则 和 自动转化原则完全相同
不会改变 变量中存储的原始数据
变量.toString( 进制 ) ;
转化原则 和 自动转化原则完全相同
不会改变 变量中存储的原始数据
如果是 整数类型 可以 设定 转化的进制
变量 存储 null 或者 undefined不支持

强制转化为数值类型
Number()
转化原则 和 自动转化完全相同
不会改变 变量中存储的原始内容
parseInt()
从 左侧起 获取符合整数语法规范的内容部分
如果 左起第一个字符就不符合整数语法规范
执行结果是 NaN
parseFloat()
从 左侧起 获取符合浮点数语法规范的内容部分
如果 左起第一个字符就不符合浮点数语法规范
执行结果是 NaN

71、执行上下文

执行上下文：指当前执行环境中的变量、函数声明，参数（arguments），作用域链，this等信息。分为全局执行上下文、函数执行上下文，其区别在于全局执行上下文只有一个，函数执行上下文在每次调用函数时候会创建一个新的函数执行上下文。

变量对象是与执行上下文相关的数据作用域，存储了上下文中定义的变量和函数声明。

变量对象式一个抽象的概念，在不同的上下文中，表示不同的对象:

全局执行上下文的变量对象全局执行上下文中，变量对象就是全局对象。在顶层js代码中，this指向全局对象，全局变量会作为该对象的属性来被查询。在浏览器中，window就是全局对象。函数执行上下文的变量对象函数上下文中，变量对象VO就是活动对象AO。初始化时，带有arguments属性。函数代码分成两个阶段执行进入执行上下文时，此时变量对象包括形参函数声明，会替换已有变量对象变量声明，不会替换形参和函数函数执行

执行上下文栈的作用是用来跟踪代码的，由于JS是单线程的，每次只能做一件事情，其他的事情会放在指定的上下文栈中排队等待执行。

JS解释器在初始化代码的时候，首先会创建一个新的全局执行上下文到执行上下文栈顶中，然后随着每次函数的调用都会创建一个新的执行上下文放入到栈顶中，随着函数执行完毕后被执行上下文栈顶弹出，直到回到全局的执行上下文中。

首先创建了全局执行上下文，当前全局执行上下文处于活跃状态。全局代码中有2个函数 getName 和 getYear，然后调用 getName 函数，JS引擎停止执行全局执行上下文，创建了新的函数执行上下文，且把该函数上下文放入执行上下文栈顶。getName 函数里又调用了 getYear 函数，此时暂停了 getName 的执行上下文，创建了 getYear 函数的新执行上下文，且把该函数执行上下文放入执行上下文栈顶。当 getYear 函数执行完后，其执行上下文从栈顶出栈，回到了 getName 执行上下文中继续执行。当 getName 执行完后，其执行上下文从栈顶出栈，回到了全局执行上下文中。

72、闭包的问题和优化

闭包：是指有权访问另外一个函数作用域中的变量的函数。创建闭包的常见方式就是在一个函数内部创建另外一个函数。

作用：

1、可以读取函数内部的变量2、相当于划出了一块私有作用域，避免数据污染；3、让变量始终保存在内存中
闭包有三个特性：

1.函数嵌套函数

2.函数内部可以引用外部的参数和变量

3.参数和变量不会被垃圾回收机制回收
闭包的问题

闭包会产生不销毁的上下文，会导致栈/堆内存消耗过大，有时候也会导致内存泄漏等，影响页面的运行性能，所以在真实项目中，要合理应用闭包！
闭包的优化

原始代码

function MyObject(name, message) {
     
  this.name = name.toString();  
  this.message = message.toString();  
  this.getName = function() {
     
    return this.name;  
  };

  this.getMessage = function() {
     
    return this.message;  
  };
}

优化代码

function MyObject(name, message) {
      
  this.name = name.toString();  
  this.message = message.toString();  
}
MyObject.prototype.getName = function() {
     
  return this.name;  
};
MyObject.prototype.getMessage = function() {
     
  return this.message;  
};

73、浏览器和Node事件循环的区别

一、全局环境下this的指向

在node中this指向global而在浏览器中this指向window，这就是为什么underscore中一上来就定义了一 root；

而且在浏览器中的window下封装了不少的API 比如 alert 、document、location、history 等等还有很多。我门就不能在node环境中xxx();或window.xxx();了。因为这些API是浏览器级别的封装，存javascript中是没有的。当然node中也提供了不少node特有的API。

二、js引擎

在浏览器中不同的浏览器厂商提供了不同的浏览器内核，浏览器依赖这些内核解释折我们编写的js。但是考虑到不同内核的少量差异，我们需要对应兼容性好在有一些优秀的库帮助我们处理这个问题比如jquery、underscore等等。

nodejs是基于Chromes JavaScript runtime，也就是说，实际上它是对GoogleV8引擎（应用于Google Chrome浏览器)进行了封装。V8引 擎执行Javascript的速度非常快，性能非常好。

NodeJS并不是提供简单的封装，然后提供API调用，如果是这样的话那么它就不会有现在这么火了。Node对一些特殊用例进行了优化，提供了替代的API，使得V8在非浏览器环境下运行得更好。例如，在服务器环境中，处理二进制数据通常是必不可少的，但Javascript对此支持不足，因此，V8.Node增加了Buffer类，方便并且高效地 处理二进制数据。因此，Node不仅仅简单的使用了V8,还对其进行了优化，使其在各环境下更加给力。

三、DOM操作

浏览器中的js大多数情况下是在直接或间接（一些虚拟DOM的库和框架）的操作DOM。因为浏览器中的代码主要是在表现层工作。但是node是一门服务端技术。没有一个前台页面，所以我门不会再node中操作DOM。

四、I/O读写

与浏览器不同，我们需要像其他服务端技术一样读写文件，nodejs提供了比较方便的组件。而浏览器（确保兼容性的）想在页面中直接打开一个本地的图片就麻烦了好多（别和我说这还不简单，相对路径。。。。。。试试就知道了要么找个库要么二进制流，要么上传上去有了网络地址在显示。不然人家为什么要搞一个js库呢），而这一切node都用一个组件搞定了。

五、模块加载

javascript有个特点，就是原生没提供包引用的API一次性把要加载的东西全执行一遍，这里就要看各位闭包的功力了。所用东西都在一起，没有分而治之，搞的特别没有逻辑性和复用性。如果页面简单或网站当然我们可以通过一些AMD、CMD的js库（比如requireJS 和 seaJS）搞定事实上很多大型网站都是这么干的。

在nodeJS中提供了CMD的模块加载的API，如果你用过seaJS，那么应该上手很快。
node还提供了npm 这种包管理工具，能更有效方便的管理我们饮用的库

74、移动端点击延迟

原因 :

为了确定用户是要做单击 还是双击 还是要做其他的操作 因此移动端 当你点击时 会有 300毫秒延迟 为了等待判断用户的下一步操作是什么

解决方案1

禁用缩放

<meta name="viewport" content="user-scalable=no">   
<meta name="viewport" content="initial-scale=1,maximum-scale=1">  

当HTML文档头部包含以上meta标签时 表明这个页面是不可缩放的，那双击缩放的功能就没有意义了，此时浏览器可以禁用默认的双击缩放行为并且去掉300ms的点击延迟。
这个方案有一个缺点，就是必须通过完全禁用缩放来达到去掉点击延迟的目的，然而完全禁用缩放并不是我们的初衷，我们只是想禁掉默认的双击缩放行为，这样就不用等待300ms来判断当前操作是否是双击。但是通常情况下，我们还是希望页面能通过双指缩放来进行缩放操作，比如放大一张图片，放大一段很小的文字。
解决方案2 更改默认的视口宽度

<meta name="viewport" content="width=device-width">  

一开始，为了让桌面站点能在移动端浏览器正常显示，移动端浏览器默认的视口宽度
并不等于设备浏览器视窗宽度，而是要比设备浏览器视窗宽度大，通常是980px。
我们可以通过以下标签来设置视口宽度为设备宽度。因为双击缩放主要是用来改善
桌面站点在移动端浏览体验的，而随着响应式设计的普及，很多站点都已经对移动
端坐过适配和优化了，这个时候就不需要双击缩放了，如果能够识别出一个网站是
响应式的网站，那么移动端浏览器就可以自动禁掉默认的双击缩放行为并且去掉
300ms的点击延迟。如果设置了上述meta标签，那浏览器就可以认为该网站已经
对移动端做过了适配和优化，就无需双击缩放操作了。
这个方案相比方案一的好处在于，它没有完全禁用缩放，而只是禁用了浏览器默认
的双击缩放行为，但用户仍然可以通过双指缩放操作来缩放页面。

解决方案3 CSS touch-action

跟300ms点击延迟相关的，是touch-action这个CSS属性。这个属性指定了相应元素上能够触发的用户代理（也就是浏览器）的默认行为。如果将该属性值设置为touch-action: none，那么表示在该元素上的操作不会触发用户代理的任何默认行为，就无需进行300ms的延迟判断。

最后的最后 我们还可以使用一些 插件来解决这个问题 例如 FastClick 是 FT Labs 专门为解决移动端浏览器 300 毫秒点击延迟问题所开发的一个轻量级的库。FastClick的实现原理是在检测到touchend事件的时候，会通过DOM自定义事件立即出发模拟一个click事件，并把浏览器在300ms之后的click事件阻止掉。

安装 npm install fastclick -S

使用 如何你是vue项目可以在main.js里面直接引入，当然这样是全局的，如果你需要某个页面用到，那就单个页面引入。

//引入
import fastClick from ‘fastclick’
//初始化FastClick实例。在页面的DOM文档加载完成后
fastClick.attach(document.body)

75、cookie属性

cookie的常见属性

键名 cookie键值对的键名
键值 cookie键值对的键值
expirescookie的时效 分为 session会话时效 时间时效 时间时效是服务器时间也就是世界标准时间
path路径 符合路径的文件才能访问cookie
httponly设置 为 true 了之后可以防止js程序访问 防止 xss攻击 增加cookie的安全性
secure设置 为 true 了之后cookie只能通过https协议发送 http协议是不能发送的 这样也是为了增加cookie的安全性

76、反柯里化

反柯里化的作用是，当我们调用某个方法，不用考虑这个对象在被设计时，是否拥有这个方法，只要这个方法适用于它，我们就可以对这个对象使用它

例如

Function.prototype.uncurring = function() {
     
  var self = this;  
  return function() {
     
    var obj = Array.prototype.shift.call(arguments);  
    return self.apply(obj, arguments);  
  };
};

我们先来看看上面这段代码有什么作用。

我们要把Array.prototype.push方法转换成一个通用的push函数，只需要这样做：

var push = Array.prototype.push.uncurring();  

//测试一下

(function() {
       
  push(arguments, 4);  
  console.log(arguments); //[1, 2, 3, 4]  
})(1, 2, 3)

arguments本来是没有push方法的，通常，我们都需要用Array.prototype.push.call来实现push方法，但现在，直接调用push函数，既简洁又意图明了。

我们不用考虑对象是否拥有这个方法，只要它适用于这个方法，那就可以使用这个方法（类似于鸭子类型）。

我们来分析一下调用Array.prototype.push.uncurring()这句代码时，发生了什么事情：

Function.prototype.uncurring = function() {
      
  var self = this;  //self此时是Array.prototype.push  

  return function() {
     
    var obj = Array.prototype.shift.call(arguments);  
    //obj 是{
   
    //  "length": 1,  
    //  "0": 1
    //}
    //arguments的第一个对象被截去(也就是调用push方法的对象),剩下[2]

    return self.apply(obj, arguments);  
    //相当于Array.prototype.push.apply(obj, 2);  

  };
};

//测试一下

var push = Array.prototype.push.uncurring();  
var obj = {
     
  "length": 1,  
  "0" : 1
};

push(obj, 2);
console.log( obj ); //{0: 1,1: 2, length: 2 }
看到这里你应该对柯里化和反柯里化有了一个初步的认识了，但要熟练的运用在开发中，还需要我们更深入的去了解它们内在的含义。

77、千分位

这里的需求 本质上是要 将 数字 转化为 带有千分位字符串 方法有很多

方法1 正则表达式

console.info( str.replace(/\d{1,3}(?=(\d{3})+$)/g,function(s){
    
  return s+','
}) )

方法2 字符串替换

console.info( str.replace(/(\d{1,3})(?=(\d{3})+$)/g,function($1){
   
  return $1=$1+','
}) )

方法3 数字转数组 反转后 添加 , 再反转回来拼接为字符串

console.info( str.split("").reverse().join("").replace(/(\d{3})+?/g,function(s){
       
  return s+",";
}).replace(/,$/,"").split("").reverse().join("") )  

方法4 利用while循环拼接字符串每隔3个数字加一个分隔符，首尾不加

var result="",  
  index = 0,  
  len = str.length-1;  
while(len>=0) {
     
  index%3===0&&index!==0 ? result+=","+str[len] : result+=str[len];  
  len--;
  index++;  
};
result=result.split("").reverse().join("");  
console.info(result);  

方法5 利用while循环在数组里push分隔符，首尾不加

// 利用while循环在数组里push分隔符
var result="",  
  index = 0,  
  len = str.length,  
  i = len-1,  
  arr = str.split("");  
while(len-index>0){
     
  len>=index&&len-index!==len && arr.splice(len-index,0,",");  
  index+=3;  
  i-=4;
};
console.log(arr.join(""));  

78、load和ready区别

document.ready：

是ready，表示文档结构已经加载完成 不包含图片等非文字媒体文件 只要html标签结构加载完毕就可以；

document.load：

是onload，指示页面包含图片等文件在内的所有元素都加载完成。
1、概念
2、作用

document.ready：

在DOM加载完成后就可以可以对DOM进行操作。

一般情况一个页面响应加载的顺序是，域名解析-加载html-加载js和css-加载图片等其他信息。
那么Dom Ready应该在“加载js和css”和“加载图片等其他信息”之间，就可以操作Dom了。

document.load：

在document文档加载完成后就可以可以对DOM进行操作，document文档包括了加载图片等其他信息。

那么Dom Load就是在页面响应加载的顺序中的“加载图片等其他信息”之后，就可以操作Dom了。

3、加载顺序

document.ready：

文档加载的顺序：域名解析–>加载HTML–>加载JavaScript和CSS–>加载图片等非文字媒体文件。

只要标签加载完成，不用等该图片加载完成，就可以设置图片的属性或样式等。

在原生JavaScript中没有Dom ready的直接方法。

document.load：

文档加载的顺序：域名解析–>加载HTML–>加载JavaScript和CSS–>加载图片等非文字媒体文件。

DOM load在加载图片等非文字媒体文件之后，表示在document文档加载完成后才可以对DOM进行操作，document文档包括了加载图片等非文字媒体文件。

例如，需要等该图片加载完成，才可以设置图片的属性或样式等。

在原生JavaScript中使用onload事件。

79、自定义事件

自定义事件，就是自己定义事件类型，自己定义事件处理函数。

我们平时操作dom时经常会用到onclick、onmousemove等浏览器特定行为的事件类型。

封装is自定义事件基本的构思：

var eventTarget = {
     
  addEvent: function(){
     
    //添加事件
  },
  fireEvent: function(){
     
    //触发事件
  },
  removeEvent: function(){
     
    //移除事件
  }
};

在js默认事件中事件类型以及对应的执行函数是一一对应的，但是自定义事件，需要一个映射表来建立两者之间的联系。

如： 这样每个类型可以处理多个事件函数

handlers = {
     
      "type1":[  
            "fun1",  
            "fun2",  
            // "..."
         ],
       "type2":[  
            "fun1",  
            "fun2"  
             // "..."
         ]
         //"..."
}

代码实现：

function EventTarget(){
     
    //事件处理程序数组集合
    this.handlers={
   };  
}
//自定义事件的原型对象
EventTarget.prototyp