一、函数
JavaScript中的函数定义分为两种：声明式函数和赋值式函数。而且，函数的名称就是函数的内存地址，和变量一样，指向函数代码所在的内存区域。
// 声明式函数
function fn(name){
var msg = "你好，"+name+"，我是一个函数.";
alert(msg);
}
// 赋值式函数
var fn = function(name){
var msg = "你好，"+name+"，我是一个函数.";
alert(msg);
}
以上两种表达式中的fn是一样的，都是指向一个函数的指针。alert(fn)的运行结果都是：
alert(fn)之所以能够打印函数的声明语句，是因为toString()方法：
function fn(){
var msg = "你好，"+name+"，我是一个函数.";
alert(msg);
}
alert(fn.toString());
运行结果是一样的。
那么toString()方法是怎样来的呢？
对于JavaScript来说，函数其实是Function类的对象。比如，我们可以用Function类直接创建上面的fn函数：
var fn = new Function("name","var msg = \"你好，\"+name+\"，我是一个函数.\";\nalert(msg);");
alert(fn);
执行结果如下：
函数的执行结果也是一样的：
var fn = new Function("name","var msg = \"你好，\"+name+\"，我是一个函数.\";\nalert(msg);");
fn("张三");
Function对象有length属性，可以查看函数的参数，有valueOf()方法和toString()方法，这两个方法返回的都是函数的源代码。因此，alert(fn)显示的就是函数的声明语句了。
既然函数名是指向函数的变量，那么就可以把函数作为参数传递给另一个函数。
function fn(name){
var msg = "你好，"+name+"，我是一个函数.";
alert(msg);
}
function call_fn(func,name){
func(name);
}
call_fn(fn,"张三");
JavaScript的函数，使用特殊对象arguments封装了函数的参数，我们无需明确指出参数名，就能访问它们。通过属性 arguments.length可以获得函数的参数个数 。用arguments对象判断传递给函数的参数个数，即可模拟函数重载。下面是官方的一个例子。
function doAdd() {
if(arguments.length == 1) {
alert(arguments[0] + 5);
} else if(arguments.length == 2) {
alert(arguments[0] + arguments[1]);
}
}
doAdd(10); //输出 "15"
doAdd(40, 20); //输出 "60"
JavaScript函数中，变量的作用域，要特别注意的一点是：加var关键字的变量是函数内部的局部变量，函数执行完后，变量将销毁；但没有加var关键字的变量，将成为全局变量，函数外可以访问。
function fn(){
var x = 10;
y = 20;
alert("函数内部访问x:"+x+"\n函数内部访问y:"+y);
}
fn();
alert("函数外部访问y:"+y);
alert("函数外部访问x:"+x);
二、对象
JavaScript没有类的概念，只有对象定义。对象是由 new 运算符加上要实例化的对象的名字创建的。其中，要实例化的对象其实就是函数。那么，函数是怎样变成对象的呢？
先看下面这段代码。
function myobj(){
return this;
}
var f = myobj();
var o= new myobj();
alert(f);
alert(o);
我们发现，加了new运算符后，this才指向由myobj创建的对象。
而var f = myobj()，这就不是创建对象，其中的this不是指myobj创建的对象，而是代码当前上下文环境的当前对象，比如是window。
也就是说，用new运算符调用函数就创建了对象。this代表实例化之后的对象，可以显示的return，但并不需要这么做。以下代码效果是一样的。
function myobj(){
}
var o = new myobj();
alert(o);
JavaScript的Object对象与Java中的Object相似，JavaScript中的所有对象都由这个对象继承而来，Object对象中的所有属性和方法都会出现在其他对象中。
Object 对象具有下列属性：
- constructor：创建对象的函数（构造函数）的引用（指针）。
- Prototype：对该对象的对象原型的引用。对于所有的对象，它默认返回Object对象的一个实例。
还具有几个方法：
- hasOwnProperty(property) ：判断对象是否有某个特定的属性。必须用字符串指定该属性。（例如，o.hasOwnProperty("name")）。
- isPrototypeOf(object) ：判断该对象是否为另一个对象的原型。
- propertyIsEnumerable ：判断给定的属性是否可以用 for...in 语句进行枚举。
- toString() ：返回对象的原始字符串表示。对于 Object 对象，ECMA-262 没有定义这个值，所以不同的 ECMAScript 实现具有不同的值。
- valueOf() ：返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同。
我们在浏览器的开发者工具的控制台输入new object()回车，可以查看上面那些Object对象的属性和方法。
Object对象也可以使用对象字面量语法来创建：var o = {};
同样，我们可以在浏览器的开发者工具中进行验证。
javascript支持后绑定，比如这样:
function obj()
{
}
var o = new obj();
o.fn = function(){
alert("hello");
}
o.fn();
所以，可以通过函数创建对象，这叫工厂方法：
function createCar(color,doors,mpg) {
var car = new Object();
car.color = color;
car.doors = doors;
car.mpg = mpg;
car.showColor = function() {
alert(this.color);
};
return car;
}
var car1 = createCar("red",4,23);
var car2 = createCar("blue",3,25);
car1.showColor();
car2.showColor();
比较正规一点的创建对象的方法，用构造函数法，用this代表当前对象了：
function Car(color,doors,mpg) {
this.color = color;
this.doors = doors;
this.mpg = mpg;
this.showColor = function() {
alert(this.color);
};
}
var car1 = new Car("red",4,23);
var car2 = new Car("blue",3,25);
car1.showColor();
car2.showColor();
构造函数法的问题是，其中的对象方法，比如例子中的showColor方法，每次new的时候都会创建一次，显然浪费内存。
可以用原型链定义对象的方法。这样，所有对象共享一个对象方法，既保证了对象属性的唯一性，也节约了内存：
function Car(color,doors,mpg) {
this.color = color;
this.doors = doors;
this.mpg = mpg;
this.drivers = new Array("Mike","John");
}
Car.prototype.showDrivers = function() {
alert(this.drivers);
};
var car1 = new Car("red",4,23);
var car2 = new Car("blue",3,25);
car1.drivers.push("Bill");
car1.showDrivers(); //输出 "Mike,John,Bill"
car2.showDrivers(); //输出 "Mike,John"
对象方法，只能是new之后的对象可以访问：
function obj(){
}
obj.prototype.fn = function(){
alert("hello");
}
var o = new obj();
o.fn();
但是，如果这样访问obj.fn()就会报错：
function obj(){
}
obj.prototype.fn = function(){
alert("hello");
}
obj.fn();
用函数名字直接访问的方法，我们叫函数方法，或者静态方法。
function obj(){
}
obj.fn = function(){
alert("hello");
}
obj.fn();
但javascript的静态方法，对象并不能访问，如果这样就会报错：
function obj(){
}
obj.fn = function(){
alert("hello");
}
var o = new obj();
o.fn();
还有很重要的一点，原型属性是所有对象共享，如果属性是引用类型，那么就会出现，一个对象修改了数值，其他对象相应的属性数值都会改变的尴尬局面。
function obj(){
}
obj.prototype.names = ["张三","李四"];
var o1 = new obj();
var o2 = new obj();
o1.names.push("o1添加的新的名字");
alert("o1.names:"+o1.names+"\no2.names:"+o2.names);
其实，javascript并没有真正的静态方法，只是利用javascript灵活的特性模拟实现的。