这里主要是JS的基础知识，也是深入理解Ext的基础。

1.参数可变长，注意跟Java还是有一点区别的。

  例：function getUser(name,age){

    alert("name: "+name + " age: "+age);

  }

  调用方法：getUser(); // 可以不传参数

            getUser("cat"); // 可以只传递一个参数

            getUser("cat"，20); // 传两个参数

            getUser("cat"，20，2，"dog"); // 传两个以上的参数

2.不给函数定义形参，直接在函数中使用arguments属性获取实际传递的参数数组。

  例：function getUser(){

       var args = arguments;

       alert(args.length);

       alert(args[0]);

    }

3.js函数不能重载.因为，JS函数的参数是可变长的，从代码意义上来说就没有重载。另外，JS是一种解释执行的语言，浏览器脚本引擎开始载入JS代码的时候，必须先“扫描”然后才开始解释执行。在这个过程中，有一个重要的操作就是“标识符解析”，要求同一命名空间不允许同名变量的存在，包括函数名。

 例：function getUser(){

       alert("hello!");

    }

    function getUser(name){

       alert("sorry!");

    }

    getUser(); // 结果永远是 sorry!

4.命名空间：Java我们用package edu.ouc.wy来定义，JS中则需要我们一层一层的定义。

  var edu = {};

  var edu.ouc = {};

  var edu.ouc.wy = {};

5.JS支持函数嵌套

 例：function outerFn(){

      function innerFn(){

       alert("innerFn test..");

     }

     alert("outerFn test...");

   }

   outerFn();  // 结果弹出来两个窗口

6.既然有了函数嵌套，我们就有从outerFn外部调用innerFn函数的需求

例：function outerFn(){

      function innerFn(){

       alert("innerFn test..");

     }

     return innerFn();

   }

   var cacheFn = outerFn();

   cacheFn();

  一般来说，“外层”作用域中的代码是无法访问“内层”作用域的。但是通过return一个函数的方式，可以让函数“穿越”作用域的限制，从而让外层作用域能够“触摸”到“内层”的函数和变量。

例：var outerName = "cat";

   function outerFn(){

    var name = "dog";

    function innerFn(){

     alert("outername: "+outerName + " innername: "+name);

   }

   return innerFn;

  }

  var cacheFn = outerFn();

   cacheFn(); // 结果为 outername: cat innername: dog

7.JS中函数既是数据

 例：function testFn(){

      alert("test function..");

   }

   alert(testFn); // 显示的结果和上面这三行是一样的

 例：testFn = function(){

      alert("test function..");

   }

    alert(testFn); // 效果和上一个例子是一样的

   两者的不同是：前者直接声明了一个函数，在脚本引擎的解析期间，这个函数就会被创建。

  而后者相当于是定义了一个变量，因此只有在脚本真正执行到这一行的时候，函数才会被构建出来。

8.函数作为对象的属性，动态的添加和删除

例：var obj = {};

   obj.testFn = function(){

    alert("test func..");

  }

  obj.testFn(); // 括号()的目的是让testFn这个属性（函数）执行

  delete obj.testFn;

  obj.testFn(); // 报错

9.函数也是对象，也有自己的类：Function

例1：var testFn = new Function('name','alert(my func...)');

   testFn();  // 结果 my func...

  Function:可以接受任意多个参数，只有最后一个参数被当做“函数体”。使用new Function()方式创建的函数，是在运行时才创建。并且他的作用域是“顶级作用域”，即window

例：function outerFn(){

    var name = "cat";

    var innerFn = new Function("alert(name)");

    return innerFn;

 }

  var cacheFn = outerFn();

  cacheFn();  // 结果报错，因为在window作用域中，找不到name变量

例2：var myFn = function(){}

     myFn.name = "cat";

     alert(myFn.name); // cat

     delete myFn.name;

     alert(myFn.name); // 空 

10.三种特殊形式的函数调用：call，apply，（）

例：function myFn(){

    alert(this.name);

  }

  myFn.call({name:"cat"});  // 结果为cat

  myFn.apply({name:"dog"});  // 结果为dog

 结果很奇怪：两次this.name居然不一样。这就是JS是动态语言的意义所在，不要被Java思想所束缚。对于JS来说，函数中的this并不一定指向特定的对象，它是可变的。（这句很重要）

 call和apply都能执行函数并给this传递参数。两者相同点：他们都可以接受两个参数，第一个参数为函数中this需要绑定的对象。不同点：call的第二个参数是可变长参数，apply的第二个参数是数组。

例：function myFn(a,b){

     return a+b;

   }

   myFn.call({},1,2);

   myFn.apply({},[1,2]);

例：(function(){

      alert("my func..");

    })();

   结果这个函数自己就执行了。

11.我们知道了函数也是对象。也用过了arguments这个原生属性。JS为函数对象提供了很多原生的属性，包括arguments,callee,caller,length,prototype等

例1：function myFn(){

      var s = "";

      var len = arguments.length;

      for(var i=0; i<len; i++){

       s += arguments[i]; // 注意arguments不是数组，而是对象

      }

      alert(s);

   }

    myFn(1,2,3,4,5);

例2：function fact(n){ // n的阶乘

      if(n==1){

        return 1;

      }else{

        return n * arguments.callee(n-1);

      }

    }

   callee在arguments属性中定义，并且它指向函数自己，可以用于递归调用。

例3：function worker(){

        alert(worker.caller); // 将会输出boss函数的代码，因为没有给他加（），

                               // 否则将报错too much recursion

     }

     function boss(){

        worker();

     }

     boss();