ES6学习之路~~作用域和闭包(Scope and closure)

制造业批次管理中双计量单位动态转换的实践指南 本文详细介绍了制造业批次管理中双计量单位动态转换的实践指南,特别是在SAP系统中的配置与操作步骤。通过实际案例展示了如何解决采购与生产部门计量单位不一致的问题,提升物料管理效率。重点讲解了批次特性配置、移动类型调整及常见问题排查方法,适用于金属加工、化工等多个行业。 阅读详情

Scope and closure(作用域和闭包)

  • 作用域和闭包 是所有js都有的,也是写js一直写到的,为什么在这里还要做一次笔记呢?原因有二:
    1. 作用域和闭包对于新手来说不太好理解,我希望通过我的笔记,能让刚入行的朋友们在面试时不会死在这个小细节上;
    2. 在es6中多了点新玩法,我想在这里分享给大家,有错误希望可以批评指正;
  • 当然了,你在看这篇笔记时,需要你是写过一些js的。。。

作用域概念

  • 编程语言最基本的功能之一就是能存储变量中的值,设计良好的规则来存储变量的值并且之后可以方便的找到这些变量的规则被称为作用域。
  • 简言之: 作用域就是能放变量的值并且能被调用的到区域(我自己浅显的理解。。。)
  • 为了进一步理解这苦涩难懂的东西,我们来看看js的编译原理:
    1. 第一步: 词法分析
      eg: var a = 2; 会被分解为对编程来说有意义的词法单元: var、 a、 =、 2、 ; 五部分形成词法单元流数组[‘var’,’a’,=,2,’;’]
    2. 第二步: 语法分析
      eg: (将词法单元流转换为一个逐级嵌套的“抽象语法树”),上面的var a = 2; 最顶层是var节点,再往下是一个变量a和一个“=”,再往下就是一个number节点,值为2,最后遇到“;”表示结束
    3. 第三步: 代码生成
      eg: 根据抽象语法树将var a = 2; 转化为一组机器指令,用来创建一个叫做a的变量,并将一个number类型的值存储在其中。
  • 接下来再看看浏览器引擎执行程序的原理:
    var a = 2; 在编译后,会被分两步执行:

    1. 执行var a , 此时如果同一作用域集合中没有变量a就会给a创建一个内存存储,有的话就会忽略,进入下一步
    2. 执行赋值 a = 2,对已有的变量赋值。
    3. 对于编译器来说,上面第一步操作叫做查询(LHS),第二步操作叫右查询(RHS)。通俗的说: 找赋值操作的目标–>LHS,找赋值操作的源头–> RHS。
        fucntion foo(a){
            var b = a;
            return a + b;
        }
        var c = foo(2);
        //LHS有三处: a=2、 b、 c
        //RHS有四处: =a、 =foo(2..、 ..b、 a.. 
  • 作用域嵌套: 引擎查找变量(LHS)会先在内部作用域查找,没找到会向上级作用域找,直到找完全局作用域为止,若仍未找到,会报ReferenceError错

词法作用域

  • js的作用域在ES6之前主要是两种: 词法作用域和动态作用域,ES6新增块作用域(oh,no no no! ES3以后就有了一个有着块作用域的写法,只是没人会去用它而已。所以这算不上新增,不然编译器也没法把ES6的块作用域写法编译为浏览器认识的ES5,这里先放着后边说)。
  • 大多标准语言编译器的第一个工作阶段都是词法化
  • 词法作用域示例:

        function foo(a){
            var b = a * 2;
            function bar(c){
                console.log(a,b,c);
            }
            bar (b * 3);
        }
        foo(2);     // 2 4 12

    这个例子中有三个逐级嵌套的作用域:

    1. 包含整个全局的作用域,其中只有foo一个标识符;
    2. 包含在foo内部的foo创建的作用域,包含: a、 bar 和 b ;
    3. 包含bar所创建的作用域,包含标识符: c
  • 动态作用域都是由函数被申明时所处的位置决定

        var b = 3;
        function foo(){
            var b = 2;
            bar(b);
        }
        function bar(x){
            console.log(x);
        }
        foo();  // 输出结果为3 ,而不是2

    事实上,javascript并不具有动态作用域,上面的表现,也是此法作用域,唯一的区别就是this是在运行期间确定的作用范围,,this机制在某种程度上很像动态作用域。

  • 欺骗词法: eval() 和 with(现已不推荐使用,关键我也不会用^_^…………)

        var b = 2;
        function foo(str,a){
            eval(str);
            console.log(a,b);
        }
        foo("var b = 3", 1);        // 1, 3     

    此处foo外申明的b表示受到了欺骗,因为在执行时,eval把字符串“var b = 3;”解释成了js语句,插入到了foo的内部作用域,所以会优先找内部的b并打印内部的b

