国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

javascript設計模式學習筆記之發布-訂閱模式

klivitamJ / 1687人閱讀

摘要:發布訂閱模式定義對象間的一種一對多的依賴關系當一個對象的狀態發生改變時所有依賴于它的對象都將得到通知簡單實現定義發布者緩存列表存放訂閱者的回調函數定義訂閱者發布消息測試訂閱者價格訂閱者價格發布消息上面的實現方式導致了每個訂閱者都會收到發布

發布-訂閱模式

定義對象間的一種 一對多 的依賴關系, 當一個對象的狀態發生改變時, 所有依賴于它的對象都將得到通知

簡單實現

</>復制代碼

  1. // 定義發布者
  2. var salesOffices = {};
  3. // 緩存列表, 存放訂閱者的回調函數
  4. salesOffices.clientList = [];
  5. // 定義訂閱者
  6. salesOffices.listen = function (fn) {
  7. this.clientList.push(fn);
  8. }
  9. // 發布消息
  10. salesOffices.trigger = function () {
  11. for (var i = 0, fn; fn = this.clientList[i++];) {
  12. fn.apply(this, arguments)
  13. }
  14. }
  15. /*** 測試 ***/
  16. // 訂閱者1
  17. salesOffices.listen(function (price, squareMeter) {
  18. console.log("價格=" + price);
  19. console.log("squareMeter= " + squareMeter);
  20. });
  21. // 訂閱者2
  22. salesOffices.listen(function (price, squareMeter) {
  23. console.log("價格=" + price);
  24. console.log("squareMeter= " + squareMeter);
  25. });
  26. // 發布消息
  27. salesOffices.trigger(2000, 80);
  28. salesOffices.trigger(3000, 100);

上面的實現方式, 導致了, 每個訂閱者都會收到發布者發布的消息

</>復制代碼

  1. // 定義發布者
  2. var salesOffices = {};
  3. // 緩存列表, 存放訂閱者的回調函數
  4. salesOffices.clientList = {};
  5. // 定義訂閱者 (增加緩存, 增加標示 key )
  6. salesOffices.listen = function (key, fn) {
  7. if (!this.clientList[key]) {
  8. this.clientList[key] = [];
  9. }
  10. this.clientList[key].push(fn);
  11. }
  12. // 發布消息
  13. salesOffices.trigger = function () {
  14. var key = Array.prototype.shift.call(arguments),
  15. fns = this.clientList[key];
  16. if (!fns || fns.length === 0) {
  17. return false;
  18. }
  19. for (var i = 0, fn; fn = fns[i++];) {
  20. fn.apply(this, arguments)
  21. }
  22. }
提煉發布-訂閱模式

</>復制代碼

  1. // 核心事件
  2. var event = {
  3. clientList: {},
  4. listen: function (key, fn) {
  5. if (!this.clientList[key]) {
  6. this.clientList[key] = [];
  7. }
  8. this.clientList[key].push(fn);
  9. },
  10. trigger: function () {
  11. var key = Array.prototype.shift.call(arguments),
  12. fns = this.clientList[key];
  13. if (!fns || fns.length === 0) {
  14. return false
  15. }
  16. for (var i = 0, fn; fn = fns[i++];) {
  17. fn.apply(this, arguments);
  18. }
  19. }
  20. }
  21. // 取消訂閱消息
  22. event.remove = function (key, fn) {
  23. var fns = this.clientList[key];
  24. if (!fns) {
  25. return false;
  26. }
  27. if (!fn) {
  28. // 沒有傳入fn 取消key對應的所有的訂閱
  29. fns && (fns.length = 0);
  30. } else {
  31. // 傳入fn 刪除對應的fn
  32. for (var l = fns.length - 1; l >= 0; l--) {
  33. var _fn = fns[l];
  34. if (_fn === fn) {
  35. fns.splice(l, 1)
  36. }
  37. }
  38. }
  39. }
  40. // 給任何對象動態增加發布-訂閱功能
  41. var installEvent = function (obj) {
  42. for (var key in event) {
  43. if (event.hasOwnProperty(key)) {
  44. obj[key] = event[key];
  45. }
  46. }
  47. }
  48. /*** 測試 ***/
  49. var salesOffices = {};
  50. installEvent(salesOffices);
  51. // 訂閱者1
  52. salesOffices.listen("squareMeter80", function (price) {
  53. console.log("價格=" + price);
  54. });
  55. // 訂閱者2
  56. salesOffices.listen("squareMeter100", function (price) {
  57. console.log("價格=" + price);
  58. });
  59. // 發布消息
  60. salesOffices.trigger("squareMeter80", 20000);
  61. salesOffices.trigger("squareMeter100", 30000);

登錄案例

</>復制代碼

  1. // 登錄成功, 發布成功消息
  2. $.ajax("http://xxx.com/login", function (data) {
  3. login.trigger("loginSuccess", data);
  4. });
  5. // 這種寫法也很好
  6. var header = (function () {
  7. // 訂閱消息
  8. login.listen("loginSuccess", function (data) {
  9. header.setAvatar(data);
  10. })
  11. return {
  12. setAvatar: function (data) {
  13. console.log("header 模塊拿到用戶信息")
  14. }
  15. }
  16. })();

