問答

1.函數(shù)聲明和函數(shù)表達(dá)式有什么區(qū)別？

在日常的任務(wù)中，JavaScript主要使用下面兩種方式創(chuàng)建函數(shù)：

• 函數(shù)聲明（Function Declaration）：

function funDec(){
        console.log("Function Declaration");
 }

• 函數(shù)表達(dá)式(Funciton Expression):

var funExp= function() {
       console.log("Funciton Expression");
};

主要區(qū)別：
1.函數(shù)聲明必須以關(guān)鍵字function開頭，如不是，則為表達(dá)式。
2.函數(shù)表達(dá)式在語句的結(jié)尾需要加上分號，表示語句結(jié)束，而函數(shù)聲明在結(jié)尾不需要加分號。
3.函數(shù)聲明在JS解析的時候會進(jìn)行函數(shù)提升，即在同一個作用域內(nèi)，不管函數(shù)聲明在哪里創(chuàng)建，它會提升至作用域頂部。
舉例：

funDec();//Function Declaration
function funDec(){
        console.log("Function Declaration");
 }

而函數(shù)表達(dá)式不會被提升，它的表現(xiàn)和變量提升的規(guī)則相同，函數(shù)名(這里是指的是var后面定義的變量名)會聲明前置，但是函數(shù)表達(dá)式的賦值操作還是在原來的位置。
舉例：

console.log(funExp);//undefined
var funExp = function() {
    console.log("Funciton Expression");
};

2.什么是變量的聲明前置？什么是函數(shù)的聲明前置？

• 變量的聲明前置
  JavaScript引擎的工作方式是，先解析代碼，獲取所有被聲明的變量，然后再一行一行的運(yùn)行，這造成的結(jié)果就是，所有被聲明的語句，都會被提升到代碼的頭部，這就是變量提升。需要注意的是，變量提升只是提升變量的聲明，并不會把賦值也提升上來。
  看例子：

console.log(name);
var name = "Hello World";

實際上由于變量提升的機(jī)制，運(yùn)行上面代碼的時候會變成這樣：

var name;
console.log(name);//undefined
name = "Hello World";

• 函數(shù)的聲明前置
  函數(shù)在聲明的時候也會像變量一樣被提升，不同的是，只有使用函數(shù)聲明（Function Declaration）的方式創(chuàng)建的函數(shù)才能提升，而使用函數(shù)表達(dá)式函數(shù)表達(dá)式(Funciton Expression)創(chuàng)建的函數(shù)不會被提升。
  看列子：

foo();
function foo() {
   console.log(name);
   var name ="Hello World"；
}

上面這段代碼實際表現(xiàn)為：

function foo() {
   var name；
   console.log(name);
   name = "Hello World";
}
foo();//undefined

函數(shù)foo()的作用域內(nèi)的變量name提升到了作用域頂部，全局作用域里的foo()的函數(shù)聲明會被提升到所處的作用域頂部，即全局作用域的頂部。

• 函數(shù)聲明會在變量聲明的后面
  同時存在函數(shù)聲明和變量聲明時，函數(shù)聲明的提升會在變量聲明的提升后面，
  看列子：

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

上面的代碼實際表現(xiàn)為：

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

3.arguments 是什么？

arguments是JavaScript里的一個內(nèi)置的類數(shù)組對象，它包含了函數(shù)調(diào)用的所有參數(shù)。這個對象為傳遞給函數(shù)的每個參數(shù)建立一個條目，條目的索引號從0開始，這個對象只有在函數(shù)體內(nèi)部才可以使用,利用arguments可以對參數(shù)重新賦值，例如：

var f = function  (a,b,c) {
    console.log(arguments[0]);
    console.log(arguments[1]);
    console.log(arguments[2]=4);
}
 f(1,2,3)
//1
//2
//4

arguments對象并不是一個真正的數(shù)組，它類似于數(shù)組，但是沒有數(shù)組特有的屬性和方法，除了length。
arguments使用場景：
對于一個參數(shù)數(shù)量是一個可變量的函數(shù)來說比較有用，可以用arguments.length來得到參數(shù)的數(shù)量，然后可以用arguments objects來對每個參數(shù)進(jìn)行處理。

4.函數(shù)的重載怎樣實現(xiàn)

重載是很多面向?qū)ο笳Z言實現(xiàn)多態(tài)的手段之一，在靜態(tài)語言中確定一個函數(shù)的手段是靠方法簽名——函數(shù)名+參數(shù)列表，也就是說相同名字的函數(shù)參數(shù)個數(shù)不同或順序不同都被認(rèn)為是不同的函數(shù)，稱為函數(shù)重載。

