JavaScript/JQuery: $(window).resize how to fire AFTER the resize is completed?

JavaScript/JQuery: $(window).resize how to fire AFTER the resize is completed?

I’m using JQuery as such:
$(window).resize(function() { … });

However, it appears that if the person manually resizes their browser windows by dragging the window edge to make it larger/smaller, the .resize event above fires multiple times.
Question: How to I call a function AFTER the browser window resize completed (so that the event only fires once)?


Solution 1:

Here’s a modification of CMS’s solution that can be called in multiple places in your code:

var waitForFinalEvent = (function () {
  var timers = {};
  return function (callback, ms, uniqueId) {
    if (!uniqueId) {
      uniqueId = "Don't call this twice without a uniqueId";
    if (timers[uniqueId]) {
      clearTimeout (timers[uniqueId]);
    timers[uniqueId] = setTimeout(callback, ms);


$(window).resize(function () {
    }, 500, "some unique string");

CMS’s solution is fine if you only call it once, but if you call it multiple times, e.g. if different parts of your code set up separate callbacks to window resizing, then it will fail b/c they share the timer variable.

Related:  How to use simulate the action of clicking button with jQuery or JavaScript?

With this modification, you supply a unique id for each callback, and those unique IDs are used to keep all the timeout events separate.

Solution 2:

I prefer to create an event:

$(window).bind('resizeEnd', function() {
    //do something, window hasn't changed size in 500ms

Here is how you create it:

 $(window).resize(function() {
        if(this.resizeTO) clearTimeout(this.resizeTO);
        this.resizeTO = setTimeout(function() {
        }, 500);

You could have this in a global javascript file somewhere.

Solution 3:

I use the following function for delaying repeated actions, it will work for your case:

var delay = (function(){
  var timer = 0;
  return function(callback, ms){
    clearTimeout (timer);
    timer = setTimeout(callback, ms);


$(window).resize(function() {
    }, 500);

The callback function passed to it, will execute only when the last call to delay has been made after the specified amount of time, otherwise a timer will be reset, I find this useful for other purposes like detecting when the user stopped typing, etc…

Solution 4:

If you have Underscore.js installed, you could:


Solution 5:

Some of the previously mentioned solutions did not work for me, even though they are of more general usage. Alternatively I’ve found this one that did the job on window resize:

$(window).bind('resize', function(e){
        window.resizeEvt = setTimeout(function(){
        //code to do after window is resized
        }, 250);

Solution 6:

Many thanks to David Walsh, here is a vanilla version of underscore debounce.

Related:  What are useful JavaScript methods that extends built-in objects? [closed]


// 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.
function debounce(func, wait, immediate) {
    var timeout;
    return function() {
        var context = this, args = arguments;
        var later = function() {
            timeout = null;
            if (!immediate) func.apply(context, args);
        var callNow = immediate && !timeout;
        timeout = setTimeout(later, wait);
        if (callNow) func.apply(context, args);

Simple usage:

var myEfficientFn = debounce(function() {
    // All the taxing stuff you do
}, 250);

$(window).on('resize', myEfficientFn);