es6 promise 异步方法处理

最新推荐文章于 2025-07-02 11:29:47 发布
最新推荐文章于 2025-07-02 11:29:47 发布
阅读量553 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 客户端 服务端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_26026975/article/details/79241479
本文介绍JavaScript中处理异步操作的方法，包括使用回调、Promise、async/await等技术，并提供了基于ES6的异步请求示例。此外，还详细介绍了如何使用Promise进行并发请求，以及通过Promise包装实现MongoDB数据库操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.在js中，凡是涉及到非内存的操作都为异步操作。如读写磁盘文件,访问url请求,读写数据库数据等都为异步操作。

2.在es6之前我们最常见对于异步的处理就是书写大量的callback函数,所以当你的下一步数据需要依赖于上一步异步操作的数据时,会出现很多嵌套,代码凌乱的感觉。这种后果就是你不会知道你的callback是在哪,并且如果报错也很难处理.这是我以前写的代码.

exports.get_charge_info = function (userid, orderno, callback) {
	callback = callback == null ? nop : callback;
	if (userid == null || orderno == null) {
		callback(null);
	}
	var sql = "SELECT * FROM game_db.t_users_rechange_record WHERE userid = {0}  AND  orderno = '{1}';";
	sql = sql.format(userid, orderno);
	console.log("查询语句是:" + sql);
	query(sql, function (err, rows, fields) {
		if (err) {
			callback(null);
			throw err;
		} else {
			if (rows.length == 0) {
				callback(null);
				return;
			}
			callback(rows[0]);
		}
	});
};

3.在es6里面,为我们提供了一个Promise类.你可以理解为一个对象,包含进行态和完成态两部分。其中完成态分为失败态和成功态。我们可以把处理完的数据，若成功则放在成功态，失败则放在失败态。具体包装如下:

     * @version 1.0 get promise请求包装
     * 
     */
    static async get({ url, data }) {

        //resolve 完成态, reject 失败态
        return await new Promise(
            (resolve, reject) => {

                //get为异步操作 .then 后面的为执行完请求后 返回的数据的回调函数
                axios.get(url, { params: data }).then((response) => {

                    resolve(response);

                }).catch((err) => {

                    reject(err);

                });

            }
        );

    }


4. async 和 await 是搭配在一起使用的. 如果不写await则不会等待异步操作。

5.多条请求并发 可用promise.all解决,回来的结果会是一个数组,若其中一个请求失败,则不会返回任何数据，如下:

Promise.all([axios.get({ url: 'http://es6.ruanyifeng.com/#docs/set-map' }), axios.get({ url: 'http://es6.ruanyifeng.com/#docs/reflect' })])

    .then(() => {

        console.log('结束时间:' + new Date().getTime());

    }).catch((err) => {

        console.log(err);
    });

6.mongodb 包装处理代码 第一段是对数据库操作的处理,第二段是怎样连接数据库,实现了连接池。

/**
 * @version 1.0 mongoDB 管理
 * 
 */
const path = require('path');

const mongoClient = require('./mongoClient.js').MongoClientMannage;

const ObjectId = require('mongodb').ObjectId;

const log = require(path.join(__dirname, '../', '../', 'lib', 'log.js')).log;

class MongoDBUtil {


    /**
     * @version 1.0 插入文档(包含)
     * @param collection 文档名
     * @param data 插入数据
     * @return ids  返回插入对应的id名
     */
    static async insertDoc({ collection, data }) {

        let db = mongoClient.getCoon();

        if (db) {
            return await new Promise(

                (resolve, reject) => {

                    let dbCollection = db.collection(collection);

                    dbCollection.insert(data, (err, result) => {

                        if (err) {
                            log.error('MongoDBUtil:insertDoc ' + err);
                            reject(err);
                        }
                        //result.ops[0]._id
                        resolve(result);
                    });
                }

            );
        }
        return false;
    }


    /**
     * @version 1.0 查找文档
     * @param collection 文档名
     * @param searchStr 搜索条件
     * @param fields 指定字段返回
     * @return result 搜索结果/false为未查找到
     */
    static async findDoc({ collection, searchStr, fields = {} }) {

        let db = mongoClient.getCoon();

        if (db) {

            return await new Promise(

                (resolve, reject) => {

                    let dbCollection = db.collection(collection);

                    if (searchStr) {
                        if (searchStr._id) {

                            if (searchStr._id instanceof Object) {

                                if (searchStr._id.$in) {

                                    for (let i = 0; i < searchStr._id.$in.length; i++) {

                                        searchStr._id.$in[i] = ObjectId(searchStr._id.$in[i]);

                                    }

                                }
                            } else {
                                searchStr._id = ObjectId(searchStr._id);
                            }

                        }
                    }


                    dbCollection.find(searchStr, fields).toArray(

                        (err, result) => {

                            if (err) {
                                log.error('MongoDBUtil:findDoc' + err);
                                reject(err);
                            }

                            resolve(result);

                        }

                    );

                }
            );
        }

        return false;

    }