在JavaScript中沒有函數(shù)重載的概念，函數(shù)通過名字確定唯一性，參數(shù)不同也被認(rèn)為是相同的函數(shù)，后面的覆蓋前面的。
但是JavaScript卻可以使用自身屬性去模擬函數(shù)重載：

function sum(){
      var sum = 0;
      for (var i=0;i<arguments.length;i++){
      sum = sum +arguments[i];
      }
      return sum;
}
console.log(sum(1,2));//3
console.log(sum(1,2,10));//13

5.立即執(zhí)行函數(shù)表達(dá)式（IIFE）是什么？有什么作用？

在JavaScript中，一對圓括號()是一種運(yùn)算符，跟在函數(shù)名后面，表示調(diào)用該函數(shù)。比如，print()就表示調(diào)用print函數(shù)。
有時，我們需要定義函數(shù)之后，立即調(diào)用該函數(shù)，但是你不能在函數(shù)的定義之后加上圓括號，這會產(chǎn)生語法錯誤。

function(){
/*body*/
}();
//Uncaught SyntaxError: Unexpected token (

原因是function這個關(guān)鍵字即可以當(dāng)作語句，也可以當(dāng)作表達(dá)式。為了避免解析上的歧義，JavaScript引擎規(guī)定，如果function關(guān)鍵字出現(xiàn)在行首，就認(rèn)為這是一個函數(shù)聲明，而不是函數(shù)表達(dá)式，就不應(yīng)該以圓括號結(jié)尾，所以就報錯了。
解決方法就是不要讓function出現(xiàn)在行首，讓引擎將其理解為一個表達(dá)式，最簡單的方法就是將其放在一個圓括號里面，有下面兩種寫法：

(function(){
/*body*/
}());
//或者
(function(){
/*body*/
})();

這樣寫引擎就會認(rèn)為后面是一個表達(dá)式，添加圓括號后會立即執(zhí)行，這就叫做"立即調(diào)用的函數(shù)表達(dá)式(Immediately-Invoked Function Expression)",簡稱IIFE。
IIFE的作用：
通常情況下，只對匿名函數(shù)使用這種“立即執(zhí)行的函數(shù)表達(dá)式”。它的目的有兩個：一是不必為函數(shù)命名，避免了污染了全局變量，而是IIFE內(nèi)部形成了一個單獨的作用域，可以封裝一些外部無法讀取的私有變量。

6.什么是函數(shù)的作用域鏈

函數(shù)的作用域鏈?zhǔn)怯梢幌盗袑ο螅ê瘮?shù)的活動對象+0個到多個的上層函數(shù)的活動對象+最后的全局對象）組成的，在函數(shù)執(zhí)行的時候，會按照先后順序從這些對象的屬性中尋找函數(shù)體中用到的標(biāo)識符的值（標(biāo)識符解析），函數(shù)會在定義時將它們各自所處的環(huán)境(全局上下文或者函數(shù)上下文)的作用域鏈存儲到自身的[scope]內(nèi)部屬性中，在需要使用返回這個屬性。
舉例：

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

function f() {
  var a = 2;
  x();
}

f() // 1

上面代碼中，函數(shù)f()的值來自于另一個函數(shù)x()的值，而函數(shù)x()的值又來自于變量a的賦值。
參考博客：JavaScript 開發(fā)進(jìn)階：理解 JavaScript 作用域和作用域鏈
[譯]JavaScript:函數(shù)的作用域鏈

1.以下代碼輸出什么？

function getInfo(name, age, sex){
         console.log('name:',name);
         console.log('age:', age);
         console.log('sex:', sex);
         console.log(arguments);
         arguments[0] = 'valley';
         console.log('name', name);
 }
getInfo('hunger', 28, '男');
getInfo('hunger', 28);
getInfo( '男');

結(jié)果：

getInfo('hunger', 28, '男');
/*
   name:hunger;
   age:28;
   sex:男；
   ['hunger',28,'男']
   name:valley;
*/
getInfo('hunger',28);
/*
   name:hunger;
   age:28;
   sex:undefined;
   ["hunger", 28]
   name:valley;
*/
getInfo('男')
/* 
   name:男；
   age：undefined；
   sex：undefined；
   ["男"]；
   name：valley;
*/

輸出結(jié)果

2.寫一個函數(shù)，返回參數(shù)的平方和。

function sumOfSquares(){
     var sumOfSquares = 0;
     for (var i = 0; i < arguments.length; i++) {
        sumOfSquares= sumOfSquares+arguments[i]*arguments[i];
     }
     return console.log(sumOfSquares);
   }
   sumOfSquares(2,3,4);   // 29
   sumOfSquares(1,3);   // 10

3.如下代碼的輸出？為什么

console.log(a);//undefined
var a = 1;
console.log(b);//報錯

