Блог

Я написал функцию javascript, которая использует setInterval для обработки строки каждую десятую долю секунды в течение определенного количества итераций.

 function timer() {
    var section = document.getElementById('txt').value;
    var len = section.length;
    var rands = new Array();

    for (i=0; i<len; i  ) {
        rands.push(Math.floor(Math.random()*len));
    };

    var counter = 0
    var interval = setInterval(function() {
        var letters = section.split('');
        for (j=0; j < len; j  ) {
            if (counter < rands[j]) {
                letters[j] = Math.floor(Math.random()*9);
            };
        };
        document.getElementById('txt').value = letters.join('');
        counter  

        if (counter > rands.max()) {
            clearInterval(interval);
        }
    }, 100);
};
 

Вместо того, чтобы устанавливать интервал с определенным числом, я хотел бы обновлять его при каждом запуске на основе счетчика. Поэтому вместо:

 var interval = setInterval(function() { ... }, 100);
 

Это было бы что-то вроде:

 var interval = setInterval(function() { ... }, 10*counter);
 

К сожалению, это не сработало. Казалось, что «10 * счетчик» равен 0.

Итак, как я могу регулировать интервал при каждом запуске анонимной функции?

Вы могли бы использовать анонимную функцию:

 var counter = 10;
var myFunction = function(){
    clearInterval(interval);
    counter *= 10;
    interval = setInterval(myFunction, counter);
}
var interval = setInterval(myFunction, counter);
 

ОБНОВЛЕНИЕ: как предложил А. Вольф, используйте setTimeout , чтобы избежать необходимости clearInterval .

 var counter = 10;
var myFunction = function() {
    counter *= 10;
    setTimeout(myFunction, counter);
}
setTimeout(myFunction, counter);
 

Используйте setTimeout() вместо этого. Затем обратный вызов будет отвечать за запуск следующего тайм-аута, после чего вы можете увеличить или иным образом манипулировать временем.

Редактировать

Вот универсальная функция, которую вы можете использовать для применения «замедляющего» таймаута для ЛЮБОГО вызова функции.

 function setDeceleratingTimeout(callback, factor, times)
{
    var internalCallback = function(tick, counter) {
        return function() {
            if (--tick >= 0) {
                window.setTimeout(internalCallback,   counter * factor);
                callback();
            }
        }
    }(times, 0);

    window.setTimeout(internalCallback, factor);
};

// console.log() requires firebug    
setDeceleratingTimeout(function(){ console.log('hi'); }, 10, 10);
setDeceleratingTimeout(function(){ console.log('bye'); }, 100, 10);
 

Мне нравится этот вопрос — вдохновил меня на создание небольшого объекта timer:

 window.setVariableInterval = function(callbackFunc, timing) {
  var variableInterval = {
    interval: timing,
    callback: callbackFunc,
    stopped: false,
    runLoop: function() {
      if (variableInterval.stopped) return;
      var result = variableInterval.callback.call(variableInterval);
      if (typeof result == 'number')
      {
        if (result === 0) return;
        variableInterval.interval = resu<
      }
      variableInterval.loop();
    },
    stop: function() {
      this.stopped = true;
      window.clearTimeout(this.timeout);
    },
    start: function() {
      this.stopped = false;
      return this.loop();
    },
    loop: function() {
      this.timeout = window.setTimeout(this.runLoop, this.interval);
      return this;
    }
  };

  return variableInterval.start();
};
 

Пример использования

 var vi = setVariableInterval(function() {
  // this is the variableInterval - so we can change/get the interval here:
  var interval = this.interval;

  // print it for the hell of it
  console.log(interval);

  // we can stop ourselves.
  if (interval>4000) this.stop();

  // we could return a new interval after doing something
  return interval   100;
}, 100);  

// we can change the interval down here too
setTimeout(function() {
  vi.interval = 3500;
}, 1000);

// or tell it to start back up in a minute
setTimeout(function() {
  vi.interval = 100;
  vi.start();
}, 60000);
 

У меня был тот же вопрос, что и у оригинального плаката, сделал это как решение. Не уверен, насколько это эффективно….

 let interval = 5000; // initial condition
let run = setInterval(request, interval); // start setInterval as "run"

function request() {

    console.log(interval); // firebug or chrome log
    clearInterval(run); // stop the setInterval()

    // dynamically change the run interval
    if (interval > 200) {
        interval = interval * .8;
    } else {
        interval = interval * 1.2;
    }

    run = setInterval(request, interval); // start the setInterval()
}
 

