javascript应该注意的小case函数

函数function在js是非常重要的存在，我们平常所讨论的js的”面向对象”，都是在它的基础上的，可以说我们应该相当的了解，它存了太多独特的地方了。

每个函数都是function类型的实例

首先让我们来理解这句话：每个函数其实是function类型的实例。也就是说我们声明的函数都是对象，有自己的属性和方法，函数名不过是指向该对象的一个指针。

看下面这个例子：

  function myfuc(arg) {
        alert(arg);
    }

    var anfuc = myfuc;

    myfuc = null;

    anfuc(1);  //  报错，还是弹出1？？

结果是弹出1，myfuc不过是指向我们函数对象的一个指针，它指向null之后，并不影响anfuc的，因此调用无影响。

函数的内部属性

arguments和this：arguments是一个类数组对象，它包含调用函数时传入的所有参数，你在函数里可以用arguments[0]、arguments[1]…来访问传入参数；此外，它还有一个属性callee，它也也是一个指针，指向拥有这个arguments对象的函数，这个属性在我们递归中相当有用，比直接的函数名易维护且健壮。

   function myfuc(arg) {
        if (arg <= 1) {
            return 1;
        } else {
            return arg + myfuc(arg - 1);
        }
    }

    function anfuc(arg) {
        if (arg <= 1) {
            return 1;
        } else {
            return arg + arguments.callee(arg - 1);
        }
    }

这两个函数虽然写法上有点不一样，但是是相同的目的，在这里强烈推荐采用第二种：在任何时候你想修改该函数名，只需要修改声明即可，同时看下边的例子。

    var myfuc2 = myfuc;
    var anfuc2 = anfuc;

    myfuc = null; anfuc = null;

    alert(anfuc2(3));  //  弹出6
    alert(myfuc2(3));  // 没弹出，并报错

myfuc2的调用中，递归时还去寻找myfuc调用，但是早已“物是人非”了，而anfuc2里arguments.callee始终指向当前调用的函数，也就是anfuc2。

this属性，函数执行时，指向其执行所在的作用域，正确的理解它的意义是很重要的。

    var name = "window";
    function sayName() {
        alert(this.name);
    }

    var o = new Object();
    o.name = "object";
    o.sayName = sayName;

    sayName();  //  弹出window
    o.sayName();  //弹出 object

尽管sayName和o.sayName指向同个对象,但是他们的调用确输出了不一样的结果。我们知道，我们声明的全局变量和函数是属于window的，其实相当于window.name,window.sayName，而这个this动态的指向了拥有该方法的对象。

函数的属性和方法

刚刚介绍的是在函数休内才能使用的属性，而既然函数是对象，那么它肯定有可供我们使用的属性和方法。

length属性：函数声明时希望接受到参数的个数。

prototype属性：这个。。这个。。这个是js强大所在，它不仅能让js比较完美的实现“类”、具有一些面向对象语言的一些特性如继承等，更能扩展内置对象所不具备的功能和属性。

apply方法和call方法：这两个方法都是让函数“自己调用自己”的，只不过传参方式不一样而已。

没有重载的重载

js是没有重载的，试图重载都会覆盖有前一个的函数声明，不过通过js的特性，我们可以实现类似重载的一些特性。由于函数是对象，声明不过是指向该对象的指针而已，因些js在定位函数时只会根据函数名，根本不会考虑你传的参数，因此我们可以用以下两种方式实现类似重载，这两种方式本质是一样的，只是表现形式上的差别。

1，arguments

   function sayHi() {
        var result = "default";
        if (arguments[0]) {
            result = arguments[0];
        }
        if (arguments[1]) {
            result += arguments[1];
        }
        if (arguments[2]) {
            result += arguments[2];
        }
        if (arguments[3]) {
            result += arguments[3];
        }
        // 此处你甚至可以遍历arguments来支持无限的参数
        return result;
    }

    alert(sayHi("a"));  //  a
    alert(sayHi("a", "b"));  // ab
    alert(sayHi("a","b","c"));  //abc

从调用上来看，是不是实现了重载。

2，声明所有参数

function sayHi(a,b,c/*还可以更多*/) {
        var result = "default";
        if (a) {
            result = a;
        }
        if (b) {
            result += b;
        }
        if (c) {
            result += c;
        }
        // 如果还有可以支持更多
        return result;
    }

调用是一样的，结果也是一样的。

第一种方式更灵活，第二种则更易读，对调用者来说更友好。推荐一般参数不多的话，使用第二种，如果要支持无限参数，只有采用第一种。极度不推荐两种混用，那会让代码结非常乱，维护和以后扩展都会有不少麻烦。

函数的创建方式

一般来说我们有两种方式创建函数：

1，函数声明方式：function func(){}

2，函数表达式：var func = function(){}

这两种难道就只是表现形式的差别吗？？当然不是，解析器在解析js时，会优先处理函数声明，会在所有任何需要执行的代码之前让函数可用；而函数表达式只有在执行到所有行时，才会被解析执行。

也就是说：

 sayHi();
    function sayHi() {
        alert("hi");
    }

这样的方式，代码是没问题的，并且会弹出hi.

但是

sayHi();
    var sayHi = function() {
        alert("hi");
    }

这种方式，会报错，缺少对象。

匿名函数和闭包

匿名函数也称做lambda函数，一般情况下，我们会在以下几种情况下会用到匿名函数：

1，回调函数

2，函数做为返回值

3，插件形式的开发

如我们经常看到的如：

(function(){

	//  代码

})();

(function($){

	//  代码

})(jQuery);

第二个是jquery推荐的插件开发的方式，这里声明一个匿名函数，然后立即执行。函数内部声明变量和函数，除了绑定给全局变量的一些变量和函数，我们在外部是不能访问，起到隔离性的作用，不会对页面造成影响，内部没有闭包的存在，函数执行完毕后，变量函数就会被回收。

很多的匿名函数往往能看到闭包的身影，闭包又是什么？

看一个例子：

function createFunc(){
	
	var name = "123";

	return function(){
		alert(name);
	};

}

var func = createFunc();

func(); //  弹出123

这是一个闭包的简单例子，createFunc返回了一个匿名函数，一般情况下，一个函数执行完毕后，其内部变量就会被回收，但是createFunc返回的函数里却保持着对内部变量name的引用，因些我们在外部调用然后执行func，仍然可以使用，只要func存在，我们执行createFunc时所创建的内部变量就会处于内存中的一个位置，直到我们显示的设置func = null，这次createFunc()创建的name才会被回收。

闭包就是有权访问另一个函数作用域变量的函数。它会让另一个函数内部的变量仍然处理有效的状态，这有时会为我们带来莫大的方便，但是我们有时可能要考虑闭包的使用：就是因为闭包的存在，函数执行完毕后，其内部所有的变量就不能被立即回收，仍然处于内存中。

js的函数即独特又很重要，用其它语言的方式使用js的函数，即不能体现出它的强大，有时还可能陷入困惑。它也使js强大，使得js具备一些封装、继承等高级特性，更有利于我们开发健壮、易维护的应用。