1
00:00:00,000 --> 00:00:02,400
[Powered by Google Translate] [PHP సింటాక్స్]

2
00:00:02,400 --> 00:00:04,400
[టామీ MacWilliam] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,400 --> 00:00:07,400
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:07,400 --> 00:00:10,080
>> ఈ వీడియో లో, మేము PHP పరిచయం చేస్తాము -

5
00:00:10,080 --> 00:00:12,820
భాషలు ఒకటి మేము CS50 ఉపయోగించి అవుతారు

6
00:00:12,820 --> 00:00:15,480
వెబ్ అభివృద్ధి మేము బదిలీ వంటి.

7
00:00:15,480 --> 00:00:19,250
PHP, PHP హైపర్టెక్స్ట్ ప్రాసెసర్ ఉన్నచో

8
00:00:19,250 --> 00:00:23,440
లేదా PHP హైపర్టెక్స్ట్ ప్రాసెసర్ హైపర్టెక్స్ట్ ప్రాసెసర్,

9
00:00:23,440 --> 00:00:24,880
మరియు నేను అక్కడ ఆపడానికి ఉంటాం.

10
00:00:24,880 --> 00:00:29,280
PHP నేను నిజంగా అద్భుతం భావించే ఒక రికర్సివ్ అక్రానిమ్, ఉంది.

11
00:00:29,280 --> 00:00:32,020
>> సో, యొక్క వ్రాయడానికి వీలు 'hello world' PHP లో,

12
00:00:32,020 --> 00:00:37,240
మేము తెలిసిన మరియు ప్రేమించడం మొదలుపెడతారు చేసిన సి లో 'hello world' కంటే కొంత భిన్నంగా ఉంటుంది.

13
00:00:37,240 --> 00:00:40,330
బదులుగా hello.c అనే ఫైలు సృష్టించే,

14
00:00:40,330 --> 00:00:42,990
మేము hello.php సృష్టిస్తారు.

15
00:00:42,990 --> 00:00:52,430
మా PHP కోడ్ అన్ని <? Php మరియు?> మధ్య కలిగి ఉంటుంది.

16
00:00:52,430 --> 00:00:56,160
మేము ఉన్న ఏ PHP కోడ్ కలిగి ఉంటే

17
00:00:56,160 --> 00:00:59,140
ఈ ఆద్యంతాలు బయట, అది అమలు కాదు.

18
00:00:59,140 --> 00:01:01,740
ఈ PHP బ్లాక్స్ యొక్క అనేక ఉండవచ్చు

19
00:01:01,740 --> 00:01:05,090
మేము ఒక PHP ఫైలు లోపల కావలసిన.

20
00:01:05,090 --> 00:01:09,000
PHP ఒక ప్రధాన క్రియకు అవసరం లేదు.

21
00:01:09,000 --> 00:01:15,540
బదులుగా, మా PHP కోడ్ మా PHP ఫైలు కనిపిస్తుంది క్రమంలో అమలు అవుతుంది.

22
00:01:15,540 --> 00:01:20,970
సి మరియు PHP రెండు డేటా ఔట్పుట్ కోసం ఒక 'printf' ఫంక్షన్ కలిగి.

23
00:01:20,970 --> 00:01:27,270
కానీ PHP లో, మేము # standardIO.h వంటి ఏ శీర్షిక ఫైల్స్ అవసరం లేదు.

24
00:01:27,270 --> 00:01:31,830
PHP లో మేము మా కోడ్ కంపైల్ కాదు ఎందుకంటే ఆ.

25
00:01:31,830 --> 00:01:35,560
మేము సి కోడ్ వ్రాశాడు మా వర్క్ఫ్లో తెరవబడుతుంది మొగ్గు

26
00:01:35,560 --> 00:01:39,560
ఒకటి లేదా ఎక్కువ. సి లేదా. h ఫైళ్లు, వాటిని మార్చడాన్ని, వాటిని కంపైల్,

