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

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

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

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

‫ﻳﻘﺪم ھﺬا اﻟﺠﺰء ﻣﻦ اﻟﻜﺘﺎب ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪام ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻓﻲ ﺑﺮﻣﺠﺔ اﻟﻮﻳﺐ‬

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

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

‫إھﺪاء ‪:‬‬

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

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

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

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

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

 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻤﺤﺘﻮﻳﺎﺕ‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪٣ ...............................................................................................Arrays‬‬ ‫اﻟﻔﺼﻞ اﻷول ‪:‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻷﺑﻌﺎد اﻟﻤﺘﻌﺪدة ‪١٧ ........................................Multidimensional Arrays‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ ‪:‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص‪٣٧ ................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ‪:‬‬
‫ﻛﺎﺋﻦ اﻟﻨﺼﻮص‪٤٧ .......................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ ‪:‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪٦٣ ..... ..........................................Regular Expressions‬‬ ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪:‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﺎرﯾﺦ ‪٧٨ ..................................................................................................‬‬ ‫اﻟﻔﺼﻞ اﻟﺴﺎدس ‪:‬‬

‫‪2‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻷﻭﻝ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺎﺕ‬
‫‪Arrays‬‬

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

‫اﻟﻜﺎﺋﻨﺎت ﻓﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬ ‫•‬

‫ﻣﺎ ھﻲ اﻟﻤﺼﻔﻮﻓﺎت‬ ‫•‬
‫إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ‬ ‫•‬
‫اﻟﻤﺼﻔﻮﻓﺎت ﺑﺸﻜﻞ ﻋﺎم‬ ‫•‬
‫ﺗﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ‬ ‫•‬
‫ﻣﻞء اﻟﻤﺼﻔﻮﻓﺔ ﺑﺎﻟﻘﯿﻢ‬ ‫•‬
‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺠﻤﻌﺔ ‪Associative Arrays‬‬ ‫•‬
‫ﺣﺬف ﻋﻨﺼﺮ ﻣﻦ ﻣﺼﻔﻮﻓﺔ‬ ‫•‬

‫‪3‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻜﺎﺋﻨﺎت ﻓﻲ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬

‫ﺗﻄﻮر أﺳﻠﻮب اﻟﺒﺮﻣﺠﯿﺎت ﻋﻠﻲ ﻣﺪي ‪ ٥٠‬ﻋﺎم وﻗﺪ أﺛﻤﺮ ھﺬا اﻟﺘﻄﻮر ﻋﻠﻲ ﻇﮫﻮر ﻃﺮق واﺳﺘﺮاﺗﯿﺠﯿﺎت ﻣﺨﺘﻠﻔﺔ ﺑﮫﺪف ﺗﻜﻮﻳﻦ‬
‫ﺑﺮﻣﺠﯿﺎت ﻋﺎﻟﯿﺔ اﻟﺠﻮدة وﻟﺘﻘﻠﯿﻞ اﻟﻮﻗﺖ واﻟﺠﮫﺪ اﻟﻤﺴﺘﮫﻠﻚ ﻓﻲ ﺗﻄﻮﻳﺮھﺎ إﻟﻰ اﻗﻞ ﺣﺪ ﻣﻤﻜﻦ ‪.‬‬
‫وﻃﺮﻳﻘﺔ ﺗﻄﻮﻳﺮ اﻟﺒﺮﻣﺠﯿﺎت اﻷﻛﺜﺮ ﻧﺠﺎﺣﺎ و ﺷﯿﻮﻋﺎ ﻓﻲ اﻻﺳﺘﺨﺪام اﻟﯿﻮم ھﻲ اﻟﻄﺮﻳﻘﺔ اﻟﻤﻮﺟﮫﺔ ﻟﻠﻜﺎﺋﻨﺎت ‪Object‬‬
‫‪. Oriented Programming‬‬

‫ﻓﮫﺬه اﻟﻄﺮﻳﻘﺔ ﺗﺸﻜﻞ ﻋﻨﺎﺻﺮ اﻟﺒﺮﻣﺠﺔ أو اﻟﺘﻄﺒﯿﻖ ﻋﻠﻰ ﺻﻮره ﻛﺎﺋﻦ ‪ Object‬ﺗﻌﺮف ﺧﻮاﺻﻪ وﻃﺮﻗﻪ وﺑﻌﺪ ذﻟﻚ ﻳﻤﻜﻦ‬
‫اﺳﺘﺨﺪاﻣﻪ ﻷ داء ﻣﮫﺎم ﺧﺎﺻﺔ ﻛﻤﺎ ﺳﻨﺮي إن ﺷﺎء اﷲ ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪.‬‬

‫ﻟﻜﻨﻨﺎ ﻟﻸﺳﻒ ﻻ ﻧﺴﺘﻄﯿﻊ اﻟﻘﻮل ﺑﺄن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﺪﻋﻢ ﺑﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﺎت اﻟﻤﻮﺟﮫﺔ ﻛﻤﺎ ھﻮ اﻟﺤﺎل ﺑﻠﻐﺔ اﻟﺴﻲ ﺑﻠﺲ‬
‫ﺑﻠﺲ أو اﻟﺠﺎﻓﺎ ﻛﻤﺎ ﺳﻮف ﻳﺘﻀﺢ ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬وﻟﻜﻨﻨﺎ ﻳﻤﻜﻨﻨﺎ اﻟﻘﻮل ﺑﺄن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﺪﻋﻢ‬
‫ﺑﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﺎت اﻷﺳﺎﺳﯿﺔ او اﻹﻋﺘﻤﺎدﻳﺔ ‪ Object Base‬أي إﻋﺘﻤﺎدﻧﺎ ﻋﻠﻲ إﺳﺘﺨﺪام ﻛﺎﺋﻨﺎت ﻣﺒﻨﯿﺔ داﺧﻞ ﻟﻐﺔ‬
‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪ built-in Objects‬ﻣﺜﻞ اﻟﻜﺎﺋﻦ ‪ window‬و اﻟﻜﺎﺋﻦ ‪. document‬‬

‫ﻛﻤﺎ ﻧﻌﻠﻢ أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻢ ﺗﺼﻤﯿﻤﮫﺎ ﻟﺒﺮﻣﺠﺔ ﺻﻔﺤﺎت اﻟﻮﻳﺐ ‪ ،‬ﻟﺬﻟﻚ ﺗﻢ ﺑﻨﺎء اﻟﻜﺎﺋﻨﺎت اﻷﺳﺎﺳﯿﺔ ﻟﻠﻐﺔ اﻟﺠﺎﻓﺎ‬
‫ﺳﻜﺮﺑﺖ ﺣﺘﻲ ﺗﻮاﻓﻖ ﻣﻤﯿﺰات ﻣﺘﺼﻔﺤﺎت اﻷﻧﺘﺮﻧﺖ ) ﻣﺜﻞ ﻣﺘﺼﻔﺢ أﻧﺘﺮﻧﺖ أﻛﺴﺒﻠﻮرار ( ﻣﺜﻞ اﻟﻜﺎﺋﻦ ‪ window‬و ‪document‬‬
‫‪ ،‬ﺑﺎﻹﺿﺎﻓﺔ إﻟﻲ أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺗﻮﻓﺮ ﺑﻌﺾ اﻟﻜﺎﺋﻨﺎت اﻷﺧﺮي اﻟﻤﻔﯿﺪة ﻣﺜﻞ اﻟﻜﺎﺋﻦ ‪ Date‬و ‪ Array‬و ‪. String‬‬

‫وﻟﻜﻦ ﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ ‪Object‬‬

‫ﺑﺸﻜﻞ ﻣﺨﺘﺼﺮ‪:‬‬
‫اﻟﻜﺎﺋﻦ ھﻮ ﻣﺘﻐﯿﺮ ﻣﺮﻛﺐ ﻳﻨﺸﺄ ﻣﻦ ﻗﺎﻟﺐ ‪ class‬ھﺬا اﻟﻘﺎﻟﺐ ﻳﺤﺪد اﻟﺨﻮاص واﻟﻄﺮق اﻟﻤﻤﯿﺰة ﻟﻠﻜﺎﺋﻨﺎت اﻟﻨﺎﺷﺌﺔ ﻣﻨﻪ ‪.‬‬

‫اﻟﻜﺎﺋﻦ ﻣﻦ‬ ‫وﻳﺘﻜﻮن‬

‫ﺧﺼﺎﺋﺺ‬ ‫•‬
‫ﻃﺮق أو وﻇﺎﺋﻒ‬ ‫•‬
‫أﺣﺪاث‬ ‫•‬

‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻧﻔﺘﺮض أن ھﻨﺎك ﻛﺎﺋﻦ ﻳﻤﺜﻞ ﺳﯿﺎرة "ﻋﺮﺑﺔ" ھﺬه اﻟﺴﯿﺎرة ﻟﮫﺎ اﻟﺘﺎﻟﻲ ‪:‬‬
‫• ﺧﺼﺎﺋﺺ ‪Properties‬‬
‫ﻣﺜﻞ ﻟﻮﻧﮫﺎ ‪ ،‬ﻣﻮدﻳﻠﮫﺎ‬
‫• ﻃﺮق أو وﻇﺎﺋﻒ ‪Methods‬‬
‫وﻟﮫﺎ ﻋﺪة وﻇﺎﺋﻒ ﺗﺆدﻳﮫﺎ ﻣﺜﻞ أﻧﮫﺎ ﺗﻤﺸﻲ وﺗﻘﻒ و ﺗﺴﺘﺪﻳﺮ‬

‫‪4‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺎ ھﻲ اﻟﻤﺼﻔﻮﻓﺎت‬
‫ﻗﺒﻞ أن ﻧﺬھﺐ ﻟﺘﻌﺮﻳﻒ ﻣﺎ ھﻲ اﻟﻤﺼﻔﻮﻓﺎت ‪ ،‬ھﺐ أﻧﻨﺎ ﻧﺮﻳﺪ ﻋﻤﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫ﻧﺮﻳﺪ ﻃﺒﺎﻋﺔ اﻟﺮﺳﺎﺋﻞ اﻟﺘﺎﻟﯿﺔ‬
‫"ﻣﺮﺣﺒﺎ ﺑﻚ"‬
‫"ﻧﺤﻦ اﻷن ﻧﺘﻌﻠﻢ اﻟﻤﺼﻔﻮﻓﺎت"‬
‫"اﻟﺤﻤﺪ ﷲ"‬

‫ﻓﻌﻠﻲ ﺣﺴﺐ ﻣﺎ ﺗﻌﻠﻤﻨﺎه ﻓﻲ ﻓﺼﻞ اﻟﻤﺘﻐﯿﺮات‬

‫ﻓﺴﻮف ﻧﻘﻮم ﺑﺘﻌﺮﻳﻒ ﺛﻼث ﻣﺘﻐﯿﺮات ﺣﺘﻲ ﻧﺤﻔﻆ ﻓﯿﮫﺎ اﻟﺮﺳﺎﺋﻞ اﻟﺴﺎﺑﻘﺔ ‪ ،‬ﻛﻤﺎ ﻳﻠﻲ‬

‫ﺑﻚ" = ‪var Msg1‬‬ ‫;"ﻣﺮﺣﺒﺎ‬

‫اﻟﻤﺼﻔﻮﻓﺎت" = ‪var Msg2‬‬ ‫;"ﻧﺤﻦ اﻷن ﻧﺘﻌﻠﻢ‬
‫= ‪var Msg3‬‬ ‫;"اﻟﺤﻤﺪ ﷲ"‬

‫ﺛﻢ ﻧﻘﻮم ﺑﻄﺒﺎﻋﺔ ھﺬه اﻟﺮﺳﺎﺋﻞ ﻛﻤﺎ ﻳﻠﻲ‬

‫;) ‪alert( Msg1‬‬

‫;) ‪alert( Msg2‬‬
‫;) ‪alert( Msg3‬‬

‫ﺗﺨﯿﻞ أﻧﻚ ﺗﺮﻳﺪ ﻋﻤﻞ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﻟﯿﺲ ﻋﻠﻲ ﺛﻼث ﻣﺘﻐﯿﺮات ﺑﻞ ﻋﻠﻲ ‪ ١٠٠‬ﻣﺘﻐﯿﺮ ﻧﺼﻲ أو ﻗﻞ ﻋﺪد ﻏﯿﺮ ﻣﺤﺪد‬
‫ﻣﻦ اﻟﻤﺘﻐﯿﺮات ‪،‬رﺑﻤﺎ ﻳﺴﺒﺐ ﻟﻚ ھﺬا إﺣﺴﺎس ﺑﺎﻟﻀﯿﻖ ﻟﻜﺜﺮة اﻷﻛﻮاد اﻟﺘﻲ ﺳﻮف ﺗﻜﺘﺐ ﻹﺗﻤﺎم ھﺬه اﻟﻤﮫﻤﺔ‬

‫ﻣﻦ ھﻨﺎ أﺗﺖ اﻟﺤﺎﺟﺔ ﻟﻌﻤﻞ ﻧﻮع ﺟﺪﻳﺪ ﻣﻦ اﻟﻤﺘﻐﯿﺮات وھﻮ ﻣﺎ ﻳﻄﻠﻖ ﻋﻠﯿﻪ اﻟﻤﺼﻔﻮﻓﺎت ‪Arrays‬‬

‫وﻟﻜﻦ ﻣﺎ ھﻲ اﻟﻤﺼﻔﻮﻓﺎت ‪Arrays‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ھﻲ ﻣﻦ إﺣﺪي أﻧﻮاع اﻟﻤﺘﻐﯿﺮات وﻟﻜﻦ ﻳﻤﻜﻨﻚ أن ﺗﺨﺰن ﺑﮫﺬا اﻟﻤﺘﻐﯿﺮ ﻗﯿﻤﺔ واﺣﺪة أو أﻛﺜﺮ ‪.‬‬

‫‪5‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ‬
‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء اﻟﻤﺼﻔﻮﻓﺔ ﺑﻌﺪة ﻃﺮق ﻛﻤﺎ ﻳﻠﻲ‬

‫‪ - ١‬إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﻓﺎرﻏﺔ ) ﻻ ﺗﺤﺘﻮي ﻋﻠﻲ ﻋﻨﺎﺻﺮ (‬

‫;)(‪var myArray = new Array‬‬

‫‪ - ٢‬إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﻋﻨﺎﺻﺮ ﻋﺪدھﺎ ‪ ) n‬ﺣﯿﺚ ‪ n‬ﺗﻤﺜﻞ ﻋﺪد ﺻﺤﯿﺢ ﻣﻮﺟﺐ (‬

‫;)‪var myArray = new Array(n‬‬

‫إي ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺧﻤﺲ ﻋﻨﺎﺻﺮ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var myArray = new Array(5‬‬

‫‪ - ٣‬إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ وﻣﻞء ﻋﻨﺎﺻﺮھﺎ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ‬

‫ﻹﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ وﻣﻞء ﻋﻨﺎﺻﺮھﺎ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ﻳﻮﺟﺪ ﻋﺪة ﻃﺮق ﻹﺗﻤﺎم ذﻟﻚ ‪:‬‬

‫أ‪-‬‬
‫;)"‪var myArray = new Array("item1"," item2"," item3‬‬

‫إي ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ وإﻋﻄﺎء ﻗﯿﻢ ﻟﻌﻨﺎﺻﺮھﺎ ﺑﺸﻜﻞ ﻣﺒﺪﺋﻲ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
‫ﺳﻮف ﻧﻘﻮم ﺑﺈﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﺗﺴﻤﻲ ‪ empArray‬ﺗﺤﺘﻮي ﻋﻠﻲ اﺳﻤﺎء ﺛﻼث ﻣﻮﻇﻔﯿﻦ‬

‫اﷲ"(‪var empArray = new Array‬‬ ‫;)"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ‬

‫ب‪-‬‬
‫;]"‪var myArray = new Array["item1"," item2"," item3‬‬

‫أو ﺑﺪون إﺳﺘﺨﺪام ﻛﻠﻤﺔ ‪ new Array‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;]"‪var myArray = ["item1"," item2"," item3‬‬

‫إي ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ ﻣﺼﻔﻮﻓﺔ وإﻋﻄﺎء ﻗﯿﻢ ﻟﻌﻨﺎﺻﺮھﺎ ﺑﺸﻜﻞ ﻣﺒﺪﺋﻲ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
‫ﺳﻮف ﻧﻘﻮم ﺑﺈﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﺗﺴﻤﻲ ‪ empArray‬ﺗﺤﺘﻮي ﻋﻠﻲ اﺳﻤﺎء ﺛﻼث ﻣﻮﻇﻔﯿﻦ‬

‫اﷲ"[‪var empArray = new Array‬‬ ‫;]"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ‬

‫أو‬
‫اﷲ"[ = ‪var empArray‬‬ ‫;]"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ‬

‫‪6‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻤﺼﻔﻮﻓﺎت ﺑﺸﻜﻞ ﻋﺎم‬

‫اﻟﻤﺼﻔﻮﻓﺔ ﻧﺴﺘﻄﯿﻊ ﺗﺸﺒﯿﮫﮫﺎ ﺑﻌﻤﺎرة ‪ .‬اﻟﻌﻤﺎرة ﻳﺤﺘﻮي ﻛﻞ ﻃﺎﺑﻖ ﻣﻨﮫﺎ ﻋﻠﻰ ﺷﻘﺔ واﺣﺪة ‪.‬‬
‫ﻟﻨﻔﺮض أن اﻟﻌﻤﺎرة ﺗﺘﻜﻮن ﻣﻦ أرﺑﻌﺔ ﻃﻮاﺑﻖ‬
‫ﻓﻜﺎن اﻟﻄﺎﺑﻖ اﻷول ﻳﺴﻜﻦ ﺑﻪ اﻟﺤﺴﯿﻦ واﻟﻄﺎﺑﻖ اﻟﺜﺎﻧﻲ ﻳﺴﻜﻦ ﺑﻪ إﺳﻤﺎﻋﯿﻞ واﻟﻄﺎﺑﻖ اﻟﺜﺎﻟﺚ ﻳﺴﻜﻦ ﺑﻪ إﺑﺮاھﯿﻢ واﻟﻄﺎﺑﻖ‬
‫اﻟﺮاﺑﻊ ﻳﺴﻜﻦ ﺑﻪ ﻳﻮﺳﻒ ‪.‬‬

‫إذا ھﻨﺎ ﻟﺪﻳﻨﺎ ﻋﻤﺎرة ﺗﺘﻜﻮن ﻣﻦ أرﺑﻌﺔ ﻃﻮاﺑﻖ ﻛﻞ ﻃﺎﺑﻖ ﻳﺤﺘﻮي ﻋﻠﻰ ﺷﺨﺺ ﻓﮫﺬا ھﻮ اﻟﺤﺎل ﺑﺎﻟﻨﺴﺒﺔ‬
‫ﻟﻠﻤﺼﻔﻮﻓﺔ ﻓﺎﻟﻌﻤﺎرة ھﻲ أﺳﻢ اﻟﻤﺼﻔﻮﻓﺔ ‪ .‬وﻋﺪد اﻟﻄﻮاﺑﻖ اﻷرﺑﻌﺔ ھﻮ ﻋﺪد ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ واﻟﺘﻰ ھﻲ أرﺑﻌﺔ‬
‫واﻻﺷﺨﺎص اﻟﺬي ﻛﺎن ﻛﻞ ﺷﺨﺺ ﻣﻨﮫﻢ ﻳﺴﻜﻦ ﺑﻄﺎﺑﻖ ھﻢ ﻗﯿﻤﺔ ﻛﻞ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

‫دﻋﻨﺎ ﻧﻄﺒﻖ ھﺬا اﻟﻤﺜﺎل ﺑﺸﻜﻞ ﺑﺮﻣﺠﻲ‬

‫ﻛﻠﻤﺔ ﻋﻤﺎرة ﻟﻨﺨﺘﺼﺮھﺎ وﻧﺴﻤﯿﮫﺎ ‪arr‬‬

