函数和作用域

作者: Schrodinger的猫 | 来源:发表于2017-06-15 20:32 被阅读0次

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

函数声明必须有标识符，也就是常说的函数名；函数表达式可以省略函数名.函数声明会提前；对于函数表达式，函数调用只有在函数表达式声明后调用；

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

变量的声明前置是指执行代码之前会先读取变量的声明，在执行的过程中进行赋值， var a=2;一般分为两步 var a 声明一个变量 a 会放在最前面，然后在进行赋值 a=2；
函数的声明前置意思是在执行代码之前会先读取函数声明。这就意味着可以把函数声明放在调用它的语句后面。

3.arguments 是什么?

在函数内部,你可以使用arguments对象获取到该函数的所有传入参数，是我们传入函数内的实参；所有的函数都有属于自己的一个arguments对象，它包括了函所要调用的参数。他不是一个数组，如果用typeof arguments，返回的是’object’。虽然我们可以用调用数据的方法来调用arguments。比如length,还有index方法。但是数组的push和pop对象是不适用的。

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

js中是没有重载的；如果想实现类似函数重载，我们可以判断传入函数内部的参数的类型和数目来执行函数。注：js判断传入参数数量可以用arguments.length这个属性来判断；判断类型：
1.用 typeof 语句判断变量类型，typeof语句返回类型对应的字符串。
2.用 instanceof 语句判断变量类型，instanceof语句返回true/false。
3.用 constructor 属性判断变量类型，这个属性返回用来构造该变量的构造函数引用。

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

立即执行函数模式是一种语法，可以让你的函数在定义后立即被执行；这种模式本质上就是函数表达式，在创建后立即执行。因为函数的声明是不可以跟圆括号的，但是函数的表达式可以；要将函数声明转换成函数表达式，就可以在声明外面加一对括号。在javascript里，括号内部不能包含语句，当解析器对代码进行解释的时候，先碰到了()，然后碰到function关键字就会自动将()里面的代码识别为函数表达式而不是函数声明。

//最常用的模式
(function () {  
    alert('hello world!');  
})(); 
//第二种模式
(function () {  
    alert('watch out!');  
}());  
//还有许多模式

作用：临时需要变量的时候，可以创建私有作用域，这样不会污染到全局，避免了全局变量过多，防止命名冲突；同时匿名函数执行完毕后，会立即销毁函数内部变量，而匿名函数又是一个闭包，可以访问自身作用域链中的所有变量。这种做法可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域链了。

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

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

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: 男 ；Arguments(3) { " valley",2," 男 " }；name valley
getInfo('小谷', 3);// 输出 name:小谷；age: 3；sex: undefined ；Arguments(2) { " valley",3}；name valley
getInfo('男');// 输出 name:男；age:  undefined ；sex: undefined ；Arguments(1) { " valley"}；name valley

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

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

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

    console.log(a); //undefined   变量声明提升，但赋值在后 所以为undefined
    var a = 1;
    console.log(b);//报错 b is not defined

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

    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);
    };

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

var x = 10;
bar() ;
function foo() {
  console.log(x);
}
function bar(){
  var x = 30;
  foo();
}
//分析
globalContext = {
  //全局执行上下文
  AO:{
          x:10,
          foo:function(){},
          bar:function(){}
       },
  Scope = null;
  };
foo.[[Scope]] = globalContext.AO;
bar.[[Scope]] = globalContext.AO;
bar执行的时候进入bar的执行上下文：
barContext = {
      //bar的执行上下文
      AO:{
          x:30
          },
    Scope:bar.[[Scope]]
}
fooContext = {
       //foo的执行上下文
         AO:{
             },
     Scope:foo.[[Scope]]
}

分析：首先将变量声明函数声明提升；执行bar函数进入bar函数的执行上下文；bar函数执行过程中执行foo函数，会先在bar的AO中寻找foo函数，没有再进入bar.[[Scope]]寻找。执行foo函数进入foo函数的执行上下文，执行console.log(x)；首先在foo自己的AO中找x，没有就进入foo.[[Scope]]中寻找所以console.log(x)打印出来的值为10；

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

 var x = 10;
  bar(); 
 function bar(){
   var x = 30;
  function foo(){
       console.log(x); 
       }
    foo();
}   
//全局执行上下文：
globalContext = {
      AO:{
         x:10,
          bar:function(){}  
        }
        Scope:null
    }
bar.[[Scope]] = globalContext.AO;
//bar的执行上下文
 barContext = {
        AO:{
          x:30,
          foo:function(){}
             },
          Scope: bar.[[Scope]] 
    }
foo.[[Scope]] = barContext.AO;
//foo的执行上下文
 fooContext = {
        AO:{
        },
        Scope:foo.[[Scope]]
  }

分析：先进行全局和函数内部的变量声明提升函数声明提升，执行bar函数先在globalContext.AO中寻找函数bar，执行bar函数进入bar函数的执行上下文；bar函数内部执行foo函数先在barContext.AO 中寻找foo函数找到后执行console.log(x)；x先在fooContext.AO中寻找，没有进入foo.[[Scope]]寻找也就是 barContext.AO中寻找x=30，所以打印结果为30.

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

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

分析：同上因为立即执行函数可以看做一个函数表达式类似于var fn = function(){}; 然后立即执行fn();匿名函数执行上下文的Scope属性为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);

分析过程：
首先在全局和函数内部进行变量声明提升和函数声明提升；

//全局执行上下文：
        globalContext = {
            AO:{
            a:1,//变化顺序1;200
            fn:function(){},
            fn3:function(){}    
            },
            Scope:null
        }
        fn.[[Scope]] = globalContext.AO;
        fn3.[[Scope]] = globalContext.AO;
        //fn函数执行上下文:
        fnContext = {
            AO:{
            a:,//执行过程a值得变化  undefined;5;6;20
            fn2:function(){}    
            },
            Scope:fn.[[Scope]]
        }
        fn2.[[Scope]] = fnContext.AO;
        //fn2的执行上下文
        fn2Context = {
            AO:{
                
            },
            Scope:fn2.[[Scope]]
        }
        //fn3的执行上下文
        fn3Context = {
            AO:{
            
            },
            Scope:fn3.[[Scope]]
        }

执行程序分析：全局环境下执行fn,在globalContext.AO中找到fn函数执行fn,第一次console.log(a),在fnContext.AO找到a只声明未赋值为undefined,对a赋值5,第二次console.log(a)结果为5,a++ a为6,var a重新声明a不会对a值产生影响,执行fn3函数进入fn3函数的执行上下文,console.log(a),先在fn3Context.AO中寻找a,全局声明的a找不到,在fn3.[[Scope]]中找到全局的var a = 1;console.log(a)即为1;随后全局的a被赋值为200,继续往下执行fn2进入fn2的执行上下文,首先在fn2Context.AO中寻找a,没有进入fn2.[[Scope]]寻找此时a为a++后的6,打印出6;随后a = 20修改了fn执行上下文的a为20;再在fn内部console.log(a),得到20;最后在全局console.log(a),此时全局的a为200;最后打印结果为undefined 5 1 6 20 200