La característica de un solo hilo del motor JavaScript permite que los hilos exclusivos durante mucho tiempo al manejar una transversal de bucle grande, lo que resulta en que otros eventos (como las operaciones del usuario) no puedan responder en el tiempo, y en casos severos puede causar retraso o incluso una muerte falsa. Para resolver el problema anterior, un mecanismo factible es dividir el bucle grande en varios fragmentos de bucle pequeño para ejecutar fragmentos, de modo que el motor JavaScript tenga la oportunidad de insertar y ejecutar otras cosas entre los segmentos, mejorando así efectivamente la experiencia de rendimiento.
Ansync.js
La copia del código es la siguiente:
Función 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;
temporizador var;
var inicio, fin;
this.process = function (alcance, tiempo de espera)
{
if (alcance! = indefinido)
{
WorkCallback = WorkCallback.Bind (Alcance);
returnCallback = returnCallback? returnCallback.bind (alcance): indefinido;
}
if (count_of_segment == num_of_segment)
{
ClearTimeOut (temporizador);
if (returnCallback! = Undefined)
returnCallback ();
}
demás
{
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) // no necesita crear un temporizador
{
WorkCallback (inicio, finalización);
count_of_segment = 1;
this.process ();
}
demás
{
timer = setTimeOut (function AnsyncTimeout () {
if (WorkCallback (Start, End)) // El proceso de finalización si la función devuelve verdadero
{
count_of_segment = num_of_segment;
}
demás
{
count_of_segment ++;
}
this.scope.process ();
} .bind ({alcance: this}), timeout == Undefined? Ansync.TimeOut: Tiempo de espera);
}
}
}
}
Ansync.Timeout = 5;
El método es muy simple, pero es muy práctico. Consultelo si tiene los mismos requisitos del proyecto.