Docstoc

أساسيات برمجة لغة باسكال

Document Sample
أساسيات برمجة لغة باسكال Powered By Docstoc
					              ‫ﺻﺪﻗﺔ ﺟﺎرﻳﻪ ..‬

     ‫اﻟﻰ روح أﺑﻲ ..‬

‫ﻓﻲ ﻋﻠﻴﻴﻦ...‬
                                      ‫اﻟﻤﻘﺪﻣﻪ‬


‫ﺑﺴﻢ اﷲ اﻟﺮﺣﻤﻦ اﻟﺮﺣﻴﻢ واﻟﺼﻼة واﻟ ﺴﻼم ﻋﻠ ﻰ ﺳ ﻴﺪﻧﺎ ﻣﺤﻤ ﺪ أﺷ ﺮف اﻟﺨﻠ ﻖ وﺧ ﺎﺗﻢ اﻟﻨﺒ ﻴﻦ‬
                                                     ‫وﻋﻠﻰ أل ﺑﻴﺘﻪ وﺻﺤﺒﻪ اﻟﻄﻴﺒﻴﻦ اﻟﻄﺎهﺮﻳﻦ.‬

‫أﻣﺎ ﺑﻌﺪ , ﻓﻬﺎ أﻧﺬا أﺿﻊ ﺑﻴﻦ ﻳﺪي اﻟﻘﺎريء اﻟﻌﺮﺑﻲ ﻧﺘﺎج ﺟﻬﺪ ﺑ ﻀﻌﺔ أﺷ ﻬﺮ ﻣ ﻦ اﻟﻌﻤ ﻞ اﻟﺠ ﺎد‬
‫واﻟﺪؤوب ﻟﻴﻜﻮن هﺬا اﻟﻜﺘﺎب ﺷﺒﻪ آﺎﻣﻞ ) ﻷن اﻟﻜﻤﺎل ﷲ وﺣﺪﻩ ( ﻟﻤﺒ ﺎديء وأﺳﺎﺳ ﻴﺎت اﻟﺒﺮﻣﺠ ﻪ ﺑﻠﻐ ﺔ‬
                                                                          ‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل .‬

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

‫ﻳﺒ ﺪأ اﻟﻜﺘ ﺎب ﺑ ﺸﺮح اﻟﻤﻔ ﺎهﻴﻢ اﻷﺳﺎﺳ ﻴﻪ اﻟﻌﺎﻣ ﻪ ﻟﻠﺒﺮﻣﺠ ﻪ واﻟﺘ ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل , وه ﻲ ﺑ ﺸﻜﻞ ﻋ ﺎم ﻣ ﺸﺘﺮآﻪ ﺑ ﻴﻦ اﻟﻜﺜﻴ ﺮ ﻣ ﻦ ﻟﻐ ﺎت اﻟﺒﺮﻣﺠ ﻪ , أﻣ ﺎ اﻟﻔ ﺼﻞ اﻟﺜ ﺎﻧﻲ ﻓﻴﺘ ﻀﻤﻦ‬
‫ﺷﺮﺣﺎ واﻓﻴﺎ ﻷواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ ﺑﺸﻜﻞ آﻔﻮء , ﺑﻴﻨﻤﺎ آ ﺮس اﻟﻔ ﺼﻞ اﻟﺜﺎﻟ ﺚ‬
‫ﻟﻌﺒﺎرات اﻟﻘﺮار واﻟﺘﻜﺮار واﻟﺘ ﻲ ﺗﻌ ﺪ أﺣ ﺪى اﻟﺮآ ﺎﺋﺰ اﻟﻤﻬﻤ ﻪ ﻓ ﻲ اﻟﺒﺮﻣﺠ ﻪ , وﺗﻨ ﺎول اﻟﻔ ﺼﻞ اﻟﺮاﺑ ﻊ‬
‫اﻟﻤ ﺼﻔﻮﻓﺎت ﺑﻨﻮﻋﻴﻬ ﺎ اﻷﺣﺎدﻳ ﻪ واﻟﺜﻨﺎﺋﻴ ﻪ , ﺑﻴﻨﻤ ﺎ ﺗﻄ ﺮق اﻟﻔ ﺼﻞ اﻟﺨ ﺎﻣﺲ اﻟ ﻰ اﻷﺟ ﺮاءات واﻟ ﺪوال‬
‫وآﻴﻔﻴﺔ أﺳﺘﺨﺪاﻣﻬﺎ , اﻟﻔﺼﻞ اﻟﺴﺎدس ﻳﺸﺮح ﺑﺘﻮﺳﻊ ﻧﺴﺒﻲ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﻪ ﻣﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ,‬
                                                      ‫وأﺧﻴﺮا ﺗﻢ اﻟﺨﺘﺎم ﻣﻊ اﻷﻧﻮاع واﻟﻤﺠﻤﻮﻋﺎت .‬

‫ﻟﻘﺪ ﺣﺎوﻟﺖ ﺟﺎهﺪا أن أﺑﺴﻂ اﻟﻤﻮاﺿﻴﻊ اﻟﺘﻲ ﺗﻄﺮﻗﺖ ﻟﻬﺎ ﺑﺸﻜﻞ آﺒﻴﺮ وأﺳﻬﺒﺖ ﺑﻌﺾ اﻟ ﺸﻲء‬
‫ﻓ ﻲ ﺷ ﺮﺣﻬﺎ ﻷﺳ ﻬﻞ ﻋﻠ ﻰ اﻟﻘ ﺎريء اﻟﺘﻮاﺻ ﻞ ﻣ ﻊ ﻣﻮاﺿ ﻴﻊ اﻟﻜﺘ ﺎب وه ﻲ ﺟﻤﻴﻌ ﺎ ﻧﺘ ﺎج ﺧﺒﺮﺗ ﻲ ﻓ ﻲ‬
‫ﺗﺪرﻳﺲ هﺬﻩ اﻟﻤﺎدﻩ ﻟﻌﺪد ﻣﻦ اﻟﺴﻨﻮات , وأرى أن هﺬا اﻟﻜﺘﺎب ﻣﻤﻜﻦ أن ﻳﻜﻮن ﻣﺮﺟﻌﺎ ﺟﻴﺪا ﻟﻠﻤﺒﺘ ﺪﺋﻴﻦ‬
‫ﻓﻲ اﻟﺒﺮﻣﺠﻪ وآﺬﻟﻚ ﻷﺻﺤﺎب اﻟﺨﺒﺮﻩ , وهﻮ ﻣﻤﻜﻦ أن ﻳﻮﻓﺮ اﻷﺳﺎس اﻟﺠﻴ ﺪ ﻟﻤ ﻦ ﻳﺮﻏ ﺐ ﺗﻌﻠ ﻢ ﻟﻐ ﺎت‬
                                                                           ‫ﺑﺮﻣﺠﻪ أﺧﺮى .‬

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


        ‫د. ﻧﻀﺎل اﻟﻌﺒﺎدي‬
         ‫ﺑﻐﺪاد / 6002‬
                               ‫اﻟﻤﺤﺘﻮﻳﺎت‬

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

 ‫1‬   ‫1.1 اﻟﻤﻘﺪﻣﻪ ..........................................................................‬
 ‫1‬    ‫2.1 ﺑﻌﺾ اﻟﺼﻔﺎت اﻟﻌﺎﻣﻪ ﻟﻠﺒﺮﻧﺎﻣﺞ .............................................‬
‫2‬    ‫3.1 اﻟﻤﻌﺮﻓﺎت .......................................................................‬
 ‫3‬    ‫4.1 اﻟﺜﻮاﺑﺖ .........................................................................‬
 ‫4‬    ‫5.1 اﻟﺒﻴﺎﻧﺎت .........................................................................‬
 ‫4‬    ‫1.5.1 اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ....................................................‬
 ‫5‬   ‫2.5.1 اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ .......................................................‬
 ‫7‬    ‫3.5.1 اﻟﺮﻣﻮز .................................................................‬
 ‫9‬    ‫4.5.1 اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ .....................................................‬
 ‫9‬    ‫6.1 اﻟﺘﻌﺎﺑﻴﺮ اﻟﻤﻨﻄﻘﻴﻪ ..............................................................‬
 ‫9‬   ‫1.6.1 اﻟﻌﻤﻠﻴﺎت اﻟﻤﻨﻄﻘﻴﻪ .....................................................‬
‫31‬   ‫7.1 ﺗﻮﻟﻴﺪ اﻷرﻗﺎم اﻟﻌﺸﻮاﺋﻲ .......................................................‬

                                                 ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ – أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج‬

‫51‬   ‫اﻟﻤﻘﺪﻣﻪ .........................................................................‬   ‫1.2‬
‫51‬   ‫هﻴﻜﻠﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ ...............................................................‬     ‫2.2‬
‫61‬   ‫اﻟﻤﺨﺮﺟﺎت واﻟﻤﺪﺧﻼت ......................................................‬            ‫3.2‬
‫42‬    ‫ﻣﺘﻐﻴﺮات اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ .................................................‬           ‫4.2‬
‫62‬   ‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ..................................‬               ‫5.2‬
‫03‬    ‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ..................................................................‬    ‫6.2‬

                                                 ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ – أﻳﻌﺎزات اﻟﻘﺮار واﻟﺘﻜﺮار‬

‫23‬    ‫1.3 اﻟﻤﻘﺪﻣﻪ .........................................................................‬
‫23‬   ‫2.3 ﻋﺒﺎرة أذا .......................................................................‬
‫53‬   ‫3.3 أذا اﻟﻤﺮآﺒﻪ ....................................................................‬
‫63‬   ‫4.3 ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................... Repeat – Until‬‬
‫73‬    ‫5.3 ﻋﺒﺎرة اﻟﺘﻜﺮار ‪............................................ While – Do‬‬
‫04‬    ‫6.3 ﻋﺒﺎرة اﻟﺘﻜﺮار ‪......................................................... For‬‬
‫14‬   ‫7.3 أﺳﺘﺨﺪام ‪ For‬اﻟﻤﺘﺪاﺧﻠﻪ ....................................................‬
‫34‬    ‫8.3 ﻋﺒﺎرة أﺧﺘﻴﺎر اﻟﺤﺎﻟﻪ ‪................................................. Case‬‬
‫74‬     ‫9.3 ﺟﻤﻠﺔ ‪..................................................................... IN‬‬
‫84‬    ‫01.3 أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ .................................................................‬
                                                                  ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ – اﻟﻤﺼﻔﻮﻓﺎت‬

‫35‬     ‫1.4 اﻟﻤﻘﺪﻣﻪ .........................................................................‬
‫35‬     ‫2.4 اﻟﻤﺼﻔﻮﻓﺎت ...................................................................‬
‫35‬    ‫1.2.4 اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ...................................................‬
‫85‬      ‫2.2.4 اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ....................................................‬
‫16‬    ‫3.4 أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ...................................................................‬



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

‫66‬     ‫اﻟﻤﻘﺪﻣﻪ .........................................................................‬   ‫1.5‬
‫66‬     ‫اﻷﺟﺮاءات ....................................................................‬       ‫2.5‬
‫57‬     ‫اﻟﺪوال ..........................................................................‬   ‫3.5‬
‫77‬    ‫أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ...................................................................‬     ‫4.5‬

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

‫1.6 اﻟﻤﻘﺪﻣﻪ ......................................................................... 08‬
‫2.6 ﻣﺎهﻲ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ...................................................... 08‬
‫3.6 اﻟﻌﻤﻠﻴﺎت اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ............................. 18‬
‫1.3.6 ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ .......................................................... 18‬
‫2.3.6 اﻷﺳﺘﻨﺴﺎخ ............................................................. 28‬
‫3.3.6 اﻟﺤﺬف ................................................................. 38‬
‫4.3.6 اﻟﺤﺸﺮ ................................................................. 48‬
‫5.3.6 دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن .............................................. 58‬
‫6.3.6 ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ...................................... 68‬
‫7.3.6 ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ .................... 78‬
‫8.3.6 ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ............................ 88‬
‫9.3.6 ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ................................ 88‬
‫4.6 أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ .................................................................. 09‬

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

 ‫39‬    ‫1.7 اﻟﻤﻘﺪﻣﻪ .........................................................................‬
 ‫39‬    ‫2.7 اﻷﻧﻮاع .........................................................................‬
 ‫49‬    ‫1.2.7 اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ .......................................................‬
 ‫79‬    ‫2.2.7 اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ......................................................‬
 ‫89‬   ‫3.2.7 اﻟﻤﺠﻤﻮﻋﺎت ...........................................................‬
‫201‬   ‫3.7 أﻣﺜﻠﻪ ﻣﺤﻠﻮﻟﻪ ...................................................................‬
‫1‬                                                      ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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


                                                                                               ‫اﻟﻤﻘﺪﻣﻪ‬           ‫1.1‬


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

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

‫• ﻳﺤﺘﺎج اﻟﺒﺮﻧﺎﻣﺞ ﺑ ﺼﻮرﻩ ﻋﺎﻣ ﻪ اﻟ ﻰ ﻣ ﻦ ﻳﻜﺘﺒ ﻪ وه ﻮ اﻟﻤﺒ ﺮﻣﺞ ) ‪ , ( Programmer‬واﻟ ﻰ‬
‫اﻟﻤﻌ ﺎﻟﺞ ) ‪ ( Processor‬ﻟﺘﻔ ﺴﻴﺮ وﺗﻨﻔﻴ ﺬ ) ‪ ( Execution OR Running‬اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ‬
‫) ‪ , ( Instructions OR Commands‬وﺗﺴﻤﻰ ﻋﻤﻠﻴﺔ ﺗﻨﻔﻴﺬ آﺎﻣﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻤﻌﺎﻟﺠﻪ ) ‪( Process‬‬

‫• أن ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻳ ﺘﻢ ﺑ ﺼﻮرﻩ ﻣﺘﺘﺎﻟﻴ ﻪ ) أي أﻳﻌ ﺎز ) ‪ ( instruction‬ﺑﻌ ﺪ اﻷﺧ ﺮ ﺣ ﺴﺐ‬
‫ﺗﺴﻠ ﺴﻠﻬﺎ (, ﻣ ﺎﻟﻢ ﻳ ﺘﻢ اﻷﺧﺒ ﺎر ﺧﺎرﺟﻴ ﺎ ﻋ ﻦ ﻏﻴ ﺮ ذﻟ ﻚ. ه ﺬا ﻳﻌﻨ ﻲ أن ﻧﺒ ﺪأ ﺑ ﺄول أﻳﻌ ﺎز وﻳﻨﻔ ﺬ ﺛ ﻢ اﻟﺜ ﺎﻧﻲ‬
‫واﻟﺜﺎﻟﺚ وهﻜﺬا ﻟﺤﻴﻦ اﻟﻮﺻﻮل اﻟﻰ اﻷﻳﻌﺎز اﻷﺧﻴﺮ. ه ﺬا اﻟﻨﻤ ﻮذج ﻣﻤﻜ ﻦ أن ﻳﻐﻴ ﺮ ﺑﻄﺮﻳﻘ ﻪ ﻣﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ‬
‫ﺑﺸﻜﻞ ﺟﻴ ﺪ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ آﻤ ﺎ ﻳﻤﻜ ﻦ أن ﻳ ﺘﻢ ﺗﻜ ﺮار ﺟ ﺰء ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ وﺣ ﺴﺐ ﺗﺤﺪﻳ ﺪات اﻟﻤﺒ ﺮﻣﺞ‬
                                                                                                   ‫ٍ‬
                                                             ‫) ﻣﺜﻠﻤﺎ ﻳﺘﻢ ﺗﻜﺮار ﻣﻘﻄﻊ ﻣﻦ ﻧﻮﺗﻪ ﻣﻮﺳﻴﻘﻴﻪ ( .‬

‫• أي ﺑﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜﻮن ﻟﻪ ﺗﺄﺛﻴﺮ.. ﻣﺜﻼ ﻓ ﻲ اﻟﻘﻄﻌ ﻪ اﻟﻤﻮﺳ ﻴﻘﻴﻪ ﻳﻜ ﻮن ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻋﺒ ﺎرﻩ‬
‫ﻋ ﻦ ﺻ ﻮت , أﻣ ﺎ ﻓ ﻲ ﺑ ﺮاﻣﺞ اﻟﺤﺎﺳ ﻮب ه ﺬا اﻟﺘ ﺄﺛﻴﺮ ﻳﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ ﻣﺨﺮﺟ ﺎت , أﻣ ﺎ ﻣﻄﺒﻮﻋ ﻪ أو‬
                                                                            ‫ﻣﻌﺮوﺿﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ .‬

‫• آ ﻞ ﺑﺮﻧ ﺎﻣﺞ ﻳﻌﻤ ﻞ ﻋﻠ ﻰ أﺷ ﻴﺎء ﻣﺤ ﺪدﻩ ﻟﻠﻮﺻ ﻮل اﻟ ﻰ اﻟﺘ ﺄﺛﻴﺮ اﻟﻤﻄﻠ ﻮب ) ﻣ ﺜﻼ ﻓ ﻲ وﺻ ﻔﺔ‬
‫أﻋﺪاد اﻟﻄﻌﺎم ﻓﺎن هﺬﻩ اﻻﺷﻴﺎء ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻠﺤﻮم , اﻟﺨﻀﺎر, وﻏﻴﺮهﺎ ( , أﻣﺎ ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓ ﺄن ه ﺬﻩ‬
                                                                           ‫اﻻﺷﻴﺎء ﺗﻜﻮن ﺑﻴﺎﻧﺎت .‬

‫• ﻓﻲ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺒﺮاﻣﺞ ﻳﺠﺐ أن ﻳﺘﻢ اﻷﻋﻼن اﻟﻤﺴﺒﻖ ﻋﻦ اﻟﻤﺘﻐﻴﺮات أو اﻟﺒﻴﺎﻧ ﺎت اﻟﺘ ﻲ ﺳ ﻴﺘﻢ‬
‫أﺳﺘﺨﺪاﻣﻬﺎ وﻣﺎهﻴﺔ أﻧﻮاﻋﻬﺎ ) هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻤﻠﻴﺔ أﻋﺪاد وﺟﺒﺔ ﻃﻌﺎم ﺣﻴﺚ ﻳﺠﺐ أن ﺗﺤﺘﻮي اﻟﻮﺻﻔﻪ اﺑﺘﺪاءا‬
                                                          ‫ﻣﺎهﻴﺔ اﻟﻤﻮاد اﻟﺘﻲ ﺳﺘﺴﺘﺨﺪم وآﻤﻴﺎﺗﻬﺎ ( .‬

‫• ﻓﻲ ﺑﻌ ﺾ اﻷﻳﻌ ﺎزات رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ أن ﻳﺘ ﺮك أﺗﺨ ﺎذ ﻗ ﺮار ﺗﻨﻔﻴ ﺬهﺎ اﻟ ﻰ اﻟﻤﻌ ﺎﻟﺞ‬
‫وﻓﻘﺎ ﻟﺸﺮوط ﻣﻌﻴﻨﻪ.. ﻓﻤﺜﻼ ) ﻋﻨﺪ أﻋ ﺪاد وﺟﺒ ﺔ ﻃﻌ ﺎم ﻳﻜﺘ ﺐ ﻓ ﻲ اﻟﻮﺻ ﻔﻪ ﻣ ﺎ ﻳﻠ ﻲ " ﻋﻨ ﺪ ﺗ ﻮﻓﺮ اﻟﻄﻤﺎﻃ ﻪ‬
                         ‫اﻟﻄﺎزﺟﻪ ﺗﺴﺘﺨﺪم ﺑﻌﺪ ﻧﺰع اﻟﻘﺸﺮ ﻓﻲ ﺧﻼف ذﻟﻚ ﻳﺴﺘﺨﺪم ﻣﻌﺠﻮن اﻟﻄﻤﺎﻃﻢ" ( .‬
‫• رﺑﻤ ﺎ ﺗﻜ ﻮن هﻨ ﺎك ﺣﺎﺟ ﻪ ﻟﺘﻨﻔﻴ ﺬ أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ اﻷﻳﻌ ﺎزات ﻷآﺜ ﺮ ﻣ ﻦ ﻣ ﺮﻩ . ﻋﻠﻴ ﻪ‬
‫ﻃﺎﻟﻤﺎ هﻨﺎك أﻳﻌﺎز ﻳﺮاد ﺗﻜﺮارﻩ ﻓﺄن ﻋﺪد ﻣﺮات اﻟﺘﻜﺮار ﻳﺠﺐ ان ﺗﺤﺪد . ﻣﻤﻜﻦ أﻧﺠ ﺎز ذﻟ ﻚ أﻣ ﺎ ﺑﺘﺤﺪﻳ ﺪ‬
‫2‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

                                                            ‫اﻟﻤﻌﺮﻓﺎت ‪IDENTIFIERS‬‬                               ‫3.1‬

                                              ‫آﻞ اﻟﺒﺮاﻣﺞ ﺗﺤﺘﻮي ﻋﻠﻰ ﻧﻮﻋﻴﻦ ﻣﻦ اﻟﺮﻣﻮز :‬

‫اﻟﻨﻮع اﻻول .. وهﻲ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﻌﻮد اﻟﻰ اﻟﻠﻐ ﻪ .. ﻓﻔ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ه ﺬﻩ‬
‫اﻟﺮﻣ ﻮز ﺑﻄ ﺮﻳﻘﺘﻴﻦ أﻣ ﺎ أن ﺗﻜ ﻮن ﻋﻠ ﻰ ﺷ ﻜﻞ رﻣ ﺰ واﺣ ﺪ أو أﺛﻨ ﻴﻦ ﻣﺜ ﻞ ) - , + , = : , ) ( , ; , : ( أو‬
                                                      ‫ﻋﻠﻰ ﺷﻜﻞ آﻠﻤﺎت ﺗﺴﻤﻰ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ ﻣﺜﻞ :‬

           ‫) ‪( begin , if , else , repeat , while, until , then , end‬‬

‫اﻟﻨ ﻮع اﻟﺜ ﺎﻧﻲ .. ه ﻮ اﻟﻤﻌﺮﻓ ﺎت وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ رﻣ ﻮز ﺗ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒ ﺮاﻣﺞ ﻓﺄﻣ ﺎ أن ﺗﻜ ﻮن‬
                                                                            ‫ﻣﻌﺮﻓﺎت ﻗﻴﺎﺳﻴﻪ ﻣﺜﻞ‬

         ‫)‪( integer , real , write, sqrt …etc‬‬

‫أو أن ﺗﻜﻮن ﻣﻌﺮﻓ ﺎت ﻳ ﺘﻢ أﺧﺘﻴﺎره ﺎ ﻣ ﻦ ﻗﺒ ﻞ اﻟﻤﺒ ﺮﻣﺞ . ه ﺬﻩ اﻟﻤﻌﺮﻓ ﺎت اﻷﺧﻴ ﺮﻩ ﻧ ﺴﻤﻴﻬﺎ أﻳ ﻀﺎ‬
‫اﻟﻤﺘﻐﻴﺮات ) ‪ ( variables‬واﻟﻤﺘﻐﻴﺮ هﻮ رﻣﺰ أو أآﺜﺮ ﻳﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻟﻴ ﺸﻴﺮ اﻟ ﻰ ﻣﺤﺘ ﻮى ﻣﻮﻗ ﻊ‬
                                                                                      ‫ﻓﻲ اﻟﺬاآﺮﻩ .‬


                                                                                                ‫اﻟﻤﺘﻐﻴﺮ ://‬

         ‫ﻓﻲ أﻏﻠﺐ ﻟﻐﺎت اﻟﺒﺮﻣﺠﻪ ﻓﺄن اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن ﻟﺘﺨﺰﻳﻦ اﻟﻤﻌﻠﻮﻣﺎت , اﻟﻤﺘﻐﻴﺮ هﻮ ﻣﻜﺎن أو‬
      ‫ﻣﻮﻗﻊ ﻓﻲ ذاآﺮة اﻟﺠﻬﺎز ﺣﻴﺚ ﻳﻤﻜﻦ ﺗﺨﺰﻳﻦ ﻗﻴﻤﻪ ﺑﺪاﺧﻠﻪ ﺛﻢ أﻣﻜﺎﻧﻴﻪ أﺳﺘﻌﺎدة هﺬﻩ اﻟﻘﻴﻤﻪ ﻓﻴﻤﺎ‬
                                                                                    ‫ﺑﻌﺪ .‬
        ‫واﻟﻤﺘﻐﻴﺮ هﻮ أﺳﻢ ﻳﻤﺜﻞ ﺑﺮﻗﻢ أو ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ) وﻣﻤﻜﻦ ﺣﺮف واﺣﺪ أو ﺗﻌﺒﻴﺮ ﻣﻨﻄﻘﻲ ( .‬



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




                               ‫ﺷﻜﻞ رﻗﻢ ) 1.1 ( : ﺑﻌﺾ ﻣﻮاﻗﻊ اﻟﺬاآﺮﻩ‬


‫ﺗﺘﻜﻮن اﻟﻤﺘﻐﻴﺮات ﻣﻦ ﺣﺮف واﺣﺪ , ﻣﺠﻤﻮﻋﺔ ﺣﺮوف , أو ﺣﺮوف وأرﻗﺎم ﻋﻠﻰ أن ﻳﻜ ﻮن أول‬
                                                                         ‫رﻣﺰ ﺣﺮف ﻣﺜﻞ‬
   ‫) 543‪ ( x , b , ad, jasim , endofpoint , hind6 , x‬هﺬﻩ ﺟﻤﻴﻌﺎ ﻣﺘﻐﻴﺮات ﻣﻘﺒﻮﻟﻪ.‬

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

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

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

‫‪Const‬‬
  ‫; 5356293141.3 = ‪Pi‬‬
 ‫; ' ‪Error = ' Run_Time Error‬‬
‫4‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                    ‫أﺳﺒﺎب أﺳﺘﺨﺪام اﻟﺜﻮاﺑﺖ :‬

     ‫• أذا آﺎن هﻨﺎك ﻋﺪد ﻳﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ﻓﺄن اﻟﻤﺒﺮﻧﺞ ﻳﻔﻀﻞ أن ﻳﺼﻔﻪ‬
    ‫ﺑﺄﺳﻢ ﺿﻤﻦ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ , وﺑﻌﺪهﺎ ﺑﺎﻷﻣﻜﺎن أﺳﺘﺨﺪام اﻷﺳﻢ اﻟﻤﻮﺻﻮف ﻓﻲ‬
                                                                ‫اﻟﻘﺴﻢ اﻟﺘﻨﻔﻴﺬي .‬

       ‫• ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام ﺣﻘﻞ اﻟﺜﻮاﺑﺖ ﻟﺘﺴﻤﻴﺔ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ واﻟﺘﻲ‬
                                      ‫ﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ .‬
    ‫ﻣﺜﺎل : ﻧﻔﺮض أﻧﻨﺎ ﻧﺤﺘﺎج اﻟﻰ ﻃﺒﺎﻋﺔ أﺳﻢ ﺟﺎﻣﻌﻪ ﻣﺜﻼ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ , ﻣﻤﻜﻦ أن‬
                                                                        ‫ﻧﻘﻮم ﺑﻤﺎﻳﻠﻲ :‬

     ‫‪Const‬‬
       ‫; ' ‪University = 'Al _ Mustnsirah university‬‬
       ‫; '----------------------------------------------' = ‪Underline‬‬

                   ‫اﻷن ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﻌﺮﻓﻪ آﺜﻮاﺑﺖ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وآﻤﺎ ﻳﻠﻲ:‬

        ‫; ) ‪Writeln ( university‬‬
        ‫; ) ‪Writeln ( underline‬‬

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

‫آﻞ ﻋﻨﺼﺮ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ أﻣ ﺎ أن ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ ﺛﺎﺑﺘ ﻪ أو ﻣﺘﻐﻴ ﺮﻩ ) أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
‫رﺑﻤﺎ ﺗﺘﻐﻴﺮ ﺧﻼل ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ (. آﻞ ﻣﺘﻐﻴﺮ) واﻟﺬي هﻮ ﺑﻴﺎﻧﺎت ( ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺠﺐ أن ﻳﻜ ﻮن ﻟ ﻪ ﻧ ﻮع‬
‫وﺑﻤﻮﺟﺐ هﺬا اﻟﻨﻮع ﺳﻴﺘﻢ ﺗﺤﺪﻳﺪ اﻟﻤﺴﺎ ﺣﻪ اﻟﺨﺰﻧﻴﻪ اﻟﻼزﻣﻪ ﻟﻘﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ , وآ ﺬﻟﻚ ﺗﺤ ﺪد اﻟﻌﻤﻠﻴ ﺎت‬
   ‫اﻟﺘﻲ ﻣﻤﻜﻦ أﺟﺮاؤهﺎ ﻋﻠﻰ هﺬا اﻟﻤﺘﻐﻴﺮ. واﻷﻧﻮاع اﻟﻘﻴﺎﺳﻴﻪ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ :‬

                                              ‫1.5.1 اﻻﻋﺪاد اﻟﺼﺤﻴﺤﻪ ‪INTEGERS‬‬

‫اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ هﻲ آﻞ اﻷﻋﺪاد اﻟﻤﻮﺟﺒﻪ واﻟﺴﺎﻟﺒﻪ اﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻰ آ ﺴﺮ. ﻓﺎﻟ ﺼﻔﺮ ﻋ ﺪد‬
‫ﺻﺤﻴﺢ و 765 هﻮ ﻋﺪد ﺻﺤﻴﺢ و 32- أﻳﻀﺎ ﻋﺪد ﺻﺤﻴﺢ . أﻣ ﺎ )543.321 و 54.1- ( ﻓﻬ ﻲ ﻟﻴ ﺴﺖ‬
‫أﻋ ﺪاد ﺻ ﺤﻴﺤﻪ. أن اﻋﻠ ﻰ ﻗﻴﻤ ﻪ وأوﻃ ﺄ ﻗﻴﻤ ﻪ ﻟﻌ ﺪد ﺻ ﺤﻴﺢ ﻣﻤﻜ ﻦ ﺗﻤﺜﻴﻠ ﻪ ﻓ ﻲ اﻟﺤﺎﺳ ﻮب ﺗﺨﺘﻠ ﻒ ﻣ ﻦ‬
                 ‫ﺣﺎﺳﻮب ﻷﺧﺮ , وﻳﻤﻜﻦ ﻣﻌﺮﻓﺔ هﺬﻩ اﻟﻘﻴﻢ ﻓﻲ أي ﺣﺎﺳﻮب ﺑﺄﺳﺨﺪام اﻷﻳﻌﺎزات اﻟﺘﺎﻟﻴﻪ :‬

                 ‫‪maxint‬‬                         ‫ﻟﻤﻌﺮﻓﺔ أﻋﻠﻰ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬
                ‫‪- maxint‬‬                        ‫ﻟﻤﻌﺮﻓﺔ أوﻃﺄ ﻗﻴﻤﻪ ﻧﺴﺘﺨﺪم‬

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



‫ﻳﺠﺐ أن ﻧﻼﺣﻆ هﻨﺎ أن اﻟﻌﻼﻣﻪ ) / ( ﺗﺴﺘﺨﺪم ﻟﻠﻘﺴﻤﻪ ﻟﻜﻦ ﻣﻊ اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ أي اﻟﺘ ﻲ ﺗﺤﺘ ﻮي‬
                                                                                                          ‫آﺴﻮر‬
                                                                                           ‫أﻣﺜﻠﻪ ://‬
    ‫0 = 3 ‪2 Div‬‬
    ‫76666666.0 = 3 / 2‬
    ‫5 = 1 ‪5 Div‬‬
    ‫0.5 = 1 / 5‬
    ‫2 = 2 ‪5 Div‬‬
    ‫41 = 4*3+2‬
    ‫02 = 4 * )3+2(‬                                               ‫هﻨﺎ ﻳﻨﻔﺬ داﺧﻞ اﻟﻘﻮس أوﻻ‬
    ‫1 = 2 ‪5 mod‬‬
    ‫3 = 4 ‪7 mod‬‬

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

                                     ‫2.5.1 اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ‪REAL NUMBERS‬‬

‫0.01 , 09876.653- , 5.21 , 30.0‬               ‫وهﻲ اﻷﻋﺪاد اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ آﺴﻮر ﻣﺜ ﻞ‬

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



                                                                                           ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                           ‫ﻣﻼﺣﻈﻪ ://‬

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

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




                                                                                           ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                          ‫3.5.1 اﻟﺮﻣﻮز ‪Characters‬‬

‫وهﻲ آﺎﻓﺔ اﻟﺮﻣﻮز اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺤﺎﺳﻮب واﻟﺘﻲ ﻏﺎﻟﺒﺎ ﻣﺎ ﻧﺠﺪهﺎ ﻋﻠﻰ ﻟﻮﺣﺔ اﻟﻤﻔ ﺎﺗﻴﺢ واﻟﺘ ﻲ‬
‫ﺗ ﺸﻤﻞ اﻟﺤ ﺮوف اﻷﺑﺠﺪﻳ ﻪ ﺳ ﻮاء آﺎﻧ ﺖ ﺣ ﺮوف آﺒﻴ ﺮﻩ ) ‪ (A . . Z‬أو ﺣ ﺮوف ﺻ ﻐﻴﺮﻩ ) ‪, ( a..z‬‬
‫( , اﻟﺮﻣ ﻮز اﻻﺧ ﺮى اﻟﺘ ﻲ ﻧﺮاه ﺎ ﻋﻠ ﻰ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﻣﺜ ﻞ‬                  ‫9..0‬      ‫اﻷرﻗ ﺎم )‬
‫) ‪ ( + , . , / , ? , # , ! , & , % ..etc‬وﺗﺴﺘﺨﺪم ﺑﺸﻜﻞ ﻣﻔﺮد . وﻳﺼﺮح ﻋﻦ اﻟﺮﻣﻮز ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ‬
‫ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ ) ‪ . ( char‬وﻻ ﺗﻮﺟ ﺪ هﻨ ﺎك ﻣﺠﻤﻮﻋ ﻪ ﺧﺎﺻ ﻪ ﻣ ﻦ‬
‫اﻟﺮﻣ ﻮز ﻟﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻷن ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﺗ ﺴﺘﺨﺪم ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف ﻟﻠﺤﺎﺳ ﻮب اﻟ ﺬي‬
                                                                                    ‫ﺗﻌﻤﻞ ﻋﻠﻴﻪ .‬
                                             ‫أن أآﺜﺮ ﻣﺠﺎﻣﻴﻊ اﻟﺤﺮوف أﺳﺘﺨﺪاﻣﺎ هﻤﺎ أﺛﻨﺎن :‬

‫‪2 ASCII‬‬
                ‫)‪(American Standard Code for Information International‬‬
‫‪3 EBCDIC‬‬
                ‫)‪(Extended Binary Coded Decimal Information Code‬‬

                                                                     ‫وآﻞ ﻣﻨﻬﻢ ﻟﻪ ﺻﻔﺎﺗﻪ اﻟﺨﺎﺻﻪ ﺑﻪ .‬

                                                                                       ‫ﻣﻼﺣﻈﻪ ://‬

                           ‫آﻞ ﻣﺎ ﻳﻜﺘﺐ ﺑﻴﻦ ﻋﻼﻣﺘﻲ أﻗﺘﺒﺎس ) ' ' ( هﻮ واﺣﺪ ﻣﻦ أﺛﻨﻴﻦ :‬
                              ‫1. أذا آﺎن أآﺜﺮ ﻣﻦ رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ .‬
            ‫2. أذا آﺎن رﻣﺰ واﺣﺪ ﻓﻴﻌﺘﺒﺮ ﺣﺮف وﻣﻤﻜﻦ ﻓﻲ ﺑﻌﺾ اﻟﺤﺎﻻت ﻳﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ‬
                                                 ‫ﺣﺮﻓﻴﻪ أذا آﺎن ﻣﻌﺮف آﺬﻟﻚ .‬



                                       ‫ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف ﻟﻬﺎ اﻟﺨﻮاص واﻟﺼﻔﺎت اﻟﺘﺎﻟﻴﻪ :‬

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

               ‫2‪ch1 ≠ ch‬‬

                  ‫) 2‪ord ( ch1 ) ≠ ord ( ch‬‬                                   ‫ﻓﺄن‬


                                                                                     ‫ﻣﻼﺣﻈﻪ ://‬

                                 ‫اﻟﻌﻮاﻣﻞ اﻟﻮﺣﻴﺪﻩ اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻟﺤﺮﻓﻴﻪ هﻲ:‬
                                          ‫) > ﻟﻸرﻗﺎم = , =< , <‬
         ‫2. اﻟﻌﺪد اﻟﺘﺮﺗﻴﺒﻲ , = > ) ,9 .. 0 ( ﻳﺠﺐ أن ﺗ(ﻜﻮن ﻣﺮﺗﺒﻪ وﻣﺘﺘﺎﻟﻴﻪ ) ﻣﺘﻌﺎﻗﺒﻪ (‬
‫8‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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



                                                                                        ‫ﻣﻼﺣﻈﻪ ://‬

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



      ‫3. ﻟﻜﻲ ﻧﺤﻮل اﻟﺮﻗﻢ ﺑﺎﻟﻤﺘﻐﻴﺮ اﻟﺤﺮﻓﻲ ) ‪ ( ch‬اﻟﻰ اﻟﻘﻴﻤﻪ اﻟﺮﻗﻤﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ) ‪( num‬‬
                                                          ‫ﻓﻴﺠﺐ أﺳﺘﺨﺪام اﻟﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ :‬

         ‫; ) ' 0 ' ( ‪Num : = ord ( ch ) – ord‬‬

‫4. اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟﻜﺒﻴ ﺮﻩ ) ‪ ( A , B , ….. , Z‬ﻳﺠ ﺐ أن ﺗﻜ ﻮن ﻣﺮﺗﺒ ﻪ‬
                                        ‫وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ .‬

‫5. اﻷﻋ ﺪاد اﻟﺘﺮﺗﻴﺒﻴ ﻪ ﻟﻸﺣ ﺮف اﻟ ﺼﻐﻴﺮﻩ ) ‪ ) ( a , b , ….. , z‬أذا وﺟ ﺪت ( ﻳﺠ ﺐ أن‬
                                ‫ﺗﻜﻮن ﻣﺮﺗﺒﻪ وﻟﻴﺲ ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻣﺘﻌﺎﻗﺒﻪ .‬

‫أن اﻟﻔﻘﺮﺗﻴﻦ ) 4 و 5 ( ﺗﺆآﺪان ﻋﻠﻰ أن ﺗﻜ ﻮن اﻟﺤ ﺮوف ﻣﺮﺗﺒ ﻪ هﺠﺎﺋﻴ ﺎ , وﻟﻜ ﻦ ﻟ ﻴﺲ‬
        ‫ﺑﺎﻟﻀﺮورﻩ أن ﺗﻜﻮن ﻟﻬﺎ أﻋﺪاد ﺗﺮﺗﻴﺒﻴﻪ ﻣﺘﻌﺎﻗﺒﻪ , ﻓﻤﺜﻼ ﻓﻲ ﻧﻈﺎم ) ‪: ( EBCDIC‬‬

        ‫102 = ) ' ‪Ord ( ' I‬‬
        ‫902 = ) ' ‪Ord ( ' J‬‬

