ES6语法实现Promise过程

JavaScript -- ES6的Promise 本文系统讲解了Promise在前端异步编程中的应用。首先分析回调函数的缺点(嵌套地狱),重点介绍Promise的实现原理:通过返回Promise对象和.then()链式调用实现异步顺序执行,并说明传参和错误处理机制。同时介绍了ES7的async/await语法糖,可消除.then()嵌套。还详细解析了Promise.all()和Promise.any()等原型方法的使用场景,通过商品查询案例演示其实际应用。最后预告将分享手写Promise的实现过程,帮助开发者深入理解异步编程原理。 阅读详情

Promise是ES6中的一种异步实现方式,现在我们来自己实现Promise。(有关Promise使用:ES6学习笔记 Promise)
下面会详细写出实现过程及遇到的问题,如果要看代码实现的话直接滑至博客底部

Promise构造

首先,我们创建一个promise.js来实现promise,使用class构造类并使用module.exports导出Promise

class Promise {
   constructor(fn) {
   }
}

module.exports = Promise

Promise要求传入一个函数作为参数,如果传入的不为函数,则会出现报错,我们来看看报错的内容
运行下面的代码

new Promise(1).then(val => {
    console.log(val)
})

得到如下的报错
在这里插入图片描述
所以我们在构造函数中加入对传入参数的类型判断

class Promise {
    constructor(fn) {
        // 类型检验
        if (typeof fn !== 'function') {
            throw TypeError(`Promise resolver ${fn} is not a function`)
        }
    }
}

Promise状态变换


接下来,我们知道,Promise有三个状态,进行中,已完成和已失败,我们需要一个值来记录这个状态,为了防止在后面写错,我们使用变量来记录三个状态对应的字符串,避免魔术字符串,并在使用resolve和reject方法时改变状态。

class Promise {
    constructor(fn) {
        // 类型检验
        if (typeof fn !== 'function') {
            throw TypeError(`Promise resolver ${fn} is not a function`)
        }
        // 初始化值
        this.state = Promise.PENDING;
        this.value = null;
        this.reason = null;
        // 调用resolve和reject方法
        try {
            fn(this.resolve, this.reject);
        } catch (e) {
            this.reject(e)
        }
    }
    resolve(val) {
        this.val = val;
        this.state = Promise.RESOLVE;
    }
    reject(reason) {
        this.reason = reason;
        this.state = Promise.REJECTED;
    }
}

Promise.PENDING = "pending";
Promise.RESOLVE = "resolve";
Promise.REJECTED = "rejected";

状态改变后,我们就要来着手实现状态改变后的操作,在Promise中,我们使用then来实现状态改变后的操作,then方法接收两个参数,第一个是当状态变为resolve时调用,第二个是当状态变为rejected时调用。同样地,这里也需要进行参数的判断,当我们传入的参数不为函数时,会将这个值传下去,如下面的代码:

new Promise((resolve, reject) => {
    resolve(1);
}).then(
    1
    // 等同于
    // (val)=>{
    //     return val
    // }
    ).then((val) => {
    console.log(val)
})

所以我们在写then方法时也许要对这部分内容做参数判断,在参数不为函数的情况下,模拟其默认实现

class Promise {
    constructor(fn) {
       // ...
    }
    resolve(val) {
        this.val = val;
        this.state = Promise.RESOLVE;
    }
    reject(reason) {
        this.reason = reason;
        this.state = Promise.REJECTED;
    }
    then(onResolve, onRejected) {
        // 参数类型判断
        if (typeof onResolve !== 'function') {
            onResolve = (val) => {
                return val;
            }
        }
        if (typeof onRejected !== 'function') {
            onRejected = (reason) => {
                throw reason;
            }
        }
        if (this.state === Promise.RESOLVE) {
            onResolve(this.value);
        } else if (this.state === Promise.REJECTED) {
            onRejected(this.reason);
        }
    }
}

运行测试代码

const Promise = require('./promise.js');

new Promise((resolve) => {
    resolve(1);
}).then((val) => {
    console.log(val)
})

结果发现报了一堆错误。。。如图
在这里插入图片描述
可以看出这是由于value被undefined引用,而这里引用value的也就只有this了,所以是this没有指向Promise,经过排除,是resolve和reject方法没有绑定在this上,所以在构造方法上对其进行绑定,为了使功能更加清晰,将初始化值和绑定放在函数中

