blocks|key|193476|text|观察者/可观察者模式和发布者/订阅者模式之间有两个主要区别：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|193477|193478|Observer/Observable模式主要是以同步的方式实现的，即当某个事件发生时，可观察对象调用其所有观察者的适当方法。Publisher/Subscriber模式主要是以异步方式实现的(使用消息队列)。|ordered-list-item|offset|length|style|BOLD|193479|193480|193481|在Observer/Observable模式中，观察者知道可观察到的。然而，在Publisher/Subscriber，中，发布者和订阅者不需要知道彼此的。它们只是在消息队列的帮助下进行通信。|193482|193483|正如您正确地提到的，数据绑定是一个通用术语，它可以使用观察者/观察者或发布者/订阅者方法来实现。数据是发布者/可观察者。|193484|entityMap^0|0|0|0|J|P|2|1R|K|2H|2|0|0|0|1|J|O|A|13|K|1X|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@$F|V|G|W|H|I]|$F|X|G|Y|H|I]|$F|Z|G|10|H|I]|$F|11|G|12|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|15|8|@$F|16|G|17|H|I]|$F|18|G|19|H|I]|$F|1A|G|1B|H|I]|$F|1C|G|1D|H|I]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|R|$]]

There are two major differences between Observer/Observable and Publisher/Subscriber patterns:
<ol>
<li>Observer/Observable pattern is mostly implemented in a synchronous way, i.e. the observable calls the appropriate method of all its observers when some event occurs. The Publisher/Subscriber pattern is mostly implemented in an asynchronous way (using message queue).
</li>
<li>In the Observer/Observable pattern, the observers are aware of the observable. Whereas, in Publisher/Subscriber, publishers and subscribers don't need to know each other. They simply communicate with the help of message queues.
</li>
</ol>
As you mentioned correctly, data binding is a generic term and it can be implemented using either Observer/Observable or Publisher/Subscriber method. Data is the Publisher/Observable.

blocks|key|3029871|text|以下是我对这三个问题的看法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3029872|数据绑定|3029873|本质上，这仅仅意味着“对象Y上的属性X的值在语义上绑定到对象B上的属性A的值。没有关于Y如何知道或被提供对象B上的变化的假设。|3029874|观察者，或可观察者/观察者|3029875|一种设计模式，通过该模式，对象具有通知其他对象特定事件的能力-通常是使用实际事件完成的，这有点像对象中具有特定函数/方法形状的插槽。观察者是提供通知的人，观察者接收这些通知。在.net中，观察者可以公开事件，观察者使用“事件处理程序”形状的钩子订阅该事件。没有关于通知发生的具体机制的假设，也没有关于一个观察者可以通知的观察者数量的假设。|3029876|发布/订阅|3029877|可观察/观察者模式的另一个名称(可能具有更多的“广播”语义)，通常意味着更“动态”的风格-观察者可以订阅或取消订阅通知，一个观察者可以向多个观察者“喊出”。在.NET中，可以使用标准事件来实现这一点，因为事件是MulticastDelegate的一种形式，因此可以支持将事件交付给多个订阅者，还可以支持取消订阅。发布/订阅在某些上下文中的含义略有不同，通常涉及事件和事件之间更多的“匿名性”，这可以通过任何数量的抽象来促进，通常涉及一些认识所有各方的“中间人”(例如消息队列)，但单独的各方并不了解对方。|3029878|数据绑定，Redux|3029879|在许多“类MVC”模式中，可观察对象公开某种方式的“属性更改通知”，其中还包含有关更改的特定属性的信息。观察者是隐式的，通常由框架创建，并通过一些绑定语法订阅这些通知，以明确地标识对象和属性，而“事件处理程序”只是复制新值，潜在地触发任何更新或刷新逻辑。|3029880|数据绑定Redux|3029881|数据绑定的另一种实现？好吧，这里有一个很愚蠢的问题：|3029882|3029883|启动后台线程，不断检查对象的绑定属性。|unordered-list-item|3029884|如果该线程检测到该属性值在上次检查后发生了更改，请将该值复制到绑定的项中。|3029885|3029886|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|17|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1A|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1C|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1D|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1E|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|Y|7|1G|8|@]|9|@]|A|$]]|$1|Z|3|10|5|Y|7|1H|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|13|$]]

Here's my take on the three:

<h3>Data Binding</h3>

Essentially, at the core this just means "the value of property X on object Y is semantically bound to the value of property A on object B. No assumptions are made as to how Y knows or is fed changes on object B.

<h3>Observer, or Observable/Observer</h3>

