美文网首页
JS函数与作用域

JS函数与作用域

作者: hhg121 | 来源:发表于2017-06-13 17:20 被阅读20次

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

    函数声明:function functionname(){}
    函数表达式:var fn = function(){};

    函数声明会前置,因此,函数调用可以放在函数声明之前。函数表达式不会前置,函数调用需放到函数表达式之后。

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

    在一个作用域下,var 声明的变量和function 声明的函数会前置

    console.log(a); //undefined  声明前置,可以在a声明之前使用变量a,但由于a没有赋值,所以输出undefined
    var a = 3;
    console.log(a); //3
    
    sayHello();//函数声明前置,所以可以在其之前使用
    
    function sayHello(){
      console.log('hello');
    }
    

    arguments 是什么

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

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

    arguments对象不是一个 Array 。它类似于数组,但除了 长度之外没有任何数组属性。

    函数的"重载"怎样实现

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

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

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

    (function(){})()
    

    由于javascript没有块级作用域,所以我们可以利用函数来构造作用域。

    求n!,用递归来实现

    function factorial(n){
      if(n==1)
        return n;
      else
        return n*factorial(n-1);
    }
    console.log(factorial(4));
    

    以下代码输出什么?

    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: 男  
    [object Arguments] {
      0: "饥人谷",
      1: 2,
      2: "男"
    }
    name: valley
    
    getInfo('小谷', 3);
    //name: 小谷  age: 3   sex: undefined
    [object Arguments] {
      0: "小谷",
      1: 3,
    }
    name: valley
    
    getInfo('男');
    //name: 男  age: undefined   sex: undefined
    [object Arguments] {
      0: "男",
    }
    name: valley
    

    写一个函数,返回参数的平方和?

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

    如下代码的输出?为什么

    console.log(a);      //undefined 变量声明前置,但没有赋值,所以是undefined
    var a = 1;
    console.log(b);   //error  未定义b
    

    如下代码的输出?为什么

    //函数声明和函数表达式的区别
    sayName('world');                   // hello: world
    sayAge(10);                           //error  
    function sayName(name){
        console.log('hello ', name);
    }
    var sayAge = function(age){
        console.log(age);
    };
    

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

    var x = 10
    bar()               //10
    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
    fooContext = {
    AO:{},
    Scope: foo.[[scope]] 
    }
    barContext = {
    AO:{
    x:30
    },
    Scope: bar.[[scope]] 
    }
    

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

    var x = 10;
    bar()                 //30
    function bar(){
      var x = 30;
      (function (){
        console.log(x)
      })()
    }
    
    globalContext = {
      AO: {
        x: 10
        bar: function
      },
      Scope: null
    }
    bar.[[scope]] = globalContext.AO
    
    barContext = {
      AO: {
        x: 30
        foo: function
      },
      Scope: bar.[[scope]] 
    }
    foo.[[scope]] = barContext.AO
    
    fooContext = {
      AO: {},
      Scope: foo.[[scope]] 
    }
    

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

    var x = 10;
    bar()                     //30
    function bar(){
      var x = 30;
      (function (){
        console.log(x)
      })()
    }
    
    globalContext = {
      AO: {
        x: 10
        bar: function
      },
      Scope: null
    }
    bar.[[scope]] = globalContext.AO
    
    barContext = {
      AO: {
        x: 30
        foo: function
      },
      Scope: bar.[[scope]] 
    }
    function.[[scope]] = barContext.AO
    
    functionContext = {
      AO: {},
      Scope: function.[[scope]] 
    }
    

    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
        fn: function
        fn3: function
      },
      Scope: null
    }
    //fn声明时,自动生成作用域链引用
    fn.[[scope]] = globalContext.AO
    fn3.[[scope]] = globalContext.AO
    
    fnContext = {
      AO: {
        a: 5
        fn2: function
      },
      Scope: fn.[[scope]] 
    }
    fn2.[[scope]] = fnContext.AO
    
    fn3Context = {
      AO: {},
      Scope: fn3.[[scope]] 
    }
    
    fn2Context = {
      AO: {},
      Scope: fn2.[[scope]] 
    }
    
    var a = 1;          //我称global的a为ga   fn中a为ia
    function fn(){
      console.log(a) //  undefined   ia声明了,但未赋值
      var a = 5
      console.log(a) //   5   ia
      a++            //   ia=6                        
      var a
      fn3()          //  1  ga=200
      fn2()         //   6  ia=20
      console.log(a)   //  20   ia
      function fn2(){
        console.log(a)
        a = 20
      }
    }
    function fn3(){
      console.log(a)
      a = 200
    }
    fn()
    console.log(a)   //200   ga
    

    相关文章

      网友评论

          本文标题:JS函数与作用域

          本文链接:https://www.haomeiwen.com/subject/edhdqxtx.html