class Promise {
    constructor(fn) {
        // 类型检验
        if (typeof fn !== 'function') {
            throw TypeError(`Promise resolver ${fn} is not a function`)
        }
        // 初始化值
        this.initVal();
        // 绑定this
        this.initBind();
        // 调用resolve和reject方法
        try {
            fn(this.resolve, this.reject);
        } catch (e) {
            this.reject(e)
        }

    }
    initVal() {
        this.state = Promise.PENDING;
        this.value = null;
        this.reason = null;
    }
    initBind() {
        this.resolve = this.resolve.bind(this);
        this.reject = this.reject.bind(this);
    }
	// ...
}

再测试上面的代码,正常输出了1,这部分的功能实现了。
我们知道,promise是异步的,看下面这段使用了ES6中的Promise的代码,看看输出顺序

console.log(1);
new Promise((resolve, reject) => {
    console.log(2);
    resolve('val');
}).then((val) => {
    console.log(4)
    console.log('val', val)
})
console.log(3);

异步实现


我们知道Promise是异步的,所以这里的输出顺序是1 2 3 4 val,而刚才实现的Promise没有做到异步,同样测试上面这段代码,使用自定义的Promise,得到的结果是1 2 4 val 3。为了实现这个异步,可以使用setTimeout来做到
(这种做法存在一定的问题,setTimeout为微任务,而promise实际上为宏任务,使用setTimeout会使得与规范中Promise的执行顺序存在一定问题,详见详解JavaScript执行机制–异步执行顺序)
将then方法中的操作内容使用setTimeout包裹起来,这里setTimeout可以不设置时间,反正setTimeout是将其中的内容放在执行栈尾部,所以会在同步任务执行完后再执行里面的内容,同时,因为then返回一个Promise,所以我们使用一个Promise将其包裹起来。
为了实现链式调用,我们需要判断什么时候将then方法返回的promise改变状态,将resolve/reject执行后的值作为resolve的参数,并使用try catch捕获错误

then(onResolve, onRejected) {
        // 参数类型判断
        if (typeof onResolve !== 'function') {
            onResolve = (value) => {
                return value;
            }
        }
        if (typeof onRejected !== 'function') {
            onRejected = (reason) => {
                throw reason;
            }
        }
        let promise = new Promise((resolve, reject) => {
            setTimeout(() => {
                if (this.state === Promise.RESOLVE) {
                    setTimeout(() => {
                    try {
                        const val = onResolve(this.value);
                        resolve(val);
                    } catch (e) {
                        reject(e);
                    }
                })
                } else if (this.state === Promise.REJECTED) {
                    setTimeout(() => {
                    try {
                        const val = onRejected(this.reason);
                        resolve(val);
                    } catch (e) {
                        reject(e);
                    }
                })
                }
            })
        })
        return promise;
    }

按上面的方法,实现了异步,但是如果我们在new Promise传入的参数函数中使用异步的话,又会怎样呢

const Promise = require('./promise.js');

console.log(1);
new Promise((resolve, reject) => {
    setTimeout(() => {
        console.log(2);
        resolve('val');
    })
}).then((val) => {
    console.log(4)
    console.log('val', val)
})
console.log(3);

我们会发现,最后只输出了1 3 2,这是因为由于在传入new Promise的参数函数里的resolve执行前,已经执行了then,所以state实际上还是pending,我们可以在then方法返回的promise中加入this.state的输出,会发现输出的结果是pending。
要解决这个问题,我们可以在状态为pending时,将值储存起来,等待状态改变时再执行对应的操作,这里采用数组来存储,并在状态为pending时将value/reason push进对应的数组中