27
00:01:39,560 --> 00:01:41,980
మరియు ఫలితంగా బైనరీ నడుస్తున్న.

28
00:01:41,980 --> 00:01:45,800
ఈ ప్రక్రియ గురించి మరింత సమాచారం కోసం సంకలనం వీడియో తనిఖీ.

29
00:01:45,800 --> 00:01:51,480
>> కాకుండా సంకలనం - - భాష సి కాకుండా, PHP ఒక అర్థం ఉంది.

30
00:01:51,480 --> 00:01:54,080
ఆ PHP కోడ్ మేము వ్రాయడానికి అర్థం

31
00:01:54,080 --> 00:01:57,360
, ఒక వ్యాఖ్యాత అనే ప్రత్యేక కార్యక్రమం ద్వారా అమలు అవుతుంది

32
00:01:57,360 --> 00:02:00,440
దీనిలో మా కోడ్ అమలు చేస్తుంది.

33
00:02:00,440 --> 00:02:03,020
మా PHP కోడ్ నడుపుటకు,

34
00:02:03,020 --> 00:02:07,860
మేము, దాని అమలు నిర్వహించడానికి ఇది PHP వ్యాఖ్యాత పాటు దీన్ని పంపుతాము

35
00:02:07,860 --> 00:02:11,260
బదులుగా యంత్రం కోడ్ దానిని కంపైల్ కంటే.

36
00:02:11,260 --> 00:02:13,450
యొక్క చర్య వ్యాఖ్యాత చూద్దాం.

37
00:02:13,450 --> 00:02:17,010
మేము ఒక టెర్మినల్ తెరిచి PHP ఆదేశాన్ని చేస్తాము

38
00:02:17,010 --> 00:02:21,130
మేము అమలు చేయాలనుకుంటే PHP ఫైలు మార్గం తరువాత.

39
00:02:21,130 --> 00:02:25,690
మేము, 'php hello.php' అని వస్తుంది.

40
00:02:25,690 --> 00:02:30,200
మరియు అక్కడ మేము వెళ్ళి. మా PHP కార్యక్రమం అవుట్పుట్ ఉంది.

41
00:02:30,200 --> 00:02:33,460
మేము అన్ని వద్ద మా PHP ఫైలు కంపైల్ అవసరం లేదు.

42
00:02:33,460 --> 00:02:37,280
PHP వ్యాఖ్యాత - బదులుగా, మేము మరొక ప్రోగ్రామ్ -

43
00:02:37,280 --> 00:02:40,070
మేము వ్రాసాడు sourcecode అమలు.

44
00:02:40,070 --> 00:02:43,280
>> PHP కేవలం printf కంటే చేయవచ్చు.

45
00:02:43,280 --> 00:02:46,490
యొక్క కొన్ని క్లిష్టమైన PHP ప్రోగ్రాములను వ్రాయటానికి వీలు.

46
00:02:46,490 --> 00:02:52,240
నిర్మాణాలు కోసం సింటాక్స్ - కోసం, అయితే, వేరే ఉంటే ఇష్టం, మరియు స్విచ్ -

47
00:02:52,240 --> 00:02:55,440
PHP మరియు C. లో అదే

48
00:02:55,440 --> 00:03:01,180
కేవలం సి వంటి, ఈ నిర్మాణాలను ప్రతి వారి శరీరం విభజన జంట కలుపులు ఉపయోగిస్తుంది

49
00:03:01,180 --> 00:03:04,420
మరియు కేవలం సి మాదిరిగా, ప్రతి లైన్ మేము వ్రాయడానికి

50
00:03:04,420 --> 00:03:06,830
ఒక సెమికోలన్ తో ముగియాలి;

51
00:03:06,830 --> 00:03:10,700
అయితే, వేరియబుల్ PHP ఒక బిట్ భిన్నంగా నిర్వహించబడతాయి.

