js拷贝数组对象：浅拷贝&深拷贝

已于 2023-03-04 15:29:04 修改
阅读量1.5k 收藏 10
点赞数 10
分类专栏： Web前端基础 文章标签： javascript 前端 数组拷贝 浅拷贝 深拷贝
于 2023-03-03 16:35:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35893033/article/details/129319527
版权

前言

js拷贝数组对象：浅拷贝&深拷贝，包括：Object.assign、concat、slice、JSON.parse(JSON.stringify())
场景：弹窗选择组织结构（树形结构），选择后显示相关数据至输入框中（每次选择都将重新拷贝初始组织结构数据）
博客地址：芒果橙的个人博客 【http://mangocheng.com】

文章目录

关于浅拷贝、深拷贝的使用场景

在开发过程中，需要基于某一个对象上进行新增修改的场景是非常多的，因此经常会进行对象的拷贝。在不需要多次复用源数据的情况下，那么对象的拷贝只需要进行赋值就能满足要求，即浅拷贝，但有时候需要多次使用到初始的原数组，那么则需要深拷贝，以达到每次拷贝原数组都是初始数据的目的

常用的拷贝方法

场景

  • 弹窗选择组织结构（树形结构），选择后显示相关数据至输入框中

  • 数据格式：[ {},{}]

  • 场景数据，案例使用

const copy = {
    // 源数组1：简单数组
	sourceArr: ['a', 'b', 'c'],			
    targetArr: [],
    // 源数组2：复杂数组
    sourceArrAndObj: [					
        {
            'A': 1,
            'B': 2
        },
        {
            'S': 10,
            'T': 20
        }
    ],
    targetArrAndObj: []
}

1. 普通赋值语法-简单数据、复杂数据均为浅拷贝

目标数组=源数组

  • 测试数据
    • 源数组1-sourceArr：[‘a’, ‘b’, ‘c’]
    • 目标数组1-targetArr：[]
    • 源数组2-sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2 }, { ‘S’ : 10, ‘T’ : 20 } ]
    • 目标数组2-targetArrAndObj: []
  • 操作
    • 赋值目标数组
    • 增加目标数组1数据[d、e]
    • 增加目标数组2数据属性[C、D]、修改属性[S、T]
  • 输出
    • 源数组1-sourceArr = a,b,c,d,e
    • 源数组2-sourceArrAndObj = [ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
  • 结果&结论
    • 源数组改变
    • 浅拷贝作用
console.log('sourceArr = ', this.sourceArr.join());
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArr = this.sourceArr;
        this.targetArrAndObj = this.sourceArrAndObj;
        console.log('赋值后：targetArr = ', this.targetArr.join());
        console.log('赋值后：targetArrAndObj=', this.targetArrAndObj);

        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');
        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);

2. Object.assign(target,source)-简单数据深拷贝、复杂数据浅拷贝

Object.assign(目标数组,源数组)

  • 测试简单数据
    • 源数组sourceArr：[‘a’, ‘b’, ‘c’]
    • 目标数组targetArr：[]
  • 操作
    • 增加目标数组数据[d、e]
  • 输出
    • targetArr = a,b,c,d,e
    • sourceArr= a,b,c
  • 结果&结论
    • 源数组未改变
    • 深拷贝作用
console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        Object.assign(this.targetArr, this.sourceArr);
        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());
  • 测试复杂数据
    • 源数组sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2 }, { ‘S’ : 10, ‘T’ : 20 } ]
    • 目标数组targetArrAndObj: []
  • 操作
    • 增加目标数组数据属性[C、D]
    • 修改属性[S、T]
  • 输出
    • sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
    • targetArrAndObj：[ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
  • 结果&结论
    • 源数组改变，与目标数组一样
    • 浅拷贝作用
console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        Object.assign(this.targetArrAndObj, this.sourceArrAndObj);
        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);

3. concat()/slice()-简单数据深拷贝、复杂数据浅拷贝

目标数组=源数组.concat();

目标数组=源数组.slice();

  • 测试简单数据
    • 源数组sourceArr：[‘a’, ‘b’, ‘c’]
    • 目标数组targetArr：[]
  • 操作
    • 增加目标数组数据[d、e]
  • 输出
    • sourceArr= a,b,c
    • targetArr = a,b,c,d,e
  • 结果&结论
    • 源数组未改变
    • 深拷贝作用