‫;)"ﯾﻮﺳﻒ "‪",‬إﺑﺮاﻫﯿﻢ "‪",‬إﺳﻤﺎﻋﯿﻞ"‪",‬اﻟﺤﺴﯿﻦ"(‪var arr = new Array‬‬

‫إذا ھﻨﺎ اﻟﻤﻮﻗﻊ اﻷول ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ﻳﺴﺎوي اﻟﺤﺴﯿﻦ واﻟﻤﻮﻗﻊ اﻟﺜﺎﻧﻲ ﻳﺴﺎوي إﺳﻤﺎﻋﯿﻞ واﻟﻤﻮﻗﻊ اﻟﺜﺎﻟﺚ ﻳﺴﺎوي‬
‫إﺑﺮاھﯿﻢ واﻟﻤﻮﻗﻊ اﻟﺮاﺑﻊ ﻳﺴﺎوي ﻳﻮﺳﻒ ‪.‬‬

‫وﻟﻜﻦ ﻋﺎدة ﻓﻲ اﻟﻤﺼﻔﻮﻓﺎت ﻧﺒﺪأ ﻣﻦ اﻟﺼﻔﺮ وﻟﯿﺲ ﻣﻦ اﻟﻮاﺣﺪ أي ﻧﻘﻮل ﻣﻮﻗﻊ اﻟﺼﻔﺮ ﻳﺴﺎوي اﻟﺤﺴﯿﻦ و اﻟﻤﻮﻗﻊ‬
‫اﻻول ﻳﺴﺎوي إﺳﻤﺎﻋﯿﻞ واﻟﻤﻮﻗﻊ اﻟﺜﺎﻧﻲ ﻳﺴﺎوي إﺑﺮاھﯿﻢ واﻟﻤﻮﻗﻊ اﻟﺜﺎﻟﺚ ﻳﺴﺎوي ﻳﻮﺳﻒ ‪.‬‬

‫ﻟﻌﻠﻚ إﻧﺰﻋﺠﺖ ﻣﻦ ذﻟﻚ ‪ ،‬ﻻ داﻋﻲ ﻟﮫﺬا اﻹﻧﺰﻋﺎج أﻋﺘﺒﺮ اﻟﻌﻤﺎرة ﺗﺘﻜﻮن ﻣﻦ ﻃﺎﺑﻖ أرﺿﻲ وﻃﺎﺑﻖ أول وﻃﺎﺑﻖ ﺛﺎﻧﻲ وﻃﺎﺑﻖ‬
‫ﺛﺎﻟﺚ ‪ ،‬إذا اﻟﺤﺴﯿﻦ ﺳﻮف ﻳﺴﻜﻦ ﻓﻲ اﻟﻄﺎﺑﻖ اﻻرﺿﻲ وھﻮ اﻟﺼﻔﺮ أي ﻣﻮﻗﻊ رﻗﻢ ﺻﻔﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ ‪ ،‬وإﺳﻤﺎﻋﯿﻞ ﻓﻲ‬
‫اﻟﻄﺎﺑﻖ اﻷول أي اﻟﻤﻮﻗﻊ اﻻول ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ وھﻜﺬا ‪.‬‬

‫ﺗﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ‬
‫ﻧﻘﺼﺪ ﺑﺘﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ اي ﻛﯿﻔﯿﺔ ﺗﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ ﺑﺪاﺧﻞ ذاﻛﺮة اﻟﺠﮫﺎز‬
‫ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻛﯿﻒ ﻳﺘﻢ ﺗﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﯿﺔ ﺑﺬاﻛﺮة اﻟﺠﮫﺎز‬

‫;)‪var a = new Array(50,90,20,45‬‬

‫ﻳﻮﺿﺢ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ﻛﯿﻔﯿﺔ ﺗﻤﺜﯿﻞ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺴﺎﺑﻘﺔ‬

‫‪7‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﻞء اﻟﻤﺼﻔﻮﻓﺔ ﺑﺎﻟﻘﯿﻢ‬

‫ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﺳﺎﺑﻘﺎ ﻛﯿﻔﯿﺔ إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ وﻣﻞء ﻋﻨﺎﺻﺮھﺎ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ‪ ،‬ﻳﻤﻜﻨﻨﺎ أﻳﻀﺎ إﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﺛﻢ ﻣﻞء‬
‫ﻋﻨﺎﺻﺮھﺎ ﺑﻌﺪ ذﻟﻚ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var arr = new Array(3‬‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﻤﻞء اﻟﻤﺼﻔﻮﻓﺔ‬

‫;‪arr[0] = 100‬‬
‫;‪arr[1] = 30‬‬
‫;‪arr[2] = 230‬‬

‫ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ ﺗﺤﺪﻳﺪ ﻣﺼﻔﻮﻓﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺛﻼث ﻋﻨﺎﺻﺮ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var arr = new Array(3‬‬

‫ﺛﻢ ﻗﻤﻨﺎ ﺑﺘﺤﺪﻳﺪ اﻟﻘﯿﻢ اﻟﻤﺨﺰﻧﺔ ﺑﻜﻞ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ إﻳﺘﺪاء ﻣﻦ اﻟﻌﻨﺼﺮ اﻟﻤﻮﺟﻮد ﺑﺎﻟﻤﻮﻗﻊ ﺻﻔﺮ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﻤﻞء اﻟﻤﺼﻔﻮﻓﺔ‬

‫;‪arr[0] = 100‬‬
‫;‪arr[1] = 30‬‬
‫;‪arr[2] = 230‬‬

‫‪8‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫وﻟﺘﻘﻠﯿﻞ ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻤﻜﻨﻨﺎ إﺳﺘﺨﺪام ﺣﻠﻘﺎت اﻟﺘﻜﺮار ﻟﻤﻞء اﻟﻤﺼﻔﻮﻓﺎت ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫;)‪var arr = new Array(100‬‬

‫‪//‬‬ ‫ﻧﻘﻮم ﺑﻤﻞء اﻟﻤﺼﻔﻮﻓﺔ‬

‫{) ‪for( var i = 0; i<3; i++‬‬
‫;‪arr[i] = 30‬‬
‫}‬

‫{) ‪for( i = 3; i<6; i++‬‬

‫;‪arr[i] = 13‬‬
‫}‬

‫{) ‪for( i = 6; i<100; i++‬‬

‫;‪arr[i] = 40‬‬
‫}‬

‫وﺑﮫﺬه اﻟﻄﺮﻳﻘﺔ ﺳﻮف ﻳﺘﻢ ﺗﺤﺪﻳﺪ ‪ ١٠٠‬ﻋﻨﺼﺮ ﻟﻠﻤﺼﻔﻮﻓﺔ ‪ arr‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var arr = new Array(100‬‬

‫ﺛﻢ ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ ‪ ٣٠‬ﺑﺪاﺧﻞ اﻟﺜﻼث ﻋﻨﺎﺻﺮ اﻷوﻟﻲ ﻟﻠﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﻳﻠﻲ‬

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

‫;‪arr[i] = 30‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ ‪ ١٣‬ﺑﺎﻟﻌﻨﺎﺻﺮ اﻟﺜﻼث اﻟﺘﺎﻟﯿﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫{) ‪for( i = 3; i<6; i++‬‬

‫;‪arr[i] = 13‬‬
‫}‬

‫ﺛﻢ ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﻘﯿﻤﺔ ‪ ٤٠‬ﺑﺎﻟﻌﻨﺎﺻﺮ اﻟﺘﺎﻟﯿﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫{) ‪for( i = 6; i<100; i++‬‬

‫;‪arr[i] = 40‬‬
‫}‬

‫‪9‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺗﻤﺮﯾﻦ ﻛﺘﺎﺑﺔ ﻣﺤﺘﻮﯾﺎت اﻟﻤﺼﻔﻮﻓﺔ‬

‫>‪<HTML dir=rtl‬‬
‫>‪ </Title‬اﻟﻤﺼﻔﻮﻓﺎت >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻣﺤﻤﺪ"(‪var empNameArray = new Array‬‬ ‫;)"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ اﷲ"‪",‬اﻟﺤﺴﯿﻦ‬
‫ﻣﺤﻤﺪ"[ = ‪// var empNameArray‬‬ ‫;]" أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪ ",‬ﻣﺤﻤﺪ ﻋﺒﺪ اﷲ"‪",‬اﻟﺤﺴﯿﻦ‬

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

‫;) ]‪document.write(empNameArray[i‬‬
‫;) " >‪document.write( "<br‬‬
‫}‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

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

‫‪10‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ for in‬اﻟﺘﻜﺮارﻳﺔ‬

‫ﻛﻤﺎ ﻗﺪ ﻛﻨﺎ أﺷﺮﻧﺎ ﺑﺎﻟﺠﺰء اﻷول ﻣﻦ ھﺬا اﻟﻜﺘﺎب أن ﺟﻤﻠﺔ ‪ for in‬ﺗﺴﺘﺨﺪم ﻟﻌﻤﻞ ﺗﻜﺮار ﻟﻠﻤﺘﻐﯿﺮات ﻣﻦ اﻟﻨﻮع اﻟﻜﺎﺋﻨﻲ‬
‫‪ objects‬ﻣﺜﻞ اﻟﻤﺼﻔﻮﻓﺎت ‪Arrays‬‬

‫ﻻﺣﻆ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻋﻨﺪﻣﺎ ﻗﻤﻨﺎ ﺑﺈﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ ، for‬ﻓﻘﺪ إﺣﺘﺠﻨﺎ ﻟﺘﺤﺪﻳﺪ ﻋﺪد ﻣﺮات اﻟﺘﻜﺮر ﺑﻤﻘﺪار ﻳﺴﺎوي ﻃﻮل‬
‫اﻟﻤﺼﻔﻮﻓﺔ ) اي ﺑﻌﺪد ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ( ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺤﻤﺪ"(‪var empNameArray = new Array‬‬ ‫;)"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ اﷲ"‪",‬اﻟﺤﺴﯿﻦ‬

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

‫;) ]‪document.write(empNameArray[i‬‬
‫;) " >‪document.write( "<br‬‬
‫}‬

‫وﻟﻜﻨﻨﺎ ﻋﻨﺪ إﺳﺘﺨﺪاﻣﻨﺎ ﻟﺠﻤﻠﺔ ‪ for in‬ﻻ ﻧﺤﺘﺎج ﻟﺘﺤﺪﻳﺪ ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ‪ ،‬ﻷﻧﮫﺎ ﺑﺸﻜﻞ ﺗﻠﻘﺎﺋﻲ ﺳﻮف ﻳﺘﻢ اﻟﺘﻜﺮار ﺑﻌﺪد‬
‫ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

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

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

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

‫ﻣﺜﺎل ﺗﻮﺿﯿﺤﻲ‬
‫ﻟﺤﺴﺎب ﻣﺠﻤﻮع ﻗﯿﻢ اﻟﻤﺼﻔﻮﻓﺔ‬

‫>‪<HTML dir=rtl‬‬
‫>‪ </Title‬اﻟﻤﺼﻔﻮﻓﺎت >‪<Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫;)‪var numArray = new Array(2,34,45,32,101,-2,0,3,1‬‬
‫;‪var sum = 0‬‬

‫{) ‪for( var index in numArray‬‬

‫;]‪sum += numArray[index‬‬

‫;) ]‪document.write(numArray[index‬‬
‫;) " >‪document.write( "<br‬‬
‫}‬

‫"(‪document.write‬‬ ‫"ﻣﺠﻤﻮع ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﯾﺴﺎوي ‪:‬‬ ‫;)‪+ sum‬‬

‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬
‫‪11‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫ﻣﺜﺎل‬

‫ﻧﺮﻳﺪ ﻋﻤﻞ داﻟﺔ ﻳﻤﺮر ﻟﮫﺎ اي ﻋﺪد ﻣﻦ اﻟﻤﻌﺎﻣﻼت ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ اﻷﻛﺒﺮ ﻟﮫﺬه اﻟﻘﯿﻢ‬
‫وﻗﺪ ﺗﻢ اﻹﺷﺎرة ﻟﮫﺬا اﻟﻤﺜﺎل ﺳﺎﺑﻘﺎ ﺑﺎﻟﺠﺰء اﻷول ﻣﻦ اﻟﻜﺘﺎب ﻛﻤﺎ ﻳﻠﻲ‬

‫>‪<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++‬‬

‫‪12‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫) ]‪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‬‬

‫وﻟﺬﻟﻚ ﻗﻤﻨﺎ ﺑﺘﻌﺮﻳﻒ اﻟﺪاﻟﺔ ‪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‬‬

‫وﻳﺘﻢ إﺳﺘﻘﺒﺎل اﻟﻤﻌﺎﻣﻼت اﻟﻤﻤﺮرة ﻟﮫﺬة اﻟﺪاﻟﺔ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﺑﻌﺔ ﻟﻜﺎﺋﻦ ھﺬة اﻟﺪاﻟﺔ‬
‫وھﺬه اﻟﻤﺼﻔﻮﻓﺔ ﺗﺴﻤﻲ ‪ arguments‬وھﻲ أﺣﺪ ي ﺧﺼﺎﺋﺺ اﻟﺪاﻟﺔ ‪ getMax‬ﻛﻤﺎ ﻳﻠﻲ‬

‫{ )( ‪function getMax‬‬
‫;‪var args = getMax.arguments‬‬

‫‪.‬‬
‫‪.‬‬
‫‪.‬‬
‫}‬

‫وﺑﺬﻟﻚ ﻳﻜﻮن اﻟﻤﺘﻐﯿﺮ ‪ args‬ﻳﺸﯿﺮ إﻟﻲ ﻣﺼﻔﻮﻓﺔ ﻋﻨﺎﺻﺮھﺎ ھﻲ اﻟﻤﻌﺎﻣﻼت اﻟﻤﻤﺮرة ﻟﻠﺪاﻟﺔ ‪.‬‬

‫‪13‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺠﻤﻌﺔ ‪Associative Arrays‬‬

‫ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﺳﺎﺑﻘﺎ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ ھﺬا اﻟﻌﻨﺼ ﺮ ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻟﺘﻌﯿﻦ‬
‫ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ اﻷول ﺑﺎﻟﻤﺼﻔﻮﻓﺔ ‪ arr‬ﻧﻘﻮم ﺑﺈﺳﺘﺨﺪام ﻣﻮﻗﻊ ھﺬا اﻟﻌﻨﺼﺮ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ وھﻮ ﺻﻔﺮ ﻟﺬﻟﻚ ﻟﺘﻌﯿﻦ ﻗﯿﻤﺘﻪ ﻧﻜﺘﺐ‬
‫]‪ arr[0‬ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺤﻤﺪ"(‪var arr = new Array‬‬ ‫;)"أﺣﻤﺪ ﻣﺤﺴﻦ"‪",‬ﺣﻤﺪي ﻏﺎﻧﻢ"‪",‬ﻣﺤﻤﺪ ﻋﺒﺪ اﷲ"‪",‬اﻟﺤﺴﯿﻦ‬

‫‪//‬‬ ‫اﻟﻌﻨﺼﺮ اﻷول ﺑﻬﺎ‬

‫;) ]‪document.write( arr[0‬‬

‫وﺑﺬﻟﻚ ﻧﺨﻠﺺ إﻟﻲ أﻧﻪ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻦ ﺧﻼل ﻣﻮاﻗﻌﮫﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ‬

‫أﻣﺎ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺼﻔﻮﻓﺎت اﻟﻤﺠﻤﻌﺔ ﻓﻼ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻋﻨﺎﺻﺮھﺎ ﻣﻦ ﺧﻼل ﻣﻮاﻗﻊ ﺗﻠﻚ اﻟﻌﻨﺎﺻﺮ ‪ ،‬ﺑﻞ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻦ‬
‫ﺧﻼل أﺳﺘﺨﺪام ﻛﻠﻤﺎت ﻣﻔﺘﺎﺣﯿﻪ ‪ keys‬ﺣﺘﻲ ﻳﻤﻜﻨﻨﺎ اﻹﺷﺎرة ﻟﻌﻨﺼﺮ ﻣﺎ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

‫ﻃﺮﻳﻘﺔ ﻣﻞء اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺠﻤﻌﺔ‬

‫;)(‪var earth = new Array‬‬

‫;"‪earth["diameter"] = "7920 miles‬‬

‫;"‪earth["distance"] = "93 million mile‬‬
‫"‪earth["year"] = "365.25 days‬‬
‫;"‪earth["day"] = "24 hours‬‬

‫ﻳﻤﻜﻨﻨﺎ أﻳﻀﺎ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﻠﻤﺎت اﻟﻤﻔﺘﺎﺣﯿﺔ ﻛﺄﻧﮫﺎ ﺧﺼﺎﺋﺺ ﺗﻢ إﺿﺎﻓﺘﮫﺎ إﻟﻲ ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ) ﻛﻤﺎ ﺳﻮف ﻳﺘﻀﺢ ﺑﺸﻜﻞ‬
‫ﻣﻔﺼﻞ ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ( ﻛﻤﺎ ﻳﻠﻲ‬

‫;)(‪var earth = new Array‬‬

‫;"‪earth.diameter = "7920 miles‬‬

‫;"‪earth.distance = "93 million mile‬‬
‫"‪earth.year = "365.25 days‬‬
‫;"‪earth.day = "24 hours‬‬

‫ﻻﺣﻆ أﻧﻨﺎ ﻻ ﻧﺴﺘﻄﯿﻊ اﻹﺷﺎرة ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﻮاﺳﻄﺔ ﻣﻮﻗﻊ اﻟﻌﻨﺼﺮ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)(‪var earth = new Array‬‬

‫;"‪earth.diameter = "7920 miles‬‬

‫;) ]‪alert( earth[0‬‬

‫‪14‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ ﻟﺘﻌﯿﻦ ﻗﯿﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤﺠﻤﻌﺔ ﻛﻤﺎ ﻳﻠﻲ‬for in ‫ﻳﻤﻜﻨﻨﺎ إﺳﺘﺨﺪام ﺟﻤﻠﺔ‬

‫ﻣﺜﺎل‬
‫ﻧﺮﻳﺪ ﻛﺘﺎﺑﺔ ﻣﺤﺘﻮﻳﺎت ﻣﺼﻔﻮﻓﺔ ﻣﺠﻤﻌﺔ ﺑﺎﻟﻤﺘﺼﻔﺢ‬

<HTML>
<Title> ‫اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺠﻤﻌﺔ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

// ‫ﻣﺼﻔﻮﻓﺔ ﻣﺠﻤﻌﺔ ﺗﻌﺮﯾﻒ‬

var earth = new Array();

earth["diameter"] = "7920 miles";

earth["distance"] = "93 million mile";
earth["year"] = "365.25 days"
earth["day"] = "24 hours";

for( var key in earth ){

document.write ( "earth[" + key + "]" );
document.write ( " = " );
document.write ( earth[key] + "<br>" );
}
//-->
</SCRIPT>
</HEAD>
</HTML>

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

15
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺣﺬف ﻋﻨﺼﺮ ﻣﻦ ﻣﺼﻔﻮﻓﺔ‬

‫ﻳﻤﻜﻨﻨﺎ ﺣﺬف ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﺈﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪delete‬‬

‫وھﻮ أﺣﺪ اﻟﻤﻌﺎﻣﻼت اﻟﺨﺎﺻﺔ ﻟﻠﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ‪.‬‬

‫ﻟﺬﻟﻚ إذا أردﻧﺎ ﺣﺬف اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ ‪ oceans‬ﻧﻘﻮم ﺑﻌﻤﻞ اﻟﺘﺎﻟﻲ‬

‫;)"‪var oceans = new Array(" Atlantic"," Pacific"," Indian"," Arctic‬‬

‫;]‪delete oceans[2‬‬ ‫‪//‬‬ ‫ﻟﺤﺬف اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺎ ھﻲ اﻟﺘﻐﯿﺮات اﻟﺘﻲ ﺣﺪﺛﺖ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

‫‪ -‬أوﻻ ﺗﻢ ﺣﺬف اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬
‫ﻓﺈذا ﻗﻤﻨﺎ ﺑﺘﻌﯿﻦ ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﻟﻠﻤﺼﻔﻮﻓﺔ ﺳﻮف ﻳﻌﻄﯿﻨﺎ اﻟﻘﯿﻤﺔ ‪ undefined‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;)"‪var oceans = new Array(" Atlantic"," Pacific"," Indian"," Arctic‬‬

