Promise

最新推荐文章于 2022-11-29 16:07:52 发布
最新推荐文章于 2022-11-29 16:07:52 发布
阅读量276 收藏
点赞数
分类专栏： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dfydn/article/details/103917108
版权

Promise

Promise.js

const PENDING = 'pending'; //初始态
const FULFILLED = 'fulfilled'; // 成功态
const REJECTED = 'rejected'; // 成功态
function Promise(executor) {
    let self = this; //先缓存当前promise实例
    self.status = PENDING; //设置状态
    // 定义存放成功回调的数组
    self.onResolvedCallbacks = [];
    // 定义存放失败回调的数组
    self.onRejectedCallbacks = [];
    // 当调用此方法的时候，如果 promise 状态为 pending 的话可以转换成 成功态，如果已经是成功态或者失败态 则什么也不做
    // 2.1
    function resolve(value) { // 2.1.1
        if (value instanceof Promise) {
            return value.then(resolve, reject)
        }
        setTimeout(function () {
            // 如果是初始态，则转成成功态
            if (self.status == PENDING) {
                self.status = FULFILLED;
                self.value = value; // 成功后会得到一个值，这个值不能改
                // 调用所有成功的回调
                self.onResolvedCallbacks.forEach(cb => cb(self.value));
            }
        });
    }
    function reject(reason) { // 2.1.2
        setTimeout(function () {
            // 如果是初始态，则转成失败态
            if (self.status == PENDING) {
                self.status = REJECTED
                self.value = reason; // 把失败的原因给了 value
                self.onRejectedCallbacks.forEach(cb => cb(self.vaule));
            }
        })
    }
    try {
        // 因为此函数执行可能出异常，所以需要捕获，如果出错了，需要用错误对象 reject
        executor(resolve, reject);
    } catch (e) {
        // 如果这个函数执行失败了，则用失败的原因 reject 这个 promise
        reject(e);
    }
}
function resolvePromise(promise2, x, resolve, reject) {
    if (promise2 === x) {
        return reject(new TypeError('循环引用'));
    }
    let called = false; // promise2 是否已经 resolve 或 reject 了
    if (x instanceof Promise) {
        if (x.status == PENDING) {
            x.then(function (y) {
                resolvePromise(promise2, y, resolve, reject)
            }, reject)
        } else {
            x.then(resolve, reject)
        }
        // x 是一个 thenable 对象或函数，只要有 then 方法的对象，
    } else if (x != null && ((typeof x == 'object') || (typeof x == 'function'))) {
        // 当我们的 promise 和别的 promise 进行交互，编写这段代码的时候尽量的考虑兼容性，允许别人瞎写
        try {
            let then = x.then
            if (typeof then == 'function') {
                // 有些 promise 会同时执行成功和失败的回调
                then.call(x, function (y) {
                    // 如果 promise2 已经成功或失败了，则不会再处理了
                    if (called) return;
                    called = true;
                    resolvePromise(promise2, y, resolve, reject)
                }, function (err) {
                    if (called) return;
                    called = true;
                    reject(err)
                })
            } else {
                // 到此的话 x 不是一个 thenable 对象，那直接把它当成值 resolve promise2 就可以了
                resolve(x)
            }
        } catch (error) {
            if (called) return;
            called = true;
            reject(error)
        }
    } else {
        // 如果 x 是一个普通的值，则用 x 的值去 resolve promise2
        resolve(x)
    }
}
// onFulfilled 是用来接收 promise 成功的值或者失败的原因
Promise.prototype.then = function (onFulfilled, onRejected) {
    // 如果成功和失败的回调没有传，则表示这个 then 没有任何逻辑，只会把值往后抛
    // 2.2.1
    onFulfilled = typeof onFulfilled == 'function' ? onFulfilled : function (value) { return value };
    onRejected = typeof onRejected == 'function' ? onRejected : reason => { throw reason };
    // 如果当前的 promise 状态已经是成功态了，onFulfilled 直接取值
    let self = this;
    let promise2;
    if (self.status == FULFILLED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onFulfilled(self.value);
                    // 如果获取到了返回值 x，会走解析 promise 的过程
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    // 如果执行成功的回调过程中出错了，用错误原因把 promise2 reject
                    reject(error);
                }
            })
        })
    }
    if (self.status == REJECTED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onRejected(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);
                }
            })
        })
    }
    if (self.status == PENDING) {
        return promise2 = new Promise(function (resolve, reject) {
            self.onResolvedCallbacks.push(function () {
                // setTimeout(function () {
                    try {
                        let x = onFulfilled(self.value);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);

                    }
                // })
            })
            self.onRejectedCallbacks.push(function () {
                // setTimeout(function () {
                    try {
                        let x = onRejected(self.value);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                // })
            })
        })
    }

}