52
00:03:10,700 --> 00:03:15,630
మొదటి, PHP లో అన్ని వేరియబుల్స్ డాలర్ సైన్ తో ప్రారంభం కావాలి.

53
00:03:15,630 --> 00:03:18,700
ఇది మొదటి వద్ద కొద్దిగా అదృష్టము తెలుస్తోంది, కానీ మీరు ఉపయోగించే పొందుతారు.

54
00:03:18,700 --> 00:03:22,150
రెండవ, PHP ఒక వదులుగా టైప్ చేసిన భాష

55
00:03:22,150 --> 00:03:24,570
ఇది మీరు ప్రత్యేకంగా జాబితా అవసరం లేదు అంటే

56
00:03:24,570 --> 00:03:27,640
మీరు దీన్ని సృష్టించడానికి ఒక వేరియబుల్ రకం.

57
00:03:27,640 --> 00:03:33,430
సి లో మీరు చెప్పే అవసరం చోట Int x = 5;

58
00:03:33,430 --> 00:03:38,650
లేదా చార్ y = 'ఒక';

59
00:03:39,250 --> 00:03:44,790
PHP మేము కేవలం $ x = 5 చెప్పగలను;

60
00:03:44,790 --> 00:03:48,930
మరియు $ y = 'ఒక';.

61
00:03:48,930 --> 00:03:52,360
అదే విధంగా వర్తిస్తుంది.

62
00:03:52,360 --> 00:04:01,290
అయితే Int f () {మా పనితీరు శరీరం} మాట్లాడుతూ కంటే,

63
00:04:01,290 --> 00:04:12,160
PHP మేము ఫంక్షన్ f () {మా పనితీరు శరీరం} అని చేయబోతున్నామని.

64
00:04:12,160 --> 00:04:17,579
మేము స్పష్టంగా మా ప్రమేయం f తిరిగి రకాన్ని పేర్కొనాలి లేదు.

65
00:04:17,579 --> 00:04:22,070
PHP లో చర్యలు అదే రకం తిరిగి లేదు

66
00:04:22,070 --> 00:04:23,840
ప్రతిసారీ వారు అమలవుతున్నాయి.

67
00:04:23,840 --> 00:04:27,940
ఉదాహరణకు, మేము ఒక లోపం న తప్పుడు తిరిగి ఒక ఫంక్షన్ రాస్తుంది

68
00:04:27,940 --> 00:04:29,750
మరియు మరొక రకమైన సఫలమైతే.

69
00:04:29,750 --> 00:04:33,060
>> ఈ కూడా మరింత సాధారణ విధులు వ్రాయండి సహాయపడుతుంది.

70
00:04:33,060 --> 00:04:35,710
ఉదాహరణకు, మేము ఒక యాడ్ ఫంక్షన్ రాస్తుంది

71
00:04:35,710 --> 00:04:39,200
2 పూర్ణాంకాల ఇస్తారు ఉంటే పూర్ణాంకం తిరిగి చేయవచ్చు

72
00:04:39,200 --> 00:04:41,250
లేదా ఫ్లోట్ 2 తేలటం ఇవ్వబడలేదు.

73
00:04:41,250 --> 00:04:45,530
సి, మేము దీన్ని 2 ప్రత్యేక విధులు వ్రాయడానికి అవసరం ఇష్టం.

74
00:04:45,530 --> 00:04:49,230
సి లో మేము ఒక రైజ్ మరియు తీగలను, కోసం గమనికలు ఉపయోగించడానికి

75
00:04:49,230 --> 00:04:52,170
మేము PHP లో గమనికలు ఉపయోగించడానికి చేయలేరు.

76
00:04:52,170 --> 00:04:58,030
బదులుగా, శ్రేణుల మరియు తీగలను రెండు PHP లో రకాలు అంతర్నిర్మిత ఉన్నాయి.

77
00:04:58,030 --> 00:04:59,660
వారికి సరైన భాషలోకి నిర్మించారు చేస్తున్నారు.

