构造函数、创建对象、继承、闭包、预解析

1-什么是构造函数？

　　构造函数函数名首字母大写，用new进行初始化

2-创建对象的方式有哪些？举例说明

　　1.var obj=new Object()

　　2.var obj={}

　　3. function obj(a){

　　　　var on=new Object()

　　　　　　on.a=a;

　　　　　　return on

　　}

　　var obj1=obj(s)

3-js 种实现继承的方式

　　1，原型链继承（有两种实现方式）

（1）Son.prototype = Father.prototype

弊端：Son.prototype.constructor 指向Father,需要手动更改为Son ；Son的实例化对象只能继承Father原型中的方法，无法继承Father本身的属性。

（2）Son.prototype = new Father()

弊端：Son.prototype.constructor 指向Father,需要手动更改为Son；Son的实例化对象共享Father自身的引用类型属性。什么意思呢？下面举个栗子：

function Father(){ this.name = "zs" ; this.arr = [1,2,3] }

function Son(){ }

Son.prototype = new Father()

var s1 = new Son(), s2 = new Son();

s1.arr.push(5);

console.log(s1.arr)--------> [1,2,3,5]

console.log(s2.arr)--------->[1,2,3,5]

看了这里例子就明白了，Son的实例化对象s1,s2继承了Father的属性arr,但是s1,s2是同时指向这一属性的。

2，借助构造函数继承

function Father(){ this.name = "zs"; this.age=38 };

function Son(){ Father.call( this) / Father.apply(this) }

弊端：Son只能继承Father自身的属性，而无法继承Father原型中的方法。

3，组合式继承

将原型链继承与构造函数结合起来

function Father(){ this.name="zs";this.age=38 }

Father.prototype.sayHi = function(){ alert("hello") }

function Son(){ Father.call(this) }

Son.prototype = new Father()

var s = new Son() ;

弊端：通过Father.call() 和 new Father() ,父类构造函数Father被调用了两次。

4，原型式继承

function createObj(o){ function F(){ } F.prototype=o ; return new F() }

var obj = { name:"zs" , age:18, sayHi:function(){ } }

var newObj = createObj( obj );

newObj继承了obj的属性和方法，但是同样出现了共享父类中引用类型属性的问题。

5，经典继承（Es5中的新语法：存在兼容性问题，需要做浏览器的能力检测）

function create(obj){

if(Object.create){ return Object.create(obj) }

else { function F(){ } F.prototype=o ; return new F() }

}

6,寄生式继承（类似于原型式继承）

function createObj(o){ function F(){ } F.prototype=o ; return new F() }

function createObj2(o){ var obj = createObj(o) ; obj.sayHi = function(){ } return obj }

var obj = { name:"zs" , age:18, sayHi:function(){ } }

var newObj = createObj2(obj)

newObj继承了obj的属性和方法，但是同样出现了共享父类中引用类型属性的问题。

7,寄生组合式继承（组合继承+寄生继承）

function createObj(o){ function F(){ } F.prototype=o ; return new F() }

function inheritPrototype(Child, Father) {

var prototype = object(Father.prototype);//创建对象

prototype.constructor = Child;//增强对象

Child.prototype = prototype;//指定对象 }

function Father(name) {

this.name = name;

this.arr = [1, 2, 3, 4]; }

Father.prototype.sayName = function () { console.log("父类原型" + this.name); }

function Child(name, age) { Father.call(this, name); this.age = age; }

inheritPrototype(Child, Father)

Child.prototype.sayAge = function () { console.log(this.age); }

var child1 = new Child() , child2 = new Child();

child1.arr.push(5) ------> [1,2,3,4,5]

child2.arr ------> [1,2,3,4].

优点：可以多重继承解决两次调用解决实例共享引用类型的问题原型链保持不变

4-什么是闭包？有什么作用？　

如果一个函数用到了它作用域外面的变量，那么这个变量和这个函数之间的环境就叫闭包。

闭包的用途有些什么：

1.模仿块级作用域

所谓块级作用域就是指在循环中定义的变量，一旦循环结束，变量也随之销毁，它的作用范围只在这一小块。而在JavaScript中没有这样的块级作用域，由于JavaScript不会告诉你变量是否已经被声明，所以容易造成命名冲突，如果在全局环境定义的变量，就会污染全局环境，因此可以利用闭包的特性来模仿块级作用域。