‫ﺑﺴﻢ ﺍﷲ ﺍﻟﺮﺣﻤﻦ ﺍﻟﺮﺣﻴﻢ‬

‫ﺳﺒﺤﺎﻧﻚ ﻻ ﻋﻠﻢ ﻟﻨﺎ ﺇﻻ ﻣﺎ ﻋﻠﻤﺘﻨﺎ ﺇﻧﻚ ﺃﻧﺖ ﺍﻟﻌﻠﻴﻢ ﺍﻟﺤﻜﻴﻢ‬

‫اﻟﻤﻘﺪﻣﺔ ‪:‬‬

‫اﻟﺤﻤﺪ ﷲ ﻣﺎﺣﻤﺪه اﻟﺤﺎﻣﺪون وﻏﻔﻞ ﻋﻦ ﺣﻤﺪه اﻟﻐﺎﻓﻠﻮن واﻟﺼﻼة واﻟﺴﻼم ﻋﻠﻰ ﻋﺒﺪه ورﺳﻮﻟﻪ ﻣﺤﻤﺪ ﺻﻼة ﺑﻌﺪد ذرات‬
‫اﻟﺨﻼﺋﻖ وﻣﺎ ﻳﻜﻮن ‪ .‬ورﺿﺎك اﻟﻠﮫﻢ ﻋﻦ آﻟﻪ اﻟﻄﯿﺒﯿﻦ وﺻﺤﺒﻪ اﻟﻤﻜﺮﻣﯿﻦ اﻟﻤﺒﺠﻠﯿﻦ أﺟﻤﻌﯿﻦ وﺑﻌﺪ ‪،‬‬

‫ﻳﻘﺪم ھﺬا اﻟﺠﺰء ﻣﻦ اﻟﻜﺘﺎب اﻟﺨﻄﻮات اﻷوﻟﻲ ﻟﺘﻌﻠﯿﻢ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪ ،‬ورﺑﻤﺎ ﻳﺤﺘﺎج اﻟﻘﺎرئ أن ﻳﻜﻮن ﻣﻠﻤﺎ ﺑﺄﺳﺎﺳﯿﺎت‬
‫ﻟﻐﺔ اﻟﮫﺘﻤﻞ ‪ html‬اﻟﺨﺎﺻﺔ ﺑﺘﻜﻮﻳﻦ ﺻﻔﺤﺎت اﻟﻮﻳﺐ‬

‫ﻓﻲ ﺣﺎﻟﺔ وﺟﻮد أي أﺧﻄﺎء أرﺟﻮ اﻋﻼﻣﻲ ﻋﻦ اﻟﺨﻄﺄ ﻋﻠﻲ اﻟﻌﻨﻮان اﻟﺘﺎﻟﻲ‬
‫‪a_elhussein@hotmail.com‬‬

‫وأرﺟﻮ ﻣﻦ ﻛﻞ ﻣﻦ أﺳﺘﻔﺎد ﻣﻦ ھﺬا اﻟﻜﺘﺎب أن ﻳﺪﻋﻮا ﻟﻲ ﺑﺎﻟﺘﻮﻓﯿﻖ ﻓﻲ اﻟﺪﻧﯿﺎ واﻷﺧﺮة‬

‫إھﺪاء ‪:‬‬

‫أھﺪي ھﺬا اﻟﻜﺘﺎب إﻟﻲ اﻟﺠﯿﻞ اﻟﻘﺎدم اﻟﺬي ﻳﻌﺰ اﷲ ﺑﻪ اﻹﺳﻼم‬

‫وﻗﺪ ﺷﺎء اﷲ أن أﻧﮫﻲ ھﺬا اﻟﺠﺰء ﻣﻦ اﻟﻜﺘﺎب ﻓﻲ ﻳﻮم ﻣﯿﻼد اﻟﻨﺒﻲ اﻷﻣﻲ ﻣﺤﻤﺪ ﺑﻦ ﻋﺒﺪ اﷲ ﺻﻠﻲ اﷲ ﻋﻠﯿﻪ وﺳﻠﻢ وھﻮ‬
‫أول ﻣﻌﻠﻢ و ﺧﯿﺮ ﻣﻌﻠﻢ ﺑﻤﺎ ﻋﻠﻤﻪ اﷲ ‪ ،‬ﻓﺄﺣﻤﺪ اﷲ ﻋﻠﻲ أن ھﺪاﻧﻲ ﻟﮫﺬا وﻣﺎ ﻛﻨﺎ ﻟﻨﮫﺘﺪﻳﺎ ﻟﻮﻻ أن ھﺪاﻧﺎ اﷲ ‪.‬‬

‫وإﻧﺎ ﻣﺎداﻣﺖ ﻓﯿﺎ اﻟﺤﯿﺎة ﺑﺎذل ﺟﮫﺪي وﻋﻘﻠﻲ وﻣﺴﺘﻔﺮغ ﻃﺎﻗﺘﻲ ﻓﻲ اﻟﻌﻠﻢ وذﻟﻚ ﻟﺜﻼﺛﺔ أﻣﻮر‬

‫إﻓﺎدة ﻣﻦ ﻳﻄﻠﺐ اﻟﻌﻠﻢ ﻓﻲ ﺣﯿﺎﺗﻲ وﺑﻌﺪ ﻣﻤﺎﺗﻲ‬ ‫‪-‬‬

‫ذﺧﯿﺮة ﻟﻲ ﻓﻲ ﻗﺒﺮي وﻳﻮم ﺣﺴﺎﺑﻲ‬ ‫‪-‬‬
‫رﻓﻌﺔ ﻟﺴﻠﻄﺎن اﻟﻤﺴﻠﻤﯿﻦ‬ ‫‪-‬‬

‫ﺗﺄﻟﯿﻒ ‪ :‬اﻟﺤﺴﯿﻦ ﻣﺤﻤﺪ ﻋﻠﻲ‬

 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻤﺤﺘﻮﻳﺎﺕ‬

‫ﻣﻘﺪﻣﺔ ﻟﻠﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪١ .............................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻷول ‪:‬‬

‫أﺳﺎﺳﯿﺎت ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪١٠ .........................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ‪:‬‬
‫اﻟﻤﺘﻐﯿﺮات ‪٣٢ .............................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ‪:‬‬
‫اﻟﻤﻌﺎﻣﻼت ‪٤١ .............................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ ‪:‬‬
‫اﻟﺘﺤﻜﻢ ﻓﻲ ﻣﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ ‪٦٩ ...........................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪:‬‬
‫اﻟﺪوال أو اﻟﻮﻇﺎﺋﻒ ‪٨٧ ...................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺴﺎدس ‪:‬‬

‫‪2‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ‬
‫ﻣﻘﺪﻣﺔ ﻟﻠﻐﺔ ﺍﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ھﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫ﻣﺎھﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬

‫أﺻﻞ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬
‫ﻣﻤﯿﺰات اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬
‫ﻟﻤﺎذا أﺗﻌﻠﻢ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬
‫ﻣﺎھﻮ اﻟﻔﺮق ﺑﯿﻦ اﻟﺠﺎﻓﺎ ‪ ..‬واﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬
‫ﻣﺎ اﻟﻤﻘﺼﻮد ﺑﺸﻔﺮة اﻟﺒﺮﻧﺎﻣﺞ أو اﻟﺴﻮرس ﻛﻮد‬ ‫•‬
‫ﻣﺘﺼﻔﺤﻲ اﻟﻨﺘﺴﻜﯿﺐ واﻹﻛﺴﺒﻠﻮرر‬ ‫•‬
‫ﺑﺮﻧﺎﻣﺠﻚ اﻷول "‪"Hello World‬‬ ‫•‬

‫‪3‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺎھﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ وﺑﻜﻞ ﺑﺴﺎﻃﻪ ﻟﻐﺔ ﻣﻦ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ان ﺻﺢ اﻟﺘﻌﺒﯿﺮ ‪ ..‬ﻣﮫﺎﻣﮫﺎ اﻷﺳﺎﺳﯿﻪ ﺑﺚ اﻟﺤﯿﺎة ﻓﻲ ﺻﻔﺤﺎت اﻟﻮﻳﺐ‬
‫اﻟﻤﻜﺘﻮﺑﺔ ﺑﻠﻐﺔ ال ‪ HTML‬وﺗﻌﻄﯿﻚ اﻣﻜﺎﻧﯿﺔ اﻟﺘﺤﻜﻢ ﺑﻜﻞ ﺟﺰء ﻓﻲ ﺻﻔﺤﺔ اﻟﻮب‪ ،‬ﻣﻦ ال ‪ forms‬اﻟﻰ اﻟﻮﺻﻼت ﺑﻞ وﺣﺘﻰ‬
‫ﺑﻌﺾ اﻟﻮﻇﺎﺋﻒ اﻟﺨﺎرﺟﯿﻪ ‪.‬‬

‫أﺻﻞ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺻﻤﻤﺖ ﻣﻦ ﻗﺒﻞ ‪ Netscape‬ﻹﺿﺎﻓﺔ ﺑﻌﺾ اﻟﺤﯿﻮﻳﺔ اﻟﻰ ﺻﻔﺤﺎت اﻟﻮﻳﺐ‪ ،‬ﻃﺒﻌﺎ ﻻﻳﻔﻮﺗﻨﻲ أن أذﻛﺮ أن ال‬
‫‪ Java‬ﻓﻲ اﻻﺻﻞ ﺻﻤﻤﺖ ﻣﻦ ﻗﺒﻞ ﺷﺮﻛﺔ ‪ Sun‬وھﻲ اﻟﻤﺎﻟﻚ اﻷﺳﺎﺳﻲ ﻟﻠﻐﺔ ‪.‬‬

‫ﻣﻤﯿﺰات اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﺨﺘﻠﻒ ﻋﻦ أﻏﻠﺐ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻷﺧﺮى ﻓﻲ ﻛﻮﻧﮫﺎ ﺳﮫﻠﺔ اﻟﺘﺤﻜﻢ ‪ ،‬ﺣﺘﻰ ﻟﻸﺷﺨﺎص اﻟﺬﻳﻦ ﻟﻢ ﻳﻜﺘﺒﻮا‬
‫ﺑﺄي ﻟﻐﺔ ﺑﺮﻣﺠﺔ أ ﺧﺮى ﻓﻲ ﺣﯿﺎﺗﮫﻢ ﻛﻠﮫﺎ ‪ .‬ﺑﻜﻞ ﺑﺴﺎﻃﺔ‪،‬اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ھﻲ اﻟﮫﻮاء ﻟﺼﻔﺤﺘﻚ ‪.‬‬

‫ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أﻧﮫﺎ ﺑﺮﻣﺠﻪ ﻛﺎﺋﻨﯿﺔ اﻹﻋﺘﻤﺎد ‪ Object base‬اي ﺗﻌﺘﻤﺪ ﻋﻠﻲ وﺟﻮد ﺑﻌﺾ اﻟﻔﺌﺎت ان ﺻﺢ اﻟﺘﻌﺒﯿﺮ ﻣﺒﻨﯿﺔ ﺑﺪاﺧﻞ‬
‫اﻟﻠﻐﺔ ﻳﻤﻜﻦ إﺳﺘﺨﺪاﻣﮫﺎ ﺑﻜﻞ ﺳﮫﻮﻟﺔ ﻣﺜﻞ اﻟﻜﺎﺋﻦ ‪ window‬و اﻟﻜﺎﺋﻦ ‪. document‬‬

‫ﺗﻮﻓﺮ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻷﺣﺪاث ‪events‬‬

‫ﺗﻌﻤﻞ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻣﻦ ﺧﻼل ﺟﻤﯿﻊ أﻧﻈﻤﺔ اﻟﺘﺸﻐﯿﻞ ﻣﺜﻞ اﻟﻮﻳﻨﺪوز و اﻟﻠﯿﻨﻜﺲ ‪ ،‬ﻓﮫﻲ ﻻ ﺗﻌﺘﻤﺪ ﻋﻠﻲ ﻧﻈﺎم‬
‫اﻟﺘﺸﻐﯿﻞ ‪. Platform independent‬‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ھﻲ ‪ ، case sensitive language‬أي أن اﻟﻜﻠﻤﺔ اﻟﻤﻜﺘﻮﺑﻪ ﺑﺎﻟﺤﺮوف اﻟﻼﺗﯿﻨﯿﻪ اﻟﺼﻐﯿﺮه ﺗﺨﺘﻠﻒ ﻋﻦ ﻧﻔﺲ‬
‫اﻟﻜﻠﻤﺔ ﻣﻜﺘﻮﺑﺔ ﺑﺎﻷﺣﺮف اﻟﻜﺒﯿﺮه‬
‫ﻣﺜﻼ‪:‬‬
‫‪ Naser‬ﻏﯿﺮ ‪ naser‬ﻏﯿﺮ ‪ ، naSer‬وھﻜﺬا ‪..‬‬

‫ﻳﻔﺘﺮض اﻟﻰ درﺟﺔ اﻹﻟﺰام أن ﻳﻨﺘﮫﻲ ﻛﻞ ﺳﻄﺮ ﺑﻔﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ‪:‬‬

‫;‪var x = 3‬‬

‫‪4‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻛﻤﺎ اﻟﮫﺘﻤﻞ ‪ HTML‬ﺗﺘﺠﺎھﻞ اﻟﻤﺴﺎﺣﺎت اﻟﺨﺎﻟﯿﺔ ‪ ،‬واﻟﺴﻄﻮر اﻟﺠﺪﻳﺪة ‪ ،‬ﻣﺜﻼ‪:‬‬

‫‪var x=4‬‬ ‫ﻫﻲ ﻧﻔﺴﻬﺎ‬ ‫‪var x = 4‬‬

‫ﻣﻊ ﻣﻼﺣﻈﺔ أﻧﻪ ﻻﺑﺪ ﻣﻦ ﺗﺮك ﻣﺴﺎﻓﺔ ﺧﺎﻟﯿﺔ ﻋﻠﻰ اﻷﻗﻞ ﺑﻌﺪ أي ﻣﺼﻄﻠﺢ ﻣﻦ ﻣﺼﻄﻠﺤﺎت اﻟﺠﺎﻓﺎ‬

‫ﻟﻤﺎذا أﺗﻌﻠﻢ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫أول ﻣﺎﻳﺨﻄﺮ ﻓﻲ ﺑﺎﻟﻲ إﺟﺎﺑﺔ ﻋﻠﻰ ھﺬا اﻟﺴﺆال ھﻮ ‪ :‬اﻟﻘﻮة ‪ ..‬اﻟﺤﺮﻳﻪ ‪ ..‬اﻹﺑﺪاع ‪ .‬ﻷﻧﻪ ﺑﻤﺠﺮد اﻟﻜﺘﺎﺑﻪ ﺑﺎل ‪ HTML‬ﻓﺄﻧﺖ‬
‫ﻣﻘﯿﺪ ﺑﺄن ﺗ ﻈﻞ ﺻﻔﺤﺘﻚ ﻛﻤﺎ ھﻲ ﺛﺎﺑﺘﻪ ﻻﺗﺘﻐﯿﺮ اﻻ ﺑﺘﻐﯿﯿﺮ اﻟﻜﻮد ‪ ،‬وھﺬا ﻏﯿﺮ ﻣﻘﺒﻮل ﺑﺘﺎﺗﺎ ﻓﻲ ﻋﺎﻟﻢ اﻟﺘﻜﻨﻮﻟﻮﺟﯿﺎ اﻟﺠﺪﻳﺪه‬
‫‪.‬وﺑﻮاﺳﻄﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻳﻤﻜﻨﻚ ﺣﺘﻰ اﻟﺒﺎس ﺻﻔﺤﺘﻚ ﺣﻠﺔ ﺟﺪﻳﺪة ﻣﻦ أﻟﻮان اﻟﺨﻠﻔﯿﻪ ‪ ..‬وأﻧﻮاع اﻟﺨﻄﻮط ‪ ..‬وﺣﺘﻰ اﻟﺼﻮر‬
‫‪..‬ﺣﺴﺐ اﻟﺘﻮﻗﯿﺖ اﻟﯿﻮﻣﻲ ﻟﻠﺰاﺋﺮ وﺑﺪون أي ﺗﺪﺧﻞ ﻣﻨﻚ!‬

‫وﺷﻲء ﻣﮫﻢ أﻳﻀﺎ ‪ ..‬اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻌﺘﺒﺮ ﻣﻦ أﺑﺴﻂ اﻟﻠﻐﺎت ! اﻟﻜﻞ ﻳﺴﺘﻄﯿﻊ ﺗﻌﻠﻤﮫﺎ ‪ ..‬ﻧﻌﻢ اﻟﻜﻞ ‪. ..‬أﻻ ﺗﻮاﻓﻘﻨﻲ اﻟﺮأي ‪،‬‬
‫أن ﻛﺘﺎﺑﺔ اﻟﻜﻮد اﻟﺨﺎص ﺑﻚ ﻣﺒﺎﺷﺮة أﻓﻀﻞ أﻟﻒ ﻣﺮة ﻣﻦ اﻟﺒﺤﺚ ﻋﻨﻪ ﻓﻲ اﻟﺸﺒﻜﻪ ‪.‬‬

‫ورﺑﻤﺎ ﻻﺗﺠﺪ ﻣﺒﺘﻐﺎك ﺑﺴﮫﻮﻟﺔ ! أو ﻗﺪ ﻻﺗﺠﺪة إﻃﻼﻗﺎ ‪.‬‬

‫ﻣﺎھﻮ اﻟﻔﺮق ﺑﯿﻦ اﻟﺠﺎﻓﺎ ‪ ..‬واﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫اﻟﻔﺮق ﺑﯿﻨﮫﻤﺎ ﻛﺒﯿﺮ ‪ .‬ﻧﻌﻢ ﻓﺎﻟﺠﺎﻓﺎ أﻗﻮي ﺑﻜﺜﯿﺮ ﻣﻦ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪ ،‬وأﻛﺜﺮ ﺗﻌﻘﯿﺪا ‪ ،‬وﻟﻸﺳﻒ ‪ ،‬أﺻﻌﺐ ﻓﻲ اﻟﺘﺤﻜﻢ ‪ .‬وھﻲ‬
‫ﺗﺄﺗﻲ ﻓﻲ ﻧﻔﺲ ﻣﺴﺘﻮى ﻟﻐﺘﻲ اﻟﺴﻲ ‪ ،‬واﻟﺴﻲ ﺑﻠﺲ ﺑﻠﺲ ‪.‬‬

‫ﺑﺎﻹﺿﺎﻓﻪ اﻟﻰ أﻧﻚ ﺗﺤﺘﺎج اﻟﻰ ﺑﺮاﻣﺞ ﺧﺎﺻﺔ ﻟﻠﻜﺘﺎﺑﺔ ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ ‪ ،‬ﺑﯿﻨﻤﺎ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ أﺑﺴﻂ ﺑﻜﺜﯿﺮ ! ﻳﻤﻜﻨﻚ ﺑﻤﺠﺮد ﻓﺘﺢ‬
‫أي ﺑﺮﻧﺎﻣﺞ ﺗﺤﺮﻳﺮ ﻧﺼﻮص ﻣﺜﻞ اﻟﻨﻮﺗﺔ ‪ NOTEPAD‬ﻛﺘﺎﺑﺔ اﻟﺴﻜﺮﺑﺖ ﻛﺎﻣﻼ !!! ﺻﺪق أوﻻ ﺗﺼﺪق ‪ .‬ﻟﻦ ﺗﺤﺘﺎج اﻟﻰ ﺷﻲ آﺧﺮ‬
‫ﺳﻮى اﻟﻤﺘﺼﻔﺢ ﻟﺘﺮى اﻟﻨﺘﯿﺠﻪ ‪.‬‬

‫ﻣﺎ اﻟﻤﻘﺼﻮد ﺑﺸﻔﺮة اﻟﺒﺮﻧﺎﻣﺞ أو اﻟﺴﻮرس ﻛﻮد‬

‫اﻟﻜﻮد أو اﻟﺴﻮرس ﻛﻮد ‪ :‬ھﻮ ﻣﺠﻤ ﻮﻋﺔ اﻷواﻣﺮ اﻟﺘﻲ ﺗﻜﺘﺐ ﻣﺠﺘﻤﻌﺔ أو ﻣﺘﻔﺮﻗﺔ ﻟﯿﻌﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺼﻮرﺗﺔ اﻟﺮﺋﯿﺴﯿﻪ ‪ ،‬أي‬
‫اﻟﺒﻨﯿﺔ اﻟﺘﺤﺘﯿﺔ ﻟﻠﺒﺮﻧﺎﻣﺞ ‪ ،‬وﺗﻜﻮن داﺋﻤﺎ ﻣﻜﺘﻮﺑﻪ ﻛﺘﺎﺑﺔ وﻳﻤﻜﻦ ﻋﺮﺿﮫﺎ ﺑﺄي ﺑﺮﻧﺎﻣﺞ ﺗﺤﺮﻳﺮ ﻧﺼﻮص ﻋﺎدي ﻣﺜﻞ ال ‪NOTEPAD‬‬
‫‪.‬‬

‫‪5‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺘﺼﻔﺤﻲ اﻟﻨﺘﺴﻜﯿﺐ واﻹﻛﺴﺒﻠﻮرر‬

‫ھﻞ ﺑﺈﻣﻜﺎن اﻟﻜﻮد اﻟﺬي ﻛﺘﺒﺘﻪ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻌﻤﻞ ﻋﻠﻰ ﻣﺘﺼﻔﺤﻲ اﻟﻨﺘﺴﻜﯿﺐ واﻹﻛﺴﺒﻠﻮرر ﺑﺪون أﻳﺔ ﻣﺸﺎﻛﻞ ؟‬

‫ﻟﻸﺳﻒ ‪ ،‬اﻹﺟﺎﺑﺔ ﺑﻼ !‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ أﺻﻼ ﻣﺼﻤﻢ ﻣﻦ ﻗﺒﻞ ﺷﺮﻛﻪ ﻧﺘﺴﻜﯿﺐ ‪ .‬اذا ﻧﺘﺴﻜﯿﺐ أﻛﺜﺮ دﻋﻤﺎ ﻟﻪ ‪ .‬ﻣﻦ ﺟﮫﺔ أﺧﺮى ھﻨﺎك ﻓﺮوﻗﺎت‬
‫أﺳﺎﺳﯿﺔ ﻓﻲ ﺗﻌﺎﻣﻞ ھﺬﻳﻦ اﻟﻤﺘﺼﻔﺤﯿﻦ ﻣﻊ اﻟﺠﺎﻓﺎ ‪ ،‬وﺑﻌﻀﮫﺎ ﻳﻄﺎل ﺣﺘﻰ اﻷواﻣﺮ اﻷﺳﺎﺳﯿﻪ ‪.‬‬

‫ﺳﻨﺘﻄﺮق ﻻﺣﻘﺎ اﻟﻰ ﻛﯿﻔﯿﺔ ﺗﺠﺎوز ھﺬه اﻟﻌﻘﺒﺔ ‪ ،‬أﻣﺎ اﻵن ﻓﺪﻋﻨﻲ أﺧﺒﺮك ﺑﺄن أﻓﻀﻞ ﻃﺮﻳﻘﺔ ﻟﻠﺘﺄﻛﺪ ﻣﻦ ﻋﻤﻞ اﻟﺴﻜﺮﺑﺖ ھﻮ‬
‫ﺗﺠﺮﺑﺘﻪ ﻋﻠﻰ ﻛﻼ اﻟﻤﺘﺼﻔﺤﯿﻦ ‪ .‬ﻃﺒﻌﺎ ﺳﺘﺪھﺸﻚ ﻛﺜﺮة اﻟﻤﻮاﻗﻊ اﻟﺘﻲ ﻓﺸﻠﺖ ﻓﻲ اﻟﻮﺻﻮل ﺑﺼﻔﺤﺎﺗﮫﺎ اﻟﻰ أﻓﻀﻞ ﺷﻜﻞ‬
‫ودﻋﻢ ﻟﻜﻼ اﻟﻤﺘﺼﻔﺤﯿﻦ ‪ ،‬وھﺬا ﻣﺎﻳﻔﺴﺮ اﻟﺴﻄﺮ اﻟﺬي ﻧﺮاه ﻛﺜﯿﺮا‪:‬‬

‫ﻷﻓﻀﻞ ﻋﺮض ‪ ،‬ﻳﻨﺼﺢ ﺑﺈﺳﺘﺨﺪام اﻟﻤﺘﺼﻔﺢ اﻟﻔﻼﻧﻲ ‪.‬‬

‫ﻃﺒﻌﺎ وﻷن اﻷﻏﻠﺒﯿﺔ ﺗﺴﺘﺨﺪم اﻹﻛﺴﺒﻠﻮرر ‪ ،‬ﻓﺴﯿﻜﻮن اﻟﺘﺮﻛﯿﺰ ﻋﻠﯿﺔ ﻓﻲ اﻟﺸﺮح واﻷﻣﺜﻠﻪ ‪ ،‬وﻟﻦ أﻧﺴﻰ اﻟﺘﻄﺮق اﻟﻰ ﻛﯿﻔﯿﺔ‬
‫ﻣﻌﺮﻓﺔ ﻧﻮع اﻟﻤﺘﺼﻔﺢ اﻟﺨﺎص ﺑﺎﻟﻤﺴﺘﺨﺪم ‪.‬‬

‫ﺑﺮﻧﺎﻣﺠﻚ اﻷول "‪"Hello World‬‬

‫ھﺬا اﻟﻤﺜﺎل اﻟﺸﮫﯿﺮ ﺑـ ‪ Hello World‬ﻳﻤﻜﻨﻨﺎ ﻣﻦ إﺳﺘﻌﺮاض أﺳﺎﺳﯿﺎت ﻛﺘﺎﺑﺔ ﻛﻮد ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>‪<TITLE>My First Script</TITLE‬‬
‫>‪</HEAD‬‬

‫>‪<BODY‬‬
‫>‪<H2> this is my First JavaScript Code </H2‬‬
‫>‪<HR‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;)"‪document.write("Hello World‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</BODY‬‬
‫>‪</HTML‬‬

‫‪6‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن ھﺬا ھﻮ اﻟﻨﺎﺗﺞ ﻋﻨﺪ ﻋﺮﺿﻪ ﻣﻦ ﺧﻼل اﻟﻤﺘﺼﻔﺢ أﻧﺘﺮﻧﺖ أﻛﺴﺒﻠﻮرار‬

‫ھﺬا اﻟﻤﺜﺎل اﻟﺒﺴﯿﻂ ﺳﻮف ﻳﻜﻮن اﻟﺒﻮاﺑﺔ اﻷوﻟﻲ ﻟﺪﺧﻮل ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬
‫وﻣﻨﻪ ﺳﻮف ﻧﺘﻌﺮف ﻋﻠﻲ اﻟﺨﻄﻮات اﻟﻤﺘﺒﻌﺔ ﻟﻜﺘﺎﺑﺔ ﻛﻮد ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ وھﻲ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬
‫• ﻧﻼﺣﻆ أﻧﻨﺎ أدرﺟﻨﺎ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﺪاﺧﻞ أﻛﻮاد)أوﺳﻤﻪ( ھﺘﻤﻞ ‪ ، HTML‬ﻟﺬﻟﻚ ﻣﺒﺪﺋﯿﺎ ﻧﻼﺣﻆ أن‬
‫ﺣﺘﻲ ﻳﺘﻢ ﺗﻨﻔﯿﺬ أﻛﻮاد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺳﻮف ﻧﺤﺘﺎج إﻟﻲ إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻓﻲ ﻣﻠﻒ ذو إﻣﺘﺪاد‬
‫‪ htm‬أو ‪) html‬أو ﻣﻠﻔﺎت دﻳﻨﺎﻣﯿﻜﯿﺔ ﻣﺜﻞ ‪ ASP‬أو ‪(PHP‬‬
‫ﻟﺬﻟﻚ ﺳﻮف ﻧﺤﻔﻆ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻓﻲ ﻣﻠﻒ وﻟﯿﻜﻮن ‪firstJs.htm‬‬
‫• ﺛﺎﻧﯿﺎ رﺑﻤﺎ ﻳﺘﺒﺎدر إﻟﻲ اﻟﺬھﻦ ﻛﯿﻒ ﻳﺘﻢ اﻟﻔﺼﻞ ﺑﯿﻦ ﻛﻮد اﻟﮫﺘﻤﻞ وﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻻﺣﻆ اﻟﻜﻮد‬
‫اﻟﺘﺎﻟﻲ‬

‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪//‬‬ ‫ﻫﻨﺎ ﯾﺘﻢ ﻛﺘﺎﺑﺔ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬
‫>‪</SCRIPT‬‬

‫ﺑﻜﻞ ﺳﮫﻮﻟﺔ ﺗﻮﻓﺮ ﻟﻨﺎ ﻟﻐﺔ اﻟﮫﺘﻤﻞ أﺣﺪ اﻷوﺳﻤﺔ )‪ (Tag‬وھﻮ >‪<script‬‬
‫ھﺬا اﻟﻮﺳﻢ ﻳﺤﺘﺎج ان ﻧﺤﺪد ﻟﻪ اﺳﻢ اﻟﻠﻐﺔ اﻟﻤﺴﺘﺨﺪﻣﺔ ﻟﻜﺘﺎﺑﺔ اﻟﺴﻜﺮﺑﺖ‬
‫وﻳﺘﻢ ھﺬا ﻣﻦ ﺧﻼل إﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪ Language‬ﺑﺎن ﻧﺤﺪد ﻟﻪ اﻟﻘﯿﻤﺔ ‪JavaScript‬‬
‫ﻣﻊ ﻣﻼﺣﻈﺔ أﻧﮫﺎ ھﻲ اﻟﻘﯿﻤﺔ اﻷﻓﺘﺮاﺿﯿﺔ ﻟﺬﻟﻚ ﻋﺎدة ﻻ ﻧﺤﺘﺎج إﻟﻲ ﺗﺤﺪﻳﺪ ﻟﻐﺔ اﻷﺳﻜﺮﺑﺖ إﻟﻲ ﺟﺎﻓﺎ‬
‫ﺳﻜﺮﺑﺖ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪7‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫>‪<SCRIPT‬‬
‫‪//‬‬ ‫ﻛﻤﺎ ﺗﺮي ﻻ ﻧﺤﺘﺎج ﻟﺘﺤﺪﯾﺪ ﻟﻐﺔ اﻷﺳﻜﺮﺑﺖ‬
‫‪//‬‬ ‫ﻫﻨ ﺎ ﯾﺘﻢ ﻛﺘﺎﺑﺔ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬
‫>‪</SCRIPT‬‬

‫وﻳﺘﻢ وﺿﻊ اﻟﻜﻮد اﻟﺨﺎص ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﯿﻦ اﻟﻮﺳﻤﯿﻦ >‪ <Script‬و >‪ </Script‬ﻛﻤﺎ ﻳﻠﻲ‬

‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;)"‪document.write("Hello World‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬

‫أذا ﻛﻞ ﻣﺎ ﻧﺤﺘﺎﺟﻪ اﻷن ﻣﻌﺮﻓﺔ ﻛﯿﻒ ﻳﺘﻢ ﻛﺘﺎﺑﺔ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻧﻌﻢ ھﺬا ﺻﺤﯿﺢ وﻟﻜﻦ ﺗﻤﮫﻞ ﻗﻠﯿﻞ‬ ‫•‬
‫وﻓﻜﺮ ﻣﻌﻲ ﻣﺎذا ﻳﺤﺪث ﻟﻮ ﻛﺎن اﻟﻤﺘﺼﻔﺢ اﻟﻤﺴﺘﺨﺪم ﻟﻔﺘﺢ اﻟﻤﻠﻒ ﻻ ﻳﺪﻋﻢ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ؟‬
‫أﻋﺘﻘﺪ أﻧﻚ ﺳﻮف ﺗﻘﻮل ﺑﻜﻞ ﺑﺴﺎﻃﺔ أن اﻟﻜﻮد اﻟﻤﻜﺘﻮب ﺑﮫﺬه اﻟﻠﻐﺔ ﻟﻦ ﻳﻌﻤﻞ وھﺬا اﻟﻘﻮل ﺻﺤﯿﺢ‬
‫ﻟﻜﻦ ﺳﻮف ﻳﻨﺘﻈﺮك ﻣﺎ ھﻮ أﺳﻮء ﻣﻦ ھﺬا أﻻ وھﻮ ﻇﮫﻮر ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﺪاﺧﻞ ﻣﺤﺘﻮﻳﺎت اﻟﺼﻔﺤﺔ‬
‫ﻛﻤﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫‪ <!--‬ﻛﻤﺎ ﻳﻠﻲ‬ ‫ﻟﻜﻦ ﻻ ﺗﺤﺰن ﻳﻤﻜﻨﻚ إﺧﻔﺎء ﻇﮫﻮر ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﻮﺿﻊ اﻟﻜﻮد ﺑﯿﻦ >‪//--‬‬

‫‪<!--‬‬
‫;)"‪document.write("Hello World‬‬
‫>‪//--‬‬

‫‪8‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻷن ﺣﺎن اﻟﻮﻗﺖ ﻟﻤﻌﺮﻓﺔ أول أﻣﺮ ﻓﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ وھﻮ‬ ‫•‬

‫;)"‪document.write("Hello World‬‬

