1.函數聲明和函數表達式有什么區別?

函數聲明必須有標識符，也就是常說的函數名；函數表達式可以省略函數名.函數聲明會提前；對于函數表達式，函數調用只有在函數表達式聲明后調用；

2.什么是變量的聲明前置？什么是函數的聲明前置?

變量的聲明前置是指執行代碼之前會先讀取變量的聲明，在執行的過程中進行賦值， var a=2;一般分為兩步 var a 聲明一個變量 a 會放在最前面，然后在進行賦值 a=2；
函數的聲明前置意思是在執行代碼之前會先讀取函數聲明。這就意味著可以把函數聲明放在調用它的語句后面。

3.arguments 是什么?

在函數內部,你可以使用arguments對象獲取到該函數的所有傳入參數，是我們傳入函數內的實參；所有的函數都有屬于自己的一個arguments對象，它包括了函所要調用的參數。他不是一個數組，如果用typeof arguments，返回的是’object’。雖然我們可以用調用數據的方法來調用arguments。比如length,還有index方法。但是數組的push和pop對象是不適用的。

4.函數的"重載"怎樣實現

js中是沒有重載的；如果想實現類似函數重載，我們可以判斷傳入函數內部的參數的類型和數目來執行函數。注：js判斷傳入參數數量可以用arguments.length這個屬性來判斷；判斷類型：
1.用 typeof 語句判斷變量類型，typeof語句返回類型對應的字符串。
2.用 instanceof 語句判斷變量類型，instanceof語句返回true/false。
3.用 constructor 屬性判斷變量類型，這個屬性返回用來構造該變量的構造函數引用。

5.立即執行函數表達式是什么？有什么作用

立即執行函數模式是一種語法，可以讓你的函數在定義后立即被執行；這種模式本質上就是函數表達式，在創建后立即執行。因為函數的聲明是不可以跟圓括號的，但是函數的表達式可以；要將函數聲明轉換成函數表達式，就可以在聲明外面加一對括號。在javascript里，括號內部不能包含語句，當解析器對代碼進行解釋的時候，先碰到了()，然后碰到function關鍵字就會自動將()里面的代碼識別為函數表達式而不是函數聲明。

//最常用的模式
(function () {  
    alert('hello world!');  
})(); 
//第二種模式
(function () {  
    alert('watch out!');  
}());  
//還有許多模式

作用：臨時需要變量的時候，可以創建私有作用域，這樣不會污染到全局，避免了全局變量過多，防止命名沖突；同時匿名函數執行完畢后，會立即銷毀函數內部變量，而匿名函數又是一個閉包，可以訪問自身作用域鏈中的所有變量。這種做法可以減少閉包占用的內存問題，因為沒有指向匿名函數的引用。只要函數執行完畢，就可以立即銷毀其作用域鏈了。

6.求n!，用遞歸來實現

  function factorial(n){
            if(n<=1){
                  return 1;
              }else{
                return n*f(n-1);
             }    
    }
    factorial(n);

7.以下代碼輸出什么？

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('饑人谷', 2, '男'); // 輸出 name:饑人谷；age: 2；sex: 男 ；Arguments(3) { " valley",2," 男 " }；name valley
getInfo('小谷', 3);// 輸出 name:小谷；age: 3；sex: undefined ；Arguments(2) { " valley",3}；name valley
getInfo('男');// 輸出 name:男；age:  undefined ；sex: undefined ；Arguments(1) { " valley"}；name valley

8. 寫一個函數，返回參數的平方和？

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

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

    console.log(a); //undefined   變量聲明提升，但賦值在后 所以為undefined
    var a = 1;
    console.log(b);//報錯 b is not defined

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

    sayName('world'); // hello world; 函數聲明提升
    sayAge(10);  //sayAge is not a function; 函數表達式只把變量的聲明提升了。賦值在后面
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };

11. 如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼

var x = 10;
bar() ;
function foo() {
  console.log(x);
}
function bar(){
  var x = 30;
  foo();
}
//分析
globalContext = {
  //全局執行上下文
  AO:{
          x:10,
          foo:function(){},
          bar:function(){}
       },
  Scope = null;
  };
