摘要：在中，函數(shù)也是以對象的形式存在的。也可以使用對象作為參數(shù)返回值調用該函數(shù)的返回結果。調用自身的函數(shù)被稱之為遞歸函數(shù)。默認名字的函數(shù)被稱之為匿名函數(shù)。內部函數(shù)在函數(shù)中聲明內嵌函數(shù)，內嵌函數(shù)對函數(shù)中的局部變量進行訪問。

函數(shù)它只定義一次，但可能被執(zhí)行或調用多次 。
Function類型是JavaScript提供的引用類型之一，通過Function類型創(chuàng)建Function對象。
在JavaScript中，函數(shù)也是以對象的形式存在的。每個函數(shù)都是一個Function對象。函數(shù)名，本質就是一個變量名，是指向某個Function對象的引用。

// 1.函數(shù)聲明方式
function fun(){
    console.log("this is function");
}
// 2.字面量方式
var fn = function(){
    console.log("this is function too");
}
// 判斷函數(shù)是否為Function類型的
console.log(fun instanceof Function);// true
console.log(fn instanceof Function);// true
// JavaScript中所有的函數(shù)都是Function類型的對象

/*
    3.創(chuàng)建Function類型的對象 -> 是一個函數(shù)
      var 函數(shù)名 = new Function(參數(shù),函數(shù)體);
      * 由于函數(shù)的參數(shù)和函數(shù)體都是以字符串形式傳遞給Function的
  */
var f = new Function("a","console.log(a)");
f(100);// 以函數(shù)方式進行調用

在JavaScript中，函數(shù)除了可以通過函數(shù)定義語句或字面量表達式兩種方式定義之外，還可以通過Function類型進行定義。（注意：通過Function類型定義函數(shù)的效率遠不如通過函數(shù)定義語句或字面量表達式兩種方式定義。目前，定義函數(shù)具有三種方式，這三種方式之間存在一定的差別。）

// 1.Object與Function都是自身的類型
console.log(Object instanceof Object);// true
console.log(Function instanceof Function);// true
// 2.Object自身是構造函數(shù)，而構造函數(shù)也是函數(shù)，是函數(shù)都是Function類型
console.log(Object instanceof Function);// true
// 3.Function是引用類型，用于創(chuàng)建對象，是對象都是Object類型
console.log(Function instanceof Object);// true

// 變量的聲明提前
console.log(v);// undefined
var v = 100;
// 如果使用函數(shù)聲明方式定義函數(shù)時 -> 函數(shù)的聲明提前
fun();
function fun(){
    console.log("this is function");
}

Function的apply（）方法用于調用一個函數(shù)，并且接受指定的this值，以及一個數(shù)組作為參數(shù)。
語法結構：
1.thisArg參數(shù)：可選項，在func函數(shù)運行時使用this值。
2.argsArray參數(shù):可選項，一個數(shù)組或者類數(shù)組對象，其中你那個的數(shù)組元素將作為多帶帶的參數(shù)傳給func函數(shù)。也可以使用argments對象作為參數(shù)
3.返回值：調用該函數(shù)的返回結果。

// 定義函數(shù)
function fun(value){
    console.log("this is " + value);
}
// 函數(shù)的調用方式
fun("function");// 語法結構：函數(shù)名稱()

    apply(thisArg,argArray)方法 -> 用于調用一個指定函數(shù)
     參數(shù)
       thisArg - this
       argArray - 數(shù)組，作為參數(shù)(實參)的列表
  
fun.apply(null, ["function"]);

Function的call（）方法用于調用一個函數(shù)，并且接收指定的this值作為參數(shù)，以及參數(shù)列表。
語法結構：
1.thisArg參數(shù)：在func函數(shù)運行時使用的this值。
2.arg1，arg2，...參數(shù)：指定的參數(shù)列表。
3.返回值：調用該函數(shù)的返回結果。
apply()與call（）非常相似，不同之處在于提供參數(shù)的方式。

Function的bind（）方法用于創(chuàng)建一個新的函數(shù)（稱之為綁定函數(shù)），并且接收指定的this值作為參數(shù)，以及參數(shù)列表。

// 定義函數(shù)
function fun(value){
    console.log("this is " + value);
}
/*
    bind(thisArg, arg1, arg2, ...)方法
    * 作用 - 用于創(chuàng)建一個新函數(shù)(稱為綁定函數(shù))
    * 參數(shù)
      * thisArg - this
       arg1, arg2, ... - 表示參數(shù)列表
    * 返回值 - 返回新的函數(shù)
 */
