‫ﺻﺪﻗﺔ ﺟﺎرﻳﻪ ‪..

‬‬
‫اﻟﻰ روح أﺑﻲ ‪..‬‬
‫ﻓﻲ ﻋﻠﻴﻴﻦ‪...‬‬

‫اﻟﻤﻘﺪﻣﻪ‬
‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ واﻟﺼﻼة واﻟ ﺴﻼم ﻋﻠ ﻰ ﺳ ﻴﺪﻧﺎ ﻣﺤﻤ ﺪ أﺷ ﺮف اﻟﺨﻠ ﻖ وﺧ ﺎﺗﻢ اﻟﻨﺒ ﻴﻦ‬
‫وﻋﻠﻰ أل ﺑﻴﺘﻪ وﺻﺤﺒﻪ اﻟﻄﻴﺒﻴﻦ اﻟﻄﺎهﺮﻳﻦ‪.‬‬
‫أﻣﺎ ﺑﻌﺪ ‪ ,‬ﻓﻬﺎ أﻧﺬا أﺿﻊ ﺑﻴﻦ ﻳﺪي اﻟﻘﺎريء اﻟﻌﺮﺑﻲ ﻧﺘﺎج ﺟﻬﺪ ﺑ ﻀﻌﺔ أﺷ ﻬﺮ ﻣ ﻦ اﻟﻌﻤ ﻞ اﻟﺠ ﺎد‬
‫واﻟﺪؤوب ﻟﻴﻜﻮن هﺬا اﻟﻜﺘﺎب ﺷﺒﻪ آﺎﻣﻞ ) ﻷن اﻟﻜﻤﺎل ﷲ وﺣﺪﻩ ( ﻟﻤﺒ ﺎديء وأﺳﺎﺳ ﻴﺎت اﻟﺒﺮﻣﺠ ﻪ ﺑﻠﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪.‬‬
‫ﻟﻘ ﺪ ﻃ ﻮرت ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻦ ﻗﺒ ﻞ ) ‪ ( Niklaus Wirth‬ﻓ ﻲ‬
‫) ‪ ( Eidgenossische Technische Hochschule in Zurich‬وه ﻲ ﻣ ﺸﺘﻘﻪ ﻣ ﻦ ﻟﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ) ‪ ( Algol 60‬وﻟﻜﻦ ﺑﺄﻣﻜﺎﻧﻴﺎت أﻓﻀﻞ ﻣ ﻊ ﺳ ﻬﻮﻟﻪ ﺑﺎﻷﺳ ﺘﺨﺪام ‪ ..‬وﺗ ﺴﺘﺨﺪم ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳﻜﺎل اﻷن ﺑﺸﻜﻞ واﺳﻊ آﻠﻐﺔ ﺑﺮﻣﺠﻪ ﻣﻔﻴﺪﻩ ﻣﻤﻜﻦ ﺗﻨﻔﻴﺬهﺎ ﺑﻜﻔﺎءﻩ وهﻲ أداة ﺗﻌﻠﻴﻤﻴﻪ ﻣﻤﺘﺎزﻩ ‪.‬‬
‫ﻣﻦ اﻟﻤﻬﻢ أن أذآ ﺮ ﺑﻘﻠ ﺔ اﻟﻤ ﺼﺎدر اﻟﻌﺮﺑﻴ ﻪ ﻓ ﻲ اﻟﻤﺠ ﺎﻻت اﻟﻌﻠﻤﻴ ﻪ ﺑ ﺸﻜﻞ ﻋ ﺎم واﻟﺘ ﻲ ﺗ ﺸﻜﻞ‬
‫ﻋﺎﺋﻘﺎ أﻣﺎم اﻟﻤﻌﺮﻓﻪ ﻓﻲ اﻟﻮﻃﻦ اﻟﻌﺮﺑﻲ ‪ ,‬ﻟﺬا آﺎن هﺬا اﻟﻜﺘﺎب أﺳﻬﺎﻣﻪ ﻣﺘﻮاﺿﻌﻪ ﻋﺴﻰ أن ﻳﻜﻮن ﻣﻔﻴﺪا‬
‫ﻟﻠﺮاﻏﺒﻴﻦ ﺑﺘﻌﻠﻢ اﻟﺒﺮﻣﺠﻪ وﺧﺼﻮﺻﺎ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ ,‬وﺗﻮﺧﻴﺖ اﻷﺟﺘﻬﺎد ﻓ ﻲ ﺗﺮﺟﻤ ﺔ‬
‫اﻟﻤ ﺼﻄﻠﺤﺎت اﻷﺟﻨﺒﻴ ﻪ اﻟ ﻰ اﻟﻠﻐ ﻪ اﻟﻌﺮﺑﻴ ﻪ ﻧﻈ ﺮا ﻟﻌ ﺪم وﺟ ﻮد ﺗﺮﺟﻤ ﻪ ﻋﺮﺑﻴ ﻪ ﻣﻌﺘﻤ ﺪﻩ ﻟﻤ ﺼﻄﻠﺤﺎت‬
‫اﻟﺒﺮﻣﺠﻪ ‪ ,‬وﺑﻤ ﺎ ﻳﺘﻨﺎﺳ ﺐ وﺳ ﻬﻮﻟﺔ ﻓﻬﻤﻬ ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻘ ﺎريء وﻗﺮﺑﻬ ﺎ ﻣ ﻦ اﻟﻤﻔﻬ ﻮم اﻟﺤﻘﻴﻘ ﻲ ﻟﻬ ﺎ أﺧ ﺬا‬
‫ﺑﻨﻈﺮ اﻷﻋﺘﺒﺎر ذآﺮ اﻟﻤﺼﻄﻠﺢ اﻷﺟﻨﺒﻲ ﻣ ﻊ ﻣ ﺎ ﻳﻘﺎﺑﻠ ﻪ ﻣ ﻦ ﺗﺮﺟﻤ ﻪ ﻋﻨ ﺪ أول ورود ﻟ ﻪ ﻓ ﻲ اﻟﻜﺘ ﺎب ‪..‬‬
‫وﺑﺎﻟﺘﺄآﻴﺪ ﻓﺄن هﺬا اﻟﻌﻤﻞ ﻻﻳﻌﺪ ﻣﺮﺟﻌ ﺎ ﺑﺎﻟﻠﻐ ﻪ اﻟﻌﺮﺑﻴ ﻪ ﻟﻤ ﺼﻄﻠﺤﺎت اﻟﺒﺮﻣﺠ ﻪ ﻷن هﻨ ﺎك ﻣ ﻦ ﻳﻜ ﺮس‬
‫ﺟﻬﺪﻩ ووﻗﺘﻪ ﻟﻠﻌﻤﻞ ﻓﻲ هﺬا اﻟﻤﺠﺎل ‪.‬‬
‫ﻳﺒ ﺪأ اﻟﻜﺘ ﺎب ﺑ ﺸﺮح اﻟﻤﻔ ﺎهﻴﻢ اﻷﺳﺎﺳ ﻴﻪ اﻟﻌﺎﻣ ﻪ ﻟﻠﺒﺮﻣﺠ ﻪ واﻟﺘ ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل ‪ ,‬وه ﻲ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻣ ﺸﺘﺮآﻪ ﺑ ﻴﻦ اﻟﻜﺜﻴ ﺮ ﻣ ﻦ ﻟﻐ ﺎت اﻟﺒﺮﻣﺠ ﻪ ‪ ,‬أﻣ ﺎ اﻟﻔ ﺼﻞ اﻟﺜ ﺎﻧﻲ ﻓﻴﺘ ﻀﻤﻦ‬
‫ﺷﺮﺣﺎ واﻓﻴﺎ ﻷواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ﺑﺸﻜﻞ آﻔﻮء ‪ ,‬ﺑﻴﻨﻤﺎ آ ﺮس اﻟﻔ ﺼﻞ اﻟﺜﺎﻟ ﺚ‬
‫ﻟﻌﺒﺎرات اﻟﻘﺮار واﻟﺘﻜﺮار واﻟﺘ ﻲ ﺗﻌ ﺪ أﺣ ﺪى اﻟﺮآ ﺎﺋﺰ اﻟﻤﻬﻤ ﻪ ﻓ ﻲ اﻟﺒﺮﻣﺠ ﻪ ‪ ,‬وﺗﻨ ﺎول اﻟﻔ ﺼﻞ اﻟﺮاﺑ ﻊ‬
‫اﻟﻤ ﺼﻔﻮﻓﺎت ﺑﻨﻮﻋﻴﻬ ﺎ اﻷﺣﺎدﻳ ﻪ واﻟﺜﻨﺎﺋﻴ ﻪ ‪ ,‬ﺑﻴﻨﻤ ﺎ ﺗﻄ ﺮق اﻟﻔ ﺼﻞ اﻟﺨ ﺎﻣﺲ اﻟ ﻰ اﻷﺟ ﺮاءات واﻟ ﺪوال‬
‫وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ‪ ,‬اﻟﻔﺼﻞ اﻟﺴﺎدس ﻳﺸﺮح ﺑﺘﻮﺳﻊ ﻧﺴﺒﻲ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﻪ ﻣﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ‪,‬‬
‫وأﺧﻴﺮا ﺗﻢ اﻟﺨﺘﺎم ﻣﻊ اﻷﻧﻮاع واﻟﻤﺠﻤﻮﻋﺎت ‪.‬‬
‫ﻟﻘﺪ ﺣﺎوﻟﺖ ﺟﺎهﺪا أن أﺑﺴﻂ اﻟﻤﻮاﺿﻴﻊ اﻟﺘﻲ ﺗﻄﺮﻗﺖ ﻟﻬﺎ ﺑﺸﻜﻞ آﺒﻴﺮ وأﺳﻬﺒﺖ ﺑﻌﺾ اﻟ ﺸﻲء‬
‫ﻓ ﻲ ﺷ ﺮﺣﻬﺎ ﻷﺳ ﻬﻞ ﻋﻠ ﻰ اﻟﻘ ﺎريء اﻟﺘﻮاﺻ ﻞ ﻣ ﻊ ﻣﻮاﺿ ﻴﻊ اﻟﻜﺘ ﺎب وه ﻲ ﺟﻤﻴﻌ ﺎ ﻧﺘ ﺎج ﺧﺒﺮﺗ ﻲ ﻓ ﻲ‬
‫ﺗﺪرﻳﺲ هﺬﻩ اﻟﻤﺎدﻩ ﻟﻌﺪد ﻣﻦ اﻟﺴﻨﻮات ‪ ,‬وأرى أن هﺬا اﻟﻜﺘﺎب ﻣﻤﻜﻦ أن ﻳﻜﻮن ﻣﺮﺟﻌﺎ ﺟﻴﺪا ﻟﻠﻤﺒﺘ ﺪﺋﻴﻦ‬
‫ﻓﻲ اﻟﺒﺮﻣﺠﻪ وآﺬﻟﻚ ﻷﺻﺤﺎب اﻟﺨﺒﺮﻩ ‪ ,‬وهﻮ ﻣﻤﻜﻦ أن ﻳﻮﻓﺮ اﻷﺳﺎس اﻟﺠﻴ ﺪ ﻟﻤ ﻦ ﻳﺮﻏ ﺐ ﺗﻌﻠ ﻢ ﻟﻐ ﺎت‬
‫ﺑﺮﻣﺠﻪ أﺧﺮى ‪.‬‬
‫وﻓﻲ آﻞ اﻟﻔﺼﻮل ﺗﻢ اﻷﺳﺘﻌﺎﻧﻪ ﺑﺄﻣﺜﻠﻪ ﺗﻮﺿﻴﺤﻴﻪ وآﺎﻧﺖ اﻟﻔﻘﺮﻩ اﻷﺧﻴﺮﻩ ﻟﻜﻞ ﻓ ﺼﻞ ﺗﺤﺘ ﻮي‬
‫ﻋﻠ ﻰ ﻋ ﺪد ﻻﺑ ﺄس ﺑ ﻪ ﻣ ﻦ اﻷﻣﺜﻠ ﻪ اﻟﻤﺤﻠﻮﻟ ﻪ واﻟﺘ ﻲ ﺗ ﻢ أﻧﺘﻘﺎﺋﻬ ﺎ ﻟﺘﻮﺿ ﻴﺢ ﺣ ﺎﻻت ﻣﺨﺘﻠﻔ ﻪ ﻣ ﻦ ﺗﻘﻨﻴ ﺎت‬
‫اﻟﺒﺮﻣﺠﻪ أﺿﺎﻓﻪ اﻟﻰ اﻟﺘﻨﻮع ﺑﻄﺮق اﻟﺤﻞ ﻟﻬﺬﻩ اﻷﻣﺜﻠﻪ واﻷﻣﺜﻠﻪ اﻷﺧﺮى ﺿﻤﻦ اﻟﻔﻘﺮات اﻷﺧ ﺮى ﻣﻤ ﺎ‬

‫ﻳﺴﺎﻋﺪ اﻟﻘﺎريء ﻋﻠﻰ اﻷﻟﻤﺎم ﺑﻄﺮق ﺣﻞ ﻣﺨﺘﻠﻔﻪ ‪ ,‬وﺑﺎﻟﺮﻏﻢ ﻣﻦ ﻗ ﺼﺮ ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ وﺑ ﺴﺎﻃﺘﻬﺎ ﻟﻜﻨﻬ ﺎ‬
‫آﺎﻣﻠ ﻪ وﻟﻴ ﺴﺖ أﺟ ﺰاء ‪ ,‬وأود أن أاآ ﺪ أن اﻟﻜﺜﻴ ﺮ ﻣ ﻦ ﺣﻠ ﻮل اﻷﻣﺜﻠ ﻪ ﻻ ﺗﻤﺜ ﻞ اﻟﺤ ﻞ اﻟﻨﻤ ﻮذﺟﻲ وذﻟ ﻚ‬
‫ﻷﻧﻲ رآﺰت ﻋﻠﻰ ﺗﻮﺿﻴﺢ ﺗﻘﻨﻴﺎت وﻃﺮق ﺣﻠﻮل ﻣﺨﺘﻠﻔﻪ ﻟﺰﻳ ﺎدة اﻟﻔﺎﺋ ﺪﻩ ‪ ,‬وﺑﺄﻣﻜ ﺎن اﻟﻘ ﺎريء أن ﻳﻔﻬ ﻢ‬
‫ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ ﺑ ﺸﻜﻞ ﺟﻴ ﺪ ﻣ ﻦ ﺧ ﻼل ﻗﺮاﺋﺘﻬ ﺎ ‪ ,‬وﻟﻜ ﻦ ﻧﻨ ﺼﺢ ﺑ ﺄن ﺗﻄﺒ ﻖ ه ﺬﻩ اﻟﺒ ﺮاﻣﺞ وﺗﻨﻔ ﺬ ﻋﻠ ﻰ‬
‫اﻟﺤﺎﺳﺐ ﻟﺰﻳﺎدة أدراآﻬﺎ وﻓﻬﻤﻬﺎ ‪.‬‬
‫أرﺟﻮ ﻣﻦ اﷲ أن ﻳﺘﻘﺒﻞ ﻣﻨﻲ هﺬا اﻟﻌﻤﻞ ﺧﺎﻟﺼﺎ ﻟﻮﺟﻬﻪ ‪.‬‬
‫وأﻧﻲ ﻣﺴﺘﻌﺪ ﻟﺴﻤﺎع أراﺋﻜﻢ وﻣﻘﺘﺮﺣﺎﺗﻜﻢ واﻷﺟﺎﺑﻪ ﻋﻦ أﺳﺌﻠﺘﻜﻢ ﻣﻦ ﺧﻼل اﻟﺒﺮﻳﺪ اﻷﻟﻜﺘﺮوﻧﻲ أدﻧﺎﻩ ‪:‬‬
‫‪Comp_dep_educ@yahoo.com‬‬
‫د‪ .‬ﻧﻀﺎل اﻟﻌﺒﺎدي‬
‫ﺑﻐﺪاد ‪2006 /‬‬

‫اﻟﻤﺤﺘﻮﻳﺎت‬
‫اﻟﻔﺼﻞ اﻷول – ﻣﺪﺧﻞ اﻟﻰ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫‪ 1.1‬اﻟﻤﻘﺪﻣﻪ ‪..........................................................................‬‬
‫‪ 1.2‬ﺑﻌﺾ اﻟﺼﻔﺎت اﻟﻌﺎﻣﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ ‪.............................................‬‬
‫‪ 1.3‬اﻟﻤﻌﺮﻓﺎت ‪.......................................................................‬‬
‫‪ 1.4‬اﻟﺜﻮاﺑﺖ ‪.........................................................................‬‬
‫‪ 1.5‬اﻟﺒﻴﺎﻧﺎت ‪.........................................................................‬‬
‫‪ 1.5.1‬اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ‪....................................................‬‬
‫‪ 1.5.2‬اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ‪.......................................................‬‬
‫‪ 1.5.3‬اﻟﺮﻣﻮز ‪.................................................................‬‬
‫‪ 1.5.4‬اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪.....................................................‬‬
‫‪ 1.6‬اﻟﺘﻌﺎﺑﻴﺮ اﻟﻤﻨﻄﻘﻴﻪ ‪..............................................................‬‬
‫‪ 1.6.1‬اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﻪ ‪.....................................................‬‬
‫‪ 1.7‬ﺗﻮﻟﻴﺪ اﻷرﻗﺎم اﻟﻌﺸﻮاﺋﻲ ‪.......................................................‬‬

‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪4‬‬
‫‪5‬‬
‫‪7‬‬
‫‪9‬‬
‫‪9‬‬
‫‪9‬‬
‫‪13‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ – أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج‬
‫‪2.1‬‬
‫‪2.2‬‬
‫‪2.3‬‬
‫‪2.4‬‬
‫‪2.5‬‬
‫‪2.6‬‬

‫اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬
‫هﻴﻜﻠﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪...............................................................‬‬
‫اﻟﻤﺨﺮﺟﺎت واﻟﻤﺪﺧﻼت ‪......................................................‬‬
‫ﻣﺘﻐﻴﺮات اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪.................................................‬‬
‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪..................................‬‬
‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪..................................................................‬‬

‫‪15‬‬
‫‪15‬‬
‫‪16‬‬
‫‪24‬‬
‫‪26‬‬
‫‪30‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ – أﻳﻌﺎزات اﻟﻘﺮار واﻟﺘﻜﺮار‬
‫‪ 3.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬
‫‪ 3.2‬ﻋﺒﺎرة أذا ‪.......................................................................‬‬
‫‪ 3.3‬أذا اﻟﻤﺮآﺒﻪ ‪....................................................................‬‬
‫‪ 3.4‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................... Repeat – Until‬‬
‫‪ 3.5‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪............................................ While – Do‬‬
‫‪ 3.6‬ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................................... For‬‬
‫‪ 3.7‬أﺳﺘﺨﺪام ‪ For‬اﻟﻤﺘﺪاﺧﻠﻪ ‪....................................................‬‬
‫‪ 3.8‬ﻋﺒﺎرة أﺧﺘﻴﺎر اﻟﺤﺎﻟﻪ ‪................................................. Case‬‬
‫‪ 3.9‬ﺟﻤﻠﺔ ‪..................................................................... IN‬‬
‫‪ 3.10‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪.................................................................‬‬

‫‪32‬‬
‫‪32‬‬
‫‪35‬‬
‫‪36‬‬
‫‪37‬‬
‫‪40‬‬
‫‪41‬‬
‫‪43‬‬
‫‪47‬‬
‫‪48‬‬

‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ – اﻟﻤﺼﻔﻮﻓﺎت‬
‫‪ 4.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬
‫‪ 4.2‬اﻟﻤﺼﻔﻮﻓﺎت ‪...................................................................‬‬
‫‪ 4.2.1‬اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪...................................................‬‬
‫‪ 4.2.2‬اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪....................................................‬‬
‫‪ 4.3‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬

‫‪53‬‬
‫‪53‬‬
‫‪53‬‬
‫‪58‬‬
‫‪61‬‬

‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ – اﻷﺟﺮاءات واﻟﺪوال‬
‫‪5.1‬‬
‫‪5.2‬‬
‫‪5.3‬‬
‫‪5.4‬‬

‫اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬
‫اﻷﺟﺮاءات ‪....................................................................‬‬
‫اﻟﺪوال ‪..........................................................................‬‬
‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬

‫‪66‬‬
‫‪66‬‬
‫‪75‬‬
‫‪77‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎدس – اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬
‫‪ 6.1‬اﻟﻤﻘﺪﻣﻪ ‪80 .........................................................................‬‬
‫‪ 6.2‬ﻣﺎهﻲ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪80 ......................................................‬‬
‫‪ 6.3‬اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪81 .............................‬‬
‫‪ 6.3.1‬ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ ‪81 ..........................................................‬‬
‫‪ 6.3.2‬اﻷﺳﺘﻨﺴﺎخ ‪82 .............................................................‬‬
‫‪ 6.3.3‬اﻟﺤﺬف ‪83 .................................................................‬‬
‫‪ 6.3.4‬اﻟﺤﺸﺮ ‪84 .................................................................‬‬
‫‪ 6.3.5‬دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن ‪85 ..............................................‬‬
‫‪ 6.3.6‬ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪86 ......................................‬‬
‫‪ 6.3.7‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ ‪87 ....................‬‬
‫‪ 6.3.8‬ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪88 ............................‬‬
‫‪ 6.3.9‬ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ‪88 ................................‬‬
‫‪ 6.4‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪90 ..................................................................‬‬
‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ – ﻣﺘﻐﻴﺮات اﻷﻧﻮاع‬
‫‪ 7.1‬اﻟﻤﻘﺪﻣﻪ ‪.........................................................................‬‬
‫‪ 7.2‬اﻷﻧﻮاع ‪.........................................................................‬‬
‫‪ 7.2.1‬اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪.......................................................‬‬
‫‪ 7.2.2‬اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ‪......................................................‬‬
‫‪ 7.2.3‬اﻟﻤﺠﻤﻮﻋﺎت ‪...........................................................‬‬
‫‪ 7.3‬أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ‪...................................................................‬‬

‫‪93‬‬
‫‪93‬‬
‫‪94‬‬
‫‪97‬‬
‫‪98‬‬
‫‪102‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪1‬‬

‫اﻟﻔﺼﻞ اﻷول‬
‫ﻣﺪﺧﻞ اﻟﻰ اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫‪1.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫اﻟﺒﺮﻧﺎﻣﺞ هﻮ ﺳﻠ ﺴﻠﻪ ﻣﺘﺘﺎﻟﻴ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات ‪ ,‬ﻳﻤﻜﻨﻨ ﺎ ﺗ ﺸﺒﻴﻬﻬﺎ ﺑﻮﺻ ﻔﺔ أﻋ ﺪاد وﺟﺒ ﻪ ﻏﺬاﺋﻴ ﻪ ‪,‬‬
‫اﻟﻨﻮﺗ ﻪ اﻟﻤﻮﺳ ﻴﻘﻴﻪ ‪ ,‬أو ﻧﻤ ﻮذج ﺣﻴﺎآ ﻪ ‪ .‬وﺗﺘﻤﻴ ﺰ ﻋﻨﻬ ﺎ ﺑ ﺮاﻣﺞ اﻟﺤﺎﺳ ﻮب ﺑ ﺸﻜﻞ ﻋ ﺎم ﺑﺄﻧﻬ ﺎ أﻃ ﻮل أﻣﺘ ﺪادا‬
‫وآﺘﺎﺑﺘﻬﺎ ﺗﺴﺘﺪﻋﻲ دﻗﻪ وﻋﻨﺎﻳﻪ ﻓﺎﺋﻘﺘﻴﻦ ‪ .‬وﻗﺒﻞ اﻟﺸﺮوع واﻟﺨﻮض ﻓﻲ ﻣﻮﺿﻮع اﻟﺒﺮﻣﺠﻪ ﻻﺑﺪ ﻣﻦ ﺗﻌﺮﻳﻒ‬
‫ﺑﻌﺾ اﻟﻤﺼﻄﻠﺤﺎت اﻟﺘﻲ ﺗﺄﺗﻲ ﻻﺣﻘﺎ‪.‬‬
‫‪1.2‬‬

‫ﺑﻌﺾ اﻟﺼﻔﺎت اﻟﻌﺎﻣﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ‬

‫• ﻳﺤﺘﺎج اﻟﺒﺮﻧﺎﻣﺞ ﺑ ﺼﻮرﻩ ﻋﺎﻣ ﻪ اﻟ ﻰ ﻣ ﻦ ﻳﻜﺘﺒ ﻪ وه ﻮ اﻟﻤﺒ ﺮﻣﺞ ) ‪ , ( Programmer‬واﻟ ﻰ‬
‫اﻟﻤﻌ ﺎﻟﺞ ) ‪ ( Processor‬ﻟﺘﻔ ﺴﻴﺮ وﺗﻨﻔﻴ ﺬ ) ‪ ( Execution OR Running‬اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ‬
‫) ‪ , ( Instructions OR Commands‬وﺗﺴﻤﻰ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ آﺎﻣﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻤﻌﺎﻟﺠﻪ ) ‪( Process‬‬
‫• أن ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻳ ﺘﻢ ﺑ ﺼﻮرﻩ ﻣﺘﺘﺎﻟﻴ ﻪ ) أي أﻳﻌ ﺎز ) ‪ ( instruction‬ﺑﻌ ﺪ اﻷﺧ ﺮ ﺣ ﺴﺐ‬
‫ﺗﺴﻠ ﺴﻠﻬﺎ (‪ ,‬ﻣ ﺎﻟﻢ ﻳ ﺘﻢ اﻷﺧﺒ ﺎر ﺧﺎرﺟﻴ ﺎ ﻋ ﻦ ﻏﻴ ﺮ ذﻟ ﻚ‪ .‬ه ﺬا ﻳﻌﻨ ﻲ أن ﻧﺒ ﺪأ ﺑ ﺄول أﻳﻌ ﺎز وﻳﻨﻔ ﺬ ﺛ ﻢ اﻟﺜ ﺎﻧﻲ‬
‫واﻟﺜﺎﻟﺚ وهﻜﺬا ﻟﺤﻴﻦ اﻟﻮﺻﻮل اﻟﻰ اﻷﻳﻌﺎز اﻷﺧﻴﺮ‪ .‬ه ﺬا اﻟﻨﻤ ﻮذج ﻣﻤﻜ ﻦ أن ﻳﻐﻴ ﺮ ﺑﻄﺮﻳﻘ ﻪ ﻣﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ‬
‫ﺑﺸﻜﻞ ﺟﻴ ﺪ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ آﻤ ﺎ ﻳﻤﻜ ﻦ أن ﻳ ﺘﻢ ﺗﻜ ﺮار ﺟ ﺰء ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ وﺣ ﺴﺐ ﺗﺤﺪﻳ ﺪات اﻟﻤﺒ ﺮﻣﺞ‬
‫) ﻣﺜﻠﻤٍﺎ ﻳﺘﻢ ﺗﻜﺮار ﻣﻘﻄﻊ ﻣﻦ ﻧﻮﺗﻪ ﻣﻮﺳﻴﻘﻴﻪ ( ‪.‬‬
‫• أي ﺑﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜﻮن ﻟﻪ ﺗﺄﺛﻴﺮ‪ ..‬ﻣﺜﻼ ﻓ ﻲ اﻟﻘﻄﻌ ﻪ اﻟﻤﻮﺳ ﻴﻘﻴﻪ ﻳﻜ ﻮن ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻋﺒ ﺎرﻩ‬
‫ﻋ ﻦ ﺻ ﻮت ‪ ,‬أﻣ ﺎ ﻓ ﻲ ﺑ ﺮاﻣﺞ اﻟﺤﺎﺳ ﻮب ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻳﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ ﻣﺨﺮﺟ ﺎت ‪ ,‬أﻣ ﺎ ﻣﻄﺒﻮﻋ ﻪ أو‬
‫ﻣﻌﺮوﺿﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ ‪.‬‬
‫• آ ﻞ ﺑﺮﻧ ﺎﻣﺞ ﻳﻌﻤ ﻞ ﻋﻠ ﻰ أﺷ ﻴﺎء ﻣﺤ ﺪدﻩ ﻟﻠﻮﺻ ﻮل اﻟ ﻰ اﻟﺘ ﺄﺛﻴﺮ اﻟﻤﻄﻠ ﻮب ) ﻣ ﺜﻼ ﻓ ﻲ وﺻ ﻔﺔ‬
‫أﻋﺪاد اﻟﻄﻌﺎم ﻓﺎن هﺬﻩ اﻻﺷﻴﺎء ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻠﺤﻮم ‪ ,‬اﻟﺨﻀﺎر‪ ,‬وﻏﻴﺮهﺎ ( ‪ ,‬أﻣﺎ ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓ ﺄن ه ﺬﻩ‬
‫اﻻﺷﻴﺎء ﺗﻜﻮن ﺑﻴﺎﻧﺎت ‪.‬‬
‫• ﻓﻲ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺒﺮاﻣﺞ ﻳﺠﺐ أن ﻳﺘﻢ اﻷﻋﻼن اﻟﻤﺴﺒﻖ ﻋﻦ اﻟﻤﺘﻐﻴﺮات أو اﻟﺒﻴﺎﻧ ﺎت اﻟﺘ ﻲ ﺳ ﻴﺘﻢ‬
‫أﺳﺘﺨﺪاﻣﻬﺎ وﻣﺎهﻴﺔ أﻧﻮاﻋﻬﺎ ) هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻤﻠﻴﺔ أﻋﺪاد وﺟﺒﺔ ﻃﻌﺎم ﺣﻴﺚ ﻳﺠﺐ أن ﺗﺤﺘﻮي اﻟﻮﺻﻔﻪ اﺑﺘﺪاءا‬
‫ﻣﺎهﻴﺔ اﻟﻤﻮاد اﻟﺘﻲ ﺳﺘﺴﺘﺨﺪم وآﻤﻴﺎﺗﻬﺎ ( ‪.‬‬
‫• ﻓﻲ ﺑﻌ ﺾ اﻷﻳﻌ ﺎزات رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ أن ﻳﺘ ﺮك أﺗﺨ ﺎذ ﻗ ﺮار ﺗﻨﻔﻴ ﺬهﺎ اﻟ ﻰ اﻟﻤﻌ ﺎﻟﺞ‬
‫وﻓﻘﺎ ﻟﺸﺮوط ﻣﻌﻴﻨﻪ‪ ..‬ﻓﻤﺜﻼ ) ﻋﻨﺪ أﻋ ﺪاد وﺟﺒ ﺔ ﻃﻌ ﺎم ﻳﻜﺘ ﺐ ﻓ ﻲ اﻟﻮﺻ ﻔﻪ ﻣ ﺎ ﻳﻠ ﻲ " ﻋﻨ ﺪ ﺗ ﻮﻓﺮ اﻟﻄﻤﺎﻃ ﻪ‬
‫اﻟﻄﺎزﺟﻪ ﺗﺴﺘﺨﺪم ﺑﻌﺪ ﻧﺰع اﻟﻘﺸﺮ ﻓﻲ ﺧﻼف ذﻟﻚ ﻳﺴﺘﺨﺪم ﻣﻌﺠﻮن اﻟﻄﻤﺎﻃﻢ" ( ‪.‬‬
‫• رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ ﻟﺘﻨﻔﻴ ﺬ أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات ﻷآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ ‪ .‬ﻋﻠﻴ ﻪ‬
‫ﻃﺎﻟﻤﺎ هﻨﺎك أﻳﻌﺎز ﻳﺮاد ﺗﻜﺮارﻩ ﻓﺄن ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ﻳﺠﺐ ان ﺗﺤﺪد ‪ .‬ﻣﻤﻜﻦ أﻧﺠ ﺎز ذﻟ ﻚ أﻣ ﺎ ﺑﺘﺤﺪﻳ ﺪ‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪2‬‬

‫ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ) ﻣﺜﻼ ﻳﻮﺿﻊ اﻟﻄﻌﺎم ﻋﻠﻰ اﻟﻨﺎر ﻟﻤﺪة ‪ 30‬دﻗﻴﻘﻪ ( أو ﺑﻔﺤﺺ ﺣﺎﻟ ﻪ ﺗﻜ ﻮن ﻣ ﻦ ﺿ ﻤﻦ‬
‫اﻟﻌﻤﻠﻴﻪ ) ﻣﺜﻼ وﺿﻊ اﻟﻄﻌﺎم ﻋﻠﻰ اﻟﻨﺎر ﻟﺤﻴﻦ أن ﻳﻨﻀﺞ ( ‪.‬‬
‫‪1.3‬‬

‫اﻟﻤﻌﺮﻓﺎت ‪IDENTIFIERS‬‬
‫آﻞ اﻟﺒﺮاﻣﺞ ﺗﺤﺘﻮي ﻋﻠﻰ ﻧﻮﻋﻴﻦ ﻣﻦ اﻟﺮﻣﻮز ‪:‬‬

‫اﻟﻨﻮع اﻻول ‪ ..‬وهﻲ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﻌﻮد اﻟﻰ اﻟﻠﻐ ﻪ ‪ ..‬ﻓﻔ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ه ﺬﻩ‬
‫اﻟﺮﻣ ﻮز ﺑﻄ ﺮﻳﻘﺘﻴﻦ أﻣ ﺎ أن ﺗﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ رﻣ ﺰ واﺣ ﺪ أو أﺛﻨ ﻴﻦ ﻣﺜ ﻞ ) ‪ ( : , ; , ( ) , : = , + , -‬أو‬
‫ﻋﻠﻰ ﺷﻜﻞ آﻠﻤﺎت ﺗﺴﻤﻰ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ ﻣﺜﻞ ‪:‬‬
‫) ‪( begin , if , else , repeat , while, until , then , end‬‬
‫اﻟﻨ ﻮع اﻟﺜ ﺎﻧﻲ ‪ ..‬ه ﻮ اﻟﻤﻌﺮﻓ ﺎت وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ رﻣ ﻮز ﺗ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓﺄﻣ ﺎ أن ﺗﻜ ﻮن‬
‫ﻣﻌﺮﻓﺎت ﻗﻴﺎﺳﻴﻪ ﻣﺜﻞ‬
‫)‪( integer , real , write, sqrt …etc‬‬
‫أو أن ﺗﻜﻮن ﻣﻌﺮﻓ ﺎت ﻳ ﺘﻢ أﺧﺘﻴﺎره ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ‪ .‬ه ﺬﻩ اﻟﻤﻌﺮﻓ ﺎت اﻷﺧﻴ ﺮﻩ ﻧ ﺴﻤﻴﻬﺎ أﻳ ﻀﺎ‬
‫اﻟﻤﺘﻐﻴﺮات ) ‪ ( variables‬واﻟﻤﺘﻐﻴﺮ هﻮ رﻣﺰ أو أآﺜﺮ ﻳﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻟﻴ ﺸﻴﺮ اﻟ ﻰ ﻣﺤﺘ ﻮى ﻣﻮﻗ ﻊ‬
‫ﻓﻲ اﻟﺬاآﺮﻩ ‪.‬‬
‫اﻟﻤﺘﻐﻴﺮ ‪//:‬‬
‫ﻓﻲ أﻏﻠﺐ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ ﻓﺄن اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن ﻟﺘﺨﺰﻳﻦ اﻟﻤﻌﻠﻮﻣﺎت ‪ ,‬اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن أو‬
‫ﻣﻮﻗﻊ ﻓﻲ ذاآﺮة اﻟﺠﻬﺎز ﺣﻴﺚ ﻳﻤﻜﻦ ﺗﺨﺰﻳﻦ ﻗﻴﻤﻪ ﺑﺪاﺧﻠﻪ ﺛﻢ أﻣﻜﺎﻧﻴﻪ أﺳﺘﻌﺎدة هﺬﻩ اﻟﻘﻴﻤﻪ ﻓﻴﻤﺎ‬
‫ﺑﻌﺪ ‪.‬‬
‫واﻟﻤﺘﻐﻴﺮ هﻮ أﺳﻢ ﻳﻤﺜﻞ ﺑﺮﻗﻢ أو ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ) وﻣﻤﻜﻦ ﺣﺮف واﺣﺪ أو ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ( ‪.‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ ﺗﺼﻮر ذاآﺮة اﻟﺠﻬﺎز ﻋﻠﻰ أﻧﻬﺎ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻤﻮاﻗﻊ اﻟﺘﻲ ﺗﺨﺰن ﻓﻴﻬ ﺎ اﻟﻤﻌﻠﻮﻣ ﺎت ‪,‬‬
‫هﺬﻩ اﻟﻤﻮاﻗﻊ ﻣﺮﻗﻤﻪ ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ ﺗﺒﺪأ ﻣﻦ اﻟﺼﻔﺮ وﺗﻨﺘﻬﻲ ﺑﺤﺠﻢ اﻟﺬاآﺮﻩ ‪ ,‬ﺗﻌﺮف ه ﺬﻩ اﻷرﻗ ﺎم ﺑﻌﻨ ﺎوﻳﻦ‬
‫اﻟﺬاآﺮﻩ ﺳﻴﻤﺜﻞ أﺳﻢ اﻟﻤﺘﻐﻴﺮ ﺑﻄﺎﻗﺔ ﻋﻨﻮﻧﻪ ﻣﻠﺼﻘﻪ ﻋﻠﻰ أﺣﺪ اﻟﻤﻮاﻗﻊ ﺑﺤﻴﺚ ﺗﺴﺘﻄﻴﻊ اﻟﻮﺻ ﻮل اﻟﻴ ﻪ ﺳ ﺮﻳﻌﺎ‬
‫دون اﻟﺤﺎﺟﻪ اﻟﻰ ﻣﻌﺮﻓﺔ اﻟﻌﻨﺎوﻳﻦ اﻟﺤﻘﻴﻘﻴﺔ ﻓﻲ اﻟﺬاآﺮة ) ﻟﺬا ﻓﺎن اﻟﻤﺘﻐﻴﺮ ﺳﻴ ﺸﻴﺮ اﻟ ﻰ اﺣ ﺪ ه ﺬﻩ اﻟﻌﻨ ﺎوﻳﻦ‬
‫وﻋﻨﺪ وﺿﻊ ﻗﻴﻤﻪ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ﻓﺎن اﻟﻤﺘﺮﺟﻢ ) ‪ ( compiler‬ﺳﻴﺬهﺐ اﻟﻰ اﻟﻌﻨﻮان اﻟﺬي ﻳﺸﻴﺮ ﻟ ﻪ اﻟﻤﺘﻐﻴ ﺮ‬
‫وﻳﻀﻊ ﻓﻴﻪ اﻟﻘﻴﻤﻪ وآﺬﻟﻚ ﻋﻨ ﺪﻣﺎ ﻧﺮﻳ ﺪ أن ﻧﻌ ﺮف ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﻓ ﺄن اﻟﻤﺘ ﺮﺟﻢ ﻳ ﺬهﺐ اﻟ ﻰ اﻟﻌﻨ ﻮان اﻟ ﺬي‬
‫ﻳﺸﻴﺮ ﻟﻪ اﻟﻤﺘﻐﻴﺮ وﻳﻘﺮأ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﻓﻴﻪ ( ‪ .‬ﻳﻌﺮض اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ه ﺬﻩ اﻟﻔﻜ ﺮﻩ واﻟﺘ ﻲ ﺗﺒ ﻴﻦ ﺑﻌ ﺾ اﻟﻤﻮاﻗ ﻊ‬
‫ﻓﻲ اﻟﺬاآﺮة واﻟﺘﻲ ﻣﻤﻜﻦ ان ﻳﺸﻴﺮ اﻟﻴﻬﺎ اﻟﻤﺘﻐﻴﺮ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪3‬‬

‫ﺷﻜﻞ رﻗﻢ ) ‪ : ( 1.1‬ﺑﻌﺾ ﻣﻮاﻗﻊ اﻟﺬاآﺮﻩ‬
‫ﺗﺘﻜﻮن اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﺣﺮف واﺣﺪ ‪ ,‬ﻣﺠﻤﻮﻋﺔ ﺣﺮوف ‪ ,‬أو ﺣﺮوف وأرﻗﺎم ﻋﻠﻰ أن ﻳﻜ ﻮن أول‬
‫رﻣﺰ ﺣﺮف ﻣﺜﻞ‬
‫) ‪ ( x , b , ad, jasim , endofpoint , hind6 , x345‬هﺬﻩ ﺟﻤﻴﻌﺎ ﻣﺘﻐﻴﺮات ﻣﻘﺒﻮﻟﻪ‪.‬‬
‫أﻣﺎ اﻟﻤﺘﻐﻴﺮات اﻟﺘﺎﻟﻴ ﻪ ﻓﻬ ﻲ ﻏﻴ ﺮ ﻣﻘﺒﻮﻟ ﻪ ) ‪ ( first name , next.word , 15may‬واﻟ ﺴﺒﺐ‬
‫هﻮ أن اﻟﻤﺘﻐﻴﺮ اﻷول ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻓ ﺮاغ واﻟﺜ ﺎﻧﻲ ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻧﻘﻄ ﻪ أﻣ ﺎ اﻷﺧﻴ ﺮ ﻓﻬ ﻮ ﻳﺒ ﺪأ ﺑ ﺮﻗﻢ وه ﺬﻩ‬
‫ﺟﻤﻴﻌﻬﺎ ﻏﻴﺮ ﻣﻘﺒﻮﻟﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫أن أول ﻇﻬﻮر ﻟﻠﻤﺘﻐﻴﺮ ﻳﻜﻮن ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴ ﺮات ﺣﻴ ﺚ ﻳ ﺘﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮ‬
‫وﻳﺤﺪد ﻧﻮﻋﻪ ) أي هﻞ هﻮ رﻗﻢ ﺻﺤﻴﺢ ) ‪ ( integer‬ﻣﺜﻼ ‪ ,‬آ ﺴﺮ ) ‪ , ( real‬ﻧ ﺺ آﺘ ﺎﺑﻲ ) ‪, ( string‬‬
‫ﺣﺮف ) ‪...( character‬اﻟﺦ ( ‪ .‬أن أﺧﺘﻴﺎر اﻟﻤﺘﻐﻴ ﺮ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ﺗﻌﺘﺒ ﺮ ﻣ ﺴﺄﻟﻪ ﻣﻬﻤ ﻪ وﻳﻔ ﻀﻞ أن‬
‫ﻳﻌﻜﺲ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻌﻨﻰ اﻟﺬي ﺑﺴﺘﺨﺪم ﻷﺟﻠﻪ اﻟﻤﺘﻐﻴﺮ ﻓﻤﺜﻼ ﻳﻔ ﻀﻞ أﺳ ﺘﺨﺪام اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( sum‬ﻣ ﻊ اﻟﺠﻤ ﻊ‬
‫وأذا ﻣﺎ أﺳﺘﺨﺪم ﻣﺘﻐﻴﺮ أﺧﺮ ﻓﺎن ذﻟﻚ ﺳﻮف ﻻ ﻳﺆدي اﻟﻰ أي اﺷﻜﺎل ‪ ,‬وآﺬﻟﻚ ﻳﻔﻀﻞ أن ﻻ ﻳﻜﻮن اﻟﻤﺘﻐﻴ ﺮ‬
‫ﻃﻮﻳﻞ ﻓﻤ ﺜﻼ ﻳﻔ ﻀﻞ أﺳ ﺘﺨﺪام ﻣﺘﻐﻴ ﺮ ﻣﺘﻜ ﻮن ﻣ ﻦ ﺣ ﺮف واﺣ ﺪ ﻋﻨ ﺪﻣﺎ ﻧ ﺴﺘﺨﺪﻣﻪ ﻓ ﻲ ﺑﺮﻧ ﺎﻣﺞ ﻗ ﺼﻴﺮ وﻻ‬
‫ﻳﺘﻜﺮر آﺜﻴﺮا ‪ ,‬أﻣﺎ أﺳﺘﺨﺪام ﻣﺘﻐﻴﺮ ﻣﻦ ﺣﺮف واﺣﺪ وﻳﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر وﺑﺄﺟﺰاء ﻣﺘﻜﺮرﻩ ﻓﻲ ﺑﺮﻧﺎﻣﺞ‬
‫ﻃﻮﻳﻞ ﻓﺄﻧﻪ ﻳﻌﺘﺒﺮ أﺧﺘﻴﺎر ﺳﻲء ﺑﺎﻟﺮﻏﻢ ﻣﻦ أﻧﻪ ﻻ ﻳﻌﻴﻖ ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫‪1.4‬‬

‫اﻟﺜﻮاﺑﺖ ‪CONSTANTS‬‬

‫ﻓﻲ ﺑﻌﺾ اﻟﺒﺮاﻣﺞ ﻧﺤﺘﺎج اﻟﻰ أﺳﺘﺨﺪام ﻗﻴﻢ رﺑﻤﺎ ﺗﻜﻮن ﻣﻌﺮوﻓﻪ ﻣ ﺴﺒﻘﺎ ﻗﺒ ﻞ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ‬
‫ﻳﻤﻜﻦ أن ﺗﺘﻐﻴﺮ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻣﺜﻞ اﻟﻨﺴﺒﻪ اﻟﺜﺎﺑﺘ ﻪ ) ‪ ( Л‬واﻟﺘ ﻲ ﺗﻜ ﻮن ﻗﻴﻤﺘﻬ ﺎ ) ‪( 3.1415926585‬‬
‫هﺬﻩ اﻟﻘﻴﻢ اﻟﺜﺎﺑﺘﻪ ﺳﻮاء آﺎﻧﺖ ذات ﻗﻴﻤﻪ ﻣﻌﺮوﻓﻪ ﻣﺴﺒﻘﺎ أو أي ﻗﻴﻤ ﻪ ﻣﻤﻜ ﻦ أن ﺗ ﺴﻨﺪ اﻟ ﻰ ﻣﺘﻐﻴ ﺮ ‪ ,‬ﺟﻤﻴﻌﻬ ﺎ‬
‫ﻣﻤﻜﻦ أن ﺗﻌﺮف ﺑﺤﻘﻞ ﺧﺎص ﻳﺪﻋﻰ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﺜﻮاﺑ ﺖ وه ﺬا اﻟﺤﻘ ﻞ ﻳ ﺴﺒﻖ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ‬
‫اﻟﻤﺘﻐﻴﺮات وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Const‬‬
‫; ‪Pi = 3.1413926535‬‬
‫; ' ‪Error = ' Run_Time Error‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪4‬‬

‫أﺳﺒﺎب أﺳﺘﺨﺪام اﻟﺜﻮاﺑﺖ ‪:‬‬
‫• أذا آﺎن هﻨﺎك ﻋﺪد ﻳﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺄن اﻟﻤﺒﺮﻧﺞ ﻳﻔﻀﻞ أن ﻳﺼﻔﻪ‬
‫ﺑﺄﺳﻢ ﺿﻤﻦ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ ,‬وﺑﻌﺪهﺎ ﺑﺎﻷﻣﻜﺎن أﺳﺘﺨﺪام اﻷﺳﻢ اﻟﻤﻮﺻﻮف ﻓﻲ‬
‫اﻟﻘﺴﻢ اﻟﺘﻨﻔﻴﺬي ‪.‬‬
‫• ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام ﺣﻘﻞ اﻟﺜﻮاﺑﺖ ﻟﺘﺴﻤﻴﺔ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ واﻟﺘﻲ‬
‫ﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﻣﺜﺎل ‪ :‬ﻧﻔﺮض أﻧﻨﺎ ﻧﺤﺘﺎج اﻟﻰ ﻃﺒﺎﻋﺔ أﺳﻢ ﺟﺎﻣﻌﻪ ﻣﺜﻼ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻣﻤﻜﻦ أن‬
‫ﻧﻘﻮم ﺑﻤﺎﻳﻠﻲ ‪:‬‬
‫‪Const‬‬
‫; ' ‪University = 'Al _ Mustnsirah university‬‬
‫; '‪Underline = '----------------------------------------------‬‬
‫اﻷن ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﻌﺮﻓﻪ آﺜﻮاﺑﺖ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وآﻤﺎ ﻳﻠﻲ‪:‬‬
‫; ) ‪Writeln ( university‬‬
‫; ) ‪Writeln ( underline‬‬
‫‪1.5‬‬

‫اﻟﺒﻴﺎﻧﺎت ‪DATA‬‬

‫آﻞ ﻋﻨﺼﺮ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ أﻣ ﺎ أن ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ ﺛﺎﺑﺘ ﻪ أو ﻣﺘﻐﻴ ﺮﻩ ) أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫رﺑﻤﺎ ﺗﺘﻐﻴﺮ ﺧﻼل ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ (‪ .‬آﻞ ﻣﺘﻐﻴﺮ) واﻟﺬي هﻮ ﺑﻴﺎﻧﺎت ( ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜ ﻮن ﻟ ﻪ ﻧ ﻮع‬
‫وﺑﻤﻮﺟﺐ هﺬا اﻟﻨﻮع ﺳﻴﺘﻢ ﺗﺤﺪﻳﺪ اﻟﻤﺴﺎ ﺣﻪ اﻟﺨﺰﻧﻴﻪ اﻟﻼزﻣﻪ ﻟﻘﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ‪ ,‬وآ ﺬﻟﻚ ﺗﺤ ﺪد اﻟﻌﻤﻠﻴ ﺎت‬
‫اﻟﺘﻲ ﻣﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻰ هﺬا اﻟﻤﺘﻐﻴﺮ‪ .‬واﻷﻧﻮاع اﻟﻘﻴﺎﺳﻴﻪ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ ‪:‬‬
‫‪ 1.5.1‬اﻻﻋﺪاد اﻟﺼﺤﻴﺤﻪ ‪INTEGERS‬‬
‫اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ هﻲ آﻞ اﻷﻋﺪاد اﻟﻤﻮﺟﺒﻪ واﻟﺴﺎﻟﺒﻪ اﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ آ ﺴﺮ‪ .‬ﻓﺎﻟ ﺼﻔﺮ ﻋ ﺪد‬
‫ﺻﺤﻴﺢ و ‪ 567‬هﻮ ﻋﺪد ﺻﺤﻴﺢ و ‪ -23‬أﻳﻀﺎ ﻋﺪد ﺻﺤﻴﺢ ‪ .‬أﻣ ﺎ )‪ 123.345‬و ‪ ( -1.45‬ﻓﻬ ﻲ ﻟﻴ ﺴﺖ‬
‫أﻋ ﺪاد ﺻ ﺤﻴﺤﻪ‪ .‬أن اﻋﻠ ﻰ ﻗﻴﻤ ﻪ وأوﻃ ﺄ ﻗﻴﻤ ﻪ ﻟﻌ ﺪد ﺻ ﺤﻴﺢ ﻣﻤﻜ ﻦ ﺗﻤﺜﻴﻠ ﻪ ﻓ ﻲ اﻟﺤﺎﺳ ﻮب ﺗﺨﺘﻠ ﻒ ﻣ ﻦ‬
‫ﺣﺎﺳﻮب ﻷﺧﺮ ‪ ,‬وﻳﻤﻜﻦ ﻣﻌﺮﻓﺔ هﺬﻩ اﻟﻘﻴﻢ ﻓﻲ أي ﺣﺎﺳﻮب ﺑﺄﺳﺨﺪام اﻷﻳﻌﺎزات اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫ﻟﻤﻌﺮﻓﺔ أﻋﻠﻰ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬
‫ﻟﻤﻌﺮﻓﺔ أوﻃﺄ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬

‫‪maxint‬‬
‫‪- maxint‬‬

‫أن أي ﻣﺤﺎوﻟ ﻪ ﻷﺳ ﺘﺨﺪام ﻗ ﻴﻢ ﺧ ﺎرج ﻧﻄ ﺎق اﻟﺤ ﺪود اﻟﻌﻠﻴ ﺎ واﻟ ﺪﻧﻴﺎ ﺳ ﻴﺆدي اﻟ ﻰ ﺣ ﺪوث ﺧﻄ ﺄ‪.‬‬
‫وﺑﺸﻜﻞ ﻋ ﺎم ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﺗ ﺴﺘﺨﺪم أﺿ ﺎﻓﻪ اﻟ ﻰ اﻟﻌﻤﻠﻴ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ ﻓ ﻲ‬
‫اﻟﻌﺪادات واﻟﻔﻬﺎرس ‪.‬‬
‫اﻟﻌﻼﻗ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﺘ ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ه ﻲ ) ‪( + , - , * , Div , Mod‬‬
‫وهﻲ ﻋﻠﻰ اﻟﺘﻮاﻟﻲ ) اﻟﺠﻤﻊ ‪ ,‬اﻟﻄﺮح ‪ ,‬اﻟﻀﺮب ‪ ,‬اﻟﻘﺴﻤﻪ ‪ ,‬وﺣﺴﺎب ﺑﺎﻗﻲ اﻟﻘﺴﻤﻪ ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪5‬‬

‫ﻳﺠﺐ أن ﻧﻼﺣﻆ هﻨﺎ أن اﻟﻌﻼﻣﻪ ) ‪ ( /‬ﺗﺴﺘﺨﺪم ﻟﻠﻘﺴﻤﻪ ﻟﻜﻦ ﻣﻊ اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ أي اﻟﺘ ﻲ ﺗﺤﺘ ﻮي‬
‫آﺴﻮر‬
‫أﻣﺜﻠﻪ ‪//:‬‬
‫‪2 Div 3 = 0‬‬
‫‪2 / 3 = 0.66666667‬‬
‫‪5 Div 1 = 5‬‬
‫‪5 / 1 = 5.0‬‬
‫‪5 Div 2 = 2‬‬
‫‪2+3*4 = 14‬‬
‫‪(2+3) * 4 = 20‬‬
‫‪5 mod 2 = 1‬‬
‫‪7 mod 4 = 3‬‬

‫هﻨﺎ ﻳﻨﻔﺬ داﺧﻞ اﻟﻘﻮس أوﻻ‬

‫وﻳ ﺼﺮح ﻋ ﻦ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات‬
‫) ﺳﻨﻮﺿﺤﻬﺎ ﻻﺣﻘﺎ ( ﺑﺎﻟﺪاﻟﻪ ) ‪. ( integer‬‬
‫‪ 1.5.2‬اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ‪REAL NUMBERS‬‬
‫وهﻲ اﻷﻋﺪاد اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ آﺴﻮر ﻣﺜ ﻞ‬

‫‪0.03 , 12.5 , -356.67890 , 10.0‬‬

‫) ‪ ( + , - , * , /‬وه ﻲ‬
‫أﻣ ﺎ اﻟﻌﻤﻠﻴ ﺎت اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﺘ ﻲ ﻣﻤﻜ ﻦ أﺟﺮاؤه ﺎ ﻋﻠﻴﻬ ﺎ ﻓﻬ ﻲ‬
‫) اﻟﺠﻤﻊ ‪ ,‬اﻟﻄﺮح ‪ ,‬اﻟﻀﺮب ‪ ,‬اﻟﻘﺴﻤﻪ (‪ .‬وﻳﺼﺮح ﻋ ﻦ اﻷﻋ ﺪاد اﻟﺤﻘﻴﻘﻴ ﻪ ﻓ ﻲ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ‬
‫ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﺪاﻟﻪ ) ‪. ( Real‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﺗﻤﺜﻞ اﻷرﻗﺎم ﺑﻄﺮﻳﻘﺘﻴﻦ ﻓﺄﻣﺎ أرﻗﺎم ﺻﺤﻴﺤﻪ ﺑﺪون آﺴﺮ أو أرﻗﺎم آﺴﺮﻳﻪ ‪ .‬اﻟﻘﻮاﻋﺪ اﻟﺘﺎﻟﻴﻪ‬
‫ﺗﻄﺒﻖ ﻋﻨﺪ آﺘﺎﺑﺔ أرﻗﺎم‬
‫‪ .1‬اﻟﻔﺎرزﻩ ﻻ ﻳﻤﻜﻦ أن ﺗﻈﻬﺮ ﻓﻲ أي ﻣﻜﺎن ﻓﻲ اﻟﺮﻗﻢ ‪.‬‬
‫‪ .2‬ﻣﻤﻜﻦ أن ﺗﺴﺒﻖ اﻷرﻗﺎم أﺣﺪى اﻟﻌﻼﻣﺘﻴﻦ ) ‪ ( + , -‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ آﻮﻧﻪ ﻣﻮﺟﺐ أو‬
‫ﺳﺎﻟﺐ ) ﻳﻌﺘﺒﺮ اﻟﺮﻗﻢ ﻣﻮﺟﺒﺎ أذا ﻟﻢ ﺗﻈﻬﺮ أي ﻣﻦ اﻟﻌﻼﻣﺘﻴﻦ أﻣﺎﻣﻪ ( ‪.‬‬
‫‪ .3‬ﻳﻤﻜﻦ ﺗﻤﺜﻴﻞ اﻷرﻗﺎم ﺑﻄﺮﻳﻘﺔ اﻟﻌﻼﻣﻪ اﻟﻌﻠﻤﻴﻪ ) وذﻟﻚ ﺑﺄﺳﺘﺒﺪال اﻟﺮﻗﻢ ) ‪( 10‬‬
‫ﺑﺎﻟﺤﺮف ) ‪ . ( ( E‬ﻣﺜﻼ اﻟﺮﻗﻢ ) ‪ ( 2.7 x 10 -6‬ﺗﻜﺘﺐ ﺣﺴﺐ اﻟﻌﻼﻣﻪ اﻟﻌﻠﻤﻴﻪ آﻤﺎ‬
‫ﻳﻠﻲ ) ‪. ( 2.7E-6‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫أدﻧﺎﻩ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻟﻬﺎﻣﻪ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﺮاﻋﻰ ﻋﻨﺪ آﺘﺎﺑﺔ اﻟﻌﻼﻗﺎت اﻟﺮﻳﺎﺿﻴﻪ ‪:‬‬
‫‪.1‬‬
‫‪.2‬‬

‫‪.3‬‬
‫‪.4‬‬

‫‪.5‬‬

‫أن وﺿﻊ أﺷﺎرة اﻟﺴﺎﻟﺐ ﻗﺒﻞ اﻟﻤﺘﻐﻴﺮات هﻲ ﻣﻜﺎﻓﺌﻪ ﻟﻀﺮب اﻟﻤﺘﻐﻴﺮ ﺑﺎﻟﻘﻴﻤﻪ ) ‪( -1‬‬
‫‪ .‬ﻣﺜﻼ اﻟﻤﺘﻐﻴﺮات ) ‪ – ( x+y‬ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﺘﺐ ) ‪. -1 * ( x+y‬‬
‫ﻳﺠﺐ أن ﺗﻜﺘﺐ اﻟﻌﻼﻗﺎت اﻟﺮﻳﺎﺿﻴﻪ وﻓﻘﺎ ﻟﻠﻄﺮﻳﻘﻪ اﻟﺘﻲ ﺗﺤﺪدهﺎ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫ﺑﺤﻴﺚ ﺗﺬآﺮ آﻞ اﻟﻌﻼﻣﺎت اﻟﺮﻳﺎﺿﻴﻪ دون أﺧﺘﺼﺎر ‪ .‬ﻣﺜﺎل ‪ :‬اﻟﻌﻼﻗﻪ اﻟﺮﻳﺎﺿﻴﻪ اﻷﺗﻴﻪ‬
‫ﻏﻴﺮ ﻣﻘﺒﻮﻟﻪ ) ) ‪ ( 2( x1 + 3x2‬هﺬﻩ اﻟﻌﻼﻗﻪ ﻟﻜﻲ ﺗﻜﻮن ﻣﻘﺒﻮﻟﻪ ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
‫ﺑﺎﺳﻜﺎل ﻳﺠﺐ أن ﺗﻜﺘﺐ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪ ( 2 * ( x1 + 3 * x2 ) ) :‬اﻟﻌﻼﻗﻪ‬
‫اﻷوﻟﻰ هﻲ اﻟﺘﻲ ﺗﻌﻮدﻧﺎ ﻋﻠﻰ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺮﻳﺎﺿﻴﺎت ‪.‬‬
‫اﻟﺮﻗﻢ اﻟﺴﺎﻟﺐ ﻣﻤﻜﻦ أن ﻳﺮﻓﻊ اﻟﻰ أي أس ﺑﺸﺮط أن ﻳﻜﻮن اﻷس ﻋﺪد ﺻﺤﻴﺢ ) ﻷن‬
‫اﻟﺮﻗﻢ اﻟﻤﺮﻓﻮع اﻟﻰ ﻗﻴﻤﻪ ﻣﻌﻴﻨﻪ ﺳﻴﻀﺮب ﺑﻨﻔﺴﻪ ﻋﺪد ﻣﻦ اﻟﻤﺮات ﺑﻘﺪر اﻷس أذا‬
‫آﺎن ﻋﺪد ﺻﺤﻴﺢ وﻻ ﻳﻬﻢ ﻓﻴﻤﺎ أذا آﺎن اﻷﺳﺎس ﺳﺎﻟﺐ أو ﻣﻮﺟﺐ ( ‪.‬‬
‫ﻻﻳﺠﻮز رﻓﻊ اﻟﻘﻴﻤﻪ اﻟﺴﺎﻟﺒﻪ اﻟﻰ أس آﺴﺮي ) وذﻟﻚ ﻷن ﺣﺴﺎب ﻧﺎﺗﺞ اﻟﺮﻗﻢ‬
‫اﻟﻤﺮﻓﻮع اﻟﻰ أس آﺴﺮي ﻳﺘﻢ ﺑﺤﺴﺎب اﻟﻠﻮﻏﺎرﻳﺜﻢ ﻟﻸﺳﺎس ‪ ,‬وﻳﻀﺮب هﺬا‬
‫اﻟﻠﻮﻏﺎرﻳﺜﻢ ﺑﺎﻷس ‪ ,‬وﻋﻨﺪهﺎ ﻳﺤﺴﺐ ﻣﻌﻜﻮس اﻟﻠﻮﻏﺎرﻳﺜﻢ ‪ ,‬وﺣﻴﺚ أن اﻟﻠﻮﻏﺎرﻳﺜﻢ‬
‫ﻟﻠﺮﻗﻢ اﻟﺴﺎﻟﺐ ﻏﻴﺮ ﻣﻌﺮف ﻟﺬا ﻻﻳﻤﻜﻦ أﻳﺠﺎد اﻟﻨﺘﻴﺠﻪ ( ‪.‬‬
‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ ﻻﻳﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪ .‬ﻣﺜﺎل ‪( 'xyz' + 34‬‬
‫) هﺬا ﻏﻴﺮ ﻣﻘﺒﻮل وذﻟﻚ ﻷن ) ‪ ( xyz‬هﻮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ وﻟﻴﺲ رﻗﻢ أو ﻣﺘﻐﻴﺮ‬
‫رﻗﻤﻲ ) ﻻﺣﻆ أﻧﻪ ﻣﺤﺼﻮر ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ‪( quotation mark‬‬
‫ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻣﻤﻜﻦ أﺳﺘﺨﺪام ﻗﻴﻢ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ﻓﻲ اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ‬
‫) وﻻ ﻳﻤﻜﻦ اﻟﻌﻜﺲ ( ‪ ,‬ﻓﺄذا آﺎﻧﺖ أﺣﺪى اﻟﻘﻴﻢ ﻷي ﻣﻦ اﻟﻌﻤﻠﻴﺎت ) * ‪ ( + , – ,‬ﻗﻴﻤﻪ‬
‫ﺣﻘﻴﻘﻴﻪ ﻓﺄن اﻟﻘﻴﻤﻪ اﻷﺧﺮى ﺗﺤﻮل اﻟﻰ ﺣﻘﻴﻘﻴﻪ أﻟﻴﺎ ﻗﺒﻞ ﺗﻄﺒﻴﻖ اﻟﻌﻤﻠﻴﻪ ‪.‬‬
‫أﻣﺎ ﻋﻨﺪ أﺳﺘﺨﺪام ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ) ‪ ( /‬ﻓﻴﺠﺐ أن ﻳﻜﻮن آﻼ اﻟﻘﻴﻤﺘﻴﻦ ﺣﻘﻴﻘﻴﺘﻴﻦ ‪.‬‬

‫‪6‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪7‬‬

‫‪ 1.5.3‬اﻟﺮﻣﻮز ‪Characters‬‬
‫وهﻲ آﺎﻓﺔ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺤﺎﺳﻮب واﻟﺘﻲ ﻏﺎﻟﺒﺎ ﻣﺎ ﻧﺠﺪهﺎ ﻋﻠﻰ ﻟﻮﺣﺔ اﻟﻤﻔ ﺎﺗﻴﺢ واﻟﺘ ﻲ‬
‫ﺗ ﺸﻤﻞ اﻟﺤ ﺮوف اﻷﺑﺠﺪﻳ ﻪ ﺳ ﻮاء آﺎﻧ ﺖ ﺣ ﺮوف آﺒﻴ ﺮﻩ ) ‪ (A . . Z‬أو ﺣ ﺮوف ﺻ ﻐﻴﺮﻩ ) ‪, ( a..z‬‬
‫( ‪ ,‬اﻟﺮﻣ ﻮز اﻻﺧ ﺮى اﻟﺘ ﻲ ﻧﺮاه ﺎ ﻋﻠ ﻰ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﻣﺜ ﻞ‬
‫‪0..9‬‬
‫اﻷرﻗ ﺎم )‬
‫) ‪ ( + , . , / , ? , # , ! , & , % ..etc‬وﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﻔﺮد ‪ .‬وﻳﺼﺮح ﻋﻦ اﻟﺮﻣﻮز ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ ) ‪ . ( char‬وﻻ ﺗﻮﺟ ﺪ هﻨ ﺎك ﻣﺠﻤﻮﻋ ﻪ ﺧﺎﺻ ﻪ ﻣ ﻦ‬
‫اﻟﺮﻣ ﻮز ﻟﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻷن ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف ﻟﻠﺤﺎﺳ ﻮب اﻟ ﺬي‬
‫ﺗﻌﻤﻞ ﻋﻠﻴﻪ ‪.‬‬
‫أن أآﺜﺮ ﻣﺠﺎﻣﻴﻊ اﻟﺤﺮوف أﺳﺘﺨﺪاﻣﺎ هﻤﺎ أﺛﻨﺎن ‪:‬‬
‫‪2 ASCII‬‬
‫)‪(American Standard Code for Information International‬‬
‫‪3 EBCDIC‬‬
‫)‪(Extended Binary Coded Decimal Information Code‬‬
‫وآﻞ ﻣﻨﻬﻢ ﻟﻪ ﺻﻔﺎﺗﻪ اﻟﺨﺎﺻﻪ ﺑﻪ ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫آﻞ ﻣﺎ ﻳﻜﺘﺐ ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ' ' ( هﻮ واﺣﺪ ﻣﻦ أﺛﻨﻴﻦ ‪:‬‬
‫‪ .1‬أذا آﺎن أآﺜﺮ ﻣﻦ رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪.‬‬
‫‪ .2‬أذا آﺎن رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺣﺮف وﻣﻤﻜﻦ ﻓﻲ ﺑﻌﺾ اﻟﺤﺎﻻت ﻳﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ‬
‫ﺣﺮﻓﻴﻪ أذا آﺎن ﻣﻌﺮف آﺬﻟﻚ ‪.‬‬

‫ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف ﻟﻬﺎ اﻟﺨﻮاص واﻟﺼﻔﺎت اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫‪ .1‬آ ﻞ ﺣ ﺮف ﻟ ﻪ ﻋ ﺪد ﺗﺮﺗﻴﺒ ﻲ ) ‪ ( Ordinal Value‬ﻣﺨﺘﻠ ﻒ ‪ ,‬ﺣﻴ ﺚ أن ه ﺬﻩ اﻟﺤ ﺮوف‬
‫ﻣﺮﺗﺒﻪ وﻓﻘﺎ ﻷﺣﺪ اﻟﻨﻈﺎﻣﻴﻦ أﻋﻼﻩ ‪.‬‬
‫وﺗﺴﺘﺨﺪم اﻟﺪاﻟﻪ ) ‪ ( Ord‬ﻟﺘﻌﻴﺪ ﻗﻴﻤﺔ اﻟﻌﺪد اﻟﺘﺮﺗﻴﺒﻲ ‪ ,‬ﻓﻤﺜﻼ أذا آﺎن آﻞ ﻣﻦ‬
‫) ‪ ( ch1 , ch2‬هﻤﺎ ﻣﻦ ﻧﻮع ﺣﺮوف ) ‪ ( char‬وآﺎن‬
‫‪ch1 ≠ ch2‬‬
‫ﻓﺄن‬

‫) ‪ord ( ch1 ) ≠ ord ( ch2‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﻌﻮاﻣﻞ اﻟﻮﺣﻴﺪﻩ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻟﺤﺮﻓﻴﻪ هﻲ‪:‬‬
‫ﻳﺠﺐ <‬
‫ﻟﻸرﻗﺎم> ) ‪, <=( 0, ..= 9,‬‬
‫اﻟﺘﺮﺗﻴﺒﻲ ‪= ,‬‬
‫‪ .2‬اﻟﻌﺪد ) >‬
‫أن ﺗ(ﻜﻮن ﻣﺮﺗﺒﻪ وﻣﺘﺘﺎﻟﻴﻪ ) ﻣﺘﻌﺎﻗﺒﻪ (‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪8‬‬

‫) '‪Ord ( '1' ) , ord ( '2' ) , ord ( '3' ) , …….., ord ( '9‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻓﻲ ﻏﺎﻟﺒﻴﺔ اﻟﻤﺠﺎﻣﻴﻊ اﻟﺤﺮﻓﻴﻪ ﻓﺄن‬
‫‪ ord ( ' 0 ' ) ≠ 0‬ﻟﺬا ﻓﺄن اﻟﺪاﻟﻪ‬
‫) ‪ ( ord‬ﻻ ﺗﺤﻮل اﻷرﻗﺎم اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻤﻘﺎﺑﻠﻪ ‪.‬‬

‫‪ .3‬ﻟﻜﻲ ﻧﺤﻮل اﻟﺮﻗﻢ ﺑﺎﻟﻤﺘﻐﻴﺮ اﻟﺤﺮﻓﻲ ) ‪ ( ch‬اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﺮﻗﻤﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ) ‪( num‬‬
‫ﻓﻴﺠﺐ أﺳﺘﺨﺪام اﻟﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫; ) ' ‪Num : = ord ( ch ) – ord ( ' 0‬‬
‫‪ .4‬اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟﻜﺒﻴ ﺮﻩ ) ‪ ( A , B , ….. , Z‬ﻳﺠ ﺐ أن ﺗﻜ ﻮن ﻣﺮﺗﺒ ﻪ‬
‫وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ ‪.‬‬
‫‪ .5‬اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟ ﺼﻐﻴﺮﻩ ) ‪ ) ( a , b , ….. , z‬أذا وﺟ ﺪت ( ﻳﺠ ﺐ أن‬
‫ﺗﻜﻮن ﻣﺮﺗﺒﻪ وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ ‪.‬‬
‫أن اﻟﻔﻘﺮﺗﻴﻦ ) ‪ 4‬و ‪ ( 5‬ﺗﺆآﺪان ﻋﻠﻰ أن ﺗﻜ ﻮن اﻟﺤ ﺮوف ﻣﺮﺗﺒ ﻪ هﺠﺎﺋﻴ ﺎ ‪ ,‬وﻟﻜ ﻦ ﻟ ﻴﺲ‬
‫ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻟﻬﺎ أﻋﺪاد ﺗﺮﺗﻴﺒﻴﻪ ﻣﺘﻌﺎﻗﺒﻪ ‪ ,‬ﻓﻤﺜﻼ ﻓﻲ ﻧﻈﺎم ) ‪: ( EBCDIC‬‬
‫‪Ord ( ' I ' ) = 201‬‬
‫‪Ord ( ' J ' ) = 209‬‬
‫‪ .6‬اﻟﺪاﻟ ﻪ ) ‪ ( chr‬ﺗﻌﻤ ﻞ ﻋﻜ ﺲ اﻟﺪاﻟ ﻪ ) ‪ ( ord‬ﻓﻬ ﻲ ﺗﺄﺧ ﺬ ﻣﻌﺎﻣ ﻞ ﻣ ﻦ ﻧ ﻮع ﻋ ﺪد ﺻ ﺤﻴﺢ‬
‫وﺗﻌﻄﻲ اﻟﻘﻴﻤﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ﻟﻪ ‪ ,‬وﻣﺪى ﻋﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ه ﻮ ﻣ ﺪى ﻋﻤ ﻞ اﻟﺪاﻟ ﻪ‬
‫) ‪.( ord‬‬
‫; ) ‪num : = ord ( ch‬‬
‫; ) ‪ch : = chr ( num‬‬
‫‪ .7‬ﻋﻤﻠﻴﺎ أذا ﻣﺎ أﺧﺬﻧﺎ رﻗﻢ ) ‪ ( num‬ﻣﻦ ﻧﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ‪( 0 ≤ num ≤ 9‬‬
‫ﻓﺄن اﻟﺤﺮف اﻟﻤﻘﺎﺑﻞ ﻟﻪ هﻮ وﻓﻘﺎ ﻟﻠﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫; )) ' ‪ch : = chr ( num + ord ( ' 0‬‬
‫ﻣﺜﻼ ‪:‬‬
‫' ‪chr ( 3 + ord ( ' 0 ' ) ) = ' 3‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪9‬‬

‫‪ 1.5.4‬اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRING‬‬
‫وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ ﻣﺘﻮاﻟﻴ ﻪ ﻣ ﻦ اﻟﺮﻣ ﻮز اﻟﻤﺒﻴﻨ ﻪ ﻓ ﻲ اﻟﻔﻘ ﺮﻩ اﻟ ﺴﺎﺑﻘﻪ ‪ ,‬آ ﺬﻟﻚ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي‬
‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ﻋﻠﻰ ﻓﺮاغ وﻳﻌﺘﺒﺮ رﻣﺰ وﻟﻜﻦ ﻻ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﻋﻠ ﻰ ﻋﻼﻣ ﺎت‬
‫اﻷﻗﺘﺒ ﺎس ‪ .‬أن اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﺗ ﺴﺘﺨﺪم ﻟﺘﻌﺮﻳ ﻒ اﻟﻤﻌﻠﻮﻣ ﺎت ﻏﻴ ﺮ اﻟﺮﻗﻤﻴ ﻪ ﻣﺜ ﻞ اﻷﺳ ﻤﺎء ‪ ,‬اﻟﻌﻨ ﺎوﻳﻦ‬
‫وﻏﻴﺮهﺎ‪ ,‬وأن ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺗﺴﺘﻮﻋﺒﻬﺎ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ ) ‪. ( 0 .. 255‬‬
‫وﻳ ﺼﺮح ﻋ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ‬
‫) ‪ . ( string‬ﻣﺜﺎل‬
‫'‪'Xyz‬‬
‫'‪'Ali Abbas‬‬
‫'‪'Apollo-17‬‬
‫'‪'Do you wish to try again‬‬
‫اﻟﺠﻤﻠﻪ اﻷﺧﻴﺮﻩ ﺗﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ‪ ,‬آ ﺬﻟﻚ ﻓ ﺄن اﻷرﻗ ﺎم ﻋﻨ ﺪﻣﺎ ﺗﻌ ﺮف ﻣ ﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
‫ﺗﻌﺎﻣﻞ آﺮﻣﻮز وﻟﻴﺲ أرﻗﺎم ‪.‬‬
‫‪1.6‬‬

‫اﻟﺘﻌﺎﺑﻴﺮ اﻟﻤﻨﻄﻘﻴﻪ ‪THE BOOLEAN EXPRESSIONS‬‬

‫وه ﻲ اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺘ ﻲ ﺗﻤﺜ ﻞ ﻧﺘﻴﺠﺘﻬ ﺎ ﺑﺤﺎﻟ ﻪ واﺣ ﺪﻩ ﻣ ﻦ أﺛﻨﺘ ﻴﻦ وهﻤ ﺎ ) ﺻ ﺢ أو ﺧﻄ ﺄ (‬
‫) ‪ , (true OR false‬وهﻨﺎك ﺛﻼث ﻋﻮاﻣﻞ ﻣﻨﻄﻘﻴﻪ وهﻲ ) ‪. (And , Or , Not‬‬
‫واﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﻳﻌﻴ ﺪ اﻟﻘﻴﻤ ﻪ ) ‪ ( 1‬ﻋﻨ ﺪﻣﺎ ﻳﻜ ﻮن اﻟﺘﻌﺒﻴ ﺮ ) ‪ ( TRUE‬واﻟﻘﻴﻤ ﻪ ) ‪ ( 0‬ﻋﻨ ﺪﻣﺎ‬
‫ﻳﻜﻮن اﻟﺘﻌﺒﻴﺮ ) ‪ . ( FALSE‬وهﻲ ﺗﺴﺘﺨﺪم ﻟﻮﺻ ﻒ أي ﺗﻌﺒﻴ ﺮ ﻓﻴﻤ ﺎ أذا آ ﺎن ﺻ ﺢ أو ﺧﻄ ﺄ ‪ .‬أن أﻧ ﻮاع‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻟﻬﺬا اﻟﻐﺮض ﻳﺼﺮح ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ﺑﺎﻟﺪاﻟﻪ ) ‪.( Boolean‬‬
‫‪ 1.6.1‬اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﻪ ‪LOGIC OPERATORS‬‬
‫هﻨﺎك ﺛﻼث أﻧﻮاع ﻣ ﻦ اﻟﻌﻤﻠﻴ ﺎت اﻟﻤﻨﻄﻘﻴ ﻪ وه ﻲ ) ‪ ( AND , OR , NOT‬آ ﻞ ﻣﻨﻬ ﺎ ﻳﺘﻌﺎﻣ ﻞ‬
‫ﻣ ﻊ اﻟﺘﻌ ﺎﺑﻴﺮ اﻟ ﺸﺮﻃﻴﻪ ) أي اﻟﺘ ﻲ ﺗﺤﺘ ﻮي ﺷ ﺮط (‪ .‬آ ﻞ واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻟﺘﻌ ﺎﺑﻴﺮ ﻟ ﻪ ﺗ ﺄﺛﻴﺮ ﻣﺨﺘﻠ ﻒ ﻋﻠ ﻰ‬
‫اﻟﺘﻌ ﺎﺑﻴﺮ اﻟ ﺸﺮﻃﻴﻪ ‪ .‬أدﻧ ﺎﻩ أﻣﺜﻠ ﻪ ﺗﺒ ﻴﻦ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام ه ﺬﻩ اﻟﺘﻌ ﺎﺑﻴﺮ واﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﺗ ﺴﺘﺨﺪم ﺑ ﻴﻦ‬
‫ﺗﻌﺒﻴﺮﻳﻦ أو أآﺜﺮ ﻣﻦ اﻟﺘﻌﺎﺑﻴﺮ اﻟﺸﺮﻃﻴﻪ‪.‬‬
‫• ‪AND‬‬

‫‪If (Str1 = 'a') AND (Str2 = 'b') then‬‬
‫; ) '‪Writeln ( 'Yes, you got it right.‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

10

( And )
Expression 1

( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) و‬: ( 1.1 ) ‫ﺟﺪول‬
Expression 2

AND (result)

true

true

true

false

true

false

true

false

false

false

false

false

OR •

If (Str1 = 'a') OR (Str2 = 'b') then
writeln('Yes, you got it right.');

( Or ) ( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) أو‬: ( 1.2 ) ‫ﺟﺪول‬
Expression 1

Expression 2

OR (result)

true

true

true

false

true

true

true

false

true

false

false

false

NOT •
( Not ) ( ‫ ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) ﻻ‬: ( 1.3 ) ‫ﺟﺪول‬
Input

Output

true

false

false

true

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪11‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﻌﺎﻣﻞ ) ‪ ( NOT‬ﻳﺨﺘﻠﻒ ﻋ ﻦ اﻟﻌ ﺎﻣﻠﻴﻦ اﻟ ﺴﺎﺑﻘﻴﻦ ﺣﻴ ﺚ أﻧ ﻪ ﻳﺘﻘﺒ ﻞ ﻣ ﺪﺧﻞ واﺣ ﺪ وداﺋﻤ ﺎ ﻳﻌﻜ ﺲ‬
‫ﺣﺎﻟﺔ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﻳ ﺪﺧﻞ ﻋﻠﻴﻬ ﺎ ﻓ ﺄذا آﺎﻧ ﺖ ﺻ ﺤﻴﺤﻪ ﻓﻴﺠﻌﻠﻬ ﺎ ﺧﺎﻃﺌ ﻪ وأن آﺎﻧ ﺖ ﺧﺎﻃﺌ ﻪ ﻳﺠﻌﻠﻬ ﺎ‬
‫ﺻﺤﻴﺤﻪ‪.‬‬

‫ﺟﺪول ) ‪ : ( 1.4‬أهﻢ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات اﻟﻤﺴﺘﺨﺪﻣﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫اﻟﻨﻮع‬

‫اﻟﻤﺪى‬

‫اﻟﺤﺠﻢ‬
‫)ﺑﺎﻳﺖ (‬

‫اﻟﻤﻼﺣﻈﺎت‬

‫‪Byte‬‬

‫‪0 .. 255‬‬

‫‪1‬‬

‫‪Word‬‬

‫‪0 .. 65535‬‬

‫‪2‬‬

‫‪Shortint‬‬

‫‪-128 .. 127‬‬

‫‪1‬‬

‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬
‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬
‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬

‫‪4‬‬

‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬

‫‪Real‬‬

‫‪2.9x10-39 .. 1.7x1038‬‬

‫‪6‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬

‫‪Sigle‬‬

‫‪1.5x10-45 .. 3.4x1038‬‬

‫‪4‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬

‫‪Double‬‬

‫‪5.0x10-324 .. 1.7x10308‬‬

‫‪8‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬

‫‪Extended‬‬

‫‪3.4x10-4932 .. 1.1x104932‬‬

‫‪10‬‬

‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬

‫‪Char‬‬

‫ﺣﺮف واﺣﺪ‬

‫‪1‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬

‫‪String‬‬

‫‪ 255‬ﺣﺮف‬

‫‪255‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬

‫‪True / False‬‬

‫‪1‬‬

‫ﻏﻴﺮ رﻗﻤﻴﻪ‬

‫‪Longint‬‬

‫‪Boolean‬‬

‫‪-2146473648 … 2146473647‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫أن أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ﺧﺎرج اﻟﻤﺪى اﻟﻤﺤﺪد ﻟﻪ ﺳﻴﺆدي اﻟﻰ ﺣﺪوث ﺧﻄﺄ ‪ ,‬هﺬا‬
‫اﻟﺨﻄﺄ أﻣﺎ أن ﻳﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ أو ﻳﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﻪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪12‬‬

‫ﺟﺪول ) ‪ : ( 1.5‬ﺑﻌﺾ اﻟﺪوال اﻟﻤﻬﻤﻪ اﻟﻤﺴﺘﺨﺪﻣﻪ ﻣﻊ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫اﻟﺪاﻟﻪ‬

‫اﻟﻮﻇﻴﻔﻪ‬

‫ﻣﺜﺎل‬

‫‪abs‬‬

‫ﻷﻳﺠ ﺎد اﻟﻘﻴﻤ ﻪ اﻟﻤﻄﻠﻘ ﻪ ﻟﻌ ﺪد‬
‫ﺳﺎﻟﺐ ) ﻳﺤﻮل اﻟﻌﺪد اﻟ ﺴﺎﻟﺐ‬
‫اﻟﻰ ﻣﻮﺟﺐ (‬
‫أﻳﺠﺎد ﻣﺮﺑﻊ ﻋﺪد‬
‫أﻳﺠﺎد اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ ﻟﻌ ﺪد‬
‫ﻣﻮﺟﺐ‬
‫اﻳﺠﺎد ﺟﻴﺐ زاوﻳﻪ‬
‫أﻳﺠﺎد ﺟﻴﺐ ﺗﻤﺎم زاوﻳﻪ‬
‫ﺗﺤﻮل اﻷﻋﺪاد اﻟﻜ ﺴﺮﻳﻪ اﻟ ﻰ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ وذﻟﻚ ﺑﺤﺬف‬
‫اﻟﻜﺴﺮ‬
‫ﻳﻘ ﺮب اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬
‫أﻗﺮب ﻋﺪد ﺻﺤﻴﺢ‬

‫‪Abs ( -5 ) = 5‬‬

‫‪sqr‬‬
‫‪sqrt‬‬
‫‪sin‬‬
‫‪cos‬‬
‫‪trunk‬‬

‫‪round‬‬

‫‪Int‬‬
‫‪inc‬‬

‫‪dec‬‬

‫‪pred‬‬
‫‪succ‬‬
‫‪odd‬‬

‫‪ln‬‬

‫ﻳﺤ ﻮل اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬
‫ﻋﺪد ﺻﺤﻴﺢ‬
‫ﻳﻌﻤ ﻞ ﻋﻠ ﻰ زﻳ ﺎدة اﻟﻤﺘﻐﻴ ﺮ‬
‫ﺑﻘ ﺪار واﺣ ﺪ أو ﺣ ﺴﺐ ﻣ ﺎ‬
‫ﻣﺤﺪد‬
‫ﺗﻘﻠﻴﺺ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻤﻘ ﺪار‬
‫واﺣﺪ أو ﺣﺴﺐ ﻣﺎ ﻣﺤﺪد‬
‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟ ﺴﺎﺑﻘﻪ‬
‫ﻟﻠﻤﺘﻐﻴﺮ‬
‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟﻼﺣﻘ ﻪ‬
‫ﻟﻠﻤﺘﻐﻴﺮ‬
‫ﻳﻔﺤﺺ اﻟﻤﺘﻐﻴﺮ ﻓﻴﻤﺎ أذا آﺎن‬
‫ﻋ ﺪد ﻓ ﺮدي أم ﻻ وﻧﺘﻴﺠﺘ ﻪ‬
‫ﺗﻜﻮن ﺻﺢ أو ﺧﻄﺄ‬
‫ﺗﻌﻄ ﻲ ﻗﻴﻤ ﺔ اﻟﻠﻮﻏ ﺎرﻳﺘﻢ‬
‫اﻟﻄﺒﻴﻌ ﻲ ) أي ﻟﻸﺳ ﺎس‬
‫)‪((e‬‬

‫‪Sqr ( 5 ) = 25‬‬
‫‪Sqrt ( 25 ) = 5.0000000000E+00‬‬
‫‪Sin ( 30 * Pi / 180 ) = 5.0000000000E-01‬‬
‫‪Cos ( 60 * Pi / 180 ) = 5.0000000000E-01‬‬
‫‪Trunk ( 5. 2431 ) = 5‬‬
‫‪Trunk ( -5.6 ) = -5‬‬
‫‪Round ( 5.2431 ) = 5‬‬
‫‪Round ( 5.765 ) = 6‬‬
‫‪Round ( -5.8 ) = -6‬‬
‫‪Int ( 2.31 ) = 2.0000000000E+00‬‬
‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ ‪x = 10‬‬
‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( inc ( x‬ﺳﺘﺆدي اﻟﻰ ‪x = 11‬‬
‫أﻣﺎ )) ‪ ( inc ( x, 4‬ﺳﺘﺆدي اﻟﻰ ‪x = 14‬‬
‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ ‪x = 15‬‬
‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( dec ( x‬ﺳﺘﺆدي اﻟﻰ ‪x = 14‬‬
‫أﻣﺎ ) ) ‪ ( dec ( x , 5‬ﺳﺘﺆدي اﻟﻰ ‪x = 10‬‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 10‬ﻓﺄن ) ‪( pred ( x ) = 9‬‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 10‬ﻓﺄن ) ‪(succ ( x ) = 11‬‬
‫أذا آﺎﻧﺖ ) ‪ ( x = 9‬ﻓﺄن‬
‫) ) ‪ ( odd ( x‬ﺳﺘﻜﻮن ) ‪( true‬‬
‫‪Ln ( 8 ) = 2.0794415417E+0‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪13‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫هﻨﺎك ﻧﻮﻋﺎن ﻣﻦ اﻟﺪوال ‪ ..‬اﻟﺪوال اﻟﻘﻴﺎﺳﻴﻪ وهﻲ اﻟﺪوال اﻟﻤﻌﺮﻓﻪ ﺿﻤﻦ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
‫ﻣﺜﻞ اﻟﺪوال ﻓﻲ اﻟﺠﺪول ) ‪ , ( 1.5‬ودوال ﺗﻌﺮف ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم واﻟﺘﻲ ﺳﻨﺸﺮﺣﻬﺎ‬
‫ﻓﻲ اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﺗﻘﺎس اﻟﺰواﻳﺎ ﻓﻲ اﻟﺪوال اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻟﺰواﻳﺎ ) ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ( ﺑﻤﺎ ﻳﺴﻤﻰ‬
‫ﺑﺎﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ) ‪ ( Radians‬وﻟﻴﺲ ﺑﺎﻟﺪرﺟﺎت آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ اﻟﺮﻳﺎﺿﻴﺎت ‪,‬‬
‫وﻟﺘﺤﻮﻳﻞ أي زاوﻳﻪ ) ‪ ( angle‬ﻣﻦ اﻟﻘﻴﺎس ﺑﺎﻟﺪرﺟﺎت اﻟﻰ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ﻧﺘﺒﻊ‬
‫اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫‪Angle ( in radians ) : = angle ( in degree ) * Pi / 180‬‬
‫ﺣﻴﺚ أن ) ‪ ( Pi‬هﻲ اﻟﻨﺴﺒﻪ اﻟﺜﺎﺑﺘﻪ وهﻲ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺨﺰوﻧﻪ ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫وﺳﻴﻌﻮض ﻋﻨﻬﺎ أﻟﻴﺎ ﺑﻘﻴﻤﺘﻬﺎ اﻟﺒﺎﻟﻐﻪ ) ‪. ( 3.1415926535897932385‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫‪Ord ( true ) = 1‬‬
‫‪Ord ( false ) = 0‬‬
‫‪Pred ( true ) = false‬‬
‫‪Succ ( false ) = true‬‬

‫‪1.7‬‬

‫ﺗﻮﻟﻴﺪ اﻷرﻗﺎم اﻟﻌﺸﻮاﺋﻲ ‪RANDOM NUMBERS GENERATION‬‬

‫ﺗﺤﺘﺎج ﺑﻌﺾ اﻟﺘﻄﺒﻴﻘﺎت اﻟﻰ أﺳﺘﺨﺪام أرﻗﺎم ﻋ ﺸﻮاﺋﻴﻪ وه ﺬا ﻣﻤﻜ ﻦ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل وذﻟ ﻚ ﻣ ﻦ‬
‫ﺧﻼل أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Random‬اﻟﺬي ﻳﻌﻤﻞ ﻋﻠﻰ ﺗﻮﻟﻴﺪ رﻗﻢ ﺑ ﺸﻜﻞ ﻋ ﺸﻮاﺋﻲ ‪ ,‬وه ﻮ ﻳﻌﻤ ﻞ وﻓﻘ ﺎ ﻟﻤ ﺎ‬
‫ﻳﻠﻲ ‪:‬‬
‫• ﻳﺴﺘﺨﺪم ﻣ ﻊ اﻷﻣ ﺮ ) ‪ ( Randomize‬ﺣﻴ ﺚ ﻳﺠ ﺐ أن ﻳ ﺴﺒﻖ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( Random‬آﺘﺎﺑ ﺔ‬
‫اﻷﻣﺮ ) ‪ , ( Randomize‬وﺑﺬﻟﻚ ﻓﺄن اﻷﻣﺮ ) ‪ ( Random‬ﺳ ﻴﻮﻟﺪ أرﻗ ﺎم ﻋ ﺸﻮاﺋﻴﻪ ﺗﺘ ﺮاوح ﻗﻴﻤﻬ ﺎ‬
‫ﺑﻴﻦ اﻟﺼﻔﺮ واﻟﻮاﺣﺪ ) ﻏﻴﺮ داﺧﻞ ( ) أي أرﻗﺎم آﺴﺮﻳﻪ ﻣﻮﺟﺒﻪ ﻗﻴﻤﺘﻬﺎ أﻗﻞ ﻣﻦ واﺣﺪ ( ﻣﺜﺎل ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪14‬‬

‫; ‪Randomize‬‬
‫; ‪X : = random‬‬
‫هﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﻜﻮن ﻗﻴﻤﺘﻪ ) ‪ ( 0 <= x < 1‬وﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﺗﻨﻔﻴﺬ هﺬا اﻷﻣﺮ ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻗﻴﻤﻪ‬
‫ﺟﺪﻳﺪﻩ ﺿﻤﻦ ﻧﻔﺲ اﻟﻤﺪى ‪.‬‬
‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻧﻴﻪ هﻲ ﺑﺄﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬أﻳﻀﺎ ﺛﻢ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن‬
‫ﻳﺤﺘﻮي اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ اﻟﻤﺪى اﻟﻤﻄﻠﻮب أﻳﺠﺎد اﻟﺮﻗﻢ اﻟﻌﺸﻮاﺋﻲ ﺿﻤﻨﻪ ) أي أﻧﻪ ﺳﻴﻮﻟﺪ‬
‫أﻋﺪاد ﺻﺤﻴﺤﻪ ﻣﻮﺟﺒﻪ ﻋﺸﻮاﺋﻴﺎ ﺗﺘﺮاوح ﻗﻴﻤﻬﺎ ﺑﻴﻦ اﻟﺼﻔﺮ واﻟﻌﺪد اﻟﻤﺤﺪد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ (‬
‫) ‪ Random‬واﻟﺬي ﻳﻤﺜﻞ اﻟﺤﺪ اﻷﻋﻠﻰ ( ‪ ,‬ﻣﺜﺎل ‪:‬‬
‫; ‪Randomize‬‬
‫; ) ‪X : = random ( 100‬‬
‫هﻨﺎ ﺗﻜ ﻮن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( 0 <= x < 100 ) ( x‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻳﻌ ﺎد ﺗﻨﻔﻴ ﺬ ه ﺬا اﻷﻣ ﺮ ﺳﻨﺤ ﺼﻞ‬
‫ﻋﻠﻰ ﻗﻴﻤﻪ ﺟﺪﻳﺪﻩ ‪ .‬أن اﻟﻤﺪى اﻟﻤﺤﺪد ﻳﻤﻜﻦ ﺗﻐﻴﺮﻩ ﺣﺴﺐ ﻃﺒﻴﻌﺔ اﻟﺘﻄﺒﻴﻖ اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻩ ‪.‬‬
‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻟﺜﻪ ﻷﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Random‬هﻲ ﺑﺪون أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬وﺑ ﺪﻻ‬
‫ﻣﻨﻪ ﻧﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻗﺒﻞ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن ﻳﺘﻢ أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴ ﺮ (‬
‫) ‪ , Randseed‬هﺬﻩ اﻟﻄﺮﻳﻘ ﻪ ﻣ ﻦ وﺟﻬ ﺔ ﻧﻈ ﺮي ه ﻲ اﻷﻓ ﻀﻞ ﻷن اﻟﻄ ﺮﻳﻘﺘﻴﻦ اﻟ ﺴﺎﺑﻘﺘﻴﻦ ﺳ ﺘﻮﻟﺪان‬
‫ﻧﻔﺲ ﻣﺠﻤﻮﻋﺔ اﻟﻘﻴﻢ ﻋﻨﺪ أﻳﻘ ﺎف اﻟﺒﺮﻧ ﺎﻣﺞ وأﻋ ﺎدة ﺗﻨﻔﻴ ﺬﻩ ﻣﻤ ﺎ ﻻ ﻳ ﺆدي اﻟ ﻰ ﻋ ﺸﻮاﺋﻴﻪ ﺣﻘﻴﻘﻴ ﻪ ‪ ,‬ﺑﻴﻨﻤ ﺎ‬
‫هﺬﻩ اﻟﻄﺮﻳﻘﻪ ﺳﺘﻮﻟﺪ ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ ﻣﺨﺘﻠﻔﻪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﻓﻴﻬﺎ أﻋ ﺎدة اﻟﺘﻨﻔﻴ ﺬ ﻋﻠ ﻰ أن ﻳ ﺘﻢ‬
‫أﺳﻨﺎد ﻗﻴﻢ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻋﻨﺪ آﻞ ﺗﻨﻔﻴﺬ ‪ ,‬ﻣﺜﺎل‬
‫; ‪Randseed : = 1200‬‬
‫; ‪X : = random‬‬
‫‪OR‬‬
‫; ‪Randseed : = 3425‬‬
‫; ) ‪X : = random ( 1000‬‬
‫ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( randseed‬أﺳﻨﺪ ﻟﻪ ﻗﻴﻤﻪ وهﻲ ) ‪ ( 1200‬ووﻓﻘﺎ ﻟﻬﺎ ﺳﻴﻮﻟﺪ أرﻗﺎم‬
‫ﻋﺸﻮاﺋﻴﻪ آﺴﺮﻳﻪ أﻗﻞ ﻣﻦ واﺣﺪ وﻟﻮ أﻋﺪﻧﺎ اﻟﺘﻨﻔﻴﺬ ﻣﻊ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( randseed‬ﻓﺄن رﻗﻢ‬
‫ﻋﺸﻮاﺋﻲ ﻣﺨﺘﻠﻒ ﺳﺘﻮﻟﺪ ) ﺣﺎول ﺗﻨﻔﻴﺬ اﻟﻄﺮﻳﻘﺘﻴﻦ وﻻﺣﻆ اﻟﻔﺮق ( ‪.‬‬
‫أﻣﺎ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ﻓﺄﻧﻪ ﺳﻴﻮﻟﺪ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ أآﺒﺮ ﻣﻦ اﻟﺼﻔﺮ وأﺻﻐﺮ ﻣﻦ ) ‪. ( 1000‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪15‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬
‫أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج ‪INPUT / OUTPUT INSTRUCTIONS‬‬
‫‪2.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬
‫ﺟﻤﻴ ﻊ اﻟﻠﻐ ﺎت اﻟﻄﺒﻴﻌﻴ ﻪ اﻟﺘ ﻲ ﻳﺘﻌﺎﻣ ﻞ ﺑﻬ ﺎ اﻷﻧ ﺴﺎن آﻮﺳ ﻴﻠﻪ ﻟﻠﺘﺨﺎﻃ ﺐ واﻟﺘﻮاﺻ ﻞ ﻟﻬ ﺎ ﻗﻮاﻋ ﺪ‬
‫وﺿﻮاﺑﻂ ﺗﺤﺪد أﻟﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ‪ ,‬وﻟﻤﺎ آﺎﻧﺖ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ ﺗﺼﻨﻒ ﻋﻠﻰ أﻧﻬ ﺎ ﻣ ﻦ اﻟﻠﻐ ﺎت اﻟﻌﻠﻴ ﺎ‬
‫) أي اﻟﻠﻐﺎت اﻟﻘﺮﻳﺒﻪ ﻣﻦ ﻟﻐﺎت اﻟﺒﺸﺮ ( ﻓﻜﺎن ﻻ ﺑ ﺪ وأن ﺗﻜ ﻮن ﻟﻬ ﺎ ﻗﻮاﻋ ﺪ ﺗﺤ ﺪد أﻟﻴ ﺔ أﺳ ﺘﺨﺪاﻣﻬﺎ‬
‫ﻟﺘﻜ ﻮن واﺿ ﺤﻪ ﻟﻠﻤﺘﻌﺎﻣ ﻞ ﻣﻌﻬ ﺎ وآ ﺬﻟﻚ ﻟﻠﻤﺘ ﺮﺟﻢ داﺧ ﻞ اﻟﺤﺎﺳ ﻮب ‪ .‬ﻋﻠﻴ ﻪ ﻓ ﺄن ه ﺬا اﻟﻔ ﺼﻞ‬
‫واﻟﻔ ﺼﻮل اﻻﺣﻘ ﻪ ﺳﺘﻮﺿ ﺢ ه ﺬﻩ اﻟﻘﻮاﻋ ﺪ وﺳ ﻨﺒﺪأ ﺑﻤﻌﺮﻓ ﺔ آﻴﻔﻴ ﺔ ﺗﻠﻘ ﻴﻢ اﻟﺤﺎﺳ ﻮب ﺑﺎﻟﻤﻌﻠﻮﻣ ﺎت‬
‫وﻃﺮق اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻨﺘﺎﺋﺞ ﺑﻌﺪ أﻧﺠﺎز ﻋﻤﻠﻴﺎت اﻟﺤﺴﺎب ﺧﻼل هﺬا اﻟﻔﺼﻞ ‪.‬‬

‫‪2.2‬‬

‫هﻴﻜﻠﻴﻪ اﻟﺒﺮﻧﺎﻣﺞ ‪PROGRAM CONSTRUCTION‬‬

‫ﻳﺘﻜ ﻮن اﻟﺒﺮﻧ ﺎﻣﺞ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻦ ) اﻟ ﺮأس واﻟﺠ ﺴﻢ ( ) ‪( head and block‬‬
‫واﻟﺮأس هﻮ اﻟﺴﻄﺮ اﻷول ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻳﺒ ﺪأ ﺑﻜﻠﻤ ﻪ ﺑﺮﻧ ﺎﻣﺞ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ وﻳﺘﺒ ﻊ ﺑﺄﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺛ ﻢ‬
‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ) ; ( وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫; ‪Program programname‬‬
‫ﻻﺣﻆ هﻨﺎ ﻳﺠﺐ ان ﻳﻜﻮن هﻨﺎك ﻓﺮاغ ﺑﻴﻦ آﻠﻤﺔ ﺑﺮﻧﺎﻣﺞ وأﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬أﻣ ﺎ أﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴ ﺘﻢ‬
‫أﺧﺘﻴﺎرﻩ ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ ‪ ,‬وأﺳﺘﺨﺪام اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃ ﻪ ﺗ ﺪل ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وه ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ آ ﻞ‬
‫اﻟﻌﺒﺎرات ﻓﻲ ﺑﺮاﻣﺞ ﺑﺎﺳﻜﺎل ﻟﻠﺪﻻﻟﻪ ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وﺑﺪاﻳ ﺔ ﻋﺒ ﺎرﻩ ﺟﺪﻳ ﺪﻩ ﻋ ﺪا ﺑﻌ ﺾ اﻟﺤ ﺎﻻت اﻟﺘ ﻲ‬
‫ﺳﻴﺘﻢ اﻻﺷﺎرﻩ ﻟﻬﺎ ﻓﻲ ﺣﻴﻨﻬﺎ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫ﻳﺠﺐ أن ﺗﻈﻬﺮ اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﻓﻲ ‪:‬‬
‫‪ .1‬ﺑﻌﺪ ﻋﺒﺎرة رأس اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬اﻷﺟﺮاء ‪ ,‬أو اﻟﺪاﻟﻪ ‪.‬‬
‫‪ .2‬ﺑﻌﺪ آﻞ ﻗﺎﺋﻤﺔ ﺗﻌﺮﻳﻔﺎت ﻣﻮﺟﻮدﻩ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ ,‬اﻟﻨﻮع ‪,‬‬
‫واﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫‪ .3‬ﺑﻴﻦ اﻟﻌﺒﺎرات اﻟﻜﺎﻣﻠﻪ ﻓﻲ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬي ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أهﻤﺎل اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﺑﻌﺪ اﻟﻌﺒﺎرات اﻟﺘﻲ ﺗﺴﺒﻖ اﻷﻣﺮ ) ‪. ( end‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪16‬‬

‫أﻣ ﺎ ﺟ ﺴﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴﺘﻜ ﻮن ﻣ ﻦ ﻗ ﺴﻤﻴﻦ اﻷول ه ﻮ ﻗ ﺴﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﺜﻮاﺑ ﺖ واﻟﻤﺘﻐﻴ ﺮات‬
‫وﻏﻴﺮهﺎ واﻟﺘﻲ ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ وهﻮ ﻳﺴﺘﺨﺪم ﺣﺴﺐ اﻟﺤﺎﺟﻪ اﻟﻴﻪ أي ﻣﻤﻜﻦ أن ﻧ ﺮى ﺑ ﺮاﻣﺞ ﻟ ﻴﺲ ﻓﻴﻬ ﺎ‬
‫هﺬا اﻟﻘﺴﻢ ﺑﺴﺒﺐ ﻋﺪم أﺣﺘﻴﺎج اﻟﺒﺮﻧﺎﻣﺞ ﻟﻸﻋﻼن ‪ .‬واﻟﻘﺴﻢ اﻟﺜﺎﻧﻲ ﻓﻬ ﻮ ﻳﻤﺜ ﻞ ) اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ(‬
‫) ‪ ( instructions or commands‬اﻟﺘﻲ ﺳﻴﻨﻔﺬهﺎ اﻟﺒﺮﻧﺎﻣﺞ وهﻮ ﻳﺒﺪأ ﺑﻜﻠﻤﺔ أﺑ ﺪأ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ‬
‫) ‪ ( begin‬ﺛ ﻢ اﻷﻳﻌ ﺎزات اﻟﻮاﺟ ﺐ ﺗﻨﻔﻴ ﺬهﺎ ‪ ,‬وﻳﻨﺘﻬ ﻲ ﺑﻜﻠﻤ ﻪ ﻧﻬﺎﻳ ﻪ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ ﻣﺘﺒﻮﻋ ﻪ ﺑﻨﻘﻄ ﻪ‬
‫)‪ ( end .‬وﻋﻠﻴﻪ ﻓﺴﻴﻜﻮن ﺷﻜﻞ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫; ‪Program programname‬‬
‫‪Declaration section (may or may not contain Type ,‬‬
‫) ‪Const , Var , Uses , Label‬‬
‫‪Begin‬‬
‫; ) ‪Statements ( instructions‬‬
‫‪End.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﻔﻀﻞ ﻋﻨﺪ ﺗﺴﻤﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ أن ﻳﻜﻮن اﻷﺳﻢ ﻳﺪل ﻋﻠﻰ ﻓﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ أو وﻇﻴﻔﺘﻪ ‪ ,‬وﻻ ﻳﺠﻮز‬
‫أن ﻳﻜﻮن اﻷﺳﻢ أﺣﺪى اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ ‪ ,‬أو ﻳﻜﻮن أﺳﻢ ﻟﻤﺘﻐﻴﺮ ﻣﺴﺘﺨﺪم ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪,‬‬
‫وﻻ ﻳﺠﻮز أن ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎﻓﺎت ) اﻟﻔﺮاﻏﺎت ( ﺑﻴﻦ أﺣﺮف اﻟﺒﺮﻧﺎﻣﺞ ‪ .‬ﻣﻤﻜﻦ اﺳﺘﺨﺪام‬
‫اﻟﺸﺎرﺣﻪ ) _ ( او اﻷرﻗﺎم ﻣﻊ أﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﻤﻜﻦ اﻷﺳﺘﻐﻨﺎء ﻋﻦ رأس اﻟﺒﺮﻧﺎﻣﺞ وﺳﻴﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻃﺒﻴﻌﻲ ‪.‬‬

‫‪2.3‬‬

‫اﻟﻤﺨﺮﺟﺎت واﻟﻤﺪﺧﻼت ‪INPUT / OUTPUT‬‬

‫ﻓ ﻲ آ ﻞ ﺑﺮﻧ ﺎﻣﺞ ﻳﺠ ﺐ أن ﺗﻜ ﻮن هﻨ ﺎك ﻣﺨﺮﺟ ﺎت ﺗﺒ ﻴﻦ اﻟﻨﺘ ﺎﺋﺞ اﻟﺘ ﻲ ﺗ ﻢ اﻟﺤ ﺼﻮل ﻋﻠﻴﻬ ﺎ ﻣ ﻦ‬
‫اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ه ﺬﻩ اﻟﻨﺘ ﺎﺋﺞ ﺳ ﻴﺘﻢ ﻋﺮﺿ ﻬﺎ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺤﺎﺳ ﻮب ﺑﺄﺳ ﺘﺨﺪام اﻷﻣ ﺮ‬
‫) ) (‪ ( writeln( ) OR writeln‬أن اﻷﻣﺮ ) ) ( ‪ ( write‬ﻳﻌﻨﻲ أآﺘﺐ ﻣﺎﻣﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ‬
‫) ) ( ‪ ( writeln‬ﻓﻬ ﻲ ﺗﻌﻨ ﻲ أآﺘ ﺐ ﻋﻠ ﻰ ﺳ ﻄﺮ‬
‫ﻋﻠﻰ هﺬا اﻟﺴﻄﺮ اﻟﺬي ﺗﺆﺷﺮ ﻋﻠﻴﻪ ‪ .‬أﻣﺎ اﻷﻣ ﺮ‬
‫ﺟﺪﻳﺪ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ‪ ,‬وهﺬﻩ ﻣﻔﻴﺪﻩ ﻓﻲ ﻋﻤﻠﻴﺔ ﺗﻨﻈﻴﻢ اﻟﻤﺨﺮﺟﺎت‪.‬‬
‫ﻓﻲ ﺟﻤﻴﻊ اﻷﺣﻮال ﺳﻮاء أﺳﺘﺨﺪﻣﻨﺎ ) ) ( ‪ ( write( ) OR writeln‬ﻓﺄﻧﻨﺎ ﻧﺤﺘﺎج أﻟ ﻰ وﺿ ﻊ‬
‫ﻣﺎﻣﻄﻠﻮب أﻇﻬﺎرﻩ ﻋﻠﻰ اﻟﺸﺎﺷﻪ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ‪ .‬أن ﻣﺎ ﻳﻮﺿﻊ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺳﻴﺄﺧﺬ ﺣﺎﻟﻪ ﻣﻦ أﺛﻨﺘﻴﻦ ‪:‬‬
‫‪ 2.3.1‬ان ﻳﻜ ﻮن ﻣ ﺎ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﻣﺤ ﺼﻮر ﺑﻌﻼﻣ ﺎت أﻗﺘﺒ ﺎس ﻣﻔ ﺮدﻩ‬
‫) ‪ ( ' ' ) ( single quotation mark‬وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺎن ﻣﺎ ﻣﻮﺟﻮد ﺑﻴﻦ ﻋﻼﻣﺘ ﻲ اﻷﻗﺘﺒ ﺎس‬
‫ﺳﻴﺘﻢ ﻃﺒﺎﻋﺘﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ دون أدﻧﻰ ﺗﻐﻴﻴﺮ وآﻤﺎ هﻮ‪ .‬ﻣﺜﺎل‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪17‬‬

‫;‪Program Ch2_Program1‬‬
‫‪Begin‬‬
‫;)'!!‪Write('Hello World. Prepare to learn PASCAL‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ان اﻟﺒﺮﻧﺎﻣﺞ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﻻ ﻳﺘﺄﺛﺮ أو ﻳﺘﺤﺴﺲ ﻟﺸﻜﻞ اﻟﺤﺮوف ﺳﻮاء آﺎﻧﺖ‬
‫ﻣﻜﺘﻮﺑﻪ ﺑﺎﻷﺣﺮف اﻟﻜﺒﻴﺮﻩ أو اﻷﺣﺮف اﻟﺼﻐﻴﺮﻩ ‪.‬‬

‫ﻻﺣﻆ ﻣﺎﻳﻠﻲ ‪// :‬‬
‫أوﻻ ‪ /‬ﻋﺪم أﺳﺘﺨﺪام أو وﺟﻮد ﻗﺴﻢ اﻷﻋﻼن وذﻟﻚ ﻟﻌﺪم وﺟﻮد ﻣﺎ ﻧﻌﻠﻦ ﻋﻨﻪ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ /‬أن ﻣﺨﺮﺟﺎت ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ه ﻲ اﻟﻌﺒ ﺎرﻩ اﻟﻤﻮﺟ ﻮدﻩ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﺑﻌ ﺪ آﻠﻤ ﻪ ) ‪( write‬‬
‫وﺳﺘﻈﻬﺮ ﻋﻠﻰ اﻟﺸﺎﺷﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫!!‪Hello World. Prepare to learn PASCAL‬‬

‫ﺛﺎﻟﺜﺎ ‪ /‬ﻋﻨﺪ ﺗﻨﻔﻴﺬ هﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﺳ ﻮف ﻻ ﻳﻤﻜ ﻦ ﻣﻼﺣﻈ ﺔ اﻟﻤﺨﺮﺟ ﺎت واﻟ ﺴﺒﺐ ه ﻮ أن اﻟﺤﺎﺳ ﺐ‬
‫ﺳﺮﻳﻊ ﺟﺪا ﺑﺤﻴﺚ ﻳﻌﺮض وﻳﺨﻔﻲ ﺷﺎﺷﻪ اﻟﺘﻨﻔﻴﺬ دون أن ﻧﻼﺣﻆ ذﻟﻚ ‪ ,‬وﻟﻐﺮض رؤﻳﺔ اﻟﻤﺨﺮﺟ ﺎت ﻓ ﻴﻤﻜﻦ‬
‫ﺑﻌ ﺪ ان ﻳ ﺘﻢ اﻟﺘﻨﻔﻴ ﺬ ﺿ ﻐﻂ اﻟ ﺰرﻳﻦ )‪ (Alt+ F5‬ﻣﻌ ﺎ وﻋﻨ ﺪهﺎ ﺳ ﺘﻈﻬﺮ ﺷﺎﺷ ﻪ اﻟﺘﻨﻔﻴ ﺬ ) اﻟ ﺴﻮداء ( ‪..‬‬
‫وﻳﻤﻜﻦ اﻟﺨﺮوج ﻣﻦ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ ﺑﻀﻐﻂ اﻟﺰر ) ‪. ( Enter‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪18‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻣﻤﻜﻦ أﻇﻬﺎر اﻟﻨﺘﺎﺋﺞ ﺑﻌﺪ أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺑﻄﺮﻳﻘﻪ ﺗﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻨﻈﻴﻢ اﻟﻤﺨﺮﺟﺎت وذﻟﻚ ﻣﻦ ﺧﻼل‬
‫ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ ) آﻞ ﺣﺮف أو رﻗﻢ ﻳﻄﺒﻊ ﻋﻠﻰ ﻣﻮﻗﻊ واﺣﺪ ( اﻟﺘﻲ ﺳﺘﻄﺒﻊ ﻋﻠﻴﻬﺎ اﻟﻨﺘﺎﺋﺞ‬
‫ﺣﻴﺚ ﺳﺘﻄﺒﻊ اﻟﻘﻴﻤﻪ اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺘﻬﺎ ﻣﻦ اﻟﻴﻤﻴﻦ اﻟﻰ اﻟﻴﺴﺎر ‪ ,‬ﻓﺄذا آﺎن ﻋﺪد اﻟﻤﻮاﻗﻊ أآﺒﺮ‬
‫ﻣﻦ ﻋﺪد اﻻرﻗﺎم ﻓﻲ اﻟﻌﺪد ﻓﺴﻴﺘﺮك ﻓﺮاغ ﻣﻦ اﻟﻴﺴﺎر ‪ ,‬واﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ هﻲ ‪:‬‬
‫; )‪Write ( data : fieldwidth‬‬
‫ﻻﺣﻆ أن اﻟﻔﺎﺻﻞ ﺑﻴﻦ اﻟﺒﻴﺎﻧﺎت واﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ ﻋﺮض اﻟﺤﻘﻞ هﻮ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن‪.‬‬
‫ﻣﺜﺎل‬
‫; ‪I : = 2345‬‬
‫; ) ‪Writeln ( I‬‬
‫; ) ‪Writeln ( I : 7‬‬
‫ﺳﺘﻜﻮن ﻧﺘﻴﺠﻪ هﺬﻳﻦ اﻷﻣﺮﻳﻦ آﻤﺎ ﻳﻠﻲ ‪ ,‬ﻻﺣﻆ اﻟﻔﺮق‬
‫‪2345‬‬
‫‪***2345‬‬
‫هﻨﺎ اﻟﻌﻼﻣﻪ ) * ( ﺗﻤﺜﻞ ﻓﺮاغ ﻟﻠﺘﻮﺿﻴﺢ ﻓﻘﻂ ‪.‬‬
‫أﺿﺎﻓﻪ اﻟﻰ أﻣﻜﺎﻧﻴﺔ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺨﺼﺼﻪ ﻟﻠﺮﻗﻢ ﻓﻴﻤﻜﻦ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﺮاﺗﺐ ﺑﻌﺪ‬
‫اﻟﻔﺎرزﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺮﻗﻢ اﻟﻜﺴﺮي وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫; ) ‪Write ( data : fieldwidth : precision‬‬
‫ﺣﻴﺚ أن ) ‪ ( precision‬ﺗﻤﺜﻞ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺤﺪدﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺠﺰء اﻟﻜﺴﺮي ‪ .‬ﻣﺜﺎل‬
‫; ) ‪Writeln ( I : 9 : 3‬‬
‫ﻳﺠﺐ أن ﺗﻜﻮن ) ‪ ( I‬ﻋﺪد ﺣﻘﻴﻘﻲ ‪.‬‬
‫ﻓﻲ ﺟﻤﻴﻊ اﻷﻣﺜﻠﻪ أﻋﻼﻩ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( I‬ﻣﻌﺮف آﻌﺪد ﺻﺤﻴﺢ ‪ ,‬أﻣﺎ أذا ﻋﺮف آﻌﺪد ﺣﻘﻴﻘﻲ‬
‫ﻓﺄن اﻟﻨﺘﺎﺋﺞ ﺳﺘﺨﺘﻠﻒ وﺗﻜﻮن ﻟﻠﻤﺜﺎل اﻷول آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪2.3450000000E+03‬‬
‫‪2.3E+03‬‬
‫أﻣﺎ ﺑﺎﻟﻨﺴﺒﻪ ﻟﻠﻤﺜﺎل اﻷﺧﻴﺮ ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﻪ‬
‫‪2345.000‬‬
‫وأﺧﻴﺮا ﻣﻤﻜﻦ أن ﻳﻜﻮن ) ‪ ( I‬ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺄن ﺣﻘﻞ ﻋﺪد اﻟﻤﺮاﺗﺐ‬
‫ﺑﻌﺪ اﻟﻔﺎرزﻩ ﺳﻮف ﻻ ﻳﻜﻮن ﻟﻪ ﺣﺎﺟﻪ ‪.‬‬

‫‪ 2.3.2‬أﻣﺎ أذا آﺎن ﻣﺎ ﻣﻮﺟﻮد ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﺑﻌ ﺪ آﻠﻤ ﺔ ) ‪ ( write OR writeln‬ﻟ ﻴﺲ ﻣﺤ ﺼﻮر ﺑ ﻴﻦ‬
‫ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻓﻌﻨﺪ ذﻟﻚ ﺳﻴﻌﺎﻣﻞ ﻣﺎ ﻣﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﻋﻠ ﻰ أﻧ ﻪ ﻣﻌ ﺮف واﻟﻤﻌﺮﻓ ﺎت ﻳﺠ ﺐ‬
‫أن ﺗﻜﻮن ﻟﻬﺎ ﻗﻴﻤﻪ ﻟﺬا ﻓﺎن اﻟﺤﺎﺳﻮب ﺳﻴﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﻌﺮف ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ ‪.‬‬
‫هﻨﺎ ﻋﻠﻴﻨﺎ أن ﻧﻼﺣﻆ أن أﺳﺘﺨﺪام أي ﻣﻌﺮف داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﺎج اﻟﻰ ﺷﺮﻃﻴﻦ ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪19‬‬

‫اﻷول ‪ /‬أن ﻳﺘﻢ اﻷﻋﻼن ﻋ ﻦ اﻟﻤﻌ ﺮف ﻓ ﻲ ﻗ ﺴﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﻌﺮﻓ ﺎت ﺁﻟ ﺬي ﺳ ﺒﻖ أن ﻧﻮهﻨ ﺎ‬
‫ﻋﻨﻪ ﻓﺄذا آﺎن ﺛﺎﺑﺖ ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑ ﺖ ) ‪ ( const‬أﻣ ﺎ أذا آ ﺎن ﻣﺘﻐﻴ ﺮ ﻓ ﻴﻌﻠﻦ ﻋﻨ ﻪ‬
‫ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ) ‪ ( var‬وﻳﺤﺪد ﻧﻮﻋﻪ ‪ .‬وﻟﻸﻋﻼن ﻋﻦ ﻣﺘﻐﻴﺮ ﻓﻲ ﻗ ﺴﻢ اﻟﻤﺘﻐﻴ ﺮات ﻧﺘﺒ ﻊ‬
‫ﻣﺎﻳﻠﻲ‪:‬‬
‫ﺑﺪءا ﻧﻜﺘﺐ آﻠﻤﺔ‬

‫‪var‬‬

‫اﻷن ﻧﻜﺘﺐ أﺳﻢ اﻟﻤﺘﻐﻴﺮ وﻳﺘﺒﻊ ﺑﺎﻟﻨﻘﻄﺘﻴﻦ اﻟﻤﺘﻌﺎﻣﺪﺗﻴﻦ ) ‪ ( : ) ( colon‬ﺛﻢ ﻧﻮع اﻟﻤﺘﻐﻴ ﺮ وﺗﻨﺘﻬ ﻲ‬
‫ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ‬
‫; ‪x : integer‬‬
‫ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ‪ ( integer‬أي أن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ داﺋﻤ ﺎ‬
‫ﺳﺘﻜﻮن ﻋﺪد ﺻﺤﻴﺢ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ /‬أن ﺗﻜﻮن ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ أو اﻟﺜﺎﺑﺖ ﻗﻴﻤ ﻪ ﻋﻨ ﺪ أول أﺳ ﺘﺨﺪام ﻟ ﻪ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻤ ﺜﻼ أﻧﻨ ﺎ‬
‫ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﻟﻜﻦ آﻢ هﻲ ﻗﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻋ ﺪد ﺻ ﺤﻴﺢ ﻟﻜ ﻦ آ ﻢ !! ﻓﻌﻨ ﺪﻣﺎ ﻧﻌﻄ ﻲ اﻷﻣ ﺮ‬
‫) )‪ ( write (x‬ﻓﻜﻢ ﻳﺠﺐ ﻋﻠﻰ اﻟﻤﺘﺮﺟﻢ أن ﻳﻄﺒﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ !! ﻟﺬا ﻳﺠ ﺐ أن ﻧﺤ ﺪد ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫أو اﻟﺜﺎﺑﺖ ﻗﺒﻞ أول أﺳﺘﺨﺪام ‪.‬‬
‫هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺗﺤﺪد ﻟﻠﻤﺘﻐﻴﺮ ﺗﺄﺗﻲ ﻣﻦ أﺣﺪى ﻋﻤﻠﻴﺘﻴﻦ ﻓﺄﻣﺎ أن ﺗﺄﺗﻲ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ أو ﺗ ﺄﺗﻲ‬
‫ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ‪ ...‬ﻟﻨﻨﺎﻗﺶ اﻟﺤﺎﻟﺘﻴﻦ ‪:‬‬
‫• ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌ ﺎدﻻت أو اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺮﻳﺎﺿ ﻴﻪ أي ﺑﺄﺳ ﺘﺨﺪام اﻟﻤ ﺴﺎواة‬
‫) ‪ , ( assignment‬ﻓﻤﺜﻼ ﻧﻘﻮل‬
‫;‪x:=5‬‬
‫هﻨﺎ أﺳﺘﺨﺪﻣﻨﺎ اﻟﻤﺴﺎواة واﻟﺘﻲ ﻳﺮﻣﺰ ﻟﻬﺎ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ) = ‪ ( :‬وﺑﺬﻟﻚ ﻓﺎن‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺳﺘﻜﻮن ﻣﺴﺎوﻳﻪ اﻟﻰ اﻟﻌﺪد اﻟﺼﺤﻴﺢ ) ‪ , ( 5‬أو ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻤﻌﺎدﻟﻪ ﻋﻠﻰ ﺷﻜﻞ‬
‫; ‪x : = 3 * 2 +5‬‬
‫هﻨﺎ ﻗﻴﻤﺔ ) ‪ ( x‬ﺗﺴﺎوي ) ‪ , ( 11‬وآﺬﻟﻚ ﻣﻤﻜﻦ أن ﺗﺤﺪد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ﺑﺎﻟﻤﺴﺎواة وﻟﻜﻦ ﻓﻲ ﺣﻘ ﻞ‬
‫اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪20‬‬

‫ﻣﻼﺣﻈﻪ ‪// :‬‬
‫داﺋﻤﺎ ﻋﻨﺪ وﺟﻮد ﻋﻼﻣﺔ اﻟﻤﺴﺎواة ) = ‪ ( :‬ﻓﺎن اﻟﻀﻮاﺑﻂ اﻟﺘﺎﻟﻴﻪ ﺳﺘﻄﺒﻖ ‪:‬‬
‫• ﻳﺠ ﺐ أن ﻳﻜ ﻮن هﻨ ﺎك ﻃ ﺮﻓﻴﻦ ﺗﻔ ﺼﻞ ﺑﻴﻨﻬﻤ ﺎ ﻋﻼﻣ ﺔ اﻟﻤ ﺴﺎواة ‪ ,‬وﺑ ﺬﻟﻚ ﻣﻤﻜ ﻦ أن‬
‫ﻧﻄﻠﻖ ﻋﻠﻴﻬﺎ ﺗﺴﻤﻴﺔ اﻟﻤﻌﺎدﻟﻪ ‪.‬‬
‫• اﻟﻄﺮف اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ أي اﻟﺬي ﻳﻘﻊ ﻋﻠﻰ اﻟﺠﺎﻧﺐ اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﺴﺎواة ﻳﻜ ﻮن‬
‫ﻣﺘﻐﻴ ﺮ وﻣﺘﻐﻴ ﺮ واﺣ ﺪ ﻓﻘ ﻂ داﺋﻤ ﺎ وﻻ ﻳﺠ ﻮز أن ﻳﻜ ﻮن ﻗﻴﻤ ﻪ ﺛﺎﺑﺘ ﻪ ) ﻣ ﺜﻼ ‪ 6‬أو‬
‫‪ 456‬أو ‪.. 34.2‬اﻟ ﺦ ( وآ ﺬﻟﻚ ﻻ ﻳﺠ ﻮز أن ﻳﻜ ﻮن رﻣ ﺰ ﻣﻌ ﺮف ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن‬
‫ﻋﻦ اﻟﺜﻮاﺑﺖ ‪ .‬آﺬﻟﻚ ﻻ ﻳﺠﻮز أن ﻳﺤﺘﻮي ﻋﻠﻰ ﻋﻼﻗﺎت رﻳﺎﺿﻴﻪ‬
‫) ﻣﺜﻞ ‪. ( x + 6‬‬
‫• أﻣﺎ اﻟﻄﺮف اﻷﻳﻤﻦ ﻓﻴﻤﻜﻦ أن ﻳﻜﻮن ﻗﻴﻤﻪ ﻋﺪدﻳﻪ واﺣﺪﻩ أو ﻋﻼﻗ ﻪ رﻳﺎﺿ ﻴﻪ ﺗﺤﺘ ﻮي‬
‫ﻋﻠﻰ ﻗﻴﻢ ﻋﺪدﻳﻪ أو ﻋﻼﻗﻪ رﻳﺎﺿ ﻴﻪ ﺗﺤﺘ ﻮي ﻣﺘﻐﻴ ﺮ واﺣ ﺪ أو ﻣﺘﻐﻴ ﺮات أو ﻣﺘﻐﻴ ﺮات‬
‫وﻗﻴﻢ ﻋﺪدﻳﻪ ‪ .‬ﻣﺜﻼ‬
‫; ‪X : = 89‬‬
‫;‪X : = 34 – 45 +3‬‬
‫;‪X:=y‬‬
‫; ‪X : = 3 * y +90‬‬
‫• ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺄن اﻟﻤﺘﺮﺟﻢ ﺳﻴﺒﺪأ ﺑﺎﻟﻄﺮف اﻷﻳﻤﻦ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ داﺋﻤﺎ وﻳﺘﻢ‬
‫ﻓﺤﺺ هﺬا اﻟﻄﺮف ﻓﺄذا آﺎﻧﺖ ﻓﻴﻪ ﻣﺘﻐﻴﺮات ﻓﺴﻴﺒﺤﺚ اﻟﻤﺘﺮﺟﻢ ﻓﻲ اﻟﺨﻄﻮات‬
‫اﻟﺴﺎﺑﻘﻪ ﻟﻠﺘﺄآﺪ ﻣﻦ أن اﻟﻤﺘﻐﻴﺮ ﻣﻌﺮف أوﻻ ﺛﻢ ﻳﺠﺐ أن ﺗﻜﻮن ﻟﻪ ﻗﻴﻤﻪ ﻗﺒﻞ هﺬﻩ‬
‫اﻟﺨﻄﻮﻩ وﺗﺠﻠﺐ ﻟﺘﻌﻮض ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﻤﻌﺎدﻟﻪ ) ﻣﻤﻜﻦ أن ﻧﺘﺨﻴﻞ اﻟﻄﺮف‬
‫اﻷﻳﻤﻦ ﻋﻨﺪهﺎ ﺳﻴﺼﺒﺢ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺜﻮاﺑﺖ ( ‪ ,‬ﺑﻌﺪهﺎ ﺗﺠﺮى اﻟﻌﻤﻠﻴﺎت‬
‫اﻟﺤﺴﺎﺑﻴﻪ وﺗﻜﻮن ﻣﻦ اﻟﻴﺴﺎر أﻟﻰ اﻟﻴﻤﻴﻦ وﺣﺴﺐ أﺳﺒﻘﻴﺎت اﻟﻌﻼﻣﺎت اﻟﺮﻳﺎﺿﻴﻪ‬
‫اﻟﻤﺒﻴﻨﻪ ﻓﻲ أدﻧﺎﻩ ‪ ,‬ﻓﺎﻷﺳﺒﻘﻴﻪ اﻷﻋﻠﻰ ﺗﻨﻔﺬ أوﻻ وأذا ﺗﺴﺎوت ﻋﻤﻠﻴﺘﺎن ﺑﺎﻷﺳﺒﻘﻴﻪ‬
‫ﻓﺘﻨﻔﺬ اﻟﻌﻤﻠﻴﻪ اﻟﺘﻰ ﻓﻲ اﻟﻴﺴﺎر‪ .‬ﻣﻦ ذﻟﻚ ﺳﻴﻨﺘﺞ ﻟﻨﺎ ﻋﺪد واﺣﺪ ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ‬
‫ﻗﻴﻤﺘﻪ هﺬﻩ اﻟﻘﻴﻤﻪ ﺳﺘﺆول اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻓﻲ اﻟﻄﺮف اﻷﻳﺴﺮ ) داﺋﻤﺎ اﻟﻘﻴﻤﻪ‬
‫ﺗﻨﺘﻘﻞ ﻣﻦ اﻟﻄﺮف اﻷﻳﻤﻦ ﻟﻠﻤﻌﺎدﻟﻪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻓﻲ اﻟﻄﺮف اﻷﻳﺴﺮ ( ‪.‬‬
‫• ﻳﺠﺐ أن ﻳﻜﻮن اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻋﻠﻰ ﻳﺴﺎر اﻟﻤﺴﺎواة واﻟﻤﺘﻐﻴﺮ أو اﻟﻤﺘﻐﻴﺮات ﻋﻠﻰ‬
‫ﻳﻤﻴﻦ اﻟﻤﺴﺎواة ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ‪.‬‬

‫أﺳﺒﻘﻴﺎت اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ ‪Operator Precedence‬‬
‫ﺗﻨﻔﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ وﻓﻘﺎ ﻷﺳﺒﻘﻴﺎﺗﻬﺎ اﻟﻤﺒﻴﻨﻪ أدﻧﺎﻩ ‪ ,‬دوﻧﺖ اﻟﻌﻤﻠﻴﺎت ﺑﺸﻜﻞ ﺗﻨﺎزﻟﻰ أي‬
‫ﻣﻦ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﻌﻠﻴﺎ اﻟﻰ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﺪﻧﻴﺎ ‪:‬‬
‫‪, Not‬‬
‫‪Mod , Div , And , Shl , Shr‬‬
‫‪Or , Xor‬‬
‫‪, > , > = , <> , = , In‬‬
‫•‬

‫‪– unary‬‬
‫‪* , / ,‬‬
‫‪+ , - ,‬‬
‫=< ‪< ,‬‬

‫‪1.‬‬
‫‪2.‬‬
‫‪3.‬‬
‫‪4.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪21‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫• اﻟﻤﻌﺎﻣﻼت ) ‪ ( operands‬ﺑﻴﻦ أﺛﻨﻴﻦ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﻤﺨﺘﻠﻔﺔ اﻷﺳﺒﻘﻴﻪ ﺗﻨﻔﺬ ﺣﺴﺐ‬
‫اﻷﺳﺒﻘﻴﻪ ) أي اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﻌﻠﻴﺎ أوﻻ ( ‪.‬‬
‫• اﻟﻤﻌﺎﻣﻼت ﺑﻴﻦ أﺛﻨﻴﻦ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﻤﺘﺴﺎوﻳﺔ اﻷﺳﺒﻘﻴﻪ ﺗﻨﻔﺬ ﻣﻦ اﻟﻴﺴﺎر اﻟﻰ اﻟﻴﻤﻴﻦ‬
‫) أي اﻟﻌﻤﻠﻴﻪ اﻟﺘﻲ ﻓﻲ اﻟﻴﺴﺎر أوﻻ ( ‪.‬‬
‫• اﻷﻗﻮاس ﺗﻨﻔﺬ أوﻻ ) أي أﻧﻬﺎ ﺗﺄﺧﺬ أﻋﻠﻰ أﺳﺒﻘﻴﻪ ( ‪.‬‬

‫• ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫وﺗ ﺘﻢ ﻋﻤﻠﻴ ﺔ أﺳ ﻨﺎد ) أدﺧ ﺎل ( ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ وذﻟ ﻚ ﺑﺄﺳ ﺘﺨﺪام أﻣ ﺮ اﻟﻘ ﺮاءﻩ‬
‫) أﻗﺮأ ( ) ) (‪ ( read( ) , OR readln‬وهﻲ ﺗﻌﻨﻲ ) أﻗﺮأ اﻟﻘﻴﻤ ﻪ اﻟﻤﻄﺒﻮﻋ ﻪ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ‬
‫وﺣﻤﻠﻬﺎ ﻓﻲ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺸﺎر اﻟﻴﻪ ﺑﻮاﺳﻄﺔ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ( ‪ ,‬ﻣﺜﺎل‬

‫;‪Program CH2_Program2‬‬
‫‪Var‬‬
‫;‪Num1, Num2, Sum: Integer‬‬
‫}‪Begin {no semicolon‬‬
‫;)'‪Write ('Input number 1 :‬‬
‫;)‪Readln (Num1‬‬
‫;)'‪Writeln ('Input number 2 :‬‬
‫;)‪Readln (Num2‬‬
‫}‪Sum: = Num1 + Num2; {addition‬‬
‫;)‪Writeln (Sum‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫} ‪{ Press enter‬‬
‫} ‪{ Press enter‬‬

‫‪Input number 1: 20‬‬
‫‪Input number 2: 15‬‬
‫‪35‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪/ /:‬‬
‫أوﻻ ‪ //:‬ﺗﻢ أﺳﺘﺨﺪام ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻸﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﺘ ﻲ ﺳﺘ ﺴﺘﺨﺪم ﻓ ﻲ‬
‫اﻟﺒﺮﻧ ﺎﻣﺞ وه ﻲ ) ‪ ( num1 , num2 , sum‬وه ﻲ ﺟﻤﻴﻌ ﺎ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﻷن ه ﺬا‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺻﻤﻢ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ) ﻳﻘﻮم ﺑﺠﻤﻊ ﻋﺪدﻳﻦ ﺻﺤﻴﺤﻴﻦ وأﻇﻬﺎر اﻟﻨﺘﻴﺠﻪ ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪22‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻳﻤﻜﻦ اﻷﻋﻼن ﻋﻦ آﻞ ﻣﺘﻐﻴﺮ ﺑ ﺴﻄﺮ ﻣﻨﻔ ﺼﻞ ‪ ,‬وﻳﻤﻜ ﻦ وﺿ ﻌﻬﺎ ﺟﻤﻴﻌ ﺎ ﺑ ﺴﻄﺮ واﺣ ﺪ‬
‫آﻤ ﺎ ﻓ ﻲ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﺮط أن ﺗﻜ ﻮن ﺟﻤﻴ ﻊ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع ) هﻨ ﺎ ﺟﻤﻴﻌﻬ ﺎ أﻋ ﺪاد‬
‫ﺻﺤﻴﺤﻪ ( وذﻟ ﻚ ﻟﻐ ﺮض ﺗﻘﻠﻴ ﻞ اﻟﻤ ﺴﺎﺣﻪ اﻟﺘ ﻲ ﻳﻜﺘ ﺐ ﻋﻠﻴﻬ ﺎ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬وﻳ ﺘﻢ اﻟﻔ ﺼﻞ ﺑ ﻴﻦ ﻣﺘﻐﻴ ﺮ وأﺧ ﺮ‬
‫ﺑﻔﺎرزﻩ ‪ .‬وﻃﺒﻌﺎ اﻟﻌﺒﺎرﻩ ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪.‬‬
‫ﺛﺎﻟﺜﺎ ‪ //:‬ﺑﻌﺪ آﻠﻤﺔ ) ‪ ( begin‬ﻧﻼﺣﻆ اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ )} ‪ ({ no semicolon‬وه ﻲ ﺗﻌﻨ ﻲ ﻻ‬
‫ﺗﺴﺘﺨﺪم ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪ ,‬وﺑﻤﺎ أﻧﻬﺎ وﺿﻌﺖ ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ ﻓﺄن ذﻟﻚ ﻳﻌﻨﻲ أﻧﻬﺎ ﻣﻼﺣﻈﻪ أو ﺗﻌﻠﻴ ﻖ‬
‫) ‪ ( Comment‬ﻟﻠﻤ ﺴﺘﺨﺪم أو اﻟﻘ ﺎريء ﺑﻌ ﺪم أﺳ ﺘﺨﺪام اﻟﻔ ﺎرزﻩ اﻟﻤﻨﻘﻮﻃ ﻪ ﺑﻌ ﺪ آﻠﻤ ﺔ ) ‪( begin‬‬
‫هﺬﻩ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ أﻋﺘﺒﺮت ﺗﻌﻠﻴ ﻖ آﺘﺒ ﺖ ووﺿ ﻌﺖ ﺑ ﻴﻦ ﻗﻮﺳ ﻴﻦ ﻣﺘﻮﺳ ﻄﻴﻦ ) } { ( ‪ ,‬وﺑﻤ ﺎ أﻧﻬ ﺎ ﺗﻌﻠﻴ ﻖ‬
‫ﻓﻴﺠﺐ ان ﻻ ﻳﻜﻮن ﻟﻬﺎ ﺗﺄﺛﻴﺮ ﻋﻠﻰ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ) أي أﻧﻬﺎ ﺗﻬﻤﻞ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ( ‪ ,‬ﻋﻠﻴ ﻪ ﻓ ﺴﻴﻜﻮن‬
‫ﻟﻨ ﺎ ﻗﺎﻋ ﺪﻩ أن أي ﻋﺒ ﺎرﻩ ﻟﻐ ﺮض اﻟﺘﻮﺿ ﻴﺢ أو اﻟﺘﻌﻠﻴ ﻖ ﻣﻤﻜ ﻦ آﺘﺎﺑﺘﻬ ﺎ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ أن ﺗﺤ ﺎط‬
‫ﺑﻘﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ وﺳﻮف ﻻ ﺗﻜﻮن ﺟﺰء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ ) ﺗﻬﻤﻞ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﺘﻌﻠﻴﻘﺎت أو اﻟﻤﻼﺣﻈﺎت ﺗﺴﺘﺨﺪم ﻷﻳﻀﺎح ﻋﻤﻞ ﺑﻌﺾ اﻟﺪوال واﻷﺟﺮاءات اﻟﺘﻲ ﺗﻜﻮن‬
‫ﻣﻌﺮوﻓﻪ ﻟﺪى اﻟﻤﺒﺮﻣﺞ وﻏﻴﺮ ﻣﻌﺮوﻓﻪ ﻟﻠﻤﺴﺘﺨﺪﻣﻴﻦ ‪ ,‬أﻳﻀﺎ ﺗﺴﺘﺨﺪم ﻟﻜﺘﺎﺑﺔ ﺑﻌﺾ‬
‫اﻟﻤﻌﻠﻮﻣﺎت ﺣﻮل اﻟﺒﺮﻧﺎﻣﺞ ) آﻮﻗﺖ اﻧﺸﺎءﻩ أو ﺗﺤﺪﻳﺜﻪ ( أو ﻣﻌﻠﻮﻣﺎت ﺣﻮل اﻟﻤﺒﺮﻣﺞ ﻧﻔﺴﻪ‬
‫) ﻣﺜﻼ اﻷﺳﻢ ‪ ,‬اﻟﻌﻨﻮان اﻷﻟﻜﺘﺮوﻧﻲ ( ‪.‬‬
‫اﻟﺘﻌﻠﻴﻘﺎت ﻣﻤﻜﻦ أن ﺗﻮﺿﻊ ﻓﻲ أي ﻣﻜﺎن ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﺑﺎﺳﻜﺎل ‪ ,‬وﻟﻜﻦ ﻳﻔﻀﻞ أن ﺗﻜﺘﺐ ﻓﻲ‬
‫ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﻤﻌﻠﻮﻣﺎت ﻋﻦ وﻇﻴﻔﺔ اﻟﺒﺮﻧﺎﻣﺞ أو ﻣﻌﻠﻮﻣﺎت ﻋﻦ‬
‫اﻟﻤﺒﺮﻣﺞ ( ‪ ,‬أو ﺗﻜﺘﺐ ﺑﺠﺎﻧﺐ اﻷواﻣﺮ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ ﺗﻮﺿﻴﺢ ‪ .‬وﻣﻤﻜﻦ أن ﻧﻀﻊ‬
‫اﻟﺘﻌﻠﻴﻘﺎت ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻣﺘﻮﺳﻄﻴﻦ ) } ‪ ( { comments‬أو ﺑﻴﻦ ﻗﻮﺳﻴﻦ ﻋﺎدﻳﻴﻦ ﻣﻊ ﻧﺠﻤﻪ‬
‫ﺑﺠﺎﻧﺐ آﻞ ﻗﻮس ) )* ‪ ( (* comments‬وﻻ ﻓﺮق ﺑﻴﻦ اﻷﺛﻨﻴﻦ ‪.‬‬

‫راﺑﻌﺎ ‪ //:‬آﻤﺎ ﺳﺒﻖ وأن ذآﺮﻧﺎ أن ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺘﻢ ﺑﺎﻟﺘﺴﻠﺴﻞ ﻣﻦ اﻷﻋﻠﻰ اﻟﻰ اﻷﺳﻔﻞ ﻓﻴﺒﺪأ ﻣﻦ‬
‫آﻠﻤﺔ ﺑﺮﻧﺎﻣﺞ ﺛﻢ ﻗﺴﻢ اﻷﻋﻼن وﻗﺮاءة اﻟﻤﺘﻐﻴﺮات ﺑﻌﺪهﺎ ﻳﻨﻔ ﺬ اﻷﻣ ﺮ أﺑ ﺪأ ﺛ ﻢ اﻟﻌﺒ ﺎرة اﻟﺘ ﻲ ﺗﻠﻴﻬ ﺎ وه ﻲ هﻨ ﺎ‬
‫اﻷﻣﺮ أآﺘﺐ ) ﻻﺣﻆ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ اﻷﻣﺮ أآﺘﺐ ه ﻮ ﻣﺤ ﺼﻮر ﺑ ﻴﻦ ﻋﻼﻣﺘ ﻲ أﻗﺘﺒ ﺎس ﻟ ﺬا ﻓﺄﻧ ﻪ‬
‫ﻳﻄﺒ ﻊ آﻤ ﺎ ه ﻮ ( ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﺳ ﺘﻈﻬﺮ ﻋﻠ ﻰ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ وه ﻲ ﺗﺨﺒ ﺮ اﻟﻤ ﺴﺘﺨﺪم ﻣ ﺎﻳﻠﻲ ) أدﺧ ﻞ اﻟ ﺮﻗﻢ‬
‫اﻷول ( وه ﻲ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻳﻤﻜ ﻦ اﻷﺳ ﺘﻐﻨﺎء ﻋﻨﻬ ﺎ دون أن ﻳﺘ ﺄﺛﺮ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ..‬وﻟﻜﻨﻬ ﺎ ﻣﻔﻴ ﺪﻩ ﺣﻴ ﺚ ﺗﻌﻠ ﻢ‬
‫اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﻟﺨﻄﻮة أو اﻟﺨﻄﻮات اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻬﺎ ﻷﻧﺠﺎز ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪ ) ,‬ﻳﻤﻜﻦ ﻣﻼﺣﻈ ﺔ ﻣﺜ ﻞ ذﻟ ﻚ‬
‫ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﻌﻤﻠﻮن ﻋﻠﻴﻬﺎ ﻣﺜﻼ ﻓﻲ ﺑﺮﻧﺎﻣﺞ ﻟﻠﻌﺒ ﻪ ) ‪ ( game‬ﻣﻌﻴﻨ ﻪ ﻓ ﺄن هﻨ ﺎك ﻣﻼﺣﻈ ﺎت ﺳ ﺘﻈﻬﺮ‬
‫ﻋﻠﻰ اﻟﺸﺎﺷﻪ ﻷرﺷﺎد اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﻟﺨﻄﻮات اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻬﺎ ﻟﺘﺸﻐﻴﻞ اﻟﻠﻌﺒﻪ أو أﺧﺘﻴﺎر درﺟ ﺔ اﻟ ﺼﻌﻮﺑﻪ‬
‫وﻏﻴﺮهﺎ (‪.‬‬
‫ﺧﺎﻣﺴﺎ ‪ //:‬هﻨﺎ ﺗﺒﺪأ ﻋﻤﻠﻴﺔ أدﺧﺎل ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( num1‬وذﻟﻚ ﺑﺄﺳﺘﺨﺪام اﻷﻣ ﺮ ) ‪( readln‬‬
‫‪ ,‬ﻋﻨﺪ اﻟﻮﺻﻮل اﻟﻰ ه ﺬﻩ اﻟﺨﻄ ﻮﻩ ﻓ ﺄن ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ) اﻟ ﺸﺎﺷﻪ اﻟ ﺴﻮداء ( ﺳ ﺘﻈﻬﺮ وﻳﻜ ﻮن هﻨ ﺎك ﻣﺆﺷ ﺮ‬
‫ﺻﻐﻴﺮ ﻋﻠﻰ ﺷﻜﻞ ﺷﺎرﺣﻪ ) ‪ ( -‬ﻳﻈﻬﺮ وﻳﺨﺘﻔﻲ ﻓﻲ ﻣﻮﻗﻊ ﻋﻠﻰ اﻟﺠﺎﻧﺐ اﻷﻳﺴﺮ ﻣ ﻦ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ه ﺬا‬
‫اﻟﻤﺆﺷﺮ ﻳﺨﺒﺮ اﻟﻤﺴﺘﺨﺪم ﺑﺄن ﻋﻠﻴﻪ أدﺧﺎل ﻗﻴﻤﻪ ) ﻃﺒﺎﻋﺔ ﻗﻴﻤﻪ ﻣﻌﻴﻨﻪ ﺑﺄﺳﺘﺨﺪام ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ( ‪ ,‬وﺑﻌ ﺪ أن‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪23‬‬

‫ﻧﻄﺒﻊ ه ﺬﻩ اﻟﻘﻴﻤ ﻪ ﻳ ﺘﻢ أﻋ ﻼم اﻟﺒﺮﻧ ﺎﻣﺞ ) اﻟﻤﺘ ﺮﺟﻢ ( ﺑﺄﻧﺠ ﺎز اﻟﻌﻤ ﻞ وذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل اﻟ ﻀﻐﻂ ﻋﻠ ﻰ اﻟ ﺰر‬
‫) ‪ ( Enter‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﻪ ﺳ ﻴﺘﻢ ﻗ ﺮاءة اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻃﺒﻌ ﺖ ﻋﻠ ﻰ اﻟ ﺸﺎﺷﻪ وﺧﺰﻧﻬ ﺎ ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي‬
‫ﻳﺆﺷﺮ ﻋﻠﻴﻪ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻮﺟﻮد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ اﻷﻣ ﺮ) ‪ ( readln‬وﺑ ﺬﻟﻚ ﻧﻜ ﻮن ﻗ ﺪ أدﺧﻠﻨ ﺎ ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ‬
‫) ‪ ) ( num1‬ﺧﺰﻧ ﺎ ﻗﻴﻤ ﻪ ( ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮﻋﻠﻴﻪ اﻟﻤﺘﻐﻴ ﺮ ﺑﻌ ﺪ ه ﺬﻩ اﻟﺨﻄ ﻮﻩ ‪ ,‬وه ﺬا ﻣ ﺎ أﺳ ﻤﻴﻪ‬
‫اﻷدﺧﺎل ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ) أي اﻷدﺧﺎل اﻟﺬي ﻳﺘﻢ ﺑﻮاﺳﻄﺔ اﻟﻤﺴﺘﺨﺪم أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ (‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﻔﺮق ﺑﻴﻦ اﻷﻣﺮ ‪ Read‬واﻷﻣﺮ ‪ Readln‬وآﻼهﻤﺎ ﻳﺴﺘﺨﺪم ﻟﻠﻘﺮاءﻩ ‪ ,‬أن اﻷﻣﺮ‬
‫‪ Read‬ﻳﻘﺮأ اﻟﻤﺪﺧﻼت اﻟﺘﻲ ﻳﺪﺧﻠﻬﺎ اﻟﻤﺴﺘﺨﺪم وﻳﺘﻮﻗﻒ ﺑﻌﺪ أﺧﺮ ﻗﻴﻤﻪ ﻳﺘﻢ ﻗﺮاﺋﺘﻬﺎ ﻓﺄذا‬
‫ﺟﺎء أﻣﺮ ) ‪ ( read‬أﺧﺮ ﻓﻴﺒﺪأ اﻟﻘﺮاءﻩ أﻋﺘﺒﺎرا ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ‬
‫اﻟﻤﺆﺷﺮ ﺑﻌﺪ اﻟﻘﺮاءﻩ اﻷوﻟﻰ ‪.‬‬
‫أﻣﺎ اﻷﻣﺮ ‪ Readln‬ﻓﺄﻧﻪ ﻳﻌﻤﻞ ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ ﻣﻊ أﺳﺘﺜﻨﺎء واﺣﺪ ‪ .‬ﻓﺒﻌﺪ أن ﻳﻨﺘﻬﻲ ﻣﻦ‬
‫ﻗﺮاءة أﺧﺮ ﻗﻴﻤﻪ ﻓﻲ اﻟﻘﺎﺋﻤﻪ ﻓﺄن اﻟﻤﺆﺷﺮ ﺳﻴﻬﻤﻞ آﻞ اﻟﻘﻴﻢ اﻟﻤﺘﺒﻘﻴﻪ ﻋﻠﻰ ذﻟﻚ اﻟﺴﻄﺮ‬
‫وﻳﻨﺘﻘﻞ اﻟﻰ ﺑﺪاﻳﺔ ﺳﻄﺮ ﺟﺪﻳﺪ ‪.‬‬

‫ﺳﺎدﺳﺎ ‪ //:‬اﻷﻣﺮان اﻟﻼﺣﻘﺎن هﻤﺎ ﻣﺸﺎﺑﻬﺎن ﻟﻠﺨﻄﻮﺗﻴﻦ اﻟﺮاﺑﻌﻪ واﻟﺨﺎﻣﺴﻪ‪.‬‬
‫ﺳ ﺎﺑﻌﺎ ‪ //:‬اﻟﻤﻌﺎدﻟ ﻪ ) ‪ ( sum : = num1 + num2‬ﻋﻨ ﺪ اﻟﻮﺻ ﻮل اﻟ ﻰ ه ﺬﻩ اﻟﻤﻌﺎدﻟ ﻪ ﻓ ﺄن‬
‫اﻟﻤﺘﺮﺟﻢ ﺳﻴﺒﺪأ ﺑﺎﻟﻄﺮف اﻷﻳﻤﻦ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ وﻳﻌﻮض ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻮﺟﻮدﻩ ﺑﻤﺎ ﻳ ﺴﺎوﻳﻬﺎ ﻣ ﻦ ﻗ ﻴﻢ ﺛ ﻢ‬
‫أﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ ﻋﻠﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻴﻨﺘﺞ ﻋﻦ ذﻟﻚ ﻗﻴﻤﻪ واﺣﺪﻩ ﻓﻲ اﻟﻄﺮف اﻷﻳﻤﻦ ‪ ,‬هﺬﻩ اﻟﻘﻴﻤ ﻪ ﺳﺘﻮﺿ ﻊ‬
‫) ﺗﺨ ﺰن ( ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ اﻟﻤﺘﻐﻴ ﺮ اﻟﻤﻮﺟ ﻮد ﻓ ﻲ اﻟﻄ ﺮف اﻷﻳ ﺴﺮ‪ ,‬وﺑ ﺬﻟﻚ ﻓ ﺎن اﻟﻤﺘﻐﻴ ﺮ‬
‫) ‪ ( sum‬ﺳﺘﺴﻨﺪ ﻟﻪ ﻗﻴﻤ ﻪ ) ﺗﺨ ﺰن ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ ( ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌﺎدﻟ ﻪ وه ﺬا ﻣ ﺎ أﺳ ﻤﻴﻪ‬
‫أدﺧﺎل ﻗﻴﻤﻪ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ) أي أن اﻟﻤﺴﺘﺨﺪم ﻻ ﻳﺘﺪﺧﻞ ﻓﻲ ذﻟﻚ أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ( ‪.‬‬
‫ﺛﺎﻣﻨ ﺎ ‪ //:‬ﺑﻌ ﺪ أﻧﺠ ﺎز اﻟﻌﻤ ﻞ اﻟﻤﻄﻠ ﻮب ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓ ﻼ ﺑ ﺪ ﻣ ﻦ أﻋ ﻼم اﻟﻤ ﺴﺘﺨﺪم ﺑﺎﻟﻨﺘﻴﺠ ﻪ‬
‫اﻟﻤﺘﺤﺼﻠﻪ ﻣﻦ أﻧﺠﺎز أو ﺗﻨﻔﻴﺬ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل ﻃﺒﺎﻋ ﺔ اﻟﻘﻴﻤ ﻪ اﻟﻤﺘﺤ ﺼﻠﻪ واﻟﺘ ﻲ ه ﻲ‬
‫اﻷن ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ) ‪ , ( sum‬ﻟﺬا ﺗﻢ أﺳﺘﺨﺪام اﻷﻣﺮ أآﺘﺐ ﻟﻴﻄﺒﻊ ﻣ ﺎ ﻣﻮﺟ ﻮد ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ اﻟﻠﺘ ﻴﻦ‬
‫ﺑﻌﺪﻩ ‪ ,‬وﻟﻤﺎ آﺎن ﻣﺎ ﻣﻮﺟﻮد ﺿﻤﻦ اﻟﻘﻮﺳﻴﻦ ﻏﻴﺮ ﻣﺤﺪد ﺑﻌﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻟ ﺬا ﻓ ﺎن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ ه ﺬا‬
‫اﻟﻤﺘﻐﻴﺮ هﻲ اﻟﺘﻲ ﺗﻈﻬﺮ ﻋﻠﻰ ﺷﺎﺷﻪ اﻟﺘﻨﻔﻴﺬ ‪.‬‬
‫ﺗﺎﺳﻌﺎ ‪ //:‬ﺳﺒﻖ وأن ﻧﺒﻬﻨﺎ أﻟﻰ أن ﺳﺮﻋﺔ اﻟﺘﻨﻔﻴﺬ ﺳﻮف ﻻﺗﻤﻜﻦ اﻟﻤﺴﺘﺨﺪم ﻣﻦ رؤﻳﻪ اﻟﻨﺘﺎﺋﺞ وﺑﻴﻨﺎ‬
‫ﺑﺄن ﻣﻦ اﻟﻤﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم اﻟ ﺰرﻳﻦ ) ‪ ( Alt + F5‬ﻣﻌ ﺎ ﻷﻇﻬ ﺎر اﻟﻨﺘ ﺎﺋﺞ ‪ ...‬وﻣﻤﻜ ﻦ أﻳ ﻀﺎ أن ﻧ ﺴﺘﺨﺪم‬
‫ﻃﺮﻳﻘﻪ أﺧﺮى وهﻲ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( readln‬ﻓﻘﻂ أي ﺑﺪون اﻷﻗﻮاس اﻟﺘﻲ ﺑﻌﺪﻩ آﻤﺎ ﻣﺒﻴﻦ أﻋﻼﻩ ‪ ,‬هﻨ ﺎ‬
‫اﻟﻤﺘﺮﺟﻢ ﺳﻴﻔﺴﺮ اﻷﻣﺮ آﻤﺎ ﻟﻮ أن اﻟﻤﺴﺘﺨﺪم ﻳﺮﻏﺐ ﺑﺎدﺧﺎل ﻗﻴﻤﻪ ﻟﻤﺘﻐﻴﺮ وﺳ ﻴﻈﻬﺮ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ﻣﻨﺘﻈ ﺮا‬
‫اﻟﻤﺴﺘﺨﺪم ﻟﻴﺪﺧﻞ اﻟﻘﻴﻤﻪ وﺑﺬﻟﻚ ﺳﻨﺮى اﻟﻨﺘﺎﺋﺞ وﻳﻤﻜﻦ اﻟﺨﺮوج ﻣﻦ هﺬﻩ اﻟﺸﺎﺷﻪ وذﻟﻚ ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺰر‬
‫)‪ ) . (Enter‬هﻲ ﻋﻤﻴﻠﺔ أﺣﺘﻴﺎل ﻋﻠﻰ اﻟﺤﺎﺳﻮب وﻋﻨﺪ اﻟﻀﻐﻂ ﻋﻠﻰ اﻟﺰر ‪ Enter‬ﻓﻬﺬا ﻳﻌﻨ ﻲ أن ﻋﻤﻠﻴ ﺔ‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪24‬‬

‫اﻷدﺧ ﺎل ﺗﻤ ﺖ واﻟﻤﻔ ﺮوض أن ﻳﻘ ﺮأ ﻣ ﺎ ﻣﻄﺒ ﻮع ﻋﻠ ﻰ اﻟ ﺸﺎﺷﻪ وﻳ ﺴﻨﺪﻩ اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ واﻟ ﺬي ه ﻮ ﻏﻴ ﺮ‬
‫ﻣﻮﺟﻮد ( ‪.‬‬
‫ﻋﺎﺷﺮا ‪ //:‬اﻷﻣﺮ اﻷﺧﻴ ﺮ ه ﻮ ) ‪ ( end‬وواﺿ ﺢ أﻧ ﻪ ﻳﻌﻨ ﻲ اﻟﻨﻬﺎﻳ ﻪ ) هﻨ ﺎ ﻳﺠ ﺐ أن ﻧﻼﺣ ﻆ أﻧﻨ ﺎ‬
‫ﻳﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم اﻷﻣ ﺮ ) ‪ ( begin‬أآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ ﺑ ﺸﺮط أن ﻳﻜ ﻮن هﻨ ﺎك أﻣ ﺮ ) ‪ ( end‬ﻟﻜ ﻞ أﻣ ﺮ‬
‫) ‪ , ( begin‬ﺟﻤﻴﻊ هﺬﻩ اﻷواﻣﺮ ) ‪ ( end‬ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃ ﻪ ﻋ ﺪا أﺧ ﺮ أﻣ ﺮ ) ‪ ( end‬ﻓﺄﻧ ﻪ ﺳ ﻴﻨﺘﻬﻲ‬
‫ﺑﻨﻘﻄﻪ ( ‪ ,‬ان اﻷﻣﺮ ) ‪ ( end‬اﻟﺬي ﻳﻨﺘﻬﻲ ﺑﻨﻘﻄﻪ ﻳﻌﻨﻲ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ آﻜﻞ وآ ﻞ ﻣﺎﺑﻌ ﺪ ه ﺬا اﻷﻣ ﺮ ﻳﻬﻤ ﻞ‬
‫وآﻤﺎ هﻮ واﺿﺢ أﻋﻼﻩ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫أدﻧﺎﻩ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﻼﺣﻆ ﻋﻨﺪ أدﺧﺎل اﻟﺒﻴﺎﻧﺎت اﻟﻤﻄﻠﻮﺑﻪ ‪:‬‬
‫‪ .1‬ﻳﺠﺐ أن ﻳﺘﻄﺎﺑﻖ ﻋﺪد اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﻳﺘﻢ أدﺧﺎﻟﻬﺎ ﻣﻊ ﻋﺪد اﻟﻤﺘﻐﻴﺮات اﻟﻤﺪوﻧﻪ ﺑﻴﻦ‬
‫اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻳﻌﺎز اﻟﻘﺮاءﻩ ‪.‬‬
‫‪ .2‬ﻳﺠﺐ أن ﻳﺘﻄﺎﺑﻖ ﻧﻮع اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻟﻤﺘﻐﻴﺮ ﻣﻌﻴﻦ ﻣﻊ اﻟﻨﻮع اﻟﻤﻌﻠﻦ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ ‪.‬‬
‫‪ .3‬اﻟﻤﺘﻐﻴﺮات اﻟﻤﺪوﻧﻪ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻳﻌﺎز اﻟﻘﺮاءﻩ ﻳﺠﺐ أن ﺗﻔﺼﻞ ﺑﻴﻨﻬﺎ ﻓﺎرزﻩ أذا آﺎن‬
‫ﻋﺪدهﺎ أآﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ واﺣﺪ ‪.‬‬
‫‪ .4‬أذا آﺎن أآﺜﺮ ﻣﻦ ﻣﺘﻐﻴﺮ واﺣﺪ ﻓﻲ أﻳﻌﺎز ﻗﺮاءﻩ واﺣﺪ ﻓﻴﻤﻜﻦ أدﺧﺎﻟﻬﺎ ﺟﻤﻴﻌﺎ ﺛﻢ ﺿﻐﻂ اﻟﺰر‬
‫) ‪ ( Enter‬ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻦ ﻗﻴﻤﻪ وأﺧﺮى ﻓﺮاغ ‪ ,‬أو ﻧﺪﺧﻞ اﻟﻘﻴﻢ واﺣﺪﻩ ﺑﻌﺪ اﻷﺧﺮى‬
‫ﻋﻠﻰ أن ﻧﻀﻐﻂ اﻟﺰر ) ‪ ( Enter‬ﺑﻌﺪ أدﺧﺎل آﻞ ﻗﻴﻤﻪ ‪.‬‬
‫‪ .5‬ﻻ ﻳﺠﻮز أن ﺗﻜﻮن اﻟﻘﻴﻢ اﻟﻤﺪﺧﻠﻪ ﺻﻴﻎ رﻳﺎﺿﻴﻪ ) أي ﻗﻴﻢ ﺑﻴﻨﻬﺎ ﻋﻼﻣﺎت رﻳﺎﺿﻴﻪ (‬

‫‪2.4‬‬

‫ﻣﺘﻐﻴﺮات اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRING VARIABLES‬‬

‫اﻷن ﻧ ﺘﻌﻠﻢ آﻴﻔﻴ ﻪ أدﺧ ﺎل ﻧ ﺺ آﺘ ﺎﺑﻲ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤ ﺴﺘﺨﺪم وذﻟ ﻚ ﺑﺄﺳ ﺘﺨﺪام ﻣﺘﻐﻴ ﺮات اﻟ ﺴﻼﺳﻞ‬
‫اﻟﺤﺮﻓﻴﻪ و اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻳﺒﻴﻦ آﻴﻔﻴﻪ أدﺧ ﺎل ﻣﺘﻐﻴ ﺮات اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ وذﻟ ﻚ ﺑﺘﺤﻔﻴ ﺰ اﻟﻤ ﺴﺘﺨﺪم ﻟﻬ ﺬا‬
‫اﻻﺟﺮاء ‪ ,‬ﻣﺜﺎل‬

‫;‪Program CH2_Program3‬‬
‫;‪Var name, surname: String‬‬
‫‪Begin‬‬
‫;)'‪Write ('Enter your name :‬‬
‫;)‪readln (name‬‬
‫;)'‪Write ('Enter your surname :‬‬
‫;)‪readln (surname‬‬
‫}‪writeln ;{new line‬‬
‫}‪writeln ;{new line‬‬
‫;)‪Writeln ('your full name is: ', name,' ', surname‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪25‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫} ‪{ enter‬‬
‫} ‪{ enter‬‬

‫‪Enter your name:‬‬
‫‪Ahmed‬‬
‫‪Enter your surname: Abass‬‬

‫‪Your full name is: Ahmed Abass‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪// :‬‬
‫اذا ﻣﺎ ﻧﻈﺮﻧﺎ اﻟﻰ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻓﻤﻦ اﻟﻤﻤﻜﻦ أن ﻧﺴﺠﻞ ﻋﺪد ﻣﻦ اﻟﻤﻼﺣﻈﺎت وﻧﺘﻌﻠﻢ أﺷﻴﺎء ﺟﺪﻳ ﺪﻩ‬
‫وهﻲ ‪:‬‬
‫اوﻻ ‪ //:‬ﺗﻢ أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮﻳﻦ ) ‪ ( name , surname‬ﻣﻦ ﻧﻮع ﺳﻼﺳﻞ ﺣﺮﻓﻴ ﻪ ) ‪( string‬‬
‫وﻟﺬﻟﻚ ﻓﻌﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﺘﻢ اﻟﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أدﺧﺎل ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺤﺮوف ﻟﻜﻞ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮﻳﻦ‬
‫وﻣ ﺎ ﻳ ﺘﻢ ﻃﺒﺎﻋﺘ ﻪ أو أدﺧﺎﻟ ﻪ ﻋ ﻦ ﻃﺮﻳ ﻖ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﺳ ﻴﺬهﺐ ﻣﺒﺎﺷ ﺮة اﻟ ﻰ اﻟ ﺬاآﺮﻩ وﻳﺨ ﺰن ﺑ ﺎﻟﻤﻮﻗﻊ‬
‫اﻟﻤﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ اﻟﻤﺘﻐﻴﺮ أﻋﻼﻩ ‪ .‬أن هﺬﻳﻦ اﻟﻤﺘﻐﻴﺮﻳﻦ ﻳﻤﻜﻦ اﺳﺘﺒﺪاﻟﻬﻤﺎ ﺑﺄي ﻣﺘﻐﻴﺮ أﺧ ﺮ ﻣ ﺜﻼ ) ‪( n‬‬
‫ﺑﺪﻻ ﻣﻦ ) ‪ ( name‬وﻃﺒﻌﺎ ذﻟﻚ ﻻ ﻳﺆﺛﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﺳﺒﻖ وأن ﺑﻴﻨﺎ‪.‬‬
‫ﺛﺎﻧﻴ ﺎ ‪ //:‬ﻻﺣ ﻆ ﻓ ﻲ اﻟ ﺴﻄﺮﻳﻦ اﻟﺘﺎﺳ ﻊ واﻟﻌﺎﺷ ﺮ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( writeln‬دون وﺟ ﻮد‬
‫أﻗ ﻮاس ﺑﻌ ﺪهﻤﺎ وه ﺬﻩ اﻟﻌﻤﻠﻴ ﻪ ﺗﻔﻴ ﺪ ﺑﻄﺒﺎﻋ ﺔ ﺳ ﻄﺮ ﻓ ﺎرغ ﻟﻜ ﻞ ﻣﻨﻬﻤ ﺎ أي أن اﻟﻤﺆﺷﺮﺳ ﻴﺘﺤﺮك اﻟ ﻰ ﺳ ﻄﺮ‬
‫ﺟﺪﻳﺪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺮد ﻣﺜﻞ هﺬا اﻷﻣﺮ‪ ,‬وهﻲ ﻷﻏﺮاض ﺗﻨﻈﻴﻢ وﺗﺮﺗﻴﺐ اﻟﻤﺨﺮﺟﺎت ‪.‬‬
‫ﺛﺎﻟﺜﺎ ‪ //:‬أﻣﺮ اﻟﻄﺒﺎﻋﻪ اﻷﺧﻴﺮ هﻮ أﻳﻀﺎ ﻳﺨﺘﻠﻒ ﻋﻦ ذﻟ ﻚ اﻟ ﺬي ﺳ ﺒﻖ وأن ﺗ ﻢ أﺳ ﺘﺨﺪاﻣﻪ ‪ ,‬ﺣﻴ ﺚ‬
‫أﻧﻪ ﻳﺤﺘﻮي ﻋﻠ ﻰ ﻋ ﺪد ﻣ ﻦ اﻟﻌﺒ ﺎرات داﺧ ﻞ اﻟﻘﻮﺳ ﻴﻦ ﻳﻔ ﺼﻞ ﺑ ﻴﻦ واﺣ ﺪﻩ واﺧ ﺮى ﻓ ﺎرزﻩ ‪ ,‬وه ﺬﻩ ﻃﺮﻳﻘ ﻪ‬
‫ﻳﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ أواﻣﺮ اﻟﻄﺒﺎﻋﻪ وذﻟﻚ ﺑﺪﻻ ﻣﻦ ﺗﻜﺮار أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﻟﻜ ﻞ ﺣﺎﻟ ﻪ ﻓ ﻴﻤﻜﻦ دﻣﺠﻬ ﺎ ﺟﻤﻴﻌ ﺎ‬
‫ﺑﺄﻣﺮ واﺣﺪ ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧﺮى ﻓﺎرزﻩ‪.‬‬
‫ﻻﺣﻆ اﻟﺠﺰء اﻷول وﺿﻊ ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ‪ ( Your full name is:‬وه ﺬا اﻟﺠ ﺰء ﺳ ﻴﺘﻢ‬
‫ﻃﺒﺎﻋﺘﻪ آﻤﺎ هﻮ آﻤﺎ ﺗﻌﻠﻤﻨﺎ ‪ ,‬أن اﻟﻔ ﺎرزﻩ ﺗﻌﻨ ﻲ اﻟﺒ ﺪأ ﺑ ﺄﻣﺮ ) ‪ ( write‬ﺟﺪﻳ ﺪ ﻟﻤ ﺎ ﻳﻠ ﻲ اﻟﻔ ﺎرزﻩ أي وآﺄﻧﻤ ﺎ‬
‫ﻧﻘ ﻮل ) )‪ , ( write (name‬وﻟ ﺬا ﻓﻬ ﻲ ﺳ ﺘﻄﺒﻊ ﻣ ﺎﻳﻠﻲ اﻟﻔ ﺎرزﻩ وﻋﻠ ﻰ ﻧﻔ ﺲ اﻟ ﺴﻄﺮ وﻟﻤ ﺎ آ ﺎن اﻟﻤﺘﻐﻴ ﺮ‬
‫) ‪ ( name‬ﻟﻴﺲ ﻣﺤﺪد ﺑﻌﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻓﺴﻴﺘﻢ ﻃﺒﺎﻋﺔ ﻣﺎﻳﺤﻤﻠﻪ ﻣﻦ ﻗﻴﻤ ﻪ ‪ ,‬واﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ هﻨ ﺎ ه ﻲ‬
‫ﻋﺒﺎرﻩ ﻋﻦ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪ .‬ﺑﻌﺪهﺎ ﻧﻼﺣﻆ اﻟﻔﺎرزﻩ ﺛﻢ ﺗﻠﻴﻬﺎ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ﺗﺤﺪد ﺑﻴﻨﻬ ﺎ ﻓ ﺮاغ ﻟ ﺬا ﻓ ﺎن أﻣ ﺮ‬
‫اﻟﻄﺒﺎﻋ ﻪ ﻳ ﺸﻴﺮ اﻟ ﻰ ﻃﺒﺎﻋ ﺔ ﻓ ﺮاغ وهﻜ ﺬا ﺳ ﻴﺘﻢ ﻃﺒﺎﻋ ﺔ ﻓ ﺮاغ ﺣ ﺴﺐ ﺣﺠ ﻢ اﻟﻔ ﺮاغ اﻟﻤﺤ ﺪد ﺑ ﻴﻦ ﻋﻼﻣﺘ ﻲ‬
‫اﻷﻗﺘﺒ ﺎس وأﺧﻴ ﺮا ﻳ ﺄﺗﻲ أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ ( surname‬وﺳ ﻴﺘﻢ ﻃﺒﺎﻋ ﺔ ﻗﻴﻤﺘ ﻪ واﻟﺘ ﻲ ه ﻲ ﺳﻠ ﺴﻠﻪ‬
‫ﺣﺮﻓﻴﻪ‪.‬‬
‫ﻣﻤﻜﻦ أﻋ ﺎدة آﺘﺎﺑ ﻪ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 3‬وﻟﻜ ﻦ ﺑﺄﺳ ﺘﺨﺪام اﻟﺜﻮاﻳ ﺖ ﻟ ﻨﻼﺣﻆ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام اﻟﺜﻮاﺑ ﺖ ‪,‬‬
‫ﺟﺰء ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺣﻘﻞ اﻟﺜﻮاﺑ ﺖ ‪ ,‬وه ﺬا ﻳﺨﺘﻠ ﻒ ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺣﻴ ﺚ أن اﻟﻤﻌ ﺮف ﻓ ﻲ‬
‫ه ﺬا اﻟﺤﻘ ﻞ ﺗﺒﻘ ﻰ ﻗﻴﻤﺘ ﻪ ﺛﺎﺑﺘ ﻪ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ ﻳﻤﻜ ﻦ ﺗﻐﻴﻴﺮه ﺎ ‪ ,‬ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻻ ﻳﺨﺘﻠ ﻒ آﺜﻴ ﺮا ﻋ ﻦ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ وﻟﻜﻦ ﺗﻢ أﺳﺘﺨﺪام اﻟﻤﻌﺮف ) ‪ ( name‬آﻘﻴﻤﻪ ﺛﺎﺑﺘ ﻪ وﻟ ﺬﻟﻚ ﺳ ﻮف ﻻ ﻧﺤﺘ ﺎج اﻟ ﻰ أدﺧ ﺎل‬
‫ﻗﻴﻤﻪ ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ أو اﻟﻤﻌﺮف ﻷﻧﻨﺎ أدﺧﻠﻨﺎ ﻟﻪ ﻗﻴﻤﻪ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ وﻣﻤﻜﻦ أن ﺗﻜﻮن هﺬﻩ اﻟﻘﻴﻤﻪ ﻋﺪد ‪,‬‬
‫ﺣﺮف ‪ ,‬أو ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪26‬‬

‫;‪Program CH2_Program4‬‬
‫‪Const‬‬
‫'‪{the reserved word 'const‬‬
‫}‪is used to initialize constants‬‬
‫;'‪Name = 'Ahmed‬‬
‫‪Var‬‬
‫;‪Surname: String‬‬
‫‪Begin‬‬
‫;)'‪Write ('Enter your surname :‬‬
‫;)‪Readln (surname‬‬
‫;‪Writeln‬‬
‫;‪Writeln‬‬
‫;)‪Writeln ('your full name is: ', name,' ', surname‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت هﺬا اﻟﺒﺮﻧﺎﻣﺞ هﻲ ذات اﻟﻤﺨﺮﺟﺎت ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( Halt‬ﻷﻳﻘﺎف ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫وﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( Exit‬ﻟﻠﺨﺮوج ﻣﻦ اﻟﻜﺘﻠﻪ اﻟﺤﺎﻟﻴﻪ ‪.‬‬

‫‪2.5‬‬

‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‬
‫هﻨﺎك ﺛﻼث أﻧﻮاع ﻣﻦ أﺧﻄﺎء اﻟﺒﺮاﻣﺞ اﻟﻤﻬﻤﻪ وهﻲ ‪:‬‬

‫‪ 2.5.1‬اﻟﺨﻄ ﺄ اﻟ ﺬي ﻳﻤﻜ ﻦ ﺗﻤﻴ ﺰﻩ أﺛﻨ ﺎء ﺗﺮﺟﻤ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻗﻴ ﻞ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫ﻋﺪم آﺘﺎﺑ ﺔ اﻷﻣ ﺮ ) ‪ ( End‬ﻷﻣ ﺮ ) ‪ ( begin‬ﻣﻮﺟ ﻮد ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ .‬وه ﺬا ﻧ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء‬
‫اﻟﺘﻲ ﺗﺴﻤﻰ أﺧﻄﺎء وﻗﺖ اﻟﺘﺮﺟﻤﻪ ) ‪ , ( Compile _ time errors‬وهﻮ ﺳ ﻴﺆدي اﻟ ﻰ ﻋ ﺪم‬
‫ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻊ ﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ ﺗﺤﺪد ﻧﻮع اﻟﺨﻄﺄ ‪.‬‬
‫‪ 2.5.2‬اﻟﺨﻄ ﺄ اﻟ ﺬي ﻻ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ وأﻧﻤ ﺎ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ آﺎن هﻨﺎك أﻣﺮ ﻷﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻟﻤﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻇﻬ ﺮ أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﺳ ﺎﻟﺒﻪ‬
‫) ﻣﻌﺮوف أﻧﻪ ﻻ ﻳﻤﻜﻦ أﻳﺠﺎد اﻟﺠﺬر ﻟﻠﻘﻴﻢ اﻟﺴﺎﻟﺒﻪ ( ‪ ,‬هﺬا ﺳﻴﺆدي اﻟﻰ ﺗﻮﻗ ﻒ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﻊ‬
‫ﻇﻬ ﻮر رﺳ ﺎﻟﺔ ﺧﻄ ﺄ ‪ .‬ه ﺬا اﻟﻨ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﺗ ﺴﻤﻰ أﺧﻄ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ‬
‫) ‪. ( Run _ time errors‬‬
‫‪ 2.5.3‬أﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻻ ﺗﻤﻴ ﺰ ﺳ ﻮاء أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ أو أﺛﻨ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ ‪ ,‬ﻣﺜ ﺎل‬
‫اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻳﺮﺗﻜﺒﻬ ﺎ اﻟﻤﺒ ﺮﻣﺞ رﺑﻤ ﺎ ﺳ ﻬﻮا وﻟﻜﻨﻬ ﺎ ﻣﻘﺒﻮﻟ ﻪ ﻟﻠﺤﺎﺳ ﻮب آ ﺄن ﻳﻜ ﻮن اﻟﻤﻄﻠ ﻮب‬
‫أدﺧﺎل اﻟﻘﻴﻤﻪ ) ‪ ( 30‬وﻳﺘﻢ أدﺧﺎل اﻟﻘﻴﻤ ﻪ ) ‪ ( 40‬ه ﺬا اﻟﺨﻄ ﺄ ﻻ ﻳﻌﺘ ﺮض ﻋﻠﻴ ﻪ اﻟﺤﺎﺳ ﻮب وﻟﻜﻨ ﻪ‬
‫ﺳﻴﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﺻﺤﻴﺤﻪ ‪ ,‬ﻣﺜﻞ هﺬﻩ اﻷﺧﻄﺎء ﺳﻮف ﺗ ﺴﻤﺢ ﻟﻠﺒﺮﻧ ﺎﻣﺞ ﺑﺎﻷﺳ ﺘﻤﺮار‬
‫ﺑﺎﻟﺘﻨﻔﻴﺬ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪27‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻋﻨﺪ ﺣﺪوث ﺧﻄﺄ ﻣﻦ اﻟﻨﻮﻋﻴﻦ اﻷول واﻟﺜﺎﻧﻲ أﻋﻼﻩ ﻓﺄن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻮف ﻻ ﻳﻨﻔﺬ وﺗﻈﻬﺮ‬
‫رﺳﺎﻟﺔ ﺧﻄﺄ ﻳﻤﻜﻦ أن ﺗﻀﻐﻂ اﻟﺰر ) ‪ ( F1‬ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻣﺴﺎﻋﺪﻩ ﺗﻮﺿﺢ ﻣﺎهﻴﺔ اﻟﺨﻄﺄ ‪,‬‬
‫آﺬﻟﻚ ﻓﺄن ﻣﺆﺷﺮ ﻋﻠﻰ ﺷﻜﻞ ﺷﺮﻳﻂ أﺣﻤﺮ ﻳﻈﻬﺮ ﻓﻲ اﻷﻋﻠﻰ ﻳﺒﻴﻦ رﻗﻢ اﻟﺨﻄﺄ ‪ ,‬وﻣﺆﺷﺮ‬
‫ﻋﻠﻰ ﺷﻜﻞ ﺷﺎرﺣﻪ ﻳﺆﺷﺮ ﻋﻠﻰ ﻣﻮﻗﻊ اﻟﺨﻄﺄ أو اﻟﺴﻄﺮ اﻟﺬي ﺑﻌﺪﻩ أﺣﻴﺎﻧﺎ ‪.‬‬

‫ﺟﺪول ) ‪ : ( 2.1‬اﻟﺮﻣﻮز اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫ﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻗﻴﻤﺘﻴﻦ ‪ ,‬ﺗﺴﺘﺨﺪم أﻳﻀﺎ ﻷﺗﺤﺎد‬
‫ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ ‪ ,‬وﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫ﺗﺴﺘﺨﺪم ﻟﻄﺮح ﻗﻴﻤﺘﻴﻦ ‪ ,‬ﺗﺴﺒﻖ اﻟﻘﻴﻢ ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ‬
‫أن اﻟﻘﻴﻢ ﺳﺎﻟﺒﻪ ‪ ,‬وﺗﺴﺘﺨﺪم ﻟﻠﻔﺮق ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ‪,‬‬
‫وآﺬﻟﻚ ﻟﺘﻘﺎﻃﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
‫وﺗﻜﻮن اﻟﻨﺘﻴﺠﻪ ﻗﻴﻤﻪ آﺴﺮﻳﻪ‬
‫ﺗﺴﺘﺨﺪم ﻟﻔﺤﺺ اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷﺻﻐﺮ‬
‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ‬
‫)‬

‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
‫ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﻤﻦ (‬
‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
‫) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
‫ﺗﺴﺘﺨﺪم ﻓﻲ أﺧﺘﻴﺎر ﺣﻘﻞ ﻟﻤﺘﻐﻴﺮ اﻟﻘﻴﻮد ‪ ,‬وﺗﺄﺗﻲ ﺑﻌﺪ‬
‫اﻷﻣﺮ ) ‪ ( end‬ﻷﻧﻬﺎء اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﻮاﻣﻞ ) ‪ (arguments‬وﻟﻔﺼﻞ‬
‫اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ‬
‫ﻣﺪﻳﺎت اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬
‫ﺗﺴﺘﺨﺪﻣﺎن ﻟﻔﺼﻞ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ‬
‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ أﺳﻢ اﻟﺪاﻟﻪ ﻋﻦ ﻧﻮﻋﻬﺎ‬
‫ﻋﻨﺪ ﺗﻌﺮﻳﻔﻬﺎ‬

‫)‪(PLUS‬‬
‫ﻋﻼﻣﺔ اﻟﺠﻤﻊ‬
‫)‪(MINUS‬‬
‫ﻋﻼﻣﺔ اﻟﻄﺮح‬
‫)‪(ASTERISK‬‬
‫ﻋﻼﻣﺔ اﻟﻀﺮب‬
‫)‪(SLASH‬‬
‫ﻋﻼﻣﺔ اﻟﻘﺴﻤﻪ‬
‫)‪(EQUAL‬‬
‫ﻋﻼﻣﺔ اﻟﻤﺴﺎواة‬
‫)‪(LESS THAN‬‬
‫أﻗﻞ ﻣﻦ‬
‫)‪(GREATER THAN‬‬
‫أآﺒﺮ ﻣﻦ‬
‫)‪(LEFT BRACKET‬‬
‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﺴﺮ‬
‫)‪(RIGHT BRACKET‬‬
‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﻤﻦ‬
‫)‪(PERIOD‬‬
‫اﻟﻨﻘﻄﻪ‬
‫)‪(COMMA‬‬

‫‪+‬‬
‫‬‫*‬
‫‪/‬‬
‫=‬
‫<‬
‫>‬
‫[‬
‫]‬
‫‪.‬‬
‫‪,‬‬

‫اﻟﻔﺎرزﻩ‬
‫)‪(COLON‬‬
‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن‬

‫‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﺒﺎرات ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
‫ﺑﺎﺳﻜﺎل‬
‫ﺗﺴﺘﺨﺪم ﻟﺘﻌﺮﻳﻒ اﻷﻧﻮاع واﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع‬
‫ﻣﺆﺷﺮ وﺗﺴﺘﺨﺪم ﻟﻠﻮﺻﻮل اﻟﻰ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺘﻐﻴﺮات ﻣﻦ‬
‫ﻧﻮع ﻣﺆﺷﺮ وآﺬﻟﻚ ﻣﺤﺘﻮﻳﺎت اﻟﻔﺎﻳﻼت‬
‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻷﺟﺮاءات ) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ‬
‫اﻟﻘﻮس اﻷﻳﻤﻦ (‬
‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻟﺮوﺗﻴﻨﺎت اﻟﻔﺮﻋﻴﻪ ) ﺑﺎﻷﺷﺘﺮاك‬
‫ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
‫أﺧﺘﺒﺎر ﻋﺪم اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬

‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ ‪ ,‬و أﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ‬
‫اﻟﺠﺰﺋﻴﻪ‬
‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ‪ ,‬وأﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ اﻟﺸﺎﻣﻠﻪ‬
‫) ‪( superset‬‬
‫ﺗﺴﺘﺨﺪم ﻷﺳﻨﺎد ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات‬
‫ﺗﻔﺼﻞ‬

‫‪28‬‬

‫)‪(SEMI-COLON‬‬
‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ‬
‫)‪(POINTER‬‬
‫اﻟﻤﺆﺷﺮ‬
‫‪(LEFT‬‬
‫)‪PARENTHESIS‬‬
‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﺴﺮ‬
‫‪(RIGHT‬‬
‫)‪PARENTHESIS‬‬
‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﻤﻦ‬
‫‪( LESS THAN /‬‬
‫) ‪GREATER THAN‬‬
‫ﻋﺪم اﻟﻤﺴﺎواة‬
‫‪(LESS THAN /‬‬
‫)‪EQUAL‬‬
‫أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬
‫‪(GREATER THAN /‬‬
‫)‪EQUAL‬‬
‫أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬
‫)‪(COLON / EQUAL‬‬
‫اﻟﻤﺴﺎواة‬
‫)‪(PERIOD / PERIOD‬‬
‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﺠﺎورﺗﺎن‬

‫;‬
‫^‬

‫(‬

‫)‬

‫><‬

‫=<‬

‫=>‬

‫=‪:‬‬
‫‪..‬‬

‫ﺟﺪول ) ‪ : ( 2.2‬اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫ﻣﻌﺎﻣﻞ اﻟﺮﺑﻂ اﻟﻤﻨﻄﻘﻲ‬
‫ﻧﻮع اﻟﻤﺼﻔﻮﻓﻪ‬
‫ﻋﺒﺎرة اﻟﺒﺪأ‬
‫ﻋﺒﺎرة اﻟﺒﺪأ ) ﻓﻲ ﺣﺎﻟﺔ ( ) ‪( case‬‬
‫ﺗﻌﺮﻳﻒ اﻟﺜﻮاﺑﺖ‬
‫ﺗﻘﺴﻴﻢ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ وﻧﺘﻴﺠﺘﻬﺎ أﻳﻀﺎ أﻋﺪاد ﺻﺤﻴﺤﻪ‬
‫ﺗﺘﺒ ﻊ أواﻣ ﺮ اﻟﺘﻜ ﺮار ) ‪ ( For , While‬وﺗ ﺴﺒﻖ اﻻﻓﻌ ﺎل اﻟﺘ ﻲ ﻳﺠ ﺐ أن‬
‫ﺗﻨﻔﺬ‬
‫ﺗﺴﺘﺨﺪم ﻣﻊ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( For‬وﺗﺪل ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﻘﻞ ﻓﻲ آﻞ‬

‫‪AND‬‬
‫‪ARRAY‬‬
‫‪BEGIN‬‬
‫‪CASE‬‬
‫‪CONST‬‬
‫‪DIV‬‬
‫‪DO‬‬
‫‪DOWNTO‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪29‬‬

‫دورﻩ‬
‫ﺗﺴﺘﺨﺪم ﻣﻊ ) ‪ , ( If‬ﺣﻴﺚ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺪ ) ‪( if‬‬
‫ﺧﻄﺄ ) ‪ ( false‬ﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪( else‬‬

‫‪ELSE‬‬

‫ﻧﻬﺎﺑﺔ اﻟﻌﺒﺎرات اﻟﻤﺮآﺒﻪ اﻟﺘﻲ ﺗﺒﺪأ ﺑﺎﻷﻣﺮ اﺑﺪأ ) ‪ , ( begin‬أو ﻧﻬﺎﻳﻪ‬
‫) ‪( record‬‬
‫اﻷﻣﺮ ) ‪ ( case‬أو ﻧﻬﺎﻳﻪ ﺗﻌﺮﻳﻒ اﻟﻘﻴﻮد‬
‫ﺗﻌﺮف ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻠﻒ‬
‫ﺗﻨﻔﺬ ﺳﻄﺮ أو أآﺜﺮ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻃﺎﻟﻤﺎ اﻟﻤﺘﻐﻴﺮ ﻟﻢ‬
‫ﻳﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺘﻪ‬
‫ﺗﻌﺮف داﻟﺔ ﺑﺎﺳﻜﺎل‬

‫‪END‬‬

‫ﺗﻔﻴﺪ ﻟﻠﺘﻔﺮع اﻟﻰ ﻋﻨﻮان ﻣﺤﺪد ) ‪( label‬‬

‫‪FILE‬‬
‫‪FOR‬‬
‫‪FUNCTION‬‬
‫‪GOTO‬‬

‫ﺗﻔﺤﺺ ﺷﺮط ﻣﻨﻄﻘﻲ وﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ أذا آﺎن اﻟﺸﺮط ﺻﺢ ) ‪( true‬‬

‫‪IF‬‬

‫ﺗﺤﺪد اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﻋﻠﻰ أﻧﻪ ﺻﺢ ) ‪ ( true‬أذا آﺎﻧﺖ اﻟﻘﻴﻤﻪ‬
‫اﻟﻤﻔﺤﻮﺻﻪ ﺿﻤﻦ ﻣﺠﻤﻮﻋﻪ ﺧﺎﺻﻪ‬

‫‪IN‬‬

‫ﺗﺤﺪد اﻟﻌﻨﻮان اﻟﺬي ﺳﻴﺘﻢ اﻟﺘﻔﺮع ﻟﻪ ﻋﻨﺪ اﺳﺘﺨﺪام اﻷﻣﺮ ) ‪( Goto‬‬
‫ﻟﺤﺴﺎب ﺑﺎﻗﻲ ﻗﺴﻤﺔ ﻋﺪدﻳﻦ‬
‫اﻟﻘﻴﻤﻪ اﻟﺨﺎﻟﻴﻪ ﻟﻠﻤﺆﺷﺮات ) ‪( pointers‬‬
‫ﻟﻨﻔﻲ ﻗﻴﻢ اﻟﻌﺒﺎرات اﻟﻤﻨﻄﻘﻴﻪ‬
‫ﺗﺴﺘﺨﺪم ﻓﻲ ﻋﺒﺎرة ) ‪ (case‬ﺑﻌﺪ ﻣﺘﻐﻴﺮ ) ‪( case‬‬
‫ﻣﻌﺎﻣﻞ اﻷﺧﺘﻴﺎر اﻟﻤﻨﻄﻘﻲ ) أو (‬
‫ﻳﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت ‪ ,‬اﻟﻤﻠﻔﺎت ‪ ,‬اﻟﻘﻴﻮد ‪ ,‬واﻟﻤﺠﻤﻮﻋﺎت‬
‫ﻟﻀﻐﻂ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺰﻧﻪ‬
‫ﺗﻌﺮف اﻟﺮوﺗﻴﻦ اﻟﻔﺮﻋﻲ ﻓﻲ ﺑﺎﺳﻜﺎل‬
‫ﻳﺴﺘﺨﺪم ﻓﻲ ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ) رأس اﻟﺒﺮﻧﺎﻣﺞ (‬
‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع اﻟﻘﻴﻮد‬
‫ﻟﻠﺒﺪأ ﺑﺄﻣﺮ اﻟﺘﻜﺮار ) ‪(repeat‬‬
‫ﻟﺘﻌﺮﻳﻒ اﻟﻤﺠﻤﻮﻋﺎت‬
‫ﺗﻠﻲ اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺒﺎرة ) ‪( IF‬‬
‫ﺗﺴﺘﺨﺪم ﻓﻲ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( for‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﺰداد ﻓﻲ آﻞ‬
‫دورﻩ ﺑﻤﻘﺪار واﺣﺪ‬
‫ﻟﻠﺘﺼﺮﺳﺢ ﻋﻦ ﻧﻮع ﺟﺪﻳﺪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات‬
‫ﻳﺴﺘﺨﺪم ﻷﻧﻬﺎء ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪( repeat‬‬
‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮات اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻳﻨﻔﺬ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻟﺤﻴﻦ أن ﻳﺼﺒﺢ اﻟﺸﺮط ) ‪( False‬‬
‫ﻟﺘﺤﺪﻳﺪ ﻣﺘﻐﻴﺮ ﻗﻴﺪ ﻳﺴﺘﺨﺪم ﻣﻊ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ‬

‫‪LABEL‬‬
‫‪MOD‬‬
‫‪NIL‬‬
‫‪NOT‬‬
‫‪OF‬‬
‫‪OR‬‬
‫‪PACKED‬‬
‫‪PROCEDURE‬‬
‫‪PROGRAM‬‬
‫‪RECORD‬‬
‫‪REPEAT‬‬
‫‪SET‬‬
‫‪THEN‬‬
‫‪TO‬‬
‫‪TYPE‬‬
‫‪UNTIL‬‬
‫‪VAR‬‬
‫‪WHILE‬‬
‫‪WITH‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

30

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬

2.6

. ‫ ( اﻟﻰ ﻣﺎ ﻳﻘﺎﺑﻠﻬﺎ ﺑﺎﻟﺴﺎﻋﺎت واﻟﺪﻗﺎﺋﻖ واﻟﺜﻮاﻧﻲ‬42200 sec ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ‬
Program CH2_Program5;
Var
Hour, min, sec, temp: integer;
Begin
Sec:=42200 mod 60;
Temp:=42200 div 60;
Min:=temp mod 60;
Hour: = temp div 60;
Writeln ('hour=', hour,'min=', min,'sec=', sec);
End.

y = 4x2 + 3x - 6

‫ ( ﻣﻦ اﻟﻤﻌﺎدﻟﻪ‬y ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬

Program CH2_Program6;
Var
X,y:integer;
Begin
X: =6;
Y: =4*sqr(x) +3*x-6;
Writeln(y);
End.

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ درﺟﺔ ﺣﺮارﻩ ﻣﻘﺎﺳﻪ ﺑﺎﻟﻔﻬﺮﻧﻬﺎﻳﺖ اﻟﻰ درﺟﻪ ﻣﺌﻮﻳﻪ‬
Program CH2_Program7;
Var
F:integer;
C: real;
Begin
Writeln ('Enter temerature degree in fehrnhite ');
Readln (f);
C :=( 5/9)*(f+32);
Writeln(c);
End.

31

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺴﺎﺣﺔ وﻣﺤﻴﻂ داﺋﺮﻩ‬
Program CH2_Program8;
Var
R: integer;
Area, perimeter: real;
Begin
writeln ('Enter circle radius');
Readln(r);
Area: =sqr(r)*pi;
Perimeter: =2*r*pi;
writeln ('area= ',area,'perimeter= ',perimeter);
End.

. ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﺣﺎﺻﻞ ﺿﺮب وﻣﻌﺪل ﺛﻼث أرﻗﺎم‬

Program CH2_Program9;
Var
Prod, a, b, c: integer;
Average: real;
Begin
Writeln ('Enter three numbers');
Readln (a, b, c);
Prod: = a*b*c;
Average :=( a + b + c)/3;
Writeln ('prod= ', prod);
Writeln ('averge= ', average);
End.

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪32‬‬

‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬
‫أﻳﻌﺎزات اﻟﻘﺮار واﻟﺘﻜﺮار‬
‫‪DECISION AND REPEAT INSTRUCTIONS‬‬
‫‪3.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫اﻷن ﺟ ﺎء دور دراﺳ ﺔ اﻟﻘﻮاﻋ ﺪ اﻷآﺜ ﺮ أهﻤﻴ ﻪ ﻓ ﻲ اﻟﺒﺮﻣﺠ ﻪ ‪ .‬وه ﻲ أﻳﻌ ﺎزات اﻟﻘ ﺮار‬
‫) ‪ ( If statement‬وآ ﺬﻟﻚ اﻷﻳﻌ ﺎز اﻟﻤﺮاﻏ ﻒ ﻟﻬ ﺎ ) ‪ ( Else‬وﻋﺒ ﺎرات اﻟﺘﻜ ﺮار واﻟﺘ ﻲ ه ﻲ‬
‫)‪ .( For loops , Repeat .. Until loop, While loop‬ﻏﺎﻟﺒ ﺎ ﺗﻌﺘﺒ ﺮ ه ﺬﻩ اﻷواﻣ ﺮ ﻣ ﻦ اﻷواﻣ ﺮ‬
‫اﻟﻜﺜﻴﺮة اﻷﺳﺘﺨﺪام ﻓﻲ اﻟﺒﺮﻣﺠﻪ ﻟﺬا ﻧﻨ ﺼﺢ ﺑﻌ ﺪ اﻷﻧﺘﻬ ﺎء ﻣ ﻦ دراﺳ ﺔ ه ﺬا اﻟﻔ ﺼﻞ اﻟ ﺸﺮوع ﺑﻜﺘﺎﺑ ﺔ ﺑ ﺮاﻣﺞ‬
‫ﺗﺴﺘﺨﺪم ﻓﻴﻬﺎ هﺬﻩ اﻟﻘﻮاﻋﺪ وزﻳﺎدة اﻟﺨﺒﺮﻩ اﻟﻌﻤﻠﻴﻪ ﻗﺒﻞ اﻷﻧﺘﻘﺎل اﻟﻰ ﻣﻮﺿﻮع ﺟﺪﻳﺪ‪.‬‬
‫‪3.2‬‬

‫ﻋﺒﺎرة أذا ‪IF STATEMENT‬‬

‫ﻳﺴﺘﺨﺪم هﺬا اﻷﻣﺮ ﺑﺎﻟﺘﺮاﻓﻖ ﻣﻊ ) ‪ ( then‬آﻤﺎ ﺳﻨﻮﺿﺢ وهﻮ ﻳﻔﻴﺪ ﻷﺗﺨﺎذ ﻗﺮار ﻣﻦ ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ‬
‫ﺑﻨﺎءا ﻋﻠﻰ ﺑﻌﺾ اﻟﻤﻌﻄﻴﺎت اﻟﺘﻲ ﺗﺮد ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬هﻨﺎك اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺤﺎﻻت اﻟﺘﻲ ﻻﻳﻤﻜﻦ اﻟﺘﻨﺒﺄ ﺑﻬﺎ ﻣ ﻦ‬
‫ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم أﺛﻨﺎء آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻓﻌﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل أﻧﻨﺎ ﻧﻜﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻷﻋﺪاد‬
‫ﺻﺤﻴﺤﻪ ﻳﺘﻢ أدﺧﺎﻟﻬ ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤ ﺴﺘﺨﺪم أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ﻓ ﻲ ه ﺬﻩ اﻟﺤﺎﻟ ﻪ وآﻤ ﺎ ﻣﻌﻠ ﻮم ﻓ ﺄن اﻟﻌ ﺪد‬
‫اﻟﺼﺤﻴﺢ ﻳﺠ ﺐ أن ﻳﻜ ﻮن ﻣﻮﺟ ﺐ ﻷﻧ ﻪ ﻻﻳﻤﻜ ﻦ أﻳﺠ ﺎد اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ ﻟﻠﻌ ﺪد اﻟ ﺴﺎﻟﺐ ‪ ,‬اﻟ ﺴﺆال هﻨ ﺎ ه ﻞ‬
‫ﻳﻤﻜﻦ ﻣﻨﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ أدﺧﺎل ﻋﺪد ﺳﺎﻟﺐ ﺳﻮاء آﺎن ﺑﻘﺼﺪ أو ﺳﻬﻮا ‪ ,‬أن اﻟﻤﺒﺮﻣﺞ ﺳﻮف ﻻﻳﺠ ﺪ وﺳ ﻴﻠﻪ‬
‫أﺛﻨﺎء آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ﻟﻤﻌﺎﻟﺠﺔ هﺬا اﻷﺷ ﻜﺎل اﻟﺒ ﺴﻴﻂ أﻻ أن ﻳ ﺴﺘﺨﺪم ﻋﺒ ﺎرة اﻟﻘ ﺮار) أذا ( واﻟﺘ ﻲ ﻣﻤﻜ ﻦ أن‬
‫ﺗﻜﻮن آﻤﺎ ﻳﻠﻲ ) أذا آﺎن اﻟﻌﺪد ﻣﻮﺟ ﺐ أوﺟ ﺪ اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ وﺑﺨ ﻼف ذﻟ ﻚ أهﻤﻠ ﻪ ( ‪) ..‬وﺑﺎﻟﺘﺄآﻴ ﺪ ﻓ ﺄن‬
‫اﻟﻤﺘﺮﺟﻢ ﻓ ﻲ اﻟﺤﺎﺳ ﻮب ﻻ ﻳﻔﻬ ﻢ ﻋﺒ ﺎرة ﻣﻮﺟ ﺐ ﻟ ﺬا ﻧ ﺴﺘﺒﺪﻟﻬﺎ ﺑﻤ ﺎ ﻳﺘﻨﺎﺳ ﺐ وﻗﻮاﻋ ﺪ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل‬
‫ﻓﻨﻘﻮل أذا آﺎن اﻟﻌﺪد أآﺒﺮ أو ﻳﺴﺎوي ﺻﻔﺮ ﻓﺄوﺟﺪ اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ (‪.‬‬
‫أن أﺳﺘﺨﺪام ﻋﺒﺎرة ) ‪ ( If‬ﻳﻜﻮن آﻤﺎ ﻳﻠﻲ ) أذا )ﺷ ﺮط( ﻋﻠﻴ ﻪ ( ‪ ( if condition then ) ..‬أذا‬
‫ﺗﺤﻘﻖ اﻟﺸﺮط اﻟﺬي ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( If‬ﻓﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( then‬أﻣﺎ أذا ﻟ ﻢ ﻳﺘﺤﻘ ﻖ ه ﺬا اﻟ ﺸﺮط‬
‫ﻓﻴﻬﻤﻞ ﻣﺎ ﺑﻌﺪ ) ‪ ( then‬أذن ﺳﺘﻜﻮن ﻃﺮﻳﻘﺔ آﺘﺎﺑﻪ هﺬا اﻷﻣﺮ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫} ‪If conditional expression true then code ... ;{if one action‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻ ﺗﻮﺟﺪ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( If‬أو ) ‪ ( then‬ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ‪.‬‬

‫ﻣﻤﻜﻦ ﻣﺜﻼ أن ﻧﻄﻠﺐ ﻣﻦ أﺣﺪهﻢ ﻋﻤﻼ وﻧﻘ ﻮل ﻟ ﻪ ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘﻮﺣ ﺎ ﻓﺄﺟﻠ ﺐ ﻟ ﻲ ﺷ ﺮاب‬
‫اﻟﺒﺒ ﺴﻲ ( ) ‪ ( If shop open then get me pepsi‬ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﻣﻤﻜ ﻦ ﺻ ﻴﺎﻏﺘﻬﺎ ﺑﺮﻣﺠﻴ ﺎ‬
‫آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪33‬‬

‫‪If shopopen then‬‬
‫; ‪Drink : = pepsi‬‬
‫ﻧﻼﺣﻆ ﻓﻲ هﺬا اﻟﻤﺜﺎل أن اﻟﻔﻌﻞ اﻟﻤﻄﻠ ﻮب أﻧﺠ ﺎزﻩ ه ﻮ ) واﺣ ﺪ أن ﻳﺠﻠ ﺐ ﻟﻨ ﺎ ﺷ ﺮاب اﻟﺒﺒ ﺴﻲ ( ‪.‬‬
‫أﻣﺎ أذا آﺎن ﻣﺎ ﻣﻄﻠﻮب أﻧﺠﺎزﻩ هﻮ أآﺜﺮ ﻣﻦ ﻓﻌﻞ واﺣﺪ ﻓﺄن اﻟﺼﻴﻐﻪ ﺳﺘﺨﺘﻠﻒ ﻗﻠﻴﻼ ‪:‬‬
‫‪If conditional expression true then‬‬
‫‪Begin‬‬
‫‪instructions ...‬‬
‫}‪{if more than one action is required‬‬

‫;‪End‬‬

‫ﻣ ﺎذا ﻳﻌﻨ ﻲ ذﻟ ﻚ أن اﻷﻣ ﺮ ) ‪ ( If‬ﻳﻨﻔ ﺬ ﻋﺒ ﺎرﻩ واﺣ ﺪﻩ ﺗ ﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬واﻟﺘ ﻲ ﺗﻤﺜ ﻞ اﻟﻔﻌ ﻞ‬
‫اﻟﻤﻄﻠﻮب أﻧﺠﺎزﻩ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط ‪ ,‬أﻣﺎ أذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ ﻓﻌ ﻞ واﺣ ﺪ ﻣﻄﻠ ﻮب أﻧﺠ ﺎزﻩ ﻋﻨ ﺪ ﺗﺤﻘ ﻖ‬
‫اﻟ ﺸﺮط ﻓﻴﺠ ﺐ أن ﻧﺤ ﺪد ه ﺬﻩ اﻷﻓﻌ ﺎل ﻟﻠﻤﺘ ﺮﺟﻢ وﻳﻜ ﻮن ذﻟ ﻚ ﺑ ﺄن ﻧﺤ ﺪدهﺎ ﺑ ﻴﻦ اﻷﻣ ﺮﻳﻦ‬
‫) )‪ (begin‬و )‪ ( (end‬وﺑﺬﻟﻚ ﺳﻴﻜﻮن واﺿﺢ أن اﻷﻓﻌﺎل اﻟﻤﻄﻠﻮب ﺗﻨﻔﻴﺬهﺎ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟ ﺸﺮط ﺗﺒ ﺪأ ﺑﻌ ﺪ‬
‫اﻷﻣﺮ ) ‪ ( begin‬وﺗﻨﺘﻬﻲ ﺑﺎﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﻗﺒﻞ ) ‪ ( end‬ﻣﻊ ﻣﻼﺣﻈﺔ أن ) ‪ ( end‬ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ‪.‬‬
‫ﻟﻨﻌﺪ اﻟﻰ اﻟﻤﺜ ﺎل اﻟ ﺴﺎﺑﻖ وﻧﻄﻠ ﺐ ﻣ ﻦ أﺣ ﺪهﻢ ﻋﻤ ﻼ وﻧﻘ ﻮل ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح ﻓﺄﺟﻠ ﺐ ﻟ ﻲ‬
‫ﺷﺮاب اﻟﺒﺒﺴﻲ وﻋﻠﺒﺔ ﺳﻜﺎﺋﺮ آﻨﺖ ( ) ‪( if shop open get me pepsi and kent cigrates‬‬
‫اﻟﻔﻌﻞ اﻟﻤﻄﻠﻮب أﻧﺠﺎزﻩ هﻨﺎ هﻮ أآﺜﺮ ﻣﻦ واﺣﺪ ﺣﻴﺚ اﻟﻤﻄﻠﻮب ﺟﻠﺐ ﺷﺮاب اﻟﺒﺒﺴﻲ وﺳﻜﺎﺋﺮ ﻣﻦ‬
‫ﻧﻮع آﻨﺖ ‪ .‬ﻟﺬا ﺳﺘﻜﻮن ﺻﻴﺎﻏﺔ هﺬﻩ اﻟﻌﺒﺎرﻩ ﺑﺮﻣﺠﻴﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪If shopopen then‬‬
‫‪Begin‬‬
‫; ‪Drink : = pepsi‬‬
‫; ‪Smook : = kent‬‬
‫; ‪End‬‬
‫ﻓ ﻲ ﺣﺎﻟ ﺔ ﻋ ﺪم وﺿ ﻊ ) ‪ ( begin , end‬ﻓ ﺎن أول ﻋﺒ ﺎرﻩ ﺳ ﺘﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬ه ﻲ اﻟﺘ ﻲ‬
‫ﺳﺘﻌﺎﻣﻞ ﻋﻠﻰ أﻧﻬﺎ ﺗﻌﻮد اﻟﻰ اﻷﻣﺮ ) ‪ ( If‬وﺗﻨﻔﺬ ﻓﻲ ﺣﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط وهﻲ هﻨﺎ ﺳﺘﻜﻮن ) ‪ ( drink‬أﻣﺎ‬
‫أﺳ ﺘﺨﺪام ) ‪ ( begin , end‬ﻓﻬ ﻲ دﻻﻟ ﻪ ﻟﻠﻤﺘ ﺮﺟﻢ ﻋﻠ ﻰ أن ﻣﺠﻤﻮﻋ ﺔ اﻷﻳﻌ ﺎزات اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬هﻲ ﺟﻤﻴﻌﺎ ﻣﻄﻠﻮب ﺗﻨﻔﻴﺬهﺎ أذا ﻣﺎ ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻋﻨﺪ اﻟﺤﺎﺟﻪ ﻷﺳﺘﺨﺪام اﻟﻤﺴﺎواة ﻓﻲ اﻟﺸﺮط ﺑﻌﺪ ) ‪ ( If‬ﻓﻼ ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎواة اﻟﻤﺴﺒﻮﻗﻪ‬
‫ﺑﻨﻘﻄﺘﻴﻦ ) = ‪ ( assignment ) ( :‬وأﻧﻤﺎ ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎواة اﻷﻋﺘﻴﺎدﻳﻪ ) = ( ﻷن أﺳﺘﺨﺪام‬
‫اﻷوﻟﻰ ﺳﻴﺆدي اﻟﻰ ﻋﺪم أآﻤﺎل اﻟﺘﻨﻔﻴﺬ وﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪34‬‬

‫هﻨﺎك ﺣﺎﻟﻪ أﺧﺮى ﻋﻨﺪ أﺳﺘﺨﺪام ) ‪ , ( If‬هﻮ أﺳﺘﺨﺪاﻣﻬﺎ ﻷﺧﺘﻴﺎر ﻓﻌﻞ واﺣﺪ ﻣ ﻦ أﺛﻨ ﻴﻦ ﻓﻤ ﺜﻼ ﻓ ﻲ‬
‫ﻣﺜﺎﻟﻨ ﺎ اﻟ ﺴﺎﺑﻖ ﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن اﻟﻄﻠ ﺐ آﻤ ﺎ ﻳﻠ ﻲ ) أذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘﻮﺣ ﺎ ﻓﺄﺟﻠ ﺐ ﻟ ﻲ ﺷ ﺮاب اﻟﺒﺒ ﺴﻲ‬
‫ﻮﻩ (‬
‫ﻲ ﻗﻬ‬
‫ﻞﻟ‬
‫ﻖ ( ﻓﺄﻋﻤ‬
‫ﻞ ﻣﻐﻠ‬
‫ﺎن اﻟﻤﺤ‬
‫ﻚ ) أي أذا آ‬
‫ﻼف ذﻟ‬
‫وﺑﺨ‬
‫) ‪ ( If shop open then get me pepsi otherwise get me a coffee‬ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ﺗﻨﻔ ﺬ‬
‫ﺑﺮﻣﺠﻴﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪If shopopen then‬‬
‫‪Drink : = pepsi‬‬
‫‪Else‬‬
‫; ‪Drink : = coffee‬‬
‫ﻟﻨﻼﺣﻆ هﻨﺎ أن اﻟﺸﺮط اﻟﺬي ﺑﻌﺪ ) ‪ ( If‬أﻣﺎ أن ﻳﻜﻮن )ﺻﺢ ‪ ,‬أو ﺧﻄ ﺄ ( ) ‪( true OR false‬‬
‫أي أﻣﺎ أن ﻳﻜﻮن اﻟﻤﺤﻞ ﻣﻔﺘﻮح أو ﻣﻐﻠﻖ وﻻ ﻳﻮﺟﺪ أﺣﺘﻤ ﺎل أﺧ ﺮ‪ .‬ﻓ ﺄذا آ ﺎن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح ﻓ ﺎﻟﻤﻄﻠﻮب أن‬
‫ﻳﺠﻠﺐ ﺷﺮاب وهﻮ اﻟﺒﺒﺴﻲ ﻓﻲ ﺧﻼف ذﻟﻚ ) ‪ ( else‬أي أذا آﺎن اﻟﻤﺤﻞ ﻣﻐﻠﻖ ﻓﻠﻴﻜﻦ اﻟ ﺸﺮاب ه ﻮ ﻗﻬ ﻮﻩ ‪.‬‬
‫اﻟﻤﻼﺣﻈﻪ اﻟﻤﻬﻤﻪ هﻨ ﺎ ه ﻲ أﻧ ﻪ ﻻﻳﻤﻜ ﻦ أن ﻳﻨﻔ ﺬ اﻟﻌﻤ ﻼن ﺳ ﻮﻳﺔ أي ﻻ ﻳﻤﻜ ﻦ أن ﻳﺠﻠ ﺐ ﺑﺒ ﺴﻲ وﻗﻬ ﻮﻩ ﻓ ﻲ‬
‫ﻧﻔ ﺲ اﻟﻮﻗ ﺖ واﻟ ﺴﺒﺐ ه ﻮ أﻧ ﻪ ﻻﻳﻤﻜ ﻦ أن ﻳﻜ ﻮن اﻟﻤﺤ ﻞ ﻣﻔﺘ ﻮح وﻣﻐﻠ ﻖ ﺑ ﺬات اﻟﻮﻗ ﺖ ‪ .‬ﻋﻠﻴ ﻪ ﻓ ﺄذا ﺗﺤﻘ ﻖ‬
‫اﻟﺸﺮط ) أي اﻟﺸﺮط ﺻﺢ ﺑﻤﻌﻨﻰ أن اﻟﻤﺤﻞ ﻣﻔﺘﻮح ( ﻓ ﺄن اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺗ ﺄﺗﻲ ﺑﻌ ﺪ ) ‪ ( then‬ﺳ ﺘﻨﻔﺬ ﺑﻴﻨﻤ ﺎ‬
‫اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( else‬ﺳﺘﻬﻤﻞ ‪ ,‬أﻣﺎ أذا آﺎن اﻟﺸﺮط ﻏﻴﺮ ﻣﺘﺤﻘﻖ ) أي أﺟﺎﺑﺔ اﻟ ﺸﺮط ﺧﻄ ﺄ ﺑﻤﻌﻨ ﻰ أن‬
‫اﻟﻤﺤﻞ ﻣﻐﻠﻖ ( ﻓﺄن اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( If‬ﺳﺘﻬﻤﻞ وﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪. ( else‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫داﺋﻤﺎ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺗﺴﺒﻖ ) ‪ ( else‬ﻣﺒﺎﺷﺮة ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ ﻓﺎرزﻩ ﻣﻨﻘﻮﻃﻪ ) ﺗﺤﺬف(‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺟﺰء ﻣﻦ ﻟﻌﺒﻪ ﺑﺎﻣﻜﺎﻧﻚ ان ﺗﻀﻴﻒ أﻟﻴﻬﺎ أﺳ ﺌﻠﻪ أﺧ ﺮى ﻟﺘﻜ ﻮن ﻟﻌﺒ ﻪ‬
‫ﻣﺘﻜﺎﻣﻠﻪ ‪:‬‬
‫;)'?‪Writeln ('Who has discovered the land of America‬‬
‫;)‪Readln (ans‬‬
‫‪If (ans = 'Christopher Columbus') then‬‬
‫‪score := score + 1‬‬
‫}‪{if this is false,‬‬
‫‪ELSE‬‬
‫;)'!‪Writeln ('sorry, you've got it wrong‬‬
‫}‪{then this is true‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪3.3‬‬

‫‪35‬‬

‫أذا اﻟﻤﺮآﺒﻪ ‪COMPOUND IF‬‬

‫ﻣﻤﻜﻦ أن ﻧ ﺴﺘﺨﺪم ) ‪ ( If‬ﺑ ﺸﻜﻞ ﻣﺘ ﺪاﺧﻞ ﻣ ﻊ ) ‪ (If OR else‬أﺧ ﺮى ‪ ,‬وﺑﻬ ﺬﻩ اﻟﺤﺎﻟ ﻪ ﺗ ﺴﻤﻰ‬
‫ﻣﺮآﺒﻪ ) أي ﻣﻤﻜﻦ أن ﻳﻜﻮن ﺑﻌﺪ ) ‪ ( then‬ﻋﺒﺎرﻩ ) ‪ ( If‬وﻣﻤﻜﻦ أﻳﻀﺎ ﺑﻌﺪ ﻋﺒ ﺎرة ) ‪ ( else‬وﻣﻤﻜ ﻦ أن‬
‫ﺗﻜ ﻮن أآﺜ ﺮ ﻣ ﻦ واﺣ ﺪﻩ ‪ .‬ﻓﻤ ﺜﻼ ﻧﺮﻳ ﺪ أن ﻧﻔﺤ ﺺ ﻧﻮﻋﻴ ﺔ رﻣ ﺰ ﻣﻌ ﻴﻦ ووﻓﻘ ﺎ ﻟ ﺬﻟﻚ ﻧﻘ ﺮر ﻣ ﺎهﻮ اﻷﺟ ﺮاء‬
‫اﻟﻮاﺟﺐ أﺗﺒﺎﻋﻪ وآﻤﺎﻳﻠﻲ ‪:‬‬
‫‪If ( charkind = digit ) then‬‬
‫‪Readnumber‬‬
‫‪Else‬‬
‫‪If ( charkind = letter ) then‬‬
‫‪Readname‬‬
‫‪Else‬‬
‫; ‪Reporterror‬‬
‫ﻟﻨﺘﺄﻣﻞ هﺬا اﻟﻤﺜﺎل ﻓﻔﻲ اﻟﺒﺪاﻳﻪ ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط ﻟﻤﻌﺮﻓ ﺔ ﻧ ﻮع اﻟﺮﻣ ﺰ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪( charkind‬‬
‫هﻞ هﻮ رﻗﻢ‬
‫) ‪ ( digit‬أم ﻻ ‪ ,‬وآﻤﺎ ﺗﻌﻠﻤﻨ ﺎ داﺋﻤ ﺎ أن اﻷﺟﺎﺑ ﻪ أﻣ ﺎ ﻧﻌ ﻢ ) ﺻ ﺢ ( أو ﻻ ) ﺧﻄ ﺄ ( وﻻ‬
‫ﻳﻮﺟ ﺪ أﺣﺘﻤ ﺎل أﺧ ﺮ ‪ ,‬ﻓ ﺄذا آ ﺎن ﺻ ﺢ ﻣﻌﻨ ﺎﻩ أن اﻟﺮﻣ ﺰ ﻣ ﻦ ﻧ ﻮع ) ‪ ( digit‬ﻋﻠﻴ ﻪ ﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ‬
‫) ‪ ( then‬ﻣﺒﺎﺷ ﺮة أي أﻗ ﺮأ رﻗ ﻢ ) ه ﺬا اﻷﺣﺘﻤ ﺎل اﻷول ( ‪ ,‬أﻣ ﺎ اﻷﺣﺘﻤ ﺎل اﻟﺜ ﺎﻧﻲ ﻓﺘﻜ ﻮن أﺟﺎﺑ ﺔ اﻟ ﺸﺮط‬
‫ﺧﻄﺄ أي أن ﻧﻮع اﻟﺮﻣﺰ هﻲ ﻟﻴﺴﺖ أرﻗﺎم ﻋﻠﻴ ﻪ ﻓ ﺴﺘﻬﻤﻞ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ ) ‪ ( then‬وﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ‬
‫ﺑﻌﺪ ) ‪ .. ( else‬ﻋﻨﺪﻣﺎ ﻳﺤﻴﻦ اﻟﺪور ﻟﺘﻨﻔﻴﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪ ( else‬ﻧﻼﺣﻆ أن ه ﺬﻩ اﻟﻌﺒ ﺎرﻩ ه ﻲ أﻳ ﻀﺎ‬
‫ﻋﺒﺎرة ) ‪ ( If‬هﺬا ﻳﻌﻨﻲ أﻧﻪ ﻻزال هﻨﺎك أﺣﺘﻤﺎﻻت أﺧﺮى ﻳﺠﺐ أن ﺗﻔﺤﺺ ﻓﻤﻤﻜﻦ أن ﻳﻜ ﻮن اﻟﺮﻣ ﺰ ﻩ و‬
‫) ‪ ( letter‬أو ﺷ ﻲء أﺧ ﺮ وﺗﻄﺒ ﻖ ﻧﻔ ﺲ اﻟﻘﺎﻋ ﺪﻩ ﻓ ﺄذا آﺎﻧ ﺖ أﺟﺎﺑ ﺔ اﻟ ﺸﺮط ﺻ ﺢ ﺗﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ‬
‫) ‪) ( then‬اﻟﺜﺎﻧﻴ ﻪ( أﻣ ﺎ أذا آﺎﻧ ﺖ اﻷﺟﺎﺑ ﻪ ﺧﻄ ﺄ ﻓﺘﻨﻔ ﺬ اﻟﻌﺒ ﺎرﻩ اﻟﺘ ﻲ ﺑﻌ ﺪ ) ‪) ( else‬اﻟﺜﺎﻧﻴ ﻪ( واﻟﺘ ﻲ ه ﻲ‬
‫) ‪( digit OR letter‬‬
‫أﺻﺪار رﺳﺎﻟﺔ ﺧﻄﺄ ) أي أﻋﻼم اﻟﻤﺴﺘﺨﺪم أن هﺬا اﻟﺮﻣﺰ هﻮ ﻟﻴﺲ‬
‫ﻋﺒﺎرات ) ‪ ( If‬هﺬﻩ ﺗﺴﻤﻰ أﻳﻀﺎ ﻋﺒﺎرات ) ‪ ( If‬اﻟﻤﺘﺪاﺧﻠﻪ ) ‪( nested If statements‬‬

‫}‪{if 1‬‬
‫}‪{if 2‬‬
‫}‪{if 2‬‬
‫}‪{if 1‬‬

‫‪If (this happens) then‬‬
‫‪If (this happens) then‬‬
‫‪(do this) etc...‬‬
‫)‪Else (do this‬‬
‫‪Else (do this) etc...‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫داﺋﻤﺎ ﺗﺴﺘﺨﺪم ) ‪ ( If‬ﻋﻨﺪﻣﺎ ﻧﺤﺘﺎج أن ﻧﺨﺘﺎر ﺑﻴﻦ أآﺜﺮ ﻣﻦ ﺣﺎﻟﻪ ) أي أﺧﺘﻴﺎر ﻋﻤﻞ‬
‫أو ﺣﺎﻟﻪ واﺣﺪﻩ ﻣﻦ ﺑﻴﻦ أﺛﻨﻴﻦ أو أآﺜﺮ ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪3.4‬‬

‫‪36‬‬

‫ﻋﺒﺎرة اﻟﺘﻜﺮار ‪REPEAT -- UNTIL LOOP‬‬

‫ﻳ ﺴﺘﺨﺪم ه ﺬا اﻷﻣ ﺮ ﻟﺘﻜ ﺮار ﻋﺒ ﺎرﻩ أو أآﺜ ﺮ ﻟﻌ ﺪد ﻣ ﻦ اﻟﻤ ﺮات وﻓﻘ ﺎ ﻟﻤﺘﻄﻠﺒ ﺎت اﻟﺒﺮﻧ ﺎﻣﺞ واﻟﺘ ﻲ‬
‫ﻳﺤﺪدهﺎ اﻟﻤﺒﺮﻣﺞ ‪ ,‬ﻓﻲ هﺬا اﻷﻣﺮ ﻓﺎن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻨﻔﺬ ﻋﻠﻰ اﻷﻗﻞ ﻟﻤﺮﻩ واﺣ ﺪﻩ ‪ ..‬وﻳﻜ ﻮن ﺗﻮﻗ ﻒ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫أﻋﺘﻤﺎدا ﻋﻠﻰ ﺷﺮط ﻳﻮﺿﻊ ﺑﻌﺪ ) ‪.( until‬‬
‫اﻟﺘﻜ ﺮار ﻳﺒ ﺪأ ﺑ ﺎﻷﻣﺮ ) أﻋ ﺪ أو آ ﺮر ( ) ‪ ( Repeat‬ﺛ ﻢ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات اﻟﻤﻄﻠ ﻮب‬
‫ﺗﻜﺮارهﺎ وﺗﻨﺘﻬﻲ ﺑﺎﻷﻣﺮ ) ﻟﻐﺎﻳﺔ ( ) ‪ ( until‬اﻟﺬي ﻳﻜﻮن ﺑﻌﺪﻩ ﺷﺮط ) أي ﻟﻐﺎﻳ ﺔ ﺗﺤﻘ ﻖ ه ﺬا اﻟ ﺸﺮط ( ‪,‬‬
‫اﻟﻤﺘﺮﺟﻢ ﺣﻴﻦ ﻳﺠ ﺪ اﻟﻌﺒ ﺎرﻩ ) أﻋ ﺪ ( ﻓﺄﻧ ﻪ ﻳﻌﻠ ﻢ أن اﻟﻤﻄﻠ ﻮب أﻋ ﺎدة ﺗﻨﻔﻴ ﺬ اﻟﻌﺒ ﺎرات اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ ه ﺬا‬
‫اﻷﻣﺮ واﻷﻣﺮ ) ﻟﻐﺎﻳﺔ (‪ ..‬ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺼﻞ اﻟﻤﺘﺮﺟﻢ اﻟﻰ اﻷﻣﺮ ) ﻟﻐﺎﻳ ﺔ ‪ ( until‬ﻳﻔﺤ ﺺ اﻟ ﺸﺮط اﻟ ﺬي‬
‫ﺑﻌ ﺪﻩ ﻓ ﺄذا آ ﺎن اﻟ ﺸﺮط ﻏﻴ ﺮ ﻣﺘﺤﻘ ﻖ ) أﺟﺎﺑﺘ ﻪ ‪ ( false‬ﻓ ﺄن اﻟﻤﺘ ﺮﺟﻢ ﺳ ﻴﻌﻮد اﻟ ﻰ اﻷﻣ ﺮ‬
‫) ‪ ( repeat‬وﻳﺒﺪأ ﺑﺎﻟﺘﻨﻔﻴﺬ ﻧﺰوﻻ ﻣﻦ ﺟﺪﻳﺪ ‪ ,‬هﺬﻩ اﻟﻌﻤﻠﻴﻪ ﺗ ﺴﺘﻤﺮ ﻟﻐﺎﻳ ﺔ أن ﻳﺘﺤﻘ ﻖ اﻟ ﺸﺮط وﺗﻜ ﻮن أﺟﺎﺑﺘ ﻪ‬
‫) ‪ . ( true‬اﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻬﺬا اﻷﻳﻌﺎز هﻲ ‪:‬‬
‫‪Repeat‬‬
‫; ‪Instruction 1‬‬
‫; ‪Instruction 2‬‬
‫…‪Etc‬‬
‫; ) ‪Until (condition is true‬‬
‫ﻣﺜﺎل ‪ //:‬هﺬا ﺑﺮﻧﺎﻣﺞ ﺑﺴﻴﻂ واﺟﺒ ﻪ أدﺧ ﺎل أﺳ ﻤﺎء اﻟﻄﻠﺒ ﻪ وﻃﺒﺎﻋﺘﻬ ﺎ ‪ ,‬اﻟﺒﺮﻧ ﺎﻣﺞ ﻻ ﻳﺘﻮﻗ ﻒ ﻟﻐﺎﻳ ﺔ‬
‫أدﺧﺎل أﺳﻢ ) ﻋﻠﻲ ( ‪.‬‬

‫;‪Program CH3_Program1‬‬
‫;‪Var YN: String‬‬
‫‪Begin‬‬
‫;)'?‪Writeln ('enter name of students‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If‬‬
‫‪(YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If (YN <> ' Ali ') then‬‬
‫;)‪Writeln (YN‬‬
‫;)‪Readln (YN‬‬
‫‪If‬‬
‫‪(YN <> ' Ali ') then‬‬
‫)‪Writeln (YN‬‬
‫…‬
‫…‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪37‬‬

‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻣﻤﻜﻦ أن ﻳﺴﺘﻤﺮ ﺑﻌ ﺪد آﺒﻴ ﺮ ﻣ ﻦ اﻟﺨﻄ ﻮات اﻟﻤﺘ ﺸﺎﺑﻪ وﺣ ﺴﺐ ﻋ ﺪد اﻟﻄﻠﺒ ﻪ اﻟﻤ ﺮاد‬
‫ﻃﺒﺎﻋﺔ أﺳﻤﺎﺋﻬﻢ ‪ ,‬أن اﻟﻌﺒﺎرات ) اﻗﺮأ ‪ ,‬أذا ‪ ,‬وأآﺘﺐ ( ﺗﺘﻜﺮر ﺑﺄﺳﺘﻤﺮار ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ‪ ,‬ﻟﺬا ﻓﺎن ﻟﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻟﺒﺪﻳﻞ اﻟﺬي ﻳﺴﻬﻞ اﻟﻌﻤﻞ وﻳﺨﺘﺼﺮ ﻋﺪد اﻟﺨﻄﻮات أﻻ وهﻮ ﻋﺒ ﺎرات اﻟﺘﻜ ﺮار ‪.‬‬
‫واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻷواﻣ ﺮ ه ﻮ ) ‪ ( repeat‬وأذا ﻣ ﺎ أﻋ ﺪﻧﺎ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ وﻟﻜ ﻦ ﻣ ﻊ أﺳ ﺘﺨﺪام‬
‫) ‪ , ( repeat‬ﺳﻴﻨﺘﺞ ﻟﻨﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪Program CH3_Program2‬‬
‫;‪Var YN: String‬‬
‫‪Begin‬‬
‫;)'?‪Writeln ('enter name of students‬‬
‫‪Repeat‬‬
‫}‪{repeat the code for at least one time‬‬
‫;) ‪Readln ( YN‬‬
‫; ) ‪Writeln ( YN‬‬
‫;)'‪Until (YN = 'Ali‬‬
‫‪End.‬‬

‫ﻣﻴﺰة هﺬا اﻷﻣﺮ أن اﻟﺸﺮط هﻮ ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺘﻜﺮار وﻟﺬا ﻓﺄﻧﻪ ﺳﻴﻨﻔﺬ وﻟﻮ ﻟﻤ ﺮﻩ واﺣ ﺪﻩ ﻗﺒ ﻞ أن ﻳ ﺘﻢ‬
‫ﻓﺤﺺ اﻟﺸﺮط ‪ .‬أرﺟﻮ ﻣﻼﺣﻈﺔ آﻴﻒ أن اﻟﺒﺮﻧﺎﻣﺞ أﺻﺒﺢ أآﺜﺮ أﺧﺘﺼﺎرا وأﺳﻬﻞ ﻟﻠﻤﺘﺎﺑﻌﻪ ‪.‬‬
‫‪3.5‬‬

‫ﻋﺒﺎرة اﻟﺘﻜﺮار‬

‫‪WHILE -_DO LOOP‬‬

‫وه ﻮ أﻳ ﻀﺎ ﻣ ﻦ أﻳﻌ ﺎزات اﻟﺘﻜ ﺮار وه ﻮ ﻳ ﺸﺎﺑﻪ أﻟ ﻰ درﺟ ﻪ آﺒﻴ ﺮﻩ اﻷﻳﻌ ﺎز ) ‪( Repeat_until‬‬
‫ﺣﻴﺚ أن واﺟﺐ اﻷﻳﻌﺎزﻳﻦ هﻮ اﻟﺘﻜﺮار ﻟﻤﺮات ﻏﻴﺮ ﻣﺤﺪدﻩ اﺑﺘﺪاءا وأﻧﻤﺎ ﻳﻌﺘﻤﺪان ﻋﻠﻰ ﺗﺤﻘﻖ ﺷﺮط ﻣﻌﻴﻦ‬
‫ﻷﻳﻘﺎف اﻟﺘﻜﺮار ‪ ,‬اﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻬﺬا اﻟﺘﻜﺮار هﻲ ‪:‬‬
‫‪While <condition is true> do the following:‬‬
‫;‪instruction 1‬‬
‫;‪instruction 2‬‬
‫;‪instruction 3‬‬
‫‪etc...‬‬
‫}‪End; {If while-do loop starts with a begin statement‬‬
‫ﻣﺎذا ﻳﻌﻨﻲ هﺬا اﻷﻣﺮ ) ﻋﻨﺪﻣﺎ ﻳﺘﺤﻘﻖ اﻟﺸﺮط أﻋﻤﻞ ﻣﺎ ﻳﻠﻲ ( وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﺳ ﻴﻨﻔﺬ اﻷﻳﻌ ﺎز اﻟ ﺬي‬
‫) ‪ ( while‬ﻟ ﻴﻔﺤﺺ اﻟ ﺸﺮط ه ﻞ ه ﻮ ﻣﺘﺤﻘ ﻖ أم ﻻ ﻓ ﺄذا آ ﺎن ﻣﺘﺤﻘ ﻖ ﻳﻨﻔ ﺬ‬
‫ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة وﻳﻌ ﻮد اﻟ ﻰ‬
‫وأن آﺎن ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﺳﻴﻬﻤﻞ اﻷﻳﻌﺎز اﻟﺬي ﺑﻌﺪ ) ‪ ( while‬وﻳﻨﻔﺬ ﻣﺎ ﺑﻌﺪﻩ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪38‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ ) ‪ ( If and else‬ﻓﺎن اﻷﻣﺮ ) ‪ ( while‬ﻳﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻓﻘﻂ واﻟﺘﻲ‬
‫ﺗﺄﺗﻲ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮﻩ ‪ ,‬أﻣﺎ أذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻣﻄﻠﻮب ﺗﻜﺮارهﺎ ﺿﻤﻦ اﻻﻣﺮ‬
‫) ‪ ( while‬ﻓﻴﺠﺐ أن ﺗﺤﺪد ﺑﻴﻦ اﻷﻣﺮ ) ‪ ( begin‬واﻷﻣﺮ ) ‪( end‬‬

‫اذن ﻣﺎ هﻮ اﻟﻔﺮق ﺑﻴﻦ ) ‪ ( While‬و )‪ .. (Repeat‬ﻻﺣﻆ اﻟﺠﺪول ) ‪: ( 3.1‬‬
‫ﺟﺪول ) ‪ : ( 3.1‬اﻟﻔﺎرق ﺑﻴﻦ أﻣﺮي اﻟﺘﻜﺮار ) ‪( repeat , while‬‬
‫‪While_Do‬‬
‫اﻟﺸﺮط ﻓﻲ ﺑﺪاﻳﺔ اﻟﺘﻜﺮار‬

‫‪Repeat_Until‬‬
‫اﻟﺸﺮط ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺘﻜﺮار‬

‫ﻻ ﻳﻨﻔﺬ أي أﻳﻌﺎز ﻣﺎﻟﻢ ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط وﺗﺤﻘﻘﻪ‬

‫ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻠﻰ اﻻﻗﻞ‬
‫ﻣﺮﻩ واﺣﺪﻩ ﻗﺒﻞ أن ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط‬
‫ﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬

‫ﺗﻨﻔﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻨﺪ ﺗﺤﻘﻖ‬
‫اﻟﺸﺮط‬
‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد‬
‫ﺛﺎﺑﺖ ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬
‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﺗﺤﻘﻖ اﻟﺸﺮط‬
‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬

‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد ﺛﺎﺑﺖ‬
‫ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬
‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬
‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬

‫ﻣﺜﺎل ‪ //:‬ﻣﺜﺎل ﺑﺴﻴﻂ ﻷدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم وﻃﺒﺎﻋﺘﻬﺎ ﺑﺸﺮط ﻳﺘﻢ اﻟﺘﻮﻗﻒ ﻋﻨﺪ أدﺧﺎل‬
‫اﻟﺮﻗﻢ ) ‪. ( 0‬‬
‫;‪Program CH3_Program3‬‬
‫;‪Var x : integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter number‬‬
‫;)‪Readln(x‬‬
‫‪While x <> 0 do‬‬
‫‪Begin‬‬
‫;)‪Writeln(x‬‬
‫;)‪Readln(x‬‬
‫;‪End‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪39‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫اﻟﻤﻄﻠﻮب ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ أدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﺑ ﺸﺮط أن ﻳﺘﻮﻗ ﻒ ﻋﻨ ﺪ أدﺧ ﺎل اﻟ ﺮﻗﻢ ) ‪ , ( 0‬أذن‬
‫ﻟﻤﺎ آﺎن أدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﻓﻬﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﺳﻨﻜﺮر أﻣ ﺮ اﻷدﺧ ﺎل أآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻳﺠ ﺐ‬
‫ﻓﺤﺺ اﻟﺮﻗﻢ ﻟﻐﺮض ﻃﺒﺎﻋﺘﻪ أذا ﻟﻢ ﻳﻜﻦ ﻳﺴﺎوي ) ‪ ( 0‬هﺬﻩ اﻟﻌﻤﻠﻴﻪ ﻣﻤﻜﻦ ﺗﻜﺮاره ﺎ ‪ 5‬ﻣ ﺮات ‪ 10‬ﻣ ﺮات‬
‫‪ 1000‬ﻣﺮﻩ أو أآﺜﺮ ﺣﺴﺐ ﻃﺒﻴﻌﺔ اﻟﻌﻤﻞ ) ﺗﺼﻮروا ﺑﺮﻧﺎﻣﺞ ﻳﺘﻜﻮن ﻣﻦ هﺬا اﻟﻜ ﻢ اﻟﻬﺎﺋ ﻞ ﻣ ﻦ اﻟﺨﻄ ﻮات‬
‫اﻟﻤﺘ ﺸﺎﺑﻬﻪ !!( ﻟ ﺬﻟﻚ ﻟﺘﺠﻨ ﺐ ه ﺬﻩ اﻟﻌﻤﻠﻴ ﻪ ﺗ ﻢ أﻳﺠ ﺎد أﻳﻌ ﺎزات اﻟﺘﻜ ﺮار ﻓ ﻴﻤﻜﻦ هﻨ ﺎ أن ﻧ ﺴﺘﺨﺪم اﻷﻣ ﺮ‬
‫) ‪ ( While‬ﻷﺧﺘﺼﺎر اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬هﺬا اﻷﻣﺮ ﻳﺤﺘﺎج اﻟﻰ ﺷﺮط ﻟﻐﺮض اﻟﻌﻤﻞ واﻟﺘﻮﻗﻒ ‪ ,‬ﻓ ﻲ ه ﺬا اﻟﻤﺜ ﺎل‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻳﺘﻮﻗﻒ ﻋﻨﺪ ورود اﻟﺮﻗﻢ ) ‪ ( 0‬أي أﻧ ﻪ ﻳﻌﻤ ﻞ ﻣ ﻊ اﻷرﻗ ﺎم اﻷﺧ ﺮى وﻟﻤ ﺎ آ ﺎن اﻟ ﺸﺮط ﻳﺠ ﺐ أن‬
‫ﻳﻜ ﻮن ) ‪ ( true‬ﻟﻜ ﻲ ﻳﻌﻤ ﻞ أذن أي رﻗ ﻢ ﻻﻳ ﺴﺎوي ﺻ ﻔﺮ ﺳ ﻮف ﻳﺠﻌ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻳﻌﻤ ﻞ ﻟ ﺬا ﺟﻌﻠﻨ ﺎ‬
‫) ‪ , ( x < > 0‬ﻟﻘﺪ ﺳ ﺒﻖ وأن ﺑﻴﻨ ﺎ أن اﻟﻤﺘ ﺮﺟﻢ ﻋﻨ ﺪﻣﺎ ﻳ ﺼﻞ اﻟ ﻰ أي ﺧﻄ ﻮﻩ ﻓﻴﻬ ﺎ ﻣﺘﻐﻴ ﺮ ﺳ ﻴﻘﻮم ﺑﻌﻤﻠ ﻴﻦ‬
‫اﻷول ﻳﺘﺄآﺪ ﻣﻦ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات واﻟﺜﺎﻧﻲ ﻳﺘﺄآﺪ ﻣﻦ أن اﻟﻤﺘﻐﻴﺮ ﻟﻪ ﻗﻴﻤﻪ وﺣﺴﺐ اﻟﻨﻮع‬
‫اﻟﻤﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ‪ .‬ﻟ ﺬا ﻓﺄﻧ ﻪ ﻋﻨ ﺪﻣﺎ ﻳ ﺼﻞ اﻟﻤﺘ ﺮﺟﻢ اﻟ ﻰ اﻷﻣ ﺮ ) ‪ ( While‬ﻳﺠ ﺐ أن ﻳﺠ ﺪ‬
‫ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( x‬وهﺬا هﻮ اﻟﺴﺒﺐ اﻟﺬي ﺟﻌﻠﻨﺎ ﻧ ﺪﺧﻞ ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻗﺒ ﻞ اﻷﻣ ﺮ ) ‪ ( While‬وأن‬
‫ﻟﻢ ﻧﻘﻢ ﺑﺬﻟﻚ ﻓﺄن اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﻔﺸﻞ ﻟﻌﺪم وﺟﻮد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ . ( x‬آﺬﻟﻚ ﻟﻤﺎ آﺎﻧﺖ هﻨﺎك أآﺜﺮ ﻣﻦ ﺧﻄﻮﻩ‬
‫ﻣﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار واﻟﺘﻲ هﻲ اﻟﻄﺒﺎﻋﻪ واﻟﻘﺮاءﻩ ﻋﻠﻴﻪ ﺗﻢ ﺗﺤﺪﻳﺪهﻤﺎ ﺑﻴﻦ ) ‪. ( begin and end‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﻗﺮاءة ﻗﻴﻤﻪ ﺟﺪﻳﺪﻩ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( x‬ﻓﺄن اﻟﻘﻴﻤﻪ اﻟﺴﺎﺑﻘﻪ ﺳﺘﺰول وﺗﺤﻞ ﻣﺤﻠﻬﺎ‬
‫اﻟﻘﻴﻤﻪ اﻟﺠﺪﻳﺪﻩ وهﺬﻩ ﻗﺎﻋﺪﻩ ﻋﺎﻣﻪ ﻳﺠﺐ أن ﺗﻼﺣﻆ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﺘﻢ أﺧﺘﻴﺎر اﻟﺸﺮط ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( While‬ﺑﺤﻴﺚ ﻳﺴﺎﻋﺪ ﺣﻠﻘﺔ اﻟﺘﻜﺮار أن ﺗﺴﺘﻤﺮ ﻃﺎﻟﻤﺎ آﺎن‬
‫هﺬا اﻟﺸﺮط ﻣﺘﺤﻘﻖ ‪ ,‬وأن ﺗﺘﻮﻗﻒ اﻟﺤﻠﻘﻪ ﻋﻦ اﻟﺘﻜﺮار ﻋﻨﺪﻣﺎ ﻻ ﻳﺘﺤﻘﻖ هﺬا اﻟﺸﺮط ‪.‬‬
‫ﻓﻲ ﺣﺎﻟﺔ اﻷﻣﺮ ) ‪ ( Repeat‬ﻓﺄن اﻟﺸﺮط ﻳﺎﺗﻲ ﺑﻌﺪ ) ‪ ( Until‬ﻟﺬا ﻳﺠﺐ أن ﻳﺘﻢ أﺧﺘﻴﺎرﻩ‬
‫ﺑﺤﻴﺚ ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﻓﺤﺼﻪ ﺗﻜﻮن اﻟﻨﺘﻴﺠﻪ ) ‪ ( False‬أي ﻏﻴﺮ ﻣﺘﺤﻘﻖ ‪ ,‬ﻟﻜﻲ ﻳﺴﺘﻤﺮ اﻟﺘﻜﺮار‬
‫ﺑﺎﻟﻌﻤﻞ وﻣﺘﻰ ﻣﺎ أﺻﺒﺤﺖ ﻧﺘﻴﺠﺔ ﻓﺤﺺ اﻟﺸﺮط ) ‪ ( True‬ﻓﺄن اﻟﺘﻜﺮار ﻳﺘﻮﻗﻒ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻣﻦ اﻟﺴﻬﻞ آﺘﺎﺑﺔ ﺣﻠﻘﻪ ﺑﺸﻜﻞ ﻋﻔﻮي ‪ ,‬ﺷﺮﻃﻬﺎ ﻻ ﻳﺼﺒﺢ ﻣﺘﺤﻘﻘﺎ أﺑﺪا ‪ ,‬هﺬا ﺳﻴﺆدي اﻟﻰ‬
‫ﺑﺮﻧﺎﻣﺞ ﻣﻘﻔﻞ أو ﻣﻐﻠﻖ أي ﻳﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ اﻟﻰ ﻣﺎﻻﻧﻬﺎﻳﻪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪3.6‬‬

‫‪40‬‬

‫أﻳﻌﺎز اﻟﺘﻜﺮار ‪FOR LOOP‬‬

‫أن ه ﺬا اﻷﻣ ﺮ ﻳﻘ ﻮم ﺑﺘﻜ ﺮار أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﺔ أﻳﻌ ﺎزات ﻟﻌ ﺪد ﻣ ﻦ اﻟﻤ ﺮات اﻟﻤﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ ‪.‬‬
‫واﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻪ أذا آﺎن ﻳﺴﺘﺨﺪم ﻟﺘﻜﺮار أﻳﻌﺎز واﺣﺪ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة هﻲ ‪:‬‬
‫‪For {variable}* := {original value} to/downto {final value} do‬‬
‫})‪{code...(for one action‬‬
‫* ﺑﺸﻜﻞ ﻋﺎم هﺬا اﻟﻤﺘﻐﻴﺮ ﻳﺴﻤﻰ‬

‫) ‪( loop counter‬‬

‫ﻗﻴﻤﺔ هﺬا اﻟﻌﺪاد ﺗﺒﺪأ ﺑﺎﻟﻘﻴﻤﻪ اﻷﺻﻠﻴﻪ أو اﻷﺑﺘﺪاﺋﻴﻪ ) ‪ ( original value‬ﺛﻢ ﺗﺰداد ﺑﻤﻘ ﺪار واﺣ ﺪ‬
‫) أو ﺗﻘﻞ ﺑﻤﻘﺪار واﺣﺪ ( ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻷﻳﻌﺎز اﻟﺬي ﺑﻌﺪﻩ ﻣﺒﺎﺷ ﺮة وﻳ ﺴﺘﻤﺮ آ ﺬﻟﻚ ﻟﺤ ﻴﻦ أن ﺗ ﺼﻞ‬
‫ﻗﻴﻤﺔ اﻟﻌﺪاد اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ) ‪ ( final value‬واﻟﺘﻲ ﺗﻤﺜﻞ اﻟﺘﻨﻔﻴﺬ اﻷﺧﻴﺮ ‪.‬‬
‫أﻣﺎ ) ‪ ( to / downto‬ﻓﺘﺴﺘﺨﺪم واﺣﺪﻩ ﻣﻨﻬﻤﺎ ﻓﻘﻂ ﻓﺎذا آﺎﻧﺖ اﻟﻘﻴﻤﻪ اﻷﺑﺘﺪاﺋﻴﻪ أﻗﻞ ﻣ ﻦ‬
‫اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ﻓﻌﻨﺪ ذﻟ ﻚ ﻧ ﺴﺘﺨﺪم ) ‪ ( to‬وﺗﺘﻐﻴ ﺮ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﺑﺄﺿ ﺎﻓﻪ واﺣ ﺪ ﻟ ﻪ ﻓ ﻲ آ ﻞ ﺗﻨﻔﻴ ﺬ ‪ ,‬أﻣ ﺎ أذا‬
‫آﺎﻧﺖ اﻟﻘﻴﻤﻪ اﻷﺑﺘﺪاﺋﻴﻪ أآﺒﺮ ﻣﻦ اﻟﻘﻴﻤﻪ اﻟﻨﻬﺎﺋﻴﻪ ﻓﻨﺴﺘﺨﺪم ) ‪ ( downto‬وﺗﺘﻐﻴﺮ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻄﺮح واﺣﺪ‬
‫ﻣﻨﻬﺎ ﻓﻲ آﻞ ﺗﻨﻔﻴﺬ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫آﻤﺎ ﻓﻲ ) ‪ ( If , Else , While‬ﻓ ﺎن اﻷﻣ ﺮ ) ‪ ( For‬ﻻﻳﻨﻔ ﺬ أآﺜ ﺮ ﻣ ﻦ أﻳﻌ ﺎز أو ﻋﺒ ﺎرﻩ‬
‫ﺗﺎﺗﻲ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮﻩ ‪ ,‬ﻓﺄذا آﺎن هﻨﺎك أآﺜﺮ ﻣﻦ أﻳﻌﺎز ﻳﺠﺐ أن ﻳﻜ ﺮر ﺿ ﻤﻦ اﻷﻣ ﺮ ) ‪( For‬‬
‫ﻓﻴﺠﺐ أن ﻳﺤﺪد ﺑﻴﻦ ) ‪( begin and end‬‬

‫;‪Program CH3_Program4‬‬
‫}!!!‪{somewhat boring writing all this‬‬
‫هﺬا ﻳﻜﻮن ﳑﻞ ﻟﻜﺘﺎﺑﻪ آﻞ ذﻟﻚ‬

‫;)'‪loop‬‬
‫;)'‪loop‬‬
‫;)'‪loop‬‬
‫;)'‪loop‬‬
‫;)'‪loop‬‬
‫;)'‪loop‬‬
‫;)'‪loop‬‬

‫‪('for‬‬
‫‪('for‬‬
‫‪('for‬‬
‫‪('for‬‬
‫‪('for‬‬
‫‪('for‬‬
‫‪('for‬‬

‫‪Begin‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫‪Writeln‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪41‬‬

‫ﻣﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﻪ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺑﻄﺮﻳﻘﻪ أﺳﻬﻞ وأﺳﺮع وﻳﺆدي ﻧﻔﺲ اﻟﻐﺮض آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫;‪Program CH2_Program5‬‬
‫;‪Var Counter: Integer‬‬

‫}‪{loop counter declared as integer‬‬

‫}!‪{it's easy and fast‬‬

‫‪Begin‬‬
‫‪For Counter: = 1 to 7 do‬‬
‫;)'‪writeln ('for loop‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻﺗﺴﺘﺨﺪم اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﺑﻌﺪ اﻷﻣﺮ ) ‪ , ( for … do‬اﻷﻣﺮ ) ‪, ( while .. do‬‬
‫) ‪. ( repeat‬‬
‫واﻷﻣﺮ‬

‫‪3.7‬‬

‫أﺳﺘﺨﺪام ) ‪ ( FOR‬اﻟﻤﺘﺪاﺧﻠﻪ ‪NESTED FOR‬‬

‫ﻣﻤﻜﻦ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( For‬ﺑﺸﻜﻞ ﻣﺘﺪاﺧﻞ وﻷآﺜﺮ ﻣﻦ ﻣﺮﻩ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓ ﺎن ﺣﻠﻘ ﺔ ) ‪( For‬‬
‫ﺗﻜﺮر آﺎﻣﻠﺔ ﺑﻌﺪد ﻣﺮات اﻟﺘﻜﺮار اﻟﻤﺤﺪدﻩ ﻓﻲ ) ‪ ( For‬اﻟﺨﺎرﺟﻲ ‪ .‬ﻓﻤﺜﻼ ﻟﻮ آﺎن ﻟ ﺪﻳﻨﺎ ﻋ ﺪد ﻣ ﻦ اﻟﻄ ﻼب‬
‫ﻓﻲ ﺻﻒ ﻣﻌﻴﻦ ) ‪ 30‬ﻃﺎﻟﺐ ﻣﺜﻼ ( وﻧﺮﻏﺐ أن ﻧﻄﺒﻊ أﺳﻤﺎء اﻟﻄﻠﺒﻪ ﻣﻊ اﻟﺪرﺟﺎت اﻟﺘﻲ ﺣﺼﻞ ﻋﻠﻴﻬ ﺎ آ ﻞ‬
‫ﻣﻨﻬﻢ ﻓﻲ آﻞ اﻟ ﺪروس اﻟﺘ ﻲ ﻳﺪرﺳ ﻮهﺎ ﻓ ﻲ ﺗﻠ ﻚ اﻟﻤﺮﺣﻠ ﻪ ) ‪ 8‬دروس ﻣ ﺜﻼ ( ‪ .‬هﻨ ﺎ ﻳﺠ ﺐ ﻃﺒﺎﻋ ﺔ أﺳ ﻤﺎء‬
‫اﻟﻄﻠﺒﻪ وهﻲ ‪ 30‬أي أن أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺳﻴﻜﺮر ‪ 30‬ﻣﺮﻩ ﻟﺬا ﻧﺴﺘﺨﺪم ) ‪ ( for‬ﻟﻬﺬا اﻟﻐﺮض ﻷن ﻋﺪد ﻣﺮات‬
‫اﻟﺘﻜﺮار ﻣﺤﺪد ‪ ,‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ) أي ﻟﻜ ﻞ ﻃﺎﻟ ﺐ ( ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ اﻟ ﺪرﺟﺎت ) ‪ 8‬درﺟ ﺎت ( أي أن أﻣ ﺮ‬
‫ﻃﺒﺎﻋﺔ اﻟﺪرﺟﺎت ﻳﻜﺮر ‪ 8‬ﻣﺮات ﻋﻠﻴﻪ ﻧﺴﺘﺨﺪم ) ‪ ( For‬أﻳﻀﺎ ﻟﻄﺒﺎﻋ ﺔ اﻟ ﺪرﺟﺎت ﻟﻜ ﻞ ﻃﺎﻟ ﺐ ‪ ,‬وﺳ ﻴﻜﻮن‬
‫اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫;‪Program CH3_Program6‬‬
‫‪Var‬‬
‫;‪Name: string‬‬
‫;‪Degree, i, j: integer‬‬
‫‪Begin‬‬
‫‪For i: = 1 to 30 do‬‬
‫‪Begin‬‬
‫; )'‪Writeln ('enter student name and his/her degree‬‬
‫;)‪Readln (name‬‬
‫;)‪Writeln (name‬‬
‫‪For j: = 1 to 8 do‬‬
‫‪Begin‬‬
‫;)‪Writeln('Enter degree:',j‬‬
‫; ) ‪Readln (degree‬‬
‫; ) ‪Write (degree:5‬‬
‫} ‪End; {second for‬‬
‫;‪End‬‬
‫} ‪{first for‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪42‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻓﺄن ) ‪ ( for‬اﻷوﻟﻰ ﺗﺴﺘﺨﺪم ﻟﻄﺒﺎﻋﺔ أﺳﻤﺎء اﻟﻄﻠﺒﻪ ‪ ,‬وﻟﻤﺎ آﺎن آ ﻞ ﻃﺎﻟ ﺐ ﻟ ﻪ‬
‫‪ 8‬درﺟ ﺎت ﻓ ﺄن أﻣ ﺮ ﺗﻜ ﺮار ﻟﻬ ﺬﻩ اﻟ ﺪرﺟﺎت ﺳ ﻴﻜﻮن ﻣ ﻦ ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ) أي ﻋﻨ ﺪ ﻃﺒﺎﻋ ﺔ أﺳ ﻢ‬
‫ﻃﺎﻟ ﺐ ﻣﻌ ﻴﻦ ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ ﻣﻌ ﻪ درﺟﺎﺗ ﻪ اﻟﺜﻤ ﺎﻧﻲ ﻗﺒ ﻞ اﻷﻧﺘﻘ ﺎل اﻟ ﻰ اﻟﻄﺎﻟ ﺐ اﻟﺘ ﺎﻟﻲ ( ‪ .‬وﺑﻤ ﺎ أن ﻋ ﺪد‬
‫اﻟﺨﻄ ﻮات اﻟﻤ ﺸﻤﻮﻟﻪ ﺑ ﺎﻟﺘﻜﺮار ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ه ﻲ أآﺜ ﺮ ﻣ ﻦ واﺣ ﺪﻩ ﻟ ﺬا ﺗ ﻢ ﺗﺤﺪﻳ ﺪهﺎ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬وﻧﻔ ﺲ اﻟ ﺸﻲء ﺑﺎﻟﻨ ﺴﺒﻪ ﻟﻸﻣ ﺮ ) ‪ ( for‬اﻟﺜﺎﻧﻴ ﻪ ‪ .‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻧﻨﻔ ﺬ ) ‪ ( for‬اﻷوﻟ ﻰ‬
‫ﺳﻨﻨﻔﺬ ) ‪ ( for‬اﻟﺜﺎﻧﻴﻪ آﺎﻣﻠﺔ ﻗﺒﻞ أن ﻧﻨﺘﻘﻞ اﻟﻰ زﻳﺎدة اﻟﻌ ﺪاد ) ‪ ) ( I‬أي أن اﻟﻌ ﺪاد ) ‪ ( j‬ﻳﺒ ﺪأ ﺑﻘﻴﻤ ﺔ اﻟﺒﺪاﻳ ﻪ‬
‫وﻳﺴﺘﻤﺮ ﺑﺎﻟﻌﻤﻞ ﺣﺘﻰ ﻳﻨﺘﻬﻲ ﺑﻘﻴﻤﺔ اﻟﻨﻬﺎﻳﻪ ﻓﻲ آﻞ زﻳﺎدﻩ ﻟﻠﻌﺪاد ) ‪ .( ( I‬هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻘ ﺎرب اﻟ ﺴﺎﻋﻪ ﻓﻠﻜ ﻲ‬
‫ﻳﺘﺤﺮك ﻋﻘﺮب اﻟﺴﺎﻋﺎت ﺧﻄﻮﻩ واﺣﺪﻩ ﻓﺄن ﻋﻘﺮب اﻟﺪﻗﺎﺋﻖ ﻳﺠﺐ أن ﻳﺘﺤﺮك ‪ 60‬ﺧﻄ ﻮﻩ ‪ ,‬وآﺄﻧﻤ ﺎ ﻋﻘ ﺮب‬
‫اﻟ ﺴﺎﻋﺎت ه ﻮ‬
‫) ‪ ( for I : = 1 to 60 do‬وه ﻮ ﺣﻠﻘ ﺔ ﺗﻜ ﺮار ﺧ ﺎرﺟﻲ وﻋﻘ ﺮب‬
‫)‪. ( for j : = 1 to 60 do‬‬
‫اﻟﺪﻗﺎﺋﻖ هﻮ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻟﺪاﺧﻠﻲ‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﺴﺘﺨﺪم اﻷﻣﺮ ) ‪ ( break‬واﻷﻣﺮ ) ‪ ( continue‬ﻣﻊ ﺣﻠﻘﺎت ) ‪ ( for‬وآﺎﻓﺔ ﺣﻠﻘﺎت اﻟﺘﻜﺮار‬
‫اﻷﺧﺮى ﻣﺜﻞ ) ‪ ( while , repeat‬وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪ .1‬اﻷﻣﺮ ) ‪ ( break‬وﻳﺴﺘﺨﺪم ﻟﻠﺴﻴﻄﺮﻩ ﻋﻠﻰ ﺗﺪﻓﻖ ﺗﻜﺮار اﻟﻌﺒﺎرات وهﻲ ﺗﺆدي اﻟﻰ أﻧﻬﺎء‬
‫أو ﺗﻮﻗﻒ اﻟﺘﻜﺮار ‪ ,‬ﻣﺜﺎل‬
‫‪For i: = 1 to 10 do‬‬
‫‪begin‬‬
‫;) ‪Readln ( x‬‬
‫‪If x < 0 then‬‬
‫‪Break‬‬
‫‪Else‬‬
‫;) ) ‪Writeln ( sqrt ( x‬‬
‫;‪End‬‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ ﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ورود ﻋﺪد ﺳﺎﻟﺐ ﻟﻌﺪم أﻣﻜﺎﻧﻴﺔ أﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ‬
‫ﻟﻠﻌﺪد اﻟﺴﺎﻟﺐ ‪.‬‬
‫‪ .2‬اﻷﻣﺮ ) ‪ ( continue‬وﻳﺴﺘﺨﺪم أﻳﻀﺎ ﻣﻊ ﺣﻠﻘﺎت اﻟﺘﻜﺮاروهﻮ ﻳﻌﻨﻲ أﺳﺘﻤﺮ ﻣﻊ ﺣﻠﻘﺔ‬
‫ﺗﻜﺮار ﺟﺪﻳﺪﻩ) أي أهﻤﻞ ﺗﻨﻔﻴﺬ اﻷواﻣﺮ اﻟﺘﻲ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( continue‬ﻋﻨﺪ ﺗﺤﻘﻖ ﺷﺮط‬
‫ﻣﻌﻴﻦ ﺣﻴﺚ ﺳﻴﻌﻴﺪ اﻟﻤﺆﺷﺮ اﻟﻰ اﻷﻣﺮ ) ‪ , ( ( for‬ﻣﺜﺎل‬
‫‪For i: = 1 to 10 do‬‬
‫‪Begin‬‬
‫;) ‪Readln ( x‬‬
‫‪If x < 0 then‬‬
‫‪Continue‬‬
‫‪Else‬‬
‫;) ) ‪Writeln ( sqrt ( x‬‬
‫;‪End‬‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ ﻋﻨﺪ ورود ﻋﺪد ﺳﺎﻟﺐ ﻓﺄن اﻷﻣﺮ ) ‪ ( continue‬ﺳﻴﻤﻨﻊ ﻣﺘﺎﺑﻌﺔ ﺗﻨﻔﻴﺬ‬
‫اﻟﻌﺒﺎرات اﻷﺧﺮى ﻓﻲ ﺣﻠﻘﺔ اﻟﺘﻜﺮار واﻟﻤﺘﻤﺜﻠﻪ ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ ﻓﻲ هﺬا اﻟﻤﺜﺎل وﻳﻌﻴﺪ اﻟﻤﺆﺷﺮ‬
‫اﻟﻰ اﻷﻣﺮ ) ‪ ( for‬ﻟﻴﺒﺪأ ﺑﺘﻜﺮار ﺟﺪﻳﺪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪43‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻳﻜﻮن اﻟﺘﺪاﺧﻞ ﺑﻴﻦ ﻋﺒﺎرات اﻟﺘﻜﺮار ﺟﻤﻴﻌﺎ ﺳﻮاء اﻟﻤﺘﺸﺎﺑﻬﺎت أو اﻟﻤﺨﺘﻠﻔﺎت ‪,‬‬
‫) ‪, ( for . and repeat ) , ( for , and while ) , ( for , and for‬‬
‫ﻣﺜﻼ ﺑﻴﻦ‬
‫) ‪( repeat , and repeat ) , ( while , and while ) , ( while , and repeat‬‬

‫‪3.8‬‬

‫ﻋﺒﺎرة أﺧﺘﻴﺎر اﻟﺤﺎﻟﻪ ‪The Simple Case statements‬‬

‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﺗﺴﺘﺨﺪم ) ‪ ( If‬اﻟﻤﺘﺪاﺧﻠ ﻪ وﻟﻤ ﺮات ﻋﺪﻳ ﺪﻩ ﺑ ﺸﻜﻞ ﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن ﻣﻄ ﻮﻻ أو‬
‫ﻣﻤﻼ ‪ ,‬وﻟﺘﺴﻬﻴﻞ اﻟﻌﻤﻞ ﻓﺄﻧﻪ ﻳﻤﻜﻦ أن ﻧﺴﺘﻌﻴﺾ ﻋﻨﻬﺎ ﺑﻌﺒﺎرة ) ‪ ( Case‬واﻟﺸﻜﻞ اﻟﻘﻮاﻋﺪي ﻟﻬﺎ هﻮ ‪:‬‬
‫‪Case {variable of type: integer or character ONLY} of‬‬
‫‪{input statement- within inverted commas if of type char} :‬‬
‫}‪{code..‬‬
‫‪{input statement- within inverted commas if of type char} :‬‬
‫}‪{code..‬‬
‫‪...‬‬
‫}‪End; {End Case‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻷﻣﺮ) ‪ ( Case‬ﻳﻨﺘﻬﻲ داﺋﻤﺎ ﺑﺎﻷﻣﺮ ) ‪ ( end‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ ﻋﺪم وﺟﻮد ) ‪( begin‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﺄﺗﻲ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( Case‬ﻣﺘﻐﻴﺮ وهﺬا اﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ أو اﻟﺤﺮوف ﻓﻘﻂ‬
‫وﻻ ﻳﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ هﻨﺎ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪44‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﻔﻀﻞ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( case‬ﻓﻲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ ﺛﻼث ﻋﺒﺎرات ) ‪ ( If‬ﻣﺘﺘﺎﻟﻴﻪ‬
‫أو أآﺜﺮ ‪.‬‬

‫ﻟﻨ ﺮى اﻟﻔ ﺮق ﺑ ﻴﻦ أﺳ ﺘﺨﺪام ) ‪ ( If‬و ) ‪ ( Case‬ﻣ ﻦ ﺧ ﻼل اﻟﺒﺮﻧ ﺎﻣﺞ اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﻳﺤ ﺎآﻲ‬
‫أﺳﺘﺨﺪام اﻟﺤﺎﺳﺒﻪ اﻟﺠﻴﺒﻴﻪ ذات اﻟﻌﻤﻠﻴﺎت اﻷرﺑﻊ ) ‪: ( Calculator‬‬

‫;)'‬

‫"‬

‫‪" +, - , * , /‬‬

‫;‪Program CH3_Program7‬‬
‫‪Var‬‬
‫; ‪ch: char‬‬
‫;‪num1, num2: integer‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫;)' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫‪Writeln (' enter one of operators‬‬
‫;)‪Readln (ch‬‬
‫‪If (ch = ' + ') then‬‬
‫‪Result: = num1 + num2‬‬
‫‪Else‬‬
‫‪If (ch = ' – ') then‬‬
‫‪Result: = num1 – num2‬‬
‫‪Else‬‬
‫‪If (ch = ' * ') then‬‬
‫‪Result: = num1 * num2‬‬
‫‪Else‬‬
‫‪Result: = num1 / num2‬‬
‫;‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬

‫اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ ﺑﺮﻧ ﺎﻣﺞ ﺑ ﺴﻴﻂ ﺣﻴ ﺚ ﻳ ﺘﻢ أدﺧ ﺎل ﻋ ﺪدﻳﻦ وأدﺧ ﺎل اﻟﻌﻤﻠﻴ ﻪ اﻟﺮﻳﺎﺿ ﻴﻪ اﻟﻤﻄﻠ ﻮب‬
‫أﺟﺮاؤهﺎ ﻋﻠﻴﻬﺎ ﺛﻢ ﻳﻘﻮم اﻟﻤﺘﺮﺟﻢ ﺑﻔﺤﺺ اﻟﻌﻤﻠﻴﻪ اﻟﺘﻲ ﺗﻢ أدﺧﺎﻟﻬﺎ ﻟﻴﻨﻔﺬ ﻣﺎ ﻣﻄﻠ ﻮب ﻓﻴﻬ ﺎ ﻋﻠ ﻰ اﻷﻋ ﺪاد ‪,‬‬
‫وأﺧﻴﺮا ﺗﻄﺒﻊ اﻟﻨﺘﻴﺠﻪ‪.‬‬
‫اﻻن ﻧﻌﻴﺪ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ وﻟﻜ ﻦ ﺑﺄﺳ ﺘﺨﺪام ) ‪ ( Case of‬وﻧﻼﺣ ﻆ اﻟﻔ ﺮق ‪ ,‬ﻣ ﻊ اﻟﻌﻠ ﻢ أن‬
‫اﻟﻨﺘﺎﺋﺞ ﻻ ﺗﺘﻐﻴﺮ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪45‬‬

‫;‪Program CH3_Program8‬‬
‫‪Var‬‬
‫;‪num1, num2: integer‬‬
‫; ‪ch: char‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫;)' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫;)' " ‪Writeln (' enter one of operators " +, - , * ,/‬‬
‫;)‪Readln (ch‬‬
‫‪Case ch of‬‬
‫;‪'+ ': result: = num1 + num2‬‬
‫;‪'– ': result: = num1 – num2‬‬
‫;‪'* ': result: = num1 * num2‬‬
‫;‪'/ ': result: = num1 / num2‬‬
‫;‪End‬‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻ ﺗ ﺴﺘﺨﺪم ) ‪ ( IF‬ﺑﻌ ﺪ ) ‪ ( Else‬ﻋﻨ ﺪﻣﺎ ﻳﻜ ﻮن هﻨ ﺎك أﺣﺘﻤ ﺎل واﺣ ﺪ ﻣﺘﺒﻘ ﻲ ‪ ,‬وﺗ ﺴﺘﺨﺪم‬
‫ﺑﻌ ﺪ ) ‪ ( Else‬أذا آ ﺎن هﻨ ﺎك أآﺜ ﺮ ﻣ ﻦ أﺣﺘﻤ ﺎل واﺣ ﺪ وﻳﺠ ﺐ اﻷﺧﺘﻴ ﺎر ﻣﻨﻬﻤ ﺎ ‪ ..‬ﻷن‬
‫أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ وﺟﻮد أﺣﺘﻤﺎل واﺣﺪ ﻳﻌﺘﺒ ﺮ ﻏﻴ ﺮ ﻣﻨﻄﻘ ﻲ ﺑ ﺎﻟﺮﻏﻢ ﻣ ﻦ أن اﻟﺒﺮﻧ ﺎﻣﺞ ﻣﻤﻜ ﻦ‬
‫أن ﻳﻨﺠﺰ ‪.‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ) ‪ ( 8‬أآﺜﺮ ﺑﺴﺎﻃﻪ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺴﺎﺑﻖ ) ‪. ( 7‬‬
‫ﻟ ﻨﻼﺣﻆ آﻴﻔﻴ ﺔ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( case‬ﺣﻴ ﺚ ﺑﻌ ﺪ أن ﻳ ﺘﻢ أﻋﻄ ﺎء ﻗﻴﻤ ﻪ ﻟﻠﻤﺘﻐﻴ ﺮ ) ‪ , ( ch‬ﻳ ﺘﻢ‬
‫ﻓﺤﺺ هﺬﻩ اﻟﻘﻴﻤﻪ ﺑﻮاﺳﻄﺔ ) ‪ ( case‬وآﺄن اﻟﻌﺒﺎرﻩ ﺗﺘﺮﺟﻢ ) أذا آﺎﻧﺖ ﻗﻴﻤﺔ ‪ ch‬ﻣ ﺎﻳﻠﻲ أﻋﻤ ﻞ اﻟﺨﻄ ﻮات‬
‫اﻟﺘﻲ ﺗﻘﺎﺑﻠﻪ ( ‪ ,‬ﺛﻢ ﻧﻜﺘﺐ اﻟﻘﻴﻢ اﻟﺘﻲ ﻣﻤﻜﻦ أن ﺗﻜ ﻮن ﻋﻠﻴﻬ ﺎ ) ‪ ( ch‬ﺣ ﺴﺐ ﻣﺘﻄﻠﺒ ﺎت اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬آ ﻞ ﻗﻴﻤ ﻪ‬
‫ﻓﻲ ﺳﻄﺮ ﻣﻨﻔﺮد وﺗﻮﺿ ﻊ ﺑﻌ ﺪهﺎ اﻟﻨﻘﻄﺘ ﻴﻦ اﻟﻤﺘﻌﺎﻣ ﺪﺗﻴﻦ ) ‪ ( colon ) ( :‬ﺑﻌ ﺪ ذﻟ ﻚ ﻧﻜﺘ ﺐ اﻻﺟ ﺮاء اﻟ ﺬي‬
‫ﻳﺠﺐ أن ﻳﺤﺼﻞ ﻋﻨﺪ ﺗﺤﻘﻖ أدﺧ ﺎل ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ‪ .‬ﻓﻤ ﺜﻼ أذا آﺎﻧ ﺖ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( ch‬ه ﻲ ) * ( ﻓ ﺄن‬
‫اﻟﻤﺘ ﺮﺟﻢ ﻳﻔﺤ ﺺ أوﻻ ) ‪ ( +‬وﺳ ﻮف ﻳﺠ ﺪهﺎ ﻻ ﺗ ﺴﺎوي ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( ch‬أي أن اﻷﺟﺎﺑ ﻪ ه ﻲ ﺧﻄ ﺄ‬
‫) ‪ ( false‬ﻓﻴﺘﺮآﻬ ﺎ ﻟﻴﻘ ﺎرن اﻟﻘﻴﻤ ﻪ اﻟﻼﺣﻘ ﻪ وه ﻲ ) ‪ ( -‬وأﻳ ﻀﺎ ﺳ ﻴﺠﺪ أن اﻷﺟﺎﺑ ﻪ ) ‪ ( false‬ﻓﻴ ﺴﺘﻤﺮ‬
‫ﺑﻔﺤﺺ اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﺑﻌ ﺪهﺎ وه ﻲ ) * ( هﻨ ﺎ ﺳ ﺘﻜﻮن اﻟﻨﺘﻴﺠ ﻪ ) ‪ , ( true‬ﻟ ﺬا ﺳ ﻴﻨﻔﺬ اﻟﻌﺒ ﺎرﻩ أو اﻟﻌﺒ ﺎرات‬
‫اﻟﺘ ﻲ ﺑﻌ ﺪهﺎ وه ﻲ أﺟ ﺮاء ﻋﻤﻠﻴ ﻪ اﻟ ﻀﺮب ووﺿ ﻊ اﻟﻨﺘﻴﺠ ﻪ ﺑ ﺎﻟﻤﺘﻐﻴﺮ ) ‪ . ( result‬أﻣ ﺎ اﻷﻣ ﺮ ) ‪( end‬‬
‫ﻓﻴﻨﻬﻲ آﺎﻓﺔ ﻋﻤﻠﻴﺎت اﻟﻔﺤﺺ ‪ ,‬ﻟﻴﺄﺗﻲ ﺑﻌﺪهﺎ أﻣﺮ ﻃﺒﺎﻋﺔ اﻟﻨﺘﻴﺠﻪ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫داﺋﻤﺎ اﻟﺤﺮوف واﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ﻋﻨﺪ أﺳﺘﺨﺪاﻣﻬﺎ وآﺘﺎﺑﺘﻬﺎ ﻓﻲ اﻟﺒﺮاﻣﺞ ﻋﻠﻰ أﺳﺎس أﻧﻬﺎ‬
‫ﺣﺮوف أو ﺳﻼﺳﻞ ﺣﺮﻓﻴﻪ وﻟﻴﺲ ﻟﻐﺮض أﺧﺮ ﻓﺄﻧﻬﺎ ﺗﺤﺪد ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫آﻤﺎ ﻓﻲ ) ‪ ( for, if ,while , else‬واﻟﺘﻲ ﺗﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﺑﻌﺪهﺎ ﻓﻘ ﻂ ‪ ,‬آ ﺬﻟﻚ ﻓ ﻲ ﺣﺎﻟ ﺔ‬
‫) ‪ ( case‬ﻓﺄﻧﻬﺎ ﺳﺘﻨﻔﺬ ﻋﺒﺎرﻩ واﺣﺪﻩ ﻣﻦ اﻟﻌﺒﺎرات اﻟﺘﻲ ﺗﺄﺗﻲ ﺑﻌ ﺪ ﻋﺒ ﺎرات اﻷدﺧ ﺎل ) واﻟﺘ ﻲ‬
‫ﺗﻤﺜﻞ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮ ( ‪ ,‬وﻟﺬا أذا آﺎﻧﺖ هﻨ ﺎك أآﺜ ﺮ ﻣ ﻦ ﻋﺒ ﺎرﻩ ﻳﺠ ﺐ أن ﺗﻨﻔ ﺬ ﺑﻌ ﺪ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫اﻟﺘﻲ ﺗﺘﻄﺎﺑﻖ ﻣﻊ اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻓﻴﺠﺐ أن ﺗﺤﺪد ﺑﻴﻦ ) ‪. ( begin , end‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﺑﺎﻷﻣﻜﺎن أﺳﺘﺨﺪام ) ‪ ( else‬ﻣﻊ ) ‪ ( case‬آﺨﻄﻮﻩ أﺧﻴﺮﻩ ﺑﻌ ﺪ أﻧﺘﻬ ﺎء ﻋﻤﻠﻴ ﺎت ﻓﺤ ﺺ اﻟﻘ ﻴﻢ‬
‫اﻷﻓﺘﺮاﺿﻴﻪ ﻟﻠﻤﺘﻐﻴﺮ ‪ ,‬وهﻲ ﺗﻌﻨﻲ ﺗﻨﻔﻴﺬ اﻷﺟﺮاء اﻟﺬي ﻳﺄﺗﻲ ﺑﻌﺪ ) ‪ ( else‬ﻓﻲ ﺣﺎﻟﺔ اﻟﻔﺸﻞ ﻓ ﻲ‬
‫ﻣﻄﺎﺑﻘﺔ اﻟﻘﻴﻤﻪ اﻟﻤﺪﺧﻠﻪ ﻟﻠﻤﺘﻐﻴﺮ ﻣﻊ اﻟﻘﻴﻢ اﻟﻤﻔﺮوﺿﻪ ‪.‬‬

‫;)'‬

‫; ‪Program CH3_Program9‬‬
‫‪Var‬‬
‫; ‪num1, num2 : integer‬‬
‫;‪Ch: char‬‬
‫;‪Result: real‬‬
‫‪Begin‬‬
‫; )' ‪Writeln (' enter two numbers‬‬
‫;)‪Readln (num1, num2‬‬
‫" ‪Writeln (' enter one of operators " +, - , *, /,‬‬
‫;)‪Readln (ch‬‬
‫‪Case ch of‬‬
‫;‪'+ ': result: = num1 + num2‬‬
‫;‪'– ': result: = num1 – num2‬‬
‫;‪'* ': result: = num1 * num2‬‬
‫;‪'/ ': result: = num1 / num2‬‬
‫‪Else‬‬
‫;)' ‪Writeln (' Error in entering operator‬‬
‫;‪End‬‬
‫;)‪Writeln (result‬‬
‫‪End.‬‬

‫‪46‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪3.9‬‬

‫‪47‬‬

‫ﺟﻤﻠﺔ ‪IN‬‬

‫ﺗﺴﺘﺨﺪم ﺟﻤﻠﺔ ) ‪ ( in‬ﻓﻲ اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﻪ أﺳﺘﺨﺪاﻣﺎت ﻣﺨﺘﻠﻔﻪ وهﻲ ‪:‬‬
‫أوﻻ ‪ //:‬ﻟﺘﺤﺪﻳﺪ اﻟﻤﺪى اﻟﺬي ﻳﻌﻤﻞ ﺑﻪ ﻣﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻟﺘﻮﺿﻴﺢ ذﻟﻚ ﻟﻨﺮى اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪If ( degree > = 90 ) And ( degree <= 100 ) then‬‬
‫; ) ' ‪Writeln ( ' Excellent‬‬
‫ﻧﻼﺣﻆ أن اﻟﺸﺮط ﻓﻲ اﻟﻤﺜﺎل ﻳﺤ ﺪد اﻟﺪرﺟ ﻪ ﺑ ﻴﻦ ) ‪ 90‬ﻟﻐﺎﻳ ﺔ ‪ ( 100‬ﻟﻴﻌﻄ ﻲ درﺟ ﺔ اﻷﻣﺘﻴ ﺎز‪,‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﻪ اﻟﺸﺮط أﻋﻼﻩ ﺑﺄﺳﺘﺨﺪام أﻳﻌﺎز ﺗﺤﺪﻳﺪ اﻟﻤﺪى ) ‪ , ( in‬وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪If degree in [ 90 .. 100 ] then‬‬
‫; ) ' ‪Writeln ( ' Excellent‬‬
‫ﻟﻜﻲ ﻧﺴﺘﺨﺪم اﻷﻳﻌﺎز أو اﻷﻣﺮ ) ‪ ( in‬ﻟﺘﺤﺪﻳﺪ اﻟﻤﺪى ﻧﺴﺘﺨﺪم ﺑﻌﺪﻩ ﻗﻮﺳ ﻴﻦ ﻣ ﺮﺑﻌﻴﻦ وﺗﺤ ﺪد ﺑﺪاﻳ ﺔ‬
‫وﻧﻬﺎﻳﺔ اﻟﻤﺪى ﻋﻠﻰ أن ﻳﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﻧﻘﻄﺘﺎن آﻤ ﺎ ﻣﻮﺿ ﺢ ﻓ ﻲ اﻟﻤﺜ ﺎل أﻋ ﻼﻩ ‪ .‬أن اﻟﺘﺮﺟﻤ ﻪ اﻟﺤﺮﻓﻴ ﻪ ﻟﻬ ﺬﻩ‬
‫اﻟﻌﺒﺎرﻩ هﻲ ) أذا اﻟﺪرﺟﻪ ﻓﻲ اﻟﻤﺪى اﻟﻤﺤﺪد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺮﺑﻌﻴﻦ ﻓﺄآﺘﺐ آﺬا ( ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻣﻤﻜﻦ أن ﻧﺴﺘﺨﺪﻣﻬﺎ ﺑﻄﺮﻳﻘﻪ أﺧﺮى ‪ ,‬ﻓﺒ ﺪﻻ ﻣ ﻦ أن ﻧﺤ ﺪد اﻟﻤ ﺪى آﺒﺪاﻳ ﻪ وﻧﻬﺎﻳ ﻪ ﻳﻤﻜ ﻦ‬
‫اﻷﺳﺘﻌﺎﺿﻪ ﻋﻨﻬﺎ ﺑﻘﻴﻢ ﻣﻌﻴﻨﻪ ﺑﺤﻴﺚ أن اﻟﻤﺘﻐﻴﺮ ﻣﻤﻜﻦ أن ﻳﻜﻮن واﺣﺪ ﻣﻦ هﺬﻩ اﻟﻘﻴﻢ ‪ .‬ﻣﺜﺎل‬
‫‪If x in [ 5 , 10, 20, 35, 50 ] then‬‬
‫; ) ' ‪Writeln ( ' OK‬‬
‫هﻨ ﺎ ه ﺬا ﻳﻌﻨ ﻲ أذا آﺎﻧ ﺖ ﻗﻴﻤ ﺔ ) ‪ ( x‬ه ﻲ أﺣ ﺪى اﻟﻘ ﻴﻢ اﻟﻤﺤ ﺪدﻩ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ اﻟﻤ ﺮﺑﻌﻴﻦ ﻓﺄآﺘ ﺐ‬
‫) ‪ ( OK‬أي أن ﻋﻤﻠﻴﺔ اﻟﺘﻄﺎﺑﻖ ﺳﺘﻜﻮن ﻣﻊ واﺣﺪﻩ ﻣﻦ هﺬﻩ اﻟﻘﻴﻢ ﺑﻴﻨﻤﺎ ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﻓﺄن أي ﻗﻴﻤﻪ ﺑﻴﻦ‬
‫اﻟﻘﻴﻤﺘﻴﻦ اﻟﻤﺤﺪدﺗﻴﻦ ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬
‫ﺛﺎﻟﺜﺎ ‪ //:‬اﻟﺤﺎﻟﻪ اﻟﺜﺎﻟﺜﻪ ﻻﺗﺨﺘﻠﻒ ﻋﻦ اﻟﺤ ﺎﻟﺘﻴﻦ اﻟ ﺴﺎﺑﻘﺘﻴﻦ وﻟﻜ ﻦ ﺑ ﺪل ﻣ ﻦ أﺳ ﺘﺨﺪام اﻷرﻗ ﺎم ﻣﻤﻜ ﻦ‬
‫أﺳﺘﺨﺪام اﻟﺤﺮوف ‪ .‬ﻣﺜﺎل‬
‫‪If ch in [ 'a' .. 'z' ] then‬‬
‫; ) ' ‪Writeln ( ' small character‬‬
‫‪OR‬‬
‫‪If ch in [ 'a' , ' b ' , 'c ' ] then‬‬
‫; ) ' ‪Writeln ( ' OK‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

48

//: ‫ﻣﻼﺣﻈﻪ‬
‫ ( آﻤﺎ‬in ) ‫ ( ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ اﻟﻤﺪى ﺑﺪون اﻷﻣﺮ‬.. ) ‫ﻣﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻟﻨﻘﻄﺘﻴﻦ اﻟﻤﺘﺠﺎورﺗﻴﻦ‬
( case ) ‫ﻧﻌﻤﻞ ﻣﻊ‬
: ‫ﻣﺜﻞ‬
Case x of
90 .. 100 : writeln ( ' Excellent ' ) ;

‫ أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬3.10
. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﺑﻴﻦ رﻗﻤﻴﻦ‬

Program CH3_Program10;
Var
X,y:integer;
Begin
Writeln ('Enter two numbers');
Readln(x, y);
If(x>y) then
Writeln ('the largest number =', x)
Else
Writeln ('the largest number =, y);
End.

‫ ( ﺣﻴﺚ أن‬z ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬
and

Z = 5x2 +3x/y
Z = y2 – 3x

when x >= y
when x < y

Program CH3_Program11;
Var
X, y: integer;
z: real;
Begin
Writeln ('Enter x and y ');
Readln(x);
readln(y);
If(x>=y) then
Z: =5*sqr(x) + 3*x/y
Else
Z: =sqr(y)-3*x;
Writeln (z);
End.

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

49

. ( 35 – 55 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ اﻷرﻗﺎم اﻟﻔﺮدﻳﻪ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﺮﻗﻤﻴﻦ‬

Program CH3_Program12;
Var
I:integer;
Begin
For i: = 35 to 55 do
begin
If (i mod 2<>0) then
Continue ;
Write (i: 4);
End;
End.

. ( 2 – 100) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺠﻤﻮع اﻷرﻗﺎم اﻟﺰوﺟﻴﻪ اﻟﻤﺤﺪدﻩ ﺑﻴﻦ اﻟﺮﻗﻤﻴﻦ‬

Program CH3_Program13;
Var
I, sum: integer;
Begin
Sum: =0;
For i: =2 to 100 do
If (I mod 2=0) then
Sum: =sum+I;
Writeln (sum);
End.

. ‫ ( ﻋﺪد‬15 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد أآﺒﺮ وأﺻﻐﺮ ﻋﺪد ﻣﻦ ﺑﻴﻦ‬
Program CH3_Program14;
Var
X,max,min:integer;
Begin
Writeln ('Enter first number');
Readln(x);
Max: =x;
min: =x;
For i: =1 to 14 do
Begin
Readln(x);
If(x>max) then
Max: =x;
Else
If(x<min) then
Min: =x;
End;
Writeln ('max number=', max);
Writeln ('min number=', min);
End.

50

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ( 0 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺠﻤﻮع ﻋﺪد ﻣﻦ اﻷرﻗﺎم أﺧﺮ رﻗﻢ ﻓﻴﻬﺎ ﻳﺴﺎوي‬

Program CH3_Program15;
Var
Sum, x: integer;
Begin
Sum: =0;
Repeat
Writeln ('Enter new number');
Readln(x);
Sum: =sum+x;
Until(x=0);
Writeln (sum);
End.

. ( 12 )‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﻌﺪل ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻷرﻗﺎم أﺧﺮ رﻗﻢ ﻓﻴﻬﺎ هﻮ‬

Program CH3_Program16;
Var
Sum, x, count: integer;
Begin
Sum: =0;
count: =0;
Writeln ('Enter first number in group');
Readln(x);
While(x<>12) do
Begin
Sum: =sum+x;
Inc (count);
Readln(x);
End;
Writeln (sum/count);
End.

‫ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ ﻓ ﻲ اﻟﻤﻌﺎدﻟ ﻪ‬
(n) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻷﻳﺠ ﺎد ﻧ ﺎﺗﺞ‬
2/1*2/3*4/3*4/5*6/5*6/7………
Program CH3_Program17;
Var
I, n: integer;
sum: real;
Begin
Writeln ('Enter number of elements ');
Readln (n);
Sum: =1;
For i: =1 to n do
Begin
If (I mod 2=0) then
Sum: =sum * i/ (i+1);
Else
Sum: =sum * (i+1)/i;
End;
Writeln (sum);
End.

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

51

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﻌﺪد اﻷﺻﻐﺮ ﺑﻴﻦ ﺛﻼث أﻋﺪاد‬

Program CH3_Program18;
Var
X,y,z:integer;
Begin
Writeln ('Enter three numbers');
Readln(x, y, z);
If(x<y) and (x<z) then
Writeln ('min number=', x)
Else
If(y<x) and (y<z) then
Writeln ('min number=',y)
Else
Writeln ('min number=',z);
End.

‫) ﻣ ﺜﻼ اﻟﻌ ﺪد‬. ‫أآﺘﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻋ ﺪد ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤ ﻮع أرﻗﺎﻣ ﻪ واﻟ ﺮﻗﻢ اﻷآﺒ ﺮ ﺑ ﻴﻦ أرﻗﺎﻣ ﻪ‬
( (7) ‫( واﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻴﻪ هﻮ‬18) ‫ ﻓﺄن ﻣﺠﻤﻮع أرﻗﺎﻣﻪ هﻲ‬5472

Program CH3_Program19;
Var
X,z:integer;
Begin
Writeln ('Enter number');
Readln(x);
Repeat
Z: = x mod 10;
Write (z);
If (z > max) then
Max: =z;
X: =x div 10;
Until(x=0);
Writeln ('max number=', max);
End.

(

‫ ( اﻟﻰ ﺛﻨﺎﺋﻲ‬decimal number ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﺤﻮﻳﻞ اﻟﺮﻗﻢ اﻟﻌﺸﺮي‬
. binary number )
Program CH3_Program20;
Var
Sum, I, x, b: integer;
Bagin
Sum: =0;
i: =1;
Writeln ('Enter decimal number');
Readln(x);
While(x<>0) do
Begin
B: =x mod 2;
Sum: =sum+ i*b;
X: =x div 2;
I: =i*10;
End;
Writeln (sum);
End.

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

52

: ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ ﻣﺎﻳﻠﻲ‬

0 3 6 9 …n
3 6 9…n
6 9…n
9…n
.
n

Program CH3_Program19;
Var
N,x,x1:integer;
Begin
Writeln ('Enter the last number N');
Readln (n);
If (n mod 3 = 0) then
Begin
X: =0;
While(x<=n) do
Begin
X1:=x;
Repeat
Write(x1:6);
Inc(x1,3);
Until(x1>n);
writeln;
x:=x+3;
End; {while}
End
{ if }
Else
writeln('Error, number N should divede by 3');
End.

*
*
*
*
*
*
*
Program CH_3 Program20;
Var
I:integer;
Begin
For i: = 3 downto -3 do
Writeln ('*': 10 + abs (i));
End.

: ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻄﺒﺎﻋﺔ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪53‬‬

‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬
‫اﻟﻤﺼﻔﻮﻓﺎت ‪ARRAYS‬‬
‫‪4.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫ﺳﻴﺘﻢ اﻟﺘﺮآﻴﺰ ﻓﻲ هﺬا اﻟﻔﺼﻞ ﻋﻠﻰ اﻟﻤﺼﻔﻮﻓﺎت ﺑﻨﻮﻋﻴﻬﺎ اﻷﺣﺎدي واﻟﺜﻨ ﺎﺋﻲ ﻣ ﻊ أﻣﺜﻠ ﻪ ﺗﻮﺿ ﻴﺤﻴﻪ‬
‫ﻟﻘﺮاءة وﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﺎت واﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﻣﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻴﻬﺎ‪.‬‬
‫‪4.2‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪ARRAYS‬‬

‫اﻟﻤ ﺼﻔﻮﻓﻪ ه ﻲ هﻴﻜ ﻞ ﺑﻴﺎﻧ ﺎت ﻳﺨ ﺰن ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﻟﻬ ﺎ ﻧﻔ ﺲ اﻟﻨ ﻮع ‪ .‬ه ﻲ ﻣ ﺸﺎﺑﻬﻪ‬
‫ﻟﻤﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺼﻨﺎدﻳﻖ ﻣﺮﺗﺒﻄﻪ واﺣﺪﻩ ﺑﺎﻷﺧﺮى ﺑﺸﻜﻞ ﻣﺘﺴﻠﺴﻞ وآﻞ واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻟ ﺼﻨﺎدﻳﻖ ﻣﻤﻜ ﻦ‬
‫أن ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﺑﻴﺎﻧ ﺎت ﻣﻌﻴﻨ ﻪ وﺟﻤﻴ ﻊ اﻟﺒﻴﺎﻧ ﺎت ﻓ ﻲ ه ﺬﻩ اﻟ ﺼﻨﺎدﻳﻖ ه ﻲ ﻣ ﻦ ﻧ ﻮع واﺣ ﺪ ‪ .‬وﻳﻘ ﺎل ﻋ ﻦ‬
‫اﻟﻤﺼﻔﻮﻓﻪ أﻧﻬﺎ هﻴﻜﻞ ﺑﻴﺎﻧﻲ ﺛﺎﺑﺖ ) ‪ ( static‬وذﻟﻚ ﻷن اﻟﻤﺒﺮﻣﺞ ﻋﻨﺪﻣﺎ ﻳﻌﻠﻦ ﻋﻦ ﻧﻮع وﺣﺠﻢ اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴ ﺮات ‪ ,‬ﻓ ﺎن ﺣﺠﻤﻬ ﺎ ﺳ ﻴﺒﻘﻰ ﺛﺎﺑ ﺖ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ وﻻ ﻳﻤﻜ ﻦ ﺗﻐﻴﻴ ﺮﻩ ‪ ,‬وهﻨ ﺎك‬
‫اﻟﻤ ﺼﻔﻮﻓﺎت اﻟﺪﻳﻨﺎﻣﻴﻜﻴ ﻪ ) ‪ ( dynamic‬اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﻧﻐﻴ ﺮ ﺣﺠﻤﻬ ﺎ أﺛﻨ ﺎء ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ‪.‬‬
‫ﻧﺴﺘﺨﺪم ﻟﻠﻤﺼﻔﻮﻓﻪ ﻣﺘﻐﻴﺮا ﻣﻔﺮدا ﻓﻘﻂ آﺎداة ﻟﺨﺰن اﻟﺒﻴﺎﻧﺎت ‪ ,‬وهﺬا اﻟﻤﺘﻐﻴﺮ ﻳﺨﺰن ﻋﻨﻮان اﻟﻤﻮﻗ ﻊ اﻻول‬
‫ﻓﻲ اﻟﺬاآﺮﻩ اﻟﺬي ﺗﺨﺰن ﻓﻴﻪ اﻟﻤﺼﻔﻮﻓﻪ وﺑﺎﻗﻲ اﻟﻤﻮاﻗﻊ ﺗﺄﺗﻲ ﺑﻌﺪﻩ ﺑﺎﻟﺘﺘﺎﺑﻊ ) ﻣﺘﺴﻠﺴﻠﻪ ( ‪.‬‬

‫اﻟﻤﺼﻔﻮﻓﺎت ‪//:‬‬
‫هﻲ ﻣﺠﻤﻮﻋﻪ ﻣﺮﺗﺒﻪ ﻣﻦ اﻟﺒﻴﺎﻧﺎت واﻟﺘﻲ ﻗﺪ ﺗﺤﺘﻮي ﻋﻠﻰ ﻋﺪد ﺛﺎﺑﺖ ﻣﻦ اﻟﻌﻨﺎﺻﺮ أو ﻏﻴﺮ ﺛﺎﺑﺖ ‪,‬‬
‫وﺗﺴﺘﺨﺪم أﺳﻠﻮب اﻟﻌﻨﻮان اﻟﻤﺤﺴﻮب ﻷﻳﺠﺎد ﻣﻮﻗﻊ اﻟﺨﻠﻴﻪ اﻟﻤﻄﻠﻮﺑﻪ ﻓﻲ اﻟﺬاآﺮﻩ وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ‬
‫ﻣﻌﺎدﻻت رﻳﺎﺿﻴﻪ‪.‬‬

‫ﺑﺸﻜﻞ ﻋﺎم ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﻧﻮﻋﺎن ) هﻨﺎك ﻣﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدﻩ اﻟﻤ ﺴﺘﻮﻳﺎت ه ﻲ ﺧ ﺎرج ﻧﻄ ﺎق ه ﺬا‬
‫اﻟﻜﺘﺎب ( ‪ ,‬ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ وﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ‪.‬‬
‫‪ 4.2.1‬اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪: ONE DIMENSION ARRAY‬‬
‫ﻧﺒﺪأ هﻨﺎ ﻣﺮﺣﻠ ﻪ ﺟﺪﻳ ﺪﻩ ﻣ ﻦ اﻟﺒﺮﻣﺠ ﻪ ‪ .‬ﻟﻐﺎﻳ ﺔ اﻷن ﻟ ﺴﻨﺎ ﻗ ﺎدرﻳﻦ ﻋﻠ ﻰ ﻣﻌﺎﻟﺠ ﻪ وﺧ ﺰن‬
‫آﻤﻴﺎت آﺒﻴ ﺮﻩ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ﺑﻄﺮﻳﻘ ﻪ ﻣﻨﺎﺳ ﺒﻪ ‪ .‬ﻓﻤ ﺜﻼ أذا أردﻧ ﺎ اﻟﻌﻤ ﻞ ﻋﻠ ﻰ ﻗﺎﺋﻤ ﻪ ﻃﻮﻳﻠ ﻪ ﻣ ﻦ اﻷﻋ ﺪاد أو‬
‫اﻷﺳﻤﺎء ‪ ,‬ﻓﺄﻧﻨﺎ ﺳﻨﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﻨﻔﺼﻠﻪ ﻟﻜﻞ ﻋﺪد أو أﺳﻢ ‪ .‬ﻟﺤ ﺴﻦ اﻟﺤ ﻆ ﻓ ﺄن ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل‬
‫وﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ اﻷﺧﺮى ﺗﻮﻓﺮ ﻋﺪد ﻣﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻬﻴﻜﻠﻪ ﻟﺘﺴﻬﻴﻞ ﺣﻞ اﻟﻤﺸﺎآﻞ اﻟﺘﻲ ﺗﺤﺘﺎج اﻟﻰ اﻟﻌﻤﻞ‬
‫ﻣﻊ آﻤﻴﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧ ﺎت ‪ ,‬ﺑﺒ ﺴﺎﻃﻪ ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮ ﻣ ﻦ ه ﺬا اﻟﻨ ﻮع ﻳ ﺴﺘﺨﺪم ﻣﻌ ﺮف واﺣ ﺪ ﻟﺨ ﺰن آﻤﻴ ﻪ‬
‫آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻓﻲ اﻟﺬاآﺮﻩ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪54‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﺼﻤﻤﻪ ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ﺑﻄﺮﻳﻘﻪ ﻣﻨﻈﻤﻪ ‪ .‬أن أﺳﺘﺨﺪام‬
‫اﻟﻤﺼﻔﻮﻓﻪ ﻳﺴﻤﺢ ﺑﺤﺠﺰ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ ﻣﻮاﻗ ﻊ اﻟ ﺬاآﺮﻩ اﻟﻤﺘﺘﺎﻟﻴ ﻪ واﻟﺘ ﻲ ﻳﻤﻜﻨﻨ ﺎ ﻣﻌﺎﻟﺠﺘﻬ ﺎ آﻜﺘﻠ ﻪ واﺣ ﺪﻩ أو‬
‫ﻣﻜﻮﻧﺎت ﻣﻨﻔﺼﻠﻪ ‪.‬‬
‫أذن اﻟﻤ ﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳ ﻪ ه ﻲ اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ آﺘﺎﺑ ﺔ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻒ أو ﻋﻤ ﻮد‬
‫واﺣﺪ وﻳﻜﻮن ﻋﺪد اﻟﻌﻨﺎﺻﺮ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮﻩ ﻟﺨ ﺰن ه ﺬﻩ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴﻬ ﺎ ﻣ ﺴﺎوﻳﺎ اﻟ ﻰ‬
‫ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ‪.‬‬
‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻳﺎﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;>‪<arrayName> : Array [n..m] Of <Data Type‬‬
‫ﻣﻤﻜﻦ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ﺗﺄﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Var‬‬
‫;‪myArray : Array [1..20] of Integer‬‬
‫ﺣﻴﺚ ﻳﺘﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات وﻳﻜﻮن ‪:‬‬
‫أوﻻ ‪ //:‬ﺑﺄﻋﻄ ﺎء أﺳ ﻢ ﻟﻠﻤ ﺼﻔﻮﻓﻪ هﻨ ﺎ ) ‪ ( myarray‬وه ﻮ ﻣﺘﻐﻴ ﺮ وﻳ ﺘﻢ أﺧﺘﻴ ﺎرﻩ ﻣ ﻦ ﻗﺒ ﻞ‬
‫اﻟﻤﺒﺮﻣﺞ ‪ ,‬ﺛﻢ ﺗﺄﺗﻲ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن آﻤﺎ ﻓﻲ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ //:‬ﻧﻜﺘﺐ آﻠﻤﺔ ﻣﺼﻔﻮﻓﻪ ) ‪ ( array‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أن هﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻣ ﻦ ﻧ ﻮع ﻣ ﺼﻔﻮﻓﻪ‬
‫واﻟﻤ ﺼﻔﻮﻓﻪ ﻳﺠ ﺐ أن ﻳﻜ ﻮن ﺣﺠﻤﻬ ﺎ ﻣﺤ ﺪد ﻗﺒ ﻞ اﻟﺒ ﺪأ ﺑﺘﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻟ ﺬا ﺳ ﻴﻜﻮن اﻟﺘﻌﺮﻳ ﻒ ) ﻣ ﺼﻔﻮﻓﻪ‬
‫ﺣﺠﻤﻬ ﺎ آ ﺬا وﻋﻨﺎﺻ ﺮهﺎ ﻣ ﻦ اﻟﻨ ﻮع اﻟﻤﺤ ﺪد ( ‪ ,‬ﻋﻤﻠﻴ ﺔ ﺗﺤﺪﻳ ﺪ اﻟﺤﺠ ﻢ ﻳﻜ ﻮن ﺑﺄﺳ ﺘﺨﺪام أﻗ ﻮاس ﻣﺮﺑﻌ ﻪ‬
‫وﺑﺪاﺧﻠﻬﺎ اﻟﺤﺠﻢ وهﻮ ﻳﺘﻜﻮن ﻣﻦ ﺟﺰﺋﻴﻦ ﺗﻔﺼﻞ ﺑﻴﻨﻬﻤﺎ ﻧﻘﻄﺘﺎن ﻓﻘﻂ ) ﻟﻠﺪﻻﻟﻪ ﻋﻠ ﻰ اﻟﻤ ﺪى اﻟ ﺬي ﺗﻌﻤ ﻞ ﺑ ﻪ‬
‫اﻟﻤﺼﻔﻮﻓﻪ ( ‪ ,‬اﻟﺠﺰء اﻷول ﻳﻤﺜﻞ رﻗﻢ اﻟﺒﺪاﻳﻪ واﻟﺜﺎﻧﻲ ﻳﻤﺜﻞ رﻗﻢ اﻟﻨﻬﺎﻳﻪ ‪ ,‬وﻋﻠﻴﻪ اﻟﻔ ﺮق ﺑﻴﻨﻬﻤ ﺎ ﻳﻤﺜ ﻞ ﻋ ﺪد‬
‫اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ) ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ( ‪ .‬أن ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ﻳﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ وﻓﻘﺎ ﻟﻤﺘﻄﻠﺒ ﺎت‬
‫اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬
‫أن أﺳﺘﺨﺪام اﻟﻤ ﺼﻔﻮﻓﻪ ﻣ ﺸﺎﺑﻪ ﻷﺳ ﺘﺨﺪام اﻟﻤﺘﻐﻴ ﺮات اﻷﻋﺘﻴﺎدﻳ ﻪ وﺑ ﺪﻻ ﻣ ﻦ أن ﻧ ﺴﺘﺨﺪم ﻋ ﺸﺮﻳﻦ‬
‫ﻣﺘﻐﻴﺮ آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل أﻋﻼﻩ ﻣ ﻦ ﻧ ﻮع أﻋ ﺪاد ﺻ ﺤﻴﺤﻪ ‪ ,‬ﻳﻤﻜ ﻦ أن ﻧ ﺴﺘﺨﺪم ﻣﺘﻐﻴ ﺮ واﺣ ﺪ آﻤ ﺼﻔﻮﻓﻪ ) أي‬
‫آﻤﺠﻤﻮﻋﺔ ﻣﺘﻐﻴﺮات ﺣ ﺴﺐ ﺣﺠ ﻢ اﻟﻤ ﺼﻔﻮﻓﻪ ) ﺳ ﻴﺘﻢ ﺣﺠ ﺰ ﻣﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮﻩ وﻓﻘ ﺎ ﻟ ﺬﻟﻚ ( ‪ ,‬ﻟﻬ ﺎ ﻧﻔ ﺲ‬
‫اﻷﺳﻢ ) أي أن ﺟﻤﻴﻊ هﺬﻩ اﻟﻤﻮاﻗﻊ ﻟﻬ ﺎ ذات اﻷﺳ ﻢ ( وﺗﺨﺘﻠ ﻒ ﺑﺎﻟﻔﻬﺮﺳ ﻪ ) ‪ ( index‬أي ﻟﻜ ﻞ واﺣ ﺪ ﻣﻨﻬ ﺎ‬
‫رﻗ ﻢ ﻳ ﺸﺎر ﺑ ﻪ ﻟﻠﻤﻮﻗ ﻊ ) ﻟﻠﺘﻤﻴﻴ ﺰ ﺑ ﻴﻦ ﻣﺘﻐﻴ ﺮ وأﺧ ﺮ( ( ‪ ,‬أن اﻟﻌﻤ ﻞ ﻣ ﻊ اﻟﻤ ﺼﻔﻮﻓﺎت ﻳ ﺴﺎﻋﺪ ﻋﻠ ﻰ ﺗ ﺴﻬﻴﻞ‬
‫اﻟﻌﻤ ﻞ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات واﻟﻤﺤﺎﻓﻈ ﻪ ﻋﻠ ﻰ ﻗ ﻴﻢ اﻟﻌﺪﻳ ﺪ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات وﺗﻤﻜ ﻦ اﻟﻤﺒ ﺮﻣﺞ ﻣ ﻦ أﺟ ﺮاء أﻋﻤ ﺎل‬
‫آﺜﻴﺮﻩ ﺑﻴﺴﺮ وﺳﻬﻮﻟﻪ ‪.‬‬
‫•‬

‫آﻴﻔﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪:‬‬

‫ﻟﻨﺄﺧﺬ اﻟﻤﺜﺎل أﻋﻼﻩ واﻟﺬي أﻋﻠﻨﺎ ﻓﻴﻪ ﻋﻦ ﻋﺸﺮﻳﻦ ﻋﻨﺼﺮ ﻓﺄﻧﻨﺎ ﻳﻤﻜﻨﻨ ﺎ اﻟﻮﺻ ﻮل اﻟ ﻰ آ ﻞ ﻋﻨ ﺼﺮ‬
‫ﻓﻴﻬﺎ وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫أوﻻ ‪ // :‬أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪55‬‬

‫ﺣﻴﺚ ﻳﻤﻜﻦ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ) ﺣ ﺴﺐ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ ( ﻷي ﻋﻨ ﺼﺮ‬
‫ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ وذﻟﻚ ﻣﻦ ﺧﻼل ﺗﺤﺪﻳﺪ رﻗﻢ أو ﺗﺴﻠﺴﻞ اﻟﻌﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ﺛﻢ اﻟﻤﺴﺎواة ﻣ ﻊ اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ‬
‫ﻣﻦ اﻟﻤﻔﺘﺮض وﺿﻌﻬﺎ ﻓﻴﻪ ) أو ﻣﻦ ﺧﻼل أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ ( وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫>‪<arrayName> [index] := <relevant data‬‬
‫;‪myArray[5] := 10‬‬
‫;‪myArray[1] := 25‬‬
‫‪OR‬‬
‫; ) ]‪Readln ( myArray[1‬‬
‫هﻨﺎ ﺗﻢ أﺳﻨﺎد اﻟﻘﻴﻤﻪ ) ‪ ( 10‬اﻟﻰ اﻟﻤﺘﻐﻴﺮ أو اﻟﻤﻮﻗ ﻊ اﻟﺨ ﺎﻣﺲ ) ﻻﺣ ﻆ آﻴﻔﻴ ﺔ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻣﻮﻗ ﻊ‬
‫اﻟﻌﻨﺼﺮ‪ ,‬ﻳﻮﺿﻊ رﻗﻢ اﻟﻤﻮﻗ ﻊ ﺑ ﻴﻦ ﻗﻮﺳ ﻴﻦ ﻣ ﺮﺑﻌﻴﻦ ( ﺑﻴﻨﻤ ﺎ ﺗ ﻢ أﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) ‪ ( 25‬اﻟ ﻰ اﻟﻤﻮﻗ ﻊ اﻷول‬
‫وﺳﺘﺒﻘﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻬﺬﻩ اﻟﻤﻮاﻗﻊ أﻻ أذا ﺗﻢ ﺗﻐﻴﻴﺮهﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ‪ ,‬ﻓﻌﻨ ﺪﻣﺎ ﻧﺮﻳ ﺪ ﻃﺒﺎﻋ ﺔ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ‬
‫اﻷول ﻓﺴﻨﺠﺪ ﻓﻴﻪ اﻟﻘﻴﻤﻪ ) ‪ .( 25‬أن ﻃﺮﻳﻘﺔ أدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻄ ﺮق اﻟﺘ ﻰ‬
‫ﺳﺒﻖ وأن ﺑﻴﻨﺎهﺎ ﻷدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ ‪ .‬ﻟﻨﻼﺣﻆ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬
‫; ‪Program CH4_Program1‬‬
‫‪Var‬‬
‫‪myVar‬‬
‫;‪: Integer‬‬
‫;‪myArray : Array[1..5] of Integer‬‬
‫‪Begin‬‬
‫;‪myArray[2] := 25‬‬
‫;]‪myVar := myArray[2‬‬
‫‪End.‬‬

‫هﻨ ﺎ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( myvar‬ه ﻮ ﻣﺘﻐﻴ ﺮ أﻋﺘﻴ ﺎدي ﺑﻴﻨﻤ ﺎ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( myarray‬ه ﻮ ﻣ ﺼﻔﻮﻓﻪ‬
‫ﺣﺠﻤﻬﺎ ﺧﻤﺴﺔ ﻋﻨﺎﺻﺮ‪ ,‬أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺗﻢ أدﺧﺎل اﻟﻘﻴﻤﻪ ) ‪ ( 25‬ﻟﻠﻤﻮﻗﻊ اﻟﺜﺎﻧﻲ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ‪ ,‬وﻓ ﻲ‬
‫اﻟﺨﻄﻮﻩ اﻟﻼﺣﻘﻪ ﺗﻢ ﻣﺴﺎواة اﻟﻌﻨﺼﺮ اﻟﺜﺎﻧﻲ ﻣﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻣﻊ اﻟﻤﺘﻐﻴﺮ ) ‪ ( myvar‬وهﺬا ﺳﻴﺆدي ‪:‬‬
‫•‬

‫ﺗﻌ ﻮﻳﺾ ﻗﻴﻤ ﺔ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ اﻟﺜ ﺎﻧﻲ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﻪ ﺑ ﺪﻻ ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮ‬
‫) ]‪ ( myarray[2‬أي ﺳ ﻴﻜﻮن اﻟﻄ ﺮف اﻷﻳﻤ ﻦ ﻣ ﻦ اﻟﻤﻌﺎدﻟ ﻪ ﻳﺤﺘ ﻮي ﻋﻠ ﻰ اﻟﻌ ﺪد اﻟ ﺼﺤﻴﺢ‬
‫) ‪. ( 25‬‬

‫•‬

‫ﺳﺘﺆول هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﻰ اﻟﻄﺮف اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﻌﺎدﻟ ﻪ ) أي أن اﻟﻤﺘﻐﻴ ﺮ ‪ myvar‬ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ‬
‫هﻲ ‪ . ( 25‬وهﻲ ﻧﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻧﺘﻌﺎﻣﻞ ﺑﻬﺎ ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ //:‬أﺳﻨﺎد ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬

‫ﻓﻲ آﻞ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ ﻣﺼﻔﻮﻓﺎت ﻳﺠﺐ اﻟﻘﻴﺎم ﺑﺄدﺧ ﺎل ﻗ ﻴﻢ ﻟﻌﻨﺎﺻ ﺮ اﻟﻤ ﺼﻔﻮﻓﻪ ﻗﺒ ﻞ‬
‫أن ﻧﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ‪ ,‬وأن ﻋﻤﻠﻴﺔ أدﺧﺎل ﻗﻴﻢ ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ﺗ ﺘﻢ أﻣ ﺎ ﻣ ﻦ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ أو ﻣ ﻦ ﺧﺎرﺟ ﻪ‬
‫آﻤ ﺎ آ ﺎن اﻟﺤ ﺎل ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻷﻋﺘﻴﺎدﻳ ﻪ ‪ .‬ﻟ ﻨﻼﺣﻆ اﻟﻤﺜ ﺎل اﻟﺘ ﺎﻟﻲ واﻟ ﺬي ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻣ ﺼﻔﻮﻓﺘﻴﻦ‬
‫ﻣﻨﻔﺼﻠﺘﻴﻦ دون وﺟﻮد أي ﻋﻼﻗﻪ ﺑﻴﻨﻬﻤﺎ ﺣﻴﺚ أن اﻷوﻟ ﻰ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ واﻟﺜﺎﻧﻴ ﻪ ﻣ ﻦ ﻧ ﻮع‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪56‬‬

‫اﻟﻌﺒﺎرات اﻟﻤﻨﻄﻘﻴﻪ وﺳﻨﻀﻊ اﻟﻘﻴﻤ ﻪ )‪ (0‬ﻟﻜ ﻞ ﻋﻨﺎﺻ ﺮ اﻟﻤ ﺼﻔﻮﻓﻪ اﻻوﻟ ﻰ وﻧ ﻀﻊ اﻟﻘﻴﻤ ﻪ ) ‪ ( false‬ﻟﻜ ﻞ‬
‫ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﺎﻧﻴﻪ آﻤﺎ ﻓﻲ ادﻧﺎﻩ ‪:‬‬

‫; ‪Program CH4_Program2‬‬
‫‪Var‬‬
‫‪i‬‬
‫;‪: Integer‬‬
‫;‪myIntArray : Array[1..20] of Integer‬‬
‫;‪myBoolArray : Array[1..20] of Boolean‬‬
‫‪Begin‬‬
‫‪For i := 1 to 20 do‬‬
‫‪Begin‬‬
‫;‪myIntArray[i] := 0‬‬
‫;‪myBoolArray[i] := false‬‬
‫;‪End‬‬
‫‪End.‬‬

‫ﺛﺎﻟﺜﺎ ‪ //:‬ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ‬
‫ﻧﺤﺘﺎج ﻓﻲ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺒﺮاﻣﺞ اﻟﻰ ﻃﺒﺎﻋﺔ اﻟﻤ ﺼﻔﻮﻓﻪ ‪ ,‬وﻃﺒﻌ ﺎ ﻳﺠ ﺐ أن ﺗﻜ ﻮن اﻟﻤ ﺼﻔﻮﻓﻪ ﻏﻴ ﺮ‬
‫ﺧﺎﻟﻴﻪ ) أي أن ﻋﻨﺎﺻﺮهﺎ أو ﻣﻮاﻗﻌﻬﺎ ﺗﺤﺘﻮي ﻋﻠﻰ ﻗﻴﻢ ( ‪.‬‬
‫أن ﻋﻤﻠﻴ ﺔ آﺘﺎﺑ ﺔ أو ﻃﺒﺎﻋ ﺔ ﻋﻨﺎﺻ ﺮ ﻣ ﺼﻔﻮﻓﻪ ﻣﻌﻴﻨ ﻪ ﻻ ﺗﺨﺘﻠ ﻒ ﻋ ﻦ ﻗ ﺮاءة اﻟﻤ ﺼﻔﻮﻓﻪ ﻋ ﺪا أن‬
‫اﻷﻳﻌ ﺎز اﻟﺨ ﺎص ﺑ ﺎﻟﻘﺮاءﻩ ﻳ ﺴﺘﺒﺪل ﺑﺎﻷﻳﻌ ﺎز اﻟﺨ ﺎص ﺑﺎﻟﻄﺒﺎﻋ ﻪ أو اﻟﻜﺘﺎﺑ ﻪ‬
‫) أي أن ) ‪ ( ( : = OR readln‬ﻳﺘﻢ أﺳﺘﺒﺪاﻟﻬﺎ ﺑﺎﻷﻳﻌﺎز أو اﻷﻣﺮ ) ‪. ( write OR writeln‬‬

‫;‪Program CH4_Program3‬‬
‫‪Var‬‬
‫‪i‬‬
‫;‪: Integer‬‬
‫;‪myIntArray: Array[1..20] of Integer‬‬
‫;‪myBoolArray: Array[1..20] of Boolean‬‬
‫‪Begin‬‬
‫‪For i: = 1 to 20 do‬‬
‫‪Begin‬‬
‫;)]‪Writeln (myIntArray [i‬‬
‫;‪End‬‬
‫‪End.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ‬
‫اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ذﻟﻚ اﻟﻨﻮع ) ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ‬
‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫•‬

‫‪57‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﻀﻐﻮﻃﻪ ‪Packed Array‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﻔﻴﺪﻩ ﺟﺪا ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴ ﺆﻩ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ‪ ,‬واﺣ ﺪﻩ ﻣ ﻦ ﺳ ﻠﺒﻴﺎت أﺳ ﺘﺨﺪام اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫ه ﻲ أﺣﺘﻴﺎﺟﻬ ﺎ اﻟ ﻰ آﻤﻴ ﻪ آﺒﻴ ﺮﻩ ﻣ ﻦ اﻟ ﺬاآﺮﻩ ‪ ,‬ﻋﻤﻠﻴ ﺎ اﻟﻤ ﺼﻔﻮﻓﻪ ﻣ ﻦ ﻧ ﻮع اﻷﺣ ﺮف ) اﻟﺘ ﻲ ﻋﻨﺎﺻ ﺮهﺎ‬
‫ﺣﺮوف ( ﺗﺤﺠﺰ ذاآﺮﻩ أآﺒﺮ ﻣﻦ اﻷﻧﻮاع اﻷﺧﺮى ‪ ..‬ﻟﺸﺮح ذﻟﻚ ﻟﻨﺮى اﻟﺘﻌﺮﻳﻒ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪Var‬‬
‫; ‪X : array [ 1..5 ] of char‬‬
‫ﺑﺎﻟﺘﺄآﻴﺪ ﻓﺄن هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﺤﺠﺰ ﻋﺪد ﻣﻦ اﻟﻤﻮاﻗﻊ ﻓﻲ اﻟﺬاآﺮﻩ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ وﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ‪,‬‬
‫هﻨﺎ ﺳﻴﺘﻢ ﺣﺠﺰ ﺧﻤﺴﺔ ﻣﻮاﻗﻊ ) ﻣﻮﻗﻊ ﻟﻜﻞ ﻋﻨﺼﺮ ( وﻟﻤﺎ آﺎن ﻧﻮع اﻟﻌﻨﺎﺻﺮ ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻲ ﻓﺴﻴﻌﺎﻣﻞ‬
‫آﻞ ﺣﺮف آﻜﻠﻤﻪ ) ‪ ( word‬ﻓﻲ اﻟﺬاآﺮﻩ ‪ ,‬وآﻞ آﻠﻤﻪ ﺗﺘﻜﻮن ﻣﻦ ﻋﺪد ﻣﻦ اﻟﺒﺎﻳﺘﺎت ‪ .‬ﻟﻮ ﻓﺮﺿﻨﺎ أن اﻟﻜﻠﻤﻪ‬
‫ﺗﺘﻜﻮن ﻣﻦ أرﺑﻊ ﺑﺎﻳﺘﺎت ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﺳﺘﺤﺠﺰ ) ‪ ( 20‬ﺑﺎﻳﺖ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫ﻓﺄذا أﺳﻨﺪﻧﺎ آﻠﻤﺔ ) ‪ ( HELLO‬آﻌﻨﺎﺻﺮ ﻟﻠﻤﺼﻔﻮﻓﻪ ﻓﺴﺘﻜﻮن اﻟﻤﺼﻔﻮﻓﻪ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪H‬‬
‫‪E‬‬
‫‪L‬‬
‫‪L‬‬
‫‪O‬‬
‫ﻧﻼﺣﻆ أن هﻨﺎك ﺧﻤﺴﺔ ﻋﺸﺮ ﺑﺎﻳﺖ ﻏﻴﺮ ﻣﺴﺘﻐﻠﻪ ‪ ,‬وهﺬا ﺳﻮء أﺳﺘﺨﺪام ﻟﻠﺬاآﺮﻩ ‪ ,‬ﻟﺬا ﻓﺄن ﻟﻐﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻷﻳﻌﺎز ) ‪ ( Packed Array‬ﻟﺘﺤﺪد اﻟﻤﺴﺎﺣﻪ اﻟﺨﺰﻧﻴﻪ ﺑﺄﻗﻞ ﺣﺠﻢ ﻣﻤﻜﻦ وآﻤﺎ‬
‫ﻳﻠﻲ ‪:‬‬
‫‪Var‬‬
‫; ‪X : packed array [ 1..5 ] of char‬‬
‫هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﻮﻟﺪ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘﺎﻟﻴﻪ ﺑﻌﺪ أﺳﻨﺎد اﻟﻜﻠﻤﻪ ) ‪ ( HELLO‬اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ‪:‬‬
‫‪O‬‬
‫هﻨﺎ ﺗﻢ أﺳﺘﺨﺪام آﻠﻤﺘﻴﻦ ﻓﻘﻂ ) أي ‪ 8‬ﺑﺎﻳﺖ ( ‪.‬‬

‫‪L‬‬

‫‪L‬‬

‫‪E‬‬

‫‪H‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪58‬‬

‫‪ 4.2.2‬اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪: 2-D ARRAY‬‬
‫اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ هﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘ ﻲ ﺗﻜﺘ ﺐ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻔﻮف وأﻋﻤ ﺪﻩ ﻓ ﻲ ذات‬
‫اﻟﻮﻗﺖ ) أي ﻳﻜﻮن هﻨﺎك ﻋﺪد ﻣﻦ اﻟﺼﻔﻮف وآﻞ ﺻﻒ ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻ ﺮ وآ ﺬﻟﻚ ﻋ ﺪد ﻣ ﻦ اﻷﻋﻤ ﺪﻩ‬
‫وآﻞ ﻋﻤﻮد ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ ( ‪ ,‬أن ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ‬
‫اﻟﺬاآﺮﻩ ﻳﺴﺎوي ﺣﺎﺻﻞ ﺿﺮب ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ ‪ .‬ﻳ ﺘﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤ ﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ‬
‫ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻳﺘﻢ ﻓﻴﻬﺎ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ﻣﻊ ﻓﺎرق واﺣﺪ ﻓﻘﻂ وهﻮ أن اﻷﻋ ﻼن ﻋ ﻦ‬
‫ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻳﺘﻢ ﻣﻦ ﺧﻼل ﻗﻴﻤﺘﻴﻦ داﺧﻞ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺮﺑﻌﻴﻦ ﺗﻔ ﺼﻞ ﺑﻴﻨﻬﻤ ﺎ ﻓ ﺎرزﻩ‬
‫آ ﻞ واﺣ ﺪﻩ ﻟﻬ ﺎ اﻟﻤ ﺪى اﻟﺨ ﺎص ﺑﻬ ﺎ وﻟ ﻴﺲ ﻗﻴﻤ ﻪ واﺣ ﺪﻩ آﻤ ﺎ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ وﻳﺤﺘ ﻮي اﻟﻤ ﺪى‬
‫اﻷول ﻋﻠﻰ ﻋﺪد اﻟﺼﻔﻮف ﺗﺒﺪأ ﻣﻦ اﻟﺮﻗﻢ واﺣﺪ وﺗﻨﺘﻬﻲ ﺑﺎﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻜﻠ ﻲ ﻟﻠ ﺼﻔﻮف ) وه ﻲ‬
‫ﺗﻤﺜﻞ ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻌﻤﻮد اﻟﻮاﺣﺪ ( ‪ ,‬أﻣﺎ اﻟﻤﺪى اﻟﺜﺎﻧﻲ ﻓﻴﺤﺘﻮي ﻋﻠﻰ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ وﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ‬
‫اﻟﻤﺴﺘﺨﺪﻣﻪ ﻟﻌﺪد اﻟﺼﻔﻮف ) وهﻲ ﺗﻤﺜ ﻞ ﻋ ﺪد اﻟﻌﻨﺎﺻ ﺮ ﻓ ﻲ اﻟ ﺼﻒ اﻟﻮاﺣ ﺪ (‪ .‬أﻣ ﺎ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻋﻨ ﺼﺮ‬
‫ﻣﻌ ﻴﻦ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴ ﺘﻢ ﻣ ﻦ ﺧ ﻼل أﺳ ﻢ اﻟﻤ ﺼﻔﻮﻓﻪ وﻗ ﻮس ﻣﺮﺑ ﻊ ﻳﺤﺘ ﻮي ﻗﻴﻤﺘ ﻴﻦ اﻷوﻟ ﻰ ﺗﻤﺜ ﻞ رﻗ ﻢ‬
‫اﻟﺼﻒ واﻟﺜﺎﻧﻴﻪ ﺗﻤﺜﻞ رﻗﻢ اﻟﻌﻤﻮد ) وﻻ ﻳﺠﻮز أن ﺗﻜﻮن اﻟﻘﻴﻤﻪ اﻷوﻟﻰ ﻟﻸﻋﻤﺪﻩ واﻟﺜﺎﻧﻴﻪ ﻟﻠﺼﻔﻮف (‪.‬‬
‫ﻃﺮﻳﻘﺔ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫;>‪my2DArray : Array [ 1..i , 1..j ] of <DataType‬‬
‫هﻲ ذات اﻟﻄﺮﻳﻘﻪ اﻟﻤﺴﺘﺨﺪﻣﻪ ﻓﻲ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳﻪ ﻋ ﺪا اﻟﻔ ﺮق اﻟ ﺬي ﺳ ﺒﻖ أن‬
‫أﺷﺮﻧﺎ اﻟﻴﻪ ‪.‬‬
‫ﺗﻤﺜﻴﻞ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ) ‪ ( 5 x 5‬ﻣﻨﻄﻘﻴﺎ ﻳﻜﻮن ﻋﻠﻰ ﺷﻜﻞ ﺷﺒﻜﻪ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪5‬‬

‫‪4‬‬

‫‪3‬‬

‫‪2‬‬

‫‪1‬‬
‫‪2‬‬
‫‪3‬‬

‫‪3,4‬‬

‫‪4‬‬
‫‪5,5‬‬

‫‪5,3‬‬

‫‪5‬‬

‫ﺣﻴ ﺚ أن أرﻗ ﺎم اﻟﻤﺮﺑﻌ ﺎت ﻓ ﻲ اﻟ ﺼﻒ اﻷﻓﻘ ﻲ ذات اﻟﻠ ﻮن اﻷﺣﻤ ﺮ ﺗﻤﺜ ﻞ أرﻗ ﺎم اﻷﻋﻤ ﺪﻩ ‪ ,‬ﺑﻴﻨﻤ ﺎ‬
‫أرﻗﺎم اﻟﻤﺮﺑﻌﺎت ﻓﻲ اﻟﺼﻒ اﻟﻌﻤﻮدي ذات اﻟﻠﻮن اﻷﺣﻤﺮ ﺗﻤﺜ ﻞ أرﻗ ﺎم اﻟ ﺼﻔﻮف ‪ .‬أﻣ ﺎ اﻷرﻗ ﺎم اﻟﻤﻮﺟ ﻮدﻩ‬
‫ﻓﻲ اﻟﻤﺮﺑﻌﺎت ذات اﻟﻠﻮن اﻷزرق ﻓﻬﻲ ﺗﻤﺜﻞ رﻗ ﻢ اﻟ ﺼﻒ واﻟﻌﻤ ﻮد ﻟ ﺬﻟﻚ اﻟﻤﻮﻗ ﻊ ) اﻟ ﺮﻗﻢ اﻷول ه ﻮ رﻗ ﻢ‬
‫اﻟ ﺼﻒ واﻟﺜ ﺎﻧﻲ ه ﻮ رﻗ ﻢ اﻟﻌﻤ ﻮد ( ‪ ) ,‬ﻓﻤ ﺜﻼ اﻟ ﺮﻗﻢ ) ‪ ( 3 , 4‬ﻳﻤﺜ ﻞ اﻟﻤﻮﻗ ﻊ أو اﻟﻌﻨ ﺼﺮ اﻟﻤﻮﺟ ﻮد ﻓ ﻲ‬
‫اﻟﺼﻒ اﻟﺜﺎﻟﺚ واﻟﻌﻤﻮد اﻟﺮاﺑﻊ ﻣﻦ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫•‬

‫‪59‬‬

‫آﻴﻔﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪:‬‬

‫أن اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ ﻣﺸﺎﺑﻪ ﻟﻄﺮﻳﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ ﻣ ﻊ اﻷﺧ ﺬ‬
‫ﺑﻨﻈﺮ اﻷﻋﺘﺒﺎر ﺧﺼﻮﺻﻴﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪.‬‬
‫أوﻻ ‪ //:‬أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ‬
‫وﻳﺘﻢ ذﻟﻚ أﻣﺎ ﺑﺄﺳﺘﺨﺪام اﻟﻤﺴﺎواة أو أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ ‪ ,‬ﻣﺜﺎل‬
‫;‪My2DArray [3, 4] := 44‬‬
‫;‪My2DArray [5, 3] := 20‬‬
‫‪OR‬‬
‫;)]‪Readln (My2DArray [1, 2‬‬
‫ﺣﻴﺚ ﺳﻴﺘﻢ وﺿﻊ اﻟﻘﻴﻤﻪ )‪ (44‬ﻓﻲ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺘﻘﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺜﺎﻟ ﺚ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺮاﺑ ﻊ ‪,‬‬
‫وﺗﻮﺿﻊ اﻟﻘﻴﻤﻪ )‪ (20‬ﻓﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺘﻘ ﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺨ ﺎﻣﺲ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺜﺎﻟ ﺚ ) ﻻﺣ ﻆ اﻟ ﺸﻜﻞ‬
‫أﻋﻼﻩ ( ‪ .‬أﻣﺎ آﻴﻔﻴﺔ اﻷﻋﻼن ﻋﻨﻬﺎ ﺑﺮﻣﺠﻴﺎ ﻳﻜﻮن ‪:‬‬

‫;‪Program CH4_Program4‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of Byte‬‬
‫‪Begin‬‬
‫;‪my2DArray [2, 4]:= 10‬‬
‫;]‪myVar := my2DArray [3,4‬‬
‫‪End.‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ أﻋﻼﻩ ﻓﻲ اﻟﻤﺜﺎل ‪ 4‬ﻣ ﻦ ﻧ ﻮع ) ‪ ( byte‬أي أن آ ﻞ ﻋﻨ ﺼﺮ ﺳ ﻴﻤﺜﻞ ﺑﺒﺎﻳ ﺖ واﺣ ﺪ ﻓ ﻲ‬
‫اﻟﺬاآﺮﻩ ‪ .‬وﺳﻨﻤﺜﻠﻬﺎ آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫‪5‬‬

‫‪4‬‬
‫‪10‬‬

‫‪3‬‬

‫‪2‬‬

‫‪1‬‬
‫‪2‬‬
‫‪3‬‬

‫ﺛﺎﻧﻴﺎ ‪ //:‬أدﺧﺎل ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬
‫أن أدﺧﺎل ﻗﻴﻢ ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻳﺤﺘﺎج ﺑﺮﻣﺠﻴ ﺎ اﻟ ﻰ أﺳ ﺘﺨﺪام أواﻣ ﺮ اﻟﺘﻜ ﺮار ) ‪( For‬‬
‫ﻣﺮﺗﻴﻦ وﺑﺸﻜﻞ ﻣﺘﺪاﺧﻞ ‪ ,‬ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻷوﻟﻰ ﻟﻠﺼﻔﻮف واﻟﺜﺎﻧﻴﻪ ﻟﻸﻋﻤﺪﻩ ‪ .‬آﻤﺎ ﻳﻠﻲ ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪60‬‬

‫;‪Program CH4_Program5‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪For j: = 1 to 5 do‬‬
‫;)]‪Readln (my2DArray [i, j‬‬
‫‪End.‬‬

‫ﻓﻲ هﺬا اﻟﺒﺮﻧﺎﻣﺞ أﺳﺘﺨﺪﻣﻨﺎ أﻣﺮ اﻷدﺧﺎل ) ‪ ( readln‬ﻷﻧﺠﺎز ﻋﻤﻠﻴﺔ اﻷدﺧﺎل ﺑ ﺪﻻ ﻣ ﻦ اﻟﻤ ﺴﺎواة‬
‫واﻟﺘﻲ أﺳﺘﺨﺪﻣﺖ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 2‬ﻟﻨﺘﻌﻠﻢ اﻟﻄﺮﻳﻘﺘﻴﻦ ‪.‬‬
‫ﺛﺎﻟﺜﺎ ‪ //:‬ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬
‫ﺗﺘﻢ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﺑﻨﻔﺲ ﻃﺮﻳﻘﺔ ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أﺳ ﺘﺒﺪال أﻣ ﺮ‬
‫اﻟﻘﺮاءﻩ ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ ‪ ,‬ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪Program CH4_Program6‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪For j: = 1 to 5 do‬‬
‫; ) ]‪writeln (my2DArray [i,j‬‬
‫‪End.‬‬

‫ﺳﺘﻜﻮن ﻣﺨﺮﺟﺎت هﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ه ﻲ ﻃﺒﺎﻋ ﺔ آ ﻞ ﻗﻴﻤ ﻪ ﻋﻠ ﻰ ﺳ ﻄﺮ ﻣﻨﻔ ﺼﻞ ) أﻣ ﺎ أذا أﺳ ﺘﺨﺪﻣﻨﺎ‬
‫اﻷﻣﺮ ‪ write‬ﻓﺄﻧﻪ ﺳﻴﻄﺒﻊ آﻞ اﻟﻘﻴﻢ ﻋﻠﻰ ذات اﻟﺴﻄﺮ( ‪ ,‬أذن آﻴﻒ ﻳﻤﻜﻨﻨﺎ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻋﻠ ﻰ‬
‫ﺷﻜﻞ ﺷﺒﻜﻪ ‪ ,‬ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫;‪Program CH4_Program7‬‬
‫‪Var‬‬
‫;‪my2DArray: Array [1..3 , 1..5] of integer‬‬
‫;‪I, j: integer‬‬
‫‪Begin‬‬
‫‪For I: = 1 to 3 do‬‬
‫‪Begin‬‬
‫‪For j: = 1 to 5 do‬‬
‫;)' '‪Write (my2DArray [i, j],‬‬
‫;‪Writeln‬‬
‫;‪End‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪61‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻻﻳﺨﺘﻠ ﻒ آﺜﻴ ﺮا ﻋ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 6‬ﻋ ﺪا أﺿ ﺎﻓﺔ أﻣ ﺮ ﻃﺒﺎﻋ ﻪ ﺧ ﺎﻟﻰ ‪ .‬ﻋﻨ ﺪ اﻟﺒ ﺪأ‬
‫ﺑﺎﻟﺘﻨﻔﻴﺬ ﻓﺎن اﻟﺘﻜﺮار اﻷول اﻟﻤﺘﻤﺜﻞ ﺑﺎﻷﻣﺮ ) ‪ ( for‬ﺳﻴﻨﻔﺬ وﺗﻜﻮن ﻗﻴﻤﺔ ) ‪ ( I‬ﺗﺴﺎوي واﺣﺪ وﺑﻤ ﺎ أن ﺣﻠﻘ ﺔ‬
‫اﻟﺘﻜ ﺮار ﺗﺒ ﺪأ وﺗﻨﺘﻬ ﻲ ﺑ ﺎﻷواﻣﺮ ) ‪ ( begin , end‬ه ﺬا ﻳﻌﻨ ﻲ أن آ ﻞ اﻟﻜﺘﻠ ﻪ اﻟﻤﺤ ﺼﻮرﻩ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬ﺳﺘﻨﻔﺬ آﺎﻣﻠﻪ ﻣﻊ آﻞ ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ . ( I‬أن أول أﻳﻌﺎز ﻳﺄﺗﻲ هﻮ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻟﺜﺎﻧﻴ ﻪ‬
‫وﻟﻤﺎ ﻟﻢ ﻳﻜ ﻦ ﺑﻌ ﺪهﺎ اﻷﻣ ﺮ ) ‪ ( begin‬ﻓﺄﻧﻬ ﺎ ﺳ ﺘﻨﻔﺬ ﺧﻄ ﻮﻩ واﺣ ﺪﻩ ﺑﻌ ﺪهﺎ ﻓﻘ ﻂ وه ﻲ أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ ‪ ,‬ه ﺬا‬
‫اﻷﻣﺮ ﺳﻴﻄﺒﻊ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﺤﺪدﻩ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ وﺣﺴﺐ اﻟﻤﻮﻗﻊ اﻟﻤﺒﻴﻦ أزاﺋﻬﺎ ﺣﻴﺚ أن اﻟﻤﺘﺮﺟﻢ‬
‫ﺳ ﻴﻘﻮم ﺑ ﺎﻟﺘﻌﻮﻳﺾ ﻋ ﻦ ﻗﻴﻤﺘ ﻲ ) ‪ ( I, j‬وهﻤ ﺎ ) ‪ , ( 1 , 1‬ﺛ ﻢ ﻳ ﺄﺗﻲ ﺑﻘﻴﻤ ﺔ ه ﺬا اﻟﻤﻮﻗ ﻊ ﻟﻄﺒﺎﻋﺘﻬ ﺎ ‪ ,‬وﺑﻌ ﺪ‬
‫ﻃﺒﺎﻋﺔ ﻣﺤﺘﻮﻳﺎت هﺬا اﻟﻤﻮﻗﻊ ﻳﻄﺒﻊ اﻟﻔﺮاغ اﻟﻮارد ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ وﺣﺴﺐ ﻣﺎ ﻣﺤ ﺪد ﺑ ﺎﻷﻣﺮ) ﻓ ﺮاﻏﻴﻦ ( ‪..‬‬
‫ﻳﺮﺟﻊ اﻟﻤﺘﺮﺟﻢ اﻟﻰ اﻟﺘﻜﺮار اﻟﺜﺎﻧﻲ ﻟﻴﺰﻳﺪ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( j‬ﺑﻤﻘﺪار واﺣﺪ ﻓﺘ ﺼﺒﺢ ﻗﻴﻤﺘ ﻪ أﺛﻨ ﻴﻦ ﻟﻴﻨﻔ ﺬ أﻣ ﺮ‬
‫اﻟﻄﺒﺎﻋﻪ ﺛﺎﻧﻴﺔ وﻳﻄﺒﻊ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ ) ‪ ( 1 , 2‬ﺑﺠﺎﻧ ﺐ اﻟﻘﻴﻤ ﻪ اﻷوﻟ ﻰ ) اﻟﺘ ﻲ ه ﻲ رﻗ ﻢ وﻓ ﺮاغ ( ﻷن‬
‫أﻣﺮ اﻟﻄﺒﺎﻋﻪ هﻮ ) ‪ ( write‬ﺛﻢ اﻟﻌﻮدﻩ ﻟﺰﻳﺎدة ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( j‬ﻟﺘﻜﻮن ﻣ ﺴﺎوﻳﻪ اﻟ ﻰ ) ‪ ( 3‬وﺗ ﺘﻢ ﻃﺒﺎﻋ ﺔ‬
‫ﻣﺤﺘﻮﻳﺎت اﻟﻤﻮﻗﻊ ) ‪ ( 1 , 3‬واﻟﻔﺮغ اﻟﺬي ﺑﻌﺪﻩ ‪ ,‬ﺗﺰاد ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( j‬وﺗ ﺼﺒﺢ ﻗﻴﻤﺘ ﻪ ) ‪ ( 4‬وﺗ ﺴﺘﻤﺮ‬
‫اﻟﻌﻤﻠﻴﻪ ﻟﺤﻴﻦ أن ﺗﺘﻢ ﻃﺒﺎﻋﺔ ﺧﻤﺴﺔ ﻗﻴﻢ ﺟﻤﻴﻌﻬﺎ ﻋﻠﻰ ﺳﻄﺮ واﺣﺪ ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧﺮى ﻓﺮاغ ﺣﺴﺐ‬
‫ﻣﺎ ﻣﺒ ﻴﻦ ﺑ ﺄﻣﺮ اﻟﻄﺒﺎﻋ ﻪ ﻋﻨ ﺪ ذاك ﻓ ﺄن ﻗﻴﻤ ﺔ ) ‪ ( j‬ﺳ ﺘﻜﻮن ﻣ ﺴﺎوﻳﻪ اﻟ ﻰ )‪ (6‬ﻟ ﺬﻟﻚ ﻳﺘﻮﻗ ﻒ ﺗﻨﻔﻴ ﺬ اﻷواﻣ ﺮ‬
‫اﻟﺘﺎﺑﻌﻪ ﻟﺤﻠﻘ ﺔ اﻟﺘﻜ ﺮار اﻟﺜﺎﻧﻴ ﻪ وﻳﻨﺘﻘ ﻞ اﻟﺘﻨﻔﻴ ﺬ اﻟ ﻰ اﻷﻣ ﺮ اﻟﺘ ﺎﻟﻲ وه ﻮ ﻃﺒﺎﻋ ﻪ ‪ ...‬وﻟﻤ ﺎ آ ﺎن أﻣ ﺮ اﻟﻄﺒﺎﻋ ﻪ‬
‫ﻻﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻗﻴﻤ ﻪ ﻟﻴﻄﺒﻌﻬ ﺎ ﻓﺄﻧ ﻪ ﺳ ﻴﻜﺘﻔﻲ ﺑﺎﻟﺘﺄﺷ ﻴﺮ ﻋﻠ ﻰ ﺳ ﻄﺮ ﺟﺪﻳ ﺪ دون ﻃﺒﺎﻋ ﺔ أي ﺷ ﻲء‪ , ..‬ﻳﻌ ﻮد‬
‫اﻟﻤﺆﺷ ﺮ اﻟ ﻰ ﺣﻠﻘ ﺔ اﻟﺘﻜ ﺮار اﻷوﻟ ﻰ ﻷﻧﻬ ﺎ ﻟ ﻢ ﺗﻨﺘﻬ ﻲ ﺑﻌ ﺪ وﻳﺰﻳ ﺪ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( I‬ﻟﻴﻜ ﻮن ) ‪ ( 2‬وﺗﺒ ﺪأ‬
‫ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ ﺟﺪﻳﺪﻩ ﻣ ﺸﺎﺑﻬﻪ ﻟﻤ ﺎ ﺷ ﺮح ﺳ ﺎﺑﻘﺎ ﻟﻜ ﻦ ﻣ ﻊ ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( I‬اﻟﻤ ﺴﺎوﻳﻪ ﻷﺛﻨ ﻴﻦ وﻋﻠ ﻰ ﺳ ﻄﺮ‬
‫ﺟﺪﻳﺪ ‪ .‬وﺗﺴﺘﻤﺮ اﻟﻌﻤﻠﻴﻪ ﻟﺤﻴﻦ اﻷﻧﺘﻬﺎء ﻣﻦ آﺎﻣﻞ ﺣﻠﻘﺔ اﻟﺘﻜﺮار اﻷوﻟﻰ ﻟﻴﻨﺘﻘﻞ ﺑﻌﺪهﺎ اﻟﻰ ﻧﻬﺎﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬

‫‪4.3‬‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬

‫•‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﻣﻜﻮﻧﻪ ﻣﻦ ) ‪ ( 20‬ﻋﻨﺼﺮ‪ ,‬ﺛﻢ أﻃﺒﻌﻬﺎ ﺑﺸﻜﻞ ﻣﻌﻜﻮس ‪.‬‬

‫;‪Program CH4_Program8‬‬
‫‪Var‬‬
‫;‪A: array [1..20] of integer‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫‪For i: =1 to 20 do‬‬
‫;)]‪Readln (a[i‬‬
‫‪For i: =20 downto 1 do‬‬
‫;)‪Write (a[i]:7‬‬
‫‪End.‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

62

‫ ﺛﻢ رﺗﺐ ﻋﻨﺎﺻﺮهﺎ ﺗﺼﺎﻋﺪﻳﺎ‬, ‫ ( ﻋﻨﺼﺮ‬20 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﻣﻜﻮﻧﻪ ﻣﻦ‬
. ‫ﺣﺴﺐ ﻗﻴﻤﻬﺎ‬

Program CH4:Program9;
Var
A: array [1..20] of integer;
I, j, temp: integer;
Begin
For i: = 1 to 20 do
Readln (a[i]);
For i: =1 to 19 do
For j: = i+1 to 20 do
If (a[i] > a[j]) then
Begin
Temp: =a[i];
A[i]:=a[j];
A[j]:=temp;
End;
For i: =1 to 20 do
Write (a[i]:6);
End.

‫ ﺛ ﻢ أدﻣ ﺞ‬,‫ ( ﻋﻨ ﺼﺮ‬15 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ أﺣ ﺎدﻳﺘﻴﻦ آ ﻞ ﻣﻨﻬﻤ ﺎ ﻣﻜﻮﻧ ﻪ ﻣ ﻦ‬
. ‫ ( ﻋﻨﺼﺮ‬30 ) ‫اﻟﻤﺼﻔﻮﻓﺘﻴﻦ ﺑﻤﺼﻔﻮﻓﻪ واﺣﺪﻩ ﺣﺠﻤﻬﺎ‬

Program CH4_Program10;
Var
A, b: array [1..15] of char;
C: array [1..30]of char;
I: integer;
Begin
For i: = 1 to 15 do
Begin
Readln (a[i]);
Readln (b[i]);
End;
For i: = 1 to 30 do
Begin
If (i<=15) then
C[i]:=a[i]
Else
C[i]:=b [i-15];
End;
For i: =1 to 30 do
Write(c[i]:3);
End.

63

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

. ‫ ﺛﻢ أوﺟﺪ ﻣﺠﻤﻮع ﻋﻨﺎﺻﺮهﺎ‬,( 5x4 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ﺣﺠﻤﻬﺎ‬

Program CH4_Program11;
Var
A: array [1..5, 1..4] of integer;
I, j, sum: integer;
Begin
Sum: =0;
For i: =1 to 5 do
For j: =1 to 4 do
Readln (a [I, j]);
For i: =1 to 5 do
For j: =1 to 4 do
Sum: =sum + a [I,j];
Writeln (sum);
End.

‫ ﺛﻢ أوﺟﺪ اﻟﻌﺪد اﻷآﺒﺮ ﻣ ﻦ ﺑ ﻴﻦ ﻋﻨﺎﺻ ﺮ‬, ( 5x4 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ ﺣﺠﻤﻬﺎ‬
. ‫اﻟﻤﺼﻔﻮﻓﻪ‬

Program CH4_program12;
Var
B: array [1..5, 1..4]of integer;
I, j, max: integer;
Begin
For i: =1 to 5 do
For j: =1 to 4 do
Readln (b [I, j]);
Max: =b [1, 1];
For i: =1 to 5 do
For j: =1 to 4 do
If (b [I, j] > max) then
Max: =b [I, j];
Wrireln (max);
End.

‫ ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤﻮﻋﻬﻤ ﺎ واﻟﻔ ﺮق‬, ( 3x4 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ آ ﻞ ﻣﻨﻬﻤ ﺎ ﺑﺤﺠ ﻢ‬
. ‫ﺑﻴﻨﻬﻤﺎ‬

64

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

Program CH4_Program13;
Var
A, b, c, d: array [1..3, 1..4] of integer;
I, j: integer;
Begin
For i: =1 to 3 do
For j: =1 to 4 do
Begin
Readln (a [I, j]);
Readln (b [I, j]);
End;
For i: =1 to 3 do
For j: =1 to 4 do
Begin
C [I, j]:=a [I, j] + b [I, j];
D [I, j]:=a [I, j] - b [I, j];
End;
For i: =1 to 3 do
Begin
For j: =1 to 4 do
Write(c [I, j]:6);
Writeln;
End;
For i: =1 to 3 do
Begin
For j: =1 to 4 do
Write (d [I, j]:6);
Writeln;
End;
End.

‫ ﺛ ﻢ أوﺟ ﺪ ﻣﺠﻤ ﻮع ﻋﻨﺎﺻ ﺮ اﻟﻘﻄ ﺮ اﻟ ﺮﺋﻴﺲ‬, ( 6x6 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﻪ ﺣﺠﻤﻬ ﺎ‬
. ‫ﻟﻠﻤﺼﻔﻮﻓﻪ‬

Program CH4_Program14;
Var
Cd: array [1..6, 1..6] of integer;
I, j, sum: integer;
Begin
Sum: =0;
For i: =1 to 6 do
For j: =1 to 6 do
Readln (cd [I, j]);
For i: =1 to 6 do
Sum: =sum + cd [i, i];
Writeln (sum);
End.

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

65

‫ ﺛ ﻢ أوﺟ ﺪ‬, ( 4x5 ) ‫ ( وﺣﺠ ﻢ اﻟﺜﺎﻧﻴ ﻪ‬3x4 ) ‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﻣ ﺼﻔﻮﻓﺘﻴﻦ ﺣﺠ ﻢ اﻷوﻟ ﻰ‬
. ‫ﺣﺎﺻﻞ ﺿﺮﺑﻬﻤﺎ‬

Program CH4_Program15;
Var
A: array [1..3, 1..4] of
B: array [1..4, 1..5] of
C: array [1..3, 1..5] of
I, j,k: integer;
Begin
For i: =1 to 3 do
For j: =1 to 4 do
Readln (a [I, j]);
For i: =1 to 4 do
For j: =1 to 5 do
Readln (b [I, j]);
For k: =1 to 3 do
For i: =1 to 5 do
Begin
C [k, i]:=0;
For j: =1 to 4 do
C [k, i]:=c [k, i]
End;
For i: =1 to 3 do
Begin
For j: =1 to 5 do
Write(c [I, j]);
Writeln;
End;
End.

integer;
integer;
integer;

+ a [k, j]* b[j,i];

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪66‬‬

‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬
‫اﻷﺟﺮاءات واﻟﺪوال ‪PROCEDURES AND FUNCTIONS‬‬
‫‪5.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫اﻷﺟ ﺮاءات ه ﻲ ﺑ ﺮاﻣﺞ ﺻ ﻐﻴﺮﻩ ﺗ ﺴﺘﺨﺪم ﺿ ﻤﻦ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ‪ ,‬ه ﺬا اﻟﻔ ﺼﻞ ﺳ ﻴﺮآﺰ ﻋﻠ ﻰ آﻴﻔﻴ ﺔ‬
‫اﻷﺳﺘﻔﺎدﻩ ﻣﻦ اﻷﺟﺮاءات واﻟﺪوال وﻣﺎهﻴﺔ اﻟﻀﻮاﺑﻂ اﻟﺘﻲ ﺗﺘﺤﻜﻢ ﺑﻬﻤﺎ ‪ ,‬ﻣﻊ ﻋﺪد ﻣﻦ اﻷﻣﺜﻠﻪ اﻟﺘﻮﺿﻴﺤﻴﻪ ‪.‬‬
‫‪5.2‬‬

‫اﻷﺟﺮاءات ‪PROCEDURES‬‬

‫اﻷﺟﺮاءات أو اﻟﺮوﺗﻴﻨﺎت اﻟﻔﺮﻋﻴﻪ آﻤﺎ ﺗﺴﻤﻰ أﺣﻴﺎﻧﺎ ه ﻲ ﺟ ﺰء ﻣ ﻦ ﺑﺮﻧ ﺎﻣﺞ ﺗ ﻮﻓﺮ ﻓﻌ ﻞ ﺧ ﺎص ‪.‬‬
‫و ﺗﺴﺘﺨﺪم ﻟﻤﺴﺎﻋﺪة اﻟﻤﺒﺮﻣﺞ ﻟﺘﺠﻨ ﺐ اﻟﺘﻜ ﺮار ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ وﺧ ﺼﻮﺻﺎ اﻟﺒ ﺮاﻣﺞ اﻟﻜﺒﻴ ﺮﻩ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻓ ﺄن‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﻳﺠﺰأ اﻟﻰ أﺟﺰاء ﺻﻐﻴﺮﻩ ‪ ,‬وهﺬﻩ اﻷﺟﺰاء ﺗﺠﺰأ اﻟﻰ أﺟﺰاء أﺻ ﻐﺮ وهﻜ ﺬا ﻟﺤ ﻴﻦ اﻟﻮﺻ ﻮل اﻟ ﻰ‬
‫أﺟﺰاء ﺳﻬﻠﺔ اﻟﺘﻨﻔﻴﺬ أو اﻷﻧﺠ ﺎز ‪ .‬وآﻤ ﺎ ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ اﻷﻋﺘﻴﺎدﻳ ﻪ ﺗﺒ ﺪأ اﻷﺟ ﺮاءات ﻣ ﻊ اﻷﻣ ﺮ ) ‪( begin‬‬
‫وﺗﻨﺘﻬ ﻲ ﻣ ﻊ اﻷﻣ ﺮ ) ; ‪ ( end‬وﻣﻤﻜ ﻦ أن ﻳﻜ ﻮن ﻟﻬ ﺎ ﻣﺘﻐﻴ ﺮات ﺧﺎﺻ ﻪ ﺑﻬ ﺎ ﻻ ﺗ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫اﻟﺮﺋﻴﺴﻲ ‪.‬‬
‫ﻳﺒﺪأ اﻷﺟﺮاء ﺑﻜﻠﻤﻪ ) ‪ ( procedure‬ﻣﺘﺒﻮﻋﻪ ﺑﺄﺳﻢ اﻷﺟﺮاء آﻤﺎ ه ﻮ اﻟﺤ ﺎل ﻓ ﻲ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫‪ ,‬وﻣﻤﻜ ﻦ أن ﻳﺘﺒ ﻊ ﺑﻘﻮﺳ ﻴﻦ ﻳﺤﺘﻮﻳ ﺎن ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات اﻟﺪاﺧﻠ ﻪ واﻟﺨﺎرﺟ ﻪ واﻟﺘ ﻲ ﺗ ﺪﻋﻰ ) اﻟﻮﺳ ﺎﺋﻂ (‬
‫) ‪ ) ( parameters‬وهﻲ ﺗﺴﺘﺨﺪم ﻟﻠﺘﻮاﺻ ﻞ ﺑ ﻴﻦ اﻟﻨﻤ ﺎذج أو اﻷﺟ ﺮاءات ( واﻟﺘ ﻲ ﺳ ﻨﺄﺗﻲ ﻋﻠﻴﻬ ﺎ ﻻﺣﻘ ﺎ‬
‫وهﺬا ﻳﺪﻋﻰ رأس اﻷﺟﺮاء ‪ .‬وآﻞ ﻣﺎﻳﻠﻲ ذﻟﻚ ﻓﻬﻮ ﻣﺸﺎﺑﻪ ﻟﻠﺒﺮاﻣﺞ اﻷﻋﺘﻴﺎدﻳﻪ واﻟﺘﻲ ﺳﺒﻖ وأن ﺗﻄﺮﻗﻨ ﺎ ﻟﻬ ﺎ‬
‫‪.‬‬
‫أن اﻟﻔﺮق ﺑﻴﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻷﻋﺘﻴﺎدي واﻷﺟﺮاء هﻮ ﻣﺎﻳﻠﻲ ‪:‬‬
‫ﻣ ﻦ اﻟﻤﻬ ﻢ ﺟ ﺪا أن ﻳﻜ ﻮن ﺣﺠ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺻ ﻐﻴﺮ ‪ .‬أن آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ‬
‫‪.1‬‬
‫أﺟﺮاءات أو دوال ) ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ ( ﻳﺴﺎﻋﺪ اﻟﻰ درﺟﻪ آﺒﻴﺮﻩ اﻟﻰ ﺗﻘﻠﻴﻞ ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻋﺎم ‪.‬‬
‫‪.2‬‬
‫أن آﺘﺎﺑﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ أﺟ ﺮاءات ﻳ ﺴﺎﻋﺪ اﻟﻤﺒ ﺮﻣﺞ ﻣ ﺴﺘﻘﺒﻼ أو أي ﺷ ﺨﺺ أﺧ ﺮ‬
‫ﻣﻦ ﻣﺘﺎﺑﻌﻪ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺼﺤﻴﺢ أو ﺗﻌﺪﻳﻞ اﻟﺒﺮﻧﺎﻣﺞ أذا أﻗﺘﻀﺖ اﻟﺤﺎﺟﻪ ﺑﺴﻬﻮﻟﻪ وﻳﺴﺮ ‪.‬‬
‫اﻷﺟﺮاءات ﺗﺴﺎﻋﺪ اﻟﻤﺒﺮﻣﺞ ﻋﻠﻰ اﻟﺘﺨﻠﺺ ﻣﻦ ﺗﻜﺮار ﻣﻘﺎﻃﻊ ﻣﻌﻴﻨﻪ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ واﻟﺘﻲ‬
‫‪.3‬‬
‫ﺗﺴﺒﺐ أﺷﻜﺎﻻت آﺜﻴﺮﻩ ﻟﻠﻤﺒﺮﻣﺞ ‪ ,‬أﺿﺎﻓﻪ اﻟﻰ زﻳﺎدة ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫اﻷﺟﺮاءات ﺗﻌﻄﻲ اﻟﻤﺒﺮﻣﺞ ﻣﺮوﻧ ﻪ أآﺒ ﺮ ﻟﻤﺘﺎﺑﻌ ﺔ اﻷﺧﻄ ﺎء آﻤ ﺎ أﺳ ﻠﻔﻨﺎ‪ ,‬وآ ﺬﻟﻚ ﺗ ﺴﺎﻋﺪ‬
‫‪.4‬‬
‫ﻋﻠﻰ أﺳﺘﺨﺪام هﺬﻩ اﻷﺟﺮاءات ﻓﻲ ﺑﺮاﻣﺞ أﺧﺮى ﻋﻨﺪ اﻟﺤﺎﺟﻪ ﻟﻬﺎ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻸﺟﺮاء هﻲ ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪67‬‬

‫; > ‪Procedure < PROCEDURE_NAME‬‬
‫‪OR‬‬
‫; ) ‪Procedure <PROCEDURE_NAME ( Var Variable_Name : Type‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫هﻨ ﺎك ﻧ ﻮﻋﻴﻦ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات ‪ ,‬ﻣﺘﻐﻴ ﺮات ﺗ ﺴﺘﺨﺪم داﺧ ﻞ اﻷﺟ ﺮاء ﻓﻘ ﻂ وﻻ ﺗ ﺴﺘﺨﺪم ﻓ ﻲ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وأن أي ﺗﻐﻴ ﺮ ﻋﻠ ﻰ ﻗﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ﺳ ﻮف ﻻ ﻳﻨ ﺴﺤﺐ ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات‬
‫اﻷﺧﺮى اﻟﺘﻲ ﺗﺤﻤﻞ ﻧﻔﺲ اﻷﺳﻢ ﻓ ﻲ اﻷﺟ ﺮاءات اﻷﺧ ﺮى أو اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وه ﺬﻩ ﺗ ﺴﻤﻰ‬
‫ﻣﺘﻐﻴﺮات ﻣﺤﻠﻴﻪ ) ‪. ( local variables‬‬
‫وﻧﻮع أﺧﺮ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻤﻤﻜ ﻦ أن ﻳ ﺴﺘﺨﺪم داﺧ ﻞ اﻷﺟ ﺮاء واﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ وأي‬
‫ﺗﻐﻴﺮ ﻳﻄ ﺮأ ﻋﻠ ﻰ ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﻳﻨ ﺴﺤﺐ ﻋﻠﻴ ﻪ ﻓ ﻲ آ ﻞ ﻣﻜ ﺎن وه ﻲ ﺗ ﺴﻤﻰ ﻣﺘﻐﻴ ﺮات ﻋﺎﻣ ﻪ‬
‫) ‪. ( global variables‬‬
‫اﻟﻤﺘﻐﻴ ﺮات اﻟﻤﺤﻠﻴ ﻪ ﻳﻌﻠ ﻦ ﻋﻨﻬ ﺎ ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات داﺧ ﻞ اﻷﺟ ﺮاء ﺑﻴﻨﻤ ﺎ‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﻌﺎﻣﻪ ﻳﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ) أي أن‬
‫أي ﻣﺘﻐﻴﺮ ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﺳﻴﻜﻮن ﻓﻌ ﺎﻻ وﻳ ﺮى‬
‫) ﻧﺴﺘﻄﻴﻊ ﻗﺮاءة وﺗﻐﻴﻴﺮ ﻗﻴﻤﺘﻪ ( ﻓﻲ آﻞ ﻣﻜﺎن ﻳﺘﻮاﺟﺪ ﺑﻪ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬أﻣﺎ اﻟﻤﺘﻐﻴ ﺮات اﻟﺘ ﻲ‬
‫ﺗﻌﺮف ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات داﺧﻠ ﺲ اﻷﺟ ﺮاء ﺳ ﻮف ﻻ ﺗ ﺮى أﻃﻼﻗ ﺎ ﺧ ﺎرج ه ﺬا‬
‫اﻷﺟﺮاء ( ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH5_Program1‬‬
‫‪Var‬‬
‫;‪X:integer‬‬
‫;‪Procedure Change‬‬
‫‪Begin‬‬
‫;‪X: =1‬‬
‫;‪End‬‬
‫}‪{change‬‬
‫‪Begin‬‬
‫}‪{main program‬‬
‫;‪X: =0‬‬
‫;‪Change‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬
‫} ‪{main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//: 1‬‬
‫‪X=1‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪68‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 1‬‬
‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﺘﻐﻴﺮ واﺣ ﺪ ه ﻮ ) ‪ ( x‬وﻣﻌ ﺮف ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﺬ ﻓﻬﻮ ﻳﻌﺘﺒﺮ ﻣﺘﻐﻴﺮ ﻋﺎم ) ‪ . ( global‬اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠ ﻰ أﺟ ﺮاء ﻳﻘ ﻮم ﺑﺘﻐﻴﻴ ﺮ‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ) ‪ ( x‬اﻟﻰ اﻟﻘﻴﻤﻪ ) ‪. ( 1‬‬
‫ﻳﺒ ﺪأ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ﺑﺄﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) ‪ ( 0‬اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ ) ‪ , ( x‬ﺛ ﻢ ﻳ ﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء‬
‫) ‪ ( change‬وذﻟ ﻚ ﺑﻜﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء ﻋﻨ ﺪ ذﻟ ﻚ ﻳﻨﺘﻘ ﻞ اﻟﻤﺆﺷ ﺮ اﻟ ﻰ اﻷﺟ ﺮاء ) ‪ ( change‬وﻳﻨﻔ ﺬ‬
‫اﻷواﻣ ﺮ اﻟﺘ ﻲ ﻓﻴ ﻪ ) آﺒﺮﻧ ﺎﻣﺞ ﻣ ﺴﺘﻘﻞ ( وﺑﻌ ﺪ ﻧﻬﺎﻳ ﺔ ﺗﻨﻔﻴ ﺬ اﻷﺟ ﺮاء ﻳﻌ ﻮد اﻟﻤﺆﺷ ﺮ اﻟ ﻰ ﻋﺒ ﺎرة أﺳ ﺘﺪﻋﺎء‬
‫اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﻴﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ ﻟﻠﻌﺒﺎرات اﻟﺘﺎﻟﻴﻪ ﻟﻬﺎ واﻟﺘ ﻲ ه ﻲ هﻨ ﺎ ﻋﺒ ﺎرة اﻟﻄﺒﺎﻋ ﻪ ﺣﻴ ﺚ‬
‫ﺳﺘﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ .. ( x‬ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺗﻐﻴﺮت ﻓﻲ اﻷﺟﺮاء وﺗﺒﻌﺎ ﻟﺬﻟﻚ ﺗﻐﻴﺮت ﻗﻴﻤﺘﻬﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‬
‫اﻟﺮﺋﻴﺲ ﻷن اﻟﻤﺘﻐﻴﺮ ﻣﻌﺮف آﻤﺘﻐﻴﺮ ﻋﺎم ‪.‬‬
‫;‪Program CH5_Program2‬‬
‫‪Var‬‬
‫;‪X:integer‬‬
‫;‪Procedure Change‬‬
‫‪Var‬‬
‫;‪X: integer‬‬
‫‪Begin‬‬
‫;‪X: =1‬‬
‫;‪End‬‬
‫}‪{change‬‬
‫‪Begin‬‬
‫}‪{main program‬‬
‫;‪X: =0‬‬
‫;‪Change‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬
‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪X=0‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 2‬‬
‫ﻻ ﻳﺨﺘﻠﻒ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻋﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ) ‪ ( 1‬آﺜﻴ ﺮا ‪ ,‬ﻋ ﺪا أن اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻋ ﺮف ﻣﺮﺗ ﺎن ﻣ ﺮﻩ‬
‫ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﻴﻜﻮن ﻣﺘﻐﻴﺮ ﻋﺎم ‪ ,‬وﺛﺎﻧﻴﺔ ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ‬
‫اﻟﻤﺘﻐﻴﺮات ﻓﻲ اﻷﺟﺮاء ) ‪ ( change‬ﻟﻴﻜﻮن ﻣﺘﻐﻴﺮ ﻣﺤﻠﻲ ‪.‬‬
‫ﺑﻨﺎء ﻋﻠﻰ ﻣﺎ ﺗﻘﺪم ﻓﺄن اﻟﻤﺘﻐﻴﺮﻳﻦ ﻳﺨﺘﻠﻔﺎن ﻷن أﺣﺪهﻤﺎ ﻋﺎم واﻟﺜ ﺎﻧﻲ ﻣﺤﻠ ﻲ وأن ﺗ ﺸﺎﺑﻬﺔ اﻟﺘ ﺴﻤﻴﻪ‪,‬‬
‫ﻣﻦ ذﻟﻚ ﻓﺄن اﻟﺘﻐﻴﻴﺮ اﻟﺬي ﻳﺤﺼﻞ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ) ‪ ( x‬داﺧ ﻞ اﻷﺟ ﺮاء ﺳﻴﻨﺤ ﺼﺮ داﺧ ﻞ اﻷﺟ ﺮاء‬
‫ﻓﻘﻂ وﻻ ﻳﺆﺛﺮ ﻋﻠ ﻰ اﻟﻤﺘﻐﻴ ﺮات ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ﺳ ﻮاء ﺗ ﺸﺎﺑﻬﺔ اﻟﺘ ﺴﻤﻴﻪ أو أﺧﺘﻠﻔ ﺖ ‪ ,‬وﻧﻔ ﺲ اﻷﻣ ﺮ‬
‫ﻳﻨﺴﺤﺐ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮ اﻟﻌﺎم ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪69‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﻮﺳﺎﺋﻂ ) ‪ ( parameters‬هﻲ ﻗﻴﻤﻪ ﺗﻤﺮر اﻟﻰ اﻷﺟﺮاء أو اﻟﺪاﻟﻪ ‪.‬‬
‫هﻨﺎك أآﺜﺮ ﻣﻦ ﻧﻮع ﻣﻦ اﻟﻮﺳﺎﺋﻂ وﻣﺎ ﻳﻬﻤﻨﺎ هﻨﺎ ﻧﻮﻋﻴﻦ ‪:‬‬
‫‪ .1‬وﺳﺎﺋﻂ اﻟﻘﻴﻤﻪ ) ‪ : ( value parameters‬ﺗﺘﺼﺮف هﺬﻩ اﻟﻮﺳﺎﺋﻂ ﻣﺜﻞ‬
‫اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ﺿﻤﻦ اﻷﺟﺮاء أو اﻟﺪاﻟﻪ ) ﺣﻴﺚ أن اﻟﻤﺘﻐﻴﺮ اﻟﻤﺤﻠﻲ ﻳﻤﻜﻦ ﺗﻐﻴﻴﺮ‬
‫ﻗﻴﻤﺘﻪ ﺿﻤﻦ اﻷﺟﺮاء ﻟﻜﻦ اﻟﻘﻴﻤﻪ اﻷﺻﻠﻴﻪ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻻﺗﺘﻐﻴﺮ ( ‪,‬‬
‫ﻓﻌﻨﺪﻣﺎ ﻳﺴﺘﺨﺪم أﺟﺮاء وﺳﺎﺋﻂ ﻗﻴﻤﻪ ﻓﺄن اﻟﻤﺘﺮﺟﻢ ﻳﻨﺴﺦ هﺬﻩ اﻟﻤﺘﻐﻴﺮات وﻳﻤﺮر‬
‫ﻧﺴﺨﻪ ﻣﻨﻬﺎ اﻟﻰ اﻷﺟﺮاء ‪ ,‬أﻣﺎ اﻟﻤﺘﻐﻴﺮات اﻷﺻﻠﻴﻪ ﻓﺘﺒﻘﻰ ﻋﻠﻰ ﺣﺎﻟﻬﺎ ﻷن ﻣﺎ‬
‫أرﺳﻞ اﻟﻰ اﻷﺟﺮاء هﻮ ﻧﺴﺨﻪ وأي ﺗﻐﻴﺮ ﻓﻲ اﻟﻨﺴﺨﻪ ﻻ ﻳﺆﺛﺮ ﻓﻲ اﻷﺻﻞ ) آﻤﺎ‬
‫ﻟﻮ ﻧﺴﺨﻨﺎ ﻣﺴﺘﻨﺪ وﺣﻮرﻧﺎ ﻓﻲ اﻟﻨﺴﺨﻪ اﻟﻤﺴﺘﻨﺴﺨﻪ ﻓﻬﻞ ﺳﻴﺆﺛﺮ ﻋﻠﻰ اﻟﻨﺴﺨﻪ‬
‫اﻷﺻﻠﻴﻪ !؟( ‪.‬‬
‫وﺳﺎﺋﻂ اﻟﻘﻴﻤﻪ ﺗﻤﺮر ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ اﻟﻰ اﻷﺟﺮاء ﻓﻘﻂ ‪.‬‬
‫‪ .2‬اﻟﻮﺳﺎﺋﻂ اﻟﻤﺮﺟﻌﻴﻪ )‪ : ( Reference Parameters‬اﻟﻤﺘﻐﻴﺮات اﻟﻤﺮﺟﻌﻴﻪ‬
‫ﻻ ﺗﺮﺳﻞ ﻧﺴﺨﻪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﺑﻞ ﺗﺮﺳﻞ اﻟﻤﺘﻐﻴﺮ ذاﺗﻪ ‪ ,‬وﻟﺬا ﻓﺄن أي ﺗﻐﻴﺮ ﻋﻠﻰ‬
‫هﺬا اﻟﻤﺘﻐﻴﺮ ﺳﻴﺆﺛﺮ ﻋﻠﻰ اﻟﻤﺘﻐﻴﺮات اﻷﺻﻠﻴﻪ هﺬﻩ اﻟﻤﺘﻐﻴﺮات ﺗﻜﻮن ﻣﺴﺒﻮﻗﻪ‬
‫ﺑﺎﻷﻣﺮ ) ‪ ( var‬داﺋﻤﺎ ‪.‬‬
‫اﻟﻮﺳﺎﺋﻂ اﻟﻤﺮﺟﻌﻴﻪ ﺗﺴﺘﺨﺪم اﻟﻄﺮﻳﻘﻴﻦ ) أي اﻟﻘﻴﻤﻪ ﺗﻨﺘﻘﻞ ﻣﻦ واﻟﻰ اﻷﺟﺮاء ( ‪.‬‬

‫ﻣﺜﺎل ‪:‬‬
‫أوﺟﺪ ﻗﻴﻤﺔ ) ‪ ( y‬ﻣﻦ اﻟﻤﻌﺎدﻟﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬

‫;)‪', p4‬‬

‫‪4‬‬

‫‪6‬‬

‫‪8‬‬

‫‪10‬‬

‫‪Y = 10 + 8 + 6 + 4‬‬

‫; ‪Program CH5_Program3‬‬
‫‪Var‬‬
‫;‪Y, p1, p2, p3, p4: longint‬‬
‫;‪i:integer‬‬
‫‪Begin‬‬
‫;‪P1:=1‬‬
‫‪For i: =1 to 10 do‬‬
‫;‪P1:=p1*10‬‬
‫;‪P2:=1‬‬
‫‪For i: =1 to 8 do‬‬
‫;‪P2:=p2*8‬‬
‫;‪P3:=1‬‬
‫‪For i: =1 to 6 do‬‬
‫;‪P3:=p3*6‬‬
‫;‪P4:=1‬‬
‫‪For i: =1 to 4 do‬‬
‫;‪P4:=p4*4‬‬
‫;‪Y: =p1+p2+p3+p4‬‬
‫'‪Writeln (p1,' ', p2' ', p3,‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪70‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪1410065408 16777216 46656 256‬‬
‫‪1426889536‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻟﻮ آﺎن اﻟﻤﺘﻐﻴﺮ ) ‪ ( y‬ﻣﻌﺮف ﻣﻦ ﻧﻮع ) ‪ ( integer‬ﻟﻜﺎﻧﺖ ﻗﻴﻤﺔ ) ‪ ( y‬ﺗﺴﺎوي‬
‫) ‪ ( -25792‬وذﻟﻚ ﻷن اﻟﻨﻮع ) ‪ ( integer‬ﻳﺤﺠﺰ ) ‪ ( 2 Byte‬وهﻲ ﻏﻴﺮ آﺎﻓﻴﻪ‬
‫ﻟﺘﻤﺜﻴﻞ رﻗﻢ أآﺒﺮ ﻣﻦ ) ‪ ( 65535‬ﻟﺬﻟﻚ ﻳﺘﺤﻮل اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﺴﺎﻟﺒﻪ ‪ ,‬وهﻮ ﻣﺸﺎﺑﻪ ﻟﻌﺪاد‬
‫اﻟﻤﺴﺎﻓﻪ ﻓﻲ اﻟﺴﻴﺎرﻩ ﻓﻌﻨﺪﻣﺎ ﻳﺼﻞ اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﻌﻠﻴﺎ وهﻲ ) ‪ ( 99999‬ﻓﺎن اﻟﺰﻳﺎدﻩ‬
‫ﺑﻤﻘﺪار واﺣﺪ ﺗﺴﺒﺐ ﺑﺄن ﻳﻜﻮن اﻟﻌﺪاد ﻣﺴﺎوي اﻟﻰ ) ‪. ( 00000‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 3‬ﺑﻄﺮﻳﻘﺔ اﻷﺟﺮاءات وآﻤﺎ ﻳﻠﻲ ‪:‬‬
‫;‪Program CH5_Program4‬‬
‫‪Var‬‬
‫;‪P1, p2, p3, p4, y: longint‬‬
‫;)‪Procedure power(x: integer; var p: longint‬‬
‫‪Var‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫;‪P: =1‬‬
‫‪For i: =1 to x do‬‬
‫;‪P: =p*x‬‬
‫;‪End‬‬
‫‪Begin‬‬
‫}‪{main program‬‬
‫;)‪Power (10, p1‬‬
‫;)‪Power (8, p2‬‬
‫;)‪Power (6, p3‬‬
‫;)‪Power (4, p4‬‬
‫;‪Y: =p1+p2+p3+p4‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪71‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 4‬‬
‫أوﻻ ‪ :‬ﻳﺒﺪأ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻌﺮﻳﻒ ﻋ ﺪد ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ ﻋﺎﻣ ﻪ ﻧﻈ ﺮا ﻷﻧﻬ ﺎ ﻣﻌﺮﻓ ﻪ ﻓ ﻲ‬
‫ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬آﺘﺎﺑﺔ اﻷﺟﺮاء واﻟﺬي ﻳﺴﺒﻖ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻷﺟ ﺮاء ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻗ ﻮس ﻓﻴ ﻪ‬
‫ﻣﺘﻐﻴ ﺮات وﻧﻼﺣ ﻆ أن ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﺗﺄﺧ ﺬ ﺷ ﻜﻠﻴﻦ ‪ :‬أﺣ ﺪهﻤﺎ ﻣ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬واﻟﻔ ﺮق هﻨ ﺎ‬
‫ﺑﺒ ﺴﺎﻃﻪ أن اﻟﻤﺘﻐﻴ ﺮ اﻷول ﻳﺤﻤ ﻞ ﻗﻴﻤ ﻪ ﺗ ﺪﺧﻞ اﻟ ﻰ اﻷﺟ ﺮاء ﻟﻠﻌﻤ ﻞ ﻋﻠﻴﻬ ﺎ داﺧ ﻞ اﻷﺟ ﺮاء ‪ ,‬أﻣ ﺎ اﻟﻤﺘﻐﻴ ﺮ‬
‫اﻟﻤ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻬ ﻮ ﻳﻌﺎﻣ ﻞ آﻤﺘﻐﻴﺮﺳ ﻴﺤﻤﻞ ﻗﻴﻤ ﻪ ﺗﺨ ﺮج ﻣ ﻦ اﻷﺟ ﺮاء اﻟ ﻰ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ‬
‫واﻟﺘﻲ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬
‫ﺛﺎﻟﺜ ﺎ ‪ :‬اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻟ ﺬي ﺳ ﻴﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء داﺧﻠ ﻪ ﻟﺤ ﺴﺎب اﻟﻘ ﻴﻢ اﻟﻤﻄﻠﻮﺑ ﻪ‬
‫واﻷﺳﺘﺪﻋﺎء ﻳﺠﺐ أن ﻳﺘﻢ ﻣ ﻦ ﺧ ﻼل آﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء اﻟﻤﻄﻠ ﻮب أﺳ ﺘﺪﻋﺎءﻩ ﺛ ﻢ آﺘﺎﺑ ﺔ اﻟﻤﺘﻐﻴ ﺮات اﻟﺘ ﻲ‬
‫ﻳ ﺮاد أرﺳ ﺎﻟﻬﺎ اﻟ ﻰ اﻷﺟ ﺮاء هﻨ ﺎ ﻧﺮﺳ ﻞ اﻟ ﺮﻗﻢ اﻟﻤﻄﻠ ﻮب ﺣ ﺴﺎب ﻗﻴﻤﺘ ﻪ ﺑﻌ ﺪ رﻓﻌ ﻪ اﻟ ﻰ اﻷس اﻟﻤﻄﻠ ﻮب‬
‫وآ ﺬﻟﻚ ﻳﻜﺘ ﺐ اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﺳ ﺘﻌﻮد اﻟﻨﺘﻴﺠ ﻪ ﻓﻴ ﻪ ) أن اﻟﻘ ﻴﻢ اﻟﻤﻮﺟ ﻮدﻩ ﻓ ﻲ أﻣ ﺮ اﻷﺳ ﺘﺪﻋﺎء ﺳ ﺘﻨﺘﻘﻞ اﻟ ﻰ‬
‫اﻷﺟﺮاء ﻟﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻳﻘﺎﺑﻠﻬﺎ ﻓﻲ اﻷﺟﺮاء ( ‪.‬‬
‫راﺑﻌﺎ ‪ :‬ﻧﺘﻴﺠ ﺔ رﻓ ﻊ ﻋ ﺪد اﻟ ﻰ أس ﻣﻌ ﻴﻦ وﺣ ﺴﺐ اﻟﺤ ﺎﻻت أﻋ ﻼﻩ ﺳ ﺘﻌﻮد ﺑ ﺎﻟﻤﺘﻐﻴﺮ ) ‪ ( p‬واﻟﺘ ﻲ‬
‫ﺳﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء وﻟﻜﻞ ﺣﺎﻟﺔ أﺳﺘﺪﻋﺎء ‪ ,‬هﺬﻩ اﻟﻘﻴﻢ ﺗﺠﻤ ﻊ ﻟﻨﺤ ﺼﻞ‬
‫ﻋﻠﻰ اﻟﻨﺘﻴﺠﻪ اﻟﻨﻬﺎﺋﻴﻪ ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﺠﺐ أن ﻳﻜﻮن ﻋﺪد اﻟﻮﺳﺎﺋﻂ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ أﺳﻢ اﻷﺟﺮاء ﻓﻲ رأس اﻷﺟﺮاء ﻣﺴﺎوﻳﺎ اﻟﻰ‬
‫ﻋﺪد اﻟﻮﺳﺎﺋﻂ اﻟﻤﻮﺟﻮدﻩ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﻮﺳﺎﺋﻂ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪاء ﻳﺠﺐ أن ﺗﻜﻮن ﻣﺘﻨﺎﺳﺒﻪ ﻣﻊ اﻟﻮﺳﺎﺋﻂ ﻓﻲ رأس‬
‫اﻷﺟﺮاء ‪ ,‬ﻓﺎﻟﻮﺳﺎﺋﻂ اﻟﺘﻲ ﻓﻲ رأس اﻷﺟﺮاء أذا ﻟﻢ ﺗﻜﻦ ﻣﺴﺒﻮﻗﻪ ﺑﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻴﺠﺐ أن‬
‫ﻳﻘﺎﺑﻠﻬﺎ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء أﻣﺎ ﻗﻴﻤﻪ ﺛﺎﺑﺘﻪ أو ﻣﺘﻐﻴﺮ ﻟﻪ ﻗﻴﻤﻪ ﻣﺤﺪدﻩ ﻗﺒﻞ ذﻟﻚ ‪ .‬أﻣﺎ اﻟﻤﺘﻐﻴﺮ اﻟﺬي‬
‫ﻓﻲ رأس اﻷﺟﺮاء واﻟﻤﺴﺒﻮق ﺑﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻴﻘﺎﺑﻠﻪ ﻓﻲ اﻷﺳﺘﺪﻋﺎء ﻣﺘﻐﻴﺮ ‪.‬‬
‫ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﺳﺘﻨﺘﻘﻞ اﻟﻘﻴﻤﻪ ﻣﻦ اﻷﺳﺘﺪﻋﺎء اﻟﻰ اﻷﺟﺮاء وآﻞ ﻗﻴﻤﻪ ﺗﻨﺘﻘﻞ اﻟﻰ اﻟﻤﺘﻐﻴﺮ‬
‫اﻟﺬي ﻳﻘﺎﺑﻠﻬﺎ ﺣﺴﺐ ﺗﺮﺗﻴﺒﻬﺎ ) أي اﻟﻘﻴﻤﻪ اﻷوﻟﻰ ﺗﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻷول واﻟﻘﻴﻤﻪ اﻟﺜﺎﻧﻴﻪ ﺗﺴﻨﺪ‬
‫اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺜﺎﻧﻲ وهﻜﺬا ( ‪.‬‬
‫أﻣﺎ اﻟﺤﺎﻟﻪ اﻟﺜﺎﻧﻴﻪ ﻓﺘﻨﺘﻘﻞ اﻟﻘﻴﻤﻪ ﻣﻦ داﺧﻞ اﻷﺟﺮاء اﻟﻰ اﻟﻤﺘﻐﻴﺮ ﻓﻲ رأس اﻷﺟﺮاء ﺛﻢ ﻣﻨﻪ ﺗﺴﻨﺪ‬
‫اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻳﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء وﺣﺴﺐ اﻟﺘﺮﺗﻴﺐ أﻳﻀﺎ ‪.‬‬
‫آﺬﻟﻚ ﻳﺠﺐ أن ﺗﺘﻄﺎﺑﻖ اﻷﻧﻮاع ﺑﻴﻦ اﻟﻤﺘﻐﻴﺮات ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء وﺗﻠﻚ ﻓﻲ رأس اﻷﺟﺮاء وآﻞ‬
‫واﺣﺪ وﻣﺎ ﻳﻘﺎﺑﻠﻪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪72‬‬

‫ﻣﺜﺎل ‪:‬‬
‫;‪Program CH5_Program5‬‬
‫‪Var‬‬
‫;‪X:integer‬‬
‫;)‪Procedure Change ( var y:integer‬‬
‫‪Begin‬‬
‫;‪y:=1‬‬
‫;‪End‬‬
‫}‪{change‬‬
‫‪Begin‬‬
‫;‪X: =0‬‬
‫;)‪Change(x‬‬
‫;)‪Write ('x=', x‬‬
‫‪End.‬‬
‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//: 5‬‬
‫‪X=1‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 5‬‬
‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻓﻴﻪ ﻣﺘﻐﻴﺮ ﻋﺎم ﻳﺪﻋﻰ ) ‪ ( x‬ووﺳﻴﻂ ﻣﺮﺟﻌﻲ ﻳﺪﻋﻰ ) ‪ ( y‬آﺘﺒﻨﺎ هﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪( y‬‬
‫ﻓﻘﻂ ﻟﺘﺠﻨ ﺐ اﻷﺷ ﺘﺒﺎﻩ واﻟﺤﻘﻴﻘ ﻪ ه ﻮ أن اﻟﺒﺮﻧ ﺎﻣﺞ ﺳ ﻴﻌﻤﻞ ﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ ﻟ ﻮ أﺳ ﺘﺒﺪﻟﻨﺎ ) ‪ ( y‬وأﻳﻨﻤ ﺎ ﺗ ﺮد‬
‫) ‪ ( y‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﺑﺎﻟﻤﺘﻐﻴﺮ) ‪. ( x‬‬
‫وﻟﻤﺎ آﺎﻧﺖ ) ‪ ( y‬ﻓﻲ رأس اﻷﺟﺮاء ﻣ ﺴﺒﻮﻗﻪ ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻬ ﺬا ﻳﻌﻨ ﻲ أﻧﻬ ﺎ ﻣﺘﻐﻴ ﺮ وﺳ ﺘﻨﺘﻘﻞ‬
‫اﻟﻘﻴﻤﺔ اﻟﻤﻘﺎﺑﻠﻪ ﻣﻦ داﺧﻞ اﻷﺟﺮاء اﻟﻴﻬﺎ )ﻋﻨﺪ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء وﺗﻨﻔﻴ ﺬﻩ ( ‪ ,‬ﺛ ﻢ ﻣﻨﻬ ﺎ اﻟ ﻰ أﻣ ﺮ اﻷﺳ ﺘﺪﻋﺎء‬
‫) أي ﻣﻦ ‪ y‬اﻟﻰ ‪. ( x‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻋﻨﻤﺎ ﺗﻜﻮن اﻟﻮﺳﺎﺋﻂ ﻣﺘﻐﻴﺮات ) أي ﻣﺴﺒﻮﻗﻪ ﺑﺎﻷﻣﺮ ‪ ( var‬ﻓﻲ رأس اﻷﺟﺮاء ﻓﺄن اﻟﻤﺘﻐﻴﺮات‬
‫اﻟﻤﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ اﻷﺳﺘﺪﻋﺎء ﻳﺠﺐ أن ﺗﻜﻮن ﻣﺘﻐﻴﺮات وﻟﻴﺲ ﺗﻌﺎﺑﻴﺮ ) ‪ ( expression‬ﻓﻤﺜﻼ‬
‫اﻷﺳﺘﺪﻋﺎء ) )‪ ( change ( 2*x‬ﻏﻴﺮ ﻣﻘﺒﻮل ﻷﻧﻪ ﻳﺴﺘﺨﺪم اﻟﺘﻌﺒﻴﺮ ) ‪ ( 2*x‬وآﺬﻟﻚ اﻷﺳﺘﺪﻋﺎء‬
‫) ) ‪ ( change ( 2‬أﻳﻀﺎ ﻏﻴﺮ ﻣﻘﺒﻮل ﻷﻧﻪ ﻳﺴﺘﺨﺪم ﺛﺎﺑﺖ ) اﻟﻤﻔﺮوض أن ﻳﻜﻮن ﻣﺘﻐﻴﺮ ( ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪73‬‬

‫;‪Program CH5_Program6‬‬
‫‪Var‬‬
‫;‪X:integer‬‬
‫;)‪Procedure Change(y: integer‬‬
‫‪Begin‬‬
‫;‪y:=1‬‬
‫;‪End‬‬
‫}‪{change‬‬
‫‪Begin‬‬
‫;‪X: =0‬‬
‫;)‪Change (x‬‬
‫;)‪Write(x‬‬
‫‪End.‬‬
‫}‪{Main program‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪:‬‬
‫‪X=0‬‬

‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) ‪//: ( 6‬‬
‫ﻣﺮة أﺧﺮى ‪ ,‬ﻟﺪﻳﻨﺎ ﻣﺘﻐﻴﺮ ﻋﺎم ) ‪ ( x‬ووﺳﻴﻂ ) ‪ . ( y‬ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﻪ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻮﺳ ﻴﻂ ﻏﻴ ﺮ‬
‫ﻣﺴﺒﻮق ﺑﺎﻷﻣﺮ ) ‪ ( var‬وﻟﺬﻟﻚ ﻓﺄن هﺬا اﻟﻮﺳﻴﻂ ﻳﺪﻋﻰ وﺳﻴﻂ ﻗﻴﻤﻪ ‪.‬‬
‫ﻋﻨﺪ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء ﻓ ﺄن اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬ﻳﻤ ﺮر اﻟ ﻰ اﻷﺟ ﺮاء ﻓﻴﻜ ﻮن ) ‪ ( y : = x‬ﻗﺒ ﻞ أن ﻳ ﺘﻢ‬
‫ﺗﻨﻔﻴ ﺬ أي ﻋﺒ ﺎرﻩ ﻣ ﻦ اﻷﺟ ﺮاء ‪ .‬وﻟﻜ ﻦ ﺑﻌ ﺪ اﻟ ﺪﺧﻮل ﻓ ﻲ اﻷﺟ ﺮاء ﻓ ﺴﻮف ﻻﺗﻜ ﻮن هﻨ ﺎك أي ﻋﻼﻗ ﻪ ﺑ ﻴﻦ‬
‫اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( x‬واﻟﻤﺘﻐﻴ ﺮ ) ‪ , ( y‬ﻋﻠﻴ ﻪ ﻓ ﺄن اﻟﺘﻐﻴﻴﺮاﻟ ﺬي ﻳﻄ ﺮأ ﻋﻠ ﻰ ) ‪ ( y‬ﺳ ﻮف ﻻﻳ ﺆﺛﺮﻋﻠﻰ اﻟﻤﺘﻐﻴ ﺮ‬
‫)‪.(x‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻮﺳﻴﻂ وﺳﻴﻂ ﻗﻴﻤﻪ ﻓﻤﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام اﻟﺘﻌﺎﺑﻴﺮ ﻣﺜﻞ‬
‫) ) ‪ ( change ( x*2 ) OR change ( 2‬ﻷن ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﺳﺘﻜﻮن هﻨﺎك ﻋﻤﻠﻴﺔ‬
‫أﺳﻨﺎد ﺿﻤﻨﻴﻪ ) ‪ ( y : = 2 * x‬وآﺬﻟﻚ ﻓﻲ اﻟﺤﺎﻟﻪ اﻟﺜﺎﻧﻴﻪ ) ‪ , ( y : = 2‬وﻗﺒﻞ ﺗﻨﻔﻴﺬ أي ﻋﺒﺎرﻩ‬
‫ﻣﻦ ﻋﺒﺎرات اﻷﺟﺮاء ‪.‬‬

‫ﻣﺜﺎل ‪ :‬ﻧﻔﺮض أﻧﻨﺎ ﻧﺮﻏﺐ ﺑﺄﺑﺪال ﻗﻴﻢ ﻣﺘﻐﻴﺮﻳﻦ ﺑﺤﻴﺚ ﺗﻜﻮن آﻞ واﺣﺪﻩ ﻓﻲ ﻣﻜﺎن اﻷﺧﺮى‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

74

Program CH5_Program7;
Var
X,y:integer;
Procedure swap ( x,y:integer);
Var
T:integer;
Begin
T: =x;
x: =y;
Y: =t;
Writeln ('x=', x,'y=', y);
End;
Begin
X: =3;
Y: =42;
Swap(x, y);
Writeln ( 'x= ', x,' y= ', y);
End.

//: 7 ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ‬
X = 42
X=3

y=3
y = 42
‫ ( ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﺑﻴﻨﻤﺎ ﺗﻐﻴﺮت ﻓﻲ اﻷﺟﺮاء‬x, y ) ‫ﻟﻢ ﺗﺘﻐﻴﺮ ﻗﻴﻢ‬
( ‫)ﺗﻤﺮﻳﺮ وﺳﻴﻄﺔ ﻗﻴﻤﻪ‬

Program CH5_Program8;
Var
X,y:integer;
Procedure swap ( var x,y:integer);
Var
T:integer;
Begin
T:=x;
x:=y;
Y: =t;
Writeln ( 'x= ', x,' y= ', y);
End;
Begin
X: =3;
Y: =42;
Swap(x, y);
Writeln ( 'x= ', x,' y= ', y);
End.

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪75‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪y=3‬‬
‫‪y=3‬‬

‫‪X = 42‬‬
‫‪X = 42‬‬

‫ﺗﻐﻴﺮ ﻗﻴﻤﺘﻲ ) ‪ ( x, y‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ واﻷﺟﺮاء‪.‬‬

‫‪5.3‬‬

‫اﻟﺪوال ‪FUNCTIONS‬‬

‫أن اﻟﻔﺮق اﻟﺮﺋﻴﺲ ﺑﻴﻦ اﻷﺟﺮاءات واﻟﺪوال هﻮ أن اﻟﺪوال ﻳﺠﺐ أن ﺗﻌﻴﺪ ﻗﻴﻤ ﻪ ﻋﻨ ﺪ ﺗﻨﻔﻴ ﺬهﺎ ﺑﻴﻨﻤ ﺎ‬
‫اﻷﺟﺮاءات ﻻﺗﻌﻴﺪ ﻗﻴﻤ ﻪ ‪ .‬ﺗﺒ ﺪأ اﻟ ﺪوال وﺗﻨﺘﻬ ﻲ ﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ اﻟﺘ ﻲ ﺗﺒ ﺪأ وﺗﻨﺘﻬ ﻲ ﻓﻴﻬ ﺎ اﻷﺟ ﺮاءات ‪ .‬أﻣ ﺎ‬
‫اﻟﻘﻴﻤﻪ اﻟﻤﻌﺎدﻩ ﻓﻲ اﻟﺪوال ﻓﺘﻌﺎد ﺑﺄﺳ ﻢ اﻟﺪاﻟ ﻪ ‪ ,‬وه ﺬا ﻳﻌﻨ ﻲ أن أﺳ ﻢ اﻟﺪاﻟ ﻪ ﺳ ﻴﻜﻮن ﻣﺘﻐﻴ ﺮ ﻳﺤﻤ ﻞ ﻗﻴﻤ ﻪ ه ﺬﻩ‬
‫اﻟﻘﻴﻤﻪ هﻲ اﻟﻘﻴﻤﻪ اﻟﻨﺎﺗﺠﻪ ﻣﻦ ﺗﻨﻔﻴﺬ اﻟﺪاﻟﻪ ‪ ,‬وأزاء ذﻟﻚ وﻟﻤﺎ آﺎن أﺳﻢ اﻟﺪاﻟﻪ هﻮ ﻣﺘﻐﻴﺮ أذن ﻳﺠﺐ أن ﻳﻜ ﻮن‬
‫ﻟﻪ ﻧﻮع ‪ ...‬ﻋﻠﻴﻪ داﺋﻤﺎ ﺳﻨﻼﺣﻆ أﺳﻢ اﻟﺪاﻟﻪ ﻣﺘﺒﻮع ﺑﻨﻮﻋﻪ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻠﺪاﻟﻪ هﻲ ‪:‬‬
‫; ‪Function < function name > : type‬‬
‫‪OR‬‬
‫; ‪Function < function name > ( Arguments ) : type‬‬

‫ﻣﺜﺎل ‪ :‬ﻓﻲ هﺬا اﻟﻤﺜﺎل ﺳﻨﻌﻴﺪ آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ) ‪ ( 3‬وﻟﻜﻦ ﻣﻊ أﺳﺘﺨﺪام اﻟﺪوال‬

‫;‪Program CH5_Program9‬‬
‫‪Var‬‬
‫;‪Y: longint‬‬
‫;‪Function power (m: integer): longint‬‬
‫‪Var‬‬
‫;‪I:integer‬‬
‫;‪P:longint‬‬
‫‪Begin‬‬
‫;‪P: =1‬‬
‫‪For i: =1 to m do‬‬
‫;‪P: =p*m‬‬
‫;‪Power: =p‬‬
‫;‪End‬‬
‫}‪{end function‬‬
‫‪Begin‬‬
‫}‪{main program‬‬
‫;)‪Y: = power (10) + power (8) + power (6) + power (4‬‬
‫;)‪Writeln(y‬‬
‫;‪Readln‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬

‫آﻞ اﻟﺪوال واﻷﺟﺮاءات ﺗﻜﺘﺐ ﺑﻌﺪ اﻷﻣﺮ ) ‪ ( var‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪,‬‬
‫وﻟﻴﺲ ﻗﺒﻠﻪ ‪.‬‬
‫أن أﺳﺘﺪﻋﺎء اﻟﺪوال واﻷﺟﺮاءات ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻏﻴﺮ ﻣﺤﺪدﻩ ﺑﺘﺮﺗﻴﺐ‬
‫هﺬﻩ اﻟﺪوال أو اﻷﺟﺮاءات ‪.‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﺘﺪاﺧﻞ اﻷﺟﺮاءات أو اﻟﺪوال ) ﺑﺤﻴﺚ ﻳﻤﻜﻦ أن ﺗﺴﺘﺪﻋﻰ‬
‫أﺟﺮاء أو داﻟﻪ ﻣﻦ داﺧﻞ داﻟﻪ أو أﺟﺮاء أﺧﺮ ( ‪.‬‬
‫ﻋﻨﺪ ﺣﺪوث اﻟﺘﺪاﺧﻞ ﻓﻴﺠﺐ ﻣﺮاﻋﺎة اﻟﺘﺮﺗﻴﺐ ﺣﻴﺚ ﻻ ﻳﺠﻮز أﺳﺘﺪﻋﺎء داﻟﻪ أو‬
‫أﺟﺮاء ﻣﻦ داﺧﻞ داﻟﻪ أو أﺟﺮاء أﺧﺮ ﻳﻜﻮن ﺳﺎﺑﻖ ﻟﻪ ﺑﺎﻟﺘﺮﺗﻴﺐ ﻋﻨﺪ آﺘﺎﺑﺔ‬
‫اﻷﺟﺮاءات واﻟﺪوال ) ﻳﺠﺐ أن ﺗﻜﻮن اﻟﻤﺴﺘﺪﻋﺎة ﺳﻠﺒﻘﻪ ( ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪:‬‬
‫ﻣﺘﻰ ﻧﺴﺘﺨﺪم اﻟﺪاﻟﻪ ﺑﺪل اﻷﺟﺮاء ؟‬
‫اﻟﻘﺎﻋﺪﻩ اﻟﻌﺎﻣﻪ هﻮ أن ﻧﻔﻜﺮ أن اﻟﺪاﻟﻪ آﻬﻴﻜﻞ ﺗﻌﻴﺪ ﻗﻴﻤﻪ واﺣﺪﻩ ﻓﻘﻂ ‪ .‬ﺗﺴﺘﺨﺪم اﻟﺪاﻟﻪ‬
‫ﻋﻨﺪﻣﺎ ﻳﻜﻮن اﻟﻤﻄﻠﻮب ﻗﻴﻤﻪ ﻣﻔﺮدﻩ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ‪.‬‬

‫‪76‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

77

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬

5.4

‫ ﺣﻴﺚ أن‬, ( y ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬

Y = x + x2 / 2! + x3 / 3! + ……..+ xn / n!

Program CH5_Program10;
Var
J, n: integer;
Y: real;
Function power (x, j: integer): integer;
Var
I, p: integer;
Begin
P: =1;
For i: =1 to j do
P: =p*x;
Power: =p;
End;
Function factorial (j:integer):integer;
Var
F,i:integer;
Begin
F: =1;
For i: =j downto 1 do
F: =f*I;
Factorial: =f;
End;
Begin {main program}
Writeln ('Enter number of elements');
Readln (n);
Y: =0;
For j: =1 to n do
Y: =y + power(x, j) / factorial (j);
Writeln(y: 6:4);
End.

.‫ ( ﻋﻨﺼﺮ‬25 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻲ ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﺣﺠﻤﻬﺎ‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

78

Program CH5_Program11;
Const
N=25;
Var
A: array [1..n] of integer;
X: integer;
Procedure readarray;
Var
I: integer;
Begin
For i: =1 to n do
Readln (a[i]);
End;
Procedure findmax (var max: integer);
Var
I: integer;
Begin
Max: =a [1];
For i: =2 to n do
If (a[i] > max) then
Max: =a[i];
End;
Begin {main program}
Readarray;
Findmax(x);
Writeln(x);
End.

. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﻌﺪد اﻷآﺒﺮ ﺑﻴﻦ ﺛﻼﺛﺔ أﻋﺪاد‬

Program CH5_Program12;
Var
T,x,y,z:integer;
Function largest(x, y: integer): integer;
Begin
If x > y then
Largest: =x
Else
Largest: =y;
End;
Begin
{main program}
Writeln ('Enter three numbers');
Readln(x, y, z);
T: =largest(x, y);
Writeln (' largest number=', largest (t, z));
End.

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

79

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻣﺮﺑﻊ أي ﻋﺪد ) ﺣﻴ ﺚ أن ﻣﺮﺑ ﻊ اﻟﻌ ﺪد ﻳ ﺴﺎوي ﻣﺠﻤ ﻮع ﻋ ﺪد ﻣ ﻦ اﻷﻋ ﺪاد‬
‫اﻟﻔﺮدﻳﻪ ) ﻋ ﺪدهﻢ ﺑﻘ ﺪر اﻟﻌ ﺪد اﻟﻤ ﺮاد أﻳﺠ ﺎد ﻣﺮﺑﻌ ﻪ ( أﺑﺘ ﺪاءا ﻣ ﻦ اﻟﻌ ﺪد واﺣ ﺪ ﺻ ﻌﻮدا ( ) ﻣ ﺜﻼ‬
. ( ( 16 ) ‫ ( وﻳﻜﻮن اﻟﻨﺎﺗﺞ‬1+3+5+7 ) ‫ ( هﻮ‬4 ) ‫ﻣﺮﺑﻊ اﻟﻌﺪد‬

Program CH5_Program13;
Var
Y: integer;
Ch: char;
Procedure square (x: integer);
Var
I, sum: integer;
Begin
Sum: =0;
i: =1;
Repeat
Sum: = sum + I;
Inc (I, 2);
Dec(x);
Until(x<=0);
Writeln ('Square of number',y,'=',sum);
End;
Begin
Writeln ('Enter number to find its square');
Repeat
Readln(y);
Square(y);
Writeln ('Do you want to enter another number(Y/N)');
Readln (ch):
Until (ch='N');
End.

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪80‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬
‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRINGS‬‬
‫‪6.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ) ‪ ( String‬ه ﻲ ﻋ ﺪد ﻣ ﻦ اﻷﺷ ﻴﺎء ﻓ ﻲ ﺧ ﻂ ‪ ,‬ﻣﺜ ﻞ ﺳﻠ ﺴﻠﻪ دور ‪ ,‬اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺪﻳﺪﻳ ﻪ ) واﻟﺘ ﻲ ه ﻲ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻟﺤﻠﻘ ﺎت اﻟﻤﺘ ﺼﻠﻪ واﺣ ﺪﻩ ﺑ ﺎﻷﺧﺮى ( ‪ ,‬وآ ﺬﻟﻚ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ‬
‫واﻟﺘﻲ هﻲ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺤﺮوف ‪.‬‬
‫ﻟﻘﺪ ﺗﻌﺮﻓﻨﺎ ﺳﺎﺑﻘﺎ ﻋﻠﻰ ﻣﺎهﻴﺔ ﻣﺘﻐﻴﺮ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ‪ ,‬وﻟﻜ ﻦ ﻣ ﺎﻟﻢ ﻧﺘﻌﻠﻤ ﻪ ﻟﻐﺎﻳ ﺔ اﻷن ه ﻮ ﻣ ﺎهﻲ‬
‫اﻟﻌﻤﻠﻴ ﺎت واﻟ ﺪوال اﻟﺘ ﻲ ﻣﻤﻜ ﻦ أن ﺗﻄﺒ ﻖ ﻋﻠ ﻰ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ وآﻴﻔﻴ ﺔ اﻟﺘﻌﺎﻣ ﻞ ﻣﻌﻬ ﺎ وﺗﺤﻮﻳﺮه ﺎ‬
‫ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﺳﻼﺳﻞ ﺟﺪﻳﺪﻩ ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻷﺻﻠﻴﻪ ‪.‬‬
‫ﻓﻲ هﺬا اﻟﻔﺼﻞ ﺳﻨﻐﻄﻲ ﺑﻌﺾ اﻟﺪوال اﻟﻤﻬﻤﻪ واﻟﺘﻲ ﺗﻮﻓﺮهﺎ ﻟﻨﺎ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﺑﺎﺳﻜﺎل ‪.‬‬
‫‪6.2‬‬

‫ﻣﺎهﻲ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬

‫ﻟﻐﺮض اﻟﻔﻬﻢ اﻟﺠﻴﺪ ﻟﻠﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪ ,‬ﻳﺠﺐ أن ﻧﻀﻊ ﻓﻲ أذهﺎﻧﻨﺎ ﺑﺄن اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
‫هﻲ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺼﻔﻮﻓﻪ ﻣﻦ اﻟﺤ ﺮوف ‪ .‬أن ﻧ ﻮع اﻟﺒﻴﺎﻧ ﺎت ﻟﻠ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ه ﻲ ) ﻧ ﻮع ﺑﻴﺎﻧ ﺎت ﻣﺒﻨ ﻲ‬
‫داﺧﻠﻴﺎ ( ﻣﺼﻔﻮﻓﻪ ﻣﻦ ) ‪ 256‬ﺣﺮف ( ‪:‬‬
‫‪Type‬‬
‫; ‪String = array [ 0 .. 255 ] of char‬‬
‫ﻟﻬﺬا اﻟﺴﺒﺐ ﻓﺄن اﻟﻤﺘﻐﻴﺮاﻟﺬي ﻳﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻋﻠﻰ أﻧﻪ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ‬
‫ﻓﺴﻴﺤﺠﺰ ﻟﻪ ) ‪ 256‬ﺑﺎﻳﺖ ( آﻤﺎ ﺳﺒﻖ وﺑﻴﻨﺎ ﻓﻲ اﻟﺠﺪول ) ‪. ( 1.4‬‬
‫أذن أﺻ ﺒﺢ واﺿ ﺢ أن اﻟ ﺬاآﺮﻩ ﺳ ﺘﺤﺠﺰ ) ‪ 256‬ﺑﺎﻳ ﺖ أو ﻣﻮﻗ ﻊ ﻣﺘﺠ ﺎور( ﻟﻤﺘﻐﻴ ﺮ اﻟ ﺴﻼﺳﻞ‬
‫اﻟﺤﺮﻓﻴﻪ ‪ ,‬ﻟﺬﻟﻚ ﻓﺄن اﻟﻤﻌﺎﻟﺞ ﻳﺠ ﺐ أن ﻳﻌ ﺮف ﻣﻮﻗ ﻊ اﻟﺒﺪاﻳ ﻪ ﻟﻠﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ وﻣﻮﻗ ﻊ اﻟﻨﻬﺎﻳ ﻪ أﻳ ﻀﺎ ) أي‬
‫أﻳﻦ ﺗﺒﺪأ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ وأﻳﻦ ﺗﻨﺘﻬﻲ ( ‪ .‬وﻟﻤﺎ آﺎﻧ ﺖ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻣ ﺼﻔﻮﻓﻪ ﺣ ﺴﺐ اﻟﺘﻌﺮﻳ ﻒ أﻋ ﻼﻩ‬
‫ﻓ ﺄن ﻣﻮاﻗ ﻊ اﻟﻤ ﺼﻔﻮﻓﻪ ) ‪ ( 1 .. 255‬ﺳ ﺘﺤﺘﻮي ﻋﻠ ﻰ اﻟﺤ ﺮوف اﻟﺘ ﻲ ﺗﺤﺘﻮﻳﻬ ﺎ اﻟﺴﻠ ﺴﻠﻪ وه ﺬا ﻻﻳﻌﻨ ﻲ أن‬
‫ﺗﻜﻮن اﻟﺴﻠﺴﻠﻪ ﺑﻄﻮل ) ‪ ( 255‬ﺣﺮف ﺣﻴﺚ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﻮن أﻗﻞ ﻣ ﻦ ذﻟ ﻚ ﻟﻜ ﻦ اﻟﻄ ﻮل اﻷﻋﻈ ﻢ ﻟﻬ ﺎ‬
‫ه ﻮ ) ‪ . ( 255‬أﻣ ﺎ اﻟﻤﻮﻗ ﻊ ) ‪ ( 0‬ﻓ ﻲ ﻣ ﺼﻔﻮﻓﺔ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻓﺄﻧ ﻪ ﺳ ﻴﺤﺘﻮي ﻋﻠ ﻰ ﻃ ﻮل اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴ ﻪ ) ﻋ ﺪد اﻷﺣ ﺮف ﻓ ﻲ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ( ‪ ,‬وﺑ ﺬﻟﻚ ﺳ ﻴﻜﻮن واﺿ ﺢ ﻟﻠﻤﻌ ﺎﻟﺞ أﻳ ﻦ ﺗﻨﺘﻬ ﻲ اﻟﺴﻠ ﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴﻪ ﻣﻦ ﺧﻼل ﻗﺮاءة اﻟﻤﻮﻗﻊ ) ‪ ( 0‬ﻓﻲ ﻣﺼﻔﻮﻓﺔ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪ .‬ﻣﺜﺎل‬

‫;‪Program CH6_Program1‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫‪Begin‬‬
‫;' ‪St: = ' computer‬‬
‫;)]‪Writeln (st [2‬‬
‫;)]‪Writeln (st [5‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪81‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪c‬‬
‫‪p‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻓﻲ اﻟﻤﺜﺎل أﻋﻼﻩ ﺗﻢ ﺣﺴﺎب اﻟﻔﺮاﻏﻴﻦ اﻟﻤﻮﺟﻮدﻳﻦ ﻗﺒﻞ وﺑﻌﺪ ) ‪ ( computer‬ﻋﻠﻰ أﻧﻬﻤﺎ‬
‫ﺣﺮوف ‪ ,‬ﻟﺬا داﺋﻤﺎ ﺗﺤﺴﺐ اﻟﻔﺮاﻏﺎت ﻋﻠﻰ أﻧﻬﺎ ﺣﺮوف وﻓﻲ أي ﻣﻮﻗﻊ ﺗﺮد ﻓﻲ اﻟﺴﻠﺴﻠﻪ‬
‫اﻟﺤﺮﻓﻴﻪ ‪.‬‬

‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ﺗ ﻢ اﻟﺘﻌﺎﻣ ﻞ ﻣ ﻊ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻋﻠ ﻰ أﻧﻬ ﺎ ﻣ ﺼﻔﻮﻓﻪ دون اﻟﺤﺎﺟ ﻪ اﻟ ﻰ ﺗﻌﺮﻳﻔﻬ ﺎ‬
‫آﻤﺼﻔﻮﻓﻪ ﻷﻧﻬﺎ ﻣﻌﺮﻓﻪ داﺧﻞ اﻟﺤﺎﺳﺐ آﻤﺼﻔﻮﻓﻪ آﻤﺎ ﺑﻴﻨﺎ ‪.‬‬
‫‪6.3‬‬

‫اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ‬

‫هﻨ ﺎك ﺑﻌ ﺾ اﻟ ﺪوال اﻟﻤﺨﺰوﻧ ﻪ ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل واﻟﺘ ﻲ ﺗ ﺴﺎﻋﺪ ﻋﻠ ﻰ أﺟ ﺮاء ﺑﻌ ﺾ‬
‫اﻟﻌﻤﻠﻴﺎت ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ وﻳﻜﻔﻲ أﺳ ﺘﺪﻋﺎﺋﻬﺎ ﺑﺄﺳ ﻤﻬﺎ ﻟﺘﻘ ﻮم ﺑﺎﻟﻌﻤ ﻞ‬
‫اﻟﻤﺤﺪد ﻟﻬﺎ ‪ .‬ﻣﻦ هﺬﻩ اﻟﺪوال ‪:‬‬
‫‪ 6.3.1‬ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ ‪POS‬‬
‫ﻧﺤﺘﺎج أﺣﻴﺎﻧﺎ اﻟﻰ ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف داﺧﻞ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ‪ ,‬وﻟﺘﺤﻘﻴ ﻖ ذﻟ ﻚ‬
‫ﻧ ﺴﺘﺨﺪم اﻟﺪاﻟ ﻪ ) ‪ ( Pos‬واﻟﺘ ﻲ ﺳ ﺘﻘﻮم ﺑﺎﻟﺒﺤ ﺚ ﻋ ﻦ ) اﻟﺤ ﺮف أو ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ‬
‫ﻣﺠﻤﻮﻋ ﻪ ﺟﺰﺋﻴ ﻪ ﻣ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ( داﺧ ﻞ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ‪ ,‬ﻓ ﺎذا ﻟ ﻢ ﻳ ﺘﻢ أﻳﺠ ﺎد اﻟﺴﻠ ﺴﻠﻪ اﻟﺠﺰﺋﻴ ﻪ‬
‫ﺿﻤﻦ اﻟﺴﻠﺴﻠﻪ اﻷﺻﻠﻴﻪ ﻓﺄﻧﻬﺎ ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) ‪ ( 0‬أﻣﺎ أذا وﺟﺪﺗ ﻪ ﻓﺄﻧﻬ ﺎ ﺳ ﺘﻌﻴﺪ اﻟ ﺮﻗﻢ اﻟ ﺬي ﻳﺤ ﺪد ﻣﻮﻗ ﻊ أول‬
‫ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺠﺰﺋﻴﻪ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪N : = Pos ( st , stn‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪ : N‬ﺗﻤﺜﻞ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ‪.‬‬
‫‪ : st‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻋﻨﻬﺎ‪.‬‬
‫‪ : stn‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻓﻴﻬﺎ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪82‬‬

‫; ‪Program CH6_Program2‬‬
‫‪Var‬‬
‫;‪N, x: integer‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪Stn: = 'System Software‬‬
‫;'‪St1: = 'Soft‬‬
‫;'‪St2: = 'system‬‬
‫;)‪N: = Pos (st1, stn‬‬
‫;)‪X: = Pos (st2, stn‬‬
‫;)‪Writeln (n,' ****** ', x‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪8 ****** 0‬‬

‫ﻻﺣﻆ أن ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﺴﺎوي ) ‪ ( 0‬وذﻟ ﻚ ﻷن اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻟﺘ ﻲ ﻧﺒﺤ ﺚ ﻋﻨﻬ ﺎ ه ﻲ‬
‫) ‪ ( system‬ﺗﺒ ﺪأ ﺑﺤ ﺮف ﺻ ﻐﻴﺮ ﺑﻴﻨﻤ ﺎ اﻟﻜﻠﻤ ﻪ اﻟﻤﻘﺎﺑﻠ ﻪ ﻓ ﻲ ) ‪ ( System ) ( stn‬ﺗﺒ ﺪأ ﺑﺤ ﺮف آﺒﻴ ﺮ‬
‫وﺑﺬﻟﻚ أﺻﺒﺢ أﺧﺘﻼف ﺑﻴﻦ اﻟﻜﻠﻤﺘﻴﻦ ﻟﺬﻟﻚ ﻋﻤﻠﻴﺔ اﻟﺒﺤ ﺚ ﺳ ﻮف ﻻﺗﺠ ﺪ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﻠﺮﻓﻴ ﻪ اﻟﻤﻄﻠﻮﺑ ﻪ ‪ ,‬أذن‬
‫ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) ‪. ( 0‬‬
‫‪ 6.3.2‬اﻷﺳﺘﻨﺴﺎخ ‪COPY‬‬
‫هﺬﻩ اﻟﺪاﻟﻪ ﺳﺘﻘﻮم ﺑﺄﺳﺘﻨﺴﺎخ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﺤ ﺪدﻩ ‪ ,‬أﻋﺘﺒ ﺎرا‬
‫ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم وﺣﺴﺐ ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤ ﺴﺘﺨﺪم ‪ ,‬وﺳ ﺘﻌﻴﺪ ه ﺬﻩ اﻟﺪاﻟ ﻪ‬
‫ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺟﺰﺋﻴﻪ وهﻲ اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤﺴﺘﺨﺪم ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪St : = Copy ( stn , Position , count‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪St‬‬
‫‪Stn‬‬
‫‪Position‬‬
‫‪Count‬‬

‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ‪.‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻷﺳﺘﻨﺴﺎخ ﻣﻨﻬﺎ‪.‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻣﻮﻗﻊ ﺑﺪاﻳﺔ اﻟﺴﻠﺴﻠﻪ اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ‪.‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻷﺣﺮف اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪83‬‬

‫;‪Program CH6_Program3‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪Stn:= 'computer science‬‬
‫;)‪St1:= copy (stn, 2, 4‬‬
‫;)‪St2:= copy (stn, 12, 20‬‬
‫;)‪Writeln ( st1,' ****** ', st2‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪ompu ****** ience‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻﺣﻆ أن اﻟﻤﺘﻐﻴﺮ ) ‪ ( st2‬آﺎن ﻣﻦ اﻟﻤﻔﺮوض أن ﻳﺴﺘﻨﺴﺦ ﻓﻴﻪ ) ‪ ( 20‬ﺣﺮف أﺑﺘﺪاءا ﻣﻦ‬
‫اﻟﺤﺮف رﻗﻢ ) ‪ ( 12‬وﻧﻈﺮا اﻟﻰ أن اﻟﺴﻠﺴﻠﻪ ﺗﻨﺘﻬﻲ ﻗﺒﻞ ﺗﺤﻘﻖ هﺬا اﻟﺸﺮط ﻓﺄﻧﻪ ﺳﻴﻜﺘﻔﻲ‬
‫ﺑﺎﻟﻤﺘﺒﻘﻲ ﻣﻦ اﻟﺤﺮوف ‪.‬‬

‫‪ 6.3.3‬اﻟﺤﺬف ‪DELETE‬‬
‫داﻟ ﺔ اﻟﺤ ﺬف ﺗ ﺴﺘﺨﺪم ﻟﺤ ﺬف ﺣ ﺮف أو ﻋ ﺪد ﻣ ﻦ اﻟﺤ ﺮوف ﻣ ﻦ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﻣﻌﻴﻨ ﻪ ‪ ,‬وﺑﻌ ﺪ‬
‫اﻟﺤﺬف ﻳﻌﻴﺪ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻟﺠﺪﻳ ﺪﻩ وﺑ ﻨﻔﺲ ﻣﺘﻐﻴ ﺮ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻷﺻ ﻠﻴﻪ ‪ ,‬أن اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺒ ﺪأ‬
‫ﻣﻨﻪ اﻟﺤﺬف وﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ﺣﺬﻓﻬﺎ ﺗﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪Delete (stn, Position, Count‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪Stn‬‬
‫‪Position‬‬
‫‪Count‬‬

‫‪ :‬اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻟﺤﺬف ﻣﻨﻬﺎ‪.‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺒﺪأ اﻟﺤﺬف ﻣﻨﻪ‪.‬‬
‫‪ :‬رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ﺣﺬﻓﻬﻢ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪84‬‬
‫;‪Program CH6_Program4‬‬
‫‪Var‬‬
‫;‪Stn: string‬‬
‫‪Begin‬‬
‫;'‪Stn: ='System Software‬‬
‫;)‪Delete (stn, 8, 3‬‬
‫;)‪Writeln (stn‬‬
‫;)‪Delete (stn, 7, 15‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪System tware‬‬
‫‪System‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻓﻲ أﻣﺮ اﻟﺤﺬف اﻟﺜﺎﻧﻲ آﺎن اﻟﻤﻄﻠﻮب ﺣﺬف ) ‪ ( 15‬ﺣﺮف اﺑﺘﺪاءا ﻣﻦ اﻟﻤﻮﻗﻊ ) ‪ ( 7‬وﻧﻈﺮا‬
‫ﻟﻌﺪم وﺟﻮد ) ‪ ( 15‬ﺣﺮف ﺑﻌﺪ اﻟﺤﺮف اﻟﺴﺎﺑﻊ ﻟﺬا ﺳﻴﺘﻢ ﺣﺬف اﻟﻤﺘﺒﻘﻲ ﻣﻦ اﻟﺤﺮوف ﻓﻘﻂ ‪.‬‬

‫‪ 6.3.4‬اﻟﺤﺸﺮ ‪INSERT‬‬
‫ﺗﻌﻤ ﻞ ه ﺬﻩ اﻟﺪاﻟ ﻪ ﻋﻠ ﻰ ﺣ ﺸﺮ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﺑ ﺄي ﻃ ﻮل داﺧ ﻞ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ أﺧ ﺮى ﺑ ﺪءا ﻣ ﻦ‬
‫اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد ﻣﻦ اﻟﻤﺴﺘﺨﺪم ) ﻣﻮﻗﻊ اﻟﺤﺮف ﻓﻲ اﻟﺴﻠﺴﻠﻪ اﻟﻤﺼﺪر اﻟﺬي ﺳﻴﺘﻢ اﻟﺤ ﺸﺮ ﺑﻌ ﺪﻩ ( ‪ .‬ﺳ ﻮف ﻻ‬
‫ﻳﺘﻢ ﺣﺬف أي ﻣﻦ اﻟﺤﺮوف ﻣﻦ اﻷﻣﺎم ﻋﺪا أذا آ ﺎن ﻃ ﻮل اﻟﺴﻠ ﺴﻠﻪ اﻟﻨﺎﺗﺠ ﻪ أآﺒ ﺮ ﻣ ﻦ ) ‪ ( 255‬ﻓﻌﻨ ﺪ ذﻟ ﻚ‬
‫ﺳﺘﺤﺬف اﻟﺤﺮوف اﻟﺰاﺋﺪﻩ ﻋﻦ هﺬا اﻟﻌﺪد ﻣﻦ اﻷﻣﺎم ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪Insert ( st , stn , Position‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪stn‬‬
‫‪st‬‬
‫‪Position‬‬

‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻷﺻﻠﻴﻪ اﻟﺘﻲ ﺳﻴﺤﺸﺮ ﻓﻴﻬﺎ‪.‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب ﺣﺸﺮهﺎ‪.‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﺳﺘﺤﺸﺮ ﻓﻴﻪ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪85‬‬

‫ﻣﺜﺎل ‪:‬‬
‫;‪Program CH6_Program5‬‬
‫‪Var‬‬
‫;‪S: String‬‬
‫‪Begin‬‬
‫'?‪S: = 'Hey! How are you‬‬
‫;))‪Write (Insert (' Ali', s, 4‬‬
‫;)‪Writeln(s‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫'?‪'Hey Ali! How are you‬‬

‫‪ 6.3.5‬دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن ‪CONCAT‬‬
‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺪﻣﺞ ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ أو أآﺜﺮﺑﺴﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ واﺣﺪﻩ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; )… ‪Stn : = Concat ( st1, st2, st3,‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪Stn‬‬
‫‪st1, st2, st3‬‬

‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﻨﺎﺗﺠﻪ ﻣﻦ اﻟﺪﻣﺞ‪.‬‬
‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻼﺳﻞ اﻟﺘﻲ ﺳﻴﺘﻢ دﻣﺠﻬﺎ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬
‫;‪Program CH6_Program6‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪St1:='info‬‬
‫;'‪St2:='rmation‬‬
‫;)‪Stn: =concat (st1, st2‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪information‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪86‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻣﻤﻜﻦ اﻷﺳﺘﻌﺎﺿﻪ ﻋﻦ اﻟﺪاﻟﻪ ) ‪ ( concat‬ﺑﻌﻼﻣﺔ اﻟﺠﻤﻊ ) ‪. ( +‬‬

‫ﻳﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻟﻴﻜﻮن ‪:‬‬
‫;‪Program CH6_Program7‬‬
‫‪Var‬‬
‫;‪Stn, st1, st2: string‬‬
‫‪Begin‬‬
‫;'‪St1:='Bag‬‬
‫;'‪St2:='hdad‬‬
‫;‪Stn: = st1 + st2‬‬
‫;)‪Writeln (stn‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪Baghdad‬‬

‫‪ 6.3.6‬ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪LENGTH‬‬
‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺤﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪N : = Length ( st‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪N‬‬
‫‪St‬‬

‫‪ :‬ﻳﻤﺜﻞ ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬
‫‪ :‬ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب أﻳﺠﺎد ﻃﻮﻟﻬﺎ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬
‫;‪Program CH6_Program8‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫;‪N: integer‬‬
‫‪Begin‬‬
‫;'‪St: ='Data Structure‬‬
‫;)‪N: =Length (st‬‬
‫;)‪Write (n‬‬
‫‪End.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪87‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪14‬‬

‫‪ 6.3.7‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ ‪UPCASE‬‬
‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟ ﺼﻐﻴﺮﻩ اﻟ ﻰ ﺣ ﺮوف آﺒﻴ ﺮﻩ ‪ ,‬ﺗﺤ ﻮل ﺣ ﺮف واﺣ ﺪ آ ﻞ‬
‫ﻣﺮﻩ ‪ .‬أﻣﺎ أذا آﺎﻧﺖ اﻟﺤﺮوف هﻲ أﺻﻼ آﺒﻴﺮﻩ أو آﺎﻧﺖ ﺧﺎرج ﻧﻄﺎق ﻣﻔﻬﻮم اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ ﻓ ﺴﺘﺘﺮك‬
‫ﻋﻠﻰ ﺣﺎﻟﻬﺎ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; )‪C : = UpCase (c‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪ : C‬اﻟﺤﺮف اﻟﻨﺎﺗﺞ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﻜﺒﻴﺮﻩ‪.‬‬
‫‪ : c‬اﻟﺤﺮف اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺣﺮف آﺒﻴﺮ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫;‪Program CH6_Program9‬‬
‫‪Var‬‬
‫;‪S: String‬‬
‫;‪i: Integer‬‬
‫‪Begin‬‬
‫;'?‪S: = 'Hey! How are you‬‬
‫‪For i: = 1 to length(S) do‬‬
‫;)]‪S[i]:= UpCase(S[i‬‬
‫;)‪Write(S‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫?‪HEY! HOW ARE YOU‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻟﺘﺤﻮﻳﻞ اﻷﺣﺮف اﻟﻜﺒﻴﺮﻩ اﻟﻰ أﺣﺮف ﺻﻐﻴﺮﻩ ﻧﺘﺒﻊ اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ ‪:‬‬
‫; ) ‪S[i] : = chr ( ord ( s[i] + 32‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪88‬‬

‫‪ 6.3.8‬ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪STR‬‬
‫ﺗﻌﻤﻞ ه ﺬﻩ اﻟﺪاﻟ ﻪ ﻋﻠ ﻰ ﺗﺤﻮﻳ ﻞ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﻓﻘ ﻂ اﻟ ﻰ ﺳﻼﺳ ﻞ ﺣﺮﻓﻴ ﻪ ‪ .‬أﻣ ﺎ أذا أﺳ ﺘﺨﺪﻣﻨﺎ‬
‫أرﻗﺎم آﺴﺮﻳﻪ ﻓﺴﺘﻌﻴﺪ ﻟﻨﺎ اﻟﺪاﻟﻪ اﻟﻘﻴﻤﻪ ﺻﻔﺮ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪STR ( NUM , ST‬‬
‫ﺣﻴﺚ أن ك‬
‫‪ : NUM‬ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ‪.‬‬
‫‪ : ST‬ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻨﺎﺗﺠﻪ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬
‫;‪Program CH6_Program10‬‬
‫‪Var‬‬
‫;‪X: integer‬‬
‫;‪St: string‬‬
‫‪Begin‬‬
‫;‪X: =2345‬‬
‫;)‪STR(x, st‬‬
‫;)‪Writeln(s‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫'‪'2345‬‬

‫‪ 6.3.9‬ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ‪VAL‬‬
‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ أﻳﺠﺎد اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ ﻟﻠﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘ ﻲ ﺗﺤﺘ ﻮي ﻋﻠ ﻰ أرﻗ ﺎم ﻓﻘ ﻂ ﻋﻠ ﻰ‬
‫ﺷﻜﻞ ﺣﺮﻓﻲ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ ‪:‬‬
‫; ) ‪VAL ( stn, number , Error‬‬
‫ﺣﻴﺚ أن ‪:‬‬
‫‪Stn‬‬
‫‪Number‬‬
‫‪Error‬‬

‫‪ :‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ‪.‬‬
‫‪ :‬ﻳﻤﺜﻞ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﺘﻮﺿﻊ ﻓﻴﻪ اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ اﻟﻤﺘﺤﻮﻟﻪ‪.‬‬
‫‪ :‬ﻣﺘﻐﻴﺮ ﻳﻌﻴﺪ ﻋﺪد ﺻﺤﻴﺢ ) ﻋﻨﺪﻣﺎ ﻳﺘﻢ اﻟﺘﺤﻮﻳﻞ دون أﺧﻄﺎء ﻓﺴﺘﻌﻴﺪ‬
‫اﻟﻘﻴﻤﻪ ) ‪ ( 0‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ﻋﺪم وﺟﻮد ﺧﻄﺄ ‪ ,‬أﻣﺎ أذا ﺣﺪث ﺧﻄﺄ ﻓﺴﺘﻌﻴﺪ‬
‫ﻋﺪد ﺻﺤﻴﺢ ﻳﺒﻴﻦ ﻣﻮﻗﻊ اﻟﺨﻄﺄ (‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪89‬‬
‫;‪Program CH6_Program11‬‬
‫‪Var‬‬
‫;‪St: string‬‬
‫;‪N, e: integer‬‬
‫‪Begin‬‬
‫;'‪St: ='1234‬‬
‫;)‪Val (st, n, e‬‬
‫;)‪Writeln (n,' ****** ', e‬‬
‫;'‪St: ='2345.12‬‬
‫;)‪Val (st, n, e‬‬
‫;)‪Writeln (n,' ^^^^^^ ', e‬‬
‫‪End.‬‬

‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪//:‬‬
‫‪1234 ****** 0‬‬
‫‪0 ^^^^^^ 5‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﺪاﻟﻪ ) ‪ ( val‬ﻻ ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﺴﻮر‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻳﻔﻀﻞ أن ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ﻋﻨﺪ اﻷﻋﻼن ﻋﻨﻬﺎ وذﻟﻚ ﻟﺘﺮﺷﻴﺪ ﻣﺴﺎ‬
‫ﺣﺔ اﻟﺬاآﺮﻩ اﻟﻤﺴﺘﺨﺪﻣﻪ ‪ ,‬وآﻤﺜﺎل ﻣﺎ ﻳﻠﻲ‬
‫; ]‪name : string [30‬‬
‫هﻨﺎ ﺣﺪدﻧﺎ اﻟﻤﻮاﻗﻊ اﻟﺘﻲ ﺗﺤﺠﺰ ﻓﻲ اﻟﺬاآﺮﻩ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( name‬ﺑﺤﺠﻢ ) ‪ ( 30‬ﺣﺮف‬
‫ﺑﺪﻻ ﻣﻦ ﺗﺮآﻬﺎ دون ﺗﺤﺪﻳﺪ وﺑﺎﻟﺘﺎﻟﻲ ﺗﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ ﺑﺤﺠﻢ ) ‪ ( 256‬ﻣﻮﻗﻊ )‬
‫ﻳﺮاﻋﻰ اﻟﺮﻗﻢ اﻟﺬي ﻧﺤﺪدﻩ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ واﻟﺤﺪ اﻻﻋﻠﻰ اﻟﺬي ﻧﺤﺘﺎج اﻟﻴﻪ ﻟﺘﻤﺜﻴﻞ‬
‫اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ( أﻣﺎ أذا آﺎن ﻣﻦ اﻟﺼﻌﺐ ﺗﺨﻤﻴﻦ اﻟﺤﺪ اﻷﻋﻠﻰ ﻓﻴﺘﺮك دون ﺗﺤﺪﻳﺪ‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪90‬‬

‫‪6.4‬‬

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬

‫•‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءﻩ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﻃﺒﻌﻬﺎ ﺑﺸﻜﻞ ﻣﻌﻜﻮس ) ﻣﺜﻼ أذا آﺎﻧﺖ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ‬
‫‪ ABCD‬ﺗﻄﺒﻊ ‪. ( DCBA‬‬

‫;‪Program CH6_Program12‬‬
‫‪Var‬‬
‫;‪S, st: string‬‬
‫;‪I: integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter string‬‬
‫;)‪Readln(s‬‬
‫;''= ‪St:‬‬
‫‪For i: =length(s) downto 1 do‬‬
‫;]‪St: = st + s[i‬‬
‫;)‪Writeln (st‬‬
‫‪End.‬‬
‫‪OR‬‬
‫}‪{instead of for loop above‬‬

‫•‬

‫‪For i: =1 to length(s) do‬‬
‫;‪St: =s[i] + st‬‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ وﺟﺪ ﻋﺪد اﻟﻤﺮات اﻟﺘﻲ ﻳﺘﻜﺮر ﻓﻴﻬﺎ اﻟﺤﺮف ) ‪. ( e‬‬

‫;‪Program CH6_Program13‬‬
‫‪Var‬‬
‫;‪S:string; k,n,i:integer‬‬
‫‪Begin‬‬
‫;)'‪Writeln ('Enter string‬‬
‫;)‪Readln(s‬‬
‫;‪K: =0‬‬
‫;)‪N: =length(s‬‬
‫‪For i: = 1 to n do‬‬
‫‪If(s[i] ='e') then‬‬
‫;‪K: =k+1‬‬
‫;)‪Writeln ('number of letter e =', k‬‬
‫‪End.‬‬

‫•‬

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻔﺼﻞ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ اﻟﻰ ﺛﻼث ﻣﺠﺎﻣﻴﻊ واﺣﺪﻩ ﻟﻠﺤﺮوف اﻟﻜﺒﻴ ﺮﻩ واﻟﺜﺎﻧﻴ ﻪ ﻟﻸرﻗ ﺎم‬
‫واﻟﺜﺎﻟﺜﻪ ﻟﻠﺤﺮوف اﻟﻤﺘﺒﻘﻴﻪ ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪.‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

91

Program CH6_Program14;
Var
S, s1, s2, s3: string;
I: integer;
Begin
Writeln ('Enter string');
Readln(s);
S1:='';
s2:='';
s3:='';
For i: = 1 to length(s) do
Case s[i] of
'A'..'Z': s1:=s1+s[i];
'0'..'9': s2:=s2+s[i]
Else s3:=s3+s[i];
End;
Writeln ('Capital letters are:', s1);
Writeln ('Digits are:' , s2);
Writeln ('Rest of string are:', s3);
End.

. ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﺣﺬف آﺎﻓﺔ اﻟﻔﺮاﻏﺎت اﻟﻤﻮﺟﻮدﻩ ﻓﻴﻬﺎ‬

Program CH6_Program15;
Var
S: string;
x: integer;
Begin
Writeln ('Enter string');
Readln(s);
X: =pos ('', x);
While(x<>0) do
Begin
Delete(s, x, 1);
X: =pos ('', s);
End;
Writeln(s);
End.

. ‫ ( ﻓﻲ اﻟﺴﻠﺴﻪ اﻟﺤﺮﻓﻴﻪ‬are ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ أﺣﺬف آﻞ اﻟﻜﻠﻤﺎت‬
Program CH6_Program16;
Var
S:string;
x:integer;
Begin
Writeln ('Enter string');
X: =pos ('are', s);
While(x<>0) do
Begin
Delete(s, x, 3);
X: =pos ('are', s);
End;
Writeln(s);
End.

Readln(s);

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

92

‫أآﺘ ﺐ ﺑﺮﻧ ﺎﻣﺞ ﻟﻘ ﺮاءة ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ ﺛ ﻢ ﺣ ﻮل ﺟﻤﻴ ﻊ اﻷﺣ ﺮف اﻟﻜﺒﻴ ﺮﻩ اﻟ ﻰ ﺣ ﺮوف ﺻ ﻐﻴﺮﻩ‬
. ‫وﺟﻤﻴﻊ اﻷﺣﺮف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ‬

Program CH6_Program17;
Var
S: string;
i: integer;
Begin
Writeln ('Enter string');
Readln(s);
For i: = 1 to length(s) do
Case s[i] of
'a'..'z': s[i]:=upcase(s[i]);
'A'..'Z': s[i]:=Chr (ord(s[i]) +32);
End;
Writeln(s);
End.

.(@@@ ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺛﻢ ﻏﻴﺮ آﻞ ﻓﺮاغ ﻓﻲ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻰ‬

Program CH6_Program 18;
Var
S:string;
N:integer;
Begin
Writeln ('Enter string');
Readln(s);
N:=pos('',s);
While(n<>0)do
begin
Delete(s, n, 1);
Insert ('@@@', s, n);
N: =pos ('', s);
Writeln(s);
End.

‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺗﺘﻜﻮن ﻣﻦ ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻜﻠﻤﺎت ﻳﻔﺼﻞ ﺑﻴﻦ واﺣﺪﻩ وأﺧ ﺮى‬
. ‫ اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺔ آﻞ آﻠﻤﻪ ﻋﻠﻰ ﺳﻄﺮ ﻣﻨﻔﺮد‬, ‫ﻓﺮاغ‬
Program CH_6Program19;
Var
Stn, st: string; x: integer;
Begin
Writeln ('Enter string');
Readln (stn);
X: =pos ('', stn);
While(x<>0) do
Begin
St: =copy (stn, 1, x-1);
Writeln (st);
Delete (stn, 1, x);
X: =pos ('', stn);
End;
Writeln (stn);
End.

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪93‬‬

‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ‬
‫ﻣﺘﻐﻴﺮات اﻷﻧﻮاع ‪VARIABLES TYPE‬‬
‫‪7.1‬‬

‫اﻟﻤﻘﺪﻣﻪ‬

‫ﺳ ﺒﻖ وأن أﻃﻠﻌﻨ ﺎ ﻋﻠ ﻰ اﻷﻧ ﻮاع اﻟﻘﻴﺎﺳ ﻴﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣﺜ ﻞ‬
‫)‪ , ( Integer , Real , Boolean , char …etc‬ﻣﻮاﺻ ﻔﺎت ه ﺬﻩ اﻷﻧ ﻮاع ﺗﺤ ﺪد ﺑ ﺸﻜﻞ آﺎﻣ ﻞ ﻣ ﻦ‬
‫ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ ﻋﻨﺪ ﺗﻨﻔﻴﺬ ﺑﺮاﻣﺞ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪.‬‬
‫ﻓﻲ هﺬا اﻟﻔ ﺼﻞ ﺳ ﻨﻘﺪم أﻧ ﻮاع أآﺜ ﺮ‪ ,‬ﺗﺤ ﺪد ﻣﻮاﺻ ﻔﺎﺗﻬﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ ‪ ,‬ﺳ ﻴﺘﻢ ﺗﻌﺮﻳ ﻒ أﻧ ﻮاع‬
‫ﻣﻨﺎﺳﺒﻪ ﻟﻜﻞ ﺑﺮﻧﺎﻣﺞ ﻣﻤﺎ ﻳﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻮﺿﻴﺢ اﻟﻤﺸﻜﻠﻪ وﻳﺴﻬﻞ ﻗﺮاءة وآﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫‪7.2‬‬

‫اﻷﻧﻮاع ‪TYPES‬‬

‫ﺗﺴﺘﺨﺪم آﻠﻤﺔ ﻧﻮع ) ‪ ( Type‬ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ أﻧﻮاع ﺟﺪﻳﺪﻩ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻷﺳﺘﺨﺪام اﻟﻨﻮع هﻲ ‪:‬‬
‫‪Type‬‬
‫; ‪Typename = new type‬‬
‫ﻟﺘﻮﺿﻴﺢ هﺬﻩ اﻟﺼﻴﻐﻪ ﻧﻔﺮض أن اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻧﻜﺘﺒﻪ ﻳﺤﺘﺎج اﻟﻰ ﻣﺼﻔﻮﻓﻪ ) ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻘ ﻴﻢ‬
‫ﻣﺘﻜﻮﻧ ﻪ ﻣ ﻦ ‪ 20‬ﻗﻴﻤ ﻪ ( ‪ ,‬وه ﺬا اﻟ ﻨﻤﻂ ﻣ ﻦ اﻟ ﺼﻔﻴﻔﻪ ﺳﻴ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﺮارا وﺗﻜ ﺮارا ‪ ,‬ﻓ ﻴﻤﻜﻦ‬
‫اﻷﻋﻼن أو اﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻧﻤﻂ ﺟﺪﻳﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Type‬‬
‫; ‪MyArray = array [ 1 .. 20 ] of byte‬‬
‫اﻷن ﻳﻤﻜﻦ أن ﻧﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧ ﻮع ) ‪ ( myarray‬ﺑ ﺪﻻ ﻣ ﻦ آﺘﺎﺑ ﺔ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫أﻋﻼﻩ ﻓﻲ آﻞ ﻣﺮﻩ ﻧﺤﺘﺎج اﻟﻰ ﻣﺜﻞ هﺬﻩ اﻟﻤﺼﻔﻮﻓﻪ ‪.‬‬
‫‪Var‬‬
‫; ‪X : myarray‬‬
‫اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺠﺪﻳﺪﻩ ﺳﻴﻜﻮن ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧ ﻮاع واﻟ ﺬي ﻳ ﺴﻤﻰ ) ‪, ( Type‬‬
‫وﻣﻮﻗﻊ هﺬا اﻟﻘﺴﻢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻜﻮن ﺑﻴﻦ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ وﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺬي ﻳﻈﻬﺮ ﻓﻲ ﺟﺴﻢ اﻷﺟﺮاءات هﻲ ﻣﺤﻠﻴﻪ ﻟﺘﻠﻚ اﻷﺟﺮاءات ‪.‬‬
‫أﻣﺎ ﺗﻠﻚ اﻟﺘﻲ ﺗﻈﻬﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻓﻬﻲ ﻋﺎﻣﻪ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪94‬‬

‫ﺑﺸﻜﻞ ﻋﺎم هﻨﺎك ﺛﻼث أﺻﻨﺎف ﻟﻸﻧﻮاع ‪:‬‬
‫‪ 7.2.1‬اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪SCALARS TYPE‬‬
‫اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ هﻲ ﺑﺒﺴﺎﻃﻪ ﻗﺎﺋﻤﻪ ﻣ ﻦ اﻟﻘ ﻴﻢ ‪ ,‬واﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أن ﺗﻔ ﺮض ﻟﻠﻤﺘﻐﻴ ﺮ ﻗﻴﻤ ﻪ ﻣ ﻦ‬
‫ذﻟﻚ اﻟﻨﻮع ‪ ,‬ﻓﻤﺜﻼ أن اﻟﻨﻮع اﻟﻘﻴﺎﺳﻲ ) ‪ ( integer‬ﻳﻤﺜﻞ ﻗﺎﺋﻤﻪ ﺑﺎﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ وﻋﻨﺪﻣﺎ ﻧﻌﺮف ﻣﺘﻐﻴ ﺮ‬
‫ﻣﻦ هﺬا اﻟﻨﻮع ﻓﺄﻧﻨﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﺴﻨﺪ ﻟﻠﻤﺘﻐﻴﺮ أي ﻗﻴﻤ ﻪ ﻣ ﻦ ﻗ ﻴﻢ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ﻓﻌﻨ ﺪﻣﺎ ﻧﻘ ﻮل أن‬
‫اﻟﻤﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع اﻟﻔﻼﻧﻲ ﻓﻬﺬا ﻳﻌﻨﻲ أن هﺬا اﻟﻤﺘﻐﻴﺮ ﺳﻴﺄﺧﺬ ﻗﻴﻤﻪ ﻣﺤﺪدﻩ ﺑﺬﻟﻚ اﻟﻨﻮع ( ‪ .‬ﻓﻤﺜﻼ‬
‫‪Type‬‬
‫; ) ‪Units = ( inches , feet , miles‬‬
‫ﻻﺣﻆ أن هﺬا اﻟﻨﻮع ﺣﺪد ﺑﺜﻼث وﺣﺪات ﻟﺬﻟﻚ ﻓﺄن اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﻴﻌﺮف ﻣﻦ هﺬا اﻟﻨﻮع ﺳ ﻮف ﻟ ﻦ ﻳﻜ ﻮن‬
‫ﺑﻤﻘﺪورﻩ أن ﻳﺤﻤﻞ ﻗﻴﻤﻪ ﻏﻴﺮ ﺗﻠﻚ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﺘﻌﺮﻳﻒ ) ﻣﻤﻜﻦ أن ﻳﺄﺧﺬ أي ﻗﻴﻤﻪ ﻣﻦ اﻟﻘ ﻴﻢ اﻟ ﺜﻼث اﻟﻤﺤ ﺪدﻩ‬
‫ﻓﻘﻂ ( ‪.‬‬
‫اﻷن ﺑﻌ ﺪ اﻷﻋ ﻼن ﻋ ﻦ ﻧ ﻮع ﺟﺪﻳ ﺪ ﻏﻴ ﺮ ﻣﻮﺟ ﻮد أﺻ ﻼ ﺿ ﻤﻦ اﻷﻧ ﻮاع اﻟﻘﻴﺎﺳ ﻴﻪ اﻟﻤﺤ ﺪدﻩ ﺑﻠﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ ,‬ﻓﺄﻧﻨﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮ ﻓﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ اﻟﻨ ﻮع (‬
‫) ‪ , units‬وآﻤ ﺎ ﻧﻌﻤ ﻞ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻟﻘﻴﺎﺳ ﻴﻪ ‪ ,‬وﺳ ﻴﻜﻮن ه ﺬا اﻟﻨ ﻮع ﻓﻌ ﺎﻻ ﺿ ﻤﻦ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻘ ﻂ‬
‫وﻟﻴﺲ اﻟﺒﺮاﻣﺞ اﻷﺧﺮى ‪ ,‬ﻓﺄذا ﻣﺎ آﺎﻧﺖ هﻨﺎك ﺣﺎﺟﻪ ﻷﺳﺘﺨﺪام هﺬا اﻟﻨﻮع ﻓﻲ ﺑﺮﻧﺎﻣﺞ أﺧﺮ ﻓﻴﺠﺐ أن ﻧﻌﻠ ﻦ‬
‫ﻋﻨﻪ ﺿﻤﻦ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺠﺪﻳﺪ ‪.‬‬
‫‪Var‬‬
‫; ‪X : units‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫اﻟﺘﻌﺮﻳﻔﺎن ) اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع واﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻣﻦ ذﻟﻚ اﻟﻨﻮع ( ﻣﻦ اﻟﻤﻤﻜﻦ‬
‫أن ﻳﺪﻣﺠﺎن ﻣﻌﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Var‬‬
‫; ) ‪Scale : ( inches , feet , miles‬‬
‫وﻟﻜﻦ ﻓﻲ ﻣﻌﻈﻢ اﻟﺤﺎﻻت ﻳﻔﻀﻞ أن ﻳﻔﺼﻞ ﺑﻴﻦ ﺗﻌﺮﻳﻒ اﻷﻧﻮاع وﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫أﻣﺜﻠﻪ ﻋﻦ اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪:‬‬
‫‪Type‬‬
‫‪Day = ( Monday, Tuesday, Wednesday, Thursday, Friday,‬‬
‫; ) ‪Saturday, Sunday‬‬
‫; ) ‪Operator = ( plus, minus, multiply, divide‬‬
‫; ) ‪Trigfunction = ( sine, cosine, tangent, secant, cosecant‬‬
‫هﻨﺎ ﺳﻨﻌﺮض ﻣﺘﻐﻴﺮات ﻣﻦ ﺗﻠﻚ اﻷﻧﻮاع‬
‫‪Var‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪95‬‬

‫; ‪Holiday, workday : day‬‬
‫; ‪Addingop, multop : operator‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻟﺴﻮء اﻟﺤﻆ ﻓﺄن ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﻻ ﺗﻮﻓﺮ أﻣﻜﺎﻧﻴﺔ ﻗﺮاءة وﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﻪ‬
‫ﻣﺒﺎﺷﺮﻩ ) اﻟﻤﺘﻐﻴﺮات ﻣﻦ هﺬا اﻟﻨﻮع ( ‪ .‬ﻣﺜﻼ‬
‫;‪Holiday := Friday‬‬
‫) ‪Write ( holiday‬‬
‫ﺳﻮف ﻻ ﻳﻄﺒﻊ ) ‪ , ( Friday‬ورﺑﻤﺎ ﻻﻧﺤﺼﻞ ﻋﻠﻰ أي ﻣﺨﺮﺟﺎت ﻷن اﻟﻤﺘﺮﺟﻢ ﺳﻴﺼﺪر‬
‫رﺳﺎﻟﺔ ﺧﻄﺄ ‪.‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻﺣﻆ أن ﻗﻴﻢ اﻷﻧﻮاع ﻋﺎدة ﺗﻜﻮن ﻣﺤﺪدﻩ ﺑﻴﻦ ﻗﻮﺳﻴﻦ ‪ ,‬وﻻ ﻳﺠﻮز أن ﺗﻜﻮن هﻨﺎك ﻗﻴﻤﻪ ﺗﻌﻮد‬
‫اﻟﻰ ﻧﻮﻋﻴﻦ ﻓﻲ ذات اﻟﺒﺮﻧﺎﻣﺞ ‪ ,‬ﻳﺠﺐ أن ﺗﺤﺪد ﻟﻨﻮع واﺣﺪ ‪ ,‬ﻓﻤﺜﻼ ﺗﻌﺮﻳﻒ اﻷﻧﻮاع اﻟﺘﺎﻟﻴﻪ‬
‫ﻏﻴﺮ ﻣﻘﺒﻮل ‪:‬‬
‫‪Type‬‬
‫;) ‪Fruit = ( apple, orange, lemon, pineapple, tomato‬‬
‫; ) ‪Vegetable = ( potato, carrot, tomato, onion‬‬
‫واﻟﺴﺒﺐ ﻷن اﻟﻌﻨﺼﺮ ) ‪ ( tomato‬ﻳﻈﻬﺮ ﻓﻲ اﻟﺘﻌﺮﻳﻔﻴﻦ ‪.‬‬

‫أن اﻟﻘﻴﻢ اﻟﻤﺪوﻧﻪ ﻓﻲ اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع اﻟﻌﺪدي ﺛﺎﺑﺘﻪ ﻟﺬﻟﻚ اﻟﻨﻮع ‪ ,‬ﻟﺬﻟﻚ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻜﺘﺐ‬
‫; ‪scale : = miles‬‬

‫; ‪Holiday : = Friday‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻﻳﺠﻮز أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ) أﺳﺘﺨﺪام اﻟﻤﺴﺎواة ( اﻟﻰ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع أﺧﺮ ‪.‬‬
‫ﻣﺜﻼ ‪:‬‬
‫; ‪Holiday := miles‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫•‬

‫‪96‬‬

‫أن اﻟﻌﻤﻠﻴ ﺎت اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ أﺳ ﺘﺨﺪاﻣﻬﺎ ﻣ ﻊ اﻟﻤﺘﻐﻴ ﺮات اﻟﻌﺪدﻳ ﻪ ه ﻲ اﻟﻌﻤﻠﻴ ﺎت اﻟﻌﻼﺋﻘﻴ ﻪ‬
‫) ‪ ( relational operators‬وﻃﺒﻌﺎ ﺳﺘﻜﻮن ﻧﺘﻴﺠﺔ هﺬا اﻟﺘﻌﺒﻴﺮ ه ﻲ ﻣ ﻦ اﻟﻨ ﻮع ) ‪( Boolean‬‬
‫أي ﺻﺢ أو ﺧﻄﺄ ‪ .‬ﻓﻤﺜﻼ‬
‫‪Monday < Friday‬‬
‫‪Multiply > divide‬‬

‫أن اﻟﻨﻮع ) ‪ ( Boolean‬هﻮ ﺑﺤﺪ ذاﺗﻪ ﻧﻮع ﻋﺪدي ‪ ,‬ﻓﻬﻮ ﻣﻌﺮف ﺿﻤﻨﻴﺎ آﻨﻮع ﻗﻴﺎﺳﻲ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Type‬‬
‫;) ‪Boolean = ( false , true‬‬
‫وﻃﺒﻌﺎ أذا ﻗﻠﻨﺎ‬
‫‪False < true‬‬
‫وهﻲ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ ‪.‬‬
‫•‬

‫اﻟ ﺪوال ) ‪ ( succ , pred‬ه ﻲ ﻣﻌﺮﻓ ﻪ ﻟﻸﻧ ﻮاع اﻟﻌﺪدﻳ ﻪ ) أي ﻳﻤﻜ ﻦ أﺳ ﺘﺨﺪاﻣﻬﺎ ﻣ ﻊ اﻷﻧ ﻮاع‬
‫اﻟﻌﺪدﻳﻪ ( ‪ ,‬واﻟﻘﻴﻤﻪ اﻟﻤﻌﺎدﻩ هﻲ ﻣﻦ ﻧﻔﺲ ﻧﻮع اﻟﻤﻌﺎﻣﻼت اﻟﻤﺴﺘﺨﺪﻣﻪ ‪ ,‬ﻣﺜﻼ‬
‫‪Succ ( Monday ) = Tuesday‬‬
‫ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أن أول ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ ) ‪ , ( pred‬وأﺧ ﺮ ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ‬
‫) ‪. ( succ‬‬

‫•‬

‫اﻟﺪاﻟﻪ ) ‪ ( ord‬ﻟﻬﺎ ﻣﻌﺎﻣﻼت ﻋﺪدﻳﻪ وﺗﻌﻴﺪ ﻗﻴﻤﺔ ﻋﺪد ﺻﺤﻴﺢ ‪ ,‬واﻟﺬي ه ﻮ اﻟﻌ ﺪد اﻟﺘﺮﺗﻴﺒ ﻲ ﻟﻠﻘﻴﻤ ﻪ‬
‫اﻟﻌﺪدﻳﻪ ﻓﻲ ﺗﻌﺮﻳﻒ اﻟﻘﺎﺋﻤﻪ ﺣﻴﺚ أن أول ﻗﻴﻤﻪ ﻓﻲ اﻟﻘﺎﺋﻤﻪ ﻟﻬﺎ اﻟﻌﺪد اﻟﺘﺮﺗﻴﺒﻲ ﺻﻔﺮواﻟﺬي ﻳﻠﻴ ﻪ ﻟ ﻪ‬
‫ﻋﺪد ﺗﺮﺗﻴﺒﻲ ﻗﻴﻤﺘﻪ واﺣﺪ وهﻜﺬا ‪ ..‬ﻣﺜﻼ‪ ..‬وﻣﻦ اﻷﻧﻮاع أﻋﻼﻩ ‪:‬‬
‫‪Ord ( plus ) = 0‬‬
‫‪Ord ( tuesdy ) = 1‬‬
‫‪Ord ( cosecant ) = 4‬‬

‫•‬

‫أﻳﻀﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام أﻣﺮ اﻟﺘﻜﺮار ) ‪ ( for‬ﺑﺎﻟﻬﻴﻜﻠﻴﻪ ‪:‬‬
‫‪For scale : = inches to miles do‬‬
‫; ‪Do something‬‬
‫هﻨﺎ ﻻ ﻳﻤﻜﻦ أﺳﺘﺨﺪام ) ‪ ( while‬ﻣﺜﻼ ‪:‬‬
‫; ‪Scale : = inches‬‬
‫‪While ( scale <= miles ) do‬‬
‫‪Begin‬‬
‫; ‪Do something‬‬
‫; ) ‪Scale: = succ ( scale‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪97‬‬

‫;‪End‬‬
‫ﺳﻴﻔﺸﻞ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ﺣﺴﺎب ) ) ‪. ( succ ( miles‬‬
‫‪ 7.2.2‬اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ‪SUBRANGE‬‬
‫هﺬا اﻟﻨﻮع ﻳﻌﺮف ﺑﺄﺳﻨﺎد ﺛﺎﺑﺘﻴﻦ ﻟﻠﻤﺘﻐﻴﺮ ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻨ ﻮع ‪ ,‬وه ﺬان اﻟﺜﺎﺑﺘ ﺎن ﻳﻤ ﺜﻼن‬
‫اﻟﺤ ﺪود اﻟ ﺪﻧﻴﺎ واﻟﺤ ﺪود اﻟﻌﻠﻴ ﺎ ﻟﻠﻤ ﺪى اﻟﺠﺰﺋ ﻲ ‪ ,‬وﻳﺠ ﺐ أن ﻳﺨﺘﻠﻔ ﺎن وﻳﻜﻮﻧ ﺎن ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع‬
‫‪.‬ﻣﺜﺎل ‪:‬‬
‫‪Type‬‬
‫; ‪Index = 1 .. 35‬‬
‫هﻨﺎ اﻟﺤﺪ اﻷدﻧﻰ ه ﻮ ) ‪ ( 1‬واﻟﺤ ﺪ اﻷﻋﻠ ﻰ ه ﻮ ) ‪ ( 35‬واﻷﺛﻨ ﺎن ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ‪.‬‬
‫واﻟﻤﺪى ﻳﻜﻮن ﺑﻴﻦ ) ‪ , ( 1 – 35‬ﻋﻠﻴﻪ ﻓﺄن اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﻳﻌ ﺮف ﻣ ﻦ ﻧ ﻮع ) ‪ ( index‬ﺳ ﻴﺄﺧﺬ‬
‫أي ﻗﻴﻤﻪ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﻤﺪى ) ‪ ( 1 – 35‬وﻟﻴﺲ ﻗﻴﻤﻪ ﺧﺎرج هﺬا اﻟﻤﺪى ‪.‬‬
‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻻ ﺗﺴﺘﺨﺪم اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ﻣﻊ هﺬا اﻟﻨﻮع ) أي ﻻ ﻳﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻷﻋﺪاد‬
‫اﻟﺤﻘﻴﻘﻴﻪ ﻓﻲ اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ( ‪.‬‬

‫•‬

‫اﻟﺘﻌﺮﻳﻔﺎن ) اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع واﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻣﻦ ذﻟﻚ اﻟﻨﻮع ( ﻣﻦ اﻟﻤﻤﻜﻦ ان ﻳ ﺪﻣﺠﺎن‬
‫ﻣﻌﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ ‪ ..‬ﻣﺜﺎل‬
‫‪Type‬‬
‫; ‪Index = 1 .. 35‬‬
‫; '‪Letter = 'a' .. 'z‬‬
‫; '‪Digit = '0' .. '9‬‬
‫‪Var‬‬
‫; ‪Count : index‬‬
‫; ‪Firstchar , lastchar : letter‬‬
‫هﺬان اﻟﺘﻌﺮﻳﻔﺎن ﻣﻦ اﻟﻤﻤﻜﻦ دﻣﺠﻬﻤﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ آﻤﺎ ﻳﻠﻲ ‪:‬‬
‫‪Var‬‬
‫; ‪Counter : 1 .. 35‬‬
‫; '‪Firstchar , lastchar : 'a' .. 'z‬‬
‫ﻟﻜﻦ ﻓﻲ ﻣﻌﻈﻢ اﻟﺤﺎﻻت ﻳﻔﻀﻞ اﻟﻤﺤﺎﻓﻈﻪ ﻋﻠﻰ ﺗﻌﺮﻳﻔﻴﻦ ﻣﻨﻔﺼﻠﻴﻦ ‪.‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪98‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫• اﻟﻤﻌﺎﻣﻼت ) ‪ ( operators‬اﻟﺘﻲ ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﺴﺘﺨﺪم ﻣﻊ ﻣﺘﻐﻴﺮ ﻟﻨﻮع‬
‫ﻣﻌﻴﻦ ‪ ,‬ﻣﻤﻜﻦ أﻳﻀﺎ أن ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺪى اﻟﺠﺰﺋﻲ ﻟﻬﺬا اﻟﻨﻮع ‪ .‬ﻣﺜﺎل ‪ ..‬أذا‬
‫آﺎن ‪:‬‬
‫‪Var‬‬
‫; ‪Index : 1 .. 10‬‬
‫; ‪Number : 1 .. 100‬‬
‫; ‪Result : integer‬‬
‫ﻓﺄن هﺬﻩ اﻟﻌﺒﺎرﻩ هﻲ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ ‪:‬‬
‫‪Result + number div index‬‬
‫• ﻣﺘﻐﻴﺮات اﻟﻤﺪى اﻟﺠﺰﺋﻲ ﻣﻤﻜﻦ أﻳﻀﺎ أﺳﺘﺨﺪاﻣﻬﺎ ﻋﻠﻰ آﻼ ﺟﺎﻧﺒﻲ اﻟﻤﺴﺎواة ‪.‬‬
‫ﻣﺜﺎل‬
‫; ‪index : = number‬‬
‫; ‪result : = index‬‬

‫‪ 7.2.3‬اﻟﻤﺠﻤﻮﻋﺎت ‪SETS‬‬
‫اﻟﻤﺠﻤﻮﻋﻪ هﻲ ﺗﺠﻤﻴﻊ ﻷﺷﻴﺎء ﻣﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع ‪ ,‬ﻓ ﺄذا آﺎﻧ ﺖ ) ‪ ( S‬ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﺷ ﻴﺎء ﻣ ﻦ ﻧ ﻮع ) ‪( t‬‬
‫ﻓﺄن أي ﻣﻜﻮن أو أي ﺷﻲء ﻣﻦ اﻟﻨﻮع ) ‪ ( t‬أﻣﺎ أن ﻳﻜ ﻮن ﻋ ﻀﻮ ) ﻋﻨ ﺼﺮ ( ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ ) ‪ ( S‬أو ﻻ‬
‫ﻳﻜﻮن ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ ) ‪. ( S‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻧﻌﺮف ﻧﻮع اﻟﻤﺠﻤﻮﻋﻪ وﻓﻘﺎ ﻷي ﻧﻮع ﻋﺪدي ) أن ﻧﻮع اﻟﻘﻴﻢ ﻓﻲ اﻟﻤﺠﻤﻮﻋ ﻪ ه ﻲ ﻣﺠ ﺎﻣﻴﻊ‬
‫ﻣﻦ اﻟﻨﻮع اﻟﻌﺪدي ( ‪ .‬ﻣﺜﺎل‬
‫‪Type‬‬
‫‪Ingredients = ( apple , orange , bananas , strawberries , nuts ,‬‬
‫; ) ‪icecream , cream , pastry , sugar , ice‬‬
‫ﺗﻌﺮﻳﻒ اﻟﻤﺠﻤﻮﻋﻪ ﻳﻜﻮن ‪:‬‬
‫‪Type‬‬
‫;‪Desert = set of ingredients‬‬
‫أﻣﺎ اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع ) ‪ ( desert‬ﻓﻴﻌﻠﻦ ﻋﻨﻬﺎ ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ‪:‬‬
‫‪Var‬‬
‫; ‪Feast , x : desert‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫‪99‬‬

‫اﻟﻘ ﻴﻢ اﻟﺜﺎﺑﺘ ﻪ أو اﻟﻤﺘﻐﻴ ﺮﻩ ﻣ ﻦ اﻟﻨ ﻮع ) ‪ ( desert‬ه ﻲ ﻣﺠﻤﻮﻋ ﻪ ﺟﺰﺋﻴ ﻪ ﻣ ﻦ اﻟﻨ ﻮع ) ‪( ingredients‬‬
‫واﻟﺘﻲ ﺗﻌﺘﺒﺮ اﻟﻨﻮع اﻷﺳﺎس ﻟﻠﻨﻮع ) ‪. ( desert‬‬
‫ﺗﻤﺜ ﻞ اﻟﻤﺠﻤﻮﻋ ﻪ ﺑﻘﺎﺋﻤ ﻪ ﻣ ﻦ اﻟﻌﻨﺎﺻ ﺮ اﻟﻤﻌﺮﻓ ﻪ ﺿ ﻤﻦ اﻟﻤﺠﻤﻮﻋ ﻪ ‪ ,‬ﺗﻔ ﺼﻞ ﻓ ﺎرزﻩ ﺑ ﻴﻦ ﻋﻨ ﺼﺮ وأﺧ ﺮ ‪,‬‬
‫وﺟﻤﻴﻊ هﺬﻩ اﻟﻌﻨﺎﺻﺮ ﻣﺤﺪدﻩ ﺑﻘﻮﺳﻴﻦ ﻣﺮﺑﻌﻴﻦ ‪ .‬ﻣﺜﺎل‬
‫] ‪[ icecream , cream‬‬
‫] ‪[ apple , bananas , icecream‬‬
‫] ‪[ orange‬‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫أذا آﺎﻧﺖ ﻋﻨﺎﺻﺮ ﻣﺠﻤﻮﻋﻪ ﻣﻌﻴﻨﻪ ﻣﺘﻌﺎﻗﺒﻪ ﻓﻴﻤﻜﻦ ﺗﺤﺪﻳﺪ اﻟﻌﻨﺼﺮ اﻷول‬
‫واﻷﺧﻴﺮ ﻓﻘﻂ آﻤﺪى ﺟﺰﺋﻲ ‪ .‬ﻣﺜﺎل‬
‫] ‪[ apple , orange , bananas , strawberries‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﺗﻜﺘﺐ ‪:‬‬
‫] ‪[ apple .. strawberries‬‬

‫ﺻﻔﺎت اﻟﻤﺠﻤﻮﻋﺎت‬
‫•‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ أن ﻻ ﺗﺤﺘﻮي اﻟﻤﺠﻤﻮﻋ ﻪ ﻋﻠ ﻰ أي ﻋﻨ ﺼﺮ ﻋﻨ ﺪهﺎ ﺗ ﺴﻤﻰ ﻣﺠﻤﻮﻋ ﻪ ﺧﺎﻟﻴ ﻪ ‪ ,‬وﻳﺮﻣ ﺰ‬
‫ﻟﻠﻤﺠﻤﻮﻋﻪ اﻟﺨﺎﻟﻴﻪ ﺑﺎﻟﺮﻣﺰ ] [ ‪.‬‬

‫•‬

‫أﺗﺤ ﺎد ) ‪ ( union‬أﺛﻨ ﺎن ﻣ ﻦ اﻟﻤﺠ ﺎﻣﻴﻊ ﻳﻨ ﺘﺞ ﻋﻨﻬﻤ ﺎ ﻣﺠﻤﻮﻋ ﻪ واﺣ ﺪﻩ ﺗﺤﺘ ﻮي ﻋﻨﺎﺻ ﺮ‬
‫اﻟﻤﺠﻤﻮﻋﺘﻴﻦ ‪ .‬ﻋﺎﻣﻞ اﻷﺗﺤﺎد هﻮ ) ‪ . ( +‬ﻣﺜﺎل‬
‫]‪[ apple ] + [ bananas , sugar ] = [ apple , bananas , sugar‬‬

‫•‬

‫ﺗﻘﺎﻃﻊ ) ‪ ( intersection‬أﺛﻨﺎن ﻣﻦ اﻟﻤﺠﺎﻣﻴﻊ ﻳﻨﺘﺞ ﻋﻨﻪ ﻣﺠﻤﻮﻋﻪ واﺣﺪﻩ ﺗﺤﺘﻮي ﻓﻘ ﻂ اﻟﻌﻨﺎﺻ ﺮ‬
‫اﻟﻤ ﺸﺘﺮآﻪ ﺑ ﻴﻦ اﻟﻤﺠﻤ ﻮﻋﺘﻴﻦ ) أي اﻟﻌﻨﺎﺻ ﺮ اﻟﻤﻮﺟ ﻮدﻩ ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ اﻷوﻟ ﻰ وﺑ ﺬات اﻟﻮﻗ ﺖ‬
‫ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻟﺜﺎﻧﻴﻪ ( ‪ .‬ﻋﺎﻣﻞ اﻟﺘﻘﺎﻃﻊ هﻮ ) * ( ‪ .‬ﻣﺜﺎل‬
‫] ‪[ Orange , icecream , cream ] * [ icecream , nuts ] = [ icecream‬‬

‫•‬

‫اﻟﻔﺮق ﺑﻴﻦ أﺛﻨﺎن ﻣﻦ اﻟﻤﺠﺎﻣﻴﻊ ﻳﻨﺘﺞ ﻋﻨﻪ ﻣﺠﻤﻮﻋﻪ واﺣ ﺪﻩ ﻓﻘ ﻂ ﺗﺤﺘ ﻮي ﻋﻠ ﻰ آ ﻞ اﻟﻌﻨﺎﺻ ﺮ اﻟﺘ ﻲ‬
‫ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ وﻟﻜﻨﻬﺎ ﻟﻴ ﺴﺖ ﻋﻨﺎﺻ ﺮ ﻓ ﻲ اﻟﻤﺠﻤﻮﻋ ﻪ اﻟﺜﺎﻧﻴ ﻪ ‪ .‬ﻋﺎﻣ ﻞ اﻟﻔ ﺮق ه ﻮ ) ‪. ( -‬‬
‫ﻣﺜﺎل‬
‫‪[ apple , strawberries , bananas ] – [ strawberries , cream ] = [ apple ,‬‬
‫] ‪bananas‬‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫•‬

‫‪100‬‬

‫اﻟﺮﻣ ﺰ ) ‪ ( IN‬ه ﻲ ﻣ ﻦ اﻟﻜﻠﻤ ﺎت اﻟﻤﺤﺠ ﻮزﻩ ﺗ ﺴﺘﺨﺪم هﻨ ﺎ ﻷﺧﺘﺒﺎرأﻧﺘﻤ ﺎء ﻋﻨ ﺼﺮ ﻟﻤﺠﻤﻮﻋ ﻪ ‪,‬‬
‫وﻃﺒﻌﺎ ﻧﺘﻴﺠﻪ ذﻟﻚ هﻮ ﻋﺒﺎرﻩ ﻣﻨﻄﻘﻴﻪ ) ﺻﺢ أو ﺧﻄﺄ ( ‪ ,‬ﻣﺜﺎل اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ‬
‫] ‪Apple in [ apple , orange , icecream‬‬
‫ﺑﻴﻨﻤﺎ اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ هﻲ ﻋﺒﺎرﻩ ﺧﺎﻃﺌﻪ‬
‫] ‪Apple in [ orange , bananas , icecream , cream‬‬

‫•‬

‫ﺗ ﺴﺘﺨﺪم اﻟﻌﻮاﻣ ﻞ اﻟﻌﻼﺋﻘﻴ ﻪ ﻟﻠﻤﻘﺎرﻧ ﻪ ﺑ ﻴﻦ اﻟﻤﺠ ﺎﻣﻴﻊ ‪ ,‬واﻟﻤﺒﻴﻨ ﻪ ﺑﺎﻟﺠ ﺪول ) ‪ .. ( 7.1‬أﻣﺜﻠ ﻪ ﻋﻠ ﻰ‬
‫ذﻟﻚ ‪:‬‬
‫] ‪[ Orange , cream ] = [ cream , orange‬‬
‫] ‪[ icecream ] ≠ [ ice , cream‬‬
‫] ‪[strawberries ] <= [ strawberries , cream‬‬
‫] ‪[ apple .. ice ] > = [ icecream .. cream‬‬

‫•‬

‫ﻋﺒﺎرة اﻟﻤﺴﺎواة رﺑﻤﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ ﻣﺘﻐﻴﺮات اﻟﻤﺠﺎﻣﻴﻊ وﺗﻌﺎﺑﻴﺮ اﻟﻤﺠﻤﻮﻋﻪ ‪ ..‬ﻣﺜﺎل‬
‫; ] ‪X : = [ apple , cream , sugar‬‬
‫; ] ‪Feast : = x + [ icecream‬‬

‫ﺟ ﺪول ) ‪ : ( 7.1‬ﻣﻘﺎرﻧ ﺔ اﻟﻌﻤﻠﻴ ﺎت اﻟﻌﻼﺋﻘﻴ ﻪ اﻟﻤ ﺴﺘﺨﺪﻣﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻊ ﻣ ﺎ ﻳﻘﺎﺑﻠﻬ ﺎ ﻓ ﻲ‬
‫اﻟﺮﻳﺎﺿﻴﺎت‬
‫اﻟﻤﻌﻨﻰ‬
‫اﻟﻤﺠﻤﻮﻋﻪ ) ‪( set‬‬
‫اﻷﺗﺤﺎد ) ‪( union‬‬
‫اﻟﺘﻘﺎﻃﻊ ) ‪( intersection‬‬
‫ﺗﺤﺘﻮي ) ‪( contains‬‬
‫ﻣﺤﺘ ﻮاة ﺑﺎﻟﻤﺠﻤﻮﻋ ﻪ ) ‪( contained by‬‬
‫) ﻣﺠﻤﻮﻋﻪ ﺟﺰﺋﻴﻪ ﻣﻦ (‬
‫ﺗﻌﻮد اﻟﻰ ) ‪( inclusion‬‬
‫ﻣﺠﻤﻮﻋﻪ ﺧﺎﻟﻴﻪ ) ‪( empty set‬‬

‫اﻟﺮﻣﺰ اﻟﻤﺴﺘﺨﺪم ﻓﻲ‬
‫اﻟﺮﻳﺎﺿﻴﺎت‬
‫}…{‬
‫‪U‬‬
‫∩‬
‫≤‬
‫≥‬

‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
‫]…[‬
‫‪+‬‬
‫*‬
‫≤‬
‫≥‬

‫‪є‬‬
‫‪Ø‬‬

‫‪IN‬‬
‫][‬

‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ‪ /‬ﺗﺄﻟﻴﻒ د‪ .‬ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

‫ﻣﻼﺣﻈﻪ ‪//:‬‬
‫ﻋﻨﺪ أﺳﺘﺨﺪام اﻟﻌﻼﻣﻪ ) ≤ أو ≥ ( ﻓﺄن ﻓﺘﺤﺔ هﺬﻩ اﻟﻌﻼﻣﻪ داﺋﻤﺎ ﺗﺸﻴﺮ اﻟﻰ اﻟﻤﺠﻤﻮﻋﻪ اﻷآﺒﺮ ‪.‬‬

‫‪101‬‬

‫ ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬.‫ ﺗﺄﻟﻴﻒ د‬/ ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

102

‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ‬
: ‫ ( ﺛﻢ أوﺟﺪ ﻣﺎﻳﻠﻲ‬0 .. 255 ) ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻜﻮﻳﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ ذات أﻋﺪاد‬
‫ أﻃﺒﻊ اﻟﻤﺠﻤﻮﻋﺘﻴﻦ‬.1
‫ ﺟﺪ أﺗﺤﺎد اﻟﻤﺠﻤﻮﻋﺘﻴﻦ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.2
‫ ﺟﺪ ﺗﻘﺎﻃﻊ اﻟﻤﺠﻤﻮﻋﺘﻴﻦ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.3
‫ ﺟﺪ ﻣﺘﻤﻤﻪ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ واﻟﺜﺎﻧﻴﻪ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬.4
‫ ﺟﺪ اﻟﻌﻨﺎﺻﺮ اﻟﻤﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ اﻷوﻟﻰ وﻏﻴﺮ ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺠﻤﻮﻋﻪ‬.5
.‫اﻟﺜﺎﻧﻴﻪ وأﻃﺒﻊ اﻟﻨﺘﻴﺠﻪ‬

Program CH7_Program1;
Type
Number=set of 0..255;
Var
U, t1, t2, t3, t4, t5, t6, t7: number;
Procedure readset (var s1: number);
Var
I, x: integer;
Begin
S1:= [];
For i: =1 to 10 do
Begin
Writeln ('Enter number 0..255');
Readln(x);
S1:=s1+[x];
End;
End;
Procedure writeset (s1: number);
Var
I: integer;
Begin
Write ('{');
For i: = 0 to 255 do
If (I) IN (s1) then
write (i: 4);
Write ('}');
End;
Begin
Readset (t1);
Readset (t2);
Writeset (t1);
Writeset (t2);
T3:=t1+t2;
{union}
Writeset (t3);
T4:=t1*t2;
{intersection}
Writeset (t4);
U:=[0..255];
T5:=u-t1;
Writeset(t5);
T6:=u-t2;
Writeset (t6);
T7:=t1-t2;
Writeset (t7);
End.

7.3

Sign up to vote on this title
UsefulNot useful