jQuery Deferred resolve() Method

What You’ll Learn

The resolve() method marks a jQuery Deferred as successful. It runs done() and then() handlers with your result value — and prevents fail() from firing. This tutorial covers syntax, five examples, comparisons with reject() and done(), and when to resolve vs reject.

Introduction

Async work eventually finishes — data loads, validation passes, animations complete. When you own a $.Deferred(), you signal success by calling resolve() — the mirror image of reject() for failure.

Listeners registered with done() or then() receive the result you pass. Consumers holding only a promise() cannot call resolve() — only the module that created the Deferred settles it.

Understanding the resolve() Method

resolve() transitions a pending Deferred into the resolved state. jQuery invokes every queued done(), then(), and success branch of always() handlers with the arguments you pass to resolve().

Once resolved, the state is permanent — you cannot reject() the same Deferred afterward. fail() handlers never run on a resolved Deferred.

📝 Syntax

General form of deferred.resolve:

deferred.resolve( [ args ] )

Parameters

• args (optional) — result value(s) forwarded to done() handlers: string, object, array, or multiple values.

Return value

• Returns the same Deferred object for chaining (though state is now locked to resolved).

Basic resolve + done handler

const dfd = $.Deferred();

dfd.done(function (message) {
  console.log("Success:", message);
});

dfd.resolve("Data successfully loaded");

Examples Gallery

Each example shows a common resolve() pattern. Use the Try-it links to run them interactively.

const dfd = $.Deferred();

dfd.done(function (message) {
  console.log(message);
});

setTimeout(function () {
  dfd.resolve("Data successfully loaded");
}, 500);

Data successfully loaded

const dfd = $.Deferred();

dfd.done(function (message) {
  console.log("Success:", message);
}).fail(function (error) {
  console.error("Error:", error);
});

setTimeout(function () {
  const conditionMet = true;

  if (conditionMet) {
    dfd.resolve("Operation completed successfully.");
  } else {
    dfd.reject("Operation failed: Condition not met.");
  }
}, 500);

Success: Operation completed successfully.

function settle(ok) {
  const dfd = $.Deferred();

  dfd.done(function (v) { console.log("resolved:", v); });
  dfd.fail(function (e) { console.log("rejected:", e); });

  if (ok) {
    dfd.resolve("OK");
    dfd.reject("Too late");  // ignored — already resolved
  } else {
    dfd.reject("Failed");
    dfd.resolve("Too late"); // ignored — already rejected
  }
}

settle(true);  // resolved: OK

resolved: OK

const dfd = $.Deferred();

dfd.done(function (status, body, meta) {
  console.log(status, body.label, meta.cached);
});

dfd.resolve(200, { label: "Users" }, { cached: true });

200 Users true

function saveUser(name) {
  const dfd = $.Deferred();

  if (!name || name.length < 2) {
    dfd.reject("Name must be at least 2 characters");
  } else {
    dfd.resolve({ saved: true, name: name });
  }

  return dfd.promise();
}

saveUser("Alex").done(function (result) {
  console.log("Saved:", result.name);
});

Saved: Alex

🚀 Use Cases

• Custom async helpers — wrap timers, workers, or third-party APIs and resolve when work completes.
• Successful AJAX — resolve in hand-rolled Deferred wrappers when HTTP status is OK.
• Animation completion — resolve when a CSS or jQuery animation finishes so the next step can run.
• Data processing — resolve with computed results after parsing, filtering, or transforming data.
• Promise chains — resolve propagates to downstream done() / then() handlers.

📝 Notes

• Only call resolve() on Deferreds you own — not on promises returned to you.
• Always pair public async APIs with consumer-side done() or then().
• Pass meaningful result values — objects, arrays, or structured tuples.
• state() returns "resolved" after resolve (preferred over deprecated isResolved() in jQuery 3+).
• For custom this in done handlers, use resolveWith() next.

💡 Best Practices