jQuery Callbacks fired() Method

What You’ll Learn

The fired() method asks whether a Callbacks list has been invoked at least once via fire() or fireWith(). It returns a boolean and changes nothing. This tutorial covers syntax, five examples, and how it pairs with fire(), the once flag, and disabled().

Introduction

After you call fire(), handlers run — but other code may need to know whether that already happened. Did initialization fire? Should a late subscriber expect replay (with the memory flag)? Should we skip a second trigger?

fired() answers those questions. It is the status companion to fire(), just as disabled() complements disable().

Understanding the fired() Method

callbacks.fired() returns true once fire() or fireWith() has executed on that list at least one time. On a brand-new list that has never fired, it returns false.

It does not tell you whether individual handlers ran successfully, nor does it accept flags or arguments. The old reference incorrectly documented fired(flags) — that parameter does not exist in jQuery.

📝 Syntax

General form of callbacks.fired:

callbacks.fired()

Parameters

• None.

Return value

• true if the list has fired at least once; false otherwise.

Basic pattern

const callbacks = $.Callbacks();



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



callbacks.fire();

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

Examples Gallery

Each example shows a different use of the boolean from fired().

const callbacks = $.Callbacks();



console.log("Before fire:", callbacks.fired()); // false



callbacks.add(function () {

  console.log("Handler ran");

});



callbacks.fire();

console.log("After fire:", callbacks.fired());  // true

Before fire: false

Handler ran

After fire: true

const callbacks = $.Callbacks("once");



callbacks.add(function () { console.log("Runs once"); });



callbacks.fire();

callbacks.fire(); // ignored by once flag



console.log("fired():", callbacks.fired()); // true

Runs once

fired(): true

const onReady = $.Callbacks("once");



function triggerReady() {

  if (onReady.fired()) {

    console.log("Already initialized — skipping");

    return;

  }

  onReady.fire("ready");

}



onReady.add(function (msg) { console.log("Init:", msg); });



triggerReady(); // → Init: ready

triggerReady(); // → Already initialized — skipping

Init: ready

Already initialized — skipping

const callbacks = $.Callbacks("memory");



callbacks.fire("app-ready");

console.log("After early fire, fired():", callbacks.fired()); // true



callbacks.add(function (state) {

  console.log("Late handler:", state);

});

// → Late handler: app-ready  (memory replays args)

After early fire, fired(): true

Late handler: app-ready

const callbacks = $.Callbacks();



callbacks.fire();

console.log("fired:", callbacks.fired());     // true

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



const dead = $.Callbacks();

console.log("never fired:", dead.fired());      // false

dead.disable();

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

fired: true

disabled: false

never fired: false

disabled: true

🚀 Use Cases

• Init guards — prevent double-firing setup callbacks.
• Late subscribers — branch logic when fired() is already true (often with memory).
• Plugin lifecycle — expose isReady() backed by fired().
• Unit tests — assert fire() was called on a spy list.
• Debugging — explain why a second fire() on a once list did nothing.

📝 Notes

• fired() takes no parameters — flags belong on $.Callbacks() at creation.
• fireWith() also sets the fired state to true.
• After the first fire, fired() remains true even if handlers are later empty()d.
• Do not confuse with disabled(), which tracks disable() instead.
• On disabled lists, fired() still reflects whether fire happened before disable.

💡 Best Practices