‫;]‪delete oceans[2‬‬ ‫‪//‬‬ ‫ﻟﺤﺬف اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

‫;) ]‪alert( " oceans[2] = " + oceans[2‬‬

‫ﻟﻜﻦ ﻻﺣﻆ أن ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ ﻟﻢ ﻳﺘﻐﯿﺮ ﻓﻤﺎزال ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ ﻳﺴﺎوي ‪٤‬‬ ‫‪-‬‬
‫وﺗﻜﻮن اﻟﻤﺼﻔﻮﻓﺔ ﻛﻤﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫;"‪oceans[0] = " Atlantic‬‬

‫;"‪oceans[1] = " Pacific‬‬
‫;"‪oceans[3] = " Arctic‬‬

‫‪16‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻧﻲ‬
‫ﺍﻟﻤﺼﻔﻮﻓﺎﺕ ﺫﺍﺕ ﺍﻷﺑﻌﺎﺩ ﺍﻟﻤﺘﻌﺪﺩﺓ‬
‫‪Multidimensional Arrays‬‬

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

‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻷﺑﻌﺎد اﻟﻤﺘﻌﺪدة ‪Multidimensional Arrays‬‬ ‫•‬

‫ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ ‪Array of Array‬‬ ‫•‬
‫ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ‪Array Object‬‬ ‫•‬
‫‪ o‬ﺧﺼﺎﺋﺺ ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ‪Array Object Properties‬‬
‫‪ o‬دوال ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ‪Array Object Methods‬‬

‫‪17‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻤﺼﻔﻮﻓﺎت ذات اﻷﺑﻌﺎد اﻟﻤﺘﻌﺪدة ‪Multidimensional Arrays‬‬

‫دﻋﻨﺎ ﻧﻘﻮل أﻧﻪ ﻳﻮﺟﺪ ﻧﻮﻋﯿﻦ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت أﺣﺪھﻤﺎ ‪:‬‬

‫‪ -‬ذات ﺑﻌﺪ واﺣﺪ وھﻮ ﻣﺎ ﻛﻨﺎ أﺷﺮﻧﺎ إﻟﯿﻪ ﺳﺎﺑﻘﺎ ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫;"‪oceans[0] = " Atlantic‬‬

‫;"‪oceans[1] = " Pacific‬‬
‫;"‪oceans[2] = " Indian‬‬
‫;"‪oceans[3] = " Arctic‬‬

‫ﻓﺎﻟﻤﺼﻔﻮﻓﺔ ‪ oceans‬ﺗﻤﺜﻞ ﻣﺼﻔﻮﻓﺔ ذات ﺑﻌﺪ واﺣﺪ‬

‫أي أﻧﻪ ﻳﻤﻜﻦ ﺗﻤﺜﯿﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻋﻠﻲ ﺷﻜﻞ ﺧﻄﻲ ﻛﻤﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫‪Atlantic‬‬ ‫‪Pacific‬‬ ‫‪Indian‬‬ ‫‪Arctic‬‬

‫‪ -‬واﻷﺧﺮي ذات أﺑﻌﺎد ﻣﺘﻌﺪدة وھﻮ ﻣﺎ ﺳﻮف ﻧﺘﺤﺪث ﻋﻨﻪ‬

‫أوﻻ اﻟﻤﺼﻔﻮﻓﺔ ذات اﻷﺑﻌﺎد اﻟﻤﺘﻌﺪدة ﻣﺜﺎﻻ ﻋﻠﻲ ذﻟﻚ اﻟﻤﺼﻔﻮﻓﺔ ﺛﻨﺎﺋﯿﺔ اﻷﺑﻌﺎد ‪ ،‬أي أﻧﻪ ﻳﻤﻜﻦ ﺗﻤﺜﯿﻞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬
‫ﻋﻠﻲ ﺷﻜﻞ ﻣﺴﺘﻄﯿﻠﻲ ‪ ،‬وأﻳﻀﺎ اﻟﻤﺼﻔﻮﻓﺎت ﺛﻼﺛﯿﺔ اﻷﺑﻌﺎد ﻳﻤﻜﻦ ﺗﻤﺜﯿﻠﮫﺎ ﻓﻲ ﺷﻜﻞ ﻣﻜﻌﺒﻲ‬
‫وﻟﻦ أﻃﯿﻞ ﻓﻲ ھﺬا اﻟﺤﺪﻳﺚ ﻷﻧﻪ ﻟﻸﺳﻒ ﻻ ﺗﻮﻓﺮ ﻟﻨﺎ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻣﻜﺎﻧﯿﺔ ﻋﻤﻞ ﻣﺼﻔﻮﻓﺔ ﻣﺘﻌﺪدة اﻷﺑﻌﺎد‬
‫وﻟﻜﻦ أﻧﺘﻈﺮ ﻗﻠﯿﻼ ﻓﺈﻧﻪ ﻳﻤﻜﻦ اﻟﺘﺤﺎﻳﻞ ﻋﻠﻲ ھﺬا اﻟﻤﻮﺿﻮع ﺑﻌﻤﻞ ﻣﺎ ﻳﺴﻤﻲ ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ ‪Array of Array‬‬

‫ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ أو ﻣﺎ ﺗﺴﻤﻲ أﺣﯿﺎﻧﺎ ﺑﻤﺼﻔﻮﻓﺔ اﻟﺠﺎﺟﺪ ‪ Jagged Array‬وھﻲ ﻃﺮﻳﻘﺔ ﻟﻠﺘﺤﺎﻳﻞ ﻟﻌﻤﻞ ﻣﺼﻔﻮﻓﺔ‬
‫ﻣﺘﻌﺪدة اﻷﺑﻌﺎد ‪.‬‬

‫وﺗﻜﻮن ﻓﻜﺮة ﻋﻤﻞ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻌﺘﻤﺪ ﻋﻠﻲ أﻧﻨﺎ ﻧﻘﻮم ﺑﻌﻤﻞ اﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻧﻘﻮم ﺑﺈﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ذات ﺑﻌﺪ واﺣﺪ ﻛﻤﺎ ﺗﻌﻠﻤﻨﺎ ﺳﺎﺑﻘﺎ‬ ‫‪-‬‬
‫ﺛﻢ ﻧﻘﻮم ﺑﻤﻞء ﻋﻨﺎﺻﺮ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ ‪ ،‬وﻟﻜﻦ أﻧﺘﻈﺮ ﻗﻠﯿﻼ ﻓﺄﻧﻨﺎ ﻟﻦ ﻧﻘﻮم ﺑﻤﻞء ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﺑﻘﯿﻢ ﻣﻦ ﻧﻮع‬ ‫‪-‬‬
‫ﻧﺼﻲ أو رﻗﻤﻲ ﻛﻤﺎ ﻛﺎن ﺑﺎﻟﺴﺎﺑﻖ ‪ ،‬وﻟﻜﻨﻨﺎ ﺳﻮف ﻧﺠﻌﻞ ﻛﻞ ﻋﻨﺼﺮ ﻣﻦ ﻋﻨﺎﺻﺮ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ ﻳﺸﯿﺮ إﻟﻲ‬
‫ﻣﺼﻔﻮﻓﺔ أﺧﺮي ‪ ،‬ورﺑﻤﺎ ﺗﻜﻮن اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤﺸﺎرة إﻟﯿﮫﺎ ذات ﺑﻌﺪ واﺣﺪ أو ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﻧﻮع ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ‬

‫‪18‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫دﻋﻨﺎ ﻧﺄﺧﺬ ﻣﺜﺎل ﻋﻤﻠﻲ ﻋﻠﻲ ذﻟﻚ‬

‫ھﺐ أﻧﻨﺎ ﻧﺮﻳﺪ ﺗﻤﺜﯿﻞ ﻣﺼﻔﻮﻓﺔ ﻟﺸﺮﻛﺔ ﻟﮫﺎ ﻋﺪة ﻓﺮوع وﻛﻞ ﻓﺮع ﻟﻪ اﻟﺨﺼﺎﺋﺺ اﻟﺘﺎﻟﯿﺔ "اﻻﺳﻢ" و "اﻟﻌﻨﻮان" و "ﻧﺸﺎﻃﻪ"‬
‫ﻛﻤﺎ ﻧﺮي ھﻨﺎ أﻧﻨﺎ ﻧﻤﻠﻚ ﻣﺼﻔﻮﻓﺔ ﻣﻦ اﻟﻔﺮوع ) ﻷن اﻟﺸﺮﻛﺔ رﺑﻤﺎ ﻳﻜﻮن ﻟﮫﺎ أﻛﺜﺮ ﻣﻦ ﻓﺮع ( ‪ ،‬إذا ﻧﻘﻮم ﺑﻌﻤﻞ ﻣﺼﻔﻮﻓﺔ ذات‬
‫ﺑﻌﺪ واﺣﺪ وﻧﻄﻠﻖ ﻋﻠﯿﮫﺎ ﻣﺜﻼ ‪ ، CompBranches‬وﻟﻜﻦ ﻳﺄﺗﻲ ﺑﻌﺪ ذﻟﻚ ﻛﯿﻔﯿﺔ ﻣﻞء ﻋﻨﺎﺻﺮ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ ‪ ،‬ﻓﻜﻤﺎ ﺗﻢ‬
‫اﻷﺷﺎرة ﺳﺎﺑﻘﺎ أن ﻛﻞ ﻓﺮع ) وھﻮ ﻣﺎ ﻳﻤﺜﻞ ﻋﻨﺼﺮ ﺑﻤﺼﻔﻮﻓﺔ اﻟﻔﺮوع ( ﺗﻤﺜﻞ ﻗﯿﻤﺘﻪ ﻣﻦ ﺧﻼل اﺳﻢ اﻟﻔﺮع وﻋﻨﻮاﻧﻪ وﻧﺸﺎﻃﻪ‬
‫إذا ﻧﺤﺘﺎج ﻟﻌﻤﻞ ﻣﺼﻔﻮﻓﺔ ﺟﺪﻳﺪ ﺗﺤﻤﻞ ﺑﯿﺎﻧﺎت اﻟﻔﺮع وﻳﻜﻮن ﻃﻮﻟﮫﺎ ‪ ٣‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var CompBranches = new Array(2‬‬

‫اﻟﺮﺋﯿﺴﻲ"(‪CompBranches[0] = new Array‬‬ ‫;)"اﻟﺘﺠﺎرة" ‪" ,‬اﻟﻘﺎﻫﺮة"‪",‬اﻟﻔﺮع‬

‫اﻟﻤﻨﯿﺮة"(‪CompBranches[1] = new Array‬‬ ‫;)"اﻟﻤﺮاﺟﻌﺔ" ‪" ,‬اﻷﺳﻜﻨﺪرﯾﺔ"‪",‬ﻓﺮع‬

‫ﻛﻤﺎ ﻧﺮي ﻓﻘﺪ ﻗﻤﻨﺎ ﺑﺘﻌﺮﻳﻒ اﻟﻤﺼﻔﻮﻓﺔ ‪ CompBranches‬اﻟﺘﻲ ﺗﻌﺒﺮ ﻋﻦ ﻓﺮوع اﻟﺸﺮﻛﺔ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var CompBranches = new Array(2‬‬

‫ﺛﻢ ﻗﻤﻨﺎ ﺑﻤﻞء ﺑﯿﺎﻧﺎت ﻛﻞ ﻓﺮع ﻋﻠﻲ ﺣﺪي ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺮﺋﯿﺴﻲ"(‪CompBranches[0] = new Array‬‬ ‫"اﻟﻘﺎﻫﺮة"‪",‬اﻟﻔﺮع‬ ‫;)"اﻟﺘﺠﺎرة" ‪,‬‬

‫اﻟﻤﻨﯿﺮة"(‪CompBranches[1] = new Array‬‬ ‫"اﻷﺳﻜﻨﺪرﯾﺔ"‪",‬ﻓﺮع‬ ‫;)"اﻟﻤﺮاﺟﻌﺔ" ‪,‬‬

‫ﻛﻤﺎ ﻳﻤﻜﻨﻨﺎ ﻋﻤﻞ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺑﻌﺪة ﻃﺮق ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var CompBranches = new Array(2‬‬

‫اﻟﺮﺋﯿﺴﻲ"(‪var branch1 = new Array‬‬ ‫"اﻟﻘﺎﻫﺮة"‪",‬اﻟﻔﺮع‬ ‫;)"اﻟﺘﺠﺎرة" ‪,‬‬

‫;‪CompBranches[0] = branch1‬‬

‫اﻟﻤﻨﯿﺮة"(‪var branch2 = new Array‬‬ ‫"اﻷﺳﻜﻨﺪرﯾﺔ"‪",‬ﻓﺮع‬ ‫;)"اﻟﻤﺮاﺟﻌﺔ" ‪,‬‬

‫;‪CompBranches[1] = branch2‬‬

‫أو ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺮﺋﯿﺴﻲ"[ [ = ‪var CompBranches‬‬ ‫"اﻟﻘﺎﻫﺮة"‪",‬اﻟﻔﺮع‬ ‫اﻟﻤﻨﯿﺮة"[ ‪"] ,‬اﻟﺘﺠﺎرة " ‪,‬‬ ‫"اﻷ ﺳﻜﻨﺪرﯾﺔ"‪",‬ﻓﺮع‬ ‫] ]"اﻟﻤﺮاﺟﻌﺔ" ‪,‬‬

‫أو ﻛﻤﺎ ﻳﻠﻲ‬

‫;)‪var CompBranches = new Array(2‬‬

‫;)‪var branch1 = new Array(3‬‬

‫اﻟﺮﺋﯿﺴﻲ" = ]‪branch1[0‬‬ ‫;"اﻟﻔﺮع‬
‫;"اﻟﻘﺎﻫﺮة" = ]‪branch1[1‬‬
‫;"اﻟﺘﺠﺎرة" = ]‪branch1[2‬‬
‫;‪CompBranches[0] = branch1‬‬

‫;)‪var branch2 = new Array(3‬‬

‫‪19‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
branch2[0] = "‫اﻟﻤﻨﯿﺮة‬ ‫;"ﻓﺮع‬
branch2[1] = "‫;"اﻷﺳﻜﻨﺪرﯾﺔ‬
branch2[2] = "‫;"اﻟﻤﺮاﺟﻌﺔ‬
CompBranches[1] = branch2;

‫أو ﻛﻤﺎ ﻳﻠﻲ‬

var CompBranches = new Array(2);

CompBranches[0] = new Array(3);

CompBranches[0][0] = "‫اﻟﺮﺋﯿﺴﻲ‬ ‫;"اﻟﻔﺮع‬
CompBranches[0][1] = "‫;"اﻟﻘﺎﻫﺮة‬
CompBranches[0][2] = "‫;"اﻟﺘﺠﺎرة‬

CompBranches[1] = new Array(3);

CompBranches[1][0] = "‫اﻟﻤﻨﯿﺮة‬ ‫;"ﻓﺮع‬
CompBranches[1][1] = "‫;"اﻷﺳﻜﻨﺪرﯾﺔ‬
CompBranches[1][2] = "‫;"اﻟﻤﺮاﺟﻌﺔ‬

‫ ﻛﻤﺎ ﻳﻠﻲ‬Associative Array ‫ﻳﻤﻜﻨﻨﺎ إﺳﺘﺨﺪام اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤ ﺠﻤﻌﺔ‬

var CompBranches = new Array(2);

CompBranches[0] = new Array(3);

CompBranches[0]["name"] = "‫اﻟﺮﺋﯿﺴﻲ‬ ‫;"اﻟﻔﺮع‬
CompBranches[0]["address"] = "‫;"اﻟﻘﺎﻫﺮة‬
CompBranches[0]["activity"] = "‫;"اﻟﺘﺠﺎرة‬

CompBranches[1] = new Array(3);

CompBranches[1]["name"] = "‫اﻟﻤﻨﯿﺮة‬ ‫;"ﻓﺮع‬
CompBranches[1]["address"] = "‫;"اﻷﺳﻜﻨﺪرﯾﺔ‬
CompBranches[1]["activity"] = "‫;"اﻟﻤﺮاﺟﻌﺔ‬

for ‫ﻣﺜﺎل ﻟﻄﺒﺎﻋﺔ ﺑﯿﺎﻧﺎت ﻣﺼﻔﻮﻓﺔ اﻟﻔﺮوع اﻟﺴﺎﺑﻘﺔ ﺑﺈﺳﺘﺨﺪام ﺟﻤﻠﺔ‬

<HTML>
<Title> ‫ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var CompBranches = new Array(2);

CompBranches[0] = new Array(3);

CompBranches[0][0] = "‫اﻟﺮﺋﯿﺴﻲ‬ ‫;"اﻟﻔﺮع‬
CompBranches[0][1] = "‫;"اﻟﻘﺎﻫﺮة‬
CompBranches[0][2] = "‫;"اﻟﺘﺠﺎرة‬

CompBranches[1] = new Array(3);

20
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
CompBranches[1][0] = "‫اﻟﻤﻨﯿﺮة‬ ‫;"ﻓﺮع‬
CompBranches[1][1] = "‫;"اﻷﺳﻜﻨﺪرﯾﺔ‬
CompBranches[1][2] = "‫;"اﻟﻤﺮاﺟﻌﺔ‬

for( var i=0; i<2; i++){

document.write( "<b>CompBranches[" + i + "]</b>" + "<br>" );

for(var j=0; j<3; j++){

document.write( " CompBranches[" + i + "][" + j + "] = " );
document.write( CompBranches[i][j] + "<br>" );
}

document.write( "<br>" );
}
//-->
</SCRIPT>
</HEAD>
</HTML>

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

21
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

for in ‫ﻣﺜﺎل أﺧﺮ ﻟﻄﺒﺎﻋﺔ ﺑﯿﺎﻧﺎت ﻣﺼﻔﻮﻓﺔ اﻟﻔﺮوع اﻟﺴﺎﺑﻘﺔ ﺑﺈﺳﺘﺨﺪام ﺟﻤﻠﺔ‬

<HTML>
<Title> ‫ﻣﺼﻔﻮﻓﺔ اﻟﻤﺼﻔﻮﻓﺔ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var CompBranches = new Array(2);

CompBranches[0] = new Array(3);

CompBranches[0]["name"] = "‫اﻟﺮﺋﯿﺴﻲ‬ ‫;"اﻟﻔﺮع‬
CompBranches[0]["address"] = "‫;"اﻟﻘﺎﻫﺮة‬
CompBranches[0]["activity"] = "‫;"اﻟﺘﺠﺎرة‬

CompBranches[1] = new Array(3);

CompBranches[1]["name"] = "‫اﻟﻤﻨﯿﺮة‬ ‫;"ﻓﺮع‬
CompBranches[1]["address"] = "‫;"اﻷﺳﻜﻨﺪرﯾﺔ‬
CompBranches[1]["activity"] = "‫;"اﻟﻤﺮاﺟﻌﺔ‬

for( var i=0; i<2; i++){

document.write( "<b>CompBranches[" + i + "]</b>" + "<br>" );

for(var key in CompBranches[i] ){

document.write( " CompBranches[" + i + "][\"" + key + "\"] = " );
document.write( CompBranches[i][key] + "<br>" );
}

document.write( "<br>" );
}
//-->
</SCRIPT>
</HEAD>
</HTML>

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

22
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ‪Array Object‬‬

‫دﻋﻨﺎ ﻧﺘﺤﺪث اﻷن ﻋﻦ اﻟﺨﺼﺎﺋﺺ و اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﻜﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﺧﺼﺎﺋﺺ ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ ‪Array Object Properties‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪constructor‬‬
‫ﺳﻮف ﻧﺘﺤﺪث ﻋﻦ اﻟﺨﺎﺻﯿﺔ ‪ constructor‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨﺎت واﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ‬

‫اﻟﺨﺎﺻﯿﺔ ‪prototype‬‬
‫ﺳﻮف ﻧﺘﺤﺪث ﻋﻦ اﻟﺨﺎﺻﯿﺔ ‪ prototype‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨﺎت واﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ‬
‫واﻟﻮراﺛﺔ ‪Inheritance‬‬

‫‪23‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

length ‫اﻟﺨﺎﺻﯿﺔ‬

‫ ﻟﺤﺴﺎب ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ اي ﻋﺪد ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬length ‫ﺗﺴﺘﺨﺪم اﻟﺨﺎﺻﯿﺔ‬

‫ﻣﺜﺎل‬

var arr = new Array("100","12","44");

alert( arr.length );

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

‫ﻣﺜﺎل‬

<HTML dir=rtl>
<Title> ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫ﻃﻮل‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var arr = new Array();

arr[0] = "100";
arr[1] = "12";
arr[2] = "44";

for( var i=0; i<arr.length; i++){

document.write( arr[i]);
document.write( "<br>" );
}

document.write( "<b> = ‫ﻋﺪد ﻋﻨﺎﺻﺮ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ‬ </b>" + arr.length );

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

24
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("100","12","44‬‬

‫;) ‪alert( arr.length‬‬ ‫‪//‬‬ ‫ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ ﯾﺴﺎوي ‪٣‬‬

‫‪//‬‬ ‫إﺿﺎﻓﺔ ﻋﻨﺼﺮ ﺟﺪﯾﺪ ﻟﻠﻤﺼﻔﻮﻓﺔ‬

‫;"‪arr[ arr.length ] = "200‬‬

‫;) ‪alert( arr.length‬‬ ‫‪//‬‬ ‫ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ ﯾﺴﺎوي ‪٤‬‬

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

‫‪25‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

Array Object Methods ‫دوال ﻛﺎﺋﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

concat ‫اﻟﺪاﻟﺔ‬

‫ﺗﺴﺘﺨﺪم ﻟﺪﻣﺞ ﻣﺼﻔﻮﻓﺘﯿﻦ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ﺟﺪﻳﺪة‬

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

Array.concat( arrayObject );

‫ﻣﺜﺎل‬

var array1 = new Array(1,2,3);

var array2 = new Array("a","b","c");

var array3 = array1.concat( array2 );

alert( array3.length );

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

‫ﻣﺜﺎل‬

<HTML dir=rtl>
<Title> ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫دوال‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var array1 = new Array(1,2,3);
var array2 = new Array("a","b","c");

var array3 = array1.concat( array2 );

for( var i=0; i<array3.length; i++){

document.write( array3[i]);
document.write( "<br>" );
}
document.write( "<b> = ‫ﻋﺪد ﻋﻨﺎﺻﺮ ﺗﻠﻚ اﻟﻤﺼﻔﻮﻓﺔ‬ </b>" + array3.length );
//-->
</SCRIPT>

26
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

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

‫اﻟﺪاﻟﺔ ‪join‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺪﻣﺞ ﻗﯿﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪ ،‬وﻳﺘﻢ اﻟﺪﻣﺞ ﺑﯿﻦ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻣﻊ وﺿﻊ ﻓﺎﺻﻞ ﺑﯿﻦ ﻗﯿﻢ اﻟﻌﻨﺎﺻﺮ وﻳﺘﻢ ﺗﺤﺪﻳﺪ‬
‫ھﺬا اﻟﻔﺎﺻﻞ ‪.‬‬

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

‫(‪Array.join‬‬ ‫اﻟﺠﻤﻠﺔ اﻟﻔﺎﺻﻠﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;)"‪var str = arr.join(",‬‬

‫;) ‪alert( str‬‬

‫;)" "(‪str = arr.join‬‬

‫;) ‪alert( str‬‬

‫;)""(‪str = arr.join‬‬
‫;) ‪alert( str‬‬

‫‪27‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﻤﺎ ﻧﻼﺣﻆ ﻓﻘﺪ ﺗﻢ دﻣﺞ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪ arr‬ﺑﻮﺿﻊ اﻟﻌﻼﻣﺔ اﻟﻔﺎﺻﻠﺔ "‪"،‬‬

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

‫اﻟﺪوال ‪ pop‬و ‪ push‬و ‪ shift‬و ‪unshift‬‬

‫اﻟﺪاﻟﺔ ‪ : push‬ﺗﺴﺘﺨﺪم ﻹﺿﺎﻓﺔ ﻋﻨﺼﺮ ﺟﺪﻳﺪ ﻓﻲ أﺧﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

‫اﻟﺪاﻟﺔ ‪ : pop‬ﺗﺴﺘﺨﺪم ﻟﺤﺬف أﺧﺮ ﻋﻨﺼﺮ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

‫اﻟﺪاﻟﺔ ‪ : unshift‬ﺗﺴﺘﺨﺪم ﻹﺿﺎﻓﺔ ﻋﻨﺼﺮ ﻓﻲ أول اﻟﻤﺼﻔﻮﻓﺔ‬

‫اﻟﺪاﻟﺔ ‪ : shift‬ﺗﺴﺘﺨﺪم ﻟﺤﺬف أول ﻋﻨﺼﺮ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

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

‫(‪Array.push‬‬ ‫ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ اﻟﺠﺪﯾﺪ‬ ‫;)‬

‫;)(‪Array.pop‬‬

‫(‪Array.unshift‬‬ ‫ﻗﯿﻤﺔ اﻟﻌﻨﺼﺮ اﻟﺠﺪﯾﺪ‬ ‫;)‬

‫;)(‪Array.shift‬‬

‫‪28‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪ : push‬ﺗﺴﺘﺨﺪم ﻹﺿﺎﻓﺔ ﻋﻨﺼﺮ ﺟﺪﻳﺪ ﻓﻲ أﺧﺮ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;) "‪arr.push( "d‬‬

‫;) ‪alert( arr.length‬‬

‫;) ]‪alert( arr[3‬‬

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

‫اﻟﺪاﻟﺔ ‪ : pop‬ﺗﺴﺘﺨﺪم ﻟﺤﺬف أﺧﺮ ﻋﻨﺼﺮ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;)(‪arr.pop‬‬

‫;) ‪alert( arr.length‬‬

‫;) ]‪alert( arr[arr.length-1‬‬ ‫‪//‬‬ ‫ﻋﺮض أﺧﺮ ﻋﻨﺼﺮ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

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

‫‪29‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪ : shift‬ﺗﺴﺘﺨﺪم ﻟﺤﺬف أول ﻋﻨﺼﺮ ﻣﻦ اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;)(‪arr.shift‬‬

‫;) ‪alert( arr.length‬‬

‫;) ]‪alert( arr[0‬‬ ‫‪//‬‬ ‫ﻋﺮض أول ﻋﻨﺼﺮ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

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

‫اﻟﺪاﻟﺔ ‪ : unshift‬ﺗﺴﺘﺨﺪم ﻹﺿﺎﻓﺔ ﻋﻨﺼﺮ ﻓﻲ أول اﻟﻤﺼﻔﻮﻓﺔ‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;) "‪arr.unshift( "x‬‬

‫;) ‪alert( arr.length‬‬

‫;) ]‪alert( arr[0‬‬ ‫‪//‬‬ ‫ﻋﺮض أول ﻋﻨﺼﺮ ﺑﺎﻟﻤﺼﻔﻮﻓﺔ‬

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

‫‪30‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

<HTML dir=rtl>
<Title> ‫اﻟﻤﺼﻔﻮﻓﺔ‬ ‫دوال‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--
var arr = new Array("‫"إﯾﻬﺎب‬," ‫"ﻣﺤﻤﺪ‬,"‫" ﻋﻼء‬,"‫;)" ﺣﺴﯿﻦ‬
var stack = new Array();

stack.push( arr[0] );
stack.push( arr[2] );

var str = stack.pop();

document.write( "<b>" + str + "</b><br>");

str = stack.pop();
document.write( "<b>" + str + "</b>");
//-->
</SCRIPT>
</HEAD>
</HTML>

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

31
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪reverse‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻌﻜﺲ ﻣﻮاﻗﻊ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

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

‫;)(‪Array.reverse‬‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = new Array("a","b","c‬‬

‫;)(‪var arrReverse = arr.reverse‬‬

‫;) )"‪alert( arrReverse.join(",‬‬

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

‫اﻟﺪاﻟﺔ ‪ slice‬و ‪splice‬‬

‫ﺗﺴﺘﺨﺪم ﻛﻠﺘﺎ اﻟﺪاﻟﺘﺎن ﻹﺧﺘﺰال ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪاﻟﺔ ‪slice‬‬

‫(‪Array.slice‬‬ ‫ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬ ‫;)‬

‫أو‬
‫(‪Array.slice‬‬ ‫ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬ ‫‪,‬‬ ‫ﻣﻮﻗﻊ أﺧﺮ ﻋﻨﺼﺮ – ‪١‬‬ ‫;)‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻠﺪاﻟﺔ ‪splice‬‬

‫(‪Array.splice‬‬ ‫ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬ ‫‪,‬‬ ‫ﻋﺪد اﻟﻌﻨﺎﺻﺮ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)"‪var arr1 = new Array("a" ,"b" ,"c" ,"d" ,"e" ,"f‬‬

‫;)‪var arr2 = arr1.slice(2‬‬

‫;) )"‪alert( arr2.join(",‬‬

‫‪32‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫ﻣﺜﺎل‬

‫;)"‪var arr1 = new Array("a" ,"b" ,"c" ,"d" ,"e" ,"f‬‬

‫;)‪var arr2 = arr1.slice(2,4‬‬

‫;) )"‪alert( arr2.join(",‬‬

