摘要：當函數(shù)是聲明語句的一部分是，他就是函數(shù)表達式。當執(zhí)行流到達函數(shù)表達式被創(chuàng)建，結果是，函數(shù)表達式只有他們被執(zhí)行后才能使用。這樣的函數(shù)叫匿名函數(shù)。總體來說，推薦使用函數(shù)聲明，除非有原因需要使用函數(shù)表達式。

函數(shù)和變量一樣，可以在代碼的任何地方定義。
JavaScript提供一些方式去定義方法：

函數(shù)聲明

函數(shù)表達式

函數(shù)作為另一個函數(shù)結果被調用

基本創(chuàng)建函數(shù)的語法是函數(shù)聲明。語法如下：

function f(arg1, arg2, ...) {
   ... code ...
}

比如：

function sayHi(name) {
  alert("Hi, "+name)
}

sayHi("John")

這個例子聲明一個只有一個參數(shù)的函數(shù)sayHi，運行sayHi。

用return聲明來返回值

function sum(a, b) {
  return a+b
}

var result = sum(2,5)
alert(result)

如果函數(shù)沒有返回值，結果被認為是一個特殊值“undefined”。如下例：

function getNothing() {
  // no return 
}

var result = getNothing()

alert(result)

返回空值也是一樣結果：

function getNothing() {
  return 
}
alert( getNothing() === undefined ) // true

函數(shù)內可以包含變量，用var來定義。這種變量叫做局部變量，只能被內部函數(shù)訪問。

function sum(a, b) {
  var sum = a + b

  return sum
}

創(chuàng)建一個函數(shù)min(a,b)，接收兩個數(shù)字，返回一個較小的值。
min(2, 5) == 2
min(3, -1) == -1

答案
方案一 用if判斷:

function min(a, b) {
  if (a < b) {
    return a
  } else {
    return b
  }
}

方案二 用三目運算符:

function min(a, b) {
  return a < b ? a : b  //  如果是true運行a，否則運行b
}

寫一個函數(shù)pow(x,n)返回x的n次方，或者說，x被自己乘了n次。
pow(3, 2) = 3*3 = 9
pow(3, 3) = 333 = 27
pow(1, 100) = 11...*1 = 1

