如何获取承诺的价值？

promiseA的函数返回一个新的 promise（），该 promise 在解析后立即解析，其值是从 success 函数返回的值。thenpromiseBpromiseApromiseA

在这种情况下，使用值进行解析 - 然后立即使用值 进行解析。promiseAresultpromiseBresult + 1

访问 的值与访问 的结果的方式相同。promiseBpromiseA

promiseB.then(function(result) {
    // here you can use the result of promiseB
});

从 ECMAScript 2016 （ES7， 2016） 开始，/ 是 JavaScript 的标准，它允许使用替代上述方法的语法。您现在可以编写：asyncawait

let result = await functionThatReturnsPromiseA();
result = result + 1;

现在没有 promiseB，因为我们已经使用 解开了 promiseA 的结果，你可以直接使用它。await

但是，只能在函数内部使用。因此，为了稍微缩小，上述内容必须像这样包含：awaitasync

async function doSomething() {
    let result = await functionThatReturnsPromiseA();
    return result + 1;
}

而且，为了清楚起见，此示例中函数的返回值仍然是一个 promise，因为异步函数返回 promise。因此，如果要访问该返回值，则必须执行，这只能在另一个异步函数中执行。基本上，只有在父异步上下文中，才能直接访问从子异步上下文生成的值。doSomethingresult = await doSomething()

promiseB 的函数接收从 promiseA 的函数返回的内容。.then.then

这里 promiseA 返回一个数字，该数字将作为 promiseB 成功函数中的参数提供。然后将递增 1。number

以与您当前理解略有不同的方式解析评论可能会有所帮助：

// promiseB will be resolved immediately after promiseA is resolved

这说明这是一个承诺，但在解决后将立即解决。另一种看待此方式意味着返回分配给 的 promise 。promiseBpromiseApromiseA.then()promiseB

// and its value will be the result of promiseA incremented by 1

这意味着解析到的值是将作为其 successCallback 值接收的值：promiseApromiseB

promiseB.then(function (val) {
  // val is now promiseA's result + 1
});

当一个 promise 被解析/拒绝时，它将调用其成功/错误处理程序：

var promiseB = promiseA.then(function(result) {
   // do something with result
});

该方法还返回一个 promise：promiseB，它将根据 promiseA 的成功/错误处理程序的返回值进行解析/拒绝。then

promiseA 的成功/错误处理程序可以返回三个可能的值，这些值将影响 promiseB 的结果：

1. 立即解决 PromiseB →不返回任何内容， 和 undefined 传递给 promiseB 的成功处理程序
2. 返回一个值→立即解析 PromiseB， 并将该值传递给 promiseB 的成功处理程序
3. 返回一个 promise → 解析后，promiseB 将被解析。 当被拒绝时，promiseB 将被拒绝。传递给的值 promiseB 的 then 处理程序将是 promise 的结果

有了这种理解，你就可以理解以下几点：

promiseB = promiseA.then(function(result) {
  return result + 1;
});

then 调用立即返回 promiseB。

当 promiseA 被解析时，它会将结果传递给 promiseA 的成功处理程序。

由于返回值是 promiseA 的结果 + 1，因此成功处理程序返回一个值（上面的选项 2），因此 promiseB 将立即解析，并且 promiseB 的成功处理程序将传递给 promiseA 的结果 + 1。

promiseA(pram).then(
     result => { 
     //make sure promiseA function allready success and response
     //do something here
}).catch(err => console.log(err)) => {
     // handle error with try catch
}

您可以使用 JavaScript 中的异步等待方法轻松做到这一点。

下面是一个使用超时检索 WebRTC promise 值的示例。

function await_getipv4(timeout = 1000) {
    var t1 = new Date();
    while(!window.ipv4) {
        var stop = new Date() - t1 >= timeout;
        if(stop) {
            console.error('timeout exceeded for await_getipv4.');
            return false;
        }
    }
    return window.ipv4;
}