// var f = fun.bind();// 相對于從指定函數(shù)復制一份出來
// console.log(f);
// f();

fun("周芷若");// this is 周芷若

var f = fun.bind(null, "張無忌");
f();// this is 張無忌

在其他開發(fā)語言中，函數(shù)具有一種特性，叫做重載。所謂的重載，就是定義多個同名的函數(shù)，但每一個函數(shù)接收的參數(shù)的個數(shù)不同，程序會根據(jù)調用是傳遞的實參個數(shù)進行判斷，具體調用的是哪個函數(shù)。

// 定義函數(shù)
function fun(value){
    console.log("this is " + value);
}

    bind(thisArg, arg1, arg2, ...)方法
     作用 - 用于創(chuàng)建一個新函數(shù)(稱為綁定函數(shù))
     參數(shù)
       thisArg - this
       arg1, arg2, ... - 表示參數(shù)列表
     返回值 - 返回新的函數(shù)
 
 var f = fun.bind();// 相對于從指定函數(shù)復制一份出來
 console.log(f);
 f();

fun("周芷若");// this is 周芷若

var f = fun.bind(null, "張無忌");
f();// this is 張無忌

但在JavaScript中函數(shù)時沒有重載現(xiàn)象的。也就是說，如果同時定義多個同名函數(shù)，只有最后一個定義的函數(shù)時有效的。
不過，JavaScript提供的arguments對象，該對象可以模擬函數(shù)重載的現(xiàn)象。arguments對象是函數(shù)內部的本地變量；arguments已經不再是函數(shù)的屬性了。
arguments對象可以獲取函數(shù)的所有參數(shù)，但arguments對象并不是一個數(shù)組，而是一個類數(shù)組對象（沒有數(shù)組特有的方法）。

在一個函數(shù)體內，如果想調用自身函數(shù)的話，有兩種方式；
1.通過使用自身函數(shù)實現(xiàn)
2.通過使用arguments對象的callee屬性實現(xiàn)。
調用自身的函數(shù)被稱之為遞歸函數(shù)。在某種意義上，遞歸近似于循環(huán)。兩者都重復執(zhí)行相同的代碼，并且兩者都需要一個終止條件以避免無限循環(huán)或者無限遞歸。

/* 函數(shù)的遞歸 -> 就是在指定函數(shù)的函數(shù)體中調用自身函數(shù)
function fun(){
    // 當前函數(shù)的邏輯內容
    console.log("this is function");
    // 調用自身函數(shù) -> 實現(xiàn)遞歸
    fun();
}
fun();
*/

function fn(v){
    console.log(v);
    if (v >= 10) {
        return;
    }
    // fn(v + 1);
    arguments.callee(v + 1);
}
fn(0);//導致出錯

var f = fn;
fn = null;
f(0);
// console.log(f);

JavaScript可以將函數(shù)作為數(shù)據(jù)使用。作為函數(shù)本體，他就像普通的數(shù)據(jù)一樣，不一定要有名字。默認名字的函數(shù)被稱之為匿名函數(shù)。
匿名函數(shù)的兩種用法：
1.可以將匿名函數(shù)作為從參數(shù)傳遞給其他函數(shù)。這樣，接收函數(shù)就能利用所傳遞的函數(shù)來完成某些事請。
2.可以定義某個匿名函數(shù)來執(zhí)行某些一次性任務。

 JavaScript語法中，定義函數(shù)必須定義函數(shù)名稱 -> 匿名函數(shù)
function (){
    console.log("this is function");
}


    匿名函數(shù)的作用：
    1.將匿名函數(shù)作為參數(shù)傳遞給其他函數(shù) -> 回調函數(shù)
    2.將匿名函數(shù)用于執(zhí)行一次性任務 -> 自調函數(shù)
 

當一個函數(shù)作為參數(shù)傳遞給另一個函數(shù)時，作為參數(shù)的函數(shù)被稱之為回調函數(shù)。

// 作為另一個函數(shù)(fn)的參數(shù)的函數(shù)(one) -> 回調函數(shù)
var one = function(){
    return 1;
}

function fn(v){
    return v();
}
// one函數(shù)僅是作為fn函數(shù)的參數(shù)出現(xiàn) -> 并不是調用
// var result = fn(one);
/*
    以上代碼等價于以下代碼
    以下代碼中作為參數(shù)的函數(shù) -> 匿名回調函數(shù)
  */
var result = fn(function(){return 1;});

console.log(result);// 1