78
00:04:59,660 --> 00:05:02,270
మేము చెప్పగలను PHP ఒక అమరికను రూపొందించడానికి

79
00:05:02,270 --> 00:05:11,280
$ ఒక = శ్రేణి (1, 2, 3);

80
00:05:11,280 --> 00:05:19,400
లేదా కేవలం $ ఒక = [1, 2, 3];.

81
00:05:19,400 --> 00:05:24,990
మేము ఈ శ్రేణి లోకి సూచిక మేము C. నుండి చేస్తున్నట్లుగానే అదే సింటాక్స్ ఉపయోగించి

82
00:05:24,990 --> 00:05:31,780
మొదటి మూలకం పొందుటకు మేము చెప్పటానికి, $ ఒక [0] చేస్తాము;.

83
00:05:31,780 --> 00:05:36,290
PHP కూడా అనుబంధ శ్రేణుల మద్దతు అంతర్నిర్మిత.

84
00:05:36,290 --> 00:05:41,460
అనుబంధ శ్రేణుల మేము ఇప్పటికే చూసిన హాష్ పట్టిక డేటా నిర్మాణం వలె -

85
00:05:41,460 --> 00:05:44,060
వారు ఒక విలువ ఒక కీ మ్యాప్.

86
00:05:44,060 --> 00:05:46,070
>> యొక్క ఒక ఉదాహరణ పరిశీలించి లెట్.

87
00:05:46,070 --> 00:06:14,740
మేము, $ సిబ్బంది చెప్పగలను = ["బోధకుడు" => "డేవిడ్", "TF" => "టామీ"];.

88
00:06:14,740 --> 00:06:21,020
శిక్షకుడు మరియు TF - ఇక్కడ, నేను 2 కీలు తో ఒక అనుబంధ అమరిక కలిగి.

89
00:06:21,020 --> 00:06:24,910
డబుల్ బాణం, లేదా సమానం అధికంగా కంటే,

90
00:06:24,910 --> 00:06:29,660
ఒక కీ మరియు దాని సంబంధిత విలువ వేరు ఉపయోగిస్తారు.

91
00:06:29,660 --> 00:06:41,830
సో, $ సిబ్బంది ["TF"] విలువ స్ట్రింగ్ "టామీ" ఉంది.

92
00:06:41,830 --> 00:06:44,430
ఒక అనుబంధ అమరిక యొక్క విలువలు -

93
00:06:44,430 --> 00:06:47,540
చాలా ఇతర శ్రేణి వంటి - ఏ రకం ఉంటుంది.

94
00:06:47,540 --> 00:07:23,370
ఉదాహరణకు, మేము చెప్పగల్గినవి, $ సిబ్బంది = ["బోధకుడు" => "డేవిడ్", "TFS" => ["టామీ", "రాబ్"]];.

95
00:07:23,370 --> 00:07:27,810
ఇప్పుడు 'TFS' విలువ ఒక శ్రేణి.

96
00:07:27,810 --> 00:07:33,030
ఒక అనుబంధ శ్రేణిలో విలువలు వివిధ రకాల ఉంటుంది అర్థం.

97
00:07:33,030 --> 00:07:36,750
>> PHP శ్రేణుల కూడా, ఒక నిర్దిష్ట పొడవు లేదు

98
00:07:36,750 --> 00:07:40,200
కాబట్టి మేము ఒక అర్రే నుండి మూలకాలు జోడించడానికి లేదా తొలగించవచ్చు.

99
00:07:40,200 --> 00:07:49,130
లెట్ యొక్క మేము $ వంటి సాధారణ శ్రేణి కలిగి చెబుతున్న = [1, 2, 3];.

100
00:07:49,130 --> 00:07:51,860
ఈ శ్రేణి ఒక కొత్త మూలకం జోడించడానికి,

