es6 -- 语法(扩展)

最新推荐文章于 2023-07-23 16:44:55 发布
最新推荐文章于 2023-07-23 16:44:55 发布
阅读量452 收藏 1
点赞数
分类专栏： es6
变量的扩展
/*
* 变量的扩展
* 1. let 在es6新的声明变量的关键字
*       特性: 1.没有与解析
*             2. 不允许重复声明
*             3. 块级作用域  {} 称之为代码块
*  2. const
*        1. 常量 固定的值 不能被修改
*        2. 对象obj 属性可以修改的
* */

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
    * 变量的扩展
    * 1. let 在es6新的声明变量的关键字
    *       特性: 1.没有与解析
    *             2. 不允许重复声明
    *             3. 块级作用域  {} 称之为代码块
    *  2. const
    *        1. 常量 固定的值 不能被修改
    *        2. 对象obj 属性可以修改的
    * */
    // console.log(a);// defined
    // let a = "2130";  //var  会先找.undefined.
    // let a = 1; //不允许重复声明
    /*
        for (var i = 0; i < 3; i++) {  //平常要输出 012. 需要闭包
            (function(a){
                var j = a;
                setTimeout(function () {
                    console.log(j);
                },300)
            })(i)
         };

    for (let i = 0; i < 3; i++) {
        setTimeout(function () {
            console.log(i);
        })
    }

    {
        let a = "";
    }
    console.log(a)//defined;
    */

   // const b =  "常量";
   // b = "不能修改";
   // 例外 对象的属性可以被修改.
   const obj = {
        name : "狗蛋",
        say : function(){
            console.log(1);
        }
   }
   obj.name = "二狗";
   obj.say = function(){
        console.log(2);
   }
   console.log(obj.name);
   console.log(obj.say);

</script>
</body>
</html>
赋值的扩展
结构赋值:  可以按照一定的结构进行赋值
                    !!结构对上
                 1.对象属性名一定要对上

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
        赋值的扩展 结构赋值:  可以按照一定的结构进行赋值
                        结构对上
                          1.对象属性名一定要对上
     */

     // let [a,b] = [1,2];
     // console.log(a,b);
     // let [a,[c],b] = [1,[2],3];
     // console.log(a,b,c);//1 3 2

     // 对象
     // let obj = {
     //    name:"狗蛋",
     //    fn : "二狗"
     // };
     // let {name,fn} = obj;
     // console.log(name,fn);

    //变量的值互换.
     var a = "狗蛋";
     var b = "二狗";
     var [a,b] = [b,a];
     console.log(a,b);
     //
</script>
</body>
</html>
字符串的扩展
1.用反引号``声明   ${}可以拼接变量.
                         ${}内可以运算
        可以换行,识别换行


2.字符串的查找
        返回bool
        includes("w")  是否存在
            第二参数 从第几位开始.
        startsWith()   开头是否是
                    从末尾位开始
        endsWith()  结尾是否是

        repeat()  复制几遍 ,自身不会改变.

pattern = /a+/g
pattern = /a+/y  ===> 不能过滤除匹配字符以外的字符.
    从上次匹配的地方开始匹配 的
    *   第一次: aaa   剩余的部分  _aa_a
    *   第二次 _aa_a 开始匹配

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
        字符串的扩展
            用反引号``声明   ${}可以拼接变量.
                             ${}内可以运算
            可以换行,识别换行
     */
    /*
    let a = 10;
    let b = `${a+1}

    goudan`;
    console.log(b);
    */


    /*
        字符串的查找
            返回bool
            includes("w")  是否存在
                第二参数 从第几位开始.
            startsWith()   开头是否是
                        从末尾位开始
            endsWith()  结尾是否是

            repeat()  复制几遍 ,自身不会改变.
     */

     // let str = "goudan";
     // // console.log(str.includes('gou'));//true
     // console.log(str.startsWith('go'));//
     // console.log(str.endsWith('an'));

     // console.log(str.repeat(10));
     // console.log(str);


     /*
            pattern = /a+/g
            pattern = /a+/y  ===> 不能过滤除匹配字符以外的字符.
                从上次匹配的地方开始匹配 的
                *   第一次: aaa   剩余的部分  _aa_a
                *   第二次 _aa_a 开始匹配
      */

     // let str = "baaabaaaabaa";
     // let pattern = /a+/g;
     // let pattern2 = /a+/y;

     // console.log(pattern.exec(str));
     // console.log(pattern.exec(str));
     // console.log(pattern2.exec(str));
     // console.log(pattern2.exec(str));//null


