Question

我正在使用debouncing来在超时后使用settimeout执行事件。我遇到的问题是，其他javascript事件期望这些事件同步发生。由于它们现在在超时后执行，我希望能够通过其他javascript事件过早地触发它们（因此那些需要它们的事件不会失败）。

Anywhom，如果我这样做：

timeout = setTimeout(function() { alert('hi'); }, 10000);

，我希望在10秒钟之前发生这种情况，我该怎么做？

如有必要，解决方案可能涉及jquery。谢谢！

编辑：是否可以只访问超时对象？

Answer 1

所以，如果你做出任何延迟其自身功能的事情：

function sayHi() {
    alert('hi');
}

您可以使用超时和常规函数调用：

var timeout = setTimeout(sayHi, 10000); // say hi after 10 seconds

或者在超时到期之前调用它，只需在需要时调用该函数：

sayHi();

我在这里走在正确的轨道上吗？如果您需要取消超时，请拨打clearTimeout()变量上的timeout。

if (timeout)
    clearTimeout(timeout);

Answer 2

您无法使用标准setTimeout跟踪它，但Javascript允许您根据需要增强功能。

例如，您可以拥有自己的增强型setTimeout：

var _setTimeout = window.setTimeout;
var timeouts = [];
window.setTimeout = function(fn, ms) {
    var id = _setTimeout(fn, ms);
    timeouts[id] = fn;
    return id;
};

window.premature = function(id) {
    var fn = timeouts[id];
    if (fn) {
        clearTimeout(id);
        if (fn instanceof String) {
            eval(fn);
        } else {
            fn()
        }
    }
};


function printDate(str) {
    $("body").append("<p>" + str + ". " + new Date() + "</p>");

}

$(function() {
    var id1 = setTimeout(function() { printDate("id1"); }, 10000);
    var id2 = setTimeout(function() { printDate("id2"); }, 10000);
    printDate("first one");
    // just to demonstrate that the string version works too
    setTimeout("window.premature(" + id1 +")", 5000);
});

您可以在jsFiddle

看到它的实际效果

请注意，这个简单的黑客没有考虑在超时发生时清除使用过的ID，但这只是为了表明你可以在Javascript中做这种事情，如果你真的需要它。

Answer 3

polyfill溶液

这是我从之前的项目中更新过的一些javascript，它现在通过触发器和更新方法进行了扩展;它类似于Jan Wikholm的解决方案（+1） - 但更为完整，考虑到清除，传递参数以及在需要时预防eval：

