JavaSctipt面向对象技术基础....节选笔记

本文节选自JavaScript面对对象基础技术..
http://www.iteye.com/wiki/Object_Oriented_JavaScript

JavaScript下创建对象的三种方式
1:使用Json格式 var bb={name:"xx",....};这种方式方便与数据的传输情况下对象的创建,便于JavaScript里面函数动态调用,如果要再这个
对象里面创建一个新的属性,可以直接使用变量名bb.新属性名="....";来创建一个新的对象属性.
2:使用var bb=new Object();方式创建对象,使用的方式类似第一种方法,同样也可以用于新增属性,
3:基于函数的创建对象,使用起来象java中的javabean一样,先定义个函数
function bb() 然后使用 var cc=new bb()去创建一个对应的对象.

遍历对象所拥有的属性的方式
var name = {"name1":"NAME1","name2":"NAME2","name3":"NAME3","name4":"NAME4"};
var namestring = "";
for(var props in name) { //循环name对象中的属性名字
namestring += name[props];
}
判断对象是否拥有指定的属性,使用alert("key" in name)的方式,第一次看到in关键字

基于函数function的方式去创建一个对象,更准确的说是定义一个对象的类型.
function f(x)...
var f=function(x){....} 分别是基于函数表达式和函数运算符的方式去创建一个对象的类型.
创建一个对象的时候可以创建对象的构造函数,可以要求传入一些参数作为构造函数需要的初始化值
不过那不是必须的,如果没有传入,那么对应的值就为undefined 可以便捷的使用(!key)来判断值是否为undefined

函数中也有对应的arguments属性,用于便捷的访问函数里面的参数,可以使用数组的方式进行访问arguments[0],

再创建对象的时候可以直接使用Josn格式去定义个函数.后面可以使用变量名.函数名进行快捷的调用
var obj = {f0:function(){alert("f0");}}; //对象包含一个方法
function f1() {alert("f1");}
obj.f1 = f1; //为对象添加方法
obj.f0();

每一个函数都有一个prototype属性,如果对对象的prototype进行了属性的附加,那么将会影响到所谓未对该属性进行修改的该对象的实例

JavaScript中所有的函数,也就是function都有一个call和apply方法,用于模拟对象调用方法,它的第一个参数是对象(Object),后面的
参数表示对象调用这个方法时的参数,用例子看的比较清楚
f.call(o, 1, 2);
作用就相当于
o.m = f;
o.m(1,2);
delete o.m;
相当于用o增加了一个为f函数的方法,然后调用后面的1 2参数,其中的f为function名
apply不用的地方在于传递参数的方式是以数组的格式Person.apply(o,["name",89]);//Person为函数名,o是new Object 其他为参数

可以方便的使用对象.xx=function(){...}的方式给对象增加一个函数方法

function Circle(radius) {
this.radius = radius;
}
Circle.prototype.area = function() {
return 3.14 * this.radius * this.radius;
}
var c = new Circle(1);
alert(c.area());

可以方便的抽取出公共的方法,然后使用prototype属性添加倒对象的function对象之上,用于节约空间.
其中可以使用this属性访问function对象中的属性.

JavaScript中的继承.
function Circle(radius) { //定义父类Circle
this.radius = radius;
}
Circle.prototype.area = function() { //定义父类的方法area计算面积
return this.radius * this.radius * 3.14;
}

function PositionCircle(x,y,radius) { //定义类PositionCircle
this.x = x; //属性横坐标
this.y = y; //属性纵坐标
Circle.call(this,radius); //调用父类的方法,相当于调用this.Circle(radius),设置PositionCircle类的
//radius属性
}
PositionCircle.prototype = new Circle(); //设置PositionCircle的父类为Circle类

var pc = new PositionCircle(1,2,1);
alert(pc.area()); //3.14
//PositionCircle类的area方法继承自Circle类,而Circle类的
//area方法又继承自它的prototype属性对应的prototype对象
alert(pc.radius); //1 PositionCircle类的radius属性继承自Circle类

/*
注意:在前面我们设置PositionCircle类的prototype属性指向了一个Circle对象,
因此pc的prototype属性继承了Circle对象的prototype属性,而Circle对象的constructor属
性(即Circle对象对应的prototype对象的constructor属性)是指向Circle的,所以此处弹出
的是Circ.
*/
alert(pc.constructor); //Circle

/*为此,我们在设计好了类的继承关系后,还要设置子类的constructor属性,否则它会指向父类
的constructor属性
*/
PositionCircle.prototype.constructor = PositionCircle
alert(pc.constructor); //PositionCircle

JavaScript中的作用域和闭包等.

var sco = "global";
function print1() {
alert(sco); //global
}
function print2() {
var sco = "local";
alert(sco); //local
}
function print3() {
alert(sco); //undefined
var sco = "local";
alert(sco); local
}
只要再函数内重新定义一个全局变量同名的变量,那样就是在函数域内部清除对全局变量的引用,不过内部对其他函数的调用不会影响.
不过使用同名的方式,不会是一个好的编程习惯

JavaScript的闭包.就是使用一种定义变量的格式,将变量的域保留在函数内,避免被修改,同时起到了全局变量的作用。
function temp() {
var i = 0;
function b() {
return ++i;
}
return b;
}
var getNext = temp();
alert(getNext()); //1
alert(getNext()); //2
alert(getNext()); //3
alert(getNext()); //4
例子中所用的方法是将操作封装起来,可是依旧可以保留住状态,关键在于return 了一个函数。

同样更为复杂的例子,使用函数内部的函数保存变量的特别引用

function Person(name, age) {
this.getName = function() { return name; };
this.setName = function(newName) { name = newName; };
this.getAge = function() { return age; };
this.setAge = function(newAge) { age = newAge; };
}

var p1 = new Person("sdcyst",3);
alert(p1.getName()); //sdcyst
alert(p1.name); //undefined 因为Person('类')没有name属性
p1.name = "mypara" //显示的给p1添加name属性
alert(p1.getName()); //sdcyst 但是并不会改变getName方法的返回值
alert(p1.name); //mypara 显示出p1对象的name属性
p1.setName("sss"); //改变私有的"name"属性
alert(p1.getName()); //sss
alert(p1.name); //仍旧为mypara