摘要：函數(shù)使用它們實參的值來計算返回值，稱為該函數(shù)調(diào)用表達(dá)式的值。通常函數(shù)名的第一個字符為小寫。在函數(shù)內(nèi)部定義的變量，外部無法讀取，稱為局部變量。注意對于命令來說，局部變量只能在函數(shù)內(nèi)部聲明，在其他區(qū)塊中聲明，一律都是全局變量。

通過函數(shù)可以封裝任意多條語句，而且可以在任何地方、任何時候調(diào)用。

ECMAScript中的函數(shù)使用function關(guān)鍵字來聲明，后跟一組參數(shù)以及函數(shù)體，這些參數(shù)在函數(shù)體內(nèi)像局部變量一樣工作。

function functionName(arg0, arg1....argN) {
  statements
}

函數(shù)調(diào)用會為形參提供實參的值。函數(shù)使用它們實參的值來計算返回值，稱為該函數(shù)調(diào)用表達(dá)式的值。

function test(name){
    return name;
}
test("tg");

在上面的例子中，name就是形參，調(diào)用時的"tg"就是實參。

除了實參之外，每次調(diào)用還會擁有另一個值---本次調(diào)用的上下文---這就是this關(guān)鍵字的值。

我們還可以通過在函數(shù)內(nèi)添加return語句來實現(xiàn)返回值。

注意：遇到return語句時，會立即退出函數(shù)，也就是說，return語句后面的語句不再執(zhí)行。

function test(){
  return 1;
  alert(1);  //永遠(yuǎn)不會被執(zhí)行
}

一個函數(shù)中可以包含多個return語句，而且return語句可以不帶有任何返回值，最終將返回undefined。

function test(num){
  if(num > 2){
   return num;
  }else{
    return ;
  }
}
test(3);  // 3
test(1);  //undefined

如果函數(shù)掛載在一個對象上，將作為對象的一個屬性，就稱它為對象的方法。

var o = {
  test: function(){}
}

test()就是對象o的方法。

JavaScript有三種方法，可以定義一個函數(shù)。

（1）function命令

function name() {}

name是函數(shù)名稱標(biāo)識符。函數(shù)名稱是函數(shù)聲明語句必需的部分。不過對于函數(shù)表達(dá)式來說，名稱是可選的：如果存在，該名字只存在于函數(shù)體內(nèi)，并指向該函數(shù)對象本身。

圓括號：圓括號內(nèi)可放置0個或多個用逗號隔開的標(biāo)識符組成的列表，這些標(biāo)識符就是函數(shù)的參數(shù)名稱。 花括號：可包含0條或多條JavaScript語句。這些語句構(gòu)成了函數(shù)體。一旦調(diào)用函數(shù)，就會執(zhí)行這些語句。

（2）函數(shù)表達(dá)式

var f = function(x){   
  console.log(x);  
}

采用函數(shù)表達(dá)式聲明函數(shù)時，function命令后面不帶有函數(shù)名。如果加上函數(shù)名，該函數(shù)名只在函數(shù)體內(nèi)部有效，在函數(shù)體外部無效。

（3）Function()

Function()函數(shù)定義還可以通過Function()構(gòu)造函數(shù)來定義

var f=new Function("x","y","return x+y");

等價于

var f=function(x,y){
  return x+y;
}

除了最后一個參數(shù)是函數(shù)體外，前面的其他參數(shù)都是函數(shù)的形參。如果函數(shù)不包含任何參數(shù)，只須給構(gòu)造函數(shù)簡單的傳入一個字符串---函數(shù)體---即可。 不過，F(xiàn)unction()構(gòu)造函數(shù)在實際編程中很少會用到。

注意點：如果同一個函數(shù)被多次定義（聲明），后面的定義（聲明）就會覆蓋前面的定義（聲明）

function f(){
 console.log(1);
}
f()  //1

function f(){
 console.log(2);
}
f()  //2

函數(shù)可以調(diào)用自身，這就是遞歸（recursion）

function f(x){
  if(x>2){
    console.log(x);
    return f(x-1);
  }else{
    return 1;
  }
}
f(4); 
// 4
//3

