‫‪Design-Pattern‬‬

‫‪Friday, April 18, 2025‬‬ ‫‪10:31 PM‬‬

‫‪Design patterns : typical solutions to commonly occurring problems in software design‬‬

‫ﺟﯿﺖ ﺗﻘﺪم ﺣﻠﻮل ﻧﻤﻮذﺟﯿﮫ وﻓﻌﺎﻟﮫ ﻟﻤﺸﺎﻛﻞ ﻗﺒﻠﻨﺎھﺎ ﻗﺒﻞ ﻛﺪه وﻋﺸﺎن ﻛﺪه ﻣﻦ اﻟﻤﮭﻢ اﻧﻚ ﺗﻌﺮف ﻓﻲ ‪Design patterns‬‬
‫وﻋﻠﺸﺎن ﺗﻘﺪر ﺗﺤﻞ اﻟﻤﺸﺎﻛﻞ دي وﺗﻘﺪر ﺗﻌﻤﻞ ‪object Oriented Software‬‬
‫اﻗﺪر اﻋﻤﻠﮫ‬
‫‪ : re-useable-1‬ﻧﻘﺪر ﻧﻌﯿﺪ اﺳﺘﻌﻤﺎﻟﮫ‬
‫‪ : Maintainability -2‬ﻗﺎﺑﻞ ﻟﻠﺼﯿﺎﻧﮫ واﻟﺘﻌﺪﯾﻞ ﻓﯿﮫ‬

‫‪It’s more of general concept for solving problems rather than a piece of code‬‬

‫ھﻲ ﻋﺒﺎره ﻋﻦ‪ general concept‬ﻣﻤﻜﻦ ﺗﻌﻤﻞ ﻟﯿﮭﺎ ‪ customization‬ﺣﺴﺐ اﻟﻤﺸﻜﻠﮫ او اﻟﻜﻮد ﺑﺘﺎﻋﻚ‬

‫‪Type Design patterns:‬‬

‫ﺑﻄﺮﯾﻘﮫ ﻣﺮﻧﮫ ‪1- Creational :‬‬

‫ﺟﮫ ﯾﺤﻞ ﻣﺸﺎﻛﻞ ﻟﯿﮭﺎ ﻋﻼﻗﮫ ب ‪ object creation‬وازاي اﺑﻨﻲ ال ‪object‬‬

‫‪2- STRUCTURAL :‬‬

‫‪o‬‬
‫ﺟﮫ ﯾﻮﻓﺮ ﻟﯿﻨﺎ ﺣﻠﻮل ﻟﻌﻼﻗﮫ ال ‪ object‬ﺑﺒﻌﻀﮭﺎ اﻟﺒﻌﺾ وازاي ﻧﻘﺪر ﻧﺠﻤﻌﮭﺎ ف ‪ structure‬ﻛﺒﯿﺮ‬
‫ﯾﻌﻨﻲ زي ﻟﻤﺎ ﺗﻜﻮن ﺑﺘﺒﻨﻲ ﻋﻤﺎرة ﻻزم ﺗﻌﺮف إزاي ﺗﺮﺑﻂ اﻟﻐﺮف ﺑﺒﻌﻀﮭﺎ‬

‫‪3- Behavioral :‬‬

‫‪et‬‬
‫ﺟﮫ ﯾﻮﻓﺮ ﺣﻠﻮل ﻟﯿﮭﺎ ﻋﻼﻗﮫ ب ‪ communication‬ﺑﯿﻦ ال ‪ object‬وﺑﻌﻀﮭﺎ وازاي ھﯿﻜﻠﻤﻮا ﺑﻌﺾ‬
‫ﯾﻌﻨﻲ زي ﻟﻤﺎ ﺗﻜﻮن ﻓﻲ ﻓﺮﯾﻖ ﺷﻐﻞ‪ ،‬ﻻزم ﺗﻌﺮف ﻣﯿﻦ ھﯿﺘﻮاﺻﻞ ﻣﻊ ﻣﯿﻦ‪ ،‬وﻣﯿﻦ ھﯿﻌﻤﻞ إﯾﮫ واﻣﺘﻰ ‪.‬اﻟﺴﻠﻮﻛﯿﺔ ﺑﺘﺤﺪد‬
‫وﺑﺘﻮزع اﻟﻤﺴﺆوﻟﯿﺎت ﺑﯿﻨﮭﻢ‪.‬‬
‫ّ‬ ‫إزاي اﻷوﺑﺠﻜﺘﺲ ﺑﺘﺘﻔﺎﻋﻞ ﻣﻊ ﺑﻌﻀﮭﺎ‬
‫‪Sh‬‬
‫‪############################################################‬‬
‫_‪R‬‬

‫‪SOLID‬‬
‫‪-----------------------------‬‬
‫‪M‬‬

‫ﻣﺒﺎدئ ‪SOLID‬دي زي اﻟﻘﻮاﻋﺪ اﻟﻠﻲ ﺑﺘﻤﺸﻲ ﻋﻠﯿﮭﺎ وإﻧﺖ ﺑﺘﻜﺘﺐ ﻛﻮد ﻋﺸﺎن ﻟﻤﺎ اﻟﺪﻧﯿﺎ ﺗﻜﺒﺮ ﻣﺎ ﺗﻘﻌﺶ ﻋﻠﻰ دﻣﺎﻏﻚ ‪.‬‬

‫أﻧﺎ ھﻘﺴﻤﮭﺎ ﻟﻚ واﺣﺪة واﺣﺪة ﺑﻄﺮﯾﻘﺔ ﺑﺴﯿﻄﺔ‪.‬‬

‫‪Single Responsibility: A class should have only reason to change‬‬ ‫• اﻟـ ‪ S -‬ﯾﻌﻨﻲ ﻛﻞ ﺣﺎﺟﺔ ﻟﯿﮭﺎ ﺷﻐﻼﻧﺔ واﺣﺪة ﺑﺲ‪:‬‬

‫ﯾﻌﻨﻲ ﻟﻤﺎ ﺗﻌﻤﻞ ﻛﻼس ﻣﺎ ﺗﺤﻄﺶ ﻓﯿﮫ ﻛﻞ ﺣﺎﺟﺔ ﻛﻞ ﻛﻼس ﯾﺒﻘﻰ ﻣﺴﺆول ﻋﻦ ﺣﺎﺟﺔ واﺣﺪة ‪.‬‬
‫زي ﻟﻮ ﻋﻨﺪك ﺳﻮﺑﺮ ﻣﺎرﻛﺖ ﻣﺎ ﺗﺨﻠﯿﺶ اﻟﻠﻲ ﺑﯿﺤﺎﺳﺐ ھﻮ ﻧﻔﺴﮫ اﻟﻠﻲ ﺑﯿﺤﻂ اﻟﺒﻀﺎﻋﺔ ﻋﻠﻰ اﻟﺮﻓﻮف ﻛﻞ واﺣﺪ ﻟﯿﮫ ﺷﻐﻼﻧﺘﮫ‪.‬‬
‫ﻣﺜﺎل ‪:‬ﻟﻮ ﻋﻨﺪك ﻛﻼس ﺑﯿﻌﻤﻞ ﺣﺴﺎﺑﺎت اﻟﺮواﺗﺐ ﻣﺎ ﺗﺨﻠﯿﮭﻮش ھﻮ ﻧﻔﺴﮫ اﻟﻠﻲ ﯾﺒﻌﺖ إﯾﻤﯿﻼت ﻟﻠﻤﻮظﻔﯿﻦ ﺧﻠﻲ ﻛﻼس ﺗﺎﻧﻲ ﯾﻌﻤﻞ ﺷﻐﻞ اﻹﯾﻤﯿﻼت‪.‬‬

‫‪Design-Pattern Page 1‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫زي ﻣﺎﻧﺖ ﺷﺎﯾﻒ ال ‪ class‬ﺑﯿﻀﻢ اﻛﺘﺮ ﻣﻦ ‪ function‬ﺑﺘﻌﻤﻞ ﺣﺎﺟﺎت ﻣﺨﺘﻠﻔﮫ ودا ﺑﯿﻜﺴﺮ‬
‫اول ﻣﺒﺪء ان ﻛﻞ ﻛﻼس ﺑﯿﻌﻤﻞ ﺣﺎﺟﮫ واﺣﺪه ﺑﺲ‬

‫ف اﻟﺤﻞ اﻧﻨﺎ ﻧﻜﺮﯾﺖ ﻛﻼس ﻟﻜﻞ ‪function‬‬

‫‪o‬‬
‫• اﻟـ ‪ O -‬ﯾﻌﻨﻲ ﺧﻠﻲ اﻟﻜﻼس ﻣﻔﺘﻮح ﻟﻠﺰﯾﺎدة ﺑﺲ ﻣﺶ ﻟﻠﺘﻌﺪﯾﻞ‪:‬‬

‫‪Open Closed principle (OCP) : Software entities should open for extension but closed for modification‬‬

‫‪et‬‬ ‫• ﯾﻌﻨﻲ ﻟﻤﺎ ﺗﻌﻤﻞ ﺣﺎﺟﺔ‪ ،‬ﻟﻮ ﻋﺎﯾﺰ ﺗﻀﯿﻒ ﻋﻠﯿﮭﺎ ﺑﻌﺪﯾﻦ ﻣﺎ ﺗﻀﻄﺮش ﺗﻜﺴﺮ اﻟﻜﻮد اﻟﻘﺪﯾﻢ‪.‬‬
‫زي ﻟﻮ ﺑﺘﺒﻨﻲ ﺑﯿﺖ ﻣﻤﻜﻦ ﺗﺰود أوﺿﺔ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﮭﺪ اﻟﻠﻲ ﺑﻨﯿﺘﮫ‪.‬‬
‫ﻣﺜﺎل ‪:‬ﻟﻮ ﻋﻨﺪك ﻛﻼس ﺑﯿﺤﺴﺐ اﻟﺨﺼﻢ وﻛﻞ ﻣﺎ ﯾﺠﯿﻠﻚ ﻧﻮع ﺧﺼﻢ ﺟﺪﯾﺪ ﺑﺘﻐﯿﺮ ﻓﻲ اﻟﻜﻼس ده ﻏﻠﻂ ‪.‬‬
‫اﻋﻤﻞ إﻧﺘﺮﻓﯿﺲ وﻛﻞ ﻧﻮع ﺧﺼﻢ ﯾﺒﻘﻰ ﻓﻲ ﻛﻼس ﻟﻮﺣﺪه ﻋﺸﺎن ﺗﻀﯿﻒ ﺑﺴﮭﻮﻟﺔ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻐﯿﺮ اﻟﻘﺪﯾﻢ‪.‬‬
‫‪Sh‬‬
‫•‬
‫• اﻟـ ‪ L -‬ﯾﻌﻨﻲ اﻟﻠﻲ ﯾﯿﺠﻲ ﻣﻜﺎن اﻟﻠﻲ ﻗﺒﻠﮫ ﻻزم ﯾﺸﺘﻐﻞ زﯾﮫ‪:‬‬

‫‪Liskov substitution : If C is a subtype of P then object of type P in a program may be replaced with‬‬
‫_‪R‬‬

‫‪object of type C without altering any of the desirable properties of that program‬‬
‫ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪك ﻛﻼس أب وﻛﻼس اﺑﻦ ﻣﻨﮫ‪ ،‬اﻻﺑﻦ ﻻزم ﯾﻘﺪر ﯾﺸﺘﻐﻞ ﻣﻜﺎن اﻷب ﻣﻦ ﻏﯿﺮ ﻣﺎ ﯾﻌﻤﻞ ﻣﺸﺎﻛﻞ ‪.‬زي ﻟﻮ ﻋﻨﺪك ﻣﻮﺑﺎﯾﻞ ﻗﺪﯾﻢ وﻣﻮﺑﺎﯾﻞ ﺟﺪﯾﺪ‪ ،‬ﻻزم اﻟﺠﺪﯾﺪ ﯾﻌﻤﻞ ﻛﻞ‬
‫ﺣﺎﺟﺔ اﻟﻘﺪﯾﻢ ﻛﺎن ﺑﯿﻌﻤﻠﮭﺎ وأﻛﺘﺮ‪ ،‬ﻣﺶ أﻗﻞ‪.‬‬
‫ﻣﺜﺎل ‪:‬ﻟﻮ ﻋﻨﺪك ﻛﻼس" ﻋﺮﺑﯿﺔ "وﻛﻼس اﺑﻦ ﻣﻨﮫ" ﻋﺮﺑﯿﺔ ﺳﺒﺎق"‪ ،‬ﻻزم" ﻋﺮﺑﯿﺔ ﺳﺒﺎق "ﺗﻘﺪر ﺗﺘﺤﻂ ﻓﻲ أي ﺣﺘﺔ ﻛﻨﺖ ﺑﺘﺤﻂ ﻓﯿﮭﺎ" ﻋﺮﺑﯿﺔ "ﻣﻦ ﻏﯿﺮ ﻣﺎ اﻟﺴﯿﺴﺘﻢ ﯾﻔﺮﻗﻊ‪.‬‬
‫‪M‬‬

‫• اﻟـ ‪ I -‬ﯾﻌﻨﻲ ﻣﺎ ﺗﺠﺒﺮش ﺣﺪ ﻋﻠﻰ ﺣﺎﺟﺔ ﻣﺶ ھﯿﺴﺘﺨﺪﻣﮭﺎ‪:‬‬

‫‪Interface Segregation : No code should be forced to depend on methods it does not use‬‬
‫‪ISP spill it interface that they are very large into the similar and the more specific ones‬‬

‫ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪك إﻧﺘﺮﻓﯿﺲ ﻓﯿﮫ ﻣﯿﺜﻮدات ﻛﺘﯿﺮ‪ ،‬ﻣﺎ ﺗﺠﺒﺮش ﻛﻞ ﻛﻼس ﯾﺴﺘﺨﺪم ﻛﻞ اﻟﻤﯿﺜﻮدات دي ‪.‬زي ﻟﻮ ﺑﺘﻌﻤﻞ ﻋﻘﺪ ﺷﻐﻞ‪ ،‬ﻣﺎ ﺗﺤﻄﺶ ﻓﯿﮫ ﺣﺎﺟﺎت ﻣﺶ ھﺘﻨﻔﻊ اﻟﻠﻲ ھﯿﻮﻗّﻊ‪.‬‬
‫ﻣﺜﺎل ‪:‬ﻟﻮ ﻋﻨﺪك إﻧﺘﺮﻓﯿﺲ ﻓﯿﮫ ﻣﯿﺜﻮد" ﯾﻄﯿﺮ "وﻣﯿﺜﻮد" ﯾﻌﻮم"‪ ،‬ﻣﺎ ﺗﺠﺒﺮش ﻛﻼس" ﻛﻠﺐ "ﯾﻨﻔﺬ" ﯾﻄﯿﺮ"‪ ،‬ﻗﺴّﻢ اﻹﻧﺘﺮﻓﯿﺲ ﻟﺠﺰﺋﯿﻦ‪ ،‬ﺟﺰء ﻟﻠﻲ ﺑﯿﻄﯿﺮ وﺟﺰء ﻟﻠﻲ ﺑﯿﻌﻮم‪.‬‬

‫• اﻟـ ‪ D -‬ﯾﻌﻨﻲ ﻣﺎ ﺗﻌﺘﻤﺪش ﻋﻠﻰ ﺣﺎﺟﺔ ﻣﺒﺎﺷﺮة‪ ،‬اﻋﺘﻤﺪ ﻋﻠﻰ وﺳﯿﻂ‪:‬‬

‫‪Dependency inversion : high level modules should not depend on low level modules both should depend on abstraction‬‬
‫‪abstraction should not depend on detail details the should depend on abstraction‬‬

‫ﯾﻌﻨﻲ اﻟﻜﻼﺳﺎت اﻟﻜﺒﯿﺮة ﻣﺎ ﺗﻌﺘﻤﺪش ﻋﻠﻰ اﻟﻜﻼﺳﺎت اﻟﺼﻐﯿﺮة ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ ﺧﻠﻲ ﻓﯿﮫ إﻧﺘﺮﻓﯿﺲ وﺳﯿﻂ‪.‬‬
‫زي ﻟﻮ ﺑﺘﺒﻨﻲ ﻣﺸﺮوع ﻣﺎ ﺗﺘﻌﺎﻣﻠﺶ ﻣﻊ اﻟﻌﻤﺎل واﺣﺪ واﺣﺪ اﺗﻌﺎﻣﻞ ﻣﻊ اﻟﻤﻘﺎول وھﻮ ﯾﻈﺒﻂ‪.‬‬
‫ﻣﺜﺎل ‪:‬ﻟﻮ ﻋﻨﺪك ﻛﻼس ﺑﯿﺴﺘﺨﺪم ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ، MySQL‬ﻣﺎ ﺗﻌﻤﻠﺶ اﻟﺮﺑﻂ ﻣﺒﺎﺷﺮة‪ ،‬اﻋﻤﻞ إﻧﺘﺮﻓﯿﺲ" داﺗﺎﺑﯿﺰ "وﺧﻠّﻲ اﻟﻜﻼس ﯾﻌﺘﻤﺪ ﻋﻠﯿﮫ‪ ،‬ﻋﺸﺎن ﻟﻮ ﻏﯿﺮت ﻟـ‬
‫‪PostgreSQL‬ﻣﺎ ﺗﺘﻌﺒﻜﺶ‪.‬‬

‫‪Design-Pattern Page 2‬‬ ‫‪Mahmoud Shetawy‬‬

Sunday, April 20, 2025 2:12 PM

r n s
t te
Pa
ra l o
et
v i o
Sh

e h a
B
R_
M

Mahmoud Shetawy
Design-Pattern Page 3
‫‪Strategy Pattern‬‬
‫‪Tuesday, July 1, 2025‬‬ ‫‪2:49 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪Strategy Pattern‬‬

‫ھﻮ ﻧﻤﻂ ﺗﺼﻤﯿﻢ ﺳﻠﻮﻛﻲ ﺑﻨﺴﺘﺨﺪﻣﮫ ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪﻧﺎ أﻛﺘﺮ ﻣﻦ طﺮﯾﻘﺔ ﻟﺤﻞ ﻣﺸﻜﻠﺔ ﻣﻌﯿﻨﺔ وﻛﻞ طﺮﯾﻘﺔ دي ﺧﻮارزﻣﯿﺔ ﻣﺴﺘﻘﻠﺔ‪.‬‬

‫اﻟﻔﻜﺮة إﻧﮫ ﺑﯿﻔﺼﻞ طﺮﯾﻘﺔ اﻟﺘﻨﻔﯿﺬ ﻋﻦ اﻟﻜﻼس اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪﻣﮭﺎ ﺑﺤﯿﺚ ﺗﻘﺪر ﺗﻐﯿﺮ طﺮﯾﻘﺔ اﻟﺘﻨﻔﯿﺬ دي واﻧﺖ ﺷﻐﺎل ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻌﺪل ﻓﻲ اﻟﻜﻼس اﻷﺳﺎﺳﻲ‪.‬‬

‫اﻟﻐﺮض اﻷﺳﺎﺳﻲ ﻣﻦ ‪Strategy Pattern‬‬

‫إﻧﻚ ﺗﺨﻠﻲ ﻋﻨﺪك ﻣﺮوﻧﺔ ﻛﺒﯿﺮة ﻓﻲ اﺧﺘﯿﺎر وﺗﺒﺪﯾﻞ اﻟﻄﺮق ﺑﺪل ﻣﺎ ﯾﺒﻘﻰ ﻋﻨﺪك ﺷﻮﯾﺔ ‪ if else‬ﺟﻮا اﻟﻜﻼس‬
‫ﺑﺘﺨﻠﻲ ﻛﻞ طﺮﯾﻘﺔ ﻓﻲ ﻛﻼس ﻟﻮﺣﺪھﺎ واﻟﻜﻼس اﻟﺮﺋﯿﺴﻲ ﻣﺎ ﯾﻌﺮﻓﺶ أي ﺗﻔﺎﺻﯿﻞ ﻋﻨﮭﻢ‬
‫ھﻮ ﺑﺲ ﺑﯿﺴﺘﺪﻋﯿﮭﻢ ﻋﻦ طﺮﯾﻖ ‪ interface‬ﻣﻮﺣﺪ‬