‫‪ :document.write‬ﻳﻤﻜﻨﻨﺎ ھﺬا اﻷﻣﺮ ﻣﻦ ﻛﺘﺎﺑﺔ ﻧﺺ ﻓﻲ اﻟﻤﺘﺼﻔﺢ وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻟﻨﺺ‬
‫‪ Hello World‬ﻣﻊ ﻣﻼﺣﻈﺔ وﺿﻊ اﻟﻨﺺ اﻟﻤﺮاد ﻛﺘﺎﺑﺘﺔ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)"‪document.write("Hello World‬‬

‫ﻳﺠﺐ ﻣﻼﺣﻈﺔ اﻟﺘﺎﻟﻲ‪:‬‬

‫ان ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻟﻐﺔ ﺣﺴﺎﺳﺔ ﻟﺤﺎﻟﺔ اﻟﺤﺮوف) اﻟﺤ ﺮوف اﻟﺼﻐﯿﺮة واﻟﻜﺒﯿﺮة ( ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‬
‫‪ document.write‬ﻻ ﺗﻜﺎﻓﻲء ‪ document.Write‬وﻟﻮ اﺳﺘﺨﺪﻣﺖ ﺑﮫﺬا اﻟﺸﻜﻞ ﺳﻮف ﺗﺆدي ﻟﺤﺪوث ﺧﻄﺄ‬
‫وﻟﻦ ﻳﺘﻢ ﻋﺮض اﻟﻨﺺ ‪Hello World‬‬

‫‪9‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻧﻲ‬
‫ﺃﺳﺎﺳﻴﺎﺕ ﻟﻐﺔ ﺍﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻓﻲ ﺻﻔﺤﺔ ھﺘﻤﻞ‬ ‫•‬

‫إدراج داﺧﻠﻲ‬ ‫‪o‬‬
‫إدراج ﺧﺎرﺟﻲ‬ ‫‪o‬‬

‫اﻟﺘﻌﻠﯿﻘﺎت ‪Comments‬‬ ‫•‬

‫ﺗﻌﻠﯿﻖ ﻟﺴﻄﺮ واﺣﺪ‬ ‫‪o‬‬
‫ﺗﻌﻠﯿﻖ ﻟﺴﻄﺮ أو ﻷﻛﺜﺮ ﻣﻦ ﺳﻄﺮ‬ ‫‪o‬‬

‫ﻃﺮق إدﺧﺎل و إﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬ ‫•‬

‫ﻃﺮق إﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬ ‫‪o‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪alert‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪write‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪writeln‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪print‬‬
‫ﻃﺮق إدﺧﺎل اﻟﺒﯿﺎﻧﺎت‬ ‫‪o‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪confirm‬‬
‫§ اﻟﻄﺮﻳﻘﺔ ‪prompt‬‬

‫‪10‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻓﻲ ﺻﻔﺤﺔ ھﺘﻤﻞ‬

‫ﻛﻤﺎ رأﻳﻨﺎ ﺳﺎﺑﻘﺎ ﻓﻲ ﻣﺜﺎل ‪ Hello World‬أن ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻏﺎﻟﺒﺎ ﻣﺎ ﻳﺘﻢ إدراﺟﻪ ﺑﯿﻦ ﻛﻮد اﻟﮫﺘﻤﻞ‬
‫وﻳﺘﻢ ھﺬا اﻹدراج ﻋﻦ ﻃﺮﻳﻖ ‪:‬‬
‫‪ .١‬إدراج داﺧﻠﻲ‬
‫‪ .٢‬إدراج ﺧﺎرﺟﻲ‬

‫إدراج داﺧﻠﻲ ‪:‬‬

‫ﻓﯿﻪ ﻳﺘﻢ ﻛﺘﺎﺑﺔ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‪:‬‬
‫أ ‪ -‬إﻣﺎ ﺑﯿﻦ اﻟﻮﺳﻢ >‪ <Script‬وﻳﻤﻜﻨﻚ وﺿﻊ ھﺬا اﻟﻮﺳﻢ ﺑﯿﻦ اﻟﻮﺳﻢ >‪ <Head‬أو اﻟﻮﺳﻢ >‪ <Body‬أو ﻛﻼھﻤﺎ‬
‫ﻛﻤﺎ ﻳﻠﻲ‬

‫وﺿﻊ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﯿﻦ وﺳﻢ >‪<Head‬‬

‫>‪<HTML‬‬
‫>‪<Head‬‬
‫>‪<script‬‬
‫‪<!--‬‬
‫;)"‪document.write("hello world‬‬
‫>‪//--‬‬
‫>‪</script‬‬
‫>‪</Head‬‬

‫>‪<Body></Body‬‬
‫>‪</HTML‬‬

‫وﺿﻊ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﯿﻦ وﺳﻢ >‪<Body‬‬

‫>‪<HTML‬‬
‫>‪<Head></Head‬‬

‫>‪<Body‬‬
‫>‪<script‬‬
‫‪<!--‬‬
‫;)"‪document.write("hello world‬‬
‫>‪//--‬‬
‫>‪</script‬‬
‫>‪</Body‬‬
‫>‪</HTML‬‬

‫ﻟﻜﻦ رﺑﻤﺎ ﻳﺘﺒﺎدر ﻟﻚ اﻟﺴﺆال اﻟﺘﺎﻟﻲ ‪:‬‬

‫ھﻞ ھﻨﺎك ﻓﺮق ﺑﯿﻦ إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﯿﻦ اﻟﻮﺳﻢ >‪ <Head‬واﻟﻮﺳﻢ >‪ <Body‬؟‬
‫اﻹﺟﺎﺑﺔ ‪ :‬ﺑﺎﻟﻄﺒﻊ ﻧﻌﻢ وﻟﻜﻦ ھﺬا اﻟﻔﺮق ﻳﻨﺤﺼﺮ ﻓﻘﻂ ﻓﻲ ﺗﺴﻠﺴﻞ ﺗﻨﻔﯿﺬ اﻟﻜﻮد أي أن ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﻨﺪرج ﺑﯿﻦ‬
‫اﻟﻮﺳﻤﯿﻦ >‪ <Head‬ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﯿﺬه أوﻻ ) ﺣﺘﻲ ﻗﺒﻞ ﺗﺤﻤﯿﻞ ﻋﻨﺎﺻﺮ اﻟﺼﻔﺤﺔ(‬
‫ﺛﻢ ﻳﺘﻢ ﺗﻨﻔﯿﺬ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﻨﺪرج ﺑﯿﻦ اﻟﻮﺳﻤﯿﻦ >‪<Body‬‬
‫‪11‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

<HTML>
<HEAD>
<TITLE> ‫اﻟﻔﺮق ﺑﯿﻦ وﺿﻊ اﻟﻜﻮد‬ </TITLE>
<SCRIPT LANGUAGE="JavaScript">
<!--
document.write(" ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ اﻟﻮﺳﻢ‬ Head");
document.write("<br>");
//-->
</SCRIPT>
</HEAD>

<BODY>
<SCRIPT LANGUAGE="JavaScript">
<!--
document.write(" ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ وﺳﻢ‬ Body");
//-->
</SCRIPT>
</BODY>
</HTML>

<Head> ‫ﻛﻤﺎ ﺗﺮي ﺗﻢ وﺿﻊ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﺑﯿﻦ اﻟﻮﺳﻢ‬

‫وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﯿﺬه أوﻻ‬
<SCRIPT LANGUAGE="JavaScript">
<!--
document.write(" ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ اﻟﻮﺳﻢ‬ Head");
document.write("<br>");
//-->
</SCRIPT>

<Body> ‫ﺛﻢ وﺿﻊ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﺑﯿﻦ اﻟﻮﺳﻢ‬

‫وﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﯿﺬه ﺑﻌﺪ اﻷﻧﺘﮫﺎء ﻣﻦ ﺗﻨﻔﯿﺬ اﻟﻜﻮد اﻟﺴﺎﺑﻖ‬
<SCRIPT LANGUAGE="JavaScript">
<!--
document.write(" ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ وﺳﻢ‬ Body");
//-->
</SCRIPT>

12
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ب ‪ -‬أو ﻳﺘﻢ وﺿﻊ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺑﺪاﺧﻞ اي وﺳﻢ ھﺘﻤﻞ‬

‫ﻛﻤﺎ ﻳﻠﻲ‬
‫ﺳﻜﺮﺑﺖ"=‪<TagName event‬‬ ‫>‪"></TagName‬ﯾﺘﻢ ﻫﻨﺎ إدراج ﻛﻮد اﻟﺠﺎﻓﺎ‬

‫ﻳﺘﻢ إﺳﺘﺒﺪال ‪ TagName‬ﺑـﺎﺳﻢ اﻟﻮﺳﻢ اﻟﻤﺮاد وﻟﯿﻜﻦ ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ‪Span‬‬
‫وﻳﺘﻢ إﺳﺘﺒﺪال ‪ event‬ﺑـﺎﺳﻢ اﻟﺤﺪث اﻟﻤﻄﻠﻮب وﻟﯿﻜﻦ ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ‪onclick‬‬
‫ﺛﻢ ﻳﺘﻢ وﺿﻊ اﻟﻜﻮد داﺧﻞ ھﺬا اﻟﺤﺪث‬

‫وھﺬا اﻟﻨﻮع ﻣﻦ إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺳﻮف ﻧﺘﻨﺎوﻟﻪ ﻓﻲ اﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻣﻦ اﻟﻜﺘﺎب ﺑﺸﻜﻞ ﻣﻔﺼﻞ‬
‫وﻟﻜﻦ دﻋﻨﺎ ﻧﺮي ﻣﺜﺎل ﺳﺮﻳﻊ ﻳﻮﺿﺢ اﻟﻄﺮﻳﻘﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>‪<TITLE‬‬ ‫إدراج اﻟﻜﻮد داﺧﻞ اﻷوﺳﻤﺔ‬ ‫>‪</TITLE‬‬
‫>‪</HEAD‬‬

‫>‪<Body‬‬
‫ﺑﺎﻟﺪاﺧﻞ'(‪<Span onclick="document.write‬‬ ‫ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻲ ﻫﺬا اﻟﻨﺺ >")'ﻧﺤﻦ اﻷن‬ ‫>‪</Span‬‬
‫>‪</Body‬‬
‫>‪</HTML‬‬

‫ﺗﻢ إﺳﺘﺨﺪام اﻟﺤﺪث ‪) onclick‬اي ﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ ﻣﺤﺘﻮﻳﺎت اﻟﻮﺳﻢ اﻟﻤﺨﺘﺎر وھﻮ ھﻨﺎ ‪ (Span‬ﻛﻤﺎ ﻳﻠﻲ‬

‫ﺑﺎﻟﺪاﺧﻞ'(‪<Span onclick="document.write‬‬ ‫ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻲ ﻫﺬا اﻟﻨﺺ >")'ﻧﺤﻦ اﻷن‬ ‫>‪</Span‬‬

‫ﻓﻌﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ ﻣﺤﺘﻮﻳﺎت اﻟﻮﺳﻢ >‪ <Span‬ﺳﻮف ﻳﺘﻢ ﺗﻨﻘﯿﺬ اﻟﻜﻮد اﻟﺘﺎﻟﻲ‬
‫‪13‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫)'ﻧﺤﻦ اﻷن ﺑﺎﻟﺪاﺧﻞ'(‪document.write‬‬

‫ﺑﺎﻟﺪاﺧﻞ'(‪<Span onclick="document.write‬‬ ‫ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻲ ﻫﺬا اﻟﻨﺺ >")'ﻧﺤﻦ اﻷن‬ ‫>‪</Span‬‬

‫إدراج ﺧﺎرﺟﻲ ‪:‬‬

‫ﻓﯿﻪ ﻳﺘﻢ إدراج ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻣﻦ ﻣﻠﻒ ﺧﺎرﺟﻲ ﻏﺎﻟﺒﺎ ﻣﺎ ﻳﻜﻮن ذو إﻣﺘﺪاد ‪js‬‬
‫ﻛﻤﺎ ﻳﻠﻲ‬

‫>‪<SCRIPT LANGUAGE="JavaScript" src="fileName.js"></SCRIPT‬‬

‫وﻳﺘﻢ ﻛﺘﺎﺑﺔ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻓﻲ اﻟﻤﻠﻒ ذو اﻹﻣﺘﺪاد ‪js‬‬

‫ﻣﺜﺎل ﺗﻮﺿﯿﺤﻲ ‪ :‬ﻳﺘﻜﻮن ﻣﻦ ﻣﻠﻔﯿﻦ أﺣﺪھﻤﺎ‬

‫‪ ExternalEmbed.htm‬ﻳﺪرج ﺑﻪ اﻟﻤﻠﻒ ‪ outerScript.js‬اﻟﺬي ﻳﺤﺘﻮي ﻋﻠﻲ ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫‪ExternalEmbed.htm‬‬
‫>‪<HTML‬‬
‫>‪<Head‬‬
‫>‪<SCRIPT LANGUAGE="JavaScript" src="outerScript.js"></SCRIPT‬‬
‫>‪</Head‬‬

‫>‪<Body‬‬
‫إدراج ﺧﺎرﺟﻲ‬
‫>‪</Body‬‬
‫>‪</HTML‬‬

‫‪outerScript.js‬‬
‫اﻟﻤﺪرج"(‪document.write‬‬ ‫;)"ﻫﺬا ﻧﺺ ﺧﺎرﺟﻲ ﻣﻦ اﻟﻤﻠﻒ‬
‫;)">‪document.write("<br‬‬

‫‪14‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﺘﻌﻠﯿﻘﺎت )‪(Comments‬‬

‫ﺗﺨﯿﻞ ﻣﻌﻲ أﻧﻚ ﻗﻤﺖ ﺑﻜﺘﺎﺑﺔ ﻛﻮد ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻣﻌﻘﺪ وﻃﻮﻳﻞ )ﻣﺜﻼ ﺣﻮاﻟﻲ ‪ ٢٠٠٠‬ﺳﻄﺮ( ﻓﻲ ﻣﺜﻞ ھﺬه اﻟﺤﺎﻻت ﺳﻮف‬
‫ﺗﻮا ﺟﻪ اﻟﺘﺎﻟﻲ ‪:‬‬
‫• ﺻﻌﻮﺑﺔ ﻗﺮاءة اﻟﻜﻮد‬
‫• ﺻﻌﻮﺑﺔ ﺗﺼﺤﯿﺢ اﻷﺧﻄﺎء ‪Debug‬‬

‫إذا ﻣﺎ اﻟﺤﻞ ‪:‬‬

‫ﻣﻦ اﻟﺨﻄﻮات اﻟﻤﺘﺒﻌﺔ ﻓﻲ ﺗﻘﻠﯿﺺ ھﺬة اﻟﻤﺸﻜﻠﺔ ﻋﻤﻞ ﻣﻼﺣﻈﺎت أو ﺗﻌﻠﯿﻘﺎت ‪ Comments‬ﻟﻜﻞ ﺟﺰء ﻣﻦ اﻟﻜﻮد‬
‫وﻛﻤﺎ ﺳﻨﺮي ﻳﻮﺟﺪ ﻧﻮﻋﯿﻦ ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت ‪:‬‬
‫• ﺗﻌﻠﯿﻖ ﻟﺴﻄﺮ واﺣﺪ )‪(//‬‬
‫ﺑﺈﺳﺘﺨﺪام اﻟﻌﻼﻣﺘﯿﻦ اﻟﺘﺎﻟﯿﺘﯿﻦ ‪ //‬ﺛﻢ ﻳﻠﯿﮫﻢ ﺗﻌﻠﯿﻘﻚ اﻟﺨﺎص ﺑﻚ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫‪//‬‬ ‫إﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺑﻜﻢ"(‪document.write‬‬ ‫;)"ﻣﺮﺣﺒﺎ‬
‫;)">‪document.write("<p‬‬ ‫‪//‬‬ ‫ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﺗﻌﻠﯿﻖ ﻟﺴﻄﺮ أو أﻛﺜﺮ ﻣﻦ ﺳﻄﺮ )‪(/* */‬‬ ‫•‬

‫ﺑﺈﺳﺘﺨﺪام اﻟﻌﻼﻣﺘﯿﻦ اﻟﺘﺎﻟﯿﺘﯿﻦ *‪ /‬ﺛﻢ ﻳﻠﯿﮫﻢ ﺗﻌﻠﯿﻘﻚ اﻟﺨﺎص ﺑﻚ رﺑﻤﺎ ﻳﻜﻮن ﻣﻜﻮن ﻣﻦ ﺳﻄﺮ أو أﻛﺜﺮ ﺛﻢ ﻧﻀﻊ ﻣﺮة‬
‫اﺧﺮة اﻟﻌﻼﻣﺘﯿﻦ ‪ */‬ﻹﻧﮫﺎء اﻟﺘﻌﻠﯿﻖ‬
‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫*‪/‬‬
‫إﻇﻬﺎر رﺳ ﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺛﻢ‬
‫ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ‬
‫‪*/‬‬
‫ﺑﻜﻢ"(‪document.write‬‬ ‫;)"ﻣﺮﺣﺒﺎ‬
‫;)">‪document.write("<p‬‬ ‫*‪/‬‬ ‫ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ‬ ‫‪*/‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪15‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻳﻤﻜﻨﻚ إﺳﺘﺨﺪام اي ﻧﻮع ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت أو ﻛﻼھﻤﺎ ﻛﻤﺎ ﻳﻔﻀﻞ اﻟﻤﺒﺮﻣﺞ‪.‬‬

‫ﻛﻼ اﻟﻨﻮﻋﯿﻦ ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت ﻳﺘﻢ ﺗﺠﺎھﻠﻪ ﻣﻦ ﻗﺒﻞ ﻣﻔﺴﺮ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ )‪ (JavaScript Interpreter‬إي ﻻ ﻳﺘﻢ‬
‫ﺗﻨﻔﯿﺬه ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل رﺑﻤﺎ ﺗﻘﻮم ﺑﺎﻟﺘﺎﻟﻲ‬
‫ﺗﺤﻮﻳﻞ ﻛﻮد ﻣﻜﻮن ﻣﻦ ﺳﻄﺮ أو أﻛﺜﺮ إﻟﻲ ﺗﻌﻠﯿﻖ )ﺗﺴﺘﺨﺪم ھﺬة اﻟﻄﺮﻳﻘﺔ ﻓﻲ ﻋﻤﻠﯿﺔ ﺗﺼﺤﯿﺢ اﻷﺧﻄﺎء(‬
‫وﺑﺎﻟﺘﺎﻟﻲ ﻟﻦ ﻳﺘﻢ ﺗﻨﻔﯿﺬه ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫*‪/‬‬
‫إﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺛﻢ‬
‫ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ‬
‫‪*/‬‬
‫ﺑﻜﻢ"(‪document.write‬‬ ‫;)"ﻣﺮﺣﺒﺎ‬
‫;)">‪document.write("<p‬‬
‫اﻟﻠﻘﺎء"(‪// document.write‬‬ ‫;)" إﻟﻲ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻛﻤﺎ ﺗﺮي ﻟﻦ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫اﻟﻠﻘﺎء"(‪// document.write‬‬ ‫;)" إﻟﻲ‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫‪16‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﻼﺣﻈﺔ ﻫﺎﻣﺔ ‪:‬‬

‫ﻻ ﻳﻤﻜﻨﻚ ﻋﻤﻞ ﺗﺪاﺧﻞ )‪ (nesting‬ﻋﻨﺪ إﺳﺘﺨﺪاﻣﻚ ﻟﻠﻨﻮع اﻟﺜﺎﻧﻲ ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت ﺗﻌﻠﯿﻖ ﻟﺴﻄﺮ أو أﻛﺜﺮ ﻣﻦ ﺳﻄﺮ )‪(/* */‬‬
‫ﻹن ذﻟﻚ ﺳﻮف ﻳﺆدي إﻟﻲ إ ﺣﺪاث ﺧﻄﺎء ﻟﻐﻮي ‪Syntax Error‬‬
‫ﻻﺣﻆ ﻣﻌﻲ اﻷﺷﻜﺎل اﻟﺘﺎﻟﯿﺔ ﻣﻦ اﻷﺧﻄﺎء ‪:‬‬

‫>‪<HTML‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫*‪/‬‬
‫إﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺛﻢ‬
‫‪ */‬ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ *‪/‬‬
‫‪*/‬‬
‫ﺑﻜﻢ"(‪document.write‬‬ ‫;)"ﻣﺮﺣﺒﺎ‬
‫;)">‪document.write("<p‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫*‪/‬‬
‫إﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺛﻢ‬
‫‪ */‬ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ *‪/‬‬
‫‪*/‬‬

‫*‪/‬‬
‫إﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم‬
‫ﺛﻢ‬
‫ﻃﺒﺎﻋﺔ ﺳﻄﺮ ﻓﺎرغ *‪/‬‬
‫‪ */‬ﺗﺪاﺧﻞ ﺟﺪﯾﺪ *‪/‬‬
‫‪*/‬‬
‫‪*/‬‬

‫‪17‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻃﺮق إدﺧﺎل و إﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬

‫ﺗﻮﻓﺮ ﻟﻨﺎ اي ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﻃﺮق ﻹدﺧﺎل وإﺧﺮاج اﻟﺒﯿﺎﻧﺎت وھﻲ ﻣﻦ اﻟﻨﻘﺎط اﻟﮫﺎﻣﺔ اﻟﺘﻲ ﺗﻌﻄﻲ ﺑﺮﻧﺎﻣﺠﻚ ﺗﻔﺎﻋﻞ ﻣﻊ‬
‫اﻟﻤﺴﺘﺨﺪﻣﯿﻦ ﻟﺒﺮﻧﺎﻣﺠﻚ‬
‫وﺳﻮف ﻧﺘﻨﺎول ﻓﻲ ھﺬا اﻟﺠﺰء اﻟﻄﺮق اﻟﻤﺨﺘﻠﻔﺔ ﻹﺧﺮاج وإدﺧﺎل اﻟﺒﯿﺎﻧﺎت ‪.‬‬

‫أوﻻ ‪ :‬ﻃﺮق إﺧﺮاج اﻟﺒﯿﺎﻧﺎت‬

‫ﻋﻨﺪﻣﺎ ﻳﻘﺎل أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻮﻓﺮ ﻟﻨﺎ ﻃﺮق ﻹﺧﺮاج اﻟﺒﯿﺎﻧﺎت ﻧﻌﻨﻲ ﺑﺬﻟﻚ أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻮﻓﺮ ﻟﻚ ﺑﻌﺾ‬
‫اﻷواﻣﺮ اﻟﺨﺎﺻﺔ ﺑﮫﺎ اﻟﺘﻲ ﺗﻤﻜﻨﻚ ﻣﻦ إﻇﮫﺎر رﺳﺎﺋﻞ ﺗﻈﮫﺮ ﻣﻦ ﺧﻼل وﺣﺪات اﻹﺧﺮاج ﺑﺠﮫﺎز اﻟﻜﻤﺒﯿﻮﺗﺮ ) ﻣﺜﻞ اﻟﺸﺎﺷﺔ‬
‫واﻟﻄﺎﺑﻌﺔ ( وﺳﻮف ﻧﺘﻨﺎول ھﺬة اﻟﻄﺮق اﻟﻤﺨﺘﻠﻔﺔ ‪.‬‬

‫‪ - ١‬اﻟﻄﺮﯾﻘﺔ ‪: alert‬‬
‫ﺗﻘﻮم ﺑﺈﻇﮫﺎر رﺳﺎﻟﺔ إﻟﻲ اﻟﻤﺴﺘﺨﺪم ‪.‬‬ ‫•‬
‫ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪ ،window‬ﻛﻤﺎ ﺳﻨﺮي ﻻﺣﻘﺎ‬ ‫•‬
‫ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪاﻣﮫﺎ ‪:‬‬ ‫•‬

‫"(‪alert‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫أو‬
‫"(‪window.alert‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫أو ‪ window.alert‬ﻛﻼھﻤﺎ ﺳﻮف ﻳﺆدي إﻟﻲ ﻧﻔﺲ اﻟﻨﺘﯿﺠﺔ ﺛﻢ ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺮاد إﻇﻬﺎرﻫﺎ‬ ‫ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻷﻣﺮ ‪alert‬‬
‫ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ""‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺤﺬﯾﺮ ﻟﻠﻤﺴﺘﺨﺪم‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪alert </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫"(‪alert‬‬ ‫;)"ﻣﻦ ﻓﻀﻠﻚ ﯾﺠﺐ إدﺧﺎل ﺑﯿﺎﻧﺎت ﺻﺤﯿﺤﺔ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪18‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪ - ٢‬اﻟﻄﺮﯾﻘﺔ ‪: write‬‬
‫ﺗﻘﻮم ﺑﻜﻨﺎﺑﺔ ﻧﺺ ﻓﻲ اﻟﺼﻔﺤﺔ ﻟﻠﻤﺴﺘﺨﺪم ‪.‬‬ ‫•‬
‫ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪ ،document‬ﻛﻤﺎ ﺳﻨﺮي ﻻﺣﻘﺎ‬ ‫•‬
‫ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪاﻣﮫﺎ ‪:‬‬ ‫•‬

‫"(‪document.write‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫أﻳﻀﺎ ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺮاد ﻛﺘﺒﺎﺗﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ "" وﺗﻜﻮن ھﺬة اﻟﺮﺳﺎﻟﺔ إﻣﺎ ﻧﺺ ﺑﺴﯿﻂ ‪ plain text‬أو ﻧﺺ‬
‫ھﺘﻤﻞ ‪HTML text‬‬

‫ﻳﺠﺐ ﻣﻼﺣﻈﺔ أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻟﻐﺔ ﺣﺴﺎﺳﺔ ﻟﺤﺎﻟﺔ اﻟﺤﺮوف ﻟﺬﻟﻚ ﻳﻜﺘﺐ اﻷﻣﺮ ﻛﻤﺎ ﻳﻠﻲ ‪ write‬ﺟﻤﯿﻊ ﺣﺮوﻓﻪ‬
‫ﺻﻐﯿﺮة )‪(small letters‬‬

‫‪19‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﺑﺴﯿﻄﺔ ﻟﻠﻤﺴﺘﺨﺪم‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪write </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫;)"ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺄﻛﯿﺪ ﻟﻌﻤﻠﯿﺔ ﺣﺬف ﻟﻠﻤﺴﺘﺨﺪم‬

‫ﻓﻲ ھﺬا اﻟﺘﻤﺮﻳﻦ ﺳﻮف ﻧﺘﻌﻠﻢ ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪام ا ﻷﻣﺮ ‪document.write‬‬

‫• ﻹﻇﮫﺎر رﺳﺎﻟﺔ أﻛﺜﺮ ﺗﻌﻘﯿﺪ ﻣﻨﺼﻘﺔ ﺑﺈﺳﺘﺨﺪام ﺟﻤﻞ اﻟﮫﺘﻤﻞ ‪.‬‬
‫• ﻃﺮﻳﻘﺔ دﻣﺞ اﻟﻨﺼﻮص ‪.‬‬
‫• ﻃﺮﻳﻘﺔ ﺣﻞ اﻟﻤﺸﻜﻠﺔ اﻟﻨﺎﺗﺠﺔ ﻣﻦ ﺗﺪاﺧﻞ ﻋﻼﻣﺎت اﻟﺘﻨﺼﯿﺺ ‪.‬‬

‫‪20‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪write </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫اﻟﺤﺬف>‪document.write("<Font Color=red‬‬ ‫;)">‪ </Font‬ﻫﻞ أﻧﺖ ﻣﺘﺄﻛﺪ ﻣﻦ إﺗﻤﺎم ﻋﻤﻠﯿﺔ‬
‫;)">‪document.write ("<P‬‬
‫;)" >ﻣﻮاﻓﻖ=‪document.write("<Center>" + "<Input type=button value‬‬
‫ﻣﻮاﻓﻖ'=‪document.write("<Input type=button value‬‬ ‫;)">‪ '></Center‬ﻏﯿﺮ‬
‫;)">‪document.write("</P‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻛﻤﺎ ذﻛﺮﻧﺎ ﻓﻲ اﻟﻨﻔﺎط اﻟﻤﺴﺘﻔﺎدة ﻣﻦ ھﺬا اﻟﺘﻤﺮﻳﻦ ﺳﻨﻼﺣﻆ اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪ -‬ﻃﺮﯾﻘﺔ دﻣﺞ اﻟﻨﺼﻮص‪:‬‬

‫ﻳﺘﻢ دﻣﺞ اﻟﻨﺼﻮص ) واﻟﻨﺺ ھﻮ اﻟﺠﻤﻠﺔ اﻟﻤﺤﺪدة ﺑﻌﻠﻤﺘﯿﻦ ﺗﻨﺼﯿﺺ ( ﺑﺈﺳﺘﺨﺪام اﻟﺮﻣﺰ ‪ +‬اﻟﻤﺴﺘﺨﺪم ﻓﻲ ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ‬
‫اﻟﺮﻳﺎﺿﻲ ﻛﻤﺎ ﻳﻠﻲ‬
‫;)" >ﻣﻮاﻓﻖ=‪document.write("<Center>" + "<Input type=button value‬‬

‫‪21‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫‪ -‬ﻋﻼج ﺗﺪاﺧﻞ ﻋﻼﻣﺎت اﻟﺘﻨﺼﯿﺺ ‪:‬‬

‫ﻛﻤﺎ ذﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ أن اﻟﻨﺺ ھﻮ ﻋﺒﺎرات وﺟﻤﻞ ﻳﺘﻢ ﻛﺘﺎﺑﺘﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ""‬
‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻧﺮﻳﺪ ﻋﻤﻞ ﻧﺺ ﺑﻪ ﻋﺒﺎرة أﻧﺎ ﻣﻦ ﻣﺤﺒﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺳﻮف ﻧﻘﻮم ﺑﻮﺿﻌﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ‬
‫اﻟﺘﻨﺼﯿﺺ ﻛﻤﺎ ﻳﻠﻲ " أﻧﺎ ﻣﻦ ﻣﺤﺒﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ " وﺑﺬﻟﻚ ﻳﺴﺘﻄﯿﻊ ﻣﻔﺴﺮ اﻟﻠﻐﺔ ﺗﻤﯿﺰ أن ھﺬه اﻟﻜﻠﻤﺎت ﺗﺎﺑﻌﺔ‬
‫ﻟﻨﺺ واﺣﺪ ‪.‬‬
‫إذا إﻳﻦ اﻟﻤﺸﻜﻠﺔ وﻣﺘﻲ ﺗﻈﮫﺮ ﻧﻌﻢ أﻧﺖ ﻋﻠﻲ ﺣﻖ ﻻ ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ ھﻨﺎ إﻻ إذا ﺣﺪث اﻟﺘﺎﻟﻲ‬
‫ﺗﺨﯿﻞ ﻣﻌﻲ أن ﻧﺺ اﻟﺠﻤﻠﺔ ﻳﺤﺘﻮي ﻋﻼﻣﺔ ﺗﻨﺼﯿﺺ أو أﻛﺜﺮ‬
‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل أﻧﻚ ﺗﺮﻳﺪ ﻛﺘﺎﺑﺔ اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﯿﺔ ) ھﻞ ھﻨﺎك "ﻣﺸﻜﻠﺔ " ﻳﺎ رﺟﻞ ؟( ﻛﻤﺎ ﺗﺮي أﻧﻨﺎ اﻷن ﻓﻲ ﻣﺄزق ﻷﻧﻨﺎ‬
‫ﻟﻮ وﺿﻌﻨﺎ ھﺬة اﻟﺠﻤﻠﺔ ﺑﯿﻦ ﻋﻼﻣﺘﯿﯿﻦ ﺗﻨﺼﯿﺺ ﺳﻮف ﻳﺤﺪث ﺗﺪاﺧﻞ ﻓﻲ ﻋﻼﻣﺎت اﻟﺘﻨﺼﯿﺺ وﺳﻮف ﻳﺆدي ھﺬا إﻟﻲ إرﺗﺒﺎك‬
‫ﻟﻤﻔﺴﺮ اﻟﻠﻐﺔ ﻣﻤﺎ ﻳﻨﺘﺞ ﻋﻨﻪ ﺧﻄﺄ ﻟﻐﻮي ‪. syntax error‬‬
‫اﻷن ﻣﺎ اﻟﺤﻞ ؟‬
‫رﺑﻤﺎ ﻳﺘﺒﺎدر إﻟﻲ ذھﻨﻚ اﻟﮫﺮب ﻣﻦ اﻟﻤﺸﻜﻠﺔ وﺗﻘﻮل أﻧﺎ ﻟﺴﺖ ﻓﻲ ﺣﺎﺟﺔ ﻹﻇﮫﺎر ﻋﻼﻣﺎت اﻟﺘﻨﺼﯿﺺ ﻓﻲ اﻟﺠﻤﻠﺔ وﺳﻮف‬
‫أﺟﻌﻞ اﻟﺠﻤﻠﺔ ﺑﺪوﻧﮫﻤﺎ ﻛﻤﺎ ھﻮ ﺣﺎﻟﻨﺎ ﻧﺤﻦ اﻟﻌﺮب وﻟﻜﻦ داﺋﻤﺎ ﺗﺄﺗﻲ اﻟﺤﻠﻮل ﻟﺘﻔﺎدي اﻷﺧﻄﺎء وﺗﺠﻨﺒﮫﺎ وﻟﯿﺲ اﻟﮫﺮب‬
‫ﻣﻨﮫﺎ ‪ ،‬أﻋﺘﻘﺪ أﻧﻪ ﺗﺒﺎدر إﻟﯿﻚ اﻷن أن ھﺬه اﻟﻤﺸﻜﻠﺔ ﻟﮫﺎ ﺣﻞ اﺑﺸﺮك ﺑﻘﻮﻟﻲ ﻧﻌﻢ‬
‫ﺣﯿﺚ ﺗﻮﻓﺮ ﻟﻨﺎ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻋﻼﻣﺎت اﻟﮫﺮوب ‪. Escaping Characters‬‬

‫ﻋﻼﻣﺎت اﻟﻬﺮوب ‪: Escaping Characters‬‬

‫ﺗﻤﻜﻨﻚ ﻣﻦ ﺗﻀﻤﯿﻦ ﺑﻌﺾ اﻟﺤﺮوف اﻟﺘﻲ ﻳﺼﻌﺐ ﻛﺘﺎﺑﺘﮫﺎ ﻓﻲ ﻣﺤﺘﻮي اﻟﻨﺼﻮص وﻣﻨﮫﺎ اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﺗﻤﻜﻨﻚ ﻣﻦ إﺿﺎﻓﺔ ﻋﻼﻣﻪ اﻟﺘﻨﺼﯿﺺ اﻟﻔﺮدﯾﺔ ﺑﺪاﺧﻞ اﻟﻨﺺ‬ ‫'\‬

‫ﺗﻤﻜﻨﻚ ﻣﻦ إﺿﺎﻓﺔ ﻋﻼﻣﻪ اﻟﺘﻨﺼﯿﺺ ﺑﺪاﺧﻞ اﻟﻨﺺ‬ ‫"\‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ إدﺧﺎل ﺣﺮف ﺧﺎص ﻟﻌﻤﻞ ﻣﺎ ﯾﺴﻤﻲ ‪Carriage‬‬ ‫‪\r‬‬
‫‪ return‬اي ﺗﺮاﺟﻊ ﻣﻮﺷﺮ اﻟﻜﺘﺎﺑﻪ إﻟﻲ ﺑﺪاﯾﺔ اﻟﺴﻄﺮ ﻣﻤﺎ‬
‫ﯾﻨﺘﺞ ﻋﻨﻪ ﻓﻲ ﺑﻌﺾ اﻷﺣﯿﺎن ﻋﻤﻞ ﺳﻄﺮ ﺟﺪﯾﺪ‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ ﻋﻤﻞ ﺳﻄﺮ ﺟﺪﯾﺪ داﺧﻞ اﻟﻨﺺ‬ ‫‪\n‬‬
‫ﺗﻤﻜﻨﻚ ﻣﻦ إدﺧﺎل اﻟﺤﺮف ‪Tab‬‬ ‫‪\t‬‬

‫ﺑﻌﺪ اﻟﺘﻌﺮف اﻟﺴﺮﻳﻊ ﻟﻌﻼﻣﺎت اﻟﮫﺮوب ﻛﯿﻒ ﻳﻤﻜﻨﻨﺎ ﺣﻞ ﻣﺸﻜﻠﺔ ﻛﺘﺎﺑﺔ اﻟﻨﺺ اﻟﺴﺎﺑﻖ )ھﻞ ھﻨﺎك "ﻣﺸﻜﻠﺔ" ﻳﺎ رﺟﻞ ؟ (‬
‫ﺑﻜﻞ ﻳﺴﺮ ﻳﺘﻢ إﺳﺘﺒﺪال اي ﻋﻼﻣﺔ ﺗﻨﺼﯿﺺ )"( ﺑﻲ ﻋﻼﻣﺔ اﻟﮫﺮوب )"\( وﻳﻜﻮن اﻟﻨﺺ ﻛﺎﻟﺘﺎﻟﻲ‬
‫)ﻫﻞ ﻫﻨﺎك \"ﻣﺸﻜﻠﺔ\" ﯾﺎ رﺟﻞ ؟ (‬