函数作用域和块作用域

  • 每申明一个function都会创建一个函数作用域:

        function foo(a){
            var b = 2;
            function bar(){
                var c = 3;
                console.log(b,c);
            }
        }
        foo(1);     // 2 , 3
        bar();      // RefenceError 

    标识符 a、 b 和 bar 都是附属于foo作用域的,c 是附属于 foo 内的 bar 的作用域的,作用域访问原则是内部可以访问外部,未暴露内部作用域,外部不能访问内部,所以上例中找不到 bar 而报错。

  • 变量和函数的外部隐藏和内部实现:

        function foo(){
            var a = 1;
            bar();
        }
        function bar(){
            console.log(a);
        }
        var a;

    上面的函数,严格来说,a 和 bar 都应该是 foo 私有的,因为除了foo 没其他地方使用 a 和 bar ,放在foo外面就显得不太安全了,可能获取不到目标值,或调用 bar 时出现冲突等等。下面对写法就相对安全很多了

        function foo(){
            var a = 1;
            (function bar(){
                console.log(a);
            })();
        }
  • 立即执行函数 :(上面示例foo中的bar就是立即执行函数)
    两种写法:

        (function(){
            console.log(a);
        }())
    
        (function(){
            console.log(a);
        })();

    立即执行函数在编译完就会自己调用自己,执行一次

  • 块作用域

    1. 什么是块作用域?
        for(var i = 0; i < 10; i ++){
            console.log(i);
        }
        console.log(i);     //10

    本应该只在for循环内部有效的变量i,为什么被污染到外面了?
    如果在for循环内部生成一个块,限制变量泄漏出去?这样的作用域是不是更安全呢?
    表面上,ES6之前貌似不能实现呢。。。

    1. ES6以前的块作用域 try{}catch(err){}
        try{
            undefined();
        }catch(err){
            for(var i = 0; i < 10; i ++){
                console.log(i);
            }
        }
        console.log(i);     // ReferenceError

    catch(){}中的变量i居然没泄漏出来!!!

    1. ES6的块作用域: let 和 const 申明(详见上一篇笔记)
    2. 来点有趣的: babel等转码工具怎么将let申明转换为现在浏览器兼容的代码?
        {
            let a = 2;
            console.log(a);     // 2
        }
        console,log(a);     //ReferenceError
    
        //  babel 等转码黑魔法 ----->>>
    
        try{
            throw 2;
        }catch(a){
            console.log(a);     // 2
        }
        console.log(a);     //ReferenceError

    目的达到了,转码成功!!!

    1. 论块作用域的重要性:
        for(var i = 0; i < 10; i++){
            setTimeout(function(){
                console.log(i);     // 每秒打印1次10,打印10次
            },i*1000);
        }

    好像不符合写这段代码的初衷呢,我只想每秒递增打印数字而已!!!
    改写:

        for(var i = 0; i < 10; i ++){
            (function(){
                setTimeout(function(){
                    console.log(i)
                },i * 1000)
            }())
        }

    完全一样,没发生变化啊,再改写:

        for(var i = 0; i < 10; i ++){
            (function(){
                var j = i;
                setTimeout(function(){
                    console.log(j)
                },j * 1000)
            }())
        }

    终于好了,但是我想说,这么麻烦的写法,真的好么?还能简化点儿。。。

        for(var i = 0; i < 10; i ++){
            (function(j){
                setTimeout(function(){
                    console.log(j)
                },j * 1000)
            }(i))
        }

    好吧,依然复杂。。。
    来看看块作用域在这里的优秀表现吧:

        for(let i = 0; i < 10; i ++){
            setTimeout(function(){
                console.log(i);
            }, i * 1000)
        }

    我就想问下,还有谁???
    每循环一次,let都会创建一个块作用域,这个块儿作用域里的setTimeout()不会受到其他块作用域里的i的值影响,所以会正确执行
    块作用域更多神奇表现希望可以在各位大神的代码中体现

