function foo(a, b, c)
{
	return a*b*c;
}
alert(foo.length);
alert(typeof foo.constructor);
alert(typeof foo.call);
alert(typeof foo.apply);
alert(typeof foo.prototype);  

// prototype
function Person(name, gender)
{
	this.name = name;
	this.gender = gender;
	this.whoAreYou = function()
    {//这个也是所谓的closure, 内部函数可以访问外部函数的变量
	var res = "I'm " + this.name + " and I'm a " + this.gender +".";
	return res;
	};
}
// 那么在由Person创建的对象便具有了下面的几个属性
Person.prototype.age = 24;
Person.prototype.getAge = function()
{
	return this.age;
};
flag = true;
if (flag)
{
	var fun = new Person("Tower", "male");
	alert(fun.name);
	alert(fun.gender);
	alert(fun.whoAreYou());
	alert(fun.getAge());
}
Person.prototype.salary = 10000;
Person.prototype.getSalary = function()
{
	return this.name + " can earn about " + this.salary + "RMB each month." ;
};
// 下面就是最神奇的地方, 我们改变了Person的prototype,而这个改变是在创建fun之后
// 而这个改变使得fun也具有了相同的属性和方法
// 继承的意味即此
if (flag)
{
	alert(fun.getSalary());
	alert(fun.constructor.prototype.age);//而这个相当于你直接调用 Person.prototype.age
	alert(Person.prototype.age);
}  

flag = true;
// 函数内部声明的方法是静态的,无法传递的
Person.school = "ISCAS";
Person.whoAreYou = function(){
return "zhutao";
};//动态更改声明期的方法,并不会影响由其创建的对象的方法, 即所谓的静态
if (flag)
{
	alert(Person.school);
	alert(fun.school);//输出的是 "undefined"
	alert(Person.whoAreYou()); //输出 zhutao
	alert(fun.whoAreYou()); // I'm Tower and I'm a male.
}
Person.prototype.getSalary = function(){
return "I can earn 1000000 USD";
};
if (flag)
{
	alert(fun.getSalary());//已经继承了改变, 即所谓的动态
}  

// 多重prototype链的例子
function Employee(name)
{
	this.name = "";
	this.dept = "general";
	this.gender = "unknown";
}
function WorkerBee()
{
	this.projects = [];
	this.hasCar = false;
}
WorkerBee.prototype = new Employee; // 第一层prototype链
function Engineer()
{
	this.dept = "engineer"; //覆盖了 "父对象"
	this.language = "javascript";
}
Engineer.prototype = new WorkerBee; // 第二层prototype链
var jay = new Engineer("Jay");
if (flag)
{
	alert(jay.dept);    //engineer, 找到的是自己的属性
	alert(jay.hasCar);  // false, 搜索到的是自己上一层的属性
	alert(jay.gender);  // unknown, 搜索到的是自己上二层的属性
}  

window.onload = function()
{   
	/*  
	每个对象实例都有个属性成员用于指向到它的instanceof 对象(暂称为父对象)的原型(prototype)  
	我们把这种层层指向父原型的关系称为[原型链 prototype chian]  
	原型也具有父原型，因为它往往也是一个对象实例，除非我们人为地去改变它  
	在JavaScript中，"一切都是对象，函数是第一型。"  
	Function和Object都是函数的实例。  
	Function的父原型指向到Function的原型，Function.prototype的父原型是Object的原型  
	Object的父原型也指向到Function的原型，Object.prototype是所有父原型的顶层  
	在spiderMonkey引擎中，父原型可以通过 __proto__ 进行访问  
  
	大家在看的时候最后能反复的读几篇,能加深理解,尤其是原型,父原型,还有原型链的意思.  
           
	*  prototype  访问的是原型  
	*  __proto__  访问的父原型  
	*  instanceof 原型链的父类     
	*/   
	Function.prototype.hi = function(){alert('hi Function');}   
	Object.prototype.hi = function(){alert('hi Object');}   
       
	var a = function()
    {   
		this.txt = 'a';   
	};   
  
	a.prototype = {   
		say:function(){alert('a');}   
	};   
        
	alert(a instanceof Function);//a是Function的实例;   
	alert(a.__proto__ === Function.prototype);   
	
    //a的父原型指向到Function的原型;   
	//a.__proto__父原型 Function   
	//Function.prototype 父原型 Function   
	alert(Function instanceof Object);   
	
    //Function是Object的实例;   
	alert(Function.__proto__ === Function.prototype);   
   
	//Function的父原型指向到Function的原型;   
	alert(Function.prototype.__proto__ === Object.prototype);   
    
	//Function的原型的父原型指向到Object的原型   
	alert(Object.__proto__ === Function.prototype);   
    
	//Object的父原型指向到Function的原型;   
	alert(Object.prototype.__proto__);   
	//Object的原型是所有父原型的顶端，它不再具有父原型,所以结果为null;       
	alert(a.prototype instanceof Object);   
	//a的原型也是一个对象   
	alert(a.prototype.__proto__ === Object.prototype);   
	//a的原型的父原型指向Object的原型   
};