详细解读深浅拷贝,实现深拷贝最好的方法就是递归方法

最新推荐文章于 2023-11-23 19:45:26 发布
最新推荐文章于 2023-11-23 19:45:26 发布
阅读量863 收藏 4
点赞数 2
分类专栏： HTML5 js 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44011751/article/details/110529515
版权
js 同时被 2 个专栏收录
22 篇文章 0 订阅
订阅专栏
HTML5
14 篇文章 0 订阅
订阅专栏

1.对浅拷贝和深拷贝的理解

浅拷贝和深拷贝都是对于JS中的引用类型而言的，浅拷贝就只是复制对象的引用堆和栈的关系，简单类型Undefined，Null，Boolean，Number和String是存入堆，直接引用，object array 则是存入桟中，只用一个指针来引用值），如果拷贝后的对象发生变化， 原对象也会发生变化。只有深拷贝才是真正地对对象的拷贝。

2.浅拷贝:浅拷贝的意思就是只复制引用（指针），而未复制真正的值。

// 数组浅拷贝
        let A = [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }];
        let B = A;
        B[0].name = '张三';
        console.log('A', A);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        console.log('B', B);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        // 数组浅拷贝时,我只想改变B数组的数据,然而这时候A和B数组都变了

        // 对象浅拷贝
        let a = { id: 1, val: "111", info: { projectName: "项目1" } };
        let b = a;
        // 给b加一个字段name
        b.name = '李四';
        console.log('a', a);// { id: 1, val: "111", info: { projectName: "项目1" }, name:"李四" }
        console.log('b', b);// { id: 1, val: "111", info: { projectName: "项目1" }, name:"李四" }

效果如图:
在这里插入图片描述
从上面可以看出浅拷贝不管是对引用类型进行什么改变,它们都是一起变化的

3.深拷贝就是对目标的完全拷贝，不像浅拷贝那样只是复制了一层引用，就连值也都复制了。

只要进行了深拷贝，它们老死不相往来，谁也不会影响谁。目前实现深拷贝的方法不多，主要是两种：
方法一:利用 JSON 对象中的 parse 和 stringify
方法二:利用递归来实现每一层都重新创建对象并赋值方法一简单来说就是先通过JSON.stringify 是将一个 JavaScript 值转成一个 JSON 字符串, 然后再通过JSON.parse 将一个 JSON 字符串转成一个 JavaScript 值或对象

        let C = [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }];
        let D = JSON.parse(JSON.stringify(C));
        D.push({ id: 4, name: 'dd' });
        console.log('C', C);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        console.log('D', D);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }, { id: 4, name: "dd" }]

        let c = { id: 1, val: "111", info: { projectName: "项目1" } };
        let d = JSON.parse(JSON.stringify(c));
        d.val = '666';
        console.log('c', c);// { id: 1, val: "111", info: { projectName: "项目1" } }
        console.log('d', d);// { id: 1, val: "666", info: { projectName: "项目1" } }

在这里插入图片描述
注意:利用JSON.parse(JSON.stringify())方法有局限性,那就是当深拷贝对象含有undefined、function、
symbol 会在转换过程中被忽略,这时候就要用方法二了,例子如下:

        let originObj = {
            name: '张三',
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        }
        let copyObj = JSON.parse(JSON.stringify(originObj));
        originObj.sayGoodbye()//Goodbye!
        copyObj.sayGoodbye()//Uncaught TypeError: copyObj.sayGoodbye is not a function

如上对象里面的方法,利用JSON.parse(JSON.stringify())方法是没办法拷贝的,所以当你使用这个方法时要考虑你的情况是否适用

方法二递归,递归的思想就很简单了，就是对每一层的数据都实现一次 创建对象->对象赋值 的操作，简单粗暴上代码：

// 递归方法:
        function deepClone(source) {
            const targetObj = source.constructor === Array ? [] : {}; // 判断复制的目标是数组还是对象
            for (let keys in source) { // 遍历目标
                if (source.hasOwnProperty(keys)) {
                    if (source[keys] && typeof source[keys] === 'object') { // 如果值是对象，就递归一下
                        targetObj[keys] = source[keys].constructor === Array ? [] : {};
                        targetObj[keys] = deepClone(source[keys]);
                    } else { // 如果不是，就直接赋值
                        targetObj[keys] = source[keys];
                    }
                }
            }
            return targetObj;
        }

运用上述方法:

let E = { id: 1, val: "111", arr: [1, 2, { name: '嘻嘻' }], info: { projectName: "项目1" } };
        let F = deepClone(E);
        console.log(E === F); // false
        console.log('E', E); // { id: 1, val: "111", arr:[1,2,{name:'嘻嘻'}], info: { projectName: "项目1" } }
        console.log('F', F); // { id: 1, val: "111", arr:[1,2,{name:'嘻嘻'}], info: { projectName: "项目1" } }

        let e = {
            name: '张三',
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        };
        let f = deepClone(e);
        e.sayGoodbye();//Goodbye!
        f.sayGoodbye();//Goodbye!

在这里插入图片描述用递归方法可以完美的实现深拷贝!

4.扩展:在 JavaScript 中，数组有两个方法 concat 和 slice 是可以实现对原数组的拷贝的，这两个方法都不会修改原数组，而是返回一个修改后的新数组。同时，ES6 中 引入了 Object.assgn 方法和 … 展开运算符也能实现对对象的拷贝

concat:该方法可以连接两个或者更多的数组，但是它不会修改已存在的数组，而是返回一个新数组。

        let originArr = [1, [1, 2, 3], {
            a: 1,
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        }];
        let copyArr = originArr.concat();
        console.log(copyArr === originArr); // false
        copyArr[2].sayGoodbye();//Goodbye!
        copyArr[1].push(4);
        copyArr[2].a = 2;
        console.log('originArr',originArr); // [1, [1, 2, 3, 4], {a: 2,sayGoodbye: function () {console.log('Goodbye!');}}]
        console.log('copyArr',copyArr); // [1, [1, 2, 3, 4], {a: 2,sayGoodbye: function () {console.log('Goodbye!');}}]

originArr 中含有数组 [1,2,3] 和对象 {a:1}，如果我们直接修改数组和对象，不会影响 originArr，但是我们修改数组 [1,2,3] 或对象 {a:1} 时，发现 originArr 也发生了变化。

结论: concat 只是对数组的第一层进行深拷贝。

剩下几个我就不举例子了,直接上结论:
结论: slice 也是只对数组的第一层进行深拷贝。

结论：… 实现的是对象第一层的深拷贝。后面的只是拷贝的引用值。

结论：Object.assign() 拷贝的是属性值。假如源对象的属性值是一个指向对象的引用，它也只拷贝那个引用值。

最后总结一下:

1.赋值运算符 = 实现的是浅拷贝，只拷贝对象的引用值；
2.JavaScript 中数组和对象自带的拷贝方法都是“首层浅拷贝”；
3.JSON.stringify 实现的是深拷贝，但是对目标对象有要求（非 undefined，function）；
4.若想真正意义上的深拷贝，请递归。

希望文档能帮助到您,最后求个赞,谢谢~

下面是例子完整代码和截图有需要的自己拷贝:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>详细解读深浅拷贝</title>
</head>