不能在條件語句中聲明函數(shù) （在ES6中的塊級作用域是允許聲明函數(shù)的。）

任何合法的JavaScript標(biāo)識符都可以用做一個函數(shù)的名稱。

函數(shù)名稱通常是動詞或以動詞為前綴的詞組。 通常函數(shù)名的第一個字符為小寫。當(dāng)函數(shù)名包含多個單詞時，可采取下劃線法，比如：like_this()；也可以采取駝峰法，也就是除了第一個單詞之外的單詞首字母使用大寫字母，比如：likeThis();

就像變量的“被提前”一樣，函數(shù)聲明語句也會“被提前”到外部腳本或外部函數(shù)作用域的頂部，所以以這種方式聲明的函數(shù)，可以被在它定義之前出現(xiàn)的代碼所調(diào)用。

f()
function f(){}

其實JavaScript是這樣解釋的：

function f(){}
f()

注意：以表達(dá)式定義的函數(shù)并沒有“被提前”，而是以變量的形式“被提前”。

f();  
var f = function (){};  
// TypeError: f is not a function

變量其實是分為聲明，賦值兩部分的，上面的代碼等同于下面的形式

var f;
f();
f = function() {};

調(diào)用f的時候，f只是被聲明了，還沒有被賦值，等于undefined，所以會報錯。

JavaScript的函數(shù)可以嵌套在其他函數(shù)中定義，這樣它們就可以訪問它們被定義時所處的作用域中的任何變量，這就是JavaScript的閉包。

function test(){
  var name = "tg";
  function test2(){
    var age = 10;
    console.log(name);  // "tg"
  }
  console.log(age);  // Uncaught ReferenceError: age is not defined
}
test();

從上面的例子可得，test2()可以訪問name，但是如果在test()內(nèi)，test2()外訪問age，就會報錯。

構(gòu)成函數(shù)主體的JavaScript代碼在定義時并不會執(zhí)行，只有調(diào)用該函數(shù)，它們才會執(zhí)行。有4種方式調(diào)用JavaScript函數(shù)：

作為函數(shù)

作為方法

作為構(gòu)造函數(shù)

通過它們的call()和apply()方法間接調(diào)用

6.1函數(shù)調(diào)用

函數(shù)可以通過函數(shù)名來調(diào)用，后跟一對圓括號和參數(shù)（圓括號中的參數(shù)如果有多個，用逗號隔開）

function test(){}
test()

6.2方法調(diào)用

var o = {
 f: function(){}
}
o.f();

6.3構(gòu)造函數(shù)調(diào)用

如果函數(shù)或者方法調(diào)用之前帶有關(guān)鍵字new，它就構(gòu)成構(gòu)造函數(shù)調(diào)用。 凡是沒有形參的構(gòu)造函數(shù)調(diào)用都可以省略圓括號（但不推薦）。

var o=new Object();
var o=new Object;

7.1 可選形參

在ECMAScript中的函數(shù)在調(diào)用時，傳遞的參數(shù)可少于函數(shù)中的參數(shù)，沒有傳入?yún)?shù)的命名參數(shù)的值是undefined。
為了保持好的適應(yīng)性，一般應(yīng)當(dāng)給參數(shù)賦予一個合理的默認(rèn)值。

function go(x,y){   
  x = x || 1;   
  y = y || 2;  
}

注意：當(dāng)用這種可選實參來實現(xiàn)函數(shù)時，需要將可選實參放在實參列表的最后。那些調(diào)用你的函數(shù)的程序員是沒法省略第一個參數(shù)并傳入第二個實參的。

7.2 實參對象

當(dāng)調(diào)用函數(shù)時，傳入的實參個數(shù)超過函數(shù)定義時的形參個數(shù)時，是沒有辦法直接獲得未命名值的引用。 這時，標(biāo)識符arguments出現(xiàn)了，其指向?qū)崊ο蟮囊?，實參對象是一個類數(shù)組對象，可以通過數(shù)字下標(biāo)來訪問傳入函數(shù)的實參值，而不用非要通過名字來得到實參。

function go(x){   
  console.log(arguments[0]);   
  console.log(arguments[1]);  
}  
go(1,2);  
//1
//2

arguments有一個length屬性，用以標(biāo)識其所包含元素的個數(shù)。

