Free tools Windows power users keep installed
One-click scans. No signup required.
console.log(getValue()) shows a Promise because getValue() returns an object for a result that will be available later—not the result itself. To log the actual value, handle the Promise with await or .then(). The exact display, such as Promise {}, varies by JavaScript runtime and console.
What Promise {} means
A Promise represents the eventual success or failure of an asynchronous operation. When you call a function that returns a Promise, JavaScript gives you that Promise object immediately; the operation’s fulfillment value may not be ready yet. That is why console.log(getValue()) logs the Promise rather than its eventual value. MDN’s Promise reference describes the object, and its debugging guide illustrates the same distinction with fetch().
The braces in a console’s rendering are not the operation’s eventual result. A Promise can be pending, fulfilled, or rejected. A pending Promise has no fulfillment value to log yet; a rejected Promise has an error reason rather than a successful value. Handle either outcome instead of relying on how the console displays the object.
How to log the fulfilled value
Use await with an async function
Use await when you want to work with the result in sequential statements. It pauses the surrounding async function until the Promise settles. If the Promise fulfills, the expression evaluates to its value; if it rejects, await throws the rejection reason, which you can catch.
#1 Best Overall
async function showValue() {
try {
const value = await getValue();
console.log(value);
} catch (error) {
console.error(error);
}
}
showValue();await is allowed inside an async function and at the top level of a JavaScript module. In a regular script, put it inside an async function as above. It does not block the entire main thread. See MDN’s await reference.
Use .then() and .catch()
A Promise handler is an alternative when you want to attach callbacks directly:
Rank #2
getValue()
.then((value) => {
console.log(value);
})
.catch((error) => {
console.error(error);
});The fulfillment callback receives the value; the rejection callback in .catch() handles failure. A Promise chain carries a handler’s returned value to the next fulfillment handler. If a later step depends on asynchronous work started in a handler, return that Promise so the chain can wait for it; otherwise, the work is not tracked by the chain. MDN explains this in its guide to using promises.
Which style should you choose?
| Approach | Typical context | Readability and error handling |
|---|---|---|
await |
Inside an async function or at module top level | Reads like sequential code; handle rejection with try/catch. |
.then() |
Any Promise chain | Composes callbacks; handle rejection with .catch() or a rejection handler. |
Both approaches wait for the asynchronous result and expose its fulfillment value. Neither makes the operation synchronous.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Why an async function still logs a Promise
Calling an async function always returns a Promise, even when its body returns an ordinary value. An await inside that function affects what the function does next; it does not make the caller receive a synchronous value.
async function getValue() {
return 42;
}
console.log(getValue()); // Promise objectThe caller must handle the returned Promise too:
getValue().then((value) => console.log(value));Or, from another async function, use const value = await getValue();. See MDN’s async function reference and its Promises tutorial.
Rank #4
Logging data from fetch()
fetch(url) returns a Promise for a Response, not the response body. Calling response.json() also returns a Promise. Await both operations to log the parsed data. If HTTP status errors should be treated as failures, check response.ok: a fulfilled fetch Promise does not by itself mean the server returned a successful status.
async function showData(url) {
try {
const response = await fetch(url);
if (!response.ok) throw new Error(`HTTP error: ${response.status}`);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}
}This pattern waits for the response, checks its HTTP status, then waits for body parsing before logging. The MDN Promises tutorial covers this sequence and error handling.
Recommended Free Tools
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
