函数与作用域

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

函数声明使用function来进行声明，函数声明提升，所以不论执行语句的位置皆可调用该函数。

function fn(){
    console.log("hello world");
}

函数表达式通过赋值来声明函数，声明完毕后要加上分号表示该句结束，在表达式执行完后，函数才存在并可被调用

var fn=function(){
      console.log("hello jirengu");
};

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

变量提升：当一个变量被定义时，在代码执行前会先将变量进行初始化再执行语句。

console.log(a);//undefined
var a = 1;
console.log(a);//1
//相当于
var a;
console.log(a);
a = 1;
console.log(a);

函数声明前置：JavaScript引擎将函数名视同变量名，所以采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部。在用声明方式创建函数的前面或者后面都可以随时调用此函数；

fn();//hello world
function fu(){
    console.log("hello world");
}
fn();//hello world

3.arguments 是什么

argument是类数组对象，每个函数中都存在argument对象，argument并不是一个真正的数组，所以不具备除length属性之外的属性，这个对象维护这所有传入该函数的参数列表。
通过以下语句可将arguments转化为数组对象
···
var args=Array.prototype.slice.call(arguments)
···

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

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

   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.立即执行函数表达式是什么？有什么作用

立即执行函数表达式（Immediately-Invoked Function Expression），简称IIFE。表示定义函数之后，立即调用该函数。
作用：隔离作用域。
写法：

(function(){var a  = 1;})()
(function fn1() {var a  = 1;});
[function fn2() {var a  = 1;}];
1, function fn3() {var a  = 1;};

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

function factor(n){
    if(n === 1){
        return 1;
    }
    return n*factor(n-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(var i = 0;i < arguments.length;i++){
          sum += arguments[i]*arguments[i];
      }
      return sum;
   }
   var result = sumOfSquares(2,3,4);
   var result2 = sumOfSquares(1,3);
   console.log(result)  //29
   console.log(result)  //10

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

console.log(a);//undefined，变量a声明前置，d但未赋值
var a = 1;
console.log(b);//报错，Uncaught ReferenceError: b is not defined，原因：变量b，未声明，不能直接调用

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

sayName('world');//hello world，函数以声明的方式创建，函数会前置声明，调用时将参数“world”传入，输出结果： hello world。
sayAge(10);//报错，Uncaught TypeError: 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。
作用域链查找过程伪代码：

1.
globalContext={
  AO:{
    x: 10,
    foo: function,
    bar: function 
  },
  scope: null
}
//声明foo时，得到下面
foo.[[scope]] = globalContext.AO;
//声明bar时，得到下面
bar.[[scope]] = globalContext.AO;
2.
barContext= {
  AO: {
    x:30
  },
  scope:bar.[[scope]] //globalContext.AO;
 }
3.
fooContext = {
  AO:{},
  scope: foo.[[scope]]//globalContext.AO;
}
//在调用foo()时，console.log(x)中,变量x将先在fooContext.AO中搜索x，没有搜索到。再在globalContext.AO中搜索，globalContext.AO.x = 10。所以最后输出结果：10。

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

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

输出结果：30。
作用域链查找过程伪代码：

1.
globalContext = {
  AO:{
  x: 10,
  bar: function
  },
  scope:null
}
//在声明bar时，得到下面
bar.[[scope]] = globalContext.AO;
2.
barContext = {
  AO:{
    x: 30,
    foo: function
  },
  scope:  globalContext.AO;
}
//在申明foo时，得到下面
foo.[[scope]] = barContext.AO
3.
fooContext = {
  AO: {},
  scope : barContext.AO
}
//在调用foo()时，console.log(x)中,变量x将先在fooContext.AO中搜索x，没有搜索到，再在barContext.AO中搜索。搜到到barContext.AO.x = 30。最终输出结果为：30。

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的同时，得到
bar.[[scope]] = globalContex.AO
2.
barContext = {
  AO: {
    x: 30,
    function(): function
  },
scope: globalContex.AO
}
function().[[scope]] = barContext.AO;
3.
functionContext  = {
  AO: {},
  scope: barContext.AO;
}
在匿名函数自调用时，变量x先搜索functionContext.AO，没有找到x，在搜索barContext.AO，x: = 30;所以输出结果为：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)

输出结果：undeifined、5、1、6、20、200
作用域链查找过程伪代码：

1. 
globalContext = {
  AO: {
    a: 200,
    fn: function,
    fn3:function
  }
scope: null
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
2.
fnContext = {
  AO: {
    a: 20,
    fn2: function
  }
  scope: globalContext.AO
}
fn2.[[scope]] = fnContext.AO
//第一次输出a为赋值，结果为:undefined。然后a赋值为5，第二次输入：为5。a++后a=6，var a后值不变，
3.
fn3Context= {
  AO: { },
scope: globalContext.AO;
}
//第三次输处结果为1，然后将globalContext.AO.a赋值为200。
4.
fn2Context = {
  AO: { },
  scope:  fnContext.AO
}
//第四次输处结果为6，然后将fnContext.AO.a赋值为20。
//第五次在fn中 console.log(a)，变量a在fnContext.AO搜索，输出结果为20。
//第六次全局作用域下console.log(a)，变量a在globalContext.AO中搜素，输出结果为200