// catch 原理就是只传失败的回调
Promise.prototype.catch = function (onReject) {
    this.then(null, onRejected)
}
Promise.deferred = Promise.defer = function () {
    let defer = {};
    defer.promise = new Promise(function (resolve, reject) {
        defer.resolve = resolve;
        defer.reject = reject;
    });
    return defer;
}
module.exports = Promise;

测试 Promise

cnpm i -g promises-aplus-tests
promises-aplus-tests Promise.js

Promise.all

Promise.all = function (promises) {
    return new Promise(function (resolve, reject) {
        let result = []
        let count = 0
        function done(i,data) {
            result[i] = data
            if(++count == promises.length) {
                resolve(result)
            }
        }
        for (let i = 0, j = promises.length; i < j; i++) {
            // promises[i].then(done.bind(null,i))
            promises[i].then(function(data){
                done(i,data)
            })
        }
    })
}

测试 Promise.all

index.js

let Promise = require('./Promise')
let p1 = new Promise(function (resolve, reject) {
    setTimeout(function () { 
        reject('err')
    }, 1000)
})
let p2 = new Promise(function (resolve, reject) {
    setTimeout(function () { 
        resolve(200)
    }, 2000)
})

Promise.all([p1,p2]).then(function(data) {
    console.log(data)
},function(err){
    console.log(err)
})

Promise.js