上面代碼實際運(yùn)行如下：

var a;
console.log(a);//undefined
a=1;
consolo.log(b);//報錯

4.如下代碼的輸出？為什么。

sayName('world');//hello world
    sayAge(10);//報錯
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };

上面代碼實際運(yùn)行如下；

var sayAge;
function sayName(name){
        console.log('hello ', name);
    }
sayName('world');//hello world
sayAge(10);//報錯
sayAge = function(age){
        console.log(age);
}

5.如下代碼的輸出？為什么

function fn(){}
var fn = 3;
console.log(fn);
//3

上面代碼實際運(yùn)行如下：

var fn;
function fu(){}
fn =3;
console.log(fn);
//3

6.如下代碼的輸出?為什么

 function fn(fn2){
       console.log(fn2);//function fn2()
       var fn2 = 3;
       console.log(fn2);//3
       console.log(fn);//function fn(fn2)
       function fn2(){
            console.log('fnnn2');
        }
     }
    fn(10);

代碼實際運(yùn)行如下：

function fn(fn2){
     var fn2;
     function fn2(){
     console.log('funn2');
}
     console.log(fn2)//function fn2()
     fn2 =3;
     console.log(fn2);//3
     console.log(fn);//function fn(fn2)
}
fn(10);

7.如下代碼的輸出？為什么

var fn = 1;
    function fn(fn){
         console.log(fn);
    }
    console.log(fn(fn)); //報錯

上面代碼實際運(yùn)行如下；

 var fn;
 function fn (fn){
    console.log(fn);
 }
 fn = 1;
 console.log(fn(fn));//報錯

8.如下代碼的輸出？為什么

 //作用域
    console.log(j);
    console.log(i);
    for(var i=0; i<10; i++){
        var j = 100;
    }
    console.log(i);
    console.log(j);

上面代碼實際運(yùn)行如下：

var i;
var j;
console.log(j);//undefined
console.log(i);//undefined
for(i = 0;i<10;i++){
     j= 100;
}
console.log(i);//10
console.log(j);//100

9.如下代碼的輸出？為什么

  fn();
    var i = 10;
    var fn = 20;
    console.log(i);
    function fn(){
        console.log(i);
        var i = 99;
        fn2();
        console.log(i);
        function fn2(){
            i = 100;
        }
    }
  

代碼實際運(yùn)行如下；

    var i;
    var fn;
    function fn(){
        var i;
        function fn2(){
            i =100;
        }
        console.log(i);
        i = 99;
        fn2();
        console.log(i);
    }
    fn();
    i = 10;
    fn= 20;
    console.log(i);
//undefined
// 100 
//10

這個代碼比較繞，這里一步一步的解析下：

• 先將全局的變量聲明和函數(shù)聲明提升到代碼的頂部，然后將函數(shù)內(nèi)部的變量聲明和函數(shù)聲明提升到函數(shù)內(nèi)部的頂部。

• 接著運(yùn)行到代碼fn()，函數(shù)fn的內(nèi)部開始解析和求值：

  • 首先求值的是console.log(i)，變量i此時只有聲明，還未賦值，而函數(shù)fn2()內(nèi)部的i值外面是無法訪問的，所以輸出為undefined。

• 接著求值的是fn2()，求值的結(jié)果是i=100，覆蓋了上一句的i=99。

• 最后一個求值的是console.log(i)，結(jié)果很明顯為100。

• 所以整個函數(shù)fn運(yùn)行來下的結(jié)果為 undefined和100。

• 接著運(yùn)行到console.log(i)，此時i被賦值為10，結(jié)果輸出為10。

所以整個代碼運(yùn)行下來的結(jié)果為undefined，100，10。

10.如下代碼的輸出？為什么

  var say = 0;
    (function say(n){
        console.log(n);
        if(n<3) return;
        say(n-1);
    }( 10 ));
    console.log(say);
//10
//9
//8
//7
//6
//5
//4
//3
//2
//0

函數(shù)say被一個圓括號包裹起來，所以函數(shù)say是一個表達(dá)式，不會有函數(shù)聲明提升，而且會立刻執(zhí)行函數(shù)表達(dá)式。
函數(shù)say的內(nèi)部有一行代碼say(n-1)，這意味著函數(shù)say會發(fā)生遞歸，每個傳入函數(shù)say的參數(shù)會減一再繼續(xù)運(yùn)行下去,直到參數(shù)n小于3。
所以在傳入?yún)?shù)10之后，函數(shù)say就會從10開始打印，直到打印2為止。
最后console.log(say),打印出變量say的值，即為0。

——————————
本文版權(quán)歸本人和饑人谷所有，轉(zhuǎn)載請注明來源。