這裏主要是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