‫ﭼﻜﻴﺪه‬

‫اﻳﻦ ﭘﺮوژه آﻣﻮزﺷﻲ ﺗﻮﺳﻂ داﻧﺸﺠﻮ ﻛﺎرﺷﻨﺎﺳﻲ داﻧﺸﮕﺎه ﺷﻤﺴﻲ ﭘﻮر ﻣﺤﺴﻦ رﺟﺒﻲ اﻧﺠﺎم ﺷﺪه و در‬
‫ﻣﻮرده آﻣﻮزش زﺑﺎن ‪ 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|Page‬‬

‫ﭘﻴﺸﮕﻔﺘﺎر‬

‫ﻣﻌﺮﻓﻲ ‪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|Page‬‬

‫ﻣﺰﻳﺖ ﻫﺎي ‪PHP‬‬

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫ﺑﺮاي ﻛﺎر ﺑﺎ ﭘﺎﻳﮕﺎه داده ‪ 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‬‬

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

‫‪[email protected]‬‬