如何在功能中摆脱异步？

Question

Let's say I have this code:

const myFunction = async => {
  const result = await foobar()
}

const foobar = async () => {
  const result = {}
  result.foo = await foo()
  result.bar = await bar()
  return result
}

And I want this:

const myFunction = () => {
  const result = foobar()
}

I tried to wrap foobar like this:

const foobar = async () => {
  return (async () => {
    const result = {}
    result.foo = await foo()
    result.bar = await bar()
    return result
  })()
}

But this still return a promise

I can't use .then in myFunction , I need that foobar returns the result variable instead a promise.

The problem is that myFunction is an async function and it will return a promise but It should return undefine I need to get rid of async in myFunction .

Edit: as Sebastian Speitel said, I want to convert myFunction to sync

Edit 2: to Shilly, I am using nightwatch for end2end test, nightwatch will call myFunction() if there are no errors in the execution of the function it will run perfectly, if there's an error then nightwatch's virtual machines will run forever instead stop, this problem happens if the called function is async.

Answer 1

To change an asynchronous function into a normal synchronous function you simply have to drop the async keyword and as a result all await keywords within that function.

const myFunction = async () => {
    const result = await foobar();
    // ...
    return 'value';
};

// becomes

const myFunction = () => {
    const result = foobar();
    // ...
    return 'value';
};

You should however keep one simple rule in mind.

1. You can't change a asynchronous function into a synchronous function if the return value depends on the value(s) of the resolved promise(s).

This means that functions that handle promises inside their body, but from whom the return value doesn't depend on those resolved promises are perfectly fine as synchronous functions. In most other scenarios you can't drop the asynchronous behaviour.

The following code gives you an example for your situation, assuming the return value of myFunction doesn't depend on the resolved promise.

const myFunction = () => {
    const result = foobar();

    result.then(data => doSomethingElse(data))
          .catch(error => console.error(error));

    return 'some value not dependent on the promise result';
};

If you want to learn more about promises I suggest checking out the promises guide and the async / await page.

Answer 2

Have you looked into using .executeAsync() and then having the promise call the .done() callback? That way it should be possible to wrap foobar and just keep either the async or any .then() calls inside that wrapper.

My nightwatch knowledge is very stale, but maybe something like:

() => {
  client.executeAsync(( data, done ) => {
    const result = await foobar();
    done( result );
  });
};

or:

  () => {
    client.executeAsync(( data, done ) => foobar().then( result => done( result )));
  };

Answer 3

Any function marked with async will return a Promise. This:

const foobar = async () => {
  return 7;
}

Will a return a Promise of 7. This is completely independent of wether the function that calls foobar is async or not, or uses await or not when calling it.

So, you're problem is not (only) with myFunction : is foobar using async which forces it to always return a Promise.

Now, said that, you probably can't achieve what you want . Async-Await is only syntax sugar for promises . What you're trying is to return a synchronous value from an asynchronous operation , and this is basically forbidden in javascript.

Answer 4

You're missing very important understanding here between the synchronous and asynchronous nature of the code.

Not every async function can be converted to synchronous function. You can use callback pattern instead of await/async, but I doubt that would be useful to you.

Instead I would recommend you just use await , as in your first code example, and leave functions as async, it shouldn't harm your logic.

Answer 5

Check this out

    function foo(){
      return 'foo'
    }
    function bar(){
      return 'bar'
    }
    const foobar = () => {
        return new Promise((resolve)=>{
          let result = {}
          result.foo = foo()
          result.bar = bar()
          return resolve(result)
        })
    }

    const myFunction = () => {
      const result = foobar()
      let response = {}
      result.then(val=>{
        response = Object.assign({}, val);
        return response
      });
    }

    var test = myFunction()
    console.log(test)