‫‪22‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل ﺗﻄﺒﯿﻘﻲ ﻟﻜﺘﺎﺑﺔ اﻟﺮﺳﺎﻟﺔ اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫ﻧﺘﻤﻨﺎ ﻟﻚ ﯾﺎ ﻗﺎرﺋﻨﺎ "اﻟﻌﺰﯾﺰ" أن ﺗﻜﻮن ﻗﺪ‬
‫ﺗﻌﻠﻤﺖ ﻣﺎ ﺳﺒﻖ ﻣﻦ ﻗﻮل وان ﺗﺤﺮص ﻋﻠﻲ ﻣﺎ ﻫﻮ أت‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫‪write‬‬ ‫و‬ ‫>‪alert </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻗﺪ"(‪alert‬‬ ‫‪ " + "\r\n" +‬ﻧﺘﻤﻨﺎ ﻟﻚ ﯾﺎ ﻗﺎرﺋﻨﺎ \" اﻟﻌﺰﯾﺰ \" أن ﺗﻜﻮن‬
‫;)" ﺗﻌﻠﻤﺖ ﻣﺎ ﺳﺒﻖ ﻣﻦ ﻗﻮل وان ﺗﺤﺮص ﻋﻠﻲ ﻣﺎ ﻫﻮ أت "‬

‫ﻗﺪ"(‪document.write‬‬ ‫">‪ " + "<br‬ﻧﺘﻤﻨﺎ ﻟﻚ ﯾﺎ ﻗﺎرﺋﻨﺎ \"اﻟﻌﺰﯾﺰ \" أن ﺗﻜﻮن‬ ‫‪+‬‬

‫أت "‬ ‫;)" ﺗﻌﻠﻤﺖ ﻣﺎ ﺳﺒﻖ ﻣﻦ ﻗﻮل وان ﺗﺤﺮص ﻋﻠﻲ ﻣﺎ ﻫﻮ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‬

‫‪23‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﻼﺣﻈﺔ ‪:‬‬
‫ﻟﻜﺘﺎﺑﺔ ﺳﻄﺮ ﺟﺪﯾﺪ‬
‫ﺑﺎﻟﻄﺮﯾﻘﺔ ‪ : alert‬ﻗﻤﻨﺎ ﺑﺈﺳﺘﺨﺪام ﻋﻼﻣﺎت اﻟﻬﺮوب ‪ \r\n‬ﻟﻌﻤﻞ ﺳﻄﺮ ﺟﺪﯾﺪ‬
‫ﺑﺎﻟﻄﺮﯾﻘﺔ ‪ :write‬ﻗﻤﻨﺎ ﺑﺈﺳﺘﺨﺪام اﻟﻮﺳﻢ >‪ <br‬ﺣﺘﻲ ﻧﻨﻤﻜﻦ ﻣﻦ ﻛﺘﺎﺑﺔ ﺳﻄﺮ ﺟﺪﯾﺪ‬

‫‪writeln‬‬
‫• ﺗﻘﻮم ﺑﻜﻨﺎﺑﺔ ﻧﺺ ﻓﻲ اﻟﺼﻔﺤﺔ ﻟﻠﻤﺴﺘﺨﺪم ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أﻧﻬﺎ ﺗﺤﺪث ﺳﻄﺮ ﺟﺪﯾﺪ ﻗﺒﻞ ﻛﺘﺎﺑﺔ اﻟﻨﺺ‪.‬‬
‫ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪ ،document‬ﻛﻤﺎ ﺳﻨﺮي ﻻﺣﻘﺎ‬ ‫•‬
‫ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪاﻣﮫﺎ ‪:‬‬ ‫•‬

‫"(‪document.writeln‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫أﻳﻀﺎ ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺮاد ﻛﺘﺎﺑﺘﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ "" وﺗﻜﻮن ھﺬة اﻟﺮﺳﺎﻟﺔ إﻣﺎ ﻧﺺ ﺑﺴﯿﻂ ‪ plain text‬أو ﻧﺺ‬
‫ھﺘﻤﻞ ‪HTML text‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪ writeln </Title‬اﻟﻄﺮﯾﻘﺔ >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫;)" ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬
‫ﺟﺪﯾﺪ"(‪document.writeln‬‬ ‫;)"ﻧﺺ ﺟﺪﯾﺪ ﻛﻤﺎ ﺗﺮي وﻟﻜﻦ ﻟﻸﺳﻒ ﻟﯿﺲ ﻓﻲ ﺳﻄﺮ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪24‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻛﻤﺎ ﺗﺮي ﻟﻢ ﻳﺘﻢ ﻋﻤﻞ ﺳﻄﺮ ﺟﺪﻳﺪ أﻗﻮل ﻟﻚ ﻧﻌﻢ أﻧﻨﺎ ﻻ ﻧﺮي ﺳﻄﺮ ﺟﺪﻳﺪ وﻟﻜﻦ ھﺬا ﻻ ﻳﻌﻨﻲ ﻋﺪم وﺟﻮدة ﺣﯿﺚ أﻧﻪ ﺗﻢ‬
‫ﻋﻤﻞ ﺗﻐﺬﻳﻪ ﻟﺴﻄﺮ ﺟﺪﻳﺪ ﺑﺎﺳﺘﺨﺪام ‪ \n‬وﻛﻤﺎ ﻧﻌﻠﻢ أن ﻟﻐﺔ اﻟﮫﺘﻤﻞ ﺗﺘﺠﺎھﻞ اﻟﻤﺴﺎﻓﺎت اﻟﺰاﺋﺪة واﻟﺴﻄﻮر اﻟﺠﺪﻳﺪة ‪.‬‬

‫‪ - ٣‬اﻟﻄﺮﯾﻘﺔ ‪: print‬‬
‫• ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﺼﻔﺤﺔ ‪.‬‬
‫• ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪. window‬‬
‫• ﻃﺮﯾﻘﺔ إﺳﺘﺨﺪاﻣﻬﺎ ‪:‬‬

‫;)(‪window.print‬‬

‫أﻳﻀﺎ ﻳﻮﺟﺪ ﺣﺪﺛﺎن ‪ onBeforeprint‬و ‪ onAfterprint‬ﺳﻮف ﻧﺘﺤﺪث ﻋﻨﮫﻤﺎ ﻓﯿﻤﺎ ﺑﻌﺪ‪.‬‬

‫‪25‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺛﺎﻧﯿﺎ ‪ :‬ﻃﺮق إدﺧﺎل اﻟﺒﯿﺎﻧﺎت‬

‫‪ - ١‬اﻟﻄﺮﯾﻘﺔ ‪: confirm‬‬

‫• ﺗﻘﻮم ﺑﺈﻇﻬﺎر رﺳﺎﻟﺔ ﻣﺜﻞ اﻟﻄﺮﯾﻘﺔ ‪ alert‬اﻟﺴﺎﺑﻘﺔ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أﻧﻬﺎ ﺗﻘﻮم ﺑﺈرﺟﺎع أﺣﺪي اﻟﻘﯿﻤﺘﯿﻦ‬
‫‪ true‬أو ‪.false‬‬
‫• ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪. window‬‬
‫• ﻃﺮﯾﻘﺔ إﺳﺘﺨﺪاﻣﻬﺎ ‪:‬‬

‫"(‪confirm‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫أو‬
‫"(‪window.confirm‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫;)"‬

‫ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻷﻣﺮ ‪ confirm‬أو ‪ window.confirm‬ﻛﻼھﻤﺎ ﺳﻮف ﻳﺆدي إﻟﻲ ﻧﻔﺲ اﻟﻨﺘﯿﺠﺔ ﺛﻢ ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺮاد‬
‫إﻇﮫﺎرھﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ""‬
‫ﺛﻢ ﻳﺘﻢ إﺳﺘﻘﺒﺎل اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻹﺧﺘﯿﺎر ﻓﻲ ﻣﺘﻐﯿﺮ ) ﺳﻮف ﻳﺘﻢ ﺷﺮح اﻟﻤﺘﻐﯿﺮات ﻓﯿﻤﺎ ﺑﻌﺪ (‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺄﻛﯿﺪ ﺣﺬف إﺷﺘﺮاك اﺣﺪي اﻟﻌﻤﻼء‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪confirm </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫"(‪confirm‬‬ ‫;)"ﻣﻦ ﻓﻀﻠﻚ ﻫﻞ أﻧﺖ ﻣﺘﺄﻛﺪ ﻣﻦ إﺗﻤﺎم ﻋﻤﻠﯿﺔ ﺣﺬف ﻫﺬا اﻟﻌﻤﯿﻞ ؟‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪26‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻛﻤﺎ ﺗﺮي ﻇﮫﻮر اﻟﺮﺳﺎﻟﺔ وﻟﻜﻦ ﺑﻌﺪ اﻟﻀﻐﻂ ﻋﻠﻲ إ ﺣﺪي اﻟﺰرارﻳﻦ ‪ cancel‬أو ‪ ok‬ﻟﻢ ﻧﺘﻌﺮف أﻳﮫﻤﺎ ﺗﻢ اﻟﻀﻐﻂ ﻋﻠﯿﻪ ‪ ،‬وﺣﺘﻲ‬
‫ﻧﺘﻌﺮ ف ﻋﻠﻲ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻹﺧﺘﯿﺎر ﻧﺤﺘﺎج إﻟﻲ ‪:‬‬
‫‪ -‬ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻓﻲ ﻣﺘﻐﯿﺮ ﺛﻢ ﻧﺤﺪد ﻗﯿﻤﺔ ھﺬا اﻟﻤﺘﻐﯿﺮ ﻓﺈذا ﻛﺎﻧﺖ ﻗﯿﻤﺘﻪ ‪ true‬ﻓﮫﺬا ﻳﻌﻨﻲ أن اﻟﻤﺴﺘﺨﺪم ﻗﺪ‬
‫ﺿﻐﻂ اﻟﺰر ‪ ، ok‬وإذا ﻛﺎﻧﺖ ﻗﯿﻤﺘﻪ ‪ false‬ﻓﮫﺬا ﻳﻌﻨﻲ أن اﻟﻤﺴﺘﺨﺪم ﻗﺪ ﺿﻐﻂ زر ‪ cancel‬وﺳﻮف ﻧﺘﺤﺪث ﻋﻠﻲ ھﺬا‬
‫اﻹﺳﻠﻮب ﻓﯿﻤﺎ ﺑﻌﺪ ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻤﺘﻐﯿﺮات‪.‬‬
‫‪ -‬أو ﻧﻘﻮم ﺑﺈﺳﺘﺨﺪام اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﺑﺪون ﺗﺨﺰﻳﻨﮫﺎ ) ﻣﻦ ﻋﻠﻲ اﻟﻄﺎﺋﺮ ﻛﻤﺎ ﻳﻘﺎل ( ﻛﻤﺎ ﺳﻮف ﻳﺘﻀﺢ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫ﺣﯿﺚ ﺳﻮف ﻧﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻹﺧﺘﯿﺎر ﺑﻮاﺳﻄﺔ اﻟﻄﺮﻳﻘﺔ ‪ alert‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪confirm </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫"(‪alert( confirm‬‬ ‫)"ﻣﻦ ﻓﻀﻠﻚ ﻫﻞ أﻧﺖ ﻣﺘﺄﻛﺪ ﻣﻦ إﺗﻤﺎم ﻋﻤﻠﯿﺔ ﺣﺬف ﻫﺬا اﻟﻌﻤﯿﻞ ؟‬ ‫;)‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪27‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻓﻌﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ زر ‪ ok‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪28‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ زر ‪ cancel‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪ - ٢‬اﻟﻄﺮﯾﻘﺔ ‪: prompt‬‬

‫• ﺗﻘﻮم ﺑﺈﻇﻬﺎر رﺳﺎﻟﺔ ﻣﺜﻞ اﻟﻄﺮﯾﻘﺔ ‪ confirm‬اﻟﺴﺎﺑﻘﺔ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أﻧﻬﺎ ﺗﻘﻮم ﺑﺈرﺟﺎع أﺣﺪي اﻟﻘﯿﻤﺘﯿﻦ‬
‫اﻟﻘﯿﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻣﻦ ﺧﻼل اﻟﻤﺴﺘﺨﺪم أو اﻟﻘﯿﻤﺔ ‪ ) null‬وﻫﻲ ﺗﻌﻨﻲ ﻻ ﺷﻲء(‪.‬‬
‫• ﺗﻌﺘﺒﺮ إﺣﺪي اﻟﻮﻇﺎﺋﻒ اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ ‪. window‬‬
‫• ﻃﺮﯾﻘﺔ إﺳﺘﺨﺪاﻣﻬﺎ ‪:‬‬

‫"(‪prompt‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫اﻟﺮاﺟﻌﺔ" ‪",‬‬ ‫;)"اﻟﻘﯿﻤﺔ اﻹﻓﺘﺮاﺿﯿﺔ ﻟﻠﻘﯿﻤﺔ‬

‫أو‬
‫"(‪window.prompt‬‬ ‫ﺿﻊ ﻫﻨﺎ رﺳﺎﻟﺘﻚ‬ ‫اﻟﺮاﺟﻌﺔ " ‪",‬‬ ‫;)"اﻟﻘﯿﻤﺔ اﻹﻓﺘﺮاﺿﯿﺔ ﻟﻠﻘﯿﻤﺔ‬

‫ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻷﻣﺮ ‪ prompt‬أو ‪ window.prompt‬ﻛﻼھﻤﺎ ﺳﻮف ﻳﺆدي إﻟﻲ ﻧﻔﺲ اﻟﻨﺘﯿﺠﺔ ﺛﻢ ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﺮﺳﺎﻟﺔ اﻟﻤﺮاد‬
‫إﻇﮫﺎرھﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ "" ﺛﻢ ﺗﻤﺮر أو ﻻ ﺗﻤﺮر اﻟﻘﯿﻤﺔ اﻹﻓﺘﺮاﺿﯿﺔ ﻟﻠﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ وإذا ﻟﻢ ﺗﻤﺮر ﺳﻮف ﺗﺄﺧﺬ اﻟﻘﯿﻤﺔ‬
‫اﻹﻓﺘﺮاﺿﯿﺔ ‪undefined‬‬
‫ﺛﻢ ﻳﺘﻢ إﺳﺘﻘﺒﺎل اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻹﺧﺘﯿﺎر ﻓﻲ ﻣﺘﻐﯿﺮ ) ﺳﻮف ﻳﺘﻢ ﺷﺮح اﻟﻤﺘﻐﯿﺮات ﻓﯿﻤﺎ ﺑﻌﺪ ( أو إﻇﮫﺎرھﺎ ﻓﻲ ﺷﻜﻞ‬
‫رﺳﺎﻟﺔ ﻛﻤﺎ ﺳﺒﻖ اﻟﻘﻮل ﻓﻲ اﻟﻄﺮﻳﻘﺔ ‪ confirm‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫‪29‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺑﻬﺎ اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﺑﻌﺪ إدﺧﺎل اﺳﻤﻪ‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻄﺮﯾﻘﺔ‬ ‫>‪prompt </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫"(‪alert( prompt‬‬ ‫‪",‬ﻣﺎ ﻫﻮ اﺳﻤﻚ ؟‬ ‫اﺳﻤﻚ "‬ ‫)"أدﺧﻞ ﻫﻨﺎ‬ ‫;)‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﺛﻢ ﻧﻘﻮم ﺑﺈدﺧﺎل اﻻﺳﻢ وﻟﯿﻜﻦ اﻟﺘﺎﻟﻲ "اﻟﺤﺴﯿﻦ ﻣﺤﻤﺪ" ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪30‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻓﻌﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ زر ‪ ok‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪31‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻲ زر ‪ cancel‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫‪32‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ‬
‫ﺍﻟﻤﺘﻐﻴﺮﺍﺕ‬

‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫اﻟﻤﺘﻐﯿﺮات ‪Variables‬‬ ‫•‬

‫ﻣﺎ ھﻮ اﻟﻤﺘﻐﯿﺮ‬ ‫‪o‬‬
‫أﻧﻮاع اﻟﺒﯿﺎﻧﺎت‬ ‫‪o‬‬
‫ﻃﺮﻳﻘﺔ ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات‬ ‫‪o‬‬
‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﯿﺮات‬ ‫‪o‬‬

‫اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ‪JavaScript Keywords‬‬ ‫•‬

‫‪33‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﻤﺘﻐﯿﺮات ‪Variables‬‬

‫ﻣﺎ ھﻮ اﻟﻤﺘﻐﯿﺮ ‪:‬‬

‫ھﺐ أﻧﻨﻲ أﻋﻄﯿﺘﻚ ﻛﻤﯿﺔ ﻣﻦ اﻟﻤﺎء ﻓﻤﺎ وﺳﯿﻠﺔ ﺗﺨﺰﻳﻨﻚ ﻟﮫﺬة اﻟﻜﻤﯿﺔ ‪ ،‬رﺑﻤﺎ ﻗﻠﺖ ﻟﻲ ﺳﻮف أﺿﻌﮫﺎ ﻓﻲ ﻛﻮب ﺻﻐﯿﺮ أو إﻧﺎء‬
‫أو أي ﻣﺤﺘﻮي أﻛﺒﺮ ‪ ،‬وﺑﮫﺬا أﻗﻮل ﻟﻚ أﻧﻚ ﻧﺠﺤﺖ ﻓﻲ ﻋﻤﻠﯿﺔ ﺗﺨﺰﻳﻦ اﻟﻤﯿﺎه وﻟﻜﻦ ﻣﺎ ﻓﺎﺋﺪة ھﺬة اﻟﻌﻤﻠﯿﺔ ‪ ،‬رﺑﻤﺎ ﺗﻘﻮل ﻟﻲ‬
‫ﺣﺘﻲ أﺳﺘﺨﺪﻣﮫﺎ ﻋﻨﺪ ﺣﺎﺟﺘﻲ ﻟﮫﺎ ﻓﻲ اﻟﻤﺴﺘﻘﺒﻞ اﻟﻘﺮﻳﺐ أو اﻟﺒﻌﯿﺪ ﻧﻌﻢ ﻧﻌﻤﺎ اﻟﺮأي ﻣﺎ ﻗﻠﺖ ‪.‬‬

‫ﻟﻜﻦ ﻣﺎ ﻋﻼﻗﺔ ھﺬا ﺑﻤﻮﺿﻮﻋﻨﺎ اﻟﻤﺘﻐﯿﺮات ‪ ،‬ﺑﻜﻞ ﺑﺴﺎﻃﺔ ﻛﻤﺎ أﺣﺘﺠﻨﺎ إﻟﻲ ﺗﺨﺰﻳﻦ اﻟﻤﺎء ﻓﻲ ﻣ ﺤﺘﻮي ﻳﺤﻔﻈﻪ ﺣﺘﻲ ﻧﺘﻤﻜﻦ‬
‫ﻣﻦ إﺳﺘﺨﺪاﻣﻪ ﻋﻨﺪ اﻟﺤﺎﺟﺔ إﻟﯿﻪ ‪ ،‬ﻓﺈﻧﻨﺎ أﻳﻀﺎ ﻓﻲ ﻋﺎﻟﻢ اﻟﻜﻤﺒﯿﻮﺗﺮ واﻟﺒﺮﻣﺠﺔ ﻧﺤﺘﺎج إﻟﻲ ﻋﻤﻠﯿﺔ ﺗﺨﺰﻳﻦ وﻟﻜﻦ ﻟﯿﺲ ﻟﻠﻤﺎء‬
‫وﻟﻜﻦ ﺗﺨﺰﻳﻦ ﻟﻠﺒﯿﺎﻧﺎت ‪.‬‬

