成功的诺言

Question

据我了解，在提供给promise构造函数的回调中指定了resolve和拒绝，并在该回调中调用了它们。但是，解决和拒绝（我认为）总是做同样的事情，为什么还要指定他们呢？

编辑：我应该澄清：我不认为解决与拒绝具有相同的作用；我的意思是说，决心似乎总是能解决，拒绝总是会拒绝-有没有办法传递函数而不是解决其他问题？

编辑：要像我在下面的评论中所做的那样进一步澄清：如果Promise构造函数采用了一个函数，而该函数又接受了resolve和拒绝，而这些总是在函数中调用，那么为什么必须将resolve和reject指定为参数呢？

最终编辑：我尝试使用foo而不是resolve，但它仍然有效。这个怎么可能？我根本没有定义foo？我可能对JavaScript不太了解，超出了预期。 code snippet where i changed resolve to foo

Answer 1

我假设您所指的是then()函数，该函数需要两个回调，一个回调在promise解决时，另一个在解决时。该模式通常如下所示：

myPromise.then(result => {
        // do something here
    },
    error => {
    }
);

如果诺言得以解决，那么一切都会按预期进行，并且第一个回调应正常进行。如果承诺被拒绝，则第二个回调应执行错误处理，可能会向用户显示适当的消息。这些永远不会做同样的事情。

如果您有应该经常发生的逻辑，无论是否有错误，都应该将另一个调用链接到then()：

myPromise.then(result => {
        // do something here
    },
    error => {
        // do something here
    }
).then(result => {
        // do something here
    }
);

从概念上讲，这与许多编程语言中的try...catch...finally相同。

Answer 2

解决并拒绝不要“做同样的事情”。

解决承诺时，您会说“这是此承诺的成功回应”。

当您拒绝承诺时，您会说“该承诺因...而失败”。

例如：

想象一下，在以下示例accountApiRequest()中实际上是执行API请求来获取帐户的。如果没有帐户，则很可能会返回null或引发异常。

承诺成功后，您将resolve进行承诺。如果承诺不成功，它将是rejected。

成功的诺言

function accountApiRequest() {
    return {
        id: 1234,
        username: 'Jim',
    }
}

function getAccount() {
    return new Promise(function(resolve, reject) {
        account = accountApiRequest()
        if (!account) {
            return reject('Unable to fetch account')
        }
        return resolve(account)
    });
}

getAccount().then(console.log).catch(console.log)

承诺失败

function accountApiRequest() {
    return null
}

function getAccount() {
    return new Promise(function(resolve, reject) {
        account = accountApiRequest()
        if (!account) {
            return reject('Unable to fetch account')
        }
        return resolve(account)
    });
}

getAccount().then(console.log).catch(console.log)

Answer 3

在Promise构造函数中，我们有一个回调，该回调以resolve和reject方法作为参数。使用构造函数创建Promise之后，Promise可以具有三种状态：

待处理
已解决
被拒绝

在解决了承诺后，将调用在then()方法中传递的回调。如果承诺被拒绝，则调用在catch()方法中传递的回调。例如：

const prom = new Promise((resolve, reject) => {
  
  setTimeout(() => {
    if(Math.random() > 0.5) {
      resolve('resolved');
    } else {
      reject('rejected');
    }
  }
  , 2000)
  
});

prom.then((val) => console.log('succes: ' + val))
    .catch((val) => console.log('fail: ' + val))

在我们的示例中，在setTimeout中调用了“解决”或“拒绝”，因此，承诺的状态为前2秒待处理。 setTimeout过期后，根据Math.random()的值来解决或拒绝承诺。然后执行then或catch回调以处理承诺的结果。

当拒绝诺言时，称为catch方法的回调称为
解决承诺后，将调用通过then方法传递的回调

Answer 4

创建JS Promise时，您希望某些任务异步发生。此任务可能成功或失败。根据任务是什么来定义成功和失败。

创建新的Promise时，您作为创建者必须指定任务成功或失败时的操作。将相同的信息传达给承诺解决/拒绝承诺的消费者很方便。

因此，当使用者使用then检查诺言的输出时。通过解决方案返回的一切都将提供给消费者。

当消费者使用catch检查诺言的输出时。拒绝品所退回的任何东西都交给了消费者。

import {Promise} from 'es6-promise'


const foo = true;
const fcuk = new Promise((resolve, reject) => {
    if (foo) {
        resolve(4);
    } else {
        reject(2);
    }
})
fcuk.then((value) => console.log(value)).catch((value) => console.log(value));

您可以通过将foo的值更改为true / false来运行上述示例，并亲自查看输出是什么。

Answer 5

resolve和reject基本上都做同样的事情。它们是回调。但是，它们将帮助您处理错误或确定通过/失败所需运行的任何其他逻辑。

示例：拒绝将最终落入您的陷阱。解决最终出现在您当时的（解决）

function myPromise(rejectOrResolve) {
	return new Promise( (resolve, reject) => {
  	if (rejectOrResolve) {
    	resolve();
    } else {
    	reject();
    }
    
  });
}


// Resolved (Success)
myPromise(true).then( t => {
console.log('resolve');
}).catch( e => {
	console.log('reject');
});


// Rejected (Error)
myPromise(false).then( t => {
console.log('resolve');
}).catch( e => {
	console.log('reject');
});

Answer 6

当我阅读有关承诺的书时，我有同样的问题。我了解到您不需要自己定义解析和拒绝函数（它们将被忽略，并且无论如何都会调用标准的解析/拒绝函数）：我认为它们是特殊的函数，可让您指示是否解析或通过调用其中之一来拒绝诺言；以及通过将参数传递给这些函数分别返回什么值。在promise构造函数中如何命名它们都没关系-第一个参数是resolve函数，第二个参数-拒绝。

Javascript：承诺中解决和拒绝的目的是什么？

6 个答案:

成功的诺言

承诺失败