這篇筆記把 JavaScript 中 Function 函式的各種知識點做了一次系統整理。函式簡直就是一大物件,各種概念都能牽扯進來,不僅僅是 Function 這個原生引用型別本身的用法,還牽涉到執行環境、作用域、閉包、上下文、私有變數等更深入的知識點。
函式中的 return
function n(){ (function(){ return 5; })(); } n();// undefined //立即執行匿名函數中的return語句其實是返回給它所在的匿名函數的。 function n(){ var num= (function(){ return 5; })(); console.log(num); }
Function 型別
函式本質上是物件,每個函式其實都是 Function 型別的實例。而且與其他引用型別一樣,函式也具備屬性和方法。函式名實際上是一個指向記憶體堆中某個函式物件的指標。
定義函式的方式有三種:
function sum(num1,num2){ return num1+num2; }
var sum=function(num1,num2){ return num1+num2; };
定義了一個變數 sum 並將它初始化為一個函式。要留意的是 function 關鍵字後面並沒有函式名,因為使用函式表達式時沒必要寫函式名,透過變數 sum 即可引用函式。另外函式結尾有個分號,就像宣告其他變數一樣。var sum=new Function('num1','num2','return num1+num2;'); sum;// function anonymous(num1,num2 /**/) { return num1+num2; }
理解參數
ECMAScript 中所有參數傳遞的都是值(即使傳遞引用,傳的也是位址值,並非引用傳遞)。ECMAScript 函式不介意傳進來多少個參數,也不在乎傳進來的參數是什麼型別。之所以如此,是因為 ECMAScript 中的參數在內部是用一個陣列表示的。函式接收到的永遠是這個陣列,而不關心裡面包含哪些參數。在函式體內,可以透過 arguments 物件來訪問這個陣列,從而取得傳遞給函式的每個參數。
function func(){ console.log(Object.prototype.toString.call(arguments)); } func();// [object Arguments]
function doAdd(num1,num2){ console.log(arguments.length); console.log(num2) arguments[1]=10; console.log(num2); } doAdd(5,0);//2 0 10 doAdd(5);//1 undefiend undefined
沒有重載
ECMAScript 函式無法像傳統意義那樣實現重載。在其他語言(如 Java)中,可以為一個函式編寫兩個定義,只要這兩個定義的簽名(接收參數的型別和數量)不同即可。ECMAScript 無法重載的原因有兩點:
function reload(){ if(arguments.length==0){ console.log('沒傳參'); }else if(arguments.legth==1){ console.log('傳了一個參數'); } }
function add(){ return 100; } function add(num){ return num+200; } //實際上和下面代碼沒什麼區別 function add(){ return 100; } add=function(num){ return num+200; }
函式聲明和函式表達式
實際上,解析器在向執行環境中載入資料時,對函式聲明和函式表達式並非一視同仁。對於解釋型語言來說,編譯步驟大致為:
解析器會先讀取函式聲明,並讓它在任何程式碼執行之前就能用。至於函式表達式,則必須等到執行階段才會被真正賦值。這什麼意思呢?雖然兩者都進行了變數提升,待真正執行時會從語法樹中把聲明取出並加入執行環境,但一個是函式提升,一個是變數提升。
//函數聲明 console.log(func);//function func(){} function func(){ } //函數表達式 console.log(func1);// undefined var func1=function(){}; console.log(func1);// function(){}
作為值的函式
因為 ECMAScript 中的函式名本身就是變數,所以函式也可以作為值來使用。不僅可以像傳遞參數那樣把一個函式傳給另一個函式,還可以將一個函式作為另一個函式的結果返回。
function callSomeFunction(someFunction,someArgument){ return someFunction(someArgument); } function concated(str){ return "Hi "+str; } callSomeFunction(concated,'xx');// 'Hi xx'
從一個函式中返回另一個函式的應用:假設有一個物件陣列,想根據某個物件屬性對陣列排序,但傳給 sort() 方法的比較函式要接收兩個參數,即要比較的值。我們需要一種方式來指明「按照哪個屬性來排序」。這時可以定義一個函式,它接收一個屬性名,然後據此創建一個比較函式。預設情況下,sort 函式會呼叫每個物件的 toString() 方法來確定它們的次序。
function createCompare(property){ return function(obj1,obj2){ var value1=obj1[property], value2=obj2[property]; if(value1<value2) return -1; else if(value1>value2) return 1; else return 0; } }
var data=[{name:'aa',age:20},{name:'bb',age:12},{name:'cc',age:30}]; data.sort(createCompare("age"));// [{name:'bb',age:12},{name:'aa',age:20},{name:'bb',age:30}]
函式的內部屬性
arguments:類陣列物件,包含傳入函式的所有參數。它是每個函式自身的屬性,之所以能直接訪問 arguments,是為了加強 JavaScript 語言的安全性,這樣第三方程式碼就不能在相同的環境下窺視其他程式碼了。
//一般階乘函數 function factorial(num){ if(num<=1){ return 1;} else { return num*factorial(num-1); } }
定義階乘函式用到了遞歸演算法,這樣定義沒問題,缺點是這個函式的執行與函式名 factorial 緊緊耦合在一起,萬一出現改變函式指向的情況就不太好了,例如:
factorial=function(){} factorial(3);// undefiend
為了消除這種現象,可以改用 arguments.callee:
function factorial(num){ if(num<=1){ return 1; } else{ return num*arguments.callee(num-1); } }
這樣無論引用函式時用的是什麼名字,都能保證完成遞歸。
function a(){ return Object.getOwnPropertyNames(arguments); } a();// ["length", "callee"]
this:行為與 Java/C# 中的 this 大致類似,它引用的是函數據以執行的環境物件(當在網頁的全域作用域中呼叫函式時,this 物件引用的就是 window)。
caller:不僅是 ECMAScript5 新增的函式物件上的屬性,也是 arguments 上的屬性,保存著呼叫當前函式的函式的引用。如果是在全域作用域中呼叫當前函式,它的值為 null。
Object.getOwnPropertyNames(Function);// ["length", "name", "arguments", "caller", "prototype"]
function outer(){ inner(); } function inner(){ console.log(inner.caller); //為了實現更松散的耦合,arguments.callee.caller } outer();// function outer(){ inner()}
嚴格模式下不能為函式的 caller 屬性賦值,否則會導致出錯。
函式的屬性和方法
function sayName(name){ // } function sum(num1,num2){ // } function sayHi(){ // } sayName.length;// 1 sum.length;// 2 sayHi.length;// 0
function sum(num1,num2){ return num1+num2; } function callSum1(num1,num2){ return sum.apply(this,arguments);//sum.apply(this,[num1,num2]) } callSum1(10,30);// 40
嚴格模式下,未指定環境物件而呼叫函式時,this 值不會轉型為 window,除非明確把函式添加到某個物件或者呼叫 apply/call,否則 this 值將是 undefined。
function callSum1(num1,num2){ retrun sum.call(this,num1,num2); } callSum1(10,30);// 40
call 和 apply 真正強大的地方在於能夠擴充函式賴以執行的作用域,改變函式的執行環境。
window.color="red"; var o={color:'blue'}; function sayColor(){ console.log(this.color); } var newobj=sayColor.bind(o); newobj;// function sayColor(){ console.log(this.color); } newobj==sayColor;// false newobj();// blue
深入理解:可以將函式綁定到指定環境的函式,接收一個函式與一個環境,回傳在給定環境中呼叫給定函式的函式。
function bind(func,context){ return function(){ func.apply(context,arguments);//這裡創建了一個閉包,arguments使用的返回的函數的,而不是bind的 } }
當呼叫回傳的函式時,它會在給定環境中執行被傳入的函式並帶上所有參數。
function bind(func,context,args){ return function(){ func.call(context,args); }; }
變數、作用域、記憶體問題
JavaScript 接近詞法作用域,變數的作用域是在定義時決定而非執行時決定,也就是說詞法作用域取決於原始碼。
JavaScript 引擎在執行每個函式實例時,都會為它創建一個執行環境,其中包含一個 AO 變數物件,用來保存內部變數表、內嵌函式表、父級引用列表等語法分析結構(變數提升在語法分析階段就已經完成,並保存在語法樹中,函式實例執行時會把這些資訊複製到 AO 上)。
ECMA-262 定義,JavaScript 松散型別的本質決定了它只在特定時間用於保存特定值的一個名字而已,由於不存在「某變數必須保存何種型別值」的規則,變數的值及其型別可在腳本的生命週期內改變。
function setName(obj){ obj.name="xx"; obj=new Object(); obj.name="bb"; } var p=new Object(); setName(p); p.name;// "xx"
如果是按引用傳遞的,即傳的不是位址值而是堆記憶體中整個 p 物件,那麼在 setName 中為它添加了一個名字叫 obj,又添加 name 屬性後,再將這個 obj 內容重新填充為新物件,那麼之前的那個物件就不存在了,更別提有 "xx" 這個屬性了,但 p.name 仍然訪問到了。這說明即使在函式內部修改了參數值,原始的引用仍保持不變。實際上,當在函式內部重寫 obj 時,這個變數引用的就是一個局部物件了,而這個局部物件會在函式執行完畢後被立即銷毀。
執行環境及作用域
var color = "blue"; function changeColor(){ if(color=="blue"){ color="red"; }else{ color="blue"; } } changeColor(); console.log(color);// red
標識符解析是沿著作用域鏈一級一級搜索標識符的過程。函式 changeColor 的作用域鏈包含兩個物件:它自己的變數物件(其中定義著 arguments 物件)和全域環境的變數物件。能在函式內部訪問到變數 color,就是因為可以在這個作用域鏈中找到它。內部環境可以透過作用域鏈訪問所有外部環境,但外部環境不能訪問內部環境的任何變數和函式。函式參數也被當作變數來對待,因此其訪問規則與執行環境中的其他變數相同。
function buildUrl(){ var qs="?debug=true"; with(location){ var url=href+qs; } return url; }
buildUrl();// "https://i.cnblogs.com/EditPosts.aspx?postid=5280805?debug=true"
with 語句接收的是一個 location 物件,因此其變數物件中就含有 location 物件的所有屬性和方法,且這個變數物件被添加到作用域鏈的最前端。當在 with 語句中引用變數 href(實際引用的是 location.href)時,可以在當前執行環境中找到;當引用變數 qs 時,引用的則是下一級執行環境中的變數。由於 JavaScript 中沒有塊級作用域,所以在函式內部可以訪問 url 才能 return 成功,這說明 url 並沒有被添加到 location 所在的變數物件中。這兩個語句都會在作用域的前端添加一個變數物件。
if(true){ var color="red"; } console.log(color);// red
函式表達式
if(condition){ function sayHi(){ console.log("Hi"); } }else{ function sayHi(){ console.log("Yo"); } }
以上程式碼會在 condition 為 true 時使用 sayHi() 的定義,否則使用另一個定義。實際上這在 ECMAScript 中屬於無效語法,JavaScript 引擎會嘗試修正錯誤,將其轉換為合理的狀態,但問題是不同瀏覽器的修正做法並不一樣,大多數瀏覽器會回傳第二個聲明。這種方式很危險,不應該出現在你的程式碼中。修正方式很簡單,改用函式表達式就沒問題了:
var sayHi; if(condition){ sayHi=function(){ console.log("Hi"); } }else{ sayHi=function(){ console.log("Yo"); } }
遞歸

在嚴格模式下,不能透過腳本訪問 arguments.callee,不過可以使用命名函式表達式來完成相同結果。
var factorial=(function f(num){ if(num<=1){ return 1; }else{ return num*f(num-1); } });
注意要用命名函式表達式,單單把命名函式賦值給 factorial 也可以,但並不能透過 f 這個名字訪問它。

閉包
閉包是指有權訪問另一個函式作用域中變數的函式。創建閉包的常見方式,就是在一個函式內部創建另一個函式。之所以能夠訪問外部作用域的變數,是因為內部函式的作用域鏈中包含外部作用域。當一個函式被呼叫時:
function compare(value1,value2){ if(value1<value2){ return -1; }else if(value1>value2){ return 1; }else{ return 0; } } var result=compare(5,10);
當呼叫 compare() 時,會創建一個包含 arguments、value1、value2 的活動物件,全域執行環境的變數物件(包含 result 和 compare)在 compare() 執行環境的作用域鏈中處於第二位。
後台的每個執行環境都有一個表示變數的物件(變數物件),全域環境的變數物件始終存在,而像 compare() 函式這樣的局部環境的變數物件,則只在函式執行過程中存在。在創建 compare() 函式時,會創建一個預先包含全域物件的作用域鏈,這個作用域鏈被存在 compare 內部的 [[Scope]] 屬性中。當呼叫 compare() 函式時,會為函式創建一個執行環境,然後透過複製函式 [[Scope]] 屬性中的物件構建起執行環境的作用域鏈,此後又有一個活動物件被創建並推入執行環境作用域鏈的最前端。對於這個例子而言,compare 函式的執行環境的作用域鏈包含兩個變數物件:本地活動物件和全域變數物件。顯然,作用域鏈的本質上是一個指向變數物件的指標列表,它只引用但不包含實際的變數物件。
無論什麼時候在函式中訪問一個變數,就會從作用域鏈中搜索具有相應名字的變數。一般來講,當函式執行完後,局部活動物件會被銷毀,記憶體中僅保留全域作用域。但閉包的情況又有所不同:在另一個函式內部定義的函式會將包含函式(外部函式)的活動物件添加到它的作用域鏈裡,當外部函式執行完後,其活動物件不會被銷毀,因為內部函式的作用域鏈仍然在引用這個活動物件。也就是說,只是外部函式它自己的作用域鏈被銷毀了,但活動物件還存在記憶體中,直到內部函式被銷毀後(例如在外部解除了對閉包的引用:func=null;),外部函式的活動物件才會被銷毀。
由於閉包會攜帶包含它的函式的作用域,因此會比其他函式佔用更多記憶體。過多使用閉包可能導致記憶體佔用過多,建議只在絕對必要時再考慮使用。不過像 V8 這樣經過優化的 JavaScript 引擎會嘗試回收被閉包佔用的記憶體。
閉包的缺點:作用域鏈的這種配置機制引出的一個副作用是,閉包只能取得包含函式中任何變數的最後一個值,因為閉包保存的是整個變數物件,而不是某個特殊的變數。
function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=function(){ return i; }; } return result; }
createFunctions()[0]();// 3
createFunctions()[1]();// 3
createFunctions()[2]();// 3
當執行 createFunctions 時,它的活動物件裡有 arguments=[]、result=undefined、i=undefined,執行完後 result=[function(){return i},function(){return i},function(){return i}],i=3。此時執行 result 陣列時,訪問到的 i 總是 3,因為沿著 function(){return i;} 的作用域鏈查找變數,在外層函式的活動物件上找到的 i 總是 3。陣列中每個函式的作用域鏈中都保存著 createFunctions 的活動物件,所以這些函式引用的都是同一個活動物件、同一個變數 i。
解決方案:我們要的是當時執行時的變數 i,那麼當時把這個 i 臨時保存一下就可以了,保存在哪呢?保存在 function(){return i;} 的活動物件中。怎麼保存呢?傳給 arguments 就好了,但只傳進來還不行:
function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=function(i){ return i; }; } return result; } createFunctions()[0]();// undefiend
因為訪問 i 的時候會先從自己所在函式執行環境的活動物件搜索起,找到 i 發現 i=undefined 有值就停止向上搜索了。問題出在 result[i]=function(i){return i;} 這句只是表達式的賦值操作,並沒有給匿名函式傳參,也不是執行匿名函式。所以現在需要透過某種方式去執行函式,把 i 的值當實參傳進去。簡單!在匿名函式外部加一層立即執行的匿名函式即可(這也增加了一層作用域)。
function createFunctions(){ var result=new Array(); for(var i=0;i<3;i++){ result[i]=(function(i){ return function(){ return i; } })(i); } return result; } createFunctins()[0]();// 0
this 物件
this 物件是在執行時基於函式的執行環境綁定的:
由於閉包編寫方式不同,this 的表現也不同:
var name="the window"; var obj={ name:"the obj", getNameFunc:function(){ //console.log(this==obj); return function(){ console.log(this.name); } } } obj.getNameFunc()();// the window
obj.getNameFunc() 回傳了一個新函式,然後在全域環境中執行該函式。為什麼匿名函式沒有取得其包含作用域的 this 物件呢?每個函式在被呼叫時,都會自動獲得兩個特殊的變數:this(創建作用域時獲得)和 arguments(創建活動物件時獲得),內部函式在搜索這兩個變數時,只會搜索到自己的活動物件為止,因此永遠不可能直接訪問外部函式的這兩個變數。不過把外部函式作用域的 this 存在一個閉包能夠訪問到的變數裡,就可以讓閉包訪問該物件了。
下面幾種情況的 this 比較特殊:
var name="the window"; var obj={ name:"the obj", getName:function(){ return this.name; } }; obj.getName();// "the obj" (obj.getName)();// "the obj" (obj.getName=obj.getName)();// "the window"
第一個是直接呼叫,第二個是呼叫後立即執行的表達式,第三個是先執行了一條賦值語句,然後再呼叫返回的結果。賦值語句返回了一個函式,然後在全域環境下呼叫這個函式。

模仿塊級作用域
function outputNumber(count){ for(var i=0;i<count;i++){ console.log(i); } var i;// 只變量提升,到後面執行代碼步驟時候略過此 console.log(i); } outputNumber(3);// 0 1 2 3
JavaScript 不會告訴你是否多次宣告了同一個變數,遇到這種情況,它只會對後續的聲明視而不見(不過它會執行後續聲明中的變數初始化)。
匿名函式可以用來模仿塊級作用域(私有作用域),語法如下:
(function(){ //這裡是塊級作用域 })();
以上程式碼定義並立即呼叫了一個匿名函式,將函式聲明包含在一對圓括號中,表示它實際上是一個函式表達式。要將函式聲明轉化為函式表達式,就得靠這對圓括號。
function outputNumber(count){ (function(){ for(var i=0;i<count;i++){ console.log(i); } })(); console.log(i);// 報錯 } outputNumber(3);// 0 1 2
在 for 循環外邊加了一個私有作用域,在匿名函式中定義的任何變數都會在執行結束時被銷毀。在私有作用域中能訪問變數 count,是因為這個匿名函式是一個閉包,它能訪問包含作用域的所有變數。這種技術經常用在全域作用域中,用來限制向全域作用域中添加過多的變數和函式,同時也能減少閉包佔用記憶體的問題,因為沒有指向匿名函式的引用,只要函式執行完畢,就可以立即銷毀其作用域鏈了。
私有變數
嚴格來講,JavaScript 中沒有私有成員的概念,所有物件屬性都是公有的,不過有私有變數的概念。任何在函式中定義的變數,都可認為是私有變數,因為不能在函式外部訪問這些變數。私有變數包括函式的參數、局部變數、在函式內定義的其他函式。如果在函式內部創建一個閉包,那麼閉包透過自己的作用域也可以訪問這些變數。利用這一點創建用於訪問私有變數的公有方法,把有權訪問私有變數和私有函式的方法叫特權方法(privileged method)。
function MyObject(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } // 特權方法 this.publicMethod=function(){ privateVariable++; return privateFunction(); }; }
new MyObject();
這個模式在建構函式內部定義了所有私有變數和函式,又繼續創建了能夠訪問這些私有成員的特權方法。能在建構函式中定義特權方法,是因為特權方法作為閉包有權訪問在建構函式中定義的所有變數和函式。變數 privateVariable 和方法 privateFunction 只能透過特權方法 publicMethod 訪問。利用私有和特權成員,可以隱藏那些不應該被直接修改的資料。
function Person(name){ this.getName=function(){ return name; }; this.setName=function(value){ name=value; }; } var p1=new Person("aa"); p1.getName();// "aa" var p2=new Person("bb"); p2.getName();// "bb" p1.getName();// "aa"
這個方法定義了兩個特權方法,在 Person 建構函式外部沒有任何辦法直接訪問 name。由於這兩個方法是在建構函式內部定義的,它們作為閉包能透過作用域鏈訪問 name。私有變數 name 在每個 Person 實例都不相同,每次呼叫建構函式都會重新創建這兩個方法,p1.getName 和 p2.getName 是不同的函式,雖然呼叫的是記憶體中同一個 Person 函式。缺點是:在建構函式中定義特權方法要求你必須使用建構函式模式,而建構函式模式的缺點是針對每個實例都會創建同一組新方法。使用靜態私有變數來實現特權方法就可以避免這個問題。
(function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //構造函數 MyObject=function(){}; //公有/特權方法 MyObject.prototype.publicMethod=function(){ privateVariable++; return privateFunction(); }; })();
這個模式創建了個私有作用域,並在其中封裝了一個建構函式和相應方法。公有方法在原型上定義,體現了典型的原型模式。這種模式在定義建構函式時並未使用函式聲明,而是使用函式表達式;也沒有用 var 宣告 MyObject,就是想讓它成為一個全域變數,能夠在私有作用域之外被訪問,但嚴格模式下未經宣告的變數賦值會出錯,可以修改為:
'use strict'; var MyObject; (function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //構造函數 MyObject=function(){}; //公有/特權方法 MyObject.prototype.publicMethod=function(){ privateVariable++; return privateFunction(); }; })();
這種模式與在建構函式中定義特權方法的主要區別就在於:私有變數和函式是由實例共享的,因為只呼叫(初始化)了一次父環境。由於特權方法是在原型上定義的,因此所有實例都使用同一個函式,而這個特權方法作為一個閉包總是保存著對包含作用域的引用。
(function(){ var name=""; Person=function(value){ name=value; }; Person.prototype.getName=function(){ return name; }; Person.prototype.setName=function(value){ name=value; }; })(); var p1=new Person("aa"); p1.getName();// "aa" var p2=new Person("bb"); p2.getName();// "bb" p1.getName();// "bb"
在這種模式下,變數 name 就成了一個靜態的、由所有實例共享的屬性。在一個實例上呼叫 setName() 會影響所有實例。以這種模式創建靜態私有變數會因為使用原型而增進程式碼復用,但每個實例都沒有自己的私有變數。多查找作用域鏈中的一個層次,會在一定程度上影響查找速度,這正是使用閉包和私有變數的一個不足之處。
var singleton=function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //特權/公有方法和屬性 return { publicProperty:true, publicMethod:function(){ privateVariable++; return privateFunction(); } } }();
這個模式使用了一個回傳物件的匿名函式,把一個物件字面量作為函式返回,本質上這個物件字面量定義的是一個單例的公共介面。這種模式在需要對單例進行某些初始化、同時又需要維護其私有變數時非常有用。在 web 應用程式中,經常需要用一個單例來管理應用程式級的資訊,如果必須創建一個物件並以某些資料對它進行初始化,同時還要公開一些能夠訪問這些私有資料的方法,就可以使用模塊模式。
var singleton=function(){ //私有變量和私有函數 var privateVariable=10; function privateFunction(){ return false; } //創建對象 var obj=new CustomType(); //添加特權/公有屬性和方法 obj.publicProperty=true; obj.publicMethod=function(){ privateVariable++; return privateFunction(); } return obj; }();
閉包的作用總結:
參考:《JavaScript 高級程式設計》、深入解讀 JavaScript 面向物件程式設計實踐。