作用域闭包

  • 闭包是面试中很多人都会问到的,希望看完这一节,你会说:函数闭包我天天见,但我就是不知道这是闭包,也不知道为什么把它叫做闭包。。。Orz
  • 讨论了那么多词法作用域,你可能还不知道,闭包是基于词法作用域书写代码时所产生的自然结果,你甚至不需要为了利用它而有意识的创建闭包,闭包在你的代码中随处可见,你缺少的知识识别、影响它的思维环境。。。
  • 定义: 当函数可以记住并访问所在的词法作用域时,就产生理闭包,即使是在当前此法作用于外执行该函数(联想下上面所说的动态作用域)。

        function foo(){
            var a = 2;
            function bar(){
                console.log(a); 
            }
            bar();
        }
        foo();      //  2   这里的bar就是一个闭包函数
  • 特点: 闭包函数可以访问所处的词法作用域的变量,但当前词法作用域的父级函数不能直接访问闭包函数内的变量

        function foo(){
            var a = 2;
            function bar(){
                var b = 3;
                console.log(a,b);       // 没错的
            }
            console.log(a,b)        // b is not defined
        }
  • 闭包的效果

        function foo(){
            var a = 2;
            function bar(){
                console.log(a);
            }
            return bar;
        }
        var brz = foo();
        brz();      // 2
    
  • 闭包的强大威力表现 —— 模块

        // 再看上面的代码
        function foo(){
            var a = 2;
            function bar(){
                console.log(a);
            }
            return{
                bar: bar
            };
        }
        var brz = foo();
        brz.bar();          // 2

    好神奇诶!!!,居然成功的调用出了bar!!!
    来剖析下原理:

    1. foo()是一个函数,里面有一个闭包函数 bar
    2. bar 被当作返回值return暴露出来了
    3. foo()被调用了一次,并且将调用结果赋值给了brz(用模块化的话来说就是foo()是一个函数,必须通过调用它来创建一个模块实例)
    4. brz里面就有了bar()这个方法,bar是在foo()内部申明的一个闭包函数,调用bar时会获取到foo的作用域,得到 a = 2 ;
      这里就是模块的雏形 … …

模块模式必须的两个条件:
1. 必须有外部封装函数,并且至少被调用一次(每次调用都会创建一个新的模块实例)
1. 封闭函数必须返回至少一个内部函数,这样内部函数才能在私有作用域中形成闭包,并且可以访问并且修改私有的状态

```
    var brz = (function foo(){
        var a = 2;
        function bar(){
            console.log(a);
        }
        return{
            bar: bar
        };
    })();
    brz.bar();          // 2
```

这里把foo变成IIFE(立即执行函数)并赋值给brz,然后在下面直接调用brz.bar(),简化写法

  • ES6的模块机制:
    ES6为模块增加了一级语法支持,但是通过模块加载时ES6会将文件当作独立的模块来处理,所以ES6的模块没有“行内式”,必须被定义在独立的文件中:

        // bar.js
        function hello(who){
            return "let me introduce :" + who; 
        }
        export hello;
    
        // foo.js
        // 仅从 bar 导入模块 hello
        import hello from "./bar"
        bar hungry = "hippo";
        function awesome(){
            console.log(hello(hungry).toUpperCase());
        }
        export awesome;
    
        // brz.js
        // 导入完整的 foo 和 bar 模块
        module foo from "./foo";
        module bar from "./bar";
        console.log(
            bar.hello("fhino");     // let me introduce : hippo
        )
        foo.awesome();      // let me introduce : hippo

