函数

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

声明一个函数有三种方式
1.用function声明一个函数：

2.函数表达式方法：

3.function构造函数的方法（一般不使用）：

因为变量提升的原因，函数表达式的方法提升的是var print，所以用function声明的函数在执行时，会把函数提升到js语句的顶部，所以即使函数调用出现在函数声明的前面，也不会出现报错；而用函数表达式的方法声明的函数提升的是var定义的变量，所以会报错。

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

JS语言的特性是JS引擎在解析JS代码时会先获取所有被声明的变量然后再一行一行的运行，所以所有var声明的变量和function声明的函数会前置到代码头部，所以使用或调用在其后的变量或函数也不会报错

arguments 是什么

arguments是一个类数组对象，对应于传递给函数的参数，可以通过索引的方式访问函数传入的参数，arguments[i]，i为数组中元素的索引

函数的"重载"怎样实现

JS里因为同名函数会被覆盖所以没有重载，但是可以在函数体针对不同的参数调用执行相应的逻辑（模拟重载）

注意：传参时需注意传入参数的顺序

立即执行函数表达式是什么？有什么作用
立即执行函数的作用是隔离作用域，使被执行的函数内部的变量不会污染到外部，即外部不能访问函数内部的变量。写法：

1.       (function fn(){})()
   

2.       [function fn(){}]()
   

3.       !function fn(){}()
   

求n!，用递归来实现

打印结果：

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

如下代码的输出？为什么

   console.log(a);
   var a = 1;
   console.log(b);

因为声明前置，所以上面代码等价于：

var a
console.log(a);
a = 1;
console.log(b);

所以console.log(a)输出 undefined
console.log(b)输出b is not defined

如下代码的输出？为什么

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

声明前置所以代码等价于：

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

所以sayName('world');输出 hello world
sayAge(10);输出 sayAge is not a function

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

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

伪代码：

 1.globalContext = {
      AO: {
        x: 10
        foo: function(){}
        bar: function(){}
      }
   Scope: null
   }
// 声明 foo 时 得到下面
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO
//调用bar()时 进入bar()的执行上下文
2. barContext={
    AO: {
        x:30
    }
    bar.[[scope]] = globalContext.AO
    }
//调用foo()时 进入foo()的执行上下文
3. fooContext={
    AO:{    }
    foo.[[scope]] = globalContext.AO
    }

foo( )的x是globalContext的x 所以输出10

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

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

伪代码：

1.globalContext = {
      AO: {
        x: 10
        bar: function(){}
      }
   Scope: null
   }
// 声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
2. barContext = {
     AO: {
     x: 30,
     foo: function
 },
    Scope: bar.[[scope]] //globalContext.AO
 }
    foo.[[scope]] = barContext.AO
3. fooContext = {
    AO: {},
    Scope: foo.[[scope]] // barContext.AO
 }

调用foo( )时先在foo的AO里找，找不到再去bar的AO里找 所以输出30

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

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

执行过程同上一题但是bar内嵌套的是一个立即执行函数声明以后立即调用并执行自身同时其内部没有x变量所以会去bar的AO里找所以输出 30

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

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)

声明前置后：

var a = 1;

function fn(){
  var a
  console.log(a)
  a = 5
  console.log(a)
  a++
  fn3()
  fn2()
  console.log(a)

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

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

执行过程如下：调用fn( )后进入其执行上下文，首先var a但未赋值所以打印undefined后 a=5所以打印5，a++此时fn内部a为6，调用fn3时进入fn3的执行上下文首先打印1后a=200污染了全局变量a，执行完退出调用fn2进入fn2的执行上下文打印6，执行a=20污染了fn内部的变量a所以打印出20最后在打印200