101
00:07:51,860 --> 00:07:57,160
మేము చెప్పటానికి, $ ఒక [] = 4 చేయవచ్చు;.

102
00:07:57,160 --> 00:08:03,630
[1, 2, 3, 4] - ఇప్పుడు మా శ్రేణి నాలుగు అంశాలు కలిగి ఉంది.

103
00:08:03,630 --> 00:08:06,980
గుర్తు మేము సి లో ఈ వంటి ఏదో చేయాలని కోరుకుంటే,

104
00:08:06,980 --> 00:08:09,610
మేము, ఒక సరికొత్త వ్యూహం కేటాయించుటకు కలిగి ఇష్టం

105
00:08:09,610 --> 00:08:12,400
అది లోకి మా మొదటి శ్రేణి యొక్క కంటెంట్లను కాపీ,

106
00:08:12,400 --> 00:08:15,870
ఆపై మా కొత్త విలువ కొత్త శ్రేణి యొక్క చివరి మూలకం సెట్.

107
00:08:15,870 --> 00:08:18,390
ఈ PHP లో చాలా సులభం.

108
00:08:18,390 --> 00:08:21,230
మా వ్యూహం ఒక అనుబంధ అమరిక ఉంటే,

109
00:08:21,230 --> 00:08:24,810
మేము కేవలం ఒక అంశాన్ని సృష్టించడానికి ఒక కొత్త కీ నిర్వచించలేదు

110
00:08:24,810 --> 00:08:26,250
అసలే లేదు ఉంటే.

111
00:08:26,250 --> 00:08:30,010
$ సిబ్బంది - - మేము మా మునుపటి అర్రే కలిగి ఉంటే

112
00:08:30,010 --> 00:08:38,679
మేము సిబ్బంది $ చెప్పగలను ["మొత్తం"] = 3;.

113
00:08:38,679 --> 00:08:43,330
ఇప్పుడు మేము 3 విలువ ఒక కొత్త కీ కలిగి.

114
00:08:43,330 --> 00:08:46,460
>> వ్యూహంలో మూలకాల సంఖ్య పొందుటకు,

115
00:08:46,460 --> 00:08:48,230
మేము 'మొత్తం' ఫంక్షన్ ఉపయోగించవచ్చు.

116
00:08:48,230 --> 00:08:56,100
మేము అని చెప్పుకోవాలంటే, ($ ఒక) కౌంట్;, 4 విలువ ఉంటుంది.

117
00:08:56,100 --> 00:09:01,930
PHP లో, మేము, డబుల్ లేదా సింగిల్ కోట్స్ ఉపయోగించి తీగలను సృష్టించవచ్చు

118
00:09:01,930 --> 00:09:04,470
కాబట్టి అంశాలపై రెండు రెమ్మలు ఉంటాయి.

119
00:09:04,470 --> 00:09:21,780
S1 $ = "స్ట్రింగ్"; $ S2 = 'మరో స్ట్రింగ్';.

120
00:09:21,780 --> 00:09:23,920
ఈ రెండు మధ్య తేడా ఏమిటి?

121
00:09:23,920 --> 00:09:26,950
బాగా, అది ఉన్నాయి అనుకుంటున్నారా అందంగా సాధారణ వార్తలు

122
00:09:26,950 --> 00:09:29,600
ఒక స్ట్రింగ్ యొక్క ఒక వేరియబుల్ లోపల విలువ.

123
00:09:29,600 --> 00:09:34,390
దీన్ని ఒక మార్గం, PHP యొక్క డాట్ ఆపరేటర్లు ఉపయోగించడానికి ఉంటుంది

124
00:09:34,390 --> 00:09:36,630
ఇది concatenates తీగలను.

125
00:09:36,630 --> 00:09:38,680
మేము ఈ వంటి ఏదో అలా -

126
00:09:38,680 --> 00:09:53,800
$ N = 5; $ s = 'n' N $.;.

