手写实现数组部分方法一

已于 2022-04-06 01:15:23 修改
阅读量587 收藏 1
点赞数
分类专栏： 手写源码 JS基础 文章标签： javascript 前端
于 2021-12-11 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46864830/article/details/121867671
版权

前言

前端工作中进行前后端联调数据，我们常常拿到的是后端返回给我们 json 数据，然而进行渲染的注意数据还是存放在数组当中，这时拿到的数据常常也不是我们想要格式而是进行一系列的整合，而实现整合就离不开数组常用方法

最近把数组的常用方法都手写了一遍，整理到了一块儿，顺便就分享出来，如有不合理之处请评论处指出

push

push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度，改变原数组

/**
 * push 方法可应用在类似数组的对象上
 * 接收参数个数无限制，可以是字符串、数值或引用类型，返回原数组的长度
 * 遍历参数，每遍历一个参数，原数组长度加 1，并把这个参数赋给这个新的索引，最后返回原数组长度
 */
Array.prototype.push = function(...args) {
  let O = Object(this);  // ecma 中提到的先转换为对象（使用包装类进行包装），因为 push 可应用在类似数组的对象上
  // 如果想之应用数组上，上面那行可以省略直接保存 this 
  let len = this.length >>> 0;  // 使用位运算进行将传入不合法数据转化为整数
  let argCount = args.length >>> 0;
  // 遍历参数
  for(let i = 0; i < argCount; i++) {
    O[len + i] = items[i];
  }
  let newLength = len + argCount;  // 添加后的总数组长度
  O.length = newLength;
  return newLength;
}

// 测试代码
var arr = [1, 2, 3, 4];
console.log(arr.push(5, 6, 7, 8));   // 8 
console.log(arr);  // [1, 2, 3, 4, 5, 6, 7, 8]

pop

pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度，所以改变原数组

/**
 * pop 方法具有通用性，可应用在类似数组的对象上
 * 不接受参数，删除原数组最后一项，当数组为空时返回 undefined
 * 原数组长度减 1，返回被删除的项
 */ 
Array.prototype.pop = function() {
  let O = Object(this);  // 获取 this 指向
  let len = this.length >>> 0;
  // 空数组情况
  if (len === 0) {
    O.length = 0;
    return undefined;
  }
  len --;
  let value = O[len];
  delete O[len];
  O.length = len;
  return value;
}

// 测试代码
var arr = [1, 2, 3, 4];
console.log(arr.pop());  // 4
console.log(arr);  // [ 1, 2, 3 ]

unshift

unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)

/** 
 * unshift 方法可以作用于类数组对象上
 * 接收不限个数的参数 
 * 返回原数组长度
 * 先将把原数组所有项后移一位，然后遍历参数在数组头部添加该参数
 */
Array.prototype.unshift = function (...args) {
    let O = Object(this);
    let len = this.length >>> 0;
    let argCount = args.length >>> 0;
    // 当空数组时
    if (len === 0) {
        for (let i = 0; i < argCount; i++) {
            O[i] = args[i];
        }
        return argCount;
    }
    // 把原数组往后移动
    for (let i = argCount + len - 1; i > argCount - 1; i--) {
        O[i] = O[i - len];
    }
    // 将形参数据遍历放数组前
    for (let i = 0; i < argCount; i++) {
        O[i] = args[i];
    }
    return O.length;
}

// 测试代码
var arr = [];
console.log(arr.unshift(1, 2, 3, 4));  // 4
console.log(arr); // [ 1, 2, 3, 4 ]

shift

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度，原数组改变

/** 
 * shift 方法不局限于数组，作用于类似数组的对象上
 * 不接受参数，如果数组为空则返回 undefined
 * 把原数组中所有的项向前移一位，原数组长度减一
 */   
Array.prototype.shift = function () {
   let O = Object(this);
   let len = this.length >>> 0;
   // 空数组情况
  if (len === 0) {
    O.length = 0;
    return undefined;
  }
   let result = O[0];
   for (let i = 0; i < len - 1 ; i++) {
    	O[i] = O[i + 1]
   }
   len --;
   O.length = len;
   return result
}

// 测试
var arr = [];
console.log(arr.shift());  // undefined
console.log(arr);  // []
var arr = [1, 2, 3, 4];
console.log(arr._shift());  // 1
console.log(arr); // [2,3,4]

forEach

forEach() 方法对数组的每个元素执行一次给定的函数

