js作用域链

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

1.函数声明
function foo() {}
2.函数表达式
var bar=function(){}；

1.声明的函数foo将会在执行前提升，因此foo在函数上下文都是可以被调用的，即使是在函数声明之前调用也不会报错。但是函数表达式bar，如果还没声明就调用，就会报错, 如下面代码写的，把函数表达式当做一个变量来看，调用bar的时候，bar只是被声明了，还没有被赋值，只有函数变量声明提前了，但是bar的初始化代码仍然在原来的位置,函数要等到表达式赋值完成后才能调用，所以这里会提示bar 不是一个函数。

var bar;
bar();
bar=function(){}

2.函数表达式与函数声明的最主要区别是函数名称，在函数表达式中可忽略它，从而创建匿名函数。
3.函数表达式可以作为其他函数的参数。

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

声明前置，也就是常说的提升，是一种将变量和函数的声明移到函数作用域最顶部的机制。一个变量应该包含三个阶段：
第一：声明一个变量，如 var a;
第二：给变量赋值，如var a=2；
第三：使用这个变量，console.log(a);
我们在编程的时候应该使用这种模式，但是javascript并没有遵循这个顺序，javascript的解析引擎，在执行代码之前也就是预处理阶段，创建执法环境，然后扫描js的全局代码，扫描出来之后就把用声明方式创建的函数名，和用var 定义的变量名加入到创建执法环境中（也就是作用域的顶部），这就是声明前置。
变量的声明前置：
在函数作用域内声明一个变量时，声明的变量会被提升到所在函数作用域的顶部，如果在声明之前使用这个变量，它的值就是undefined，如：

执法环境
{
a:undefined，
}
var a=5;

函数的声明前置：
只有以声明方式创建的函数才会声明前置，函数声明前置允许在所属作用域内任何地方使用该函数，即使是在声明之前也不会报错。如：

执法环境
{
   f: 对函数的一个引用
}
  function f(){
    console.log("f")；
}

arguments 是什么？

arguments对象是所有函数中可用的局部变量,就是变量arguments是指向实参对象的引用，arguments对象是一个类数组对象（也就是说它不能能像数组一样pop,push），所以可以通过数字下标访问传入函数的实参的值，而不用通过参数名得到实参。一个函数， function f(x){},它只有一个形参，但是调用时传入了两个实参，f(1,2),第一实参可以通过x名得到，也可以通过arguments[0]得到，但是第二个实参只能通过arguments[1]得到。arguments和真正的数组一样，也有length属性，表示的是传入的实参的个数。如下

function f() {
  return arguments.length;
}

f(1, 2, 3) // 3
f(1) // 1

arguments 对象仅在函数内部有效，当调用的函数的参数数量比它显式声明的参数数量多的时候，就可以使用 arguments 对象。

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

在其他面向对象的语言中，重载函数是一个共有的特性，重载是指：传给函数不同数目的参数或者不同类型的参数时，函数将执行不同的操作。
在javascript中，先定义的函数，可以被后定义的同名函数覆盖，js函数的参数可以是不定的个数，任何不确定的值都是默认为undifined，因此Javascript不可以直接使用函数的重载，但是可以通过别的方式实现：
1.arguments参数

 //一个简单的发送消息的函数
     function  sendMessage(msg,obj){

         //如果同时提供一个消息和一个对象
         if(arguments.length==2){
             //就把消息发送给对象
             obj.handleMsg(msg);
         }else {
             //只显示该消息
             alert(msg);
         }
     }
参考《面向对象编程》

2.使用if(我感觉是同一个意思),在函数体内，根据不同的参数，调用执行不同的逻辑。

  function f(a,b,c){
        if(a){
            console.log(a);
        }
        if(b){
            console.log(b);
        }
        if(c){
            console.log(c);
        }
    }

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

立即执行函数是一个即使调用的函数表达式（Immediately-Invoked Function Expression），简称IIFE。可以使用立即调用的函数表达式来避免块内的变量提升 ，防止污染全局环境 。

求n!，用递归来实现

 function num(n){
        if(n<=1){
            return 1;
        }
        else {
            return n*num(n-1);
        }
    }

console.log(num(5))/120

