Thay đổi khoảng thời gian SetInterval khi nó đang chạy

Tôi đã viết một hàm javascript sử dụng setInterval để thao tác một chuỗi mỗi phần mười giây cho một số lần lặp nhất định.

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);
};

Thay vì đặt khoảng thời gian ở một số cụ thể, tôi muốn cập nhật nó mỗi khi nó chạy, dựa trên bộ đếm. Vì vậy, thay vì:

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

Nó sẽ giống như:

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

Thật không may, điều đó đã không làm việc. Có vẻ như "bộ đếm 10 *" bằng 0.

Vì vậy, làm thế nào tôi có thể điều chỉnh khoảng thời gian mỗi khi chức năng ẩn danh chạy?

Sử dụng setTimeout()thay thế. Cuộc gọi lại sau đó sẽ chịu trách nhiệm bắn thời gian chờ tiếp theo, tại thời điểm đó bạn có thể tăng hoặc thao tác thời gian.

BIÊN TẬP

Đây là một chức năng chung mà bạn có thể sử dụng để áp dụng thời gian chờ "giảm tốc" cho bất kỳ cuộc gọi chức năng nào.

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);

Bạn có thể sử dụng một chức năng ẩn danh:

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

CẬP NHẬT: Theo đề xuất của A. Wolff, sử dụng setTimeoutđể tránh sự cần thiết clearInterval.

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

Tôi thích câu hỏi này - lấy cảm hứng từ một đối tượng hẹn giờ nhỏ trong tôi:

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 = result;
      }
      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();
};

Ví dụ sử dụng

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);

Tôi đã có câu hỏi tương tự như poster ban đầu, đã làm điều này như một giải pháp. Không chắc cách này hiệu quả ....

interval = 5000; // initial condition
var 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()

    }

Đây là cách của tôi để làm điều này, tôi sử dụng 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);
    }
};

Sử dụng:

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

timer.set_interval(500);

timer.stop();

Một cách đơn giản hơn nhiều sẽ là có một ifcâu lệnh trong hàm được làm mới và điều khiển để thực thi lệnh của bạn theo các khoảng thời gian thông thường. Trong ví dụ sau, tôi chạy cảnh báo cứ sau 2 giây và khoảng thời gian ( intrv) có thể được thay đổi linh hoạt ...

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

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

Điều này có thể được bắt đầu theo cách bạn muốn. thời gian chờ là phương pháp tôi đã sử dụng để giữ nó trên đầu giờ.

Tôi có nhu cầu mỗi giờ để bắt đầu một khối mã vào giờ. Vì vậy, điều này sẽ bắt đầu khi máy chủ khởi động và chạy khoảng thời gian hàng giờ. Về cơ bản việc chạy ban đầu là bắt đầu khoảng thời gian trong cùng một phút. Vì vậy, trong một giây từ init, hãy chạy ngay sau đó cứ sau 5 giây.

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();

Thay phiên nếu bạn muốn có một cái gì đó xảy ra khi bắt đầu và sau đó mãi mãi ở một khoảng thời gian cụ thể, bạn có thể gọi nó cùng lúc với setInterval. Ví dụ:

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

Ở đây chúng tôi có điều này chạy lần đầu tiên và sau đó mỗi giờ.

Câu trả lời đơn giản là bạn không thể cập nhật một khoảng thời gian đã được tạo . (Chỉ có hai chức năng setInterval/setTimervà clearInterval/clearTimervì vậy, có một chức năng timerIdbạn chỉ có thể tắt nó.) Nhưng bạn có thể thực hiện một số cách giải quyết. Hãy nhìn vào repo github này .

Tôi không thể đồng bộ hóa và thay đổi tốc độ thiết lập của mình và tôi cũng sắp đăng một câu hỏi. Nhưng tôi nghĩ rằng tôi đã tìm thấy một cách. Nó chắc chắn nên được cải thiện bởi vì tôi là người mới bắt đầu. Vì vậy, tôi rất vui khi đọc những bình luận / nhận xét của bạn về điều này.

<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>

Nếu bạn muốn các bộ đếm bắt đầu tăng sau khi trang được tải, hãy đặt counter1()và counter2()vào foo()trước countingSpeedđược gọi. Nếu không, phải mất một speedphần nghìn giây trước khi thực hiện. EDIT: Câu trả lời ngắn hơn.

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

không thể rút ngắn

Tôi là người mới bắt đầu sử dụng javascript và không tìm thấy bất kỳ trợ giúp nào trong các câu trả lời trước đó (nhưng nhiều ý tưởng hay).
Đoạn mã dưới đây tăng tốc (tăng tốc> 1) hoặc giảm tốc (tăng tốc <1). Tôi hy vọng nó có thể giúp một số người:

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);
}

Với :

• timer: giá trị ban đầu setInterval tính bằng ms (tăng hoặc giảm)
• refresh: thời gian trước khi giá trị mới timerđược tính. Đây là bước dài
• factor: khoảng cách giữa timergiá trị cũ và giá trị tiếp theo . Đây là chiều cao bước

Tạo chức năng mới:

// 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();
}

Đây là một cách khác để tạo một bộ đếm thời gian giảm tốc / tăng tốc. Khoảng thời gian được nhân với một yếu tố cho đến khi tổng thời gian bị vượt quá.

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();
}

var counter = 15;
var interval = setTimeout(function(){
    // your interval code here
    window.counter = dynamicValue;
    interval();
}, counter);

Lấy cảm hứng từ cuộc gọi lại nội bộ ở trên, tôi đã thực hiện một chức năng để thực hiện một cuộc gọi lại với phân số phút. Nếu thời gian chờ được đặt thành các khoảng như 6 000, 15 000, 30 000, 60 000, nó sẽ liên tục điều chỉnh các khoảng thời gian đồng bộ hóa để chuyển chính xác sang phút tiếp theo của đồng hồ hệ thống của bạn.

//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());
};