O JavaScript é único e possui um modelo de execução síncrona. Encadeamento único significa que um comando está sendo executado por vez. Síncrono significa um de cada vez, ou seja, uma linha de código está sendo executada ao mesmo tempo para que o código apareça. Então, em JavaScript, uma coisa está acontecendo de cada vez.
Contexto de Execução
O mecanismo JavaScript interage com outros mecanismos no navegador. Na pilha de execução do JavaScript, há um contexto global na parte inferior e, quando invocamos funções, o mecanismo JavaScript cria novos contextos de execução para as respectivas funções. Quando a função chamada sai, seu contexto de execução é exibido na pilha e o próximo contexto de execução é exibido e assim por diante ...
Por exemplo
function abc()
{
console.log('abc');
}
function xyz()
{
abc()
console.log('xyz');
}
var one = 1;
xyz();
No código acima, um contexto de execução global será criado e, nesse contexto var one, será armazenado e seu valor será 1 ... quando a chamada xyz () for chamada, um novo contexto de execução será criado e se definimos alguma variável na função xyz, essas variáveis seriam armazenadas no contexto de execução de xyz (). Na função xyz, invocamos abc () e, em seguida, o contexto de execução abc () é criado e colocado na pilha de execução ... Agora, quando abc () termina, seu contexto é retirado da pilha, o contexto xyz () é retirado de empilhar e, em seguida, o contexto global será exibido ...
Agora, sobre retornos de chamada assíncronos; assíncrono significa mais de um de cada vez.
Assim como a pilha de execução, há a fila de eventos . Quando queremos ser notificados sobre algum evento no mecanismo JavaScript, podemos ouvi-lo, e esse evento é colocado na fila. Por exemplo, um evento de solicitação do Ajax ou evento de solicitação de HTTP.
Sempre que a pilha de execução estiver vazia, como mostrado no exemplo de código acima, o mecanismo JavaScript verifica periodicamente a fila de eventos e verifica se há algum evento a ser notificado. Por exemplo, na fila, havia dois eventos, uma solicitação ajax e uma solicitação HTTP. Ele também procura ver se existe uma função que precise ser executada nesse gatilho de evento ... Portanto, o mecanismo JavaScript é notificado sobre o evento e conhece a respectiva função a ser executada nesse evento ... Portanto, o mecanismo JavaScript chama o função manipulador, no caso de exemplo, por exemplo, AjaxHandler () será invocado e, como sempre, quando uma função é invocada, seu contexto de execução é colocado no contexto de execução e agora a execução da função termina e a solicitação de evento ajax também é removida da fila de eventos ... Quando AjaxHandler () termina, a pilha de execução está vazia, portanto, o mecanismo novamente analisa a fila de eventos e executa a função de manipulador de eventos da solicitação HTTP, que foi a próxima na fila. É importante lembrar que a fila de eventos é processada apenas quando a pilha de execução está vazia.
Por exemplo, consulte o código abaixo, explicando a pilha de execução e a manipulação da fila de eventos pelo mecanismo Javascript.
function waitfunction() {
var a = 5000 + new Date().getTime();
while (new Date() < a){}
console.log('waitfunction() context will be popped after this line');
}
function clickHandler() {
console.log('click event handler...');
}
document.addEventListener('click', clickHandler);
waitfunction(); //a new context for this function is created and placed on the execution stack
console.log('global context will be popped after this line');
E
<html>
<head>
</head>
<body>
<script src="program.js"></script>
</body>
</html>
Agora execute a página da web, clique na página e veja a saída no console. A saída será
waitfunction() context will be popped after this line
global context will be emptied after this line
click event handler...
O mecanismo JavaScript está executando o código de forma síncrona, conforme explicado na parte do contexto de execução, o navegador está colocando as coisas de forma assíncrona na fila de eventos. Portanto, as funções que levam muito tempo para serem concluídas podem interromper a manipulação de eventos. Coisas que acontecem em um navegador, como eventos, são tratadas dessa maneira por JavaScript; se houver um ouvinte em execução, o mecanismo executará quando a pilha de execução estiver vazia. Como os eventos são processados na ordem em que ocorrem, a parte assíncrona é sobre o que está acontecendo fora do mecanismo, ou seja, o que o mecanismo deve fazer quando esses eventos externos acontecerem.
Portanto, o JavaScript é sempre síncrono.
