Angular 为什么等待承诺。决心给你承诺，而不等待给你承诺？

当我这样做时：

const p = Promise.resolve(‘hello world’);
console.log(p);

const p = await Promise.resolve(‘hello world’);

我得到这个输出：

ZoneAwarePromise {__zone_symbol__state: true, __zone_symbol__value: "hello world"}
__zone_symbol__state: true
__zone_symbol__value: "hello world"
__proto__: Object

hello world

但如果我这样做：

const p = Promise.resolve(‘hello world’);
console.log(p);

const p = await Promise.resolve(‘hello world’);

我得到这个输出：

ZoneAwarePromise {__zone_symbol__state: true, __zone_symbol__value: "hello world"}
__zone_symbol__state: true
__zone_symbol__value: "hello world"
__proto__: Object

hello world

为什么当我不等待承诺时，决心（…），p是承诺，但当我等待时，p是承诺的价值

---

我这样问是因为从我的理解来看，Promise.resolve（…）不是异步的，这意味着它会立即解析。因此，在这两种情况下，p不应该只是“hello world”的值吗？如果承诺已经解决，还有什么需要等待？换言之：在承诺得到解决和承诺给你的价值得到解决之间会发生什么？是什么触发了这一切？

这正是

等待

所做的。在某种程度上，它可以被认为是“拆开”承诺——从语义上讲，您正在等待承诺得到解决，然后获得解决的值。因此，您只能在一个异步函数（用

async

关键字指定）中使用

wait

，该函数强制将该函数的返回值作为承诺

例如：

async function example() {
  return await promise;
}

在功能上等同于：

function example() {
  return promise.then(result => {
   return result;
  })
}

---

函数

Promise.resolve（val）

专门用于返回Promise对象。这就是它的设计目的。因此，当您这样做时：

const p = Promise.resolve('hello world');
console.log(p);

变量

p

正好包含

Promise.resolve（）

设计用于返回的Promise对象

这个promise对象碰巧已经在内部解析，但是当您检查返回值时，您看到的是promise对象

与所有promise对象一样，如果要从promise对象中获取解析的值，则必须使用

.then（）

或

wait

来访问该值。从

promise.resolve（）

返回的承诺在这方面与任何其他承诺没有区别

const p = Promise.resolve('hello world');
console.log(p);           // shows you the promise object

p.then(val => {
    console.log(val);     // 'hello world'
});

// or this
console.log(await p);     // 'hello world'

为什么当我不等待承诺时，决心（…），p是承诺，但当我等待时，p是承诺的价值

因为

Promise.resolve（）

返回一个Promise对象，所以总是和

wait p

从该Promise对象获取值

我这样问是因为从我的理解来看，Promise.resolve（…）不是异步的，这意味着它会立即解析。因此，在这两种情况下，p不应该只是“hello world”的值吗？如果承诺已经解决，还有什么需要等待？换言之：在承诺得到解决和承诺给你的价值得到解决之间会发生什么？是什么触发了这一切

当您想要的是已处于已解析状态的承诺对象时，可以使用

Promise.resolve（）

。如果只需要一个值，则根本不使用

Promise.resolve（）

。因此，这样的代码通常没有意义：

const val = await Promise.resolve('hello world');

你不妨这样做：

const val = 'hello world';

---

我将举一个小例子。假设您有一个从其他服务器返回一些数据的函数，并且您有一个简单的缓存。函数应该总是返回一个承诺，因为它可能需要从另一台服务器获取数据（异步操作）。但是，有时您的数据已经在本地缓存中。你需要你的函数一致地返回一个承诺，这样调用者就有了一个干净一致的API

 const cache = new Map();
 const rp = require('request-promise');

 function getData(id) {
     // see if we already have the result in the cache
     if (cache.has(id)) {
         // if so, return a promise that is resolved with our cached value
         return Promise.resolve(cache.get(id));
     } else {
         return rp(myURL + "?id=" + id).then(data => {
             // cache the value
             cache.set(id, data);
             return data;
         });
     }     
 }

在本例中，我们特别需要始终返回函数使用一致性的承诺。但是，当缓存中有值时，我们希望返回一个已经解析的承诺，其中包含我们的值。因此，我们专门为此使用

Promise.resolve（）

然后，调用方可以始终一致地使用返回的承诺，而不必知道是否缓存了该值：

 getData("price").then(val => {
     console.log(val);
 }).catch(err => {
     console.log(err);
 });

---

谢谢你，朋友，这很有道理。谢谢凯西，这很有道理。