$.Deferred()?$.Deferred() (same as jQuery.Deferred()) is a factory that returns a new Deferred object (since jQuery 1.5). Officially it creates a chainable utility for registering callbacks, invoking them, and relaying success or failure of sync or async work — the same pattern used by $.ajax().
var dfd = $.Deferred(); // pending
dfd.done(fn); // success queue
dfd.fail(fn); // failure queue
dfd.resolve(value); // → resolved (done runs)
dfd.reject(reason); // → rejected (fail runs)
// Share safely with callers:
return dfd.promise();| Need | Use |
|---|---|
| Create a Deferred | $.Deferred() |
| Mark success | dfd.resolve(value) |
| Mark failure | dfd.reject(reason) |
| Export read-only API | dfd.promise() |
$.Deferred()Create, attach handlers, settle when the work finishes.
$.Deferred() (optionally with a beforeStart function).done / fail / then / always handlers.resolve() or reject() once when finished.promise() if other code should listen but not settle.| Piece | Required? | Role |
|---|---|---|
| beforeStart | No | Runs with the new Deferred as this and as arg 1 |
| Handlers | Usually | done, fail, then, always, … |
| Return | — | New Deferred object |
Deferred([beforeStart]):
create object in state = pending
if beforeStart: call it(deferred)
return deferred
on resolve(args):
if already settled: ignore
state = resolved
run done / then success / always queues
on reject(args):
if already settled: ignore
state = rejected
run fail / then fail / always queues
promise():
return read-only view (no resolve / reject)Core facts for the Deferred factory.
| Topic | Detail |
|---|---|
| Syntax | jQuery.Deferred( [ beforeStart ] ) |
| Alias | $.Deferred( [ beforeStart ] ) |
| Starts as | pending |
| Success | resolve() / resolveWith() |
| Failure | reject() / rejectWith() |
| Safe export | promise() (no settle methods) |
| Late handlers | Still run immediately if already settled |
| Since | jQuery 1.5 |
Create a Deferred and compare resolve, reject, locked state, and promise().
Short, copy-ready snippets. Open DevTools Console, or use Try It Yourself for a live editor.
Factory → attach done() → resolve() with a value.
var dfd = $.Deferred();
dfd.done(function (value) {
console.log("done:", value);
});
dfd.resolve("Hello from Deferred");
// done: Hello from Deferred$.Deferred() starts in pending.done() registers a success handler.resolve(...) locks the state and runs the queue.Same factory; use fail() and reject() for the error path.
var dfd = $.Deferred();
dfd.fail(function (reason) {
console.log("fail:", reason);
});
dfd.reject("Validation failed");
// fail: Validation failedfail() waits for rejection.reject(...) runs fail handlers; done is skipped.promise()Keep the Deferred private; callers only get a read-only promise.
function loadConfig() {
var dfd = $.Deferred();
setTimeout(function () {
dfd.resolve({ theme: "dark", lang: "en" });
}, 300);
return dfd.promise(); // no resolve / reject for callers
}
loadConfig().done(function (cfg) {
console.log(cfg.theme, cfg.lang);
});
// dark enloadConfig can settle it.promise() lets callers attach done / fail.resolve early by accident.Wrap delayed work that can succeed or fail; return a promise.
function fetchTotal(ok) {
var dfd = $.Deferred();
setTimeout(function () {
if (ok) {
dfd.resolve(42);
} else {
dfd.reject("Service down");
}
}, 200);
return dfd.promise();
}
fetchTotal(true)
.done(function (n) { console.log("Total:", n); })
.fail(function (err) { console.log("Error:", err); });
// Total: 42done / fail (or then / catch).beforeStartPass a function to $.Deferred(); it runs with the new Deferred as this.
var dfd = $.Deferred(function (deferred) {
// deferred === this
setTimeout(function () {
deferred.notify("working…");
deferred.resolve("task complete");
}, 200);
});
dfd.progress(function (msg) {
console.log("progress:", msg);
});
dfd.done(function (result) {
console.log("done:", result);
});
// progress: working…
// done: task completeWatch these when building custom Deferred helpers.
After the first settle, the state never changes. Extra resolve() calls do nothing.
promise(), not the DeferredHanding out the full Deferred lets callers settle your task early. Prefer promise().
Adding done() to an already-resolved Deferred runs the callback immediately with the stored args.
Reuse a settled Deferred for a new request only if you create a fresh one — never “reset” an old object.
PromisejQuery Deferred is Promises/A-inspired and jQuery-specific. Prefer Deferred APIs inside jQuery code; use native Promise when you leave the jQuery stack.
$.Deferred() is part of jQuery’s Deferred API (since 1.5). It works in any browser where your jQuery build runs.
Supported wherever jQuery 1.5+ is loaded — Chrome, Firefox, Safari, Edge, and other browsers with a matching jQuery build.
Bottom line: Use $.Deferred() whenever you need jQuery-style async control. Load jQuery 1.5+ (3.x recommended for modern projects).
| Operation | Cost | Best for |
|---|---|---|
$.Deferred() | O(1) create | One object per async task |
| Attach handlers | O(1) each | Queuing done / fail / then |
| resolve / reject | O(n) handlers | Running queued callbacks once |
Creating a Deferred is cheap. Cost grows with how many handlers you attach and how heavy each callback is. Keep settle handlers short — update UI, map a value, or forward an error message.
resolve or reject locks the state forever.promise() so callers listen but cannot settle.One line: $.Deferred() creates the object you resolve or reject — return promise() when sharing it.
Attach success callbacks that run when a Deferred is resolved.
8 people found this page helpful