1.函数声明和函数表达式有什么区别

函数声明会提前，声明前置。声明不必放到调用的前面
函数表达式是将声明变量提升，是为了得到返回值，一定会返回一个值，声明必须放到调用的前面

  //函数声明
function sayHello(){
console.log('hello')
 }

 //函数调用
 sayHello()

//函数表达式
 var sayHello = function(){
 console.log('hello');
 }

 sayHello()

2.什么是变量的声明前置？什么是函数的声明前置

console.log(a);
var a = 1;  // 虽然不会报错（存在变量提升） 但真实运行的是下面的代码

var a;
console.log(a);
a = 1;     //这就是变量声明前置

函数的声明前置（JavaScript引擎将函数名视同变量名），但如果采用赋值语句定义函数，就会报错。

f();  //不会报错

function f() {}

3.arguments 是什么

arguments是一个类数组对象。代表传给一个function的参数列表。

// arguments对象
 function args() { return arguments }
 var arrayLike = args('a', 'b');

 arrayLike[0] // 'a'
 arrayLike.length // 2
 arrayLike instanceof Array // false

4.函数的"重载"怎样实现

JS中没有重载! 同名函数会覆盖。 但可以在函数体针对不同的参数调用执行相应的逻辑

function printPeopleInfo(name, age, sex){
if(name){
  console.log(name);
}

if(age){
  console.log(age);
}

if(sex){
  console.log(sex);
}
}


printPeopleInfo('Byron', 26);
printPeopleInfo('Byron', 26, 'male');

5.立即执行函数表达式是什么？有什么作用

(function(){
   var a = 1;
})()

作用：隔离作用域，避免变量污染全局。

6.求n!，用递归来实现

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

factorial();

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：男 ['饥人谷',2,'sex'] name valley
getInfo('小谷', 3); // name:小谷、age:3、undefined、['小谷', 3]、name vally;
getInfo('男');  //name:男、undefined、undefined、['男']、name vally;

8.写一个函数，返回参数的平方和？

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

9.如下代码的输出？为什么

console.log(a);//underfined,因为声明变量前置
var a = 1;
console.log(b); //会报错，b is not defined 未声明变量b

10.如下代码的输出？为什么

sayName('world');
sayAge(10);
function sayName(name){
    console.log('hello ', name);  // hello world  ,因为函数声明前置
}
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时，得到下面
        foo.[ [scope] ] = globalContext.AO
        //声明bar时，得到下面
        bar.[ [scope] ] = globalContext.AO
                //调用bar，bar执行上下文
        barContext = {
            AO:{
                x:30
                foo:function
            },
            scope:bar.[[scope]] = golobaContext.AO
        }

        fooContext = {
            AO:{

            }
            scope:foo.[ [scope] ]= globalContext.AO
        }//从scope中即globalContext.AO中可以找到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 
    barContext = {
        AO:{
         x:30
         foo:function
        }
        bar.[ [scope] ] = globalContext.AO 
    }
    foo.[ [scope] ] = barContext.AO
    fooContext = {
        AO:{
        }
        foo.[ [scope] ] = barContext.AO
    }
    //调用foo时会在barContext.AO中找到x:30。

13.以下代码输出什么? 写出作用域链的查找过程伪代码

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

伪代码：

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

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

    x: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
            fn:function
            fn3:function
        },
        scope:null
    }
        //声明fn时，得到下面
        fn.[ [scope] ] = globalContext.AO
        //声明fn3时，得到下面
        fn3.[ [scope] ] = globalContext.AO

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

        fn3Context = {
            AO:{
                a:200

            },
            scope:fn3.[ [scope] ] = globalContext.AO
        }

        fn2Context = {
            AO:{
                a:20

            },
            scope:fn2.[ [scope] ] = fnContext.AO
        }
          // underfined 5 1 6 20 200

【个人总结，如有错漏，欢迎指出】
：>