了解javascript中的事件队列和调用堆栈 [英] Understanding Event Queue and Call stack in javascript

查看：102
本文介绍了了解javascript中的事件队列和调用堆栈的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我对理解事件队列和调用堆栈概念的好奇心在我解决这个问题时开始：

My curiosity for understanding the concept of "Event Queue" and "Call Stack" Started when I was solving this question:

var list = readHugeList();

var nextListItem = function() {
    var item = list.pop();

    if (item) {
        // process the list item...
        nextListItem();
    }
};

如果数组列表太大，以下递归代码将导致堆栈溢出。你如何解决这个问题仍然保留递归模式？

提到的解决方案是：

var list = readHugeList();

var nextListItem = function() {
    var item = list.pop();

    if (item) {
        // process the list item...
        setTimeout( nextListItem, 0);
    }
};

解决方案：


由于事件循环处理
递归而不是调用堆栈，因此消除了堆栈溢出。当nextListItem运行时，如果item不是
null，则将超时函数（nextListItem）推送到事件队列
并退出该函数，从而使调用堆栈保持清零。当
事件队列运行其超时事件时，处理下一个项目并设置
计时器以再次调用nextListItem。因此，该方法是从开始到结束处理的
而没有直接递归调用，因此无论迭代次数如何，
调用堆栈都保持清晰。

The stack overflow is eliminated because the event loop handles the recursion, not the call stack. When nextListItem runs, if item is not null, the timeout function (nextListItem) is pushed to the event queue and the function exits, thereby leaving the call stack clear. When the event queue runs its timed-out event, the next item is processed and a timer is set to again invoke nextListItem. Accordingly, the method is processed from start to finish without a direct recursive call, so the call stack remains clear, regardless of the number of iterations.

现在我的问题：

Q1）事件队列和事件队列之间有什么区别调用堆栈

Q1) What is the difference between "Event Queue" and "call stack"

Q2）我不明白答案。有人可以详细解释我吗？

Q2) I did not understand the answer. Can someone explain me in detail?

Q3）当我在javascript中执行函数或调用变量或对象时。流程如何？ 调用堆栈的内容是什么？（假设我执行setTimeout ..它是去callstack还是事件队列？）