class Promise {
    constructor(fn) {
        // 类型检验
        if (typeof fn !== 'function') {
            throw TypeError(`Promise resolver ${fn} is not a function`)
        }
        // 初始化值
        this.initVal();
        // 绑定this
        this.initBind();
        // 调用resolve和reject方法
        try {
            fn(this.resolve, this.reject);
        } catch (e) {
            this.reject(e)
        }

    }
    initVal() {
        this.state = Promise.PENDING;
        this.value = null;
        this.reason = null;
        this.resolveArr = []; // 成功回调的数组
        this.rejectArr = []; // 失败回调的数组
    }
    initBind() {
        this.resolve = this.resolve.bind(this);
        this.reject = this.reject.bind(this);
    }
    resolve(value) {
        if (this.state === Promise.PENDING) {
            this.value = value;
            this.state = Promise.RESOLVE;
            this.resolveArr.forEach(fn => fn(this.value));
        }
    }
    reject(reason) {
        if (this.state === Promise.PENDING) {
            this.reason = reason;
            this.state = Promise.REJECTED;
            this.rejectArr.forEach(fn => fn(this.reason));
        }
    }
    then(onResolve, onRejected) {
        // 参数类型判断
        if (typeof onResolve !== 'function') {
            onResolve = (value) => {
                return value;
            }
        }
        if (typeof onRejected !== 'function') {
            onRejected = (reason) => {
                throw reason;
            }
        }
        let promise = new Promise((resolve, reject) => {
            if (this.state === Promise.RESOLVE) {
                setTimeout(() => {
                    try {
                        const val = onResolve(this.value);
                        resolve(val);
                    } catch (e) {
                        reject(e);
                    }
                })
            } else if (this.state === Promise.REJECTED) {
                setTimeout(() => {
                    try {
                        const val = onRejected(this.reason);
                        resolve(val);
                    } catch (e) {
                        reject(e);
                    }
                })
            } else if (this.state === Promise.PENDING) {
                // 将值压入数组中
                this.resolveArr.push((value) => {
                    setTimeout(() => {
                        try {
                            onResolve(value)
                            resolve(val);
                        } catch (e) {
                            reject(e);
                        }
                    });
                })
                this.rejectArr.push((value) => {
                    setTimeout(() => {
                        try {
                            const val = onRejected(this.reason);
                            resolve(val);
                        } catch (e) {
                            reject(e);
                        }
                    });
                })
            }
        })
        return promise;
    }
}

对返回内容的处理


至此,我们已经基本完成了Promise的内容,回到创建Promise实例的地方,我们每次resolve返回的值都为一个字符串或者一个数字,那么如果我们返回一个Promise对象呢

const Promise = require('./promise.js');

new Promise((resolve, reject) => {
    resolve(1)
}).then((val) => {
    return new Promise((resolve, reject) => {
        resolve(val);
    })
}).then((val) => {
    console.log('val', val)
})

正常情况下这里应该输出1,但是在我们的测试代码中,却输出了整个Promise对象,这正是上面缺漏的地方,我们没对复杂的参数进行对应的处理。
在Promise中,Promise构造器第一个参数回调会展开thenable或真正的Promise,而第二个参数reject并不像第一个参数resolve一样,reject只会将传入的Promise/thenable值原封不动地设置为拒绝理由,不会展开Promise/thenable。
下面对代码进行修改,首先要将返回的promise对象中调用的resolve在执行前判断各种条件并做处理,这里使用一个新的方法来对这部分条件进行判断处理,该方法需要的参数有:当前then方法返回的promise,onResolve/onReject返回的值以及resolve和reject

Promise.resolvePromise = function(promise, val, resolve, reject) {
    // 判断onResolve/onReject的返回值的类型是否为Promise
    if (val instanceof Promise) {
        val.then(
            // 状态变为resolve的情况
            value => {
                Promise.resolvePromise(promise, value, resolve, reject);
            },
            // 状态变为rejected的情况
            reason => {
                reject(reason);
            }
        )
    }
    // 判断onResolve/onReject的返回值的类型是否为对象或者方法
    else if (Object.prototype.toString.call(val) === "[object Object]" ||
        Object.prototype.toString.call(val) === "[object Function]") {
        try {
            const then = val.then;
            if (typeof then === "function") {
                // 取出val的then方法,将其this绑定在val上
                then.call(
                    val,
                    value => {
                        Promise.resolvePromise(promise, value, resolve, reject);
                    },
                    reason => {
                        reject(reason);
                    }
                )
            } else {
                resolve(val)
            }
        } catch (e) {
            reject(e)
        }
    }
    // 判断onResolve/onReject的返回值的类型不为对象或者函数,直接使用resolve执行
    else {
        resolve(val);
    }
}

这个方法到这里基本可以解决问题了,但是如果在调用方法时,onResolve和onRejected同时被调用,按Promise的规定,我们会先执行优先变化的那个,而慢变化的那个,由于Promise状态的不可逆性,只能由pending变为resolve/rejected,所以慢变化的那个就会被忽略,所以我们再对上面的代码进行修改