‫ﻓﮫﺐ أﻧﻨﻲ أﻋﻄﯿﺘﻚ اﻟﻨﺺ اﻟﺘﺎﻟﻲ اﻟﺤﻤﺪ ﷲ اﻟﻌﻠﻲ اﻟﻌﻈﯿﻢ وﻗﻠﺖ ﻟﻚ ﻛﯿﻒ ﻳﻤﻜﻨﻚ ﺗﺨﺰﻳﻦ ھﺬا اﻟﻨﺺ رﺑﻤﺎ أﺳﺮﻋﺖ‬
‫ﺑﺎﻟﻘﻮل ﻟﻲ أﻧﻨﻲ ﺳﻮف أﻗﻮم ﺑﺤﻔﻆ ھﺬا اﻟﻨﺺ ﻓﻲ رأﺳﻲ وﺗﻜﻮن رأﺳﻚ ھﻨﺎ ھﻲ ﻣﺨﺰن اﻟﻨﺺ ‪ ،‬وﻟﻜﻦ إذا أردﻧﺎ ﺗﺨﺰﻳﻦ‬
‫اﻟﻨﺺ اﻟﺴﺎﺑﻖ ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﺑﺸﻜﻞ ﻣﺆﻗﺖ ) اي ﺧﻼل ﻓﺘﺮة ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻘﻂ وﻳﻨﺘﮫﻲ ﺗﺨﺰﻳﻨﮫﺎ ﻋﻨﺪ إﻧﺘﮫﺎء اﻟﺒﺮﻧﺎﻣﺞ (‬
‫ھﻨﺎ ﺳﻮف ﻧﺤﺘﺎج إﻟﻲ ﻣﺨﺰن ﻳﺘﻢ ﺣﻔﻆ ھﺬا اﻟﻨﺺ ﺑﻪ وﻏﺎﻟﺒﺎ ﻣﺎ ﻳﻜﻮن ﺟﺰء ﻣﻦ ذاﻛﺮة اﻟﺤﮫﺎز اﻟﻤﺆﻗﺘﺔ ‪ ،‬وﻳﺘﻢ إﻋﻄﺎء ھﺬا‬
‫اﻟﺠﺰء ﻣﻦ ذاﻛﺮة اﻟﺠﮫﺎز اﺳﻢ ﺧﺎص ﺣﺘﻲ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ھﺬا اﻟﺠﺰء ‪.‬‬

‫ﻧﺨﻠﺺ ﻣﻤﺎ ﺳﺒﻖ إﻟﻲ أن اﻟﻤﺘﻐﯿﺮ ھﻮ ﺟﺰء ﻣﻦ ذاﻛﺮة اﻟﺠﮫﺎز ﻳﺘﻢ إﻋﻄﺎء اﺳﻢ ﻟﻪ ‪ ،‬ﻳﻌﺘﺒﺮ ﺑﻤﺜﺎﺑﺔ ﻣﺨﺰن ﻟﻠﺒﯿﺎﻧﺎت‬

‫أﻧﻮاع اﻟﺒﯿﺎﻧﺎت ‪:‬‬

‫ﺗﺨﺘﻠﻒ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت ﻓﻤﺜﻼ ﻳﺴﺘﻄﯿﻊ اﻹﻧﺴﺎن إ دراك اﻟﺘﻤﯿﺰ ﺑﯿﻦ اﻟﺤﺮوف اﻷﺑﺠﺪﻳﺔ و اﻷرﻗﺎم وﺑﯿﻦ اﻟﻨﺼﻮص واﻟﻘﯿﻢ اﻟﻌﺪدﻳﺔ‬
‫وھﻜﺬا ‪ ،‬وأﻳﻀﺎ ﺗﻮﻓﺮ ﻟﻨﺎ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺘﻤﯿﺰ ﺑﯿﻦ ‪ ٤‬أﻧﻮاع ﻣﻦ اﻟﺒﯿﺎﻧﺎت ‪:‬‬
‫• اﻟﻨﺼﻮص ‪String‬‬
‫• اﻟﻘﯿﻢ اﻟﻌﺪدﻳﺔ ‪Number‬‬
‫• اﻟﺤﺎﻟﺔ اﻟﺒﻮﻟﯿﻨﯿﺔ ) ﺻﺢ أم ﺧﻄﺄ ( ‪Boolean‬‬
‫• اﻟﻘﯿﻤﺔ ﻻ ﺷﺊ ‪Null‬‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺘﺎﻟﻲ ﻛﻤﺎ ﻧﻌﻠﻢ أن ﺷﻜﻞ وﻃﺒﯿﻌﺔ ﺗﺮﻛﯿﺐ ﻣﺨﺎزن اﻟﻤﯿﺎه ﻳﺨﺘﻠﻒ ﻋﻦ ﺑﻨﯿﺔ ﻣﺨﺎزن اﻟﺒﺘﺮول ﻣﺜﻼ‬
‫وھﻜﺬا ﻳﺨﺘﻠﻒ ﻧﻮع اﻟﻤﺨﺰن ﺣﺴﺐ ﻃﺒﯿﻌﺔ وﻧﻮع اﻟﻤﺎدة اﻟﻤﺨﺰﻧﺔ ﺑﻪ ‪.‬‬

‫وﻟﻜ ﻦ اﻟﻤﺘﻐﯿﺮات ﻓﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ) وھﻲ ﻣﺨﺎزن اﻟﺒﯿﺎﻧﺎت ( ﻻ ﺗﺨﺘﻠﻒ ﻓﻲ ﺑﻨﯿﺘﮫﺎ ﺑﺈﺧﺘﻼف ﻧﻮع اﻟﺒﯿﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ‬
‫ﺑﮫﺎ ﻛﻤﺎ ھﻮ اﻟﺤﺎل ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ واﻟﺴﻲ اﻟﺘﻲ ﻳﺘﻤﯿﺰ ﻓﯿﮫﺎ ﻧﻮع اﻟﻤﺨﺰن ﺣﺴﺐ ﻧﻮع اﻟﺒﯿﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ ﺑﻪ ‪.‬‬

‫‪34‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻃﺮﻳﻘﺔ ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات ‪:‬‬

‫ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات ﺗﺨﻀﻊ ﻟﺸﺮوط أﺳﺎﺳﯿﺔ ﻳﺠﺐ ﺗﻮاﻓﺮھﺎ ﻟﯿﻌﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﺼﻮرة اﻟﺼﺤﯿﺤﺔ وھﻲ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫اﻟﺨﺎﻧﺔ اﻷوﻟﻲ ﻣﻦ إﺳﻢ اﻟﻤﺘﻐﯿﺮ ﻻﺑﺪ أن ﺗﻜﻮن أﺣﺪ اﻷﺣﺮف اﻹﻧﺠﻠﯿﺰﻳﺔ ﺳﻮاءً ﺣﺮﻓﺎ ﻛﺒﯿﺮا أو ﺻﻐﯿﺮا ﻣﻊ ﻣﻼﺣﻈﺔ‬ ‫•‬
‫اﻟﻔﺮق ﺑﯿﻨﮫﻤﺎ ‪ ،‬وﻳﻤﻜﻦ اﻟﺒﺪء ﺑﻌﻼﻣﺔ _ أو ﻋﻼﻣﺔ ‪ ، $‬ﻣﻊ أﻧﻪ ﻻﻳﻨﺼﺢ ﺑﺈﺳﺘﺨﺪام اﻟﻌﻼﻣﺔ اﻷﺧﯿﺮة ‪.‬‬

‫ﻻﻳﻤﻜﻨﻚ إﻃﻼﻗﺎ إٍﺳﺘﺨﺪام رﻗﻢ ﻛﺄول ﺧﺎﻧﺔ ﻓﻲ اﻹﺳﻢ ‪.‬‬ ‫•‬

‫اﻷﺳﻤﺎء ﻻﻳﻤﻜﻦ أن ﺗﺤﻮي ﻣﺴﺎﻓﺎت ﺑﯿﻦ أﺣﺮﻓﮫﺎ ‪ ،‬ﻟﻜﻦ ﻳﻤﻜﻨﻚ إﺳﺘﺨﺪام اﻟﻌﻼﻣﺔ _ ﺑﺪل اﻟﻤﺴﺎﻓﺎت ‪.‬‬ ‫•‬

‫ﻻﻳﻤﻜﻦ ﻷي إﺳﻢ أن ﻳﻤﺎﺛﻞ أﻳﺎ ﻣﻦ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة وھﺬه اﻟﻘﺎﻋﺪة ﻋﺎﻣﺔ ﻟﺠﻤﯿﻊ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ‪.‬‬ ‫•‬

‫وإﻟﯿﻚ ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺘﺴﻤﯿﺔ اﻟﺼﺤﯿﺤﺔ ﻟﻠﻤﺘﻐﯿﺮات ‪:‬‬

‫• ‪Address1‬‬
‫• ‪A4xb5‬‬
‫• ‪lastName‬‬
‫• ‪_firstName‬‬
‫• ‪parent_Name‬‬

‫وإﻟﯿﻚ ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﻠﻰ اﻟﺘﺴﻤﯿﺔ ﻏﯿﺮ اﻟﺼﺤﯿﺤﺔ ﻟﻠﻤﺘﻐﯿﺮات ‪:‬‬

‫• ‪1stName‬‬
‫• ‪?subName‬‬
‫• ‪last name‬‬
‫@‪userID‬‬ ‫•‬

‫ﺟﺮت اﻟﻌﺎدة ﻋﻨﺪ ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات ﻓﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ أﻧﻪ ﻻ ﻳﻔﻀﻞ إﺳﺘﺨﺪام اﻟﺤﺮف _ ﻟﻠﻔﺼﻞ ﺑﯿﻦ ﻣﻘﺎﻃﻊ اﻟﻜﻠﻤﺎت‬
‫وﻟﻜﻦ ﻳﺘﻢ دﻣﺞ اﻟﻤﻘﺎﻃﻊ ﻣﻊ ﺟﻌﻞ اﻟﺤﺮف اﻷول ﺻﻐﯿﺮ وأول ﺣﺮف ﻣﻦ اﻟﻤﻘﺎﻃﻊ اﻟﺘﺎﻟﯿﺔ ﻳﻜﻮن ذو ﺣﺮف ﻛﺒﯿﺮ ﻓﻌﻠﻲ ﺳﺒﯿﻞ‬
‫اﻟﻤﺜﺎل ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺗﺴﻤﯿﺔ ﻣﺘﻐﯿﺮ ﻟﯿﻌﺒﺮ ﻋﻦ ‪ last name‬ﻻ ﻳﻔﻀﻞ ﺗﺴﻤﯿﺘﻪ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪ Last_name‬وﻟﻜﻦ ﻳﻔﻀﻞ ﺗﺴﻤﯿﺔ ﻛﻤﺎ ﻳﻠﻲ ‪.lastName‬‬

‫ﻣﻼﺣﻈﺎت ھﺎﻣﺔ ﻋﻨﺪ ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات ‪:‬‬

‫ﻛﻤﺎ ﻧﻌﻠﻢ ﻓﺈن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻤﯿﺰ ﺑﯿﻦ ﺣﺎﻟﺔ اﻟﺤﺮوف اﻟﻜﺒﯿﺮة واﻟﺼﻐﯿﺮة ﻓﺈن اﻟﻤﺘﻐﯿﺮ‬
‫‪ lastName‬ﻟﯿﺲ ﻣﺜﻞ اﻟﻤﺘﻐﯿﺮ ‪. LastName‬‬

‫داﺋﻤﺎ ﺣﺎول أن ﺗﻜﻮن أﺳﻤﺎء اﻟﻤﺘﻐﯿﺮات ذات دﻻﻟﺔ ﺗﺒﺴﻂ ﻋﻠﯿﻚ ﻓﻲ اﻟﻤﺴﺘﻘﺒﻞ ﻋﻤﻠﯿﺔ اﻟﺘﻌﺪﻳﻞ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫‪35‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﯿﺮات ‪:‬‬

‫ﻛﻤﺎ ﻏﻠﻤﻨﺎ أن اﻟﻤﺘﻐﯿﺮات ھﻲ أﺳﻤﺎء ﻟﺤﺠﺰ أﻣﺎﻛﻦ ﻓﻲ ذاﻛﺮة اﻟﺠﮫﺎز ﻟﺤﻔﻆ اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﺗﺴﻨﺪ إﻟﯿﮫﺎ ‪ .‬وﻗﺒﻞ أن‬
‫ﺗﺴﺘﺨﺪم أﻳﺎ ﻣﻦ ھﺬه اﻟﻤﺘﻐﯿﺮات ﻻﺑﺪ ﻣﻦ اﻹﻓﺼﺎح ﻋﻨﮫﺎ ‪ ،‬وذﻟﻚ ﺑﺈﺳﺘﺨﺪام اﻷﻣﺮ ‪var‬‬

‫;‪var firstName‬‬

‫وھﻜﺬا ‪ ،‬ﻛﻤﺎ أﻧﻪ ﻣﻦ اﻟﻤﻤﻜﻦ اﻹﻋﻼن ﻋﻦ أﻛﺜﺮ ﻣﻦ ﻣﺘﻐﯿﺮ ﻓﻲ ﺳﻄﺮ واﺣﺪ ‪ ،‬وھﺬا ﻣﺎﻻﻳﻤﻜﻨﻚ ﻋﻤﻠﻪ ﺑﻮاﺳﻄﺔ اﻟﻔﯿﺠﻮال‬
‫ﺑﯿﺴﻚ ﺳﻜﺮﺑﺖ ‪..‬‬

‫;‪var firstName, lastName, userID‬‬

‫وأﺧﯿﺮاً ‪ ،‬ﻟﻤﺰﻳﺪ ﻣﻦ اﻟﺘﺒﯿﺴﻂ ‪ ،‬ﻳﻤﻜﻨﻨﺎ إﺳﻨﺎد اﻟﻘﯿﻢ اﻟﻰ ھﺬه اﻟﻤﺘﻐﯿﺮات أﺛﻨﺎء ﺗﻌﺮﻳﻔﮫﺎ واﻹﻓﺼﺎح ﻋﻨﮫﺎ‪ ،‬ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫;‪ ", userID = 13‬ﻋﻠﻲ" = ‪var firstName, lastName‬‬

‫ﺗﺬﻛﺮ أﻧﻪ إذا ﻟﻢ ﺗﻔﺼﺢ ﻋﻦ أي ﻣﺘﻐﯿﺮ ﻗﺒﻞ إﺳﺘﺨﺪاﻣﻪ ﻓﺈن ذﻟﻚ ﺳﯿﻮﻗﻒ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ‪ ،‬وﻻﺗﻨﺴﻰ أن اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻟﻐﺔ‬
‫ﺣﺴﺎﺳﺔ ﺗﺠﺎه اﻷﺣﺮف ﻛﻤﺎ ذﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ ﻓـ ‪ x‬ﻏﯿﺮ ‪ X‬داﺋﻤﺎ ﺣﺘﻰ ﻓﻲ أواﻣﺮ اﻟﺠﺎﻓﺎ اﻟﺴﻜﺮﺑﺖ واﻟﻮﻇﺎﺋﻒ وﻣﺼﻄﻠﺤﺎﺗﮫﺎ‬
‫اﻟﻤﺤﺠﻮزة ‪.‬‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻠﻤﺴﺘﺨﺪم ﺑﻌﺪ إدﺧﺎل اﺳﻤﻪ‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻤﺘﻐﯿﺮات‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫"(‪var username = prompt‬‬ ‫‪",‬ﻣﺎ ﻫﻮ اﺳﻤﻚ ؟‬ ‫اﺳﻤﻚ"‬ ‫;)"أدﺧﻞ ﻫﻨﺎ‬
‫" (‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ username‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﺑﻌﺪ إدﺧﺎل اﻷﺳﻢ ﺑﻘﯿﻤﺔ ﻣﺤﻤﺪ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪36‬‬
‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﺑﻌﺪ اﻟﻀﻐﻂ ﻋﻠﻲ اﻟﺰر ‪: ok‬‬

‫‪37‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻛﻤﺎ ﻧﺮي ﻓﻘﺪ ﺗﻢ اﻹﻋﻼن ﻋﻦ ﻣﺘﻐﯿﺮ ﺑﺎﺳﻢ ‪ userName‬ﺛﻢ ﺧﺰن ﺑﻪ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻷﻣﺮ ‪ prompt‬ﻛﻤﺎ ﻳﻠﻲ‬

‫"(‪var username = prompt‬‬ ‫‪",‬ﻣﺎ ﻫﻮ اﺳﻤﻚ ؟‬ ‫اﺳﻤﻚ"‬ ‫;)"أدﺧﻞ ﻫﻨﺎ‬

‫ﺛﻢ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ اﻟﻘﯿﻤﺔ اﻟﻤﺨﺰﻧﺔ ﺑﺎﻟﻤﺘﻐﯿﺮ ‪ userName‬ﻣﻀﺎﻓﺎ إﻟﯿﮫﺎ ﻧﺺ " ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪ " :‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫"(‪var username = prompt‬‬ ‫‪",‬ﻣﺎ ﻫﻮ اﺳﻤﻚ ؟‬ ‫اﺳﻤﻚ"‬ ‫;)"أدﺧﻞ ﻫﻨﺎ‬

‫" (‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ username‬‬

‫ﺗﻤﺮﯾﻦ ﻹﻇﻬﺎر ﺑﯿﺎﻧﺎت اﻟﻤﺴﺘﺨﺪم ﺑﻌﺪ إدﺧﺎل اﺳﻤﻪ وﻋﻤﺮه‬

‫>‪<HTML dir=rtl‬‬
‫>‪ </Title‬اﻟﻤﺘﻐﯿﺮات >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var userage, username‬‬

‫؟"(‪userage = confirm‬‬ ‫;)" ﻫﻞ ﻋﻤﺮك أﻗﻞ ﻣﻦ ‪ ٢٠‬ﻋﺎم‬

‫"(‪username = prompt‬‬ ‫;)"أدﺧﻞ ﻫﻨﺎ اﺳﻤﻚ" ‪",‬ﻣﺎ ﻫﻮ اﺳﻤﻚ ؟‬

‫" (‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ username‬‬

‫>‪document.write( "<b‬‬ ‫">‪</b‬ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ">‪+ username + "<br‬‬

‫ﻋﺎم>‪document.write( "<b‬‬ ‫ﻋﻤﺮك أﻗﻞ ﻣﻦ ‪٢٠‬‬ ‫;) ">‪: </b>" + userage + "<br‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﺑﻌﺪ إﺧﺘﯿﺎر ‪ ok‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪38‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﺑﻌﺪ إدﺧﺎل اﻷﺳﻢ ﺑﻘﯿﻤﺔ ﻣﺤﻤﺪ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪39‬‬
‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫‪40‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة‬
‫ وھﻲ أواﻣﺮ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺘﻲ ﻻﻳﻤﻜﻨﻚ ﻧﺴﺐ أي ﻣﺘﻐﯿﺮات إﻟﯿﮫﺎ ﻋﻠﻰ‬، ‫أو ﻣﺼﻄﻠﺤﺎت اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺤﺠﻮزة‬
. ‫ ﻛﻤﺎ ﻓﻲ ﻛﻞ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻟﻤﻌﺮوﻓﺔ‬، ‫اﻹﻃﻼق‬

‫ وﺳﺘﺠﺪ ﺟﺪوﻻ ﻣﺒﯿﻨﺎ ﻟﮫﺎ‬. ‫ وإﻧﻤﺎ اﻹﻟﻤﺎم ﺑﮫﺎ‬، ‫ﻃﺒﻌﺎ ﻻﻳﺠﺐ ﻋﻠﯿﻚ ﺣﻔﻈﮫﺎ ﻛﺎﻣﻠﺔ‬

break in true
continue int typeof
do labeled var
else new void
false null while
for return with
function switch
if this

abstract final protected

boolean finally public
byte float short
case goto static
catch implements synchronized
char import super
class instanceof throw
const interface throws
default long transient
delete native try
double package
extends private

41
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺮﺍﺑﻊ‬
‫ﺍﻟﻤﻌﺎﻣﻼﺕ‬
‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫اﻟﻤﻌﺎﻣﻼت ‪Operators‬‬ ‫•‬

‫رﻳﺎﺿﯿﺔ ‪Arithmetic Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫دﻣﺞ اﻟﻨﺼﻮص ‪Concatenation Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫اﻟﻤﻘﺎرﻧﺔ ‪Comparison Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫ﻣﻨﻄﻘﯿﺔ ‪Logical Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫ا ﺣﺎدﻳﺔ ‪Unary Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫ﺗﻐﯿﺮ اﻟﻘﯿﻢ ‪Assignment Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫اﻟﺘﻌﺎﻣﻞ ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪Shift & Bitwise Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬
‫ﺧﺎﺻﺔ‬ ‫ﻣﻌﺎﻣﻼت‬ ‫‪o‬‬

‫أوﻟﻮﻳﺔ ﺗﻨﻔﯿﺬ اﻟﻤﻌﺎﻣﻼت ‪Operator Precedence‬‬ ‫•‬

‫ﻣﻌﺎﻟﺠﺔ اﻷﺧﻄﺄ ‪Exception Handling‬‬ ‫•‬
‫ﺟﻤﻠﺔ ‪with‬‬ ‫•‬

‫‪42‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﻤﻌﺎﻣﻼت ‪Operators‬‬

‫ﺗﻌﺘﺒﺮ اﻟﻤﻌﺎﻣﻼت ھﻲ اﻟﻮﺳﯿﻂ اﻷﺳﺎﺳﻲ ﻟﻠﺘﻌﺎﻣﻞ ﺑﯿﻦ ﻗﯿﻢ اﻟﻤﺘﻐﯿﺮات ‪.‬‬

‫وﺗﻨﻘﺴﻢ اﻟﻤﻌﺎﻣﻼت إﻟﻲ ﻏﺪة أﻗﺴﺎم ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫رﻳﺎﺿﯿﺔ ‪Arithmetic Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬

‫دﻣﺞ اﻟﻨﺼﻮص ‪Concatenation Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫اﻟﻤﻘﺎرﻧﺔ ‪Comparison Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫ﻣﻨﻄﻘﯿﺔ ‪Logical Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫اﺣﺎدﻳﺔ ‪Unary Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫ﺗﻐﯿ ﺮ اﻟﻘﯿﻢ ‪Assignment Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫اﻟﺘﻌﺎﻣﻞ ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪Shift & Bitwise Operators‬‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬
‫ﺧﺎﺻﺔ‬ ‫ﻣﻌﺎﻣﻼت‬ ‫•‬

‫ﻣﻌﺎﻣﻼت رﻳﺎﺿﯿﺔ ‪Arithmetic Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻹﺟﺮاء اﻟﻌﻤﻠﯿﺎت اﻟﺮﻳﺎﺿﯿﺔ ﻣﻦ ﺟﻤﻊ وﻃﺮح وﺿﺮب وﻗﺴﻤﺔ وﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ‪.‬‬

‫‪ : +‬ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ اﻟﺮﻳﺎﺿﻲ ‪.‬‬ ‫•‬

‫‪ : -‬ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﻄﺮح اﻟﺮﻳﺎﺿﻲ ‪.‬‬ ‫•‬
‫* ‪ :‬ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﻀﺮب اﻟﺮﻳﺎﺿﻲ ‪.‬‬ ‫•‬
‫‪ : /‬ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﻘﺴﻤﺔ اﻟﺮﻳﺎﺿﻲ ‪.‬‬ ‫•‬
‫‪ : %‬ﺗﺴﺘﺨﺪم ﻟﺤﺴﺎب ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ اﻟﺮﻳﺎﺿﻲ‬ ‫•‬
‫ﻣﺜﺎل ‪:‬‬

‫;) ‪alert( 5 % 2‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪43‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﻌﺎﻣﻼت دﻣﺞ اﻟﻨﺼﻮص ‪Concatenation Operators‬‬

‫‪ : +‬ﻛﻤﺎ ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ اﻟﺮﻳﺎﺿﻲ ﺗﺴﺘﺨﺪم ﻟﺪﻣﺞ اﻟﻨﺼﻮص ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬ ‫•‬

‫;"ﻣﺤﻤﺪ" = ‪var username‬‬

‫" (‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ username‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ ‪Comparison Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﻤﻘﺎرﻧﺔ‬

‫ﻋﻨﺪ إﺟﺮاء ﻣﻘﺎرﻧﺔ ﻳﻜﻮن ﻧﺎﺗﺞ ھﺬة اﻟﻤﻘﺎرﻧﺔ إﺣﺪي اﻟﻘﯿﻢ اﻣﺎ ‪ true‬أو ‪. false‬‬
‫• == ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻣﺘ ﺴﺎوﻳﺎن ﻓﻲ اﻟﻘﯿﻤﺔ ‪.‬‬
‫• == = ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻣﺘﺴﺎوﻳﺎن ﻓﻲ اﻟﻘﯿﻤﺔ و ﻧﻮع اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫=! ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻏﯿﺮ ﻣﺘﺴﺎوﻳﺎن ﻓﻲ اﻟﻘﯿﻤﺔ ‪.‬‬ ‫•‬
‫• = =! ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻏﯿﺮ ﻣﺘﺴﺎوﻳﺎن ﻓﻲ اﻟﻘﯿﻤﺔ و ﻧﻮع اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫• > ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ اﻟﻄﺮف اﻷﻳﺴﺮ أﻛﺒﺮ ﻣﻦ اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬
‫• < ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ اﻟﻄﺮف اﻷﻳﺴﺮ أﻗﻞ ﻣﻦ اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬
‫• => ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ اﻟﻄﺮف اﻷﻳﺴﺮ أﻛﺒﺮ أو ﻳﺴﺎوي اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬
‫• =< ‪ :‬ﻟﺘﻌﯿﻦ ھﻞ اﻟﻄﺮف اﻷﻳﺴﺮ أﻗﻞ ﻣﻦ أو ﻳﺴﺎوي اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬

‫ﻻﺣﻆ ‪:‬‬
‫ﻋﻨﺪ ﺗﻌﯿﻦ ھﻞ اﻟﻄﺮﻓﯿﻦ ﻣﺘﺴﺎوﻳﺎن ﻳﻢ أﺳﺘﺨﺪام اﻟﺤﺮف "=" ﻣﺮﺗﯿﯿﻦ ﻣﺘﺘﺎﻟﯿﺘﯿ ﻦ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;) )‪alert( "5 == 2 : " + (5 == 2‬‬

‫;) )‪alert( "7 == 7 : " + (7 == 7‬‬

‫‪44‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﻌﺎﻣﻼت ﻣﻨﻄﻘﯿﺔ ‪Logical Operators‬‬

‫ﺗﺴﺘﺨﺪ ﻹﺟﺮاء ﻣﻘﺎرﻧﺔ ﻣﻨﻄﻘﯿﺔ ‪ ،‬وﻏﺎﻟﺒﺎ ﻣﺎ ﺗﻜﻮن أﻃﺮاف اﻟﻤﻘﺎرﻧﺔ إﺣﺪي اﻟﻘﯿﻢ ‪ true‬أو ‪. false‬‬
‫ﻋﻨﺪ إﺟﺮاء ﻣﻘﺎرﻧﺔ ﻳﻜﻮن ﻧﺎﺗﺞ ھﺬة اﻟﻤﻘﺎرﻧﺔ إﺣﺪي اﻟﻘﯿﻢ اﻣﺎ ‪ true‬أو ‪. false‬‬
‫• && ‪:‬‬
‫ﺗﻌﻨﻲ اﻟﻌﻤﻠﯿﺔ اﻟﻤﻨﻄﻘﯿﺔ "و" وﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ ‪ true‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻳﺴﺎوي ‪ true‬وﻏﯿﺮ ذﻟﻚ‬
‫ﺳﻮف ﻳﺆدي إﻟﻲ إرﺟﺎع اﻟﻘﯿﻤﺔ ‪ false‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻨﺎﺗﺞ‬

‫‪True‬‬ ‫‪True‬‬ ‫‪True‬‬
‫‪True‬‬ ‫‪False‬‬ ‫‪False‬‬
‫‪False‬‬ ‫‪True‬‬ ‫‪False‬‬
‫‪False‬‬ ‫‪False‬‬ ‫‪False‬‬

‫|| ‪:‬‬ ‫•‬

‫ﺗﻌﻨﻲ اﻟﻌﻤﻠﯿﺔ اﻟﻤﻨﻄﻘﯿﺔ "أو" وﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ ‪ true‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﺣﺪي ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ أو ﻛﻼھﻤﺎ ﻳﺴﺎوي‬
‫‪ true‬وﻏﯿﺮ ذﻟﻚ ﺳﻮف ﻳﺆدي إﻟﻲ إرﺟﺎع اﻟﻘﯿﻤﺔ ‪ false‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻨﺎﺗﺞ‬

‫‪True‬‬ ‫‪True‬‬ ‫‪True‬‬
‫‪True‬‬ ‫‪False‬‬ ‫‪True‬‬
‫‪False‬‬ ‫‪True‬‬ ‫‪True‬‬
‫‪False‬‬ ‫‪False‬‬ ‫‪False‬‬

‫‪45‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫! ‪:‬‬ ‫•‬
‫ﺗﻌﻨﻲ اﻟﻌﻤﻠﯿﺔ اﻟﻤﻨﻄﻘﯿﺔ " ﻻ" وﺗﻘﻮم ﺑﻌﻜﺲ اﻟﻘﯿﻤﺔ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻨﺎﺗﺞ‬
‫‪True‬‬ ‫‪False‬‬
‫‪False‬‬ ‫‪True‬‬

‫أﻣﺜﻠﺔ ‪:‬‬

‫;) ‪alert( true && false‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;) ‪alert( true || false‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫;) ‪alert( !true‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪46‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫;) ) ‪alert( !( 5 > 7‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﻤﻌﺎﻣﻼت اﻻ ﺣﺎدﻳﺔ ‪Unary Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻹﺟﺮاء اﻟﻌﻤﻠﯿﺎت اﻟﺮﻳﺎﺿﯿﺔ ﻣﻦ ﺟﻤﻊ وﻃﺮح ﺑﺸﻜﻞ ﻣﺨﺘﺼﺮ ﺟﺪا ‪.‬‬
‫وﺗﺴﻤﻲ ھﺬه اﻟﻤﻌﺎﻣﻼت ﺑﺄﻧﮫﺎ ﻣﻌﺎﻣﻼت اﺣﺎدﻳﺔ ﻷﻧﮫﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻃﺮف واﺣﺪ )‪(operand‬‬

‫‪ : + +‬ﺗﺴﺘﺨﺪم ﻟ ﺰﻳﺎدة ﻗﯿﻤﺔ اﻟﻄﺮف )اﻟﻌﺎﻣﻞ( اﻟﻤﻤﺮر ﻟﮫﺎ ﺑﻤﻘﺪار واﺣﺪ ﺻﺤﯿﺢ ‪.‬‬ ‫•‬
‫‪ : - -‬ﺗﺴﺘﺨﺪم ﻹﻧﻘﺎص ﻗﯿﻤﺔ اﻟﻄﺮف )اﻟﻌﺎﻣﻞ( اﻟﻤﻤﺮر ﻟﮫﺎ ﺑﻤﻘﺪار واﺣﺪ ﺻﺤﯿﺢ ‪.‬‬ ‫•‬
‫‪ : -‬ﺗﺴﺘﺨﺪم ﻟﻌﻜﺲ إﺷﺎرة اﻟﻌﺎﻣﻞ اﻟﻤﻤﺮر ﻟﮫﺎ ﻓﺈذا ﻛﺎﻧﺖ ﻗﯿﻤﺔ ﺳﺎﻟﺒﺔ ﻓﺴﻮف ﺗﺘﺤﻮل إﻟﻲ ﻗﯿﻤﺔ ﻣﻮﺟﺒﺔ‬ ‫•‬
‫واﻟﻌﻜﺲ ﺻﺤﯿﺢ ‪.‬‬

‫ﻻﺣﻆ ‪:‬‬
‫ﻳﻮﺟﺪ ﺣﺎﻟﺘﺎن ﻟﻠﻤﻌﺎﻣﻠﯿﻦ ‪ ++‬و ‪ --‬ﺣﺎﻟﺔ ﻗﺒﻠﯿﺔ وأﺧﺮي ﺑﻌﺪﻳﺔ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﺤﺎﻟﺔ اﻟﺒﻌﺪﻳﺔ )‪:(Postfix‬‬

‫ﻓﯿﮫﺎ ﻳﺘﻢ إﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﺰﻳﺎدة )‪ (++‬أو اﻟﻨﻘﺺ ) ‪ (--‬ﺑﻌﺪ اﻹﻧﺘﮫﺎء ﻣﻦ إﺟﺮاء اﻟﺴﻄﺮ اﻟﺤﺎﻟﻲ ﻻﺣﻆ ﻣﻌﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻻﺣﺎدﯾﺔ >‪<Title‬‬ ‫اﻟ ﻤﻌﺎﻣﻼت‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num1 = 5, num2‬‬

‫;‪num2 = num1++‬‬

‫;) ‪alert( "num2 = " + num2‬‬

‫;) ‪alert( "num1 = " + num1‬‬
‫>‪//--‬‬
‫‪47‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻻﺣﻆ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num2 = num1++‬‬

‫ﻳﺘﻢ ﻓﯿﻪ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ اﻻﺣﺎدي ‪ ++‬وﻟﻜﻦ ﺑﺎﻟﻮﺿﻊ اﻟﺒﻌﺪي ﻷﻧﻪ أﺗﻲ ﺑﻌﺪ اﻟﻌﺎﻣﻞ ‪num1‬‬
‫وھﺬا اﻟﺴﻄﺮ ﻳﻜﺎﻓﺊ اﻟﺴﻄﺮﻳﻦ اﻟﺘﺘﺎﻟﯿﯿﻦ ‪:‬‬

‫;‪num2 = num1‬‬
‫;‪num1 = num1 + 1‬‬

‫ﻟﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﺤﺎﻟﺔ اﻟﻘﺒﻠﯿﺔ )‪:(Prefix‬‬

‫ﻓﯿﮫﺎ ﻳﺘﻢ إﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﺰﻳﺎدة )‪ (++‬أو اﻟﻨﻘﺺ ) ‪ (--‬ﻗﺒﻞ إﺟﺮاء ﺗﻨﻔﯿﺬ اﻟﺴﻄﺮ اﻟﺤﺎﻟﻲ ﻻﺣﻆ ﻣﻌﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻻﺣﺎدﯾﺔ >‪<Title‬‬ ‫اﻟﻤﻌﺎﻣﻼت‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num1 = 5, num2‬‬

‫‪48‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫;‪num2 = ++num1‬‬

‫;) ‪alert( "num2 = " + num2‬‬

‫;) ‪alert( "num1 = " + num1‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻻﺣﻆ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num2 = ++num1‬‬

‫ﻳﺘﻢ ﻓﯿﻪ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ اﻻﺣﺎدي ‪ ++‬وﻟﻜﻦ ﺑﺎﻟﻮﺿﻊ اﻟﻘﺒﻠﻲ ﻷﻧﻪ أﺗﻲ ﻗﺒﻞ اﻟﻌﺎﻣﻞ ‪num1‬‬
‫وھﺬا اﻟﺴﻄﺮ ﻳﻜﺎﻓﺊ اﻟﺴﻄﺮﻳﻦ اﻟﺘﺘﺎﻟﯿﯿﻦ ‪:‬‬

‫;‪num1 = num1 + 1‬‬

‫;‪num2 = num1‬‬

‫ﻟﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪49‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻷﻣﺜﻠﺔ اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 3, num2‬‬

‫;‪num2 = ++num1 + 4‬‬

‫;) ‪alert( "num1 = " + num1‬‬

‫;) ‪alert( "num2 = " + num2‬‬

‫ﻻ ﺣﻆ ان اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num2 = ++num1 + 4‬‬

‫ﻳﻜﺎﻓﻲ اﻟﺴﻄﺮﻳﯿﻦ اﻟﺘﺘﺎﻟﯿﯿﻦ ‪:‬‬

‫;‪num1 = num1 + 1‬‬

‫;‪num2 = num1 + 4‬‬

‫ﻟﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 13‬‬

‫;‪num1--‬‬

‫;) ‪alert( "num1 = " + num1‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪50‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

: ‫ﻣﺜﺎل‬

var num1 = 13;

alert( "num1 + 1 = " + (num1 + 1) );

alert( "num1 = " + num1 );

alert( "num1 + 1 = " + ++num1 );

alert( "num1 = " + num1 );

: ‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

51
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻻﺣﻆ أن اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ﻟﻢ ﻳﺆﺛﺮ ﻓﻲ ﻗﯿﻤﺔ ‪num1‬‬

‫;) )‪alert( "num1 + 1 = " + (num1 + 1‬‬

‫ﻣﻌﺎﻣﻼت ﺗﻐﯿﺮ اﻟﻘﯿﻢ ‪Assignment Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﻐﯿﺮ ﻗﯿﻤﺔ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻮﺟﻮد ﺑﺎﻟﻄﺮف اﻷﻳﺴﺮ‬

‫= ‪ :‬ﻟﺘﻐﯿﺮ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﺑﻘﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬ ‫•‬

‫=‪ : +‬ﻟﺰﻳﺎدة ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﺑﻤﻘﺪار ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬ ‫•‬
‫=‪ : -‬ﻟﻨﻘﺺ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﺑﻤﻘﺪار ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ ‪.‬‬ ‫•‬
‫=* ‪ :‬ﻟﻀﺮب ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﻓﻲ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ ووﺿﻊ اﻟﻨﺎﺗﺞ ﻟﯿﻜﻮن ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴ ﺮ ‪.‬‬ ‫•‬
‫=‪ : /‬ﻟﻘﺴﻤﺔ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﻋﻠﻲ ﻗﯿﻤﺔ اﻟﻄﺮ ف اﻷﻳﻤﻦ ووﺿﻊ اﻟﻨﺎﺗﺞ ﻟﯿﻜﻮن ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ‪.‬‬ ‫•‬
‫=‪ : %‬ﻟﺤﺴﺎب ﺑﺎﻗﻲ ﻗﺴﻤﺔ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﺴﺮ ﻋﻠﻲ ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ ووﺿﻊ اﻟﻨﺎﺗﺞ ﻟﯿﻜﻮن ﻗﯿﻤﺔ اﻟﻄﺮف‬ ‫•‬
‫اﻷﻳﺴﺮ ‪.‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num = 6‬‬

‫;‪num += 5‬‬
‫;) ‪alert( "num : " + num‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪52‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻻﺣﻆ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num += 5‬‬

‫وﻳﻌﻨﻲ أﺿﻒ إﻟﻲ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ num‬اﻟﻤﻘﺪار ‪ 5‬وھﺬا اﻟﺴﻄﺮ ﻳﻜﺎﻓﺊ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num = num + 5‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num = 6‬‬

‫;‪num *= 5‬‬
‫;) ‪alert( "num : " + num‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﻌﺎﻣﻼت اﻟﺘﻌﺎﻣﻞ ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪Shift & Bitwise Operators‬‬

‫ﻗﺒﻞ اﻟﺤﺪﻳﺚ ﻋﻦ ﻣﻌﺎﻣﻼت اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ دﻋﻨﻲ أﺧﺬك ﻟﻨﺮي ﻟﻤﺤﺎت ﻓﻲ ﻋﺎﻟﻢ اﻟﺜﻨﺎﺋﯿﺎت أو ﻧﻈﺎم اﻟﻌﺪ اﻟﺜﻨﺎﺋﻲ‬
‫وﻻ أﺧﻔﻲ ﻋﻠﻲ اي ﻣﺒﺘﺪأ ﻓﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﯿﺎت أو رﺑﻤﺎ اﻟﻤﺘﻮﺳﻄﯿﻦ أﻳﻀﺎ أن دﺧﻮل ھﺬا اﻟﻤﻨﻌﻄﻒ رﺑﻤﺎ ﻻ ﻳﻜﻮن ﺳﮫﻞ‬
‫وﻟﻜﻦ دﻋﻨﺎ ﻧﺘﻮﻛﻞ ﻋﻠﻲ اﷲ ﻓﮫﻮ ﺧﯿﺮا ﻣﻌﯿﻦ ‪.‬‬

‫اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ‬

‫ھﻮ أﺣﺪ أﻧﻈﻤﺔ اﻟﻌﺪ ﻣﺜﻞ اﻟﻨﻈﺎم اﻟﻌﺸﺮي اﻟﻤﻌﺘﺎد ﻟﻨﺎ ‪.‬‬
‫ﻟﻜﻦ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻳﻌﺘﻤﺪ ﻋﻠﻲ رﻗﻤﯿﻦ ﻓﻘﻂ وھﻤﺎ اﻟﻮاﺣﺪ و اﻟﺼﻔﺮ ‪.‬‬
‫وھﺬا اﻟﻨﻈﺎم اﻟﻌﺪدي ﺗﻢ إﺳﺘﺨﺪاﻣﻪ ﻟﺒﺮﻣﺠﺔ اﻟﺤﻮاﺳﺐ ﻓﻲ ﺑﺪاﻳﺎت ﺗﻄﻮﻳﺮ ﺑﺮاﻣﺞ ﻟﻠﺤﺎﺳﺒﺎت ﺑﻤﺎ ﻛﺎن ﻳﻌﺮف ﺑﻠﻐﺔ اﻷﻟﺔ‬
‫‪ machine language‬وذﻟﻚ ﻻن وﺣﺪات ﺑﻨﺎء اﻟ ﺤﺎﺳﺐ ﺗﺘﻌﺎﻣﻞ ﻓﻲ ﺣﺴﺎﺑﺎﺗﮫﺎ ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ) ﻻن اﻟﻮﺣﺪة اﻹﻟﻜﺘﺮوﻧﯿﺔ‬
‫ﻻ ﺗﺴﺘﻄﯿﻊ ﺗﻤﯿﺰ إﻻ ﺣﺎﻟﺘﺎن وھﻤﺎ وﺟﻮد إﺷﺎرة إﻟﯿﻜﺘﺮوﻧﯿﺔ ﻧﺘﯿﺠﺔ إﻏﻼق اﻟﺪاﺋﺮة اﻹﻟﻜﺘﺮوﻧﯿﺔ ‪ ،‬وﻋﺪم وﺟﻮد إﺷﺎرة ﻧﺘﯿﺠﺔ‬
‫ﻓﺘﺢ اﻟﺪاﺋﺮة اﻹﻟﻜﺘﺮوﻧﯿﺔ ( ‪.‬‬

‫ﻓﺈن ﻛﻨﺎ ﻧﺮﻳﺪ ﺗﻤﺜﯿﻞ اﻷﻋﺪاد وﻻ ﻧﻤﻠﻚ إﻻ رﻗﻤﯿﻦ ﻓﻘﻂ وھﻤﺎ ‪ ١‬واﻟـ ‪٠‬‬
‫ﻟﺬﻟﻚ ﻗﯿﺎﺳﺎ ﻋﻠﻲ ﻣﺎ ﺗﻌﻠﻤﻨﺎه ﻓﻲ اﻟﻨﻈﺎم اﻟﻌﺸﺮي ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺗﻤﺜﯿﻞ اﻟﻌﺪد ﻋﺸﺮة ﻧﻘﻮم ﺑﻌﻤﻠﯿﺔ دﻣﺞ اﻟﺮﻗﻤﯿﻦ ‪ ١‬و ‪٠‬‬
‫وﻋﻨﺪ ﺗﻤﺜﯿﻞ اﻟﻌﺪد اﻟﺤﺎدي ﻋﺸﺮ ﻧﻘﻮم ﺑﺪﻣﺞ اﻟﺮﻗﻤﯿﻦ ‪ ١‬و ‪ ١‬وھﻜﺬا ﻋﻨﺪﻣﺎ ﻧﺨﺮج ﻋﻦ ﻧﻄﺎق ﻧﻈﺎم اﻟﻌﺪ ‪.‬‬

‫وﺑﻤﺎ أن اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻻ ﻳﺘﻤﯿﺰ إﻻ ﺑﺮﻗﻤﯿﻦ ﻓﻘﻂ ﻓﻌﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺗﻤﺜﯿﻞ اﻟﻌﺪد أﺛﻨﯿﻦ ﻧﻘﻮم ﺑﺪﻣﺞ اﻟﺮﻗﻤﯿﻦ ‪ ١‬و ‪ ٠‬وھﻜﺬا‬
‫ﻓﺎﻟﻌﺪد اﻟﻌﺸﺮي ‪ ٢‬ﻳﻤﺜﻞ ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻛﻤﺎ ﻳﻠﻲ ‪١٠‬‬
‫واﻟﻌﺪد اﻟﻌﺸﺮي ‪ ٣‬ﻳﻤﺜﻞ ﻓﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻛﻤﺎ ﻳﻠﻲ ‪١١‬‬

‫‪53‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫وﺗﻮﺟﺪ أﺳﺎﻟﯿﺐ رﻳﺎﺿﯿﺔ ﻟﻦ ﻧﺘﻄﺮق ﻟﮫﺎ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺘﺤﻮﻳﻞ ﺑﯿﻦ أﻧﻈﻤﺔ اﻟﻌﺪ اﻟﻤﺨﺘﻠﻔﻪ ‪.‬‬

‫ﻣﻌﺎﻣﻼت اﻟﺘﻌﺎﻣﻞ ﺑﺎﻟﺒﺖ ‪Bitwise Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻘﯿﻤﺔ اﻟﺜﻨﺎﺋﯿﺔ ﻟﻜﻼ اﻟﻄﺮﻓﯿﻦ‬
‫وﻋﻤﻞ ﻣﻘﺎرﻧﻪ ﻣﻨﻄﻘﯿﺔ ﻟﻜﻞ ﺑﺖ ﻋﻠﻲ ﺣﺪي ﻛﻤﺎ ﺳﯿﺘﻀﺢ ﻓﯿﻤﺎ ﻳﻠﻲ ‪:‬‬

‫& ‪:‬‬ ‫•‬

‫ﺗﺘﻌﺎﻣﻞ ﻣﺜﻞ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻨﻄﻘﻲ &&‬
‫ﺑﺖ واﺣﺪ ﺗﻠﻮ اﻷﺧﺮ ‪.‬‬ ‫وﻟﻜﻦ ﺗﺘﻌﺎﻣﻞ ﻟﯿﺲ ﺑﺎﻟﻘﯿﻤﺔ اﻟﻜﻠﯿﺔ ﻟﻠﻄﺮﻓﯿﻦ وﻟﻜﻦ ﺗﺘﻢ اﻟﻤﻘﺎرﻧﺔ ﻋﻠﻲ ﻣﺴﺘﻮي اﻟﺒﺖ ‪،‬‬
‫| ‪:‬‬ ‫•‬
‫ﺗﺘﻌﺎﻣﻞ ﻣﺜﻞ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻨﻄﻘﻲ ||‬
‫ﺑﺖ واﺣﺪ ﺗﻠﻮ اﻷﺧﺮ ‪.‬‬ ‫وﻟﻜﻦ ﺗﺘﻌﺎﻣﻞ ﻟﯿﺲ ﺑﺎﻟﻘﯿﻤﺔ اﻟﻜﻠﯿﺔ ﻟﻠﻄﺮﻓﯿﻦ وﻟﻜﻦ ﺗﺘﻢ اﻟﻤﻘﺎرﻧﺔ ﻋﻠﻲ ﻣﺴﺘﻮي اﻟﺒﺖ ‪،‬‬
‫~ ‪:‬‬ ‫•‬
‫ﺗﺘﻌﺎﻣﻞ ﻣﺜﻞ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻨﻄﻘﻲ !‬
‫ﺑﺖ واﺣﺪ ﺗﻠﻮ اﻷﺧﺮ ‪.‬‬ ‫وﻟﻜﻦ ﺗﺘﻌﺎﻣﻞ ﻟﯿﺲ ﺑﺎﻟﻘﯿﻤﺔ اﻟﻜﻠﯿﺔ ﻟﻠﻄﺮﻓﯿﻦ وﻟﻜﻦ ﺗﺘﻢ اﻟﻤﻘﺎرﻧﺔ ﻋﻠﻲ ﻣﺴﺘﻮي اﻟﺒﺖ ‪،‬‬
‫^ ‪:‬‬ ‫•‬
‫ﺗﺘﻌﺎﻣﻞ ﺑﻤﻔﮫﻮم اﻟـ ‪ XOR‬ﻣﺜﻞ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻨﻄﻘﻲ || وﻟﻜﻦ‬
‫ﺳﻮف ﻳﺆدي إﻟﻲ إرﺟﺎع‬ ‫ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ ‪ true‬ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﺣﺪي ﻃﺮﻓﻲ اﻟﻤﻘﺎرﻧﺔ ﻳﺴﺎوي ‪ true‬وﻏﯿﺮ ذﻟﻚ‬
‫اﻟﻘﯿﻤﺔ ‪ false‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻘﯿﻤﺔ‬ ‫اﻟﻨﺎﺗﺞ‬

‫‪True‬‬ ‫‪True‬‬ ‫‪False‬‬
‫‪True‬‬ ‫‪False‬‬ ‫‪True‬‬
‫‪False‬‬ ‫‪True‬‬ ‫‪True‬‬
‫‪False‬‬ ‫‪False‬‬ ‫‪False‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;) ‪alert( 2 & 3‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﺗﻔﺴﯿﺮ اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪٢‬‬ ‫‪١‬‬ ‫‪٠‬‬
‫‪٣‬‬ ‫‪١‬‬ ‫‪١‬‬
‫‪٢‬‬ ‫‪١‬‬ ‫‪٠‬‬

‫ﻣﺜﺎل ‪:‬‬

‫‪alert( 2‬‬ ‫|‬ ‫;) ‪3‬‬

‫‪54‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﺗﻔﺴﯿﺮ اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪٢‬‬ ‫‪١‬‬ ‫‪٠‬‬
‫‪٣‬‬ ‫‪١‬‬ ‫‪١‬‬
‫‪٣‬‬ ‫‪١‬‬ ‫‪١‬‬

‫ﻣﺜﺎل ‪:‬‬

‫‪alert( 2‬‬ ‫^‬ ‫;) ‪3‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﺗﻔﺴﯿﺮ اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪٢‬‬ ‫‪١‬‬ ‫‪٠‬‬
‫‪٣‬‬ ‫‪١‬‬ ‫‪١‬‬
‫‪١‬‬ ‫‪٠‬‬ ‫‪١‬‬

‫أﻣﺎ ﻣﻌﺎﻣﻼت اﻹزاﺣﺔ ‪Shift Operators‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻌﻤﻞ أزاﺣﺔ ) ﺗﺤﺮﻳﻚ ( ﻟﻠﺒﺘﺎت ‪ bits‬إﻟﻲ اﻟﯿﻤﯿﻦ أو اﻟﯿﺴﺎر ﺣﺴﺐ ﻧﻮع اﻹزاﺣﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫>> ‪:‬‬ ‫•‬

‫ﺗﻘﻮم ﺑﻌﻤﻞ إزاﺣﺔ ﻧﺎﺣﯿﺔ اﻟﯿﻤﯿﻦ ﻟﻌﺪد ﻣﻦ اﻟﺒﺘﺎت ﻳﻜﺎﻓﻲء ﻣﻘﺎدر ﻗﯿﻤﺔ اﻟﻄﺮ ف اﻷﻳﻤﻦ‬
‫ﻟﻘﯿﻤﺔ اﻟﻌﺪد ﺑﺎﻟﻄﺮف اﻷﻳﺴﺮ‬
‫<< ‪:‬‬ ‫•‬
‫ﺗﻘﻮم ﺑﻌﻤﻞ إزاﺣﺔ ﻧﺎﺣﯿﺔ اﻟﯿﺴﺎر ﻟﻌﺪد ﻣﻦ اﻟﺒﺘﺎت ﻳﻜﺎﻓﻲء ﻣﻘﺎدر ﻗﯿﻤﺔ اﻟﻄﺮف اﻷﻳﻤﻦ‬
‫ﻟﻘﯿﻤﺔ اﻟﻌﺪد ﺑﺎﻟﻄﺮف اﻷﻳﺴﺮ‬

‫‪55‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num = 6 , num1 , num2‬‬

‫;‪num1 = num >> 1‬‬

‫;) ‪alert( "num1 : " + num1‬‬

‫;‪num2 = num >> 2‬‬

‫;) ‪alert( "num2 : " + num2‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫وﺗﻔﺴﯿﺮ اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻳﻤﺜﻞ اﻟﻌﺪد ‪ ٦‬ﺑﺎﻟﻌﺪد ‪ ١١٠‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪ ،‬ﻓﻌﻨﺪ إزاﺣﺔ ھﺬا اﻟﻌﺪد اﻟﺜﻨﺎﺋﻲ ﻧﺎﺣﯿﺔ اﻟﯿﻤﯿﻦ ﺑﻤﻘﺪار ﺑﺖ واﺣﺪ ﺳﻮف ﻳﺼﺒﺢ‬
‫ﻛﺎﻟﺘﺎﻟﻲ ‪ ١١‬اي ﻣﺎ ﻳﻜﺎﻓﺊ اﻟﻌﺪد ‪ ٣‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي ‪ ،‬وإذا ﺗﻢ إزاﺣﺔ ﺑﻤﻘﺪار ﺑﺖ أﺧﺮ ﺟﮫﺔ اﻟﯿﻤﯿﻦ ﻳﻜﻮن اﻟﻌﺪد ﻛﺎﻟﺘﺎﻟﻲ ‪١‬‬
‫اي ﻣﺎ ﻳﻌﺎدل ‪ ١‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي ﻛﻤﺎ ﻳﺘﻀﺢ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num = 6 , num1 , num2‬‬

‫;‪num1 = num << 1‬‬

‫;) ‪alert( "num1 : " + num1‬‬
‫‪56‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫;‪num2 = num << 2‬‬

‫;) ‪alert( "num2 : " + num2‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫وﺗﻔﺴﯿﺮ اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻳﻤﺜﻞ اﻟﻌﺪد ‪ ٦‬ﺑﺎﻟﻌﺪد ‪ ١١٠‬ﺑﺎﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ‪ ،‬ﻓﻌﻨﺪ إزاﺣﺔ ھﺬا اﻟﻌﺪد اﻟﺜﻨﺎﺋﻲ ﻧﺎﺣﯿﺔ اﻟﯿﺴﺎر ﺑﻤﻘﺪار ﺑﺖ واﺣﺪ ﺳﻮف ﻳﺼﺒﺢ‬
‫ﻛﺎﻟﺘﺎﻟﻲ ‪ ١١٠٠‬اي ﻣﺎ ﻳﻜﺎﻓﺊ اﻟﻌﺪد ‪ ١٢‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي ‪ ،‬وإذا ﺗﻢ إزاﺣﺔ ﺑﻤﻘﺪار ﺑﺖ أﺧﺮ ﺟﮫﺔ اﻟﯿﻤﯿﻦ ﻳﻜﻮن اﻟﻌﺪد‬
‫ﻛﺎﻟﺘﺎﻟﻲ ‪ ١١٠٠٠‬اي ﻣﺎ ﻳﻌﺎدل ‪ ٢٤‬ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮي‬

‫ﻣﻌﺎﻣﻼت ﺧﺎﺻﺔ‬

‫‪: ?:‬‬ ‫•‬

‫اﻟﻤﻌﺎﻣﻞ اﻟﺸﺮﻃﻲ )‪ (conditional operator‬وﻳﺴﻤﻲ أﻳﻀﺎ ﻣﻌﺎﻣﻞ ﺗﯿﺮﻧﺮي )‪(Ternary operator‬‬
‫اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻪ ‪:‬‬

‫(‬ ‫اﻟﺸﺮط‬ ‫?)‬ ‫اﻟﻘﯿﻤﺔ ﻋﻨﺪﻣﺎ ﯾﻜﻮن ﻧﺎﺗﺞ اﻟﺸﺮط ﺻﺤﯿﺤﺔ‬ ‫‪:‬‬ ‫اﻟﻘﯿﻤﺔ ﻋﻨﺪﻣﺎ ﯾﻜﻮن ﻧﺎﺗﺞ اﻟﺸﺮط ﺧﻄﺄ‬ ‫;‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 6 ,num2‬‬

‫;‪num2 = ( num1 > 3 )? 5 : 100‬‬

‫;) ‪alert( "num2 : " + num2‬‬

‫وﻷن ﻧﺎﺗﺞ اﻟﻤﻘﺎرﻧﺔ ) ‪ ( num1 > 3‬ﺳﻮف ﻳﻜﻮن ‪true‬‬

‫ﻟﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪57‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 6 ,num2‬‬

‫;‪num2 = ( num1 < 3 )? 5 : 100‬‬

‫;) ‪alert( "num2 : " + num2‬‬

‫وﻷن ﻧﺎﺗﺞ اﻟﻤﻘﺎرﻧﺔ ) ‪ ( num1 < 3‬ﺳﻮف ﻳﻜﻮن ‪false‬‬

‫ﻟﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪58‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫أوﻟﻮﻳﺔ ﺗﻨﻔﯿﺬ اﻟﻤﻌﺎﻣﻼت ‪Operator Precedence‬‬

‫ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﺟﻤﯿﻌﺎ ﺑﺎﻟﻤﺮﺣﻠﺔ اﻹﺑﺘﺪاﺋﯿﺔ أن اﻟﻌﻤﻠﯿﺎت اﻟﺮﻳﺎﺿﯿﺔ ﻣﻦ ﺟﻤﻊ و ﻃﺮح وﻗﺴﻤﺔ وﺿﺮب ﺗﺨﺘﻠﻒ أوﻟﻮﻳﺔ ﺗﻨﻔﯿﺬه‬
‫ﺣﯿﺚ أن أوﻟﻮﻳﺔ إﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﻀﺮب واﻟﻘﺴﻤﺔ أﻛﺒﺮ ﻣﻦ أوﻟﻮﻳﺔ إﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ و اﻟﻄﺮح ‪.‬‬
‫وأوﻟﻮﻳﺔ ﻋﻤﻠﯿﺎت اﻟﻀﺮب واﻟﻘﺴﻤﺔ ﻣﺘﺴﺎوﻳﺔ ‪.‬‬
‫وأﻳﻀﺎ أوﻟﻮﻳﺔ ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ واﻟﻄﺮح ﻣﺘﺴﺎوﻳﺔ ‪.‬‬
‫ﻓﺠﺰي اﷲ ﻛﻞ ﺧﯿﺮ ﻣﻦ ﻋﻠﻤﻨﺎ اﻟﻌﻠﻢ وﻧﺤﻦ ﺻﻐﺎرا ) وﺗﺎﷲ ﻣﺎ زﻟﻨﺎ ﺻﻐﺎرا وﻟﺴﻨﺎ ﺑﺼﻐﺎر ( ‪.‬‬

‫ﺗﻌﺎﻟﻲ ﻣﻌﻲ ﻧﺒﺤﺚ ھﺬه اﻟﻌﻤﻠﯿﺔ اﻟﺤﺴﺎﺑﯿﺔ‬

‫‪2 + 4 * 3‬‬

‫ﻓﻤﺎ ﻧﺘﯿﺠﺔ ھﺬه اﻟﻌﻤﻠﯿﺔ اﻟﺤﺴﺎﺑﯿﺔ ھﻞ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ‪ ١٨‬أم ‪ ١٤‬؟‬

‫ﻟﻮ ﺗﻢ ﺟﻤﻊ اﻟﺮﻗﻢ ‪ ٢‬ﻋﻠﻲ اﻟﺮﻗﻢ ‪ ٤‬ﻳﻨﺘﺞ اﻟﻌﺪد ‪ ٦‬ﺛﻢ ﻋﻨﺪ ﺿﺮب ھﺬا اﻟﺮﻗﻢ ﻓﻲ اﻟﻌﺪد ‪ ٣‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ‪ ١٨‬وﻟﻜﻦ ھﺬا ﻏﯿﺮ‬
‫ﺻﺤﯿﺢ رﻳﺎﺿﯿﺎ ﻷﻧﻨﺎ أﺟﺮﻳﻨﺎ ﻋﻤﻠﯿﺔ اﻟﺠﻤﻊ أوﻻ ﺛﻢ إﺟﺮﻳﻨﺎ ﻋﻤﻠﯿﺔ اﻟﻀﺮب ‪ ،‬وﻟﻜﻨﻨﺎ ﻋﻠﻤﻨﺎ ﻣﻦ ﻗﻠﯿﻞ أن أوﻟﻮﻳﺔ إﺟﺮاء ﻋﻤﻠﯿﺎت‬
‫اﻟﻀﺮب واﻟﻘﺴﻤﺔ أﻛﺒﺮ ﻣﻦ أوﻟﻮﻳﺔ إﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﺠﻤﻊ و اﻟﻄﺮح ‪ ،‬أي أﻧﻨﺎ ﻳﻨﺒﻐﻲ أن ﻧﻨﻔﺬ ﻋﻤﻠﯿﺔ اﻟﻀﺮب أوﻻ وﺗﻜﻮن‬
‫اﻟﺨﻄﻮات ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬
‫ﻳﺘﻢ ﺿﺮب اﻟﻌﺪد ‪ ٤‬ﻓﻲ اﻟﻌﺪد ‪ ٣‬وﻳﻨﺘﺞ ﻋﻨﻪ اﻟﻌﺪد ‪ ١٢‬ﺛﻢ ﻳﺘﻢ ﺟﻤﻌﻪ ﻋﻠﻲ اﻟﻌﺪد ‪ ٢‬وﻳﻜﻮن اﻟﻨﺎﺗﺞ ‪. ١٤‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 2 ,num2 = 4 , num3‬‬

‫;‪num3 = num1 + num2 * 3‬‬

‫;) ‪alert( "num3 : " + num3‬‬

‫و ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫وﻟﻜﻨﻨﺎ ﺗﻌﻠﻤﻨﺎ ﻣﻤﺎ درﺳﻨﺎه ﻓﻲ ﻣﻨﮫﺞ اﻟﺮﻳﺎﺿﯿﺎت أﻧﻨﺎ ﻳﻤﻜﻨﻨﺎ ﺗﻐﯿﺮ أوﻟﻮﻳﺔ ﺗﻨﻔﯿﺬ اﻟﻌﻤﻠﯿﺎت اﻟﺮﻳﺎﺿﯿﺔ ﺑﺈﺳﺘﺨﺪام ﻣﺎ ﻳﺴﻤﻲ‬
‫أﻗﻮاس اﻟﻤﺠﻤﻮﻋﺎت وﺗﻜﻮن اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ اﻟﻤﻮﺟﻮدة داﺧﻞ ھﺬه اﻷﻗﻮاس ذات أﻋﻠﻲ أوﻟﻮﻳﺔ‬
‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪59‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 2 ,num2 = 4 , num3‬‬

‫;‪num3 = (num1 + num2) * 3‬‬

‫;) ‪alert( "num3 : " + num3‬‬

‫و ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬

‫;‪num3 = (num1 + num2) * 3‬‬

‫ﻻﺣﻆ وﺟﻮد اﻷﻗﻮاس ﺣﻮل اﻟﻌﻤﻠﯿﺔ اﻟﺤﺴﺎﺑﯿﺔ ‪num1 + num2‬‬

‫ﻣﻤﺎ ﻳﺠﻌﻞ أوﻟﻮﻳﺔ إﺟﺮاء ھﺬه اﻟﻌﻤﻠﯿﺔ أﻛﺒﺮ ﻣﻦ أوﻟﻮﻳﺔ إﺟﺮاء ﻋﻤﻠﯿﺔ اﻟﻀﺮب ‪.‬‬
‫ﻓﯿﺘﻢ ﺟﻤﻊ اﻟﺮﻗﻢ ‪ ٢‬ﻋﻠﻲ اﻟﺮﻗﻢ ‪ ٤‬ﻳﻨﺘﺞ اﻟﻌﺪد ‪ ٦‬ﺛﻢ ﻋﻨﺪ ﺿﺮب ھﺬا اﻟﺮﻗﻢ ﻓﻲ اﻟﻌﺪد ‪ ٣‬ﻳﻜﻮن اﻟﻨﺎﺗﺞ ‪١٨‬‬

‫ﻣﺜﺎل ‪:‬‬

‫;‪var num1 = 2 ,num2 = 4 , num3‬‬

‫) ‪num3 = ( (num1 + num2) / 2 + 6‬‬ ‫;‪* 3‬‬

‫;) ‪alert( "num3 : " + num3‬‬

‫و ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪60‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﻌﺎﻟﺠﺔ اﻷﺧﻄﺄ ‪Exception Handling‬‬

‫رﺑﻤﺎ ﻳﺼﺎدﻓﻚ ﺣﺪوث ﺑﻌﺾ اﻟﻤﺸﺎﻛﻞ وﻻ ﺗﻜﻮن أﺧﻄﺎء ﻟﻐﻮﻳﺔ وﻣﻊ أﻧﻚ ﻟﻢ ﺗﺨﻄﺄ ﻓﻲ ﻛﻮد اﻟﺒﺮﻧﺎﻣﺞ دﻋﻨﺎ ﻧﺮي اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل ‪:‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻷﺧﻄﺎ >‪<Title‬‬ ‫ﻣﻌﺎﻟﺠﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num1 ,num2‬‬

‫;) ‪alert( num3‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﺑﻤﺎ أن اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪ num3‬ﻟﻢ ﻳﺘﻢ ﺗﻌﺮﻳﻔﺔ وﻻ إﻋﻄﺎﺋﻪ ﻗﯿﻤﺔ ﻓﻼ ﻳﻤﻜﻦ إﺳﺘﺨﺪاﻣﻪ‬
‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻛﻤﺎ ﻳﺘﻀﺢ ﻣﻦ اﻟﺮﺳﺎﻟﺔ أﻧﮫﺎ رﺳﺎﻟﺔ ‪ Error‬اي رﺳﺎﻟﺔ ﺧﻄﺄ‬

‫وﺗﺸﯿﺮ اﻟﺮﺳﺎﻟﺔ إﻟﻲ أن "‪ "num3 is undefined‬اي أن اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪ num3‬ﻏﯿﺮ ﻣﻌﺮف أو ﻏﯿﺮ ﻣﻌﺮوف ﻟﺪي‬
‫اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫‪61‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻟﻜﻦ اﻟﺴﺆال اﻷن ھﻞ ﻳﻤﻜﻦ ﺗﺠﻨﺐ وﻗﻮع اﻷﺧﻄﺄ ؟‬

‫ﻧﻌﻢ ‪ ،‬ﻳﻤﻜﻨﻚ ﺗﺠﻨﺐ ﺣﺪوث اﻷﺧﻄﺄ ﺑﺎﺳﺘﺨﺪام ﺻﯿﻐﺔ ‪ try‬و اﻟـ ‪catch‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬
‫{‪try‬‬

‫{) ‪}catch( e‬‬

‫}‬

‫ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻷﻛﻮد ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ ‪ try‬ﻓﺈذا ﺣﺪث اي ﺧﻄﺄ ﻳﻨﺘﻘﻞ اﻟﻤﻔﺴﺮ إﻟﻲ ﻣﻨﻄﻘﺔ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ‬
‫‪ catch‬وﻳﺘﻢ ﺗﺤﻤﯿﻞ ﻛﺎﺋﻦ ﻣﺨﺼﺺ ﻟﺤﻤﻞ ﻣﻮاﺻﻔﺎت ھﺬا اﻟﺨﻄﺄ ﺟﺮت اﻟﻌﺎدة ﻟﺘﺴﻤﯿﺔ ھﺬا اﻟﻤﺘﻐﯿﺮ ﺑﺎﺳﻢ ‪ e‬ﻻﻧﻪ ﻳﺪل ﻋﻠﻲ‬
‫ﺣﺪوث إﺳﺘﺜﻨﺎء ‪Exception‬‬

‫وﻟﻤﻌﺎﻟﺠﺔ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﻘﻮم ﺑﺈﻋﺎدة ﻛﺘﺎﺑﺘﺔ ﻛﺎﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل ‪:‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻷﺧﻄﺎ >‪<Title‬‬ ‫ﻣﻌﺎﻟﺠﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num1 ,num2‬‬
‫{‪try‬‬
‫;) ‪alert( num3‬‬
‫{) ‪}catch( e‬‬
‫ﺧﻄﺄ"(‪alert‬‬ ‫;)"ﺣﺪث‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪62‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻤﻜﻨﻨﺎ إﻇﮫﺎر رﺳﺎﻟﺔ اﻟﺨﻄﺄ اﻷﺳﺎﺳﯿﺔ ﺑﺈﺳﺘﺨﺪام ﺧﺼﺎﺋﺺ اﻟﻜﺎﺋﻦ ‪ e‬وﺧﺎﺋﺼﻪ ھﻲ ‪:‬‬

‫‪Name‬‬ ‫•‬
‫وﺗﻌﺒﺮ ﻋﻦ اﺳﻢ اﻟﺨﻄﺄ‬
‫‪Message‬‬ ‫•‬
‫وﺗﻌﺒﺮ ﻋﻦ ﻣﺤﺘﻮي ﻧﺺ رﺳﺎﻟﺔ اﻟﺨﻄﺄ‬
‫‪Number‬‬ ‫•‬
‫وﺗﻌﺒﺮ ﻋﻦ رﻗﻢ اﻟﺨﻄﺄ‬
‫‪Description‬‬ ‫•‬
‫وﺗﻌﺒﺮ ﻋﻦ رﺳﺎﻟﺔ ﺗﻔﺼﯿﻠﯿﺔ ﻟﻠﺨﻄﺄ‬

‫ﻧﻘﻮم ﺑﺈﻋﺎدة ﻛﺘﺎﺑﺔ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻛﺎﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل ‪:‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻷﺧﻄﺎ >‪<Title‬‬ ‫ﻣﻌﺎﻟﺠﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num1 ,num2‬‬
‫{‪try‬‬
‫;) ‪alert( num3‬‬
‫{) ‪}catch( e‬‬
‫" (‪alert‬‬ ‫‪ " +‬اﺳﻢ اﻟﺨﻄﺄ ‪:‬‬ ‫‪e.name + "\n" +‬‬
‫"‬ ‫‪ " +‬رﻗﻢ اﻟﺨﻄﺄ ‪:‬‬ ‫‪e.number + "\n" +‬‬
‫" رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪" :‬‬ ‫‪+ e.message + "\n" +‬‬
‫"وﺻﻒ اﻟﺨﻄﺄ ‪" :‬‬ ‫;) ‪+ e.description‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪63‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫إﺳﺘﺤﺪاث ﺧﻄﺄ ﺑﺈﺳﺘﺨﺪام اﻟﺠﻤﻠﺔ ‪throw‬‬

‫ﻓﻲ ﺑﻌﺾ اﻷﺣﯿﺎن ﻧﺤﺘﺎج إﻟﻲ إﺳﺘﺤﺪاث ﺧﻄﺄ ﻣﺎ ‪ ،‬وﻳﺘﻢ ذﻟﻚ ﺑﺈﺳﺘﺨﺪام اﻷﻣﺮ ‪ ، throw‬ﺑﻄﺮﻳﻘﺘﯿﻦ‬

‫أوﻟﮫﻤﺎ‬
‫ھﺬا اﻟﻤﺜﺎل ﻟﯿﺲ ﺑﻪ اي ﺧﻄﺄ وﻟﻜﻨﻨﺎ ﺳﻮف ﻧﺴﺘﺤﺪث ھﺬا اﻟﺨﻄﺄ ﻛﻤﺎ ﻳﻠﻲ‬

‫>‪<HTML dir=rtl‬‬
‫اﻷﺧﻄﺎ >‪<Title‬‬ ‫ﻣﻌﺎﻟﺠﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﺑﻚ" = ‪var helloMessage‬‬ ‫;"ﻣﺮﺣﺒﺎ‬
‫{‪try‬‬
‫;) ‪alert( helloMessage‬‬
‫ﻣﺴﺘﺤﺪث" ‪throw‬‬ ‫;" ﻫﺬا ﺧﻄﺄ ﻟﯿﺲ ﺣﻘﯿﻘﻲ وﻟﻜﻨﻪ‬
‫{) ‪}catch( e‬‬
‫" (‪alert‬‬ ‫" رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪:‬‬ ‫;) ‪+ e‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ ﻛﺘﺎﺑﺔ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ﺑﻌﺪ اﻷﻣﺮ ‪ throw‬ﻛﻤﺎ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫ﻣﺴﺘﺤﺪث" ‪throw‬‬ ‫;" ﻫﺬا ﺧﻄﺄ ﻟﯿﺲ ﺣﻘﯿﻘﻲ وﻟﻜﻨﻪ‬

‫ﻓﻌﻨﺪ ﺗﻨﻔﯿﺬ ھﺬا اﻷﻣﺮ ﻳﻨﺘﻘﻞ اﻟﻤﻔﺴﺮ إﻟﻲ اﻟﺠﻤﻠﺔ ‪ catch‬ﺣﺎﻣﻼ ﻣﻌﻪ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ﻓﻲ اﻟﻤﺘﻐﯿﺮ ‪e‬‬
‫ﺑﻌﺪھﺎ ﻗﻤﻨﺎ ﺑﻄﺒﺎﻋﺔ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ﻛﻤﺎ ﻳﻠﻲ‬

‫{) ‪}catch( e‬‬

‫" (‪alert‬‬ ‫" رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪:‬‬ ‫;) ‪+ e‬‬
‫}‬

‫‪64‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺛﺎﻧﯿﮫﻤﺎ ھﻮ ﻋﻤﻞ ﺧﻄﺄ ﻣﻦ اﻟﻜﺎﺋﻦ ‪ Error‬ﺛﻢ إرﺳﺎﻟﻪ إﻟﻲ اﻷﻣﺮ ‪throw‬‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻷﺧﻄﺎ >‪<Title‬‬ ‫ﻣﻌﺎﻟﺠﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﺑﻚ" = ‪var helloMessage‬‬ ‫;"ﻣﺮﺣﺒﺎ‬
‫{‪try‬‬
‫;) ‪alert( helloMessage‬‬
‫ﻣﺴﺘﺤﺪث"(‪var err = new Error‬‬ ‫;)" ﻫﺬا ﺧﻄﺄ ﻟﯿﺲ ﺣﻘﯿﻘﻲ وﻟﻜﻨﻪ‬
‫ﯾﺪوﯾﻦ" = ‪err.description‬‬ ‫;" ﻫﺬا ﺧﻄﺄ ﺗﻢ ﺻﻨﻌﺔ‬
‫;‪throw err‬‬
‫{) ‪}catch( e‬‬
‫" (‪alert‬‬ ‫" رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪:‬‬ ‫‪+ e.message + "\n" +‬‬
‫"‬ ‫"وﺻﻒ اﻟﺨﻄﺄ ‪:‬‬ ‫;) ‪+ e.description‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻟﻦ ﻧﺨﻮض ﻛﺜﯿﺮا ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﺣﺘﻲ ﻧﻘﻮم ﺑﺸﺮح اﻟﻜﺎﺋﻦ ‪ Error‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻣﻦ ھﺬا اﻟﻜﺘﺎب إن ﺷﺎء اﷲ‬

‫‪65‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺟﻤﻠﺔ ‪with‬‬

‫ﻋﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺈﺳﺘﺨﺪام ﺧﺼﺎﺋﺺ ‪ properties‬و أو وﻇﺎﺋﻒ ‪ functions‬ﺗﺎﺑﻌﺔ ﻟﻜﺎﺋﻦ واﺣﺪ ‪ ،‬ﻳﻤﻜﻨﻨﺎ أن ﻧﺠﻌﻞ ھﺬا اﻟﻜﺎﺋﻦ‬
‫ﻳﺸﯿﺮ إﻟﻲ ﺧﺼﺎﺋﺼﻪ و وﻇﺎﺋﻔﻪ ﺑﺪون ﺗﻜﺮار ﻛﺘﺎﺑﺘﻪ ﻗﺒﻞ ﻛﺘﺎﺑﺔ اﻟﺨﺎﺻﯿﺔ أو اﻟﻮﻇﯿﻔﺔ ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺠﻤﻠﺔ ‪with‬‬

‫(‪with‬‬ ‫{ ) اﺳﻢ اﻟﻜﺎﺋﻦ اﻟﻤﺴﺘﻬﺪف ﻋﺪم ﺗﻜﺮاره‬
‫اﻷﻛﻮاد ‪//‬‬
‫رﺑﻤﺎ ﺗﺤﺘﻮي اﻷﻛﻮاد ﻋﻠﻲ ﺧﺼﺎﺋﺺ أو وﻇﺎﺋﻒ ﻟﻬﺬا اﻟﻜﺎﺋﻦ ‪//‬‬
‫}‬

‫وﺑﺎﻟﻤﺜﺎل ﻳﺘﻀﺢ اﻟﻤﻘﺎل‬

‫ﻣﺜﺎل ‪:‬‬

‫ھﺬا اﻟﻤﺜﺎل ﺑﺪون إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪with‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪ with </Title‬ﺑﺪون ﺟﻤﻠﺔ >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻋﻠﻲ" = ‪var userName‬‬ ‫;"اﻟﺤﺴﯿﻦ ﻣﺤﻤﺪ‬

‫؟"(‪var familyName = window.prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬

‫"(‪window.alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪window.alert(" :‬‬ ‫;) ‪+ familyName‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻛﻤﺎ ﺗﺮي ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻗﺪ ﻗﻤﻨﺎ ﺑﺘﻜﺮار ﻛﺘﺎﺑﺔ اﻟﻜﺎﺋﻦ ‪ window‬ﻛﻤﺎ ﻳﻠﻲ‬

‫؟"(‪var familyName = window.prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬

‫"(‪window.alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪window.alert(" :‬‬ ‫;) ‪+ familyName‬‬