function f(x){
  console.log(arguments.length);
}
f(1,2)  // 2

注意：arguments并不是真正的數(shù)組，它是一個類數(shù)組對象。每個實參對象都包含以數(shù)字為索引的一組元素以及l(fā)ength屬性。

通過實參名字來修改實參值的話，通過arguments[]數(shù)組也可以獲取到更改后的值。

在函數(shù)體內(nèi)，我們可以通過arguments對象來訪問這個參數(shù)類數(shù)組，我們可以使用方括號語法訪問它的每一個參數(shù)（比如arguments[0]），它還有一個length屬性，表示傳遞進(jìn)來的參數(shù)個數(shù)。

arguments類數(shù)組中每一個元素的值會與對應(yīng)的命名參數(shù)的值保持同步，這種影響是單向的，也可以這樣說，如果是修改arguments中的值，會影響到命名參數(shù)的值，但是修改命名參數(shù)的值，并不會改變arguments中對應(yīng)的值。

function f(x){   
  console.log(x);    // 1
  arguments[0]=null;   
  console.log(x);    // null
}

f(1);

在上面的例子中，arguments[0]和x指代同一個值，修改其中一個的值會影響到另一個。 注意：如果有同名的參數(shù)，則取最后出現(xiàn)的那個值。

function f(x,x){
 console.log(x);
}
f(1,2)  // 2

callee和caller屬性

arguments對象帶有一個callee屬性，返回它所對應(yīng)的原函數(shù)。

在一個函數(shù)調(diào)用另一個函數(shù)時，被調(diào)用函數(shù)會自動生成一個caller屬性，指向調(diào)用它的函數(shù)對象。如果該函數(shù)當(dāng)前未被調(diào)用，或并非被其他函數(shù)調(diào)用，則caller為null。

再次提醒，arguments并不是真正的數(shù)組，它只是類數(shù)組對象（有l(wèi)ength屬性且可使用索引來訪問子項）。但我們可以借助Array類的原型對象的slice方法，將其轉(zhuǎn)為真正的數(shù)組：

Array.prototype.slice.call(arguments, 0);

//更簡潔的寫法

[].slice.call(arguments, 0);

7.3 按值傳參

ECMAScript中所有函數(shù)的參數(shù)都是按值傳遞的。也就是說，把函數(shù)外部的值復(fù)制給函數(shù)內(nèi)部的參數(shù)，就和把值從一個變量復(fù)制到另一個變量一樣。

在向參數(shù)傳遞基本類型的值時，被傳遞的值會被復(fù)制給一個局部變量（即命名參數(shù)，或者用ECMAScript的概念來說，就是arguments對象中的一個元素。）

例子：

var num = 1;
function test(count){
  count += 10;
  return count;
}
var result = test(num);
console.log(num);  // 1
console.log(result);  // 11

在上面的例子中，我們將num作為參數(shù)傳給了test()函數(shù)，即count的值也是1，然后在函數(shù)內(nèi)將count加10，但是由于傳遞的只是num的值的一個副本，并不會影響num，count和num是獨立的，所以最后num的值依舊是1.

在向參數(shù)傳遞引用類型的值時，會先把這個值在內(nèi)存中的地址復(fù)制給一個局部變量，若局部變量變化，則局部變量和復(fù)制給局部變量路徑的全局變量也會發(fā)生改變。

function test(obj){
  obj.name = "tg";
}
var person = new Object();
test(person);
console.log(person.name);  // "tg"

但是，如果局部變量指向了一個新的堆內(nèi)地址，再改變局部變量的屬性時，不會影響全局變量。

看下面的例子：

function test(obj){
  obj.name = "tg";
  obj = new Object();
  obj.name = "tg2";
}

var person = new Object();
test(person);
console.log(person.name);  // "tg"

在上面的例子中，全局的person和函數(shù)內(nèi)局部的obj在初始傳遞時，兩者指向的是內(nèi)存中的同一個地址，但是，當(dāng)在函數(shù)內(nèi)創(chuàng)建了一個新的對象，并賦值給obj（賦值的是新對象的地址）。這個時候，obj指向的就不在是全局對象person，而是指向了新對象的地址，所以給obj添加屬性name時，全局對象person的屬性不會被改變。

