Une brève discussion sur les appels d'expiration JavaScript et les compétences d'appels intermittents_javascript

Appel intermittent

Les appels intermittents sont très courants en JavaScript. setInterval est appelé à plusieurs reprises à un certain intervalle.

La méthode

setInterval() reçoit deux paramètres : le premier paramètre peut être une chaîne ou une fonction, et le deuxième paramètre est un nombre en millisecondes, indiquant la longueur de l'intervalle de répétition.

Le paramètre est une chaîne

Lorsque le premier paramètre passé est une chaîne, comme suit :

setInterval("alert('this is a string.')",1000);

La chaîne ici est un morceau de code JavaScript, qui est le même que le paramètre de la fonction eval() transmis. S'il y a deux guillemets à l'intérieur et à l'extérieur, rappelez-vous que les guillemets ne doivent pas être les mêmes.

setInterval() renverra un identifiant numérique. Cet identifiant est un identifiant unique du code d'exécution prévu, il peut donc être utilisé pour annuler des opérations répétées. SetInterval() correspond à une méthode pour annuler l'opération : clearInterval() Bien entendu, si vous souhaitez annuler une opération répétée, clearInterval() doit être placé avant la fin de l'exécution.

Par exemple :

var intervalId=setInterval(...);
clearInterval(intervalId);

Nous obtenons d'abord l'ID, puis transmettons l'ID dans clearInterval(). Étant donné que l'opération d'annulation suit setInterval(), elle peut être annulée immédiatement, comme si cela ne s'était pas produit.

Le paramètre est une fonction

Parce que lorsque le paramètre passé est une chaîne, cela peut entraîner une perte de performances, donc dans des circonstances normales, la méthode la plus couramment utilisée consiste à lui transmettre une fonction.

est le suivant :

var num=0;
function increNum(){
 num++;
 if(num>=10){
  clearInterval(intervalId);
  alert('over');
 }
}
intervalId=setInterval(increNum,500);

Ce programme définit une fonction incrNum et la transmet comme paramètre à setInterval(). En même temps, lorsqu'elle est répétée 10 fois, l'opération en cours est annulée et une boîte d'avertissement apparaît.

Appel hors délai

L'appel Timeout est similaire à l'appel intermittent, setTimeout(), il reçoit également deux paramètres, le premier peut être une chaîne contenant du code JavaScript, ou il peut être une fonction, le deuxième paramètre est le temps de retard et setInterval() Les paramètres de la méthode sont les mêmes.

Mais voici quelque chose à noter :

Le délai ne signifie pas que le programme sera définitivement exécuté après le délai défini.

Pourquoi ?

Étant donné que JavaScript est un interpréteur monothread, il ne peut exécuter qu'un seul morceau de code dans un certain laps de temps et ne peut pas exécuter plusieurs morceaux de code en même temps. Par conséquent, il existe une file d'attente de tâches en JavaScript et. les tâches à exécuter sont classées dans la file d'attente dans l'ordre. Le délai défini est le temps après lequel la tâche en cours sera ajoutée à la file d'attente des tâches. Si aucune tâche n'est en cours d'exécution, le code ajouté à la file d'attente des tâches sera exécuté immédiatement. Si un segment de code est actuellement en cours d'exécution, la tâche nouvellement ajoutée ne sera exécutée qu'après l'exécution du segment de code.

De même, setTimeout() a également un ID de retour, et vous pouvez également utiliser cet ID numérique pour annuler l'appel de délai d'attente. La méthode d'annulation correspondante est clearTimeout().

Ici, nous utilisons la méthode d'appel timeout pour copier le code qui est exécuté à plusieurs reprises lors de l'appel intermittent :

var num=0;
function increNum(){
 num++;
 if(num<=10){
  setTimeout(increNum,500);
 }else{
  alert('over');
 }
}
setTimeout(increNum,500);

Ce programme peut également effectuer des opérations répétées et terminer l'opération après 10 fois. La différence avec setInterval() ci-dessus est qu'il n'utilise pas l'ID numérique renvoyé.

Parce que setInterval() est exécuté à plusieurs reprises, il y aura toujours un identifiant numérique renvoyé, donc cet identifiant numérique doit être suivi tout le temps, et setTimeout() ne sera plus exécuté après son exécution, nous n'avons donc pas besoin pour suivre l'identifiant numérique renvoyé, cela nous apporte une certaine commodité.

De plus, ce dernier appel intermittent peut être appelé avant la fin de l'appel intermittent précédent. Cette situation se produira lorsque le temps d'exécution de la fonction est plus long que le temps d'appel intermittent, donc pour résumer, utiliser setTimeout() est une meilleure solution. moyen de simuler des appels intermittents.

Bien sûr, il n'y a pas de gros problème à utiliser setInterval() dans des programmes relativement simples (je me suis soudainement souvenu d'une phrase, l'existence est raisonnable~~~~).