Comment faire pour annuler une sans rebond fonction après, il est appelé, et avant qu'il s'exécute?

- Je créer un sans rebond version d'une fonction avec un trait de soulignement:

var debouncedThing = _.debounce(thing, 1000);

Une fois debouncedThing est appelé...

debouncedThing();

...est-il possible de l'annuler, au cours de la période d'attente avant qu'il s'exécute en fait?

  • Pourquoi le downvote?
  • double possible de Utilisation de la fonction anti-rebond dans soulignement
  • Cette question n'est pas claire. Le mien est spécifique. Cette question n'est pas de fournir une réponse à ma question.
  • La réponse est "Non".
  • Bien sûr, vous pouvez mettre en place votre propre version de debouncer qui sera en quelque sorte exposer timeout ou une fonction de compensation de l'expiration du délai.
  • cela a été très bien répondu j'espère que vous avez retiré le downvote

InformationsquelleAutor user1031947 | 2015-03-12
  1. 42

    Si vous utilisez la dernière version de lodash vous pouvez tout simplement faire:

    //create debounce
const debouncedThing = _.debounce(thing, 1000);

//execute debounce, it will wait one second before executing thing
debouncedThing();

//will cancel the execution of thing if executed before 1 second
debouncedThing.cancel()

    Une autre solution est avec un drapeau:

    //create the flag
let executeThing = true;

const thing = () => {
   //use flag to allow execution cancelling
   if (!executeThing) return false;
   ...
};

//create debounce
const debouncedThing = _.debounce(thing, 1000);

//execute debounce, it will wait one second before executing thing
debouncedThing();

//it will prevent to execute thing content
executeThing = false;
    InformationsquelleAutor Carlos Ruana
  2. 1

    Ce que j'ai fait est utilisé _.mixin pour créer un _.cancellableDebounce méthode. Il est presque identique à l'original, sauf pour les deux nouvelles lignes de.

    _.mixin({
    cancellableDebounce: function(func, wait, immediate) {
        var timeout, args, context, timestamp, result;

        var later = function() {
          var last = _.now() - timestamp;

          if (last < wait && last >= 0) {
            timeout = setTimeout(later, wait - last);
          } else {
            timeout = null;
            if (!immediate) {
              result = func.apply(context, args);
              if (!timeout) context = args = null;
            }
          }
        };

        return function() {
          context = this;
          args = arguments;
          timestamp = _.now();
          var callNow = immediate && !timeout;
          if (!timeout) timeout = setTimeout(later, wait);
          if (callNow) {
            result = func.apply(context, args);
            context = args = null;
          }

          //Return timeout so debounced function can be cancelled
          result = result || {};
          result.timeout = timeout;

          return result;
        };
    }
});

    UTILISATION:

    var thing = function() {
    console.log("hello world");
}

var debouncedThing = _.cancellableDebounce(thing, 1000);
var timeout = debouncedThing().timeout;

clearTimeout(timeout);
    InformationsquelleAutor George Jempty
  3. 0

    Le moyen le plus facile d'annuler un déjà appelé fonction au sein de son anti-rebond de la période est de rendre résiliables. Vraiment juste ajouter 3 lignes de code et une condition.

    const doTheThingAfterADelay = debounce((filter, abort) => {
  if (abort) return

  //here goes your code...

}, /*debounce delay*/500)


function onFilterChange(filter) {
  let abort = false

  if (filter.length < 3) { //your abort condition
    abort = true
  }

  doTheThingAfterADelay(filter, abort) //debounced call
}

    Vous annulez en l'appelant de nouveau avec abort = true.

    Pour la référence, c'est votre classique debounce fonction de prise de Underscore. Il reste intact dans mon exemple.

    //taken from Underscore.js
//Returns a function, that, as long as it continues to be invoked, will not
//be triggered. The function will be called after it stops being called for
//N milliseconds. If `immediate` is passed, trigger the function on the
//leading edge, instead of the trailing.
export function debounce(func, wait, immediate) {
  let timeout
  return function() {
    let context = this, args = arguments
    let later = function() {
      timeout = null
      if (!immediate) func.apply(context, args)
    }
    let callNow = immediate && !timeout
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
    if (callNow) func.apply(context, args)
  }
}
    InformationsquelleAutor Qwerty
  4. 0

    Vieux, mais l'ajout d'une note pour quelqu'un d'autre qui est ici.

    Les docs (je suis à la recherche d'1.9.1 droit maintenant) dire que vous devriez être en mesure de le faire:

    var fn = () => { console.log('run'); };
var db = _.debounce(fn, 1000);
db();
db.cancel();

    Ce serait faire la chose que l'OP veut faire (et ce que je voulais faire). Il ne serait pas imprimer le message de la console.

    Je n'ai jamais pu obtenir que cela fonctionne. J'ai cherché haut et bas pour un .cancel(), comme promis, le trait de Soulignement doc et je ne le trouve pas.

    Si vous utilisez le trait de Soulignement, utilisez l'option d'indicateur dans la accepté de répondre par Carlos Ruana. Mes exigences lamentablement (à mon avis) ne permettent pas une mise à niveau (à mon avis) à partir de trait de Soulignement pour Lodash. Trait de soulignement a moins de fonctionnalités, mais il est plus fonctionnel que sans.

    InformationsquelleAutor Stephan Samuel