console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        this.targetArr = this.sourceArr.concat();
        // this.targetArr = this.sourceArr.slice();

        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());
  • 测试复杂数据
    • 源数组sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2 }, { ‘S’ : 10, ‘T’ : 20 } ]
    • 目标数组targetArrAndObj: []
  • 操作
    • 增加目标数组数据属性[C、D]
    • 修改属性[S、T]
  • 输出
    • sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
    • targetArrAndObj：[ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
  • 结果&结论
    • 源数组改变，与目标数组一样
    • 浅拷贝作用
console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArrAndObj = this.sourceArrAndObj.concat();
        // this.targetArrAndObj = this.sourceArrAndObj.slice();

        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);

4. JSON.parse(JSON.stringify())-简单数据、复杂数据均为深拷贝

目标数组=JSON.parse(JSON.stringify(源数组))

  • 测试简单数据
    • 源数组sourceArr：[‘a’, ‘b’, ‘c’]
    • 目标数组targetArr：[]
  • 操作
    • 增加目标数组数据[d、e]
  • 输出
    • targetArr = a,b,c,d,e
    • sourceArr= a,b,c
  • 结果&结论
    • 源数组未改变
    • 深拷贝作用
console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        this.targetArr = JSON.parse(JSON.stringify(this.sourceArr));

        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());
  • 测试复杂数据
    • 源数组sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2 }, { ‘S’ : 10, ‘T’ : 20 } ]
    • 目标数组targetArrAndObj: []
  • 操作
    • 增加目标数组数据属性[C、D]
    • 修改属性[S、T]
  • 输出
    • sourceArrAndObj：[ { ‘A’ : 1, ‘B’:2 }, { ‘S’ : 10, ‘T’ : 20 } ]
    • targetArrAndObj：[ { ‘A’ : 1, ‘B’:2, ‘C’ : 3, ‘D’ : 4 }, { ‘S’ : 30, ‘T’ : 40 } ]
  • 结果&结论
    • 源数组未改变
    • 深拷贝作用
console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArrAndObj = JSON.parse(JSON.stringify(this.sourceArrAndObj));

        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);

参考代码

const copy = {

    sourceArr: ['a', 'b', 'c'],
    targetArr: [],
    sourceArrAndObj: [
        {
            'A': 1,
            'B': 2
        },
        {
            'S': 10,
            'T': 20
        }
    ],
    targetArrAndObj: [],

    /**
     * = 赋值
     */
    equalSign: function () {

        console.log('sourceArr = ', this.sourceArr.join());
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArr = this.sourceArr;
        this.targetArrAndObj = this.sourceArrAndObj;
        console.log('赋值后：targetArr = ', this.targetArr.join());
        console.log('赋值后：targetArrAndObj=', this.targetArrAndObj);

        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');
        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
    },

    /**
     * Object.assign()
     */
    objectAssign: function () {
        console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        Object.assign(this.targetArr, this.sourceArr);
        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());


        console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        Object.assign(this.targetArrAndObj, this.sourceArrAndObj);
        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);
    },

    /**
     * concat方法
     */
    concataAndSlice: function () {
        console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        this.targetArr = this.sourceArr.concat();
        // this.targetArr = this.sourceArr.slice();

        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());

        console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArrAndObj = this.sourceArrAndObj.concat();
        // this.targetArrAndObj = this.sourceArrAndObj.slice();

        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);
    },

    /**
     * json转换
     */
    json2array: function () {
        console.log('=========简单数组对象=========');
        console.log('sourceArr = ', this.sourceArr.join());
        this.targetArr = JSON.parse(JSON.stringify(this.sourceArr));

        console.log('拷贝后：targetArr = ', this.targetArr.join());
        console.log('=====增加目标数组数据[d、e]');
        this.targetArr.push('d');
        this.targetArr.push('e');

        console.log('更新后：sourceArr = ', this.sourceArr.join());
        console.log('更新后：targetArr = ', this.targetArr.join());

        console.log('=========复杂数组对象=========')
        console.log('sourceArrAndObj=', this.sourceArrAndObj);
        this.targetArrAndObj = JSON.parse(JSON.stringify(this.sourceArrAndObj));

        console.log('拷贝后：targetArrAndObj=', this.targetArrAndObj);
        console.log('=====增加目标数组数据属性[C、D]；修改属性[S、T]');

        this.targetArrAndObj[0].C = 3;
        this.targetArrAndObj[0].D = 4;
        this.targetArrAndObj[1].S = 30;
        this.targetArrAndObj[1].T = 40;

        console.log('更新后：sourceArrAndObj=', this.sourceArrAndObj);
        console.log('更新后：targetArrAndObj=', this.targetArrAndObj);

    },


    test: function () {
        this.equalSign();
        // this.objectAssign();
        // this.concataAndSlice();
        // this.json2array();
    }


}

