jQuery Callbacks empty() Method

Beginner

6 min read

Updated: Oct 2026

5 examples

Live preview

jQuery callbacks.empty() — remove all handlers from a Callbacks list

Definition

What Is `empty()`?

callbacks.empty() removes all callbacks from a list (since jQuery 1.7). The official API: remove all of the callbacks from a list. The list stays reusable — you can add() again. Returns the same Callbacks object for chaining.

Remember

callbacks.add(foo)
callbacks.add(bar)
callbacks.empty()

callbacks.has(foo)  → false
callbacks.has(bar)  → false

callbacks.add(newFn)  // still allowed
callbacks.fire()      // runs newFn only

Need	Use
Clear every handler	`cbs.empty()`
Drop one handler	`cbs.remove(fn)`
Shut down forever	`cbs.disable()`
Check membership	`cbs.has(fn)`

Approach

How to Use `empty()`

Call it when you want a clean slate but still need the same list object.

Register handlers with add() as usual.
Call empty() to wipe every handler in one step.
Optionally verify with has(fn) → false.
Re-add() new handlers and fire() when ready.

Piece	Required?	Role
Callbacks object	Yes	List to clear
Arguments	None	`empty()` takes no parameters
Return	—	Same Callbacks object (chainable)

Pseudocode

list = [fn1, fn2, …]

empty():
  if list is locked:
    ignore
  else:
    list = []          // remove all handlers
  return Callbacks     // still active (unless disabled)

fire(args…):
  for each fn in list:
    call fn(args…)     // no-op when list is []

Reference

Cheat Sheet

Keep these facts handy when resetting Callbacks lists.

Topic	Detail
Syntax	`callbacks.empty()`
Arguments	None
Effect	Removes every registered handler
Reusable?	Yes — `add()` / `fire()` still work
vs `remove()`	All vs specific references
vs `disable()`	Clear vs permanent shutdown
Since	jQuery 1.7

Try it

Live Preview

Compare clear, reuse, remove, and chain patterns on a fresh list.

Browser demo of callbacks.empty — same ideas as the examples below.

Result

add(foo, bar); empty(); fire()
→ (no output)

Code

jQuery Examples

Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.

Example 1 — Clear All Callbacks

Add two handlers, call empty(), then fire() — silent.

jQuery

var callbackList = $.Callbacks();

callbackList.add(function () { console.log("Callback 1"); });
callbackList.add(function () { console.log("Callback 2"); });

callbackList.empty();
callbackList.fire(); // no output

Try It Yourself

How It Works

Register. Two handlers join the list.
Empty. Both are removed in one call.
Fire. The queue is empty → nothing prints.
Note. The list object is still alive for future add().

Example 2 — Empty, Then Add Fresh Handlers

The list remains usable — register new callbacks after clearing.

jQuery

var callbacks = $.Callbacks();

callbacks.add(function () { console.log("Old handler"); });
callbacks.empty();

callbacks.add(function () { console.log("New handler"); });
callbacks.fire();
// → New handler

Try It Yourself

How It Works

Old handler. Added, then wiped by empty().
New handler. add() still works on the same list.
Fire. Only the new handler runs.
vs disable. disable() would block this reuse entirely.

Example 3 — `empty()` vs `remove()`

remove(fn) drops one handler; empty() clears the rest.

jQuery

var callbacks = $.Callbacks();

function loggerA() { console.log("A"); }
function loggerB() { console.log("B"); }

callbacks.add(loggerA, loggerB);
callbacks.remove(loggerA);
callbacks.fire();
// → B

callbacks.empty();
callbacks.fire(); // no output

Try It Yourself

How It Works

Add both. loggerA and loggerB are registered.
Remove one. Only A is dropped → fire prints B.
Empty. The remaining handler is cleared.
Rule. Surgical unsubscribe → remove; full reset → empty.

Example 4 — Reset an Event Bus Between Steps

Clear subscribers when moving to a new wizard step or route.

jQuery

var StepBus = (function () {
  var onEnter = $.Callbacks();

  return {
    onEnter: onEnter,
    enterStep: function (name) {
      onEnter.fire(name);
    },
    reset: function () {
      onEnter.empty();
      console.log("Bus reset for next step");
    }
  };
})();

StepBus.onEnter.add(function (s) { console.log("Enter:", s); });
StepBus.enterStep("billing");  // → Enter: billing
StepBus.reset();
StepBus.enterStep("review");   // no output — no handlers

Try It Yourself

How It Works

Subscribe. Step-one handlers attach to onEnter.
Enter billing. Handlers run for that step.
Reset. empty() drops stale listeners.
Next step. Fire finds no handlers until you re-subscribe.

Example 5 — Chain `empty().add().fire()`

empty() returns the list, so you can replace handlers in one fluent chain.

jQuery

var callbacks = $.Callbacks();