const PENDING = 'pending'; //初始态
const FULFILLED = 'fulfilled'; // 成功态
const REJECTED = 'rejected'; // 成功态
function Promise(executor) {
    let self = this; //先缓存当前promise实例
    self.status = PENDING; //设置状态
    // 定义存放成功回调的数组
    self.onResolvedCallbacks = [];
    // 定义存放失败回调的数组
    self.onRejectedCallbacks = [];
    // 当调用此方法的时候，如果 promise 状态为 pending 的话可以转换成 成功态，如果已经是成功态或者失败态 则什么也不做
    // 2.1
    function resolve(value) { // 2.1.1
        if (value instanceof Promise) {
            return value.then(resolve, reject)
        }
        setTimeout(function () {
            // 如果是初始态，则转成成功态
            if (self.status == PENDING) {
                self.status = FULFILLED;
                self.value = value; // 成功后会得到一个值，这个值不能改
                // 调用所有成功的回调
                self.onResolvedCallbacks.forEach(cb => cb(self.value));
            }
        });
    }
    function reject(reason) { // 2.1.2
        setTimeout(function () {
            // 如果是初始态，则转成失败态
            if (self.status == PENDING) {
                self.status = REJECTED
                self.value = reason; // 把失败的原因给了 value
                self.onRejectedCallbacks.forEach(cb => cb(self.vaule));
            }
        })
    }
    try {
        // 因为此函数执行可能出异常，所以需要捕获，如果出错了，需要用错误对象 reject
        executor(resolve, reject);
    } catch (e) {
        // 如果这个函数执行失败了，则用失败的原因 reject 这个 promise
        reject(e);
    }
}
function resolvePromise(promise2, x, resolve, reject) {
    if (promise2 === x) {
        return reject(new TypeError('循环引用'));
    }
    let called = false; // promise2 是否已经 resolve 或 reject 了
    if (x instanceof Promise) {
        if (x.status == PENDING) {
            x.then(function (y) {
                resolvePromise(promise2, y, resolve, reject)
            }, reject)
        } else {
            x.then(resolve, reject)
        }
        // x 是一个 thenable 对象或函数，只要有 then 方法的对象，
    } else if (x != null && ((typeof x == 'object') || (typeof x == 'function'))) {
        // 当我们的 promise 和别的 promise 进行交互，编写这段代码的时候尽量的考虑兼容性，允许别人瞎写
        try {
            let then = x.then
            if (typeof then == 'function') {
                // 有些 promise 会同时执行成功和失败的回调
                then.call(x, function (y) {
                    // 如果 promise2 已经成功或失败了，则不会再处理了
                    if (called) return;
                    called = true;
                    resolvePromise(promise2, y, resolve, reject)
                }, function (err) {
                    if (called) return;
                    called = true;
                    reject(err)
                })
            } else {
                // 到此的话 x 不是一个 thenable 对象，那直接把它当成值 resolve promise2 就可以了
                resolve(x)
            }
        } catch (error) {
            if (called) return;
            called = true;
            reject(error)
        }
    } else {
        // 如果 x 是一个普通的值，则用 x 的值去 resolve promise2
        resolve(x)
    }
}
// onFulfilled 是用来接收 promise 成功的值或者失败的原因
Promise.prototype.then = function (onFulfilled, onRejected) {
    // 如果成功和失败的回调没有传，则表示这个 then 没有任何逻辑，只会把值往后抛
    // 2.2.1
    onFulfilled = typeof onFulfilled == 'function' ? onFulfilled : function (value) { return value };
    onRejected = typeof onRejected == 'function' ? onRejected : reason => { throw reason };
    // 如果当前的 promise 状态已经是成功态了，onFulfilled 直接取值
    let self = this;
    let promise2;
    if (self.status == FULFILLED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onFulfilled(self.value);
                    // 如果获取到了返回值 x，会走解析 promise 的过程
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    // 如果执行成功的回调过程中出错了，用错误原因把 promise2 reject
                    reject(error);
                }
            })
        })
    }
    if (self.status == REJECTED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onRejected(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);
                }
            })
        })
    }
    if (self.status == PENDING) {
        return promise2 = new Promise(function (resolve, reject) {
            self.onResolvedCallbacks.push(function () {
                // setTimeout(function () {
                try {
                    let x = onFulfilled(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);

                }
                // })
            })
            self.onRejectedCallbacks.push(function () {
                // setTimeout(function () {
                try {
                    let x = onRejected(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);
                }
                // })
            })
        })
    }

}

// catch 原理就是只传失败的回调
Promise.prototype.catch = function (onReject) {
    this.then(null, onRejected)
}
Promise.deferred = Promise.defer = function () {
    let defer = {};
    defer.promise = new Promise(function (resolve, reject) {
        defer.resolve = resolve;
        defer.reject = reject;
    });
    return defer;
}
Promise.all = function (promises) {
    return new Promise(function (resolve, reject) {
        let result = []
        let count = 0
        function done(i,data) {
            result[i] = data
            if(++count == promises.length) {
                resolve(result)
            }
        }
        for (let i = 0, j = promises.length; i < j; i++) {
            // promises[i].then(done.bind(null,i))
            promises[i].then(function(data){
                done(i,data)
            })
        }
    })
}
module.exports = Promise;

Promise.all 2

function gen(times,cb) {
    let result = []
    let count = 0
    return function(i, data) {
        result[i] = data
        if (++count == times) {
            cb(result)
        }
    }
}
Promise.all = function (promises) {
    return new Promise(function (resolve, reject) {
        // let result = []
        // let count = 0
        // function done(i, data) {
        //     result[i] = data
        //     if (++count == promises.length) {
        //         resolve(result)
        //     }
        // }
        let done = gen(promises.length,resolve)
        for (let i = 0, j = promises.length; i < j; i++) {
            // promises[i].then(done.bind(null,i))
            promises[i].then(function (data) {
                done(i, data)
            },reject)
        }
    })
}