‫;)‪var arr3 = arr1.splice(2,2‬‬

‫;) )"‪alert( arr3.join(",‬‬

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

‫اﻟﺪاﻟﺔ ‪sort‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺮﺗﯿﺐ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ‪.‬‬

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

‫;)(‪Array.sort‬‬

‫أو‬

‫(‪Array.sort‬‬ ‫اﻟﺪاﻟﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﺮﺗﯿﺐ‬ ‫;)‬

‫‪33‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)"‪var arr1 = new Array("c", "a", "b‬‬

‫;)(‪var arr2 = arr1.sort‬‬

‫;) )"‪alert( arr2.join(",‬‬

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

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

‫;)‪var arr1 = new Array(12, 5, 200, 80‬‬

‫;)(‪var arr2 = arr1.sort‬‬

‫;) )"‪alert( arr2.join(",‬‬

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

‫ﻛﻤﺎ ﺗﺮي ﻟﻢ ﻳﺘﻢ اﻟﺘﺮﺗﯿﺐ ﺑﺸﻜﻞ ﺻﺤﯿﺢ ‪ ،‬ﻷﻧﻪ ﺗﻢ ﺗﺮﺗﯿﺐ ﻋﻨﺎﺻﺮ ﻗﯿﻢ اﻟﻤﺼﻔﻮﻓﺔ ﻋﻠﻲ أﺳﺎس أﻧﮫﺎ ﻗﯿﻢ ﻧﺼﯿﺔ‬
‫وﻟﺤﻞ ھﺬة اﻟﻤﺸﻜﻠﺔ ﻳﺘﻢ ﻋﻤﻞ داﻟﺔ ﺧﺎﺻﺔ ﻟﻠﺘﺮﺗﯿﺐ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺜﺎل‬

‫>‪<HTML dir=rtl‬‬
‫اﻟﻤﺼﻔﻮﻓﺔ >‪<Title‬‬ ‫دوال‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪34‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫{ )‪function compare(a, b‬‬
‫;‪return a – b‬‬
‫}‬

‫;)‪var arr1 = new Array(12, 5, 200, 80‬‬

‫;) ‪var arr2 = arr1.sort( compare‬‬

‫;) )"‪alert( arr2.join(",‬‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

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

‫اﻟﺪاﻟﺔ ‪ toLocaleString‬و ‪toString‬‬

‫ﺗﻘﻮم ﻛﻠﺘﺎ اﻟﺪاﻟﺘﯿﻦ ﺑﺪﻣﺞ ﻗﯿﻢ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ ﻓﻲ ﻣﺘﻐﯿﺮ ﻧﺼﻲ ﺑﻮﺿﻊ ﻓﺎﺻﻞ ﺑﯿﻦ اﻟﻘﯿﻢ‬
‫ﻓﻌﻨﺪ إﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ toString‬ﻳﻜﻮن اﻟﻔﺎﺻﻞ اﻟﻤﺴﺘﺨﺪم ھﻮ "‪"،‬‬
‫وﺑﺬﻟﻚ ﻓﺈﻧﮫﺎ ﺗﻜﺎﻓﺊ ﻋﻤﻞ اﻟﺪاﻟﺔ ‪ join‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;)"‪Array.join(",‬‬

‫أﻣﺎ ﻋﻨﺪ إﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ toLocaleString‬ﻳﻜﻮن اﻟﻔﺎﺻﻞ اﻟﻤﺴﺘﺨﺪم ھﻮ ";"‬

‫وﺑﺬﻟﻚ ﻓﺈﻧﮫﺎ ﺗﻜﺎﻓﺊ ﻋﻤﻞ اﻟﺪاﻟﺔ ‪ join‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;)";"(‪Array.join‬‬
‫‪35‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

Array.toLocaleString();
Array.toString();

‫ﻣﺜﺎل‬

var arr1 = new Array("a", "b", "c");

var str = arr1.toLocaleString();

alert( str );

str = arr1.toString();
alert( str );

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

36
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺜﺎﻟﺚ‬
‫ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﻨﺼﻮﺹ‬

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

‫اﻟﻨﺼﻮص اﻟﺒﺴﯿﻄﺔ ‪Simple String‬‬ ‫•‬

‫دﻣﺞ اﻟﻨﺼﻮص ‪Concatenation‬‬ ‫•‬
‫اﻟﺪاﻟﺔ ‪parseInt‬‬ ‫•‬
‫اﻟﺪاﻟﺔ ‪isNaN‬‬ ‫•‬
‫اﻟﺪاﻟﺔ ‪parseFloat‬‬ ‫•‬
‫ﻋﻼج ﺗﺪاﺧﻞ ﻋﻼﻣﺎت اﻟﺘﻨﺼﯿﺺ‬ ‫•‬
‫ﻋﻼﻣﺎت اﻟﮫﺮوب أو اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﺔ ﻟﻠﻜﺘﺎﺑﺔ ‪Escaping Characters‬‬ ‫•‬
‫دوال ﺗﺸﻔﯿﺮ وﻓﻚ ﺗﺸﻔﯿﺮ ﻋﻨﺎوﻳﻦ اﻷﻧﺘﺮﻧﺖ ‪URL String Encoding and Decoding‬‬ ‫•‬
‫‪ o‬اﻟﺪاﻟﺔ ‪escape‬‬
‫‪ o‬اﻟﺪاﻟﺔ ‪unescape‬‬

‫‪37‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﻤﺎ ﻛﻨﺎ ﻗﺪ أﺷﺮﻧﺎ ﺳﺎﺑﻘﺎ ﺑﺎﻟﺠﺰء اﻷول ﻣﻦ اﻟﻜﺘﺎب ﻓﻲ ﻓﺼﻞ اﻟﻤﺘﻐﯿﺮات أن ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻟﯿﺴﺖ ﻣﻦ اﻟﻠﻐﺎت اﻟﺘﻲ‬
‫ﺗﻤﯿﺰ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ ﺑﺎﻟﻤﺘﻐﯿﺮات ﻳﺸﻜﻞ ﻗﻮي "‪ "not strongly typed language‬ﻳﺠﻌﻠﮫﺎ ﺗﻤﯿﺰ ﺑﯿﻦ اﻟﻤﺘﻐﯿﺮات‬
‫اﻟﺤﺮﻓﯿﺔ واﻟﻤﺘﻐﯿﺮات اﻟﻨﺼﯿﺔ ﺑﺸﻜﻞ ﺟﯿﺪ ‪ ،‬ﻛﻤﺎ ﺳﻨﺮي ﻇﮫﻮر ﺑﻌﺾ اﻟﻤﺸﺎﻛﻞ ﻋﻨﺪ إﺳﺘﺨﺪام اﻟﻤﺘﻐﯿﺮات اﻟﻨﺼﯿﺔ اﻟﺒﺴﯿﻄﺔ‬
‫ﻟﺬﻟﻚ ﻇﮫﺮت اﻟﺤﺎﺟﺔ ﻹﻧﺸﺎء ﻛﺎﺋﻦ ﻧﺼﻲ ﻳﻜﻮن ﻣﺒﻨﻲ داﺧﻞ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻳﻮﻓﺮ أﺳﻠﻮب ﺗﻌﺎﻣﻞ ﺻﺤﯿﺢ ﻣﻊ اﻟﻤﺘﻐﯿﺮات‬
‫اﻟﻨﺼﯿﺔ‬

‫اﻟﻨﺼﻮص اﻟﺒﺴﯿﻄﺔ ‪Simple String‬‬

‫ﻣﺎ ھﻮ اﻟﻨﺺ اﻟﺒﺴﯿﻂ ‪ :‬ﻳﺘﻜﻮن اﻟﻨﺺ ﻣﻦ ﺣﺮف أو أﻛﺜﺮ ورﺑﻤﺎ ﻣﻦ رﻗﻢ أو أﻛﺜﺮ أو رﺑﻤﺎ ﻳﻜﻮن ﺧﻠﯿﻂ ﻣﻦ ﺣﺮوف ﻣﻊ أرﻗﺎم ﻟﻜﻦ‬
‫ﺑﺸﺮط أن ﻳﺘﻢ وﺿﻊ ھﺬه اﻟﺤﺮوف ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ﻛﻤﺎ ﻳﻠﻲ‬

‫= ‪var str‬‬ ‫;"ﻣﺮﺣﺒﺎ ﺑﻜﻢ"‬

‫أو ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ﻓﺮدي ﻛﻤﺎ ﻳﻠﻲ‬

‫= ‪var str‬‬ ‫;'ﻣﺮﺣﺒﺎ ﺑﻜﻢ'‬

‫ﻻﺣﻆ أﻳﻀﺎ أن اﻟﻤﺘﻐﯿﺮ اﻟﻨﺼﻲ رﺑﻤﺎ ﻻ ﻳﺤﺘﻮي ﻋﻠﻲ اي ﺣﺮوف أو أرﻗﺎم وھﻮ ﻣﺎ ﻳﺴﻤﻲ ﺑﺎﻟﻤﺘﻐﯿﺮ اﻟﻨﺼﻲ اﻟﻔﺎرغ ‪Empty‬‬
‫‪ String‬ﻛﻤﺎ ﻳﻠﻲ‬

‫= ‪var str‬‬ ‫;""‬

‫دﻣﺞ اﻟﻨﺼﻮص ‪Concatenation‬‬

‫ﺗﻌﺘﺒﺮ ﻋﻤﻠﯿﺔ دﻣﺞ اﻟﻨﺼﻮص ﻣﻦ اﻟﻌﻤﻠﯿﺎت اﻟﮫﺎﻣﺔ ﻋﻨﺪ اﻟﻘﯿﺎم ﺑﺈﻧﺸﺎء ﺻﻔﺤﺎت ﻟﻠﻮﻳﺐ‬
‫وﻳﺘﻢ دﻣﺞ اﻟﻨﺼﻮص ﺑﺈﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪ +‬أو اﻟﻤﻌﺎﻣﻞ =‪ +‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;"" = ‪var str‬‬

‫اﻟﺼﻔﺤﺔ>‪str += "<html><head><title‬‬ ‫;">‪</title></head‬رأس‬

‫اﻟﺒﺴﯿﻄﺔ>‪str += "<body><h1‬‬ ‫;">‪</h1></body‬اﻟﻨﺼﻮص‬
‫;">‪str += "</html‬‬

‫ﻣﺜﺎل‬

‫ﻣﻌﻨﺎ" = ‪var str1‬‬ ‫;"أﻧﺖ ﻫﻨﺎ‬

‫اﻟﺜﺎﻧﻲ" = ‪var str2‬‬ ‫;"ﺑﺎﻟﺠﺰء‬

‫;‪var str3 = str1 + " " + str2‬‬

‫;) ‪alert( str3‬‬

‫‪38‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫ﻣﺜﺎل‬

‫;"‪var str1 = "2‬‬

‫;‪var str2 = 3‬‬

‫;‪var str3 = str1 + str2‬‬

‫;) ‪alert( str3‬‬

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

‫ﻻﺣﻆ ﻣﻌﻲ أﻧﻪ ﺗﻢ إﻋﺘﺒﺎر ﻗﯿﻤﺔ اﻟﻤﺘﻐﯿﺮ ‪ str2‬ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﺑﺎﻟﺮﻏﻢ ﻣﻦ أﻧﮫﺎ ﻟﻢ ﻳﺘﻢ وﺿﻌﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ وﻛﺎن‬
‫اﻟﻤﺘﻮﻗﻊ أن ﻳﻜﻮن ﻧﺎﺗﺞ اﻟﺠﻤﻊ ھﻮ ‪. ٥‬‬
‫وﻟﻌﻼج ھﺬة اﻟﻤﺸﻜﻠﺔ ﻳﺘﻢ إﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ parseInt‬أو اﻟﺪاﻟﺔ ‪ parseFloat‬ﻛﻤﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﻧﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم إدﺧﺎل رﻗﻤﯿﻦ ‪ ،‬ﺛﻢ ﻧﻘﻮم ﺑﺈﻇﮫﺎر ﺣﺎﺻﻞ ﺟﻤﻌﮫﻢ‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﻨﺼﻮص اﻟﺒﺴﯿﻄﺔ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫اﻷول"(‪var num1 = prompt‬‬ ‫;)""‪",‬ادﺧﻞ اﻟﺮﻗﻢ‬

‫اﻟﺜﺎﻧﻲ"(‪var num2 = prompt‬‬ ‫;)""‪",‬ادﺧﻞ اﻟﺮﻗﻢ‬
‫‪39‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫;)‪var num3 = parseInt(num1) + parseInt(num2‬‬

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

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

‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻋﻨﺪ إدﺧﺎل اﻟﺮﻗﻢ اﻷول ﺑﺎﻟﻘﯿﻤﺔ ‪ ٤‬واﻟﺮﻗﻢ اﻟﺜﺎﻧﻲ ﺑﺎﻟﻘﯿﻤﺔ ‪ ، ٨‬ﻓﯿﻜﻮن ﻧﺎﺗﺞ اﻟﺠﻤﻊ ھﻮ ‪ ١٢‬ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺪاﻟﺔ ‪parseInt‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ اﻟﻘﯿﻢ اﻟﻨﺼﯿﺔ إﻟﻲ ﻗﯿﻢ ﻋﺪدﻳﺔ ﺻﺤﯿﺤﺔ ) اي أﻧﮫﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد اﻟﺼﺤﯿﺤﺔ وﻟﯿﺴﺖ ﻣﻊ اﻷﻋﺪاد‬
‫اﻟﻨﺴﺒﯿﺔ ( ‪.‬‬

‫ﻛﻤﺎ رأﻳﻨﺎ ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺘﺤﻮﻳﻞ اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ اﻟﺪاﻟﺔ ‪ prompt‬إﻟﻲ ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﻳﻤﻜﻨﻨﺎ‬
‫إﺳﺘﺨﺪاﻣﮫﺎ ﻓﻲ اﻟﻌﻤﻠﯿﺎت اﻟﺤﺴﺎﺑﯿﺔ ﺑ ﺸﻜﻞ ﺻﺤﯿﺢ‬

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

‫(‪parseInt‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد ﺗﺤﻮﯾﻠﻬﺎ‬ ‫;)‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ھﺬه اﻟﺪاﻟﺔ ‪ :‬ﺑﻌﺪ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﻳﻞ ﻳﺘﻢ إرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﯿﺤﺔ‬

‫ﻣﺜﺎل‬

‫;) "‪var num = parseInt( "23‬‬

‫;) ‪alert( num‬‬

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

‫‪40‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;) "‪var num = parseInt( "23.43‬‬

‫;) ‪alert( num‬‬

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

‫ﻻﺣﻆ أن اﻟﺪاﻟﺔ ‪ parseInt‬ﺗﻘﻮم ﺑﺎﻟﺘﺤﻮﻳﻞ اﻟﻘﯿﻢ اﻟﻨﺼﯿﺔ إﻟﻲ ﻗﯿﻢ ﻋﺪدﻳﺔ ﺻﺤﯿﺤﺔ ‪integer Number‬‬

‫ﻻﺣﻆ ﻣﻌﻲ ھﺬه اﻟﺤﺎﻟﺔ‬

‫إ ذا ﻗﻤﻨﺎ ﺑﺘﻤﺮﻳﺮ ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻟﻠﺪاﻟﺔ وﻟﻜﻦ ھﺬه اﻟﻘﯿﻤﺔ ﻻ ﺗﻤﺜﻞ ﻋﺪد ﻛﻤﺎ ﻳﻠﻲ‬

‫;) "‪parseInt( "h23‬‬

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

‫ﻓﻘﺪ ﻗﺎﻣﺖ اﻟﺪاﻟﺔ ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ ‪ NaN‬وھﻲ إﺧﺘﺼﺎر ﻟﻠﺠﻤﻠﺔ اﻟﺘﺎﻟﯿﺔ ‪ Not a Numeric‬اي أن اﻟﻘﯿﻤﺔ اﻟﻤﻤﺮة ﻟﮫﺎ ﻟﯿﺴﺖ‬
‫ﻗﯿﻤﺔ ﻋﺪدﻳﺔ وﻟﺘﻔﺎدي ھﺬه اﻟﺤﺎﻟﺔ ﻳﻤﻜﻨﻨﺎ إﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪. isNaN‬‬

‫اﻟﺪاﻟﺔ ‪isNaN‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺘﺄﻛﺪ ﻣﻦ ﺣﺎﻟﺔ اﻟﻘﯿﻤﺔ اﻟﻤﻤﺮرة ﻟﮫﺎ ھﻞ ھﻲ ﻗﯿﻤﺔ ﻋﺪدﻳﺔ أم ﻻ‬

‫وﻛﻠﻤﺔ ‪ isNaN‬ھﻲ إﺧﺘﺼﺎر ﻟﻠ ﺠﻤﻠﺔ اﻟﺘﺎﻟﯿﺔ ‪ is Not a Number‬اي ھﻞ اﻟﻘﯿﻤﺔ اﻟﻤﻤ ﺮرة ﻟﯿﺴﺖ ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫(‪isNaN‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫‪41‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ھﺬه اﻟﺪاﻟﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻣﻦ اﻟﻨﻮع اﻟﺒﻮﻟﯿﻨﻲ اي إﺣﺪي اﻟﻘﯿﻤﺘﯿﻦ ‪ true‬أو ‪false‬‬

‫ﻣﺜﺎل‬

‫;) )"‪alert( isNaN("1.3‬‬

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

‫اﻟﺪاﻟﺔ ‪parseFloat‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ اﻟﻘﯿﻢ اﻟﻨﺼﯿﺔ إﻟﻲ ﻗﯿﻢ ﻋﺪدﻳﺔ ﻧﺴﺒﯿﺔ ) اي أﻧﮫﺎ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد اﻟﺼﺤﯿﺤﺔ و اﻷﻋﺪاد اﻟﻨﺴﺒﯿﺔ ( ‪.‬‬

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

‫(‪parseFloat‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد ﺗﺤﻮﯾﻠﻬﺎ‬ ‫;)‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ھﺬه اﻟﺪاﻟﺔ ‪ :‬ﺑﻌﺪ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﻳﻞ ﻳﺘﻢ إرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﻧﺴﺒﯿﺔ‬

‫ﻣﺜﺎل‬

‫;) "‪var num = parseFloat( "23.32‬‬

‫;) ‪alert( num‬‬

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

‫‪42‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫ﻛﻤﺎ ذﻛﺮﻧﺎ ﺳﺎﺑﻘﺎ أن اﻟﻨﺺ ھﻮ ﻋﺒﺎرات وﺟﻤﻞ ﻳﺘﻢ ﻛﺘﺎﺑﺘﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ ﺗﻨﺼﯿﺺ ""‬
‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﻧﺮﻳﺪ ﻋﻤﻞ ﻧﺺ ﺑﻪ ﻋﺒﺎرة أﻧﺎ ﻣﻦ ﻣﺤﺒﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﺳﻮف ﻧﻘﻮم ﺑﻮﺿﻌﮫﺎ ﺑﯿﻦ ﻋﻼﻣﺘﯿﻦ‬
‫اﻟﺘﻨﺼﯿﺺ ﻛﻤﺎ ﻳﻠﻲ " أﻧﺎ ﻣﻦ ﻣﺤﺒﻲ ﻟﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ " وﺑﺬﻟﻚ ﻳﺴﺘﻄﯿﻊ ﻣﻔﺴﺮ اﻟﻠﻐﺔ ﺗﻤﯿﺰ أن ھﺬه اﻟﻜﻠﻤﺎت ﺗﺎﺑﻌﺔ‬
‫ﻟﻨﺺ واﺣﺪ ‪.‬‬

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

‫ﻋﻼﻣﺎت اﻟﮫﺮوب أو اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﺔ ﻟﻠﻜﺘﺎﺑﺔ ‪Escaping Characters‬‬

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

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

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

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

‫‪43‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

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

‫>‪<HTML dir=rtl‬‬
‫اﻟﺘﻨﺼﯿﺺ >‪<Title‬‬ ‫ﺗﺪاﺧﻞ ﻋﻼﻣﺎت‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬
‫ﻗﺪ"(‪document.write‬‬ ‫">‪ " + "<br‬ﻧﺘﻤﻨﺎ ﻟﻚ ﯾﺎ ﻗﺎرﺋﻨﺎ \"اﻟﻌﺰﯾﺰ \" أن ﺗﻜﻮن‬ ‫‪+‬‬
‫أت "‬ ‫;)" ﺗﻌﻠﻤﺖ ﻣﺎ ﺳﺒﻖ ﻣﻦ ﻗﻮل وان ﺗﺤﺮص ﻋﻠﻲ ﻣﺎ ﻫﻮ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

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

‫‪44‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫‪URL String Encoding and Decoding‬‬ ‫دوال ﺗﺸﻔﯿﺮ وﻓﻚ ﺗﺸﻔﯿﺮ ﻋﻨﺎوﻳﻦ اﻷﻧﺘﺮﻧﺖ‬
‫أﺣﯿﺎﻧﺎ ﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺈرﺳﺎل ﻋﻨﻮان ﻻﺣﺪي اﻟﻤﻮاﻗﻊ ‪ ،‬ﺑﺄن ﻧﻘﻮم ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل ﺑﻜﺘﺎﺑﺔ اﻟﻌﻨﻮان اﻟﺘﺎﻟﻲ‬
‫"‪ "http://www.islamway.com/index.php?action=all news‬ﻓﻲ ﺷﺮﻳﻂ اﻟﻌﻨﻮان ﺑﺎﻟﻤﺘﺼﻔﺢ ‪ Address Bar‬ﻓﻌﻨﺪ‬
‫اﻟﻀﻐﻂ ﻋﻠﻲ زرار ذھﺎب ‪ go‬ﻳﺘﻢ ﺗﺸﻔﯿﺮ ﻋﻨﻮان اﻟﻤﻮﻗﻊ ‪ url‬ﺗﻠﻘﺎﺋﯿﺎ اي ﻳﺘﻢ ﺗﺤﻮﻳﻞ اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﺔ إﻟﻲ ﻣﺎ ﻳﻘﺎﺑﻠﮫﺎ ﻓﻲ‬
‫اﻟﻨﻈﺎم اﻟﺴﺘﻌﺸﺮي ﺑﻨﻈﺎم اﻟﺘﺸﻔﯿﺮ اﻷﺳﻜﻲ ‪ ASCII‬وﻳﻜﻮن اﻟﻌﻨﻮان اﻟﻨﺎﺗﺞ ﻛﻤﺎ ﻳﻠﻲ‬
‫"‪ " http://www.islamway.com/index.php?action=all%20news‬ﻻﺣﻆ أن ﺣﺮف اﻟﻤﺴﺎﻓﺔ ﺑﯿﻦ اﻟﻜﻠﻤﺘﯿﻦ ‪ all‬و‬
‫اﻟﻜﻠﻤﺔ ‪ news‬ﺗﻢ إﺳﺘﺒﺪاﻟﮫﺎ ﺑﺎﻟﺮﻣﺰ اﻟﺘﺎﻟﻲ "‪ "%20‬واﻟﺮﻗﻢ ‪ ٢٠‬ھﻮ اﻟﺮﻗﻢ اﻟﺴﺘﻌﺸﺮي ﻓﻲ ﻧﻈﺎم اﻟﺘﺸﻔﯿﺮ اﻷﺳﻜﻲ‬
‫اﻟﻤﻘﺎﺑﻞ ﻟﺤﺮف اﻟﻤﺴﺎﻓﺔ ‪.‬‬

‫ﻟﻜﻦ أﺣﯿﺎﻧﺎ ﻧﻘﻮم ﻧﺤﻦ ﺑﺈﺳﺘﺨﺪام أﺣﺪي اﻟﺪوال ﻟﻌﻤﻞ إرﺳﺎل ﻟﻌﻨﻮان ﻣﻮﻗﻊ ﻣﻦ ﺧﻼل ﻛﻮد اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ وﺑﺬﻟﻚ ﻓﻨﺤﻦ‬
‫ﻓﻲ ﻋﺮﺿﺔ ﻟﻌﺪم ﺗﺸﻔﯿﺮ ﺑﯿﺎﻧﺎت ﻋﻨﻮان اﻟﻤﻮﻗﻊ اﻟﻤﺮﺳﻞ ﻟﺬﻟﻚ ﻧﺤﺘﺎج إﻟﻲ ﻛﻠﺘﺎ اﻟﺪاﻟﺘﯿﻦ ‪ escape‬و ‪. unescape‬‬

‫اﻟﺪاﻟﺔ ‪escape‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺸﻔﯿﺮ اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﺔ اﻟﻤﻮﺟﻮدة ﺑﻌﻨﻮان اﻟﻤﻮﻗﻊ ‪ url‬أو اي ﻧﺺ ) ﻟﯿﺲ ﺑﺎﻟﻀﺮورة أن ﻳﻜﻮن ﻋﻨﻮان ﻟﻤﻮﻗﻊ (‬
‫إﻟﻲ ﻣﺎ ﻳﻘﺎﺑﻠﮫﺎ ﻓﻲ اﻟﻨﻈﺎم اﻟﺴﺘﻌﺸﺮي ﺑﻨﻈﺎم اﻟﺘﺸﻔﯿﺮ اﻷﺳﻜﻲ ‪ ASCII‬ﻣﻀﺎﻓﺎ إﻟﯿﺔ اﻟﻌﻼﻣﺔ ‪. %‬‬

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

‫(‪escape‬‬ ‫ﻋﻨﻮان اﻟﻤﻮﻗﻊ اﻟﻤﺮاد ﺗﺸﻔﯿﺮه‬ ‫;)‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ھﺬه اﻟﺪاﻟﺔ ‪ :‬ﺑﻌﺪ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﻳﻞ ﻳﺘﻢ إرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

‫ﻣﺜﺎل‬

‫;"‪var siteURL = "http://www.islamway.com/index.php?action=all news‬‬

‫;) ‪var codedSiteURL = escape( siteURL‬‬

‫;) ‪alert( codedSiteURL‬‬

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

‫وﻛﻤﺎ ﺗﺮي ﻓﻘﺪ ﺗﻐﯿﺮ ﻋﻨﻮان اﻟﻤﻮﻗﻊ إﻟﻲ ﻋﻨﻮان ﺧﻄﺄ ﻷﻧﻪ ﺗﻢ ﺗﺸﻔﯿﺮ ﻛﻞ اﻟﻌﻨﻮان ‪ ،‬وﻟﻜﻨﻨﺎ داﺋﻤﺎ ﻣﺎ ﻧﺤﺘﺎج إﻟﻲ ﺗﺸﻔﯿﺮ‬
‫اﻟﺒﯿﺎﻧﺎت اﻟﻤﺮﺳﻠﺔ ﻓﻘﻂ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪45‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;"=‪var siteURL = "http://www.islamway.com/index.php?action‬‬

‫;) "‪var codedSiteURL = siteURL + escape( "all news‬‬