以上寫法會有三個問題

需要一個類似"中介者"的角色, 把發布者和訂閱者聯系起來(通過 全局的 Event 來解決)

以上必須先訂閱, 才能發布

全局命名的沖突

實現類似 Event 的發布-訂閱模式

優點1: 時間上的解耦,

優點2: 對象之間的解耦

缺點1: 創建訂閱者本生要消耗內存和時間

缺點2: 弱化了對象之間的聯系之后, 對象之間的必要聯系也被埋沒

</>復制代碼

  1. var Event = (function() {
  2. var global = this,
  3. Event,
  4. _default = "default";
  5. Event = function () {
  6. var _listen,
  7. _trigger,
  8. _remove,
  9. _slice = Array.prototype.slice,
  10. _shift = Array.prototype.shift,
  11. _unshift = Array.prototype.unshift,
  12. namespaceCache = {},
  13. _create,
  14. find,
  15. each = function(arr, fn) {
  16. var ret;
  17. for (var i = 0, l = arr.length; i < l; i++) {
  18. var n = arr[i];
  19. ret = fn.call(n, i, n);
  20. }
  21. return ret;
  22. };
  23. _listen = function (key, fn, cache) {
  24. if (!cache[key]) {
  25. cache[key] = [];
  26. }
  27. cache[key].push(fn);
  28. };
  29. _remove = function (key, cache, fn) {
  30. if (cache[eky]) {
  31. if (fn) {
  32. for (var i = cache[key].length - 1; i >= 0; i--) {
  33. if (cache[key][i] === fn) {
  34. cache[key].splice(i, 1);
  35. }
  36. }
  37. } else {
  38. cache[key] = [];
  39. }
  40. }
  41. }
  42. _trigger = function () {
  43. var cache = _shift.call(arguments),
  44. key = _shift.call(arguments),
  45. args = arguments,
  46. _self = this,
  47. ret,
  48. stack = cache[key];
  49. if (!stack || !stack.length) {
  50. return;
  51. }
  52. return each(stack, function () {
  53. return this.apply(_self, args);
  54. })
  55. };
  56. _create = function (namespace) {
  57. namespace = namespace || _default;
  58. var cache = {},
  59. offlineStack = [],
  60. ret = {
  61. listen: function (key, fn, last) {
  62. _listen(key, fn, cache);
  63. if (offlineStack === null) {
  64. return;
  65. }
  66. if (last === "last") {
  67. offlineStack.length && offlineStack.pop()();
  68. } else {
  69. each(offlineStack, function () {
  70. this();
  71. })
  72. }
  73. offlineStack = null;
  74. },
  75. one: function (key, fn, last) {
  76. _remove(key, fn, cache);
  77. this.listen(key, fn, last);
  78. },
  79. remove: function (key, fn) {
  80. _remove(key, cache, fn);
  81. },
  82. trigger: function () {
  83. var fn,
  84. args,
  85. _self = this;
  86. _unshift.call(arguments, cache);
  87. args = arguments;
  88. fn = function () {
  89. return _trigger.apply(_self, args);
  90. }
  91. if (offlineStack) {
  92. return offlineStack.push(fn);
  93. }
  94. return fn();
  95. }
  96. };
  97. return namespace
  98. ? (namespaceCache[namespace]
  99. ? namespaceCache[namespace]
  100. : namespaceCache[namespace] = ret)
  101. : ret
  102. }
  103. return {
  104. create: _create,
  105. one: function (key, fn, last) {
  106. var event = this.create();
  107. event.one(key, fn, last);
  108. },
  109. remove: function (key, fn) {
  110. var event = this.create();
  111. event.remove(key, fn);
  112. },
  113. listen: function (key, fn, last) {
  114. var event = this.create();
  115. event.listen(key, fn, last);
  116. },
  117. trigger: function () {
  118. var event = this.create();
  119. event.trigger.apply(this, arguments);
  120. }
  121. }
  122. }()
  123. return Event;
  124. })();
觀察者(observer) 模式 和 發布/訂閱模式 之間的區別

本質上的區別及時在調度的地方不同

分清楚誰是發布者, 誰是觀察者, 誰是訂閱者

觀察者模式

