强悍的javascript手势库

最新推荐文章于 2021-05-27 10:40:55 发布
置顶 最新推荐文章于 2021-05-27 10:40:55 发布
阅读量3k 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libin_1/article/details/52551527
版权 
/**
 * Toucher
 * git：https://github.com/cometwo/Toucher-1
 */

"use strict";

(function (root, factory) {
    if (typeof define === "function" && define.amd) {
        define([], function () {
            return factory(root);
        });
    } else {
        root.Toucher = factory(root);
    }
}(window, function (root, undefined) {

    if (!"ontouchstart" in window) {
        return;
    }

    var _wrapped;

    //  获取对象上的类名
    function _typeOf(obj) {
        return Object.prototype.toString.call(obj).toLowerCase().slice(8, -1);
    }

    //  获取当前时间戳
    function getTimeStr() {
        return +(new Date());
    }

    //  获取位置信息
    function getPosInfo(ev) {
        var _touches = ev.touches;
        if (!_touches || _touches.length === 0) {
            return;
        }
        return {
            pageX: ev.touches[0].pageX,
            pageY: ev.touches[0].pageY,
            clientX: ev.touches[0].clientX || 0,
            clientY: ev.touches[0].clientY || 0
        };
    }

    //  绑定事件
    function bindEv(el, type, fn) {
        if (el.addEventListener) {
            el.addEventListener(type, fn, false);
        } else {
            el["on" + type] = fn;
        }
    }

    //  解绑事件
    function unBindEv(el, type, fn) {
        if (el.removeEventListener) {
            el.removeEventListener(type, fn, false);
        } else {
            el["on" + type] = fn;
        }
    }

    //  获得滑动方向
    function getDirection(startX, startY, endX, endY) {
        var xRes = startX - endX;
        var xResAbs = Math.abs(startX - endX);
        var yRes = startY - endY;
        var yResAbs = Math.abs(startY - endY);
        var direction = "";

        if (xResAbs >= yResAbs && xResAbs > 25) {
            direction = (xRes > 0) ? "Right" : "Left";
        } else if (yResAbs > xResAbs && yResAbs > 25) {
            direction = (yRes > 0) ? "Down" : "Up";
        }
        return direction;
    }

    //  取得两点之间直线距离
    function getDistance(startX, startY, endX, endY) {
        return Math.sqrt(Math.pow((startX - endX), 2) + Math.pow((startY - endY), 2));
    }

    function getLength(pos) {
        return Math.sqrt(Math.pow(pos.x, 2) + Math.pow(pos.y, 2));
    }

    function cross(v1, v2) {
        return v1.x * v2.y - v2.x * v1.y;
    }

    //  取向量
    function getVector(startX, startY, endX, endY) {
        return (startX * endX) + (startY * endY);
    }

    //  获取角度
    function getAngle(v1, v2) {
        var mr = getLength(v1) * getLength(v2);
        if (mr === 0) {
            return 0
        }
        ;
        var r = getVector(v1.x, v1.y, v2.x, v2.y) / mr;
        if (r > 1) {
            r = 1;
        }
        return Math.acos(r);
    }

    //  获取旋转的角度
    function getRotateAngle(v1, v2) {
        var angle = getAngle(v1, v2);
        if (cross(v1, v2) > 0) {
            angle *= -1;
        }
        return angle * 180 / Math.PI;
    }

    //  包装一个新的事件对象
    function wrapEvent(ev, obj) {
        var res = {
            touches: ev.touches,
            type: ev.type
        };
        if (_typeOf(obj) === "object") {
            for (var i in obj) {
                res[i] = obj[i];
            }
        }
        return res;
    }

    //  把伪数组转换成数组
    function toArray(list) {
        if (list && (typeof list === "object") && isFinite(list.length) && (list.length >= 0) && (list.length === Math.floor(list.length)) && list.length < 4294967296) {
            return [].slice.call(list);
        }
    }

    //  判断一个元素列表里面是否有多个元素
    function isContain(collection, el) {
        if (arguments.length === 2) {
            return collection.some(function (elItem) {
                return el.isEqualNode(elItem);
            });
        }
        return false;
    }

    //  生成一个随机id
    function uId() {
        return Math.random().toString(16).slice(2);
    }

    //  事件模块
    var Event = (function () {

        var storeEvents = {};

        return {

            //  add an event handle
            add: function (type, el, handler) {
                var selector = el,
                    len = arguments.length,
                    finalObject = {}, _type;
                /**
                 * Event.add("swipe", function() {
                 *      //  ...
                 * });
                 */

                if (_typeOf(el) === "string") {
                    el = document.querySelectorAll(el);
                }

                if (len === 2 && _typeOf(el) === "function") {
                    finalObject = {
                        handler: el
                    };
                } else if (len === 3 && el instanceof HTMLElement || el instanceof NodeList && _typeOf(handler) === "function") {
                    /**
                     * Event.add("swipe", "#div", function(ev) {
                     *      //  ...
                     * });
                     */
                    _type = _typeOf(el);
                    finalObject = {
                        type: _type,
                        selector: selector,
                        el: _type === "nodelist" ? toArray(el) : el,
                        handler: handler
                    };
                }

                if (!storeEvents[type]) {
                    storeEvents[type] = [];
                }

                storeEvents[type].push(finalObject);
            },

            //  remove an event handle
            remove: function (type, selector) {
                var len = arguments.length;
                if (_typeOf(type) === "string" && _typeOf(storeEvents[type]) === "array" && storeEvents[type].length) {
                    if (len === 1) {
                        storeEvents[type] = [];
                    } else if (len === 2) {
                        storeEvents[type] = storeEvents[type].filter(function (item) {
                            return !(item.selector === selector || _typeOf(selector) !== "string" && item.selector.isEqualNode(selector));
                        });
                    }
                }
            },

            //  trigger an event handle
            trigger: function (type, el, argument) {
                var len = arguments.length;

                /**
                 * Event.trigger("swipe", document.querySelector("#div"), {
                 *      //  ...
                 * });
                 */
                if (len === 3 && _typeOf(storeEvents[type]) === "array" && storeEvents[type].length) {
                    storeEvents[type].forEach(function (item) {
                        if (_typeOf(item.handler) === "function") {
                            if (item.type && item.el) {
                                argument.target = el;
                                if (item.type === "nodelist" && isContain(item.el, el)) {
                                    item.handler(argument);
                                } else if (item.el.isEqualNode && item.el.isEqualNode(el)) {
                                    item.handler(argument);
                                }
                            } else {
                                item.handler(argument);
                            }
                        }
                    });
                }
            }
        };
    })();

    //  构造函数
    function Toucher(selector) {
        return new Toucher.fn.init(selector);
    }

    Toucher.fn = Toucher.prototype = {

        //  修改原型构造器
        constructor: Toucher,

        //  初始化方法
        init: function (selector) {
            this.el = selector instanceof HTMLElement ? selector :
                _typeOf(selector) === "string" ? document.querySelector(selector) : null;
            if (_typeOf(this.el) === "null") {
                throw new Error("you must specify a particular selector or a particular DOM object");
            }
            this.scale = 1;
            this.pinchStartLen = null;
            this.isDoubleTap = false;
            this.triggedSwipeStart = false;
            this.triggedLongTap = false;
            this.delta = null;
            this.last = null;
            this.now = null;
            this.tapTimeout = null;
            this.singleTapTimeout = null;
            this.longTapTimeout = null;
            this.swipeTimeout = null;
            this.startPos = {};
            this.endPos = {};
            this.preTapPosition = {};

            this.cfg = {
                doubleTapTime: 400,
                longTapTime: 700
            };

            //  绑定4个事件
            bindEv(this.el, "touchstart", this._start.bind(this));
            bindEv(this.el, "touchmove", this._move.bind(this));
            bindEv(this.el, "touchcancel", this._cancel.bind(this));
            bindEv(this.el, "touchend", this._end.bind(this));
            return this;
        },

        //  提供config方法进行配置
        config: function (option) {
            if (_typeOf(option) !== "object") {
                throw new Error("method Toucher.config must pass in an anguments which is an instance of Object, but passed in " + option.toString());
            }
            for (var i in option) {
                this.cfg[i] = option[i];
            }
            return this;
        },

        //  on方法绑定事件
        /**
         * var toucher = Toucher({...});
         *
         * toucher.on("swipe", function(ev) {
         *     //   ...
         * });
         *
         * //   or
         *
         * toucher.on("tap", "#id", function(ev) {
         *     //   ...
         * });
         *
         * support events: singleTap,longTap,swipe,swipeStart,swipeEnd,swipeUp,swipeRight,swipeDown,swipeLeft,pinch,rotate
         *
         */

        on: function (type, el, callback) {
            var len = arguments.length;
            if(len === 2) {
                Event.add(type, el);
            } else {
                Event.add(type, el, callback);
            }
            return this;
        },

        //  off 解除绑定
        /**
         *  var toucher = Toucher({...});
         *  toucher.off(type);
         *
         *  //  or
         *
         *  toucher.off(type, selector);
         */
        off: function (type, selector) {
            Event.remove(type, selector);
            return this;
        },

        //  手指刚触碰到屏幕
        _start: function (ev) {
            if (!ev.touches || ev.touches.length === 0) {
                return;
            }

            var self = this;
            var otherToucher, v,
                preV = this.preV,
                target = ev.target;

            self.now = getTimeStr();
            self.startPos = getPosInfo(ev);
            self.delta = self.now - (self.last || self.now);
            self.triggedSwipeStart = false;
            self.triggedLongTap = false;

            //  快速双击
            if (JSON.stringify(self.preTapPosition).length > 2 && self.delta < self.cfg.doubleTapTime && getDistance(self.preTapPosition.clientX, self.preTapPosition.clientY, self.startPos.clientX, self.startPos.clientY) < 25) {
                self.isDoubleTap = true;
            }

            //  长按定时
            self.longTapTimeout = setTimeout(function () {
                _wrapped = {
                    el: self.el,
                    type: "longTap",
                    timeStr: getTimeStr(),
                    position: self.startPos
                };
                Event.trigger("longTap", target, _wrapped);
                self.triggedLongTap = true;
            }, self.cfg.longTapTime);

            //  多个手指放到屏幕
            if (ev.touches.length > 1) {
                self._cancelLongTap();
                otherToucher = ev.touches[1];
                v = {
                    x: otherToucher.pageX - self.startPos.pageX,
                    y: otherToucher.pageY - self.startPos.pageY
                };
                this.preV = v;
                self.pinchStartLen = getLength(v);
                self.isDoubleTap = false;
            }

            self.last = self.now;
            self.preTapPosition = self.startPos;

            ev.preventDefault();
        },

        //  手指在屏幕上移动
        _move: function (ev) {
            if (!ev.touches || ev.touches.length === 0) {
                return;
            }

            var v, otherToucher;
            var self = this;
            var len = ev.touches.length;
            var posNow = getPosInfo(ev);
            var preV = self.preV;
            var currentX = posNow.pageX;
            var currentY = posNow.pageY;
            var target = ev.target;

            //  手指移动取消长按事件和双击
            self._cancelLongTap();
            self.isDoubleTap = false;

            //  一次按下抬起只触发一次swipeStart
            if (!self.triggedSwipeStart) {
                _wrapped = {
                    el: self.el,
                    type: "swipeStart",
                    timeStr: getTimeStr(),
                    position: posNow
                };
                Event.trigger("swipeStart", target, _wrapped);
                self.triggedSwipeStart = true;
            } else {
                _wrapped = {
                    el: self.el,
                    type: "swipe",
                    timeStr: getTimeStr(),
                    position: posNow
                };
                Event.trigger("swipe", target, _wrapped);
            }

            if (len > 1) {
                otherToucher = ev.touches[1];
                v = {
                    x: otherToucher.pageX - currentX,
                    y: otherToucher.pageY - currentY
                };

                //  缩放
                _wrapped = wrapEvent(ev, {
                    el: self.el,
                    type: "pinch",
                    scale: getLength(v) / this.pinchStartLen,
                    timeStr: getTimeStr(),
                    position: posNow
                });
                Event.trigger("pinch", target, _wrapped);

                //  旋转
                _wrapped = wrapEvent(ev, {
                    el: self.el,
                    type: "rotate",
                    angle: getRotateAngle(v, preV),
                    timeStr: getTimeStr(),
                    position: posNow
                });
                Event.trigger("rotate", target, _wrapped);
                ev.preventDefault();
            }

            self.endPos = posNow;
        },

        //  触碰取消
        _cancel: function (ev) {
            clearTimeout(this.longTapTimeout);
            clearTimeout(this.tapTimeout);
            clearTimeout(this.swipeTimeout);
            clearTimeout(self.singleTapTimeout);
        },

        //  手指从屏幕离开
        _end: function (ev) {
            if (!ev.changedTouches) {
                return;
            }

            //  取消长按
            this._cancelLongTap();

            var self = this;
            var direction = getDirection(self.endPos.clientX, self.endPos.clientY, self.startPos.clientX, self.startPos.clientY);
            var callback, target = ev.target;

            if (direction !== "") {
                self.swipeTimeout = setTimeout(function () {
                    _wrapped = wrapEvent(ev, {
                        el: self.el,
                        type: "swipe",
                        timeStr: getTimeStr(),
                        position: self.endPos
                    });
                    Event.trigger("swipe", target, _wrapped);

                    //  获取具体的swipeXyz方向
                    callback = self["swipe" + direction];
                    _wrapped = wrapEvent(ev, {
                        el: self.el,
                        type: "swipe" + direction,
                        timeStr: getTimeStr(),
                        position: self.endPos
                    });
                    Event.trigger(("swipe" + direction), target, _wrapped);

                    _wrapped = wrapEvent(ev, {
                        el: self.el,
                        type: "swipeEnd",
                        timeStr: getTimeStr(),
                        position: self.endPos
                    });
                    Event.trigger("swipeEnd", target, _wrapped);
                }, 0);
            } else if (!self.triggedLongTap) {
                self.tapTimeout = setTimeout(function () {
                    if (self.isDoubleTap) {
                        _wrapped = wrapEvent(ev, {
                            el: self.el,
                            type: "doubleTap",
                            timeStr: getTimeStr(),
                            position: self.startPos
                        });
                        Event.trigger("doubleTap", target, _wrapped);
                        clearTimeout(self.singleTapTimeout);
                        self.isDoubleTap = false;
                    } else {
                        self.singleTapTimeout = setTimeout(function () {
                            _wrapped = wrapEvent(ev, {
                                el: self.el,
                                type: "singleTap",
                                timeStr: getTimeStr(),
                                position: self.startPos
                            });
                            Event.trigger("singleTap", target, _wrapped);
                        }, 100);
                    }
                }, 0);
            }

            this.startPos = {};
            this.endPos = {};
        },

        //  取消长按定时器
        _cancelLongTap: function () {
            if (_typeOf(this.longTapTimeout) !== "null") {
                clearTimeout(this.longTapTimeout);
            }
        }
    };

    Toucher.fn.init.prototype = Toucher.fn;

    return Toucher;

}));