‫وﻳﻤﻜﻨﻨﺎ أن ﻧﻘﻮم ﺑﺈﻟﻐﺎء ﺗﻜﺮار ﻛﺘﺎﺑﺔ اﻟﻜﺎﺋﻦ ‪ window‬ﺑﺈﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ ‪ window‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪66‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ھﺬا اﻟﻤﺜﺎل ﺑﺈﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪with‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪ with </Title‬ﺟﻤﻠﺔ >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻋﻠﻲ" = ‪var userName‬‬ ‫;"اﻟﺤﺴﯿﻦ ﻣﺤﻤﺪ‬

‫{) ‪with( window‬‬

‫؟"(‪var familyName = prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬
‫"(‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪alert(" :‬‬ ‫;) ‪+ familyName‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﺆدي ھﺬا اﻟﻤﺜﺎل إﻟﻲ ﻧﻔﺲ اﻟﻨﺎﺗﺞ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬

‫وﻳﺘﻀﺢ ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ with‬ﺑﺎﻷﺳﻄﺮ اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫{) ‪with( window‬‬

‫؟"(‪var familyName = prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬
‫"(‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪alert(" :‬‬ ‫;) ‪+ familyName‬‬
‫}‬

‫ﻛﻤﺎ ﺗﺮي ﻟﻢ ﻧﻘﻢ ﺑﺘﻜﺮار ﻛﺘﺎﺑﺔ اﺳﻢ اﻟﻜﺎﺋﻦ ‪ ، window‬ﺑﻞ ﺗﻢ ﻛﺘﺎﺑﺘﻪ ﻣﺮة واﺣﺪة ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ ‪ with‬ﺛﻢ اي ﺧﺎﺻﯿﺔ أو‬
‫وﻇﯿﻔﺔ ﺗﺎﺑﻌﺔ ﻟﮫﺬا اﻟﻜﺎﺋﻦ ﺗﻢ ﻛﺘﺎﺑﺘﮫﺎ ﺑﯿﻦ أﻗ ﻮاس اﻟﻤﺠﻤﻮﻋﺔ ﻟﺠﻤﻠﺔ ‪ with‬ﻳﻤﻜﻨﻚ ﺗﺠﺎھﻞ ﻛﺘﺎﺑﺔ اﺳﻢ اﻟﻜﺎﺋﻦ ‪window‬‬
‫اﻟﺘﺎﺑﻊ ﻟﻪ ‪.‬‬

