javaScript学习总结(一)

1：历史
A：网景公司(NetScape)为了解决低拨号时代，网速慢问题---->LiveScript
B：微软公司-----JScript 导致脚本语言的多样性，制定标准就刻不容缓了
C：ECMA(欧洲计算机制造联合会)
2：概述
A：主要用来向HTML页面添加交互行为
B：跨平台特性(Windows、Linux、Mac、Android、iOS等),浏览器决定
C：安全性
3：JavaScript和html的结合方式
A：JS代码存放到标签
B：使用script标签，引入一个js文件，推荐使用

4：第一个小程序
5：注释
A：一行注释 双斜杠------//
B：多行注释 /* 内容 */
6：JavaScript书写格式
A：大括号要对齐，且成对写
B：遇到左大括号要缩进，Tab键
C：方法和程序块之间加空行让程序看起来清晰
D：并排语句之间加空格，例如for循环语句
E：运算符两侧加空格
7：标识符
A：标识符是指可被用来为类、变量或方法等命名的字符序列，通俗来讲，在JavaScript中凡是能自定义名字的地方，必须遵守标识符规则
B：标识符规则
1：标识符由字母，下划线，美元符开头
2：大小写敏感，长度没有要求（最好控制在21个字母内，太长不利于阅读）
3：由字母，下划线，美元符，数字组成
4：遵守驼峰标示，见名知意
5：不能跟关键字相同，可以包含关键字
C：参阅
不合法的标识符

8：直接量(字面量literaaal)
A：数字字面-----------------------100
B：字符串字面量----------------”张三”
C：布尔字面量--------------------false/true
D：对象字面量-------------------null
9：关键字

保留关键字