Promise.resolvePromise = function(promise, val, resolve, reject) {
    // 用于判断状态是否已经改变了
    let called = false;
    // 判断onResolve/onReject的返回值的类型是否为Promise
    if (val instanceof Promise) {
        val.then(
            // 状态变为resolve的情况
            value => {
                Promise.resolvePromise(promise, value, resolve, reject);
            },
            // 状态变为rejected的情况
            reason => {
                reject(reason);
            }
        )
    }
    // 判断onResolve/onReject的返回值的类型是否为对象或者方法
    else if (Object.prototype.toString.call(val) === "[object Object]" ||
        Object.prototype.toString.call(val) === "[object Function]") {
        try {
            const then = val.then;
            if (typeof then === "function") {
                // 取出val的then方法,将其this绑定在val上
                then.call(
                    val,
                    value => {
                        if (called) {
                            return;
                        }
                        called = true;
                        Promise.resolvePromise(promise, value, resolve, reject);
                    },
                    reason => {
                        if (called) {
                            return;
                        }
                        called = true;
                        reject(reason);
                    }
                )
            } else {
                if (called) {
                    return;
                }
                called = true;
                resolve(val)
            }
        } catch (e) {
            if (called) {
                return;
            }
            called = true;
            reject(e)
        }
    }
    // 判断onResolve/onReject的返回值的类型不为对象或者函数,直接使用resolve执行
    else {
        resolve(val);
    }
}

Promise的重复调用


问题解决,来到下一个问题,如果Promise重复调用,会发生什么呢,看下面的代码

let p1 = new Promise((resolve, reject) => {
    resolve(1);
})
let p2 = p1.then(() => {
    return p2;
})

这段代码的执行最终会报下图的错误
在这里插入图片描述
实际上就是then方法返回的内容与本身的promise相同,这样不断地循环调用,最终报错,我们在Promise.resolvePromise方法的开头进行判断并将上面的错误复制进去。

Promise.resolvePromise = function(promise, val, resolve, reject) {
    // 对循环调用的判断处理
    if (promise === val) {
        reject(new TypeError('Chaining cycle detected for promise'))
    }
	// ...
}

最终代码


class Promise {
    constructor(fn) {
        // 类型检验
        if (typeof fn !== 'function') {
            throw TypeError(`Promise resolver ${fn} is not a function`)
        }
        // 初始化值
        this.initVal();
        // 绑定this
        this.initBind();
        // 调用resolve和reject方法
        try {
            fn(this.resolve, this.reject);
        } catch (e) {
            this.reject(e)
        }
    }

    initVal() {
        this.state = Promise.PENDING;
        this.value = null;
        this.reason = null;
        this.resolveArr = []; // 成功回调的数组
        this.rejectArr = []; // 失败回调的数组
    }

    initBind() {
        this.resolve = this.resolve.bind(this);
        this.reject = this.reject.bind(this);
    }

    resolve(value) {
        if (this.state === Promise.PENDING) {
            this.value = value;
            this.state = Promise.RESOLVE;
            this.resolveArr.forEach(fn => fn(this.value));
        }
    }

    reject(reason) {
        if (this.state === Promise.PENDING) {
            this.reason = reason;
            this.state = Promise.REJECTED;
            this.rejectArr.forEach(fn => fn(this.reason));
        }
    }