Q3) When I execute a function or call a variable or object in javascript. How does the flow go? What goes in call stack? (Let's say I do setTimeout.. Does it go to callstack or event queue?)

这些概念非常不清楚。我用谷歌搜索，但大部分结果都不是我期望理解的。

These concepts are very unclear. I googled but most of the results aren't what I was expecting to understand.

请帮忙！

推荐答案

答案1& 3



事件队列和调用堆栈之间存在很大差异。事实上，它们几乎没有任何共同之处。

Answer 1 & 3

There is a very big difference between event queue and call stack. In fact, they have almost nothing in common.

当你执行一个函数时，它所使用的一切都被称为在堆栈，这是你所指的那个调用堆栈。非常简化，它是功能执行的临​​时内存。或换句话说

When you execute a function everything it uses is said to go on the stack, which is the same call stack you're referring to there. Very simplified, it's temporary memory for functional execution. Or in other words

function foo() {
  console.log("-> start [foo]");
  console.log("<- end   [foo]");
}

foo();

当被调用时，它会被赋予一个小沙箱来与堆栈中的一起玩。当函数结束时，使用的临时内存将被擦除并可用于其他内容。因此，所使用的资源（除非在系统的某个地方给出）只会持续该函数持续的时间。

when called it would be given a little sandbox to play with on the stack. When the function ends, the temporary memory used would be wiped and made available to other things. So, the resources used (unless given somewhere to the system) will only last as long as the function lasts.

现在，如果你有嵌套函数

Now, if you have nested functions

function foo() {
  console.log("-> start [foo]");
  console.log("<- end   [foo]");
}

function bar() {
  console.log("-> start [bar]");
  foo()
  console.log("<- end   [bar]");
}

bar();

以下是您致电该函数时的情况：

Here is what happens when you call the function:


  1. bar 被执行 - 内存在堆栈上分配给它。

  2. bar 打印start

  3. foo 执行 - 为堆栈分配内存。 NB！ bar 仍在运行，其内存也在那里。

  4. foo 打印开始

  5. foo 打印结束

  6. foo 完成执行并从堆栈中清除其内存。

  7. bar 打印结束

  8. bar 完成执行并从堆栈中清除其内存。

  1. bar gets executed - memory is allocated on the stack for it.
  2. bar prints "start"
  3. foo gets executed - memory is allocated on the stack for it. NB! bar is still running and its memory is also there.
  4. foo prints "start"
  5. foo prints "end"
  6. foo finishes execution and its memory is cleared from the stack.
  7. bar prints "end"
  8. bar finishes execution and its memory is cleared from the stack.

因此，执行顺序是 bar - > foo 但是分辨率是最后的，先退出订单（LIFO） foo 完成 - > bar 完成。

So, the execution order is bar -> foo but the resolution is in last in, first out order (LIFO) foo finishes -> bar finishes.

这就是它成为堆栈的原因。

And this is what makes it a "stack".

这里要注意的重要一点是使用的资源函数只有在完成执行时才会被释放。当它内部的所有函数和它们内部的函数完成执行时，它完成执行。所以你可以有一个非常深的调用堆栈，如 a - > b - > c - > d - > e 以及是否有任何大型资源以<$ c $持有c> a 您需要 b 到 e 才能在发布之前完成。

The important thing to note here is that the resources used by a function will only be released when it finishes executing. And it finishes execution when all the functions inside it and those inside them finish executing. So you could have a very deep call stack like a -> b -> c -> d -> e and if any large resources are held in a you would need b to e to finish before they are released.

在递归中，一个函数调用自身，它仍然在堆栈上创建条目。所以，如果 a 一直在调用自己，你最终会得到一个的调用堆栈 - > a - > a - > a 等。

In recursion a function calls itself which still makes entries on the stack. So, if a keeps calling itself you end up with a call stack of a -> a -> a -> a etc.

这是一个非常简短的插图

Here is a very brief illustration

// a very naive recursive count down function
function recursiveCountDown(count) {
  //show that we started
  console.log("-> start recursiveCountDown [" + count + "]");
  
  if (count !== 0) {//exit condition
    //take one off the count and recursively call again
    recursiveCountDown(count -1);
    console.log("<- end recursiveCountDown [" + count + "]"); // show where we stopped. This will terminate this stack but only after the line above finished executing;
  } else {
    console.log("<<<- it's the final recursiveCountDown! [" + count + "]"); // show where we stopped
  }
}

console.log("--shallow call stack--")
recursiveCountDown(2);

console.log("--deep call stack--")
recursiveCountDown(10);

这是一个非常简单且非常有缺陷的递归函数，但它只用于演示什么在这种情况下发生。

This is a very simplistic and very flawed recursive function but it only serves to demonstrate what happens in that case.

JavaScript在事件队列中运行（或者也是事件循环 ），简单来说，等待活动（事件），处理它们然后再等待。

JavaScript is ran in an event queue (or also "event loop") which, in simple terms, waits for "activity" (events), processes them and then waits again.

如果有多个事件，它将按顺序处理它们 - 先进先出（FIFO），因此成为一个队列。所以，如果我们重新编写上述函数：

If there are multiple events, it would process them in order - first in, first out (FIFO), hence a queue. So, if we re-write the above functions:

function foo() {
  console.log("-> start [foo]");
  console.log("<- end   [foo]");
}

function bar() {
  console.log("-> start [bar]");
  console.log("<- end   [bar]");
}


function baz() {
  console.log("-> start [baz]");
  
  setTimeout(foo, 0);
  setTimeout(bar, 0);
  
  console.log("<- end   [baz]");
}

baz();

这是如何发挥作用的。

Here is how this plays out.


  1. baz 已执行。在堆栈上分配的内存。

  2. foo 因计划运行下一步而延迟。

  3. bar 因计划运行下一步而延迟。

  4. baz 完成。堆栈已清除。

  5. 事件循环选择队列中的下一项 - 这是 foo 。

  6. foo 被执行。在堆栈上分配的内存。

  7. foo 完成。堆栈被清除。

  8. 事件循环选择队列中的下一个项目 - 这是 bar 。

  9. bar 被执行。在堆栈上分配的内存。

  10. bar 完成。堆栈已清除。

  1. baz is executed. Memory allocated on the stack.
  2. foo is delayed by scheduling it to run "next".
  3. bar is delayed by scheduling it to run "next".
  4. baz finishes. Stack is cleared.
  5. Event loop picks the next item on the queue - this is foo.
  6. foo gets executed. Memory allocated on the stack.
  7. foo finishes. Stack is cleared.
  8. Event loop picks the next item on the queue - this is bar.
  9. bar gets executed. Memory allocated on the stack.
  10. bar finishes. Stack is cleared.

正如您所希望的那样，堆栈仍在使用中。您调用的任何函数将始终生成堆栈条目。事件队列是一个单独的机制。

As you can hopefully see, the stack is still in play. Any function you call will always generate a stack entry. The event queue is a separate mechanism.

使用这种方式，你可以获得更少的内存开销，因为你不需要在任何其他函数上释放分配资源。另一方面，你不能依赖任何完成的功能。

With this way of doing things, you get less memory overhead, since you do not have to way on any other function to release the allocated resources. On the other hand, you cannot rely on any function being complete.

我希望这部分也能回答你的Q3。

I hope this section also answers your Q3.

如何推迟到队列帮助？

我希望上面的解释能够做到它更清楚，但它确保解释有意义：

I hope the above explanation will make it more clear but it bears making sure the explanation makes sense:

堆栈的深度有一个设定的限制。如果你考虑一下，它应该是显而易见的 - 只有大量的内存可以用来推测临时存储。一旦达到最大调用深度，JavaScript将抛出 RangeError：超出最大调用堆栈大小错误。

There is a set limit of how deep the stack could be. If you think about it, it should be obvious - there is only so much memory to spare for presumably temporary storage. Once the maximum call depth is reached, JavaScript will throw RangeError: Maximum call stack size exceeded error.

如果你看看上面给出的 recursiveCountDown 示例，很容易导致错误 - 如果你调用 recursiveCountDown（100000）你将得到 RangeError 。

If you look at the recursiveCountDown example I gave above that can very easily be made to cause an error - if you call recursiveCountDown(100000) you will get the RangeError.

通过将所有其他执行放在队列中，你可以避免填写堆栈，因此你避免 RangeError 。所以让我们重新编写函数

By putting every other execution on the queue, you avoid filling up the stack and thus you avoid the RangeError. So let's re-write the function

// still naive but a bit improved recursive count down function
function betterRecursiveCountDown(count) {
  console.log("-> start recursiveCountDown [" + count + "]");
  
  if (count !== 0) {
    //setTimeout takes more than two parameters - anything after the second one will be passed to the function when it gets executed
    setTimeout(betterRecursiveCountDown, 0, count - 1);
    console.log("<- end recursiveCountDown [" + count + "]");
  } else {
    console.log("<<<- it's the final recursiveCountDown! [" + count + "]"); // show where we stopped
  }
}

betterRecursiveCountDown(10);

这篇关于了解javascript中的事件队列和调用堆栈的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！

查看全文
相关文章
前端开发最新文章
热门教程
热门工具
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