foo.[[Scope]] = globalContext.AO;
bar.[[Scope]] = globalContext.AO;
bar執行的時候進入bar的執行上下文：
barContext = {
      //bar的執行上下文
      AO:{
          x:30
          },
    Scope:bar.[[Scope]]
}
fooContext = {
       //foo的執行上下文
         AO:{
             },
     Scope:foo.[[Scope]]
}

分析：首先將變量聲明 函數聲明提升；執行bar函數進入bar函數的執行上下文；bar函數執行過程中執行foo函數，會先在bar的AO中尋找foo函數，沒有再進入bar.[[Scope]]尋找。執行foo函數進入foo函數的執行上下文，執行console.log(x)；首先在foo自己的AO中找x，沒有就進入foo.[[Scope]]中尋找所以console.log(x)打印出來的值為10；

12. 如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼

 var x = 10;
  bar(); 
 function bar(){
   var x = 30;
  function foo(){
       console.log(x); 
       }
    foo();
}   
//全局執行上下文：
globalContext = {
      AO:{
         x:10,
          bar:function(){}  
        }
        Scope:null
    }
bar.[[Scope]] = globalContext.AO;
//bar的執行上下文
 barContext = {
        AO:{
          x:30,
          foo:function(){}
             },
          Scope: bar.[[Scope]] 
    }
foo.[[Scope]] = barContext.AO;
//foo的執行上下文
 fooContext = {
        AO:{
        },
        Scope:foo.[[Scope]]
  }

分析：先進行全局和函數內部的變量聲明提升 函數聲明提升，執行bar函數先在globalContext.AO中尋找函數bar，執行bar函數進入bar函數的執行上下文；bar函數內部執行foo函數先在barContext.AO 中尋找foo函數找到后執行console.log(x)；x先在fooContext.AO中尋找，沒有進入foo.[[Scope]]尋找也就是 barContext.AO中尋找x=30，所以打印結果為30.

13.如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼

var x = 10;
bar(); 
function bar(){
  var x = 30;
  (function (){
    console.log(x);
  })();
}

分析：同上因為立即執行函數可以看做一個函數表達式類似于var fn = function(){}; 然后立即執行fn();匿名函數執行上下文的Scope屬性為barContext.AO，找到x為30；打印結果為30.

14.如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼

var a = 1;
function fn(){
  console.log(a);
  var a = 5;
  console.log(a);
  a++;
  var a;
  fn3();
  fn2();
  console.log(a);
  function fn2(){
    console.log(a);
    a = 20;
  }
}
function fn3(){
  console.log(a);
  a = 200;
}
fn();
console.log(a);

分析過程：
首先在全局和函數內部進行變量聲明提升和函數聲明提升；

//全局執行上下文：
        globalContext = {
            AO:{
            a:1,//變化順序1;200
            fn:function(){},
            fn3:function(){}    
            },
            Scope:null
        }
        fn.[[Scope]] = globalContext.AO;
        fn3.[[Scope]] = globalContext.AO;
        //fn函數執行上下文:
        fnContext = {
            AO:{
            a:,//執行過程a值得變化  undefined;5;6;20
            fn2:function(){}    
            },
            Scope:fn.[[Scope]]
        }
        fn2.[[Scope]] = fnContext.AO;
        //fn2的執行上下文
        fn2Context = {
            AO:{
                
            },
            Scope:fn2.[[Scope]]
        }
        //fn3的執行上下文
        fn3Context = {
            AO:{
            
            },
            Scope:fn3.[[Scope]]
        }

執行程序分析：全局環境下執行fn,在globalContext.AO中找到fn函數執行fn,第一次console.log(a),在fnContext.AO找到a只聲明未賦值為undefined,對a賦值5,第二次console.log(a)結果為5,a++ a為6,var a重新聲明a不會對a值產生影響,執行fn3函數進入fn3函數的執行上下文,console.log(a),先在fn3Context.AO中尋找a,全局聲明的a找不到,在fn3.[[Scope]]中找到全局的var a = 1;console.log(a)即為1;隨后全局的a被賦值為200,繼續往下執行fn2進入fn2的執行上下文,首先在fn2Context.AO中尋找a,沒有進入fn2.[[Scope]]尋找此時a為a++后的6,打印出6;隨后a = 20修改了fn執行上下文的a為20;再在fn內部console.log(a),得到20;最后在全局console.log(a),此時全局的a為200;最后打印結果為undefined 5 1 6 20 200