Как избавиться от асинхронности в функции?

Любая функция, помеченная как async, вернет обещание. Этот:

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

Будет ли возвращено Promise 7. Это полностью не зависит от того, является ли функция, вызывающая foobar, async или нет, использует ли await или нет при ее вызове.

Итак, ваша проблема не (только) в myFunction: foobar использует async, что заставляет его всегда возвращать Promise.

Так вот, сказал это, ты, наверное, не сможешь достичь того, чего хочешь. Асинхронное ожидание только синтаксический сахар для обещаний. Вы пытаетесь использовать вернуть синхронное значение из асинхронной операции, а это в основном запрещено в javascript.

Здесь отсутствует очень важное понимание между синхронной и асинхронной природой кода.

Не каждую асинхронную функцию можно преобразовать в синхронную функцию. Вы можете использовать шаблон обратного вызова вместо await / async, но я сомневаюсь, что это будет вам полезно.

Вместо этого я бы рекомендовал вам просто использовать await, как в вашем первом примере кода, и оставить функции как асинхронные, это не должно повредить вашей логике.

Вы изучали возможность использования .executeAsync (), а затем обещание вызывать обратный вызов .done ()? Таким образом, должна быть возможность обернуть foobar и просто сохранить либо async, либо любые вызовы .then () внутри этой оболочки.

Мои знания о ночном дозоре очень устарели, но, возможно, что-то вроде:

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

или:

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

Чтобы преобразовать асинхронную функцию в обычную синхронную функцию, вам просто нужно отбросить ключевое слово async и, как результат, все ключевые слова await в этой функции.

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

// becomes

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

Однако вы должны помнить одно простое правило.

1. Вы не можете преобразовать асинхронную функцию в синхронную, если возвращаемое значение зависит от значения (значений) разрешенного обещания (й).

Это означает, что функции, которые обрабатывают обещания внутри своего тела, но от которых возвращаемое значение не зависит от этих разрешенных обещаний, прекрасно подходят как синхронные функции. В большинстве других сценариев вы не можете отказаться от асинхронного поведения.

Следующий код дает вам пример для вашей ситуации, предполагая, что возвращаемое значение моя функция не зависит от разрешенного обещания.

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

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

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

Если вы хотите узнать больше об обещаниях, я предлагаю проверить страницы гид обещаний и async / await.

Проверь это

    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.info(test)