Das Einzel-Threading-Merkmal der JavaScript-Engine ermöglicht es, bei der Behandlung eines großen Schleifenverlaufs lange Threads auszuschließen, was zu anderen Ereignissen (z. B. Benutzeroperationen) nicht rechtzeitig reagieren kann, und in schweren Fällen kann dies zu einer Verzögerung oder sogar einem falschen Tod führen. Um das obige Problem zu lösen, besteht ein praktikabler Mechanismus darin, die große Schleife in mehrere kleine Schleifenfragmente aufzuteilen, um Fragmente auszuführen, damit die JavaScript -Engine die Möglichkeit hat, andere Dinge zwischen den Segmenten einzufügen und auszuführen, wodurch die Leistungserfahrung effektiv verbessert wird.
Ansync.js
Die Codekopie lautet wie folgt:
Funktion 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, Ende;
this.Process = Funktion (Umfang, Zeitlimit)
{
if (Scope! = undefiniert)
{
WorkCallback = WorkCallback.bind (Scope);
returnCallback = returnCallback? returnCallback.bind (Umfang): undefiniert;
}
if (count_of_segment == num_of_segment)
{
Clearimeout (Timer);
if (returncallback! = undefiniert)
returnCallback ();
}
anders
{
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) // muss keinen Timer erstellen
{
WorkCallback (Start, Ende);
count_of_segment = 1;
this.process ();
}
anders
{
timer = setTimeout (Funktion ansynctimeout () {
if (WorkCallback (Start, Ende)) // Prozess beenden, wenn die Funktion true zurückgibt
{
count_of_segment = num_of_segment;
}
anders
{
count_of_segment ++;
}
this.scope.process ();
} .bind ({scope: this}), timeout == undefiniert? Ansync.Timeout: Timeout);
}
}
}
}
Ansync.timeout = 5;
Die Methode ist sehr einfach, aber sehr praktisch. Bitte beachten Sie es, wenn Sie die gleichen Projektanforderungen haben.