‫;) ‪alert( codedSiteURL‬‬

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

‫اﻟﺪاﻟﺔ ‪unescape‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻔﻚ ﺗﺸﻔﯿﺮ اﻟﻌﻼﻣﺎت اﻟﺨﺎﺻﺔ اﻟﻤﻮﺟﻮدة ﺑﻌﻨﻮان اﻟﻤﻮﻗﻊ ‪ url‬أو اي ﻧﺺ ) ﻟﯿﺲ ﺑﺎﻟﻀﺮورة أن ﻳﻜﻮن ﻋﻨﻮان ﻟﻤﻮﻗﻊ‬
‫( إ ي ﻋﻜﺲ ﻣﺎ ﺗﻘﻮم ﺑﻪ اﻟﺪاﻟﺔ ‪. escape‬‬

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

‫(‪unescape‬‬ ‫ﻋﻨﻮان اﻟﻤﻮﻗﻊ اﻟﻤﺮاد ﻓﻚ ﺗﺸﻔﯿﺮه‬ ‫;)‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ﻣﻦ ھﺬه اﻟﺪاﻟﺔ ‪ :‬ﺑﻌﺪ ﻋﻤﻠﯿﺔ اﻟﺘﺤﻮﻳﻞ ﻳﺘﻢ إرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

‫ﻣﺜﺎل‬

‫‪//‬‬ ‫ﺗﺸﻔﯿﺮ اﻟﻨﺺ‬

‫;"=‪var siteURL = "http://www.islamway.com/index.php?action‬‬
‫;) "‪var codedSiteURL = siteURL + escape( "all news‬‬

‫‪//‬‬ ‫ﻓﻚ ﺗﺸﻔﯿﺮ اﻟﻨﺺ‬

‫;)‪var UnCodedSiteURL = unescape(codedSiteURL‬‬

‫;) ‪alert( UnCodedSiteURL‬‬

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

‫‪46‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺮﺍﺑﻊ‬
‫ﻛﺎﺋﻦ ﺍﻟﻨﺼﻮﺹ‬

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

‫ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object‬‬ ‫•‬

‫إﻧﺸﺎء ﻛﺎﺋﻦ ﻧﺼﻲ‬ ‫•‬
‫ﺧﺼﺎﺋﺺ ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object Properties‬‬ ‫•‬
‫دوال ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object Methods‬‬ ‫•‬
‫‪ o‬اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ‪parsing Methods‬‬
‫‪ o‬اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺘﻨﺴﯿﻖ اﻟﻨﺺ ‪Formatting Methods‬‬

‫‪47‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object‬‬

‫إﻧﺸﺎء ﻛﺎﺋﻦ ﻧﺼﻲ‬

‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء اﻟﻜﺎﺋﻦ اﻟﻨﺼﻲ ﺑﻌﺪة ﻃﺮق ﻛﻤﺎ ﻳﻠﻲ‬

‫‪ - ١‬إﻧﺸﺎء ﻛﺎﺋﻦ ﻧﺼﻲ ﺑﺈﺳﺘ ﺨﺪام اﻟﻜﺎﺋﻦ ‪String‬‬

‫;)(‪var str = new String‬‬

‫أو‬

‫;)"اﻟﻨﺺ"(‪var str = new String‬‬

‫‪ - ٢‬ﻻﺣﻆ أن اﻟﻨﺺ اﻟﺒﺴﯿﻂ ﻳﻤﻜﻦ إﺳﺘﺨﺪاﻣﻪ ﻣﺜﻞ اﻟﻤﺘﻐﯿﺮ اﻟﻨﺎﺷﺊ ﻣﻦ اﻟﻜﺎﺋﻦ ‪String‬‬

‫ﺑﺎﻟﻨﺼﻮص" = ‪var literalStr‬‬ ‫;"ﻣﺮﺣﺒﺎ‬

‫ﻳﻮﻓ ﺮ ﻟﻨﺎ اﻟﻜﺎﺋﻦ اﻟﻨﺼﻲ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺨﺼﺎﺋﺺ واﻟﺪوال اﻟﻤﮫﻤﺔ ‪ ،‬ﻟﺬﻟﻚ دﻋﻨﺎ ﻧﺘﺤﺪث اﻷن ﻋﻦ اﻟﺨﺼﺎﺋﺺ و اﻟﺪوال اﻟﺨﺎﺻﺔ‬
‫ﺑﻜﺎﺋﻦ اﻟﻨﺼﻮص‬

‫ﺧﺼﺎﺋﺺ ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object Properties‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪constructor‬‬
‫ﺳﻮف ﻧﺘﺤﺪث ﻋﻦ اﻟﺨﺎﺻﯿﺔ ‪ constructor‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨﺎت واﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ‬

‫اﻟﺨﺎﺻﯿﺔ ‪prototype‬‬
‫ﺳﻮف ﻧﺘﺤﺪث ﻋﻦ اﻟﺨﺎﺻﯿﺔ ‪ prototype‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨﺎت واﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ‬
‫واﻟﻮراﺛﺔ ‪Inheritance‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪length‬‬

‫ﺗﺴﺘﺨﺪم اﻟﺨﺎﺻﯿﺔ ‪ length‬ﻟﺤﺴﺎب ﻃﻮل اﻟﻨﺺ اي ﻋﺪد اﻟﺤﺮوف اﻟﻤﻜﻮﻧﺔ ﻟﮫﺬا اﻟﻨﺺ‬

‫ﻣﺜﺎل‬

‫ا ﻟﻨﺼﻲ"(‪var strObject = new String‬‬ ‫;)"اﻟﻜﺎﺋﻦ‬

‫;) ‪alert( strObject.length‬‬

‫‪48‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫أو ﻛﻤﺎ ﻳﻠﻲ‬

‫;)(‪var strObject = new String‬‬

‫اﻟﻨﺼﻲ" = ‪strObject‬‬ ‫;"اﻟﻜﺎﺋﻦ‬

‫;) ‪alert( strObject.length‬‬

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

‫ﻣﺜﺎل‬

‫اﻟﺒﺴﯿﻂ" = ‪var str‬‬ ‫;"اﻟﻤﺘﻐﯿﺮ اﻟﻨﺼﻲ‬

‫;) ‪alert( str.length‬‬

‫أو ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺒﺴﯿﻂ" (‪alert‬‬ ‫‪".length‬اﻟﻤﺘﻐﯿﺮ اﻟﻨﺼﻲ‬ ‫;)‬

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

‫‪49‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫دوال ﻛﺎﺋﻦ اﻟﻨﺼﻮص ‪String Object Methods‬‬

‫ﺳﻮف ﻧﻘﺴﻢ دوال اﻟﻜﺎﺋﻦ اﻟﻨﺼﻲ إﻟﻲ ﻗﺴﻤﯿﻦ أﺣﺪھﻤﺎ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ﺗﻘﻄﯿﻊ اﻟﻨﺼﻮص واﻷﺧﺮ ﻟﺘﻐﯿﺮ ﻧﺴﻖ اﻟﻨﺺ ﻣﻦ ﻟﻮن‬
‫وﺳﻤﻚ أﻟﺦ ﻋﻨﺪ ﻛﺘﺎﺑﺔ ﺗﻠﻚ اﻟﻨﺺ ﻓﻲ اﻟﻤﺘﺼﻔﺢ‬

‫اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ‪parsing Methods‬‬

‫اﻟﺪاﻟﺔ ‪charAt‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻘﺮاءة ﺣﺮف واﺣﺪ ﻓﻲ ﻣﻮﻗﻊ ﻣﻌﯿﻦ ﻣﻦ اﻟﻨﺺ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

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

‫(‪String.charAt‬‬ ‫ﻣﻮﻗﻊ اﻟﺤﺮف‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var str = new String‬‬

‫اﷲ" = ‪str‬‬ ‫;"ﻻ اﻟﻪ إﻻ اﷲ ﻣﺤﻤﺪ رﺳﻮل‬

‫" (‪alert‬‬ ‫"اﻟﺤﺮف اﻟﺬي ﯾﻘﻊ ﻋﻨﺪ اﻟﻤﻮﻗﻊ اﻟﺜﺎﻧﻲ ‪:‬‬ ‫;) )‪+ str.charAt(1‬‬

‫;)‪var char = str.charAt(7‬‬

‫" (‪alert‬‬ ‫"اﻟﺤﺮف اﻟﺬي ﯾﻘﻊ ﻋﻨﺪ اﻟﻤﻮﻗﻊ اﻟﺜﺎﻣﻦ ‪:‬‬ ‫;) ‪+ char‬‬

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

‫‪50‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ ﻋﻜﺲ ﻧﺺ ﻳﺘﻢ إﺳﺘﻘﺒﺎﻟﻪ ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬

<HTML>
<Title> ‫ﻋﻜﺲ اﻟﻨﺺ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

// ‫اﻟﺪاﻟﺔ اﻟﺨﺎﺻﺔ ﺑﻌﻜﺲ اﻟﻨﺺ‬

function reverseString( str ){
var Revstr = "";
for( var i = str.length-1; i>=0; i--)
Revstr += str.charAt(i);

return Revstr;
}

var strFromUser = prompt("‫اﻟﻨﺺ‬ ‫"ادﺧﻞ‬,"");

alert( reverseString(strFromUser) );

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

‫ ﻛﻤﺎ ﻳﻠﻲ‬olleh ‫ ھﻮ‬hello ‫وﻳﻜﻮن اﻟﻨﺎﺗﺞ ﻋﻨﺪ إدﺧﺎل اﻟﻘﯿﻤﺔ‬

51
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪوال ‪ charCodeAt‬و ‪fromCharCode‬‬

‫اﻟﺪاﻟﺔ ‪charCodeAt‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻘﺮاءة ﺣﺮف واﺣﺪ ﻓﻲ ﻣﻮﻗﻊ ﻣﻌﯿﻦ ﻣﻦ اﻟﻨﺺ وﻟﻜﻦ ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻘﯿﻤﺔ اﻟﻌﺪدﻳﺔ ﺑﻨﻈﺎم اﻟﺘﺸﻔﯿﺮ اﻷﺳﻜﻲ‬
‫‪ ASCII‬ﻟﮫﺬا اﻟﺤﺮف‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫(‪String.charCodeAt‬‬ ‫ﻣﻮﻗﻊ اﻟﺤﺮف‬ ‫;)‬

‫أو‬

‫;)(‪String.charCodeAt‬‬

‫ﻣﺜﺎل‬

‫;)(‪"abc".charCodeAt‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 97‬‬

‫;)‪"abc".charCodeAt(0‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 97‬‬
‫;)‪"abc".charCodeAt(1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 98‬‬

‫اﻟﺪاﻟﺔ ‪fromCharCode‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ ﻗﯿﻤﺔ ﻋﺪدﻳﺔ أو أﻛﺜﺮ ﺑﻨﻈﺎم اﻷﺳﻜﻲ ‪ ASCII‬إﻟﻲ ﻣﺎ ﻳﻘﺎﺑﻠﮫﺎ ﻣﻦ ﺣﺮوف‬
‫اي أﻧﮫﺎ ﺗﻘﻮم ﺑﻌﻜﺲ وﻇﯿﻔﺔ اﻟﺪاﻟﺔ ‪charCodeAt‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺣﺮف أو أﻛﺜﺮ‬

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

‫( ‪String.fromCharCode‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻌﺪدﯾﺔ‬ ‫;)‬

‫أو‬

‫(‪String.fromCharCode‬‬ ‫أﻛﺜﺮ ﻣﻦ ﻗﯿﻤﺔ ﻋﺪدﯾﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)‪String.fromCharCode(97‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: a‬‬

‫;)‪String.fromCharCode(97, 98 ,99‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: abc‬‬

‫‪52‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪concat‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺪﻣﺞ ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﺑﻘﯿﻤﺔ ﻧﺼﯿﺔ أﺧﺮي‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ ﻣﻜﻮﻧﺔ ﻧﺎﺗﺞ دﻣﺞ ﻧﺼﯿﻦ‬

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

‫(‪String.concat‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)"‪"abc".concat("def‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: abcdef‬‬

‫اﻟﺪوال ‪ indexOf‬و ‪lastIndexOf‬‬

‫اﻟﺪاﻟﺔ ‪indexOf‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺒﺤﺚ ﻋﻦ ﻣﻮﻗﻊ ﻧﺺ داﺧﻞ ﻧﺺ أﺧﺮ ‪ ،‬وﻳﺒﺪأ اﻟﺒﺤﺚ ﻣﻦ أول ﺣﺮف ﺑﺎﻟﻨﺺ اﻟﺬي ﻳﺘﻢ اﻟﺒﺤﺚ ﻓﯿﻪ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﺗﻌﺒﺮ ﻋﻦ ﻣﻮﻗﻊ اﻟﻨﺺ اﻟﺬي ﻳﺘﻢ اﻟﺒﺤﺚ ﻋﻨﻪ داﺧﻞ اﻟﻨﺺ اﻟﻤﺒﺤﻮث ﻓﺒﻪ‬

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

‫(‪String.indexOf‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد اﻟﺒﺤﺚ ﻋﻨﻬﺎ‬ ‫;)‬

‫أو‬

‫(‪String.indexOf‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد اﻟﺒﺤﺚ ﻋﻨﻬﺎ‬ ‫‪,‬‬ ‫;)ﻣﻮﻗﻊ ﺑﺪاﯾﺔ اﻟﺒﺤﺚ‬

‫ﻣﺜﺎل‬

‫;)"‪"abc".indexOf("b‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 1‬‬

‫;)"‪"abc".indexOf("c‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 2‬‬

‫;)"‪"abc".indexOf("bd‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: -1‬‬

‫;)"‪"abc".indexOf("g‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: -1‬‬

‫;)‪"abc".indexOf("b" ,1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 1‬‬

‫;)‪"abc".indexOf("b" ,2‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: -1‬‬

‫ﻛﻤﺎ ﻧﺮي إذا ﻟﻢ ﻳﺘﻢ اﻟﻌﺜﻮر ﻋﻠﻲ اﻟﻨﺺ ﻳﺘﻢ إرﺟﺎع اﻟﻘﯿﻤﺔ ‪١ -‬‬

‫‪53‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ اﻟﺘﺄﻛﺪ ﻣﻦ ﺻﺤﺔ ﻗﯿﻤﺔ ﺑﺮﻳﺪ إﻟﯿﻜﺘﺮوﻧﻲ ﻳﺘﻢ إﺳﺘﻘﺒﺎﻟﻪ ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬

‫ﻣﻊ اﻟﻌﻠﻢ أن اﻟﺒﺮﻳﺪ اﻷﻟﯿﻜﺘﺮوﻧﻲ ﻳﺘﻤﯿﺰ ﺑﻮﺟﻮد اﻟﺮﻣﺰ @‬

‫>‪<HTML‬‬
‫>‪<Title‬‬ ‫اﻟﺘﺄﻛﺪ ﻣﻦ ﺻﺤﺔ اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫‪//‬‬ ‫اﻟﺪاﻟﺔ اﻟﺨﺎﺻﺔ ﻟﻠﺘﺄﻛﺪ ﻣﻦ وﺟﻮد اﻟﺮﻣﺰ‬ ‫@‬

‫‪//‬‬ ‫ﺑﻨﺺ اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ اﻟﻤﺮﺳﻞ ﻟﻬﺎ‬
‫{) ‪function IsValidEmail( Emailstr‬‬
‫; ‪return ( Emailstr.indexOf("@") != -1 )? true : false‬‬
‫}‬

‫اﻷﻟﯿﻜﺘﺮوﻧﻲ"(‪var EmailstrFromUser = prompt‬‬ ‫;)""‪",‬ادﺧﻞ ﺑﺮﯾﺪك‬

‫) )‪if( IsValidEmail(EmailstrFromUser‬‬
‫"(‪alert‬‬ ‫ﻫﺬا اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﺻﺤﯿﺢ‬ ‫;)"‬
‫‪else‬‬
‫" (‪alert‬‬ ‫ﻫﺬا اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﻏﯿﺮ ﺻﺤﯿﺢ‬ ‫;) "‬

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

‫وﺳﻮف ﻧﺮي ﺑﺎﻟﻔﺼﻞ اﻟﻘﺎدم "اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ" ﻛﯿﻒ ﻳﺘﻢ اﻟﺘﺄﻛﺪ ﻣﻦ اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﺑﺸﻜﻞ أﻛﺜﺮ دﻗﺔ‬

‫اﻟﺪاﻟﺔ ‪lastIndexOf‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺒﺤﺚ ﻋﻦ ﻣﻮﻗﻊ ﻧﺺ داﺧﻞ ﻧﺺ أﺧﺮ ‪ ،‬وﻳﺒﺪأ اﻟﺒﺤﺚ ﻣﻦ أﺧﺮ ﺣﺮف ﺑﺎﻟﻨﺺ اﻟﺬي ﻳﺘﻢ اﻟﺒﺤﺚ ﻓﯿﻪ ‪ ،‬وھﻲ‬
‫ﺑﺬﻟﻚ ﺗﺘﺸﺎﺑﻪ إﻟﻲ ﺣﺪ ﻣﺎ ﻣﻊ اﻟﺪاﻟﺔ ‪. indexOf‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ ﺗﻌﺒﺮ ﻋﻦ ﻣﻮﻗﻊ اﻟﻨﺺ اﻟﺬي ﻳﺘﻢ اﻟﺒﺤﺚ ﻋﻨﻪ داﺧﻞ اﻟﻨﺺ اﻟﻤﺒﺤﻮث ﻓﺒﻪ‬

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

‫(‪String.lastIndexOf‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد اﻟﺒﺤﺚ ﻋﻨﻬﺎ‬ ‫;)‬

‫أو‬

‫(‪String.lastIndexOf‬‬ ‫اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ اﻟﻤﺮاد اﻟﺒﺤﺚ ﻋﻨﻬﺎ‬ ‫‪,‬‬ ‫;)ﻣﻮﻗﻊ ﺑﺪاﯾﺔ اﻟﺒﺤﺚ‬

‫‪54‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)"‪"abcdef".lastIndexOf("b‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 1‬‬

‫;)"‪"abcdef".lastIndexOf("c‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 2‬‬

‫;)"‪"abcdef".lastIndexOf("bd‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: -1‬‬

‫;)"‪"abcdef".lastIndexOf("g‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: -1‬‬