Это мой способ сделать это, я использую setTimeout:

 var timer = {
    running: false,
    iv: 5000,
    timeout: false,
    cb : function(){},
    start : function(cb,iv){
        var elm = this;
        clearInterval(this.timeout);
        this.running = true;
        if(cb) this.cb = cb;
        if(iv) this.iv = iv;
        this.timeout = setTimeout(function(){elm.execute(elm)}, this.iv);
    },
    execute : function(e){
        if(!e.running) return false;
        e.cb();
        e.start();
    },
    stop : function(){
        this.running = false;
    },
    set_interval : function(iv){
        clearInterval(this.timeout);
        this.start(false, iv);
    }
};
 

Использование:

 timer.start(function(){
    console.debug('go');
}, 2000);

timer.set_interval(500);

timer.stop();
 

Гораздо более простым способом было бы иметь if инструкцию в обновленной функции и элемент управления для выполнения вашей команды через регулярные промежутки времени . В следующем примере я запускаю оповещение каждые 2 секунды, и интервал ( intrv ) может быть изменен динамически…

 var i=1;
var intrv=2; // << control this variable

var refreshId = setInterval(function() {
  if(!(i%intrv)) {
    alert('run!');
  }
  i  ;
}, 1000);
 

Это можно инициировать, как вы хотите. тайм-аут — это метод, который я использовал, чтобы поддерживать его в начале часа.

Мне нужно было каждый час начинать блок кода в час. Таким образом, это начнется при запуске сервера и будет выполняться ежечасно. В основном начальный запуск должен начинаться с интервала в течение той же минуты. Итак, через секунду после инициализации немедленно запускайте каждые 5 секунд.

 var interval = 1000;
var timing =function(){
    var timer = setInterval(function(){
        console.log(interval);
        if(interval == 1000){ /*interval you dont want anymore or increment/decrement */
            interval = 3600000; /* Increment you do want for timer */
            clearInterval(timer);
            timing();
        }
    },interval);
}
timing();
 

В качестве альтернативы, если вы хотите, чтобы что-то происходило при запуске, а затем навсегда с определенным интервалом, вы могли бы просто вызвать его одновременно с setInterval . Например:

 var this = function(){
 //do
}
setInterval(function(){
  this()
},3600000)
this()
 

Здесь у нас это выполняется в первый раз, а затем каждый час.

Простой ответ: вы не можете обновить интервал уже созданного таймера. (Существует только две функции setInterval/setTimer и clearInterval/clearTimer , поэтому, имея a timerId , вы можете только деактивировать его.) Но вы можете сделать несколько обходных путей. Взгляните на это репозиторий github.

Я также не мог синхронизировать и изменять скорость своих setIntervals, и я собирался опубликовать вопрос. Но я думаю, что нашел способ. Это, безусловно, должно быть улучшено, потому что я новичок. Итак, я бы с удовольствием прочитал ваши комментарии / замечания по этому поводу.

 <body onload="foo()">
<div id="count1">0</div>
<div id="count2">2nd counter is stopped</div>
<button onclick="speed0()">pause</button>
<button onclick="speedx(1)">normal speed</button>
<button onclick="speedx(2)">speed x2</button>
<button onclick="speedx(4)">speed x4</button>
<button onclick="startTimer2()">Start second timer</button>
</body>
<script>
var count1 = 0,
    count2 = 0,
    greenlight = new Boolean(0), //blocks 2nd counter
    speed = 1000,   //1second
    countingSpeed;
function foo(){
    countingSpeed = setInterval(function(){
        counter1();
        counter2();
    },speed);
}
function counter1(){
    count1  ;
    document.getElementById("count1").innerHTML=count1;
}
function counter2(){
    if (greenlight != false) {
        count2  ;
        document.getElementById("count2").innerHTML=count2;
    }
}
function startTimer2(){
    //while the button hasn't been clicked, greenlight boolean is false
    //thus, the 2nd timer is blocked
    greenlight = true;
    counter2();
    //counter2() is greenlighted
}

//these functions modify the speed of the counters
function speed0(){
    clearInterval(countingSpeed);
}
function speedx(a){
    clearInterval(countingSpeed);
    speed=1000/a;
    foo();
}
</script>
 

Если вы хотите, чтобы счетчики начали увеличиваться после загрузки страницы, вызывается функция put counter1() and counter2() in foo() before countingSpeed . В противном случае выполнение занимает speed миллисекунды.
РЕДАКТИРОВАТЬ: более короткий ответ.

 (function variableInterval() {
    //whatever needs to be done
    interval *= 2; //deal with your interval
    setTimeout(variableInterval, interval);
    //whatever needs to be done
})();
 

не может быть короче