127
00:09:53,800 --> 00:09:57,430
ఇక్కడ మా n వేరియబుల్ ఒక పూర్ణ సంఖ్య.

128
00:09:57,430 --> 00:10:00,020
కానీ మేము స్ట్రింగ్ తో concatenate ఉన్నప్పుడు,

129
00:10:00,020 --> 00:10:04,110
PHP స్వయంచాలకంగా మాకు స్ట్రింగ్ అది మార్పిడి అవుతుందని.

130
00:10:04,110 --> 00:10:09,090
లేదా మేము కేవలం స్ట్రింగ్ కూడా లోకి వేరియబుల్ ఉంచాలి డబుల్ కోట్స్ ఉపయోగించవచ్చు.

131
00:10:09,090 --> 00:10:19,290
మేము, $ s చెప్పగలను = "N $ n ఉంది";.

132
00:10:19,290 --> 00:10:24,040
ఇప్పుడు $ s యొక్క విలువ 'n 5' ఉంటుంది.

133
00:10:24,040 --> 00:10:34,250
మేము బదులుగా సింగిల్ కోట్స్ ఉపయోగిస్తే, $ s లో = 'N $ n ఉంది';

134
00:10:34,250 --> 00:10:39,670
లు విలువ ఉంటుంది 'N $ n ఉంది';.

135
00:10:39,670 --> 00:10:43,720
మేము సింగిల్ కోట్స్ ఉపయోగిస్తే n విలువ, బదులుగా కాదు

136
00:10:43,720 --> 00:10:47,150
మేము డబుల్ కోట్స్ ఉపయోగిస్తే కానీ ఉంటుంది.

137
00:10:47,150 --> 00:10:51,800
మేము, ఒక స్ట్రింగ్ లో వ్యూహం విలువ చేర్చడానికి డబుల్ కోట్స్ ఉపయోగించడానికి కావాలా

138
00:10:51,800 --> 00:10:55,060
మేము ఈ వంటి శ్రేణి చుట్టూ కర్లీ జంట కలుపులు, ఉన్నాయి చెయ్యాలి -

139
00:10:55,060 --> 00:11:14,470
$ S = "{$ సిబ్బంది ['మొత్తం']}";.

140
00:11:14,470 --> 00:11:20,350
>> ప్రస్తుతం సి లో ఒక చిన్న స్నిప్పెట్ పరిశీలించి మరియు PHP అది అనువాదం లెట్.

141
00:11:20,350 --> 00:11:25,410
ఇక్కడ, మేము, ఒక స్ట్రింగ్ యొక్క పత్రాలను ముద్రిస్తుంది ఒక ఫంక్షన్ సృష్టిస్తున్నారు

142
00:11:25,410 --> 00:11:27,310
ప్రతి లైనుకు ఒక పాత్ర.

143
00:11:27,310 --> 00:11:32,250
PHP లో అదే పనిని లెట్ యొక్క.

144
00:11:32,250 --> 00:11:36,530
మొదటి, మేము మా PHP ఆద్యంతాలు అవసరం.

145
00:11:36,530 --> 00:11:39,000
మేము, మా ఫంక్షన్ రూపొందించినప్పుడు

146
00:11:39,000 --> 00:11:42,740
మేము తిరిగి రకం లేదా దాని వాదన రకాన్ని పేర్కొనాలి లేదు.

147
00:11:42,740 --> 00:11:46,890
మా లు వేరియబుల్ కూడా ఒక డాలర్ సైన్ తో ప్రారంభం కావాలి.

148
00:11:46,890 --> 00:11:51,590
PHP యొక్క strlen ఫంక్షన్, మాకు ఒక స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది

149
00:11:51,590 --> 00:11:55,660
కేవలం సి యొక్క strlen వంటి మాకు ఒక స్ట్రింగ్ యొక్క పొడవు ఇస్తుంది.