</script>
</body>
</html>
数学方法的扩展
/*
    Math.trunc()   取整(去掉小数点)
    Math.sign()    判断是否是正数还是负数.  返回值 正 1  负 -1   0 -0;
    Math.hypot()   求勾股定理的第三边

 */

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
        Math.trunc()   取整(去掉小数点)
        Math.sign()    判断是否是正数还是负数.  返回值 正 1  负 -1   0 -0;
        Math.hypot()   求勾股定理的第三边

     */

    let num = 1.23213;
    console.log(Math.trunc(num));

    console.log(Math.sign(-0));

    console.log(Math.hypot(3,4));
</script>
</body>
</html>
数组的扩展

1.扩展运算符（spread）是三个点（…）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。 —摘自阮一峰

console.log(...[1, 2, 3])
// 1 2 3

console.log(1, ...[2, 3, 4], 5)
// 1 2 3 4 5

[...document.querySelectorAll('div')]
// [<div>, <div>, <div>]

作为展开数组的方法。 不再需要apply方法，将数组转为函数的参数了

// ES5 的写法
function f(x, y, z) {
  // ...
}
var args = [0, 1, 2];
f.apply(null, args);

// ES6的写法
function f(x, y, z) {
  // ...
}
let args = [0, 1, 2];
f(...args);

        Array.from()      ,将类数组 变成 数组.
        Array.of(param)   ,将param  变成数组
        arr.find()         遍历数组 将第一个符合条件的值返回出去, 无则返回-1;
        arr.findIndex()                                返回下标.

        arr.fill()          在数组原来的内容上替换. 可以多个.
                        参数1 : 填充的内容
                                eg:[2,5)
                        参数2 : 开始位置(下标).
                        参数3 : 结束位置(下标).

<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <meta name="Author" content="">
    <meta name="Keywords" content="">
    <meta name="Description" content="">
    <title>Document</title>
    <style type="text/css">
        * {margin: 0; padding: 0;}
        a {text-decoration: none;}
        ul,li {list-style: none;}
        body {font-family: "Microsoft yahei";}
    </style>
</head>
<body>
    <div></div>
    <div></div>
    <div></div>
    <script type="text/javascript">
    /*
        数组的扩展
            Array.from()      ,将类数组 变成 数组.
            Array.of(param)   ,将param  变成数组
            arr.find()         遍历数组 将第一个符合条件的值返回出去, 无则返回-1;
            arr.findIndex()                                返回下标.

            arr.fill()          在数组原来的内容上替换. 可以多个.
                            参数1 : 填充的内容
                                    eg:[2,5)
                            参数2 : 开始位置(下标).
                            参数3 : 结束位置(下标).
    */

    /*Array.from():
    var divs = document.querySelectorAll("div");
    // var str = "goudan";
    // var arr2 = str.split("");
    // var arr = [].slice.call(divs);
    var arr = Array.from(divs);
    var arr2 = Array.from("goudan");
    console.log(arr,arr2);*/

    // Array.of
    //console.log(Array.of(1,2,3,4));

    // arr.find() findIndex()  arr.fill()
    let arr = [1,2,3,4,5,6];
    // let n = arr.find(function(value,i){//值,下标
    //     return i>3;
    // })
    let n = arr.findIndex(function(value,i){//值,下标
        return value>3;
    });
    console.log(n);

    arr.fill(2,0,6); //[2,2,2,2,2,2]
    arr.fill(3,1,6); //[2,3,3,3,3,3]
    console.log(arr);
</script>
</body>
</html>
循环的扩展
 循环的扩展
    for (let/var of )

<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <meta name="Author" content="">
    <meta name="Keywords" content="">
    <meta name="Description" content="">
    <title>Document</title>
    <style type="text/css">
        * {margin: 0; padding: 0;}
        a {text-decoration: none;}
        ul,li {list-style: none;}
        body {font-family: "Microsoft yahei";}
    </style>