    /**
     * @version 1.0 聚合查询
     */
    static async queryDoc({ collection, searchStr }) {

        let db = mongoClient.getCoon();

        if (db) {

            return await new Promise(

                (resolve, reject) => {

                    let dbCollection = db.collection(collection);

                    if (searchStr && searchStr.length > 0 && searchStr[0].$match && searchStr[0].$match._id) {

                        searchStr[0].$match._id = ObjectId(searchStr[0].$match._id);
                    }

                    dbCollection.aggregate(searchStr).toArray(

                        (err, result) => {

                            if (err) {
                                log.error('MongoDBUtil:queryDoc' + err);
                                reject(err);
                            }

                            resolve(result);

                        }

                    );

                }
            );
        }

        return false;
    }


    /***
     * @version 1.0 根据条件来进行统计
     * 
     */
    static async countDocs({ collection, searchStr = {} }) {

        let db = mongoClient.getCoon();

        if (db) {

            return await new Promise(

                (resolve, reject) => {

                    let dbCollection = db.collection(collection);

                    if (searchStr._id) {

                        searchStr._id = ObjectId(searchStr._id);

                    }

                    dbCollection.count(searchStr,

                        (err, result) => {

                            if (err) {
                                log.error('MongoDBUtil:countDocs' + err);
                                reject(err);
                            }

                            resolve(result);

                        }

                    );

                }
            );
        }

        return false;

    }

    /**
     * @version 1.0 更新文档
     * @param collection 文档名
     * @param searchStr 搜索条件
     * @param updateStr 更新条件
     * @return flag true为更新成功  false 为未更新成功
     */
    static async updateDoc({ collection, searchStr, updateStr }) {


        let db = mongoClient.getCoon();

        if (db) {

            return await new Promise((resolve, reject) => {

                let dbCollection = db.collection(collection);

                if (searchStr._id) {

                    searchStr._id = ObjectId(searchStr._id);
                }


                dbCollection.update(searchStr, updateStr, (err, result) => {

                    if (err) {
                        log.error('MongoDBUtil:updateDoc' + err);
                        reject(err);
                    }
                    if (result.result.n > 0) {
                        resolve({ flag: true });
                    } else {
                        resolve({ flag: false });
                    }


                }

                );

            });

        }

        return false;

    }



    /**
     * @version 1.0 删除文档 
     * @param collection 文档名
     * @param searchStr 需删除的条件名
     * @return flag true为成功 false为失败
     * 
     */
    static async deleteDoc({ collection, searchStr }) {

        let db = mongoClient.getCoon();

        if (db) {

            return await new Promise((resolve, reject) => {

                let dbCollection = db.collection(collection);

                dbCollection.remove(searchStr, (err, result) => {

                    if (err) {
                        log.error('MongoDBUtil:deleteDoc' + err);
                        reject(err);
                    }
                    if (result.result.n > 0) {
                        resolve({ flag: true });
                    } else {
                        resolve({ flag: false });
                    }


                }

                );

            });

        }

        return false;

    }

}

// mongoClient.createConn().then(

//     () => {


//         let m = new MongoDBUtil();

//         //插入操作示例
//         // let user = [{ 'userName': 'zjx6', 'age': 11 }, { 'userName': 'zjx7', 'age': 12 }];
//         // m.insertDoc({ collection: 'xmj_users', data: user });

//         //查找操作示例
//         //  let searchStr = {'_id':'59eef0741bd3f0d6255c9362'};
//         //  m.findDoc({collection:'xmj_user', searchStr});

//         //更新操作示例  ！！请注意 $set 若不写则为直接覆盖
//         // let searchStr = { 'userName': 'zj6' };
//         // m.updateDoc({ collection: 'xmj_user', searchStr, updateStr: { $set: { 'age': 22 } } });

//         //删除操作示例
//         // let searchStr = { 'userName': 'zjx6' };
//         // m.deleteDoc({ collection: 'xmj_user', searchStr });


//     }

// );

module.exports = { MongoDBUtil, };


/**
 * @version 1.0 创建客户端
 * 
 */
const path = require('path');

const MongoClient = require('mongodb').MongoClient;

const logger = require(path.join(__dirname,'../','../','lib','log.js')).log;