150
00:11:55,660 --> 00:11:59,060
దీనిలోనే అయితే, ఈ చర్యలను నిజానికి కొంత భిన్నంగా ఉంటాయి

151
00:11:59,060 --> 00:12:03,010
ఒక స్ట్రింగ్ PHP ఒక అంతర్నిర్మిత రకం నుండి.

152
00:12:03,010 --> 00:12:06,930
లూప్ 'కోసం' మా యొక్క సింటాక్స్ అదే.

153
00:12:06,930 --> 00:12:13,530
>> PHP లో, మేము కూడా ఒక స్ట్రింగ్ యొక్క అక్షరాలు ఆక్సెస్ చెయ్యడానికి శ్రేణి సంజ్ఞామానం ఉపయోగించవచ్చు.

154
00:12:13,530 --> 00:12:19,350
మేము ఇప్పుడు స్ట్రింగ్ యొక్క ప్రతి అక్షరం ముద్రించాలా ముద్రణ ఫంక్షన్ ఉపయోగించవచ్చు.

155
00:12:19,350 --> 00:12:23,080
PHP యొక్క ముద్రణ ఫంక్షన్, మేము placeholders గురించి ఆందోళన అవసరం లేదు -

156
00:12:23,080 --> 00:12:28,200
% d లేదా% సి వంటి - మేము ఒక స్ట్రింగ్ కాదు ఒక వేరియబుల్ ముద్రించాలా కావలసినప్పుడు.

157
00:12:28,200 --> 00:12:33,590
బదులుగా, మేము కేవలం, ముద్రణ ఫంక్షన్ ఏ రకం యొక్క ఒక వేరియబుల్ తరలిస్తారు

158
00:12:33,590 --> 00:12:36,810
మరియు అది ఒక స్ట్రింగ్ మార్చబడతాయి మరియు ప్రదర్శించబడుతుంది.

159
00:12:36,810 --> 00:12:43,430
అంతే! లెట్ యొక్క ఇప్పుడు 'php print.php' తో మా ఫైలు అమలు.

160
00:12:43,430 --> 00:12:48,160
మరియు మేము మా సి కార్యక్రమం నుండి చూసిన అవుట్పుట్ ఉంది.

161
00:12:48,160 --> 00:12:52,120
>> PHP కూడా 'foreach' లూప్ అనే నిర్మాణం మద్దతు.

162
00:12:52,120 --> 00:12:54,800
'Foreach' లూప్, కేవలం లూప్ 'కోసం' ఒక వంటిది

163
00:12:54,800 --> 00:12:59,080
కానీ విషయాలు చదవదగ్గ చేయడానికి వాక్యనిర్మాణ చక్కెర బిట్ జతచేస్తుంది.

164
00:12:59,080 --> 00:13:03,690
ఇక్కడ, మేము '$ శ్రేణి' అని ఒక కొత్త శ్రేణి సృష్టిస్తున్నారు.

165
00:13:03,690 --> 00:13:10,090
ఇప్పుడు మేము (సంఖ్య $ వంటి $ శ్రేణి), foreach చెప్పగలను,

166
00:13:10,090 --> 00:13:12,390
మరియు మేము $ సంఖ్య అవ్ట్ ముద్రించవచ్చు.

167
00:13:12,390 --> 00:13:20,650
మేము ఈ ఫైల్ అమలు చేసినప్పుడు - php foreach.php-మేము తన సొంత లైన్ ప్రతి సంఖ్య చూడగలరు.

168
00:13:20,650 --> 00:13:26,700
>> మేము సి కోడ్ రాసినప్పుడే అది తరచుగా ప్రత్యేక ఫైళ్లు లోకి మా కోడ్ నిర్వహించడానికి ఉపయోగపడే.

169
00:13:26,700 --> 00:13:29,170
PHP లో, మేము అదే విషయం చేయవచ్చు.

170
00:13:29,170 --> 00:13:33,870
లెట్ యొక్క మేము math.php పిలువబడే ఒక ఫైల్ లో కొన్ని విధులు అని.