callbacks
  .add(function () { console.log("v1"); })
  .fire(); // → v1

callbacks
  .empty()
  .add(function () { console.log("v2"); })
  .fire(); // → v2

Try It Yourself

How It Works

First chain. Add v1 and fire → v1.
Empty. Clears v1; returns the same object.
Add v2 and fire. Only the new handler runs.
Fluent API. Same pattern as other chainable Callbacks methods.

Edge Cases & Pitfalls

Check these before using empty() as a reset.

alive

List stays active

empty() is not disable(). New add() / fire() calls still work.

lock

Locked lists ignore `empty()`

After lock(), membership is frozen — empty() / add() / remove() do not change the list.

disable

Empty does not undo disable

If disable() already ran, clearing handlers does not re-enable firing.

memory

Flags stay the same

empty() does not change once / memory / unique behavior set at creation.

verify

Confirm with `has()`

After empty(), has(fn) returns false for previously registered references — the official check.

Compatibility

Browser Support

callbacks.empty() is part of jQuery’s Callbacks API (since 1.7). It works in any browser where your jQuery build runs — the list logic lives in jQuery, not as a separate browser API.

✓ jQuery 1.7+ · Browsers

jQuery callbacks.empty()

Supported in jQuery 1.x, 2.x, and 3.x across Chrome, Firefox, Safari, Edge, and other browsers with jQuery loaded.

100% With jQuery loaded

Google Chrome All versions · Desktop & Mobile

Full support

Mozilla Firefox All versions · Desktop & Mobile

Full support

Apple Safari All versions · macOS & iOS

Full support

Microsoft Edge All versions · Chromium & Legacy

Full support

Internet Explorer IE 6+ · Legacy environments

Full support

Opera All modern versions

Full support

callbacks.empty() Browsers

Bottom line: Safe wherever jQuery is loaded. Use empty() to reset handlers; use disable() when the list must never fire again.

Analysis

Performance Notes

Operation	Cost	Best for
`empty()`	O(1) clear*	Full reset without naming handlers
`remove(fn)`	O(n) scan	Dropping one known reference
Many `remove`s	O(n × k)	Prefer one `empty()` instead

*Implementation details vary, but clearing the whole list is cheaper than removing handlers one by one when you want none left. Reuse the same Callbacks object after empty() instead of allocating a new one every time — unless you also need different flags.

Remember

Key Takeaways

Role: wipe every handler in one call.
Reusable: the list stays active for new add() / fire().
vs remove: all handlers vs one reference.
Verify: has(fn) returns false after a successful clear.

One line: empty() resets the queue without killing the bus.

Frequently Asked Questions

What does callbacks.empty() do in jQuery?

empty() removes every handler from the Callbacks list in one call. After empty(), fire() runs nothing until you add() new functions. The list itself stays active — unlike disable(), which permanently shuts down firing.

What is the difference between empty() and remove()?

remove(fn) drops specific function references you pass in. empty() wipes the entire list at once — useful when you want a clean slate without tracking each handler.

What is the difference between empty() and disable()?

empty() clears handlers but the list can still accept add() and fire() afterward. disable() permanently prevents all future firing; disabled() stays true.

Does empty() return anything useful?

Yes. It returns the same Callbacks object, so you can chain: callbacks.empty().add(fn).fire().

How do I verify the list is empty?

Use has(fn) for a known reference — after empty(), has(foo) returns false for every previously registered function. That matches the official API example.

Does empty() work on a locked or disabled list?

On a locked list, empty() is ignored (membership is frozen). On a disabled list, clearing handlers does not re-enable firing — disabled() stays true. Prefer empty() on active lists you plan to reuse.

Next: has()

Check whether a Callbacks list has any handlers or a specific one.

has() tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

8 people found this page helpful

jQuery callbacks.remove() Method jQuery callbacks.has() Method

jQuery Callbacks empty() Method

What Is empty()?

How to Use empty()

Pseudocode

Cheat Sheet

Live Preview

jQuery Examples

Example 1 — Clear All Callbacks

How It Works

Example 2 — Empty, Then Add Fresh Handlers

How It Works

Example 3 — empty() vs remove()

How It Works

Example 4 — Reset an Event Bus Between Steps

How It Works

Example 5 — Chain empty().add().fire()

How It Works

Edge Cases & Pitfalls

List stays active

Locked lists ignore empty()

Empty does not undo disable

Flags stay the same

Confirm with has()

Browser Support

jQuery callbacks.empty()

Performance Notes

Key Takeaways

Frequently Asked Questions

Related Topics

callbacks.remove()

callbacks.disable()

callbacks.has()

callbacks.add()

callbacks.fire()

callbacks.lock()

Next: has()

About the author

What Is `empty()`?

How to Use `empty()`

Example 3 — `empty()` vs `remove()`

Example 5 — Chain `empty().add().fire()`

Locked lists ignore `empty()`

Confirm with `has()`