Promise.race

Promise.race = function (promises) {
    return new Promise(function (resolve, reject) {
        for (let i = 0, j = promises.length; i < j; i++) {
            promises[i].then(resolve, reject)
        }
    })
}

测试 Promise.race

Promise.race([p1,p2]).then(function(data) {
    console.log(data)
},function(err) {
    console.log(err)
})

Promise.js 最终

const PENDING = 'pending'; //初始态
const FULFILLED = 'fulfilled'; // 成功态
const REJECTED = 'rejected'; // 成功态
function Promise(executor) {
    let self = this; //先缓存当前promise实例
    self.status = PENDING; //设置状态
    // 定义存放成功回调的数组
    self.onResolvedCallbacks = [];
    // 定义存放失败回调的数组
    self.onRejectedCallbacks = [];
    // 当调用此方法的时候，如果 promise 状态为 pending 的话可以转换成 成功态，如果已经是成功态或者失败态 则什么也不做
    // 2.1
    function resolve(value) { // 2.1.1
        if (value instanceof Promise) {
            return value.then(resolve, reject)
        }
        setTimeout(function () {
            // 如果是初始态，则转成成功态
            if (self.status == PENDING) {
                self.status = FULFILLED;
                self.value = value; // 成功后会得到一个值，这个值不能改
                // 调用所有成功的回调
                self.onResolvedCallbacks.forEach(cb => cb(self.value));
            }
        });
    }
    function reject(reason) { // 2.1.2
        setTimeout(function () {
            // 如果是初始态，则转成失败态
            if (self.status == PENDING) {
                self.status = REJECTED
                self.value = reason; // 把失败的原因给了 value
                self.onRejectedCallbacks.forEach(cb => cb(self.vaule));
            }
        })
    }
    try {
        // 因为此函数执行可能出异常，所以需要捕获，如果出错了，需要用错误对象 reject
        executor(resolve, reject);
    } catch (e) {
        // 如果这个函数执行失败了，则用失败的原因 reject 这个 promise
        reject(e);
    }
}
function resolvePromise(promise2, x, resolve, reject) {
    if (promise2 === x) {
        return reject(new TypeError('循环引用'));
    }
    let called = false; // promise2 是否已经 resolve 或 reject 了
    if (x instanceof Promise) {
        if (x.status == PENDING) {
            x.then(function (y) {
                resolvePromise(promise2, y, resolve, reject)
            }, reject)
        } else {
            x.then(resolve, reject)
        }
        // x 是一个 thenable 对象或函数，只要有 then 方法的对象，
    } else if (x != null && ((typeof x == 'object') || (typeof x == 'function'))) {
        // 当我们的 promise 和别的 promise 进行交互，编写这段代码的时候尽量的考虑兼容性，允许别人瞎写
        try {
            let then = x.then
            if (typeof then == 'function') {
                // 有些 promise 会同时执行成功和失败的回调
                then.call(x, function (y) {
                    // 如果 promise2 已经成功或失败了，则不会再处理了
                    if (called) return;
                    called = true;
                    resolvePromise(promise2, y, resolve, reject)
                }, function (err) {
                    if (called) return;
                    called = true;
                    reject(err)
                })
            } else {
                // 到此的话 x 不是一个 thenable 对象，那直接把它当成值 resolve promise2 就可以了
                resolve(x)
            }
        } catch (error) {
            if (called) return;
            called = true;
            reject(error)
        }
    } else {
        // 如果 x 是一个普通的值，则用 x 的值去 resolve promise2
        resolve(x)
    }
}
// onFulfilled 是用来接收 promise 成功的值或者失败的原因
Promise.prototype.then = function (onFulfilled, onRejected) {
    // 如果成功和失败的回调没有传，则表示这个 then 没有任何逻辑，只会把值往后抛
    // 2.2.1
    onFulfilled = typeof onFulfilled == 'function' ? onFulfilled : function (value) { return value };
    onRejected = typeof onRejected == 'function' ? onRejected : reason => { throw reason };
    // 如果当前的 promise 状态已经是成功态了，onFulfilled 直接取值
    let self = this;
    let promise2;
    if (self.status == FULFILLED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onFulfilled(self.value);
                    // 如果获取到了返回值 x，会走解析 promise 的过程
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    // 如果执行成功的回调过程中出错了，用错误原因把 promise2 reject
                    reject(error);
                }
            })
        })
    }
    if (self.status == REJECTED) {
        return promise2 = new Promise(function (resolve, reject) {
            setTimeout(function () {
                try {
                    let x = onRejected(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);
                }
            })
        })
    }
    if (self.status == PENDING) {
        return promise2 = new Promise(function (resolve, reject) {
            self.onResolvedCallbacks.push(function () {
                // setTimeout(function () {
                try {
                    let x = onFulfilled(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);

                }
                // })
            })
            self.onRejectedCallbacks.push(function () {
                // setTimeout(function () {
                try {
                    let x = onRejected(self.value);
                    resolvePromise(promise2, x, resolve, reject);
                } catch (error) {
                    reject(error);
                }
                // })
            })
        })
    }

}

