Question

我正在尝试使用await-async而不使用try-catch：

＆＃13;

const getUsers = async (reject, time) => (
  new Promise((resolve, reject) => {
    setTimeout(() => {
      if (reject) {
        reject(....)
      }
      resolve(.....);
    }, time);
  })
);

module.exports = {
  getUsers ,
};

＆＃13;

使用try-catch块，它看起来像这样：

＆＃13;

const { getUsers } = require('./users');

const users = async () => {
  try {
    const value = await getUsers(1000, false);
    .....
  } catch (error) {
    .....
  }
}

users();

＆＃13;

如何在不使用try-catch块的情况下编写相同的代码？

Answer 1

使用promise函数then-catch使过程更简单我使用这个utils：

// utils.js

const utils = promise => (
  promise
    .then(data => ({ data, error: null }))
    .catch(error => ({ error, data: null }))
);

module.exports = utils;

然后

const { getUsers } = require('./api');
const utils = require('./utils');

const users = async () => {
  const { error, data } = await utils(getUsers(2000, false));
  if (!error) {
    console.info(data);
    return;
  }
  console.error(error);
}

users();

不使用try-catch块我得到了相同的输出，这样可以更好地理解代码。

Answer 2

如果您有错误案例的有效默认值，则可以使用catch承诺上的getUsers方法，然后await将处理错误的承诺

const users = async () => {
    const value = await getUsers(1000, false).catch(e => null);
}

虽然这种方法应该有用，但应该注意的是，这可能会掩盖getUsers返回null与引发错误时的情况，并且您仍然需要检查{{1}或获取空访问错误。总而言之，我会坚持null为大多数casses

Answer 3

我发现一个名为await-to-js的软件包也可以提供帮助。

import to from 'await-to-js';

const [err, users] = await to(getUsers());
if(err) doSomething();

这个想法就像Lyes CHIOUKH的方法一样，只是包装。在此处复制source code。

/**
 * @param { Promise } promise
 * @param { Object= } errorExt - Additional Information you can pass to the err object
 * @return { Promise }
 */
export function to<T, U = Error> (
  promise: Promise<T>,
  errorExt?: object
): Promise<[U | null, T | undefined]> {
  return promise
    .then<[null, T]>((data: T) => [null, data])
    .catch<[U, undefined]>((err: U) => {
      if (errorExt) {
        Object.assign(err, errorExt);
      }

      return [err, undefined];
    });
}

export default to;

Answer 4

在L Y E S-C H I O U K H的扩展中：

实用工具功能实际上是正确的，但是请确保在承诺前添加return关键字，如下所示：

// utils.js

const utils = promise => (
  return promise
    .then(data => { [data, null]; })
    .catch(error => { [null, error]; });
);

module.exports = utils;

使用主代码拨打电话时：

let resonse, error; // any variable name is fine make sure there is one for error and the response

[response, error] = await utils(any_function()); // Make sure that inside the tuple, response is first and error is last like: [response, error].
if (error) console.log(error);

// -- Do Whatever with the Response -- //

使用我的方法会给您带来以下好处：

您自己的变量名。
使用打字稿时未遇到类型安全问题。
强类型输入代码的充分理由。

我个人最近在代码中使用了它，并减轻了许多麻烦，我的代码更简洁，我不必坚持使用相同的变量名，尤其是在大型代码库上工作时。

快乐编码：）

再见！

Answer 5

如果您具有上述单行async/await函数，那么这对您来说将是干净的代码：

const getUsers = async (time, shouldReject=false) => {
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        if (shouldReject) {
          reject(Error('Rejected...'));
        } else {
          resolve(["User1", "User2"]);
        }
      }, time);
    });
}

const userOperation = users => {
  console.log("Operating user", users);
}

// Example 1, pass
getUsers(100)
    .then(users => userOperation(users))
    .catch(e => console.log(e.message));

// Example 2, rejected
getUsers(100, true)
    .then(users => userOperation(users))
    .catch(e => console.log(e.message));

对于单个await函数中的多个async，最好如下设置try / catch块：

const users = async () => {
    try {
        const value = await getUsers(1000, false);
        const value1 = await getUsers2(1000, false);
        ...
    } catch (error) {
        ...
    }
}

使用await async获取数据而不使用try catch

5 个答案: