| 1. OOP基础 |
1.1面向对象编程OOP
1、语言的分类：
① 面向机器：汇编语言
② 面向过程：C语言
③ 面向对象：C++ Java PHP 等
2、面向过程与面向对象
① 面向过程：专注于如何去解决一个问题的过程步骤。编程特点是由一个个的函数去实
现每一步的过程步骤，没有类和对象的概念。
② 面向对象：专注于由哪一个对象来解决这个问题。编程特点是出现了一个个的类，从
类中拿到对象，由这个对象去解决具体问题。
对于调用者来说，面向过程需要调用者自己去实现各种函数；而面向对象，只需要告诉调用者对象中具体方法的功能，而不需要调用者了解方法中的实现细节。
[面向对象的三大特征]
继承、封装、多态
JS可以模拟实现继承和封装，但是无法模拟实现多态，所以说JS是一门基于对象的语言，而并非是面向对象的语言！
1.2类和对象
1、类：一类具有相同特征(属性)和行为(方法)的集合。
eg：人类-->属性：身高、体重、性别 方法：吃饭、睡觉、说话
2、对象：从类中，拿出具有确定属性值和方法的个体。
eg：张三-->属性：身高180 体重160 方法：说话-->我叫张三
3、类和对象的关系：
类是抽象的，对象是具体的(类是对象的抽象化，对象是类的具体化)
类是一个抽象的概念，只能说类有属性和方法，但是不能给属性赋具体的值。
eg：人类有姓名，但是不能说人类的姓名是什么
对象是一个具体的个例，是将类中的属性进行具体赋值而来的个体
eg：张三是人类的一个个体，可以说张三的姓名是张三，也就是张三对人类的每一个属性进行了赋值，那么张三就是由人类产生的一个对象。
4、使用类和对象的步骤：
① 创建一个类(构造函数)：类名必须使用大驼峰法则，即每个单词首字母都要大写。
function Person(name,age){ this.name=name; this.age=age; this.say=function(content){ // 在类中，访问类自身的属性，必须使用this.属性 调用 alert("我叫"+this.name+"，今年"+this.age+"岁。我说了一句话："+content); } }
② 通过类，实例化(new)出一个对象。
var zhangsan = new Person("张三",18);
obj.属性; 调用属性
obj.方法; 调用方法
③ 注意事项：
>>> 通过类名，new出一个对象的过程，叫做"类的实例化"
>>> 类中的this，会在实例化的时候，指向新new出的对象；
所以，this.属性 this.方法 实际上是将属性和方法绑定在即将new出的对象上面
>>> 在类中，要调用自身属性，必须使用this.属性名。如果直接使用变量名，则无法访问对应属性。
>>> 类名必须使用大驼峰法则，注意与普通函数区分。
5、两个重要属性：
① constructor：返回当前对象的构造函数。
>>> lisi.constructor==Person; √
② instanceof：检测一个对象，是不是一个类的实例
>>> lisi instanceof Person √ lisi是通过Person类new出的
>>> lisi instanceof Object √ 所有对象都是Object的实例
>>> Person instanceof Object √ 函数本身也是对象
6、广义对象与狭义对象：
① 狭义对象：只有属性和方法，除此之外没有任何其他内容。
var obj = {} var obj = new Object();
② 广义对象：除了用字面量声明的基本数据类型之外，JS中万物皆对象。换句话说，只要能够添加属性和方法的变量，都可以成为对象。
var s="123"; // 不是对象 s.name="aaa"; console.log(typeof s); // String console.log(s.name); // Undefined 字面量声明的字符串不是对象，不能添加属性。
| 2. 成员属性、静态属性和私有属性 |
2.1成员属性与成员方法
在构造函数中，使用this.属性 声明，或者在实例化出对象以后，使用"对象.属性"追加的，都属于成员属性或成员方法，
也叫实例属性和实例方法。
成员属性/方法，是属于由类new出的对象的。
需要使用"对象名.属性名"调用
var zhangsan = new Person("张三"); zhangsan.age = 14; // 追加成员属性 console.log(zhangsan.age); // 调用成员属性
2.2静态属性与静态方法
1、通过"类名.属性"、"类名.方法"声明的属性和方法，称为静态属性、静态方法，也叫类属性和类方法。
类属性/类方法，是属于类的(属于构造函数的)
通过"类名.属性名"调用
2、成员属性是属于实例化出的对象的，只能使用对象调用。
静态属性是属于构造函数的，只能使用类名调用。
Person.count = "60亿"; // 声明静态属性 console.log(Person.count); // 调用静态属性 var lisi = new Person("李四"); console.log(lisi.count); // Undefined 静态属性是属于类的，只能用类名调用
2.3私有属性与私有方法
在构造函数中，使用var声明的变量，称为私有属性；
在构造函数中，使用function声明的函数，称为私有方法；
function Person(){ var num = 1; // 私有属性 function func(){}; // 私有方法 }
私有属性和私有方法的作用域，只在构造函数内部有效。即，只能在构造函数内部使用，无论使用对象名还是类名都无法调用。
| 3. JS模拟实现封装 |
1、 什么叫封装？
① 方法的封装：将类内部的函数进行私有化处理，不对外提供调用接口，无法在类外部使用的方法称为私有方法，即方法的封装。
② 属性的封装：将类中的属性进行私有化处理，对外不能直接使用对象名访问(私有属性)。同时，需要提供专门用于设置和读取私有
属性的set/get方法，让外部使用我们 提供的方法，对属性进行操作。这就叫属性的封装。
2、 注意：封装不是拒绝访问，而是限制访问。要求调用者，必须使用我们提供的set/get方法进行属性的操作，而不是直接拒绝操作。
因此，单纯的属性私有化，不能成为封装！必须私有化之后，提供对应的set/get方法
function Person(){ var age=0; this.setAge=function(ages){ age=ages; } this.getAge=function(){ return age; } }
| 4. JS中的this指向详解 |
4.1谁最终调用函数，this就指向谁
4.1.1 this指向谁，不应该考虑函数在哪声明，而应该考虑函数在哪调用！！！
4.1.2 this指向的，永远只可能是对象，而不可能是函数！！！
4.1.3 this指向的对象，叫做函数的上下文/context，也叫函数的调用者
4.2this指向的规律！！！（与函数的调用方式息息相关）
4.2.1 通过函数名()调用的，this永远指向window
func();
4.2.2 通过对象.方法调用的，this指向这个对象
obj.func(); // 狭义对象 document.getElementById("div1").onclick = func; // 广义对象
4.2.3 函数作为数组中的一个元素，用数组下标调用的，this指向这个数组
var arr = [1,2,3,func,4,5,6]; arr[3]();
4.2.4 函数作为window内置函数的回调函数使用，this指向window。setInterval setTimeout 等
setTimeout(func,1000);
4.2.5 函数作为构造函数，使用new关键字调用，this指向新new出的对象。
var obj1 = new func();
| 5. 原型与原型链 |
5.1__proto__与prototype
5.1.1 prototype：函数的原型对象
① 只有函数才有prototype，而且所有函数必有prototype。
② prototype本身也是一个对象！
③ prototype指向了当前函数所在的引用地址！
5.1.2 __proto__：对象的原型！
① 只有对象才有__proto__，而且所有对象必有__proto__。
② __proto__也是一个对象，所以也有自己的__proto__，顺着这条线向上找的顺序，就是原型链。
③ 函数、数组都是对象，都有自己的__proto__
5.1.3 实例化一个类，拿到对象的原理？
实例化一个类，实际上是将新对象的__proto__，指向构造函数所在的prototype。
也就是说：zhangsan.__proto__==Person.prototype √
5.1.4 所有对象的__proto__沿原型链向上查找，都将指向Object的prototype。
Object的prototype的__proto__，指向null
5.2原型链的指向问题
研究原型链的指向，就是要研究各种特殊对象的__proto__指向问题。
5.2.1 通过构造函数，new出的对象，新对象的__proto__指向构造函数的prototype
5.2.2 函数的__proto__，指向Function()的prototype
5.3.3 函数的prototype的__proto__指向Object的prototype
(直接使用{}字面声明，或使用new Object拿到的对象的__proto__直接指向Object的prototype)
5.2.4 Object的prototype的__proto__指向null
(Object作为一个函数，它的__proto__指向Function()的prototype)
| 6. 原型属性与原型方法 |
6.1 成员属性与成员方法：
this.name = ""; this.func = function(){}
>>> 属于实例化出的新对象，使用 对象.属性 调用
6.2 静态属性与静态方法：
Person.name = ""; Person.func = function(){}
>>> 属于类的，用 类名.属性 调用
6.3 私有属性与私有方法：
构造函数中，使用var声明属性，使用function声明方法；
>>> 只在类内部能够使用，外部无法使用任何方式调用。
6.4 原型属性与原型方法：
Person.prototype.name = "";
Person.prototype.func= function(){};
>>> 将属性或方法写到类的prototype上，在实例化的时候，这些属性和方法就会进入
到新对象的 __proto__上，就可以使用对象名调用
也就是说，1/4适用对象名访问，2使用类名访问，3只能在函数内部使用。
6.5 当访问对象的属性或方法时，会优先使用对象自身上的成员属性和成员方法。如果没
有找到，则使用 __proto__上面的原型属性和原型方法。如果依然没有继续沿原型链
查找，最后返回Undefined。
6.6 习惯上，我们会将属性写为成员属性，讲方法定义为原型方法：
例如：
function Person(){ this.name = "张三"; // 成员属性 } Person.prototype.say = function(){};
原因：
① 原型属性在定义后不能改变，无法在实例化时进行赋值。所以属性不能使用原型
属性。但是方法，写完以后基本不用改变，所以，方法可以使用原型方法。
② 实例化出对象后，属性全在对象上，方法全在原型上，结构清晰。
③ 使用for-in遍历对象时，会将属性和方法全部打印出来。而方法往往并不需要展
示，那么将方法写在原型上，就可以使用hasOwnProperty将原型方法过滤掉。
④ 将方法写道prototype上，将更节省内存
⑤ 官方都这么写
6.7 通过prototype扩展系统内置函数的原型方法
/** * 给数组添加一个遍历打印所有值的方法 */ Array.prototype.eachAll = function(){ for (var i=0;i<this.length;i++) { console.log(this[i]); } } var arr = [1,2,3,4,5,6,7]; arr.eachAll();
| 7. for-in循环 |
for-in 循环主要用于遍历对象
for()中的格式：for(keys in zhangsan){}
keys表示obj对象的每一个键值对的键！所以循环中，需要使用obj[keys]来取到每一个的值
for-in循环，遍历时不只能读取对象自身上面的成员属性，也能沿原型链遍历出对象的原型属性。
所以，可以使用hasOwnProperty判断一个属性是不是对象自身上的属性。
zhangsan.hasOwnProperty(keys)==true 表示这个属性是对象的成员属性，而不是原型属性。
function Person(){ this.name = "张三"; this.age = 14; this.func1 = function(){
} } Person.prototype.name1 = "zhangsan"; Person.prototype.age1 = 15; Person.prototype.func2 = function(){}; var zhangsan = new Person(); for(keys in zhangsan) { if (zhangsan.hasOwnProperty(keys)) { console.log(zhangsan[keys]); } }
| 8. 继承 |
8.1扩展Object实现继承
8.1.1 扩展Object实现继承
① 声明父类
function Parent(){}
声明子类
function Son(){}
② 通过prototype给Object类添加一个扩展方法：
Object.prototype.extend = function(parent){ for(var i in parent){ this[i]=parent[i]; } }
③ 分别拿到父类对象和子类对象：
var p = new Parent(); var s = new Son();
④ 用子类对象，调用扩展方法，实现继承操作：
s.extend(p);
8.1.2 实现继承的原理：
通过循环将父类对象的所有属性和方法，全部赋给子类对象。关键点在于for-in循环，
即使不扩展Object，也能通过简单的循环实现操作。
8.1.3 扩展Object继承的缺点：
① 无法通过一次实例化，直接拿到完整的子类对象，而需要先拿到父类对象和子类对象两个对象，再手动合并。
② 扩展Object的继承方法，也会保留在子类的对象上。
8.2使用原型实现继承
8.2.1 使用原型实现继承
① 定义父类
function Parent(){}
定义子类
function Son(){}
② 将父类对象，赋值给子类的prototype
Son.prototype = new Parent();
③ 拿到子类对象，就会将父类对象的所有属性和方法，添加到__proto__
var s = new Son();
8.2.2 使用原型继承的原理：
将父类对象，赋值给子类的prototype，那么父类对象的属性和方法就会出现在子类的
prototype中，那么，实例化子类时，子类的prototype又会到子类对象的__proto__
中，最 终，父类对象的属性和方法，会出现在子类对象的__proto__中。
8.2.3 这种继承的特点：
① 子类自身的所有属性，都是成员属性，父类继承过来的属性，都是原型属性
② 依然无法通过一步实例化拿到完整的子类对象。
8.3call/apply/bind实现继承
[call/bind/apply]
1、 三个函数的作用：通过函数名调用这三个函数，可以强行将函数中的this指定为某个对象
2、 三个函数的写法(区别)：
call写法：func.call(func的this指定的obj,func参数1,func参数2,...);
apply写法：func.call(func的this指定的obj,[func参数1,func参数2,...]);
bind写法：func.call(func的this指定的obj)(func参数1,func参数2,...);
3、 三个函数的唯一区别，在于接收func的参数列表的方式不同，除此之外，功能上没有任何差异！！！
[使用call/bind/apply实现继承]
1、 实现步骤：
① 定义父类
function Parent(name){}
② 定义子类时，在子类中使用三个函数，调用父类，将父类函数中的this，指向位子类函数中的this：
function Son(no,name){ this.no = no; Parent.call(this,name）; }
③ 实例化子类时，将自动继承父类属性
var s = new Son(12,"张三");
| 9. 闭包 |
[JS中的作用域]
1、 全局变量：函数外声明的变量，成为全局变量；
局部变量：函数内部使用var声明的变量，称为局部变量；
在JS中，只有函数作用域，没有块级作用域！！也就是说，if/for等有{}结构体，
并不能具备自己的作用域
所以，函数外部不能访问函数内部的局部变量(私有属性)。因为，函数内部的变量，在
函数执行完毕以后，就会被释放掉。
2、 使用闭包，可以访问函数的私有变量！
JS中，提供了一种"闭包"的概念：在函数内部，定义一个子函数，子函数可以访问父
函数的私有变量。可以在子函数中进行操作，最后将子函数通过return返回
function func1(){ var num = 1; function func2(){ return num; } return func2; } var num = func1()();
3、 闭包的作用：
① 可以在函数外部访问函数的私有变量；
② 让函数内部的变量，可以始终存在于内存中，不会在函数完成后释放掉