對于上面的例子中的obj，也可以這樣說，一旦obj的值發(fā)生了變化，那么它就不再指向person在內(nèi)存中的地址了。

當(dāng)一個函數(shù)包含超過三個形參時，要記住調(diào)用函數(shù)中實參的正確順序是件讓人頭疼的事。不過，我們可以通過名/值對的形式傳入?yún)?shù)，這樣就不需要管參數(shù)的順序了。

function f(params){ 
  console.log(params.name);
}
f({name:"a"})

在JavaScript中，我們可以將函數(shù)賦值給變量。

function f(){} 
var a=f;

作用域（scope）指的是變量存在的范圍。

Javascript只有兩種作用域：一種是全局作用域，變量在整個程序中一直存在，所有地方都可以讀??；另一種是函數(shù)作用域，變量只在函數(shù)內(nèi)部存在。 在函數(shù)外部聲明的變量就是全局變量（global variable），它可以在函數(shù)內(nèi)部讀取。

var a=1;
function f(){
 console.log(a)
}
f()  //1

上面的代碼中，函數(shù)f內(nèi)部可以讀取全局變量a。

在函數(shù)內(nèi)部定義的變量，外部無法讀取，稱為“局部變量”（local variable）。

function f(){
  var a=1;
}
v  //ReferenceError: v is not defined

上面代碼中，變量v在函數(shù)內(nèi)部定義，所以是一個局部變量，函數(shù)之外就無法讀取。

函數(shù)內(nèi)部定義的變量，會在該作用域內(nèi)覆蓋同名全局變量。

var a=1;
function f(){
  var a=2;
  console.log(a);
}
f()  //2
a  //1

注意：對于var命令來說，局部變量只能在函數(shù)內(nèi)部聲明，在其他區(qū)塊中聲明，一律都是全局變量。

函數(shù)的執(zhí)行依賴于變量作用域，這個作用域是在函數(shù)定義時決定的，而不是函數(shù)調(diào)用時決定的。

與全局作用域一樣，函數(shù)作用域內(nèi)部也會產(chǎn)生“變量提升”現(xiàn)象。

var命令聲明的變量，不管在什么位置，變量聲明都會被提升到函數(shù)體的頭部。

function f(x){
  if(x>10){
    var a = x -1;
  }
}

//等同于

function f(x){
  var a;
  if(x>10){
    a = x - 1;
  }
}

ECMAScript函數(shù)沒有重載的定義。

重載是指為一個函數(shù)編寫兩個定義，只要這兩個定義的簽名（接受的參數(shù)的類型和數(shù)量）不同即可。

對于ECMAScript函數(shù)，如果定義了兩個同名的，后定義的函數(shù)會覆蓋先定義的函數(shù)。

13.1 函數(shù)的屬性、方法

（1）name屬性

name屬性返回緊跟在function關(guān)鍵字之后的那個函數(shù)名。

function f(){}
f.name   //f

（2）length屬性

函數(shù)的length屬性是只讀屬性，代表函數(shù)形參的數(shù)量，也就是在函數(shù)定義時給出的形參個數(shù)。

function f(x,y){}
f.length  //2

（3）prototype屬性

每一個函數(shù)都包含一個prototype屬性，這個屬性指向一個對象的引用，這個對象稱做“原型對象”（prototype object）。

（4）call()

語法：

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

定義：調(diào)用一個對象的一個方法，以另一個對象替換當(dāng)前對象。
說明： call 方法可以用來代替另一個對象調(diào)用一個方法。call 方法可將一個函數(shù)的對象上下文從初始的上下文改變?yōu)橛?thisObj 指定的新對象。

（5）apply()

語法：

apply([thisObj[,argArray]]) 

定義：應(yīng)用某一對象的一個方法，用另一個對象替換當(dāng)前對象。
說明： 如果 argArray 不是一個有效的數(shù)組或者不是 arguments 對象，那么將導(dǎo)致一個 TypeError。 如果沒有提供 argArray 和 thisObj 任何一個參數(shù)，那么 Global 對象將被用作 thisObj， 并且無法被傳遞任何參數(shù)。 bind()方法 bind()方法是在ECMAScript 5中新增的方法。 toString()方法
函數(shù)的toString方法返回函數(shù)的源碼。

