‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬

‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻣﺎﲢﺘﺎﺟﺔ ﻟﺒﺮﻣﺠﺔ اﳌﺎﻛﻨﺘﻮش‬

‫ﺑﻠﻐﺔ ‪Objective-C‬‬
‫‪Bert Altenburg, Alex Clarke , Philippe Mougin‬‬ ‫ﻛﺘﺎب ﻣﻦ ﺗﺄﻟﻴﻒ‬

‫ﺗﺮﺟﻤﺔ ‪ :‬ﻣﺎزن اﻟﺮﻣﺎل‬
‫ﻫﻞ اﺣﺒﺒﺖ ﻳﻮﻣ َﺎ ﻣﻌﺮﻓﺔ ﻛﻴﻔﻴﺔ ﻋﻤﻞ اﻻﻣﻮر‪،‬‬
‫ﻫﻞ اﻧﺖ ﳑﻦ ﻳﺘﺎﺑﻊ ﺟﺪﻳﺪ اﻟﻌﻠﻮم واﳌﺨﺘﺮﻋﺎت‪،‬‬
‫و ﻫﻞ اﻧﺖ ﻣﻦ ﻣﺤﺒﻲ اﻟﺒﺮﻣﺠﺔ واﻟﺘﺤﺪى؟‬
‫ﺑﲔ ﻳﺪﻳﻚ ﻛﺘﺎب ﻗﻴﻢ‪ ،‬ﻛﻤﻘﺪﻣﺔ ﳊﻘﻞ‬
‫ﻣﺸﻮق وﺟﺪت ﻓﻴﻪ ﻣﺎ ﻳﻔﻴﺪﻧﻲ‪ ،‬واﺣﺒﺒﺖ‬
‫ﻣﺸﺎرﻛﺘﻜﻢ ﺑﻪ‪ ،‬ارﺟﻮ اﻻ ﺗﺒﺨﻠﻮا ﻋﻠﻰ‬
‫ﲟﺮﺋﻴﺎﺗﻜﻢ وﻣﻼﺣﻈﺎﺗﻜﻢ ﻋﻠﻰ اﻟﺒﺮﻳﺪ‬
‫‪maxenco@mac.com‬‬
‫ﻣﺎﲢﺘﺎﺟﺔ ﻟﺒﺮﻣﺠﺔ اﳌﺎﻛﻨﺘﻮش‬
‫ﺑﻠﻐﺔ ‪Objective-C‬‬
‫ﻛﺘﺎب ﻣﻦ ﺗﺄﻟﻴﻒ‬
‫‪Bert Altenburg‬‬
‫‪Alex Clarke‬‬
‫‪Philippe Mougin‬‬
‫ﺗﺮﺟﻤﺔ ‪ :‬ﻣﺎزن اﻟﺮﻣﺎل‬

‫اﻟﻨﺴﺨﺔ ‪١٫١‬‬
‫ﺗﺮﺧﻴﺺ‬
‫إن ﻛﺎﻓﺔ ﺣﻘﻮق اﳌﻠﻜﻴﺔ اﻟﻔﻜﺮﻳﺔ ﻣﺤﻔﻮﻇﺔ‬
‫ﻟﻜﻞ ﻣﻦ ‪Bert Altenburg, Alex Clarke‬‬
‫‪ and Philippe Mougin‬اﻟﻨﺴﺨﺔ رﻗﻢ ‪ 1،2‬و‬
‫اﳌﺆﻟﻔﻮن اﻻﺻﻠﻴﻮن ﳝﺎﻧﻌﻮن ﻋﻤﻞ اي ﻧﺴﺦ‪،‬‬
‫ﺗﻌﺪﻳﻞ أو ﺗﻮزﻳﻊ ﻟﻬﺬا اﻟﻌﻤﻞ دون ذﻛﺮ‬
‫ﻷﺳﻤﺎﺋﻬﻢ اﻷﺻﻠﻴﺔ‪.‬‬
‫اﻷﻋﻤﺎل ﻏﻴﺮ ﲡﺎرﻳﺔ اﻟﻬﺪف‪:‬‬

‫إن أﺻﺤﺎب ﻫﺬا اﻟﺘﺮﺧﻴﺺ ﳝﺎﻧﻌﻮن ﻧﺴﺦ‪،‬‬
‫ﺗﻌﺪﻳﻞ‪ ،‬ﺗﻮزﻳﻊ ﻫﺬا اﻟﻌﻤﻞ ﺿﻤﻦ اﻷﻋﻤﺎل‬
‫ذات اﻟﻄﺎﺑﻊ اﻟﺘﺠﺎري أو ﻣﻦ ﺧﻼل اﶈﺎﺿﺮات‬
‫اﳌﺪﻓﻮﻋﺔ اﻟﺜﻤﻦ او اﻟﻜﺘﺐ‪ .‬وﻟﻜﻦ ﳝﻜﻦ‬
‫ﻟﻬﺬا اﻟﻌﻤﻞ ان ﻳﻜﻮن ﻣﺼﺎﺣﺒ ًﺎ ﻻي ﻧﺸﺎﻃﺎت‬
‫اﺧﺮى ﻣﺪﻓﻮﻋﺔ اﻟﺜﻤﻦ ﺑﺸﻜﻞ ﻣﺠﺎﻧﻲ‪.‬‬
‫‪II‬‬
‫اﶈﺘﻮﻳﺎت‬
‫‪٤٩‬‬ ‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬ ‫‪II‬‬ ‫ﺗﺮﺧﻴﺺ‬

‫‪٦٩‬‬ ‫ﺑﺤﺚ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﺔ‬ ‫‪١‬‬ ‫اﳌﻘﺪﻣﺔ‬
‫‪٧٥‬‬ ‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬ ‫‪٣‬‬ ‫ﻗﺒﻞ أن ﻧﺒﺪأ‬
‫‪٧٩‬‬ ‫اﳌﺆﺷﺮات‬ ‫‪٧‬‬ ‫اﻟﺒﺮﻧﺎﻣﺞ ﻋﺒﺎرة ﻋﻦ ﺗﻌﻠﻴﻤﺎت ﻣﺘﺘﺎﻟﻴﺔ‬
‫‪٨٣‬‬ ‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬ ‫‪١٥‬‬ ‫ﻻﺗﻬﻤﻞ اﻟﺘﻌﻠﻴﻘﺎت!!‬
‫‪٩١‬‬ ‫اﳌﺼﻔﻮﻓﺎت‬ ‫‪١٧‬‬ ‫اﻟﺪاﻻت اﻟﻮﻇﻴﻔﻴﺔ‬
‫‪٩٧‬‬ ‫إدارة اﻟﺬاﻛﺮة‬ ‫‪٢٥‬‬ ‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬
‫‪١٠١‬‬ ‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬ ‫‪٣١‬‬ ‫ﲡﻤﻴﻊ وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬
‫‪١٠٥‬‬ ‫ﻣﺴﺮد اﳌﺼﻄﻠﺤﺎت‬ ‫‪٤١‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬
‫‪١١٣‬‬ ‫ﻣﻼﺣﻈﺎت اﳌﺘﺮﺟﻢ‬ ‫‪٤٥‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬
‫‪III‬‬
‫‪IV‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﳌﻘﺪﻣﺔ‬
‫اﳌﻘﺪﻣﺔ‬
‫ﺗﻘﺪم ﻟﻚ ﺗﻜﻨﻮﻟﻮﺟﻴﺎ أﭘﻞ ‪ Apple‬ﻛﺎﻓﺔ اﻷدوات اﻟﻼزﻣﺔ ﻹﻧﺸﺎء‬
‫ﺗﻄﺒﻴﻘﺎت ‪ Cocoa‬ﻣﺠﺎﻧ َﺎ‪ .‬ﻓﻬﺬﻩ اﻷدوات ﺗﺄﺗﻴﻚ ﻣﺠﺘﻤﻌﺔ ﲢﺖ ﻣﻈﻠﺔ‬
‫‪ Xcode‬اﻟﺘﻲ ﺗﻮﺟﺪ ﺑﻨﻈﺎم ‪ Mac OS X‬ﻛﻤﺎ اﻧﻬﺎ ﻗﺎﺑﻠﺔ ﻟﻠﺘﺤﻤﻴﻞ ﻣﻦ‬
‫ﻗﺴﻢ اﳌﻄﻮرﻳﻦ ﲟﻮﻗﻊ أﭘﻞ اﻷﻟﻜﺘﺮوﻧﻲ‪.‬‬
‫ﻳﻮﺟﺪ ﻋﺪد ﻣﻦ اﻟﻜﺘﺐ اﳉﻴﺪة ﺣﻮل ﺑﺮﻣﺠﺔ اﳌﺎﻛﻨﺘﻮش‪ ،‬وﻟﻜﻨﻬﺎ‬
‫ﺗﻔﺘﺮض وﺟﻮد ﺧﺒﺮة ﺑﺮﻣﺠﻴﻪ ﻟﺪى اﻟﻘﺎرئ‪ .‬ﻫﺬا اﻟﻜﺘﺎب ﻟﻦ ﻳﻔﺘﺮض‬
‫ذﻟﻚ‪ .‬وﺳﻴﻌﻠﻤﻚ أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪ Objective-C‬ﻣﺴﺘﺨﺪﻣ َﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪.Xcode‬‬
‫ﺑﻌﺪ ﻗﺮأﺗﻚ ﻟﻌﺪد ﻣﻦ ﻓﺼﻮل اﻟﻜﺘﺎب ﺳﺘﺘﻤﻜﻦ ﻣﻦ إﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ‬
‫ﺑﺴﻴﻂ ﻻ ﻳﻌﺘﻤﺪ اﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﻪ ‪Graphical -‬‬
‫‪ User Interface‬واﳌﻌﺮوﻓﺔ ﺑﺎﺧﺘﺼﺎرﻫﺎ اﻟﺸﺎﺋﻊ ‪ . GUI‬وﺑﻌﺪ ذﻟﻚ‬
‫ﺑﻌﺪد ﻣﻦ اﻟﻔﺼﻮل ﺳﺘﺘﻌﻠﻢ إﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﺑﺴﻴﻂ ﻣﻦ ﺧﻼل واﺟﻬﺔ‬
‫اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﻪ )‪ .(GUI‬وﺑﻌﺪ اﻧﺘﻬﺎﺋﻚ ﻣﻦ ﻗﺮاءة ﻫﺬا اﻟﻜﺘﺎب‬
‫ﺳﺘﻜﻮن ﺟﺎﻫﺰاَ ﳌﺎ ﺗﻘﺪﻣﺔ ﻟﻚ اﻟﻜﺘﺐ اﳌﺘﻘﺪﻣﺔ ﳌﺎ ورد ﺑﻌﺎﻟﻴﻪ‪ .‬ﻋﻠﻴﻚ‬
‫ﺑﺘﻔﺤﺼﻬﺎ وﻗﺮاءﺗﻬﺎ ﺣﻴﺚ ﻳﻮﺟﺪ اﻟﻜﺜﻴﺮ ﻟﺘﺘﻌﻠﻤﻪ‪ .‬ﺣﺎﻟﻴ ًﺎ ﻻ داﻋﻲ‬
‫ﻟﻠﻘﻠﻖ ﻓﻬﺬا اﻟﻜﺘﺎب ﻳﻨﺘﻬﺞ أﺳﻠﻮب اﻟﺘﻘﺪﱘ اﻟﺴﻬﻞ ﻟﻠﻤﻌﻠﻮﻣﺎت‪.‬‬
‫‪١‬‬
‫اﳌﻘﺪﻣﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﻟﺸﻔﺮة ﺳﻨﻘﻮم ﺑﺎﻹﺷﺎرة إﻟﻰ ﺳﻄﺮ ﻣﻌﲔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫ﻛﻴﻒ ﺗﺴﺘﺨﺪم ﻫﺬا اﻟﻜﺘﺎب‬
‫]‪volume = baseArea * height // [4.3‬‬
‫ﻛﻤﺎ ﺳﺘﺮى‪ ،‬ﺳﻨﺴﺘﻌﺮض ﺑﻌﺾ اﻟﻨﺼﻮص اﻟﺘﻲ ﲤﺜﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬
‫‪ Code snippest‬اﻟﺘﻲ ﺳﻴﻘﻮم اﳌﺎﻛﻨﺘﻮش ﺑﺘﻘﻴﻴﻤﻬﺎ وﺗﻨﻔﻴﺬ ﻣﺤﺘﻮاﻫﺎ‬
‫ﻓﻲ اﳊﻘﻴﻘﺔ إن ﻋﻤﻠﻴﺔ اﻟﺒﺮﻣﺠﺔ ﻟﻴﺴﺖ ﺑﺎﻷﻣﺮ اﻟﻴﺴﻴﺮ‪ .‬ﻓﻬﻲ ﺗﺘﻄﻠﺐ‬ ‫وﺳﺘﻜﻮن داﺧﻞ ﺻﻨﺎدﻳﻖ ﻣﺜﻞ ﻫﺬا‪:‬‬
‫ﻣﻨﻚ اﳊﻀﻮر اﻟﻮاﻋﻲ واﻟﺘﺠﺮﻳﺐ اﻟﺘﻄﺒﻴﻘﻲ ﻟﻜﺎﻓﺔ اﳌﻌﻠﻮﻣﺎت اﻟﺘﻲ‬ ‫‪Some tidbits‬‬
‫ﻳﻘﺪﻣﻬﺎ ﻫﺬا اﻟﻜﺘﺎب‪ .‬ﻟﻦ ﺗﺴﺘﻄﻴﻊ اﻟﻌﺰف ﻋﻠﻰ اﻟﺒﻴﺎﻧﻮ أو ﻗﻴﺎدة‬ ‫وﻧﻘﺘﺮح ﻋﻠﻴﻚ أن ﺗﻘﺮأ اﻟﻔﺼﻞ اﻟﻮاﺣﺪ ﻣﺮﺗﺎن ﻋﻠﻰ اﻷﻗﻞ ﻣﻊ ﲡﺎﻫﻞ‬
‫اﻟﺴﻴﺎرة ﻣﻦ ﺧﻼل ﻗﺮاءة اﻟﻜﺘﺐ‪ .‬اﻷﻣﺮ ذاﺗﻪ ﻳﻨﻄﺒﻖ ﻣﻊ اﻟﺒﺮﻣﺠﺔ‪.‬‬ ‫ﺻﻨﺎدﻳﻖ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻓﻲ اﻟﺒﺪاﻳﺔ‪ .‬ﺛﻢ أﺛﻨﺎء ﻗﺮاءﺗﻚ اﻟﺜﺎﻧﻴﺔ‬
‫ﻫﺬا اﻟﻜﺘﺎب ُﻣﻘﺪم ﻟﻚ ﺑﻬﻴﺌﺘﺔ اﻹﻟﻜﺘﺮوﻧﻴﺔ ﻟﺘﻤﻜﻴﻨﻚ ﻣﻦ اﻻﻧﺘﻘﺎل‬ ‫ﻟﻠﻔﺼﻞ إﻗﺮاء ﻫﺬﻩ اﻟﺼﻨﺎدﻳﻖ‪ ،‬ﺣﻴﺚ ﺳﺘﻜﻮن ﻋﻨﺪﻫﺎ ﻣﺘﺄﻫﺒ َﺎ ﻹﻋﺎدة‬
‫ﻣﻨﻪ إﻟﻰ ﺑﺮﻧﺎﻣﺞ ‪ Xcode‬واﻟﻌﻮدة دون أﻳﺔ ﻋﻮاﺋﻖ‪ .‬ﻟﺬا ﻣﺎ أن ﺗﺒﺪأ ﻣﻊ‬ ‫ﺗﺬﻛﺮ وﺗﻄﺒﻴﻖ ﻣﺎ ﺗﻌﻠﻤﺘﻪ ﻓﻐﺎﻟﺒ َﺎ ﻣﺎ ﺗﻜﻮن ﻫﺬﻩ اﻟﻨﺼﻮص ﻣﺸﺘﺘﺔ‬
‫اﻟﻔﺼﻞ اﳋﺎﻣﺲ ﻧﻘﺘﺮح ﻋﻠﻴﻚ اﳌﺮور ﺑﻜﻞ ﻓﺼﻞ ﺛﻼث ﻣﺮات ﻋﻠﻰ‬ ‫ﻻﻧﺘﺒﺎﻫﻚ ﺑﺎﳌﺮات اﻷوﻟﻰ‪ .‬إن اﻋﺘﻤﺎد ﻫﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻓﻲ ﺗﻌﻠﻢ ﻣﺒﺎدئ‬
‫اﻷﻗﻞ‪ .‬ﻓﻲ اﳌﺮات اﻟﻼﺣﻘﺔ ﺣﺎول ﺗﻄﺒﻴﻖ اﻷﻣﺜﻠﺔ اﻟﻮاردة وﻻ ﻣﺎﻧﻊ ﻣﻦ‬ ‫ﺟﺪﻳﺪة ﻳﻌﻴﻨﻚ ﻣﻦ ﺗﺜﺒﻴﺖ اﳌﻌﻠﻮﻣﺔ‪.‬‬
‫أن ﲡﺮي ﺗﻌﺪﻳﻼﺗﻚ ﻋﻠﻰ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﺣﺘﻰ ﲡﺮب ﻛﻴﻔﻴﺔ ﺳﻴﺮ‬ ‫ﻫﺬﻩ اﻟﻜﺘﺎب ﻳﺤﺘﻮي ﻋﺪة أﻣﺜﻠﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺳﻄﺮ أو اﺛﻨﲔ ﻣﻦ‬
‫اﻷﻣﻮر‪.‬‬ ‫اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ .‬وﻗﺪ اﺳﺘﺨﺪﻣﻨﺎ اﻷﻗﻮاس اﻟﺘﺎﻟﻴﺔ]‪ [4‬ﻟﻌﻤﻞ ارﺗﺒﺎط‬
‫ﻟﻠﻤﻌﻠﻮﻣﺔ ﻣﻊ ﻣﺜﺎﻟﻬﺎ اﳌﻘﺎﺑﻞ‪ .‬إن ﻏﺎﻟﺒﻴﺔ اﻷﻣﺜﻠﺔ ﻣﻜﻮﻧﺔ ﻣﻦ ﺳﻄﺮﻳﻦ‬
‫ﻼ ﻣﻦ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ .‬وﻓﻲ أﺣﻴﺎن ﻣﻌﻴﻨﺔ ﺳﻴﺘﻀﻤﻦ‬ ‫أو اﻛﺜﺮ ﻗﻠﻴ ً‬
‫اﳌﺜﺎل رﻗﻢ وﻳﺘﺒﻌﻪ رﻗﻢ آﺧﺮ ﺑﻌﺪ اﻟﻔﺎﺻﻠﺔ ﺣﻴﺚ ﻧﺴﺘﺨﺪم اﻟﺮﻗﻢ اﻵﺧﺮ‬
‫ﻟﻺﺷﺎرة إﻟﻰ رﻗﻢ ﺳﻄﺮ ﻣﻌﲔ ﻣﻦ ﻛﺘﻠﺔ ﺷﻔﺮة اﻟﺒﺮﻣﺠﺔ‪ .‬ﻛﻤﺜﺎل اﻟﻘﻮس‬
‫]‪ [3.4‬ﻳﺸﻴﺮ إﻟﻰ اﻟﺴﻄﺮ ‪ ٣‬ﻣﻦ اﳌﺜﺎل‪ . ٤‬وﻓﻲ اﻻﻗﺘﺒﺎﺳﺎت اﻟﻄﻮﻳﻠﺔ ﻣﻦ‬
‫‪٢‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻗﺒﻞ أن ﻧﺒﺪأ‬
‫ﻗﺒﻞ أن ﻧﺒﺪأ‬
‫ﻟﻘﺪ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ ﻫﺬا اﻟﻜﺘﺎب وﻛﻨﺖ ﻋﺰﻳﺰي اﻟﻘﺎريء ﻣﺤﻮر اﻫﺘﻤﺎﻣﻨﺎ‪.‬‬
‫ﻓﺒﻤﺎ أﻧﻪ ﻣﺠﺎﻧﻲ‪ ،‬أﺳﻤﺢ ﻟﻨﺎ ﺑﺘﺴﻮﻳﻖ اﳌﺎﻛﻨﺘﻮش ﻛﺄﻓﻀﻞ ﻧﻈﺎم ﺗﺸﻐﻴﻞ‬
‫ﺑﻘﻠﻴﻞ ﻣﻦ اﳉﻬﺪ‪ .‬وإﻟﻴﻚ اﻟﻄﺮﻳﻘﺔ‪:‬‬
‫ﺳﻬﻠﺖ‬ ‫‪ .١‬ﻛﻠﻤﺎ ﺻﻘﻠﺖ ﺧﺒﺮات ﺗﻌﺎﻣﻠﻚ ﻣﻊ اﳌﺎﻛﻨﺘﻮش ﻛﻠﻤﺎ ّ‬
‫ﻟﻠﻤﺤﻴﻄﲔ ﺑﻚ أن ﻳﺘﻨﺒﻬﻮا ﻹﻣﻜﺎﻧﻴﺎت ﻫﺬا اﻟﻨﻈﺎم‪ .‬ﻟﺬا ﻛﻦ ﻣﻄﻠﻌ َﺎ‬
‫ﻋﻠﻰ آﺧﺮ اﻷﺧﺒﺎر ﺑﺰﻳﺎرﺗﻚ ﻟﻠﻤﻮاﻗﻊ واﳌﻨﺘﺪﻳﺎت وﻗﺮاءﺗﻚ ﻟﻠﻤﺠﻼت‬
‫اﻟﺘﻲ ﺗﻬﺘﻢ ﺑﺎﳌﺎﻛﻨﺘﻮش‪ .‬ﻣﻦ اﳌﺆﻛﺪ أن ﺗﻌﻠﻤﻚ ﻟﻠﻐﺔ ‪Objective-C‬‬
‫أو إﺗﻘﺎﻧﻚ ﻟـ ‪ AppleScript‬ﺳﻴﻜﻮن ﻟﻬﻤﺎ اﺛﺮﻫﻤﺎ اﻟﻔﺎﻋﻞ ﻓﻲ اﻷﻋﻤﺎل‬
‫اﻟﺘﻲ ﺗﺆدﻳﻬﺎ‪.‬‬
‫إن اﺳﺘﺨﺪام ‪ AppleScript‬ﻳﻐﻨﻴﻚ ﻋﻦ ﺳﺎﻋﺎت ﻣﻦ اﻷﻋﻤﺎل اﳌﺘﻜﺮرة‬
‫واﳌﻀﻨﻴﺔ‪ .‬أﻟﻘﻲ ﻧﻈﺮة ﻋﻠﻰ ﻛﺘﺎﺑﻨﺎ اﳌﺠﺎﻧﻲ ﺣﻮل ‪AppleScript‬‬
‫واﳌﻮﺟﻪ ﻟﻠﻤﺒﺘﺪﺋﲔ وﻫﻮ ﻣﺘﻮﻓﺮ ﻋﻠﻰ ‪http://www.macscripter.‬‬
‫‪. net/books‬‬
‫‪.٢‬اﻇﻬﺮﻟﻠﻌﺎﻟﻢﻛﺎﻓﺔأناﳊﺎﺳﺒﺎتﻟﻴﺴﺖﻓﻘﻂ”"وﻧﺪوز ‪.“Windows‬‬
‫إن ﻟﺒﺲ ﻣﻼﺑﺲ ﻋﻠﻴﻬﺎ ﺷﻌﺎرات ﻣﺎﻛﻨﺘﻮش ﻟﻠﻌﻠﻦ ﻫﻮ أﺣﺪ اﻟﻄﺮق‪،‬‬
‫وﻟﻜﻦ ﻫﻨﺎك ﻃﺮق اﻛﺜﺮ ﻟﺘﻌﺰﻳﺰ ﻫﺬا اﻟﻨﻈﺎم وﻫﻲ ﺗﺒﺪأ ﻣﻦ داﺧﻞ ﺑﻴﺘﻚ‪.‬‬
‫‪٣‬‬
‫ﻗﺒﻞ أن ﻧﺒﺪأ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻣﺴﺘﺨﺪﻣﻲ اﳌﺎﻛﻨﺘﻮش واﻟﺬي ﺳﻴﻜﻮن ﻟﻚ دور ﻣﻬﻢ ﻓﻲ رﻓﻊ ﻧﺴﺒﺔ‬ ‫ﻓﺈذا ﻣﺎ ﺷﻐﻠﺖ ﻣﺮاﻗﺐ اﻟﻨﺸﺎﻃﺎت ‪ Activity Monitor‬اﳌﻮﺟﻮد ﲟﺠﻠﺪ‬
‫ﻣﺸﺎرﻛﺘﻬﻢ‪ .‬ﻋﻨﺪﻫﺎ ﺳﻴﺪرك ﻣﺴﺘﺨﺪﻣﻲ اﻷﻧﻈﻤﺔ اﻷﺧﺮى ﻛﻴﻒ ﻫﻮ‬ ‫اﻷدوات ‪ Utilities‬اﳌﺘﻮاﺟﺪ داﺧﻞ ﻣﺠﻠﺪ اﻟﺘﻄﺒﻴﻘﺎت ‪Applications‬‬
‫أداء اﳌﺎﻛﻨﺘﻮش‪.‬‬ ‫ﺳﺘﻠﺤﻆ ﻣﺪى ﻧﺪرة اﺳﺘﺨﺪام اﻟﻨﻈﺎم ﻟﻜﺎﻓﺔ ﻗﻮاﻩ اﳊﺴﺎﺑﻴﺔ اﻟﻘﺼﻮى‪.‬‬
‫ﻳﻮﺟﺪ ﻫﻨﺎك ﺑﺮاﻣﺞ ﻋﻤﻼء ﺑﻌﺪﻳﺔ ﺗﻐﻄﻲ ﻣﻮاﺿﻴﻊ ﻣﺘﻨﻮﻋﺔ ﻛﺎﳊﺴﺎب‪،‬‬ ‫ﻳﻘﻮم اﻟﻌﻠﻤﺎء ﺑﺘﻄﻮﻳﺮ ﻋﺪة ﻣﺸﺎرﻳﻊ ﺣﻮﺳﺒﺔ ذات ﲢﻜﻢ ﺑﻌﺪي‬
‫واﻟﻌﻼﺟﺎت اﻟﺴﺮﻳﺮﻳﻪ واﳌﺰﻳﺪ‪ .‬ﺣﺘﻰ ﺗﺨﺘﺎر اﳌﺸﺮوع اﳌﻨﺎﺳﺐ ﺗﻔﺤﺺ‬ ‫)‪ distributed computing (DC‬ﻛﻤﺸﺮوع ‪ Folding@home‬أو‬
‫ﻫﺬا اﳌﻮﻗﻊ ‪http://distributedcomputing.info/projects.html‬‬ ‫ﻣﺸﺮوع ‪ SETI@home‬اﻟﺬي ﻳﺴﺘﻘﻲ ﺟﺰء ﺑﺴﻴﻂ ﻻ ﻳﺬﻛﺮ ﻣﻦ ﻣﻮارد‬
‫وﻗﺪ ﺗﻮﺟﺪ ﻣﺸﻜﻠﺔ ﺑﺴﻴﻄﺔ ﺣﻮل ﻫﺬا اﻻﻗﺘﺮاح‪ :‬ﻫﺬﻩ اﳌﺸﺎرﻛﺔ‬ ‫اﻟﻌﻤﻠﻴﺎت وﻫﻲ ﻣﺸﺎرﻳﻊ ذات أﻫﺪاف ﺳﺎﻣﻴﺔ‪ .‬ﺣﻴﺚ ﳝﻜﻨﻚ ﲢﻤﻴﻞ‬
‫ﺳﺘﺘﺤﻮل إﻟﻰ ﻧﻮع ﻣﻦ اﻹدﻣﺎن!‬ ‫أﺣﺪ ﺗﻠﻚ اﻟﺒﺮاﻣﺞ اﳌﺠﺎﻧﻴﺔ وﻫﻲ ﺗﺪﻋﻰ ﻋﻤﻴﻞ ‪ DC client‬ودﻋﻬﺎ‬
‫ﺗﻨﺠﺰ اﻋﻤﺎك اﳊﺴﺎب اﳌﻄﻠﻮﺑﺔ ﻣﻨﻬﺎ‪ .‬اﻧﻬﺎ ﺗ ّﻔﻌﻞ ذاﺗﻬﺎ ﺿﻤﻦ اﻟﻨﻈﺎم‬
‫‪ .٣‬ﺗﺄﻛﺪ ﻣﻦ ﺣﺼﻮل ﺟﻬﺎزك ﻋﻠﻰ أﻓﻀﻞ اﻟﺒﺮﻣﺠﻴﺎت‪ .‬وﻻ ﺗﻌﺘﻤﺪ‬
‫ﺑﺄدﻧﻰ ﻗﺪر ﻣﻦ ﻃﺎﻗﺔ اﳌﻌﺎﳉﺔ اﳌﺘﺎﺣﺔ‪.‬‬
‫ﻓﻲ ذﻟﻚ ﻋﻠﻰ ﻣﺎ ﺗﻄﻮرﻩ ﻣﻦ ﺑﺮﻣﺠﻴﺎت ﺑﻨﻔﺴﻚ‪ .‬واﺟﻌﻠﻬﺎ ﻋﺎدة‬
‫ﻣﻦ ﻋﺎداﺗﻚ اﻟﺪاﺋﻤﺔ أن ﺗﺰود ﻣﻄﻮري اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺴﺘﺨﺪﻣﻬﺎ‬ ‫ﻣﺎ أن ﺗﺴﺘﺨﺪم أﺣﺪ ﺑﺮاﻣﺠﻚ اﻻﻋﺘﻴﺎدﻳﺔ ﻋﻠﻰ ﺟﻬﺎزك ﺳﻴﺘﻄﻠﺐ‬
‫ﲟﺮﺋﻴﺎﺗﻚ‪ .‬ﺣﺘﻰ ﻓﻲ ﺣﺎل ﲡﺮﻳﺒﻚ ﻻﺣﺪ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﻟﻢ ﺗﻌﺠﺐ‬ ‫اﻷﺧﻴﺮ اﻻﻧﺘﺒﺎﻩ اﻷﻗﺼﻰ ﻣﻦ اﳌﻮارد‪ ،‬ﻋﻨﺪﻫﺎ ﻳﺘﻨﺤﻰ ﺑﺮﻧﺎﻣﺞ اﻟﻌﻤﻴﻞ‬
‫ﺑﻬﺎ‪ ،‬ﻓﻘﻂ أﺧﺒﺮ اﳌﻄﻮر ﺑﺎﻟﺴﺒﺐ‪ .‬اﻋﻠﻦ ﻋﻦ ﻣﺸﻜﻼت اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﺣﺘﻰ أﻧﻚ ﻟﻦ ﺗﺸﻌﺮ ﺑﻪ وﻫﻮ ﻓﻲ اﳊﺪود اﻟﺪﻧﻴﺎ ﻣﻦ ﻧﻄﺎق اﻟﻨﻈﺎم‪.‬‬
‫‪ bugs‬ﻣﻦ ﺧﻼل اﻟﺘﻮﺛﻴﻖ اﻟﺪﻗﻴﻖ ﻟﻸواﻣﺮ اﻟﺘﻲ ُﻗﻤﺖ ﺑﻬﺎ أو اﶈﺘﻤﻠﺔ‬ ‫ﻛﻴﻒ ﻟﻬﺬﻩ اﳌﺸﺎرﻛﺔ أن ﺗﺴﺎﻋﺪ ﻣﻦ وﺿﻊ اﻟﺘﻮﻋﻴﺔ ﺑﺎﳌﺎﻛﻨﺘﻮش؟‬
‫ﻟﻈﻬﻮر ﺗﻠﻚ اﳌﺸﻜﻠﺔ‪.‬‬ ‫ﻓﻲ اﳊﻘﻴﻘﺔ ﻛﺜﻴﺮ ﻣﻦ ﺑﺮاﻣﺞ ﻣﺸﺎرﻳﻊ اﻟﻌﻤﻴﻞ ‪ DC client‬ﻫﺬﻩ ﺗﻘﻮم‬
‫‪ .٤‬ادﻓﻊ ﻗﻴﻤﺔ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺴﺘﺨﺪﻣﻬﺎ‪ .‬وﻟﺘﻌﻠﻢ اﻧﻪ ﻃﺎﳌﺎ ﻛﺎن‬ ‫ﺑﺘﻘﻴﻴﺪ ﻧﺘﺎﺋﺞ ﻣﻌﻄﻴﺎﺗﻬﺎ ﻓﻲ ﻣﻮاﻗﻊ أﻟﻜﺘﺮوﻧﻴﺔ ﺣﻮل اﻟﻮﺣﺪات اﻟﺘﻲ‬
‫ﻫﻨﺎك ﻃﻠﺒﺎت ﺷﺮاء ﻟﺴﻮق ﺑﺮاﻣﺞ اﳌﺎﻛﻨﺘﻮش ﻓﺎﻟﻔﺮﺻﺔ ﻛﺒﻴﺮة ﻟﻈﻬﻮر‬ ‫ﰎ اﺣﺘﺴﺎﺑﻬﺎ‪ .‬ﻣﺎ أن ﺗﻨﻀﻢ ﻟﻔﺮﻳﻖ اﳌﺎﻛﻨﺘﻮش )واﻟﺬﻳﻦ ﺳﺘﺘﻌﺮف‬
‫ﻣﻄﻮرﻳﻦ وﺑﺮاﻣﺞ ﻗ ّﻴﻤﺔ‪.‬‬ ‫ﻋﻠﻰ أﺳﻤﺎﺋﻬﻢ ﻣﻦ ﺧﻼل اﻟﻨﺘﺎﺋﺞ اﳌﻌﺮوﺿﺔ( ﻋﻨﺪﻫﺎ ﺳﺘﺠﺪ ﻧﺴﺒﺔ‬
‫‪٤‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻗﺒﻞ أن ﻧﺒﺪأ‬
‫‪ .٥‬ﻗﻢ ﺑﺎﻟﺘﻮاﺻﻞ ﻋﻠﻰ اﻷﻗﻞ ﻣﻊ ﺛﻼﺛﺔ ﻣﺴﺘﺨﺪﻣﲔ ﻟﻠﻤﺎﻛﻨﺘﻮش ﻋﻠﻰ‬

‫أن ﻳﻜﻮﻧﻮا ﻣﺘﺤﻤﺴﲔ ﻟﻠﺒﺮﻣﺠﺔ‪ .‬أﺧﺒﺮﻫﻢ ﻋﻦ ﻫﺬا اﻟﻜﺘﺎب‪ ،‬وﻛﻴﻒ‬
‫ﳝﻜﻨﻬﻢ اﳊﺼﻮل ﻋﻠﻴﻪ‪ .‬أو اﻓﻌﻞ ﺧﻴﺮاَ ﺑﺈﺧﺒﺎرﻫﻢ ﻋﻦ أﻫﻤﻴﺔ اﻟﻨﻘﺎط‬
‫اﻷرﺑﻌﺔ اﻟﺴﺎﺑﻘﺔ‪.‬‬
‫واﻻن أﺛﻨﺎء ﻗﻴﺎﻣﻚ ﺑﺘﺤﻤﻴﻞ أﺣﺪ ﺗﻠﻚ اﻟﺒﺮاﻣﺞ اﻟ ُﺒﻌﺪﻳﺔ‪ ،‬دﻋﻨﺎ ﻧﺒﺪأ‬
‫اﻟﻌﻤﻞ!‬
‫‪٥‬‬
‫ﻗﺒﻞ أن ﻧﺒﺪأ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺒﺮﻧﺎﻣﺞ ﻋﺒﺎرة ﻋﻦ ﺗﻌﻠﻴﻤﺎت ﻣﺘﺘﺎﻟﻴﺔ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻋﺒﺎرة ﻋﻦ ﺗﻌﻠﻴﻤﺎت‬

‫ﻣﺘﺘﺎﻟﻴﺔ‬
‫ﻋﻨﺪ ﺗﻌﻠﻤﻚ ﻗﻴﺎدة اﻟﺴﻴﺎرة‪ ،‬وﺟﺐ ﻋﻠﻴﻚ إن ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﻋﺪة أﻣﻮر‬
‫ﻓﻲ وﻗﺖ واﺣﺪ‪ .‬ﺣﻴﺚ ﺗﻮﺟﺐ ﻋﻠﻴﻚ ﺣﻴﻨﻬﺎ ﻣﻌﺮﻓﺔ دور ﻣﺒﺪل‬
‫اﻟﻜﻠﺘﺶ ودواﺳﺔ اﻟﻮﻗﻮد و اﳌﻜﺎﺑﺢ‪ .‬ﻓﺎﻟﺒﺮﻣﺠﺔ ﻛﺬﻟﻚ ﺗﺘﻄﻠﺐ ﻣﻨﻚ‬
‫ﻣﻌﺮﻓﺔ أﻣﻮر ﻋﺪﻳﺪة‪ ،‬واﻻ ﺗﻌﺮض ﺑﺮﻧﺎﻣﺠﻚ ﻟﻠﺘﺤﻄﻢ‪.‬‬
‫ﻓﺒﺎﻟﺮﻏﻢ ﻣﻦ إن ﻣﺤﺘﻮﻳﺎت اﻟﺴﻴﺎرة ﻣﺄﻟﻮﻓﺔ ﻟﺪﻳﻚ إﻻ أن ذﻟﻚ ﻻ‬
‫ﻳﻌﺪ ﻣﻴﺰة أﺛﻨﺎء اﻟﺘﻌﺎﻣﻞ ﻣﻊ ‪ .Xcode‬وﺣﺘﻰ ﻻ ﻧﺜﻘﻞ ﻋﻠﻴﻚ‪ ،‬ﺗﺮﻛﻨﺎ‬
‫اﳌﺴﺎﺋﻞ اﻟﺒﺮﻣﺠﻴﺔ ﻵﺧﺮ ﻫﺬا اﻟﻔﺼﻞ‪ .‬أوﻻ ﺳﻨﺠﻌﻠﻚ ﺗﺘﻌﺎﻣﻞ ﺑﺎرﺗﻴﺎح‬
‫ﻣﻊ ﺷﻔﺮة ‪ Objective-C‬وذﻟﻚ ﻣﻦ ﺧﻼل ﻋﺮض أﺳﺎﺳﻴﺎت ﺣﺴﺎﺑﻴﺔ‬
‫ﻣﺄﻟﻮﻓﺔ ﻟﺪﻳﻚ‪ .‬ﻓﻔﻲ اﻟﺘﻌﻠﻴﻢ اﻹﺑﺘﺪاﺋﻲ وﺟﺐ ﻋﻠﻴﻚ اﻟﻘﻴﺎم ﺑﺒﻌﺾ‬
‫اﳌﻌﺎﻣﻼت اﳊﺴﺎﺑﻴﺔ ﻣﺜﻞ ﻣﻞء اﻟﻔﺮاغ‬
‫‪ ...=٢+٦‬ﻓﺮاغ أو ﻓﺮاغ ‪٤*٣ = .....‬‬
‫)اﻟﻨﺠﻤﺔ ﻫﻨﺎ ﲢﻞ ﻣﺤﻞ ﻣﻌﺎﻣﻞ اﻟﻀﺮب( وﻓﻲ اﻟﺘﻌﻠﻴﻢ اﳌﺘﻮﺳﻂ‪،‬‬
‫ﲢﻮﻟﺖ ﻧﻘﺎط اﻟﻔﺮاﻏﺎت إﻟﻰ ﻧﻮﻋ َﺎ ﻣﻨﻘﺮﺿ ًﺎ ﻣﻦ اﻟﻌﻤﻠﻴﺎت وﰎ‬
‫اﻻﺳﺘﻌﺎﺿﺔ ﻋﻨﻬﺎ ﺑـ س و ص )واﻃﻠﻖ ﻋﻠﻴﻬﺎ ﻣﻮﺿﺔ اﳉﺒﺮ( ﺣﻴﺚ‬
‫‪٧‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻋﺒﺎرة ﻋﻦ ﺗﻌﻠﻴﻤﺎت ﻣﺘﺘﺎﻟﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﻟﺘﻌﻠﻴﻤﺔ ﺗﻠﻚ إﻟﻰ إﻳﻌﺎزات و أواﻣﺮ ﻣﻜﻮﻧﺔ ﻣﻦ ﻧﺒﻀﺎت اﻟﺼﻔﺮ‬ ‫ﻛﺎﻧﺖ ﺗﻠﻚ ﻫﻲ اﻟﺼﻴﺤﺔ اﻟﺴﺎﺋﺪة ﺑﺘﻠﻚ اﻟﻔﺘﺮة‪ .‬وﻗﺪ ﺗﺘﺴﺎءل ﻋﻦ‬
‫واﻟﻮاﺣﺪ ﺣﻴﺚ ﻳﺴﺘﻄﻴﻊ اﳊﺎﺳﺐ ﻋﻨﺪﻫﺎ اﻟﻘﻴﺎم ﺑﻌﻤﻠﻪ‪.‬‬ ‫أﺣﻮال أوﻟﺌﻚ اﻟﺬﻳﻦ ﻓﻘﺪوا اﻫﺘﻤﺎﻣﻬﻢ ﻟﺘﻘﺪﱘ اﳊﻠﻮل ﺑﺴﺒﺐ ﺗﻐﻴﻴﺮ‬
‫إن ﻗﺮاءة واﺳﺘﻴﻌﺎب اﻟﻨﺼﻮص اﳌﻜﺘﻮﺑﺔ ﻣﻦ ﻗﺒﻞ اﻟﺒﺸﺮ ﻣﻬﻤﺔ ﺻﻌﺒﺔ‬ ‫ﻃﻔﻴﻒ ﻓﻲ اﻟﺘﺴﻤﻴﺔ ”"اﳌﺘﻐﻴﺮات ‪.“Variables‬‬
‫ﻟﻠﻤﺮﻛﻢ‪ ،‬ﻟﺬا ﻳﻨﺒﻐﻲ ﻋﻄﺎءﻩ ﺗﻠﻤﻴﺤﺎت ﺧﺎﺻﺔ‪ ،‬ﻛﺘﻠﻤﻴﺤﺔ إﻧﺘﻬﺎء ﺳﻄﺮ‬ ‫‪=٢+٦‬س‬
‫اﳌﻌﻠﻮﻣﺔ ﻣﻦ اﻻواﻣﺮ واﻟﺒﻴﺎﻧﺎت ﻣﺜ َ‬
‫ﻼ ﺣﻴﺚ وﺿﻌﻨﺎ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ‪.‬‬ ‫ص=‪٤*٣‬‬
‫ان ﻣﺠﺮد اﻏﻔﺎل ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ واﺣﺪة ﻻﺣﺪ اﺳﻄﺮ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪،‬‬ ‫إن ﻟﻐﺔ ‪ Objective-C‬ﺗﺴﺘﺨﺪم اﳌﺘﻐﻴﺮات ﻛﺬﻟﻚ‪ .‬ﻓﺎﳌﺘﻐﻴﺮات ﻣﺎ‬
‫اﳌﺠﻤﻊ‪ ،‬ذﻟﻚ اﻧﻪ ﺳﻴﻔﺸﻞ ﻓﻲ ﲢﻮﻳﻞ ﺗﻠﻚ‬ ‫ﻳﺴﺒﺐ ﻓﺸﻞ ﻓﻲ ﻣﻬﻤﺔ ّ‬ ‫ﻼ‪.‬‬‫ﻫﻲ إﻻ أﺳﻤﺎء ﺗﺸﻴﺮ ﳉﺰﺋﻴﺎت ﻣﻌﻴﻨﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪ ،‬ﻛﺎﻷﻋﺪاد ﻣﺜ َ‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﻰ اواﻣﺮ ﳝﻜﻦ ﻟﻠﻤﺎﻛﻨﺘﻮش ان ﻳﻔﺴﺮﻫﺎ وﻳﻨﻔﺬﻫﺎ‪ .‬ﻻ ﺗﺪع‬ ‫ﻫﻨﺎ ﻟﺪﻳﻨﺎ ﻣﺜﺎل ]‪ [1‬ﻳ ّﻌﺪ ﻛﺘﺼﺮﻳﺢ ﻹﻳﻌﺎز ‪ Objective-C‬ﺣﻴﺚ‬
‫اﳌﺠﻤﻊ ﺳﻴﺸﻜﻮ ﻣﻦ ﻋﺪم ﲤﻜﻨﻪ ﻣﻦ‬ ‫ﻫﺬا اﻻﻣﺮ ﻳﻘﻠﻘﻚ ﻛﺜﻴﺮاَ‪ ،‬ذﻟﻚ ان ّ‬ ‫أوﺟﺪﻧﺎ ﻣﺘﻐﻴﺮاً اﻋﻄﻴﻨﺎﻩ اﺳﻤ َﺎ واﺳﻨﺪﻧﺎ ﻟﻪ ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﻣﻦ ﺧﻼل‬
‫اﲤﺎم ﻋﻤﻠﻴﺔ اﻟﺘﻔﺴﻴﺮ‪ .‬ﻛﻤﺎ ﺳﻨﺮى ﻓﻲ اﻟﺘﻔﺼﻮل اﻟﻘﺎدﻣﺔ‪ ،‬اﻧﻪ ﻳﻘﺪم ﻟﻚ‬ ‫ﺳﻄﺮ ﺑﺮﻣﺠﻲ‪.‬‬
‫اﻟﻌﻮن ﻟﻠﺒﺤﺚ ﻋﻦ اﻻﺧﻄﺎء اﶈﺘﻤﻠﺔ ﺑﲔ ﺳﻄﻮر ﺷﻔﺮة اﻟﺘﻌﻠﻴﻤﺎت‪.‬‬ ‫]‪[1‬‬
‫;‪x = 4‬‬
‫ﺑﺎﻟﺮﻏﻢ ﻣﻦ ان اﺳﻤﺎء اﳌﺘﻐﻴﺮات ﻟﻴﺴﺖ ذات ﻣﻌﻨﻰ ﻗ ّﻴﻢ ﻟﻠﻤﺮﻛﻢ‪،‬‬
‫اﻻ ان اﺳﻤﺎء اﳌﺘﻐﻴﺮات اﻟﻮاﺿﺤﺔ ﲡﻌﻞ ﻣﻦ ﻗﺮاءﺗﻚ ﻟﻠﺒﺮﻧﺎﻣﺞ اﻳﺴﺮ‬ ‫إن اﳌﺘﻐﻴﺮ ‪ x‬ﻳﺤﺘﻮي ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺗﺴﺎوي ‪ .٤‬وﺳﺘﻼﺣﻆ وﺟﻮد‬
‫ﻟﻠﻔﻬﻢ‪ .‬ان ﻫﺬﻩ اﳋﺎﺻﻴﺔ ﻣﻬﻤﺔ ﺟﺪاَ ﻋﻨﺪ ﺗﻘﺼﻴﻚ ﻋﻦ اﻻﺧﻄﺎء‬ ‫ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ";" ﻓﻲ ﻧﻬﺎﻳﺔ اﻹﻳﻌﺎز‪ .‬ذﻟﻚ أن اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ‬
‫اﻟﺒﺮﻣﺠﻴﺔ داﺧﻞ ﺳﻄﻮر اﻟﺸﻔﺮة‪.‬‬ ‫ﻣﻄﻠﺐ أﺳﺎﺳﻲ ﻋﻨﺪ ﻧﻬﺎﻳﺔ ﻛﻞ إﻳﻌﺎز‪ .‬ﳌﺎذا؟‬
‫ٌﻳﻄﻠﻖ ﻋﻠﻰ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ﺗﻌﺎرﻓ َﺎ ﻣﺼﻄﻠﺢ ‪ .Bug‬ﺑﻴﻨﻤﺎ ﺗﻘﺼﻲ‬ ‫ﻗﺪ ﻳﺒﺪو اﳌﺜﺎل ﻏﻴﺮ ذي أﻫﻤﻴﺔ‪ ،‬ﻋﻠﻰ ﻛﻞ ﺣﺎل اﳊﺎﺳﺒﺎت إﺟﻤﺎﻻ‬
‫واﺻﻼح ﺗﻠﻚ اﻻﺧﻄﺎء ﻳﻄﻠﻖ ﻋﻠﻴﻪ ‪ .debugging‬ﻟﺬا‪ ،‬ﻣﺘﻰ ﻣﺎ‬ ‫ﻻ ﺗﺪرك ﻣﺎ ﻋﻠﻴﻬﺎ أن ﺗﻔﻌﻠﻪ ﺑﻬﺬا اﻟﺴﻄﺮ‪ .‬ﻟﺬا ﻳﻮﺟﺪ ﺑﺮﻧﺎﻣﺞ ﺧﺎص‬
‫ﺗﻌﺎﻣﻠﺖ ﻣﻊ اﻟﺸﻔﺮة ﲡﻨﺐ اﺳﺘﺨﺪام ﺗﻠﻚ اﳌﺴﻤﻴﺎت اﻟﻐﻴﺮ واﺿﺤﺔ‬ ‫اﳌﺠﻤﻊ ‪ ” compiler‬وﻫﻮ ﺿﺮوري ﻟﺘﺤﻮﻳﻞ ﻧﺺ‬ ‫ﻳﻄﻠﻖ ﻋﻠﻴﻪ اﺳﻢ ”" ّ‬
‫‪٨‬‬
‫ﺑﺸﻜﻞ ﻛﺒﻴﺮ ﻓﻴﻤﺎ ﻳﺘﻌﻠﻖ ﲟﺴﺄﻟﺔ ﺣﺴﺎﺳﻴﺔ اﳊﺮوف‪.‬‬ ‫أو اﻟﺘﻲ ﻻ ﻣﻌﻨﻰ ﻟﻬﺎ ﻣﺜﻞ اﺳﺘﺨﺪام ﻣﺘﻐﻴﺮ ‪ .x‬ﻣﺜﻼ ﻋﻨﺪ اﳊﺎﺟﺔ‬
‫اﻟﺮﺟﺎء ﻣﻼﺣﻈﺔ ﺗﺴﻤﻴﺔ اﳌﺘﻐﻴﺮات ﺑﻜﻠﻤﺎت ﻣﺘﻮاﺻﻠﺔﺗﻜﻮنﻓﻲاﻟﻨﻬﺎﻳﺔ‬ ‫ﻟﻮﺟﻮد ﻣﺘﻐﻴﺮ ﻣﻬﻤﺘﻪ ﺣﻔﻆ ﻗﻴﻤﺔ ﻋﺮض ﺻﻮرة ﻣﺎ‪ ،‬ﺣﻴﺚ ﳝﻜﻨﻨﺎ ان‬
‫ﻛﻠﻤﺔ واﺣﺪة‪ .‬ﻓﺮﻏﻢ وﺟﻮد ﺣﺮﻳﺔ ﻛﺒﻴﺮة ﻓﻲ اﺧﺘﻴﺎر أﺳﻤﺎء اﳌﺘﻐﻴﺮات‪،‬‬ ‫ﻧﻄﻠﻖ ﻋﻠﻴﻪ اﺳﻢ ‪ pictureWidth‬ﻛﺎﳌﺜﺎل ]‪. [2‬‬
‫إﻻ أن ﻫﻨﺎك ﻗﻮاﻋﺪ ﻣﻬﻤﺔ ﻳﻔﺘﺮض ﺑﺎﻟﺘﺴﻤﻴﺔ ان ﺗﺘﻄﺎﺑﻖ ﻣﻌﻬﺎ‪.‬‬ ‫]‪[2‬‬
‫;‪pictureWidth = ٨‬‬
‫وﺑﺎﻟﺮﻏﻢ ﻣﻦ ﻗﺪرﺗﻲ ﻋﻠﻰ ﺳﺮدﻫﺎ ﻛﺎﻣﻠﻪ‪ ،‬اﻻ ان ذﻟﻚ ﺳﻴﺪﻋﻮ ﻟﻠﻤﻠﻞ‪.‬‬ ‫اﳌﺠﻤﻊ ﻣﻦ ﺗﻮﻗﻒ وﻓﺸﻞ ﻛﺒﻴﺮ ﳌﺠﺮد ﻧﺴﻴﺎﻧﻚ‬
‫ﻳﺤﺪﺛﻪ ّ‬‫ﻣﻦ ﻣﻨﻄﻠﻖ ﻣﺎ ّ‬
‫ﻋﻠﻰ ﻛﻞ ﺣﺎل اﻟﻘﺎﻋﺪة اﻻﺳﺎﺳﻴﺔ ﻫﻨﺎ ﺗﺸﺘﺮط اﻻ ﻳﻜﻮن اﺳﻢ اﳌﺘﻐﻴﺮ‬ ‫ﻹدراج اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ ﻋﻨﺪ ﻧﻬﺎﻳﺔ اﻟﺴﻄﺮ‪ ،‬ﺳﻴﺠﻌﻠﻚ ذﻟﻚ ﺗﺪرك‬
‫ﻣﺤﺠﻮز ﻟﻠﻤﻔﺮدات اﶈﺠﻮزة ﻟﻠﻐﺔ ‪) Objective-C‬اي ان ﻻ ﻳﻜﻮن‬ ‫أن اﻟﺒﺮﻣﺠﺔ ﺗﻬﺘﻢ ﺑﺎﻟﺘﻔﺎﺻﻴﻞ‪ .‬أﺣﺪ ﺗﻠﻚ اﻟﺘﻔﺎﺻﻴﻞ اﻟﻮاﺟﺐ‬
‫اﻻﺳﻢ ذي دﻻﻟﺔ ﻣﻌﻴﻨﺔ ﻟﺪى ‪.( Objective-C‬‬ ‫اﻟﺘﻨﺒﻪ ﻟﻬﺎ ﻫﻲ ﺣﻘﻴﻘﺔ ﺣﺴﺎﺳﻴﺔ اﻟﻨﺺ ‪ .case-sensitive‬ذﻟﻚ أن‬
‫‪pictureWidth‬‬ ‫ان ﲡﻤﻴﻊ اﺳﻢ اﳌﺘﻐﻴﺮ ﻣﻦ ﻋﺪة ﻛﻠﻤﺎت ﻛﺎﳌﺘﻐﻴﺮ‬ ‫اﺳﺘﺨﺪام ﺣﺮوف ﻻﺗﻴﻨﻴﺔ ﻛﺒﺮى ﻟﺘﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻳﺆدي ﻷﺧﻄﺎء ﻓﻴﻤﺎ‬
‫ﻳﺠﻌﻞ ﻃﺮﻳﻖ ﺑﺮﻣﺠﺘﻚ آﻣﻦ ﻣﻦ اﻻﺧﻄﺎء‪ .‬وﳉﻌﻞ اﳌﺘﻐﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻘﺮاءة‬ ‫ﻟﻮ اﺳﺘﺨﺪﻣﺖ اﳊﺮوف اﻟﺼﻐﺮى ﻟﻺﺷﺎرة ﻟﻠﻤﺘﻐﻴﺮ اﳌﻘﺼﻮد‪ .‬ﻓﺎﺳﻢ‬
‫ﻳﻔﻀﻞ دوﻣ َﺎ اﺳﺘﺨﺪام ﺻﻴﻐﺔ اﳊﺮوف اﻟﻜﺒﺮى ﻛﻔﺎﺻﻞ ﻟﻠﻜﻠﻤﺎت‬ ‫اﳌﺘﻐﻴﺮ ‪ pictureWidth‬ﻟﻴﺲ ﻫﻮ ذاﺗﻪ اﳌﺘﻐﻴﺮ ‪ pictureWIDTH‬أو‬
‫داﺧﻞ اﺳﻢ اﳌﺘﻐﻴﺮ‪ .‬ان اﻟﺘﺰاﻣﻚ ﺑﻬﺬا اﻟﺘﻮﺟﻪ ﻳﻌﺼﻤﻚ ﻣﻦ اﺧﻄﺎء‬ ‫اﳌﺘﻐﻴﺮ ‪.PictureWidth‬‬
‫ﺑﺮﻣﺠﻴﺔ ﻛﺜﻴﺮة‪.‬‬ ‫وﻛﺄﺳﻠﻮب ﻋﺎم ﰎ اﻻﺗﻔﺎق ﻋﻠﻰ ﻣﻨﻬﺞ ﻋﺎم ﻟﺘﺴﻤﻴﺔ اﳌﺘﻐﻴﺮات اﺗُﻔﻖ‬
‫ﻓﻲ ﺣﺎل اﺻﺮارك ﻟﺘﻌﻠﻢ اﻛﺜﺮ ﻣﻦ ﻗﺎﻋﺪة ﻟﺘﺴﻤﻴﺔ اﳌﺘﻐﻴﺮات‪ ،‬أﻛﻤﻞ‬ ‫ﻋﻠﻰ أن ﺗﻜﻮن ﺗﺴﻤﻴﺎت اﳌﺘﻐﻴﺮات ﻣﻦ ﺧﻼل وﺿﻊ اﳊﺮوف اﻟﻜﺒﺮى‬
‫اﻟﻘﺮاءة ﻓﺒﺎﻻﺿﺎﻓﺔ اﻟﻰ اﳊﺮوف ﳝﻜﻨﻚ اﺳﺘﺨﺪام اﻻﻋﺪاد ﺷﺮﻳﻄﺔ اﻻ‬ ‫ﻓﻲ ﻋﺪة ﻣﻮاﻗﻊ ﻣﻦ ﺗﻌﺮﻳﻒ اﺳﻢ اﳌﺘﻐﻴﺮ‪ ،‬ﻓﺎﳊﺮف اﻷول ﻣﻦ اﻟﻜﻠﻤﺔ‬
‫ﺗﻜﻮن ﻓﻲ ﺑﺪاﻳﺔ اﺳﻢ اﳌﺘﻐﻴﺮ‪ .‬ﻛﺬﻟﻚ ﳝﻜﻨﻚ اﺳﺘﺨﺪام اﻟﺴﺎﻃﺮة‬ ‫اﻷوﻟﻰ ﺻﻐﻴﺮ وﻣﺎ ﻳﻠﻴﻪ ﻣﻦ ﻛﻠﻤﺎت ﺗﺎﻟﻴﺔ ﻳﻜﻮن أول ﺣﺮف ﻣﻨﻬﺎ‬
‫اﻟﺴﻔﻠﻴﺔ ”ـ“ ﻟﻠﺒﺪأ ﺑﺎﺳﻢ اﳌﺘﻐﻴﺮ أو اﻟﻔﺼﻞ ﺑﲔ اﻟﻜﻠﻤﺎت اﳌﻜﻮﻧﻪ ﻟﻪ‪.‬‬ ‫ﻛﺒﻴﺮ‪ ،‬ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﺑﺎﳌﺜﺎل ]‪.[2‬‬
‫وﻋﻨﺪ اﻻﻟﺘﺰام ﺑﻬﺬا اﻷﺳﻠﻮب ﳝﻜﻨﻚ أن ﺗﺘﻼﻓﻲ أﺧﻄﺎء اﻟﺒﺮﻣﺠﺔ‬
‫‪٩‬‬
‫]‪[4‬‬
‫;‪pictureWidth = 8‬‬ ‫ﻫﻨﺎك ﻋﺪة ﻃﺮق ﻻﻃﻼق اﻻﺳﻤﺎء‪ ،‬ﻓﻌﻠﻰ ﺳﺒﻴﻞ اﳌﺜﺎل‪:‬‬
‫;‪pictureHeight = 6‬‬
‫* ‪pictureSurfaceArea = pictureWidth‬‬ ‫‪door8k, do8or, do_or‬‬ ‫‪ -‬اﺳﻤﺎء ﻣﺘﻐﻴﺮات ﻣﻘﺒﻮﻟﺔ ‪:‬‬
‫;‪pictureHeight‬‬
‫‪8door‬‬ ‫‪ -‬اﺳﻤﺎء ﻣﺘﻐﻴﺮات ﻏﻴﺮ ﻣﻘﺒﻮﻟﺔ ‪) door 8 :‬ﲢﻮي ﻓﺮاغ( ‪,‬‬
‫واﻻن ﺗﻔﺤﺺ اﳌﺜﺎل ]‪ ، [5‬وﺧﺼﻮﺻ َﺎ اﻟﺴﻄﺮان اﻻوﻻن‪.‬‬ ‫)ﺗﺒﺪأ ﺑﺮﻗﻢ(‪.‬‬
‫]‪[5‬‬
‫;‪pictureWidth = 8‬‬
‫‪ -‬ﻻ ﻳﻨﺼﺢ ﺑﺎﺳﺘﺨﺪاﻣﻬﺎ ‪) Door8 :‬ﺑﺪاﻳﺔ اﻻﺳﻢ ﺣﺮف ﻛﺒﻴﺮ(‬
‫;‪pictureHeight = 4.5‬‬
‫* ‪pictureSurfaceArea = pictureWidth‬‬
‫واﻻن ﺑﻌﺪ ان ﺗﻌﻠﻤﻨﺎ ﻛﻴﻒ ﻧﺴﻨﺪ ﻗﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ‪ ،‬ﳝﻜﻨﻨﺎ اﺟﺮاء‬
‫;‪pictureHeight‬‬ ‫ﺑﻌﺾ اﳊﺴﺎﺑﺎت‪ ،‬ﻟﻨﺘﻔﺤﺺ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﺗﻘﻮم ﺑﺈﺣﺘﺴﺎب‬
‫‪integers‬‬ ‫ﳝﻜﻨﺎ ﺗﺼﻨﻴﻒ اﻻﻋﺪاد ﻋﻤﻮﻣ َﺎ اﻟﻰ ﻧﻮﻋﺎن ‪ :‬ﺻﺤﻴﺤﺔ‬ ‫ﻣﺴﺎﺣﺔ ﺳﻄﺢ اﻟﺼﻮرة‪ .‬ﺑﺎﳌﺜﺎل ]‪.[3‬‬
‫)اﻋﺪاد ﻛﺎﻣﻠﺔ ﻣﺜﻞ }‪ ١‬و ‪ ٢٣‬و ‪ ٤٥٦‬و ‪ ( {٩٩٩‬واﻋﺪاد ﻛﺴﺮﻳﺔ‬ ‫]‪[3‬‬
‫;‪pictureWidth=8‬‬
‫‪ fractional‬ﻣﺜﻞ }‪ ١.٥‬و ‪ .{٧.٢٥‬ﻛﻤﺎ ﺗﺮى ﻓﻲ اﳌﺜﺎل ]‪ [5.1‬و‬ ‫;‪pictureHeight=6‬‬
‫]‪ [5.2‬ﺳﻨﺴﺘﺨﺪم اﻻﻋﺪاد اﻟﺼﺤﻴﺤﺔ ﻻﺟﺮاء اﻟﻌﻤﻠﻴﺎت اﳊﺴﺎﺑﻴﺔ‬ ‫‪pictureSurfaceArea=pictureWidth*pictureHeig‬‬
‫;‪ht‬‬
‫وﺳﻨﺴﺘﺨﺪﻣﻬﺎ اﺣﻴﺎﻧ َﺎ اﺧﺮى ﻟﻠﻌﻤﻠﻴﺎت اﳌﺘﻜﺮرة ﻟﻌﺪد ﻣﻌﲔ ﻣﻦ‬
‫اﳌﺮات اﻧﻈﺮ اﻟﻔﺼﻞ ‪ .٧‬وﺳﻨﺴﺘﺨﺪم اﻻﻋﺪاد اﻟﻜﺴﺮﻳﺔ أو ﻣﺎ ﻳﻄﻠﻖ‬ ‫اﳌﺠﻤﻊ ﻻ ﻳﺼﺪر اي اﻋﺘﺮاض ﻋﻨﺪ وﺟﻮد‬ ‫ﺳﺘﺮى ﻛﻴﻒ ان ّ‬
‫ﻋﻠﻴﻬﺎ ‪ floating-point‬ﻛﻘﻴﻢ ﺣﺴﺎﺑﻴﺔ ﻻﺣﺘﺴﺎب ﻣﺘﻮﺳﻂ اﻫﺪاف‬ ‫ﻓﺮاﻏﺎت)اﳌﺴﺎﻓﺎت( )ﻋﺪا اﻟﺘﻲ ﺗﻮﺟﺪ ﻓﻲ اﺳﻤﺎء اﳌﺘﻐﻴﺮات أو‬
‫ﻼ‪.‬‬‫ﻛﺮة اﻟﺴﻠﺔ ﻣﺜ َ‬ ‫اﻟﻜﻠﻤﺎت اﶈﺠﻮزة‪ ،،‬اﻟﺦ‪ (.‬وﻟﻨﺠﻌﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻳﺴﺮ ﻗﺮاﺋﺔ‪،‬‬
‫ﳝﻜﻨﻨﺎ اﺿﺎﻓﺔ اﻟﻔﺮاﻏﺎت ﻛﺎﳌﺜﺎل ]‪.[4‬‬
‫اﳌﺠﻤﻊ‬
‫ان اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﺑﺎﳌﺜﺎل ]‪ [5‬ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻨﻔﻴﺬ‪ .‬ذﻟﻚ ان ّ‬
‫ﻳﺸﺘﺮط ﻋﻠﻴﻚ اﺧﺒﺎرﻩ ﻣﺴﺒﻘ َﺎ ﺑﺎﺳﻤﺎء اﳌﺘﻐﻴﺮات اﻟﺘﻲ ﺳﺘﺴﺨﺪﻣﻬﺎ‬
‫اﳌﺠﻤﻊ ﲟﻌﺮﻓﺔ ﻧﻮع ﻣﺼﻨﻒ اﳌﺘﻐﻴﺮ ﺳﻮاء ﻛﺎن‬

‫ﳌﺎذا ﻗﺪ ﻳﺮﻏﺐ ّ‬ ‫ﺑﺎﻟﺒﺮﻧﺎﻣﺞ‪ ،‬وان ﺗﻮﺿﺢ ﻟﻪ ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﺗﺮﻏﺐ ﺑﺎﺳﻨﺎد اﻟﻘﻴﻢ‬
‫ﺻﺤﻴﺢ أو ﻛﺴﺮي؟‬ ‫اﻟﻴﻬﺎ‪ ،‬ﻓﻬﻞ ﻫﻲ ﺻﺤﻴﺤﺔ ام ﻛﺴﺮﻳﺔ‪ .‬ﺗﻘﻨﻴ َﺎ ذﻟﻚ ﻣﺎ ﻳﻄﻠﻖ ﻋﻠﻴﻪ‬
‫واﳌﺠﻤﻊ ﻣﺴﺌﻮل‬ ‫اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺘﻐﻴﺮ ”‪“declare a variable‬‬
‫ذﻟﻚ ان ﺑﺮاﻣﺞ اﳊﺎﺳﺒﺎت ﺗﺴﺘﺨﺪم ﺟﺰء ﻣﻦ اﻟﺬاﻛﺮة‪ّ .‬‬
‫ﻋﻦ ﺣﺠﺰ ﺣﻴﺰ اﻟﺬاﻛﺮة اﳌﻨﺎﺳﺐ )ﺑﺎﻟﺒﺎﻳﺖ( ﻟﻜﻞ ﻣﺘﻐﻴﺮ ﻳﺼﺎدﻓﻪ‪ ،‬وﲟﺎ‬ ‫]‪[6‬‬
‫;‪int pictureWidth‬‬
‫ان ﻫﻨﺎك ﻣﺼﻨﻔﺎت واﻧﻮاع ﻣﺘﻌﺪدة ﻟﻠﺒﻴﺎﻧﺎت ﻣﺜﻞ ﻣﺎ رأﻳﻨﺎ ﻣﻦ ﺻﺤﻴﺤﺔ‬ ‫;‪float pictureHeight, pictureSurfaceArea‬‬
‫وﻛﺴﺮﻳﺔ‪ ،‬ﻓﺎن ﻛﻞ ﻧﻮع ﻳﺴﺘﻬﻠﻚ ﻗﻴﻤﺔ ﻣﺨﺘﻠﻔﺔ ﻋﻦ اﻵﺧﺮ اﺛﻨﺎء ﺣﺠﺰ‬ ‫;‪pictureWidth = 8‬‬
‫ﻓﺎﳌﺠﻤﻊ ﺑﺤﺎﺟﺔ ﳌﻌﺮﻓﺔ ﺗﻠﻚ اﻟﻘﻴﻢ ﺣﺘﻰ‬ ‫اﻟﺬاﻛﺮة أو اﺛﻨﺎء اﻟﻌﺮض‪ّ ،‬‬ ‫* ‪pictureSurfaceArea = pictureWidth‬‬
‫ﻳﺘﻤﻜﻦ ﻣﻦ اﻟﻘﻴﺎم ﺑﺎﳊﺠﺰ واﻻﻇﻬﺎر اﻟﺼﺤﻴﺢ ﻟﻜﺎﻓﺔ اﳌﺼﻨﻔﺎت‪.‬‬ ‫;‪pictureHeight‬‬
‫ﻓﻲ اﻟﺴﻄﺮ ]‪ [6.1‬ﻳﺪﻟﻨﺎ ‪ int‬ﻋﻠﻰ ان ﺗﺼﺮﻳﺢ ﻧﻮع اﳌﺘﻐﻴﺮ ‪pictureWidth‬‬

‫ﻣﺎذا ﻟﻮ اﻧﻨﺎ ﻧﺘﻌﺎﻣﻞ ﻣﻊ اﻋﺪاد ﺧﻴﺎﻟﻴﺔ أو اﻋﺪاد ذات دﻗﺔ ﻋﺎﻟﻴﺔ؟‬
‫ﻟﻦ ﻳﺴﻌﻬﺎ ان ُﲢﺘﻮى ﺿﻤﻦ ﺗﻠﻚ اﳌﺴﺎﺣﺎت اﻟﺒﺴﻴﻄﺔ اﶈﺠﻮزة‬ ‫ﻧﺼﺮح ﻋﻦ ﻣﺘﻐﻴﺮان‬‫او ﻣﻦ ﻧﻮع ﻋﺪدي ﺻﺤﻴﺢ وﻓﻲ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ّ‬
‫اﳌﺠﻤﻊ‪ ،‬اﻟﻴﺲ ﻛﺬﻟﻚ؟‬ ‫ﻣﻦ ﻗﺒﻞ ّ‬ ‫دﻓﻌﺔ واﺣﺪة‪ .‬ﻣﻊ ﻓﺼﻞ اﳌﺘﻐﻴﺮات ﺑﻮاﺳﻄﺔ اﻟﻔﺎﺻﻠﺔ‪ .‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ‬
‫ﻳﺼﺮح ﻋﻦ ان ﻛﻼ اﳌﺘﻐﻴﺮان ﻣﺼﻨﻔﺎن‬
‫ذﻟﻚ ﻧﺮى اﻻﻳﻌﺎز ﺑﺎﻟﺴﻄﺮ ]‪ّ [6.2‬‬
‫ﻧﻌﻢ ذﻟﻚ ﺻﺤﻴﺢ‪ .‬وﺗﻮﺟﺪ اﺟﺎﺑﺘﺎن ﻟﻬﺬا اﻟﺴﺆال‪ :‬اﻻﺟﺎﺑﺔ اﻻوﻟﻰ‬
‫ﻛﻤﺘﻐﻴﺮات ﻛﺴﺮﻳﺔ‪ ،‬اي ارﻗﺎم ذات ﺟﺰء ﻛﺴﺮي‪.‬‬
‫ﺗﻘﻮل‪ ،‬ان ﻛﻼ ﻣﻦ اﻻﻋﺪاد اﻟﺼﺤﻴﺤﺔ واﻻﻋﺪاد اﻟﻜﺴﺮﻳﺔ ﻟﺪﻳﻬﻤﺎ‬
‫ﳝﻜﻨﺎﻫﻤﺎ ﻣﻦ ﺣﻔﻆ اﻋﺪاد اﻻﻛﺒﺮ )او ﺗﻠﻚ اﻋﺪاد ذات‬ ‫ﻇﻬﻴﺮﻳﻦ ّ‬ ‫ﻓﻲ ﻫﺬﻩ اﳊﺎﻟﺔ ﻣﻦ اﻟﺴﺬاﺟﺔ ان ﻳﻜﻮن اﳌﺘﻐﻴﺮ ‪ pictureWidth‬ﻣﻦ‬
‫اﻟﺪﻗﺔ اﻟﻌﺎﻟﻴﺔ(‪.‬‬ ‫ﻧﻮع ﺗﺼﻨﻴﻔﺎت اﺧﺮى ﻏﻴﺮ اﻟﻌﺪدﻳﺔ )اﻟﺼﺤﻴﺤﺔ ﻣﻨﻬﺎ أو اﻟﻜﺴﺮﻳﺔ(‪.‬‬
‫ﻋﻠﻰ ﻛﻞ ﺣﺎل ﺳﺘﺮى ان ﻣﺠﻤﻮع ﺿﺮب اﻻﻋﺪاد اﻟﺼﺤﻴﺤﺔ اﻟﺘﺼﻨﻴﻒ‬
‫ﻓﺎﻏﻠﺐ اﻧﻈﻤﺔ اﻟﺘﺸﻐﻴﻞ ﺗﻌﺘﻤﺪ أﻧﻮاﻋ َﺎ ﻣﻦ اﺻﻨﺎف اﻻﻋﺪاد اﻟﺘﺨﻴﻠﻴﺔ‬
‫ﻣﻊ اﻧﻮاع ﻛﺴﺮﻳﺔ اﻟﺘﺼﻨﻴﻒ ﻳﻨﺘﺞ ﻋﻨﻪ ﻧﺎﰋ ﻣﻦ ﻧﻮع ﻛﺴﺮي‪ ،‬وذﻟﻚ‬
‫اﻟﻜﺒﻴﺮة ﻛﻨﻮع أﻋﺪاد ‪ long long‬اﳌﺴﺘﺨﺪم ﻟﻼﻋﺪاد اﻟﺼﺤﻴﺤﺔ‬
‫ﻫﻮ ﺳﺒﺐ ﺗﺼﻮﻳﺤﻨﺎ ﻋﻦ ﻧﻮع اﳌﺘﻐﻴﺮ ‪ pictureSurfaceArea‬ﻛﻤﺘﻐﻴﺮ‬
‫وﻧﻮع ‪ double‬اﳌﺴﺘﺨﺪم ﻟﻼﻋﺪاد اﻟﻜﺴﺮﻳﺔ‪ .‬وﻟﻜﻦ ﺣﺘﻰ ﺗﻠﻚ‬
‫ﻛﺴﺮي ﺑﺎﻟﺴﻄﺮ ]‪.[6.2‬‬
‫اﻟﺘﺎﻟﻴﺔ‪ ،‬وﻫﻲ ﺗﻌﺮف رﺳﻤﻴ َﺎ ﺑﺎﺳﻢ اﳌُﻌﺎ ِﻣﻼت اﳊﺴﺎﺑﻴﺔ ﻻﻧﻬﺎ ﺗﻘﻮم‬ ‫ﳝﻜﻨﻬﺎ ان ﺗُﻐﺮق ﺣﻴﺰﻫﺎ ﻣﻦ اﳌﻞء‪ ،‬ﳑﺎ ﻳﻘﻮدﻧﺎ ﻟﻼﺟﺎﺑﺔ ذات اﻟﺸﻖ‬
‫ﺑﺎﺟﺮاء اﻟﻌﻤﻠﻴﺎت اﳊﺴﺎﺑﻴﺔ اﻻﺳﺎﺳﻴﺔ‪.‬‬ ‫اﻟﺜﺎﻧﻲ‪ :‬ﺣﻴﺚ اﻧﻪ ﻣﻦ واﺟﺒﻚ ﻛﻤﺒﺮﻣﺞ ان ﺗﺘﻨﺒﻪ ﳌﺜﻞ ﻫﺬﻩ اﳌﺸﺎﻛﻞ‪.‬‬
‫‪ +‬ﻣﻌﺎﻣﻞ اﳉﻤﻊ‬ ‫ﻋﻠﻰ ﻛﻞ ﺣﺎل‪ ،‬ﻫﺬﻩ اﳌﺸﻜﻠﺔ ﻏﻴﺮ ﻣﻨﺎﺳﺒﻪ ﻻن ﺗﻨﺎﻗﺶ ﻓﻲ اﻟﻔﺼﻞ‬
‫‪ -‬ﻣﻌﺎﻣﻞ اﻟﻄﺮح‬ ‫اﻻول ﻣﻦ ﻛﺘﺎب ﻟﻠﻤﺒﺘﺪﺋﲔ‪.‬‬
‫‪ /‬ﻣﻌﺎﻣﻞ اﻟﻘﺴﻤﺔ‬
‫* ﻣﻌﺎﻣﻞ اﻟﻀﺮب‬
‫ﻟﻠﻌﻠﻢ ﳝﻜﻦ ﻟﻘﻴﻤﺔ ﻛﻼ اﻟﻨﻮﻋﲔ )اﻟﺼﺤﻴﺢ واﻟﻜﺴﺮي( ان ﺗﻜﻮن‬
‫ﻼ‪ .‬ﻓﻲ ﺣﺎل ﻳﻘﻴﻨﻚ ﻣﻦ ان اﻟﻘﻴﻤﺔ ﻟﻦ‬ ‫ﺳﺎﻟﺒﺔ‪ ،‬ﻛﺤﺴﺎﺑﻚ اﻟﺒﻨﻜﻲ ﻣﺜ َ‬
‫ﺑﺎﺳﺘﺨﺪام ﺗﻠﻚ اﳌﻌﺎﻣﻼت‪ ،‬ﳝﻜﻨﻨﺎ اﺟﺮاء ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ ﻣﺘﻨﻮﻋﺔ‪.‬‬ ‫ﺗﻜﻮن ﺳﺎﻟﺒﺔ‪ ،‬ﳝﻜﻨﻚ ﻋﻨﺪﻫﺎ زﻳﺎدة اﳌﺪى اﳌﻘﺒﻮل ﻟﻠﻘﻴﻤﺔ اﳌﺘﺎﺣﺔ‪.‬‬
‫ﻓﻲ ﺣﺎل اﻟﻘﻴﺖ ﻧﻈﺮة ﻋﻠﻰ ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ ﺑﺎﺣﺪ ﻛﺘﺐ ﺑﺮﻣﺠﺔ‬ ‫]‪[7‬‬
‫‪،Objective-C‬ﺳﻴﺼﺎدﻓﻚ ﺗﺮﻣﻴﺰ ﻋﺠﻴﺐ‪ ،‬وﻏﺎﻟﺒ َﺎ ان ﻛﺎﺗﺐ اﻟﺸﻔﺮة‬ ‫;‪unsigned int chocolateBarsInStock‬‬
‫ﻛﺎﺗﺐ ﻛﺴﻮل‪ .‬ﻓﺒﺪﻻ ﻣﻦ ﻛﺘﺎﺑﺔ‬ ‫اﻧﺖ ﺗﻌﻠﻢ ﻳﻘﻴﻨ َﺎ اﻧﻪ ﻟﻦ ﻳﻮﺟﺪ ﻟﺪﻳﻚ ﻟﻮح ﺷﻮﻛﻮﻻﺗﻪ ﺑﻘﻴﻤﺔ ﺳﺎﻟﺒﺔ‪،‬‬
‫;‪x = x + 1‬‬
‫ﻟﺬا ﳝﻜﻨﻚ اﺳﺘﺨﺪام ﺗﻨﻮﻳﻪ ‪ unsigned int‬اﳌﻮﺿﺢ ﺑﺎﳌﺜﺎل ]‪ .[7‬ان‬
‫ﻣﺜﻞ ]‪ [9‬أو ]‪[10‬‬ ‫ﳝﻴﻞ اﳌﺒﺮﻣﺠﻮن ﻻﺳﺘﺨﺪام ﺷﻲء ﻣﻦ ﻫﺬا اﻟﻘﺒﻴﻞ‬ ‫اﻻرﻗﺎم اﻟﻐﻴﺮ ﺳﺎﻟﺒﺔ ﳝﻜﻨﻬﺎ ان ﺗﻜﻮن ﺑﻘﻴﻤﺔ اﻛﺒﺮ أو ﺗﺴﺎوي ﺻﻔﺮ‪.‬‬
‫]‪[9‬‬
‫;‪x++‬‬
‫ﳝﻜﻨﻚ دوﻣ َﺎ اﻻﻋﻼن ﻋﻦ اﳌﺘﻐﻴﺮ واﺳﻨﺎد ﻗﻴﻤﺘﻪ دﻓﻌﺔ واﺣﺪة ﺣﻴﺚ‬
‫ﳝﻜﻦ ﻟﻬﺬا اﻟﺴﻄﺮ ﺗﻮﻓﻴﺮ ﺑﻀﻌﺔ اﺳﻄﺮ ﻣﻦ اﻻﺳﻨﺎدات‪ .‬ﻛﻤﺎ ﻫﻮ‬
‫]‪[10‬‬
‫;‪++x‬‬ ‫ﻣﻮﺿﺢ ﲟﺜﺎل]‪. [8‬‬
‫]‪[8‬‬
‫ﻓﻲ ﻛﻠﺘﺎ اﳊﺎﻟﺘﲔ ذﻟﻚ اﻻﻳﻌﺎز ﻳﻌﻨﻲ‪ :‬ﻗﻢ ﺑﺰﻳﺎدة ﻗﻴﻤﺔ ‪ x‬ﲟﻘﺪار ‪.١‬‬ ‫;‪int x = 10‬‬
‫ﻓﻲ ﺣﺎﻻت ﺧﺎﺻﺔ ﻳﺠﺪر اﻻﻧﺘﺒﺎﻩ ﳌﻮﺿﻊ ‪ ++‬ﺳﻮاء ﻗﺒﻞ ام ﺑﻌﺪ اﳌﺘﻐﻴﺮ‬ ‫;‪float y= 3.5, z = 42‬‬
‫‪ .‬ﺗﻔﺤﺺ اﳌﺜﺎﻻن اﻟﺘﺎﻟﻴﺎن ]‪ [11‬و ]‪[12‬‬ ‫ﻓﻲ اﳌﺜﺎل اﻟﺴﺎﺑﻖ‪ ،‬ﻗﻤﻨﺎ ﺑﺎﺟﺮاء ﻋﻤﻠﻴﺔ ﺿﺮب ﻣﺴﺘﺨﺪﻣﲔ اﻟﺮﻣﻮز‬
‫اﻟﻀﺮب * واﻟﻘﺴﻤﺔ ‪َ /‬‬

‫اوﻻ ﻗﺒﻞ ﻋﻤﻠﻴﺎت اﳉﻤﻊ واﻟﻄﺮح‪.‬‬ ‫]‪[11‬‬
‫;‪x = 10‬‬
‫ان ﺗﺎﰋ ‪ ٤+٣*٢‬ﺳﻴﻜﻮن ‪ .١٠‬أﻣﺎ ﺑﺎﺳﺘﺨﺪام اﻻﻗﻮاس ﻓﺈﻧﻨﺎ ﻧﻘﻮم‬ ‫;)‪y = 2 * (x++‬‬
‫ﺑﺈﺟﺒﺎر ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺪﻧﻴﺎ ﻗﺒﻞ اﻟﻌﻤﻠﻴﺎت اﻟﻌﻠﻴﺎ ﻟﻴﻜﻮن ﻧﺎﰋ‬ ‫]‪[12‬‬
‫;‪x = 10‬‬
‫ﻋﻤﻠﻴﺔ ‪ (٣+٤)*٢‬ﻳﺴﺎوي ‪.١٤‬‬ ‫;)‪y = 2 * (++x‬‬
‫أﻣﺎ اﻟﻘﺴﻤﺔ ﻓﺈﻧﻬﺎ ﻋﻤﻠﻴﺔ ﺗﺴﺘﺪﻋﻲ ﺑﻌﺾ اﻻﻧﺘﺒﺎﻩ‪ ،‬ﺳﺒﺐ ذﻟﻚ ﻳﻌﻮد‬ ‫ﻓﻔﻲ اﳌﺜﺎل ]‪ [11‬وﺑﻌﺪ ﻛﻞ ﻣﺎ ﻗﻴﻞ‪ ،‬ﺳﺘﻜﻮن ﻗﻴﻤﺔ ‪ y‬ﻣﺴﺎوﻳﺔ ﻟـ ‪٢٠‬‬
‫ﻟﻼﺧﺘﻼف اﻻﺳﺎﺳﻲ ﻋﻨﺪ اﺟﺮاءﻫﺎ ﻋﻠﻰ اﻋﺪاد ﺻﺤﻴﺤﺔ أو اﻋﺪاد‬ ‫ﺑﻴﻨﻤﺎ ‪ x‬ﺗﺴﺎوي ‪ .١١‬ﻋﻠﻰ اﻟﻨﻘﻴﺾ ﻣﻦ ذﻟﻚ ﻓﻲ اﻻﻳﻌﺎز ]‪,[12.2‬‬
‫ﻛﺴﺮﻳﺔ‪ .‬ﺗﻔﺤﺺ اﳌﺜﺎﻟﲔ ]‪ [14, 15‬اﻟﺘﺎﻟﻴﲔ‪:‬‬ ‫‪،‬ﺳﻴﺘﻢ اﺿﺎﻓﺔ ﻗﻴﻤﺔ ‪ x‬ﲟﻘﺪار ‪ ١‬ﻗﺒﻞ اﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﺑـ ‪،٢‬‬
‫]‪[14‬‬
‫;‪int x = 5, y = 12, ratio‬‬
‫ﻟﺬا ﻓﻲ اﻟﻨﻬﺎﻳﺔ ﺳﺘﻜﻮن ‪ x‬ﺑﻘﻴﻤﺔ ‪ ١١‬و ﻗﻴﻤﺔ ‪ y‬ﻣﺴﺎوﻳﺔ ﻟـ ‪ .٢٢‬ان‬
‫;‪ratio = y / x‬‬ ‫اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻓﻲ اﳌﺜﺎل ]‪ [12‬ﻣﻄﺎﺑﻘﺔ ﻟﻠﻤﺜﺎل ]‪.[13‬‬
‫]‪[15‬‬ ‫]‪[13‬‬
‫;‪float x = 5, y = 12, ratio‬‬ ‫;‪x = 10‬‬
‫;‪ratio = y / x‬‬ ‫;‪x++‬‬
‫;‪y = 2 * x‬‬
‫ﻓﻲ اﳌﺜﺎل اﻻول ﻛﺎﻧﺖ اﻟﻘﻴﻤﺔ اﻟﻨﺎﲡﺔ ﺗﺴﺎوي ‪ .٢‬ﺑﻴﻨﻤﺎ ﻓﻲ اﳌﺜﺎل‬
‫ﻣﻦ اﻟﻮاﺿﺢ ان اﳌﺒﺮﻣﺞ ﻗﺪ ﻗﺎم ﺑﺪﻣﺞ ﻋﻤﻠﻴﺘﲔ ﺣﺴﺎﺑﻴﺘﲔ ﻓﻲ ﺧﻄﻮة‬
‫اﻟﺜﺎﻧﻲ ﺳﺘﻜﻮن اﻟﻘﻴﻤﺔ اﻟﻨﺎﲡﺔ ﻫﻲ اﻟﺘﻲ ﺗﻮﻗﻌﺘﻬﺎ اي ‪٢٫٤‬‬
‫واﺣﺪة‪ .‬وﺷﺨﺼﻴ َﺎ اﻋﺘﻘﺪ ان ﻫﺬا اﻻﺳﻠﻮب ﻳﺰﻳﺪ ﻣﻦ ﺻﻌﻮﺑﺔ ﻗﺮاءة‬
‫وﻓﻬﻢ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﻓﻲ ﺣﺎل اﻋﺘﻤﺎدك ﻟﺘﻠﻚ اﳌﺨﺘﺼﺮات ﻻ ﺑﺄس ﺑﺬﻟﻚ‪،‬‬
‫وﻟﻜﻦ ﺗﻨﺒﻪ ﻟﻮﺟﻮد اﺧﻄﺎء ﺑﺮﻣﺠﻴﺔ ﻣﺤﺘﻤﻠﺔ ﻫﻨﺎ وﻫﻨﺎك‪.‬‬
‫ﻗﺪ ﺗﻜﻮن اﳌﻌﻠﻮﻣﺎت اﻟﺘﺎﻟﻴﺔ ﻗﺪﳝﺔ‪ ،‬وﻟﻜﻦ اﻻﻗﻮاس ﲢﺪد ﺗﺮﺗﻴﺐ‬
‫إﺟﺮاء اﻟﻌﻤﻠﻴﺎت اﳊﺴﺎﺑﻴﺔ‪ .‬ﻓﻤﻦ اﻟﻄﺒﻴﻌﻲ ان ﻳﺘﻢ اﺟﺮاء ﻋﻤﻠﻴﺎت‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻻﺗﻬﻤﻞ اﻟﺘﻌﻠﻴﻘﺎت!!‬
‫ﻻﺗﻬﻤﻞ اﻟﺘﻌﻠﻴﻘﺎت!!‬
‫ﻧﺴﺘﻄﻴﻊ ﺑﺎﺳﺘﺨﺪام أﺳﻤﺎء ذات دﻻﻟﺔ ﻟﻠﻤﺘﻐﻴﺮات ان ﳒﻌﻞ ﻣﻦ‬
‫اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻧﺼﻮﺻ َﺎ ﻗﺎﺑﻠﺔ ﻟﻠﻘﺮاءة واﻟﺘﻔﺴﻴﺮ اﳌﻨﻄﻘﻲ]‪.[1‬‬
‫]‪[1‬‬
‫‪float pictureWidth, pictureHeight,‬‬
‫;‪pictureSurfaceArea‬‬
‫;‪pictureWidth = 8.0‬‬
‫وﺑﺎﻟﺮﻏﻢ ﻣﻦ اﻧﻨﺎ ﻣﻠﺘﺰﻣﲔ ﺑﻌﺮض اﻣﺜﻠﺔ ﺑﻌﺪد ﻣﺤﺪود ﻣﻦ اﻻﺳﻄﺮ‪،‬‬

‫اﻻ ان اﻟﺒﺮاﻣﺞ اﻟﻜﺎﻣﻠﺔ اﻟﺘﻰ ﺗﺆدي أﻋﻤﺎل ذات ﻗﻴﻤﺔ ﻏﺎﻟﺒ َﺎ ﻣﺎ ﺗﻜﻮن‬
‫اﳌﻮﺻﻔﺔ اﻃﻮل ﻣﻦ ذﻟﻚ ﺑﻜﺜﻴﺮ‪.‬‬
‫ﺷﻔﺮﺗﻬﺎ اﻟﺒﺮﻣﺠﻴﺔ ّ‬
‫ان ﺗﻮﺻﻴﻒ وﺗﻮﺛﻴﻖ ﺷﻔﺮة اﻟﺒﺮﻧﺎﻣﺞ ﻋﻤﻠﻴﺔ ﺑﺎﻟﻐﺔ اﻻﻫﻤﻴﺔ‪ ،‬ﻓﻬﻲ ﲤﺜﻞ‬
‫اﻟﻬﻢ اﻻﻛﺒﺮ ﻣﻦ ﻣﺠﺮد اﳊﺮص ﻋﻠﻰ ان اﻟﺒﺮﻧﺎﻣﺞ ﻳﻌﻤﻞ ﺑﺎﻟﺸﻜﻞ‬
‫ﺻﺤﻴﺢ‪ .‬ﻓﺒﻌﺪ ﻓﺘﺮة ﻣﻦ اﻟﺰﻣﻦ ﻗﺪ ﺗﺮﻏﺐ ﺑﺘﻐﻴﻴﺮ ﺟﺰﺋﻴﺔ ﻣﻦ اﻟﺸﻔﺮة‪،‬‬
‫ﻋﻨﺪﻫﺎ ﺳﺘﺠﺪ ان ﻫﺬﻩ اﻟﺘﻌﻠﻴﻘﺎت واﳌﻼﺣﻈﺎت ﺗﻠﻌﺐ دوراَ ﻣﻬﻤﺎ‬
‫ﻟﺘﻮﺛﻴﻖ واﺳﺘﻴﻌﺎب ﻣﻬﻤﺔ ﻫﺬا اﳉﺰء ﻣﻦ اﻟﺸﻔﺮة‪ ،‬وﳌﺎذا اوﺟﺪت ‪-‬‬
‫اﻟﺸﻔﺮة‪ -‬ﺑﺎﳌﻘﺎم اﻻول‪.‬‬
‫‪١٥‬‬
‫ﻻﺗﻬﻤﻞ اﻟﺘﻌﻠﻴﻘﺎت!!‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻧﻨﺼﺤﻚ ﺑﺠﺪﻳﺔ ان ﺗﻮﺛﻖ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬اﻧﻬﺎ اﺳﺘﺜﻤﺎر‬

‫ﻻ ﳝﻜﻨﻚ اﻟﺘﻘﻠﻴﻞ ﻣﻦ ﻗﻴﻤﺔ اﻟﺘﻌﻠﻴﻘﺎت‪ ،‬ﻓﻬﻴﺎ ﻣﻔﻴﺪة ﺟﺪاَ ﻟﺸﺮح‬ ‫ﻣﺴﺘﻘﺒﻠﻲ‪ .‬ﻓﺒﺎﻻﺿﺎﻓﺔ اﻟﻰ ذﻟﻚ ﺗﻠﻌﺐ ﻋﻤﻠﻴﺔ اﻟﺘﻮﺛﻴﻖ دورﻫﺎ اﻟﺮﺋﻴﺲ‬
‫ﺗﺪاﺧﻞ ﺧﻄﻮات اﻟﺒﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ ﺻﺮﻳﺤﺔ وواﺿﺤﺔ‪ .‬ان ﺷﺮح ﻣﺎ‬ ‫ﻣﺘﻰ ﻣﺎ ﻗﻤﺖ ﲟﺸﺎرﻛﺔ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ ﻣﻊ ﻣﺒﺮﻣﺠﲔ اﺧﺮﻳﻦ‪.‬‬
‫ﺗﻘﻮم ﺑﻪ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﳝّﻜﻦ اﳌﺒﺮﻣﺠﲔ ﻣﻦ ﲢﺪﻳﺪ اﳉﺰء اﻻوﻟﻰ‬ ‫وﻟﻌﻤﻞ ﻣﻠﺤﻮﻇﺔ أو ﺗﻌﻠﻴﻖ ﺿﻌﻬﺎ ﺑﻌﺪ ﺳﻄﺮﻳﻦ ﻣﺎﺋﻠﲔ‪.‬‬
‫ﺑﺎﻟﺘﻔﺤﺺ واﳌﻌﺎﻳﻨﺔ‪.‬‬ ‫‪// This is a comment‬‬
‫ﻳﺠﺪر ﺑﻚ اﺳﺘﺨﺪام اﻟﺘﻌﻠﻴﻘﺎت ﻟﺸﺮح اﻻواﻣﺮ واﻟﺘﻌﻠﻴﻤﺎت اﻻﺟﺮاﺋﻴﺔ‬ ‫ٌﻳﻈﻬﺮ ‪ Xcode‬اﻟﺘﻌﻠﻴﻘﺎت ﺑﺎﻟﻠﻮن اﻻﺧﻀﺮ‪ .‬ﻣﺘﻰ ﻣﺎ ﻛﺎن اﻟﺘﻌﻠﻴﻖ‬
‫ﻃﻮﻳﻞ وﳝﺘﺪ ﻻﻛﺜﺮ ﻣﻦ ﺳﻄﺮ‪ ،‬ﺿﻌﻪ ﻣﺎ ﺑﲔ *‪ /‬و‪*/‬‬
‫اﻟﺘﻲ ﺗ ّﻮﺻﻒ وﺗﺸﺮح اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺣﻴﺚ ﻳﺴﺘﺤﻴﻞ ﺑﺪوﻧﻬﺎ ﻓﻬﻢ وﺗﻔﺴﻴﺮ‬
‫دور ﺑﻌﺾ ﺗﻠﻚ اﻻﺟﺰاء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ اﻻﻋﺘﻤﺎد ﻋﻠﻰ اﻟﺸﻔﺮة‬ ‫‪/* This is a comment‬‬
‫‪extending over two lines */‬‬
‫ﻓﻘﻂ‪.‬‬
‫ﺳﻨﺘﻄﺮق ﻟﻌﻤﻠﻴﺎت ﺗﻘﺼﻲ اﺧﻄﺎء اﻟﺒﺮﻧﺎﻣﺞ ﻗﺮﻳﺒ َﺎ‪ ،‬ﺣﻴﺚ ﻳﻮﻓﺮ ﻟﻚ‬
‫ﻛﻤﺜﺎل ﻟﺒﺮﻧﺎﻣﺞ ﺣﺴﺎﺑﻲ ﻳﺴﺘﺨﺪم ﻣﻌﺎﻣﻞ رﻳﺎﺿﻲ ﻣﺒﻨﻲ ﻣﻦ ﺧﻼل‬ ‫‪ Xcode‬ﻋﺪد ﻣﻦ اﻻﻣﻜﺎﻧﻴﺎت اﻟﻔﺮﻳﺪة‪ .‬وان اﺣﺪ اﻟﻄﺮق اﻻﻗﺪم ﻓﻲ‬
‫وﺻﻒ ﺗﻔﺼﻴﻠﻲ وارد ﺑﺄﺣﺪ اﻟﻜﺘﺐ‪ ،‬ﻳﺠﺪر ﺑﻚ اﻟﺘﻨﻮﻳﻪ ﻋﻦ ذﻟﻚ‬ ‫اﻟﺘﻘﺼﻲ ﻳﻄﻠﻖ ﻋﻠﻴﻬﺎ اﻟﻼﺗﻌﻠﻴﻘﺎت ‪ outcommenting‬وذﻟﻚ ﻣﻦ‬
‫اﻻرﺗﺒﺎط ﺑﺘﻌﻠﻴﻘﺎت داﺧﻞ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ‪ .‬وﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن‬ ‫ﺧﻼل ادراج ﺟﺰء ﻣﻦ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﺑﲔ ﺗﻠﻚ اﻻﺳﻄﺮ اﳌﺎﺋﻠﺔ ﺣﺘﻰ‬
‫ﻳﻔﻀﻞ اﻟﻘﻴﺎم ﺑﻌﻤﻞ ﻛﺘﺎﺑﺔ اﻟﺘﻌﻠﻴﻘﺎت ﻗﺒﻞ اﻟﺒﺪء اﻟﻔﻌﻠﻲ ﺑﻜﺘﺎﺑﺔ‬ ‫ﺗﺮى ﻛﻴﻒ ﺗﻌﻤﻞ ﺑﻘﻴﺔ اواﻣﺮ اﻟﺸﻔﺮة‪.‬‬
‫اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ .‬ﺗﻠﻚ اﻟﺘﻌﻠﻴﻘﺎت ﺗﻌﻴﻨﻚ اﺛﻨﺎء ﺑﻨﺎء اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻫﺬا اﻻﺳﻠﻮب ّ‬
‫وﺳﺘﻜﻮن ﻧﺘﺎﺋﺞ اﳌﻌﺎﻳﻨﺔ اﻓﻀﻞ واﻳﺴﺮ‪.‬‬ ‫ﳝﻜﻨﻚ ﻣﻦ ﺗﻘﺼﻲ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ﻣﺘﻰ ﻣﺎ ﻛﺎن‬
‫اﳉﺰء اﶈﺠﻮب ﻣﺘﺴﺒﺒ َﺎ ﻓﻲ ﺗﻠﻚ اﻻﺧﻄﺎء‪ ،‬ﻛﺄن ﲢﺠﺐ ﻗﻴﻤﺔ اﺣﺪ‬
‫ان اﻣﺜﻠﺔ اﻟﻜﺘﺎب ﻟﻴﺴﺖ ﺑﺎﻟﻀﺮورة ﻣﻮﺛﻘﺔ ﻛﻤﺎ ﻫﻲ اﳊﺎل داﺋﻤ َﺎ‪،‬‬ ‫اﳌﺘﻐﻴﺮات‪ ،‬ﺣﻴﺚ ﳝﻜﻨﻚ ﺣﺠﺒﻬﺎ ﻣﺆﻗﺘ َﺎ‪ ،‬ﺛﻢ اﺳﻨﺎد ﻗﻴﻤﺔ اﺧﺘﺒﺎرﻳﺔ‬
‫ذﻟﻚ اﻧﻬﺎ ﺗﺮد إﻟﻴﻚ وﻫﻲ ﻣﺤﺎﺻﺮة ﺑﺎﻟﺸﺮح واﻟﺘﻮﺿﻴﺢ‪.‬‬ ‫ﻟﺘﺠﺮﺑﺔ اداء ﺑﻘﻴﺔ اﺟﺰاء اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣﻊ ﺗﻠﻚ اﻟﻘﻴﻤﺔ اﻻﺧﺘﺒﺎرﻳﺔ‪.‬‬
‫‪١٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺪاﻻت اﻟﻮﻇﻴﻔﻴﺔ‬
‫اﻟﺪاﻻت اﻟﻮﻇﻴﻔﻴﺔ‬
‫ان اﻃﻮل ﺷﻔﺮة رأﻳﺘﻬﺎ ﺣﺘﻰ اﻻن ﻣﻜﻮﻧﺔ ﻣﻦ ﺧﻤﺴﺔ اﺳﻄﺮ‪ .‬ﻛﺜﻴﺮ ﻣﻦ‬
‫اﻟﺒﺮاﻣﺞ ﻣﻜﻮﻧﺔ ﻣﻦ ﻋﺪة اﻻف ﻣﻦ اﻻﺳﻄﺮ و ﻗﺮاﺋﺘﻬﺎ ﺗﻜﻮن ﻣﺪﻋﺎة‬
‫ﻟﻠﻤﻠﻞ‪ ،‬دﻋﻨﺎ ﻧﻨﺎﻗﺶ ﻃﺒﻴﻌﺔ ﻟﻐﺔ ‪ Objective-C‬ﻓﻲ ﺗﺮﺗﻴﺒﻬﺎ ﻟﻌﻨﺎﺻﺮ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻣﺒﻜﺮ‪.‬ﻓﻤﺘﻰ ﻣﺎ ﻛﺎن اﻟﺒﺮﻧﺎﻣﺞ ﻣﻜﻮن ﻣﻦ ﻋﺪة‬
‫اﻻف ﻣﻦ اﻻﺳﻄﺮ واﻻواﻣﺮ اﳌﺘﻼﺣﻘﺔ‪ ،‬ﺗﻜﻮن ﻧﺴﺒﺔ ﺗﻘﺼﻲ اﻻﺧﻄﺎء‬
‫اﻟﺒﺮﻣﺠﻴﺔ اﻛﺜﺮ ﺻﻌﻮﺑﺔ‪.‬‬
‫إن ذﻟﻚ ﺳﻴﺆدي ﻟﻮﺟﻮد ﺳﻠﺴﻠﺔ ﻣﺘﻮاﺻﻠﺔ ﻣﻦ اﻻواﻣﺮ اﳌﺘﻤﺎﺛﻠﺔ و‬
‫اﳌﺘﻜﺮرة ﺑﺤﻴﺚ ﺗﺘﺸﺎﺑﻚ ﺑﻌﺪة اﻣﺎﻛﻦ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬وﻫﺬا اﻟﺘﺸﺎﺑﻚ‬
‫ﺑﲔ اﻻواﻣﺮ اﺷﺒﺔ ﻣﺎ ﻳﻜﻮن ﺑﺼﺤﻦ ﻣﻌﻜﺮوﻧﺔ ‪ .spaghetti code‬وﻣﺘﻰ‬
‫ﻣﺎﻛﺎن ﻫﻨﺎك ﺧﻄﺎء ﺑﺮﻣﺠﻲ ﻓﻲ اﺣﺪ ﺗﻠﻚ اﻟﺴﻼﺳﻞ‪ ،‬ﺳﻴﺘﻄﻠﺐ‬
‫اﺻﻼﺣﻬﺎ ﺗﻜﺮار ﻋﻤﻠﻴﺔ اﻻﺻﻼح ﺑﺎي ﻣﻮﻗﻊ ﺗﻜﺮر ورودﻫﺎ ﻓﻴﻪ‪ .،‬اﻧﻪ‬
‫اﻟﻜﺎﺑﻮس ﺑﻌﻴﻨﺔ! ﻓﻤﻦ اﻟﺴﻬﻞ ﺟﺪاَ ان ُﻳﻨﺴﻰ ﺗﻌﺪﻳﻞ ﺟﺰء أو اﺛﻨﺎن‬
‫اﺛﻨﺎء ﻋﻤﻠﻴﺔ اﻟﺘﺼﺤﻴﺢ!‬
‫ﻟﺬا ﻓﻜﺮ اﳌﺒﺮﻣﺠﻮن ﺑﻌﺪة ﻃﺮق ﻟﺘﻨﻈﻴﻢ اﻻﺟﺰاء اﳌﻜﻮﻧﺔ ﻟﻠﺒﺮﻧﺎﻣﺞ‪،‬‬
‫ﳑﺎ ﺳﻬﻞ ﻣﻦ ﻋﻤﻠﻴﺎت ﺗﻘﺼﻲ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ‪ .‬ﻟﻘﺪ ﲤﺜﻞ اﳊﻞ‬
‫ﺑﺤﺼﺮ ﺟﻤﻴﻊ ﺗﻠﻚ اﳌﺠﻤﻮﻋﺎت ﻣﻦ اﻻواﻣﺮ واﻻﺟﺮاءات ﺑﻨﺎء ﻋﻠﻰ‬
‫ﻃﺒﻴﻌﺔ اداﺋﻬﺎ‪.‬‬
‫‪١٧‬‬
‫اﻟﺪاﻻت اﻟﻮﻇﻴﻔﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﻻﻗﻮاس ﻫﻨﺎ‪ ،‬اﻧﻬﺎ ﻣﻮﺟﻮدة ﻟﺴﺒﺐ ﻣﻬﻢ ﺟﺪاَ‪ ،‬اﻻ اﻧﻨﺎ ﺳﻨﻨﺎﻗﺶ ذﻟﻚ‬ ‫ﲤﻜﻨﻚ ﻣﻦ ﺣﺴﺎب ﻣﺴﺎﺣﺔ ﺳﻄﺢ‬ ‫ﻛﻤﺜﺎل ﳝﻜﻨﻚ ﺟﻤﻊ ﻋﺪة اواﻣﺮ ّ‬
‫ﻻﺣﻘ َﺎ ﺧﻼل ﻫﺬا اﻟﻔﺼﻞ‪.‬‬ ‫اﻟﺪاﺋﺮة‪ .‬وﻣﺎ ان ﺗﺘﺄﻛﺪ ﻣﻦ ﻣﺪى ﺻﻼﺣﻴﺔ وﺻﺤﺔ ﻋﻤﻞ ﺗﻠﻚ‬
‫ﻓﻲ اﻻﺳﻄﺮ اﻟﺘﺎﻟﻴﺔ ﻣﻦ اﻟﺸﻔﺮة ﺳﻨﺠﺪ اﻗﻮاس ﻣﻌﻘﻮﻓﺔ‪ .‬ﺣﻴﺚ ُﻳﺘﻮﻗﻊ‬ ‫اﳌﺠﻤﻮﻋﺔ ﻣﻦ اﻻواﻣﺮ وﻧﺘﺎﺟﻬﺎ اﻟﺼﺤﻴﺢ‪ ،‬ﻓﺎﻧﻚ ﻟﻦ ﺗﻌﻮد اﻟﻴﻬﺎ ﻣﺮة‬
‫ﻣﻨﺎ ادراج اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ أو ﻣﺎ ﻳﻄﻠﻖ ﻋﻠﻴﻪ اﻟﺒﻨﻴﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﺪاﻟﺔ‬ ‫اﺧﺮى ﻟﺘﻘﺼﻲ اﻻﺧﻄﺎء‪.‬‬
‫‪ . body‬ﻟﻘﺪ ﻧﺴﺨﻨﺎ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣﻦ اﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ ووﺿﻌﻨﺎﻫﺎ‬ ‫انﻣﺠﻤﻮﻋﺔاﻻواﻣﺮ ﺗﻠﻚ ﻫﻲﻣﺎﻳﻄﻠﻖﻋﻠﻴﻬﺎاﻟﺪوال‪/‬اﻟﺪاﻻتاﻟﺒﺮﻣﺠﻴﺔ‬
‫ﻓﻲ ﻣﻜﺎﻧﻬﺎ اﻟﺼﺤﻴﺢ ﺣﻴﺚ ﻳﺠﺐ ان ﺗﻜﻮن]‪.[2‬‬ ‫‪ function‬وﳝﻜﻨﻨﺎ اﻃﻼق ﻣﺴﻤﻴﺎت ﳑﻴﺰة ﻟﻬﺎ‪ ،‬ﺣﻴﺚ ﳝﻜﻨﻨﺎ اﺳﺘﺪﻋﺎء‬
‫]‪[2‬‬ ‫وﻇﺎﺋﻔﻬﺎ ﻣﻦ ﺧﻼل اﻳﺮاد اﺳﻤﺎﺋﻬﺎ داﺧﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬
‫)(‪main‬‬
‫{‬
‫‪// Variables are declared below‬‬
‫ﻫﺬا اﳌﺒﺪء ﻛﺎن ﲟﺜﺎﺑﺔ اﻟﺘﻮﺟﻪ اﻟﺮﺋﻴﺲ ﻻﺳﺘﺨﺪام اﻟﺪوال‪ ،‬ﺣﺘﻰ ان‬
‫‪float pictureWidth, pictureHeight,‬‬ ‫اي ﺑﺮﻧﺎﻣﺞ ﻳﺘﻜﻮن ﻣﻦ داﻟﺔ واﺣﺪة ﻋﻠﻰ اﻻﻗﻞ ﺗﻌﺮف ﺑﺎﺳﻢ )(‪.main‬‬
‫اﳌﺠﻤﻊ‪ ،‬اﻧﻪ ﻳﺴﺘﺪل ﺑﻬﺎ‬
‫ﻫﺬﻩ اﻟﺪاﻟﺔ )(‪ main‬ﻫﻲ ﻣﺎ ﻳﺒﺤﺚ ﻋﻨﻪ ّ‬
‫‪// We initialize the variables (we give‬‬
‫)‪the variables a value‬‬ ‫ﻟﻴﺒﺪاء ﺗﻨﻔﻴﺬ اﻻواﻣﺮ واﻻﺟﺮاءات اﻟﺘﺎﻟﻴﺔ وﻗﺖ ﺗﺸﻐﻴﻞ وﺗﻨﻔﻴﺬ‬
‫;‪pictureHeight = 4.5‬‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‪ .‬دﻋﻨﺎ ﻧﺘﻔﺤﺺ اﻟﺪاﻟﺔ )(‪ main‬ﲟﺰﻳﺪ ﻣﻦ اﻟﺘﻔﺼﻴﻞ]‪.[1‬‬
‫]‪[1‬‬
‫‪// Here the actual calculation is‬‬ ‫)(‪main‬‬
‫‪performed‬‬
‫* ‪pictureSurfaceArea = pictureWidth‬‬ ‫{‬
‫;‪pictureHeight‬‬ ‫‪// Body of the main() function. Put your‬‬
‫}‬ ‫‪code here.‬‬
‫}‬
‫اذا ﻣﺎ اﺳﺘﻤﺮﻳﻨﺎ ﺑﺎدراج ﻣﺰﻳﺪ ﻣﻦ اﺳﻄﺮ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻟﺒﻨﻴﺔ اﻟﺪاﻟﺔ‬
‫اﻟﺒﻴﺎن ]‪ [1.1‬ﻳﻈﻬﺮ اﺳﻢ اﻟﺪاﻟﺔ ”‪ “main‬ﻳﺘﺒﻌﺔ اﻗﻮاس‪ .‬ان ﻛﻠﻤﺔ ‪main‬‬
‫)(‪ main‬ﺳﻨﺼﻞ ﻟﻨﺘﻴﺠﺔ ﺣﺘﻤﻴﺔ ﻣﻔﺎدﻫﺎ اﺳﺘﺤﺎﻟﺔ أو ﺻﻌﻮﺑﺔ اﺟﺮاء اي‬
‫ﺗﻘﺼﻲ ﻟﻸﺧﻄﺎء‪.‬‬ ‫ﻛﻠﻤﺔ ﻣﺤﺠﻮزة‪ ،‬ﺣﻴﺚ ﲤﺜﻞ داﻟﺔ ﻣﻄﻠﻮﺑﻪ اﺳﺎﺳ ًﺎ ﻻن ﻳﻜﻮن ﻫﻨﺎك‬
‫ﺑﺮﻧﺎﻣﺞ‪ ،‬وﳝﻜﻦ ﻟﺪاﻻﺗﻚ اﻻﺧﺮى ان ﺗُﺴﻤﻰ ﺑﺎي اﺳﻢ اﺧﺮ‪ .‬ﻻﺣﻆ‬
‫‪١٨‬‬
‫ﻫﺬﻩ اﻟﺪاﻟﺔ ﻏﻴﺮ ﻣﻌﺸﺸﺔ ﺑﺎﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ‪.‬‬ ‫ذﻟﻚ ان ﺗﺘﺎﻟﻲ ﺗﻠﻚ اﻻﺳﻄﺮ ﻳﻘﻮدﻧﺎ ﲡﺎﻩ ﺑﻨﻴﺔ ﻏﻴﺮ ﻣﻬﻴﻜﻠﺔ‬
‫وﺣﺘﻰ ﺗﺆدي داﻟﺘﻨﺎ اﳉﺪﻳﺪة )(‪ circleArea‬دورﻫﺎ ﻳﺠﺐ ﻋﻠﻴﻨﺎ‬ ‫‪ unstructured‬ﻳﺠﺪر ﺑﻨﺎ ﺗﻼﻓﻴﻬﺎ اﺛﻨﺎء اﻟﺒﺮﻣﺠﺔ‪ .‬ﻟﺬا دﻋﻨﺎ ﻧﻌﻴﺪ‬
‫اﺳﺘﺪﻋﺎﺋﻬﺎ داﺧﻞ ﻧﻄﺎق اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ‪ .‬ﻟﻨﺮى ﻛﻴﻒ ﻳﺘﻢ ذﻟﻚ‪.‬‬ ‫ﻛﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ وذﻟﻚ ﺑﺎﺳﺘﺨﺪام اﻟﻬﻴﻜﻠﺔ ‪ .structure‬ﺑﻐﺾ اﻟﻨﻈﺮ‬
‫]‪[4‬‬ ‫ﻋﻦ اﻟﺪاﻟﺔ اﻻﺟﺒﺎرﻳﺔ‪ ،‬ﳝﻜﻨﻨﺎ اﺳﺘﺤﺪاث داﻟﺔ ﺟﺪﻳﺪة وﻧﻄﻠﻖ ﻋﻠﻴﻬﺎ‬
‫)(‪main‬‬ ‫اﺳﻢ )(‪ circleArea‬ﻛﻤﺎ ﺑﺎﳌﺜﺎل ]‪ [3‬اﻟﺘﺎﻟﻲ‪:‬‬
‫{‬
‫]‪[3‬‬
‫)(‪main‬‬
‫‪pictureSurfaceArea,‬‬
‫{‬
‫;‪circleRadius, circleSurfaceArea‬‬
‫]‪// [4.4‬‬
‫]‪circleRadius = 5.0; // [4.7‬‬
‫}‬
‫!‪// Here we call our function‬‬
‫)(‪circleArea‬‬ ‫]‪// [3.9‬‬
‫‪circleSurfaceArea = circleArea(circleRadi‬‬
‫{‬
‫]‪us); // [4.11‬‬
‫}‬
‫}‬
‫ﻣﻠﺤﻮﻇﺔ‪ :‬ﺑﺎﻗﻲ ﺷﻔﺮة اﻟﺒﺮﻧﺎﻣﺞ ﻏﻴﺮ ﻣﻜﺘﻤﻠﺔ ﻫﻨﺎ اﻧﻈﺮ اﳌﺜﺎل ]‪. [3‬‬ ‫ﻼ‪ ،‬اﻻ ان داﻟﺘﻨﺎ )(‪ circleArea‬اﳌﺴﺘﺤﺪﺛﺔ ﻻ‬‫ﻟﻘﺪ ﻛﺎن ذﻟﻚ ﺳﻬ َ‬
‫ﺗﻘﻮم ﺑﺎي ﺷﻲء ﺣﺎﻟﻴ َﺎ‪ .‬ﻟﻜﻦ ﻻﺣﻆ ان ﺗﻮﺻﻴﻒ اﻟﺪاﻟﺔ )(‪circleArea‬‬
‫ﻟﻘﺪ اﺿﻔﻨﺎ ﻣﺘﻐﻴﺮان ﲟﺴﻤﻴﺎت ﻣﻦ ﻧﻮع ﻋﺪدي ﻛﺴﺮي ‪ float‬ﻓﻲ]‪،[4.4‬‬
‫وﺑﻨﻴﺘﻬﺎ اﻟﺒﺮﻣﺠﻴﺔ ﺧﺎرج ﻧﻄﺎق اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﻴﺔ )(‪ ،main‬ﲟﻌﻨﻰ اﺧﺮ‬
‫‪١٩‬‬
‫وذﻟﻚ ﺑﻨﻔﺲ اﻻﺳﻠﻮب اﳌﺴﺘﺨﺪم ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ اﻟﺪاﻟﺔ ]‪.main [4.4‬‬ ‫وﻗﺪ ﻗﻤﻨﺎ ﺑﺘﻬﺌﻴﺔ اﳌﺘﻐﻴﺮ ‪ - initialize‬ﲟﻌﻨﻰ اﺳﻨﺪﻧﺎ ﻟﻪ ﻗﻴﻤﺔ ﻣﺒﺪﺋﻴﺔ‬
‫ﺣﻴﺚ ﺳﺘﻠﺤﻆ ان اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺘﻐﻴﺮ ‪ theRadius‬ﻗﺪ ﰎ ﺧﻼل‬ ‫]‪ -[4.7‬وﻣﻦ اﻛﺜﺮ ﻣﺎ ﻳﻠﻔﺖ اﻟﻨﻈﺮ ]‪ [4.11‬ﻛﻴﻔﻴﺔ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫اﻗﻮاس ]‪ .[5.1‬وﻳﻌﻴﺪ اﻟﺴﻄﺮ ]‪ [5.5‬اﻟﻨﺎﰋ اﻟﻰ ذﻟﻚ اﳉﺰء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ‬ ‫)(‪ circleArea‬ﻓﻜﻤﺎ ﺗﺮى ﻟﻘﺪ ادرﺟﻨﺎ اﺳﻢ اﳌﺘﻐﻴﺮ‪circleRadius‬‬
‫اﻟﺬي ﺣﺪث ﻓﻴﻪ اﺳﺘﺪﻋﺎء ﻫﺬﻩ اﻟﺪاﻟﺔ‪ .‬وﻛﻨﺘﻴﺠﺔ ﻟﺬﻟﻚ ﻧﺮ'ى ﺑﺎﻟﺴﻄﺮ‬ ‫ﺑﲔ اﻗﻮاس ﻓﻬﻮ ﻣﻌﺎﻣﻞ ﻟﻠﺪاﻟﺔ )(‪. circleArea‬‬
‫]‪ ،[4.11‬ان ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ circleSurfaceArea‬ﻗﺪ اﺻﺒﺤﺖ ﺗﻠﻚ‬ ‫ﺳﻮف ﻳﺘﻢ ﲤﺮﻳﺮ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ circleRadius‬اﻟﻰ اﻟﺪاﻟﺔ )(‪.circleArea‬‬
‫اﻟﻘﻴﻤﺔ اﳌﺴﻨﺪة اﻟﻴﻪ ﻣﻦ ذﻟﻚ اﻻﺳﺘﺪﻋﺎء‪.‬‬ ‫وﻣﺘﻰ ﻣﺎ ﻗﺎﻣﺖ اﻟﺪاﻟﺔ ﺑﺎﻻﻧﺘﻬﺎء ﻣﻦ اﳒﺎز ﺧﻄﻮات ﻋﻤﻠﻬﺎ ﺣﺴﺎﺑﻴ َﺎ‬
‫ان اﻟﺪاﻟﺔ ﺑﺎﳌﺜﺎل ]‪ [5‬ﻛﺎﻣﻠﺔ ﻋﺪا ﻋﻦ اﻣﺮ واﺣﺪ‪ .‬ﻓﻨﺤﻦ ﻟﻢ ﻧﻘﻢ ﺑﺘﻌﻴﲔ‬ ‫ﺳﺘﻘﻮم ﺑﺎرﺟﺎع ﻧﺘﻴﺠﺔ ﺣﺘﻤﻴﺔ‪.‬دﻋﻨﺎ ﻧﻘﻮم ﺑﺘﻌﺪﻳﻞ اﻟﺪاﻟﺔ ﻣﻦ اﳌﺜﺎل ]‪[3‬‬
‫”"ﻧﻮع ‪ “Type -‬اﻟﺒﻴﺎﻧﺎت اﻟﻌﺎﺋﺪ ﻣﻨﻬﺎ‪ .‬وذﻟﻚ ﻣﻄﻠﺐ اﺳﺎﺳﻲ ﺣﺘﻰ‬ ‫ﻟﺘﻜﻮن ﻛﻤﺎ ﻫﻲ ﺑﺎﳌﺜﺎل]‪.[5‬و ﺳﻨﻌﺮض داﻟﺔ )(‪ circleArea‬ﻓﻘﻂ‪.‬‬
‫اﳌﺠﻤﻊ ﻣﻦ اﻟﻘﻴﺎم ﺑﻌﻤﻠﻪ‪ ،‬وﻣﺎ ﻋﻠﻴﻨﺎ اﻻ اﻟﻄﺎﻋﺔ واﻟﺘﻨﻮﻳﻪ ﻋﻦ‬
‫ﻳﺘﻤﻜﻦ ّ‬ ‫]‪[5‬‬
‫اﻟﻨﻮع ﻋﻠﻰ ان ﻳﻜﻮن ﻋﺪدي ﻛﺴﺮي]‪.[6.1‬‬ ‫]‪circleArea(float theRadius) // [5.1‬‬
‫{‬
‫]‪[6‬‬ ‫;‪float theArea‬‬
‫)‪float circleArea(float theRadius‬‬ ‫;‪theArea = 3.1416 * theRadius * theRadius‬‬
‫{‬ ‫‪// pi times r square‬‬ ‫]‪[5.4‬‬
‫;‪float theArea‬‬ ‫;‪return theArea‬‬
‫;‪theArea = 3.1416 * theRadius * theRadius‬‬ ‫}‬
‫;‪return theArea‬‬
‫}‬ ‫)(‪circleArea‬‬‫ﺑﺎﻟﺴﻄﺮ ]‪ [5.1‬ﺻﺮﺣﻨﺎ ﺑﺎن ﺗﻜﻮن ﻗﻴﻤﺔ ﻣﻌﺎﻣﻞ داﻟﺔ‬
‫ﻛﻤﺎ ﻫﻮ ﻣﻼﺣﻆ ان اول ﻛﻠﻤﺔ ﺑﺎﻟﺒﻴﺎن ]‪ [6.1‬ﺗﺼﺮح ﻋﻦ ﻧﻮع‬ ‫ﻗﻴﻤﺔ ﻛﺴﺮﻳﺔ‪ .‬ﻣﺘﻰ ﺗﺴﻠﻢ اﳌﻌﺎﻣﻞ ﻗﻴﻤﺘﻪ‪ ،‬ﺳﺘﺨﺰن ﺑﺎﳌﺘﻐﻴﺮ اﳌﺴﻤﻰ‬
‫اﻟﺒﻴﺎﻧﺎت اﻟﻌﺎﺋﺪ ﻣﻦ ﻫﺬﻩ اﻟﺪاﻟﺔ ‪-‬ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ - theArea‬وﻫﻲ ﻫﻨﺎ‬ ‫‪.theRadius‬‬
‫ﻣﻦ ﺻﻨﻒ ﻋﺪد ﻛﺴﺮي‪ .‬و ﻣﻦ واﺟﺒﻚ ﻛﻤﺒﺮﻣﺞ ﺣﺮﻳﺺ‪ ،‬اﳊﺮص‬ ‫وﻟﻘﺪ اﺳﺘﺨﺪﻣﻨﺎ ﻣﺘﻐﻴﺮاَ اﺧﺮ ‪-‬اﺳﺘﺨﺪﻣﻨﺎ ‪ theArea‬ﻟﺘﺨﺰﻳﻦ ﻧﺎﰋ‬
‫ﻋﻠﻰ اﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮ ‪ circleSurfaceArea‬اﳌﺪرج داﺧﻞ ﻧﻄﺎق‬ ‫اﻟﻌﻤﻠﻴﺔ اﳊﺴﺎﺑﻴﺔ ]‪ ،[5.4‬ﻟﺬا ﻳﺠﺐ ﻋﻠﻴﻨﺎ اﻟﺘﺼﺮﻳﺢ ﻋﻨﻪ ]‪،[5.3‬‬
‫‪٢٠‬‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن ﻟﻠﺪاﻟﺔ اﳌﺴﺘﺨﺪﻣﺔ اﻛﺜﺮ ﻣﻦ ﻣﻌﺎﻣﻞ ﻣﻄﻠﻮب‬ ‫)(‪ main‬ان ﻳﺴﺘﻘﺒﻞ ﻧﻔﺲ ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﳌﺘﻔﻖ اي ﻋﺪد ﻛﺴﺮي‪،‬‬
‫‪ Arguments‬ﻛﺎﻟﺪاﻟﺔ )(‪ pictureSurfaceArea‬وﻫﻲ ﺗﺴﺘﺨﺪم‬ ‫اﳌﺠﻤﻊ ﻣﻦ اﺻﺪار ﺗﻠﻚ اﻟﺮﺳﺎﺋﻞ اﳌﺰﻋﺠﺔ‪ .‬وﻻ ﻳﺸﺘﺮط‬‫وذﻟﻚ ﳌﻨﻊ ّ‬
‫ﻣﻌﺎﻣﻼن ﻛﻤﺎل ﺑﺎﳌﺜﺎل]‪ ، [9‬ﻋﻨﺪﻫﺎ ﻳﺠﺐ ان ﻧﺴﺘﺨﺪم ﻓﺎﺻﻞ ﺑﲔ‬ ‫دوﻣ َﺎ ان ﺗﻜﻮن ﻫﻨﺎك ﻣﻌﺎﻣﻼت ﻟﻠﺪاﻻت‪ .‬وﺣﺘﻰ ﻋﻨﺪﺋﺬ ﻳﺸﺘﺮط ان‬
‫اﻟﻌﻮاﻣﻞ اﳌﺘﻌﺪدة وذﻟﻚ ﺑﻮﺿﻊ ﻓﺎﺻﻠﺔ اﻋﺘﻴﺎدﻳﺔ"‪ "،‬ﺑﺒﲔ اﻟﻌﻮاﻣﻞ‪.‬‬ ‫ﺗﻜﻮن ﻫﻨﺎك اﻗﻮاس وﻟﻮ ﻛﺎﻣﻦ ﻓﺎرﻏﺔ‪.‬‬
‫]‪[9‬‬ ‫]‪[7‬‬
‫‪float pictureSurfaceArea(float theWidth, float‬‬ ‫)(‪int throwDice‬‬
‫)‪theHeight‬‬ ‫{‬
‫{‬ ‫;‪int noOfEyes‬‬
‫‪// Code here‬‬
‫}‬ ‫‪// Code to generate a random value from 1‬‬
‫‪to 6‬‬
‫‪return‬‬ ‫ان اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬ﺗﺘﻄﻠﺐ ارﺟﺎع ﻗﻴﻤﺔ ﻣﺮﲡﻌﺔ‬
‫‪ ،value‬وﻫﻲ ﺗﺮﺟﻊ ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ ‪ ،integer‬وﻳﺠﺪر ﺑﻬﺎ ارﺟﺎع‬ ‫}‬
‫;‪return noOfEyes‬‬
‫ﻗﻴﻤﺔ ﺻﻔﺮ )]‪ (zero, [10.9‬ﻟﻠﺘﻨﻮﻳﺔ ﻋﻦ ان اﻟﺪاﻟﺔ اﳒﺰت ﻋﻤﻠﻬﺎ‬

‫دوﳕﺎ اﺧﻄﺎء‪.‬‬ ‫ﻻﻳﺸﺘﺮط ان ﺗﻌﻴﺪ اﻟﺪاﻻت اي ﻗﻴﻤﺔ ‪ .return a value‬ﻓﻤﺘﻰ ﻣﺎ‬
‫ﻛﺎﻧﺖ اﻟﺪاﻟﺔ ﻛﺬﻟﻚ اﺻﺒﺢ ﺗﺼﻨﻴﻔﻬﺎ ﻣﻦ ﻧﻮع ‪ . void‬ﻋﻨﺪﻫﺎ ﻳﻜﻮن‬
‫وﲟﺎ ان اﻟﺪاﻟﺔ )(‪ main‬ﺗﺮﺟﻊ ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ‪ ،‬ﻳﺠﺐ ﻋﻨﺪﻫﺎ ﻛﺘﺎﺑﺔ‬ ‫ﺑﻴﺎن اﻟﻌﺎﺋﺪ ”‪ “return‬اﺧﺘﻴﺎري‪ .‬ﻣﺘﻰ ﻣﺎ اﺳﺘﺨﺪﻣﺖ ﻣﺜﻞ ﺗﻠﻚ‬
‫ﻧﻮع اﻟﻘﻴﻤﺔ اﳌﺮﲡﻌﺔ ‪ int‬ﻗﺒﻞ ﻛﺘﺎﺑﺔ اﺳﻢ اﻟﺪاﻟﺔ ﻛﻤﺎ ﻳﻠﻲ ﻓﻲ ]‪.[10.1‬‬ ‫اﻟﺪاﻻت اﺣﺮص ﻋﻠﻰ ان ﺗﻜﻮن ﺧﺎﻧﺔ اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة ‪.void‬‬
‫واﻻن ﻟﻨﺴﺮد ﻛﺎﻓﺔ اﻟﺒﻨﻰ اﻟﺒﺮﻣﺠﻴﺔ ﺑﺎﻟﺼﻨﺪوق ﻣﻦ اﻟﺼﻔﺤﺔ اﻟﺘﺎﻟﻴﺔ‪.‬‬ ‫]‪[8‬‬
‫;)‪void beepXTimes(int x‬‬
‫{‬
‫‪// Code to beep x times.‬‬
‫;‪return‬‬
‫}‬
‫‪٢١‬‬
‫ﻛﻤﺎ ﺗﺮى ﻓﻲ]‪ ، [10‬ﻟﺪﻳﻨﺎ داﻟﺔ )(‪ [10.1] main‬وداﻟﺔ اﺧﺮى ﻣﻌﺮﻓﺔ ﻣﻦ‬ ‫]‪[10‬‬
‫)(‪int main‬‬
‫اﳌﺠﻤﻊ ﻓﻲ ﺣﻴﺮة ﻣﻦ اﻣﺮﻩ ﻋﻨﺪ ﻗﻴﺎﻣﻨﺎ ﺑﺘﺠﻤﻴﻊ‬‫ﻗﺒﻠﻨﺎ]‪ .[10.13‬ﺳﻴﻈﻞ ّ‬ ‫{‬
‫وﲡﻤﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﻓﻔﻲ اﻟﺴﻄﺮ ]‪ [10.9‬ﺳﻴﺪﻋﻲ ﻋﺪم ﻣﻌﺮﻓﺘﻪ ﺑﺎي داﻟﺔ‬‫ّ‬ ‫‪float pictureWidth, pictureHeight,‬‬
‫اﺳﻤﻬﺎ )(‪. circleArea‬ﻳﺎ ﺗﺮى ﳌﺎذا؟‬ ‫‪pictureSurfaceArea,‬‬
‫;‪circleRadius, circleSurfaceArea‬‬
‫اﳌﺠﻤﻊ ﻗﺪ ﺑﺪاء ﺑﺘﻔﺴﻴﺮ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬ﺛﻢ‬
‫ﻣﻦ اﻟﻮاﺿﺢ ان ّ‬ ‫;‪pictureWidth = 8‬‬
‫ﺗﻮاﺟﻪ ﻓﺠﺄة ﻣﻊ ﻣﺎ ﻻ ﻳﻌﺮف ﻛﻴﻒ ﻳﺘﻌﺎﻣﻞ ﻣﻌﻪ‪ .‬ﻋﻨﺪﻫﺎ ﺗﻮﻗﻒ ﻋﻦ‬ ‫;‪pictureHeight = 4.5‬‬
‫اﻟﻌﻤﻞ اﳌﻨﺎط ﺑﻪ وأﻇﻬﺮ ﻟﻚ رﺳﺎﻟﺔ ﲢﺬﻳﺮﻳﺔ‪.‬‬ ‫;‪circleRadius = 5.0‬‬
‫اﳌﺠﻤﻊ ﻟﻴﺘﺠﺎوز ﻫﺬﻩ اﳌﺸﻜﻠﺔ‪ ،‬ﻗﻢ ﺑﻮﺿﻊ اﻟﺘﺼﺮﻳﺢ ﻋﻦ‬ ‫ﺣﺘﻰ ﺗﺮﺿﻲ ّ‬ ‫* ‪pictureSurfaceArea = pictureWidth‬‬
‫اﻟﺪاﻟﺔ ﻓﻲ ﻣﻮﻗﻊ اﻋﻠﻰ ﻣﻦ ﺑﻴﺎن اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ ]‪.int main() [11.1‬‬ ‫‪circleSurfaceArea = circleArea(circleRadi‬‬
‫ﻻﺷﻲء ﺻﻌﺐ ﺣﻴﺎل ذﻟﻚ‪ ،‬ﻋﺪا اﻧﻪ ﻣﺜﻞ ﻣﺎ ورد ﺑـ ]‪ [10.13‬ﻓﻬﻮ ﻫﻨﺎ‬ ‫;)‪us‬‬ ‫]‪// [10.9‬‬
‫إﻳﻌﺎز ﻣﻨﺘﻬﻲ ﺑﻔﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ‪.‬‬ ‫;‪return 0‬‬
‫]‪[11‬‬ ‫}‬
‫;)‪float circleArea(float theRadius‬‬ ‫‪//‬‬
‫‪function declaration‬‬ ‫)‪float circleArea(float theRadius‬‬
‫]‪// [10.13‬‬
‫{‬ ‫{‬
‫;‪float theArea‬‬
‫ﻣﻠﺤﻮﻇﺔ ‪ :‬ﺑﻘﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻛﻤﺎ ﻫﻮ ﻓﻲ اﳌﺜﺎل]‪ .[10‬وﻗﺮﻳﺒﺎ ﺳﻨﺮﻛﻢ‬ ‫;‪theArea = 3.1416 * theRadius * theRadius‬‬
‫وﻧﺸﻐّﻞ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺣﺎﻟﻴ َﺎ ﻟﺪﻳﻨﺎ اﺷﻴﺎء ﻣﻦ ﻫﻨﺎ وﻫﻨﺎك‪.‬‬ ‫;‪return theArea‬‬
‫}‬
‫‪٢٢‬‬
‫ﻻﺳﺘﻌﺮاض ﻛﻴﻔﻴﻪ اﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮ داﺧﻞ ﻧﻄﺎق اﻟﺪاﻟﺔ‪.‬‬ ‫ﻣﻦ ﻫﻨﺎ وﻫﻨﺎك‬
‫ﻓﺒﺎﻟﺮﻏﻢ ﻣﻦ ﺳﻬﻮﻟﺔ اﻟﺪاﻻت اﻟﺘﻲ ﻋﺮ ّﻓﻨﺎﻫﺎ ﺑﺎﻧﻔﺴﻨﺎ ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ‪،‬‬ ‫ﻓﺄﺛﻨﺎء ﻛﺘﺎﺑﺔ اﻟﺒﺮاﻣﺞ‪ ،‬ﻳﻨﺼﺢ دوﻣ َﺎ ﺑﺎﻋﺘﻤﺎد اﻋﺎدة اﺳﺘﺨﺪام اﻟﺸﻔﺮة‬
‫اﻻ اﻧﻪ ﻣﻦ اﳌﻬﻢ اﻟﺘﻨﺒﻪ ﻻﻣﻜﺎﻧﻴﺔ ﺗﻐﻴﻴﺮ اﻟﺪوال دون اﺣﺪاث ﺻﺪﻣﺔ‬ ‫اﻟﺒﺮﻣﺠﻴﺔ ‪ .code reuse‬ﻓﻔﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﻫﺬا ﳝﻜﻨﻨﺎ اﺿﺎﻓﺔ داﻟﺔ‬
‫ﻓﻲ أداء اﻟﺒﺮﻧﺎﻣﺞ ﻃﺎﳌﺎ ﻟﻢ ﺗﻐﻴﺮ اﻟﺴﻄﻮر اﻻوﻟﻰ ﻣﻦ ﺗﺼﺎرﻳﺢ اﻟﻘﻴﻢ‬ ‫اﺣﺘﺴﺎب ﻣﺴﺎﺣﺔ اﳌﺴﺘﻄﻴﻞ )(‪ ،rectangleArea‬ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ‬
‫اﻟﻌﺎﺋﺪة واﻧﻮاع ﻣﻌﺎﻣﻼت اﻟﺪوال‪.‬‬ ‫ﺑﺎﳌﺜﺎل]‪ ،[12‬وﳝﻜﻦ اﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﻦ ﻧﻄﺎق اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪.main‬‬
‫ﻛﻤﺜﺎل ﳝﻜﻨﻚ ﺗﻐﻴﻴﺮ اﺳﻤﺎء اﳌﺘﻐﻴﺮات داﺧﻞ اﻟﻨﻄﺎق اﶈﻠﻲ ﻟﻠﺪاﻟﺔ‬ ‫ﻫﺬا اﻻﻣﺮ ﻣﻔﻴﺪ ﺣﺘﻰ ﻟﻮ ﻛﺎن اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻫﺬﻩ اﻟﺪاﻟﺔ ﺳﻴﺘﻢ ﳌﺮة‬
‫‪ ،variable scope‬وﻣﻊ ذﻟﻚ ﺳﺘﻈﻞ اﻟﺪاﻟﺔ ﺗﺆدي ﻋﻤﻠﻬﺎ اﳌﻄﻠﻮب‬ ‫واﺣﺪة ﻓﻘﻂ وﻗﺖ ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪-‬وﻟﻦ ﻳﻜﻮن ﻟﺬﻟﻚ اي اﺛﺮ اﻋﺘﺮاﺿﻲ ﺑﺎﺟﺰاء اﻟﺒﺮﻧﺎﻣﺞ‪.-‬‬ ‫ﺳﺘﺠﺪ ان اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬اﺻﺒﺤﺖ ﻗﺮاﺋﺘﻬﺎ اﻳﺴﺮ ‪ ،‬وﻣﺘﻰ ﻣﺎ‬
‫وﳝﻜﻦ ﳌﺒﺮﻣﺞ آﺧﺮ ﻛﺘﺎﺑﺔ ﺑﻨﻴﺔ ﺗﻠﻚ اﻟﺪاﻟﺔ‪ ،‬ﺣﻴﺚ ﲟﻜﻨﻚ اﺳﺘﺨﺪاﻣﻬﺎ‬ ‫ﻗﻤﺖ ﺑﺘﻘﺼﻲ اﻻﺧﻄﺎء ﺳﻴﻜﻮن اﻳﺠﺎدﻫﺎ اﺳﻬﻞ‪ ،‬وﻗﺪ ﺗﻀﻊ ﻳﺪك‬
‫ﺑﺪﻻ ﻣﻦ ان ﺗﻄﻮف‬‫ﻋﻠﻰ ﺧﻄﺎء ﺑﺮﻣﺠﻲ داﺧﻞ اﺣﺪ ﺗﻠﻚ اﻟﺪوال‪َ ،‬‬
‫دون اﻟﺘﻌﻤﻖ ﻓﻲ ﻓﻬﻢ ﻛﻴﻔﻴﻪ ﻋﻤﻠﻬﺎ اﻟﺪاﺧﻠﻲ‪ ،‬ﻓﻜﻞ ﻣﺎ ﻫﻮ ﻣﻄﻠﻮب‬
‫ﻣﻨﻚ ﻫﻮ ان ﺗﺘﻌﺮف ﻋﻠﻰ ﻛﻴﻔﻴﻪ اﺳﺘﺨﺪاﻣﻬﺎ‪ .‬وذﻟﻚ ﻳﻌﻨﻲ ﻣﻌﺮﻓﺔ‪:‬‬ ‫ﺑﻜﺎﻓﺔ اﻟﻜﺘﻞ اﳌﻜﻮﻧﺔ ﻟﻠﺒﺮﻧﺎﻣﺞ‪ ،‬ﻛﻞ اﳌﻄﻠﻮب ﻣﻨﻚ ﻫﻮ ﺗﻔﺤﺺ ﺟﺰﺋﻴﺔ‬
‫‪ -‬اﺳﻢ اﻟﺪاﻟﺔ‬ ‫ﺑﺴﻴﻄﺔ ﻓﻲ اﻟﺪاﻟﺔ‪ ،‬واﻟﺸﻜﺮ ﻣﻮﺻﻮل ﻟﺘﻠﻚ اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ‪.‬‬
‫‪ -‬ﻗﻴﻤﺔ وﺗﺮﺗﻴﺐ اﳌﻌﺎﻣﻼت واﳌﻌﻄﻴﺎت واﻧﻮاﻋﻬﺎ اﳌﺴﺘﺨﺪﻣﺔ‬ ‫]‪[12‬‬
‫)‪float rectangleArea(float length, float width‬‬
‫‪ -‬ﻧﻮع اﻟﻘﻴﻤﺔ اﻟﻌﺎﺋﺪة‪/‬اﳌﺴﺘﺮﺟﻌﺔ ﻣﻦ ﺗﻠﻚ اﻟﺪاﻟﺔ )ﻗﻴﻤﺔ ﻧﺎﰋ‬ ‫{‬
‫اﺣﺘﺴﺎب ﻣﺴﺎﺣﺔ ﺳﻄﺢ ﻣﺴﺘﻄﻴﻞ ﻣﺜﻼ(‪ ،‬وﻧﻮع اﻟﻨﺎﰋ ﻋﺪدي‬ ‫}‬
‫;)‪return (length * width‬‬
‫ﺻﺤﻴﺢ أو ﻛﺴﺮي‬
‫ﻛﻤﺎ ﺗﺮى ﻓﻲ ﺣﺎﻻت ﺑﺴﻴﻄﺔ ﻣﺜﻞ ﻫﺬﻩ اﳊﺎﻟﺔ ﻣﻦ اﳌﻤﻜﻦ ان ﲡﺪ إﻳﻌﺎز‬
‫ﻓﻲ ﻣﺜﺎﻟﻨﺎ اﻟﺴﺎﺑﻖ ﺗﺮدك اﻻﺟﺎﺑﺎت ﺗﺒﺎﻋ َﺎ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫واﺣﺪﺗﻘﻮمﻋﻠﻴﻪﺑﻨﻴﺔاﻟﺪاﻟﺔ‪ ،‬وذﻟﻚ ﻻﺟﺮاءﻋﻤﻠﻴﺘﻲ اﳊﺴﺎبواﻻرﺳﺎل‬
‫اﻟﺪاﻟﺔ ‪rectangleArea‬‬ ‫‪ -‬اﺳﻢ‬ ‫دﻓﻌﺔ واﺣﺪة‪ .‬ﻟﻘﺪ اﺳﺘﺨﺪﻣﻨﺎ ﻣﺘﻐﻴﺮ ‪ theArea‬دون ﺣﺎﺟﺔ ﻓﻌﻠﻴﺔ ﻟﻪ إﻻ‬
‫‪٢٣‬‬
‫‪ -‬ﻟﻬﺎ ﻣﻌﺎﻣﻼن‪ ،‬ﻛﻼﻫﻤﺎ ﻋﺪد ﻛﺴﺮي‪ ،‬اﳌﻌﺎﻣﻞ اﻻول ﳝﺜﻞ‬

‫اﻟﻄﻮل‪ ،‬واﳌﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ﳝﺜﻞ اﻟﻌﺮض‪.‬‬
‫‪ -‬اﻟﺪاﻟﺔ ﺗﻌﻮد ﺑﻘﻴﻤﺔ ﻣﺴﺘﺮﺟﻌﺔ‪ ،‬وﻧﻮﻋﻬﺎ ﻋﺪد ﻛﺴﺮي )وﳝﻜﻦ‬
‫ﻣﻌﺮﻓﺔ ذﻟﻚ ﻣﻦ اول ﻛﻠﻤﺔ ﻓﻲ اﻟﺘﺼﺮﻳﺢ ]‪([12.1‬‬
‫ان اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﳌﻜﻮﻧﺔ ﻟﻠﺪاﻟﺔ ﻣﺤﺠﻮﺑﺔ ﻋﻦ ﻛﺎﻓﺔ اﺟﺰاء اﻟﺒﺮﻧﺎﻣﺞ‬

‫واﻟﺪاﻻت اﻟﺒﺮﻣﺠﻴﺔ اﻻﺧﺮى‪ ،‬وﻳﻌﺪ ذﻟﻚ اﺣﺪ اﻫﻢ ﳑﻴﺰات ﻟﻐﺔ‬
‫‪ .Objective-C‬ﻓﻔﻲ اﻟﻔﺼﻞ اﳋﺎﻣﺲ ﺳﻨﻨﺎﻗﺶ ﻃﺒﻴﻌﺔ ﻫﺬا اﻟﺴﻠﻮك‬
‫ﻣﻦ اﳊﺠﺐ‪ .‬ﺣﺎﻟﻴ َﺎ‪ ،‬ﻋﻠﻴﻨﺎ ﺗﺸﻐﻴﻞ ‪ّ Xcode‬‬
‫وﲡﻤﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ‬
‫]‪.[11‬‬
‫‪٢٤‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬
‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬

‫ﻟﻘﺪ ﺗﻘﺪﻣﻨﺎ ﺑﺸﻜﻞ ﺟﻴﺪ ﻣﻊ ﺑﺮﻧﺎﻣﺠﻨﺎ‪ ،‬وﻟﻜﻨﻨﺎ اﻟﻰ اﻻن ﻟﻢ ﻧﻨﺎﻗﺶ‬
‫ﻛﻴﻔﻴﺔ ﻋﺮض ﻧﺘﺎﺋﺞ اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ أﺟﺮﻳﻨﺎﻫﺎ‪ .‬ﻫﻨﺎك ﻋﺪة ﺧﻴﺎرات‬
‫ﻟﻌﺮض اﻟﻨﺘﺎﺋﺞ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪.‬‬
‫ﻓﻲ ﻫﺬا اﻟﻜﺘﺎب‪ ،‬ﺳﻨﺴﺘﺨﺪم اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﻮﻓﺮﻫﺎ ‪ Cocoa‬وﻫﻲ داﻟﺔ‬
‫)(‪ .NSLog‬اﻧﻬﺎ داﻟﺔ ﻓﻌﺎﻟﺔ وﺑﺴﻴﻄﺔ‪ ،‬ﻓﻠﺴﺖ ﺑﺤﺎﺟﺔ ﻟﻜﺘﺎﺑﺔ اواﻣﺮ‬
‫ﻣﻨﺨﻔﻀﺔ اﳌﺴﺘﻮى ﻟﺘﺘﻤﻜﻦ ﻣﻦ ﻋﺮض ﻧﺘﺎﺋﺠﻚ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ .‬ﻫﺬﻩ‬
‫اﻟﺪاﻟﺔ ﺗﻘﻮم ﺑﺬﻟﻚ‪.‬‬
‫ان داﻟﺔ )(‪ NSLog‬ﻣﺼﻤﻤﺔ ﻓﻲ اﻻﺻﻞ ﻟﻌﺮض رﺳﺎﺋﻞ اﻻﺧﻄﺎء‪ ،‬وﻟﻴﺲ‬
‫ﻟﻌﺮض ﻧﺘﺎﺋﺞ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﻋﻠﻰ اﻳﺔ ﺣﺎل اﺳﺘﺨﺪاﻣﻬﺎ ﻣﻦ اﻟﺴﻬﻮﻟﺔ ﺑﺤﻴﺚ‬
‫ادرﺟﻨﺎﻫﺎ ﻓﻲ ﻛﺘﺎﺑﻨﺎ ﻟﻌﺮض اﻟﻨﺘﺎﺋﺞ‪ .‬ﲟﺠﺮد ان ﺗﺼﻘﻞ ﺧﺒﺮاﺗﻚ ﻣﻊ‬
‫‪ Cocoa‬ﺳﺘﺘﺪرج ﻻﺳﺘﺨﺪام ﺗﻘﻨﻴﺎت اﻛﺜﺮ ﻣﻼءﻣﺔ‪ .‬واﻻن ﻟﻨﺘﻔﺤﺺ‬
‫داﻟﺔ )(‪ NSLog‬اﳌﺴﺘﺨﺪﻣﺔ‪.‬‬
‫]‪[1‬‬
‫{‬
‫;)”‪NSLog(@”Julia is a pretty actress.‬‬
‫;‪return 0‬‬
‫}‬
‫‪٢٥‬‬
‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﺣﺮوف ﲢﺘﻮي ﻓﺮاغ واﺣﺪ ‪ ،single space‬ﻟﺬا ﻗﻴﻤﺘﻬﺎ ﺗﺴﺎوي ‪.١‬‬ ‫ﺳﻴﻘﻮم اﻻﻳﻌﺎز ﻓﻲ اﳌﺜﺎل ]‪ [1‬ﺑﺎﺧﺮاج اﻟﻨﺺ اﻟﺘﺎﻟﻲ ‪.‬‬
‫ﻫﺬﻩ اﻟﺴﻼﺳﻞ ﺗﺴﺘﺨﺪم ﺑﻀﻊ ﺣﺮوف ﻣﻦ اﻟﺮﻣﻮز اﳌﺘﺘﺎﻟﻴﺔ وﻫﻲ‬ ‫”‪“Julia is a pretty actress.‬‬
‫ﺗﺴﺘﺨﺪم ﳌﻬﺎم ﻣﻌﻴﻨﺔ داﺧﻞ ﺳﻼﺳﻞ اﳊﺮوف‪ .‬ﻛﻤﺜﺎل ﻋﻠﻰ ذﻟﻚ‬ ‫ان ﻛﺎﻓﺔ اﻟﻨﺼﻮص ﻣﺎﺑﲔ ﻋﻼﻣﺘﻲ اﻟﺘﻨﺼﻴﺺ “ ‪ ” ...‬ذات اﻟﺒﺎدﺋﺔ‬
‫اﺳﺘﺨﺪام اﳊﺮف ‪ \n‬ﻻﺟﺒﺎر اﻟﺴﻠﺴﻠﺔ أن ﺗﻌﺮض ﺳﻠﺴﻠﺔ ﺣﺮوﻓﻬﺎ‬ ‫@ ﻳﻄﻠﻖ ﻋﻠﻴﻬﺎ اﺳﻢ )ﺳﻠﺴﺔ اﳊﺮوف ‪ .(string‬وﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ‬
‫ﺑﺴﻄﺮ ﺟﺪﻳﺪ‪ .‬ﻫﺬا اﻟﺘﺮﻣﻴﺰ اﺧﺘﺼﺎر ﻟﻜﻠﻤﺔ ‪.new line character‬‬ ‫اﻟﻨﺺ ذاﺗﻪ‪ ،‬ﳝﻜﻦ ﻟﺪاﻟﺔ )(‪ NSLog‬ان ﺗﻄﺒﻊ ﻋﺪة ﻣﻌﻠﻮﻣﺎت اﺿﺎﻓﻴﺔ‪،‬‬
‫]‪[3‬‬ ‫ﻛﺎﻟﺘﺎرﻳﺦ اﳊﺎﻟﻲ واﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻘﺎﺋﻢ‪ .‬ﻛﻤﺜﺎل‪ ،‬ﻣﺨﺮﺟﺎت ﻫﺬﻩ‬
‫;)”‪NSLog(@”Julia is a pretty \nactress.‬‬
‫اﻟﺪاﻟﺔ اﻟﻜﺎﻣﻠﺔ ﻋﻠﻰ ﻧﻈﺎﻣﻲ ﺳﺘﻜﻮن‪:‬‬
‫اﻻن ﺳﻴﻜﻮن اﳋﺮج ﻛﻤﺎ ﻳﻠﻲ ‪-‬ﻣﻊ اﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﻣﺎ ﻳﻬﻤﻨﺎ ﻓﻘﻂ‪-‬‬
‫‪2005-12-22 17:39:23.084 test[399] Julia is‬‬
‫‪Julia is a pretty‬‬
‫‪actress.‬‬ ‫‪a pretty actress.‬‬
‫‪escape‬‬ ‫ان اﳋﻂ اﳌﺎﺋﻞ "\" ﺑﺎﳌﺜﺎل]‪ [3.1‬ﻳﺪﻋﻰ ﺗﺮﻣﻴﺰ ﻫﺮوب‬ ‫ﳝﻜﻦ ﻟﺴﻠﺴﻠﺔ اﳊﺮوف اﻟﻨﺼﻴﺔ ﻫﺬﻩ ان ﺗﻜﻮن ﺑﻘﻴﻤﺔ ﺻﻔﺮ أو اﻛﺜﺮ‪.‬‬
‫‪ character‬وﻫﻮ ﻳﺴﺘﺨﺪم ﻻﻋﻼم اﻟﺪاﻟﺔ )(‪ NSLog‬ﺑﺄن اﳊﺮف اﻟﺘﺎﻟﻲ‬ ‫ﻣﻠﺤﻮﻇﺔ‪ :‬اﻻﻣﺜﻠﺔ اﻟﺘﺎﻟﻴﺔ ﺗﻌﺮض اﻟﺪوال اﻻﻛﺜﺮ اﻫﻤﻴﺔ دون ﻋﺮض‬
‫ﻓﻲ اﻟﺴﻠﺴﻠﺔ ﻏﻴﺮ ﻗﺎﺑﻞ ﻟﻠﻌﺮض‪ ،‬إن اﳊﺮف اﳋﺎص اﻟﻐﻴﺮ ﻣﻌﺮوض‬ ‫ﻟﻠﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬ﻛﻤﺎ ﻳﻠﻲ‪.‬‬
‫ﻓﻲ ﻫﺬا اﳌﺜﺎل ﻫﻮ ”‪ “n‬وﻫﻮ ﻳﻌﻨﻲ ﻟﻠﺪاﻟﺔ ﻋﺮض ﻣﺎﻳﻠﻲ ﻣﻦ ﺣﺮوف‬ ‫]‪[2‬‬
‫;)””@(‪NSLog‬‬
‫اﻟﺴﻠﺴﻠﺔ ﺑﺴﻄﺮ ﺟﺪﻳﺪ‪.‬‬ ‫;)“ ”@(‪NSLog‬‬
‫ﻓﻲ ﺣﺎﻻت ﻧﺎدرة ﻗﺪ ﺗﺮﻏﺐ ﺑﻄﺒﺎﻋﺔ ﻫﺬا اﳋﻂ اﳌﺎﺋﻞ "\" ﺑﺎﻟﺬات‬ ‫ان اﻻﻳﻌﺎز ﺑﺎﻟﺴﻄﺮ ]‪ [2.1‬ﻳﺤﺘﻮي ﺳﻠﺴﻠﺔ ﺣﺮوف ﻣﺤﺘﻮاﻫﺎ ﻳﺴﺎوي‬
‫ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬ﻓﻤﺎ ﻫﻮ اﻟﻌﻤﻞ؟‬ ‫ﻗﻴﻤﺔ ﺻﻔﺮ وﻫﻲ ﺗﺪﻋﻰ ﺳﻠﺴﻠﺔ ﺣﺮوف ﻓﺎرﻏﺔ ‪) empty string‬اي‬
‫ان ﻃﻮﻟﻬﺎ ﻳﺴﺎوي ﺻﻔﺮ(‪ .‬اﻻﻳﻌﺎز ﺑﺎﻟﺴﻄﺮ ]‪ [2.2‬ﻻ ﻳﺮى ان ﺳﻠﺴﻠﺔ‬
‫ﳝﻜﻨﻚ ﺗﻜﺮار وﺿﻊ اﳋﻂ اﳌﺎﺋﻞ ﺧﻠﻒ )او اﻣﺎم( ذﻟﻚ اﳋﻂ اﳌﺎﺋﻞ‬
‫اﳊﺮوف ﻓﺎرﻏﺔ ‪-‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ ان ﺷﻜﻠﻬﺎ ﻛﺬﻟﻚ‪ -‬ﺑﻞ ﻳﺮاﻫﺎ ﺳﻠﺴﻠﺔ‬
‫‪٢٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬
‫‪ ، integerToDisplay‬ان ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻌﻄﻲ اﻟﻨﺘﻴﺠﺔ اﻟﺘﺎﻟﻴﺔ‪.‬‬ ‫‪-‬اي ﺗﻜﺮرﻩ ﻣﺮﺗﺎن‪ .-‬ﻫﺬا اﻻﻳﻌﺎز ﻳﺨﺒﺮ اﻟﺪاﻟﺔ )(‪ NSLog‬ان اﳊﺮف‬
‫‪The value of the integer is 6.‬‬ ‫اﻟﺘﺎﻟﻲ ﻣﻦ اﳋﻂ اﳌﺎﺋﻞ ﻣﻄﻠﻮب ﻟﻠﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ وان اي ﺣﺮف‬
‫‪%f‬‬ ‫وﻟﻌﺮض ﻋﺪد ﻣﻦ ﻧﻮع ﻛﺴﺮي‪ ،‬ﻳﺠﺐ اﺳﺘﺨﺪام اﳊﺮف اﳋﺎص‬ ‫ﺧﺎص آﺧﺮ ﺳﻴﻜﻮن ﻗﻴﺪ اﻻﻫﻤﺎل‪ .‬ﻫﻨﺎ ﻣﺜﺎل‪:‬‬
‫َ‬
‫ﺑﺪﻻ ﻣﻦ ‪.%d‬‬ ‫]‪[4‬‬
‫;)”‪NSLog(@”Julia is a pretty actress.\\n‬‬
‫]‪[6‬‬
‫;‪float x, floatToDisplay‬‬ ‫اﻟﺒﻴﺎن اﻟﺴﺎﺑﻖ ﻳﻌﺮض ﻣﺎ ﻳﻠﻲ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪.‬‬
‫;‪x = 12345.09876‬‬
‫‪Julia is a pretty actress.\n‬‬
‫;‪floatToDisplay = x/3.1416‬‬
‫‪NSLog(@”The value of the float is %f.”,‬‬
‫;)‪floatToDisplay‬‬
‫ﺣﺘﻰ اﻻن ﻗﻤﻨﺎ ﺑﺎﺳﺘﻌﺮض اﻟﺴﻼﺳﻞ اﻟﺜﺎﺑﺘﺔ‪ ،‬دﻋﻨﺎ ﻧﻄﺒﻊ اﻟﻘﻴﻢ اﻟﻨﺎﲡﺔ‬
‫ﻣﻦ ﺣﺴﺎﺑﺘﻨﺎ اﻟﻰ اﻟﺸﺎﺷﺔ‪.‬‬
‫ﻟﺘﺤﺪﻳﺪ دﻗﺔ ﻋﺮض اﻟﻌﺪد اﻟﻜﺴﺮي ﻳﻌﻮد ﻟﻚ اﻻﻣﺮ ﻓﻲ ﲢﺪﻳﺪ ﻋﺪد‬ ‫]‪[5‬‬
‫اﳋﺎﻧﺎت اﳌﺘﺎﺣﺔ ﺑﻌﺪ اﻟﻔﺎﺻﻠﺔ ‪ .‬ﻓﻠﻌﺮض ﺧﺎﻧﺘﲔ ﺑﻌﺪ اﻟﻔﺎﺻﻠﺔ ادرج‬ ‫;‪int x, integerToDisplay‬‬
‫رﻗﻢ ‪ ٢‬ﻣﺎﺑﲔ اﻟﻌﻼﻣﺔ اﳌﺌﻮﻳﺔ ورﻣﺰ اﻟﻜﺴﺮ ‪.f‬‬ ‫;‪x = 1‬‬
‫;‪integerToDisplay = 5 + x‬‬
‫]‪[7‬‬ ‫‪NSLog(@”The value of the integer is %d.”,‬‬
‫;‪float x, floatToDisplay‬‬ ‫;)‪integerToDisplay‬‬
‫;‪x = 12345.09876‬‬
‫;‪floatToDisplay = x/3.1416‬‬
‫ﻻﺣﻆ وﺟﻮد ﻛﻞ ﻣﻦ ‪ :‬ﺳﻠﺴﻠﺔ ﺣﺮوف‪ ،‬ﻓﺎﺻﻠﺔ واﺳﻢ ﻣﺘﻐﻴﺮ ﻣﺎﺑﲔ‬
‫‪NSLog(@”The value of the float is %.2f.”,‬‬ ‫اﻻﻗﻮاس‪ .‬ﻟﻘﺪ اﺣﺘﻮت ﺳﻠﺴﻠﺔ اﳊﺮوف ﻋﻠﻰ رﻣﺰ ﻋﺠﻴﺐ ‪ :%d‬اﻧﻪ‬
‫;)‪floatToDisplay‬‬
‫رﻣﺰ ﺧﺎص ﻛﺎﳋﻂ اﳌﺎﺋﻞ‪ ،‬ﻓﻌﻼﻣﺔ اﻟﻨﺴﺒﺔ اﳌﺌﻮﻳﺔ وﺣﺮف ‪ d‬ﲤﺜﻞ ﺣﺮف‬
‫ﻗﺪ ﺗﺮﻏﺐ ﺑﺎﻧﺸﺎء ﺟﺪول ﻟﻠﻘﻴﻢ ﻣﻊ اﳊﺴﺎﺑﺎت اﳌﺘﻜﺮرة‪ .‬ﺗﺨﻴﻞ‬ ‫ﻣﻦ اﳊﺮوف اﳋﺎﺻﺔ ﻟﻠﺪاﻟﺔ‪ .‬ﻋﻨﺪ إرﻓﺎق اﻟﺮﻣﺰ اﳌﺌﻮي ﺑﺤﺮف ‪) d‬وﻫﻮ‬
‫ﺟﺪول ﻟﻠﺘﺤﻮﻳﻞ ﻣﺎﺑﲔ ﻣﻌﻄﻴﺎت درﺟﺎت اﳊﺮارة ﺑﺎﻟﺪرﺟﺔ اﳌﺌﻮﻳﺔ‬ ‫اﺧﺘﺼﺎراَ ﻟﻨﻮع ‪ decimal number‬اﻟﻌﺪدي(‪ ،‬اﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‬
‫وﻣﺎ ﻳﻘﺎﺑﻠﻬﺎ ﺑﺎﻟﻔﻬﺮﻧﻬﺎﻳﺖ‪.‬‬ ‫ﺳﻴﺘﻢ اﺳﺘﺒﺪال ذﻟﻚ اﳊﺮف ﺑﺎﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺪل ﻋﻠﻴﻬﺎ ذﻟﻚ اﳌﺘﻐﻴﺮ‬
‫‪٢٧‬‬
‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫رؤﻳﺔ ﻋﺮض اﳌﺴﺎﻓﺎت اﳌﺘﺎﺣﺔ ﻟﻼﻋﺪاد واﻟﺘﻲ ﺗﺪل ﻋﻠﻰ ﺣﺠﺰ زاﺋﺪ‬ ‫اذا اردت ﻋﺮض اﻟﻘﻴﻢ ﺑﺸﻜﻞ ﺻﺤﻴﺢ وﻣﺮﺗﺐ ﻋﻠﻴﻚ ﻋﺮض‬
‫ﻋﻦ ﻣﺴﺎﺣﺔ اﺣﺘﻮاء اﻟﻌﺪد‪.‬ﳝﻜﻨﻨﺎ اﻳﻀ َﺎ ﺗﻀﻤﲔ ﻣﻮاﺻﻔﺎت ﻣﺴﺎﻓﺔ‬ ‫اﻟﺒﻴﺎﻧﺎت ﺿﻤﻦ ﻋﻤﻮد ﻋﺮﺿﻪ ﺛﺎﺑﺖ‪ .‬وﳝﻜﻨﻚ ﲢﺪﻳﺪ اﻟﻌﺮض ﻣﻦ‬
‫اﻟﻌﺮض ﻣﻊ اﻻﻋﺪاد اﻟﻜﺴﺮﻳﺔ‪.‬‬ ‫ﺧﻼل اﺳﺘﺨﺪام اﻟﻘﻴﻢ ﻣﻦ ﻧﻮع ﻋﺪد ﺻﺤﻴﺢ ‪ integer‬وذﻟﻚ ﺑﺎدراج‬
‫]‪[9‬‬ ‫اﻟﻌﺪد ﻣﺎﺑﲔ اﻟﻌﻼﻣﺔ اﳌﺌﻮﻳﺔ ‪ ٪‬وﺣﺮف اﻟﻜﺴﺮ ‪) f‬او اﻟﻌﻼﻣﺔ اﳌﺌﻮﻳﺔ ‪٪‬‬
‫‪float x=1234.5678‬‬
‫‪NSLog(@”Reserve a space of 10, and show 2‬‬
‫وﺣﺮف ‪ (d‬ﻋﻠﻰ ﻛﻞ ﻓﻲ ﺣﺎل ﻛﺎن اﻟﻌﺮض اﳌﺴﻨﺪ اﺻﻐﺮ ﻣﻦ اﻟﻌﺮض‬
‫;”‪significant digits.‬‬ ‫اﳌﺘﺎح ﻟﻠﺮﻗﻢ اﻟﻜﺴﺮي‪ ،‬ﻋﻨﺪﻫﺎ ﺗﻜﻮن اﻻوﻟﻮﻳﺔ ﻟﻠﻌﺪد اﳌﺴﻨﺪ‪.‬‬
‫;)‪NSLog(@”%10.2d”, x‬‬
‫]‪[8‬‬
‫;‪int x = 123456‬‬
‫وﺑﺎﻟﺘﺄﻛﻴﺪ ﳝﻜﻦ ﻋﺮض اﻛﺜﺮ ﻣﻦ ﻗﻴﻤﺔ واﺣﺪة‪ ،‬أو ﺧﻠﻴﻂ ﻣﻦ اﻟﻘﻴﻢ‬ ‫;)‪NSLog(@”%2d”, x‬‬
‫;)‪NSLog(@”%4d”, x‬‬
‫اﳌﺘﻨﻮﻋﺔ‪.‬و ﻳﺠﺐ ﻋﻠﻴﻚ ﻋﻨﺪﻫﺎ ﲢﺪﻳﺪ اﻟﺼﻨﻒ اﻟﺼﺤﻴﺢ ﻟﻠﻘﻴﻢ ‪-‬‬ ‫;)‪NSLog(@”%6d”, x‬‬
‫ﺳﻮاء ﻛﺎﻧﺖ ﺻﺤﻴﺤﺔ ‪ int‬أو ﻛﺴﺮﻳﺔ ‪ -float‬ﺑﺎﺳﺘﺨﺪام اﳊﺮوف‬ ‫;)‪NSLog(@”%8d”, x‬‬
‫اﳋﺎﺻﺔ ‪ %d‬و‪.%f‬‬
‫]‪[10‬‬
‫اﻟﺴﺎﺑﻖ ﻳﻌﻄﻲ اﳋﺮج اﻟﺘﺎﻟﻲ‪:‬‬ ‫اﳌﺜﺎل]‪[8‬‬
‫;‪int x = 8‬‬ ‫‪123456‬‬
‫;‪float pi = 3.1416‬‬ ‫‪123456‬‬
‫‪NSLog(@”The integer value is %d, whereas‬‬ ‫‪123456‬‬
‫;)‪the float value is %f.”, x, pi‬‬ ‫‪123456‬‬
‫ﻣﻦ اﻟﻀﺮوري اﺳﺘﺨﺪام اﻟﺮﻣﺰ اﻟﺼﺤﻴﺢ ﻣﻊ ﻧﻮع ﺻﻨﻒ اﳌﺘﻐﻴﺮ‪،‬‬ ‫ان اﻻﻳﻌﺎزان ]‪ [8.1, 8.2‬ﻳﺴﻨﺪﻧﺎن ﻣﺴﺎﺣﺎت ﻗﻠﻴﻠﺔ ﻣﻦ اﳋﺎﻧﺎت اﳌﺘﺎﺣﺔ‬
‫اﳌﺠﻤﻊ ﻟﻠﻘﻴﻤﺔ اﻻوﻟﻰ ﻓﺈﻧﻚ ﻟﻦ ﺗﻨﺠﻮ‬ ‫ﻓﻲ ﺣﺎل ﻗﻴﺎﻣﻚ ﺑﺈﺳﺘﻐﻔﺎل ّ‬ ‫ﻟﻼﻋﺪاد اﳌﻌﺮوﺿﺔ‪ ،‬وﻟﻜﻦ اﳌﺴﺎﺣﺔ اﳌﺘﺎﺣﺔ ﻣﺄﺧﻮذة ﻋﻠﻰ ﻛﻞ ﺣﺎل‪.‬‬
‫ﻣﺤﺎوﻟﺘﻚ ﺣﻴﺚ ﺳﻨﻌﺮض اﻟﻘﻴﻤﺔ اﻟﺘﺎﻟﻴﺔ ﻟﻌﺪم اﻟﻌﺮض‪ .‬ﻛﻤﺜﺎل‪،‬‬ ‫ﻓﻘﻂ اﻻﻳﻌﺎز ]‪ [8.4‬ﻳﺴﻨﺪ ﻣﺴﺎﺣﺔ اﻋﺮض ﻣﻦ اﻟﻘﻴﻤﺔ‪ ،‬ﻟﺬا ﳝﻜﻨﻨﺎ‬
‫‪٢٨‬‬
Xcode ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ‬ ‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬
[11] [10b]
#import <Foundation/Foundation.h> int x = 8;
float circleArea(float theRadius); float pi = 3.1416;
float rectangleArea(float width, float NSLog(@”The integer value is %f, whereas
the float value is %f.”, x, pi);
height);
int main() :‫ﺧﺮج ﻫﺬﻩ اﻟﺸﻔﺮة اﻟﻨﺎﰋ ﻛﺎﻟﺘﺎﻟﻲ‬

{
The integer value is 0.000000, whereas the
float pictureWidth, pictureHeight,
float value is 0.000000.
pictureSurfaceArea,
circleRadius, circleSurfaceArea;
pictureWidth = 8.0; ‫ﻟﺪﻳﻨﺎ ﺳﺆال واﺣﺪ واﺟﺎﺑﺔ واﺣﺪة ﻗﺒﻞ اﳌﻀﻲ ﺑﺘﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺠﻨﺎ‬
pictureHeight = 4.5; ‫ ؟‬NSLog() ‫ وﻫﻮ ﻛﻴﻒ إﺳﺘﻄﺎع ﺑﺮﻧﺎﻣﺠﻨﺎ اﻟﺘﻌﺮف ﻋﻠﻰ داﻟﺔ‬.‫اﻻول‬
circleRadius = 5.0;
pictureSurfaceArea = rectangleArea(pictur ‫ﻓﻲ اﳊﻘﻴﻘﺔ ﺑﺮﻧﺎﻣﺠﻨﺎ ﻟﻦ ﻳﺴﺘﻄﻴﻊ اﻟﺘﻌﺮف ﻋﻠﻴﻬﺎ اﻻ اذا ﻋﺮﻓﻨﺎﻩ ﺑﻬﺎ‬
eWidth, pictureHeight);
‫اﳌﺠﻤﻊ ﺑﺠﻠﺐ ﻣﻜﺘﺒﺔ‬ ّ ‫ ﻋﻠﻴﻨﺎ اﺧﺒﺎرﻩ ﺑﺄن ﻳﺄﻣﺮ‬،‫ وﻟﻠﻘﻴﺎم ﺑﺬﻟﻚ‬.‫اوﻻ‬
circleSurfaceArea = circleArea(circleRad
ius); ‫ ﻣﻦ ﺧﻼل‬NSLog() ‫ واﻟﺘﻲ ﻣﻦ ﺿﻤﻨﻬﺎ داﻟﺔ‬،‫ﻣﻦ اﻟﺪوال اﳌﻔﻴﺪة‬
NSLog(@”Area of circle: %10.2f.”, :‫اﻻﻳﻌﺎز اﻟﺘﺎﻟﻲ‬
circleSurfaceArea);
#import <Foundation/Foundation.h>
NSLog(@”Area of picture: %f. “,
pictureSurfaceArea); ‫ﻫﺬا اﻻﻳﻌﺎز ﻳﺠﺐ ان ﻳﻜﻮن اول أﻣﺮ ﻣﻜﺘﻮب ﺑﺎﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬
}
return 0;
،‫ واﻻن اذا وﺿﻌﻨﺎ ﻛﻞ ﻣﺎ ﺗﻌﻠﻤﻨﺎﻩ ﺧﻼل ﻫﺬ اﻟﻔﺼﻞ‬.‫ﻟﻠﺒﺮﻧﺎﻣﺞ‬
// continued ... ‫ واﻟﺘﻲ ﺳﻮف ﻧﻘﻮم ﺑﺘﻨﻔﻴﺬﻫﺎ‬،‫ﺳﻴﻜﻮن ﻟﺪﻳﻨﺎ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﺎﻟﻴﺔ‬
.‫ﺑﺎﻟﻔﺼﻞ اﻟﺘﺎﻟﻲ‬
٢٩
‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬ Xcode ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ‬
float circleArea(float theRadius)

// first custom function
{
float theArea;
theArea = 3.1416 * theRadius * theRadius;
return theArea;
}
float rectangleArea(float width, float height)

// second custom function
{
return width*height;
}
٣٠
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﲡﻤﻴﻊ وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﲡﻤﻴﻊ وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬

‫ﺣﺘﻰ اﻻن ﺗﻌﺪ ﻛﺎﻓﺔ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ اﺳﺘﻌﺮﺿﻨﺎﻫﺎ ﻋﺒﺎرة‬
‫ﻋﻦ ﻧﺼﻮص ﻗﺎﺑﻠﺔ ﻟﻠﻘﺮاءة ﻣﻦ ﻗﺒﻠﻨﺎ ﻧﺤﻦ اﻟﺒﺸﺮ‪ ،‬وﻟﻮ اﻧﻬﺎ ﻟﻴﺴﺖ‬
‫ﻣﺼﺎﻏﺔ ﺑﺎﻟﺸﻜﻞ اﻟﺒﺪﻳﻬﻲ اﳌﻌﺘﺎد‪ ،‬ﺳﻴﻌﺎﻧﻲ اﳌﺎﻛﻨﺘﻮش اﻻﻣﺮﻳﻦ ﻟﻮ‬ ‫ُ‬
‫ﺣﺎول اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻛﻤﺎ ﻫﻲ‪ .‬ﻓﻲ اﻟﻮاﻗﻊ ﻟﻦ ﳝﻜﻨﻪ ﲢﺮﻳﻚ ﺳﺎﻛﻦ‬
‫ﻋﻠﻰ اﻻﻃﻼق!‬
‫اﳌﺠﻤﻊ ‪ compiler‬وﻫﻮ ﺿﺮوري ﻟﺘﺤﻮﻳﻞ‬ ‫ﻳﻮﺟﺪ ﺑﺮﻧﺎﻣﺞ ﺧﺎص ﻳﺪﻋﻲ ّ‬
‫وﺗﻔﺴﻴﺮ ﺗﻠﻚ اﻟﻨﺼﻮص اﻟﻰ ﺷﻔﺮة واﻛﻮاد ﺗﺸﻐﻴﻠﻴﺔ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻨﻔﻴﺬ ﻣﻦ‬
‫اﳌﺠﻤﻊ ﺟﺰء ﻣﻦ ﺑﻴﺌﺔ اﻟﺒﺮﻣﺠﺔ اﻟﺘﻲ ﺗﺰودك‬ ‫ﻗﺒﻞ اﳌﺎﻛﻨﺘﻮش‪ .‬ﻳﻌﺪ ّ‬
‫ﺑﻬﺎ أﭘﻞ ﻣﻊ ‪ .Xcode‬وﻳﻔﺘﺮض اﻧﻚ ﻗﺪ ﻗﻤﺖ ﺑﺘﺜﺒﻴﺖ ‪ Xcode‬اﻟﺬي‬
‫ﺟﺎء ﻣﻊ ﻧﻈﺎم اﻟﺘﺸﻐﻴﻞ‪ .‬ﻋﻠﻰ ﻛﻞ ﺣﺎل اﺣﺮص ﻋﻠﻰ ﲢﺪﻳﺜﻪ ﺑﺎﺧﺮ‬
‫اﺻﺪارت أﭘﻞ ﻋﻠﻰ اﻟﻌﻨﻮان اﻟﺘﺎﻟﻲ ‪http://developer.apple.com‬‬
‫)واﻟﺘﺴﺠﻴﻞ اﺟﺒﺎري(‪.‬‬
‫اﻻن ﺷﻐﻞ ﺑﺮﻧﺎﻣﺞ ‪ Xcode،‬اﻟﺬي ﺳﺘﺠﺪﻩ داﺧﻞ ﻣﺠﻠﺪ اﻟﺘﻄﺒﻴﻘﺎت‬
‫ﲟﺠﻠﺪ اﳌﻄﻮرﻳﻦ‪ .‬واذا ﻛﺎﻧﺖ ﻫﺬﻩ اﳌﺮة ﻫﻲ اﻻوﻟﻰ ﻟﺘﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻋﻨﺪﻫﺎ ﺳﻴﻄﺮح ﻋﻠﻴﻚ ﺑﻀﻌﺔ اﺳﺌﻠﺔ‪ .‬ﻗﻢ ﺑﻘﺒﻮل اﻹﻋﺪادات‬
‫اﻻﻓﺘﺮاﺿﻴﺔ‪ ،‬ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﻟﺒﺪء وﳝﻜﻨﻚ دوﻣ َﺎ ﺗﻐﻴﻴﺮ ﺗﻠﻚ‬
‫اﻻﻋﺪادات وﺗﺨﺼﻴﺼﻬﺎ ﺣﺴﺐ اﺣﺘﻴﺎﺟﺎﺗﻚ‪.‬‬
‫‪٣١‬‬
‫ﲡﻤﻴﻊ وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻧﺮﻏﺐ ﺣﺎﻟﻴ َﺎ ﺑﺎﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﺑﺴﻴﻂ ﺟﺪاَ ﻣﺴﺘﺨﺪﻣﲔ ‪، Objective-C‬‬ ‫ﻟﺘﺒﺪء ﻓﻌﻠﻴ َﺎ‪ ،‬اﺧﺘﺮ ﻣﺸﺮوع ﺟﺪﻳﺪ ‪ New Project‬ﻣﻦ ﻗﺎﺋﻤﺔ ﻣﻠﻒ‬
‫)دون اﻟﺘﻄﺮق ﻻﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺒﺮﻣﺠﺔ اﻟﺮﺳﻮﻣﻴﺔ ‪ (GUI‬ﻟﺬا ﺗﻮﺟﺔ‬ ‫‪ File menu‬واﻟﺘﻲ ﺗﻮﺟﺪ ﺑﺄﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ .‬ﺳﻴﻈﻬﺮ ﻟﻚ ﺻﻨﺪوق‬
‫ادﻧﻰ اﻟﻘﺎﺋﻤﺔ واﺧﺘﺮ ”اداة اﺳﺎﺳﻴﺔ ‪ ” Foundation Tool‬ﺣﻴﺚ ﲡﺪﻫﺎ‬ ‫ﺣﻮار ﺳﺎرداَ ﻻﺋﺤﺔ واﻓﻴﺔ ﺑﺨﻴﺎرات اﳌﺸﺎرﻳﻊ اﻟﺘﻲ ﳝﻜﻨﻚ اﻻﻧﻄﻼق‬
‫داﺧﻞ ﻣﺼﻨﻒ ادوات ﺳﻄﺮ اﻻواﻣﺮ ‪.Command Line Utility‬‬ ‫ﻣﻨﻬﺎ ﻟﺘﻄﻮﻳﺮ ﻣﺸﺮوﻋﻚ‪. .‬‬
‫اﻃﻠﻖ اﺳﻤ َﺎ ﳌﺸﺮوﻋﻚ‬
‫اﻃﻠﻖ اﺳﻤ َﺎ ﻟﻠﻤﺸﺮوع وﺣﺪد ﻣﻮﻗﻊ ﺣﻔﻈﻪ داﺧﻞ ﻗﺮﺻﻚ اﻟﺼﻠﺐ‪.‬‬

‫واﲤﻢ اﺟﺮاءات اﻻﻧﺸﺎء ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ازرار اﻻﻧﺘﻬﺎء‪ .‬ﻟﻘﺪ اﺳﻤﻴﻨﺎ‬
‫اﳌﺸﺮوع ‪ justatry‬وﻟﻚ ﺣﺮﻳﺔ اﻟﺘﺴﻤﻴﺔ ﻛﻴﻔﻤﺎ ﺷﺌﺖ‪ .‬ان ﻣﺸﺮوﻋﻨﺎ‬
‫ان اﳌﺴﺎﻋﺪ ّ‬
‫اﳌﻀﻤﻦ ﺑﺎﻟﺒﺮﻧﺎﻣﺞ ﻳﻌﻴﻨﻚ ﻋﻠﻰ اﻧﺸﺎء ﻣﺸﺎرﻳﻌﻚ ﺑﺸﻜﻞ اﺳﺮع‬
‫ﻗﻴﺪ اﻻﻧﺸﺎء ﻣﻌﺪ ﻟﻠﻌﻤﻞ ﻣﻦ ﺧﻼل وﺣﺪة ﻃﺮﻓﻴﺔ ‪ Terminal‬ﺗﺴﺘﺨﺪم‬
‫‪٣٢‬‬
‫ﻫﺬﻩ اﳌﻠﻔﺎت ّﲡﻤﻊ وﲢﻔﻆ داﺧﻞ اﻻﻃﺎر ﲟﺠﻠﺪات اﻓﺘﺮاﺿﻴﺔ‪ ،‬ﻓﻤﺎ‬ ‫ﺳﻄﺮ اﻻواﻣﺮ ﻛﺎﺳﻠﻮب ﺗﻔﺎﻋﻠﻲ ﻣﻊ اﳊﺎﺳﺐ‪ .‬وﺣﺘﻰ ﺗﺘﺠﻨﺐ ﺑﻌﺾ‬
‫ان ﺗﻘﻮم ﺑﻌﻤﻠﻴﺔ ﺗﺼﻔﺢ ﻣﻦ ﺧﻼل ﺑﺮﻧﺎﻣﺞ )‪ (Finder‬اﻟﺬي ﻳﻘﻮم‬ ‫اﻟﻌﻮاﺋﻖ ﻗﻢ ﺑﺎﺧﺘﻴﺎر اﺳﻢ ﻣﻦ ﻛﻠﻤﺔ واﺣﺪة ﳌﺸﺮوﻋﻚ‪.‬‬
‫ﺑﺘﺼﻔﺢ وادارة اﳌﻠﻔﺎت ﻋﻠﻰ اﻟﻘﺮص اﻟﺼﻠﺐ ﳉﻬﺎز اﳌﺎﻛﻨﺘﻮش‪،‬‬
‫ﺗﺸﻐﻞ ﻣﻦ‬‫ان ﻣﻦ اﳌﺘﻌﺎرف ﻋﻠﻴﻪ ﺗﺴﻤﻴﺔ ﻣﻠﻔﺎت اﻷدوات اﻟﺘﻲ ّ‬
‫ﺳﺘﺠﺪ ان ﺗﻠﻚ اﳌﻠﻔﺎت ﺟﻤﻴﻌﻬﺎ ﻣﺤﻔﻮﻇﺔ ﻋﻠﻰ ﻣﺴﺘﻮى ﺟﺬري‬
‫ﺧﻼل اﻟﻮﺣﺪات اﻟﻄﺮﻓﻴﺔ ﺑﺎﺳﻤﺎء ﻳﻜﻮن ﺣﺮﻓﻬﺎ اﻻول ﺻﻐﻴﺮ‪.‬‬
‫واﺣﺪ ‪ Flat Level‬داﺧﻞ ﻣﺠﻠﺪ ﻣﺸﺮوﻋﻚ‪ Xcode .‬ﻳﻮﻓﺮ ﻟﻚ‬
‫ﺑﻴﻨﻤﺎ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ّ‬
‫ﺗﺸﻐﻞ ﻣﻦ ﺧﻼل اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﺑﺎﺳﻤﺎء‬
‫ﻣﻴﺰة اﻟﺘﺮﺗﻴﺐ اﻻﻓﺘﺮاﺿﻲ ﻣﻦ ﺧﻼل ﻓﻜﺮة اﳌﺠﻤﻮﻋﺎت ”‪“groups‬‬
‫ﺣﺮﻓﻬﺎ اﻻول ﻛﺒﻴﺮ‪.‬‬
‫واﻟﻬﺪف ﻣﻨﻬﺎ ﺗﻨﻈﻴﻤﻲ ﺑﺤﺖ‪.‬‬
‫ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ اﳌﺼﺎدر اﳌﺴﻤﺎة ”‪ “Source‬واﻟﺘﻲ‬ ‫ﺗﻮاﺟﻬﻚ ﻧﺎﻓﺬة ﺣﺎﻟﻴ َﺎ‪ ،‬ﺳﺘﺮاﻫﺎ ﻛﺜﻴﺮاَ ﻣﺎ دﻣﺖ ﺑﺤﻘﻞ اﻟﺒﺮﻣﺠﺔ‪ .‬ﻫﺬﻩ‬
‫ﺳﺘﺠﺪﻫﺎ ﺑﺎﻻﻃﺎر اﻻﻳﺴﺮ ﺣﻴﺚ ﺗﻮﺟﺪ اﳌﻠﻔﺎت واﳌﺠﻠﺪات ‪ .‬داﺧﻞ‬ ‫اﻟﻨﺎﻓﺬة ﻣﻜﻮﻧﺔ ﻣﻦ اﻃﺎرﻳﻦ )ﻗﻄﺎﻋﲔ(‪.‬‬
‫ﻫﺬا اﳌﺠﻠﺪ ﺳﺘﺠﺪ ﻣﻠﻒ ‪-‬ﻣﺴﻤﻰ ﺑﺎﺳﻢ ﻣﺸﺮوﻋﻚ‪ -‬وﻫﻮ ﻫﻨﺎ‬ ‫ﳝﺜﻞ اﻻﻃﺎر اﻻﻳﺴﺮ ﻓﻴﻬﺎ ﻋﺮض ﳌﺎ ﻟﺪﻳﻚ ﻣﻦ ﻣﻠﻔﺎت وﻣﺠﻤﻮﻋﺎت‬
‫‪ justry.m‬وﻫﻞ ﺗﺘﺬﻛﺮ ﻛﻴﻒ ان ﻛﻞ ﺑﺮﻧﺎﻣﺞ ﻳﺘﻄﻠﺐ وﺟﻮد داﻟﺔ‬ ‫وذﻟﻚ ﻟﺘﻤﻜﻴﻨﻚ ﻣﻦ اﻟﻨﻔﺎذ اﻟﻰ ﻛﺎﻓﺔ اﳌﻠﻔﺎت اﳌﺴﺎﻫﻤﺔ ﻓﻲ ﺗﻜﻮﻳﻦ‬
‫رﺋﻴﺴﺔ ﺑﺈﺳﻢ )(‪ main‬؟ ﻓﻲ اﳊﻘﻴﻘﺔ ذﻟﻚ ﻫﻮ اﳌﻠﻒ اﶈﺘﻮي ﻟﻠﺪاﻟﺔ‬ ‫ﺑﺮﻧﺎﻣﺠﻚ‪ .‬ﺣﺎﻟﻴ َﺎ ﻻ ﻳﻮﺟﺪ ﻣﻠﻔﺎت ﻛﺜﻴﺮة‪.‬‬
‫اﻟﺮﺋﻴﺴﺔ‪.‬‬
‫ﻓﻲ اﳌﺴﺘﻘﺒﻞ وﻣﻊ ﺗﻌﺎﻣﻠﻚ ﻣﻊ اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﺳﺘﺠﺪ اﻟﻌﺪﻳﺪ‬
‫ﺳﻨﻘﻮم ﻻﺣﻘ َﺎ ﺧﻼل ﻫﺬا اﻟﻔﺼﻞ ﺑﺎﺟﺮاء ﺗﻌﺪﻳﻼت ﻋﻠﻰ اﳌﻠﻒ ﺣﻴﺚ‬
‫ﻣﻦ اﳌﻠﻔﺎت ﻫﻨﺎ‪.‬‬
‫ﺳﻴﺸﻤﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﻳﺘﻜﻮن ﻣﻨﻬﺎ ﺑﺮﻧﺎﻣﺠﻨﺎ‪ .‬اذا ﻗﻤﺖ‬
‫ﺑﻔﺘﺢ اﳌﻠﻒ اﳌﺴﻤﻰ ‪ justatry.m‬وذﻟﻚ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻳﻘﻮﻧﺔ اﳌﻠﻒ‬ ‫ُﻳﻌﺪ اﻻﻃﺎر اﻻﻳﺴﺮ اﳌﻨﻈﻢ اﻟﺬي ﻳﻌﺮض ﻟﻚ ﻣﺼﺎدر اﳌﻠﻔﺎت ﺣﻴﺚ‬
‫ﻋﻨﺪﻫﺎ ﺳﺘﺠﺪ ﻣﻔﺎﺟﺄة ﺳﻌﻴﺪة ﺑﺎﻧﺘﻈﺎرك‪ .‬ﻓﻘﺪ ﻗﺎﻣﺖ أﭘﻞ ﺑﻜﺘﺎﺑﺔ‬ ‫ﻳﻌﻴﻨﻚ ﻋﻠﻰ ﺗﺼﻨﻴﻔﻬﺎ وﲡﻤﻴﻌﻬﺎ‪ .‬ﺳﻮاء اﺳﺘﺨﺪﻣﺖ اﻟﻮاﺟﻬﺔ‬
‫اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬ﺑﺎﻟﻨﻴﺎﺑﺔ ﻋﻨﻚ‪.‬‬ ‫اﻟﺮﺳﻮﻣﻴﺔ أو اﻟﻠﻐﺎت اﻻﺧﺮى اﳌﺘﺎﺣﺔ ﻗﻴﺪ اﻟﺘﻌﺎﻣﻞ‪.‬‬
‫‪٣٣‬‬
‫]‪[1‬‬
‫>‪#import <Foundation/Foundation.h‬‬
‫‪int main (int argc, const char * argv[]) //‬‬
‫]‪[1.3‬‬
‫{‬
‫= ‪NSAutoreleasePool * pool‬‬
‫]‪[[NSAutoreleasePool alloc] init]; // [1.5‬‬
‫‪// insert code here...‬‬
‫;)”!‪NSLog(@”Hello, World‬‬
‫]‪[pool release]; //[1.9‬‬
‫}‬
‫ﺳﻮف ﺗﺮى ‪:‬‬

‫‪ -‬اﻳﻌﺎز ﺟﻠﺐ اﻟﺪوال ‪ import‬اﻻﺟﺒﺎري واﻣﺎﻣﻪ ﻋﻼﻣﺔ اﳌﺮﺑﻊ‪#‬‬
‫ﻫﺬا اﻻﻣﺮ اﻟﺬي ﺳﻴﺠﻠﺐ ﻟﻚ داﻟﺔ )(‪.NSLog‬‬
‫‪ -‬داﻟﺔ )(‪ main‬اﻟﺮﺋﻴﺴﺔ‪.‬‬
‫‪ Xcode‬ﻳﺴﺘﻌﺮض داﻟﺔ )(‪ main‬اﻟﺮﺋﻴﺴﺔ‬
‫‪ -‬اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ }{ اﻟﺘﻲ ﺳﺘﺤﺘﻮي اﻟﺒﻨﻴﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﺪاﻟﺔ‪.‬‬
‫ﺗﻔﺤﺺ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﻛﺘﺒﺖ ﺑﺎﻟﻨﻴﺎﺑﺔ ﻋﻨﻚ‪ ،‬وﻫﻲ ﻣﻮﺿﺤﺔ‬
‫‪ -‬ﺗﻌﻠﻴﻘﺎت‪ ،‬ﲢﺜﻨﺎ ﻟﻜﺘﺎﺑﺔ ﺷﻔﺮﺗﻨﺎ اﻟﺒﺮﻣﺠﻴﺔ ﻣﻜﺎﻧﻬﺎ‪.‬‬
‫ﺑﺎﳌﺜﺎل ]‪ [1‬وﺣﺎول اﻟﺘﻌﺮف ﻋﻠﻰ ﻣﺎ ﺗﺄﻟﻔﻪ ﻣﻦ اواﻣﺮ وداﻻت رأﻳﻨﺎﻫﺎ‬
‫‪ -‬اﻳﻌﺎز ﻳﺴﺘﺨﺪم داﻟﺔ ‪ NSlog‬ﻟﻄﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ اﳊﺮوف‪.‬‬ ‫ﺳﺎﺑﻘ َﺎ ‪:‬‬
‫‪ -‬اﻳﻌﺎز اﻻرﺟﺎع ‪ ، return‬اﻟﺬي ﻳﻌﻠﻦ ﺣﲔ إﻧﺘﻬﺎء اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﺗﻮﺟﺪ ﻋﻠﻰ اﻳﺔ ﺣﺎل ﻋﺪة اﻳﻌﺎزات ﻏﻴﺮ ﻣﺄﻟﻮﻓﺔ ﻟﺪﻳﻚ‪:‬‬
‫‪٣٤‬‬
‫اﳌﻜﺎﺳﺐاﳉﻴﺪة ﻫﻨﺎ‪،‬ﻫﻲواﻗﻊاﻧﺘﻬﺎﺋﻚﻣﻦﻗﺮاءةﻓﺼﻠﲔﻣﻦاﻛﺜﺮ اﻟﻔﺼﻮل‬ ‫‪ -‬ﻣﻌﺎﻣﻼت ﻏﺮﻳﺒﺔ اﻟﺸﻜﻞ ][‪،int argc, const char * argv‬‬
‫ﺻﻌﻮﺑﺔ ﺑﻬﺬا اﻟﻜﺘﺎب‪ ،‬واﻧﻚ ﻣﻘﺒﻞ ﻋﻠﻰ ﺛﻼﺛﺔ ﻓﺼﻮل ﺳﻬﻠﺔ ﻧﺴﺒﻴ َﺎ ﻗﺒﻞ‬ ‫ﻣﺤﺼﻮرة ﺑﲔ اﻗﻮاس اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ ]‪.main() [1.3‬‬
‫ان ﻧﺘﻮاﺟﻪ ﻣﺮة اﺧﺮى ﻣﻊ اﻣﻮر ﺗﺘﻄﻠﺐ ﻗﺪراَ ﻣﻦ اﻟﺘﺮﻛﻴﺰ اﻟﻨﺴﺒﻲ‪.‬‬ ‫‪NSAutoreleasePool‬‬ ‫‪ -‬اﻳﻌﺎز ﺑﺪء ﻋﻤﻞ ﻟﺪاﻟﺔ ﻏﺮﻳﺒﺔ اﺳﻤﻬﺎ‬
‫ﺑﺎﻟﺴﻄﺮ ]‪.[1.5‬‬
‫ﻓﻲ ﺣﺎل ﻋﺪم رﻏﺒﺘﻚ ﲟﻐﺎدرة ﻫﺬا اﳉﺰء اﻻ ﺑﻮﺟﻮد ﺗﻔﺴﻴﺮ‬ ‫و ‪ release‬ﺑﺎﻟﺴﻄﺮ ]‪. [1.9‬‬ ‫ﻛﻠﻤﺘﻲ ‪pool‬‬ ‫‪ -‬اﻳﻌﺎز آﺧﺮ ﻳﺤﺘﻮي‬
‫ﺣﻮل ﻣﺎ ﺳﺒﻖ‪ ،‬ﻟﻴﻜﻦ ﻟﺪﻳﻚ ﻫﺬا اﻟﺘﻔﺴﻴﺮ اﳌﻘﺘﻀﺐ‪:‬‬ ‫ﺷﺨﺼﻴ َﺎ اﺷﻌﺮ ﺑﻌﺪم اﻟﺮﺿﺎ ﻋﻨﺪﻣﺎ ﻳﻘﻮم ﻣﺆﻟﻔﻲ اﻟﻜﺘﺐ ﺑﻘﺬﻓﻲ‬
‫إن ﻣﻌﺎﻣﻼت اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ ‪ main‬ﻣﻄﻠﻮﺑﺔ ﻣﺘﻰ ﰎ ﺗﺸﻐﻴﻞ‬ ‫ﲟﺠﻤﻮﻋﺔ ﻛﺒﻴﺮة ﻣﻦ اﻟﺮﻣﻮز اﻟﻐﻴﺮ ﻣﺄﻟﻮﻓﺔ ﻣﻊ وﻋﺪ ﻗﺎﻃﻊ ﺑﺎﻧﻬﺎ ﺳﺘﻜﻮن‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ ﺧﻼل اﻟﻮﺣﺪة اﻟﻄﺮﻓﻴﺔ ‪. Terminal‬وﺑﺮﻧﺎﻣﺠﻚ‬ ‫ﻣﻔﻬﻮﻣﺔ وﻣﺄﻟﻮﻓﺔ ﺑﻌﺪ ﻓﺘﺮة‪ .‬ﻟﺬﻟﻚ ﻛﻤﺎ ﺗﺮى ارﺗﺄﻳﻨﺎ ﺗﻌﺮﻳﻔﻚ ﲟﻔﻬﻮم‬
‫ﻛﺎي ﺑﺮﻧﺎﻣﺞ اﺧﺮ ﻳﺘﻄﻠﺐ ﺣﺠﺰ ﻗﺪراَ ﻣﻦ اﻟﺬاﻛﺮة اﳌﺘﺎﺣﺔ‪ ،‬ذﻟﻚ‬ ‫اﻟﺪوال وﺟﻌﻠﻨﺎﻩ ﻣﻮﺿﻮﻋ َﺎ ﻣﺄﻟﻮﻓ َﺎ ﻗﺒﻞ اﳋﻮض ﺑﻐﻤﺎر اﻟﺘﻌﺮﻳﻔﺎت‬
‫اﻟﻘﺪر اﻟﺬي ﺳﺘﺮﻏﺐ اﻟﺒﺮاﻣﺞ اﻻﺧﺮى ﺑﺤﺠﺰﻫﺎ ﻟﻨﻔﺴﻬﺎ ﻓﻮر‬ ‫اﻻﺧﺮى اﻟﺘﻲ ﻗﺪ ﺗﺸﻜﻞ ﺻﻌﻮﺑﺔ ﻓﻲ اﻟﻔﻬﻢ‪.‬‬
‫اﻧﺘﻬﺎء ﺑﺮﻧﺎﻣﺠﻚ ﻣﻨﻬﺎ‪.‬‬ ‫ﻟﻘﺪ آﻟﻔﺖ ﻣﻔﻬﻮم اﻟﺪوال وﻣﺎ ﻫﻮ دورﻫﺎ ﻓﻲ ﺗﻨﻈﻴﻢ ﺗﺮﻛﻴﺐ اﺟﺰاء‬
‫وﻣﻦ واﺟﺒﻚ ﻛﻤﺒﺮﻣﺞ‪ ،‬اﻟﻘﻴﺎم ﺑﺤﺠﺰ ذﻟﻚ اﻟﻘﺪر ﻣﻦ اﻟﺬاﻛﺮة‬ ‫اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬وﻛﻴﻒ ان اي ﺑﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي داﻟﺔ رﺋﻴﺴﺔ ﻫﻲ )(‪، main‬‬
‫اﻟﺘﻲ ﻳﺤﺘﺎﺟﻬﺎ ﺑﺮﻧﺎﻣﺠﻚ‪ ،‬وﻳﺘﺮﺗﺐ ﻋﻠﻴﻚ اﻳﻀ َﺎ ﻣﻬﻤﺔ ارﺟﺎﻋﻬﺎ‬ ‫ﻋﻠﻰ اﻻﻋﺘﺮاف ﺑﺎﻧﻪ ﻻ ﳝﻜﻨﻨﻲ‬
‫وﻛﻴﻒ ﻫﻮ ﺷﻜﻞ ﻫﺬﻩ اﻟﺪوال‪ .‬وﻟﻜﻦ ّ‬
‫ﻟﻠﻨﻈﺎم ﻓﻮر اﻧﺘﻬﺎﺋﻚ ﻣﻨﻬﺎ ﺣﺘﻰ ﻳﺘﻴﺤﻬﺎ ﳌﻦ ﻳﺮﻏﺐ ﺑﺎﺳﺘﺨﺪاﻣﻬﺎ‪.‬‬ ‫ﺷﺮح ﻛﻞ ﺗﺮاﻩ ﺑﺎﳌﺜﺎل رﻗﻢ ]‪ [1‬ﺣﺎﻟﻴ َﺎ ﻋﻠﻰ اﻻﻗﻞ‪.‬‬
‫ذﻟﻚ ﻣﺎ ﻳﻘﻮم ﺑﻪ اﻻﻳﻌﺎزان اﻟﻠﺬان ﻳﺤﺘﻮﻳﺎن ﻛﻠﻤﺔ ”‪“pool‬‬ ‫ﻟﺬا آﻣﻞ ﻣﻨﻚ اﳌﻌﺬرة ﺣﻴﺚ ﺳﺎﻃﻠﺐ ﻣﻨﻚ ﲡﺎﻫﻞ اﻻﻳﻌﺎزات اﻟﻐﻴﺮ‬
‫داﺧﻠﻬﻤﺎ‪.‬‬ ‫ﻣﺄﻟﻮﻓﺔ ﻟﺪﻳﻚ )اﻋﻨﻲ ﺑﺬﻟﻚ ﻛﻞ ﻣﻦ ]‪ ( [1.3, 1.5 , 1.9‬ﻓﻲ اﻟﻮﻗﺖ‬
‫اﳊﺎﻟﻲ‪ .‬ﻓﻬﻨﺎك اﻣﻮر وﻣﻔﺎﻫﻴﻢ ﻋﺪﻳﺪة ﺗﺘﻄﻠﺐ ﻣﻨﻚ ان ﺗﺄﻟﻔﻬﺎ َ‬
‫اوﻻ ﺑـ‬
‫‪ Objective-C‬ﳑﺎ ّ‬
‫ﳝﻜﻨﻚ ﻣﻦ ﻛﺘﺎﺑﺔ اﻟﺒﺮاﻣﺞ ﺑﺴﻬﻮﻟﺔ اﻛﺜﺮ ‪.‬‬
‫‪٣٥‬‬
‫]‪[2‬‬
‫>‪#import <Foundation/Foundation.h‬‬ ‫دﻋﻨﺎ اﻻن ّ‬
‫ﻧﺸﻐﻞ اﻟﺒﺮﻧﺎﻣﺞ اﳌﻘﺪم اﻟﻴﻨﺎ ﻣﻦ‬
‫ﻗﺒﻞ أﭘﻞ‪ ،‬ﻓﻲ اﳌﺜﺎل ]‪ .[1‬اﺿﻐﻂ اﻻزرار‬
‫)][‪int main (int argc, const char * argv‬‬
‫{‬ ‫ازرار ‪Build‬‬
‫اﻟﺜﺎﻧﻲ اﻟﺬي ﻳﺤﺘﻮي ﺻﻮرة ﻣﻄﺮﻗﺔ وﻳﻈﻬﺮ‬
‫= ‪NSAutoreleasePool * pool‬‬ ‫‪and Go‬‬ ‫اﺳﻢ ‪ Build،‬ﺑﺸﺰﻳﻂ اﻻدوات‪ ،‬وﺗﻮﺟﻪ اﻟﻰ‬
‫;]‪[[NSAutoreleasePool alloc] init‬‬
‫‪// insert code here...‬‬ ‫ﺑﻨﺪ ‪ compile build‬وﺷﻐّﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫)”‪NSLog(@”Julia is a pretty actress‬‬ ‫‪//‬‬
‫!‪Whoops, forgot the semicolon‬‬
‫]‪[pool release]; //[2.9‬‬ ‫ﺳﻴﺘﻢ ّﲡﻤﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ ﺛﻢ ﺗﺸﻐﻴﻠﻪ‪ ،‬وﺳﻴﺘﻢ ﻋﺮض اﻟﻨﺘﺎﺋﺞ داﺧﻞ اﻃﺎر‬
‫}‬ ‫ﻧﺎﻓﺬة اﻟﺘﻮﺛﻴﻖ ‪ ، Run Log window‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﺑﻌﺾ اﳌﻌﻠﻮﻣﺎت‬
‫اﻻﺿﺎﻓﻴﺔ‪ .‬إن آﺧﺮ ﺟﻤﻠﺔ ﺳﺘﻘﺮأﻫﺎ ﺗﻔﻴﺪ ﺧﺮوج اﻟﺒﺮﻧﺎﻣﺞ وﺗﻮﻗﻔﻪ ﻋﻦ‬
‫ﻟﺘﺠﻤﻴﻊ وﺑﻨﺎء ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬اﺿﻐﻂ اﻳﻘﻮﻧﺔ اﻟﺒﻨﺎء اﳌﻮﺟﻮدة ﺑﺸﺮﻳﻂ‬
‫ّ‬ ‫اﻟﻌﻤﻞ ﺑﻘﻴﻤﺔ ﻣﻘﺪارﻫﺎ ﺻﻔﺮ‪.‬‬
‫اﻷدوات‪ .‬ﺳﺘﻈﻬﺮ ﻟﻚ داﺋﺮة ﺻﻐﻴﺮة ﺣﻤﺮاء اﻣﺎم اﻻﻳﻌﺎز ]‪.[2.9‬‬
‫ﺗﻠﻚ اﻟﻘﻴﻤﺔ اﻟﺘﻲ اﻧﺘﺠﺘﻬﺎ اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪، main‬واﻟﺘﻲ ﰎ ذﻛﺮﻫﺎ‬
‫ﺑﺎﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ ]‪ [7.9‬ﻟﺬا ﻣﻦ اﻟﻮاﺿﺢ ان ﺑﺮﻧﺎﻣﺠﻨﺎ ﻗﺪ ﻧﻔﺬ ﻛﺎﻓﺔ اﳌﻬﺎم‬
‫اﳌﺪرﺟﺔ ﻟﺪﻳﺔ ﺣﺘﻰ آﺧﺮ ﺳﻄﺮ‪ ،‬وﻟﻢ ﻳﺘﻮﻗﻒ ﺑﺸﻜﻞ ﻣﺒﻜﺮ‪ .‬ﺣﺘﻰ اﻻن‬
‫‪ Xcode‬ﻳﺒﻠﻴﻐﻚ ﻋﻦ وﺟﻮد ﺧﻄﺎء‬ ‫اﻻﻣﻮر ﺗﺴﻴﺮ ﻋﻠﻰ ﻣﺎ ﻳﺮام!‬
‫اﻟﺘﺠﻤﻴﻊ‪ ،‬ﻓﺘﻠﻚ‬
‫ﻟﻘﺪ ﻗﺎم ‪ Xcode‬ﺑﺘﺒﻠﻴﻐﻚ ﻋﻦ وﺟﻮد ﺧﻄﺎء اﺛﻨﺎء ّ‬ ‫ﻧﻌﻮد اﻟﻰ ﻣﺜﺎﻟﻨﺎ ]‪ [1‬ﻟﻨﺮى ﻣﺎ ﺳﻴﺤﺪث ﻟﻮ ﻛﺎن ﻫﻨﺎك ﻣﺸﻜﻠﺔ ﺑﺮﻣﺠﻴﺔ‬
‫ﻫﻲ ﻃﺮﻳﻘﺘﻪ ‪ -‬وإذا ﺿﻐﻄﺖ اﻟﺪاﺋﺮة اﳊﻤﺮاء‪ ،‬ﺳﻴﻈﻬﺮ ﻟﻚ ﺳﻄﺮ ﻣﻦ‬ ‫‪.bug‬‬
‫اﳌﻌﻠﻮﻣﺎت اﳌﻘﺘﻀﺒﺔ اﺳﻔﻞ ﺷﺮﻳﻂ اﻷدوات ﺷﺎرﺣ َﺎ ﺳﺒﺐ اﻻﻋﺘﺮاض‪:‬‬ ‫ﻛﻤﺜﺎل ﻗﻤﺖ ﺑﺎﺳﺘﺒﺪال داﻟﺔ ‪ NSLog‬ﺑﺪاﻟﺔ اﺧﺮى وﻟﻜﻨﻨﻲ ”اﻏﻔﻠﺖ‬
‫‪error: parse error before “release”.‬‬ ‫ﻋﻤﺪاَ“ اﺿﺎﻓﺔ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ اﻟﺘﻲ ﺗﻌﻠﻦ اﻧﺘﻬﺎء اﻟﺴﻄﺮ‪.‬‬
‫‪٣٦‬‬
‫وﻟﻨﺮى‬ ‫]‪[1‬‬ ‫وﻟﻨﺪرﺟﻬﺎ ﺑﺸﻔﺮة ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻗﺪﻣﺘﻪ ﻟﻨﺎ أﭘﻞ‬ ‫اﳌﺠﻤﻊ‪:‬‬
‫ان ﻋﻤﻠﻴﺔ اﻟﺘﻔﺴﻴﺮ ﻣﺮﺣﻠﺔ ﻣﻦ اﺣﺪ اﳌﺮاﺣﻞ اﻟﺘﻲ ﻳﻘﻮم ﺑﻬﺎ ّ‬
‫ﻧﺘﺎﺟﻪ ﺑﺎﳌﺜﺎل ]‪[3‬‬ ‫ﻓﻬﻮ ﻳﺴﺒﺮ ﻛﺎﻓﺔ ﺳﻄﻮر اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣ ّﻘﻴﻤ َﺎ ﻣﺎ اذا ﻛﺎﻧﺖ ﻣﻘﺒﻮﻟﺔ‬
‫]‪[3‬‬ ‫ﻟﺪﻳﻪ أو ﻣﺮﻓﻮﺿﺔ‪.‬‬
‫اﳌﺠﻤﻊ ﺑﺒﻌﺾ اﳊﻠﻮل‪ ،‬ﻓﻨﺤﻦ ﻧﻘﺪم ﻟﻪ ﻳﺪ‬ ‫واﻻﻣﺮ ﻳﻌﻮد ﻟﻚ ﻟﺘﺰوﻳﺪ ّ‬
‫اﻟﻌﻮن ﻟﺘﻘﺒﻞ ﺑﻌﺾ اﳉﺰﺋﻴﺎت‪ ،‬ﻓﺈﻳﻌﺎز ﺟﻠﺐ اﳌﺼﺎدر ‪ import‬ﻣﺼﺮح‬
‫;)‪float circleArea(float theRadius‬‬ ‫‪//‬‬ ‫ﻋﻨﻪ ﺑﺎﺳﺘﺨﺪام رﻣﺰ اﳌﺮﺑﻊ ‪ ،#‬وﻟﻠﺘﻨﻮﻳﻪ ﻋﻦ اﻧﺘﻬﺎء ﺳﻄﺮ اﻟﺸﻔﺮة‬
‫]‪[3.3‬‬
‫اﳌﺠﻤﻊ‬
‫اﻟﺒﺮﻣﺠﻲ إﺳﺘﺨﺪﻣﻨﺎ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ ]‪ ، [2.8‬وﺑﻴﻨﻤﺎ ﻳﺴﺒﺮ ّ‬
‫)][‪int main (int argc, const char * argv‬‬ ‫اﻻﻳﻌﺎز ]‪ [2.9‬ﺳﻴﻠﺤﻆ اﻣﺮاَ ﻳﺸﻜﻞ ﺧﻄﺎء ﻳﺴﺘﺪﻋﻲ ﻣﻨﻪ اﻟﺘﻮﻗﻒ‪.‬‬
‫]‪// [3.5‬‬
‫{‬ ‫اﳌﺠﻤﻊ ﻣﻜﻤﻦ ﺣﺪوث اﳋﻄﺎء ﺑﺬﻟﻚ‬ ‫ﻋﻠﻰ ﻛﻞ ﺣﺎل ﻟﻦ ﻳﺪرك ّ‬
‫= ‪NSAutoreleasePool * pool‬‬ ‫اﻟﺴﻄﺮ‪ ،‬ﺑﻞ ﺳﻴﻘﻮم ﺑﺎﻟﻘﺎء اﳋﻄﺎء ﻋﻠﻰ ذﻟﻚ اﻟﺴﻄﺮ اﻟﺬي ﻳﻔﺘﻘﺪ‬
‫;‪int pictureWidth‬‬ ‫اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ‪.‬‬
‫‪float pictureHeight, pictureSurfaceArea,‬‬
‫;‪circleRadius, circleSurfaceArea‬‬ ‫اﳌﺠﻤﻊ ﻳﺤﺎول اﻋﻄﺎءك ﻣﻌﻠﻮﻣﺎت ﺣﻮل اﻻﺧﻄﺎء‬ ‫واﻟﻌﺒﺮة ﻫﻨﺎ ﻫﻲ ان ّ‬
‫;‪pictureWidth = 8‬‬ ‫اﻟﺘﻲ ﻳﺼﺎدﻓﻬﺎ‪ ،‬اﻻ اﻧﻪ ﻓﻲ ﻣﻮاﺿﻊ ﻛﺜﻴﺮة ﻳﻜﻮن ﻏﻴﺮ دﻗﻴﻖ ﻓﻲ وﺿﻊ‬
‫;‪circleRadius = 5.0‬‬ ‫اﻟﻴﺪ ﻋﻠﻴﻬﺎ )ﻫﻮ ﻟﻴﺲ دﻗﻴﻖ ﺑﺎﻟﻀﺮورة وﻟﻜﻨﻪ ﻗﺮﻳﺐ ﻣﻦ ﺗﻌﻴﻴﻨﻬﺎ(‪.‬‬
‫;‪pictureHeight‬‬ ‫ﻗﻢ ﺑﺎﺻﻼح اﳋﻄﺎء اﻟﻮارد ﺑﺎﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﺿﺎﻓﺔ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ اﻟﺘﻲ‬
‫اﻏﻠﻔﻨﺎﻫﺎ ﻋﻤﺪاً وأﻋﺪ ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬وﻛﻦ ﻋﻠﻰ ﻳﻘﲔ ﻣﻦ اﻧﻪ‬
‫‪// Continued ...‬‬
‫ﻳﻌﻤﻞ ﺑﺎﻟﺸﻜﻞ اﳌﺘﻮﻗﻊ اﻟﺬي ﻗﻤﺖ ﺑﺘﺮﺗﻴﺒﺔ‪.‬‬
‫دﻋﻨﺎ اﻻن ﻧﺄﺧﺬ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﺗﻨﺎوﻟﻨﺎﻫﺎ ﺑﺎﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ‬
‫‪٣٧‬‬
‫)(‪main‬‬ ‫ﺑﺎﻟﺴﻄﺮ ]‪ [3.29‬وﻫﻲ اﻟﺘﻲ ﺗﺴﺒﻖ ﻇﻬﻮر اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ‬ ‫‪circleSurfaceArea = circleArea(circleRadi‬‬
‫;)‪us‬‬
‫ﺑـﺎﻟﺴﻄﺮ ]‪ ،[3.5‬ﻓﺘﻠﻚ ﻫﻲ ﻣﻮاﺿﻌﻬﺎ اﻟﺼﺤﻴﺤﺔ‪.‬‬ ‫‪NSLog(@”Area of picture: %f. Area of‬‬
‫‪circle: %10.2f.”,‬‬
‫ﻟﻘﺪ وﺿﻌﻨﺎ اﻟﺒﻨﻴﺔ اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ )(‪ main‬ﺣﻴﺚ اﺧﺒﺮﺗﻨﺎ‬ ‫‪pictureSurfaceArea,‬‬
‫أﭘﻞ‪ ،‬ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺗﻠﻚ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬ﺳﻴﻜﻮن اﳋﺮج ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫;)‪circleSurfaceArea‬‬
‫;]‪[pool release‬‬
‫‪Area of picture: 36.000000. Area of circle:‬‬ ‫;‪return 0‬‬
‫‪78.54.‬‬ ‫}‬
‫)‪float circleArea(float theRadius‬‬
‫‪justatry has exited with status 0.‬‬ ‫]‪// [3.22‬‬
‫{‬
‫ﻟﻘﺪ ﻗﺎم اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻨﻔﻴﺬ اﻟﺘﻌﻠﻴﻤﺎت اﳌﻄﻠﻮﺑﺔ ﻣﻨﻪ واﻧﺘﻬﻰ ﻣﻦ اﻟﻌﻤﻞ‬ ‫;‪float theArea‬‬
‫;‪theArea = 3.1416 * theRadius * theRadius‬‬
‫ﻣﻨﻬﻴ َﺎ ﻧﻔﺴﻪ ﺑﺎن اﻋﻠﻦ ﻋﻦ ذﻟﻚ اﳊﺪث ﺑﻘﻴﻤﺔ ﺻﻔﺮ اﳌﻌﻠﻨﺔ‪ .‬ﻓﻌﻨﺪﻣﺎ‬ ‫;‪return theArea‬‬
‫ﻳﺒﺪأ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺎﻟﺘﻮﺳﻊ واﻟﺘﻌﻘﻴﺪ‪ ،‬ﻋﻨﺪﻫﺎ ﺗﺼﺒﺢ ﻋﻤﻠﻴﺎت ﺗﻘﺼﻲ‬ ‫}‬
‫اﻻﺧﻄﺎء اﻛﺜﺮ ﺻﻌﻮﺑﺔ‪.‬‬ ‫)‪float rectangleArea(float width, float height‬‬
‫ﻟﺬا ﻗﺪ ﺗﺮﻏﺐ اﺣﻴﺎﻧ َﺎ ﲟﻌﺮﻓﺔ ﻣﺎ ﻳﺠﺮي ﺧﻠﻒ اﻟﻜﻮاﻟﻴﺲ اﺛﻨﺎء ﺗﺸﻐﻴﻞ‬

‫]‪// [3.29‬‬
‫{‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ان ‪ Xcode‬ﻳﺴﻬﻞ ﻋﻠﻴﻚ ﻫﺬا اﻻﻣﺮ‪.‬‬ ‫;‪return width*height‬‬
‫}‬
‫ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻬﻮاﻣﺶ اﻟﺮﻣﺎدﻳﺔ اﻣﺎم اﺣﺪ اﻻﻳﻌﺎزات اﻟﺘﻲ‬
‫ﺗﺮﻏﺐ ﺑﺘﻔﺤﺺ ﻗﻴﻤﻬﺎ‪ .‬ﺳﻴﻘﻮم ‪ Xcode‬ﺑﺎدراج ﺳﻬﻢ رﻣﺎدي اﻣﺎم‬
‫ﺧﺬ ﻣﺎ ﻳﺘﻄﻠﺐ ﻣﻦ وﻗﺖ ﻟﺘﻔﺤﺺ واﺳﺘﻴﻌﺎب ﻫﻴﻜﻠﻴﺔ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ذﻟﻚ اﻻﻳﻌﺎز ﺣﻴﺚ ﻳﺴﺠﻠﻪ ﻛﺤﺪث ﻳﺴﺘﻮﺟﺐ اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ‬
‫ﺑﺎﻟﺘﺼﺮﻳﺢ ﻋﻦ داﻻت‬‫ّ‬ ‫ﻓﻠﺪﻳﻨﺎ ﻫﻨﺎ ﺗﺮوﻳﺴﺎت ‪ headers‬وﻫﻲ ﺗﻘﻮم‬
‫”‪ “breakpoint‬اﺛﻨﺎء ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ وﻣﺮورﻩ ﺑﻬﺬا اﻟﺴﻬﻢ‪.‬‬
‫اﺳﺘﺤﺪﺛﻨﺎﻫﺎ ﻣﺜﻞ )(‪ circleArea‬ﺑـ ]‪ [3.22‬و )(‪rectangleArea‬‬
‫‪٣٨‬‬
‫ادراج ﻋﻼﻣﺎت اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ ‪ breakpoint‬داﺧﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬
‫ﻻﺣﻆ اﻧﻚ ﺳﺘﺘﻔﺤﺺ ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات ﲟﺮﺣﻠﺔ ﺗﺴﺒﻖ ﻣﺎﻗﺒﻞ ذﻟﻚ‬

‫اﻻﻳﻌﺎز اﻟﺬي ﻋﻴﻨﺖ ﻋﻨﺪﻩ ﳊﻈﺔ اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ‪ ،‬ﻟﺬا ﻏﺎﻟﺒ َﺎ ﻣﺎ ﺳﺘﻀﻊ‬
‫ﻧﻘﺎط اﻟﺘﻮﻗﻒ ﺑﻌﺪ ذﻟﻚ اﻻﻳﻌﺎز اﻟﺬي ﺗﺮﻏﺐ ﺑﺘﻔﺤﺺ ﻗﻴﻤﺘﻪ‪.‬‬
‫اﻻن اﺿﻐﻂ اﻟﻔﺄرة ﺿﻐﻄﺔ ﻣﺴﺘﻤﺮة داﺧﻞ اﻻزرار اﻟﺜﺎﻧﻲ ﺑﺸﺮﻳﻂ‬
‫اﻷدوات‪ ،‬ﻋﻨﺪﻫﺎ ﺳﺘﻈﻬﺮ ﻟﻚ ﻗﺎﺋﻤﺔ ﻣﻨﺴﺪﻟﺔ ‪.pop-up menu‬‬
‫‪ Xcode‬ﻳﺘﻘﺼﻰ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ﺧﻄﻮة ﺧﻄﻮة‬
‫ﻳﻌﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ اﺛﻨﺎء ﻣﺮﺣﻠﺔ اﻟﺘﻘﺼﻲ ﻫﺬﻩ ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ﺛﻢ ﻳﺘﻮﻗﻒ‬

‫ﻋﻦ ﺗﻨﻔﻴﺬ اﻹﺟﺮاءات ﺣﲔ ﻳﻠﺘﻘﻲ ﺑﺎﺣﺪ ﻋﻼﻣﺎت اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ‪.‬‬
‫اذا ﻗﻤﺖ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻻﻃﺎر اﻻﻋﻠﻰ ﳝﻴﻨ َﺎ‪ ،‬ﺳﺘﺘﻤﻜﻦ ﻋﻨﺪﻫﺎ ﻣﻦ‬
‫ﻗﺎﺋﻤﺔ اﻟﺒﻨﺎء واﻟﺘﺸﻐﻴﻞ ‪Build and Go‬‬
‫رؤﻳﺔ اﻟﻘﻴﻢ اﳌﺨﺰﻧﺔ ﻟﻌﺪد ﻣﻦ اﳌﺘﻐﻴﺮات‪.‬‬
‫اﺧﺘﺮ ﺑﻨﺎء وﺗﻘﺼﻲ ‪ .Build and Debug‬وﺳﺘﺮى اﻟﻨﺎﻓﺬة اﻟﺘﺎﻟﻴﺔ‬
‫ان اي ﻗﻴﻤﺔ ﰎ ﺗﻐﻴﻴﺮﻫﺎ ﻣﻨﺬ اﺧﺮ ﻋﻼﻣﺔ ﺗﻮﻗﻒ ﻣﺆﻗﺖ ﺳﻴﺘﻢ ﻋﺮﺿﻬﺎ‬
‫ﺣﻴﺚ ﻳﺴﻤﺢ ﻟﻚ ‪ Xcode‬ﺑﺘﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺧﻄﻮة ﺧﻄﻮة ﻣﻊ ﻋﺮض‬
‫ﺑﺎﻟﻠﻮن اﻻﺣﻤﺮ‪.‬وﻟﻠﺴﻤﺎح ﻟﻠﺒﺮﻧﺎﻣﺞ ان ﻳﻜﻤﻞ ﻋﻤﻠﻪ اﺳﺘﺨﺪم ازرار‬
‫ﻟﻠﻤﺘﻐﻴﺮات وﻗﻴﻤﻬﺎ اﻳﻀ َﺎ ﻣﻊ ﻛﻞ ﺧﻄﻮة‪.‬‬
‫اﻻﺳﺘﻤﺮار‪ .‬إن ﺑﺮﻧﺎﻣﺞ ﺗﻘﺼﻲ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ‪ debugger‬اداة ذات‬
‫‪٣٩‬‬
‫اﻫﻤﻴﺔ ﻗﻮﻳﺔ‪ .‬ﻓﺤﺎول ان ﺗﺘﻌﺎﻣﻞ ﻣﻌﻪ ﺣﺘﻰ ﺗﺄﻟﻒ ﻃﺮﻳﻘﺔ ﻋﻤﻠﻪ‪.‬‬

‫ﻟﺪﻳﻨﺎ اﻻن ﻛﻞ ﻣﺎ ﻧﺤﺘﺎﺟﺔ ﻟﺘﺼﻤﻴﻢ و ﻛﺘﺎﺑﺔ اﻟﺒﺮاﻣﺞ‪ ،‬وﺗﻘﺼﻲ أﺧﻄﺎء‬
‫اﻟﺒﺮﻣﺠﺔ واﻣﻜﺎﻧﻴﺔ ﺗﺸﻐﻴﻞ اﻟﺒﺮاﻣﺞ اﻟﺒﺴﻴﻄﺔ ‪-‬ﻣﻨﻌﺪﻣﺔ اﻟﻮاﺟﻬﺎت‬
‫اﻟﺮﺳﻮﻣﻴﺔ‪ -‬ﻋﻠﻰ ﻧﻈﺎم ‪. Mac OS X‬‬
‫ﻓﻲ ﺣﺎل ﻋﺪم رﻏﺒﺘﻚ ﺑﺘﺼﻤﻴﻢ ﺑﺮاﻣﺞ ﺗﺴﺘﺨﺪم اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ‪،‬‬
‫ﻳﺠﺪر ﺑﻚ اﻻن ان ﺗﺘﺰود ﺑﺎﳌﻌﺎرف واﳌﻌﻠﻮﻣﺎت اﳌﺘﺎﺣﺔ ﻋﻦ ﻟﻐﺔ‬
‫اﻟﺒﺮﻣﺠﺔ ‪ Objective-C‬ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﺗﻄﻮﻳﺮ اﻟﺒﺮاﻣﺞ اﳌﺘﺨﺼﺼﺔ‬
‫دون اﳊﺎﺟﺔ ﻻﺳﺘﺨﺪام اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﻟﻠﻨﻈﺎم‪ .‬وﻓﻲ اﻟﻔﺼﻮل‬
‫اﻟﺘﺎﻟﻴﺔ ﺳﻮف ﻧﻘﻮم ﺑﺬﻟﻚ اﻟﺘﺰود اﳌﻌﺮﻓﻲ ﺣﺮﻓﻴ َﺎ‪ .‬ﺛﻢ ﺳﻨﺴﺒﺮ إﻧﺸﺎء‬
‫اﻟﺘﻄﺒﻴﻘﺎت اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﻟﻠﻨﻈﺎم‪ .‬ﻓﺎﻛﻤﻞ‬
‫اﻟﻘﺮاءة!!‬
‫‪٤٠‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬
‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻗﺪ ﺗﺮﻏﺐ ﺑﺠﻌﻞ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ ﻗﺎدرة ﻋﻠﻰ‬
‫ﺗﻮﺟﻴﺔ ﻋﻤﻠﻴﺔ ﺳﻴﺮ اواﻣﺮ اﻟﺒﺮﻧﺎﻣﺞ ﺑﻨﺎء ﻋﻠﻰ اﺳﺘﻴﻔﺎء ﺷﺮوط ﻣﻌﻴﻨﺔ‪.‬‬
‫ﻟﺬا ﺗﻮﺟﺪ ﻣﻔﺮدات ﻣﺤﺠﻮزة ﻟﺘﺤﻘﻴﻖ ﻫﺬا اﻻﻣﺮ‪.‬‬
‫]‪[1‬‬
‫;‪int age = 42‬‬
‫)‪if (age > 30‬‬ ‫‪// The > symbol means‬‬
‫”‪“greater than‬‬
‫{‬
‫;)”‪NSLog(@”age is older than thirty.‬‬
‫]‪//[1.4‬‬
‫}‬
‫]‪NSLog(@”Finished.”); //[1.6‬‬
‫اﻟﺴﻄﺮ ]‪ [1.2‬ﻳﻈﻬﺮ اﻳﻌﺎز اﺳﺘﻔﺴﺎر اﻟﺸﺮط ‪ if...‬واﻟﺬي ﺗﻨﺤﺼﺮ ﻣﻬﻤﺘﺔ‬

‫ﺑﺘ ّﻘﻴﻴﻢ ﲢﻘﻴﻖ ﺷﺮط ﻣﻌﲔ‪ .‬ﺳﻮف ﺗﺘﻌﺮف ﻋﻠﻰ دور اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ‬
‫واﻟﺘﻲ ﺑﺪورﻫﺎ ﲢﺘﻮي اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﻳﺠﺐ ﺗﻨﻔﻴﺬﻫﺎ ﻣﺘﻰ‬
‫ﻣﺎ اﺳﺘﻮﻓﻴﺖ ﺻﺤﺔ ﺣﻘﻴﻘﺔ اﻟﺸﺮط اﳌﻨﻄﻘﻲ اﻟﺼﻴﺎﻏﺔ و اﶈﺼﻮر ﺑﲔ‬
‫اﻻﻗﻮاس‪.‬‬
‫ﻫﻨﺎ اذا اﺳﺘﻮﻓﻰ اﻟﺸﺮط اﳊﻘﻴﻘﺔ ‪ if the condition age > 30‬ﻋﻨﺪ‬
‫ذﻟﻚ ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ اﳊﺮوف اﳌﻌﻴﻨﺔ ]‪ .[1.4‬ﺛﻢ ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ‬
‫‪٤١‬‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻳﺴﺎوي ==‬ ‫ﻧﺺ ﺳﻠﺴﻠﺔ اﳊﺮوف اﳌﻌﻴﻨﺔ ﺑـ ]‪ ،[1.6‬ﺳﻮاء ﰎ اﺳﺘﻴﻔﺎء اﻟﺸﺮط ﻣﻦ‬
‫اﻛﺒﺮ ﻣﻦ >‬ ‫ﻋﺪﻣﺔ ذﻟﻚ ﻳﻌﻮد ﻻن ﻣﻮﻗﻌﻬﺎ ﺧﺎرج ﻧﻄﺎق اﻟﺸﺮط‪ ،‬اي ﺧﺎرج‬
‫اﺻﻐﺮ ﻣﻦ <‬
‫اﻛﺒﺮ ﻣﻦ أو ﻳﺴﺎوي =>‬
‫اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ‪.‬‬
‫اﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي =<‬ ‫ﳝﻜﻨﻨﺎ اﻳﻀ َﺎ ﺗﺰوﻳﺪ اﺳﺘﻌﻼم اﻟﺸﺮط ﺑﺘﻌﻠﻴﻤﺎت اﺧﺮى ﻓﻲ ﺣﺎل ﻟﻢ‬
‫ﻻﻳﺴﺎوي =!‬
‫ﻳﺘﻢ اﻻﺳﺘﻴﻔﺎء‪ .‬ﺑﺎﺳﺘﺨﺪام ﻣﻔﺮدة ‪ if...else statement‬ﺑﺎﳌﺜﺎل ]‪.[2‬‬
‫]‪[2‬‬
‫ﲤﻌﻦ ﲟﻌﺎﻣﻞ رﻣﺰ ﻣﻔﺎﺿﻠﺔ اﳌﺴﺎواة ﻫﻨﺎ ﺣﻴﺚ ﻟﺪﻳﻨﺎ ﻋﻼﻣﺘﻲ ﻳﺴﺎوي‬ ‫;‪int age = 42‬‬
‫ﻣﺘﻜﺮرة "==" وﻫﻲ ﻣﻦ اﻟﺴﻬﻮﻟﺔ ﺑﺤﻴﺚ ان ﻳﺘﻢ ادراج واﺣﺪة ﻓﻘﻂ‬ ‫)‪if (age > 30‬‬
‫{‬
‫ﻣﻊ ﻧﺴﻴﺎن اﻻﺧﺮى ﻋﻨﺪﻫﺎ ﺳﻴﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ذﻟﻚ اﻻﻳﻌﺎز ﻛﺎﺳﻨﺎد‬ ‫;)”‪NSLog(@”age is older than thirty.‬‬
‫ﻟﻠﻘﻴﻤﺔ ﺑﺎﻟﺮﻏﻢ ﻣﻦ اﻧﻨﺎ ﻗﺪ ﻧﺮﻏﺐ ﺑﺎﺟﺮاء اﺧﺘﺒﺎر ﻣﻔﺎﺿﻠﺔ ﺗﺴﺎوي ﺑﲔ‬ ‫]‪//[2.4‬‬
‫}‬
‫اﻟﻘﻴﻢ‪ .‬وذﻟﻚ ﺧﻄﺎء ﺷﺒﻪ ﺷﺎﺋﻊ وﻣﺪﻋﺎة ﻟﻼرﺗﺒﺎك وأﺣﺪ اﻫﻢ اﺳﺒﺎب‬ ‫‪else‬‬
‫وﺟﻮد اﺧﻄﺎء ﺑﺮﻣﺠﻴﺔ ﺑﺎﻟﺸﻔﺮات اﳌﺼﺪرﻳﺔ ﻟﻠﻤﺒﺘﺪﺋﲔ‪.‬‬ ‫{‬
‫;)”‪NSLog(@”age is not older thirty.‬‬
‫ردد ﻣﻌﻲ ﺑﺼﻮت ﻋﺎﻟﻲ و ﻣﺴﻤﻮع‪:‬‬ ‫]‪//[2.7‬‬
‫}‬
‫ﻟﻦ اﻧﺴﻰ اﺳﺘﺨﺪام ﻋﻼﻣﺘﻲ ﻳﺴﺎوي ﻣﺜﻞ ﻫﺬﻩ == ﻣﺘﻰ رﻏﺒﺖ‬ ‫]‪NSLog(@”Finished.”); //[1.6‬‬
‫ﺑﺎﺟﺮاء ﻣﻔﺎﺿﻠﺔ ﺗﺴﺎوي ﺑﲔ اﻟﻘﻴﻢ!‬

‫إن ﻣﻌﺎﻣﻼت اﳌﻔﺎﺿﻠﺔ ﻣﻔﻴﺪة ﺟﺪاَ ﻣﺘﻰ رﻏﺒﺖ ﺑﺎﺟﺮاء ﺳﻠﺴﻠﺔ‬ ‫ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ اﻟﻨﺺ ]‪ [2.7‬ﻓﻘﻂ ﻓﻲ ﺣﺎل ﻋﺪم ﲢﻘﻖ اﻟﺸﺮط‪ ،‬وذﻟﻚ‬
‫ﻣﻦ اﻻﻳﻌﺎزات ﻟﻌﺪد ﻣﻦ اﳌﺮات‪ .‬وذﻟﻚ ﺳﻴﻜﻮن ﻣﻮﺿﻮع ﺣﺪﻳﺜﻨﺎ‬ ‫ﻟﻦ ﻳﺘﺤﻘﻖ ﻫﻨﺎ ﺑﺎﳌﺜﺎل ]‪ .[2‬وﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ اﻗﻮاس اﳌﻔﺎﺿﻠﺔ ﻣﺎ ﺑﲔ‬
‫ﺑﺎﻟﻔﺼﻞ اﻟﺘﺎﻟﻲ‪.‬‬ ‫اﻟﻘﻴﻢ اﻻﻛﺒﺮ ">“ أو اﻻﺻﻐﺮ “ <" اﳋﺎﺻﺔ ﺑﺎﻻﻋﺪاد ﻳﻮﺟﺪ ﻟﺪﻳﻚ‬
‫ﻣﻌﺎﻣﻼت اﺧﺮى ﻣﺘﻨﻮﻋﺔ‪:‬‬
‫‪٤٢‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬
‫]‪[4‬‬
‫) )‪if ( (age >= 18) && (age < 65‬‬
‫دﻋﻨﺎ اﻻن ﻧﻨﺎﻗﺶ ﺑﻌﺾ اﳌﻔﺎﻫﻴﻢ اﻟﺘﻲ ﻗﺪ ﻳﻜﻮن ﻟﻬﺎ اﺳﺘﺨﺪام ﻣﺜﻴﺮ‪.‬‬
‫{‬ ‫و ﻟﻨﺘﻔﺤﺺ ﺑﺸﻜﻞ اﻋﻤﻖ ﻋﻤﻠﻴﺔ اﳌﻔﺎﺿﻠﺔ ﻫﺬﻩ‪ .‬ان ﻧﺘﻴﺠﺔ اﳌﻔﺎﺿﻠﺔ‬
‫‪NSLog(@”Probably has to work for a‬‬
‫;)”‪living.‬‬
‫ﺗﻨﺤﺼﺮ ﺑﲔ ﻧﺘﻴﺠﺘﲔ ﻻ ﺛﺎﻟﺚ ﻟﻬﻤﺎ‪ :‬اﻟﻨﺘﻴﺠﺔ إﻣﺎ ﺗﻜﻮن ﺻﺤﻴﺤﺔ أو‬
‫}‬ ‫ﻏﻴﺮ‪-‬ﺻﺤﻴﺤﺔ‪/‬ﺧﺎﻃﺌﺔ ‪.true or false‬‬
‫ﻣﻦ اﳌﻤﻜﻦ ﺗﻌﺸﻴﺶ ﻋﺪة اﻳﻌﺎزات اﺷﺘﺮاﻃﻴﺔ ‪.-nested condition-‬‬ ‫ﻓﻲ ‪ ، Objective-C‬ﻳﺘﻢ ﲤﺜﻴﻞ اﻟﻨﺘﻴﺠﺔ اﻟﺼﺤﻴﺤﺔ أو ﻏﻴﺮ‪-‬اﻟﺼﺤﻴﺤﺔ‬
‫ﻓﻬﻲ ﺑﺒﺴﺎﻃﺔ ﺗﺘﻤﺜﻞ ﺑﺎدراج ﺷﺮط داﺧﻞ اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ ﻟﻼﺷﺘﺮاط‬ ‫ﺑﺈﻣﺎ ‪ 1‬أو ‪ 0‬ﻋﻠﻰ اﻟﺘﻮاﻟﻲ‪ .‬ﺣﺘﻰ اﻧﻪ ﻳﻮﺟﺪ ﻧﻮع ﺧﺎص ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت‬
‫اﻻول‪ .‬ﻋﻨﺪﻫﺎ ﺳﻴﺘﻢ ﺗﻘﻴﻴﻢ اﻻﺷﺘﺮاط اﻻول‪ ،‬ﺛﻢ ﺑﻌﺪ اﺳﺘﻴﻔﺎء ﲢﻘﻴﻖ‬ ‫اﺳﻤﺔ ‪ BOOL‬ﺗﻨﺤﺼﺮ ﻣﻬﻤﺘﺔ ﺑﺎﻇﻬﺎر ﻫﺬﻩ اﻟﻨﺘﻴﺠﺔ‪ .‬وﺣﺘﻰ ﻧﻘﻮل‬
‫ﺣﻘﻴﻘﺔ ﺷﺮوﻃﺔ ﺳﻴﺘﻢ ﺗﻘﻴﻴﻢ اﻻﻳﻌﺎز اﻟﺸﺮﻃﻲ اﳌﻌﺸﺶ داﺧﻠﻪ وﻫﻜﺬا‬ ‫ان ﻗﻴﻤﺔ اﻟﻨﺘﻴﺠﺔ ”ﺻﺤﻴﺤﺔ ‪ “true‬ﳝﻜﻨﻚ اﻣﺎ ﻛﺘﺎﺑﺔ ‪ 1‬أو ‪.YES‬‬
‫ﺗﺒﺎﻋ َﺎ‪.‬‬ ‫وﻻﺳﻨﺎد ﻗﻴﻤﺔ ﻏﻴﺮ‪-‬ﺻﺤﻴﺤﺔ‪/‬ﺧﺎﻃﺌﺔ ﳝﻜﻨﻚ اﻣﺎ ﻛﺘﺎﺑﺔ ‪ 0‬أو ‪NO‬‬
‫]‪[5‬‬ ‫]‪[3‬‬
‫)‪if (age >= 18‬‬ ‫;‪int x = 3‬‬
‫{‬ ‫;‪BOOL y‬‬
‫)‪if (age < 65‬‬ ‫;)‪y = (x == 4‬‬ ‫‪// y will be 0.‬‬
‫{‬
‫‪NSLog(@”Probably has to work for a‬‬
‫;)”‪living.‬‬ ‫ﻣﻦ اﳌﻤﻜﻦ ﻋﻤﻞ اﺧﺘﺒﺎر ﺣﻘﻴﻘﺔ ﻷﻛﺜﺮ ﻣﻦ ﺷﺮط‪ .‬وﻳﺘﻢ ذﻟﻚ ﻋﻨﺪﻣﺎ‬
‫}‬
‫}‬
‫ﻳﺘﻄﻠﺐ اﻻﻣﺮ اﺳﺘﻴﻔﺎء ﻛﺎﻓﺔ اﻟﺸﺮوط‪ ،‬ﻋﻨﺪﻫﺎ ﻧﺴﺘﺨﺪم اﳌﻌﺎﻣﻞ‬
‫اﳌﻨﻄﻘﻲ ‪ ، AND‬وﻫﻮ ﻳﺮد داﺋﻤﺎ ﺑﻌﻼﻣﺘﻲ ‪ampersands: &&.‬‬
‫ﺗﺘﻘﺪﻣﻪ‪ .‬اﻣﺎ ﻋﻨﺪ اﺷﺘﺮاط ﻗﻴﻤﺔ ﺻﺤﻴﺤﺔ ﻣﺘﺤﻘﻘﻪ ﻷﺣﺪ اﻟﺸﺮوط‪،‬‬
‫ﻋﻨﺪﻫﺎ ﻧﺴﺘﺨﺪم اﳌﻌﺎﻣﻞ اﳌﻨﻄﻘﻲ ‪ ، OR‬وﻫﻮ ﻳﺮد داﺋﻤﺎ ﺑﻌﻼﻣﺘﻲ|| ‪.‬‬
‫‪٤٣‬‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﻟﺸﺮﻃﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪٤٤‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬
‫ﻛﺎﻓﺔ اﻻﻳﻌﺎزات واﻻواﻣﺮ اﻟﺘﻲ ﻣﺮرﻧﺎ ﺑﻬﺎ ﻓﻲ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ ﺳﺎﺑﻘ َﺎ‬
‫ﺗﻨﻔﺬ ﻣﺮة واﺣﺪة ﻓﻘﻂ‪ .‬ﳝﻜﻨﻨﺎ دوﻣ َﺎ ﺗﻜﺮار ﺗﻨﻔﻴﺬ اواﻣﺮ اﻟﺪاﻻت‬
‫ﺑﺎﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﺮاراَ وﺗﻜﺮارا َ]‪.[1‬‬
‫]‪[1‬‬
‫ﺑﻨﺎء ﻋﻠﻰ ذﻟﻚ ﺳﻴﺘﻢ اﺳﺘﺪﻋﺎء وﺗﻨﻔﻴﺬ اﻟﺪاﻟﺔ ﺣﺴﺐ ﻋﺪد اﳌﺮات اﻟﺘﻲ‬
‫وردت وﻟﻜﻦ ﺗﻜﺮار ﻛﺘﺎﺑﺔ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ داﺧﻞ اﻟﺸﻔﺮة ﻳﻌﺪ اﻣﺮاَ‬
‫ﻏﻴﺮ ﻋﻤﻠﻲ‪ .‬ﻗﻔﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻳﺘﻄﻠﺐ ان ﻳﺘﻢ ﺗﻜﺮار ﺗﻨﻔﻴﺬ اﻻﻳﻌﺎز‬
‫أو اﻟﺪاﻟﺔ ﻋﺪد ﻣﻌﲔ ﻣﻦ اﳌﺮات ﻳﺤﺪد وﻗﺖ ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﻣﺜﻠﻬﺎ ﻣﺜﻞ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻻﺧﺮى‪ ،‬ﺗﻘﺪم ﻟﻚ ﻟﻐﺔ ‪ Objective-C‬ﻋﺪة‬
‫ﻃﺮق ﻟﺘﺤﻘﻴﻖ ذﻟﻚ ﻓﺎذا ﺣﺪدت اﻟﻌﺪد اﳌﻄﻠﻮب ﻣﻦ اﳌﺮات اﻟﻼزﻣﺔ‬
‫ﻻﺟﺮاء اﻟﺘﻜﺮار ﻋﻠﻰ اﻻﻳﻌﺎز أو ﻣﺠﻤﻮﻋﺔ اﻻﻳﻌﺎزات أو اﻟﺪاﻻت‪،‬‬
‫ﻋﻨﺪﻫﺎ ﳝﻜﻨﻚ ﲢﺪﻳﺪ ذﻟﻚ اﻟﺮﻗﻢ ﻣﺴﺘﺨﺪﻣ َﺎ ﻣﻔﺮدة ‪ for‬اﳋﺎﺻﺔ‬
‫ﺑﺈﺟﺮاء ﺣﻠﻘﺔ ﺗﻜﺮارﻳﺔ‪ ،‬وﻟﻠﻌﻠﻢ ﻳﺠﺐ ان ﻳﻜﻮن اﻟﻌﺪد ﺻﺤﻴﺢ‬
‫‪ integer،‬ﺣﻴﺚ ﻟﻦ ﺗﺴﺘﻄﻴﻊ ﻋﻤﻞ ﺧﻤﺲ دورات وﻧﺺ!‬
‫‪٤٥‬‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻟﻠﻤﻔﺎﺿﻠﺔ ﺑﲔ اﻟﻘﻴﻤﺔ واﳌﻌﺎدﻟﺔ اﶈﺪدة ﻟﺸﺮط ﺗﻜﺮارﻳﺔ اﳊﻠﻘﺔ واﻟﺘﻲ‬ ‫]‪[2‬‬

‫;‪int x‬‬
‫ﺳﺘﻈﻞ ﺗﻌﻤﻞ ﺣﺘﻰ ﻳﺘﺤﻘﻖ اﻟﺸﺮط وﻫﻮ ان ﺗﻜﻮن ﻗﻴﻤﺔ ‪ x‬اﻗﻞ أو‬ ‫)‪for (x = 1; x <= 10; x++‬‬
‫ﺗﺴﺎوي ‪ .١٠‬ﻓﻤﺎ ان ﺗﺼﻞ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ x‬اﻟﻰ ‪ ١١‬ﻋﻨﺪﻫﺎ ﻳﻜﻮن‬ ‫{‬
‫اﻟﺸﺮط ﺑﺎﳌﻌﺎدﻟﺔ ﻗﺪ ﲢﻘﻖ‪ ،‬وﺑﺬﻟﻚ ﻳﺘﻢ اﳋﺮوج ﻣﻦ ﺣﻠﻘﺔ اﻟﺘﻜﺮار‪.‬‬ ‫}‬
‫;)‪NSLog(@”The value of x is %d”, x‬‬
‫اﺧﺮ اﻳﻌﺎز ﻳﻀﻤﻦ ﻟﻚ ان ﺗﻜﻮن ﻗﻴﻤﺔ ‪ x‬ﻣﺴﺎوﻳﺔ ﻟـ ‪ ١١‬وﻟﻴﺲ ‪١٠‬‬
‫وﻫﻨﺎ ﺗﻨﺘﻬﻲ اﳊﻠﻘﺔ اﻟﺘﻜﺮارﻳﺔ‪.‬‬
‫ﻓﻲ اﳌﺜﺎل ]‪، [2‬ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ ﺣﺮوف ﻣﺤﺪدة ﻓﻲ ]‪ [1.4‬ﻋﺪد‬
‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻗﺪ ﺗﺮﻏﺐ ﲟﻌﺪل زﻳﺎدة اﻛﺒﺮ ﻓﻲ اﳋﻄﻮات ﻣﻦ‬ ‫‪ ١٠‬ﻣﺮات‪ .‬ﰎ اوﻻ اﻧﺸﺎء ﻣﺘﻐﻴﺮ ﺑﺎﺳﻢ ‪ x‬واﺳﻨﺪت ﻟﻪ ﻗﻴﻤﺔ ﻣﻘﺪارﻫﺎ‬
‫ﻗﻴﻤﺔ ‪ ١‬ﺣﻴﺚ اﺳﺘﺨﺪﻣﻨﺎ ‪ x++‬ﻟﺰﻳﺎدﺗﻬﺎ‪ .‬ﻛﻞ ﻣﺎ ﻋﻠﻴﻚ ﻋﻤﻠﻪ ﻫﻮ‬ ‫واﺣﺪ‪ .‬ﺳﻴﻘﻮم اﳊﺎﺳﺐ ﺑﺘﻘﻴﻴﻢ اﻟﻘﻴﻤﺔ وﻳﻔﺎﺿﻠﻬﺎ ﻣﻊ اﳌﻌﺎدﻟﺔ =< ‪x‬‬
‫ﺗﻐﻴﻴﺮ ﺧﻄﻮات اﻟﺰﻳﺎدة ”‪ “steps‬ﺑﺼﻴﻐﺔ اﳌﻌﺎدﻟﺔ ﻓﻲ ﺧﺎﻧﺔ اﳋﻄﻮات‪.‬‬ ‫‪ 10‬اﻟﺘﻲ ﺗﺸﺘﺮط ان ﺗﻜﻮن ﻗﻴﻤﺔ ‪ x‬اﻗﻞ أو ﺗﺴﺎوي ‪.١٠‬‬
‫اﳌﺜﺎل اﻟﺘﺎﻟﻲ]‪ [2‬ﻳﻘﻮم ﺑﺘﻐﻴﻴﺮ اﻟﻘﻴﻢ ﻣﻦ درﺟﺎت ﻣﺌﻮﻳﺔ اﻟﻰ درﺟﺎت‬
‫ﻳﺴﺘﻮﻓﻲ ﻫﺬا اﻻﺷﺘﺮاط ﲢﻘﻴﻘﺔ وﺗﻈﻞ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ﲢﺪث ﻣﺘﻰ ﻣﺎ‬
‫ﻓﻬﺮﻧﻬﺎﻳﺖ‪.‬‬
‫ﻛﺎﻧﺖ ﻗﻴﻤﺔ اﻗﻞ او ﺗﺴﺎوي ‪ ،(x <= 10) ١٠‬ﻫﺬا اﻟﺸﺮط ﻣﺘﺤﻘﻖ‬
‫]‪[3‬‬
‫;‪float celsius, tempInFahrenheit‬‬ ‫ﺣﻴﺚ ان ﻗﻴﻤﺔ ‪ x‬ﺗﺴﺎوي ‪ ١‬وﻫﻲ اﻗﻞ ﻣﻦ ‪ ١٠‬وﺳﻴﻈﻞ اﻣﺮ اﻟﺘﻜﺮار‬
‫‪for (tempInFahrenheit = 0; tempInFahrenheit‬‬ ‫ﻗﻴﺪ اﻟﻌﻤﻞ‪.‬‬
‫= ‪<= 200; tempInFahrenheit‬‬
‫)‪tempInFahrenheit + 20‬‬ ‫اﺛﻨﺎء اﲤﺎم ﻛﻞ دورة ﻟﻠﺤﻠﻘﺔ ﺳﻴﺘﻢ زﻳﺎدة ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ‪ x‬ﺑﻨﺴﺒﺔ ﻋﺪدﻳﺔ‬
‫{‬
‫‪celsius = (tempInFahrenheit - 32.0) * 5.0‬‬ ‫ﺗﺴﺎوي ‪ ١‬وذﻟﻚ ﻟﻮﺟﻮد اﻟﻌﺪاد ‪ x++‬اﻟﺬي ﻳﺆدي ﻟﺰﻳﺎدة ﻗﻴﻤﺔ ‪x‬‬
‫;‪/ 9.0‬‬ ‫ﺑﻜﻞ دورة‪.‬‬
‫‪NSLog(@”%10.2f -> %10.2f”,‬‬
‫;)‪tempInFahrenheit, celsius‬‬ ‫ﻻﺣﻘ َﺎ ﺳﺘﺼﺒﺢ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ‪ x‬ﻣﺴﺎوﻳﺔ ﻟﻠﻌﺪد‪ ٢‬وﺳﻴﺘﻢ ﻋﻤﻞ ﺗﻘﻴﻴﻢ‬
‫}‬
‫‪٤٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬
‫]‪[4‬‬
‫;‪int counter = 1‬‬
‫وﺧﺮج اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻜﻮن‪:‬‬
‫)‪while (counter <= 10‬‬ ‫‪0.00‬‬ ‫>‪-‬‬ ‫‪-17.78‬‬
‫{‬ ‫‪20.00‬‬ ‫>‪-‬‬ ‫‪-6.67‬‬
‫;)”‪NSLog(@”Julia is a pretty actress.\n‬‬ ‫‪40.00‬‬ ‫>‪-‬‬ ‫‪4.44‬‬
‫;‪counter = counter + 1‬‬ ‫‪60.00‬‬ ‫>‪-‬‬ ‫‪15.56‬‬
‫}‬ ‫‪80.00‬‬ ‫>‪-‬‬ ‫‪26.67‬‬
‫‪NSLog(@”The value of counter is %d”,‬‬ ‫‪100.00‬‬ ‫>‪-‬‬ ‫‪37.78‬‬
‫;)‪counter‬‬ ‫‪120.00‬‬ ‫>‪-‬‬ ‫‪48.89‬‬
‫‪140.00‬‬ ‫>‪-‬‬ ‫‪60.00‬‬
‫ﻓﻲ ﻫﺬﻩ اﳊﺎﻟﺔ‪ ،‬ﺳﺘﻜﻮن ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ counter‬ﺗﺴﺎوي ‪ ،١١‬ﻓﻬﻞ‬ ‫‪160.00‬‬ ‫>‪-‬‬ ‫‪71.11‬‬
‫ﻣﻦ اﻫﻤﻴﺔ ﻟﻬﺎ ﺑﻌﺪ ذﻟﻚ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ؟ ‪-‬اﻻﻣﺮ ﻋﺎﺋﺪ اﻟﻴﻚ‪..‬‬ ‫‪180.00‬‬
‫‪200.00‬‬
‫>‪-‬‬
‫>‪-‬‬
‫‪82.22‬‬
‫‪93.33‬‬
‫ان اﺳﺘﺨﺪام اﻳﻌﺎز ﺣﻠﻘﺔ )( ‪ do {} while‬ﻳﻌﻄﻲ اﻟﻔﺮﺻﺔ ﻟﺘﻨﻔﻴﺬ‬ ‫ﻃﺮق اﺧﺮى ﻟﻌﻤﻞ‬ ‫‪Objective-C‬‬‫ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ‪ for..loop‬ﺗﻘﺪم ﻟﻚ‬
‫ﻟﻠﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻣﺎ ﺑﲔ اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ ﻣﺮة واﺣﺪة ﻋﻠﻰ اﻻﻗﻞ‪.‬‬ ‫ﺣﻠﻘﺎت اﻟﺘﻜﺮار ﻣﻦ ﺧﻼل اﳌﻔﺮدات‪:‬‬
‫]‪[5‬‬ ‫} { )( ‪while‬‬
‫;‪int counter = 1‬‬
‫‪do‬‬ ‫وأﻳﻀ َﺎ‬
‫{‬
‫;)”‪NSLog(@”Julia is a pretty actress.\n‬‬ ‫)( ‪do {} while‬‬
‫إن اﻻﻳﻌﺎز اﻻﺧﻴﺮ ﻣﺸﺎﺑﺔ ﺟﺪاَ ﳊﻠﻘﺔ ‪ .for-loop‬ﻓﻬﺬا اﻷﻳﻌﺎز‬

‫;‪counter = counter + 1‬‬
‫}‬ ‫‪do‬‬
‫;)‪while (counter <= 10‬‬ ‫)( ‪ {} while‬ﻳﺒﺪأ ﻋﻤﻠﻪ ﺑﺘﻘﻴﻴﻢ اﻟﻘﻴﻤﺔ ﻗﻴﺪ اﻟﻨﻈﺮ‪ .‬ﻃﺎﳌﺎ ﻛﺎﻧﺖ‬
‫;)‪NSLog(@”The value of counter is %d”, counter‬‬ ‫ﻧﺘﻴﺠﺔ اﻟﺘﻘﻴﻴﻢ ﻏﻴﺮ‪-‬ﺻﺤﻴﺤﺔ ﺗﻈﻞ اﳊﻠﻘﺔ ﺗﺪور ﺣﺘﻰ ﻳﺘﻢ اﺳﺘﻴﻔﺎء‬
‫اﻟﺸﺮط‪.‬‬
‫ﻓﻲ ﻧﻬﺎﻳﺔ ﻋﻤﻞ اﳊﻠﻘﺔ ﺳﺘﻜﻮن ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ﻣﺴﺎوﻳﺔ ﻟـ ‪.١١‬‬
‫‪٤٧‬‬
‫اﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻜﺮرة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻟﻘﺪ اﻛﺘﺴﺒﺖ ﻣﻬﺎرات ﺑﺮﻣﺠﻴﺔ ﻣﺘﻨﻮﻋﺔ ﻣﺆﺧﺮاَ‪ ،‬ﻟﺬا ﺳﻨﻘﻮم ﲟﻨﺎﻗﺸﺔ‬

‫ﻣﻮاﺿﻴﻊ اﻛﺜﺮ ﺻﻌﻮﺑﺔ‪ ،‬ﺳﺘﺘﻄﻠﺐ ﻗﺪراَ ﻣﻦ اﻟﺘﺮﻛﻴﺰ واﻟﺘﻄﺒﻴﻖ‪ .‬ﻓﻔﻲ‬
‫اﻟﻔﺼﻞ اﻟﻘﺎدم ﺳﻨﻘﻮم ﺑﺎﻧﺸﺎء اول ﺑﺮﻧﺎﻣﺞ ﻳﺴﺘﺨﺪم واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت‬
‫اﻟﺮﺳﻮﻣﻴﺔ أو )‪.(GUI‬‬
‫‪٤٨‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬
‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ‬

‫اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬
‫ﻣﻊ ازدﻳﺎد ﺧﺒﺮة اﻟﺘﻌﺎﻣﻞ ﺑـ ‪ Objective-C‬ﺳﻨﻜﻮن ﻣﻬﻴﺌﲔ ﳌﻨﺎﻗﺸﺔ‬
‫ﻛﻴﻔﻴﺔ إﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﻣﺴﺘﺨﺪﻣﲔ ﻓﻴﻪ ﻣﺎ ﺗﻘﺪﻣﺔ واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت‬
‫وﻋﻠﻲ اﻻﻋﺘﺮاف ﺑﺎﻣﺮ ﻣﻬﻢ ﻫﻨﺎ وﻫﻮ‬
‫ّ‬ ‫اﻟﺮﺳﻮﻣﻴﺔ )‪ (GUI‬ﻣﻦ ﺧﺪﻣﺎت‪.‬‬
‫ان ‪ Objective-C‬ﻟﻐﺔ ﺑﺮﻣﺠﻴﺔ ﻣﺴﺘﻘﺎة ﻣﻦ ﻟﻐﺔ ‪ .C‬ﻓﺄﻏﻠﺐ ﻣﺎ ﰎ‬
‫ﻋﺮﺿﻪ ﺣﺘﻰ اﻻن ﻳﻌﺪ ‪ C‬اﻟﺼﺮﻓﻪ ‪ .‬ﻟﺬا اﻟﺴﺆال اﻟﺬي ﻳﻄﺮح ﻧﻔﺴﻪ‬
‫ﻫﻮ ﻣﺎﻟﻔﺮق اﻟﺬي ﺗﺸﻜﻠﺔ ﻟﻐﺔ ‪ Objective-C‬ﻋﻦ ﻟﻐﺔ ‪C‬؟‬
‫ﻳﻜﻤﻦ اﻻﺧﺘﻼف ﻓﻲ ذﻟﻚ اﳉﺰء اﳌﺘﻌﻠﻖ ﺑـ ”‪ .“Objective‬ﻓـ‬
‫‪ Objective-C‬ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺳﻤﺎت وﻣﻔﺎﻫﻴﻢ ﻣﺠﺮدة ﺗﻌﺮف ﺑﺎﺳﻢ‬
‫اﻟﻜﺎﺋﻨﺎت ‪.objects‬ﻓﺤﺘﻰ ﻫﺬﻩ اﻟﻠﺤﻈﺔ ﻛﻨﺎ ﻗﺪ ﺗﻌﺎﻣﻠﻨﺎ ﻣﻊ اﻻﻋﺪاد‪.‬‬
‫وﻟﻜﻦ ﻛﻤﺎ ﺳﺘﺮى ﺗﺘﻌﺎﻣﻞ ‪ Objective-C‬ﻓﻲ اﻻﺻﻞ ﻣﻊ اﻻﻋﺪاد‬
‫ﻋﻠﻰ اﻧﻬﺎ ﻣﻔﺎﻫﻴﻢ ﻣﺠﺮدة‪.‬‬
‫ذﻟﻚ اﻧﻬﺎ ﲤﻜﻨﻚ ﻣﻦ اﻧﺸﺎء ﺗﻠﻚ اﻻﻋﺪاد ﺑﺎﻟﺬاﻛﺮة وﲤﻜﻨﻚ ﻣﻦ‬
‫ﺗﻄﺒﻴﻖ اﳌﻌﺎﻣﻼت اﳊﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ ﺑﺘﻄﺒﻴﻖ ﻣﺨﺘﻠﻒ اﻟﺪاﻻت اﳌﻨﺎﺳﺒﺔ‬
‫ﲟﻌﺎﻣﻼﺗﻬﺎ‪ .‬ذﻟﻚ اﻣﺮ راﺋﻊ ﻋﻨﺪﻣﺎ ﻳﺘﻌﺎﻣﻞ ﺑﺮﻧﺎﻣﺠﻚ ﺑﺎﻻرﻗﺎم )ﻣﺜﻞ‬
‫‪٤٩‬‬
‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻟﺘﻨﻔﻴﺬ ذﻟﻚ اﳉﺰء اﳌﺘﻌﻠﻖ ﺑﺈﻏﻼق اﻟﻨﺎﻓﺬة ﻟﺬاﺗﻬﺎ‪.‬ﺑﺈﺧﺘﺼﺎر ﻟﻘﺪ‬ ‫اﻻﻟﺔ اﳊﺎﺳﺒﺔ(‪ .‬ﻟﻜﻦ ﻣﺎﻟﻌﻤﻞ ﻋﻨﺪﻣﺎ ﻳﺘﻌﺎﻣﻞ ﺑﺮﻧﺎﻣﺠﻚ ﻋﻠﻰ ﺳﺒﻴﻞ‬
‫ﺗﻠﻘﺖ اﻟﻨﺎﻓﺬة رﺳﺎﻟﺔ ﺗﻔﻴﺪﻫﺎ ﺑﺎﻏﻼق ذاﺗﻬﺎ‪.‬‬ ‫اﳌﺜﺎل ﻣﻊ ﻣﻘﻄﻮﻋﺎت ﻣﻮﺳﻴﻘﻴﺔ و ﻣﻜﻮﻧﺎت أﺧﺮى ﻛﻼﺋﺤﺔ ﺑﺎﺳﻤﺎء‬
‫اﳌﻘﻄﻮﻋﺎت‪ ،‬وﻻﺋﺤﺔ ﺑﺎﺳﻤﺎء اﳌﻐﻨﲔ؟ أو ان ﻳﺪﻳﺮ ﺑﺮﻧﺎﻣﺠﻚ ﻋﻠﻰ‬
‫ﺳﺒﻴﻞ اﳌﺜﺎل اﳊﺮﻛﺔ اﳉﻮﻳﺔ ﻛﻨﻈﺎم ﻻدارة اﻟﻄﺎﺋﺮات واﻟﺮﺣﻼت‬
‫واﳌﻄﺎرات؟ اﻟﻦ ﻳﻜﻮن ﻣﻦ اﻟﺮاﺋﻊ ان ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺗﻠﻚ اﳌﻌﻄﻴﺎت ﻣﻦ‬
‫ﺧﻼل ‪ Objective-C‬ﻛﻤﺎ ﻟﻮ اﻧﻚ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻻﻋﺪاد؟‬
‫ﻫﻨﺎ ﻳﺄﺗﻲ دور اﻟﻜﺎﺋﻨﺎت‪ .‬ﻓﻤﻦ ﺧﻼل ‪ Objective-C‬ﳝﻜﻨﻚ وﺿﻊ‬
‫ﺗﻮﺻﻴﻒ ﻟﻨﻮع اﻟﻜﺎﺋﻦ اﻟﺒﺮﻣﺠﻲ اﻟﺬي ﺗﺮﻏﺐ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‪ ،‬وﻣﻦ ﺛﻢ‬
‫ﺗﻜﺘﺐ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﳌﻼﺋﻤﺔ ﻟﻠﺘﻌﺎﻣﻞ واﻟﺘﻌﺎﻃﻲ ﻣﻌﻪ‪.‬‬
‫ﻛﻤﺜﺎل ﻋﻠﻰ ذﻟﻚ دﻋﻨﺎ ﻧﻠﻘﻲ ﻧﻈﺮة ﻋﻠﻰ ﻧﺎﻓﺬة اي ﺑﺮﻧﺎﻣﺞ ﻣﻦ إﻧﺸﺎء‬
‫ﻼ‪ .‬ﺗﻔﺤﺺ ﻧﺎﻓﺬة اﻟﺒﺮﻧﺎﻣﺞ‬ ‫‪ ، Objective-C‬ﻛﺒﺮﻧﺎﻣﺞ ‪ Safari‬ﻣﺜ َ‬
‫واﻧﻈﺮ ﻟﺘﻠﻚ اﳌﺴﺎﺣﺔ اﻟﻌﻠﻮﻳﺔ ﻣﻦ اﻟﻨﺎﻓﺬة ﺣﻴﺚ ﲡﺪ ﺗﻠﻚ اﻻزرار‬
‫اﻟﺜﻼﺛﺔ‪ .‬ﺳﺘﺠﺪ ان اﻟﺰر اﻻﺣﻤﺮ ﻣﻨﻬﺎ ُﻳﻐﻠﻖ اﻟﻨﺎﻓﺬة ﲟﺠﺮد ﺿﻐﻄﻚ‬
‫ﻋﻠﻴﻪ ﺑﺎﻟﻔﺄرة‪ .‬ﺗﺮى ﻣﺎﻟﺬي ﻳﺤﺪث ﻋﻨﺪﻣﺎ ﺗﻐﻠﻖ اﻟﻨﺎﻓﺬة ﺟﺮاء ﺿﻐﻄﻚ‬
‫اﻟﻨﺎﻓﺬة ﺗﺘﻠﻘﻰ رﺳﺎﻟﺔ إﻏﻼق‬ ‫ﻟﺬﻟﻚ اﻟﺰر اﻻﺣﻤﺮ؟‬
‫ﻓﺎﻟﻨﺎﻓﺬة ذاﺗﻬﺎ ﺗﻌﺪ ﻛﺎﺋﻦ ﺑﺮﻣﺠﻲ‪ .‬ﺣﻴﺚ ﳝﻜﻨﻚ ﺳﺤﺒﻬﺎ ﻫﻨﺎ‬ ‫ﻟﻘﺪ اﻏﻠﻘﺖ اﻟﻨﺎﻓﺬة ذاﺗﻬﺎ ﻻﻧﻬﺎ ﺗﻠﻘﺖ رﺳﺎﻟﺔ ‪ message‬ﻣﻦ ذﻟﻚ‬
‫وﻫﻨﺎك‪ .‬ان ﺗﻠﻚ اﻻزرار اﻟﺜﻼﺛﺔ ﻓﻲ اﻻﺻﻞ ﻫﻲ ﻛﺎﺋﻨﺎت ﺑﺮﻣﺠﻴﺔ‬ ‫اﻟﺰر اﻻﺣﻤﺮ ﺗﻔﻴﺪﻫﺎ ﺑﻮﺟﻮب اﻏﻼق ذاﺗﻬﺎ‪ .‬اﻧﻬﺎ ﻋﻤﻠﻴﺔ رد ﻓﻌﻞ‬
‫ﳝﻜﻨﻚ اﻟﻀﻐﻂ ﻋﻠﻰ اي ﻣﻨﻬﺎ‪ .‬ﺗﻠﻚ اﻟﻜﺎﺋﻨﺎت اﻟﺒﺮﻣﺠﻴﺔ ﻣﺒﻨﻴﺔ‬ ‫وﺗﻨﻔﻴﺬ ﻟﺸﻔﺮة ﺑﺮﻣﺠﻴﺔ داﺧﻞ اﻟﻨﺎﻓﺬة ﻛﺎﻧﺖ اﻟﺮﺳﺎﻟﺔ ﻫﻲ اﳌﺴﺒﺐ‬
‫‪٥٠‬‬
‫ﻟﻘﺪ وﺿﻌﻮا ﺑﻌﺾ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ ﻟﺘﻤﺜﻞ ﳕﻮذج ﻟﻠﻨﺎﻓﺬة ﺣﻴﺚ‬ ‫ﻣﻊ ﺧﺎﺻﻴﺔ ﲤﻜﻨﻬﺎ ﻣﻦ ﻣﻌﺮﻓﺘﻬﺎ ﻟﻜﻴﻔﻴﺔ اﻇﻬﺎر )رﺳﻢ( ذاﺗﻬﺎ ﻋﻠﻰ‬
‫ﺣﺪدوا اﻟﺘﺼﺮﻓﺎت واﻟﺴﻮﻟﻜﻴﺎت اﻟﻌﺎﻣﺔ اﻟﻮاﺟﺐ اﺗﺒﺎﻋﻬﺎ ﻟﺘﻠﻚ‬ ‫ﺷﺎﺷﺔ اﳌﺴﺘﺨﺪم‪.‬‬
‫اﻟﻨﺎﻓﺬة واﻃﻠﻘﻮا ﻋﻠﻴﻬﺎ ﺗﺼﻨﻴﻒ أو ‪.Class‬‬ ‫ﻋﻠﻰ ﻛﻞ ﺟﺰء اﻹﻇﻬﺎر ﻫﺬا ﻟﻴﺲ ﺳﻤﺔ ﻏﺎﻟﺒﺔ ﻟﻜﻞ اﻟﻜﺎﺋﻨﺎت‪ .‬ﻓﻌﻠﻰ‬
‫ﻓﻌﻨﺪﻣﺎﺗﻨﺸﻲءﻧﺎﻓﺬةﺟﺪﻳﺪةﻓﺎﻧﻚ ﺗﻌﺘﻤﺪﻓﻲإﻧﺸﺎﺋﻚﻟﻬﺎﻋﻠﻰﻧﺴﺨﺔ‬ ‫ﺳﺒﻴﻞ اﳌﺜﺎل ﻫﻨﺎك ﻛﺎﺋﻨﺎت ﲤﺜﻞ ﻋﻤﻠﻴﺔ اﻻﺗﺼﺎﻻت ﻣﺎﺑﲔ ﺑﺮﻧﺎﻣﺞ‬
‫ﻣﻦ ذﻟﻚ اﻟﺘﺼﻨﻴﻒ ‪ Class‬اﻟﺬي ﻳﺤﺘﻮي ﺗﻮﺻﻴﻒ ﻟﻠﻨﻤﻮذج اﻻﺻﻞ‬ ‫ﺳﻔﺎري وذﻟﻚ اﳌﻮﻗﻊ اﻻﻟﻜﺘﺮوﻧﻲ وﻟﻜﻨﻬﺎ ﻻﲤﺜﻞ ذاﺗﻬﺎ ﺑﺼﺮﻳ َﺎ ﻋﻠﻰ‬
‫ﻟﻠﻨﺎﻓﺬة‪ .‬ﻓﺎﻟﺘﺼﻨﻴﻒ ‪ Class‬ﻫﻨﺎ ﳝﺜﻞ ﻣﻔﻬﻮم ﻋﻦ اﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج‪ .‬ﳑﺎ‬ ‫اﻟﺸﺎﺷﺔ‪.‬‬
‫ﻳﻌﻨﻲ ان اي ﻧﺎﻓﺬة ﺗﺮاﻫﺎ اﻣﺎﻣﻚ اﳕﺎ ﻫﻲ ﻓﻲ اﻟﻮاﻗﻊ ﻣﺴﺘﻨﺴﺦ ‪instance‬‬
‫ﻛﺎﺋﻦ ﻧﺎﻓﺬة ﻳﺤﺘﻮى ﻛﺎﺋﻨﺎت اﻻزرار‬
‫ﻣﻦ ﻣﻔﻬﻮم اﻟﻨﺎﻓﺬة اﻟﻨﻤﻮذج‪) .‬ﻓﻲ ذات اﻟﺴﻴﺎق ﻧﺴﺘﻮﻋﺐ ان اﻟﻌﺪد‬
‫‪ ٧٦‬اﳕﺎ ﻫﻮ ﻣﺴﺘﻨﺴﺦ ﻣﻦ ﻣﻔﻬﻮم ﺗﺼﻨﻴﻒ اﻻﻋﺪاد(‪.‬‬ ‫ﻼ( ﳝﻜﻨﻪ ان ﻳﺤﺘﻮي ﻋﻠﻰ اي ﻛﺎﺋﻨﺎت‬ ‫ان اي ﻛﺎﺋﻦ )اﻟﻨﺎﻓﺬة ﻣﺜ َ‬
‫ان اﻟﻨﺎﻓﺬة اﻟﺘﻲ ﻗﻤﺖ ﺑﺎﻧﺸﺎءﻫﺎ ﺗﺘﺨﺬ ﻣﻮﻗﻊ وﻣﺴﺎﺣﺔ ﻣﻌﻴﻨﺔ ﻣﻦ‬ ‫اﺧﺮى )اﻻزرار اﻟﺜﻼﺛﺔ(‪ .‬ﳝﻜﻦ ﻟﺒﺮﻧﺎﻣﺞ ﺳﻔﺎري ان ﻳﺰودك ﺑﺎي ﻋﺪد‬
‫ﺷﺎﺷﺔ اﳌﺎﻛﻨﺘﻮش‪ .‬ﻓﺈذا ﻗﻤﺖ ﺑﺘﺼﻐﻴﺮﻫﺎ إﻟﻰ اﳌﻨﺼﺔ ‪ ،Dock‬ﺛﻢ‬ ‫ﻣﻦ اﻟﻨﻮاﻓﺬ اﻟﺘﻲ ﺗﺮﻳﺪﻫﺎ‪.‬‬
‫ﻗﻤﺖ ﺑﺈﺳﺘﺪﻋﺎﺋﻬﺎ ﻣﺮة اﺧﺮى ﺳﺘﺮى اﻧﻬﺎ ﺗﻌﻮد اﻟﻰ ذات اﳌﻜﺎن اﻟﺬي‬ ‫ﺗﺮى ﻫﻞ ﻛﻨﺖ ﺗﺘﻮﻗﻊ ان‪:‬‬
‫ﻛﺎﻧﺖ ﻣﺘﻤﻮﺿﻌﺔ ﻓﻴﻪ‪ .‬ﻳﺎ ﺗﺮى ﻛﻴﻒ ﺗﻌﻤﻞ ﻫﺬﻩ اﻻﻣﻮر؟‬ ‫‪ .١‬ﻗﺒﺎم ﻣﺒﺮﻣﺠﻲ أﭘﻞ ﺑﺒﺮﻣﺠﺔ ﻛﻞ ﺗﻠﻚ اﻟﻨﻮاﻓﺬ ﻣﺴﺒﻘ َﺎ ﻣﺴﺘﻨﻔﺬﻳﻦ‬
‫ﺳﻨﺮى ان اﻟﺘﺼﻨﻴﻒ اﻻﺳﺎﺳﻲ ﻳ ّﻌﺮف ﻋﺪد ﻣﻦ اﳌﺘﻐﻴﺮات اﳌﻨﺎﺳﺒﺔ‬ ‫ﻛﺎﻓﺔ ﻣﻮاردﻫﻢ اﻟﻌﻘﻠﻴﺔ واﳊﺴﺎﺑﻴﺔ ﺣﺘﻰ ﻳﻠﺒﻮا ﻃﻠﺒﺎﺗﻚ ﻣﻦ اﻟﻨﻮاﻓﺬ‬
‫واﻟﺘﻲ ﺗ ّﺘﺤﺪّ د ﻣﻬﻤﺘﻬﺎ ﺑﺤﻔﻆ ﻣﻮﻗﻊ اﻟﻨﺎﻓﺬة ﻣﻦ اﻟﺸﺎﺷﺔ‪.‬‬ ‫اﻟﺘﻲ ﻗﺪ ﲢﺘﺎﺟﻬﺎ؟‬
‫ان ﻣﺴﺘﻨﺴﺦ اﻟﺘﺼﻨﻴﻒ ‪ ،class instance‬أو اﻟﻜﺎﺋﻦ اﳊﺎﻟﻲ ﻳﺤﺘﻔﻆ‬ ‫‪ .٢‬ﻗﺎﻣﻮا ﺑﻮﺿﻊ ﳕﻮذج ﻟﻠﻨﺎﻓﺬة وﻣﻜﻨﻮا ﺑﺮﻧﺎﻣﺞ ﺳﻔﺎري ﻣﻦ اﺳﺘﺨﺪام‬
‫ﺑﺘﻠﻚ اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺨﺼﻪ ﻓﻲ ﻣﺘﻐﻴﺮاﺗﻪ اﻟﺘﻲ ﺗﺨﻀﻊ ﲢﺖ ﺗﺼﺮﻓﻪ‪.‬‬ ‫ذﻟﻚ اﻟﻨﻤﻮذج ﻻﻧﺸﺎء ﻧﻮاﻓﺬ اﺧﺮى وﻗﺖ اﻟﻄﻠﺐ؟‬
‫ﻟﺬا ﻛﻞ ﻛﺎﺋﻦ ﻧﺎﻓﺬة ﻳﺤﺘﻮي ﻣﺘﻐﻴﺮات ﻣﺤﺪدة وﺑﻘﻴﻢ ﺧﺎﺻﺔ ﺑﺬﻟﻚ‬ ‫ﻗﻄﻌ َﺎ اﻻﺟﺎﺑﺔ اﻟﺜﺎﻧﻴﺔ ﻫﻲ اﻟﺼﺤﻴﺤﺔ ‪.‬‬
‫‪٥١‬‬
‫اﳊﻞ اﻻﻣﺜﻞ ﻫﻮ ان ﺗﻮﺟﺪ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﶈﺪدة ﻟﺴﻠﻮﻛﻴﺎت‬ ‫اﻟﻜﺎﺋﻦ‪ .‬ان ﻋﺪة ﻛﺎﺋﻨﺎت ﻣﻦ اﻟﻨﻮاﻓﺬ اﳌﺨﺘﻠﻔﺔ ﻳﺤﺘﻔﻆ ﻛﻞ ﻛﺎﺋﻦ‬
‫وﺗﺼﺮﻓﺎت اﻟﻨﺎﻓﺬة ﲟﻮﻗﻊ ﻣﺮﻛﺰي واﺣﺪ ﻓﻘﻂ‪ ،‬ﺣﻴﺚ ﻳﺘﻢ ﻣﺸﺎرﻛﺔ‬ ‫ﻣﻨﻬﺎ ﺑﻘﻴﻢ ﻣﺨﺘﻠﻔﺔ ﳌﺘﻐﻴﺮاﺗﻬﺎ اﳋﺎﺻﺔ ﺑﻬﺎ‪.‬‬
‫وﻣﺮاﺟﻌﺔ ﺗﻠﻚ اﻻواﻣﺮ واﻟﺴﻠﻮﻛﻴﺎت ﻣﻊ اي ﻛﺎﺋﻦ ﻧﺎﻓﺬة آﺧﺮ ﻳﻨﺘﻤﻲ‬ ‫ﻫﺬا اﻟﺘﺼﻨﻴﻒ ﻟﻢ ﻳﻘﻢ ﺑﺎﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻨﺎﻓﺬة ﻓﻘﻂ‪ ،‬ﻟﻜﻨﻪ ﻣﻜﻨﻬﺎ ﻣﻦ‬
‫ﻟﺬﻟﻚ اﻟﺘﺼﻨﻴﻒ‪.‬‬ ‫ﺳﻠﺴﻠﺔ ﻣﻦ اﻻﻧﺸﻄﺔ واﻟﺘﺼﺮﻓﺎت )إﺟﺮاءات ‪ (actions‬اﻟﺘﻲ ﳝﻜﻦ‬
‫ﻛﻤﺎ أوردﻧﺎ ﺳﺎﺑﻘ َﺎ ﻣﻦ اﻣﺜﻠﺔ‪ ،‬ﺳﺘﺤﺘﻮي اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﺳﺘﺮاﻫﺎ‬ ‫ﻟﻠﻨﺎﻓﺬة ان ﺗﺆدﻳﻬﺎ‪.‬‬
‫ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ ﺑﻌﺾ اﻟﺴﻄﻮر اﻟﺘﻲ ﺗﻬﺘﻢ ﺑﺤﺠﺰ ﻣﻮاﻗﻊ اﻟﺬاﻛﺮة‬ ‫اﺣﺪ ﺗﻠﻚ اﻹﺟﺮاءات‪ ،‬إﺟﺮاء اﻏﻼق اﻟﻨﺎﻓﺬة ﻟﺬاﺗﻬﺎ ‪ .close‬ﻓﻤﺘﻰ‬
‫وﺗﺴﺮﻳﺢ اﳊﺠﺰ ﺣﺘﻰ ﻳﺘﻤﻜﻦ اﻟﻨﻈﺎم ﻣﻦ اﺳﺘﻌﺎدﺗﻬﺎ وﺗﻮﻇﻴﻔﻬﺎ ﻣﺮة‬ ‫ﻣﺎ ﻗﻤﺖ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ازرار اﻻﻏﻼق اﻻﺣﻤﺮ ﺑﺎﺣﺪ اﻟﻨﻮاﻓﺬ‪،‬‬
‫اﺧﺮى‪ .‬وﻛﻤﺎ ﰎ اﻟﺘﻨﻮﻳﻪ ﺳﺎﺑﻘ َﺎ ﺳﻨﺘﻄﺮق ﻟﺸﺮح ﻫﺬﻩ اﻻﺳﻄﺮ ﻓﻲ‬ ‫ﺳﻴﻘﻮم اﻻزرار ﺑﺎرﺳﺎل رﺳﺎﻟﺔ اﻟﻰ اﻟﻨﺎﻓﺬة ﻣﻔﺎدﻫﺎ اﻏﻠﻘﻲ ذاﺗﻚ‪.‬‬
‫ﻣﻮاﺿﻴﻊ ﻣﺘﻘﺪﻣﺔ ﻻﺣﻘ َﺎ‪ .‬ﻟﺬا ﻧﺮﺟﻮ اﳌﻌﺬرة‪...‬‬ ‫ان اﻹﺟﺮاءات اﻟﺘﻲ ﻳﻘﻮم ﺑﻬﺎ اﻟﻜﺎﺋﻦ ﺗﺴﻤﻰ ‪ .methods‬ﻛﻤﺎ ﺗﺮى‬
‫ﻓﻲ ﻫﺬا ﺳﻨﻘﻮم ﺑﺈﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﻣﻜﻮن ﻣﻦ ازرارﻳﻦ اﺛﻨﲔ وﺣﻘﻞ ﻧﺺ‬ ‫اﻧﻬﺎ ﺷﺪﻳﺪة اﻟﺸﺒﺔ ﺑﺎﻟﺪاﻻت‪ ،‬وذﻟﻚ ﻟﻦ ﻳﺸﻜﻞ ﻣﺸﻜﻠﺔ ﻓﻲ اﻟﺘﻌﻠﻢ‬
‫‪ .text field‬ﺑﺤﻴﺚ اذا ﻗﻤﺖ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﺣﺪ اﻻزرار‪ ،‬ﺳﻴﺘﻢ‬ ‫واﻻﺳﺘﺨﺪام اذا ﻛﻨﺖ ﻣﺘﺎﺑﻊ ﻣﻌﻨﺎ ﺣﺘﻰ اﻟﻠﺤﻈﺔ‪.‬‬
‫ﻋﺮض ﻗﻴﻤﺔ ﻣﺎ ﺑـ ﺣﻘﻞ اﻟﻨﺺ‪ .‬وﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻰ اﻻزرار اﻻﺧﺮ ﺳﻴﺘﻢ‬ ‫ﻋﻨﺪﻣﺎ ﻳﻘﻮم اﻟﻨﻤﻮذج اﻟﺘﺼﻨﻴﻔﻲ ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻧﺎﻓﺬة ﻣﻦ اﺟﻠﻚ‪،‬‬
‫ﻋﺮض ﻗﻴﻤﺔ اﺧﺮى ﺑﺤﻘﻞ اﻟﻨﺺ‪ .‬ﻓﻜﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻛﺄﻧﻪ آﻟﻪ ﺣﺎﺳﺒﺔ‬ ‫ﻓﺈﻧﻪ ﻓﻲ اﻟﻮاﻗﻊ ﻳﺤﺠﺰ ﺟﺰء ﻣﻦ اﻟﺬاﻛﺮة )‪ (RAM‬ﻛﻲ ﻳﺘﻢ ﺣﻔﻆ ﻣﻮﻗﻊ‬
‫ﻣﻜﻮﻧﺔ ﻣﻦ ازرارﻳﻦ وﻻﳝﻜﻨﻬﺎ ﻋﻤﻞ اي ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ‪...‬‬ ‫اﻟﻨﺎﻓﺬة ﻣﻦ اﻟﺸﺎﺷﺔ‪ ،‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ﻋﺪد ﻣﻦ اﳌﻌﻠﻮﻣﺎت اﻻﺧﺮى‪.‬‬
‫ﻋﻠﻰ ﻛﻞ ﺣﺎل ﻋﻤﻠﻴﺔ اﻻﺳﺘﻨﺴﺎخ ﻫﺬﻩ ﻻ ﺗﻘﻮم ﺑﻨﺴﺦ ﻛﺎﻓﺔ اﻟﺸﻔﺮات‬
‫ﲟﺠﺮد ﺗﻌﻠﻢ اﳌﺰﻳﺪ ﳝﻜﻨﻚ ﺻﻨﻊ آﻟﺘﻚ اﳊﺎﺳﺒﺔ ﺑﺎﻟﺘﺄﻛﻴﺪ‪ ،‬وﻟﻜﻨﻨﺎ‬ ‫اﻟﺒﺮﻣﺠﻴﺔ اﳌﻜﻮﻧﺔ ﻟﻠﻨﺎﻓﺬة ﻛﺎﻣﺮ اﻻﻏﻼق ﻣﺜﻼ‪ .‬ﻫﺬا اﻟﻌﻤﻞ ﺳﻴﺒﺪد‬
‫ﻧﻔﻀﻞ اﻟﺘﻌﻠﻢ ﺧﻄﻮة ﺧﻄﻮة‪.‬‬ ‫ﺣﻴﺰ ﻛﺒﻴﺮ ﻣﻦ اﻟﺬاﻛﺮة اﳌﺘﺎﺣﺔ ﺣﻴﺚ ﺳﻴﺘﻢ ﻧﺴﺦ ﻛﺎﻓﺔ اﻟﺸﻔﺮات‬
‫اﻟﺒﺮﻣﺠﻴﺔ واﻹﺟﺮاءات اﳋﺎﺻﺔ ﺑﻜﻞ ﻧﺎﻓﺬة ﺗﻮﺟﺪ ﻫﻨﺎ أو ﻫﻨﺎك‪.‬‬
‫‪٥٢‬‬
‫ﻟﺬا ﻓﻲ اﻟﺒﺪء ﻋﻠﻴﻨﺎ ﺑﺈﻧﺸﺎء اﻟﺘﺼﻨﻴﻒ اﳋﺎص ﺑﻨﺎ ﻛﻨﻤﻮذج‪ ،‬ﺛﻢ ﻧﻘﻮم‬
‫ﺑﺈﺳﺘﻨﺴﺎﺧﻪ ﻛﻜﺎﺋﻦ‪ .‬ﻫﻨﺎ ﺳﻴﻜﻮن ﻫﺬا اﻟﻜﺎﺋﻦ ﻫﻮ اﳌﺴﺘﻘﺒﻞ ﻟﻠﺮﺳﺎﺋﻞ‬
‫اﻟﺘﻲ ﺳﺘﺮﺳﻠﻬﺎ اﻟﻴﻪ ﺗﻠﻚ اﻻزرار )اﻧﻈﺮ ﻟﻠﺮﺳﻢ اﻟﺘﻮﺿﻴﺤﻲ ادﻧﺎﻩ(‪.‬‬
‫ان ﻣﺴﺘﻨﺴﺨﻨﺎ ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻦ ﺑﺮﻣﺠﻲ‪ ،‬ﻣﺜﻠﻪ ﻣﺜﻞ ﻛﺎﺋﻦ اﻟﻨﺎﻓﺬة‪،‬‬
‫وﻟﻜﻨﻪ ﻋﻠﻰ اﻟﻨﻘﻴﺾ ﻣﻦ ﻛﺎﺋﻦ اﻟﻨﺎﻓﺬة ﻓﻬﺬ اﳌﺴﺘﻨﺴﺦ ﻏﻴﺮ ﻇﺎﻫﺮ‬
‫ﺑﺼﺮﻳ َﺎ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﻣﺘﻰ ﻗﻤﻨﺎ ﺑﺘﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬اﻧﻪ ﻣﺠﺮد ﻛﺎﺋﻦ‬
‫ﺑﺮﻣﺠﻲ ﻣﻮﺟﻮد ﻓﻲ ذاﻛﺮة اﳊﺎﺳﺐ ﻓﻘﻂ‪.‬‬
‫ﻣﺎ ان ﻳﺘﻠﻘﻰ ﻛﺎﺋﻨﻨﺎ اﳌﺴﺘﻨﺴﺦ ﺗﻠﻚ اﻟﺮﺳﺎﻟﺔ اﳌﺮﺳﻠﺔ اﻟﻴﻪ ﻣﻦ اﺣﺪ ﺗﻠﻚ‬
‫اﻻزرار‪ ،‬ﺳﻴﺘﻢ ﻋﻨﺪﻫﺎ ﺗﻨﻔﻴﺬ اﻻﺟﺮاء اﳌﻄﻠﻮب‪ .‬واﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬ ‫ﻫﻨﺎ ﺗﺼﻮر ﻋﻦ اﻟﺒﺮﻧﺎﻣﺞ اﳌﺰﻣﻊ اﻧﺸﺎءﻩ‪.‬‬
‫ﻟﺬﻟﻚ اﻻﺟﺮاء ﺳﺘﻮﺟﺪ ﺑﺎﻟﺘﺼﻨﻴﻒ اﻟﻨﻤﻮذﺟﻲ اﻻﺻﻠﻲ )اي اﻧﻬﺎ‬
‫ﻓﻲ ﺣﺎل اﻟﻀﻐﻂ ﻋﻠﻰ اﺣﺪ ﺗﻠﻚ اﻻزرار‪ ،‬ﺳﻮف ﻳﻘﻮم اﻻزرار‬
‫ﻟﻴﺴﺖ ﻣﻮﺟﻮدة ﺑﺎﳌﺴﺘﻨﺴﺦ(‪.‬‬
‫اﳌﻀﻐﻮط ﺑﺎرﺳﺎل رﺳﺎﻟﺔ‪ .‬ﻫﺬﻩ اﻟﺮﺳﺎﻟﺔ ﲢﺘﻮي اﺳﻢ اﻻﺟﺮاء ‪method‬‬
‫اﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ‪ ،‬ﺳﻴﻘﻮم ﻫﺬا اﻻﺟﺮاء ﺑﺎرﺳﺎل رﺳﺎﻟﺔ اﻟﻰ ﻛﺎﺋﻦ ﺣﻘﻞ‬ ‫اﳌﺰﻣﻊ ﺗﻨﻔﻴﺬﻩ‪ .‬ﺗﺮى ﻫﺬﻩ اﻟﺮﺳﺎﻟﺔ ﺗﻮﺟﻪ اﻟﻰ ﻣﻦ أو ﻣﺎذا؟‬
‫اﻟﻨﺺ‪.‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ اﺳﻢ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪ ،‬ﺗﻜﻮن ﺻﻴﻐﺔ اﻟﺮﺳﺎﻟﺔ‬
‫ﻓﻲ ﺣﺎﻟﺔ اﻟﻨﺎﻓﺬة‪ ،‬ﻛﺎﻧﺖ رﺳﺎﻟﺔ اﻻﻏﻼق ﻣﻮﺟﻬﺔ اﻟﻰ ﻛﺎﺋﻦ اﻟﻨﺎﻓﺬة‪،‬‬
‫اﳌﺮﺳﻠﺔ ﻣﺤﺘﻮﻳﺔ ﻋﻠﻰ ﻣﺎ ﻳﻠﻲ دوﻣ َﺎ‪ :‬اﺳﻢ اﻻﺟﺮاء )اﳋﺎص ﺑﺤﻘﻞ‬
‫واﻟﺬي ﺑﺪورﻩ ﻛﺎن ﻣﺴﺘﻨﺴﺦ ‪ instance‬ﻋﻦ ﺗﺼﻨﻴﻒ اﻟﻨﺎﻓﺬة اي‬
‫اﻟﻨﺺ(‪.‬‬
‫‪ .window class‬ﻣﺎ ﻧﺤﺘﺎﺟﺔ اﻻن ﻫﻮ ﻛﺎﺋﻦ ﻟﺪﻳﻪ اﻟﻘﺪرة ﻋﻠﻰ‬
‫ﻓﻮر ﺗﺴﻠﻢ ﺣﻘﻞ اﻟﻨﺺ ﻟﻠﺮﺳﺎﻟﺔ ﻳﺘﻢ اﻟﺘﻨﻔﻴﺬ ﻓﻮراَ‪ .‬ﻓﻨﺤﻦ ﻧﺮﻳﺪ‬ ‫اﺳﺘﻘﺒﺎل اﻟﺮﺳﺎﺋﻞ ﻣﻦ اي ﻣﻦ ﻫﺆﻻء اﻻزرارﻳﻦ‪ ،‬وﻛﺬﻟﻚ اﻟﻘﺪرة‬
‫ﻣﻦ ﺣﻘﻞ اﻟﻨﺺ ان ﻳﻌﺮض ﻗﻴﻤﺔ ﻧﺼﻴﺔ ﻣﻌﻴﻨﺔ‪ ،‬ﺑﻨﺎء ﻋﻠﻰ اﻻزرار‬ ‫ﻟﺘﻮﺟﻴﻪ ﺣﻘﻞ اﻟﻨﺺ ﻟﻌﺮض ﻗﻴﻤﺔ ﻣﺎ‪.‬‬
‫اﳌﻀﻐﻮط‪ .‬ﻟﺬا ﺳﺘﺤﺘﻮي اﻟﺮﺳﺎﻟﺔ ﻋﻠﻰ ُﻣﻌﺎﻣﻞ ‪) argument‬ﻗﻴﻤﺔ(‬
‫‪٥٣‬‬
‫ﻛﻤﺎ ﺗﺮى ﻣﻦ اﻻﻳﻌﺎزات‪ ،‬ﻳﻜﻮن اﻟﻘﻠﺐ اﻟﻨﺎﺑﺾ ﻟﻼﺟﺮاء ﻣﺤﺼﻮراَ ﺑﲔ‬ ‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ اﺳﻢ اﻟﻜﺎﺋﻦ اﻟﺬي ﺳﺘﺮﺳﻞ اﻟﻴﻪ اﻟﺮﺳﺎﻟﺔ‪ ،‬واﺳﻢ اﻻﺟﺮاء‬
‫ﺗﻠﻚ اﻻﻗﻮاس اﳌﺮﺑﻌﺔ ;]‪ [...‬ﻣﺘﺒﻮﻋﺔ ﺑﺘﻠﻚ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ اﻻﺑﺪﻳﺔ‪.‬‬ ‫اﳌﻄﻠﻮب ﺗﻨﻔﻴﺬﻩ ﺣﺘﻰ ﻳﺘﻤﻜﻦ ﺣﻘﻞ اﻟﻨﺺ ﻣﻦ اﻟﻘﻴﺎم ﺑﺪورﻩ‪.‬‬
‫داﺧﻞ ﺗﻠﻚ اﻻﻗﻮاس اﳌﺮﺑﻌﺔ‪ ،‬ﻳﺘﻢ ذﻛﺮ اﺳﻢ اﻟﻜﺎﺋﻦ اﳌﺴﺘﻘﺒﻞ ﻟﻠﺮﺳﺎﻟﺔ‬
‫َ‬
‫اوﻻ ﻳﺘﺒﻌﻪ اﺳﻢ اﺣﺪ اﻻﺟﺮاءات اﻟﺘﻲ ﳝﻜﻨﻪ ﺗﻨﻔﻴﺬﻫﺎ‪ .‬واذا ﻣﺎ ﺗﻄﻠﺐ‬
‫اﻻﺟﺮاء وﺟﻮد اﻛﺜﺮ ﻣﻦ ﻗﻴﻤﺔ او ﻣﻌﺎﻣﻞ‪ ،‬وﺟﺐ ﺗﺰوﻳﺪﻩ ﺑﻬﺎ اﺟﺒﺎراَ‬
‫]‪.[1.2‬‬
‫دﻋﻨﺎ ﻧﺘﻔﺤﺺ ﻛﻴﻔﻴﺔ ﻋﻤﻞ ذﻟﻚ ﺟﺪﻳﺎَ‪.‬‬

‫ﺷﻐّﻞ ‪ Xcode‬واﻧﺸﻲء ﻣﺸﺮوع ﺟﺪﻳﺪ‪ .‬اﺧﺘﺮ ﻧﻮع ﺗﻄﺒﻴﻘﺎت ‪Cocoa‬‬
‫‪Application‬‬ ‫اﳌﻌﺸﺸﺔ داﺧﻞ ﺗﺮوﻳﺴﺔ اﻟﺘﻄﺒﻴﻘﺎت‬ ‫‪Application‬‬
‫‪.heading‬‬
‫اﻃﻠﻖ اﺳﻢ ﻋﻠﻰ اﳌﺸﺮوع )ﻣﻊ ﻣﺮاﻋﺎة ﻗﻮاﻋﺪ اﻟﺘﺴﻤﻴﺔ اﻟﺘﻲ ﲢﺜﻚ ﻋﻠﻰ‬
‫اﻟﺮﺳﻢ اﻟﺘﻮﺿﻴﺤﻲ ﻳﻮﺿﺢ ﻋﻤﻠﻴﺔ ﺗﺒﺎدل اﻟﺮﺳﺎﺋﻞ ﺑﲔ اﻟﻜﺎﺋﻨﺎت داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫إﺳﺘﺨﺪام ﺣﺮف ﻛﺒﻴﺮ ‪ Capital‬ﻓﻲ ﺑﺪاﻳﺔ اﺳﻢ اﻟﺘﻄﺒﻴﻖ اﳌﺴﺘﺨﺪم‬
‫ﻟﻠﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ(‪ .‬داﺧﻞ اﻃﺎر اﳌﻠﻔﺎت واﳌﺠﻤﻮﻋﺎت‪ ،‬اﻓﺘﺢ‬ ‫ﻫﻨﺎ ﻧﻌﺮض اﻟﻄﺮﻳﻘﺔ اﻟﻌﺎﻣﺔ ﻻرﺳﺎل اﻟﺮﺳﺎﺋﻞ ﺑـ ‪ Objective-C‬دون‬
‫ﻣﺠﻠﺪ اﳌﺼﺎدر ‪ Resources‬واﺿﻐﻂ ﻣﺘﺘﺎﻟﻴ َﺎ ﻋﻠﻰ اﻻﻳﻘﻮﻧﺔ اﳌﺴﻤﺎة‬ ‫وﺟﻮد ﻣﻌﺎﻣﻼت ]‪ [1.1‬وﺑﻮﺟﻮدﻫﺎ]‪[1.2‬‬
‫‪. MainMenu.nib‬‬ ‫]‪[1‬‬
‫;]‪[receiver message‬‬
‫;]‪[receiver message:argument‬‬
‫‪٥٤‬‬
‫ﺑـ”‪ . “Cocoa-‬وﻫﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺨﺰن ﻟﻜﺎﻓﺔ اﻧﻮاع اﻟﻜﺎﺋﻨﺎت اﻟﺒﺼﺮﻳﺔ‬

‫اﳌﺘﺎﺣﺔ وﻫﺬﻩ اﻟﻨﺎﻓﺬة ﺗﻌﺮف ﺑﺎﺳﻢ ”‪. “palettes window‬‬
‫اﺿﻐﻂ اﻻﻳﻘﻮﻧﺔ اﻟﺘﺎﻟﻴﺔ ﻣﻦ ﺷﺮﻳﻂ اﻷدوات ‪ Tool Bar‬ﺑﺎﻋﻠﻰ ﻣﺨﺰن‬
‫اﻟﻜﺎﺋﻨﺎت‪ ،‬وﻗﻢ ﺑﺴﺤﺐ اﻻﻳﻘﻮﻧﺔ اﻟﺘﻲ ﲤﺜﻞ ازرارﻳﻦ اﺳﻔﻞ ذﻟﻚ‬
‫اﻟﺸﺮﻳﻂ ﺛﻢ ﻗﻢ ﺑﺈﻓﻼﺗﻬﺎ ﻋﻠﻰ اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ اﳌﺴﻤﺎة ”‪“Window‬‬
‫‪.‬اﺿﻐﻂ اﻻﻳﻘﻮﻧﺔ اﻟﺘﺎﻟﻴﺔ ﻣﻦ ﺷﺮﻳﻂ ادوات ﻣﺨﺰن اﻟﻜﺎﺋﻨﺎت واﺳﺤﺐ‬
‫اﻟﻜﺎﺋﻦ اﳌﻤﺜﻞ ﳊﻘﻞ ﻧﺺ ‪ text field‬وﻛﻤﺎ ﻓﻌﻠﺖ ﺳﺎﺑﻘ َﺎ ﻗﻢ ﺑﺴﺤﺒﻬﺎ‬
‫واﻓﻼﺗﻬﺎ اﻟﻰ اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ‪ .‬ﺳﺘﺠﺪ ﻋﻨﺪﻫﺎ ان ﺣﻘﻞ اﻟﻨﺺ ﻗﺪ‬
‫اﺿﺎف ﺳﻠﺴﺔ اﳊﺮوف اﻟﺘﺎﻟﻴﺔ ”‪ “System Font Text‬اﻟﻰ اﻟﻨﺎﻓﺬة‬
‫اﻟﺮﺋﻴﺴﺔ‪.‬‬ ‫اﻟﻀﻐﻂ اﳌﺘﺘﺎﻟﻲ ﻟﻔﺘﺢ اﳌﻠﻒ ‪MainMenu.nib‬‬
‫‪Xcode‬‬ ‫ﻳﺆدي اﻟﻀﻐﻂ اﳌﺘﺘﺎﻟﻲ ﻋﻠﻰ ‪ MainMenu.nib‬داﺧﻞ‬

‫ﻟﺘﺸﻐﻴﻞ ﺑﺮﻧﺎﻣﺞ آﺧﺮ ﻳﺪﻋﻰ ‪ Interface Builder‬واﺧﺘﺼﺎرﻩ ‪،IB‬‬
‫ﺣﻴﺚ ﺳﻴﻈﻬﺮ ﻟﻚ ﻧﻮاﻓﺬﻩ اﳋﺎﺻﺔ‪ ،‬ﳝﻜﻨﻚ ﻋﻨﺪﻫﺎ اﺧﻔﺎء ﻧﻮاﻓﺬ‬
‫اﻟﺘﻄﺒﻴﻘﺎت اﻻﺧﺮى ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﻟﺘﺮﻛﻴﺰ ﻋﻠﻰ ﻣﺎ ﻳﺘﻴﺤﻪ ﻟﻚ‬
‫‪.Interface Builder‬‬
‫ﻳﻌﺮض ‪ Interface Builder‬ﻋﺪد ‪ ٣‬ﻧﻮاﻓﺬ اﺣﺪﻫﺎ ﺗﺴﻤﻰ ”‪“Window‬‬
‫واﻟﺘﻲ ﺳﺘﻜﻮن اﻟﻨﺎﻓﺬة اﻟﻈﺎﻫﺮة ﳌﺴﺘﺨﺪﻣﻲ ﺑﺮﻧﺎﻣﺠﻚ‪ ،‬اﻧﻬﺎ ﻛﺒﻴﺮة‬
‫ﺳﺤﺐ اﻟﻜﺎﺋﻨﺎت ﻣﻦ اﳌﺨﺰن اﻟﻰ ﻧﺎﻓﺬة اﻟﺘﻄﺒﻴﻖ‪.‬‬ ‫ﺗﻘﺮﻳﺒ َﺎ‪ ،‬ﳝﻜﻨﻚ ﲢﺠﻴﻤﻬﺎ‪ .‬واﻟﻰ ﳝﻴﻨﻬﺎ ﻳﻮﺟﺪ ﻧﺎﻓﺬة ﻳﺒﺪاء اﺳﻤﻬﺎ‬
‫‪٥٥‬‬
‫‪command-‬‬ ‫ﺑﺎﻟﻨﺎﻓﺬة اﻟﺴﻔﻠﻴﺔ اﻟﻴﺴﺮى( ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﳌﻔﺎﺗﻴﺢ‬ ‫ﺧﻠﻒ اﻟﻜﻮاﻟﻴﺲ‪ ،‬ﺗﺆدي ﻋﻤﻠﻴﺔ اﻟﺴﺤﺐ واﻻﻓﻼت ﻟﻠﻜﺎﺋﻨﺎت‬
‫‪ .shift-i‬ﺗﻔﺤﺺ ﻧﺎﻓﺬة اﳋﺼﺎﺋﺺ واﺧﺘﺮ "ﻣﻼﻣﺢ ‪ "Attributes‬ﻣﻦ‬ ‫‪-‬اﻻزرار ﻣﻦ ﻣﺨﺰﻧﻬﺎ اﻟﻰ اﻟﻨﺎﻓﺬة‪ ،-‬ﺗﺆدي إﻟﻰ إﻧﺸﺎء ﻛﺎﺋﻦ ازرار‬
‫اﻟﻘﺎﺋﻤﺔ اﳌﻨﺴﺪﻟﺔ ‪ .pop-up menu‬ﳝﻜﻨﻚ ﺗﻔﻌﻴﻞ ﻣﻼﻣﺢ اﻟﻨﻘﺸﺎت‬ ‫ﺟﺪﻳﺪ ﻋﻠﻰ اﻟﻨﺎﻓﺬة‪ .‬وﻛﺬﻟﻚ اﳊﺎل ﻣﻊ ﺣﻘﻞ اﻟﻨﺺ واى ﻛﺎﺋﻦ آﺧﺮ‬
‫‪ Textured Window‬اﻟﺘﻲ ﺗﻮﻓﺮﻫﺎ اﻟﻨﺎﻓﺬة‪ ،‬ﻫﺬا اﻟﺘﻔﻌﻴﻞ ﻳﺠﻌﻞ‬ ‫ﻗﺎﺑﻞ ﻟﻠﺴﺤﺐ واﻻﻓﻼت‪.‬‬
‫ﻧﺎﻓﺬﺗﻚ ﺗﺘﺨﺬ اﻟﺸﻜﻞ اﳌﻌﺪﻧﻲ ﻻﻇﻬﺎر ذاﺗﻬﺎ‪ .‬ذﻟﻚ ﻳﻌﻨﻲ اﻣﻜﺎﻧﻴﺔ‬ ‫ﻻﺣﻆ ﻇﻬﻮر ﺗﻌﻠﻴﻖ ﻣﻘﺘﻀﺐ ﲟﺠﺮد اﻳﻘﺎف اﳌﺆﺷﺮ ﻋﻠﻰ اﺣﺪ ﺗﻠﻚ‬
‫ﺗﺨﺼﻴﺺ اﻟﻌﺮض اﻟﺒﺼﺮي ﻟﻌﺪد ﻛﺒﻴﺮ ﻣﻦ اﺟﺰاء ﺑﺮﻧﺎﻣﺞ دون اﳊﺎﺟﺔ‬ ‫اﻟﻜﺎﺋﻨﺎت‪ ،‬ﺗﻌﻠﻴﻘﺎت ﻣﺜﻞ ‪ NSButton‬أو ‪ . NSTextView‬ﺗﻠﻚ‬
‫ﻟﻜﺘﺎﺑﺔ اي ﺳﻄﺮ ﺑﺮﻣﺠﻲ!‬ ‫اﻟﺘﻌﻠﻴﻘﺎت ﲤﺜﻞ اﺳﻤﺎء اﻟﺘﺼﻨﻴﻔﺎت اﻟﺘﻲ ﲤﺜﻠﻬﺎ واﻟﺘﻲ اﻋﺪﺗﻬﺎ ﻟﻚ‬
‫أﭘﻞ‪ ،‬وﻫﻲ ﺿﺮورﻳﺔ ﻟﺘﺄدﻳﺔ ﻋﺪد ﻣﻦ اﻟﻌﻤﻠﻴﺎت داﺧﻞ اﻟﺘﻄﺒﻴﻖ‪.‬‬
‫ﻗﻢ ﺑﺘﺮﺗﻴﺐ ﻣﻮﺿﻊ ﺗﻠﻚ اﻟﻜﺎﺋﻨﺎت داﺧﻞ ﻧﺎﻓﺬﺗﻚ‪ .‬وﲢﺠﻴﻢ ﻣﺎ ﻳﻠﺰم‪.‬‬
‫ﻗﻢ ﺑﺘﻐﻴﻴﺮ ﻧﺼﻮص اﻻزرار‪ ،‬وذﻟﻚ ﻣﻦ ﺧﻼل اﻟﻀﻐﻂ اﳌﺘﻜﺮر ﻋﻠﻰ‬
‫اﻻزرار‪.‬‬
‫ﻧﺪﻋﻮك ﻟﺘﻔﺤﺺ ﻧﺎﻓﺬة ﻣﺨﺰن اﻟﻜﺎﺋﻨﺎت ﺣﺘﻰ ﺗﺘﻤﺮس ﻋﻠﻰ ﻋﻤﻠﻴﺔ‬
‫اﺿﺎﻓﺔ اﻟﻜﺎﺋﻨﺎت إﻟﻰ اﻟﻨﺎﻓﺬة‪.‬‬
‫ﻟﺘﻐﻴﻴﺮ ﺧﺼﺎﺋﺺ ‪ properties‬اﺣﺪ اﻟﻜﺎﺋﻨﺎت‪ ،‬اﺧﺘﺮ اﻟﻜﺎﺋﻦ اﳌﺮاد‬
‫ﺗﻐﻴﻴﺮ ﺧﺼﺎﺋﺼﺔ وذﻟﻚ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﳌﻔﺎﺗﻴﺢ ‪.command-shift-i‬‬
‫ﻧﻨﺼﺤﻚ ﺑﺘﻔﺤﺺ ﺗﻠﻚ اﳋﺼﺎﺋﺺ اﻳﻀ َﺎ‪.‬‬
‫ﻛﻤﺜﺎل اﺧﺘﺮ اﻟﻨﺎﻓﺬ اﻟﺮﺋﻴﺴﺔ ”‪) “Window‬ﺳﻮف ﻳﺘﻢ اﻋﻼﻣﻚ‬
‫دﺗﻔﺤﺺ ﻧﺎﻓﺬﺗﻨﺎ ﻣﻦ ﺧﻼل ﺑﺮﻧﺎﻣﺞ ‪.IB‬‬ ‫ﺑﺬﻟﻚ ﻣﺒﺎﺷﺮة ﻣﻦ ﺧﻼل وﺟﻮد ﲢﺪﻳﺪ ﺣﻮل ﻣﺴﺘﻨﺴﺦ اﻟﻨﺎﻓﺬة اﳌﺒﲔ‬
‫‪٥٦‬‬
‫ﻓﺎﻧﺖ ﻟﻢ ﺗﻘﻢ ﺑﻜﺘﺎﺑﺔ أو ﺑﻨﺴﺦ اي ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ ﺗﺘﻌﺎﻣﻞ ﻣﻊ ﺗﻠﻚ‬ ‫ﻛﻤﺎ وﻋﺪﻧﺎك ﺳﺎﺑﻘ َﺎ‪،‬ﻧﺤﻦ ﻋﻠﻰ وﺷﻚ إﻧﺸﺎء ﺗﺼﻨﻴﻒ ‪ .class‬وﻟﻜﻦ‬
‫اﻟﺮﺳﺎﻟﺔ‪ .‬اﻻﻣﺮ ﺑﺴﻴﻂ ﺟﺪاَ ﻫﻨﺎ‪ ،‬ﻓﺎذا ﻣﺎ ﺗﻠﻘﻰ اﻟﺘﺼﻨﻴﻒ اﳉﺪﻳﺪ رﺳﺎﻟﺔ‬ ‫ﻗﺒﻞ اﻟﺒﺪء ﺑﺬﻟﻚ دﻋﻨﺎ ﻧﺘﻔﺤﺺ أﻟﻴﺔ ﻋﻤﻞ ﺗﻠﻚ اﻟﺘﺼﻨﻴﻔﺎت‪.‬‬
‫ﻣﺎ ﻟﺘﻨﻔﻴﺬ إﺣﺮاء ﻣﻌﲔ ﻟﻢ ﻧﻘﻢ ﺑﺎدﺧﺎل اي ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ ﳌﻌﺎﳉﺘﻪ‪،‬‬ ‫ﻓﻠﺘﻮﻓﻴﺮ اﳉﻬﻮد اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬ﻣﻦ اﻻﻓﻀﻞ داﺋﻤ َﺎ ان ﻧﺒﻨﻲ ﻋﻠﻰ ﻣﺎﺑﻨﺎﻩ‬
‫ﻋﻨﺪﻫﺎ ﺳﻴﺘﻢ ﺗﻮﺟﻴﻪ اﻟﺮﺳﺎﻟﺔ ﺑﺸﻜﻞ آﻟﻲ إﻟﻰ اي ﺗﺼﻨﻴﻒ اﻋﻠﻰ ﻣﻨﻪ‬ ‫اﻻﺧﺮون‪َ ،‬‬
‫ﺑﺪﻻ ﻣﻦ اﻟﺒﺪء ﻣﻦ ﻧﻘﻄﺔ اﻟﺼﻔﺮ ﻟﻨﻌﻴﺪ إﺧﺘﺮاع اﻟﺪاﺋﺮة‪ .‬ﻓﺎن‬
‫ﺑﺴﻠﺴﻠﺔ اﻟﻮراﺛﺔ اي اﻟﺘﺼﻨﻴﻒ اﻟﺬي ورﺛﻨﺎ ﻣﻨﻪ ﺧﺼﺎﺋﺺ ﺗﺼﻨﻴﻔﻨﺎ‬ ‫ﻛﻨﺖ ﺑﺤﺎﺟﺔ ﻹﻧﺸﺎء ﻧﺎﻓﺬة ﺟﺪﻳﺪة ﺑﺨﺼﺎﺋﺺ وﺳﻠﻮﻛﻴﺎت ﺧﺎﺻﺔ‬
‫أو ﻣﺎ ﻧﻄﻠﻖ ﻋﻠﻴﻪ )”‪.(“superclass‬‬ ‫ﻼ‪ ،‬ﻓﺎن ﻛﻞ ﻣﺎ ﻫﻮ ﻣﻄﻠﻮب ﻣﻨﻚ ﻫﻮ ﺗﺰوﻳﺪ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ‬‫ﻣﺜ َ‬
‫ﻋﻨﺪ اﻟﻀﺮورة‪ ،‬ﻳﺘﻢ اﻋﺎدة ﺗﻮﺟﻴﺔ ﻃﻠﺐ ﺗﻨﻔﻴﺬ اﻻﺟﺮاء ﺑﺎﲡﺎﻩ‬ ‫ﺗﻮﺻﻒ ﺗﻠﻚ اﳋﺼﺎﺋﺺ و اﻟﺴﻠﻮﻛﻴﺎت‪ .‬وﻟﻦ ﺗﻜﻮن ﻣﻠﺰﻣ َﺎ ﻟﻜﺘﺎﺑﺔ اي‬
‫اﻟﺘﺼﻨﻴﻒ اﻻﻋﻠﻰ ﻓﺎﻻﻋﻠﻰ‪ ،‬ﺣﺘﻰ ﻳﺘﻢ اﻳﺠﺎد ذﻟﻚ اﻻﺟﺮاء وﺗﻨﻔﻴﺬﻩ‬ ‫ﺷﻔﺮات ﺑﺮﻣﺠﻴﺔ ﻟﺘﻮﺻﻴﻒ ﻋﻤﻠﻴﺎت اﻻﻏﻼق ﻣﺜﻼ‪ ،‬ﻻﻧﻬﺎ ﻣﻮﺟﻮد َة‪.‬‬
‫ﻣﻦ اﻋﻠﻰ اﻟﻬﺮم اﳌﻜﻮن ﻣﻨﻪ ﻫﺬا اﻟﺘﺼﻨﻴﻒ ‪(top of the hierarchy‬‬ ‫ان اﻋﺘﻤﺎدك اﻟﺒﻨﺎء ﻋﻠﻰ ﻣﺎ ﻗﺎم اﻻﺧﺮون ﺑﺒﻨﺎﻩ ﻳﻜﺴﺒﻚ ﻛﺎﻓﺔ ﺗﻠﻚ‬
‫)‪.of inheritance‬‬ ‫اﻟﺴﻠﻮﻛﻴﺎت اﳌﺒﻨﻴﺔ ﻣﺠﺎﻧﺎ دون ادﻧﻲ ﺟﻬﺪَ ‪ .‬وذﻟﻚ ﻣﺎ ﻳﺠﻌﻞ‬
‫ﻓﻲ ﺣﺎل ﻟﻢ ﻳﺘﻢ اﻟﻌﺜﻮر ﻋﻠﻰ ذﻟﻚ اﻻﺟﺮاء ﻧﻜﻮن ﻋﻨﺪﻫﺎ ﻗﺪ‬ ‫‪ Objective-C‬ﻣﺨﺘﻠﻔﺔ اﻛﺜﺮ ﻋﻦ ﻟﻐﺔ ‪ C‬اﻟﺼﺮﻓﺔ‪.‬‬
‫ارﺳﻠﻨﺎ رﺳﺎﻟﺔ ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﻤﻌﺎﳉﺔ‪ .‬اﻧﻪ ﻣﺜﻞ ﻃﻠﺒﻚ ﻟﻌﻤﺎل‬ ‫ﻛﻴﻒ ﻳﺘﻢ ذﻟﻚ؟‬
‫ورﺷﺔ ان ﻳﻐﻴﺮوا دواﻟﻴﺐ زﻻﺟﺘﻚ اﻟﺜﻠﺠﻴﺔ ‪-‬اﻟﺘﻲ ﻻﲢﺘﻮي اي‬ ‫ﻓﻲ اﳊﻘﻴﻘﺔ‪ ،‬ﻫﻨﺎك ﺗﺼﻨﻴﻒ ﻟﻠﻨﺎﻓﺬة ﺑﺎﺳﻢ ‪، NSWindow‬ﺣﻴﺚ‬
‫دواﻟﻴﺐ‪ .-‬ﻓﻲ ﻫﺬﻩ اﳊﺎﻟﺔ ﺣﺘﻰ ﻣﺪﻳﺮ اﻟﻮرﺷﺔ ﻟﻦ ﻳﺴﺘﻄﻴﻊ ان‬ ‫ﳝﻜﻨﻚ ذﻟﻚ ان ﺗﺒﻨﻲ ﺗﺼﻨﻴﻒ ﺧﺎص ﺑﻚ ﺑﺤﻴﺚ ﻳﺴﺘﻘﻰ )ﻳﺮث‬ ‫ّ‬
‫ﻳﻘﺪم ﻟﻚ ﺷﻲء‪ .‬ﺗﻘﻮم ‪ Objective-C‬ﻓﻲ ﻣﺜﻞ ﻫﺬﻩ اﳊﺎﻻت‬ ‫‪ (inherits‬ﻛﺎﻓﺔ ﺧﺼﺎﺋﺺ اﻟﺘﺼﻨﻴﻒ اﻻول اي ‪.NSWindow‬‬
‫ﺑﺎﺻﺪار رﺳﺎﻟﺔ ﺧﻄﺎء‪.‬‬ ‫واﻻن ﻟﻨﻔﺘﺮض اﻧﻚ ﺗﺮﻏﺐ ﺑﺎﺿﺎﻓﺔ ﺳﻠﻮك ﺟﺪﻳﺪ ﻟﺘﺼﻨﻴﻔﻚ اﳌﺒﻨﻲ‬
‫ﻣﺎذا ﻟﻮ رﻏﺒﺖ ﺑﺘﻌﺪﻳﻞ اﺣﺪ اﻟﺴﻠﻮﻛﻴﺎت أو اﻻﺟﺮاءات اﳌﻮروﺛﺔ ﻣﻦ‬ ‫ﻋﻠﻰ ﺗﺼﻨﻴﻒ اﻟﻨﺎﻓﺬة‪ .‬ﻣﺎﻟﺬي ﺳﻴﺤﺪث ﻟﻮ ﺗﻠﻘﻰ ﺗﺼﻨﻴﻒ ﻧﺎﻓﺬﺗﻨﺎ‬
‫ﺗﺼﻨﻴﻔﻚ اﻻب ﻓﻲ ﺗﺼﻨﻴﻔﻚ اﳊﺎﻟﻲ؟‬ ‫اﳉﺪﻳﺪ رﺳﺎﻟﺔ اﻻﻏﻼق ”‪ “close‬؟‬
‫‪٥٧‬‬
‫ﺑﺎﻗﻲ اﻟﻜﺎﺋﻨﺎت ﻓﻤﻨﻪ ﻳﺘﺤﺪر اﳉﻤﻴﻊ وﻣﻨﻪ ﻳﺴﺘﻘﻮن ﺗﻮﺻﻴﻔﺎﺗﻬﻢ‪،‬‬ ‫ذﻟﻚ اﻣﺮ ﻳﺴﻴﺮ‪ ،‬ﺣﻴﺚ ﳝﻜﻨﻚ دوﻣ َﺎ ﺗﻜﻴﻴﻒ ‪ -override-‬ﺗﻠﻚ‬
‫وﺟﻤﻴﻌﻬﻢ ﻳﺤﺘﻔﻈﻮن ﺑﺨﺼﺎﺋﺼﻪ وﺳﻠﻮﻛﻴﺎﺗﻪ وراﺛﻴ َﺎ‪ .‬اﻧﻪ اﻟﺘﺼﻨﻴﻒ‬ ‫اﻻﺟﺮاءات‪ .‬ﻛﻤﺜﺎل ﳝﻜﻨﻚ اﻋﺎدة ﺗﻜﻴﻴﻒ اﻻﺟﺮاء ‪ ، close‬اﻟﺬي‬
‫اﻻب ﻟﻜﺎﻓﺔ اﻟﺘﺼﻨﻴﻔﺎت ‪ subclasses‬اﻟﺘﻲ ﺗﺮث ﻣﻨﻪ ﺳﻮاء ﺑﺸﻜﻞ‬ ‫ﻳﺠﻌﻞ اﻟﻨﺎﻓﺬة ﺗﺨﻔﻲ ذاﺗﻬﺎ ﺑﺼﺮﻳ َﺎ ﺑﺤﻴﺚ ﻳﻜﻮن إﺟﺮاء اﻻﻏﻼق ﻋﺒﺎرة‬
‫ﻣﺒﺎﺷﺮ أو ﻏﻴﺮ ﻣﺒﺎﺷﺮ‪.‬ﻛﻤﺜﺎل ﳒﺪ ان اﻟﺘﺼﻨﻴﻒ ‪NSWindow‬‬ ‫ﻋﻦ ﺗﻨﺤﻴﺔ وﺗﻐﻴﻴﺮ ﳌﻮﻗﻊ اﻟﻨﺎﻓﺬة ﺛﻢ اﻏﻼﻗﻬﺎ‪ .‬ان اﻟﺘﺼﻨﻴﻒ اﻟﻜﺎﺋﻨﻲ‬
‫ﺗﺼﻨﻴﻒ ﻣﺘﺤﺪر ﻣﻦ ﺳﻼﻟﺔ اﻟﺘﺼﻨﻴﻒ ‪ NSResponder‬وﻫﺬا‬ ‫ﻟﻨﺎﻓﺬﺗﻚ ﻳﺴﺘﺨﺪم ذات اﻻﺳﻢ اﳌﻌﺮف ﻟﻼﻏﻼق واﻟﺬي اﻋﺪﺗﻪ ﻟﻚ‬
‫اﻻﺧﻴﺮ ﻣﺘﺤﺪر ﻣﻦ ﺳﻼﻟﺔ اﻟﺘﺼﻨﻴﻒ اﻻب ‪.NSObject‬‬ ‫أﭘﻞ‪ .‬ﻟﺬا ﻣﺎ ان ﻳﺘﻢ ﺗﻮﺟﻴﻪ رﺳﺎﻟﺔ إﺟﺮاء اﻻﻏﻼق ﻟﻨﺎﻓﺬﺗﻚ‪ ،‬ﻓﺎﻧﻬﺎ‬
‫ان اﻟﺘﺼﻨﻴﻒ اﻻب ‪ NSObject‬ﻳﻮﺻﻒ اﻓﻌﺎل ﻣﺘﺠﺎﻧﺴﺔ وﻣﻌﻤﻤﺔ‬ ‫ﺳﻮف ﺗﺘﻨﺤﻰ وﺗﻐﻴﺮ ﻣﻮﻗﻌﻬﺎ ﻣﻦ اﻟﺸﺎﺷﺔ ﺛﻢ ﺗﻐﻠﻖ ذاﺗﻬﺎ‪.‬‬
‫داﺧﻞ اﻟﻜﺎﺋﻨﺎت اﻟﺘﻲ ﺗﺴﺘﻘﻲ‪/‬ﺗﺮث ﻣﻨﻪ )ﻛﺈﻧﺸﺎء ﻧﺺ ﻳﺼﻒ ﻧﻮع‬ ‫ان ﻋﻤﻠﻴﺔ اﻏﻼق اﻟﻨﺎﻓﺬة ﻟﺬاﺗﻬﺎ إﺟﺮاء ﻣﺒﺮﻣﺞ ﻣﺴﺒﻘ َﺎ ﻣﻦ ﻗﺒﻞ أﭘﻞ‪.‬‬
‫اﻟﻜﺎﺋﻦ‪ ،‬أو ﻗﺎﺑﻠﻴﺔ اﺟﺮاء اﺳﺘﻔﺴﺎر ﻣﺎ اذا ﻛﺎن اﻟﻜﺎﺋﻦ ﻗﺎدر ﻋﻠﻰ ﺗﻠﻘﻲ‬ ‫ﻓﻤﻦ داﺧﻞ ﻧﻄﺎق ﺗﻌﺮﻳﻔﻨﺎ ﻟﺬات اﻻﺟﺮاء ‪ close method‬ﻗﻤﻨﺎ‬
‫رﺳﺎﻟﺔ ﻣﺎ ‪..‬اﻟﺦ( ﻗﺒﻞ ان اﺿﺠﺮك ﺑﺎﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻨﻈﺮﻳﺎت‪ ،‬دﻋﻨﺎ ﻧﺮى‬ ‫ﺑﺎﺳﺘﺪﻋﺎء اﻻﺟﺮاء اﻻﺻﻠﻲ ﻟﻼﻏﻼق وﻫﻮ اﳌﻮروث ﻣﻦ اﻟﻨﻤﻮذج‬
‫ﻛﻴﻒ ُﻳﻨﺸﺄ اﻟﺘﺼﻨﻴﻒ ‪.create a class‬‬ ‫اﻻب ‪ superclass‬ﻟﻠﻨﺎﻓﺬة‪ .‬ﻫﻨﺎك ﺗﻐﻴﻴﺮات ﻃﻔﻴﻔﺔ ﻣﻄﻠﻮﺑﺔ ﺣﺘﻰ‬
‫ﺗﻮﺟﺔ اﻟﻰ ﻧﺎﻓﺬة ‪ MainMenu.nib‬واﺧﺘﺮ ﺑﻨﺪ اﻟﺘﺼﻨﻴﻔﺎت ‪.Classes‬‬ ‫ﻧﻀﻤﻦ اﻻﻳﻜﻮن ﻫﻨﺎك ﺗﻌﺎودﻳﺔ ‪ recursive‬اﺛﻨﺎء اﺳﺘﺪﻋﺎء اﻻﺟﺮاء‪.‬‬
‫ﺳﺘﺠﺪ رأس اﻟﻬﺮم ‪ NSObject‬ﻓﻲ اﻟﻌﻤﻮد اﻻول‪ .‬اﺧﺘﺮ ﻫﺬا اﻟﺘﺼﻨﻴﻒ‬ ‫]‪[2‬‬
‫‪// Code to move the window out of sight‬‬
‫ﺛﻢ ﺗﻮﺟﻪ اﻟﻰ اﻟﻘﺎﺋﻤﺔ اﻟﻌﻠﻴﺎ ‪ menubar‬ﺣﻴﺚ ﲡﺪ ﻗﺎﺋﻤﺔ ‪Classes‬‬ ‫‪here.‬‬
‫‪ .menu‬وﻣﻦ ﻫﻨﺎك اﺧﺘﺮ ﺗﻔﻌﻴﻞ اﻣﺮ ‪ ، Subclass NSObject‬ﻫﺬا‬ ‫‪[super close]; // Use the close method of‬‬
‫‪the superclass.‬‬
‫اﻻﻣﺮ ﺳﻴﻨﺸﻲء ﺗﺼﻨﻴﻒ ﻳﺮث ﺻﻔﺎت اﻟﻨﻤﻮذج اﻻب‪ .‬ﻗﻢ ﺑﺎﻟﻌﻮدة‬
‫ﻣﺮة أﺧﺮى اﻟﻰ ‪ ،MainMenu.nib‬واﻃﻠﻖ ﻋﻠﻰ اﻟﺘﺼﻨﻴﻒ اﳉﺪﻳﺪ‬ ‫ﻫﺬا اﳌﻔﻬﻮم اﻟﺒﺮﻣﺠﻲ ﻣﺘﻘﺪم ﺟﺪاَ ﻻن ﻳﻮﺟﺪ ﺑﻜﺘﺎب ﻟﻠﻤﺒﺘﺪﺋﲔ‪،‬‬
‫اﺳﻤ َﺎ ذي دﻻﻟﺔ‪ ،‬ﻋﻦ ﻧﻔﺴﻲ اﻃﻠﻘﺖ ﻋﻠﻰ اﻟﺘﺼﻨﻴﻒ اﳉﺪﻳﺪ اﺳﻢ‬ ‫ﻟﺬا ﻟﻦ ﻧﺘﻮﻗﻊ ﻣﻨﻚ ان ﺗﺴﺘﻮﻋﺒﻪ ﺑﺒﻀﻌﺔ اﺳﻄﺮ ﺧﺎﻟﻴﺔ ﻣﻦ اﻟﺪﺳﻢ‪.‬‬
‫”‪.“MAFoo‬‬ ‫ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻜﺎﺋﻨﺎت اﻟﺒﺮﻣﺠﻴﺔ‪ُ ،‬ﻳﻌﺪ ‪ NSObject‬اﺻﻞ ﻧﺸﺄة ووﺟﻮد‬
‫‪٥٨‬‬
‫اﳊﺮﻓﲔ ‪ NS‬ذﻟﻚ اﻧﻬﺎ ﺑﺎدﺋﺔ ﻣﻌﺘﻤﺪة ﻟﺘﺼﻨﻴﻔﺎت أﭘﻞ ‪ .‬وﻫﻲ اﺧﺘﺰال‬

‫ﻻﺳﻢ ‪ .NextStep‬ﻓـ ‪ NextStep‬ﻛﺎن اﻟﻨﻈﺎم اﻻﺳﺎﺳﻲ اﻟﺬي ﻳﻘﻮم‬
‫ﻋﻠﻴﻪ ﻧﻈﺎم ‪ Mac OS X‬واﻟﺬي ﻗﺎﻣﺖ أﭘﻞ ﺑﺸﺮاءﻩ‪ ،‬وﺣﺼﻠﺖ ﻋﻠﻰ‬
‫ﺳﺘﻴﻒ ﺟﻮﺑﺰ ﻛﻬﺪﻳﺔ اﺿﺎﻓﻴﺔ ﻓﻮق اﻟﻌﺮض‪.‬‬
‫ﻣﻮﻗﻊ داﺋﺮة اﳌﻌﻠﻮﻣﺎت اﳌﺘﺸﺎرﻛﺔ ‪ CocoaDev wiki‬ﻳﺤﻮي ﻗﺎﺋﻤﺔ‬
‫ﺑﺎﳊﺮوف اﻟﺒﺎدﺋﺔ ‪ prefixes‬اﻟﺘﻲ ﻳﺠﺐ ﲡﻨﺒﻬﺎ‪ .‬ﻳﺠﺪر ﺑﻚ زﻳﺎرة‬
‫اﳌﻮﻗﻊ ﻣﺘﻰ ﻣﺎ ﻗﺮرت اﻋﺘﻤﺎد ﺑﺎدﺋﺔ ﺗﺴﻤﻴﺎت ﺧﺎﺻﺔ ﺑﻚ‪.‬‬
‫‪http://www.cocoadev.com/index.‬‬
‫‪pl?ChooseYourOwnPre x‬‬
‫ﻣﺘﻰ ﻗﻤﺖ ﺑﺈﻧﺸﺎء ﺗﺼﻨﻴﻒ ﺟﺪﻳﺪ‪ ،‬اﺣﺮص ﻋﻠﻰ اﻋﻄﺎءﻩ اﺳﻤ َﺎ ذي‬
‫دﻻﻟﺔ وﻣﻌﻨﻰ ﻣﻮﺟﺰ ﻋﻦ دورﻩ‪ .‬ﻛﻤﺜﺎل وﻛﻤﺎ رأﻳﻨﺎ ﻓﻲ ﺗﺼﻨﻴﻔﺎت‬ ‫إﻧﺸﺎء ﺗﺼﻨﻴﻒ ”‪“MAFoo class‬‬
‫‪ Cocoa‬ﺣﻴﺚ ﻛﺎن ﺗﺼﻨﻴﻒ اﻟﻨﺎﻓﺬة ﻣﺘﺨﺬاَ اﻻﺳﻢ ‪NSWindow‬‬
‫‪ .‬ﻣﺜﺎل آﺧﺮ ﻋﻦ ﺗﺼﻨﻴﻒ ﻳﺨﺘﺺ ﺑﺈﻇﻬﺎر اﻻﻟﻮان وﻫﻮ ﲢﺖ اﺳﻢ‬ ‫ﺳﺘﻠﺤﻆ وﺟﻮد ﺣﺮﻓﲔ ﻛﺒﻴﺮﻳﻦ ‪ Capital‬ﺿﻤﻦ اﺳﻢ ﻣﺼﻨﻔﻨﺎ‪ ،‬اﻧﻬﻤﺎ‬
‫‪ . NSColor‬ﻓﻲ ﺣﺎﻟﺘﻨﺎ ﻳﻌﺪ اﺳﻢ اﻟﺘﺼﻨﻴﻒ ‪ MAFoo‬اﻟﺬي ﻗﻤﻨﺎ‬ ‫اﺧﺘﺰال اﺑﺘﻜﺮﻧﺎﻩ ﻟﻼﺷﺎرة اﻟﻰ ”‪ .“My Application‬ﳝﻜﻨﻚ اﺧﺘﺮاع‬
‫ﺑﺈﻧﺸﺎءﻩ ﻣﺠﺮد ﻣﺜﺎل ﻟﺸﺮح اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﺳﻴﺘﻌﺎﻣﻞ ﺑﻬﺎ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻊ‬ ‫ﻣﺎ ﺗﺮاﻩ ﻣﻨﺎﺳﺒ َﺎ ﻣﻦ اﻻﺳﻤﺎء ﳌﺼﻨﻔﺎﺗﻚ‪ .‬ﻗﺒﻞ ان ﺗﺒﺪأ اﻟﻌﻤﻞ ﺑﻜﺘﺎﺑﺔ‬
‫ﻫﺬا اﻟﺘﺼﻨﻴﻒ‪ .‬ﻟﺬا اﻃﻠﻘﻨﺎ ﻋﻠﻴﻪ ﻫﺬا اﻻﺳﻢ اﻟﻌﺒﺜﻲ دون اﻟﺪﻻﻟﺔ ﻻي‬ ‫ﺷﻔﺮة ﺑﺮﻧﺎﻣﺠﻚ ﻧﻨﺼﺤﻚ ﺑﺎن ﺗﺘﺨﺬ ﻣﻨﻬﺞ ﺗﺴﻤﻴﺔ ﻣﺸﺎﺑﻪ‪) .‬ﲟﻌﻨﻰ‬
‫دور ﻳﻘﻮم ﺑﻪ‪.‬‬ ‫اﺧﺘﻴﺎر ﺣﺮﻓﺎن أو ﺛﻼﺛﺔ ﻟﺘﻤﻴﻴﺰ ﻣﺼﻨﻔﺎﺗﻚ وﲡﻨﺐ ازدواﺟﻴﺔ ﺗﺼﺎدم‬
‫اﳌﺴﻤﻴﺎت ﻣﻊ اﳌﺼﻨﻔﺎت اﳌﻮﺟﻮدة أو اﻟﺘﻲ ﻳﺘﻢ اﺳﺘﻌﺎرﺗﻬﺎ وﺗﻀﻤﻴﻨﻬﺎ‬
‫ﺑﺎﻟﻌﻮدة اﻟﻰ ﺑﺮﻧﺎﻣﺞ ‪ ، IB‬ﻗﻢ ﺑﺎﺧﺘﻴﺎر إﺳﺘﻨﺴﺎخ ‪ Instantiate‬ﻟﻌﻤﻞ‬ ‫ﻣﻦ ﻗﺒﻞ ﻣﺒﺮﻣﺠﲔ آﺧﺮﻳﻦ(‪ .‬ﻋﻠﻰ ﻛﻞ ﺣﺎل ﲡﻨﺐ اﺳﺘﺨﺪم ﺑﺎدﺋﺔ‬
‫ﻣﺴﺘﻨﺴﺦ ﻣﻦ ﺗﺼﻨﻴﻒ ‪ MAFoo‬اﻟﺬي ﺳﺘﺠﺪﻩ ﻗﺪ اﺿﻴﻒ داﺧﻞ‬
‫‪٥٩‬‬
‫رﺳﺎﺋﻞ ﻣﻮﺟﻬﺔ ﻣﻨﻪ ﺷﺨﺼﻴ َﺎ اﻟﻰ ﺣﻘﻞ اﻟﻨﺺ‪ ،‬ذﻟﻚ ﺿﺮوري ﻻن‬ ‫ﻗﺎﺋﻤﺔ اﻟﺘﺼﻨﻴﻔﺎت ‪، .Classes menu‬ﻛﻤﺎ ﺳﺘﺮى ادﻧﻰ ﻟﻮﻳﺤﺔ‬
‫ﺣﻘﻞ اﻟﻨﺺ ﻛﺎﺋﻦ ﻳﺴﺘﻘﺒﻞ اﻟﺮﺳﺎﺋﻞ‪.‬‬ ‫اﳌﺴﺘﻨﺴﺨﺎت ‪ ،Instances tab‬ﻟﺪﻳﻚ اﻻن اﻳﻘﻮﻧﺔ ﺟﺪﻳﺪة ﺑﺎﺳﻢ‬
‫ان اي ﻛﺎﺋﻦ ﻏﻴﺮ ﻗﺎدر ﻋﻠﻰ اﻟﺘﻮاﺻﻞ ﻣﻊ اﻟﻜﺎﺋﻨﺎت اﻻﺧﺮى ﻓﻲ‬ ‫‪ .MAFoo‬ﻫﺬﻩ اﻻﻳﻘﻮﻧﺔ ﺗﻘﻮم ﻣﻘﺎم اﳌﺴﺘﻨﺴﺦ اﳉﺪﻳﺪ اﻟﺬي ﻗﻤﺖ‬
‫ﻇﻞ ﻋﺪم وﺟﻮد ﺗﻮﺻﻴﻠﺔ ﻣﺮﺟﻌﻴﺔ ‪ reference‬ﺗﺪﻟﻪ ﻋﻠﻰ اﻟﻜﺎﺋﻦ‬ ‫ﺑﺈﻧﺸﺎءﻩ‪.‬‬
‫اﳌﺴﺘﻘﺒﻞ‪.‬‬
‫ﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺎﻟﺘﻮﺻﻴﻞ ﻣﺎ ﺑﲔ اﻻزرار وﻣﺼﻨﻔﻨﺎ اﻟﻜﺎﺋﻦ ‪،MAFoo‬‬
‫ﻓﺈﻧﻨﺎ ﺑﺬﻟﻚ ﻧﺰود اﻻزرار ﺑﺎﺷﺎرة ﻣﺮﺟﻌﻴﺔ ﻛﺠﺴﺮ ﺗﻮاﺻﻞ ﺗﺸﻴﺮ‬
‫ﻟﻠﻜﺎﺋﻦ ‪ .MAFoo‬اﻻزرار ﻫﻨﺎ ﺳﻴﺘﻤﻜﻦ ﻣﻦ ارﺳﺎل اﻟﺮﺳﺎﻟﺔ اﻟﻰ‬
‫اﻟﻜﺎﺋﻦ ‪ .MAFoo‬وﺑﺎﳌﻘﺎﺑﻞ ﻛﺎﺋﻨﻨﺎ ‪ MAFoo‬ﺳﻴﺤﺘﺎج ﳌﺪ ﺟﺴﺮ‬
‫اﻟﺘﻮاﺻﻞ ﻣﻊ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪ ،‬ﺣﺘﻰ ﻳﺘﻤﻜﻦ اﻻﺧﻴﺮ ﻣﻦ ﺗﻠﻘﻲ‬
‫اﻟﺮﺳﺎﻟﺔ واﻻﻣﺘﺜﺎل ﻟﻬﺎ‪.‬‬
‫دﻋﻨﺎ ﻧﻮاﻛﺐ ﻣﺎ ﻳﻘﻮم ﺑﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻣﺮة اﺧﺮى‪ .‬ان ﻛﻞ ازرار ﻣﻦ اﻻزارﻳﺮ‬
‫ﻼ ﻟﻀﻐﻄﺔ‬ ‫ﻫﻨﺎ ﻗﺎدر ﻋﻠﻰ ارﺳﺎل رﺳﺎﻟﺔ ﳊﺪث ﻓﺮﻳﺪ ﻛﺮد ﻓﻌﻞ ﻣﺜ َ‬
‫ﻣﺆﺷﺮ اﳌﺎوس اﻟﺬي ﰎ ﻋﻠﻰ ذﻟﻚ اﻻزرار‪ .‬ﻣﺘﻰ ﰎ ﺿﻐﻂ اﻻزرار ﻗﺎم‬
‫اﻻﺧﻴﺮ ﺑﺎرﺳﺎل رﺳﺎﻟﺔ ﺑﻨﺎء ﻋﻠﻰ ذﻟﻚ اﳊﺪث‪ .‬ﻫﺬﻩ اﻟﺮﺳﺎﻟﺔ ﲢﺘﻮي‬ ‫إﻧﺸﺎء ﻣﺴﺘﻨﺴﺦ ‪MAFoo‬‬
‫ﻣﺎﻳﻠﻲ‪:‬‬ ‫ﺧﻄﻮﺗﻨﺎ اﻟﺘﺎﻟﻴﺔ ﺣﻮل إﻧﺸﺎء ﺗﻮﺻﻴﻼت ﻣﺎ ﺑﲔ اﻻزرار )اﻟﺘﻲ ﺳﺘﻘﻮم‬
‫‪ -‬اﺳﻢ اﻻﺟﺮاء اﳌﺮاد ﺗﻨﻔﻴﺬﻩ ﻣﻦ اﻟﺘﺼﻨﻴﻒ ‪ MAFoo‬اﻟﺬي ﺳﻴﻘﻮم‬ ‫ﺑﺎرﺳﺎل اﻟﺮﺳﺎﻟﺔ( اﻟﻰ ﻛﺎﺋﻦ ‪) MAFoo‬اﻟﺬي ﺳﻴﺘﻠﻘﻰ ﺗﻠﻚ اﻟﺮﺳﺎﺋﻞ(‪.‬‬
‫ﻓﻌﻠﻴ َﺎ ﺑﺘﻨﻔﻴﺬ اﻻﻣﺮ‪.‬‬ ‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ذﻟﻚ‪ ،‬ﺳﻨﻘﻮم ﺑﺠﻌﻞ ﻛﺎﺋﻦ ‪ MAFoo‬ﻗﺎدراَ ﻋﻠﻰ ارﺳﺎل‬
‫‪٦٠‬‬
‫ﻣﻦ ﺧﻼل ارﺳﺎل اﻟﺮﺳﺎﺋﻞ اﻟﻴﻪ‪.‬‬ ‫‪ -‬ﻫﺬﻩ اﻟﺮﺳﺎﻟﺔ ﺗﻮﺟﻪ اﻟﻰ اﻟﻜﺎﺋﻦ اﳌﺴﺘﻨﺴﺦ ﻣﻦ اﻟﺘﺼﻨﻴﻒ ‪MAFoo‬‬
‫ﺗﻴﻘﻦ ﻣﻦ اﺧﺘﻴﺎرك ﻟﻠﺘﺼﻨﻴﻒ ‪ MAFoo‬ﺑﻠﻮﻳﺤﺔ اﻟﺘﺼﻨﻴﻔﺎت ‪Classes‬‬ ‫اﻟﺬي أﻧﺸﺎءﻧﺎﻩ ﻣﺆﺧﺮاَ‪.‬‬

‫‪ tab‬ﺑﺎﻟﻨﺎﻓﺬة ذات اﻟﻌﻨﻮان ‪.MainFile.nib‬‬ ‫ﻓﻲ اﳊﻘﻴﻘﺔ اﻟﻜﺎﺋﻦ اﳌﺴﺘﻨﺴﺦ ‪ ، MAFoo‬ﻻﻳﻮﺟﺪ ﻟﺪﻳﻪ اي ﺧﺒﺮ‬
‫وﻣﻦ ﺧﻼل ﻟﻮﺣﺔ اﳌﻔﺎﺗﻴﺢ اﺿﻐﻂ اﳌﻔﺎﺗﻴﺢ اﻟﺘﺎﻟﻴﺔ ‪command-shift-‬‬ ‫ﺣﻮل ﻛﻴﻔﻴﺔ ﺗﻨﻔﻴﺬ اﻻﻣﺮ اﳌﺮﺳﻞ ﺑﺎﻟﺮﺳﺎﻟﺔ‪ .‬ﻟﻜﻦ اﻟﺘﺼﻨﻴﻒ ‪MAFoo‬‬
‫‪ i‬ﺣﺘﻰ ﺗﻈﻬﺮ ﻟﻚ ﻧﺎﻓﺬة ﺗﺪﻗﻴﻖ اﳋﺼﺎﺋﺺ اﳋﺎﺻﺔ ﺑﻬﺬا اﻟﺘﺼﻨﻴﻒ‪.‬‬ ‫ﻟﺪﻳﻪ اﳋﺒﺮ اﻟﻴﻘﲔ‬
‫‪Action tab‬‬ ‫ﻓﻲ ﻧﺎﻓﺬة ﺗﺪﻗﻴﻖ اﳋﺼﺎﺋﺺ‪ ،‬اﺧﺘﺮ ﻟﻮﻳﺤﺔ اﻻﻓﻌﺎل‬ ‫ﻟﺬا ﻣﺎ ﻳﺠﺮي ﻫﻨﺎ ﻫﻮ ان ﻳﺘﻢ ﺗﻮﺟﻴﺔ اﻟﺮﺳﺎﻟﺔ اﻟﻰ اﻟﻜﺎﺋﻦ اﳌﺴﺘﻨﺴﺦ‬
‫واﺿﻐﻂ اﻻزرار اﳌﻌﻨﻮن ﺑـ‪ Add‬ﺣﺘﻰ ﳝﻜﻨﻚ اﺿﺎﻓﺔ اﻻﺟﺮاء )ﻳﻄﻠﻖ‬ ‫‪ MAFoo‬واﻟﺬي ﺑﺪورﻩ ﺳﻴﻘﻮم ﺑﺮﻓﻌﻬﺎ اﻟﻰ ﻣﻮﺻﻒ ﺗﺼﻨﻴﻔﻪ اي‬
‫ﻋﻠﻴﻪ ‪ Action‬أو ‪ method‬وﻛﻼﻫﻤﺎ ﻧﻔﺲ اﳌﻌﻨﻰ( اﻟﻰ ﺗﺼﻨﻴﻔﻨﺎ ‪.‬‬ ‫‪ MAFoo‬وﻣﻦ ﻫﻨﺎك ﺳﻴﺘﻢ ﺗﻮﺟﻴﺔ ﺗﻠﻚ اﻟﺮﺳﺎﻟﺔ اﻟﻰ ﻛﺎﺋﻦ ﺣﻘﻞ‬
‫اﻟﻨﺺ‪.‬‬
‫ﻗﻢ ﺑﺘﻐﻴﻴﺮ اﻻﺳﻢ اﻻﻓﺘﺮاﺿﻲ ﻟﻺﺟﺮاء اﳌﻀﺎف ﺑﺎﺳﻢ ذي دﻻﻟﺔ وﺻﻔﻴﺔ‬
‫ﻣﺜﻞ ”‪- “setTo5:‬ذﻟﻚ اﻧﻨﺎ ﺳﻨﺒﺮﻣﺞ اﻟﻔﻌﻞ ﻟﻴﻌﺮض اﻟﻌﺪد ‪ ٥‬ﻛﻨﺺ‬ ‫ﻣﺜﻠﻬﺎ ﻣﺜﻞ اي رﺳﺎﻟﺔ‪ ،‬ﻫﺬﻩ اﻟﺮﺳﺎﻟﺔ ﻣﻜﻮﻧﺔ ﻣﻦ اﺳﻢ اﻻﺟﺮاء ‪method،‬‬
‫داﺧﻞ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪ -‬ﺛﻢ ﻗﻢ ﺑﺎﺿﺎﻓﺔ إﺣﺮاء آﺧﺮ وﻗﻢ ﺑﺘﺴﻤﻴﺘﻪ‬ ‫وﻫﻮ ﻓﻲ ﻫﺬﻩ اﳊﺎﻟﺔ اﻻﺟﺮاء اﻟﺬي ﻳﺄﻣﺮ ﺣﻘﻞ اﻟﻨﺺ ﺑﻌﺮض اﻟﻘﻴﻤﺔ‬
‫”‪ - “reset:‬ﻋﻠﻰ ﺳﺒﻴﻞ اﳌﺜﺎل ذﻟﻚ اﻧﻨﺎ ﺳﻨﺒﺮﻣﺞ ﻫﺬا اﻻﺟﺮاء ﻟﻴﻌﺮض‬ ‫ﻓﻲ اﻃﺎرﻩ‪ .‬ان اﻟﻘﻴﻤﺔ اﳌﺮﺳﻠﺔ ﺗﻌﺪ ﺟﺰء ﻣﻦ ﺗﻜﻮﻳﻦ اﻟﺮﺳﺎﻟﺔ‪ ،‬ﺑﺎﻻﺿﺎﻓﺔ‬
‫ﻗﻴﻤﺔ ﺻﻔﺮ ﺑﺤﻘﻞ اﻟﻨﺺ‪.-‬‬ ‫اﻟﻰ اﻻﺳﻢ اﻟﺬي ﺳﻴ ّﻨﺸﻂ ﺣﻘﻞ اﻟﻨﺺ ﻟﺘﻐﻴﻴﺮ ﻣﺤﺘﻮاﻩ‪.‬‬
‫وﻻﺣﻆ ان ﻛﺎﻓﺔ اﻻﺟﺮاءات اﳌﺴﺘﺤﺪﺛﺔ ﻫﺬﻩ ﺗﻨﺘﻬﻲ ﺑﻨﻘﺘﻄﲔ‬ ‫ﻟﺬا ﺗﺼﻨﻴﻔﻨﺎ ‪ MAFoo‬ﺑﺤﺎﺟﺔ ﻟﺘﻌﺮﻳﻒ إﺟﺮاﺋﲔ ﻳﻄﻠﻖ ﻋﻠﻴﻬﻤﺎ‬
‫ﻋﻤﻮدﻳﺘﲔ)”‪ .(“:‬اﳌﺰﻳﺪ ﻣﻦ اﳌﻌﻠﻮﻣﺎت ﻻﺣﻘ َﺎ‪.‬‬ ‫‪ actions‬ﺣﻴﺚ ﺳﻴﺘﻢ اﺳﺘﺪﻋﺎﺋﻬﻤﺎ ﻣﻦ ﺧﻼل ﻛﺎﺋﻨﻲ اﻻزرارﻳﻦ‪.‬‬
‫وﺗﺼﻨﻴﻔﻨﺎ ‪ MAFoo‬ﺑﺤﺎﺟﺔ ﻟﺘﻌﺮﻳﻒ ﻣﻨﻔﺬ ﺧﺮج واﺣﺪ )‪،(outlet‬‬
‫وﻣﻨﻔﺬ اﳋﺮج ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﻴﺮ ﻳﺤﺘﻔﻆ ﺑﻌﻨﻮان اﻟﻜﺎﺋﻦ اﻟﺬي ﺳﻴﺘﻢ‬
‫اﻟﺘﻮاﺻﻞ ﻣﻌﻪ )ﻓﻲ ﺣﺎﻟﺘﻨﺎ ﻫﺬﻩ ﺣﻘﻞ اﻟﻨﺺ ﻫﻮ ذﻟﻚ اﻟﻜﺎﺋﻦ( وذﻟﻚ‬
‫‪٦١‬‬
‫إﺿﺎﻓﺔ ﻣﺨﺮﺟﺎت ‪ outlet‬ﻟﻠﺘﺼﻨﻴﻒ ‪MAFoo‬‬ ‫إﺿﺎﻓﺔ اﻻﺟﺮءات ‪ action methods‬ﻟﻠﺘﺼﻨﻴﻒ ‪MAFoo‬‬
‫ﻗﺒﻞ اﻟﺒﺪء ﺑﻌﻤﻞ اﻟﺘﻮﺻﻴﻼت اﻟﻼزﻣﺔ ﺑﲔ اﻟﻜﺎﺋﻨﺎت‪ ،‬ﻳﺠﺪر ﺑﻨﺎ‬ ‫‪Outlet‬‬ ‫اﻻن واﻧﺖ ﺑﻨﺎﻓﺬة ﺗﺪﻗﻴﻖ اﳋﺼﺎﺋﺺ‪ ،‬اﺧﺘﺮ ﻟﻮﻳﺤﺔ اﳋﺮج‬
‫اﻋﻄﺎء اﻻزرارﻳﻦ اﺳﻤﺎء ذات دﻻﻟﺔ‪.‬وﲟﺎ ان اﻻزرار اﻻول ﺳﻴﻘﻮم‬ ‫‪ ،tab‬وﻗﻢ ﺑﺈﺿﺎﻓﺔ ﻣﺨﺮج ‪ outlet‬واﻃﻠﻖ ﻋﻠﻴﻪ اﺳﻢ ”‪“textField‬‬
‫ﺑﺎﻟﻄﻠﺐ ﻣﻦ ﻣﺴﺘﻨﺴﺦ ‪ MAFoo‬ان ﻳﻌﺮض اﻟﻌﺪد ‪ ٥‬ﺑﺤﻘﻞ اﻟﻨﺺ‪،‬‬ ‫ﻼ‪.‬‬‫ﻣﺜ َ‬
‫ﻟﺬا ﺳﻨﻘﻮم ﺑﺘﺴﻤﻴﺔ اﻻزرار ”‪- “Set to 5‬ﻧﺤﻦ ﻧﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻋﻤﻞ‬
‫ذﻟﻚ ﻣﻦ ﺧﻼل اﻟﻀﻐﻂ اﳌﺘﺘﺎﻟﻲ ﻋﻠﻰ اﻻزرار ﺛﻢ ﺗﻐﻴﻴﺮ اﻟﻨﺺ اﻟﻰ‬
‫اﻻﺳﻢ اﳉﺪﻳﺪ‪ .-‬ﻛﺮر اﻻﻣﺮ ذاﺗﻪ ﻣﻊ اﻻزرار اﻟﺜﺎﻧﻲ‪ ،‬ﺣﻴﺚ ﺳﻨﻄﻠﻖ‬
‫ﻋﻠﻴﻪ اﺳﻢ ”‪. “Reset‬‬
‫‪٦٢‬‬
‫ﻻﺣﻆ ان ﻋﻤﻠﻴﺔ ﺗﻐﻴﻴﺮ ﻣﺴﻤﻴﺎت اﻟﻌﻨﺎوﻳﻦ اﻟﺘﻲ اﺟﺮﻳﻨﺎﻫﺎ ﺗﻌﺪ‬

‫ﻋﻤﻠﻴﺔ ﻏﻴﺮ اﺳﺎﺳﻴﺔ ﻟﻌﻤﻞ ﺑﺮﻧﺎﻣﺠﻨﺎ‪ .‬اﻧﻬﺎ ﻣﺴﺄﻟﺔ ﺗﺘﻌﻠﻖ ﺑﺘﻌﺪﻳﻞ‬
‫اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﻟﻠﻜﺎﺋﻨﺎت ﺣﺘﻰ ﺗﻜﻮن ذات دﻻﻟﺔ وﺻﻔﻴﺔ اﻛﺒﺮ‬
‫ﻟﻠﻤﺴﺘﺨﺪم‪.‬‬
‫ﻧﺤﻦ اﻻن ﺟﺎﻫﺰون ﳌﺪ ﺟﺴﺮ اﻟﺘﻮاﺻﻞ ﺑﲔ اﻟﻜﺎﺋﻨﺎت ﺣﻴﺚ ﺳﻨﻌﻤﻞ‬
‫اﻟﺘﻮﺻﻴﻼت اﻟﻼزﻣﺔ ﺑﲔ ﻛﻞ ﻣﻦ‪:‬‬
‫‪MAFoo‬‬ ‫‪ (١‬ﺗﻮﺻﻴﻞ اﻻزرار”‪ “Reset‬ﲟﺴﺘﻨﺴﺦ‬
‫‪MAFoo‬‬ ‫‪(٢‬ﺗﻮﺻﻴﻞ اﻻزرار ”‪ “Set to 5‬ﲟﺴﺘﻨﺴﺦ‬
‫‪ (٣‬ﺗﻮﺻﻴﻞ اﳌﺴﺘﻨﺴﺦ ‪ MAFoo‬ﺑﺤﻘﻞ اﻟﻨﺺ‬
‫ﻟﻌﻤﻞﻫﺬﻩاﻟﺘﻮﺻﻴﻼت‪،‬اﺿﻐﻂﻟﻮﻳﺤﺔاﳌﺴﺘﻨﺴﺨﺎت ‪Instances tab‬‬
‫ﺗﻮﺻﻴﻞ اﻻزرار ﺑﻜﺎﺋﻦ ‪MAFoo‬‬
‫ﺑﻨﺎﻓﺬة ‪ .MainFile.nib‬ﺛﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ﻣﻔﺘﺎح ‪ Control‬اﳌﻮﺟﻮد‬
‫ﻋﻨﺪﻣﺎ ﻗﻤﺖ ﺑﺎﻓﻼت اﻟﻀﻐﻂ ﻋﻦ اﻟﻔﺄرة‪ ،‬ﻗﺎم ﻣﺤﻘﻖ ﺧﺼﺎﺋﺺ اﻻزرار‬ ‫ﺑﻠﻮﺣﺔ اﳌﻔﺎﺗﻴﺢ اﺳﺘﺨﺪم اﻟﻔﺄرة ﻟﻌﻤﻞ ﺳﺤﺐ واﻓﻼت ﻣﻨﻄﻠﻘ َﺎ ﻣﻦ‬
‫ﺑﻌﺮض اﻟﺘﻮﺻﻴﻼت ﻓﻲ ﻗﺎﺋﻤﺔ ﺗﻌﺮض اﻻﺟﺮاءات ‪action methods‬‬ ‫ازرار ‪ Reset‬اﻟﻰ ﻣﺴﺘﻨﺴﺦ ‪) MAFoo‬واﻧﺘﺒﻪ ﻟﻸ ﺗﻘﻢ ﺑﻌﻜﺲ ﻫﺬﻩ‬
‫اﻟﺘﻲ ﲤﺜﻞ ﻣﺎ ﻳﻘﺪﻣﺔ اﻟﻜﺎﺋﻦ ‪. MAFoo‬‬ ‫اﻟﺘﻮﺻﻴﻠﺔ اي ان ﺗﻨﻄﻠﻖ ﻣﻦ اﳌﺴﺘﻨﺴﺦ وﺗﻨﺘﻬﻲ ﺑﺎﻻزرار!(‪ .‬ﻋﻨﺪﻫﺎ‬
‫ﻗﻢ ﺑﺎﺧﺘﻴﺎر اﻻﺟﺮاءد اﳌﻨﺎﺳﺐ )اﻋﻨﻲ ”‪ ( “reset:‬واﺿﻐﻂ ﻋﻠﻰ اﻟﺰر‬ ‫ﺳﻴﻈﻬﺮ ﺧﻂ ﺑﲔ ﻧﻘﻄﺔ اﻻﻧﻄﻼق وﻣﻜﻌﺐ ﺻﻐﻴﺮ ﻋﻨﺪ اﻻﻧﺘﻬﺎء‪،‬‬
‫‪ Connect‬ﻻﲤﺎم اﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﺘﻮﺻﻴﻞ‪.‬‬ ‫ﻫﺬا اﳋﻂ ﳝﺜﻞ اﻟﺘﻮﺻﻴﻠﺔ اﻟﺘﻲ ﻗﻤﺖ ﺑﻌﻤﻠﻬﺎ‪ .‬اﺟﻌﻞ اﳋﻂ ﻣﻨﻄﻠﻘ َﺎ‬
‫ﻣﻦ اﻻزرار ودﻋﻪ ﻳﻨﺘﻬﻲ ﻋﻨﺪ ﻣﺴﺘﻨﺴﺦ ‪ MAFoo‬وﻋﻨﺪﻫﺎ اﻓﻠﺖ‬
‫ﺿﻐﻄﻚ ﻣﻦ اﻟﻔﺄرة ‪.‬‬
‫‪٦٣‬‬
‫اﻻن ﺳﺘﺮى ان اﻻزرار ﻳﺤﺘﻔﻆ ﺑﻌﻨﺎوﻳﻦ ﻣﺮﺟﻌﻴﺔ ﻣﻮﺟﻬﺔ اﻟﻰ اﻟﻜﺎﺋﻦ‬

‫‪ MAFoo،‬ﻫﺬا اﻻزرار ﺳﻴﻘﻮم ﺑﺘﻮﺟﻴﺔ رﺳﺎﻟﺔ اﻟﻰ ذﻟﻚ اﻟﻜﺎﺋﻦ‬
‫‪ MAFoo‬ﻛﻠﻤﺎ ﰎ ﺿﻐﻄﻪ‪ .‬ﳝﻜﻨﻚ اﻻن اﺟﺮاء اﻟﺘﻮﺻﻴﻼت اﻟﺘﻲ‬
‫ﺗﺮﺑﻂ اﻻزرار ‪ Set to 5‬ﺑﺎﻟﻜﺎﺋﻦ ‪ MAFoo‬ﻣﻦ اﺧﻼل اﻋﺎدة ﻧﻔﺲ‬
‫اﻻﺟﺮاء اﻟﺴﺎﺑﻖ‪.‬‬
‫وﻟﻌﻤﻞ ﺗﻮﺻﻴﻼت ﻣﺎﺑﲔ اﻟﻜﺎﺋﻦ ‪ MAFoo‬وﺣﻘﻞ اﻟﻨﺺ‪ ،‬اﺑﺪاء َ‬
‫اوﻻ‬
‫ﺑﺎﻟﻜﺎﺋﻦ ‪ MAFoo‬ﺛﻢ اﺿﻐﻂ ﻣﻔﺘﺎح ‪ control‬وﻗﻢ ﺑﻌﻤﻠﻴﺔ ﺳﺤﺐ‬
‫ﻣﻨﻄﻠﻘ َﺎ إﻟﻰ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪ ،‬اﺿﻐﻂ اﻻزرار ‪ Connect‬وﺑﺬﻟﻚ‬
‫ﺗﻜﻮن اﻧﺘﻬﻴﺖ ﻣﻦ ﻋﻤﻠﻴﺔ اﻟﺘﻮﺻﻴﻞ‪.‬‬
‫ﺗﺮى ﻣﺎ ﻛﻞ ﻫﺬا؟ وﳌﺎذا؟‬
‫ﻓﻲ اﳊﻘﻴﻘﺔ وﻛﻤﺎ ﺳﺘﺮى ﺑﻌﺪ ﻗﻠﻴﻞ‪ ،‬اﻧﻚ ﻗﺪ ﻗﻤﺖ ﺑﺎﻋﻤﺎل ﺟﻨﺒﺘﻚ‬
‫ﻋﻦ ﻛﺘﺎﺑﺔ أي ﺳﻄﺮ ﺑﺮﻣﺠﻲ‪ ،‬ﻓﻤﺎ ﻗﻤﺖ ﺑﻪ ﻗﺒﻞ ﻗﻠﻴﻞ ﳝﻜﻨﻚ ﻋﻤﻠﻪ‬
‫ﻣﻦ ﺧﻼل ﻋﺪد ﻻﺑﺄس ﺑﻪ ﻣﻦ اﺳﻄﺮ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬
‫ﺗﺄﻛﺪ ﻣﻦ ان ﻣﺴﺘﻨﺴﺦ ‪ MAFoo‬ﻗﻴﺪ اﻻﺧﺘﻴﺎر ﺑﻨﺎﻓﺬة ‪MainMenu.‬‬
‫‪ nib‬ﺛﻢ ﻗﻢ ﺑﺘﺤﻮﻳﻞ ﻋﺮض اﻟﺒﻴﺎﻧﺎت ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ ﻟﻮﻳﺤﺔ اﻟﺘﺼﻨﻴﻔﺎت‬
‫‪ .Classes tab‬وﻳﻔﺘﺮض اﻧﻚ ﺗﺮى اﻻن ﻻﺋﺤﺔ ﺑﻜﺎﻓﺔ اﻟﺘﺼﻨﻴﻔﺎت‬
‫وﺳﺘﺮى ان ﺗﺼﻨﻴﻔﻨﺎ ‪ MAFoo‬ﻗﻴﺪ اﻻﺧﺘﻴﺎر ﺣﺎﻟﻴ َﺎ‪.‬‬
‫اﳌﻮﺟﻮدة ﺑﺎﻟﻘﺎﺋﻤﺔ اﻟﻌﻠﻴﺎ‪ ،‬ﻣﻦ ﺛﻢ ﻓ ّﻌﻞ‬ ‫‪Classes menu‬‬ ‫اﺧﺘﺮ ﻗﺎﺋﻤﺔ‬ ‫ﻧﻔﻌﻴﻞ اﻟﺘﻮﺻﻴﻼت ﻣﻦ ﺧﻼل اﶈﻘﻖ ‪.inspector‬‬
‫‪٦٤‬‬
‫اﻣﺮ إﻧﺸﺎء ﻣﻠﻔﺎت اﻟﺘﺼﻨﻴﻒ ‪ .Create Files for MAFoo‬ﻋﻨﺪﻫﺎ‬

‫ﺳﻴﺴﺄﻟﻚ ‪ IB‬ﻋﻦ اﳌﻮﻗﻊ اﻟﺬي ﺳﺘﺮﻏﺐ ﺑﺤﻔﻆ ﻣﻠﻔﺎﺗﻚ ﻗﻴﺪ اﻻﻧﺸﺎء‪.‬‬
‫اﻓﺘﺮاﺿﻴ َﺎ ﻫﺬﻩ اﳌﻠﻔﺎت ﺳﻮف ﺗﻨﺸﺄ داﺧﻞ ﻣﺠﻠﺪ اﳌﺸﺮوع‪ ،‬وﻫﺬا‬
‫اﻟﻌﻨﻮان ﻫﻮ ﺑﺎﻟﻀﺒﻂ ﻣﺎ ﻧﺮﻳﺪﻩ‪.‬‬
‫اﺳﺘﻌﺮاض اﳌﻠﻔﺎت اﳌﻨﺸﺎءة داﺧﻞ ‪.Xcode‬‬
‫ﻼ‪ ،‬ﺣﻴﺚ اﻟﻔﺼﻞ ‪ ،٤‬ﻋﻨﺪﻣﺎ ﻧﺎﻗﺸﻨﺎ وﻇﻴﻔﺔ‬ ‫دﻋﻨﺎ ﻧﻌﻮد ﻟﻠﻮراء ﻗﻠﻴ َ‬
‫اﻟﺪاﻻت‪ .‬ﻫﻞ ﺗﺘﺬﻛﺮ ﻧﻘﺎﺷﻨﺎ ﺣﻮل ﺗﺮوﻳﺴﺔ اﻟﺪاﻟﺔ ‪function‬‬
‫إﻧﺸﺎء اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻟﻠﺘﺼﻨﻴﻒ ‪MAFoo‬‬
‫‪ header‬ﺑﺎﳌﺜﺎل ]‪[11.1‬؟ ﻟﻘﺪ ﻛﺎﻧﺖ ﲟﺜﺎﺑﺔ ﺗﺼﺮﻳﺢ اﺧﺒﺎري ﻟﻠﻤﺮﻛﻢ‪،‬‬
‫ﺗﺨﺒﺮة ﻋﻤﺎ ﻗﺪ ﻳﺼﺎدﻓﺔ ﻣﻦ اﻋﻼﻧﺎت وﺗﻌﺎرﻳﻒ ﻋﻦ اﻟﺪوال واﻧﻮاع‬ ‫اﻻن ﻗﻢ ﺑﺎﻟﻌﻮدة اﻟﻰ ﺑﺮﻧﺎﻣﺞ ‪ Xcode،‬وﺳﻮف ﺗﺮى ان اﳌﻠﻔﺎت اﻟﺘﻲ‬
‫أﻧﺸﺄﺗﻬﺎ ﻣﻮﺟﻮدة داﺧﻞ ﻧﺎﻓﺬة اﳌﺸﺮوع‪ ،‬ﲟﺠﻠﺪ اﳌﺼﺎدر اﻻﺧﺮى ‪Other‬‬
‫اﳌﻌﺎﻣﻼت‪.‬‬
‫‪ .Sources group‬ﺣﻴﺚ ﳝﻜﻨﻚ ﺳﺤﺐ ﻫﺬﻩ اﳌﻠﻔﺎت وادراﺟﻬﺎ‬
‫إن اﺣﺪ ﻣﻠﻔﺎﺗﻨﺎ اﳌﻨﺸﺎءة ﻣﺆﺧﺮاَ ﻳﺤﻤﻞ اﻻﺳﻢ ‪ MAFoo.h‬وﺗﺮوﻳﺴﺔ‬ ‫ﲟﺠﻠﺪ اﻟﺘﺼﻨﻴﻔﺎت ‪ Classes group‬ﻓﻲ ﺣﺎل اﻟﺮﻏﺒﺔ‪ ،‬ﻓﻜﻤﺎ ﺗﺮى ان‬
‫ﺗﻮﺻﻒ ﻫﺬا اﻟﺘﺼﻨﻴﻒ‪ .‬ﻓﻔﻲ‬ ‫ذﻟﻚ اﳌﻠﻒ ﲢﻮي اﳌﻌﻠﻮﻣﺎت اﻟﺘﻲ ّ‬ ‫ﻫﺬﻩ اﳌﻠﻔﺎت اﳊﺪﻳﺜﺔ اﻹﻧﺸﺎء ﲤﺜﻞ ﺗﻮﺻﻴﻒ اﻟﺘﺼﻨﻴﻒ ‪.MAFoo‬‬
‫‪٦٥‬‬
‫ﺑﺎرﺳﺎل اﻟﺮﺳﺎﻟﺔ‪ :‬ﻓﻘﻂ و اﻟﺘﻲ ﻻ ﺗﺘﻄﻠﺐ اي رد ﻳﻠﻴﻬﺎ ﻋﻨﺪ ارﺳﺎﻟﻬﺎ‬ ‫اﻟﺴﻄﺮ ]‪ [3.5‬ﲡﺪ ﻛﻠﻤﺔ ‪ NSObject‬اﳌﺄﻟﻮﻓﺔ ﻟﺪﻳﻚ‪ ،‬واﻟﺘﻲ ﺗﺨﺒﺮﻧﺎ‬
‫اﻟﻰ اﻟﻜﺎﺋﻦ ‪. MAFoo‬‬ ‫اﳌﺠﻤﻊ ان ﻫﺬا اﻟﺘﺼﻨﻴﻒ ﻳﺴﺘﻘﻲ‪/‬ﻳﺮث ﺻﻔﺎﺗﻪ ﻣﻦ اﻟﺘﺼﻨﻴﻒ‬‫وﺗﺨﺒﺮ ّ‬
‫ﺳﺘﺮى اﻳﻀ َﺎ ﻋﺪد اﺛﻨﲔ ﻣﻦ اﻻﺟﺮاءات اﻟﺘﻲ ﻳﺴﺘﺨﺪﻣﻬﺎ ‪.IB‬‬ ‫اﻻب ‪.NSObject class‬‬
‫]‪[3‬‬
‫‪#import <Foundation/Foundation.‬‬ ‫ﻟﻘﺪ رأﻳﻨﺎ ﺳﺎﺑﻘ َﺎ ﻣﻔﺮدة‬ ‫‪/* MAFoo */‬‬
‫ﺑﺪﻻ ﻣﻦ اﻟﺴﻄﺮ]‪ . [3.3‬ﻓﺎﳌﻔﺮدة اﻻوﻟﻰ ﺗﺴﺘﺨﺪم ﻣﺎ ﻳﻠﺰم ﻣﻦ‬ ‫>‪َ h‬‬
‫>‪#import <Cocoa/Cocoa.h‬‬ ‫]‪// [3.3‬‬
‫دوال ووﻇﺎﺋﻒ ﻟﻠﺒﺮاﻣﺞ اﻟﺘﻲ ﻻ ﺗﻌﺘﻤﺪ إﺳﺘﺨﺪام إﻣﻜﺎﻧﻴﺎت ووﻇﺎﺋﻒ‬
‫واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ او ‪ ،GUI‬ﺑﻴﻨﻤﺎ ﻣﺎ ﺗﺮاﻩ اﻻن ﺑﺎﻟﺸﻔﺮة‬ ‫‪@interface MAFoo : NSObject‬‬
‫{‬
‫اﻟﺒﺮﻣﺠﻴﺔ ﻳﺴﺘﻨﻔﺬﻫﺎ اﺳﺘﻨﻔﺎذاَ ‪.‬‬ ‫]‪IBOutlet id textField; // [3.7‬‬
‫}‬
‫دﻋﻨﺎ اﻻن ﻧﺘﻔﺤﺺ اﳌﻠﻒ اﳌ ُﻨﺸﺎء اﻟﺜﺎﻧﻲ‪ .‬اﻧﻪ اﳌﻠﻒ اﳌﺴﻤﻰ ‪MAFoo.‬‬ ‫;‪- (IBAction)reset:(id)sender‬‬
‫‪ . m‬وﻣﺮة اﺧﺮى ﺣﺼﻠﻨﺎ ﻋﻠﻰ ﺳﻄﻮر وﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ ﻣﺠﺎﻧ َﺎ دون اي‬ ‫;‪- (IBAction)setTo5:(id)sender‬‬
‫‪@end‬‬
‫ﺗﺪﺧﻞ أو ﻋﻨﺎء ﻣﻦ ﻗﺒﻠﻨﺎ‪.‬‬
‫]‪[4‬‬ ‫ﺳﺘﺮى اﻳﻀ َﺎ ]‪ [3.7‬وﺟﻮد ﻣﻨﻔﺬ ﺧﺮج ‪ outlet‬ﻳﺴﺘﺨﺪم ﺣﻘﻞ اﻟﻨﺺ‬
‫”‪#import “MAFoo.h‬‬ ‫ﻛﻤﻌﺎﻣﻞ ‪-‬اﳉﺪﻳﺪ ﻫﻨﺎ ﻫﻮ”‪ “id‬وﻫﻲ ﺗﻌﻨﻲ ﻛﺎﺋﻦ‪ ،‬أو ﻓﻲ اﳊﻘﻴﻘﺔ‬
‫‪@implementation MAFoo‬‬ ‫ﻫﻲ ﻣﺆﺷﺮ ﻟﻠﻜﺎﺋﻦ ﺣﻴﺚ ﺗﻨﻮب ﻋﻨﻪ ﻫﻨﺎ ‪.-‬‬
‫]‪- (IBAction)reset:(id)sender // [4.5‬‬ ‫‪ ،‬ذﻟﻚ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي‬ ‫‪Interface Builder‬‬‫ان ”‪ “IB‬ﺗﺸﻴﺮ اﻟﻰ‬
‫{‬ ‫اﺳﺘﺨﺪﻣﻨﺎﻩ ﻹﻧﺸﺎء ﻫﺬﻩ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬
‫}‬
‫ﺳﺘﺠﺪ اﻳﻀ َﺎ ﻛﻠﻤﺎت ‪ IBAction‬ﻓﻲ ]‪ [3.9, 3.10‬وﻫﻲ ﳑﺎﺛﻠﺔ‬
‫‪// ...Continued‬‬
‫ﻟﻠﺪاﻻت اﻟﺘﻲ ﻻﺗﻘﻮم ﺑﺈرﺟﻊ اي ﻗﻴﻤﺔ ‪ .void‬ودورﻫﺎ ﻫﻨﺎ ﻳﺘﻤﺜﻞ‬
‫‪٦٦‬‬
‫]‪[5‬‬
‫”‪#import “MAFoo.h‬‬ ‫‪- (IBAction)setTo5:(id)sender‬‬
‫{‬
‫‪@implementation MAFoo‬‬ ‫}‬
‫‪@end‬‬
‫‪- (IBAction)reset:(id)sender‬‬
‫{‬ ‫ﻗﺒﻞ اى ﺷﻲء‪ ،‬ﺳﻮف ﻳﺘﻢ ﺟﻠﺐ ﺗﺼﺮﻳﺤﺎت ﺗﺮوﻳﺴﺔ اﳌﻠﻒ ‪MAFoo.‬‬
‫}‬
‫]‪[textField setIntValue:0]; // [5.7‬‬ ‫اﳌﺠﻤﻊ ﻓﺮﺻﺘﺔ ﻓﻲ اﻟﺘﻌﺮف ﻋﻤﺎ ﺳﻴﻮاﺟﻬﻪ‪.‬‬
‫‪ h‬و ذﻟﻚ ﺣﺘﻰ ﻳﺄﺧﺬ ّ‬
‫ﻳﻮﺟﺪ ﻣﻔﺮدﺗﺎن ﻣﺄﻟﻮﻓﺘﺎن ﻟﻨﺎ ﻫﻨﺎ اﻧﻬﺎ ‪ reset:‬و ‪ . setTo5:‬ﻫﺬﻩ اﻻواﻣﺮ‬
‫‪- (IBAction)setTo5:(id)sender‬‬ ‫ﻫﻲ ﻧﻔﺴﻬﺎ اﻻﺟﺮاءات ‪ methods‬اﻟﺘﻲ ﺣﺪدﻧﺎﻫﺎ ﻟﻠﺘﺼﻨﻴﻒ‪.‬‬
‫{‬
‫]‪[textField setIntValue:5]; // [5.12‬‬ ‫اﻧﻬﺎ ﺷﺪﻳﺪة اﻟﺸﺒﻪ ﺑﺎﻟﺪاﻻت ذﻟﻚ اﻧﻬﺎ ﺗﺘﻄﻠﺐ وﺿﻊ اﻻواﻣﺮ ﻣﺤﺼﻮرة‬
‫}‬ ‫ﺑﲔ اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ‪ .‬ﻓﻔﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﻣﺘﻰ ﻣﺎ ﰎ ﺿﻐﻂ اﺣﺪ اﻻزرار‪،‬‬
‫ﺳﻴﻘﻮم اﻻزرار اﳌﻀﻐﻮط ﺑﺎرﺳﺎل رﺳﺎﻟﺔ اﻟﻰ اﻟﻜﺎﺋﻦ ‪ ،MAFoo‬ﺗﻄﻠﺐ‬
‫‪@end‬‬ ‫ﻣﻦ ﺗﻨﻔﻴﺪ اﺣﺪ ﺗﻠﻚ اﻻﻓﻌﺎل ‪ .methods‬اﳉﻤﻴﻞ ﻓﻲ اﳌﻮﺿﻮع اﻧﻨﺎ‬
‫ﻛﻤﺎ ﺗﺮى ﻧﺤﻦ ﻧﺮﺳﻞ اﻟﺮﺳﺎﻟﺔ اﻟﻰ ذﻟﻚ اﻟﻜﺎﺋﻦ اﳌﺨﺰن ﲟﻨﻔﺬ اﳋﺮج‬ ‫ﻏﻴﺮ ﻣﻠﺰﻣﲔ ﺑﻜﺘﺎﺑﺔ اي ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ ﻟﺘﺤﻘﻴﻖ ذﻟﻚ‪.‬‬
‫‪ outlet‬اﳋﺎص ﺑﺤﻘﻞ اﻟﻨﺺ ‪ .textField‬وﲟﺎ اﻧﻨﺎ ﻗﺪ ﻗﻤﻨﺎ ﺑﺎﻋﺪاد‬ ‫ان ﻣﺎ ﻗﻤﻨﺎ ﺑﻪ ﻣﻦ اﻋﻤﺎل ﺗﻮﺻﻴﻞ ﺑﲔ اﻻزرار واﻟﻜﺎﺋﻦ ‪ MAFoo‬ﻣﻦ‬
‫اﻟﺘﻮﺻﻴﻞ ﻣﺎﺑﲔ ﻣﻨﻔﺬ اﳋﺮج وﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ﺑﺎﺳﺘﺨﺪام ﺑﺮﻧﺎﻣﺞ‬ ‫ﺧﻼل ‪ IB‬ﻛﺎن ﻫﻮ ﻛﻞ اﳌﻄﻠﻮب‪ ،‬وﻗﺪ ﺟﻨﺒﻨﺎ ذﻟﻚ ﻛﺘﺎﺑﺔ ﻫﺬﻩ اﻟﺴﻄﻮر‬
‫‪ ،IB‬ﻟﺬا ﺳﻴﺘﻢ ﺗﻮﺟﻴﻪ اﻟﺮﺳﺎﻟﺔ اﻟﻰ وﺟﻬﺘﻬﺎ اﻟﺼﺤﻴﺤﺔ‪.‬‬ ‫اﻟﺘﻲ ﺗﺮاﻫﺎ اﻻن‪ .‬ﻋﻠﻰ ﻛﻞ ﺣﺎل ﻋﻠﻴﻨﺎ ﻛﺘﺎﺑﺔ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ‬
‫ان اﺳﻢ اﻻﺟﺮاء ‪ method‬اﳌﺴﺘﺨﺪم ﻟﻌﻤﻠﻴﺔ ارﺳﺎل اﻟﺮﺳﺎﻟﺔ ﻫﻮ‬ ‫ﺳﺘﺠﻌﻞ اﻟﻜﺎﺋﻦ ‪ MAFoo‬ﻳﺮﺳﻞ رﺳﺎﻟﺘﻪ إﻟﻰ ﺣﻘﻞ اﻟﻨﺺ ﻟﻴﻘﻮم اﻻﺧﻴﺮ‬
‫‪ setIntValue:‬وﻫﻮ ﻳﺘﻄﻠﺐ ﻣﻌﺎﻣﻞ ﻋﺪدي ﺻﺤﻴﺢ ‪ .Integer‬ﻛﻤﺎ‬ ‫ﻳﺘﻐﻴﻴﺮ اﻟﻘﻴﻤﺔ اﳌﻌﺮوﺿﺔ ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ ﺑﺎﻻﺳﻄﺮ ]‪.[5.7, 5.12‬‬
‫‪٦٧‬‬
‫ان إﺟﺮاء ‪ setIntValue:‬ﻗﺎدر ﻋﻠﻰ اﻇﻬﺎر اﻟﻘﻴﻤﺔ اﳌﺮﻓﻘﺔ ﻣﻌﻪ ﻓﻲ ﻛﺎﺋﻦ‬

‫ﺣﻘﻞ اﻟﻨﺺ‪.‬‬
‫ﻓﻲ اﻟﻔﺼﻞ اﻟﺘﺎﻟﻲ ﺳﻮف ﻧﺨﺒﺮك ﻛﻴﻔﻴﺔ اﻛﺘﺸﺎﻓﻨﺎ ﻟﻬﺬا اﻻﻳﻌﺎز‪ .‬اﻧﺖ‬
‫اﻻن ﺟﺎﻫﺰ ﻟﺘﺠﻤﻴﻊ ّﲡﻤﻴﻊ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺸﻐﻴﻠﻪ‪ .‬وﻛﻤﺎ ﻫﻮ ﻣﻌﺘﺎد ﻗﻢ‬
‫ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻻزرار ‪ Build‬اﳌﻮﺟﻮد ﺑﺸﺮﻳﻂ اﻻدوات‪ ،‬ﺳﻴﺘﻄﻠﺐ‬
‫اﻻﻣﺮ ﻋﺪة ﺛﻮان ﻟﺒﻨﺎء وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ .‬ﻓﻲ اﻟﻨﻬﺎﻳﺔ ﺳﻴﻨﻄﻠﻖ اﻟﺒﺮﻧﺎﻣﺞ‬
‫وﺗﻈﻬﺮ ﻧﺎﻓﺬﺗﻪ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﲡﺮﺑﺘﺔ واﺧﺘﺒﺎرﻩ‪.‬‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ‪.‬‬
‫ﺑﺎﺧﺘﺼﺎر ﻟﻘﺪ ﻗﻤﺖ ﺑﺈﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﺑﺪاﺋﻲ ﺑﺴﻴﻂ‪ ،‬وﻗﺪ ﺗﺘﻄﻠﺐ‬

‫ﻣﻨﻚ ﻛﺘﺎﺑﺔ ﺳﻄﺮﻳﻦ ﻣﻦ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ!‬
‫‪٦٨‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﺑﺤﺚ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﺔ‬
‫ﺑﺤﺚ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﺔ‬

‫ﻓﻲ اﻟﻔﺼﻞ اﻟﺴﺎﺑﻖ ﺗﻌﺮﺿﻨﺎ ﻟﺒﻌﺾ اﻻﺟﺮاءات ‪ ،‬وﻗﺪ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺔ‬
‫اﺛﻨﺎن ﻣﻨﻬﻤﺎ ﺑﺎﻧﻔﺴﻨﺎ ) ُﺑﻨﻴﺔ اﻻﺟﺮاء(‪ ،‬ﻟﻜﻨﻨﺎ ﻗﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام اﺟﺮاء‬
‫واﺣﺪ ﺟﺎﻫﺰ ﻣﻦ ﻗﺒﻞ أﭘﻞ ‪ .‬ﻓﺎﻻﺟﺮاء ‪ setIntValue:‬ﻛﺎن ذﻟﻚ اﻻﻣﺮ‬
‫اﳌﻮﻛﻞ ﺑﻌﺮض اﻟﻘﻴﻤﺔ اﻟﺮﻗﻤﻴﺔ ﲟﺤﺘﻮى ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪ .‬ﺗﺮى ﻛﻴﻒ‬
‫ﲤﻜﻨﺎ ﻣﻦ ﻣﻌﺮﻓﺔ ذﻟﻚ؟‬
‫ﻫﻞ ﺗﺬﻛﺮ ان اي اﺟﺮاء ﻣﻘﺪم اﻟﻴﻚ ﻣﻦ ﻗﺒﻞ أﭘﻞ ﻻ ﻳﺘﻄﻠﺐ ﻣﻨﻚ‬
‫ﻛﺘﺎﺑﺔ اي ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ‪ .‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ ذﻟﻚ ﻫﺬﻩ اﻻﺟﺮاءات‬
‫ﺗﻀﻤﻦ ﻟﻚ ﺧﻠﻮﻫﺎ ﻣﻦ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ‪ .‬ﻟﺬا ﺗﻘﻀﻲ اﳊﻜﻤﺔ‬
‫ان ﺗﺴﺘﺜﻤﺮ ﺑﻌﻀ َﺎ ﻣﻦ اﻟﻮﻗﺖ ﻟﻠﺘﻘﺼﻲ واﻟﺒﺤﺚ ﻋﻦ ﺗﻠﻚ‬
‫اﻻﺟﺮاءات اﳌﺘﻮﻓﺮة ﻟﻚ ﻗﺒﻞ ان ﺗﻘﻮم ﺑﻜﺘﺎﺑﺔ اي ﺳﻄﺮ ﺑﺮﻣﺠﻲ‪.‬‬
‫اذا ﻣﺎ ﻗﻤﺖ ﺑﺎﺧﺘﻴﺎر اﺣﺪ اﻟﻜﺎﺋﻨﺎت اﻟﺘﻲ ﻳﻌﺮﺿﻬﺎ ﻟﻚ ﺑﺮﻧﺎﻣﺞ ‪ IB‬ﺳﺘﺠﺪ‬
‫ﺗﻮﺻﻴﻒ ﻣﻘﺘﻀﺐ ﻳﺸﻴﺮ ﻻﺳﻢ ذﻟﻚ اﻟﺘﺼﻨﻴﻒ اﻟﺬي ﻳﻘﻒ ﻋﻨﺪﻩ‬
‫اﳌﺆﺷﺮ‪ ،‬اﻧﻪ ﺗﻮﺻﻴﻒ ﻣﺨﺘﺼﺮ ﺟﺪاَ ﻣﺜﻞ ‪. NSButton‬واذا ﻣﺎ اوﻗﻔﺖ‬
‫ﻣﺆﺷﺮ اﻟﻔﺄرة ﻓﻮق ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ﻓﺎﻧﻚ ﺳﺘﻘﺮاء ‪ . NSTextField‬ان‬
‫ﻛﻞ اﺳﻢ ﻣﻦ ﺗﻠﻚ اﻻﺳﻤﺎء ﳝﺜﻞ اﺳﻢ ذﻟﻚ اﻟﺘﺼﻨﻴﻒ‪ ،‬دﻋﻨﺎ ﻧﺘﻔﺤﺺ‬
‫‪ NSTextField‬وﻣﺎ ﻳﻘﺪﻣﺔ اﻟﺘﺼﻨﻴﻒ ﻣﻦ اﺟﺮاءات ‪.methods‬‬
‫‪٦٩‬‬
‫ﺑﺤﺚ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﺛﻨﺎء ادﺧﺎﻻك ﻟﻠﻤﻔﺮدة‪ ،‬ﺳﺘﺠﺪ ان ﻗﺎﺋﻤﺔ ﻧﺘﻴﺠﺔ اﻟﺒﺤﺚ اﻟﺘﻲ ﲢﻮي‬ ‫اﻻﺳﺘﺪﻻل ﻋﻠﻰ اﻻﻳﻌﺎزات اﻻﺳﺘﻘﺼﺎء ﻋﻦ واﻻواﻣﺮ‬
‫اﺣﺘﻤﺎل وﺟﻮد ﺗﻠﻚ اﳌﻔﺮدة ﻗﺪ ﺑﺪأت ﺑﺎﻟﺘﻘﻠﺺ‪ ،‬ﻋﻨﺪﻫﺎ ﺳﺘﺠﺪ‬ ‫‪ ،‬ﺑﻨﺪ ﻗﺎﺋﻤﺔ‬ ‫‪menu‬‬ ‫ﺗﻮﺟﻪ اﻟﻰ ‪ Xcode‬وﺳﺘﺠﺪ ﺑﺎﻟﻘﺎﺋﻤﺔ اﻟﻌﻠﻴﺎ‬
‫ﺗﻠﻚ اﳌﻔﺮدة ‪ NSTextField‬ﻗﺪ ﻇﻬﺮت اﻋﻠﻰ اﻟﻘﺎﺋﻤﺔ‪ .‬واﺿﻐﻂ ﻋﻠﻰ‬ ‫اﳌﺴﺎﻋﺪة ﺑﺎﺳﻢ ‪، Help->Documentation‬‬
‫اﻟﺴﻄﺮ اﻟﺬي ﻳﺸﻬﺮ ﻣﻔﺮدة اﻟﺒﺤﺚ ‪) NSTextField‬وﻫﻲ ﻫﻨﺎ ﻣﻦ‬
‫اﺧﺘﺮ ‪ Cocoa‬ﻣﻦ اﻻﻃﺎر اﻻﻳﺴﺮ ﺛﻢ ادﺧﻞ ﻣﻔﺮدة ‪ NSTextField‬ﺑﺤﻘﻞ‬
‫ﻧﻮع ﺗﺼﻨﻴﻒ ‪ (Class‬ﺣﺘﻰ ﲢﺼﻞ ﻋﻠﻰ ﻣﻌﻠﻮﻣﺎت ذﻟﻚ اﻟﺘﺼﻨﻴﻒ‪.‬‬
‫اﻟﺒﺤﺚ ‪ ،‬ﺗﺄﻛﺪ ﻣﻦ اﺗﺎﺣﺔ ﺧﻴﺎر اﻟﺒﺤﺚ ان ﻳﺸﻤﻞ اﺟﺮاءات واﺟﻬﺔ‬
‫وﺳﻮف ﻳﻌﺮض اﻟﺘﺼﻨﻴﻒ ﻣﻌﻠﻮﻣﺎﺗﻪ ﺑﺎﻻﻃﺎر اﻟﺴﻔﻠﻲ‪.‬‬
‫اﻟﺘﻄﺒﻴﻘﺎت ‪) ،API-Search‬اﻧﻈﺮ ﻟﻠﺼﻮرة اﳌﺮﻓﻘﺔ ﺑﺎﻻﺳﻔﻞ(‪.‬‬
‫اول اﻣﺮ ﻧﻼﺣﻈﺔ ﻫﻨﺎ ﻫﻮ ان ﻫﺬا اﻟﺘﺼﻨﻴﻒ ﻣﻜﻮن ﺑﺎﻟﻮراﺛﺔ ﻣﻦ‬
‫ﺳﻠﺴﻠﺔ ﻣﺘﺼﻠﺔ ﻣﻦ اﻟﺘﺼﻨﻴﻔﺎت اﻻﺧﺮى‪ .‬اﺧﺮ ﺗﺼﻨﻴﻒ ﻓﻲ اﻟﻘﺎﺋﻤﺔ‬
‫ﻫﻮ اﻻب‪ ،‬أو اﻟﺘﺼﻨﻴﻒ اﳉﺬر‪ ،‬اﻧﻪ ﻣﻠﻚ اﻟﻬﺮم ‪! NSObject‬‬
‫اﻧﺰل ﻟﻼﺳﻔﻞ ﻗﻠﻴ َ‬
‫ﻼ )‪ (scroll‬وﺳﺘﺠﺪ ان اﻟﻌﻨﻮان اﻟﺮﺋﻴﺲ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪Method Types‬‬
‫إﺑﺪء ﺑﺤﺜﻚ ﻋﻦ اﻻﺟﺮاءات ﲢﺖ ﻫﺬا اﻟﻌﻨﻮان‪ .‬ان ﻧﻈﺮة ﺳﺮﻳﻌﺔ ﻋﻠﻰ‬

‫اﻟﻌﻨﺎوﻳﻦ اﻟﻔﺮﻋﻴﺔ ﺗﺪل ﻋﻠﻰ اﻧﻨﺎ ﻟﻦ ﳒﺪ ذﻟﻚ اﻻﺟﺮاء اﻟﺬي ﻧﺤﺘﺎﺟﺔ‬
‫ﻟﻌﺮض ﺗﻠﻚ اﻟﻘﻴﻤﺔ اﻟﻨﺼﻴﺔ داﺧﻞ ﻣﺤﺘﻮى ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪.‬‬
‫ﻳﻌﻮد ﺳﺒﺐ ذﻟﻚ ﳌﺒﺎدىء اﻟﺘﻮارث ﺑﲔ اﻟﻜﺎﺋﻨﺎت‪ ،‬ﻓﻨﺤﻦ ﺑﺤﺎﺟﺔ‬
‫ﻟﺘﻔﺤﺺ اﻟﺘﺼﻨﻴﻒ اﻻﻋﻠﻰ ﻓﻲ اﻟﺴﻼﻟﺔ ‪ superclass‬اﻟﺬي ﺗﻜﻮن ﻣﻨﻪ‬
‫ﺗﺼﻨﻴﻒ ‪ ، NSTextField‬وﻫﻮ ﺑﻄﺒﻴﻌﺔ اﳊﺎل ﺗﺼﻨﻴﻒ ‪NSControl‬‬
‫)وﻓﻲ ﺣﺎل ﻓﺸﻠﻨﺎ ﻓﻲ اﻟﻌﺜﻮر ﻋﻦ ﻣﺎ ﻧﺒﺤﺚ ﻋﻨﻪ ﺳﻨﺘﻮﺟﻪ اﻟﻰ‬ ‫اﻟﺘﺠﻮال ﺑﲔ وﺛﺎﺋﻖ ‪ Cocoa‬ﺑﺎﺳﺘﺨﺪام ‪.Xcode‬‬
‫‪٧٠‬‬
‫اﻹﺟﺮاء ‪ setIntValue:‬وﺻﻴﻐﺘﻪ‬ ‫اﻟﺘﺼﻨﻴﻒ اﻻﻋﻠﻰ ﻓﻲ اﻟﺴﻼﻟﺔ‪ ،‬اﻻ وﻫﻮ ‪ ، NSView‬وﻫﻜﺬا ﺣﺘﻰ‬

‫‪- (void)setIntValue:(int)anInt‬‬ ‫ﻧﺼﻞ اﻟﻰ اﳉﺬر اﻻب (‪.‬‬
‫اﻧﻪ إﺟﺮاء ﻳﻘﻮم ﺑﺈﺳﻨﺎد ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ‪ anInt‬داﺧﻞ ﺧﻠﻴﺔ )او ﺧﻠﻴﺔ‬ ‫ﲟﺎ ان وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة اﻟﺘﻮﺿﻴﺤﺔ ﻣﻜﺘﻮﺑﺔ ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ‪،HTML‬‬
‫ﻗﻴﺪ اﻻﺧﺘﻴﺎر(‪ .‬واذا ﻣﺎ ﻛﺎﻧﺖ اﳋﻠﻴﺔ ﻗﻴﺪ اﻟﺘﺤﺮﻳﺮ‪ ،‬ﻋﻨﺪﻫﺎ ﺳﻴﺘﻢ‬ ‫ﻓﻜﻞ ﻣﺎ ﻋﻠﻴﻨﺎ ﻋﻤﻠﻪ اﻻن ﻫﻮ اﻟﻀﻐﻂ ﻋﻠﻰ ﻛﻠﻤﺔ ‪NSControl‬‬
‫اﻳﻘﺎف ﻛﺎﻓﺔ اﻟﻌﻤﻠﻴﺎت ﻗﺒﻞ اﲤﺎم ﻋﻤﻠﻴﺔ اﻻﺳﻨﺎد‪ ،‬ذﻟﻚ؛ ﻓﻲ ﺣﺎل‬ ‫)اﻟﺴﻼﻟﺔ اﳌﺘﺤﺪرة ﻣﺮﺗﺒﺔ ﻛﻤﺎ ﻫﻮ ﻣﻮﺿﺢ(‪ .‬ﺗﻠﻚ اﻟﻀﻐﻄﺔ ﺗﻨﻘﻠﻨﺎ‬
‫ﻟﻢ ﺗﻜﻦ اﳋﻠﻴﺔ ﺳﻠﻴﻠﺔ ﻣﺘﺤﺪرة ﻣﻦ ﺳﻠﺴﻠﺔ اﻟﻮراﺛﺔ ﻟﻠﺘﺼﻨﻴﻒ‬ ‫اﻟﻰ اﻟﺼﻔﺤﺔ اﻟﺘﻲ ﲢﻮي ﺗﻮﺻﻴﻒ ‪.NSControl‬‬
‫‪.NSActionCell‬‬
‫ان ﻫﺬا اﻻﺟﺮاء ﻳﻘﻮم ﺑﺠﺪوﻟﺔ ﻋﻤﻠﻴﺔ ﲢﺪﻳﺚ ﻋﺮض ﻗﻴﻤﺔ ﻣﺤﺘﻮى‬
‫اﳋﻠﻴﺔ )ان اﻟﺘﺼﻨﻴﻒ ‪ NSActionCell‬ﻳﻘﻮم ﺑﺠﺪوﻟﺔ اﻋﻤﺎل‬
‫ﻛﻤﺎ ﺗﺮى ﻟﻘﺪ اﻧﺘﻘﻠﻨﺎ ﺧﻄﻮة ﻟﻸﻋﻠﻰ داﺧﻞ ﺳﻠﺴﻠﺔ اﻟﻮراﺛﺔ‪ .‬وﻓﻲ‬
‫اﻟﺘﺤﺪﻳﺚ اﳋﺎﺻﺔ ﺑﺎﳋﻼﻳﺎ اﻟﺘﻲ ﳝﺘﻠﻜﻬﺎ(‪.‬‬
‫اﻟﻌﻨﺎوﻳﻦ اﻟﻔﺮﻋﻴﺔ ﻟﻼﺟﺮاءات ﺳﻨﺠﺪ اﻟﺘﺒﻮﻳﺐ اﻟﺘﺎﻟﻲ‪:‬‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ ﳒﺪ ان ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ‪ NSTextField‬ﻫﻮ اﳌﺴﺘﻘﺒﻞ‬ ‫‪Setting the control’s value‬‬
‫ﻟﻠﺮﺳﺎﻟﺔ وﻫﻮ ﺑﺤﺎﺟﺔ ﻻدﺧﺎل ﻗﻴﻤﺔ ﻣﻦ ﻧﻮع ﻋﺪدي ﺻﺤﻴﺢ ﻓﻲ اﳌﻌﺎﻣﻞ‬
‫أو ﻣﺠﻤﻮﻋﺔ إﺳﻨﺎدات اﻟﻘﻴﻢ ﻟﻠﺘﺼﻨﻴﻒ‪ ،‬وﻫﺬﻩ اﻻﺟﺮاءات ﻫﻲ‬
‫اﳌﺴﺘﺨﺪم ﺑﺎﻻﺟﺮاء‪ .‬وﳝﻜﻨﻨﺎ ﺗﺒﲔ ذﻟﻚ ﺑﺪﻻﻟﺔ ﺗﻮﻗﻴﻊ اﻻﺟﺮاء‪:‬‬
‫ﻣﺎ ﻧﺒﺤﺚ ﻋﻨﻪ‪ ،‬اﻧﻨﺎ ﻧﺮﻏﺐ ﺑﺎﺳﻨﺎد ﻗﻴﻤﺔ‪ .‬ﻟﺬا اﺳﻔﻞ ذﻟﻚ اﻟﻌﻨﻮان‬
‫‪- (void)setIntValue:(int)anInt‬‬
‫اﻟﻔﺮﻋﻲ ﺳﻨﺠﺪ‪:‬‬
‫ﺗﺴﺘﺨﺪم ‪ Objective-C‬رﻣﺰ ﻋﻼﻣﺔ اﻟﻨﺎﻗﺺ ”‪ “-‬ﻓﻲ ﺑﺪاﻳﺔ اﻻﺟﺮاءات‬ ‫‪– setIntValue‬‬
‫اﳌﺼﺮﺣﺔ ﻛﺈﺟﺮاءات ﺗﺨﺺ اﻟﻜﺎﺋﻦ اﳌﺴﺴﺘﻨﺴﺦ )وﻫﻲ اﻟﺘﺼﺮﻳﺤﺎت‬
‫‪ :‬ﺣﺘﻰ اﻻن اﻻﻣﻮر واﺿﺤﺔ‪ ،‬ﻟﺬا ﺳﻨﺘﻔﺤﺺ وﺻﻒ ذﻟﻚ اﻻﺟﺮاء ﻣﻦ‬
‫اﳌﻘﺎﺑﻠﺔ ﺑﺘﺼﺮﻳﺤﺎت اﻟﺘﺼﻨﻴﻒ ذاﺗﻪ‪ ،‬وﺳﻨﻘﻮم ﺑﺘﻐﻄﻴﺔ ذﻟﻚ اﳌﻮﺿﻮع‬
‫ﺧﻼل اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺮاﺑﻂ اﶈﻴﻂ ﺑﻜﻠﻤﺔ ‪. setIntValue:‬‬
‫ﻻﺣﻘ َﺎ(‪.‬‬
‫‪٧١‬‬
‫ﺑﺎﻻﺳﺘﻌﻼم ﻋﻦ اﻟﻘﻴﻤﺔ‪ ،‬واﻻﺧﺮ ﻳﺨﺘﺺ ﺑﺎﺳﻨﺎد ﺗﻠﻚ اﻟﻘﻴﻤﺔ‪ .‬وﻟﻘﺪ‬ ‫ان ﻣﻔﺮدة ‪ void‬اﻟﺒﺎدﺋﺔ ﺑﻬﺬا اﻻﺟﺮاء ﺗﻌﻨﻲ ﻋﺪم وﺟﻮد ﻗﻴﻤﺔ ﻣﺮﲡﻌﺔ‪.‬‬
‫ﺗﻌﺎرﻓﻨﺎ ﻋﻠﻰ اﻻﺧﻴﺮ اﻟﺬي ﻳﻘﻮم ﺑﺎﻻﺳﻨﺎد ‪ setIntValue:‬ﻋﻠﻰ ﻛﻞ‬ ‫ﲟﻌﻨﻰ ان اﻻﺟﺮاء ‪ setIntValue:‬ﺑﺎﻟﺮﺳﺎﻟﺔ اﳌﺮﺳﻠﺔ اﻟﻰ ﺣﻘﻞ اﻟﻨﺺ‪،‬‬
‫ﺣﺎل ﺗﻮأﻣﻪ اﳌﺘﻼزم ﺳﻴﻜﻮن ﻣﺜﻞ ﻣﺎ ﻳﻠﻲ‪:‬‬ ‫ﻣﻦ ﻗﺒﻞ اﳌﺮﺳﻞ ﻟﻦ ﲡﻌﻞ ﻫﺬا اﳌﺮﺳﻞ )‪ MAFood‬ﻫﻞ ﺗﺘﺬﻛﺮﻩ؟(‬
‫]‪[1‬‬ ‫ﻳﺴﺘﻘﺒﻞ اي ﻗﻴﻤﺔ راﺟﻌﺔ ﻣﻦ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ﺟﺮاء ﺗﻨﻔﻴﺬ ﻫﺬا‬
‫‪- (int) intValue‬‬
‫اﻻﺟﺮاء‪ .‬ﻫﺬا ﻫﻮ اﻟﻄﺒﻴﻌﻲ‪ .‬ﻓﺒﻌﺪ اﻟﻨﻘﻄﲔ اﻟﻌﻤﻮدﻳﺘﲔ ”‪ “:‬ﻧﻼﺣﻆ‬
‫ﻛﻤﺎ ﺗﺮى‪ ،‬ﻫﺬا اﻻﺟﺮاء‪ ،‬ﻳﻘﻮم ﺑﺎرﺟﺎع ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﻴﺤﺔ‪ .‬ﻟﺬا‬ ‫ان ﻣﻌﺎﻣﻞ اﻻﺟﺮاء )‪ (int‬ﻳﺸﺘﺮط ان ﻳﻜﻮن اﳌﺘﻐﻴﺮ اﳌﺮﺳﻞ ﻋﺪد‬
‫ﻣﺘﻰ ﻣﺎ اردﻧﺎ اﻻﺳﺘﻌﻼم ﻋﻦ ﻗﻴﻤﺔ ﺗﻠﻚ اﻟﻘﻴﻤﺔ اﻟﻌﺪﻳﺪة اﻟﺼﺤﻴﺤﺔ‬ ‫ﺻﺤﻴﺢ‪ .‬ﻓﻔﻲ ﻣﺜﺎﻟﻨﺎ اﳌﺴﺘﺨﺪم‪ ،‬ﻗﻤﻨﺎ ﺑﺎﺳﻨﺎد ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺗﺴﺎوي‬
‫اﳌﻀﻤﻨﺔ داﺧﻞ ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ﻓﺎﻧﻨﺎ ﺳﻨﻘﻮم ﺑﺎﺳﺘﺪﻋﺎء وﺗﻨﻔﻴﺬ‬‫ّ‬ ‫‪ ٥‬أو ﻗﻴﻤﺔ ﺗﺴﺎوي ﺻﻔﺮ‪ ،‬وﻛﻼﻫﻤﺎ ﻋﺪد ﺻﺤﻴﺢ‪ ،‬ﻟﺬا ﻧﺤﻦ ﻧﺴﻴﺮ‬
‫ﻫﺬا اﻻﺟﺮاء ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫ﺑﺸﻜﻞ ﺳﻠﻴﻢ‪.‬‬
‫]‪[2‬‬
‫;]‪resultReceived = [textField intValue‬‬
‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻳﺼﻌﺐ ﻋﻠﻴﻚ ﲢﺪﻳﺪ اﻻﺟﺮاء اﻻﻧﺴﺐ‬
‫ﻟﻼﺳﺘﺨﺪام‪ .‬ﻟﺬا ﻗﻢ ﺑﺎﺳﺘﺸﺎرة وﻣﺮاﺟﻌﺔ ﻣﻜﺘﺒﺔ وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة‪،‬‬
‫‪functions‬‬ ‫ﻣﺮة أﺧﺮى‪ ،‬ﻛﻤﺎ ﻫﻮ اﳊﺎل ﻣﻊ وﻇﺎﺋﻒ اﻟﺪوال‬
‫وﲤﺮن وﻣﺎرس ﻣﺎ ﺗﺘﻌﻠﻤﻪ‪.‬‬
‫)واﻻﺟﺮاءات ﻛﺬﻟﻚ( ﺳﺘﻜﻮن ﺟﻤﻴﻊ اﳌﺘﻐﻴﺮات اﻟﺪاﺧﻠﻴﺔ ﺑﺘﻠﻚ‬
‫دواﻟﻬﺎ‪ .‬ﻫﺬﻩ ﻣﻴﺰة ﺟﻤﻴﻠﺔ ﺟﺪاَ ﻻﻧﻬﺎ‬
‫اﻟﺪوال ﻣﺤﺠﻮﺑﺔ ﺿﻤﻦ ﻧﻄﺎق ّ‬ ‫ﻣﺎﻟﻌﻤﻞ ﻋﻨﺪﻣﺎ ﺗﺮﻏﺐ ﺑﺎﻻﺳﺘﻌﻼم ﻋﻦ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺤﺘﻮﻳﻬﺎ‬
‫ﲢﻤﻲ اﺳﻤﺎء اﳌﺘﻐﻴﺮات‪ ،‬وﻟﻦ ﻳﻌﺘﺮﻳﻚ اﳋﻮف ﻣﻦ اﺳﻨﺎد ﻗﻴﻤﺔ ﳌﺘﻐﻴﺮ‬ ‫ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ؟‬
‫ﻓﻲ اﺣﺪ اﺟﺰاء ﺑﺮﻧﺎﻣﺠﻚ ﺧﻮﻓ َﺎ ﻣﻦ ﻳﺆدي ذﻟﻚ اﻻﺳﻨﺎد ﻟﺘﻐﻴﻴﺮ ﻗﻴﻤﺔ‬ ‫ﻫﻞ ﺗﺘﺬﻛﺮ ذﻟﻚ اﳌﺒﺪء اﳉﻤﻴﻞ اﻟﺬي ﻳﺤﺠﺐ ﻋﻨﻚ اﳌﺘﻐﻴﺮات اﳋﺎﺻﺔ‬
‫ﻣﺘﻐﻴﺮ آﺧﺮ ﻳﺼﺪف ان ﻳﻜﻮن ﺑﻨﻔﺲ اﻻﺳﻢ‪.‬‬ ‫ﺑﻨﻄﺎق اﻟﺪاﻟﺔ؟ ﻫﺬا اﳌﺒﺪء ﻳﻨﻄﺒﻖ ﻫﻨﺎ ﻓﻲ ﺣﺎﻟﺔ اﻻﺟﺮاءات‪ .‬ﻋﻠﻰ ﻛﻞ‬
‫ﺗﺪﻓﻊ ‪ Objective-C‬ﻣﻴﺰة اﳊﺠﺐ ﻫﺬﻩ ﺷﻮﻃ َﺎ اﺑﻌﺪ‪ ،‬ﺣﻴﺚ ﺗﺸﺘﺮط ان‬ ‫ﺣﺎل ﻏﺎﻟﺒ َﺎ ﻣﺎ ﺳﺘﺠﺪ ان اﻻﺟﺮاءات ﺗﺄﺗﻲ ﺑﺸﻜﻞ ﺗﻮأم ﻣﺘﻼزم‪ ،‬ﻧﺪﻋﻮ‬
‫ان ﺗﻜﻮن اﺳﻤﺎء اﻻﺟﺮاءات ﻓﺮﻳﺪة ﻓﻘﻂ داﺧﻞ ﻧﻄﺎق اﻟﺘﺼﻨﻴﻒ‪ ،‬ﻟﺬا‬ ‫ﺗﻠﻚ اﻻﺟﺮاءات اﳌﺘﻼزﻣﺔ ﺑـ ”‪ ،“Accessors‬ﻓﻬﻨﺎك إﺟﺮاء ﺧﺎص‬
‫‪٧٢‬‬
‫اﻟﺮﺳﻮﻣﻴﺔ ‪ GUI،‬ﻓﻔﻲ ﺣﺎل اردﻧﺎ اﺳﺘﺒﺪال ﻛﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ‪،‬‬ ‫ﺳﺘﺠﺪ ﻋﺪة ﺗﺼﻨﻴﻔﺎت ﻣﺨﺘﻠﻔﺔ ﻟﺪﻳﻬﺎ اﺟﺮاءات ﺑﺎﺳﻤﺎء ﻣﻮﺣﺪة‪.‬‬
‫ﺑﻜﺎﺋﻦ آﺧﺮ ﻣﻦ ﻓﺼﻴﻠﺔ ﻣﺨﺘﻠﻔﺔ وﻟﻜﻦ اﻻﺧﻴﺮ ﻳﻘﺒﻞ ﺗﻨﻔﻴﺬ اﻹﺟﺮاء‬ ‫ﻫﺬﻩ ﻣﻴﺰة ﻣﻬﻤﺔ ﺗﻠﻤﺲ ﻗﻴﻤﺘﻬﺎ ﻣﺘﻰ ﻋﻤﻠﺖ ﻋﻠﻰ ﺗﻄﻮﻳﺮ ﺑﺮاﻣﺞ‬
‫‪ ، setInValue:‬ﻋﻨﺪﻫﺎ ﺳﻴﻈﻞ ﺑﺮﻧﺎﻣﺠﻨﺎ ﻳﻌﻤﻞ دون اﳊﺎﺟﺔ ﻟﺘﻐﻴﻴﺮ‬ ‫ﺿﺨﻤﺔ‪ ،‬ﺣﻴﺚ ﻳﺘﺸﺎرك ﻓﻲ ﻛﺘﺎﺑﺘﻬﺎ ﻋﺪة ﻣﺒﺮﻣﺠﲔ ‪ ،‬وﻛﻞ واﺣﺪ‬
‫اي ﺷﻔﺮة ﺑﺮﻣﺠﻴﺔ‪ ،‬أو ﺣﺘﻰ اﳊﺎﺟﺔ ﻻﻋﺎدة ﺗﺮﻛﻴﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻦ‬ ‫ﻣﻨﻬﻢ ﻣﺴﺌﻮل ﻋﻦ ﺗﺼﻤﻴﻢ اﻟﺘﺼﻨﻴﻒ اﻟﺬي ﻳﺮاﻩ ﻣﻨﺎﺳﺒ َﺎ‪ ،‬دون وﺟﻮد‬
‫اﳌﺠﻤﻊ‪.‬‬
‫ﺧﻼل ّ‬ ‫ﻣﺸﺎﻛﻞ ﺗﺘﻌﻠﻖ ﺑﺘﺼﺎدم أو إزدواﺟﻴﺔ ﺑﺎﺳﻤﺎء اﻻﺟﺮاءات‪.‬‬
‫ﻧﺤﻦ ﻗﺎدرون ﺣﺘﻰ ﻋﻠﻰ ﺗﻐﻴﻴﺮ ﻧﻮع اﻟﻜﺎﺋﻦ وﻗﺖ اﻟﺘﺸﻐﻴﻞ دون ان‬ ‫وﻫﻨﺎك اﳌﺰﻳﺪ ﻣﻦ اﻟﻔﺎﺋﺪة‪ .‬ﺣﻴﺚ ان ﺣﻘﻴﻘﺔ وﺟﻮد ﻋﺪة إﺟﺮاءات‬
‫ﻳﻜﻮن ﻟﺬﻟﻚ ﺿﺮر ﻋﻠﻰ اي ﻗﻄﺎع ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠﻰ اﻻﻃﻼق‪.‬‬ ‫ﻣﺘﻤﺎﺛﻠﺔ اﻻﺳﻤﺎء داﺧﻞ ﻋﺪة ﺗﺼﻨﻴﻔﺎت ﻳﻄﻠﻖ ﻋﻠﻴﻬﺎ ﺗﻘﻨﻴ َﺎ‬
‫ﻫﻨﺎ ﺗﻜﻤﻦ اﻟﻘﻮة واﻟﻔﺎﺋﺪة ﻋﻨﺪ اﺳﺘﺨﺪام اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت )‪(OOP‬‬ ‫‪ . polymorphism‬وﻫﺬﻩ اﻻﺧﻴﺮة ﻫﻲ ﻣﺎ ﻳﺠﻌﻞ اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت‬
‫‪.‬‬ ‫‪ object-oriented programming‬واﺧﺘﺼﺎرﻫﺎ )‪ (OOP‬اﺳﻠﻮﺑ َﺎ‬
‫ﺑﺮﻣﺠﻴ َﺎ ﻓﺮﻳﺪاَ‪.‬‬
‫ﻓﻬﺬﻩ اﳌﻴﺰة ﲤﻜﻨﻚ ﻣﻦ ﻛﺘﺎﺑﺔ ﻛﺘﻞ ﻣﻦ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ دون ان‬
‫ﻳﺘﻄﻠﺐ ﻣﻨﻚ ذﻟﻚ ﻣﻌﺮﻓﺔ ﻣﺴﺒﻘﺔ ﻋﻦ ﻛﺎﺋﻦ اﻟﺘﺼﻨﻴﻒ أو اﻟﺘﺼﻨﻴﻔﺎت‬
‫‪ classes‬اﻟﺘﻲ ﺗﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‪.‬‬
‫ذﻟﻚ ﻛﻞ ﻣﺎ ﻫﻮ ﻣﻄﻠﻮب‪ ،‬ﻓﻌﻨﺪ ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﻌﻠﻴ َﺎ ‪run-time‬‬
‫ﺳﺘﻘﻮم ﺗﻠﻚ اﻟﻜﺎﺋﻨﺎت ﺑﺘﻔﻬﻢ واﺳﺘﻴﻌﺎب اﻟﺮﺳﺎﺋﻞ اﳌﻮﺟﻬﺔ اﻟﻴﻬﺎ‪.‬‬
‫ان اﻻﺳﺘﻔﺎدة ﻣﻦ ﻫﺬﻩ اﳌﻴﺰة‪ ،‬ﲤﻜﻨﻚ ﻣﻦ ﻛﺘﺎﺑﺔ ﺗﻄﺒﻴﻘﺎت ﻗﺎﺑﻠﺔ‬
‫ﻟﻠﺘﻌﺪﻳﻞ واﻟﺘﻄﻮﻳﺮ‪.‬‬
‫ﻛﻤﺜﺎل‪ ،‬ﻧﻮرد ﺑﺮﻧﺎﻣﺠﻨﺎ اﻟﺬي اﺳﺘﺨﺪﻣﻨﺎ ﻓﻴﻪ واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت‬
‫‪٧٣‬‬
‫‪٧٤‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬
‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬
‫ﻗﺎﻣﺖ أﭘﻞ ﺑﻌﻤﻞ اﻟﻜﺜﻴﺮ واﻟﻜﺜﻴﺮ ﻟﺘﺴﻬﻞ ﻋﻠﻴﻚ إﻧﺸﺎء ﺑﺮاﻣﺠﻚ‪.‬‬
‫ﻓﻔﻲ ﺑﺮﻧﺎﻣﺠﻨﺎ اﻟﺼﻐﻴﺮ‪ ،‬ﻟﻢ ﻧﻜﺘﺮث ﻟﺒﺮﻣﺠﺔ اﻟﻨﺎﻓﺬة ﻛﻲ ﺗﺮﺳﻢ ذاﺗﻬﺎ‬
‫ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬وﻟﻢ ﻳﻜﻦ ﻣﻄﻠﻮﺑ َﺎ ﻣﻨﺎ ﻛﺘﺎﺑﺔ اي ﺳﻄﺮ ﺑﺮﻣﺠﻲ ﻟﻨﺸﺮح‬
‫ﻟﻺزرار ﻛﻴﻒ ﻳﺮﺳﻢ ذاﺗﻪ ﻋﻠﻰ اﻟﻨﺎﻓﺬة‪ ،‬ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ اﻣﻮر وﺗﻔﺎﺻﻴﻞ‬
‫اﺧﺮى‪ .‬ﻓﻬﺬﻩ اﻻﻋﻤﺎل ﻣﻦ ﻣﺴﺌﻮﻟﻴﺔ ﻫﻴﻜﻠﻲ ﻋﻤﻞ ‪frameworks‬‬
‫‪ ،‬اﺛﻨﲔ ﻫﻤﺎ ‪ Foundation Kit framework‬و ‪Application Kit.‬‬
‫‪framework‬‬
‫اﻻول ‪ ،Foundation Kit‬ﻫﻮ واﻟﺬي ﺗﻌﺎﻣﻠﻨﺎ ﻣﻊ وﺟﻠﺒﻨﺎﻩ ﻓﻲ ﻣﺜﺎﻟﻨﺎ‬

‫]‪ [12‬ﺑﺎﻟﻔﺼﻞ ‪ ،٤‬ﺣﻴﺚ ﻛﺎﻧﺖ ﻣﻬﻤﺘﺔ ﺗﺰوﻳﺪﻧﺎ ﺑﺨﺪﻣﺎت ﻟﻴﺲ ﻟﻬﺎ‬
‫ﻋﻼﻗﺔ ﺑﺎﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ‪ .‬واﻟﻬﻴﻜﻞ اﻟﻌﻤﻠﻲ اﻟﺜﺎﻧﻲ ‪Application‬‬
‫‪ ، Kit‬ﻫﻮ اﳌﺴﺆل اﳌﺒﺎﺷﺮ ﻋﻦ اي ﻛﺎﺋﻨﺎت رﺳﻮﻣﻴﺔ ﺗﺮاﻫﺎ ﻣﻌﺮوﺿﺔ ﻋﻠﻰ‬
‫اﻟﺸﺎﺷﺔ اﻣﺎﻣﻚ‪ ،‬ﻓﻬﻮ ﻳﺤﻘﻖ اﻟﻌﺮض واﻟﺘﺪاول ‪user-interaction‬‬
‫‪ . mechanisms‬دﻋﻨﺎ ﻧﻌﻮد ﻣﺮة اﺧﺮى اﻟﻰ ﺑﺮﻧﺎﻣﺠﻨﺎ اﻟﺬي ﻳﻌﺘﻤﺪ‬
‫واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ ‪ ،GUI‬وﻟﻨﻔﺘﺮض اﻧﻨﺎ ﻧﺮﻏﺐ ﻣﻦ ﺑﺮﻧﺎﻣﺠﻨﺎ‬
‫ان ﻳﻌﺮض ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﺑﻜﺎﺋﻦ ﺣﻘﻞ اﻟﻨﺺ ﻣﺎ ان ﻳﻨﻄﻠﻖ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻟﻠﻌﻤﻞ وﻳﺒﺪأ ﺑﻌﺮض ﻧﺎﻓﺬﺗﻪ‪.‬‬
‫‪٧٥‬‬
‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﻹﺳﺘﻨﻬﺎض ﺑﺒﺮوﺗﻮﻛﻞ ‪NSNibAwakening‬‬ ‫ان ﺟﻤﻴﻊ اﳌﻌﻠﻮﻣﺎت اﻟﺘﻲ ﺗﻬﺘﻢ ﻟﻬﺎ ﻧﺎﻓﺬة اﻟﺒﺮﻧﺎﻣﺞ ﻣﺨﺰﻧﺔ ﲟﻠﻒ‬
‫اﻧﻪ إﺟﺮاء ﻟﻺﻋﻼن واﻟﺘﺼﺮﻳﺢ‪ ،‬ﻳﺤﺘﻮي ﻣﺎ ﻳﻠﻲ‪:‬‬ ‫ﻣﻦ اﻣﺘﺪاد ‪) nib‬و ‪ nib‬ﻫﺬﻩ ﲤﺜﻞ اﻣﺘﺪاد ﻣﺨﺘﺼﺮ ﻟﻜﻠﻤﺔ ‪Next‬‬
‫‪.( Interface Builder‬‬
‫ان ﻓﻲ ذﻟﻚ اﺷﺎراة اﻟﻰ ان اﻻﺟﺮاء اﻟﺬي ﻧﺤﺘﺎﺟﺔ ﻳﺨﺘﺺ ﺑﻘﻄﺎع‬
‫ﻫﻴﻜﻞ اﻟﻌﻤﻞ ‪ . Application Kit‬ﻟﺬا دﻋﻨﺎ ﻧﺘﻔﺤﺺ ﻛﻴﻔﻴﺔ ﺣﺼﻮﻟﻨﺎ‬
‫ﻋﻠﻰ اﳌﻌﻠﻮﻣﺎت ﺣﻮل ﻫﺬا اﻟﻬﻴﻜﻞ اﻟﻌﻤﻠﻲ‪ .‬وﻣﻦ ﺧﻼل ‪Xcode،‬‬
‫ﺗﻮﺟﻪ إﻟﻰ ﻗﺎﺋﻤﺔ اﳌﺴﺎﻋﺪة ‪ Help menu‬واﺧﺘﺮ وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة‬
‫‪.Documentation‬‬
‫ﻓﻲ ﻧﺎﻓﺬة وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة ﺗﺄﻛﺪ ﻣﻦ ان ﺧﻴﺎر ﺑﺤﺚ ﻛﺎﻓﺔ اﻟﻨﺼﻮص‬
‫‪ Full-Text Search‬ﻗﻴﺪ اﻟﺘ ّﻔﻌﻴﻞ )وﻟﻌﻤﻞ ذﻟﻚ ﻗﻢ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ‬
‫اﻳﻘﻮﻧﺔ اﳌﻜﺒﺮ ﺑﺤﻘﻞ اﻟﺒﺤﺚ اﳌﻮﺟﻮد ﺑﺘﻠﻚ اﻟﻘﺎﺋﻤﺔ(‪ .‬ﺛﻢ ﻗﻢ ﺑﻜﺘﺎﺑﺔ‬
‫‪ Application Kit‬ﺑﺤﻘﻞ اﻟﺒﺤﺚ ﻳﻠﻴﻬﺎ ﻣﻔﺘﺎح اﻻدﺧﺎل ‪.Return‬‬
‫اﻟﺒﺮوﺗﻮﻛﻮل ﻋﺒﺎرة ﻋﻦ ﻃﺮﻳﻘﺔ ذات آﻟﻴﺔ ﻋﻤﻞ ﻣﺘﻔﻖ ﻋﻠﻴﻬﺎ‪ ،‬ﻓﻬﻮ‬
‫ﺳﻴﻘﻮم ‪ Xcode‬ﺑﺘﺰوﻳﺪك ﺑﻌﺪة ﻧﺘﺎﺋﺞ ﻣﺘﻨﻮﻋﺔ‪ .‬وﻣﻦ ﺿﻤﻦ ﻫﺬﻩ‬
‫ﻫﻨﺎ ﺑﺮوﺗﻮﻛﻮل اﻋﻼﻣﻲ ‪ ،informal‬ﻳﺘﻜﻮن ﻣﻦ إﺟﺮاء واﺣﺪ‪ ،‬ﻳﺘﻤﺜﻞ‬
‫اﻟﻨﺘﺎﺋﺞ ﺳﺘﺠﺪ وﺛﻴﻘﺔ ﺑﺎﺳﻢ ‪Application Kit Reference for‬‬
‫ﺑـ ‪.awakeFromNib‬‬
‫‪ .Objective-C‬داﺧﻞ اﻟﻮﺛﻴﻘﺔ ﺳﺘﺠﺪ ﻗﺎﺋﻤﺔ ﻣﻦ اﳋﺪﻣﺎت اﻟﺘﻲ‬
‫ﺗﻘﻮم اﻟﺘﺼﻨﻴﻔﺎت ﺑﺈﻗﺤﺎم ‪ -implement-‬ﻫﺬا اﻟﺒﺮوﺗﻮﻛﻞ ﻟﻴﺴﺎﻋﺪﻫﺎ‬ ‫ﻳﻮﻓﺮﻫﺎ ﻫﺬا اﻟﻬﻴﻜﻞ‪.‬‬
‫ﺑﺘﻬﺌﻴﺔ ﺣﺎﻟﺘﻬﺎ اﻟﻨﻬﺎﺋﻴﺔ ﻣﺘﻰ ﻣﺎ ﰎ ﺟﻠﺒﻬﺎ ﻣﻦ ارﺷﻴﻒ اﳌﻠﻒ اﻟﺬي‬
‫راﺑﻂ ﻳﺴﻤﻰ‬ ‫‪Protocols‬‬ ‫ﺳﺘﺠﺪ ﲢﺖ اﻟﻌﻨﻮان اﻟﻔﺮﻋﻲ ﻟﻠﻘﺴﻢ‬
‫ﻳﺨﺮﻧﻬﺎ واﻟﺬي ﻳﻜﻮن اﻣﺘﺪادﻩ ‪ .NIB‬ﻓﻤﺘﻰ ﻣﺎ اﻗﺤﻤﻨﺎ ‪-implement-‬‬ ‫‪NSNibAwakening.‬‬
‫ﻫﺬا اﻻﺟﺮاء‪ ،‬ﻓﺎﻧﻪ ﺳﻴﻜﻮن ﻗﻴﺪ اﻟﺘﻨﻔﻴﺬ ﻻﺟﺮاء اﻟﺘﻬﺌﻴﺔ اﳌﻨﺎﺳﺒﺔ ﻟﻠﻜﺎﺋﻦ‬
‫‪٧٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬
‫]‪[1‬‬
‫”‪#import “MAFoo.h‬‬
‫اﻟﺬي ﻗﺎم ﺑﺎﺳﺘﺪﻋﺎﺋﺔ وﻫﻮ ﻓﻲ ﻣﺮﺣﻠﺔ اﻟﺘﺤﻤﻴﻞ ﻣﻦ اﻻرﺷﻴﻒ‪ .‬ﺑﻨﺎء ﻋﻠﻰ‬
‫ذﻟﻚ ﳝﻜﻨﻨﺎ اﺳﺘﺨﺪاﻣﺔ ﻟﺘﺤﻘﻴﻖ ﻫﺪﻓﻨﺎ‪ :‬اي ﻋﺮض ﻗﻴﻤﺔ اﻓﺘﺮاﺿﻴﺔ‬
‫‪@implementation MAFoo‬‬
‫ﻣﻌﻴﻨﺔ وﻗﺖ اﻟﺘﺸﻐﻴﻞ‪.‬‬
‫ﻧﻘﺘﺮح ﻋﻠﻴﻚ دوﻣ َﺎ ان ﲡﺮي ﺑﺤﺜﻚ وﲢﻮﻳﺎﺗﻚ ﻋﻦ اﻻﺟﺮاءات‬
‫‪- (IBAction)reset:(id)sender‬‬
‫{‬
‫;]‪[textField setIntValue:0‬‬ ‫ﻼ ﻣﻦ اﻟﺘﺼﻔﺢ‬ ‫اﻻﻧﺴﺐ‪ .‬و ﻏﺎﻟﺒ َﺎ ﻣﺎ ﻳﺘﻄﻠﺐ ذﻟﻚ ﻗﻠﻴ َ‬
‫}‬
‫واﻻﺳﺘﺨﺪام اﳋﻼق ﳌﻔﺮدات اﻟﺒﺤﺚ اﳌﺴﺘﺨﺪﻣﺔ ﻟﺘﺴﻠﻴﻂ‬
‫‪- (IBAction)setTo5:(id)sender‬‬ ‫اﻟﻀﻮء ﻋﻠﻰ اﻻﺟﺮاء اﳌﻄﻠﻮب‪.‬‬
‫{‬
‫;]‪[textField setIntValue:5‬‬ ‫ﻟﺬا ﻣﻦ اﳌﻬﻢ ﺟﺪاَ ان ﺗﺘﺄﻟﻒ ﺑﺒﺤﺜﻚ ﺧﻼل ﺗﻠﻚ اﻟﻮﺛﺎﺋﻖ ﺣﻮل ﻫﺬان‬
‫}‬
‫اﻟﻬﻴﻜﻼن ‪ frameworks،‬ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﻟﺘﻌﺮف ﻋﻠﻰ اﻟﺘﺼﻨﻴﻔﺎت‬
‫]‪- (void)awakeFromNib // [1.15‬‬ ‫اﻟﺘﻲ ﻳﻘﺪﻣﺎﻧﻬﺎ‪ ،‬واﻻﺟﺮاءات اﻟﺘﻲ ﺳﻮف ﺗﻜﻮن ﲢﺖ ﺗﺼﺮﻓﻚ‪.‬‬
‫{‬
‫;]‪[textField setIntValue:0‬‬ ‫ﻗﺪ ﺗﻘﺮأ ﻋﻦ ﻣﻌﻠﻮﻣﺎت ﻟﻴﺴﺖ ﺑﺬات اﻫﻤﻴﺔ ﻟﺒﺤﺜﻚ اﳊﺎﻟﻲ‪ ،‬وﻟﻜﻨﻚ‬
‫}‬
‫ﺳﺘﻜﺘﺸﻒ اﻧﻚ ﺗﺒﻨﻲ ﻗﺎﻋﺪة ﻣﻦ اﳌﻌﻠﻮﻣﺎت ﲟﺨﻴﻠﺘﻚ ﺳﻮف ﻳﻜﻮن‬
‫‪@end‬‬ ‫ﻟﻬﺎ اﻻﺛﺮ ﻓﻲ ﺳﺮﻋﺔ ﺑﻨﺎﺋﻚ ﻟﺒﺮاﻣﺠﻚ‪.‬‬
‫ﻣﺘﻰﻣﺎ ﻗﺎﻣﺖاﻟﻨﺎﻓﺬة ﺑﻌﺮض ذاﺗﻬﺎ‪،‬ﺳﻴﻘﻮم اﻻﺟﺮاء ‪awakeFromNib‬‬ ‫ﺟﻤﻴﻞ ﺟﺪاَ‪ ،‬ﻟﻘﺪ وﺟﺪﻧﺎ اﻻﺟﺮاء ﺑﻌﺪ ﺗﺴﻠﻴﻂ اﻟﻀﻮء ﻋﻠﻴﻪ‪ ،‬وﻛﻞ ﻣﺎ‬
‫ﺑﺈﺳﺘﺪﻋﺎء ذاﺗﺔ إﻟﻴ َﺎ‪ .‬وﻛﻨﺘﻴﺠﺔ ﻟﺬﻟﻚ‪ ،‬ﺳ ُﻴﺴﺘﻨﻬﺾ ﺣﻘﻞ اﻟﻨﺺ‬ ‫ﻋﻠﻴﻨﺎ ﻋﻤﻠﻪ اﻻن ﻫﻮ إﺿﺎﻓﺘﺔ إﻟﻰ ﻣﻠﻒ ﺗﻮﺻﻴﻒ اﻟﺘﺼﻨﻴﻒ ‪MAFoo.‬‬
‫ﻣﺒﻜﺮاَ ﻟﻴﻌﺮض ﻗﻴﻤﺔ ﺗﺴﺎوي ﺻﻔﺮ ﻣﺎ ان ﻳﻜﻮن ﻇﺎﻫﺮاَ ﻟﻚ داﺧﻞ‬ ‫‪ m‬ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫ﺗﻠﻚ اﻟﻨﺎﻓﺬة اﳌﻔﺘﻮﺣﺔ‪.‬‬
‫‪٧٧‬‬
‫اﻻﺳﺘﻨﻬﺎض ﻣﻦ اﻟﻐﻔﻮة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪٧٨‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﳌﺆﺷﺮات‬
‫اﳌﺆﺷﺮات‬
‫ﻣﻦ واﺟﺒﻨﺎ ﲢﺬﻳﺮك ان ﻫﺬا اﻟﻔﺼﻞ ﻳﺤﺘﻮي ﻋﻠﻰ ﻋﺪد ﻣﻦ اﳌﻔﺎﻫﻴﻢ‬
‫اﳌﺘﻘﺪﻣﺔ ﺣﻮل اﺳﺎﺳﻴﺎت ﻟﻐﺔ ‪ C‬واﻟﺘﻲ ﻗﺪ ﺗُﺸﻌﺮ اﳌﺒﺘﺪﺋﲔ ﺑﺎﻟﻀﻴﻖ‬
‫واﻟﺘﻀﺠﺮ‪.‬‬
‫ﻻ ﺗﻘﻠﻖ اذا ﻟﻢ ﺗﺴﺘﻮﻋﺒﻬﺎ اﻻن وﻻ ﲡﻌﻞ اﻻﻣﺮ ﻳﻘﻠﻘﻚ ﺣﻴﺚ اﻧﻪ‬
‫ﻟﻴﺲ ﻣﺘﻄﻠﺐ رﺋﻴﺴﻲ ﻟﺒﺪء اﻟﺒﺮﻣﺠﺔ ﺑﻠﻐﺔ ‪ ، Objective-C‬ﻟﻜﻦ‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﳌﺆﺷﺮات ﻟﻪ ﻓﻮاﺋﺪ ﺟﻤﺔ‪ ،‬ﻓﻌﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺘﻌﻴﲔ وﺗﻌﺮﻳﻒ‬
‫ﻣﺘﻐﻴﺮ ‪ ،variable‬ﺳﻴﻘﻮم اﳌﺎﻛﻨﺘﻮش ﺑﺤﺠﺰ ﺣﻴﺰ ﻣﻌﲔ ﻣﻦ اﻟﺬاﻛﺮة‬
‫وذﻟﻚ ﳊﻔﻆ اﻟﻘﻴﻢ اﻟﺘﻲ ﺳﻴﺤﺘﻮﻳﻬﺎ ﻫﺬا اﳌﺘﻐﻴﺮ‪ .‬ﻛﻤﺜﺎل ﻋﻠﻰ ذﻟﻚ‪،‬‬
‫ﺗﻔﺤﺺ اﻻﻳﻌﺎز اﻟﺘﺎﻟﻲ‪:‬‬
‫]‪[1‬‬
‫;‪int x = 4‬‬
‫ﺣﺘﻰ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﻫﺬا اﻻﻳﻌﺎز‪ ،‬ﺳﻴﻘﻮم اﳌﺎﻛﻨﺘﻮش ﺑﺎﻟﺒﺤﺚ ﻋﻦ‬

‫ﻣﺴﺎﺣﺔ ﻏﻴﺮ ﻣﺴﺘﺨﺪﻣﺔ ﺑﺎﻟﺬاﻛﺮة‪ .‬ﺛﻢ ﺳﻴﻘﻮم ﺑﺤﺠﺰ ﺣﻴﺰ ﻣﻨﻬﺎ ﺣﻴﺚ‬
‫ﻳﺘﻢ ﺗﺨﺰﻳﻦ ﻗﻴﻤﺔ ذﻟﻚ اﳌﺘﻐﻴﺮ ‪) ،x‬وﺑﺎﻟﺘﺄﻛﻴﺪ ﻟﻚ ﻣﻄﻠﻖ اﳊﺮﻳﺔ ﻓﻲ‬
‫اﺧﺘﻴﺎر اﺳﻢ اﳌﺘﻐﻴﺮ(‪.‬‬
‫ﺗﻔﺤﺺ اﻻﻳﻌﺎز ﻣﺮة أﺧﺮى ]‪ ،[1‬وﺳﺘﺠﺪ اﻧﻪ ﻳﺤﺪد ﻧﻮع‪/‬ﺻﻨﻒ‬
‫اﳌﺘﻐﻴﺮ )وﻫﻮ ﻋﺪدي ﺻﺤﻴﺢ ﻫﻨﺎ(‪ ،‬ﺣﺘﻰ ﻳﺘﻤﻜﻦ اﳊﺎﺳﺐ ﻣﻦ‬
‫‪٧٩‬‬
‫اﳌﺆﺷﺮات‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫اﻟﻌﺪدﻳﺔ ‪ .(٤‬وﻋﻠﻰ اﻟﻨﻘﻴﺾ ﻣﻦ ذﻟﻚ ﻋﻨﺪﻣﺎ ﻳﺠﺮي ﺗﻘﻴﻴﻢ اﻻﻳﻌﺎز‬ ‫ﲢﺪﻳﺪ اﳌﺴﺎﺣﺔ اﳌﻄﻠﻮﺑﺔ ﻟﻠﺤﺠﺰ واﻻﺣﺘﻔﺎظ ﺑﻘﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ .x‬ﻟﻮ‬
‫‪ ،&x‬ﻓﺈن اﳊﺎﺳﺐ ﻫﻨﺎ ﻟﻦ ﻳﻌﻮد ﻟﻨﺎ ﺑﺎﻟﻘﻴﻤﺔ اﶈﻔﻮﻇﺔ ﻟﻠﻤﺘﻐﻴﺮ‪ ،‬ﺑﻞ‬ ‫ﻛﺎﻧﺖ اﻟﻘﻴﻤﺔ ﻣﻦ ﻧﻮع ﻋﺪدي ﻛﺒﻴﺮ أو ﻋﺪد ﻣﺰدوج ‪(long long or‬‬
‫ﺳﻴﻌﻮد ﺑﺎﻟﻌﻨﻮان اﻟﺬي ﻳﻮﺟﺪ ﺑﻪ ذﻟﻚ اﳌﺘﻐﻴﺮ ﻣﻦ اﻟﺬاﻛﺮة‪ .‬ان اﻟﻌﻨﻮان‬ ‫)‪ ،double‬ﺳﻴﺘﻄﻠﺐ ذﻟﻚ ﻣﻦ اﳊﺎﺳﺐ ان ﻳﻘﻮم ﺑﺤﺠﺰ ﺣﻴﺰ اﻛﺒﺮ ﻣﻦ‬
‫ﻋﺒﺎرة ﻋﻦ رﻗﻢ ﳝﺜﻞ ﺟﺰء ﻣﻌﲔ ﻣﻦ ذاﻛﺮة اﳊﺎﺳﺐ )ﻣﺜﻞ اﻻرﻗﺎم‬ ‫اﻟﺬاﻛﺮة اﳌﺘﺎﺣﺔ‪.‬‬
‫اﻟﺘﻲ ﲤﺜﻞ ﻏﺮف اﻟﻔﻨﺪق ‪ -‬وﻓﻨﺪﻗﻨﺎ ﻫﻨﺎ ﻣﻜﻮن ﻣﻦ آﻻف اﻵﻻف ﻣﻦ‬ ‫إن اﻳﻌﺎز اﻻﺳﻨﺎد ”‪ “x = 4‬ﺳﻴﻘﻮم ﺑﺘﺨﺰﻳﻦ ﻗﻴﻤﺔ اﻟﻌﺪد ‪ ٤‬ﻓﻲ ذﻟﻚ‬
‫اﻟﻐﺮف( ﺳﻴﺘﻢ اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺆﺷﺮ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫اﳊﻴﺰ اﶈﺠﻮز ﻣﻦ اﻟﺬاﻛﺮة‪ .‬ﺑﺎﻟﺘﺄﻛﻴﺪ ﺳﻴﺘﺬﻛﺮ اﳊﺎﺳﺐ اﻳﻦ ﻗﺎم‬
‫]‪[2‬‬
‫;‪int *y‬‬
‫ﺑﺘﺨﺰﻳﻦ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ‪ x‬ﻣﻦ اﻟﺬاﻛﺮة‪ ،‬أو ﲟﻌﻨﻰ آﺧﺮ إﻧﻪ ﻳﻌﺮف ”ﻋﻨﻮان“‬
‫اﳌﺘﻐﻴﺮ ‪ x‬ﻣﻦ اﻟﺬاﻛﺮة‪ ،‬ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ‪ ،‬ﻛﻠﻤﺎ اﺳﺘﺨﺪﻣﺖ اﳌﺘﻐﻴﺮ ‪ x‬ﻓﻲ‬
‫ﻫﺬا اﻻﻳﻌﺎز ﻳﺼﺮح ﻋﻦ ان ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ‪ y‬ﲢﺘﻮي ﻋﻨﻮان ﻣﻦ اﻟﺬاﻛﺮة‬ ‫ﺑﺮﻧﺎﻣﺠﻚ‪ ،‬ﺳﻴﻘﻮم اﳊﺎﺳﺐ ﺑﺎﻟﺒﺤﺚ ﻓﻲ اﳌﻜﺎن اﻟﺼﺤﻴﺢ )اﻟﻌﻨﻮان‬
‫ﳌﺘﻐﻴﺮ آﺧﺮ ﻣﻦ ﻧﻮع ﻋﺪدي ﺻﺤﻴﺢ ‪ .int‬وﻟﻨﻘﻮم ﺑﺤﻔﻆ ﻋﻨﻮان اﳌﺘﻐﻴﺮ‪x‬‬
‫اﻟﺼﺤﻴﺢ ﺑﺎﻟﺬاﻛﺮة( ﻻﻳﺠﺎد اﻟﻘﻴﻤﺔ اﳌﺨﺰﻧﺔ اﳋﺎﺻﺔ ﺑﺎﳌﺘﻐﻴﺮ‪.x‬‬
‫داﺧﻞ اﳌﺘﻐﻴﺮ ‪) y‬ﻧﺴﻨﺪ ﻋﻨﻮان ‪ x‬اﻟﻰ ‪ y‬ﺗﻘﻨﻴﻨﺎً( ﻧﻜﺘﺐ ﻣﺎ ﻳﻠﻲ‪:‬‬
‫]‪[3‬‬ ‫ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﻴﺮ ﺗﻜﻮن ﻗﻴﻤﺘﻪ ”ﻋﻨﻮان“‬ ‫)‪(pointer‬‬ ‫اﳌﺆﺷﺮ‬
‫;‪y = &x‬‬ ‫ﳌﺘﻐﻴﺮ آﺧﺮ‪.‬‬
‫ﻣﻊ وﺟﻮد اﳌﺆﺷﺮ‪ ،‬ﳝﻜﻨﻚ اﻟﻮﺻﻮل اﻟﻰ ﻗﻴﻤﺔ ذﻟﻚ اﳌﺘﻐﻴﺮ اﻟﺬي‬ ‫ﻣﺘﻰ ﻣﺎ ﻛﺎن ﻟﺪﻳﻚ ﻣﺘﻐﻴﺮ‪ ،‬ﳝﻜﻨﻚ ان ﲢﺼﻞ ﻋﻠﻰ ﻋﻨﻮان ﻣﻮﻗﻌﻪ‬
‫ﻳﺸﻴﺮ اﻟﻴﻪ‪ ،‬ﻣﻦ ﺧﻼل اﺿﺎﻓﺔ ﻋﻼﻣﺔ ﻣﻌﺎﻣﻞ اﻟﻀﺮب * ﻛﺒﺎدﺋﺔ اﻣﺎم‬ ‫ﺑﺎﻟﺬاﻛﺮة ﻣﻦ ﺧﻼل اﺿﺎﻓﺔ اﻟﺮﻣﺰ & ﻛﺒﺎدﺋﺔ اﺳﻤﻴﺔ‪.‬‬
‫اﺳﻢ اﳌﺘﻐﻴﺮ )اﳌﺆﺷﺮ(‪ .‬ﻛﻤﺜﺎل‪ ،‬ان ﺗﻘﻴﻴﻢ ﻫﺬا اﻻﻳﻌﺎز‬
‫ﻟﺬا ﺣﺘﻰ ﻧﺘﺤﺼﻞ ﻋﻠﻰ ﻋﻨﻮان اﳌﺘﻐﻴﺮ ‪ ،x‬ﻳﺠﺐ ﻋﻠﻴﻨﺎ ﻛﺘﺎﺑﺔ ‪.&x‬‬
‫‪*y‬‬
‫‪&x‬‬
‫ﺳﻴﻌﻮد ﺑﻘﻴﻤﺔ ﻋﺪدﻳﺔ ﺗﺴﺎوي ‪ .٤‬ﻓﺎﻻﻳﻌﺎز ﻫﺬا ﳝﺎﺛﻞ اﻻﻳﻌﺎز‬
‫ﻋﻨﺪﻣﺎ ﻳﻘﻮم اﳊﺎﺳﺐ ﺑﺘﻘﻴﻴﻢ اﻻﻳﻌﺎز ‪ ،x‬ﻓﺎﻧﻪ ﺳﻴﻘﻮم ﻓﻮراَ ﺑﺎرﺟﺎع‬
‫اﳌﺴﺘﺨﺪم ﻟﺘﻘﻴﻴﻢ ”‪ .“x‬إن ﺗﻨﻔﻴﺬ اﻻﻳﻌﺎز‬
‫ﻗﻴﻤﺔ ذﻟﻚ اﳌﺘﻐﻴﺮ )ﻓﻲ ﻣﺜﺎﻟﻨﺎ اﻟﺴﺎﺑﻖ ﻛﺎﻧﺖ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ ﺗﺮﺟﻊ اﻟﻘﻴﻤﺔ‬
‫‪٨٠‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﳌﺆﺷﺮات‬
‫‪*y = 5‬‬
‫ﺳﻴﻜﻮن ﳑﺎﺛ َ‬
‫ﻼ ﻟﺘﻨﻔﻴﺬ اﻻﻳﻌﺎز‬
‫‪x = 5‬‬
‫ﻟﻠﻤﺆﺷﺮات ﻓﻮاﺋﺪﻫﺎ ﻓﻘﺪ ﺗﺮﻏﺐ ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ان ﺗﺸﻴﺮ إﻟﻰ‬

‫ﻋﻨﻮان اﺣﺪ اﳌﺘﻐﻴﺮات دون اﻻﻛﺘﺮاث ﻟﻠﻘﻴﻤﺔ اﻟﺘﻲ ﻳﺤﺘﻮﻳﻬﺎ ذﻟﻚ‬
‫اﳌﺘﻐﻴﺮ‪ ،‬ان ﺗﻌﲔ ﻣﺘﻐﻴﺮ ﻳﻨﻮب ﻋﻦ دﻟﻚ اﳌﺘﻐﻴﺮ وﻗﺖ ﺗﻮﺟﻴﻬﻚ‬
‫ﻟﻺﻳﻌﺎزات‪.‬ﻛﻤﺜﺎل‪ ،‬ﻟﻨﻔﺮض اﻧﻚ ﺑﺼﺪد إﻧﺸﺎء داﻟﺔ ﺗﻘﻮم وﻇﻴﻔﺘﻬﺎ‬
‫ﺑﺰﻳﺎدة ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﻣﻘﺪارﻫﺎ ‪ ١‬اﻟﻰ اﺣﺪ اﳌﺘﻐﻴﺮات‪ ،‬وﻫﻲ ﺗﺴﺘﻮﺟﺐ‬
‫ﻣﻌﺎﻣﻞ ﻳﺤﺘﻮي ﻋﻨﻮان ذﻟﻚ اﳌﺘﻐﻴﺮ‪ .‬وﺳﺒﺐ ذﻟﻚ اﻧﻬﺎ ﺳﺘﻘﻮم ﺑﺘﻌﺪﻳﻞ‬
‫ﻣﺤﺘﻮى اﻟﻘﻴﻤﺔ اﳌﺨﺰﻧﺔ‪ ،‬وﻟﻴﺲ ﻓﻘﻂ اﺳﺘﺨﺪاﻣﻬﺎ‪ .‬ﻟﺬا ﻳﺘﻮﺟﺐ‬
‫ﻋﻠﻴﻚ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ ﻣﻦ ﻧﻮع ﻣﺆﺷﺮ ”‪“pointer as argument‬‬
‫]‪[4‬‬
‫)‪void increment(int *y‬‬
‫{‬
‫;‪*y = *y + 1‬‬
‫}‬
‫ﳝﻜﻨﻚ ﺑﻌﺪ ذﻟﻚ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﺘﻨﻔﻴﺬ ﻣﺎ ﺗﻘﻮم ﺑﻪ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫]‪[5‬‬
‫;‪int x = 4‬‬
‫;)‪increment(&x‬‬
‫‪// now x is equal to 5‬‬
‫‪٨١‬‬
‫اﳌﺆﺷﺮات‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪٨٢‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬
‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬

‫‪integer,‬‬‫ﺣﺘﻰ اﻻن ﺗﻌﺎرﻓﻨﺎ ﻋﻠﻰ ﻋﺪة اﻧﻮاع ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻣﺜﻞ‪:‬‬
‫‪ ، long, float, double, BOOL‬وﻗﺪ ﺗﻌﺎرﻓﻨﺎ ﻣﺆﺧﺮاَ ﻋﻠﻰ اﳌﺆﺷﺮات‬
‫او ﻣﺎﻳﻌﺮف ﺑـ ‪.pointers‬‬
‫وﻗﺪ ﺗﻌﺮﺿﻨﺎ ﺳﻄﺤﻴ َﺎ ﻟﺴﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‪ ،‬ﻣﻦ ﺧﻼل ﺣﺪﻳﺜﻨﺎ‬
‫اﺛﻨﺎء اﺳﺘﺨﺪاﻣﻬﺎ ﺑﺎﻟﺪاﻟﺔ )(‪ .NSLog‬ﺗﻠﻚ اﻟﺪاﻟﺔ اﻟﺘﻲ ﲤﻜﻨﻨﺎ‬
‫ﻣﻦ ﻃﺒﺎﻋﺔ ﺳﻠﺴﻠﺔ ﻣﻦ اﳊﺮوف ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪ ،‬ﻣﺴﺘﺒﺪﻟﲔ ﺑﻌﺾ‬
‫اﳌﻌﺎﻣﻼت ﺑﻮاﺳﻄﺔ اﳊﺮوف اﳋﺎﺻﺔ ﻛـ ”\” أو "‪ "%‬وﻋﻼﻣﺔ ‪%d‬‬
‫ﺑﻘﻴﻢ ﻣﺘﻨﻮﻋﺔ‪.‬‬
‫]‪[1‬‬
‫;‪float piValue = 3.1416‬‬
‫‪NSLog(@”Here are three examples of strings‬‬
‫;)”‪printed to the screen.\n‬‬
‫‪NSLog(@”Pi approximates %10.4f.\n”,‬‬
‫;)‪piValue‬‬
‫‪NSLog(@”The number of eyes of a dice is‬‬
‫;)‪%d.\n”, 6‬‬
‫ﻟﻢ ﻧﺘﺤﺪث ﻋﻦ ﺳﻠﺴﻠﺔ اﳊﺮوف ﻛﻨﻮع ﻣﻦ اﻧﻮاع اﻟﺒﻴﺎﻧﺎت ﺳﺎﺑﻘ َﺎ‪،‬‬

‫واﻟﺴﺒﺐ وﺟﻴﻪ‪ .‬وﻫﻮ ان ﺳﻠﺴﻠﺔ اﳊﺮوف ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻦ! وأﺻﻠﻪ‬
‫ﻓﻲ ﺳﻼﻟﺔ اﻟﺘﺤﺪر ﺑﺴﻠﺴﻠﺔ اﻟﺘﻮارث ﻫﻮ اﻟﺘﺼﻨﻴﻒ ‪ NSString‬أو‬
‫‪٨٣‬‬
‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻟﻘﺪ اﺳﺘﺨﺪﻣﻨﺎ ﻣﺆﺷﺮ ﻟﻴﻘﻮم ﺑﺎﻻﺣﺘﻔﺎظ ﺑﺘﻠﻚ اﻟﺴﻠﺴﻠﺔ ﻣﻦ اﳊﺮوف‪.‬‬ ‫اﻟﺘﺼﻨﻴﻒ ‪ .NSMutableString‬دﻋﻨﺎ ﻧﺘﺤﺪث ﻋﻦ ﻫﺬﻩ اﻟﺘﺼﻨﻴﻔﺎت‬
‫ﻳﻌﻮد اﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ ﻟﻄﺒﻴﻌﺔ ‪ Objective-C‬اﻟﺘﻲ ﲤﻜﻨﻚ ﻣﻦ‬ ‫ﺣﻴﺚ ﺳﻨﺒﺪأ ﺑﺎﻟﺘﺼﻨﻴﻒ ‪. NSString‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ وﺗﻐﻴﻴﺮ ﻗﻴﻤﺔ اﻟﻜﺎﺋﻨﺎت ﻣﻦ ﺧﻼل اﳌﺆﺷﺮات وﻟﻴﺲ ﻣﻦ‬ ‫]‪[2‬‬
‫ﺧﻼل اﻟﺘﻌﺎﻣﻞ اﳌﺒﺎﺷﺮ‪.‬‬ ‫;‪NSString *favoriteComputer‬‬
‫;”!‪favoriteComputer = @”Mac‬‬
‫;)‪NSLog(favoriteComputer‬‬
‫ﺣﺘﻰ اﻻن ﻛﻞ ﺷﻲء ﺟﻤﻴﻞ‪ ،‬ﻟﻜﻦ ﻣﺎﺑﺎل ذﻟﻚ اﻟﺮﻣﺰ اﻟﻐﺮﻳﺐ‬
‫@ اﻟﺬي ﻳﻈﻬﺮ ﺑﲔ ﺳﻄﻮر ﺷﻔﺮﺗﻨﺎ اﻟﺒﺮﻣﺠﻴﺔ ﻣﻦ ﺣﲔ‬ ‫ﻣﻦ اﶈﺘﻤﻞ ﺟﺪاَ ان ﻳﻜﻮن اﻟﺴﻄﺮ اﻟﺜﺎﻧﻲ ﻣﻔﻬﻮﻣ َﺎ‪ ،‬وﻟﻜﻦ اﻟﺴﻄﺮ‬
‫ﻵﺧﺮ؟‬ ‫اﻻول ]‪ [2.1‬ﻳﺴﺘﺤﻖ ﺑﻌﺾ اﻟﺘﻮﺿﻴﺢ‪.‬‬
‫ﻛﻤﺎ ﺗﻌﻠﻢ ﺗﻌﺪ ﻟﻐﺔ ‪ Objective-C‬اﻣﺘﺪاد ﻣﺘﻄﻮر ﻣﻦ ﻟﻐﺔ ‪ C‬اﻻﺻﻠﻴﺔ‪،‬‬ ‫‪-pointer‬‬‫ﻓﻬﻞ ﺗﺘﺬﻛﺮ ﻋﻨﺪﻣﺎ ﻗﻤﻨﺎ ﺑﺎﻟﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺘﻐﻴﺮ اﳌﺆﺷﺮ‬
‫ﻓﺎﻟﻘﺪﳝﺔ ﻟﻬﺎ ﻃﺮﻳﻘﺘﻬﺎ ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻨﺼﻮص وﺳﻼﺳﻞ اﳊﺮوف‬ ‫‪ ،variable-‬ﻛﺎن ﻋﻠﻴﻨﺎ ﺣﻴﻨﻬﺎ ﲢﺪﻳﺪ ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﺳﻴﺸﺎر‬
‫ﻋﻦ اﳉﺪﻳﺪة‪.‬‬ ‫اﻟﻴﻬﺎ؟ اﻟﻴﻚ اﻻﻳﻌﺎز اﻟﺬي ﻗﻤﻨﺎ ﺑﻪ ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ذﻟﻚ‪ ،‬ﻣﻦ اﻟﻔﺼﻞ‬
‫ﺗﺒﲔ اﻟﻨﻮع اﳊﺪﻳﺚ ﻣﻦ اﻟﻨﺼﻮص و ﺳﻼﺳﻞ اﳊﺮوف‬ ‫وﺣﺘﻰ ﳝﻜﻨﻨﺎ ّ‬ ‫‪.[2] ١١‬‬
‫‪-‬وﻫﻮ ﻧﻮع ﻣﺘﻄﻮر ﺟﺪاَ‪ ،-‬ﺗﻘﻮم ﺑﺎﺳﺘﺨﺪام ‪ Objective-C‬ﻫﺬﻩ‬ ‫]‪[3‬‬
‫;‪int *y‬‬
‫اﻟﻌﻼﻣﺔ @ ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ اﻧﻬﺎ ﻣﻦ اﻟﻨﻮع اﳉﺪﻳﺪ ‪-‬ﺗﻨﻄﻖ ﻫﺬﻩ ﺻﻮﺗﻴ َﺎ‬
‫ﺑﻘﻮل "‪."At‬‬ ‫اﳌﺠﻤﻊ ﺑﺎن ﻣﺘﻐﻴﺮ اﳌﺆﺷﺮ‪ y‬ﻳﺤﺘﻮي ﻋﻨﻮان ﳊﻴﺰ ﻣﻦ‬
‫ﻟﻘﺪ اﻋﻠﻤﻨﺎ ّ‬
‫اﻟﺬاﻛﺮة‪ .‬ﺣﻴﺚ ﺗﻮﺟﺪ ﻗﻴﻤﺔ ﻋﺪدﻳﺔ ﺻﺤﻴﺤﺔ ﻣﺨﺰﻧﺔ ﻫﻨﺎك‪.‬‬
‫ﺗﺮى ﻣﺎ اﻟﺘﻄﻮﻳﺮ اﻟﺬي اوﺟﺪﺗﻪ ‪ Objective-C‬ﻓﻲ‬
‫اﻟﻨﺼﻮص وﺳﻼﺳﻞ اﳊﺮوف ﻋﻦ ﺳﺎﺑﻘﺘﻬﺎ ﻟﻐﺔ ‪C‬؟‬ ‫اﳌﺠﻤﻊ ﺑﺎن اﳌﺘﻐﻴﺮ اﳌﺆﺷﺮ ﻫﺬا ﻳﺸﻴﺮ اﻟﻰ ﻋﻨﻮان‬
‫ﻓﻲ اﳌﺜﺎل ﻧﺤﻦ ﻧﺨﺒﺮ ّ‬
‫ﺑﺤﻴﺰ اﻟﺬاﻛﺮة ﺣﻴﺚ ﻳﻮﺟﺪ ﻛﺎﺋﻦ ﻣﻦ ﻧﻮع ‪. NSString‬‬
‫‪٨٤‬‬
‫]‪[5‬‬ ‫َ‬
‫اوﻻ ‪ Objective-C‬ﺗﺴﺘﺨﺪم ﺳﻼﺳﻞ ﺣﺮوف ‪ Unicode‬اﻟﺸﺎﻣﻠﺔ‬
‫)][‪int main (int argc, const char *argv‬‬ ‫ﺑﻌﻜﺲ ﺳﻼﺳﻞ ﺣﺮوف ‪ ASCII‬اﶈﺪودة اﳌﺴﺘﺨﺪﻣﻪ ﺑﻠﻐﺔ ‪. C‬‬
‫{‬
‫= ‪NSAutoreleasePool * pool‬‬ ‫ان ﺳﻼﺳﻞ ﺣﺮوف ‪ Unicode‬اﻟﺸﺎﻣﻠﺔ ﲤﻜﻨﻚ ﻣﻦ ﻋﺮض اي ﺳﻠﺴﻠﺔ‬
‫;]‪[[NSAutoreleasePool alloc] init‬‬ ‫ﻧﺼﻴﺔ ﺑﺄي ﻟﻐﺔ ﺣﻴﺔ ﺗﺘﺨﻴﻠﻬﺎ ﻣﻦ ﻛﺎﻟﺮوﺳﻴﺔ‪ ،‬اﻟﺼﻴﻨﻲ‪ ،‬اﻟﻌﺮﺑﻴﺔ‪،‬‬
‫;‪NSString *x‬‬ ‫ﺑﺎﻻﺿﺎﻓﺔ اﻟﻰ اﻟﻼﺗﻴﻨﻴﺔ ‪ Roman alphabet‬ﻃﺒﻌ َﺎ!‬
‫]‪x = @”iBook”; // [5.7‬‬
‫‪x = @”MacBook Pro Intel”; // Hey, I’m‬‬ ‫ﺑﺎﻟﺘﺄﻛﻴﺪ ﳝﻜﻨﻚ اﻟﺘﺼﺮﻳﺢ وﺗﻬﺌﻴﺔ ﻣﺤﺘﻮى ﻣﺘﻐﻴﺮ اﳌﺆﺷﺮ ﺑﺴﻠﺴﻠﺔ‬
‫‪just trying to make‬‬ ‫ﻧﺼﻮص ‪ ،‬دﻓﻌﺔ واﺣﺪة ]‪.[4‬‬
‫‪// this book‬‬
‫!‪look up to date‬‬ ‫]‪[4‬‬
‫;)‪NSLog(x‬‬ ‫;”‪NSString *favoriteActress = @”Julia‬‬
‫}‬ ‫ان ﻣﺘﻐﻴﺮ اﳌﺆﺷﺮ ‪ favoriteActress‬ﻳﺸﻴﺮ اﻟﻰ ﻋﻨﻮان ﺣﻴﺰ ﻣﻦ اﻟﺬاﻛﺮة‬
‫ﺣﻴﺚ ﻳﻮﺟﺪ ذﻟﻚ اﻟﻜﺎﺋﻦ اﻟﺬي ﳝﺜﻞ وﻳﺤﺘﻔﻆ ﺑﺎﻟﺴﻠﺴﺔ اﻟﻨﺼﻴﺔ‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﻫﺬا اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻚ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫”‪. “Julia‬‬
‫‪MacBook Pro Intel‬‬
‫ﻣﺎ ان ﺗﻨﺘﻬﻲ ﻣﻦ ﺗﻬﺌﻴﺔ اﳌﺘﻐﻴﺮ )‪ favoriteComputer‬ﻓﻲ ﻣﺜﺎﻟﻨﺎ(‪،‬‬
‫ﺗﺪﻋﻰ‬ ‫‪NSString‬‬ ‫ان اي ﺳﻠﺴﻠﺔ ﺣﺮوف ﻣﻦ ﺳﻼﻟﺔ اﻟﺘﺼﻨﻴﻒ‬
‫ﳝﻜﻨﻚ ﻋﻨﺪﻫﺎ إﺳﻨﺎد ﻗﻴﻤﺔ أﺧﺮى اﻟﻴﻪ‪ ،‬ﻻﺣﻆ اﻧﻚ ﻟﻦ ﺗﻜﻮن ﻗﺎدر‬
‫‪ immutable،‬ﲟﻌﻨﻰ اﻧﻬﺎ ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﻴﺮ واﻟﺘﻌﺪﻳﻞ‪.‬‬
‫ﻋﻠﻰ ﺗﻐﻴﻴﺮ ﺳﻠﺴﻠﺔ اﻟﻨﺺ ذاﺗﻬﺎ ]‪ [3‬وﻳﻌﻮد اﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ ﻛﻮن‬
‫ﻣﺎﻟﻔﺎﺋﺪة ﻣﻦ وﺟﻮد ﺳﻠﺴﻠﺔ ﺣﺮوف ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﻴﻴﺮ؟‬ ‫ﻫﺬﻩ اﻟﺴﻠﺴﻠﺔ اﻟﻨﺼﻴﺔ ﺳﻠﻴﻠﺔ اﻟﺘﺼﻨﻴﻒ ‪ NSString‬ﺑﺴﻠﺴﻠﺔ اﻟﻮراﺛﺔ‪.‬‬
‫ﺑﺼﺮاﺣﺔ‪ ،‬ﻳﻜﻮن ﺗﻌﺎﻣﻞ اﻟﻨﻈﺎم ﻣﻊ ﺳﻼﺳﻞ اﳊﺮوف اﻟﻐﻴﺮ ﻗﺎﺑﻠﺔ‬ ‫و ﺳﻨﺘﺤﺪث ﻋﻦ ذﻟﻚ ﺧﻼل دﻗﻴﻘﺔ‪.‬اﻻن ﺗﺎﺑﻊ اﻟﻘﺮاءة‪...‬‬
‫ﻟﻠﺘﻌﺪﻳﻞ اﻳﺴﺮ واﺳﻬﻞ‪ ،‬ﳑﺎ ﻳﻌﻨﻰ ان ﺑﺮﻧﺎﻣﺠﻚ ﺳﻴﻜﻮن اﺳﺮع‪ .‬ﻓﻲ‬
‫‪٨٥‬‬
‫اﻟﻮاﻗﻊ ﺳﺘﺮى اﺛﻨﺎء ﻛﺘﺎﺑﺘﻚ ﻟﻠﺒﺮاﻣﺞ ﻣﺴﺘﺨﺪﻣ َﺎ ‪ Objective-C‬أﻧﻚ‬

‫;”!‪foo = @”Julia‬‬ ‫ﻏﻴﺮ ﻣﻀﻄﺮ ﻟﺘﻌﺪﻳﻞ اي ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ ﻓﻲ ﻛﺜﻴﺮ ﻣﻦ اﻻﺣﻴﺎن‪.‬‬
‫]‪theLength = [foo length]; // [6.10‬‬
‫;)‪NSLog(@”The length is %d.”, theLength‬‬ ‫وﺑﺎﻟﺘﺄﻛﻴﺪ ﻫﻨﺎك اوﻗﺎت ﺳﺘﺤﺘﺎج ﻓﻴﻬﺎ ان ﺗﻘﻮم ﺑﺘﻌﺪﻳﻞ وﺗﻐﻴﻴﺮ‬
‫ﺳﻠﺴﻠﺔ ﺣﺮﻓﻴﺔ‪ .‬ﻟﺬا ﰎ اﻳﺠﺎد ﺗﺼﻨﻴﻒ ﺧﺎص ﻳﻘﻮم ﺑﺬﻟﻚ‪ ،‬ﺣﻴﺚ‬
‫;‪return 0‬‬ ‫ﺳﻴﻤﻜﻨﻚ ﻣﻦ ﺗﻌﺪﻳﻞ ﻛﺎﺋﻦ اﻟﻨﺺ ﺑﻜﻞ ﻳﺴﺮ وﺳﻬﻮﻟﺔ‬
‫}‬
‫ﻫﺬا اﻟﺘﺼﻨﻴﻒ ﻣﻌﺮوف ﺑﺎﺳﻢ ‪. NSMutableString‬‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻚ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫وﺳﻮف ﻧﻨﺎﻗﺶ ﻃﺮﻳﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻻﺣﻘ َﺎ ﺑﻬﺬا اﻟﻔﺼﻞ‪.‬وﻟﻜﻦ دﻋﻨﺎ‬
‫‪The length is 6.‬‬
‫اوﻻ ﻧﺆﻛﺪ ﻟﻚ ان ﺳﻼﺳﻞ اﳊﺮوف اﳕﺎ ﻫﻰ ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻨﺎت‪.‬‬ ‫َ‬
‫ﳝﻴﻞ اﳌﺒﺮﻣﺠﲔ ﻻﺳﺘﺨﺪام ﻣﻔﺮدﺗﻲ ‪ foo‬و ‪ bar‬ﻛﺄﺳﻤﺎء ﻟﻠﻤﺘﻐﻴﺮات‬ ‫ذﻟﻚ ﻳﻌﻨﻲ اﻣﻜﺎﻧﻴﺔ اﺳﺘﻘﺒﺎﻟﻬﺎ ﻟﻠﺮﺳﺎﺋﻞ‪.‬‬
‫اﺛﻨﺎء ﺷﺮﺣﻬﻢ ﻟﻠﻤﻮاﺿﻴﻊ اﳌﺘﻌﻠﻘﺔ ﺑﺎﻟﺒﺮﻣﺠﺔ‪.‬ﻓﻲ اﻟﻮاﻗﻊ ﺗﻠﻚ‬
‫ﻛﻤﺜﺎل‪ ،‬ﳝﻜﻨﻨﺎ ارﺳﺎل اﻟﺮﺳﺎﻟﺔ ‪ length‬اﻟﻰ ﻛﺎﺋﻦ ﺳﻠﺴﻠﺔ اﳊﺮوف‬
‫اﳌﺴﻤﻴﺎت ﺳﻴﺌﺔ ﺟﺪاَ‪ ،‬ﻳﻌﻮد اﻟﺴﺒﺐ ﻓﻲ ذﻟﻚ ﻟﻜﻮﻧﻬﺎ ﻏﻴﺮ ذات‬
‫ﻛﻤﺎ ﻳﻠﻲ ﺑﺎﳌﺜﺎل]‪. [6‬‬
‫دﻻﻟﺔ ﻓﻼ ﻣﻌﻨﻰ‪ ،‬اﻧﻬﺎ ﻣﺜﻞ اﺳﺘﺨﺪاﻣﻨﺎ ﻟﻠﻤﺘﻐﻴﺮ ‪ .x‬وﻟﻜﻨﻨﺎ ﺗﻌﺮﺿﻨﺎ‬
‫]‪[6‬‬
‫ﻟﻬﺎ ﻫﻨﺎ ﺣﺘﻰ ﻻﺗﺸﻌﺮ ﺑﺎﳊﻴﺮة ﻣﻦ اﻣﺮك ﻋﻨﺪﻣﺎ ﺗﺮاﻫﺎ ﻓﻲ ﻧﻘﺎﺷﺎت‬ ‫>‪#import <Foundation/Foundation.h‬‬
‫وﻣﺤﺎورات اﻻﻧﺘﺮﻧﺖ‪.‬‬
‫ﻓﻲ اﻟﺴﻄﺮ ]‪ [6.10‬ﻗﻤﻨﺎ ﺑﺎرﺳﺎل رﺳﺎﻟﺔ ‪ length‬اﻟﻰ اﻟﻜﺎﺋﻦ ‪،foo‬‬ ‫{‬
‫اﻟﺮﺳﺎﻟﺔ ﺗﻠﻚ ﻋﺒﺎرة ﻋﻦ إﺟﺮاء ‪ method‬ﻣﺼﺮح ﻋﻨﻪ ﺑﺎﺳﻢ ‪length‬‬
‫= ‪NSAutoreleasePool * pool‬‬
‫ﻓﻲ ﺗﺼﻨﻴﻒ ‪ NSString class‬ﻛﻤﺎ ﻳﻠﻲ‪:‬‬ ‫;‪int theLength‬‬
‫;‪NSString * foo‬‬
‫‪- (unsigned int)length‬‬
‫‪// Continued‬‬
‫‪٨٦‬‬
‫;‪NSString *foo, *bar‬‬

‫اﻧﻪ إﺟﺮاء ﻳﻌﻮد ﺑﻘﻴﻤﺔ ﻋﺪدﻳﺔ ﲤﺜﻞ إﺣﺼﺎء ﻟﻌﺪد اﳊﺮوف اﳌﻮﺟﻮدة‬
‫;”!‪foo = @”Julia‬‬ ‫ﺑﺴﻠﺴﻠﺔ اﳊﺮوف‪ .‬وﳝﻜﻨﻚ إﻳﻀ َﺎ ﺗﻐﻴﻴﺮ اﳊﺮوف اﳌﻮﺟﻮدة ﺑﺎﻟﺴﻠﺴﻠﺔ‬
‫;]‪bar = [foo uppercaseString‬‬
‫‪NSLog(@”%@ is converted into %@.”, foo,‬‬
‫اﻟﻰ ﺣﺮوف ﻛﺒﻴﺮة ‪. uppercase‬‬
‫;)‪bar‬‬ ‫وﻟﺘﺤﻘﻴﻖ ذﻟﻚ ارﺳﻞ اﻟﺮﺳﺎﻟﺔ اﳌﻨﺎﺳﺒﺔ ﻟﻜﺎﺋﻦ ﺳﻠﺴﻠﺔ اﳊﺮوف ‪،‬‬
‫;]‪[pool release‬‬ ‫ﻧﻌﻨﻲ ﺑﺬﻟﻚ إﺟﺮاء ‪ uppercaseString‬اﻟﺬي ﳝﻜﻨﻚ اﻟﺒﺤﺚ ﻋﻨﻪ‬
‫;‪return 0‬‬ ‫واﻻﻃﻼع ﻋﻠﻰ ﻃﺮﻳﻘﺔ ﺗﻨﻔﻴﺬﻩ ﻣﻦ ﺧﻼل ﻗﺮاءة وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة‬
‫}‬
‫ﻣﻌﺘﻤﺪاَ ﻋﻠﻰ ﻧﻔﺴﻚ ﻫﺬﻩ اﳌﺮة )وﺗﻔﺤﺺ اﻻﺟﺮاءات اﻟﺘﻲ ﻳﻘﺪﻣﻬﺎ‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻚ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬ ‫ﻟﻚ ﺗﺼﻨﻴﻒ ‪.( NSString‬‬
‫!‪Julia! is converted into JULIA‬‬
‫ﻓﻮر ﺗﻠﻘﻴﻪ ﻟﻠﺮﺳﺎﻟﺔ‪ ،‬ﻳﻘﻮم ﻛﺎﺋﻦ ﺳﻠﺴﻠﺔ اﳊﺮوف ﺑﺈﻧﺸﺎء وإرﺟﺎع ﻛﺎﺋﻦ‬
‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻗﺪ ﺗﺮﻏﺐ ﺑﺘﻐﻴﻴﺮ ﻣﺤﺘﻮى ﻣﻮﺟﻮد ﺳﺎﺑﻘ َﺎ َ‬
‫ﺑﺪﻻ ﻣﻦ‬ ‫ﺳﻠﺴﻠﺔ ﺣﺮوف ﺟﺪﻳﺪ ﻳﺤﻮي ﻧﻔﺲ اﶈﺘﻮى وﻟﻜﻦ ﰎ ﲢﻮﻳﻞ اﻻن‬
‫ان ﺗﻨﺶء ﻣﺤﺘﻮى ﺟﺪﻳﺪ‪ .‬ﻓﻲ ﻣﺜﻞ ﻫﺬﻩ اﳊﺎﻟﺔ ﻋﻠﻴﻚ ﺑﺎﺳﺘﺨﺪام‬ ‫ﻛﻞ ﺣﺮف ﺻﻐﻴﺮ ‪ small letter‬إﻟﻰ ﻣﺎ ﻳﻘﺎﺑﻠﺔ ﻣﻦ اﳊﺮوف اﻟﻜﺒﻴﺮة‬
‫اﻟﻜﺎﺋﻦ اﻟﺬي ﻳﺄت ﻣﻦ ﺳﻼﻟﺔ اﻟﺘﺼﻨﻴﻒ ‪ NSMutableString‬ﺣﺘﻰ‬ ‫‪.Capital Letter‬‬
‫ﻳﺘﻢ ﻋﺮض اﻟﻨﺺ اﳉﺪﻳﺪ‪ .‬ﻓﺎﻟﺘﺼﻨﻴﻒ ‪ NSMutableString‬ﻳﻮﻓﺮ‬ ‫]‪[7‬‬
‫ﻟﻚ ﻋﺪة إﺟﺮاءات ﲤﻜ ّﻨﻚ ﻣﻦ ﺗﻌﺪﻳﻞ ﻣﺤﺘﻮى ﺳﻠﺴﻠﺔ اﳊﺮوف‪.‬‬ ‫>‪#import <Foundation/Foundation.h‬‬
‫ﻛﻤﺜﺎل‪ ،‬ﲡﺪ أن اﻹﺟﺮاء ‪ appendString:‬ﻳﻘﻮم ﺑﺈﺿﺎﻓﺔ ﺳﻠﺴﻠﺔ‬ ‫)][‪int main (int argc, const char * argv‬‬
‫ﺣﺮوف اﻟﻰ ﻧﻬﺎﻳﺔ ﺳﻠﺴﻠﺔ ﺣﺮوف اﻟﻜﺎﺋﻦ اﳌﺴﺘﻘﺒﻞ ﻟﻠﺮﺳﺎﻟﺔ‪.‬‬ ‫{‬
‫= ‪NSAutoreleasePool *pool‬‬
‫‪//...Continued‬‬
‫‪٨٧‬‬
‫ﻛﺎن اﳌﺘﻐﻴﺮ ‪ foo‬ﻣﺸﻴﺮاَ اﻟﻰ ﺳﻠﺴﻠﺔ ﺣﺮوف ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ ﻛﺎﻧﺖ‬ ‫]‪[8‬‬
‫ﲢﺘﻮى ”!‪.“Julia‬‬
‫ﻓﻲ ﺑﺪاﻳﺔ ﻓﺼﻠﻨﺎ ﻫﺬا اوﺿﺤﻨﺎ اﻻ ﻳﻜﻮن ﻫﻨﺎك اي ﺗﻌﺎﻣﻞ ﻣﻊ ﻛﺎﺋﻨﺎت‬ ‫{‬
‫‪ Objective-C‬ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ‪ .‬وان اي ﻋﻤﻠﻴﺎت ﺗﺪاول أو ﺗﻌﺎﻣﻞ ﻣﻊ‬ ‫= ‪NSAutoreleasePool *pool‬‬
‫اﻟﻜﺎﺋﻨﺎت ﻳﺘﻢ ﻣﻦ ﺧﻼل اﳌﺆﺷﺮات‪ .‬واﻟﻴﻚ ﺳﺒﺐ ذﻟﻚ ‪،‬ﻓﻨﺤﻦ ﻗﺪ‬
‫اﺳﺘﺨﺪﻣﻨﺎ ﻣﺘﻐﻴﺮ ﻣﺆﺷﺮ ﺑﺎﻟﺴﻄﺮ ]‪ .[8.7‬ﻓﻲ اﻟﻮاﻗﻊ ﻋﻨﺪﻣﺎ اﺳﺘﺨﺪﻣﻨﺎ‬ ‫;‪NSMutableString *foo‬‬
‫]‪// [8.7‬‬
‫ﻣﻔﺮدة ”ﻛﺎﺋﻦ‪ “object-‬إﳕﺎ ﻋﻨﻴﻨﺎ ﺑﺬﻟﻚ ”ﻣﺆﺷﺮ ﻟﻠﻜﺎﺋﻦ ‪pointer‬‬ ‫;]‪foo = [@”Julia!” mutableCopy‬‬
‫‪.“to an object‬‬ ‫]‪// [8.8‬‬
‫;]”‪[foo appendString:@” I am happy‬‬
‫وﻃﺎﳌﺎ اﻧﻨﺎ ﻧﺴﺘﺨﺪم اﻟﻜﺎﺋﻨﺎت ﺑﺎﳌﺆﺷﺮات دوﻣ َﺎ‪ ،‬ﻓﻘﺪ اﺳﺘﺨﺪﻣﻨﺎ ﻛﻠﻤﺔ‬ ‫;)‪NSLog(@”Here is the result: %@.”, foo‬‬
‫”ﻛﺎﺋﻦ‪ “object-‬إﺧﺘﺼﺎراَ‪ .‬ان ﺣﻘﻴﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺎﺋﻨﺎت ﻣﻦ‬ ‫;]‪[pool release‬‬

‫ﺧﻼل اﳌﺆﺷﺮات ﻟﻪ ﺟﺎﻧﺐ آﺧﺮ‪ ،‬وﻣﻦ اﳌﻬﻢ ﺟﺪاَ اﺳﺘﻴﻌﺎﺑﻪ‪:‬‬ ‫;‪return 0‬‬
‫}‬
‫ﳝﻜﻦ ﻟﻌﺪة ﻣﺘﻐﻴﺮات ان ﺗﻜﻮن ﳑﺜﻠﺔ ‪-reference-‬‬
‫ﻟﻜﺎﺋﻦ ﻣﻦ اﻟﻜﺎﺋﻨﺎت ﻓﻲ وﻗﺖ واﺣﺪ‪.‬‬ ‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻚ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Here is the result: Julia! I am happy.‬‬
‫ﻛﻤﺜﺎل‪ ،‬ﺑﻌﺪ ان ﰎ ﺗﻨﻔﻴﺬ اﻟﺴﻄﺮ ]‪ ،[8.7‬اﺻﺒﺢ ﻣﺘﻐﻴﺮ اﳌﺆﺷﺮ ‪foo‬‬ ‫ﻓﻔﻲ اﻟﺴﻄﺮ ]‪ ، [8.8‬ﻗﺎم اﻻﺟﺮاء ‪) mutableCopy‬وﻫﻮ ﻣﻦ اﻻﺟﺮاءات‬
‫ﻼ ﻟﻜﺎﺋﻦ ﻳﺤﺘﻮي ﺳﻠﺴﻠﺔ اﳊﺮوف اﳌﻜﻮﻧﺔ ﻟﻜﻠﻤﺔ ”‪،“!Julia‬‬ ‫ﳑُ ﺜ َ‬ ‫اﻟﺘﻲ ﻳﻘﺪﻣﻬﺎ ﻟﻚ ﺗﺼﻨﻴﻒ ‪ (NSString‬ﺑﺈﻧﺸﺎء وإرﺟﺎع ﺳﻠﺴﻠﺔ‬
‫ﻫﺬﻩ اﻻﻣﺮ ﳝﻜﻦ ﲡﺴﻴﺪة ﻋﻠﻰ اﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ‪:‬‬ ‫ﺣﺮوف ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ ﺑﻨﻔﺲ ﻣﺤﺘﻮى ﺳﻠﺴﻠﺔ اﳊﺮوف اﻟﻜﺎﺋﻦ‬
‫اﳌﺴﺘﻘﺒﻞ‪ .‬وذﻟﻚ ﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣﻦ ﺗﻨﻔﻴﺬ اواﻣﺮ اﻟﺴﻄﺮ ]‪ ، [8.8‬ﺣﻴﺚ‬
‫‪٨٨‬‬
Xcode ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ‬ ‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬
:‫وﻫﺬا اﻻﻣﺮ ﻣﻮﺿﺢ ﺑﻬﺬا اﳌﺜﺎل‬

[9]
int main (int argc, const char * argv[])

{ .‫اﻟﺘﻌﺎﻣﻞ واﻟﺘﺪاول ﻣﻊ اﻟﻜﺎﺋﻨﺎت ﻳﺘﻢ ﻣﻦ ﺧﻼل اﳌﺆﺷﺮات دوﻣ َﺎ‬
NSAutoreleasePool *pool =
[[NSAutoreleasePool alloc] init]; :‫ ﻛﻤﺎ ﻳﻠﻲ‬bar ‫ اﻟﻰ اﳌﺘﻐﻴﺮ‬foo ‫اﻻن ﻟﻨﻔﺘﺮض اﺳﻨﺎدﻧﺎ ﻗﻴﻤﺔ اﳌﺘﻐﻴﺮ‬
NSMutableString *foo = [@”Julia!” bar = foo;
mutableCopy];
NSMutableString *bar = foo; .‫ ان ﻛﻼ اﳌﺘﻐﻴﺮان ﺳﻴﺸﻴﺮان اﻟﻰ ﻧﻔﺲ اﻟﻜﺎﺋﻦ‬،‫ﻧﺘﻴﺠﺔ ﻫﺬا اﻻﻳﻌﺎز‬
NSLog(@”foo points to the string: %@.”,
foo);
NSLog(@”bar points to the string: %@.”,
bar);
NSLog(@”------------------------------”);
[foo appendString:@” I am happy”];
NSLog(@”foo points to the string: %@.”,

foo);
NSLog(@”bar points to the string: %@.”,
bar); .‫ﳝﻜﻦ ﻟﻌﺪة ﻣﺘﻐﻴﺮات ان ﺗﺸﻴﺮ اﻟﻰ ﻧﻔﺲ اﻟﻜﺎﺋﻦ‬
[pool release]; ‫ ﻋﻨﺪﻣﺎ ﻧﺮﻏﺐ ﺑﺎرﺳﺎل رﺳﺎﻟﺔ اﻟﻰ اﻟﻜﺎﺋﻦ ﻣﻦ ﺧﻼل‬،‫ﻓﻲ ﻫﺬﻩ اﳊﺎﻟﺔ‬
return 0; ‫[ ( ﺳﻴﻜﻮن اﻻﺛﺮ ذاﺗﺔ‬foo dosomething];‫ )ﻛﺄن ﻧﻘﻮل‬foo ‫اﳌﺆﺷﺮ‬
}
،([bar dosomething]; ‫ ﻛﺄن ﻧﻘﻮل‬bar ‫ﻛﻤﺎ ﻟﻮ ﻗﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام‬
٨٩
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻚ ﻣﺎ ﻳﻠﻲ ‪:‬‬

‫!‪foo points to the string: Julia‬‬
‫!‪bar points to the string: Julia‬‬
‫‪------------------------------‬‬
‫‪foo points to the string: Julia! I am‬‬
‫‪happy‬‬
‫‪bar points to the string: Julia! I am‬‬
‫‪happy‬‬
‫ان ﺗﻜﻮن ﻟﻚ اﻟﻘﺪرة ﻋﻠﻰ ﲤﺜﻴﻞ )او اﻻﺷﺎرة اﻟﻰ( ﻧﻔﺲ اﻟﻜﺎﺋﻦ ﻣﻦ‬
‫ﻋﺪة اﻣﺎﻛﻦ‪ ،‬ذﻟﻚ ﻳﻌﺪ ﻣﻴﺰة ﻣﻦ اﻫﻢ ﳑﻴﺰات اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت‪.‬‬
‫ﻓﻲ اﻟﻮاﻗﻊ ﻟﻘﺪ ﻗﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام ﻫﺬﻩ اﳋﺎﺻﻴﺔ ﻓﻲ اﻟﻔﺼﻮل اﻟﺴﺎﺑﻘﺔ‪.‬‬
‫ﻼ‪ ،‬ﻗﻤﻨﺎ ﺑﺘﻤﺜﻴﻞ اﻟﻜﺎﺋﻦ ‪ MAFoo‬ﻣﻦ ﺧﻼل‬ ‫ﻓﻔﻲ اﻟﻔﺼﻞ ‪ ٨‬ﻣﺜ َ‬
‫ﻛﺎﺋﻨﻲ اﻻزرارﻳﻦ‪.‬‬
‫‪٩٠‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫اﳌﺼﻔﻮﻓﺎت‬
‫اﳌﺼﻔﻮﻓﺎت‬
‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﻳﺘﻄﻠﺐ اﻻﻣﺮ ﻣﻨﻚ ان ﲢﺘﻔﻆ ﲟﺠﻤﻮﻋﺔ ﻣﺘﺠﺎﻧﺴﺔ‬
‫ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪ .‬ﻛﺄن ﲢﺘﻔﻆ ﺑﻘﺎﺋﻤﺔ ﻣﻦ ﺳﻼﺳﻞ اﳊﺮوف ﻣﺜ َ‬
‫ﻼ‪ .‬وﻗﺪ‬
‫ﻳﻜﻮن اﳊﻞ اﻟﻐﻴﺮ ﻋﻤﻠﻲ ان ﻧﻨﺸﻲء ﻣﺘﻐﻴﺮات ﻋﺪﻳﺪة ﺑﺤﻴﺚ ﻳﺤﺘﻔﻆ‬
‫ﻛﻞ ﻣﺘﻐﻴﺮ ﻣﻨﻬﺎ ﺑﺴﻠﺴﻠﺔ ﺣﺮوف‪ .‬وﻟﻜﻦ اﳊﻞ اﻻﻓﻀﻞ وﺑﺎﻟﺘﺄﻛﻴﺪ‬
‫اﻟﻌﻤﻠﻲ‪ ،‬ﻫﻮ ان ﻧﺴﺘﺨﺪم اﳌﺼﻔﻮﻓﺔ ‪. -Array-‬‬
‫ﻓﺎﳌﺼﻔﻮﻓﺔ ﻋﺒﺎرة ﻋﻦ ﻗﺎﺋﻤﺔ ﻣﺮﺗﺒﺔ ﻣﻦ اﻟﻜﺎﺋﻨﺎت‬

‫)أو ﻣﺆﺷﺮات ﻟﻠﻜﺎﺋﻨﺎت ﻋﻠﻰ وﺟﻪ اﻟﺪﻗﺔ(‪.‬‬
‫ﺣﻴﺚ ﳝﻜﻨﻚ اﺿﺎﻓﺔ اﻟﻜﺎﺋﻨﺎت ﺑﺎﳌﺼﻔﻮﻓﺔ أو ﺣﺬف ﺗﻠﻚ اﻟﻜﺎﺋﻨﺎت‬

‫أو ان ﺗﺴﺘﻌﻠﻢ اﳌﺼﻔﻮﻓﺔ ﻋﻦ ذﻟﻚ اﻟﻜﺎﺋﻦ ﺑﺮﻗﻤﻪ اﻟﺘﺴﻠﺴﻠﻲ )‪index‬‬
‫اﻟﺮﻗﻢ اﻟﺬي ﻳﺤﺪد ﻣﻮﻗﻊ ﺗﺮﺗﻴﺐ اﻟﻜﺎﺋﻦ ﺑﻘﺎﺋﻤﺔ اﳌﺼﻔﻮﻓﺔ(‪ ،‬ﳝﻜﻨﻚ‬
‫اﻳﻀ َﺎ ان ﺗﺴﺘﻌﻠﻢ اﳌﺼﻔﻮﻓﺔ ﻋﻦ اﻟﻌﺪد اﻻﺟﻤﺎﻟﻲ ﻟﻠﻜﺎﺋﻨﺎت اﻟﺘﻲ‬
‫ﲢﺘﻔﻆ ﺑﻬﺎ‪.‬‬
‫وﻋﻨﺪﻣﺎ ﻧﻘﻮم ﺑﺎﺟﺮاء ﻋﻤﻠﻴﺔ ﺗﻌﺪاد ﻟﻠﻌﻨﺎﺻﺮ ﻓﺈﻧﻨﺎ دوﻣ َﺎ ﻧﺒﺪأ ﻋﻤﻠﻴﺔ‬
‫اﻟﻌﺪ إﺑﺘﺪا َء ﺑﺎﻟﺮﻗﻢ ‪ ١‬ﺛﻢ ‪ ٢‬ﺛﻢ ‪..٣‬اﻟﺦ‪.‬‬
‫‪٩١‬‬
‫اﳌﺼﻔﻮﻓﺎت‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﺷﺮح اﻟﻨﺴﺨﺔ اﻟﻘﺎﺑﻠﺔ ﻟﻠﺘﻌﺪﻳﻞ‪ .‬وﻫﻨﺎك ﻃﺮﻳﻘﺔ واﺣﺪة ﻹﻧﺸﺎء‬ ‫أﻣﺎ ﻓﻲ اﳌﺼﻔﻮﻓﺎت ﻋﻠﻰ أﻳﺔ ﺣﺎل اﻻﻣﺮ ﻣﺨﺘﻠﻒ ﻓﺎﻟﻌﻨﺼﺮ اﻻول‬
‫اﳌﺼﻔﻮﻓﺔ‪ ،‬وﻫﻲ ﺗﺘﻢ ﺑﺎﻻﻳﻌﺎز اﻟﺘﺎﻟﻲ‪:‬‬ ‫ﻳﺒﺪأ ﺑﺎﻟﺮﻗﻢ ﺻﻔﺮ )‪-zero index‬وﻫﻮ اﻟﺮﻗﻢ اﻟﺘﺴﻠﺴﻠﻲ اﻟﺬي ﻳﻘﺎﺑﻞ‬
‫]‪[NSMutableArray array‬‬ ‫اﻟﻌﻨﺼﺮ اﻻول ﺑﺎﻟﻘﺎﺋﻤﺔ( ﻟﺬا ﺳﻴﻜﻮن اﻟﺮﻗﻢ اﻟﺘﺴﻠﺴﻠﻲ ﻟﻠﻌﻨﺼﺮ‬
‫ان ﺗﻨﻔﻴﺬ ﻫﺬ اﻻﻳﻌﺎز‪ ،‬ﺳﻴﻌﻮد ﻋﻠﻴﻨﺎ ﲟﺼﻔﻮﻓﺔ ﻓﺎرﻏﺔ‪ .‬وﻟﻜﻦ ﳊﻈﺔ‪...‬‬ ‫اﻟﺜﺎﻧﻲ ﻳﺴﺎوي ‪ ١‬ﺛﻢ اﻟﻌﻨﺼﺮ اﻟﺜﺎﻟﺚ ﲟﻘﺎﺑﻞ ﺗﺴﻠﺴﻠﻲ ﻳﺴﺎوي ‪٢‬‬
‫ﻫﺬا اﻻﻳﻌﺎز ﻳﺒﺪو ﻏﺮﻳﺒ َﺎ اﻟﻴﺲ ﻛﺬﻟﻚ؟ اﻧﻪ ﺑﺎﻟﺘﺄﻛﻴﺪ ﻏﺮﻳﺐ ﺟﺪاَ‪،‬‬ ‫‪ ...‬وﻫﻜﺬا‪.‬‬
‫ﻓﻔﻲ ﻫﺬﻩ اﳊﺎﻟﺔ ﻗﻤﻨﺎ ﺑﺎﺳﺘﺨﺪام اﺳﻢ ‪ NSMutableArray‬وﺣﺪدﻧﺎﻩ‬
‫ان ﻳﻜﻮن ﻛﻤﺴﺘﻘﺒﻞ ﻟﻠﺮﺳﺎﻟﺔ‪.‬‬
‫اﻟﻢ ﻳﻜﻦ ﻣﻦ اﳌﻔﺮوض ان ﻧﻘﻮم ﺑﺎرﺳﺎل رﺳﺎﺋﻠﻨﺎ إﻟﻰ ﻣﺴﺘﻨﺴﺦ‬
‫ﻻ ﻣﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺗﺼﻨﻴﻒ اﻟﻜﺎﺋﻦ ‪-‬‬ ‫اﻟﻜﺎﺋﻦ ‪ -instances-‬ﺑﺪ َ‬
‫‪ class-‬؟‬
‫ﻣﺜﺎل ‪ :‬ﻣﺼﻔﻮﻓﺔ ﲢﺘﻮي ﺛﻼﺛﺔ )‪ (٣‬ﺳﻼﺳﻞ ﺣﺮﻓﻴﺔ‪.‬‬
‫ﻓﻲ اﳊﻘﻴﻘﺔ ﻟﻘﺪ ﺗﻌﻠﻤﻨﺎ ﺷﻲء ﺟﺪﻳﺪ‪ :‬اﻧﻬﺎ ﺣﻘﻴﻘﺔ ﻣﻦ ﺣﻘﺎﺋﻖ‬
‫‪ Objective-C‬ﺣﻴﺚ ﺗﺘﻴﺢ ﻟﻨﺎ ارﺳﺎل اﻟﺮﺳﺎﺋﻞ اﻟﻰ اﻟﺘﺼﻨﻴﻔﺎت‬ ‫ﺳﻨﺰودك ﺑﺄﻣﺜﻠﺔ ﻟﻠﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﻻﺣﻘ َﺎ ﺧﻼل ﻫﺬا اﻟﻔﺼﻞ‪،‬‬
‫‪ classes‬اﻻﺻﻠﻴﺔ )ﻳﻌﻮد ﺳﺒﺐ ذﻟﻚ ان اﻟﺘﺼﻨﻴﻔﺎت ‪ classes‬ذاﺗﻬﺎ‬ ‫ﻟﻨﻤﻜﻨﻚ ﻣﻦ ﻣﻼﻣﺴﺔ اﻻﺛﺮ اﻟﺬي ﻳﺤﺪﺛﺔ اﻟﺘﻌﺪاد اﺑﺘﺪا َء ﻣﻦ‬
‫ﻋﺒﺎرة ﻋﻦ ﻛﺎﺋﻨﺎت‪ ،‬وﺑﺪورﻫﺎ ﻫﻲ اﻳﻀ ًﺎ ﻣﺴﺘﻨﺴﺨﺎت ﻳﻄﻠﻖ ﻋﻠﻴﻬﺎ‬ ‫اﻟﺼﻔﺮ‪.‬اﳌﺼﻔﻮﻓﺎت ﺗﺄﺗﻴﻚ ﻛﺘﺼﻨﻴﻔﺎن‪ :‬اﻟﺘﺼﻨﻴﻒ اﻻول ‪NSArray‬‬
‫‪،meta-classes‬وﻟﻜﻨﻨﺎ ﺳﻨﺘﻮﻗﻒ ﻋﻦ ﺷﺮح ﻫﺬﻩ اﻟﻔﻜﺮة ﻟﻌﺪم‬ ‫واﻟﺜﺎﻧﻲ ‪ .NSMutableArray‬ﻛﻤﺎ ﻫﻮ اﳊﺎل ﻣﻊ ﺳﻼﺳﻞ اﳊﺮوف‬
‫ﻣﻨﺎﺳﺒﺘﻬﺎ ﻻن ﺗﻜﻮن ﺑﻜﺘﺎب ﻳﻔﺘﺮض ان ﻳﻜﻮن ﺗﻘﺪﳝﻲ ﻟﻠﻤﺒﺘﺪﺋﲔ‪،‬‬ ‫‪.strings‬‬
‫وﻛﺬﻟﻚ ﺷﺮﺣﻬﺎ ﺳﻴﻄﻮل ﺟﺪا(‪.‬‬ ‫ﻓﻬﻨﺎك ﻧﺴﺨﺔ ﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻟﻠﺘﻐﻴﺮ واﻟﺘﻌﺪﻳﻞ ‪ immutable‬وﻫﻨﺎك ﻧﺴﺨﺔ‬
‫ﻣﻦ وﺛﺎﺋﻖ ‪ ،Cocoa‬ﳒﺪ ان اﻻﺟﺮاءات اﻟﺘﻲ ﻳﺘﻢ ﺗﻨﻔﻴﺬﻫﺎ ﻋﻠﻰ‬ ‫ﻣﻬﻤﺘﻬﺎ اﻟﺘﻐﻴﻴﺮ واﻟﺘﺒﺪﻳﻞ ‪ .mutable‬ﻓﻲ ﻫﺬا اﻟﻔﺼﻞ‪ ،‬ﺳﻨﺴﺘﻬﺪف‬
‫‪٩٢‬‬
‫‪NSMutableArray *myArray = [NSMutableArray‬‬ ‫اﻟﺘﺼﻨﻴﻒ ذاﺗﻪ ﺗﻜﻮن ﺑﺎدﺋﺘﻬﺎ ﺑﺎﻟﺮﻣﺰ ”‪َ “+‬‬
‫ﺑﺪﻻ ﻣﻦ اﻟﺮﻣﺰ ”‪ “-‬اﻟﺒﺎدىء‬
‫;]‪array‬‬
‫اﻣﺎم اﻻﺟﺮاءات اﻟﺘﻲ ﺗﺮﺳﻞ اﻟﻰ اﻟﻜﺎﺋﻨﺎت‪) .‬اﻧﻈﺮ اﳌﺜﺎل ]‪ [4.5‬اﻟﺬي‬
‫;]”‪[myArray addObject:@”first string‬‬
‫;]”‪[myArray addObject:@”second string‬‬
‫ورد ذﻛﺮﻩ ﺑﺎﻟﻔﺼﻞ ‪ .(٨‬وﻛﻤﺜﺎل ﻧﺮى ان اﻟﻮﺛﺎﺋﻖ ﺗﺼﻒ إﺟﺮاءات‬
‫;]”‪[myArray addObject:@”third string‬‬ ‫اﳌﺼﻔﻮﻓﺔ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪array‬‬
‫;]‪int count = [myArray count‬‬
‫‪+ (id)array‬‬
‫‪Creates and returns an empty array. This method is used‬‬
‫‪NSLog(@”There are %d elements in my‬‬
‫‪by mutable subclasses of‬‬
‫;)‪array”, count‬‬
‫‪NSArray.‬‬
‫‪See Also: + arrayWithObject:, + arrayWithObjects:‬‬
‫}‬
‫دﻋﻨﺎ ﻧﻄﺒﻖ ﻣﺎ ﻗﺮأﻧﺎﻩ ﺳﺎﺑﻘ َﺎ ﻣﻦ ﺧﻼل اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ .‬ﻓﺒﺮﻧﺎﻣﺠﻨﺎ‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﺳﻴﻄﺒﻊ ﻟﻨﺎ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‪:‬‬ ‫اﻟﺘﺎﻟﻲ ﺳﻴﻘﻮم ﺑﺈﻧﺸﺎء ﻣﺼﻔﻮﻓﺔ ﻓﺎرﻏﺔ‪ ،‬ﻟﻴﺴﺘﻮدع ﺑﻬﺎ ‪ ٣‬ﺳﻼﺳﻞ‬
‫‪There are 3 elements in my array‬‬
‫ﺣﺮﻓﻴﺔ‪ ،‬ﺛﻢ ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ اﻟﻌﺪد اﳌﻤﺜﻞ ﳌﺠﻤﻮع اﻟﻌﻨﺎﺻﺮ ﺑﺎﳌﺼﻔﻮﻓﺔ‪.‬‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ اﻟﺘﺎﻟﻲ ﻣﺸﺎﺑﻪ ﳌﺎ ﻗﺒﻠﻪ اﻻ ان ﻫﺬا ﺳﻮف ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ‬ ‫]‪[1‬‬
‫ﺳﻠﺴﻠﺔ اﳊﺮوف اﳌﻮﺟﻮدة ﺑﺎﻟﺘﺴﻠﺴﻠﻲ )ﺻﻔﺮ( داﺧﻞ اﳌﺼﻔﻮﻓﺔ ‪-‬‬ ‫>‪#import <Foundation/Foundation.h‬‬
‫اي اﻟﻌﻨﺼﺮ اﻻول‪ .-‬ﺣﺘﻰ ﻧﺘﻤﻜﻦ ﻣﻦ اﻟﻮﺻﻮل ﻟﻌﻨﺼﺮ ﺑﺎﳌﺼﻔﻮﻓﺔ‬ ‫)][‪int main (int argc, const char * argv‬‬
‫ﻧﺴﺘﺨﺪم اﻻﺟﺮاء ‪ objectAtIndex:‬ﻛﻤﺎ ﻳﻠﻲ]‪:[2.13‬‬ ‫{‬
‫= ‪NSAutoreleasePool *pool‬‬
‫‪//...Contined‬‬
‫‪٩٣‬‬
‫اﳌﺼﻔﻮﻓﺎت‬ Xcode ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ‬
‫ﺳﻴﺘﻄﻠﺐ ﻣﻨﻚ داﺋﻤﺎ ان ﺗﺴﺒﺮ اﳌﺼﻔﻮﻓﺔ ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﻋﻤﻞ‬ [2]

‫ وﻟﻠﻘﻴﺎم ﺑﺬﻟﻚ ﳝﻜﻨﻚ‬.‫اي إﺟﺮاءات ﻋﻠﻰ اي ﻋﻨﺎﺻﺮ ﻣﺴﺘﻮدﻋﺔ ﺑﻬﺎ‬
‫اﺳﺘﺨﺪام ﺣﻠﻘﺎت اﻟﺘﻜﺮار ﻛﻤﺎ ﺳﻨﺮى ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ اﻟﺬي‬ int main (int argc, const char * argv[])
{
‫ﺳﻮف ﻳﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﺤﺘﻮى ﻛﻞ ﻣﺎ ﺳﻴﻘﺎﺑﻠﺔ ﻣﻦ ﻋﻨﺎﺻﺮ ﻣﺴﺘﻮدﻋﺔ‬ NSAutoreleasePool *pool =
.‫داﺧﻞ اﳌﺼﻔﻮﻓﺔ‬ [[NSAutoreleasePool alloc] init];
[3] NSMutableArray *myArray = [NSMutableArray

#import <Foundation/Foundation.h> array];
int main (int argc, const char * argv[]) [myArray addObject:@”first string”];
{ [myArray addObject:@”second string”];
NSAutoreleasePool *pool = [myArray addObject:@”third string”];
[[NSAutoreleasePool alloc] init];
NSString *element = [myArray
NSMutableArray *myArray = [NSMutableArray objectAtIndex:0]; // [2.13]
array];
[myArray addObject:@”first string”]; NSLog(@”The element at index 0 in the
[myArray addObject:@”second string”]; array is: %@”, element);
[myArray addObject:@”third string”];
[pool release];
int i; return 0;
int count; }
for (i = 0, count = [myArray count]; i <
count; i = i + 1) :‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻄﺒﻊ اﻟﺴﻄﺮ اﻟﺘﺎﻟﻲ‬
The element at index 0 in the array is:
//... continued
first string
٩٤
‫ﳝّﻜﻨﻚ ﻣﻦ ﺗﺒﺪﻳﻞ ﻋﻨﺼﺮ ﻣﻌﺮوف رﻗﻤﻪ اﻟﺘﺴﻠﺴﻠﻲ ﺑﻌﻨﺼﺮ آﺧﺮ‬ ‫{‬

‫‪NSString *element = [myArray‬‬
‫داﺧﻞ اﳌﺼﻔﻮﻓﺔ‪.‬اﺳﻢ ﻫﺬا اﻹﺟﺮاء ﻫﻮ ‪replaceObjectAtIndex:‬‬ ‫;]‪objectAtIndex:i‬‬
‫‪ withObject:‬ﻓﺤﺘﻰ ﻫﺬﻩ اﻟﻠﺤﻈﺔ ﻗﻤﻨﺎ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻﺟﺮاءات‬ ‫‪NSLog(@”The element at index %d in the‬‬
‫;)‪array is: %@”, i, element‬‬
‫اﻟﺘﻲ ﺗﻄﻠﺒﺖ وﺟﻮد ﻣﻌﺎﻣﻞ واﺣﺪ ﻛﺤﺪ أﻋﻠﻰ‪ .‬وﻫﺬا اﻻﺟﺮاء ﻫﻨﺎ‬ ‫}‬
‫ﻣﺨﺘﻠﻒ‪ ،‬وﻟﺬﻟﻚ ﻧﺤﻦ ﻧﺘﻔﺤﺼﺔ اﻻن‪ ،‬ﻓﻬﺬا اﻻﺟﺮاء ﻳﺘﻄﻠﺐ وﺟﻮد‬ ‫;]‪[pool release‬‬
‫ﻣﻌﺎﻣﻼن‪ .‬وﳝﻜﻨﻚ ان ﺗﺆﻛﺪ ذﻟﻚ ﺣﻴﺚ ﻳﻮﺟﺪ ﻋﺪد ‪ ٢‬ﻣﻦ اﻟﻨﻘﺎط‬ ‫;‪return 0‬‬
‫اﻟﻌﻤﻮدﻳﺔ ”‪.“:‬‬ ‫}‬
‫ﺗﺴﻤﺢ ‪ Objective-C‬ﻟﻺﺟﺮاءات ﺑﺄن ﲢﺘﻮى اي ﻋﺪد ﻣﻦ اﳌﻌﺎﻣﻼت‬ ‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻘﻮم ﺑﻄﺒﺎﻋﺔ ﻣﺎﻳﻠﻲ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪:‬‬
‫‪ .-arguments-‬وﻫﻨﺎ ﻧﺮى ﻛﻴﻒ ﳝﻜﻨﻨﺎ اﺳﺘﺨﺪام ﻫﺬا اﻻﺟﺮاء‪.‬‬ ‫‪The element at index 0 in the array is:‬‬
‫‪first string‬‬
‫]‪[4‬‬ ‫‪The element at index 1 in the array is:‬‬
‫‪[myArray replaceObjectAtIndex:1‬‬ ‫‪second string‬‬
‫;]”‪withObject:@”Hello‬‬ ‫‪The element at index 2 in the array is:‬‬
‫‪third string‬‬
‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﻫﺬا اﻻﺟﺮاء‪ ،‬ﺳﻴﻜﻮن اﻟﻌﻨﺼﺮ اﻟﺜﺎﻧﻲ ذي اﻟﺮﻗﻢ اﻟﺘﺴﻠﺴﻠﻲ‬
‫‪ ١‬ﻣﺤﺘﻮﻳ َﺎ ﻟﺴﻠﺴﻠﺔ اﳊﺮوف ”‪ . @”Hello‬ﺑﻜﻞ ﺗﺄﻛﻴﺪ ﻳﺠﺐ ﺗﻨﻔﻴﺬ‬ ‫ﻻﺣﻆ ﻟﻠﻤﺼﻔﻮﻓﺎت اﻟﻘﺎﺑﻠﻴﺔ ان ﲢﺘﻮي اي ﻛﺎﺋﻨﺎت اﺧﺮى ﻓﻬﻲ‬
‫ﻫﺬا اﻻﺟﺮاء ﺑﻮﺟﻮد رﻗﻢ ﺗﺴﻠﺴﻠﻲ ﻣﻮﺟﻮد‪ .‬ﲟﻌﻨﻰ ﻳﺠﺐ ان ﻳﻜﻮن‬ ‫ﻟﻴﺴﺖ ﻣﺤﺼﻮرة ﺑﺘﺨﺰﻳﻦ ﺳﻼﺳﻞ اﳊﺮوف ﻓﻘﻂ‪.‬‬
‫ﻫﻨﺎك ﻋﻨﺼﺮ ﻣﺨﺰن ﺑﺎﻟﺮﻗﻢ اﻟﺘﺴﻠﺴﻠﻲ اﳌﺬﻛﻮر‪ ،‬ﺣﺘﻰ ﻳﺘﻤﻜﻦ اﻻﺟﺮاء‬ ‫ﻳﺰودك ﺗﺼﻨﻴﻔﻲ ‪ NSMutableArray‬و ‪ NSArray‬ﺑﻌﺪة إﺟﺮاءات‪،‬‬
‫ﻣﻦ ﺗﻨﻔﻴﺬ ﻋﻤﻠﻴﺔ اﻻﺳﺘﺒﺪال ﺑﺎﻟﻜﺎﺋﻦ ﻗﻴﺪ اﻟﺒﺪل‪.‬‬ ‫وﻧﻨﺼﺤﻚ ان ﺗﻄﺎﻟﻊ ﻣﺎ ﲢﺘﻮﻳﺔ وﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة ﻟﻬﺬﻳﻦ اﻟﺘﺼﻨﻴﻔﲔ‬
‫ﻛﻤﺎ ﺗﺮى ﻣﻦ اﳌﺜﺎل‪ ،‬ان اﺳﻤﺎء اﻹﺟﺮاءات ﺑـ ‪ Objective-C‬ﻣﺜﻞ‬ ‫ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ اﻟﺘﻌﺮف اﻛﺜﺮ ﻋﻠﻰ ﻓﻮاﺋﺪ وﳑﻴﺰات اﳌﺼﻔﻮﻓﺎت‪.‬‬
‫اﳉﻤﻞ اﻟﺘﻲ ﺗﺘﻄﻠﺐ ﻣﻨﻚ ان ﲤﻞء ﻓﺮاﻏﺎﺗﻬﺎ‪) .‬اﻟﻔﺮاغ اﳌﻄﻠﻮب ﻣﻠﺌﻪ‬ ‫وﺳﻨﻘﻮم ﺑﺎﻧﻬﺎء ﻫﺬا اﻟﻔﺼﻞ ﻣﻦ ﺧﻼل ﺣﺪﻳﺜﻨﺎ ﻋﻦ اﻻﺟﺮاء اﻟﺬي‬
‫‪٩٥‬‬
‫اﳌﺼﻔﻮﻓﺎت‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻳﺄﺗﻲ ﺑﻌﺪ اﻟﻨﻘﻄﺘﲔ اﻟﻌﻤﻮدﻳﺘﲔ ”إﺟﺮاء ﻣﻌﺎﻣﻞ‪ ..... :١‬ﻣﻌﺎﻣﻞ‪:٢‬‬

‫‪ .(” .....‬وﻣﺘﻰ ﻣﺎ وﺿﻌﺖ اﻹﺟﺮاء ﻗﻴﺪ اﻟﺘﻨﻔﻴﺬ وﺟﺐ ﻋﻠﻴﻚ‬
‫ﻣﻞء ﺗﻠﻚ اﻟﻔﺮاﻏﺎت ﺑﻘﻴﻢ ﺣﻘﻴﻘﻴﺔ‪ ،‬ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ إﻧﺸﺎء ﺟﻤﻠﺔ‬
‫ذات ﻣﻌﻨﻰ‪.‬‬
‫ﻫﺬا اﻻﺳﻠﻮب اﳌﺘﺒﻊ ﻟﻠﺘﺴﻤﻴﺔ وﺗﻔﻌﻴﻞ ﺻﻴﺎﻏﺔ اﻹﺟﺮاءات ﻗﺪ واﺿﺢ‬
‫ﺟﺪاَ ﺑـ ‪ Objective-C‬ﺑﺴﺒﺐ ﻣﺎ ورﺛﺘﺔ ﻣﻦ ﺳﻠﻔﻬﺎ ﻟﻐﺔ ‪Smalltalk‬‬
‫اﻟﺒﺮﻣﺠﻴﺔ‪ .‬ﳑﺎ اﻛﺴﺐ ‪ Objective-C‬ﻗﻮﺗﻬﺎ اﳊﺎﻟﻴﺔ ﺑﺤﻴﺚ اﺻﺒﺤﺖ‬
‫ﺷﻔﺮﺗﻬﺎ اﻟﺒﺮﻣﺠﻴﺔ ُﻣﺼﺎﻏﺔ ﺑﺸﻜﻞ ﻳﺠﻌﻠﻬﺎ ﻣﻘﺮؤة ﺑﻜﻞ وﺿﻮح‬
‫وﺗﻠﻘﺎﺋﻴﺔ‪.‬‬
‫ﻋﻨﺪﻣﺎ ﺗﻘﻮم ﺑﺘﺄﻟﻴﻒ إﺟﺮاءاﺗﻚ اﳋﺎﺻﺔ‪ ،‬اﺣﺮص ﻋﻠﻰ ان ﺗﻜﻮن‬
‫ﻣﺴﻤﻴﺎﺗﻬﺎ ﻣﺼﺎﻏﺔ ﺑﺸﻜﻞ ﻳﺠﻌﻠﻬﺎ ﺗُﻘﺮأ ﻛﺎﻓﻌﺎل ﺑﺠﻤﻠﺔ‪ .‬ﻫﺬا‬
‫اﻻﺳﻠﻮب ﻳﻌﲔ ﻣﻦ ﺗﺴﻬﻴﻞ ﻗﺮاءة اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬وﻫﻮ اﻣﺮ ﻣﻬﻢ‬
‫ﻻن ﺗﻜﻮن ﺑﺮاﻣﺠﻚ ﻗﺎﺑﻠﺔ ﻟﻠﻔﻬﻢ ﳑﺎ ﻳﺴﻬﻞ ﻣﻦ ﻋﻤﻠﻴﺔ ﺗﺼﻴﻴﻨﻬﺎ‪.‬‬
‫‪٩٦‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫إدارة اﻟﺬاﻛﺮة‬
‫إدارة اﻟﺬاﻛﺮة‬
‫ﻗﺪﻣﺖ اﻋﺘﺬاري ﺑﺎﻛﺜﺮ ﻣﻦ ﻓﺼﻞ ﺳﺎﺑﻖ‪ ،‬ﺣﻮل ﺗﻔﺴﻴﺮ ﺑﻌﺾ اﻻﻳﻌﺎزات‬
‫اﻟﺘﻲ ﺳﻮف ﻧﺘﻨﺎوﻟﻬﺎ ﻫﻨﺎ‪ .‬ﻓﻬﺬﻩ اﻻﻳﻌﺎزات ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺬاﻛﺮة‪.‬ﻓﻜﻤﺎ‬
‫ﺗﺮى إن ﺑﺮﻧﺎﻣﺠﻚ ﻟﻴﺲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻮﺣﻴﺪ ﺑﺠﻬﺎز اﳌﺎﻛﻨﺘﻮش‪ ،‬ﺣﻴﺚ‬
‫ﺗﻜﻮن اﻟﺬاﻛﺮة ‪ RAM‬ﻣﺤﺪودة ﻛﺎﻟﻌﻤﻠﺔ اﻟﺼﻌﺒﺔ‪ .‬ﻟﺬا ﻓﻲ ﺣﺎل ﻟﻢ‬
‫ﻳﻌﺪ ﺑﺮﻧﺎﻣﺠﻚ ﺑﺤﺎﺟﺔ ﻟﺬﻟﻚ اﳉﺰء اﶈﺠﻮز ﻣﻦ اﻟﺬاﻛﺮة‪ ،‬ﻳﺠﺐ ﻋﻠﻴﻪ‬
‫ﻋﻨﺪﻫﺎ إﻋﺎدة ذﻟﻚ اﳉﺰء إﻟﻰ اﻟﻨﻈﺎم‪.‬‬
‫ﻟﻘﺪ اﺣﺴﻨﺖ واﻟﺪﺗﻚ ﺗﺮﺑﻴﺘﻚ ﻋﻨﺪﻣﺎ اﺧﺒﺮﺗﻚ ﺑﺄن ﺗﻜﻮن ﻣﺘﺄدﺑ َﺎ وان‬
‫ﺗﺘﻌﺎﻳﺶ ﻣﻊ ﺑﺎﻗﻲ أﻓﺮاد ﻣﺠﺘﻤﻌﻚ‪ ،‬ﻟﻘﺪ ﻛﺎﻧﺖ ﺗﻌﻠﻤﻚ ﺑﻄﺮﻳﻘﺔ ﻣﺎ‬
‫ﻛﻴﻒ ﻳﻜﻮن اﻟﺒﺮﻧﺎﻣﺞ!‬
‫وﺣﺘﻰ ﻟﻮ ﻛﺎن ﺑﺮﻧﺎﻣﺠﻚ ﻫﻮ اﻟﻮﺣﻴﺪ ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ‪ ،‬ﻓﺈن ﻋﺪم ﻓﻚ‬
‫اﳊﺠﺰ ﻋﻦ اﻟﺬاﻛﺮة وإﺳﺘﻬﻼك اﳌﺰﻳﺪ ﻳﺆدي اﻟﻰ ﺣﻜﺮ ﺑﺮﻧﺎﻣﺠﻚ‬
‫ﺗﺪرﻳﺠﻴ َﺎ ﺑﺮﻛﻦ ﻳﺼﻌﺐ اﳋﺮوج ﻣﻨﻪ‪ ،‬وﺳﻴﻜﻮن أداء ﺣﺎﺳﺒﻚ ﺑﻄﻲء‬
‫ﺟﺪاَ ﻟﺪرﺟﺔ اﳊﺒﻮ‪.‬‬
‫ﻋﻨﺪﻣﺎ ﻳﻘﻮم ﺑﺮﻧﺎﻣﺠﻚ ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﺟﺪﻳﺪ‪ ،‬ﺳﻴﺤﺘﻞ اﻻﺧﻴﺮ ﺟﺰء‬
‫ﻣﻦ ﻣﺴﺎﺣﺔ اﻟﺬاﻛﺮة وﺳﻴﻜﻮن ﻣﻦ واﺟﺒﻚ إﺧﻼء وﻓﻚ ﺣﺠﺰ ذﻟﻚ‬
‫اﳉﺰء ﻣﻦ اﻟﺬاﻛﺮة ﻣﺘﻰ ﻣﺎ اﻧﻌﺪﻣﺖ ﺣﺎﺟﺘﻚ ﻟﻮﺟﻮد ذﻟﻚ اﻟﻜﺎﺋﻦ‪ .‬ان‬
‫‪٩٧‬‬
‫إدارة اﻟﺬاﻛﺮة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻣﺘﻰ ﻣﺎ اﺻﺒﺤﺖ ﻗﻴﻤﺔ ﻋﺪاد اﻟﺮواﺑﻂ ﻣﺴﺎوﻳﺔ ﻟﺼﻔﺮ‪ ،‬ﻳﻌﻠﻢ اﻟﻜﺎﺋﻦ‬ ‫اﻧﻌﺪام ﺣﺎﺟﺘﻚ ﻟﻠﻜﺎﺋﻦ ﲢﺘﻢ ﻋﻠﻴﻚ إﻓﻨﺎءة‪/‬ﺗﺪﻣﻴﺮﻩ وإﺧﻼء اﳌﺴﺎﺣﺔ‬
‫ﻋﻨﺪﻫﺎ اﻧﻪ ﻻ ﻳﻮﺟﺪ اﺣﺪ ﻣﺮﺗﺒﻂ ﺑﻪ واﻧﻪ ﳝﻜﻨﻪ ﻋﻨﺪﻫﺎ ﺗﺪﻣﻴﺮ ذاﺗﻪ‪،‬‬ ‫اﻟﺘﻲ ﻛﺎن ﻳﺤﺘﺠﺰﻫﺎ‪.‬ﻋﻠﻰ ﻛﻞ ﺣﺎل‪ ،‬ﺗﻘﺮﻳﺮ ﻣﺼﻴﺮ اﻟﻜﺎﺋﻦ ﻣﻦ ﺧﻼل‬
‫ﻣﺨﻠﺼ َﺎ ﺑﺬﻟﻚ اﳊﻴﺰ اﻟﺬي ﻛﺎن ﻳﺤﺘﻠﻪ ﻣﻦ اﻟﺬاﻛﺮة‪.‬‬ ‫ﻣﺪى ﺣﺎﺟﺘﻚ ﻗﺪ ﻻ ﻳﻜﻮن ﺑﺎﻻﻣﺮ اﻟﻴﺴﻴﺮ‪.‬‬
‫ﻛﻤﺜﺎل‪ ،‬ﻟﻨﻔﺮض ان ﺑﺮﻧﺎﻣﺠﻚ ﻋﺒﺎرة ﻋﻦ ﻣﺸﻐﻞ ﻣﻮﺳﻴﻘﻲ وﻟﺪﻳﻚ‬ ‫ﻛﻤﺜﺎل‪ ،‬واﺛﻨﺎء ﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‪ ،‬ﻗﺪ ﻳﻜﻮن ﻛﺎﺋﻨﻚ ﻫﺬا ﻣﺴﺘﺨﺪﻣ َﺎ‬
‫ﻛﺎﺋﻨﺎت ﲤﺜﻞ ”اﻻﻏﻨﻴﺎت“ وأﺧﺮى ﲤﺜﻞ ”ﻗﻮاﺋﻢ اﺳﻤﺎء اﻻﻏﻨﻴﺎت“‪.‬‬ ‫ﻣﻦ ﻗﺒﻞ ﻋﺪة ﻛﺎﺋﻨﺎت ﺗﺸﻴﺮ اﻟﻴﻪ ﻣﺮﺟﻌﻴ َﺎ‪ ،‬ﻋﻨﺪﻫﺎ ﻳﺠﺪر ﺑﻚ اﻻ‬
‫ﻟﻨﻔﺮض ان ﻛﺎﺋﻦ ”اﻏﻨﻴﺔ“ ﻣﺮﺗﺒﻂ ﺑﺈﺷﺎرة ﻣﺮﺟﻌﻴﺔ ﻣﻦ ﻗﺒﻞ ‪ ٣‬ﻛﺎﺋﻨﺎت‬ ‫ﺗﻘﻮم ﺑﺘﺪﻣﻴﺮﻩ ﻻﺣﺘﻤﺎل ان ﻳﻘﻮم اﺣﺪ ﺗﻠﻚ اﻟﻜﺎﺋﻨﺎت اﻻﺧﺮى‬
‫”ﻗﻮاﺋﻢ أﺳﻤﺎء اﻻﻏﻨﻴﺎت“‪ .‬ﻋﻨﺪﻫﺎ ﺳﺘﻜﻮن ﻗﻴﻤﺔ ﻋﺪاد رواﺑﻂ اﻟﻜﺎﺋﻦ‬ ‫ﺑﺈﺳﺘﺨﺪاﻣﻪ‪.‬‬
‫”اﻏﻨﻴﺔ“ ﻣﺴﺎوﻳﺔ ﻟـ‪.٣‬‬
‫)ان ﻣﺠﺮد ﻣﺤﺎوﻟﺔ اﺳﺘﺨﺪام ﻛﺎﺋﻦ ﰎ ﺗﺪﻣﻴﺮﻩ ﺗﺆدي اﻟﻰ‬
‫ﺗﻮﻗﻒ ﺑﺮﻧﺎﻣﺠﻚ ﻋﻦ اﻟﻌﻤﻞ ‪ crash‬أو ﻳﺘﺼﺮف ﺑﻄﺮﻳﻘﺔ‬
‫ﻏﻴﺮ اﳌﻘﺮرة(‬
‫وﻟﻠﻤﺴﺎﻋﺪة ﻓﻲ ﺗﻘﺮﻳﺮ ﻋﻤﻠﻴﺔ إﻓﻨﺎء اﻟﻜﺎﺋﻦ ﻋﻨﺪ اﻧﻌﺪام اﳊﺎﺟﺔ إﻟﻴﻪ‪،‬‬
‫ﺗﻘﺪم ﻟﻚ ‪ Cocoa‬ﻣﺒﺪأ رﺑﻂ اﻟﻜﺎﺋﻦ ﺑﺎﻟﻌﺪاد‪ ،‬وﻫﻮ ﳝﺜﻞ ﻣﺎ ﻳﻄﻠﻖ‬
‫ﻋﻠﻴﻪ ”"ﻋﺪاد اﻟﺮواﺑﻂ ‪ “retain count‬اﳋﺎص ﺑﻜﻞ ﻛﺎﺋﻦ‪.‬‬
‫ﻓﻔﻲ ﺑﺮﻧﺎﻣﺠﻚ ﻣﺘﻰ ﻣﺎ ﻋﻴﻨﺖ اﺷﺎرة ﻣﺮﺟﻌﻴﺔ ‪ -reference-‬ﻻﺣﺪ‬
‫اﻟﻜﺎﺋﻨﺎت‪ ،‬وﺟﺐ ﻋﻠﻴﻚ ﻋﻨﺪﻫﺎ اﻋﻼم ذﻟﻚ اﻟﻜﺎﺋﻦ‪ ،‬ﺣﻴﺚ ﺗﻘﻮم‬
‫ﻳﺴﺘﻄﻴﻊ اﻟﻜﺎﺋﻦ ﻣﻌﺮﻓﺔ ﻋﺪد اﻻﺷﺎرات اﻟﻴﻪ‪.‬‬
‫ﺑﺰﻳﺎدة ﻋﺪاد رواﺑﻄﻪ ﺑﻘﻴﻤﺔ ﻣﻘﺪارﻫﺎ ‪ .١‬وﻣﺘﻰ ﻣﺎ ﻗﻤﺖ ﺑﺈزاﻟﺔ ﺗﻠﻚ‬
‫ﻟﻘﺪ اﺻﺒﺢ ﻟﻠﻜﺎﺋﻦ اﻟﻘﺪرة ﻋﻠﻰ ﻣﻌﺮﻓﺔ ﻋﺪد اﳌﺮات اﻟﺘﻲ ﲤﺖ اﻻﺷﺎرة‬ ‫اﻻﺷﺎرة اﳌﺮﺟﻌﻴﺔ‪ ،‬وﺟﺐ ﻋﻠﻴﻚ اﻟﻘﻴﺎم ﺑﺈﻧﻘﺎص ﻋﺪاد رواﺑﻄﻪ ﺑﻘﻴﻤﺔ‬
‫اﻟﻴﻪ‪ ،‬واﻟﻔﻀﻞ ﻓﻲ ذﻟﻚ ﻳﻌﻮد اﻟﻰ ﻋﺪاد اﻟﺮواﺑﻂ‪ .‬وﻟﻠﻘﻴﺎم ﺑﺰﻳﺎدة‬ ‫ﻣﻘﺪارﻫﺎ ‪.١‬‬
‫‪٩٨‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫إدارة اﻟﺬاﻛﺮة‬
‫اﻓﺼﺢ ﺑﻌﺾ ﻣﻬﻨﺪﺳﻲ أﭘﻞ ﻋﻦ ﺗﻮﺟﻬﻬﺎ ﻟﺘﻄﻮﻳﺮ ﳕﻮذج آﻟﻴﺔ ﺟﺪﻳﺪة‬ ‫ﻋﺪاد اﻟﺮواﺑﻂ ﻻﺣﺪ اﻟﻜﺎﺋﻨﺎت‪ ،‬ﻛﻞ ﻣﺎ ﻋﻠﻴﻨﺎ ﻋﻤﻠﻪ ﻫﻮ ارﺳﺎل رﺳﺎﻟﺔ‬
‫ﺗﻌﺮف ﺑﺎﺳﻢ ”‪ .“automatic garbage collection‬ﺣﻴﺚ ﺳﺘﻜﻮن‬ ‫‪ retain‬ﻟﺬﻟﻚ اﻟﻜﺎﺋﻦ‪ .‬اﻣﺎ ﻓﻲ ﺣﺎل رﻏﺒﺘﻨﺎ ﺑﺈﻧﻘﺎص ﻋﺪاد اﻟﺮواﺑﻂ‬
‫ﻫﺬﻩ اﻻﻟﻴﺔ اﻛﺜﺮ ﻗﻮة ﻣﻦ اﻟﻮﺳﺎﺋﻞ اﳊﺎﻟﻴﺔ‪ ،‬وذات اﺳﺘﺨﺪام اﺳﻬﻞ‬ ‫ﻋﻨﺪﻫﺎ ﻧﺮﺳﻞ ﻟﻪ رﺳﺎﻟﺔ ‪. release‬‬
‫وﺑﻨﺴﺒﺔ اﺧﻄﺎء اﻗﻞ وﻗﺖ ﻛﺘﺎﺑﺔ ﻫﺬا اﻟﻜﺘﺎب‪.‬‬ ‫”‪“autorelease pool‬‬ ‫ﺗﻘﺪم ﻟﻚ ‪ Cocoa‬آﻟﻴﺔ ﻋﻤﻞ آﺧﺮى ﺗﺪﻋﻰ‬
‫ﻋﻠﻰ ﻛﻞ ﺣﺎل ﻻ ﺗﻮﺟﺪ ﺿﻤﺎﻧﻪ ﻋﻤﺎ اذا ﻛﺎﻧﺖ ﻫﺬﻩ اﻟﺘﻜﻨﻮﻟﻮﺟﻴﺎ‬ ‫ﲤﻜﻨﻚ ﻣﻦ ارﺳﺎل رﺳﺎﻟﺔ ‪ release‬ﻣﺘﺄﺧﺮة ﻟﺬﻟﻚ اﻟﻜﺎﺋﻦ‪.‬‬ ‫وﻫﻲ ّ‬
‫ﻣﻜﺘﻤﻠﺔ‪ ،‬أو ﻣﺘﻰ ﺳﺘﻘﻮم أﭘﻞ ﺑﺘﺰوﻳﺪﻫﺎ ﻓﻲ ‪.Cocoa‬‬ ‫‪ delayed message -‬ﲟﻌﻨﻰ اﻧﻬﺎ ﻟﻴﺴﺖ ﻗﻴﺪ اﻻرﺳﺎل َ‬
‫ﺣﺎﻻ ﺑﻞ‬
‫ﺑﻌﺪ ﺗﺨﻀﻊ ﻟﻔﺘﺮة ﻣﺘﺄﺧﺮة ﻣﻦ اﻟﺰﻣﻦ‪ .‬وﻻﺳﺘﺨﺪام ﻫﺬﻩ اﻵﻟﻴﺔ‪،‬‬
‫ﻛﻞ ﻣﺎ ﻋﻠﻴﻚ ﻋﻤﻠﻪ ﻫﻮ ﺗﺴﺠﻴﻞ ذﻟﻚ اﻟﻜﺎﺋﻦ ﺑﻘﺎﺋﻤﺔ ﻣﺎ ﻳﺴﻤﻰ‬
‫”‪ ،“autorelease pool‬ﻣﻦ ﺧﻼل ارﺳﺎل رﺳﺎﻟﺔ ‪. autorelease‬‬
‫وﺳﺘﻘﻮم ﻋﻨﺪﻫﺎ آﻟﻴﺔ ”‪ “autorelease pool‬ﺑﺎﻟﺘﻜﻔﻞ ﺑﻌﻤﻠﻴﺔ ارﺳﺎل‬
‫رﺳﺎﻟﺔ ‪ release‬اﳌﺘﺄﺧﺮة إﻟﻰ ذﻟﻚ اﻟﻜﺎﺋﻦ اﳌﺴﺠﻞ ﻣﻌﻬﺎ‪.‬‬
‫إذاً اﻻﻳﻌﺎزات اﻟﺘﻲ ﺗﺘﻜﻔﻞ ﺑﻬﺎ ”‪ “autorelease pool‬وﻗﺪ رأﻳﻨﺎﻫﺎ‬
‫ﻓﻲ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﺑﺎﻷﻣﺜﻠﺔ اﻟﺴﺎﺑﻘﺔ‪ ،‬ﻫﻲ اﻳﻌﺎزات ﻣﻮﺟﻬﺔ ﻟﻨﻈﺎم‬
‫اﻟﺘﺸﻐﻴﻞ ﺣﺘﻰ ﻳﺘﻜﻔﻞ ﺑﺘﻬﻴﺌﺔ آﻟﻴﺔ ﻋﻤﻞ ”‪.“autorelease pool‬‬
‫ان ﻋﻤﻠﻴﺔ ادارة اﻟﺬاﻛﺮة اﳌﺴﺘﺨﺪﻣﺔ ﻣﻦ ﻗﺒﻞ ‪ Cocoa‬واﻟﺘﻲ ﰎ ﻋﺮﺿﻬﺎ‬
‫ﺑﻬﺬا اﻟﻔﺼﻞ ﺗُﻌﺮف ﻋﺎدة ﲟﺴﻤﻰ ”‪ .“reference counting‬وﺳﻮف‬
‫ﲡﺪ ﺷﺮﺣ َﺎ واﻓﻴﺎ ﺣﻮل ﻧﻈﺎم ‪ Cocoa‬ﻻدارة اﻟﺬاﻛﺮة ﺑﻜﺘﺐ و ﻣﻮاﺿﻴﻊ‬
‫ﻣﺘﻘﺪﻣﺔ )اﻧﻈﺮ اﻟﻔﺼﻞ ‪.(١٥‬‬
‫‪٩٩‬‬
‫إدارة اﻟﺬاﻛﺮة‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬
‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬
‫ان اﻟﻬﺪف اﻻﺳﻤﻰ ﻟﻬﺬا اﻟﻜﺘﺎب ﻫﻮ ﺗﻌﻠﻴﻤﻚ اﺳﺲ ﻟﻐﺔ ‪Objective-‬‬
‫‪ C‬ﻣﻦ ﺧﻼل ﺑﻴﺌﺔ ‪ .Xcode‬ﻓﺎذا ﺻﺪف ان ﻗﺮأت ﻫﺬا اﻟﻜﺘﺎب ﻣﺮﺗﲔ‪،‬‬
‫وﻗﻤﺖ ﺑﺘﺠﺮﻳﺐ اﻻﻣﺜﻠﺔ واﺿﻔﺖ ﲡﺎرﺑﻚ ﻋﻠﻴﻬﺎ‪ ،‬ﻋﻨﺪﻫﺎ ﺗﺄﻛﺪ اﻧﻚ‬
‫ﺟﺎﻫﺰ ﻻن ﺗﺘﻌﻠﻢ ﻛﻴﻔﻴﺔ ﻋﻤﻞ ﺑﺮﻧﺎﻣﺠﻚ اﻟﻔﺘﺎك‪ ،‬اﻟﺬي ﻃﺎﳌﺎ رﻏﺒﺖ‬
‫ﺑﻜﺘﺎﺑﺘﻪ‪.‬‬
‫ﻫﺬا اﻟﻜﺘﺎب ﻳﺰودك ﲟﻔﺎﺗﻴﺢ اﳌﻌﺮﻓﺔ اﻻوﻟﻴﺔ‪ ،‬و اﻟﻜﺎﻓﻴﺔ ﻟﺘﺘﻌﻤﻖ‬
‫اﳌﺸﺎﻛﻞ اﻟﺒﺮﻣﺠﻴﺔ ﺑﺸﻜﻞ اﺳﺮع‪ .‬وﲟﺎ اﻧﻚ ﻻ ﺗﺰال ﻣﻌﻨﺎ ﺣﺘﻰ ﻫﺬا‬
‫اﻟﻔﺼﻞ‪ ،‬ﻓﺎﻧﻚ ﺣﺘﻤ َﺎ ﺟﺎﻫﺰ ﻻن ﺗﻐﺰو اﳌﺼﺎدر اﳌﻌﻠﻮﻣﺎﺗﻴﺔ اﻻﺧﺮى‪،‬‬
‫وﻣﺎ ﺳﻨﺬﻛﺮﻩ ﻫﻨﺎ ﺳﻴﻠﻔﺖ اﻧﺘﺒﺎﻫﻚ‪.‬‬
‫ﻧﺼﻴﺤﺔ ﻣﻬﻤﺔ ﻗﺒﻞ ان ﺗﺒﺪأ ﺑﻜﺘﺎﺑﺔ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ‪:‬‬
‫ﻼ! وﺗﻔﺤﺺ ﻫﻴﺎﻛﻞ‬ ‫ﻻﺗﺒﺪأ ﺑﺈﻧﺪﻓﺎع‪ ،‬أﺑﺪ َا ! ﺑﻞ ﺗﺮوى ﻗﻠﻴ َ‬
‫اﻟﻌﻤﻞ ‪ frameworks‬اﳌﺘﻮﻓﺮة‪...‬‬
‫ذﻟﻚ ان أﭘﻞ‪ ،‬ﻏﺎﻟﺒ َﺎ ﻣﺎ ﻗﺎﻣﺖ ﻋﻨﻚ ﺑﺎﻟﻌﻤﻞ‪ ،‬أو زودﺗﻚ ﺑﺘﺼﻨﻴﻔﺎت‬
‫ﺗﺘﻄﻠﺐ اﻟﻘﻠﻴﻞ ﻣﻦ اﻟﺘﻌﺪﻳﻞ ﻟﺘﺤﻘﻖ ﻣﺎ ﺗﺮﻳﺪ‪ .‬ﻛﺬﻟﻚ ﻣﻦ اﳌﻤﻜﻦ‬
‫ان ﻳﻜﻮن اﺣﺪﻫﻢ ﻗﺪ ﻗﺎم ﺑﺈﳒﺎز ﻣﺎ ﲢﺘﺎج ﺗﺼﻤﻴﻤﻪ واﺗﺎح ﺷﻔﺮﺗﻪ‬
‫اﳌﺼﺪرﻳﺔ ‪ -open source-‬ﻟﻠﺠﻤﻬﻮر‪ .‬ﻟﺬا وﻓﺮ ﻋﻠﻰ ﻧﻔﺴﻚ اﻟﻌﻨﺎء‬
‫‪١٠١‬‬
‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪http://www.cocoabuilder.com‬‬
‫ﻣﻦ ﺧﻼل ﻣﻄﺎﻟﻌﺘﻚ ﻟﻮﺛﺎﺋﻖ اﳌﺴﺎﻋﺪة واﻟﺒﺤﺚ ﺑﺎﻻﻧﺘﺮﻧﺖ‪ .‬واول‬
‫وﻟﻠﻤﻌﻠﻮﻣﺎت واﻟﻨﺼﺎﺋﺢ ﺣﻮل اﺗﻴﻜﻴﺖ ﻓﻦ اﻟﺘﺨﺎﻃﺐ وﻃﺮح اﻻﺳﺌﻠﺔ‬ ‫ﻣﺼﺪر ﻳﺠﺪر ﺑﻚ زﻳﺎرﺗﻪ ﻫﻮ ﻣﻮﻗﻊ ﻣﻄﻮري أﭘﻞ ﺑﺎﻟﺮاﺑﻂ‬
‫ﻋﻠﻰ اﻋﻀﺎء اﻟﻘﺎﺋﻤﺔ اﻟﺒﺮﻳﺪﻳﺔ‪ ،‬إﻗﺮاء ‪“How To Ask Questions‬‬ ‫‪Apple’s developer site at: http://www.‬‬
‫”‪ The Smart Way‬اﻟﺘﻲ ﺳﺘﺠﺪﻫﺎ ﺑﺎﻟﺮاﺑﻂ‬ ‫‪apple.com/developer‬‬
‫‪http://www.catb.org/~esr/faqs/smart-‬‬
‫ﻧﺤﻦ ﻧﻨﺼﺤﻚ ﺑﺸﺪة ان ﺑﺈرﺗﻴﺎد وﺗﺒﻮﻳﺐ ‪ -bookmark-‬اﻟﻌﻨﺎوﻳﻦ‬
‫‪questions.html‬‬ ‫اﻟﺘﺎﻟﻴﺔ‪:‬‬
‫ﻫﻨﺎك ﻋﺪة ﻛﺘﺐ ﻗ ّﻴﻤﺔ ﺣﻮل اﻟﺘﻄﻮﻳﺮ ﺑﺎﺳﺘﺨﺪام ‪.Cocoa‬و ﻧﺒﺪأ‬ ‫‪http://osx.hyperjeff.net/reference/‬‬
‫‪CocoaArticles.php‬‬
‫ﺳﺮدﻧﺎ ﺑﻜﺘﺎب ‪Programming in Objective-C, by Stephen‬‬ ‫‪http://www.cocoadev.com‬‬
‫‪ Kochan‬وﻫﻮ ﻣﻮﺟﻪ ﻟﻠﻤﺒﺘﺪﺋﲔ‪ .‬وﺑﺠﻌﺒﺘﻨﺎ ﺑﻌﺾ اﻟﻜﺘﺐ اﻟﺘﻲ‬ ‫‪http://www.cocoabuilder.com‬‬
‫‪http://www.stepwise.com‬‬
‫ﺗﻔﺘﺮض اﻛﺘﺴﺎﺑﻚ ﳌﻌﺮﻓﺔ ﺑﺮﻣﺠﻴﺔ ﻛﺎﻟﺘﻲ اﺳﺘﻔﺪﻧﺎ ﻣﻨﻬﺎ ﺑﻬﺬا‬
‫اﻟﻜﺘﺎب‪ .‬ﻟﺬا ﻧﻨﺼﺤﻚ ﺑﻜﺘﺎب ‪Cocoa Programming for Mac‬‬
‫اﳌﻮاﻗﻊ اﳌﻮﺿﺤﺔ ﺑﻌﺎﻟﻴﺔ ﲢﺘﻮي رواﺑﻂ ﻣﺘﻨﻮﻋﺔ وﻣﺘﻌﺪدة ﳌﻮاﻗﻊ أﺧﺮى‬
‫‪ OS X by Aaron Hillegass‬واﳌﺆﻟﻒ ﺻﺎﺣﺐ ﻣﺆﺳﺴﺔ ‪Big Nerd‬‬
‫ذات ﻣﺼﺎدر ﻣﻌﻠﻮﻣﺎت ﻣﺘﺸﻌﺒﺔ وﺷﺎﻣﻠﺔ‪ .‬ﻳﺠﺪر ﺑﻚ ﺗﺴﺠﻴﻞ‬
‫‪ Ranch‬اﻟﺘﻌﻠﻴﻤﻴﺔ ﺣﻴﺚ ﻳﻌﻄﻲ دورات ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﺗﺆﻫﻠﻚ ﻟﻠﻌﻤﻞ‬ ‫ﻋﻀﻮﻳﺘﻚ ﺑﺎﻟﻘﺎﺋﻤﺔ اﻟﺒﺮﻳﺪﻳﺔ اﳋﺎﺻﺔ ﲟﻮﻗﻊ ‪ cocoa-dev‬ﻋﻠﻰ اﻟﺮﺑﻂ‬
‫ﲟﻬﻨﺔ "ﻣﺒﺮﻣﺞ ﻣﺤﺘﺮف"‪ .‬ﻛﺬﻟﻚ ﻧﻨﺼﺤﻚ ﺑﻜﺘﺎب ‪Cocoa with‬‬
‫‪http://lists.apple.com/mailman/listinfo/‬‬
‫‪cocoa-dev‬‬
‫‪ Objective-C by James Duncan Davidson and Apple‬وﻫﻮ‬
‫ذﻟﻚ اﳌﻜﺎن اﻟﺬي ﳝﻜﻨﻚ ﻃﺮح اﺳﺌﻠﺘﻚ ﻓﻴﻪ ﺑﻜﻞ ﺣﺮﻳﺔ‪ .‬ﺣﻴﺚ‬
‫ﻣﻦ اﺻﺪارات ‪ . O’Reilly‬وﻫﻨﺎك ﻛﺘﺎب ‪Cocoa Programming‬‬
‫ﺳﻴﻘﻮم اﻟﻌﺪﻳﺪ ﻣﻦ اﻻﻋﻀﺎء ﺑﺘﻘﺪﱘ ﻳﺪ اﻟﻌﻮن ﺑﻜﻞ ﺣﻔﺎوة وﺗﺮﺣﻴﺐ‪.‬‬
‫‪ by Scott Anguish, Erick M.Buck, Donald A. Yacktman‬وﻫﻮ‬ ‫وﻟﻜﻦ ﻣﻘﺎﺑﻞ ﻫﺬﻩ اﳊﻔﺎوة ﻳﺘﻄﻠﺐ ﻣﻨﻚ اﻟﻘﻴﺎم َ‬
‫أوﻻ ﺑﺘﻔﺤﺺ ﻣﺎ‬
‫ﻣﻦ إﺻﺪارات ‪ SAMS‬واﻟﻜﺘﺎب دﺳﻢ ﺟﺪاَ ﺑﻜﺒﺮ اﻟﻘﺎﻣﻮس‪.‬‬
‫ﻳﺤﺘﻮﻳﺔ اﻻرﺷﻴﻒ ﻣﻦ اﺟﻮﺑﺔ ﻗﺪ ﺗﻜﻮن ﺷﺎﻓﻴﺔ ﻻﺳﺘﻔﺴﺎرك أو ﺣ َ‬
‫ﻼ‬
‫ﳌﺸﻜﻠﺘﻚ‪ ،‬ان راﺑﻂ اﻻرﺷﻴﻒ ﻫﻮ‬
‫‪١٠٢‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬
‫ﻛﻠﻤﺔ أﺧﻴﺮﻩ ﺑﻬﺪف اﻟﺘﻨﺒﻴﻪ‪.‬‬

‫واﻧﺖ ﻋﻠﻰ وﺷﻚ ان ﺗﺒﺮﻣﺞ ﺑﺮاﻣﺠﻚ ﻋﻠﻰ اﳌﺎﻛﻨﺘﻮش‪ .‬وﻗﺒﻞ ان‬
‫ﺗﻘﻮم ﺑﺈﻃﻼق ﺑﺮﻧﺎﻣﺠﻚ ﻟﻠﺠﻤﻬﻮر‪ ،‬ﻻ ﺗﻜﻦ ﺣﺮﻳﺼ َﺎ ﻋﻠﻰ ان ﻳﻜﻮن‬
‫ﺑﺮﻧﺎﻣﺠﻚ ﺧﺎﻟﻴ َﺎ ﻣﻦ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ﻓﻘﻂ‪ ،‬ﺑﻞ اﺣﺮص ﻋﻠﻰ ان‬
‫ﻳﻈﻬﺮ ﺑﺮﻧﺎﻣﺠﻚ ﺑﺎﻟﺸﻜﻞ اﻟﻼﺋﻖ وان ﻳﺤﻘﻖ اﳌﻮاﺻﻔﺎت اﻟﺘﻲ وﺿﻌﺘﻬﺎ‬
‫أﭘﻞ ﻟﺘﺼﻤﻴﻢ اﻟﻮاﺟﻬﺎت اﻟﺮﺳﻮﻣﻴﺔ ‪Apple human interface‬‬
‫‪ guidelines‬واﻟﺘﻲ ﺳﺘﺠﺪ ﻣﺎدﺗﻬﺎ اﻟﻘ ّﻴﻤﺔ ﺑﺎﻟﺮاﺑﻂ‬
‫‪http://developer.apple.com/documentation/‬‬
‫‪UserExperience/Conceptual/OSXHIGuidelines/‬‬
‫‪index.html‬‬
‫ﻓﻤﺎ ان ﺗﻨﺘﻬﻲ ﻣﻦ ذﻟﻚ‪ ،‬إدﻓﻊ ﺑﺒﺮﻧﺎﻣﺠﻚ إﻟﻰ اﳉﻤﻴﻊ! ان اﻟﺘﻌﻠﻴﻘﺎت‬

‫اﻟﺘﻲ ﺳﺘﺘﻠﻘﺎﻫﺎ ﻣﻦ ﻧﻘﺪ وﺗﻘﻴﻴﻢ ﺳﺘﻜﻮن ﻣﻌﻴﻨ َﺎ ﻟﻚ ﻟﺘﻄﻮﻳﺮ وﲢﺪﻳﺚ‬
‫ﺑﺮﻧﺎﻣﺞ ﻗ ّﻴﻢ ﻣﺎدﻣﺖ ﲢﺮص ﻋﻠﻰ ذﻟﻚ ﺑﺘﺮﻛﻴﺰ‪.‬‬
‫ﻧﺘﻤﻨﻰ ان ﺗﻜﻮن ﻗﺪ اﺳﺘﻤﻌﺖ ﻣﻌﻨﺎ ﺑﻘﺮاءة ﻫﺬا اﻟﻜﺘﺎب‪ ،‬وان ذﻟﻚ‬
‫ﺳﻴﻜﻮن داﻓﻌ َﺎ ﻟﻚ ﻟﺴﺒﺮ اﻏﻮار اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام ‪ ،Xcode‬واﻟﺮﺟﺎء‬
‫اﻟﺮﺟﺎء ﻻ ﺗﻨﺴﻰ ﻣﺎ ورد ﺑﺎﻟﻔﺼﻞ رﻗﻢ ‪٠‬‬
‫‪Bert, Alex, Philippe.‬‬
‫‪١٠٣‬‬
‫ﻣﺼﺎدر اﳌﻌﻠﻮﻣﺎت‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪١٠٤‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻣﺴﺮد اﳌﺼﻄﻠﺤﺎت‬
‫‪١٦ ,٢‬‬ ‫‪Code snippest‬‬

‫ﺟﺰء ﺑﺴﻴﻂ ﻣﻦ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ﺑﻐﺮض‬ ‫ﻣﺴﺮد اﳌﺼﻄﻠﺤﺎت‬
‫اﻟﻌﺮض واﻻﻳﻀﺎح‪.‬‬
‫‪٩٩ ,٤٣‬‬ ‫‪ampersands: &&.‬‬
‫‪٩٩ ,٩٢ ,٦٣ ,٥٨ ,٥٤ ,٥٢ ,٣٨ headers‬‬
‫اﺳﻢ ﻟﻠﺮﻣﺰ & اﳌﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﻴﺎت‬
‫اﻧﻈﺮ ‪Application heading‬‬
‫اﳌﻘﺎرﻧﺔ اﳌﻨﻄﻘﻴﺔ واﻟﺘﻲ ﺗﻔﺘﺮض اﺳﺘﻴﻔﺎء ﻛﺎﻓﺔ‬
‫‪١٠٣‬‬ ‫‪human interface guidelines‬‬
‫اﻟﺸﺮوط‪.‬‬
‫ﻋﺪد ﻣﻦ اﻟﻀﻮاﺑﻂ اﶈﺪدة ﻟﺘﻮﺿﻴﺢ اﻟﺘﺼﻤﻴﻢ‬
‫‪٩٨ ,١‬‬ ‫‪Apple‬‬
‫اﻻﻣﺜﻞ ﻟﻠﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﻟﻠﺒﺮﻧﺎﻣﺞ ﻟﻴﺼﻠﺢ‬
‫ﺷﺮﻛﺔ أﭘﻞ اﳌﻄﻮرة ﻟﻨﻈﺎم ﻣﺎﻛﻨﺘﻮش‬
‫ﻟﻠﺘﻌﺎﻣﻞ اﻻﻧﺴﺎﻧﻲ‪.‬‬
‫واﻟﺘﻜﻨﻮﻟﻮﺟﻴﺎ اﳌﺼﺎﺣﺒﺔ‪.‬‬
‫??‬ ‫‪IB / Interface Builder‬‬
‫‪٨١ ,٥٤‬‬ ‫‪Application heading‬‬
‫ﻣﺼﻤﻢ واﺟﻬﺔ اﻟﺒﺮاﻣﺞ اﻟﺮﺳﻮﻣﻴﺔ‪ .‬ﻟﻠﺘﻤﻜﻦ ﻣﻦ‬
‫اﻟﻼزﻣﺔ اﻟﺒﺎدﺋﺔ ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺼﺎدر‬
‫وﺿﻊ وﺿﺒﻂ ﻣﻮاﻗﻊ اﻟﻌﻨﺎﺻﺮ‪ ،‬وﺗﻮﺻﻴﻼﺗﻬﺎ‪.‬‬
‫واﳌﺘﻐﻴﺮات واﶈﺘﻮﻳﺎت اﳌﻄﻠﻮﺑﺔ ﻹﺟﺮاء ﲡﻤﻴﻊ‬
‫‪٧٣‬‬ ‫‪object-oriented programming‬‬
‫اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ ﺑﺎﳌﻠﻔﺎت اﻟﺮﻗﻤﻴﺔ‪.‬‬
‫اﺳﻠﻮب ﺑﺮﻣﺠﻲ ﻟﺒﻨﺎء اﻟﺒﺮاﻣﺞ ﻣﻦ ﺧﻼل‬
‫‪٩٩‬‬ ‫‪garbage collection‬‬
‫اﺳﺘﺨﺪام اﻟﻜﺎﺋﻨﺎت‪ ،‬وﻣﺎ ﻳﺘﺒﻊ ذﻟﻚ ﻣﻦ‬
‫ﺑﺮوﺗﻮﻛﻮل ﺑﺈﺗﻔﺎﻗﻴﺔ ﻣﻌﻴﻨﺔ ﻟﺘﻮﻓﻴﺮ وﲢﺮﻳﺮ ﻣﺼﺎدر‬
‫ﺿﻮاﺑﻂ وﻗﻮاﻋﺪ ﻟﻐﻮﻳﺔ ﲤﻴﺰ ﻫﺬﻩ اﻟﻠﻐﺔ‪.‬‬
‫اﻟﺬاﻛﺮة‪.‬‬
‫‪٣ ,١‬‬ ‫‪Objective-C‬‬
‫‪٥٥ ,٥٤‬‬ ‫‪Cocoa Application‬‬
‫ﺗ ّﻔﺮع ﻣﻦ ﻟﻐﺔ ‪ C‬اﻻم ﻳﻬﺪف ﻟﻠﺒﺮﻣﺠﺔ ﻣﻦ‬
‫ﺑﺮﻧﺎﻣﺞ ﻣﺒﻨﻲ ﻣﻦ ﺧﻼل ﻣﺎ ﺗﻮﻓﺮﻩ ﺗﻜﻨﻮﻟﻮﺟﻴﺎ و‬
‫ﺧﻼل ﺗﻮﻇﻴﻒ اﻟﻜﺎﺋﻨﺎت‪.‬‬
‫ﻣﻜﺘﺒﺎت ‪ Cocoa‬اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬
‫‪١٠٥‬‬
‫ﻣﺴﺮد اﳌﺼﻄﻠﺤﺎت‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫‪٩٢,١٠‬‬ ‫اﻋﺪاد ﻛﺴﺮﻳﺔ ‪fractional‬‬ ‫‪٣٦, ٩, ٨, ٤‬‬ ‫‪ ٤٣‬اﺧﻄﺎء اﻟﺒﺮﻣﺠﺔ‬ ‫‪OR‬‬

‫اﻻرﻗﺎم اﳊﻘﻴﻘﻴﺔ ذات اﻟﻔﺎﺻﻠﺔ اﻟﻌﺸﺮة ﻣﺜﻞ‬ ‫اﻟﺮﻣﺰ )أو( اﳌﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﻴﺎت اﳌﻘﺎرﻧﺔ إدﺧﺎﻻت ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﳌﻔﺮدات اﻟﻠﻐﺔ‪ ،‬او‬
‫اﻟﻌﺪد ‪ ٥٫٥‬او اﻟﻌﺪد ‪٢٫٧٥‬‬ ‫ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ ﻏﻴﺮ دﻗﻴﻘﺔ‪.‬‬ ‫اﳌﻨﻄﻘﻴﺔ‪.‬‬
‫‪٣١‬‬ ‫‪ ٢‬اﻛﻮاد ﺗﺸﻐﻴﻠﻴﺔ‬ ‫‪ ٩٩ ,٨٦ ,٧٠‬ارﺗﺒﺎط‬ ‫‪string‬‬
‫ﻛﻠﻤﺎت ﻣﺤﺠﻮزة ﻟﻠﻐﺔ ﻟﺘﻨﻔﻴﺬ ﻣﻬﺎم ﻣﻬﻴﻨﺔ‬ ‫ﺳﻠﺴﻠﺔ ﻣﻦ اﳊﺮوف اﳌﻜﻮﻧﺔ ﻟﻠ ّﻨﺼﻮص اﳌﻘﺮؤة‪ .‬ﻣﺆﺷﺮات ﻟﺮواﺑﻂ ﻣﺆدﻳﺔ ﳌﺰﻳﺪ ﻣﻦ اﳌﻌﻠﻮﻣﺎت‬
‫‪ -‬اﻧﻈﺮ اﻹﺟﺮاءات‬ ‫‪ ٩٨ ,٧٣ ,١٢‬ذات اﻟﻌﻼﻗﺔ‪.‬‬ ‫‪unsigned int‬‬
‫‪٧٢‬‬ ‫اﻻﺟﺮاءات اﳌﺘﻼزﻣﺔ ‪Accessors‬‬ ‫‪٥٠‬‬ ‫ازرار ‪Button‬‬ ‫اي رﻗﻢ ﺻﺤﻴﺢ ﻏﻴﺮ ﺳﺎﻟﺐ‪.‬‬
‫ﺗﺆام ﻣﻦ اﻹﺟﺮاءات ﺗﻨﺤﺼﺮ ﻣﻬﻤﺔ اﻻول ﺑﺈﺳﻨﺎد‬ ‫‪ ٥٢‬ﺗﺸﺒﻴﻪ ﻣﺠﺎزي ﻟﻠﻤﻔﺎﺗﻴﺢ اﻟﺘﻲ ﻳﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‬ ‫إﺟﺮاء‬
‫ﻗﻴﻤﺔ ﺑﻴﻨﻤﺎ اﻟﺜﺎﻧﻲ إﺳﺘﺮﺟﺎع ﻫﺬﻩ اﻟﻘﻴﻤﺔ‪.‬‬ ‫اﻟﺒﺸﺮ ﻓﻲ اﻟﻌﺎﻟﻢ اﳋﺎرﺟﻲ‪.‬‬ ‫ﻣﺠﻤﻮﻋﺔ اﻻواﻣﺮ واﻻﻳﻌﺎزات اﻟﺘﻲ ﲢﺪد ﻣﻬﺎم‬
‫‪٣٤ ,٢٣‬‬ ‫‪ ٩٨‬اﻻﻗﻮاس اﳌﻌﻘﻮﻓﺔ }{‬ ‫اﺷﺎرة ﻣﺮﺟﻌﻴﺔ ‪Referenc‬‬ ‫ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪ ٩٨‬ﻋﻨﺼﺮ ﻣﺆﺷﺮ ﻛﻤﺮﺟﻊ ﻟﻜﺎﺋﻦ او ﻋﻨﺼﺮ ﺑﺮﻣﺠﻲ‪ .‬ﻛﺘﻞ ﻣﺤﺪدة ﻟﻠﺸﺮوط واﳌﻌﻄﻴﺎت اﻟﺘﻲ ﺗﺘﻄﻠﺒﻬﺎ‬ ‫إﻓﻨﺎء‪/‬ﺗﺪﻣﻴﺮ اﻟﻜﺎﺋﻦ‬
‫‪ ٣٣‬ﺑﻌﺾ اﻹﺟﺮاءات واﳌﻔﺮدات اﶈﺠﻮزة ﺑﺎﻟﻠﻐﺔ‪.‬‬ ‫اﻃﺎر ‪Frame‬‬ ‫ﻋﻤﻠﻴﺔ ﲢﺮﻳﺮ ﺟﻴﺰ اﻟﺬاﻛﺮة اﶈﺠﻮز ﻟﻺﺣﺘﻔﺎظ‬
‫‪٤٣‬‬ ‫ﺑﻘﻴﻢ ﻋﻨﺼﺮ ﻛﺎﺋﻦ ﺑﺮﻣﺠﻲ إﻧﺘﻬﺖ اﳊﺎﺟﺔ ﻣﻨﻪ‪ .‬ﺗﺸﺒﻴﺔ ﻣﺠﺎزي ﳊﺎوﻳﺔ ﲡﻤﻊ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ اﻻﻳﻌﺎز اﻟﺸﺮﻃﻲ اﳌﻌﺸﺶ‬
‫‪. ٧٦‬ﺗﺪوﻳﺮ ﺷﻔﺮة اﻟﺒﺮﻣﺠﺔ ‪ ٢٣ code reuse‬إﺳﺘﻔﺴﺎرات ﺣﻮل ﻗﻴﻢ ﻣﻨﻄﻘﻴﺔ ﺑﺤﻴﺚ ﻳﻜﻮن‬ ‫إﻗﺤﺎم ‪implement‬‬
‫ﻛﻞ اﺳﺘﻔﺴﺎر ﻣﻀﻤﻦ ﺿﻤﻦ اﺳﺘﻔﺴﺎر آﺧﺮ‬ ‫دﻣﺞ وﺗﻀﻤﲔ ﺗﻮﺻﻴﻒ اﻹﺟﺮاءات اﻟﺘﻲ ﻳﺠﺐ إﻣﻜﺎﻧﻴﺔ إﻋﺎدة إﺳﺘﺨﺪام اﻹﺟﺮاءات ﻟﻌﻤﻞ‬
‫‪١١‬‬ ‫اﻟﺒﺎﻳﺖ‬ ‫ﻣﻬﺎﻣﻬﺎ ﻣﻊ ﻋﺪد ﻣﻦ اﳌﺘﻌﺎﻣﻠﲔ‪.‬‬ ‫إﺗﺒﺎﻋﻬﺎ ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﻜﺎﺋﻦ ﻟﻸواﻣﺮ‪.‬‬
‫‪ ١٠‬أﺻﻐﺮ وﺣﺪة ﻳﺴﺘﺨﺪﻣﻬﺎ اﳊﺎﺳﺐ ﻟﺘﺨﺰﻳﻦ‬ ‫‪ ٨‬اﻋﺪاد ﻛﺎﻣﻠﺔ‬ ‫إﻳﻌﺎز‬
‫اﳌﻌﻠﻮﻣﺎت‪.‬‬ ‫اﻻﻋﺪاد اﻟﺮﻳﺎﺿﻴﺔ اﻟﺼﺤﻴﺤﺔ واﳋﺎﻟﻴﺔ ﻣﻦ‬ ‫ﻛﻠﻤﺎت وﻣﻔﺮدات إﺟﺮاﺋﻴﺔ ﻣﺤﺠﻮزة ﻟﻌﻤﻞ‬
‫‪٢‬‬ ‫اﻟﺒﺮﻣﺠﺔ‬ ‫اﻟﻜﺴﻮر‪.‬‬ ‫ﻣﻬﻤﺔ ﻣﻌﻴﻨﺔ‪.‬‬
‫‪١٠٦‬‬
‫ﺟﻬﺎز ﻳ ّﺰود اﳌﺴﺘﺨﺪم ﲟﺆﺷﺮ ﻋﻠﻰ ﺷﺎﺷﺔ‬ ‫ﻋﻤﻮدﻳ َﺎ أو أﻓﻘﻴ َﺎ او اﻻﺛﻨﺎن ﻣﻌﺎً‪.‬‬ ‫ﻋﺪد ﻣﻦ اﻟﺘﻮﺟﻴﻬﺎت واﻻواﻣﺮ اﻟﺘﻲ ﻳﻘﻮم‬
‫اﳊﺎﺳﺐ‪ ،‬ﻛﺘﺸﺒﻴﺔ ﻣﺠﺎزي ﻟﻴﺪ اﳌﺴﺘﺨﺪم‪.‬‬ ‫‪١٧‬‬ ‫اﻟﺪاﻻت اﻟﻮﻇﻴﻔﻴﺔ‬ ‫اﳊﺎﺳﺐ ﺑﺘﻨﻔﻴﺬﻫﺎ‪.‬‬
‫‪٥٨‬‬ ‫اﻟﻘﺎﺋﻤﺔ اﻟﻌﻠﻴﺎ ‪Manu Bar‬‬ ‫‪ ٧٦‬ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻹﺟﺮاءات ﺗﺆدي وﻇﻴﻔﺔ ﻣﻌﻴﻨﺔ‪.‬‬ ‫اﻟﺒﺮوﺗﻮﻛﻮل‬
‫ﻣﺠﻤﻮﻋﺔ اﻹﺟﺮاءات اﳌﺘﺎﺣﺔ ﻟﻠﻤﺴﺘﺨﺪم‬ ‫إﺟﺮاءات ذات ﺻﻴﻐﺔ وﺗﺮﺗﻴﺒﺎت ﻋﻤﻞ ﻣﻮﺣﺪة اﻟﺪوال‪/‬اﻟﺪاﻻت اﻟﺒﺮﻣﺠﻴﺔ ‪١٨ function‬‬
‫ﺣﺴﺐ اﻟﺒﺮﻧﺎﻣﺞ ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ وﺗﻮﺟﺪ ﺑﺎﳌﺴﺎﺣﺔ‬ ‫‪ ٣٣‬ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻹﺟﺮاءات ﺗﺆدي وﻇﻴﻔﺔ ﻣﻌﻴﻨﺔ‬ ‫اﻟﺘﺮﺗﻴﺐ اﻻﻓﺘﺮاﺿﻲ‬
‫اﻟﻌﻠﻴﺎ ﻣﻦ اﻟﺸﺎﺷﺔ‪.‬‬ ‫اﻟﻨﺴﻖ اﳌﻌﺪ او اﻟﻘﻴﻤﺔ اﳌﺴﻨﺪة إﻓﺘﺮاﺿﻴ ًﺎ وﻗﺖ ﻣﻊ إرﺟﺎع ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ‪.‬‬
‫‪٣‬‬ ‫اﳌﺎﻛﻨﺘﻮش ‪Macintosh‬‬ ‫‪٩‬‬ ‫اﻟﺴﺎﻃﺮة اﻟﺴﻔﻠﻴﺔ ”ـ“ ‪Underscore‬‬ ‫إﻧﺸﺎء اﻟﻌﻨﺼﺮ أو اﻟﻜﺎﺋﻦ‪.‬‬
‫ﻧﻈﺎم ﺗﺸﻐﻴﻞ ﺑﺘﻜﻨﻮﻟﻮﺟﻴﺎ ﻣﺘﻄﻮرة ﻳﻌﺘﻤﺪ‬ ‫‪ ١١‬رﻣﺰ ﺣﺮﻓﻲ ﻣﻦ اﳊﺮوف اﳌﺘﻮﻓﺮة ﺑﻠﻮﺣﺔ اﳌﻔﺎﺗﻴﺢ‬ ‫اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﳌﺘﻐﻴﺮ‬
‫ﻣﻜﺘﺒﺎت رﺳﻮﻣﻴﺔ وﻛﺎﺋﻨﺎت ﺑﺮﻣﺠﻴﺔ ﻗﺎﺑﻠﺔ ﻹﻋﺎدة‬ ‫‪٥٦‬‬ ‫اﻟﺴﺤﺐ واﻻﻓﻼت‬ ‫ﻋﻘﺪ إﺗﻔﺎق ﳊﺠﺰ ﺣﻴﺰ ﻣﻦ اﻟﺬاﻛﺮة ﻳﺪﻋﻰ‬
‫اﻻﺳﺘﺨﺪام ﺑﻀﻮاﺑﻂ ﻣﻌﻴﻨﺔ‪.‬‬ ‫اﺳﻠﻮب ﺗﻌﺎﻣﻞ ﻓﺮﻳﺪ ﻣﻦ ﻣﻮاﺻﻔﺎت اﻧﻈﻤﺔ‬ ‫ﺑﺎﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻧﻮع واﺳﻢ اﳌﺘﻐﻴﺮ‪.‬‬
‫‪٨‬‬ ‫اﳌﺘﻐﻴﺮات ‪Variables‬‬ ‫‪ ٧٧‬ﺗﺸﻐﻴﻞ أﭘﻞ‪.‬‬ ‫اﻟﺘﺼﻔﺢ‬
‫ﺣﺎوﻳﺎت ﺗﺨﺰن ﻗﻴﻢ ﺑﺎﻧﻮاع ﻣﻌﻴﻨﺔ‪ ،‬ﲢﺘﻞ ﺟﺰء‬ ‫‪٤١‬‬ ‫إﺳﺘﻌﺮاض اﳌﻌﻠﻮﻣﺎت وﻓﻖ ﻣﻈﻬﺮ وﺗﺮﺗﻴﺐ ﻣﻌﲔ‪ .‬اﻟﺸﺮط اﳌﻨﻄﻘﻲ‬
‫ﻣﻦ ذاﻛﺮة اﳋﺎﺳﺐ اﻻﻟﻲ‪.‬‬ ‫‪ ٦٣‬ﻋﻤﻠﻴﺔ إﺳﺘﻴﻔﺎء ﻟﺸﺮط ﺗﻨﺤﺼﺮ ﻋﻤﻠﻴﺎت اﻟﻘﻴﻢ‬ ‫اﻟﺘﻮﺻﻴﻼت‬
‫‪٨‬‬ ‫اﳌﺠﻤﻊ ‪compiler‬‬ ‫ّ‬ ‫ﺣﺠﺰ ﻣﺘﻐﻴﺮات ﻟﻠﻌﻨﺎﺻﺮ ﻣﻦ ﺧﻼل اﻟﺘﻄﺒﻴﻖ ‪ IB‬ﻓﻴﻪ ﺑﺼﺤﻴﺢ او ﻏﻴﺮ ﺻﺤﻴﺢ‪.‬‬
‫ﺑﺮﻧﺎﻣﺞ ﳝﺜﻞ اﳌﺮﺣﻠﺔ اﻟﺘﻲ ﺗﻠﻲ ﺗﻔﺴﻴﺮ اﻟﺸﻔﺮة‬ ‫‪٢‬‬ ‫اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ ‪Code‬‬ ‫‪٣٨‬‬ ‫اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ ‪Braek Point‬‬
‫اﻟﺒﺮﻣﺠﻴﺔ وﺟﻠﺐ اﳌﺼﺎدر اﻟﻼزﻣﺔ ﻟﺘﺤﻮﻳﻠﻬﺎ اﻟﻰ‬ ‫رﻣﻮز وﻣﻔﺮدات اﻟﻠﻐﺔ اﻟﺒﺮﻣﺠﻴﺔ ﺣﻴﺚ ﺗﻜﻮن‬ ‫ﺣﺎﻟﺔ ﻣﻦ اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ ﻟﺘﻔﺤﺺ ﻣﻌﻄﻴﺎت‬
‫ﻟﻐﺔ اﻻﻟﺔ‪.‬‬ ‫ﻋﺒﺎرة ﻋﻦ ﻛﺘﻞ ﺗﻌﺮف ﺑﺎﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬ ‫اﻟﻌﻨﺎﺻﺮ اﻟﺒﺮﻣﺠﻴﺔ ﺑﺎﻟﺒﺮﻧﺎﻣﺞ ﻗﻴﺪ اﻟﺘﻔﺤﺺ‪.‬‬
‫‪٧‬‬ ‫اﳌﺴﺎﺋﻞ اﻟﺒﺮﻣﺠﻴﺔ‬ ‫‪ ٧١‬اﳌﺴﺘﺨﺪﻣﺔ ﻟﺒﻨﺎء اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬ ‫اﳋﻠﻴﺔ‬
‫ﻋﻤﻠﻴﺔ ﲢﻮﻳﻞ ﻣﺸﻜﻼت ﺣﺴﺎﺑﻴﺔ وﻣﺘﻄﻠﺒﺎت‬ ‫‪٥٠‬‬ ‫اﻟﻔﺄرة‬ ‫ﺗﺸﺒﻴﻪ ﻣﺠﺎزي ﻟﻌﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ اﳌﻜﺮرة‬
‫‪١٠٧‬‬
‫‪ ٥٨‬اﻟﻜﺎﺋﻦ‪ ،‬ﺣﺘﻰ ﻳﺘﻌﺎﻣﻞ اﳊﺎﺳﺐ ﻣﻌﻬﺎ ﻳﺠﺐ‬ ‫اﻟﻨﻤﻮذج اﻻب ‪superclass‬‬ ‫ﻋﻤﻞ وﻣﻬﺎم اﻟﻌﺎﻟﻢ اﳋﺎرﺟﻲ اﻟﻰ ﺻﻴﻎ رﻳﺎﺿﻴﺔ‬
‫ﺗﻮﺻﻴﻒ ﻟﻠﻜﺎﺋﻦ اﻟﺒﺮﻣﺠﻲ ﺑﺤﻴﺚ ﻳﺴﺘﻘﻲ ﻣﻨﻪ اﻟﺘﺼﺮﻳﺢ ﻋﻨﻬﺎ ﻟﺘﻮﻓﻴﺮ اﳊﺠﺰ اﳌﻨﺎﺳﺐ ﻣﻦ‬ ‫وﻣﻌﺎدﻻت ﻗﺎﺑﻠﺔ ﻟﻠﺤﻞ ﻣﻦ ﺧﻼل اﳊﺎﺳﺐ‪.‬‬
‫‪ ٩١‬اﻟﻜﺎﺋﻦ اﻟﻮرﻳﺚ او اﻟﻜﺎﺋﻨﺎت اﻟﻮرﻳﺜﺔ ﻣﺎ ﻳﺤﺘﻮﻳﻪ اﻟﺬاﻛﺮة اﳌﺘﺎﺣﺔ‪.‬‬ ‫اﳌﺼﻔﻮﻓﺎت‬
‫‪٤‬‬ ‫ﺑﺮﻣﺠﻴﺎت‬ ‫اﻻب ﻣﻦ ﻣﻮاﺻﻔﺎت وإﺟﺮاءات‪.‬‬ ‫ﳕﻂ ﻣﻦ اﳌﺘﻐﻴﺮات اﻟﺘﻲ ﺗﺨﺰن ﻗﻴﻢ‪/‬ﻛﺎﺋﻨﺎت‬
‫اﻟﻨﻤﻮذج اﻟﺘﺼﻨﻴﻔﻲ ‪ ٥٢ Class Template‬ﺑﺮاﻣﺞ ﲢﻘﻖ ﻧﻔﻌﻴﺔ ﻣﻌﻴﻨﺔ دون ان ﺗﻜﻮن ﻣﻦ‬ ‫ﻣﺘﺠﺎﻧﺴﺔ‪.‬‬
‫ﺿﻤﻦ اﻟﺒﺮاﻣﺞ اﻟﻜﺒﻴﺮة‪.‬‬ ‫‪ ١٢‬ﻣﻮﺻﻔﺎت ﻟﻠﺘﺼﻨﻴﻒ ﺗﺴﺘﺨﺪم ﻛﻨﻤﺎذج‬ ‫اﳌُﻌﺎ ِﻣﻼت اﳊﺴﺎﺑﻴﺔ‬
‫‪٥٠‬‬ ‫ﺑﺮﻧﺎﻣﺞ ‪Safari‬‬ ‫اﻟﻌﻠﻤﻴﺎت اﳊﺴﺎﺑﻴﺔ اﻟﺮﻳﺎﺿﻴﺔ اﻟﺘﻲ ﻳﺘﻢ ﺗﻄﺒﻴﻘﻬﺎ ﻫﻴﻜﻠﻴﺔ ﻟﺒﻨﺎء ﻣﺎ ﻳﻠﻲ ﻣﻦ ﻛﺎﺋﻨﺎت‪.‬‬
‫‪ ٣٨‬ﺑﺮﻧﺎﻣﺞ أﭘﻞ ﻟﺘﺼﻔﺢ ﻣﻮاﻗﻊ اﻻﻧﺘﺮﻧﺖ‪.‬‬ ‫اﻟﻬﻮاﻣﺶ‬ ‫ﻋﻠﻰ اﻻﻋﺪاد‪.‬‬
‫‪١‬‬ ‫ﺑﺮﻧﺎﻣﺞ ‪Xcode‬‬ ‫‪ ٥١‬ﻋﻤﻠﻴﺔ ﺗﺮﺗﻴﺐ وﺗﻨﺴﻴﻖ ﻧﺼﻮص اﻟﺸﻔﺮة‬ ‫اﳌﻨﺼﺔ ‪Dock‬‬
‫واﺟﻬﺔ إﻧﺸﺎء اﻟﺒﺮاﻣﺞ وﲡﻤﻴﻊ اﻟﺸﻔﺮات‬ ‫اﻟﺒﺮﻣﺠﻴﺔ ﲟﺴﺎﺣﺎت ﻓﺎرﻏﺔ ﻟﺴﻬﻮﻟﺔ اﻟﻘﺮاءة‬ ‫ﺷﺮﻳﻂ ﻳﺤﺘﻔﻆ ﲟﺆﺷﺮات ﻟﻠﺒﺮاﻣﺞ اﻟﺘﻲ‬
‫اﻟﺒﺮﻣﺠﻴﺔ ﻣﻦ ﺧﻼل ﻋﺪة ﻟﻐﺎت ﻣﺜﻞ ‪coca,‬‬ ‫وﺗﻌﻴﲔ اﻟﺘﻌﺸﻴﺶ اﳋﺎص ﺑﻜﻞ داﻟﺔ‪.‬‬ ‫ﻳﺴﺘﺨﺪﻣﻬﺎ او ﻳﻌﺘﻤﺪﻫﺎ اﳌﺴﺘﺨﺪم‪.‬‬
‫‪carbon,java‬‬ ‫‪٤٠‬‬ ‫‪ ٥٦‬اﻟﻮاﺟﻬﺔ اﻟﺮﺳﻮﻣﻴﺔ ﻟﻠﻨﻈﺎم‬ ‫اﻟﻨﺎﻓﺬ اﻟﺮﺋﻴﺴﺔ‬
‫اﻟﺘﺸﺒﻴﻬﺎت اﳌﺠﺎزﻳﺔ ﻟﻠﻌﻨﺎﺻﺮ ﺑﺎﻟﻌﺎﻟﻢ اﳋﺎرﺟﻲ‪ ،‬ﺗﻘﺼﻲ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ‪٣٩ debugger‬‬ ‫اﻟﻨﺎﻓﺬة اﻟﺮﺋﻴﺴﺔ اﻟﺘﻲ ّﲤﺜﻞ ﻛﺎﻓﺔ ﺗﻌﺎﻣﻼت‬
‫ﺑﺮﻧﺎﻣﺞ ﻣﺘﺨﺼﺺ ﻟﺘﻔﺤﺺ اﺧﻄﺎء وﻣﻌﻄﻴﺎت‬ ‫داﺧﻞ ﺷﺎﺷﺔ اﳊﺎﺳﺐ ﻣﻦ إزرار وﻧﻮاﻓﺬ‬ ‫اﳌﺴﺘﺨﺪم ﻣﻊ اﻟﺒﺮﻧﺎﻣﺞ ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ‪.‬‬
‫وﺳﻴﺮ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻗﻴﺪ اﻟﺒﻨﺎء‪.‬‬ ‫اﻟﻨﻄﺎق اﶈﻠﻲ ﻟﻠﺪاﻟﺔ ‪ ٢٣ variable scope‬وﻛﺎﺋﻨﺎت رﺳﻮﻣﻴﺔ‪.‬‬
‫‪٦٩‬‬ ‫‪ُ ٢١‬ﺑﻨﻴﺔ اﻻﺟﺮاء‬ ‫داﻻت ﺗﻌﻴﺪ ﻗﻴﻤﺔ ‪return a value‬‬ ‫ﻋﻤﻠﻴﺔ ﺣﺠﺐ وﺣﻤﺎﻳﺔ اﺳﻤﺎء اﻟﺘﻐﻴﺮات‬
‫ﻛﺘﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﻟﺘﻲ ﺗﻮﺻﻒ ﺳﻴﺮ ﻋﻤﻞ‬ ‫وﻣﺤﺘﻮﻳﺎﺗﻬﺎ داﺧﻞ ﻧﻄﺎق اﻟﺪاﻟﺔ دون اﻟﺘﻌﺎرض‬
‫‪ ٨٣, ٢٠‬ﻫﺬا اﻻﺟﺮاء‪.‬‬ ‫اﻧﻮاع اﻟﺒﻴﺎﻧﺎت‬ ‫ﻣﻊ ﺗﺸﺎﺑﺔ اﻻﺳﻤﺎء ﻓﻲ ﺣﺎل وﺟﺪ ﺧﺎرج‬
‫‪٢٣‬‬ ‫ﻟﻠﺒﻴﺎﻧﺎت اﻧﻮاع ﻣﻨﻬﺎ اﻟﻌﺪد وﻣﻨﻬﺎ اﻟﻨﺺ وﻣﻨﻬﺎ ﺑﻨﻴﺔ اﻟﺪاﻟﺔ‬ ‫ﻧﻄﺎﻗﻬﺎ‪.‬‬
‫‪١٠٨‬‬
‫‪ ١‬ﺗﻨﻔﺬ وﻓﻖ ﻋﺪد ﻣﻌﲔ ﻣﻦ اﳌﺮات ﺑﻨﺎء ﻋﻠﻰ ﺷﺮط‬ ‫ﺗﻄﺒﻴﻘﺎت‬ ‫اﻧﻈﺮ ﺑﻨﻴﺔ اﻹﺟﺮاء‬
‫ﻣﻨﻄﻘﻲ ﻣﺤﺪد ﻣﻦ ﻗﺒﻞ اﳌﺒﺮﻣﺞ‪.‬‬ ‫‪ ١٩‬ﻣﺤﻤﻮﻋﺔ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺆدي ادوار وﻣﻬﺎم‬ ‫ﺑﻨﻴﺔ ﻏﻴﺮ ﻣﻬﻴﻜﻠﺔ ‪unstructured‬‬
‫ﺣﻠﻘﺔ اﻟﺘﻜﺮار ‪٩٤ ,٤٧ ,٤٦ for-loop‬‬ ‫ﺑﺮﻣﺠﻴﺔ‬ ‫ﺑﺮﻧﺎﻣﺞ ﻣﻜﻮن ﻣﻦ ﻋﺪد ﻣﻦ اﳌﻜﻮﻧﺎت اﻟﻐﻴﺮ‬
‫‪ ٥٨‬ﻛﺘﻠﺔ ﻣﺤﺘﻮﻳﺔ ﻟﻌﺪد ﻣﻦ اﻹﺟﺮاءات‪ ،‬واﻟﺘﻲ ﺗﻨﻔﺬ‬ ‫ﺗﻌﺎودﻳﺔ‬ ‫ﻣﺮﺗﺒﺔ ﺑﺸﻜﻞ ﻣﻨﻄﻘﻲ‪.‬‬
‫وﻓﻖ ﻋﺪد ﻣﻌﲔ ﻣﻦ اﳌﺮات‪.‬‬ ‫‪ ٥٤, ٣٨‬إﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻟﺬاﺗﻪ ﺿﻤﻦ إﺟﺮاءاﺗﻪ‬ ‫ﺗﺮوﻳﺴﺎت ‪headers‬‬
‫‪٥٦‬‬ ‫ﺧﺼﺎﺋﺺ ‪proprity‬‬ ‫اﻟﺪاﺧﻠﻴﺔ‪.‬‬ ‫اﻧﻈﺮ‬
‫‪ ٥٦‬ﻗﻴﻢ ﻣﻜﻨﻮﻧﺎت وﺧﺼﺎﺋﺺ اﻟﻌﻨﺼﺮ اﻟﺒﺮﻣﺠﻲ أو‬ ‫ﺗﻌﻠﻴﻖ ﻣﻘﺘﻀﺐ‬ ‫ﺗﺮوﻳﺴﺔ اﻟﺘﻄﺒﻴﻘﺎت‬
‫اﻟﻜﺎﺋﻦ‪.‬‬ ‫ﳕﺎذج ﻣﺒﻴﺘﻪ ﻣﻦ اﳌﺼﺎدر واﻟﻜﺘﻞ اﻟﺒﺮﻣﺠﻴﺔ وﻫﻲ ﺗﻔﺴﻴﺮ ﻣﺨﺘﺼﺮ دون اﻟﺘﻌﻤﻖ ﻟﺸﺮح اﻟﻔﻜﺮة‪.‬‬
‫‪٤٦‬‬ ‫ﺧﻄﻮات اﻟﺰﻳﺎدة ”‪“steps‬‬ ‫‪٢٢‬‬ ‫ﺗﻔﺴﻴﺮ‬ ‫ﺟﺎﻫﺰة ﻟﻺﺳﺘﺨﺪام اﻟﻔﻮري‪.‬‬
‫‪١٨‬‬ ‫ﻋﻤﻠﻴﺔ ﺗﻘﻴﻴﻢ ﻣﻔﺮدات اﻻﺟﺮاءات اﻟﺒﺮﻣﺠﻴﺔ ﻓﻮر داﻟﺔ )(‪main‬‬ ‫‪٧١‬‬ ‫ﺗﺼﺮﻳﺤﺎت‬
‫اﻟﺪاﻟﺔ اﻟﺮﺋﻴﺴﺔ ﺑﺸﻔﺮة اﻟﺒﺮﻣﺠﺔ ﻋﻨﺪ ﺗﺸﻐﻴﻞ اي‬ ‫ﻋﻘﺪ اﺗﻔﺎق ﻣﻊ اﳊﺎﺳﺐ ﳊﺠﺰ ﺣﻴﺰ ﻣﻦ اﻟﺬاﻛﺮة ﺗﻠﻘﻴﻬﺎ‪ ،‬وﻫﻲ ﻋﻤﻠﻴﺔ ﺑﻄﻴﺌﺔ ﻧﺴﺒﻴﺎً‪.‬‬
‫‪ ٥٨‬ﺑﺮﻧﺎﻣﺞ‪.‬‬ ‫ﺗﻜﻴﻴﻒ ‪override‬‬ ‫ﻣﺼﺮح ﻋﻨﻪ‪.‬‬‫ﳌﺘﻐﻴﺮ أو ﻛﺎﺋﻦ ّ‬
‫‪٣٣‬‬ ‫ﺳﻄﺮ اﻻواﻣﺮ‪Command Line‬‬ ‫‪ ٥٧ ,٥١‬ﺗﻐﻴﺮ ﻃﻔﻴﻒ ﻓﻲ أداء ﻋﻤﻞ ﻣﺼﻨﻒ او إﺟﺮاء‬ ‫ﺗﺼﻨﻴﻒ ‪Class‬‬
‫‪٥٨‬‬ ‫ﺳﻼﻟﺔ اﻟﺘﺼﻨﻴﻒ‬ ‫ﺑﺎﻟﺒﺮﻧﺎﻣﺞ‬ ‫ﻛﺎﺋﻦ ﺑﺮﻣﺠﻲ ﻣﻦ ﺳﻼﻟﺔ ﻣﻌﻴﻨﺔ ﺑﻌﺪد ﻣﻦ‬
‫‪ ٥٢‬ﻧﻮع اﻟﺴﻼﻟﺔ اﻟﺘﻲ ﻳﺮث ﻣﻨﻬﺎ اﻟﻜﺎﺋﻦ ﺻﻔﺎﺗﻪ‪.‬‬ ‫ﺣﻘﻞ ﻧﺺ ‪text field‬‬ ‫اﻟﺘﻮﺻﻴﻔﺎت واﻻﺟﺮاءات واﻟﻮﻇﺎﺋﻒ اﳌﻔﻴﺪة‪.‬‬
‫‪٢٦‬‬ ‫ﺗﺸﺒﻴﺔ رﺳﻮﻣﻲ ﻣﺠﺎزي ﻟﻠﺤﻘﻞ اﳌﺘﺎح ﻹﺳﺘﻘﺒﺎل ﺳﻠﺴﺔ اﳊﺮوف ‪string‬‬ ‫ﺗﺼﻨﻴﻒ اﻋﻠﻰ‪٥٧Root Class/Super Class‬‬
‫ﺳﻠﺴﻠﺔ اﳊﺮوف اﳌﻜﻮﻧﺔ ﻟﻠﻨﺼﻮص‪ ،‬ﺣﻴﺚ ﻳﺘﻢ‬ ‫ادﺧﺎﻻت اﳌﺴﺘﺨﺪم ﻣﻦ اﻟﻨﺼﻮص‪.‬‬ ‫اﻻب اﳌ ّﻮرث ﻓﻲ ﺳﻠﺴﻠﺔ اﻟﻮراﺛﺔ‬
‫‪ ٤٧‬اﻻﺷﺎرة ﶈﺘﻮﻳﺎﺗﻬﺎ ﻣﻦ ﺣﺮوف وﻛﻠﻤﺎت‪.‬‬ ‫ﺣﻠﻘﺔ )( ‪do {} while‬‬ ‫‪٥٨‬‬ ‫ﺗﺼﻨﻴﻒ ﻣﺘﺤﺪر ‪sub-Class‬‬
‫‪٨٣ ,٥٧‬‬ ‫ﺳﻠﺴﻠﺔ اﻟﺘﻮارث‪ /‬اﻟﻮراﺛﺔ‬ ‫ﻛﺘﻠﺔ ﻣﺤﺘﻮﻳﺔ ﻟﻌﺪد ﻣﻦ اﻹﺟﺮاءات‪ ،‬واﻟﺘﻲ‬ ‫اﻻﺑﻦ اﳌﺘﺤﺪر ﻣﻦ ﺳﻠﺴﻠﺔ اﻟﻮراﺛﺔ‪.‬‬
‫‪١٠٩‬‬
‫ﻣﺠﻠﺪ ادوات اﻟﺒﺮﳝﺠﺎت اﳌﺴﺎﻧﺪة ﺑﺎﻟﻨﻈﺎم‪.‬‬ ‫اﻟﻨﺼﻲ او اﻟﻜﺎﺋﻦ‬

‫اﳌ ّﻮﺻﻒ اﻟﻌﺪدي او ّ‬ ‫ﻣﻮﻗﻊ ﺗﺼﻨﻴﻒ اﻟﻜﺎﺋﻦ ﻣﻦ اﻟﺴﻼﻟﺔ اﻟﺘﻲ ﻳﺮث‬
‫‪٤‬‬ ‫ﻣﺠﻠﺪ اﻟﺘﻄﺒﻴﻘﺎت ‪Applications‬‬ ‫اﳌﺴﺘﺨﺪم ﻹﺟﺮاء ﻋﻤﻠﻴﺎت ﻣﻔﺎرﻧﺔ وﻛﻤﻴﺎت‪.‬‬ ‫ﻣﻨﻬﺎ ﺻﻔﺎﺗﻪ‪.‬‬
‫‪ ٧٧‬ﻣﺠﻠﺪ اﻟﺒﺮاﻣﺞ ﺑﺎﻟﻨﻈﺎم‪.‬‬ ‫ﻗﻴﻤﺔ اﻓﺘﺮاﺿﻴﺔ ‪Default Value‬‬ ‫‪٥٥‬‬ ‫ﺷﺮﻳﻂ اﻷدوات ‪Tool Bar‬‬
‫‪٩١‬‬ ‫ﻣﺠﻤﻮﻋﺔ ﻣﺘﺠﺎﻧﺴﺔ‬ ‫ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﺗﺴﺘﺨﺪم وﻗﺖ إﻧﺸﺎء اﳌﺘﻐﻴﺮ أو‬ ‫ﺗﺸﺒﻴﻪ ﻣﺠﺎزي ﻟﺸﺮﻳﻂ ﻣﺤﺘﻮي ﻷزرار ﺗﺆدي‬
‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻌﻨﺎﺻﺮ اﻟﺘﻲ ﺗﺸﺘﺮك ﺑﺬات‬ ‫اﻟﻜﺎﺋﻦ‪.‬‬ ‫ﻋﺪد ﻣﻦ اﻹﺟﺮاءات‪.‬‬
‫‪ ٥٠‬اﻟﺘﺮﻛﻴﺐ اﻟﺒﻨﻴﻮي أو اﻹﺟﺮاءات واﻟﺼﻔﺎت ﻣﻊ‬ ‫ﻛﺎﺋﻨﺎت ﺑﺮﻣﺠﻴﺔ‬ ‫‪٩٨‬‬ ‫ﻋﺪاد اﻟﺮواﺑﻂ‬
‫اﺧﺘﻼف اﻟﻘﻴﻢ اﳌﺴﻨﺪة‪.‬‬ ‫ﻣﻮﺻﻔﺎت ﺑﺮﻣﺠﻴﺔ ﳌﺠﻤﻮﻋﺔ ﻣﻦ اﻹﺟﺮاءات‬ ‫ّ‬ ‫ﺗﻜﻨﻴﻚ ﺑﺮﻣﺠﻲ ﻣﺴﺘﺨﺪم ﻟﻠﺤﻔﺎط ﻋﻠﻰ‬
‫ﻣﺮاﻗﺐ اﻟﻨﺸﺎﻃﺎت ‪٤ Activity Monitor‬‬ ‫واﻟﻮﻇﺎﺋﻒ‪.‬‬ ‫ﻣﺼﺎدر اﻟﺬاﻛﺮة وإﻓﻨﺎء اﻟﻜﺎﺋﻨﺎت اﻟﻐﻴﺮ‬
‫‪ ١٨‬ﺑﺮﳝﺞ ﻣﺴﺎﻧﺪة ﳌﺮاﻗﺒﺔ اداء اﻟﻨﻈﺎم وﺣﺼﺮ ﻟﻠﺒﺮاﻣﺞ‬ ‫ﻛﻠﻤﺔ ﻣﺤﺠﻮزة‬ ‫ﻣﺴﺘﺨﺪﻣﺔ‪.‬‬
‫ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ ﻣﻊ ﻣﺪى اﳌﺼﺎدر اﳌﺴﺘﻬﻠﻜﺔ‬ ‫ﻟﻜﻞ ﻟﻐﺔ ﺑﺮﻣﺠﻴﺔ ﻛﻠﻤﺎﺗﻬﺎ اﶈﺠﻮزة ﻟﻠﺪﻻﻟﺔ‬ ‫‪٣٤‬‬ ‫ﻋﻼﻣﺔ اﳌﺮﺑﻊ ‪#‬‬
‫ﻣﺴﺘﻨﺴﺦ اﻟﺘﺼﻨﻴﻒ ‪٥١ class instance‬‬ ‫ﻋﻠﻰ ﺗﻨﻔﻴﺬ إﺟﺮاءات ﺑﻌﻴﻨﻬﺎ‪.‬‬ ‫رﻣﺰ اﳌﺮﺑﻊ اﳌﺴﺘﺨﺪم ﳉﻠﺐ ﻣﺼﺎدر وﻛﻮاد‬
‫‪ ٧٩ ,٥٧‬ﻣﺆﺷﺮ ﺧﻔﻴﻒ ﻛﻨﺴﺨﺔ ﻣﺴﺘﻘﻠﺔ ﳌّﻮﺻﻒ اﻟﻜﺎﺋﻦ‬ ‫ﻟﻐﺔ ‪C‬‬ ‫ﺑﺮﻣﺠﻴﺔ ﺑﺒﺎدﺋﺔ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‪.‬‬
‫اﻟﺒﺮﻣﺠﻲ اﻟﻨﻤﻮذج‪.‬‬ ‫ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ اﻟﺒﻨﻴﻮﻳﺔ ﻣﻦ اﺳﺎس ‪ Ansi‬واﻟﺘﻲ‬ ‫‪٨‬‬ ‫ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ";"‬
‫‪٣٣‬‬ ‫ﻣﺴﺘﻮى ﺟﺬري واﺣﺪ ‪Flat Level‬‬ ‫ﺗﺨﺎﻃﺐ اﻻﻟﺔ ﻣﻦ ﺧﻼل ﻋﺪد ﻣﺤﺪود ﻣﻦ‬ ‫رﻣﺰ اﻟﻔﺎﺻﻠﺔ اﳌﻨﻘﻮﻃﺔ‪ ،‬ﺣﻴﺚ ﺗﺴﺘﺨﺪم‬
‫ﺗﺴﺎوي ﺗﺮﺗﻴﺐ ﻛﺎﻓﺔ اﻟﻌﻨﺎﺻﺮ ﻋﻠﻰ ﻣﺴﻄﺢ او‬ ‫اﳌﻔﺮدات واﻟﻜﺘﻞ اﻟﺒﺮﻣﺠﻴﺔ اﳌﻔﻬﻮﻣﺔ ﻟﻠﺒﺸﺮ‪.‬‬ ‫ﻟﻺﺳﺘﺪﻻل ﻋﻠﻰ إﻧﺘﻬﺎء اﻟﺴﻄﺮ اﻟﺒﺮﻣﺠﻲ‪.‬‬
‫‪ ٦١‬ﻣﺘﺴﻮى واﺣﺪ‪.‬‬ ‫ﻟﻮﻳﺤﺔ ‪Tab‬‬ ‫ﻗﺎﺋﻤﺔ ﻣﻨﺴﺪﻟﺔ ‪٥٦ ,٣٩ pop-up menu‬‬
‫‪٥٣ ,٢٠‬‬ ‫ﻣ ّﻌﺮف رﺳﻮﻣﻲ ﻛﺘﺸﺒﻴﺔ ﻣﺠﺎزي ﻟﺘﺒﻮﻳﺐ ﻣﻌﲔ ﻣﻌﺎﻣﻞ اﻟﺪاﻟﺔ ‪Argument‬‬ ‫ﻧﺎﻓﺬة ﻣﺒﻴﺘﻪ ﻟﻌﺬد ﻣﻦ اﻹﺟﺎراءات واﻻواﻣﺮ‪،‬‬
‫اﻟﻘﻴﻤﺔ‪/‬اﻟﻘﻴﻢ أو اﻟﻜﺎﺋﻦ‪/‬اﻟﻜﺎﺋﻨﺎت اﻟﻼزﻣﺔ‬ ‫ﻣﻦ اﻟﺒﻴﺎﻧﺎت واﳌﻌﻄﻴﺎت‪.‬‬ ‫ﺗﻌﺮض ﻣﺤﺘﻮﻳﺎﻫﺎ وﻗﺖ اﻟﻀﻐﻂ ﻋﻠﻴﻬﺎ‪.‬‬
‫ﻣﺠﻠﺪ اﻻدوات ‪ ٩٨ ,٤ Utilities Folder‬إدﺧﺎﻟﻪ ﺿﻤﻦ ﺗﻨﻔﻴﺬ ﺗﻠﻚ اﻟﺪاﻟﺔ‪.‬‬ ‫‪١١‬‬ ‫ﻗﻴﻤﺔ ‪Value‬‬
‫‪١١٠‬‬
‫ﻋﻠﻰ إﺟﺮاءات وﻣﻌﺎﻣﻼت ﺗُﺪﺧﻞ ﻳﺪوﻳﺎً‪ ،‬ﻫﺬﻩ‬ ‫‪ ١٩‬ﻧﻄﺎق اﻟﺪاﻟﺔ ﺑﻌﻴﻨﻬﺎ‪.‬‬ ‫ﻣﻌﺸﺶ ‪Nesting‬‬
‫اﻟﻮاﺟﻬﺔ ﺗﺴﺘﺨﺪم اﻟﻨﺼﻮص ﻓﻘﻂ‪.‬‬ ‫‪١‬‬ ‫ﻧﻈﺎم ‪Mac OS X‬‬ ‫ﺗﻌﺸﻴﺶ‪ ،‬ﲟﻌﻨﻰ ﺗﻀﻤﲔ ﻋﻤﻠﻴﺎت إﺟﻮاﺋﻴﺔ‪،‬‬
‫‪٣‬‬ ‫وﻧﺪوز ‪Windows‬‬ ‫ﻧﻈﺎم ﺗﺸﻐﻴﻞ ﺣﺪﻳﺚ ﻣﻜﻮن ﻣﻦ ﻋﺪة‬ ‫داﺧﻞ ﻋﻤﻠﻴﺎت إﺟﺮاﺋﻴﺔأﺧﺮى‪.‬‬
‫ﻧﻈﺎم ﺗﺸﻐﻴﻞ رﺳﻮﻣﻲ ﻣ ّﻌﺪ ﻣﻦ ﻗﺒﻞ‬ ‫‪ ٥٦‬ﻣﻜﻮﻧﺎت ﻻﻧﻈﻤﺔ ﺗﺸﻐﻴﻞ اﻫﻤﻬﺎ ﻧﻈﺎم ‪،BSD‬‬ ‫ﻣﻼﻣﺢ ‪Attributes‬‬
‫ﻣﺎﻳﻜﺮوﺳﻮﻓﺖ‬ ‫وﺗﻜﻨﻮﻟﻮﺟﻴﺎ اﺑﻞ ﻣﻦ ﻣﻜﺘﺒﺎت ‪ cocoa‬و ‪car-‬‬ ‫اﻟﺴﻤﺎت اﻟﺘﻲ ﲢﺪد ﻫﻴﺌﺔ اﻟﻌﻨﺎﺻﺮ اﻟﺒﺮﻣﺠﻴﺔ‬
‫‪ bon‬وﻣﺪﻳﺮ اﳌﻜﻮﻧﺎت اﻟﺮﺳﻮﻣﻴﺔ ‪.quartz‬‬ ‫ﺑﺼﺮﻳﺎً‪.‬‬
‫‪٢٠‬‬ ‫‪ ٦١‬ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﻌﺎﺋﺪ‬ ‫ﻣﻨﻔﺬ ﺧﺮج ‪Output Port‬‬
‫اﻧﻈﺮ ﻧﻮع ‪ - Type‬ﺣﻴﺚ ﺗﺸﺘﺮط ﺑﻌﺾ اﻟﺪوال‬ ‫ﻣﺼﺪر ﻟﺘﻠﻘﻲ ﻣﺨﺮﺟﺎت ﻋﻤﻠﻴﺎت اﳊﺎﺳﺐ‬
‫إﺳﺘﺮﺟﺎع ﻗﻴﻤﺔ ﻣﻦ ﻧﻮع ﻣﻌﲔ‪.‬‬ ‫اﻻﻟﻲ‪.‬‬
‫‪١٩‬‬ ‫ﻫﻴﻜﻠﺔ ‪structure‬‬ ‫‪١‬‬ ‫ﻣﻮﻗﻊ أﭘﻞ اﻻﻟﻜﺘﺮوﻧﻲ‬
‫ﻣﻮﻗﻊ اﻟﺸﺮﻛﺔ اﻻم ﺣﻴﺚ ﻳﺘﻢ ﺗﺰوﻳﺪك ﺑﺎﳌﺼﺎدر ﻧﻈﺎم ﺑﻨﻴﻮي ﻣﺮﺗﺐ ﻟﺘﻜﻮﻳﻦ ﺑﻨﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ‬
‫واﻟﺘﻌﻠﻴﻤﺎت اﳌﺘﻌﻠﻘﺔ ﺑﺎﻟﻨﻈﺎم واﺳﺎﻟﻴﺐ ﺑﺮﻣﺠﺘﻪ‪ .‬ﻣﻨﻄﻘﻴ َﺎ ﺣﺘﻰ ﻳﺴﻬﻞ ﺗﻄﻮﻳﺮة وزﻳﺎدة ﻗﺪراﺗﻪ‪.‬‬
‫‪١‬‬ ‫‪ ٥٠‬واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬ ‫ﻧﺎﻓﺬة‬
‫واﺟﻬﺔ ﺗﻌﺎﻣﻞ رﺳﻮﻣﻴﺔ ﻣﻊ اﳊﺎﺳﺐ اﻻﻟﻲ‪،‬‬ ‫ﻋﻨﺼﺮ ﺑﺮﻣﺠﻲ ﻳﺆدي دور اﺣﺘﻮاء وﻋﺮض‬
‫ﺗﺴﺘﻨﺪ ﻓﻲ إﺟﺮاءاﺗﻬﺎ وﻣﻌﺎﻣﻼﺗﻬﺎ ﻋﻠﻰاﻟﺘﻌﺎﻣﻞ‬ ‫ﻋﻨﺎﺻﺮ ﺑﺮﻣﺠﻴﺔ ﻛﺘﺸﺒﻴﻪ ﻣﺠﺎزي ﻟﻠﺤﺎوﻳﺔ‪.‬‬
‫‪ ٣٦‬اﻟﺘﺸﺒﻴﻬﻲ ﻟﻠﻌﻨﺎﺻﺮ ﻣﻦ ازرار وﻧﻮاﻓﺬ‪ ،‬ﻫﺬﻩ‬ ‫ﻧﺎﻓﺬة اﻟﺘﻮﺛﻴﻖ ‪Run Log window‬‬
‫اﻟﻮاﺟﻬﺔ ﺗﺴﺘﺨﺪم اﻟﻨﺼﻮص واﻟﺮﺳﻮﻣﺎت‪.‬‬ ‫ﻧﺎﻓﺬة ﻟﻌﺮض ﻣﺨﺮﺟﺎت ﻋﻨﺎﺻﺮ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪٣٢‬‬ ‫وﺣﺪة ﻃﺮﻓﻴﺔ ‪Terminal‬‬ ‫‪٢٣ ,٢٠‬‬ ‫ﻧﻄﺎق اﻟﺪاﻟﺔ‬
‫ﻣﺤﺪد ﻻﺳﻤﺎء اﳌﺘﻐﻴﺮات اﻟﺘﻲ ﺗﻨﺤﺼﺮ داﺧﻞ واﺟﻬﺔ ﺗﻌﺎﻣﻞ ﻣﻊ اﳊﺎﺳﺐ اﻻﻟﻲ‪ ،‬ﺗﺴﺘﻨﺪ‬
‫‪١١١‬‬
‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬ ‫ﻣﻼﺣﻈﺎت اﳌﺘﺮﺟﻢ‬
‫ﻣﻼﺣﻈﺎت اﳌﺘﺮﺟﻢ‬
‫ﻟﻘﺪ ﺣﺮﺻﺖ ﻛﻞ اﳊﺮص ان اﻗﻮم ﺑﻨﻘﻞ اﳌﻌﻠﻮﻣﺎت اﻟﻮاردة ﺑﻬﺬا‬
‫اﻟﻜﺘﺎب ‪ BECOME AN XCODER‬ﺑﻜﻞ دﻗﺔ واﻣﺎﻧﺔ ﻣﻊ ﻣﺮاﻋﺎة‬
‫ﻗﻮاﻋﺪ اﻟﻠﻐﺔ اﻟﻌﺮﺑﻴﺔ‪ ،‬وﻧﻈﺮاَ ﻻﺧﺘﻼف ﻃﺒﻴﻌﺔ ﺑﻌﺾ اﳌﺴﻤﻴﺎت اﻟﺘﻲ ﻟﻢ‬
‫ﻳﺄت ﻓﻴﻬﺎ اﻻﺗﻔﺎق ﻋﻨﺪﻣﺎ ﻳﺨﺘﺺ اﻻﻣﺮ ﺑﺎﻟﺒﺮﻣﺠﺔ اﳊﺪﻳﺜﺔ ﻛﺈﺳﺘﺨﺪام‬
‫اﻟﻜﺎﺋﻨﺎت ﺣﻴﺚ ﻳﺸﻴﺮ اﻟﺒﻌﺾ اﻟﻴﻬﺎ ﺑﺎﻟﺒﺮﻣﺠﺔ ﻏﺮﺿﻴﺔ اﻟﺘﻮﺟﺔ‪ ،‬وﻫﻨﺎك‬
‫ﻓﺮﻳﻖ ﻳﺮى اﻧﻬﺎ اﻟﺒﺮﻣﺠﺔ ﺑﺎﻷﺷﻴﺎء ﻟﺪا اﻋﺘﻤﺪت اﻹﺷﺎرة اﻟﻰ ﻛﻞ ﻣﺎ‬
‫ﻳﺘﻌﻠﻖ ﺑﻬﺬا اﻟﻘﻄﺎع اﳉﺪﻳﺪ ﻣﻦ اﻟﺒﺮﻣﺠﺔ ﺑﺎﻟﻜﺎﺋﻨﺎت وﻣﺎ ﻳﻨﺪرج ﲢﺘﻬﺎ‬
‫ﻣﻦ ﻣﺼﻨﻔﺎت وﻣﺴﺘﻨﺴﺨﺎت‪ ،‬وﻣﺆﺷﺮات ‪ pointers‬ﻧﺎﺋﺒﺔ‪ ،‬ﻹﻧﺎﺑﺘﻬﺎ‬
‫ﻋﻦ اﻟﻜﺎﺋﻦ اﳊﻘﻴﻘﻲ أﺛﻨﺎء اﻟﺘﻌﺎﻣﻞ واﻟﺘﺪاول‪ .‬ﻟﺬا ﻗﺪ ﻳﻈﻬﺮ ﻟﻠﺴﻄﺢ‬
‫ازدواﺟﻴﺔ ﻓﻲ اﺳﺘﺨﺪام ﺑﻌﺾ اﳌﻔﺮدات اﻟﺘﻘﻨﻴﺔ‪ ،‬واﻟﺘﻲ ﻗﺪ ﻳﻌﺘﺎد ﻣﻦ‬
‫ﻫﻢ ﺑﺤﻘﻞ اﻟﺒﺮﻣﺠﺔ ﻋﻠﻴﻬﺎ ﻣﻦ ﺗﺴﻤﻴﺎت ﻣ ّﻌﺮﺑﺔ ﻛﻜﻠﻤﺔ ‪ Class‬ﺣﻴﺚ‬
‫اﻋﺘﻤﺪﺗﻬﺎ ﺑﻜﻠﻤﺔ "ﺗﺼﻨﻴﻒ" ﻓﻲ ﻫﺬا اﻟﻜﺘﺎب رﻏﻢ ان ﺑﻌﺾ اﳌﺮاﺟﻊ‬
‫ﺗﺮاﻫﺎ "ﻛﻄﺒﻘﺔ"‪ .‬ﻛﺬﻟﻚ اﻋﺘﻤﺪت ﻛﻠﻤﺔ إﺟﺮاء وداﻟﺔ ﻟﻺﺷﺎرة اﻟﻰ‬
‫ﻛﻞ ﻣﻦ ‪Method,Action‬و‪ ،function‬و ﻟﻢ اﻣﺘﻨﻊ ﻋﻦ ﺳﺮد ﻫﺬﻩ‬
‫اﳌﺼﻄﻠﺤﺎت ﻣﻊ ﻣﺘﺮادﻓﺎﺗﻬﺎ اﻟﻼﺗﻴﻨﻴﺔ‪ ،‬وﻗﺪ اﺷﻴﺮ اﻟﻴﻬﺎ ﺑﻄﺮﻳﻘﺔ او‬
‫أﺧﺮى‪ ،‬وﻓﻲ ﺣﺎل اﺧﺘﻼل اﳌﻌﻨﻰ ﻳﻜﻮن اﳊﻞ ﲟﺴﺮد اﳌﺼﻄﻠﺤﺎت‪.‬‬
‫‪١١٣‬‬
‫ﻣﻼﺣﻈﺎت اﳌﺘﺮﺟﻢ‬ ‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬
‫ﻓﻘﺪ اﻋﺘﻤﺪﺗﻬﺎ ﲟﻘﺎس ‪ ١٢‬ﻧﻘﻄﺔ ﺑﻨﺴﺒﺔ ‪ ٪٥٠‬ﻣﻦ اﻻﺳﻮد‬ ‫ﺣﻮل ﻫﺬا اﻟﻌﻤﻞ‬
‫ﺑﺎﻟﻜﺘﺎب‪ ،‬اﻣﺎ اﳋﻂ اﻟﻼﺗﻴﻨﻲ اﳌﺴﺘﺨﺪم ﻫﻮ )‪Palatino (T1‬‬ ‫اﻟﺒﺮﻣﺠﺔ ﻣﻦ وﺟﻬﺔ ﻧﻈﺮي ﻧﻮع ﻣﻦ اﻧﻮاع اﻟﻬﻮاﻳﺎت اﻟﺘﻲ‬
‫ﻣﻘﺎس ‪ ١٢‬ﻧﻘﻄﺔ ﻛﺒﻨﻂ اﻧﺴﺐ‪ ،‬اﻣﺎ ﻟﻨﻤﻂ ﺧﻄﻮط اﻟﺸﻔﺮة‬ ‫اﻣﻀﻴﺖ ﻣﻌﻬﺎ ﻓﺘﺮة ﺗﺘﺠﺎوز اﻟﻌﺸﺮة ﺳﻨﻮات واﻧﺎ اراﻗﺐ‬
‫اﻟﺒﺮﻣﺠﻴﺔ ﻓﻘﺪ رأﻳﺖ ان اﳋﻂ ‪ Courier New‬ﻣﻘﺎس ‪١٢‬‬ ‫ﺗﻄﻮرﻫﺎ وﲢﺴﻨﻬﺎ دون ﻣﺸﺎرﻛﺔ ﻓﻌﻠﻴﺔ ﻣﻨﻲ ﺑﺘﻄﻮﻳﺮ ﻣﺎ‬
‫ﻫﻮ اﻻﻧﺴﺐ‪ ،‬وﻗﺪ اﻋﺘﻤﺪت ﻣﻘﺎس ﺻﻔﺤﺎت ‪ A4‬ﻣﻨﺎﺳﺐ‬ ‫ﳝﻜﻦ ان ﻳﻜﻮن ﺑﺮاﻣﺞ ﻋﺮﺑﻴﺔ ذات ﻣﻘﺎﻳﻴﺲ ﻣﻮﺣﺪة‪ ،‬وﻗﻴﻤﺔ‬
‫ﻟﻠﻘﺮاءة ﻣﻦ ﺧﻼل ﺷﺎﺷﺔ اﳊﺎﺳﺐ او ﻋﻨﺪ ﻃﺒﺎﻋﺔ اﶈﺘﻮى‬ ‫ﻣﻨﻔﻌﻴﺔ ﺟﻤﺔ ﳌﻦ ﻳﺴﺘﺨﺪم ﺗﻠﻚ اﻟﺒﺮاﻣﺞ‪.‬‬
‫ﻋﻠﻰ اﻻوراق ﺑﻮﺿﻌﻴﺔ اﻓﻘﻴﺔ ﻣﻌﺮوﻓﻪ ﺑﺎﺳﻢ ‪.landscape‬‬
‫ﺑﺎﻟﺼﺪﻓﺔ اﺛﻨﺎء ﲡﻮﻟﻲ ﺑﺎﺣﺪ اﳌﻮاﻗﻊ‪ ،‬وﺟﺪت ﻫﺬا اﻟﻜﺘﺎب‬
‫ﻛﺎﻓﺔ اﻟﺸﻔﺮات اﻟﺒﺮﻣﺠﻴﺔ اﳌﺴﺘﺨﺪﻣﺔ ﺑﺎﻟﻜﺘﺎب ﺗﻮﺟﺪ ﲟﻠﻒ‬ ‫اﻟﻘﻴﻢ‪ ،‬وﻫﻮ دﻋﻮة ﻟﻨﺸﺮ ﺛﻘﺎﻓﺔ ووﻋﻲ ﺟﻴﻞ ﺟﺪﻳﺪ ﻣﻦ‬
‫ﻣﻨﻔﺮد اﺳﻤﻪ ‪BECOME AN XCODER - source code.‬‬ ‫اﳌﺒﺮﻣﺠﲔ‪ ،‬وﻗﺪ رأﻳﺖ اﻧﻬﺎ ﻓﺮﺻﺔ ﺳﺎﻧﺤﺔ ﻻﺛﺒﺎت ﻣﺪى‬
‫‪ txt‬وﻫﻮ ﻳﺤﺘﻮي ﻣﺎورد ﻣﻦ أﻛﻮاد ﺣﺴﺐ ﻛﻞ ﻓﺼﻞ‪.‬‬ ‫ﻓﻬﻤﻲ ﻣﻦ ﺧﻼل ﺗﺮﺟﻤﺔ ﻣﺎ ﻳﺤﺘﻮﻳﺔ اﻟﻜﺘﺎب‪ ،‬ﻣﺆﻟﻔﻴﻪ‬
‫ﻟﻘﺪ ﰎ اﻟﺒﺪأ ﺑﻬﺬا اﻟﻌﻤﻞ واﻻﻧﺘﻬﺎء ﻣﻨﻪ ﺧﻼل ﺷﻬﺮ وﻧﻴﻒ‬ ‫اﻻﺻﻠﻴﲔ ﻳﺸﺠﻌﻮن اﳉﻤﻴﻊ ﻋﻠﻰ ﻗﺮاءﺗﻪ وﺗﺪاوﻟﻪ وﻫﻮ‬
‫ﻣﻦ اﻟﻌﺎم ‪ ،٢٠٠٦‬وﻫﻮ ﻣﺠﻬﻮد ﻓﺮدي ‪-‬ﻓﻼ ﺗﺒﺨﻞ ﻋﻠﻰ‬ ‫ﺑﺎﻟﻔﻌﻞ ذي ﻗﻴﻤﺔ ﻋﺎﻟﻴﺔ‪.‬‬
‫ﺑﺎﻟﺘﺼﻮﻳﺐ‪ -‬آﻣﻞ ان ﺗﺴﺘﻤﻊ ﺑﻘﺮاءﺗﺔ واﻻﺳﺘﻔﺎدة ﻣﻨﻪ ﻛﻤﺎ‬
‫ﻟﻘﺪ اﻋﺘﻤﺪت ﻓﻲ ﺗﻨﺴﻴﻖ ﻫﺬا اﻟﻜﺘﺎب ﳕﻂ ﻣﻮﺣﺪ ﻣﻦ‬
‫اﺳﺘﻤﺘﻌﺖ واﺳﺘﻔﺪت ﻣﻨﻪ‪.‬‬
‫اﳋﻄﻮط وﻫﻮ ﺧﻂ اﻟﺒﻴﺎن ‪ Al Bayan‬اﳌﺰود ﺑﺎﻟﻨﻈﺎم وﻫﻮ‬
‫ﻣﺎزن اﻟﺮﻣﺎل‬ ‫ﻣﺴﺘﺨﺪم ﻟﻠﻨﺼﻮص اﻟﺪاﺧﻠﻴﺔ ﲟﻘﺎس ﻣﻘﺪارﻩ ‪ ١٨‬ﻧﻘﻄﺔ وﻫﻮ‬
‫ﺟﺪة ‪٢٠٠٦ -‬‬ ‫ذاﺗﻪ اﳌﺴﺘﺨﺪم ﻟﻠﺘﺒﻮﻳﺐ واﻟﺘﺮوﻳﺴﺎت اﻟﻌﻠﻮﻳﺔ )‪ ١٣‬ﻧﻘﻄﺔ(‬
‫واﻟﻌﻨﺎوﻳﻦ اﻟﺮﺋﻴﺴﺔ )‪ ٣٦‬ﻧﻘﻄﺔ(‪ ،‬اﻣﺎ اﻟﻌﻨﺎوﻳﻦ اﻟﻔﺮﻋﻴﺔ )ﳕﻂ‬
‫ﻋﺮﻳﺾ( ﻓﻬﻲ ذاﺗﻬﺎ اﳌﺴﺘﺨﺪﻣﺔ ﻟ ُﺒﻨﻴﺔ اﻟﻨﺺ اﻣﺎ اﻟﺘﻨﻮﻳﻬﺎت‬
‫‪١١٤‬‬

‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬

Uploaded by

Copyright:

Available Formats

‫ﻧﺤﻮ اﻟﺒﺮﻣﺠﺔ ﺑـ ‪Xcode‬‬

‫ﻣﺎﲢﺘﺎﺟﺔ ﻟﺒﺮﻣﺠﺔ اﳌﺎﻛﻨﺘﻮش‬

‫‪Bert Altenburg, Alex Clarke , Philippe Mougin‬‬ ‫ﻛﺘﺎب ﻣﻦ ﺗﺄﻟﻴﻒ‬

‫ﺗﺮﺟﻤﺔ ‪ :‬ﻣﺎزن اﻟﺮﻣﺎل‬

‫اﻷﻋﻤﺎل ﻏﻴﺮ ﲡﺎرﻳﺔ اﻟﻬﺪف‪:‬‬

‫‪٤٩‬‬ ‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ اﻟﺘﻄﺒﻴﻘﺎت اﻟﺮﺳﻮﻣﻴﺔ‬ ‫‪II‬‬ ‫ﺗﺮﺧﻴﺺ‬

‫‪ .٥‬ﻗﻢ ﺑﺎﻟﺘﻮاﺻﻞ ﻋﻠﻰ اﻷﻗﻞ ﻣﻊ ﺛﻼﺛﺔ ﻣﺴﺘﺨﺪﻣﲔ ﻟﻠﻤﺎﻛﻨﺘﻮش ﻋﻠﻰ‬

‫اﻟﺒﺮﻧﺎﻣﺞ ﻋﺒﺎرة ﻋﻦ ﺗﻌﻠﻴﻤﺎت‬

‫اﳌﺠﻤﻊ ﲟﻌﺮﻓﺔ ﻧﻮع ﻣﺼﻨﻒ اﳌﺘﻐﻴﺮ ﺳﻮاء ﻛﺎن‬

‫ﻓﻲ اﻟﺴﻄﺮ ]‪ [6.1‬ﻳﺪﻟﻨﺎ ‪ int‬ﻋﻠﻰ ان ﺗﺼﺮﻳﺢ ﻧﻮع اﳌﺘﻐﻴﺮ ‪pictureWidth‬‬

‫اﻟﻀﺮب * واﻟﻘﺴﻤﺔ ‪َ /‬‬

‫وﺑﺎﻟﺮﻏﻢ ﻣﻦ اﻧﻨﺎ ﻣﻠﺘﺰﻣﲔ ﺑﻌﺮض اﻣﺜﻠﺔ ﺑﻌﺪد ﻣﺤﺪود ﻣﻦ اﻻﺳﻄﺮ‪،‬‬

‫ﻧﻨﺼﺤﻚ ﺑﺠﺪﻳﺔ ان ﺗﻮﺛﻖ ﺷﻔﺮﺗﻚ اﻟﺒﺮﻣﺠﻴﺔ‪ ،‬اﻧﻬﺎ اﺳﺘﺜﻤﺎر‬

‫ﻗﻴﻤﺔ ﺻﻔﺮ )]‪ (zero, [10.9‬ﻟﻠﺘﻨﻮﻳﺔ ﻋﻦ ان اﻟﺪاﻟﺔ اﳒﺰت ﻋﻤﻠﻬﺎ‬

‫‪ -‬ﻟﻬﺎ ﻣﻌﺎﻣﻼن‪ ،‬ﻛﻼﻫﻤﺎ ﻋﺪد ﻛﺴﺮي‪ ،‬اﳌﻌﺎﻣﻞ اﻻول ﳝﺜﻞ‬

‫ان اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ اﳌﻜﻮﻧﺔ ﻟﻠﺪاﻟﺔ ﻣﺤﺠﻮﺑﺔ ﻋﻦ ﻛﺎﻓﺔ اﺟﺰاء اﻟﺒﺮﻧﺎﻣﺞ‬

‫اﻟﻄﺒﺎﻋﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‬

int main() :‫ﺧﺮج ﻫﺬﻩ اﻟﺸﻔﺮة اﻟﻨﺎﰋ ﻛﺎﻟﺘﺎﻟﻲ‬

ﬂoat circleArea(ﬂoat theRadius)

float rectangleArea(float width, float height)

‫ﲡﻤﻴﻊ وﺗﺸﻐﻴﻞ اﻟﺒﺮﻧﺎﻣﺞ‬

‫اﻃﻠﻖ اﺳﻤ َﺎ ﳌﺸﺮوﻋﻚ‬

‫اﻃﻠﻖ اﺳﻤ َﺎ ﻟﻠﻤﺸﺮوع وﺣﺪد ﻣﻮﻗﻊ ﺣﻔﻈﻪ داﺧﻞ ﻗﺮﺻﻚ اﻟﺼﻠﺐ‪.‬‬

‫ﺳﻮف ﺗﺮى ‪:‬‬

‫اﻻﺧﻄﺎء اﻛﺜﺮ ﺻﻌﻮﺑﺔ‪.‬‬ ‫)‪float rectangleArea(float width, float height‬‬

‫ﻟﺬا ﻗﺪ ﺗﺮﻏﺐ اﺣﻴﺎﻧ َﺎ ﲟﻌﺮﻓﺔ ﻣﺎ ﻳﺠﺮي ﺧﻠﻒ اﻟﻜﻮاﻟﻴﺲ اﺛﻨﺎء ﺗﺸﻐﻴﻞ‬

‫ادراج ﻋﻼﻣﺎت اﻟﺘﻮﻗﻒ اﳌﺆﻗﺖ ‪ breakpoint‬داﺧﻞ اﻟﺸﻔﺮة اﻟﺒﺮﻣﺠﻴﺔ‬

‫ﻻﺣﻆ اﻧﻚ ﺳﺘﺘﻔﺤﺺ ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات ﲟﺮﺣﻠﺔ ﺗﺴﺒﻖ ﻣﺎﻗﺒﻞ ذﻟﻚ‬

‫‪ Xcode‬ﻳﺘﻘﺼﻰ اﻻﺧﻄﺎء اﻟﺒﺮﻣﺠﻴﺔ ﺧﻄﻮة ﺧﻄﻮة‬

‫ﻳﻌﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ اﺛﻨﺎء ﻣﺮﺣﻠﺔ اﻟﺘﻘﺼﻲ ﻫﺬﻩ ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ﺛﻢ ﻳﺘﻮﻗﻒ‬

‫اﻫﻤﻴﺔ ﻗﻮﻳﺔ‪ .‬ﻓﺤﺎول ان ﺗﺘﻌﺎﻣﻞ ﻣﻌﻪ ﺣﺘﻰ ﺗﺄﻟﻒ ﻃﺮﻳﻘﺔ ﻋﻤﻠﻪ‪.‬‬

‫اﻟﺴﻄﺮ ]‪ [1.2‬ﻳﻈﻬﺮ اﻳﻌﺎز اﺳﺘﻔﺴﺎر اﻟﺸﺮط ‪ if...‬واﻟﺬي ﺗﻨﺤﺼﺮ ﻣﻬﻤﺘﺔ‬

‫ﺑﺎﺟﺮاء ﻣﻔﺎﺿﻠﺔ ﺗﺴﺎوي ﺑﲔ اﻟﻘﻴﻢ!‬

‫ﻟﻠﻤﻔﺎﺿﻠﺔ ﺑﲔ اﻟﻘﻴﻤﺔ واﳌﻌﺎدﻟﺔ اﶈﺪدة ﻟﺸﺮط ﺗﻜﺮارﻳﺔ اﳊﻠﻘﺔ واﻟﺘﻲ‬ ‫]‪[2‬‬

‫إن اﻻﻳﻌﺎز اﻻﺧﻴﺮ ﻣﺸﺎﺑﺔ ﺟﺪاَ ﳊﻠﻘﺔ ‪ .for-loop‬ﻓﻬﺬا اﻷﻳﻌﺎز‬

‫ﻟﻘﺪ اﻛﺘﺴﺒﺖ ﻣﻬﺎرات ﺑﺮﻣﺠﻴﺔ ﻣﺘﻨﻮﻋﺔ ﻣﺆﺧﺮاَ‪ ،‬ﻟﺬا ﺳﻨﻘﻮم ﲟﻨﺎﻗﺸﺔ‬

‫اﻟﺒﺮﻣﺠﺔ ﺑﺈﺳﺘﺨﺪام واﺟﻬﺔ‬

‫دﻋﻨﺎ ﻧﺘﻔﺤﺺ ﻛﻴﻔﻴﺔ ﻋﻤﻞ ذﻟﻚ ﺟﺪﻳﺎَ‪.‬‬

‫ﺑـ”‪ . “Cocoa-‬وﻫﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺨﺰن ﻟﻜﺎﻓﺔ اﻧﻮاع اﻟﻜﺎﺋﻨﺎت اﻟﺒﺼﺮﻳﺔ‬

‫‪Xcode‬‬ ‫ﻳﺆدي اﻟﻀﻐﻂ اﳌﺘﺘﺎﻟﻲ ﻋﻠﻰ ‪ MainMenu.nib‬داﺧﻞ‬

‫اﳊﺮﻓﲔ ‪ NS‬ذﻟﻚ اﻧﻬﺎ ﺑﺎدﺋﺔ ﻣﻌﺘﻤﺪة ﻟﺘﺼﻨﻴﻔﺎت أﭘﻞ ‪ .‬وﻫﻲ اﺧﺘﺰال‬

‫ﺗﻴﻘﻦ ﻣﻦ اﺧﺘﻴﺎرك ﻟﻠﺘﺼﻨﻴﻒ ‪ MAFoo‬ﺑﻠﻮﻳﺤﺔ اﻟﺘﺼﻨﻴﻔﺎت ‪Classes‬‬ ‫اﻟﺬي أﻧﺸﺎءﻧﺎﻩ ﻣﺆﺧﺮاَ‪.‬‬

‫إﺿﺎﻓﺔ ﻣﺨﺮﺟﺎت ‪ outlet‬ﻟﻠﺘﺼﻨﻴﻒ ‪MAFoo‬‬ ‫إﺿﺎﻓﺔ اﻻﺟﺮءات ‪ action methods‬ﻟﻠﺘﺼﻨﻴﻒ ‪MAFoo‬‬

‫ﻻﺣﻆ ان ﻋﻤﻠﻴﺔ ﺗﻐﻴﻴﺮ ﻣﺴﻤﻴﺎت اﻟﻌﻨﺎوﻳﻦ اﻟﺘﻲ اﺟﺮﻳﻨﺎﻫﺎ ﺗﻌﺪ‬

‫اﻻن ﺳﺘﺮى ان اﻻزرار ﻳﺤﺘﻔﻆ ﺑﻌﻨﺎوﻳﻦ ﻣﺮﺟﻌﻴﺔ ﻣﻮﺟﻬﺔ اﻟﻰ اﻟﻜﺎﺋﻦ‬

‫اﻣﺮ إﻧﺸﺎء ﻣﻠﻔﺎت اﻟﺘﺼﻨﻴﻒ ‪ .Create Files for MAFoo‬ﻋﻨﺪﻫﺎ‬

‫اﺳﺘﻌﺮاض اﳌﻠﻔﺎت اﳌﻨﺸﺎءة داﺧﻞ ‪.Xcode‬‬

‫ان إﺟﺮاء ‪ setIntValue:‬ﻗﺎدر ﻋﻠﻰ اﻇﻬﺎر اﻟﻘﻴﻤﺔ اﳌﺮﻓﻘﺔ ﻣﻌﻪ ﻓﻲ ﻛﺎﺋﻦ‬

‫ﺑﺮﻧﺎﻣﺠﻨﺎ ﻗﻴﺪ اﻟﺘﺸﻐﻴﻞ‪.‬‬

‫ﺑﺎﺧﺘﺼﺎر ﻟﻘﺪ ﻗﻤﺖ ﺑﺈﻧﺸﺎء ﺑﺮﻧﺎﻣﺞ ﺑﺪاﺋﻲ ﺑﺴﻴﻂ‪ ،‬وﻗﺪ ﺗﺘﻄﻠﺐ‬

‫ﺑﺤﺚ اﻟﺘﻌﻠﻴﻤﺎت اﻟﺒﺮﻣﺠﻴﺔ‬

‫إﺑﺪء ﺑﺤﺜﻚ ﻋﻦ اﻻﺟﺮاءات ﲢﺖ ﻫﺬا اﻟﻌﻨﻮان‪ .‬ان ﻧﻈﺮة ﺳﺮﻳﻌﺔ ﻋﻠﻰ‬

‫اﻹﺟﺮاء ‪ setIntValue:‬وﺻﻴﻐﺘﻪ‬ ‫اﻟﺘﺼﻨﻴﻒ اﻻﻋﻠﻰ ﻓﻲ اﻟﺴﻼﻟﺔ‪ ،‬اﻻ وﻫﻮ ‪ ، NSView‬وﻫﻜﺬا ﺣﺘﻰ‬

‫اﻻول ‪ ،Foundation Kit‬ﻫﻮ واﻟﺬي ﺗﻌﺎﻣﻠﻨﺎ ﻣﻊ وﺟﻠﺒﻨﺎﻩ ﻓﻲ ﻣﺜﺎﻟﻨﺎ‬

‫ﺣﺘﻰ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ﻫﺬا اﻻﻳﻌﺎز‪ ،‬ﺳﻴﻘﻮم اﳌﺎﻛﻨﺘﻮش ﺑﺎﻟﺒﺤﺚ ﻋﻦ‬

‫ﻟﻠﻤﺆﺷﺮات ﻓﻮاﺋﺪﻫﺎ ﻓﻘﺪ ﺗﺮﻏﺐ ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ان ﺗﺸﻴﺮ إﻟﻰ‬

‫ﳝﻜﻨﻚ ﺑﻌﺪ ذﻟﻚ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻟﺘﻨﻔﻴﺬ ﻣﺎ ﺗﻘﻮم ﺑﻪ ﻛﻤﺎ ﻳﻠﻲ‪:‬‬

‫ﺳﻼﺳﻞ اﳊﺮوف اﻟﻨﺼﻴﺔ‬

‫ﻟﻢ ﻧﺘﺤﺪث ﻋﻦ ﺳﻠﺴﻠﺔ اﳊﺮوف ﻛﻨﻮع ﻣﻦ اﻧﻮاع اﻟﺒﻴﺎﻧﺎت ﺳﺎﺑﻘ َﺎ‪،‬‬

‫اﻟﻮاﻗﻊ ﺳﺘﺮى اﺛﻨﺎء ﻛﺘﺎﺑﺘﻚ ﻟﻠﺒﺮاﻣﺞ ﻣﺴﺘﺨﺪﻣ َﺎ ‪ Objective-C‬أﻧﻚ‬

‫;‪NSString *foo, *bar‬‬

‫”ﻛﺎﺋﻦ‪ “object-‬إﺧﺘﺼﺎراَ‪ .‬ان ﺣﻘﻴﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺎﺋﻨﺎت ﻣﻦ‬ ‫;]‪[pool release‬‬

:‫وﻫﺬا اﻻﻣﺮ ﻣﻮﺿﺢ ﺑﻬﺬا اﳌﺜﺎل‬

int main (int argc, const char * argv[])

‫;‪NSString foo, bar‬‬