)`
272 |
273 | ```
274 | transform: scale3d(1.2, 1.2, 1);
275 | transform: scale3d(1, 1.2, 1);
276 | transform: scale3d(1.2, 1, 1);
277 | transform: scaleZ(5);
278 |
279 | ```
280 | 
281 |
--------------------------------------------------------------------------------
/chapter1/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [页面制作](#%E9%A1%B5%E9%9D%A2%E5%88%B6%E4%BD%9C)
6 |
7 |
8 |
9 | # 页面制作
10 |
11 | 页面制作指的是将视觉设计师设计好的视觉稿文件实现成具体的HTML页面。页面制作一般包括`PhotoShop切图`、`页面实现`两个过程。
12 |
13 | - `PhotoShop切图`指的是根据视觉稿文件将图片、按钮等资源保存成单独的文件,以供后面页面实现调用。
14 | - `页面实现`指的是用HTML+CSS等技术将视觉稿实现成HTML静态页面。
--------------------------------------------------------------------------------
/chapter2/01_javascript_intro.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [JavaScript 介绍](#javascript-%E4%BB%8B%E7%BB%8D)
6 |
7 |
8 |
9 | ## JavaScript 介绍
10 |
11 | 前端开发三要素,`HTML`(描述网页内容),`CSS`(描述样式),`JavaScript`(控制网页行为)。JavaScript 为解释型编程语言,运行环境也很广泛。
12 |
13 | 
14 |
15 | 
16 |
17 | **JavaScript**的引入方法如下:
18 |
19 | ```javascript
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
36 |
37 |
38 | ```
--------------------------------------------------------------------------------
/chapter2/02_dev_tools.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [调试器](#%E8%B0%83%E8%AF%95%E5%99%A8)
6 |
7 |
8 |
9 | ## 调试器
10 |
11 | 调试工具都内置于主流浏览器中(Firefox 中需独立下载 Firebug)。更多关于 Google Chrome DevTools 的信息可以在[这里](https://developer.chrome.com/devtools)找到。
--------------------------------------------------------------------------------
/chapter2/03_basic_syntax.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [基本语法](#%E5%9F%BA%E6%9C%AC%E8%AF%AD%E6%B3%95)
6 | - [变量标示符](#%E5%8F%98%E9%87%8F%E6%A0%87%E7%A4%BA%E7%AC%A6)
7 | - [关键字与保留字](#%E5%85%B3%E9%94%AE%E5%AD%97%E4%B8%8E%E4%BF%9D%E7%95%99%E5%AD%97)
8 | - [字符敏感](#%E5%AD%97%E7%AC%A6%E6%95%8F%E6%84%9F)
9 | - [严格模式](#%E4%B8%A5%E6%A0%BC%E6%A8%A1%E5%BC%8F)
10 | - [注释](#%E6%B3%A8%E9%87%8A)
11 |
12 |
13 |
14 | ## 基本语法
15 |
16 | ### 变量标识符
17 |
18 | - 第一个字符必须是一个字母、下划线(_)或一个美元符号($)
19 | - 其他字符可以是字母、下划线、美元符号或数字
20 |
21 | ```javascript
22 | var _name = null;
23 | var $name = null;
24 | var name0 = null;
25 | ```
26 |
27 | ### 关键字与保留字
28 |
29 | JavaScript 在语言定义中保留的字段,这些字段在语言使用中存在特殊意义或功能,在程序编写的过程中不可以当做变量或函数名称使用。无需记忆,报错修改即可。
30 |
31 | ```
32 | //ECMAScript的全部关键字
33 | break else new var
34 | case finally return void
35 | catch for switch while
36 | continue function this with
37 | default if throw
38 | delete in try
39 | do instanceof typeof
40 | //ECMA-262第3版定义的所有保留字
41 | abstract enum int short
42 | boolean export interface static
43 | byte extends long super
44 | char final native synchronized
45 | class float package throws
46 | const goto private transient
47 | debugger implements protected volatile
48 | double import public
49 | ```
50 |
51 | ### 字符敏感
52 |
53 | 字符串的大小写是有所区分的,不同字符指代不同的变量。
54 |
55 | ### 严格模式
56 |
57 | **增益**
58 |
59 | - 消除语法中不合理与不安全的问题,保证代码正常运行
60 | - 提高编译效率,增加运行速度
61 |
62 | **使用方法**
63 |
64 | ```javascript
65 |
66 | "use strict";
67 | (function(){
68 | console.log('>>> Hello, world!');
69 | })()
70 |
71 |
72 | (function(){
73 | "use strict";
74 | console.log('>>> Hello, world!');
75 | })()
76 | ```
77 |
78 | 严格模式与标准模式的区别:
79 |
80 | - 严格模式下隐式声明或定义变量被静止
81 | - 严格模式下对象重名的属性在严格模式下被静止
82 | - 严格模式下 `arguments.callee()` 被禁用
83 | - 严格模式下 `with()` 语句
84 | - 更多限制
85 |
86 | ### 注释
87 |
88 | ```javascript
89 | /*
90 | 多行注释,不可嵌套
91 | */
92 |
93 | // 单行注释
94 | ```
95 |
96 | ### JavaScript中的参数
97 |
98 | ECMAScript函数的参数与大多数其他语言中的函数参数有所不同,ECMAScript函数不介意床底多少个参数,也不在乎传进来的参数是什么数据类型。
99 |
100 | ```
101 | //普通函数
102 | function sayHi(name, message){
103 | alert("Hello " + name + message);
104 | }
105 | //用arguments获取参数
106 | function sayHi(){
107 | alert("Hello " + arguments[0] + arguments[1]);
108 | }
109 | ```
110 |
111 | 上面两个函数都是合法并且功能相同的。这个事实说明了ECMAScript函数的一个重要特点:命名的参数只是提供便利,但不是必须的。
112 |
113 | NOTE:ECMAScript中的所有参数传递都是值,不可能通过引用传递参数。
114 |
115 |
116 |
117 |
118 |
--------------------------------------------------------------------------------
/chapter2/06_scope.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [变量作用域](#%E5%8F%98%E9%87%8F%E4%BD%9C%E7%94%A8%E5%9F%9F)
6 | - [作用域介绍](#%E4%BD%9C%E7%94%A8%E5%9F%9F%E4%BB%8B%E7%BB%8D)
7 | - [静态作用域](#%E9%9D%99%E6%80%81%E4%BD%9C%E7%94%A8%E5%9F%9F)
8 | - [动态作用域](#%E5%8A%A8%E6%80%81%E4%BD%9C%E7%94%A8%E5%9F%9F)
9 | - [JavaScript 变量作用域](#javascript-%E5%8F%98%E9%87%8F%E4%BD%9C%E7%94%A8%E5%9F%9F)
10 | - [词法环境](#%E8%AF%8D%E6%B3%95%E7%8E%AF%E5%A2%83)
11 | - [组成](#%E7%BB%84%E6%88%90)
12 | - [创建](#%E5%88%9B%E5%BB%BA)
13 | - [结构](#%E7%BB%93%E6%9E%84)
14 | - [关于词法环境的问题](#%E5%85%B3%E4%BA%8E%E8%AF%8D%E6%B3%95%E7%8E%AF%E5%A2%83%E7%9A%84%E9%97%AE%E9%A2%98)
15 | - [with 语句](#with-%E8%AF%AD%E5%8F%A5)
16 | - [try-catch 句法](#try-catch-%E5%8F%A5%E6%B3%95)
17 | - [带名称的函数表达式](#%E5%B8%A6%E5%90%8D%E7%A7%B0%E7%9A%84%E5%87%BD%E6%95%B0%E8%A1%A8%E8%BE%BE%E5%BC%8F)
18 |
19 |
20 |
21 | ## 变量作用域
22 |
23 | 变量的作用域值的是变量的生命周期和作用范围(全局与局部作用域的区别)。
24 |
25 | ### 作用域介绍
26 |
27 | #### 静态作用域
28 |
29 | 静态作用域有称为词法作用域,即指其在编译的阶段就可以决定变量的引用。**静态作用域**只更变量定义的位置有关与代码执行的顺序无关。
30 |
31 | ```javascript
32 | var x = 0;
33 | function foo() {
34 | alert(x);
35 | }
36 |
37 | function bar() {
38 | var x = 20;
39 | foo();
40 | }
41 |
42 | foo();
43 | ```
44 |
45 | 
46 |
47 | #### 动态作用域
48 |
49 | 动态作用域的变量引用只可在程序运行时刻决定(其通常通过动态栈来进行管理)。
50 |
51 | ```javascript
52 | var x = 10;
53 | function foo() {
54 | alert(x);
55 | }
56 |
57 | function bar() {
58 | var x = 20;
59 | foo();
60 | }
61 | //Follow the Stack to search the x
62 | bar(); //The x to be alert is 20
63 | ```
64 |
65 | 
66 |
67 | ### JavaScript 变量作用域
68 |
69 | 1. 使用**静态作用域**
70 | 2. 其没有块级作用域(只有函数作用域,就是只有 function 用于可以定义作用域),if/for循环中的块是不会产生一个作用域的。
71 | 3. 在 ES5 之作使用`词法环境`来管理作用域。
72 |
73 | #### 词法环境
74 |
75 | ##### 组成
76 |
77 | 词法环境用来描述静态作用域的数据结构。它由`环节记录`和`外部词法环境的引用`组成。
78 |
79 | - 环境记录(record)(指形参,变量,函数等)
80 | - 外部词法环境的引用(outer)
81 |
82 | ##### 创建
83 |
84 | 在一段代码执行之前,先初始化词法环境。会被初始化的有:
85 |
86 | - 形参
87 | - 函数定义(创建函数对象,会保存当前作用域。见下图)
88 | - 变量定义(所有初始化值均为 `undefined`)
89 |
90 | 
91 |
92 | ##### 结构
93 |
94 | ```javascript
95 | var x = 10;
96 | function foo(y) {
97 | var z = 30;
98 | function bar(q) {
99 | return x + y + z + q;
100 | }
101 | return bar;
102 | }
103 | var bar = foo(20);
104 | bar(40);
105 | ```
106 |
107 | **全局词法作用域(初始化状态)**
108 |
109 | 
110 |
111 | **函数词法作用域**
112 |
113 | 
114 |
115 | #### 关于词法环境的问题
116 |
117 | **命名冲突**
118 |
119 | 形参,函数定义,变量名称命名冲突。其中的优先级的排序如下:
120 |
121 | ```
122 | 函数定义 > 形参 > 变量
123 | ```
124 |
125 | **`arguments` 的使用**
126 |
127 | `arguments`是函数中定义好的变量,我们通过`arguments`可以访问到函数传过来的形参。
128 |
129 | **函数表达式与函数定义的区别**
130 |
131 | - 函数表达式是在执行时才创建函数对象。
132 | - 函数定义为在代码执行之前就进行创建的。
133 |
134 | #### with 语句
135 |
136 | `with` 会创造一个临时作用域。
137 |
138 | ```javascript
139 | var foo = 'abc';
140 | with({
141 | foo: 'bar';
142 | }) {
143 | /* 函数定义 */
144 | function f() {
145 | alert(foo);
146 | };
147 | /* 函数表达式(相当于匿名函数执行) */
148 | (function() {
149 | alert(foo);
150 | })();
151 | f();
152 | }
153 | ```
154 | 
155 |
156 | #### try-catch 句法
157 |
158 | ```
159 | try {
160 | var e = 10;
161 | throw new Error();
162 | } catch (e) {
163 | function f() {
164 | alert(e);
165 | }
166 | (function() {
167 | alert(e);
168 | })();
169 | f();
170 | }
171 | ```
172 | 
173 |
174 | #### 带名称的函数表达式
175 |
176 | 当一个函数表达式有了名称之后,JavaScript 会创建一个新的词法环境。并在这个词法环境中拥有一个属性 A 指向这个函数,同时这个属性 A 指向的函数是不可被修改的。
177 |
178 | **下面例子为不常规的写法**
179 |
180 | ```
181 | (function A(){
182 | A = 1;
183 | alert(A);
184 | })();
185 | ```
186 |
187 | 
188 |
--------------------------------------------------------------------------------
/chapter2/08_statement.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [语句](#%E8%AF%AD%E5%8F%A5)
6 | - [条件控制语句](#%E6%9D%A1%E4%BB%B6%E6%8E%A7%E5%88%B6%E8%AF%AD%E5%8F%A5)
7 | - [循环控制语句](#%E5%BE%AA%E7%8E%AF%E6%8E%A7%E5%88%B6%E8%AF%AD%E5%8F%A5)
8 | - [遍历语句 for-in](#%E9%81%8D%E5%8E%86%E8%AF%AD%E5%8F%A5-for-in)
9 | - [异常处理语句](#%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86%E8%AF%AD%E5%8F%A5)
10 | - [with 语句](#with-%E8%AF%AD%E5%8F%A5)
11 |
12 |
13 |
14 | ## 语句
15 |
16 | ### 条件控制语句
17 |
18 | 条件控制语句包括:
19 |
20 | - if 条件语句
21 | - switch 条件语句
22 |
23 | 其中expression可以使用整型,字符串,甚至表达式
24 |
25 | ```javascript
26 | if (expression) {statement}
27 | else if (expression) {statement1}
28 | else {statement2}
29 |
30 | // JavaScript 中的 case 可以使用整型,字符串,甚至表达式
31 | switch(persion.type) {
32 | case "teacher":
33 | statement1
34 | break;
35 | case "student":
36 | statement2
37 | break;
38 | default:
39 | statement3
40 | break;
41 | }
42 | ```
43 |
44 | ### 循环控制语句
45 |
46 | 循环语句包括:
47 |
48 | - while 循环
49 | - do-while 循环
50 | - for 循环
51 |
52 | ```javascript
53 | while(expression) {statement}
54 |
55 | // 至少执行一次
56 | do {statement} while(expression);
57 |
58 | for (initialise; test_expresiion; increment) {statement}
59 | // 跳过下面代码并进入下一轮循环
60 | continue;
61 | // 退出当前循环
62 | break;
63 | ```
64 |
65 | ### 遍历语句 for-in
66 |
67 | 用于遍历对象的**全部**属性。
68 |
69 | ```javascript
70 | function Car(id, type, color) {
71 | this.type = type;
72 | this.color = color;
73 | this.id = id;
74 | }
75 |
76 | var benz = new Car('benz', 'black', 'red');
77 | Car.prototype.start = function(){
78 | console.log(this.type + ' start');
79 | }
80 |
81 | for (var key in benz) {
82 | console.log(key + ':' benz[key]);
83 | }
84 |
85 | // 输出结果
86 | type:black
87 | color:red
88 | id:benz
89 | start:function (){
90 | console.log(this.type + ' start');
91 | }
92 |
93 | // -----------
94 |
95 | // 如不需原型对象上的属性可以使用 hasOwnProperty
96 | for (var key in benz) {
97 | if (benz.hasOwnProperty(key)) {
98 | console.log(key + ':' benz[key]);
99 | }
100 | }
101 |
102 | // 输出结果
103 | type:black
104 | color:red
105 | id:benz
106 | ```
107 |
108 | 如不需原型对象上的属性可以使用 hasOwnProperty
109 |
110 | ```javascript
111 | for (var key in benz) {
112 | if (benz.hasOwnProperty(key)) {
113 | console.log(key + ':' benz[key]);
114 | }
115 | }
116 | /* 输出结果
117 | type:black
118 | color:red
119 | id:benz */
120 | ```
121 |
122 | ### 异常处理语句
123 |
124 | ```javascript
125 | try{
126 | // statements
127 | throw new Error();
128 | catch(e){
129 | // statements
130 | }
131 | finally{
132 | // statements
133 | }
134 | ```
135 |
136 | ### with 语句
137 |
138 | `with` 语句是 JavaScript 中特有的语句形式,它主要有两个作用:
139 |
140 | 其一,其用于缩短特定情况下必须书写的代码量。它可以暂时改变变量的作用域。
141 |
142 | ```javascript
143 | // 使用 with 之前
144 | (function(){
145 | var x = Math.cos(3 * Math.PI) + Math.sin(Math.LN10);
146 | var y = Math.tan(14 * Math.E);
147 | })();
148 |
149 | // 使用 with
150 | (function(){
151 | with(Math) {
152 | var x = cos(3 * PI) + sin(LN10);
153 | var y = tan(14 * E);
154 | }
155 | })();
156 | ```
157 |
158 | 
159 |
160 | 其二,改变变量的作用域,将`with`语句中的对象添加至作用域链的头部。
161 |
162 | ```javascript
163 | frame[1].document.forms[0].name.value = "";
164 | frame[1].document.forms[0].address.value = "";
165 | frame[1].document.forms[0].email.value = "";
166 |
167 | with(frame[1].document.[0]) {
168 | name.value = "";
169 | address.value = ""
170 | email.value = "";
171 | }
172 | ```
173 |
174 | **缺点**就是导致 JavaScript 语句的可执行性下降,所以通常情况下因尽可能的避免使用。
--------------------------------------------------------------------------------
/chapter2/09_closure.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [闭包](#%E9%97%AD%E5%8C%85)
6 | - [闭包的应用](#%E9%97%AD%E5%8C%85%E7%9A%84%E5%BA%94%E7%94%A8)
7 | - [保存变量现场](#%E4%BF%9D%E5%AD%98%E5%8F%98%E9%87%8F%E7%8E%B0%E5%9C%BA)
8 | - [封装](#%E5%B0%81%E8%A3%85)
9 |
10 |
11 |
12 | ## 闭包
13 |
14 | - 闭包有函数和与其相关的引用环境的组合而成
15 | - 闭包允许函数访问其引用环境中的变量(又称自由变量)
16 | - 广义上来说,所有 JavaScript 的函数都可以成为闭包,因为 JavaScript 函数在创建时保存了当前的词法环境。
17 |
18 | ```
19 | function add() {
20 | var i = 0;
21 | return function() {
22 | alert(i++);
23 | }
24 | }
25 | var f = add();
26 | f();
27 | f();
28 | ```
29 |
30 | ### 闭包的应用
31 |
32 | #### 保存变量现场
33 |
34 | ```javascript
35 |
36 | // 错误方法
37 | var addHandlers = function(nodes) {
38 | for (var i = 0, len = nodes.length; i < len; i++) {
39 | nodes[i].onclick = function(){
40 | alert(i);
41 | }
42 | }
43 | }
44 |
45 | // 正确方法
46 | var addHandlers = function(nodes) {
47 | var helper = function(i) {
48 | return function() {
49 | alert(i);
50 | }
51 | }
52 |
53 | var (var i = 0, len = nodes.length; i < len; i++) {
54 | nodes[i].onclick = helper(i);
55 | }
56 | }
57 | ```
58 |
59 | #### 封装
60 |
61 | ```javascript
62 | // 将 observerList 封装在 observer 中
63 | var observer = (function(){
64 | var observerList = [];
65 | return {
66 | add: function(obj) {
67 | observerList.push(obj);
68 | },
69 | empty: function() {
70 | observerList = [];
71 | },
72 | getCount: function() {
73 | return observerList.length;
74 | },
75 | get: function() {
76 | return observerList;
77 | }
78 | };
79 | })();
80 | ```
--------------------------------------------------------------------------------
/chapter2/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [JavaScript 程序设计](#javascript-%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1)
6 |
7 |
8 |
9 | # JavaScript 程序设计
10 |
11 | Javascript 程序设计以 ECMAScript 5.1为标准,从基本语法到原理深入,理解和编写Javascript程序。核心内容有语言简介、调试器、类型系统、内置对象、基本语法、变量作用域、闭包、面向对象编程等。
12 |
--------------------------------------------------------------------------------
/chapter3/01_dom_tree.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [文档树](#%E6%96%87%E6%A1%A3%E6%A0%91)
6 | - [My header](#my-header)
7 | - [文档节点(DOM Note)](#%E6%96%87%E6%A1%A3%E8%8A%82%E7%82%B9%EF%BC%88dom-note%EF%BC%89)
8 | - [文档节点类型](#%E6%96%87%E6%A1%A3%E8%8A%82%E7%82%B9%E7%B1%BB%E5%9E%8B)
9 |
10 |
11 |
12 | ## 文档树
13 |
14 | Document Object Model (DOM) ,即文档**对象**模型,其用对象的方式表示对应的文档结构及内容。
15 |
16 | ```html
17 |
18 |
19 |
20 | My title
21 |
22 |
23 | My Link
24 | My header
25 |
26 |
27 | ```
28 |
29 | **DOM 树的核心内容**
30 |
31 | - DOM Core DOM核心结构,API的定义
32 | - DOM HTML 定义HTML如何转换成对象
33 | - DOM Style 定义如何把样式转换成对象
34 | - DOM Event 事件模型
35 |
36 | 
37 |
38 | 通过使用 DOM 提供的 API (Application Program Interface) 可以动态的修改节点(node),也就是对 DOM 树的直接操作。浏览器中通过使用 JavaScript 来实现对于 DOM 树的改动。
39 |
40 | ### 文档节点(DOM Note)
41 |
42 | #### 文档节点类型
43 |
44 | **常用节点类型**
45 |
46 | - ELEMENT_NODE 元素节点
47 |
48 | 可使用 `document.createElement('elementName');`创建
49 |
50 | - TEXT_NODE 元素节点
51 |
52 | 可使用 `document.createTextNode('Text Value');` 创建
53 |
54 | ```html
55 | var bodyNode = document.getElementsByTagName("body")[0]; //Get the node
56 | var pNode = document.createElement("p"); //create a new node
57 | var txtNode = document.createTextNode("Here is the text content"); //create a new text node
58 | divNode.appendChild(txtNode);
59 | bodyNode.appendChild(divNode);
60 | //可以通过element.nodeType获取一个节点的节点类型
61 | //alert(bodyNode.nodeType); //1 Element
62 | //alert(pNode.nodeType); //1 Text
63 | //alert(txtNode.nodeType); //3 Text
64 | ```
65 |
66 | **不常用节点类型**
67 |
68 | - COMMENT_NODE
69 | - DOCUMENT_TYPE_NODE
70 |
71 | **不同节点对应的NodeType类型**
72 |
73 | |节点编号|节点名称|
74 | |---|--|
75 | |1|Element|
76 | |2|Attribute|
77 | |3|Text|
78 | |4|CDATA Section|
79 | |5|Entity Reference|
80 | |6|Entity|
81 | |7|Processing Instrucion|
82 | |8|Comment|
83 | |9|Document|
84 | |10|Document Type|
85 | |11|Document Fragment|
86 | |12|Notation|
87 |
88 | NOTE:要清楚`节点`和`元素`的区别。我们平常说的`元素`其实指的是节点中的`元素节点`。所以说`节点`不仅包含`元素节点`,还包括`文本节点`、`实体节点`等。
89 |
--------------------------------------------------------------------------------
/chapter3/03_attribute_manipulation.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [属性操作](#%E5%B1%9E%E6%80%A7%E6%93%8D%E4%BD%9C)
6 | - [HTML 属性与 DOM 属性的对应](#html-%E5%B1%9E%E6%80%A7%E4%B8%8E-dom-%E5%B1%9E%E6%80%A7%E7%9A%84%E5%AF%B9%E5%BA%94)
7 | - [属性操作方式](#%E5%B1%9E%E6%80%A7%E6%93%8D%E4%BD%9C%E6%96%B9%E5%BC%8F)
8 | - [通过属性访问器访问(Property Accessor)](#%E9%80%9A%E8%BF%87%E5%B1%9E%E6%80%A7%E8%AE%BF%E9%97%AE%E5%99%A8%E8%AE%BF%E9%97%AE%EF%BC%88property-accessor%EF%BC%89)
9 | - [通过 getAttribute/setAttribute 方法访问](#%E9%80%9A%E8%BF%87-getattributesetattribute-%E6%96%B9%E6%B3%95%E8%AE%BF%E9%97%AE)
10 | - [dataset 来存储数据](#dataset-%E6%9D%A5%E5%AD%98%E5%82%A8%E6%95%B0%E6%8D%AE)
11 |
12 |
13 |
14 | ## 属性操作
15 |
16 | ### HTML 属性与 DOM 属性的对应
17 |
18 | 每个 HTML 属性都会对应相应的 DOM 对象属性。如下面代码中,ulNode对象的id属性就对应了html代码中ul元素的id属性。
19 |
20 | ```html
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 | - First
29 | - Second
30 | - Third
31 | - Fourth
32 |
33 | Hello
34 |
41 |
42 |
43 | ```
44 |
45 | ### 属性操作方式
46 |
47 | #### 通过属性访问器访问(Property Accessor)
48 |
49 | 通过属性访问器得到的属性为转换过的实例对象(并非全字符串)。
50 |
51 | **读取属性**
52 |
53 | ```html
54 |
55 |
56 |
57 |
58 |
59 |
60 |
65 |
73 |
74 |
75 | ```
76 |
77 | **写入属性**
78 |
79 | 可增加新的属性或改写已有属性。
80 |
81 | ```html
82 |
83 |
84 |
85 |
86 |
87 |
88 |
93 |
104 |
105 |
106 | ```
107 |
108 | NOTE:为元素增加新的属性时,如果该属性不存在,那么设置是无效的。另外,通过`[]`来访问和通过`.`来访问设置属性是相同的,下面代码的效果是等值的:
109 |
110 | ```html
111 | var value1 = optionNodes[0].className;
112 | var value2 = optionNodes[0]["className"];
113 | optionNodes[0].className = "Basketball";
114 | optionNodes[0]["className"] = "Basketball";
115 | ```
116 |
117 | **特点**
118 |
119 | - X 通用行差(命名异常,使用不同的命名方式进行访问)
120 | - X 扩展性差
121 | - √ 实用对象(取出后可直接使用)
122 |
123 |
124 | #### 通过 getAttribute/setAttribute 方法访问
125 |
126 | **读取属性**
127 |
128 | 获取到的均为属性的**字符串**
129 |
130 | ```html
131 |
132 |
133 |
134 |
135 |
136 |
137 |
142 |
150 |
151 |
152 | ```
153 |
154 | **写入属性**
155 |
156 | 可增加新的属性或改写已有属性
157 |
158 | ```html
159 |
160 |
161 |
162 |
163 |
164 |
165 |
170 |
181 |
182 |
183 | ```
184 |
185 | **特点**
186 |
187 | - X 仅可获取字符串(使用时需转换)
188 | - √ 通用性强
189 |
190 | ### dataset 来存储数据
191 |
192 | 自定义属性,其为 `HTMLElement` 上的属性也是 `data-*` 的属性集。主要用于在元素上保存数据。获取的均为**属性字符串**。数据通常使用 AJAX 获取并存储在节点之上。
193 |
194 | ```html
195 |
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 |
204 |
211 |
212 |
213 | ```
214 |
215 | NOTE:`dataset` 在低版本 IE 不可使用,但可通过 `getAttribute` 与 `setAttribute` 来做兼容。
--------------------------------------------------------------------------------
/chapter3/06_animation.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [JavaScript 动画](#javascript-%E5%8A%A8%E7%94%BB)
6 | - [JavaScript 动画三要素](#javascript-%E5%8A%A8%E7%94%BB%E4%B8%89%E8%A6%81%E7%B4%A0)
7 | - [定时器](#%E5%AE%9A%E6%97%B6%E5%99%A8)
8 | - [setInterval](#setinterval)
9 | - [setTimeout](#settimeout)
10 | - [requestAnimationFrame](#requestanimationframe)
11 | - [JavaScript 动画DEMO](#javascript-%E5%8A%A8%E7%94%BBdemo)
12 |
13 |
14 |
15 | ## JavaScript 动画
16 |
17 | **帧**,为动画的最小单位,一个静态的图像。**帧频**,每秒播放的帧的数量。一个动画是由很多帧组成的,因为人眼的暂留特性,当图片交替的速度大于每秒 30 帧就会有动画的感觉。
18 |
19 | **实现方式**
20 |
21 | - gif 图像形式存储,容量大,需第三方制图工具制作。
22 | - flash 需要第三方制作工具,不推荐。
23 | - CSS3 实现动画具有局限性
24 | - JavaScript 可实现大部分上面几类可实现的动画效果
25 |
26 | ### JavaScript 动画三要素
27 |
28 | 
29 |
30 | #### 定时器
31 |
32 | ##### setInterval
33 |
34 | ```javascript
35 | var intervalId = setInterval(func, delay[, param1, param2, ...]);
36 | //clearInterval(intervalId); //清除定时器
37 | ```
38 |
39 | - `func` 执行改变属性操作函数
40 | - `delay` 触发的时间间隔(毫秒为单位)
41 | - `param1, param2, ...` 为执行时可传入改变属性函数的参数,可选。
42 |
43 | NOTE:使用 `setInterval` 可以调用一次定时器既可实现连贯的动画,但最后需要使用 `clearInterval` 即可清除动画效果。
44 |
45 | ##### setTimeout
46 |
47 | ```javascript
48 | var timeoutId = setTimeout(func[, delay, param1, param2, ...]);
49 | //clearTimeout(timeoutId); //清除定时器
50 | ```
51 |
52 | - `func` 为执行改变属性的操作
53 | - `delay` 为出发时间间隔(毫秒为单位)默认为 0,可选。
54 | - `para1` 为执行时可传入改变属性函数的参数,可选。
55 |
56 | NOTE:使用 `setTimeout` 实现动画,则需要在动画每一帧结束时再次调用定时器,但它无需清除定时器。
57 |
58 | **区别**
59 |
60 | - `setTimeout` 在延时后只执行一次,`setInterval` 则会每隔一个延时期间后会再执行。
61 |
62 | ##### requestAnimationFrame
63 |
64 | 类似于 `setTimeout` 但是无需设定时间间隔。此定时器为 HTML5 中的新标准,其间隔时间不由用户控制,而是由显示器的刷新频率决定。(市面上的显示器刷新频率为每秒刷新60次)
65 |
66 | ```javascript
67 | var requestId = requestAnimationFrame(func);
68 | cancelAnimationFrame(requestId);
69 | ```
70 |
71 | NOTE:使用它来实现动画与 `setTimeout` 类似,需要每次每帧结束时再次调用,但它无需清除定时器。不可设置时间间隔(系统决定),时间间隔为16.67毫秒一帧。
72 |
73 | **优势**
74 |
75 | - 无需设置间隔时间
76 | - 动画流畅度高
77 |
78 | ### JavaScript 动画DEMO
79 |
80 | **常见动画**
81 |
82 | 大多的复杂动画都是有下列的简单动画所组成的。
83 |
84 | - 形变,改变元素的宽高
85 | - 位移,改变元素相对位置
86 | - 旋转
87 | - 透明度
88 | - 其他...
89 |
90 | 下面的例子为以 px 为单位的动画代码
91 |
92 | ```javascript
93 | var animation = function(ele, attr, from, to) {
94 | var distance = Math.abs(to - from);
95 | var stepLength = distance/100;
96 | var sign = (to - from)/distance;
97 | var offset = 0;
98 | var step = function(){
99 | var tmpOffset = offset + stepLength;
100 | if (tmpOffset < distance) {
101 | ele.style[attr] = from + tmpOffset * sign + 'px';
102 | offset = tmpOffset;
103 | } else {
104 | ele.style[attr] = to + 'px';
105 | clearInterval(intervalID);
106 | }
107 | }
108 | ele.style[attr] = from + 'px';
109 | var intervalID = setInterval(step, 10);
110 | }
111 | ```
112 |
113 |
--------------------------------------------------------------------------------
/chapter3/07_canvas.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | **Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
4 |
5 | - [Canvas](#canvas)
6 | - [渲染上下文对象](#%E6%B8%B2%E6%9F%93%E4%B8%8A%E4%B8%8B%E6%96%87%E5%AF%B9%E8%B1%A1)
7 | - [绘图步骤](#%E7%BB%98%E5%9B%BE%E6%AD%A5%E9%AA%A4)
8 |
9 |
10 |
11 | ## Canvas
12 |
13 | **Mozilla** 官方 `