A design pattern by which an object is imbued with the ability to notify others of specific events - typically done using actual events, which are kind of like slots in the object with the shape of a specific function/method. The observable is the one who provides notifications, and the observer receives those notifications. In .net, the observable can expose an event and the observer subscribes to that event with an "event handler" shaped hook. No assumptions are made about the specific mechanism which notifications occur, nor about the number of observers one observable can notify.

<h3>Pub/Sub</h3>

Another name (perhaps with more "broadcast" semantics) of the Observable/Observer pattern, which usually implies a more "dynamic" flavor - observers can subscribe or unsubscribe to notifications and one observable can "shout out" to multiple observers. In .NET, one can use the standard events for this, since events are a form of MulticastDelegate, and so can support delivery of events to multiple subscribers, and also support unsubscription. Pub/Sub has a slightly different meaning in certain contexts, usually involving more "anonymity" between event and eventer, which can be facilitated by any number of abstractions, usually involving some "middle man" (such as a message queue) who knows all parties, but the individual parties don't know about each other.

<h3>Data Binding, Redux</h3>

In many "MVC-like" patterns, the observable exposes some manner of "property changed notification" that also contains information about the specific property changed. The observer is implicit, usually created by the framework, and subscribes to these notifications via some binding syntax to specifically identify an object and property, and the "event handler" just copies the new value over, potentially triggering any update or refresh logic.

<h3>Data binding re Redux</h3>

An alternative implementation for data binding? Ok, here's a stupid one:

<ul>
<li>a background thread is started that constantly checks the bound property on an object.</li>
<li>if that thread detects that the value of the property has changed since last check, copy the value over to the bound item.</li>
</ul>

blocks|key|2817599|text|我同意你关于这两种模式的结论，然而，对我来说，当我在相同的进程中时，我使用Observable，我在进程间场景中使用发布/订阅，其中所有各方只知道公共通道，而不知道各方。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2817600|我不知道其他模式，或者让我这样说，我从来没有需要其他模式来完成这项任务。甚至大多数MVC框架和数据绑定实现通常在内部使用观察者概念。|2817601|如果您对进程间通信感兴趣，我建议您：|2817602|“企业集成模式:设计、构建和部署消息传递解决方案”-+|offset|length|style|BOLD|2817603|这本书包含了很多关于如何在进程或类之间发送消息的想法，甚至可以在进程内通信任务中使用(它帮助我以一种更松耦合的方式进行编程)。|2817604|我希望这能帮到你!|2817605|entityMap^0|0|0|0|0|P|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@$H|V|I|W|J|K]]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

I agree with your conclusion about both patterns, nevertheless, for me, I use Observable when I'm in the same process and I use the Pub/Sub in inter-process scenarios, where all parties only know the common channel but not the parties.
I don't know other patterns, or let me say this way, I've never needed another patterns for this task. Even most MVC frameworks and data binding implementations use usually internally the observer concept.
If you're interested in inter-process communication, I recommend you:
&quot;Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions&quot; -
<a href="https://www.enterpriseintegrationpatterns.com/" rel="nofollow noreferrer">https://www.enterpriseintegrationpatterns.com/</a>
This book contains a lot of ideas about how to send messages between processes or classes that can be used even in intra-process communication tasks (it helped me to program in a more loose-coupled way).
I hope this helps!

