‫ﭼﻜﻴﺪه ‪ ‬‬

‫اﻳﻦ ﭘﺮوژه آﻣﻮزﺷﻲ ﺗﻮﺳﻂ داﻧﺸﺠﻮ ﻛﺎرﺷﻨﺎﺳﻲ داﻧﺸﮕﺎه ﺷﻤﺴﻲ ﭘﻮر ﻣﺤﺴﻦ رﺟﺒﻲ اﻧﺠﺎم ﺷﺪه و در‬
‫ﻣﻮرده آﻣﻮزش زﺑﺎن ‪ PHP‬اﺳﺖ ﻛﻪ اﻣﺮوزه ﭘﺮ اﺳﺘﻔﺎده ﺗﺮﻳﻦ زﺑﺎن ﺑﺮاي ﻃﺮاﺣﻲ ﺻﻔﺤﺎت ﻧﻴﺰ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬
‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﺤﻘﻴﻘﺎت اﻧﺠﺎم ﺷﺪه در ﺳﺎل ‪ 2013‬ﻧﺰدﻳﻚ ﺑﻪ ‪ 60%‬ﺳﺎﻳﺖ ﻫﺎي اﻳﺠﺎد ﺷﺪه ﺑﻪ وﺳﻴﻠﻪ ي اﻳﻦ‬
‫زﺑﺎن ﺑﻮده اﻧﺪ ‪ .‬اﻳﻦ زﺑﺎن از ﻣﺤﺒﻮﺑﻴﺖ ﺑﺴﻴﺎر ﺑﺎﻻﻳﻲ ﺑﺮﺧﻮردار ﻣﻲ ﺑﺎﺷﺪ ‪ .‬در اﻳﻦ ﭘﺮوژه ﺳﻌﻲ ﺷﺪه ﺗﺎ‬
‫اﻳﻦ زﺑﺎن از ﻣﺒﺘﺪي ﺗﺎ ﭘﻴﺸﺮﻓﺘﻪ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺜﺎل ﻫﺎ و ﺗﻮﺿﻴﺤﺎت آﻣﻮزش داده ﺷﻮد و در آﺧﺮ ﻧﻴﺰ‬
‫ﭼﻨﺪﻳﻦ ﻣﺜﺎل ﻛﺎرﺑﺮدي در ﭘﺮوژه ﻫﺎي ﻛﺎري زده ﺷﺪه اﺳﺖ ‪ .‬اﻳﻦ آﻣﻮزش در ‪ 37‬ﻣﺜﺎل )‪ (Example‬ﻛﻪ‬
‫ﻫﺮ ﻣﺜﺎل داراي ﻳﻚ ﻋﺪد ورد ﻛﻪ داراي ﭼﻨﺪﻳﻦ ﻣﺜﺎل ﻣﻲ ﺑﺎﺷﺪ ﺗﺸﻜﻴﻞ ﺷﺪه اﺳﺖ ‪ .‬در ﻫﺮ ورد‬
‫ﭘﻴﺮاﻣﻮن ﭼﻨﺪ دﺳﺘﻮر ‪ PHP‬ﺗﻮﺿﻴﺢ داده ﺷﺪه اﺳﺖ و ﻣﺜﺎل ﻫﺎﻳﻲ ﺑﺮاي آن ﻫﺎ آورده ﺷﺪه اﺳﺖ ﻛﻪ ﻓﺎﻳﻞ‬
‫ﻣﺜﺎل ﻫﺎ درون ﭘﻮﺷﻪ ﻣﺜﺎل ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﺮاي ﺷﺮوع ﺑﺎﻳﺪ از ﻣﺜﺎل ‪ 0‬ﺷﺮوع ﻧﻤﻮد ﻛﻪ در اﻳﻦ ورد‬
‫ﺟﺰﺋﻴﺎﺗﻲ در ﻣﻮرده ‪ PHP‬و دﺳﺘﻮرات آن و ﻧﺮم اﻓﺰار ﻫﺎي ﻣﻮرده ﻧﻴﺎز آﻣﺪه اﺳﺖ ‪ .‬ﺗﻤﺎﻣﻲ ﻧﺮم اﻓﺰار‬
‫ﻫﺎي ﻣﻮرده ﻧﻴﺎز درون ﭘﺮوژه ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﻣﺜﺎل ﻫﺎي ﭘﺮوژه از اﺑﺘﺪا دﺳﺘﻮررات ‪ PHP‬ﺷﺮوع ﺷﺪه‬
‫اﺳﺖ و ﺷﺮح ﻛﺎﻣﻞ آن ﻫﺎ آﻣﺪه اﺳﺖ و اﻳﻦ دﺳﺘﻮرات اداﻣﻪ ﭘﻴﺪا ﻧﻤﻮده اﻧﺪ ﺗﺎ اﺳﺘﻔﺎده از ﭘﺎﻳﮕﺎه داده‬
‫‪ MySql‬و ذﺧﻴﺮه اﻃﻼﻋﺎت در آن ﺑﻪ ﻋﻼوه اﻧﺠﺎم ﻋﻤﻠﻴﺎﺗﻲ ﻫﻤﭽﻮن درج ‪ ,‬ﺣﺬف ‪ ,‬وﻳﺮاﻳﺶ و ‪ . ...‬ﻫﻤﭽﻨﻴﻦ‬
‫در ﻣﻴﺎن ﻣﺜﺎل ﻫﺎ ﻧﺤﻮه اﺳﺘﻔﺎده از ﺗﻜﻨﻮﻟﻮژي ‪ Ajax‬ﺑﺎ اﻧﺠﺎم ﻣﺜﺎل ﻫﺎي ﻛﺎرﺑﺮدي ﺑﻪ ﺧﻮﺑﻲ آﻣﻮزش داده‬
‫ﺷﺪه اﺳﺖ ‪ .‬ﺑﺎ ﻣﻄﺎﻟﻌﻪ دﻗﻴﻖ اﻳﻦ ﭘﺮوژه ﺷﺨﺺ ﺧﻮاﻧﻨﺪه ﺑﻪ ﺧﻮﺑﻲ ﺑﺎ زﺑﺎن ‪ PHP‬آﺷﻨﺎﻳﻲ ﻛﺎﻣﻞ ﭘﻴﺪا ﻣﻲ‬
‫ﻛﻨﺪ و ﺑﻪ ﻣﺒﺎﺣﺚ آن ﻣﺎﻧﻨﺪ ﺷﺊ ﮔﺮاﻳﻲ ‪ ,‬ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎ ‪ ,‬اﺳﺘﻔﺎده از ‪ Ajax‬و ‪ ..‬ﺗﺴﻠﻂ ﻻزم را ﭘﻴﺪا ﻣﻲ‬
‫ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫ﻓﻬﺮﺳﺖ ‪ ‬‬

‫ ‬
‫‪ ‬ﻓﺼﻞ اول ‪12.............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ دوم ‪14.............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﺳﻮم ‪20............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﭼﻬﺎرم ‪31...........................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﭘﻨﺠﻢ ‪35............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﺷﺸﻢ ‪38...........................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﻫﻔﺘﻢ ‪42...........................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﻫﺸﺘﻢ ‪48..........................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﻧﻬﻢ ‪52..............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ دﻫﻢ ‪63............................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﻳﺎزدﻫﻢ ‪73.........................................................................................‬‬

‫‪ ‬ﻓﺼﻞ دوازدﻫﻢ ‪95......................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﺳﻴﺰدﻫﻢ ‪107 ....................................................................................‬‬

‫‪ ‬ﻓﺼﻞ ﭼﻬﺎردﻫﻢ ‪114 ....................................................................................‬‬

‫‪ ‬‬
‫‪1 | P a g e  ‬‬
‫‪ ‬‬
‫ﭘﻴﺸﮕﻔﺘﺎر‬

‫ﻣﻌﺮﻓﻲ ‪PHP ‬‬

‫‪ PHP‬ﻳﻚ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ اﺳﻜﺮﻳﭙﺘﻲ اﭘﻦ ﺳﻮرس اﺳﺖ ﻛﻪ ﺑﺮاي ﻃﺮاﺣﻲ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺗﺤﺖ وب ﺳﺮور ﺑﻪ‬
‫ﻛﺎر ﻣﻲ رود ‪ .‬ﺳﻤﺖ ﺳﺮور ﺑﻮدن ﺑﻪ اﻳﻦ ﻣﻌﻨﺎﺳﺖ ﻛﻪ ﺻﻔﺤﺎت ‪ PHP‬اﺑﺘﺪا ﺗﻮﺳﻂ ﺳﺮور )ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ از ﻧﻮع‬
‫‪ Apache‬ﻳﺎ ‪ ( IIS‬ﺑﺎﺷﺪ ‪ ,‬ﭘﺮدازش ﺷﺪه و ﺳﭙﺲ ﺧﺮوﺟﻲ ﺑﻪ ﺻﻮرت ﻛﺪ ﻫﺎي ‪ HTML‬و ﺟﺎوا اﺳﻜﺮﻳﭙﺖ ﺑﺮاي‬
‫ﻣﺮورﮔﺮ ﻛﺎرﺑﺮ ارﺳﺎل ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ وﻇﻴﻔﻪ اﺟﺮاي ﺻﻔﺤﺎت ‪ PHP‬ﺑﻪ ﻋﻬﺪه ﺳﺮور وب ﻫﺎﺳﺖ‬
‫ﺳﺎﻳﺖ ﻣﻲ ﺑﺎﺷﺪ ﺑﺮ ﺧﻼف ‪ HTML‬ﻳﺎ ﺟﺎوا اﺳﻜﺮﻳﭙﺖ ‪.‬‬

‫‪ PHP‬ﻣﺨﻔﻒ ﻋﺒﺎرت ‪ Hypertext PreProcessor‬ﺑﻪ ﻣﻌﻨﺎ ﭘﻴﺶ ﭘﺮدازﻧﺪه ﻓﺮا ﻣﺘﻦ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ در ﺳﺎل ‪1994‬‬
‫ﺗﻮﺳﻂ رﺳﻤﻮس ﻟﺮدورف اﻳﺠﺎد ﺷﺪ و ﺳﭙﺲ ﺗﺴﻂ ﺳﺎﻳﺮﻳﻦ ﺗﻮﺳﻌﻪ و ﮔﺴﺘﺮش ﭘﻴﺪا ﻛﺮد ‪ .‬اوﻟﻴﻦ ﻧﮕﺎرش‬
‫ﻋﻤﻮﻣﻲ آن در اواﻳﻞ ﺳﺎل ‪ 95‬اراﺋﻪ ﺷﺪ و ﺑﺎ ﻧﺎم ‪ Personal Home Page Tools‬رواﻧﻪ ﺑﺎزار ﺷﺪ اﻟﺒﺘﻪ ﺑﺴﻴﺎر‬
‫ﺳﺎده ﺑﻮد ‪.‬‬

‫ﺳﺎﺧﺘﺎر زﺑﺎن ‪ PHP‬ﺑﺴﻴﺎر ﺷﺒﻴﻪ ﺑﻪ زﺑﺎن ‪ C‬و در ﻧﺴﺨﻪ ﻫﺎي ﺟﺪﻳﺪ ﺷﺒﻴﻪ ﺑﻪ ﺟﺎوا ﻣﻲ ﺑﺎﺷﺪ و ﺑﻪ ﻫﻤﻴﻦ دﻟﻴﻞ‬
‫از ﻣﺤﺒﻮﺑﻴﺖ ﻓﺮاواﻧﻲ ﺑﺮ ﺧﻮردار اﺳﺖ ‪.‬از ﻣﺸﻬﻮر ﺗﺮﻳﻦ ﻧﺮم اﻓﺰار ﻫﺎي ﺳﺎﺧﺘﻪ ﺷﺪه ﺑﺎ ‪ PHP‬ﻣﻲ ﺗﻮان ﺑﻪ‬
‫ﺟﻮﻣﻼ ‪ ,‬وردﭘﺮس و‪ ....‬اﺷﺎره ﻛﺮد ‪ .‬ﺳﺎﻳﺖ ﻫﺎي ﻓﺮاواﻧﻲ در ﺟﻬﺎن ﺑﺮ اﺳﺎس زﺑﺎن ‪ PHP‬ﻧﻮﺷﺘﻪ ﺷﺪه اﻧﺪ و ﻫﺮ‬
‫روز ﻧﻴﺰ ﺑﺮ ﺗﻌﺪاد آن ﻫﺎ اﺿﺎﻓﻪ ﻣﻲ ﺷﻮد ‪ .‬ﺑﺮ ﻃﺒﻖ آﻣﺎر ﻣﻨﺘﺸﺮ ﺷﺪه ‪ 60%‬از ﺳﺎﻳﺖ ﻫﺎي ﻣﻮﺟﻮد در ﺳﺮور ﻫﺎ‬
‫ﺑﺎ ‪ PHP‬ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ از ﻣﻬﻢ ﺗﺮﻳﻦ آن ﻫﺎ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ وﻳﻜﻲ ﭘﺪﻳﺎ و ﻓﻴﺴﺒﻮك اﺷﺎره ﻛﺮد‪ PHP .‬اﻣﻜﺎن‬
‫اﺳﺘﻔﺎده از اﻧﻮاع ﻣﺨﺘﻠﻔﻲ از ﭘﺎﻳﮕﺎه داده را از ﺟﻤﻠﻪ ‪ , SqlLite , MySql‬اوراﻛﻞ ‪Microsoft  , IBM DB2 ,‬‬
‫‪ Sql Server‬و ‪ ...‬را ﺑﺎ دﺳﺘﻮر ﻫﺎﻳﻲ ﺳﺎده ﻓﺮاﻫﻢ ﻣﻲ ﺳﺎزد ‪ .‬ﭘﻲ اچ ﭘﻲ روي ﺑﻴﺸﺘﺮ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎي ﻣﻌﺮوف‬
‫از ﺟﻤﻠﻪ وﻳﻨﺪوز ‪ ,‬ﻟﻴﻨﻮﻛﺲ ‪ ,‬ﻳﻮﻧﻴﻜﺲ ‪ ,‬ﻣﻚ و ﺑﺎ اﻏﻠﺐ ﺳﺮور ﻫﺎي ﻣﻌﺮوف ﻗﺎﺑﻞ اﺟﺮاﺳﺖ ‪ .‬ﭘﻴﺶ از آﻏﺎز ﺑﻪ‬
‫ﻳﺎدﮔﻴﺮي ‪ PHP‬ﺷﻤﺎ ﺑﺎﻳﺪ آﺷﻨﺎﻳﻲ ﻛﺎﻓﻲ ﺑﺎ زﺑﺎن ﻫﺎي ‪ HTML‬و ﺟﺎوا اﺳﻜﺮﻳﭙﺖ و ﻛﺎر ﺑﺎ ‪ MySql‬را ﺑﺪاﻧﻴﺪ ‪.‬‬
‫دﺳﺘﻮرات اﻳﻦ زﺑﺎن ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﻪ ﺻﻮرت ﻣﺴﺘﻘﻴﻢ در درون ﻛﺪ ﻫﺎي ‪ HTML‬ﻗﺮا ﺑﮕﻴﺮﻧﺪ ‪ .‬زﺑﺎن ‪ PHP‬از‬
‫ﻧﺴﺨﻪ ‪ 4.3‬ﺑﻪ ﺑﻌﺪ ﻗﺎﺑﻠﻴﺖ ﭘﺸﺘﻴﺒﺎﻧﻲ از واﺳﻂ ﺧﻂ ﻓﺮﻣﺎن را ﻧﻴﺰ ﺑﻪ اﻣﻜﺎﻧﺎت ﺧﻮد اﺿﺎﻓﻪ ﻛﺮد ﻛﻪ اﻳﻦ ﻗﺎﺑﻠﻴﺖ‬
‫ﻣﻲ ﺗﻮاﻧﺪ ﺑﺮاي اﻳﺠﺎد ﻧﺮم اﻓﺰار ﻫﺎي ﻏﻴﺮ وب و ﻳﺎ ﻧﺮم اﻓﺰار ﻫﺎﻳﻲ ﺑﺎ واﺳﻂ ﮔﺮاﻓﻴﻜﻲ ﻛﺎرﺑﺮ ﻣﻮرد اﺳﺘﻔﺎده‬
‫ﻗﺮار ﺑﮕﻴﺮد ‪.‬‬

‫‪ ‬‬
 ‫‪2 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﺰﻳﺖ ﻫﺎي ‪  PHP‬‬

‫‪ PHP‬ﻳﻚ اﺑﺰار اﭘﻦ ﺳﻮرس و راﻳﮕﺎن اﺳﺖ ﺑﻪ ﻫﻤﻴﻦ دﻟﻴﻞ ﻫﺎﺳﺖ ﻫﺎﻳﻲ ﻛﻪ ﻣﻴﺰﺑﺎﻧﻲ آن را اﻧﺠﺎم ﻣﻲ‬ ‫‪‬‬
‫‪ ‬‬ ‫دﻫﻨﺪ ﺑﺴﻴﺎر ارزان ﺗﺮ از ﻫﺎﺳﺖ ﻫﺎي ‪ .net‬ﻫﺴﺘﻨﺪ ‪.‬‬

‫‪ ‬‬ ‫ﭘﻲ اچ ﭘﻲ ﺑﺮ روي ﺗﻤﺎﻣﻲ ﭘﻠﺘﻔﻮرم ﻫﺎي ﻣﻌﺮوف ﻣﺜﻞ وﻳﻨﺪوز ‪ ,‬ﻟﻴﻨﻮﻛﺲ ‪ ,‬ﻣﻚ ﻗﺎﺑﻞ اﺟﺮاﺳﺖ ‪.‬‬ ‫‪‬‬
‫‪ ‬‬ ‫‪ PHP‬ﻳﻚ زﺑﺎن ﺳﺎﺧﺖ ﻳﺎﻓﺘﻪ ﺑﻮده و ﻳﺎدﮔﻴﺮي آن ﺑﺴﻴﺎر ﺳﺎده اﺳﺖ ‪.‬‬ ‫‪‬‬
‫‪ ‬‬ ‫اﺑﺰار ﻛﺎر ﺑﺎ ‪ PHP‬ﻫﻤﮕﻲ اﭘﻦ ﺳﻮرس ﺑﻮده و اﺳﺘﻔﺎده از آن راﻳﮕﺎن ﻫﺴﺘﻨﺪ ‪.‬‬ ‫‪‬‬
‫‪ ‬‬ ‫ﺳﺮﻋﺖ ﺑﺎﻻ ‪ .‬اﺟﺮاي ﻳﻚ اﺳﻜﺮﻳﭙﺖ ‪ PHP‬ﺑﻪ ﻃﻮر ﻣﺘﻮﺳﻂ ﺗﺎ ﺳﻪ ﺑﺮاﺑﺮ ﻳﻚ اﺳﻜﺮﻳﭙﺖ ‪ asp‬اﺳﺖ ‪.‬‬ ‫‪‬‬
‫در زﻣﺎن ﻧﻮﺷﺘﻦ اﻳﻦ ﻣﻘﺎﻟﻪ آﺧﺮﻳﻦ ﻧﺴﺨﻪ ‪ PHP‬ﻣﻮﺟﻮد ﻧﺴﺨﻪ ‪ 5.5‬ﻣﻲ ﺑﺎﺷﺪ ‪ .‬در ﻛﻨﺎر ﻧﺴﺨﻪ ‪ 5‬ﭘﻲ اچ ﭘﻲ ﻳﻚ‬
‫ﻧﺴﺨﻪ اﺻﻠﻲ دﻳﮕﺮ در ﺣﺎل ﺗﻮﺳﻌﻪ اﺳﺖ ‪ .‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻐﻴﻴﺮات ﻋﻤﺪه ﻣﻮﺟﻮد در اﻳﻦ ﻧﺴﺨﻪ از ﺟﻤﻠﻪ ﭘﺸﺘﻴﺒﺎﻧﻲ‬
‫ﻛﺎﻣﻞ از ﻳﻮﻧﻴﻜﺪ ﺑﻮد ﻛﻪ ﻗﺮار ﺑﻮد اﻳﻦ ﻧﺴﺨﻪ ﺑﻪ ﻋﻨﻮان ﻧﺴﺨﻪ ‪ 6‬ﭘﻲ اچ ﭘﻲ ﻣﻨﺘﺸﺮ ﺷﻮد ‪ .‬اﻣﺎ ﭘﻴﺎده ﺳﺎزي‬
‫ﭘﺸﺘﻴﺒﺎﻧﻲ از ﻳﻮﻧﻴﻜﺪ ﺑﻴﺶ از آﻧﭽﻪ اﻧﺘﻈﺎر ﻣﻲ رﻓﺖ ﺑﻪ ﻃﻮل اﻧﺠﺎﻣﻴﺪ اﻳﻦ اﻣﺮ ﺑﺎﻋﺚ ﺷﺪه ﺗﺎ در ﺳﺎل ‪2010‬‬
‫اﻳﻦ ﻧﺴﺨﻪ ﺑﻪ ﺑﺨﺶ در ﺣﺎل ﺗﻮﺳﻌﻪ ﻣﻨﺘﻘﻞ ﺷﻮد و دﻳﮕﺮ ﺑﻪ آن ﻧﺴﺨﻪ ‪ 6‬ﮔﻔﺘﻪ ﻧﻤﻲ ﺷﻮد ‪ .‬ﻣﻔﺴﺮ ‪ PHP‬ﺗﻨﻬﺎ‬
‫ﻛﺪ ﻫﺎﻳﻲ ﻛﻪ در درون ﺟﺪا ﻛﻨﻨﺪه ﻫﺎي ‪ PHP‬ﻗﺮار ﺑﮕﻴﺮﻧﺪ را ﺗﻔﺴﻴﺮ ﻣﻴﻜﻨﻨﺪ ‪ ,‬ﻣﻌﺮف ﺗﺮﻳﻦ اﻳﻦ ﺟﺪا ﻛﻨﻨﺪ ﻫﺎ‬
‫‪ <?PHP‬ﺑﺮاي اﺑﺘﺪا و >? ﺑﺮاي اﻧﺘﻬﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﻧﺎم ﻣﺘﻐﻴﻴﺮ در زﺑﺎن ‪ PHP‬ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﻧﻤﺎد ‪ $‬آﻏﺎز‬
‫ﺷﻮد و ﻧﻴﺎزي ﺑﻪ ﻣﺸﺨﺺ ﻛﺮدن آن ﻧﻴﺴﺖ ‪ .‬ﺑﺮ ﺧﻼف ﻧﺎم ﺗﻮاﺑﻊ و ﻛﻼس ﻫﺎ ﻧﺎم ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﺑﻪ ﺑﺰرﮔﻲ و ﻛﻮﭼﻜﻲ‬
‫ﺣﺮوف ﺣﺴﺎس ﻫﺴﺘﻨﺪ ‪  .‬ﺧﻄﻮط ﺟﺪﻳﺪ و ﻓﺎﺻﻠﻪ ﻧﺎدﻳﺪه ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮﻧﺪ اﻟﺒﺘﻪ ﺑﻪ ﺟﺰء ﻓﺎﺻﻠﻪ ﻫﺎﻳﻲ ﻛﻪ در‬
‫درون رﺷﺘﻪ ﻫﺎ ﻗﺮار داﺷﺘﻪ ﺑﺎﺷﺪ و ﺗﻤﺎﻣﻲ دﺳﺘﻮرات اﻳﻦ زﺑﺎن ﺑﺎ ﻋﻼﻣﺖ ﺳﻤﻲ ﻛﻮﻟﻦ );( ﭘﺎﻳﺎن ﻣﻲ ﻳﺎﺑﺪ ‪ .‬در‬
‫زﺑﺎن ‪ PHP‬ﺑﻪ ‪ 3‬ﺻﻮرت ﻣﺘﻔﺎوت ﻣﻲ ﺗﻮان ﻛﺎﻣﻨﺖ )ﺗﻮﺿﻴﺤﺎت( ﮔﺬاﺷﺖ ‪.‬‬

‫از ﻋﻼﻣﺖ ‪ //‬ﻳﺎ ‪ #‬ﺑﺮاي ﻛﺎﻣﻨﺖ ﻫﺎي ﻳﻚ ﺧﻄﻲ و از ‪ /**/‬ﺑﺮاي ﻛﺎﻣﻨﺖ ﻫﺎي ﭼﻨﺪ ﺧﻄﻲ ﻣﻲ ﺗﻮان اﺳﺘﻔﺎده ﻛﺮد‬
‫ﺑﻪ ﺗﺼﻮﻳﺮ زﻳﺮ دﻗﺖ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪3 | P a g e  ‬‬
‫‪ ‬‬
‫زﺑﺎن ‪ PHP‬در اﺑﺘﺪا ﺑﻪ ﺻﻮرت ﻳﻚ زﺑﺎن ﻣﻔﺴﺮي ﭘﻴﺎده ﺳﺎزي ﺷﺪ و اﻣﺮوزه ﻧﻴﺰ اﻳﻦ ﭘﻴﺎده ﺳﺎزي ﭘﺮ ﻛﺎرﺑﺮد‬
‫ﺗﺮﻳﻦ ﻧﺴﺨﻪ ﻣﻮرد اﺳﺘﻔﺎده اﺳﺖ ‪ .‬ﺗﻌﺪادي ﻣﺘﺮﺟﻢ ﻧﻴﺰ ﺑﺮاي اﻳﻦ زﺑﺎن اﻳﺠﺎد ﺷﺪه اﺳﺖ ﻛﻪ اﻳﻦ زﺑﺎن را از‬
‫ﻣﻔﺴﺮ ﻫﺎ دور ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻧﺤﻮه ﻧﺼﺐ و اﺟﺮاي ‪PHP‬‬

‫ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ و اﺳﺘﻔﺎده از ‪ PHP‬ﺑﻪ ‪ 3‬ﭼﻴﺰ ﻛﻠﻲ ﻧﻴﺎز اﺳﺖ ‪:‬‬

‫ﺑﺮﻧﺎﻣﻪ ي ﻳﺎ اﺑﺰاري ﺑﺮاي ﻛﺪ ﻧﻮﻳﺴﻲ ‪ :‬در ﺳﺎده ﺗﺮﻳﻦ ﺣﺎﻟﺖ ﻣﻲ ﺗﻮاﻧﻴﺪ از ﺑﺮﻧﺎﻣﻪ ‪ Notepad‬ﺑﺮاي ﻛﺪ‬ ‫‪‬‬
‫ﻧﻮﻳﺴﻲ اﺳﺘﻔﺎده ﻛﻨﻴﺪ ‪ .‬اﻣﺎ ﻧﺮم اﻓﺰار ﻫﺎي ﺣﺮﻓﻪ اي ﻣﺎﻧﻨﺪ ‪ NuSphere  PhpED , Dreamweaver‬و‬
‫‪ ‬‬ ‫‪ NetBeans‬و ‪ ...‬ﻫﺴﺘﻨﺪ ﻛﻪ در اﻳﻦ آﻣﻮزش از ﻧﺮم اﻓﺰار ‪ Dreamweaver‬اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ‪.‬‬

‫ﻣﺮورﮔﺮ وب ‪ :‬ﺑﺮاي ﻣﺸﺎﻫﺪه ﺻﻔﺤﺎت ﻧﻴﺎز ﺑﻪ ﻳﻚ ﻣﺮورﮔﺮ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ اﻟﺒﺘﻪ ﻣﻲ ﺷﻮد از ﻣﺮورﮔﺮ ﭘﻴﺶ‬ ‫‪‬‬
‫‪ ‬‬ ‫ﻓﺮض اﺳﺘﻔﺎده ﻛﺮد وﻟﻲ ﭘﻴﺸﻨﻬﺎد ﻣﻲ ﺷﻮد از ﻣﺮورﮔﺮ ‪ Firefox‬اﺳﺘﻔﺎده ﺷﻮد ‪.‬‬

‫ﺳﺮور اﺟﺮا ﻛﻨﻨﺪه ‪ : PHP‬ﭼﻨﺎﻧﭽﻪ ﺑﺨﻮاﻫﻴﺪ ﺑﺮﻧﺎﻣﻪ ﻫﺎ و ﺻﻔﺤﺎت ‪ PHP‬را ﺑﺮ روي ﻛﺎﻣﭙﻴﻮﺗﺮ ﺧﻮد اﺟﺮا‬ ‫‪‬‬
‫ﻛﻨﻴﺪ ﻧﻴﺎز ﺑﻪ ﻧﺼﺐ ‪ PHP‬و ‪ MySql‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻣﻲ ﺗﻮان آن ﻫﺎ را ﺑﻪ ﺻﻮرت ﺗﻜﻲ داﻧﻠﻮد و ﻧﺼﺐ ﻛﺮد وﻟﻲ‬
‫دو ﺑﺮﻧﺎﻣﻪ وﺟﻮد دارﻧﺪ ﻛﻪ ﻧﻘﺶ وب ﺳﺮور را اﻳﻔﺎ ﻣﻲ ﻛﻨﻨﺪ و ﻫﻤﻪ ﺑﺮﻧﺎﻣﻪ ﻫﺎ و ﻛﺘﺎﺑﺨﺎﻧﻪ ﻫﺎي ﻣﻮرد ﻧﻴﺎز را‬
‫دارا ﻣﻲ ﺑﺎﺷﻨﺪ ‪ WampServer :‬و ‪ XamppServer‬ﻛﻪ در اﻳﻦ آﻣﻮزش از ‪ Wamp‬اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ‪.‬‬
‫‪ ‬‬ ‫ﻛﻪ ﻣﻲ ﺗﻮاﻧﻴﺪ اﻳﻦ ﺑﺮﻧﺎﻣﻪ رو از ﺳﺎﻳﺖ ﺧﻮدش ﻳﻌﻨﻲ ‪ www.wampserver.com‬داﻧﻠﻮد ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪4 | P a g e  ‬‬
‫‪ ‬‬
‫وﻗﺘﻲ اﻳﻦ ﺑﺮﻧﺎﻣﻪ رو داﻧﻠﻮد ﻧﻤﻮدﻳﺪ و ﻓﺎﻳﻞ آن را اﺟﺮا ﻛﻨﻴﺪ ﺻﻔﺤﻪ اﻳﻲ ﻣﺎﻧﻨﺪ ﺻﻔﺤﻪ زﻳﺮ ﻧﻤﺎﻳﺎن ﻣﻲ ﺷﻮد ‪.‬‬

‫در اﻳﻦ ﺻﻔﺤﻪ ﺑﺮ روي دﻛﻤﻪ ‪ Next‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ ‪ .‬در ﻣﺮﺣﻠﻪ ﺑﻌﺪ ﺗﺼﻮﻳﺮ زﻳﺮ ﻧﻤﺎﻳﺎن ﻣﻲ ﺷﻮد ‪.‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ روي ﮔﺰﻳﻨﻪ اﻳﻲ ﻛﻪ ﺑﺎ ﻓﻠﺶ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ ﻛﻠﻴﻚ ﻛﺮده وﺳﭙﺲ دﻛﻤﻪ ‪ Next‬را ﺑﺰﻧﻴﺪ‪.‬‬

‫‪ ‬‬
‫‪5 | P a g e  ‬‬
‫‪ ‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ آدرس را ﺗﻐﻴﻴﺮ ﻧﺪﻫﻴﺪ و ﺑﺮ روي دﻛﻤﻪ ‪ Next‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ ﺑﺮ روي ﻫﺮ دوي ﭼﻚ ﺑﺎﻛﺲ ﻫﺎ ﻛﻠﻴﻚ ﻛﺮده و در ﻧﻬﺎﻳﺖ ﺑﺮ روي ﮔﺰﻳﻨﻪ ‪ Next‬ﻛﻠﻴﻚ ﻛﺮده ‪.‬‬

‫‪ ‬‬
‫‪6 | P a g e  ‬‬
‫‪ ‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ ﺑﺮ روي ﮔﺰﻳﻨﻪ ي ‪ Install‬ﻛﻠﻴﻚ رده و ﺻﺒﺮ ﻧﻤﺎﻳﻴﺪ ﺗﺎ ﺑﺮﻧﺎﻣﻪ ﻧﺼﺐ ﺷﻮد ‪.‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ ﻧﺼﺐ ﭘﺎﻳﺎن ﻳﺎﻓﺘﻪ و ﭘﻨﺠﺮه اﻳﻲ ﺑﺎز ﻣﻲ ﺷﻮد ﻛﻪ در ﺗﺼﻮﻳﺮ ﺑﺎﻻ ﻣﺸﺨﺺ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﻓﻘﻂ ﻛﺎﻓﻲ‬
‫اﺳﺖ روي دﻛﻤﻪ ‪ Open‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪7 | P a g e  ‬‬
‫‪ ‬‬

‫در اﻳﻦ ﻣﺮﺣﻠﻪ ﻧﺒﺎﻳﺪ ﺑﻪ ﻣﺘﻐﻴﻴﺮ ﻫﺎي ﺑﺎﻻ دﺳﺖ زد و ﻓﻘﻂ ﻛﺎﻓﻲ اﺳﺖ روي دﻛﻤﻪ ‪ Next‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫اﻳﻦ آﺧﺮﻳﻦ ﻣﺤﻠﻪ ﻧﺼﺐ ﻣﻲ ﺑﺎﺷﺪ و ﻓﻘﻂ ﻛﺎﻓﻲ اﺳﺖ روي دﻛﻤﻪ ‪ Finish‬ﻛﻠﻴﻚ ﻧﻤﺎﻳﻴﺪ ‪ .‬ﺑﻌﺪ از ﻛﻠﻴﻚ ﺑﺮﻧﺎﻣﻪ‬
‫ﺧﻮدش اﺟﺮا ﻣﻲ ﺷﻮد ‪ .‬و در ﻛﻨﺎر ﺳﺎﻋﺖ وﻳﻨﺪوز ﻇﺎﻫﺮ ﻣﻲ ﺷﻮد ‪ .‬ﺗﺼﻮﻳﺮ اﻳﻦ ﻧﺮم اﻓﺰار ‪ 3‬ﺣﺎﻟﺖ دارد اﮔﺮ‬

‫‪ ‬‬
‫‪8 | P a g e  ‬‬
‫‪ ‬‬
‫ﻗﺮﻣﺰ ﺑﺎﺷﺪ ﻧﻤﻲ ﺗﻮاﻧﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻛﺮد ‪ ,‬اﮔﺮ زرد ﺑﺎﺷﺪ ﺑﻌﻀﻲ از ﻗﺎﺑﻠﻴﺖ ﻫﺎي آن اﺟﺮا ﻣﻲ ﺷﻮد وﻟﻲ وﻗﺘﻲ‬
‫ﺳﺒﺰ ﺑﺎﺷﺪ ﺗﻤﺎم ﻗﺎﺑﻠﻴﺖ ﻫﺎي آن را ﻣﻲ ﺗﻮان اﺳﺘﻔﺎده ﻛﺮد ‪.‬‬

‫ﺧﺐ ﺑﺮاي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ PHP‬اﺑﺘﺪا ﺑﻌﺪ اﻳﻨﻜﻪ ﺑﺮﻧﺎﻣﻪ ‪ WampServer‬را ﻧﺼﺐ و اﺟﺮا ﻛﺮدﻳﻢ ﺑﺎﻳﺪ ﺑﺮﻧﺎﻣﻪ‬
‫ﺧﻮد را ﺑﻨﻮﻳﺴﻴﻢ و ﺑﻌﺪ اﻳﻨﻜﻪ ﺑﺮﻧﺎﻣﻪ را ﻧﻮﺷﺘﻴﻢ آن ﺑﺮﻧﺎﻣﻪ را ذﺧﻴﺮه و در ﻣﺴﻴﺮ زﻳﺮ ﻗﺮار دﻫﻴﻢ ﺗﺎ ﺑﺘﻮان‬
‫آن را اﺟﺮا ﻛﺮد ‪.‬‬

‫در ﺗﺼﻮﻳﺮ ﺑﺎﻻ ﻣﺴﻴﺮ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ اﻳﻦ ﻣﺴﻴﺮ در داﺧﻞ دراﻳﻮ ‪ c‬و درون ﭘﻮﺷﻪ ‪ wamp‬و دوﺑﺎره‬
‫درون ﭘﻮﺷﻪ ‪ www‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻣﺎ ﺑﺎﻳﺪ ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﺧﻮد را در اﻳﻨﺠﺎ ذﺧﻴﺮه ﻛﻨﻴﻢ ‪ .‬ﺑﻌﺪ از ذﺧﻴﺮه ﻛﺮدن ﻓﺎﻳﻞ‬
‫درون اﻳﻦ آدرس اﺑﺘﺪا ﻣﺮورﮔﺮ را ﺑﺎز ﻛﺮده و ﻋﺒﺎرت ‪ localhost‬را ﻣﻲ ﻧﻮﻳﺴﻴﻢ اﻳﻦ آدرس ﺻﻔﺤﻪ ‪index ‬‬
‫ﻣﺎ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﻓﺮض ﻛﻨﻴﺪ ﻣﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ اﻳﻢ ﻛﻪ اي ﺑﺮﻧﺎﻣﻪ را ﺑﻪ اﺳﻤﻪ ‪ test.php‬در ﻣﺴﻴﺮي ﻛﻪ ﮔﻔﺘﻪ ﺷﺪ‬
‫ذﺧﻴﺮه ﻛﺮده اﻳﻢ ﺑﺮاي اﺟﺮا اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺎﻳﺪ آدرس ‪ localhost/test.php‬را درون ﻣﺮورﮔﺮ وارد ﻛﻨﻴﻢ ‪ .‬ﺑﻪ‬
‫ﺗﺼﻮﻳﺮ زﻳﺮ ﻧﮕﺎه ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪9 | P a g e  ‬‬
‫‪ ‬‬

‫ﺑﺎ اﻳﻨﮕﻮﻧﻪ آدرس دﻫﻲ ﻣﻲ ﺗﻮان ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻧﻮﺷﺘﻪ ﺷﺪه را اﺟﺮا ﻧﻤﻮد ‪.‬‬

‫ﺑﺮاي ﻛﺎر ﺑﺎ ﭘﺎﻳﮕﺎه داده ‪ MySql‬ﺑﺎﻳﺪ آدرس زﻳﺮ را در ﻣﺮورﮔﺮ وارد ﻛﻨﻴﺪ ‪localhost/phpmyadmin/ :‬‬

‫ﺑﺎ وارد ﻛﺮدن اﻳﻦ آدرس ﺗﺼﻮﻳﺮ زﻳﺮ ﻧﻤﺎﻳﺎن ﻣﻲ ﺷﻮد ‪.‬‬

‫ﻳﻮزر ﭘﻴﺸﻔﺮض ﭘﺎﻳﮕﺎه داده ‪ root‬ﻣﻲ ﺑﺎﺷﺪ و رﻣﺰ ﻋﺒﻮر ﭘﻴﺶ ﻓﺮض ﻫﻢ دارا ﻧﻤﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﺮاي ورود روي‬
‫دﻛﻤﻪ ‪ Go‬ﻛﻠﻴﻚ ﻛﻨﻴﺪ ﺗﺎ وارد ﺷﻮﻳﺪ و ﭘﺎﻳﮕﺎه داده ﻣﻮرد ﻧﻈﺮ ﺧﻮد را ﻃﺮاﺣﻲ ﻛﻨﻴﺪ ﻳﺎ ﺑﺎ دﻳﺘﺎﺑﺲ ﻣﻮرد ﻧﻈﺮ ﻛﺎر‬
‫ﻛﻨﻴﺪ ﻛﻪ در اﻳﻦ آﻣﻮزش ﻣﺒﺤﺚ ﻛﺎر ﺑﺎ ‪ MySql‬ﻣﺪ ﻧﻈﺮ ﻣﺎ ﻧﻴﺴﺖ ‪  .‬‬

‫‪ ‬‬
‫‪10 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﺮﻧﺎﻣﻪ ‪ Dreamweaver‬را ﻧﺼﺐ ﻧﻤﺎﻳﻴﺪ ‪ .‬ﺑﻌﺪ از ﻧﺼﺐ آن را اﺟﺮا ﻧﻤﺎﻳﻴﺪ ‪ .‬در ﺻﻔﺤﻪ ورود آن زﺑﺎن ‪ PHP‬را‬
‫ﻣﺎﻧﻨﺪ ﺗﺼﻮﻳﺮ زﻳﺮ اﻧﺘﺨﺎب ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫ﺑﻌﺪ از اﻧﺘﺨﺎي زﺑﺎن ‪ PHP‬ﺻﻔﺤﻪ اﻳﻲ ﻣﺎﻧﻨﺪ ﺷﻜﻞ زﻳﺮ ﺑﺎز ﻣﻲ ﺷﻮد ﻛﻪ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻛﺪ ﻫﺎي ‪ PHP‬ﺧﻮد را در آن‬
‫ﺑﻨﻮﻳﺴﻴﻢ و ﺑﻌﺪ در ﻣﺴﻴﺮ ﮔﻔﺘﻪ ﺷﺪه ذﺧﻴﺮه ﻧﺎﻣﻴﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪ ‬‬
‫‪11 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ اول‬
‫دﺳﺘﻮر ‪ Print‬و ‪  Echo‬‬

‫در ﻣﻘﺪﻣﻪ ﺧﻮاﻧﺪﻳﻢ ﻛﻪ ﻛﺪ ﻫﺎي ‪ PHP‬ﭼﮕﻮﻧﻪ ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد و ﺑﺎ ﺗﮓ ﻫﺎي آﻏﺎز و ﭘﺎﻳﺎن آن آﺷﻨﺎ ﺷﺪﻳﻢ وﻟﻲ‬
‫ﺣﺎﻻ ﻣﻴﺨﻮاﻫﻴﻢ ﺑﺎ ﭼﻜﻮﻧﮕﻲ ﭼﺎپ ﻛﺮدن ﻣﺘﻦ ﻣﻮرد ﻧﻈﺮ ﺧﻮد در ﺻﻔﺤﻪ را ﺑﻴﺎﻣﻮزﻳﻢ‪ ,‬ﺑﺮاي اﻳﻦ ﻛﺎر از دو دﺳﺘﻮر‬
‫زﻳﺮ اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﻫﺮ ﻛﺪام رو ﺑﺎ ﺗﻮﺿﻴﺤﺎت ﻛﺎﻣﻞ ﻣﻌﺮﻓﻲ ﻣﻴﻜﻨﻢ ‪.‬‬

‫‪  Echo‬‬ ‫‪.1‬‬

‫‪  Print‬‬ ‫‪.2‬‬
‫ﻗﺒﻞ از اﻳﻨﻜﻪ اﻳﻦ دو دﺳﺘﻮر رو ﺗﻮﺿﻴﺢ دﻫﻴﻢ ﺑﺎﻳﺪ ﻓﺮق ﺗﻚ ﻛﻮﺗﻴﺸﻦ ) ‘ ‪ ( ‬ﺑﺎ دو ﻛﻮﺗﻴﺸﻦ ) “ ‪ ( ‬رو‬
‫ﺑﺪاﻧﻴﺪ‪.‬زﺑﺎن ‪ PHP‬ﻫﺮ ﭼﻴﺰي ﻛﻪ داﺧﻞ ﺗﻚ ﻛﻮﺗﻴﺸﻦ ﻫﺴﺖ را ﺑﻪ ﻋﻨﻮان رﺷﺘﻪ ﻣﻴﺸﻨﺎﺳﺪ و ﻫﺮ ﭼﻴﺰي ﻛﻪ اﻋﻢ‬
‫از اﻋﺪاد ﻳﺎ ﻣﺘﻐﻴﻴﺮ ﻫﺎ رو داﺧﻞ آن ﺑﻨﻮﻳﺴﻴﻢ رﺷﺘﻪ در ﻧﻈﺮ ﻣﻴﮕﻴﺮد وﻟﻲ وﻗﺘﻲ ﻣﺘﻨﻲ داﺧﻞ دو ﻛﻮﺗﻴﺸﻦ‬
‫ﻣﻴﻨﻮﻳﺴﻴﻢ و ﻣﺘﻐﻴﻴﺮي داﺧﻞ آن ﻣﻴﻨﻮﻳﺴﻴﻢ ‪ PHP‬آن را ﻣﻴﻔﻬﻤﺪ و ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ echo‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﺑﺎﻻ دﺳﺘﻮر ”>‪ echo “<br‬ﺑﺮاي رﻓﺘﻦ ﺑﻪ ﺧﻂ ﺑﻌﺪي اﺳﺖ‪.‬ﺣﺎﻻ ﻓﺮق ‘ و “ رو ﻓﻬﻤﻴﺪﻳﻢ ‪ .‬اﻣﺎ دو ﺑﺮاي‬
‫ﭼﺎپ ﺑﺮ روي ﺻﻔﺤﻪ وب ﺑﻪ ﻛﺎر ﻣﻲ رود ‪ .‬دﺳﺘﻮر ‪ echo‬ﻧﺴﺒﺖ ﺑﻪ ‪ print‬ﺳﺮﻳﻊ ﺗﺮ اﺳﺖ و ﻫﻴﭻ ﺧﺮوﺟﻲ ﻧﺪارد‬

‫‪ ‬‬
‫‪12 | P a g e  ‬‬
‫‪ ‬‬
‫وﻟﻲ دﺳﺘﻮر ‪ print‬ﺑﻌﺪ از ﭼﺎپ ﻋﺪد ‪ 1‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ﻛﻪ اﺧﺘﻴﺎري اﺳﺖ ﻳﻌﻨﻲ ﻧﻤﻲ ﺧﻮاﻫﺪ ﺣﺘﻤﺎ ﺧﺮوﺟﻲ‬
‫دﺳﺘﻮر ‪ print‬را در ﻣﺘﻐﻴﻴﺮي ﺑﺮﻳﺰﻳﺪ‪.‬ﺑﻪ ﻣﺜﺎل ﺷﻤﺎره ‪ echo&print‬در زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﺑﺎﻻ دﺳﺘﻮر ”>‪ echo “<hr‬ﺑﺮاي اﻧﺪاﺧﺘﻦ ﺧﻂ در ﺻﻔﺤﻪ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫‪ ‬‬
‫‪13 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ دوم‬
‫ﻣﺘﻐﻴﻴﺮ ﻫﺎ‬

‫ﻓﺮض ﻛﻨﻴﺪ ﺷﻤﺎ ﻣﻲ ‪ ‬ﺧﻮاﻫﻴﺪ ﻳﻚ ﻣﻘﺪار ﻋﺪدي ﻳﺎ رﺷﺘﻪ اﻳﻲ ﻣﺜﻼ ﻧﻤﺮه ﻳﻪ داﻧﺸﺠﻮ ﻳﺎ اﺳﻢ ﻳﻚ داﻧﺸﺠﻮ رو‬
‫ﻧﮕﻪ دارﻳﺪ و ﺑﻌﺪ از ﻳﻚ ﺳﺮي ﻛﺎر ﻫﺎ دوﺑﺎره اﺳﺘﻔﺎده ﻛﻨﻴﺪ ﺑﺮاي اﻳﻦ ﻛﺎر از ﻣﺘﻐﻴﻴﺮ ﻫﺎ اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ و‬
‫ﻳﻚ ﻣﺘﻐﻴﻴﺮ را ﺗﻌﺮﻳﻒ ﻣﻴﻜﻨﻴﻢ‪.‬در زﺑﺎن ﻫﺎي دﻳﮕﺮ ﻣﺎﻧﻨﺪ ‪  C , C++ , C# , Pascal‬ﻣﺎ ﻫﻨﮕﺎم ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﻴﺮ ﺑﺎﻳﺪ‬
‫ﻧﻮع آن را ﻫﻢ ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ اﻣﺎ در ‪ PHP‬ﻧﻴﺎزي ﺑﻪ ﺗﻌﺮﻳﻒ ﻧﻮع ﻣﺘﻌﻴﻴﺮ ﻧﻤﻲ ﺑﺎﺷﺪ ﺧﻮد ‪  PHP‬ﻧﻮع آن را ﺗﺸﺨﻴﺺ‬
‫ﻣﻲ دﻫﺪ ‪  PHP  .‬ﺑﻪ ﺣﺮوف ﺑﺰرگ و ﻛﻮﭼﻚ ﺣﺴﺎس اﺳﺖ‪.‬ﺑﺮاي ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﻴﺮ دو ﻧﻮع ﻣﺘﻐﻴﻴﺮ ﻣﻮﺟﻮد اﺳﺖ‬
‫اوﻟﻲ ﺛﺎﺑﺖ ﻫﺎ ﻫﺴﺘﻨﺪ ﻛﻪ ﺑﻌﺪ از ﺗﻌﺮﻳﻒ آن ﻫﺎ از آن ﻫﺎ ﻓﻘﻂ اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ و ﻣﻘﺪار آن ﻫﺎ را ﻧﻤﻲ ﺗﻮان‬
‫ﺗﻐﻴﻴﺮ داد و ﻣﻘﺪار آن ﻫﺎ ﻫﻤﻴﺸﻪ ﺛﺎﺑﺖ ﻫﺴﺘﺪ ﻧﻮع دوﻣﻲ ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﻣﻌﻤﻮﻟﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﻣﻘﺪار آن ﻫﺎ ﻣﻲ‬
‫ﺗﻮاﻧﻨﺪ در داﺧﻞ ﺑﺮﻧﺎﻣﻪ ﺗﻐﻴﻴﺮ ﻛﻨﻨﺪ ‪.‬‬

‫ﻗﻮاﻧﻴﻦ ﻧﺎم ﮔﺬاري ﻣﺘﻐﻴﻴﺮ ﻫﺎ‬

‫‪ ‬‬ ‫ﻧﺎم ﻣﺘﻐﻴﻴﺮ ﻣﻲ ﺗﻮاﻧﺪ از ﺣﺮوف اﻟﻔﺒﺎي اﻧﮕﻠﻴﺴﻲ و ﺑﺰرگ و ﻛﻮﭼﻚ و ﻋﺪد و ﻋﻼﻣﺖ _‬ ‫‪.1‬‬
‫) ﻫﻤﺎن ‪ ( Underline‬ﺗﺸﻜﻴﻞ ﺷﻮد ‪  .‬‬
‫ﻧﺎم ﻣﺘﻐﻴﻴﺮ ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﻳﻚ ﺣﺮف ﻳﺎ ﻋﻼﻣﺖ _‪  ‬ﺷﺮوع ﺷﻮد‪ .‬ﻣﺜﺎل ﻧﺎم ‪ Intnumber‬ﺻﺤﻴﺢ و ﻧﺎم ‪1int‬‬ ‫‪.2‬‬
‫ﻏﻠﻂ اﺳﺖ ‪  .‬‬
‫ﻧﺎم ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﻧﻤﻲ ﺗﻮاﻧﺪ ﺷﺎﻣﻞ ﻓﺎﺻﻠﻪ ﺑﺎﺷﺪ ‪.‬‬ ‫‪.3‬‬

‫ﺛﺎﺑﺖ ﻫﺎ‬

‫ﺛﺎﺑﺖ ﻫﺎ در ﻛﻞ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺻﻮرت ﺳﺮاﺳﺮي ﻫﺴﺘﻨﺪ و در ﺑﺮﻧﺎﻣﻪ ﺑﺎ دﺳﺘﻮر ‪ define‬ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ و در‬
‫ﻧﺎم ﮔﺬاري آن ﻫﺎ ﻻزم ﻧﻴﺴﺖ ﻛﻪ ﻛﺎراﻛﺘﺮ ‪ $‬اول آن ﻗﺮار ﺑﮕﻴﺮد ‪ .‬دﺳﺘﻮر ‪ define‬ﺳﻪ ورودي دارد ﻛﻪ‬
‫اوﻟﻴﻦ ورودي آن ﻧﺎم ﺛﺎﺑﺖ ﻫﺴﺖ و دوﻣﻴﻦ ورودي آن ﻣﻘﺪار آن ﺛﺎﺑﺖ ﻫﺴﺖ و ورودي ﺳﻮﻣﻲ ﻛﻪ اﺧﺘﻴﺎري‬
‫ﻫﻢ ﻫﺴﺖ ﻣﻘﺪار ‪ true‬ﻳﺎ ‪ false‬اﺳﺖ ﻛﻪ اﮔﻪ در آن ‪ true‬ﻗﺮار دﻫﻴﻢ ﻧﺎم ﺛﺎﺑﺖ ﻣﺎ در ﻛﻞ ﺑﺮﻧﺎﻣﻪ ﺣﺴﺎس‬
‫ﺑﻪ ﺣﺮوف ﺑﺰرگ و ﻛﻮﭼﻚ ﻧﻴﺴﺖ و ﻓﺮﻗﻲ ﻧﻤﻲ ﻛﻨﺪ ﻛﻪ در ﺑﺮﻧﺎﻣﻪ ﺑﺎ ﺣﺮوف ﺑﺰرگ ﻧﻮﺷﺘﻪ ﺷﻮﻧﺪ ﻳﺎ ﻛﻮﭼﻚ وﻟﻲ‬
‫اﮔﺮ ‪ false‬ﻗﺮار دﻫﻴﻢ در ﻛﻞ ﺑﺮﻧﺎﻣﻪ ﺣﺴﺎس ﺑﻪ ﺣﺮوف ﺑﺰرگ و ﻛﻮﭼﻚ اﺳﺖ و ﻣﺎ ﺑﺎﻳﺪ در ﻛﻞ ﺑﺮﻧﺎﻣﻪ ﻧﺎم‬

‫‪ ‬‬
‫‪14 | P a g e  ‬‬
‫‪ ‬‬
‫ﺛﺎﺑﺖ‪ ‬را دﻗﻴﻘﺎ ﻫﻤﺎن ﻧﺎﻣﻲ ﻛﻪ در دﺳﺘﻮر ‪ define‬ﻧﻮﺷﺘﻴﻢ ﺑﻨﻮﻳﺴﻴﻢ ﭘﻴﺸﻔﺮض دﺳﺘﻮر ‪  define‬ﻛﻠﻤﻪ ‪false‬‬
‫اﺳﺖ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ define‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎ ‪ ‬‬

‫در ‪ PHP‬ﺑﺮاي ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﻴﺮ ﺑﺎﻳﺪ از ﻛﺎراﻛﺘﺮ ‪ $‬اول اﺳﻢ ﻣﺘﻐﻴﻴﺮ اﺳﺘﻔﺎده ﻛﺮد ﻛﻪ ﺧﻮد ‪  PHP‬ﻧﻮع داده اﻳﻲ‬
‫آن را ﺗﺸﺨﻴﺺ ﻣﻲ دﻫﺪ ‪ .‬وﻗﺘﻲ ﻣﺘﻐﻴﻴﺮي را ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﺪ ﻣﺤﻠﻲ )ﻳﺎ ‪ ( Local‬اﺳﺖ اﻳﻦ ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ اﺳﺖ‬
‫ﻛﻪ وﻗﺘﻲ ﻣﺘﻐﻴﻴﺮي در داﺧﻞ ﻳﻚ ﺗﺎﺑﻊ ﺗﻌﺮﻳﻒ ﺷﻮد ﻓﻘﻂ در ﻫﻤﺎن ﺗﺎﺑﻊ ﻗﺎﺑﻞ دﺳﺘﺮﺳﻲ ﻫﺴﺖ ﻧﻪ در ﻛﻞ ﺑﺮﻧﺎﻣﻪ‬
‫ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر ﻣﺎ در ‪ PHP‬ﭼﻬﺎر داﻣﻨﻪ ﻛﺎرﺑﺮد ﻣﺘﻐﻴﻴﺮ دارﻳﻢ ﻛﻪ ﺑﻪ ﺷﺮح زﻳﺮ اﺳﺖ ‪.‬‬

‫‪  Local‬‬ ‫‪.1‬‬

‫‪  Global‬‬ ‫‪.2‬‬
‫‪  Static‬‬ ‫‪.3‬‬
‫‪  Parameter‬‬ ‫‪.4‬‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪  Local‬‬

‫ﻣﺘﻐﻴﻴﺮي ﻛﻪ درون ﺗﺎﺑﻊ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد ﻓﻘﻂ ﺑﺮاي آن ﺗﺎﺑﻊ ﻗﺎﺑﻞ اﺳﺘﻔﺎده اﺳﺖ و ﻣﺤﻠﻲ اﺳﺖ وﺑﻌﺪ از اﺗﻤﺎم‬
‫ﻛﺎر ﺗﺎﺑﻊ ﻣﺘﻐﻴﻴﺮ ﻫﺎي ﻣﺤﻠﻲ درون آن از درون ﺣﺎﻓﻈﻪ ﺣﺬف ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ local‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ‬

‫‪ ‬‬
‫‪15 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﺜﺎل ﻳﻚ ﺗﺎﺑﻊ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ اﻟﺒﺘﻪ ﺷﻤﺎ ﻫﻨﻮز ﺑﺎ ﻧﻮﺷﺘﻦ آن آﺷﻨﺎ ﻧﺸﺪﻳﺪ ﻧﮕﺮان ﻧﺒﺎﺷﻴﺪ در ﻣﺒﺎﺣﺚ ﺑﻌﺪ‬
‫ﺑﺎ آن آﺷﻨﺎ ﻣﻲ ﺷﻮﻳﺪ ‪.‬‬

‫اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣﻲ دﻫﺪ ﭼﻮن ﻣﺘﻐﻴﻴﺮ ‪  x‬ﺑﻪ ﺻﻮرت ‪  Local‬اﺳﺖ و ﻧﻤﻲ ﺗﻮان ﻫﻤﻴﻨﻄﻮري درون ﺗﺎﺑﻊ از آن‬
‫اﺳﺘﻔﺎده ﻧﻤﻮد ‪  .‬‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪  Global‬‬

‫ﻫﺮ ﻣﺘﻐﻴﻴﺮي ﻛﻪ ﺧﺎرج از ﺗﻤﺎم ﺗﻮاﺑﻊ ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺎﺷﺪ داراي داﻣﻨﻪ ﻛﺎرﺑﺮدي ‪  Global‬ﺧﻮاﻫﺪ ﺑﻮد ‪ .‬ﻣﺘﻐﻴﻴﺮ‬
‫ﻫﺎي ‪  Global‬را ﻣﻲ ﺗﻮان در ﻫﺮ ﻗﺴﻤﺖ ﺑﺮﻧﺎﻣﻪ از ﺟﻤﻠﻪ درون ﺗﻮاﺑﻊ ﺑﻄﻮر ﻣﺸﺘﺮك اﺳﺘﻔﺎده ﻛﺮد ‪ .‬ﺑﺮاي‬
‫اﺳﺘﻔﺎده از ﻣﺘﻐﻴﻴﺮ درون ﺗﺎﺑﻊ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪  global‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﺑﻪ دو ﺻﻮرت اﺳﺖ ‪ .‬ﺑﻪ ﻣﺜﺎل‬
‫‪  global‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻧﻮع اول‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪16 | P a g e  ‬‬
‫‪ ‬‬
‫ﻧﻮع دوم ﻣﺜﺎل ‪global2‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪  Static‬‬

‫ﮔﺎﻫﻲ ﻣﺎ ﻣﻲ ﺧﻮاﻫﻴﻢ ﺑﻌﺪ از ﺗﻤﺎم ﺷﺪن دﺳﺘﻮرات ﺗﺎﺑﻊ ﻣﺘﻐﻴﻴﺮ ﻫﺎي ﻣﺤﻠﻲ آن ﺗﺎﺑﻊ و ﻣﻘﺎدﻳﺮ درون آن ﻫﺎ از‬
‫ﺑﻴﻦ ﻧﺮوﻧﺪ ﺗﺎ ﺑﺎر دﻳﮕﺮ ﻛﻪ آن ﺗﺎﺑﻊ اﺟﺮا ﺷﺪ ﻣﻘﺎدﻳﺮ ﻗﺒﻠﻲ درون آن ﻫﺎ ﻣﺤﻔﻮظ ﻣﺎﻧﺪه ﺑﺎﺷﻨﺪ و ﺑﺘﻮان از آن ﻫﺎ‬
‫اﺳﺘﻔﺎده ﻛﺮد ﺑﺮاي اﻳﻦ ﻛﺎر وﻗﺘﻲ ﻛﻪ ﺑﺮاي اوﻟﻴﻦ ﺑﺎر ﺑﺨﻮاﻫﻴﻢ ﻣﺘﻐﻴﻴﺮ را ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ از ﻋﺒﺎرت ‪ static‬‬
‫اﺳﺘﻘﺎده ﻣﻴﻜﻨﻴﻢ اﻣﺎ ﻓﺮاﻣﻮش ﻧﻜﻨﻴﺪ اﻳﻦ ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﻧﻴﺰ ﺑﻪ ﺻﻮرت ﻣﺤﻠﻲ ﻫﺴﺘﻨﺪ ﻳﻌﻨﻲ ﻓﻘﻂ ﺑﺮاي آن ﺗﺎﺑﻊ‬
‫ﺷﻨﺎﺧﺘﻪ ﻣﻲ ﺷﻮﻧﺪ ﺑﻪ ﻣﺜﺎل ‪ static‬دﻗﺖ ﻧﻤﺎﻳﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
 ‫‪17 | P a g e  ‬‬
‫‪ ‬‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪Parameter‬‬

‫اﻳﻦ ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﻣﺤﻠﻲ اﺳﺖ ﻛﻪ ﻣﻘﺪار آن در زﻣﺎن ﻓﺮاﺧﻮاﻧﻲ ﺗﺎﺑﻊ ﺑﺮاي آن ﻣﺘﻐﻴﻴﺮ ارﺳﺎل ﻣﻲ ﺷﻮد و ﻣﺤﻞ‬
‫ﺗﻌﺮﻳﻒ آن درون ﭘﺮاﻧﺘﺰ ﺟﻠﻮي ﺗﺎﺑﻊ اﺳﺖ‪.‬ﺑﻪ ﻣﺜﺎل ‪ parameter‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪ ‬‬ ‫‪ ‬‬

‫‪ ‬‬
‫‪18 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﺳﻮم‬
‫اﻧﻮاع ﻣﺘﻐﻴﻴﺮ ﻫﺎ‬

‫‪ PHP‬از ﻫﺸﺖ ﻧﻮع داده اﺻﻠﻲ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﻧﻤﺎﻳﺪ ‪ ,‬اﻟﺒﺘﻪ ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻧﻮع داده اﻳﻲ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ‬
‫ﻧﻮﻳﺲ ﻣﺸﺨﺺ ﻧﻤﻲ ﺷﻮد ﺑﻠﻜﻪ در زﻣﺎن اﺟﺮا ﺗﻮﺳﻂ ﺧﻮد ‪ PHP‬ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ‬
‫)(‪ Var_dump‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﻧﻮع داده اﻳﻲ ﻣﺘﻐﻴﻴﺮ را ﺑﺒﻴﻨﻴﻢ ‪ .‬اﻳﻦ اﻧﻮاع داده ﻋﺒﺎرﺗﻨﺪ از ‪  :‬‬

‫ﭼﻬﺎر ﻧﻮع داده اﺳﻜﺎﻟﺮ ‪:‬‬

‫‪  Boolean‬‬ ‫‪‬‬

‫‪  Integer‬‬ ‫‪‬‬
‫‪  Float‬‬ ‫‪‬‬
‫‪  String‬‬ ‫‪‬‬
‫دو ﻧﻮع داده ﺗﺮﻛﻴﺒﻲ ‪:‬‬

‫‪  Array‬‬ ‫‪‬‬

‫‪  Object‬‬ ‫‪‬‬
‫و در ﻧﻬﺎﻳﺖ دو ﻧﻮع داده ﻣﺨﺼﻮص ‪:‬‬

‫‪  Resource‬‬ ‫‪‬‬

‫‪Null‬‬ ‫‪‬‬

‫ﻧﻮع داده اﻳﻲ ‪  Boolean‬‬

‫ﻧﻮع داده اﻳﻲ ‪ Boolean‬ﺷﺎﻣﻞ دو ﻣﻘﺪار ‪ True‬و ‪ False‬اﺳﺖ و ﻓﻘﻂ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻜﻲ را درﻳﺎﻓﺖ ﻛﻨﺪ ‪.‬‬

‫ﻫﺮ داده اﻳﻲ در ‪ Boolean‬ﻣﻘﺪار ‪ True‬رو ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ﻣﮕﺮ اﻳﻨﻜﻪ‬

‫ﻋﺪد ﺻﻔﺮ )‪  ( 0‬‬ ‫‪‬‬

‫ﻋﺪد ﺻﻔﺮ ﻣﻤﻴﺰ ﺻﻔﺮ ) ‪  ( 0.0‬‬ ‫‪‬‬
‫رﺷﺘﻪ ﺧﺎﻟﻲ و ﻳﺎ رﺷﺘﻪ "‪  " 0‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪19 | P a g e  ‬‬
‫‪ ‬‬
‫ﻳﻚ آراﻳﻪ ﺑﺪون ﻋﻨﺼﺮ ‪ ‬‬ ‫‪‬‬
‫ﻳﻚ ﺷﺊ ﺑﺪون ﻣﺘﻐﻴﻴﺮ ﻋﻀﻮ ‪ ‬‬ ‫‪‬‬
‫ﻣﻘﺪار وﻳﮋه ‪  Null‬‬ ‫‪‬‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ Is_boll‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻔﻬﻤﻴﻢ ﻳﻚ ﻣﺘﻐﻴﻴﺮ از ﻧﻮع ‪ Boolean‬ﻫﺴﺖ ﻳﺎ ﺧﻴﺮ ‪ .‬ﺑﻪ ﻣﺜﺎل‬
‫‪ boolean‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻧﻮع داده اﻳﻲ ‪  Integer‬‬

‫از ﻧﻮع داده اﻳﻲ ﺻﺤﻴﺢ ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﻛﻨﺪ و ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ اﻋﺪاد ﺻﺤﻴﺢ را ﺑﻪ ﺻﻮرت دﺳﻴﻤﺎل)ﻣﺒﻨﺎي ‪( 10‬‬
‫‪ ,‬ﻫﮕﺰا دﺳﻴﻤﺎل )ﻣﺒﻨﺎي ‪ , ( 16‬اوﻛﺘﺎل )ﻣﺒﻨﺎي ‪ ( 8‬ﺑﻪ ﻛﺎر ﺑﺒﺮﻳﺪ اﻧﺪازه ﻧﻮع ‪ Integer‬ﺑﻪ ﺳﺨﺖ اﻓﺰار و ﺳﻴﺴﺘﻢ‬
‫ﻋﺎﻣﻞ ﺑﺴﺘﮕﻲ دارد ‪.‬‬

‫‪ ‬‬
‫‪20 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﺮاي ﻣﺜﺎل دو ﻋﺪد ‪ 123‬و ‪ -123‬ﻫﺮ دو از ﻧﻮع ‪ Integer‬ﻫﺴﺘﻨﺪ ﺑﺮاي ﻧﻮﺷﺘﻦ اﻋﺪاد در ﻣﺒﻨﺎي ‪ 16‬در اﺑﺘﺪاي‬
‫ﻋﺪد ﻋﻼﻣﺖ ‪ 0x‬را ﻣﻴﮕﺬارﻳﻢ ﻣﺜﻼ ﻋﺪد ‪ 123‬اﻳﻨﮕﻮﻧﻪ ﻣﻲ ﺷﻮد ‪ 0x123‬و ﺑﺮاي ﻧﻮﺷﺘﻦ اﻋﺪاد ر ﻣﺒﻨﺎي ‪ 8‬اﺑﺘﺪاي‬
‫ﻋﺪد ‪ 0‬ﻣﻴﮕﺬارﻳﻢ ‪.‬‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ Is_int‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻔﻬﻤﻴﻢ ﻛﻪ ﻳﻚ ﺗﺎﺑﻊ از ﻧﻮع ‪ Integer‬ﻫﺴﺖ ﻳﺎ ﻧﻪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ int‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻧﻮع داده اﻳﻲ ‪  Float‬‬

‫اﻳﻦ ﻧﻮع داده اﻳﻲ در ‪ PHP‬از ﻧﻮع ﻋﺪدي اﻋﺸﺎري ﭘﺸﺘﻴﺒﺎﻧﻲ ﻣﻲ ﻛﻨﺪ ‪ .‬اﻧﺪازه اﻳﻦ اﻋﺪاد ﺑﻪ ﻧﻮع ﺳﻴﺴﺘﻢ‬
‫ﻋﺎﻣﻞ و ﭘﺮدازﻧﺪه ﺑﺴﺘﮕﻲ دارد وﻟﻲ ﺣﺪاﻛﺜﺮ ﻋﺪد ‪ 1.8e308‬ﺑﺎ ‪ 14‬رﻗﻢ اﻋﺸﺎري را ﻣﻲ ﺗﻮان در ﻧﻈﺮ ﮔﺮﻓﺖ‪ .‬‬

‫‪ ‬‬
‫‪21 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ Is_float‬ﻣﻲ ﺗﻮاﻧﻴﻢ ﺑﻔﻬﻤﻴﻢ ﻛﻪ ﻳﻚ ﺗﺎﺑﻊ از ﻧﻮع ‪ Float‬ﻫﺴﺖ ﻳﺎ ﻧﻪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ float‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻧﻮع داده اﻳﻲ ‪  String‬‬

‫رﺷﺘﻪ ﻣﺠﻤﻮﻋﻪ اﻳﻲ از ﻛﺎراﻛﺘﺮﻫﺎ ﻣﻲ ﺑﺎﺷﺪ و در ‪ PHP‬از اﻳﻦ ﻧﻮع داده اﻳﻲ ﺑﺮاي ذﺧﻴﺮه رﺷﺘﻪ اﺳﺘﻔﺎده ﻣﻲ‬
‫ﺷﻮد ‪ PHP‬ﻫﻴﭻ ﻧﻮع ﻣﺤﺪودﻳﺘﻲ در ﻃﻮل رﺷﺘﻪ اﻳﺠﺎد ﻧﻤﻲ ﻛﻨﺪ ‪.‬‬

‫ﺑﺮاي ذﺧﻴﺮه رﺷﺘﻪ در ‪ PHP‬ﺑﻪ روش ﻣﻲ ﺗﻮاﻧﻴﻢ ﻋﻤﻞ ﻛﻨﻴﻢ ‪:‬‬

‫ﺑﺎ ﻛﺎراﻛﺘﺮ ﻫﺎي ﻧﻘﻞ ﻗﻮل ﺗﻜﻲ ‘‪  ‘   ‬‬ ‫‪‬‬

‫ﺑﺎ ﻛﺎراﻛﺘﺮ ﻫﺎي ﻧﻘﻞ ﻗﻮل ﺟﻔﺘﻲ " " ‪ ‬‬ ‫‪‬‬
‫ﺑﻪ روش ‪  Heredoc‬‬ ‫‪‬‬

‫ﺳﺎده ﺗﺮﻳﻦ روش ﺑﺮاي اﻳﺠﺎد رﺷﺘﻪ اﺳﺘﻔﺎده از ﻛﺎراﻛﺘﺮ ﻫﺎي ﻧﻘﻞ ﻗﻮل ﺗﻜﻲ اﺳﺖ و ﻋﻴﺐ آن اﻳﻦ اﺳﺖ ﻛﻪ‬
‫در آن ﻧﻤﻲ ﺗﻮاﻧﻴﻢ از ﻣﺘﻐﻴﻴﺮ اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﮔﺮ در ﻧﻮﺷﺘﻪ ﻣﺎن ﻧﻴﺎزﻣﻨﺪ اﺳﺘﻔﺎده از ﻛﺎراﻛﺘﺮ \ ﺑﺎﺷﻴﻢ ﻣﻴﺘﻮاﻧﻴﻢ‬
‫آن را ﻳﻚ ﺑﺎر ﻳﺎ دوﺑﺎر ﺑﻨﻮﻳﺴﻴﻢ در ﻫﺮ ﺻﻮرت ‪ PHP‬ﺑﺮاي ﻣﺎ ﻛﺎراﻛﺘﺮ \ را ﻳﻜﺒﺎر ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪string‬‬
‫ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪22 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫ﻳﻜﻲ دﻳﮕﺮ از روش ﻫﺎي اﻳﺠﺎد رﺷﺘﻪ اﺳﺘﻔﺎده از ﻛﺎراﻛﺘﺮﻫﺎي ﻧﻘﻞ ﻗﻮل ﺟﻔﺘﻲ اﺳﺖ ﻛﻪ ﺑﺎ اﺳﺘﻔﺎده از آن ﻣﺎ‬
‫دﻳﮕﺮ ﻣﺸﻜﻞ ﻛﺎراﻛﺘﺮ ﻧﻘﻞ ﻗﻮﻟﻲ ﺗﻜﻲ را ﻧﺪارﻳﻢ و ﻣﻴﺘﻮاﻧﻴﻢ از ﻣﺘﻐﻴﻴﺮ در آن اﺳﺘﻔﺎده ﻛﻨﻴﻢ در اﻳﻦ ﺣﺎﻟﺖ ﻧﻴﺰ‬
‫ﻣﺎ ﻣﻲ ﺗﻮاﻧﻴﻢ از ﻛﺪﻫﺎي وﻳﮋه اﻳﻲ ﺑﺮاي ﺗﻮﻟﻴﺪ ﻛﺎراﻛﺘﺮ ﻫﺎي ﺧﺎص اﺳﺘﻔﺎده ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﺟﺪول زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻛﺪ ﻫﺎي وﻳﮋه ﻣﻮرد اﺳﺘﻔﺎده در دﺳﺘﻮر ‪  echo‬‬

‫ﻛﺎراﻛﺘﺮ ‪ 10‬اﺳﻜﻲ را ﺗﻮﻟﻴﺪ ﻣﻲ ﻛﻨﺪ‬ ‫‪\n‬‬

‫ﻛﺎراﻛﺘﺮ ‪ 13‬اﺳﻜﻲ را ﺗﻮﻟﻴﺪ ﻣﻲ ﻛﻨﺪ‬ ‫‪\r‬‬

‫ﻣﻌﺎدل ﻛﺎراﻛﺘﺮ ﺗﺐ اﻓﻘﻲ ﻣﻲ ﺑﺎﺷﺪ‬ ‫‪\t‬‬

‫ﻛﺎراﻛﺘﺮ \ را اﻳﺠﺎد ﻣﻲ ﻧﻤﺎﻳﺪ‬ ‫\\‬

‫ﻛﺎراﻛﺘﺮ ‪ $‬را اﻳﺠﺎد ﻣﻲ ﻧﻤﺎﻳﺪ‬ ‫‪\$‬‬

‫ﻛﺎراﻛﺘﺮ " را اﻳﺠﺎد ﻣﻲ ﻧﻤﺎﻳﺪ‬ ‫”\‬

‫‪ ‬‬
‫‪23 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ string2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻳﻜﻲ دﻳﮕﺮ از روش ﻫﺎي اﻳﺠﺎد رﺷﺘﻪ در ‪ PHP‬اﺳﺘﻔﺎده از ﻫﺮدوك اﺳﺖ ‪ .‬اﻳﻦ روش ﺑﺮاي اﻳﺠﺎد رﺷﺘﻪ ﻫﺎي‬
‫ﻃﻮﻻﻧﻲ اﺳﺖ در اﻳﻦ روش ﺑﺮاي اﻳﺠﺎد رﺷﺘﻪ ﺑﺎﻳﺪ ﻣﺮاﺣﻞ زﻳﺮ را ﻃﻲ ﻛﺮد‬

‫‪ ‬‬ ‫اﺑﺘﺪا ﻛﺎراﻛﺘﺮﻫﺎي <<< را ﻧﻮﺷﺘﻪ و ﻳﻚ ﺷﻨﺎﺳﻪ دﻟﺨﻮاه را ذﻛﺮ ﻛﻨﻴﺪ‬ ‫‪‬‬
‫‪ ‬‬ ‫رﺷﺘﻪ ﻣﻮرد ﻧﻈﺮ را ﺑﻨﻮﻳﺴﻴﺪ‬ ‫‪‬‬
‫‪ ‬‬ ‫ﺷﻨﺎﺳﻪ اﺳﺘﻔﺎده ﺷﺪه در اﺑﺘﺪاي رﺷﺘﻪ را ﻧﻴﺰ ﺑﻨﻮﻳﺴﻴﺪ‬ ‫‪‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ string3‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ ﻣﺜﺎل از ﺷﻨﺎﺳﻪ ‪ EOD‬ﺑﺮاي ﻣﺸﺨﺺ ﻛﺮدن اﺑﺘﺪا و اﻧﺘﻬﺎي ﻧﻮﺷﺘﻪ اﺳﺘﻔﺎده‬
‫ﺷﺪه اﺳﺖ ﻧﺎم اﻳﻦ ﺷﻨﺎﺳﻪ اﺧﺘﻴﺎري اﺳﺖ و ﻣﻲ ﺗﻮاﻧﺪ ﻫﺮ ﻧﺎم دﻳﮕﻴﺮي ﺑﺎﺷﺪ وﻟﻲ ﻧﺒﺎﻳﺪ در ﻣﺘﻦ اﺻﻠﻲ ﺑﺎﺷﺪ‬
‫و از ﻗﻮاﻧﻴﻦ ﻧﺎم ﮔﺬاري ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﭘﻴﺮوي ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪24 | P a g e  ‬‬
‫‪ ‬‬
‫ﻧﻮع داده اﻳﻲ ‪  Array‬‬

‫ﺗﺎ ﻛﻨﻮن ﺑﺎ ﻣﺘﻐﻴﻴﺮ ﻫﺎ و ﻧﻘﺶ آﻧﻬﺎ در ‪ PHP‬آﺷﻨﺎ ﺷﺪﻳﺪ ‪ ,‬ﻫﻤﺎن ﮔﻮﻧﻪ ﻛﻪ دﻳﺪﻳﺪ ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﺗﻨﻬﺎ ﻗﺎﺑﻠﻴﺖ ذﺧﻴﺮه‬
‫ﻳﻚ ﻣﻘﺪار را دارا ﻣﻲ ﺑﺎﺷﺪ وﻟﻲ در ﻣﻘﺎﻳﺴﻪ آراﻳﻪ ﻫﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ ﭼﻨﺪﻳﻦ ﻣﻘﺪار را در ﺧﻮد ذﺧﻴﺮه ﻛﻨﻨﺪ ‪ .‬ﻳﻪ‬
‫آراﻳﻪ داراي ﭼﻨﺪ ﻋﻨﺼﺮ اﺳﺖ ﻫﺮ ﻋﻨﺼﺮ داراي ﻳﻚ ﻣﻘﺪار اﺳﺖ ‪ .‬در ‪ PHP‬ﻫﺮ آراﻳﻪ ﺑﻪ دو دﺳﺘﻪ آراﻳﻪ ﻫﺎي‬
‫اﻳﻨﺪﻛﺲ دار و آراﻳﻪ ﻫﺎي اﻧﺠﻤﻨﻲ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ اﻳﻦ دو ﻧﻮع در آراﻳﻪ در روش دﺳﺘﺮﺳﻲ ﺑﻪ ﻋﻨﺎﺻﺮﺷﺎن‬
‫ﻣﺘﻔﺎوت ﻫﺴﺘﻨﺪ ‪.‬‬

‫در آراﻳﻪ اﻳﻨﺪﻛﺲ دار ﻫﺮ ﻳﻚ از ﻋﻨﺎﺻﺮ آراﻳﻪ ﺑﺮ اﺳﺎس اﻳﻨﺪﻛﺲ ﻣﻮرد دﺳﺘﺮﺳﻲ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ﻛﻪ ﺑﻪ‬
‫ﺻﻮرت ﭘﻴﺸﻔﺮض ﻋﺪد ﺻﺤﻴﺢ اﺳﺖ و از ﺻﻔﺮ ﺷﺮوع ﻣﻲ ﺷﻮد ﺑﻪ ﻣﺜﺎل ‪ array‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫آراﻳﻪ اﻧﺠﻤﻨﻲ در ‪ PHP‬ﻣﺠﻤﻮﻋﻪ اﻳﻲ ﻣﺮﺗﺐ از ﻧﮕﺎﺷﺖ ﻫﺎ ﻣﻲ ﺑﺎﺷﺪ ‪ ,‬در ﻳﻚ ﻧﮕﺎﺷﺖ ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﻫﺮ‬
‫ﻳﻚ از ﻣﻘﺎدﻳﺮ ذﺧﻴﺮه ﺷﺪه در آراﻳﻪ ﻳﻚ ﻛﻠﻴﺪ دﻟﺨﻮاه اﻧﺘﺴﺎب داده ﻣﻲ ﺷﻮد ‪ .‬از اﻳﻦ ﻧﻮع آراﻳﻪ ﻣﻲ ﺗﻮان‬
‫ﺑﻪ ﺻﻮرت آراﻳﻪ ﻋﺎدي ‪ ,‬ﻟﻐﺖ ﻧﺎﻣﻪ ‪ ,‬ﭘﺸﺘﻪ ‪ ,‬ﺻﻒ ‪ ...  ,‬اﺳﺘﻔﺎده ﻛﺮد ﺑﻪ ﻣﺜﺎل ‪ array2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪25 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻧﻮع داده اﻳﻲ ‪  Object‬‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎﻳﻲ ﻛﻪ در داﺧﻞ ﻛﻼس ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ﮔﻔﺘﻪ ﻣﻲ ﺷﻮد ﺑﻪ ﻣﺜﺎل ‪ object‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫در اﻳﻦ ﻣﺜﺎل ﻛﻼﺳﻲ ﺑﻪ اﺳﻢ ‪ car‬ﺗﻌﺮﻳﻒ ﺷﺪه ﻛﻪ در آن ﻣﺘﻐﻴﻴﺮه ‪ color‬ﻳﻪ ﻣﺘﻐﻴﻴﺮ از ﻧﻮع ‪ object‬اﺳﺖ ‪.‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬
‫‪26 | P a g e  ‬‬
‫‪ ‬‬
‫ﻧﻮع داده اﻳﻲ ‪  NULL‬‬

‫اﻳﻦ ﻧﻮع داده اﻳﻲ ﻣﺨﺼﻮص ﻣﻲ ﺑﺎﺷﺪ و ﺗﻨﻬﺎ ﻳﻚ ﻣﻘﺪار ﻳﻌﻨﻲ ‪ NULL‬را ﻣﻲ ﮔﻴﺮد ‪ NULL .‬ﻣﺸﺨﺺ ﻣﻴﻜﻨﻨﺪ ﻛﻪ‬
‫ﻣﺘﻐﻴﻴﺮ داراي ﻣﻘﺪار ﻧﻤﻲ ﺑﺎﺷﺪ ‪ ,‬ﻳﻚ ﻣﺘﻐﻴﻴﺮ در ﺻﻮرﺗﻲ ‪ NULL‬ﺑﻪ ﺣﺴﺎب ﻣﻲ آﻳﺪ ﻛﻪ ﻳﻜﻲ از ﺷﺮاﻳﻂ زﻳﺮ را‬
‫دارا ﺑﺎﺷﺪ ‪:‬‬

‫‪ ‬‬ ‫ﻣﻘﺪار ‪ NULL‬ﺑﻪ آن اﺧﺘﺼﺎص داده ﺷﺪه ﺑﺎﺷﺪ‬ ‫‪‬‬

‫‪ ‬‬ ‫ﻫﻴﭻ ﻣﻘﺪاري ﺑﻪ آن اﺧﺘﺼﺎص ﻧﺪاده ﺷﺪه ﺑﺎﺷﺪ‬ ‫‪‬‬
‫‪ ‬‬ ‫ﺗﺎﺑﻊ )(‪ unset‬ﺑﺮ روي آن اﻋﻤﺎل ﺷﺪه ﺑﺎﺷﺪ‬ ‫‪‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ null‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
 ‫‪27 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﭼﻬﺎرم‬
‫ﺗﻮاﺑﻊ ﻛﺎر ﺑﺎ رﺷﺘﻪ‬

‫ﻣﻌﺮﻓﻲ ﭼﻨﺪ ﺗﺎﺑﻊ ﻛﻪ ﻣﺨﺼﻮص ﻛﺎر ﺑﺎ رﺷﺘﻪ ﻣﻲ ﺑﺎﺷﻨﺪ ‪  PHP.‬ﺗﻮاﺑﻊ زﻳﺎدي ﺑﺮاي ﻛﺎر ﺑﺎ رﺷﺘﻪ دارد ‪.‬‬

‫ﺗﺎﺑﻊ )(‪strlen‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ورودي ﻣﻴﮕﻴﺮد و ﺗﻌﺪاد ﻛﺎراﻛﺘﺮ ﻣﻮﺟﻮد در اﻳﻦ ورودي را ﺑﻪ ﻣﺎ ﻣﻲ دﻫﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ strlen‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫ﺗﺎﺑﻊ )(‪  strpos‬‬

‫اﻳﻦ ﺗﺎﺑﻊ دو ورودي ﻣﻴﮕﻴﺮد و ورودي دوﻣﻲ را در ورودي اوﻟﻲ ﺟﺴﺘﺠﻮ ﻣﻲ ﻛﻨﺪ و ﺷﻤﺎره ﻛﺎراﻛﺘﺮ را ﺑﺮ ﻣﻲ‬
‫ﮔﺮداﻧﺪ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ strpos‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺗﺎﺑﻊ )(‪strtolower‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ورودي ﻣﻴﮕﻴﺮد و ﺗﻤﺎم ﺣﺮوف ورودي را ﺑﻪ ﺣﺮوف ﻛﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻴﻜﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪strtolower‬‬
‫ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪28 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺗﺎﺑﻊ ‪strtoupper‬‬

‫اﻳﻦ ﺗﺎﺑﻊ دﻗﻴﻘﺎ ﺑﺮﻋﻜﺲ ﺗﺎﺑﻊ )(‪ strtolower‬ﻋﻤﻞ ﻣﻴﻜﻨﺪ و ﺗﻤﺎم ﺣﺮوف ورودي ﺧﻮد را ﺑﻪ ﺣﺮوف ﺑﺰرگ ﺗﺒﺪﻳﻞ‬
‫ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ strtoupper‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺗﺎﺑﻊ )(‪  ord‬‬

‫اﻳﻦ ﺗﺎﺑﻊ‪ ‬ﻳﻚ ورودي ﻣﻴﮕﺮد و ﻛﺪ اﺳﻜﻲ ﺣﺮف اول آن را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ ord‬ﻧﻮﭼﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪29 | P a g e  ‬‬
‫‪ ‬‬
‫ﺗﺎﺑﻊ )(‪  trim‬‬

‫اﻳﻦ ﺗﺎﺑﻊ‪  ‬ﻓﻀﺎ ﺧﺎﻟﻲ ﺳﻤﺘﻪ ﭼﭗ و راﺳﺖ ﭘﺎراﻣﺘﺮ ورودي را ﺣﺬف ﻣﻲ ﻛﻨﺪ اﻳﻦ ﺗﺎﺑﻊ ﺑﻴﺸﺘﺮ ﻣﻮاﻗﻌﻲ ﻛﻪ ﭘﺎراﻣﺘﺮي‬
‫از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﻣﻴﻜﻨﻴﻢ ﻛﺎرﺑﺮد دارد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ trim‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ اﺑﺘﺪا دو ورودي ﺑﻪ ﻧﺎم ‪ a‬و ‪ b‬دارﻳﻢ ﻛﻪ‬
‫داﺧﻞ آن دو ﻳﻚ ﻛﻠﻤﻪ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ وﻟﻲ در ﻣﻘﺪار ‪ a‬ﺳﻤﺘﻪ ﭼﭗ و راﺳﺖ آن ﻓﻀﺎ ﺧﺎﻟﻲ وﺟﻮد دارد‬
‫ﺑﺨﺎﻃﺮ ﻫﻤﻴﻦ در ﺷﺮط اول )دﺳﺘﻮر ‪ ( if‬ﻣﻴﺒﻴﻨﻢ ﻛﻪ اﻳﻦ دو ﺑﺎ ﻫﻢ ﻓﺮق دارﻧﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫اﻳﻦ ﺗﺎﺑﻊ‪  ‬ﻫﻤﭽﻨﻴﻦ ﻧﻴﺰ دو ﺗﺎﺑﻊ دﻳﮕﺮ ﻫﻢ دارد ﻛﻪ ﻳﻜﻲ )(‪ ltrim‬ﻛﻪ ﻓﻀﺎ ﺧﺎﻟﻲ ﺳﻤﺘﻪ ﭼﭗ را ﺣﺬف ﻣﻲ ﻛﻨﺪ و‬
‫ﻫﻤﭽﻨﻴﻦ ﺗﺎﺑﻊ )(‪ rtrim‬ﻛﻪ ﻓﻀﺎ ﺧﺎﻟﻲ ﺳﻤﺘﻪ راﺳﺖ را از ﺑﻴﻦ ﻣﻲ ﺑﺮد ‪.‬‬

‫‪ ‬‬
‫‪30 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﭘﻨﺠﻢ‬
‫ﻋﻤﻠﮕﺮ ﻫﺎ‬

‫ﻛﺎر اﺻﻠﻲ ﻳﻚ ﻋﻤﻠﮕﺮ اﻧﺠﺎم ﺑﺮﺧﻲ ﻛﺎرﻫﺎ ﺑﺮ روي ﻣﻘﺪار ﻳﻚ ﻣﺘﻐﻴﻴﺮ اﺳﺖ ‪ .‬آن ﻛﺎر ﻫﺎ ﻣﻲ ﺗﻮاﻧﻨﺪ اﺧﺘﺼﺎص ﻳﻚ‬
‫ﻣﻘﺪار ‪ ,‬ﺗﻐﻴﻴﺮ دادن ﻳﻚ ﻣﻘﺪار ‪ ,‬ﻳﺎ ﻣﻘﺎﻳﺴﻪ دو ﻳﺎ ﭼﻨﺪ ﻣﻘﺪار ﺑﺎﺷﻨﺪ ‪.‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎ ﺑﻪ ‪ 4‬ﻗﺴﻤﺖ ﺗﻘﺴﻴﻢ ﻣﻲ ﺷﻮﻧﺪ ﻛﻪ در اداﻣﻪ ﺑﻪ ﺗﺸﺮﻳﺢ ﻛﺎﻣﻞ آن ﻫﺎ ﻣﻲ ﭘﺮدازﻳﻢ ‪.‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي ﺗﺨﺼﻴﺺ ‪ ‬‬ ‫‪‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي رﻳﺎﺿﻲ ‪ ‬‬ ‫‪‬‬
‫ﻋﻤﻠﮕﺮ ﻫﺎي ﻣﻘﺎﻳﺴﻪ ‪ ‬‬ ‫‪‬‬
‫ﻋﻤﻠﮕﺮ ﻫﺎي ﻣﻨﻄﻘﻲ‬ ‫‪‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي ﺗﺨﺼﻴﺺ‬

‫ﺷﻤﺎ ﻗﺒﻼ ﻳﻚ ﻋﻤﻠﮕﺮ ﺗﺨﺼﻴﺺ را ﻋﻤﻼ دﻳﺪﻳﺪ ‪ ,‬ﻋﻼﻣﺖ ﻣﺴﺎوي ﻋﻤﻠﮕﺮ اﺻﻠﻲ ﺗﺨﺼﻴﺺ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﻪ ﺟﺪول‬
‫زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻋﻤﻠﻲ ﻛﻪ اﻧﺠﺎم ﻣﻲ دﻫﺪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﮕﺮ‬

‫;‪$a=$a+3‬‬ ‫;‪  $a+=3‬‬ ‫=‪+‬‬

‫;‪$a=$a‐3‬‬ ‫;‪$a‐=3‬‬ ‫=‐‬
‫;”‪$a=$a.”string‬‬ ‫;”‪$a.=”string‬‬ ‫=‪.‬‬
‫;‪  $a=$a*3‬‬ ‫;‪  $a*=3‬‬ ‫=* ‪ ‬‬
‫;‪  $a=$a/3‬‬ ‫;‪  $a/=3‬‬ ‫=‪  /‬‬
‫;‪  $a=$a%2‬‬ ‫;‪  $a%=2‬‬ ‫=‪  %‬‬
‫ﻋﻤﻠﮕﺮ ‪ /‬ﺑﺮاي ﺗﻘﺴﻴﻢ و ﻋﻤﻠﮕﺮ ‪ %‬ﺑﺮاي ﻣﺪ ) ﺑﺎ ﻗﻴﻤﺎﻧﺪه ( ﺑﻪ ﻛﺎر ﻣﻲ رود ‪.‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي رﻳﺎﺿﻲ‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي رﻳﺎﺿﻲ ﺑﺴﺎدﮔﻲ ﺑﺮاي اﻧﺠﺎم وﻇﺎﻳﻒ رﻳﺎﺿﻲ ﭘﺎﻳﻪ ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﺑﻪ ﺗﻮﺟﻪ ﻣﻘﺎﺑﻞ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪31 | P a g e  ‬‬
‫‪ ‬‬
‫ﻋﻤﻠﻲ ﻛﻪ اﻧﺠﺎم ﻣﻲ دﻫﺪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﮕﺮ‬
‫ﻣﻘﺎدﻳﺮ را ﺟﻤﻊ ﻣﻲ ﻛﻨﺪ‬ ‫;‪  $b=$a+3‬‬ ‫‪+‬‬
‫ﻣﻘﺎدﻳﺮ را ﺗﻔﺮﻳﻖ ﻣﻲ ﻛﻨﺪ‬ ‫;‪$b=$a‐3‬‬ ‫‐‬
‫ﻣﻘﺎدﻳﺮ را ﺿﺮب ﻣﻲ ﻛﻨﺪ ‪ ‬‬ ‫;‪  $b=$a*3‬‬ ‫*‪ ‬‬
‫ﻣﻘﺎدﻳﺮ را ﺗﻘﺴﻴﻢ ﻣﻲ ﻛﻨﺪ ‪ ‬‬ ‫;‪  $b=$a/3‬‬ ‫‪ /‬‬
‫ﺑﺎ ﻗﻴﻤﺎﻧﺪه را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b=$a%3‬‬ ‫‪ %‬‬
‫ﻣﺘﻐﻴﻴﺮ ‪ $a‬را ﺑﺮﻣﻴﮕﺮداﻧﺪ و ﺳﭙﺲ ﻣﻘﺪار ‪ $a‬را ﻳﻚ واﺣﺪ اﻓﺰاﻳﺶ ﻣﻲ دﻫﺪ‬ ‫;‪  $a++‬‬ ‫‪  ++‬‬
‫ﻣﺘﻐﻴﻴﺮ ‪ $a‬را ﻳﻚ واﺣﺪ اﻓﺰاﻳﺶ ﻣﻲ دﻫﺪ و ﺳﭙﺲ ﻣﻘﺪار ‪ $a‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  ++$a‬‬ ‫‪  ++‬‬
‫ﻣﺘﻐﻴﻴﺮ ‪ $a‬را ﺑﺮﻣﻴﮕﺮداﻧﺪ و ﺳﭙﺲ ﻣﻘﺪار ‪ $a‬را ﻳﻚ واﺣﺪ ﻛﺎﻫﺶ ﻣﻲ دﻫﺪ‬ ‫;‐‐‪  $a‬‬ ‫‐‐ ‪ ‬‬
‫ﻣﺘﻐﻴﻴﺮ ‪ $a‬را ﻳﻚ واﺣﺪ ﻛﺎﻫﺶ ﻣﻲ دﻫﺪ و ﺳﭙﺲ ﻣﻘﺪار ‪ $a‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  ‐‐$a‬‬ ‫‐‐ ‪ ‬‬
‫‪ ‬‬

‫ﻋﻤﻠﮕﺮ ﻫﺎي ﻣﻘﺎﻳﺴﻪ اﻳﻲ‬

‫اﻳﻦ ﻋﻤﻠﮕﺮ ﻫﺎ ﺑﺮاي ﻣﻘﺎﻳﺴﻪ دو ﻣﻘﺪار ﺑﻪ ﻛﺎر ﻣﻲ روﻧﺪ ‪ .‬ﺑﻪ ﺟﺪول زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻋﻤﻠﻲ ﻛﻪ اﻧﺠﺎم ﻣﻲ دﻫﺪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﮕﺮ‬

‫اﮔﺮ ﻣﻘﺪار ‪ $a‬و ‪ $b‬ﺑﺮاﺑﺮ ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b==$a‬‬ ‫==‬
‫اﮔﺮ ﻣﻘﺪار ‪ $a‬و ‪ $b‬ﺑﺮاﺑﺮ ﺑﻮده و ﻫﺮ دو ﻫﻢ ﻧﻮع ﺑﺎﺷﻨﺪ آﻧﮕﺎه ﻣﻘﺪار ‪ true‬را‬
‫;‪$b===$a‬‬ ‫===‬
‫ﺑﺮﻣﻴﮕﺮداﻧﺪ‬
‫اﮔﺮ ﻣﻘﺪار ‪ $a‬و ‪ $b‬ﺑﺮاﺑﺮ ﻧﺒﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b!=$a‬‬ ‫=! ‪ ‬‬
‫اﮔﺮ ﻣﻘﺪار ‪ $a‬و ‪ $b‬ﺑﺮاﺑﺮ ﻧﺒﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ‪ ‬‬ ‫;‪  $b<>$a‬‬ ‫>< ‪ ‬‬
‫اﮔﺮ ﻣﻘﺪار ‪ $a‬و ‪ $b‬ﺑﺮاﺑﺮ ﻧﺒﻮده ﻳﺎ ﻫﺮ دو ﻫﻢ ﻧﻮع ﺑﺎﺷﻨﺪ آﻧﮕﺎه ﻣﻘﺪار ‪ true‬را‬
‫;‪  $b!==$a‬‬ ‫==! ‪ ‬‬
‫ﺑﺮﻣﻴﮕﺮداﻧﺪ‬
‫اﮔﺮ ﻣﻘﺪار ‪ $b‬ﻛﻮﭼﻜﺘﺮ از ‪ $a‬ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b<$a‬‬ ‫<‪ ‬‬
‫اﮔﺮ ﻣﻘﺪار ‪ $b‬ﺑﺰرﮔﺘﺮ از ‪ $a‬ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b>$a‬‬ ‫>‪ ‬‬
‫اﮔﺮ ﻣﻘﺪار ‪ $b‬ﻛﻮﭼﻜﺘﺮ ﻣﺴﺎوي از ‪ $a‬ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b<=$a‬‬ ‫=< ‪ ‬‬
‫اﮔﺮ ﻣﻘﺪار ‪ $b‬ﺑﺰرﮔﺘﺮ ﻣﺴﺎوي از ‪ $a‬ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $b>=$a‬‬ ‫=> ‪ ‬‬

‫‪ ‬‬
 ‫‪32 | P a g e  ‬‬
‫‪ ‬‬
‫ﻋﻤﻠﮕﺮ ﻫﺎي ﻣﻨﻄﻘﻲ‬

‫اﻳﻦ ﻋﻤﻠﮕﺮ ﻫﺎ ﺑﺮاي اﻧﺠﺎم ﻋﻤﻠﻴﺎت ﻣﻨﻄﻘﻲ ﻣﺎﻧﻨﺪ ‪ and‬و ‪ or‬ﺑﻪ ﻛﺎر ﻣﻲ روﻧﺪ و ﻛﺎرﺑﺮد ﮔﺴﺘﺮده اي در دﺳﺘﻮرات‬
‫ﻣﺨﺘﻠﻒ ﻳﻚ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ دارﻧﺪ ‪.‬‬

‫ﻋﻤﻠﻲ ﻛﻪ اﻧﺠﺎم ﻣﻲ دﻫﺪ‬ ‫ﻣﺜﺎل‬ ‫ﻋﻤﻠﮕﺮ‬

‫اﮔﺮ ﻣﺘﻐﻴﻴﺮ ‪ $a‬و‪ $b ‬ﻫﺮ دو ﻣﻘﺪار ‪ true‬را داﺷﺘﻪ ﺑﺎﺷﻨﺪ آﻧﮕﺎه ‪ true‬را ﺑﺎز ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $a and $b‬‬ ‫‪and‬‬
‫اﮔﺮ ﺣﺪاﻗﻞ ﻳﻜﻲ از ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪ $a‬و ‪ $b‬ﻣﻘﺪار ‪ true‬را داﺷﺘﻪ ﺑﺎﺷﻨﺪ آﻧﮕﺎه ‪ true‬را ﺑﺎز ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪$a or $b‬‬ ‫‪or‬‬
‫اﮔﺮ ﻳﻜﻲ از ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪ $a‬و ‪ $b‬ﻣﻘﺪار ‪ false‬و دﻳﮕﺮي ﻣﻘﺪار ‪ true‬را داﺷﺘﻪ ﺑﺎﺷﻨﺪ آﻧﮕﺎه‪  true‬ﻣﻲ‬
‫;‪  $a xor $b‬‬ ‫‪  xor‬‬
‫ﺷﻮد‬
‫ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ‪ $a‬را ﻧﻘﻴﺺ ﻣﻲ ﻛﻨﺪ‬ ‫;‪  ! $a‬‬ ‫!‪ ‬‬
‫اﮔﺮ ﻣﺘﻐﻴﻴﺮ ‪ $a‬و‪ $b ‬ﻫﺮ دو ﻣﻘﺪار ‪ true‬را داﺷﺘﻪ ﺑﺎﺷﻨﺪ آﻧﮕﺎه ‪ true‬را ﺑﺎز ﻣﻴﮕﺮداﻧﺪ ‪ ‬‬ ‫;‪  $a && $b‬‬ ‫&& ‪ ‬‬
‫اﮔﺮ ﺣﺪاﻗﻞ ﻳﻜﻲ از ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪ $a‬و ‪ $b‬ﻣﻘﺪار ‪ true‬را داﺷﺘﻪ ﺑﺎﺷﻨﺪ آﻧﮕﺎه ‪ true‬را ﺑﺎز ﻣﻴﮕﺮداﻧﺪ‬ ‫;‪  $a || $b‬‬ ‫|| ‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬ ‫‪ ‬‬

‫‪ ‬‬
‫‪33 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﺷﺸﻢ‬
‫دﺳﺘﻮرات ﺷﺮﻃﻲ‬

‫زﺑﺎن ﻫﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﺎﺧﺘﺎر ﻳﺎﻓﺘﻪ داراي دﺳﺘﻮرات ﺷﺮﻃﻲ ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬دﺳﺘﻮرات ﺷﺮﻃﻲ ﺑﺎ ﺑﺮﻗﺮاري‬
‫ﺷﺮط ﺧﺎﺻﻲ ﻣﺠﻤﻮﻋﻪ اي از دﺳﺘﻮراﻟﻌﻤﻞ ﻫﺎ را اﺟﺮا ﻣﻲ ﻧﻤﺎﻳﻨﺪ ‪ PHP .‬دو ﻧﻮع دﺳﺘﻮر ﺷﺮﻃﻲ را اراﺋﻪ ﻣﻲ‬
‫ﻧﻤﺎﻳﺪ ‪  .‬‬

‫دﺳﺘﻮر ﺷﺮﻃﻲ ‪  if‬‬

‫اﻳﻦ دﺳﺘﻮر ﺑﺮ اﺳﺎس ﺷﺮط ﺧﺎﺻﻲ ﻣﺠﻤﻮﻋﻪ اي از دﺳﺘﻮرات را اﺟﺮا ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ if‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺑﺮﻧﺎﻣﻪ ﺑﺎﻻ ﻳﻚ ﺣﺎﻟﺖ ﺳﺎده ‪ if‬اﺳﺖ و ﻓﻘﻂ ﻳﻚ ﺣﺎﻟﺖ دارد اﮔﺮ ‪ a‬ﻛﻮﭼﻜﺘﺮ از ‪ b‬ﺑﺎﺷﺪ ﻣﺘﻦ ﭼﺎپ ﻣﻲ ﺷﻮد در‬
‫ﻏﻴﺮ اﻳﻨﺼﻮرت ﻫﻴﭻ ﻣﻘﺪاري ﭼﺎپ ﻧﻤﻲ ﺷﻮد ‪.‬‬

‫ﻧﻜﺘﻪ ‪ :‬در ‪ if‬اﮔﺮ ﺷﺮط ﻣﺎ ﻳﻚ ﺧﻂ ﺑﺎﺷﺪ ﻧﻴﺎز ﺑﻪ ﺑﺎز و ﺑﺴﺘﻪ ﻛﺮدن ﺑﻼك ﻧﻴﺴﺖ و ﺑﺮاي ﺧﻮاﻧﺎﻳﻲ ﺑﺮﻧﺎﻣﻪ از ﺑﻼك‬
‫ﺑﺎز و ﺑﺴﺘﻪ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ if2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪34 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﺑﺎﻻ دو ﺣﺎﻟﺖ ﺑﻴﺸﺘﺮ ﭘﻴﺶ ﻧﻤﻲ آﻳﺪ ﻳﺎ ‪ a‬ﺑﺰﮔﺘﺮ اﺳﺖ ﻳﺎ ‪ . b‬دﺳﺘﻮر ‪ else‬در ‪ if‬ﺑﻪ ﻣﻌﻨﻲ اﮔﺮ اﺳﺖ در‬
‫ﻣﺜﺎل ﺑﺎﻻ اﮔﺮ‪  a‬ﻛﻮﭼﻜﺘﺮ از ‪ b‬ﺑﺎﺷﺪ ﻣﺘﻦ اول ﭼﺎپ ﻣﻲ ﺷﻮد وﻟﻲ اﮔﺮ ‪ a‬ﺑﺰرﮔﺘﺮ از ‪ b‬ﺑﺎﺷﺪ ﻣﺘﻦ دوﻣﻲ ﭼﺎپ ﻣﻲ‬
‫ﺷﻮد ‪  .‬‬

‫‪ ‬دﺳﺘﻮر ﺷﺮﻃﻲ ‪  elseif‬‬

‫دﺳﺘﻮر ‪ elseif‬اﻳﻦ اﻣﻜﺎن را ﻓﺮاﻫﻢ ﻣﻲ ﻛﻨﺪ ﺗﺎ در ﺻﻮرت ﻋﺪم ﺑﺮﻗﺮاري ﺷﺮط دﺳﺘﻮر ‪ if‬ﺷﺮط ﻫﺎي دﻳﮕﺮي‬
‫را ﺑﺮرﺳﻲ ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ elseif‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﺑﺎﻻ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﺷﻮد ﻛﻪ آﻳﺎ ‪ $a‬ﻛﻮﭼﻜﺘﺮ از ‪ $b‬اﺳﺖ ﻳﺎ ﻧﻪ اﮔﺮ اﻳﻦ ﺷﺮط درﺳﺖ ﺑﺎﺷﺪ ﻣﻘﺪار‬
‫ﺗﻔﺎﺿﻞ ‪ a‬و ‪ b‬را ﭼﺎپ ﻣﻴﻜﻨﻴﻢ و اﮔﺮ ﺷﺮط درﺳﺖ ﻧﺒﺎﺷﺪ دوﺑﺎره ﺑﺮرﺳﻲ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ‪ a‬و ‪ b‬ﺑﺎ ﻫﻢ ﻣﺴﺎوي‬
‫ﻫﺴﺘﻨﺪ اﮔﺮ ﻣﺴﺎوي ﺑﻮدﻧﺪ ﻣﺠﻤﻮع دو را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ و اﮔﺮ ﻣﺴﺎوي ﻫﻢ ﻧﺒﻮدﻧﺪ ﺿﺮب دو ﻣﻘﺪار را ﭼﺎپ ﻣﻲ‬
‫ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
‫‪35 | P a g e  ‬‬
‫‪ ‬‬
‫‪ ‬دﺳﺘﻮر ﺷﺮﻃﻲ ‪  switch‬‬

‫در ﺑﻌﻀﻲ ﻣﻮاﻗﻊ ﻣﺎ ﻣﻴﺨﻮاﻫﻴﻢ ﺗﺎ ﺗﺴﺎوي ﻣﻘﺪار ﻳﻚ ﻣﺘﻐﻴﻴﺮ را ﺑﺎ ﻣﺠﻤﻮ ﻋﻪ اي از ﻣﻘﺎدﻳﺮ ﻣﺘﻔﺎوت ﺑﺮرﺳﻲ ﻛﻨﻴﻢ‬
‫و در ﺻﻮرت ﺗﺴﺎوي ﺑﺎ ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ﺑﺎ ﻫﺮ ﻳﻚ از اﻳﻦ ﻣﻘﺪار ﻫﺎ ﻣﺠﻤﻮﻋﻪ اي از دﺳﺘﻮرات را اﺟﺮا ﻛﻨﻴﻢ ‪ ,‬در‬
‫اﻳﻦ ﻣﻮاﻗﻊ از دﺳﺘﻮد ‪ switch‬اﺳﺘﻔﺎده ﻣﻴﻜﻨﻴﻢ ‪ .‬دﺳﺘﻮر ‪ switch‬ﻣﻌﺎدل ﻣﺠﻤﻮﻋﻪ اي از دﺳﺘﻮرات ‪ if‬اﺳﺖ‬
‫ﻛﻪ ﺑﺮ روي ﻳﻚ ﺷﺮط ﻳﺎ ﻋﺒﺎرت ﻳﻜﺴﺎن اﺟﺮا ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ switch‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﺑﺎﻻ دﺳﺘﻮر ‪ switch‬ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ‪ a‬را درﻳﺎﻓﺖ ﻛﺮده و آن را ﺑﺎ ﻣﻘﺎدﻳﺮ ‪ case‬ﻫﺎي ﺧﻮد ﻣﻘﺎﻳﺴﻪ ﻣﻲ‬
‫ﻛﻨﺪ وﻗﺘﻲ ﻫﻴﭽﻜﺪام از ‪ case‬ﻫﺎي دﺳﺘﻮر ‪ Switch‬ﺑﺎ ﻣﻘﺪار درﻳﺎﻓﺘﻲ ﻣﺴﺎوي ﻧﺒﺎﺷﺪ دﺳﺘﻮر داﺧﻞ ‪default‬‬
‫اﺟﺮا ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫‪36 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﻫﻔﺘﻢ‬
‫ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار‬

‫ﺣﻠﻘﻪ ﻫﺎ از ﻋﻨﺎﺻﺮ اﺻﻠﻲ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺳﺎﺧﺘﺎر ﻳﺎﻓﺘﻪ ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﺑﺎ ﻛﻤﻚ ﺣﻠﻘﻪ ﻫﺎ ﻣﻲ ﺗﻮاﻧﻴﻢ ﻣﺠﻤﻮﻋﻪ اﻳﻲ‬
‫از دﺳﺘﻮرات را ﺑﻪ دﻓﻌﺎت ﻣﺸﺨﺺ ﻳﺎ ﺗﺎ ﺑﺮﻗﺮاري ﺷﺮط ﺧﺎﺻﻲ اﺟﺮا ﻧﻤﺎﺋﻴﻢ‪.‬‬

‫دﺳﺘﻮر ‪  while‬‬

‫دﺳﺘﻮر ‪ while‬ﻳﻜﻲ از دﺳﺘﻮرات ﻻزم ﺑﺮاي اﻳﺠﺎد ﺣﻠﻘﻪ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬در ﺳﺎﺧﺘﺎر اﻳﻦ دﺳﺘﻮر از ﻳﻚ ﺷﺮط‬
‫اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد و ﺗﺎ ﺑﺮﻗﺮار ﺑﻮدن اﻳﻦ ﺷﺮط ‪ ,‬ﻣﺠﻤﻮﻋﻪ دﺳﺘﻮراﻟﻌﻤﻞ ﻫﺎي ﺣﻠﻘﻪ ‪ while‬ﺗﻜﺮار ﻣﻲ ﮔﺮدﻧﺪ ‪.‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ while‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫دﺳﺘﻮر ‪  do while‬‬

‫دﺳﺘﻮر ‪ do while‬ﻣﺸﺎﺑﻪ ﺣﻠﻘﻪ ‪ while‬اﺳﺖ ‪ .‬اﻟﺒﺘﻪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ ﺷﺮط ﺣﻠﻘﻪ در اﻧﺘﻬﺎي ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﭼﻚ‬
‫ﻣﻲ ﺷﻮد‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﺣﻠﻘﻪ ﺣﺪاﻗﻞ ﻳﻜﺒﺎر اﺟﺮا ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ dowhile‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪37 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫دﺳﺘﻮر ‪  for‬‬

‫از دﺳﺘﻮر ‪ for‬ﺑﻴﺸﺘﺮ زﻣﺎﻧﻲ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﺗﻌﺪاد دﻓﻌﺎت ﺗﻜﺮار را ﺑﺪاﻧﻴﻢ ‪ .‬اﻳﻦ ﺣﻠﻘﻪ داراي ﺳﻪ‬
‫ﻗﺴﻤﺖ اﺳﺖ ‪.‬‬

‫ﻣﻘﺪار دﻫﻲ ‪ :‬اﻳﻦ ﻗﺴﻤﺖ ﺗﻨﻬﺎ ﻳﻜﺒﺎر در اﺑﺘﺪار اﺟﺮاي ﺣﻠﻘﻪ اﺟﺮا ﻣﻲ ﮔﺮدد و اﻏﻠﺐ ﺑﺮاي ﻣﻘﺪار دﻫﻲ اﻳﻨﺪﻛﺲ‬
‫ﺣﻠﻘﻪ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪.‬‬

‫ﺷﺮط ‪ :‬ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ اﻳﻦ ﺷﺮط درﺳﺖ ﺑﺎﺷﺪ ‪ ,‬دﺳﺘﻮر زﻳﺮ ﺣﻠﻘﻪ ‪ for‬اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ ‪.‬‬

‫ﮔﺎم ﺣﻠﻘﻪ ‪ :‬ﺑﺮاي اﻓﺰاﻳﺶ ﻳﺎ ﻛﺎﻫﺶ ﻣﻘﺪار اﻳﻨﺪﻛﺲ ﺣﻠﻘﻪ ﺑﻪ ﻛﺎر ﻣﻲ رود ‪.‬‬

‫ﻻزم اﺳﺖ ﺑﺪاﻧﻴﻢ ﻛﻪ ﻫﺮ ﻛﺪام از اﻳﻦ ﻗﺴﻤﺖ ﻫﺎ اﺧﺘﻴﺎري ﻣﻲ ﺑﺎﺷﻨﺪ و در ﺻﻮرت ﻧﻴﺎز ﻣﻴﺘﻮاﻧﻴﻢ آن ﻫﺎ را‬
‫ﻧﻨﻮﻳﺴﻴﻢ و ﺟﺎي آن ﻫﺎ را ﺧﺎﻟﻲ ﺑﮕﺬارﻳﻢ ‪ .‬وﻟﻲ ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ اﮔﺮ ﺷﺮط ﺣﻠﻘﻪ را ﻧﻨﻮﻳﺴﻴﺪ ﺣﻠﻘﻪ‬
‫ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﻪ ﺣﻠﻘﻪ ﺑﻴﻨﻬﺎﻳﺖ ﺗﺒﺪﻳﻞ ﺧﻮاﻫﺪ ﺷﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ for‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ ﻣﺜﺎل اﻋﺪاد زوج ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 9‬ﭼﺎپ ﺷﺪه اﻧﺪ ‪.‬‬

‫‪ ‬‬
‫‪38 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫دﺳﺘﻮر ‪foreach‬‬

‫اﻳﻦ دﺳﺘﻮر در ‪ PHP‬ﻧﺴﺨﻪ ‪ 4‬اراﺋﻪ ﺷﺪ و ﺑﺮاي ﻛﺎر ﺑﺎ آراﻳﻪ ﻫﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺑﻨﺎﺑﺮاﻳﻦ اﮔﺮ ﺷﻤﺎ دﺳﺘﻮر‬
‫‪ foreach‬را ﺑﺎ ﻣﺘﻐﻴﻴﺮ ﻫﺎﻳﻲ از ﻧﻮع دﻳﮕﺮي ﺑﻪ ﻛﺎر ﺑﺒﺮﻳﺪ ﻳﻚ ﺧﻄﺎ اﻳﺠﺎد ﺧﻮاﻫﺪ ﺷﺪ ‪ .‬ﺑﻪ ﻃﻮر ﻛﻠﻲ ﺑﻪ دو روش‬
‫از اﻳﻦ دﺳﺘﻮر ﻣﻲ ﺗﻮان اﺳﺘﻔﺎده ﻛﺮد ‪.‬‬

‫در روش اول ﻳﻚ ورودي از ﺟﻨﺲ آراﻳﻪ ﺑﻪ ﺣﻠﻘﻪ ﻣﻲ دﻫﻴﻢ ﺑﻪ ﻣﺜﺎل ‪ foreach‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﻳﻚ‬
‫آراﻳﻪ اﻳﺠﺎد ﻧﻤﻮده اﻳﻢ و آن را ﺑﻪ ﺣﻠﻘﻪ ‪ foreach‬داده اﻳﻢ ‪ .‬ﺑﺮاي دادن آراﻳﻪ ﺑﻪ ﺣﻠﻘﻪ اﺑﺘﺪا ﻧﺎم آراﻳﻪ را‬
‫ﻣﻲ ﻧﻮﻳﺴﻴﻢ و ﺳﭙﺲ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ as‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ و ﺳﭙﺲ ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﺑﺮاي ذﺧﻴﺮه ﻣﻘﺎدﻳﺮ آراﻳﻪ‬
‫ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻣﻘﺎدﻳﺮ آراﻳﻪ از اول ﺗﺎ اﻧﺘﻬﺎ درون اﻳﻦ ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﺷﻮد ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در روش دوم دﺳﺘﻮر ‪ foreach‬ﻳﻚ ورودي از ﺟﻨﺲ آراﻳﻪ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻛﻪ اﻳﻦ آراﻳﻪ از ﺟﻨﺲ آراﻳﻪ‬
‫اﻧﺠﻤﻨﻲ اﺳﺖ ‪.‬‬

‫‪ ‬‬
‫‪39 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ foreach2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫دﺳﺘﻮر ‪Break‬‬

‫دﺳﺘﻮر ‪ Break‬ﺑﺮاي ﺧﺎﺗﻤﻪ دادن ﺑﻪ اﺟﺮاي ﺣﻠﻘﻪ ﻫﺎي ‪ for , foreach , while , do while‬و دﺳﺘﻮرات‬

‫‪ switch‬ﺑﻪ ﻛﺎر ﻣﻲ رود‪ .‬ﺑﻪ ﻣﺜﺎل ‪ break‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪40 | P a g e  ‬‬
‫‪ ‬‬
‫دﺳﺘﻮر ‪  Continue‬‬

‫اﻳﻦ دﺳﺘﻮر در ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار ﺑﻪ ﻛﺎر ﻣﻲ رود و زﻣﺎﻧﻲ ﻛﻪ اﺟﺮا ﻣﻲ ﺷﻮد ‪ PHP‬از ﺑﻘﻴﻪ دﺳﺘﻮرات ﺣﻠﻘﻪ ﺻﺮف‬
‫ﻧﻈﺮ ﻣﻲ ﻛﻨﺪ و ﻛﻨﺘﺮل ﺑﺮﻧﺎﻣﻪ را ﺑﻪ اﺑﺘﺪاي ﺣﻠﻘﻪ ﻣﻨﺘﻘﻞ ﻣﻲ ﻛﻨﺪ ‪ .‬ﻻزم ﺑﻪ ذﻛﺮ اﺳﺖ ﻛﻪ از اﻳﻦ دﺳﺘﻮر در‬
‫دﺳﺘﻮر ‪ switch‬ﻫﻢ ﻣﻲ ﺗﻮان اﺳﺘﻔﺎده ﻛﺮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ continue‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
 ‫‪41 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﻫﺸﺘﻢ‬
‫ﻧﺤﻮه اﻳﺠﺎد ﺗﻮاﺑﻊ‬

‫ﻳﻚ ﺗﺎﺑﻊ ﺑﻼﻛﻲ از ﻛﺪ ﻫﺎ اﺳﺖ ﻛﻪ ﻳﻜﺒﺎر ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ و در ﻗﺴﻤﺖ ﻫﺎي ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻣﻤﻜﻦ اﺳﺖ ﺑﻪ‬
‫دﻓﻌﺎت ﻣﺘﻌﺪد ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا ﮔﺮدد ‪  .‬در ‪ PHP‬ﺗﻮاﺑﻊ ﺑﺎ دﺳﺘﻮر اﻟﻌﻤﻞ ‪ function‬ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﺑﻪ‬
‫ﺷﻜﻞ ﺗﻮاﺑﻊ در دﻗﺖ ﻛﻨﻴﺪ ‪  .‬‬

‫ﭘﺎراﻣﺘﺮ ﻫﺎ ﺑﺎ )‪ ( , ‬از ﻫﻢ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻨﺪ ﺑﺪون ورودي ﺑﺎﺷﻨﺪ ‪ .‬ﺑﺮاي اﺳﺘﻔﺎده از ﺗﺎﺑﻊ اﮔﺮ‬
‫درون ﺗﺎﺑﻊ از دﺳﺘﻮر ‪ return‬ﻛﻪ ﺟﻠﻮﺗﺮ ﺑﺎ آن آﺷﻨﺎ ﻣﻲ ﺷﻮﻳﺪ اﺳﺘﻔﺎده ﺷﺪه ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﻧﺎم ﺗﺎﺑﻊ را ﻧﻮﺷﺘﻪ و‬
‫ﻳﺎ آن را ﭼﺎپ ﻧﻤﻮد ﻳﺎ درون ﻣﺘﻐﻴﻴﺮي ذﺧﻴﺮه ﻧﻤﺎﻳﻴﺪ ﺑﻪ ﻣﺜﺎل ‪ function‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻨﺪ ورودي داﺷﺘﻪ ﺑﺎﺷﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ function2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪42 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ورودي ﺗﻮاﺑﻊ ﻣﻲ ﺗﻮاﻧﻨﺪ ﻣﻘﺪار اوﻟﻴﻪ داﺷﺘﻪ ﺑﺎﺷﻨﺪ ﺑﻪ ﻣﺜﺎل ‪ function3‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻧﻜﺘﻪ ‪ :‬ﺑﻪ ﻃﻮر ﻛﻠﻲ ﻳﻚ ﺗﺎﺑﻊ ﻣﻤﻜﻦ اﺳﺖ ﻣﻘﺪاري را ﺑﺮ ﻧﮕﺮداﻧﺪ ‪ .‬در اﻳﻦ ﺣﺎﻟﺖ ﻣﺴﻠﻤﺎ در ﺑﺪﻧﻪ ﺗﺎﺑﻊ از دﺳﺘﻮر‬
‫‪ return‬اﺳﺘﻔﺎده ﻧﺨﻮاﻫﺪ ﺷﺪ ‪ ,‬در اﻏﻠﺐ ﻣﻮارد اﻳﻦ ﻧﻮع از ﺗﻮاﺑﻊ ﻧﺘﺎﺑﺞ ﺑﻪ دﺳﺖ آورده را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﺑﻌﻀﻲ از ﺗﻮاﺑﻊ از دﺳﺘﻮر ‪ return‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﺑﺮاي ﺑﺎزﮔﺸﺖ ﻣﻘﺪار ﺗﺎﺑﻊ اﺳﺖ ﺑﻪ ﻣﺜﺎل‬
‫‪ returnfunction‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬

‫‪ ‬‬
‫‪43 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﺤﺪوده ﻣﺘﻐﻴﻴﺮ‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎﻳﻲ ﻛﻪ در داﺧﻞ ﻳﻚ ﺗﺎﺑﻊ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ﻣﺘﻐﻴﻴﺮ ﻣﺤﻠﻲ ﻫﺴﺘﻨﺪ و ﻓﻘﻂ در داﺧﻞ آن ﺗﺎﺑﻊ ﻗﺎﺑﻞ‬
‫دﺳﺘﺮس ﻫﺴﺘﻨﺪ ‪ .‬ﻣﺘﻐﻴﻴﺮ ﻫﺎﻳﻲ ﻛﻪ در ﺑﻴﺮون ﺗﺎﺑﻊ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ﺑﻪ ﺻﻮرت ﺳﺮاﺳﺮي ﻫﺴﺘﻨﺪ و در داﺧﻞ‬
‫ﺗﺎﺑﻊ ﻗﺎﺑﻞ اﺳﺘﻔﺎده ﻧﻴﺴﺘﻨﺪ ﻫﻤﺎﻧﻄﻮر ﻛﻪ ﺑﺎ ﻣﺘﻐﻴﻴﺮ ‪ global‬آﺷﻨﺎ ﺷﺪﻳﺪ ﺑﻪ ﻛﻤﻚ آن ﻣﻲ ﺗﻮان از ﻣﺘﻐﻴﻴﺮ‬
‫ﺳﺮاﺳﺮي در داﺧﻞ ﺗﺎﺑﻊ اﺳﺘﻔﺎده ﻛﺮد ‪.‬‬

‫ﺗﻮاﺑﻊ ﺑﺎزﮔﺸﺘﻲ‬

‫زﻣﺎﻧﻲ ﻛﻪ ﻳﻚ ﺗﺎﺑﻊ ﺧﻮدش را ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﺪ ﺗﺎﺑﻊ ﺑﻪ ﺗﺎﺑﻊ ﺑﺎزﮔﺸﺘﻲ ﺗﺒﺪﻳﻞ ﻣﻲ ﺷﻮد ‪ .‬ﺑﻌﻀﻲ اوﻗﺎت ﻣﺴﺌﻠﻪ‬
‫اﻳﻲ ﻛﻪ ﺣﻞ ﻣﻲ ﻧﻤﺎﺋﻴﻢ ﺑﻪ ﻃﻮر ذاﺗﻲ ﺣﺎﻟﺖ ﺑﺎزﮔﺸﺘﻲ دارد و ﺑﺮاي ﺣﻞ ﻣﺴﺌﻠﻪ ﻻزم اﺳﺖ ﻣﺴﺌﻠﻪ ﻛﻪ ﺑﻪ واﺣﺪ‬
‫ﻫﺎي ﻛﻮﭼﻜﺘﺮي ﺷﻜﺴﺘﻪ ﺷﺪه و ﻳﻚ اﻟﮕﻮرﻳﺘﻢ ﺑﺮ روي ﺗﻤﺎﻣﻲ آﻧﻬﺎ اﻋﻤﺎل ﻣﻲ ﺷﻮد و اﻳﻦ ﻣﺴﺌﻠﻪ ﺑﻪ دﻓﻌﺎت‬
‫ﻣﺘﻌﺪد ﺗﻜﺮار ﻣﻲ ﮔﺮدد ‪ .‬اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ ﺑﺎزﮔﺸﺘﻲ در رﻳﺎﺿﻴﺎت ﻣﺘﺪاول ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﻣﺤﺎﺳﺒﻪ ﻓﺎﻛﺘﻮرﻳﻞ ﻳﻚ‬
‫ﻧﻤﻮﻧﻪ از ﻣﺴﺎﺋﻞ ﺑﺎزﮔﺸﺘﻲ اﺳﺖ ‪.‬در ﻣﺜﺎل ‪ functionbazgashti‬ﻳﻚ ﺗﺎﺑﻊ ﺑﺎزﮔﺸﺘﻲ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻓﺎﻛﺘﻮرﻳﻞ ﻋﺪد داده ﺷﺪه را ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﺪ ﺑﻪ ﻣﺜﺎل ‪ functionbazgashti‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪44 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﻧﻬﻢ‬
‫آراﻳﻪ ﻫﺎي ﻓﻮق ﺳﺮاﺳﺮي‬

‫ﻣﺘﻐﻴﻴﺮ ﻫﺎي از ﭘﻴﺶ ﺗﻌﺮﻳﻒ ﺷﺪه آراﻳﻪ ﻫﺎي ﻓﻮق ﺳﺮاﺳﺮي ﻫﻢ ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮﻧﺪ زﻳﺮا ﺑﺪون ﺗﻮﺟﻪ ﺑﻪ‬
‫ﻣﺤﺪوده و ﺑﺪون اﺳﺘﻔﺎده از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ global‬در ﻫﻤﻪ ﺟﺎي ﺑﺮﻧﺎﻣﻪ ﻗﺎﺑﻞ دﺳﺘﺮس ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﻣﺘﻐﻴﻴﺮ‬
‫ﻫﺎي از ﭘﻴﺶ ﺗﻌﺮﻳﻒ ﺷﺪه ﻣﻮﺟﻮد در زﺑﺎن ‪ PHP‬را در زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ﻛﻪ در اداﻣﻪ ﻛﺎرﺑﺮد ﻣﻮارد ﻣﻬﻢ‬
‫آن ﻫﺎ را ﺗﻮﺿﻴﺢ ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫‪  $GLOBALS‬‬ ‫‪‬‬

‫‪  $_SERVER‬‬ ‫‪‬‬
‫‪  $_GET‬‬ ‫‪‬‬
‫‪  $_POST‬‬ ‫‪‬‬
‫‪  $_COOKIE‬‬ ‫‪‬‬
‫‪  $_FILES‬‬ ‫‪‬‬
‫‪  $_ENV‬‬ ‫‪‬‬
‫‪  $_REQUEST‬‬ ‫‪‬‬
‫‪  $_SESSION‬‬ ‫‪‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪$GLOBALS‬‬

‫ﺗﻤﺎﻣﻲ ﻣﺘﻐﻴﻴﺮ ﺳﺮاﺳﺮي ﻣﻮﺟﻮد در ﻳﻚ ﺑﺮﻧﺎﻣﻪ ‪ PHP‬در اﻳﻦ آراﻳﻪ ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷﺪ ‪ .‬اﻟﺒﺘﻪ ﺑﻴﺸﺘﺮ ﻣﺘﻐﻴﻴﺮﻫﺎي‬
‫ﻣﻮﺟﻮد در اﻳﻦ آراﻳﻪ در ﺳﺎﻳﺮ آراﻳﻪ ﻫﺎي ﻓﻮق ﺳﺮاﺳﺮي ﻧﻴﺰ ﻣﻮﺟﻮد دارﻧﺪ ‪ .‬در ﻗﺴﻤﺖ ﻫﺎي ﻗﺒﻞ ﻧﺤﻮه‬
‫اﺳﺘﻔﺎده از اﻳﻦ ﻣﺘﻐﻴﻴﺮ را دﻳﺪه اﻳﺪ ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_SERVER‬‬

‫ﺗﻤﺎﻣﻲ داده ﻫﺎﻳﻲ ﻛﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه در ﻳﻚ ﭘﻴﺎم ﭘﺎﺳﺦ ‪ HTTP‬ﺑﻪ ﺳﺮوﻳﺲ ﮔﻴﺮﻧﺪه ارﺳﺎل ﻣﻲ ﻛﻨﺪ در اﻳﻦ‬
‫آراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ‪ .‬اﻳﻦ اﻃﻼﻋﺎت ﻋﺒﺎرﺗﻨﺪ از ‪:‬‬

‫ﻧﺎم اﺳﻜﺮﻳﭙﺖ در ﺣﺎل اﺟﺮا ‪ ‬‬ ‫‪‬‬

‫ﻧﺎم ﺳﺮوﻳﺲ دﻫﻨﺪه ‪ ‬‬ ‫‪‬‬
‫ﻧﺴﺨﻪ ‪  HTTP‬‬ ‫‪‬‬
‫‪ ‬‬
‫‪45 | P a g e  ‬‬
‫‪ ‬‬
‫آدرس ‪ IP‬راه دور ‪ ‬‬ ‫‪‬‬
‫‪  .....‬‬ ‫‪‬‬

‫در ﻣﺜﺎل زﻳﺮ ﭼﻨﺪ از اﻳﻦ اﻃﻼﻋﺎت ﻣﻬﻢ آورده ﺷﺪه اﺳﺖ ﺑﻪ ﻣﺜﺎل ‪ server$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_REQUEST‬‬

‫اﻳﻦ آراﻳﻪ ﺷﺎﻣﻞ ﻋﻨﺎﺻﺮ آراﻳﻪ ﻫﺎي ‪ $_GET‬و ‪ $_POST‬و ‪ $_COOKIE‬ﻣﻲ ﺑﺎﺷﺪ ‪ .‬در ﻣﺜﺎل زﻳﺮ ﺗﻮﺳﻂ ﻳﻚ‬
‫ﻓﺮم ورودي را از ﻛﺎرﺑﺮ ﻣﻴﮕﺮﻳﺪ و ﺑﺎ اﺳﺘﻔﺎده از آراﻳﻪ ‪ $_REQUEST‬ﻣﻘﺪار آن را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل‬
‫‪ request$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪46 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﻓﻮق ﻳﻚ ﻓﺮم ﺑﺮاي درﻳﺎﻓﺖ ورودي از ﻛﺎرﺑﺮ اﻳﺠﺎد ﺷﺪه اﺳﺖ ﻛﻪ از ﻣﺘﺪ ‪ POST‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﺪ‬
‫و ﺑﺎ زدن دﻛﻤﻪ ‪ Submit‬ﻣﻘﺪار درﻳﺎﻓﺘﻲ ﻛﺎرﺑﺮ ﺑﻪ ﻫﻤﻴﻦ ﺻﻔﺤﻪ ارﺳﺎل ﻣﻲ ﺷﻮد و اﻣﺎ در ﻗﺴﻤﺖ ‪ PHP‬ﻫﻢ‬
‫اﺑﺘﺪا ﻋﺪم وﺟﻮد ﭘﺎراﻣﺘﺮ ارﺳﺎﻟﻲ ‪ name‬اﺑﺘﺪا ﭼﻚ ﻣﻲ ﺷﻮد و اﮔﺮ اﻳﻦ ﻣﺘﻐﻴﻴﺮ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه‬
‫ﺑﺎﺷﺪ آن را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪$_POST‬‬

‫ﻳﻜﻲ از روش ﻫﺎي ارﺳﺎل داده ﻫﺎي ﻓﺮم ﺑﻪ اﺳﻜﺮﻳﭙﺖ ﺳﺮوﻳﺲ دﻫﻨﺪه ﻣﻲ ﺑﺎﺷﺪ ‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﻳﻚ ﻓﺮم داده‬
‫ﻫﺎي ﺧﻮد را ﺑﺎ ﻣﺘﺪ ‪ POST‬ﺑﻪ ﻣﻘﺼﺪ ﺑﻪ ﻣﻘﺼﺪ ارﺳﺎل ﻣﻲ ﻧﻤﺎﻳﺪ آﻧﮕﺎه اﻳﻦ داده ﻫﺎ در اﺳﻜﺮﻳﭙﺖ ﻣﻘﺼﺪ ﺑﺎ‬
‫آراﻳﻪ ‪ $_POST‬ﻗﺎﺑﻞ دﺳﺘﺮس ﺧﻮاﻫﻨﺪ ﺑﻮد ‪ .‬وﻗﺘﻲ ﻛﻪ ﻓﺮم داده ﻫﺎي ﺧﻮد را ﺑﺎ اﻳﻦ روش ارﺳﺎل ﻣﻲ ﻛﻨﺪ‬
‫داده ﻫﺎ ﺑﻪ ﺻﻮرت رﻣﺰ ﻧﮕﺎري ﺷﺪه ارﺳﺎل ﻣﻲ ﺷﻮﻧﺪ و در ‪ URL‬ﻧﻴﺰ ﻧﺸﺎن داده ﻧﻤﻲ ﺷﻮﻧﺪ و از اﻣﻨﻴﺖ ﺑﺎﻻﻳﻲ‬
‫ﻧﺴﺒﺖ ﺑﻪ ﻣﺘﺪ دﻳﮕﺮ ارﺳﺎل داده ‪ $_GET‬دارد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ post$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ ﻣﺜﺎل اﺑﺘﺪا ﺑﺎ ﺗﺎﺑﻊ ‪isset‬‬
‫ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﻣﺘﻐﻴﻴﺮ ‪ age‬ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ﺑﺎ ﻣﺘﺪ ‪ Post‬ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﻘﺪار ‪ false‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ و دﺳﺘﻮرات داﺧﻞ ‪if‬‬
‫اﺟﺮا ﻧﻤﻲ ﺷﻮد ‪ .‬ﺑﺎ زدن دﻛﻤﻪ ‪ Submit‬ﻫﺮ ﻣﻘﺪاري ﻛﻪ در ﻛﺎدر ﻧﻮﺷﺘﻪ ﺷﺪه ﺑﺎﺷﺪ ﭼﺎپ ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫‪47 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻣﺘﻐﻴﻴﺮ ‪$_GET‬‬

‫ﻳﻜﻲ دﻳﮕﺮ از روش ﻫﺎي ارﺳﺎل داده ﻫﺎي ﻓﺮم ﺑﻪ اﺳﻜﺮﻳﭙﺖ ﺳﺮوﻳﺲ دﻫﻨﺪه ﻣﻲ ﺑﺎﺷﺪ ‪ .‬زﻣﺎﻧﻲ ﻛﻪ ﻳﻚ ﻓﺮم‬
‫داده ﻫﺎي ﺧﻮد را ﺑﺎ ﻣﺘﺪ ‪ GET‬ﺑﻪ ﻣﻘﺼﺪ ارﺳﺎل ﻣﻲ ﻧﻤﺎﻳﺪ آﻧﮕﺎه اﻳﻦ داده ﻫﺎ در اﺳﻜﺮﻳﭙﺖ ﻣﻘﺼﺪ ﺑﺎ آراﻳﻪ‬
‫‪ $_GET‬ﻗﺎﺑﻞ دﺳﺘﺮس ﺧﻮاﻫﻨﺪ ﺑﻮد ‪ .‬وﻗﺘﻲ ﻛﻪ ﻓﺮم داده ﻫﺎي ﺧﻮد را ﺑﺎ اﻳﻦ روش ارﺳﺎل ﻣﻲ ﻛﻨﺪ داده ﻫﺎ‬
‫از ﻃﺮﻳﻖ ‪ URL‬ارﺳﺎل ﻣﻲ ﺷﻮﻧﺪ و اﻣﻨﻴﺖ ﻛﻢ دارد وﻟﻲ ﺳﺮﻋﺖ آن ﻧﺴﺒﺖ ﺑﻪ ﻣﺘﺪ ‪ post‬ﺑﻴﺸﺘﺮ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﻪ‬
‫ﻣﺜﺎل ‪ get$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﺑﺎ زدن دﻛﻤﻪ ‪ Submit‬ﻣﻲ ﺑﻴﻨﻴﺪ ﻛﻪ ﻫﺮ ﭼﻪ داﺧﻞ ﻛﺎدر ﻧﻮﺷﺘﻪ ﺷﻮد از ﻃﺮﻳﻖ ‪ Url ‬ﺑﻪ‬
‫ﺧﻮده ﺻﻔﺤﻪ ارﺳﺎل ﻣﻲ ﺷﻮد و ﭼﺎپ ﻣﻲ ﺷﻮد ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪48 | P a g e  ‬‬
‫‪ ‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_COOKIE‬‬

‫اﻳﻦ آراﻳﻪ ﺷﺎﻣﻞ ﺗﻤﺎﻣﻲ ﻛﻮﻛﻲ ﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﺗﻮﺳﻂ ﻣﺮورﮔﺮ وب ﺑﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه وب ارﺳﺎل ﺷﺪه اﺳﺖ‬
‫‪ .‬در اﺳﻜﺮﻳﭙﺖ ﻣﻘﺼﺪ ﺑﺮاي ﺧﻮاﻧﺪن ﻛﻮﻛﻲ ﻫﺎ از اﻳﻦ آراﻳﻪ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﻛﻮﻛﻲ ﻫﺎ داده ﻫﺎي ﻛﻮﭼﻜﻲ‬
‫ﻫﺴﺘﻨﺪ ﻛﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه آن ﻫﺎ را ﺑﺎ ﻛﻤﻚ ﻣﺮورﮔﺮ وب ﺑﺮ روي ﺳﻴﺴﺘﻢ ﻛﺎرﺑﺮان ﻣﻲ ﻧﻮﻳﺴﺪ ﺗﺎ ﻛﺎرﺑﺮان‬
‫را در ﻣﺮاﺟﻌﺎت ﺑﻌﺪي ﺗﺸﺨﻴﺺ دﻫﺪ ‪ .‬ﺑﺮاي ﻧﻮﺷﺘﻦ ﻛﻮﻛﻲ ﻫﺎ ﺑﺮ روي ﺳﻴﺴﺘﻢ ﻛﺎرﺑﺮان ﺗﺎﺑﻊ )(‪  setcookie‬ﺑﻪ‬
‫ﻛﺎر ﻣﻲ رود ‪ .‬اﻣﺮوزه ﺑﻪ دﻟﻴﻞ اﻣﻨﻴﺖ ﻛﻢ ﻛﻮﻛﻲ از آن ﺧﻴﻠﻲ ﻛﻢ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪  .‬‬

‫ﻣﻘﺎدﻳﺮ ﭘﻴﺸﻔﺮض دﺳﺘﻮر ‪ setcookie‬را در ﺟﺪول زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ‪.‬‬

‫ﻣﻘﺎدﻳﺮ ﭘﻴﺶ ﻓﺮض ﭘﺎراﻣﺘﺮﻫﺎ‬

‫ﻣﻘﺪار ﭘﻴﺶ ﻓﺮض ‪ ‬‬ ‫ﻧﺎم ﭘﺎراﻣﺘﺮ‬

‫‪) /‬ﺗﻤﺎﻣﻲ داﻳﺮﻛﺘﻮري ﻫﺎي ﺳﺮوﻳﺲ دﻫﻨﺪه (‬ ‫‪  path‬‬

‫داﻣﻨﻪ ﺳﺮوﻳﺲ ﺳﺮوﻳﺲ دﻫﻨﺪه اي ﻛﻪ ﻛﻮﻛﻲ را اﻳﺠﺎد ﻛﺮده اﺳﺖ‬ ‫‪domain‬‬

‫ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ ﺳﺮوﻳﺲ ﮔﻴﺮﻧﺪه وب ﺑﺴﺘﻪ ﺷﻮد ‪ ‬‬ ‫‪  Expire information‬‬

‫)ﻏﻴﺮ ﻓﻌﺎل ﺷﺪه( ‪  disabled‬‬ ‫‪  secure‬‬

‫در ﻣﺜﺎل زﻳﺮ ﺧﻂ اول ﺳﺎﺧﺘﺎر دﺳﺘﻮر ‪ setcookie‬ﻧﺸﺎن داده ﺷﺪه اﺳﺖ و در ﺧﻂ ﺑﻌﺪي ﻳﻚ ﻛﻮﻛﻲ ﺑﻪ اﺳﻢ‬
‫‪ name‬و ﻣﻘﺪار آن ﻧﻴﺰ ﻣﻘﺪار ﻣﺘﻐﻴﻴﺮ ‪ $name‬اﺳﺖ و زﻣﺎن اﻧﻘﻀﺎ آن زﻣﺎن ﺳﻴﺴﺘﻢ ﺑﻪ اﺿﺎﻓﻪ ‪ 3600‬ﺛﺎﻧﻴﻪ‬
‫اﺳﺖ ﻳﻌﻨﻲ ﻳﻚ ﺳﺎﻋﺖ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ cookie$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل در ﻗﺴﻤﺖ ‪ html‬ﻳﻚ ﻓﺮم ﺑﺮاي درﻳﺎﻓﺖ ﻧﺎم ﻛﺎرﺑﺮ ﻃﺮاﺣﻲ ﺷﺪه‬
‫اﺳﺖ ﻛﻪ ﺑﺎ ﻣﺘﺪ ‪ get‬ورودي ﻛﺎرﺑﺮ را ﺑﻪ ﻫﻤﻴﻦ ﺻﻔﺤﻪ ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪ .‬در ﻗﺴﻤﺖ ‪ PHP‬اﺑﺘﺪا ﺑﺎ ﺗﺎﺑﻊ ‪isset‬‬

‫‪ ‬‬
‫‪49 | P a g e  ‬‬
‫‪ ‬‬
‫ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ورودي اﻳﻲ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه ﻳﺎ ﺧﻴﺮ ‪ .‬اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ورودي ﻣﻴﮕﻴﺮد اﮔﺮ ﻣﺘﻐﻴﻴﺮي‬
‫ﻛﻪ ﺑﻪ اﻳﻦ ورودي ﻣﻲ دﻫﻴﻢ ﻗﺒﻼ اﻳﺠﺎد ﺷﺪه ﺑﺎﺷﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﻘﺪار‬
‫‪ false‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ‪ .‬اﮔﺮ ورودي ارﺳﺎل ﺷﺪه اﺳﺖ آن را در ﻛﻮﻛﻲ ﺑﻪ ﻣﺪت اﻧﻘﻀﺎ ﻳﻚ دﻗﻴﻘﻪ ذﺧﻴﺮه ﻣﻲ‬
‫ﻛﻨﻴﻢ و اﮔﺮ ورودي ارﺳﺎل ﻧﺸﺪه ﺑﺎﺷﺪ ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﻛﻮﻛﻲ ﻛﺎرﺑﺮ ﻛﻪ ﻣﺪت اﻧﻘﻀﺎ آن ﻳﻚ دﻗﻴﻘﻪ اﺳﺖ‬
‫وﺟﻮد دارد ﻳﺎ ﺧﻴﺮ اﮔﺮ وﺟﻮد داﺷﺖ آن را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_FILES‬‬

‫ﺷﺎﻣﻞ ﻓﺎﻳﻞ ﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﻛﺎرﺑﺮان ﺑﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه آﭘﻠﻮد ) ارﺳﺎل ( ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_ENV‬‬

‫ﺷﺎﻣﻞ اﻃﻼﻋﺎﺗﻲ درﺑﺎره ﺳﺮوﻳﺲ دﻫﻨﺪه و ‪ PHP‬ﻣﻲ ﺑﺎﺷﺪ ‪ .‬اﻃﻼﻋﺎﺗﻲ ﻫﻤﺎﻧﻨﺪ ﻧﺎم ﻛﺎﻣﭙﻴﻮﺗﺮ ‪ ,‬ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ‪,‬‬
‫دراﻳﻮ ﺳﻴﺴﺘﻢ در اﻳﻦ آراﻳﻪ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ‪.‬‬

‫ﻣﺘﻐﻴﻴﺮ ‪  $_SESSION‬‬

‫ﺷﺎﻣﻞ ﺗﻤﺎﻣﻲ ﻣﺘﻐﻴﻴﺮ ﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﻫﻢ اﻛﻨﻮن ﺑﻪ ﻋﻨﻮان ﻣﺘﻐﻴﻴﺮ ﺟﻠﺴﻪ ﺛﺒﺖ ﺷﺪه اﻧﺪ ‪ .‬ﺟﻠﺴﻪ ﻳﺎ ‪session‬‬
‫ﻳﻚ از روش ﻫﺎﻳﻲ اﺳﺖ ﻛﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه وب ﺑﺮاي ﺗﺸﺨﻴﺺ و اﻫﺮاز ﻫﻮﻳﺖ ﻛﺎرﺑﺮان در ﻣﺮاﺟﻌﺎت ﻣﺨﺘﻠﻒ‬
‫ﺑﻪ ﻛﺎر ﻣﻲ رود ‪ .‬ﺑﺮاي ﻫﺮ ﺟﻠﺴﻪ ﻣﻲ ﺗﻮان ﺑﻪ ﺗﻌﺪاد دﻟﺨﻮاه ﻣﺘﻐﻴﻴﺮ ﻫﺎي را ﺗﻌﺮﻳﻒ ﻛﺮد ‪ ,‬اﻳﻦ ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﺟﺰء‬

‫‪ ‬‬
‫‪50 | P a g e  ‬‬
‫‪ ‬‬
‫آراﻳﻪ ﻓﻮق ﺳﺮاﺳﺮي ‪ $_SESSION‬ﻣﻲ ﺷﻮﻧﺪ و در ﺟﻠﺴﻪ ﻗﺎﺑﻞ اﺳﺘﻔﺎده ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﺟﻠﺴﻪ ﺑﺎ دﺳﺘﻮر‬
‫)(‪ session_start‬ﺷﺮوع ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ session$‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫در اﻳﻦ ﻣﺜﺎل ﻓﺮﻣﻲ ﺑﺮاي ورود ﻛﺎرﺑﺮ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ و اﻣﺎ در ﻗﺴﻤﺖ ‪ PHP‬آن اﺑﺘﺪا ﺟﻠﺴﻪ را ﺷﺮوع ﻣﻲ‬
‫ﻛﻨﻴﻢ اﺑﺘﺪا ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ اﻃﻼﻋﺎت ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﻧﺸﺪه ﺑﺎﺷﺪ ﭼﻚ‬
‫ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﺟﻠﺴﻪ از دﻓﻌﻪ ﻗﺒﻞ وﺟﻮد دارد ﻳﺎ ﺧﻴﺮ اﮔﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ ﻣﻘﺪار آن را ﭼﺎپ ﻣﻴﻜﻨﻴﻢ وﻟﻲ‬
‫اﮔﺮ اﻃﻼﻋﺎت ارﺳﺎل ﺷﺪه ﺑﻮد ﻳﻚ ﺟﻠﺴﻪ را ﺷﺮوع ﻣﻴﻜﻨﻴﻢ و ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﺟﻠﺴﻪ ﻣﻲ ﺳﺎزﻳﻢ و اﺳﻢ ﻛﺎرﺑﺮ را‬
‫درون آن ﻗﺮار ﻣﻲ دﻫﻴﻢ و آدرس ‪  url‬ﻣﺮورﮔﺮ را ﺑﻪ دوﺑﺎره ﺑﻪ ﺧﻮد اﻳﻦ ﺻﻔﺤﻪ ﻗﺮار ﻣﻲ دﻫﻴﻢ و ﺳﭙﺲ‬
‫ﻟﻴﻨﻜﻲ ﺑﺮاي ﭘﺎﻳﺎن ﺟﻠﺴﻪ و ﺧﺮوج ﻛﺎرﺑﺮ ﻗﺮار ﻣﻲ دﻫﻴﻢ ﻛﻪ اﮔﺮ ﻛﺎرﺑﺮ روي ﻟﻴﻨﻚ ﻛﻠﻴﻚ ﻛﻨﺪ ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﺑﻪ ﻧﺎم‬
‫‪ action‬را ﺑﺎ ﻣﻘﺪار ‪ logout‬ﺑﻪ ﻫﻤﻴﻦ ﺻﻔﺤﻪ ﺑﺎ ﻣﺘﺪ ‪ get‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ و در ‪ if‬آﺧﺮ ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﻛﺎرﺑﺮ‬
‫روي اﻳﻦ ﻟﻴﻨﻚ ﻛﻠﻴﻚ ﻛﺮده اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ﻛﻠﻴﻚ ﻛﺮده ﺑﺎﺷﺪ ﺟﻠﺴﻪ را ﭘﺎﻳﺎن ﻣﻴﺪﻫﻴﻢ و دوﺑﺎره ﻣﺮورﮔﺮ را‬
‫ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺟﺎع ﻣﻲ دﻫﻴﻢ ‪ .‬اﻳﻦ ﻣﺜﺎل درﺳﺖ ﻫﻤﺎﻧﻨﺪ ﺻﻔﺤﻪ ‪ login‬ﻛﺎرﺑﺮان ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫‪ ‬‬
‫‪51 | P a g e  ‬‬
‫‪ ‬‬
‫دﺳﺘﻮر ‪  include‬‬

‫از اﻳﻦ دﺳﺘﻮر ﺑﺮاي ﭘﻴﻮﺳﺖ ﻛﺮدن ﻣﺤﺘﻮﻳﺎت ﻳﻚ ﻓﺎﻳﻞ ‪ PHP‬درون ﻳﻚ ﻓﺎﻳﻞ دﻳﮕﺮ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‪ .‬در‬
‫اﻳﻦ ﺣﺎﻟﺖ ﺳﺮور ‪ PHP‬در ﻫﻨﮕﺎم اﺟﺮاي ﺻﻔﺤﻪ ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ اﺿﺎﻓﻪ ﺷﺪه راﺧﻮاﻧﺪه و آن را ﺑﺎ ﺻﻔﺤﻪ اول‬
‫ﺗﺮﻛﻴﺐ ﻣﻲ ﻛﻨﺪ ﺳﭙﺲ ﺧﺮوﺟﻲ را در ﻗﺎﻟﺐ ﻳﻚ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ ‪ .‬در ﺗﺼﻮﻳﺮ ﻓﻮق اﺑﺘﺪا در ﺧﻂ اول‬
‫ﻧﺤﻮه اﺳﺘﻔﺎده از دﺳﺘﻮر ‪ include‬را ﻧﺸﺎن ﻣﻲ دﻫﺪ و در ﺧﻂ دوم ﻣﻘﺪار ﻓﺎﻳﻞ ‪ menu.php‬ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ‬
‫ﭘﻴﻮﺳﺖ ﺷﺪه اﺳﺖ ‪.‬‬

‫دﺳﺘﻮر ‪  require‬‬

‫اﻳﻦ دﺳﺘﻮر ﻫﻤﺎﻧﻨﺪ دﺳﺘﻮر ‪ include‬ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ و ﺑﺮاي ﭘﻴﻮﺳﺖ ﻛﺮدن ﻓﺎﻳﻞ ﺑﻪ ﻛﺎر ﻣﻲ رود اﻣﺎ اﻳﻦ دو‬
‫دﺳﺘﻮر ﺑﺎ ﻫﻢ ﺗﻔﺎوت ﻫﺎﻳﻲ دارﻧﺪ ‪ .‬ﺗﻔﺎوت ﺑﻴﻦ دﺳﺘﻮر ‪ include ‬و ‪ require‬اﻳﻦ اﺳﺖ ﻛﻪ اﮔﺮ ﻓﺎﻳﻞ ﻓﺮﺧﻮاﻧﻲ‬
‫ﺷﺪه وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ و ﻳﺎ ﭘﺮﻣﻴﺸﻦ ﻻزم ﺑﺮاي ﺧﻮاﻧﺪن ﻳﺎ اﺟﺮا را ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ دﺳﺘﻮر ‪ include‬ﻓﻘﻂ‬
‫ﻳﻪ ‪ warning‬ﺑﺮ ﻣﻴﮕﺮداﻧﺪ و ﺑﺮﻧﺎﻣﻪ را اداﻣﻪ ﻣﻲ دﻫﺪ اﻣﺎ دﺳﺘﻮر ‪ require‬ﻳﻚ ‪ error‬ﺑﺮ ﻣﻴﮕﺮداﻧﺪ و اﺟﺮا‬
‫ﺑﺮﻧﺎﻣﻪ را ﻣﺘﻮﻗﻒ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫اﻳﻦ ﺗﻔﺎوت از ﻧﻈﺮ اﻣﻨﻴﺘﻲ ﻣﻬﻢ اﺳﺖ ﻓﺮض ﻛﻨﻴﺪ ﺑﺮاي ﻣﺤﻴﻂ ادﻣﻴﻦ ﻓﺎﻳﻞ ‪ check.php‬را ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﻛﻨﻴﺪ‬
‫و در اﻳﻦ ﻓﺎﻳﻞ ﺻﺤﺖ ﻛﺎرﺑﺮ ﺻﻮرت ﻣﻲ ﮔﻴﺮد و اﮔﺮ ﻛﺎرﺑﺮ درﺳﺖ ﺑﺎﺷﺪ اداﻣﻪ ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﻣﻲ ﺷﻮد و ﮔﺮ ﻧﻪ‬
‫ﺑﻪ ﺻﻔﺤﻪ ﻗﺒﻞ ارﺟﺎ ﻣﻲ ﺷﻮد ﺣﺎل اﮔﺮ اﻳﻦ ﻓﺎﻳﻞ را ﺑﺎ دﺳﺘﻮر ‪ Include ‬ﭘﻴﻮﺳﺖ ﻛﺮده ﺑﺎﺷﻴﻢ ﻳﻚ ‪warning‬‬
‫رخ ﻣﻲ دﻫﺪ و ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﺤﻴﻂ اﻣﻴﻦ ﻣﻲ رود وﻟﻲ اﮔﺮ ﺑﺎ دﺳﺘﻮر ‪ require‬ﻓﺮاﺧﻮاﻧﻲ ﺷﻮد اﺟﺮا ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ‬
‫ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫‪52 | P a g e  ‬‬
‫‪ ‬‬
‫دﺳﺘﻮر )(‪ include_once‬و )(‪  require_once‬‬

‫ﺗﺼﻮر ﻛﻨﻴﺪ در ﻓﺎﻳﻞ ‪ index.php‬ﻓﺎﻳﻞ ‪ x‬و ‪ y‬ﭘﻴﻮﺳﺖ ﺷﺪه اﻧﺪ و درون ﻓﺎﻳﻞ ‪ x‬ﻓﺎﻳﻞ ‪ y‬ﭘﻴﻮﺳﺖ ﺷﺪه اﺳﺖ‬
‫در اﻳﻦ ﺻﻮرت ﺷﻤﺎ ﻓﺎﻳﻞ ‪ y‬را دوﺑﺎر ﭘﻴﻮﺳﺖ ﻛﺮده اﻳﺪ ‪ .‬اﻳﻨﻜﺎر اﮔﺮ روال اﺟﺮا ﻛﺪ ﻫﺎ را ﺧﺮاب ﻧﻜﻨﺪ ﺑﺎﻋﺚ‬
‫ﭘﺮدازش ﺑﻴﺶ از ﺣﺪ ﻣﻲ ﺷﻮد در اﻳﻦ ﻣﻮاﻗﻊ ﺑﻬﺘﺮ اﺳﺖ از دﺳﺘﻮر ‪ include_once‬و ﻳﺎ دﺳﺘﻮر‬
‫‪ require_once‬اﺳﺘﻔﺎده ﻛﻨﻴﻢ اﻳﻦ دو دﺳﺘﻮر ﻛﻤﻚ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻓﺎﻳﻞ را ﻳﻜﺒﺎر ﭘﻴﻮﺳﺖ ﻛﻨﻴﻢ اﮔﺮ ﻓﺎﻳﻠﻲ را‬
‫ﻗﺒﻼ ﻳﻜﺒﺎر ﻓﺮاﺧﻮاﻧﻲ ﻛﺮده اﻳﻢ و ﺑﻪ ﻫﺮ دﻟﻴﻠﻲ دوﺑﺎره آن را ﻓﺮاﺧﻮاﻧﻲ ﻛﻨﻴﻢ دﻓﻌﻪ دوم ‪ ,‬ﺳﻮم و‪ ..‬ﻓﺮاﺧﻮاﻧﻲ‬
‫ﺻﻮرت ﻧﻤﻴﮕﻴﺮد وﻃﺒﻴﻌﺘﺎ اﮔﺮ ﻗﺒﻼ ﻓﺮاﺧﻮاﻧﻲ ﻧﺸﺪه ﺑﻮد آن را ﻓﺮﺧﻮاﻧﻲ ﻣﻲ ﻛﻨﺪ ‪ .‬ﻓﺮق اﻳﻦ دو دﺳﺘﻮر ﻫﻢ‬
‫ﻣﺎﻧﻨﺪ اﻳﻦ دﺳﺘﻮر ﻫﺎ ﺑﺪون ﻛﻠﻤﻪ ‪ once‬اﺳﺖ ‪.‬‬

‫‪ ‬‬
‫‪53 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ دﻫﻢ‬
‫‪ PHP‬و ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎ‬

‫‪ PHP‬ﻗﺎﺑﻠﻴﺖ ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﻓﺎﻳﻞ ﻫﺎي ﺳﺮوﻳﺲ دﻫﻨﺪه را دارد ‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ ﻣﻲ ﺗﻮان ﺑﺮﻧﺎﻣﻪ ﻫﺎي ﻛﺎرﺑﺮدي‬
‫ﻣﺘﻌﺪدي ر اﻧﻮﺷﺖ ﺗﺎ از ﻓﺎﻳﻞ ﺳﻴﺴﺘﻢ ﺳﺮوﻳﺲ دﻫﻨﺪه اﺳﺘﻔﺎده ﻛﺮده و ﻳﺎ ﻓﺎﻳﻞ ﻫﺎﻳﻲ را ﺑﺮ روي ﺳﺮوﻳﺲ‬
‫دﻫﻨﺪه اﻳﺠﺎد ﻳﺎ ﺗﻐﻴﻴﺮ دﻫﻨﺪ ‪ PHP .‬ﺑﺮ روي ﻟﻴﻨﻮﻛﺲ ﺑﻪ ﻋﻨﻮان ﻫﻤﺎن ﻛﺎرﺑﺮ ﻣﺎﻟﻚ ﺳﺮوﻳﺲ دﻫﻨﺪه آﭘﺎﭼﻲ و‬
‫ﺑﺮ روي وﻳﻨﺪوز ﺑﻪ ﻋﻨﻮان ﻛﺎرﺑﺮ ﻣﻴﻬﻤﺎن اﺟﺮا ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻃﻮر ﻛﻠﻲ ‪ PHP‬ﻗﺎﺑﻠﻴﺖ ﺑﺎ ﻫﺮ ﻧﻮع ﻓﺎﻳﻠﻲ را دارد‬
‫اﻣﺎ ﺑﻪ ﻃﻮر ﻣﻌﻤﻮل ﻣﺎ ﺑﺎ ﻓﺎﻳﻞ ﻫﺎي ﻣﺘﻨﻲ ﻛﺎر ﺧﻮاﻫﻴﻢ ﻛﺮد ‪ .‬ﺳﻴﺴﺘﻢ ﻫﺎي ﻋﺎﻣﻞ وﻳﻨﺪوز و ﻟﻴﻨﻮﻛﺲ ﺗﻔﺎوت ﻫﺎي‬
‫ﻣﺘﻌﺪدي در ﻛﺎر ﺑﺎ ﻓﺎﻳﻞ ﻫﺎ دارﻧﺪ ‪ .‬ﻳﻜﻲ از اﻳﻦ ﺗﻔﺎوت ﻫﺎ ﺑﻪ ﻧﺤﻮه ﻣﺸﺨﺺ ﻛﺮدن ﻣﺴﻴﺮ ﻫﺎ ﻣﺮﺑﻮط ﻣﻲ ﺷﻮد ‪.‬‬
‫ﺑﻪ ﻃﻮر ﻣﺜﺎل ﺑﺮاي ﻣﺸﺨﺺ ﻛﺮدن ﻣﺴﻴﺮ ﻳﻚ ﻓﺎﻳﻞ در ﻟﻴﻨﻮﻛﺲ و ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎي ﻫﻤﺎﻧﻨﺪ ﻳﻮﻧﻴﻜﺲ از‬
‫ﻛﺎراﻛﺘﺮ ‪ /‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬در ﻗﺴﻤﺖ زﻳﺮ ﻧﺤﻮه اﺳﺘﻔﺎده از ﻣﺴﻴﺮ در ﺗﺎﺑﻊ ‪ fopen‬آﻣﺪه اﺳﺖ ‪:‬‬
‫‪/home/dan/data/data.txt‬‬

‫در ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞ وﻳﻨﺪوز ﻧﻴﺰ ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل زﻳﺮ از ﻛﺎراﻛﺘﺮ \ ﺑﺮاي ﻣﺴﻴﺮ ﻫﺎ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪:‬‬
‫‪c:\mydocs\data.txt‬‬

‫اﻟﺒﺘﻪ در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺨﻮاﻫﻴﺪ ﻣﺴﻴﺮ ﻫﺎي وﻳﻨﺪوز را در ﺗﻮاﺑﻊ ﻣﺨﺘﻠﻒ ‪ PHP‬ﺑﻪ ﻛﺎر ﺑﺮﻳﺪ ﺑﺎﻳﺪ ﺑﻪ ﺟﺎي ﻳﻚ‬
‫ﻛﺎراﻛﺘﺮ \ از دو ﻛﺎراﻛﺘﺮ \\ اﺳﺘﻔﺎده ﻛﻨﻴﺪ ﺑﻪ ﻃﻮر ﻣﺜﺎل اﮔﺮ ﻣﺴﻴﺮ ‪ c:\mydocs\data.txt‬را در ﻳﻚ ﺗﺎﺑﻊ‬
‫‪ PHP‬ﺑﻪ ﻛﺎر ﺑﺮﻳﺪ ﺑﺎﻳﺪ اﻳﻦ ﻣﺴﻴﺮ را ﺑﻪ ﺻﻮرت زﻳﺮ ﺗﻐﻴﻴﺮ دﻫﻴﺪ ‪  c:\\mydocs\\data\\data.txt :‬‬

‫ﺗﺎﺑﻊ ‪  fopen‬‬

‫اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﺑﺎز ﻛﺮدن ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻛﺎر ﻣﻲ رود و ‪ handle‬ﻣﺮﺗﺒﻂ ﺑﺎ ﻓﺎﻳﻞ ﺑﺎز ﺷﺪه را ﺑﺮ ﻣﻲ ﮔﺮداﻧﺪ ‪ .‬اﻳﻦ‬
‫ﺗﺎﺑﻊ ﺳﻪ آرﮔﻮﻣﻨﺖ زﻳﺮ را درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ‪:‬‬

‫ﻧﺎم ﻓﺎﻳﻞ ‪ ‬‬ ‫‪‬‬

‫ﻣﺪ ‪ ‬‬ ‫‪‬‬
‫آرﮔﻮﻣﻨﺖ اﺧﺘﻴﺎري ‪ ‬‬ ‫‪‬‬

‫‪ ‬‬
‫‪54 | P a g e  ‬‬
‫‪ ‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ ﻓﺎﻳﻞ ﺑﻪ درﺳﺘﻲ ﺑﺎز ﺷﻮد ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ ﻳﻚ ﻣﻘﺪار ﺻﺤﻴﺢ ﻣﺜﺒﺖ ﺧﻮاﻫﺪ ﺑﻮد اﮔﺮ در ﺑﺎز‬
‫ﻛﺮدن ﻓﺎﻳﻞ ﻣﺸﻜﻠﻲ ﺑﻪ وﺟﻮد آﻳﺪ آﻧﮕﺎه اﻳﻦ ﻣﻘﺪار ﺻﻔﺮ ﺧﻮاﻫﺪ ﺷﺪ ‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ ﺑﻌﺪ از ﺑﺎز ﻛﺮدن ﻳﻚ ﻓﺎﻳﻞ‬
‫ﺑﻬﺘﺮ اﺳﺖ ﺑﺮرﺳﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ ﻓﺎﻳﻞ ﺑﻪ درﺳﺘﻲ ﺑﺎز ﺷﺪه اﺳﺖ ﻳﺎ ﻧﻪ ‪ .‬ﺑﻪ ﻛﺪ زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫آرﮔﻮﻣﻨﺖ اول آدرس ﻓﺎﻳﻠﻲ اﺳﺖ ﻛﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ آن را ﺑﺎز ﻛﻨﻴﻢ ‪ .‬اﻳﻦ ﻣﺴﻴﺮ ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ ﻃﻮر ﻧﺴﺒﻲ ﻳﺎ ﺑﻪ‬
‫ﻃﻮر ﻣﻄﻠﻖ ذﻛﺮ ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻃﻮر ﻣﺜﺎل اﮔﺮ داﻳﺮﻛﺘﻮري ﺳﺮوﻳﺲ دﻫﻨﺪه وب ﻣﺎ ‪ d:\in\wwwroot‬ﺑﺎﺷﺪآﻧﮕﺎه‬
‫دﺳﺘﻮر )”‪ fopen(“./data.txt”,”w‬ﻳﻚ ﻓﺎﻳﻞ ﺟﺪﻳﺪ ﺑﻨﺎم ‪ data‬را در داﻳﺮﻛﺘﻮري وب ﺳﺎﻳﺖ ﻳﻌﻨﻲ‬
‫‪ d:\in\wwwroot‬اﻳﺠﺎد ﺧﻮاﻫﺪ ﻧﻤﻮد اﻳﻦ ﻣﺴﻴﺮ ﻧﺴﺒﻲ ﻣﻲ ﺑﺎﺷﺪ وﻟﻲ اﮔﺮ آدرس ﻓﺎﻳﻞ را ﺑﻪ ﺻﻮرت‬
‫‪ d:\in\wwwroot‬وارد ﻛﻨﻴﻢ آدرس ﻣﻄﻠﻖ ﻧﺎﻣﻴﺪه ﻣﻲ ﺷﻮد و ﻳﻚ ﻓﺎﻳﻞ در آن ﻣﺴﻴﺮ اﻳﺠﺎد ﺧﻮاﻫﺪ ﻧﻤﻮد ‪.‬‬

‫آرﮔﻮﻣﻨﺖ دوم ﺗﺎﺑﻊ ‪  fopen‬‬

‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻣﻘﺪار‬
‫ﻓﺎﻳﻞ را ﺑﺮاي ﺧﻮاﻧﺪن ﺑﺎز ﻣﻲ ﻛﻨﺪ و ﻧﺸﺎﻧﮕﺮ ﻣﻮﻗﻌﻴﺖ ﺟﺎري ﻓﺎﻳﻞ را در اﺑﺘﺪاي ﻓﺎﻳﻞ ﻗﺮار ﻣﻲ‬
‫‪ r‬‬
‫دﻫﺪ‬
‫ﻓﺎﻳﻞ را ﺑﺮاي ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﺑﺎز ﻣﻲ ﻛﻨﺪ و ﻧﺸﺎﻧﮕﺮ ﻣﻮﻗﻌﻴﺖ ﺟﺎري ﻓﺎﻳﻞ را در اﺑﺘﺪاي ﻓﺎﻳﻞ‬
‫‪r+‬‬
‫ﻗﺮار ﻣﻲ دﻫﺪ‬
‫ﻓﺎﻳﻞ را ﺑﺮاي ﻧﻮﺷﺘﻦ ﺑﺎز ﻣﻲ ﻛﻨﺪ و ﺗﻤﺎﻣﻲ ﻣﺤﺘﻮاي ﻓﺎﻳﻞ را از ﺑﻴﻦ ﻣﻲ ﺑﺮد ‪ .‬اﮔﺮ ﻓﺎﻳﻞ ﻗﺒﻼ و ﺟﻮد‬
‫‪w‬‬
‫ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ آﻧﮕﺎه آن را اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‬
‫ﻓﺎﻳﻞ را ﺑﺮاي ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ ﺑﺎز ﻣﻲ ﻛﻨﺪ و ﺗﻤﺎﻣﻲ ﻣﺤﺘﻮاي ﻓﺎﻳﻞ را از ﺑﻴﻦ ﻣﻲ ﺑﺮد ‪ .‬اﮔﺮ ﻓﺎﻳﻞ‬
‫‪w+‬‬
‫ﻗﺒﻼ و ﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ آﻧﮕﺎه آن را اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‬
‫ﻓﺎﻳﻞ را ﺑﺎز ﻣﻲ ﻛﻨﺪ ﺗﺎ اﻃﻼﻋﺎﺗﻲ را ﺑﻪ اﻧﺘﻬﺎي آن ﺑﻴﻔﺰاﻳﻴﻢ ‪ .‬ﻣﺤﺘﻮاي ﻓﺎﻳﻞ ﺑﺎز ﺷﺪه را از ﺑﻴﻦ ﻧﻤﻲ‬
‫‪a‬‬
‫ﺑﺮد و اﮔﺮ ﻓﺎﻳﻞ ﻗﺒﻼ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ آﻧﮕﺎه آن را اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‬
‫ﻓﺎﻳﻞ را ﺑﺮاي ﺧﻮاﻧﺪن و اﻓﺰودن اﻃﻼﻋﺎت ﺑﻪ اﻧﺘﻬﺎي آن ﺑﺎز ﻣﻲ ﻛﻨﺪ ‪ .‬ﻣﺤﺘﻮاي ﻓﺎﻳﻞ را از ﺑﻴﻦ ﻧﻤﻲ‬
‫‪a+‬‬
‫ﺑﺮد و اﮔﺮ ﻓﺎﻳﻞ ﻗﺒﻼ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ آﻧﮕﺎه آن را اﻳﺠﺎد ﻣﻲ ﻛﻨﺪ‬

‫‪ ‬‬
‫‪55 | P a g e  ‬‬
‫‪ ‬‬
‫ﺗﺎﺑﻊ ‪fclose‬‬

‫ﺑﻌﺪ از اﻳﻨﻜﻪ ﭘﺮدازش ﻫﺎ و ﻋﻤﻠﻴﺎت ﻣﻮرد ﻧﻈﺮ را ﺑﺮ روي ﻓﺎﻳﻞ ﺑﺎز ﺷﺪه اﻧﺠﺎم دادﻳﻢ ﺑﺎﻳﺪ ﻓﺎﻳﻞ را ﺑﺒﻨﺪﻳﻢ ﺑﻪ‬
‫ﻫﻤﻴﻦ ﻣﻨﻈﻮر ﺑﺎﻳﺪ از ﺗﺎﺑﻊ ‪ fclose‬اﺳﺘﻔﺎده ﻛﺮد ‪ .‬اﻳﻦ ﺗﺎﺑﻊ ﻓﺎﻳﻞ ﺑﺎز ﺷﺪه را ﻣﻲ ﺑﻨﺪد در ﺻﻮرﺗﻲ ﻛﻪ اﻳﻦ‬
‫ﻋﻤﻠﻴﺎت را ﺑﺎ ﻣﻮﻓﻘﻌﻴﺖ اﻧﺠﺎم دﻫﺪ ﻣﻘﺪار ‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﻘﺪار ‪ false‬را ﺑﺮ ﻣﻲ‬
‫ﮔﺮداﻧﺪ ‪.‬‬

‫ﺑﺪﺳﺖ آوردن اﻃﻼﻋﺎت ﻓﺎﻳﻞ‬

‫ﻓﺎﻳﻞ ﻫﺎ ﻋﻼوه ﺑﺮ اﻃﻼﻋﺎت ﻛﻪ ﻧﮕﻬﺪاري ﻣﻲ ﻛﻨﻨﺪ اﻃﻼﻋﺎﺗﻲ را ﻧﻴﺰ درﺑﺎره ي ﺧﻮدﺷﺎن دارا ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﻧﺎم ‪,‬‬
‫اﻧﺪازه ‪ ,‬زﻣﺎن ﺗﻐﻴﻴﺮ و ‪ .....‬از ﺟﻤﻠﻪ اﻃﻼﻋﺎت ﻳﻚ ﻓﺎﻳﻞ ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬در ‪ PHP‬ﺗﺎﺑﻊ )(‪ stat‬ﻣﺎ را ﻗﺎدر ﻣﻲ ﺳﺎزد‬
‫درﺑﺎره ﻳﻚ ﻓﺎﻳﻞ اﻃﻼﻋﺎﺗﻲ را ﺑﺪﺳﺖ آورﻳﻢ ‪.‬‬

‫ﻋﻨﺎﺻﺮ آراﻳﻪ ﺑﺎزﮔﺸﺘﻲ ﺗﺎﺑﻊ )(‪  stat‬‬

‫اﻃﻼﻋﺎت‬ ‫ﻧﺎم‬ ‫اﻳﻨﺪﻛﺲ‬
‫ﺷﻤﺎره ‪  device‬‬ ‫‪  dev‬‬ ‫‪0‬‬
‫ﺷﻤﺎره ‪  incode‬‬ ‫‪ino‬‬ ‫‪1‬‬
‫ﻣﺪ ﺣﺎﻓﻈﻪ ‪  incode‬‬ ‫‪mode‬‬ ‫‪2‬‬
‫ﺗﻌﺪاد ﻟﻴﻨﻚ ﻫﺎ‬ ‫‪nlink‬‬ ‫‪3‬‬
‫ﺷﻨﺎﺳﻪ ﻛﺎرﺑﺮ ﻣﺎﻟﻚ‬ ‫‪uid‬‬ ‫‪4‬‬
‫ﺷﻨﺎﺳﻪ ﮔﺮوه ﻣﺎﻟﻚ‬ ‫‪gid‬‬ ‫‪5‬‬
‫ﻧﻮع وﺳﻴﻠﻪ‬ ‫‪rdev‬‬ ‫‪6‬‬
‫اﻧﺪازه ﺑﺮ ﺣﺴﺐ ﺑﺎﻳﺖ‬ ‫‪size‬‬ ‫‪7‬‬
‫زﻣﺎن آﺧﺮﻳﻦ دﺳﺘﻴﺎﺑﻲ‬ ‫‪atime‬‬ ‫‪8‬‬
‫‪ ‬‬
‫‪56 | P a g e  ‬‬
‫‪ ‬‬
‫زﻣﺎن آﺧﺮﻳﻦ ﺗﻐﻴﻴﺮ‬ ‫‪mtime‬‬ ‫‪9‬‬
‫زﻣﺎن آﺧﺮﻳﻦ ﺗﻐﻴﻴﺮ‬ ‫‪ctime‬‬ ‫‪10‬‬
‫اﻧﺪازه ﺑﻼك ﻓﺎﻳﻞ ﺳﻴﺴﺘﻢ‬ ‫‪blksize‬‬ ‫‪11‬‬
‫ﺗﻌﺪاد ﺑﻼك ﻫﺎي اﺧﺘﺼﺎص ﻳﺎﻓﺘﻪ‬ ‫‪blocks‬‬ ‫‪12‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ stat‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪57 | P a g e  ‬‬
‫‪ ‬‬
‫ﺗﺎﺑﻊ )(‪  fread‬‬

‫اﻳﻦ ﺗﺎﻳﻊ ﺑﺮاي ﺧﻮاﻧﺪن ﻳﻚ رﺷﺘﻪ از ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻛﺎر ﻣﻲ رود ‪ .‬ﺗﺎﺑﻊ )(‪ fread‬ﻳﻚ ﻓﺎﻳﻞ و ﻳﻚ ﻣﻘﺪار ﺻﺤﻴﺢ‬
‫را ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﻨﺖ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﺳﭙﺲ ﺑﻪ اﻧﺪازه ﻣﺸﺨﺺ از ﻓﺎﻳﻞ ﻣﻮرد ﻧﻈﺮ ﺧﻮاﻧﺪه و آن را ﺑﺮ ﻣﻲ‬
‫ﮔﺮداﻧﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ fread‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﻓﺎﻳﻞ ‪ data.txt‬ﺑﺮاي ﺧﻮاﻧﺪن ﺑﺎز ﻣﻲ ﺷﻮد و از اول آن‬
‫ﺑﻪ ﻣﻴﺰان ‪ 8‬ﻛﺎراﻛﺘﺮ ﺧﻮاﻧﺪه ﻣﻲ ﺷﻮد و در ﻣﺘﻐﻴﻴﺮ ‪ $data‬ذﺧﻴﺮه ﻣﻲ ﺷﻮد ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺗﺎﺑﻊ )(‪  fwrite‬‬

‫از اﻳﻦ ﺗﺎﺑﻊ ﺑﺮاي ﻧﻮﺷﺘﻦ اﻃﻼﻋﺎت ﺑﺮ روي ﻳﻚ ﻓﺎﻳﻞ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺗﺎﺑﻊ ‪ fwrite‬ﻫﻤﺎﻧﻨﺪ ﺗﺎﺑﻊ )(‪fread‬‬
‫دو آرﮔﻮﻣﺎن ﻣﻲ ﮔﻴﺮد ‪.‬اﻳﻦ ﺗﺎﺑﻊ آرﮔﻮﻣﻨﺖ دوم را در ﻓﺎﻳﻞ ﻣﺸﺨﺺ ﺷﺪه ﺗﻮﺳﻂ آرﮔﻮﻣﻨﺖ اوﻟﻲ ﻣﻲ ﻧﻮﻳﺴﺪ و‬
‫ﺳﭙﺲ ﺗﻌﺪاد ﻛﺎراﻛﺘﺮ ﻫﺎي ﻧﻮﺷﺘﻪ ﺷﺪه را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ و در ﺻﻮرﺗﻲ ﻛﻪ اﻳﻦ ﺗﺎﺑﻊ ﺑﺎ ﺧﻄﺎﻳﻲ ﻣﻮاﺟﻪ ﺷﻮد ﻣﻘﺪار‬
‫‪ -1‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ fwrite‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪58 | P a g e  ‬‬
‫‪ ‬‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻫﻤﭽﻨﺎن ورودي ﺳﻮم ﻫﻢ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻣﻴﺰان ﺣﺪاﻛﺜﺮ ﻧﻮﺷﺘﻦ در ﻓﺎﻳﻞ اﺳﺖ ﺑﻪ ﺷﻜﻞ زﻳﺮ‬
‫ﻧﮕﺎه ﻛﻨﻴﺪ ﻋﺪد ‪ 4‬ﺑﻪ ﻣﻌﻨﻲ اﻳﻦ اﺳﺖ ﻛﻪ در ﻓﺎﻳﻞ ﺑﺎز ﺷﺪه رﺷﺘﻪ ‪ Mohs‬ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ Upload‬ﻛﺮدن ﻓﺎﻳﻞ‬

‫ﺳﺎﻳﺖ ﻫﺎي ﻣﺨﺘﻠﻒ اﻳﻨﺘﺮﻧﺘﻲ ﻫﻤﺎﻧﻨﺪ ﻳﺎﻫﻮ اﻣﻜﺎن آﭘﻠﻮد ﻓﺎﻳﻞ ﻫﺎ را ﻓﺮاﻫﻢ ﻣﻲ آوردﻧﺪ ‪ .‬در اﻳﻦ ﺳﺎﻳﺖ ﻫﺎ‬
‫ﻛﺎرﺑﺮ ﻣﻲ ﺗﻮاﻧﺪ ﻓﺎﻳﻞ ﻫﺎي ﻣﻮرد ﻧﻈﺮ را از ﺳﻴﺴﺘﻢ ﺧﻮد ﺑﻪ ﺳﺮوﻳﺲ دﻫﻨﺪه ارﺳﺎل ﻧﻤﺎﻳﺪ ‪ PHP .‬ﻧﻴﺰ ﻗﺎﺑﻠﻴﺖ‬
‫ﻣﺪﻳﺮﻳﺖ ﻋﻤﻠﻴﺎت آﭘﻠﻮد ﻓﺎﻳﻞ ﻫﺎ را دارا ﻣﻲ ﺑﺎﺷﺪ ‪ .‬اﻟﺒﺘﻪ زﻣﺎﻧﻲ ﻛﻪ ﺷﻤﺎ ﺑﻪ ﻛﺎرﺑﺮان اﻣﻜﺎن آﭘﻠﻮد ﻓﺎﻳﻞ ﻫﺎ را‬
‫ﻣﻲ دﻫﻴﺪ ﻣﻤﻜﻦ اﺳﺖ ﻣﺸﻜﻼت اﻣﻨﻴﺘﻲ ﺑﺮاي ﺳﺮوﻳﺲ دﻫﻨﺪه ﺷﻤﺎ ﺑﻪ وﺟﻮد آﻳﺪ ﻟﺬا ﺑﻪ ﻫﻨﮕﺎم ﻓﻌﺎل ﺳﺎزي‬
‫اﻳﻦ ﻗﺎﺑﻠﻴﺖ ﻣﺴﺎﺋﻞ اﻣﻨﻴﺘﻲ را ﻧﻴﺰ ﺑﻪ ﻃﻮر ﻛﺎﻣﻞ در ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ﻓﻮق ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل اﺑﺘﺪا ﻳﻚ ﻓﺮم ﺑﺮاي اﻧﺘﺨﺎب ﻓﺎﻳﻠﻲ ﻛﻪ ﻗﺮار اﺳﺖ آﭘﻠﻮد ﺷﻮد اﻳﺠﺎد‬
‫ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ اﻳﻦ ﻓﺮم ﺣﺘﻤﺎ ﺑﺎﻳﺪ ﺑﺎ ﻣﺘﺪ ‪ post‬ارﺳﺎل ﺷﻮد و ﺧﺎﺻﻴﺖ ‪ enctype‬آن ﻫﻢ ﺑﺎﻳﺪ روي‬
‫‪ multipart/form‐data‬ﺗﻨﻈﻴﻢ ﺷﺪه ﺑﺎﺷﺪ ‪ .‬اﺑﺘﺪا ﻳﻚ ورودي ﺑﺮاي اﻧﺘﺨﺎب ﻓﺎﻳﻞ در ﻓﺮم ﻗﺮار ﻣﻲ دﻫﻴﻢ و‬
‫ﻳﻚ دﻛﻤﻪ ﺑﺮاي ارﺳﺎل ﻫﻢ ﻗﺮار ي دﻫﻴﻢ و ‪ action‬ﻓﺮم را ﻫﻢ روي ﻓﺎﻳﻞ ‪ uploader.php‬ﻣﻲ ﮔﺬارﻳﻢ ‪ .‬در‬
‫ﻓﺎﻳﻞ ‪ uploader.php‬اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ ﻓﺎﻳﻠﻲ از ﻓﺮم ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل‬
‫ﻧﺸﺪه ﺑﺎﺷﺪ دوﺑﺎره ‪ url‬ﻣﺮورﮔﺮ را ﺑﻪ ﺻﻔﺤﻪ ﻓﺮم ﺑﺮ ﻣﻴﮕﺮداﻧﻴﻢ وﻟﻲ اﮔﺮ اﻃﻼﻋﺎت ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ دوﺑﺎره‬
‫ﺑﺎ ﻣﺘﻐﻴﻴﺮ ﺳﺮاﺳﺮي ‪ $_FILES‬ﺑﺮرﺳﻲ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ‪ error‬وﺟﻮد دارد ﻳﺎ ﺧﻴﺮ اﮔﺮ ‪ error‬وﺟﻮد ﻧﺪاﺷﺘﻪ‬
‫ﺑﺎﺷﺪ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ move_uploaded_file‬ﻛﻪ دو ورودي ﻣﻲ ﮔﻴﺮد ﻛﻪ ﭘﺎراﻣﺘﺮ اول ﻣﺴﻴﺮ ﻓﺎﻳﻞ ﻣﻮﻗﺖ‬
‫آﭘﻠﻮد ﺷﺪه اﺳﺖ و ﭘﺎراﻣﺘﺮ دوم ﻣﺴﻴﺮي اﺳﺖ ﻛﻪ ﻓﺎﻳﻞ ﺑﺎﻳﺪ آﭘﻠﻮد ﺷﻮد ‪.‬‬

‫ﻣﻘﺪار ﻓﺎﻳﻞ ‪ formupload.html ‬را در ﺗﺼﻮﻳﺮ ﻓﻮق ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪59 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﻘﺪار ﻓﺎﻳﻞ ‪ uploader.php‬را در ﺗﺼﻮﻳﺮ ﻓﻮق ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ‪.‬‬

‫ﻣﻘﺪاري آراﻳﻪ ﻓﻮق ﺳﺮاﺳﺮي ‪ $_FILES‬را در ﺟﺪول زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ‪.‬‬

‫ﻋﻨﺎﺻﺮ آراﻳﻪ ﻓﻮق ﺳﺮاﺳﺮي ‪  $_FILES‬‬

‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﻋﻨﺼﺮ‬

‫ﻧﺎم ﻓﺎﻳﻞ آﭘﻠﻮد ﺷﺪه‬ ‫]’‪  $_FILES[‘userfile’][‘name‬‬

‫ﻧﻮع ﻓﺎﻳﻞ ارﺳﺎل ﺷﺪه ﺑﻪ ﻃﻮر ﻣﺜﺎل ‪  image/gif‬‬ ‫]’‪  $_FILES[‘userfile’][‘type‬‬

‫اﻧﺪازه ﻓﺎﻳﻞ آﭘﻠﻮد ﺷﺪه‬ ‫]’‪$_FILES[‘userfile’][‘size‬‬

‫ﻧﺎم ﻓﺎﻳﻞ ﻣﻮﻗﺖ داراي ﻓﺎﻳﻞ آﭘﻠﻮد ﺷﺪه‬ ‫]’‪$_FILES[‘userfile’][‘tmp_name‬‬

‫ﻛﺪ ﺧﻄﺎ اﻳﺠﺎد ﺷﺪه ﻫﻨﮕﺎم آﭘﻠﻮد ﻓﺎﻳﻞ‬ ‫]’‪$_FILES[‘userfile’][‘error‬‬

‫‪ ‬‬
‫‪60 | P a g e  ‬‬
‫‪ ‬‬
‫ارﺳﺎل ‪ email‬ﺑﺎ ‪  PHP‬‬

‫ﺑﺮاي ارﺳﺎل ﭘﻴﺎم ﻫﺎي ﻣﺘﻨﻲ ﺳﺎده از دﺳﺘﻮر )(‪ mail‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬اﻳﻦ دﺳﺘﻮر ﺑﺮاي ارﺳﺎل اﻳﻤﻴﻞ ﺑﻪ‬
‫ﺳﻴﺴﺘﻢ ﭘﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜﻲ ﻣﺤﻠﻲ ﻣﺘﻜﻲ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬در ﺗﺼﻮﻳﺮ ﻓﻮق ﻧﺤﻮه اﺳﺘﻔﺎده از اﻳﻦ ﺗﺎﺑﻊ آﻣﺪه اﺳﺖ ‪.‬‬

‫ﻫﺮ ﻳﻚ از ورودي ﻫﺎي اﻳﻦ ﺗﺎﺑﻊ در ﺟﺪول زﻳﺮ آﻣﺪه اﺳﺖ ‪.‬‬

‫ﭘﺎراﻣﺘﺮ ﻫﺎي ﺗﺎﺑﻊ ‪  mail‬‬

‫ﺗﻮﺿﻴﺤﺎت‬ ‫ﭘﺎراﻣﺘﺮ‬
‫آدرس ﻣﻘﺼﺪ ‪ .‬اﮔﺮ ﭘﻴﺎﻣﻲ را ﺑﺨﻮاﻫﻴﺪ ﺑﻪ ﭼﻨﺪ ﻧﻔﺮ‬
‫ارﺳﺎل ﻛﻨﻴﺪ ﺑﺎﻳﺪ آدرس ﻫﺎ را ﺑﺎ ﻛﺎراﻛﺘﺮ )‪ ( , ‬از ﻫﻢ‬ ‫‪  $to‬‬
‫ﺟﺪا ﻛﻨﻴﺪ ‪ ‬‬
‫ﻣﻮﺿﻮع ﭘﻴﺎم‬ ‫‪$subject‬‬
‫ﺑﺪﻧﻪ ﻳﺎ ﺧﻮد ﭘﻴﺎم‬ ‫‪$message‬‬
‫اﻳﻦ رﺷﺘﻪ ﺑﻪ اﻧﺘﻬﺎي ﻫﺪر ﭘﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜﻲ اﻓﺰوده‬
‫ﻣﻲ ﺷﻮد ‪ .‬ﺧﻄﻮط ﺟﺪاﮔﺎﻧﻪ در اﻳﻦ رﺷﺘﻪ را ﻣﻲ ﺗﻮان‬ ‫‪$mailheader‬‬
‫ﺑﺎ ‪ \r\n‬اﻳﺠﺎد ﻛﺮد ‪.‬‬
‫در ﺻﻮرﺗﻲ ﻛﻪ اﻳﻤﻴﻞ ﺑﻪ درﺳﺘﻲ ﺑﻪ ﺳﻴﺴﺘﻢ ﭘﺴﺖ اﻟﻜﺘﺮوﻧﻴﻜﻲ ﻣﺤﻠﻲ ﺗﺤﻮﻳﻞ ﺷﺪه ﺑﺎﺷﺪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار‬
‫‪ true‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ وﻟﻲ اﻳﻦ ﻣﺴﺌﻠﻪ ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ ﻧﻤﻲ ﺑﺎﺷﺪ ﻛﻪ اﻳﻤﻴﻞ ﺑﻪ ﻣﻘﺼﺪ ﻧﻬﺎﻳﻲ ﺗﺤﻮﻳﻞ داده ﺷﺪه‬
‫ﺑﺎﺷﺪ ‪.‬‬

‫‪ ‬‬
‫‪61 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ mail‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪62 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﻳﺎزدﻫﻢ‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا‬

‫ﻗﺎﺑﻠﻴﺖ ﺷﺊ ﮔﺮاﻳﻲ در ‪ PHP‬ﻧﺴﺨﻪ ‪ 3‬ﺑﻪ ﺑﻌﺪ اﻳﺠﺎد ﺷﺪه اﺳﺖ ‪ .‬روش ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻛﻪ در ﺟﻠﺴﺎت ﻗﺒﻞ‬
‫ﻣﺸﺎﻫﺪه ﻛﺮدﻳﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ روﻳﻪ اﻳﻲ ﻧﺎم دارد ‪ .‬در اﻳﻦ ﻣﺪل ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻛﺎرﺑﺮدي از‬
‫ﻳﻜﺴﺮي ﺗﻮاﺑﻊ ﻳﺎ روﻳﻪ ﻫﺎ ﺗﺸﻜﻴﻞ ﻣﻲ ﺷﻮد و در ﺣﻴﻦ اﺟﺮاي ﺑﺮﻧﺎﻣﻪ ﺗﻮاﺑﻊ ﻣﻮرد ﻧﻈﺮ ﺑﺎ داده ﻫﺎي ﻻزم‬
‫ﻓﺮاﺧﻮاﻧﻲ و اﺟﺮا ﻣﻲ ﮔﺮدﻧﺪ ‪ .‬در اﻳﻦ ﺟﻠﺴﻪ ﻣﻲ ﺧﻮاﻫﻴﻢ ﺗﺎ ﻣﺘﺪ ﻣﺘﻔﺎوﺗﻲ در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﻪ ﻧﺎم ﺑﺮﻧﺎﻣﻪ‬
‫ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا را ﻣﻌﺮﻓﻲ ﻛﻨﻴﻢ ‪.‬‬

‫در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا ﺑﺎ ﻛﻤﻚ اﺷﻴﺎء ﻣﻲ ﺗﻮاﻧﻴﻢ اﺷﻴﺎء ﻣﻮﺟﻮد در دﻧﻴﺎي واﻗﻌﻲ ﻫﻤﺎﻧﻨﺪ ﭼﻴﺰ ﻫﺎي ﻣﺨﺘﻠﻒ ‪,‬‬
‫ﻓﺮآﻳﻨﺪ ﻫﺎ و اﻳﺪه ﻫﺎ را ﻣﺪل ﺳﺎزي ﻛﻨﻴﻢ ‪ .‬در اﻳﻦ ﻣﺪل ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺑﺮﻧﺎﻣﻪ از ﻳﻜﺴﺮي ﺷﺊ ﺗﺸﻜﻴﻞ ﻣﻲ‬
‫ﺷﻮﻧﺪ ﻛﻪ ﻫﺮ ﻛﺪام در ﺣﻘﻴﻘﺖ ﻧﻘﺶ ﻳﻜﻲ از اﺷﻴﺎء ﻣﻮﺟﻮد در دﻧﻴﺎي واﻗﻌﻲ را ﺑﺎزي ﻣﻲ ﻛﻨﺪ ﻫﻤﭽﻨﻴﻦ ﻫﺮ ﺷﺊ‬
‫ﻋﻤﻠﻴﺎت ﺧﺎﺻﻲ را اﻧﺠﺎم ﻣﻲ دﻫﺪ و ﺳﺮوﻳﺲ ﻫﺎي ﺧﺎﺻﻲ را ﺑﻪ ﺳﺎﻳﺮ اﺷﻴﺎء ﻣﻲ ﺗﻮاﻧﺪ اراﺋﻪ دﻫﺪ وﻟﻲ ﺑﻪ ﻃﻮر‬
‫ﻛﻠﻲ ﺟﺰوﺋﻴﺎت ﻧﺤﻮه اﻧﺠﺎم ﻋﻤﻠﻴﺎت داﺧﻞ ﻫﺮ ﺷﺊ ﺑﺮاي اﺷﻴﺎء دﻳﮕﺮ ﭘﻨﻬﺎن ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫)‪ Oop (object oriented programming‬ﺑﺮاي ﺳﺎدﮔﻲ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن ﺑﻪ وﺟﻮد آﻣﺪه اﺳﺖ ﺑﺎ اﺳﺘﻔﺎده از‬
‫‪ oop‬ﺷﻤﺎ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻣﺴﺎﺋﻞ ﺑﺰرگ را ﺗﺒﺪﻳﻞ ﺑﻪ ﭼﻨﺪ ﻣﺴﺌﻠﻪ ﻛﻮﭼﻚ ﻧﻤﺎﻳﻴﺪ ﻛﻪ ﻧﺴﺒﺖ ﺑﻪ ﻣﺴﺌﻠﻪ اﺻﻠﻲ راﺣﺖ‬
‫ﺗﺮ ﺣﻞ ﻣﻲ ﺷﻮﻧﺪ ‪.‬‬

‫اﻫﺪاف اﺻﻠﻲ ‪ oop‬را ﻣﻲ ﺗﻮان ﺑﻪ ﻃﻮر ﺧﻼﺻﻪ ﭼﻨﻴﻦ ﺑﺮ ﺷﻤﺮد ‪:‬‬

‫ﻗﺎﺑﻠﻴﺖ اﺳﺘﻔﺎده ﻣﺠﺪد ‪ :‬ﻳﻚ ﺷﺊ ﻣﻮﺟﻮدﻳﺘﻲ اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﺪ ﺧﺼﻮﺻﻴﺎت و رﻓﺘﺎر ﻫﺎ را در ﺑﺮ‬ ‫‪‬‬
‫داﺷﺘﻪ و ﻳﺎ ﺑﺎ اﺷﻴﺎء دﻳﮕﺮ ﻣﺮﺗﺒﻂ ﺑﺎﺷﺪ ‪ .‬ﻳﻚ ﺷﺊ اﻏﻠﺐ ﺑﺮاي رﻓﻊ ﻣﺠﻤﻮﻋﻪ ﻣﺸﺨﺼﻲ از ﻣﺸﻜﻼت ﺗﻮﻟﻴﺪ ﻣﻲ‬
‫ﺷﻮد ﻫﺮﮔﺎه در ﺳﺎﻳﺮ ﭘﺮوژه ﻫﺎ ﻧﻴﺎز ﺑﻪ رﻓﻊ ﻣﺸﻜﻼت ﻣﺸﺎﺑﻬﻲ ﺑﺎﺷﺪ ﻣﻲ ﺗﻮان از ﻫﻤﺎن ﺷﺊ در آن ﭘﺮوژه‬
‫اﺳﺘﻔﺎده ﻛﺮد ‪  .‬‬
‫اﺻﻼح ﻣﺠﺪد ‪ :‬اﮔﺮ ﻧﻴﺎز ﺑﻪ اﺻﻼح ﭘﺮوژه ﻫﺎي ﺧﻮد داﺷﺘﻪ ﺑﺎﺷﻴﺪ ‪ oop ,‬ﺑﻪ ﺷﻤﺎ ﺣﺪاﻛﺜﺮ ﺳﻮد را ﻣﻲ‬ ‫‪‬‬
‫رﺳﺎﻧﺪ زﻳﺮا ﺗﻤﺎﻣﻲ اﺷﻴﺎء ﻣﻮﺟﻮد در ﺑﺮﻧﺎﻣﻪ ‪ ,‬ﻣﻮﺟﻮدﻳﺖ ﻫﺎي ﻛﻮﭼﻜﻲ ﻫﺴﺘﻨﺪ ﻛﻪ ﺷﺎﻣﻞ ﺧﺼﻮﺻﻴﺎت و رﻓﺘﺎر‬
‫ﻫﺎي ﺧﺎص ﺧﻮد ﻣﻲ ﺑﺎﺷﻨﺪ ‪ .‬ﺑﻨﺎﺑﺮ اﻳﻦ ﺗﻐﻴﻴﺮ و اﺻﻼح آن ﻫﺎ ﺑﻪ ﻣﺮاﺗﺐ ﺳﺎده ﺗﺮ اﺳﺖ ‪  .‬‬
‫ﻗﺎﺑﻠﻴﺖ ﮔﺴﺘﺮش ‪ :‬ﺑﺎ اﺳﺘﻔﺎده از ‪ oop‬ﻣﻴﺘﻮاﻧﻴﺪ اﺷﻴﺎء ﺧﻮد را ﺑﺎزﻧﻮﻳﺴﻲ ﻛﺮده و وﻳﮋﮔﻲ ﻫﺎ ي ﺧﺎﺻﻲ‬ ‫‪‬‬
‫را ﺑﻪ آن ﻫﺎ اﺿﺎﻓﻪ ﻛﻨﻴﺪ ﻫﻤﺰﻣﺎن ﺑﺎ اﻳﻦ ﻛﺎر ﻣﻲ ﺗﻮاﻧﻴﺪ ﺳﺎزﮔﺎري ﺑﺎ ﻧﺴﺨﻪ ﻫﺎي ﻗﺒﻠﻲ را ﻧﻴﺰ ﺣﻔﻆ ﻧﻤﺎﻳﻴﺪ ‪ .‬ﺑﺮاي‬
‫‪ ‬‬
‫‪63 | P a g e  ‬‬
‫‪ ‬‬
‫اﻳﻦ ﻛﺎر ﻛﺪ ﻗﺒﻠﻲ ﺷﻤﺎ ﺑﻪ ﺻﻮرت ﭘﺎﻳﻪ ﺗﻌﺮﻳﻒ و اﻣﻜﺎﻧﺎت ﺟﺪﻳﺪ ﺑﻪ آن اﺿﺎﻓﻪ ﺷﺪه و آن‪ ‬را ﮔﺴﺘﺮش ﻣﻲ دﻫﺪ‪.‬‬
‫ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ اﺷﻴﺎء ﺟﺪﻳﺪ ﺗﻤﺎﻣﻲ ﺧﺼﻮﺻﻴﺎت و ﺷﺊ واﻟﺪ را از آن ﺑﻪ ارث ﻣﻲ ﺑﺮﻧﺪ و ﺳﭙﺲ وﻳﮋﮔﻲ ﻫﺎي ﺟﺪﻳﺪ‬
‫را ﺑﻪ آن اﺿﺎﻓﻪ ﻣﻲ ﻧﻤﺎﻳﻨﺪ ‪ .‬اﻳﻦ ﻋﻤﻞ اﺻﻄﻼﺣﺎ وراﺛﺖ ﻧﺎم دارد و ﻳﻜﻲ از وﻳﮋﮔﻲ ﻫﺎي ﺑﺴﻴﺎر ﻣﻬﻢ ‪ oop‬ﺑﻪ‬
‫ﺷﻤﺎر ﻣﻲ رود ‪  .‬‬
‫ﻗﺎﺑﻠﻴﺖ ﻧﮕﻬﺪاري ‪ :‬ﻛﺪ ﺷﺊ ﮔﺮا راﺣﺖ ﺗﺮ ﻧﮕﻬﺪاري ﻣﻲ ﺷﻮد ﺑﺮاي ﻣﺜﺎل وﻗﺘﻲ ﻛﻪ ﻳﻚ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ‬ ‫‪‬‬
‫آﻧﺮا ﺗﻮﺳﻌﻪ ﻣﻲ دﻫﺪ ‪ ,‬ﺑﺎزﻧﻮﻳﺴﻲ و ﻳﺎ اﺷﻜﺎل زداﻳﻲ ﻣﻲ ﻛﻨﺪ ﻣﻲ ﺗﻮان ﺑﻪ راﺣﺘﻲ ﺳﺎﺧﺘﺎر ﻛﺪﻧﻮﻳﺴﻲ داﺧﻠﻲ‬
‫آن را ﻛﺸﻒ ﻛﺮد و ﻛﺪ را ﻫﺮ زﻣﺎن ﺑﻪ روز رﺳﺎﻧﻲ ﻧﻤﻮد ‪  .‬‬
‫ﻛﺎرآﻳﻲ ‪ :‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا در ﺣﻘﻴﻘﺖ ﺑﺮاي ﻛﺎرآﻳﻲ ﺑﻬﺘﺮ و راﺣﺘﻲ ﻓﺮآﻳﻨﺪ ﺗﻮﺳﻌﻪ ﻧﺮم اﻓﺰار ﺑﻪ‬ ‫‪‬‬
‫وﺟﻮد آﻣﺪه اﺳﺖ ‪.‬اﺑﺘﺪا ﻣﺴﺌﻠﻪ ر اﺑﻪ ﻣﺠﻤﻮﻋﻪ اﻳﻲ از ﻣﺴﺎﺋﻞ ﻛﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﻴﺪ و ﺳﭙﺲ راه ﺣﻞ ﻣﺴﺎﺋﻞ‬
‫ﻛﻮﭼﻚ را ﻣﻲ ﻳﺎﺑﺪ و ﻃﺒﻴﻌﺘﺎ ﻣﺴﺌﻠﻪ ﺑﺰرگ و اﺻﻠﻲ ﺑﻄﻮر ﺧﻮدﻛﺎر ﺣﻞ ﺧﻮاﻫﺪ ﺷﺪ ‪  .‬‬

‫ﺗﻌﺎرﻳﻒ ﻣﻬﻢ در ﺷﺊ ﮔﺮاﻳﻲ‬

‫ﻛﻼس‬

‫ﻳﻚ ﻛﻼس اﻟﮕﻮﻳﻲ ﺑﺮاي اﻳﺠﺎد اﺷﻴﺎء اﺳﺖ و ﺳﺎﺧﺘﺎر اﺷﻴﺎء را ﻣﺸﺨﺺ ﻛﺮده و ﻣﺘﺪ ﻫﺎ و ﺧﺎﺻﻴﺖ ﻫﺎي ﻳﻚ ﺷﺊ‬
‫را ﺗﻌﻴﻴﻦ ﻣﻲ ﻧﻤﺎﻳﺪ ‪ .‬ﻛﻼس ﭼﻴﺰي ﺑﻪ ﺟﺰء ﻗﻄﻌﻪ اﻳﻲ از ﻛﺪ ﺑﺎ ﺗﻌﺪادي ﺧﺼﻮﺻﻴﺎت )ﻓﻴﻠﺪ‪ (field-‬و‬

‫رﻓﺘﺎر ﻫﺎ )ﻣﺘﺪ‪ (method-‬ﻧﻴﺴﺖ ‪ .‬ﺧﺼﻮﺻﻴﺎت داده ﻫﺎي اﺷﻴﺎء ﻫﺴﺘﻨﺪ و ﺑﻪ ﺻﻮرت ﻣﺘﻐﻴﻴﺮ ﻫﺎﺋﻲ در داﺧﻞ‬
‫ﻛﻼس ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ‪ .‬ﻳﻚ ﺧﺎﺻﻴﺖ ﻣﻤﻜﻦ اﺳﺖ ﻳﻪ ﻣﻘﺪار ‪ ,‬ﻳﻚ آراﻳﻪ و ﺣﺘﻲ ﻳﻚ ﺷﺊ ﺑﺎﺷﺪ ‪.‬‬

‫ﻣﺘﺪ ﻫﺎ در ﺣﻘﻴﻘﺖ ﺗﻮاﺑﻊ ﻳﺎ ﻋﻤﻠﻴﺎﺗﻲ ﻫﺴﻨﺘﺪ ﻛﻪ در داﺧﻞ ﻛﻼس ﻳﻚ ﺷﺊ ﺗﻌﺮف ﻣﻲ ﮔﺮدد ‪.‬‬

‫اﺷﻴﺎء‬

‫اﻟﮕﻮي ﻳﻚ ﺷﺊ اﺳﺖ ‪ .‬در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ وﻗﺘﻲ ﻛﻼس ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد اﻳﻦ ﻛﻼس ﺑﻪ ﺗﻨﻬﺎﻳﻲ ﻫﻴﭻ ﻗﺎﺑﻠﻴﺖ‬
‫اﺟﺮاﻳﻲ ﻧﺪارد و ﻗﺘﻲ از ﻛﻼس ﺷﺊ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬آن وﻗﺖ ﻣﻲ ﺗﻮان از آن ﺷﺊ در ﺑﺮﻧﺎﻣﻪ اﺳﺘﻔﺎده ﻧﻤﻮد و‬
‫ﺗﻤﺎﻣﻲ وﻳﮋﮔﻲ ﻫﺎﻳﻲ ﻛﻪ در ﻛﻼس ﻣﺮﺑﻮﻃﻪ ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ )اﻋﻢ از ﺧﺼﻮﺻﻴﺎت‪,‬رﻓﺘﺎرﻫﺎ و‪ (...‬ﺑﺮ روي ﺷﺊ‬
‫ﻣﺮﺑﻮﻃﻪ ﻗﺎﺑﻞ دﺳﺘﺮﺳﻲ ﺧﻮاﻫﻨﺪ ﺑﻮد ‪ .‬در ‪ oop‬ﻫﻴﭻ ﺷﺌﻲ ﺑﺪون ﻛﻼس وﺟﻮد ﻧﺪارد و ﺑﻪ ﻋﺒﺎرت دﻳﮕﺮ اﺷﻴﺎء‬
‫از روي ﻛﻼس ﻫﺎ ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮﻧﺪ و ﺗﺎ زﻣﺎﻧﻲ ﻛﻪ ﻛﻼس ﻧﺒﺎﺷﺪ ﺷﺊ ﻧﻴﺰ وﺟﻮد ﻧﺨﻮاﻫﺪ داﺷﺖ ‪.‬‬

‫‪ ‬‬
‫‪64 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺎﺻﻴﺖ‬

‫ﻳﻚ ﺧﺎﺻﻴﺖ ﻳﺎ ﻓﻴﻠﺪ در ﺣﻘﻴﻘﺖ ﻣﺘﻐﻴﻴﺮي از ﻛﻼس اﺳﺖ ﻛﻪ ﻣﺴﺘﻘﻴﻤﺎ درون ﺧﻮد ﻛﻼس )و ﻧﻪ درون ﻣﺘﺪ ﻫﺎي‬
‫داﺧﻞ ﻛﻼس( ﺗﻌﺮﻳﻒ ﻣﻴﺸﻮد ‪ .‬اﻳﻦ ﻋﻨﺎﺻﺮ ﺗﻮﺳﻂ ﺗﻤﺎﻣﻲ ﺗﻮاﺑﻊ )ﻣﺘﺪ ﻫﺎ( در ﺗﻤﺎﻣﻲ ﺑﺨﺶ ﻫﺎي ﻛﻼس ﻗﺎﺑﻞ‬
‫دﺳﺘﺮﺳﻲ ﻫﺴﺘﻨﺪ ‪.‬‬

‫ﻣﺘﺪ‬

‫ﻣﺘﺪ ﻫﺎ ﺗﻮاﺑﻌﻲ ﻫﺴﺘﻨﺪ ﻛﻪ درون ﻳﻚ ﻛﻼس ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ و رﻓﺘﺎر ﻫﺎي اﺷﻴﺎء اﻳﺠﺎد ﺷﺪه از ﻛﻼس را‬
‫ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻛﭙﺴﻮﻟﻪ ﺳﺎزي‬

‫اﻳﻦ اﺻﻄﻼح ﺑﻪ ﻣﻌﻨﻲ ﻣﻜﺎﻧﻴﺰﻣﻲ اﺳﺖ ﻛﻪ ﺗﻮﺳﻂ آن ﻛﺪ درون ﻛﻼس )ﻣﺘﺪﻫﺎ( و داده ﻫﺎي ﻣﻮﺟﻮد در آن‬
‫)ﻓﻴﻠﺪﻫﺎ( ﺑﻪ ﻫﻢ ﻣﺘﺼﻞ ﻣﻲ ﺷﻮﻧﺪ و ﻫﺮ دو ﻣﻮرد )ﻓﻴﻠﺪ و ﻣﺘﺪ( از ﺗﺪاﺧﻞ ﺧﺎرﺟﻲ و اﺳﺘﻔﺎده ﻧﺎﻣﻨﺎﺳﺐ ﻣﺼﻮن‬
‫ﻣﻲ ﻣﺎﻧﻨﺪ ‪ .‬در ﺣﻘﻴﻘﺖ ﺑﻪ ﻋﻤﻞ ﻣﺤﺎﻓﻈﺖ از داده ﻫﺎ و ﻣﺘﺪ ﻫﺎ از ﻃﺮﻳﻖ ﻳﻚ ﺳﻴﺴﺘﻢ واﺣﺪ )ﻛﻼس( ﻛﭙﺴﻮﻟﻪ‬
‫ﺳﺎزي ﻣﻲ ﮔﻮﻧﺪ ‪ .‬ﻣﺰﻳﺖ اﺻﻠﻲ ﻛﭙﺴﻮﻟﻪ ﺳﺎزي ﺗﻀﻤﻴﻦ ﺻﺤﺖ اﻃﻼﻋﺎت و اﻧﺠﺎم ﻋﻤﻠﻴﺎت اﺳﺖ ‪.‬‬

‫وراﺛﺖ‬

‫ﻓﺮآﻳﻨﺪ ﻣﺸﺘﻖ ﺷﺪن ﻳﻚ ﻛﻼس از ﻛﻼس دﻳﮕﺮ و ﮔﺴﺘﺮش اﻣﻜﺎﻧﺎت ﺗﻌﺮﻳﻒ ﺷﺪه آن ‪ ,‬وراﺛﺖ ﻧﺎم دارد‪ .‬وﻗﺘﻲ‬
‫ﻳﻚ ﻛﻼس را از ﻛﻼس دﻳﮕﺮي ﻣﺸﺘﻖ ﻣﻲ ﺷﻮد ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه )ﻓﺮﻋﻲ( ﺗﻤﺎﻣﻲ رﻓﺘﺎر ﻫﺎ و ﺧﺼﻮﺻﻴﺎت‬
‫ﻛﻼس واﻟﺪ )اﺻﻠﻲ( را ﺑﻪ ارث ﻣﻲ ﺑﺮد ‪ .‬ﺳﭙﺲ ﻛﻼس ﻓﺮﻋﻲ ﻣﻲ ﺗﻮاﻧﺪ ﻣﺘﺪ ﻫﺎ و ﻓﻴﻠﺪ ﻫﺎي دﻟﺨﻮاه ﺧﻮد را‬
‫اﺿﺎﻓﻪ ﻛﺮده ﻳﺎ ﺗﻐﻴﻴﺮ دﻫﺪ ‪.‬‬

‫ﭼﻨﺪ رﻳﺨﺘﻲ‬

‫اﮔﺮ ﻳﻚ ﻛﻼس از ﻛﻼس دﻳﮕﻴﺮي ﻣﺸﺘﻖ ﺷﺪه ﺑﺎﺷﺪ ﻣﻲ ﺗﻮاﻧﺪ ﻣﺘﺪ ﻫﺎي آن را ﺑﺎزﻧﻮﻳﺴﻲ ﻛﻨﺪ ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ‬
‫اﮔﺮ ﻳﻚ ﺷﺊ از اﻳﻦ ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه اﻳﺠﺎد ﺷﻮد ‪ ,‬اﻳﻦ اﻣﻜﺎن وﺟﻮد دارد ﻛﻪ ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﻳﻚ ﻣﺘﺪ ﺧﺎص‬
‫رﻓﺘﺎري ﻣﺘﻔﺎوت ﺑﺎ زﻣﺎﻧﻲ ﻛﻪ ﻫﻤﺎن ﻣﺘﺪ را از ﺷﺊ واﻟﺪ اﻳﺠﺎد ﺷﺪه اﺳﺖ ﺻﺪا ﻣﻲ زﻧﻴﻢ ‪ ,‬اﺟﺮا ﮔﺮدد ﺑﻪ اﻳﻦ‬

‫‪ ‬‬
‫‪65 | P a g e  ‬‬
‫‪ ‬‬
‫ﻋﻤﻞ ‪ ,‬ﭼﻨﺪ رﻳﺨﺘﻲ ﻣﻲ ﮔﻮﻳﻴﻢ ﻛﻪ در آن ﻳﻚ ﺷﺊ ﺑﺴﺘﻪ ﺑﻪ آن ﻛﻪ از ﻛﻼس واﻟﺪ ﻳﺎ ﻣﺸﺘﻖ ﺷﺪه اﻳﺠﺎد ﺷﻮد ‪,‬‬
‫ﺑﺎ ﻓﺮاﺧﻮاﻧﻲ ﻳﻚ ﻣﺘﺪ ﺧﺎص ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ اﺷﻜﺎل ﻣﺨﺘﻠﻔﻲ رﻓﺘﺎر ﻛﻨﺪ ‪.‬‬

‫اﻣﺘﺰاج‬

‫اﻳﻦ اﺻﻄﻼح ﺑﻴﺎﻧﮕﺮ واﺑﺴﺘﮕﻲ ﻛﻼس ﻫﺎ ﺑﻪ ﻳﻜﺪﻳﮕﺮ اﺳﺖ ‪ .‬ﺑﺮاي ﻣﺜﺎل ﻣﻤﻜﻦ اﺳﺖ ﻳﻚ ﻛﻼس ﺣﺎوي ﻳﻚ ﻳﺎ‬
‫ﭼﻨﺪ ﻓﻴﻠﺪ ﺑﺎﺷﺪ ﻛﻪ اﻳﻦ ﻓﻴﻠﺪ ﻫﺎ در ﺣﻘﻴﻘﺖ اﺷﻴﺎﺋﻲ از ﻛﻼس ﻫﺎي دﻳﮕﺮ ﺑﺎﺷﻨﺪ ‪ .‬ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ‪ ,‬اﺷﻴﺎء ﻳﻚ‬
‫ﻛﻼس ﺑﺪون وﺟﻮد ﻛﻼس دﻳﮕﺮ ﻗﺎدر ﺑﻪ ﻛﺎر ﻛﺮدن ﻧﻴﺴﺘﻨﺪ ‪ .‬ﻫﺮ ﭼﻘﺪر اﻣﺘﺰاج ﻳﻚ ﻛﻼس ﻛﻤﺘﺮ ﺑﺎﺷﺪ ﻗﺎﺑﻠﻴﺖ‬
‫اﺳﺘﻔﺎده ﻣﺠﺪد ﻛﻼس ﻣﺠﺒﻮر در ﺳﺎﻳﺮ ﭘﺮوژه ﻫﺎ اﻓﺰاﻳﺶ ﺧﻮاﻫﺪ ﻳﺎﻓﺖ و ﺑﺮﻋﻜﺲ ‪.‬‬

‫ﻛﻼس ﺑﺮﺗﺮ )واﻟﺪ(‬

‫در ﻣﻔﺎﻫﻴﻢ وراﺛﺖ ‪ ,‬ﻛﻼﺳﻲ ﻛﻪ ﺳﺎﻳﺮ ﻛﻼس ﻫﺎ از آن ﻣﺸﺘﻖ ﻣﻲ ﺷﻮﻧﺪ و اﻣﻜﺎﻧﺎت ان را ﺗﻮﺳﻌﻪ ﻣﻲ دﻫﻨﺪ ‪,‬‬
‫ﻛﻼس ﺑﺮﺗﺮ ﻳﺎ واﻟﺪ )‪ (parent‬ﻧﺎم دارد ‪.‬‬

‫ﻛﻼس ﻓﺮﻋﻲ )ﻓﺮزﻧﺪ(‬

‫ﺑﻪ ﻛﻼﺳﻲ ﻛﻪ از ﻳﻚ ﻛﻼس دﻳﮕﺮ ﻣﺸﺘﻖ ﺷﺪه ﺑﺎﺷﺪ و ﺧﺼﻮﺻﻴﺎت و رﻓﺘﺎر ﻫﺎي آن را ﺑﻪ ارث ﻣﻲ ﺑﺮد ‪ ,‬ﻛﻼس‬
‫ﻓﺮﻋﻲ ﻳﺎ ﻓﺮزﻧﺪ )‪ (child‬ﻣﻲ ﮔﻮﻳﻨﺪ ‪.‬‬

‫اﻳﺠﺎد ﻛﻼس‬

‫ﺑﺮاي اﻳﺠﺎد ﻛﻼس ﺑﺎﻳﺪ اﺑﺘﺪا ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ class‬و ﺳﭙﺲ ﻧﺎم آن ﻛﻼس را ﺑﻨﻮﻳﺴﻴﺪ و ﺳﭙﺲ ﺑﻼك ﺑﺎز ﻛﺮده‬
‫و ﺧﺎﺻﻴﺖ ﻫﺎ و ﻣﺘﺪ ﻫﺎي آن ﻛﻼس را ﻧﻮﺷﺘﻪ و ﺑﻼك را ﻣﻲ ﺑﻨﺪﻳﻢ ‪.‬‬

‫ﻓﻴﻠﺪ ﻫﺎ درون ﻛﻼس ﺑﺎ ﻛﺎﻣﻪ ‪ $this‬ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ‪.‬‬

‫‪ ‬‬
‫‪66 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ class‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﻓﻮق ﻛﻼﺳﻲ ﺑﻪ اﺳﻢ ‪ human‬ﺳﺎﺧﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ درون آن ﺳﻪ ﻓﻴﻠﺪ ﺧﺼﻮﺻﻲ ﺗﻌﺮﻳﻒ ﺷﺪه‬
‫و ﻋﻼﻣﺖ >‐‬ ‫اﺳﺖ ‪ .‬اﺑﺘﺪا ﻳﻚ ﻣﺘﺪ ﺑﺮاي درﻳﺎﻓﺖ ورودي از ﻛﺎرﺑﺮ اﻳﺠﺎد ﺷﺪه اﺳﺖ ﺑﺎ اﺳﺘﻔﺎده از ‪$this‬‬
‫)ﻛﺎراﻛﺘﺮ – ﻳﺎ ﺗﻔﺮﻳﻖ و ﺳﭙﺲ ﻋﻼﻣﺖ ﺑﺰرﮔﺘﺮ >( ﺑﻪ ﻓﻴﻠﺪ ﻫﺎ و ﻣﺘﺪ ﻫﺎي ﻣﻮﺟﻮد در ﻛﻼس ﻣﻲ ﺗﻮان دﺳﺘﺮﺳﻲ‬
‫ﭘﻴﺪا ﻛﺮد و ﺑﺎ اﺳﺘﻔﺎده از ‪ $this‬ﻓﻴﻠﺪ ﻫﺎي داﺧﻞ ﻛﻼس را ﭘﺮ ﻛﺮده اﺳﺖ و ﻣﺘﺪ ﺑﻌﺪي ﺑﺮاي ﭼﺎپ ﺧﺮوﺟﻲ‬
‫اﺳﺖ و ﺧﺮوﺟﻲ را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬در آﺧﺮ ﻛﻪ ﻧﻮﺷﺘﻦ ﻛﻼس ﺗﻤﺎم ﻣﻲ ﺷﻮد ﺑﺎ اﺳﺘﻔﺎده از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ new‬ﻣﻲ‬

‫‪ ‬‬
‫‪67 | P a g e  ‬‬
‫‪ ‬‬
‫ﺗﻮان از ﻛﻼس ﻣﻮﺟﻮد ﺷﺊ ﺳﺎﺧﺖ دو ﺷﺊ از ﻛﻼس ﺳﺎﺧﺘﻪ ﻣﻲ ﺷﻮد و ﻣﻘﺎدﻳﺮ ﻻزم ﺑﺮاي ﻣﺘﺪ اوﻟﻲ ﺑﻪ ﺷﺊ‬
‫داده ﻣﻲ ﺷﻮد ﺳﭙﺲ ﻣﺘﺪ دوﻣﻲ ﻛﻼس ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ‪.‬‬

‫ﻣﺘﺪ ﺳﺎزﻧﺪه‬

‫در ‪ PHP‬ﻣﺘﺪ ﺳﺎزﻧﺪه ﻳﻚ ﻛﻼس ﺑﺎ ﻧﺎم ‪ __construct‬ﻣﺸﺨﺺ ﻣﻲ ﺷﻮد اﻳﻦ ﻣﺘﺪ ﻳﻚ اﺳﺘﺜﻨﺎ اﺳﺖ ﻛﻪ در‬
‫ﻫﻤﻪ ﻛﻼس ﻫﺎ وﺟﻮد دارد‪ .‬اﻏﻠﺐ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن از اﻳﻦ ﻣﺘﺪ ﺑﺮاي ﻋﻤﻠﻴﺎﺗﻲ ﻫﻤﺎﻧﻨﺪ ﻣﻘﺪار دﻫﻲ اوﻟﻴﻪ ﺧﺎﺻﻴﺖ‬
‫ﻫﺎي ﺷﺊ اﺳﺘﻔﺎده ﻛﻨﻨﺪ ‪ .‬ﻫﺮ ﮔﺎه ﺑﺨﻮاﻫﻴﻢ ﻳﻚ ﺷﺊ ﺟﺪﻳﺪ از ﻛﻼس اﻳﺠﺎد ﻛﻨﻴﻢ ‪ ,‬اﻳﻦ ﻣﺘﺪ ﺑﻄﻮر ﺧﻮدﻛﺎر‬
‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ‪ .‬ﺑﻨﺎ ﺑﺮ اﻳﻦ اﮔﺮ ﻣﻲ ﺧﻮاﻫﻴﻢ ﻛﺎر ﻫﺎﻳﻲ را در زﻣﺎن آﻣﺎده ﺳﺎزي و اﻳﺠﺎد ﺷﺊ اﻧﺠﺎم دﻫﻴﻢ‬
‫‪ ,‬دﺳﺘﻮرات ﻣﺮﺑﻮﻃﻪ را در اﻳﻦ ﻣﺘﺪ ﻗﺮار ﻣﻲ دﻫﻴﻢ ﻛﻪ ﺑﻪ آن ﺳﺎزﻧﺪه )‪ (constructor‬ﻣﻲ ﮔﻮﻳﻴﻢ ‪ .‬ﻳﻚ ﻣﺘﺪ‬
‫ﺳﺎزﻧﺪه ﻣﻲ ﺗﻮاﻧﺪ آرﮔﻮﻣﻨﺖ ﻫﺎﺋﻲ را ﻧﻴﺰ درﻳﺎﻓﺖ ﻛﺮده و ﺑﺮ اﺳﺎس آن ﻋﻤﻠﻴﺎت ﻣﻘﺪار دﻫﻲ اوﻟﻴﻪ را اﻧﺠﺎم‬
‫دﻫﺪ ‪ .‬ﺑﺮاي ارﺳﺎل آرﮔﻮﻣﻨﺖ ﺑﻪ ﻣﺘﺪ ﺳﺎزﻧﺪه ﺑﺎﻳﺪ روش زﻳﺮ را ﺑﻪ ﻛﺎر ﺑﺮد ‪:‬‬

‫در ﺗﺼﻮﻳﺮ ﻓﻮق ﻳﻚ ﺷﺊ از ﻛﻼس ‪ adder‬ﻣﻲ ﺳﺎزد ﻛﻪ درون ﻛﻼس ﻣﺘﺪ ﺳﺎزﻧﺪه اﻳﻲ ﺑﺎ دو ورودي وﺟﻮد‬
‫دارد ﻛﻪ ورودي ﻫﺎي آن ﺑﻪ اﻳﻦ ﮔﻮﻧﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ‪.‬‬

‫ﻧﻜﺘﻪ ‪ :‬ﻣﺘﺪ ﺳﺎزﻧﺪه ﻳﻚ ﺷﺊ ﻧﻤﻲ ﺗﻮاﻧﺪ ﻣﻘﺪاري را ﺑﺮ ﮔﺮداﻧﺪ ‪.‬‬

‫ﻣﺘﺪ ﺗﺨﺮﻳﺐ ﻛﻨﻨﺪه‬

‫ﻋﻤﻠﮕﺮد ﺗﻮاﺑﻊ ﺗﺨﺮﻳﺐ ﻛﻨﻨﺪه ﺑﺮ ﻋﻜﺲ ﺗﻮاﺑﻊ ﺳﺎزﻧﺪه اﺳﺖ و ﺑﻪ ﻫﻨﮕﺎم از ﺑﻴﻦ رﻓﺘﻦ اﺷﻴﺎء ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ‬
‫ﺷﻮﻧﺪ ‪ .‬اﻟﺒﺘﻪ ﺑﻪ دﻟﻴﻞ اﻳﻨﻜﻪ ‪ PHP‬ﺧﻮدش ﺗﻤﺎﻣﻲ ﻣﻨﺎﺑﻊ را ﺑﻌﺪ از اﺳﺘﻔﺎده رﻫﺎ ﻣﻲ ﻧﻤﺎﻳﺪ ‪ ,‬ﺗﻮاﺑﻊ ﺗﺨﺮﻳﺐ‬
‫ﻛﻨﻨﺪه از اﻫﻤﻴﺖ ﻛﻤﺘﺮي ﻧﺴﺒﺖ ﺑﻪ ﺗﻮاﺑﻊ ﺳﺎزﻧﺪه ﺑﺮ ﺧﻮردار اﺳﺖ ‪ .‬ﺗﻮاﺑﻊ ﺗﺨﺮﻳﺐ ﻛﻨﻨﺪه در ﺷﺮاﻳﻂ زﻳﺮ‬
‫ﻓﺮاﺧﻮاﻧﻲ ﻣﻲ ﺷﻮد ‪:‬‬

‫‪ ‬‬ ‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ ﺗﻤﺎﻣﻲ رﺟﻮع ﻫﺎ ﺑﻪ ﻳﻚ ﺷﺊ ﺑﻪ اﺗﻤﺎم ﺑﺮﺳﺪ ‪.‬‬ ‫‪‬‬

‫‪ ‬‬ ‫ﻫﻨﮕﺎﻣﻲ ﻛﻪ اﺟﺮا اﺳﻜﺮﻳﭙﺖ ﺑﻪ اﺗﻤﺎم ﺑﺮﺳﺪ ‪.‬‬ ‫‪‬‬
‫ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﺗﺨﺮﻳﺐ ﻛﻨﻨﺪه ﺑﺎﻳﺪ ﻣﺘﺪي را ﺑﻪ ﻧﺎم )(‪ __destruct‬را در ﻛﻼس ﺗﻌﺮﻳﻒ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪68 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ destruct‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫روش ﻫﺎي دﺳﺘﻴﺎﺑﻲ‬

‫ﻳﻜﻲ از ﻣﺰاﻳﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا اﺳﺘﻔﺎده از اﻣﻜﺎن ﻛﭙﺴﻮﻟﻪ ﺳﺎزي اﺳﺖ ‪ .‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن ﺑﺎ ﻛﻤﻚ اﻳﻦ‬
‫ﻗﺎﺑﻠﻴﺖ ﻣﻲ ﺗﻮاﻧﻨﺪ دﺳﺘﺮﺳﻲ ﺑﻪ ﺧﺎﺻﻴﺖ ﻫﺎ و ﻣﺘﺪ ﻫﺎي اﺷﻴﺎء را ﻣﺤﺪود ﻧﻤﺎﻳﻨﺪ ‪ .‬ﺑﻴﺸﺘﺮ زﺑﺎن ﻫﺎي ﺑﺮﻧﺎﻣﻪ‬
‫ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا ﻣﺎﻧﻨﺪ ‪ C++ , java , PHP‬ﺳﻪ روش دﺳﺘﻴﺎﺑﻲ ‪ public , private , protected‬را ﺑﺮاي‬
‫ﻣﺤﺪود ﻛﺮدن دﺳﺘﺮﺳﻲ ﺑﻪ ﺧﺎﺻﻴﺖ ﻫﺎ و ﻣﺘﺪ ﻫﺎ ﻣﻮﺟﻮد در ﻛﻼس ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار ﻣﻲ دﻫﻨﺪ ‪ .‬ﺑﻪ ﻫﻨﮕﺎم‬
‫ﺗﻌﺮﻳﻒ ﻫﺮ ﻳﻚ از ﻣﺘﻐﻴﻴﺮ ﻫﺎ و ﻣﺘﺪ ﻫﺎي ﻣﻮﺟﻮد در ﻛﻼس ﺑﺮاي ﻣﺤﺪود ﻛﺮدن دﺳﺘﺮﺳﻲ ﺑﻪ آن ﻫﺎ ﺑﺎﻳﺪ ﻳﻜﻲ‬
‫از ﺳﻪ روش دﺳﺘﻴﺎﺑﻲ ‪ public , private , protected‬را ﺑﻪ ﻛﺎر ﺑﺒﺮﻳﻢ ‪ .‬در ﺻﻮرﺗﻲ ﻛﻪ ﺑﺮاي ﻣﺘﻐﻴﻴﺮ ﻳﺎ ﻣﺘﺪ‬
‫ﻫﺎ روش دﺳﺘﻴﺎﺑﻲ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﺸﻮد ‪ ,‬روش دﺳﺘﻴﺎﺑﻲ آن ‪ publice‬در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫‪69 | P a g e  ‬‬
‫‪ ‬‬
‫‪) Private‬ﺧﺼﻮﺻﻲ( ‪ :‬ﻓﻴﻠﺪ ﻫﺎ و ﻣﺘﺪ ﻫﺎﻳﻲ ﻛﻪ ﺑﻪ ﺻﻮرت ﺧﺼﻮﺻﻲ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ‪ ,‬اﺟﺎزه دﺳﺘﺮﺳﻲ‬
‫از ﺑﻴﺮون ﻛﻼس را ﻧﺪارﻧﺪ ‪ .‬اﻟﺒﺘﻪ ﻫﺮ ﻣﺘﺪي درون ﻛﻼس ﻣﻲ ﺗﻮاﻧﺪ ﺑﻪ آن ﻫﺎ دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﺪ و در‬
‫واﻗﻊ ﻓﻘﻂ از ﺑﻴﺮون ﻛﻼس )از ﻃﺮﻳﻖ اﺷﻴﺎء اﻳﺠﺎد ﺷﺪه از ﻛﻼس( ﻗﺎﺑﻞ دﺳﺘﺮس ﻧﻴﺴﺘﻨﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ private‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫در ﻣﺜﺎل ﻓﻮق ﻫﻤﺎن ﮔﻮﻧﻪ ﻛﻪ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ﭼﻮن ﻣﺘﺪ )(‪ s‬از ﻧﻮع ﺧﺼﻮﺻﻲ اﺳﺖ و در ﺑﻴﺮون ﻛﻼس ﻗﺎﺑﻞ‬
‫اﺳﺘﻔﺎده ﻧﻴﺴﺖ ﺑﺨﺎﻃﺮ اﻳﻦ اﺳﺖ ﻛﻪ اﻳﻦ ﻣﺜﺎل در زﻣﺎن اﺟﺮا ‪ error‬داده اﺳﺖ ‪.‬‬

‫‪) Public‬ﻋﻤﻮﻣﻲ(‬

‫ﻫﺮ ﻋﻨﺼﺮي از ﻛﻼس )اﻋﻢ از ﻓﻴﻠﺪ ﻳﺎ ﻣﺘﺪ( ﻛﻪ ﺑﻪ ﺻﻮرت ﻋﻤﻮﻣﻲ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮد ‪ ,‬ﺑﻪ راﺣﺘﻲ ﺗﻮﺳﻂ اﺷﻴﺎء‬
‫اﻳﺠﺎد ﺷﺪه از ﻛﻼس )ﺑﻴﺮون ﻛﻼس( ﻗﺎﺑﻞ دﺳﺘﺮﺳﻲ اﺳﺖ ‪.‬‬

‫‪) Protected‬ﻣﺤﺎﻓﻆ ﺷﺪه(‬

‫اﮔﺮ ﻳﻚ ﻋﻨﺼﺮ ﺑﻪ ﺻﻮرت ﻣﺤﺎﻓﻈﺖ ﺷﺪه ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺎﺷﺪ ‪ ,‬ﻓﻘﻂ ﻣﻲ ﺗﻮاﻧﻴﺪ از آن در ﺧﻮد ﻛﻼس اﺳﺘﻔﺎده‬
‫ﻛﻨﻴﺪ و از ﻃﺮﻳﻖ اﺷﻴﺎء )ﺑﻴﺮون ﻛﻼس( ﻗﺎﺑﻞ دﺳﺘﺮس ﻧﻴﺴﺖ ‪ .‬ﺗﻔﺎوت ﻣﺤﺎﻓﻈﺖ ﺷﺪه ﻳﺎ ﻋﻤﻮﻣﻲ اﻳﻦ اﺳﺖ در‬

‫‪ ‬‬
‫‪70 | P a g e  ‬‬
‫‪ ‬‬
‫ﻛﻼس ﻫﺎي ﻓﺮﻋﻲ ﻛﻪ از ﻛﻼس اﺻﻠﻲ ﻣﺸﺘﻖ ﻣﻲ ﺷﻮﻧﺪ ﻧﻴﺰ ﺗﻮاﻧﺎﻳﻲ دﺳﺘﺮﺳﻲ ﺑﻪ ﻋﻨﺎﺻﺮ ﻣﺤﺎﻇﺖ ﺷﺪه آن را‬
‫ﺧﻮاﻫﺪ داﺷﺖ ‪.‬‬

‫ﺟﻮاب‬ ‫ﺷﺎﻳﺪ اﻳﻦ ﺳﻮال ﭘﻴﺶ ﺑﻴﺎﻳﺪ ﻛﻪ ﭼﺮا ﺑﺎﻳﺪ ﻳﻚ ﻋﻨﺼﺮ ﻛﻼس را ﺑﻪ ﺻﻮرت ﺧﺼﻮﺻﻲ ﺗﻌﺮﻳﻒ ﻛﻨﻴﻢ؟؟؟‬
‫اﻳﻦ ﺳﻮال ﺳﺎده اﺳﺖ ﺑﺮاي اﻣﻨﻴﺖ اﻳﻦ ﻛﺎر اﻧﺠﺎم ﻣﻲ ﺷﻮد ‪ ,‬اﮔﺮ ﻋﻨﺼﺮ ﻣﺮﺑﻮﻃﻪ ﺧﺼﻮﺻﻲ ﻧﺒﺎﺷﺪ ‪ ,‬اﻣﻜﺎن‬
‫ﺗﻐﻴﻴﺮ آن ﺑﻪ ﻫﺮ ﻣﻘﺪاري از ﻃﺮﻳﻖ اﺷﻴﺎء اﻳﺠﺎد ﺷﺪه از ﻛﻼس وﺟﻮد دارد ‪ .‬ﺑﺮاي ﻣﺜﺎل ﻓﺮض ﻛﻨﻴﺪ ﻛﻼﺳﻲ‬
‫ﻧﻮﺷﺘﻪ ﻣﻲ ﺷﻮد ﻛﻪ ﻓﻬﺮﺳﺖ ﺑﺮﻧﺪﮔﺎن ﻗﺮﻋﻪ ﻛﺸﻲ را از ﭘﺎﻳﮕﺎه داده اﺳﺘﺨﺮاج ﻛﺮده و ﺑﻪ ﻛﺎرﺑﺮ ﻧﺸﺎن ﻣﻲ دﻫﺪ‬
‫ﻃﺒﻴﻌﺘﺎ اﮔﺮ اﻳﻦ ﻓﻬﺮﺳﺖ ﺑﻪ ﺻﻮرت ﻋﻤﻮﻣﻲ ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺎﺷﺪ ﻫﺮ ﺷﺨﺼﻲ ﻣﻲ ﺗﻮاﻧﺪ ﻳﻚ ﺷﺊ از ﻛﻼس اﻳﺠﺎد‬
‫ﻛﻨﺪ و اﺳﻢ ﺧﻮد را ﺑﻪ آراﻳﻪ ﻣﻮﺟﻮد در آن ﻟﻴﺴﺖ اﺿﺎﻓﻪ ﻛﻨﺪ در ﺣﺎﻟﻲ ﻛﻪ اﮔﺮ اﻳﻦ ﻓﻴﻠﺪ ﺧﺼﻮﺻﻲ ﺑﺎﺷﺪ ﭼﻨﻴﻦ‬
‫اﻣﻜﺎﻧﻲ وﺟﻮد ﻧﺪارد و ﻣﻲ ﺗﻮان ﻳﻚ ﻣﺘﺪ ﻋﻤﻮﻣﻲ اﻳﺠﺎد ﻛﺮد ﺗﺎ ﺑﻪ ﻓﻴﻠﺪﺧﺼﻮﺻﻲ دﺳﺘﺮﺳﻲ داﺷﺘﻪ ﺑﺎﺷﺪ و آن‬
‫را ﭼﺎپ ﻛﻨﺪ ‪.‬‬

‫ﻓﻴﻠﺪ ﻫﺎ و ﻣﺘﺪ ﻫﺎي اﻳﺴﺘﺎ ) ‪  ( static‬‬

‫ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ static‬در ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا اﻫﻤﻴﺖ ﺑﺴﻴﺎر زﻳﺎدي دارد ‪ .‬ﻓﻴﻠﺪ ﻫﺎ و ﻣﺘﺪ ﻫﺎي اﻳﺴﺘﺎ ﻧﻘﺶ‬
‫اﺳﺎﺳﻲ دراﻟﮕﻮي ﻃﺮاﺣﻲ ﺑﺮﻧﺎﻣﻪ اﻳﻔﺎ ﻣﻲ ﻛﻨﻨﺪ ‪ ,‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺲ ﻣﻲ ﺗﻮاﻧﺪ ﺑﺎ اﺳﺘﻔﺎده از ﻓﻴﻠﺪ ﻫﺎ و ﻣﺘﺪ ﻫﺎي‬
‫اﻳﺴﺘﺎﺗﻴﻚ ﺑﺼﻮرت ﻣﺴﺘﻘﻴﻢ و ﺑﺪون اﻳﺠﺎد ﻫﺮ ﮔﻮﻧﻪ ﺷﺊ از ﻛﻼس ﻣﺮﺑﻮﻃﻪ ‪ ,‬دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﻛﻨﺪ ‪ .‬ﻋﻨﺎﺻﺮ‬
‫اﻳﺴﺘﺎ ﻣﺸﺎﺑﻪ ﻳﻚ ﻋﻀﻮ ﺳﺮاﺳﺮي ﺑﺮاي ﻛﻼس ﻋﻤﻞ ﻣﻲ ﻛﻨﻨﺪ و ﺗﻤﺎم اﺷﻴﺎء اﻳﺠﺎد ﺷﺪه از آن ﻛﻼس ﻣﻲ ﺗﻮاﻧﻨﺪ‬
‫ﺑﻪ آن ﻫﺎ دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﻛﻨﻨﺪ ‪ .‬ﺑﻪ ﻋﻼوه ﻓﻴﻠﺪ ﻫﺎي اﻳﺴﺘﺎ ﻫﻤﻴﺸﻪ آﺧﺮﻳﻦ وﺿﻌﻴﺖ )ﻣﻘﺪار( ﺧﻮد را ﺣﻔﻆ ﻣﻲ‬
‫ﻛﻨﻨﺪ ‪ .‬در ﻣﺜﺎل ﻓﻮق اﺑﺘﺪا ﻛﻼس ‪ human‬اﻳﺠﺎد ﺷﺪه و درون آن ﻳﻚ ﻓﻴﻠﺪ و ﻣﺘﺪ اﻳﺴﺘﺎ اﻳﺠﺎد ﺷﺪه اﺳﺖ‬
‫‪ .‬در داﺧﻞ ﻣﺘﺪ ﻫﺎي ﻛﻼس ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﺧﺎﺻﻴﺖ اﻳﺴﺘﺎ ﺑﺎﻳﺪ از ﻛﻠﻤﻪ ‪ self::‬اﺳﺘﻔﺎده ﻛﺮد‪ .‬و ﻫﻤﭽﻨﻴﻦ‬
‫ﺑﺮاي اﺳﺘﻔﺎده از ﻣﺘﺪ ﻫﺎي اﻳﺴﺘﺎ درون ﻛﻼس از اﻳﻦ ﻛﻠﻤﻪ ﻛﻠﻴﺪي اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد اﻣﺎ در ﺑﻴﺮون ﻛﻼس‬
‫ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﺧﺎﺻﻴﺖ ﻫﺎي اﻳﺴﺘﺎ ﺑﺎﻳﺪ اﻳﻨﮕﻮﻧﻪ ﻋﻤﻞ ﻛﺮد ‪:: :‬ﻧﺎم ﻛﻼس ‪.‬‬

‫‪ ‬‬
‫‪71 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ staticfunction‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ Self::‬و ‪  parent::‬‬

‫‪ PHP‬از دو ﻧﺎم ﻛﻼس رزرو ﺷﺪه ﺑﻪ ﻧﺎم ‪ self::‬و ‪ parent::‬اﺳﺘﻔﺎده ﻣﻲ ﻧﻤﺎﻳﺪ ‪ self:: .‬ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ‬
‫ﺧﺎﺻﻴﺖ ﻫﺎ و ﻣﺘﺪ ﻫﺎي اﺳﺘﺎﺗﻴﻚ و ﻫﻤﭽﻨﻴﻦ ﺛﺎﺑﺖ ﻫﺎ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻛﺎر ﻣﻲ رود ‪ parent::.‬ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ‬
‫اﻋﻀﺎ ﻛﻼس واﻟﺪ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ extends‬اﺳﺘﻔﺎده‬
‫ﻣﻲ ﺷﻮد در اداﻣﻪ ﺑﻪ ﺑﺮرﺳﻲ ﻛﺎﻣﻞ آن ﻣﻲ ﭘﺮدازﻳﻢ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ self&parent‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪72 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﻓﻴﻠﺪ ﻫﺎي اﻳﺴﺘﺎ ﻣﻘﺪار ﻣﺸﺘﺮﻛﻲ در ﺗﻤﺎﻣﻲ اﺷﻴﺎء دارﻧﺪ و ﻣﻲ ﺗﻮان از آن ﻫﺎ ﺑﺮاي اﺷﺘﺮاك ﮔﺬاري ﻣﻘﺎدﻳﺮ‬
‫ﺑﻴﻦ اﺷﻴﺎء ﻳﻚ ﻛﻼس اﺳﺘﻔﺎده ﻧﻤﻮد ‪ .‬ﻋﻨﺎﺻﺮ اﻳﺴﺘﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮا را ﺑﺴﻴﺎر ﺷﺒﻴﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ‬
‫ﺳﻨﺘﻲ و روﻳﻪ ﮔﺮا ﻣﻲ ﻛﻨﻨﺪ ‪ ,‬ﺑﺪن ﺳﺎﺧﺖ اﺷﻴﺎء ﻣﻲ ﺗﻮان ﻣﺴﺘﻘﻴﻤﺎ ﻫﺮ ﺗﺎﺑﻌﻲ را ﺻﺪا زده و ﺑﻪ ﻫﺮ ﻓﻴﻠﺪي‬
‫دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﻧﻤﻮد ‪ .‬ﺑﻪ ﻫﻤﻴﻦ ﻋﻠﺖ ﺑﺎﻳﺪ از ﻋﻨﺎﺻﺮ اﻳﺴﺘﺎ ﺑﺎ دﻗﺖ اﺳﺘﻔﺎده ﻧﻤﻮد ‪.‬‬

‫ﺛﺎﺑﺖ ﻫﺎ در ﻛﻼس‬

‫ﺑﺮاي ﺗﻌﺮﻳﻒ ﺛﺎﺑﺖ در داﺧﻞ ﻛﻼس ﺑﺎﻳﺪ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ const‬اﺳﺘﻔﺎده ﻛﺮد ‪ .‬ﺛﺎﺑﺖ ﻫﺎي ﺗﻌﺮﻳﻒ ﺷﺪه درون‬
‫ﻛﻼس ﺑﺎ ﺛﺎﺑﺖ ﻫﺎي ﻋﻤﻮﻣﻲ ﺗﻔﺎوت دارﻧﺪ و از ﺛﺎﺑﺖ ﻫﺎي ﺗﻌﺮﻳﻒ ﺷﺪه درون ﻛﻼس ﻓﻘﻂ ﻣﻲ ﺗﻮان در داﺧﻞ‬
‫ﻛﻼس ﻳﺎ از ﻃﺮﻳﻖ اﺷﻴﺎء اﻳﺠﺎد ﺷﺪه از ﻛﻼس اﺳﺘﻔﺎده ﻧﻤﻮد ‪ .‬ﺛﺎﺑﺖ ﻫﺎ در ﻛﻼس ﺑﺎ اﺳﺘﻔﺎده از ﻛﻠﻤﻪ ﻛﻠﻴﺪي‬
‫‪ self::‬ﻗﺎﺑﻞ دﺳﺘﺮس ﻫﺴﺘﻨﺪ ‪.‬‬

‫‪ ‬‬
‫‪73 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ const‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪  .‬‬

‫ﺧﺮوﺟﻲ‬

‫وراﺛﺖ‬

‫ﻳﻜﻲ از ﺑﻬﺘﺮﻳﻦ وﻳﮋﮔﻲ ﻫﺎي ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ﺷﺊ ﮔﺮاﻳﻲ وراﺛﺖ اﺳﺖ ﻛﻪ ﻣﻲ ﺗﻮاﻧﻴﺪ ﻳﻚ ﻛﻼس را ﺗﻮﺳﻌﻪ داده‬
‫و ﻛﻼﺳﻲ ﻛﺎﻣﻼ ﺟﺪﻳﺪ ﺑﺴﺎزﻳﺪ ‪ .‬ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه )ﻓﺮزﻧﺪ( ﻣﻲ ﺗﻮاﻧﺪ ﺗﻤﺎﻣﻲ ﻗﺎﺑﻠﻴﺖ ﻫﺎي ﻛﻼس ﭘﺎﻳﻪ )واﻟﺪ(‬
‫را داﺷﺘﻪ ﺑﺎﺷﺪ ﻳﺎ در ﺻﻮرت ﻧﻴﺎز ‪ ,‬ﺑﺮﺧﻲ از آن ﻫﺎ را ﺑﺎزﻧﻮﻳﺴﻲ ﻧﻤﺎﻳﺪ ‪ .‬ﻫﻤﭽﻨﻴﻦ ﻣﻲ ﺗﻮاﻧﺪ ﻗﺎﺑﻠﻴﺖ ﻫﺎي ﻛﺎﻣﻼ‬
‫ﺟﺪﻳﺪي را ﻣﻌﺮﻓﻲ ﻛﻨﺪ ﻛﻪ در ﻛﻼس ﭘﺎﻳﻪ وﺟﻮد ﻧﺪارد ‪ .‬ﺑﺮاي اﻳﺠﺎد ﻳﻚ ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه ﻳﺎ ﻓﺮزﻧﺪ ﺑﺎﻳﺪ از‬
‫ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ extends‬اﺳﺘﻔﺎده ﻛﻨﻴﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ extends‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل اﺑﺘﺪا ﻳﻚ ﻛﻼس ﺑﻪ ﻧﺎم‬
‫‪ person‬ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ ﻛﻪ دو ﻓﻴﻠﺪ ﺳﺮاﺳﺮي دارد و ﻳﻚ ﻣﺘﺪ ﻛﻪ ﻣﻘﺎدﻳﺮ آن ﻓﻴﻠﺪ ﻫﺎ رو ﭼﺎپ ﻣﻲ ﻛﻨﺪ و‬
‫ﺳﭙﺲ ﻛﻼس دﻳﮕﺮي ﺑﻪ ﻧﺎم ‪ student‬ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ ﻛﻪ از ﻛﻼس اوﻟﻲ ﻣﺸﺘﻖ ﺷﺪه اﺳﺖ ﻛﻪ داراي ﻳﻚ‬
‫ﻓﻴﻠﺪ ﺳﺮاﺳﺮي اﺳﺖ و ﻳﻚ ﻣﺘﺪ ﻛﻪ ﻣﻘﺪار آن ﻓﻴﻠﺪ را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬در آﺧﺮ ﻳﻚ ﺷﺊ از ﻛﻼس ‪student‬‬
‫ﺳﺎﺧﺘﻪ ﺷﺪه اﺳﺖ و ﻣﻘﺪار ﻓﻴﻠﺪ ﻫﺎي ﺳﺮاﺳﺮي را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻛﻨﺪ وﻣﺘﺪ ﻫﺎي آن را اﺟﺮا ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫‪ ‬‬
‫‪74 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺑﻪ ﻃﻮر ﻛﻠﻲ ﻳﻚ ﻛﻼس ﺗﻨﻬﺎ ﻳﻚ ﻛﻼس ﭘﺎﻳﻪ ﻳﺎ واﻟﺪ ﻣﻲ ﺗﻮاﻧﺪ داﺷﺘﻪ ﺑﺎﺷﺪ وﻟﻲ ﻳﻚ ﻛﻼس واﻟﺪ ﻣﻲ ﺗﻮاﻧﺪ ﭼﻨﺪ‬
‫ﻛﻼس ﻓﺮزﻧﺪ داﺷﺘﻪ ﺑﺎﺷﺪ ‪ .‬اﮔﺮ ﺑﺨﻮاﻫﻴﻢ ﺗﺎ از ﻛﻼس ﺧﺎﺻﻲ ﻫﻴﭻ ﻛﻼس ﻓﺮزﻧﺪي اﻳﺠﺎد ﻧﺸﻮد ﺑﺎﻳﺪ از ﻛﻠﻤﻪ‬
‫ﻛﻠﻴﺪي ‪ final‬اﺳﺘﻔﺎده ﺷﻮد ﺑﻪ ﻣﺜﺎل ‪ final‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪75 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ﺑﺎزﻧﻮﻳﺴﻲ ﻣﺘﺪ ﻫﺎ )ﭼﻨﺪ رﻳﺨﺘﻲ(‬

‫در ﺻﻮرﺗﻲ ﻛﻪ ﻳﻚ ﻣﺘﺪ ﻫﻢ در ﻛﻼس واﻟﺪ و ﻫﻢ در ﻛﻼس ﻓﺮزﻧﺪ ﺗﻌﺮﻳﻒ ﺷﺪه ﺑﺎﺷﺪ آﻧﮕﺎه اﺷﻴﺎﺋﻲ ﻛﻪ از‬
‫ﻛﻼس ﻓﺮزﻧﺪ اﻳﺠﺎد ﻣﻲ ﺷﻮﻧﺪ ‪ ,‬از ﻣﺘﺪ ﺗﻌﺮﻳﻒ ﺷﺪه در ﻛﻼس ﻓﺮزﻧﺪ اﺳﺘﻔﺎده ﺧﻮاﻫﻨﺪ ﻧﻤﻮد ﻫﻤﭽﻨﻴﻦ اﺷﻴﺎﺋﻲ‬
‫ﻛﻪ از ﻛﻼس واﻟﺪ اﻳﻦ ﻣﺘﺪ را ﺻﺪا ﻣﻲ زﻧﻨﺪ از ﻣﺘﺪ داﺧﻞ ﻛﻼس واﻟﺪ اﺳﺘﻔﺎده ﺧﻮاﻫﻨﺪ ﻧﻤﻮد ‪ .‬ﺑﻪ اﻳﻦ ﻣﺴﺌﻠﻪ‬
‫ﭼﻨﺪ رﻳﺨﺘﻲ ﻣﻲ ﮔﻮﻳﻨﺪ ﻳﻌﻨﻲ ﻓﺮﺧﻮاﻧﻲ ﻳﻚ ﻣﺘﺪ ﺑﺮ روي اﺷﻴﺎء ﻣﺨﺘﻠﻒ ‪ ,‬اﺟﺮا ﻫﺎي ﻣﺘﻔﺎوﺗﻲ را در ﭘﻲ ﺧﻮاﻫﻨﺪ‬
‫داﺷﺖ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ chandrikhti‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬
‫‪76 | P a g e  ‬‬
‫‪ ‬‬
‫ﺟﻠﻮﮔﻴﺮي از ﺑﺎزﻧﻮﻳﺴﻲ ﻣﺘﺪ ﻫﺎ‬

‫ﺷﺎﻳﺪ ﮔﺎﻫﻲ اوﻗﺎت در ﺑﺮﻧﺎﻣﻪ ﻻزم ﺑﺎﺷﺪ ﻳﻚ ﻣﺘﺪ ﺑﻪ ﻧﺤﻮي ﻧﻮﺷﺘﻪ ﺷﻮد ﻛﻪ اﻣﻜﺎ ﺑﺎزﻧﻮﻳﺴﻲ آن در ﻛﻼس‬
‫ﻣﺸﺘﻖ ﺷﺪه وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ ﺑﻪ ﺑﻴﺎن دﻳﮕﺮ ﺗﻤﺎﻣﻲ ﻛﻼﺳﻬﺎي ﻣﺸﺘﻖ ﺷﺪه از ﻛﻼس ﭘﺎﻳﻪ ﻧﻴﺰ آن را ﺑﻪ ﻫﻤﺎن‬
‫ﺷﻜﻞ ﻣﻮرد اﺳﺘﻔﺎده ﻗﺮار دﻫﻨﺪ ‪ .‬ﺑﺮاي اﻳﻨﻜﺎر ﻫﻤﺎﻧﻨﺪ ﻛﻼس ﻫﺎ ﺑﺎﻳﺪ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ final‬اﺳﺘﻔﺎده ﻛﺮد ﺑﻪ‬
‫ﻣﺜﺎل ‪ finalfunction‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﺧﺮوﺟﻲ‬

‫اﻳﻦ ﻣﺜﺎل ﻫﻤﺎن ﻣﺜﺎل ﻗﺒﻠﻲ اﺳﺖ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ final‬در ﻣﺘﺪ ﻛﻼس واﻟﺪ اﺳﺘﻔﺎده ﺷﺪه‬
‫اﺳﺖ ﺑﺨﺎﻃﺮ ﻫﻤﻴﻦ اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣﻲ دﻫﺪ ‪.‬‬

‫در داﺧﻞ ﻛﻼس ﻣﺸﺘﻖ ﺷﺪه ﻣﻲ ﺗﻮان ﺑﻪ ﻣﺘﺪ ﻫﺎي ﻛﻼس واﻟﺪ دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﺑﻪ ﻫﻤﻴﻦ ﻣﻨﻈﻮر ﺑﺎﻳﺪ از دﺳﺘﻮر‬
‫‪ parent::‬اﺳﺘﻔﺎده ﻛﺮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ parentfunction‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪77 | P a g e  ‬‬
‫‪ ‬‬

‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫‪ ‬‬

‫ﺗﺎﺑﻊ ‪instanceof‬‬

‫در ﭘﺮوژه ﻫﺎي ﺑﺰرگ ﺗﻮﺟﻪ ﺑﻪ اﻳﻦ ﻧﻜﺘﻪ ﻛﻪ آﻳﺎ ﺷﺊ ﻣﻮرد ﻧﻈﺮ از ﻛﻼس ﻣﺪ ﻧﻈﺮ ﻣﺎ ﺳﺎﺧﺘﻪ ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ‪.‬‬
‫ﺑﺮاي اﻳﻦ ﻛﺎر ﺑﺎﻳﺪ از ﺗﺎﺑﻊ ‪ instanceof‬اﺳﺘﻔﺎده ﻛﺮد اﻳﻦ ﺗﺎﺑﻊ ﻫﻤﭽﻨﻴﻦ ﺑﺮاي ﻛﻼس ﻫﺎﻳﻲ ﻛﻪ از ﻳﻚ ﻛﻼس‬
‫دﻳﮕﺮ ارث ﺑﺮي ﻛﺮده اﻧﺪ ﻧﻴﺰ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬اﮔﺮ ﺷﺊ از ﻛﻼس ﻣﻮرد ﻧﻈﺮ اﻳﺠﺎد ﺷﺪه ﺑﺎﺷﺪ ﻣﻘﺪار ‪true‬‬
‫را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻣﻘﺪار ‪ false‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ instanceof‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ‬
‫ﻣﺜﺎل در دو ﺷﺮط ﻣﻘﺪار ﺗﺎﺑﻊ ﺑﺮاﺑﺮ ‪ true‬ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫‪78 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺗﻮاﺑﻊ ﺳﺎزﻧﺪه و ﻛﻼس ﻫﺎي ﻓﺮزﻧﺪ‬

‫اﮔﺮ ﻳﻚ ﻛﻼس ﻓﺮزﻧﺪ داراي ﻣﺘﺪ ﺳﺎزﻧﺪه ﻧﺒﺎﺷﺪ ‪ ,‬ﺑﻪ ﻫﻨﮕﺎم اﻳﺠﺎد ﺷﺊ از ﻛﻼس ﻓﺮزﻧﺪ ﻣﺘﺪ ﺳﺎزﻧﺪه ﻛﻼس‬
‫واﻟﺪ ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﻓﺮاﺧﻮاﻧﻲ ﺧﻮاﻫﺪ ﺷﺪ ‪ .‬اﮔﺮ ﻛﻼس ﻓﺮزﻧﺪ ﺧﻮد داراي ﻳﻚ ﻣﺘﺪ ﺳﺎزﻧﺪه ﺑﺎﺷﺪ دﻳﮕﺮ ﻣﺘﺪ‬
‫ﺳﺎزﻧﺪه واﻟﺪ ﺑﻪ ﻃﻮر ﺧﻮدﻛﺎر ﻓﺮاﺧﻮاﻧﻲ ﻧﺨﻮاﻫﺪ ﺷﺪ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ constructparent‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪79 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫راﺑﻂ ﻫﺎ )‪  (Interface‬‬

‫ﻳﻚ راﺑﻂ )واﺳﻂ( ﻣﺘﺪ ﻫﺎﻳﻲ را ﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻳﻚ ﻛﻼس ﺑﺎﻳﺪ آن ﻫﺎ را ﭘﻴﺎده ﺳﺎزي ﻛﻨﺪ ‪ .‬اﻟﺒﺘﻪ راﺑﻂ ﻫﺎ‬
‫ﺗﻨﻬﺎ ﻣﺸﺨﺼﺎت ﻣﺘﺪ ﻣﻮرد ﻧﻈﺮ را ﺑﻴﺎن ﻣﻲ ﻛﻨﻨﺪ و درﺑﺎره ي ﻛﺪ ﻫﺎي داﺧﻞ ﻣﺘﺪ ﻫﻴﭻ ﺗﻮﺿﻴﺤﻲ ﻧﻤﻲ دﻫﺪ ‪.‬‬
‫واﺳﻂ ﻫﺎ ﺑﺎ ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ interface‬و ﻫﻤﺎﻧﻨﺪ ﻛﻼس ﻫﺎ اﻳﺠﺎد ﻣﻲ ﺷﻮﻧﺪ وﻟﻲ در واﺳﻂ ﻫﺎ ﻛﺪ ﻣﺮﺑﻮط ﺑﻪ ﻫﻴﭻ‬
‫ﻣﺘﺪي ﭘﻴﺎده ﺳﺎزي ﻧﻤﻲ ﺷﻮد ‪ .‬ﺣﺎل اﮔﺮ ﻛﻼﺳﻲ ﺑﺨﻮاﻫﺪ اﻳﻦ راﺑﻂ را ﭘﻴﺎده ﺳﺎزي ﻛﻨﺪ ‪ ,‬ﺑﺎﻳﺪ ﺗﻤﺎﻣﻲ ﻣﺘﺪ ﻫﺎي‬
‫ﻣﺸﺨﺺ ﺷﺪه در آن را ﺑﺎ ﻫﻤﺎن ﺳﺎﺧﺘﺎر ‪ ,‬ﺑﺎزﻧﻮﻳﺴﻲ ﻧﻤﺎﻳﺪ ‪ .‬ﺑﺮاي اﻳﻨﻜﻪ ﻣﺸﺨﺺ ﻛﻨﻴﻢ ﻳﻚ ﻛﻼس ‪ ,‬ﻗﺮار‬
‫اﺳﺖ ﻳﻚ راﺑﻂ را ﭘﻴﺎده ﺳﺎزي ﻧﻤﺎﻳﺪ ﺑﺎﻳﺪ از ﻛﻠﻤﻪ ﻛﻠﻴﺪي ‪ implements‬اﺳﺘﻔﺎده ﺷﻮد اﻳﻦ ﻛﻠﻤﻪ ﺑﺎﻳﺪ ﺑﻌﺪ از‬
‫اﺳﻢ ﻛﻼس و ﺳﭙﺲ ﻧﺎم راﺑﻂ اﺳﺘﻔﺎده ﺷﻮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ interface‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل اﮔﺮ ﻧﺎم ﻫﺮ ﻳﻚ‬
‫از ﻣﺘﺪ ﻫﺎي داﺧﻞ ﻛﻼس و ﻳﺎ ﺳﺎﺧﺘﺎر آن ﻫﺎ ﺗﻐﻴﻴﺮ ﻳﺎﺑﺪ ﺑﺮﻧﺎﻣﻪ ﺑﺎ ﺧﻄﺎ ﻣﻮاﺟﻪ ﺧﻮاﻫﺪ ﺷﺪ ‪.‬‬

‫‪ ‬‬
‫‪80 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ﺗﻤﺎﻣﻲ ﻣﺘﺪﻫﺎﻳﻲ ﻛﻪ در ﻳﻚ واﺳﻂ ﺗﻌﺮﻳﻒ ﻣﻲ ﺷﻮﻧﺪ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮرت ‪ publice‬ﺑﺎﺷﻨﺪ ‪ .‬ﻛﻼس ﻫﺎ ﻣﻤﻜﻦ اﺳﺖ‬
‫ﺑﻴﺶ از ﻳﻚ واﺳﻂ داﺷﺘﻪ ﺑﺎﺷﻨﺪ در اﻳﻦ ﺻﻮرت ﻧﺎم واﺳﻂ ﻫﺎ را ﺑﺎ ﻛﺎراﻛﺘﺮ ﻛﺎﻣﺎ )‪ (,‬از ﻫﻤﺪﻳﮕﺮ ﺟﺪا ﻣﻴﻜﻨﻴﻢ‪.‬‬

‫‪ ‬‬
‫‪81 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ دوازدﻫﻢ‬
‫ارﺗﺒﺎط ﺑﺎ ﭘﺎﻳﮕﺎه داده ‪ ‬‬

‫ﺑﺮاي اﺗﺼﺎل و ﻛﺎر ﺑﺎ ﭘﺎﻳﮕﺎه داده ‪ Mysql‬از زﺑﺎن و دﺳﺘﻮرات ‪ PHP‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬از ﭘﺎﻳﮕﺎه داده ﺑﺮاي‬

‫ذﺧﻴﺮه اﻃﻼﻋﺎت اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﻗﺒﻞ از اﻳﻨﻜﻪ ﺑﺘﻮاﻧﻴﺪ ﺑﻪ اﻃﻼﻋﺎت ﻳﻚ ﭘﺎﻳﮕﺎه داده دﺳﺘﺮﺳﻲ داﺷﺘﻪ‬

‫ﺑﺎﺷﻴﺪ و آن ﻫﺎ را وﻳﺮاﻳﺶ ﻧﻤﺎﻳﻴﺪ ‪ .‬ﺑﺎﻳﺪ ﻳﻚ اﺗﺼﺎل ﺑﺎ ارﺗﺒﺎط ﻳﺎ دﻳﺘﺎﺑﻴﺲ ﺑﺮﻗﺮار ﺷﻮد ‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر ﺗﻮاﺑﻌﻲ‬

‫ﻣﺨﺘﻠﻔﻲ وﺟﻮد دارد ﻫﻤﻪ اﻳﻦ روش ﻫﺎ از ﻧﻈﺮ ﻗﺪرت و اﻣﻜﺎﻧﺎت ﻫﻤﺎﻧﻨﺪ ﻫﻢ ﻫﺴﻨﺘﺪ ‪ .‬اﺑﺘﺪا ‪phpmyadmin‬‬

‫را ﺑﺎز ﻣﻲ ﻧﻤﺎﻳﻴﻢ ‪ .‬و ﻃﺒﻖ ﺗﺼﻮﻳﺮ ﮔﺰﻳﻨﻪ ‪ databases‬را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﺑﻌﺪ از اﻧﺘﺨﺎب ﮔﺰﻳﻨﻪ ﺑﺎﻻ ﺻﻔﺤﻪ ﭘﺎﻳﻴﻦ ﺑﺎز ﻣﻲ ﺷﻮد ﻛﻪ در ﺟﺎي ﺧﺎﻟﻲ اول ﻧﺎم ﭘﺎﻳﮕﺎه داده ﻣﻮرده ﻧﻈﺮ را ﻣﻲ‬

‫ﻧﻮﻳﺴﻴﻢ و روي دﻛﻤﻪ ‪ create‬ﻛﻠﻴﻚ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
‫‪82 | P a g e  ‬‬
‫‪ ‬‬

‫ﺑﻌﺪ در ﺳﻤﺖ راﺳﺖ ﻧﺎم ﭘﺎﻳﮕﺎه داده را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻴﻢ و ﺻﻔﺤﻪ ﭘﺎﻳﻴﻦ ﺑﺎز ﻣﻲ ﺷﻮد ﻛﻪ ﻧﺎم ﺟﺪول را در‬

‫ﺟﺎي ﺧﺎﻟﻲ اول و ﺗﻌﺪاد ﻓﻴﻠﺪ ﻫﺎ را در ﺟﺪول دوم ﻣﻲ ﻧﻮﻳﺴﻴﻢ و روي دﻛﻤﻪ ‪ Go‬ﻛﻠﻴﻚ ﻣﻲ ﻛﻨﻴﻢ و ﻧﻮع ﻓﻴﻠﺪ‬

‫ﻫﺎ را ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
‫‪83 | P a g e  ‬‬
‫‪ ‬‬

‫ﺑﺮاي اﺗﺼﺎل و ﻛﺎر ﺑﺎ ﭘﺎﻳﮕﺎه داده ‪ Mysql‬از زﺑﺎن و دﺳﺘﻮرات ‪ PHP‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬از ﭘﺎﻳﮕﺎه داده ﺑﺮاي‬
‫ذﺧﻴﺮه اﻃﻼﻋﺎت اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﻗﺒﻞ از اﻳﻨﻜﻪ ﺑﺘﻮاﻧﻴﺪ ﺑﻪ اﻃﻼﻋﺎت ﻳﻚ ﭘﺎﻳﮕﺎه داده دﺳﺘﺮﺳﻲ داﺷﺘﻪ‬
‫ﺑﺎﺷﻴﺪ و آن ﻫﺎ را وﻳﺮاﻳﺶ ﻧﻤﺎﻳﻴﺪ ‪ .‬ﺑﺎﻳﺪ ﻳﻚ اﺗﺼﺎل ﺑﺎ ارﺗﺒﺎط ﻳﺎ دﻳﺘﺎﺑﻴﺲ ﺑﺮﻗﺮار ﺷﻮد ‪ .‬ﺑﺮاي اﻳﻦ ﻛﺎر ﺗﻮاﺑﻌﻲ‬
‫ﻣﺨﺘﻠﻔﻲ وﺟﻮد دارد ﻫﻤﻪ اﻳﻦ روش ﻫﺎ از ﻧﻈﺮ ﻗﺪرت و اﻣﻜﺎﻧﺎت ﻫﻤﺎﻧﻨﺪ ﻫﻢ ﻫﺴﻨﺘﺪ ‪ .‬ﺑﺮاي اﻳﺠﺎد ارﺗﺒﺎط ﺑﺎ‬
‫ﭘﺎﻳﮕﺎه داده از ﻛﻼس ‪ mysqli‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ ‪ .‬اﻳﻦ ﺗﺎﺑﻊ ‪ 4‬ورودي از ﻛﺎرﺑﺮ ﻣﻲ ﮔﻴﺮد ‪ .‬ﻛﻪ در آن ﻫﺎ را در‬
‫زﻳﺮ ﻣﺸﺎﻫﺪه ﻣﻲ ﻛﻨﻴﺪ ‪:‬‬

‫ﭘﺎراﻣﺘﺮ اول ‪ :‬ﻧﺎم ﺳﺮور ‪ mysql‬ي اﺳﺖ ﻛﻪ دﻳﺘﺎﺑﻴﺲ ﺷﻤﺎ روي آن ﻗﺮار دارد و ﺷﻤﺎ ﻣﻴﺨﻮاﻫﻴﺪ ﺑﻪ‬ ‫‪‬‬
‫آن ﻣﺘﺼﻞ ﺷﻮﻳﺪ ‪  .‬‬
‫ﭘﺎﻣﺘﺮ دوم ‪ :‬ﻧﺎم ﻛﺎرﺑﺮي اﺳﺖ ﻛﻪ در ﺳﺮور ﭘﺎﻳﮕﺎه داده ﺗﻌﺮﻳﻒ ﺷﺪه ‪  .‬‬ ‫‪‬‬
‫ﭘﺎراﻣﺘﺮ ﺳﻮم ‪ :‬ﻛﻠﻤﻪ ﻋﺒﻮر ﻣﺮﺗﺒﻂ ﺑﺎ ﻧﺎم ﻛﺎرﺑﺮي اﺳﺖ ‪  .‬‬ ‫‪‬‬
‫ﭘﺎراﻣﺘﺮ ﭼﻬﺎرم ‪ :‬ﻧﺎم ﭘﺎﻳﮕﺎه داده ﻣﻮرد ﻧﻈﺮ ﻣﺎ از ﺑﻴﻦ ﻫﻤﻪ ﭘﺎﻳﮕﺎه داده ﻫﺎي ﻣﻮﺟﻮد در ﺳﺮور اﺳﺖ ‪  .‬‬ ‫‪‬‬

‫‪ ‬‬
 ‫‪84 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ‪ connection‬ﺑﻪ دﻳﺘﺎﺑﻴﺲ ﻣﻮرد ﻧﻈﺮ اﺳﺖ ‪ .‬وﻗﺘﻲ ﻛﻪ ارﺗﺒﺎط ﺑﺮﻗﺮار ﺷﺪه ﺑﺎﺷﺪ ﻣﻲ‬
‫ﺗﻮاﻧﺪ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ query‬از ﻛﻼس ‪ mysqli‬ﻋﻤﻠﻴﺎت ﺧﻮد را در ﭘﺎﻳﮕﺎه داده اﻧﺠﺎم داد ‪.‬‬

‫دﺳﺘﻮر ‪  Insert into‬‬

‫اﻳﻦ دﺳﺘﻮر ﺑﺮاي درج رﻛﻮرد در ﺟﺪول ﻣﻮرد ﻧﻈﺮ ﻣﺎ ﺑﻪ ﻛﺎر ﻣﻲ رود ‪ .‬ﺷﻜﻞ‪ ‬ﻛﻠﻲ اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺻﻮرت زﻳﺮ‬
‫ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ check‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  check.php‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬
 ‫‪85 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  check.html‬‬

‫‪ ‬‬
‫ﺑﺎ اﺟﺮا ﻣﺜﺎل ﻓﻮق اﺑﺘﺪا ﻳﻚ ﻓﺮم ﺑﺮاي ﮔﺮﻓﺘﻦ ورودي از ﻛﺎرﺑﺮ اﻳﺠﺎد ﺷﺪه اﺳﺖ ﻛﻪ ﺑﺎ ﻣﺘﺪ ‪ post‬ورودي ﻫﺎ‬
‫رو ﺑﻪ ‪ check.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪ .‬در ﻓﺎﻳﻞ ‪ check.php‬در ﺧﻂ اول اﺑﺘﺪا ﺑﺮرﺳﻲ ﺷﺪه اﺳﺖ ﻛﻪ آﻳﺎ اﻃﻼﻋﺎت‬
‫ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﻧﺸﺪه ﺑﺎﺷﺪ ﺑﺎ ﺗﺎﺑﻊ ‪ header‬در زﺑﺎن ‪ PHP‬ﻣﺮورﮔﺮ دوﺑﺎره‬
‫ﺑﻪ ﺻﻔﺤﻪ ﻓﺮم ﺑﺮ ﻣﻴﮕﺮدد اﮔﺮ اﻃﻼﻋﺎت ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ اﺑﺘﺪا اﻃﻼﻋﺎت درﻳﺎﻓﺘﻲ را در ﻣﺘﻐﻴﻴﺮي ذﺧﻴﺮه ﺷﺪه‬
‫اﺳﺖ و در ﺧﻂ ﭼﻬﺎرم از ﺗﺎﺑﻊ ‪ mysqli‬ﺑﺮاي اﺗﺼﺎل اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ﻛﻪ ﺳﺮور ﻣﺎ ‪ localhost‬و ﻳﻮزر ﻣﺎ‬
‫‪ root‬ﺑﺪون ﭘﺴﻮرد اﺳﺖ و اﺳﻢ ﭘﺎﻳﮕﺎه داده ﻣﺎ ‪ school‬ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ در ﻛﻨﺎر ﺗﺎﺑﻊ ‪  mysqli‬از ﻛﺎراﻛﺘﺮ @‬
‫اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ ﻛﻪ ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ اﺳﺖ ﻛﻪ اﮔﺮ اﻳﻦ ﺗﺎﺑﻊ ﻧﺘﻮاﻧﺪ ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﻮرده ﻧﻈﺮ ﻣﺘﺼﻞ ﺷﻮد‬
‫ﻫﻴﭻ ‪ error‬ﺑﺮاي ﻛﺎرﺑﺮ ﭼﺎپ ﻧﻤﻲ ﺷﻮد و ﻣﺎ ﺧﻮدﻣﺎن ﻣﻲ ﺧﻮاﻫﻴﻢ اﻳﻦ ﺧﻄﺎ را ﻣﺪﻳﺮﻳﺖ ﻛﻨﻴﻢ ‪ .‬در ﺷﺮط ﺑﻌﺪي‬
‫اﺑﺘﺪا ﺑﺮرﺳﻲ ﺷﺪه اﺳﺖ ﻛﻪ آﻳﺎ اﺗﺼﺎل درﺳﺖ و ﻛﺎﻣﻞ اﻧﺠﺎم ﺷﺪه اﺳﺖ و ﺧﻄﺎﻳﻲ ﻧﺪارد اﮔﺮ ﺧﻄﺎﻳﻲ داﺷﺖ‬
‫ﭘﻴﻐﺎم ‪ error connect‬ﺑﺮاي ﻛﺎرﺑﺮ ﻧﻤﺎﻳﺶ داده ﻣﻲ ﺷﻮد اﮔﺮ ﺧﻄﺎﻳﻲ ﻧﺪاﺷﺖ ﺑﺎ اﺳﺘﻔﺎده از ‪mysqli_query‬‬
‫ﻛﻮﺋﺮي ﻣﻮرد ﻧﻈﺮﻣﺎن را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻛﻮﺋﺮي درج در ﭘﺎﻳﮕﺎه داده ﻣﻲ ﺑﺎﺷﺪ و در آﺧﺮ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ‬
‫‪ mysqli_clise‬ارﺗﺒﺎط را ﻣﻲ ﺑﻨﺪﻳﻢ و ﻣﺮور ﮔﺮ را ﺑﻪ ﺻﻔﺤﻪ ﻓﺮم ﻣﻲ ﻓﺮﺳﺘﻴﻢ ‪.‬‬

‫ﺧﻮاﻧﺪن از ﭘﺎﻳﮕﺎه داده‬

‫در ﻣﺜﺎل ﻗﺒﻞ ﻧﺤﻮه درج در ﭘﺎﻳﮕﺎه داه را آﻣﻮﺧﺘﻴﺪ ‪ .‬ﻫﺮ ﮔﺎه در ﭘﺎﻳﮕﺎه داده ﻧﻴﺎز ﺑﺎﺷﺪ ﺗﺎ اﻃﻼﻋﺎت ﺧﺎﺻﻲ را از‬
‫ﻳﻚ ﻳﺎ ﭼﻨﺪ ﺟﺪول اﺳﺘﺨﺮاج ﻛﺮده و آن ﻫﺎ را در ﺧﺮوﺟﻲ ﻧﻤﺎﻳﺶ دﻫﻴﺪ از دﺳﺘﻮر ‪ select‬اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد‬
‫‪ .‬ﺑﻪ ﻣﺜﺎل ‪ select.php‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪86 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫در اﻳﻦ ﻣﺜﺎل اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ mysqli‬ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﻮرده ﻧﻈﺮ ﻣﺘﺼﻞ ﺷﺪه اﻳﻢ و ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل‬
‫ﻗﺒﻞ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎ را ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر @ ﺑﻪ دﺳﺖ ﮔﺮﻓﺘﻪ اﻳﻢ ‪ .‬اﺑﺘﺪا ﺑﺎ دﺳﺘﺮ ﺷﺮﻃﻲ ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ‬
‫ﻛﻪ آﻳﺎ ارﺗﺒﺎط ﺧﻄﺎ دارد ﻳﺎ ﺧﻴﺮ اﮔﺮ دارد ﭘﻴﻐﺎﻣﻲ ﺑﺮاي ﻛﺎرﺑﺮ ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻛﻮﺋﺮي ﻣﺪ ﻧﻈﺮ‬
‫ﺧﻮد را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ دﺳﺘﻮر ‪ select‬ﻣﻲ ﺑﺎﺷﺪ و ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ query‬اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ را در‬
‫ﻣﺘﻐﻴﻴﺮي ذﺧﻴﺮ ه ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﺑﺎ دﺳﺘﻮر ‪ echo‬دﺳﺘﻮر ﺳﺎﺧﺖ ﺟﺪول را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ‪ .‬ﺑﺮاي ﭼﺎپ ﺧﺮوﺟﻲ روش‬
‫ﻫﺎي ﻣﺘﺪاوﻟﻲ وﺟﻮد دارد در اﻳﻨﺠﺎ ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ و ﺗﺎﺑﻊ ‪ mysqli_fetch_assoc‬اﻳﻨﻜﺎر اﻧﺠﺎم ﺷﺪه‬
‫اﺳﺖ‪.‬‬

‫‪ ‬‬
 ‫‪87 | P a g e  ‬‬
‫‪ ‬‬
‫اﻳﻦ ﺗﺎﺑﻊ ﻳﻚ ورودي ﻣﻲ ﮔﻴﺮد ﻛﻪ ﻫﻤﺎن ﻣﻘﺪار ﺑﺎزﮔﺸﺘﻲ ﺗﺎﺑﻊ ‪ mysqli_query‬ﻣﻲ ﺑﺎﺷﺪ و ﺧﺮوﺟﻲ اﻳﻦ ﺗﺎﺑﻊ‬
‫ﻳﻚ آراﻳﻪ ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ اﻳﻦ آراﻳﻪ ﭘﻴﻤﺎﻳﺶ ﻣﻲ ﺷﻮد ﺗﺎ ﺑﻪ آﺧﺮ ﺑﺮﺳﺪ و ﻣﻘﺪار ‪ false‬را‬
‫ﺗﻮﻟﻴﺪ ﻛﻦ و از ﺣﻠﻘﻪ ﺧﺎرج ﺷﻮد ﺑﻨﺎ ﺑﺮاﻳﻦ ﻛﻞ آراﻳﻪ ﭼﺎپ ﻣﻲ ﺷﻮد و در آﺧﺮ ارﺗﺒﺎط را ﺑﺎ ﭘﺎﻳﮕﺎه داده را ﻗﻄﻊ‬
‫ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫دﺳﺘﻮر ‪  where‬‬

‫اﻣﺎ ﺑﺮاي اﻳﻨﻜﻪ ﻣﺎ ﺑﺘﻮاﻧﻴﻢ در ﻛﻮﺋﺮي ﻫﺎي ﺧﻮد از ﻋﺒﺎرات ﺷﺮﻃﻲ ﻫﻢ اﺳﺘﻔﺎده ﻛﻨﻴﻢ از ﻋﺒﺎرت ‪ where‬اﺳﺘﻔﺎده‬
‫ﻣﻲ ﻛﻨﻴﻢ ﺑﺮاي ﻣﺜﺎل ﻣﺎ ﻣﻴﺨﻮاﻫﻢ در ﭘﺎﻳﮕﺎه داده ﻳﻮزر ﻫﺎ ﺷﺨﺺ ﺧﺎﺻﻲ را ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ 16‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  16.html‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  16.php‬‬

‫‪ ‬‬
‫‪ ‬‬
‫‪88 | P a g e  ‬‬
‫‪ ‬‬
‫در اﻳﻦ ﻣﺜﺎل ﻧﺎم و ﻓﺎﻣﻴﻠﻲ ﺑﺮاي ﺟﺴﺘﺠﻮ در ﭘﺎﻳﮕﺎه داده از ﻛﺎرﺑﺮ ﮔﺮﻓﺘﻪ ﻣﻲ ﺷﻮد و ﺑﻪ ﺻﻔﺤﻪ ‪ 16.php‬ارﺳﺎل‬
‫ﻣﻲ ﺷﻮد در اﻳﻦ ﺻﻔﺤﻪ اﺑﺘﺪا ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﭘﺎراﻣﺘﺮ ﻧﺎم و ﻓﺎﻣﻴﻠﻲ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ‬
‫ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﻧﺸﺪه ﺑﺎﺷﺪ ﻳﻌﻨﻲ اﻳﻦ آدرس دﺳﺘﻲ وارد ﺷﺪه اﺳﺖ ﺑﺮاي ﻫﻤﻴﻦ ﻣﺮورﮔﺮ را ﺑﻪ ﺻﻔﺤﻪ وارد‬
‫ﻛﺮدن ﻓﺮم ﻣﻴﻔﺮﺳﺘﻢ اﮔﺮ ﭘﺎراﻣﺘﺮ ﻫﺎ ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ mysqli‬ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﻮرد ﻧﻈﺮ‬
‫ﻣﺘﺼﻞ ﻣﻲ ﺷﻮﻳﻢ و از ﻛﺎراﻛﺘﺮ @ ﺑﺮاي ﺟﻠﻮ ﮔﻴﺮي اﻳﺠﺎد ﺧﻄﺎ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ و ﺧﻮدﻣﺎن ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎ را ﺑﻪ‬
‫ﻋﻬﺪه ﻣﻲ ﮔﻴﺮﻳﻢ ‪ .‬دﺳﺘﻮر ﺷﺮﻃﻲ ﻣﻴﻨﻮﻳﺴﻢ ﺑﺮاي ﭼﻚ ﻛﺮدن درﺳﺖ ﺑﻮدن اﺗﺼﺎل ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﻲ ﻧﻮﻳﺴﻢ‬
‫اﮔﺮ ارﺗﺒﺎط ﺑﺮﻗﺮار ﺑﻮد ﻛﻮﺋﺮي ﻣﺪ ﻧﻈﺮ را ﻣﻲ ﻧﻮﻳﺴﻢ و ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر ‪ where‬ﺷﺮط ﻣﻮرد ﻧﻈﺮﻣﺎ را ﻣﻲ‬
‫ﻧﻮﻳﺴﻴﻢ اﻳﻦ ﺷﺮط ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻧﺎم و ﻓﺎﻣﻴﻠﻲ درﻳﺎﻓﺘﻲ در ﺟﺪول ‪ user‬وﺟﻮد دارد ﻳﺎ ﺧﻴﺮ ‪ .‬ﺗﺎﺑﻊ‬
‫‪ mysqli_num_rows‬ﺗﻌﺪاد رﻛﻮرد ﺑﺮﮔﺸﺘﻲ از ﻛﻮﺋﺮي ﻣﺪ ﻧﻈﺮﻣﺎن را ﺑﺮ ﻣﻴﮕﻴﺮداﻧﺪ اﻳﻦ دﺳﺘﻮر ﻳﻚ ورودي‬
‫ﻣﻲ ﮔﻴﺮد ﻛﻪ ﻫﻤﺎن ﺧﺮوﺟﻲ دﺳﺘﻮر ‪ msqli_query‬ﻣﻲ ﺑﺎﺷﺪ ‪ .‬ﺑﻨﺎ ﺑﺮاﻳﻦ اﮔﻪ دﺳﺘﻮر ‪mysqli_num_rows‬‬
‫ﺑﺮاﺑﺮ ﻳﻚ ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻳﻚ رﻛﻮرد در ﭘﺎﻳﮕﺎه داده ﻣﻮﺟﻮد اﺳﺖ ﻛﻪ اﻳﻦ ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ اﺳﺖ ﻛﻪ ﺟﺴﺘﺠﻮ ﻣﻮرد‬
‫ﻧﻈﺮ در ﭘﺎﻳﮕﺎه داده ﻣﻮﺟﻮد اﺳﺖ ﺑﺨﺎﻃﺮ ﻫﻤﻴﻦ ﭘﻴﻐﺎم ‪ Yes Found‬ﺑﺮاي ﻛﺎرﺑﺮ ﻧﻤﺎﻳﺶ داده ﻣﻲ ﺷﻮد و در ﻏﻴﺮ‬
‫اﻳﻦ ﺻﻮرت ﭘﻴﻐﺎم ‪ Not Found‬ﺑﻪ ﻛﺎرﺑﺮ ﻧﻤﺎﻳﺶ دادﻫﺪ ﻣﻲ ﺷﻮد ‪  .‬‬

‫دﺳﺘﻮر ‪  order by‬‬

‫دﺳﺘﻮر ‪ select‬اﻃﻼﻋﺎت ﺗﻤﺎﻣﻲ ﻓﻴﻠﺪ ﻫﺎي ﺗﻌﻴﻴﻦ ﺷﺪه ﺑﺮاي آن را ﺑﺮ اﺳﺎس ﻓﻴﻠﺪ اول ﻣﺮﺗﺐ ﻛﺮده و ﻧﻤﺎﻳﺶ‬
‫ﻣﻲ دﻫﺪ ‪ .‬اﻣﺎم ﻣﻤﻜﻦ اﺳﺖ ﺷﻤﺎ ﺑﺨﻮاﻫﻴﺪ اﻃﻼﻋﺎت را ﺑﺮ اﺳﺎس ﻣﻘﺪار ﻳﻚ ﻓﻴﻠﺪ دﻳﮕﺮ ﻏﻴﺮ از ﻓﻴﻠﺪ اول‬
‫ﺑﺼﻮرت ﻫﻤﺰﻣﺎن ﻣﺮﺗﺐ ﻧﻤﺎﻳﻴﺪ ﺑﺮاي اﻳﻦ ﻣﻨﻈﻮر ﺑﺎﻳﺴﺘﻲ ﭘﺲ از دﺳﺘﻮر ‪ select‬ﻧﺎم ﻓﻴﻠﺪ ﻳﺎ دو ﻓﻴﻠﺪي ﻛﻪ‬
‫ﻣﻴﺨﻮاﻫﻴﺪ اﻃﻼﻋﺎت ﺧﺮوﺟﻲ ﺑﺮ اﺳﺎس آن ﻣﺮﺗﺐ ﺷﻮﻧﺪ را ﺑﻪ ﺗﺮﺗﻴﺐ در ﻣﻘﺎﺑﻞ ﻋﺒﺎرت ‪ order by‬ﺗﻌﻴﻴﻦ ﻛﻨﻴﺪ‪.‬‬

‫ﻧﻜﺘﻪ ‪ :‬اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺻﻮرت ﭘﻴﺶ ﻓﺮض اﻃﻼﻋﺎت را ﺑﻪ ﺻﻮرت ﺻﻌﻮدي )ﻛﻮﭼﻚ ﺑﻪ ﺑﺰرگ( ﻣﺮﺗﺐ ﻣﻲ ﻛﻨﺪ‬
‫ﺑﺮاي اﻳﻨﻜﻪ از ﻧﺰوﻟﻲ )ﺑﺰرگ ﺑﻪ ﻛﻮﭼﻚ( ﻣﺮﺗﺐ ﻛﻨﺪ ﭘﺲ از ﺗﺎﻳﭗ ﻓﻴﻠﺪ ﻫﺎ از ﻋﺒﺎرت ‪ DESC‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ orderby‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﺑﺎ اﺳﺘﻔﺎده از اﻳﻦ دﺳﺘﻮر ﻣﻘﺪار ﺧﺮوﺟﻲ ﺑﺮ اﺳﺎس ﻧﺎم ﺑﻪ‬
‫ﺻﻮرت ﻧﺰوﻟﻲ ﻣﺮﺗﺐ ﺷﺪه اﺳﺖ ‪.‬‬

‫‪ ‬‬
‫‪89 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺑﻪ ﻣﺜﺎل ‪ orderby2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ‪ id‬ﺑﻪ ﺻﻮرت ﻧﺰوﻟﻲ در ﺧﺮوﺟﻲ ﭼﺎپ ﺷﺪه اﺳﺖ ‪.‬‬

‫‪ ‬‬
‫‪90 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫دﺳﺘﻮر ‪  Update‬‬

‫اﻳﻦ دﺳﺘﻮر ﺑﺮاي ﺗﻐﻴﻴﺮ ﻣﺠﻮد در ﻳﻚ ﻓﻴﻠﺪ ﺑﺎ ﻣﻘﺪار ﺟﺪﻳﺪ اﺳﺖ ‪ .‬ﺷﻜﻞ ﻛﻠﻲ اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺷﻜﻞ زﻳﺮ اﺳﺖ‬
‫ﺑﻪ ﺗﺼﻮﻳﺮ ﻓﻮق دﻗﺖ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪91 | P a g e  ‬‬
‫‪ ‬‬

‫در اﻳﻦ ﺗﺼﻮﻳﺮ اﮔﺮ ﺧﻮاﺳﺘﻴﻢ ﻣﻘﺪار ﭼﻨﺪ ﻓﻴﻠﺪ را ﺗﻐﻴﻴﺮ دﻫﻴﻢ در ﺟﻠﻮ دﺳﺘﻮر ‪ set‬از ﻛﺎﻣﺎ اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ‪.‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ 16-3‬ﺗﻮوﺟﻪ ﻛﻨﻴﺪ ‪ .‬ﻣﻘﺪار ﺟﺪول ﻣﺎ ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫ﺣﺎل ﺑﻪ ﻣﺜﺎل ‪ update‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪  .‬‬

‫‪ ‬‬
‫ﺑﺎ اﺟﺮا ﻣﺜﺎل ﺑﺎﻻ ﺟﺪول ﻣﺎ ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ ﺑﻪ ﺗﺼﻮﻳﺮ ﻓﻮق ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﺗﺎ ﺗﻐﻴﻴﺮ را ﻣﺸﺎﻫﺪه ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪92 | P a g e  ‬‬
‫‪ ‬‬
‫دﺳﺘﻮر ‪  Delete‬‬

‫از اﻳﻦ دﺳﺘﻮر ﺑﺮاي ﺣﺬف اﻃﻼﻋﺎت ﻳﻚ رﻛﻮرد اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ‪ .‬ﺷﻜﻞ ﻛﻠﻲ اﻳﻦ دﺳﺘﻮر ﺑﻪ ﺻﻮرت زﻳﺮ‬
‫اﺳﺖ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ delete‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ ﻣﺜﺎل از ﭘﺎﻳﮕﺎه داده ﻣﻮرده ﻧﻈﺮ ﻣﺎ رﻛﻮردي ﻛﻪ ‪ id‬آن ﺑﺮار ‪ 5‬ﺑﺎﺷﺪ از‬
‫ﺟﺪول ﺣﺬف ﻣﻲ ﺷﻮد ‪.‬‬

‫‪ ‬‬
‫از اﻳﻦ دﺳﺘﻮر ﺑﺮاي ﺣﺬف ﻛﻞ اﻃﻼﻋﺎت ﻫﻢ اﺳﺘﻔﺎده ﻣﻲ ﺷﻮد ﺑﺮاي ﺣﺬف ﻛﻞ اﻃﻼﻋﺎت ﺑﻪ ﻣﺜﺎل ‪ delete2‬ﺗﻮﺟﻪ‬
‫ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﺗﻤﺎم رﻛﻮرد ﻫﺎي ﺟﺪول ‪ user‬ﭘﺎك ﻣﻲ ﺷﻮد ‪ .‬ﺑﺮاي اﻳﻨﻜﺎر دو روش وﺟﻮد دارد ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ delete2‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
‫‪93 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﺳﻴﺰدﻫﻢ‬
‫‪ Ajax‬در ‪  jQuery‬‬

‫‪ Ajax‬ﻫﻨﺮ ﺗﺒﺎدل داده ﻫﺎ ﺑﺎ ﺳﺮور و ﺑﺮوز رﺳﺎﻧﻲ ﺑﺨﺶ ﻫﺎﻳﻲ از ﻳﻚ ﺻﻔﺤﻪ وب ﺑﺪون ﺑﺎرﮔﺬاري ﻣﺠﺪد ﺻﻔﺤﻪ‬
‫اﺳﺖ ‪.‬‬

‫‪ Ajax‬ﻣﺨﻔﻒ ﻛﻠﻤﺎت ‪ Asynchronous  JavaScript  And  XML‬اﺳﺖ ‪ Ajax .‬داده ﻫﺎ را در ﭘﺲ زﻣﻴﻨﻪ‬

‫ﺑﺎرﮔﺬاري ﻣﻲ ﻛﻨﺪ و آن ﻫﺎ را در ﺻﻔﺤﻪ وب ﺑﺪون ﺑﺎرﮔﺬاري ﻣﺠﺪد ﻛﻞ ﺻﻔﺤﻪ ﻧﻤﺎﻳﺲ ﻣﻲ دﻫﺪ ‪           .‬ﻣﺘﺪ‬
‫ﻫﺎي زﻳﺎدي ﺑﺮاي اﺳﺘﻔﺎده از ‪ Ajax‬در ‪ jQuery‬ﻓﺮاﻫﻢ ﺷﺪه اﺳﺖ و ﻳﻜﻲ از اﻳﻦ روش ﻫﺎ ‪ POST‬و ‪Get  ‬را‬
‫ﻣﻲ ﺗﻮاﻧﻴﺪ از ﺳﺮور راه دور درﺧﻮاﺳﺖ ﻛﻨﻴﺪ ‪  .‬‬

‫‪ ‬‬ ‫ﻣﺘﺪ ‪post‬‬

‫ﻣﺘﺪ )(‪ $.post‬ﺑﺎ اﺳﺘﻔﺎده از روش ‪ POST‬داده اي را از ﺳﺮور درﺧﻮاﺳﺖ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺷﻜﻞ ﻛﻠﻲ اﻳﻦ دﺳﺘﻮر‬
‫ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫‪ : Url ‬اﻟﺰاﻣﻲ اﺳﺖ ‪ Url ,‬ﻓﺎﻳﻞ در ﺧﻮاﺳﺖ ﺷﺪه اﺳﺖ ‪  .‬‬

‫‪ : Data ‬اﺧﺘﻴﺎري اﺳﺖ ‪ ,‬ﻣﻲ ﺗﻮاﻧﺪ ﺷﺎﻣﻞ ﺗﻌﺪادي ﻣﺘﻐﻴﻴﺮ و ﻣﻘﺎدﻳﺮ آن ﻫﺎ ﺑﺎﺷﺪ ﻛﻪ ﻫﻤﺮاه درﺧﻮاﺳﺖ‬
‫ﺑﻪ ﺳﺮور ارﺳﺎل ﻣﻲ ﺷﻮد ﻛﻪ اﻳﻦ ﻣﺘﻐﻴﻴﺮ ﻫﺎ ﺑﺎ ﻛﺎﻣﺎ )‪ (,‬از ﻫﻢ ﺟﺪا ﻣﻲ ﺷﻮﻧﺪ و ﻫﻤﻪ آن ﻫﺎ ﺑﺎ ﻫﻢ‬
‫درون }{ ﻗﺮار ﻣﻲ ﮔﻴﺮﻧﺪ ‪  .‬‬
‫‪ : Callback ‬اﺧﺘﻴﺎري اﺳﺖ ‪ ,‬ﺗﺎﺑﻌﻲ اﺳﺖ ﻛﻪ ﺑﻌﺪ از اﺟﺮا ﻛﺎﻣﻞ ﻣﺘﺪ )(‪ $.post‬اﺟﺮا ﻣﻲ ﺷﻮد ‪  .‬‬

‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﻳﻚ ورودي ﺑﺮاي درﻳﺎﻓﺖ از ﻛﺎرﺑﺮ اﻳﺠﺎد ﺷﺪه اﺳﺖ ﻛﻪ ﺧﺎﺻﻴﺖ‬
‫‪ onkeyup‬آن ﺗﺎﺑﻌﻲ را اﺟﺮا ﻣﻲ ﻛﻨﺪ ‪ id .‬اﻳﻦ ورودي ﺑﺮاﺑﺮ ‪ f‬داده ﺷﺪه اﺳﺖ و ﺳﭙﺲ ﺗﮓ ‪ div‬اﻳﺠﺎد ﺷﺪه‬
‫اﺳﺖ ﻛﻪ ‪ id‬آن ﺑﺮاﺑﺮ ‪ sss‬ﻗﺮار داده ﺷﺪه ‪ .‬اﺑﺘﺪا ‪ Jquery‬را در ﺻﻔﺤﻪ وارد ﻣﻲ ﻛﻨﻴﻢ و ﺳﭙﺲ ﻳﻚ ﺗﺎﺑﻊ ﺟﺎوا‬
‫ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ در اﻳﻦ ﺗﺎﺑﻊ از ﺗﺎﺑﻊ ‪ $.post‬اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻴﻢ آرﮔﻮﻣﻨﺖ اوﻟﻲ اﻳﻦ ﺗﺎﺑﻊ را آدرس ﺻﻔﺤﻪ‬
‫‪ aja.php‬اﺳﺖ ﻛﻪ در آن ﻓﻘﻂ دﺳﺘﻮر ‪ echo‬ﺑﺮاي ﭼﺎپ ﻣﻘﺪار درﻳﺎﻓﺘﻲ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ آرﮔﻮﻣﻨﺖ دوﻣﻲ‬
‫آن ﻣﺎ ﻣﺘﻐﻴﻴﺮي ﺑﻪ ﻧﺎم ‪ name‬را اﻳﺠﺎد ﻛﺮده و ﻣﻘﺪار آن را ﺑﺎ ﻛﻤﻚ ‪ Id‬ورودي ﺑﺮاﺑﺮ ﻣﻘﺪار ورودي ﻗﺮا ر‬
‫داده اﻳﻢ ﺳﭙﺲ آرﮔﻮﻣﻨﺖ ﺳﻮم ﻳﻚ ﺗﺎﺑﻊ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ ﻳﻚ ورودي دارد ﻛﻪ اﻳﻦ ورودي ﻫﻤﺎن ﻣﻘﺪار‬
‫‪ ‬‬
 ‫‪94 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﺮﮔﺸﺘﻲ از ﺻﻔﺤﻪ ‪ aja.php‬اﺳﺖ و ﺑﺎ اﺳﺘﻔﺎده از ‪ id‬ﺗﮓ ‪ div‬ﻣﺎ اﻳﻦ ‪ data‬ﺑﺮﮔﺸﺘﻲ را درون آن ﭼﺎپ ﻣﻲ‬
‫ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﻣﺜﺎل‪ aja‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  aja.html‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  aja.php‬‬

‫در ﻓﺎﻳﻞ ‪ aja.php‬اﺑﺘﺪا ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ورودي ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل‬
‫ﻧﺸﺪه ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻛﺎرﺑﺮ اﻳﻦ آدرس را دﺳﺘﻲ وارد ﻛﺮده و ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ header‬ﺻﻔﺤﻪ ﻣﺮورﮔﺮ را‬
‫ﺑﻪ ﺻﻔﺤﻪ ورود اﻃﻼﻋﺎت ارﺟﺎع ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ 17‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ ,‬در اﻳﻦ ﻣﺜﺎل ﻫﻤﺎﻧﻨﺪ ﻣﺜﺎل ﻗﺒﻞ ﺗﺎﺑﻌﻲ ﺑﺎ ﺟﺎوا ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ در آن از ﺗﺎﺑﻊ‬
‫)(‪ $.post‬اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ و ﻣﻘﺪار ورودي را ﺑﻪ ﺻﻔﺤﻪ ‪ 17.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪.‬در اﻳﻦ ﺻﻔﺤﻪ ﺑﻌﺪ از‬
‫اﻳﻨﻜﻪ ﭼﻚ ﻣﻲ ﺷﻮد ﻛﻪ آﻳﺎ ورودي ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﺘﺼﻞ ﺷﺪه و ﺑﺎ اﺳﺘﻔﺎده‬
‫از دﺳﺘﻮر ‪ like ‬ﻛﻮﺋﺮي ﻣﺪ ﻧﻈﺮﻣﺎن را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ در اﻳﻦ ﻛﻮﺋﺮي ﻫﺮ اﺳﻤﻲ ﻛﻪ داراي ﺣﺮوﻓﻲ ﻛﻪ اﻳﻦ‬
‫ﺻﻔﺤﻪ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ﺑﺎﺷﺪ ﻧﺸﺎن ﻣﻲ دﻫﺪ و ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ آن را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪95 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  17.html‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  17.php‬‬

‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل ‪ 17‐1p1.php‬و ‪ 17‐1p2.php‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل در ﺻﻔﺤﻪ ‪ 17‐1p1.php‬اﺑﺘﺪا ﺑﻪ ﭘﺎﻳﮕﺎه‬
‫داده ﻣﺘﺼﻞ ﺷﺪه و ﻣﻘﺪار آن را در ﻳﻚ ‪ combo  box‬ﻗﺮا داده اﺳﺖ ﻛﻪ ﻣﺎﻧﻨﺪ ﻣﺜﺎل ﻗﺒﻞ از ‪ id‬ﺑﺮاي‬
‫دﺳﺘﺮﺳﻲ ﺑﻪ ﻣﻘﺎدﻳﺮ اﻳﻦ ‪ combo  box‬اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ و ﺗﺎﺑﻊ ‪ java‬ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ از ﺗﺎﺑﻊ‬
‫)(‪ $.post‬ﺑﺮاي دﺳﺘﺮﺳﻲ ﺑﻪ ﺻﻔﺤﻪ ‪ 17‐1p2.php‬ﻣﺘﺼﻞ ﺷﺪه و ﻣﻘﺎدﻳﺮ را از آن ﺻﻔﺤﻪ ﺑﻪ ﺻﻮرت ‪ ajax‬ﺑﻪ‬
‫ﺧﻮده اﻳﻦ ﺻﻔﺤﻪ ﻣﻴﻔﺮﺳﺘﺪ ‪.‬‬
‫‪ ‬‬
 96 | P a g e  
 
  17p1.php ‫ﻓﺎﻳﻞ‬

 
 

 
 ‫‪97 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  17‐1p2.php‬‬

‫‪ ‬‬

‫ﻣﺘﺪ ‪  get‬‬

‫ﻣﺘﺪ ‪ get‬داده ﻫﺎ را از ﻃﺮﻳﻖ ﻣﺘﺪ ‪ get‬از ﺳﺮور درﺧﻮاﺳﺖ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺷﻜﻞ ﻛﻠﻲ اﺳﺘﻔﺎده از اﻳﻦ دﺳﺘﻮر ﺑﻪ‬
‫ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫ﭘﺎراﻣﺘﺮ ﻫﺎي ورودي اﻳﻦ ﻣﺘﻐﻴﻴﺮ ﻣﺎﻧﻦ ﻣﺘﺪ ‪ post‬ﻣﻲ ﺑﺎﺷﺪ و ﻣﻲ ﺗﻮان ﻣﺎﻧﻨﺪ ﻣﺘﺪ ‪ post‬از آن اﺳﺘﻔﺎده ﻧﻤﻮد‪.‬‬

‫ﺑﻪ ﻣﺜﺎل ‪ 17get‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪98 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  17get.html‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  17get.php‬‬

‫‪ ‬‬
‫اﻳﻦ ﻣﺜﺎل در ﺻﻔﺤﻪ ‪ 17get.html‬اﺑﺘﺪا ورودي را از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ و ﺑﻪ از ﻃﺮﻳﻖ ﻣﺘﺪ ‪ get‬ﺑﻪ‬
‫ﺻﻔﺤﻪ ‪ 17get.php‬ارﺳﺎل ﻣﻲ ﻛﻨﻴﻢ و در آن ﺻﻔﺤﻪ آن را درﻳﺎﻓﺖ و ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
 ‫‪99 | P a g e  ‬‬
‫‪ ‬‬

‫ﻓﺼﻞ ﭼﻬﺎردﻫﻢ‬
‫در اﻳﻦ ﻓﺼﻞ ﺑﺎ آﻣﻮﺧﺘﻪ ﻫﺎي ﻓﺼﻞ ﻫﺎي ﻗﺒﻞ اﻗﺪام ﺑﻪ ﻧﻮﺷﺘﻦ ﭼﻨﺪﻳﻦ ﻣﺜﺎل ﻧﻤﻮده اﻳﻢ وﻟﻲ اﻳﻦ ﺑﺪان ﻣﻌﻨﺎ‬
‫ﻧﻴﺴﺖ ﻛﻪ در اﻳﻦ ﻓﺼﻞ ﺑﻪ داﻧﺶ ﺷﻤﺎ ﭼﻴﺰي اﺿﺎﻓﻪ ﻧﺸﻮد و ﻣﻄﺎﻟﺐ ﺗﻜﺮار ﺑﺎﺷﺪ ‪.‬‬

‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬ﻣﺜﺎل زﻳﺮ ﻳﻚ ﻣﺜﺎل ﺳﺎده از ﺷﺊ ﮔﺮاﻳﻲ ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ ﻳﻚ ﻛﻼس ﺑﺴﻴﺎر ﺳﺎده از‬
‫ﻣﺘﺼﻞ ﺷﺪن از ﭘﺎﻳﮕﺎه داده ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ﻛﻪ ﺑﺎ اﻳﺠﺎد ﺳﺊ از آن ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﺘﺼﻞ ﺷﺪه و ﻣﻘﺎدﻳﺮ‬
‫را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  classdb.php‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
 ‫‪100 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  objectclassdb.php‬‬

‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل ﻳﻚ ﻛﻼس ﺑﺮاي ﻓﺮﺳﺘﺎدن ‪ email‬ﺳﺎﺧﺘﻪ ﺷﺪه اﺳﺖ ‪ .‬در اﻳﻦ ﻛﻼس‬
‫‪ 4‬ﻓﻴﻠﺪ ﺧﺼﻮﺻﻲ ﺗﻌﺮﻳﻒ ﺷﺪه اﺳﺖ ﺑﺮاي اﺳﺘﻔﺎده در ﺗﺎﺑﻊ )(‪ mail‬و ﻣﺘﺪ ﻫﺎﻳﻲ ﺑﺮاي ﻣﻘﺪار دﻫﻲ ﺑﻪ اﻳﻦ‬
‫ﻓﻴﻠﺪ ﻫﺎ ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ ‪ .‬ﻣﺘﺪ ﺳﺎزﻧﺪه اﻳﻦ ﻛﻼس ﻓﻴﻠﺪ ‪ sender‬را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻫﻤﺎن ﻧﺎم‬
‫ﻓﺮﺳﺘﻨﺪه ﻣﻲ ﺑﺎﺷﺪ و ﻓﻴﻠﺪ ‪ recipients‬را ﺑﻪ ﺻﻮرت آراﻳﻪ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﺪ ‪ .‬ﻣﺘﺪ ‪ addrecipient‬ﻣﻘﺎدﻳﺮ‬
‫ارﺳﺎل ﺷﺪه را در آراﻳﻪ ‪ recipients‬ﻗﺮا ﻣﻲ دﻫﺪ ‪ .‬ﻣﺘﺪ ‪ setsubject‬ﻣﻮﺿﻮع اﻳﻤﻴﻞ را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻛﻨﺪ‬
‫و ﻣﺘﺪ ‪ setbody‬ﻣﺘﻦ اﺻﻠﻲ و ﺑﺪﻧﻪ اﻳﻤﻴﻞ را ﻣﻘﺪار دﻫﻲ ﻣﻲ ﻛﻨﺪ ‪ .‬ﻣﺘﺪ ‪ sendemail‬ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ‬
‫‪ foreach‬ﺗﺎﺑﻊ )(‪ mail‬ﻫﺮ دﻓﻌﻪ ﻳﻚ اﻳﻤﻴﻞ ﺑﻪ ﻣﻘﺎدﻳﺮ آراﻳﻪ ‪ recipients‬ﻣﻲ ﻓﺮﺳﺘﺪ و ﻧﺘﻴﺠﻪ آن را در ﻣﺘﻐﻴﻴﺮ‬
‫‪ result‬ذﺧﻴﺮه ﻣﻲ ﻛﻨﺪ و در آﺧﺮ ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ اﻳﻤﻴﻞ ﺑﻪ درﺳﺘﻲ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ و ﭘﻴﻐﺎﻣﻲ‬
‫ﺑﺮاي ﻛﺎرﺑﺮ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫‪ ‬‬
 ‫‪101 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  classemail.php‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  objectclassemail.php‬‬

‫‪ ‬‬
‫ﺑﻪ ﻣﺜﺎل زﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪ .‬در اﻳﻦ ﻣﺜﺎل اﺑﺘﺪا ﻳﻚ ﻛﻼس ﺑﺮاي ﻣﺸﺨﺼﺎت ﺷﺨﺼﻲ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ و ﻳﻚ‬
‫ﻛﻼس ﻫﻢ ﺑﺮاي داﻧﺸﺠﻮ ﻃﺮاﺣﻲ ﺷﺪه اﺳﺖ ﻛﻪ از ﻛﻼس اوﻟﻲ ﻣﺸﺘﻖ ﺷﺪه اﺳﺖ و ﻳﻚ آﻳﺪي و وﺿﻌﻴﺖ‬
‫داﻧﺸﺠﻮ ﺑﻪ ﻛﻼس داﻧﺸﺠﻮ اﺿﺎﻓﻪ ﺷﺪه اﺳﺖ و ﻳﻚ ﻣﺘﺪ ﺑﺮاي درﻳﺎﻓﺖ و ﭼﺎپ ﻣﺸﺨﺼﺎت داﻧﺸﺠﻮ ﻧﻮﺷﺘﻪ‬

‫‪ ‬‬
 ‫‪102 | P a g e  ‬‬
‫‪ ‬‬
‫ﺷﺪه اﺳﺖ ﻛﻪ آﻳﺪي و وﺿﻌﻴﺖ داﻧﺸﺠﻮ و ﻧﺎم و ‪ ...‬را ﻣﻴﮕﻴﺮد و ﻣﺘﺪ ﻛﻼس واﻟﺪ را اﺟﺮا ﻣﻲ ﻛﻨﺪ و‪ ‬ﻣﺸﺨﺼﻪ‬
‫اﺿﺎﻓﻪ ﺷﺪه را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  classperson.php‬‬

‫‪ ‬‬

‫ﺳﺎﺧﺖ ﺗﺼﻮﻳﺮ اﻣﻨﻴﺘﻲ‬

‫ﻓﺮض ﻛﻨﻴﺪ ﻳﻚ ﻓﺮم در ﺳﺎﻳﺖ ﺧﻮد ﺑﺮاي ارﺗﺒﺎط ﺑﺎ ﻣﺎ ﻗﺮار داده اﻳﺪ اﮔﺮ ﺷﻤﺎ در اﻳﻦ ﻓﺮم ﺗﺼﻮﻳﺮ اﻣﻨﻴﺘﻲ‬
‫ﻗﺮار ﻧﺪﻫﻴﺪ ﺣﺎل ﻳﻚ ﻧﻔﺮ ﺑﺎ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ اي ﻛﻮﭼﻚ و ﺳﺎده در ﺑﺎزه ي زﻣﺎﻧﻲ ﺧﻴﻠﻲ ﻛﻢ و ﺑﻪ دﻓﻌﺎت ﻓﺮم‬
‫ﺷﻤﺎ را ﺑﺎ ﻳﻚ ﻣﻘﺪار ﺟﺪﻳﺪ ﺑﻪ ﺳﺮور ارﺳﺎل ﻣﻲ ﻛﻨﺪ و ﺑﻌﺪ از ﻣﺪت ﻛﻢ ﭘﺎﻳﮕﺎه داده ﺷﻤﺎ ﭘﺮ ﻣﻴﺸﻪ و ﻫﻨﮓ‬
‫ﻣﻴﻜﻨﻪ و ﭘﻴﺎم ﻫﺎي درﻳﺎﻓﺘﻲ اﻳﻤﻴﻠﺘﻮن ﻫﻢ ﭘﺮ ﻣﻴﺸﻪ ﺑﺮاي ﺟﻠﻮ ﮔﻴﺮي از اﻳﻦ ﻛﺎر از ﺗﺼﺎوﻳﺮ اﻣﻨﻴﺘﻲ اﺳﺘﻔﺎده‬
‫ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﻣﺜﺎل ‪ 19‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ در اﻳﻦ ﻣﺜﺎل ﻳﻚ ﻓﺎﻳﻞ ‪ index.php‬ﻛﻪ ﺻﻔﺤﻪ اﺻﻠﻲ اﺳﺖ وﺟﻮ دارد و‬
‫‪ ‬‬
‫‪103 | P a g e  ‬‬
‫‪ ‬‬
‫در اﻳﻦ ﺻﻔﺤﻪ اﺑﺘﺪا‪ session‬اﺟﺮا ﺷﺪه اﺳﺖ ‪ .‬در داﺧﻞ ‪ $text‬ﺣﺮوﻓﻲ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻣﻴﺨﻮاﻫﻴﻢ در‬
‫رﻣﺰ ﻋﺒﻮر ﺑﺎﺷﻨﺪ ‪ .‬ﻣﺘﻐﻴﻴﺮ ‪  cod‬را اﺑﺘﺪا ﺧﺎﻟﻲ ﻗﺮار ﻣﻲ دﻫﻴﻢ ﺑﻌﺪ ﺣﻠﻘﻪ اﻳﻲ را ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ‪ 6‬ﺑﺎر ﺗﻜﺮار‬
‫ﻣﻲ ﺷﻮد و در ﺧﻂ اول ﻳﻚ ﻋﺪد ﺗﺼﺎدﻓﻲ از ‪ 0‬ﺗﺎ ﺗﻌﺪاد ﺣﺮوف ‪ text‬ﺑﻪ ﻣﺎ ﻣﻲ دﻫﺪ و در ﺧﻂ ﺑﻌﺪ ﺑﻮﺳﻴﻠﻪ‬
‫‪ substr‬ﻣﻘﺪار ﺷﺮوع را اﻧﺘﺨﺎب زﻳﺮ رﺷﺘﻪ رو ﻫﻤﻮن ﻋﺪد رﻧﺪوم ﻗﺮار دادﻳﻢ و ﻃﻮﻟﺶ ﻫﻢ ﻳﻚ ﮔﺬاﺷﺘﻴﻢ و‬
‫درون ﻣﺘﻐﻴﻴﺮ ‪ cod‬رﻳﺨﺘﻴﻢ ﺑﺎ اﺟﺮا ﺣﻠﻘﻪ ‪ 6‬ﺣﺮف ﺗﺼﺎدﻓﻲ در ‪ cod‬ﻗﺮار ﻣﻲ ﮔﻴﺮد و ﺑﻌﺪ از ﺣﻠﻘﻪ ﻣﻘﺪار ‪cod‬‬
‫را ﺑﺮاي اﻣﻨﻴﺖ ﺑﻴﺸﺘﺮ در ‪ session‬ﻗﺮار ﻣﻲ دﻫﻴﻢ ‪ .‬وﺳﭙﺲ ﺑﺎ اﺳﺘﻔﺎده از ﺗﮓ ‪ img‬ﻳﻚ ﻟﻴﻨﻚ ﺑﻪ ﺗﺼﻮﻳﺮ‬
‫ﻣﻮن ﻛﻪ در ﺻﻔﺤﻪ ‪ securitycod.php‬ﻫﺴﺖ ﻗﺮار ﻣﻲ دﻫﻴﻢ ‪ .‬و ﻳﻚ ورودي ﺑﺮاي ﺗﺎﻳﭗ رﻣﺰ ﺑﺮاي ﻛﺎرﺑﺮ ﻗﺮار‬
‫ﻣﻲ دﻫﻴﻢ و ﺑﺎ اﺳﺘﻔﺎده از ‪ ajax‬اﻳﻦ ﻣﻘﺎدﻳﺮ ﺑﻪ ﺻﻔﺤﻪ ‪ securitycod.php‬ارﺳﺎل ﻣﻲ ﻛﻨﻴﻢ و ﻫﻤﺮاه آن ﻳﻚ‬
‫ﻣﺘﻐﻴﻴﺮ ‪ status‬ﺑﺮاي ﻛﻨﺘﺮل ﺑﺮﻧﺎﻣﻪ ﻣﻴﻔﺮﺳﺘﻴﻢ و ﺑﻪ آن ﻳﻚ ﻣﻘﺪار ﻣﻲ دﻫﻴﻢ ‪ .‬اﻣﺎ در ﺻﻔﺤﻪ ‪scuritycod.php‬‬
‫اﺑﺘﺪا ﺟﻠﺴﻪ را اﺟﺮا ﻣﻲ ﻛﻨﻴﻢ و ﭼﻮن ﻗﺮار اﺳﺖ ﺧﺮوﺟﻲ ﺗﺼﻮﻳﺮ ﺑﺎﺷﺪ ﻣﺎ ﻫﺪر ﺻﻔﺤﻪ رو ‪ jpg‬ﻗﺮار دادﻳﻢ و‬
‫ﻣﻘﺪار ‪ cod‬رااز ﺟﻠﺴﻪ درﻳﺎﻓﺖ و درون ﻣﺘﻐﻴﻴﺮ ‪ cod‬ﻣﻴﺮﻳﺰﻳﻢ ‪ .‬و ﻳﻜﺴﺮي ﻣﺘﻐﻴﻴﺮ ﺑﺮاي وﻳﮋﮔﻲ ﻫﺎي ﺗﺼﻮﻳﺮ‬
‫ﺗﻌﺮﻳﻒ ﻛﺮده اﻳﻢ ﻣﺜﻠﻪ اﻧﺪازه ﻓﻮﻧﺖ ‪ ,‬ﻃﻮل ﻋﻜﺲ ‪,‬ارﺗﻔﺎع ﻋﻜﺲ ‪ .‬ﺳﭙﺲ ﺑﺎ دﺳﺘﻮر ﺷﺮﻃﻲ ﺑﺮرﺳﻲ ﻛﺮده اﻳﻢ‬
‫ﻛﻪ آﻳﺎ ﻣﺘﻐﻴﻴﺮ ‪ status‬ﺧﺎﻟﻲ اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ﺧﺎﻟﻲ ﻧﺒﺎﺷﺪ ﺑﻪ اﻳﻦ ﻣﻌﻨﺎ اﺳﺖ ﻛﻪ ﻛﺎرﺑﺮ ﭼﻴﺰي ﺗﺎﻳﭗ اﺳﺖ و‬
‫ﺗﺼﻮﻳﺮ ﻗﺒﻼ اﻳﺠﺎد ﺷﺪه اﺳﺖ اﮔﺮ ﺧﺎﻟﻲ ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﭼﻴﺰي ﺗﺎﻳﭗ ﻛﺮده و ﺗﺼﻮﻳﺮ ﻗﺒﻼ ﺳﺎﺧﺘﻪ ﻧﺸﺪه اﺳﺖ و ﺑﺎﻳﺪ‬
‫ﺗﺼﻮﻳﺮ را ﺑﺴﺎزﻳﻢ ‪.‬اﺑﺘﺪا ﺑﺎ ﻣﺘﺪ ‪ imagecreate‬ﺑﺎ دادن ﻃﻮل و ﻋﺮض ﻳﻚ ﺗﺼﻮﻳﺮ ﻣﻲ ﺳﺎزد و اون را درون‬
‫ﻣﺘﻐﻴﻴﺮ ‪ image‬ﻗﺮار ﻣﻲ دﻫﻴﻢ و ﺳﭙﺲ ﺑﺎ ﻣﺘﺪ ‪ imagecolorallocate‬ﺗﺼﻮﻳﺮﻣﺎن را ﺑﺎ رﻧﮓ ﺧﺎﻛﺴﺘﺮي ﭘﺮ‬
‫ﻣﻴﻜﻨﻴﻢ ‪ .‬ﺳﭙﺲ رﻧﮓ ﻧﻮﺷﺘﻪ ﻫﻢ ﺑﺎ ﻫﻤﺎن ﻣﺘﺪ ﺑﻪ رﻧﮓ ﻣﺸﻜﻲ ﻣﻴﮕﻴﺮﻳﻢ و درون ﻣﺘﻐﻴﻴﺮ ﻗﺮار ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫ﺣﺎﻻ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ imagettftext‬ﻣﺘﻦ ﻛﺪ رو روي ﺻﻔﺤﻪ ﺗﺼﻮﻳﺮﻣﻮن ﺑﻨﻮﻳﺴﻴﻢ ‪:‬‬

‫‪ ‬ﭘﺎراﻣﺘﺮ اول ‪ :‬ﻣﺘﻐﻴﻴﺮ ﺗﺼﻮﻳﺮ رو درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﺪ ‪  .‬‬

‫‪ ‬ﭘﺎراﻣﺘﺮ دوم ‪ :‬ﺳﺎﻳﺰ ﻓﻮﻧﺖ رو درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﺳﻮم ‪ :‬زاوﻳﻪ ﭼﺮﺧﺶ ﻣﺘﻦ رو ﺗﻮ ﻋﻜﺴﻲ درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﭼﻬﺎرم ‪ :‬ﻓﺎﺻﻠﻪ ‪ x‬رو درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪ ,‬ﻓﺎﺻﻠﻪ ﻧﻮﺷﺘﻪ از ﺳﻤﺖ ﭼﭗ ﺗﺼﻮﻳﺮ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﭘﻨﺠﻢ ‪ :‬ﻓﺎﺻﻠﻪ ‪ y‬رو درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪ ,‬ﻓﺎﺻﻠﻪ ﻧﻮﺷﺘﻪ از ﺳﻤﺖ ﺑﺎﻻ ﺗﺼﻮﻳﺮ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﺷﺸﻢ ‪ :‬رﻧﮓ ﻣﺘﻦ رو ﻛﻪ ﺗﻮﻟﻴﺪ ﻛﺮده اﻳﻢ رو درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﻫﻔﺘﻢ ‪ :‬ﻳﻪ ﻓﻮﻧﺖ رو درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ﻛﻪ ﺑﺎ اون ﻣﺘﻦ رو ﻣﻴﻨﻮﻳﺴﻪ ﻛﻪ آدرس ﻓﻮﻧﺖ ﺑﺎﻳﺪ‬
‫ﻣﺴﺘﻘﻴﻢ ﺑﺎﺷﻪ ‪  .‬‬
‫‪ ‬ﭘﺎراﻣﺘﺮ ﻫﺸﺘﻢ ‪ :‬ﻣﺘﻨﻲ رو ﻛﻪ روي ﺗﺼﻮﻳﺮ ﭼﺎپ ﻣﻴﺸﻪ را درﻳﺎﻓﺖ ﻣﻴﻜﻨﻪ ‪  .‬‬
‫‪ ‬‬
 ‫‪104 | P a g e  ‬‬
‫‪ ‬‬
‫در آﺧﺮ ﻫﻢ ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ ‪ imagejpeg‬ﻛﻪ ﺗﺼﻮر رو ورودي ﻣﻴﮕﻴﺮه ﺗﺼﻮﻳﺮ رو ﺗﻮﻟﻴﺪ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  index.php‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬
 ‫‪105 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  securitycod.php‬‬

‫‪ ‬‬

‫ورود اﻃﻼﻋﺎت ﺑﺎ ‪  Ajax‬‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ اﺳﻢ ‪ insertp1.php‬ﺑﺮاي ورود اﻃﻼﻋﺎت اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬در اﻳﻦ ﺻﻔﺤﻪ اﺑﺘﺪا ﻳﻚ ﻓﺮم‬
‫ﺑﺎ دو ورودي و ﻳﻚ دﻛﻤﻪ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﺧﺎﺻﻴﺖ ‪ onclick‬دﻛﻤﻪ ﻳﻚ ﺗﺎﺑﻊ ﺟﺎوا را اﺟﺮا ﻣﻲ ﻛﻨﺪ ‪ .‬اﻳﻦ ﺗﺎﺑﻊ‬
‫ﺟﺎوا اﻃﻼﻋﺎت را ﺑﻪ ﺻﻮرت ‪ Ajax‬ﺑﺮاي ﺻﻔﺤﻪ ‪ insertp2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻣﺘﻐﻴﻴﺮ ﻫﺎي ‪ name‬و ‪family‬‬
‫را ﺑﺎ ﻣﻘﺎدﻳﺮ داﺧﻞ ﻓﺮم ﭘﺮ ﻣﻲ ﻛﻨﺪ و اﻃﻼﻋﺎت ﺑﺮﮔﺸﺘﻲ را درون ‪ div‬ﺑﺎ آﻳﺪي ‪ mes‬ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬اﻣﺎ در‬
‫ﺻﻔﺤﻪ ‪ insertp2.php‬اﺑﺘﺪا ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﻣﺘﻐﻴﻴﺮ ‪ name‬و ‪ family‬ﻫﺮ دو داراي ﻣﻘﺪار ﻣﻲ ﺑﺎﺷﻨﺪ ﻳﺎ‬
‫ﺧﻴﺮ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ empty‬اﻳﻦ ﻛﺎر را اﻧﺠﺎم ﻣﻲ دﻫﻴﻢ ﻛﻪ اﮔﺮ اﻳﻦ دو ﻣﺘﻐﻴﻴﺮ ﻣﻘﺪارﺷﺎن ﺧﺎﻟﻲ ﺑﺎﺷﺪ‬
‫ﻣﻘﺪار ‪ true‬ر ﺑﺮ ﻣﻴﮕﺮداﻧﺪ و اﮔﺮ ﻣﻘﺪار دﻫﻲ ﺷﺪه ﺑﺎﺷﻨﺪ ﻣﻘﺪار ‪ false‬را ﺑﺮ ﻣﻴﮕﺮداﻧﺪ ‪ .‬اﮔﺮ ﻣﻘﺪاري ﻧﺪاﺷﺘﻪ‬
‫ﺑﺎﺷﻨﺪ ﭘﻴﻐﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ اﻳﻨﻜﻪ اﻃﻼﻋﺎت را وارد ﻛﻨﻴﺪ ﭼﺎپ ﻣﻲ ﺷﻮد و اﮔﺮ ﻫﺮ دو ﻣﺘﻐﻴﻴﺮ ﭘﺮ ﺑﺎﺷﻨﺪ دو ﻣﺘﻐﻴﻴﺮ‬
‫را اﺑﺘﺪا ﻓﺎﺻﻠﻪ ﻫﺎي ﻛﻨﺎري آن ﻫﺎ را ﺣﺬف ﻛﺮده و ﻫﻤﻪ ﺣﺮوف آن ﻫﺎ را ﺑﻪ ﺣﺮوف ﻛﻮﭼﻚ ﺗﺒﺪﻳﻞ ﻣﻲ ﻛﻨﻴﻢ و‬
‫ﺳﭙﺲ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ mysqli‬ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﻮرد ﻧﻈﺮ ﻣﺘﺼﻞ ﻣﻲ ﺷﻮﻳﻢ و در ﺧﻂ ﺑﻌﺪ ﭼﻚ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ‬
‫آﻳﺎ اﻳﻦ ارﺗﺒﺎط ﺑﻪ درﺳﺘﻲ ﺑﺮﻗﺮار ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ اﻳﻦ ارﺗﺒﺎط ﺧﻄﺎ داده ﺑﺎﺷﺪ ﭘﻴﻐﺎم ﺧﻄﺎﻳﻲ ﺑﺮاي ﻛﺎرﺑﺮ‬
‫ﻧﺸﺎن ﻣﻲ دﻫﻴﻢ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻳﻚ ﻛﻮﺋﺮي ﺑﺮاي ﺑﺮرﺳﻲ اﻳﻨﻜﻪ ﻛﻪ ﻛﺎرﺑﺮ اﻃﻼﻋﺎت ﺗﻜﺮاري وارد ﻛﺮده‬
‫ﺑﺎﺷﺪ ﻳﺎ ﺧﻴﺮ ﻣﻲ ﻧﻮﻳﺴﻴﻢ و ﺑﺎ دﺳﺘﻮر ﺷﺮﻃﻲ ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ در اﻳﻦ ﻛﻮﺋﺮي رﻛﻮردي ﭘﻴﺪا ﺷﺪه اﺳﺖ‬
‫‪ ‬‬
 ‫‪106 | P a g e  ‬‬
‫‪ ‬‬
‫ﻳﺎ ﺧﻴﺮ اﮔﺮ ﭘﻴﺪا ﺷﺪه ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﻛﺎرﺑﺮ ﻛﻠﻤﺎت ﺗﻜﺮاري وارد ﻛﺮده اﺳﺖ و ﭘﻴﻐﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ ﺗﻜﺮاري ﺑﻮدن‬
‫ﺑﺮاي ﻛﺎرﺑﺮ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﻴﻢ در ﻏﻴﺮ اﻳﻦ ﺻﻮرت ﻛﻮﺋﺮي ﺑﺮاي درج اﻳﻦ ﻧﺎم و ﻓﺎﻣﻴﻠﻲ ﻣﻲ ﻧﻮﻳﺴﻴﻢ و در آﺧﺮ‬
‫ارﺗﺒﺎط ﺑﺎ ﭘﺎﻳﮕﺎه داده را ﻗﻄﻊ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬و در ﺧﻂ ﺑﻌﺪ ﻣﻘﺪار ‪ table‬را ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ اﮔﺮ اﻳﻦ ﻣﻘﺪار ‪1‬‬
‫ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﺛﺒﺖ ﺷﺪه اﺳﺖ و ﭘﻴﻐﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ درج ﻣﻮﻓﻘﻴﺖ اﻃﻼﻋﺎت ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ و در ﻏﻴﺮ‬
‫اﻳﻦ ﺻﻮرت ﻳﻌﻨﻲ اﻃﻼﻋﺎت ﺑﺎ ﻣﻮﻓﻘﻴﺖ ﺛﺒﺖ ﻧﺸﺪه اﺳﺖ و ﭘﻴﻐﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ درج ﻧﺎ ﻣﻮﻓﻘﻴﺖ اﻃﻼﻋﺎت ﻧﻤﺎﻳﺶ‬
‫ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  insertp1.php‬‬

‫‪ ‬‬
 ‫‪107 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  insertp2.php‬‬

‫ﺧﻮاﻧﺪن اﻃﻼﻋﺎت ﺑﺎ ‪  Ajax‬‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ اﺳﻢ ‪ combop1.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ داراي ﻳﻚ ‪ combo box‬اﺳﺖ ﻛﻪ ﻛﺎرﺑﺮ ﻣﻲ‬

‫ﺗﻮاﻧﺪ دو اﻧﺘﺨﺎب داﺷﺘﻪ ﺑﺎﺷﺪ ﻛﻪ ﻳﻜﻲ ‪ DESC‬اﺳﺖ ﻛﻪ اﻃﻼﻋﺎت را ﺑﻪ ﺻﻮرت ﻧﺰوﻟﻲ ﭼﺎپ ﻣﻲ ﻛﻨﺪ و دﻳﮕﺮ‬
‫‪ ASC‬اﺳﺖ ﻛﻪ اﻃﻼﻋﺎت را ﺑﻪ ﺻﻮرت ﺻﻌﻮدي ﭼﺎپ ﻣﻲ ﻛﻨﺪ و اﻳﻦ اﻃﻼﻋﺎت ﺑﻪ ﺻﻮرت ‪ Ajax‬از ﻳﻚ ﺻﻔﺤﻪ‬
‫دﻳﮕﺮ ﻣﻲ ﺧﻮاﻧﺪ و درون ﻳﻚ ﻧﺎﺣﻴﻪ ﻣﺘﻦ )‪ (textarea‬ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬در اﺑﺘﺪا اﻳﻦ ﻓﺎﻳﻞ ﻳﻚ ﺗﺎﺑﻊ ﺟﺎوا ﻧﻮﺷﺘﻪ‬
‫ﺷﺪه اﺳﺖ ﻛﻪ ﻣﺘﻐﻴﻴﺮ ‪ status‬را ﺑﺎ ﻣﻘﺪار ﻛﻤﺒﻮﺑﺎﻛﺲ ﭘﺮ ﻣﻲ ﻛﻨﺪ و ﺑﻪ ﻓﺎﻳﻞ ‪ combop2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ‬

‫‪ ‬‬
 ‫‪108 | P a g e  ‬‬
‫‪ ‬‬
‫و ﻧﺘﻴﺠﻪ آن را در ﻧﺎﺣﻴﻪ ﻣﺘﻦ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ ‪ .‬در ﻓﺎﻳﻞ ‪ combop2.php‬اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﺷﻮد ﻛﻪ آﻳﺎ‬
‫ﻣﺘﻐﻴﺮ ‪ status‬از ﻃﺮﻳﻖ ﻣﺘﺪ ‪ post‬ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﻧﺸﺪه ﺑﺎﺷﺪ دوﺑﺎره ﺻﻔﺤﻪ ﻣﺮورﮔﺮ‬
‫را ﺑﻪ ﺻﻔﺤﻪ اﺑﺘﺪا ﻣﻴﻔﺮﺳﺘﻴﻢ وﻟﻲ اﮔﺮ ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ اﺑﺘﺪا آن را درون ﻣﺘﻐﻴﻴﺮي ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ و ﺑﺎ‬
‫اﺳﺘﻔﺎده از ‪ mysqli‬ﺑﻪ ﭘﺎﻳﮕﺎه داده ﻣﺪ ﻧﻈﺮ ﻣﺘﺼﻞ ﻣﻲ ﺷﻮﻳﻢ و ﻛﻮﺋﺮي ﺑﺮاي درﻳﺎﻓﺖ داده ﻫﺎ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ‬
‫ﻧﺤﻮه ﻣﺮﺗﺐ ﺳﺎزي آن را از ﻛﻤﺒﻮﺑﺎﻛﺲ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ و ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ﻣﻘﺪار ﺳﻦ را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ‬
‫و در آﺧﺮ ارﺗﺒﺎط را ﻗﻄﻊ ﻣﻲ ﻛﻴﻨﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  combop1.php‬‬

‫‪ ‬‬
 ‫‪109 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  combop2.php‬‬

‫‪ ‬‬

‫ﻣﺎﺷﻴﻦ ﺣﺴﺎب ﺳﺎده ‪ ‬‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﻧﺎم ‪ cal.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ دو ﺗﺎ ورودي از ﻛﺎرﺑﺮ ﻣﻲ ﮔﻴﺮد و ﭼﻬﺎر ﺗﺎ دﻛﻤﻪ دارد ﻛﻪ‬
‫ﻛﻪ ﺑﺮاي ﭼﻬﺎر ﻋﻤﻞ اﺻﻠﻲ ﻣﻲ ﺑﺎﺷﻨﺪ ﻛﻪ ﺑﺎ زدن ﻫﺮ ﻛﺪام از دﻛﻤﻪ ﻫﺎ ﻣﻘﺪار آن ﻫﺎ ﻛﻪ ﺑﺎ ﻋﻤﻠﮕﺮ ﻫﺎي ﺧﻮدﺷﺎن‬
‫ﭘﺮ ﺷﺪه اﺳﺖ را ﺑﻪ ﺗﺎﺑﻊ ﺟﺎوا ﻣﻲ ﻓﺮﺳﺘﺪ اﻳﻦ ﺗﺎﺑﻊ ﺳﻪ ﭘﺎراﻣﺘﺮ را ﺑﻪ ﺻﻮرت ‪ Ajax‬ﺑﻪ ﺻﻔﺤﻪ ‪cal2.php‬‬
‫ارﺳﺎل ﻣﻲ ﻛﻨﺪ و ﻧﺘﻴﺠﻪ آن را در ﺑﺮﭼﺴﺐ ﻧﻤﺎﻳﺶ ﻣﻲ دﻫﺪ ‪ .‬اﻳﻦ ﺳﻪ ﭘﺎراﻣﺘﺮي ﻛﻪ ﺑﻪ اﻳﻦ ﺗﺎﻳﻊ ارﺳﺎل ﻣﻲ‬
‫ﻛﻨﺪ دو ورودي ﻛﺎرﺑﺮ ﻣﻲ ﺑﺎﺷﺪ و ﻳﻜﻲ ﻧﻮع ﻋﻤﻠﻴﺎﺗﻲ اﺳﺖ ﻛﻪ ﻛﺎرﺑﺮ روي دﻛﻤﻪ ﻣﻮرده ﻧﻈﺮ ﻛﻠﻴﻚ ﻛﺮده اﺳﺖ‬
‫‪ .‬اﻣﺎ در ﺻﻔﺤﻪ ‪ cal2.php‬اﺑﺘﺪا ﭼﻚ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ داده ﻫﺎ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﻪ‬
‫ارﺳﺎل ﺷﺪه اﺳﺖ آن ﻫﺎ را در ﻣﺘﻐﻴﻴﺮ ي ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر ﺷﺮﻃﻲ ‪ switch‬ﻧﻮع ﻋﻤﻠﻴﺎت‬
‫را ﻣﻴﮕﻴﺮﻳﻢ و ﺑﺮ اﺳﺎس آن ﻧﻮع ﻋﻤﻠﻴﺎت را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﻴﻢ و در ﻧﻬﺎﻳﺖ ﺧﺮوﺟﻲ را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
 110 | P a g e  
 
  cal.php ‫ﻓﺎﻳﻞ‬

 
 ‫‪111 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  cal2.php‬‬

‫‪ ‬‬

‫ﺟﺪول ﺿﺮب‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار ﻣﺘﺪاﺧﻞ ﻣﻴﺨﻮاﻫﻴﻢ ﻳﻚ ﺟﺪول ﺿﺮب ‪ 10*10‬اﻳﺠﺎد ﻛﻨﻴﻢ ‪ .‬اﺑﺘﺪا ﻳﻚ ﺣﻠﻘﻪ ﻣﻲ‬
‫ﻧﻮﻳﺴﻴﻢ ﻛﻪ از ‪ 1‬ﺗﺎ ‪ 10‬ﺷﻤﺎرﻧﺪه دارد و درون آن ﻫﻢ ﻳﻚ ﺣﻠﻘﻪ دﻳﮕﺮ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ‪ 1‬ﺗﺎ ‪ 10‬ﺷﻤﺎرﻧﺪه دارد‬
‫و ﺳﭙﺲ ﺣﺎﺻﻞ ﺿﺮب ﺷﻤﺎرﻧﺪه ﻫﺎي اﻳﻦ دو ﺣﻠﻘﻪ را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﺣﻠﻘﻪ ﻫﺎي ﻣﺘﺪاﺧﻞ ﺑﻪ اﻳﻦ ﺻﻮرت‬
‫ﻋﻤﻞ ﻣﻲ ﻛﻨﻨﺪ ﻛﻪ ﺑﺎ ﻳﻚ ﺣﺮﻛﺖ ﺣﻠﻘﻪ ﺑﺎﻻﻳﻲ ﺣﻠﻘﻪ دروﻧﻲ از اﺑﺘﺪا ﺗﺎ اﻧﺘﻬﺎ اﻧﺠﺎم ﻣﻲ ﺷﻮد ‪ .‬ﺑﻪ ﻣﺜﺎل ‪zarb.php‬‬
‫دﻗﺖ ﻛﻨﻴﺪ‪.‬‬

‫‪ ‬‬
‫‪112 | P a g e  ‬‬
‫‪ ‬‬

‫ﺧﺮوﺟﻲ‬

‫ﺣﺎل اﻳﻦ ﻣﺜﺎل را ﺑﻪ ﺻﻮرت ‪ Ajax‬ﻣﻲ ﻧﻮﻳﺴﻴﻢ و ﻣﻘﺪار ﺟﺪول ﺿﺮب را از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬در اﻳﻨﺠﺎ‬
‫اﺑﺘﺪا ﻓﺎﻳﻞ ‪ zarbajax.php‬را اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ در اﻳﻦ ﻓﺎﻳﻞ دو ورودي از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ و اﻳﻦ‬
‫دو ورودي را ﺑﻪ ﺻﻮرت ‪ Ajax‬ﺑﻪ ﺻﻔﺤﻪ ‪ zarbajax2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﻴﻢ ‪ .‬در اﻳﻦ ﻓﺎﻳﻞ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ‬
‫ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ورودي ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ ‪ .‬داده ﻫﺎ را درون ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ و‬
‫ﻣﻘﺪار ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار را ﺗﺎ ﻣﻘﺪار ورودي درﻳﺎﻓﺘﻲ ﻛﺎرﺑﺮ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ‪.‬‬
‫‪ ‬‬
 ‫‪113 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  zarbajax.php‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  zarbajax2.php‬‬

‫‪ ‬‬

‫ﻣﻌﻜﻮس ﻛﺮدن رﺷﺘﻪ‬

‫اﺑﺘﺪا ﻳﻚ ﺻﻔﺤﻪ ﺑﺮاي درﻳﺎﻓﺖ ﻛﻠﻤﻪ از ﻛﺎرﺑﺮ ﺑﻪ ﻧﺎم ‪ reversp1.php‬اﻳﺠﺎد ﻣﻴﻜﻨﻴﻢ و ﻳﻚ ﻓﺮم ﻃﺮاﺣﻲ ﻣﻴﻜﻨﻴﻢ‬
‫ﻛﻪ ﻳﻚ ورودي و ﻳﻚ دﻛﻤﻪ دارد و داده ﻛﺎرﺑﺮ را ﺑﻪ ﺻﻔﺤﻪ ‪ reversp2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪ .‬اﻣﺎ در ﺻﻔﺤﻪ‬
‫‪ reversp2.php‬اﺑﺘﺪا داده را درﻳﺎﻓﺖ ﻣﻴﻜﻨﻴﻢ و ﻳﻚ ﻣﺘﻐﻴﻴﺮ ﺑﻪ ﻧﺎم ‪ r‬از ﻧﻮع آراﻳﻪ ﺗﻌﻴﻴﻦ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬و ﻳﻚ‬
‫‪ ‬‬
 ‫‪114 | P a g e  ‬‬
‫‪ ‬‬
‫ﺗﺎﺑﻊ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻛﻠﻤﻪ را ﻣﻌﻜﻮس ﻛﻨﺪ ‪ .‬اﻳﻦ ﺗﺎﺑﻊ اﺑﺘﺪا ﻳﻚ ورودي ﻣﻲ ﮔﻴﺮد و ﺗﻌﺪاد ﺣﺮوف ورودي را‬
‫درون ﻳﻚ ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﻳﻚ ﺣﻠﻘﻪ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ از ﺗﻌﺪاد ﺣﺮوف ﺗﺎ ‪ 0‬ﺷﻤﺎرﻧﺪه دارد و ﻫﺮ‬
‫دﻓﻌﻪ ﻳﻜﻲ از آن ﻛﻢ ﻣﻲ ﺷﻮد ‪ .‬درون اﻳﻦ ﺣﻠﻘﻪ ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ array_push‬ﻣﻘﺪاري را ﺑﻪ آﺧﺮ آراﻳﻪ‬
‫‪ r‬ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ ﻣﺎ ورودي اول اﻳﻦ ﺗﺎﺑﻊ را ﻧﺎم آراﻳﻪ ﻣﻲ ﮔﺬارﻳﻢ و ورودي دوم را ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ‬
‫‪ substr‬رﺷﺘﻪ را ﻣﻴﮕﻴﺮﻳﻢ و از ﺣﺮف ﺷﻤﺎره ‪ i‬ﺷﺮوع ﻣﻴﻜﻨﻴﻢ و ﻳﻜﻲ از آن را ﺑﺮ ﻣﻲ دارﻳﻢ ﺑﺪﻳﻦ ﺗﺮﺗﻴﺐ ﺑﺎ‬
‫اﺟﺮ اﺷﺪن ﺣﻠﻘﻪ از آﺧﺮ رﺷﺘﻪ درﻳﺎﻓﺘﻲ ﺷﺮوع ﻣﻲ ﻛﻨﺪ و ﺣﺮوف آن را دوﻧﻪ دوﻧﻪ درون آراﻳﻪ ﭼﺎپ ﻣﻲ ﻛﻨﺪ‬
‫‪ .‬در آﺧﺮ ﻫﻢ آرﻳﻪ را ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ‪ foreach‬ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  reversp1.php‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  reversp2.php‬‬

‫‪ ‬‬
‫ﺣﺎل اﻳﻦ ﺑﺮﻧﺎﻣﻪ را ﺑﺎ اﺳﺘﻔﺎده از ‪ Ajax‬ﻣﻲ ﻧﻮﻳﺴﻴﻢ ‪ .‬اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ اﺳﻢ ‪ reversajaxp1.php‬اﻳﺠﺎد‬
‫ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﻣﺤﺘﻮﻳﺎت آن ﻣﺎﻧﻨﺪ ﻓﺎﻳﻞ ‪ reversp1.php‬ﻣﻲ ﺑﺎﺷﺪ ﺑﺎ اﻳﻦ ﺗﻔﺎوت ﻛﻪ از ﺗﺎﺑﻊ ‪ post‬ﺑﺮاي ‪Ajax‬‬
‫اﺳﺘﻔﺎده ﺷﺪه اﺳﺖ و ورودي ﻛﺎرﺑﺮ را ﺑﻪ ﺻﻔﺤﻪ ‪ reversajaxp2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪ .‬ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ‬
‫‪ reverajaxp2.php‬دﻗﻴﻘﺎ ﻣﺎﻧﻨﺪ ﻣﺤﺘﻮﻳﺎت ﻓﺎﻳﻞ ‪ reversp2.php‬ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪115 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  reversajaxp1.php‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  reversajaxp2.php‬‬

‫‪ ‬‬

‫ﭼﻨﺪ ﻣﺜﺎل از ﺗﻮاﺑﻊ‬

‫ﺑﺮﻧﺎﻣﻪ ‪ ave.php‬ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ و ﺣﻠﻘﻪ ﺗﻜﺮار ﻣﻴﺎﻧﮕﻴﻦ اﻋﺪاد ﻓﺮد ﺑﻴﻦ ‪ 1‬ﺗﺎ ‪ 500‬را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪116 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪ave.php‬‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ﻫﺎي ﺗﻜﺮار ﻣﻲ ﺧﻮاﻫﻴﻢ دو ﺷﻜﻞ زﻳﺮ را ﻃﺮاﺣﻲ ﻛﻨﻴﻢ ‪ .‬ﺑﻪ ﺗﺼﻮﻳﺮ اﻳﻦ دو ﺷﻜﻞ ﻧﮕﺎه‬
‫ﻛﻨﻴﺪ‪.‬‬

‫‪ ‬‬
117 | P a g e  
 

 
‫‪118 | P a g e  ‬‬
‫‪ ‬‬
‫ﺑﻪ ﺑﺮﻧﺎﻣﻪ ‪ setare.php‬ﺗﻮﺟﻪ ﻛﻨﻴﺪ ‪.‬‬

‫اﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺎ اﺳﺘﻔﺎده از دو ﺣﻘﻠﻪ ﻣﺘﺪاﺧﻞ اﻳﻦ اﺷﻜﺎل را ﻃﺮاﺣﻲ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫رﻣﺰﻧﮕﺎري اﻃﻼﻋﺎت‬

‫ﺑﺮاي ذﺧﻴﺮه رﻣﺰ ﻛﺎرﺑﺮان در ﭘﺎﻳﮕﺎه داده ﺑﻬﺘﺮ اﺳﺖ داده ﻫﺎ ﺑﻪ ﺻﻮرت رﻣﺰﻧﮕﺎري در ﭘﺎﻳﮕﺎه داده ذﺧﻴﺮه‬
‫ﺷﻮد اﮔﺮ رﻣﺰ ﻋﺒﻮر ﻛﺎرﺑﺮان ﺑﻪ ﺻﻮرت رﻣﺰﻧﮕﺎري ﺷﺪه در دﻳﺘﺎﺑﻴﺲ ذﺧﻴﺮه ﻧﺸﻮد وﻗﺘﻲ ﻫﻜﺮي ﺑﻪ دﻳﺘﺎﺑﻴﺲ‬
‫ﺳﺎﻳﺖ ﺷﻤﺎ دﺳﺘﺮﺳﻲ ﭘﻴﺪا ﻛﻨﺪ ﺗﻤﺎﻣﻲ رﻣﺰ ﻋﺒﻮر ﻫﺎ را در اﺧﺘﻴﺎر دارد ﭘﺲ ﺑﻬﺘﺮ اﺳﺖ داده ﻫﺎ را ﺑﻪ ﺻﻮرت‬
‫رﻣﺰﻧﮕﺎري ﺷﺪه در ﺑﻴﺎﻳﺪ ‪ .‬ﺑﺮاي اﻳﻨﻜﺎر ‪ PHP‬ﺗﻮاﺑﻌﻲ ﻣﺨﺘﻠﻔﻲ دارد ‪ MD5 .‬ﻳﻜﻲ از ﻣﺤﺒﻮب ﺗﺮﻳﻦ اﻟﮕﻮرﻳﺘﻢ‬
‫ﻫﺎي رﻣﺰﻧﮕﺎري ﻣﻮرد اﺳﺘﻔﺎده ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن اﺳﺖ ‪ .‬ﺗﺎﺑﻊ ‪ md5‬روش ﻛﺎﻣﻼ ﻣﻄﻤﺌﻨﻲ ﺑﺮاي رﻣﺰﻧﮕﺎري‬
‫ﻧﻴﺴﺖ ‪ .‬اﻛﺜﺮ ﻛﺎرﺑﺮان ﺗﻤﺎﻳﻞ دارﻧﺪ از رﻣﺰ ﻫﺎي ﻋﺒﻮر ‪ 5‬ﻳﺎ ‪ 6‬ﻛﺎراﻛﺘﺮي اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻨﺪ ‪ ,‬رﻣﺰ ﻫﺎي ﻋﺒﻮر ﺑﻪ‬
‫اﻳﻦ ﺷﻜﻞ ﻛﻪ از ﭘﻴﭽﻴﺪﮔﻲ ﻣﻨﺎﺳﺒﻲ ﺑﺮ ﺧﻮردار ﻧﻴﺴﺘﻨﺪ و ﺗﻮﺳﻂ ﻳﻚ ﺣﻤﻠﻪ ﺳﺎده آﺳﻴﺐ ﭘﺬﻳﺮ ﺧﻮاﻫﻨﺪ ﺑﻮد ‪.‬‬
‫ﺷﻜﻞ ﺻﺤﻴﺢ اﺳﺘﻔﺎده از ‪ md5‬ﺑﻪ ﺻﻮرت زﻳﺮ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫ﺑﺮاي اﻳﻨﻜﻪ اﻳﻦ ﻣﺸﻜﻞ ﺣﻞ ﺷﻮد ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﺎن از دو روش اﺳﺘﻔﺎده ﻣﻲ ﻛﻨﻨﺪ ‪ ,‬روش اول اﺿﺎﻓﻪ ﻛﺮدن‬
‫ﻳﻚ ﻋﺒﺎرت ﻧﺎ ﻣﻔﻬﻮم ﺑﻪ ﭘﺴﻮرد ﻫﺎ ﻗﺒﻞ از رﻣﺰﻧﮕﺎري آن ﻫﺎ اﺳﺖ ‪ .‬ﺑﻪ ﺗﺼﻮﻳﺮ زﻳﺮ ﻧﮕﺎه ﻛﻨﻴﺪ ‪.‬‬
‫‪ ‬‬
 ‫‪119 | P a g e  ‬‬
‫‪ ‬‬

‫روش دوم اﺳﺘﻔﺎده از اﻟﮕﻮرﻳﺘﻢ ﻫﺎي رﻣﺰﻧﮕﺎري ﻃﻮﻻﻧﻲ ﺗﺮ )وﻟﻲ ﻛﻨﺪﺗﺮ( ﻣﺎﻧﻨﺪ ‪ sha2 , sha1‬و ‪ ...‬اﺳﺖ ‪.‬‬

‫ﺑﻪ ﺗﺼﻮﻳﺮ زﻳﺮ ﻧﮕﺎه ﻛﻨﻴﺪ ‪.‬‬

‫درج اﻃﻼﻋﺎت در ﻓﺎﻳﻞ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ fileajax.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﻛﻪ ﻳﻚ ورودي از ﻛﺎرﺑﺮ ﻣﻴﮕﻴﺮد و اﻳﻦ ورودي را ﺑﻪ‬
‫ﺗﺎﺑﻌﻲ ﻣﻲ دﻫﺪ ﻛﻪ اﻳﻦ ﺗﺎﺑﻊ اﻳﻦ ورودي را ﺑﻪ ﺻﻮرت ‪ Ajax‬ﺑﻪ ﺻﻔﺤﻪ ‪ fileajax2.php‬ارﺳﺎل ﻣﻲ ﻛﻨﺪ ‪.‬اﻣﺎ در‬
‫ﻓﺎﻳﻞ ‪ fileajax2.php‬اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻴﻜﻴﻨﻢ ﻛﻪ آﻳﺎ ورودي ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل‬
‫ﺷﺪه ﺑﺎﺷﺪ ﻳﻚ ﻓﺎﻳﻞ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﺑﻪ اﺳﻢ ‪ user.txt‬و ﻣﻘﺪار ورودي را در اﻳﻦ ﻓﺎﻳﻞ ﻣﻲ ﻧﻮﻳﺴﻴﻢ و ﻣﻘﺪار‬
‫ﺑﺎزﮔﺸﺘﻲ را ﻛﻪ ﺗﻌﺪاد ﺣﺮوف ﻧﻮﺷﺘﻪ ﺷﺪه اﺳﺖ را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  fileajax.php‬‬

‫‪ ‬‬
 ‫‪120 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  fileajax2.php‬‬

‫‪ ‬‬

‫درج روز ﻫﻔﺘﻪ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم‪  day1.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ روز ‪ ‬ﻫﻔﺘﻪ را از ﻛﺎرﺑﺮ ﻣﻲ ﮔﻴﺮد و ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ‬
‫‪ Ajax‬آن را ﺑﻪ ﺻﻔﺤﻪ ‪ day2.php‬ﻣﻲ دﻫﺪ و آن ﺻﻔﺤﻪ ورودي را ﺑﻪ دﺳﺘﻮر ‪ switch‬ﻣﻲ دﻫﺪ و ﺑﺮ اﺳﺎس‬
‫ﺷﻤﺎره وارد ﺷﺪه ﺗﻮﺳﻂ ﻛﺎرﺑﺮ ﻧﺎم ﻫﻔﺘﻪ را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  day1.php‬‬

‫‪ ‬‬
‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬
 ‫‪121 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  day2.php‬‬

‫‪ ‬‬

‫ﻣﺤﺎﺳﺒﻪ ي ﺳﻦ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ agetest1.php‬اﻳﺠﺎد ﻣﻴﻜﻨﻴﻢ ﻛﻪ ﺳﻦ ﻛﺎرﺑﺮ را از ورودي ﺑﮕﻴﺮد و آن را درون ﻣﺘﻐﻴﻴﺮ‬
‫‪ age‬ﻗﺮار دﻫﻴﺪ و ﺑﺎ ﺗﺎﺑﻊ ‪ post‬آن را ب ﺻﻮرت اﻳﺠﻜﺲ ﺑﻪ ﺻﻔﺤﻪ ‪ agetest2.php‬ﺑﻔﺮﺳﺘﺪ ‪.‬اﻣﺎ در آن‬
‫ﺻﻔﺤﻪ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻴﻜﻨﻴﻢ ﻛﻪ آﻳﺎ ﭘﺎراﻣﺘﺮ ‪ age‬ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﺷﺪه‬
‫ﺑﺎﺷﺪ اﺑﺘﺪا ﻣﺘﻐﻴﻴﺮ ‪ day‬ﺑﺮاي ﺗﻌﺪاد روز و ﻣﺘﻐﻴﻴﺮ ‪ week‬ﺑﺮاي ﺗﻌﺪاد ﻫﻔﺘﻪ و ﻣﺘﻐﻴﻴﺮ ‪ month‬ﺑﺮاي ﺗﻌﺪاد‬
‫ﻣﺎه و ﻣﺘﻐﻴﻴﺮ ‪ h‬ﺑﺮاي ﺗﻌﺪاد ﺳﺎﻋﺖ و ﻣﺘﻐﻴﻴﺮ ‪ m‬ﺑﺮاي ﺗﻌﺪاد دﻗﻴﻘﻪ و ﻣﺘﻐﻴﻴﺮ ‪ s‬ﺑﺮاي ﺗﻌﺪاد ﺛﺎﻧﻴﻪ را در ﻧﻈﺮ‬
‫ﻣﻴﮕﻴﺮﻳﻢ ‪ .‬ﺳﭙﺲ ﺗﺎﺑﻌﻲ ﺑﺮاي ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻣﻘﺎدﻳﺮ ﺑﺎﻻ را ﻣﺤﺎﺳﺒﻪ ﻛﻨﺪ ‪.‬‬

‫‪ ‬‬
 ‫‪122 | P a g e  ‬‬
‫‪ ‬‬
‫و در آﺧﺮ ﭘﺎراﻣﺘﺮ ورودي اﻳﻦ ﺻﻔﺤﻪ را ﺑﻪ ﺗﺎﺑﻊ ﻣﻲ دﻫﻴﻢ ‪ .‬ﻣﻘﺎدﻳﺮ را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  agetest1.php‬‬

‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  agetest2.php‬‬

‫‪ ‬‬
 ‫‪123 | P a g e  ‬‬
‫‪ ‬‬
‫ﺟﺴﺘﺠﻮ ﺧﻄﻲ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ searcharray.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ در اﻳﻦ ﻓﺎﻳﻞ ﻳﻚ آراﻳﻪ ﻣﻮﺟﻮد ﻣﻲ ﺑﺎﺷﺪ ﻛﻪ‬
‫داراي ﻣﻘﺎدﻳﺮي ﻣﻲ ﺑﺎﺷﺪ اﻳﻦ ﻣﻘﺎدﻳﺮ ﻣﻲ ﺗﻮاﻧﻨﺪ از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﺷﺪه ﺑﺎﺷﻨﺪ ﻳﺎ از ﭘﺎﻳﮕﺎه داده درﻳﺎﻓﺖ‬
‫ﺷﺪه ﺑﺎﺷﺪ ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﺗﻜﻨﻴﻚ ﺟﺴﺘﺠﻮ ﺧﻄﻲ ﻣﻲ ﺧﻮاﻫﻢ اﺳﻤﻲ را درون اﻳﻦ آراﻳﻪ ﺟﺴﺘﺠﻮ ﻛﻨﻴﻢ ‪ .‬اﺑﺘﺪا‬
‫ﻳﻚ ﺗﺎﺑﻊ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻳﻚ ورودي ﻣﻴﮕﻴﺮد و داﺧﻞ اﻳﻦ ﺗﺎﺑﻊ ﻣﺘﻐﻴﻴﺮ ‪ s‬را ﺑﺮاي ﺑﺮرﺳﻲ ﻗﺮار ﻣﻲ دﻫﻴﻢ و‬
‫ﻣﺘﻐﻴﻴﺮي از ﺟﻨﺲ آراﻳﻪ ﺗﻌﺮﻳﻒ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﻳﻚ ﺣﻠﻘﻪ ﻗﺮار ﻣﻲ دﻫﻴﻢ ﺗﺎ از اول آراﻳﻪ ﺗﺎ آﺧﺮ آراﻳﻪ را ﺟﺴﺘﺠﻮ‬
‫ﻛﻨﺪ ﺑﺮاي اﻳﻦ ﻛﺎر ﺗﻌﺪاد ﻋﻨﺎﺻﺮ آراﻳﻪ را ﺑﺎ ﺗﺎﺑﻊ ‪ count‬درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﺣﻠﻘﻪ از ‪ 0‬ﺗﺎ ﺗﻌﺪا آراﻳﻪ ﺷﻤﺎرﻧﺪه‬
‫دارد درون اﻳﻦ ﺣﻘﻠﻪ دﺳﺘﻮر ﺷﺮﻃﻲ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﺗﺎ آراﻳﻪ ﺑﺎ اﻧﺪﻳﺲ ﺷﻤﺎرﻧﺪه را ﺑﺎ ﻣﻘﺪار ورودي ﺗﺎﺑﻊ‬
‫ﻣﻘﺎﻳﺴﻪ ﻛﻨﺪ اﮔﺮ ﺑﺮاﺑﺮ ﺑﻮد ﺑﻪ اﻳﻦ ﻣﻌﻨﻲ اﺳﺖ ﻛﻪ اﻳﻦ ﻛﻠﻤﻪ درون آراﻳﻪ وﺟﻮد دارد و ﺑﺎﻳﺪ از ﺣﻠﻘﻪ ﺧﺎرج‬
‫ﺷﺪ و ﻣﻘﺪار ‪ s‬را ﺑﺮاﺑﺮ ‪ 1‬ﻣﻴﮕﺬارﻳﻢ ﺑﺪﻳﻦ ﻣﻌﻨﻲ ﻛﻪ اﻳﻦ ﻣﻘﺪار ﭘﻴﺪا ﺷﺪه اﺳﺖ و در آﺧﺮ دﺳﺘﻮر ﺷﺮﻃﻲ ﻣﻲ‬
‫ﻧﻮﻳﺴﻴﻢ ﻛﻪ آﻳﺎ ﻣﻘﺪار ‪ s‬ﻣﺨﺎﻟﻒ ‪ 1‬اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ﻣﺨﺎﻟﻒ ﺑﺎﺷﺪ ﻳﻌﻨﻲ ﭘﻴﺪا ﻧﺸﺪه و ﭘﻴﻐﺎﻣﻲ ﻣﺒﻨﻲ ﺑﺮ ﭘﻴﺪا‬
‫ﻧﺸﺪن ﺑﺮاي ﻛﺎرﺑﺮ ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  searcharray.php‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪124 | P a g e  ‬‬
‫‪ ‬‬
‫ﺧﺮوﺟﻲ‬

‫ﻣﺮﺗﺐ ﺳﺎزي آراﻳﻪ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ sortarray.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬در اﻳﻦ ﻓﺎﻳﻞ اﺑﺘﺪا ﻳﻚ آراﻳﻪ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ و‬
‫ﻣﻘﺎدﻳﺮ آن را ﺑﻪ ﺻﻮرت دﺳﺘﻲ وارد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ﻳﻚ ﺗﺎﺑﻊ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻣﻘﺪار آراﻳﻪ را از ﺑﻴﺮون ﻣﻴﮕﻴﺮد و‬
‫ﺗﻌﺪاد ﻣﻘﺎدﻳﺮ آن را ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ count‬درون ﻣﺘﻐﻴﻴﺮ ‪ t‬ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ ‪ .‬دو ﺣﻠﻘﻪ ﺑﺮاي ﻣﺮﺗﺐ ﻛﺮدن‬
‫آراﻳﻪ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ از ‪ 0‬ﺷﺮوع ﻣﻲ ﺷﻮﻧﺪ و ﺗﺎ ﺗﻌﺪاد ﻋﻨﺎﺻﺮ آراﻳﻪ ﻣﻨﻬﺎي ‪ 1‬اداﻣﻪ ﭘﻴﺪا ﻣﻲ ﻛﻨﺪ و ﻣﻘﺎدﻳﺮ‬
‫آراﻳﻪ را ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر ﺷﺮﻃﻲ ﻣﺮﺗﺐ ﻣﻲ ﻛﻨﺪ در اﻳﻦ دﺳﺘﻮر اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﺷﻮد ﻛﻪ آﻳﺎ ﺧﺎﻧﻪ ﺑﻌﺪي‬
‫آراﻳﻪ ﺑﺰرﮔﺘﺮ از ﺧﺎﻧﻪ ﻛﻨﻮﻧﻲ آراﻳﻪ اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ ﻣﻘﺪار ﻛﻨﻮﻧﻲ را در ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ‬
‫ﺗﺎ از ﺑﻴﻦ ﻧﺮود و ﺳﭙﺲ ﻣﻘﺪار ﺧﺎﻧﻪ ﺑﻌﺪي را در ﺧﺎﻧﻪ ﻛﻨﻮﻧﻲ ﻣﻲ رﻳﺰﻳﻢ و در آﺧﺮ ﻣﻘﺪار ذﺧﻴﺮ ه ﺷﺪه ﻛﻪ‬
‫ﺣﺎوي ﻣﻘﺪار ﻛﻨﻮﻧﻲ اﺳﺖ را در ﺧﺎﻧﻪ ﺑﻌﺪي ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ اﻳﻨﮕﻮﻧﻪ ﻣﻘﺪار آراﻳﻪ ﻣﺮﺗﺐ ﻣﻲ ﺷﻮد ‪ .‬در آﺧﺮ‬
‫ﻫﻢ ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ﻣﻘﺎدﻳﺮ آراﻳﻪ ﻣﺮﺗﺐ ﺷﺪه را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪  .‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬

‫‪ ‬‬
 ‫‪125 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  sertarray.php‬‬

‫‪ ‬‬

‫ﺟﺴﺘﺠﻮ ﺑﺎﻳﻨﺮي‬

‫ﺟﺴﺘﺠﻮ ﺑﺎﻳﻨﺮي از ﺳﺮﻋﺖ ﺑﺴﻴﺎ ﺑﺎﻻي ﻧﺴﺒﺖ ﺑﻪ ﺟﺴﺘﺠﻮ ﺧﻄﻲ ﻣﻲ ﺑﺎﺷﺪ و ﺑﺮاي ﻣﻘﺎدﻳﺮ زﻳﺎد ﺑﺴﻴﺎر ﺑﻬﻴﻨﻪ ﻣﻲ‬
‫ﺑﺎﺷﺪ ‪ .‬در اﻟﮕﻮرﻳﺘﻢ ﺑﺎﻳﻨﺮي اﺑﺘﺪا ﻣﻘﺎدﻳﺮ ﺑﺎﻳﺪ ﻣﺮﺗﺐ ﺷﺪه ﺑﺎﺷﻨﺪ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑﻪ اﻳﻦ ﺷﻜﻞ ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ‬
‫ﻛﻪ ﻓﺮض ﻛﻨﻴﺪ ﺗﻌﺪاد ﻛﻞ داده ﻫﺎي ﻣﺎ ﺑﺮاﺑﺮ ‪ 200‬ﻋﺪد ﻣﻲ ﺑﺎﺷﺪ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ اﺑﺘﺪا ﻣﺤﻞ ﺷﺮوع ﺟﺴﺘﺠﻮ و‬
‫ﭘﺎﻳﺎن آن راﻣﺸﺨﺺ ﻣﻲ ﻛﻨﺪ و ﻣﻴﺎﻧﻪ را اﻧﺘﺨﺎب ﻣﻲ ﻛﻨﺪ ﻳﻌﻨﻲ ﺳﺮاغ ﻋﻨﺼﺮ ‪ 100‬ﻣﻲ رود اﮔﺮ اﻳﻦ ﻋﻨﺼﺮ ﻋﻨﺼﺮ‬
‫ﻣﻮرده ﻧﻈﺮ ﻣﺎ ﺑﺎﺷﺪ ﺑﺎ ﻳﻚ ﺣﺮﻛﺖ اﻳﻦ ﻋﻨﺼﺮ را ﭘﻴﺪا ﻛﺮده اﺳﺖ ‪ .‬اﮔﺮ ﻋﻨﺼﺮ ﻣﺎ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ اﻟﮕﻮرﻳﺘﻢ ﺷﺮوع‬
‫ﺟﺴﺘﺠﻮ را از ﻋﻨﺼﺮ ‪ 101‬ﺷﺮوع ﻣﻴﻜﻨﺪ ﭼﻮن ﻋﻨﺼﺮي ﻛﻪ دﻧﺒﺎل آن از ﻣﻴﺎﻧﻪ ﺑﺰرﮔﺘﺮ اﺳﺖ ﺣﺎل ﻣﻴﺎﻧﻪ اﻟﮕﻮرﻳﺘﻢ‬
‫ﺗﻐﻴﻴﺮ ﻣﻲ ﻛﻨﺪ و ﻋﻨﺼﺮ ‪ 150‬ﻣﻴﺎﻧﻪ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﻣﻲ ﺷﻮد و اﮔﺮ اﻳﻦ ﻋﻨﺼﺮ ﻫﻤﺎن ﻋﻨﺼﺮ ﺑﺎﺷﺪ ﺑﺎ دو ﺣﺮﻛﺖ‬
‫ﺟﺴﺘﺠﻮ ﺑﻪ ﭘﺎﻳﺎن ﻣﻲ رﺳﺪ و اﮔﺮ دوﺑﺎره ﻋﺒﺎرت ﻣﻮرده ﻧﻈﺮ ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ دوﺑﺎره ﺷﺮوع اﻟﮕﻮرﻳﺘﻢ از ‪ 151‬ﻣﻲ‬
‫ﺑﺎﺷﺪ و ﻣﻴﺎﻧﻪ اﻟﮕﻮرﻳﺘﻢ ﺑﻪ ‪ 175‬ﺗﻐﻴﻴﺮ ﻣﻲ ﻳﺎﺑﺪ ‪ .‬در واﻗﻊ اﻳﻦ اﻟﮕﻮرﻳﺘﻢ ﺑﻪ ﮔﻮﻧﻪ اﻳﻲ ﻋﻤﻞ ﻣﻲ ﻛﻨﺪ ﻛﻪ ﻋﻨﺼﺮ‬
‫وﺳﻂ ﻟﻴﺴﺖ اﻧﺘﺨﺎب ﺷﺪه و ﺑﺎ آرﮔﻮﻣﺎن ﺟﺴﺘﺠﻮ ﻣﻘﺎﻳﺴﻪ ﻣﻲ ﺷﻮد ﺗﺎ ﺗﻌﻴﻴﻦ ﺷﻮد از آن ﺑﺰرﮔﺘﺮ ‪ ,‬ﻛﻮﭼﻴﻜﺘﺮ ﻳﺎ‬

‫‪ ‬‬
 ‫‪126 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﺴﺎوي اﺳﺖ ‪ .‬اﮔﺮ آرﮔﻮﻣﺎن از ﻋﻨﺼﺮ اﻧﺘﺨﺎب ﺷﺪه ﺑﺰرﮔﺘﺮ ﺑﺎﺷﺪ ﺟﺴﺘﺠﻮ در ﻧﻴﻤﻪ ﺑﺎﻻﻳﻲ و اﮔﺮ ﻛﻮﭼﻜﺘﺮ ﺑﺎﺷﺪ‬
‫در ﻧﻴﻤﻪ ﭘﺎﻳﻴﻨﻲ ﻟﻴﺴﺖ اداﻣﻪ ﭘﻴﺪا ﻣﻲ ﻛﻨﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  binerysearch.php‬‬

‫‪ ‬‬

‫‪ ‬‬
‫‪ ‬‬
 ‫‪127 | P a g e  ‬‬
‫‪ ‬‬
‫اﻋﺪاد زوج‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ zoj.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ و ﺑﺎ اﺳﺘﻔﺎده ازﺣﻠﻘﻪ اﻋﺪاد زوج ﺑﻴﻦ ‪ 0‬ﺗﺎ ‪ 100‬را ﭼﺎپ ﻣﻴﻜﻨﺪ‪.‬‬
‫ﺷﻤﺎرﻧﺪه اﻳﻦ ﺣﻠﻘﻪ ‪ 2‬ﺗﺎﻳﻲ ﻣﻲ ﺑﺎﺷﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  zoj.php‬‬

‫‪ ‬‬
‫ﺣﺎل ﺑﺮﻧﺎﻣﻪ اﻳﻲ ﻣﻴﻨﻮﻳﺴﻴﻢ ﻛﻪ اﻋﺪاد ﻛﻪ ﺑﺮ ‪ 5‬ﺑﺨﺶ ﭘﺬﻳﺮ ﻣﻲ ﺑﺎﺷﻨﺪ را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬ﺑﺎ اﺳﺘﻔﺎده از ﺷﺮط‬
‫ﻫﺮ ﻋﺪدي ﻛﻪ ﺗﻘﺴﻢ ﺑﺮ ‪ 5‬ﻣﻲ ﺷﻮد و ﺑﺎﻗﻴﻤﺎﻧﺪه آن ‪ 0‬ﺷﻮد ﻳﻌﻨﻲ ﺑﺮ ‪ 5‬ﺑﺨﺶ ﭘﺬﻳﺮ اﺳﺖ ﺑﻨﺎﺑﺮ اﻳﻦ آن را ﭼﺎپ‬
‫ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  baghimande5.php‬‬

‫‪ ‬‬

‫ﺗﺎﺑﻊ ﻣﻴﺎﻧﮕﻴﻦ‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم ‪ average.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬درون اﻳﻦ ﻓﺎﻳﻞ ﻳﻚ ﺗﺎﺑﻊ ﻣﻲ ﻧﻮﻳﺴﻴﻢ ﻛﻪ ﻳﻚ آراﻳﻪ‬
‫از اﻋﺪاد ﻣﻴﮕﻴﺮد و ﻣﻴﺎﻧﮕﻴﻦ آن را ﭼﺎپ ﻣﻲ ﻛﻨﺪ ‪ .‬اﺑﺘﺪا ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ ‪ count‬ﺗﻌﺪا ﻋﻨﺎﺻﺮ آراﻳﻪ را‬
‫ﻣﺤﺎﺳﺒﻪ ﻣﻲ ﻛﻨﻴﻢ و ﺑﺎ اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ﻣﻘﺎدﻳﺮ آراﻳﻪ را ﺑﺎ ﻫﻢ ﺟﻤﻊ ﻣﻲ ﻛﻨﻴﻢ و در ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ‬
‫در آﺧﺮ ﻣﻘﺪار ﻛﻞ را ﺗﻘﺴﻴﻢ ﺑﺮ ﺗﻌﺪاد ﻣﻲ ﻧﻤﺎﻳﻴﻢ و ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪.‬‬

‫‪ ‬‬
 ‫‪128 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  average.php‬‬

‫اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﺎ ﻧﺎم ‪ srtlen1.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ‪ .‬درون اﻳﻦ ﻓﺎﻳﻞ اﺑﺘﺪا ﻳﻚ ورودي ﺑﺮاي درﻳﺎﻓﺖ ﻛﻠﻤﻪ‬
‫از ﻛﺎرﺑﺮ اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ ﻣﻘﺪار ورودي ﻛﺎرﺑﺮ را ﺑﻪ ﺗﺎﺑﻊ ‪ post‬ﻣﻲ دﻫﺪ ﻛﻪ اﻳﻦ ﺗﺎﺑﻊ ﻣﻘﺪار ورودي ﻛﺎرﺑﺮ‬
‫را ﺑﺎ اﺳﺘﻔﺎده از ‪ Ajax‬ﺑﻪ ﻓﺎﻳﻞ ‪ srtlen2.php‬ﻣﻴﻔﺮﺳﺘﺪ ‪ .‬در اﻳﻦ ﻓﺎﻳﻞ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ ﭘﺎراﻣﺘﺮ‬
‫ورودي ﺑﻪ اﻳﻦ ﺗﺎﺑﻊ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ آن را در ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ و آن‬
‫ﻣﺘﻐﻴﻴﺮ را ﺑﻪ ﺗﺎﺑﻊ ‪ strlen‬ﻣﻲ دﻫﻴﻢ ﻛﻪ اﻳﻦ ﺗﺎﺑﻊ ﺗﻌﺪاد ﻛﺎراﻛﺘﺮ را ﺑﺮ ﻣﻴﮕﻴﺮداﻧﺪ و آن را ﭼﺎپ ﻣﻲ ﻛﻨﻴﻢ ‪  .‬‬

‫ﻓﺎﻳﻞ ‪  strlen1.php‬‬

‫‪ ‬‬

‫‪ ‬‬
 ‫‪129 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  strlen2.php‬‬

‫‪ ‬‬
‫ﺟﺴﺘﺠﻮ درون رﺷﺘﻪ‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ strpos‬ﻣﻲ ﺗﻮان ﻳﻚ آراﻳﻪ را درون آراﻳﻪ دﻳﮕﺮ ﺟﺴﺘﺠﻮ ﻛﺮد ‪ .‬اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ ﻧﺎم‬
‫‪ searchajax.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ درون آن دو ورودي از ﻛﺎرﺑﺮ درﻳﺎﻓﺖ ﻣﻲ ﻛﻨﻴﻢ ‪ .‬ورودي اول ﻛﻠﻤﻪ‬
‫اﺳﺖ و ورودي دوم ﻣﻘﺪاري اﺳﺖ ﻛﻪ ﺑﺎﻳﺪ ﺟﺴﺘﺠﻮ ﺷﻮد اﻳﻦ دو ﻣﻘﺪار را ﺑﻪ ﺻﻔﺤﻪ ‪searchajax2.php‬‬
‫ارﺳﺎل ﻣﻲ ﻛﻨﻴﻢ ‪ .‬در اﻳﻦ ﻓﺎﻳﻞ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ ورودي ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ‬
‫ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﺷﺪه ﺑﺎﺷﺪ اﻳﻦ دو ورودي را در ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ و ﺑﻪ ﺗﺎﺑﻊ ‪ strpos‬ﻣﻲ دﻫﻴﻢ ﻛﻪ‬
‫ﺷﻤﺎره ﻛﺎراﻛﺘﺮ را ﺑﺮ ﻣﻴﮕﻴﺮداﻧﺪ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  searchajax.php‬‬

‫‪ ‬‬

‫‪ ‬‬
 ‫‪130 | P a g e  ‬‬
‫‪ ‬‬
‫ﻓﺎﻳﻞ ‪  searchajax2.php‬‬

‫‪ ‬‬

‫ﺗﻜﺮار رﺷﺘﻪ‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ str_repeat‬ﻣﻲ ﺗﻮان ﻳﻚ رﺷﺘﻪ را ﺑﻪ ﻣﻴﺰان دﻟﺨﻮاه ﺗﻜﺮار ﻛﺮد ‪ .‬اﺑﺘﺪا ﻳﻚ ﻓﺎﻳﻞ ﺑﻪ‬
‫ﻧﺎم ‪ repeatajax1.php‬اﻳﺠﺎد ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ دو ورودي از ﻛﺎرﺑﺮ ﺑﮕﻴﺮد اوﻟﻲ ﻛﻠﻤﻪ ﻣﻮرده ﻧﻈﺮ و دوﻣﻲ ﻣﻴﺰان‬
‫ﺗﻜﺮار آن ﻣﻲ ﺑﺎﺷﺪ و اﻳﻦ دو ﻣﺘﻐﻴﻴﺮ را ﺑﺎ اﺳﺘﻔﺎده از ‪ Ajax‬ﺑﻪ ﺻﻔﺤﻪ ‪ repeatajax2.php‬ﻣﻴﻔﺮﺳﺘﺪ ‪ .‬در اﻳﻦ‬
‫ﺻﻔﺤﻪ اﺑﺘﺪا ﺑﺮرﺳﻲ ﻣﻲ ﻛﻨﻴﻢ ﻛﻪ آﻳﺎ دو ﭘﺎراﻣﺘﺮ ﺑﻪ اﻳﻦ ﺻﻔﺤﻪ ارﺳﺎل ﺷﺪه اﺳﺖ ﻳﺎ ﺧﻴﺮ اﮔﺮ ارﺳﺎل ﺷﺪه‬
‫ﺑﺎﺷﺪ آن دو را درون ﻣﺘﻐﻴﻴﺮ ذﺧﻴﺮه ﻣﻲ ﻛﻨﻴﻢ و ﻣﺘﻐﻴﻴﺮ ﻫﺎ را ﺑﻪ ﺗﺎﺑﻊ )(‪ str_repeat‬ﻣﻲ دﻫﻴﻢ ‪.‬‬

‫ﻓﺎﻳﻞ ‪  repeatajax1.php‬‬

‫‪ ‬‬

‫‪ ‬‬
 131 | P a g e  
 
  repeatajax2.php ‫ﻓﺎﻳﻞ‬

 
   

 
‫‪132 | P a g e  ‬‬
‫‪ ‬‬
‫ﻣﻨﺎﺑﻊ ‪ ‬‬

‫‪ ‬‬
‫‪ ‬ﻛﺘﺎب ﻣﺮﺟﻊ ﻛﺎﻣﻞ و ﻣﺼﻮر ‪ PHP 5‬ﭼﺎپ ﺳﻮم ‪) .‬ﻣﻬﻨﺪس ﻣﻬﺮداد ﺗﻮاﻧﺎ و ﻣﻬﻨﺪس ﺳﻌﻴﺪ‬
‫ﻫﺮاﺗﻴﺎن( اﻧﺘﺸﺎرات ﮔﺮوه ﻣﻬﻨﺪﺳﻲ – ﭘﮋوﻫﺸﻲ ﺳﺎﺣﺮ ‪ ‬‬
‫‪ ‬زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ PHP 5‬ﺟﻠﺪ اول ‪) .‬ﻣﺤﻤﺪ ﻣﺼﺪري( اﻧﺘﺸﺎرات ﻧﺎﻗﻮس ‪ ‬‬
‫‪ ‬زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴﻲ ‪ PHP 5‬ﺟﻠﺪ دوم ‪) .‬ﻣﺤﻤﺪ ﻣﺼﺪري( اﻧﺘﺸﺎرات ﻧﺎﻗﻮس ‪ ‬‬
‫‪ ‬ﺳﺎﻳﺖ ‪  www.w3schools.com‬‬
‫‪ ‬ﺳﺎﻳﺖ ‪  www.php.net‬‬
‫‪ ‬ﺳﺎﻳﺖ ‪  www.en.wikipedia.org‬‬

‫اﻣﻴﺪوارم ﺑﺎ ﺧﻮاﻧﺪن اﻳﻦ ﻛﺘﺎب اﻟﻜﺘﺮوﻧﻴﻜﻲ ﺑﻪ ﻋﻠﻢ ﺷﻤﺎ اﺿﺎﻓﻪ ﺷﺪه ﺑﺎﺷﺪ ‪.‬‬

‫ﻣﺤﺴﻦ رﺟﺒﻲ ‪1392/11/05‬‬

‫از ﻃﺮﻳﻖ اﻳﻦ اﻳﻤﻴﻞ ﻣﻲ ﺗﻮاﻧﻴﺪ ﺳﻮاﻻت ﺧﻮد را ﺑﺎ ﺑﻨﺪه در ﻣﻴﺎن ﺑﮕﺬارﻳﺪ ‪.‬‬

‫‪  m.kabir8895@yahoo.com‬‬

‫‪ ‬‬