‫ﻣﻼﺣﻈﺔ ‪:‬‬
‫ﻳﻤﻜﻨﻚ ﻛﺘﺎﺑﺔ اﺳﻢ اﻟﻜﺎﺋﻦ وﺣﺘﻲ ﺑﻌﺪ إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ with‬وﻟﻜﻦ ھﺬا ﻳﺠﻌﻞ ﺟﻤﻠﺔ ‪ with‬ﺑﺪون ﻓﺎﺋﺪة ‪.‬‬
‫ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫{) ‪with( window‬‬

‫؟"(‪var familyName = prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬
‫"(‪window.alert‬‬ ‫;) ‪" + userName‬ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬
‫;) ‪" + familyName‬ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪alert(" :‬‬
‫}‬

‫‪67‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﺪاﺧﻞ ﺟﻤﻠﺔ ‪: with‬‬

‫ﻳﺴﻤﺢ ﺑﻌﻤﻞ ﺗﺪاﺧﻞ ‪ nesting‬ﻟﺠﻤﻞ ‪ with‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫>‪ with </Title‬ﺟﻤﻠﺔ >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻋﻠﻲ" = ‪var userName‬‬ ‫;"اﻟﺤﺴﯿﻦ ﻣﺤﻤﺪ‬

‫{) ‪with( window‬‬

‫؟"(‪var familyName = prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬
‫"(‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪alert(" :‬‬ ‫;) ‪+ familyName‬‬

‫‪//‬‬ ‫ﺗﺪاﺧﻞ ﻟﺠﻤﻞ‬ ‫‪with‬‬

‫{) ‪with( document‬‬
‫"(‪write‬‬ ‫;) ">‪ with <br‬ﻣﺮﺣﺒﺎ ﺑﻔﻜﺮة ﺗﺪاﺧﻞ ﺟﻤﻞ‬
‫"(‪writeln‬‬ ‫;)" إﻟﻲ اﻟﻠﻘﺎء ﻣﻊ اﻟﻔﺼﻞ اﻟﻘﺎدم‬
‫;) ‪ " + familyName‬إﻟﻲ اﻟﻠﻘﺎء ﻟﻌﺎﺋﻠﺔ ‪alert(" :‬‬
‫}‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻛﻤﺎ ﺗﻼﺣﻆ أﻧﻪ ﺗﻢ ﺗﺪاﺧﻞ ﺟﻤﻠﺘﯿﻦ ﻟـ ‪ with‬أﺣﺪھﻤﺎ ﻟﻠﻜﺎﺋﻦ ‪ window‬واﻷﺧﺮي ﻟﻠﻜﺎﺋﻦ ‪ document‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬
‫{) ‪with( window‬‬
‫؟"(‪var familyName = prompt‬‬ ‫;)"ﻣﺎ ﻫﻮ اﺳﻢ اﻟﻌﺎﺋﻠﺔ‬
‫"(‪alert‬‬ ‫"ﻣﺮﺣﺒﺎ ﺑﻚ ﯾﺎ ‪:‬‬ ‫;) ‪+ userName‬‬
‫"ﻣﺮﺣﺒﺎ ﺑﻌﺎﺋﻠﺔ ‪alert(" :‬‬ ‫;) ‪+ familyName‬‬

‫‪//‬‬ ‫ﺗﺪاﺧﻞ ﻟﺠﻤﻞ‬ ‫‪with‬‬

‫{) ‪with( document‬‬
‫"(‪write‬‬ ‫">‪ with <br‬ﻣﺮﺣﺒﺎ ﺑﻔﻜﺮة ﺗﺪاﺧﻞ ﺟﻤﻞ‬ ‫;)‬
‫"(‪writeln‬‬ ‫;)" إﻟﻲ اﻟﻠﻘﺎء ﻣﻊ اﻟﻔﺼﻞ اﻟﻘﺎدم‬

‫‪//‬‬ ‫‪ alert‬ﻻﺣﻆ أن ﻫﺬه اﻟﻮﻇﯿﻔﺔ‬

‫‪//‬‬ ‫ﺗﺎﺑﻌﺔ ﻟﺠﻤﻠﺔ‬
‫اﻷوﻟﻲ ‪// with‬‬
‫‪ " + familyName‬إﻟﻲ اﻟﻠﻘﺎء ﻟﻌﺎﺋﻠﺔ ‪alert(" :‬‬ ‫;)‬
‫}‬
‫}‬

‫‪68‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺨﺎﻣﺲ‬
‫ﺍﻟﺘﺤﻜﻢ ﻓﻲ ﻣﺴﺎﺭ ﺍﻟﺒﺮﻧﺎﻣﺞ‬

‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫ﺟﻤﻞ اﻟﺸﺮط ‪Conditional Statements‬‬ ‫•‬

‫ﺟﻤﻠﺔ اﻟﺸﺮط ‪if‬‬ ‫‪o‬‬
‫ﺟﻤﻠﺔ اﻟﺸﺮط ‪switch‬‬ ‫‪o‬‬

‫ﺟﻤﻞ اﻟﺘﻜﺮار واﻟﺤﻠﻘﺎت ‪Iteration Statements‬‬ ‫•‬

‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪for‬‬ ‫‪o‬‬
‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪while‬‬ ‫‪o‬‬
‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪do while‬‬ ‫‪o‬‬

‫‪69‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺟﻤﻞ اﻟﺸﺮط ‪Conditional Statements‬‬

‫داﺋﻤﺎ ﻓﻲ ﺣﯿﺎﺗﻨﺎ اﻟﻤﻌﺎﺻﺮة ﻣﺎ ﻧﺤﺘﺎج ﻹﺗﺨﺎذ ﺑﻌﺾ اﻟﻘﺮارات ھﻞ ﻧﻔﻌﻞ ﻛﺬا أم ﻛﺬا ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻗﺒﻞ أن ﺗﺒﺪأ ﻓﻲ‬
‫ﺗﻌﻠﻢ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ رﺑﻤﺎ ﺗﺒﺎدر ﻟﻚ ھﺬا اﻟﺴﺆال ھﻞ أﻧﺖ ﻓﻲ ﺣﺎﺟﺔ ﻟﺘﻌﻠﻢ ھﺬه اﻟﻠﻐﺔ ؟‬
‫وھﺬا اﻟﺴﺆال ﻳﺤﺘﻤﻞ إﺣﺪي اﻹﺟﺎﺑﺎت إﻣﺎ ﻧﻌﻢ أو ﻻ ‪ ،‬وﺑﺈﺟﺎﺑﺘﻚ ﻋﻠﻲ ھﺬا اﻟﺴﺆال ﺗﻜﻮن ﻗﺪ ﺣﺪدت ﻣﺴﺎرك ﻓﻲ اﻷﻳﺎم‬
‫اﻟﻘﺎدﻣﺔ ‪ ،‬ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻟﻮ ﻛﺎﻧﺖ إﺟﺎﺑﺘﻚ ﺑﻼ ﻟﻤﺎ إﺳﺘﻄﻌﺖ ﻗﺮأت ھﺬا اﻟﻨﺺ اﻟﻤﻜﺘﻮب ﺑﯿﻦ ﻳﺪﻳﻚ ‪ ،‬وإذا ﻛﺎﻧﺖ إﺟﺎﺑﺘﻚ‬
‫ﺑﻨﻌﻢ ﻓﺴﻮف ﺗﻜﻮن ﻣﻦ ﻗﺎرﺋﻲ ھﺬا اﻟﻨﺺ ‪.‬‬

‫ﻧﺨﻠﺺ ﻣﻤﺎ ﺳﺒﻖ إﻟﻲ أﻧﻨﺎ داﺋﻤﺎ ﻣﺎ ﺗﻄﺮح أﻣﺎﻣﻨﺎ إﺧﺘﯿﺎرات ﻧﺤﺘﺎج ﻟﻮﺿﻌﮫﺎ ﻓﻲ ﺟﻤﻞ ﺷﺮط وھﺬه اﻟﺠﻤﻠﺔ ﺗﺤﺪد اﻟﻤﺴﺎر‬
‫ﺣﺴﺐ اﻹﺧﺘﯿﺎر ‪ ،‬ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻟﺠﻤﻠﺔ اﻟﺸﺮط‬
‫ھﻞ ﺗﺮﻳﺪ أن ﺗﺘﻌﻠﻢ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ؟ وﻟﯿﺲ أﻣﺎﻣﻚ إﻻ إﺧﺘﯿﺎران أﺣﺪھﻤﺎ ﻧﻌﻢ واﻷﺧﺮ ﻻ‬
‫ﻓﻌﻨﺪﻣﺎ ﺗﻘﻮل ﻧﻌﻢ ﻓﺴﻮف ﺗﺠﻨﻲ ﺛﻤﺎر ﻣﺎ ﺗﻌﻠﻤﺖ إن ﺷﺎء اﷲ ﻓﻤﻦ ﺟﺪ وﺟﺪ ‪ ،‬وإذا ﻛﺎن اﻟﺨﯿﺎر ﺑﻼ ﻓﻼ ﺗﻠﻮﻣﻨﺎ إﻻ ﻧﻔﺴﻚ‬
‫ﻟﺘﻔﺮﻳﻄﻚ ﻓﻲ أﺧﺬ اﻟﻌﻠﻢ اﻟﻨﺎﻓﻊ ‪.‬‬

‫ﺟﻤﻠﺔ اﻟﺸﺮط ‪if‬‬

‫ﻣﻦ أﺷﮫﺮ ﺟﻤﻞ اﻟﺸﺮط اﻟﺠﻤﻠﺔ ‪ if‬وﺗﺴﺘﺨﺪم ﻟﻌﻤﻞ ﺗﻔﺮﻳﻊ ﺑﻤﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺠﻤﻠﺔ اﻟﺸﺮط ‪if‬‬

‫ﺗﻮﺟﺪ ﻋﺪة ﺻﯿﻎ ﻟﺠﻤﻠﺔ اﻟﺸﺮط ‪ if‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻔﺮدﻳﺔ ‪: if‬‬

‫وﻓﯿﻪ ﻳﺘﻢ ﺣﺴﺎب ﻗﯿﻤﺔ ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﺈذا ﻛﺎﻧﺖ ﺟﻤﻠﺔ اﻟﺸﺮط ﺗﻜﺎﻓﻲ اﻟﻘﯿﻤﺔ ‪) true‬أو اي ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﻏﯿﺮ اﻟﺼﻔﺮ أو‬
‫اي ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻏﯿﺮ ﻗﯿﻤﺔ اﻟﻨﺺ اﻟﻔﺎرغ أو اﻟﻘﯿﻤﺔ ‪ ، ( null‬ﻓﻌﻨﺪﺋﺬ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪، if‬‬
‫وإذا ﻛﺎﻧﺖ ﺗﻜﺎﻓﺊ اﻟﻘﯿﻤﺔ ‪ ) false‬أو اﻟﻘﯿﻤﺔ اﻟﻌﺪدﻳﺔ ﺻﻔﺮ أو اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻔﺎرﻏﺔ ( ﺳﻮف ﻳﺘﻢ ﺗﺠﺎھﻞ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد‬
‫ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪.‬‬

‫(‪if‬‬ ‫{ ) ﺟﻤﻠﺔ اﻟﺸﺮط‬

‫اﻷﻛﻮاد ‪//‬‬
‫}‬

‫ﻣﺜﺎل‬
‫;‪var num = 78‬‬
‫{ ) ‪if( num >= 50‬‬
‫" (‪alert‬‬ ‫اﻟﻤﺘﻐﯿﺮ‬ ‫‪num = " + num + "\n‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪٥٠‬‬ ‫"‬ ‫;)‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪70‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﺼﯿﻐﺔ اﻟﻤﺰدوﺟﺔ ‪: if ... else‬‬

‫وﻓﯿﻪ ﻳﺘﻢ ﺣﺴﺎب ﻗﯿﻤﺔ ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﺈذا ﻛﺎﻧﺖ ﺟﻤﻠﺔ اﻟﺸﺮط ﺗﻜﺎﻓﻲ اﻟﻘﯿﻤﺔ ‪) true‬أو اي ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﻏﯿﺮ اﻟﺼﻔﺮ أو‬
‫اي ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻏﯿﺮ ﻗﯿﻤﺔ اﻟﻨﺺ اﻟﻔﺎرغ أو اﻟﻘﯿﻤﺔ ‪ ، ( null‬ﻓﻌﻨﺪﺋﺬ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪، if‬‬
‫وإذا ﻛﺎﻧﺖ ﺗﻜﺎﻓﺊ اﻟﻘﯿﻤﺔ ‪ ) false‬أو اﻟﻘﯿﻤﺔ اﻟﻌﺪ دﻳﺔ ﺻﻔﺮ أو اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻔﺎرﻏﺔ ( ﺳﻮف ﻳﺘﻢ ﺗﺠﺎھﻞ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد‬
‫ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪ if‬ﺛﻢ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد اﻟﻤﻨﺤﺼﺮة ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ ‪. else‬‬

‫(‪if‬‬ ‫{ ) ﺟﻤﻠﺔ اﻟﺸﺮط‬

‫اﻷﻛﻮاد ‪//‬‬
‫{‪}else‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫}‬

‫ﻣﺜﺎل‬
‫;‪var num = 18‬‬
‫{ ) ‪if( num >= 50‬‬
‫" (‪alert‬‬ ‫اﻟﻤﺘﻐﯿﺮ‬ ‫‪num = " + num + "\n‬‬ ‫أﻛﺒﺮ ﻣﻦ أو ﯾﺴﺎوي ‪٥٠‬‬ ‫"‬ ‫;)‬
‫{‪}else‬‬
‫" (‪alert‬‬ ‫اﻟﻤﺘﻐﯿﺮ‬ ‫‪num = " + num + "\n‬‬ ‫أﻗﻞ ﻣﻦ ‪٥٠‬‬ ‫"‬ ‫;)‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺼﯿﻐﺔ اﻟﻤﺮﻛﺒﺔ ‪:‬‬

