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

函數(shù)聲明： function myFunction(){}
函數(shù)表達(dá)式：var myFunction = function(){}
函數(shù)聲明會前置，函數(shù)調(diào)用可以放在函數(shù)聲明之前。但是函數(shù)表達(dá)式不會前置，函數(shù)調(diào)用需放到函數(shù)表達(dá)式之后。

2.變量的聲明前置與函數(shù)的聲明前置

變量聲明前置：變量聲明前置就是在一個作用域塊中，所有的變量都被放在塊的開始作出聲明

console.log(a)  //  Uncaught ReferenceError: a is not defined

console.log(a) //  undefined   不再報錯，因?yàn)樽兞柯暶髑爸昧耍?var a=1;

函數(shù)聲明前置：JavaScript解釋器允許在函數(shù)聲明之前使用函數(shù)，此時不僅僅是函數(shù)名被前置了，整個函數(shù)定義也被前置了，所以就可以直接調(diào)用函數(shù)

myFunction();   //hello world
function myFunction(){
  console.log("hello world");
}

3.什么是arguments

arguments可以用來獲取函數(shù)所有傳入的參數(shù)

function printPersonInfo(name, age, sex){
    console.log(arguments);
  }
printPersonInfo('cz', 24, 'male'); 
/*
0 : 'cz'
1 : 24
2 : 'male'
*/

4.函數(shù)的重載

在js中是沒有函數(shù)的重載，同名函數(shù)只會覆蓋，但可以在函數(shù)體針對不同的參數(shù)調(diào)用執(zhí)行相應(yīng)的邏輯

function printPeopleInfo(name, age, sex){
    if(name){
      console.log(name);
    }
    if(age){
      console.log(age);
    }
    if(sex){
      console.log(sex);
    }
  }
  printPeopleInfo('Byron', 26);  //  Byron   26
  printPeopleInfo('Byron', 26, 'male');  //  Byron, 26, male

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

立即執(zhí)行函數(shù)表達(dá)式：(function(){})() (function fn1(){}) 等
可以立即執(zhí)行函數(shù)，同時也可以閉包，此中的變量外面不能訪問，避免變量污染。

6.求n!,用遞歸的方式

function factorial(n){
  if( n===0 || n===1 ){
    return 1;
  }
  else if( n<0 ){
    return "負(fù)數(shù)沒有階乘"；
  }
  else{
  return n*factorial(n-1);
  }
}

7.實(shí)例1（arguments）

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：男
['饑人谷',24,'男']
name  valley
*/


getInfo('小谷', 3);
/*
name : 小谷 
age：3  
sex：undefined
['小谷',3]
name  valley
*/


getInfo('男');
/*
name : 男 
age：undefined  
sex：undefined
['男']
name  valley
*/

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

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

9.實(shí)例2（變量聲明前置）

console.log(a);  // undefined 變量聲明前置
var a = 1;
console.log(b);  // Uncaught ReferenceError: a is not defined  b未聲明

10.實(shí)例3（函數(shù)聲明前置與函數(shù)表達(dá)式）

sayName('world');  // hello world   函數(shù)聲明前置，可以正常使用
sayAge(10);    //error  sayAge函數(shù)表達(dá)式只能在定義后使用，不能再前面使用
function sayName(name){
    console.log('hello ', name);
}
var sayAge = function(age){
    console.log(age);
};

11.實(shí)例4（作用域鏈）

var x = 10
bar()    // 10
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
fooContext = {
AO:{},
Scope: globalContext.AO
}
barContext = {
AO:{
x:30
},
Scope: globalContext.AO
}

12.實(shí)例5（作用域鏈2）

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

其具體過程

globalContext = {
  AO: {
    x: 10
    bar: function
  },
  Scope: null
}
bar.[[scope]] = globalContext.AO

barContext = {
  AO:{
    x:30
    foo:function
},
Scope: globalContext.AO
}
foo.[[scope]] = barContext.AO

fooContext = {
AO:{},
Scope: barContext.AO
}

13.實(shí)例6（作用域鏈3）

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

此例中立即執(zhí)行函數(shù) (function(){})()  就相當(dāng)于實(shí)例5中 先在函數(shù)bar中定義
foo函數(shù)，接著在寫一行foo()來執(zhí)行foo()函數(shù)過程是一樣的，只不過立即執(zhí)行函數(shù)
把函數(shù)的名字省略了。

14.實(shí)例7（作用域鏈4）

var a = 1;

function fn(){
  console.log(a)   // undefined
  var a = 5
  console.log(a)   // 5
  a++
  var a
  fn3()            // 1
  fn2()            // 6
  console.log(a)   // 20

  function fn2(){
    console.log(a)
    a = 20
  }
}

function fn3(){
  console.log(a)
  a = 200
}

fn()
console.log(a)     // 200

其作用域鏈查找過程偽代碼

globalContext = {
  AO : {
    a : 1,
    fn : function,
    fn3 : function
  }
  Scope: null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO

fnContext = {
  AO: {
    a : 5,
    fn2 : function
  }
  Scope : globalContext.AO
}
fn2.[[scope]] = fnContext.AO

fn2Context = {
  AO : {}
  Scope : fnContext.AO
}

fn3Context = {
  AO : {}
  Scope : globalContext.AO
}