更多的模块机制后续学习中在详述… …
敬请期待下期*_*

三、Crowd与JIRA、Confluence用户集成并SSO单点登录 补充说明: 通过此方法集成后,用户、组以及用户和组的关系都在Crowd系统中存储,但各个系统的权限仍由各系统控制,也可在JIRA和Confluence中添加和删除用户。 在做步骤4和步骤5的时候,要特别小心,确保当前系统的超级权限用户(一般为admin,具体看当前系统的全局权限配置)和组以及它们的关系已经在Crowd中同样存在了,才可切换并禁用当前系统的内部用户目录,否则可能造成权限丢失等严重问题(因为禁用了内部用户目录,而Crowd中又不存在这个超级权限用户和组或它们的关系,所以权限就丢失了) 维护示例 阅读详情

相关推荐

【AI智能体】Coze 搭建个人旅游规划助手实战详解

本文将详细介绍如何使用Coze平台搭建个人旅游规划助手。首先概述了AI智能体如何简化传统复杂任务的开发流程,然后重点介绍了Coze工作流的作用和核心节点类型(包括大模型、插件、知识库等)。通过实际操作演示,从创建智能体到配置多级工作流,逐步实现旅游规划功能:解析用户输入时间地点、查询必玩景点、获取景点详细信息等。该教程展示了如何利用Coze的可视化编排能力,即使非技术人员也能快速构建专业级AI应用。最终呈现的旅游助手可提供天气查询、行程建议等一站式服务。

Hello, New World! 2121

ES6之 Module

20 Module ES6 的 Class 只是面向对象编程的语法糖,升级了 ES5 的构造函数的原型链继承的写法,并没有解决模块化问题。 Module 功能就是为了解决这个问题而 提出的。 历史上, JavaScript 一直没有模块( module )体系,无法将一个大程序拆分成互相依赖的小文件,再用简单的方法拼装起来。其他语言都有这项功能, 比如 Ruby 的require、 Python ...

low666的博客 1040

NAO V6 开发环境的配置(附所有文件)

NAO V6开发环境配置前言环境Robot SettingsChoregraphe 2.8.5.10python2.7+naoqi2.8+opencv4.1.0putty与FileZilla 前言 学校的机器人摸索了一段时间,之前摸爬滚打探索环境,之前没接触这类机器人可能会非常艰辛,希望能给需要的人一些帮助。Nao与pepper通用 环境 win10(x64)+naoqi2.8 1、Robot S...

wbhhello的博客 3221

JavaScript ES6和ES5的闭包

JavaScript ES6和ES5的闭包的语法的小不同

谢萌新 630

手把手教你学Simulink--单相逆变器模糊逻辑控制策略仿真

本文介绍了在Simulink中设计单相逆变器模糊逻辑控制策略的完整流程。主要包括:1)构建单相逆变器模型;2)使用FuzzyLogicToolbox设计模糊控制器,定义输入输出变量和模糊规则;3)将控制器集成到Simulink模型;4)添加干扰源和示波器;5)配置仿真参数并分析结果。该方法利用模糊控制处理非线性系统的优势,可实现输出电压的精确跟踪,具有良好的鲁棒性。文中提供了详细的步骤说明和示例代码,强调准确设计隶属函数和规则库对控制性能的关键作用。该仿真设计为电力电子控制系统的开发提供了有效支持。

MHD0815的博客 203

基于YOLOv8的MVTec AD缺陷检测系统设计与实现

速度快,精度高;支持 anchor-free 架构;支持实例分割和图像分类;模块化代码,易于部署与改进;完美兼容 ONNX、TensorRT 等推理框架;官方支持多平台训练和推理(CPU/GPU)。YOLOv8 是工业视觉检测落地非常理想的选择。MVTec AD(Anomaly Detection)数据集包括15类工业对象,每个对象包括多个子类缺陷(例如 “scratch”, “crack”, “hole”)及正常图像。类别缺陷子类bottlecablecapsule。

