jQuery Callbacks has() Method

What You’ll Learn

The has() method checks whether a specific function reference is already registered on a Callbacks list. This tutorial covers syntax, five examples, how it compares with add() and remove(), and patterns for avoiding duplicate subscriptions.

Introduction

You use add() to register handlers and fire() to run them. But what if the same handler gets added twice by mistake — or you need to know whether a subscriber is already on the list before calling remove()?

has() answers that membership question. Pass the function reference you care about; jQuery returns true if that exact function is currently stored in the list.

Understanding the has() Method

callbacks.has(callback) performs a lookup by reference equality. It returns true only when the same function object you pass was previously added with add() and has not been removed with remove() or cleared with empty().

It does not accept flags, does not tell you whether the list is empty, and does not track whether fire() has run. The old reference incorrectly documented has(flags) and has() with no arguments — neither matches jQuery’s actual API.

📝 Syntax

General form of callbacks.has:

callbacks.has( callback )

Parameters

• callback — The function reference to look up in the list.

Return value

• true if the callback is registered; false otherwise.

Basic pattern

const callbacks = $.Callbacks();



function onReady() {

  console.log("Ready!");

}



callbacks.add(onReady);

console.log(callbacks.has(onReady)); // true



function otherHandler() {}

console.log(callbacks.has(otherHandler)); // false

Examples Gallery

Each example shows a different way to use the boolean from has().

const callbacks = $.Callbacks();



function onReady() {

  console.log("Ready!");

}



function onError() {}



callbacks.add(onReady);



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

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

has(onReady): true

has(onError): false

const callbacks = $.Callbacks();

const handler = function () { console.log("Handler ran"); };



console.log("Before add:", callbacks.has(handler)); // false



callbacks.add(handler);

console.log("After add:", callbacks.has(handler));  // true



callbacks.fire(); // Handler ran

Before add: false

After add: true

Handler ran

const callbacks = $.Callbacks();

const handler = function () { console.log("Subscribed"); };



function subscribe(fn) {

  if (!callbacks.has(fn)) {

    callbacks.add(fn);

    console.log("Added handler");

  } else {

    console.log("Already subscribed — skipped");

  }

}



subscribe(handler);

subscribe(handler); // duplicate attempt

Added handler

Already subscribed — skipped

const callbacks = $.Callbacks();

const handler = function () { console.log("Tick"); };



callbacks.add(handler);

console.log("After add:", callbacks.has(handler));    // true



callbacks.remove(handler);

console.log("After remove:", callbacks.has(handler)); // false

After add: true

After remove: false

const callbacks = $.Callbacks();



const stored = function () { console.log("A"); };

callbacks.add(stored);



const lookalike = function () { console.log("A"); };



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

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

has(stored): true

has(lookalike): false

🚀 Use Cases

• Duplicate prevention — guard add() when the same handler might register twice.
• Safe unsubscribe — verify membership before calling remove().
• Plugin APIs — expose isSubscribed(fn) backed by has(fn).
• Unit tests — assert a mock handler was registered on a Callbacks list.
• Conditional wiring — attach optional listeners only when not already present.

📝 Notes

• has() requires a callback argument — it does not accept flags.
• Matching is by reference, not by function source code or name.
• Adding the same reference twice makes has() true, but fire() will run it twice.
• has() is unrelated to fired() (invocation history) and disabled() (shutdown status).
• After empty(), every previous handler returns false from has().

💡 Best Practices