copy.test();
芒果-橙
关注
  • 10
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
js数组拷贝
xieqiuyuelx的博客
02-18 6921
1、数组的直接赋值属于数组的浅拷贝，JS存储对象都是存内存地址的，所以浅拷贝会导致新数组和旧数组共用同一块内存地址，其中一个数组变化，另一个数组也会相应的变化。 var a =[1,2,3];var b=a;a[0]=30;console.log(a,b); 结果： [30, 2, 3] [30, 2, 3] 2、数组内部不含有引用类型，使用slice() 、concat() 和 assign() 方法都属于数组的深拷贝，一个数组变化，另一个数组不受影响。 数组的concat方法 var a=[..
javascript二维数组和对象的深拷贝与浅拷贝实例分析
10-16
在JavaScript编程中，深拷贝和浅拷贝是两种处理复杂数据结构（如二维数组和对象）时常见的复制方法。这两种拷贝的区别在于它们如何处理数据的引用。 **浅拷贝**指的是创建一个新对象或数组，这个新对象或数组包含...
JS数组和对象的深拷贝方法
drakseason的博客
07-25 1043
在学习JS数组和对象的深拷贝方法前，我们必须了解JS的变量存储方式，这样才能更好的了解深浅拷贝！栈：自动分配内存空间，系统自动释放，里面存放的是基本类型的值和引用类型的地址（指针）。堆：动态分配的内存，大小不定，也不会自动释放，里面存放引用类型的值。目前只是一些比较简单的深拷贝方法，还有其他深拷贝方法，未完待续…JS 的变量存储方式： 栈（stack）和堆（heap）。
JavaScript 数组的深拷贝
howeres的博客
12-08 648
a 数组连接 x 数组，并且返回一个新的数组
JSON.parse(JSON.stringify('XXXX'))原来是用来实现深拷贝的呀
txwsmsm7023_的博客
08-16 741
在提交表单的时候有时候需要我们将提交的数据中的某些需要删除数据对象中的某个元素，所以用JSON.parse(JSON.stringify(obj))来实现深拷贝得到一个对象，将该对象传给下个请求做参数 JSON.parse(JSON.stringify(obj))我们一般用来深拷贝，其过程说白了 就是利用JSON.stringify 将js对象序列化（JSON字符串），再使用JSON.parse...
javascript 实现对象和数组深拷贝的几种常见方法
Smile0L0的博客
06-29 2873
JavaScript 中的数据类型可以分为： 基本类型：string，number，boolean，undefined，null 引用类型：array，object （array 本质上也是 object） 假如存在两个变量，a 和 b ，在执行 a = b 的操作时，基本类型采用值传递，引用类型采用地址传递。关于值传递和地址传递，大概就是，值传递会在内存中单独的开辟一片空间存储数据，a 在内存中有自己的存储空间，b 在内存中也有自己的存储空间，a 和 b 已经没有什么关系了。而地址传递只是增加了一个地
JS赋值、浅拷贝和深拷贝（数组和对象的深浅拷贝）实例详解
11-20
本文实例讲述了JS赋值、浅拷贝和深拷贝（数组和对象的深浅拷贝）。分享给大家供大家参考，具体如下： 深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。  浅拷贝 只是拷贝了基本类型的数据，而引用类型...
JS 数组和对象的深拷贝操作示例
10-15
在JavaScript中，深拷贝是创建一个新对象，这个新对象复制了原始对象的所有属性，并且对于包含的对象引用，深拷贝会递归地复制这些引用的对象，而不是仅仅复制引用。这样，修改原始对象不会影响到深拷贝后的对象。在...
javascript中数组深拷贝途径及对象数组深拷贝
01-08
javascript中数组深拷贝途径及对象数组深拷贝 什么是浅拷贝 在js当中，我们常常遇到数组复制的的情况，许多人一般都会使用“=”来直接把一个数组赋值给一个变量，如： var a=[1,2,3]; var b=a; console.log(b);　...
JavaScript数组深拷贝和浅拷贝的两种方法
01-21
例如这个例子： 代码如下:var arr = [“One”,”Two”,”Three”];...像上面的这种直接赋值的方式就是浅拷贝，很多时候，这样并不是我们想要得到的结果，其实我们想要的是arr的值不变，不是吗？ 方法一：js的sli
js实现数组和对象的深浅拷贝
10-19
主要为大家详细介绍了js实现数组和对象的深浅拷贝，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JS实现数组深拷贝的方法分析
10-17
在JavaScript中，数组的深拷贝是指创建一个新数组，该数组包含原始数组的所有元素，并且这些元素如果是对象或数组，也会被递归地深度复制。这样，原始数组的任何修改都不会影响到深拷贝后的数组。以下是对JS实现数组...
vue 使用lodash实现对象数组深拷贝操作
10-14
深拷贝与浅拷贝的区别在于，深拷贝会创建一个全新的对象，包含原始对象的所有属性和值，包括嵌套对象和数组的每一个元素。当修改拷贝后对象的任何属性时，都不会影响到原始对象。这在处理复杂数据结构时尤其重要，...
JavaScript深拷贝和浅拷贝概念与用法实例分析
01-19
本文实例讲述了JavaScript深拷贝和浅拷贝概念与用法。分享给大家供大家参考，具体如下： js中的浅拷贝和深拷贝，只是针对复杂数据类型(Objcet，Array)的复制问题。简单来讲浅拷贝和深拷贝都可以实现在原有对象的基础...
JavaScript基础心法 深浅拷贝(浅拷贝和深拷贝)
12-09
前言 说到深浅拷贝，必须先提到的是JavaScript的...浅拷贝的意思就是只复制引用，而未复制真正的值。 const originArray = [1,2,3,4,5]; const originObj = {a:'a',b:'b',c:[1,2,3],d:{dd:'dd'}}; const cloneArray =
JS/JavaScript中解析JSON --- JSON.parse()、JSON.stringify()以及$.parseJSON()使用详解
热门推荐
有范管理美学 | 公众号/头条号：有范管理美学
12-20 4万+
现在JSON格式在web开发中非常重要，特别是在使用ajax开发项目的过程中，经常需要将后端响应的JSON格式的字符串返回到前端，前端解析成JS对象值（JSON 对象），再对页面进行渲染。 在数据传输过程中，JSON是以文本，即字符串的形式传递的，而JS操作的是JSON对象，所以，JSON对象和JSON字符串之间的相互转换是关键。
JS拷贝的几种方法
Venchi的博客
03-18 8852
1. 遍历,就是把对象的属性遍历一遍，赋给一个新的对象。 var deepCopy= function(source) { var result={}; for (var key in source) { result[key] = typeof source[key]===’object’? deepCoyp(source[key]): sou...
接收json数组_JSON.parse()方法，将数据(字符串)转化为javascript对象
weixin_39617252的博客
12-17 696
Json经常用于与服务端交换数据。但是接收的数据一般都是字符串，我们需要先把它转换为javascript对象，才能继续使用它！举例： 这串数据是我们接收的： {"name":"靓仔","age":24,"gender":“男”}var data=JSON.parse('{"name":"靓仔","age":24,"gender":“男”}');$("body").text(obj.name);//...
JS 对象数组深拷贝
weixin_57953310的博客
08-31 515
JS 对象数组深拷贝
js数组的深拷贝和浅拷贝
最新发布
05-24
JavaScript 中的数组拷贝分为浅拷贝和深拷贝两种方式： 1.浅拷贝： 浅拷贝只是拷贝了对象或数组的引用，两个变量指向同一个内存地址，修改其中一个，另一个也会随之修改。常见的实现方式有：Object.assign()、Array...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芒果-橙

谢谢啦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值