面向对象

* 单利模式

* 工厂模式

* 构造函数模式

* 原型模式

* call,apply,bind

* 继承

面向对象

对象：指的是基于对象 类 实力来研究的

类:是对对象的具体细分

实例:某一个类别种具体的事物

对象的特征：属性 方法

面向对象的特点

面向对象思想也叫（oo思想 oop思想）

1：封装：对同一个功能的函数，只能封装一次，以后遇到此功能只需要调用即可，无需重写。避免大量亢余代码：低耦合，高内聚(单利模式 工厂模式 构造函数模式 原型模式)

2：继承：子类可以继承父类的属性跟方法

3：多态：多种形态  重写 重载

重载：js没有严格意义上的重载，有类似的功能，传不同的参数，可以实现不同的功能

重写：子类可以重写父类的属性和方法

单利模式

单例模式

1：单例模式；把描述同一个对象的属性和方法，都放在同一个命名空间下避免全局变量的污染

和冲突

单利模式，解决了变量冲突，实现了分类分组

命名空间： 在单利模式中，我们的对象名叫做命名空间，单利模式把实现和描述同一件事物的属性和方法进行分类归纳，然后汇总的同一个命名空间下，不同的命名空间互不冲突

把描述這个对象的属性跟方法，所存放的空间，起个名字

2:单利模式的本质;普通对象

模块化开发；单利模式就是最简单的模块化开发

对于一个大型的项目，会分配给不同的工程师，进行同步开发；等所有人都开发完成之后，最后

进行代码合并

3:关于单利模式的优缺点

1 优点:单利模式可以避免全局变量的污染和冲突

2；单利模式是最简单的模块开发

1）本模块之间的相互调用 ；this.属性名

2）不同模块之间的相互调用；模块名.属性名

2 缺点:会存在大量的大量亢余代码

4:解决措施；工厂模式

這三种都是单例模式

1:var personRender={};

2:var studentRender=(function{

return {}

})()

3:function Person(){ }  var p=new Person()

工厂模式

工厂模式的本质-封装

1；引进原材料     创建一个空对象{} new Object()

2；加工          给对象添加属性和方法

3；输出产品       输出已经加工后的对象；

5；如果想让工厂模式的调用方式，跟系统类的调用方式一样需要做两步

1）首字母大写

2）添加new

构造函数模式

函数：

object 和function 都有一个自带的name值指向自己

length是形参的个数

构造函数跟工厂模式的区别

1）类调用的时候；

（1）工厂模式是普通函数的调用 person()

普通函数执行的时候没返回值，那么是undefined

（2）构造函数；new首字母大写（） new person

构造函数执行的时候，没返回值，那么是person{} 這个对象

构造函数模式执行：

- 1：创建一个私有作用域 - 进行形参赋值- 预解释

- 2：new 这样执行，在预解释完成后，浏览器默认的在私有作用域中，创建一个对象，函数中this指向這个对象

- 3：在和普通函数一样，代码从上到下执行

- 4：new这样执行，在代码执行完成之后，会默认的把第二步种（没有return也会默认返回一个对象），我们创建的這个对象返回

2)函数体内的不同

工厂模式（普通函数）；三步 1）创建对象 2）加工对象 3）返回对象

构造函数；一步加工对象

7）关于构造函数的小细节

1；构造函数的this都是实例

2；构造函数中存放的都是私有的属性和方法

3；实例只跟构造函数种的this.xxx有关，跟var没任何关系

4；构造函数中，系统默认为我们创建一个实例，并且默认返回一个实例

5：通过构造函数创建出来的实例都是相互独立的个体，互不影响，而在构造函数体中写的this,xx=xx 都相当于给当前实例增加自己的私有属性

不建议自己手动返回对象，如果非要手动返回的话 return  构造函数最好不要写return

1）返回的是基本数据类型，无效，实例该有的属性和方法仍然有

2）返回的是引用数据类型，以前给实例添加的属性和方法都无效了

8；构造函数；实例和类打交道

9； new Student() new Student這个new出来的实例都会执行 在new一个实例的时候，如果不需要传参（）可以省略

10；学习构造函数的目的

1）了解系统类的构成

2）自己定义一个类，并且创建一个实例；

11： 类是函数数据类型

实例是对象数据类型

原型模式

原型模式的基础知识：

1.每个函数数据类型(普通函数，类（内置类，自定义类）构造函数)上，都有一个属性，

叫做prototype，prototype是个原型；他的属性值是个对象

2.prototype这个对象上，存放的都是公有的属性和方法，

他天生自带一个属性

constructor（构造函数）,指向当前这个构造函数；

3.每个对象数据类型（实例，prototype,普通对象）上，

都有一个属性叫做__proto__,指向当前实例所属类的原型；

14)Object.prototype上的方法：

in验证某一个属性是否属于這个对象，不管是私有的还是公有的，只要有，返回的结果都是true

hasOwnProperty():

判断是否为对象的私有属性

obj1.isPrototypeOf(obj2) :obj1是否在obj2的原型链上；

propertyIsEnumerable：是否为可枚举的属性

15）__proto__原型链：

如果想查找：对象.属性名

