JavaScript中的observable和promise之间有什么区别？

What are the differences between observables and promises in JavaScript?

所以我读到，在即将到来的一些JavaScriptMVC中，Observables希望超越承诺：

角度2.0
Netflix使用的Falcor

可观察的和承诺的区别是什么？

更新：道歉！删除了我的错误陈述。

相关讨论

Promises提供了一个非常简单的回调机制，在这里，由于RX提供了异步编程的强大抽象。可观测数据代表一个数据流，然后我们可以对其应用运算符，以便定义如何处理传入的数据。

如果您只需要发出一个HTTP请求，然后更新一个UI组件，那么使用Promise就足够了。

然而，大多数应用程序的需求往往比这更复杂(即使最初并不明显)。以我们的HTTP请求为例，让我们看看如何将其建模为可观察的，并使用一些RX运算符可以帮助我们：

-如果HTTP请求是由一个用户操作触发的，那么我们可能希望警惕触发多个HTTP请求(想象一个用户在搜索框中键入)。我们不想为每一次击键触发一个请求，所以我们可能想限制我们的搜索，这样我们只在用户停止键入300ms时触发一个请求。此外，如果用户键入一个单词，等待300ms，并添加另一个字符，我们将触发后续的HTTP请求。有了承诺，我们可能会遇到一个竞争条件，因为我们无法控制收到回复的顺序，也无法取消旧的请求。Rx通过允许我们在流之间切换来解决这个问题，流对我们不再关心的旧请求订阅调用Dispose。我们还可以过滤掉任何无效的搜索输入，例如搜索词的长度小于3个字符。

-支持处理超时/错误处理。假设我们的HTTP请求失败，RX允许我们轻松地重试发出请求。

-假设我们的应用程序的几个部分需要进行相同的HTTP调用，我们可能不希望实际进行多次调用。我们可以将我们的Observable公开给多个消费者，并使用Replay来确保调用一次，结果被缓存给后续订户。我们甚至可以提供一个时间跨度来重放，从而使缓存行为过期。

-通过使用调度程序对线程进行强大的抽象，这允许我们控制并发性。更好的是，我们可以在单元测试中使用测试调度程序来控制时间，允许我们模拟超时、比赛条件等。

这些是一些快速的例子来证明什么是可能的。RX框架中有更多的运算符来满足所有类型的场景，RX的可组合性意味着您可以轻松地组合运算符来定义所需的行为。创建自己的可重用操作符也很容易(例如retryafterdelay)。

总之，RX可以做的一切比承诺可以做的要多得多。我怀疑在接下来的几年里，RX将继续转变，而不是承诺。

为了进一步阅读，我建议您看一下角度2指南中的观察部分。

As说在2角的GUIDP＞＜／

转换到is often答应好的选择，当你想把单块的数据。我知道当你receive the日期，你做。P＞＜／

but some cases的要求是在T总是只做一次。你可以启动一个请求，取消它，并使在不同服务器的request has before theresponded to the first request。P＞＜／

在搜索中的for example as the user name组件类型在你进入搜索框，搜索模式，重复灌水使HTTP请求查询。P＞＜／

A request-cancel-new-request sequence is difficult to implement with
Promises, but easy with Observables.

我知道，如果你得到一个组件的数据与存储器请求好的选择是使用Promisebut if it to request has a chain of New You should -取消-使用observablerequestP＞＜／

可见的承诺(by Jeremy vilken)。P＞＜／

在加成到新的句法模式是可见的，newer JavaScript for applications to管理异步活动。他们也在选秀natively to be for a特征要实现在JavaScript语言知道它背后有茶量模式。rxjs is the我们使用图书馆帮助美国实施"订单量在我们的应用程序。P＞＜／

承诺是一construct异步协议以帮助呼吁，which are useful制作API for example for requests，。在专业承诺有一个限制，他们的国王useful for only one呼叫循环。for example，如果你想有一个在返回的承诺值类在线安事件，承诺会在用户点击，点击resolve on the first。但你会处理好每一个用户点击行动的兴趣。你normally事件，使用安listener for this和that，to handle events allows你过时间。this is an important event handlers类区分：可见，他们是在连续处理过的数据时间和continuously handle that allow to You)数据流。P＞＜／

