remove()?callbacks.remove(callbacks) removes a function — or an array of functions — from a Callbacks list (since jQuery 1.7). Later fire() calls skip those handlers. Returns the same Callbacks object for chaining.
callbacks.add(foo)
callbacks.fire("hello") // foo runs
callbacks.remove(foo)
callbacks.fire("world") // nothing — foo is gone
remove(fn) // one handler
remove([a, b]) // several at once| Need | Use |
|---|---|
| Register | cbs.add(fn) |
| Unregister one / some | cbs.remove(fn) or cbs.remove([a, b]) |
| Clear all | cbs.empty() |
| Still registered? | cbs.has(fn) |
remove()Keep the reference, then remove it when you unsubscribe.
add() them to the list and use fire() as needed.remove(fn) or remove([fn1, fn2]) to unsubscribe.has(fn) — expect false.| Piece | Required? | Role |
|---|---|---|
callbacks | Yes | Function or array of functions to remove |
| Return | — | Same Callbacks object (chainable) |
function remove(callbacks, targets):
for each fn in (targets as list):
if fn is in callbacks.list: // reference match
delete fn from list
return callbacksTargeted unsubscribe — not a full clear.
Add, fire, remove, and fire again — watch which handlers still run.
Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.
Official style: add, fire, remove, fire again.
var foo = function (value) {
console.log("foo: " + value);
};
var callbacks = $.Callbacks();
callbacks.add(foo);
callbacks.fire("hello");
// foo: hello
callbacks.remove(foo);
callbacks.fire("world");
// (no output)foo.foo.Pass an array to unregister more than one handler.
var lines = [];
var a = function () { lines.push("a"); };
var b = function () { lines.push("b"); };
var c = function () { lines.push("c"); };
var cbs = $.Callbacks();
cbs.add(a).add(b).add(c);
cbs.remove([a, b]);
cbs.fire();
console.log(lines.join("")); // "c"c.has()Membership flips after a successful remove.
var onReady = function () {
console.log("ready");
};
var cbs = $.Callbacks();
cbs.add(onReady);
console.log(cbs.has(onReady)); // true
cbs.remove(onReady);
console.log(cbs.has(onReady)); // falseonReady.true.false.remove() vs empty()Pick one handler to drop, or clear the whole list.
var lines = [];
var keep = function () { lines.push("keep"); };
var drop = function () { lines.push("drop"); };
var cbs = $.Callbacks();
cbs.add(keep).add(drop);
cbs.remove(drop); // only drop is gone
cbs.fire();
console.log(lines.join(",")); // keep
cbs.empty(); // clears keep too
cbs.fire();
console.log(lines.join(",")); // keep (unchanged)keep on the list.keep.lines.Most failures come from losing the original function reference.
add(function(){}) then remove(function(){}) fails — different objects, same text.
Use empty() instead of removing every handler one by one.
remove(fn) quietly does nothing if fn is not on the list.
fired()Removing handlers does not clear the fired flag — that tracks past fire() / fireWith() calls.
callbacks.remove() has shipped since jQuery 1.7 with $.Callbacks. It works in all modern browsers with jQuery loaded.
Unregister a function or array of functions from the Callbacks list.
Bottom line: Pass the same function reference you added. Use empty() when you need to clear everything.
| Approach | Cost | Best for |
|---|---|---|
remove(fn) | O(n) scan | Drop one subscriber |
remove([a,b]) | O(n × k) | Drop a small batch |
empty() | O(1) clear | Wipe the whole list |
Lists are usually short. Prefer named handlers and targeted remove for unsubscribe paths.
add()ed.One line: remove(fn) unsubscribes the same function object you added.
Clear every handler from a Callbacks list in one call.
8 people found this page helpful