Toucher

移动端手势库

API
Toucher("#node").config(Object).on(Object)

    或者

var toucher = Toucher("#node");
toucher.config(Object);
toucher.on(name, callback);

通过

var toucher = Toucher(css selector);

来构造一个Toucher对象

用

toucher.config(Object)

来配置相关事件的触发条件

touch.on(name, callbck);

或

touch.on(name, target, callbck);

来绑定事件

完整示例
//  HTML
<div id="toucher">
    <div id="event"></div>
    <ul>
        <li class="list-item"></li>
        <li class="list-item"></li>
        <li class="list-item"></li>
        <li class="list-item"></li>
        <li class="list-item"></li>
        <li class="list-item"></li>
    </ul>
</div>


//  javascript
var toucher = Toucher("#toucher");

//  回调函数会在任何时候被执行,只要event.target为<div>#toucher或者其子元素
toucher.on("singleTap", function(ev) {
    //  ...
});

//  只有当event.target为<div>#event的时候,才会执行后面的回调函数
toucher.on("singleTap", "#event", function(ev) {
    //  ...
});

//  只有当event.target为<li>.list-item的时候,才会执行后面的回调函数
toucher.on("singleTap", document.querySelector(".list-item"), function(ev) {
    //  ...
});
支持的配置项(config)和事件列表(on)
  • config
