美文网首页
函数的实参 函数的形参 闭包 js

函数的实参 函数的形参 闭包 js

作者: 小小小8021 | 来源:发表于2018-07-15 02:23 被阅读7次

    函数的实参和形参

    可选形参

    if(a === undefined) a = [];
    

    等价于

    a = a || [];
    

    这两句是完全等价的,只不过后者需要提前声明a而已
    如果参数没有传入,其余的填充undefined
    可选的形式参数:通过注释/optional/来强调参数可选,并且要将其放在最后,否则就要使用null或者undefined来作为占位符来进行传入

    可变长的实参列表

    callee和caller

    callee为指代当前正在执行的函数
    caller指代当前正在执行函数的函数

    将对象属性用作实参

    >
    > function e(o){
    ...   return o.Object;
    ... }
    undefined
    > e;
    [Function: e]
    > var a = {Object:33};
    undefined
    > e(a);
    33
    >
    

    作为值的函数

    函数能作为值传入另外一个函数

    自定义函数属性

    函数属性可以自定义

    o.a = 3;
    function o() {
      return o.a;
    }
    
    此处输入图片的描述此处输入图片的描述

    作为命名空间的函数

    在函数中声明的变量在整个函数体内都是可见的(包括在嵌套函数中),在函数外部是不可见的。不在任何函数内声明的变量为全局变量。在整个js程序中都是可见的。在js中无法声明只在一个代码块内可见的变量的。所以常常简单的定义一个函数用作临时的命名空间。在这个命名空间内定义的变量都不会污染到全局命名空间。
    正是因为如果将变量定义在全局的时候,会出现变量的污染,污染到全局变量(好吧,这是动态语言的坑)导致出现一些未知的错误。所以呢将变量放置在函数中,在进行调用,这样放置其变量污染其全局空间,出现变量的冲突(尤其是在浏览器的环境下,很容易的,导致各种未知错误,所以必须要这样做)

    定义完函数后直接调用函数

    (
      function() {
        return 333;
      }()
    );
    

    加()是必须的,因为如果不加()会让js解释器认为其为函数声明,function按照函数声明来进行解释,js解释器不允许创建一个匿名的函数声明,所以会报错。
    加()变成一个函数表达式,js解释器运行创建一个匿名的函数表达式

    闭包

    终于到闭包了。(正经点Σ( ° △ °|||)︴)
    (这是最难的地方,是函数式编程的基础,也是能否学好js的最关键的地方。。。。当然了,es6还有一个令人讨厌的箭头函数)
    闭包是其函数式编程的重要的基础
    和其他语言一样js采用的词法作用域,即函数的执行依赖于变量的作用域,作用域是在函数定义时确定的,不是在其调用所决定的
    即js的函数对象的内部状态不仅仅包含函数的代码逻辑,还必须引用当前的作用域链(变量的作用域向下传递的,变量的作用域链在进行寻找的时候往上寻找,直到函数的顶部)函数对象可以通过作用域链相互关联起来,函数体内部的变量可以保存在函数作用域内,即闭包

    很古老滴术语,指函数变量可以被隐藏于作用域链之内,因此看起来函数将变量包裹起来。

    如何定义作用域链

    作用域链为一个对象的列表,每次调用js函数的时候,都会创建一个新的对象来保存其局部变量,把这个对象添加到作用域链中,如果函数返回,就从作用域链中将绑定的对象删除,如果不存在嵌套函数,也不存在其引用指向这个绑定的对象,会被js解释器的垃圾回收机制不定时的回收,是不定时的,不是在没有完全引用的时候立马删除,如果定义了嵌套函数,每个嵌套函数都各自对应着一个作用域链,并且这个作用域链指向一个变量绑定的对象。如果这些嵌套函数对象在外部函数中保存下来,那么他们也会和所指向的变量绑定对象一样当做垃圾进行回收,如果这个函数定义了嵌套的函数,并将它作为返回值返回,或者存储在某处属性里,会有外部引用指向这个嵌套函数,即不会被当做垃圾回收,其变量所绑定的对象也不会当做垃圾进行回收。

    函数执行完毕以后相关的作用域链不会删除,只有当不在有引用的时候,才会进行删除操作

    此处输入图片的描述此处输入图片的描述

    关于栈的说明

    原始栈
    栈顶 window
    执行下列js脚本

    function a() {
      function f() {
        return 333;
      }
      return f;
    }
    a()();
    

    栈顶 a → window
    开始调用,执行到return
    发现需要调用f
    继续加栈
    栈顶 f → a → window
    执行完f弹出f
    继续执行a,执行完毕弹出a
    最后全部执行完毕弹出window

    算了文字解释太无力,直接上代码

    var scope = "global scope"; // 一个全局变量
    function checkscope() 
    {
      
      var scope = "local scope";  // 定义一个局部变量
      
      function f() 
      {
        return scope; // 返回变量作用域中的scope的值
      }
      
      return f(); // 返回这个函数
    }
    

    调用一下这个函数

    checkscope();
    "local scope"
    

    接着这样执行

    var scope = "global scope"; // 一个全局变量
    function checkscope() 
    {
      
      var scope = "local scope";  // 定义一个局部变量
      
      function f() 
      {
        return scope; // 返回变量作用域中的scope的值
      }
      
      return f; // 返回这个函数
    }
    

    继续调用函数

    checkscope()();
    "local scope"
    

    闭包有什么用

    先看一个函数uniqueInteger()使用这个函数能够跟踪上次的返回值

    var uniqueInteger = (
      function() {
        var count = 0;
        return function() {return count++}
      }()
    );
    

    这样子就使用闭包

    uniqueInteger();
    0
    uniqueInteger();
    1
    

    每次返回是其上一次的值,并随便直接将值加1
    至于为什么要这样写,如果不使用闭包,那么恶意代码就可以随便的将计数器重置了。。

    uniqueInteger.count = 0;
    function uniqueInteger() {
      return uniqueInteger.count++;
    }
    

    类似这样的,完全可以做到直接通过赋值,将其count的值重置。
    而如果使用闭包,没有办法进行修改,为私有状态,也不会导致其一个页面内变量的冲突,或者是其覆盖。

    立即调用的函数

    var a = (function c(){
      var a = 1;
      a++;
      console.log('已经执行');
      return function b(){return a++};
    }())
    

    额,我大概解释一下这段代码。
    首先呢,解释最外层的圆括号,因为如果没有圆括号,则这个是一个赋值语句,将一个匿名函数赋值给变量a,实际上是在内存中完成了栈中变量a指向匿名函数存储的空间的地址,如果有圆括号,实际上是告诉js解释器这是一个语句,需要js执行,消除了其function带来的影响。(ps;貌似火狐上不加也可以,也可以正常的运行)执行和引用的关系下方有。
    然后呢,最后的圆括号,代表着其执行这个函数,因为js解析器将()解析为调用前方的函数名称,类似于运算符吧。但是实际上并不是运算符,因为能往其内传值,注意,这点是将其执行的结果保存在堆中,并完成其指向
    其后,当直接输入a;,实际上执行并完成了一次调用,其返回值为函数b,将函数b完成一次引用,即变量a引用函数b,由于其存在引用关系,即栈中变量a保存的为其函数a的返回结果,(因为其不是不是对象,如果写a()()表示将函数a调用后返回的对象保存在栈中,然后将栈中的内容再次调用,由于是保存,并不存在其应用关系,所以执行完毕后直接垃圾回收)由于其保存的是函数b的作用域链,而函数b的作用域链是继承自函数a的作用域链,但是由于函数a的作用域链并没有引用导致其执行完后被垃圾回收(当不在有变量指向的时候)。所以呢,函数其值是在函数b中进行保存,如果修改函数c此时函数c并不会影响到函数b中的保存,因为其函数c的变量列表已被销毁,
    最后,继续讨论起嵌套函数的引用,由于其父函数已被销毁,但是嵌套函数被引用,(注意:因为其父已经没有,所以是另开辟一块新的堆空间,用于存储其函数c的返回结果,注意是返回结果,而不是函数b)此时另外指定变量保存其结果,无论指定多少个变量保存其结果,都是新的空间的执行,没有任何的干扰,详细了解看下面,继续讨论

    1. ps;如果是()()则代表其会被其垃圾回收
    2. ps 还需要注意一点点的是由于其引用的是result的值,并不是其

    最后,这样就能完成其变量保存在函数中,貌似叫做记忆?

    所以呢,借助堆和栈就很好的能理解了闭包

    再继续看代码

    function count() {
      var n = 0;
      return {
        count: function() { return n++; },
        reset: function() { n = 0; }
      };
    }
    
    var c = count(); var d = count();
    undefined
    

    在分别执行一下下

    c.count();
    0
    d.count();
    0
    c.count();
    1
    d.count();
    1
    c.reset();
    undefined
    c.count();
    0
    d.count();
    2
    

    这一点体现了其互不影响性,表明其由于其父被回收,导致其子分别开创了一块在堆中新的内存空间,并完成其指向,互相不干扰。
    其作用域链互不干扰

    使用getter和setter完成其闭包

    function count(n) {
      return {
        get count() { return n++; },
        set count(m) { 
          if ( m >= n)
            n = m;
          else
            throw new Error( '请输入一个正确的值' );
        },
      };
    }
    

    这个就不用解释啦,很简单啦

    同一个作用域链中定义两个闭包

    function test1() {
      val = value = 111;
      this.test = function() { return value - 1; };
      this.test2 = function() { return value + 1; };
      
    }
    

    这同样是两个作用链域
    不过这样写需要先执行其o.test1(),因为其方法在其函数内部,必须先执行一下,完成其方法的添加,否则会报错,

    ee.test is not a function
    

    提示找不到这个方法,
    因为执行

    ee.test1 = test1;
    function test1()
    

    只是简单的进行赋值,并不能进行查看,所以导致其无法使用
    所以嘛,要先执行一遍,让其方法添加进去

    ee.test1();
    undefined
    ee.test();
    110
    ee.test2();
    112
    

    这就是两个闭包,这两个闭包互相平行,同时继承于其父,但是又不受其父影响,很神奇吧,(@ο@)

    叮 又发现一个莫名奇妙的东东 https://us.leancloud.cn 貌似目前水平能看懂一些了

    关于this的问题

    this在父闭包显示的即为使用该方法的对象。
    但是子就不一定了。

    function test1() {
      val = value = 111;
      this.test = function() { return this.x - 1; };
      this.test2 = function() { return this.x + 1; };
    }
    

    执行一下

    ee.test();
    4443
    

    这就尴尬了。
    好吧。只能说是一般不这样用
    一般这样写

    var self = this;
    

    将其值保存进一个self中

    相关文章

      网友评论

          本文标题:函数的实参 函数的形参 闭包 js

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