所謂自調函數(shù)就是在定義函數(shù)后自行調用。
1.第一對括號的作用，放置的是一個匿名函數(shù)。匿名函數(shù)接受一個參數(shù)
2.第二個對括號的作用，是‘立即調用’。在調用時，向匿名函數(shù)傳遞參數(shù)內內容。
自調函數(shù)只需將匿名函數(shù)的定義放進一對括號中，然后外面在跟一個對括號。

    自調函數(shù) - 定義即調用的函數(shù)
     第一個小括號 - 用于定義函數(shù)
     第二個小括號 - 用于調用函數(shù)
 
// 全局作用域 - 生命周期：JavaScript文件從執(zhí)行到執(zhí)行完畢
(function(value){
    // 函數(shù)作用域 - 生命周期：從函數(shù)調用到調用完畢
    console.log("this is " + value);
})("function");
// 表達式語法
(function(value){
    // 函數(shù)作用域 - 生命周期：從函數(shù)調用到調用完畢
    console.log("this is " + value);
}("function"));

!function(value){
    // 函數(shù)作用域 - 生命周期：從函數(shù)調用到調用完畢
    console.log("this is " + value);
}("function");

+function(value){
    // 函數(shù)作用域 - 生命周期：從函數(shù)調用到調用完畢
    console.log("this is " + value);
}("function");

將一個函數(shù)作為另一個函數(shù)的結果進行返回，作為結果返回的函數(shù)稱之為作為置的函數(shù)。

var one = function(){
    return 100;
}
// 作為值的函數(shù) -> 內部函數(shù)的一種特殊用法
function fun(){
    var v = 100;
    // 內部函數(shù)
    return function(){
        return v;
    };
}

var result = fun();
// console.log(result);// one函數(shù)
// console.log(result());// 100

console.log(fun()());

很多開發(fā)語言中都具有塊級作用域，但ECMAScript5版本中并沒有跨級作用域，這經常會導致理解上的困惑。
雖然ECMAScript5版本沒有塊級作用域，但具有函數(shù)作用域。在某個函數(shù)內部定義的變量的作用域就是該函數(shù)作用域。
每一段JavaScript代碼（全局代碼或函數(shù)）都有一個與之關聯(lián)的作用域。這個作用域鏈是一個對象列表或鏈表，這組最想定義了這段代碼“作用域中”的變量。

var a = 10;// 全局變量
function fun(){
    var b = 100;// fun函數(shù)作用域的局部變量
    // 內部函數(shù)
    function fn(){
        var c = 200;// fn函數(shù)作用域的局部變量
        // 內部函數(shù)
        function f(){
            var d = 300;// f函數(shù)作用域的布局變量
            // 調用變量
            console.log(a);// 10
            console.log(b);// 100
            console.log(c);// 200
            console.log(d);// 300
        }
        f();
        // 調用變量
        // console.log(a);// 10
        // console.log(b);// 100
        // console.log(c);// 200
        // console.log(d);// d is not defined
    }
    fn();
    // 調用變量
    // console.log(a);// 10
    // console.log(b);// 100
    // console.log(c);// c is not defined
    // console.log(d);// d is not defined
}
fun();

JavaScript允許函數(shù)嵌套，并且內部函數(shù)可以訪問定義在外部函數(shù)中的所有變量和函數(shù)，以及外部函數(shù)能訪問的所有變量和函數(shù)。但是，外部函數(shù)卻不能訪問定義在內部函數(shù)中的變量和函數(shù)。
當內部函數(shù)以某種方式唄任何一個外部函數(shù)作用域訪問時，一個閉包就產生了。
閉包就是詞法表示包括不必計算的變量的函數(shù)，也就是說，該函數(shù)能使用函數(shù)外定義的變量。

var n;// 定義變量，但不初始化值
function fun(){// 函數(shù)作用域
    var v = 100;
    // 進行初始化值 -> 一個函數(shù)
    n = function(){
        console.log(v);
    }
    // n();
}
fun();

n();// 100

閉包的特點和作用
特點：
1.局部變量：在函數(shù)中定義有共享意義的局部變量。
2.內部函數(shù)：在函數(shù)（f）中聲明內嵌函數(shù)，內嵌函數(shù)（g）對函數(shù)（f）中的局部變量進行訪問。
3.外部使用：函數(shù)（f）向外返回此內嵌函數(shù)（g），外部可以通過此內嵌函數(shù)持有并訪問聲明在函數(shù)（f）中的局部變量，而此變量在外部是通過其他途徑無法訪問的。
作用
1.提供可共享的局部變量。
2.保護共享的局部變量。提供專門的讀寫變量的函數(shù)。
3.避免全局污染。