10：变量
A：变量，在程序执行的过程中，某个范围内其值可以发生改变的量
B：变量的格式，var 变量名 = 变量值
C：为什么要变量，用来不断的存放值，并可以重复使用
D：注意事项：一定按照规范，变量名，分号，排版
11：数据类型
A：typeof操作符：typeof操作符是用来检测变量的数据类型
B：Undefined类型------------------------>未定义----只声明，不赋值，就直接使用
1：声明未赋值，就会出现
2：为了区分空值和未赋值的现象
C：Null类型 ------------------------>空的
D：Boolean类型 ------------------------>布尔值
E：Number类型 ------------------------>数字
F：String类型 ------------------------>字符串
G：Object类型 ------------------------>对象
12：运算符
A：运算符，就是对常量和变量进行操作的符号
B：运算符的分类
1：算数运算符
2：赋值运算符
3：比较运算符（关系或条件）
4：逻辑运算符
5：位运算符
6：三目(元)运算符
C：算数运算符（+ ，- ，* ，/ ，% ，++ ，–）
D：注意事项
1：+号在javaScript中有三种作用，代表正号，做加法运算，字符串的连接符
2：-号：做减法，和数学上一样
3：号：做乘法，和数学上一样
4：/获取的是除法操作的商，
5：%运算符，%获取的是除法操作的余数
A：当左边的绝对值小于右边绝对值时，结果是左边
B：当左边的绝对值等于右边或是右边的倍数时，结果为0
C：当左边的绝对值大于右边绝对值时，结果是余数
D：%运算符结果是符号只和左边有关系，与右边无关
E：任何一个整数%2结果不是0就是1可以用来当做切换条件
E：++ ，-- 运算符
1：++，操作数的值增加1，例如var b = 10；b++；那么b就等于11了
a：前加: ++a 先自增，再运算
b：后加: a++ 先运算，再自增
2：–，操作数减1，例如var b = 10；b–；那么b就等于9了
a：前加: --a 先自减，再运算
b：后加: a-- 先运算，再自减
3：练习，var x=4； var y = (x++)+(++x)+(x10);
F：赋值运算符的基本用法
1：基本的赋值运算符：=号，把=号右边的数据赋值给左边
2：扩展的赋值运算符：+=，-=，=，/=，%=，把左边和右边做加法，然后赋值给左边
H：关系运算符的基本用法和注意事项
1：== != > >= < <=
2：无论你操作的是简单的还是复杂的，结果都是Boolean类型。
3：==号不能写成= ，否则就编程赋值运算了
J：逻辑运算符的基本用法
1：逻辑运算符：& , | , ！ && ， ||
2：例子演示
3：注意事项，逻辑运算符一般用于连接Boolean类型的表达式或者值，表达式，就是用运算符把常量或者变量连接的符合JavaScript语法的式子。例如，算术表达式：a+b，关系表达式：a == b
4：结论
A：&逻辑与，有false则false
B：|逻辑或，有true则true
C：!逻辑非，非false则true，非true则false
K：逻辑运算符 && 和 &的区别
1：例子演示
2：&&和&的区别
A：最终结果都一样
B：&&具有短路效果，左边是false，右边不执行
3：同理 || 和 |的区别
4：& 和 && 本质：只为发现一个假的
5：| 和 || 本质：只为发现一个真的
L：三元运算符的基本用法
1：三元运算符的格式，关系表达式 ？表达式1 ：表达式2；
2：三元运算符的执行流程
C：例子演示
13：流程控制语句的分类
A：流程控制语句，可以控制程序的执行流程。
B：流程控制语句的分类
1：顺序结构
2：选择结构
3：循环结构
C：执行流程，从上往下，依次执行。
14：选择结构if语句的格式1及其使用
A：选择结构的分类
1：if语句
2：switch语句
B：if语句的几种格式
1：格式1:，if…
2：格式2，if…else…
3：格式3，if…else if…else…
C：if语句的格式1
If( 比较表达式 ){ 语句体; }
D：执行流程
1：先计算比较表达式的值，看其返回值是true还是false
2：如果是true，就执行语句体
3：如果是false，就不执行语句体
15：选择结构if语句格式2及其使用
A：if语句格式2
if ( 比较表达式 ) {
语句体1;
}else {
语句体2；
}
B：执行流程
1：首先计算比较表达式的值，看其返回值是true还是false
2：如果是true，就执行语句体1
3：如果false，就执行语句体2
C：例子演示
1：获取两个数据较大的值
2：判断一个数据是奇数还是偶数，并输出是奇数还是偶数
D：注意事项，else后面没有比较表达式的，只有if后面有
16：选择结构if语句格式3及其使用
A：if语句的格式3:
If(比较表达式1){
语句体1;
}else if (比较表达式2){
语句体2;
}else if(比较表达式3){
语句体3;
}
…else if…
else{
语句体n + 1;
}
B：执行流程
1：首先计算比较表达式1看其返回值是true还是false
2：如果是true，就执行语句体1，if语句就结束
3：如果是false，接着计算比较表达式2看返回时true还是false
4：如果是true，执行语句体2，if语句结束
5：如果是false，接着计算比较表达式3看其返回值是true还是false
6：如果都是false，就执行语句体n+1
C：注意事项，最后一个else可以省略，但是建议不要省略，可以对范围外的错误值提示
D：练习，需求，一个学生的成绩为n分，并判断和输出成绩的等级
1：(90 - 100) 优
2：(80- 89) 良
3：(70 - 79) 中
4：(60 - 69) 及格
5：(0- 59) 差
E：if语句的嵌套使用（举例说明即可）
F：选择结构if语句的注意事项
1：比较表达式无论简单还是复杂，结果必须是Boolean类型
2：if语句控制的语句体如果是一条语句，大括号可以省略，如果是多条语句，就不能省略，建议永远也不用省略
3：一般来说，有左大括号就没有分号，有分号就没有左大括号
17：switch语句
A：switch语句的格式
Switch(表达式){
Case 值1：
语句体1;
Break;
Case 值2：
语句体2;
Break;
default：
语句体n;
Break;
}
B：switch语句格式解释
C：执行流程
1：先计算表达式的值
2：然后和case后面的值匹配，如果有就执行对应的语句，
否则执行default控制语句
18：循环体
A:循环结构的分类
for,while,do…while
B:循环结构for语句的格式：
for(初始化表达式;条件表达式;循环后的操作表达式) {
循环体;
}
C执行流程：
1：执行初始化语句
2：执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
3：执行循环体语句;
4：执行循环后的操作表达式
5：回到B继续。
D：案例演示
在控制台输出10次"helloworld"
E：循环结构while语句的格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
F：执行流程：
1：执行初始化语句
2：执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
3：执行循环体语句;
4：执行控制条件语句
5：回到B继续。
G：案例演示
需求：请在控制台输出数据1-10
H：循环结构do…while语句的格式：
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
J：执行流程：
1：执行初始化语句
2：执行循环体语句;
3：执行控制条件语句
4：执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
5：回到b继续。
K：案例演示
需求：请在控制台输出数据1-10
L：循环嵌套演示
1：需求：请输出一个4行5列的星星()图案。
如图：
*****
*****
*****
*****
2：注意：
System.out.println("");和System.out.print("");的区别
M:结论：
外循环控制行数，内循环控制列数
19：函数
A：函数概述和格式说明
1：为什么要函数（易读，复用性）
2：什么是函数：完成特定功能的代码块
3：函数的格式
function 函数名(参数名1，数名2…) {
语句块
return 返回值
}
B：函数的格式说明
1：修饰符：function 固定写法，记住不要问为什么
2：函数名：符合标识符命名规则，且有动词，见名知意，方便调用
3：参数：
实际参数：实际参与运算的，调用函数传进去的参数
形式参数：就是函数小括号里面，用于接收实际参数的
4：参数名：变量名，符合标识符规则
5：函数体语句：完成特定功能的代码
6：return：结束函数 和 返回的值
7：返回值：函数结束，return带回给调用者
C：举例说明，并画图列出执行步骤
D：函数的注意事项
1：函数不调用不执行
2：函数和函数是平级关系，不能嵌套定义
3：函数定义的时候参数之间用逗号隔开
E：有返回值的函数的调用归类
1：单独调用，意义不大
2：输出调用，不够好，如果后面要进行进一步计算和赋值时，就没法操作了
3：赋值调用，推荐使用
20：对象
A：概述：其实就是一种类型，本质还是引用类型，引用类型其实就是把数据和功能结合到一起
B：创建对象的几种方式
1：大括号
2：new关键字
3：省略new关键字，不常用
4：例子演示
C：对象里面有什么
1：属性(字段)，注意可以用单引号括起来，属性的两种输出方式
2：函数(方法)，注意可以用属性的方式书写
3：例子演示
D：标准的对象例子演示
E：delete关键字用法
F：匿名对象作为参数传递
21：数组
A：数组概述和定义格式说明
1：为什么要有数组：为了存储多个值
2：数组概念
数组是存储任意数据类型的集合，也可以看成一个容器
3：数组定义格式
格式一：
var arr = new Array();
var arr = new Array(10);
var arr = new Array(“a”,”b”,12,true);
格式二：
var arr = [];
var arr = [2,3,4,5,true];
var arr = [,];
B：数组元素的读和写：数组都是通过下标访问的，下标也称索引值，从0开始
1：读：使用 数组名 + 左中括号 + 下标 + 右中括号，例子 arr[0]
2：写，使用 数组名 + 左中括号 + 下标 + 右中括号 = 某个值
3：举例说明
C：稀疏数组，就是包含从0开始的不连续索引的数组
1：var arr = []; arr[1000] = 5;
D：数组的长度，每个数组都有一个length属性，也就是这个长度区分稠密(稀疏)数组
E：数组的添加和删除
F：数组遍历(迭代)
G：数组方法
1：join()
2：reverse()
3：sort()
4：concat()
5：slice()
6：splice()
7：push()
8：pop()
9：unshift()
10：shift()
11：toString()
12：toLocaleString()
H：多维数组，举例说明
22：时间与日期（带着看辅助文档）
23：正则表达式
A：概念：描述一个字符模式的对象
B：为啥用：验证客户端的输入数据
C：创建正则表达式两种方式
1：直接量
2：RegExp
B：RegExp对象方法
1：test，在字符串中测试模式匹配，返回true和false
2：exec，在字符串中执行匹配搜索，返回结果数组
C：举例说明
1：单个单词匹配
2：语句匹配
3：test方法
4：exec方法
D：元字符
元字符 描述 例子
. 查找任意的单个字符，除换行符外 new RegExp(“regexp.”) 或者直接量语法 /regexp./比如代码如下：
var str = “abcde”;
console.log(str.match(/a.c/));
\w 任意一个字母或数字或下划线，A_Za_Z0_9,中任意一个 基本语法：new RegExp(“\w”); 或 直接量语法：/\w/
比如代码如下：
var str = “abcde”;
// 匹配单个字符，找到一个直接返回
console.log(str.match(/\w/)); // [“a”, index: 0, input: “abcde”]
\W 查找非单词的字符，等价于[^A_Za_z0_9] 基本语法：new RegExp(“\W”) 或直接量 /\W/
var str = “abcde”;
// 匹配单个字符，没有找到返回null
console.log(str.match(/\W/)); // null
\d 匹配一个数字字符，等价于[0-9] 基本语法：new RegExp(“\d”); 或 直接量语法：/\d/
代码如下：
var str = “abcde111”;
console.log(/\d/g.exec(str)); // [“1”, index: 5, input: “abcde111”]
\D 匹配一个非数字字符，等价于[^0-9] 基本语法：new RegExp(“\D”) 或直接量 /\D/
如下测试代码：
var str = “abcde111”;
console.log(/\D+/g.exec(str)); // [“abcde”, index: 0, input: “abcde111”]
\s 匹配任何空白字符，包括空格，制表符，换行符等等。等价于[\f\n\r\t\v] 基本语法：new RegExp(“\s”) 或直接量 /\s/
如下测试代码：
var str=“Is this all there is?”;
console.log(/\s/g.exec(str)); // [" ", index: 2, input: “Is this all there is?”]
\S 匹配任何非空白字符，等价于[^\f\n\r\t\v] 基本语法：new RegExp(“\S”) 或直接量 /\S/
如下测试代码：
var str=“Is this all there is?”;
console.log(/\S+/g.exec(str)); // [“Is”, index: 0, input: “Is this all there is?”]
\b 匹配一个单词边界，也就是指单词和空格间的位置，比如’er\b’可以匹配”never”中的”er”,但是不能匹配”verb”中的”er” 基本语法：new RegExp(“\bregexp”) 或直接量 /\bregexp/
如下测试代码：
var str=“Is this all there is?”;
console.log(/\bthis\b/g.exec(str)); // [“this”, index: 3, input: “Is this all there is?”]
\B 匹配非单词边界,’er\B’能匹配’verb’中的’er’,但不能匹配’never’中的’er’ 基本语法：new RegExp(“\Bregexp”) 或直接量 /\Bregexp/
测试代码如下：
var str=“Is this all there is?”;
console.log(/\Bhi/g.exec(str)); // [“hi”, index: 4, input: “Is this all there is?”]
\n 匹配一个换行符 基本语法：new RegExp(“\n”) 或直接量 /\n/
如下测试代码：
var str=“Is this all \nthere is?”;
console.log(/\n/g.exec(str)); // [“换行符”, index: 12, input: “Is this all ↵there is?”]
\xxx 查找一个以八进制数xxx规定的字符 基本语法：new RegExp(“\xxx”) 或直接量 /\xxx/
如下测试代码：
var str=“Visit W3School. Hello World!”;
console.log(/\127/g.exec(str)); // [“W”, index: 6, input: “Visit W3School. Hello World!”]
如上代码分析：127的八进制转换为10进制的值等于 18的二次方 + 28的一次方 + 7*8的0次方 = 64 + 16 + 7 = 87 而W的ASCLL编码转换为10进制也是87，因此打印W
\xdd 查找以16进制数dd规定的字符 基本语法：new RegExp(“\xdd”) 或直接量 /\xdd/
如下测试代码：
var str=“Visit W3School. Hello World!”;
console.log(/\x57/g.exec(str)); // [“W”, index: 6, input: “Visit W3School. Hello World!”]
W的16进制数等于57；
\uxxxx 查找以16进制数的xxxx规定的Unicode字符 基本语法：new RegExp(“\uxxx”) 或直接量 /\uxxx/
如下测试代码：
var str=“Visit W3School. Hello World!”;
console.log(/\u0057/g.exec(str)); // [“W”, index: 6, input: “Visit W3School. Hello World!”]