Вот еще один способ создания интервального таймера замедления / ускорения. Интервал умножается на коэффициент, пока не будет превышено общее время.

 function setChangingInterval(callback, startInterval, factor, totalTime) {
    let remainingTime = totalTime;
    let interval = startInterval;

    const internalTimer = () => {
        remainingTime -= interval ;
        interval *= factor;
        if (remainingTime >= 0) {
            setTimeout(internalTimer, interval);
            callback();
        }
    };
    internalTimer();
}
 

Создать новую функцию:

 // set Time interval
$("3000,18000").Multitimeout();

jQuery.fn.extend({
    Multitimeout: function () {
        var res = this.selector.split(",");
        $.each(res, function (index, val) { setTimeout(function () { 
            //...Call function
            temp();
        }, val); });
        return true;
    }
});

function temp()
{
    alert();
}
 

Этот фрагмент кода ниже ускоряет (ускорение> 1) или замедляет (ускорение <1) setInterval функцию :

 function accelerate(yourfunction, timer, refresh, acceleration) {
    var new_timer = timer / acceleration;
    var refresh_init = refresh;//save this user defined value
    if (refresh < new_timer ){//avoid reseting the interval before it has produced anything.
        refresh = new_timer   1 ;
    };
    var lastInter = setInterval(yourfunction, new_timer);
    console.log("timer:", new_timer);
    function stopLastInter() {
        clearInterval(lastInter);
        accelerate(yourfunction, new_timer, refresh_init, acceleration);
        console.log("refresh:", refresh);
    };
    setTimeout(stopLastInter, refresh);
}
 

С помощью :

• timer : начальное значение setInterval в мс (увеличивается или уменьшается)
• refresh : время до вычисления нового значения timer . Это длина шага
• acceleration : разрыв между старым и следующим timer значением. Это высота шага

Вдохновленный описанным выше внутренним обратным вызовом, я создал функцию для запуска обратного вызова за доли минут. Если время ожидания установлено на интервалы, подобные 6 000, 15 000, 30 000, 60 000 он будет постоянно синхронизировать интервалы с точным переходом на следующую минуту ваших системных часов.

 //Interval timer to trigger on even minute intervals
function setIntervalSynced(callback, intervalMs) {

    //Calculate time to next modulus timer event
    var betterInterval = function () {
        var d = new Date();
        var millis = (d.getMinutes() * 60   d.getSeconds()) * 1000   d.getMilliseconds();
        return intervalMs - millis % intervalMs;
    };

    //Internal callback
    var internalCallback = function () {
        return function () {
            setTimeout(internalCallback, betterInterval());
            callback();
        }
    }();

    //Initial call to start internal callback
    setTimeout(internalCallback, betterInterval());
};
 

Это моя идея для случаев, когда вы не хотите setInterval , чтобы циклы перекрывались.
Вы также хотите иметь возможность устанавливать задержку выполнения цикла, а также запускать и останавливать цикл мгновенно на лету.
Я использую loop_flag переменную и setTimeout функцию.
Я установил для функции main async значение, чтобы вы могли вызывать другие функции в теле путем вызова await . Когда выполняется основная часть вашего кода, основной цикл ожидает и не повторяется. (что не относится к setInterval )

Примером простого кода является:

 //@NabiKAZ

document.getElementById("btn_start").addEventListener("click", function() {
  console.log("Starting...");
  loop_flag = true;
  loop_func();
});
document.getElementById("btn_stop").addEventListener("click", function() {
  console.log("Stoping...");
  loop_flag = false;
});

var n = 0;

var loop_flag = false;
var loop_func = async function() {
  if (!loop_flag) {
    console.log("STOP.");
    return;
  }

  //body main function inhere
  n  ;
  console.log(n);
  ////


  if (loop_flag) {
    setTimeout(loop_func, document.getElementById("inp_delay").value);
  } else {
    console.log("STOP.");
  }
} 

 <input id="inp_delay" value="1000">
<button id="btn_start">START</button>
<button id="btn_stop">STOP</button> 

Более полный код с запросом выборки внутри цикла см. Здесь:

https://jsfiddle.net/NabiKAZ/a5hdw2bo/

Вы можете использовать переменную и вместо этого изменить переменную.

 setInterval(() => function, variable)
 

 var counter = 15;
var interval = function() {
    setTimeout(function(){
        // Write your code here and remove console.log, remember that you need declare yourDynamicValue and give it a value
        console.log((new Date()).getTime())

        window.counter = yourDynamicValue;
        window.interval();
    }, counter);
}
 

// Он должен выполняться только один раз как init

interval();