‫وﻓﯿﻪ ﻳﺘﻢ ﺣﺴﺎب ﻗﯿﻤﺔ ﺟﻤﻠﺔ اﻟﺸﺮط اﻷوﻟﻲ ﻓﺈذا ﻛﺎﻧﺖ ﺟﻤﻠﺔ اﻟﺸﺮط ﺗﻜﺎﻓﻲ اﻟﻘﯿﻤﺔ ‪) true‬أو اي ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﻏﯿﺮ‬
‫اﻟﺼﻔﺮ أو اي ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻏﯿﺮ ﻗﯿﻤﺔ اﻟﻨﺺ اﻟﻔﺎرغ أو اﻟﻘﯿﻤﺔ ‪ ، ( null‬ﻓﻌﻨﺪﺋﺬ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪if‬‬
‫‪ ،‬وإذا ﻛﺎﻧﺖ ﺗﻜﺎﻓﺊ اﻟﻘﯿﻤﺔ ‪ ) false‬أو اﻟﻘﯿﻤﺔ اﻟﻌﺪدﻳﺔ ﺻﻔﺮ أو اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻔﺎرﻏﺔ ( ﺳﻮف ﻳﺘﻢ ﺗﺠﺎھﻞ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد‬
‫ﺑﯿﻦ أﻗ ﻮاس ﺟﻤﻠﺔ اﻟﺸﺮط ‪ if‬ﺛﻢ ﻳﻨﺘﻘﻞ أﻟﻲ ﺟﻤﻠﺔ اﻟﺸﺮط اﻟﺘﺎﻟﯿﺔ وﻳﻔﻌﻞ ﻣﻌﮫﺎ ﻣﺜﻞ ﻣﺎ ﺳﺒﻖ ﻓﺈذا ﻛﺎﻧﺖ ﻛﻞ ﺟﻤﻞ اﻟﺸﺮط‬
‫ﺗﺆول إﻟﻲ ‪ false‬ﻓﺴﻮف ﻳﺘﻢ اﻟﺒﺤﺚ ﻋﻦ ﺟﻤﻠﺔ ‪ else‬ﻓﺈن وﺟﺪت ﻓﺴﻮف ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد اﻟﻤﻨﺤﺼﺮة ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ‬
‫‪ else‬وإن ﻟﻢ ﻳﺠﺪ ﺟﻤﻠﺔ ‪ else‬ﻓﻠﻦ ﻳﺘﻢ ﺗﻨﻔﯿﺬ ﺷﺊ‪.‬‬

‫(‪if‬‬ ‫{ ) ﺟﻤﻠﺔ اﻟ ﺸﺮط رﻗﻢ ‪١‬‬

‫اﻷﻛﻮاد ‪//‬‬
‫ﺟﻤﻠﺔ اﻟﺸﺮط رﻗﻢ ‪else if( ٢‬‬ ‫{ )‬
‫اﻷﻛﻮاد ‪//‬‬
‫{‪}else‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫}‬

‫‪71‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫أ و ﺑﺪون ‪ else‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫(‪if‬‬ ‫{ ) ﺟﻤﻠﺔ اﻟﺸﺮط رﻗﻢ ‪١‬‬
‫اﻷﻛﻮاد ‪//‬‬
‫ﺟﻤﻠﺔ اﻟﺸﺮط رﻗﻢ ‪else if( ٢‬‬ ‫{ )‬
‫اﻷﻛﻮاد ‪//‬‬
‫}‬

‫ﻣﺜﺎل‬
‫;‪var num = 48‬‬

‫{ ) ‪if( num >= 1 && num <= 10‬‬

‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"ﻣﺤﺼﻮر ﺑﯿﻦ ‪ ١‬و ‪١٠‬‬ ‫;)‬
‫‪}else if( num > 10‬‬ ‫{) ‪&& num <=20‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"أﻛﺒﺮ ﻣﻦ ‪ ١٠‬وأﻗﻞ ﻣﻦ أو ﺗﺴﺎوي‪٢٠‬‬ ‫;)‬
‫‪}else if( num > 20‬‬ ‫{) ‪&& num <=30‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"أﻛﺒﺮ ﻣﻦ ‪ ٢٠‬وأﻗﻞ ﻣﻦ أو ﺗﺴﺎوي‪٣٠‬‬ ‫;)‬
‫{‪}else‬‬
‫‪ num \n‬اﻟﻌﺪد" (‪alert‬‬ ‫"أﻛﺒﺮ ﻣﻦ ‪٣٠‬‬ ‫;)‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺜﺎل‬
‫ھﻮ ﻧﻔﺲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﺑﺪون ﺟﻤﻠﺔ ‪else‬‬
‫;‪var num = 48‬‬

‫{ ) ‪if( num >= 1 && num <= 10‬‬

‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"ﻣﺤﺼﻮر ﺑﯿﻦ ‪ ١‬و ‪١٠‬‬ ‫;)‬
‫‪}else if( num > 10‬‬ ‫{) ‪&& num <=20‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"أﻛﺒﺮ ﻣﻦ ‪ ١٠‬وأﻗﻞ ﻣﻦ أو ﺗﺴﺎوي‪٢٠‬‬ ‫;)‬
‫‪}else if( num > 20‬‬ ‫{) ‪&& num <=30‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"أﻛﺒﺮ ﻣﻦ ‪ ٢٠‬وأﻗﻞ ﻣﻦ أو ﺗﺴﺎوي‪٣٠‬‬ ‫;)‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻟﻦ ﻳﺘﻢ ﻇﮫﻮر اي رﺳﺎﺋﻞ ﻟﻌﺪم ﺗﺤﻘﻖ اي ﻣﻦ اﻟﺸﺮوط اﻟﺴﺎﺑﻘﺔ ‪.‬‬

‫‪72‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﺮﯾﻦ ﻟﻠﻜﺸﻒ ﻋﻦ ﻛﻠﻤﺔ اﻟﺴﺮ‬

‫>‪<HTML dir=rtl‬‬
‫ﻛﻠﻤﺔ اﻟﺴﺮ >‪<Title‬‬ ‫اﻟﻜﺸﻒ ﻋﻦ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;"‪var userPassword = "123‬‬

‫اﻟﺴﺮ"(‪var password = prompt‬‬ ‫‪",‬أدﺧﻞ ﻛﻠﻤﺔ‬ ‫;)""‬

‫{) ‪if( password == userPassword‬‬
‫ﯾﺎ" (‪alert‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ‬ ‫‪\n‬‬ ‫"ﻛﻠﻤﺔ ﺳﺮ ﺻﺤﯿﺤﺔ‬ ‫;)‬
‫{‪}else‬‬
‫ﺻﺤﯿﺤﺔ" (‪alert‬‬ ‫"ﻛﻠﻤﺔ اﻟﺴﺮﻏﯿﺮ‬ ‫;)‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﺑﻌﺪ إدﺧﺎل ﻛﻠﻤﺔ اﻟﺴﺮ ﺑﻘﯿﻤﺔ ‪ ١٢‬ﺛﻢ اﻟﻀﻐﻂ ﻋﻠﻲ زرار ‪ ok‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﺑﻌﺪ إدﺧﺎل ﻛﻠﻤﺔ اﻟﺴﺮ ﺑﻘﯿﻤﺔ ‪ ١٢٣‬ﺛﻢ اﻟﻀﻐﻂ ﻋﻠﻲ زرار ‪ ok‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪73‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺣﺎول أن ﺗﺮﻛﺰ ﻓﻲ اﻷﻣﺜﻠﺔ اﻟﻘﺎدﻣﺔ ‪:‬‬

‫ﻣﺜﺎل‬

‫;‪var num = 4‬‬

‫{ ) ‪if( ++num == 5‬‬

‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"ﯾﺴﺎوي ‪٥‬‬ ‫;)‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺜﺎل‬

‫;‪var num = 4‬‬

‫{ ) ‪if( num++ == 5‬‬

‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"ﯾﺴﺎوي ‪٥‬‬ ‫;)‬
‫{‪}else‬‬
‫;) ‪alert( "num = " + num‬‬
‫}‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪74‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺟﻤﻠﺔ اﻟﺸﺮط ‪switch‬‬

‫ﺗﺴﺘﺨﺪم ﺟﻤﻠﺔ اﻟﺸﺮط ‪ switch‬ﻣﺜﻞ إﺳﺘﺨﺪاﻣﻨﺎ ﻟﺠﻤﻠﺔ اﻟﺸﺮط ‪ if‬اﻟﻤﺰدوﺟﺔ أو اﻟﻤﺮﻛﺒﺔ ‪ ،‬إذا ﻣﺎ داﻣﺖ ﺗﺆدي ﻧﻔﺲ‬
‫وﻇﯿﻔﺔ اﻟﺠﻤﻠﺔ ‪ if‬ﻓﻤﺎ اﻟﺤﺎﺟﺔ إﻟﯿﮫﺎ ‪ ،‬ﻧﻌﻢ أﻧﺖ ﻋﻠﻲ ﺣﻖ ﻟﻜﻨﻨﺎ ﻧﺤﺘﺎج إﻟﻲ ﺟﻤﻠﺔ ‪ switch‬اﻟﺸﺮﻃﯿﺔ ﺑﺪﻻ ﻣﻦ‬
‫ﺟﻤﻠﺔ ‪ if ... else‬ﻟﺘﺴﮫﯿﻞ ﺷﻜﻞ اﻟﻜﻮد ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫(‪switch‬‬ ‫اﻟﻤﺘﻐﯿﺮ أو اﻟﻌﻤﻠﯿﺔ اﻟﻤﺮاد ﻣﻘﺎرﻧﺘﻬﺎ‬ ‫{ )‬

‫‪case "١‬‬ ‫‪" :‬ﻗﯿﻤﺔ‬
‫اﻷﻛﻮاد ‪//‬‬
‫;‪break‬‬
‫‪case "٢‬‬ ‫"ﻗﯿﻤﺔ‬ ‫‪:‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫;‪break‬‬
‫‪case "٣‬‬ ‫"ﻗﯿﻤﺔ‬ ‫‪:‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫;‪break‬‬
‫‪default :‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫}‬

‫أ و ﺑﺪون ‪ default‬ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫(‪switch‬‬ ‫اﻟﻤﺘﻐﯿﺮ أو اﻟﻌﻤﻠﯿﺔ اﻟﻤﺮاد ﻣﻘﺎرﻧﺘﻬﺎ‬ ‫{ )‬

‫‪case "١‬‬ ‫‪" :‬ﻗﯿﻤﺔ‬
‫اﻷﻛﻮاد ‪//‬‬
‫;‪break‬‬
‫‪case "٢‬‬ ‫"ﻗﯿﻤﺔ‬ ‫‪:‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫;‪break‬‬
‫‪case "٣‬‬ ‫"ﻗﯿﻤﺔ‬ ‫‪:‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫;‪break‬‬
‫}‬

‫ﻳﺘﻢ ﻣﻘﺎرﻧﺔ اﻟﻤﺘﻐﯿﺮ أو اﻟﻌﻤﻠﯿﺔ اﻟﻤﺮاد ﻣﻘﺎرﻧﺘﮫﺎ ﺑﺎﻟﻘﯿﻢ اﻟﻤﻮﺟﻮدة ﺑﺤﺎﻻت )‪ ( cases‬ﺟﻤﻠﺔ ‪ switch‬ﻓﺈذا ﺗﺴﺎوت‬
‫إﺣﺪاھﻤﺎ ﻣﻊ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ اﻟﻤﻘﺎرن ﻳﺘﻢ اﻟﺪﺧﻮل داﺧﻞ ھﺬة اﻟﺤﺎﻟﺔ ‪ case‬وﺗﻨﻔﯿﺬ اﻷﻛﻮاد اﻟﺘﻲ ﺑﺪاﺧﻠﮫﺎ ‪ ،‬وإن ﻟﻢ ﻳﺘﻢ‬
‫ﺗﺴﺎوي اﻟﻘﯿﻤﺔ اﻟﻤﻘﺎرﻧﺔ ﺑﺎي ﻣﻦ ﺣﺎﻻت ﺟﻤﻠﺔ ‪ switch‬ﻳﺘﻢ اﻟﺒﺤﺚ ﻋﻦ اﻟﺤﺎﻟﺔ اﻟﺨﺎﺻﺔ ‪ default‬ﻓﺈذا وﺟﺪت ﻳﺘﻢ اﻟﺪﺧﻮل‬
‫ﻓﯿﮫﺎ ﺛﻢ ﺗﻨﻔﺬ اﻷﻛﻮاد اﻟﻤﻮﺟﻮدة ﺑﮫﺎ ‪.‬‬

‫ﻣﻼﺣﻈﺔ ‪:‬‬
‫ﻟﺘﻔﺎدي ﺣﺪوث ﻋﻤﻠﯿﺔ اﻟﺴﻘﻮط أو ﻣﺎ ﻳﺴﻤﻲ ﺑﻲ ‪ fall through‬ﻳﺠﺐ وﺿﻊ اﻷﻣﺮ ‪ break‬ﺣﺘﻲ ﺗﻨﮫﻲ ﺟﻤﻠﺔ ‪. switch‬‬
‫وﻟﻜﻦ ﻓﻲ ﺑﻌﺾ اﻷﺣﯿﺎن ﻧﺤﺘﺎج ﻟﻌﺪم ﺗﻼﻓﻲ ﻋﻤﻠﯿﺔ اﻟﺴﻘﻮط ﻛﻤﺎ ﺳﻨﺮي ﺑﺎﻷﻣﺜﻠﺔ اﻟﻘﺎدﻣﺔ ‪.‬‬

‫‪75‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل‬

<HTML dir=rtl>
<Title> ‫اﻟﺸﺮط‬ ‫ﺟﻤﻠﺔ‬ switch </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var num = 4;

switch( num ) {
case 1 :
alert( " ‫اﻟﻌﺪد‬ num \n ١ ‫"ﯾﺴﺎوي‬ );
break;
case 2 :
alert( " ‫اﻟﻌﺪد‬ num \n ٢ ‫"ﯾﺴﺎوي‬ );
break;
case 3 :
alert( " ‫اﻟﻌﺪد‬ num \n ٣ ‫"ﯾﺴﺎوي‬ );
break;
case 4 :
alert( " ‫اﻟﻌﺪد‬ num \n ٤ ‫"ﯾﺴﺎوي‬ );
break;
default :
alert( " ‫اﻟﻌﺪد‬ num \n ‫ﯾﺴﺎوي‬ " + num );
break;
}
//-->
</SCRIPT>
</HEAD>
</HTML>

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

76
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺸﺮط >‪<Title‬‬ ‫ﺟﻤﻠﺔ‬ ‫>‪switch </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num = 4‬‬

‫{ ) ‪switch( num‬‬
‫‪case 1 , 2 , 3 , 4:‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"رﺑﻤﺎ ﯾﺴﺎوي ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪٤‬‬ ‫;)‬
‫;‪break‬‬
‫‪default :‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫ﯾﺴﺎوي‬ ‫;) ‪" + num‬‬
‫;‪break‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻛﻤﺎ ﺗﻼﺣﻆ ﺑﺎﻟﺴﻄﺮ ذو اﻟﻠﻮن اﻷﺣﻤﺮ‬

‫ﻳﺘﻢ دﺧﻮل ھﺬه اﻟﺤﺎﻟﺔ إذا ﺗﺴﺎوت اﻟﻘﯿﻤﺔ ‪ num‬ﺑﺈﺣﺪي اﻟﻘﯿﻢ ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪٤‬‬
‫{ ) ‪switch( num‬‬
‫‪case 1 , 2 , 3 , 4:‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"رﺑﻤﺎ ﯾﺴﺎوي ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪٤‬‬ ‫;)‬
‫;‪break‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺘﺎﻟﻲ ‪:‬‬

‫أن ھﺬه اﻟﺤﺎﻟﺔ ﺗﻜﺎﻓﻲء اﻟﺘﺎﻟﻲ ‪:‬‬
‫{ ) ‪switch( num‬‬
‫‪case 1 :‬‬
‫‪case 2 :‬‬
‫‪case 3 :‬‬
‫‪case 4 :‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"رﺑﻤﺎ ﯾﺴﺎوي ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪٤‬‬ ‫;)‬
‫;‪break‬‬

‫‪77‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺸﺮط >‪<Title‬‬ ‫ﺟﻤﻠﺔ‬ ‫>‪switch </Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var num = 4‬‬

‫{ ) ‪switch( num‬‬
‫‪case 1 :‬‬
‫‪case 2 :‬‬
‫‪case 3 :‬‬
‫‪case 4 :‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫"رﺑﻤﺎ ﯾﺴﺎوي ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪٤‬‬ ‫;)‬
‫;‪break‬‬
‫‪default :‬‬
‫" (‪alert‬‬ ‫اﻟﻌﺪد‬ ‫‪num \n‬‬ ‫ﯾﺴﺎوي‬ ‫;) ‪" + num‬‬
‫;‪break‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وھﻨﺎ ﻟﻢ ﻧﻀﻊ اﻟﺠﻤﻠﺔ ‪ break‬ﻟﺘﻔﺎدي ﺣﺪوث ﻋﻤﻠﯿﺔ اﻟﺴﻘﻮط ‪ fall through‬ﺑﻞ أردﻧﺎ إﺣﺪاث ھﺬا اﻟﺴﻘﻮط ‪ ،‬و إذا‬
‫ﺗﺼﺎدف ﺗﺴﺎوي اﻟﻘﯿﻤﺔ ‪ num‬ﺑﺈﺣﺪي اﻟﻘﯿﻢ ‪ ١‬أو ‪ ٢‬أو ‪ ٣‬أو ‪ ٤‬ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﯿﺬ ﻧﻔﺲ ﻗﻄﻌﺔ اﻟﻜﻮد ‪.‬‬

‫ﻓﺈذا ﻛﺎﻧﺖ اﻟﻘﯿﻤﺔ ‪ num‬ﺗﺴﺎوي اﻟﻘﯿﻤﺔ ‪ ، ٢‬ﺳﻮف ﻳﺘﻢ اﻟﺴﻘﻮط إﻟﻲ اﻟﺤﺎﻟﺔ ‪ ٣‬ﻷن اﻟﺤﺎﻟﺔ ‪ ٢‬ﻻ ﻳﻮﺟﺪ ﺑﮫﺎ اﻷﻣﺮ ‪، break‬‬
‫ﺛﻢ ﻳﺤﺪث ﺳﻘﻮط أﺧﺮ إﻟﻲ اﻟﺤﺎﻟﺔ ‪ ٤‬ﻷن اﻟﺤﺎﻟﺔ ‪ ٣‬ﻟﯿﺲ ﺑﮫﺎ اﻷﻣﺮ ‪ break‬اﻟﺨﺎص ﺑﺈﻧﮫﺎء ﺗﻨﻔﯿﺬ ﺟﻤﻠﺔ ‪ ، switch‬ﺛﻢ ﻳﺘﻢ‬
‫ﺗﻨﻔﯿﺬ اﻟﻜﻮد اﻟﻤﻮﺟﻮد ﺑﺎﻟﺤﺎﻟﺔ ‪ ، ٤‬ﺛﻢ ﻳﺘﻢ إﻧﮫﺎء اﻟﺠﻤﻠﺔ ‪ switch‬ﻧﺘﯿﺠﺔ وﺟﻮد اﻷﻣﺮ ‪ break‬ﺑﺎﻟﺤﺎﻟﺔ ‪. ٤‬‬

‫‪78‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺟﻤﻞ اﻟﺘﻜﺮار واﻟﺤﻠﻘﺎت ‪Iteration Statements‬‬

‫اﻟﮫﺪف ﻣﻦ ﺟﻤﻞ اﻟﺘﻜﺮار ھﻮ ﺗﻜﺮار ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻛﻮاد ﻟﻌﺪد أو ﻣﺪي ﻣﻌﯿﻦ ﻣﻦ اﻟﻤﺮات ‪.‬‬

‫ھﺐ أﻧﻨﻲ ﻃﻠﺒﺖ ﻣﻨﻚ أن ﺗﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﯿﺔ "أن ﻣﺤﺘﺎج ﻟﺠﻤﻞ اﻟﺘﻜﺮار" ﺛﻼث ﻣﺮات ﻓﺴﻮف ﺗﻘﻮل ﻟﻲ ھﺬا‬
‫أﻣﺮ ﺳﮫﻞ ‪ ،‬ﻧﻌﻢ ﺳﻮف أﺻﺪﻗﻚ وﻟﻜﻦ ﻣﺎذا ﻟﻮ زادت ﻣﺮات اﻟﺘﻜﺮار إﻟﻲ ‪ ١٠٠٠‬ﻣﺮة ﻣﺜﻼ أو إﻟﻲ ﻋﺪد ﻣﻦ اﻟﻤﺮات ﻏﯿﺮ ﻣﺤﺪد‬
‫ﻳﺘﻮﻗﻒ ﻋﻠﻲ ﺷﺮط ﻣﺎ ﻛﻤﺎ ﺳﻨﺮي ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻠﻲ ﺟﻤﻞ اﻟﺘﻜﺮار ﻋﻠﻲ ﺣﺪا ‪.‬‬

‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪for‬‬

‫اﻟﮫﺪف ﻣﻦ ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪ for‬ھﻮ ﺗﻜﺮار ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻛﻮاد ﻟﻌﺪد ﻣﻌﯿﻦ ﻣﻦ اﻟﻤﺮات ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫( ‪for‬‬ ‫ﺷﺮط اﻟﺘﻜﺮار ; ﻛﻮد اﻟﺒﺪاﯾﺔ‬ ‫;‬ ‫إﺟﺮاء زﯾﺎدة أو ﻧﻘﺺ‬ ‫{ )‬

‫اﻷﻛﻮاد ‪//‬‬
‫}‬

‫ﻣﺜﺎل‬
‫ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﺠﻤﻮع اﻷرﻗﺎم ﻣﻦ ‪ ١‬إﻟﻲ ‪٤‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪<Title‬‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻤﻠﺔ‬ ‫>‪for</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var x = 0‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫;)‪alert("1 + 2 + 3 + 4 = " + x‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪79‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻋﻨﺪ ﺗﻨﻔﯿﺬ ﺟﻤﻠﺔ ‪ for‬ﻳﺘﻢ ﺗﻨﻔﯿﺬ ﺟﻤﻠﺔ اﻟﺒﺪاﻳﺔ أول ﻣﺮة ﻓﻘﻂ ‪.‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺣﺴﺎب ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﺈذا ﻛﺎﻧﺖ ﺗﺴﺎوي ‪ true‬ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ ‪. for‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ ‪. for‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺣﺴﺎب ﺟﻤﻠﺔ اﻟﺰﻳﺎدة أو اﻟﻨﻘﺺ ‪.‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺣﺴﺎب ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﺈذا ﻛﺎﻧﺖ ﺗﺴﺎوي ‪ true‬ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮاد ﺑﯿﻦ أﻗﻮاس اﻟﺠﻤﻠﺔ ‪. for‬‬

‫{ ) ‪for( i=0; i<5 ; i++‬‬

‫;‪x += i‬‬
‫}‬

‫وھﻜﺬا ﺣﺘﻲ ﺗ ﺴﺎوي ﺟﻤﻠﺔ اﻟﺸﺮط ‪ false‬ﻓﺘﻨﺘﮫﻲ ھﺬة اﻟﺤﻠﻘﺔ ‪.‬‬

‫ﻣﺜﺎل‬
‫ﻣﺜﻞ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﺑﻌﺪم وﺿﻊ ﺟﻤﻠﺔ اﻟﺸﺮط ﻟﺠﻤﻠﺔ ‪for‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪<Title‬‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻤﻠﺔ‬ ‫>‪for</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var x = 0‬‬

‫{ ) ‪for( i=0; ; i++‬‬

‫;‪x += i‬‬
‫;‪if( i == 4 ) break‬‬
‫}‬

‫;)‪alert("1 + 2 + 3 + 4 = " + x‬‬

‫>‪//--‬‬
‫‪80‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬

‫ﻻﺣﻆ أﻧﻪ ﻻ ﺗﻮﺟﺪ ﺟﻤﻠﺔ ﺷﺮط ﻟﺠﻤﻠﺔ ‪ for‬وﻟﻜﻦ ﻳﻮﺟﺪ داﺧﻞ ﻛﻮد ﺟﻤﻞ اﻟﺘﻜﺮار أﺣﺪ ﺟﻤﻞ اﻟﺸﺮط ﺑﮫﺎ ﻛﻮد ﻳﺆدي إﻟﻲ إﻧﮫﺎء‬
‫دورة ﺟﻤﻠﺔ ‪. for‬‬

‫ﻛﻤﺎ ﺑﺎﻟﺴﻄﻮر اﻟﺘﺎﻟﯿﺔ‬

‫{ ) ‪for( i=0; ; i++‬‬

‫;‪x += i‬‬
‫;‪if( i == 4 ) break‬‬
‫}‬

‫ﺟﻤﻠﺔ ‪for in‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻌﻤﻞ ﺗﻜﺮار ﻟﻠﻤﺘﻐﯿﺮات ﻣﻦ اﻟﻨﻮع اﻟﻜﺎﺋﻨﻲ ‪ objects‬ﻣﺜﻞ اﻟﻤﺼﻔﻮﻓﺎت ‪Arrays‬‬
‫وﺳﻮف ﻧﺘﺤﺪث ﻋﻨﮫﺎ ﻓﻲ اﻟﺠﺰء اﻟﺜﺎﻧﻲ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫( ‪for‬‬ ‫اﻟﻤﺘﻐﯿﺮ‬ ‫)اﻟﻜﺎﺋﻦ ‪in‬‬ ‫{‬

‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫}‬

‫ﺟﻤﻠﺔ ‪break‬‬
‫ﺗﺴﺘﺨﺪم ﻹﻧﮫﺎء ﺟﻤﻞ اﻟﺘﻜﺮار ﻣﺜﻞ ﺟﻤﻞ ‪ for‬و ﺟﻤﻞ ‪ while‬وﺟﻤﻞ ‪do while‬‬

‫ﺟﻤﻠﺔ ‪continue‬‬
‫ﺗﺴﺘﺨﺪم ﻟﻠﺮﺟﻮع ﻣﺮة أﺧﺮي إﻟﻲ ﺟﻤﻠﺔ اﻟﺸﺮط اﻟﻤﺤﺪدة ﻟﻌﻤﻠﯿﺔ اﻟﺘﻜﺮار ‪ ،‬وإﻟﻐﺎء ﺗﻨﻔﯿﺬ اﻷﻛﻮاد اﻟﺘﺎﻟﯿﺔ ﻟﮫﺎ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل‬
‫اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل‬
‫ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﺠﻤﻮع اﻷرﻗﺎم اﻟﻔﺮدﻳﺔ ﺑﯿﻦ ‪ ١‬و ‪١٠‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪<Title‬‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻤﻠﺔ‬ ‫>‪for</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var x = 0‬‬

‫{ ) ‪for( i=1; i<10 ; i++‬‬

‫;‪if( i % 2 == 0 ) continue‬‬
‫;‪x += i‬‬
‫}‬

‫‪81‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫;)‪alert("1 + 3 + 5 + 7 + 9 = " + x‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪while‬‬

‫اﻟﮫﺪف ﻣﻦ ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪ while‬ھﻲ ﺗﻜﺮار ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻛﻮاد ﻟﻌﺪد ﻏﯿﺮ ﻣﺤﺪد ﻳﺘﻮﻗﻒ ﻋﻠﻲ ﺟﻤﻠﺔ ﺷﺮط ‪ ،‬ﺑﺪون وﺟﻮد‬
‫ﻗﯿﻤﺔ إﺑﺘﺪاﺋﯿﺔ وﺑﺪون ﺟﻤﻠﺔ ﻟﻠﺰﻳﺎدة أو اﻟﻨﻘﺼﺎن ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫( ‪while‬‬ ‫ﺷﺮط اﻟﺘﻜﺮار‬ ‫{ )‬

‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫}‬

‫ﻣﺜﺎل‬
‫ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻷرﻗﺎم ﺑﯿﻦ ‪ ١‬و ‪٥‬‬

‫>‪<HTML dir=rtl‬‬
‫>‪<Title‬‬ ‫اﻟﺘﻜﺮار‬ ‫ﺣﻤﻠﺔ‬ ‫>‪while</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var i = 1‬‬

‫{ ) ‪while( i<6‬‬
‫;) ">‪document.write( i + "<br‬‬
‫;‪i++‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪82‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻻ ﻧﺠﺪ ﻓﺮق ﺑﯿﻦ ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪ while‬وﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪for‬‬
‫وﻟﻜﻦ ﺗﻈﮫﺮ اﻟﺤﺎﺟﺔ إﻟﻲ إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ while‬ﻋﻨﺪ اﻟﺘﻌﺮض إﻟﻲ ﺗﻨﻔﯿﺬ اﻟﻜﻮد ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﺣﺴﺐ ﺷﺮط ﻏﯿﺮ ﻣﺮﺗﺒﻂ‬
‫ﺑﻌﻤﻠﯿﺔ ﺣﺴﺎﺑﯿﺔ ﺗﻜﺮارﻳﺔ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل‬
‫ﻧﻘﻮم ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﺑﺎﻟﻜﺸﻒ ﻋﻦ ﻛﻠﻤﺔ اﻟﺴﺮ‬
‫ﻓﻠﻮ أدﺧﻠﺖ ﻛﻠﻤﺔ اﻟﺴﺮ ﺧﻄﺄ ﻳﺘﻢ إﻋﺎدة إدﺧﺎل ﻛﻠﻤﺔ اﻟﺴﺮ ﺣﺘﻲ ﻳﺘﻢ إدﺧﺎﻟﮫﺎ ﺑﺸﻜﻞ ﺻﺤﯿﺢ‬

‫>‪<HTML dir=rtl‬‬
‫ﻛﻠﻤﺔ اﻟﺴﺮ >‪<Title‬‬ ‫اﻟﻜﺸﻒ ﻋﻦ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;"‪var userPassword = "123‬‬

‫اﻟﺴﺮ"(‪var password = prompt‬‬ ‫‪",‬أدﺧﻞ ﻛﻠﻤﺔ‬ ‫;)""‬

‫{) ‪while( password != userPassword‬‬

‫ﺻﺤﯿﺤﺔ" (‪alert‬‬ ‫;) "ﻛﻠﻤﺔ اﻟﺴﺮﻏﯿﺮ‬
‫اﻟﺴﺮ"(‪password = prompt‬‬ ‫‪",‬أدﺧﻞ ﻛﻠﻤﺔ‬ ‫;)""‬
‫}‬

‫‪83‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫ﯾﺎ" (‪alert‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ‬ ‫‪\n‬‬ ‫"ﻛﻠﻤﺔ ﺳﺮ ﺻﺤﯿﺤﺔ‬ ‫;)‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪do … while‬‬

‫ﺗﺘﺸﺎﺑﻪ ﻣﻊ وﻇﯿﻔﺔ ﺟﻤﻠﺔ اﻟﺘﻜﺮار ‪ ، while‬وﻟﻜﻨﮫﺎ ﺗﺨﺘﻠﻒ ﻓﻲ أن اﻟﻜﻮد اﻟﻤﻮﺟﻮد ﺑﺪاﺧﻠﮫﺎ ﻳﺘﻢ ﺗﻨﻔﯿﺬه ﻣﺮة واﺣﺪة‬
‫ﻋﻠﻲ اﻷﻗﻞ ﺣﺘﻲ وﻟﻮ ﻛﺎﻧﺖ ﺟﻤﻠﺔ اﻟﺸﺮط ﺗﺴﺎوي ‪ false‬ﻋﻨﺪ أول ﻣﻘﺎرﻧﺔ ‪،‬‬
‫ﻷﻧﻪ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻟﻜﻮد أوﻻ ﺛﻢ ﻳﺘﻢ ﺗﻨﻔﯿﺬ ﺟﻤﻠﺔ اﻟﺸﺮط ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬

‫{‪do‬‬
‫‪//‬‬ ‫اﻷﻛﻮاد‬
‫( ‪}while‬‬ ‫ﺷﺮط اﻟﺘﻜﺮار‬ ‫;)‬

‫ﻣﺜﺎل‬
‫ﻧﻘﻮم ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﺑﺎﻟﻜﺸﻒ ﻋﻦ ﻛﻠﻤﺔ اﻟﺴﺮ ‪ ،‬ﻓﻠﻮ أدﺧﻠﺖ ﻛﻠﻤﺔ اﻟﺴﺮ ﺧﻄﺄ ﻳﺘﻢ إﻋﺎدة إدﺧﺎل ﻛﻠﻤﺔ اﻟﺴﺮ وﺗﺘﻢ ھﺬه‬
‫اﻟﻌﻤﻠﯿﺔ ‪ ٣‬ﻣﺮات ﻣﺘﺘﺎﻟﯿﺔ ﻋﻨﺪ إدﺧﺎل ﻛﻠﻤﺔ ﺳﺮ ﺧﺎﻃﺌﺔ ‪.‬‬

‫>‪<HTML dir=rtl‬‬
‫ﻛﻠﻤﺔ اﻟﺴﺮ >‪<Title‬‬ ‫اﻟﻜﺸﻒ ﻋﻦ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var userPassword = "123", password‬‬
‫;‪var failureCount = 0‬‬

‫{‪do‬‬
‫;‪failureCount++‬‬
‫;‪if( failureCount == 4 ) break‬‬
‫ﺻﺤﯿﺤﺔ" (‪if( failureCount != 1 ) alert‬‬ ‫"ﻛﻠﻤﺔ اﻟﺴﺮﻏﯿﺮ‬ ‫;)‬

‫اﻟﺴﺮ"(‪password = prompt‬‬ ‫‪",‬أدﺧﻞ ﻛﻠﻤﺔ‬ ‫;)""‬

‫;) ‪} while( password != userPassword‬‬

‫) ‪if( failureCount == 4‬‬

‫اﻟﺼﻔﺤﺔ" (‪alert‬‬ ‫" ﻏﯿﺮ ﻣﺴﻤﻮح ﻟﻚ ﺑﺪﺧﻮل ﺗﻠﻚ‬ ‫;)‬
‫‪else‬‬
‫ﯾﺎ" (‪alert‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ‬ ‫‪\n‬‬ ‫"ﻛﻠﻤﺔ ﺳﺮ ﺻﺤﯿﺤﺔ‬ ‫" ‪+‬‬ ‫"ﺑﻌﺪ ﻋﺪد ﻣﻦ اﻟﻤﺤﺎوﻻت ﯾﺴﺎوي ‪:‬‬ ‫;)‪+ failureCount‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪84‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫أﻣﺜﻠﺔ ﻋﺎﻣﺔ ﻋﻦ ﺟﻤﻞ اﻟﺘﻜﺮار‬

‫ﻣﺜﺎل‬
‫ﺣﺴﺎب اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻲ ﻟﻸﻋﺪاد ﻣﻦ ‪ ٢٠‬إﻟﻲ ‪٨٠‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺤﺴﺎﺑﻲ >‪<Title‬‬ ‫اﻟﻤﺘﻮﺳﻂ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var count = 0, i‬‬
‫;‪var sum = 0‬‬

‫{) ‪for( i=20; i<=80 ; i++‬‬

‫;‪sum += i‬‬
‫;‪count++‬‬
‫}‬

‫;‪var average = sum / count‬‬

‫ﻟﻸﻋﺪاد ﻣﻦ ‪ ٢٠‬إﻟﻲ ‪ ٨٠‬ﯾﺴﺎوي ‪alert( " :‬‬ ‫" اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻲ‬ ‫;) ‪+ average‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﺜﺎل ﻣﺘﻘﺪم‬
‫ﻧﺄﺧﺬ ﻣﻦ اﻟﻤﺴﺘﺨﺪم رﻗﻢ ﺑﺎﻟﻨﻈﺎم اﻟﻌﺸﺮ ي ‪ ،‬ﺛﻢ ﻧﺤﻮﻟﻪ إﻟﻲ اﻟﻨﻈﺎم اﻟﺜﻨﺎﺋﻲ ﻣﻊ ﻋﺮض ﻋﺪد اﻟﺒﺘﺎت اﻟﻤﻜﻮﻧﺔ ﻟﮫﺬا اﻟ ﺮﻗﻢ ‪.‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺜﻨﺎﺋﻲ >‪<Title‬‬ ‫اﻟﺘﺤﻮﯾﻞ ﻟﻠﻨﻈﺎم‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var decimalNumber, binaryNumber‬‬

‫"(‪decimalNumber = prompt‬‬ ‫أدﺧﻞ اﻟﺮﻗﻢ اﻟﻌﺸﺮي‬ ‫;)""‪",‬‬

‫‪85‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

var binaryString = "", count=0;

do{
binaryString = (decimalNumber & 1) + binaryString;
count++;
} while( decimalNumber >>= 1 )

alert(binaryString);
alert(count)

//-->
</SCRIPT>
</HEAD>
</HTML>

‫ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬٥ ‫ﻓﻌﻨﺪ إدﺧﺎل اﻟﺮﻗﻢ‬

86
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺩﺱ‬
‫ﺍﻟﺪﻭﺍﻝ ﺃﻭ ﺍﻟﻮﻇﺎﺋﻒ‬
‫ﺳﻮف ﻧﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ اﻟﻨﻘﺎط اﻟﺘﺎﻟﯿﺔ ‪:‬‬

‫ﺗﻤﮫﯿﺪ‬ ‫•‬
‫ﺗﻌﺮﻳﻒ اﻟﺪوال أو اﻟﻮﻇﺎﺋﻒ‬ ‫•‬
‫أﻧﻮاع اﻟﺪوال‬ ‫•‬
‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪوال‬ ‫•‬
‫ﺗﻌﺮﻳﻒ اﻟﺪوال‬ ‫•‬
‫ﻃﺮﻳﻘﺔ إﺳﺘﺪﻋﺎء اﻟﺪوال‬ ‫•‬
‫اﻟﻤﺘﻐﯿﺮات اﻟﻤﺤﻠﯿﺔ واﻟﻌﺎﻣﺔ‬ ‫•‬
‫إﺳﺘﺮﺟﺎع اﻟﻘﯿﻢ ﻣﻦ اﻟﺪوال‬ ‫•‬
‫ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت ﻟﻠﺪوال‬ ‫•‬
‫إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﻨﻔﺴﮫﺎ ‪Recursive Function‬‬ ‫•‬
‫داﻟﺔ داﺧﻞ داﻟﺔ ‪inner Function‬‬ ‫•‬

‫‪87‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﮫﯿﺪ‬

‫رﺑﻤﺎ ﻛﻨﺎ ﻓﻲ اﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ ﻧﺤﺘﺎج إﻟﻲ إﺳﺘﺨﺪام ﺟﺰء ﻣﻦ اﻟﻜﻮد ﺑﺸﻜﻞ ﺗﻜﺮاري ﻟﺬﻟﻚ إﺣﺘﺠﻨﺎ ﻟﺠﻤﻞ اﻟﺘﻜﺮار ﻣﺜﻞ ﺟﻤﻠﺔ‬
‫‪ ، for‬وﻟﻜﻦ ﻟﻮ ﻛﻨﺎ ﻧﺮﻳﺪ إﺳﺘﺨﺪام ﺟﺰء ﻣﻦ اﻟﻜﻮد ﺑﺸﻜﻞ داﺋﻤﺎ ﻓﺴﻮف ﻧﻠﺠﺄ إﻟﻲ إﺳﺘﺨﺪام ﻣﺎ ﻳﺴﻤﻲ ﺑﺎﻟﺪوال أو‬
‫اﻟﻮﻇﺎﺋﻒ ‪Functions‬‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺤﺎﻟﺔ اﻟﺘﺎﻟﯿﺔ‬

‫"(‪var password = prompt‬‬ ‫أدﺧﻞ ﻛﻠﻤﺔ اﻟﺴﺮ‬ ‫;)""‪",‬‬

‫{) "‪if ( password == "123‬‬

‫;)"ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ ﻣﻮﻗﻌﻨﺎ"(‪alert‬‬
‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬ ‫;)">‪<br‬‬

‫اﻟﻤﻮﻗﻊ"(‪document.write‬‬ ‫;)" ﻣﺪﯾﺮ‬

‫{) "‪}else if ( password == "111‬‬
‫;)"ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ ﻣﻮﻗﻌﻨﺎ"(‪alert‬‬
‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬ ‫;)">‪<br‬‬

‫ﺑﺎﻟﻤﻮﻗﻊ"(‪document.write‬‬ ‫;)" ﻣﺸﺘﺮك‬

‫{‪}else‬‬
‫ﺧﺎﻃﺌﺔ"(‪alert‬‬ ‫;)" ﻛﻠﻤﺔ اﻟﺴﺮ‬
‫}‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺴ ﻄﻮر اﻟﺘﺎﻟﯿﺔ‬

‫ﻣﻮﻗﻌﻨﺎ"(‪alert‬‬ ‫;)"ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬

‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬ ‫;)">‪<br‬‬

