为什么 Promise.resolve 不能作为函数调用? [英] Why can't Promise.resolve be called as a function?

问题描述

让我和我的同事烦恼的事情.考虑以下...

Something that is bugging me and my colleague. Consider the following...

const {map, compose} = require('ramda');

compose(
  console.log,
  map(Math.tan)
)([1,2,3]);

compose(
  console.log,
  map(v=>Promise.resolve(v))
)([4,5,6]);

compose(
  console.log,
  map(Promise.resolve)
)([7,8,9]);

如您所料，输出 1、2 和 3 的 tan，解析 3、4 和 5 的承诺也是如此.但我的问题是......为什么第三个会中断?为什么 Promise.resolve 的行为方式与任何其他函数不同?

As you would expect, the tan of 1, 2 and 3 are output and so are the promises resolving 3, 4 and 5. But my question is... why does the third break? Why doesn't Promise.resolve behave in the same way as any other function?

[ 1.5574077246549023, -2.185039863261519, -0.1425465430742778 ]
[ Promise { 4 }, Promise { 5 }, Promise { 6 } ]
/home/xxx/node_modules/ramda/src/internal/_map.js:6
    result[idx] = fn(functor[idx]);
                  ^

TypeError: PromiseResolve called on non-object
    at resolve (<anonymous>)
    at _map (/home/xxx/node_modules/ramda/src/internal/_map.js:6:19)
    at map (/home/xxx/node_modules/ramda/src/map.js:57:14)
    at /home/xxx/node_modules/ramda/src/internal/_dispatchable.js:39:15
    at /home/xxx/node_modules/ramda/src/internal/_curry2.js:20:46
    at f1 (/home/xxx/node_modules/ramda/src/internal/_curry1.js:17:17)
    at /home/xxx/node_modules/ramda/src/internal/_pipe.js:3:27
    at /home/xxx/node_modules/ramda/src/internal/_arity.js:5:45
    at Object.<anonymous> (/home/xxx/b.js:20:6)
    at Module._compile (module.js:569:30)

推荐答案

Promise.resolve 指的是 resolve 函数没有上下文对象.

您想使用适当的上下文对象调用它.这是可以的

You want to call it with the proper context object. This can be done

• 通过在该上下文对象上调用它，如 v =>;Promise.resolve(v) 或
• 通过创建它的绑定版本，如 Promise.resolve.bind(Promise)

所以，这行得通:

compose(
  console.log,
  map(Promise.resolve.bind(Promise))
)([7,8,9]);

<小时>

请记住，Javascript 没有类.函数没有所有者.对象可以在其属性中存储函数，但这并不意味着该函数归该对象所有.

---

Remember that Javascript does not have classes. Functions have no owner. Objects can store functions in their properties, but that does not mean the function is owned by that object.

另一种方法是显式设置上下文对象，使用 Function#call 或 Function#apply:

Another way is setting the context object explicitly, with Function#call or Function#apply:

function (v) {
    var resolve = Promise.resolve;
    return resolve.call(Promise, v);
}

<小时>

也许最好通过关注方法以外的东西来说明:

---

Maybe it's best illustrated by focusing on something other than a method:

function Foo() {
    this.bar = {some: "value"};
    this.baz = function () { return this.bar; };
}

var f = new Foo();
var b = f.bar;
var z = f.baz;

这里的 b 指的是 {some: "value"} 而没有 {some: "value"} 神奇地知道"那个 f 存储对它的引用.这应该是显而易见的.

here b refers to {some: "value"} without {some: "value"} magically "knowing" that f stores a reference to it. This should be obvious.

z 也是如此.它存储一个函数，而该函数知道" f 也引用了它.这在理论上应该是显而易见的.

The same is true of z. It stores a function without that function "knowing" that f also references it. This should be just as obvious, in theory.

调用 z() 将产生与调用 f.baz() 不同的结果，即使被调用的函数是相同的.只是上下文不同.

Calling z() will yield different results than calling f.baz(), even though the called function is the same one. Only the context is different.

这篇关于为什么 Promise.resolve 不能作为函数调用?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！