function f(){
  return 1;
}
f.toString()  
//function f(){
//  return 1;
//}

bind()方法會創(chuàng)建一個新函數(shù)，稱為綁定函數(shù)，當(dāng)調(diào)用這個綁定函數(shù)時，綁定函數(shù)會以創(chuàng)建它時傳入 bind()方法的第一個參數(shù)作為 this，傳入 bind() 方法的第二個以及以后的參數(shù)加上綁定函數(shù)運行時本身的參數(shù)按照順序作為原函數(shù)的參數(shù)來調(diào)用原函數(shù)。

var bar=function(){   
  console.log(this.x);   
}
var foo={ 
     x:3   
}   
bar();  
bar.bind(foo)();
 /*或*/
var func=bar.bind(foo);   
func();

輸出：
undefined
3

注意：bind()返回的是函數(shù)。

構(gòu)造函數(shù)和普通函數(shù)的定義并沒有太大區(qū)別，不過我們使用new關(guān)鍵字來生成構(gòu)造函數(shù)的實例對象。

function Test(){}
var t = new Test();

對于構(gòu)造函數(shù)，一般首字母大寫，便于和普通函數(shù)區(qū)別開來。

定義每個函數(shù)都會主動獲取一個prototype屬性，該屬性擁有一個對象--該函數(shù)的原型，該原型有一個constructor屬性，指向其當(dāng)前所屬的函數(shù)。

JavaScript的函數(shù)可以嵌套在其他函數(shù)中定義，這樣它們就可以訪問它們被定義時所處的作用域中的任何變量，這就是JavaScript的閉包。

閉包會保存函數(shù)作用域中的狀態(tài)，即使這個函數(shù)已經(jīng)執(zhí)行完畢。

閉包的最大用處有兩個，一個是可以讀取函數(shù)內(nèi)部的變量，另一個就是讓這些變量始終保持在內(nèi)存中，即閉包可以使得它誕生環(huán)境一直存在。

閉包的創(chuàng)建依賴于函數(shù)。

function f(a){   
  return function(){   
    return a++;   
  };   
}   
var c=f(1);   
console.log(c());    //1
console.log(c());   //2
console.log(c());  //3

閉包的另一個用處，是封裝對象的私有屬性和私有方法。

在Javascript中，一對圓括號()是一種運算符，跟在函數(shù)名之后，表示調(diào)用該函數(shù)。

(function(){  
  statement
}())

上面的函數(shù)會立即調(diào)用。

注意：上面代碼的圓括號的用法，function之前的左圓括號是必需的，因為如果不寫這個左圓括號，JavaScript解釋器會試圖將關(guān)鍵字function解析為函數(shù)聲明語句。而使用圓括號，JavaScript解釋器才會正確地將其解析為函數(shù)定義表達(dá)式。

當(dāng)然，下面的方法也會以表達(dá)式來處理函數(shù)定義的方法。

!function(){}();
~function(){}();
-function(){}();
+function(){}();

通常情況下，只對匿名函數(shù)使用這種“立即執(zhí)行的函數(shù)表達(dá)式”。它的目的有兩個：

一是不必為函數(shù)命名，避免了污染全局變量；

二是IIFE內(nèi)部形成了一個多帶帶的作用域，可以封裝一些外部無法讀取的私有變量。

eval命令的作用是，將字符串當(dāng)作語句執(zhí)行。

eval("var a=1");
a  //1

eval沒有自己的作用域，都在當(dāng)前作用域內(nèi)執(zhí)行

JavaScript規(guī)定，如果使用嚴(yán)格模式，eval內(nèi)部聲明的變量，不會影響到外部作用域。

(function(){

  "use strict";

  eval("var a=1");

  console.log(a);  //ReferenceError: a is not defined

})();

不能把函數(shù)命名為eval或arguments

不能把參數(shù)命名為eval或arguments

不能出現(xiàn)兩個命名參數(shù)同名的情況

如果出現(xiàn)上面三種情況，都會導(dǎo)致語法錯誤，代碼無法執(zhí)行。