F：修饰符
1：i，执行不区分大小写匹配
2：g，执行一个全局匹配，简言之，机找到所有匹配，而不是找到第一个之后就停
3：m，多行匹配模式
G：特殊字符需要转义字符
$ 匹配输入字符串的结尾位置，如果需要匹配匹配输入字符串的结尾位置，如果需要匹配本身的话，使用$
^ 匹配输入字符串的开始位置，匹配^本身的话，使用^

• 匹配前面的子表达式的零次或者多次，匹配*本身的话，使用*

• 匹配子表达式的1次或者多次，匹配+本身的话，使用+
  . 匹配除换行符之外的任何一个字符，匹配.本身的话，使用.
  [ 匹配一个中括号开始，匹配本身的，使用[
  ? 匹配前面的子表达式的零次或者1次，或指明一个非贪婪限定符，要匹配本身的话，使用?
  \ 匹配本身的话，请使用\
  { 标记限定符开始的地方，要匹配{ ,请使用{
  | 指明多项中的一个选择，可以理解含义为或的意思，匹配本身的话，使用|

G：量词
量词 描述
n+ 匹配任何至少包含一个n的字符串
n* 匹配零个或者多个n的字符串
n? 匹配零个或者1个n的字符串
n{x} 匹配包含x个n的序列字符串
n{x,y} 匹配至少x个，最多y个n的字符串
n{x,} 匹配至少x个的字符串
n$ 匹配以n结尾的字符串
^n 匹配以n开头的字符串
?=n 匹配其后紧接指定的n字符串
?!n 匹配其后没有紧接指定的n字符串

H：贪婪模式和非贪婪模式
1：贪婪量词 {x,y} , {x,} , ? , * , 和 +
2：非贪婪量词 {x,y}?，{x,}?，??，*?，和 +?
I：选择，分组
1：选择 |
2：分组 ()
3：非捕获 ?:
4：前瞻捕获 ?=
K：RegExp的属性和方法
1：静态属性，直接调用，无需创建对象

2：实例属性，有对象才能用

3：以上属性几乎不怎么用，主要是浏览器兼容问题，每个浏览器支持程度不一
L：用于模式匹配的String方法
1：match(pattern)，返回pattern中的子串或null
2：replace(pattern,replaceement)用replaceement替换pattern
3：search(pattern)，返回字符串中的pattern开始位置
4：split(pattern)，返回字符串按指定pattern拆分的数组
24：Function类型
A：函数的生命方式
1：function 函数名(){}-------------->定义式函数
2：var 函数名 = function(){}------>变量式函数
3：var 函数名 = new Function(‘参数1’,’参数2’,’return 返回值’);
4：第三种方式，不建议用，书写不方便，而且效率低
5：举例说明，定义式和变量式之间的差别
B：函数作为参数传递，因为函数本身就是一个变量，举例说明
C：函数内部属性
1：arguments
2：this
D：arguments
1：概述，类似数组对象，包含了函数所有参数，通过下标就可以访问
2：用途，就是用来保存函数参数
3：此对象还有callee属性，此属性是一个指针，指向拥有这个arguments
对象的函数
E：window
1：是一个对象，最大的对象，最外围的对象
2：只要是全局的，不管是变量，还是函数都属于window
F：this关键字
1：在不同的作用域里，this所呈现的不同的含义
2：举例说明
3：外面函数，赋值给对象属性，不同调用方式，结果不一样，举例说明
G：函数属性
1：length，函数参数个数，可以直接调用
2：prototype，面向对象时，深入讲
25：基本包装类型（带着看辅助文档）
A：为啥存在？为了便于操作基本数据类型
B：基本包装类型和基本数据类型区别，举例说明
C：共同点，都可以调用内置的方法，一般只有对象才能用方法，
这就是JavaScript语言的灵活之处
D：Boolean类型，没有特定属性和方法，就固定2个值
E：Number类型
1：静态属性，直接通过类型加点就可以直接调用
2：方法
F：String类型
1：对象属性
2：方法
26：内置对象
A：Global对象
B：Math对象
27：面向对象与原型
A：创建对象
1：普通方式，太多重复
2：工厂模式，解决了重复问题，但是类型归属
3：构造函数(用来创建对象的)
a：函数名首字母最好大写
b：通过new关键字来调用
c：不需要return关键字
d：this总结
1：出现在构造函数里，this就代表它即将new出来的对象
2：出现在对象函数里，函数中的this指向该对象
3：函数用call或者apply调用，this的值就取传入的对象的值
4：全局 & 调用普通函数，this永远是window
B：函数和对象的关系
1：对象都是通过函数来创建的
2：当然有所谓的快捷方式，在编程语言中，成为语法糖 var obj={};
3：例子演示，例如Object，Array
4：函数也是一种对象
5：鸡生蛋，蛋生鸡的原理
C：prototype(原型)
1：作用，就是用来共享方法和属性
2：只要创建函数，函数就会自带prototype属性，实际是指向一个对象
3：画图说明结构
4：Object.prototype提供了
a：constructor：对创建对象的函数的引用（指针）。对于 Object 对象，该
指针指向原始的 Object() 函数。
b：hasOwnProperty()：是用来判断一个对象是否有你给出名称的属性或对象，
不过需要注意的是，此方法无法检查该对象的原型链中是否具有该属性，
该属性必须是对象本身的一个成员
c：isPrototypeOf()：判断该对象是否为另一个对象的原型。
d：propertyIsEnumerable()：判断给定的属性是否可以用 for…in 语句进行
枚举。
e：toLocaleString()：返回本地化字符串
f：toString()：返回对象的原始字符串表示
g：valueOf()：返回最适合该对象的原始值
5：画图说明结构
6：原型中加自定义的方法和属性
7：实例对象怎么可以用原型里面的属性和方法？
8：隐式原型
a：每个对象都有隐式属性__proto__，指向原型对象
b：本质上和函数prototype是相等的，都是指向同一个原型对象
c：画图，并用Object对象演示
d：并不是所有浏览器都支持，因为JavaScript并不想让开发者去使用
隐式原型，比如IE就不支持
e：自定函数的prototype本质上就是和var obj={}一样的，都是被Object
创建的，所以自定义原型对象的__proto__指向Object.prototype
f：Object.prototype的__proto__是null的，是一个特例
g：画图演示自定义和Object的关系
h：函数也是对象，也有隐式属性__proto__，详细图解
i：Function也是一个函数，函数是一种对象，也有__proto__属性。既然是
函数，那么它一定是被Function创建。所以——Function是被自身创建
的。所以它的__proto__指向了自身的Prototype。
29：BOM
A：BOM也叫浏览器对象模型
B：BOM的核心对象window，window处于JavaScript结构最顶层
C：BOM核心对象架构图

D：获取窗口相对于屏幕左上角的位置
//获取窗口相对于屏幕左上角的位置

1：var leftPos=(typeof window.screenLeft==='number')?
					window.screenLeft:window:screenX;
2：var topPos=(typeof window.screenLeft==='number')?
					window.screenTop:window:screenY;

E：移动窗口，调整窗口大小
1：window.moveTo(0,0)
2：window.moveBy(20,10)
3：window.resizeTo(100,100);
4：window.resizeBy(100,100);
5：注意，这几个方法在浏览器中很可能会被禁用。
F：获得浏览器页面视口的大小
1：var pageWith=document.documentElement.clientWidth||
document.body.clientWidth;
2：var pageHeight=document.documentElement.clientHeight||
document.body.clientHeight;
G：导航和打开窗口( window.open() )

H：几个时序相关的函数（原来这是BOM的实现，而非ECMAjavascript的实现）
1：setInterval()，方法接受两个参数，第一个参数是函数，第二个参数是时间
（单位微秒），返回数值ID
2：clearInterval()，取消调用，接受一个参数间歇调用ID
3：setTimeout()，方法接受两个参数，第一个参数是函数，第二个参数是时间
（单位微秒），返回数值ID。
4：clearTimeout()，取消调用，接受一个参数超时调用ID
I：系统对话框，这些对话框外观由操作系统/浏览器设置决定，css不起作用，所以很多时候可能需要自定义对话框
1：alert():带有一个确定按钮
2：confirm()：带有一个确定和取消按钮
3：prompt():显示OK和Cancel按钮之外，还会显示一个文本输入域
J：location对象

K：navigator对象，这个对象代表浏览器实例，其属性很多，但常用的不太多
L：history对象
1：history对象保存着用户上网的历史记录，使用go()实现在用户的浏览记录
中跳转：
2：history.back()
3：history.forward()
4：history.go(2) //前进两页
5：history.go(‘wrox.com’)
31：DOM(参考DHTML)
32：事件
A：事件是什么
B：事件用法
举例说明—div跟随鼠标动，留言功能，拖拽
C：事件对象兼容处理
D：事件冒泡
1：举例说明，冒泡例子
2：冒泡带来的困扰和麻烦
E：默认行为
1：默认只能输入数字例子
2：自定义右菜单例子
F：绑定方式
1：内联模型
2：普通脚本模型
3：脚本升级版本
a：IE增加绑定：attachEvent()
b：IE删除绑定：detachEvent()
c：其他增加绑定：addEventListener()
d：其他删除绑定：removeEventListener()
e：抽成公用绑定方法
4：举例
a：拖拽不能拖出父级
b：吸附功能