</>復制代碼

  1. // subject(發布) 中的目標發生變化. Observer(觀察) 能接受到變化
  2. function ObserverList() {
  3. this.observerList = [];
  4. }
  5. ObserverList.prototype.add = function (obj) {
  6. return this.observerList.push(obj);
  7. }
  8. ObserverList.prototype.get = function (index) {
  9. if (index > -1 && this.observerList.length) {
  10. return this.observerList[index];
  11. }
  12. }
  13. ObserverList.prototype.indexOf = function (obj, startIndex) {
  14. var i = startIndex;
  15. while(i < this.observerList.length) {
  16. if (this.observerList[i] === obj) {
  17. return i;
  18. }
  19. i++;
  20. }
  21. return -1;
  22. }
  23. ObserverList.prototype.removeAt = function (index) {
  24. this.observerList.splice(index, 1);
  25. }
  26. // 發布者
  27. function Subject() {
  28. this.observers = new ObserverList();
  29. }
  30. Subject.prototype.addObserver = function (observer) {
  31. this.observers.add(observer);
  32. }
  33. Subject.prototype.removeObserver = function (observer) {
  34. this.observers.removeAt(this.observers.indexOf(observer, 0));
  35. }
  36. Subject.prototype.notify = function (context) {
  37. var observerCount = this.observers.count();
  38. for (var i = 0; i < observerCount; i++) {
  39. this.observers.get(i).update(context);
  40. }
  41. }
  42. // 觀察者
  43. function Observer() {
  44. this.update = function () {
  45. // ...
  46. }
  47. }

發布(Publish)/訂閱(Subscribe)模式

</>復制代碼

  1. var pubsub = {};
  2. (function (myObject) {
  3. var topics = {};
  4. var subUid = -1;
  5. // 發布
  6. myObject.publish = function (topic, args) {
  7. if (!topics[topic]) {
  8. return false;
  9. }
  10. var subscribers = topics[topic],
  11. len = subscribers ? subscribers.length : 0;
  12. while (len--) {
  13. subscribers[len].func(topic, args);
  14. }
  15. return this;
  16. }
  17. // 訂閱者
  18. myObject.subscribe = function (topic, func) {
  19. if (!topics[topic]) {
  20. topics[topic] = [];
  21. }
  22. var token = (++subUid).toString();
  23. topics[topic].push({
  24. token: token,
  25. func: func
  26. })
  27. }
  28. // 取消訂閱
  29. myObject.unsubscribe = function (token) {
  30. for (var m in topics) {
  31. if (topics[m]) {
  32. for (var i = 0, j = topics[m].length; i < j; i++) {
  33. if (topics[m][i].token === token) {
  34. topics[m].splice(i, 1);
  35. return token;
  36. }
  37. }
  38. }
  39. }
  40. return this;
  41. }
  42. })(pubsub)

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://m.specialneedsforspecialkids.com/yun/104533.html

相關文章

  • 前端學習筆記觀察者模式

    摘要:觀察者模式也稱發布訂閱模式它的作用就是當一個對象的狀態發生改變時,所有依賴于它的對象都將得到通知,自動刷新對象狀態舉個生活比較常見常見的例子比如你去面試之后,面試官看你表現不錯,最后會跟你要聯系方式,以便之后可以聯系你。 觀察者模式也稱發布-訂閱模式,它的作用就是當一個對象的狀態發生改變時,所有依賴于它的對象都將得到通知,自動刷新對象狀態 舉個生活比較常見常見的例子,比如你去面試之后,...

    tommego 評論0 收藏0
  • JavaScript設計模式發布-訂閱模式(觀察者模式)-Part1

    摘要:設計模式與開發實踐讀書筆記。發布訂閱模式又叫觀察者模式,它定義了對象之間的一種一對多的依賴關系。附設計模式之發布訂閱模式觀察者模式數據結構和算法系列棧隊列優先隊列循環隊列設計模式系列設計模式之策略模式 《JavaScript設計模式與開發實踐》讀書筆記。 發布-訂閱模式又叫觀察者模式,它定義了對象之間的一種一對多的依賴關系。當一個對象的狀態發生改變時,所有依賴它的對象都將得到通知。 例...

    muzhuyu 評論0 收藏0
  • vue 雙向數據綁定的實現學習(一)

    摘要:雙向數據綁定簡言之數據動頁面動,頁面動,數據動典型的應用就是在做表單時候,輸入框的內容改動后,跟該輸入框的的值改動。看官網上的這個的演示案例雙向數據綁定的好處要說出這個好處的時候,也只有在實際場景中才能對應的顯示出來。 前言:本系列學習筆記從以下幾個點展開 什么是雙向數據綁定 雙向數據綁定的好處 怎么實現雙向數據綁定 實現雙向數據數據綁定需要哪些知識點 數據劫持 發布訂閱模式 ...

    anonymoussf 評論0 收藏0
  • JavaScript設計模式發布-訂閱模式(觀察者模式)-Part2

    摘要:設計模式與開發實踐讀書筆記。看此文章前,建議先看設計模式之發布訂閱模式觀察者模式在中,已經介紹了什么是發布訂閱模式,同時,也實現了發布訂閱模式。 《JavaScript設計模式與開發實踐》讀書筆記。 看此文章前,建議先看JavaScript設計模式之發布-訂閱模式(觀察者模式)-Part1 在Part1中,已經介紹了什么是發布-訂閱模式,同時,也實現了發布-訂閱模式。但是,就Part1...

    Charlie_Jade 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<