</head>
<body>

    <script type="text/javascript">
    /*
        循环的扩展
        for (let/var of )
    */
   // 遍历str 的 值
    /*let str = "goudan";
    for(let value of str){
        value = ` ${value}`;
        console.log(value);
    }
    console.log(str);//不改变*/

    let arr = ["goudan","ergou","shagou"];
    /*for(let value of arr){
        value = value.substring(0,2);
        console.log(value);
    }*/
    // 遍历下标
    /*for(let i of arr.keys()){
        arr[i] = "123";
        console.log(i);
    }*/

    // 对象的遍历Object.values(obj)  Object.keys(obj)
    let obj = {
        name : "goudan",
        say : function(){
            console.log(1);
        }
    }
    // var arr1 = Object.values(obj);   //返回是数组.
    // console.log(arr1);
    /*// 遍历值Object.values(obj)
    for(let value of Object.values(obj)){
        console.log(value);
        if(typeof value === "function"){
            value();
        }
    }*/
    // 遍历属性名
    for(let key of Object.keys(obj)){
        console.log(key);
    }
    </script>
</body>
</html>
对象的扩展
    1.对象的代理
        new Proxy(obj,{
            get(){

            },
            set(){

            }
        });
        参数1: //被代理的对象
        参数2:　对象 {被访问时触发的函数get(),修改对象属性时触发的函数set()}

     2.定义对象的方法扩展
     3.Object.is()  判断参数是否相等;

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
        1.对象的代理
            new Proxy(obj,{
                get(){

                },
                set(){

                }
            });
            参数1: //被代理的对象
            参数2:　对象 {被访问时触发的函数get(),修改对象属性时触发的函数set()}
     */
    /*let obj = {
        name : "goudan",
        a : 10,
        b : 100
    }
    let p1 = new Proxy(obj,{
        // 被访问时触发.
        get(obj,key){//key访问的属性名.
            if(key != "name"){
                return obj[key];
            }
        },
        // 修改对象属性的值时触发.
        set(obj,key,value){ //value修改的值
            if(key != "name"){
                obj[key] = value;
            }
        }
    });
    console.log(p1.a);
    console.log(p1.b);
    // console.log(p1.name); //undefined
    // 修改
    p1.a = 123;
    console.log(p1.a);
    // p1.name = "ergou";
    // console.log(p1.name);*/


    /*
        2.定义对象的方法扩展

     */
    /*let obj = {
        name : "goudan",
        say(){
            console.log(1);
        },
        ["w"+"w"]:"213"
    }
    obj.say();
    console.log(obj.ww);*/

    /*
        Object.is()  判断参数是否相等;
     */

    /*console.log(Object.is(0,-0));//false
    console.log(0 === -0);//true
    console.log(Object.is(NaN,NaN));//true
    console.log(NaN === NaN);//false*/

    /*
        Object.assign()
        将多个对象合并到第一个,
        第一个参数 被赋值的对象  剩下的所有参数  赋值的对象
         如果重复 后面覆盖前面的
     */
    /*let obj = {};
    let obj1 = {
        name: "hou"
    },obj2 = {
        name: "gou",
        say(){
            conosole.log(1);
        }
    };

    Object.assign(obj,obj1,obj2);
    console.log(obj);*/


    /*
        获取对象的prototype
            通过创建的对象去获取
            Object.getPrototypeOf(创建的对象)
        替换.
            Object.setPrototypeOf()
     */
     function Cat(names){
        if(this instanceof Cat){
            this.name = names;

        }else{
            return new Cat(names);
        }
     }
     Cat.prototype.say = function(){
        console.log(this.name);
     };
     function Dog(names){
        if(this instanceof Dog){
            this.name = names;

        }else{
            return new Dog(names);
        };
     }
     Dog.prototype.replace = function(){
        console.log("cat");
     }
     let a = Cat("goudan");
     let b = Dog("ergou");
     a.say();
     Object.setPrototypeOf(b,Cat.prototype);  //替换.
     console.log(Object.getPrototypeOf(a));
     console.log(Object.getPrototypeOf(b));   //只是创建的这个对象改变了
     console.log(Dog.prototype);  //不影响.
</script>
</body>
</html>
函数的扩展
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="Author" content="">
        <meta name="Keywords" content="">
        <meta name="Description" content="">
        <title>Document</title>
        <style type="text/css">
            * {margin: 0; padding: 0;}
            a {text-decoration: none;}
            ul,li {list-style: none;}
            body {font-family: "Microsoft yahei";}
        </style>
    </head>
