微任务是如何进入微任务队列的？
微任务是通过以下几种方式进入微任务队列的：
- Promise的resolve和reject方法：当Promise对象的状态变为resolved或rejected时，相关的回调函数会被放入微任务队列中执行。
- MutationObserver：当DOM发生变化时，MutationObserver会将相关的回调函数放入微任务队列中。
- process.nextTick（Node.js环境）：在Node.js环境中，process.nextTick方法会将回调函数放入微任务队列中，以便在当前操作完成后立即执行。
- Object.observe（已废弃）：在旧版的JavaScript中，Object.observe方法可以用于监听对象的变化，并将相关的回调函数放入微任务队列中。
需要注意的是，微任务队列的执行时机是在当前任务执行完毕、事件循环的下一个阶段（称为微任务阶段）开始时。在微任务阶段，事件循环会依次执行微任务队列中的所有任务，直到队列为空为止。
对于微任务的使用场景，它通常用于需要在当前任务执行完毕后立即执行的情况，比如需要更新DOM、执行一些异步操作等。微任务的优势在于它的执行时机比宏任务更早，能够更快地响应用户操作，提升用户体验。
腾讯云相关产品中，与微任务相关的是云函数（Serverless Cloud Function）和消息队列（Message Queue）。云函数是一种无需管理服务器即可运行代码的计算服务，可以用于处理微任务队列中的任务。消息队列则提供了可靠的消息传递机制，可以用于在不同的服务之间传递微任务。
腾讯云云函数产品介绍链接：https://cloud.tencent.com/product/scf 腾讯云消息队列产品介绍链接：https://cloud.tencent.com/product/cmqueue
相关·内容
1回答
在下面的代码中，‘嘿嘿，超时执行！’只在longLoop函数中的循环完成后才打印出来。
setTimeout(() => console.log('Hey, timeout executed!'), 100);
let longLoop = async () => {
for (i = 0; i < 1000000000; i++) {
}
}
let exec = async () => {
await longLoop();
console.log('Loop finished')
}
exe
浏览 4提问于2022-05-13得票数 2
我是JS的初学者，在阅读Event Loop and Promises时，我在mdn上看到了下面的例子。
const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
wait().then(() => console.log(4));
Promise.resolve().then(() => console.log(2)).then(() => console.log(3));
console.log(1); // 1, 2, 3, 4
O/P不是应该是1,4,2,3吗
根据我的理解，这
浏览 2提问于2021-01-17得票数 0
回答已采纳
2回答
与macrotask和microtask队列的这种描述相混淆。
对于“事件循环”的每个循环，将从宏任务队列中完成一个宏任务。该宏任务完成后，事件循环将访问microtask队列。在继续之前，将完成整个微任务队列。
setTimeout(function() {
console.log('macrotask');
}, 0);
Promise.resolve().then(function() {
console.log('microtask 1');
}).then(function() {
console.log('micro
浏览 3提问于2019-03-16得票数 0
1回答
我读了很多关于承诺的文章。我知道承诺执行是任务队列的微任务，异步代码执行是任务队列的任务。在保证异步代码工作后同步代码(即在一些获取之后，我们可以在.then块中编写同步代码)，这种情况是如何发生的？我猜想承诺中的所有代码都使用调用堆栈(如果在允诺体内同步代码)或任务队列(如果承诺体内有异步代码)。我看到了许多使用setTimeout代码的调用堆栈、Web和任务队列的示例，但是它如何与我只能承担的承诺一起工作。请在我的示例中显示调用堆栈、Web和任务队列发生了什么吗？
第一个示例：
const promiseWithAsyncBody = new Promise(resolve=>
s
浏览 1提问于2020-06-13得票数 2
这个问题在这里已经有答案了： Promise vs setTimeout](/questions/38752620/promise-vs-settimeout) [(6个答案) Promise [事件循环和Promise [duplicate]](/questions/46375711/what-is-the-relationship-between-event-loop-and-promise)之间的关系是什么 (2个答案) 3天前就关门了。 在以下代码中： setTimeout(() => console.log("hello"), 0);
Promise.r
浏览 46提问于2021-02-26得票数 11
回答已采纳
5回答
我在JS中测试异步代码的概念。被回调队列和微任务队列顺序搞混了。每当承诺对象被解析时，实现方法{ is }被推入微任务队列，而浏览器计时器函数(如setTimeout )的回调被推入回调队列。事件循环不断检查队列，并在调用堆栈为空时将函数从队列推入调用堆栈。事件循环应该更喜欢微任务队列而不是普通的回调队列，但是在示例中：，否则就会发生。
function display(data) {
console.log('hi back from fetch');
}
function printHello() {
console.log('hello'
浏览 0提问于2018-06-08得票数 1
回答已采纳
我在CodeSmith YouTube频道看了一段“承诺”视频，老师说，.then接受回调函数，并将该cb函数推入隐藏的onFulfillment数组中，该数组将在承诺被解析后触发，第一个参数是其解析后的值！
现在，我认为细节有点不完整，因为后来我发现，.then不仅将cb函数推入隐藏的onFulfilment数组中以供以后执行，而且它还会立即返回一个挂起的承诺，然后当该cb函数运行并返回任何值时，这就是.then返回的挂起的承诺所解析的值！
我还注意到，如果承诺立即得到解决，那么cb函数将直接放入微任务队列中！
现在我的问题是，假设我有这样的代码：
let p = new Promise(r
浏览 2提问于2021-05-30得票数 0
在中，文档告诉我们，如果你想在渲染完成后做一些事情(例如，获取元素的新的宽度和高度)，你应该在Vue.nextTick(callback)的回调中进行。但有几次我发现它不能工作(我不知道其他人是否有时也发现它不能工作)，必须求助于setTimeout来修复它。
我怀疑nextTick如何确保渲染完全完成。我阅读了源代码，发现它可能使用Promise.then、setImmediate或setTimeout(cb, 0)在nextTick上运行您的代码。我认为dom渲染可以在事件循环的节拍之间的任何时间发生。因此，nextTick使用的所有内部方法都不能确保完成新的渲染工作。
注意:我不是在讨论
浏览 0提问于2018-07-12得票数 3
4回答
我刚刚读完了承诺/A+规范，无意中发现了微任务和宏任务的术语:参见
我以前从未听说过这些术语，现在我想知道这两者有什么区别？
我已经尝试在网络上找到一些信息，但我发现的只有w3.org档案中的这篇文章(这并没有向我解释这种区别)：
此外，我还发现了一个名为“宏任务”的npm模块：，它没有明确区别到底是什么。
我所知道的是，它与事件循环有关，如和所述。
考虑到WHATWG规范，我知道理论上我应该能够自己提取差异。但我相信其他人也可以从专家的简短解释中获益。
浏览 7提问于2014-09-18得票数 239
回答已采纳
3回答
我对JS中如何调度异步任务的理解 如果我说错了什么，请纠正我： JS运行时引擎代理由一个事件循环驱动，该循环收集任何用户和其他事件，将任务排入队列以处理每个回调。 事件循环持续运行，并具有以下思维过程： 是执行上下文堆栈(通常称为调用堆栈)为空？ 如果是，则将微任务队列(或作业队列)中的任何微任务插入到调用堆栈中。继续执行此操作，直到微任务队列为空。 如果微任务队列为空，则将任务队列(或回调队列)中最旧的任务插入到调用堆栈中 所以这里有两个关键的区别b/w如何处理任务和微任务： 微任务(例如承诺使用微任务队列运行其回调)优先于任务(例如，来自其他web API的回调，如setTimeout)
浏览 52提问于2021-02-14得票数 9
回答已采纳
3回答
我正在研究JS中的异步行为，它在很大程度上进行得很好。我了解执行代码的同步方式、JS的单个线程以及回调(如setTimeout内部的回调)将如何由Web来计时，以及稍后如何添加到任务队列中。
事件循环将不断检查调用堆栈，只有当调用堆栈为空(所有同步代码都已执行)时，它才会接受任务队列中排队的函数。将它们推回调用堆栈，然后执行它们。
这是非常直截了当的，也是为什么下面的代码：
console.log('start');
setTimeout(() => console.log('timeout'), 0);
console.log('end'
浏览 3提问于2020-08-05得票数 3
回答已采纳
当我跑的时候
process.nextTick(() => console.log(8))
Promise.resolve("hi").then(t => console.log(t))
console.log(7);
Output is 7 8 hi
输出是预期的，因为process.nextTick在堆栈为空之后、在我们开始处理任务队列之前运行。但是当我跑的时候
function main() {
console.log(1);
console.log(2);
func();
console.lo
浏览 9提问于2021-06-20得票数 1
2回答
消息队列和宏任务队列有什么区别？是同一回事吗？
在Nodejs文档上，它说：
当调用setTimeout()时，浏览器或Node.js启动计时器。一旦计时器过期，在这种情况下，就像我们将0作为超时一样，回调函数将被放入消息队列中。
然而，在部分，它说：
将setTimeout，setImmediate回调添加到宏任务队列中。
那么，消息队列和宏任务队列是一回事吗？
浏览 6提问于2022-06-16得票数 3
回答已采纳
我知道事件循环以及它是如何工作的。最近，为了更好地理解promises，我阅读了一些内容，并了解到ECS6和较低规范之间的一个区别就是它。javascript引擎现在对如何在事件循环队列上调度任务有影响。现在有了job queue的新概念，据说它存在于事件循环迭代的末尾。谁能给我解释清楚job queue是什么，它是如何运行的，以及它如何帮助调度事件循环队列上的任务。我似乎没有从任何地方得到一个清晰的解释。
浏览 6提问于2017-08-11得票数 1
回答已采纳
2回答
在Dart文档中，它提到将任何Future添加到Event队列中。
它还提到，Microtask队列总是首先运行，然后是Event队列。
这个文档是旧的，并且似乎是面向web开发的，所以我不确定这是否和我编写这段代码时的情况不同。
Future<String> myFunction() => new Future.value('Hello');
Future<String> myFunction2() => new Future.value('Hello2');
Future<void> mainTest() as
浏览 1提问于2019-01-14得票数 10
回答已采纳
2回答
我知道，MutationObservers回调可能在DOM更改后的某个时候被调用。但问题是:这些回调的时间是什么时候？回调是否进入浏览器的事件队列？如果是，他们什么时候进入队列？
是回调：
在DOM变异发生后立即调用，
在操作DOM的函数完成后调用，
调用堆栈为空时立即调用，
在DOM变异发生后立即排队，
在操作DOM的函数完成后立即排队，或
在别的时间吗？
例如，如果执行以下代码(使用)：
var target = document.body;
new MutationObserver(function(mutations) {
console.log(
浏览 10提问于2013-01-28得票数 45
回答已采纳
1回答
从我对javascript虚拟机工作方式的全球理解中，我可以清楚地看到，微任务/宏任务的概念发挥了很大的作用。
以下是我对此的理解：
VM‘转向’是将一个宏任务从VM宏任务队列中取出并执行的事实。
在VM转时，可以将微任务添加到当前宏任务的微任务队列中。
微任务可以将其他微任务推送到当前宏任务的微任务队列中。
当微任务队列为空时，VM循环将结束。
我的问题是：
为什么没有明确的API来操作这两个队列.
有点像
pushToMacroTask( function )
pushToMicroTask( function )
实际上，操纵这些队列的唯一方法
浏览 7提问于2016-12-10得票数 6
回答已采纳
我搞不懂哪个任务是先由事件循环来完成的。
原因如下。
堆栈溢出来自 的答案
在这个宏任务完成后，所有可用的微任务都将被处理。
类似的例子来自 博客文章
setTimeout(() => console.log('Macro task'), 0);
Promise.resolve().then(() => console.log('Micro task'));
所以，这让我很困惑。我现在所理解的就是这个。
非回调函数的代码将立即插入到调用堆栈中。
将setTimeout()的回调函数插入到宏任务队列中。
将Promise的
浏览 3提问于2020-02-27得票数 1
使用本地Javascript承诺：
Promise.resolve(1).then(it => console.log(it))
console.log(2)
这是记录的：
2
1
问：2如何能够在1之前执行？JS是事件驱动的，当原始调用者已经离开该执行树时，执行给then的回调的事件是什么？引擎在这里做了什么幕后魔术吗？
浏览 0提问于2021-03-21得票数 2
回答已采纳
这里我写了3个console.log()。请帮助我，为什么在setTimeout之前执行Promise，即使它有0秒的延迟。据我所知，setTimeout和Promise都是在webAPI中执行的，而不是在JavaScript引擎中。这件事跟priorty有关系吗？
setTimeout(()=>console.log("SET TIME OUT"),0); // #1
var promise = new Promise((resolve,reject)=>{
resolve()
})
promise
.then(()=>console.l
浏览 1提问于2020-04-02得票数 1
以下代码：
let promise = new Promise(function(resolve, reject) {
console.log("resolve, reject are", resolve, reject);
resolve("this is the success data");
console.log("Point A");
setTimeout(function() { console.log("Point B"); }, 0);
});
promise.then(
浏览 2提问于2019-12-25得票数 2
我使用上下文API并使用钩子来响应函数组件。我有一个功能组件ProfileForm.js
在这个文件的顶部，我调用useContext，以便能够访问当前状态(配置文件对象数组)。
const {state: {userProfiles}, addProfile, removeProfile, editProfile} = useContext(UserProfilesContext);
在本例中，我将重点介绍函数addProfile。当用户单击submit按钮时，我希望将新配置文件添加到全局状态/上下文中，并希望将更新后的列表保存到AsyncStorage中。
这是我的处理程序：
const
浏览 3提问于2021-03-15得票数 1
回答已采纳
1回答
我使用类型记录，因此使用libuv来执行任何IO操作。在我的特定场景中，我将获取给定文件的指纹散列。为了在此说明我的问题，请考虑输入文件是1TB的文件。为了获得文件的指纹，我可以通过文件流打开文件并更新散列：
return new Promise((resolve, reject) => {
const hash = crypto.createHash('sha256');
const fh = fse.createReadStream(filepath, {
highWaterMark : 100000000
});
f
浏览 1提问于2021-01-21得票数 4
我预计这段代码会运行，然后在2秒后，执行堆栈将变成空的，并且有一个setTimeout回调。我期待这一点，因为我期望消息队列和作业队列为空(因为promise尚未解析)。 因此，首先打印Callback，然后在3秒后解析promise，将其回调放入作业队列，并打印消息Promise is resolved。但事实并非如此。那么我在这里错过了什么呢？ 代码是： setTimeout(function() {
console.log("Callbcack");
}, 0);
new Promise((resolve, reject) => {
conso
浏览 44提问于2020-09-29得票数 3
hasPendingMacrotasks和hasPendingMicrotasks在NgZone中有什么区别？这些文件似乎缺乏信息。我只知道他们会返回一个布尔值。但他们到底在查什么？什么是微任务？什么是宏任务？
class NgZone {
static isInAngularZone() : boolean
static assertInAngularZone() : void
static assertNotInAngularZone() : void
constructor({enableLongStackTrace = false}: any)
run(fn: ()
浏览 0提问于2017-04-18得票数 13
回答已采纳
1回答
以下引号是理解微任务队列处理的主要引用：
当JS堆栈清空.时处理微任务(承诺使用)。
对我毫无意思。
事件循环的一个循环将从宏任务队列中处理一个任务(这个队列在WHATWG规范中被简单地称为任务队列)。在这个宏任务完成后，所有可用的微任务都将被处理，即在相同的执行周期内.。
现在，关于以下代码段中的第9行(**)：
从执行这个代码片段w/调试器开始，在处理/执行这些.then( callback )微任务时，执行堆栈不会显示为空。
像f2()这样的常规函数是否被认为是一项任务(也称为宏任务)？(当它返回时，它是一个事件循环nextTick()，微任务队列被处
浏览 0提问于2019-07-02得票数 13
2回答
我知道有消息队列，而且JavaScript是单线程的。还有一个事件循环，从队列中获取消息并做一些工作。
当您创建一个承诺，并且该承诺被保留在消息队列中时，循环何时或如何知道何时解析(或拒绝)。它是永久地问，是状态不是“待定”，还是承诺本身在消息队列被解析或拒绝时排队？
更新：
经过一番调查，我想我搞错了。实际上在自己的线程中阻塞和运行的不是承诺本身，而是XHR请求，而不是阻止主执行线程。因此，只有主执行线程是单线程的，当XHR请求得到结果(或失败)时，XHR线程将将回调排队到主线程。
因此，对应于，承诺本身是否被保存在堆栈中，并在它解决后将回调函数推到队列中？
浏览 3提问于2017-05-08得票数 4
回答已采纳
在我的node.js文件中有一个名为parsedata的函数，当用户登录时调用它。在调用parsedata()之后，服务器切换到一个新屏幕。然而，这只在每隔一次起作用。我在中间放置了一个异步等待，这使得它在90%的时间内工作，但我只是想知道它为什么要这样做。我相信这与所有正在使用的助手函数有关，但我不完全确定。任何信息或帮助将不胜感激！
app.post("/login.html", urlencodedParser, async (req, res) => {
await parseData();
//await sleep(750);
res.redi
浏览 8提问于2022-06-28得票数 1
回答已采纳
当运行下面的代码片段时，它会输出2,1。由于承诺是一个微任务，并且在宏任务(setTimeout)之前，承诺中的所有内容都应该运行，所以我希望输出将是1,2。因此，即使在一个微任务中有一个宏任务，我也认为输出将是1,2。
但是它输出2,1。
这里的陷阱是什么？为什么它输出2,1而不是1,2
Promise.resolve().then(() => {
setTimeout(() =>{
console.log("1")
}, 0)
})
setTimeout(() => {
console.log("2")
}, 0
浏览 3提问于2022-07-01得票数 0
回答已采纳
1回答
我的理解是，整个微任务队列是在每个宏任务之后处理的。
如果是这样的话，为什么在下面的setTimeout片段中的Promise微任务之后执行JavaScript回调？
console.log('start');
setTimeout(() => {
console.log("setTimeout");
});
Promise.resolve().then(function() {
console.log('promise');
});
console.log('end');
这将产生以下结果：
>
浏览 0提问于2018-08-25得票数 1
回答已采纳
1回答
我想运行一个函数，即'callbackfn‘，在执行setTimeout函数之后，在全局执行上下文中运行它，然后只有在执行callbackfn中的代码时，setTimeout函数才会运行，因为它将在回调队列中运行，直到全局执行上下文中的行处于搁置状态。
但是我想要的是在是executed.For之后执行setTimeout回调can ，我必须将回调can推到回调queue.So中，我们如何显式地将它推到回调队列中。
浏览 3提问于2021-10-19得票数 0
从的文档中可以看出：
* Creates a future containing the result of calling [computation]
* asynchronously with [scheduleMicrotask].
的文档声明：
* Creates a future containing the result of calling [computation]
* asynchronously with [Timer.run].
我想知道，它们对编码有什么样的影响，我们什么时候应该使用这种或那种？
浏览 7提问于2020-07-24得票数 24
回答已采纳
我刚接触JavaScript，想知道"JS“是如何处理异步操作的。我开始知道它是在“事件循环”和“事件队列”的帮助下实现的，但我不知道有什么不同。谁能帮帮我。
asynchronous operations的一个示例可以是：
function alpha(){
setTimeout(() => alert("hi"), 3000);
};
alpha();
浏览 2提问于2020-10-01得票数 0
2回答
为什么事件循环优先考虑卡通的setTimeouts，而不是，然后是 setTimeout？我所知道的是，事件循环应该优先处理诸如承诺之类的微任务，然后执行消息队列(卡通的setTimeouts)。
const tom = () => console.log('Tom');
const jerry = () => console.log('Jerry');
const doggy = () => console.log('Doggy');
const cartoon = () => {
console.log(&
浏览 3提问于2021-06-15得票数 1
我正在阅读解释事件循环和执行时间的。其中提到，事件循环可以选择多个任务队列来执行任务。我的主要问题是浏览器什么时候决定创建一个新的队列?我试着观察到这种情况发生了，但到目前为止还没有。
与在这个主题上的对比，没有提到多个队列，所以我要么误解了什么，要么这两篇文章中的一篇是不正确的。
浏览 5提问于2017-07-28得票数 0
我当时正在浏览html5boilerplate github，我去看了一些面试问题，我遇到了这个问题，我不明白为什么它会按照它的顺序输出。我以为是一四二三，而不是它的输出。谁能解释一下原因吗？如果太简单的话很抱歉。
问题:下面的代码打印什么？
console.log('one');
setTimeout(function() {
console.log('two');
}, 0);
Promise.resolve().then(function() {
console.log('three');
})
console.log('f
浏览 0提问于2018-08-07得票数 9
回答已采纳
我正在尝试使用FakeAsync编写一个测试，但它似乎挂在我的await上。
test('danny', () async {
await FakeAsync().run((FakeAsync async) async {
print('1');
final a = Future<bool>.delayed(const Duration(seconds: 5))
.then((_) => print('Delayed future completed!'))
浏览 4提问于2020-06-30得票数 12
回答已采纳
1回答
我有3个菜单名为主菜单，微站点菜单，超级导航菜单。我正在创建一个视图页面，并希望包括微站点菜单。但是视图页面采用的是默认的主菜单，如何删除主菜单并嵌入微站点菜单。我看不到任何选项，比如在视图页面设置中选择可用菜单。我怎样才能做到这一点？
是否有任何选项可以使用php嵌入微站点菜单？
浏览 3提问于2014-06-19得票数 1
回答已采纳
我是在看完后跟进的
张贴的例子如下
macrotasks: setTimeout, setInterval, setImmediate, requestAnimationFrame, I/O, UI rendering
microtasks: process.nextTick, Promises, Object.observe, MutationObserver
我想知道在哪里可以找到官方文档中添加到微任务队列中的任务列表
谢谢
浏览 0提问于2020-01-21得票数 2
我正在写一些代码，用户会点击一个按钮，然后计算下一次本地可见日食的时间。
这可能是一个非常耗时的计算。所以我用两个嵌套的异步函数编写了计算代码，将所有的计算分解成几个小块，允许执行频繁，这样用户的web浏览器就不会在计算过程中锁定。
这里有一个关于时间问题的非常简化的测试案例，没有天文学的复杂性
window.CP.PenTimer.MAX_TIME_IN_LOOP_WO_EXIT = 15000;
async function workWorkWork(msg) {
return new Promise(async (resolve) => {
const start =
浏览 5提问于2022-10-26得票数 3
回答已采纳
1回答
与以下JS优先级混淆
、、、、
在面试中，我得到了这些问题，因为我代码混淆了。
哪一个有更高优先级的回调或承诺？
setInterval也是像setTimeOut这样的宏任务吗？
浏览 1提问于2020-05-05得票数 0
1回答
我一直在学习承诺，等待和异步功能。当我正处于学习承诺的阶段时，我偶然发现了这一点：
async function async1(){
console.log('Async 1');
await async2(); // *
console.log('AFter Async 1');
}
async function async2(){
console.log('FROM async 2');
}
async1();
console.log('Synchronous'); //**
其结果是：
Asy
浏览 6提问于2022-08-13得票数 7
回答已采纳
2回答
我有两个函数，一个函数，asyncTest_returnPromise只返回一个诺言，另一个函数，asyncTest，通过调用承诺数组中的Promise.all(承诺)调用3次。在数组中的每个承诺中，在调用asyncTest_returnPromise函数之前，我向控制台发送一个值("Foo")，并在调用后将另一个值("Bar")发送到控制台。
考虑到我对Promise.all函数的理解，我希望数组中的每个承诺只有在实现了随后的承诺之后才会被处理，这意味着由于两个console.log语句都在数组中的每个承诺中，结果将是：
相反，输出似乎是: Foo Bar B
浏览 3提问于2020-01-27得票数 0
回答已采纳
1回答
我的特快代码：
app.use('/test', async (req, res, next) => {
try {
setTimeout(() => console.log('setTimeout')); // setTimeout (macrotask)
User.findOne().then(user => console.log('user')); // promise (microtask)
console.log('console.log');
} catch (err
浏览 3提问于2021-02-05得票数 0
回答已采纳
请参阅代码 <script>
console.log('first script')
setTimeout(() => {
console.log('settimout');
}, 0);
</script>
<script>
console.log('second script')
</script> 输出为 first script
second script
settimout 我的理解是一个宏观，然后是所有可用的微观。然后是第二个宏。 因此，当js看到
浏览 14提问于2021-08-11得票数 0
回答已采纳
我试图理解fetch()的执行流程，但这与我的实验不一致。
我找到了这个答案
fetch方法确实会立即启动一个网络请求，该请求将被“并行”处理，即在事件循环之外。当收到请求响应时(而不是它的主体，通常是标头)，浏览器将排队一个新任务，它只负责解决这个承诺，从而排队处理它的微任务。
实验
我理解它，除了任务/微任务队列位。这就是我试过的实验：
function delay() {
i=0;
while(i<1000000000) i++;
}
console.log('start');
setTimeout(()=> {
浏览 13提问于2022-09-02得票数 1
1回答
我想启动一个HttpRequest，然后为它的完成进行投票。这似乎是一个相当普遍的模式。
void main() {
_tick(0);
_tickB(0);
build();
print("End of main");
}
void build() {
var path = '../layout.txt';
html.HttpRequest.getString(path).then((String layout) {
print("layout received");
});
}
void _tick(i
浏览 3提问于2022-06-21得票数 1
回答已采纳
2回答
代码片段：
console.log('out1');
setTimeout(() => console.log('out2'), 0);
Promise.resolve('out3').then(console.log);
console.log('out4');
执行后，我将得到以下内容：
"out1"
"out4"
"out3"
"out2"
根据我的理解，由于第2行和第3行都是异步的，所以应该首先打印out2，因为它首先被放入队列中。但在这里它似乎是相反的
浏览 2提问于2021-07-07得票数 0
Promise
.resolve()
.then(() => console.log(1))
.then(() => console.log(2))
.then(() => console.log(3));
Promise
.resolve()
.then(() => console.log(4))
.then(() => console.log(5))
.then(() => console.log(6));
答：1 4 2 5 3 6
有人能解释一下它是怎么工作的吗？
为什么不执行1,2,3,4,5,6？
浏览 1提问于2020-04-25得票数 1
回答已采纳
我们知道承诺是微任务，它们被添加到微任务队列中，事件监听器/定时器是任务，所以它们被添加到任务队列中。但是，如果事件侦听器/定时器在允诺函数中(这个函数是在承诺构造函数的创建过程中传递的)，那么事件侦听器/定时器怎么办？它们被添加到哪个队列中？
console.log("script start");
var promise = new Promise(function (resolve, reject) {
setTimeout(function () {
console.log("setTimeout2");
resolve();
}, 0
浏览 6提问于2020-06-18得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