属性含义类型
longTapTime触发longTap事件的时间(毫秒),默认700msNumber
doubleTapTime在多少毫秒内连续点击两次屏幕,触发doubleTap,默认400msNumber
  • on
两个参数
name属性含义callback类型
singleTap轻击(单个手指)Fucntion
doubleTap手指放到屏幕(单个手指)Fucntion
longTap长按Fucntion
swipe手指在屏幕上移动Fucntion
swipeStart手指在屏幕上移动(只触发一次)Fucntion
swipeEnd下滑Fucntion
swipeUp左滑Fucntion
swipeRight右滑Fucntion
swipeDown下滑Fucntion
swipeLeft左滑Fucntion
pinch缩放Fucntion
rotate旋转Fucntion
三个参数

name和callback和上表一样

target可以为具体的css selector, 也可以为具体的DOM元素(document.querySelector(selector)之类方法获取到的)

  • off

解除之前绑定过的代理事件(之前怎样绑定的就怎样解除)

例子
var toucher = Toucher("#div");

//  绑定
toucher.on("singleTap", function(ev){});

//  解除绑定
toucher.off("sigleTap");

或者

var toucher = Toucher("#div");

//  绑定
toucher.on("singleTap", ".list-item", function(ev){});

//  解除绑定
toucher.off("sigleTap", ".list-item");
在线体验