‫;)‪"abcdef".lastIndexOf("b" ,1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 1‬‬

‫;)‪"abcdef".lastIndexOf("b" ,2‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: 1‬‬

‫اﻟﺪوال ‪ match‬و ‪ replace‬و ‪search‬‬

‫ﺳﻮف ﻳﺘﻢ ﻣﻨﺎﻗﺸﺘﮫﻢ ﻓﻲ اﻟﻔﺼﻞ اﻟﻘﺎدم "اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ"‬

‫اﻟﺪوال ‪ slice‬و ‪ substr‬و ‪substring‬‬

‫اﻟﺪاﻟﺔ ‪ slice‬و ‪substring‬‬

‫ﺗﺴﺘﺨﺪم ﻹﺳﺘﺨﻼص ﺟﺰء ﻣﻦ اﻟﻨﺺ ﺑﺪون أن ﺗﺆﺛﺮ ﻋﻠﻲ اﻟﻨﺺ اﻷﺳﺎﺳﻲ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

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

‫(‪String.slice‬‬ ‫;) ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬

‫(‪String.substring‬‬ ‫;) ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬

‫أو‬

‫(‪String.slice‬‬ ‫;)ﻣﻮﻗﻊ اﻟﻨﻬﺎﯾﺔ ‪ ,‬ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬

‫( ‪String.substring‬‬ ‫;)ﻣﻮﻗﻊ اﻟﻨﻬﺎﯾﺔ ‪ ,‬ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬

‫ﻣﺜﺎل‬

‫;)‪"abcdef".substring(1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: bcdef‬‬

‫;)‪"abcdef".substring(1,3‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: bc‬‬

‫‪55‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻻﺟﻆ اﻟﺘﺎﻟﻲ‬

‫ﻣﺜﺎل‬

‫;)‪"abcdef".substring(2, -1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: ab‬‬

‫ﻷﻧﻪ ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻣﻮﻗﻊ اﻟﻨﮫﺎﻳﺔ اﻟﻤﻤﺮر ﻟﻠﺪاﻟﺔ ‪ substring‬أو ‪ slice‬ﻗﯿﻤﺔ ﺳﺎﻟﺒﺔ ﻳﺘﻢ اﻟﺒﺤﺚ ﻣﻦ ﻧﮫﺎﻳﺔ ﻣﻮﻗﻊ اﻟﺒﺪاﻳﺔ ﻓﻜﻤﺎ‬
‫ﺑﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻛﺎن ﻣﻮﻗﻊ اﻟﺒﺪاﻳﺔ ھﻮ ‪ ٢‬اي ﻣﺎ ﻳﻜﺎﻓﺊ اﻟﺤﺮف ‪ c‬ﺛﻢ ﺗﻢ اﻟﺒﺤﺚ ﻟﻘﯿﻤﺔ ﻣﻮﻗﻊ اﻟﻨﮫﺎﻳﺔ ﺑﻘﯿﻤﺔ ﺳﺎﻟﺒﺔ ﺗﺴﺎوي‬
‫– ‪ ١‬اي أﻧﻪ ﺳﺘﺘﻢ ﻋﻤﻠﯿﺔ إﺧﺘﺰال اﻟﻨﺺ ﻓﻲ أﺗﺠﺎه اﻟﯿﺴﺎر إﺑﺘﺪأ ﻣﻦ اﻟﺤﺮف ﻣﻮﻗﻊ اﻟﺤﺮف ‪. b‬‬

‫اﻟﺪاﻟﺔ ‪substr‬‬

‫ﺗﺴﺘﺨﺪم ﻹﺳﺘﺨﻼص ﺟﺰء ﻣﻦ اﻟﻨﺺ ﺑﺪون أن ﺗﺆﺛﺮ ﻋﻠﻲ اﻟﻨﺺ اﻷﺳﺎﺳﻲ ‪ ،‬ﻛﻤﺎ ﺗﻔﻌﻞ اﻟﺪاﻟﺔ ‪ substring‬ﻣﻊ وﺟﻮد ﻓﺎرق‬
‫أن اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ اﻟﻤﻤﺮر ﻟﻠﺪاﻟﺔ ‪ substr‬ﻳﻌﺒﺮ ﻋﻦ ﻋﺪد اﻟﺤﺮوف اﻟﻤﺨﺘﺰﻟﺔ أو ﻃﻮل اﻟﻨﺺ اﻟﻨﺎﺗﺞ ‪ ،‬ﺑﯿﻨﻤﺎ ﻳﻌﺒﺮ ﻋﻦ ﻣﻮﻗﻊ‬
‫اﻟﻨﮫﺎﻳﺔ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺪاﻟﺔ ‪. substring‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

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

‫(‪String.substr‬‬ ‫;) ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬

‫أو‬

‫( ‪String.substr‬‬ ‫ﻣﻮﻗﻊ اﻟﺒﺪاﯾﺔ‬ ‫‪,‬‬ ‫ﻃﻮل اﻟﻨﺺ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)‪"abcdef".substr(1‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: bcdef‬‬

‫;)‪"abcdef".substr(1,3‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: bcd‬‬

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ إﺳﺘﺨﻼص اﺳﻢ اﻟﻤﺴﺘﺨﺪم وﺳﻢ ﻣﺰود ﺧﺪﻣﺔ اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﻟﻘﯿﻤﺔ ﺑﺮﻳﺪ إﻟﯿﻜﺘﺮوﻧﻲ ﻳﺘﻢ إﺳﺘﻘﺒﺎﻟﻪ ﻣﻦ‬
‫اﻟﻤﺴﺘﺨﺪم‬

‫ﻣﻊ اﻟﻌﻠﻢ أن اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻳﺴﺒﻖ ﻣﻮﻗﻊ اﻟﺮﻣﺰ @ و اﺳﻢ ﻣﺰود اﻟﺨﺪﻣﺔ ﻳﻠﻲ اﻟﺮﻣﺰ @ ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‬
‫إذا ﻛﺎن اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ اﻟﻤﺪﺧﻞ ھﻮ ‪a_elhussein@hotmail.com‬‬
‫ﻳﻜﻮن اﺳﻢ اﻟﻤﺴﺘﺨﺪم ‪a_elhussein‬‬
‫وﻳﻜﻮن اﺳﻢ اﻟﻤﺰود ‪hotmail‬‬

‫‪56‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

<HTML dir=rtl>
<Title> ‫اﻹﻟﯿﻜﺘﺮوﻧﻲ‬ ‫اﻟﺒﺮﯾﺪ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

var EmailstrFromUser;
EmailstrFromUser = prompt("‫اﻷﻟﯿﻜﺘﺮوﻧﻲ‬ ‫"ادﺧﻞ ﺑﺮﯾﺪك‬,"");

var indexOfDelimiter = EmailstrFromUser.indexOf("@");

if( indexOfDelimiter != -1 ){
var username = EmailstrFromUser.substring(0, indexOfDelimiter);

var indexOfDot = EmailstrFromUser.indexOf(".");

var serverName = EmailstrFromUser.substring( indexOfDelimiter+1, indexOfDot);

alert( " : ‫"اﺳﻢ اﻟﻤﺴﺘﺨﺪم‬ + username + "\r\n" +

" : ‫ "اﺳﻢ اﻟﻤﺰود‬+ serverName );
}else{
alert( " ‫ﻫﺬا اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﻏﯿﺮ ﺻﺤﯿﺢ‬ " );
}

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

split ‫اﻟﺪاﻟﺔ‬

‫ ﺛﻢ ﺗﻘﻮم ﺑﻮﺿﻊ اﻟﺠﻤﻞ اﻟﻤﻘﻄﻌﺔ ﻓﻲ ﻣﺼﻔﻮﻓﺔ ذات‬، ‫ﺗﺴﺘﺨﺪم ﻟﺘﻘﻄﯿﻊ اﻟﻨﺺ إﺳﺘﻨﺎدا ﻋﻠﻲ ﺟﻤﻠﺔ اﻟﺘﻘﻄﯿﻊ اﻟﻤﻤﺮرة ﻟﮫﺎ‬
. ‫ﺑﻌﺪ واﺣﺪ‬

‫ ﺗﻘﻮم ﺑﺈرﺟﺎع ﻣﺼﻔﻮﻓﺔ ﺗﺤﻤﻞ اﻟﺠﻤﻞ اﻟﻤﻘﻄﻌﺔ‬: ‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ‬

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

String.split( ‫اﻟﺠﻤﻠﺔ اﻟﻤﺮاد اﻟﺘﻘﻄﯿﻊ ﺑﻬﺎ‬ );

‫أو‬

String.split( ‫اﻟﺠﻤﻠﺔ اﻟﻤﺮاد اﻟﺘﻘﻄﯿﻊ ﺑﻬﺎ‬ , ‫;)ﻃﻮل اﻟﻤﺼﻔﻮﻓﺔ اﻟﻨﺎﺗﺞ‬

57
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)"‪"abcdef".split("cd‬‬

‫ﻳﻨﺘﺞ ﻋﻨﮫﺎ اﻟﻤﺼﻔﻮﻓﺔ اﻟﺘﺎﻟﯿﺔ‬

‫‪Arr[0] ----------à ab‬‬

‫‪Arr[1] ----------à ef‬‬

‫ﻣﺜﺎل‬

‫;)"‪var arr = "abcdef".split("cd‬‬