以下代码输出什么？

 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:男,
         Arguments(3)  //因为传入了三个实参
         name:valley  //因为把第一个参数的值改了
  getInfo('小谷', 3);
            name:小谷,
            age:3,
            sex:undefined  //被省略的参数的值就变为undefined
            Arguments(2) //因为传入了2个实参
            name:valley  //因为把第一个参数的值改了
   getInfo('男');
            name:男, //保留前面的参数，省略后面的参数
            age:undefined,//被省略的参数的值就变为undefined
            sex:undefined  //被省略的参数的值就变为undefined
            Arguments(1) //因为传入了1个实参
            name:valley  //因为把第一个参数的值改了

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

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

如下代码的输出？为什么

console.log(a);// undefined,a声明提前了，但是赋值还在原来的位置，所以值是undefined
var a = 1;
console.log(b);//b is not defined ，b没有声明也没赋值。

如下代码的输出？为什么

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

声明方式创建的函数会声明前置，函数声明前置允许在所属作用域内任何地方使用该函数，因为sayName函数以声明方式创建的，声明前置，所以可以在声明之前调用，而sayAge是以表达式的方式创建的，当变量sayAge声明提前的时候，sayAge只是被声明了，并没有初始化，所以调用函数的时候，会提示sayAge is not a function。

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

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

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

    }

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

注：在当前的执行上下文内声明的函数，该函数的[[scope]]就是当前执行上下文的AO。
所以：
foo.[[scope]]=globalContext.AO (全局上下文的活动对象)
bar.[[scope]]=globalContext.AO (全局上下文的活动对象)
代码从上到下执行，调用bar的时候，进入到bar函数内，bar内声明了局部变量x,调用了foo,程序进入foo,foo的AO为空没有声明变量x，又因为foo是在全局作用域中声明的，所以foo.[[scope]]=globalContext.AO,所以在globalContext.AO找到了变量x，console.log(x),所以x为10。

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

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

globalContext={
   AO:{
     x:10
    bar:function
}
  Scope:null
}
barContext={
   AO:{
   x:30
   foo:function
}
Scope:bar.[[scope]]=globalContext.AO
}
fooContext={
   AO:{
       null
}
 Scope:foo.[[scope]]=barContext.AO
}

调用bar函数，在bar里声明了foo函数并调用，在调用foo函数的时候foo的AO对象是空的，所以从父级作用域链也就是barContext.AO找，在bar的AO里找到了x=30，所以最后结果是30.

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

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

globalContext={
   AO:{
     x:10
    bar:function
}
  Scope:null
}
barContext={
   AO:{
   x:30
  function
}
Scope:bar.[[scope]]=globalContext.AO
}
function={
   AO:{null}
   Scope:barContext
}
}

程序进入到bar函数里的时候，bar里声明了变量x,和一个立即执行函数 ，所以执行到立即执行函数的时候，先检查函数里的活动对象有没有x,没有x,又继续沿着作用域链一层一层的往上找，所以找到了bar函数的AO中的x,
最后输出30.

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

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()  //输出 undefined 5 1 6 20 
console.log(a)  //200

 globalContext={
   AO:{
       a:1-->a:200
        fn:function
        fn3:function
   }

}
进入fn(){},先扫描所有声明的变量和声明的函数，并声明前置
fnContext={
       AO:{
       a:undefined -->a:5--->a:(a++)=6-->var a 时 a已经存在，不变,a=6-->a=20      
       fn2:function
}
Scope:fn.[[scope]]=globalContext.AO
}
调用fn3(),进入fn3函数,里面没有声明a,所以在globalContext.AO中找到a=1，输出1。继续往下执行，a=200，因为fn3里没有声明a,所以把a=200赋值给globalContext.AO中的a,a=1变成a=200。
fn3Context={
       AO:{}
Scope:fn3.[[scope]]=globalContext.AO
}
 接着调用fn2(),进入fn2,fn2里也没有声明a,所以到fnContext.AO中找a，a=6,输出6，继续往下执行，a=20，因为fn2里没有声明a,所以把a=20赋值给fnContext.AO中的a,a=6变成a=20。再console.log(a)时，输出20，
fn2Context={
       AO:{}
Scope:fn2.[[scope]]=fnContext.AO
}
最后console.log(a)，此时globalContext.AO中的a变成200。