jQuery Callbacks disabled() Method

What You’ll Learn

The disabled() method asks a simple question: has this Callbacks list been shut down with disable()? It returns true or false and does not change anything. This tutorial covers syntax, five examples, and how it pairs with disable(), locked(), and safe-fire patterns.

Introduction

jQuery Callbacks lists can be permanently shut down with disable(). After teardown, you often need to know whether firing is still allowed — especially in shared utilities, plugin APIs, or code that runs long after initialization.

That is what disabled() is for. It is a status query, not an action. Calling it never disables or enables the list; it only reports the current state.

Understanding the disabled() Method

callbacks.disabled() returns true if disable() has been called on that list, and false otherwise. On a brand-new $.Callbacks() object, it always starts as false.

The old misconception — treating disabled() as the way to turn callbacks off — is incorrect. The action method is disable(); disabled() only reads the result.

📝 Syntax

General form of callbacks.disabled:

callbacks.disabled()

Parameters

• None.

Return value

• true if the list has been disabled; false if it is still active (never had disable() called).

Correct usage pattern

const callbacks = $.Callbacks();



console.log(callbacks.disabled()); // false



callbacks.disable();



console.log(callbacks.disabled()); // true

Examples Gallery

Each example shows a different way to use the boolean returned by disabled().

const callbacks = $.Callbacks();



console.log("Disabled?", callbacks.disabled()); // false



callbacks.add(function () {

  console.log("Handler runs");

});



callbacks.fire(); // → Handler runs

Disabled? false

Handler runs

const callbacks = $.Callbacks();



callbacks.add(function () {

  console.log("Callback 1 executed");

});



callbacks.add(function () {

  console.log("Callback 2 executed");

});



callbacks.fire();

// → Callback 1 executed

// → Callback 2 executed



callbacks.disable();

console.log("Disabled?", callbacks.disabled()); // true



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

Callback 1 executed

Callback 2 executed

Disabled? true

function safeFire(callbacks, args) {

  if (callbacks.disabled()) {

    console.warn("Callbacks list is disabled — skipping fire");

    return;

  }

  callbacks.fire.apply(callbacks, args);

}



const hooks = $.Callbacks();

hooks.add(function (msg) { console.log("Hook:", msg); });

hooks.disable();



safeFire(hooks, ["late call"]);

// → Callbacks list is disabled — skipping fire

Callbacks list is disabled — skipping fire

const AppBus = (function () {

  const events = $.Callbacks();



  return {

    on: function (fn) {

      if (events.disabled()) {

        console.log("Cannot subscribe — bus disabled");

        return;

      }

      events.add(fn);

    },

    emit: function (data) { events.fire(data); },

    shutdown: function () { events.disable(); }

  };

})();



AppBus.on(function (d) { console.log("Got:", d); });

AppBus.emit("hello");     // → Got: hello

AppBus.shutdown();

AppBus.on(function () {}); // → Cannot subscribe — bus disabled

Got: hello

Cannot subscribe — bus disabled

const locked = $.Callbacks();

locked.lock();

console.log("locked:", locked.locked());     // true

console.log("disabled:", locked.disabled()); // false



const disabled = $.Callbacks();

disabled.disable();

console.log("locked:", disabled.locked());     // false

console.log("disabled:", disabled.disabled()); // true

locked: true

disabled: false

locked: false

disabled: true

🚀 Use Cases

• Defensive fire helpers — skip or warn when a list is already disabled.
• Plugin public API — expose isDestroyed() backed by disabled().
• Unit tests — assert teardown called disable() by expecting disabled() to be true.
• Conditional UI — hide “Subscribe” buttons when the event bus is off.
• Debugging — log list state when mysterious silent no-ops occur.

📝 Notes

• disabled() is read-only — it never disables or enables the list.
• Use disable() for the shutdown action; use disabled() to test the result.
• Once disabled() returns true, it stays true for that object.
• Do not confuse with locked(), which tracks lock() instead.
• fire() on a disabled list is safe but silent — guards are optional but helpful.

💡 Best Practices