compared are often to可观测量的承诺。这里是一些关键的差别：P＞＜／

可见computation does not start是declarative；直到订阅。execute立即在线创造的承诺。defining useful for this that makes量recipes can be run每当你need the result。P＞＜／

提供多量的值。提供的一个承诺。useful for this让要过多量的时间值。P＞＜／

differentiate between chaining和订阅量。承诺条款(.then only have)。This makes useful for creating可观测量的复合变换recipes used by other to be part of the system，the work to be executed不常见。P＞＜／

订阅(可见的)是负责为处理错误。承诺承诺推错误to the Child)。这让predictable useful for集中可观测量和误差处理。P＞＜／

最好的解释模式：角在线官方网站P＞＜／

HTTPS：/ / / / angular.io -?比较可观测量指南P＞＜／

当你明白observables to the之间的正确，Promises --是漂亮的。P＞＜／

最好的方式来convoluted is to demystify恩从概念到实施"订单划痕。here is an implementation and an purely功能几乎observableexample with that就不会工作，Promises：P＞＜／

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

/*** Observable type ***/

// type constructor (of a product type)

const proType = name => cons => {
const f = (k, ...args) =>
Object.defineProperties({["run" + name]: k}, {
[Symbol.toStringTag]: {value: name},
[Symbol("args")]: {value: args}
});

return cons(f);
};

// value constructor

const Observable = proType("Observable")
(Observable => k => Observable(k));

/*** Observer factory ***/

const Observer = observer => {
let isUnsubscribed = false;

return {
next: function(x) {
if (isUnsubscribed)
throw new Error("unsubscribed");

else {
try {
return observer.next(x);
}

catch(e) {
isUnsubscribed = true;
this.cancel();
throw e;
}
}
},

error: function(e) {
if (isUnsubscribed)
throw new Error("unsubscribed");

else {
try {
return observer.error(e);
}

catch(e_) {
isUnsubscribed = true;
this.cancel();
throw e_;
}
}
},

complete: function() {
if (isUnsubscribed)
throw new Error("unsubscribed");

else {
try {
const r = observer.complete();
this.cancel();
return r;
}

catch(e) {
isUnsubscribed = true;
cancel();
throw e;
}
}
}
};
};

/*** combinators + auxiliary functions ***/

const subscribe = observable => handlers => {
const observer = Observer(handlers),
cancel = observable.runObservable(observer);

observer.cancel = cancel;
return cancel;
};

const obsMap = f => observable =>
Observable(observer => {
const mapObserver = {
next: x => observer.next(f(x)),
error: e => observer.error(e),
complete: () => observer.complete()
};

return observable.runObservable(mapObserver);
});

/*** main ***/

// create an Observable instance

const numStream = Observable(observer => {
let i = 0;

const timer = setInterval(() => {
observer.next(i++);
}, 1000);

return () => clearTimeout(timer);
});

// map a function over it

const squaredNumStream =
obsMap(x => x * x) (numStream);

// run the observable

const cancel = subscribe(squaredNumStream) ({
next: x => console.log(x),
error: e => console.error(e),
complete: () => console.log("finished")
});

// cancel it

setTimeout(cancel, 11000);

P＞＜／

在the above the example of theoretically observablesquaredNumStream发射流无穷值异步。You cannot do this with Promises单身，因为他们代表的价值在未来。P＞＜／

我有subscribed to another without easily两个干扰情况下squaredNumStreamwith each other。这是因为observables是单播，组播whereas Promises are。P＞＜／

在运行时不squaredNumStream宣言，but only after订阅，因为observables是lazily evaluated。Promises on the other is that are eagerly evaluated手，他们开始运行，当你创建它们。P＞＜／

和最后，observables是可取消的模式设计，whereas Promises是难有两个语义上的单播。P＞＜／