    then(onResolve, onRejected) {
        // 参数类型判断
        if (typeof onResolve !== 'function') {
            onResolve = (value) => {
                return value;
            }
        }
        if (typeof onRejected !== 'function') {
            onRejected = (reason) => {
                throw reason;
            }
        }
        // 实现链式调用
        let promise = new Promise((resolve, reject) => {
            if (this.state === Promise.RESOLVE) {
                setTimeout(() => {
                    try {
                        const val = onResolve(this.value);
                        Promise.resolvePromise(promise, val, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                })
            } else if (this.state === Promise.REJECTED) {
                setTimeout(() => {
                    try {
                        const val = onRejected(this.reason);
                        Promise.resolvePromise(promise, val, resolve, reject);
                    } catch (e) {
                        reject(e);
                    }
                })
            } else if (this.state === Promise.PENDING) {
                // 将值压入数组中
                this.resolveArr.push((value) => {
                    setTimeout(() => {
                        try {
                            onResolve(value)
                            Promise.resolvePromise(promise, val, resolve, reject);
                        } catch (e) {
                            reject(e);
                        }
                    });
                })
                this.rejectArr.push((value) => {
                    setTimeout(() => {
                        try {
                            const val = onRejected(this.reason);
                            Promise.resolvePromise(promise, val, resolve, reject);
                        } catch (e) {
                            reject(e);
                        }
                    });
                })
            }
        })
        return promise;
    }
}

Promise.PENDING = "pending";
Promise.RESOLVE = "resolve";
Promise.REJECTED = "rejected";
Promise.resolvePromise = function(promise, val, resolve, reject) {
    // 对循环调用的判断处理
    if (promise === val) {
        reject(new TypeError('Chaining cycle detected for promise'))
    }
    // 用于判断状态是否已经改变了
    let called = false;
    // 判断onResolve/onReject的返回值的类型是否为Promise
    if (val instanceof Promise) {
        val.then(
            // 状态变为resolve的情况
            value => {
                Promise.resolvePromise(promise, value, resolve, reject);
            },
            // 状态变为rejected的情况
            reason => {
                reject(reason);
            }
        )
    }
    // 判断onResolve/onReject的返回值的类型是否为对象或者方法
    else if (Object.prototype.toString.call(val) === "[object Object]" ||
        Object.prototype.toString.call(val) === "[object Function]") {
        try {
            const then = val.then;
            if (typeof then === "function") {
                // 取出val的then方法,将其this绑定在val上
                then.call(
                    val,
                    value => {
                        if (called) {
                            return;
                        }
                        called = true;
                        Promise.resolvePromise(promise, value, resolve, reject);
                    },
                    reason => {
                        if (called) {
                            return;
                        }
                        called = true;
                        reject(reason);
                    }
                )
            } else {
                if (called) {
                    return;
                }
                called = true;
                resolve(val)
            }
        } catch (e) {
            if (called) {
                return;
            }
            called = true;
            reject(e)
        }
    }
    // 判断onResolve/onReject的返回值的类型不为对象或者函数,直接使用resolve执行
    else {
        resolve(val);
    }
}


module.exports = Promise

基本实现了Promise的大部分内容,出现什么错误请路过大佬指出。


参考文档:Promises/A+规范

解密UFS Explorer:Drobo BeyondRAID数据恢复实战指南 本文详细介绍了使用UFS Explorer Professional Recovery软件中的Drobo BeyondRAID助手进行数据恢复的完整实战流程。当Drobo设备因BeyondRAID配置信息丢失而无法访问时,该工具能安全、只读地扫描硬盘,虚拟重建存储池,帮助用户找回宝贵数据。指南涵盖了从前期准备、硬盘选择、配置扫描到数据安全导出的每一步关键操作与常见问题解决方案。 阅读详情

相关推荐

ENVI中Landsat8大气校正法实现地表温度精准反演

本文详细介绍了在ENVI软件中,利用大气校正法对Landsat8热红外数据进行地表温度反演的完整流程。该方法通过辐射定标、大气参数获取、发射率估算及温度转换四个核心步骤,精准剔除大气干扰,还原地表真实温度,是城市热岛效应监测、农业旱情分析等应用的关键技术。

weixin_29292535的博客 151

javaScript进阶 ES6 详细全解,解构赋值,Proxy,箭头函数,class类, 模块,export和import,Promise,then 方法,async等等

前言:读万卷书不如行万里路,行万里路不如名师指路,还是阅人无数? 解构赋值 Proxy 6.class类 7.模块 export和import as 的用法& export default Promise&then方法 async javaScript进阶 一、作用域 JS的作用域简单来说就是变量(变量作用于又称上下文)和函数生效(能被访问)的区域 1.全局作用域 ...

cao919的专栏Net 2060

Widar3.0复现日志(DFSExtractionCode)

需要使用的matlab基本功能

XiaoQiXiaoWei_J的博客 2440

ES6深入—Module 与 Promise 对象

本文讲解了 Module 对 export 命令、import 命令的基本用法;以及对 Promise 对象三种不同状态时应进行的相应操作和示例讲解。

weixin_44009656的博客 618

STM32 ADC+DMA实战:手把手教你驱动XGZP6847A压力传感器(附完整代码)

本文详细介绍了如何使用STM32的ADC和DMA外设驱动XGZP6847A压力传感器,包括硬件连接、ADC配置、DMA高效传输实现以及数据处理与校准方法。通过实战案例和完整代码,帮助开发者快速掌握高精度压力数据采集技术,适用于工业控制和医疗设备等领域。

weixin_42570484的博客 406

独立游戏开发者必看:STEAM税务信息更新全流程(附中国区避坑指南)

本文为独立游戏开发者详细解析了Steam税务信息更新的全流程,重点针对中国区开发者提供了避坑指南。文章深入解释了W-8BEN表格的填写要点,并指导如何准备个人所得税纳税记录和身份证等核心证明文件,以确保顺利通过审核,避免收入被预扣税款。

tcp8optimizer的博客 1324

js中的promise详解

js中的promise详解

zyf971020的博客 6万+

U盘拒绝访问的根源与权限修复全指南

U盘‘拒绝访问’是Windows权限机制的典型表现,本质源于用户SID与NTFS安全描述符(Security Descriptor)匹配失败,而非硬件故障或文件系统损坏。其原理涉及UAC控制、ACL继承中断、所有权归属缺失及组策略压制等多层机制。技术价值在于无需格式化即可恢复访问,保障数据零丢失;典型应用场景包括跨电脑使用U盘、Win11家庭版无gpedit.msc、OEM预装软件干扰等。本文聚焦U盘权限修复核心路径,结合icacls命令重置继承、takeown夺回所有权、注册表绕过组策略限制等实操方法,覆

weixin_31742871的博客 344

ES6模块化export异步导出数据

ES6模块化export异步导出数据,实现的方式。 当我们尝试在js中使用export导出异步的数据时,会发现输出的是异步前的结果。 //export.js let asyData = [1, 2, 3] setTimeout(function () { asyData = [3, 2, 1] }, 2000); export { asyData } //import.js import { asyData } from "./export.js"; console.log( as

伟深么的博客 4178

Hypermesh二次开发实战:从Tcl/Tk脚本到Ext API的进阶之路

本文系统介绍了Hypermesh二次开发的进阶路径,从自动化重复操作的Tcl/Tk脚本入门,到利用HMASCII接口深度读写模型数据,最终深入Ext API进行高性能计算与功能定制。通过实战案例,帮助工程师掌握从脚本录制到C++插件开发的完整技能,显著提升CAE前处理效率与自动化水平。

weixin_29306875的博客 672

8155源码编译DSP(ubuntu环境下)

一.设置环境变量 -users:/$ sudo gedit ~/.bashrc #set adsp cdsp tools path #export ARMLMD_LICENSE_FILE=<LICENSE FILE INFO> #export ARMTOOLS=RVCT221 #export ARMROOT=/pkg/asw/compilers/arm/ADS1.2 #export ARM_COMPILER_PATH=/pkg/qct/software/arm/RVDS/2.2BLD593

Johnny2004的专栏 1679

promise简单的封装以及export和export default 的区别

简单的promise封装 封装promise时首先我们需要了解promise是什么? 1、主要用于异步计算。 2、可以将异步操作队列化,按照期望的顺序执行,返回符合预期的结果。 3、可以在对象之间传递和操作promise,帮助我们处理队列。 promise 封装 const promise = new Promise(function(resolve, reject) { if (/* 异步操作成功 */){ resolve(value) } else { reject(error)

a552966346的博客 1079

图形推理2-四大类六提示

图形推理笔记2

小y的学习笔记 6752

es6的Promise对象详解

秋招已经进入了尾声,这两个月以来一直忙着找工作,没有时间看新东西,这几天得空将es6的Promise对象又细细的理解了一下,所以下来整理一下我对Promise对象以及用法的理解。什么是Promise?为什么要使用Promise? 当我们使用js的异步调用时通常习惯使用回调函数,这样的代码简单便于理解,但是当回调嵌套的时候就会造成代码混乱,不好梳理,比如:function fun1(arg1,fun

csdn_zsdf的博客 7141

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

ES6语法详解

模板字符串。

拥抱变化! 2320

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

ES6 Promise实现异步操作

ES6 Promise的内容就这些吗?是的,能用到的基本就这些。我怎么还见过done、finally、success、fail等,这些是啥?这些并不在Promise标准中,而是我们自己实现的语法糖。本文中所有异步操作均以setTimeout为例子,之所以不使用ajax是为了避免引起混淆,因为谈起ajax,很多人的第一反应就是jquery的ajax,而jquery又有自己的Promise实现。如果你理解了原理,就知道使用setTimeout和使用ajax是一样的意思。

weixin_41987908的博客 957

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

JS ES6 Promise 之 Hello World

■前言最近学习VUE,涉及到了一些内容,都不了解,比如 Axios, Promise,所以,整理记录一下仅仅是一个【 简单 】的介绍,更多的内容,可以看看提供的文章链接,或是其他的资料。0.AxiosAxios,可以理解为ajax i/o system,这不是一种新技术,本质上还是对原生XMLHttpRequest的封装,可用于浏览器和nodejs的HTTP客户端,只不过它是基于Promise的,符合最新的ES规范。

sun0322 5220

ES6 Promise相关用法详解

Promise是异步编程的一种解决方案,异步编程的历程经历了:回调函数和事件 ->Promise->。相较于传统的回调函数和事件,Promise了回调函数可能引发的,是有了进一步的。

qq_56427830的博客 1180

JavaScript ES6到ES10语法 回调地狱与异步操作 Promise then

[toc](JavaScript ES6到ES10语法 回调地狱与异步操作 Promise then)resolve reject catch all race。

一个做过前端开发的产品经理,经历过睿智产品的折磨导致脱发之后,励志要翻身"农奴"把歌唱,一边打入敌人内部一边持续提升自己,为我们广大开发同胞谋福祉,坚决抵制睿智产品折磨我们码农兄弟! 1006

es6 promise详解

基本概念 Promise是一个构造函数,自己身上有all、reject、resolve这几个眼熟的方法,原型上有then、catch等同样很眼熟的方法。这么说用Promise new出来的对象肯定就有then、catch方法喽,没错。 那就new一个玩玩吧。 var p = new Promise(function(resolve, reject){ //做一些异步操作 setTimeout(function(){ console.log('执行完成');

qq_40096030的博客 1570

说说es6 promise async await 以及 promise A+规范的了解

Promise是 JavaScript 中用于处理异步操作的一种方式,它表示一个异步操作的最终完成(或失败)及其结果值的表示。Promise是 ES6 引入的,它通过链式调用来处理回调函数,避免了“回调地狱”的问题。async和await是 ES2017(ES8)引入的用于简化处理异步操作的语法糖。它们是基于Promise的,但使用起来更加简洁和直观。async:标记一个函数为异步函数,返回一个Promise对象。await:用于等待一个Promise对象的完成,await后面必须跟一个Promise。

HHX_01的博客 1180

【ES6新特性】ES6新特性中Promise对象的概念,Async函数的使用以及Module语法

ES6新特性中Promise对象的概念,Async函数的使用以及Module语法

qq_62555748的博客 1111

详解ES6的Promise

异步操作处理:Promise用于处理需要等待时间较长的操作,如网络请求、文件读取等。通过Promise可以更清晰地表达异步操作的执行顺序和结果处理。状态:Promise有三种状态:pending(进行中)、fulfilled(已完成)和rejected(已失败)。初始状态为pending,当操作成功完成时,状态变为fulfilled,如果发生错误,状态则变为rejected。then()方法:Promise对象的then()方法用于指定操作成功或失败时的回调函数。

rr20060119的博客 1268

promise 中的异常捕获_ES6 的 promise 和异步捕获错误 catch

ES6 已经学习了不少,因为平常学习写代码没怎么用到 Promise 就没怎么学这一部分。但随着深入的学习,接触好几次 Promise 了,决心学习一下,毕竟这部分还是很重要的,还有就是原生最新的 Ajax 请求,不用不知道有多好用,以前的设计真是反人类的设计。一、Promise 的含义Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大。它由社区最早提出...

weixin_39683598的博客 1752

ES6 promise详解

ES6 Promise 1.什么是promise? ES6 中一个非常重要和好用的特性就是Promise promise 到底是做什么的呢? promise 是异步编程的一种解决方案。 那什么时候我们回来处理异步事件呢? 1.一种很常见的场景就是网络请求 2.我们分装一个网络请求的函数,因为不能立即拿到结果,所以不能像简单的3+4 = 7一样将结果返回。 3.所以我们往往会传入另外一个...

qq_43955202的博客 1379

分析ES6Promise

简版ES6语法 function _Promise(...args) { this.status = "pending"; this.msg = ""; const process = args[0]; process( (...args) => { this.status = "resolve"; this.msg = args[0]; ...

coderMozart的博客 321
上一篇: wireshark学习笔记----抓包网络原理
下一篇: node.js爬虫——爬取优快云首页的文章内容
前端小黑
博客等级 码龄9年 148粉丝 222原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值