主页 / 问题 / 757956
Accepted
LiaVa
Asked:2020-12-14 03:42:30 +0000 UTC2020-12-14 03:42:30 +0000 UTC

为什么需要承诺？

  • 772

我只是无法理解他们的意思。

当我可以放 setTimeout() 时，为什么要通过 async/await 编写 promise 或创建函数？

javascript

2 个回答

  1. Promise 是回调的便捷替代品

    假设我们有一个函数：

    const awesomeFunction = () => {
    // ... делаю дела
    // ... делаю дела
}

    我们想在第一个函数完成后立即执行另一个函数：

    const awesomeFunction = callback => {
    // ... делаю дела
    // ... делаю дела
    callback()
}

const printFunction = () => {
    // ... что то вывожу в консоль
}

awesomeFunction(printFunction)

    我们可以使用 Promise 重写它，但现在它不会有太大的不同，因为我们的代码是同步的：

    const awesomeFunction = () => {
    return new Promise (resolve => {
        // ... делаю дела
        // ... делаю дела
        resolve()
    })
}

const printFunction = () => {
    // ... что то вывожу в консоль
}

awesomeFunction().then(printFunction)

    还没有什么特别的，但是请注意使用 promises和then()方法时它变得更加清晰。

    在单个回调的例子中，这可能不是那么明显，但是当有很多回调时，这将使我们免于所谓的回调地狱。

    如果您还没有遇到过这样的术语，那么想象一下代码中嵌套了一百个回调的代码会是什么样子。

    眼下：

    理解 Promise 是相同的回调就足够了，只是使用了更方便的语法，使编写和维护代码更容易。

    考虑异步代码的相同选项：

    const awesomeFunction = callback => {
    // функция printFunction будет 
    // запущена через одну секунду
    setTimeout(callback, 1000)
}

const printFunction = () => {
    // ... что то вывожу в консоль
}

awesomeFunction(printFunction)

    同步选项有什么区别吗？

    对我们来说，它不存在，我们仍然在我们认为有必要的时候准确地调用我们的回调，在这种特殊情况下，在函数执行开始后一秒钟awesomeFunction。

    让我们重写 Promise：

    const awesomeFunction = () => {
    return new Promise (resolve => setTimeout(resolve, 1000))
}

const printFunction = () => {
    // ... что то вывожу в консоль
}

awesomeFunction().then(printFunction)

    假设它printFunction也是异步的，那么我们可以将它们一一链接起来，因为现在它也向我们返回了一个 Promise：

    const awesomeFunction = () => {
    return new Promise (resolve => setTimeout(resolve, 1000))
}

const printFunction = () => {
    return new Promise (resolve => setTimeout(() => {
        console.log("printed")
        resolve()
    }, 1000))
}

const anotherFunction = () => {
    // ... делаю что нибудь третие
}

awesomeFunction()
   .then(printFunction)
   .then(anotherFunction)

    注意像 then 这样的符号与回调的嵌套相比有多清晰。

    如果我们想将某些东西从一个函数传递给另一个函数，那么我们可以这样做：

    const awesomeFunction = () => {
    return new Promise (resolve => setTimeout(() => {
        resolve("текст для \"print\"")
    }, 1000))
}

const printFunction = text => {
    console.log(text)
}

awesomeFunction().then(text => printFunction(text))

    ECMAScript 2017引入了一种更好的异步语法，称为async/await。

    它基于 Promise，本质上与 Pr​​omise 没有区别，但允许我们以与同步几乎相同的方式编写异步代码。

    为了表明一个特定的函数是异步的，我们只需要添加一个特殊的词async，并在异步操作之前加上一个词await：

    const awesomeFunction = () => {
    return new Promise (resolve => setTimeout(() => {
        resolve("текст для \"print\"")
    }, 1000))
}

const printFunction = text => {
    console.log(text)
}

// что бы не отходить далеко от предидущих примеров
// я завернул вызовы в IIFE
// что это такое см. ниже

(async() => {
    const text = await awesomeFunction()
    printFunction(text)
})()

// если бы мы делали вызовы из другой функции
// то это выглядело бы так

const parentFunction = async() => {
    const text = await awesomeFunction()
    printFunction(text)
}
    
parentFunction()

    什么是 IIFE

    • 10
  2. Best Answer

    Promise 可帮助您方便地管理异步请求。基本上它就像 try/catch/finally。在 Promise 中，分别在成功或失败的情况下传递给异步方法then并catch在完成时执行回调。

    假设foo返回一个promise，那么我们可以这样写：

    foo()
  .then((response) => {
    // обработка удачного выполнения кода
  })
  .catch((error) => {
    // обработка ошибки
  })
    • 8

相关问题