ex1.
	var abc = 'sss';
	alert(abc);//"sss"
	alert(this.abc);//"sss"
	function fun1(){
		alert(this.abc);
	}
	fun1();//"sss"
	this.alert(123);
	alert(this.parseInt('234s4'));

ex2.
	var O1 = function(){
		function O(){
			this.abc = 123;
			function f2(){
				alert(this.abc);
			}
			f2();//直接调用f2方法，this指代window
			f2.call(this);//通过call调用f2方法，this指代O1
		}
		function pf(){
			alert(this.abc);
		}
		O.prototype = {
			f1 : function(){
				pf();//直接调用pf方法，this指代window
				pf.call(this);//通过call调用pf方法，this指代O1
			}
		};
		return O;
	}();
	var o = new O1();
	o.f1();

ex3.
	document.getElementById('xxxx').onclick = function(){
		alert(this.id);
	};
	//使用jquery注册事件时，结果是一样的
	$('#xxxx').click(function(){
		alert(this.id);
		$(this).xxx()...//以this创建jquery对象
	});

ex4：
	var abc = 'window';
	//O1
	var O1 = function(){
		function O(){
			this.abc = 'O1';
		}
		O.prototype = {
			f1 : function(){
				alert(this.abc);
			}
		};
		return O;
	}();
	//O2
	var O2 = function(){
		function O(){
			this.abc = 'O2';
		}
		O.prototype.callbackFun = function(fun){
			fun();
		}
		return O;
	}();
	//实例化O1和O2
	var o1 = new O1();
	var o2 = new O2();
	//猜猜看这里会alert什么.....window
	o2.callbackFun(o1.f1);//“window”
	//所以，在使用需要类环境的回调方法时，需要套一层function
	o2.callbackFun(function(){
		o1.f1();//“O1”
	});
	//当然，也可以通过call让this指向O2
	o2.callbackFun(function(){
		o1.f1.call(o2);//“O2”
		o1.f1.call(this);//“window”
	});

ex1. 
	//O1 父类
	function O1(){
		this.a1 = 123;
	}
	//O2 子类
	function O2(){
		O1.call(this);
	}
	var o = new O2();
	alert(o.a1);//123

ex2. 
	//O1
	function O1(){
		this.a1 = 123;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(){
		//…
	}
	//将O1的所有属性和方法赋到O2.prototype
	O2.prototype = new O1();
	O2.prototype.f2 = function(){...};
	O2.prototype.constructor = O2;
	var o = new O2();
	alert(o.a1);//123

ex3：
	//O1
	function O1(a){
		this.a1 = a;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(a){
		O1.call(this);
	}
	//将O1的所有属性和方法赋到O2.prototype
	O2.prototype = new O1();
	O2.prototype.f2 = function(){...};
	O2.prototype.constructor = O2;

ex4：
	//原型式继承 
	//将对象o的塑像和方法交给类F的prototype，然后返回实例化F，使返回对象具有o的属性和方法
	function object_(o){
		function F(){}
		F.prototype = o;
		return new F();
	}
	//寄生式继承
	//利用原型式继承的object_方法，将给定对象的属性和方法交给clone，然后为clone添加方法f1
	function createAnother(original){
		var clone = object_(original);
		//在通过原型继承以后，在给clone添加方法，这种方式导致代码复用率很低
		clone.f1() = function(){…};
		return clone;
	}
	//寄生组合式继承 使用寄生式继承父类的prototype对象到子类的prototype
	function inheritPrototype(superType, subType){
		var prototype = object_(superType.prototype);
		prototype.construction = subType;
		subType.prototype = prototype;
	}
	//寄生组合式继承仍然只继承prototype，如果要实现完整的继承，仍然需要结合call方法
	//下面是寄生组合式继承的示例
	//O1
	function O1(a){
		this.a1 = a;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(a){
		O1.call(this);
	}
	//将O2的所有属性和方法赋到O2.prototype
	inheritPrototype(O1, O2);
	O2.prototype.f2 = function(){...};//为子类添加额外的属性/方法

s>0&&(b=s,alert(1));

if(s > 0){
	b = s;
	alert(1);
}

ex：
	//通过对象直接量创建对象
	var o = {a:123, b:'abc', f:function(){...}};
	//添加属性
	o.c = [1,2,3];
	//添加方法
	o.g = function(){...};
	//删除属性/方法
	delete o.a;
	oc = undefinde;

ex：
	var a = [];
	var b = typeof a; //b = "object"
	var c = a.constructor === Array; //true  注意，这里的Array不是字符串

ex:
     	var o = new C();//假设C继承自A
	o instanceof C;//true
	a instanceof A;//true
	a instanceof Object;//true

ex1：
	function O1(){
		//添加属性
		this.a = 123;
		//添加方法
		this.f1 = function(){
			...
		};
	}
	var ot = new O1();
	alert(ot.a);//123

ex2：
	function O2(){
 
	}
	O2.prototype.a = 1234;
	O2.prototype.f1 = function(){
		alert(this.a);
	};
	var ot = new O2();
	ot.f1();//1234

ex3：
	function O3(){
		this.a = 234;
	}
	O3.prototype = {
		f1 : function(){
			alert(this.a);
		},
		//使用这种方式完全覆盖了prototype，对象的constructor属性会变成Object，这一步，是将其修改为O3
		constructor : O3
	};
	var ot = new O3();
	ot.f1();//234

ex4：
	var O4 = function(){
		//构造函数
		funciton O(){
			//public
			this.a = 567;
		}
		//private
		var b = 234;
		function pf(){
			return b;
		}
		//public
		O.prototype = {
			f1 : function(){
				alert(b);
			},
			f2 : function(){
				return b;
			},
			constructor : O4
		};
		//返回类O给变量O4
		return O;
	}();//定义一个立即执行的方法
	var ot = new O4();
	ot.f1();//234

ex5：
	var O5 = function(){
		//构造函数
		funciton O(){
			//public
			this.a = 567;
		}
 
		//通过立即执行的function返回prototype对象	
		O.prototype = function(){
			//属性和方法
			var b = 234;
			var c = 2345;
			function f1(){
				//...
			}
			function f2(){
				//...
			}
			//通过return返回给prototype便是public，其他的private
			return {
				c : c,
				f1 : f1
			}
		}();
		return O;
	}();