js-面向对象的程序设计,函数表达式

面向对象的程序设计：

1、属性类型：数据属性、访问器属性

数据属性：wirtable：false –只读；如果尝试为它赋值，会忽略

Configurable：false—不能从对象中删除属性

在调用Object.defineProperty（）方法时，如果不指定，configurable，enumerable（能否通过for-in循环输出对象的属性），writable的默认值是false；---直接在对象上定义的属性，其默认值是true

2、 构造函数以及工厂模式：

//工厂模式

function creatPerson(name,age,job){

var o=new Object();

o.name=name;

o.age=age;

o.job=job;

o.sayName=function(){

alert(this.name);

}

return o;

}

var person1=creatPerson("zhang",29,"yu");

var person2=creatPerson("zhanw",24,"yuw");

//构造函数

function Person(name,age,job){

this.name=name;

this.age=age;

this.job=job;

this.sayName=function(){

alert(this.name);

}

}

var person1=new Person("zhang",29,"yu");

var person2=new Person("zhanw",24,"yuw");

//构造函数中函数名一个字母大写，非构造函数应该以一个小写字母开头

//没有return语句，没有显式创建对象，直接属性与方法赋给this对象

3、将构造函数当做函数使用

var person=new Person("zhang",29,"zhhhh");

person.sayName();   //zhang

Person("zhang",78,"kk");   //添加到window

window.sayName();    //zhang

var 0=new Object();

Person.call(o,"zzz",23,"ddd");

o.sayName();  //zzz

4、原型对象：可以通过对象实例访问保存在原型中的值，不能通过对象实例重写原型中的值，在实例中添加了一个属性，该属性名与实例原型中的一个属性同名，那么就在实例中创建该属性，该属性会屏蔽原型中的那个属性，不过可以使用delete操作符删除实例属性，从而可以重新访问原型中的属性

5、

1. 取得对象中所有可枚举的实例属性，可以使用object.keys（）方法，接受一个对象作为参数，返回一个包含所有可枚举属性的字符串数值
2. 取得所有的实例属性，无论是否可枚举，使用Object.getOwnPropertyNames（）方法

6、组合使用构造函数以及原型模式：构造函数用于定义实例属性，原型模式用于定义方法以及共享的属性

function Person(name,age,job){

this.name=name;

this.age=age;

this.job=job;

this.friends=["a","b"];

}

Person.prototype={

constructor :Person,

sayName:function(){

alert(this.name);

}

}

var person1=new Person("zhang",29,"yu");

var person2=new Person("zhanw",24,"yuw");

person1.friends.push("zg");

alert(person1.friends);     //"a,b,zg"

alert(person2.friends);    //"a,b"

7、原型链的问题与借用构造函数

function SuperType(){

this.colors=["red","green","blue"];

}

function SubType(){

}

SubType.prototype=new SuperType();

var instance1=new SubType();

instance1.colors.push("black");

alert(instance1.colors);

var instance2=new SubType();   //"red,green,blue,black"

alert(instance2.colors);          //"red,green,blue,black"

//借用构造函数

function SuperType(){

this.colors=["red","green","blue"];

}

function SubType(){

//继承了SuperType属性

SuperType.call(this);

}

var instance1=new SubType();

instance1.colors.push("black");

alert(instance1.colors);

var instance2=new SubType();   //"red,green,blue,black"

alert(instance2.colors);          //"red,green,blue"

//SubType的每个实例都会具有自己的属性副本

//apply（）与call（）方法可以在将来创建的对象上执行构造函数

8、借用构造函数的优势，即可以在子类型构造函数中向超类型构造函数传递参数

function SuperType(){

this.name=name;

}

function SubType(){

//继承了SuperType属性，同时还传递了参数

SuperType.call(this,"zhang");

this.age=29;

}

var instance1=new SubType();

alert(instance.name);

alert(instance.age);

9、将原型链与借用组合函数组合在一起（继承）：原型链实现对原型属性和方法的继承，通过借用构造函数来实现对实例属性的继承

10、寄生式继承：

function createAnother(original){

var clone=object(original);

clone.sayHi=function(){

alert("hi");

};

return clone;

}

var Person={

name:"zhang",

friends:["z","zz","zzz"]

};

var anotherPerson=createAnother(person);

anotherPerson.sayHi()；  //"hi"

函数表达式：

1、函数表达式：

var functionName=function(arg1,arg2){

函数体

};

函数表达式与其他表达式一样，在使用前必须赋值

2、var sayHi;

if(condition){

sayHi=function(){

alert("hi");

};

}else{

sayHi=function(){

alert("uo");

};

}

3、递归函数是一个函数通过名字调用自身，在调用自身函数的时候，使用arguments.callee代替函数名

4、闭包是指有权访问另一个函数作用域中的变量的函数，创建闭包的常见方式就是子啊函数内部创建另一个函数

内部函数的作用域包含了外部函数的作用域

在匿名函数从外部函数被返回后，它的作用域被初始化为包含外部函数的活动对象以及全局变量对象，匿名函数就可以访问在外部函数定义的所有变量，外部函数执行完毕后，其活动对象也不会销毁，直至匿名函数被销毁后，外部函数的活动对象才会被销毁

5、function assignHandler(){

var element=document.getElementById("some");

element.onclick=function(){

alert(element.id);

};

}

//只要匿名函数存在，element的引用至少是1，因此它占用的内存就永远回收不了

function assignHandler(){

var element=document.getElementById("some");

var id=element.id;

element.onclick=function(){

alert(id);

};

element=null;

}

//闭包会引用包含函数的整个活动对象，其中包含element

//即使闭包不直接引用element，包含函数的活动对象也依然会保存一个引用，所有element=null，解除对DOM对象的引用

6、调用函数的方式是在函数名称后面添加一对圆括号

将函数声明转化为函数表达式：

(function(){

})();

7、在匿名函数中定义的任何变量在执行结束后会被销毁