blocks|key|2817619|text|让我感到有点好笑的是，这里的所有答案都试图解释观察者模式和发布/订阅模式之间的细微差别，而没有给出任何具体的例子。我敢打赌，大多数读者仍然不知道如何通过读取一个是同步的，另一个是异步的来实现每一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2817620|需要注意的一件事是：这些模式的目标是尝试解耦代码|offset|length|style|BOLD|2817621|2817622|观察者是一种设计模式，其中对象(称为主题)维护依赖于它的对象(观察者)的列表，自动通知它们状态的任何更改。|blockquote|2817623|2817624|2817625|2817626|这意味着observable+object有一个列表，其中保存了它的所有observers(通常是函数)。并且可以遍历这个列表并在它觉得合适的时候调用这些函数。|CODE|2817627|详情请参见this+observer+pattern示例。|2817628|当您想要监听对象上的任何数据更改并相应地更新其他UI视图时，此模式非常有用。|2817629|但是Cons是可观测的，只维护一个用于保持观察者的数组(在本例中，该数组是observersList)。|2817630|它不区分update是如何触发的，因为它只有一个notify+function，用来触发存储在该数组中的所有函数。|2817631|如果我们想要根据不同的事件对观察者处理程序进行分组。我们只需要将该observersList修改为如下所示的Object|2817632|var+events+=+{
++++"event1":+[handler1,+handler2],
++++"event2":+[handler3]
}|code-block|syntax|javascript|2817633|详情请参见this+pubsub+example。|2817634|人们称这种变体为pub/sub。因此，您可以根据发布的events触发不同的函数。|2817635|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/liqiang372/48b26fc4fe5cd808ad5b9aba63d11b88|1|https://gist.github.com/liqiang372/47a987065947f3338c1a168b8ee473e0^0|0|A|E|0|0|0|0|0|0|4|H|10|9|0|5|L|0|0|0|7|H|11|D|0|O|F|0|X|D|1I|6|0|0|5|J|1|0|8|7|R|6|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|1P|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1T|8|@$D|1U|E|1V|F|Q]|$D|1W|E|1X|F|Q]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1Y|8|@]|9|@$D|1Z|E|20|1|21]]|A|$]]|$1|T|3|U|5|6|7|22|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|23|8|@$D|24|E|25|F|G]|$D|26|E|27|F|Q]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|28|8|@$D|29|E|2A|F|Q]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2B|8|@$D|2C|E|2D|F|Q]|$D|2E|E|2F|F|Q]]|9|@]|A|$]]|$1|11|3|12|5|13|7|2G|8|@]|9|@]|A|$14|15]]|$1|16|3|17|5|6|7|2H|8|@]|9|@$D|2I|E|2J|1|2K]]|A|$]]|$1|18|3|19|5|6|7|2L|8|@$D|2M|E|2N|F|Q]|$D|2O|E|2P|F|Q]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]|1I|$5|1D|1E|1F|A|$1G|1J]]]]

I am a bit amused that all the answers here were trying to explain the subtle difference between Observer and Pub/Sub patterns without giving any concrete examples. I bet most of the readers still don't know how to implement each one by reading one is synchronous and the other is asynchronous.
One thing to note is: The goal of these patterns is trying to decouple code
<blockquote>
The Observer is a design pattern where an object (known as a subject) maintains a list of objects depending on it (observers), automatically notifying them of any changes to state.
<a href="https://addyosmani.com/resources/essentialjsdesignpatterns/book/#observerpatternjavascript" rel="noreferrer">Observer pattern</a>
</blockquote>
This means an <code>observable object</code> has a list where it keeps all its <code>observers</code>(which are usually functions). and can traverse this list and invoke these functions when it feels a good time.
see <a href="https://gist.github.com/liqiang372/48b26fc4fe5cd808ad5b9aba63d11b88" rel="noreferrer">this observer pattern</a> example for details.
This pattern is good when you want to listen for any data change on an object and update other UI views correspondingly.
But the Cons are Observables only maintain one array for keeping observers
(in the example, the array is <code>observersList</code>).
It does NOT differentiate how the update is triggered because it only has one <code>notify function</code>, which triggers all the functions stored in that array.
If we want to group observers handlers based on different events. We just need to modify that <code>observersList</code> to an <code>Object</code> like
<pre><code>var events = {
 &quot;event1&quot;: [handler1, handler2],
 &quot;event2&quot;: [handler3]
}
</code></pre>
see <a href="https://gist.github.com/liqiang372/47a987065947f3338c1a168b8ee473e0" rel="noreferrer">this pubsub example</a> for details.
and people call this variation as <code>pub/sub</code>. So you can trigger different functions based on the <code>events</code> you published.

What is the difference between the <a href="http://en.wikipedia.org/wiki/Observer_pattern" rel="noreferrer">Observer Pattern</a>, <a href="http://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern" rel="noreferrer">Publish/Subscribe</a>, and <a href="http://en.wikipedia.org/wiki/UI_data_binding" rel="noreferrer">Data Binding</a>?

I searched around a bit on Stack Overflow and did not find any good answers.

What I have come to believe is that data binding is a generic term and there are different ways of implementing it such as the Observer Pattern or the Pub/Sub pattern. With the Observer pattern, an Observable updates its Observers. With Pub/Sub, 0-many publishers can publish messages of certain classes and 0-many subscribers can subscribe to messages of certain classes.

Are there other patterns of implementing "data binding"?

Difference between Observer, Pub/Sub, and Data Binding

消息队列

、和之间的区别是什么我在Stack Overflow上搜索了一下，没有找到任何好的答案。我相信数据绑定是一个通用的术语，有不同的方式实现它，比如观察者模式或发布/订阅模式。使用观察者模式，一个观察者更新它的观察者。通过发布/订阅，0-多个发布者可以发布某些类的消息，0-多个订阅者可以订阅某些类的消息。是否还有其他实现“...

问观察者、发布/订阅和数据绑定之间的区别
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问观察者、发布/订阅和数据绑定之间的区别EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问观察者、发布/订阅和数据绑定之间的区别
EN