171
00:13:33,870 --> 00:13:38,900
నేను, calculator.php వంటి, మరొక PHP ఫైలు లో ఆ విధులు ఉపయోగించడానికి కావాలా

172
00:13:38,900 --> 00:13:44,110
నేను PHP యొక్క require_once () ఫంక్షన్ ఉపయోగించవచ్చు.

173
00:13:44,110 --> 00:13:47,110
Require_once కేవలం # ఉన్నాయి వంటిది.

174
00:13:47,110 --> 00:13:52,050
ఒక ఫైల్ ఒక మార్గం ఇచ్చినపుడు, అది తప్పనిసరిగా విషయాలు కాపీ మరియు పేస్ట్ ఉంటుంది

175
00:13:52,050 --> 00:13:54,930
ప్రస్తుత ఫైల్ ఆ ఫైలు యొక్క.

176
00:13:54,930 --> 00:14:00,150
Require_once, ప్రతి ఫైల్ మాత్రమే ఒకసారి ప్రస్తుత ఫైల్లోకి చేర్చబడింది నిర్ధారిస్తుంది

177
00:14:00,150 --> 00:14:05,680
మీరు ప్రతి ఇతర అవసరం PHP ఫైళ్లు పెద్ద సేకరణ కలిగి ఉంటే ఇది తోడ్పడుతుంది.

178
00:14:05,680 --> 00:14:07,750
యొక్క ఒక ఉదాహరణ పరిశీలించి లెట్.

179
00:14:07,750 --> 00:14:12,620
ఇక్కడ మేము నేను మరొక ఫైల్ లో ఉపయోగించడానికి చెయ్యాలనుకునే విధులు సమూహాన్ని కలిగి.

180
00:14:12,620 --> 00:14:14,990
యొక్క మేము వాటిని ఉపయోగించవచ్చు ఎలా పరిశీలించి లెట్.

181
00:14:14,990 --> 00:14:20,700
లైన్ 3 న, మేము math.php అవసరం ఉంటాయి.

182
00:14:20,700 --> 00:14:27,170
'__DIR__' ప్రస్తుత డైరెక్టరీ ప్రాతినిధ్యం ప్రత్యేక స్థిరంగా

183
00:14:27,170 --> 00:14:33,440
math.php మరియు calculator.php అదే డైరెక్టరీలో ఉన్న కనుక.

184
00:14:33,440 --> 00:14:38,010
మేము math.php అవసరం తరువాత, మేము విధులు ఉపయోగించవచ్చు

185
00:14:38,010 --> 00:14:41,690
 ఒకవేళ మేము calculator.php వాటిని నిర్వచించవచ్చు చేసిన.

186
00:14:41,690 --> 00:14:47,440
లెట్ యొక్క 'php calculator.php' తో ఈ అమలు. గ్రేట్!

187
00:14:47,440 --> 00:14:50,880
>> ఇది PHP యొక్క సింటాక్స్ మా పరిచయం కోసం ఆ.

188
00:14:50,880 --> 00:14:53,700
మరింత తెలుసుకోవడానికి, PHP.net తనిఖీ.

189
00:14:53,700 --> 00:14:59,470
PHP అంతర్నిర్మిత ఫంక్షన్లు చాలా ఉంది, మరియు అదృష్టవశాత్తూ దాని డాక్యుమెంటేషన్ నిజంగా గొప్ప ఉంది.

190
00:14:59,470 --> 00:15:02,680
నా పేరు టామీ ఉంది, మరియు ఈ CS50 ఉంది.

191
00:15:02,680 --> 00:15:04,680
[CS50.TV]

192
00:15:04,680 --> 00:15:14,000
>> ... బ్రాకెట్, నేను గది బయట రెడీ. ఇది డామన్! ఈ నేను కోడ్ పెద్ద పదాలు ఉపయోగిస్తారు గత వీడియో.