// catch 原理就是只传失败的回调
Promise.prototype.catch = function (onReject) {
    this.then(null, onRejected)
}
Promise.deferred = Promise.defer = function () {
    let defer = {};
    defer.promise = new Promise(function (resolve, reject) {
        defer.resolve = resolve;
        defer.reject = reject;
    });
    return defer;
}
function gen(times, cb) {
    let result = []
    let count = 0
    return function (i, data) {
        result[i] = data
        if (++count == times) {
            cb(result)
        }
    }
}
Promise.all = function (promises) {
    return new Promise(function (resolve, reject) {
        // let result = []
        // let count = 0
        // function done(i, data) {
        //     result[i] = data
        //     if (++count == promises.length) {
        //         resolve(result)
        //     }
        // }
        let done = gen(promises.length, resolve)
        for (let i = 0, j = promises.length; i < j; i++) {
            promises[i].then(function (data) {
                done(i, data)
            }, reject)
        }
    })
}
Promise.race = function (promises) {
    return new Promise(function (resolve, reject) {
        for (let i = 0, j = promises.length; i < j; i++) {
            promises[i].then(resolve, reject)
        }
    })
}
// 返回一个立刻成功的 Promise
// 别人提供 给你一个方法，需要你传入一个 Promise，但你只有一个普通的值，你就可以通过这个方法把这个普通的值（string number object)转成一个 Promise 对象
Promise.resolve = function(value) {
    return new Promise(function(resolve,reject) {
        resolve(value)
    })
}
// 立刻返回一个失败的 Promise 对象
Promise.reject = function(reason) {
    return new Promise(function(resolve,reject) {
        reject(reason)
    })
}
module.exports = Promise;

