What sets returning a promise from async or a regular function apart?

Question

What sets returning a promise from async or a regular function apart?

I have been pondering whether the async keyword is redundant when simply returning a promise for some time now.

Let's take a look at this example:

async function thePromise() {
    const v = await Inner();
    return v+1;
}

async function wrapper() {
    return thePromise();
}

I am questioning if, for the wrapper function, since it does not wait inside the promise for resolution, the async keyword is unnecessary. Shouldn't we just use:

function wrapper() {
    return thePromise();
}

The main downside to this approach is that it hides the fact that we are using promises, but other than that: is there any real distinction between returning a promise from an asynchronous function or a regular function?

javascript asynchronous async-await

Answer 1

Answer №1

Take a look at this straightforward example: -

let person = {
    name: 'Jessica'
}
// Creating a promise
let myPromise = new Promise((resolve, reject) => {
    if (person) {
        resolve(person.name==='Jessica')
    }
    else {
        reject(new Error("Oops!"))
    }
}
)

function handlePromise(){
    return myPromise;
}
// Using the promise
handlePromise().then(res => {
    if (res) {
        console.log("Promise fulfilled")
        console.log(person)
    }
    else {
        console.log("Promise rejected")
    }
})

Answer 2

Take a look at this straightforward example: -

let person = {
    name: 'Jessica'
}
// Creating a promise
let myPromise = new Promise((resolve, reject) => {
    if (person) {
        resolve(person.name==='Jessica')
    }
    else {
        reject(new Error("Oops!"))
    }
}
)

function handlePromise(){
    return myPromise;
}
// Using the promise
handlePromise().then(res => {
    if (res) {
        console.log("Promise fulfilled")
        console.log(person)
    }
    else {
        console.log("Promise rejected")
    }
})

Answer 3

Answer №2

In the realm of JavaScript, there is no concept of a Promise within a Promise; they are essentially the same.

// code snippet 1
promise1.then(() => {
  //...
  return promise2;
}).then(f);

// This is equivalent to code snippet 2

promise1.then(() => {
  //...
  return promise2.then(f);
});

A similar principle applies to async functions. When a promise is returned from an async function, it is akin to returning the awaited expression.

// code snippet 3
async () => {
  // ...
  return p;
}

// This is equivalent to code snippet 4
async () => {
  // ...
  return await p;
}

It's important to mention that this equivalence does not extend to arrays of promises and similar scenarios. In such cases, you can utilize Promise.all to transform the array of promises into a single promise or create custom solutions for other data structures.

Answer 4

In the realm of JavaScript, there is no concept of a Promise within a Promise; they are essentially the same.

// code snippet 1
promise1.then(() => {
  //...
  return promise2;
}).then(f);

// This is equivalent to code snippet 2

promise1.then(() => {
  //...
  return promise2.then(f);
});

A similar principle applies to async functions. When a promise is returned from an async function, it is akin to returning the awaited expression.

// code snippet 3
async () => {
  // ...
  return p;
}

// This is equivalent to code snippet 4
async () => {
  // ...
  return await p;
}

It's important to mention that this equivalence does not extend to arrays of promises and similar scenarios. In such cases, you can utilize Promise.all to transform the array of promises into a single promise or create custom solutions for other data structures.

What sets returning a promise from async or a regular function apart?

Answer №1

Answer №2

Similar questions

Update the data table after a new file has been uploaded

Issues with the audio on ExpressJS video streaming can be quite vexing

Pushing state history causes browser back and forward button failure

Tips for extracting dynamically loaded content from a website using Node.js and Selenium?

Tips for adjusting the size of an HTML canvas to fit the screen while preserving the aspect ratio and ensuring the canvas remains fully visible

Retrieve the parseJSON method using a string identifier

The error message "UnhandledPromiseRejectionWarning: Error: ENOTEMPTY: directory not empty" typically occurs

It appears that Vivus JS is having difficulty animating specific <path> elements

Tips for utilizing Vue.js techniques to assign values to data properties

Node.js (Express), passport.js, mongoose.js, and Android app all have in common the HTTP Error 307 - Temporary redirect

The function slice is not a method of _co

Jasmine and Karma encountered a TypeError stating that the function this.role.toLowerCase is not valid

Mixing success and error states can lead to confusion when using jQuery and Express together

Exploring AngularJS tab navigation and injecting modules into the system

Encountering 404 errors on dynamic routes following deployment in Next.JS

Rearranging components in React does not automatically prompt a re-render of the page

Can you explain the contrast between the functions 'remove' and 'removeChild' in JavaScript?

Facing problem with implementing NgMoudleFactoryLoader for lazy loading in Angular 8

Display two images consecutively within a single img tag

Dealing with the issue of receiving raw JavaScript in the .ajax error function even when receiving a 200