function async_getipv4() {
    var ipv4 = null;
    var findIP = new Promise(r=>{var w=window,a=new (w.RTCPeerConnection||w.mozRTCPeerConnection||w.webkitRTCPeerConnection)({iceServers:[]}),b=()=>{};a.createDataChannel("");a.createOffer(c=>a.setLocalDescription(c,b,b),b);a.onicecandidate=c=>{try{c.candidate.candidate.match(/([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/g).forEach(r)}catch(e){}}})
    findIP.then(ip => window.ipv4 = ip);
    return await_getipv4();
};

Pixelbits的答案是正确的，你应该始终使用在生产代码中访问承诺的价值。.then()

但是，有一种方法可以在解析 promise 的值后直接访问该值，方法是使用以下不受支持的内部 Node.js 绑定：

process.binding('util').getPromiseDetails(myPromise)[1]

警告：process.binding 从未打算在 Node.js 核心之外使用，Node.js 核心团队正在积极寻求弃用它

• 文档：Process.binding 的文档弃用 #22004

• 从 process.binding 迁移 #22064

我觉得这个例子是不言自明的。请注意，await 是如何等待结果的，因此您错过了返回的 Promise。

cryA = crypto.subtle.generateKey({name:'ECDH', namedCurve:'P-384'}, true, ["deriveKey", "deriveBits"])
Promise {<pending>}
cryB = await crypto.subtle.generateKey({name:'ECDH', namedCurve:'P-384'}, true, ["deriveKey", "deriveBits"])
{publicKey: CryptoKey, privateKey: CryptoKey}

在 Node.js REPL 中，为了获取作为 promise 值的数据库连接，我采用了以下方法：

let connection
try {
  (async () => {
    connection = await returnsAPromiseResolvingToConnection()
  })()
} catch(err) {
  console.log(err)
}

with 行通常会返回一个 promise。此代码可以粘贴到 Node.js REPL 中，也可以保存在 index.js 中。它可以在 Bash 中运行await

node -i -e "$(< index.js)"

在运行脚本后，您将留在 Node.js REPL 中，并有权访问设置变量。例如，若要确认异步函数已返回，可以进行日志记录，然后即可使用该变量。当然，对于异步函数之外的脚本中的任何代码，人们还不想指望异步函数正在解析。connection

之前有一些很好的答案，这里是 ES6 箭头函数版本：

var something = async() => {
    let result = await functionThatReturnsPromiseA();
    return result + 1;
}

我对 JavaScript 承诺的学习速度很慢。默认情况下，所有异步函数都返回一个 promise，您可以将结果包装为：

(async () => {
//Optional "await"
  await yourAsyncFunctionOrPromise()
    .then(function (result) {
      return result +1;
    })
    .catch(function (error) {
      return error;
    })()
})

从 await （MDN）：

await 表达式使异步函数执行暂停，直到 Promise 结算（即已履行或已拒绝），并在履行后恢复异步函数的执行。恢复时，await 表达式的值是已实现的 Promise 的值。

如果 Promise 被拒绝，await 表达式将抛出被拒绝的值

在 MDN Web 文档中阅读有关 await 和 promise 的更多信息。

在交互式提示符下进行实验时，可以通过将值分配给 “then（）” 函数中的全局变量来访问 Promise 的值，例如：

> promise = new Promise((resolve, reject) => resolve(17));
Promise {
   17,
   [Symbol(async_id_symbol)]: 7600,
   [Symbol(trigger_async_id_symbol)]: 5,
   [Symbol(destroyed)]: { destroyed: false }
}
> global_cheat = null;
null
> promise.then((v) => { global_cheat = v; } );
Promise {
   <pending>,
  [Symbol(async_id_symbol)]: 7875,
  [Symbol(trigger_async_id_symbol)]: 7600,
  [Symbol(destroyed)]: { destroyed: false }
}
> global_cheat
17

在代码中，这个想法似乎是总是强制人们将“后续”代码放入“then（）”部分（或者，如果我理解的话，相当于将 async/await 模式放入，如果我理解，它也会被重写为“then（）”模式）。我想这个想法是可以防止“阻塞”系统，尽管在我看来，没有提供后门来同步获取价值似乎是语言设计者的过度家长式作风。

请注意，再次从交互式命令行：

> xyz=null; promise.then((v) => {xyz = v;}); console.log(`xyz=${xyz}`);
xyz=null

这是因为“then（）”中的代码尚未运行。

但是，在“下一行”（在交互式提示符下）可以执行以下操作：

> xyz
17

实际上，从交互式（Node.js）提示中，可以“等待”：

> y = new Promise((resolve, reject) => resolve(23));
Promise {
   23,
   [Symbol(async_id_symbol)]: 10419,
   [Symbol(trigger_async_id_symbol)]: 5,
   [Symbol(destroyed)]: { destroyed: false }
}
> v = await y;
23

这在 REPL 进行实验时很有用。

你不能在“普通”函数中这样做：

> function foo() { let z = await y; return z; }
Uncaught SyntaxError:
Unexpected token 'y'

你可以在“异步函数”中执行此操作，但这会让你背负着一个承诺，而不是你想要的值：

> async function foo() { let z = await y; return z; }
undefined
> foo()
Promise {
  <pending>,
  [Symbol(async_id_symbol)]: 10571,
  [Symbol(trigger_async_id_symbol)]: 5,
  [Symbol(destroyed)]: { destroyed: false }
}

MDN文档帮助我解决了这个问题：

Promise.resolve（）

let promiseB = promiseA;

promiseB.then((value) => {
    console.log(value);
});

如果需要对 JSON 对象进行多个级别的访问：

let promiseB = promiseA;

promiseB.then((value) => {
    console.log(value?.key1.key2);
});