<body>

<script type="text/javascript">
    /*
        参数:
            1.多余参数. (argument)
            多余的参数用...param(自定名)接收
            2.默认参数.

            3.箭头函数  ==>
     */
    // 1.多余参数. (argument)
    /*function fn(a,...param){
        console.log(a);
        console.log(param)//[]
    }
    fn(1,12,{"name":1},function(){
        alert(1);
    });*/

    // 2.默认参数.
    /*function fn(a,b = "goudan"){
        // var b = b || "goudan";// 平常
        console.log(a,b);
    };
    fn("123");*/

    // 3.箭头函数. (不能当作真正的函数)
    //      如果一行代码可以省略{};
    //      一个参数可以省略();
    // var Fn = function(){};
    // let fn = (a) => console.log(a);
    // fn("123456");
    // 与真正的函数的区别
    //    1.不能用new
    //    2.arguments不存在.
    //    3.this指向始终指向定义的那个对象.
    let obj = {
        name: "goudan",
        say:function(){
            setTimeout(()=>{
                console.log(this); //obj.
            })
        }
    };
    let obj1 = {
        name: "goudan",
        say:function(){
            setTimeout(function(){
                console.log(this);//window.
            })
        }
    };
    obj.say();
    obj1.say();
</script>
</body>
</html>
维克多噗噗
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6语法扩展（剩余参数与扩展运算符、set和map、遍历器、es6新增方法）
ailsa_csdn的博客
03-30 1551
ES6 新特性之语法扩展，包含剩余参数和扩展运算符、set和map、for...of方法、以及ES6新增的字符串方法、数组方法、对象方法等内容
es6-string-html：es6多行字符串中的突出显示代码
02-05
在es6多行字符串中添加了对代码的语法突出显示支持： HTML（包括带引号和未引号的html的atts） SQL 社区 在ES6模板文字中突出显示CSS 在python多行字符串中突出显示SQL代码 在多行字符串中突出显示JS 安装 从扩展...
ES6新特性：解构、对象扩展、函数扩展、数组扩展、数值扩展
lalala_dxf的博客
05-08 1309
解构 1、什么是解构 ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring），解构的本质属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。如果解构不成功，变量的值就等于undefined。 2、数组结构 以前为变量赋值时只能直接指定值，如下 let a = 1; let b = 2; let c = 3; ES6 允许写成下面这样。等号左边的变量放到中括号内部，匹配右侧数组中的元素。 let [a, b, c] = [1, 2, 3
ES6基础知识二：ES6中数组新增了哪些扩展？
Allen-Ye博客
07-23 359
ES6中数组新增了哪些扩展？
ES6扩展
qq_43157227的博客
10-03 161
ES6模块基本用法，promise，async/await,宏任务和微任务，同步任务和异步任务，事件循环机制
ES6的一些常用语法
weixin_45799076的博客
12-24 133
ES5和6的一些新特性 此博客仅作本人知识点总结,许多地方都有所省略,小白勿仿 1.创建一个空的html页面： <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" cont...
es6-spread:ES6 扩展编译为 ES5
07-03
编译使用 ES6 扩展语法编写的 JavaScript 以使用等效的 ES5 代码。 例如，这将args作为位置参数展开到f ： function f ( x , y , z ) { } var args = [ 0 , 1 , 2 ] ; f ( ... args ) ; 该项目是一部分，该项目将...
express-es6-template-engine:Express渲染引擎，使用ES6 javascript字符串模板作为语法
05-07
ES6 Renderer是用于Node和Express应用程序的简单，超快速和可扩展的模板引擎，它使用纯ES6 Javascript语法。 它的工作方式是扫描工作目录中的文件，然后读取文件的内容并将其从纯字符串转换为ES6模板字符串。 ES6...
es6-module-transpiler-npm-resolver:使用`jsnext 从 NPM 模块到解析器的 ES6 模块转译器扩展
06-29
es6-module-transpiler-npm-resolver 带有jsnext:main标志的从 NPM 模块到解析器的 ES6 模块转换器扩展。概述ES6 模块转换器es6-module-transpiler是一个实验性编译器，它允许您使用当前 ES6 模块语法的子集编写 ...
es6-module-transpiler-system-formatter:ES6 模块转译器扩展到输出 `System.register()` 格式
06-29
ES6 模块转换器es6-module-transpiler是一个实验性编译器，它允许您使用当前 ES6 模块语法的子集编写 JavaScript，并将其编译为各种格式。 es6-module-transpiler-system-formatter是专注于将 ES6 模块语义带回 ES5 ...
es6 扩展运算符 三个点（...）
热门推荐
现在学习也不晚
11-29 27万+
1  含义扩展运算符（ spread ）是三个点（...）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列。console.log(...[1, 2, 3]) // 1 2 3 console.log(1, ...[2, 3, 4], 5) // 1 2 3 4 5 [...document.querySelectorAll('div')] // [&lt;div&gt;, &...
ES6的...拓展语法
ZhangXiaoTianZC的博客
10-10 328
ES6中的拓展语法 … 就是拓展语法 它有3个作用： 1 收集剩余参数 2 解构数组时 3 传递参数 1 收集剩余参数 function demo(a, ...args) { console.log(a, args); } demo(1, 2, 3, 4, 5); 2 解构数组 var arr = [1, ...
es6 扩展运算符 (...)
weixin_30257433的博客
03-29 330
扩展运算符（ spread ）是三个点（...）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列 var a = [1,2,3,4]; console.log(...a); //1,2,3,4 console.log(3,...a,5); // 3,1,2,3,4,5 console.log(...document.querySelectorAll('div')...
ES6扩展运算符（...）
Leayh
05-08 2万+
在使用vuex的过程中，经常会碰到以下写法： ...mapGetters('user',['classList','class','subjectList','termList']) 在不了解ES6的扩展运算符前，对这种写法很迷惑，不懂...的作用到底是什么，于是通过《ECMAScript 6 入门》一书，学习了扩展运算符的相关知识。 数组的扩展运算符 概念 扩展运算符（spr...
...ES6语法之扩展运算符
wding914的博客
04-23 1348
…ES6语法之扩展运算符 对象的扩展运算符 数组的扩展运算符 对象的扩展运算符 对象中的扩展运算符(…)用于取出参数对象中的所有可遍历属性，拷贝到当前对象之中 let obj1 = { a: 1, b: 2 }; let obj2 = { ...obj1}; // { a: 1, b: 2 } 注意: 扩展运算符对对象实例的拷贝属于一种浅拷贝 浅拷贝: 简单...
Promise源码阅读之ES6 Extensions API
玉案轩窗的博客
11-13 308
前言 本次阅读的Promise是基于Promise A+规范的，对于ES6 Promises规范中有些API需要提供另外的支持，即ex6-extensions.js文件中的逻辑处理。 具体分析 Promise.resolve 该方法返回一个fulfilled状态的Promise对象 if (value instanceof Promise) return value; // NULL 即v...
ES6其他语法及扩展语法总结
qq_65715980的博客
07-23 362
includes、**幂运算、flat数组降维、flat和map的一个结合、对象的扩展方法、 fromEntries 把键值对的形式 转为对象、trim 去除空格、?. 对象层级比较深。
ES6 — 对象扩展
webxiaoma
07-12 1495
今天来总结一下es6的对象扩展，最近一直在看es6, 感觉es6真的很好用，不过也看到过网上一些反面语言，可能因人而异，es6 的发展前景让我们拭目以待。一、对象属性和方法1.简写// 属性简写 var a = "first"; var b = {a}; console.log(b) // {a:"first"}//方法简写 var obj = { method (){ retrun
JavaScript基础==＞ES6扩展
weixin_46037781的博客
07-04 400
一、对象操作 Object.assign.(obj, objitem) Object.assgin() //es6方法 将源对象合并到目标对象 Object.assign 在 对象只有一层时为深度克隆 否则 为浅克隆 Object.assign(newObj,a,b,c) // 第一个参数是个对象后面都是源对象也就是被合并的对象 ......
es6创造类的语法规则
最新发布
09-08
### 回答1： ES6中创建类的语法规则如下： 1. 使用 `class` 关键字定义一个类。...总而言之，ES6的类的语法规则提供了一种更加简洁、易读的方式来实现面向对象编程，使得代码更加可维护和可扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值