某人初学javascript的时候写的学习笔记

/* 
* JavaScript对象就是一组属性（方法）的集合 
* 在该语言中如果变量名或方法名不符合声明规范， 
* 则一定得用方括号“ [] ”引用它 
* 
*/ 
/** 
* <1.>该语句声明了一个class1类，class1相当于构造方法，又叫构造器 
* 也可说声明了一个class1方法 
*/ 
function class1(){ 
this.name="xjl"; //给对象添加属性 
this.say= function(){alert("大家好！");}; //给对象添加方法 
}; 
/** 
* <2.>创建实例用 new 关键字，new 操作符不仅对内部类有效，对用户定义的类也是同样的用法 
* 每个对象可以看作是多个属性（方法）的集合,即 对象名.属性（方法）名 或 对象名[“属性（方法）名”] 
* 方括号 '[]' 适合不确定具体要引用哪个属性（方法）的场合 
*/ 
var a = new class1(); 
//alert(typeof(a)); //typeof(a) 返回a的类型 
//alert(a.name); //每个对象可以看作是多个属性（方法）的集合, 
//alert(a['name']); //用方括号（[]）引用对象的属性和方法 
//下拉框对象名[下拉框对象.value] 即可获得用户所选的值 也可用 eval(“下拉框对象名.”+下拉框对象.value); 
//a.say(); //调用对象的方法 
//var arr=new Array(); 
//arr['push']('abc'); //为数组添加一个元素，其中的 push 为内置的属性 
//arr['push']('1234'); //为数组添加一个元素 
//alert(arr); 
/** 
* <二.>动态添加、修改、删除对象的属性和方法 
* 
*/ 
var obj = new Object(); 
//添加属性……其中的属性名可任意取 
obj.name="徐建龙"; 
obj.sex = '男'; 
obj['my name'] = "xujianlong"; //使用方括号 “ [] ”可以使用非标识符字符串作为属性名称 
//添加方法……方法名也可任意取,也可传参数 
obj.alert = function(a){ 
alert(a+"你好！"); 
} 
//修改属性，就是把属性的值改成别的内容 
obj.name = "张三"; 
obj['name'] = 'anme'; 
//删除属性，就是把属性的值改成 undefined 或 null 
obj.name = 'undefined'; 
/** 
* <三>使用大括号（{}）语法创建无类型对象 
*/ 
//在大括号中方属性和方法，属性与属性用逗号隔开,属性与值之间用冒号隔开 
var ob = { 
name:"123", 
say:function(){alert("123")} //最后一个属性或方法不用逗号 
} 
//也可用如下方法定义对象的属性和方法 
var ob1 = {"name":'123','say':function(){alert("abcd");}}; 
/** 
*<四>prototype原型对象 
* 所有的函数（function）对应的类是（Function） 
* prototype 实际上就是表示了一个类的成员的集合。 
* *当通过new 来获取一个类的对象时，prototype 对象的成员都会成为实例化对象的成员。 
*/ 
function class2(){ //创建一个对象 
} 
var ob2 = new class2(); 
class2.prototype.me = function(){alert("123");} //在prototype的前面是，你所创建的类名 
class2.prototype.name = "123"; // 
/** 
* 函数对象和其他内部对象的关系 
*/ 
//typeof(new Function()),typeof(Function),typeof(Array),typeof(Object) 返回字符串“function”这些参数称之为构造器 
//typeof(new Date())，typeof(new Array())，typeof(new Object()) 返回字符串“object” 
/** 
* 传递给函数的隐含参数：arguments，它具有数组的特点，但它不是数组，可用下标来访问它 
*/ 
//arguments 中包含了一个参数 callee， 它表示对 函数对象本身的引用，如下： 
var sum=function(n){ 
if(1==n) 
return 1; 
else 
return n+arguments.callee(n-1); 
} 
//该语句表示声明一个 namespace1 的命名空间 ,如下： 
var namespace1 = new Object(); 
namespace1.class1 = function(){alert("123");}; 
var obj1=new namespace1.class1(); //页面加载时就执行 
/** 
* 使用prototype 对象定义类成员 
*/ 
//在创建实例的语句之后使用函数的prototype属性给类定义新成员，只会对后面创建的对象有效 
//在prototype中的constructor()方法 ，相当于构造方法 
function class1(){ 
//alert('adf'); 
} 
//class1.prototype.constructor(); //页面加载时就执行 
//用prototype 定义的简化 
class1.prototype={ 
//放入一些属性或方法 
//多个属性或方法是用逗号（,）隔开 
} 
//如下代码即是 静态方法和属性 
class1.name="abc"; 
class1.say = function(){/*codes*/} 
//利用反射机制，可以改变 element 中指定的样式，而其他样式不会改变，得到了所要的结果，例如： 
function setStyle(_style){ 
//得到要改变样式的界面对象 
var element=getElement(); 
for(var p in _style){ 
element.style[p]=_style[p]; 
} 
} 
//可以通过拷贝一个类的 prototype 到另外一个类来实现继承，但有缺陷。例如： 
// function class4(){} 
// 
// function class2(){ 
// 
// 
// class2.prototype=class4.prototype; //实现的继承 
// class2.prototype.f = function(){alert("a");} 
// 
//当对class2 进行prototype 的改变时，class4 的prototype 也随之改变 
// instanceof 操作符来判断一个对象是否是某个类的实例, 例如： 
var a = new class2(); 
a instanceof class2; //返回一个 bool ，如果 a 的class2 中的继承类，则也是 true 
//一种更好的继承 
for(var p in class1.prototype){ 
class2.prototype[p]=class1.prototype[p]; 
} 
class2.prototype.ma=function(){ 
alert(123); 
} 
//当对class2 进行prototype 的改变时，class4 的prototype 不会改变 
/** 
* prototype-1.3.1框架中的类继承实现机制 
*/ 
//------------------------------------------------------------------------------------------- 
//该语句为每个对象天加一个extend 方法，代码如下; 
Object.extend = function(destination, source) { 
for (property in source) { 
destination[property] = source[property]; //将source中所有的属性或方法都赋值给destination 
} 
return destination; 
} 
//通过Object类为每个对象添加方法extend 
Object.prototype.extend = function(object) { 
return Object.extend.apply(this, [this, object]); 
} 
Object.extend.apply(this,[this,object]); 
//class1继承与class2 ，好处是 通过new class2（）相当于把class2的prototype的副本赋给class1 
//在class1中的prototype的改变，不会影响class2中的prototyp 
class1.prototype=(new class2()).extend({/*class1要增加的属性或方法*/}); 
/** 
* 只做了一个声明而未实现的方法，具有虚函数的类就称之抽象类 ，抽象类是不能实例化的 
*/ 
//里虚方法不需经过声明，而直接使用了。这些方法将在派生类中实现，例如： 
function c1(){} 
c2.prototype={ 
fun:function(){ this.fn();}//其中的fn方法未定义 
} 
function c2(){} 
c1.prototype=(new c2()).extend({ 
fn:function(){var x = 1;} 
}); 
//this.initialize.apply(this, arguments);该语句是把创建对象时的参数传给initialize方法 
/*** 
* 在javascript中也可以用 try-catch-finally 语句用于捕获异常或错误信息 
* 其中在catch（e）的小括号中的e 是必须的 e是一个名为error 的对象 
* e=new Error(message)来创建这个对象，异常的描述被作为error 对象的一个属性message， 
*/ 
//该代码演示了异常的抛出 
function s(a,b){ 
try{ 
if(b==0) 
throw new Error("除数不能为零！........"); 
else 
alert(a/b) 
}catch(e){ 
document.write(e.message);///通过message 获得Error中的实参 
} 
} 
onlaod=s(1,0);