进阶任务3

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

函数声明：function functionName(){}
函数表达式：var fn = function(){}
区别：
1.函数声明会在代码开始前定义，函数表达式遇到时才会执行。
2.函数声明必须有函数名，函数表达式则可以省略。

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

变量声明前置就是在一个作用域块中，所有的变量都被放在块的开始出声明。JavaScript引擎将函数名视同变量名，所以采用function命令声明函数时，整个函数会像变量声明一样，被提升到代码头部，只要函数在代码中进行了声明，无论它在哪个位置上进行声明，js引擎都会将它的声明放在范围作用域的顶部。

arguments 是什么##

arguments 是一个类数组对象。代表传给一个function的参数列表。在函数内部，你可以使用arguments对象获取到该函数的的所有传入参数

函数的"重载"怎样实现##

function printInfo(name,age,sex) {
if(name) {
console.log(name);
 }
if(age) {
console.log(age);
 }
if(sex) {
console.log(sex);
 }
}
//printInfo(27 ,'male') 输出 27 male

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

当JS执行到该行代码时，函数会被定义且立即执行，叫做立即执行函数表达式。
使用立即执行函数表达式可以创建一个独立的作用域，形成隔离，避免污染全局

求n!，用递归来实现##

function factor(n) {
    if (n>0) {
      if (n===1) {
        return 1;
      }
      return n * factor(n-1);
    } else if (n===0) {
      return 0;
    } else {
      if (n<0) {
      return 'ERROR'
      }
    }
  }

以下代码输出什么？##

    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

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

   function sumOfSquares(){
     var sum=0;
     for (var i=0;i

如下代码的输出？为什么?##

    console.log(a);// 变量声明前置，a未赋值，undefined
    var a = 1;
    console.log(b); //b未定义变量，报错

如下代码的输出？为什么?##

    sayName('world');
    sayAge(10);
    function sayName(name){
        console.log('hello ', name);  // hello world 因为函数声明中变量和函数声明提前不影响调用；
    }
    var sayAge = function(age){
        console.log(age);       //报错  函数表达式需要放在调用之前；
    };

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

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

查找过程

globalContext = {
  AO: {
      x:undefined -->10,
      foo:function,
      bar:function  
    }
  scope:null
}

barContext = {
 AO: {
     x:undefined-->30，
   }
 scope: globalContext.AO
}

fooContext ={
AO: { }
scope: globalContext.AO
}

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

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

12查找过程

globalContext= {
  AO:  {
      x: undefined-->10,
      bar:function
    }
  scope:null
}

barContext = {
  AO:  {
           x:undefined-->30,
           foo:function
}
scope: globalContext.AO

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

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

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

查找过程

globalContext= {
  AO: {
      x:10,
      bar:function
}
scope:unll
}

barContext = {
AO:{
x: undefined-->30,
匿名函数:function
}
scope: globalContext.AO
}

匿名函数context = {
AO :{}
scope: barcontext.AO

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

var a = 1;

function fn(){
  console.log(a)  //输出undefined
  var a = 5
  console.log(a)  //输出5
  a++  //6
  var a //6
  fn3()  //输出1
  fn2()  //输出6
  console.log(a) //20

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

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

fn() //undefined  5 1 6 20 
console.log(a)  //200

查找过程

globalContext= {
  AO: {
      a: undefined-->1-->200,
      fn:function,
      fn3:function
}
scope:null
}

fnContext = {
AO:{
    a:underfined-->5-->6-->20,
    fn2:function
}
scope: globalContext.AO
}

fn3Context = {
AO:{}
scope :globalContext.AO
}

fn2Context = {
 AO: {}
scope: fnContext.AO
}