进阶任务三

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

• 函数声明

     // 函数声明
    function sayHello(){
        console.log('hello');
    }
    // 函数调用
    sayHello();

• 函数表达式

    // 函数表达式
    var sayName = function(){
        console.log('nihao');
    }
    sayName();

• 区别： 函数调用可以发生在函数声明之前，不能在函数表达式之前。

一、Javascript引擎在解析javascript代码时会‘函数声明提升’（Function declaration Hoisting）当前执行环境（作用域）上的函数声明，而函数表达式必须等到Javascirtp引擎执行到它所在行时，才会从上而下一行一行地解析函数表达式，
二、函数表达式后面可以加括号立即调用该函数，函数声明不可以，只能以fnName()形式调用

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

• 变量声明前置

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

• 函数前置

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

3. arguments 是什么

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

function printPersonInfo(name, age, sex){
    console.log('name : '+name);
    console.log('age : '+age);
    console.log('sex : ' +sex);
    console.log(arguments);
}

printPersonInfo('wang', 25,'boy');

name : wang
age : 25
sex : boy
 ["wang", 25, "boy"]

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

重载是很多面向对象语言实现多态的手段之一，在静态语言中确定一个函数的手段是靠方法签名——函数名+参数列表，也就是说相同名字的函数参数个数不同或者顺序不同都被认为是不同的函数，称为函数重载
在JavaScript中没有函数重载的概念，函数通过名字确定唯一性，参数不同也被认为是相同的函数，后面的覆盖前面的，这是不是意味着JavaScript不能通过重载功能实现一个函数，参数不同功能不同呢？

在JavaScript中，函数调用没必要把所有参数都传入，只要你函数体内做好处理就行，但前提是传的参数永远被当做前几个

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

• 立即执行函数表达式有多种写法

1. (function(){})();
2. (function(){}());
3. !function(){}();
4. void function(){}();

• 作用：创建一个独立的作用域。这个作用域里面的变量，外面访问不到（即避免变量污染）。

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

function fn(n){
    if(n===1){
          return 1
}
    else{
          return n*fn(n-1)
}
}

fn(4)//输出24

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('hunger', 28, '男'); 
getInfo('hunger', 28); 
getInfo('男');

输出

name:hunger;
age:28;
sex:男；
["hunger", 28, "男"]
name:valley;

name:hunger;
age:28;
sex:undefined；
["hunger", 28]
name:valley;

name:"男"；
age:undefined;
sex:undefined;
["男"]
name:valley;

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

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

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

console.log(a);  //underfined，因为变量提升的缘故，初始值undefined
var a = 1;  
console.log(b);  //Uncaught ReferenceError: b is not defined

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

sayName('world');     //输出hello world，因为使用函数声明声明的函数，相当于整个函数都被前置了，可以在声明之前就被调用
sayAge(10);  //会报错,因为使用表达式声明的函数，只是函数名被前置了，所以在声明之前调用会报错
function sayName(name){ 
    console.log('hello ', name); 
} 
var sayAge = function(age){ 
    console.log(age); 
};

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

var x = 10
bar() 
function foo() {
  console.log(x)  //输出10
}
function bar(){ 
  var x = 30
  foo()           //此时barContext: Ao中没有foo，转去bar.scope即globalContext中发现有foo，因此还是输出10
}//输出10

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

function fn(fn2){
    console.log(fn2); 
    var fn2 = 3; 
    console.log(fn2); 
    console.log(fn);
    function fn2(){
       console.log('fnnn2');
   } 
} 
fn(10);

输出

function fn2(){
       console.log('fnnn2');
   } 

3

function fn(fn2){ 
    console.log(fn2); 
    var fn2 = 3; 
    console.log(fn2);
     console.log(fn); 
    function fn2(){ 
        console.log('fnnn2'); 
  } 
}

因为，当函数执行有命名冲突的时候，函数执行时载入顺序是变量、函数、参数 ,所以原代码等同于如下代码:

function fn(fn2){
    var fn2;  //变量声明前置
    function fn2(){   //函数声明前置
        console.log('fnnn2'); 
    }
     console.log(fn2);   //打印fn2()函数
     fn2 = 3;
     console.log(fn2);   //打印数字3
     console.log(fn);     //向上寻找，打印fn()函数
}
fn(10);

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

var fn;   //变量声明前置
function fn(fn){   //函数声明前置
    console.log(fn); 
}
fn=1;  //fn赋值为1
console.log(fn(fn));   //报错，因为此时的fn是数字1

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

var a = 1;
function fn(){
  console.log(a)//输出undefined
  var a = 5
  console.log(a)//输出5
  a++
  var a
  fn3()//调用fn3函数，最后输出1
  fn2()//调用fn2函数，最后输出20
  console.log(a)//输出20

  function fn2(){
    console.log(a)
    a = 20
  }//因上方调用调用fn2函数，输出20
}

function fn3(){
  console.log(a)
  a = 200
}//因上方调用调用fn3函数，输出1

fn()
console.log(a)//输出200


依次输出undefined，5，1，6，2，200

globalContext:{
  Ao:{a:1-->200
    fn:function
    fn3:function
}
}
fn[[scope]]=globalContext.Ao
fn3[[scope]]=globalContext.Ao

fnContext:{
    Ao:{
    a:undefined-->5-->6-->20
    fn2:function
}
scope:globalContext.Ao
}

fn3Context{
Ao:{}
scope:globalContext.Ao
}

fn2Context{
Ao:{}
scope:fnContext.Ao
}