JavaScript中的函数运行在它们被定义的作用域里，而不是它们被执行的作用域里。

1. 函数声明和函数表达式有什么区别
   函数声明和函数表达式非常相似，有着相同的语法。函数声明的函数名不能省略。函数表达式的函数名，可以省略。当省略函数名的时候，该函数就成为了匿名函数。
   函数声明会被整体提升，调用可以放在声明的前面。
   function a(){}
   而函数表达式是一个表达式，常出现在赋值的式子中。只有声明变量的部分会被提升，调用要放在声明的后面
   function (){}
2. 什么是变量的声明前置？什么是函数的声明前置
   变量的声明前置：所有变量的声明语句会提升到代码的头部
   函数的声明前置：采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部
3. arguments 是什么
   arguments对象在函数内部用来获取到该函数的所有传入的参数.arguments对象不是一个数组 。它类似于数组，但除了length之外没有任何数组属性
4. 函数的"重载"怎样实现
   JS是不支持重载的，第二个同名函数会覆盖前一个。但是可以通过arguments对象来实现“重载”。
   实现重载常用的方式：
   1、根据传入参数的类型执行不同的操作。
   2、利用参数中特殊的参数值进行不同的操作。
   3、根据参数的个数进行重载。
5. 立即执行函数表达式是什么？有什么作用
   立即执行函数表达式常见两种形式
   (function (){console.log(123)}())
(function (){console.log(123)})()
   立即执行函数可以创建一个独立的作用域，防止变量污染。
6. 求n!，用递归来实现

function a(n){
  if(n>1){
     return n * a(n-1) 
  }
  if(n===1){
    return 1 
  }
}

代码题

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, '男'] name valley
getInfo('小谷', 3); //name: 小谷 age:3 sex:undefined ["小谷", 3] name valley
getInfo('男'); //name:男 age: undefined sex: undefined ["男"] name valley

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

function sumOfSquares(){
var sum = 0
for(i=0;i<arguments.length;i++){
sum += Math.pow(arguments[i],2)
}
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);   //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()
}
输出10
下面是伪代码

globalContext = {
AO: {
x: 10
foo: function
bar: function
}
Scope: null
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO
2.调用bar()
barContext = {
AO: {
x: 30
}
Scope: bar.[[scope]] = globalContext.AO
}
3.调用foo()
fooContext = {
AO: {}
Scope: foo.[[scope]] = globalContext.AO

12. 如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10;
bar()
function bar(){
var x = 30;
function foo(){
console.log(x)
}
foo();
}
输出30
下面是伪代码

globalContext = {
AO: {
x: 10
bar: function
}
Scope: null
}
bar.[[scope]] = globalContext.AO
2.调用bar()
barContext = {
AO: {
x: 30
foo: function
}
Scope: bar.[[scope]] = globalContext.AO
}
foo.[[scope]] = barContext.AO
3.调用foo()
fooContext = {
AO: {}
Scope: foo.[[scope]] = barContext.AO
}

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

var x = 10;
bar()
function bar(){
var x = 30;
(function (){
console.log(x)
})()
}
输出 30
下面是伪代码
1 .
globalContext = {
AO: {
x: 10
bar: function
}
Scope: null
}
bar.[[scope]] = globalContext.AO
2.调用bar()
barContext = {
AO: {
x: 30
function(){}
}
Scope: bar.[[scope]] = globalContext.AO
}
function.[[scope]] = barContext.AO
3.调用function()
functionContext = {
AO: {}
Scope: function.[[scope]] = barContext.AO
}

14.  以下代码输出什么？ 写出作用域链查找过程伪代码

var a = 1;

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

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

}

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

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

下面是伪代码

globalContext = {
AO: {
a = 1
fn : function
fn3 : function
}
Scope : null
}
fn.[[Scope]] = globalContext.AO
fn3.[[Scope]] = globalContext.AO
2.调用fn
fnContext = {
AO:{
a = undefined 5 6 20
fn2 = function
}
Scope : fn.[[Scope]] = globalConstext.AO
}
fn2.[[Scope]] = fnContext.AO
3.调用fn3
fn3Context = {
AO:{

    }
    Scope : fn3.[[Scope]] = globalContext.AO

}
4.调用fn2
fn2Context = {
AO: {

    }
     Scope: fn2.[[scope]] = fnContext.AO

}
5.console.log(a) globalContext.AO