jQuery Callbacks disable() Method

What You’ll Learn

The disable() method permanently shuts down a jQuery Callbacks list so fire() no longer runs handlers. This tutorial covers syntax, five worked examples, how disable() differs from lock(), and when to use it during plugin teardown.

Introduction

A jQuery Callbacks list collects functions you trigger with fire(). Sometimes that list should stop forever — when a widget is destroyed, a page unloads, or a one-time workflow must never repeat. The disable() method is jQuery’s built-in “off switch” for the entire list.

After disable(), calling fire() does nothing: no handlers run, no errors throw. The change is permanent — jQuery does not ship an enable() method. Plan accordingly.

Understanding the disable() Method

callbacks.disable() takes no arguments and returns the same Callbacks object for chaining. Internally, jQuery marks the list as disabled and tears down the internal queue so future fire() calls exit immediately.

Do not confuse disable() with a pause button. It is teardown, not suspension. For a reversible pause, track your own boolean flag and skip fire() in application code, or simply stop calling fire().

📝 Syntax

General form of callbacks.disable:

callbacks.disable()

Parameters

• None.

Return value

• Returns the Callbacks object (chainable), though further operations on a disabled list have no effect.

Basic pattern

const callbacks = $.Callbacks();



callbacks.add(function () {

  console.log("Callback 1");

});



callbacks.add(function () {

  console.log("Callback 2");

});



callbacks.disable();



callbacks.fire(); // no output — list is disabled

Examples Gallery

Each example shows a different aspect of disable(). Use the Try-it links to run them in the browser.

const callbacks = $.Callbacks();



callbacks.add(function () {

  console.log("Callback 1");

});



callbacks.add(function () {

  console.log("Callback 2");

});



callbacks.disable();

callbacks.fire(); // no output

(no console output)

const callbacks = $.Callbacks();



callbacks.add(function () {

  console.log("Runs once");

});



callbacks.fire();

// → Runs once



callbacks.disable();

callbacks.fire(); // ignored

Runs once

const callbacks = $.Callbacks();



function safeFire(list, args) {

  if (list.disabled()) {

    console.log("Skipped — list disabled");

    return;

  }

  list.fire.apply(list, args);

}



callbacks.add(function () {

  console.log("Handler");

});



callbacks.disable();

safeFire(callbacks, []);

// → Skipped — list disabled

Skipped — list disabled

const locked = $.Callbacks();

locked.add(function () { console.log("locked: fired"); });

locked.lock();

locked.fire(); // → locked: fired



const disabled = $.Callbacks();

disabled.add(function () { console.log("disabled: fired"); });

disabled.disable();

disabled.fire(); // no output

locked: fired

const Widget = (function () {

  const onDestroy = $.Callbacks();



  function destroy() {

    onDestroy.fire("destroying");

    onDestroy.disable();

    console.log("Widget torn down, hooks disabled");

  }



  return { onDestroy: onDestroy, destroy: destroy };

})();



Widget.onDestroy.add(function (phase) {

  console.log("Cleanup:", phase);

});



Widget.destroy();

Widget.onDestroy.fire(); // no-op — already disabled

Cleanup: destroying

Widget torn down, hooks disabled

🚀 Use Cases

• Plugin destroy — shut down internal Callbacks lists when a widget unmounts.
• One-time workflows — disable after a migration or init routine completes.
• Error containment — disable a bus after a fatal error to prevent cascading handlers.
• Testing — verify that code respects disabled() and does not expect re-enable.
• Memory hygiene — release callback references when a SPA route tears down.

📝 Notes

• disable() is permanent — there is no built-in enable().
• Not the same as lock(), which blocks add()/remove() but still allows fire().
• After disable, add() in jQuery 3.7+ has no effect on the cleared internal list.
• disabled() returns true after shutdown — use it for defensive checks.
• To wipe handlers but keep the list active, use empty() instead of disable().

💡 Best Practices