J'ai créé le SettimeOut qui a un rappel nommé exécuté, à l'intérieur de la course, j'ai appelé un console.log (i) pour imprimer la valeur de i avec i ++ Et une fois qu'il atteint à 50, je veux effacer le Settimeout avec ClearTimeout , j'appelle à nouveau Settimeout avec l'exécution en faisant la tâche, mais cela ne fonctionne pas.
Quelqu'un peut-il m'aider à mieux comprendre le concept mieux?
7 Réponses :
Le SETTIMETTOUTOOUT () INTÉRIEUR () In non-exécuté () In non attribué à aucune variable, il ne peut donc pas être effacé de quelque manière que ce soit.
Je suppose que vous voulez écraser ABC afin que vous puissiez remplacer: < Pré> xxx
par
Etant donné que Si vous souhaitez effacer le dernier timeout, vous souhaitez peut-être toujours mettre à jour var abc code> est uniquement défini une fois, au premier délai d'attente, vous ne nettoyez que le tout premier délai d'attente, ce qui est probablement déjà complet. Settimeout code> Renvoie une valeur numérique, qui est un ID pour faire référence à cette tâche. Lorsque vous appelez Cleartimeout code>, vous devez informer l'ID du délai d'attente que vous souhaitez effacer, et vous informez désormais l'ID pour le tout premier délai d'attente, qui est déjà terminé, il ne peut donc pas être effacé. P> abc code> avec les identifiants pour chaque délai d'attente, comme celui-ci: P> abc = setTimeout(run,100);
" Lequel est probablement déjà complet " c'est complet par définition. Il doit fonctionner au moins une fois (la poignée capturée) avant de pouvoir fonctionner 50 encore 50 fois.
Ce n'est pas la matière importante, mais dans une réflexion théorique très théorique, la fin de chaque cycle n'est pas une condition préalable à l'exécution de la suivante. Imaginez s'il y avait un Pause () instruction juste après Settimeout (exécuté, 100); . L'exécution irait théoriquement sans problèmes (sauf 50 instructions en pause, mais bien ...)
" la fin de chaque exécution n'est pas une condition préalable à l'exécution de la suivante " mais vous retardez d'abord une fonction et vous obtenez une poignée. Sauf si quelque chose gère Cleartimeout sur cette poignée, la fonction retardée exécute. S'il exécute, alors exécutez le ClearTimeout de la fonction retardée signifie que la poignée est déjà inutile - la minuterie est tirée. Si la minuterie a été annulée, la fonction retardée ne fonctionne pas et il n'appelle donc pas ClearTimeout . Dans tous les cas, je peux voir l'exécution d'annulation de la minuterie de la fonction retardée est inutile, pas parfois inutile.
Ceci est une façon étrange de faire une boucle chronométrée, mais il vous suffit de vous effacer (en réalité pas dans ce cas, mais j'aime le faire de toute façon, car il s'agit d'une bonne pratique de libérer des ressources une fois que vous ne les utilisez plus) Les délais d'attente (faites en gardant une trace de la poignée ABC) avant de créer de nouveaux et de retourner après p> Effacer code> sur la condition donnée:
let i = 1;
let abc = setTimeout(
function run(){
console.log(i);
if(i==50){
abc1();
return;
}
abc1();
i++;
abc = setTimeout(run,100);
},
100
);
function abc1(){
clearTimeout(abc);
}
salut ce code fonctionne bien, pouvez-vous m'aider à comprendre pourquoi vous avez appelé ABC1 deux fois
Ce code fonctionne mais n'est pas correct. La raison pour laquelle il ne continue pas est parce que retour quittera la fonction avant qu'un nouveau est planifié - appeler abc1 (et donc ClearTimeout ) est Complètement superflu et n'a aucun effet sur le code. Il ne fera jamais disparaître la poignée qui fonctionne actuellement, qui est un non-op.
Vous devez ajouter de retour après avoir appelé la fonction ABC1. Vous clarifiez le délai d'attente, mais le code s'exécute toujours et appelle Settimeout (exécuté, 100) à nouveau.
Le retour appelle abc1 redondant. Effacer l'ancienne poignée n'affectera rien.
Le problème est l'ordre de vos opérations.
let i = 1;
var abc = setTimeout(function run() {
console.log(i);
if (i == 50) {
abc1();
} else {
i++;
setTimeout(run, 100);
}
}, 100);
function abc1() {
clearTimeout(abc);
}
Calling ABC1 () produit un nouvel effet dans ce cas. Il ne fera que effacer une poignée pour une minuterie qui est déjà exécutée. C'est superflu au mieux, mais cela ne devrait vraiment pas être fait consciemment.
let i = 1;
var abc = setTimeout(function run(){
console.log(i);
if(i<50){
setTimeout(run,100);
}
i++;
},100);
You should run timeout only if timer not run out.
Lorsque vous appelez Cependant, cet identifiant n'est valide que jusqu'à ce que la fonction retardée exécute. Une fois que cela fait, c'est inefficace. Lorsque vous appelez Il existe une contrepartie finale - avec votre code actuel même si vous devez capturer correctement l'appel d'identité Settimeout code>, vous obtenez l'identifiant de la minuterie renvoyé. C'est exactement ce que vous avez fait ici: SettimeOut (exécuté, 100); code> vous obtiendrez un nouvel identifiant em> pour la minuterie. Vous devez capturer cela à nouveau, sinon l'identifiant est perdu et vous n'avez aucun moyen de l'arrêter. P> ABC = SETTimeOut (exécuté, 100); code> qui n'arrêterait toujours pas le compteur car il tentera d'arrêter la fonction qui fonctionne maintenant (ce qui ne fait rien), au lieu d'annuler l'exécution de la suivante: P> let i = 1;
setTimeout(function run() {
console.log(i);
if (i != 50) { //until 50 is reached
abc = setTimeout(run, 100); //schedule a new execution
}
i++;
}, 100);
Quelle est l'erreur que vous obtenez? Je suppose que c'est
exécuté n'est pas défini ?En tant que mis à part, connaissez-vous
seinterval /ClearInterval ? Si vous savez que vous voulez continuer à courir la même chose à plusieurs reprises jusqu'à une certaine condition, ils pourraient être un meilleur choix.@nightgaunt
Exécuter est défini - c'est l'expression de fonction nommée transmise àSettimeout .