/** 
 * forEach 方法
 *  接收一个函数参数和一个函数执行作用域的参数（可选）
 *  回调函数参数函数也接受3个参数，分别是数组当前项的值，当前数组当前项的索引（可选），当前数组对象本身（可选）
 *  执行参数函数，默认执行环境为window，不返回任何值
 */
Array.prototype.forEach = function (fn) {
	let O = Object(this);
    let len = this.length >>> 0;
    // 处理做些兼容 node 环境处理（回调函数this指向）
    let _this = arguments[1] || (typeof window === "undefined" ? {} : window);
    // 传入的不是回调函数
    if (typeof fn !== "function") {
      throw new TypeError(fn + ' is not a function');
    }
	// 遍历传入回调函数
    for (let i = 0; i < len; i++) {
   		// 改变 this 指向
        fn.apply(_this, [O[i], i, O])
    }
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
arr.forEach((item, index, self) => {
    console.log(item, index, self, this)
}, obj)

// 1 0 [ 1, 2, 3, 4, 5 ] 
// 2 1 [ 1, 2, 3, 4, 5 ]
// 3 2 [ 1, 2, 3, 4, 5 ] 
// 4 3 [ 1, 2, 3, 4, 5 ] 
// 5 4 [ 1, 2, 3, 4, 5 ]

map

map() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成

/** 
 * map 方法
 * 接收一个函数参数和一个函数执行作用域的参数（可选）
 * 参数函数也接受3个参数，分别是数组中正在处理的当前元素，数组中正在处理的当前元素的索引（可选），当前调用的数组（可选）
 * 执行参数函数，默认执行环境为window
 */
Array.prototype.map = function (fn) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[1] || (typeof window === "undefined" ? {} : window);
    // 传入的不是回调函数
    if (typeof fn !== "function") {
      throw new TypeError(fn + ' is not a function');
    }
    let newArr = new Array(len);
    for (let i = 0; i < len; i++) {
        // 将每次返回的结果获取得到映射关系
        newArr[i] = fn.apply(_this, [O[i], i, O]);
    }
    return newArr
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.map((item, index, self) => {
    console.log(item, index, self, this);
    // 1 0 [ 1, 2, 3, 4, 5 ] 
	// 2 1 [ 1, 2, 3, 4, 5 ] 
	// 3 2 [ 1, 2, 3, 4, 5 ] 
	// 4 3 [ 1, 2, 3, 4, 5 ] 
	// 5 4 [ 1, 2, 3, 4, 5 ] 
    return item + 2;
}, obj);
console.log(newArr);  // [ 3, 4, 5, 6, 7 ]

filter

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

/** 
 * filter 方法
 * 接收一个函数参数和一个函数执行作用域的参数（可选）
 * 参数函数也接受3个参数，分别是前正在处理的元素，正在处理的元素在数组中的索引（可选），调用了 filter 的数组本身（可选）
 * 执行参数函数，默认执行环境为window
 */ 
Array.prototype.filter = function (fn) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[1] || (typeof window === "undefined" ? {} : window);
    if (typeof fn !== "function") {
      throw new TypeError(fn + ' is not a function');
    }
    let newArr = [];
    if(len === 0) return newArr;
    for (let i = 0; i < len; i++) {
        // 根据函数返回值判断真假符合要求
        fn.apply(_this, [O[i], i, O]) && newArr.push(O[i]);
    }
    return newArr
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.filter((item, index, self) => {
    console.log(item, index, self, this);
    // 1 0 [ 1, 2, 3, 4, 5 ] 
    // 2 1 [ 1, 2, 3, 4, 5 ] 
	// 3 2 [ 1, 2, 3, 4, 5 ]
    // 4 3 [ 1, 2, 3, 4, 5 ] 
    // 5 4 [ 1, 2, 3, 4, 5 ] 
    return item > 3
}, obj)
console.log(newArr );  // [ 4, 5 ]

some

some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值

如果用一个空数组进行测试，在任何情况下它返回的都是 false

/**
 * some 方法
 * 接收一个函数参数和一个函数执行作用域的参数（可选）
 * 参数函数也接受3个参数，分别是正在处理的元素，当前正在处理的元素的索引值（可选），当前some()被调用的数组（可选）
 * 执行参数函数，默认执行环境为window
 * 数组中有至少一个元素通过回调函数的测试就会返回true；所有元素都没有通过回调函数的测试返回值才会为false
 */ 
Array.prototype.some = function (fn) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[1] || (typeof window === "undefined" ? {} : window);
    if (typeof fn !== "function") {
      	throw new TypeError(fn + ' is not a function');
    }
    if(len === 0) return false;
    for (let i = 0; i < len; i++) {
        // 遇到函数返回 true 最终就是返回 true
        if (fn.call(_this, 	O[i], i, O)) {
            return true;
        }
    }
    return false
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.some((item, index, self) => {
    console.log(item, index, self, this);
    // 1 0 [ 1, 2, 3, 4, 5 ]
	// 2 1 [ 1, 2, 3, 4, 5 ] 
	// 3 2 [ 1, 2, 3, 4, 5 ] 
    return item > 2
}, obj)
console.log(newArr ); // true

every

every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值

若收到一个空数组，此方法在一切情况下都会返回 true

/**
 * every 方法
 * 接收一个函数参数和一个函数执行作用域的参数（可选），
 * 参数函数也接受3个参数，分别是用于测试的当前值，当前用于测试的当前值的索引（可选），当前调用 every 的当前数组（可选）
 * 执行参数函数默认执行环境为window
 * 如果回调函数的每一次返回都为 true 值，返回 true ，否则返回 false
 */  
Array.prototype.every = function (fn) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[1] || (typeof window === "undefined" ? {} : window);   // 作用域 this 指向可能在 node 运行环境中
    if (typeof fn !== "function") {
      	throw new TypeError(fn + ' is not a function');
    }
    if(len === 0) return true;
    for (let i = 0; i < len; i++) {
        // 遇到函数返回 true 最终就是返回 true
        if (!fn.call(_this, O[i], i, O)) {
            return false;
        }
    }
    return true
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.every((item, index, self) => {
    console.log(item, index, self, this);
    // 1 0 [ 1, 2, 3, 4, 5 ] 
	// 2 1 [ 1, 2, 3, 4, 5 ] 
	// 3 2 [ 1, 2, 3, 4, 5 ] 
    return item < 3
})
console.log(newArr);  // false
var arr = [];
console.log(arr.every((item) => item > 6));  // true

reduce

reduce() 方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值

reduce() 是高阶函数，常用于计算求和操作

/* 
* reduce 方法
* 接收函数参数和一个初始值，初始值默0，
* 参数函数也有四个参数，分别是上一次调用 callbackFn 时的返回值，正在处理的元素，正在处理的元素的索引，当前用于遍历的数组
* 遍历数组，依次把当前项与上一项之和，当前项的值，当前项索引，当前数组传入参数函数
* 执行参数函数，并把归并后的值保存下来，提供给下一项使用，使用 “reducer” 回调函数遍历整个数组后的结果
*/
Array.prototype.reduce = function (fn, initialValue) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[2] || (typeof window === "undefined" ? {} : window);   // 作用域 this 的指向
    if (typeof fn !== "function") {
      	throw new TypeError(fn + ' is not a function');
    }
    let i = initialValue ? 0 : 1;
    // 是否有默认值没有则默认数组第一项
    initialValue = initialValue ? initialValue : O[0];
    for (; i < len; i++) {
        initialValue = fn.apply(_this, [initialValue, O[i], i, O]);
    }
    return initialValue
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.reduce((prev, curr, index, self) => {
    console.log(prev, curr, index, self);
    // 1 2 1 [ 1, 2, 3, 4, 5 ]
    // 3 3 2 [ 1, 2, 3, 4, 5 ]
    // 6 4 3 [ 1, 2, 3, 4, 5 ] 
    // 10 5 4 [ 1, 2, 3, 4, 5 ]
    return prev + curr
})
console.log(newArr );  // 15
var newArr = arr.reduce((prev, curr, index, self) => {
    console.log(prev, curr, index, self);
   	// 10 1 0 [ 1, 2, 3, 4, 5 ]
	// 11 2 1 [ 1, 2, 3, 4, 5 ]
	// 13 3 2 [ 1, 2, 3, 4, 5 ]
	// 16 4 3 [ 1, 2, 3, 4, 5 ]
	// 20 5 4 [ 1, 2, 3, 4, 5 ]
    return prev + curr
},10)
console.log(newArr );  // 25

reduceRight

reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值

/* 
* reduceRight 方法
* 接收函数参数和一个初始值，
* 参数函数也有四个参数，分别是上一次调用 callbackFn 时的返回值，正在处理的元素，正在处理的元素的索引，当前用于遍历的数组
* 遍历数组，依次把当前项与上一项之和，当前项的值，当前项索引，当前数组传入参数函数
*/
Array.prototype.reduceRight = function (fn, initialValue) {
    let O = Object(this);
    let len = this.length >>> 0;
    let _this = arguments[2] || (typeof window === "undefined" ? {} : window);   // 作用域 this 的指向
    if (typeof fn !== "function") {
      	throw new TypeError(fn + ' is not a function');
    }
    initialValue = null;  // 利用 null 转化为数字时为 0 ===> 此方法没有 initialValue 跟自带 reduce 相比会多循环一次
    for (let i = len - 1; i >= 0; i--) {
        initialValue = fn.apply(_this, [initialValue, O[i], i, O]);
    }
    return initialValue
}

// 测试代码
var arr = [1, 2, 3, 4, 5];
var obj = {
    a: 1,
    b: 2,
}
var newArr = arr.reduceRight((prev, curr, index, self) => {
    console.log(prev, curr, index, self);
    // null 5 4 [ 1, 2, 3, 4, 5 ]
	// 5 4 3 [ 1, 2, 3, 4, 5 ]
	// 9 3 2 [ 1, 2, 3, 4, 5 ]
	// 12 2 1 [ 1, 2, 3, 4, 5 ]
	// 14 1 0 [ 1, 2, 3, 4, 5 ]
    return prev + curr
});
console.log(newArr); // 15
染墨^O^
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写模拟实现find，findIndex，some，every，map，filter，reduce
bigfatDone的博客
05-25 898
1. 模拟实现find let arrFind = [12,15,19] Array.prototype.myFind = function(fn) { //必须使用function不能使用箭头函数，this指向调用的数组 if(typeof fn != 'function'){ throw TypeError('err function') } for(let i = 0; i < this.length; i++){ if
手写数组
有光
02-08 200
#include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct Add{ int * pBase; int len; int cnt; }Arr; void show_arr(Add * pArr); void init_arr(Add * pArr, int leng...
JavaScript进阶手写系列，手写13个数组方法的原理实现
秋天，黄叶坠地，凉风有信。
03-22 2334
文章目录JavaScript进阶手写系列，手写数组方法的原理实现1、forEach2、map3、filter4、every5、some6、reduce7、findIndex8、find9、fill10、includes11、join12、flat13、splice JavaScript进阶手写系列，手写数组方法的原理实现 1、forEach 参数代表含义 item：遍历项 index：遍历项的索引 arr：数组本身 // forEach Array.prototype.myForEach = func
【push,pop,shift,unshift】手写数组push,pop,shift,unshiftt方法
xh1506101064的博客
11-05 821
操作数组的方法有很多，这里先手写部分 ，主要是push , shift，pop，unshift从实现看具体的区别push：将一个或多个元素添加到数组的末尾，并返回该数组的新长度。pop： 从数组中删除最后一个元素，并返回该元素的值。shift：从数组中删除第一个元素，并返回该元素的值。unshift：将一个或多个元素添加到数组的开头。开始吧~~
手写实现数组方法之去重、concat、slice 和 扁平化
浮生离梦的博客
08-22 1028
一、数组去重 数组的去重，有三种方法，如下所示： 利用 forEach() 和 indexOf()，本质上是双重遍历，效率差些 利用 forEach() + 对象容器，只需一重遍历，效率高些 利用 ES6 语法：from + Set 或者 ... + set，编码简洁 数组去重的实现，代码如下所示： function unique1 (arr) { // 声明一个空数组 const result = []; // 遍历原始数组 arr.forEach(item => {
数据结构——数组（JAVA）
蜡笔小贤的博客
05-20 176
实现动态数组 在数据结构中，有一种数据结构叫数组。在很多人眼中数组很简单，不就是int[] num = new int[10];嘛 如果这样想的小盆友就答错特错了。 先上代码吧，这是动态数组实现的实现 /** * Created by XiaoXian on 2020/5/18. */ public class Array<E> { private E[] data; //数组游标，一开始指向0 private int size; /** *
基于PythonKNN算法实现手写数字识别的三种方法（源码）
最新发布
05-30
在本项目中，我们主要探讨的是如何利用Python编程语言实现基于K近邻(K-Nearest Neighbors, KNN)算法的手写数字识别。KNN是一种简单而强大的非参数机器学习算法，广泛应用于分类任务，包括手写数字识别。MNIST数据集...
Android编程实现的手写板和涂鸦功能
01-20
在Android开发中，实现手写板和涂鸦功能是一项常见的需求，这通常涉及到用户交互、图形绘制以及数据存储等多个方面。以下将详细讲解如何通过编程实现在Android应用中创建这样的功能。 首先，我们需要一个布局文件来...
js代码-手写Array的map方法
07-16
在JavaScript中，`Array.prototype.map()` 是一个非常重要的方法，它允许我们遍历数组中的每个元素，并根据提供的函数返回一个新的数组。这个新数组中的元素是原数组元素经过处理后的结果。在本项目中，我们将深入...
python不使用框架实现卷积神经网络识别手写数字
02-19
在本项目中，我们不依赖任何特定的深度学习框架，如TensorFlow或PyTorch，而是直接用Python实现一个CNN来识别手写数字。这种实践可以帮助我们更深入地理解CNN的工作原理，以及如何通过编程实现这些概念。 手写数字...
MINIST手写识别（前向传播的python实现）
12-22
标题中的"MINIST手写识别（前向传播的python实现）"指的是使用Python编程语言实现的基于前向传播算法的手写数字识别系统，这个系统针对的是MINIST数据集。MINIST是一个广泛使用的手写数字图像数据库，包含60,000个...
JavaScript手写数组的常用函数总结
01-21
前言 在开发过程中，我们常常使用数组的一些 api 相关操作，其中包含 forEach 、 filter 、 find 、 findIndex 、 map 、 some 、 every 、 reduce 、 reduceRight 等函数方法。 今天，我们试试手写这些函数，实现数组这些函数方法。为了方便，直接在数组原型对象 prototype 上扩展。 本文 Githab 已上传，更多往期文章已分类整理。 正文 参数说明 callbackFn 回调函数 thisArg 执行 callbackFn 时使用的 this 值 currentValue 数组中正在处理的元素 index 当前索引
手写数组方法之用于遍历的方法
qq_45272642的博客
12-05 312
forEach，map，flatMap，find，findIndex，filter，some，every，reduce，reduceRight,
手写系列---map（高阶函数）
qq_38253873的博客
03-19 1106
我们都知道map函数是数组里面的常用函数，先看看map函数具体做了什么 var array = [1,2,3,4] /* map方法第一个参数为一个回调函数，该函数拥有三个参数 //第一个参数代表array数组中的每一项 //第二个参数代表当前遍历的索引值 //第三个参数代表数组本身 该函数中的this指向map方法的第二个参数，如果无则this指向丢失 */ var newArray = ar...
手写实现数组的方法
qq_38917309的博客
08-03 235
手写实现数组的方法 文章目录手写实现数组的方法someeveryfiltermapreduce some 该方法用于检测数组中的元素是否满足指定条件 ，只要有一个满足就返回true,否则false.不会改变原数组。 let data=[1,2,3]; Array.prototype.mySome=function(fn){ // fn=item => {return item > 2} if(typeof fn!='function'){ throw new Type
数组原型上的方法实现原理（Array.prototype.pop/push/shift/unshift）
pony的博客
01-15 3458
html> html lang="en"> head> meta charset="UTF-8"> title>数组原型上的方法实现原理title> head> body> body> html> script type="text/javascript"> var ary=[1,2,3,4,5,6,7,8]; //pop() Array.prototyp
Array.prototype.push() 源码探究
pspxuan的博客
10-21 654
在学习阮一峰老师的《ES6入门》的数组的扩展运算符时遇到了这样一串代码 // ES5的 写法 var arr1 = [0, 1, 2]; var arr2 = [3, 4, 5]; Array.prototype.push.apply(arr1, arr2); // ES6 的写法 let arr1 = [0, 1, 2]; let arr2 = [3, 4, 5]; arr1.push(......
js数组合并concat()和Array.prototype.push.apply()的性能分析
热门推荐
maoguiyou的专栏
05-17 2万+
js数组合并有两个常用方法，用法如下： var a=[1,2,3],b=[4,5,6]; 1.a.concat(b);//得到1,2,3,4,5,6； 1.1那个数组在前面合并后那个数组的元素就在前面 1.2 可以利用这个来复制一份数组，a.concat(a); 1.3 数组长度无限制，返回值是合并后的数组 1.4 千万级别的数组合并大约30毫秒 2.Array.protot
JS中Array方法中常用方法五：Array.prototype.push()
......
09-14 3774
Array.prototype.push()添加一个或多个元素到数组的末尾，并返回数组新的长度（length 属性值）。 语法：arr.push(element1, ..., elementN) 举例如下： //(1)添加元素到数组 var sports = ["soccer", "baseball"]; var total = sports.push("football", "sw
用python实现手写数字识别
04-03
# 随机选取一部分数据作为训练集，剩下的作为测试集 train_images, test_images, train_labels, test_labels = train_test_split( images, labels, test_size=0.25, random_state=0) # 对训练集数据进行预处理，如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值