函数，对象，原型

函数：

1、定义式函数

function Person(){
    alert('Hello!');
}

Person();//Hello!

2、变量式函数 

var Person = function (){
 alert('Hello!');     
}
Person();//Hello!

3、

var Person = function (){
    alert('Lily');
}
Person();//第一次调用,显示Lily
Person = function (){
    alert('Bill');
}
Person();//第二次调用，显示Bill

 第一次调用之后，函数变量又被重新赋予新的函数体，第二次调用函数的时候，出现了不同的输出。以上代码给为下边代码

4、

function Person(){
    alert('Lily');
}
Person();//输出Bill
function Person(){
    alert('Bill');
}
Person();//输出Bill

两个命名一样的函数，在程序运行完后，你会发现，输出的都是最后一个函数值；第一个函数没起到作用；Javascript不是一行一行执行代码，而是一段一段，第一个函数会被最后执行的覆盖，所以两次调用都执行最后一个函数值。

对象：

任何一个函数都可以为其动态地添加或去除属性，这些属性可以是简单类型，可以是对象，也可以是其他函数；函数有对象的全部特征，可以说函数就是对象

function Person(){
    with(arguments.callee)
    alert(age);
}
Person.age = 22;
Person(); //显示22

Person函数被定以后，又增加了age属性。

1、创建一个没有任何属性的对象

var Person = {}

2、有数据的对象

　　1）、创建一个有属性，初始值的对象

var Person = {name:'Lily',age:22};

　　2）、创建一个有属性及方法的对象

var Person = {name:'Lily',age:22,sayHello:function(){alert('Hello')}};

alert(Person.name);//Lily

　　3）、创建一个嵌套其他对象及数组的对象 

var company = {
    name:'Mic',
    employees:[
        {name:'Lily',age:22},
        {name:'Lucy',age:44}
    ]
};

alert(company.employees[0].name);//Lily

对象和函数可以象数组一样，用属性名或方法名作为下标来访问并处理　

　4)、

var Person = {};
Person.name = 'Lily';
Person.age = 22;
Person.sayHello = function (){
    alert("I'm  " +" " + this.name  + ' ' + this.age)
};

Person.sayHello();

创建了Person空对象，并设置name,age属性及sayHello方法；

构造函数： 

function Person(name){
    this.name = name;//this对象name属性    
    this.sayHello = function (){ //给this对象创建sayHello方法
        alert("Hello I'm" + ' ' + this.name)
    }
}
function Employee(name, salary) {
  Person.call(this, name); //将this 传给父构造函数
  this.salary = salary; //设置一个this 的salary 属性
  this.ShowMeTheMoney = function() {
    alert(this.name + " $" + this.salary);
  };
  //添加ShowMeTheMoney 方法。
};
var oBill = new Person('Bill');//用Person构造函数创建oBill对象
var oLily = new Employee('Lily',1145); //用Empolyee 构造函数创建SteveJobs 对象
oBill.sayHello();//显示 Hello I'm Bill
oLily.sayHello();//显示 Hello I'm Lily
oLily.ShowMeTheMoney();//显示 Lily $1145

创造了一个带参数的构造函数Person,并把2行的name参数值赋值给this.name,并创建了sayHello方法，利用Person构造函数创建oBill对象；

7行的Employee函数将自己接受的this 作为参数调用Person构造函数；

oBill是由Person 构造的，oLily是由Employee构造的；

15\16行用Person和Empolyee创建基类的oBill和oLily对象；

我们还可以先定义一份唯一的方法函数体，并在构造this对象时使用它作为其方法，共享逻辑。如下：

function sayHello(){ //先定义一份方法
    alert("Hello I'm" + ' ' + this.name)
}

function Person(name){
    this.name = name;//this对象name属性    
    this.sayHello = sayHello; //把2行中的sayHello方法的一堆代码复制给 this.sayHello
}

var oBill = new Person('Bill');//用Person构造函数创建oBill对象

oBill.sayHello();//显示 Hello I'm Bill

这样达到了共享的目的，还可以用prototype这个概念，如下：

原型：

function Person(name){
    this.name = name;//设置对象属性，每个对象各自一份属性数据
}
Person.prototype.sayHello = function(){ //给Person 函数的prototype 添加SayHello 方法。
    alert("Hello I'm" + ' ' + this.name)
}
var oBill = new Person('Bill');//创建oBill对象

oBill.sayHello();//oBill 对象直接调用到SayHello 方法

构造函数 prototype上定义的方法可以通过对象直接调用，而且代码共享。逻辑上体现了方法和类的关系。来个复杂点的：

function Person(name){//基类构造函数
    this.name = name;
}

function Employee(name, salary) {
  Person.call(this, name); //调用基类构造函数
  this.salary = salary; 
};
 
Person.prototype.sayHello = function(){ //给基类构造函数的prototype 添加方法
    alert("Hello I'm" + ' ' + this.name)
}

Employee.prototype = new Person(); //建一个基类的对象作为子类原型的原型，这里很有意思

Employee.prototype.ShowMeTheMoney = function() //给子类添构造函数的prototype 添加方法
{
  alert(this.name + " $" + this.salary);
};

var oBill = new Person('Bill');//创建基类Person oBill 对象
var oLily = new Employee('Lily',1145); //创建子类Employee 的oLily 对象

oBill.sayHello();//通过对象直接调用到prototype 的方法
oLily.sayHello();//通过子类对象直接调用基类prototype 的方法，关注！
oLily.ShowMeTheMoney(); //通过子类对象直接调用子类prototype 的方法

继承：

闭包：

http://liuxiaofan.com/?p=1330#more-1330