Appel d'une fonction toutes les 60 secondes

Son utilisation setTimeout()permet de lancer une fonction à une heure spécifiée:

setTimeout(function, 60000);

Mais que se passe-t-il si je souhaite lancer la fonction plusieurs fois? Chaque fois qu'un intervalle de temps passe, je voudrais exécuter la fonction (toutes les 60 secondes, disons).

Si vous ne vous souciez pas si le code dans le timerpeut prendre plus de temps que votre intervalle, utilisez setInterval():

setInterval(function, delay)

Cela déclenche encore et encore la fonction passée en premier paramètre.

Une meilleure approche consiste à utiliser setTimeoutavec une self-executing anonymousfonction:

(function(){
    // do some stuff
    setTimeout(arguments.callee, 60000);
})();

cela garantit que le prochain appel ne sera pas effectué avant l'exécution de votre code. J'ai utilisé arguments.calleedans cet exemple comme référence de fonction. C'est une meilleure façon de donner un nom à la fonction et de l'appeler à l'intérieur setTimeoutcar elle arguments.calleeest déconseillée dans ecmascript 5.

Utilisez le

setInterval(function, 60000);

EDIT: (Au cas où si vous souhaitez arrêter l'horloge après son démarrage)

Section de script

<script>
var int=self.setInterval(function, 60000);
</script>

et code HTML

<!-- Stop Button -->
<a href="#" onclick="window.clearInterval(int);return false;">Stop</a>

Une meilleure utilisation des Jandy de réponse à mettre en œuvre une fonction de vote que les sondages tous les intervalsecondes, et se termine après quelques timeoutsecondes.

function pollFunc(fn, timeout, interval) {
    var startTime = (new Date()).getTime();
    interval = interval || 1000;

    (function p() {
        fn();
        if (((new Date).getTime() - startTime ) <= timeout)  {
            setTimeout(p, interval);
        }
    })();
}

pollFunc(sendHeartBeat, 60000, 1000);

METTRE À JOUR

Selon le commentaire, mettez-le à jour pour que la fonction passée arrête l'interrogation:

function pollFunc(fn, timeout, interval) {
    var startTime = (new Date()).getTime();
    interval = interval || 1000,
    canPoll = true;

    (function p() {
        canPoll = ((new Date).getTime() - startTime ) <= timeout;
        if (!fn() && canPoll)  { // ensures the function exucutes
            setTimeout(p, interval);
        }
    })();
}

pollFunc(sendHeartBeat, 60000, 1000);

function sendHeartBeat(params) {
    ...
    ...
    if (receivedData) {
        // no need to execute further
        return true; // or false, change the IIFE inside condition accordingly.
    }
}

Dans jQuery, vous pouvez faire comme ça.

function random_no(){
     var ran=Math.random();
     jQuery('#random_no_container').html(ran);
}
           
window.setInterval(function(){
       /// call your function here
      random_no();
}, 6000);  // Change Interval here to test. For eg: 5000 for 5 sec

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

<div id="random_no_container">
      Hello. Here you can see random numbers after every 6 sec
</div>

setInterval(fn,time)

est la méthode que vous recherchez.

Vous pouvez simplement appeler setTimeout à la fin de la fonction. Cela l'ajoutera à nouveau à la file d'attente des événements. Vous pouvez utiliser n'importe quel type de logique pour faire varier les valeurs de retard. Par exemple,

function multiStep() {
  // do some work here
  blah_blah_whatever();
  var newtime = 60000;
  if (!requestStop) {
    setTimeout(multiStep, newtime);
  }
}

Utilisez window.setInterval(func, time).

Appelez une fonction Javascript toutes les 2 secondes en continu pendant 10 secondes.

var intervalPromise;
$scope.startTimer = function(fn, delay, timeoutTime) {
    intervalPromise = $interval(function() {
        fn();
        var currentTime = new Date().getTime() - $scope.startTime;
        if (currentTime > timeoutTime){
            $interval.cancel(intervalPromise);
          }                  
    }, delay);
};

$scope.startTimer(hello, 2000, 10000);

hello(){
  console.log("hello");
}

Exécuter l'extrait de codeMasquer les résultats

Développer l'extrait

// example:
// checkEach(1000, () => {
//   if(!canIDoWorkNow()) {
//     return true // try again after 1 second
//   }
//
//   doWork()
// })
export function checkEach(milliseconds, fn) {
  const timer = setInterval(
    () => {
      try {
        const retry = fn()

        if (retry !== true) {
          clearInterval(timer)
        }
      } catch (e) {
        clearInterval(timer)

        throw e
      }
    },
    milliseconds
  )
}

ici, nous consolons le nombre naturel 0 à ...... n (le numéro suivant est imprimé dans la console toutes les 60 secondes), en utilisant setInterval ()

var count = 0;
function abc(){
    count ++;
    console.log(count);
}
setInterval(abc,60*1000);

Il y a 2 façons d'appeler

1. setInterval(function (){ functionName();}, 60000);

2. setInterval(functionName, 60000);

la fonction ci-dessus se déclenchera toutes les 60 secondes.