jQuery Callbacks locked() Method

What You’ll Learn

The locked() method asks whether a Callbacks list has been frozen with lock(). It returns a boolean and changes nothing. This tutorial covers syntax, five examples, and how it pairs with lock(), disabled(), and safe registration patterns.

Introduction

After you call lock(), the handler list is frozen — add(), remove(), and empty() silently do nothing. But other code may need to know whether that freeze already happened. Should we try to register a late handler? Is init complete?

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

Understanding the locked() Method

callbacks.locked() returns true once lock() has been called on that list. On a brand-new list that has never been locked, it returns false.

It does not lock the list, return a new Callbacks object, or limit how many handlers run on fire(). The old reference incorrectly showed var lockedCallbacks = myCallbacks.locked() and described concurrency control — that is not how jQuery works.

📝 Syntax

General form of callbacks.locked:

callbacks.locked()

Parameters

• None.

Return value

• true if the list has been locked; false otherwise.

Basic pattern

const callbacks = $.Callbacks();



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



callbacks.lock();

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

Examples Gallery

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

const callbacks = $.Callbacks();



console.log("Before lock:", callbacks.locked()); // false



callbacks.add(function () { console.log("Handler ran"); });

callbacks.lock();

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

Before lock: false

After lock: true

const callbacks = $.Callbacks();



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



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

console.log("Can still add:", !callbacks.locked());

locked(): false

Can still add: true

const hooks = $.Callbacks();



function subscribe(fn) {

  if (hooks.locked()) {

    console.log("Registration closed — cannot add handler");

    return;

  }

  hooks.add(fn);

}



hooks.lock();

subscribe(function () { console.log("Late handler"); });

Registration closed — cannot add handler

const callbacks = $.Callbacks();



callbacks.add(function () { console.log("Handler fired"); });

callbacks.lock();



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

callbacks.fire(); // → Handler fired

locked(): true

Handler fired

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

• Registration guards — warn when add() is attempted after init closed.
• Plugin APIs — expose isLocked() backed by locked().
• Unit tests — assert lock() ran after setup phase.
• Debugging — explain why late add() had no effect.
• Lifecycle checks — branch logic when init locked hooks but events should still fire.

📝 Notes

• locked() takes no parameters and returns a boolean only.
• It does not return a Callbacks object — that was a documentation error in older material.
• After lock(), locked() stays true permanently — no unlock() exists.
• Do not confuse with disabled(), which tracks disable() instead.
• fire() works when locked() is true; it does not when disabled() is true.

💡 Best Practices