let MongoDBConn = [];


/**
 * @version 1.0 mongoclient 客户端管理
 * 
 */
class MongoClientMannage {


    static async createConn(mongoCluster) {

        for (let i = 0; i < mongoCluster.length; i++) {

            let res = await new Promise(
                (resolve, reject) => {
                    MongoClient.connect(mongoCluster[0].url,
                        {
                            server: {
                                poolSize: 5,
                                socketOptions: { connectTimeoutMS: 10000 },
                                auto_reconnect: true
                            },
                            replSet: {},
                            mongos: {}
                        }, (err, db) => {
                            if (err) {
                                logger.error('连接mongo失败:'+mongoCluster[0].url);
                                reject(err);
                            } else {
                                logger.info('连接mongo成功:'+mongoCluster[0].url);
                                resolve(db);
                            }
                        });
                }

            );
            MongoDBConn.push(res);
        }
    }


    /**
     * @version 1.0 返回一个可用的mongo数据库连接
     * 
     */
    static getCoon() {

        if (MongoDBConn.length == 0) {

            return false;

        } else {

            //返回任一一个连接
            return MongoDBConn[Math.floor(Math.random() * MongoDBConn.length)];
        }
    }

}


module.exports = {MongoClientMannage,};

ES6 使用Promise异步加载图片例子
爱酸的博文
09-08 541
<!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>异步加
ES6异步解决方案(promise)
m0_60667010的博客
04-11 934
js经常会遇到一些异步任务,所谓的异步任务,就是需要经过一段时间或当某个实际到达后才能得到结果的任务如:1.使用ajax请求服务器,当服务器完成响应后拿到响应结果;2.监听按钮是否被点击,当按钮被点击后拿到某个文本框的值;3.使用setTimeout等待一段时间,当时间到达后做某件事情;由于没有一种标准规范代码,会导致不同的人写的异步代码使用方式不一致,ES6总结了各种异步场景,并提出一种通用的异步模型;总结来说，面试成功=基础知识+项目经验+表达技巧+运气。
前端开源库-es6-promise-pool
08-29
前端开源库-es6-promise-poolES6 Promise池，在限制并发性的池中运行Promise。
ES6的异步处理
weixin_34345753的博客
03-10 878
在学习ES6语法的过程中，一大难点异步处理promise的学习。所以今天就来详解的总结一下ES6中的异步处理。 同步异步 对于同步异步的概念先用白话简单的介绍一下。 同步：操作的执行有先后顺序，需要按顺序一个一个的执行。 异步：多个操作可以同时执行，且互不干扰。一般多用于数据交互。 相对比同步处理，异步处理性能好，效率高，用户体验也较好，但是之前异步操作都是通过回调函数来实现的，写起来比较复杂，可...
ES6从入门到精通：Promise与异步
最新发布
m0_71963731的博客
07-02 362
Promise是处理JavaScript异步操作的核心对象，具有Pending、Fulfilled、Rejected三种状态。通过链式调用.then()/.catch()或使用async/await语法可简化异步处理。ES6提供了Promise.all()、Promise.race()等静态方法，而async函数会自动将返回值包装为Promise。典型应用包括封装AJAX请求和定时操作。使用时需注意避免嵌套过深、正确处理错误，并确保async函数中正确使用await。这些特性共同构成了现代JavaScrip
ES6解决异步问题
qq_59494319的博客
07-21 509
ES6新增的promise以及练习题
ES6中的异步
weixin_34019929的博客
12-27 1701
  在ES6中，主要涉及到的异步有Promise对象，Generator函数和async函数。我主要会从各个的定义、特点以及涉及到的一些方法、原理等进行梳理。 Promise对象 定义：Promise是一个对象，里面保存着未来可能发生的事件。值得注意的是，定义Promise对象里的函数会立即执行。 let promise = new Promise(function(resolve, rejec...
ES6异步
shuzipai的博客
12-28 647
我没法用比较标准的说法给你解释，我尽可能按我理解的说开始我一直很不理解什么叫“用同步的思想解决异步的问题”这句话，很抽象，一直不理解我有一个项目的代码在服务端运行需要同步调用接口，在客户端运行需要异步调用接口（其实都同步也可以，但是客户端为了提升体验）JS函数式编程嘛~我写了一个函数（如下，我手写，肯定不能运行）async get(async) { if (!async) { retu
ES6中异步对象Promise用法详解
12-10
本文实例讲述了ES6中异步对象Promise用法。分享给大家供大家参考，具体如下： 回忆一下ES5中的怎么使用异步方法 // es5中的异步回调 let ajax = function(callback){ console.log('执行') // 执行 setTimeout(()...
ES6的异步操作之promise用法和async函数的具体使用
10-15
总的来说，Promise和async/await是ES6异步操作的核心，它们提供了更优雅的处理异步操作的方式，让代码更加简洁、易于理解和维护。掌握这些特性对于现代JavaScript开发至关重要。通过实例化Promise、使用`then`和`...
ES6新标准下JS异步编程Promise解读
m0_74157361的博客
09-20 1589
ES5及以下，要实现复杂的异步编程，需要大量运用回调函数，而每个回调函数中的执行正确与否无法及时判断，让你只能猜测或分析找问题，这将造成大量无法理解的情况出现。 ES6新标准引入Promise对上述问题进行解决，它的核心思想，是将上一次函数执行返回一个Promise对象，明确指示代码是否成功执行，则你可以基于此成功与否判断，以链式编程方式将复杂嵌套回调函数转换为简单流程化式的形式完成目标任务。
Promise作为ES6最重要的特性之一
08-12
Promise 作为 ES6 最重要的特性之一。用于一个异步操作的最终完成（或失败）及其结果值的表示：即处理异步请求。我们经常会做些承诺，如果我赢了你就嫁给我，如果输了我就嫁给你之类的诺言。这就是promise的中文含义：诺言，一个成功，一个失败！
ES6 Promise对象的应用实例分析
10-16
主要介绍了ES6 Promise对象的应用,结合实例形式分析了Promise对象原理与异步处理相关操作技巧,需要的朋友可以参考下
ES6 Promise对象概念与用法分析
12-10
本文实例讲述了ES6 Promise对象概念与用法。分享给大家供大家参考，具体如下： 1.Promise概念 Promise 对象有三种状态： ① Fulfilled 可以理解为成功的状态 ② Rejected 可以理解为失败的状态 ③ Pending 既不是 Fulfilld 也不是 Rejected 的状态，可以理解为 Promise 对象实例创建时候的初始状态 2.三个重要方法 在 Promise 对象当中有三个重要方法————resolve, reject和then。 resolve 方法可以使 Promise 对象的状态改变成成功，同时传递一个参数用于后续成功后的操作，在这个例子当中
ES6 系列之异步处理实战
全栈修炼
07-09 481
作者：冴羽 ，原文：https://github.com/mqyqingfeng/Blog/issues/101前言我们以查找指定目录下的最大文件为例，感受从回调函数 -...
es6中的异步处理模型详解
qq_41938120的博客
04-09 378
模型 1.es6将某一件可能发生异步操作的事情分为两个阶段：unsettled和settled。 unsettled：未决阶段，表示事情还在进行前期处理，还没有发生通向结果的事情 settled：已决阶段，表示事情已经有了结果，事情无法逆转 事情总是从未决到已决的，未决有控制何时到达已决的能力。 2.es6将事情划分为三种状态：pending、resolved、rejected pending...
ES6学习——关于ES6中的异步操作处理
我们的目标是星辰大海
10-09 1659
1.Promise Promise 是异步编程的⼀种解决⽅案，⽐传统的解决⽅案——回调函数和事件——更合理和更强⼤。 ⼀个 Promise 必然处于以下⼏种状态之⼀： 待定（pending）: 初始状态，既没有被兑现，也没有被拒绝。 已兑现（fulfilled）: 意味着操作成功完成。 已拒绝（rejected）: 意味着操作失败 图源MDNPromise - JavaScript | MDN 1. 构造函数 创建⼀个新的 Promise 对象。该构造函数主要⽤于包装还没有...
Es6之promise
zhqi9277的博客
04-24 230
首先，js是一门单线程语言，所谓"单线程"，就是指一次只能完成一件任务。如果有多个任务，就必须排队，前面一个任务完成，再执行后面一个任务，以此类推。如果一个任务耗时过长，那么后面的任务就必须一直等待下去，会拖延整个程序，常见浏览器无反应，可能就是一段代码死循环，造成程序卡住在这个位置，无法继续。因此，js为了解决这个问题就出现了同步和异步概念。简单来说，"同步模式"就是上一段的模式，后一个任务等待前一个任务结束，然后再执行，程序的执行顺序与任务的排列顺序是一致的、同步的；
ES6 Promise实现异步加载图片技术示例
【描述】:"ES6 Promise异步加载图片例子" 【标签】:"ES6 Promise 异步" 【压缩包子文件的文件名称列表】: 异步加载图片示例 知识点详细说明: 1. ES6 Promise介绍: ES6（ECMAScript 2015）是JavaScript的一次重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值