摘要：類型與函數函數是這樣一段代碼它只定義一次但可能被執行或調用多次類型是提供的引用類型之一通過類型創建對象在中函數也是以對象的形式存在的每個函數都是一個對象函數名本質就是一個變量名是指向某個對象的引用函數聲明方式字面量方式判斷函數是否為類型的中

函數是這樣一段JavaScript代碼 它只定義一次 但可能被執行或調用多次
Function類型是JavaScript提供的引用類型之一 通過Function類型創建Function對象
在JavaScript中 函數也是以對象的形式存在的 每個函數都是一個Function對象
函數名 本質就是一個變量名 是指向某個Function對象的引用

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

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

Object與Function

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

代碼的執行流程

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

Function的apply()方法

Function的apply()方法用于調用一個函數 并且接受指定的this值 以及一個數組作為參數

// 定義函數
function fun(value){
    console.log("this is " + value);
}
// 函數的調用方式
fun("function");// 語法結構：函數名稱()
/*
    apply(thisArg,argArray)方法 -> 用于調用一個指定函數
    * 參數
      * thisArg - this
      * argArray - 數組，作為參數(實參)的列表
  */
fun.apply(null, ["function"]);

Function的call()方法

Function的call()方法用于調用一個函數 并且接受指定的this值作為參數 以及參數列表

//定義函數
function fun(value value2){
    console.log("this is" + value);
}
//函數的調用方式
fun("function","張三");//語法結構:函數名稱()

fun.apply(null,["function","張三"]);
//call()方法 - 用于調用一個函數
fun.call(null,"function","張三");

Function的bind()方法

Function的bind()方法用于創建一個新的函數(稱為綁定函數) 并且接受指定的this值作為參數 以及參數列表

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

fun("李四");// this is 李四

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

重載是什么

在其他開發語言中 函數具有一種特性 叫做重載 重載就是定義多個同名的函數 但每一個函數接受的參數的個數不同 程序會根據用時傳遞的實參個數進行判斷 具體調用的是哪個函數
但是在JaveScript中 函數是沒有重載現象的 也就是說 如果同時定義多個同名的函數 只有最后一個定義的函數是有效的

/*
    重載的含義
    1.定義多個同名的函數，但具有數量不同的參數
    2.調用函數，根據傳遞參數的個數調用指定的函數
 */
function add(a,b){
    return a + b;
}
function add(a,b,c){
    return a + b + c;
}
function add(a,b,c,d){
    return a + b + c + d;
}

add(1,2);// 3
add(1,2,3);// 6
add(1,2,3,4);// 10

// JavaScript的函數不存在重載 -> 當函數同名時，最后一次定義的函數有效
console.log(add(1,2));// NaN
console.log(add(1,2,3));// NaN
console.log(add(1,2,3,4));// 10

arguments對象

JavaScript提供了arguments對象 該對象可以模擬函數重載的現象 arguments對象是函數內部的本地變量 arguments已經不再是函數的屬性了
arguments對象可以獲取函數的所有參數 但arguments對象并不是一個數組 而是一個類數組對象(沒有數組特有的方法)

/*
    JavaScript提供arguments對象
    * 該對象存儲當前函數中所有的參數(實參) - 類數組對象
    * 場景 - 該對象一般用于函數中
    * 作用 - 用于獲取當前函數的所有參數
    * 屬性
    * length - 函數所有參數(實參)的個數
    * 用法 - 模擬實現函數的重載
 */
function add(){
    var num = arguments.length;
    switch (num) {
        case 2:
            return arguments[0] + arguments[1];
            break;
        case 3:
            return arguments[0] + arguments[1] + arguments[2];
            break;
        case 4:
            return arguments[0] + arguments[1] + arguments[2] + arguments[3];
            break;
    }
}
console.log(add(1,2));// 3
console.log(add(1,2,3));// 6
console.log(add(1,2,3,4));// 10

函數的遞歸

調用自身的函數被稱之為遞歸函數 在某種意義上說 遞歸近似于循環 兩者都有重復執行相同的代碼 并且兩者都需要一個終止條件以避免無限循環或者無限遞歸

/* 函數的遞歸 -> 就是在指定函數的函數體中調用自身函數
function fun(){
    // 當前函數的邏輯內容
    console.log("this is function");
    // 調用自身函數 -> 實現遞歸
    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可以將函數作為數據使用 作為函數本體 它像普通的數據一樣 不一定要有名字 默認名字的函數被稱之為匿名函數

function(a){return a;}
/*
    匿名函數的作用：
    1.將匿名函數作為參數傳遞給其他函數 - 回調函數
    2.將匿名函數用于執行一次性任務 - 自調函數
 */

回調函數

當一個函數作為參數傳遞給另一個函數時 作為參數的函數被稱之為回調函數

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

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

console.log(result);// 1

回調函數的優點:
1.它可以在不做命名的的情況下傳遞函數(這意味著可以節省全局變量)
2.可以將一個函數調用操作委托給另一個函數(這意味著可以節省一些代碼編寫工作)
3.回調函數也有助于提升性能

回調函數的參數

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

function fn(v){// 形參是一個函數
    return v(100);// 函數的調用體
}

// var result = fn(one);// 實參必須是一個函數

var result = fn(function(w){return w;});

console.log(result);

自調函數

自調函數就是定義函數后自行調用

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

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

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

作為值的函數

將一個函數作為另一個函數的結果進行返回 作為結果返回的函數稱之為值的函數

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

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

console.log(fun()());

作用域鏈

很多開發語言中都具有塊級作用域 但ECMAScript5版本中并沒有跨級作用域 這經常會導致理解上的困惑
雖然ECMAScript5版本沒有塊級作用域 但具有函數作用域 在某個函數內部定義的便利的作用域就是該函數作用域
每一段JavaScript代碼(全局代碼或函數)都有一個與之關聯的作用域鏈

var a = 10;// 全局變量
function fun(){
    var b = 100;// fun函數作用域的局部變量
    // 內部函數
    function fn(){
        var c = 200;// fn函數作用域的局部變量
        // 內部函數
        function f(){
            var d = 300;// f函數作用域的布局變量
            // 調用變量
            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允許函數嵌套 并且內部函數可以訪問定義在外部函數中的所有變量和函數 以及外部函數能訪問的所有變量和函數 但是 外部函數卻不能夠訪問定義在內部函數中的變量和函數
當內部函數以某一種方式被任何一個外部函數作用域訪問時 一個閉包距產生了
閉包就是詞法表示包括不必計算的變量的函數 也就是說 該函數能使用函數外定義的變量

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

n();// 100

閉包的特點與作用

閉包的特點:
1.局部變量:在函數中定義有共享意義(如 緩存 計數器等)的局部變量(注:定義全局變量會對外造成污染)
2.內部函數:在函數(f)中聲明有內嵌函數 內嵌函數(g)對函數(f)長得局部變量進行訪問
3.外部使用:函數(f)向外返回此內嵌函數(g) 外部可以通過此內嵌函數持有并訪問聲明在函數(f)中的變量 而此變量在外部是通過其他途徑無法訪問的
閉包的作用:
1.提供可共享的局部變量
2.保護共享的局部變量 提供專門的讀寫變量的函數
3.避免全局污染