‫;) )(‪alert( arr.toString‬‬

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

‫ﻣﺜﺎل‬

‫;)‪var arr = "abcdef".split("cd", 1‬‬

‫;) )(‪alert( arr.toString‬‬

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

‫‪58‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪ toLowerCase‬و ‪toUpperCase‬‬

‫ﺗﺴﺘﺨﺪم اﻟﺪاﻟﺔ ‪ toLowerCase‬ﻟﺘﺤﻮﻳﻞ ﺣﺎﻟﺔ اﻟﺤﺮوف ﺑﺎﻟﻨﺺ إﻟﻲ ﺣﺮوف ﺻﻐﯿﺮة ‪small letters‬‬
‫وﻋﻠﻲ اﻟﻌﻜﺲ ﺗﺴﺘﺨﺪم اﻟﺪاﻟﺔ ‪ toUpperCase‬ﻟﺘﺤﻮﻳﻞ ﺣﺎﻟﺔ اﻟﺤﺮوف ﺑﺎﻟﻨﺺ إﻟﻲ ﺣﺮوف ﻛﺒﯿﺮة ‪. capital letters‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

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

‫;)(‪String.toLowerCase‬‬
‫;)(‪String.toUpperCase‬‬

‫ﻣﺜﺎل‬

‫;)(‪"abcdef".toUpperCase‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: ABCDEF‬‬

‫;)(‪"AbcDef".toLowerCase‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: abcdef‬‬

‫اﻟﺪاﻟﺔ ‪ toString‬و ‪valueOf‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻌﺮض ﻗﯿﻤﺔ اﻟﻨﺺ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻧﺼﯿﺔ‬

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

‫;)‪String.toString‬‬
‫;)(‪String.valueOf‬‬

‫ﻣﺜﺎل‬

‫;)(‪"abcdef".toString‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: abcdef‬‬

‫;)(‪"abcdef".valueOf‬‬ ‫‪//‬‬ ‫ﯾﻨﺘﺞ ﻋﻨﻪ اﻟﻘﯿﻤﺔ‬ ‫‪: abcdef‬‬

‫‪59‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪوال اﻟﺨﺎﺻﺔ ﺑﺘﻨﺴﯿﻖ اﻟﻨﺺ ‪Formatting Methods‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﻐﯿﺮ ﻧﺴﻖ اﻟﻨﺺ‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺪاﻟﺔ‬
‫)‪ anchor( name‬ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬
‫>‪<a name="">… </a‬‬

‫)(‪ blink‬ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬

‫>‪< blink>…</ blink‬‬

‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪bold‬‬

‫>‪< b>…</ b‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪fixed‬‬
‫>‪<tt>…</tt‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)‪Fontcolor(colorValue‬‬
‫>‪<font color="colorValue">…</font‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)‪Fontsize(size‬‬
‫>‪<font size="size">…</font‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪Italics‬‬
‫>‪<i>…</i‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)‪link( url‬‬
‫>‪<a href="url">… </a‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪big‬‬
‫>‪<big>… </big‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪small‬‬
‫>‪<small>… </small‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪strike‬‬
‫> ‪<strick>…</ strick‬‬
‫ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬ ‫)(‪sub‬‬
‫>‪<sub>…</ sub‬‬

‫)(‪ sup‬ﺗﻌﻤﻞ اﻟﺘﺎﻟﻲ‬

‫>‪<sup> … </ sup‬‬

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ إﺳﺘﺨﻼص اﻟﻜﻠﻤﺎت اﻟﺘﺎﻟﯿﺔ "ﻣﺤﻤﺪ" و "ﺻﺤﺒﻪ" و "ﻋﻦ" ﻣﻦ اﻟﻨﺺ اﻟﺘﺎﻟﻲ‬

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

‫‪60‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫اﻷﺣﻤﺮ‬

<HTML dir=rtl>
<Title> ‫< ﺗﻠﻮﯾﻦ اﻟﻨﺺ‬/Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

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

var wordsArray = str.split(" ");

var resultStr = "";
for(var i=0; i< wordsArray.length; i++){
var word = wordsArray[i];

if(word == "‫ || "ﻣﺤﻤﺪ‬word == "‫ || "ﺻﺤﺒﻪ‬word == "‫)" ﻋﻦ‬

resultStr += word.fontcolor("red");
else
resultStr += word;

resultStr += " ";

}

document.write(resultStr);
//-->
</SCRIPT>
</HEAD>
</HTML>

61
‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫‪62‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺨﺎﻣﺲ‬
‫ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﺘﻌﺒﻴﺮﺍﺕ ﺍﻟﻤﻨﺘﻈﻤﺔ‬
‫‪Regular Expressions‬‬

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

‫ﻣﺎ ھﻲ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪Regular Expressions‬‬ ‫•‬

‫ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺔ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ‬ ‫•‬
‫‪ o‬اﻷﻧﻤﺎط ‪patterns‬‬
‫‪ o‬اﻟﻤﺠﻤﻮﻋﺎت ‪Grouping‬‬
‫إﺳﺘﺨﺪام ﻛﺎﺋﻦ اﻟﻨﺼﻮص ﻣﻊ اﻷﻧﻤﺎط‬ ‫•‬
‫ﻛﺎﺋﻦ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪RegExp‬‬ ‫•‬

‫‪63‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺎ ھﻲ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪Regular Expressions‬‬

‫ﻳﻤﻜﻨﻨﺎ اﻟﻘﻮل ﺑﺄن اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ھﻮ أﺳﻠﻮب ﻣﺘﻘﺪم ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ‪ ،‬ﻟﺘﻮﻓﯿﺮ اﻟﻮﻗﺖ واﻟﻤﺠﮫﻮد اﻟﻤﺒﺬول ﻋﻨﺪ‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ﻛﻤﺎ رأﻳﻨﺎ ﺑﺎﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ اﻟﺨﺎص ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ﻣﻦ ﺗﻘﻄﯿﻊ و ﻣﻌﺎﻳﻨﺔ ﻣﻮﻗﻊ ﺟﻤﻠﺔ ﻣﻌﯿﻨﺔ ﺑﻨﺺ‬
‫ﻣﺎ ‪.‬‬

‫وﻟﻤﻦ ﻳﺒﺮﻣﺞ ﺑﻠﻐﺔ ﻣﺜﻞ ﻟﻐﺔ ‪ perl‬اﻟﺒﯿﺮل ‪ ،‬ﻓﻠﻦ ﻳﺠﺪ إﺧﺘﻼف ﻓﻲ ﻃﺮﻳﻘﺔ إﺳﺘﺨﺪام اﻟﺘﻌﺒﯿﺮات اﻟﺨﺎﺻﺔ ﺑﻠﻐﺔ اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ‬
‫ﻋﻤﺎ ﺗﻌﻠﻤﻪ ﺑﻠﻐﺔ اﻟﺒﯿ ﺮل ‪.‬‬

‫ﺗﻮﻓﺮ أﻳﻀﺎ اﻟﺘﻌﺒﯿﺮات اﻟﺨﺎﺻﺔ أﺳﻠﻮب ﻗﻮي ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص ‪ ،‬ﻣﻊ اﻟﻘﺪرة اﻟﻌﺎﻟﯿﺔ ﻟﺘﻘﻄﯿﻊ اﻟﻨﺼﻮص وإﺳﺘﺒﺪال ﻧﺺ ﺑﻨﺺ‬
‫أﺧﺮ وﻛﺜﯿﺮ ﻣﻦ اﻟﻤﮫﺎم اﻷﺧﺮي ‪.‬‬

‫ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺔ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪Regular Expressions‬‬

‫ﻳﻤﻜﻨﻨﺎ ﻛﺘﺎﺑﺔ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ﺑﻨﺎء ﻋﻠﻲ ﻣﺎ ﻳﺴﻤﻲ ﺑﺎﻷﻧﻤﺎط ‪ patterns‬و ﻋﻤﻞ اﻟﻤﺠﻤﻮﻋﺎت ‪ grouping‬وﺳﻮف ﻧﺘﺤﺪث‬
‫ﻋﻦ ﻛﻞ ﻋﻨﺼﺮ ﻋﻠﻲ ﺣﺪي‬

‫اﻷﻧﻤﺎط ‪patterns‬‬

‫ﺗﻨﻘﺴﻢ اﻷﻧﻤﺎط إﻟﻲ ﻧﻮﻋﯿﻦ أﻧﻤﺎط ﺑﺴﯿﻄﺔ و أﺧﺮي ﻣﺮﻛﺒﺔ‬

‫ا ﻷﻧﻤﺎط اﻟﺒﺴﯿﻄﺔ‬

‫أﻣﺜﻠﺔ ﻋﻠﻲ اﻷﻧﻤﺎط اﻟﺒﺴﯿﻄﺔ‬

‫;‪var pattern = / /‬‬

‫ﻓﮫﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ اﻟﺤﺮف "ﻣﺴﺎﻓﺔ" وﻓﯿﻤﺎ ﺑﻌﺪ ﺳﻮف ﻧﺮي ﻛﯿﻔﯿﺔ إﺳﺘﺨﺪام ھﺬا اﻟﻨﻤﻂ ﻹﺟﺮاء ﻋﻤﻠﯿﺎت اﻟﺒﺤﺚ و‬
‫اﻹﺳﺘﺒﺪال‬

‫;‪var pattern = /hello/‬‬

‫ﻓﮫﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ اﻟﻜﻠﻤﺔ "‪"hello‬‬

‫;‪var pattern = /hello patterns/‬‬

‫ﻓﮫﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ اﻟ ﺠﻤﻠﺔ "‪"hello patterns‬‬

‫;‪var pattern = /web/i‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف ‪ i‬اﻟﺬي ﻳﺠﻌﻞ ﻋﻤﻠﯿﺎت اﻟﺒﺤﺚ واﻹﺳﺘﺒﺪال اﻟﻘﺎﺋﻤﺔ ﻋﻠﻲ ھﺬا اﻟﻨﻤﻂ ﻻ ﺗ ﺘﺄﺛﺮ ﺑﺤﺎﻟﺔ اﻟﺤﺮوف ﻛﺒﯿﺮة أم‬
‫ﺻﻐﯿﺮة ‪ ،‬وﺣﺮف ‪ i‬ھﻮ إﺧﺘﺼﺎر ﻟﻲ ‪Case Insensitive‬‬

‫ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ ﻛﻠﻤﺔ "‪ "WEB‬أو "‪ "web‬أو "‪ "Web‬أو "‪ "weB‬وھﻜﺬا ‪.‬‬

‫‪64‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫;‪var pattern = /web/g‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف ‪ g‬اﻟﺬي ﻳﺠﻌﻞ ﻋﻤﻠﯿﺎت اﻟﺒﺤﺚ واﻹﺳﺘﺒﺪال اﻟﻘﺎﺋﻤﺔ ﻋﻠﻲ ھﺬا اﻟﻨﻤﻂ ﺗﺘﻢ ﻋﻠﻲ ﻛﻞ اﻟﻨﺺ وﻻ ﺗﺘﻮﻗﻒ‬
‫ﺑﻤﺠﺮد أن ﻳﺘﻢ ﺗﻮاﻓﻖ اﻟﻨﻤﻂ ﻣﻊ ﺟﺰء ﻣﻦ اﻟﻨﺺ ‪ ،‬وﺣﺮف ‪ g‬ھﻮ إﺧﺘﺼﺎر ﻟﻲ ‪global‬‬

‫ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ ﻛﻠﻤﺔ "‪ "web‬ﻓﻘﻂ وﻟﻜﻦ ﻳﺘﻢ اﻟﺒﺤﺚ ﻋﻨﮫﺎ ﻓﻲ ﻛﻞ اﻟﻨﺺ ﺑﺪون ﺗﻮﻗﻒ ‪.‬‬

‫وﻳﻤﻜﻨﻨﺎ دﻣﺞ اﻟﺮﻣﺰﻳﻦ ‪ i‬و ‪ g‬ﻛﻤﺎ ﻳﻠﻲ‬

‫;‪var pattern = /web/gi‬‬

‫ا ﻷﻧﻤﺎط اﻟ ﻤﺮﻛﺒﺔ‬

‫ﺗﻤﻜﻨﻨﺎ اﻷﻧﻤﺎط اﻟﻤﺮﻛﺒﺔ ﻣﻦ إﺟﺮاء ﺗﻌﺒﯿﺮات أﻛﺜﺮ ﻗﻮة ‪ ،‬وﻣﺜﻞ ﻋﻠﻲ ذﻟﻚ ﺗﻤﻜﻨﻨﺎ اﻷﻧﻤﺎط اﻟﻤﺮﻛﺒﺔ ﻣﻦ ﻋﻤﻞ اﻟﺘﺎﻟﻲ‬

‫إﺳﺘﺨﺪام اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ ﺑﺎﻟﺘﻜﺮار‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫ﺗﻌﺒﺮ ﻋﻦ ﺣﺮف واﺣﺪ‬ ‫‪.‬‬
‫ﺗﻌﺒﺮ ﻋﻦ وﺟﻮد ﺣﺮف واﺣﺪ ﻋﻠﻲ اﻷﻛﺜﺮ ‪ ،‬اي رﺑﻤﺎ ﺗﻌﺒﺮ ﻋﻦ‬ ‫?‬
‫ﻋﺪم وﺟﻮد اي ﺣﺮف‬
‫ﺗﻌﺒﺮ ﻋﻦ وﺟﻮد ﺣﺮف أو أﻛﺜﺮ أو ﻻ ﺷﺊ‬ ‫*‬
‫ﺗﻌﺒﺮ ﻋﻦ وﺟﻮد ﺣﺮف أو أﻛﺜﺮ‬ ‫‪+‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /w.eb/‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف "‪ " .‬داﺧﻞ ﻧﺺ اﻟﻨﻤﻂ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ ﻛﻠﻤﺔ "‪ "waeb‬أو "‪ "Wbeb‬وھﻜﺬا‬
‫وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "web‬ﻷن اﻟﺤﺮف "‪ ".‬ﻳﻌﺒﺮ ﻋﻦ وﺟﻮد ﺣﺮف واﺣﺪ ﺑﺪون ﺗﺤﺪﻳﺪ ﻟﮫﺬا اﻟﺤﺮف‪.‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c.t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬أو "‪ "cut‬وھﻜﺬا وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "ct‬وﻻ ﻋﻦ "‪"category‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /w?eb/‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف "? " داﺧﻞ ﻧﺺ اﻟﻨﻤﻂ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻌﺒﺮ ﻋﻦ ﻛﻠﻤﺔ "‪ "waeb‬أو "‪ "Wbeb‬وھﻜﺬا‬
‫و أﻳﻀﺎ ﻳﻌﺒﺮ ﻋﻦ "‪ "web‬ﻷن اﻟﺤﺮف "?" ﻳﻌﺒﺮ ﻋﻦ وﺟﻮد ﺣﺮف واﺣﺪ ﺑﺪون ﺗﺤﺪﻳﺪ ﻟﮫﺬا اﻟﺤﺮف ورﺑﻤﺎ ﻳﻌﺒﺮ ﻋﻦ ﻻ ﺷﺊ‪.‬‬

‫‪65‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c*t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬و "‪ "cut‬و "‪ "ct‬و "‪ "coot‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪"category‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c*t */‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬و "‪ "cut‬و "‪ "ct‬و "‪ "coot‬و "‪"category‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c+t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬و "‪ "cut‬و "‪ "coot‬و ﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "ct‬أو "‪"category‬‬

‫إﺳﺘﺨﺪام رﻣﻮز اﻟﺒﺪاﻳﺔ واﻟﻨﮫﺎﻳﺔ اﻟﺨﺎﺻﺔ‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫ﺗﻌﺒﺮ ﻋﻦ أن ﻋﻨﺪ إﺟﺮاء ﻋﻤﻠﯿﺔ ﺗﻤﺎﺛﻞ اﻟﻨﺺ ﻣﻊ اﻟﻨﻤﻂ ﻳﺠﺐ‬ ‫^‬
‫أن ﻳﺘﻜﺎﻓﺊ اﻟﻨﻤﻂ ﻣﻊ ﺑﺪاﻳﺔ اﻟﻨﺺ‬
‫ﺗﻌﺒﺮ ﻋﻦ أن ﻋﻨﺪ إﺟﺮاء ﻋﻤﻠﯿﺔ ﺗﻤﺎﺛﻞ اﻟﻨﺺ ﻣﻊ اﻟﻨﻤﻂ ﻳﺠﺐ‬ ‫‪$‬‬
‫أن ﻳﺘﻜﺎﻓﺊ اﻟﻨﻤﻂ ﻣﻊ ﻧﮫﺎﻳﺔ اﻟﻨﺺ‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /^web/‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف "^" ﺑﺎﻟﻨﻤﻂ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "web‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "this is a web‬ﻷﻧﻨﺎ‬
‫أﺷﺘﺮﻃﻨﺎ ﻓﻲ ھﺬا اﻟﻨﻤﻂ أن ﺗﺄﺗﻲ ﻛﻠﻤﺔ ‪ web‬ﻓﻲ أول اﻟﻨﺺ ‪.‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /web$/‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮف "‪ " $‬ﺑﺎﻟﻨﻤﻂ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "web‬أ و "‪ "this is a web‬ﻷﻧﻨﺎ أﺷﺘﺮﻃﻨﺎ ﻓﻲ ھﺬا‬
‫اﻟﻨﻤﻂ أن ﺗﺄﺗﻲ ﻛﻠﻤﺔ ‪ web‬ﻓﻲ أﺧﺮ اﻟﻨﺺ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻻ ﻳﻌﺒﺮ ﻋﻦ "‪. "is web , good‬‬

‫‪66‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /^web$/‬‬

‫ﻻﺣﻆ وﺟﻮد اﻟﺤﺮﻓﯿﻦ "^ " و "‪ "$‬ﺑﺎﻟﻨﻤﻂ ‪ ،‬ﻟﺬﻟﻚ ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "web‬ﻓﻘﻂ ‪.‬‬

‫إﺳﺘﺨﺪام رﻣﻮز اﻟﺘﻜﺮار اﻟﻌﺪدﻳﺔ‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫ﺗﻌﺒﺮ ﻋﻦ أن ﻳﺠﺐ ﺗﻜﺮار اﻟﺤﺮ ف اﻟﺴﺎﺑﻖ ﻟﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات‬ ‫}‪{n‬‬
‫ﻳﺴﺎوي ‪n‬‬
‫ﺗﻌﺒﺮ ﻋﻦ أن ﻳﺠﺐ ﺗﻜﺮار اﻟﺤﺮف اﻟﺴﺎﺑﻖ ﻟﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات‬ ‫}‪{n,m‬‬
‫ﻳﺴﺎوي ﻣﻦ اﻟﻘﯿﻤﺔ ‪ n‬إﻟﻲ اﻟﻘﯿﻤﺔ ‪m‬‬
‫ﺗﻌﺒﺮ ﻋﻦ أن ﻳﺠﺐ ﺗﻜﺮار اﻟﺤﺮف اﻟﺴﺎﺑﻖ ﻟﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات‬ ‫}‪{n,‬‬
‫ﻳﺴﺎوي ﻣﻦ اﻟﻘﯿﻤﺔ ‪ n‬إﻟﻲ ﻣﺎﻻﻧﮫﺎﻳﺔ‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c{2}t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cct‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬وﻻ ﻋﻦ "‪"ct‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c{1,2}t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cct‬أو "‪ "ct‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪"cat‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c{2,}t/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cct‬أو "‪ "ccccct‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬وﻻ ﻋ ﻦ "‪"ct‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /c.t{2}.{2}/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cotton‬أو "‪"cutter‬‬

‫‪67‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻻﺣﻆ اﻟﺤﺎﻻت اﻟﺘﺎﻟﯿﺔ‬

‫اﻟﺤﺎﻟﺔ اﻷوﻟﻲ‬
‫;‪var pattern = / a?/‬‬
‫ﻳﻜﺎﻓﺊ‬
‫;‪var pattern = / a{0,1}/‬‬

‫اﻟﺤﺎﻟﺔ اﻟﺜﺎﻧﯿﺔ‬
‫;‪var pattern = / a./‬‬
‫ﻳﻜﺎﻓﺊ‬
‫;‪var pattern = / a{1}/‬‬

‫اﻟﺤﺎﻟﺔ اﻟﺜﺎﻟﺜﺔ‬
‫;‪var pattern = / a*/‬‬
‫ﻳﻜﺎﻓﺊ‬
‫;‪var pattern = / a{0,}/‬‬

‫اﻟﺤﺎﻟﺔ اﻟﺮاﺑﻌﺔ‬
‫;‪var pattern = / a+/‬‬
‫ﻳﻜﺎﻓﺊ‬
‫;‪var pattern = / a{1,}/‬‬

‫إﺳﺘﺨﺪام رﻣﻮز اﻟﻤﺪي ‪range‬‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫ﺗﻌﺒﺮ ﻋﻦ أﻧﻪ ﻳﺘﻢ اﻟﺒﺤﺚ ﻓﻲ اﻟﻤﺪي اﻟﻤﺤﺪد‬ ‫][‬
‫ﺗﻌﺒﺮ ﻋﻦ أﻧﻪ ﻳﺘﻢ اﻟﺒﺤﺚ ﻓﻲ ﻋﻜﺲ اﻟﻤﺪي اﻟﻤﺤﺪد‬ ‫] ^[‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /[a-z]/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ اي ﺣﺮف ﺻﻐﯿﺮ ‪ small letter‬ﻳﻘﻊ ﺑﯿﻦ اﻟﺤﺮﻓﯿﻦ ‪ a‬و ‪z‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /[a-z]+/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "hello‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪"HELLO‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /[^a-z]+/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "HELLO‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪"hello‬‬

‫‪68‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺑﻌﺾ اﻷﻧﻤﺎط اﻟﻤﻔﯿﺪة‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻳﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺤﺮوف اﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﮫﺎ ﺑﺠﻤﯿﻊ اﻟﺤﺎﻻت )ﺻﻐﯿﺮة أو ﻛﺒﯿﺮة(‬
‫;‪var pattern = /[a-zA-Z]/‬‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻻ ﻳﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺤﺮوف اﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﮫﺎ ﺑﺠﻤﯿﻊ اﻟﺤﺎﻻت )ﺻﻐﯿﺮة أو ﻛﺒﯿﺮة(‬
‫;‪var pattern = /[^a-zA-Z]/‬‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻳﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻷﻋﺪاد ﻣﻦ ﺻﻔﺮ إﻟﻲ ‪٩‬‬

‫;‪var pattern = /[0-9]/‬‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻻ ﻳﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻷﻋﺪاد ﻣﻦ ﺻﻔﺮ إﻟﻲ ‪٩‬‬

‫;‪var pattern = /[^0-9]/‬‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻳﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻷﻋﺪاد ﻣﻦ ﺻﻔﺮ إﻟﻲ ‪ ٩‬وﺟﻤﯿﻊ اﻟﺤﺮوف اﻟﻤﻜﺘﻮﺑﺔ‬
‫;‪var pattern = /[a-zA-Z0-9]/‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /^[0-9]web/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪"2web‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /^[^0-9]web/‬‬

‫ھﺬا اﻟﻨﻤﻂ ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "aweb‬وﻻ ﻳﻌﺒﺮ ﻋﻦ "‪"2web‬‬

‫إﺳﺘﺨﺪام اﻟﺮﻣﻮز اﻟ ﺨﺎﺻﺔ‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫ﺗﻌﺒﺮ ﻋﻦ اﻷرﻗﺎم ﻣﻦ ﺻﻔﺮ إﻟﻲ ‪٩‬‬ ‫‪\d‬‬
‫اي أﻧﮫﺎ ﺗﻜﺎﻓﺊ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ]‪[0-9‬‬
‫ﻻ ﺗﻌﺒﺮ ﻋﻦ اﻷرﻗﺎم ﻣﻦ ﺻﻔﺮ إﻟﻲ ‪٩‬‬ ‫‪\D‬‬
‫اي أﻧﮫﺎ ﺗﻜﺎﻓﺊ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ]‪[^0-9‬‬
‫ﺗﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺮﻣﻮز اﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﮫﺎ ﻛﺎﻷرﻗﺎم ﻣﻦ‬ ‫‪\w‬‬
‫ﺻﻔﺮ إﻟﻲ ‪ ٩‬أو ﻋﻦ اﻟﺤﺮوف ﻣﻦ ‪ a‬إﻟﻲ ‪ z‬أو ﻋﻦ اﻟﺤﺮف _ أو‬
‫ﻣﺎ ﻳﺴﻤﻲ ﺑﺎﻷﻧﺪرﺳﻜﻮر ‪underscore‬‬
‫اي أﻧﮫﺎ ﺗﻜﺎﻓﺊ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ]_‪[a-zA-Z0-9‬‬
‫ﻻ ﺗﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺮﻣﻮز اﻟﺘﻲ ﻳﻤﻜﻦ ﻛﺘﺎﺑﺘﮫﺎ ﻛﺎﻷرﻗﺎم ﻣﻦ‬ ‫‪\W‬‬
‫ﺻﻔﺮ إﻟﻲ ‪ ٩‬أو ﻋﻦ اﻟﺤﺮوف ﻣﻦ ‪ a‬إﻟﻲ ‪ z‬أو ﻋﻦ اﻟﺤﺮف _ أو‬
‫ﻣﺎ ﻳﺴﻤﻲ ﺑﺎﻷﻧﺪرﺳﻜﻮر ‪underscore‬‬
‫‪69‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
‫اي أﻧﮫﺎ ﺗﻜﺎﻓﺊ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ]_‪[^a-zA-Z0-9‬‬
‫ﺗﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ اﻟﺘﻲ ﻳﺼﻌﺐ ﻛﺘﺎﺑﻪ ﺑﻌﻀﮫﺎ‬ ‫‪\s‬‬
‫ﻣﺜﻞ ﺣﺮف اﻟﻤﺴﺎﻓﺔ واﻟﺘﺎب ‪ tab‬واﻟﺴﻄﺮ اﻟﺠﺪﻳﺪ ‪\n‬‬
‫واﻟﺮﻣﻮز اﻟﺘﺎﻟﯿﺔ ‪ \r‬و ‪\f‬‬
‫ﻻ ﺗﻌﺒﺮ ﻋﻦ ﺟﻤﯿﻊ اﻟﺮﻣﻮز اﻟﺨﺎﺻﺔ اﻟﺘﻲ ﻳﺼﻌﺐ ﻛﺘﺎﺑﻪ ﺑﻌﻀﮫﺎ‬ ‫‪\S‬‬
‫ﻣﺜﻞ ﺣﺮف اﻟﻤﺴﺎﻓﺔ واﻟﺘﺎب ‪ tab‬واﻟﺴﻄﺮ اﻟﺠﺪﻳﺪ ‪\n‬‬
‫واﻟﺮﻣﻮز اﻟﺘﺎﻟﯿﺔ ‪ \r‬و ‪\f‬‬
‫ﺗﻌﺒﺮ ﻋﻦ أن اﻟﻨﻤﻂ ﻳﺠﺐ أن ﻳﺘﻮاﺟﺪ ﻓﻲ أول اﻟﻜﻠﻤﺔ ﻓﻘﻂ‬ ‫‪\b‬‬
‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل اﻟﻨﻤﻂ ‪ /\bor/‬ﻳﻌﺒﺮ ﻋﻦ ‪ organ‬وﻻ‬
‫ﻳﻌﺒﺮ ﻋﻦ ‪normal‬‬

‫واﻟﻨﻤﻂ ‪ /or\b/‬ﻳﻌﺒﺮ ﻋﻦ ‪ traitor‬وﻻ ﻳﻌﺒﺮ ﻋﻦ ‪perform‬‬

‫ﻻ ﺗﻌﺒﺮ ﻋﻦ أن اﻟﻨﻤﻂ ﻳﺠﺐ أن ﻳﺘﻮاﺟﺪ ﻓﻲ أول اﻟﻜﻠﻤﺔ ﻓﻘﻂ‬ ‫‪\B‬‬

‫ﻋﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل اﻟﻨﻤﻂ ‪ /\Bor/‬ﻻ ﻳﻌﺒﺮ ﻋﻦ ‪organ‬‬
‫وﻟﻜﻦ ﻳﻌﺒﺮ ﻋﻦ ‪normal‬‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﺮﻣﺰ‬
‫\‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫\\‬
‫‪tab‬‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫‪\t‬‬
‫‪.‬‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫‪\.‬‬
‫?‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫?\‬
‫‪+‬‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫‪\+‬‬
‫*‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫*\‬
‫^‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫^\‬
‫‪$‬‬ ‫اﻟﺤﺮف‬ ‫ﺗﻌﺒﺮ ﻋﻦ‬ ‫‪\$‬‬

‫اﻟﻤﺠﻤﻮﻋﺎت ‪Grouping‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺠﻤﯿﻊ ﻧﻮاﺗﺞ اﻟﺒﺤﺚ ﻓﻲ ﻣﺠﻤﻮﻋﺎت ﻳﺘﻢ ﺗﺨﺰﻳﻨﮫﺎ ﻓﻲ ﻣﺼﻔﻮﻓﺔ أو ﻓﻲ ﻣﺘﻐﯿﺮات ﺗﺒﺪأ ﺑﺎﻟﺮﻣﺰ ‪ $‬ﻛﺎﻟﻤﺘﻐﯿﺮ ‪ $1‬و ‪$2‬‬
‫وﻟﻌﻤﻞ ﻣﺠﻤﻮﻋﺎت ﻳﺘﻢ إﺳﺘﺨﺪام اﻟﺮﻣﺰ اﻷﻗﻮاس اﻟﺘﺎﻟﯿﺔ )( أو اﻟﻌﻼﻣﺔ اﻟﺘﺎﻟﯿﺔ | ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /^([0-9])(web)/‬‬

‫ﺳﻮف ﻳﺘﻢ وﺿﻊ ﻧﺘﺎﺋﺞ اﻟﺒﺤﺚ ﻋﻠﻲ ھﺬا اﻟﻨﻤﻂ ﻓﻲ ﻣﺠﻤﻮﻋﺎت أﺣﺪھﻤﺎ ﻟﻠﻨﻤﻂ ]‪ [0-9‬واﻷﺧﺮي ﻟﻠﻨﻤﻂ ‪web‬‬

‫ﻣﺜﺎل‬

‫;‪var pattern = /web|cat/‬‬

‫ﺳﻮف ﻳﺘﻢ وﺿﻊ ﻧﺘﺎﺋﺞ اﻟﺒﺤﺚ ﻋﻠﻲ ھﺬا اﻟﻨﻤﻂ ﻓﻲ ﻣﺠﻤﻮﻋﺎت أﺣﺪھﻤﺎ ﻟﻠﻨﻤﻂ ‪ cat‬واﻷﺧﺮي ﻟﻠﻨﻤﻂ ‪ ، web‬وھﺬا اﻟﻨﻤﻂ‬
‫ﻳﻤﻜﻦ أن ﻳﻌﺒﺮ ﻋﻦ "‪ "cat‬أو "‪"web‬‬

‫‪70‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫إﺳﺘﺨﺪام ﻛﺎﺋﻦ اﻟﻨﺼﻮص ﻣﻊ اﻷﻧﻤﺎط‬

‫ﺑﻌﺪﻣﺎ ﺗﻌﻠﻤﻨﺎ ﻃﺮﻳﻘﺔ ﻛﺘﺎﺑﺔ اﻷﻧﻤﺎط ‪ ،‬ﺣﺎن اﻟﻮﻗﺖ ﻟﻤﻌﺮﻓﺔ ﻃﺮﻳﻘﺔ ﺗﻄﺒﯿﻘﮫﺎ‬
‫ﻟﺬﻟﻚ ﺳﻮف ﻧﻌﺘﻤﺪ ﻋﻠﻲ ﺑﻌﺾ دوال اﻟﻜﺎﺋﻦ اﻟﻨﺼﻲ ﻟﺘﻄﺒﯿﻖ اﻷﻧﻤﺎط وھﻲ ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺪاﻟﺔ ‪match‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺒﺤﺚ ﻋﻦ ﻧﻤﻂ ﻣﻌﯿﻦ ﺑﺪاﺧﻞ اﻟﻨﺺ ‪ ،‬ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع ﻣﺼﻔﻮﻓﺔ ﺑﮫﺎ ﻧﻮاﺗﺞ اﻟﺒﺤﺚ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻣﺼﻔﻮﻓﺔ‬

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

‫(‪String.match‬‬ ‫اﻟﻨﻤﻂ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var str = new String‬‬

‫;"‪str = "hello mr hello‬‬

‫;)(‪var arrResult = new Array‬‬

‫;‪var pattern = /hello/‬‬

‫;) ‪arrResult = str.match( pattern‬‬

‫اﻟﺘﻮاﺟﺪ" (‪alert‬‬ ‫ﻋﺪد ﻣﺮات‬ ‫;) ‪: " + arrResult.length‬‬

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

‫ﻣﻊ أﻧﺎ اﻟﻨﺺ ﻳﺤﺘﻮي ﻋﻠﻲ ﻛﻠﻤﺔ ‪ hello‬ﻣﺮﺗﯿﻦ ﻟﻜﻦ ﻧﺎﺗﺞ اﻟﺒﺤﺚ ﻛﺎن ﻣﺮة واﺣﺪة ‪ ،‬وھﺬا ﺻﺤﯿﺢ ﻷن اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم‬
‫ﻳﺘﻮﻗﻒ ﺑﻌﺪ ﺣﺪوث ﺗﻤﺎﺛﻞ ﻟﻪ ﻣﻊ اﻟﻨﺺ اﻟﺬي ﻳﺘﻢ اﻟﺒﺤﺚ ﻓﯿﻪ ‪ ،‬ﻟﺬﻟﻚ ﻹﺟﺮاء اﻟﺒﺤﺚ ﻋﻠﻲ ﺟﻤﯿﻊ اﻟﻨﺺ ﻳﺘﻢ إﺳﺘﺒﺪال اﻟﻨﻤﻂ‬
‫اﻟﺴﺎﺑﻖ ﺑﺎﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ﻛﻤﺎ ﻳﻠﻲ‬

‫‪71‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

var str = new String();

str = "hello mr hello";

var arrResult = new Array();

var pattern = /hello/g;

arrResult = str.match( pattern );

alert( "‫اﻟﺘﻮاﺟﺪ‬ ‫ﻋﺪد ﻣﺮات‬ : " + arrResult.length );

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

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ اﻟﺘﺄﻛﺪ ﻣﻦ ﺻﺤﺔ اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ اﻟﺬي ﻳﺘﻢ إﺳﺘﻘﺒﺎﻟﻪ ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬

<HTML dir=rtl>
<Title> ‫اﻹﻟﯿﻜﺘﺮوﻧﻲ‬ ‫اﻟﺒﺮﯾﺪ‬ </Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

var EmailstrFromUser;
EmailstrFromUser = prompt("‫اﻷﻟﯿﻜﺘﺮوﻧﻲ‬ ‫"ادﺧﻞ ﺑﺮﯾﺪك‬,"");

var emailPattern = /^[a-zA-Z]{1}\w+@[a-zA-Z]{1}\w+\.\w{2,3}/;

var arrResult = EmailstrFromUser.match(emailPattern);

if( arrResult != null )

alert("‫ﺻﺤﯿﺢ‬ ‫;)" ﻫﺬا اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ‬
else
alert("‫ﺻ ﺤﯿﺢ‬ ‫;)" ﻫﺬا اﻟﺒﺮﯾﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﻏﯿﺮ‬
//-->
</SCRIPT>
</HEAD>
</HTML>
72
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺗﻤﺮﻳﻦ‬

‫ﻧﺮﻳﺪ إﺳﺘﺨﻼص اﺳﻢ اﻟﻤﺴﺘﺨﺪم واﺳﻢ ﻣﺰود ﺧﺪﻣﺔ اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ ﻟﻘﯿﻤﺔ ﺑﺮﻳﺪ إﻟﯿﻜﺘﺮوﻧﻲ ﻳﺘﻢ إﺳﺘﻘﺒﺎﻟﻪ ﻣﻦ‬
‫اﻟﻤﺴﺘﺨﺪم‬

‫ﻣﻊ اﻟﻌﻠﻢ أن اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻳﺴﺒﻖ ﻣﻮﻗﻊ اﻟﺮﻣﺰ @ و اﺳﻢ ﻣﺰود اﻟﺨﺪﻣﺔ ﻳﻠﻲ اﻟﺮﻣﺰ @ ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‬
‫إذا ﻛﺎن اﻟﺒﺮﻳﺪ اﻹﻟﯿﻜﺘﺮوﻧﻲ اﻟﻤﺪﺧﻞ ھﻮ ‪a_elhussein@hotmail.com‬‬
‫ﻳﻜﻮن اﺳﻢ اﻟﻤﺴﺘﺨﺪم ‪a_elhussein‬‬
‫وﻳﻜﻮن اﺳﻢ اﻟﻤﺰود ‪hotmail‬‬

‫ﻻﺣﻆ أن اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم ھﻮ ﻧﻔﺲ اﻟﻨﻤﻂ اﻟﺴﺎﺑﻖ ﻣﻊ إﺿﺎﻓﺔ اﻟﻤﺠﻤﻮﻋﺎت ﺑﺈﺳﺘﺨﺪام اﻷﻗﻮاس ‪.‬‬

‫>‪<HTML dir=rtl‬‬
‫اﻹﻟﯿﻜﺘﺮوﻧﻲ >‪<Title‬‬ ‫اﻟﺒﺮﯾﺪ‬ ‫>‪</Title‬‬
‫>‪<HEAD‬‬
‫>"‪<SCRIPT LANGUAGE="JavaScript‬‬
‫‪<!--‬‬

‫;‪var EmailstrFromUser‬‬
‫اﻷﻟﯿﻜﺘﺮوﻧﻲ"(‪EmailstrFromUser = prompt‬‬ ‫;)""‪",‬ادﺧﻞ ﺑﺮﯾﺪك‬

‫;‪var emailPattern = /^([a-zA-Z]{1}\w+)@([a-zA-Z]{1}\w+)\.(\w{2,3})/‬‬

‫;)‪var arrResult = EmailstrFromUser.match(emailPattern‬‬
‫{) ‪if( arrResult != null‬‬
‫" (‪alert‬‬ ‫"اﺳﻢ اﻟﻤﺴﺘﺨﺪم ‪:‬‬ ‫‪+ arrResult[1] + "\r\n" +‬‬
‫"‬ ‫‪" +‬اﺳﻢ اﻟﻤﺰود ‪:‬‬ ‫;) ]‪arrResult[2‬‬

‫}‬
‫‪else‬‬
‫ﺻﺤﯿﺢ"(‪alert‬‬ ‫;)" ﻫﺬا اﻟﺒﺮﯾﺪ اﻟﻺﻟﯿﻜﺘﺮوﻧﻲ ﻏﯿﺮ‬
‫>‪//--‬‬
‫>‪</SCRIPT‬‬
‫>‪</HEAD‬‬
‫>‪</HTML‬‬

‫اﻟﺪاﻟﺔ ‪replace‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺒﺤﺚ ﻋﻦ ﻧﻤﻂ ﻣﻌﯿﻦ ﺑﺪاﺧﻞ اﻟﻨﺺ ﺛﻢ ﺗﻘﻮم ﺑﺈﺳﺘﺒﺪاﻟﻪ ﺑﻨﺺ أﺧﺮ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع اﻟﻨﺺ اﻟﺠﺪﻳﺪ‬

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

‫( ‪String.replace‬‬ ‫ﻧﻤﻂ اﻟﺒﺤﺚ‬ ‫‪,‬‬ ‫ﻧﺺ اﻹﺳﺘﺒﺪال‬ ‫;)‬

‫‪73‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)(‪var str = new String‬‬

‫;"‪str = "hello mr hello‬‬

‫;‪var pattern = /hello/g‬‬

‫;) "‪var newStr = str.replace( pattern, "me‬‬

‫" (‪alert‬‬ ‫اﻟﻨﺺ اﻟﺠﺪﯾﺪ ‪:‬‬ ‫;) ‪: " + newStr‬‬

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

‫اﻟﺪاﻟﺔ ‪search‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺒﺤﺚ ﻋﻦ ﻧﻤﻂ ﻣﻌﯿﻦ ﺑﺪاﺧﻞ اﻟﻨﺺ ﺛﻢ ﺗﻘﻮم ﺑﺈرﺟﺎع ﻣﻜﺎن ﺗﻮاﺟﺪة ﻣﺜﻞ اﻟﺪاﻟﺔ ‪ indexOf‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﻜﺎﺋﻦ اﻟﻨﺼﻲ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻣﻮﻗﻊ اﻟﻨﺺ ﻋﻠﻲ ھﯿﺌﺔ ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

‫اﻟﺼﯿﻐﺔ اﻟﻌﺎﻣﺔ‬
‫(‪String.search‬‬ ‫ﻧﻤﻂ اﻟﺒﺤﺚ‬ ‫;)‬

‫ﻣﺜﺎل‬
‫;)(‪var str = new String‬‬
‫;"‪str = "hello mr hello‬‬

‫;‪var pattern = /mr/‬‬

‫;) ‪var index = str.search( pattern‬‬

‫" (‪alert‬‬ ‫ﻣﻮﻗﻊ ﺟﻤﻠﺔ‬ ‫;) ‪mr : " + index‬‬

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

‫‪74‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﺎﺋﻦ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪RegExp‬‬

‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ‪RegExp‬‬

‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎﺋﻪ ﻛﻤﺎ ﻳﻠﻲ‬

‫;)(‪var regexpObject = new RegExp‬‬

‫ﺧﺼﺎﺋﺺ اﻟﻜﺎﺋﻦ ‪RegExp‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪constructor‬‬

‫ﺳﻮف ﻧﺘﺤﺪث ﻋﻦ اﻟﺨﺎﺻﯿﺔ ‪ constructor‬ﺑﺎﻟﺠﺰء اﻟﺜﺎﻟﺚ ﻣﻦ ھﺬا اﻟﻜﺘﺎب ‪ ،‬ﻋﻨﺪ اﻟﺤﺪﻳﺚ ﻋﻦ اﻟﻜﺎﺋﻨﺎت واﻟﺒﺮﻣﺠﺔ اﻟﻜﺎﺋﻨﯿﺔ‬

‫اﻟﺨﺎﺻﯿﺔ ‪global‬‬

‫ھﺬه اﻟﺨﺎﺻﯿﺔ ﻟﻠﻘﺮأة ﻓﻘﻂ ‪ ، read only‬وﺗﻌﺒﺮ ھﻞ اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم ﺗﻢ إﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪ g‬ﺑﻪ‬
‫ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ‪ /hello/g‬ﺗﻜﻮن اﻟﺨﺎﺻﯿﺔ ‪ global‬ﺗﺴﺎوي ‪true‬‬

‫أﻣﺎ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ‪ /hello/‬ﺗﻜﻮن اﻟﺨﺎﺻﯿﺔ ‪ global‬ﺗﺴﺎوي ‪false‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪ignoreCase‬‬

‫ھﺬه اﻟﺨﺎﺻﯿﺔ ﻟﻠﻘﺮأة ﻓﻘﻂ ‪ ، read only‬وﺗﻌﺒﺮ ھﻞ اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم ﺗﻢ إﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪ i‬ﺑﻪ‬
‫ﻓﻌﻠﻲ ﺳﺒﯿﻞ اﻟﻤﺜﺎل‬

‫اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ‪ /hello/i‬ﺗﻜﻮن اﻟﺨﺎﺻﯿﺔ ‪ ignoreCase‬ﺗﺴﺎوي ‪true‬‬

‫أﻣﺎ اﻟﻨﻤﻂ اﻟﺘﺎﻟﻲ ‪ /hello/‬ﺗﻜﻮن اﻟﺨﺎﺻﯿﺔ ‪ ignoreCase‬ﺗﺴﺎوي ‪false‬‬

‫اﻟﺨﺎﺻﯿﺔ ‪multiline‬‬

‫ھﺬه اﻟﺨﺎﺻﯿﺔ ﻟﻠﻘﺮأة ﻓﻘﻂ ‪ ، read only‬وﺗﻌﺒﺮ ھﻞ اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم ﺳﻮف ﻻ ﻳﺘﺠﺎھﻞ اﻟﺴﻄﻮر اﻟﻌﺪﻳﺪة ﺑﻪ‬

‫اﻟﺨﺎﺻﯿﺔ ‪source‬‬

‫ھﺬه اﻟﺨﺎﺻﯿﺔ ﻟﻠﻘﺮأة ﻓﻘﻂ ‪ ، read only‬وﺗﻌﺒﺮ ﻋﻦ ﺻﯿﻐﺔ اﻟﻨﻤﻂ اﻟﻤﺴﺘﺨﺪم ﺑﺎﻟﻜﺎﺋﻦ ‪. RegExp‬‬

‫‪75‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫دوال اﻟﻜﺎﺋﻦ ‪RegExp‬‬

‫اﻟﺪاﻟﺔ ‪compile‬‬

‫ﺗﻤﻜﻨﻨﺎ ﻣﻦ إﻧﺸﺎء ﻛﺎﺋﻦ ﻟﻠﺘﻌﺒﯿﺮات اﻟﻤﻨﺘﻈﻤﺔ ﺑﻪ ﻧﻤﻂ ﻣﻌﯿﻦ‬

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

‫(‪RegExp.compile‬‬ ‫اﻟﻨﻤﻂ‬ ‫;)‬

‫أو‬

‫(‪RegExp.compile‬‬ ‫اﻟﻨﻤﻂ‬ ‫;)]"‪, ["g" | "i" | "m‬‬

‫ﻳﺤﺪد اﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ﻃﺮﻳﻘﺔ اﻟﺒﺤﺚ ﺑﺈﺳﺘﺨﺪام اﻟﻨﻤﻂ‬

‫وھﻨﺎ ﺳﻮف ﻧﺸﯿﺮ إﻟﻲ اﻟﺮﻣﺰ ‪ m‬وھﻲ ﻳﻌﺒﺮ ﻋﻦ اﻟﺒﺤﺚ ﻓﻲ ﺟﻤﯿﻊ اﻟﺴﻄﻮر ‪multiline‬‬

‫ﻣﺜﺎل‬

‫;)(‪var regexpObject = new RegExp‬‬

‫;)"‪var regexpObject2 = regexpObject.compile("/me/‬‬

‫;)"‪var regexpObject2 = regexpObject.compile("/me/", "i‬‬

