这里主要是JS的基础知识，也是深刻理解Ext的基础。
1.参数可变长，注意跟Java仍是有一点区别的。
例：node
1.
function getUser(name,age){
2.
alert("name: "+name + " age: "+age);
3.
}
调用方法：getUser(); // 能够不传参数
getUser("cat"); // 能够只传递一个参数
getUser("cat"，20); // 传两个参数
getUser("cat"，20，2，"dog"); // 传两个以上的参数
2.不给函数定义形参，直接在函数中使用arguments属性获取实际传递的参数数组。
例：
1.
function getUser(){
2.
var args = arguments;
3.
alert(args.length);
4.
alert(args[0]);
5.
}
3.js函数不能重载.由于，JS函数的参数是可变长的，从代码意义上来讲就没有重载。另外，JS是一种解释执行的语言，浏览器脚本引擎开始载入JS代码的时候，必须先“扫描”而后才开始解释执行。在这个过程当中，有一个重要的操做就是“标识符解析”，要求同一命名空间不容许同名变量的存在，包括函数名。
例：
1.
function getUser(){
2.
alert("hello!");
3.
}
4.
function getUser(name){
5.
alert("sorry!");
6.
}
7.
getUser(); // 结果永远是 sorry!
4.命名空间：Java咱们用package edu.ouc.wy来定义，JS中则须要咱们一层一层的定义。
1.
var edu = {};
2.
var edu.ouc = {};
3.
var edu.ouc.wy = {};
5.JS支持函数嵌套
例：
1.
function outerFn(){
2.
function innerFn(){
3.
alert("innerFn test..");
4.
}
5.
alert("outerFn test...");
6.
}
7.
outerFn(); // 结果弹出来两个窗口
6.既然有了函数嵌套，咱们就有从outerFn外部调用innerFn函数的需求
例：
1.
function outerFn(){
2.
function innerFn(){
3.
alert("innerFn test..");
4.
}
5.
return innerFn();
6.
}
7.
var cacheFn = outerFn();
8.
cacheFn();
通常来讲，“外层”做用域中的代码是没法访问“内层”做用域的。可是经过return一个函数的方式，可让函数“穿越”做用域的限制，从而让外层做用域可以“触摸”到“内层”的函数和变量。
例：
01.
var outerName = "cat";
02.
function outerFn(){
03.
var name = "dog";
04.
function innerFn(){
05.
alert("outername: "+outerName + " innername: "+name);
06.
}
07.
return innerFn;
08.
}
09.
var cacheFn = outerFn();
10.
cacheFn(); // 结果为 outername: cat innername: dog
7.JS中函数既是数据
例：
1.
function testFn(){
2.
alert("test function..");
3.
}
4.
alert(testFn); // 显示的结果和上面这三行是同样的
例：
1.
testFn = function(){
2.
alert("test function..");
3.
}
4.
alert(testFn); // 效果和上一个例子是同样的
二者的不一样是：前者直接声明了一个函数，在脚本引擎的解析期间，这个函数就会被建立。
然后者至关因而定义了一个变量，所以只有在脚本真正执行到这一行的时候，函数才会被构建出来。
8.函数做为对象的属性，动态的添加和删除
例：
1.
var obj = {};
2.
obj.testFn = function(){
3.
alert("test func..");
4.
}
5.
obj.testFn(); // 括号()的目的是让testFn这个属性（函数）执行
6.
delete obj.testFn;
7.
obj.testFn(); // 报错
9.函数也是对象，也有本身的类：Function
例1：
1.
var testFn = new Function('name','alert(my func...)');
2.
testFn(); // 结果 my func...
Function:能够接受任意多个参数，只有最后一个参数被当作“函数体”。使用new Function()方式建立的函数，是在运行时才建立。而且他的做用域是“顶级做用域”，即window
例：
1.
function outerFn(){
2.
var name = "cat";
3.
var innerFn = new Function("alert(name)");
4.
return innerFn;
5.
}
6.
var cacheFn = outerFn();
7.
cacheFn(); // 结果报错，由于在window做用域中，找不到name变量
例2：
1.
var myFn = function(){}
2.
myFn.name = "cat";
3.
alert(myFn.name); // cat
4.
delete myFn.name;
5.
alert(myFn.name); // 空
10.三种特殊形式的函数调用：call，apply，（）
例：
1.
function myFn(){
2.
alert(this.name);
3.
}
4.
myFn.call({name:"cat"}); // 结果为cat
5.
myFn.apply({name:"dog"}); // 结果为dog
结果很奇怪：两次this.name竟然不同。这就是JS是动态语言的意义所在，不要被Java思想所束缚。对于JS来讲，函数中的this并不必定指向特定的对象，它是可变的。（这句很重要）
call和apply都能执行函数并给this传递参数。二者相同点：他们均可以接受两个参数，第一个参数为函数中this须要绑定的对象。不一样点：call的第二个参数是可变长参数，apply的第二个参数是数组。
例：
1.
function myFn(a,b){
2.
return a+b;
3.
}
4.
myFn.call({},1,2);
5.
myFn.apply({},[1,2]);
6.
例：(function(){
7.
alert("my func..");
8.
})();
结果这个函数本身就执行了。
11.咱们知道了函数也是对象。也用过了arguments这个原生属性。JS为函数对象提供了不少原生的属性，包括arguments,callee,caller,length,prototype等
例1：
01.
function myFn(){
02.
var s = "";
03.
var len = arguments.length;
04.
for(var i=0; i<len; i++){
05.
s += arguments[i]; // 注意arguments不是数组，而是对象
06.
}
07.
alert(s);
08.
}
09.
myFn(1,2,3,4,5);
例2：
1.
function fact(n){ // n的阶乘
2.
if(n==1){
3.
return 1;
4.
}else{
5.
return n * arguments.callee(n-1);
6.
}
7.
}
callee在arguments属性中定义，而且它指向函数本身，能够用于递归调用。
例3：
1.
function worker(){
2.
alert(worker.caller); // 将会输出boss函数的代码，由于没有给他加（），
3.
// 不然将报错too much recursion
4.
}
5.
function boss(){
6.
worker();
7.
}
8.
boss();
原文连接：http://extjs.org.cn/node/585