function(x,n){
    var result
    for(var i = 0;i

函數(shù)聲明
函數(shù)聲明在預執(zhí)行階段（當瀏覽器準備執(zhí)行代碼）解析。所以函數(shù)聲明在前后都能被調用到。
function sayHi(name) {
  alert("Hi, "+name)
}

sayHi("John")
sayHi("John")

function sayHi(name) {
  alert("Hi, "+name)
}
所以函數(shù)在任何位置都可以聲明
比如，我們可能希望根據(jù)條件聲明不同的函數(shù)
sayHi()

if (1) {
  function sayHi() {  alert(1)  }
} else {
  function sayHi() {  alert(2)  } // <--
}
嘗試在不同瀏覽器中運行這個例子。火狐會報錯，其他瀏覽器輸出2。
那是因為聲明在執(zhí)行前被傳遞了。根據(jù)文檔(p.10.5)，后同名的函數(shù)，后
聲明的會覆蓋存在的函數(shù)。
當執(zhí)行時，其他聲明會被忽略，所以if語句沒有任何效果。

函數(shù)表達式
JavaScript中函數(shù)是一等公民，和數(shù)字字符一樣。
在任何你可以寫值的地方，你都可以寫函數(shù)。函數(shù)表達式的語法
function(arguments) { ... }
舉例，你可以寫
var f = 5
但你也可以賦函數(shù)表達式
var f = function(name) {
    alert("Hi, " + name + "!");
}
什么時候函數(shù)是表達式，什么時候是聲明呢？
規(guī)則很簡單。
但javascript解析器在主代碼流中，他會認為這是函數(shù)聲明。
當函數(shù)是聲明語句的一部分是，他就是函數(shù)表達式。
當執(zhí)行流到達函數(shù)表達式被創(chuàng)建，結果是，函數(shù)表達式只有他們被執(zhí)行后才能使用。
var sayHi

// sayHi() <-- 這里不能執(zhí)行，還沒有sayHi函數(shù)

if (1) {
  sayHi = function() {  alert(1)  }
} else {
  sayHi = function() {  alert(2)  }
}

sayHi()
上述代碼所有瀏覽器執(zhí)行結果相同。
請用聲明
經(jīng)驗不足的開發(fā)人員寫的代碼中，方法經(jīng)常用表達式來聲明：
var f = function() { ... }
函數(shù)聲明更加可讀簡潔，還是用函數(shù)聲明吧。
function f() { ... }
除此以外，函數(shù)聲明可在定義前調用。
只有你在執(zhí)意要用函數(shù)表達式時采用。如例子中，條件性的函數(shù)定義。
函數(shù)是值
javascript中的函數(shù)是一般值，我們可以輸出他。
function f() { alert(1) }

alert(f)
上面這個輸出函數(shù)的例子。通常用作源代碼。( Usually as the source code.)
Both declarations and expression declare a variable and put the function into it. Only the creation time is different.
聲明和表達式都可以作為變量的值。只是創(chuàng)建的時間不同。
傳遞函數(shù)
函數(shù)和任何值一樣可以被賦值，做為其他函數(shù)的參數(shù)傳遞等。
如下例，怎么定義函數(shù)沒有關系。
function sayHi(name) {
  alert("Hi, "+name)
}

var hi = sayHi // 把函數(shù)賦值給變量

hi("dude")     // 執(zhí)行函數(shù)
函數(shù)通過引用被賦值。函數(shù)保存在內存的某處，sayHi是它的引用（指向）。當我把函數(shù)賦值給hi，變量開始引用同一個函數(shù)。
一個函數(shù)可以接受另一個函數(shù)做為參數(shù)
function runWithOne(f) {  // 運行做為參數(shù)1的函數(shù)
  f(1)
}

runWithOne( 
  function(a){ alert(a) } 
)
邏輯上說，函數(shù)是一個動作.那么，傳遞函數(shù)是傳遞一個動作，能夠在程序另一部分來初始化。這種特性在javascript中被廣泛使用。
在上面的例子中，我們創(chuàng)建一個沒有名字的函數(shù)，沒有賦值給任何變量。這樣的函數(shù)叫匿名函數(shù)。
就地執(zhí)行
可以用函數(shù)表達式創(chuàng)建并立即運行函數(shù)，像這樣：
(function() {
  var a, b    // 局部變量
  // ...      // 其他代碼
})()
立即執(zhí)行函數(shù)大多被用在我們想做一些圍繞局部變量的事情。我們不想我們的局部變量變成全局，所以包含在函數(shù)里面。
在執(zhí)行后，全局命名空間還是很干凈，很好的實踐。
那為什么函數(shù)在括號中？是因為javascript只允許函數(shù)表達式立即執(zhí)行。
函數(shù)聲明不能被這樣用：
function work() {
  // ...
}()  //  語法錯誤
即使我們去掉名稱，javaScript會看到關鍵詞函數(shù)，嘗試轉換成函數(shù)聲明。
function() { // 錯誤，沒有名稱的函數(shù)聲明。
  // ...
}()
那么。唯一的方式是把函數(shù)用括號包起來。就會打斷他被認為是聲明的一部分，所以是函數(shù)表達式。
如果函數(shù)是一個明顯的表達式，那就沒必要包起來，如下：
var result = function(a,b) { return a+b }(2,2)
alert(result) // 4
在上面的代碼中，函數(shù)被創(chuàng)建且立即調用。
就像var result = sum(2,2)，用sum函數(shù)替換函數(shù)表達式。
下面的代碼執(zhí)行結果是什么？為什么？
var a = 5

(function() {
  alert(a)
})()
答案：
答案是error，嘗試下面代碼：
var a = 5
(function() {
  alert(a)
})()
在var a = 5后面沒有分號。JavaScript把代碼認為是：
var a = 5(function() {
  alert(a)
})()
那么，他會嘗試運行5做為一個函數(shù)，這就會造成錯誤。能運行的代碼如下：
var a = 5;
(function() {
  alert(a)
})()
這可能JavaScript中是最危險隱蔽的不寫分號。
還有一種方式直接調用函數(shù)構造器。把參數(shù)列表和函數(shù)作為字符串，用他們創(chuàng)建函數(shù)。
var sayHi = new Function("name", " alert("Hi, "+name) ");

sayHi("Benedict");
這種方式用的很少很少，幾乎不用。
命名函數(shù)表達式
一個函數(shù)表達式可有名字：
var f = function sayHi(name) {
  alert("Hi, "+name)
}
語法叫命名函數(shù)表達式（NFE）在任何瀏覽器都可用除了IE9以下。
在那些支持的瀏覽器中，名字只在函數(shù)內可見
var f = function sayHi(name) {
  alert(sayHi) // 輸出函數(shù)
}

alert(sayHi) // 錯誤：為定義的變量"sayHi"
在這種情況IE會創(chuàng)建兩個函數(shù)對象：sayHi和f：
var f = function g() {  }
//
IE中是false，其他瀏覽器報錯（g為定義）
alert(f=== g)
NEFS存在是為了遞歸匿名函數(shù)。
觀察下面代碼片段被包在serTimeout中調用：
setTimeout(function factorial(n) {
  return n == 1 ? n : n*factorial(n-1)
}, 100)
代碼的結果是什么？為什么？
( function g() { return 1 } )
 
alert(g)
答案：
結果是error：
( function g() { return 1 } )

alert(g)
解決方案的關鍵是理解(function ... )是一個函數(shù)表達式（參考本章），不是函數(shù)聲明。
那么，我們有一個有名函數(shù)表達式。
有名函數(shù)表達式的名字只在內部可見。
除了IE9.0以下，所有瀏覽器都支持NFEs，那么他們會給出錯誤“undefined variable”，因為g只有在函數(shù)內部可見。
ie9.0以下不支持NFE，就會輸出函數(shù)
函數(shù)命名
函數(shù)是一個動作。所以命名應該是動詞，像get,read,caculateSum,等等。
短函數(shù)名稱的規(guī)則：

一個函數(shù)是臨時的且只使用在附近的代碼。變量的短命名可用這個邏輯。

一個函數(shù)用在代碼任何地方。一方米昂，沒有忘記他的危險，另一方面，你可以寫的更少。


真實的例子‘$’, ‘$$’, ‘$A’, ‘$F’ 等。
JavaScript庫中頻繁調用的函數(shù)用這些短名稱。
其他情況，函數(shù)的名字應該是一個動詞，或者一個動詞開頭的多個詞疊加。
總結
JavaScript中函數(shù)是普通值。他們可以按需求被賦值，傳遞，調用。

一個不返回值的函數(shù)事實上會返回一個特殊值：undefined。

使用動詞命名函數(shù)。短命名允許被用在兩種情況：被用在附近代碼塊，或被非常廣泛使用。


總體來說，推薦使用函數(shù)聲明，除非有原因需要使用函數(shù)表達式。