‫ﺗﺨﯿﻞ ﻛﺪه ﻣﻌﺎﯾﺎ‬

‫إﻧﺖ ﻓﺎﺗﺢ ﺷﺮﻛﺔ ﺗﻮﺻﯿﻞ طﻠﺒﺎت ﻛﺒﯿﺮة ﻛﻞ ﯾﻮم اﻟﺰﺑﺎﯾﻦ ﺑﯿﻄﻠﺒﻮا ﺗﻮﺻﯿﻞ ﺑﻄﺮق ﻣﺨﺘﻠﻔﺔ‪:‬‬

‫‪o‬‬
‫زﺑﻮن ﻋﺎوز اﻟﺘﻮﺻﯿﻞ ﯾﻜﻮن ﺑﺄرﺧﺺ طﺮﯾﻘﺔ )ﻣﺸﻲ ً‬
‫ﻣﺜﻼ(‬
‫{ )"‪if (type == "walking‬‬ ‫زﺑﻮن ﺗﺎﻧﻲ ﻣﺴﺘﻌﺠﻞ وﻋﺎوز ﻋﺮﺑﯿﺔ‪.‬‬
‫ﺣﺴﺎب ﺗﻜﻠﻔﺔ اﻟﻤﺸﻲ ‪//‬‬ ‫زﺑﻮن ﺗﺎﻟﺖ ﻋﻨﺪه ﺷﺤﻨﺔ ﻛﺒﯿﺮة وﻋﺎوز ﺷﺎﺣﻨﺔ‬
‫{ )"‪} else if (type == "car‬‬
‫ﺣﺴﺎب ﺗﻜﻠﻔﺔ اﻟﻌﺮﺑﯿﺔ ‪//‬‬
‫{ )"‪} else if (type == "truck‬‬
‫‪et‬‬ ‫ﻟﻮ اﻧﺖ ﻛﻞ ﻣﺮة ھﺘﻜﺘﺐ ﻛﻮد ﺑﺎﻟﺸﻜﻞ ده‪:‬‬
‫‪Sh‬‬
‫ﺣﺴﺎب ﺗﻜﻠﻔﺔ اﻟﺸﺎﺣﻨﺔ ‪//‬‬
‫}‬
‫ھﺘﻼﻗﻲ ﻧﻔﺴﻚ ﺑﻌﺪ ﺷﮭﺮ‪:‬‬
‫اﻟﻜﻮد اﺗﻌﻘﺪ ﺟﺪا‬
‫ﻛﻞ ﻣﺎ ﺗﺤﺐ ﺗﻀﯿﻒ طﺮﯾﻘﺔ ﺟﺪﯾﺪة ھﺘﺪﺧﻞ ﺗﻌﺪل ﺟﻮه اﻟﻜﻮد اﻷﺳﺎﺳﻲ‪.‬‬
‫ﻟﻮ ﺣﺼﻞ ﺧﻄﺄ ھﺘﻔﻀﻞ ﺗﺪور ﻓﻲ اﻟﺸﺮوط‪.‬‬
‫_‪R‬‬

‫وﻋﺸﺎن ﻛﺪه ‪ Strategy Pattern‬ﺟﮫ ﯾﻘﻮﻟﻚ‪:‬‬

‫ﯾﺎ ﻋﻢ ﺑﺪل ﻣﺎ ﺗﻐﻠﺐ ﻧﻔﺴﻚ ﺧﻠﻲ ﻛﻞ طﺮﯾﻘﺔ ﻟﻮﺣﺪھﺎ ﻓﻲ ﻛﻼس ﻣﻨﻔﺼﻞ وﺧﻠﻲ ﻋﻨﺪك ﻛﺎﺋﻦ رﺋﯿﺴﻲ ﺑﯿﺨﺘﺎر أي واﺣﺪة ﯾﺴﺘﺨﺪﻣﮭﺎ وﻗﺖ ﻣﺎ ﺗﺤﺐ‬
‫‪M‬‬

‫ﺑﯾﺗﻛون ﻣن ﺗﻼت ﺣﺎﺟﺎت ﻣﮭﻣﺔ‪.‬‬

‫‪ .1‬أول ﺣﺎﺟﺔ ‪ Strategy Interface‬وده اﻟﻠﻲ ﺑﯾﺣدد اﻟدوال اﻟﻣﺷﺗرﻛﺔ‬
‫اﻟﻠﻲ ﻛل طرﯾﻘﺔ ﻻزم ﺗﻧﻔذھﺎ‪.‬‬
‫‪ .2‬ﺗﺎﻧﻲ ﺣﺎﺟﺔ ‪ Concrete Strategies‬ودي اﻟﻛﻼﺳﺎت اﻟﻠﻲ ﻓﯾﮭﺎ اﻟﺧوارزﻣﯾﺎت اﻟﻣﺧﺗﻠﻔﺔ‪.‬‬

‫‪ .3‬ﺗﺎﻟت ﺣﺎﺟﺔ ‪ Context‬وده اﻟﻛﻼس اﻟﻠﻲ ﺑﯾﺳﺗﺧدم اﻻﺳﺗراﺗﯾﺟﯾﺔ وﺑﯾﻧﺎدي ﻋﻠﯾﮭﺎ وﻗت ﻣﺎ ﯾﺣﺗﺎج ﯾﻧﻔذ اﻟﺳﻠوك‪.‬‬

‫اﻟﻔﻮاﺋﺪ اﻟﺮﺋﯿﺴﯿﺔ ﻻﺳﺘﺨﺪام ‪Strategy Pattern‬‬

‫‪ ‬أول ﻓﺎﯾﺪة إﻧﻚ ﺑﺘﻔﺼﻞ اﻟﺴﻠﻮك ﻋﻦ اﻟﻜﺎﺋﻦ ﻧﻔﺴﮫ وده ﺑﯿﺨﻠﻲ اﻟﻜﻮد أﺳﮭﻞ ﻓﻲ اﻟﻔﮭﻢ واﻟﺼﯿﺎﻧﺔ‬
‫‪ ‬ﺗﺎﻧﻲ ﻓﺎﯾﺪة إﻧﻚ ﺗﻘﺪر ﺗﻀﯿﻒ ﺧﻮارزﻣﯿﺎت ﺟﺪﯾﺪة ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻌﺪل ﺣﺎﺟﺔ ﻓﻲ اﻟﻜﻮد اﻟﻤﻮﺟﻮد‬
‫‪ ‬ﺗﺎﻟﺖ ﻓﺎﯾﺪة إﻧﻚ ﺗﻘﺪر ﺗﺨﺘﺒﺮ ﻛﻞ اﺳﺘﺮاﺗﯿﺠﯿﺔ ﻟﻮﺣﺪھﺎ ﺑﺴﮭﻮﻟﺔ‬
‫‪ ‬راﺑﻊ ﻓﺎﯾﺪة إﻧﻚ ﺗﻘﺪر ﺗﺒﺪل اﻟﺴﻠﻮك ﻓﻲ وﻗﺖ اﻟﺘﺸﻐﯿﻞ ﻋﻠﻰ ﺣﺴﺐ اﻟﻈﺮوف‬

‫‪Design-Pattern Page 5‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ راﺑﻊ ﻓﺎﯾﺪة إﻧﻚ ﺗﻘﺪر ﺗﺒﺪل اﻟﺴﻠﻮك ﻓﻲ وﻗﺖ اﻟﺘﺸﻐﯿﻞ ﻋﻠﻰ ﺣﺴﺐ اﻟﻈﺮوف‬

#################################################################

!!!!!!!!!!!!!!! ‫ﺗﻌﺎﻟﻲ ﻧﺸﻮف ﻣﻮﻗﻒ ھﻨﻔﻜﺮ ﻓﯿﮫ ازاي‬

you're developing an e-commerce platform

where different products may have varying pricing logic based on factors such as customer segment.

We have regular, gold and premium membership.

Once product price is calculated,

then at the checkout the customer could pay with different methods like PayPal, VisaCard and Bank_Transfer.

Each payment method vary in it’s logic of processing the payment and conducting required fees

‫إﻧﺖ ﻋﻨﺪك ﻣﻨﺼﺔ ﻻزم ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺣﺎﺟﺘﯿﻦ رﺋﯿﺴﯿﺘﯿﻦ ﺑﺸﻜﻞ ﻣﻨﻔﺼﻞ‬

.‫ ﻓﯿﮫ ﺧﺼﻢ أﻛﺒﺮ‬Premium ‫ ﻓﯿﮫ ﺧﺼﻢ ﻟﻮ‬Gold ‫ اﻟﺴﻌﺮ ﺛﺎﺑﺖ ﻟﻮ‬Regular ‫ أول ﺣﺎﺟﺔ إن اﻟﺴﻌﺮ اﻟﻨﮭﺎﺋﻲ ﻟﻠﻤﻨﺘﺞ ﻣﺶ ﺛﺎﺑﺖ ﺑﯿﺘﻐﯿﺮ ﺣﺴﺐ ﻧﻮع ﻋﻀﻮﯾﺔ اﻟﻌﻤﯿﻞ ﯾﻌﻨﻲ ﻟﻮ‬.1
.‫ ﺗﺎﻧﻲ ﺣﺎﺟﺔ إن ﺑﻌﺪ ﻣﺎ ﺗﺤﺴﺐ اﻟﺴﻌﺮ اﻟﻌﻤﯿﻞ ھﯿﺨﺘﺎر طﺮﯾﻘﺔ اﻟﺪﻓﻊ وﻛﻞ طﺮﯾﻘﺔ ﻟﯿﮭﺎ رﺳﻮم ﻣﺨﺘﻠﻔﺔ وطﺮﯾﻘﺔ ﻣﻌﺎﻟﺠﺔ اﻟﺪﻓﻊ ﻣﺨﺘﻠﻔﺔ‬.2

o
et
Sh
R_

