函数与作用域

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

函数声明

function printInConsole(str) {
    console.log(str);
}

函数表达式

var printInConsole=function (str) {
    console.log(str);
};

区别

1. 函数表达式结束后需要加;表示声明变量结束。
2. 函数表达式的本质是用一个变量来存储一个函数。
3. 由于在JavaScript中函数是提前声明的，所以使用函数声明方式只要在作用域中，写在哪里都可以，而函数表达式只能先声明在调用。

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

变量的声明前置
JavaScript引擎的工作方式是，先解析代码，获取所有被声明的变量，然后再一行一行地运行。这造成的结果，就是所有的变量的声明语句，都会被提升到代码的头部，这就叫做变量提升。这种工作方式体现在我们可以先使用变量在声明变量。

console.log(a);
var a=6;
// 6

函数的声明前置
和变量的声明会前置一样，函数声明同样会前置，如果我们使用函数表达式来声明一个函数，那么规则和变量一样。

printInConsole('啦啦啦');
function printInConsole(str) {
    console.log(str);
}
//啦啦啦

arguments 是什么

在函数内部,你可以使用arguments对象获取到该函数的所有传入参数

function printInConsole() {
        for(var i=0;i<arguments.length;i++){
            console.log(arguments[i]);
        }
    }
printInConsole(1,2,3,4,5);
//1  2  3  4  5

函数的"重载"怎样实现

在JavaScript中，函数调用可以不把所有参数都传入，只要你函数体内做好处理就行，但前提是传的参数永远被当做前几个。只能按照顺序来写我们可能会传入的参数，通过判断参数的个数来达到重载的效果。比如上题中的例子，不管我们传入多少参数都会打印出来，打印的顺序就是我们传入参数的顺序，不能更改。

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

立即执行表达式

(function(){console.log('1')})();

(function(){console.log('2')}());

!function(){console.log('3')}();

void function(){console.log('4')}()

作用
隔离作用域，说隔离作用域有些难以理解，如果说可以创建一个作用域就很好理解了。他可以将作用域分为两块，内部一块外部一块。

求n!，用递归来实现

function factor(num) {
    if(num==0){
        return 1;
    }
    else{
        return num*factor(num-1);
    }
}

以下代码输出什么？

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, '男');
getInfo('小谷', 3);
getInfo('男');

name:饥人谷
age:2
sex:男
['饥人谷'，2，'男']
name:valley

name:小谷
age:3
sex:undefined
['小谷'，3]
name:valley

name:男
age:undefined
sex:undefined
['男']
name:valley

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

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

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

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

1 undefined
在JavaScript中变量的声明位置会提前，所以a不是undefined，而是1。没有定义变量b，所以输出undefined

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

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

world 报错:'sayAge不是一个函数'
使用函数声明函数的时候会将函数声明提前，所以无论在相同作用域中的哪里都能够使用，但是使用表达式声明函数的时候实际上我们只是声明了一个变量，并将一个函数赋值给了变量，所以他会报sayAge不是一个函数的错。

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和bar时得到
  foo.[Scope] = globalContext.AO;
  bar.[Scope] = globalContext.AO;
  //调用bar()时执行 bar()
}

//进入bar()的执行上下文，从globalContext.AO进入
barContext = {
  AO: {
    x: 30,
  };
  Scope: globalContext.AO;
  //执行 foo() 在这个作用域内找不到，就从Scope中去找
}

//进入 foo()的执行上下文，从globalContext.AO进入
fooContext = {
  AO: {}；
  Scope: globalContext.AO;
  //执行 console.log(x)输出10，因为 foo()的作用域是globalContext.AO
}

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

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

//进入全局执行上下文
gloabalContext = {
    AO:{
        x : 10,
        bar : function
    };
    Scope : null;
    bar[Scope] = gloabalContext.AO;
    //执行 bar()
}
//当调用bar时进入bar的执行上下文，从globalContext.AO进入
barContext = {
    AO:{
        x:30,
        foo: function
    }
    Scope: globalContext.AO;
    //声明foo时得到
    foo[Scope] = barContext.AO;
    //调用foo
}
//调用foo()进入foo的执行上下文，从barContext.AO进入
fooContext = {
  AO: {},
  Scope: foo.[[scope]] // barContext.AO
}
//所以输出的值为30，foo在bar的作用域链中，使用bar中的变量。

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;
  //执行 bar();
}

//进入 bar() 的执行上下文
barContext = {
  AO: {
    x: 30,
    function: function,
  };
  Scope: globalContext.AO;
  function.[Scope] = barContext.AO;
  //执行 function ()
}

//进入 function() 的执行上下文
functionContext = {
  AO: {};
  Scope: barContext.AO
  //执行 console.log(x)    // 输出30    因为 AO 中没有，就从 Scope 中去找 
}

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.[Scope]  = globalContext.AO;
  fn3.[Scope] = globalContext.AO;
  执行 fn();
}

进入 fn() 的执行上下文
fnContext = {
  var a;
  function fn2(){}
    fn2.[Scope] = fnContext;
  console.log(a)// undefined，var 声明前置未赋值
  a = 5;
  console.log(a);// 5，a 已经赋值 5
  a++;
//执行 fn3(){
    console.log(a);//  1，fn3 的作用域为 globalContext
    a = 200;    //改变了 globalContext 中的 a
  }
  执行 fn2(){
    console.log(a);//  6,fn2 的作用域为 fnContext
    a = 20;     // 改变了 fnContext 中的 a 为 20
  }
  console.log(a);//   20，a 已经赋值 20
}
console.log(a);//   200，它的作用域为globalContext
// 最终输出为 undefined   5  1  6  20  200