‫اﻟﺪاﻟﺔ ‪test‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻠﺘﺄﻛﺪ ﻣﻦ ﺗﻮاﻓﻖ اﻟﻨﻤﻂ ﻣﻊ اﻟﻨﺺ اﻟﻤﻤﺮر ﻟﮫﺎ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﻓﻲ ﺣﺎﻟﺔ ﺗﻮاﻓﻖ اﻟﻨﻤﻂ ﻣﻊ اﻟﻨﺺ ﺗﺮﺟﻊ اﻟﺪاﻟﺔ اﻟﻘﯿﻤﺔ ‪ true‬وﻓﻲ ﺣﺎﻟﺔ ﻋﺪم اﻟﺘﻮاﻓﻖ ﺗﺮﺟﻊ ‪false‬‬

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

‫(‪RegExp.test‬‬ ‫اﻟﻨﺺ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;‪var RegExp = /me/‬‬

‫;) )"‪alert( regExp.test("hello me hello‬‬

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

‫‪76‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪exec‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﻨﻔﯿﺬ اﻟﻨﻤﻂ ﻋﻠﻲ اﻟﻨﺺ اﻟﻤﻤﺮر ﻟﮫﺎ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﻣﺼﻔﻮﻓﺔ ﻣﻦ ﻛﺎﺋﻨﺎت ﻣﻦ اﻟﻨﻮع ‪Match‬‬

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

‫(‪RegExp.exec‬‬ ‫اﻟﻨﺺ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;‪var RegExp = /me/‬‬

‫;)"‪var matchArray = RegExp.exec("hello me hello‬‬

‫) ‪if( matchArray == null‬‬

‫"(‪alert‬‬ ‫ﻟﻢ ﯾﺘﻢ اﻟﻌﺜﻮر ﻋﻠﻲ ﺟﻤﻠﺔ‬ ‫;)"‪me‬‬
‫‪else‬‬
‫" (‪alert‬‬ ‫"ﺗﻢ اﻟﻌﺜﻮر ﻋﻠﻲ ﺟﻤﻠﺔ ‪:‬‬ ‫;) ]‪+ matchArray[0‬‬

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

‫‪77‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﺍﻟﻔﺼﻞ ﺍﻟﺴﺎﺩﺱ‬
‫ﺍﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺍﻟﺘﺎﺭﻳﺦ‬

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

‫اﻟﻜﺎﺋﻦ ‪Date‬‬ ‫•‬
‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ‬ ‫•‬
‫دوال ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ‬ ‫•‬

‫‪78‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ ‪Date Object‬‬

‫اﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ ﻟﯿﺲ ﺑﮫﺎ ﻧﻮع ﺑﯿﺎﻧﺎت أوﻟﻲ ﻟﻠﺘﺎرﻳﺦ ‪ ،‬ﻟﻜﻨﻚ ﺗﺴﺘﻄﯿﻊ أن ﺗﺴﺘﺨﺪم ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ ودواﻟﺔ أو وﻇﺎﺋﻔﻪ ﻟﻠﺘﻌﺎﻣﻞ‬
‫ﻣﻊ اﻟﺘﺎرﻳﺦ واﻟﻮﻗﺖ ﻓﻲ ﺗﻄﺒﯿﻘﺎﺗﻚ‬

‫ﻳﺘﻢ ﺗﺨﺰﻳﻦ اﻟﺘﺎرﻳﺦ ﺑﺎﻟﻤﻠﻲ ﺳﻜﻨﺪ ‪ milliseconds‬ﻣﻨﺬ ﺗﺎرﻳﺦ ‪ ١‬ﻳﻨﺎﻳﺮ ‪١٩٧٠‬‬

‫ﻻﺣﻆ أن ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ ﻟﯿﺲ ﺑﻪ أي ﺧﺼﺎﺋﺺ‬

‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ‬

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

‫;)(‪var dateObject = new Date‬‬

‫أو‬

‫(‪var dateObject = new Date‬‬ ‫ﺗﺎرﯾﺦ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) ‪alert( dateObject‬‬

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

‫وﻳﻤﻜﻨﻨﺎ ﺗﺤﺪﻳﺪ اﻟﺘﺎرﻳﺦ ﻛﻤﺎ ﻳﻠﻲ‬

‫ﻣﺜﺎل‬

‫;)"‪var dateObject = new Date("6/15/2004‬‬

‫;) ‪alert( dateObject‬‬

‫‪79‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

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

‫دوال ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ‬

‫ﺗﻨﻘﺴﻢ دوال ﻛﺎﺋﻦ اﻟﺘﺎرﻳﺦ إﻟﻲ ﺛﻼث أﻗﺴﺎم أﺣﺪھﻤﺎ دوال ﻹرﺟﺎع اﻟﻘﯿﻢ ﻣﻦ اﻟﺘﺎرﻳﺦ واﻷﺧﺮي ﻟﻮﺿﻊ ﻗﯿﻢ ﺑﺎﻟﺘﺎرﻳﺦ‬
‫واﻷﺧﺮي ﻟﺘﺤﻮﻳﻞ اﻟﺘﺎرﻳﺦ ﻛﻤﺎ ﻳﻠﻲ‬

‫اﻟﺪاﻟﺔ ‪getDate‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع اﻷﻳﺎم اﻟﻤﻮﺟﻮدة ﺑﺎﻟﺘﺎرﻳﺦ ﻣﻦ ‪ ١‬إﻟﻲ ‪٣١‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getDate‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getDate‬‬

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

‫‪80‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪getDay‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع رﻗﻢ ﻳﻮم اﻷﺳﺒﻮع اﻟﻤﻮﺟﻮد ﺑﺎﻟﺘﺎرﻳﺦ وﺗﻜﻮن ﻣﻤﺜﻠﺔ ﻷﻳﺎم اﻷﺳﺒﻮع ﻣﻦ ‪ ٠‬إﻟﻲ ‪ ، ٦‬ﺣﯿﺚ ﺻﻔﺮ ﻳﻌﺒﺮ ﻋﻦ ﻳﻮم‬
‫اﻷﺣﺪ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getDay‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getDay‬‬

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

‫واﻟﺮﻗﻢ ‪ ٣‬ﻳﻌﺒﺮ ﻋﻦ ﻳﻮم اﻷرﺑﻌﺎء‬

‫اﻟﺪاﻟﺔ ‪getMonth‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع رﻗﻢ اﻷﺷﮫﺮ ﻣﻦ ‪ ٠‬إﻟﻲ ‪ ، ١١‬ﺣﯿﺚ ﻳﻌﺒﺮ اﻟﺮﻗﻢ ﺻﻔﺮ ﻋﻦ ﺷﮫﺮ ﻳﻨﺎﻳﺮ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getMonth‬‬

‫‪81‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getMonth‬‬

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

‫واﻟﺮﻗﻢ ‪ ٥‬ﻳﻌﺒﺮ ﻋﻦ ﺷﮫﺮ ﻳﻮﻧﯿﻮ‬

‫اﻟﺪاﻟﺔ ‪getYear‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع اﻟﺴﻨﺔ‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getYear‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getYear‬‬

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

‫‪82‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪getHours‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع ﻗﯿﻤﺔ ﻋﺪد اﻟﺴﺎﻋﺎت ﻣﻦ ‪ ٠‬إﻟﻲ ‪٢٣‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getHours‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getHours‬‬

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

‫واﻟﺴﺎﻋﺔ ‪ ١٦‬ﺗﻌﺎدل اﻟﺴﺎﻋﺔ اﻟﺮاﻋﺔ ﺻﺒﺎﺣﺎ‬

‫اﻟﺪاﻟﺔ ‪getMinutes‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع ﻗﯿﻤﺔ ﻋﺪد اﻟﺪﻗﺎﺋﻖ ﻣﻦ ‪ ٠‬إﻟﻲ ‪٥٩‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getMinutes‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getMinutes‬‬

‫‪83‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪getSeconds‬‬

‫ﺗﺴﺘﺨﺪم ﻹرﺟﺎع ﻗﯿﻤﺔ ﻋﺪد اﻟﺪﻗﺎﺋﻖ ﻣﻦ ‪ ٠‬إﻟﻲ ‪٥٩‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getSeconds‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getSeconds‬‬

‫اﻟﺪاﻟﺔ ‪getTime‬‬

‫ﺗﺴﺘﺨﺪم ﺑﺤﺴﺎب اﻟﺘﺎرﻳﺦ ﺑﺎﻟﻤﻠﻲ ﺳﻜﻨﺪ اﻟﺬي ﻣﺮ ﻋﻠﻲ ھﺬا اﻟﺘﺎرﻳﺦ ﻣﻨﺬ ﺗﺎرﻳﺦ ﻣﻨﺘﺼﻒ ﻟﯿﻞ ﻳﻮم ‪ ١‬ﻳﻨﺎﻳﺮ ‪١٩٧٠‬‬

‫اﻟﻘﯿﻤﺔ اﻟﺮاﺟﻌﺔ ‪ :‬ﺗﻘﻮم ﺑﺈرﺟﺎع ﻗﯿﻤﺔ ﻋﺪدﻳﺔ‬

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

‫;)(‪Date.getTime‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.getTime‬‬

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

‫‪84‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪setDate‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻮﺿﻊ ﻋﺪد اﻷﻳﺎم ﺑﺎﻟﺘﺎرﻳﺦ وﺗﻜﻮن اﻟﻘﯿﻤﺔ اﻟﻤﻀﺎﻓﺔ ﻣﻦ ‪ ١‬إﻟﻲ ‪٣١‬‬

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

‫(‪Date.setDate‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setDate("2‬‬

‫اﻟﺪاﻟﺔ ‪setMonth‬‬

‫ﺗﺴﺘﺨﺪم ﻟﻮﺿﻌﻌﺪد اﻟﺸﮫﻮر ﺑﺎﻟﺘﺎرﻳﺦ وﺗﻜﻮن اﻟﻘﯿﻤﺔ اﻟﻤﻀﺎﻓﺔ ﻣﻦ ‪ ٠‬إﻟﻲ ‪١١‬‬

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

‫(‪Date.setMonth‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setMonth("2‬‬

‫اﻟﺪاﻟﺔ ‪setYear‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﺪﻳﺪ ﻗﯿﻤﺔ اﻟﺴﻨﻮات ﺑﺎﻟﺘﺎرﻳﺦ‬

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

‫(‪Date.setYear‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setYear("2006‬‬

‫‪85‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﺪاﻟﺔ ‪setHours‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﺪﻳﺪ ﻗﯿﻤﺔ اﻟﺴﺎﻋﺎت ﺑﺎﻟﺘﺎرﻳﺦ‬

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

‫(‪Date.setHours‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setHours("2‬‬

‫اﻟﺪاﻟﺔ ‪setMinutes‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﺪﻳﺪ ﻗﯿﻤﺔ اﻟﺪﻗﺎﺋﻖ ﺑﺎﻟﺘﺎرﻳﺦ‬

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

‫(‪Date.setMinutes‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setMinutes("20‬‬

‫اﻟﺪاﻟﺔ ‪setSeconds‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﺪﻳﺪ ﻗﯿﻤﺔ اﻟﺜﻮاﻧﻲ ﺑﺎﻟﺘﺎرﻳﺦ‬

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

‫(‪Date.setSeconds‬‬ ‫اﻟﻘﯿﻤﺔ‬ ‫;)‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;)"‪dateObject.setSeconds("2‬‬

‫اﻟﺪاﻟﺔ ‪toGMTString‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ اﻟﺘﺎرﻳﺦ إﻟﻲ ﻣﺎ ﻳﻌﺎدﻟﺔ ﺑﺘﻮﻗﯿﺖ ﺟﺮﻳﻨﺘﺶ‬

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

‫;)(‪Date.toGMTString‬‬
‫‪86‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.toGMTString‬‬

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

‫اﻟﺪاﻟﺔ ‪toLocaleString‬‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ اﻟﺘﺎرﻳﺦ إﻟﻲ ﻣﺎ ﻧﺺ ﻋﻠﻲ ﺣﺴﺐ ﻧﻈﺎم اﻟﺘﺸﻐﯿﻞ اﻟﺬي ﻳﻌﻤﻞ ﺑﻪ اﻟﺠﮫﺎز‬

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

‫;)(‪Date.toLocaleString‬‬

‫ﻣﺜﺎل‬

‫;)(‪var dateObject = new Date‬‬

‫;) )(‪alert( dateObject.toLocaleString‬‬

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

‫‪87‬‬
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

parse ‫اﻟﺪاﻟﺔ‬

‫ﺗﺴﺘﺨﺪم ﻟﺘﺤﻮﻳﻞ اﻟﻘﯿﻤﺔ اﻟﻨﺼﯿﺔ إﻟﻲ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع ﺗﺎرﻳﺦ‬

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

Date.parse( "‫اﻟﺘﺎرﯾﺦ‬ ‫"ﻧﺺ‬ );

‫ﻣﺜﺎل‬

var dateObject = new Date( Date.parse("Wed Jun 16 17:31:01 PDT 2004") );

alert( dateObject.getYear() );

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

‫ﺗﻤﺮﻳﻦ‬

<HTML dir=rtl>
<Title> ‫< اﻟﺘﺎرﯾﺦ‬/Title>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">
<!--

var today = new Date();

var monthName = new Array(11);

monthName[0] = "‫;"ﯾﻨﺎﯾﺮ‬
monthName[1] = "‫;" ﻓﺒﺮاﯾﺮ‬
monthName[2] = "‫;"ﻣﺎرس‬
monthName[3] = "‫;"اﺑﺮﯾﻞ‬
monthName[4] = "‫;"ﻣﺎﯾﻮ‬
monthName[5] = "‫;"ﯾﻮﻧﯿﻮ‬
monthName[6] = "‫;"ﯾﻮﻟﯿﻮ‬
monthName[7] = "‫;"اﻏﺴﻄﺲ‬
88
 ‫اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﺠﺎﻓﺎ ﺳﻜﺮﺑﺖ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬
monthName[8] = "‫;" ﺳﺒﺘﻤﺒﺮ‬
monthName[9] = "‫;"اﻛﺘﻮﺑﺮ‬
monthName[10] = "‫;"ﻧﻮﻓﻤﺒﺮ‬
monthName[11] = "‫;"دﯾﺴﻤﺒﺮ‬

var myYear = today.getYear();

if( myYear < 2000 )
myYear += 1900;

var myDate = today.getDate();

var dayExt = "th";

if( myDate == 1 || myDate == 21 || myDate == 31)

dayExt = "st";
else if( myDate == 2 || myDate == 22)
dayExt = "nd";
else if( myDate == 3 || myDate == 23 )
dayExt = "rd";

var extDate = myDate + dayExt;

document.write( extDate + " ‫ﯾﻮم‬ " );
document.write( monthName[today.getMonth()] + " ‫ﻓﻲ ﺳﻨﺔ‬ " );
document.write( myYear + "." );
//-->
</SCRIPT>
</HEAD></HTML>

89