public void processPayment(double payment, PaymentMethod paymentMethod) {

if ([Link](PaymentMethod.VISA_CARD)) {

[Link]("Processing Visa Card Payment");

if else ‫ وﻛﺎن ﺑﯿﻌﺘﻤﺪ ﻋﻠﻰ‬Strategy Pattern ‫ده ﻛﺎن اﻟﻜﻮد ﻗﺒﻞ ﻣﺎ ﻧﺴﺘﺨﺪم‬
M

[Link]("Calculating fees of amount for Visa Card Payment");

:‫ﻋﻠﺸﺎن ﯾﺤﺪد طﺮﯾﻘﺔ اﻟﺪﻓﻊ وﯾﺤﺴﺐ اﻟﺮﺳﻮم وده ﻛﺎن ﺑﯿﺨﻠﻲ اﻟﻜﻮد ﺻﻌﺐ اﻟﺘﻮﺳﻊ واﻟﺼﯿﺎﻧﺔ‬
}

else if (paymentMethod .equals([Link])) {

[Link]("Processing PAYPALPayment");

[Link]("Calculating fees of amount for PAYPAL Payment");

else if ([Link](PaymentMethod.BANK_TRANSFER)) {

[Link]("Processing Bank Transfer");

[Link]("Calculating fees of amount for Bank Transfer");

،Strategy Pattern ‫وده اﻟﻠﻲ ﺑﻌﺪ ﻛﺪه ھﻨﺤﺴﻨﮫ ﻋﻦ طﺮﯾﻖ إﻧﻨﺎ ﻧﻔﺼﻞ ﻛﻞ طﺮﯾﻘﺔ دﻓﻊ ﻓﻲ ﻛﻼس ﻣﺴﺘﻘﻞ وﻧﺴﺘﺨﺪم‬
.‫ ﻛﻞ ﻣﺮة‬if else ‫ﺑﺤﯿﺚ ﻟﻮ ﺣﺒﯿﻨﺎ ﻧﻀﯿﻒ طﺮﯾﻘﺔ دﻓﻊ ﺟﺪﯾﺪة ﻣﺶ ھﻨﻀﻄﺮ ﻧﻌﺪل اﻟـ‬

Design-Pattern Page 6 Mahmoud Shetawy

 ‫ﺑﻜﺪه ﯾﺎ ﺟﻤﺎﻋﺔ أﻧﺎ طﺒﻘﺖ اﻟـ ‪ Strategy Pattern‬ﺑﺸﻜﻞ ﻛﺎﻣﻞ ﺑﺤﯿﺚ ﻛﻞ طﺮﯾﻘﮫ ﺧﺎص ﺑﺎﻟﺘﺴﻌﯿﺮ وﻛﻞ طﺮﯾﻘﮫ ﺧﺎص ﺑﺎﻟﺪﻓﻊ ﺑﻘﻰ ﻣﻮﺟﻮد ﻓﻲ ﻛﻼس ﻣﺴﺘﻘﻞ ﻟﻮﺣﺪه‬

‫واﻟـ ‪ Product‬واﻟـ ‪ Checkout‬ﻣﺎ ﺑﻘﻮش ﯾﻌﺮﻓﻮا ﺗﻔﺎﺻﯿﻞ اﻟﺘﻨﻔﯿﺬ ﻛﻞ اﻟﻠﻲ ﺑﯿﻌﻤﻠﻮه إﻧﮭﻢ ﺑﯿﻨﺎدوا ﻋﻠﻰ اﻟـ ‪ Strategy‬اﻟﻠﻲ اﺗﺤﺪدت‬
‫ده ﺧﻠﻰ اﻟﻜﻮد ﻣﺮن ﺟﺪًا وﺳﮭﻞ إﻧﻨﺎ ﻧﻀﯿﻒ أي طﺮﯾﻘﺔ ﺟﺪﯾﺪة ﻓﻲ اﻟﻤﺴﺘﻘﺒﻞ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﻧﻌﺪل أي ﺣﺎﺟﺔ ﻓﻲ اﻟﻜﻼﺳﺎت اﻷﺳﺎﺳﯿﺔ‬

‫‪o‬‬
‫‪CODE :‬‬ ‫‪Mahmoud-Shetawy/Design-Pattern‬‬

‫‪et‬‬ ‫اﻟﻌﯿﻮب اﻟﻠﻲ ﻻزم ﺗﺎﺧﺪ ﺑﺎﻟﻚ ﻣﻨﮭﺎ‬

‫أھﻢ ﻋﯿﺐ إﻧﻚ ﺑﺘﺰود ﻋﺪد اﻟﻜﻼﺳﺎت ﻓﻲ اﻟﻤﺸﺮوع وده ﺳﺎﻋﺎت ﺑﯿﻜﻮن أوﻓﺮ ﻟﻮ اﻟﻤﺸﺮوع ﺑﺴﯿﻂ ﺟﺪا‬
‫‪Sh‬‬
‫ﻋﯿﺐ ﺗﺎﻧﻲ إن ﻻزم اﻟﻠﻲ ھﯿﺴﺘﺨﺪم ‪ pattern‬ده ﯾﺒﻘﻰ ﻓﺎھﻢ ﻛﻮﯾﺲ إﯾﮫ اﻻﺳﺘﺮاﺗﯿﺠﯿﺔ اﻟﺼﺢ ﻋﺸﺎن ﻣﯿﺤﺼﻠﺶ ﻟﺨﺒﻄﺔ‬

‫إﻣﺘﻰ ﺗﺴﺘﺨﺪم‪Strategy Pattern‬‬

‫_‪R‬‬

‫ﺑﺺ ﯾﺎ ﺳﯿﺪي اﻟـ ‪ Strategy Pattern‬ﺑﺘﺴﺘﺨﺪﻣﮫ ﻓﻲ اﻟﺤﺎﻻت اﻟﻠﻲ ﺑﯿﺒﻘﻰ ﻋﻨﺪك ﻓﯿﮭﺎ ﻧﻔﺲ اﻟﮭﺪف اﻟﻨﮭﺎﺋﻲ ﺑﺲ اﻟﻄﺮق اﻟﻠﻲ ﺑﺘﺤﻘﻖ اﻟﮭﺪف ده ﻣﺨﺘﻠﻔﺔ وﻣﻤﻜﻦ ﺗﺘﻐﯿﺮ‪.‬‬

‫ﻣﻼﺣﻈﺔ ﻣﻔﯿﺪة‬
‫‪M‬‬

‫ﺧﺪ ﺑﺎﻟﻚ إن ﻣﺶ ﻓﻲ ﻛﻞ اﻟﺤﺎﻻت ﻻزم ﺗﺠﺮي ﺑﺴﺮﻋﺔ ﻋﻠﻰ اﻟـ‪Strategy Pattern‬‬

‫ﻟﻮ اﻟﻄﺮق او اﻟﻌﻤﻠﯿﺎت اﻟﻠﻲ ﻋﻨﺪك ﺑﺴﯿﻄﺔ ﺟﺪا وﻣﺎﻓﯿﺶ ﻓﺮوق ﺟﻮھﺮﯾﺔ ﺑﯿﻨﮭﻢ ﺳﺎﻋﺘﮭﺎ ﻣﻤﻜﻦ ﺗﻜﺘﻔﻲ إﻧﻚ ﺗﺴﺘﺨﺪم ‪polymorphism‬اﻟﻌﺎدي‬

‫‪Design-Pattern Page 7‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Template Method‬‬
‫‪Thursday, July 3, 2025‬‬ ‫‪5:45 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪Template Method‬‬

‫ھﻮ أﺳﻠﻮب ﺗﺼﻤﯿﻢ ﺑﯿﺴﻤﺤﻠﻚ ﺗﻜﺘﺐ ﺗﺴﻠﺴﻞ ﺛﺎﺑﺖ ﻟﺨﻄﻮات ﻣﻌﯿﻨﺔ ﻓﻲ ﻛﻼس أﺳﺎﺳﻲ ‪Abstract Class‬‬

‫وﺗﺴﯿﺐ ﺗﻔﺎﺻﯿﻞ ﺗﻨﻔﯿﺬ اﻟﺨﻄﻮات ﻟﻠﻜﻼﺳﺎت اﻟﻔﺮﻋﯿﺔ ‪ Subclasses‬اﻟﻨﻤﻂ ده ﺑﯿﻮﻓﺮﻟﻚ طﺮﯾﻘﺔ ﺗﺤﻜﻢ واﺿﺤﺔ ﻓﻲ ﺗﺮﺗﯿﺐ اﻟﺨﻄﻮات ﺑﺲ ﻣﻦ‬
‫ﻏﯿﺮ ﻣﺎ ﺗﺠﺒﺮ اﻟﻜﻼﺳﺎت اﻟﺘﺎﻧﯿﺔ ﺗﻠﺘﺰم ﺑﻨﻔﺲ اﻟﺘﻔﺎﺻﯿﻞ‬

‫اﻟﮭدف ﻣن ‪Template Method‬‬

‫ده ھو إﻧﻧﺎ ﻧﺣﻘﻖ ﻣﺑدأ اﻟـ ")‪ Don't Repeat Yourself" (DRY‬ﺑﺷﻛل ﻓﻌﺎل ﺟدا ً‪.‬‬
‫ﺑدل ﻣﺎ ﻧﻛﺗب ﻧﻔس اﻟﻛود اﻟﻠﻲ ﺑﯾﻣﺛل اﻟﺧطوات اﻟﺛﺎﺑﺗﺔ ﻓﻲ أﻛﺗر ﻣن ﻣﻛﺎن ﺑﻧﺣطﮫ ﻣرة واﺣدة ﺑس ﻓﻲ اﻟﻛﻼس اﻷب وﺑﻧﺧﻠﻲ اﻟﻛﻼﺳﺎت اﻷﺑﻧﺎء ھﻲ اﻟﻠﻲ ﺗﮭﺗم ﺑﺗﻔﺎﺻﯾل‬
‫اﻟﺧطوات اﻟﻣﺗﻐﯾرة‪ .‬ده ﺑﯾﺧﻠﻲ اﻟﻛود أﻧﺿف وأﺳﮭل ﻓﻲ اﻟﺻﯾﺎﻧﺔ واﻟﺗﻌدﯾل‪.‬‬
‫و إﻧك ﺗﺿﻣن إن ﻛل اﻟﻌﻣﻠﯾﺎت اﻟﻠﻲ ﺑﺗﺗم ﻋﻠﻰ ﻧﻔس ال ‪ Workflow‬ﻣﺎﺷﯾﺔ ﺑﻧﻔس اﻟﺗرﺗﯾب وﺑﻧﻔس اﻟﮭﯾﻛل‬
‫ﻟﻛن ﻓﻲ ﻧﻔس اﻟوﻗت ﺗدي ﺣرﯾﺔ ﻟﻠﻛﻼﺳﺎت اﻟﻔرﻋﯾﺔ إﻧﮭﺎ ﺗﺣدد ﺗﻔﺎﺻﯾل اﻟﺗﻧﻔﯾذ ﻟوﺣدھﺎ ده ﺑﯾﺧﻠﻲ اﻟﻛود ﻣﻧظم وﻗﺎﺑل ﻹﻋﺎدة اﻻﺳﺗﺧدام وﺳﮭل اﻟﺻﯾﺎﻧﺔ‬

‫‪o‬‬
‫‪et‬‬ ‫ﺗﺨﯿﻞ ﻣﺜﻼ إن ﻋﻨﺪك ﺑﺮﻧﺎﻣﺞ ﺑﯿﻘﺮأ ﺑﯿﺎﻧﺎت ﻣﻦ أﻛﺘﺮ ﻣﻦ ﻣﺼﺪر زي ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت و‪API‬‬

‫وﻣﻠﻒ ﻧﺼﻲ ﻓﻲ ﻛﻞ ﺣﺎﻟﺔ اﻧﺖ ﻋﺎﯾﺰ ﺗﻨﻔﺬ ﻧﻔﺲ اﻟﺨﻄﻮات ﺑﺎﻟﻈﺒﻂ ﻓﺘﺢ اﻻﺗﺼﺎل ﺟﻠﺐ اﻟﺒﯿﺎﻧﺎت ﻏﻠﻖ اﻻﺗﺼﺎل ﻟﻜﻦ طﺮﯾﻘﺔ ﺗﻨﻔﯿﺬ ﻛﻞ ﺧﻄﻮة ﺑﺘﺨﺘﻠﻒ ھﻨﺎ ‪Template‬‬
‫‪ Method‬ﺑﯿﻜﻮن ﻣﺜﺎﻟﻲ‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 8‬‬ ‫‪Mahmoud Shetawy‬‬

 o
et
Sh
R_
M

Design-Pattern Page 9 Mahmoud Shetawy

‫‪Memento Pattern‬‬
‫‪Thursday, July 10, 2025‬‬ ‫‪11:01 AM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪Memento Pattern‬‬

‫ﻓﻜﺮﺗﮫ اﻷﺳﺎﺳﯿﺔ ھﻲ إﻧﻚ ﺗﺤﻔﻆ ﺣﺎﻟﺔ ﻛﺎﺋﻦ )‪ (object‬ﻓﻲ ﻟﺤﻈﺔ ﻣﻌﯿﻨﺔ وﺗﺮﺟﻊ ﻟﮫ اﻟﺤﺎﻟﺔ دي ﻓﻲ أي وﻗﺖ ﻻﺣﻖ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻜﺴﺮ ﻣﺒﺪأ اﻟﻜﺒﺴﻮﻟﺔ )‪(encapsulation‬‬
‫ﯾﻌﻨﻲ اﻟﻜﺎﺋﻦ ﯾﻔﻀﻞ ﻣﺤﺎﻓﻆ ﻋﻠﻰ ﺣﺎﻟﺘﮫ اﻟﺪاﺧﻠﯿﺔ وﻣﺤﺪش ﯾﻘﺪر ﯾﻌﺒﺚ ﺑﯿﮭﺎ ﻟﻜﻦ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ﻧﻘﺪر ﻧﻌﻤﻞ ﻟﮫ "ﺣﻔﻆ" و"اﺳﺘﺮﺟﺎع" ﻟﻠﺤﺎﻟﺔ‪.‬‬

‫اوھﻮ ‪ pattern‬ﺑﯿﺴﻤﺤﻠﻚ ﺗﺤﻔﻆ ‪ snapshot‬ﻣﻦ ﺣﺎﻟﺔ ‪ object‬ﻣﻌﯿﻦ ﻓﻲ وﻗﺖ ﻣﻌﯿﻦ وﺗﺮﺟﻌﻠﮫ ﺑﻌﺪﯾﻦ ﻟﻮ ﺣﺼﻞ ﺣﺎﺟﺔ‬

‫زي ﻓﻜﺮة اﻟـ ‪ Undo‬ﺑﺎﻟﻈﺒﻂ اﻟﻠﻲ ﻓﻲ أي ﺑﺮﻧﺎﻣﺞ ﻛﺘﺎﺑﺔ‬

‫ﯾﻌﻨﻲ ﻟﻮ ﺑﺘﻜﺘﺐ ﺣﺎﺟﺔ ﻓﻲ ﻣﻠﻒ وﻛﺘﺒﺖ ﻛﻼم ﻛﺘﯿﺮ وﺑﻌﺪﯾﻦ ﺿﻐﻄﺖ ‪Ctrl + Z‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺑﯿﺮﺟﻌﻚ ﻟﺤﺎﻟﺔ أﻗﺪم ﻣﻦ اﻟﻜﻼم اﻟﻠﻲ ﻛﻨﺖ ﻛﺎﺗﺒﮫ‬

‫إﻣﺘﻰ ﺗﺴﺘﺨﺪﻣﮫ؟‬

‫‪o‬‬
‫ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك ‪ object‬ﺣﺎﻟﺘﮫ ﺑﺘﺘﻐﯿﺮ ﻛﺘﯿﺮوﻋﺎﯾﺰ ﺗﻘﺪر ﺗﺮﺟﻊ ورا ﻷي ﻟﺤﻈﺔ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻐﯿﺮ اﻟﻜﺎﺋﻦ ﺑﺈﯾﺪك‬

‫وﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ﻋﺎﯾﺰ ﺗﺤﺎﻓﻆ ﻋﻠﻰ إن اﻟـ ‪ data‬ﺟﻮا اﻟﻜﺎﺋﻦ ﻣﺘﺒﻘﺎش ﻣﻜﺸﻮﻓﺔ ﻟﺒﺮا‬

‫‪et‬‬ ‫ﻣﺜﺎل ﺣﻘﯿﻘﻲ‬

‫ﺑﺮﻧﺎﻣﺞ ﺑﯿﺨﺰن ﺑﯿﺎﻧﺎت ‪ user‬ﻛﻞ ﻣﺎ ﯾﻌﻤﻞ ﺗﻌﺪﯾﻞ ﺑﻨﺤﻔﻆ ﻧﺴﺨﺔ ﻣﻦ ﺣﺎﻟﺘﮫ ﻟﻮ ﺿﻐﻂ ‪ undo‬ﻧﺮﺟﻌﮫ ﻟﺤﺎﻟﺔ أﻗﺪم‬
‫‪Sh‬‬
‫ﻣﻦ ﻏﯿﺮ ﻣﺎ اﻟـ ‪ UI‬ﯾﻌﺮف إﯾﮫ ﺟﻮه اﻟـ ‪ object‬أﺻﻼً‬
‫_‪R‬‬

‫ﺑﯿﺘﻜﻮن ﻣﻦ إﯾﮫ؟‬
‫ﻓﯿﮫ ‪ ٣‬أطﺮاف رﺋﯿﺴﯿﯿﻦ ﻓﻲ ‪Memento Pattern‬‬

‫‪Originator .1‬‬
‫‪M‬‬

‫وده ھﻮ اﻟـ ‪ object‬اﻟﻠﻲ ﺣﺎﻟﺘﮫ ﺑﺘﺘﻐﯿﺮ وھﻮ اﻟﻠﻲ ﺑﯿﺨﻠﻖ اﻟـ ‪ Memento‬وﺑﯿﺴﺘﺮﺟﻌﮫ‬

‫‪Memento .2‬‬

‫وده ‪ snapshot‬ﻣﻦ اﻟﺤﺎﻟﺔ ﻛﺎﺋﻦ ﺑﺴﯿﻂ ﻣﺶ ﺑﯿﻌﺮض ﺗﻔﺎﺻﯿﻠﮫ ﻟﺤﺪ‬

‫‪Caretaker .3‬‬

‫ده اﻟﻠﻲ ﺑﯿﺨﺰن اﻟـ ‪ Mementos‬وﺑﯿﻄﻠﺐ ﻣﻦ ‪ Originator‬ﯾﺮﺟﻊ ﺣﺎﻟﺔ ﻣﻌﯿﻨﺔ ﻟﻤﺎ ﯾﺤﺐ‬

‫‪Design-Pattern Page 10‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ﺧﻄﻮات اﻟﺸﻐﻞ‬
‫‪ Originator .1‬ﺑﯿﻨﺸﺊ ﻧﺴﺨﺔ ‪ Memento‬ﻓﯿﮭﺎ ‪ snapshot‬ﻣﻦ ﺣﺎﻟﺘﮫ‬

‫‪ Caretaker .2‬ﺑﯿﺨﺰن اﻟﻨﺴﺨﺔ دي‬

‫‪ .3‬ﺑﻌﺪ ﺷﻮﯾﺔ ﻟﻮ اﻟﺤﺎﻟﺔ ﺗﻐﯿﺮت واﻟﻤﺴﺘﺨﺪم ﻋﺎﯾﺰ ﯾﺮﺟﻊ ‪ Caretaker‬ﯾﺒﻌﺚ ‪ Memento‬ﻟﻠـ ‪ Originator‬و‪ Originator‬ﯾﺮﺟﻊ ﻟﺤﺎﻟﺘﮫ اﻟﺴﺎﺑﻘﺔ‬

‫‪o‬‬
‫‪et‬‬ ‫ﻣﺶ ﻓﺎھﻢ‬

‫ﺗﺨﯿﻞ إﻧﻚ ﻗﺎﻋﺪ ﺑﺘﻜﺘﺐ ﻓﻲ ﻛﺮاﺳﺔ‬

‫‪Sh‬‬
‫وﻛﻞ ﺻﻔﺤﺔ ﺑﺘﻜﺘﺐ ﻓﯿﮭﺎ ﻛﻼم ﺑﻌﺪ ﻛﻞ ﺻﻔﺤﺔ ﺑﺘﺎﺧﺪ ‪ photocopy‬ﻣﻨﮭﺎ وﺗﺤﻄﮭﺎ ﻓﻲ درج‬
‫ﻟﻮ ﻓﻲ ﻣﺮة ﻛﺘﺒﺖ ﺣﺎﺟﺔ ﻏﻠﻂ ﻓﻲ اﻟﺼﻔﺤﺔ اﻟﻠﻲ ﺑﻌﺪ ﻛﺪه‬
‫ﻣﻤﻜﻦ ﺗﺮوح ﻟﻠﺪرج وﺗﺠﯿﺐ اﻟـ ‪ photocopy‬اﻟﻘﺪﯾﻤﺔ وﺗﺮﺟﻌﮭﺎ ﻣﻜﺎن اﻟﺼﻔﺤﺔ اﻟﺠﺪﯾﺪة‬
‫_‪R‬‬

‫اﻟـ ﻛﺮاﺳﺔ ھﻨﺎ ھﻲ اﻟـ ‪Originator‬‬

‫اﻟـ ‪ Photocopy‬ھﻲ اﻟـ ‪Memento‬‬

‫اﻟـ درج اﻟﻮرق ھﻮ اﻟـ ‪Caretaker‬‬

‫‪M‬‬

‫‪Design-Pattern Page 11‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Visitor Pattern‬‬
‫‪Thursday, July 10, 2025‬‬ ‫‪2:54 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫ﯾﻌﻨﻲ إﯾﮫ ‪Visitor Pattern‬؟‬

‫‪ Visitor Pattern‬ﻓﻜﺮﺗﮫ إﻧﻚ ﺗﻔﺼﻞ اﻟﻌﻤﻠﯿﺎت )‪ (operations‬اﻟﻠﻲ ﺑﺘﺘﻄﺒﻖ ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ ﻛﺎﺋﻨﺎت ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻟﻜﺎﺋﻨﺎت ﻧﻔﺴﮭﺎ‬

‫ﯾﻌﻨﻲ ﻣﺶ ﻛﻞ ﻛﺎﺋﻦ ھﯿﺤﺘﻮي ﻋﻠﻰ ﻛﻞ اﻟﻮظﺎﯾﻒ اﻟﻠﻲ ﺑﺘﺘﻌﻤﻞ ﻋﻠﯿﮫ ﻟﻜﻦ ﺗﻘﺪر ﺗﺒﻌﺘﻠﮫ )‪(Visitor‬‬
‫واﻟﺰاﺋﺮ ده ﯾﻌﺮف ﯾﻄﺒﻖ اﻟﻌﻤﻠﯿﺔ اﻟﻤﻄﻠﻮﺑﺔ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﯾﻌﺪل ﻋﻠﻰ اﻟﻜﺎﺋﻦ ﻧﻔﺴﮫ‬

‫اﻟﻤﺸﻜﻠﺔ اﻟﻠﻲ ﺑﯿﺤﻠﮭﺎ‬

‫ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﻜﺒﯿﺮة ﺑﯿﺒﻘﻰ ﻋﻨﺪك ﻛﺎﺋﻨﺎت ﻛﺘﯿﺮ ﻣﺨﺘﻠﻔﺔ وﻛﻞ ﻛﺎﺋﻦ ﻣﺤﺘﺎج ﺗﺘﻄﺒﻖ ﻋﻠﯿﮫ ﻋﻤﻠﯿﺎت ﻣﺨﺘﻠﻔﺔ‬
‫وﻣﻊ اﻟﻮﻗﺖ اﻟﻌﻤﻠﯿﺎت دي ﺑﺘﺰﯾﺪ وﻟﻮ ﺟﯿﺖ ﺗﻀﯿﻔﮭﺎ ﺟﻮا اﻟﻜﺎﺋﻦ ﻧﻔﺴﮫ ھﺘﻼﻗﻲ اﻟﻜﻮد ﺑﯿﻜﺒﺮ ﺟﺪًا وﻛﻞ ﻛﺎﺋﻦ ﺑﻘﻰ ﺷﺎﯾﻞ ﻣﺴﺆوﻟﯿﺎت ﻣﺶ ﺑﺘﺎﻋﺘﮫ‬
‫طﯿﺐ ﻧﻌﻤﻞ إﯾﮫ؟‬
‫ﻧﺴﺘﺨﺪم ‪Visitor‬‬

‫ﻧﺨﻠﻲ اﻟﻜﺎﺋﻦ ﻧﻔﺴﮫ ﺑﺴﯿﻂ وﻧﺒﻌﺘﮫ "ﯾﺰور" ﻛﻼس ﺗﺎﻧﻲ ﻓﯿﮫ اﻟﻌﻤﻠﯿﺎت دي ﻛﻠﮭﺎ واﻟﻜﺎﺋﻦ ﯾﺴﻤﺢ ﻟﻠـ ‪ visitor‬ﯾﻨﻔﺬ ﻋﻠﯿﮫ اﻟﻠﻲ ھﻮ ﻋﺎﯾﺰه‬
‫ﺑﻜﺪه اﻟﻜﺎﺋﻦ ﻣﺶ ﺑﯿﺘﻐﯿﺮ واﻟﻌﻤﻠﯿﺎت ﺑﺘﻔﻀﻞ ﻣﻨﻈﻤﺔ ﻓﻲ ﻣﻜﺎن واﺣﺪ‬

‫‪o‬‬
‫‪et‬‬ ‫اﻷطﺮاف اﻟﻤﺸﺎرﻛﺔ‬
‫ﻓﯿﮫ ﻛﺬا طﺮف ﺑﯿﺸﺘﻐﻠﻮا ﻓﻲ ‪Visitor Pattern‬‬
‫‪Sh‬‬
‫ﺗﻌﺎﻟﻰ ﻧﻮﺿﺤﮭﻢ ﺑﺒﺴﺎطﺔ‪:‬‬
‫‪) Element .1‬أو ‪(Visitable‬‬

‫ده اﻟﻜﺎﺋﻦ اﻟﻠﻲ ھﯿﺘﻢ ﻋﻠﯿﮫ اﻟﻌﻤﻠﯿﺎت ﺑﯿﺤﺘﻮي ﻋﻠﻰ ‪ method‬واﺣﺪة اﺳﻤﮭﺎ )‪ accept(Visitor visitor‬اﻟﻠﻲ ﺑﯿﺨﻠﻲ اﻟﺰاﺋﺮ ﯾﺪﺧﻞ وﯾﺸﺘﻐﻞ ﻋﻠﯿﮫ‬

‫‪Visitor .2‬‬
‫_‪R‬‬

‫ده اﻟﻜﺎﺋﻦ اﻟﻠﻲ ﺑﯿﺤﻤﻞ اﻟﻌﻤﻠﯿﺎت ﺟﻮاه ‪ method‬ﻟﻜﻞ ﻧﻮع ﻣﻦ ﻋﻨﺎﺻﺮ ‪ Element‬ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪﻧﺎ ﻛﺎﺋﻨﯿﻦ )ﻣﺜﻼً ‪ File‬و‪ (Folder‬ھﯿﻜﻮن ﺟﻮاه )‪ visit(File f‬و )‪visit(Folder f‬‬

‫‪Concrete Element .3‬‬

‫ده اﻟﻜﺎﺋﻦ اﻟﻔﻌﻠﻲ اﻟﻠﻲ ھﯿﺘﻨﻔﺬ ﻋﻠﯿﮫ اﻟﺰﯾﺎرة وﺑﯿﻄﺒﻖ )(‪ accept‬وﺑﯿﺴﺘﺪﻋﻲ ﻓﯿﮭﺎ )‪[Link](this‬‬
‫‪M‬‬

‫‪Concrete Visitor .4‬‬

‫ده اﻟﻠﻲ ﺑﯿﺤﻤﻞ اﻟﻌﻤﻠﯿﺎت اﻟﻔﻌﻠﯿﺔ وﺑﯿﻄﺒﻖ )(‪ visit‬ﻟﻜﻞ ﻧﻮع ﻣﻦ اﻟﻌﻨﺎﺻﺮ اﻟﻠﻲ ﻋﻨﺪك‬

‫‪Design-Pattern Page 12‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫‪o‬‬
‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫إﻧﺖ دﻟﻮﻗﺘﻲ ﺑﺘﺸﺘﻐﻞ ﻋﻠﻰ ﻧﻈﺎم ﻹدارة ﺟﺪاول ﺷﻐﻞ اﻟﻤﻮظﻔﯿﻦ‬

‫وﻓﯿﮫ ﻋﻨﺪك ﺗﻼت أﻧﻮاع ﻣﻦ اﻟﺠﺪاول‪:‬‬
‫‪DayShift‬‬
‫‪NightShift‬‬
‫‪RemoteWork‬‬
‫وﻋﻨﺪك ‪ Requirement‬إﻧﻚ ﺗﻀﯿﻒ ﻣﯿﺰة إدارة طﻠﺒﺎت اﻹﺟﺎزات )‪ (Leave Requests‬ﺑﺲ اﻟﻤﺸﻜﻠﺔ إن اﻟﻨﻈﺎم ﺷﻐﺎل ﻓﻌﻠﯿﺎ ﻓﻲ ‪Production‬‬
‫ﻓـ ﻣﻤﻨﻮع ﺗﻐﯿﺮ ﻓﻲ اﻟﻜﻮد اﻷﺳﺎﺳﻲ ﻟﻜﻞ ‪ Schedule‬أو ﺗﻌﺪل ﺟﻮاه ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ‬

‫ﯾﺒﻘﻰ اﻟﺤﻞ؟‬
‫ھﻮ اﺳﺘﺨﺪام ‪ Visitor Pattern‬ﻋﻠﺸﺎن ﺗﻀﯿﻒ ﺳﻠﻮك ﺟﺪﯾﺪ )إدارة اﻹﺟﺎزات( ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻌﺪل ﻓﻲ اﻟﻜﻼﺳﺎت اﻷﺳﺎﺳﯿﺔ‬

‫‪Design-Pattern Page 13‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Iterator Pattern‬‬
‫‪Thursday, July 10, 2025‬‬ ‫‪5:06 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪ ‬ﯾﻌﻨﻲ إﯾﮫ ‪Iterator Pattern‬؟‬

‫ھﺪﻓﮫ إﻧﻚ ﺗﻮﻓﺮ طﺮﯾﻘﺔ ﻣﻮﺣﺪة ﻟﻠﺘﻨﻘﻞ )‪ (iteration‬ﺟﻮه ﻣﺠﻤﻮﻋﺔ ﻋﻨﺎﺻﺮ )‪(collection‬‬

‫ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻔﻀﺢ أو ﺗﻜﺸﻒ اﻟﺘﻔﺎﺻﯿﻞ اﻟﺪاﺧﻠﯿﺔ ﻟﻠـ ‪ collection‬ﻧﻔﺴﮭﺎ‪.‬‬

‫ﺑﻤﻌﻨﻰ ﺑﺴﯿﻂ ﺟﺪًا‪:‬‬
‫أﻧﺎ ﻋﺎﯾﺰ أﻟﻒ ﻋﻠﻰ اﻟﻌﻨﺎﺻﺮ ﻣﻦ ﻏﯿﺮ ﻣﺎ أﻋﺮف ھﻤﺎ ﻣﺘﺨﺰﻧﯿﻦ إزاي وﻻ ﯾﮭﻤﻨﻲ دول ‪ Array‬وﻻ ‪ LinkedList‬وﻻ ‪ Tree‬أﻧﺎ ﻋﺎﯾﺰ "أﻣﺸﻲ ﻋﻠﯿﮭﻢ ﺧﻄﻮة ﺧﻄﻮة" ﺑﻄﺮﯾﻘﺔ ﻣﻮﺣﺪة‪.‬‬

‫‪ ‬ﺑﻨﺴﺘﺨﺪﻣﮫ ﻟﯿﮫ؟‬
‫ﻋﻠﺸﺎن ﺗﻔﺼﻞ طﺮﯾﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻌﻨﺎﺻﺮ ﻋﻦ طﺮﯾﻘﺔ ﺗﺨﺰﯾﻨﮭﻢ‬
‫ﻋﻠﺸﺎن ﺗﻘﺪر ﺗﻐﯿﺮ اﻟـ ‪ structure‬اﻟﺪاﺧﻠﻲ )زي ﺗﺘﺤﻮل ﻣﻦ ‪ List‬ﻟـ ‪ (Tree‬ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻐﯿﺮ طﺮﯾﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺒﯿﺎﻧﺎت ﻧﻔﺴﮭﺎ‬
‫ﻋﻠﺸﺎن ﺗﻮﺣﺪ طﺮﯾﻘﺔ اﻟﺘﻜﺮار ﻋﻠﻰ ﻣﺠﻤﻮﻋﺎت ﻣﺨﺘﻠﻔﺔ ﺣﺘﻰ ﻟﻮ ﻛﻞ واﺣﺪة ﻣﺘﺨﺰﻧﺔ ﺑﺸﻜﻞ ﻣﺨﺘﻠﻒ‬

‫إﯾﮫ اﻟﻤﺸﻜﻠﺔ اﻟﻠﻲ ﺑﯿﺤﻠﮭﺎ؟‬

‫‪o‬‬
‫ﺗﺨﯿﻞ ﻣﻌﺎﯾﺎ ﻋﻨﺪك ﻛﺎﺋﻦ اﺳﻤﮫ ‪ EmployeeList‬ﻓﯿﮫ ‪ Array‬داﺧﻠﻲ ﻟﻮ ﺟﯿﺖ ﺗﻤﺸﻲ ﻋﻠﯿﮫ ھﺘﺤﺘﺎج ﺗﻌﻤﻞ ‪ for loop‬ﻋﻠﯿﮫ ﺟﻮا اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪﻣﮫ‬

‫وﻟﻮ ﺑﻜﺮة ﻗﺮرت ﺗﺨﺰﻧﮫ ﻓﻲ ‪ LinkedList‬ﺑﺪل ‪ Array‬ھﺘﺤﺘﺎج ﺗﻌﯿﺪ ﻛﺘﺎﺑﺔ اﻟﻜﻮد ﻛﻠﮫ اﻟﻠﻲ ﻛﺎن ﺑﯿﺴﺘﺨﺪﻣﮫ‬

‫‪et‬‬ ‫ده اﺳﻤﮫ ‪ coupling‬ﻋﺎﻟﻲ ﺟﺪًا ﺑﯿﻦ اﻟﺒﻨﯿﺔ وطﺮﯾﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻌﮭﺎ‬

‫اﻟـ ‪ Iterator Pattern‬ﺑﯿﻘﻮﻟﻚ‪:‬‬

‫اﻓﺼﻞ اﻟـ ‪ structure‬ﻋﻦ طﺮﯾﻘﺔ اﻟﺘﻜﺮار ﺧﻠﻲ اﻟﻜﺎﺋﻦ ﻧﻔﺴﮫ ﯾﺪﯾﻠﻚ ﻛﺎﺋﻦ ﺗﺎﻧﻲ اﺳﻤﮫ "‪ "Iterator‬ھﻮ اﻟﻠﻲ ﻣﺴﺆول ﯾﻤﺸﻲ ﻋﻠﻰ اﻟﻌﻨﺎﺻﺮ واﺣﺪة واﺣﺪة‬
‫‪Sh‬‬
‫اﻟـ ‪ Pattern‬ده ﺑﯾﺗﻛون ﻣن ﺧﻣس أطراف رﺋﯾﺳﯾﯾن ﻛل واﺣد ﻟﯾﮫ وظﯾﻔﺔ ﻣﺣددة وﻣﻧﻔﺻﻠﺔ ﺗﻣﺎ ًﻣﺎ‬
‫_‪R‬‬

‫‪ .1‬اﻟطرف اﻷول‪Iterator :‬‬

‫ده ‪ Interface‬ﻓﯾﮫ دوال ﺑﺳﯾطﺔ زي ‪ hasNext‬و ‪ next‬ﯾﻌﻧﻲ ﺑﯾﺳﺄﻟك "ھل ﻓﯾﮫ ﻋﻧﺻر ﺗﺎﻧﻲ؟" و"ھﺎﺗﻠﻲ اﻟﻌﻧﺻر اﻟﻠﻲ ﺑﻌده"‬

‫‪ .2‬اﻟطرف اﻟﺗﺎﻧﻲ‪Concrete Iterator :‬‬

‫‪M‬‬

‫ده اﻟﻛﻼس اﻟﻠﻲ ﺑﯾﻧﻔذ ﻓﻌﻠﯾﺎ اﻟـ ‪ Interface‬اﻟﻠﻲ ﻓوق وﺑﯾﺣﺗﻔظ ﺑﻣؤﺷر داﺧﻠﻲ ﻋﻠﺷﺎن ﯾﻌرف ﻣﻛﺎﻧﮫ ﻓﯾن ﻓﻲ اﻟﻣﺟﻣوﻋﺔ ھو اﻟﻠﻲ ﺑﯾﺗﺣرك ﺧطوة ﺧطوة ﺟوا اﻟـ ‪Collection‬‬

‫‪ .3‬اﻟطرف اﻟﺗﺎﻟت‪Aggregate :‬‬

‫ده ‪ Interface‬ﺑﯾﻘول إن اﻟﻛﺎﺋن ده ﻣﻣﻛن ﯾﺗﻌﻣﻠﮫ ‪ Iterator‬ﯾﻌﻧﻲ ﺑﯾﺣﺗوي ﻋﻠﻰ داﻟﺔ واﺣدة اﺳﻣﮭﺎ ‪createIterator‬‬

‫‪ .4‬اﻟطرف اﻟراﺑﻊ‪Concrete Aggregate :‬‬

‫ده اﻟﻛﺎﺋن اﻟﻠﻲ ﻓﻌﻠﯾﺎ ﺑﯾﺧزن اﻟﺑﯾﺎﻧﺎت زي ‪ List‬أو ‪ Set‬وﺑﯾوﻓر ﻧﺳﺧﺔ ‪ Iterator‬ﻟﻣﺎ ﺣد ﯾطﻠب‬

‫‪ .5‬اﻟطرف اﻟﺧﺎﻣس‪Client :‬‬

‫وده اﻟﻣﺳﺗﺧدم اﻟﻧﮭﺎﺋﻲ اﻟﻠﻲ ﺑﯾﺎﺧد اﻟـ ‪ Iterator‬وﯾﻣﺷﻲ ﺑﯾﮫ ﻋﻠﻰ اﻟﻌﻧﺎﺻر ﻣن ﻏﯾر ﻣﺎ ﯾﻌرف أي ﺗﻔﺎﺻﯾل داﺧﻠﯾﺔ‬

‫‪Design-Pattern Page 14‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫‪o‬‬
‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬

‫إﻧﺖ ﻋﻨﺪك ‪ System‬ﻹدارة اﻟﻤﻮظﻔﯿﻦ وﻣﻄﻠﻮب ﻣﻨﻚ ﺗﻀﯿﻒ طﺮﯾﻘﺔ ﻣﻨﻈﻤﺔ ﻟﺘﻤﻜﯿﻦ أي ﺣﺪ ﺑﯿﺴﺘﺨﺪم اﻟﻤﻜﺘﺒﺔ دي إﻧﮫ ﯾﻠﻒ )‪ (iterate‬ﻋﻠﻰ اﻟﻤﻮظﻔﯿﻦ داﺧﻞ ھﯿﻜﻞ اﻟﺸﺮﻛﺔ‪.‬‬
‫ﯾﻌﻨﻲ ً‬
‫ﻣﺜﻼ‪:‬‬
‫ﻟﻮ ﻣﻌﺎك ﻣﻮظﻒ ﺗﻘﺪر ﺗﺠﯿﺐ اﻟـ ‪ Direct Reports‬ﺑﺘﻮﻋﮫ )اﻟﻠﻲ ﺗﺤﺘﮫ ﻓﻲ اﻟﮭﯿﻜﻞ(‬

‫ﺗﻘﺪر ﺗﺠﯿﺐ زﻣﺎﯾﻠﮫ ﻓﻲ ﻧﻔﺲ اﻟﻤﺴﺘﻮى )‪ (Co-workers‬وﺗﻘﺪر ﻛﻤﺎن ﺗﻤﺸﻲ ﻋﻠﻰ اﻟـ ‪ Subordinates‬ﺑﺘﻮﻋﮫ )ﻛﻞ اﻟﻠﻲ ﺗﺤﺘﮫ ﻓﻲ اﻟﺸﺠﺮة(‬
‫‪M‬‬

‫اﻟﺸﺮط اﻷﺳﺎﺳﻲ ھﻮ‪:‬‬

‫إن اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪم اﻟﻤﻜﺘﺒﺔ دي ﻣﺎ ﯾﻌﺮﻓﺶ ﺣﺎﺟﺔ ﻋﻦ ﺷﻜﻞ اﻟﺘﺨﺰﯾﻦ اﻟﺪاﺧﻠﻲ‬
‫ﺑﺲ ﯾﻜﻮن ﻋﻨﺪه ‪ getNext‬و ‪ hasNext‬ﯾﻤﺸﻮه ﻋﻠﻰ اﻟﻨﺎس واﺣﺪة واﺣﺪة‬

‫ﯾﺒﻘﻰ اﻟﺤﻞ اﻟﻜﻼﺳﯿﻜﻲ ھﻨﺎ ھﻮ ﺗﻄﺒﯿﻖ ‪ Iterator Pattern‬ﻣﺨﺼﺺ ﻟﻜﻞ ﻧﻮع ﻋﻼﻗﺔ‬
‫ﺗﻌﺎل ﻧﻤﺸﻲ ﺧﻄﻮة ﺑﺨﻄﻮة ﺑﺄﺳﻠﻮب واﺿﺢ واﺣﺘﺮاﻓﻲ‬

‫‪Design-Pattern Page 15‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Structural Patterns‬‬
‫‪Sunday, April 20, 2025‬‬ ‫‪2:17 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬
‫‪Structural Design Patterns ‬‬
‫ھﺪﻓﮭﺎ إﻧﮭﺎ ﺗﻨﻈﻢ ﺷﻜﻞ اﻟﻌﻼﻗﺎت ﺑﯿﻦ اﻟﻜﻼﺳﺎت أو اﻟﻜﺎﺋﻨﺎت‬
‫ﯾﻌﻨﻲ‪:‬‬
‫إزاي أرﺑﻂ ﺑﯿﻦ ﻛﺎﺋﻨﺎت ﻣﺨﺘﻠﻔﺔ ﻋﻠﺸﺎن ﺗﺸﺘﻐﻞ ﻣﻊ ﺑﻌﺾ ﻣﻦ ﻏﯿﺮ ﻣﺎ أﻛﺴﺮ ﻣﺒﺪأ اﻟﻔﺼﻞ أو أﻋﻘﺪ اﻟﻜﻮد‬
‫ھﻲ ﺑﺘﺤﻞ ﻣﺸﺎﻛﻞ زي‪:‬‬
‫إزاي أﺧﻠﻲ ﻛﻼس ﯾﺸﺘﻐﻞ ﻣﻊ ﻛﻼس ﺗﺎﻧﻲ رﻏﻢ إﻧﮭﻢ ﻣﺶ ﻣﺘﻮاﻓﻘﯿﻦ إزاي أﺿﯿﻒ طﺒﻘﺔ أو وظﯿﻔﺔ ﻋﻠﻰ ﻛﺎﺋﻦ ﻣﻦ ﻏﯿﺮ ﻣﺎ أﻋﺪل ﻋﻠﯿﮫ‬
‫إزاي أوﺣﺪ ﺷﻜﻞ ﻣﺠﻤﻮﻋﺔ ﻛﺎﺋﻨﺎت وأﺗﻌﺎﻣﻞ ﻣﻌﺎھﻢ ﻛﺄﻧﮭﻢ واﺣﺪ‬

‫‪ ‬أﻣﺘﻰ أﺳﺘﺨﺪم ‪Structural Patterns‬‬

‫ﻟﻮ ﻋﻨﺪك أﻛﺘﺮ ﻣﻦ ﻛﺎﺋﻦ وﻋﺎﯾﺰ ﺗﺮﺑﻄﮭﻢ ﺳﻮا ﺑﺸﻜﻞ ﻣﻨﻈﻢ ﻟﻮ ﻋﻨﺪك ﻛﺎﺋﻦ ﻣﻮﺟﻮد وﻣﺶ ﻋﺎﯾﺰ ﺗﻌﺪل ﻓﯿﮫ ﺑﺲ ﻋﺎﯾﺰ ﺗﻀﯿﻔﻠﮫ ﺣﺎﺟﺔ‬
‫ﻟﻮ اﻟﻜﻮد ﻋﻨﺪك ﻣﺘﺸﺎﺑﻚ وﻣﺤﺘﺎج ﺗﻔﺼﻞ اﻟﻌﻼﻗﺎت ﻟﻮ ﻋﺎﯾﺰ ﺗﻮﻓﺮ ﻣﺮوﻧﺔ ﻓﻲ اﻟﺘﺮﻛﯿﺐ وإﻋﺎدة اﻻﺳﺘﺨﺪام‬

‫‪o‬‬
‫أھﻢ اﻷﻧﻮاع اﻟﻠﻲ ﺗﺤﺖ ‪Structural Patterns‬‬

‫ﻓﯿﮫ ﺳﺒﻊ ‪ Patterns‬ﻣﺸﮭﻮرﯾﻦ ﺗﺤﺖ اﻟـ ‪Structural Group‬‬

‫‪et‬‬ ‫ھﻨﺬﻛﺮھﻢ ھﻨﺎ ﺑﺴﺮﻋﺔ وﺑﻌﺪ ﻛﺪه ﻧﺸﺮح ﻛﻞ واﺣﺪ ﻓﯿﮭﻢ ﻓﻲ وﻗﺖ ﻣﺴﺘﻘﻞ‬
‫‪Adapter‬‬
‫‪Sh‬‬
‫‪Decorator‬‬

‫‪Facade‬‬

‫‪Composite‬‬
‫_‪R‬‬

‫‪Bridge‬‬

‫‪Proxy‬‬

‫‪Flyweight‬‬
‫‪M‬‬

‫ﻣﺜﺎل ﺳﺮﯾﻊ ﻋﻦ ﻛﻞ واﺣﺪ‬

‫ﻋﻠﺸﺎن ﺑﺲ ﯾﺒﻘﻰ ﻋﻨﺪك ﺻﻮرة ﻋﺎﻣﺔ ﻗﺒﻞ ﻣﺎ ﻧﺪﺧﻞ ﻓﻲ اﻟﺘﻔﺎﺻﯿﻞ ﺑﻌﺪﯾﻦ‬
‫‪Adapter‬‬
‫ﻟﻮ ﻋﻨﺪك ﻛﺎﺋﻦ ﻗﺪﯾﻢ وﻋﺎﯾﺰه ﯾﺸﺘﻐﻞ ﻣﻊ ﻛﻮد ﺟﺪﯾﺪ‬
‫ﺑﺲ اﻟـ ‪ Interface‬ﺑﺘﺎﻋﮫ ﻣﺶ ﻣﺘﻮاﻓﻖ ﻓﺒﺘﻌﻤﻞ ‪ Adapter‬ﯾﺘﺮﺟﻢ ﺑﯿﻦ اﻟﻄﺮﻓﯿﻦ زي ﻛﺄﻧﻚ ﺟﺒﺖ وﺻﻠﺔ ﺑﺘﺤﻮل ﻣﻦ ‪ USB-A‬ﻟـ ‪USB-C‬‬

‫‪Decorator‬‬
‫ﻟﻮ ﻋﻨﺪك ﻛﺎﺋﻦ وﻋﺎﯾﺰ ﺗﺰودﻟﮫ وظﺎﺋﻒ ﺟﺪﯾﺪة ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻐﯿﺮه ﻓﺒﺘﻠﻔﮫ ﺑﻜﺎﺋﻦ ﺗﺎﻧﻲ ﯾﺰودﻟﮫ ﺣﺎﺟﺔ زي ﻛﺄﻧﻚ ﺑﺘﺤﻂ ﻛﻮﺑﺎﯾﺔ ﺟﻮة ﻛﻮﻓﺮ ﯾﺨﻠﯿﮭﺎ ﺗﺒﺮد أو ﺗﺴﺨﻦ أو ﺗﺘﺰﯾﻦ‬

‫‪Facade‬‬

‫ﻟﻮ ﻋﻨﺪك ‪ System‬ﻣﻌﻘﺪ ﻓﯿﮫ ﻛﻼﺳﺎت ﻛﺘﯿﺮ وﻋﺎﯾﺰ ﺗﻮﻓﺮ واﺟﮭﺔ ﺑﺴﯿﻄﺔ ﻟﻠﻲ ھﯿﺴﺘﺨﺪﻣﮫ ﻓﺒﺘﻌﻤﻞ ‪ Facade‬ﯾﻐﻄﻲ اﻟﺘﻌﻘﯿﺪ ده‬
‫زي ﻟﻤﺎ ﺗﺪﺧﻞ ﺑﻨﻚ وﻣﻮظﻒ واﺣﺪ ﯾﺨﻠﺼﻠﻚ ﻛﻞ ﺣﺎﺟﺔ‬

‫‪Composite‬‬

‫ﻟﻮ ﻋﻨﺪك ﺷﺠﺮة ﻛﺎﺋﻨﺎت وﻛﻞ ﻋﻨﺼﺮ ﻣﻤﻜﻦ ﯾﺒﻘﻰ ‪ Leaf‬أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟـ ‪ Leafs‬وﻋﺎﯾﺰ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻠﮫ ﺑﻨﻔﺲ اﻟﺸﻜﻞ‬

‫‪Composite‬‬

‫‪Design-Pattern Page 16‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ﻓﺒﺘﺴﺘﺨﺪم ‪ Composite‬زي ﻟﻤﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻓﻮﻟﺪر وﺟﻮاه ﻓﻮﻟﺪرات ﺗﺎﻧﯿﺔ‪ ،‬وﻛﻠﮭﻢ ﺑﻨﻔﺲ اﻟﻮاﺟﮭﺔ‬

‫‪Bridge‬‬
‫ﻟﻮ ﻋﻨﺪك ﻛﻼس ﺑﯿﻐﯿﺮ ﻓﻲ أﻛﺘﺮ ﻣﻦ ﻣﺤﻮرﻣﺜﻼ اﻟﺸﻜﻞ ﺑﯿﺨﺘﻠﻒ واﻟﻨﻮع ﺑﯿﺨﺘﻠﻒ ﻓﺒﺘﻔﺼﻞ اﻟﻤﺤﻮرﯾﻦ ﻋﻦ ﺑﻌﺾ‬
‫ﯾﻌﻨﻲ ﺗﺮﺑﻂ ﺑﯿﻨﮭﻢ ﺑﻜﻮﺑﺮي )‪ (Bridge‬ﯾﺨﻠﯿﮭﻢ ﯾﺸﺘﻐﻠﻮا ﻣﻊ ﺑﻌﺾ ﺑﺤﺮﯾﺔ‬

‫‪Proxy‬‬

‫ﻟﻮ ﻋﻨﺪك ﻛﺎﺋﻦ ﺗﻘﯿﻞ أو ﺣﺴﺎس أو ﻣﺤﺘﺎج ﻣﺮاﻗﺒﺔ ﻓﺒﺘﺤﻂ ﻗﺪاﻣﮫ ﻛﺎﺋﻦ ‪ Proxy‬ﯾﺘﺤﻜﻢ ﻓﻲ اﻟﻮﺻﻮل ﻟﯿﮫ زي اﻟﺠﺪار اﻟﻨﺎري اﻟﻠﻲ ﺑﯿﻘﻌﺪ ﺑﯿﻨﻚ وﺑﯿﻦ اﻹﻧﺘﺮﻧﺖ‬

‫‪Flyweight‬‬
‫ﻟﻮ ﻋﻨﺪك ﻋﺪد ﻛﺒﯿﺮ ﺟﺪًا ﻣﻦ اﻟﻜﺎﺋﻨﺎت اﻟﻤﺘﺸﺎﺑﮭﺔ وﻣﺶ ﻋﺎﯾﺰ ﺗﻀﯿﻊ ذاﻛﺮة ﻓﺒﺘﺸﺎرك اﻟﺤﺎﻟﺔ اﻟﻤﺘﻜﺮرة ﺑﯿﻨﮭﻢ وﺗﻔﺼﻞ اﻟﻤﺘﻐﯿﺮ‬
‫زي ﺧﻄﻮط اﻟﺤﺮوف‪ :‬ﻛﻞ اﻟﺤﺮوف ﺑﺘﺸﺎرك ﻓﻲ ﻧﻔﺲ ﺷﻜﻞ اﻟﺨﻂ‬

‫ﻟﯿﮫ ‪ Structural Patterns‬ﻣﮭﻤﺔ ً‬

‫ﻓﻌﻼ‬

‫‪o‬‬
‫ﻷﻧﻚ واﻧﺖ ﺷﻐﺎل ﻋﻠﻰ ‪ Systems‬ﻛﺒﯿﺮة‬

‫‪et‬‬ ‫ھﺘﻼﻗﻲ ﻧﻔﺴﻚ ﻣﺤﺘﺎج‪:‬‬

‫ﺗﺒﻨﻲ أﻧﻈﻤﺔ ﻣﺮﻧﺔ ﺗﻘﺪر ﺗﻐﯿﺮ ﻓﯿﮭﺎ ﺣﺎﺟﺎت ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﺄﺛﺮ ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻨﻈﺎم‬
‫ﺗﻘﻠﻞ اﻟـ ‪ Coupling‬ﺑﯿﻦ اﻟﻜﻼﺳﺎت ﺗﺰود ﺣﺎﺟﺎت ﺟﺪﯾﺪة ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻌﯿﺪ ﻛﺘﺎﺑﺔ اﻟﻜﻮد‬
‫‪Sh‬‬
‫ﺗﻮﻓﺮ واﺟﮭﺎت أﺑﺴﻂ ﻷي ﺣﺪ ھﯿﺴﺘﺨﺪم اﻟﻤﻜﺘﺒﺔ أو اﻟـ ‪ API‬ﺑﺘﺎﻋﺘﻚ‬

‫ﯾﻌﻨﻲ ﻣﻦ اﻵﺧﺮ‪ ،‬دي ‪ Patterns‬ﺑﺘﺴﺎﻋﺪك ﻓﻲ ھﻨﺪﺳﺔ اﻟﻌﻼﻗﺎت ﺑﯿﻦ اﻟﻜﻼﺳﺎت ﻣﺶ ﺑﺲ ﻓﻲ ﻛﺘﺎﺑﺔ اﻟﻜﻮد‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 17‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Adapter Pattern‬‬
‫‪Saturday, July 12, 2025‬‬ ‫‪11:48 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫اﻟـ ‪Adapter Pattern‬‬

‫ﻓﻜﺮﺗﮫ إﻧﮫ ﺑﯿﻌﻤﻞ زي "اﻟﻮﺻﻠﺔ أو اﻟﻤﺤﻮل" ﺑﯿﺮﺑﻂ ﺑﯿﻦ ﻛﺎﺋﻨﯿﻦ ﻣﺶ ﻣﺘﻮاﻓﻘﯿﻦ ﻓﻲ اﻟـ ‪ Interface‬ﺑﺘﺎﻋﮭﻢ ﺑﺲ ﻋﺎﯾﺰھﻢ ﯾﺸﺘﻐﻠﻮا ﻣﻊ ﺑﻌﺾ‬
‫ﺑﻤﻌﻨﻰ ﺗﺎﻧﻲ‪:‬‬
‫ﻟﻮ ﻋﻨﺪك ﻛﻮد ﺑﯿﻄﻠﺐ داﻟﺔ ﻣﻌﯿﻨﺔ ﺑﺲ اﻟﻜﻮد اﻟﻠﻲ ﻋﻨﺪك ﺑﯿﻮﻓﺮ داﻟﺔ ﻣﺨﺘﻠﻔﺔ ﺑﺪل ﻣﺎ ﺗﻐﯿﺮ اﻟﻜﻮد أو ﺗﻌﺪل ﻓﻲ اﻟﻜﻼﺳﺎت اﻟﻘﺪﯾﻤﺔ ﺑﺘﺒﻨﻲ ‪ Adapter‬ﯾﺘﺮﺟﻢ ﻣﺎ ﺑﯿﻦ اﻟﻄﺮﻓﯿﻦ‬

‫اﻟﻤﺸﻜﻠﺔ اﻟﻠﻲ ﺑﯿﺤﻠﮭﺎ‬

‫ﻓﻲ اﻟﺸﻐﻞ ﺳﺎﻋﺎت ﺑﺘﺴﺘﺨﺪم ﻛﻮد ﻣﻜﺘﺒﺔ ﻗﺪﯾﻤﺔ‪ ،‬أو ﻛﻮد ﺧﺎرﺟﻲ واﻟـ ‪ Interface‬ﺑﺘﺎﻋﮫ ﻣﺶ ھﻮ اﻟﻠﻲ اﻟﻜﻮد ﺑﺘﺎﻋﻚ ﻣﺘﻌﻮد ﻋﻠﯿﮫ‬
‫ﻟﻮ ﻋﺪﻟﺖ ﻓﻲ اﻟﻜﻮد اﻟﺠﺪﯾﺪ ﻣﻤﻜﻦ ﺗﺒﻮظ ﺣﺎﺟﺎت‬
‫وﻟﻮ ﻋﺪﻟﺖ ﻓﻲ اﻟﻜﻮد اﻟﻘﺪﯾﻢ ﻣﻤﻜﻦ ﺗﻜﺴﺮ اﻟـ ‪ API‬أو ﺗﺘﻌﺐ ﻓﻲ ‪Testing‬‬
‫اﻟﺤﻞ؟‬
‫ﺗﺒﻨﻲ ﻛﻼس وﺳﯿﻂ اﺳﻤﮫ ‪ Adapter‬ﯾﺤﺘﻮي ﻋﻠﻰ ﻧﻔﺲ اﻟﻮاﺟﮭﺔ اﻟﻠﻲ اﻧﺖ ﻣﺤﺘﺎﺟﮭﺎ وﻣﻦ ﺟﻮاه ﯾﺴﺘﺪﻋﻲ اﻟﻜﻮد اﻷﺻﻠﻲ ﺑﻄﺮﯾﻘﺔ ﻣﻨﺎﺳﺒﺔ‬

‫‪o‬‬
‫أﻧﻮاع اﻟـ ‪Adapter‬‬
‫ﻓﯿﮫ ﻧﻮﻋﯿﻦ رﺋﯿﺴﯿﯿﻦ‪:‬‬

‫‪et‬‬ ‫‪Object Adapter‬‬

‫ﺑﯿﻌﺘﻤﺪ ﻋﻠﻰ ‪ Composition‬ﯾﻌﻨﻲ اﻟـ ‪ Adapter‬ﺑﯿﺤﺘﻮي ﻛﺎﺋﻦ ﻣﻦ اﻟﻨﻮع اﻟﻘﺪﯾﻢ وﯾﺴﺘﺨﺪﻣﮫ ﺟﻮاه‬
‫‪Sh‬‬
‫‪Class Adapter‬‬
‫ﺑﯿﻌﺘﻤﺪ ﻋﻠﻰ ‪ Inheritance‬ﯾﻌﻨﻲ اﻟـ ‪ Adapter‬ﺑﯿﻮرث ﻣﻦ اﻟﻜﻼس اﻟﻠﻲ ﻋﺎﯾﺰ ﯾﺘﻌﺎﻣﻞ ﻣﻌﺎه وﯾﻌﺪل ﺳﻠﻮﻛﮫ اﻟﻨﻮع ده ﻣﺶ ﺷﺎﺋﻊ ﻓﻲ ‪ Java‬أو ﻟﻐﺎت ﻣﺎ ﺑﺘﺪﻋﻤﺶ اﻟﻮراﺛﺔ اﻟﻤﺘﻌﺪدة‬

‫إﺣﻨﺎ ھﻨﺮﻛﺰ ﻋﻠﻰ ‪ Object Adapter‬ﻷﻧﮫ اﻷﻛﺜﺮ ﺷﯿﻮﻋﺎ‬

‫_‪R‬‬

‫اﻷطﺮاف اﻟﻤﺸﺎرﻛﺔ اﻟـ ‪ Pattern‬ده ﻓﯿﮫ ‪ 4‬أطﺮاف رﺋﯿﺴﯿﯿﻦ‪:‬‬

‫‪Client‬‬
‫‪M‬‬

‫اﻟﻜﻮد اﻟﻠﻲ ﻣﺤﺘﺎج داﻟﺔ ﻣﻌﯿﻨﺔ ﺑﺸﻜﻞ ﻣﻌﯿﻦ‬

‫‪Target Interface‬‬
‫اﻟﺸﻜﻞ اﻟﻠﻲ اﻟـ ‪ Client‬ﺑﯿﺘﻮﻗﻌﮫ‬

‫‪Adaptee‬‬
‫اﻟﻜﻼس اﻷﺻﻠﻲ اﻟﻠﻲ ﻣﺶ ﻣﺘﻮاﻓﻖ ﻣﻊ اﻟـ ‪Target‬‬

‫‪Adapter‬‬
‫اﻟﻜﻼس اﻟﻠﻲ ﺑﯿﺮﺑﻂ ﺑﯿﻦ ‪ Target‬و ‪Adaptee‬‬

‫‪Design-Pattern Page 18‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫اﻟـ ‪ Weather App‬اﻟﻘﺪﯾﻤﺔ ﺑﺘﺸﺘﻐﻞ ﻛﺪه‪:‬‬

‫ﺑﺘﺴﺘﻘﺒﻞ ‪ city‬و ‪country‬‬

‫ﺑﺘﺒﻌﺘﮭﻢ ﻟﺜﺎﻟﺚ طﺮف )‪ (Third-party library‬ﺑﺘﺪﯾﻠﻚ ‪ XML‬ﻓﯿﮭﺎ ﺑﯿﺎﻧﺎت اﻟﻄﻘﺲ‬

‫‪o‬‬
‫اﻟﻄﻠﺐ اﻟﺠﺪﯾﺪ ﺑﻘﻰ‪:‬‬

‫اﻟﺒﯿﺎﻧﺎت اﻟﻠﻲ داﺧﻠﺔ ھﺘﻜﻮن ‪ Longitude‬و ‪) Latitude‬إﺣﺪاﺛﯿﺎت(‬

‫‪et‬‬ ‫ﻻزم ﻧﺴﺘﺨﺮج ﻣﻨﮭﺎ اﻟـ ‪ city‬واﻟـ ‪country‬‬

‫ﻧﺴﺘﺨﺪم ﻧﻔﺲ ‪ Third-party‬اﻟﻘﺪﯾﻤﺔ )اﻟﻠﻲ ﻟﺴﮫ ﺑﺘﺸﺘﻐﻞ ﺑـ ‪ city‬و ‪(country‬‬

‫‪Sh‬‬
‫ﻟﻜﻦ ﻧﻌﺮض اﻟﺒﯿﺎﻧﺎت ﻟﻠﻤﺴﺘﺨﺪم ﻓﻲ ﺷﻜﻞ ‪ JSON‬ﺑﺪل ‪XML‬‬

‫ﯾﺒﻘﻰ ﻋﻨﺪﻧﺎ ﻣﺸﻜﻠﺘﯿﻦ ﻻزم ﻧﺤﻠﮭﻢ‪:‬‬

‫_‪R‬‬

‫ﺷﻜﻞ اﻟﺒﯿﺎﻧﺎت اﻟﺪاﺧﻠﺔ ﻣﺨﺘﻠﻒ ﻋﻦ اﻟﻤﺘﻮﻗﻊ‬

‫ﺷﻜﻞ اﻟﺒﯿﺎﻧﺎت اﻟﺨﺎرﺟﺔ ﻻزم ﯾﺘﻐﯿﺮ ﺑﺮﺿﻮ‬

‫‪M‬‬

‫ھﻨﺒﻨﻲ ‪ WeatherAdaptee‬ھﻮ اﻟﻠﻲ ھﯿﻘﻮم ﺑﻜﻞ اﻟﻤﮭﺎم اﻟﻮﺳﯿﻄﺔ‪:‬‬

‫‪long, lat‬‬

‫‪Design-Pattern Page 19‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ﯾﺴﺘﻘﺒﻞ إﺣﺪاﺛﯿﺎت )‪(long, lat‬‬

‫ﯾﺤﻮﻟﮭﻢ إﻟﻰ ‪ city‬و ‪) country‬ﻋﻦ طﺮﯾﻖ ﺧﺪﻣﺔ ﺧﺎرﺟﯿﺔ أو ‪ dummy logic‬ﻣﺆﻗﺖ(‬ ‫ّ‬
‫ﯾﺒﻌﺜﮭﻢ ﻟﻠﻤﻜﺘﺒﺔ اﻟﻘﺪﯾﻤﺔ‬
‫ﯾﺎﺧﺪ اﻟـ ‪ XML‬اﻟﻨﺎﺗﺞ ﯾﺤﻮﻟﮫ إﻟﻰ ‪ JSON‬وﯾﺒﻌﺘﮫ ﻟﻠـ ‪Client‬‬

‫ﯾﻌﻨﻲ ‪ WeatherAdaptee‬ھﻮ اﻟﻤﺤﻮل اﻟﻜﺎﻣﻞ ﻣﻦ ﻧﻈﺎم ﺟﺪﯾﺪ ﻟﻨﻈﺎم ﻗﺪﯾﻢ واﻟﻌﻜﺲ‬

‫اﻟﻜﻮد ع ال ‪GITHUB‬‬

‫ﻋﻼﻗﺔ ‪ Adapter‬ﺑﻤﺒﺎدئ ‪SOLID‬‬

‫ﺑﯿﺤﻘﻖ ‪Open/Closed Principle‬‬

‫اﻟﻜﻼﺳﺎت اﻷﺻﻠﯿﺔ ﻣﺶ ﻣﺤﺘﺎﺟﺔ ﺗﺘﻌﺪل إﺣﻨﺎ ﺑﻨﻀﯿﻒ ﻛﻼس وﺳﯿﻂ‬

‫ﺑﯿﻘﻠﻞ ‪ Coupling‬ﺑﯿﻦ اﻟـ ‪ Client‬واﻟﻜﻮد اﻟﻘﺪﯾﻢ‬

‫ﺑﯿﺴﺎﻋﺪ ﻓﻲ ‪ Dependency Inversion‬ﻟﻮ ﺧﻠﺖ اﻟـ ‪ Client‬ﯾﺘﻌﺎﻣﻞ ﻣﻊ ‪ Interface‬ﻣﺶ ﻣﻊ ﻛﺎﺋﻦ ﻣﺒﺎﺷﺮ‬

‫‪o‬‬
‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 20‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Bridge Pattern‬‬
‫‪Sunday, July 13, 2025‬‬ ‫‪1:57 AM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪Bridge Pattern‬‬

‫ﺑﯿﻔﺼﻞ ﺑﯿﻦ اﻟـ ‪) Abstraction‬اﻟﻮاﺟﮭﺔ( وﺑﯿﻦ اﻟـ ‪) Implementation‬طﺮﯾﻘﺔ اﻟﺘﻨﻔﯿﺬ( ﺑﺤﯿﺚ ﺗﻘﺪر ﺗﻐﯿﺮ أي واﺣﺪة ﻓﯿﮭﻢ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﺄﺛﺮ ﻋﻠﻰ اﻟﺘﺎﻧﯿﺔ‬

‫ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪك ﻛﻼس ﻓﯿﮫ ﺳﻠﻮك ﺑﯿﺘﻐﯿﺮ ﻓﻲ أﻛﺘﺮ ﻣﻦ اﺗﺠﺎه ﺑﺪل ﻣﺎ ﺗﺒﻨﻲ ھﯿﺮارﻛﻲ ﻓﯿﮭﺎ ﻛﻞ اﻻﺣﺘﻤﺎﻻت ﺗﻔﺼﻞ اﻻﺗﺠﺎھﺎت دي وﺗﺮﺑﻄﮭﻢ ﺑﻜﻮﺑﺮي )‪(Bridge‬‬

‫اﻣﺘﻰ ﺗﺴﺘﺨﺪم ‪Bridge‬‬

‫ﺗﺴﺘﺨﺪم ‪ Bridge‬ﻟﻤﺎ ﺗﻼﻗﻲ ﻧﻔﺴﻚ ﻓﻲ اﻟﺤﺎﻻت دي‪:‬‬

‫ﻋﻨﺪك ﻛﻼس ﻓﯿﮫ أﻛﺘﺮ ﻣﻦ ‪ dimension‬ﺑﯿﺘﻐﯿﺮ زي ﻣﺜﻼ ﺷﻜﻞ اﻟﺰر )‪ (Button‬وﻧﻈﺎم اﻟﺘﺸﻐﯿﻞ اﻟﻠﻲ ﺑﯿﺸﺘﻐﻞ ﻋﻠﯿﮫ‬

‫ﻟﻮ ﺑﺪأت ﺗﺒﻨﻲ ‪ inheritance tree‬ﻣﻌﻘﺪة وﻛﻞ ﻣﺮة ﺗﻀﯿﻒ ﻓﯿﮭﺎ ‪ option‬ﺟﺪﯾﺪ ﻻزم ﺗﻌﻤﻞ ‪ Subclass‬ﺟﺪﯾﺪ‬

‫ﻟﻮ ﻋﺎﯾﺰ ﺗﺨﻠﻲ ﻛﻞ ‪ dimension‬ﻣﺴﺘﻘﻞ وﺳﮭﻞ اﻟﺘﻌﺪﯾﻞ ﺗﻘﺪر ﺗﻀﯿﻒ ﺷﻜﻞ ﺟﺪﯾﺪ أو ﺗﻨﻔﯿﺬ ﺟﺪﯾﺪ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻜﺴﺮ اﻟﻜﻮد اﻟﻘﺪﯾﻢ‬

‫ﻣﺶ ﻓﺎھﻢ ﺑﺴﯿﻄﺔ‬

‫‪o‬‬
‫ﺗﺨﯿﻞ ﻣﻌﺎﯾﺎ إﻧﻚ ﺑﺘﺒﻨﻲ ‪ System‬ﻹرﺳﺎل إﺷﻌﺎرات )‪(Notifications‬‬

‫‪et‬‬ ‫ﺑﺲ ﻋﻨﺪك ﺣﺎﺟﺘﯿﻦ ﺑﯿﺘﻐﯿﺮوا‪:‬‬

‫‪ .1‬ﻧﻮع اﻹﺷﻌﺎر‪ :‬ﻋﺎدي اوﻋﺎﺟﻞ او ﺗﻨﺒﯿﮭﺎت‬
‫‪ .2‬وﺳﯿﻠﺔ اﻹرﺳﺎل‪Email, SMS, Slack :‬‬
‫‪Sh‬‬
‫ﯾﻌﻨﻲ ‪:‬‬
‫ﺗﻨﺒﯿﮫ ﻋﺎدي ﯾﺮوح ﻋﻠﻰ ‪Email‬‬

‫ﺗﻨﺒﯿﮫ ﻋﺎﺟﻞ ﯾﺮوح ﻋﻠﻰ ‪SMS‬‬

‫_‪R‬‬

‫ﺗﻨﺒﯿﮫ ﺗﻨﻔﯿﺬي ﯾﺮوح ﻋﻠﻰ ‪Slack‬‬

‫ﻟﻮ ﻓ ّﻜﺮت ﺗﻌﻤﻞ ﻛﻼس ﻟﻜﻞ اﺣﺘﻤﺎل‬
‫ھﺘﻀﻄﺮ ﺗﺒﻨﻲ‪:‬‬
‫‪M‬‬

‫‪NormalEmailNotification‬‬

‫‪NormalSMSNotification‬‬

‫‪UrgentEmailNotification‬‬

‫‪UrgentSMSNotification‬‬

‫‪ExecutiveSlackNotification‬‬
‫وھﻜﺬا‪...‬‬

‫ﺗﺨﯿﻞ ﻟﻮ ﺿﻔﺖ وﺳﯿﻠﺔ ﺟﺪﯾﺪة أو ﻧﻮع ﺟﺪﯾﺪ؟ ھﺘﻀﻄﺮ ﺗﻀﯿﻒ ‪ Subclasses‬ﻛﺘﯿﺮ ﺟﺪا واﻟﻜﻮد ھﯿﻜﺒﺮ ﺑﺸﻜﻞ ﺑﺸﻊ‬

‫اﻟﺤﻞ؟ ﻧﻔﺼﻞ ﺑﯿﻦ "ﻧﻮع اﻹﺷﻌﺎر" و"طﺮﯾﻘﺔ اﻹرﺳﺎل"‬

‫إﺣﻨﺎ ﺑﻨﺴﻤﻲ ده ‪dimension of change‬‬

‫ﯾﻌﻨﻲ ﻓﯿﮫ ﺑﻌﺪﯾﻦ ﺑﯿﺘﻐﯿﺮوا وده اﻟﻠﻲ ‪ Bridge Pattern‬ﺑﯿﺘﻌﺎﻣﻞ ﻣﻌﺎه‬

‫ھﻮ ﺑﯿﻌﻤﻞ إﯾﮫ ﺑﺎﻟﻈﺒﻂ؟‬

‫‪Bridge‬‬ ‫‪Implementation‬‬ ‫‪Notification‬‬ ‫‪Abstraction‬‬

‫‪Design-Pattern Page 21‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ﺑﯿﻔﺼﻞ ﺑﯿﻦ اﻟـ ‪) Abstraction‬ﯾﻌﻨﻲ ‪ (Notification‬واﻟـ ‪) Implementation‬ﯾﻌﻨﻲ وﺳﯿﻠﺔ اﻹرﺳﺎل( وﯾﺨﻠﻲ ﺑﯿﻨﮭﻢ ﻛﻮﺑﺮي )‪(Bridge‬‬

‫ﻓﺄي ‪ Notification‬ﺗﻘﺪر ﺗﺮﺑﻄﮭﺎ ﺑﺄي ‪ Sender‬ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﺒﻨﻲ ﻛﻞ اﻟﺘﺮﻛﯿﺒﺎت اﻟﻤﻤﻜﻨﺔ‬

‫اﻷطﺮاف اﻟﻤﺸﺎرﻛﺔ‬
‫ﻓﻲ ‪ Bridge Pattern‬ﺑﻨﻔﺼﻞ اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪Abstraction‬‬
‫اﻟﻜﻼس أو اﻟﻮاﺟﮭﺔ اﻷﺳﺎﺳﯿﺔ اﻟﻠﻲ ﺑﯿﺘﻌﺎﻣﻞ ﻣﻌﺎھﺎ اﻟـ ‪Client‬‬

‫‪Abstraction Refined‬‬
‫ﻧﺴﺨﺔ أﻛﺜﺮ ﺗﺨﺼﺼﺎ ﻣﻦ اﻟـ ‪Abstraction‬‬

‫‪Implementor‬‬
‫‪ Interface‬ﻓﯿﮫ دوال اﻟﺘﻨﻔﯿﺬ‬

‫‪Implementor Concrete‬‬
‫اﻟﻔﻌﻞ اﻟﺤﻘﯿﻘﻲ اﻟﻠﻲ ﺑﯿﺤﺼﻞ ﻋﻠﻰ اﻷرض‬

‫‪o‬‬
‫‪et‬‬ ‫ﻋﺎﯾﺰ ﺗﺒﻨﻲ ‪Streaming Video Platform‬‬
‫‪Sh‬‬
‫ﺑﺘﺪﻋﻢ ﻣﺰودﯾﻦ ﻣﺨﺘﻠﻔﯿﻦ ﻟﻠﻔﯿﺪﯾﻮ زي ‪ YouTube‬و‪Twitch‬‬

‫وﻛﻞ ﻣﺰود ﻣﻤﻜﻦ ﯾﺪﻋﻢ ﺟﻮدات ﻣﺨﺘﻠﻔﺔ ) … ‪HD, SD‬إﻟﺦ(‬

‫ﺑﺲ ﻣﺶ ﻛﻞ ﻣﺰود ﺑﯿﺪﻋﻢ ﻛﻞ ﺟﻮدة‬
‫_‪R‬‬

‫وﻣﻄﻠﻮب ﺗﻌﺮض اﻟﻔﯿﺪﯾﻮ ﺑﺠﻮدة ﻣﻌﯿﻨﺔ ﻋﻠﻰ أي ﻣﺰود‬

‫‪M‬‬

‫ﻓﯿﮫ ﻣﺤﻮرﯾﻦ ﻟﻠﺘﻐﯿﯿﺮ )‪:(Dimensions of Change‬‬

‫ﻣﺰود اﻟﻔﯿﺪﯾﻮ )… ‪Video Provider (YouTube, Twitch,‬‬

‫ﺟﻮدة اﻟﻔﯿﺪﯾﻮ )… ‪Video Quality (HD, SD, 4K,‬‬

‫اﻟﻤﺰود ﺑﯿﺘﻐﯿﺮ‬
‫واﻟﺠﻮدة ﺑﺘﺘﻐﯿﺮ‬
‫وﻟﻮ ﺣﺎوﻟﺖ ﺗﺒﻨﻲ ﻛﻞ اﻟﺘﺮﻛﯿﺒﺎت دي ﺑﻜﻼﺳﺎت ﻣﺴﺘﻘﻠﺔ ھﺘﻮﺻﻞ ﻟﻌﺪد ﻛﺒﯿﺮ ﺟﺪا ﻣﻦ اﻟﻜﻼﺳﺎت‬

‫ﻣﺜﺎل‪:‬‬

‫‪YouTubeHDPlayer‬‬

‫‪YouTubeSDPlayer‬‬

‫‪TwitchHDPlayer‬‬

‫‪TwitchSDPlayer‬‬

‫وﻛﻞ ﻣﺎ ﺗﻀﯿﻒ ﺟﻮدة أو ﻣﺰود ﺟﺪﯾﺪ ھﺘﻀﻄﺮ ﺗﻀﯿﻒ ﻛﻼس ﺟﺪﯾﺪ‬

‫‪Design-Pattern Page 22‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫‪TwitchSDPlayer‬‬

‫وﻛﻞ ﻣﺎ ﺗﻀﯿﻒ ﺟﻮدة أو ﻣﺰود ﺟﺪﯾﺪ ھﺘﻀﻄﺮ ﺗﻀﯿﻒ ﻛﻼس ﺟﺪﯾﺪ‬

‫ودي اﺳﻤﮭﺎ ‪ Cartesian Explosion‬وﺑﺘﺨﻠﻲ اﻟﻜﻮد ﻏﯿﺮ ﻗﺎﺑﻞ ﻟﻠﺼﯿﺎﻧﺔ‬

‫اﻟﻔﺮق ﺑﯿﻦ ‪ Bridge‬و‪ Strategy‬ﺑﺸﻜﻞ ﺗﻔﺼﯿﻠﻲ‬

‫‪:Bridge Pattern‬‬
‫اﻟﮭﺪف ﻣﻨﮫ إﻧﻚ ﺗﻔﺼﻞ ﺑﯿﻦ ‪ Abstraction‬و ‪ Implementation‬ﯾﻌﻨﻲ ﻋﻨﺪك ﻛﺎﺋﻨﯿﻦ ﻣﺴﺘﻘﻠﯿﻦ ﻛﻞ واﺣﺪ ﻓﯿﮭﻢ ﺑﯿﺘﻐﯿﺮ ﻟﻮﺣﺪه ﻓﺒﺘﺮﺑﻄﮭﻢ ﺑﺒﻌﺾ ﺑﻜﻮﺑﺮي ﺑﺪل ﻣﺎ ﺗﺪﻣﺠﮭﻢ ﻓﻲ ﻛﻼس واﺣﺪ‬

‫‪:Strategy Pattern‬‬
‫اﻟﮭﺪف إﻧﻚ ﺗﻐﯿﺮ ﺳﻠﻮك ﻣﻌﯿﻦ ﺟﻮه اﻟﻜﻼس ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻌﺪل اﻟﻜﻼس ﻧﻔﺴﮫ ﯾﻌﻨﻲ اﻟﺴﻠﻮك )اﻟﺠﺰء اﻟﻠﻲ ﺑﯿﺘﻐﯿﺮ( ﺑﯿﺒﻘﻰ ‪External object‬‬

‫‪o‬‬
‫‪et‬‬ ‫طﺒﯿﻌﺔ اﻟﻌﻼﻗﺔ ﺑﯿﻦ اﻟﻜﻼﺳﺎت‬
‫‪:Bridge‬‬
‫اﻟﻌﻼﻗﺔ ﺑﯿﻦ ‪ Abstraction‬و‪ Implementation‬ﻋﺎدة ﺑﺘﻜﻮن ﻋﻼﻗﺔ ﺗﺮﻛﯿﺒﯿﺔ )‪ (has-a‬ﺑﯿﺘﻢ اﺳﺘﺨﺪاﻣﮭﺎ ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك أﻛﺜﺮ ﻣﻦ ﻣﺤﻮر ﻟﻠﺘﻐﯿﯿﺮ‬
‫‪Sh‬‬
‫‪:Strategy‬‬

‫اﻟﻌﻼﻗﺔ ﺑﯿﻦ ﻛﻼس وﺳﻠﻮك ﻣﻌﯿﻦ اﻟﺴﻠﻮك ﺑﯿﺘﻐﯿﺮ ﺑﻨﺎء ﻋﻠﻰ اﻟﺴﯿﻨﺎرﯾﻮ ﺑﺘﺴﺘﺨﺪﻣﮭﺎ ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك ﺧﻮارزﻣﯿﺎت ﻣﺨﺘﻠﻔﺔ ﻟﻨﻔﺲ اﻟﻤﮭﻤﺔ‬
‫_‪R‬‬

‫ﺗﻮﻗﯿﺖ اﺧﺘﯿﺎر اﻟـ ‪Pattern‬‬

‫‪:Bridge‬‬
‫ﻟﻤﺎ ﺗﺤﺲ إن ﻓﯿﮫ ‪ two dimensions‬ﺑﯿﺘﻐﯿﺮوا وﻋﺎﯾﺰ ﺗﺒﻨﻲ ‪ hierarchies‬ﻣﻨﻔﺼﻠﺔ وﺗﺮﺑﻄﮭﻢ ﺑﺒﻌﺾ‬
‫‪M‬‬

‫‪:Strategy‬‬

‫ﺑﺮه ﻣﻦ ﻏﯿﺮ ‪if/else‬‬

‫ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك ﺳﻠﻮك ﺑﯿﺘﻜﺮر ﺑﻄﺮق ﻣﺨﺘﻠﻔﺔ وﻋﺎﯾﺰ ﺗﺨﻠﻲ اﻟﻜﻼس ﯾﺴﺘﺒﺪل اﻟﺴﻠﻮك ﻣﻦ ّ‬

‫‪Design-Pattern Page 23‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Composite Pattern‬‬
‫‪Sunday, July 13, 2025‬‬ ‫‪7:17 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬
‫‪Composite Pattern‬‬

‫ﺑﯿﺴﻤﺤﻠﻚ إﻧﻚ ﺗﺒﻨﻲ ﻛﺎﺋﻨﺎت ﺑﺸﻜﻞ )‪ (Hierarchical‬وﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻌﻨﺎﺻﺮ اﻟﻔﺮدﯾﺔ )‪ (Leaf‬واﻟﻤﺮﻛﺒﺔ )‪ (Composite‬ﺑﻨﻔﺲ اﻟﺸﻜﻞ‪.‬‬
‫ﺑﺒﺴﺎطﺔ‪:‬‬
‫ﻟﻮ ﻋﻨﺪك "ﺣﺎﺟﺔ ﺟﻮاھﺎ ﺣﺎﺟﺎت ﺗﺎﻧﯿﺔ ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع"‬
‫وده ﺑﯿﺨﻠﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻌﺎھﻢ ﻛﺄﻧﮭﻢ ﺣﺎﺟﺔ واﺣﺪة رﻏﻢ إﻧﮭﻢ ﺟﻮا ﺑﻌﺾ‪.‬‬

‫ﺗﺨﯿﻞ إﻧﻚ ﺑﺘﺒﻨﻲ ھﯿﻜﻞ زي‪:‬‬

‫ﻗﺎﺋﻤﺔ )‪ (Menu‬ﻓﯿﮭﺎ ﻋﻨﺎﺻﺮ ﻋﺎدﯾﺔ وﺟﻮاھﺎ ‪ Submenus‬ﻓﯿﮭﺎ ﻋﻨﺎﺻﺮ ﺗﺎﻧﯿﺔ وﻛﻞ ﻋﻨﺼﺮ ﻣﻨﮭﻢ ﻣﻤﻜﻦ ﯾﻜﻮن ‪ Action‬أو ﻗﺎﺋﻤﺔ ﺗﺎﻧﯿﺔ‬

‫{ )'‪if ([Link] === 'menu‬‬ ‫ﻟﻮ ﺣﺎوﻟﺖ ﺗﻜﺘﺐ ﻛﻮد ﻟﻜﻞ ﻧﻮع ﻋﻨﺼﺮ ﺑﻄﺮﯾﻘﺔ ﻣﻨﻔﺼﻠﺔ‪ ،‬ھﺘﻀﻄﺮ ﺗﻜﺘﺐ ﻟﻜﻞ ﺣﺎﻟﺔ ﻛﻮد ﻣﺨﺘﻠﻒ‪:‬‬
‫;)‪renderMenu(item‬‬

‫{ )'‪} else if ([Link] === 'action‬‬ ‫اﻟﻜﻮد ھﯿﺒﻘﻰ ﻣﻠﯿﺎن ‪if else‬‬
‫وﻣﺶ ھﯿﻜﻮن ﻗﺎﺑﻞ ﻟﻠﺘﻮﺳﻌﺔ ﺑﺴﮭﻮﻟﺔ وﻟﻮ ﻋﺎﯾﺰ ﺗﻀﯿﻒ ﻋﻨﺼﺮ ﺟﺪﯾﺪ ﻻزم ﺗﻌﺪل ﻓﻲ ﻛﻞ ﺣﺘﺔ‬
‫;)‪renderButton(item‬‬

‫}‬

‫‪o‬‬
‫‪et‬‬ ‫اﻟﻔﻜﺮة اﻷﺳﺎﺳﯿﺔ‬
‫‪ Composite Pattern‬ﺑﯿﺨﻠﯿﻚ‪:‬‬

‫ﺗﻌﻤﻞ ﻛﺎﺋﻦ ﻣﻮﺣﺪ )‪ (Component‬ﯾﻤﺜﻞ اﻟﻌﻨﺼﺮ‬

‫‪Sh‬‬
‫وﺗﻌﻤﻞ ﻣﻨﮫ ﻧﻮﻋﯿﻦ‪:‬‬

‫‪ :Leaf‬ﻋﻨﺼﺮ ﺑﺴﯿﻂ ﻣﺎﻟﻮش أطﻔﺎل‬

‫_‪R‬‬

‫‪ :Composite‬ﻋﻨﺼﺮ ﻣﺮﻛﺐ ﺟﻮاه ﻋﻨﺎﺻﺮ ﺗﺎﻧﯿﺔ )‪ Leaf‬أو ‪(Composite‬‬

‫وﺑﺎﻟﺘﺎﻟﻲ‪ ،‬ﺗﻘﺪر ﺗﺴﺘﺨﺪم ﻧﻔﺲ اﻟﻤﯿﺜﻮد )‪ (... ,render, show, delete‬ﻋﻠﻰ اﻟﻜﻞ‪.‬‬
‫‪M‬‬

‫ﯾﺒﻘﻲ اﻷطﺮاف اﻟﻠﻲ ﺑﺘﺸﺎرك ﻓﻲ ‪Composite‬‬

‫‪:Component Interface‬‬
‫ده اﻟﻮاﺟﮭﺔ اﻟﻤﺸﺘﺮﻛﺔ اﻟﻠﻲ ﻛﻞ اﻟﻌﻨﺎﺻﺮ ﺑﺘﻨﻔﺬھﺎ‬
‫ﺑﺘﻌﺮف اﻟﻮظﺎﺋﻒ زي ‪ ()render‬أو ‪.()display‬‬
‫ّ‬
‫‪:Leaf‬‬
‫ﻋﻨﺼﺮ ﺑﺴﯿﻂ ﻣﺎﻟﻮش أطﻔﺎل‪ ،‬ﺑﯿﻨﻔﺬ اﻟﻮظﯿﻔﺔ ﺑﻨﻔﺴﮫ‪.‬‬
‫‪:Composite‬‬
‫ﻋﻨﺼﺮ ﻣﺮﻛﺐ ﺟﻮاه ﻋﻨﺎﺻﺮ ﺗﺎﻧﯿﺔ وﺑﯿﻨﻔﺬ اﻟﻮظﯿﻔﺔ ﻋﻦ طﺮﯾﻖ اﺳﺘﺪﻋﺎﺋﮭﺎ ﻟﻜﻞ اﻟﻌﻨﺎﺻﺮ اﻟﻠﻲ ﺟﻮاه‪.‬‬

‫‪Design-Pattern Page 24‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Creational Patterns‬‬
‫‪Sunday, April 20, 2025‬‬ ‫‪2:16 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫اﻟـ ‪ : Creational Design Patterns‬ﺑﺘﺤﻞ اﻟﻤﺸﺎﻛﻞ اﻟﻤﺘﻌﻠﻘﺔ ﺑﺈﻧﺸﺎء اﻟﻜﺎﺋﻨﺎت )‪ (Objects‬ﺑﻄﺮﯾﻘﺔ ﻣﺮﻧﺔ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻮﺳﻌﺔ وﺑﺘﻔﺼﻞ اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ ﻋﻦ اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺒﻨﯿﮫ‬

‫ﺑﺘﺴﺎﻋﺪﻧﺎ ﻋﻠﻰ‪:‬‬
‫اﻟﺘﺤﻜﻢ ﻓﻲ ﻋﺪد اﻟـ ‪ Instances‬و ﺟﻌﻞ اﻟﻜﻮد أﻛﺘﺮ ﻣﺮوﻧﺔ ﻋﻨﺪ اﻟﺘﻐﯿﯿﺮ و ﺗﺤﺴﯿﻦ اﻟـ ‪Testability‬‬

‫اﻷﻧﻤﺎط اﻟﺨﻤﺴﺔ ﻓﻲ ‪:Creational Patterns‬‬

‫‪:Factory Pattern‬‬
‫ﺗﺨﻠﻲ ﻛﻼس أو ﻓﺎﻧﻜﺸﻦ ﻣﺴﺆوﻟﺔ ﻋﻦ إﻧﺸﺎء ﻛﺎﺋﻨﺎت‪ ،‬ﺑﺪل ﻣﺎ ﺗﻜﺘﺐ ‪ new‬ﻓﻲ ﻛﻞ ﺣﺘﺔ‪.‬‬

‫‪Builder Pattern‬‬
‫ﺑﺘﻔﺼﻞ ﺧﻄﻮات ﺑﻨﺎء اﻟﻜﺎﺋﻦ اﻟﻤﻌﻘﺪ )‪ (object with many options‬ﻋﻦ اﻟﻜﻼس ﻧﻔﺴﮫ‪ ،‬وﺑﺘﺪﯾﻚ طﺮﯾﻘﺔ ﻣﺮﻧﺔ ﺗﺒﻨﻲ ﺑﯿﮭﺎ ﻛﺎﺋﻨﺎت ﺧﻄﻮة ﺑﺨﻄﻮة‪.‬‬

‫‪o‬‬
‫‪Prototype Pattern‬‬
‫ﺗﺴﺘﺨﺪم ﻛﺎﺋﻦ ﻣﻮﺟﻮد ﻛـ ﻗﺎﻟﺐ )‪ (prototype‬وﺗﻨﺴﺨﮫ ﺑﺪل ﻣﺎ ﺗﺒﻨﯿﮫ ﻣﻦ اﻟﺼﻔﺮ‪.‬‬
‫‪et‬‬ ‫‪Singleton Pattern‬‬
‫‪Sh‬‬
‫ﺑﯿﻀﻤﻦ إن ﻓﯿﮫ ‪ instance‬واﺣﺪة ﺑﺲ ﻣﻦ اﻟﻜﻼس ﻣﻮﺟﻮدة ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻛﻠﮫ‪.‬‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 25‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Factory Pattern‬‬
‫‪Saturday, July 19, 2025‬‬ ‫‪2:06 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪: Factory Pattern‬‬

‫ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ ﻓﻜﺮة إﻧﻚ ﺑﺪل ﻣﺎ ﺗﻨﺸﺊ اﻟﻜﺎﺋﻨﺎت )‪ (Objects‬ﺑﺈﯾﺪك ﻓﻲ اﻟﻜﻮد ﺑﺎﺳﺘﺨﺪام ‪ new‬ﺗﺪي اﻟﻤﮭﻤﺔ دي ﻟﺠﮭﺔ ﺗﺎﻧﯿﺔ اﺳﻤﮭﺎ ‪Factory‬‬
‫اﻟﮭﺪف إﻧﻚ ﺗﻔﺼﻞ ﻋﻤﻠﯿﺔ اﻹﻧﺸﺎء ﻧﻔﺴﮭﺎ ﻋﻦ اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪم اﻟﻜﺎﺋﻨﺎت‬
‫ده ﺑﯿﺴﺎﻋﺪ ﺟﺪا ﻟﻤﺎ أﻧﻮاع اﻟﻜﺎﺋﻨﺎت اﻟﻠﻲ ﺑﺘﻨﺸﺌﮭﺎ ﺑﺘﺘﻐﯿﺮ ﺣﺴﺐ اﻟﻈﺮوف‬

‫ﻟﯿﮫ ﻣﻤﻜﻦ ﻧﺤﺘﺎج ‪Factory‬؟‬

‫ﻟﻮ ﻋﻨﺪك ﻛﻼس ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ أﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ اﻟﻤﻨﺘﺠﺎت )‪ (Product classes‬وﻛﻞ ﻣﻨﺘﺞ ﻟﮫ طﺮﯾﻘﺔ إﻧﺸﺎء ﻣﺨﺘﻠﻔﺔ أو ﺷﺮوط ﻣﻌﯿﻨﺔ‬
‫ﯾﺒﻘﻰ ﺑﺪل ﻣﺎ اﻟﻜﻮد اﻟﺮﺋﯿﺴﻲ ﯾﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻞ اﻟﺘﻔﺎﺻﯿﻞ دي ﺗﺪﯾﮭﺎ ﻟﻜﻼس ﻣﺴﺘﻘﻞ ﻣﮭﻤﺘﮫ اﻟﻮﺣﯿﺪة إﻧﮫ ﯾﻨﺸﺊ اﻟﻜﺎﺋﻦ اﻟﺼﺢ ﻋﻠﻰ ﺣﺴﺐ اﻟﻤﺪﺧﻼت‬

‫ﻣﺜﺎااال‬

‫إﻧﺖ ﻋﻨﺪك ﻧﻈﺎم ‪ E-Commerce‬ﺑﯿﺤﺘﺎج ﯾﺘﻌﺎﻣﻞ ﻣﻊ أﻧﻮاع ﻣﺨﺘﻠﻔﺔ ﻣﻦ وﺳﺎﺋﻞ اﻟﺪﻓﻊ‪. AmericanExpress، MasterCard،Visa :‬‬

‫‪o‬‬
‫ﻛﻞ واﺣﺪة ﻟﯿﮭﺎ ‪ processing logic‬ﺧﺎص ﺑﯿﮭﺎ )ﯾﻌﻨﻲ ﻣﻤﻜﻦ ﺗﺨﺘﻠﻒ ﻓﻲ اﻟﺮﺳﻮم أو ﺧﻄﻮات اﻟﺘﻨﻔﯿﺬ(‪.‬‬

‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫ﻓﻲ اﻟﺤﺎﻟﺔ دي‪ ،‬ﺑﺪل ﻣﺎ ﻧﻜﺘﺐ ‪ if‬أو ‪ switch‬ﺟﻮه اﻟﻜﻮد اﻟﺮﺋﯿﺴﻲ وﻧﻌﻤﻞ ﺗﺸﻌﺐ ﻛﺒﯿﺮ‬
‫ﺑﻨﺴﺘﺨﺪم ‪ Factory Pattern‬ﻋﻠﺸﺎن ﻧﻌﺰل ﻣﺴﺆوﻟﯿﺔ إﻧﺸﺎء اﻟـ ‪ Payment Processor‬اﻟﻤﻨﺎﺳﺐ ﻓﻲ ﻣﻜﺎن واﺣﺪ‪.‬‬

‫اﻟﺘﻘﺴﯿﻢ‬
‫‪ Interface‬أو ‪ Class‬أﺳﺎﺳﻲ ﯾﺤﺪد ﺷﻜﻞ أي ‪PaymentProcessor‬‬

‫‪ Implementations‬ﻣﺘﻌﺪدة ﻟﻜﻞ ﻧﻮع ﻣﻦ أﻧﻮاع اﻟﻜﺮوت‬

‫‪ Factory class‬ﻣﺴﺆوﻟﺔ ﻋﻦ إﻧﺸﺎء اﻟـ ‪ Processor‬اﻟﻤﻨﺎﺳﺐ ﺑﻨﺎء ﻋﻠﻰ ﻧﻮع اﻟﻜﺎرت‬

‫‪ Client code‬ﺑﯿﺴﺘﺨﺪم اﻟـ ‪ Factory‬وﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ اﻟـ ‪ Interface‬ﺑﺲ‬

‫‪.‬‬

‫‪Design-Pattern Page 26‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫‪ Implementations‬ﻣﺘﻌﺪدة ﻟﻜﻞ ﻧﻮع ﻣﻦ أﻧﻮاع اﻟﻜﺮوت‬

‫‪ Factory class‬ﻣﺴﺆوﻟﺔ ﻋﻦ إﻧﺸﺎء اﻟـ ‪ Processor‬اﻟﻤﻨﺎﺳﺐ ﺑﻨﺎء ﻋﻠﻰ ﻧﻮع اﻟﻜﺎرت‬

‫‪ Client code‬ﺑﯿﺴﺘﺨﺪم اﻟـ ‪ Factory‬وﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ اﻟـ ‪ Interface‬ﺑﺲ‬

‫‪.‬‬

‫أﻧﺖ ھﻨﺎ ﺑﺘﻌﺰل ﻣﺴﺆوﻟﯿﺔ اﻹﻧﺸﺎء ﻓﻲ اﻟـ ‪ Factory‬وﺑﺘﺨﻠﻲ اﻟﻜﻮد ﻧﻈﯿﻒ وﺳﮭﻞ اﻟﺘﻮﺳﻌﺔ‪.‬‬

‫ﻟﻮ ﻓﻲ اﻟﻤﺴﺘﻘﺒﻞ ﻋﺎﯾﺰ ﺗﻀﯿﻒ ﻧﻮع ﺟﺪﯾﺪ )زي ‪(PayPal‬‬

‫ﻛﻞ اﻟﻠﻲ ھﺘﻌﻤﻠﮫ‪ :‬ﺗﻀﯿﻒ ‪ Class‬ﺟﺪﯾﺪ وﺗﺤﺪث ‪ Factory‬ﺑﺲ‬

‫اﻟﻜﻼﯾﻨﺖ ﻣﺶ ﺑﯿﮭﺘﻢ ھﻮ ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ إﯾﮫ ھﻮ ﺷﺎﯾﻒ ﺑﺲ ‪ Interface‬ﻣﻮﺣﺪ‬

‫‪Abstract Factory‬‬
‫ووظﯿﻔﺘﮫ اﻷﺳﺎﺳﯿﺔ ھﻲ ﺗﻮﻓﯿﺮ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﺼﺎﻧﻊ )‪ (Factories‬ﻛﻞ ﻣﺼﻨﻊ ﻣﺴﺆول ﻋﻦ إﻧﺸﺎء ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻜﺎﺋﻨﺎت اﻟﻤﺮﺗﺒﻄﺔ ﺑﺒﻌﺾ )‪ (related objects‬ﻣﻦ ﻏﯿﺮ ﻣﺎ اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪﻣﮭﻢ‬
‫ﯾﻌﺮف اﻟﻨﻮع اﻟﺤﻘﯿﻘﻲ ﻟﻜﻞ ﻛﺎﺋﻦ‪.‬‬

‫‪o‬‬
‫ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪك ﺳﯿﺴﺘﻢ ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ أﻛﺜﺮ ﻣﻦ ﻧﻈﺎم ﺗﺸﻐﯿﻞ أو أﻛﺜﺮ ﻣﻦ ‪ Theme‬وﻋﺎﯾﺰ ﺗﻮﻟﺪ ‪ UI Elements‬ﻣﺨﺘﻠﻔﺔ ﺣﺴﺐ اﻟﺒﯿﺌﺔ ﺗﻘﺪر ﺗﺴﺘﺨﺪم ‪ Abstract Factory‬ﻋﻠﺸﺎن ﺗﻮﻟﺪ اﻟﻌﻨﺎﺻﺮ‬

‫‪et‬‬ ‫اﻟﻤﺮﺗﺒﻄﺔ ﺑﺒﻌﺾ ﻛـ"ﻣﺠﻤﻮﻋﺔ" ﻣﺘﺴﻘﺔ‬

‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫ﻣﺘﻰ ﺗﺴﺘﺨﺪم ‪Abstract Factory‬؟‬

‫اﺳﺘﺨﺪﻣﮫ ﻟﻤﺎ‪:‬‬

‫ﺗﺤﺘﺎج ﺗﻮﻟﺪ ﻋﺎﺋﻼت ﻣﻦ اﻟﻜﺎﺋﻨﺎت اﻟﻤﺮﺗﺒﻄﺔ )‪.(related products‬‬

‫ﻋﺎﯾﺰ ﺗﻔﺼﻞ اﻟﻜﻮد اﻟﻠﻲ ﺑﯿﺴﺘﺨﺪم اﻟﻜﺎﺋﻨﺎت ﻋﻦ ﺗﻔﺎﺻﯿﻞ إﻧﺸﺎءھﺎ‪.‬‬

‫ﺗﺤﺘﺎج إﻧﻚ ﺗﺪﻋﻢ ﺑﯿﺌﺎت أو ‪ configurations‬ﻣﺨﺘﻠﻔﺔ ﺑﺪون ﻣﺎ ﺗﻐﯿﺮ اﻟﻜﻮد اﻟﺮﺋﯿﺴﻲ‬

‫‪Design-Pattern Page 27‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Builder Pattern‬‬
‫‪Saturday, July 19, 2025‬‬ ‫‪5:36 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫‪Builder Pattern‬؟‬

‫ھﻮ ‪ Creational Design Pattern‬ھﺪﻓﮫ إﻧﮫ ﯾﻔﺼﻞ ﺑﯿﻦ "ﺧﻄﻮات إﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻌﻘﺪ" و"اﻟﺘﻤﺜﯿﻞ اﻟﻨﮭﺎﺋﻲ ﻟﻠﻜﺎﺋﻦ"‪.‬‬

‫ﯾﻌﻨﻲ ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك ‪ object‬ﻓﯿﮫ ﺗﻔﺎﺻﯿﻞ ﻛﺘﯿﺮ وﻣﻤﻜﻦ ﯾﺘﺒﻨﻲ ﺑﻌﺪة طﺮق )ﺑﻤﻌﻨﻰ إن ﺑﻌﺾ اﻟﺨﺼﺎﺋﺺ ﻣﻤﻜﻦ ﺗﺒﻘﻰ ‪ optional‬أو ‪(configurable‬‬

‫اﻟـ ‪ Builder‬ﺑﯿﺴﺎﻋﺪك ﺗﺒﻨﻲ اﻟـ ‪ object‬ﺧﻄﻮة ﺑﺨﻄﻮة‪ ،‬ﻣﻦ ﻏﯿﺮ ﻣﺎ ﯾﺤﺼﻞ ﺗﻌﻘﯿﺪ ﻓﻲ اﻟـ ‪ constructor‬أو ﺗﻜﺮار ﻓﻲ اﻟﻜﻮد‪.‬‬

‫إﻣﺘﻰ أﺳﺘﺨﺪم ‪Builder Pattern‬؟‬

‫ﺑﺘﺴﺘﺨﺪم اﻟـ ‪ Builder‬ﻓﻲ اﻟﺤﺎﻻت دي‪:‬‬

‫ﻟﻤﺎ ﯾﻜﻮن اﻟـ ‪ object‬ﻓﯿﮫ ﻋﺪد ﻛﺒﯿﺮ ﻣﻦ اﻟﺨﺼﺎﺋﺺ أو اﻟﻘﯿﻢ اﻟﻠﻲ ﻣﻤﻜﻦ ﺗﺨﺘﻠﻒ )‪.(optional parameters‬‬

‫ﻟﻤﺎ ﯾﻜﻮن ﻋﻨﺪك ﻋﺪة طﺮق ﻣﺨﺘﻠﻔﺔ ﻟﺒﻨﺎء ﻧﻔﺲ اﻟـ ‪.object‬‬
‫ﻟﻤﺎ ﯾﻜﻮن ﻓﻲ اﺧﺘﻼف ﻓﻲ ﺗﺮﺗﯿﺐ ﺗﻨﻔﯿﺬ ﺧﻄﻮات اﻹﻧﺸﺎء‪.‬‬
‫ﻟﻤﺎ ﻋﺎﯾﺰ ﺗﺨﻠﻲ اﻟـ ‪ object immutable‬ﺑﻌﺪ ﻣﺎ ﯾﺘﺒﻨﻲ‪.‬‬

‫‪o‬‬
‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫دور اﻟـ ‪) Builder Class‬أو ‪(Function‬‬

‫اﻟـ ‪) Builder‬ﺳﻮاء ﻛﺎن ﻛﻼس أو داﻟﺔ ﻓﻲ ‪ (JavaScript‬دوره إﻧﮫ ﯾﺠﻤﻊ ﻛﻞ اﻟﻤﻌﻠﻤﺎت اﻟﻼزﻣﺔ ﻹﻧﺸﺎء اﻟﻜﺎﺋﻦ ﺧﻄﻮة ﺑﺨﻄﻮة‬
‫ﻋﺎدة ً ﺑﻨﻌﻤﻞ ﻣﯿﺜﻮد ﻟﻜﻞ ﻣﻌﻠﻤﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻌﻠﻤﺎت ﻣﺘﺮاﺑﻄﺔ ﺑﺲ ﻣﻔﯿﺶ ﻗﺎﻋﺪة ﺻﻠﺒﺔ‬
‫اﻟﻤﺼﻤﻢ )اﻟـ ‪ (developer‬ھﻮ اﻟﻠﻲ ﺑﯿﻘﺮر إزاي ﯾﺴﻤﻲ اﻟﻤﯿﺜﻮدز وإزاي ھﺘﺸﺘﻐﻞ اﻟﮭﺪف إﻧﻚ ﺗﺨﻠﻲ اﻟﻌﻤﻠﯿﺔ ﻣﺮﻧﺔ وواﺿﺤﺔ‬

‫اﻟﮭﺪف اﻷﺳﺎﺳﻲ ﻣﻦ اﻟـ ‪ Builder Pattern‬ھﻮ إﻧﻚ ﺗﻔﻜﻚ ‪ constructor‬ﻣﻌﻘﺪ )اﻟﻠﻲ ﺑﯿﺎﺧﺪ ﻣﻌﻠﻤﺎت ﻛﺘﯿﺮ( إﻟﻰ ﺧﻄﻮات ﺻﻐﯿﺮة وواﺿﺤﺔ‪.‬‬
‫‪Builder‬‬ ‫‪constructor‬‬

‫‪Design-Pattern Page 28‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫ﺑﺪل ﻣﺎ ﺗﻌﻤﻞ ‪ constructor‬ﻓﯿﮫ ‪ 10‬ﻣﻌﻠﻤﺎت وﯾﺒﻘﻰ ﺻﻌﺐ اﻟﻘﺮاءة واﻟﺘﻌﺪﯾﻞ اﻟـ ‪ Builder‬ﺑﯿﺨﻠﯿﻚ ﺗﻀﺒﻂ اﻟﻤﻌﻠﻤﺎت واﺣﺪة واﺣﺪة ﺑﻄﺮﯾﻘﺔ ﻣﺮﻧﺔ‬

‫ﻧﻈﺎم إﺷﻌﺎرات )‪ (Notifications‬ﻓﻲ ﺗﻄﺒﯿﻖ رﺳﺎﺋﻞ"‪ ،‬ﺑﺤﯿﺚ ﯾﻜﻮن ﻓﯿﮫ ﻣﺮوﻧﺔ ﻓﻲ إﻋﺪاد ﻣﺤﺘﻮﯾﺎت اﻹﺷﻌﺎر زي اﻟﺮﺳﺎﻟﺔ‪ ،‬اﻟﻤﺮﺳﻞ‪ ،‬اﻟﺘﺎرﯾﺦ‪،‬‬
‫وﺧﺼﺎﺋﺺ إﺿﺎﻓﯿﺔ زي اﻟﻤﺮﻓﻘﺎت )‪(attachments‬‬

‫ﺗﻌﺮﯾﻒ اﻟﻤﺸﻜﻠﺔ‪:‬‬
‫إﺷﻌﺎر )‪ (Notification‬ﻣﻤﻜﻦ ﯾﺘﻜﻮن ﻣﻦ‪:‬‬

‫‪ :messageContent‬ﻧﺺ اﻟﺮﺳﺎﻟﺔ )إﺟﺒﺎري(‬

‫‪ :sender‬اﺳﻢ أو ﺑﯿﺎﻧﺎت اﻟﻤﺮﺳﻞ )إﺟﺒﺎري(‬

‫‪ :timestamp‬ﺗﻮﻗﯿﺖ اﻹرﺳﺎل )إﺟﺒﺎري(‬

‫‪o‬‬
‫‪ :attachment‬ﻣﺮﻓﻖ اﺧﺘﯿﺎري‬

‫‪et‬‬ ‫‪ :priority‬درﺟﺔ اﻷوﻟﻮﯾﺔ )اﺧﺘﯿﺎري(‬

‫ﻟﻮ ﻋﻤﻠﺖ ‪ Constructor‬ﺑـ ‪ 5‬ﺑﺎراﻣﯿﺘﺮز ھﺘﺒﻘﻰ اﻟﺪﻧﯿﺎ ﻣﻠﺨﺒﻄﺔ ﺟﺪا ﺧﺼﻮﺻﺎ ﻟﻮ ﻋﺎﯾﺰ ﺗﺴﺘﺨﺪم ﺑﺎراﻣﯿﺘﺮز اﺧﺘﯿﺎرﯾﺔ ﺑﺲ‪.‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫اﻟﻤﻤﯿﺰات اﻟﻠﻲ ﻛﺪه أﺧﺪﻧﺎھﺎ ﻣﻦ اﻟـ ‪:Builder‬‬

‫ﺳﮭﻮﻟﺔ ﻗﺮاءة اﻟﻜﻮد‪ :‬اﻟﻜﻮد واﺿﺢ ﺟﺪا إﻧﻚ ﺑﺘﺒﻨﻲ إﺷﻌﺎر ﺑﻤﺤﺘﻮى ﻣﻌﯿﻦ وﺑﺘﻀﯿﻒ ﻋﻠﯿﮫ ﺧﺼﺎﺋﺺ اﺧﺘﯿﺎرﯾﺔ واﺣﺪة واﺣﺪة‪.‬‬

‫اﻟﻤﺮوﻧﺔ‪ :‬ﻣﻤﻜﻦ ﺗﺒﻨﻲ إﺷﻌﺎر ﻓﯿﮫ ﺧﺎﺻﯿﺔ واﺣﺪة ﺑﺲ أو اﻟﻜﻞ ﻣﻦ ﻏﯿﺮ ﻣﺎ ﺗﻀﻄﺮ ﺗﻌﻤﻞ ‪ Constructor‬ﺑﻌﺪد ﺿﺨﻢ ﻣﻦ اﻟﺒﺎراﻣﯿﺘﺮز‪.‬‬

‫‪) Immutability‬اﻟﻼ‪-‬ﺗﻐﯿﺮ(‪ :‬اﻟﻜﺎﺋﻦ اﻟﻨﮭﺎﺋﻲ ‪ Notification‬ﺑﯿﺘﻢ إﻧﺸﺎؤه ﺟﺎھﺰ‪ ،‬وﻣﺶ ﺑﻨﻌﺪّل ﻋﻠﯿﮫ ﺑﻌﺪ ﻛﺪه‪.‬‬

‫ﻗﺎﺑﻠﯿﺔ اﻟﺘﻮﺳﯿﻊ‪ :‬ﻟﻮ زودت ﺧﺎﺻﯿﺔ ﺟﺪﯾﺪة )زي ﻧﻮع اﻹﺷﻌﺎر(‪ ،‬ھﺘﺰودھﺎ ﺟﻮه اﻟـ ‪ Builder‬ﺑﺲ‪ ،‬ﻣﻦ ﻏﯿﺮ ﻣﺎ ّ‬
‫ﺗﺒﻮظ اﻟﻜﻮد اﻟﺘﺎﻧﻲ‬

‫ھﻞ ﺗﻘﺪر ﺗﺸﺮح اﻟﻔﺮق ﺑﯿﻦ ‪ Builder‬و‪Factory‬؟‬

‫‪Design-Pattern Page 29‬‬ ‫‪Mahmoud Shetawy‬‬

 ‫اﻟـ ‪ Factory‬ﺑﯿﺮﻛﺰ ﻋﻠﻰ "إﯾﮫ ﻧﻮع اﻟﻜﺎﺋﻦ اﻟﻠﻲ ھﯿﺘﺒﻨﻲ"‬

‫ﻟﻜﻦ اﻟـ ‪ Builder‬ﺑﯿﺮﻛﺰ ﻋﻠﻰ "إزاي ﺗﺒﻨﻲ اﻟﻜﺎﺋﻦ ﺧﻄﻮة ﺑﺨﻄﻮة" ﺧﺼﻮﺻﺎ ﻟﻮ اﻟﻜﺎﺋﻦ ﻣﻌﻘﺪ أو ﻓﯿﮫ ﺧﯿﺎرات ﻛﺘﯿﺮ‬

‫‪o‬‬
‫‪et‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 30‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Singleton Pattern‬‬
‫‪Saturday, July 19, 2025‬‬ ‫‪8:54 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫اﻟـ ‪:Singleton Pattern‬‬

‫ھﻮ ﻧﻤﻂ ﺗﺼﻤﯿﻢ )‪ (Design Pattern‬ﺑﯿﻀﻤﻦ إن ﻓﯿﮫ ‪ instance‬واﺣﺪة ﺑﺲ ﻣﻦ ﻛﻼس أو ﻛﺎﺋﻦ ﻣﻌﯿﻦ ﻓﻲ اﻟﺘﻄﺒﯿﻖ ﻛﻠﮫ وإن أي ﻛﻮد ﻋﺎﯾﺰ ﯾﺴﺘﺨﺪم اﻟﻜﺎﺋﻦ ده ﯾﻮﺻﻞ ﻟﻨﻔﺲ اﻟـ ‪instance‬‬

‫ﯾﻌﻨﻲ ﻟﻮ ﻋﻨﺪك ﻛﺎﺋﻦ زي ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت أو ‪ Logger‬ﺑﺪل ﻣﺎ ﺗﻨﺸﺊ ‪ instances‬ﺟﺪﯾﺪة ﻛﻞ ﻣﺮة ﺑﺘﺴﺘﺨﺪم ﻧﻔﺲ اﻟـ ‪ instance‬ﻋﺸﺎن ﺗﻮﻓﺮ اﻟﻤﻮارد وﺗﻀﻤﻦ إن ﻛﻞ اﻟﻜﻮد ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ ﻧﻔﺲ اﻟﺤﺎﻟﺔ‬
‫)‪(state‬‬

‫ﺗﻮﻓﯿﺮ اﻟﻤﻮارد‪ :‬ﺑﺪل ﻣﺎ ﺗﻨﺸﺊ ‪ instances‬ﻛﺘﯿﺮ ﺑﻨﻔﺲ اﻟﻮظﯿﻔﺔ )زي اﺗﺼﺎل ﺑﻘﺎﻋﺪة ﺑﯿﺎﻧﺎت(‪ ،‬ﺗﺴﺘﺨﺪم ‪ instance‬واﺣﺪة‬

‫ﺣﺎﻟﺔ ﻣﺸﺘﺮﻛﺔ )‪ :(Shared State‬ﺑﯿﻀﻤﻦ إن ﻛﻞ اﻟﻜﻮد ﺑﯿﺘﻌﺎﻣﻞ ﻣﻊ ﻧﻔﺲ اﻟﺒﯿﺎﻧﺎت أو اﻹﻋﺪادات‬

‫ﺗﺤﻜﻢ ﻣﺮﻛﺰي‪ :‬ﺑﯿﺨﻠﯿﻚ ﺗﺘﺤﻜﻢ ﻓﻲ ﻧﻘﻄﺔ وﺻﻮل واﺣﺪة )‪ (single point of access‬ﻟﻠﻜﺎﺋﻦ‪.‬‬
‫ﺗﺠﻨﺐ اﻟﺘﻜﺮار‪ :‬ﺑﯿﻤﻨﻊ إﻧﺸﺎء ﻧﺴﺦ ﻣﻜﺮرة ﻣﻦ ﻛﺎﺋﻨﺎت ﺛﻘﯿﻠﺔ زي اﺗﺼﺎﻻت اﻟﺸﺒﻜﺔ‪.‬‬

‫ﺧﻄﻮات ﺗﻨﻔﯿﺬ ‪Singleton‬‬

‫ﻓﻲ أي ﻟﻐﺔ ﺗﻘﺮﯾﺒﺎ )وھﻨﻄﺒﻖ ﺑﺎﻟﻤﺜﺎل ﻋﻠﻰ ‪ (JavaScript‬ﻓﯿﮫ ‪ ٣‬ﺣﺎﺟﺎت أﺳﺎﺳﯿﺔ ﻻزم ﻧﻌﻤﻠﮭﻢ‪:‬‬

‫‪o‬‬
‫ﻧﺨﻠﻲ اﻟـ‪ Constructor Private‬أو ‪ Protected‬ﻋﻠﺸﺎن ﻣﺎﻧﺴﻤﺤﺶ ﻷي ﻛﻮد ﺧﺎرﺟﻲ ﯾﻨﺎدي ‪ new‬وﯾﻌﻤﻞ ‪.Instance‬‬

‫‪et‬‬ ‫ﻧﻌﻤﻞ ‪ Static Method‬أو ‪ Property‬ﺑﺘﺘﺤﻜﻢ ﻓﻲ إﻧﺸﺎء أو اﺳﺘﺮﺟﺎع اﻟـ‪.Instance‬‬

‫ﻧﺨﺰن اﻟـ‪ Instance‬ﺟﻮه اﻟﻜﻼس وﻧﺘﺄﻛﺪ إﻧﮭﺎ ﺑﺘﺘﻌﻤﻞ ﻣﺮة واﺣﺪة ﺑﺲ‪.‬‬
‫‪Sh‬‬
‫اﻟﻨﺎس ﺑﺘﺘﻠﺨﺒﻂ ﻓﻲ ‪ Singleton Pattern‬ﻓﻲ ‪[Link]‬؟‬

‫ﺑﯿﺘﻠﺨﺒﻄﻮا ﻓﻲ اﻟـ ‪ Singleton Pattern‬ﻷﻧﮭﻢ ﺑﯿﻔﻜﺮوا إن ﺗﻄﺒﯿﻘﮫ ﻣﺤﺘﺎج ﺗﻌﻘﯿﺪ زي اﻟﻠﻲ ﻓﻲ اﻟﻠﻐﺎت اﻟﺘﻘﻠﯿﺪﯾﺔ زي ‪ Java‬أو ‪،++C‬‬

‫زي إﻧﺸﺎء ﻛﻼس ﻣﻊ ‪ static method‬وﺗﺄﻛﺪ إن اﻟـ ‪ instance‬واﺣﺪة ﺑﺲ‪.‬‬

‫_‪R‬‬

‫ﻟﻜﻦ ﻓﻲ ‪ [Link]‬اﻟـ ‪ module system‬ﺑﯿﻮﻓﺮ طﺮﯾﻘﺔ طﺒﯿﻌﯿﺔ وﺳﮭﻠﺔ ﻟﺘﺤﻘﯿﻖ اﻟـ ‪ Singleton Pattern‬ﺑﺴﺒﺐ طﺮﯾﻘﺔ اﻟـ ‪ caching‬ﺑﺘﺎﻋﺘﮫ‪.‬‬

‫ﻟﻤﺎ ﺑﺘﻌﻤﻞ ‪ require‬ﻟـ ‪ [Link] module‬ﺑﯿﺨﺰن )‪ (cache‬اﻟـ ‪ module‬ده ﻓﻜﻞ ﻣﺮة ﺑﺘﻌﻤﻞ ‪ require‬ﻟﻨﻔﺲ اﻟـ ‪ module‬ﺑﯿﺮﺟﻊ ﻧﻔﺲ اﻟـ ‪.instance‬‬

‫ﯾﻌﻨﻲ ﻟﻮ ﺻﺪرت ‪ instance‬ﻣﻦ ‪ module‬أي ﻛﻮد ﺑﯿﺴﺘﺨﺪم اﻟـ ‪ module‬ده ھﯿﺎﺧﺪ ﻧﻔﺲ اﻟـ ‪ instance‬وده ﺑﯿﺤﻘﻖ ھﺪف اﻟـ ‪ Singleton‬ﻣﻦ ﻏﯿﺮ ﺗﻌﻘﯿﺪ‬
‫‪M‬‬

‫‪project/‬‬
‫‪├── app/‬‬
‫‪│ ├── [Link]‬‬
‫‪│ ├── node_modules/‬‬
‫‪│ │ ├── package-a/‬‬
‫‪│ │ │ ├── [Link]‬‬
‫‪│ │ │ ├── node_modules/‬‬
‫‪│ │ │ │ ├── mydb/‬‬
‫‪│ │ ├── package-b/‬‬
‫‪│ │ │ ├── [Link]‬‬
‫ﻟﻤﺎذا اﻟـ ‪ Singleton‬ﺑﯿﻔﺸﻞ ھﻨﺎ؟‬
‫‪│ │ │ ├── node_modules/‬‬
‫‪│ │ │ │ ├── mydb/‬‬ ‫اﻟـ ‪ Singleton Pattern‬ﺑﯿﻔﺘﺮض إن ﻓﯿﮫ ‪ instance‬واﺣﺪة ﺑﺲ ﻓﻲ اﻟﺘﻄﺒﯿﻖ ﻛﻠﮫ‪ .‬ﻟﻜﻦ ﻓﻲ اﻟﺴﯿﻨﺎرﯾﻮ ده‪:‬‬
‫‪├── [Link]‬‬
‫‪ package-a/node_modules/mydb.‬ﻣﻦ ‪ mydb‬ﺑﯿﺴﺘﺪﻋﻲ ‪package-a‬‬

‫‪ package-b/node_modules/mydb.‬ﻣﻦ ‪ mydb‬ﺑﯿﺴﺘﺪﻋﻲ ‪package-b‬‬

‫ﺑﺴﺒﺐ اﻟـ ‪ module resolution [Link]‬ﺑﯿﺤﻤﻞ ﻧﺴﺨﺘﯿﻦ ﻣﻨﻔﺼﻠﺘﯿﻦ ﻣﻦ ‪ mydb‬وﻛﻞ ﻧﺴﺨﺔ ﺑﺘﺼﺪر ‪ instance‬ﻣﺨﺘﻠﻔﺔ ﻣﻦ ‪.Database‬‬

‫ده ﺑﯿﺨﻠﻲ ‪ getDbFromA‬و‪getDbFromB‬ﯾﺮﺟﻌﻮا ‪ instances‬ﻣﺨﺘﻠﻔﺔ وﺑﺎﻟﺘﺎﻟﻲ اﻟﺸﺮط اﻷﺳﺎﺳﻲ ﻟﻠـ ‪ instance) Singleton‬واﺣﺪة(‬
‫ﺑﯿﺘﻜﺴﺮ‪.‬‬

‫‪Design-Pattern Page 31‬‬ ‫‪Mahmoud Shetawy‬‬

‫‪Prototype Pattern‬‬
‫‪Saturday, July 19, 2025‬‬ ‫‪11:46 PM‬‬
‫ˉﺴﻢ ﷲ اﻟﺮﲪﻦ اﻟﺮﺣﲓ‬
‫ﻟﯿﺠﺰي ﷲ اﻟﺼﺎدﻗﲔ ﺑﺼﺪﻗﻬﻢ‬

‫اﻟـ ‪Prototype Pattern‬‬

‫ھﻮ ‪ Creational Pattern‬ھﺪﻓﮫ اﻷﺳﺎﺳﻲ إﻧﻨﺎ ﻧﻨﺸﺊ ﻧﺴﺦ ﺟﺪﯾﺪة ﻣﻦ ‪ Object‬ﻣﻌﯿﻦ ﻋﻦ طﺮﯾﻖ ﻧﺴﺨﺔ ﻣﻮﺟﻮدة أﺻﻼ )‪(Prototype‬‬

‫ﺑﺪل ﻣﺎ ﻧﺴﺘﺨﺪم ‪ new‬ﻛﻞ ﻣﺮة أو ﻧﻌﯿﺪ ﺗﻜﻮﯾﻨﮫ ﻣﻦ اﻟﺼﻔﺮ‬

‫ده ﺑﯿﻜﻮن ﻣﻔﯿﺪ ﺟﺪا ﻟﻤﺎ ﯾﻜﻮن إﻧﺸﺎء اﻟـ ‪ Object‬ﻣﻜﻠﻒ أو ﻓﯿﮫ إﻋﺪادات ﻛﺘﯿﺮة ﻣﻌﻘﺪة‬

‫ﻋﻤﻞ ‪ Prototype Pattern‬ﻓﻲ ‪JavaScript‬؟‬

‫ﻓﻲ ‪ JavaScript‬اﻟـ ‪ Prototype Pattern‬ﻣﺪﻣﺞ ﻓﻲ اﻟﻠﻐﺔ ﻧﻔﺴﮭﺎ ﺑﺴﺒﺐ اﻟـ ‪.prototypal inheritance‬‬

‫ﻛﻞ ﻛﺎﺋﻦ ﻓﻲ ‪ JavaScript‬ﻋﻨﺪه ‪) prototype‬ﺑﺘﻼﻗﯿﮫ ﻓﻲ __‪ __proto‬أو ‪ ([Link]‬وده ﺑﯿﺴﻤﺢ ﻟﻠﻜﺎﺋﻨﺎت ﺗﻮرث ﺧﺼﺎﺋﺺ وﻣﯿﺜﻮدز ﻣﻦ ﻛﺎﺋﻨﺎت‬
‫ﺗﺎﻧﯿﺔ‪.‬‬
‫اﻟـ ‪ Prototype Pattern‬ﺑﯿﺴﺘﻐﻞ اﻟﺨﺎﺻﯿﺔ دي ﻋﺸﺎن ﯾﻨﺸﺊ ﻛﺎﺋﻨﺎت ﺟﺪﯾﺪة ﻋﻦ طﺮﯾﻖ ﻧﺴﺦ ‪ prototype‬ﻣﻮﺟﻮد‪.‬‬

‫اﻟﻄﺮق اﻟﺸﺎﺋﻌﺔ ﻟﺘﻄﺒﯿﻖ اﻟـ ‪:Prototype Pattern‬‬

‫اﺳﺘﺨﺪام ‪ :[Link]‬ﺑﯿﺴﻤﺢ ﺑﻨﺴﺦ ﻛﺎﺋﻦ ﻣﻊ اﻟﺤﻔﺎظ ﻋﻠﻰ اﻟـ ‪.prototype chain‬‬

‫‪o‬‬
‫اﺳﺘﺨﺪام ‪ :Constructor Functions‬ﺑﻨﻌﻤﻞ داﻟﺔ ‪ constructor‬ﻣﻊ ‪ prototype‬ﻣﺸﺘﺮك ﻟﻜﻞ اﻟـ ‪.instances‬‬

‫اﺳﺘﺨﺪام ‪ :Classes‬اﻟـ ‪ ES6 classes‬ﻓﻲ ‪ JavaScript‬ﺑﺘﺴﺘﺨﺪم اﻟـ ‪prototype‬‬

‫‪et‬‬
‫‪ :Deep Cloning‬ﻟﻮ اﻟﻜﺎﺋﻦ ﻓﯿﮫ ﺑﯿﺎﻧﺎت ﻣﻌﻘﺪة )زي ‪ (nested objects‬ﺑﻨﺤﺘﺎج ﻧﻌﻤﻞ ‪ deep clone‬ﻋﺸﺎن ﻧﻀﻤﻦ إن اﻟﺘﻌﺪﯾﻼت ﻣﺶ ﺑﺘﺄﺛﺮ ﻋﻠﻰ اﻟـ ‪.prototype‬‬
‫‪Sh‬‬
‫_‪R‬‬
‫‪M‬‬

‫‪Design-Pattern Page 32‬‬ ‫‪Mahmoud Shetawy‬‬