1）先看该对象的私有空间中是否有，如果有，说明这个属性是私有属性；

2）如果没有，通过__proto__继续往当前实例所属类的原型上找，找到了，说明是公有属性；

3）找不到继续通过__proto__一直往上找，找到基类Object.prototype原型上，还没有的话undefined;

__proto__原型链this:

他们的this指向不同，但是查到找的结果都一样

p1.hasOwnproperty()   p1

p1.__proto__.hasOwnproperty()  p1的原型

p1.__proto__.__proto__hasOwnproperty() object

16）

1：所有的函数数据类型，都是

function這个类的实例

2：所有的对象都是object這个基类的实例

3）function和object的关系：

（1）object instanceof function ===>true 所有类都是function這个类的实例

（2）function instanceof function ===>true 所有的对象都是object這个基类的实例

（3）object.prototype 是function.prototype的爹 当他的身份是函数的时候，有prototype

（4）object.prototype是function_proto_的爹 当他为对象的时候，是有這个—proto—

4:

函数的三种角色

（1）：普通函数：形成私有作用域-形参赋值-预解释-代码从上到下执行 以及内存和内存的释放

（2）：构造函数：实例 类 原型 —proto—

(3):对象：跟普通对象的功能一模一样

1；在ie浏览器下，禁止用户通过__proto__去修改实例上公有的属性和方法

这上ie浏览器的自我保护机制

2；在所有的浏览器下，禁止用户批量修改，实例上的公有属性和方法

但是我们可以通过，类.prototype.xx进行一个个的修改

一个个修改在标准浏览器下，有两种方式

1）实例.__proto__.属性名

2）类.prototype.属性名

3；

-  链式操作，我们关注的是前一个函数执行完成的返回值，返回的是个数组，后续就跟数组的方法，

- 链式写法：需要保证每一次执行方法返回的结果依然是当前类的一个实例，这样就可以继续调取原型上的方法了

返回的是个数字，后续就跟数字的方法

num.toFixed(2)保留小数个数2位

4；应有的条件反射

构造函数；放的都是私有的属性和方法

prototype；放的都是共有的属性和方法

类.prototype自己赋值一个对象，

constructor一定会出问题

5；in判断某个属性是否为对象私有+公有属性  加引号

6；数组去重；

1.思路1；双重循环

拿当前项跟他后面的每一项，如果相同，删除其中一个，一定要预防数组塌陷 ;

2;思路2；创建新数组

当新数组中没有重复的时候，才给新数组种放

3；思路3；利用对象不重名的特性

当对象中没有该属性的时候，赋值为1

当对象中已经有了该属性的时候，进行累加

注意；两个条件中，只走一个1）continue 2)if...else...

7;属性操作

注意；判断属性是否在对象上，属性名一定要加引号，否则会把它当作变量，报错

1；in判断某个属性是否为对象私有+公有属性  加引号

2；obj.hasOwnproperty(属性名)判断是否有对象的私有属性 propertyIsEnumerable也可以用

3；自己封装；hasOwnproperty；判断属性是否为对象的

8;原型批量设置

Fn.prototype=

{

手动添加一个：constrouctor:Fn

x:10,

y:11,

c:22

}

call,apply,bind

call：

1：call在Function.prototype原型上找：公有属性和方法

- f1.call(f2);

函数中没有this的时候，

call前面的函数f1执行

- f1.call.call.call.call.call.call.call.call(f2);

-

call(f2) 他先执行，  然后将前面f1.call改成f2.call()执行

函数中没有this的时候 f2這个函数执行

2：f1.call(obj);

严格和非严格

1： 非严格模式下如果

call的第一个参数，不传或者传的是undefined/null，方法种的this是window

2：严格模式下，如果call中第一个参数不传就是undefined，其余call中的第一个参数是啥就是啥，如果是null就是null,如果传的的undefined就是undefined 'use strict'

3：call的第一个参数，用来改变call前面这个实例中的this关键字；

4：call改完this指向，传完参数之后，让call前面的函数立即执行；

3：call的作用改变this指向

call的第一个参数，用来改变call点前面的函数中this指向

call的第二个参数开始，相当于给fn的形参从左往右赋值

1）call,apply,bind区别：

call apply 都是在改完this指向，传完参数之后，让前面的函数立即执行

区别；第二个参数不同；call从第二个参数开始，一个个写参数，

apply；第二个参数是个数组；

2）bind;

属于预处理机制；先把bind前面的函数种的this改了，参数传了，

然后返回一个修改后的函数；在需要的时候，手动调用   函数执行的时候，他才执行

继承

子类可以继承父类的属性跟方法

1:

call继承

call:把父类的私有的属性和方法，都继承给了子类私有的

2；冒充继承

把父类私有+公有的属性和方法，都继承给子类私有的（for var a in f1 )

3;

原型链继承

把父类私有+公有的属性和方法,都继承给子类公有的

4;拷贝继承

call继承+extend继承（参数里面，后面继承前面的，）

私有继承私有的，公有继承公有的

5：混合继承：子类私有有父类私有的； 子类公有也有父类私有的

原型链继承：把父类私有+公有，都给了子类公有的

call继承把父类私有的给了子类私有的；

6：混合继承