La fonction de lancement unique du moteur JavaScript permet à des threads exclusifs pendant longtemps lors de la manipulation d'une grande traversée de boucle, ce qui entraîne d'autres événements (tels que les opérations utilisateur) incapables de répondre à temps, et dans des cas graves, il peut provoquer un décalage ou même un faux décès. Pour résoudre le problème ci-dessus, un mécanisme réalisable consiste à diviser la grande boucle en plusieurs fragments de petite boucle pour exécuter des fragments, afin que le moteur JavaScript ait la possibilité d'insérer et d'exécuter d'autres choses entre les segments, améliorant ainsi efficacement l'expérience de performance.
Anync.js
La copie de code est la suivante:
fonction anync (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 temporisateur;
Var start, end;
this.process = fonction (portée, délai d'attente)
{
if (Scope! = Undefined)
{
workCallback = workCallback.bind (scope);
returnCallback = returnCallback? returnCallback.bind (Scope): Undefined;
}
if (count_of_segment == num_of_segment)
{
ClearTimeout (temporisateur);
if (returnCallback! = Undefined)
returnCallback ();
}
autre
{
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'a pas besoin de créer une minuterie
{
WorkCallback (début, fin);
count_of_segment = 1;
this.process ();
}
autre
{
timer = setTimeout (fonction anynctimeout () {
if (workcallback (start, fin)) // Processus de finition si la fonction renvoie true
{
count_of_segment = num_of_segment;
}
autre
{
count_of_segment ++;
}
this.scope.process ();
} .bind ({scope: this}), timeout == Undefined? Anync.timeout: timeout);
}
}
}
}
Anync.timeout = 5;
La méthode est très simple, mais elle est très pratique. Veuillez vous y référer si vous avez les mêmes exigences du projet.