<body>
    <script>
        // 1.对浅拷贝和深拷贝的理解
        // 浅拷贝和深拷贝都是对于JS中的引用类型而言的，浅拷贝就只是复制对象的引用
        // （堆和栈的关系，简单类型Undefined，Null，Boolean，Number和String是存入堆，
        // 直接引用，object array 则是存入桟中，只用一个指针来引用值），如果拷贝后的对象发生变化，
        // 原对象也会发生变化。只有深拷贝才是真正地对对象的拷贝。



        // 2.浅拷贝:浅拷贝的意思就是只复制引用（指针），而未复制真正的值。
        // 数组浅拷贝
        let A = [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }];
        let B = A;
        B[0].name = '张三';
        console.log('A', A);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        console.log('B', B);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        // 数组浅拷贝时,我只想改变B数组的数据,然而这时候A和B数组都变了

        // 对象浅拷贝
        let a = { id: 1, val: "111", info: { projectName: "项目1" } };
        let b = a;
        // 给b加一个字段name
        b.name = '李四';
        console.log('a', a);// { id: 1, val: "111", info: { projectName: "项目1" }, name:"李四" }
        console.log('b', b);// { id: 1, val: "111", info: { projectName: "项目1" }, name:"李四" }
        // 从上面可以看出浅拷贝不管是对引用类型进行什么改变,它们都是一起变化的



        // 3.深拷贝就是对目标的完全拷贝，不像浅拷贝那样只是复制了一层引用，就连值也都复制了。
        // 只要进行了深拷贝，它们老死不相往来，谁也不会影响谁。目前实现深拷贝的方法不多，主要是两种：
        // 方法一:利用 JSON 对象中的 parse 和 stringify
        // 方法二:利用递归来实现每一层都重新创建对象并赋值

        // 方法一简单来说就是先通过JSON.stringify 是将一个 JavaScript 值转成一个 JSON 字符串,
        // 然后再通过JSON.parse 将一个 JSON 字符串转成一个 JavaScript 值或对象
        let C = [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }];
        let D = JSON.parse(JSON.stringify(C));
        D.push({ id: 4, name: 'dd' });
        console.log('C', C);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }]
        console.log('D', D);// [{ id: 1, name: "aa" }, { id: 2, name: "bb" }, { id: 3, name: "cc" }, { id: 4, name: "dd" }]

        let c = { id: 1, val: "111", info: { projectName: "项目1" } };
        let d = JSON.parse(JSON.stringify(c));
        d.val = '666';
        console.log('c', c);// { id: 1, val: "111", info: { projectName: "项目1" } }
        console.log('d', d);// { id: 1, val: "666", info: { projectName: "项目1" } }

        // 注意:利用JSON.parse(JSON.stringify())方法有局限性,那就是当深拷贝对象含有undefined、function、
        // symbol 会在转换过程中被忽略,这时候就要用方法二了,例子如下:
        let originObj = {
            name: '张三',
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        }
        let copyObj = JSON.parse(JSON.stringify(originObj));
        originObj.sayGoodbye()//Goodbye!
        // copyObj.sayGoodbye()//Uncaught TypeError: copyObj.sayGoodbye is not a function
        // 如上对象里面的方法,利用JSON.parse(JSON.stringify())方法是没办法拷贝的,所以当你使用这个方法时要考虑你的情况是否适用

        // 方法二递归,递归的思想就很简单了，就是对每一层的数据都实现一次 创建对象->对象赋值 的操作，简单粗暴上代码：
        // 方法:
        function deepClone(source) {
            const targetObj = source.constructor === Array ? [] : {}; // 判断复制的目标是数组还是对象
            for (let keys in source) { // 遍历目标
                if (source.hasOwnProperty(keys)) {
                    if (source[keys] && typeof source[keys] === 'object') { // 如果值是对象，就递归一下
                        targetObj[keys] = source[keys].constructor === Array ? [] : {};
                        targetObj[keys] = deepClone(source[keys]);
                    } else { // 如果不是，就直接赋值
                        targetObj[keys] = source[keys];
                    }
                }
            }
            return targetObj;
        }
        let E = { id: 1, val: "111", arr: [1, 2, { name: '嘻嘻' }], info: { projectName: "项目1" } };
        let F = deepClone(E);
        console.log(E === F); // false
        console.log('E', E); // { id: 1, val: "111", arr:[1,2,{name:'嘻嘻'}], info: { projectName: "项目1" } }
        console.log('F', F); // { id: 1, val: "111", arr:[1,2,{name:'嘻嘻'}], info: { projectName: "项目1" } }

        let e = {
            name: '张三',
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        };
        let f = deepClone(e);
        e.sayGoodbye();//Goodbye!
        f.sayGoodbye();//Goodbye!
        // 完美深拷贝!

        // 4.扩展:在 JavaScript 中，数组有两个方法 concat 和 slice 是可以实现对原数组的拷贝的，
        // 这两个方法都不会修改原数组，而是返回一个修改后的新数组。同时，ES6 中 引入了 Object.assgn 方法和 ... 展开运算符
        // 也能实现对对象的拷贝

        // concat:该方法可以连接两个或者更多的数组，但是它不会修改已存在的数组，而是返回一个新数组。
        let originArr = [1, [1, 2, 3], {
            a: 1,
            sayGoodbye: function () {
                console.log('Goodbye!');
            }
        }];
        let copyArr = originArr.concat();
        console.log(copyArr === originArr); // false
        copyArr[2].sayGoodbye();//Goodbye!
        copyArr[1].push(4);
        copyArr[2].a = 2;
        console.log('originArr',originArr); // [1, [1, 2, 3, 4], {a: 2,sayGoodbye: function () {console.log('Goodbye!');}}]
        console.log('copyArr',copyArr); // [1, [1, 2, 3, 4], {a: 2,sayGoodbye: function () {console.log('Goodbye!');}}]
        // originArr 中含有数组 [1,2,3] 和对象 {a:1}，如果我们直接修改数组和对象，不会影响 originArr，
        // 但是我们修改数组 [1,2,3] 或对象 {a:1} 时，发现 originArr 也发生了变化。
        // 结论: concat 只是对数组的第一层进行深拷贝。

        // 结论: 同样的例子就不写了, slice 也是只对数组的第一层进行深拷贝。

        // 结论：... 实现的是对象第一层的深拷贝。后面的只是拷贝的引用值。

        // 结论：Object.assign() 拷贝的是属性值。假如源对象的属性值是一个指向对象的引用，它也只拷贝那个引用值。

        // 最后总结一下:
        // 1.赋值运算符 = 实现的是浅拷贝，只拷贝对象的引用值；
        // 2.JavaScript 中数组和对象自带的拷贝方法都是“首层浅拷贝”；
        // 3.JSON.stringify 实现的是深拷贝，但是对目标对象有要求（非 undefined，function）；
        // 4.若想真正意义上的深拷贝，请递归。
    </script>
