O recurso de threading único do mecanismo JavaScript possibilita tópicos exclusivos por um longo tempo ao lidar com uma grande travessia de loop, resultando em outros eventos (como operações do usuário) sendo incapazes de responder a tempo e, em casos graves, pode causar lag ou até morte falsa. Para resolver o problema acima, um mecanismo viável é dividir o grande loop em vários pequenos fragmentos de loop para executar fragmentos, de modo que o mecanismo JavaScript tenha a oportunidade de inserir e executar outras coisas entre os segmentos, melhorando efetivamente a experiência de desempenho.
ANSYNC.JS
A cópia do código é a seguinte:
Função ANSYNC (TotalCount, SegmentCount, WorkCallback, ReturnCallback)
{
var num_of_item_for_each_segment = segmentCount;
var num_of_segment = math.ceil (totalCount / num_of_item_for_each_segment);
var count_of_segment = 0;
Var Timer;
Var Start, fim;
this.process = function (escopo, tempo limite)
{
se (escopo! = indefinido)
{
WorkCallback = WorkCallback.Bind (SCOPE);
returnCallback = returnCallback? returnCallback.Bind (SCOPE): indefinido;
}
if (count_of_segment == num_of_segment)
{
ClearTimeout (timer);
if (returnCallback! = indefinido)
returnCallback ();
}
outro
{
start = count_of_segment * num_of_item_for_each_segment;
end = math.min (totalcount, (count_of_segment + 1) * num_of_item_for_each_segment);
if (num_of_segment == 1) // não precisar criar um temporizador
{
WorkCallback (start, fim);
count_of_segment = 1;
this.process ();
}
outro
{
Timer = setTimeout (função ANSYNCTIMEOUT () {
if (workcallback (start, fim)) // processo de acabamento se a função retornar
{
count_of_segment = num_of_segment;
}
outro
{
count_of_segment ++;
}
this.Scope.process ();
} .bind ({scope: this}), timeout == indefinido? ANSYNC.Timeout: Timeout);
}
}
}
}
ANSYNC.TIMEOUT = 5;
O método é muito simples, mas é muito prático. Consulte, se você tiver os mesmos requisitos do projeto.