函数与作用域

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

• 函数声明使用function来进行声明，必须有函数名，函数声明会提升，所以不必放在执行前声明。
• 函数表达式其实就是创建一个匿名的函数声明并赋值给一个变量，函数的执行必须放在创建之后才可以

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

变量的声明前置
console.log(a);// undefined，因为a已经声明了，等同于在console.log(a)之前有一句 var a =undefined
var a = 1;
console.log(a); // 1,因为a已经等于1了，所以此时会输出1。

arguments 是什么

arguments是函数内部的一个类数组对象，它存储了函数的所有参数

对于函数
function foo(a1,a2,a3,a4...){}，可以通过
for(var i=0;i<arguments.length;i++){
  console.log(arguments[i])输出该函数的所有参数
}

函数的"重载"怎样实现

可以通过判断arguments的长度来实现

function reload(){
  var arguLen = arguments.length;
  switch(arguLen){
    case 0:
    do something;
    return something;
    break;

    case 1:
    do something;
    return something;
    break;

    case 2:
    do something;
    return something;
    break;

    case 3:
    do something;
    return something;
    break;

   case ...//可能还能很多情况去判断
  }；
}

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

• 立即执行函数的表达式

(function foo(){console.log(1)})()
!function foo(){console.log(1)}()
[function foo(){console.log(1)}()]

通常情况下，只对匿名函数使用这种“立即执行的函数表达式”。它的目的有两个：一是不必为函数命名，避免了污染全局变量；二是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。

求n!，用递归来实现

function factor(n){
  if(n === 1){
    return 1
  }
  return n*factor(n-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, '男');
    // 输出:name: 饥人谷, age: 2,sex: 男,["饥人谷", 2, "男"],name valley
    getInfo('小谷', 3);
    // 输出: name:小谷、age:3、undefined、['小谷', 3]、name vally;
    getInfo('男');
    // 输出: name:男、undefined、undefined、['男']、name vally;

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

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

如下代码的输出？为什么

    console.log(a);// 输出undefined，因为变量a的声明提升，相当于在当前代码前面声明了变量a等于undefined
    var a = 1;
    console.log(b); 会报错，因为变量b未声明，ReferenceError: b is not defined
        

如下代码的输出？为什么

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

// sayName('world')会输出 hello world
// sayAge(10)会报错：Uncaught TypeError: sayAge is not a function
因为函数声明会提升，不必放到执行之前，但是函数表达式相当于创建了一个匿名函数并且赋值给了一个变量sayAge,它的执行必须放到函数表达式之后才可以

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

var x = 10
bar() 
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
  foo()
}
输出 10
// 伪代码
/*
globalContext = {
  AO: {
    x: 10
    foo: function
    bar: function
  }
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO

barContext = {
  AO: {
    x: 30
  },
  scope: globalContext.AO
}
fooContext = {
  AO: {},
  scope: globalContext.AO
}
*/

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}
输出 30
伪代码：
globalContext = {
  AO: {
    x: 10
    bar: function
  },
}
bar.[[scope]] = globalContext.AO

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

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

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}
输出 30
伪代码：
globalContext = {
  AO: {
    x: 10
    bar: function
  }
}
bar.[[scope]] = globalContext.AO

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

IIFEContext = {
  AO: {},
  scope: barContext.AO
}

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

var a = 1;

function fn(){
  console.log(a) // 会输出undefined，因为变量声明提升，但并未赋值（first）
  var a = 5
  console.log(a) //会输出 5，变量被赋值5(second)
  a++ // 变量自增1，下次调用时会变为6
  var a // 重复声明已经存在的变量，其值不变，还是6
  fn3()
  fn2()
  console.log(a) // 会输出20，因为执行完fn2()后，已经把该作用域中的变量a更改为20(fifth)

  function fn2(){
    console.log(a)// 会输出6，因为他自身的作用域中没有声明变量a，只能从它的上一级作用域中查找，是6(fourth)
    a = 20//此时，它上一级作用域中的变量a会变为20，因为他自身的作用域中没有申明变量a，所以只能从它的上一级作用域中查找和更改
  }
}

function fn3(){
  console.log(a) // 会输出1，因为他的作用域中没有变量a，会从全局作用域中查找，是1(third)
  a = 200 //此时，全局作用域中的a会变为200，因为它自身的作用域中没有变量a，只能从它的上一级作用域中查找
}

fn()
console.log(a) // 会输出200，因为fn3()的执行已经把全局作用域中的变量a更改为200（sixth）

所以最终的输出结果依次是:undefined,5,1,6,20,200