‫ﻓﻘﺪ ﺗﻢ ﺗﻜﺮارھﺎ ﻣﺮﺗﯿﻦ ‪ ،‬ﻓﮫﺐ أﻧﻨﺎ ﺳﻮف ﻧﺴﺘﺨﺪﻣﮫﺎ أﻛﺜﺮ ﻣﻦ ﻣﺮﺗﯿﻦ ﻓﻤﺎ اﻟﺤﻞ‬
‫ھﻞ ﻧﻘﻮم ﺑﺘﻜﺮار ھﺬة اﻟﺠﻤﻞ ﻛﻠﻤﺎ إﺣﺘﺠﻨﺎ ﻟﮫﺎ ‪ ،‬ﺑﺎﻟﻄﺒﻊ ھﺬا ﻟﯿﺲ ﺑﺤﻞ ﻳﺮوق ﻟﻚ‬
‫وأﻧﺎ ﻣﻌﻚ أن ھﺬا اﻟﺤﻞ ﻻ ﻳﺮوق ﻟﻲ أﻧﺎ أﻳﻀﺎ ‪،‬‬
‫ﻻ ﺗﻘﻠﻖ اﻟﺤﻞ ﻗﺪ أﺗﻲ ﺑﺤﻤﺪ اﷲ ﻓﺴﻮف ﻧﻘﻮم ﺑﻮﺿﻊ ھﺬﻳﯿﻦ اﻟﺴﻄﺮﻳﻦ داﺧﻞ ﺑﻮﻃﻘﺔ ) داﻟﺔ أو وﻇﯿﻔﺔ ( ‪ ،‬ﻧﺴﺘﻄﯿﻊ ﺗﻨﻔﯿﺬ‬
‫ﻣﺎ ﺑﮫﺎ ﻣﻦ اﻷﻛﻮاد وﻗﺘﻤﺎ أردﻧﺎ ‪.‬‬

‫وﺗﻜﻮن ﻋﻠﻲ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫{ )(‪function displayMessage‬‬
‫ﻣﻮﻗﻌﻨﺎ"(‪alert‬‬ ‫;)"ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬
‫ﻣﻮﻗﻌﻨﺎ"(‪document.write‬‬ ‫ﻣﺮﺣﺒﺎ ﺑﻚ ﻓﻲ‬ ‫;)">‪<br‬‬
‫}‬

‫وﻟﯿﺲ ھﻨﺎك اي داﻋﻲ ﻟﻤﺤﺎوﻟﺔ ﻓﮫﻢ ﻣﺎ ﻛﺘﺐ اﻷن ‪ ،‬وﻟﻜﻦ ﺗﺎﺑﻊ ﻣﻌﻲ أول إﻧﻄﻼﻗﺔ ﺣﻘﯿﻘﯿﺔ إﻟﻲ ﻋﺎﻟﻢ اﻟﺒﺮﻣﺠﺔ‬
‫ﻣﻊ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﺪوال أو اﻟﻮﻇﺎﺋﻒ ‪.‬‬

‫‪88‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻌﺮﻳﻒ اﻟﺪوال أو اﻟﻮﻇﺎﺋﻒ‬

‫واﻟﻮﻇﺎﺋﻒ ھﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﻤﻞ ﻳﻄﻠﻖ ﻋﻠﯿﮫﺎ إﺳﻢ وﻳﺸﺎر إﻟﯿﮫﺎ ﺑﻪ وﺗﻨﻔﺬ ﻛﻮﺣﺪة واﺣﺪة ‪.‬‬

‫أﻧﻮاع اﻟﺪوال‬
‫ﻳﻮﺟﺪ ﻧﻮﻋﯿﻦ ﻣﻦ اﻟﺪوال‬
‫‪ -‬اﻟﺪوال اﻟﻤﺒﻨﯿﺔ داﺧﻞ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪built-in functions‬‬
‫ھﺬه اﻟﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺪوال ﺗﻢ ﺑﻨﺎﺋﮫﺎ داﺧﻞ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻣﺜﻞ داﻟﺔ ‪ ، parseInt‬و ﻳﻤﻜﻨﻨﺎ‬
‫أﺳﺘﺨﺪاﻣﮫﺎ ﻛﺄي داﻟﺔ ﻗﻤﻨﺎ ﺑﺘﻌﺮﻳﻔﮫﺎ ﻛﻤﺎ ﺳﻨﺮي ﻓﯿﻤﺎ ﺑﻌﺪ ‪.‬‬
‫‪ -‬اﻟﺪوال اﻟﻤﺒﻨﯿﺔ ﻣﻦ ﺧﻼل ﻣﺒﺮﻣﺠﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬
‫وھﺬا ھﻮ اﻟﻨﻮع ﻣﻦ اﻟﺪوال اﻟﺬي ﺳﻮف ﻧﺘﺤﺪث ﻋﻨﻪ ﻓﻲ ھﺬا اﻟﻔﺼﻞ ﺑﺸﻜﻞ ﻣﻔﺼﻞ ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪوال‬

‫{ ) ﻣﻌﺎﻣﻼت اﻟﺪاﻟﺔ ( إﺳﻢ اﻟﺪاﻟﺔ ‪function‬‬

‫‪//‬‬ ‫اﻷﻛﻮاد اﻟﻤﺮاد ﺗﻨﻔﯿﺬﻫﺎ‬

‫‪//‬‬ ‫رﺑﻤﺎ ﺗﻘﻮم اﻟﺪاﻟﺔ ﺑﺈرﺟﺎع ﻗﯿﻤﺔ‬

‫‪return‬‬ ‫; اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ‬
‫}‬

‫‪ - ١‬أوﻻ ﻧﺒﺪأ ﺑﻜﺘﺎﺑﺔ ﻛﻠﻤﺔ ‪ function‬ﺛﻢ ﻳﻠﯿﮫﺎ اﺳﻢ اﻟﺪاﻟﺔ و ﺗﺨﻀﻊ ﻟﻨﻔﺲ ﺷﺮوط ﺗﺴﻤﯿﺔ اﻟﻤﺘﻐﯿﺮات ‪ ،‬ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أﻧﮫﺎ ﻻ‬
‫ﻳﺠﺐ أن ﺗﺄﺧﺬ اي اﺳﻢ ﻟﺪاﻟﺔ ﻣﺒﻨﯿﺔ داﺧﻞ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪. built-in function‬‬

‫‪ - ٢‬ﺛﻢ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻼت ﻟﮫﺎ أو رﺑﻤﺎ ﻻ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻼت ﻟﮫﺎ ﻛﻤﺎ ﺳﻮف ﻧﺮي ﻻﺣﻘﺎ ‪.‬‬

‫‪ - ٣‬ﺛﻢ ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻷﻛﻮاد اﻟﻤﺮاد ﺗﻨﻔﯿﺬھﺎ ﺑﯿﻦ أﻗﻮاس اﻟﻤﺠﻤﻮﻋﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﺪاﻟﺔ ‪.‬‬

‫‪ - ٤‬ﺑﻌﺪھﺎ رﺑﻤﺎ ﺗﻘﻮم ھﺬة اﻟﺪاﻟﺔ ﺑﺈرﺟﺎع ﻗﯿﻤﺔ أو ﻻ ﺗﺮﺟﻊ اي ﻗﯿﻢ ﻛﻤﺎ ﺳﻮف ﻧﺮي ﻻﺣﻘﺎ ‪.‬‬

‫ﺗﻌﺮﻳﻒ اﻟﺪوال‬

‫دﻋﻨﺎ ﺑﻌﺪﻣﺎ ﻋﻠﻤﻨﺎ اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪوال ‪ ،‬أن ﻧﻘﻮم ﺑﻜﺘﺎﺑﺔ اﺣﺪي اﻟﺪوال اﻟﺒﺴﯿﻄﺔ وﻇﯿﻔﺘﮫﺎ ﻋﻤﻞ اﻟﺘﺎﻟﻲ‬
‫أﺧﺬ اﺳﻢ اﻟﻤﺴﺘﺨﺪم ‪ ،‬ﺛﻢ إﻇﮫﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ ﻟﻪ ‪.‬‬

‫‪89‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻟﺬﻟﻚ ﺳﻨﻘﻮم ﺑﻌﻤﻞ داﻟﺔ ﺑﺎﺳﻢ ‪ showMessage‬ھﺬه اﻟﺪاﻟﺔ ﻻ ﺗﺄﺧﺬ ﻣﻌﺎﻣﻼت وﻻ ﺗﻘﻮم ﺑﺈرﺟﺎع اي ﻗﯿﻢ ﻛﻤﺎ ﻳﻠﻲ‬

‫{ )( ‪function showMessage‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫ﻧﻌﻢ ﻟﻘﺪ ﺗﻤﻜﻨﺎ ﻣﻦ ﺑﻨﺎء ھﺬه اﻟﺪاﻟﺔ إﺳﺘﻨﺎدا ﻋﻠﻲ ﻣﺎ ﺗﻌﻠﻤﻨﺎه ﻟﻠﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪوال‬
‫وﻟﻜﻦ ﻛﯿﻒ ﻳﻤﻜﻨﻨﺎ ﺗﻨﻔﯿﺬ ﻣﺎ ﺑﺪاﺧﻠﮫﺎ ﻣﻦ أﻛﻮاد ؟‬
‫ﻟﻺﺟﺎﺑﺔ ﻋﻠﻲ ھﺬا اﻟﺴﺆال أﺗﺒﻌﻨﻲ ﻓﻲ اﻟﻔﻘﺮة اﻟﺘﺎﻟﯿﺔ‬

‫ﻃﺮﻳﻘﺔ إﺳﺘﺪﻋﺎء اﻟﺪوال‬

‫اﻟﺪاﻟﺔ اي ﺗﻨﻔﯿﺬ ﻣﺎ ﺑﺪاﺧﻠﮫﺎ ﻣﻦ أﻛﻮاد ‪ ،‬وﻳﻤﻜﻨﻨﺎ إﺳﺘﺪﻋﺎء اﻟﺪوال ﺑﻌﺪة أﺷﻜﺎل أﺣﺪھﻤﺎ ‪:‬‬ ‫ﻧﻌﻨﻲ ﺑﺈﺳﺘﺪﻋﺎء‬
‫إﺳﺘﺪﻋﺎء داﻟﺔ ﻣﻦ ﺧﺎرج اي داﻟﺔ‬ ‫‪-‬‬
‫إﺳﺘﺪﻋﺎء داﻟﺔ ﻣﻦ داﺧﻞ داﻟﺔ‬ ‫‪-‬‬
‫إﺳﺘﺪﻋﺎء داﻟﺔ ﻟﻨﻔﺴﮫﺎ ‪Recursive function‬‬ ‫‪-‬‬
‫وھﺬا اﻟﻨﻮع ﻣﻦ اﻟﺪوال أﻛﺜﺮ ﺻﻌﻮﺑﺔ ‪ ،‬ﺳﯿﺘﻢ ﻧﻘﺎﺷﻪ ﻓﻲ أﺧﺮ ھﺬا اﻟﻔﺼﻞ‬

‫دﻋﻨﺎ ﺑﻌﺪﻣﺎ ﻗﻤﻨﺎ ﺑﺘﻌﺮﻳﻒ اﻟﺪاﻟﺔ ‪ showMessage‬أن ﻧﻘﻮم ﺑﺈﺳﺘﺨﺪاﻣﮫﺎ‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫ﻧﺪاء‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫{ )( ‪function showMessage‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫;)(‪showMessage‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫‪90‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‬

‫وﺑﻌﺪ إدﺧﺎل اﻻﺳﻢ ﺑﺎﻟﻘﯿﻤﺔ ﻣﺤﻤﺪ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﺎﻟﺘﺎﻟﻲ‬

‫ﺟﻤﯿﻞ ﺟﺪا ﻟﻘﺪ ﺗﻢ ﺗﻨﻔﯿﺬ أﻛﻮاد ھﺬا اﻟﺪاﻟﺔ ﺑﻤﺠﺮد ﻛﺘﺎﺑﺔ اﺳﻤﮫﺎ ﻣﺘﺒﻮﻋﺎ ﺑﺄﻗﻮاس ﻛﻤﺎ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫;)(‪showMessage‬‬

‫ﻻﺣﻆ ﻣﺎ ھﻮ أت‬
‫رﺑﻤﺎ ﻧﺤﺘﺎج ﻓﻲ ﺑﻌﺾ اﻷﺣﯿﺎن ﻟﻌﻤﻞ أﻛﺜﺮ ﻣﻦ داﻟﺔ ‪ ،‬ورﺑﻤﺎ ﻧﺤﺘﺎج ﻟﺘﻨﻔﯿﺬ أﺣﺪي اﻟﺪوال ﻣﻦ داﺧﻞ داﻟﺔ أﺧﺮي‬
‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫ﻟﺒﻌﺾ >‪<Title‬‬ ‫ﻧﺪاء اﻟﺪوال ﺑﻌﻀﻬﺎ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;‪var userName‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫{ )( ‪function showMessage‬‬
‫‪//‬‬ ‫‪ getName‬ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫‪//‬‬ ‫‪ showMessage‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ‬
‫;)(‪getName‬‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫‪91‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬
‫‪getName‬‬
‫{ )( ‪function getName‬‬
‫ﻓﻀﻠﻚ"(‪userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫}‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫;)(‪showMessage‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬

‫ﻻﺣﻆ ﻣﻌﻲ اﻟﺴﻄﻮر اﻟﺘﺎﻟﯿﺔ‬

‫ﻟﻘﺪ ﺗﻢ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ‪ getName‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ ‪showMessage‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫{ )( ‪function showMessage‬‬
‫‪//‬‬ ‫‪ getName‬ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫‪//‬‬ ‫‪ showMessage‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ‬
‫;)(‪getName‬‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getName‬‬

‫{ )( ‪function getName‬‬
‫ﻓﻀﻠﻚ"(‪userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫}‬

‫ﻻﺣﻆ أﻳﻀﺎ اﻟﺘﺎﻟﻲ‬

‫ﻟﻘﺪ ﺗﻢ ﺗﻐﯿﺮ ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ userName‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ ‪ ، getName‬وﺗﻢ ﻋﺮض ﻗﯿﻤﺘﻪ ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ‬
‫‪ showMessage‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;‪var userName‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫{ )( ‪function showMessage‬‬
‫‪//‬‬ ‫‪ getName‬ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫‪//‬‬ ‫‪ showMessage‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ‬
‫;)(‪getName‬‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getName‬‬

‫{ )( ‪function getName‬‬
‫‪92‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬
‫ﻓﻀﻠﻚ"(‪userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫}‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫;)(‪showMessage‬‬

‫وھﺬا ﻳﻘﻮدﻧﺎ إﻟﻲ ﻛﯿﻔﯿﺔ ﺗﻌﺎﻣﻞ اﻟﺪوال ﻣﻊ اﻟﻤﺘﻐﯿﺮات ‪ ،‬وﻹﻛﺘﺸﺎ ف ھﺬا دﻋﻨﺎ ﻧﻨﺘﻘﻞ ﻟﻠﻔﻘﺮة اﻟﺘﺎﻟﯿﺔ ‪.‬‬

‫اﻟﻤﺘﻐﯿﺮات اﻟﻤﺤﻠﯿﺔ و اﻟﻌﺎﻣﺔ‬

‫اﻟﻤﺘﻐﯿﺮات اﻟﻤﺤﻠﯿﺔ ‪Local variables‬‬

‫إذا ﺗﻢ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﯿﺮ داﺧﻞ داﻟﺔ ‪ ،‬ﻓﻠﻦ ﺗﺴﺘﻄﯿﻊ ﻋﺮض أو ﺗﻌﺪﻳﻞ ﻗﯿﻤﺔ ھﺬا اﻟﻤﺘﻐﯿﺮ إﻻ ﻣﻦ داﺧﻞ ھﺬة اﻟﺪاﻟﺔ اﻟﻤﻌﺮف ﺑﮫﺎ‬
‫وﻻ ﻳﻤﻜﻨﻚ ﻋﺮض أو ﺗﻌﺪﻳﻞ ﻣﺤﺘﻮﻳﺎت ھﺬا اﻟﻤﺘﻐﯿﺮ ﻣﻦ داﺧﻞ داﻟﺔ أﺧﺮي ‪ ،‬وﻳﺴﻤﻲ ھﺬا اﻟﻤﺘﻐﯿﺮ ﺑﻤﺘﻐﯿﺮ ﻣﺤﻠﻲ ‪Local‬‬
‫‪ variable‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getJob‬‬

‫{ )( ‪function getJob‬‬
‫ﻓﻀﻠﻚ"(‪var userJob = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫}‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showJob‬‬

‫{ )( ‪function showJob‬‬
‫" (‪alert‬‬ ‫ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ‬ ‫;) ‪userJob = " + userJob‬‬
‫}‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﺠﺪ أن اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪ userJob‬ﺗﻢ ﺗﻌﺮﻳﻔﻪ داﺧﻞ اﻟﺪاﻟﺔ ‪ ، getJob‬ﻟﺬﻟﻚ ﻳﻌﺘﺒﺮ ھﺬا اﻟﻤﺘﻐﯿﺮ‬
‫ﻣﺘﻐﯿﺮ ﻣﺤﻠﻲ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺪاﻟﺔ ‪ getJob‬وﻻ ﻳﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺘﻐﯿﺮ ‪ userJob‬ﻣﻦ ﺧﺎرج ھﺬه اﻟﺪاﻟﺔ أو ﻣﻦ داﺧﻞ داﻟﺔ‬
‫ﺧﺎرﺟﯿﺔ أﺧﺮي‪.‬‬

‫وﻟﻮ ﻗﻤﻨﺎ ﺑﻌﺮض ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ userJob‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ ‪ showJob‬ﺳﯿﺆدي ذﻟﻚ ﻟﺤﺪوث ﺧﻄﺄ ﻛﻤﺎ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫" (‪alert‬‬ ‫ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ‬ ‫;) ‪userJob = " + userJob‬‬

‫‪93‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﻣﻼﺣﻈﺔ ھﺎﻣﺔ‬

‫ﻳﻤﻜﻨﻚ إﺳﺘﺨﺪام ﻧﻔﺲ اﺳﻢ اﻟﻤﺘﻐﯿﺮ ﻓﻲ أﻛﺜﺮ ﻣﻦ داﻟﺔ ﺑﺸﺮط أن ﻳﺘﻢ ﺗﻌﺮﻳﻔﻪ داﺧﻞ ﻛﻞ داﻟﺔ ﻋﻠﻲ ﺣﺪي ‪ ،‬وﺳﻮف ﻳﺘﻢ‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻛﻞ ﻣﺘﻐﯿﺮ ﻋﻠﻲ ﺣﺪي داﺧﻞ اﻟﺪاﻟﺔ اﻟﻤﻌﺮف ﺑﮫﺎ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﻤﺤﻠﯿﺔ >‪<Title‬‬ ‫اﻟﻤﺘﻐﯿﺮات‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getJob‬‬

‫{ )( ‪function func1‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬

‫;) ‪document.write( userName‬‬

‫}‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showJob‬‬

‫{ )( ‪function func2‬‬
‫;" ﻣﺤﻤﺪ" = ‪var userName‬‬

‫;) ‪alert( userName‬‬

‫}‬

‫;)(‪func1‬‬
‫;)(‪func2‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﺠﺪ أن اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪ userName‬ﺗﻢ ﺗﻌﺮﻳﻔﻪ داﺧﻞ اﻟﺪاﻟﺔ ‪ func1‬و اﻟﺪاﻟﺔ ‪ ، func2‬ﻟﻜﻦ ﻳﺘﻢ‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ ھﺬا اﻟﻤﺘﻐﯿﺮ ﻋﻠﻲ أﺳﺎس أﻧﮫﻢ ﻣﺘﻐﯿﺮﻳﻦ ﻛﻼ ﺣﺴﺐ ﻣﻜﺎن ﺗﻌﺮﻳﻔﻪ داﺧﻞ اﻟﺪاﻟﺔ ‪.‬‬

‫‪94‬‬
‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪95‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﻤﺘﻐﯿﺮات اﻟﻌﺎﻣﺔ ‪Global variables‬‬

‫إذا ﺗﻢ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﯿﺮ ﺧﺎرج ﻧﻄﺎق اي داﻟﺔ اي ﻋﻠﻲ ﻣﺴﺘﻮي اﻷﺳﻜﺮﺑﺖ اﻟﻌﺎم ‪ ،‬ﺑﮫﺬا ﺗﺴﺘﻄﯿﻊ ﻋﺮض أو ﺗﻌﺪﻳﻞ ﻗﯿﻤﺔ ھﺬا‬
‫اﻟﻤﺘﻐﯿﺮ ﻣﻦ داﺧﻞ أي داﻟﺔ أو ﻣﻦ ﺧﺎرﺟﮫﻤﺎ ‪ ،‬وﻳﺴﻤﻲ ھﺬا اﻟﻤﺘﻐﯿﺮ ﺑﻤﺘﻐﯿﺮ ﻋﺎم ‪ Global variable‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫;‪var userName‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫{ )( ‪function showMessage‬‬
‫‪//‬‬ ‫‪ getName‬ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫‪//‬‬ ‫‪ showMessage‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ‬
‫;)(‪getName‬‬
‫"(‪alert‬‬ ‫" ﻣﺮﺣﺒﺎ ﺑﻚ ‪:‬‬ ‫;) ‪+ userName‬‬
‫}‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getName‬‬

‫{ )( ‪function getName‬‬
‫ﻓﻀﻠﻚ"(‪userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫}‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬ ‫‪showMessage‬‬

‫;)(‪showMessage‬‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﺠﺪ أن اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪ userName‬ﺗﻢ ﺗﻌﺮﻳﻔﻪ ﻓﻲ اﻟﻜﻮد ﺧﺎرج ﻧﻄﺎق اي داﻟﺔ ‪ ،‬وﻗﺪ ﺗﻢ ﺗﻐﯿﺮ‬
‫ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ userName‬ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ ‪ ، getName‬وﺗﻢ ﻋﺮض ﻗﯿﻤﺘﻪ ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ ‪showMessage‬‬

‫‪96‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫إﺳﺘﺮﺟﺎع اﻟﻘﯿﻢ ﻣﻦ اﻟﺪوال‬

‫ﻳﻤﻜﻦ ﻟﻠﺪوال ﻓﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ إرﺟﺎع ﻗﯿﻢ ﻟﻠﺠﻤﻠﺔ اﻟﺘﻲ ﻗﺎﻣﺖ ﺑﺈﺳﺘﺪﻋﺎﺋﮫﺎ ‪ ،‬ﺑﺈﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪. return‬‬
‫ﻳﺘﻢ وﺿﻊ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻟﺪاﻟﺔ ﺑﻌﺪ اﻟﻜﻠﻤﺔ ‪. return‬‬
‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻟﺪاﻟﺔ ﻳﻤﻜﻦ ﺗﺨﺰﻳﻨﮫﺎ ﻓﻲ ﻣﺘﻐﯿﺮ أو ﺗﻜﻮن وﺳﻂ ﺟﻤﻠﺔ ﺣﺴﺎﺑﯿﻪ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟ ﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫إﺳﺘﺮﺟﺎع اﻟﻘﯿﻢ ﻣﻦ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getGuestName‬‬

‫{ )( ‪function getGuestName‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫;‪return userName‬‬
‫}‬

‫;)(‪var returnName = getGuestName‬‬

‫;) ‪alert( returnName‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫دﻋﻨﺎ ﻧﺪرس ھﺬا اﻟﻤﺜﺎل ﺧﻄﻮة ﺑﺨﻄﻮة‬

‫أوﻻ ﻗﻤﻨﺎ ﺑﺈﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ‪getGuestName‬‬
‫وﺑﻤﺎ أن ھﺬه اﻟﺪاﻟﺔ ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ‪ ،‬ﻓﺴﻮف ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻟﺪاﻟﺔ ﻓﻲ اﻟﻤﺘﻐﯿﺮ ‪returnName‬‬
‫ﻛﻤﺎ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫;)(‪var returnName = getGuestName‬‬

‫ﻓﻌﻨﺪ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻛﻮد اﻟﺘﺎﻟﯿﺔ‬

‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬

‫;‪return userName‬‬

‫وﻛﻤﺎ ﻧﺮي ﻳﺘﻢ ﺗﻨﻔﯿﺬ اﻷﻣﺮ ‪ prompt‬وﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻨﻪ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﻤﺴﻤﻲ ‪userName‬‬
‫ﺛﻢ ﻳﺘﻢ إﻧﮫﺎء اﻟﺪاﻟﺔ واﻟﺨﺮوج ﻣﻨﮫﺎ ﺑﺘﻨﻔﯿﺬ اﻷﻣﺮ اﻟﺘﺎﻟﻲ‬

‫;‪return userName‬‬

‫وﻳﻘﻮم اﻷﻣﺮ ‪ return‬ﺑﻌﻤﻞ ﺷﯿﺌﯿﻦ أوﻟﮫﻤﺎ إرﺟﺎع اﻟﻘﯿﻤﺔ اﻟﺘﺎﻟﯿﺔ ﻟﻪ ‪ ،‬ﺛﻢ إﻧﮫﺎء ﺗﻨﻔﯿﺬ اﻟﺪاﻟﺔ ‪.‬‬

‫‪97‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺑﻌﺪ إﻧﺘﮫﺎء ﺗﻨﻔﯿﺬ اﻟﺪاﻟﺔ ‪ ،‬ﻳﻘﻮم ﻣﻔﺴﺮ اﻟﻠﻐﺔ ‪ interpreter‬ﺑﺎﻹﻧﺘﻘﺎل إﻟﻲ ﻣﻜﺎن إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻛﻤﺎ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫;)(‪var returnName = getGuestName‬‬

‫ﺛﻢ ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻟﺪاﻟﺔ ‪ getGuestName‬ﻓﻲ اﻟﻤﺘﻐﯿﺮ ‪. returnName‬‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻻﺣﻆ أن اي أﻣﺮ ﻳﻜﺘﺐ ﺑﻌﺪ اﻷﻣﺮ ‪ return‬ﻻ ﻳﺘﻢ ﺗﻨﻔﯿﺬه ‪ ،‬ﻷﻧﻨﺎ ﻛﻤﺎ أﺷﺮﻧﺎ إﻟﻲ أن ﺑﻤﺠﺮد ﺗﻨﻔﯿﺬ اﻷﻣﺮ ‪ return‬ﻳﺘﻢ إرﺟﺎع‬
‫اﻟﻘﯿﻤﺔ اﻟﺘﺎﻟﯿﺔ ﻟﻪ ‪ ،‬ﺛﻢ إﻧﮫﺎء اﻟﺪاﻟﺔ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫إﺳﺘﺮﺟﺎع اﻟﻘﯿﻢ ﻣﻦ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getGuestName‬‬

‫{ )( ‪function getGuestName‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫;‪return userName‬‬
‫اﻟﻠﻘﺎء"(‪alert‬‬ ‫;)"إﻟﻲ‬
‫}‬

‫;)(‪var returnName = getGuestName‬‬

‫;) ‪alert( returnName‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻓﻌﻨﺪ ﺗﺸﻐﯿﻞ ھﺬا اﻟﻜﻮد ﻟﻦ ﺗﻈﮫﺮ رﺳﺎﻟﺔ إﻟﻲ اﻟﻠﻘﺎء ﻷﻧﮫﺎ أﺗﺖ ﺑﻌﺪ اﻷﻣﺮ ‪ return‬ﻛﻤﺎ ھﻮ ﻣﻮﺿﺢ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getGuestName‬‬

‫{ )( ‪function getGuestName‬‬
‫ﻓﻀﻠﻚ"(‪var userName = prompt‬‬ ‫;)""‪ ",‬أدﺧﻞ اﺳﻤﻚ ﻣﻦ‬
‫;‪return userName‬‬
‫اﻟﻠﻘﺎء"(‪alert‬‬ ‫;)"إﻟﻲ‬
‫}‬

‫‪98‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت ﻟﻠﺪوال‬

‫ﻣﻌﺎﻣﻼت اﻟﺪاﻟﺔ ‪:‬‬
‫ھﻲ ﻗﯿﻢ ﻳﺘﻢ ﺗﻤﺮﻳﺮھﺎ إﻟﻲ اﻟﺪاﻟﺔ ﻣﻦ ﺧﺎرﺟﮫﺎ ‪ ،‬ﻳﺘﻢ إﺳﺘﺨﺪاﻣﮫﺎ داﺧﻞ اﻟﺪاﻟﺔ‬
‫ﺛﻢ ﺗﻤﺴﺢ ﻣﻦ ذاﻛﺮة اﻟﺒﺮﻧﺎﻣﺞ ﺑﻤﺠﺮد إﻧﺘﮫﺎء ﻋﻤﻞ اﻟﺪاﻟﺔ‬

‫ﻃﺮﻳﻘﺔ ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت ﻟﻠﺪوال ‪:‬‬

‫ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت ‪ Arguments‬إﻟﻲ اﻟﺪوال ﺑﻌﺪة ﻃﺮق‬
‫‪ -‬ﻣﻌﺎﻣﻞ واﺣﺪ أو أﻛﺜﺮ‬
‫‪ -‬ﻣﻌﺎﻣﻼت إﺧﺘﯿﺎرﻳﻪ ‪Optional argument‬‬
‫‪ -‬ﻻ ﻳﺘﻢ ﻋﻤﻞ اي ﻣﻌﺎﻣﻼت ﻟﻠﺪاﻟﻪ وﻟﻜﻦ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻼت ﻟﻠﺪاﻟﻪ ﺑﻌﺪد ﻏﯿﺮ ﻣﺤﺪد‬
‫اي ﻳﻤﻜﻨﻚ ﺗﻤﺮﻳﺮ اي ﻋﺪد ﻣﻦ اﻟﻘﯿﻢ ‪.‬‬

‫دوال ذات ﻣﻌﺎﻣﻞ أو أﻛﺜﺮ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫ﺗﻤﺮﯾﺮ اﻟﻘﯿﻢ إﻟﻲ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫;‪var GuestName‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪setGuestName‬‬

‫{ ) ‪function setGuestName ( name‬‬
‫;‪GuestName = name‬‬
‫}‬

‫;)"اﻟﺤﺴﯿﻦ"(‪setGuestName‬‬
‫;) ‪alert( GuestName‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻳﺘﻢ ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت ﻟﻠﺪاﻟﺔ ﺑﯿﻦ أﻗﻮاس اﻟﺪاﻟﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪setGuestName‬‬

‫{ ) ‪function setGuestName ( name‬‬

‫ﺛﻢ ﻳﺘﻢ إﺳﺘﺨﺪام ھﺬا اﻟﻤﻌﺎﻣﻞ ﻋﻠﻲ اﻧﻪ ﻣﺘﻐﯿﺮ ﻣﻌﺮف داﺧﻞ اﻟﺪاﻟﺔ ﻛﻤﺎ ھﻢ ﻣﺒﯿﻦ ﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬

‫{ ) ‪function setGuestName ( name‬‬

‫;‪GuestName = name‬‬

‫‪99‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺛﻢ ﻳﺘﻢ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫;) "اﻟﺤﺴﯿﻦ" (‪setGuestName‬‬

‫ﻣﺜﺎل‬
‫ﻧﺮﻳﺪ ﻋﻤﻞ داﻟﺔ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻠﯿﻦ ﻟﮫﺎ ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ اﻷﻛﺒﺮ ﻟﻠﻘﯿﻤﺘﯿﻦ‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫ﺗﻤﺮﯾﺮ اﻟﻘﯿﻢ إﻟﻲ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getMax‬‬

‫{ ) ‪function getMax ( num1 , num2‬‬
‫‪return‬‬ ‫; ‪( num1 > num2 )? num1 : num2‬‬
‫}‬

‫;) )‪alert( getMax(21,34‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻓﻲ اﻟﺪاﻟﺔ ‪ getMax‬ﻗﻤﻨﺎ ﺑﺘﻤﺮﻳﺮ ﻣﻌﺎﻣﻠﯿﻦ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getMax‬‬

‫{ ) ‪function getMax ( num1 , num2‬‬

‫ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ اﻷﻛﺒﺮ ﻟﻠﻌﺪدﻳﻦ اﻟﻤﻤﺮران ﻟﮫﺎ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getMax‬‬

‫{ ) ‪function getMax ( num1 , num2‬‬
‫‪return‬‬ ‫; ‪( num1 > num2 )? num1 : num2‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫;) )‪alert( getMax(21,34‬‬

‫‪100‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫اﻟﻤﻌﺎﻣﻼت اﻹﺧﺘﯿﺎرﻳﺔ ‪Optional Arguments‬‬

‫ﻧﺮﻳﺪ ﻋﻤﻞ داﻟﺔ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻠﯿﻦ ﻟﮫﺎ ‪ ،‬وﻟﻜﻦ اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ﻳﻜﻮن ﻣﻌﺎﻣﻞ إﺧﺘﯿﺎري ‪optional argument‬‬
‫وﻇﯿﻔﺔ ھﺬه اﻟﺪاﻟﺔ ﻃﺒﺎﻋﺔ اﻟﻨﺺ اﻟﻤﻤﺮر ﻟﮫﺎ ‪ ،‬ﺑﺤﯿﺚ ﻳﻜﻮن اﻟﻤﻌﺎﻣﻞ اﻷول ﻋﺒﺎرة ﻋﻦ ﻣﺤﺘﻮي اﻟﻨﺺ اﻟﻤﺮاد ﻃﺒﺎﻋﺔ ‪ ،‬أﻣﺎ‬
‫اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ﻳﻜﻮن إﺧﺘﯿﺎر ﻹﻇﮫﺎر رﺳﺎﻟﺔ ﺗﺮﺣﯿﺐ أم ﻻ ‪.‬‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫ﺗﻤﺮﯾﺮ اﻟﻘﯿﻢ إﻟﻲ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪displayMessage‬‬

‫{ ) ‪function displayMessage ( messageText , dispalyHelloMessage‬‬
‫) ‪if( dispalyHelloMessage != null && dispalyHelloMessage‬‬
‫ﺑﻚ"(‪alert‬‬ ‫;)" ﻣﺮﺣﺒﺎ‬

‫;) ‪alert( messageText‬‬

‫}‬

‫ﻣﺮﺳﻠﺔ" (‪displayMessage‬‬ ‫"رﺳﺎﻟﺔ‬ ‫;) ‪, true‬‬

‫ﻣﺮﺳﻠﺔ" (‪displayMessage‬‬ ‫"رﺳﺎﻟﺔ‬ ‫;)‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫ﻓﻲ اﻟﺪاﻟﺔ ‪ displayMessage‬ﻗﻤﻨﺎ ﺑﺘﻤﺮﻳﺮ ﻣﻌﺎﻣﻠﯿﻦ اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ‪ dispalyHelloMessage‬ﻣﻌﺎﻣﻞ إﺧﺘﯿﺎري‬

‫اي رﺑﻤﺎ ﻻ ﻳﻤﺮر ﻟ ﻠﺪاﻟﺔ ﻋﻨﺪ إﺳﺘﺪﻋﺎﺋﮫﺎ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪displayMessage‬‬

‫{ ) ‪function displayMessage ( messageText , dispalyHelloMessage‬‬

‫ﺗﻢ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ‪ dispalyHelloMessage‬ﻣﺮﺗﯿﻦ أﺣﺪھﻤﺎ ﺗﻢ ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ﻟﮫﺎ ﺑﻘﯿﻤﺔ ‪true‬‬
‫واﻷﺧﺮ ﻟﻢ ﻳﻤﺮر ﻟﮫﺎ إﻻ اﻟﻤﻌﺎﻣﻞ اﻷول ﻓﻘﻂ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺮﺳﻠﺔ" (‪displayMessage‬‬ ‫"رﺳﺎﻟﺔ‬ ‫;) ‪, true‬‬

‫ﻣﺮﺳﻠﺔ" (‪displayMessage‬‬ ‫"رﺳﺎﻟﺔ‬ ‫;)‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬

‫‪101‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫ﺗﻤﺮﻳﺮ ﻋﺪد ﻏﯿﺮ ﻣﺤﺪد ﻣﻦ اﻟﻤﻌﺎﻣﻼت إﻟﻲ اﻟﺪاﻟﺔ‬

‫ﻓﯿﮫﺎ ﻻ ﻳﺘﻢ ﻋﻤﻞ اي ﻣﻌﺎﻣﻼت ﻟﻠﺪاﻟﻪ وﻟﻜﻦ ﻳﺘﻢ ﺗﻤﺮﻳﺮ ﻣﻌﺎﻣﻼت ﻟﻠﺪاﻟﻪ ﺑﻌﺪد ﻏﯿﺮ ﻣﺤﺪد‬
‫اي ﻳﻤﻜﻨﻚ ﺗﻤﺮﻳﺮ اي ﻋﺪد ﻣﻦ اﻟﻘﯿﻢ ‪.‬‬

‫ﻣﺜﺎل‬
‫ﻧﺮﻳﺪ ﻋﻤﻞ داﻟﺔ ﻳﻤﺮر ﻟﮫﺎ اي ﻋﺪد ﻣﻦ اﻟﻤﻌﺎﻣﻼت ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ اﻷﻛﺒﺮ ﻟﮫﺬه اﻟﻘﯿﻢ‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﺪوال >‪<Title‬‬ ‫ﺗﻤﺮﯾﺮ اﻟﻘﯿﻢ إﻟﻲ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪getMax‬‬

‫{ )( ‪function getMax‬‬
‫;‪var args = getMax.arguments‬‬
‫;]‪var max = args[0‬‬

‫{) ‪for( var i=1; i<args.length; i++‬‬

‫) ]‪if( max < args[i‬‬
‫;]‪max = args[i‬‬
‫}‬

‫;‪return max‬‬
‫}‬

‫;) )‪alert( getMax(21,34‬‬

‫;) )‪alert( getMax(2,43,5‬‬
‫;) )‪alert( getMax(2,1,3,4,7,4,8,1‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وھﺬا اﻟﻤﺜﺎل أﻗﺪﻣﻪ ﻟﻜﻢ اﻷن ﺑﺪون ﺷﺮح ﺣﺘﻲ ﻧﺘﻨﺎول اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ﻓﻲ اﻟﺠﺰء اﻟﺜﺎﻟﻲ ﻣﻦ اﻟﻜﺘﺎب‬

‫‪102‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﻨﻔﺴﮫﺎ ‪Recursive Function‬‬

‫ﻛﻤﺎ أﺷﺮﻧﺎ ﺳﺎﺑﻘﺎ أﻧﻨﺎ ﻳﻤﻜﻨﻨﺎ إﺳﺘﺪﻋﺎء داﻟﺔ ﻣﻦ داﺧﻞ داﻟﺔ أﺧﺮي وﻗﻤﻨﺎ ﺑﺘﻄﺒﯿﻖ أﻣﺜﻠﺔ ﻟﺬﻟﻚ اﻟﻐﺮض‬
‫وﻟﻜﻦ ھﻞ ﻳﻤﻜﻦ ﻟﺪاﻟﺔ أن ﺗﺴﺘﺪﻋﻲ ﻧﻔﺴﮫﺎ ﻣﻦ داﺧﻠﮫﺎ ؟‬

‫أﺟﯿﺐ ﺑﻨﻌﻢ ‪ ،‬وﻟﻜﻦ ﺑﺸﺮط وﺿﻊ ﺷﺮط ﻳﻨﮫﻲ إﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﻨﻔﺴﮫﺎ وإﻻ ﺳﻮف ﻳﺪﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻲ ﺣﻠﻘﺔ ﻣﻦ اﻟﺪورات‬
‫ﻏﯿﺮ ﻣﻨﺘﮫﯿﻪ ‪infinite loop‬‬

‫ﻣﺜﺎل ﻋﻠﻲ ذﻟﻚ ﻋﻤﻞ داﻟﺔ رﻳﺎﺿﯿﺔ ﺗﻘﻮم ﺑﺤﺴﺎب اﻟﻤﻀﺮوب اﻟﺮﻳﺎﺿﻲ ‪ Factorial‬ﻟﻘﯿﻤﺔ اﻟﻤﻌﺎﻣﻞ اﻟﻤﻤﺮر ﻟﮫﺎ‬
‫ﻳﺘﻢ ﺣﺴﺎب اﻟﻤﻀﺮوب اﻟﺮﻳﺎﺿﻲ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬
‫ﻣﻀﺮوب ‪ ٣‬ﻳﺴﺎوي ‪١ x ٢ x ٣‬‬
‫و ﻣﻀﺮوب ‪ ٤‬ﻳﺴﺎوي ‪١ x ٢ x ٣ x ٤‬‬
‫و ﻣﻀﺮوب ‪ ٥‬ﻳﺴﺎوي ‪١ x ٢ x ٣ x ٤ x ٥‬‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﻤﻀﺮوب >‪<Title‬‬ ‫ﺣﺴﺎب‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪factorial‬‬

‫{ ) ‪function factorial ( number‬‬
‫;‪if( number == 1 || number == 0 ) return 1‬‬

‫;‪return factorial( number-1 ) * number‬‬

‫}‬

‫;) )‪alert( factorial(1‬‬

‫;) )‪alert( factorial(4‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪103‬‬
 ‫ﺟﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﻤﺴﺘﻮي اﻷول‬

‫داﻟﺔ داﺧﻞ داﻟﺔ ‪inner Function‬‬

‫ﻳﻤﻜﻨﻨﺎ ﺗﻌﺮﻳﻒ داﻟﺔ داﺧﻞ داﻟﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪superFunction‬‬

‫{ ) ‪function superFunction ( number‬‬

‫‪//‬‬ ‫ﺗﻌﺮﯾﻒ اﻟﺪاﻟﺔ‬ ‫‪innerFunction‬‬

‫‪//‬‬ ‫داﻟﺔ داﺧﻠﺒﺔ‬
‫{ ) ‪function innerFunction ( number‬‬

‫}‬

‫اﻟﺜﺎﻧﻲ" ‪return‬‬ ‫;"إﻟﻲ اﻟﻠﻘﺎء ﻣﻊ اﻟﺠﺰء‬

‫}‬

‫وھﺬا اﻟﻨﻮع اﻟﻤﺘﻘﺪم ﻣﻦ اﻟﺪوال ﺳﻮف ﻳﺘﻢ ﺷﺮﺣﻪ ﻓﻲ اﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب اﻟﺨﺎص ﺑﺎﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ ﻟﻠﺠﺎﻓﺎ‬
‫ﺳﻜﺮﺑﺖ ‪.‬‬

‫‪104‬‬