(function(keep){

  /// a few things to remember
  keep.setTimeout = window.setTimeout;
  keep.clearTimeout = window.clearTimeout;
  keep.TO = function(){};
  keep.list = {};
  keep.settings = {
    eval: false /// set this to true if you wish to support string timeouts
  };

  /**
   * Quick check function to prevent eval
   */
  keep.checkParam = function( param ){
    if ( !keep.settings.eval && typeof param == 'string' ) {
      throw new Error('setTimeout blocked evaluation of string, ' + 
        'use a function instead.');
      return false;
    }
    else if ( param ) {
      return true;
    }
  };

  /**
   * Simple function constructor to avoid trapping unwanted references
   */
  keep.makeFunction = function(data){
    return function(args){
      /// copy our args array
      args = data.args.slice();
      /// do we allow eval?
      if ( keep.settings.eval ) {
        /// if so, reuse setTimeout for it's abilities
        args[0] = data.param; /// use the original param
        args[1] = 0;          /// trigger immediately
        keep.setTimeout.apply( window, args );
      }
      // more secure, assume dealing with function -- not string
      else if ( keep.checkParam( data.param ) && data.param.apply ) {
        data.param.apply( window, args.slice(2) );
      }
      else {
        throw new Error('unsupported param for setTimeout' + 
          ' i.e. non-function used.');
      }
      /// clear our storage of this tid
      window.clearTimeout( data.tid );
    };
  };

  /**
   * Sets timeouts just like you would expect
   */
  window.setTimeout = function( param, timeout ){
    if ( keep.checkParam( param ) ) {
      var tid, data;
      /// support passing a timeout object as param
      if ( param instanceof keep.TO ) {
        data = param;
        data.args[1] = data.timeout;
      }
      else {
        /// create an object to store the timeout info
        data = new keep.TO();
        data.func = keep.makeFunction(data);
        data.param = param;
        data.timeout = timeout;
        data.args = Array.prototype.slice.call(arguments,0);
        data.args[0] = data.func;
      }
      data.tid = keep.setTimeout.apply( window, data.args );
      keep.list[data.tid] = data;
      /// enhance the returned number to support .clear, .trigger and .update
      tid = new Number(data.tid);
      tid.clear = window.clearTimeout;
      tid.trigger = window.triggerTimeout;
      tid.update = window.updateTimeout;
      return tid;
    }
  };

  /**
   * Clearing timeouts since 2013
   */
  window.clearTimeout = function( tid ){
    if ( this instanceof Number ) {
      tid = 0 + this;
    }
    var obj;
    if ( (obj = window.getTimeout(tid)) ) {
      delete keep.list[tid];
      keep.clearTimeout.call(window, tid);
    }
  };

  /**
   * Returns the internal timeout storage object
   */
  window.getTimeout = function( tid ){
    var obj;
    if ( (obj = keep.list[tid]) ) {
      return obj;
    }
  };

  /**
   * Clears and fires a timeout before it's outed time
   */    
  window.triggerTimeout = function( tid ){
    if ( this instanceof Number ) {
      tid = 0 + this;
    }
    var obj;
    if ( (obj = window.getTimeout(tid)) ) {
      window.clearTimeout(tid);
      obj.func.call(window);
    }
    else {
      throw new Error('No Timeout found to trigger for ID '+ tid);
    }
  };

  /**
   * Clears and recreates an existing timeout, returns a new timeout id.
   */
  window.updateTimeout = function( tid, timeout ){
    if ( this instanceof Number ) {
      if ( arguments.length == 1 ) {
        timeout = tid;
      }
      tid = 0 + this;
    }
    var obj;
    if ( (obj = window.getTimeout(tid)) ) {
      obj.timeout = timeout;
      window.clearTimeout(tid);
      return window.setTimeout(obj);
    }
    else {
      throw new Error('No Timeout found to update for ID ' + tid);
    }
  };

  /**
   * Utility function to tidy up
   */
  window.clearAllTimeouts = function(){
    for ( var i in keep.list ) {
      window.clearTimeout(i);
    };
  };

  /// Tidy up
  window.onunload = (function(previous){
    return function(){
      window.clearAllTimeouts();
      keep.list = {};
      previous && previous.call(window);
    };
  }(window.onunload));

})({});

包括

将上述内容放在js文件中并使用普通脚本标记包含到您的页面中，不需要以任何方式调用代码：

<script src="timeouts.js"></script>

使用

显然，这应该像普通的setTimeout调用一样使用，但是现在你有额外的方法可以提供更大的灵活性。

var tid = setTimeout( function(){ alert('OK Computer') }, 2000 );

例如，您可以取消原件并强制超时触发：

setTimeout( function(){ triggerTimeout( tid ); }, 500 );

或者，您可以更新超时（确保我们记住新返回的tid）：

setTimeout( function(){ tid = updateTimeout( tid, 5000 ); }, 500 );

你也可以这样做：

setTimeout( function(){ clearTimeout( tid ); }, 1000 );

这些方法中的每一种都可以通过tid本身访问：

setTimeout( function(){ tid.trigger(); }, 1000 );
setTimeout( function(){ tid.update( 5000 ); }, 1000 );
setTimeout( function(){ tid.clear(); }, 1000 );

默认情况下，此代码阻止将setTimeout与字符串参数一起使用，主要是因为传递函数而不是字符串是一种更好的编码风格。要更改此设置，您可以将以下设置切换为true：

keep.settings = {
  eval: true
};

但不建议这样做。

禁用eval还有一个额外的好处，因为代码将使用正常的函数调用来触发超时，即.apply()。这意味着无论您使用什么浏览器，您都可以通过setTimeout将参数传递给超时函数 - 这通常不是您可以依赖跨浏览器的东西。 e.g：

setTimeout( function(a){ alert(a) }, 2000, 'Hello World' );

Answer 4

只需将该功能输出并命名：

function handler(){ 
    alert('hi'); 
}

timeout = setTimeout(handler, 10000);

然后您可以使用handler();

在其他地方调用它

Answer 5

使用clearTimeout并提前重新安排。

尽早执行settimeout

5 个答案:

polyfill溶液

包括

使用