扫描下方二维码或者手机直接访问https://rwson.github.io/Toucher/


最骚的就是你
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python：实现手势识别(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-28 839
python：实现手势识别(附完整源码)
JavaScript 监听手机端的touch滑动事件（滑动手势）
For_My_Own_Voice的博客
08-09 6919
如何监听移动端滑动手势（上 / 下 / 左 / 右滑动），今天记录下。 var startx, starty; //获得角度 function getAngle(angx, angy) { return Math.atan2(angy, angx) * 180 / Math.PI; }; //根据起点终点返回方向 1向上滑动 2向下滑动 3向左滑动 4向右滑动 0点击事件 func...
移动端的多指事件以及原生JS封装通用多指事件
weixin_37632943的博客
07-18 654
移动端的多指事件以及用原生JS封装通用多指事件 IOS的多指事件 事件类型： gesturestart: 手指触碰当前元素，屏幕上有两个或者两个以上的手指 gesturechange:手指触碰当前元素，屏幕上有两个或者两个以上的手指位置在发生移动。 gestureend:在gesturestart后, 屏幕上只剩下两根以下（不包括两根）的手指 Event额外新增的属性 属性 rotation :...
js常用插件(二)之移动端手势利器hammer单双指操作
小龚的博客
01-13 3548
js常用插件之hammer单双指操作 欢迎点击: 个人官网博客 移动端手势利器： 先引用cdn或自己下载下来 <script src="https://cdn.bootcdn.net/ajax/libs/hammer.js/2.0.8/hammer.js"></script> 使用方法 //要操作的元素 var hammertime= new Hammer(document.getElementById('test')); //直接调用就可以 //比如写了pan就
vue3基于hammerjs实现移动端图片拖动缩放旋转功能案例
xiexikk的博客
05-27 3371
首先我们先有一个需求，就是在移动端h5实现图片的拖动，缩放，旋转等手势操作。 假如我们使用原生的touch实现起来是非常麻烦，推荐使用一下hammerjs这个包进行处理这些手势操作。 hammerjs是什么 　　hammerjs：hammerjs这个库可以让我们轻松的实现移动端上的手势操作， 也去除移动端上的点击事件的300ms延迟。 　　它封装了一下这些方法： pan 左右拖动 tap 点击 press 长时间按压 swipe 滑动 rotate 旋转效果 pinch 缩放 我写了个案例大概是这样子
基于JavaScript开发的移动端手势库
11-16
基于JavaScript开发的移动端手势库是专门为触摸屏设备设计的，它们允许用户通过各种手势来控制和与应用程序进行交互，如滑动、捏合、旋转、双击等。这样的库极大地提升了移动应用的用户体验，因为它们更直观、更符合...
zingtouch一个JavaScript手势检测库
08-07
总之，ZingTouch 是一个强大且灵活的JavaScript手势库，它使得开发者能够轻松地为Web应用添加丰富的触摸交互，尤其适合于移动设备的开发。通过其内置的手势和自定义手势功能，可以创造出富有创新性和个性化的用户...
Hammerjs实现多点触摸手势的javascript库
08-09
通过创建一个新的Hammer.Manager实例，并添加自定义的识别器，可以扩展其手势库。例如，创建一个名为`customGesture`的新手势： ```javascript var manager = new Hammer.Manager(myElement); var CustomGesture = ...
手势库存
02-17
这里的“GestionStock-master”可能是一个基于JavaScript的库存管理项目源代码库。JavaScript是一种广泛使用的编程语言，特别是在Web开发中，用于实现客户端的动态功能。现在，我们将深入探讨JavaScript在库存管理中...
Gebble:鹅卵石的 JavaScript 手势控制库
06-11
Gebble.js Gebble.js 是一个库，可帮助开发人员使用 Pebble 智能手表和 pebble.js 在 javascript 应用程序中实现手势控制。 ##1。 设置 Gebble.js 首先，您必须将 Gebble.js 库添加到应用程序中的文件中。 Gebble.js...
Hammer.js移动端手势库实例
09-26
里面包括很多事例，可以实现div,img的缩放，旋转，滑动 还有在指定区域内滑动不能覆盖其他区域，还有很多其他实例自己挖掘，http://www.cnblogs.com/vajoy/p/4011723.html一份官方翻译说明，附有操作说明书。
touch.js分析
11-11
touch.js分析
H5手势插件
05-16
支持手机端的旋转，缩放，拖动等操作
纯js 判断手势滑动方向
weixin_34311757的博客
07-12 300
$('body').on('touchstart', '#gallerySlider img', function(e) { var touch = e.originalEvent, startX = touch.changedTouches[0].pageX; startY = touch.changedTouches[0].pageY; slider.on('touchmove', funct...
hammer.js移动端手势库
weixin_33827731的博客
06-20 120
hammer.js 是一个多点触摸手势库，能够为网页加入Tap、Double Tap、Swipe、Hold、Pinch、Drag等多点触摸事件，免去自己监听底层touchstart、touchmove、touchend事件并且写一大堆判断逻辑的痛苦。hammer.js不但支持触摸屏设备的浏览器，在桌面浏览器上，也能将鼠标的点击当做触摸，方便开发人员在桌面浏览器上调试。这是一个专为触摸手势而生的j...
touch.js详解
github_37360787的博客
02-02 9000
Touch 在开发移动端的应用中会使用到很多的手势操作，例如一指拖动、两指旋转等等，为了方便开放者快速集成这些手势，在Clouda中内置了事件和手势库Library.touch，下面将详细的介绍如何使用Library.touch。 手势事件处理类API目前支持以下功能： 事件配置 事件代理 事件绑定 解除事件代理 解除事件绑定 触发事件 事件配置 tou
Vue 精简手势库
weixin_34216196的博客
03-27 632
function vueTouch(el, binding, type) { var _this = this; this.obj = el; this.binding = binding; this.touchType = type; this.vueTouches = { x: 0, y: 0 }; this.vueMoves = true; this.vueLeave...
Toucher触摸屏浏览器V3.1正式发布
jytouch1的专栏
12-16 1384
Toucher触摸屏浏览器是专门针对触摸屏应用而开发的榔鳎贗E内核，提供访问本地及远程网页功能，具备触摸屏应用所需要的各种实用功能，提供了触摸屏软件所需要的自动返回首页，定时关机，背景音乐播放，周末不开机，禁止图像工具栏，禁止屏幕保护以及限制网站访问等在触摸屏应用中非常实用的功能，为您快速搭建触摸屏查询系统提供了最快捷的方式。     Toucher触摸屏浏览器提供导航工具栏的显示和
matlab下载.pdf
最新发布
07-14
matlab下载下载方式及注意事项
不使用npm命令,怎么使用vue2-touch-events这个手势库
05-27
然后，在你的Vue组件中，你需要导入你刚刚放置的手势库文件，并在组件中引用它。例如，如果你将vue2-touch-events放在了你的项目中的“gestures”文件夹中，你可以这样导入它： ```javascript import Vue2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值