你的微笑像拥抱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于promise
weixin_70152241的博客
09-15 178
浅谈Promise
Promise理解
qq_59076775的博客
04-26 916
Promise是一个构造函数,里面有三种状态peading，fulfilled,reject也就是等待,成功,失败这三个状态。 1.等待状态 const p1 = new Promise((resolve, reject) => { // 成功的时候 可以调用 resolve()方法 // 失败的时候 可以调用 reject()方法 }) console.log(p1) 可以看出在里面什么都没有干,此时就是一个等待的Promise状态。 2.成功的状态 co
Promise 的状态， promise 指定多个成功/失败回调函数，都会调用吗？
Allen的博客
11-29 1217
实例对象promise中的一个属性 PromiseStatepending 变为 resolved/fullfilledpending 变为 rejected注意对象的状态不受外界影响只有这两种，且一个 promise 对象只能改变一次一旦状态改变，就不会再变，任何时候都可以得到这个结果无论成功还是失败，都会有一个结果数据。成功的结果数据一般称为 value，而失败的一般称为 reason。
js 使用async、await 和promise 获取 异步请求的结果(微信小程序)
m0_47136986的博客
01-11 1074
重要的两句话 1、 await后面接一个会return new promise的函数并执行它。 2、 await只能放在async函数里。 使用方式 getNews: async function (len,category) { var that=this return await new Promise((resolve, reject) => { //wx.request()是异步方法 wx.request({ url: app.glob
promise:Python 中的超高性能 Promise 实现
05-30
承诺这是 Python 中 Promise 的一个实现。 它是 Promises/A+ 的超级集，旨在拥有可读、高性能的代码，并仅提供在 Python 中使用 Promise 绝对必要的扩展。 它与完全兼容安装 $ pip install promise用法下面的示例...
promise.pdf
05-30
promise学习笔记
promise.md
06-03
promise.md记载了promise的规范 它是一套异步操作处理机制， [Promise A+](https://promisesaplus.com/) 是规范，jQuery、ES2015、q的promise都是对该规范的一种实现.
Promise用法
01-08
promise是个构造函数对象，解决了回调问题，它有三种状态，pending(等待态)，fulfiled(成功态)，rejected(失败态)，常用到的方法则有 then，catch，all，race promise是用来解决两个问题的： 回调地狱，代码难以维护...
Promise.js
06-19
手动实现promise的功能， 只能保证功能相同。用于来更加深刻的理解promise，由于es6是官方提出的一个新的概念，每家浏览器厂商实现的底层原理都不一样，所以这个实现的只是模拟用来练习的。更加理解promise，和养成...
promise详解
03-09
关键词：Promise，resolve，reject，Prepending，Resolve，Reject，then，catch，all，race
promise的学习总结
09-08
Promise的学习总结
filereader与promise封装使用.html
10-03
Filereader与Promise的搭配使用/JavaScript异步回调函数返回值 完美解决！！！！！！！ 工作中项目需求：读取用户上传的Excel文件，并将Excel转换为json数据格式，然后上传至后台数据库。 问题点：Filereader中new ...
JS中promise化微信小程序api
10-18
主要给大家通过代码实例分析了promise化微信小程序api的使用方法，对此有需要的朋友可以参考学习下。
微信小程序——Promise异步简化回调，简易回调，代理接口回调，await的用法，匿名函数
wy313622821的博客
07-20 1520
Promise异步简化回调 使用的背景：同时存在两个或者多个网络请求，且第二个请求要使用第一个请求返回的数据 代码： const app = getApp() Page({ data: { }, onLoad: function () { this.function_1().then(res=>{ console.log('方法1结果：',res) //这里可以把结果放到GetUserEntity_2作为参数 this.function_2
Promise以及async/await解决回调
XUYIGE的博客
03-31 717
文章目录一、函数对象与实例对象二、两种类型的回调函数同步回调异步回调三、JS的error处理1、 错误的类型：2、错误处理四、Promise 一、函数对象与实例对象 函数对象：将函数作为对象使用时，简称为函数对象 实例对象：new函数产生的对象，简称为对象 function Fn(){ //Fn函数 } const fn=new Fn() //Fn是构造函数 fn是实例对象（对象） consol...
看了就懂的Promise和回调函数
热门推荐
小天才程序员的博客乐园
04-08 1万+
最通俗易懂的回调函数 (callback)与Promise
微信小程序封装request请求，primise队列化，async await做同步处理，缓存token信息
mrcaoyongkang的博客
07-24 939
微信小程序封装request请求，promise队列话，async await同步处理，请求头携带token做缓存处理
promise 嵌套
最新发布
04-17
Promise嵌套是指在使用Promise时，一个Promise的回调函数中又返回了一个新的Promise，形成了嵌套的结构。这种嵌套的结构可以用来处理多个异步操作的依赖关系，使得代码更加清晰和可读。 在Promise嵌套中，可以通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值