</body>

</html>

在这里插入图片描述

舞空~
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ym——Andorid-15k+的面试题。
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
2020面试篇：python面试题库（基础篇）附详细答案
chaxiaoli001的博客
01-16 5780
https://shimo.im/docs/CdDxcHctyWwDJTYt/read 面试篇：python基础篇 为什么学习Python？ 通过什么途径学习的Python？ Python和Java、PHP、C、C#、C++等其他语言的对比？ 具体见https://www.cnblogs.com/ppf3678/p/10739261.html描述即可。 简述解释型和编译型编程语言？...
关于Object.assign与 JSON.parse(JSON.stringify())
weixin_30607659的博客
07-30 624
假如源对象的属性值是一个指向对象的引用，它也只拷贝那个引用值。例如： var arr = [a,b,{c:111}], var val={c:222} var copy = Object.assign(arr[2], val); 此时，arr [2].c 和 copy.c指向的还是一个同一个对象。 Object.assign()只是一级属性复制，比浅拷贝多深拷...
Object.assign() {...obj} JSON.Parse 等几种拷贝的区别
weixin_30613343的博客
03-22 744
let obj = { age: 10 } let obj1 = { grade: 1, name: { first: 'bob' } } let objS = obj1 let objA = Object.assign(obj, obj1) let objJ = JSON.parse(JSON.stringify(ob...
js经典面试题手写一个深拷贝函数
weixin_43837268的博客
09-22 591
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title>D.
清晰易懂的递归实现深拷贝
qq_52340302的博客
09-27 599
深拷贝：就是复制多层新对象会创建一个新的堆内存地址，原对象堆内存地址的属性会复制一份存放到新对象里的堆内存地址中去，两者不互干扰。 var obj = { arr1 : [1,2,3], fn: function(){ console.log('我是一个方法') }, a : '我是普通属性' } // 现在我要把obj字面量创
【折腾】深拷贝的递归思想
Madman528的博客
04-02 294
首先先理一下思路 数组可以通过下标这样拷贝 数组可以通过下标这样拷贝 let arr = [4, 5, 6] let arr1 = [] arr1[0] = arr[0] console.log(arr1[0]);//4 对象可以通过key这样拷贝属性 let obj1 = { name: "小明" } let obj2 = {} obj2['name'] = obj1['name'] obj2.name = '小白' console.log(obj1.name);//..
【设计模式】通俗易懂的Java设计模式篇！
互联网小阿祥
11-03 1870
通俗易懂的Java设计模式篇！
串联高频面试问题，触类旁通，一通百通！
掘金安东尼
07-15 1615
前言 开宗明义，本瓜深知汝之痛点：前端面试知识点太杂，卿总为了面试而面试，忘了记，记了又忘，循环往复，为此叫苦不迭。 来，让本瓜带领各位都稍稍回顾一下，自己曾经在学生时代记忆元素周期表的光辉岁月。 氢、氦、锂、铍、硼、碳、氮、氧、氟、氖、钠、镁、铝、硅、磷、硫、氯、氩、钾、钙、钪、钛、钒、铬、猛、铁、钴、镍、铜、锌… 咱当初记这前三十位元素，是死记硬背的吗？答案是否定的，机智的我们用到了 串联记忆法 。 一定是像这样或类似这样去记： 第一周期：氢 氦 ———— 轻嗨：轻轻的打个了招呼：嗨！ 第二周期：锂
python基础试题（2）
热门推荐
time_money的博客
03-21 1万+
1.Python和Java、PHP、C、C#、C++等其他语言的对比？ python是一种脚本语言，它的运行需要python解释器，属于解释型的语言，python本身就是由C语言开发出来的，而且是开源的，由此可见C语言的强大，；C语言属于中级语言，它介于高级和低级语言之间，C是编译型的语言，它的运行必须经过编译器的处理才能形成最终的执行代码，C语言的应用非常广泛，C语言最主要的用途就是系统底层的应用。 简单的说，它们都是编程语言。是在第三代和第四代编程语言。 都和C有关系。 底层解释器都是C写的。都存在进程
递归深拷贝和Object.assign() 加递归深拷贝和(JSON.stringify()+JSON.parse()最简单深拷贝)
清风的博客
10-21 1312
深拷贝的几种方式 1.使用递归深拷贝 var obj = { name:'张三', age:20, card:['11','22',33], wife:{ name:'李四', son:{ name:'张六' } }, say:function(){ var a=3...
深浅拷贝，递归
摸鱼小队
04-07 167
js代码： /* 1.源数据 */ let ff = { car: { brand: "奔驰", color: {one:'haha'} }, money: 1000000, house: "海景房" } /* 2.浅拷贝 */ function copy2(obj){ let obj3 = {} for(let k in obj){ obj3[k] = obj[k] // 浅拷贝,拷贝的是对象属性的引用，而
递归函数，浅拷贝跟深拷贝
不是死水
08-15 264
递归函数：递归就是一个函数在它的函数内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。递归函数必须有结束条件。 浅拷贝 <script> var obj = { id: 1, name: 'andy', msg: { age: 18 }, color: ['pink','white'] }; var o = {} Object.assign(o,obj) .
深浅拷贝(递归拷贝)
weixin_55865982的博客
03-21 1152
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>D.
Object.assign和JSON.parse(JSON.stringify())的区别
weixin_38687522的博客
11-02 1231
浅拷贝: Object.assign() 深拷贝: JSON.parse(JSON.stringify()) 什么是浅拷贝？ 对于字符串类型，浅复制是对值的复制，对于对象来说，浅复制是对对象地址的复制，并没有开辟新的栈，也就是复制的结果是两个对象指向同一个地址，修改其中一个对象的属性，则另一个对象的属性也会改变。 什么是深拷贝？ 深拷贝是开辟新的栈，两个对象对应两个不同的地址，修改一个对象的属性，不会改变另一个对象的属性。 若对象是基础数据类型。此时 Object.assign()可实现深拷贝，和JSON.
递归以及深拷贝和浅拷贝
lucky_ferry的博客
07-26 608
递归 函数内部自己调用自己 递归函数必须有退出条件，否则会造成栈溢出 数组操作-forEach() 迭代遍历数组（加强版的for循环遍历） 用法：arry.forEach ( function(value, index, arr ) ) 其中 value 是数组里面的值，index 是该值的索引号 一句话：遍历该数组，得到值，对其进行操作 数组操作-some() 数组操作-filter() ...
深拷贝 浅拷贝 递归
最新发布
jokerJOJO777的博客
11-23 227
浅拷贝指的是创建一个新对象，其中包含原始对象的引用（指针），并没有真正将原始对象的数据复制到新对象中，因此新对象与原始对象共享部分或全部数据。深拷贝指的是创建一个新对象，并递归地将原始对象的数据复制到新对象中，因此新对象与原始对象之间不存在数据共享。深拷贝 JSON.stringify 与 JSON.parse。浅拷贝方式一Object.assign(目标对象 ，源对象)浅拷贝:拷贝的对象和源对象相互有影响。深拷贝:拷贝的对象和源对象没有影响。深拷贝 自己实现 递归。浅拷贝方式二： 展开运算符。
深拷贝(比较完整的拷贝方法)
kbdmy的博客
05-27 209
let obj = { name: '1张三丰', age: 22, messige: { sex: '男', score: 16 }, color: ['red', 'purple', 'qing'], fig: true, fn: function (x) { .
关于递归和深拷贝
qq_61896295的博客
06-21 420
递归，就是在运行的过程中调用自己。简而言之，递归就是函数自己调用自己浅显易懂的例子优点缺点 递归的实际应用 深拷贝 正常深拷贝只能深拷贝利用 值类型,与引用类型都拷贝(互相不影响) 对象转字符JSON.stringify,字符串转json JSON.parse() JSON数据格式只支持:string,number,null,undefined,array,object 有了递归，就可以对是JSON数据格式支持的对象进行简易拷贝 然后对不支持的（函数，正则等）进行递归拷贝...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值