https://www.beilika.com/贝莉卡个人博客，分享JS，HTML，JAVA，PHP，Linux，Golang等编程语言技术zh-cnCopyright beilika.com. All Rights ReservedFri, 13 Feb 2026 10:20:38 +0800https://www.beilika.com/article/c169.htmlAihttps://www.beilika.com/article/c169.htmlFri, 13 Feb 2026 10:05:29 +0800https://www.beilika.com/article/c168.htmlAihttps://www.beilika.com/article/c168.htmlFri, 13 Feb 2026 09:46:32 +0800https://www.beilika.com/article/c167.htmlAihttps://www.beilika.com/article/c167.htmlFri, 13 Feb 2026 09:24:27 +0800https://www.beilika.com/article/c166.htmlWindowshttps://www.beilika.com/article/c166.htmlTue, 10 Feb 2026 15:14:44 +0800https://www.beilika.com/article/c165.htmlnssmstartwebapp8888webapp8888:START:操作成功完成。（2）关闭服务D:\nssm-2.24\win64>nssmstopwebapp8888webapp8888:STOP:操作成功完成。（3）重启服务如果服务未启动就会直接启动，启动的会重启。D:\nssm-2.24\win64>nssmrestartwebapp8888webapp8888:STOP:服务尚未启动。webapp8888:START:操作成功完成。D:\nssm-2.24\win64>nssmrestartwebapp8888webapp8888:STOP:操作成功完成。webapp8888:START:操作成功完成。（4）修改服务输入命令，修改配置，不能修改服务名D:\nssm-2.24\win64>nssmeditwebapp8888（5）删除服务删除有二次确认，删除之后服务就找不到了，需要重新安装D:\nssm-2.24\win64>nssmremovewebapp8888Service"webapp8888"removedsuccessfully!]]>Windowshttps://www.beilika.com/article/c165.htmlTue, 10 Feb 2026 15:00:56 +0800https://www.beilika.com/article/c164.html{setTimeout(resolve,ms);});}asyncfunctionasyncPrint(value,ms){awaittimeout(ms);console.log(value);}asyncPrint('helloworld',50);上面代码指定50毫秒以后，输出helloworld。由于async函数返回的是Promise对象，可以作为await命令的参数。所以，上面的例子也可以写成下面的形式。asyncfunctiontimeout(ms){awaitnewPromise((resolve)=>{setTimeout(resolve,ms);});}asyncfunctionasyncPrint(value,ms){awaittimeout(ms);console.log(value);}asyncPrint('helloworld',50);async函数有多种使用形式。//函数声明asyncfunctionfoo(){}//函数表达式constfoo=asyncfunction(){};//对象的方法letobj={asyncfoo(){}};obj.foo().then(...)//Class的方法classStorage{constructor(){this.cachePromise=caches.open('avatars');}asyncgetAvatar(name){constcache=awaitthis.cachePromise;returncache.match(`/avatars/${name}.jpg`);}}conststorage=newStorage();storage.getAvatar('jake').then(…);//箭头函数constfoo=async()=>{};语法async函数的语法规则总体上比较简单，难点是错误处理机制。返回Promise对象async函数返回一个Promise对象。async函数内部return语句返回的值，会成为then方法回调函数的参数。asyncfunctionf(){return'helloworld';}f().then(v=>console.log(v))//"helloworld"上面代码中，函数f内部return命令返回的值，会被then方法回调函数接收到。async函数内部抛出错误，会导致返回的Promise对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。asyncfunctionf(){thrownewError('出错了');}f().then(v=>console.log(v),e=>console.log(e))//Error:出错了Promise对象的状态变化async函数返回的Promise对象，必须等到内部所有await命令后面的Promise对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。下面是一个例子。asyncfunctiongetTitle(url){letresponse=awaitfetch(url);lethtml=awaitresponse.text();returnhtml.match(/([\s\S]+)/i)[1];}getTitle('https://tc39.github.io/ecma262/').then(console.log)//"ECMAScript2017LanguageSpecification"上面代码中，函数getTitle内部有三个操作：抓取网页、取出文本、匹配页面标题。只有这三个操作全部完成，才会执行then方法里面的console.log。await命令正常情况下，await命令后面是一个Promise对象，返回该对象的结果。如果不是Promise对象，就直接返回对应的值。asyncfunctionf(){//等同于//return123;returnawait123;}f().then(v=>console.log(v))//123上面代码中，await命令的参数是数值123，这时等同于return123。另一种情况是，await命令后面是一个thenable对象（即定义了then方法的对象），那么await会将其等同于Promise对象。classSleep{constructor(timeout){this.timeout=timeout;}then(resolve,reject){conststartTime=Date.now();setTimeout(()=>resolve(Date.now()-startTime),this.timeout);}}(async()=>{constsleepTime=awaitnewSleep(1000);console.log(sleepTime);})();//1000上面代码中，await命令后面是一个Sleep对象的实例。这个实例不是Promise对象，但是因为定义了then方法，await会将其视为Promise处理。这个例子还演示了如何实现休眠效果。JavaScript一直没有休眠的语法，但是借助await命令就可以让程序停顿指定的时间。下面给出了一个简化的sleep实现。functionsleep(interval){returnnewPromise(resolve=>{setTimeout(resolve,interval);})}//用法asyncfunctionone2FiveInAsync(){for(leti=1;iconsole.log(v)).catch(e=>console.log(e))//出错了注意，上面代码中，await语句前面没有return，但是reject方法的参数依然传入了catch方法的回调函数。这里如果在await前面加上return，效果是一样的。任何一个await语句后面的Promise对象变为reject状态，那么整个async函数都会中断执行。asyncfunctionf(){awaitPromise.reject('出错了');awaitPromise.resolve('helloworld');//不会执行}上面代码中，第二个await语句是不会执行的，因为第一个await语句状态变成了reject。有时，我们希望即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，第二个await都会执行。asyncfunctionf(){try{awaitPromise.reject('出错了');}catch(e){}returnawaitPromise.resolve('helloworld');}f().then(v=>console.log(v))//helloworld另一种方法是await后面的Promise对象再跟一个catch方法，处理前面可能出现的错误。asyncfunctionf(){awaitPromise.reject('出错了').catch(e=>console.log(e));returnawaitPromise.resolve('helloworld');}f().then(v=>console.log(v))//出错了//helloworld错误处理如果await后面的异步操作出错，那么等同于async函数返回的Promise对象被reject。asyncfunctionf(){awaitnewPromise(function(resolve,reject){thrownewError('出错了');});}f().then(v=>console.log(v)).catch(e=>console.log(e))//Error：出错了上面代码中，async函数f执行后，await后面的Promise对象会抛出一个错误对象，导致catch方法的回调函数被调用，它的参数就是抛出的错误对象。具体的执行机制，可以参考后文的“async函数的实现原理”。防止出错的方法，也是将其放在try...catch代码块之中。asyncfunctionf(){try{awaitnewPromise(function(resolve,reject){thrownewError('出错了');});}catch(e){}returnawait('helloworld');}如果有多个await命令，可以统一放在try...catch结构中。asyncfunctionmain(){try{constval1=awaitfirstStep();constval2=awaitsecondStep(val1);constval3=awaitthirdStep(val1,val2);console.log('Final:',val3);}catch(err){console.error(err);}}下面的例子使用try...catch结构，实现多次重复尝试。constsuperagent=require('superagent');constNUM_RETRIES=3;asyncfunctiontest(){leti;for(i=0;i{await_;awaitdb.post(doc);},undefined);}上面例子中，reduce方法的第一个参数是async函数，导致该函数的第一个参数是前一步操作返回的Promise对象，所以必须使用await等待它操作结束。另外，reduce方法返回的是docs数组最后一个成员的async函数的执行结果，也是一个Promise对象，导致在它前面也必须加上await。如果确实希望多个请求并发执行，可以使用Promise.all方法。当三个请求都会resolved时，下面两种写法效果相同。asyncfunctiondbFuc(db){letdocs=[{},{},{}];letpromises=docs.map((doc)=>db.post(doc));letresults=awaitPromise.all(promises);console.log(results);}//或者使用下面的写法asyncfunctiondbFuc(db){letdocs=[{},{},{}];letpromises=docs.map((doc)=>db.post(doc));letresults=[];for(letpromiseofpromises){results.push(awaitpromise);}console.log(results);}第四点，async函数可以保留运行堆栈。consta=()=>{b().then(()=>c());};上面代码中，函数a内部运行了一个异步任务b()。当b()运行的时候，函数a()不会中断，而是继续执行。等到b()运行结束，可能a()早就运行结束了，b()所在的上下文环境已经消失了。如果b()或c()报错，错误堆栈将不包括a()。现在将这个例子改成async函数。consta=async()=>{awaitb();c();};上面代码中，b()运行的时候，a()是暂停执行，上下文环境都保存着。一旦b()或c()报错，错误堆栈将包括a()。async函数的实现原理async函数的实现原理，就是将Generator函数和自动执行器，包装在一个函数里。asyncfunctionfn(args){//...}//等同于functionfn(args){returnspawn(function*(){//...});}所有的async函数都可以写成上面的第二种形式，其中的spawn函数就是自动执行器。下面给出spawn函数的实现，基本就是前文自动执行器的翻版。functionspawn(genF){returnnewPromise(function(resolve,reject){constgen=genF();functionstep(nextF){letnext;try{next=nextF();}catch(e){returnreject(e);}if(next.done){returnresolve(next.value);}Promise.resolve(next.value).then(function(v){step(function(){returngen.next(v);});},function(e){step(function(){returngen.throw(e);});});}step(function(){returngen.next(undefined);});});}与其他异步处理方法的比较我们通过一个例子，来看async函数与Promise、Generator函数的比较。假定某个DOM元素上面，部署了一系列的动画，前一个动画结束，才能开始后一个。如果当中有一个动画出错，就不再往下执行，返回上一个成功执行的动画的返回值。首先是Promise的写法。functionchainAnimationsPromise(elem,animations){//变量ret用来保存上一个动画的返回值letret=null;//新建一个空的Promiseletp=Promise.resolve();//使用then方法，添加所有动画for(letanimofanimations){p=p.then(function(val){ret=val;returnanim(elem);});}//返回一个部署了错误捕捉机制的Promisereturnp.catch(function(e){/*忽略错误，继续执行*/}).then(function(){returnret;});}虽然Promise的写法比回调函数的写法大大改进，但是一眼看上去，代码完全都是Promise的API（then、catch等等），操作本身的语义反而不容易看出来。接着是Generator函数的写法。functionchainAnimationsGenerator(elem,animations){returnspawn(function*(){letret=null;try{for(letanimofanimations){ret=yieldanim(elem);}}catch(e){/*忽略错误，继续执行*/}returnret;});}上面代码使用Generator函数遍历了每个动画，语义比Promise写法更清晰，用户定义的操作全部都出现在spawn函数的内部。这个写法的问题在于，必须有一个任务运行器，自动执行Generator函数，上面代码的spawn函数就是自动执行器，它返回一个Promise对象，而且必须保证yield语句后面的表达式，必须返回一个Promise。最后是async函数的写法。asyncfunctionchainAnimationsAsync(elem,animations){letret=null;try{for(letanimofanimations){ret=awaitanim(elem);}}catch(e){/*忽略错误，继续执行*/}returnret;}可以看到Async函数的实现最简洁，最符合语义，几乎没有语义不相关的代码。它将Generator写法中的自动执行器，改在语言层面提供，不暴露给用户，因此代码量最少。如果使用Generator写法，自动执行器需要用户自己提供。实例：按顺序完成异步操作实际开发中，经常遇到一组异步操作，需要按照顺序完成。比如，依次远程读取一组URL，然后按照读取的顺序输出结果。Promise的写法如下。functionlogInOrder(urls){//远程读取所有URLconsttextPromises=urls.map(url=>{returnfetch(url).then(response=>response.text());});//按次序输出textPromises.reduce((chain,textPromise)=>{returnchain.then(()=>textPromise).then(text=>console.log(text));},Promise.resolve());}上面代码使用fetch方法，同时远程读取一组URL。每个fetch操作都返回一个Promise对象，放入textPromises数组。然后，reduce方法依次处理每个Promise对象，然后使用then，将所有Promise对象连起来，因此就可以依次输出结果。这种写法不太直观，可读性比较差。下面是async函数实现。asyncfunctionlogInOrder(urls){for(consturlofurls){constresponse=awaitfetch(url);console.log(awaitresponse.text());}}上面代码确实大大简化，问题是所有远程操作都是继发。只有前一个URL返回结果，才会去读取下一个URL，这样做效率很差，非常浪费时间。我们需要的是并发发出远程请求。asyncfunctionlogInOrder(urls){//并发读取远程URLconsttextPromises=urls.map(asyncurl=>{constresponse=awaitfetch(url);returnresponse.text();});//按次序输出for(consttextPromiseoftextPromises){console.log(awaittextPromise);}}上面代码中，虽然map方法的参数是async函数，但它是并发执行的，因为只有async函数内部是继发执行，外部不受影响。后面的for..of循环内部使用了await，因此实现了按顺序输出。]]>JShttps://www.beilika.com/article/c164.htmlFri, 14 Nov 2025 09:48:17 +0800https://www.beilika.com/article/c163.htmlstream.once('end',resolve)),newPromise((resolve,reject)=>stream.once('error',reject))]);if(!res){break;}stream.removeAllListeners('data');stream.removeAllListeners('end');stream.removeAllListeners('error');valjeanCount+=(res.toString().match(/valjean/ig)||[]).length;}console.log('count:',valjeanCount);//count:1120});上面代码采用Stream模式读取《悲惨世界》的文本文件，对于每个数据块都使用stream.once方法，在data、end、error三个事件上添加一次性回调函数。变量res只有在data事件发生时才有值，然后累加每个数据块之中valjean这个词出现的次数。]]>JShttps://www.beilika.com/article/c163.htmlFri, 14 Nov 2025 09:47:54 +0800https://www.beilika.com/article/c162.htmlJShttps://www.beilika.com/article/c162.htmlFri, 14 Nov 2025 09:47:27 +0800https://www.beilika.com/article/c161.html3与其他遍历语法的比较以数组为例，JavaScript提供多种遍历语法。最原始的写法就是for循环。for(varindex=0;index1000)break;console.log(n);}上面的例子，会输出斐波纳契数列小于等于1000的项。如果当前项大于1000，就会使用break语句跳出for...of循环。]]>JShttps://www.beilika.com/article/c161.htmlFri, 14 Nov 2025 09:47:02 +0800https://www.beilika.com/article/c160.htmlresolve('foo'))Promise.resolve方法的参数分成四种情况。（1）参数是一个Promise实例如果参数是Promise实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。（2）参数是一个thenable对象thenable对象指的是具有then方法的对象，比如下面这个对象。letthenable={then:function(resolve,reject){resolve(42);}};Promise.resolve方法会将这个对象转为Promise对象，然后就立即执行thenable对象的then方法。letthenable={then:function(resolve,reject){resolve(42);}};letp1=Promise.resolve(thenable);//这里的then是Promise的then，和上面那个不是同一个了//console.log(thenable.then==p1.then)falsep1.then(function(value){console.log(value);//42});上面代码中，thenable对象的then方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then方法指定的回调函数，输出42。（3）参数不是具有then方法的对象，或根本就不是对象如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的Promise对象，状态为resolved。constp=Promise.resolve('Hello');p.then(function(s){console.log(s)});//Hello上面代码生成一个新的Promise对象的实例p。由于字符串Hello不属于异步操作（判断方法是字符串对象不具有then方法），返回Promise实例的状态从一生成就是resolved，所以回调函数会立即执行。Promise.resolve方法的参数，会同时传给回调函数。（4）不带有任何参数Promise.resolve()方法允许调用时不带参数，直接返回一个resolved状态的Promise对象。所以，如果希望得到一个Promise对象，比较方便的方法就是直接调用Promise.resolve()方法。constp=Promise.resolve();p.then(function(){//...});上面代码的变量p就是一个Promise对象。需要注意的是，立即resolve()的Promise对象，是在本轮“事件循环”（eventloop）的结束时执行，而不是在下一轮“事件循环”的开始时。setTimeout(function(){console.log('three');},0);Promise.resolve().then(function(){console.log('two');});console.log('one');//one//two//three上面代码中，setTimeout(fn,0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行，因此最先输出。Promise.reject()Promise.reject(reason)方法也会返回一个新的Promise实例，该实例的状态为rejected。constp=Promise.reject('出错了');//等同于constp=newPromise((resolve,reject)=>reject('出错了'))p.then(null,function(s){console.log(s)});//出错了上面代码生成一个Promise对象的实例p，状态为rejected，回调函数会立即执行。注意，Promise.reject()方法的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。constthenable={then(resolve,reject){reject('出错了');}};Promise.reject(thenable).catch(e=>{console.log(e===thenable)})//true上面代码中，Promise.reject方法的参数是一个thenable对象，执行以后，后面catch方法的参数不是reject抛出的“出错了”这个字符串，而是thenable对象。Promise.try()实际开发中，经常遇到一种情况：不知道或者不想区分，函数f是同步函数还是异步操作，但是想用Promise来处理它。因为这样就可以不管f是否包含异步操作，都用then方法指定下一步流程，用catch方法处理f抛出的错误。一般就会采用下面的写法。Promise.resolve().then(f)上面的写法有一个缺点，就是如果f是同步函数，那么它会在本轮事件循环的末尾执行。constf=()=>console.log('now');Promise.resolve().then(f);console.log('next');//next//now上面代码中，函数f是同步的，但是用Promise包装了以后，就变成异步执行了。那么有没有一种方法，让同步函数同步执行，异步函数异步执行，并且让它们具有统一的API呢？回答是可以的，并且还有两种写法。第一种写法是用async函数来写。constf=()=>console.log('now');(async()=>f())();console.log('next');//now//next上面代码中，第二行是一个立即执行的匿名函数，会立即执行里面的async函数，因此如果f是同步的，就会得到同步的结果；如果f是异步的，就可以用then指定下一步，就像下面的写法。(async()=>f())().then(...)需要注意的是，async()=>f()会吃掉f()抛出的错误。所以，如果想捕获错误，要使用promise.catch方法。(async()=>f())().then(...).catch(...)第二种写法是使用newPromise()。constf=()=>console.log('now');(()=>newPromise(resolve=>resolve(f())))();console.log('next');//now//next上面代码也是使用立即执行的匿名函数，执行newPromise()。这种情况下，同步函数也是同步执行的。鉴于这是一个很常见的需求，所以现在有一个提案，提供Promise.try方法替代上面的写法。constf=()=>console.log('now');Promise.try(f);console.log('next');//now//next事实上，Promise.try存在已久，Promise库Bluebird、Q和when，早就提供了这个方法。由于Promise.try为所有操作提供了统一的处理机制，所以如果想用then方法管理流程，最好都用Promise.try包装一下。这样有许多好处，其中一点就是可以更好地管理异常。functiongetUsername(userId){returndatabase.users.get({id:userId}).then(function(user){returnuser.name;});}上面代码中，database.users.get()返回一个Promise对象，如果抛出异步错误，可以用catch方法捕获，就像下面这样写。database.users.get({id:userId}).then(...).catch(...)但是database.users.get()可能还会抛出同步错误（比如数据库连接错误，具体要看实现方法），这时你就不得不用try...catch去捕获。try{database.users.get({id:userId}).then(...).catch(...)}catch(e){//...}上面这样的写法就很笨拙了，这时就可以统一用promise.catch()捕获所有同步和异步的错误。Promise.try(()=>database.users.get({id:userId})).then(...).catch(...)事实上，Promise.try就是模拟try代码块，就像promise.catch模拟的是catch代码块。Promise.all()Promise.all()方法用于将多个Promise实例，包装成一个新的Promise实例。constp=Promise.all([p1,p2,p3]);上面代码中，Promise.all()方法接受一个数组作为参数，p1、p2、p3都是Promise实例，如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为Promise实例，再进一步处理。另外，Promise.all()方法的参数可以不是数组，但必须具有Iterator接口，且返回的每个成员都是Promise实例。p的状态由p1、p2、p3决定，分成两种情况。（1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。（2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。下面是一个具体的例子。//生成一个Promise对象的数组constpromises=[2,3,5,7,11,13].map(function(id){returngetJSON('/post/'+id+".json");});Promise.all(promises).then(function(posts){//...}).catch(function(reason){//...});上面代码中，promises是包含6个Promise实例的数组，只有这6个实例的状态都变成fulfilled，或者其中有一个变为rejected，才会调用Promise.all方法后面的回调函数。下面是另一个例子。constdatabasePromise=connectDatabase();constbooksPromise=databasePromise.then(findAllBooks);constuserPromise=databasePromise.then(getCurrentUser);Promise.all([booksPromise,userPromise]).then(([books,user])=>pickTopRecommendations(books,user));上面代码中，booksPromise和userPromise是两个异步操作，只有等到它们的结果都返回了，才会触发pickTopRecommendations这个回调函数。注意，如果作为参数的Promise实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。constp1=newPromise((resolve,reject)=>{resolve('hello');}).then(result=>result).catch(e=>e);constp2=newPromise((resolve,reject)=>{thrownewError('报错了');}).then(result=>result).catch(e=>e);Promise.all([p1,p2]).then(result=>console.log(result)).catch(e=>console.log(e));//["hello",Error:报错了]上面代码中，p1会resolved，p2首先会rejected，但是p2有自己的catch方法，该方法返回的是一个新的Promise实例，p2指向的实际上是这个实例。该实例执行完catch方法后，也会变成resolved，导致Promise.all()方法参数里面的两个实例都会resolved，因此会调用then方法指定的回调函数，而不会调用catch方法指定的回调函数。如果p2没有自己的catch方法，就会调用Promise.all()的catch方法。constp1=newPromise((resolve,reject)=>{resolve('hello');}).then(result=>result);constp2=newPromise((resolve,reject)=>{thrownewError('报错了');}).then(result=>result);Promise.all([p1,p2]).then(result=>console.log(result)).catch(e=>console.log(e));//Error:报错了Promise.race()Promise.race()方法同样是将多个Promise实例，包装成一个新的Promise实例。constp=Promise.race([p1,p2,p3]);上面代码中，只要p1、p2、p3之中有一个实例率先改变状态(不管是什么状态)，p的状态就跟着改变。那个率先改变的Promise实例的返回值，就传递给p的回调函数。Promise.race()方法的参数与Promise.all()方法一样，如果不是Promise实例，就会先调用下面讲到的Promise.resolve()方法，将参数转为Promise实例，再进一步处理。下面是一个例子，如果指定时间内没有获得结果，就将Promise的状态变为reject，否则变为resolve。constp=Promise.race([fetch('/resource-that-may-take-a-while'),newPromise(function(resolve,reject){setTimeout(()=>reject(newError('requesttimeout')),5000)})]);p.then(console.log).catch(console.error);上面代码中，如果5秒之内fetch方法无法返回结果，变量p的状态就会变为rejected，从而触发catch方法指定的回调函数。Promise.allSettled()Promise.allSettled()方法接受一组Promise实例作为参数，包装成一个新的Promise实例。只有等到所有这些参数实例都返回结果，不管是fulfilled还是rejected，包装实例才会结束。该方法由ES2020引入。constpromises=[fetch('/api-1'),fetch('/api-2'),fetch('/api-3'),];awaitPromise.allSettled(promises);removeLoadingIndicator();上面代码对服务器发出三个请求，等到三个请求都结束，不管请求成功还是失败，加载的滚动图标就会消失。该方法返回的新的Promise实例，一旦结束，状态总是fulfilled，不会变成rejected。状态变成fulfilled后，Promise的监听函数接收到的参数是一个数组，每个成员对应一个传入Promise.allSettled()的Promise实例。constresolved=Promise.resolve(42);constrejected=Promise.reject(-1);constallSettledPromise=Promise.allSettled([resolved,rejected]);allSettledPromise.then(function(results){console.log(results);});//[//{status:'fulfilled',value:42},//{status:'rejected',reason:-1}//]上面代码中，Promise.allSettled()的返回值allSettledPromise，状态只可能变成fulfilled。它的监听函数接收到的参数是数组results。该数组的每个成员都是一个对象，对应传入Promise.allSettled()的两个Promise实例。每个对象都有status属性，该属性的值只可能是字符串fulfilled或字符串rejected。fulfilled时，对象有value属性，rejected时有reason属性，对应两种状态的返回值。下面是返回值用法的例子。constpromises=[fetch('index.html'),fetch('https://does-not-exist/')];constresults=awaitPromise.allSettled(promises);//过滤出成功的请求constsuccessfulPromises=results.filter(p=>p.status==='fulfilled');//过滤出失败的请求，并输出原因consterrors=results.filter(p=>p.status==='rejected').map(p=>p.reason);有时候，我们不关心异步操作的结果，只关心这些操作有没有结束。这时，Promise.allSettled()方法就很有用。如果没有这个方法，想要确保所有操作都结束，就很麻烦。Promise.all()方法无法做到这一点。consturls=[/*...*/];constrequests=urls.map(x=>fetch(x));try{awaitPromise.all(requests);console.log('所有请求都成功。');}catch{console.log('至少一个请求失败，其他请求可能还没结束。');}上面代码中，Promise.all()无法确定所有请求都结束。想要达到这个目的，写起来很麻烦，有了Promise.allSettled()，这就很容易了。Promise.any()Promise.any()方法接受一组Promise实例作为参数，包装成一个新的Promise实例。只要参数实例有一个变成fulfilled状态，包装实例就会变成fulfilled状态；如果所有参数实例都变成rejected状态，包装实例就会变成rejected状态。该方法目前是一个第三阶段的提案。Promise.any()跟Promise.race()方法很像，只有一点不同，就是不会因为某个Promise变成rejected状态而结束。constpromises=[fetch('/endpoint-a').then(()=>'a'),fetch('/endpoint-b').then(()=>'b'),fetch('/endpoint-c').then(()=>'c'),];try{constfirst=awaitPromise.any(promises);console.log(first);}catch(error){console.log(error);}上面代码中，Promise.any()方法的参数数组包含三个Promise操作。其中只要有一个变成fulfilled，Promise.any()返回的Promise对象就变成fulfilled。如果所有三个操作都变成rejected，那么await命令就会抛出错误。Promise.any()抛出的错误，不是一个一般的错误，而是一个AggregateError实例。它相当于一个数组，每个成员对应一个被rejected的操作所抛出的错误。下面是AggregateError的实现示例。newAggregateError()extendsArray->AggregateErrorconsterr=newAggregateError();err.push(newError("firsterror"));err.push(newError("seconderror"));throwerr;捕捉错误时，如果不用try...catch结构和await命令，可以像下面这样写。Promise.any(promises).then((first)=>{//Anyofthepromiseswasfulfilled.},(error)=>{//Allofthepromiseswererejected.});下面是一个例子。varresolved=Promise.resolve(42);varrejected=Promise.reject(-1);varalsoRejected=Promise.reject(Infinity);Promise.any([resolved,rejected,alsoRejected]).then(function(result){console.log(result);//42});Promise.any([rejected,alsoRejected]).catch(function(results){console.log(results);//[-1,Infinity]});]]>JShttps://www.beilika.com/article/c160.htmlFri, 14 Nov 2025 09:45:26 +0800