YOLO 934

ES6闭包

作用域、闭包、闭包的使用场景

m0_65729457的博客 1160

2026年佰维存储数字IC笔试试卷带答案

建立时间是有效时钟沿到来前,输入数据必须稳定保持的最短时间。保持时间是有效时钟沿到来后,输入数据必须继续稳定保持的最短时间。

Open 104

es6中闭包的详解

es6中的闭包的详解

weixin_51938803的博客 451

SST专题(2-2)MMC-SST 输入级的工作原理及数学模型

本文研究了MMC-SST和iMMC-SST的电路结构及工作原理。系统由前级MMC电路和后级DC/DC电路组成,MMC负责电能转换和能量存储,DC/DC电路进行电压电流调节。重点分析了半桥型子模块(SM)的开关组态和工作原理,建立了平均值模型,推导了上下桥臂电压方程和环流特性。研究表明,通过合理控制子模块充放电模态可维持端口电压平衡,上下桥臂电压调控可影响网侧功率吸收,而环流特性对中压直流侧电压具有重要影响。

嵌入式老牛的博客 774

Cloud Connector RFC 访问控制深度实践:为 SAP BTP ABAP environment 打通安全、可控的远程连接

本文是一份面向企业ABAP团队与平台工程团队的Cloud Connector RFC访问控制配置指南。文章详细介绍了虚拟主机/实例号、负载均衡、资源白名单等核心概念,并提供了从零开始的配置流程。主要内容包括:通过Cloud Connector建立安全隧道的价值(零暴露、最小权限)、两种连接类型(无负载均衡/带负载均衡)的配置方法、资源白名单设置技巧,以及两个典型应用场景(Custom Code Migration远程检查与BAPI调用)的实操案例。指南基于SAP官方文档,包含落地经验与避坑建议,可帮助团队快

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 147

ES6 scope(作用域)

ES6 scope(作用域) 作用域 : 1.全局作用域(global) 2.函数作用域(function) 全局作用域 var a=1; console.log(a);//1 //{}表示语句块 if(a==1){ var b=2; console.log(b);//2 } console.log(b); for (var c = 0; c < 10; ...

weixin_30659829的博客 156

火灾图像检测识别:cnn卷积神经网络 Adaboost 支持向量机 随机森林 决策树 完整代码数据

火灾图像检测识别:cnn卷积神经网络 Adaboost 支持向量机 随机森林 决策树 完整代码数据

865

ReferenceError require is not defined in ES module scope, you can use import instead

运行的第一个node.js,在package.json中增加了 "type": "module",然后自己傻憨憨看node API 的fs,学着里面写了下面的代码,报错,因为require不是定义在ES module里的,需要改成import。 const fs = require('fs'); fs.readFile('./1.txt', 'utf-8', (err, data) => { if (err) throw err; console.log(data); }) 终端运行

bhegi_seg的博客 6378

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Module语法

概述 ES6 模块的设计思想是尽量的静态化,使得编译时就能确定模块的依赖关系,以及输入和输出的变量。CommonJS 和 AMD 模块,都只能在运行时确定这些东西。比如,CommonJS 模块就是对象,输入时必须查找对象属性。 ES6 模块不是对象,而是通过export命令显式指定输出的代码,再通过import命令输入。 // ES6模块 import { stat, exists, read...

教官的博客 1151

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

JS闭包的理解

闭包 - closure, 函数可以把 来自其它作用域中的变量 封闭在自身保存, 这篇文章带你简单的理解什么是闭包

m0_67212141的博客 398

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

如何理解闭包

摘要 本文介绍了闭包的定义,作用,及常见的理解中的误区,并没有引入其他的专业词汇。 定义 闭包对应的英文是closure,下边的定义是来自MDN。 A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access

weixin_46185369的博客 823

JavaScript ES6函数式编程(一):闭包与高阶函数