‫6. اﻟﺪاﻟ ﻪ ) ‪ ( chr‬ﺗﻌﻤ ﻞ ﻋﻜ ﺲ اﻟﺪاﻟ ﻪ ) ‪ ( ord‬ﻓﻬ ﻲ ﺗﺄﺧ ﺬ ﻣﻌﺎﻣ ﻞ ﻣ ﻦ ﻧ ﻮع ﻋ ﺪد ﺻ ﺤﻴﺢ‬
    ‫وﺗﻌﻄﻲ اﻟﻘﻴﻤﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻘﺎﺑﻠﻪ ﻟﻪ , وﻣﺪى ﻋﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ه ﻮ ﻣ ﺪى ﻋﻤ ﻞ اﻟﺪاﻟ ﻪ‬
                                                                         ‫) ‪.( ord‬‬

       ‫; ) ‪num : = ord ( ch‬‬
       ‫; ) ‪ch : = chr ( num‬‬

‫7. ﻋﻤﻠﻴﺎ أذا ﻣﺎ أﺧﺬﻧﺎ رﻗﻢ ) ‪ ( num‬ﻣﻦ ﻧﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) 9 ≤ ‪( 0 ≤ num‬‬
                             ‫ﻓﺄن اﻟﺤﺮف اﻟﻤﻘﺎﺑﻞ ﻟﻪ هﻮ وﻓﻘﺎ ﻟﻠﺼﻴﻐﻪ اﻟﺘﺎﻟﻴﻪ :‬

       ‫; )) ' 0 ' ( ‪ch : = chr ( num + ord‬‬
                                                                                   ‫ﻣﺜﻼ :‬
    ‫' 3 ' = ) ) ' 0 ' ( ‪chr ( 3 + ord‬‬
‫9‬                                                       ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                       ‫4.5.1 اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRING‬‬

‫وه ﻲ ﻋﺒ ﺎرﻩ ﻋ ﻦ ﻣﺘﻮاﻟﻴ ﻪ ﻣ ﻦ اﻟﺮﻣ ﻮز اﻟﻤﺒﻴﻨ ﻪ ﻓ ﻲ اﻟﻔﻘ ﺮﻩ اﻟ ﺴﺎﺑﻘﻪ , آ ﺬﻟﻚ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي‬
‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ﻋﻠﻰ ﻓﺮاغ وﻳﻌﺘﺒﺮ رﻣﺰ وﻟﻜﻦ ﻻ ﻳﻤﻜ ﻦ أن ﺗﺤﺘ ﻮي اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﻋﻠ ﻰ ﻋﻼﻣ ﺎت‬
‫اﻷﻗﺘﺒ ﺎس . أن اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ﺗ ﺴﺘﺨﺪم ﻟﺘﻌﺮﻳ ﻒ اﻟﻤﻌﻠﻮﻣ ﺎت ﻏﻴ ﺮ اﻟﺮﻗﻤﻴ ﻪ ﻣﺜ ﻞ اﻷﺳ ﻤﺎء , اﻟﻌﻨ ﺎوﻳﻦ‬
‫وﻏﻴﺮهﺎ, وأن ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺗﺴﺘﻮﻋﺒﻬﺎ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل هﻲ ) 552 .. 0 ( .‬
‫وﻳ ﺼﺮح ﻋ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات ﺑﺎﻟﺪاﻟ ﻪ‬
                                                                                  ‫) ‪ . ( string‬ﻣﺜﺎل‬

‫'‪'Xyz‬‬
‫'‪'Ali Abbas‬‬
‫'71-‪'Apollo‬‬
‫'‪'Do you wish to try again‬‬

‫اﻟﺠﻤﻠﻪ اﻷﺧﻴﺮﻩ ﺗﻌﺘﺒﺮ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴ ﻪ , آ ﺬﻟﻚ ﻓ ﺄن اﻷرﻗ ﺎم ﻋﻨ ﺪﻣﺎ ﺗﻌ ﺮف ﻣ ﻊ اﻟ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
                                                                     ‫ﺗﻌﺎﻣﻞ آﺮﻣﻮز وﻟﻴﺲ أرﻗﺎم .‬


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


‫وه ﻲ اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺘ ﻲ ﺗﻤﺜ ﻞ ﻧﺘﻴﺠﺘﻬ ﺎ ﺑﺤﺎﻟ ﻪ واﺣ ﺪﻩ ﻣ ﻦ أﺛﻨﺘ ﻴﻦ وهﻤ ﺎ ) ﺻ ﺢ أو ﺧﻄ ﺄ (‬
            ‫) ‪ , (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 )    ( ‫ﺟﺪول ) 1.1 ( : ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) و‬


       Expression 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 ) ( ‫ﺟﺪول ) 2.1 ( : ﺟﺪول اﻟﺼﺪق ﻟﻠﻌﺎﻣﻞ ) أو‬

     Expression 1            Expression 2                         OR (result)
         true                     true                               true
         false                    true                               true
         true                     false                              true
         false                    false                              false


                                                                                           NOT •


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

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




                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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



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

     ‫اﻟﻤﻼﺣﻈﺎت‬                ‫اﻟﺤﺠﻢ‬               ‫اﻟﻤﺪى‬                                           ‫اﻟﻨﻮع‬
                           ‫)ﺑﺎﻳﺖ (‬
      ‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬            ‫1‬                  ‫552 .. 0‬                                         ‫‪Byte‬‬
       ‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
      ‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬            ‫2‬                ‫53556 .. 0‬                                       ‫‪Word‬‬
       ‫ﻣﻮﺟﺒﻪ ﻓﻘﻂ‬
      ‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬            ‫1‬                ‫721 .. 821-‬                                     ‫‪Shortint‬‬

      ‫أﻋﺪاد ﺻﺤﻴﺤﻪ‬            ‫4‬          ‫7463746412 … 8463746412-‬                               ‫‪Longint‬‬

      ‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬           ‫6‬           ‫8301‪2.9x10-39 .. 1.7x‬‬                                  ‫‪Real‬‬

      ‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬           ‫4‬           ‫8301‪1.5x10-45 .. 3.4x‬‬                                 ‫‪Sigle‬‬

      ‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬           ‫8‬          ‫80301‪5.0x10-324 .. 1.7x‬‬                                ‫‪Double‬‬

      ‫أﻋﺪاد ﺣﻘﻴﻘﻴﻪ‬          ‫01‬         ‫239401‪3.4x10-4932 .. 1.1x‬‬                              ‫‪Extended‬‬

       ‫ﻏﻴﺮ رﻗﻤﻴﻪ‬             ‫1‬                 ‫ﺣﺮف واﺣﺪ‬                                         ‫‪Char‬‬

       ‫ﻏﻴﺮ رﻗﻤﻴﻪ‬            ‫552‬                ‫552 ﺣﺮف‬                                        ‫‪String‬‬

       ‫ﻏﻴﺮ رﻗﻤﻴﻪ‬             ‫1‬               ‫‪True / False‬‬                                     ‫‪Boolean‬‬




                                                                                                ‫ﻣﻼﺣﻈﻪ ://‬

       ‫أن أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻤﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ﺧﺎرج اﻟﻤﺪى اﻟﻤﺤﺪد ﻟﻪ ﺳﻴﺆدي اﻟﻰ ﺣﺪوث ﺧﻄﺄ , هﺬا‬
                           ‫اﻟﺨﻄﺄ أﻣﺎ أن ﻳﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ أو ﻳﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﻪ .‬
‫21‬                                              ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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

                          ‫ﻣﺜﺎل‬                                          ‫اﻟﻮﻇﻴﻔﻪ‬                       ‫اﻟﺪاﻟﻪ‬

                    ‫5 = ) 5- ( ‪Abs‬‬                         ‫ﻷﻳﺠ ﺎد اﻟﻘﻴﻤ ﻪ اﻟﻤﻄﻠﻘ ﻪ ﻟﻌ ﺪد‬               ‫‪abs‬‬
                                                           ‫ﺳﺎﻟﺐ ) ﻳﺤﻮل اﻟﻌﺪد اﻟ ﺴﺎﻟﺐ‬
                                                                           ‫اﻟﻰ ﻣﻮﺟﺐ (‬
                   ‫52 = ) 5 ( ‪Sqr‬‬                                      ‫أﻳﺠﺎد ﻣﺮﺑﻊ ﻋﺪد‬                 ‫‪sqr‬‬
         ‫00+‪Sqrt ( 25 ) = 5.0000000000E‬‬                    ‫أﻳﺠﺎد اﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ ﻟﻌ ﺪد‬               ‫‪sqrt‬‬
                                                                                  ‫ﻣﻮﺟﺐ‬
     ‫10-‪Sin ( 30 * Pi / 180 ) = 5.0000000000E‬‬                         ‫اﻳﺠﺎد ﺟﻴﺐ زاوﻳﻪ‬                  ‫‪sin‬‬
     ‫10-‪Cos ( 60 * Pi / 180 ) = 5.0000000000E‬‬                    ‫أﻳﺠﺎد ﺟﻴﺐ ﺗﻤﺎم زاوﻳﻪ‬                 ‫‪cos‬‬
                ‫5 = ) 1342 .5 ( ‪Trunk‬‬                      ‫ﺗﺤﻮل اﻷﻋﺪاد اﻟﻜ ﺴﺮﻳﻪ اﻟ ﻰ‬                 ‫‪trunk‬‬
                 ‫5- = ) 6.5- ( ‪Trunk‬‬                       ‫أﻋﺪاد ﺻﺤﻴﺤﻪ وذﻟﻚ ﺑﺤﺬف‬
                                                                                   ‫اﻟﻜﺴﺮ‬
                ‫5 = ) 1342.5 ( ‪Round‬‬                       ‫ﻳﻘ ﺮب اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬                 ‫‪round‬‬
                 ‫6 = ) 567.5 ( ‪Round‬‬                                 ‫أﻗﺮب ﻋﺪد ﺻﺤﻴﺢ‬
                 ‫6- = ) 8.5- ( ‪Round‬‬
         ‫00+‪Int ( 2.31 ) = 2.0000000000E‬‬                   ‫ﻳﺤ ﻮل اﻟﻌ ﺪد اﻟﻜ ﺴﺮي اﻟ ﻰ‬                   ‫‪Int‬‬
                                                                           ‫ﻋﺪد ﺻﺤﻴﺢ‬
            ‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ 01 = ‪x‬‬                   ‫ﻳﻌﻤ ﻞ ﻋﻠ ﻰ زﻳ ﺎدة اﻟﻤﺘﻐﻴ ﺮ‬                  ‫‪inc‬‬
         ‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( inc ( x‬ﺳﺘﺆدي اﻟﻰ 11 = ‪x‬‬           ‫ﺑﻘ ﺪار واﺣ ﺪ أو ﺣ ﺴﺐ ﻣ ﺎ‬
         ‫أﻣﺎ )) 4 ,‪ ( inc ( x‬ﺳﺘﺆدي اﻟﻰ 41 = ‪x‬‬                                   ‫ﻣﺤﺪد‬
           ‫ﻧﻔﺮض أن ﻗﻴﻤﺔ ) ‪ ( x‬هﻲ 51 = ‪x‬‬                    ‫ﺗﻘﻠﻴﺺ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﻤﻘ ﺪار‬                  ‫‪dec‬‬
        ‫ﻋﻠﻴﻪ ﻓﺄن ) ) ‪ ( dec ( x‬ﺳﺘﺆدي اﻟﻰ 41 = ‪x‬‬                 ‫واﺣﺪ أو ﺣﺴﺐ ﻣﺎ ﻣﺤﺪد‬
         ‫أﻣﺎ ) ) 5 , ‪ ( dec ( x‬ﺳﺘﺆدي اﻟﻰ 01 = ‪x‬‬
       ‫أذا آﺎﻧﺖ ) 01 = ‪ ( x‬ﻓﺄن ) 9 = ) ‪( pred ( x‬‬          ‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟ ﺴﺎﺑﻘﻪ‬                     ‫‪pred‬‬
                                                                                ‫ﻟﻠﻤﺘﻐﻴﺮ‬
       ‫أذا آﺎﻧﺖ ) 01 = ‪ ( x‬ﻓﺄن ) 11 = ) ‪(succ ( x‬‬          ‫ﺗﻌﻄ ﻲ اﻟﻘﻴﻤ ﻪ اﻟﻼﺣﻘ ﻪ‬                      ‫‪succ‬‬
                                                                                ‫ﻟﻠﻤﺘﻐﻴﺮ‬
                 ‫أذا آﺎﻧﺖ ) 9 = ‪ ( x‬ﻓﺄن‬                    ‫ﻳﻔﺤﺺ اﻟﻤﺘﻐﻴﺮ ﻓﻴﻤﺎ أذا آﺎن‬                  ‫‪odd‬‬
             ‫) ) ‪ ( odd ( x‬ﺳﺘﻜﻮن ) ‪( true‬‬                  ‫ﻋ ﺪد ﻓ ﺮدي أم ﻻ وﻧﺘﻴﺠﺘ ﻪ‬
                                                                    ‫ﺗﻜﻮن ﺻﺢ أو ﺧﻄﺄ‬
           ‫0+‪Ln ( 8 ) = 2.0794415417E‬‬                      ‫ﺗﻌﻄ ﻲ ﻗﻴﻤ ﺔ اﻟﻠﻮﻏ ﺎرﻳﺘﻢ‬                      ‫‪ln‬‬
                                                           ‫اﻟﻄﺒﻴﻌ ﻲ ) أي ﻟﻸﺳ ﺎس‬
                                                                                ‫)‪((e‬‬
‫31‬                                                ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                         ‫ﻣﻼﺣﻈﻪ :‬

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




                                                                                       ‫ﻣﻼﺣﻈﻪ ://‬

       ‫ﺗﻘﺎس اﻟﺰواﻳﺎ ﻓﻲ اﻟﺪوال اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻟﺰواﻳﺎ ) ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ( ﺑﻤﺎ ﻳﺴﻤﻰ‬
         ‫ﺑﺎﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ) ‪ ( Radians‬وﻟﻴﺲ ﺑﺎﻟﺪرﺟﺎت آﻤﺎ هﻮ اﻟﺤﺎل ﻓﻲ اﻟﺮﻳﺎﺿﻴﺎت ,‬
           ‫وﻟﺘﺤﻮﻳﻞ أي زاوﻳﻪ ) ‪ ( angle‬ﻣﻦ اﻟﻘﻴﺎس ﺑﺎﻟﺪرﺟﺎت اﻟﻰ اﻟﻨﺼﻒ ﻗﻄﺮﻳﻪ ﻧﺘﺒﻊ‬
                                                                      ‫اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ :‬

           ‫081 / ‪Angle ( in radians ) : = angle ( in degree ) * Pi‬‬

       ‫ﺣﻴﺚ أن ) ‪ ( Pi‬هﻲ اﻟﻨﺴﺒﻪ اﻟﺜﺎﺑﺘﻪ وهﻲ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺨﺰوﻧﻪ ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬
               ‫وﺳﻴﻌﻮض ﻋﻨﻬﺎ أﻟﻴﺎ ﺑﻘﻴﻤﺘﻬﺎ اﻟﺒﺎﻟﻐﻪ ) 5832397985356295141.3 ( .‬




                                                                                       ‫ﻣﻼﺣﻈﻪ ://‬

          ‫1 = ) ‪Ord ( true‬‬
          ‫0 = ) ‪Ord ( false‬‬
          ‫‪Pred ( true ) = false‬‬
          ‫‪Succ ( false ) = true‬‬



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

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




  ‫; ‪Randomize‬‬
  ‫; ‪X : = random‬‬

 ‫هﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﻜﻮن ﻗﻴﻤﺘﻪ ) 1 < ‪ ( 0 <= x‬وﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﺗﻨﻔﻴﺬ هﺬا اﻷﻣﺮ ﺳﻨﺤﺼﻞ ﻋﻠﻰ ﻗﻴﻤﻪ‬
                                                                ‫ﺟﺪﻳﺪﻩ ﺿﻤﻦ ﻧﻔﺲ اﻟﻤﺪى .‬

    ‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻧﻴﻪ هﻲ ﺑﺄﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬أﻳﻀﺎ ﺛﻢ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن‬
  ‫ﻳﺤﺘﻮي اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ اﻟﻤﺪى اﻟﻤﻄﻠﻮب أﻳﺠﺎد اﻟﺮﻗﻢ اﻟﻌﺸﻮاﺋﻲ ﺿﻤﻨﻪ ) أي أﻧﻪ ﺳﻴﻮﻟﺪ‬
      ‫أﻋﺪاد ﺻﺤﻴﺤﻪ ﻣﻮﺟﺒﻪ ﻋﺸﻮاﺋﻴﺎ ﺗﺘﺮاوح ﻗﻴﻤﻬﺎ ﺑﻴﻦ اﻟﺼﻔﺮ واﻟﻌﺪد اﻟﻤﺤﺪد ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ (‬
                                            ‫) ‪ Random‬واﻟﺬي ﻳﻤﺜﻞ اﻟﺤﺪ اﻷﻋﻠﻰ ( , ﻣﺜﺎل :‬

     ‫; ‪Randomize‬‬
     ‫; ) 001 ( ‪X : = random‬‬


‫هﻨﺎ ﺗﻜ ﻮن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ) ‪ ( 0 <= x < 100 ) ( x‬وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻳﻌ ﺎد ﺗﻨﻔﻴ ﺬ ه ﺬا اﻷﻣ ﺮ ﺳﻨﺤ ﺼﻞ‬
               ‫ﻋﻠﻰ ﻗﻴﻤﻪ ﺟﺪﻳﺪﻩ . أن اﻟﻤﺪى اﻟﻤﺤﺪد ﻳﻤﻜﻦ ﺗﻐﻴﺮﻩ ﺣﺴﺐ ﻃﺒﻴﻌﺔ اﻟﺘﻄﺒﻴﻖ اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻩ .‬

‫• اﻟﻄﺮﻳﻘﻪ اﻟﺜﺎﻟﺜﻪ ﻷﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Random‬هﻲ ﺑﺪون أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( Randomize‬وﺑ ﺪﻻ‬
‫ﻣﻨﻪ ﻧﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻗﺒﻞ اﻷﻣﺮ ) ‪ ( Random‬ﻋﻠﻰ أن ﻳﺘﻢ أﺳﻨﺎد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴ ﺮ (‬
‫) ‪ , Randseed‬هﺬﻩ اﻟﻄﺮﻳﻘ ﻪ ﻣ ﻦ وﺟﻬ ﺔ ﻧﻈ ﺮي ه ﻲ اﻷﻓ ﻀﻞ ﻷن اﻟﻄ ﺮﻳﻘﺘﻴﻦ اﻟ ﺴﺎﺑﻘﺘﻴﻦ ﺳ ﺘﻮﻟﺪان‬
‫ﻧﻔﺲ ﻣﺠﻤﻮﻋﺔ اﻟﻘﻴﻢ ﻋﻨﺪ أﻳﻘ ﺎف اﻟﺒﺮﻧ ﺎﻣﺞ وأﻋ ﺎدة ﺗﻨﻔﻴ ﺬﻩ ﻣﻤ ﺎ ﻻ ﻳ ﺆدي اﻟ ﻰ ﻋ ﺸﻮاﺋﻴﻪ ﺣﻘﻴﻘﻴ ﻪ , ﺑﻴﻨﻤ ﺎ‬
‫هﺬﻩ اﻟﻄﺮﻳﻘﻪ ﺳﺘﻮﻟﺪ ﻣﺠﻤﻮﻋﺔ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ ﻣﺨﺘﻠﻔﻪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺘﻢ ﻓﻴﻬﺎ أﻋ ﺎدة اﻟﺘﻨﻔﻴ ﺬ ﻋﻠ ﻰ أن ﻳ ﺘﻢ‬
                                       ‫أﺳﻨﺎد ﻗﻴﻢ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( Randseed‬ﻋﻨﺪ آﻞ ﺗﻨﻔﻴﺬ , ﻣﺜﺎل‬

 ‫; 0021 = : ‪Randseed‬‬
 ‫; ‪X : = random‬‬

 ‫‪OR‬‬

‫; 5243 = : ‪Randseed‬‬
‫; ) 0001 ( ‪X : = random‬‬

    ‫ﻓﻲ اﻟﺤﺎﻟﻪ اﻷوﻟﻰ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( randseed‬أﺳﻨﺪ ﻟﻪ ﻗﻴﻤﻪ وهﻲ ) 0021 ( ووﻓﻘﺎ ﻟﻬﺎ ﺳﻴﻮﻟﺪ أرﻗﺎم‬
‫ﻋﺸﻮاﺋﻴﻪ آﺴﺮﻳﻪ أﻗﻞ ﻣﻦ واﺣﺪ وﻟﻮ أﻋﺪﻧﺎ اﻟﺘﻨﻔﻴﺬ ﻣﻊ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﺨﺘﻠﻔﻪ ﻟﻠﻤﺘﻐﻴﺮ ) ‪ ( randseed‬ﻓﺄن رﻗﻢ‬
                                  ‫ﻋﺸﻮاﺋﻲ ﻣﺨﺘﻠﻒ ﺳﺘﻮﻟﺪ ) ﺣﺎول ﺗﻨﻔﻴﺬ اﻟﻄﺮﻳﻘﺘﻴﻦ وﻻﺣﻆ اﻟﻔﺮق ( .‬
                 ‫أﻣﺎ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ﻓﺄﻧﻪ ﺳﻴﻮﻟﺪ أرﻗﺎم ﻋﺸﻮاﺋﻴﻪ أآﺒﺮ ﻣﻦ اﻟﺼﻔﺮ وأﺻﻐﺮ ﻣﻦ ) 0001 ( .‬
‫51‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                     ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻲ‬

 ‫أواﻣﺮ اﻷدﺧﺎل واﻷﺧﺮاج ‪INPUT / OUTPUT INSTRUCTIONS‬‬

                                                                                                ‫اﻟﻤﻘﺪﻣﻪ‬         ‫1.2‬

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

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


  ‫ﻳﺘﻜ ﻮن اﻟﺒﺮﻧ ﺎﻣﺞ ﺑﻠﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻦ ) اﻟ ﺮأس واﻟﺠ ﺴﻢ ( ) ‪( head and block‬‬
‫واﻟﺮأس هﻮ اﻟﺴﻄﺮ اﻷول ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وﻳﺒ ﺪأ ﺑﻜﻠﻤ ﻪ ﺑﺮﻧ ﺎﻣﺞ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ وﻳﺘﺒ ﻊ ﺑﺄﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺛ ﻢ‬
                                                                      ‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ) ; ( وآﻤﺎ ﻳﻠﻲ :‬

  ‫; ‪Program programname‬‬

‫ﻻﺣﻆ هﻨﺎ ﻳﺠﺐ ان ﻳﻜﻮن هﻨﺎك ﻓﺮاغ ﺑﻴﻦ آﻠﻤﺔ ﺑﺮﻧﺎﻣﺞ وأﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ , أﻣ ﺎ أﺳ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴ ﺘﻢ‬
‫أﺧﺘﻴﺎرﻩ ﻣﻦ ﻗﺒﻞ اﻟﻤﺒﺮﻣﺞ , وأﺳﺘﺨﺪام اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃ ﻪ ﺗ ﺪل ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وه ﻲ ﺗ ﺴﺘﺨﺪم ﻣ ﻊ آ ﻞ‬
‫اﻟﻌﺒﺎرات ﻓﻲ ﺑﺮاﻣﺞ ﺑﺎﺳﻜﺎل ﻟﻠﺪﻻﻟﻪ ﻋﻠ ﻰ ﻧﻬﺎﻳ ﺔ اﻟﻌﺒ ﺎرﻩ وﺑﺪاﻳ ﺔ ﻋﺒ ﺎرﻩ ﺟﺪﻳ ﺪﻩ ﻋ ﺪا ﺑﻌ ﺾ اﻟﺤ ﺎﻻت اﻟﺘ ﻲ‬
                                                                          ‫ﺳﻴﺘﻢ اﻻﺷﺎرﻩ ﻟﻬﺎ ﻓﻲ ﺣﻴﻨﻬﺎ.‬


                                                                                             ‫ﻣﻼﺣﻈﻪ :‬

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



                                                                                             ‫ﻣﻼﺣﻈﻪ :‬

              ‫ﻣﻦ اﻟﻤﻤﻜﻦ أهﻤﺎل اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ ﺑﻌﺪ اﻟﻌﺒﺎرات اﻟﺘﻲ ﺗﺴﺒﻖ اﻷﻣﺮ ) ‪. ( end‬‬
‫61‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



‫أﻣ ﺎ ﺟ ﺴﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻴﺘﻜ ﻮن ﻣ ﻦ ﻗ ﺴﻤﻴﻦ اﻷول ه ﻮ ﻗ ﺴﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﺜﻮاﺑ ﺖ واﻟﻤﺘﻐﻴ ﺮات‬
‫وﻏﻴﺮهﺎ واﻟﺘﻲ ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ وهﻮ ﻳﺴﺘﺨﺪم ﺣﺴﺐ اﻟﺤﺎﺟﻪ اﻟﻴﻪ أي ﻣﻤﻜﻦ أن ﻧ ﺮى ﺑ ﺮاﻣﺞ ﻟ ﻴﺲ ﻓﻴﻬ ﺎ‬
‫هﺬا اﻟﻘﺴﻢ ﺑﺴﺒﺐ ﻋﺪم أﺣﺘﻴﺎج اﻟﺒﺮﻧﺎﻣﺞ ﻟﻸﻋﻼن . واﻟﻘﺴﻢ اﻟﺜﺎﻧﻲ ﻓﻬ ﻮ ﻳﻤﺜ ﻞ ) اﻷﻳﻌ ﺎزات أو اﻷواﻣ ﺮ(‬
 ‫) ‪ ( instructions or commands‬اﻟﺘﻲ ﺳﻴﻨﻔﺬهﺎ اﻟﺒﺮﻧﺎﻣﺞ وهﻮ ﻳﺒﺪأ ﺑﻜﻠﻤﺔ أﺑ ﺪأ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ‬
‫) ‪ ( begin‬ﺛ ﻢ اﻷﻳﻌ ﺎزات اﻟﻮاﺟ ﺐ ﺗﻨﻔﻴ ﺬهﺎ , وﻳﻨﺘﻬ ﻲ ﺑﻜﻠﻤ ﻪ ﻧﻬﺎﻳ ﻪ ﺑﺎﻟﻠﻐ ﻪ اﻻﻧﻜﻠﻴﺰﻳ ﻪ ﻣﺘﺒﻮﻋ ﻪ ﺑﻨﻘﻄ ﻪ‬
                                                     ‫). ‪ ( end‬وﻋﻠﻴﻪ ﻓﺴﻴﻜﻮن ﺷﻜﻞ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ :‬

        ‫; ‪Program programname‬‬

          ‫, ‪Declaration section (may or may not contain Type‬‬
                                  ‫) ‪Const , Var , Uses , Label‬‬
        ‫‪Begin‬‬
            ‫; ) ‪Statements ( instructions‬‬
        ‫.‪End‬‬
                                                                                                 ‫ﻣﻼﺣﻈﻪ ://‬

         ‫ﻳﻔﻀﻞ ﻋﻨﺪ ﺗﺴﻤﻴﺔ اﻟﺒﺮﻧﺎﻣﺞ أن ﻳﻜﻮن اﻷﺳﻢ ﻳﺪل ﻋﻠﻰ ﻓﻌﻞ اﻟﺒﺮﻧﺎﻣﺞ أو وﻇﻴﻔﺘﻪ , وﻻ ﻳﺠﻮز‬
          ‫أن ﻳﻜﻮن اﻷﺳﻢ أﺣﺪى اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ , أو ﻳﻜﻮن أﺳﻢ ﻟﻤﺘﻐﻴﺮ ﻣﺴﺘﺨﺪم ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ,‬
             ‫وﻻ ﻳﺠﻮز أن ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎﻓﺎت ) اﻟﻔﺮاﻏﺎت ( ﺑﻴﻦ أﺣﺮف اﻟﺒﺮﻧﺎﻣﺞ . ﻣﻤﻜﻦ اﺳﺘﺨﺪام‬
                                                ‫اﻟﺸﺎرﺣﻪ ) _ ( او اﻷرﻗﺎم ﻣﻊ أﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ .‬



                                                                                                 ‫ﻣﻼﺣﻈﻪ ://‬

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



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

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

‫1.3.2 ان ﻳﻜ ﻮن ﻣ ﺎ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﻣﺤ ﺼﻮر ﺑﻌﻼﻣ ﺎت أﻗﺘﺒ ﺎس ﻣﻔ ﺮدﻩ‬
‫) ‪ ( ' ' ) ( single quotation mark‬وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺎن ﻣﺎ ﻣﻮﺟﻮد ﺑﻴﻦ ﻋﻼﻣﺘ ﻲ اﻷﻗﺘﺒ ﺎس‬
                              ‫ﺳﻴﺘﻢ ﻃﺒﺎﻋﺘﻪ ﻋﻠﻰ اﻟﺸﺎﺷﻪ دون أدﻧﻰ ﺗﻐﻴﻴﺮ وآﻤﺎ هﻮ. ﻣﺜﺎل‬
‫71‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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




                                                                                     ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                ‫ﻻﺣﻆ ﻣﺎﻳﻠﻲ : //‬

                  ‫أوﻻ / ﻋﺪم أﺳﺘﺨﺪام أو وﺟﻮد ﻗﺴﻢ اﻷﻋﻼن وذﻟﻚ ﻟﻌﺪم وﺟﻮد ﻣﺎ ﻧﻌﻠﻦ ﻋﻨﻪ.‬

‫ﺛﺎﻧﻴﺎ / أن ﻣﺨﺮﺟﺎت ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ه ﻲ اﻟﻌﺒ ﺎرﻩ اﻟﻤﻮﺟ ﻮدﻩ ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ ﺑﻌ ﺪ آﻠﻤ ﻪ ) ‪( write‬‬
                                                                      ‫وﺳﺘﻈﻬﺮ ﻋﻠﻰ اﻟﺸﺎﺷﻪ آﻤﺎ ﻳﻠﻲ :‬



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



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




                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

      ‫ﻣﻤﻜﻦ أﻇﻬﺎر اﻟﻨﺘﺎﺋﺞ ﺑﻌﺪ أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺑﻄﺮﻳﻘﻪ ﺗﺴﺎﻋﺪ ﻋﻠﻰ ﺗﻨﻈﻴﻢ اﻟﻤﺨﺮﺟﺎت وذﻟﻚ ﻣﻦ ﺧﻼل‬
       ‫ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ ) آﻞ ﺣﺮف أو رﻗﻢ ﻳﻄﺒﻊ ﻋﻠﻰ ﻣﻮﻗﻊ واﺣﺪ ( اﻟﺘﻲ ﺳﺘﻄﺒﻊ ﻋﻠﻴﻬﺎ اﻟﻨﺘﺎﺋﺞ‬
       ‫ﺣﻴﺚ ﺳﺘﻄﺒﻊ اﻟﻘﻴﻤﻪ اﻟﻤﻄﻠﻮب ﻃﺒﺎﻋﺘﻬﺎ ﻣﻦ اﻟﻴﻤﻴﻦ اﻟﻰ اﻟﻴﺴﺎر , ﻓﺄذا آﺎن ﻋﺪد اﻟﻤﻮاﻗﻊ أآﺒﺮ‬
                      ‫ﻣﻦ ﻋﺪد اﻻرﻗﺎم ﻓﻲ اﻟﻌﺪد ﻓﺴﻴﺘﺮك ﻓﺮاغ ﻣﻦ اﻟﻴﺴﺎر , واﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ هﻲ :‬
       ‫; )‪Write ( data : fieldwidth‬‬

        ‫ﻻﺣﻆ أن اﻟﻔﺎﺻﻞ ﺑﻴﻦ اﻟﺒﻴﺎﻧﺎت واﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ ﻋﺮض اﻟﺤﻘﻞ هﻮ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن.‬
                                                                                   ‫ﻣﺜﺎل‬
                     ‫; 5432 = : ‪I‬‬
                     ‫; ) ‪Writeln ( I‬‬
                     ‫; ) 7 : ‪Writeln ( I‬‬
                                        ‫ﺳﺘﻜﻮن ﻧﺘﻴﺠﻪ هﺬﻳﻦ اﻷﻣﺮﻳﻦ آﻤﺎ ﻳﻠﻲ , ﻻﺣﻆ اﻟﻔﺮق‬
     ‫5432‬
     ‫5432***‬
                                             ‫هﻨﺎ اﻟﻌﻼﻣﻪ ) * ( ﺗﻤﺜﻞ ﻓﺮاغ ﻟﻠﺘﻮﺿﻴﺢ ﻓﻘﻂ .‬
        ‫أﺿﺎﻓﻪ اﻟﻰ أﻣﻜﺎﻧﻴﺔ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺨﺼﺼﻪ ﻟﻠﺮﻗﻢ ﻓﻴﻤﻜﻦ ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﻤﺮاﺗﺐ ﺑﻌﺪ‬
                                                ‫اﻟﻔﺎرزﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺮﻗﻢ اﻟﻜﺴﺮي وآﻤﺎ ﻳﻠﻲ :‬
                     ‫; ) ‪Write ( data : fieldwidth : precision‬‬

            ‫ﺣﻴﺚ أن ) ‪ ( precision‬ﺗﻤﺜﻞ ﻋﺪد اﻟﻤﻮاﻗﻊ اﻟﻤﺤﺪدﻩ ﻟﻄﺒﺎﻋﺔ اﻟﺠﺰء اﻟﻜﺴﺮي . ﻣﺜﺎل‬

                       ‫; ) 3 : 9 : ‪Writeln ( I‬‬
                                                           ‫ﻳﺠﺐ أن ﺗﻜﻮن ) ‪ ( I‬ﻋﺪد ﺣﻘﻴﻘﻲ .‬
        ‫ﻓﻲ ﺟﻤﻴﻊ اﻷﻣﺜﻠﻪ أﻋﻼﻩ ﻓﺄن اﻟﻤﺘﻐﻴﺮ ) ‪ ( I‬ﻣﻌﺮف آﻌﺪد ﺻﺤﻴﺢ , أﻣﺎ أذا ﻋﺮف آﻌﺪد ﺣﻘﻴﻘﻲ‬
                                          ‫ﻓﺄن اﻟﻨﺘﺎﺋﺞ ﺳﺘﺨﺘﻠﻒ وﺗﻜﻮن ﻟﻠﻤﺜﺎل اﻷول آﻤﺎ ﻳﻠﻲ :‬
     ‫30+‪2.3450000000E‬‬
     ‫30+‪2.3E‬‬
                                                     ‫أﻣﺎ ﺑﺎﻟﻨﺴﺒﻪ ﻟﻠﻤﺜﺎل اﻷﺧﻴﺮ ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﻪ‬
                                                                               ‫000.5432‬
     ‫وأﺧﻴﺮا ﻣﻤﻜﻦ أن ﻳﻜﻮن ) ‪ ( I‬ﻣﻦ ﻧﻮع اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓﺄن ﺣﻘﻞ ﻋﺪد اﻟﻤﺮاﺗﺐ‬
                                                       ‫ﺑﻌﺪ اﻟﻔﺎرزﻩ ﺳﻮف ﻻ ﻳﻜﻮن ﻟﻪ ﺣﺎﺟﻪ .‬




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



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

                     ‫‪var‬‬                                   ‫ﺑﺪءا ﻧﻜﺘﺐ آﻠﻤﺔ‬

‫اﻷن ﻧﻜﺘﺐ أﺳﻢ اﻟﻤﺘﻐﻴﺮ وﻳﺘﺒﻊ ﺑﺎﻟﻨﻘﻄﺘﻴﻦ اﻟﻤﺘﻌﺎﻣﺪﺗﻴﻦ ) ‪ ( : ) ( colon‬ﺛﻢ ﻧﻮع اﻟﻤﺘﻐﻴ ﺮ وﺗﻨﺘﻬ ﻲ‬
                                                                                   ‫ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ‬

       ‫; ‪x : integer‬‬

‫ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ) ‪ ( integer‬أي أن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ داﺋﻤ ﺎ‬
                                                                             ‫ﺳﺘﻜﻮن ﻋﺪد ﺻﺤﻴﺢ.‬

‫ﺛﺎﻧﻴﺎ / أن ﺗﻜﻮن ﻟﻬﺬا اﻟﻤﺘﻐﻴﺮ أو اﻟﺜﺎﺑﺖ ﻗﻴﻤ ﻪ ﻋﻨ ﺪ أول أﺳ ﺘﺨﺪام ﻟ ﻪ داﺧ ﻞ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓﻤ ﺜﻼ أﻧﻨ ﺎ‬
‫ﻋﺮﻓﻨﺎ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﻟﻜﻦ آﻢ هﻲ ﻗﻴﻤ ﺔ ه ﺬا اﻟﻤﺘﻐﻴ ﺮ ه ﻮ ﻋ ﺪد ﺻ ﺤﻴﺢ ﻟﻜ ﻦ آ ﻢ !! ﻓﻌﻨ ﺪﻣﺎ ﻧﻌﻄ ﻲ اﻷﻣ ﺮ‬
‫) )‪ ( write (x‬ﻓﻜﻢ ﻳﺠﺐ ﻋﻠﻰ اﻟﻤﺘﺮﺟﻢ أن ﻳﻄﺒﻊ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺘﻨﻔﻴﺬ !! ﻟﺬا ﻳﺠ ﺐ أن ﻧﺤ ﺪد ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ‬
                                                                            ‫أو اﻟﺜﺎﺑﺖ ﻗﺒﻞ أول أﺳﺘﺨﺪام .‬
‫هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺗﺤﺪد ﻟﻠﻤﺘﻐﻴﺮ ﺗﺄﺗﻲ ﻣﻦ أﺣﺪى ﻋﻤﻠﻴﺘﻴﻦ ﻓﺄﻣﺎ أن ﺗﺄﺗﻲ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ أو ﺗ ﺄﺗﻲ‬
                                                                ‫ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ ... ﻟﻨﻨﺎﻗﺶ اﻟﺤﺎﻟﺘﻴﻦ :‬

                                                                                    ‫• ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ :‬

‫وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌ ﺎدﻻت أو اﻟﺘﻌ ﺎﺑﻴﺮ اﻟﺮﻳﺎﺿ ﻴﻪ أي ﺑﺄﺳ ﺘﺨﺪام اﻟﻤ ﺴﺎواة‬
                                                     ‫) ‪ , ( assignment‬ﻓﻤﺜﻼ ﻧﻘﻮل‬

         ‫;5=:‪x‬‬

‫هﻨﺎ أﺳﺘﺨﺪﻣﻨﺎ اﻟﻤﺴﺎواة واﻟﺘﻲ ﻳﺮﻣﺰ ﻟﻬﺎ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ ) = : ( وﺑﺬﻟﻚ ﻓﺎن‬
  ‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺳﺘﻜﻮن ﻣﺴﺎوﻳﻪ اﻟﻰ اﻟﻌﺪد اﻟﺼﺤﻴﺢ ) 5 ( , أو ﻣﻤﻜﻦ أن ﺗﻜﻮن اﻟﻤﻌﺎدﻟﻪ ﻋﻠﻰ ﺷﻜﻞ‬

       ‫; 5+ 2 * 3 = : ‪x‬‬

‫هﻨﺎ ﻗﻴﻤﺔ ) ‪ ( x‬ﺗﺴﺎوي ) 11 ( , وآﺬﻟﻚ ﻣﻤﻜﻦ أن ﺗﺤﺪد ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ﺑﺎﻟﻤﺴﺎواة وﻟﻜﻦ ﻓﻲ ﺣﻘ ﻞ‬
                                                                        ‫اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ.‬
‫02‬                                            ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                         ‫ﻣﻼﺣﻈﻪ : //‬

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



                                  ‫أﺳﺒﻘﻴﺎت اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ ‪Operator Precedence‬‬

       ‫ﺗﻨﻔﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ وﻓﻘﺎ ﻷﺳﺒﻘﻴﺎﺗﻬﺎ اﻟﻤﺒﻴﻨﻪ أدﻧﺎﻩ , دوﻧﺖ اﻟﻌﻤﻠﻴﺎت ﺑﺸﻜﻞ ﺗﻨﺎزﻟﻰ أي‬
                           ‫ﻣﻦ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﻌﻠﻴﺎ اﻟﻰ اﻟﻌﻤﻠﻴﻪ ذات اﻷﺳﺒﻘﻴﻪ اﻟﺪﻧﻴﺎ :‬

            ‫.1‬   ‫‪– unary‬‬     ‫‪, Not‬‬
            ‫.2‬   ‫, / , *‬      ‫‪Mod , Div , And , Shl , Shr‬‬
            ‫.3‬   ‫, - , +‬       ‫‪Or , Xor‬‬
            ‫.4‬   ‫=< , <‬       ‫‪, > , > = , <> , = , In‬‬
                                                                                                           ‫•‬
‫12‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                                 ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                 ‫• ﻣﻦ ﺧﺎرج اﻟﺒﺮﻧﺎﻣﺞ :‬

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


         ‫;2‪Program CH2_Program‬‬
         ‫‪Var‬‬
           ‫;‪Num1, Num2, Sum: Integer‬‬

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




                                                                               ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ :‬
         ‫02 :1 ‪Input number‬‬           ‫} ‪{ Press enter‬‬
         ‫51 :2 ‪Input number‬‬           ‫} ‪{ Press enter‬‬
          ‫53‬



                                                                              ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ :/ /‬

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



‫ﺛﺎﻧﻴﺎ :// ﻳﻤﻜﻦ اﻷﻋﻼن ﻋﻦ آﻞ ﻣﺘﻐﻴﺮ ﺑ ﺴﻄﺮ ﻣﻨﻔ ﺼﻞ , وﻳﻤﻜ ﻦ وﺿ ﻌﻬﺎ ﺟﻤﻴﻌ ﺎ ﺑ ﺴﻄﺮ واﺣ ﺪ‬
‫آﻤ ﺎ ﻓ ﻲ ه ﺬا اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﺮط أن ﺗﻜ ﻮن ﺟﻤﻴ ﻊ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع ) هﻨ ﺎ ﺟﻤﻴﻌﻬ ﺎ أﻋ ﺪاد‬
‫ﺻﺤﻴﺤﻪ ( وذﻟ ﻚ ﻟﻐ ﺮض ﺗﻘﻠﻴ ﻞ اﻟﻤ ﺴﺎﺣﻪ اﻟﺘ ﻲ ﻳﻜﺘ ﺐ ﻋﻠﻴﻬ ﺎ اﻟﺒﺮﻧ ﺎﻣﺞ , وﻳ ﺘﻢ اﻟﻔ ﺼﻞ ﺑ ﻴﻦ ﻣﺘﻐﻴ ﺮ وأﺧ ﺮ‬
                                                       ‫ﺑﻔﺎرزﻩ . وﻃﺒﻌﺎ اﻟﻌﺒﺎرﻩ ﺗﻨﺘﻬﻲ ﺑﻔﺎرزﻩ ﻣﻨﻘﻮﻃﻪ .‬

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



                                                                                             ‫ﻣﻼﺣﻈﻪ ://‬

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



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

‫ﺧﺎﻣﺴﺎ :// هﻨﺎ ﺗﺒﺪأ ﻋﻤﻠﻴﺔ أدﺧﺎل ﻗﻴﻤﻪ ﻟﻠﻤﺘﻐﻴﺮ ) 1‪ ( num‬وذﻟﻚ ﺑﺄﺳﺘﺨﺪام اﻷﻣ ﺮ ) ‪( readln‬‬
‫, ﻋﻨﺪ اﻟﻮﺻﻮل اﻟﻰ ه ﺬﻩ اﻟﺨﻄ ﻮﻩ ﻓ ﺄن ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ ) اﻟ ﺸﺎﺷﻪ اﻟ ﺴﻮداء ( ﺳ ﺘﻈﻬﺮ وﻳﻜ ﻮن هﻨ ﺎك ﻣﺆﺷ ﺮ‬
‫ﺻﻐﻴﺮ ﻋﻠﻰ ﺷﻜﻞ ﺷﺎرﺣﻪ ) - ( ﻳﻈﻬﺮ وﻳﺨﺘﻔﻲ ﻓﻲ ﻣﻮﻗﻊ ﻋﻠﻰ اﻟﺠﺎﻧﺐ اﻷﻳﺴﺮ ﻣ ﻦ ﺷﺎﺷ ﺔ اﻟﺘﻨﻔﻴ ﺬ , ه ﺬا‬
‫اﻟﻤﺆﺷﺮ ﻳﺨﺒﺮ اﻟﻤﺴﺘﺨﺪم ﺑﺄن ﻋﻠﻴﻪ أدﺧﺎل ﻗﻴﻤﻪ ) ﻃﺒﺎﻋﺔ ﻗﻴﻤﻪ ﻣﻌﻴﻨﻪ ﺑﺄﺳﺘﺨﺪام ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ ( , وﺑﻌ ﺪ أن‬
‫32‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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


                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

            ‫اﻟﻔﺮق ﺑﻴﻦ اﻷﻣﺮ ‪ Read‬واﻷﻣﺮ ‪ Readln‬وآﻼهﻤﺎ ﻳﺴﺘﺨﺪم ﻟﻠﻘﺮاءﻩ , أن اﻷﻣﺮ‬
         ‫‪ Read‬ﻳﻘﺮأ اﻟﻤﺪﺧﻼت اﻟﺘﻲ ﻳﺪﺧﻠﻬﺎ اﻟﻤﺴﺘﺨﺪم وﻳﺘﻮﻗﻒ ﺑﻌﺪ أﺧﺮ ﻗﻴﻤﻪ ﻳﺘﻢ ﻗﺮاﺋﺘﻬﺎ ﻓﺄذا‬
          ‫ﺟﺎء أﻣﺮ ) ‪ ( read‬أﺧﺮ ﻓﻴﺒﺪأ اﻟﻘﺮاءﻩ أﻋﺘﺒﺎرا ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ‬
                                                             ‫اﻟﻤﺆﺷﺮ ﺑﻌﺪ اﻟﻘﺮاءﻩ اﻷوﻟﻰ .‬
        ‫أﻣﺎ اﻷﻣﺮ ‪ Readln‬ﻓﺄﻧﻪ ﻳﻌﻤﻞ ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ ﻣﻊ أﺳﺘﺜﻨﺎء واﺣﺪ . ﻓﺒﻌﺪ أن ﻳﻨﺘﻬﻲ ﻣﻦ‬
           ‫ﻗﺮاءة أﺧﺮ ﻗﻴﻤﻪ ﻓﻲ اﻟﻘﺎﺋﻤﻪ ﻓﺄن اﻟﻤﺆﺷﺮ ﺳﻴﻬﻤﻞ آﻞ اﻟﻘﻴﻢ اﻟﻤﺘﺒﻘﻴﻪ ﻋﻠﻰ ذﻟﻚ اﻟﺴﻄﺮ‬
                                                            ‫وﻳﻨﺘﻘﻞ اﻟﻰ ﺑﺪاﻳﺔ ﺳﻄﺮ ﺟﺪﻳﺪ .‬




                    ‫ﺳﺎدﺳﺎ :// اﻷﻣﺮان اﻟﻼﺣﻘﺎن هﻤﺎ ﻣﺸﺎﺑﻬﺎن ﻟﻠﺨﻄﻮﺗﻴﻦ اﻟﺮاﺑﻌﻪ واﻟﺨﺎﻣﺴﻪ.‬

‫ﺳ ﺎﺑﻌﺎ :// اﻟﻤﻌﺎدﻟ ﻪ ) 2‪ ( sum : = num1 + num‬ﻋﻨ ﺪ اﻟﻮﺻ ﻮل اﻟ ﻰ ه ﺬﻩ اﻟﻤﻌﺎدﻟ ﻪ ﻓ ﺄن‬
‫اﻟﻤﺘﺮﺟﻢ ﺳﻴﺒﺪأ ﺑﺎﻟﻄﺮف اﻷﻳﻤﻦ ﻣﻦ اﻟﻤﻌﺎدﻟﻪ وﻳﻌﻮض ﻋﻦ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻮﺟﻮدﻩ ﺑﻤﺎ ﻳ ﺴﺎوﻳﻬﺎ ﻣ ﻦ ﻗ ﻴﻢ ﺛ ﻢ‬
‫أﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ ﻋﻠﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻴﻨﺘﺞ ﻋﻦ ذﻟﻚ ﻗﻴﻤﻪ واﺣﺪﻩ ﻓﻲ اﻟﻄﺮف اﻷﻳﻤﻦ , هﺬﻩ اﻟﻘﻴﻤ ﻪ ﺳﺘﻮﺿ ﻊ‬
‫) ﺗﺨ ﺰن ( ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ اﻟﻤﺘﻐﻴ ﺮ اﻟﻤﻮﺟ ﻮد ﻓ ﻲ اﻟﻄ ﺮف اﻷﻳ ﺴﺮ, وﺑ ﺬﻟﻚ ﻓ ﺎن اﻟﻤﺘﻐﻴ ﺮ‬
‫) ‪ ( sum‬ﺳﺘﺴﻨﺪ ﻟﻪ ﻗﻴﻤ ﻪ ) ﺗﺨ ﺰن ﻓ ﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺆﺷ ﺮ ﻋﻠﻴ ﻪ ( ﻣ ﻦ ﺧ ﻼل اﻟﻤﻌﺎدﻟ ﻪ وه ﺬا ﻣ ﺎ أﺳ ﻤﻴﻪ‬
             ‫أدﺧﺎل ﻗﻴﻤﻪ ﻣﻦ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ ) أي أن اﻟﻤﺴﺘﺨﺪم ﻻ ﻳﺘﺪﺧﻞ ﻓﻲ ذﻟﻚ أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ( .‬

‫ﺛﺎﻣﻨ ﺎ :// ﺑﻌ ﺪ أﻧﺠ ﺎز اﻟﻌﻤ ﻞ اﻟﻤﻄﻠ ﻮب ﻣ ﻦ اﻟﺒﺮﻧ ﺎﻣﺞ ﻓ ﻼ ﺑ ﺪ ﻣ ﻦ أﻋ ﻼم اﻟﻤ ﺴﺘﺨﺪم ﺑﺎﻟﻨﺘﻴﺠ ﻪ‬
‫اﻟﻤﺘﺤﺼﻠﻪ ﻣﻦ أﻧﺠﺎز أو ﺗﻨﻔﻴﺬ هﺬا اﻟﺒﺮﻧﺎﻣﺞ , وﻳ ﺘﻢ ذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل ﻃﺒﺎﻋ ﺔ اﻟﻘﻴﻤ ﻪ اﻟﻤﺘﺤ ﺼﻠﻪ واﻟﺘ ﻲ ه ﻲ‬
‫اﻷن ﻣﻮﺟﻮدﻩ ﻓﻲ اﻟﻤﺘﻐﻴﺮ ) ‪ , ( sum‬ﻟﺬا ﺗﻢ أﺳﺘﺨﺪام اﻷﻣﺮ أآﺘﺐ ﻟﻴﻄﺒﻊ ﻣ ﺎ ﻣﻮﺟ ﻮد ﺑ ﻴﻦ اﻟﻘﻮﺳ ﻴﻦ اﻟﻠﺘ ﻴﻦ‬
‫ﺑﻌﺪﻩ , وﻟﻤﺎ آﺎن ﻣﺎ ﻣﻮﺟﻮد ﺿﻤﻦ اﻟﻘﻮﺳﻴﻦ ﻏﻴﺮ ﻣﺤﺪد ﺑﻌﻼﻣﺘﻲ أﻗﺘﺒﺎس ﻟ ﺬا ﻓ ﺎن اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ ﻳﺤﻤﻠﻬ ﺎ ه ﺬا‬
                                                           ‫اﻟﻤﺘﻐﻴﺮ هﻲ اﻟﺘﻲ ﺗﻈﻬﺮ ﻋﻠﻰ ﺷﺎﺷﻪ اﻟﺘﻨﻔﻴﺬ .‬

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



‫اﻷدﺧ ﺎل ﺗﻤ ﺖ واﻟﻤﻔ ﺮوض أن ﻳﻘ ﺮأ ﻣ ﺎ ﻣﻄﺒ ﻮع ﻋﻠ ﻰ اﻟ ﺸﺎﺷﻪ وﻳ ﺴﻨﺪﻩ اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ واﻟ ﺬي ه ﻮ ﻏﻴ ﺮ‬
                                                                                    ‫ﻣﻮﺟﻮد ( .‬

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



                                                                                               ‫ﻣﻼﺣﻈﻪ ://‬

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




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

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


     ‫;3‪Program CH2_Program‬‬
     ‫;‪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‬‬
‫52‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                   ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ :‬
      ‫:‪Enter your name‬‬    ‫‪Ahmed‬‬            ‫} ‪{ enter‬‬
      ‫‪Enter your surname: Abass‬‬           ‫} ‪{ enter‬‬

      ‫‪Your full name is: Ahmed Abass‬‬



                                                                                ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ : //‬

‫اذا ﻣﺎ ﻧﻈﺮﻧﺎ اﻟﻰ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻓﻤﻦ اﻟﻤﻤﻜﻦ أن ﻧﺴﺠﻞ ﻋﺪد ﻣﻦ اﻟﻤﻼﺣﻈﺎت وﻧﺘﻌﻠﻢ أﺷﻴﺎء ﺟﺪﻳ ﺪﻩ‬
                                                                                                             ‫وهﻲ :‬
 ‫اوﻻ :// ﺗﻢ أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮﻳﻦ ) ‪ ( name , surname‬ﻣﻦ ﻧﻮع ﺳﻼﺳﻞ ﺣﺮﻓﻴ ﻪ ) ‪( string‬‬
‫وﻟﺬﻟﻚ ﻓﻌﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﺳﻴﺘﻢ اﻟﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم أدﺧﺎل ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﺤﺮوف ﻟﻜﻞ ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮﻳﻦ‬
‫وﻣ ﺎ ﻳ ﺘﻢ ﻃﺒﺎﻋﺘ ﻪ أو أدﺧﺎﻟ ﻪ ﻋ ﻦ ﻃﺮﻳ ﻖ ﻟﻮﺣ ﺔ اﻟﻤﻔ ﺎﺗﻴﺢ ﺳ ﻴﺬهﺐ ﻣﺒﺎﺷ ﺮة اﻟ ﻰ اﻟ ﺬاآﺮﻩ وﻳﺨ ﺰن ﺑ ﺎﻟﻤﻮﻗﻊ‬
‫اﻟﻤﺆﺷﺮ ﻋﻠﻴﻪ ﺑﻮاﺳﻄﺔ اﻟﻤﺘﻐﻴﺮ أﻋﻼﻩ . أن هﺬﻳﻦ اﻟﻤﺘﻐﻴﺮﻳﻦ ﻳﻤﻜﻦ اﺳﺘﺒﺪاﻟﻬﻤﺎ ﺑﺄي ﻣﺘﻐﻴﺮ أﺧ ﺮ ﻣ ﺜﻼ ) ‪( n‬‬
                               ‫ﺑﺪﻻ ﻣﻦ ) ‪ ( name‬وﻃﺒﻌﺎ ذﻟﻚ ﻻ ﻳﺆﺛﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﺳﺒﻖ وأن ﺑﻴﻨﺎ.‬

‫ﺛﺎﻧﻴ ﺎ :// ﻻﺣ ﻆ ﻓ ﻲ اﻟ ﺴﻄﺮﻳﻦ اﻟﺘﺎﺳ ﻊ واﻟﻌﺎﺷ ﺮ أﺳ ﺘﺨﺪام اﻷﻣ ﺮ ) ‪ ( writeln‬دون وﺟ ﻮد‬
‫أﻗ ﻮاس ﺑﻌ ﺪهﻤﺎ وه ﺬﻩ اﻟﻌﻤﻠﻴ ﻪ ﺗﻔﻴ ﺪ ﺑﻄﺒﺎﻋ ﺔ ﺳ ﻄﺮ ﻓ ﺎرغ ﻟﻜ ﻞ ﻣﻨﻬﻤ ﺎ أي أن اﻟﻤﺆﺷﺮﺳ ﻴﺘﺤﺮك اﻟ ﻰ ﺳ ﻄﺮ‬
                 ‫ﺟﺪﻳﺪ ﻓﻲ آﻞ ﻣﺮﻩ ﻳﺮد ﻣﺜﻞ هﺬا اﻷﻣﺮ, وهﻲ ﻷﻏﺮاض ﺗﻨﻈﻴﻢ وﺗﺮﺗﻴﺐ اﻟﻤﺨﺮﺟﺎت .‬

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




         ‫;4‪Program CH2_Program‬‬
         ‫‪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‬ﻟﻠﺨﺮوج ﻣﻦ اﻟﻜﺘﻠﻪ اﻟﺤﺎﻟﻴﻪ .‬




                                                ‫أﻧﻮاع اﻷﺧﻄﺎء اﻟﺘﻲ ﺗﺤﺪث ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ‬                        ‫5.2‬

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

‫1.5.2 اﻟﺨﻄ ﺄ اﻟ ﺬي ﻳﻤﻜ ﻦ ﺗﻤﻴ ﺰﻩ أﺛﻨ ﺎء ﺗﺮﺟﻤ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻗﻴ ﻞ اﻟﺘﻨﻔﻴ ﺬ , ﻣﺜ ﺎل‬
‫ﻋﺪم آﺘﺎﺑ ﺔ اﻷﻣ ﺮ ) ‪ ( End‬ﻷﻣ ﺮ ) ‪ ( begin‬ﻣﻮﺟ ﻮد ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ . وه ﺬا ﻧ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء‬
‫اﻟﺘﻲ ﺗﺴﻤﻰ أﺧﻄﺎء وﻗﺖ اﻟﺘﺮﺟﻤﻪ ) ‪ , ( Compile _ time errors‬وهﻮ ﺳ ﻴﺆدي اﻟ ﻰ ﻋ ﺪم‬
                                     ‫ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻣﻊ ﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ ﺗﺤﺪد ﻧﻮع اﻟﺨﻄﺄ .‬

‫2.5.2 اﻟﺨﻄ ﺄ اﻟ ﺬي ﻻ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ وأﻧﻤ ﺎ ﻳﻤﻴ ﺰ أﺛﻨ ﺎء اﻟﺘﻨﻔﻴ ﺬ , ﻣﺜ ﺎل‬
‫أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ آﺎن هﻨﺎك أﻣﺮ ﻷﻳﺠﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻟﻤﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻇﻬ ﺮ أن ﻗﻴﻤ ﺔ اﻟﻤﺘﻐﻴ ﺮ ﺳ ﺎﻟﺒﻪ‬
‫) ﻣﻌﺮوف أﻧﻪ ﻻ ﻳﻤﻜﻦ أﻳﺠﺎد اﻟﺠﺬر ﻟﻠﻘﻴﻢ اﻟﺴﺎﻟﺒﻪ ( , هﺬا ﺳﻴﺆدي اﻟﻰ ﺗﻮﻗ ﻒ ﺗﻨﻔﻴ ﺬ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﻊ‬
‫ﻇﻬ ﻮر رﺳ ﺎﻟﺔ ﺧﻄ ﺄ . ه ﺬا اﻟﻨ ﻮع ﻣ ﻦ اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﺗ ﺴﻤﻰ أﺧﻄ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ‬
                                                             ‫) ‪. ( Run _ time errors‬‬

‫3.5.2 أﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻻ ﺗﻤﻴ ﺰ ﺳ ﻮاء أﺛﻨ ﺎء اﻟﺘﺮﺟﻤ ﻪ أو أﺛﻨ ﺎء وﻗ ﺖ اﻟﺘﻨﻔﻴ ﺬ , ﻣﺜ ﺎل‬
‫اﻷﺧﻄ ﺎء اﻟﺘ ﻲ ﻳﺮﺗﻜﺒﻬ ﺎ اﻟﻤﺒ ﺮﻣﺞ رﺑﻤ ﺎ ﺳ ﻬﻮا وﻟﻜﻨﻬ ﺎ ﻣﻘﺒﻮﻟ ﻪ ﻟﻠﺤﺎﺳ ﻮب آ ﺄن ﻳﻜ ﻮن اﻟﻤﻄﻠ ﻮب‬
‫أدﺧﺎل اﻟﻘﻴﻤﻪ ) 03 ( وﻳﺘﻢ أدﺧﺎل اﻟﻘﻴﻤ ﻪ ) 04 ( ه ﺬا اﻟﺨﻄ ﺄ ﻻ ﻳﻌﺘ ﺮض ﻋﻠﻴ ﻪ اﻟﺤﺎﺳ ﻮب وﻟﻜﻨ ﻪ‬
‫ﺳﻴﺆدي اﻟﻰ ﻇﻬﻮر ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﺻﺤﻴﺤﻪ , ﻣﺜﻞ هﺬﻩ اﻷﺧﻄﺎء ﺳﻮف ﺗ ﺴﻤﺢ ﻟﻠﺒﺮﻧ ﺎﻣﺞ ﺑﺎﻷﺳ ﺘﻤﺮار‬
                                                                                 ‫ﺑﺎﻟﺘﻨﻔﻴﺬ .‬
‫72‬                                             ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                    ‫ﻣﻼﺣﻈﻪ ://‬

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




                                        ‫ﺟﺪول ) 1.2 ( : اﻟﺮﻣﻮز اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬

       ‫+‬              ‫)‪(PLUS‬‬                      ‫ﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻗﻴﻤﺘﻴﻦ , ﺗﺴﺘﺨﺪم أﻳﻀﺎ ﻷﺗﺤﺎد‬
                     ‫ﻋﻼﻣﺔ اﻟﺠﻤﻊ‬                ‫ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ , وﺗﺴﺘﺨﺪم ﻟﺠﻤﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
       ‫-‬             ‫)‪(MINUS‬‬                   ‫ﺗﺴﺘﺨﺪم ﻟﻄﺮح ﻗﻴﻤﺘﻴﻦ , ﺗﺴﺒﻖ اﻟﻘﻴﻢ ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ‬
                    ‫ﻋﻼﻣﺔ اﻟﻄﺮح‬                 ‫أن اﻟﻘﻴﻢ ﺳﺎﻟﺒﻪ , وﺗﺴﺘﺨﺪم ﻟﻠﻔﺮق ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
       ‫*‬          ‫)‪(ASTERISK‬‬                      ‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ ,‬
                   ‫ﻋﻼﻣﺔ اﻟﻀﺮب‬                                       ‫وآﺬﻟﻚ ﻟﺘﻘﺎﻃﻊ ﻣﺠﻤﻮﻋﺘﻴﻦ‬
       ‫/‬             ‫)‪(SLASH‬‬                         ‫ﺗﺴﺘﺨﺪم ﻷﺟﺮاء ﻋﻤﻠﻴﺔ اﻟﻘﺴﻤﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
                    ‫ﻋﻼﻣﺔ اﻟﻘﺴﻤﻪ‬                                    ‫وﺗﻜﻮن اﻟﻨﺘﻴﺠﻪ ﻗﻴﻤﻪ آﺴﺮﻳﻪ‬
       ‫=‬            ‫)‪(EQUAL‬‬                                ‫ﺗﺴﺘﺨﺪم ﻟﻔﺤﺺ اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
                   ‫ﻋﻼﻣﺔ اﻟﻤﺴﺎواة‬
       ‫<‬            ‫)‪(LESS THAN‬‬                  ‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷﺻﻐﺮ‬
                          ‫أﻗﻞ ﻣﻦ‬
       ‫>‬      ‫)‪(GREATER THAN‬‬                        ‫ﺗﺴﺘﺨﺪم ﻟﻤﻘﺎرﻧﺔ ﻗﻴﻤﺘﻴﻦ وﺗﺤﺪﻳﺪ اﻟﻘﻴﻤﻪ اﻷآﺒﺮ‬
                       ‫أآﺒﺮ ﻣﻦ‬
       ‫[‬       ‫)‪(LEFT BRACKET‬‬                             ‫)‬‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
                 ‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﺴﺮ‬                             ‫ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﻤﻦ (‬
       ‫]‬     ‫)‪(RIGHT BRACKET‬‬                               ‫ﻳﺴﺘﺨﺪم ﻓﻲ اﻟﻤﺠﺎﻣﻴﻊ واﻟﻤﺼﻔﻮﻓﺎت‬
                 ‫اﻟﻘﻮس اﻟﻤﺮﺑﻊ اﻷﻳﻤﻦ‬                          ‫) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
       ‫.‬            ‫)‪(PERIOD‬‬                 ‫ﺗﺴﺘﺨﺪم ﻓﻲ أﺧﺘﻴﺎر ﺣﻘﻞ ﻟﻤﺘﻐﻴﺮ اﻟﻘﻴﻮد , وﺗﺄﺗﻲ ﺑﻌﺪ‬
                        ‫اﻟﻨﻘﻄﻪ‬                              ‫اﻷﻣﺮ ) ‪ ( end‬ﻷﻧﻬﺎء اﻟﺒﺮﻧﺎﻣﺞ‬
       ‫,‬           ‫)‪(COMMA‬‬               ‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﻮاﻣﻞ ) ‪ (arguments‬وﻟﻔﺼﻞ‬
                                            ‫اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ‬
                       ‫اﻟﻔﺎرزﻩ‬                                     ‫ﻣﺪﻳﺎت اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬
       ‫:‬            ‫)‪(COLON‬‬                       ‫ﺗﺴﺘﺨﺪﻣﺎن ﻟﻔﺼﻞ أﻧﻮاع اﻟﻤﺘﻐﻴﺮات ﻓﻲ ﺣﻘﻞ‬
                 ‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن‬     ‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات وﻟﻔﺼﻞ أﺳﻢ اﻟﺪاﻟﻪ ﻋﻦ ﻧﻮﻋﻬﺎ‬
                                                                                ‫ﻋﻨﺪ ﺗﻌﺮﻳﻔﻬﺎ‬
‫82‬                                         ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



     ‫;‬      ‫)‪(SEMI-COLON‬‬                        ‫ﺗﺴﺘﺨﺪم ﻟﻔﺼﻞ اﻟﻌﺒﺎرات ﻓﻲ ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ‬
              ‫اﻟﻔﺎرزﻩ اﻟﻤﻨﻘﻮﻃﻪ‬                                                 ‫ﺑﺎﺳﻜﺎل‬
     ‫^‬        ‫)‪(POINTER‬‬                    ‫ﺗﺴﺘﺨﺪم ﻟﺘﻌﺮﻳﻒ اﻷﻧﻮاع واﻟﻤﺘﻐﻴﺮات ﻣﻦ ﻧﻮع‬
                                    ‫ﻣﺆﺷﺮ وﺗﺴﺘﺨﺪم ﻟﻠﻮﺻﻮل اﻟﻰ ﻣﺤﺘﻮﻳﺎت اﻟﻤﺘﻐﻴﺮات ﻣﻦ‬
                    ‫اﻟﻤﺆﺷﺮ‬                        ‫ﻧﻮع ﻣﺆﺷﺮ وآﺬﻟﻚ ﻣﺤﺘﻮﻳﺎت اﻟﻔﺎﻳﻼت‬
     ‫(‬             ‫‪(LEFT‬‬                   ‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
            ‫)‪PARENTHESIS‬‬              ‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻷﺟﺮاءات ) ﺑﺎﻷﺷﺘﺮاك ﻣﻊ‬
            ‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﺴﺮ‬                                        ‫اﻟﻘﻮس اﻷﻳﻤﻦ (‬
     ‫)‬            ‫‪(RIGHT‬‬                   ‫ﻳﺴﺘﺨﺪم ﻟﻴﺤﺘﻮي اﻟﺘﻌﺎﺑﻴﺮ اﻟﺮﻳﺎﺿﻴﻪ واﻟﻤﻨﻄﻘﻴﻪ‬
            ‫)‪PARENTHESIS‬‬             ‫أو ﻣﻌﺎﻣﻼت اﻟﺪوال واﻟﺮوﺗﻴﻨﺎت اﻟﻔﺮﻋﻴﻪ ) ﺑﺎﻷﺷﺘﺮاك‬
            ‫اﻟﻘﻮس اﻷﻋﺘﻴﺎدي اﻷﻳﻤﻦ‬                                    ‫ﻣﻊ اﻟﻘﻮس اﻷﻳﺴﺮ (‬
     ‫><‬      ‫/ ‪( LESS THAN‬‬                              ‫أﺧﺘﺒﺎر ﻋﺪم اﻟﻤﺴﺎواة ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ‬
           ‫) ‪GREATER THAN‬‬
                 ‫ﻋﺪم اﻟﻤﺴﺎواة‬
     ‫=<‬      ‫/ ‪(LESS THAN‬‬                   ‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ , و أﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ‬
                 ‫)‪EQUAL‬‬                                                       ‫اﻟﺠﺰﺋﻴﻪ‬
             ‫أﺻﻐﺮ ﻣﻦ أو ﻳﺴﺎوي‬
     ‫=>‬   ‫/ ‪(GREATER THAN‬‬                ‫ﻟﻠﻤﻘﺎرﻧﻪ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ , وأﺧﺘﺒﺎر اﻟﻤﺠﻤﻮﻋﻪ اﻟﺸﺎﻣﻠﻪ‬
                 ‫)‪EQUAL‬‬                                             ‫) ‪( superset‬‬
              ‫أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوي‬
     ‫=:‬    ‫)‪(COLON / EQUAL‬‬                                         ‫ﺗﺴﺘﺨﺪم ﻷﺳﻨﺎد ﻗﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات‬
                    ‫اﻟﻤﺴﺎواة‬
     ‫..‬   ‫)‪(PERIOD / PERIOD‬‬                                                                       ‫ﺗﻔﺼﻞ‬
             ‫اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﺠﺎورﺗﺎن‬


                         ‫ﺟﺪول ) 2.2 ( : اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزﻩ اﻟﺨﺎﺻﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬


     ‫‪AND‬‬                                                         ‫ﻣﻌﺎﻣﻞ اﻟﺮﺑﻂ اﻟﻤﻨﻄﻘﻲ‬
     ‫‪ARRAY‬‬                                                             ‫ﻧﻮع اﻟﻤﺼﻔﻮﻓﻪ‬
     ‫‪BEGIN‬‬                                                                 ‫ﻋﺒﺎرة اﻟﺒﺪأ‬
     ‫‪CASE‬‬                                             ‫ﻋﺒﺎرة اﻟﺒﺪأ ) ﻓﻲ ﺣﺎﻟﺔ ( ) ‪( case‬‬
     ‫‪CONST‬‬                                                            ‫ﺗﻌﺮﻳﻒ اﻟﺜﻮاﺑﺖ‬
     ‫‪DIV‬‬                              ‫ﺗﻘﺴﻴﻢ اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ وﻧﺘﻴﺠﺘﻬﺎ أﻳﻀﺎ أﻋﺪاد ﺻﺤﻴﺤﻪ‬
     ‫‪DO‬‬             ‫ﺗﺘﺒ ﻊ أواﻣ ﺮ اﻟﺘﻜ ﺮار ) ‪ ( For , While‬وﺗ ﺴﺒﻖ اﻻﻓﻌ ﺎل اﻟﺘ ﻲ ﻳﺠ ﺐ أن‬
                                                                                   ‫ﺗﻨﻔﺬ‬
     ‫‪DOWNTO‬‬           ‫ﺗﺴﺘﺨﺪم ﻣﻊ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( For‬وﺗﺪل ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﻘﻞ ﻓﻲ آﻞ‬
‫92‬                                     ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                                ‫دورﻩ‬
     ‫‪ELSE‬‬           ‫ﺗﺴﺘﺨﺪم ﻣﻊ ) ‪ , ( If‬ﺣﻴﺚ ﻓﻲ ﺣﺎﻟﺔ آﻮن اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺪ ) ‪( if‬‬
                                         ‫ﺧﻄﺄ ) ‪ ( false‬ﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ اﻟﺘﻲ ﺑﻌﺪ ) ‪( else‬‬
     ‫‪END‬‬           ‫ﻧﻬﺎﺑﺔ اﻟﻌﺒﺎرات اﻟﻤﺮآﺒﻪ اﻟﺘﻲ ﺗﺒﺪأ ﺑﺎﻷﻣﺮ اﺑﺪأ ) ‪ , ( begin‬أو ﻧﻬﺎﻳﻪ‬
                             ‫) ‪( record‬‬      ‫اﻷﻣﺮ ) ‪ ( case‬أو ﻧﻬﺎﻳﻪ ﺗﻌﺮﻳﻒ اﻟﻘﻴﻮد‬
     ‫‪FILE‬‬                                                 ‫ﺗﻌﺮف ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع ﻣﻠﻒ‬
     ‫‪FOR‬‬                   ‫ﺗﻨﻔﺬ ﺳﻄﺮ أو أآﺜﺮ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻃﺎﻟﻤﺎ اﻟﻤﺘﻐﻴﺮ ﻟﻢ‬
                                                                     ‫ﻳﺼﻞ اﻟﻰ ﻧﻬﺎﻳﺘﻪ‬
     ‫‪FUNCTION‬‬                                                      ‫ﺗﻌﺮف داﻟﺔ ﺑﺎﺳﻜﺎل‬
     ‫‪GOTO‬‬                                     ‫ﺗﻔﻴﺪ ﻟﻠﺘﻔﺮع اﻟﻰ ﻋﻨﻮان ﻣﺤﺪد ) ‪( label‬‬
     ‫‪IF‬‬             ‫ﺗﻔﺤﺺ ﺷﺮط ﻣﻨﻄﻘﻲ وﺗﻨﻔﺬ اﻟﻌﺒﺎرﻩ أذا آﺎن اﻟﺸﺮط ﺻﺢ ) ‪( true‬‬
     ‫‪IN‬‬                 ‫ﺗﺤﺪد اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﻋﻠﻰ أﻧﻪ ﺻﺢ ) ‪ ( true‬أذا آﺎﻧﺖ اﻟﻘﻴﻤﻪ‬
                                                  ‫اﻟﻤﻔﺤﻮﺻﻪ ﺿﻤﻦ ﻣﺠﻤﻮﻋﻪ ﺧﺎﺻﻪ‬
     ‫‪LABEL‬‬           ‫ﺗﺤﺪد اﻟﻌﻨﻮان اﻟﺬي ﺳﻴﺘﻢ اﻟﺘﻔﺮع ﻟﻪ ﻋﻨﺪ اﺳﺘﺨﺪام اﻷﻣﺮ ) ‪( Goto‬‬
     ‫‪MOD‬‬                                              ‫ﻟﺤﺴﺎب ﺑﺎﻗﻲ ﻗﺴﻤﺔ ﻋﺪدﻳﻦ‬
     ‫‪NIL‬‬                                    ‫اﻟﻘﻴﻤﻪ اﻟﺨﺎﻟﻴﻪ ﻟﻠﻤﺆﺷﺮات ) ‪( pointers‬‬
     ‫‪NOT‬‬                                               ‫ﻟﻨﻔﻲ ﻗﻴﻢ اﻟﻌﺒﺎرات اﻟﻤﻨﻄﻘﻴﻪ‬
     ‫‪OF‬‬                          ‫ﺗﺴﺘﺨﺪم ﻓﻲ ﻋﺒﺎرة ) ‪ (case‬ﺑﻌﺪ ﻣﺘﻐﻴﺮ ) ‪( case‬‬
     ‫‪OR‬‬                                               ‫ﻣﻌﺎﻣﻞ اﻷﺧﺘﻴﺎر اﻟﻤﻨﻄﻘﻲ ) أو (‬
     ‫‪PACKED‬‬                   ‫ﻳﺴﺘﺨﺪم ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت , اﻟﻤﻠﻔﺎت , اﻟﻘﻴﻮد , واﻟﻤﺠﻤﻮﻋﺎت‬
                                                             ‫ﻟﻀﻐﻂ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺰﻧﻪ‬
     ‫‪PROCEDURE‬‬                                    ‫ﺗﻌﺮف اﻟﺮوﺗﻴﻦ اﻟﻔﺮﻋﻲ ﻓﻲ ﺑﺎﺳﻜﺎل‬
     ‫‪PROGRAM‬‬                            ‫ﻳﺴﺘﺨﺪم ﻓﻲ ﺑﺪاﻳﺔ اﻟﺒﺮﻧﺎﻣﺞ ) رأس اﻟﺒﺮﻧﺎﻣﺞ (‬
     ‫‪RECORD‬‬                                       ‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع اﻟﻘﻴﻮد‬
     ‫‪REPEAT‬‬                                               ‫ﻟﻠﺒﺪأ ﺑﺄﻣﺮ اﻟﺘﻜﺮار ) ‪(repeat‬‬
     ‫‪SET‬‬                                                         ‫ﻟﺘﻌﺮﻳﻒ اﻟﻤﺠﻤﻮﻋﺎت‬
     ‫‪THEN‬‬                                             ‫ﺗﻠﻲ اﻟﺘﻌﺒﻴﺮ اﻟﻤﻨﻄﻘﻲ ﺑﻌﺒﺎرة ) ‪( IF‬‬
     ‫‪TO‬‬          ‫ﺗﺴﺘﺨﺪم ﻓﻲ ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪ ( for‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ أن اﻟﻤﺘﻐﻴﺮ ﻳﺰداد ﻓﻲ آﻞ‬
                                                                 ‫دورﻩ ﺑﻤﻘﺪار واﺣﺪ‬
     ‫‪TYPE‬‬                                     ‫ﻟﻠﺘﺼﺮﺳﺢ ﻋﻦ ﻧﻮع ﺟﺪﻳﺪ ﻣﻦ اﻟﻤﺘﻐﻴﺮات‬
     ‫‪UNTIL‬‬                                 ‫ﻳﺴﺘﺨﺪم ﻷﻧﻬﺎء ﺣﻠﻘﺔ اﻟﺘﻜﺮار ) ‪( repeat‬‬
     ‫‪VAR‬‬                                          ‫ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ ﻣﺘﻐﻴﺮات اﻟﺒﺮﻧﺎﻣﺞ‬
     ‫‪WHILE‬‬       ‫ﻳﻨﻔﺬ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ ﺑﺸﻜﻞ ﻣﺘﻜﺮر ﻟﺤﻴﻦ أن ﻳﺼﺒﺢ اﻟﺸﺮط ) ‪( False‬‬
     ‫‪WITH‬‬                           ‫ﻟﺘﺤﺪﻳﺪ ﻣﺘﻐﻴﺮ ﻗﻴﺪ ﻳﺴﺘﺨﺪم ﻣﻊ آﺘﻠﻪ ﻣﻦ اﻷواﻣﺮ‬
30                                          ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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


         . ‫ 00224 ( اﻟﻰ ﻣﺎ ﻳﻘﺎﺑﻠﻬﺎ ﺑﺎﻟﺴﺎﻋﺎت واﻟﺪﻗﺎﺋﻖ واﻟﺜﻮاﻧﻲ‬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.
‫23‬                                                     ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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


                                                                                               ‫اﻟﻤﻘﺪﻣﻪ‬           ‫1.3‬

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

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

‫ﻳﺴﺘﺨﺪم هﺬا اﻷﻣﺮ ﺑﺎﻟﺘﺮاﻓﻖ ﻣﻊ ) ‪ ( 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‬‬

        ‫;‪End‬‬               ‫}‪{if more than one action is required‬‬

‫ﻣ ﺎذا ﻳﻌﻨ ﻲ ذﻟ ﻚ أن اﻷﻣ ﺮ ) ‪ ( 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‬وأﻧﻤﺎ ﺗﺴﺘﺨﺪم اﻟﻤﺴﺎواة اﻷﻋﺘﻴﺎدﻳﻪ ) = ( ﻷن أﺳﺘﺨﺪام‬
                                    ‫اﻷوﻟﻰ ﺳﻴﺆدي اﻟﻰ ﻋﺪم أآﻤﺎل اﻟﺘﻨﻔﻴﺬ وﻇﻬﻮر رﺳﺎﻟﺔ ﺧﻄﺄ .‬
‫43‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



‫هﻨﺎك ﺣﺎﻟﻪ أﺧﺮى ﻋﻨﺪ أﺳﺘﺨﺪام ) ‪ , ( 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‬‬
      ‫1 + ‪score := score‬‬                            ‫},‪{if this is false‬‬
     ‫‪ELSE‬‬
      ‫;)'!‪Writeln ('sorry, you've got it wrong‬‬      ‫}‪{then this is true‬‬
‫53‬                                                     ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

‫ﻣﻤﻜﻦ أن ﻧ ﺴﺘﺨﺪم ) ‪ ( 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 (this happens) then‬‬                    ‫}1 ‪{if‬‬
           ‫‪If (this happens) then‬‬                 ‫}2 ‪{if‬‬
              ‫...‪(do this) etc‬‬
           ‫)‪Else (do this‬‬                         ‫}2 ‪{if‬‬
         ‫...‪Else (do this) etc‬‬                    ‫}1 ‪{if‬‬




                                                                                         ‫ﻣﻼﺣﻈﻪ ://‬

          ‫داﺋﻤﺎ ﺗﺴﺘﺨﺪم ) ‪ ( If‬ﻋﻨﺪﻣﺎ ﻧﺤﺘﺎج أن ﻧﺨﺘﺎر ﺑﻴﻦ أآﺜﺮ ﻣﻦ ﺣﺎﻟﻪ ) أي أﺧﺘﻴﺎر ﻋﻤﻞ‬
                                              ‫أو ﺣﺎﻟﻪ واﺣﺪﻩ ﻣﻦ ﺑﻴﻦ أﺛﻨﻴﻦ أو أآﺜﺮ ( .‬
‫63‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

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

     ‫‪Repeat‬‬
        ‫; 1 ‪Instruction‬‬
       ‫; 2 ‪Instruction‬‬
       ‫…‪Etc‬‬
     ‫; ) ‪Until (condition is true‬‬


‫ﻣﺜﺎل :// هﺬا ﺑﺮﻧﺎﻣﺞ ﺑﺴﻴﻂ واﺟﺒ ﻪ أدﺧ ﺎل أﺳ ﻤﺎء اﻟﻄﻠﺒ ﻪ وﻃﺒﺎﻋﺘﻬ ﺎ , اﻟﺒﺮﻧ ﺎﻣﺞ ﻻ ﻳﺘﻮﻗ ﻒ ﻟﻐﺎﻳ ﺔ‬
                                                                              ‫أدﺧﺎل أﺳﻢ ) ﻋﻠﻲ ( .‬


 ‫;1‪Program CH3_Program‬‬

 ‫;‪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‬‬
      ‫…‬
      ‫…‬
‫73‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻣﻤﻜﻦ أن ﻳﺴﺘﻤﺮ ﺑﻌ ﺪد آﺒﻴ ﺮ ﻣ ﻦ اﻟﺨﻄ ﻮات اﻟﻤﺘ ﺸﺎﺑﻪ وﺣ ﺴﺐ ﻋ ﺪد اﻟﻄﻠﺒ ﻪ اﻟﻤ ﺮاد‬
‫ﻃﺒﺎﻋﺔ أﺳﻤﺎﺋﻬﻢ , أن اﻟﻌﺒﺎرات ) اﻗﺮأ , أذا , وأآﺘﺐ ( ﺗﺘﻜﺮر ﺑﺄﺳﺘﻤﺮار ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ , ﻟﺬا ﻓﺎن ﻟﻐ ﺔ‬
‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻟﺒﺪﻳﻞ اﻟﺬي ﻳﺴﻬﻞ اﻟﻌﻤﻞ وﻳﺨﺘﺼﺮ ﻋﺪد اﻟﺨﻄﻮات أﻻ وهﻮ ﻋﺒ ﺎرات اﻟﺘﻜ ﺮار .‬
‫واﺣ ﺪ ﻣ ﻦ ه ﺬﻩ اﻷواﻣ ﺮ ه ﻮ ) ‪ ( repeat‬وأذا ﻣ ﺎ أﻋ ﺪﻧﺎ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ أﻋ ﻼﻩ وﻟﻜ ﻦ ﻣ ﻊ أﺳ ﺘﺨﺪام‬
                                                            ‫) ‪ , ( repeat‬ﺳﻴﻨﺘﺞ ﻟﻨﺎ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ :‬

        ‫;2‪Program CH3_Program‬‬

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




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

                                         ‫‪WHILE -_DO LOOP‬‬                              ‫ﻋﺒﺎرة اﻟﺘﻜﺮار‬            ‫5.3‬

‫وه ﻮ أﻳ ﻀﺎ ﻣ ﻦ أﻳﻌ ﺎزات اﻟﺘﻜ ﺮار وه ﻮ ﻳ ﺸﺎﺑﻪ أﻟ ﻰ درﺟ ﻪ آﺒﻴ ﺮﻩ اﻷﻳﻌ ﺎز ) ‪( Repeat_until‬‬
‫ﺣﻴﺚ أن واﺟﺐ اﻷﻳﻌﺎزﻳﻦ هﻮ اﻟﺘﻜﺮار ﻟﻤﺮات ﻏﻴﺮ ﻣﺤﺪدﻩ اﺑﺘﺪاءا وأﻧﻤﺎ ﻳﻌﺘﻤﺪان ﻋﻠﻰ ﺗﺤﻘﻖ ﺷﺮط ﻣﻌﻴﻦ‬
                                           ‫ﻷﻳﻘﺎف اﻟﺘﻜﺮار , اﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻬﺬا اﻟﺘﻜﺮار هﻲ :‬

      ‫:‪While <condition is true> do the following‬‬

        ‫;1 ‪instruction‬‬

        ‫;2 ‪instruction‬‬

        ‫;3 ‪instruction‬‬

        ‫...‪etc‬‬

        ‫}‪End; {If while-do loop starts with a begin statement‬‬

‫ﻣﺎذا ﻳﻌﻨﻲ هﺬا اﻷﻣﺮ ) ﻋﻨﺪﻣﺎ ﻳﺘﺤﻘﻖ اﻟﺸﺮط أﻋﻤﻞ ﻣﺎ ﻳﻠﻲ ( وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﺳ ﻴﻨﻔﺬ اﻷﻳﻌ ﺎز اﻟ ﺬي‬
‫) ‪ ( while‬ﻟ ﻴﻔﺤﺺ اﻟ ﺸﺮط ه ﻞ ه ﻮ ﻣﺘﺤﻘ ﻖ أم ﻻ ﻓ ﺄذا آ ﺎن ﻣﺘﺤﻘ ﻖ ﻳﻨﻔ ﺬ‬      ‫ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة وﻳﻌ ﻮد اﻟ ﻰ‬
                            ‫وأن آﺎن ﻏﻴﺮ ﻣﺘﺤﻘﻖ ﺳﻴﻬﻤﻞ اﻷﻳﻌﺎز اﻟﺬي ﺑﻌﺪ ) ‪ ( while‬وﻳﻨﻔﺬ ﻣﺎ ﺑﻌﺪﻩ .‬
‫83‬                                               ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

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




                ‫اذن ﻣﺎ هﻮ اﻟﻔﺮق ﺑﻴﻦ ) ‪ ( While‬و )‪ .. (Repeat‬ﻻﺣﻆ اﻟﺠﺪول ) 1.3 ( :‬


                         ‫ﺟﺪول ) 1.3 ( : اﻟﻔﺎرق ﺑﻴﻦ أﻣﺮي اﻟﺘﻜﺮار ) ‪( repeat , while‬‬

          ‫‪Repeat_Until‬‬                                           ‫‪While_Do‬‬
                  ‫اﻟﺸﺮط ﻓﻲ ﻧﻬﺎﻳﺔ اﻟﺘﻜﺮار‬                                ‫اﻟﺸﺮط ﻓﻲ ﺑﺪاﻳﺔ اﻟﺘﻜﺮار‬
‫ﺳﻴﺘﻢ ﺗﻨﻔﻴﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻠﻰ اﻻﻗﻞ‬    ‫ﻻ ﻳﻨﻔﺬ أي أﻳﻌﺎز ﻣﺎﻟﻢ ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط وﺗﺤﻘﻘﻪ‬
            ‫ﻣﺮﻩ واﺣﺪﻩ ﻗﺒﻞ أن ﻳﺘﻢ ﻓﺤﺺ اﻟﺸﺮط‬
                 ‫ﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬        ‫ﺗﻨﻔﺬ اﻷﻳﻌﺎزات اﻟﻤﺸﻤﻮﻟﻪ ﺑﺎﻟﺘﻜﺮار ﻋﻨﺪ ﺗﺤﻘﻖ‬
                                                                                       ‫اﻟﺸﺮط‬
‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد ﺛﺎﺑﺖ‬       ‫ﻳﺴﺘﺨﺪم ﻣﻊ ﻃﻠﺒﺎت اﻟﺘﻜﺮار ﻏﻴﺮ اﻟﻤﺤﺪدﻩ ﺑﻌﺪد‬
                           ‫ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬                        ‫ﺛﺎﺑﺖ ﻣﻦ اﻟﺘﻜﺮارات ﻣﺴﺒﻘﺎ‬
     ‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬            ‫ﻳﻌﺘﻤﺪ أﺳﺘﻤﺮار اﻟﺘﻨﻔﻴﺬ ﻋﻠﻰ ﺗﺤﻘﻖ اﻟﺸﺮط‬
                ‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط‬              ‫وﻳﺘﻮﻗﻒ اﻟﺘﻨﻔﻴﺬ ﻋﻨﺪ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‬



        ‫ﻣﺜﺎل :// ﻣﺜﺎل ﺑﺴﻴﻂ ﻷدﺧﺎل ﻣﺠﻤﻮﻋﺔ أرﻗﺎم وﻃﺒﺎﻋﺘﻬﺎ ﺑﺸﺮط ﻳﺘﻢ اﻟﺘﻮﻗﻒ ﻋﻨﺪ أدﺧﺎل‬
                                                                    ‫اﻟﺮﻗﻢ ) 0 ( .‬

          ‫;3‪Program CH3_Program‬‬

          ‫;‪Var x : integer‬‬
          ‫‪Begin‬‬
            ‫;)'‪Writeln ('Enter number‬‬
            ‫;)‪Readln(x‬‬
            ‫‪While x <> 0 do‬‬
              ‫‪Begin‬‬
                ‫;)‪Writeln(x‬‬
                ‫;)‪Readln(x‬‬
              ‫;‪End‬‬
          ‫.‪End‬‬
‫93‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                               ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ://‬

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



                                                                                           ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

         ‫ﻣﻦ اﻟﺴﻬﻞ آﺘﺎﺑﺔ ﺣﻠﻘﻪ ﺑﺸﻜﻞ ﻋﻔﻮي , ﺷﺮﻃﻬﺎ ﻻ ﻳﺼﺒﺢ ﻣﺘﺤﻘﻘﺎ أﺑﺪا , هﺬا ﺳﻴﺆدي اﻟﻰ‬
                                   ‫ﺑﺮﻧﺎﻣﺞ ﻣﻘﻔﻞ أو ﻣﻐﻠﻖ أي ﻳﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ اﻟﻰ ﻣﺎﻻﻧﻬﺎﻳﻪ .‬
‫04‬                                                      ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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


‫أن ه ﺬا اﻷﻣ ﺮ ﻳﻘ ﻮم ﺑﺘﻜ ﺮار أﻳﻌ ﺎز أو ﻣﺠﻤﻮﻋ ﺔ أﻳﻌ ﺎزات ﻟﻌ ﺪد ﻣ ﻦ اﻟﻤ ﺮات اﻟﻤﺤ ﺪدﻩ ﻣ ﺴﺒﻘﺎ .‬
                          ‫واﻟﺼﻴﻐﻪ اﻟﻘﻮاﻋﺪﻳﻪ ﻟﻪ أذا آﺎن ﻳﺴﺘﺨﺪم ﻟﺘﻜﺮار أﻳﻌﺎز واﺣﺪ ﺑﻌﺪﻩ ﻣﺒﺎﺷﺮة هﻲ :‬

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




      ‫;4‪Program CH3_Program‬‬

      ‫‪Begin‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬      ‫}!!!‪{somewhat boring writing all this‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬           ‫هﺬا ﻳﻜﻮن ﳑﻞ ﻟﻜﺘﺎﺑﻪ آﻞ ذﻟﻚ‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬
        ‫‪Writeln‬‬      ‫‪('for‬‬    ‫;)'‪loop‬‬
        ‫;‪Readln‬‬
      ‫.‪End‬‬
‫14‬                                                ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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


     ‫;5‪Program CH2_Program‬‬

     ‫;‪Var Counter: Integer‬‬              ‫}‪{loop counter declared as integer‬‬

     ‫‪Begin‬‬
       ‫‪For Counter: = 1 to 7 do‬‬            ‫}!‪{it's easy and fast‬‬
         ‫;)'‪writeln ('for loop‬‬
       ‫;‪Readln‬‬
     ‫.‪End‬‬




                                                                                          ‫ﻣﻼﺣﻈﻪ ://‬

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



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

‫ﻣﻤﻜﻦ أﺳﺘﺨﺪام اﻷﻣﺮ ) ‪ ( For‬ﺑﺸﻜﻞ ﻣﺘﺪاﺧﻞ وﻷآﺜﺮ ﻣﻦ ﻣﺮﻩ وﺑﻬﺬﻩ اﻟﺤﺎﻟﻪ ﻓ ﺎن ﺣﻠﻘ ﺔ ) ‪( For‬‬
‫ﺗﻜﺮر آﺎﻣﻠﺔ ﺑﻌﺪد ﻣﺮات اﻟﺘﻜﺮار اﻟﻤﺤﺪدﻩ ﻓﻲ ) ‪ ( For‬اﻟﺨﺎرﺟﻲ . ﻓﻤﺜﻼ ﻟﻮ آﺎن ﻟ ﺪﻳﻨﺎ ﻋ ﺪد ﻣ ﻦ اﻟﻄ ﻼب‬
‫ﻓﻲ ﺻﻒ ﻣﻌﻴﻦ ) 03 ﻃﺎﻟﺐ ﻣﺜﻼ ( وﻧﺮﻏﺐ أن ﻧﻄﺒﻊ أﺳﻤﺎء اﻟﻄﻠﺒﻪ ﻣﻊ اﻟﺪرﺟﺎت اﻟﺘﻲ ﺣﺼﻞ ﻋﻠﻴﻬ ﺎ آ ﻞ‬
‫ﻣﻨﻬﻢ ﻓﻲ آﻞ اﻟ ﺪروس اﻟﺘ ﻲ ﻳﺪرﺳ ﻮهﺎ ﻓ ﻲ ﺗﻠ ﻚ اﻟﻤﺮﺣﻠ ﻪ ) 8 دروس ﻣ ﺜﻼ ( . هﻨ ﺎ ﻳﺠ ﺐ ﻃﺒﺎﻋ ﺔ أﺳ ﻤﺎء‬
‫اﻟﻄﻠﺒﻪ وهﻲ 03 أي أن أﻣﺮ اﻟﻄﺒﺎﻋﻪ ﺳﻴﻜﺮر 03 ﻣﺮﻩ ﻟﺬا ﻧﺴﺘﺨﺪم ) ‪ ( for‬ﻟﻬﺬا اﻟﻐﺮض ﻷن ﻋﺪد ﻣﺮات‬
‫اﻟﺘﻜﺮار ﻣﺤﺪد , وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ) أي ﻟﻜ ﻞ ﻃﺎﻟ ﺐ ( ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ اﻟ ﺪرﺟﺎت ) 8 درﺟ ﺎت ( أي أن أﻣ ﺮ‬
‫ﻃﺒﺎﻋﺔ اﻟﺪرﺟﺎت ﻳﻜﺮر 8 ﻣﺮات ﻋﻠﻴﻪ ﻧﺴﺘﺨﺪم ) ‪ ( For‬أﻳﻀﺎ ﻟﻄﺒﺎﻋ ﺔ اﻟ ﺪرﺟﺎت ﻟﻜ ﻞ ﻃﺎﻟ ﺐ , وﺳ ﻴﻜﻮن‬
                                                                            ‫اﻟﺒﺮﻧﺎﻣﺞ آﻤﺎ ﻳﻠﻲ :‬

 ‫;6‪Program CH3_Program‬‬
 ‫‪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‬‬
           ‫; ) 5:‪Write (degree‬‬
         ‫} ‪End; {second for‬‬
     ‫;‪End‬‬     ‫} ‪{first for‬‬
 ‫.‪End‬‬
‫24‬                                                       ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                    ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ://‬

‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻓﺄن ) ‪ ( for‬اﻷوﻟﻰ ﺗﺴﺘﺨﺪم ﻟﻄﺒﺎﻋﺔ أﺳﻤﺎء اﻟﻄﻠﺒﻪ , وﻟﻤﺎ آﺎن آ ﻞ ﻃﺎﻟ ﺐ ﻟ ﻪ‬
‫8 درﺟ ﺎت ﻓ ﺄن أﻣ ﺮ ﺗﻜ ﺮار ﻟﻬ ﺬﻩ اﻟ ﺪرﺟﺎت ﺳ ﻴﻜﻮن ﻣ ﻦ ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ) أي ﻋﻨ ﺪ ﻃﺒﺎﻋ ﺔ أﺳ ﻢ‬
‫ﻃﺎﻟ ﺐ ﻣﻌ ﻴﻦ ﻳﺠ ﺐ أن ﻧﻄﺒ ﻊ ﻣﻌ ﻪ درﺟﺎﺗ ﻪ اﻟﺜﻤ ﺎﻧﻲ ﻗﺒ ﻞ اﻷﻧﺘﻘ ﺎل اﻟ ﻰ اﻟﻄﺎﻟ ﺐ اﻟﺘ ﺎﻟﻲ ( . وﺑﻤ ﺎ أن ﻋ ﺪد‬
‫اﻟﺨﻄ ﻮات اﻟﻤ ﺸﻤﻮﻟﻪ ﺑ ﺎﻟﺘﻜﺮار ﺿ ﻤﻦ ) ‪ ( for‬اﻷوﻟ ﻰ ه ﻲ أآﺜ ﺮ ﻣ ﻦ واﺣ ﺪﻩ ﻟ ﺬا ﺗ ﻢ ﺗﺤﺪﻳ ﺪهﺎ ﺑ ﻴﻦ‬
‫) ‪ ( begin , end‬وﻧﻔ ﺲ اﻟ ﺸﻲء ﺑﺎﻟﻨ ﺴﺒﻪ ﻟﻸﻣ ﺮ ) ‪ ( for‬اﻟﺜﺎﻧﻴ ﻪ . وﻓ ﻲ آ ﻞ ﻣ ﺮﻩ ﻧﻨﻔ ﺬ ) ‪ ( for‬اﻷوﻟ ﻰ‬
‫ﺳﻨﻨﻔﺬ ) ‪ ( for‬اﻟﺜﺎﻧﻴﻪ آﺎﻣﻠﺔ ﻗﺒﻞ أن ﻧﻨﺘﻘﻞ اﻟﻰ زﻳﺎدة اﻟﻌ ﺪاد ) ‪ ) ( I‬أي أن اﻟﻌ ﺪاد ) ‪ ( j‬ﻳﺒ ﺪأ ﺑﻘﻴﻤ ﺔ اﻟﺒﺪاﻳ ﻪ‬
‫وﻳﺴﺘﻤﺮ ﺑﺎﻟﻌﻤﻞ ﺣﺘﻰ ﻳﻨﺘﻬﻲ ﺑﻘﻴﻤﺔ اﻟﻨﻬﺎﻳﻪ ﻓﻲ آﻞ زﻳﺎدﻩ ﻟﻠﻌﺪاد ) ‪ .( ( I‬هﺬا ﻣﺸﺎﺑﻪ ﻟﻌﻘ ﺎرب اﻟ ﺴﺎﻋﻪ ﻓﻠﻜ ﻲ‬
‫ﻳﺘﺤﺮك ﻋﻘﺮب اﻟﺴﺎﻋﺎت ﺧﻄﻮﻩ واﺣﺪﻩ ﻓﺄن ﻋﻘﺮب اﻟﺪﻗﺎﺋﻖ ﻳﺠﺐ أن ﻳﺘﺤﺮك 06 ﺧﻄ ﻮﻩ , وآﺄﻧﻤ ﺎ ﻋﻘ ﺮب‬
‫) ‪ ( 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‬ﻟﻴﺒﺪأ ﺑﺘﻜﺮار ﺟﺪﻳﺪ .‬
‫34‬                                               ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

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




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

‫ﻓﻲ ﺑﻌﺾ اﻻﺣﻴﺎن ﺗﺴﺘﺨﺪم ) ‪ ( 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‬‬



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




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




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




                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                                                 ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ://‬

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




                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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



     ‫; 9‪Program CH3_Program‬‬
     ‫‪Var‬‬
       ‫; ‪num1, num2 : integer‬‬
       ‫;‪Ch: char‬‬
       ‫;‪Result: real‬‬
     ‫‪Begin‬‬
       ‫; )' ‪Writeln (' enter two numbers‬‬
       ‫;)2‪Readln (num1, num‬‬
       ‫" ,/ ,* , - ,+ " ‪Writeln (' enter one of operators‬‬                                ‫;)'‬
       ‫;)‪Readln (ch‬‬
       ‫‪Case ch of‬‬
         ‫;2‪'+ ': result: = num1 + num‬‬
         ‫;2‪'– ': result: = num1 – num‬‬
         ‫;2‪'* ': result: = num1 * num‬‬
         ‫;2‪'/ ': result: = num1 / num‬‬
         ‫‪Else‬‬
           ‫;)' ‪Writeln (' Error in entering operator‬‬
       ‫;‪End‬‬
       ‫;)‪Writeln (result‬‬
     ‫.‪End‬‬
‫74‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                               ‫ﺟﻤﻠﺔ ‪IN‬‬             ‫9.3‬

                       ‫ﺗﺴﺘﺨﺪم ﺟﻤﻠﺔ ) ‪ ( in‬ﻓﻲ اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﻪ أﺳﺘﺨﺪاﻣﺎت ﻣﺨﺘﻠﻔﻪ وهﻲ :‬

          ‫أوﻻ :// ﻟﺘﺤﺪﻳﺪ اﻟﻤﺪى اﻟﺬي ﻳﻌﻤﻞ ﺑﻪ ﻣﺘﻐﻴﺮ ﻣﻌﻴﻦ وﻟﺘﻮﺿﻴﺢ ذﻟﻚ ﻟﻨﺮى اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ :‬

            ‫‪If ( degree > = 90 ) And ( degree <= 100 ) then‬‬
              ‫; ) ' ‪Writeln ( ' Excellent‬‬

‫ﻧﻼﺣﻆ أن اﻟﺸﺮط ﻓﻲ اﻟﻤﺜﺎل ﻳﺤ ﺪد اﻟﺪرﺟ ﻪ ﺑ ﻴﻦ ) 09 ﻟﻐﺎﻳ ﺔ 001 ( ﻟﻴﻌﻄ ﻲ درﺟ ﺔ اﻷﻣﺘﻴ ﺎز,‬
                ‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﻪ اﻟﺸﺮط أﻋﻼﻩ ﺑﺄﺳﺘﺨﺪام أﻳﻌﺎز ﺗﺤﺪﻳﺪ اﻟﻤﺪى ) ‪ , ( 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 ' ) ;




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


                                         . ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﺑﻴﻦ رﻗﻤﻴﻦ‬                         •

     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 ) ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد ﻗﻴﻤﺔ‬                          •

                Z = 5x2 +3x/y        when x >= y
      and       Z = y2 – 3x          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.




                       . ‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد أآﺒﺮ وأﺻﻐﺮ ﻋﺪد ﻣﻦ ﺑﻴﻦ ) 51 ( ﻋﺪد‬                             •

     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) ‫2745 ﻓﺄن ﻣﺠﻤﻮع أرﻗﺎﻣﻪ هﻲ )81( واﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻴﻪ هﻮ‬

          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.
‫35‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                     ‫اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‬

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

                                                                                                ‫اﻟﻤﻘﺪﻣﻪ‬         ‫1.4‬

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

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

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



                                                                                               ‫اﻟﻤﺼﻔﻮﻓﺎت ://‬

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



‫ﺑﺸﻜﻞ ﻋﺎم ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﻧﻮﻋﺎن ) هﻨﺎك ﻣﺼﻔﻮﻓﺎت ﻣﺘﻌﺪدﻩ اﻟﻤ ﺴﺘﻮﻳﺎت ه ﻲ ﺧ ﺎرج ﻧﻄ ﺎق ه ﺬا‬
                                                  ‫اﻟﻜﺘﺎب ( , ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ وﻣﺼﻔﻮﻓﻪ ﺛﻨﺎﺋﻴﻪ .‬

                               ‫1.2.4 اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ‪: ONE DIMENSION ARRAY‬‬

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



‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﺼﻤﻤﻪ ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴﺮﻩ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻧﻔﺲ اﻟﻨﻮع ﺑﻄﺮﻳﻘﻪ ﻣﻨﻈﻤﻪ . أن أﺳﺘﺨﺪام‬
‫اﻟﻤﺼﻔﻮﻓﻪ ﻳﺴﻤﺢ ﺑﺤﺠﺰ ﻣﺠﻤﻮﻋ ﻪ ﻣ ﻦ ﻣﻮاﻗ ﻊ اﻟ ﺬاآﺮﻩ اﻟﻤﺘﺘﺎﻟﻴ ﻪ واﻟﺘ ﻲ ﻳﻤﻜﻨﻨ ﺎ ﻣﻌﺎﻟﺠﺘﻬ ﺎ آﻜﺘﻠ ﻪ واﺣ ﺪﻩ أو‬
                                                                                    ‫ﻣﻜﻮﻧﺎت ﻣﻨﻔﺼﻠﻪ .‬
‫أذن اﻟﻤ ﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳ ﻪ ه ﻲ اﻟﺘ ﻲ ﻣ ﻦ اﻟﻤﻤﻜ ﻦ آﺘﺎﺑ ﺔ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻒ أو ﻋﻤ ﻮد‬
‫واﺣﺪ وﻳﻜﻮن ﻋﺪد اﻟﻌﻨﺎﺻﺮ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ اﻟ ﺬاآﺮﻩ ﻟﺨ ﺰن ه ﺬﻩ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴﻬ ﺎ ﻣ ﺴﺎوﻳﺎ اﻟ ﻰ‬
                                                                                     ‫ﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ .‬

                                                ‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻳﺎﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ :‬

 ‫;>‪<arrayName> : Array [n..m] Of <Data Type‬‬

                                                       ‫ﻣﻤﻜﻦ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات ﺗﺄﺧﺬ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ :‬

        ‫‪Var‬‬

        ‫;‪myArray : Array [1..20] of Integer‬‬

                               ‫ﺣﻴﺚ ﻳﺘﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ ﻓﻲ ﺣﻘﻞ اﻟﻤﺘﻐﻴﺮات وﻳﻜﻮن :‬

‫أوﻻ :// ﺑﺄﻋﻄ ﺎء أﺳ ﻢ ﻟﻠﻤ ﺼﻔﻮﻓﻪ هﻨ ﺎ ) ‪ ( myarray‬وه ﻮ ﻣﺘﻐﻴ ﺮ وﻳ ﺘﻢ أﺧﺘﻴ ﺎرﻩ ﻣ ﻦ ﻗﺒ ﻞ‬
                                  ‫اﻟﻤﺒﺮﻣﺞ , ﺛﻢ ﺗﺄﺗﻲ اﻟﻨﻘﻄﺘﺎن اﻟﻤﺘﻌﺎﻣﺪﺗﺎن آﻤﺎ ﻓﻲ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات .‬

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

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

‫ﻟﻨﺄﺧﺬ اﻟﻤﺜﺎل أﻋﻼﻩ واﻟﺬي أﻋﻠﻨﺎ ﻓﻴﻪ ﻋﻦ ﻋﺸﺮﻳﻦ ﻋﻨﺼﺮ ﻓﺄﻧﻨﺎ ﻳﻤﻜﻨﻨ ﺎ اﻟﻮﺻ ﻮل اﻟ ﻰ آ ﻞ ﻋﻨ ﺼﺮ‬
                                                                             ‫ﻓﻴﻬﺎ وآﻤﺎ ﻳﻠﻲ :‬

                                              ‫أوﻻ : // أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ :‬
‫55‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



‫ﺣﻴﺚ ﻳﻤﻜﻦ أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع اﻷﻋﺪاد اﻟﺼﺤﻴﺤﻪ ) ﺣ ﺴﺐ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ ( ﻷي ﻋﻨ ﺼﺮ‬
‫ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ وذﻟﻚ ﻣﻦ ﺧﻼل ﺗﺤﺪﻳﺪ رﻗﻢ أو ﺗﺴﻠﺴﻞ اﻟﻌﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ ﺛﻢ اﻟﻤﺴﺎواة ﻣ ﻊ اﻟﻘﻴﻤ ﻪ اﻟﺘ ﻲ‬
                           ‫ﻣﻦ اﻟﻤﻔﺘﺮض وﺿﻌﻬﺎ ﻓﻴﻪ ) أو ﻣﻦ ﺧﻼل أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ ( وآﻤﺎ ﻳﻠﻲ :‬

        ‫>‪<arrayName> [index] := <relevant data‬‬

            ‫;01 =: ]5[‪myArray‬‬
            ‫;52 =: ]1[‪myArray‬‬
         ‫‪OR‬‬
          ‫; ) ]1[‪Readln ( myArray‬‬
         ‫هﻨﺎ ﺗﻢ أﺳﻨﺎد اﻟﻘﻴﻤﻪ ) 01 ( اﻟﻰ اﻟﻤﺘﻐﻴﺮ أو اﻟﻤﻮﻗ ﻊ اﻟﺨ ﺎﻣﺲ ) ﻻﺣ ﻆ آﻴﻔﻴ ﺔ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻣﻮﻗ ﻊ‬
‫اﻟﻌﻨﺼﺮ, ﻳﻮﺿﻊ رﻗﻢ اﻟﻤﻮﻗ ﻊ ﺑ ﻴﻦ ﻗﻮﺳ ﻴﻦ ﻣ ﺮﺑﻌﻴﻦ ( ﺑﻴﻨﻤ ﺎ ﺗ ﻢ أﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) 52 ( اﻟ ﻰ اﻟﻤﻮﻗ ﻊ اﻷول‬
‫وﺳﺘﺒﻘﻰ هﺬﻩ اﻟﻘﻴﻢ ﻟﻬﺬﻩ اﻟﻤﻮاﻗﻊ أﻻ أذا ﺗﻢ ﺗﻐﻴﻴﺮهﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ , ﻓﻌﻨ ﺪﻣﺎ ﻧﺮﻳ ﺪ ﻃﺒﺎﻋ ﺔ ﻣﺤﺘﻮﻳ ﺎت اﻟﻤﻮﻗ ﻊ‬
‫اﻷول ﻓﺴﻨﺠﺪ ﻓﻴﻪ اﻟﻘﻴﻤﻪ ) 52 (. أن ﻃﺮﻳﻘﺔ أدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻄ ﺮق اﻟﺘ ﻰ‬
‫ﺳﺒﻖ وأن ﺑﻴﻨﺎهﺎ ﻷدﺧﺎل ﺑﻴﺎﻧﺎت اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ . ﻟﻨﻼﺣﻆ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ :‬


          ‫; 1‪Program CH4_Program‬‬
          ‫‪Var‬‬
            ‫‪myVar‬‬   ‫;‪: Integer‬‬
            ‫;‪myArray : Array[1..5] of Integer‬‬
          ‫‪Begin‬‬
            ‫;52 =: ]2[‪myArray‬‬
            ‫;]2[‪myVar := myArray‬‬
          ‫.‪End‬‬




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

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

‫ﺳﺘﺆول هﺬﻩ اﻟﻘﻴﻤﻪ اﻟﻰ اﻟﻄﺮف اﻷﻳﺴﺮ ﻣﻦ اﻟﻤﻌﺎدﻟ ﻪ ) أي أن اﻟﻤﺘﻐﻴ ﺮ ‪ myvar‬ﺗﻜ ﻮن ﻗﻴﻤﺘ ﻪ‬                                 ‫•‬
                ‫هﻲ 52 ( . وهﻲ ﻧﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻧﺘﻌﺎﻣﻞ ﺑﻬﺎ ﻣﻊ اﻟﻤﺘﻐﻴﺮات اﻷﻋﺘﻴﺎدﻳﻪ.‬

                           ‫ﺛﺎﻧﻴﺎ :// أﺳﻨﺎد ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬

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



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


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




                                                                   ‫ﺛﺎﻟﺜﺎ :// ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ‬

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



         ‫;3‪Program CH4_Program‬‬
         ‫‪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‬‬




                                                                                            ‫ﻣﻼﺣﻈﻪ :‬

          ‫اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ هﻲ ذات اﻟﻌﻤﻠﻴﺎت اﻟﺮﻳﺎﺿﻴﻪ‬
          ‫اﻟﺘﻲ ﺗﺠﺮى ﻋﻠﻰ ذﻟﻚ اﻟﻨﻮع ) ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻌﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ اﻟﻤﻌﻠﻦ ﻋﻨﻪ ﻓﻲ ﺣﻘﻞ‬
                                                            ‫اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ( .‬
‫75‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

‫اﻟﻤﺼﻔﻮﻓﻪ ﻣﻔﻴﺪﻩ ﺟﺪا ﻟﺤﻤﻞ آﻤﻴﻪ آﺒﻴ ﺆﻩ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت , واﺣ ﺪﻩ ﻣ ﻦ ﺳ ﻠﺒﻴﺎت أﺳ ﺘﺨﺪام اﻟﻤ ﺼﻔﻮﻓﻪ‬
‫ه ﻲ أﺣﺘﻴﺎﺟﻬ ﺎ اﻟ ﻰ آﻤﻴ ﻪ آﺒﻴ ﺮﻩ ﻣ ﻦ اﻟ ﺬاآﺮﻩ , ﻋﻤﻠﻴ ﺎ اﻟﻤ ﺼﻔﻮﻓﻪ ﻣ ﻦ ﻧ ﻮع اﻷﺣ ﺮف ) اﻟﺘ ﻲ ﻋﻨﺎﺻ ﺮهﺎ‬
               ‫ﺣﺮوف ( ﺗﺤﺠﺰ ذاآﺮﻩ أآﺒﺮ ﻣﻦ اﻷﻧﻮاع اﻷﺧﺮى .. ﻟﺸﺮح ذﻟﻚ ﻟﻨﺮى اﻟﺘﻌﺮﻳﻒ اﻟﺘﺎﻟﻲ :‬

     ‫‪Var‬‬
       ‫; ‪X : array [ 1..5 ] of char‬‬

 ‫ﺑﺎﻟﺘﺄآﻴﺪ ﻓﺄن هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﺤﺠﺰ ﻋﺪد ﻣﻦ اﻟﻤﻮاﻗﻊ ﻓﻲ اﻟﺬاآﺮﻩ ﺑﻤﺎ ﻳﺘﻨﺎﺳﺐ وﺣﺠﻢ اﻟﻤﺼﻔﻮﻓﻪ ,‬
‫هﻨﺎ ﺳﻴﺘﻢ ﺣﺠﺰ ﺧﻤﺴﺔ ﻣﻮاﻗﻊ ) ﻣﻮﻗﻊ ﻟﻜﻞ ﻋﻨﺼﺮ ( وﻟﻤﺎ آﺎن ﻧﻮع اﻟﻌﻨﺎﺻﺮ ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻲ ﻓﺴﻴﻌﺎﻣﻞ‬
‫آﻞ ﺣﺮف آﻜﻠﻤﻪ ) ‪ ( word‬ﻓﻲ اﻟﺬاآﺮﻩ , وآﻞ آﻠﻤﻪ ﺗﺘﻜﻮن ﻣﻦ ﻋﺪد ﻣﻦ اﻟﺒﺎﻳﺘﺎت . ﻟﻮ ﻓﺮﺿﻨﺎ أن اﻟﻜﻠﻤﻪ‬
                               ‫ﺗﺘﻜﻮن ﻣﻦ أرﺑﻊ ﺑﺎﻳﺘﺎت ﻓﺄن اﻟﻤﺼﻔﻮﻓﻪ ﺳﺘﺤﺠﺰ ) 02 ( ﺑﺎﻳﺖ آﻤﺎ ﻳﻠﻲ :‬




         ‫ﻓﺄذا أﺳﻨﺪﻧﺎ آﻠﻤﺔ ) ‪ ( HELLO‬آﻌﻨﺎﺻﺮ ﻟﻠﻤﺼﻔﻮﻓﻪ ﻓﺴﺘﻜﻮن اﻟﻤﺼﻔﻮﻓﻪ ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ :‬

                                   ‫‪H‬‬
                                   ‫‪E‬‬
                                   ‫‪L‬‬
                                   ‫‪L‬‬
                                   ‫‪O‬‬

   ‫ﻧﻼﺣﻆ أن هﻨﺎك ﺧﻤﺴﺔ ﻋﺸﺮ ﺑﺎﻳﺖ ﻏﻴﺮ ﻣﺴﺘﻐﻠﻪ , وهﺬا ﺳﻮء أﺳﺘﺨﺪام ﻟﻠﺬاآﺮﻩ , ﻟﺬا ﻓﺄن ﻟﻐﺔ‬
 ‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل أوﺟﺪت اﻷﻳﻌﺎز ) ‪ ( Packed Array‬ﻟﺘﺤﺪد اﻟﻤﺴﺎﺣﻪ اﻟﺨﺰﻧﻴﻪ ﺑﺄﻗﻞ ﺣﺠﻢ ﻣﻤﻜﻦ وآﻤﺎ‬
                                                                                  ‫ﻳﻠﻲ :‬

     ‫‪Var‬‬
      ‫; ‪X : packed array [ 1..5 ] of char‬‬

‫هﺬا اﻟﺘﻌﺮﻳﻒ ﺳﻴﻮﻟﺪ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘﺎﻟﻴﻪ ﺑﻌﺪ أﺳﻨﺎد اﻟﻜﻠﻤﻪ ) ‪ ( HELLO‬اﻟﻰ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ:‬


     ‫‪H‬‬           ‫‪E‬‬          ‫‪L‬‬           ‫‪L‬‬           ‫‪O‬‬

                                              ‫هﻨﺎ ﺗﻢ أﺳﺘﺨﺪام آﻠﻤﺘﻴﻦ ﻓﻘﻂ ) أي 8 ﺑﺎﻳﺖ ( .‬
‫85‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                     ‫2.2.4 اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ‪: 2-D ARRAY‬‬

‫اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ هﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺘ ﻲ ﺗﻜﺘ ﺐ ﻋﻨﺎﺻ ﺮهﺎ ﻋﻠ ﻰ ﺷ ﻜﻞ ﺻ ﻔﻮف وأﻋﻤ ﺪﻩ ﻓ ﻲ ذات‬
‫اﻟﻮﻗﺖ ) أي ﻳﻜﻮن هﻨﺎك ﻋﺪد ﻣﻦ اﻟﺼﻔﻮف وآﻞ ﺻﻒ ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻ ﺮ وآ ﺬﻟﻚ ﻋ ﺪد ﻣ ﻦ اﻷﻋﻤ ﺪﻩ‬
‫وآﻞ ﻋﻤﻮد ﻓﻴﻪ ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ ( , أن ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ وﺑﺎﻟﺘﺎﻟﻲ ﻋ ﺪد اﻟﻤﻮاﻗ ﻊ ﻓ ﻲ‬
‫اﻟﺬاآﺮﻩ ﻳﺴﺎوي ﺣﺎﺻﻞ ﺿﺮب ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ . ﻳ ﺘﻢ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤ ﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ‬
‫ﺑﻨﻔﺲ اﻟﻄﺮﻳﻘﻪ اﻟﺘﻲ ﻳﺘﻢ ﻓﻴﻬﺎ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﻪ اﻷﺣﺎدﻳﻪ ﻣﻊ ﻓﺎرق واﺣﺪ ﻓﻘﻂ وهﻮ أن اﻷﻋ ﻼن ﻋ ﻦ‬
‫ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻳﺘﻢ ﻣﻦ ﺧﻼل ﻗﻴﻤﺘﻴﻦ داﺧﻞ اﻟﻘﻮﺳﻴﻦ اﻟﻤﺮﺑﻌﻴﻦ ﺗﻔ ﺼﻞ ﺑﻴﻨﻬﻤ ﺎ ﻓ ﺎرزﻩ‬
‫آ ﻞ واﺣ ﺪﻩ ﻟﻬ ﺎ اﻟﻤ ﺪى اﻟﺨ ﺎص ﺑﻬ ﺎ وﻟ ﻴﺲ ﻗﻴﻤ ﻪ واﺣ ﺪﻩ آﻤ ﺎ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ وﻳﺤﺘ ﻮي اﻟﻤ ﺪى‬
‫اﻷول ﻋﻠﻰ ﻋﺪد اﻟﺼﻔﻮف ﺗﺒﺪأ ﻣﻦ اﻟﺮﻗﻢ واﺣﺪ وﺗﻨﺘﻬﻲ ﺑﺎﻟﺮﻗﻢ اﻟﺬي ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻜﻠ ﻲ ﻟﻠ ﺼﻔﻮف ) وه ﻲ‬
‫ﺗﻤﺜﻞ ﻋﺪد اﻟﻌﻨﺎﺻﺮ ﻓﻲ اﻟﻌﻤﻮد اﻟﻮاﺣﺪ ( , أﻣﺎ اﻟﻤﺪى اﻟﺜﺎﻧﻲ ﻓﻴﺤﺘﻮي ﻋﻠﻰ ﻋ ﺪد اﻷﻋﻤ ﺪﻩ وﺑ ﻨﻔﺲ اﻟﻄﺮﻳﻘ ﻪ‬
‫اﻟﻤﺴﺘﺨﺪﻣﻪ ﻟﻌﺪد اﻟﺼﻔﻮف ) وهﻲ ﺗﻤﺜ ﻞ ﻋ ﺪد اﻟﻌﻨﺎﺻ ﺮ ﻓ ﻲ اﻟ ﺼﻒ اﻟﻮاﺣ ﺪ (. أﻣ ﺎ اﻷﺷ ﺎرﻩ اﻟ ﻰ ﻋﻨ ﺼﺮ‬
‫ﻣﻌ ﻴﻦ ﻓ ﻲ اﻟﻤ ﺼﻔﻮﻓﻪ ﻓﻴ ﺘﻢ ﻣ ﻦ ﺧ ﻼل أﺳ ﻢ اﻟﻤ ﺼﻔﻮﻓﻪ وﻗ ﻮس ﻣﺮﺑ ﻊ ﻳﺤﺘ ﻮي ﻗﻴﻤﺘ ﻴﻦ اﻷوﻟ ﻰ ﺗﻤﺜ ﻞ رﻗ ﻢ‬
     ‫اﻟﺼﻒ واﻟﺜﺎﻧﻴﻪ ﺗﻤﺜﻞ رﻗﻢ اﻟﻌﻤﻮد ) وﻻ ﻳﺠﻮز أن ﺗﻜﻮن اﻟﻘﻴﻤﻪ اﻷوﻟﻰ ﻟﻸﻋﻤﺪﻩ واﻟﺜﺎﻧﻴﻪ ﻟﻠﺼﻔﻮف (.‬

                                          ‫ﻃﺮﻳﻘﺔ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ آﻤﺎ ﻳﻠﻲ :‬

          ‫;>‪my2DArray : Array [ 1..i , 1..j ] of <DataType‬‬


‫هﻲ ذات اﻟﻄﺮﻳﻘﻪ اﻟﻤﺴﺘﺨﺪﻣﻪ ﻓﻲ اﻷﻋﻼن ﻋﻦ اﻟﻤﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳﻪ ﻋ ﺪا اﻟﻔ ﺮق اﻟ ﺬي ﺳ ﺒﻖ أن‬
                                                                                 ‫أﺷﺮﻧﺎ اﻟﻴﻪ .‬
                ‫ﺗﻤﺜﻴﻞ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ) 5 ‪ ( 5 x‬ﻣﻨﻄﻘﻴﺎ ﻳﻜﻮن ﻋﻠﻰ ﺷﻜﻞ ﺷﺒﻜﻪ آﻤﺎ ﻳﻠﻲ :‬



                       ‫1‬           ‫2‬           ‫3‬                  ‫4‬                   ‫5‬
                       ‫2‬
                       ‫3‬                                          ‫4,3‬
                       ‫4‬
                       ‫5‬                       ‫3,5‬                                    ‫5,5‬


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



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

‫أن اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺼﻔﻮﻓﺎت اﻟﺜﻨﺎﺋﻴﻪ ﻣﺸﺎﺑﻪ ﻟﻄﺮﻳﻘﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤ ﺼﻔﻮﻓﺎت اﻷﺣﺎدﻳ ﻪ ﻣ ﻊ اﻷﺧ ﺬ‬
                                                    ‫ﺑﻨﻈﺮ اﻷﻋﺘﺒﺎر ﺧﺼﻮﺻﻴﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ .‬

                                              ‫أوﻻ :// أﺳﻨﺎد ﻗﻴﻢ ﻟﺒﻌﺾ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ‬

                           ‫وﻳﺘﻢ ذﻟﻚ أﻣﺎ ﺑﺄﺳﺘﺨﺪام اﻟﻤﺴﺎواة أو أﺳﺘﺨﺪام أﻳﻌﺎز اﻟﻘﺮاءﻩ , ﻣﺜﺎل‬

‫;44 =: ]4 ,3[ ‪My2DArray‬‬
‫;02 =: ]3 ,5[ ‪My2DArray‬‬

‫‪OR‬‬
‫;)]2 ,1[ ‪Readln (My2DArray‬‬

‫ﺣﻴﺚ ﺳﻴﺘﻢ وﺿﻊ اﻟﻘﻴﻤﻪ )44( ﻓﻲ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺘﻘﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺜﺎﻟ ﺚ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺮاﺑ ﻊ ,‬
‫وﺗﻮﺿﻊ اﻟﻘﻴﻤﻪ )02( ﻓﻲ اﻟﻤﻮﻗ ﻊ اﻟ ﺬي ﻳﺘﻘ ﺎﻃﻊ ﻓﻴ ﻪ اﻟ ﺼﻒ اﻟﺨ ﺎﻣﺲ ﻣ ﻊ اﻟﻌﻤ ﻮد اﻟﺜﺎﻟ ﺚ ) ﻻﺣ ﻆ اﻟ ﺸﻜﻞ‬
                                                   ‫أﻋﻼﻩ ( . أﻣﺎ آﻴﻔﻴﺔ اﻷﻋﻼن ﻋﻨﻬﺎ ﺑﺮﻣﺠﻴﺎ ﻳﻜﻮن :‬



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




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


                          ‫1‬           ‫2‬           ‫3‬               ‫4‬                  ‫5‬

                          ‫2‬                                       ‫01‬
                          ‫3‬


                          ‫ﺛﺎﻧﻴﺎ :// أدﺧﺎل ﻗﻴﻢ ﻟﻜﺎﻓﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﻪ ) ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ (‬

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




         ‫;5‪Program CH4_Program‬‬
         ‫‪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 ( ﻟﻨﺘﻌﻠﻢ اﻟﻄﺮﻳﻘﺘﻴﻦ .‬

                                                          ‫ﺛﺎﻟﺜﺎ :// ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ‬

‫ﺗﺘﻢ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﺑﻨﻔﺲ ﻃﺮﻳﻘﺔ ﻗﺮاءة اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴ ﻪ ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أﺳ ﺘﺒﺪال أﻣ ﺮ‬
                                                      ‫اﻟﻘﺮاءﻩ ﺑﺄﻣﺮ اﻟﻄﺒﺎﻋﻪ , ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ :‬

         ‫;6‪Program CH4_Program‬‬
         ‫‪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‬ﻓﺄﻧﻪ ﺳﻴﻄﺒﻊ آﻞ اﻟﻘﻴﻢ ﻋﻠﻰ ذات اﻟﺴﻄﺮ( , أذن آﻴﻒ ﻳﻤﻜﻨﻨﺎ ﻃﺒﺎﻋﺔ اﻟﻤﺼﻔﻮﻓﻪ اﻟﺜﻨﺎﺋﻴﻪ ﻋﻠ ﻰ‬
                                                              ‫ﺷﻜﻞ ﺷﺒﻜﻪ , ﻻﺣﻆ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ :‬

         ‫;7‪Program CH4_Program‬‬
         ‫‪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‬‬
‫16‬                                                        ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                                     ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ://‬

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




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

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



           ‫;8‪Program CH4_Program‬‬
           ‫‪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‬‬
               ‫;)7:]‪Write (a[i‬‬
           ‫.‪End‬‬
62                                                ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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




         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.




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


             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                                                ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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



             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.




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


             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.




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




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


           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                                               ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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


             Program CH4_Program15;
             Var
               A: array [1..3, 1..4] of         integer;
               B: array [1..4, 1..5] of         integer;
               C: array [1..3, 1..5] of         integer;
               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]         + a [k, j]* b[j,i];
                 End;
               For i: =1 to 3 do
                 Begin
                   For j: =1 to 5 do
                     Write(c [I, j]);
                   Writeln;
                 End;
             End.
‫66‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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


                                                                                              ‫اﻟﻤﻘﺪﻣﻪ‬         ‫1.5‬

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


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


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

‫ﻣ ﻦ اﻟﻤﻬ ﻢ ﺟ ﺪا أن ﻳﻜ ﻮن ﺣﺠ ﻢ اﻟﺒﺮﻧ ﺎﻣﺞ ﺻ ﻐﻴﺮ . أن آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ‬     ‫1.‬
‫أﺟﺮاءات أو دوال ) ﺳﻨﺄﺗﻲ ﻋﻠﻴﻬﺎ ﻻﺣﻘﺎ ( ﻳﺴﺎﻋﺪ اﻟﻰ درﺟﻪ آﺒﻴﺮﻩ اﻟﻰ ﺗﻘﻠﻴﻞ ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺸﻜﻞ ﻋﺎم .‬

‫أن آﺘﺎﺑﻪ اﻟﺒﺮﻧﺎﻣﺞ ﻋﻠ ﻰ ﺷ ﻜﻞ أﺟ ﺮاءات ﻳ ﺴﺎﻋﺪ اﻟﻤﺒ ﺮﻣﺞ ﻣ ﺴﺘﻘﺒﻼ أو أي ﺷ ﺨﺺ أﺧ ﺮ‬  ‫2.‬
              ‫ﻣﻦ ﻣﺘﺎﺑﻌﻪ اﻟﺒﺮﻧﺎﻣﺞ وﺗﺼﺤﻴﺢ أو ﺗﻌﺪﻳﻞ اﻟﺒﺮﻧﺎﻣﺞ أذا أﻗﺘﻀﺖ اﻟﺤﺎﺟﻪ ﺑﺴﻬﻮﻟﻪ وﻳﺴﺮ .‬


‫اﻷﺟﺮاءات ﺗﺴﺎﻋﺪ اﻟﻤﺒﺮﻣﺞ ﻋﻠﻰ اﻟﺘﺨﻠﺺ ﻣﻦ ﺗﻜﺮار ﻣﻘﺎﻃﻊ ﻣﻌﻴﻨﻪ ﻣﻦ اﻟﺒﺮﻧﺎﻣﺞ واﻟﺘﻲ‬          ‫3.‬
                                 ‫ﺗﺴﺒﺐ أﺷﻜﺎﻻت آﺜﻴﺮﻩ ﻟﻠﻤﺒﺮﻣﺞ , أﺿﺎﻓﻪ اﻟﻰ زﻳﺎدة ﺣﺠﻢ اﻟﺒﺮﻧﺎﻣﺞ .‬

‫اﻷﺟﺮاءات ﺗﻌﻄﻲ اﻟﻤﺒﺮﻣﺞ ﻣﺮوﻧ ﻪ أآﺒ ﺮ ﻟﻤﺘﺎﺑﻌ ﺔ اﻷﺧﻄ ﺎء آﻤ ﺎ أﺳ ﻠﻔﻨﺎ, وآ ﺬﻟﻚ ﺗ ﺴﺎﻋﺪ‬   ‫4.‬
       ‫ﻋﻠﻰ أﺳﺘﺨﺪام هﺬﻩ اﻷﺟﺮاءات ﻓﻲ ﺑﺮاﻣﺞ أﺧﺮى ﻋﻨﺪ اﻟﺤﺎﺟﻪ ﻟﻬﺎ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ .‬

                                                                         ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻸﺟﺮاء هﻲ :‬
‫76‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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


                                                                                           ‫ﻣﻼﺣﻈﻪ ://‬

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


                                                                                              ‫ﻣﺜﺎل :‬


      ‫;1‪Program CH5_Program‬‬
      ‫‪Var‬‬
        ‫;‪X:integer‬‬

      ‫;‪Procedure Change‬‬
      ‫‪Begin‬‬
        ‫;1= :‪X‬‬
      ‫;‪End‬‬      ‫}‪{change‬‬

      ‫‪Begin‬‬     ‫}‪{main program‬‬
        ‫;0= :‪X‬‬
        ‫;‪Change‬‬
        ‫;)‪Write ('x=', x‬‬
      ‫.‪End‬‬      ‫} ‪{main program‬‬




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



                                                                         ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) 1 ( ://‬

‫هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠﻰ ﻣﺘﻐﻴﺮ واﺣ ﺪ ه ﻮ ) ‪ ( x‬وﻣﻌ ﺮف ﻓ ﻲ ﺣﻘ ﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻤﺘﻐﻴ ﺮات‬
‫ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﺬ ﻓﻬﻮ ﻳﻌﺘﺒﺮ ﻣﺘﻐﻴﺮ ﻋﺎم ) ‪ . ( global‬اﻟﺒﺮﻧﺎﻣﺞ ﻳﺤﺘﻮي ﻋﻠ ﻰ أﺟ ﺮاء ﻳﻘ ﻮم ﺑﺘﻐﻴﻴ ﺮ‬
                                                                   ‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ) ‪ ( x‬اﻟﻰ اﻟﻘﻴﻤﻪ ) 1 ( .‬
‫ﻳﺒ ﺪأ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ ﺑﺄﺳ ﻨﺎد اﻟﻘﻴﻤ ﻪ ) 0 ( اﻟ ﻰ اﻟﻤﺘﻐﻴ ﺮ ) ‪ , ( x‬ﺛ ﻢ ﻳ ﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء‬
‫) ‪ ( change‬وذﻟ ﻚ ﺑﻜﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء ﻋﻨ ﺪ ذﻟ ﻚ ﻳﻨﺘﻘ ﻞ اﻟﻤﺆﺷ ﺮ اﻟ ﻰ اﻷﺟ ﺮاء ) ‪ ( change‬وﻳﻨﻔ ﺬ‬
‫اﻷواﻣ ﺮ اﻟﺘ ﻲ ﻓﻴ ﻪ ) آﺒﺮﻧ ﺎﻣﺞ ﻣ ﺴﺘﻘﻞ ( وﺑﻌ ﺪ ﻧﻬﺎﻳ ﺔ ﺗﻨﻔﻴ ﺬ اﻷﺟ ﺮاء ﻳﻌ ﻮد اﻟﻤﺆﺷ ﺮ اﻟ ﻰ ﻋﺒ ﺎرة أﺳ ﺘﺪﻋﺎء‬
‫اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻟﻴﺴﺘﻤﺮ ﺑﺎﻟﺘﻨﻔﻴﺬ ﻟﻠﻌﺒﺎرات اﻟﺘﺎﻟﻴﻪ ﻟﻬﺎ واﻟﺘ ﻲ ه ﻲ هﻨ ﺎ ﻋﺒ ﺎرة اﻟﻄﺒﺎﻋ ﻪ ﺣﻴ ﺚ‬
‫ﺳﺘﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ .. ( x‬ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺗﻐﻴﺮت ﻓﻲ اﻷﺟﺮاء وﺗﺒﻌﺎ ﻟﺬﻟﻚ ﺗﻐﻴﺮت ﻗﻴﻤﺘﻬﺎ ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ‬
                                                             ‫اﻟﺮﺋﻴﺲ ﻷن اﻟﻤﺘﻐﻴﺮ ﻣﻌﺮف آﻤﺘﻐﻴﺮ ﻋﺎم .‬

      ‫;2‪Program CH5_Program‬‬
      ‫‪Var‬‬
        ‫;‪X:integer‬‬

      ‫;‪Procedure Change‬‬
      ‫‪Var‬‬
        ‫;‪X: integer‬‬
      ‫‪Begin‬‬
        ‫;1= :‪X‬‬
      ‫;‪End‬‬      ‫}‪{change‬‬

      ‫‪Begin‬‬     ‫}‪{main program‬‬
        ‫;0= :‪X‬‬
        ‫;‪Change‬‬
        ‫;)‪Write ('x=', x‬‬
      ‫.‪End‬‬      ‫}‪{Main program‬‬




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




                                                                         ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) 2 ( ://‬

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




                                                                                     ‫ﻣﻼﺣﻈﻪ ://‬

                       ‫اﻟﻮﺳﺎﺋﻂ ) ‪ ( parameters‬هﻲ ﻗﻴﻤﻪ ﺗﻤﺮر اﻟﻰ اﻷﺟﺮاء أو اﻟﺪاﻟﻪ .‬
                              ‫هﻨﺎك أآﺜﺮ ﻣﻦ ﻧﻮع ﻣﻦ اﻟﻮﺳﺎﺋﻂ وﻣﺎ ﻳﻬﻤﻨﺎ هﻨﺎ ﻧﻮﻋﻴﻦ :‬

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



                                                                                           ‫ﻣﺜﺎل :‬
                                           ‫أوﺟﺪ ﻗﻴﻤﺔ ) ‪ ( y‬ﻣﻦ اﻟﻤﻌﺎدﻟﻪ اﻟﺘﺎﻟﻴﻪ :‬
                  ‫01‬      ‫8‬    ‫6‬    ‫4‬
         ‫4 + 6 + 8 + 01 = ‪Y‬‬

        ‫; 3‪Program CH5_Program‬‬
        ‫‪Var‬‬
          ‫;‪Y, p1, p2, p3, p4: longint‬‬
          ‫;‪i:integer‬‬
        ‫‪Begin‬‬
          ‫;1=:1‪P‬‬
          ‫‪For i: =1 to 10 do‬‬
            ‫;01*1‪P1:=p‬‬
          ‫;1=:2‪P‬‬
          ‫‪For i: =1 to 8 do‬‬
            ‫;8*2‪P2:=p‬‬
          ‫;1=:3‪P‬‬
          ‫‪For i: =1 to 6 do‬‬
            ‫;6*3‪P3:=p‬‬
          ‫;1=:4‪P‬‬
          ‫‪For i: =1 to 4 do‬‬
            ‫;4*4‪P4:=p‬‬
          ‫;4‪Y: =p1+p2+p3+p‬‬
          ‫',3‪Writeln (p1,' ', p2' ', p‬‬               ‫;)4‪', p‬‬
          ‫;)‪Writeln(y‬‬
          ‫;‪Readln‬‬
        ‫.‪End‬‬
‫07‬                                           ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                        ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ://‬
     ‫652 65664 61277761 8045600141‬
     ‫6359886241‬




                                                                                  ‫ﻣﻼﺣﻈﻪ ://‬

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




                  ‫ﻣﻦ اﻟﻤﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ ) 3 ( ﺑﻄﺮﻳﻘﺔ اﻷﺟﺮاءات وآﻤﺎ ﻳﻠﻲ :‬

     ‫;4‪Program CH5_Program‬‬
     ‫‪Var‬‬
       ‫;‪P1, p2, p3, p4, y: longint‬‬

     ‫;)‪Procedure power(x: integer; var p: longint‬‬
     ‫‪Var‬‬
       ‫;‪I: integer‬‬
     ‫‪Begin‬‬
       ‫;1= :‪P‬‬
       ‫‪For i: =1 to x do‬‬
         ‫;‪P: =p*x‬‬
     ‫;‪End‬‬

     ‫‪Begin‬‬    ‫}‪{main program‬‬
       ‫;)1‪Power (10, p‬‬
       ‫;)2‪Power (8, p‬‬
       ‫;)3‪Power (6, p‬‬
       ‫;)4‪Power (4, p‬‬
       ‫;4‪Y: =p1+p2+p3+p‬‬
       ‫;)‪Writeln(y‬‬
       ‫;‪Readln‬‬
     ‫.‪End‬‬
‫17‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                         ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) 4 ( ://‬

‫أوﻻ : ﻳﺒﺪأ اﻟﺒﺮﻧﺎﻣﺞ ﺑﺘﻌﺮﻳﻒ ﻋ ﺪد ﻣ ﻦ اﻟﻤﺘﻐﻴ ﺮات واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ ﻋﺎﻣ ﻪ ﻧﻈ ﺮا ﻷﻧﻬ ﺎ ﻣﻌﺮﻓ ﻪ ﻓ ﻲ‬
                                                      ‫ﺣﻘﻞ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات ﻟﻠﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ .‬

‫ﺛﺎﻧﻴﺎ : آﺘﺎﺑﺔ اﻷﺟﺮاء واﻟﺬي ﻳﺴﺒﻖ آﺘﺎﺑ ﺔ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻷﺟ ﺮاء ﻳﺤﺘ ﻮي ﻋﻠ ﻰ ﻗ ﻮس ﻓﻴ ﻪ‬
‫ﻣﺘﻐﻴ ﺮات وﻧﻼﺣ ﻆ أن ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﺗﺄﺧ ﺬ ﺷ ﻜﻠﻴﻦ : أﺣ ﺪهﻤﺎ ﻣ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬واﻟﻔ ﺮق هﻨ ﺎ‬
‫ﺑﺒ ﺴﺎﻃﻪ أن اﻟﻤﺘﻐﻴ ﺮ اﻷول ﻳﺤﻤ ﻞ ﻗﻴﻤ ﻪ ﺗ ﺪﺧﻞ اﻟ ﻰ اﻷﺟ ﺮاء ﻟﻠﻌﻤ ﻞ ﻋﻠﻴﻬ ﺎ داﺧ ﻞ اﻷﺟ ﺮاء , أﻣ ﺎ اﻟﻤﺘﻐﻴ ﺮ‬
‫اﻟﻤ ﺴﺒﻮق ﺑ ﺎﻷﻣﺮ ) ‪ ( var‬ﻓﻬ ﻮ ﻳﻌﺎﻣ ﻞ آﻤﺘﻐﻴﺮﺳ ﻴﺤﻤﻞ ﻗﻴﻤ ﻪ ﺗﺨ ﺮج ﻣ ﻦ اﻷﺟ ﺮاء اﻟ ﻰ اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ‬
                                                  ‫واﻟﺘﻲ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ .‬

‫ﺛﺎﻟﺜ ﺎ : اﻟﺒﺮﻧ ﺎﻣﺞ اﻟ ﺮﺋﻴﺲ واﻟ ﺬي ﺳ ﻴﺘﻢ أﺳ ﺘﺪﻋﺎء اﻷﺟ ﺮاء داﺧﻠ ﻪ ﻟﺤ ﺴﺎب اﻟﻘ ﻴﻢ اﻟﻤﻄﻠﻮﺑ ﻪ‬
‫واﻷﺳﺘﺪﻋﺎء ﻳﺠﺐ أن ﻳﺘﻢ ﻣ ﻦ ﺧ ﻼل آﺘﺎﺑ ﺔ أﺳ ﻢ اﻷﺟ ﺮاء اﻟﻤﻄﻠ ﻮب أﺳ ﺘﺪﻋﺎءﻩ ﺛ ﻢ آﺘﺎﺑ ﺔ اﻟﻤﺘﻐﻴ ﺮات اﻟﺘ ﻲ‬
‫ﻳ ﺮاد أرﺳ ﺎﻟﻬﺎ اﻟ ﻰ اﻷﺟ ﺮاء هﻨ ﺎ ﻧﺮﺳ ﻞ اﻟ ﺮﻗﻢ اﻟﻤﻄﻠ ﻮب ﺣ ﺴﺎب ﻗﻴﻤﺘ ﻪ ﺑﻌ ﺪ رﻓﻌ ﻪ اﻟ ﻰ اﻷس اﻟﻤﻄﻠ ﻮب‬
‫وآ ﺬﻟﻚ ﻳﻜﺘ ﺐ اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﺳ ﺘﻌﻮد اﻟﻨﺘﻴﺠ ﻪ ﻓﻴ ﻪ ) أن اﻟﻘ ﻴﻢ اﻟﻤﻮﺟ ﻮدﻩ ﻓ ﻲ أﻣ ﺮ اﻷﺳ ﺘﺪﻋﺎء ﺳ ﺘﻨﺘﻘﻞ اﻟ ﻰ‬
                                                ‫اﻷﺟﺮاء ﻟﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﻳﻘﺎﺑﻠﻬﺎ ﻓﻲ اﻷﺟﺮاء ( .‬

‫راﺑﻌﺎ : ﻧﺘﻴﺠ ﺔ رﻓ ﻊ ﻋ ﺪد اﻟ ﻰ أس ﻣﻌ ﻴﻦ وﺣ ﺴﺐ اﻟﺤ ﺎﻻت أﻋ ﻼﻩ ﺳ ﺘﻌﻮد ﺑ ﺎﻟﻤﺘﻐﻴﺮ ) ‪ ( p‬واﻟﺘ ﻲ‬
‫ﺳﺘﺴﻨﺪ اﻟﻰ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻘﺎﺑﻠﻪ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء وﻟﻜﻞ ﺣﺎﻟﺔ أﺳﺘﺪﻋﺎء , هﺬﻩ اﻟﻘﻴﻢ ﺗﺠﻤ ﻊ ﻟﻨﺤ ﺼﻞ‬
                                                                          ‫ﻋﻠﻰ اﻟﻨﺘﻴﺠﻪ اﻟﻨﻬﺎﺋﻴﻪ .‬


                                                                                                 ‫ﻣﻼﺣﻈﻪ ://‬

        ‫ﻳﺠﺐ أن ﻳﻜﻮن ﻋﺪد اﻟﻮﺳﺎﺋﻂ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﺑﻌﺪ أﺳﻢ اﻷﺟﺮاء ﻓﻲ رأس اﻷﺟﺮاء ﻣﺴﺎوﻳﺎ اﻟﻰ‬
          ‫ﻋﺪد اﻟﻮﺳﺎﺋﻂ اﻟﻤﻮﺟﻮدﻩ ﺑﻴﻦ اﻟﻘﻮﺳﻴﻦ ﻓﻲ أﻣﺮ أﺳﺘﺪﻋﺎء اﻷﺟﺮاء ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ .‬



                                                                                                 ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                                                                ‫ﻣﺜﺎل :‬

         ‫;5‪Program CH5_Program‬‬
         ‫‪Var‬‬
           ‫;‪X:integer‬‬

         ‫;)‪Procedure Change ( var y:integer‬‬
         ‫‪Begin‬‬
           ‫;1=:‪y‬‬
         ‫;‪End‬‬      ‫}‪{change‬‬

         ‫‪Begin‬‬
           ‫;0= :‪X‬‬
           ‫;)‪Change(x‬‬
           ‫;)‪Write ('x=', x‬‬
         ‫.‪End‬‬      ‫}‪{Main program‬‬




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




                                                                        ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) 5 ( ://‬

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



                                                                                                ‫ﻣﻼﺣﻈﻪ ://‬

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




     ‫;6‪Program CH5_Program‬‬
     ‫‪Var‬‬
       ‫;‪X:integer‬‬

     ‫;)‪Procedure Change(y: integer‬‬
     ‫‪Begin‬‬
       ‫;1=:‪y‬‬
     ‫;‪End‬‬      ‫}‪{change‬‬

     ‫‪Begin‬‬
       ‫;0= :‪X‬‬
       ‫;)‪Change (x‬‬
       ‫;)‪Write(x‬‬
     ‫.‪End‬‬      ‫}‪{Main program‬‬




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




                                                                      ‫ﺷﺮح اﻟﺒﺮﻧﺎﻣﺞ ) 6 ( ://‬

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


                                                                                              ‫ﻣﻼﺣﻈﻪ ://‬

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




       ‫ﻣﺜﺎل : ﻧﻔﺮض أﻧﻨﺎ ﻧﺮﻏﺐ ﺑﺄﺑﺪال ﻗﻴﻢ ﻣﺘﻐﻴﺮﻳﻦ ﺑﺤﻴﺚ ﺗﻜﻮن آﻞ واﺣﺪﻩ ﻓﻲ ﻣﻜﺎن اﻷﺧﺮى‬
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   y=3
     X=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.
‫57‬                                                     ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                   ‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ://‬
      ‫24 = ‪X‬‬         ‫3=‪y‬‬
      ‫24 = ‪X‬‬         ‫3=‪y‬‬
                                              ‫ﺗﻐﻴﺮ ﻗﻴﻤﺘﻲ ) ‪ ( x, y‬ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ واﻷﺟﺮاء.‬




                                                                      ‫اﻟﺪوال ‪FUNCTIONS‬‬                           ‫3.5‬

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


‫; ‪Function < function name > : type‬‬
‫‪OR‬‬
‫; ‪Function < function name > ( Arguments ) : type‬‬



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


          ‫;9‪Program CH5_Program‬‬
          ‫‪Var‬‬
            ‫;‪Y: longint‬‬

          ‫;‪Function power (m: integer): longint‬‬
          ‫‪Var‬‬
            ‫;‪I:integer‬‬
            ‫;‪P:longint‬‬
          ‫‪Begin‬‬
            ‫;1= :‪P‬‬
            ‫‪For i: =1 to m do‬‬
              ‫;‪P: =p*m‬‬
            ‫;‪Power: =p‬‬
          ‫;‪End‬‬     ‫}‪{end function‬‬

          ‫‪Begin‬‬    ‫}‪{main program‬‬
            ‫;)4( ‪Y: = power (10) + power (8) + power (6) + power‬‬
            ‫;)‪Writeln(y‬‬
            ‫;‪Readln‬‬
          ‫.‪End‬‬
‫67‬                                           ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                    ‫ﻣﻼﺣﻈﻪ :‬

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




                                                                                    ‫ﻣﻼﺣﻈﻪ :‬

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




              .‫أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻷﻳﺠﺎد اﻟﺮﻗﻢ اﻷآﺒﺮ ﻓﻲ ﻣﺼﻔﻮﻓﻪ أﺣﺎدﻳﻪ ﺣﺠﻤﻬﺎ ) 52 ( ﻋﻨﺼﺮ‬                            •
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 ) ‫ﻣﺮﺑﻊ اﻟﻌﺪد ) 4 ( هﻮ ) 7+5+3+1 ( وﻳﻜﻮن اﻟﻨﺎﺗﺞ‬




      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.
‫08‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                  ‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬

                          ‫اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ ‪STRINGS‬‬

                                                                                               ‫اﻟﻤﻘﺪﻣﻪ‬         ‫1.6‬

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

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

‫ﻟﻐﺮض اﻟﻔﻬﻢ اﻟﺠﻴﺪ ﻟﻠﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ , ﻳﺠﺐ أن ﻧﻀﻊ ﻓﻲ أذهﺎﻧﻨﺎ ﺑﺄن اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ‬
‫هﻲ ﻋﺒﺎرﻩ ﻋﻦ ﻣﺼﻔﻮﻓﻪ ﻣﻦ اﻟﺤ ﺮوف . أن ﻧ ﻮع اﻟﺒﻴﺎﻧ ﺎت ﻟﻠ ﺴﻼﺳﻞ اﻟﺤﺮﻓﻴ ﻪ ه ﻲ ) ﻧ ﻮع ﺑﻴﺎﻧ ﺎت ﻣﺒﻨ ﻲ‬
                                                             ‫داﺧﻠﻴﺎ ( ﻣﺼﻔﻮﻓﻪ ﻣﻦ ) 652 ﺣﺮف ( :‬
         ‫‪Type‬‬
              ‫; ‪String = array [ 0 .. 255 ] of char‬‬

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


         ‫;1‪Program CH6_Program‬‬
         ‫‪Var‬‬
           ‫;‪St: string‬‬
         ‫‪Begin‬‬
           ‫;' ‪St: = ' computer‬‬
           ‫;)]2[ ‪Writeln (st‬‬
           ‫;)]5[ ‪Writeln (st‬‬
         ‫.‪End‬‬
‫18‬                                                     ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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




                                                                                                   ‫ﻣﻼﺣﻈﻪ ://‬

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




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

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

‫هﻨ ﺎك ﺑﻌ ﺾ اﻟ ﺪوال اﻟﻤﺨﺰوﻧ ﻪ ﻣ ﻊ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل واﻟﺘ ﻲ ﺗ ﺴﺎﻋﺪ ﻋﻠ ﻰ أﺟ ﺮاء ﺑﻌ ﺾ‬
‫اﻟﻌﻤﻠﻴﺎت ﻋﻠﻰ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ دون اﻟﺤﺎﺟﻪ اﻟﻰ أﻋﺎدة آﺘﺎﺑﺘﻬﺎ وﻳﻜﻔﻲ أﺳ ﺘﺪﻋﺎﺋﻬﺎ ﺑﺄﺳ ﻤﻬﺎ ﻟﺘﻘ ﻮم ﺑﺎﻟﻌﻤ ﻞ‬
                                                                        ‫اﻟﻤﺤﺪد ﻟﻬﺎ . ﻣﻦ هﺬﻩ اﻟﺪوال :‬

                                                                             ‫1.3.6 ﺗﺤﺪﻳﺪ اﻟﻤﻮﻗﻊ ‪POS‬‬

‫ﻧﺤﺘﺎج أﺣﻴﺎﻧﺎ اﻟﻰ ﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف داﺧﻞ ﺳﻠ ﺴﻠﻪ ﺣﺮﻓﻴ ﻪ , وﻟﺘﺤﻘﻴ ﻖ ذﻟ ﻚ‬
‫ﻧ ﺴﺘﺨﺪم اﻟﺪاﻟ ﻪ ) ‪ ( Pos‬واﻟﺘ ﻲ ﺳ ﺘﻘﻮم ﺑﺎﻟﺒﺤ ﺚ ﻋ ﻦ ) اﻟﺤ ﺮف أو ﻣﺠﻤﻮﻋ ﺔ اﻟﺤ ﺮوف واﻟﺘ ﻲ ﺗﻌﺘﺒ ﺮ‬
‫ﻣﺠﻤﻮﻋ ﻪ ﺟﺰﺋﻴ ﻪ ﻣ ﻦ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ ( داﺧ ﻞ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ , ﻓ ﺎذا ﻟ ﻢ ﻳ ﺘﻢ أﻳﺠ ﺎد اﻟﺴﻠ ﺴﻠﻪ اﻟﺠﺰﺋﻴ ﻪ‬
‫ﺿﻤﻦ اﻟﺴﻠﺴﻠﻪ اﻷﺻﻠﻴﻪ ﻓﺄﻧﻬﺎ ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) 0 ( أﻣﺎ أذا وﺟﺪﺗ ﻪ ﻓﺄﻧﻬ ﺎ ﺳ ﺘﻌﻴﺪ اﻟ ﺮﻗﻢ اﻟ ﺬي ﻳﺤ ﺪد ﻣﻮﻗ ﻊ أول‬
                                                                              ‫ﺣﺮف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺠﺰﺋﻴﻪ .‬
                                                                   ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

                ‫; ) ‪N : = Pos ( st , stn‬‬
                                                                                     ‫ﺣﻴﺚ أن :‬
                                                      ‫‪ : N‬ﺗﻤﺜﻞ اﻟﻘﻴﻤﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ.‬
                                                       ‫‪ : st‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻋﻨﻬﺎ.‬
                                                        ‫‪ : stn‬ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺘﻲ ﻧﺒﺤﺚ ﻓﻴﻬﺎ.‬
                                                                  ‫ﻣﺜﺎل :‬
‫28‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




       ‫; 2‪Program CH6_Program‬‬
       ‫‪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‬‬




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




‫ﻻﺣﻆ أن ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ) ‪ ( x‬ﺗﺴﺎوي ) 0 ( وذﻟ ﻚ ﻷن اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﺮﻓﻴ ﻪ اﻟﺘ ﻲ ﻧﺒﺤ ﺚ ﻋﻨﻬ ﺎ ه ﻲ‬
‫) ‪ ( system‬ﺗﺒ ﺪأ ﺑﺤ ﺮف ﺻ ﻐﻴﺮ ﺑﻴﻨﻤ ﺎ اﻟﻜﻠﻤ ﻪ اﻟﻤﻘﺎﺑﻠ ﻪ ﻓ ﻲ ) ‪ ( System ) ( stn‬ﺗﺒ ﺪأ ﺑﺤ ﺮف آﺒﻴ ﺮ‬
‫وﺑﺬﻟﻚ أﺻﺒﺢ أﺧﺘﻼف ﺑﻴﻦ اﻟﻜﻠﻤﺘﻴﻦ ﻟﺬﻟﻚ ﻋﻤﻠﻴﺔ اﻟﺒﺤ ﺚ ﺳ ﻮف ﻻﺗﺠ ﺪ اﻟﺴﻠ ﺴﻠﻪ اﻟﺤﻠﺮﻓﻴ ﻪ اﻟﻤﻄﻠﻮﺑ ﻪ , أذن‬
                                                                               ‫ﺗﻌﻴﺪ اﻟﻘﻴﻤﻪ ) 0 ( .‬

                                                                         ‫2.3.6 اﻷﺳﺘﻨﺴﺎخ ‪COPY‬‬

‫هﺬﻩ اﻟﺪاﻟﻪ ﺳﺘﻘﻮم ﺑﺄﺳﺘﻨﺴﺎخ ﺣﺮف أو ﻣﺠﻤﻮﻋﺔ ﺣﺮوف ﻣﻦ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﺤ ﺪدﻩ , أﻋﺘﺒ ﺎرا‬
‫ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم وﺣﺴﺐ ﻋﺪد اﻟﺤﺮوف اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤ ﺴﺘﺨﺪم , وﺳ ﺘﻌﻴﺪ ه ﺬﻩ اﻟﺪاﻟ ﻪ‬
                                                  ‫ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ﺟﺰﺋﻴﻪ وهﻲ اﻟﺘﻲ ﺣﺪدهﺎ اﻟﻤﺴﺘﺨﺪم .‬
                                                           ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

          ‫; ) ‪St : = Copy ( stn , Position , count‬‬

                                                                                        ‫ﺣﻴﺚ أن :‬
                                ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘﻲ ﺳﺘﻌﻴﺪهﺎ اﻟﺪاﻟﻪ.‬           ‫‪St‬‬
                          ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻷﺳﺘﻨﺴﺎخ ﻣﻨﻬﺎ.‬               ‫‪Stn‬‬
                       ‫: رﻗﻢ ﻳﻤﺜﻞ ﻣﻮﻗﻊ ﺑﺪاﻳﺔ اﻟﺴﻠﺴﻠﻪ اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ.‬               ‫‪Position‬‬
                             ‫: رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻷﺣﺮف اﻟﻤﻄﻠﻮب أﺳﺘﻨﺴﺎﺧﻬﺎ.‬                  ‫‪Count‬‬
                                            ‫ﻣﺜﺎل :‬
‫38‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




        ‫;3‪Program CH6_Program‬‬
        ‫‪Var‬‬
          ‫;‪Stn, st1, st2: string‬‬
        ‫‪Begin‬‬
          ‫;'‪Stn:= 'computer science‬‬
          ‫;)4 ,2 ,‪St1:= copy (stn‬‬
          ‫;)02 ,21 ,‪St2:= copy (stn‬‬
          ‫;)2‪Writeln ( st1,' ****** ', st‬‬
        ‫.‪End‬‬




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




                                                                                             ‫ﻣﻼﺣﻈﻪ ://‬

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



                                                                            ‫3.3.6 اﻟﺤﺬف ‪DELETE‬‬


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

             ‫; ) ‪Delete (stn, Position, Count‬‬
                                                                                           ‫ﺣﻴﺚ أن :‬
                                     ‫: اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب اﻟﺤﺬف ﻣﻨﻬﺎ.‬                ‫‪Stn‬‬
                                      ‫: رﻗﻢ ﻳﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﻳﺒﺪأ اﻟﺤﺬف ﻣﻨﻪ.‬              ‫‪Position‬‬
                                   ‫: رﻗﻢ ﻳﻤﺜﻞ ﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ﺣﺬﻓﻬﻢ.‬                   ‫‪Count‬‬
                                                     ‫ﻣﺜﺎل :‬
‫48‬                                                ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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




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




                                                                                          ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                          ‫4.3.6 اﻟﺤﺸﺮ ‪INSERT‬‬


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

      ‫; ) ‪Insert ( st , stn , Position‬‬
                                                                                       ‫ﺣﻴﺚ أن :‬
                       ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻷﺻﻠﻴﻪ اﻟﺘﻲ ﺳﻴﺤﺸﺮ ﻓﻴﻬﺎ.‬               ‫‪stn‬‬
                               ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب ﺣﺸﺮهﺎ.‬                ‫‪st‬‬
                         ‫: ﺗﻤﺜﻞ اﻟﻤﻮﻗﻊ اﻟﺬي ﺳﺘﺤﺸﺮ ﻓﻴﻪ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ.‬              ‫‪Position‬‬
‫58‬                                            ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                                                   ‫ﻣﺜﺎل :‬


     ‫;5‪Program CH6_Program‬‬
     ‫‪Var‬‬
       ‫;‪S: String‬‬

     ‫‪Begin‬‬
       ‫'?‪S: = 'Hey! How are you‬‬
       ‫;))4 ,‪Write (Insert (' Ali', s‬‬
       ‫;)‪Writeln(s‬‬
     ‫.‪End‬‬




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




                                             ‫5.3.6 دﻣﺞ ﺳﻠﺴﻠﺘﺎن ﺣﺮﻓﻴﺘﺎن ‪CONCAT‬‬

                ‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺪﻣﺞ ﺳﻠﺴﻠﺘﻴﻦ ﺣﺮﻓﻴﺘﻴﻦ أو أآﺜﺮﺑﺴﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ واﺣﺪﻩ.‬
                                                    ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

       ‫; )… ,3‪Stn : = Concat ( st1, st2, st‬‬
                                                                                     ‫ﺣﻴﺚ أن :‬
                               ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﻨﺎﺗﺠﻪ ﻣﻦ اﻟﺪﻣﺞ.‬              ‫‪Stn‬‬
                                ‫: ﺗﻤﺜﻞ اﻟﺴﻼﺳﻞ اﻟﺘﻲ ﺳﻴﺘﻢ دﻣﺠﻬﺎ.‬               ‫3‪st1, st2, st‬‬
                                                     ‫ﻣﺜﺎل :‬


     ‫;6‪Program CH6_Program‬‬
     ‫‪Var‬‬
       ‫;‪Stn, st1, st2: string‬‬
     ‫‪Begin‬‬
       ‫;'‪St1:='info‬‬
       ‫;'‪St2:='rmation‬‬
       ‫;)2‪Stn: =concat (st1, st‬‬
       ‫;)‪Writeln (stn‬‬
     ‫.‪End‬‬




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



                                                                                          ‫ﻣﻼﺣﻈﻪ ://‬

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




                                            ‫ﻳﻤﻜﻦ أﻋﺎدة آﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ أﻋﻼﻩ ﻟﻴﻜﻮن :‬

      ‫;7‪Program CH6_Program‬‬
      ‫‪Var‬‬
        ‫;‪Stn, st1, st2: string‬‬
      ‫‪Begin‬‬
        ‫;'‪St1:='Bag‬‬
        ‫;'‪St2:='hdad‬‬
        ‫;2‪Stn: = st1 + st‬‬
        ‫;)‪Writeln (stn‬‬
      ‫.‪End‬‬




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




                                         ‫6.3.6 ﺣﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ ‪LENGTH‬‬

                                      ‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﻪ ﻟﺤﺴﺎب ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ.‬
                                                       ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

     ‫; ) ‪N : = Length ( st‬‬
                                                                                      ‫ﺣﻴﺚ أن :‬
                                       ‫: ﻳﻤﺜﻞ ﻃﻮل اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ.‬                         ‫‪N‬‬
                         ‫: ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻤﻄﻠﻮب أﻳﺠﺎد ﻃﻮﻟﻬﺎ.‬                       ‫‪St‬‬
                                                         ‫ﻣﺜﺎل :‬

         ‫;8‪Program CH6_Program‬‬
         ‫‪Var‬‬
           ‫;‪St: string‬‬
           ‫;‪N: integer‬‬
         ‫‪Begin‬‬
           ‫;'‪St: ='Data Structure‬‬
           ‫;)‪N: =Length (st‬‬
           ‫;)‪Write (n‬‬
         ‫.‪End‬‬
‫78‬                                              ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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




                              ‫7.3.6 ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ اﻟﻰ ﺣﺮوف آﺒﻴﺮﻩ ‪UPCASE‬‬

‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ ﺗﺤﻮﻳﻞ اﻟﺤﺮوف اﻟ ﺼﻐﻴﺮﻩ اﻟ ﻰ ﺣ ﺮوف آﺒﻴ ﺮﻩ , ﺗﺤ ﻮل ﺣ ﺮف واﺣ ﺪ آ ﻞ‬
‫ﻣﺮﻩ . أﻣﺎ أذا آﺎﻧﺖ اﻟﺤﺮوف هﻲ أﺻﻼ آﺒﻴﺮﻩ أو آﺎﻧﺖ ﺧﺎرج ﻧﻄﺎق ﻣﻔﻬﻮم اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ ﻓ ﺴﺘﺘﺮك‬
                                                                                ‫ﻋﻠﻰ ﺣﺎﻟﻬﺎ .‬
                                                     ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

           ‫; )‪C : = UpCase (c‬‬
                                                                    ‫ﺣﻴﺚ أن :‬
                                  ‫‪ : C‬اﻟﺤﺮف اﻟﻨﺎﺗﺞ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﻜﺒﻴﺮﻩ.‬
            ‫‪ : c‬اﻟﺤﺮف اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺣﺮف آﺒﻴﺮ وهﻮ ﻣﻦ اﻟﺤﺮوف اﻟﺼﻐﻴﺮﻩ.‬
                                                                 ‫ﻣﺜﺎل :‬


       ‫;9‪Program CH6_Program‬‬
       ‫‪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‬‬




                                                                                     ‫ﻣﻼﺣﻈﻪ ://‬

                       ‫ﻟﺘﺤﻮﻳﻞ اﻷﺣﺮف اﻟﻜﺒﻴﺮﻩ اﻟﻰ أﺣﺮف ﺻﻐﻴﺮﻩ ﻧﺘﺒﻊ اﻟﻌﻼﻗﻪ اﻟﺘﺎﻟﻴﻪ :‬
          ‫; ) 23 + ]‪S[i] : = chr ( ord ( s[i‬‬
‫88‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                            ‫8.3.6 ﺗﺤﻮﻳﻞ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ ‪STR‬‬

‫ﺗﻌﻤﻞ ه ﺬﻩ اﻟﺪاﻟ ﻪ ﻋﻠ ﻰ ﺗﺤﻮﻳ ﻞ اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ ﻓﻘ ﻂ اﻟ ﻰ ﺳﻼﺳ ﻞ ﺣﺮﻓﻴ ﻪ . أﻣ ﺎ أذا أﺳ ﺘﺨﺪﻣﻨﺎ‬
                                                           ‫أرﻗﺎم آﺴﺮﻳﻪ ﻓﺴﺘﻌﻴﺪ ﻟﻨﺎ اﻟﺪاﻟﻪ اﻟﻘﻴﻤﻪ ﺻﻔﺮ.‬
                                                             ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬
      ‫; ) ‪STR ( NUM , ST‬‬
                                                                                   ‫ﺣﻴﺚ أن ك‬
                               ‫‪ : NUM‬ﻳﻤﺜﻞ اﻟﻌﺪد اﻟﻤﻄﻠﻮب ﺗﺤﻮﻳﻠﻪ اﻟﻰ ﺳﻠﺴﻠﻪ ﺣﺮﻓﻴﻪ.‬
                                              ‫‪ : ST‬ﻳﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﻨﺎﺗﺠﻪ.‬
                                                                        ‫ﻣﺜﺎل :‬

            ‫;01‪Program CH6_Program‬‬
            ‫‪Var‬‬
              ‫;‪X: integer‬‬
              ‫;‪St: string‬‬
            ‫‪Begin‬‬
              ‫;5432= :‪X‬‬
              ‫;)‪STR(x, st‬‬
              ‫;)‪Writeln(s‬‬
            ‫.‪End‬‬




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

            ‫'5432'‬




                                                ‫9.3.6 ﺗﺤﻮﻳﻞ اﻟﺴﻼﺳﻞ اﻟﺤﺮﻓﻴﻪ اﻟﻰ أرﻗﺎم ‪VAL‬‬

‫ﺗﻌﻤﻞ هﺬﻩ اﻟﺪاﻟﻪ ﻋﻠﻰ أﻳﺠﺎد اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ ﻟﻠﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ اﻟﺘ ﻲ ﺗﺤﺘ ﻮي ﻋﻠ ﻰ أرﻗ ﺎم ﻓﻘ ﻂ ﻋﻠ ﻰ‬
                                                                                       ‫ﺷﻜﻞ ﺣﺮﻓﻲ .‬
                                                             ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻟﻬﺬﻩ اﻟﺪاﻟﻪ هﻲ :‬

         ‫; ) ‪VAL ( stn, number , Error‬‬
                                                                                            ‫ﺣﻴﺚ أن :‬
                                             ‫: ﺗﻤﺜﻞ اﻟﺴﻠﺴﻠﻪ اﻟﺤﺮﻓﻴﻪ.‬               ‫‪Stn‬‬
           ‫: ﻳﻤﺜﻞ اﻟﻤﺘﻐﻴﺮ اﻟﺬي ﺳﺘﻮﺿﻊ ﻓﻴﻪ اﻟﻘﻴﻤﻪ اﻟﻌﺪدﻳﻪ اﻟﻤﺘﺤﻮﻟﻪ.‬                  ‫‪Number‬‬
   ‫: ﻣﺘﻐﻴﺮ ﻳﻌﻴﺪ ﻋﺪد ﺻﺤﻴﺢ ) ﻋﻨﺪﻣﺎ ﻳﺘﻢ اﻟﺘﺤﻮﻳﻞ دون أﺧﻄﺎء ﻓﺴﺘﻌﻴﺪ‬                      ‫‪Error‬‬
‫اﻟﻘﻴﻤﻪ ) 0 ( ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ﻋﺪم وﺟﻮد ﺧﻄﺄ , أﻣﺎ أذا ﺣﺪث ﺧﻄﺄ ﻓﺴﺘﻌﻴﺪ‬
                                    ‫ﻋﺪد ﺻﺤﻴﺢ ﻳﺒﻴﻦ ﻣﻮﻗﻊ اﻟﺨﻄﺄ (.‬
                                           ‫ﻣﺜﺎل :‬
‫98‬                                         ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



     ‫;11‪Program CH6_Program‬‬
     ‫‪Var‬‬
       ‫;‪St: string‬‬
       ‫;‪N, e: integer‬‬
     ‫‪Begin‬‬
       ‫;'4321'= :‪St‬‬
       ‫;)‪Val (st, n, e‬‬
       ‫;)‪Writeln (n,' ****** ', e‬‬
       ‫;'21.5432'= :‪St‬‬
       ‫;)‪Val (st, n, e‬‬
       ‫;)‪Writeln (n,' ^^^^^^ ', e‬‬
     ‫.‪End‬‬




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




                                                                                ‫ﻣﻼﺣﻈﻪ ://‬

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




                                                                                ‫ﻣﻼﺣﻈﻪ ://‬

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



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

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



       ‫;21‪Program CH6_Program‬‬
       ‫‪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‬‬
               ‫‪For i: =1 to length(s) do‬‬           ‫}‪{instead of for loop above‬‬
                 ‫;‪St: =s[i] + st‬‬




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



         ‫;31‪Program CH6_Program‬‬
         ‫‪Var‬‬
           ‫;‪S:string; k,n,i:integer‬‬
         ‫‪Begin‬‬
           ‫;)'‪Writeln ('Enter string‬‬
           ‫;)‪Readln(s‬‬
           ‫;0= :‪K‬‬
           ‫;)‪N: =length(s‬‬
           ‫‪For i: = 1 to n do‬‬
             ‫‪If(s[i] ='e') then‬‬
               ‫;1+‪K: =k‬‬
           ‫;)‪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');           Readln(s);
       X: =pos ('are', s);
       While(x<>0) do
         Begin
           Delete(s, x, 3);
           X: =pos ('are', s);
         End;
       Writeln(s);
     End.
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.
‫39‬                                                  ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                   ‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ‬

                  ‫ﻣﺘﻐﻴﺮات اﻷﻧﻮاع ‪VARIABLES TYPE‬‬


                                                                                              ‫اﻟﻤﻘﺪﻣﻪ‬         ‫1.7‬

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

                                                                              ‫اﻷﻧﻮاع ‪TYPES‬‬                    ‫2.7‬

‫ﺗﺴﺘﺨﺪم آﻠﻤﺔ ﻧﻮع ) ‪ ( Type‬ﻟﻠﺘﺼﺮﻳﺢ ﻋﻦ أﻧﻮاع ﺟﺪﻳﺪﻩ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ .‬
                                                          ‫اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﻪ ﻷﺳﺘﺨﺪام اﻟﻨﻮع هﻲ :‬
          ‫‪Type‬‬
               ‫; ‪Typename = new type‬‬

‫ﻟﺘﻮﺿﻴﺢ هﺬﻩ اﻟﺼﻴﻐﻪ ﻧﻔﺮض أن اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬي ﻧﻜﺘﺒﻪ ﻳﺤﺘﺎج اﻟﻰ ﻣﺼﻔﻮﻓﻪ ) ﻣﺠﻤﻮﻋﻪ ﻣﻦ اﻟﻘ ﻴﻢ‬
‫ﻣﺘﻜﻮﻧ ﻪ ﻣ ﻦ 02 ﻗﻴﻤ ﻪ ( , وه ﺬا اﻟ ﻨﻤﻂ ﻣ ﻦ اﻟ ﺼﻔﻴﻔﻪ ﺳﻴ ﺴﺘﺨﺪم ﻓ ﻲ اﻟﺒﺮﻧ ﺎﻣﺞ ﻣ ﺮارا وﺗﻜ ﺮارا , ﻓ ﻴﻤﻜﻦ‬
                                                     ‫اﻷﻋﻼن أو اﻟﺘﺼﺮﻳﺢ ﻋﻦ ﻧﻤﻂ ﺟﺪﻳﺪ آﻤﺎ ﻳﻠﻲ :‬

           ‫‪Type‬‬
             ‫; ‪MyArray = array [ 1 .. 20 ] of byte‬‬

‫اﻷن ﻳﻤﻜﻦ أن ﻧﻌﻠﻦ ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﻦ ﻧ ﻮع ) ‪ ( myarray‬ﺑ ﺪﻻ ﻣ ﻦ آﺘﺎﺑ ﺔ ﺗﻌﺮﻳ ﻒ اﻟﻤ ﺼﻔﻮﻓﻪ‬
                                             ‫أﻋﻼﻩ ﻓﻲ آﻞ ﻣﺮﻩ ﻧﺤﺘﺎج اﻟﻰ ﻣﺜﻞ هﺬﻩ اﻟﻤﺼﻔﻮﻓﻪ .‬
          ‫‪Var‬‬
              ‫; ‪X : myarray‬‬

‫اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺠﺪﻳﺪﻩ ﺳﻴﻜﻮن ﻓﻲ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧ ﻮاع واﻟ ﺬي ﻳ ﺴﻤﻰ ) ‪, ( Type‬‬
    ‫وﻣﻮﻗﻊ هﺬا اﻟﻘﺴﻢ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ ﻳﻜﻮن ﺑﻴﻦ ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﺜﻮاﺑﺖ وﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮات .‬


                                                                                               ‫ﻣﻼﺣﻈﻪ ://‬

          ‫ﻗﺴﻢ اﻷﻋﻼن ﻋﻦ اﻷﻧﻮاع اﻟﺬي ﻳﻈﻬﺮ ﻓﻲ ﺟﺴﻢ اﻷﺟﺮاءات هﻲ ﻣﺤﻠﻴﻪ ﻟﺘﻠﻚ اﻷﺟﺮاءات .‬
                                      ‫أﻣﺎ ﺗﻠﻚ اﻟﺘﻲ ﺗﻈﻬﺮ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺮﺋﻴﺲ ﻓﻬﻲ ﻋﺎﻣﻪ .‬
‫49‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



                                              ‫ﺑﺸﻜﻞ ﻋﺎم هﻨﺎك ﺛﻼث أﺻﻨﺎف ﻟﻸﻧﻮاع :‬

                                                 ‫1.2.7 اﻷﻧﻮاع اﻟﻌﺪدﻳﻪ ‪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‬‬
‫59‬                                              ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



      ‫; ‪Holiday, workday : day‬‬
      ‫; ‪Addingop, multop : operator‬‬

                                                                                        ‫ﻣﻼﺣﻈﻪ ://‬

      ‫ﻟﺴﻮء اﻟﺤﻆ ﻓﺄن ﻟﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل ﻻ ﺗﻮﻓﺮ أﻣﻜﺎﻧﻴﺔ ﻗﺮاءة وﻃﺒﺎﻋﺔ اﻟﻘﻴﻢ اﻟﻌﺪدﻳﻪ‬
                                           ‫ﻣﺒﺎﺷﺮﻩ ) اﻟﻤﺘﻐﻴﺮات ﻣﻦ هﺬا اﻟﻨﻮع ( . ﻣﺜﻼ‬
                 ‫;‪Holiday := Friday‬‬
                ‫) ‪Write ( holiday‬‬

       ‫ﺳﻮف ﻻ ﻳﻄﺒﻊ ) ‪ , ( Friday‬ورﺑﻤﺎ ﻻﻧﺤﺼﻞ ﻋﻠﻰ أي ﻣﺨﺮﺟﺎت ﻷن اﻟﻤﺘﺮﺟﻢ ﺳﻴﺼﺪر‬
                                                                ‫رﺳﺎﻟﺔ ﺧﻄﺄ .‬



                                                                                        ‫ﻣﻼﺣﻈﻪ ://‬

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

                                  ‫واﻟﺴﺒﺐ ﻷن اﻟﻌﻨﺼﺮ ) ‪ ( tomato‬ﻳﻈﻬﺮ ﻓﻲ اﻟﺘﻌﺮﻳﻔﻴﻦ .‬




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

              ‫; ‪Holiday : = Friday‬‬                            ‫; ‪scale : = miles‬‬



                                                                                        ‫ﻣﻼﺣﻈﻪ ://‬

          ‫ﻻﻳﺠﻮز أﺳﻨﺎد ﻗﻴﻤﻪ ﻣﻦ ﻧﻮع ﻣﻌﻴﻦ ) أﺳﺘﺨﺪام اﻟﻤﺴﺎواة ( اﻟﻰ ﻣﺘﻐﻴﺮ ﻣﻦ ﻧﻮع أﺧﺮ .‬
                                                                             ‫ﻣﺜﻼ :‬
              ‫; ‪Holiday := miles‬‬
‫69‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

            ‫‪Monday < Friday‬‬
            ‫‪Multiply > divide‬‬

        ‫أن اﻟﻨﻮع ) ‪ ( Boolean‬هﻮ ﺑﺤﺪ ذاﺗﻪ ﻧﻮع ﻋﺪدي , ﻓﻬﻮ ﻣﻌﺮف ﺿﻤﻨﻴﺎ آﻨﻮع ﻗﻴﺎﺳﻲ آﻤﺎ ﻳﻠﻲ :‬

            ‫‪Type‬‬
               ‫;) ‪Boolean = ( false , true‬‬
                                                                                                ‫وﻃﺒﻌﺎ أذا ﻗﻠﻨﺎ‬
                 ‫‪False < true‬‬

                                                                                     ‫وهﻲ ﻋﺒﺎرﻩ ﺻﺤﻴﺤﻪ .‬

‫اﻟ ﺪوال ) ‪ ( succ , pred‬ه ﻲ ﻣﻌﺮﻓ ﻪ ﻟﻸﻧ ﻮاع اﻟﻌﺪدﻳ ﻪ ) أي ﻳﻤﻜ ﻦ أﺳ ﺘﺨﺪاﻣﻬﺎ ﻣ ﻊ اﻷﻧ ﻮاع‬                           ‫•‬
                   ‫اﻟﻌﺪدﻳﻪ ( , واﻟﻘﻴﻤﻪ اﻟﻤﻌﺎدﻩ هﻲ ﻣﻦ ﻧﻔﺲ ﻧﻮع اﻟﻤﻌﺎﻣﻼت اﻟﻤﺴﺘﺨﺪﻣﻪ , ﻣﺜﻼ‬

              ‫‪Succ ( Monday ) = Tuesday‬‬

‫ﻣ ﻊ ﻣﻼﺣﻈ ﺔ أن أول ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ ) ‪ , ( pred‬وأﺧ ﺮ ﻋﻨ ﺼﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﻪ ﻟ ﻴﺲ ﻟ ﻪ‬
                                                                                 ‫) ‪. ( succ‬‬

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

                                  ‫أﻳﻀﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪام أﻣﺮ اﻟﺘﻜﺮار ) ‪ ( for‬ﺑﺎﻟﻬﻴﻜﻠﻴﻪ :‬                        ‫•‬

‫‪For scale : = inches to miles do‬‬
        ‫; ‪Do something‬‬

                                                  ‫هﻨﺎ ﻻ ﻳﻤﻜﻦ أﺳﺘﺨﺪام ) ‪ ( while‬ﻣﺜﻼ :‬

‫; ‪Scale : = inches‬‬
‫‪While ( scale <= miles ) do‬‬
‫‪Begin‬‬
   ‫; ‪Do something‬‬
   ‫; ) ‪Scale: = succ ( scale‬‬
‫79‬                                                   ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



‫;‪End‬‬
                                    ‫ﺳﻴﻔﺸﻞ هﺬا اﻟﺒﺮﻧﺎﻣﺞ ﻋﻨﺪ ﺣﺴﺎب ) ) ‪. ( succ ( miles‬‬


                                                        ‫2.2.7 اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ‪SUBRANGE‬‬

‫هﺬا اﻟﻨﻮع ﻳﻌﺮف ﺑﺄﺳﻨﺎد ﺛﺎﺑﺘﻴﻦ ﻟﻠﻤﺘﻐﻴﺮ ﻓﻲ ﺣﻘﻞ اﻷﻋ ﻼن ﻋ ﻦ اﻟﻨ ﻮع , وه ﺬان اﻟﺜﺎﺑﺘ ﺎن ﻳﻤ ﺜﻼن‬
‫اﻟﺤ ﺪود اﻟ ﺪﻧﻴﺎ واﻟﺤ ﺪود اﻟﻌﻠﻴ ﺎ ﻟﻠﻤ ﺪى اﻟﺠﺰﺋ ﻲ , وﻳﺠ ﺐ أن ﻳﺨﺘﻠﻔ ﺎن وﻳﻜﻮﻧ ﺎن ﻣ ﻦ ﻧﻔ ﺲ اﻟﻨ ﻮع‬
                                                                                     ‫.ﻣﺜﺎل :‬

          ‫‪Type‬‬
              ‫; 53 .. 1 = ‪Index‬‬

‫هﻨﺎ اﻟﺤﺪ اﻷدﻧﻰ ه ﻮ ) 1 ( واﻟﺤ ﺪ اﻷﻋﻠ ﻰ ه ﻮ ) 53 ( واﻷﺛﻨ ﺎن ﻣ ﻦ ﻧ ﻮع اﻷﻋ ﺪاد اﻟ ﺼﺤﻴﺤﻪ .‬
‫واﻟﻤﺪى ﻳﻜﻮن ﺑﻴﻦ ) 53 – 1 ( , ﻋﻠﻴﻪ ﻓﺄن اﻟﻤﺘﻐﻴ ﺮ اﻟ ﺬي ﻳﻌ ﺮف ﻣ ﻦ ﻧ ﻮع ) ‪ ( index‬ﺳ ﻴﺄﺧﺬ‬
               ‫أي ﻗﻴﻤﻪ ﻣﻦ اﻟﻘﻴﻢ اﻟﻤﺤﺪدﻩ ﺑﺎﻟﻤﺪى ) 53 – 1 ( وﻟﻴﺲ ﻗﻴﻤﻪ ﺧﺎرج هﺬا اﻟﻤﺪى .‬


                                                                                    ‫ﻣﻼﺣﻈﻪ ://‬

             ‫ﻻ ﺗﺴﺘﺨﺪم اﻷﻋﺪاد اﻟﺤﻘﻴﻘﻴﻪ ﻣﻊ هﺬا اﻟﻨﻮع ) أي ﻻ ﻳﻤﻜﻦ أن ﻧﺴﺘﺨﺪم اﻷﻋﺪاد‬
                                                  ‫اﻟﺤﻘﻴﻘﻴﻪ ﻓﻲ اﻟﻤﺪﻳﺎت اﻟﺠﺰﺋﻴﻪ ( .‬




‫اﻟﺘﻌﺮﻳﻔﺎن ) اﻷﻋﻼن ﻋﻦ اﻟﻨﻮع واﻷﻋﻼن ﻋﻦ اﻟﻤﺘﻐﻴﺮ ﻣﻦ ذﻟﻚ اﻟﻨﻮع ( ﻣﻦ اﻟﻤﻤﻜﻦ ان ﻳ ﺪﻣﺠﺎن‬                                  ‫•‬
                                                          ‫ﻣﻌﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ .. ﻣﺜﺎل‬
         ‫‪Type‬‬
              ‫; 53 .. 1 = ‪Index‬‬
              ‫; '‪Letter = 'a' .. 'z‬‬
              ‫; '9' .. '0' = ‪Digit‬‬
           ‫‪Var‬‬
               ‫; ‪Count : index‬‬
              ‫; ‪Firstchar , lastchar : letter‬‬

                                    ‫هﺬان اﻟﺘﻌﺮﻳﻔﺎن ﻣﻦ اﻟﻤﻤﻜﻦ دﻣﺠﻬﻤﺎ ﺑﺘﻌﺮﻳﻒ واﺣﺪ آﻤﺎ ﻳﻠﻲ :‬
           ‫‪Var‬‬
             ‫; 53 .. 1 : ‪Counter‬‬
             ‫; '‪Firstchar , lastchar : 'a' .. 'z‬‬

                               ‫ﻟﻜﻦ ﻓﻲ ﻣﻌﻈﻢ اﻟﺤﺎﻻت ﻳﻔﻀﻞ اﻟﻤﺤﺎﻓﻈﻪ ﻋﻠﻰ ﺗﻌﺮﻳﻔﻴﻦ ﻣﻨﻔﺼﻠﻴﻦ .‬
‫89‬                                                 ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬

                                                                                     ‫ﻣﻼﺣﻈﻪ ://‬

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

           ‫; ‪index : = number‬‬
           ‫; ‪result : = index‬‬




                                                                          ‫3.2.7 اﻟﻤﺠﻤﻮﻋﺎت ‪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‬‬
‫001‬                                                    ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




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

‫] ‪Apple in [ apple , orange , icecream‬‬

                                                         ‫ﺑﻴﻨﻤﺎ اﻟﻌﺒﺎرﻩ اﻟﺘﺎﻟﻴﻪ هﻲ ﻋﺒﺎرﻩ ﺧﺎﻃﺌﻪ‬

‫] ‪Apple in [ orange , bananas , icecream , cream‬‬

‫ﺗ ﺴﺘﺨﺪم اﻟﻌﻮاﻣ ﻞ اﻟﻌﻼﺋﻘﻴ ﻪ ﻟﻠﻤﻘﺎرﻧ ﻪ ﺑ ﻴﻦ اﻟﻤﺠ ﺎﻣﻴﻊ , واﻟﻤﺒﻴﻨ ﻪ ﺑﺎﻟﺠ ﺪول ) 1.7 ( .. أﻣﺜﻠ ﻪ ﻋﻠ ﻰ‬                     ‫•‬
                                                                                          ‫ذﻟﻚ :‬

‫] ‪[ Orange , cream ] = [ cream , orange‬‬
‫] ‪[ icecream ] ≠ [ ice , cream‬‬
‫] ‪[strawberries ] <= [ strawberries , cream‬‬
‫] ‪[ apple .. ice ] > = [ icecream .. cream‬‬

‫ﻋﺒﺎرة اﻟﻤﺴﺎواة رﺑﻤﺎ ﻣﻦ اﻟﻤﻤﻜﻦ أﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ ﻣﺘﻐﻴﺮات اﻟﻤﺠﺎﻣﻴﻊ وﺗﻌﺎﺑﻴﺮ اﻟﻤﺠﻤﻮﻋﻪ .. ﻣﺜﺎل‬                                ‫•‬

‫; ] ‪X : = [ apple , cream , sugar‬‬
‫; ] ‪Feast : = x + [ icecream‬‬


‫ﺟ ﺪول ) 1.7 ( : ﻣﻘﺎرﻧ ﺔ اﻟﻌﻤﻠﻴ ﺎت اﻟﻌﻼﺋﻘﻴ ﻪ اﻟﻤ ﺴﺘﺨﺪﻣﻪ ﻓ ﻲ ﻟﻐ ﺔ اﻟﺒﺮﻣﺠ ﻪ ﺑﺎﺳ ﻜﺎل ﻣ ﻊ ﻣ ﺎ ﻳﻘﺎﺑﻠﻬ ﺎ ﻓ ﻲ‬
                                                                                            ‫اﻟﺮﻳﺎﺿﻴﺎت‬


       ‫اﻟﺮﻣﺰ ﻓﻲ ﻟﻐﺔ‬          ‫اﻟﺮﻣﺰ اﻟﻤﺴﺘﺨﺪم ﻓﻲ‬                                   ‫اﻟﻤﻌﻨﻰ‬
      ‫اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل‬             ‫اﻟﺮﻳﺎﺿﻴﺎت‬
          ‫]…[‬                     ‫}…{‬                                        ‫اﻟﻤﺠﻤﻮﻋﻪ ) ‪( set‬‬
            ‫+‬                       ‫‪U‬‬                                       ‫اﻷﺗﺤﺎد ) ‪( union‬‬
            ‫*‬                       ‫∩‬                               ‫اﻟﺘﻘﺎﻃﻊ ) ‪( intersection‬‬
            ‫≤‬                       ‫≤‬                                    ‫ﺗﺤﺘﻮي ) ‪( contains‬‬
            ‫≥‬                       ‫≥‬                 ‫ﻣﺤﺘ ﻮاة ﺑﺎﻟﻤﺠﻤﻮﻋ ﻪ ) ‪( contained by‬‬
                                                                        ‫) ﻣﺠﻤﻮﻋﻪ ﺟﺰﺋﻴﻪ ﻣﻦ (‬
           ‫‪IN‬‬                         ‫‪є‬‬                               ‫ﺗﻌﻮد اﻟﻰ ) ‪( inclusion‬‬
           ‫][‬                         ‫‪Ø‬‬                         ‫ﻣﺠﻤﻮﻋﻪ ﺧﺎﻟﻴﻪ ) ‪( empty set‬‬
‫101‬                                            ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬




                                                                                            ‫ﻣﻼﺣﻈﻪ ://‬

      ‫ﻋﻨﺪ أﺳﺘﺨﺪام اﻟﻌﻼﻣﻪ ) ≤ أو ≥ ( ﻓﺄن ﻓﺘﺤﺔ هﺬﻩ اﻟﻌﻼﻣﻪ داﺋﻤﺎ ﺗﺸﻴﺮ اﻟﻰ اﻟﻤﺠﻤﻮﻋﻪ اﻷآﺒﺮ .‬
102                                            ‫أﺳﺎﺳﻴﺎت اﻟﺒﺮﻣﺠﻪ ﺑﻠﻐﺔ اﻟﺒﺮﻣﺠﻪ ﺑﺎﺳﻜﺎل / ﺗﺄﻟﻴﻒ د. ﻧﻀﺎل ﺧﻀﻴﺮ اﻟﻌﺒﺎدي‬



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

                : ‫• أآﺘﺐ ﺑﺮﻧﺎﻣﺞ ﻟﺘﻜﻮﻳﻦ ﻣﺠﻤﻮﻋﺘﻴﻦ ذات أﻋﺪاد ) 552 .. 0 ( ﺛﻢ أوﺟﺪ ﻣﺎﻳﻠﻲ‬
                                                          ‫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.

				
DOCUMENT INFO
Shared By:
Stats:
views:3549
posted:1/10/2011
language:Arabic
pages:109
Description: كتاب مفيد جدا للتعامل مع لغة باسكال للمبتدئين