函数式编程的历史 函数的第一原则是要小,第二原则则是要更小 —— ROBERT C. MARTIN 解释一下上面那句话,就是我们常说的一个函数只做一件事,比如:将字符串首字母和尾字母都改成大写,我们此时应该编写两个函数。为什么呢?为了更好的复用,这样做保证了函数更加的颗粒化。 早在 1950 年代,随着 Lisp 语言的创建,函数式编程( Functional Programming,简称 ...

Addisoni 815

javascript 中的立即调用函数模式、闭包及es6中的块级作用域

先来看一个在牛客上看到的面试题: 这里一开始会以为是不就是隔1秒输出i的值吗,最后结果就是输出0~9 的十个数字呀,真的是太young了。 但是真是撸了一遍代码,控制台输出刺眼的10个10,what? 这个查了资料是说因为这个函数为每一个i都设置了一个计时器,那么就设置了10个计时器,但是它们被存放在队列中,for循环结束 后setTimeout()函数才得以执行,而这时i的值为10,...

Jackshijin的博客 596

什么是闭包?为什么有闭包?什么是块级作用域?为什么ES6要有let const var的区别?javascript,js

先来看一个例子 <script> window.onload = function(){ var abtn = document.getElementsByTagName('input'); for(var i=0; i<abtn.length; i++ ){ ...

水机.Threeki 772

ES6 —— 闭包

文章目录一、变量作用域二、什么是闭包? 一、变量作用域 变量根据作用域的不同分为两种:全局变量和局部变量。 函数内部可以使用全局变量。 函数外部不可以使用局部变量。 当函数执行完毕,本作用域内的局部变量会销毁。 二、什么是闭包? 闭包(closure)指有权访问另一个函数作用域中变量的函数。简单理解:一个作用域可以访问另外一个函数内部的局部变量。 // fun 这个函数作用域 访问了另外一个函数 fn 里面的局部变量 num function fn(){ let num

HuoZhiyan 的博客 1458

ES6 let语法实现闭包

在ES5时代,通常使用函数 return 嵌套函数实现闭包,这里我就不细说了,可参考《Javascript闭包——懂不懂由你,反正我是懂了》,《什么是闭包,我的理解》。 在ES6时代,我们可以利用let 来很方便的实现闭包,先来看两段代码:var arr=[]; for(var i=0;i<10;i++){ arr.push(()=>i) } console.log(arr[2]()) /

Clyde Kuo 1万+

ES6学习之闭包函数

&lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt; &lt

Runing_snailLBNL的博客 925

ES6 学习笔记之二 块作用域与闭包

“闭包是函数和声明该函数的词法环境的组合。” 这是MDN上对闭包的定义。 《JavaScript高级程序设计》中则是这样定义的:闭包是指有权访问另一个函数作用域中的变量的函数。 个人更倾向于MDN的闭包定义,原因有三: 其一,如果仅将闭包定义为可访问其父作用域(链)的局部变量的函数,那么就忽视了它持有外部环境(使外部作用域不被销毁)的意义。 其二,闭包有权访问的必然是其父作用域(链)中的...

weixin_30609287的博客 160

Node.js系列--异步流程控制

异步编程是Node.js中最大的特点,在Node.js的编程实践中我们为了使得其发挥特性,将所有的东西都写成异步方式,特别是异步回调方式。在Node.js原生代码中,只有fs模块即提供了同步版本又提供了异步版本。现在我们来认识一下Node.js的异步流程控制。 一、 callback 在Node.js中,无论是自定义API还是原生方法到处都可以看到callback的身影,说道callback就

Closure 专栏 1635

javascript的闭包与scope

闭包这种特性在异步回调编程中作用很强大,我们在具体的编程中不需要对变量进行太多的处理,只需要利用语言闭包的特性,就能简单的编写出漂亮的异步程序。。。javascript的闭包特性让node.js如鱼得水。。。 一直觉得要写一篇关于javascript闭包的文章,一直拖着没有写,今天终于开动了。。。。 首先是闭包是什么东西,它的定义,这里给出《javascript高级程序设计》书上给出的

fjs的专栏 1662
上一篇: ES6学习之路~~let和const申明
下一篇: 微信小程序学习之路(一)
EricLua
博客等级 码龄10年 34粉丝 33原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值