1
00:00:00,000 --> 00:00:05,340

2
00:00:05,340 --> 00:00:07,370
>> ડો LLOYD: તેથી અમે કર્યું
સી કામ ઘણું કર્યું,

3
00:00:07,370 --> 00:00:09,536
અને C ખરેખર ઠંડી છે
ભાષા તે તમને આપે છે કારણ કે

4
00:00:09,536 --> 00:00:12,840
ખરેખર ડાઇવ કરવાની ક્ષમતા
તમારા કાર્યક્રમો ઓછી સ્તરે.

5
00:00:12,840 --> 00:00:16,810
અમે વસ્તુઓ કરવા માટે વિચાર
હેરફેર તરીકે ખરેખર મિનિટ

6
00:00:16,810 --> 00:00:18,800
મેમરી વ્યક્તિગત બાઇટ્સ.

7
00:00:18,800 --> 00:00:21,420
ખરેખર પોઇન્ટર છે કે રિકોલ
અમને જે રાહત પરવાનગી આપે છે.

8
00:00:21,420 --> 00:00:25,260
>> પરંતુ અમે હંમેશા હોય જરૂર નથી
વિગતવાર કે દંડ અનાજ સ્તર

9
00:00:25,260 --> 00:00:26,820
અમારા કાર્યક્ર?

10
00:00:26,820 --> 00:00:28,210
કદાચ નથી, અધિકાર?

11
00:00:28,210 --> 00:00:30,376
અને અમે જઈ રહ્યાં છો, તો
હોવા વચ્ચે મડાગાંઠ

12
00:00:30,376 --> 00:00:32,911
ખરેખર, ખરેખર કરવા માટે સમર્થ
મિનિટ વસ્તુઓ અને ખરેખર, ખરેખર

13
00:00:32,911 --> 00:00:35,910
અમે લાગે છે નથી કે મોટી વસ્તુઓ
વિશે, અમે અમલ કરવા માટે નથી

14
00:00:35,910 --> 00:00:40,290
આ ખરેખર મોટા વિચારો તો
તેઓ પહેલેથી જ, આપણા માટે માં બાંધવામાં રહ્યાં છો

15
00:00:40,290 --> 00:00:43,980
સામાન્ય રીતે મોટા બનાવવા માટે
કાર્યક્રમો અથવા મોટા પ્રોજેક્ટ,

16
00:00:43,980 --> 00:00:49,130
અમે કદાચ બાજુ પર ભૂલ કરવી જઈ રહ્યાં છો
વધુ ભાષા સામગ્રી બનાવવામાં કર્યા

17
00:00:49,130 --> 00:00:51,300
અમારા માટે, તેના બદલે કર્યા
નીચા-સ્તર સામગ્રી.

18
00:00:51,300 --> 00:00:53,970
PHP, ખરેખર આવે છે અને તે છે.

19
00:00:53,970 --> 00:00:58,200
>> હવે, એક કારણો
અમે CS50 PHP, શીખવે છે કે

20
00:00:58,200 --> 00:01:01,020
તે ભારે દ્વારા પ્રેરિત છે છે કે
સી અને હકીકતમાં, મારા મતે,

21
00:01:01,020 --> 00:01:05,140
બે ખરેખર છે
પૂર્વજ ભાષાઓ કે

22
00:01:05,140 --> 00:01:08,200
હવે ખૂબ જ સામાન્ય છે.

23
00:01:08,200 --> 00:01:10,110
સી અને તોતડાવું.

24
00:01:10,110 --> 00:01:13,280
અને તેઓ પૂર્વજ ભાષાઓ છો
દરેક અન્ય આધુનિક પ્રોગ્રામિંગ કારણ કે

25
00:01:13,280 --> 00:01:17,380
વિકસાવ્યું છે કે ભાષા
ત્યારથી પ્રેરિત છે

26
00:01:17,380 --> 00:01:20,330
એક અથવા અન્ય વાક્યરચના અનુસાર છે.

27
00:01:20,330 --> 00:01:26,160
PHP, વાક્યરચના અનુસાર ખૂબ સમાન છે
સે સ્કીમ જેવી ભાષાઓ જ્યારે,

28
00:01:26,160 --> 00:01:27,900
ઉદાહરણ તરીકે, જે
તમે સાંભળ્યું હશે

29
00:01:27,900 --> 00:01:32,070
ભારે ભાષા દ્વારા પ્રેરિત છે
જૂની ભાષા છે, જે કહેવાય તોતડાવું.

30
00:01:32,070 --> 00:01:34,220
>> આપણે શીખવે કારણ તેથી
CS50 માં PHP છે,

31
00:01:34,220 --> 00:01:37,730
મૂળભૂત તરીકે સી જાણીને દ્વારા
જો તમે આ બિંદુએ કરવા માટે,

32
00:01:37,730 --> 00:01:41,280
તમે આપે છે અપ ચૂંટતા PHP,
ખૂબ ઊંચા સ્તર વસ્તુઓ કરવા માટે ક્ષમતા

33
00:01:41,280 --> 00:01:44,710
સી કરતાં નથી,
કે અંતરાય ખૂબ

34
00:01:44,710 --> 00:01:48,230
જો તમે પહેલાથી જ હોય ​​છે, કારણ કે
આ વાક્યરચના મૂળભૂત વિચાર.

35
00:01:48,230 --> 00:01:50,590
સી લગભગ માટે આસપાસ કરવામાં આવી છે
આ બિંદુએ 45 વર્ષ.

36
00:01:50,590 --> 00:01:52,780
PHP, લગભગ 20 વર્ષ માટે આસપાસ કરવામાં આવી છે.

37
00:01:52,780 --> 00:01:57,080
અને તે 25 વર્ષ
, પ્રોગ્રામરો વચ્ચે

38
00:01:57,080 --> 00:02:01,540
નક્કી છે કે તેઓ ખૂબ કરશે
તેના બદલે, ઉચ્ચ સ્તર ક્ષમતા ધરાવે છે

39
00:02:01,540 --> 00:02:04,970
અને ભૂલો અને સંઘર્ષ
વચ્ચે 20 વર્ષ

40
00:02:04,970 --> 00:02:08,210
PHP, અને અન્ય આધુનિક ભાષાઓમાં થયો હતો.

41
00:02:08,210 --> 00:02:11,039
>> PHP, એક મહાન પસંદગી
સોફ્ટવેર ભાષા

42
00:02:11,039 --> 00:02:14,042
માટે allow-- કે
જ્યાં તમે કે સોફ્ટવેર

43
00:02:14,042 --> 00:02:16,250
કે વસ્તુઓ કરવાની જરૂર છે
સી ખરેખર જટિલ છે.

44
00:02:16,250 --> 00:02:18,480
તેથી, ઉદાહરણ તરીકે, કામ
સી શબ્દમાળાઓ સાથે

45
00:02:18,480 --> 00:02:21,709
કારણ કે ખૂબ જ જટિલ છે
આપણે જાણીએ છીએ, સી શબ્દમાળાઓ

46
00:02:21,709 --> 00:02:23,250
ખરેખર અક્ષરો માત્ર એરે છે.

47
00:02:23,250 --> 00:02:25,230
તે આંતરિક માહિતી પ્રકાર નથી.

48
00:02:25,230 --> 00:02:28,220
અથવા કદાચ વધુ મૂળભૂત
અમે પણ સી આવરી ન હતી કંઈક

49
00:02:28,220 --> 00:02:30,360
તમે શું કરવાની જરૂર છે, તો શું
કેટલાક કમ્પ્યુટર નેટવર્કિંગ?

50
00:02:30,360 --> 00:02:30,860
બધા અધિકાર?

51
00:02:30,860 --> 00:02:34,920
>> સી તે કરવા માટે ક્ષમતા હોય છે, પરંતુ તે છે
Arcane અને ખરેખર આમ કરવા માટે મુશ્કેલ છે.

52
00:02:34,920 --> 00:02:37,580
તે તો સરસ નહિં હોય
ભાષા આંતરિક, સરળ રીત હતી

53
00:02:37,580 --> 00:02:38,910
નેટવર્કિંગ અમલ કરવા માટે?

54
00:02:38,910 --> 00:02:43,420
અને PHP કે બનાવે છે કે જે ભાષા છે,
અથવા, તે તદ્દન થોડી વધુ કરે છે.

55
00:02:43,420 --> 00:02:47,740
હું જણાવ્યું હતું કે, PHP ખૂબ જ ભારે પ્રેરિત છે
સી દ્વારા વાક્યરચના ખૂબ સમાન છે.

56
00:02:47,740 --> 00:02:51,760
અને તેથી તે આસ્થાપૂર્વક કરવી જોઈએ
એક અન્ય સંક્રમણ

57
00:02:51,760 --> 00:02:54,710
કેટલાક કરતાં થોડી નરમ
અન્ય ભાષાઓમાં હોઈ શકે છે.

58
00:02:54,710 --> 00:02:58,800
>> PHP, લખવાનું શરૂ કરવા માટે, માત્ર ખોલો
આ .PHP ફાઇલ એક્સ્ટેંશન સાથે ફાઇલ.

59
00:02:58,800 --> 00:03:00,670
ટેક્નિકલ આ ​​નથી
ખરેખર જરૂરી છે,

60
00:03:00,670 --> 00:03:04,495
પરંતુ તમે વાક્યરચના જેવી વસ્તુઓ કરવા માંગો છો તો
કે પ્રકાર, જેથી IDE માં પ્રકાશ

61
00:03:04,495 --> 00:03:07,620
નામો, અથવા ચલ નામો, કાર્યો,
તમે ભાષાના કીવર્ડ્સ ખબર

62
00:03:07,620 --> 00:03:10,090
એક માં પ્રકાશિત થાય છે
ચોક્કસ રંગ, તમે સામાન્ય રીતે

63
00:03:10,090 --> 00:03:14,020
સાથે તમારા ફાઈલોની નામ આપવા માંગો છો
ચોક્કસ ફાઇલ એક્સ્ટેંશન.

64
00:03:14,020 --> 00:03:18,430
તેથી અમે એક .PHP સાથે અમારી નામની ફાઇલ કર્યું
વિસ્તરણ, પરંતુ તે પછી પણ PHP, સાથે,

65
00:03:18,430 --> 00:03:23,310
અમે તે લખી તમામ PHP કોડ
ફાઇલ આ PHP, માં બંધ કરી શકાય છે

66
00:03:23,310 --> 00:03:25,190
અમે જુઓ કે વિભાજકો
અહીં સ્ક્રીન પર.

67
00:03:25,190 --> 00:03:27,910
કોણ કૌંસ? PHP શરૂ કરવા માટે.

68
00:03:27,910 --> 00:03:30,860
પછી અમે અમારી PHP ની તમામ લખવા
અમે વચ્ચે માંગો છો તે કોડ.

69
00:03:30,860 --> 00:03:32,260
અને પછી ?

70
00:03:32,260 --> 00:03:34,710
કોણ કૌંસ બંધ કરો.

71
00:03:34,710 --> 00:03:37,170
>> અમે આ, તો પછી ન હોય તો
શું ચાલી રહ્યું છે?

72
00:03:37,170 --> 00:03:38,170
તે તૂટી રહ્યું નથી.

73
00:03:38,170 --> 00:03:39,410
તે ચાલી રહ્યું છે
ખરેખર અમારા કાર્યક્રમ વિનાશ.

74
00:03:39,410 --> 00:03:41,440
પરંતુ તે ચાલી રહ્યું છે
અમે માંગો છો તે અસર કરે છે.

75
00:03:41,440 --> 00:03:44,540
થાય છે શું થઈ રહ્યું છે, ખરેખર, છે
અમે પ્રયાસ અને આ કાર્યક્રમ ચલાવો ત્યારે,

76
00:03:44,540 --> 00:03:50,330
બધું નથી તે વિભાજકો વચ્ચે
અક્ષરશઃ છપાયેલ કરી રહ્યું છે.

77
00:03:50,330 --> 00:03:52,210
તે ચાલી રહ્યું છે
વાસ્તવમાં કોડ ચલાવો,

78
00:03:52,210 --> 00:03:56,010
તે ચાલી રહ્યું છે માત્ર
અક્ષરશઃ તે છાપે.

79
00:03:56,010 --> 00:03:57,320
>> હવે શા માટે બને છે?

80
00:03:57,320 --> 00:04:00,416
તેથી સી ઓળખાય છે
એક સંકલિત ભાષા તરીકે.

81
00:04:00,416 --> 00:04:03,040
તમે કદાચ સાથે પરિચિત છો
તમારા કાર્યક્રમો બનાવવા પગલું

82
00:04:03,040 --> 00:04:07,820
સી ફાઇલો અને ક ફાઇલો દેવાનો
મેક સાથે એક એક્ઝેક્યુટેબલ માં,

83
00:04:07,820 --> 00:04:11,130
ખાસ કરીને ઉપયોગ
અમારા કમ્પાઇલર તરીકે રણકાર.

84
00:04:11,130 --> 00:04:13,030
PHP, છતાં, નથી
આ સમકક્ષ હોય છે.

85
00:04:13,030 --> 00:04:15,600
PHP, એક કહેવાય છે તે છે
અર્થઘટન ભાષા.

86
00:04:15,600 --> 00:04:16,760
અને તે શું અર્થ છે?

87
00:04:16,760 --> 00:04:20,680
>> વેલ, તે અમે કન્વર્ટ કરવાની જરૂર નથી એનો અર્થ એ થાય
zeros અને ચામાં અમારા સ્રોત કોડ

88
00:04:20,680 --> 00:04:21,470
અગાઉથી.

89
00:04:21,470 --> 00:04:23,900
તેના બદલે, એક કાર્યક્રમ છે,
જે પણ કહેવામાં આવે છે

90
00:04:23,900 --> 00:04:29,771
PHP, અને સમજે છે કે PHP,
પ્રકારની ફ્લાય પર કરી શકો છો.

91
00:04:29,771 --> 00:04:32,520
તે ખરેખર બરાબર ચોક્કસ નથી
પરંતુ તે એક ખૂબ સારી સાદ્રશ્ય છે

92
00:04:32,520 --> 00:04:33,760
ના ચાલી રહ્યું છે તે.

93
00:04:33,760 --> 00:04:37,230
તે તે ઈન્ટરપ્રીટ છે
ફ્લાય પર zeroes અને મુદ્દાઓ પર પણ.

94
00:04:37,230 --> 00:04:40,160
અને તેથી જો તે ખબર નથી
કેવી રીતે કંઈક પ્રક્રિયા,

95
00:04:40,160 --> 00:04:42,800
તે ખબર નથી તો કેવી રીતે
પ્રક્રિયા PHP, તો તમે કદાચ

96
00:04:42,800 --> 00:04:44,680
અધિકાર, ત્યાં છે કે જે લખાણ મૂકવા માગે છે?

97
00:04:44,680 --> 00:04:48,960
>> તમે કદાચ કોડ મૂકવા માગે છે
ત્યાં, તે PHP-- વચ્ચે નથી, પણ જો

98
00:04:48,960 --> 00:04:50,035
PHP, વિભાજકો.

99
00:04:50,035 --> 00:04:51,910
પરંતુ છે તેથી તે ચાલી રહ્યું છે
તે તમારા માટે કાઢી નાંખવા માટે,

100
00:04:51,910 --> 00:04:53,576
તે માત્ર મૂળભૂત રીતે તે કાઢી રહ્યું છે.

101
00:04:53,576 --> 00:04:55,550
તેથી તે છાપી રહ્યું છે
તે સ્ક્રીન પર બહાર.

102
00:04:55,550 --> 00:04:57,150
>> તે ખરાબ છે, જેમ કે આ લાગે છે
વસ્તુ છે, પરંતુ વાસ્તવમાં તે છે

103
00:04:57,150 --> 00:04:58,220
ખરેખર હોઈ ચાલે
સારી વાત છે, અમે પડશે

104
00:04:58,220 --> 00:05:00,390
અમે વિશે વાત ત્યારે જોવા
PHP, વેબ વિકાસ,

105
00:05:00,390 --> 00:05:04,010
તે અર્થ એ થાય છે, કારણ કે અમે કરી શકો છો
PHP, અને HTML વિવિધતા લાવવી.

106
00:05:04,010 --> 00:05:06,640
અમે તેમને એકસાથે ઉપયોગ કરી શકો છો
એક વધુ ગતિશીલ વેબ પાનું બનાવો.

107
00:05:06,640 --> 00:05:10,650
પરંતુ તે પર વધુ
PHP, વેબ વિકાસ પર વિડિઓ.

108
00:05:10,650 --> 00:05:12,021
>> તેથી PHP ની સિન્ટેક્ષ શું છે?

109
00:05:12,021 --> 00:05:13,520
કે આ વિડિઓ વિશે બધા શું છે.

110
00:05:13,520 --> 00:05:14,850
ચાલો તે વિશે વાત કરો.

111
00:05:14,850 --> 00:05:16,490
>> તેથી, ચલો શરૂ કરવા માટે.

112
00:05:16,490 --> 00:05:18,030
PHP, ચલો અસ્તિત્વ ધરાવે છે.

113
00:05:18,030 --> 00:05:20,067
માત્ર મોટા બે છે
સી તફાવતો

114
00:05:20,067 --> 00:05:21,900
પ્રથમ છે તે છે
કોઈ પ્રકાર specifier.

115
00:05:21,900 --> 00:05:24,245
અમે પૂર્ણાંક કહેવું નથી
ઘરનાં પરચૂરણ કામો, ફ્લોટ, કે જે બધી સામગ્રી.

116
00:05:24,245 --> 00:05:25,620
અમે હવે તે કરવા માટે નથી.

117
00:05:25,620 --> 00:05:26,810
PHP, આધુનિક ભાષા છે.

118
00:05:26,810 --> 00:05:28,910
તે તમે છો તે બહાર આકૃતિ કરી શકો છો
અથવા એક શ્રેષ્ઠ બનાવવા માટે પ્રયાસ કરી

119
00:05:28,910 --> 00:05:30,451
તમે કરવા પ્રયાસ કરી રહ્યાં છો, તે માટે ધારી.

120
00:05:30,451 --> 00:05:31,700
તેથી તે ખૂબ સરસ છે.

121
00:05:31,700 --> 00:05:35,330
>> અન્ય વસ્તુ બધા ચલ છે
નામો ડોલર સાઇન સાથે શરૂ કરવા માટે હોય છે.

122
00:05:35,330 --> 00:05:36,940
તે માટે ઉપયોગ કરો ફક્ત કંઈક છે.

123
00:05:36,940 --> 00:05:39,496
તે છે, કારણ કે થોડો વિચિત્ર છે
PHP, સમજી શકે છે કે જેથી તે

124
00:05:39,496 --> 00:05:40,870
શું એક ચલ છે અને શું નથી.

125
00:05:40,870 --> 00:05:43,340
તેથી દરેક ચલ નામ
ડોલર સાઇન સાથે શરૂ થાય છે.

126
00:05:43,340 --> 00:05:46,884
તેથી સી અમે કંઈક કહી શકે છે
આ જેમ, પૂર્ણાંક એક્સ = 54.

127
00:05:46,884 --> 00:05:48,550
અમે PHP માં હવે તે કરવા માટે નથી.

128
00:05:48,550 --> 00:05:52,540
અમે હમણાં જ એક્સ = 54 $ કહી શકો છો.

129
00:05:52,540 --> 00:05:55,920
અને અમે સી, ઉદાહરણ તરીકે, કહી શકે છે,
અમે CS50 ક પાઉન્ડ સમાવવામાં હતી તો

130
00:05:55,920 --> 00:06:00,314
હેડર ફાઈલ, આપણે કહી શકીએ
શબ્દમાળા શબ્દસમૂહ = "આ CS50 છે."

131
00:06:00,314 --> 00:06:01,980
અમે જોકે PHP, માં તે કરવા માટે નથી.

132
00:06:01,980 --> 00:06:04,865
અમે હમણાં જ $ શબ્દસમૂહ કહી શકો છો
= "આ CS50 છે."

133
00:06:04,865 --> 00:06:08,760
અને હકીકતમાં, શબ્દમાળા હવે
PHP, એક આંતરિક માહિતી પ્રકાર,

134
00:06:08,760 --> 00:06:10,950
અથવા બદલે PHP સમજે
શબ્દમાળા શું છે.

135
00:06:10,950 --> 00:06:15,612
તે એક એરે અલગ છે
અક્ષરો તે સી માં છે જેમ

136
00:06:15,612 --> 00:06:17,570
તમારા બધા મનપસંદ
સી થી શરતી નિવેદનો

137
00:06:17,570 --> 00:06:19,520
હજુ પણ તમે ઉપયોગ કરવા માટે ઉપલબ્ધ છે.

138
00:06:19,520 --> 00:06:21,140
તેથી ત્યાં કોઈ મોટા સંક્રમણ.

139
00:06:21,140 --> 00:06:23,400
અમે કરી શકો છો કહેવું કરી શકો છો
આ જેમ નિવેદનો તો.

140
00:06:23,400 --> 00:06:28,210
$ વાય 43 જો, અથવા $ Z = 15.

141
00:06:28,210 --> 00:06:29,690
તેથી તે ખૂબ સરળ છે.

142
00:06:29,690 --> 00:06:31,980
અમે તો અને બીજું હોઈ શકે છે.

143
00:06:31,980 --> 00:06:34,210
અમે તો બીજું તો કરી શકે છે.

144
00:06:34,210 --> 00:06:36,430
>> અને કંઈક નોટિસ
ખૂબ અહીં સરસ છે, અને આ

145
00:06:36,430 --> 00:06:39,620
તે એક પ્રકારની છે
સી, નોટિસ વિરુદ્ધ PHP ની લાભો

146
00:06:39,620 --> 00:06:41,510
શું કાર્ય અમે અહીં ઉપયોગ કરી રહ્યાં છો?

147
00:06:41,510 --> 00:06:47,737
અમે એક સરખાવવા માટે == ઉપયોગ કરી રહ્યાં છો
ચલ, $ નામ, શબ્દમાળા છે.

148
00:06:47,737 --> 00:06:49,070
અમે અધિકાર, સી કે ન કરી શકે?

149
00:06:49,070 --> 00:06:53,200
અમે કહેવાય કાર્ય વાપરવા માટે હતી
StrComp અથવા StrEndComp અથવા કોઈપણ

150
00:06:53,200 --> 00:06:54,840
તેના સંબંધિત પિત્રાઈ ભાઈઓ.

151
00:06:54,840 --> 00:06:56,980
>> અને તેથી પહેલેથી જ અમે આ લાભ જુઓ.

152
00:06:56,980 --> 00:07:00,930
અમે કંઈક કરવાની જરૂર નથી
તરીકે અવિવેકી અથવા કદાચ unintuitive

153
00:07:00,930 --> 00:07:03,540
કહેવાય કાર્ય કૉલ
StrComp હું માત્ર પરીક્ષણ કરવા માંગો છો તો

154
00:07:03,540 --> 00:07:05,237
કે શું કિંમત એક શબ્દમાળા સમકક્ષ હોય છે.

155
00:07:05,237 --> 00:07:07,820
હું માત્ર સમકક્ષ સમકક્ષ હોય છે ઉપયોગ કરી શકે છે
જેમ હું બીજું કાંઇ કરી શકે છે.

156
00:07:07,820 --> 00:07:09,560
તેથી એક લાભ છે.

157
00:07:09,560 --> 00:07:13,350
>> કેટલીકવાર, માર્ગ દ્વારા, તમે કદાચ
elseif, બીજું તો એક શબ્દ જુઓ.

158
00:07:13,350 --> 00:07:14,910
અને તે તેમજ PHP, માં બરાબર છે.

159
00:07:14,910 --> 00:07:17,020
તેથી ક્યારેક તમે તે જોઈ શકે છે.

160
00:07:17,020 --> 00:07:17,790
તે ટાઈપો નથી.

161
00:07:17,790 --> 00:07:21,830
PHP, ખરેખર elseif સમજે છે.

162
00:07:21,830 --> 00:07:23,980
મને ખબર નથી કે શા માટે તેઓ
કે અમલ કરવાનો નિર્ણય લીધો,

163
00:07:23,980 --> 00:07:28,220
પરંતુ અમે ઘણી વખત જોઇ છે
અત્યાર સુધી અમારી વિડિઓઝ દરમ્યાન,

164
00:07:28,220 --> 00:07:30,460
અમે પ્રોગ્રામરો તો તેને પ્રેમ
અમે ઝડપથી વસ્તુઓ કરી શકો છો

165
00:07:30,460 --> 00:07:33,660
જેથી જગ્યા છૂટકારો મેળવવામાં
દેખીતી રીતે એક મોટો લાભ છે.

166
00:07:33,660 --> 00:07:34,800
>> તેથી તે તો elseif છે.

167
00:07:34,800 --> 00:07:37,540
અમે પણ ત્રિપુટી ઓપરેટર છે,
રિકોલ પ્રશ્ન ચિહ્ન કોલોન,

168
00:07:37,540 --> 00:07:43,262
બીજું જો ખરેખર ટૂંકા સ્વરૂપ માટે
અથવા શરતી શાખા.

169
00:07:43,262 --> 00:07:45,470
અને દેખીતી રીતે, આ માં,
અમે શું અહીં શું કરવા પ્રયાસ કરી રહ્યાં છો

170
00:07:45,470 --> 00:07:49,720
ચલ સોંપી છે
સાચું કે ખોટું ક્યાં $ પત્ર

171
00:07:49,720 --> 00:07:54,110
$ var તેના પર આધાર રાખીને
એ વર્ણમાળાનો અક્ષર છે.

172
00:07:54,110 --> 00:07:57,320
તેથી આ isalpha માટે ખૂબ સમાન છે
અમે સી થી પરિચિત છો કે

173
00:07:57,320 --> 00:07:59,010
આ PHP માં સમકક્ષ જેવું છે.

174
00:07:59,010 --> 00:08:01,550
આ કાર્ય દેખીતી રીતે છે
ctype_alpha કહેવાય છે,

175
00:08:01,550 --> 00:08:03,450
પરંતુ અમે PHP, માં કેવી રીતે કરવું તે છે.

176
00:08:03,450 --> 00:08:08,560
તેથી આ બધા તો હોઈ રહ્યું છે
$ Var પત્ર છે, $ પત્ર સાચું છે.

177
00:08:08,560 --> 00:08:13,820
$ Var પત્ર ન હોય તો,
$ પત્ર ખોટું છે.

178
00:08:13,820 --> 00:08:15,820
>> અમે હજુ પણ સ્વીચ નિવેદનો છે.

179
00:08:15,820 --> 00:08:17,870
અમે સી તે તેમજ યાદ અપાવે છે.

180
00:08:17,870 --> 00:08:22,480
ત્યાં ખૂબ જ ટોચ પર, કે જે આપણે કેવી રીતે
વિચાર પૂર્ણાંક અથવા શબ્દમાળા વિચાર કંઈક.

181
00:08:22,480 --> 00:08:23,845
તેથી PHP, માં બાંધવામાં કે છે.

182
00:08:23,845 --> 00:08:25,470
અમે હવે CS50 પુસ્તકાલય જરૂર નથી.

183
00:08:25,470 --> 00:08:27,237
અમે હમણાં જ કાર્ય readline વાપરી શકો છો.

184
00:08:27,237 --> 00:08:29,820
શું કે શું થઈ રહ્યું પ્રિન્ટ છે
સંદેશ બહાર, "તમારા રાજ્ય,

185
00:08:29,820 --> 00:08:33,820
કૃપા કરીને "અને પછી પ્રોમ્પ્ટ ખીલેલું
ઇનપુટ વપરાશકર્તા માટે રાહ જોઈ રહ્યું

186
00:08:33,820 --> 00:08:34,739
કેટલીક માહિતી.

187
00:08:34,739 --> 00:08:36,530
હવે શું બીજું નોટિસ
અમે સ્વીચ સાથે કરી શકો છો.

188
00:08:36,530 --> 00:08:39,105
તમે તે પહેલાં ઉપયોગ કર્યો છે,
તમે તે સ્વીચ યાદ કરી શકે છે

189
00:08:39,105 --> 00:08:44,960
પૂર્ણાંકો માટે ખૂબ ખૂબ મર્યાદિત છે અને
અક્ષરો છે, પરંતુ હવે અમે શબ્દમાળાઓ વાપરી શકો છો.

190
00:08:44,960 --> 00:08:50,190
અને હકીકતમાં, આ સ્વીચ નિવેદન
PHP, માં ખૂબ થોડી વધુ સરળ છે

191
00:08:50,190 --> 00:08:54,880
સી તેના પિતરાઇ કરતાં

192
00:08:54,880 --> 00:08:55,380
આંટીઓ.

193
00:08:55,380 --> 00:08:58,130
જસ્ટ શરતો જેમ, બધા
તમારા જૂના ફેવરિટ ત્યાં હજુ પણ છે.

194
00:08:58,130 --> 00:09:00,740
અમે ગણતરી જ્યારે આંટીઓ છે
1 થી આ કિસ્સામાં 100.

195
00:09:00,740 --> 00:09:03,940
અમે જ્યારે આંટીઓ કરી છે
કે, 1 થી 100 ગણક

196
00:09:03,940 --> 00:09:06,200
અને અમે આંટીઓ માટે છે
કે 1 થી 100 ગણક.

197
00:09:06,200 --> 00:09:07,220
તેથી ત્યાં કોઈ મોટો કૂદકો.

198
00:09:07,220 --> 00:09:09,360
વાક્યરચના ખૂબ છે
બરાબર એ જ ખૂબ,

199
00:09:09,360 --> 00:09:11,760
હવે અમે ઉપયોગ કરી રહ્યાં છો સિવાય
ડોલર સાઇન ચલ બદલે

200
00:09:11,760 --> 00:09:17,260
પૂર્ણાંક ચલો જાહેર અથવા
અમારા ગણકો માટે કંઈક હોય છે.

201
00:09:17,260 --> 00:09:20,090
>> વસ્તુઓ વિચાર અહીં છે જ્યાં
છતાં, સી કરતાં ઘણો વધુ સારી.

202
00:09:20,090 --> 00:09:21,020
એરે.

203
00:09:21,020 --> 00:09:23,020
તેથી અમે હતા યાદ છે જ્યારે
ક્રમમાં સી વિશે વાત

204
00:09:23,020 --> 00:09:25,560
અમને વૃદ્ધિ અને સંકોચો માટે
માહિતી સમૂહો,

205
00:09:25,560 --> 00:09:28,310
અમે મૂળભૂત સૉર્ટ કરવા માટે જરૂરી
એક કડી થયેલ યાદી આ વિચાર કરવા માટે,

206
00:09:28,310 --> 00:09:30,780
સી એરે કદ નક્કી કરવામાં આવી હતી કારણ કે.

207
00:09:30,780 --> 00:09:31,800
અમે તેમને સંકોચો કરી શકે છે.

208
00:09:31,800 --> 00:09:32,930
અમે તેમને વૃદ્ધિ કરી શકે છે.

209
00:09:32,930 --> 00:09:36,074
અમે મેમરી ફરી ફાળવવા માટે હતી
અને આ બધા ગાંડપણ કરી

210
00:09:36,074 --> 00:09:38,490
અથવા કડી થયેલ યાદીઓ, ઉપયોગ કરે છે
તદ્દન થોડી વધુ જગ્યા લે છે.

211
00:09:38,490 --> 00:09:41,590
પરંતુ PHP માં, એરે છે
હવે કદ નિશ્ચિત નથી.

212
00:09:41,590 --> 00:09:43,240
તેઓ પ્રગતિ કરી શકે છે અને તેઓ સંકોચો કરી શકો છો.

213
00:09:43,240 --> 00:09:46,660
તેથી ફરીથી, આ 20 વર્ષ અસ્તિત્વમાં છે કે જે
સી પ્રથમ પ્રકાશન વચ્ચે

214
00:09:46,660 --> 00:09:49,440
અને પ્રથમ પ્રકાશન PHP,
અમે તમને ખબર છે, કે જે નિર્ણય લીધો

215
00:09:49,440 --> 00:09:51,670
તે ખરેખર મહાન હશે
અમે આ કરી શકે છે જો.

216
00:09:51,670 --> 00:09:54,100
અને તેથી અમે આ અમલ.

217
00:09:54,100 --> 00:09:58,040
>> તેથી PHP એરે માં ચોક્કસ નથી
કદ, અને PHP નથી, કારણ કે ખરેખર

218
00:09:58,040 --> 00:10:03,090
પ્રોગ્રામર ફ્રન્ટ સામનો છે
પ્રકારના કલ્પના,

219
00:10:03,090 --> 00:10:05,110
અમે ડેટા પ્રકારો ભળવું કરી શકો છો
અમારા એરે માં, પણ.

220
00:10:05,110 --> 00:10:08,100
જેથી અમે પણ બધા ઉપયોગ કરવાની જરૂર નથી
પૂર્ણાંકો અથવા બધું ફ્લોટિંગ પોઇન્ટ,

221
00:10:08,100 --> 00:10:12,826
અમે બધા મિશ્રણ કરી શકે છે
એક એરે માં વિવિધ પ્રકારના.

222
00:10:12,826 --> 00:10:14,700
ઝાકઝમાળ છે જાહેર
ખૂબ સરળ.

223
00:10:14,700 --> 00:10:16,116
તે માત્ર અન્ય કોઇ વેરિયેબલ જેવું છે.

224
00:10:16,116 --> 00:10:20,020
$ Nums = એરે (1, 2, 3,
4) એરે એક કાર્ય છે

225
00:10:20,020 --> 00:10:22,760
કે PHP માં સમાયેલ છે કે
તમારા માટે એક એરે બનાવવા માટે પડશે.

226
00:10:22,760 --> 00:10:28,315
આ ચાર કિંમતો ઝાકઝમાળ બનાવે છે,
આ કિસ્સામાં નંબરો, $ nums કહેવાય છે.

227
00:10:28,315 --> 00:10:29,940
અને તે કરવા એક કરતાં વધુ રીતે છે.

228
00:10:29,940 --> 00:10:32,420
અને અમે જઈ રહ્યાં છો
આ PHP, માં ઘણો જુઓ.

229
00:10:32,420 --> 00:10:36,380
PHP, ઘણા વિવિધ દ્વારા વિકસિત કરવામાં આવી છે
લોકો વધે છે અને વધે છે અને વધે છે.

230
00:10:36,380 --> 00:10:40,050
સામાન્ય રીતે થાય છે માત્ર બે અથવા
PHP, માં કંઈક કરવા માટે ત્રણ રસ્તાઓ,

231
00:10:40,050 --> 00:10:42,170
સામાન્ય રીતે 10 અથવા 20 જેવી છે.

232
00:10:42,170 --> 00:10:45,300
અહીં માત્ર અન્ય સામાન્ય
એક એરે જાહેર રીતે.

233
00:10:45,300 --> 00:10:48,310
$ Nums = ચોરસ કૌંસ 1, 2, 3, 4.

234
00:10:48,310 --> 00:10:53,170
તેથી આ પ્રકારની સી કોણ સમાન છે
તેના બદલે, સર્પાકાર તાણવું નોટેશનમાં br--. $ -

235
00:10:53,170 --> 00:10:58,525
અથવા તે પૂર્ણાંક nums સ્ક્વેર હશે
કૌંસ સર્પાકાર તાણવું 1, 2, 3, 4 સમકક્ષ હોય છે.

236
00:10:58,525 --> 00:11:02,710
PHP માં તે $ nums = ચોરસ છે
કૌંસ 1, 2, 3, 4.

237
00:11:02,710 --> 00:11:08,920
પરંતુ આ ઉદાહરણો બંને અહીં મને આપી
આ કિસ્સામાં પૂર્ણાંકો ચાર ઝાકઝમાળ.

238
00:11:08,920 --> 00:11:10,920
>> હવે હું પર કંઈક ખીલી કરવા શું માંગો છો?

239
00:11:10,920 --> 00:11:14,760
વેલ હું માત્ર $ nums 4 કહી શકો છો, કે જે
ફરીથી, અમે હજુ પણ અહીં 0 થી ગણતરી કરી રહ્યાં છો

240
00:11:14,760 --> 00:11:17,800
PHP, માં, પાંચમી હશે
એરે તત્વ.

241
00:11:17,800 --> 00:11:18,990
હું માત્ર કહે છે કે કરી શકો છો.

242
00:11:18,990 --> 00:11:22,860
હું seg ભોગ માટે નથી જતા છું
મારી એરે ફક્ત છે, કારણ કે દોષ

243
00:11:22,860 --> 00:11:24,337
કે સમાવવા માટે વધવા માટે ચાલુ.

244
00:11:24,337 --> 00:11:25,420
તે સાચું છે, ખૂબ સરસ છે?

245
00:11:25,420 --> 00:11:28,400
અને હકીકતમાં, હું પણ કરવાની જરૂર નથી
હું તેને મૂકવા માંગો છો જ્યાં સ્પષ્ટ કરો.

246
00:11:28,400 --> 00:11:31,220
હું માત્ર આ અને માત્ર કહી શકો છો
અધિકાર અંતે પર ખીલી,

247
00:11:31,220 --> 00:11:34,099
અથવા હું તો માત્ર કરી શકે
$ nums 20 અથવા 1,000 કહે છે.

248
00:11:34,099 --> 00:11:35,140
તે ખરેખર તો કોઈ વાંધો નથી.

249
00:11:35,140 --> 00:11:38,330
તે હજુ પણ માત્ર કરવા જઈ રહ્યું છે
ઓવરને અધિકાર પર ખીલી.

250
00:11:38,330 --> 00:11:41,490
>> તેથી હું ઉગે છે, અને અમે છો as-- કરી શકો છો
તે અહીં આવરી નથી જવાનું,

251
00:11:41,490 --> 00:11:45,360
પરંતુ હું સાંધાવાળા અથવા છીનવી શકે છે
તેમજ એરે બહાર તત્વો,

252
00:11:45,360 --> 00:11:50,064
અને એરે સમાવવા માટે સંકોચો કરશે
કે હવે ખૂટે છે અથવા ખાલી જગ્યા.

253
00:11:50,064 --> 00:11:52,230
કાર્યનીતિ માટે બીજી રીતે પણ છે
ઝાકઝમાળ પર કંઈક,

254
00:11:52,230 --> 00:11:54,330
જે array_push કહેવાય કાર્ય છે.

255
00:11:54,330 --> 00:11:57,860
તેથી ફરી, માત્ર હોવાની આ વિચાર
વસ્તુઓ ઘણા અલગ અલગ રીતે કરવા માટે સમર્થ છે.

256
00:11:57,860 --> 00:12:01,950
તેથી અમે હવે ત્રણ અલગ અલગ રીતે જોઇ
ઝાકઝમાળ પર અન્ય તત્વ ખીલી છે.

257
00:12:01,950 --> 00:12:06,900
તેથી આ અન્ય તત્વ ઉમેરે છે
આ $ nums એરે ઓવરને છે.

258
00:12:06,900 --> 00:12:08,340
અને અમે અમારા ડેટા પ્રકારો ભળવું કરી શકો છો.

259
00:12:08,340 --> 00:12:13,110
તેથી હું નથી ઝાકઝમાળ કરી શકે છે
1, 2, 3, 4, પરંતુ 1, સાચા, 3, 4,

260
00:12:13,110 --> 00:12:16,420
જ્યાં સાચું બુલિયન છે, અને પછી
હું બીજા તત્વ પર ખીલી કરવા માંગો છો, તો

261
00:12:16,420 --> 00:12:20,860
કે એરે, કદાચ એક શબ્દમાળા
શબ્દમાળા "પાંચ" હું તે કરી શકે.

262
00:12:20,860 --> 00:12:26,110
અને હવે મારા એરે કરશે
સાચું 1, 3, 4, પાંચ છે.

263
00:12:26,110 --> 00:12:28,640
આ શબ્દ પાંચ, નથી પૂર્ણાંક 5.

264
00:12:28,640 --> 00:12:31,270
તેથી ત્યાં રાહત ઘણો.

265
00:12:31,270 --> 00:12:33,290
>> રાહત નહીં
પણ સારી છે, છતાં,

266
00:12:33,290 --> 00:12:37,530
PHP, કંઈક માટે આધાર છે, કારણ કે
એક સમૂહનો એરે કહેવાય છે.

267
00:12:37,530 --> 00:12:40,660
અને અમે સૉર્ટ ડાઘ વાત
સી વિશે સમૂહનો એરે

268
00:12:40,660 --> 00:12:44,740
હેશ કોષ્ટકો સંદર્ભમાં, કારણ કે
શું સમૂહનો એરે ખરેખર બધા છે

269
00:12:44,740 --> 00:12:48,950
કી બનાવે છે વિશે
કિંમતની જોડી મેપિંગ્સ.

270
00:12:48,950 --> 00:12:53,410
અને જો આ કિસ્સામાં, keys--
અમે સી થી એરે સાથે પરિચિત છો

271
00:12:53,410 --> 00:12:55,440
કીઓ ઈન્ડેક્સ નંબરો છે.

272
00:12:55,440 --> 00:12:57,530
0, 1, 2, 3.

273
00:12:57,530 --> 00:13:03,070
અને કિંમતો કે અમે શોધવા શું છે
એરે 0, એરે 1, તેથી એરે 2, અને.

274
00:13:03,070 --> 00:13:06,310
તેથી કીઓ નિર્દેશિકાઓની છે,
અને કિંમતો

275
00:13:06,310 --> 00:13:10,060
કે એરે સ્થાન શું છે,
કે ઇન્ડેક્સ દ્વારા સ્પષ્ટ કરેલ છે.

276
00:13:10,060 --> 00:13:15,130
>> પરંતુ PHP, અમે આ કરવા માટે નથી
એરે 0 કલ્પના, એરે 1, એરે 2

277
00:13:15,130 --> 00:13:15,830
હવે.

278
00:13:15,830 --> 00:13:21,025
હવે અમે વાસ્તવિક શબ્દો ઉપયોગ કરી શકો છો
કિંમતો કીઓ મેપ.

279
00:13:21,025 --> 00:13:22,650
અને તેથી હું આ કંઈક કહી શકે છે.

280
00:13:22,650 --> 00:13:26,710
હું ઉપયોગ ઝાકઝમાળ બનાવી શકે છે
નીચે પ્રમાણે ચોરસ કૌંસ વાક્યરચના.

281
00:13:26,710 --> 00:13:30,685
$ Pizzas = ચોરસ કૌંસ
"ચીઝ" અને પછી

282
00:13:30,685 --> 00:13:37,210
ડબલ તીર સંકેત આ પ્રકારની છે,
8.99, "pepperoni," 10.99-- 9.99 તીર

283
00:13:37,210 --> 00:13:37,880
અને તેથી પર.

284
00:13:37,880 --> 00:13:39,060
અને તેથી શું અહીં ચાલી રહ્યું છે?

285
00:13:39,060 --> 00:13:41,040
હું ખરેખર શું કરી રહ્યો છું?

286
00:13:41,040 --> 00:13:43,990
હું કી કિંમતની જોડી જોડણીઓ બનાવી રહ્યો છું.

287
00:13:43,990 --> 00:13:49,060
તેથી તેના બદલે કહેતા, ઉદાહરણ તરીકે,
pizzas 0, ટુકડાઓ 1, pizzas 2,

288
00:13:49,060 --> 00:13:52,350
હવે હું pizzas કહી શકો છો
ચીઝ, pizzas pepperoni,

289
00:13:52,350 --> 00:13:55,120
અને કિંમતો નો સંદર્ભ લો
તેમની સાથે સંકળાયેલ હોય છે.

290
00:13:55,120 --> 00:13:56,970
>> તેથી અહીં અમારા કીઓ લીલા છે.

291
00:13:56,970 --> 00:13:59,870
ચીઝ, pepperoni,
વનસ્પતિ, ભેંસ ચિકન.

292
00:13:59,870 --> 00:14:04,200
અહીં બનાવે છે કે તીર છે
આ કી કિંમતની જોડી મેપિંગ.

293
00:14:04,200 --> 00:14:07,420
અને પછી અહીં કિંમતો છે
કે એરે સ્થાન પર.

294
00:14:07,420 --> 00:14:10,330
તેથી તે એરે 0 8.99 બરાબર કહીને જેવી છે.

295
00:14:10,330 --> 00:14:11,720
કી 0 હોય છે.

296
00:14:11,720 --> 00:14:13,600
કિંમત 8.99 છે.

297
00:14:13,600 --> 00:14:19,370
હવે હું એરે ચીઝ કહે છે, અથવા આ કરી શકો છો
કેસ pizzas ચીઝ, ચીઝ, કી છે

298
00:14:19,370 --> 00:14:23,340
અને હું શું શોધી
pizzas ચીઝ 8.99 છે.

299
00:14:23,340 --> 00:14:25,540
કે હું ત્યાં શોધવા કે મૂલ્ય છે.

300
00:14:25,540 --> 00:14:28,124
>> તેથી હું વસ્તુઓ ગમે કહી શકો છો.
$ પિઝા ચીઝ = 7.99.

301
00:14:28,124 --> 00:14:29,040
હું વેચાણ કર્યા છું.

302
00:14:29,040 --> 00:14:31,750
હું મૂકવા માંગો છો dis-- માંગો છો
ચીઝ પિઝા કિંમત.

303
00:14:31,750 --> 00:14:35,620
અથવા હું વનસ્પતિ ઉપયોગ કરી શકો છો
પિઝા એક શરત ભાગરૂપે

304
00:14:35,620 --> 00:14:39,990
અથવા હું એક નવી તત્વ ઉમેરી શકો છો મારા
અરે, માત્ર હું અગાઉ કરી શકે.

305
00:14:39,990 --> 00:14:44,680
હું આ એક નવી તત્વ ઉમેરી શકો છો
કી "બેકન" સાથે સમૂહનો એરે

306
00:14:44,680 --> 00:14:49,250
અને કિંમત 13,49.

307
00:14:49,250 --> 00:14:53,820
>> પરંતુ આ પ્રકારની સમસ્યા પરિચય
તમે એક બીજા માટે તે વિશે વિચારો તો.

308
00:14:53,820 --> 00:14:55,721
કેવી રીતે અમે આ એરે મારફતે ફરી વળવું કરશે?

309
00:14:55,721 --> 00:14:56,220
અધિકાર?

310
00:14:56,220 --> 00:14:59,820
સી, અમે માત્ર એક હશે
લૂપ માટે, સામાન્ય રીતે તે

311
00:14:59,820 --> 00:15:03,650
આ 0 થી ચાલે છે
1 ઓછા એરે માપ.

312
00:15:03,650 --> 00:15:08,060
એરે પર n તત્વોના છે,
માન્ય નિર્દેશિકાઓની n બાદ 1 0 છે.

313
00:15:08,060 --> 00:15:11,530
તેથી અમે લૂપ માટે ઉપયોગ કરી શકે છે
દરેક એક તત્વ મારફતે પગલું.

314
00:15:11,530 --> 00:15:13,530
>> પરંતુ તે ખરેખર નથી
કેસ હવે, અધિકાર?

315
00:15:13,530 --> 00:15:17,360
હવે અમે કી કિંમત જોડી હોય છે
કીઓ શબ્દો છે જ્યાં જોડણીઓ,

316
00:15:17,360 --> 00:15:19,970
અમે કેવી રીતે બધા જ શબ્દો પર ફરી વળવું નથી?

317
00:15:19,970 --> 00:15:22,420
વેલ, સદભાગ્યે, PHP છે
એક માર્ગ છે, પણ આ સાથે વ્યવહાર કરવા માટે

318
00:15:22,420 --> 00:15:24,580
અને તેથી અમે પાછા આવો પડશે
એક બીજા માટે આંટીઓ માટે

319
00:15:24,580 --> 00:15:30,780
લૂપ ચોથા પ્રકારની રજૂ કરવા કે
PHP, foreach લૂપ કહેવાય હાજર છે.

320
00:15:30,780 --> 00:15:34,430
અને શું એક foreach લૂપ કરે છે
મૂળભૂત રીતે તે જ વિચાર છે.

321
00:15:34,430 --> 00:15:36,060
તમે એરે કોઇ પણ પ્રકારના માટે વાપરી શકો છો.

322
00:15:36,060 --> 00:15:38,100
પરંતુ તે મૂળભૂત રીતે માતાનો
લૂપ માટે જ વિચાર,

323
00:15:38,100 --> 00:15:40,750
બદલે ઉપયોગ સિવાય
ઇન્ડેક્સ નંબરો, તમે માત્ર

324
00:15:40,750 --> 00:15:45,830
આ વિચિત્ર વાક્યરચના જ્યાં છે
તમે દરેક એક તત્વ કૉલ

325
00:15:45,830 --> 00:15:47,550
આ લૂપ હેતુ માટે એક નામ.

326
00:15:47,550 --> 00:15:49,258
>> તેથી આ કિસ્સામાં,
foreach ($ કી તરીકે $ એરે).

327
00:15:49,258 --> 00:15:52,900

328
00:15:52,900 --> 00:15:56,450
મૂળભૂત રીતે, કે ટિપ્પણી નોંધો તરીકે,
કે foreach લૂપ અંદર,

329
00:15:56,450 --> 00:16:00,466
તે દરેક એક પર જાઓ રહ્યું છે
સામાન્ય રીતે, જે $ એરે તત્વ

330
00:16:00,466 --> 00:16:03,340
એક સમૂહનો એરે હોઈ ચાલે છે,
પરંતુ ખરેખર એરે કોઈપણ પ્રકારની હોઈ શકે

331
00:16:03,340 --> 00:16:05,419
તમે PHP માં કરવા માંગો છો છે.

332
00:16:05,419 --> 00:16:07,210
અને કે દર વખતે
લૂપ માટે તમે કદાચ

333
00:16:07,210 --> 00:16:13,780
$ એરે ચોરસ કૌંસ કહ્યું છે
$ હું તમને માત્ર $ કી કહી શકે છે.

334
00:16:13,780 --> 00:16:22,340
તેથી તે $ કી દરેક માટે એક ઉપનામ બને
તમારા PHP, સમૂહનો એરે ઇન્ડેક્સ,

335
00:16:22,340 --> 00:16:23,710
અને તેથી તમે કે જેમ તે વાપરી શકો છો.

336
00:16:23,710 --> 00:16:25,897
>> તેથી, ઉદાહરણ તરીકે, અમે કર્યું
હવે અમારી pizzas એરે મળી.

337
00:16:25,897 --> 00:16:27,730
હું પ્રકારની તે tucked કર્યું
ત્યાં ખૂણામાં માં

338
00:16:27,730 --> 00:16:31,080
તેથી અમે એક ઝડપી ઉદાહરણ કરવા માટે તેનો ઉપયોગ કરી શકો છો.

339
00:16:31,080 --> 00:16:36,420
હું foreach ($ pizzas કહે તો
$ પિઝા), ઠીક છે, શું થઈ રહ્યું છે?

340
00:16:36,420 --> 00:16:42,400
ઠીક છે, હું દરેક મારફતે ફરી વળવું જઈ રહ્યો છું
એરે $ pizzas ની એક તત્વ,

341
00:16:42,400 --> 00:16:46,670
અને આમ કરવાથી, હું કહી જાઉં છું
દરેક તત્વ, જ્યારે હું અંદર છું

342
00:16:46,670 --> 00:16:49,400
લૂપ માટે કે શરીરના, પિત્ઝા $.

343
00:16:49,400 --> 00:16:52,440
>> તેથી કે જે જેવું છે
ઊભા માં, સ્મૃતિ, કે $ પિઝા

344
00:16:52,440 --> 00:16:59,140
એક સ્ટેન્ડ-કહીને માટે છે
$ Pizzas ચોરસ કૌંસ $ i

345
00:16:59,140 --> 00:17:03,370
અમે લૂપ છે, જ્યાં અમે એક ઉપયોગ કરી રહ્યા હતા તો
આ કિસ્સામાં $ હું = 0 માટે, જાઓ શકે છે,

346
00:17:03,370 --> 00:17:06,089
$ I = 3.

347
00:17:06,089 --> 00:17:09,780
અમે કી કિંમત જોડીઓને ન હોય
અહીં, આ તત્વ 0, 1, 2, 3 હશે,

348
00:17:09,780 --> 00:17:16,390
અને અમે જાઓ લૂપ માટે ઉપયોગ કરશે
$ Pizzas 0, $ pizzas 1, $ pizzas 2,

349
00:17:16,390 --> 00:17:17,750
$ Pizzas 3.

350
00:17:17,750 --> 00:17:23,130
તેથી હવે માત્ર પીત્ઝા અવેજીમાં છે $
જે વ્યક્તિગત કી માટે.

351
00:17:23,130 --> 00:17:25,630
>> તેથી શું આ છાપે રહ્યું છે?

352
00:17:25,630 --> 00:17:29,030
હું $ પિઝા બહાર છાપવા છું.

353
00:17:29,030 --> 00:17:35,270
શું હું at-- શોધવા માટે જાઉં છું
હું $ pizzas $ છાપે તો શું?

354
00:17:35,270 --> 00:17:35,770
અધિકાર?

355
00:17:35,770 --> 00:17:38,680
હું છાપે જાઉં છું
pizzas ના ઇથ તત્વ,

356
00:17:38,680 --> 00:17:40,070
શું હું છાપવા માટે જાઉં છું?

357
00:17:40,070 --> 00:17:42,580
હું છાપે જાઉં છું
તે સ્થાન પર કિંમતો, અધિકાર?

358
00:17:42,580 --> 00:17:45,370
અમે કરી રહ્યા હતા, તો ગમે
સી ના સંદર્ભમાં આ

359
00:17:45,370 --> 00:17:49,786
અમે સામાન્ય રીતે અમારી iterator ઉપયોગ કરતા નથી
ચલ, હું = 0, હું કરતાં ઓછી 3 પૂર્ણાંક

360
00:17:49,786 --> 00:17:52,900
હું 0, 1, 2, 3 છાપે, ++.

361
00:17:52,900 --> 00:17:57,500
અમે એરે 0 બહાર છાપવા કરી રહ્યાં છો
અરે 1, અરે 2, એરે 3.

362
00:17:57,500 --> 00:17:59,580
અને તેથી આ છાપે શું આ છે.

363
00:17:59,580 --> 00:18:01,150
તે ભાવ યાદી છે.

364
00:18:01,150 --> 00:18:05,750
8.99, 9.99, 10.99, 11,99.

365
00:18:05,750 --> 00:18:06,900
>> હવે અહીં એક ઝડપી નોંધ.

366
00:18:06,900 --> 00:18:10,900
એક foreach લૂપ જરૂરી નથી
ક્રમમાં વસ્તુઓ છાપશે.

367
00:18:10,900 --> 00:18:12,770
તે ખાતરી આપી નથી.

368
00:18:12,770 --> 00:18:13,550
તે સામાન્ય રીતે કરે છે.

369
00:18:13,550 --> 00:18:17,667
તે સામાન્ય રીતે ક્રમમાં પર આધારિત છે
જે તત્વો એરે માટે ઉમેરવામાં આવે છે,

370
00:18:17,667 --> 00:18:18,750
તેથી માત્ર ધ્યાનમાં સહન.

371
00:18:18,750 --> 00:18:20,830
તે માટે ન હોઈ શકે છે.

372
00:18:20,830 --> 00:18:23,930
પરંતુ foreach લૂપ ફરી વળવું કરશે
દરેક એક તત્વ સમગ્ર

373
00:18:23,930 --> 00:18:25,060
પ્રશ્ન એરે.

374
00:18:25,060 --> 00:18:27,980
આ કિસ્સામાં, ફરી,
કે એરે $ pizzas છે.

375
00:18:27,980 --> 00:18:32,920
>> હું તો, જોકે, આ વાક્યરચના બદલી શકો છો
હું કી અને કિંમત બંને માંગો છો.

376
00:18:32,920 --> 00:18:37,179
તેના બદલે $ pizzas કહેતા
$ પિઝા તરીકે, હું આ કહી શકો છો.

377
00:18:37,179 --> 00:18:39,470
અને તમે મને કર્યું તે જોવા તો
અહીં લીલા પ્રકાશિત,

378
00:18:39,470 --> 00:18:42,130
તે કી કિંમતની જોડી મેપિંગ જેવો દેખાય છે.

379
00:18:42,130 --> 00:18:45,980
અને તેથી તમારી પાસે જો તમે ન હોય તો પણ
સંપૂર્ણપણે તે કરવા જઇ રહ્યા છે તે ખાતરી કરો કે,

380
00:18:45,980 --> 00:18:49,300
તમે કદાચ ધારી શકો છો
કે $ ઉપયોગમાં લેવામાં આવનારા રહ્યું છે

381
00:18:49,300 --> 00:18:53,800
આ કિસ્સામાં કી હોઇ શકે છે અને
$ કિંમત કિંમત હોઈ ચાલે છે.

382
00:18:53,800 --> 00:18:59,200
તેથી હવે હું દરેક તત્વ અવેજીમાં છું
$ ની કી કિંમત જોડી તરીકે pizzas,

383
00:18:59,200 --> 00:19:03,900
અને હવે હું કી ઉલ્લેખ કરી શકે છે અને
કિંમત, જે કદાચ હાથમાં,

384
00:19:03,900 --> 00:19:05,590
ઉદાહરણ માટે, નીચે મુજબ છે.

385
00:19:05,590 --> 00:19:10,170
>> "સમગ્ર" - આ એક ઘણો છે
પ્રિન્ટિંગ અહીં "સમગ્ર" પર જઈ

386
00:19:10,170 --> 00:19:17,300
ઉપયોગમાં લેવામાં આવનારા પછી ભાવ, અને "પિઝા $ ખર્ચ"
હું સમય અને બેકસ્લેશ n છાપશે.

387
00:19:17,300 --> 00:19:23,420
તેથી હવે, નોટિસ ફરીથી હું વપરાશ હોય છે
કી $ ઉપયોગમાં લેવામાં આવનારા, અને કિંમત $ ભાવ.

388
00:19:23,420 --> 00:19:26,647
જેથી તમે શું આ અનુમાન કરી શકો છો
બહાર છાપી રહ્યું છે?

389
00:19:26,647 --> 00:19:29,480
પ્રિન્ટ નિવેદનો ઘણો છે,
પરંતુ માત્ર એક બેકસ્લેશ n એ ત્યાં છે,

390
00:19:29,480 --> 00:19:33,410
તેથી તે પર કંઈક છાપવા માટે ચાલી રહ્યું છે
કોડ એક વાક્ય પર entire--.

391
00:19:33,410 --> 00:19:36,965
>> હું કી ઉલ્લેખ કરી શકે છે, તો
અને કિંમત, તો પછી હવે,

392
00:19:36,965 --> 00:19:39,090
તેના બદલે માત્ર સક્ષમ છે
ભાવ છાપે,

393
00:19:39,090 --> 00:19:41,330
હું આ કંઈક છાપી શકો છો.

394
00:19:41,330 --> 00:19:43,780
"સમગ્ર ચીઝ પિઝા $ 8.99 ખર્ચ પડે છે."

395
00:19:43,780 --> 00:19:47,150
અને હવે હું keys-- તમામ ઉપયોગ કરું છું
ચીઝ, pepperoni, શાકભાજી,

396
00:19:47,150 --> 00:19:49,640
બફેલો chicken-- અને કિંમતો.

397
00:19:49,640 --> 00:19:53,980
8.99, 9.99, 10.99, 11,99 તેથી
કે જે હમણાં જ એક અલગ રીત છે

398
00:19:53,980 --> 00:19:57,840
એક foreach લૂપ કરવા કે બદલે
ફક્ત તમને કિંમતો ઍક્સેસ આપવા

399
00:19:57,840 --> 00:20:02,950
તે તમને આપે છે તમારી પાસે તે માત્ર આપે છે
કીઓ અને કિંમતો ઍક્સેસ કરો.

400
00:20:02,950 --> 00:20:04,411
>> તેથી માહિતી બહાર છાપવા.

401
00:20:04,411 --> 00:20:07,410
હું પહેલેથી જ તે એક દંપતિ કર્યું
અલગ અલગ રીતે, તમે જણાયું છે શકે છે.

402
00:20:07,410 --> 00:20:11,080
બે કાર્યો અમે મુખ્યત્વે કર્યું
પ્રિન્ટ અને ઇકો જોવા મળે છે.

403
00:20:11,080 --> 00:20:14,380
અને ખૂબ ખૂબ તમામ ઇરાદાઓ અને
હેતુઓ, તેઓ બરાબર એ જ છો.

404
00:20:14,380 --> 00:20:17,130
They're-- ખૂબ જ સૂક્ષ્મ છે
પણ નથી મૂલ્યના છે કે તફાવત

405
00:20:17,130 --> 00:20:21,130
મૂળભૂત બધે પ્રવેશ મેળવવામાં, પરંતુ
તમે કદાચ ઉપયોગ કરી શકો છો પ્રિન્ટ ઉપયોગ કરી શકો છો

406
00:20:21,130 --> 00:20:22,370
તેમજ ઇકો.

407
00:20:22,370 --> 00:20:23,610
>> અને તે માત્ર બે નથી.

408
00:20:23,610 --> 00:20:26,970
PHP, અલગ ઘણો છે
વસ્તુઓ બહાર છાપો માર્ગો

409
00:20:26,970 --> 00:20:30,520
અને તે પણ સંકલિત રીતો છે
શબ્દમાળા ના મધ્યમાં માં ચલો.

410
00:20:30,520 --> 00:20:32,860
તેથી સી યાદ, તમે શું
શું કાર્ય યાદ

411
00:20:32,860 --> 00:20:37,580
અમે ચલો અલગ ઉપયોગ કરી શકો છો
વસ્તુઓ માં અમે છાપી કરવા માંગો છો?

412
00:20:37,580 --> 00:20:40,160
તમે કદાચ આ વાપરો
તદ્દન ઘણો કામ કરે છે.

413
00:20:40,160 --> 00:20:42,290
printf, અધિકાર?

414
00:20:42,290 --> 00:20:45,290
તેથી આ અમે અંદર પહેલાં હતી શું છે
અમારા foreach લૂપ સંદર્ભમાં.

415
00:20:45,290 --> 00:20:48,000
અમે આ પાંચ હતી
અલગ પ્રિન્ટ નિવેદનો,

416
00:20:48,000 --> 00:20:50,330
કે જે માત્ર હતો કારણ કે
માર્ગ હું ખરેખર તે સમયે જાણતા

417
00:20:50,330 --> 00:20:52,450
કેવી રીતે સંદેશાઓ છાપે છે.

418
00:20:52,450 --> 00:20:59,560
હું સંકલિત કેવી રીતે ખબર ન હતી
મારા PHP કોડ માં ઉપયોગમાં લેવામાં આવનારા ચલ $.

419
00:20:59,560 --> 00:21:03,700
ઠીક છે, હું માત્ર એક જંગલી અનુમાન લેવામાં જો,
printf, તે ખરેખર કામ કર્યું હશે.

420
00:21:03,700 --> 00:21:08,980
printf હું ઉપયોગ કરી શકો છો કે એક કાર્ય છે
PHP, માં, માત્ર હું સી માં તેનો ઉપયોગ કરી શકો છો જેમ

421
00:21:08,980 --> 00:21:11,880
>> અને તેથી આ કંઈક, printf માટે,
ફરીથી, અમે તે સાથે પરિચિત છો.

422
00:21:11,880 --> 00:21:16,420
પ્રથમ% s બદલાઈ જાય છે
$ ઉપયોગમાં લેવામાં આવનારા ની કિંમત સાથે.

423
00:21:16,420 --> 00:21:19,700
બીજા% s બદલાઈ જાય છે
$ કિંમત કિંમત સાથે.

424
00:21:19,700 --> 00:21:22,630
અને તેથી હું interpellating છું,
જે માત્ર એક ફેન્સી માર્ગ છે

425
00:21:22,630 --> 00:21:25,400
કહેતા હું ચોંટતા છું
તે સ્થાન માં ચલો.

426
00:21:25,400 --> 00:21:31,000
તેથી હું ઉપયોગમાં લેવામાં આવનારા માં $ પ્લગ છું જ્યાં
લાલ% s $ ભાવ જ્યાં વાદળી% s છે અને

427
00:21:31,000 --> 00:21:36,060
છે, અને પછી હું મેસેજ મળી જશે,
"સમગ્ર ચીઝ પિઝા $ 8.99 ખર્ચ પડે છે."

428
00:21:36,060 --> 00:21:37,750
>> હું જોકે, તે કરી શકો છો માત્ર એક જ રસ્તો છે.

429
00:21:37,750 --> 00:21:39,760
કદાચ હું આ પદ્ધતિ ઉપયોગ કરવા માંગો છો શકે છે.

430
00:21:39,760 --> 00:21:44,890
આ સૌથી સામાન્ય છે તે ખરેખર છે
ચલ અવાંતર કહેવાય છે.

431
00:21:44,890 --> 00:21:45,690
હું એક પડઘો વાપરી શકો છો.

432
00:21:45,690 --> 00:21:47,737
અમે જોશો, કારણ કે હું ખૂબ પ્રિન્ટ ઉપયોગ કરી શકે છે.

433
00:21:47,737 --> 00:21:48,820
પરંતુ અહીં શું થઈ રહ્યું છે?

434
00:21:48,820 --> 00:21:51,520
>> તમામ પ્રથમ, હું હોય
ડોલર સાઇન એસ્કેપ ઓનલાઇન.

435
00:21:51,520 --> 00:21:55,140
અમે ખરેખર હતા ત્યારે, કારણ કે યાદ
આ pizzas ભાવમાં બહાર છાપવા,

436
00:21:55,140 --> 00:21:59,370
હું ખરેખર તેમને ફોર્મેટિંગ હતી
ડોલર સાઇન સાથે નાણાકીય આધાર.

437
00:21:59,370 --> 00:22:05,635
પરંતુ અમે પણ ડોલર ચિહ્ન ઉપયોગ કરી રહ્યાં છો
PHP, ચલ નામો પ્રતિનિધિત્વ કરવા માટે,

438
00:22:05,635 --> 00:22:08,010
અને ખાસ કરીને જ્યારે હું છું
આ સર્પાકાર આ પદ્ધતિનો ઉપયોગ કરીને

439
00:22:08,010 --> 00:22:10,040
તાણવું ચલ
અવાંતર પદ્ધતિ, હું જરૂર

440
00:22:10,040 --> 00:22:13,490
જો તેમ ન હોય તેથી મારા ડોલર સાઇન ભાગી
હું એક ચલ વિશે વાત કરું છું એવું લાગે છે.

441
00:22:13,490 --> 00:22:16,920
તે ખરેખર કરવા જઈ રહ્યું છે
શાબ્દિક ડોલર સાઇન છાપો.

442
00:22:16,920 --> 00:22:19,530
>> તેથી સૉર્ટ તે analogize
જો તમને ત્યાં ઓવરને અંતે જોવા છે.

443
00:22:19,530 --> 00:22:22,832
તે ખરેખર નથી
પ્રિન્ટ બેકસ્લેશ n એ, અધિકાર?

444
00:22:22,832 --> 00:22:24,290
તે એક નવી લાઇન પાત્ર છાપે છે.

445
00:22:24,290 --> 00:22:26,750
આ તે નથી ચાલી રહ્યું છે is--
પ્રિન્ટ બેકસ્લેશ ડોલર સાઇન,

446
00:22:26,750 --> 00:22:30,130
તે માત્ર બહાર છાપી રહ્યું છે
ડોલર સાઇન પાત્ર.

447
00:22:30,130 --> 00:22:30,640
જ વિચાર.

448
00:22:30,640 --> 00:22:32,760
શ્રેણીઓ એસ્કેપ શું
આ વસ્તુઓ કહેવામાં આવે છે.

449
00:22:32,760 --> 00:22:37,080
>> પરંતુ હું નથી કરી રહ્યો છું કે નોટિસ
% s ખેલાડીઓની ફેરબદલ કોઇ પણ પ્રકારની,

450
00:22:37,080 --> 00:22:40,050
હું માત્ર શાબ્દિક પ્લગ છું
આ ચલો છે.

451
00:22:40,050 --> 00:22:45,110
અને તેથી છે આ અહીં શું થશે
, કે જે $ topping-- ની કિંમત ફરીથી છે

452
00:22:45,110 --> 00:22:48,390
માત્ર અમે આવી કર્યું છે તે સાથે રાખવા
જેથી અત્યાર સુધી લગભગ ચીઝ વિશે વાત કરશે

453
00:22:48,390 --> 00:22:49,720
ત્યાં પ્લગ.

454
00:22:49,720 --> 00:22:54,780
અને $ કિંમત છે ગમે કિંમત હશે
pizzas પર, ચોરસ કૌંસ, ચીઝ,

455
00:22:54,780 --> 00:22:56,270
જે 8.99 હતો.

456
00:22:56,270 --> 00:23:01,860
અને તેથી આ પણ છાપે કરશે
"સમગ્ર ચીઝ પિઝા $ 8.99 ખર્ચ પડે છે."

457
00:23:01,860 --> 00:23:05,160
જેમ હું જણાવ્યું હતું કે, હું ઉપયોગ કરી શકે છે
તેના બદલે પડઘો અહીં છાપો,

458
00:23:05,160 --> 00:23:08,040
અને કાર્યક્ષમતા હોઈ
બરાબર એ જ ખૂબ ખૂબ.

459
00:23:08,040 --> 00:23:09,660
તે જ વસ્તુ છાપે કરશે.

460
00:23:09,660 --> 00:23:12,680
>> તે શું કરવા માટે અન્ય માર્ગ છે,
અને આ બીજી ફાયદો છે

461
00:23:12,680 --> 00:23:14,710
PHP ની શબ્દમાળાઓ સાથે કામ કરે છે.

462
00:23:14,710 --> 00:23:17,130
અમે શબ્દમાળા શૃંખલીકરણ કરી શકો છો.

463
00:23:17,130 --> 00:23:19,660
અમે પણ, સી માં આ કરી શકે છે,
strcat કહેવાય કાર્ય ઉપયોગ કરીને,

464
00:23:19,660 --> 00:23:21,180
પરંતુ ફરીથી, અમે હતી
અલગ કાર્યો કૉલ કરો.

465
00:23:21,180 --> 00:23:22,640
તે કરવું આ સમગ્ર વાસણ હતું.

466
00:23:22,640 --> 00:23:24,590
અમે હતી string.h પાઉન્ડ સમાવેશ થાય છે.

467
00:23:24,590 --> 00:23:25,780
તે અધિકાર, ઉત્પાદન હતું?

468
00:23:25,780 --> 00:23:30,070
પરંતુ હવે હું ફક્ત આ કોઈ ઓપરેટર ઉપયોગ કરી શકો છો
સાથે મળીને શબ્દમાળાઓ એકસાથે જોડવું.

469
00:23:30,070 --> 00:23:34,910
>> તેથી હું "સમગ્ર" concatenating છું અને
પછી ગમે $ ઉપયોગમાં લેવામાં આવનારા કિંમત છે,

470
00:23:34,910 --> 00:23:38,860
અને પછી બીજા
શબ્દમાળા "પિઝા ખર્ચ $"

471
00:23:38,860 --> 00:23:42,340
અને પછી concatenating ગમે
$ કિંમત કિંમત છે,

472
00:23:42,340 --> 00:23:45,670
અને પછી ખૂબ જ ઓવરને અંતે હું
સમય બેકસ્લેશ n એ પર આબંધન.

473
00:23:45,670 --> 00:23:47,926
અને તેથી આ પણ કરશે
"સમગ્ર" છાપે - ફરી,

474
00:23:47,926 --> 00:23:50,550
અમે પ્રથમ વિશે વાત કરી રહ્યાં છો, તો
કે pizzas એરે તત્વ

475
00:23:50,550 --> 00:23:54,710
"સમગ્ર ચીઝ પિઝા $ 8.99 ખર્ચ પડે છે."

476
00:23:54,710 --> 00:24:01,260
સમય, ફરીથી બેકસ્લેશ n એ, સાથે,
આ $ ઉપયોગમાં લેવામાં આવનારા અને $ ભાવ અવેજીમાં

477
00:24:01,260 --> 00:24:06,580
અમે અમારા foreach માં સ્પષ્ટ હતી તે માટે
કી કિંમતની જોડી મેપિંગ તરીકે લૂપ.

478
00:24:06,580 --> 00:24:08,050
>> PHP, કાર્યો સંભાળી શકે છે.

479
00:24:08,050 --> 00:24:11,250
કાર્યો સૉર્ટ હતા
સે અભિન્ન તરીકે આપણે જોયું.

480
00:24:11,250 --> 00:24:14,870
ચલો જેમ, અમે જરૂર નથી
, આ કાર્ય પરત પ્રકાર સ્પષ્ટ

481
00:24:14,870 --> 00:24:16,350
તે ખરેખર તો કોઈ વાંધો નથી.

482
00:24:16,350 --> 00:24:18,660
અને અમે સ્પષ્ટ કરો નહિં
કોઈપણ પરિમાણો ડેટા પ્રકારો,

483
00:24:18,660 --> 00:24:21,410
તેઓ ખરેખર નથી કારણ કે
બાબત, અમે PHP, માં જોઇ જેવા હોય છે.

484
00:24:21,410 --> 00:24:24,510
દરેક કાર્ય રજૂ કરવામાં આવે છે
કાર્ય કીવર્ડ સાથે.

485
00:24:24,510 --> 00:24:27,920
એટલે કે, અમે કે જે PHP સૂચવે કેવી રીતે
આપણે જે અંગે વાત કરી રહ્યા છીએ એક કાર્ય છે.

486
00:24:27,920 --> 00:24:29,720
>> અને અમે નથી
બધા અંતે મુખ્ય સાથે વ્યવહાર,

487
00:24:29,720 --> 00:24:33,690
ઈન્ટરપ્રીટર, કારણ કે PHP,
દુભાષિયો, ટોચ પરથી નીચે કામ કરે છે,

488
00:24:33,690 --> 00:24:34,190
અનુલક્ષીને.

489
00:24:34,190 --> 00:24:35,640
તે જુએ છે, તો તમે કરી શકો છો
એક ફંક્શન કોલ, તે પડશે

490
00:24:35,640 --> 00:24:37,850
આ વિધેય કોલ શોધવા જાઓ,
પણ તે પછી આવે તો.

491
00:24:37,850 --> 00:24:40,360
પરંતુ તે ટોચ પરથી વાંચી રહ્યું છે
નીચે છે, તેથી અમે સ્પષ્ટ કરવા માટે જરૂર નથી,

492
00:24:40,360 --> 00:24:41,500
તમે શરૂ કરો જ્યાં અહીં છે.

493
00:24:41,500 --> 00:24:46,700
તમે રેખા 1 પર શરૂ તમારા
PHP, ત્યાંથી નીચે કામ કરે છે અને.

494
00:24:46,700 --> 00:24:49,690
>> તેથી અહીં અમે બનાવવા કેવી રીતે છે
એક કાર્ય hard_square કહેવાય છે.

495
00:24:49,690 --> 00:24:54,100
તે દેખીતી રીતે એક લે
પરિમાણ, હું $ X ફોન કરું છું છે.

496
00:24:54,100 --> 00:24:58,424
આ કાર્ય માત્ર જટિલ છે
વિવિધ વસ્તુઓ સમજાવે છે.

497
00:24:58,424 --> 00:24:59,590
અમે હજુ પણ વળતર કિંમતો છે.

498
00:24:59,590 --> 00:25:00,870
હું અહીં લૂપ માટે ઉપયોગ કરું છું.

499
00:25:00,870 --> 00:25:04,970
પરંતુ તે મૂળભૂત રીતે માત્ર, આ શું છે
માત્ર $ X વખત $ X છે જેટલી.

500
00:25:04,970 --> 00:25:10,520
શું હું ખરેખર માત્ર ઉમેરી રહ્યા છે કરી રહ્યો છું
એક્સ એક્સ વખત 0 અથવા $ શૂન્ય $ X વખત એક્સ.

501
00:25:10,520 --> 00:25:15,850
પરંતુ તે અસરકારક રીતે બરાબર છે
$ એક્સ વખત $ X ગુણાકાર જ.

502
00:25:15,850 --> 00:25:18,700
હું હજુ પણ એક કિંમત પરત ફરી શકે છે,
આ કિસ્સામાં $ પરિણામ,

503
00:25:18,700 --> 00:25:22,060
અને હું PHP, એક કાર્ય કર્યા છે.

504
00:25:22,060 --> 00:25:24,160
>> અહીં તમે સંદર્ભમાં તે ઉપયોગ કરી શકે છે કેવી રીતે.

505
00:25:24,160 --> 00:25:26,020
તેથી કદાચ હું કેટલાક PHP ફાઈલ ની અંદર છું.

506
00:25:26,020 --> 00:25:29,240
ત્યાં વાદળી નોટિસ
હું મારા PHP વિભાજકો ઉપયોગ કર્યો છે,

507
00:25:29,240 --> 00:25:31,010
કોણ કૌંસ પ્રશ્ન ચિહ્ન PHP.

508
00:25:31,010 --> 00:25:35,180
તે વચ્ચે બધા છે
હું લખવા માંગો છો કે PHP.

509
00:25:35,180 --> 00:25:37,840
તેથી હું દેખીતી રીતે વિચાર કરી જાઉં છું
હું વપરાશકર્તા પૂછવા જાઉં છું

510
00:25:37,840 --> 00:25:41,550
મને એક નંબર, સ્ટોર આપવા માટે
ચલ, કે ચલ $ એક્સ સ્ટોર,

511
00:25:41,550 --> 00:25:43,320
ગમે તેઓ મને આપી હતી.

512
00:25:43,320 --> 00:25:48,590
પછી હું પડઘો જાઉં છું
કે મૂલ્ય hard_square,

513
00:25:48,590 --> 00:25:50,370
અને દેખીતી રીતે જઈ
એક નવી લાઇન પર ખીલી માટે

514
00:25:50,370 --> 00:25:53,590
તેમજ, અને પછી પાછળથી હું પડશે
તેથી hard_square કાર્ય વ્યાખ્યાયિત

515
00:25:53,590 --> 00:25:55,550
હું જ્યારે કે
hard_square માટે કૉલ,

516
00:25:55,550 --> 00:25:58,160
હું વિશે વાત કરું છું શું જાણે છે.

517
00:25:58,160 --> 00:26:00,705
>> હવે, હું પણ આવું કરી શકે છે
આ કંઈક.

518
00:26:00,705 --> 00:26:02,050
આ સહેજ અલગ છે.

519
00:26:02,050 --> 00:26:04,190
તે લગભગ બરાબર છે
અમે પહેલાં શું જોયું તરીકે જ છે,

520
00:26:04,190 --> 00:26:08,400
X બદલે માત્ર $ કહેતા સિવાય
ત્યાં પરિમાણ hard_square માટે,

521
00:26:08,400 --> 00:26:11,730
હું $ X = 10 કહી રહ્યો છું.

522
00:26:11,730 --> 00:26:14,330
તેથી આ એક ઉદાહરણ છે
રક્ષણાત્મક પ્રોગ્રામિંગ,

523
00:26:14,330 --> 00:26:17,070
તમારા કાર્યક્રમો રક્ષણ
મલીન વપરાશકર્તાઓ સામે.

524
00:26:17,070 --> 00:26:20,020
>> આ અમુક ભૂલ કરવા માટે એક માર્ગ છે
અમે ખરેખર ન હતી કે તપાસ

525
00:26:20,020 --> 00:26:24,670
સી માં એક વિકલ્પ તરીકે છે અમે ક્યારેય કરી શકે છે
કંઈક મૂળભૂત કિંમત સ્પષ્ટ કરો.

526
00:26:24,670 --> 00:26:27,010
અમે હંમેશા તપાસ કરી હતી
આ કે શું, ઉદાહરણ તરીકે,

527
00:26:27,010 --> 00:26:30,820
અમે GetString કૉલ કરી હોય, તો તે હતી
સૌથી યોગ્ય તરત જ જો આપણે પછી

528
00:26:30,820 --> 00:26:33,300
, અમે ચકાસાયેલ ચકાસાયેલ
શબ્દમાળા કે શું

529
00:26:33,300 --> 00:26:35,504
વપરાશકર્તા અમને આપ્યો કે
, નલ માટે સમાન નથી

530
00:26:35,504 --> 00:26:37,920
અમે શરૂ કરવા માંગો છો નથી કારણ કે
નલ શબ્દમાળા સાથે કામ કરે છે.

531
00:26:37,920 --> 00:26:39,670
>> અહીં, આ એક માર્ગ છે
સામે રક્ષણ.

532
00:26:39,670 --> 00:26:43,480
વપરાશકર્તા અમને કંઈક રાખતો નથી
કોઈક અમે શું કરવા જઇ રહ્યા છે?

533
00:26:43,480 --> 00:26:46,080
ઠીક છે, આપણે કહેવું પડશે ગમે
તેઓ અમને પૂરી પાડી ન હતી,

534
00:26:46,080 --> 00:26:47,705
અમે ફક્ત બદલે 10 માં પ્લગ રહ્યા છીએ.

535
00:26:47,705 --> 00:26:52,030
તેઓ અમને નીચેની આપી ન હતી તેથી જો,
માત્ર મૂળભૂત દ્વારા 10 ઉપયોગ કરે છે. અને તેથી અહીં,

536
00:26:52,030 --> 00:26:53,940
હું બનાવવા છું કે નોટિસ
એક hard_square માટે કૉલ,

537
00:26:53,940 --> 00:26:55,980
પરંતુ કોઈ પ્રોમ્પ્ટ છે
આ વપરાશકર્તા માટે, અધિકાર?

538
00:26:55,980 --> 00:26:57,540
હું માત્ર એક ખાલી કોલ બનાવવા છું.

539
00:26:57,540 --> 00:27:00,860
>> પરંતુ મારા કાર્ય hard_square
એક પરિમાણ અપેક્ષા છે.

540
00:27:00,860 --> 00:27:02,222
શું આ છાપે રહ્યું છે?

541
00:27:02,222 --> 00:27:03,680
તે હક, 100 છાપે રહ્યું છે?

542
00:27:03,680 --> 00:27:05,720
વપરાશકર્તા ન હતી કારણ કે
મને કશું આપો.

543
00:27:05,720 --> 00:27:08,970
અને તેથી હું હમણાં ધારણ જાઉં છું
10-- 10 કે મૂળભૂત કિંમત છે.

544
00:27:08,970 --> 00:27:13,760
અને તેથી આ છાપો કરશે
બહાર 100 તેના પોતાના વાક્ય પર.

545
00:27:13,760 --> 00:27:16,390
>> PHP, ફાઇલો કરવાની જરૂર નથી
માત્ર એક જ ફાઇલ હોય.

546
00:27:16,390 --> 00:27:19,480
તમે એકસાથે બહુવિધ ફાઇલો ભેગા કરી શકો છો,
માત્ર સી તમે કરી શકો છો આ રીતે ગમે છે

547
00:27:19,480 --> 00:27:24,330
અમે સી માં કરવું સામાન્ય રીતે કરવામાં આવી હતી કે હતી
# સમાવેશ થાય છે હેડર ફાઈલો ખેંચાય વિચાર.

548
00:27:24,330 --> 00:27:26,180
અમે PHP, માં કે નથી.

549
00:27:26,180 --> 00:27:29,110
અમે require_once કહેવાય કંઈક.

550
00:27:29,110 --> 00:27:33,360
અને પછી આ સમગ્ર છે
વસ્તુ, આ __dir__ શું છે?

551
00:27:33,360 --> 00:27:36,510
કે જે હમણાં જ એક ખાસ છે
ચલ, અથવા ખાસ સતત,

552
00:27:36,510 --> 00:27:39,030
ખરેખર, કે શું સ્પષ્ટ
તમારી વર્તમાન ડિરેક્ટરી છે.

553
00:27:39,030 --> 00:27:41,320
અને તેથી તે જોવા જઈ રહ્યું છે
તમારી વર્તમાન ડિરેક્ટરીમાં

554
00:27:41,320 --> 00:27:44,900
ફાઇલ કહેવાય cs50.php માટે
અહીં આ ઉદાહરણમાં,

555
00:27:44,900 --> 00:27:50,490
અને તે ફાઈલ વળગી રહ્યું છે
તમારા PHP કાર્યક્રમ ટોચ પર,

556
00:27:50,490 --> 00:27:56,980
તમે જરૂર મૂકી એમ ધારી રહ્યા છીએ
તમારા PHP ફાઈલ ટોચ પર લીટી એકવાર.

557
00:27:56,980 --> 00:28:01,474
>> તેથી PHP મુખ્યત્વે વપરાય છે
પરંતુ તે માત્ર ઉપયોગ નથી

558
00:28:01,474 --> 00:28:03,140
વેબ આધારિત પ્રોગ્રામિંગ માટે એક ભાષા તરીકે.

559
00:28:03,140 --> 00:28:05,270
તે હોઈ આવ્યા ખરેખર કેવી રીતે.

560
00:28:05,270 --> 00:28:06,980
પરંતુ તે એક સંપૂર્ણ છે
અમે જોઇ છે ભાષા.

561
00:28:06,980 --> 00:28:10,105
અમે ખૂબ ખૂબ બધી વસ્તુઓ જોઇ છે
તે સી જેવું જ છે કે જે કરી શકે છે,

562
00:28:10,105 --> 00:28:13,290
અને તે એક હેક કરી શકો છો
તે કરતાં વધુ ઘણો.

563
00:28:13,290 --> 00:28:16,950
>> પરંતુ તે છે, કારણ કે એક સંપૂર્ણ ભાષા અને અમે
તે આદેશ વાક્ય પ્રોગ્રામિંગ કરી શકો છો.

564
00:28:16,950 --> 00:28:18,630
અમે આદેશ વાક્ય કાર્યક્રમો ચલાવી શકો છો.

565
00:28:18,630 --> 00:28:22,580
તે એક આદેશ ચલાવવા માટે જરૂરી છે
PHP, માં લખેલા છે કે વાક્ય કાર્યક્રમ

566
00:28:22,580 --> 00:28:24,260
તમે PHP દુભાષિયો હોય છે.

567
00:28:24,260 --> 00:28:27,460
તેથી તે પ્રકારના સમાન છે
તમારી સિસ્ટમ પર કમ્પાઇલર કર્યા

568
00:28:27,460 --> 00:28:31,100
તમે તમારા સી કોડ કમ્પાઇલ કરવા માંગો છો, તો
એક્ઝેક્યુટેબલ ફાઈલો મા ફેરવાઇ જાય છે.

569
00:28:31,100 --> 00:28:33,810
તમે PHP દુભાષિયો કરવાની જરૂર છે
કે જે તમારી સિસ્ટમ પર હાજર

570
00:28:33,810 --> 00:28:37,330
જેથી તમે PHP, ફાઇલો અર્થઘટન કરી શકે છે.

571
00:28:37,330 --> 00:28:40,370
>> તમે એમ ધારી રહ્યા છીએ, અને સામાન્ય રીતે
આ દુભાષિયો, PHP કહેવાય છે

572
00:28:40,370 --> 00:28:44,300
અને તે સામાન્ય રીતે મોટા ભાગના સાથે બનીને છે
ડાઉનલોડ અથવા PHP ની સ્થાપનો

573
00:28:44,300 --> 00:28:47,430
તમે ચોક્કસપણે વિચાર છે, અને શકે છે કે
PHP દુભાષિયો નામ

574
00:28:47,430 --> 00:28:49,550
અમે CS50 માં IDE છે.

575
00:28:49,550 --> 00:28:51,819
તમે શું તમામ પ્રકારના PHP ફાઈલ છે.

576
00:28:51,819 --> 00:28:53,610
અને શું તમારા કાર્યક્રમ
કરવા જઇ તે છે

577
00:28:53,610 --> 00:28:55,360
મારફતે ચલાવવા માટે જતા
ઈન્ટરપ્રીટર, તે

578
00:28:55,360 --> 00:28:58,040
છે કે બધું અવગણો જાઉં
નથી પ્રશ્ન mark-- વચ્ચે

579
00:28:58,040 --> 00:29:03,160
અથવા, કોણ કૌંસ પ્રશ્ન ચિહ્ન PHP,
PHP, વિભાજકો, અને તે છાપે

580
00:29:03,160 --> 00:29:07,660
અને તે અર્થઘટન અને અમલ કરશે
તમારા PHP વિભાજકો અંદર કોડ.

581
00:29:07,660 --> 00:29:12,850
>> તેથી આપણે CS50 IDE પર પૉપ દો અને
PHP, ફાઈલો એક દંપતિ પર એક નજર હોય છે,

582
00:29:12,850 --> 00:29:19,850
માં, PHP ફાઈલો એક દંપતિ ચાલી
CS50 IDE ની આદેશ વાક્ય ઈન્ટરફેસ.

583
00:29:19,850 --> 00:29:22,100
તેથી અહીં અમે CS50 IDE છે,
અને હું લિબર્ટી ભર્યું

584
00:29:22,100 --> 00:29:25,800
ના hello1.php તરીકે ઓળખાતી ફાઈલ ખોલ્યા.

585
00:29:25,800 --> 00:29:29,920
આ અને દેખીતી રીતે, સમાવિષ્ટો
ફાઇલ, ત્યાં માત્ર PHP વિભાજકો છે

586
00:29:29,920 --> 00:29:32,220
અને પડઘો વચ્ચે ("હેલો, વિશ્વ").

587
00:29:32,220 --> 00:29:34,710
આ એક ખૂબ સુંદર સરળ PHP કાર્યક્રમ છે.

588
00:29:34,710 --> 00:29:37,670
મેં હમણાં જ નીચે સ્ક્રોલ જાઉં છું
અહીં મારી ટર્મિનલ વિન્ડોમાં,

589
00:29:37,670 --> 00:29:44,320
અને હું PHP લખો જાઉં છું
hello1.php દાખલ હિટ.

590
00:29:44,320 --> 00:29:44,950
હેલો, વિશ્વ.

591
00:29:44,950 --> 00:29:48,110
કે અમે શું હતા કદાચ
તે શું અપેક્ષા, અધિકાર?

592
00:29:48,110 --> 00:29:51,140
>> ઉપર જાઓ અને લેવા દો
અન્ય એક કાર્યક્રમ જુઓ.

593
00:29:51,140 --> 00:29:52,924
hello2.php.

594
00:29:52,924 --> 00:29:55,090
ખૂબ ખૂબ જ વસ્તુ છે,
ઘણો અહીં પર નથી જતા.

595
00:29:55,090 --> 00:29:57,190
આ જ સમયે, છતાં, હું પૂછવા જાઉં છું
વપરાશકર્તા મને તેમના નામો આપે છે.

596
00:29:57,190 --> 00:29:59,290
હું ફરીથી કે readline કાર્ય ઉપયોગ કરું છું.

597
00:29:59,290 --> 00:30:01,340
$ નામ = readline.

598
00:30:01,340 --> 00:30:03,070
તે પ્રોમ્પ્ટ પર, છે "તમારું નામ શું છે?"

599
00:30:03,070 --> 00:30:04,880
>> દેખીતી રીતે હું છાપવા છું
તે તેના પોતાના વાક્ય પર.

600
00:30:04,880 --> 00:30:07,220
અને પછી, જેથી રેખા નીચે
કે પ્રોમ્પ્ટ હશે

601
00:30:07,220 --> 00:30:08,750
જ્યાં વપરાશકર્તા તેમના નામ દાખલ કરી શકો છો.

602
00:30:08,750 --> 00:30:12,030
અને પછી હું થોડો ના ઉપયોગ કરું છું
3 લીટી પર અહીં ચલ અવાંતર

603
00:30:12,030 --> 00:30:14,780
"હેલો" છાપે અને
ગમે તે વપરાશકર્તા પ્રકારો.

604
00:30:14,780 --> 00:30:22,040
તેથી આ હેલો, કહે છે માટે સરખું હોય છે,
અલ્પવિરામ,% s અમે સી માં printf ઉપયોગ કરતા હતા તો

605
00:30:22,040 --> 00:30:24,910
>> તેથી આપણે જાઓ અને આ કાર્યક્રમ અર્થઘટન દો.

606
00:30:24,910 --> 00:30:27,400
તેથી ફરી, હું સરકાવો પડશે
મારી ટર્મિનલ વિન્ડોમાં.

607
00:30:27,400 --> 00:30:29,070
PHP, hello2.php.

608
00:30:29,070 --> 00:30:31,920

609
00:30:31,920 --> 00:30:33,820
તમારું નામ શું છે?

610
00:30:33,820 --> 00:30:35,490
ડો.

611
00:30:35,490 --> 00:30:36,526
હેલો, ડો.

612
00:30:36,526 --> 00:30:39,440
હું પણ અન્ય છે
ફાઇલ hello3.php કહેવાય છે.

613
00:30:39,440 --> 00:30:42,850
હું સ્પષ્ટ કરવા જઇ રહ્યો છું મારા
નિયંત્રણ એલ સાથે સ્ક્રીન,

614
00:30:42,850 --> 00:30:46,210
અને મને લાગે છે કે ચલાવવા માટે જઇ રહ્યો છું.

615
00:30:46,210 --> 00:30:47,640
તમારું નામ શું છે?

616
00:30:47,640 --> 00:30:49,020
ડો.

617
00:30:49,020 --> 00:30:49,780
હેલો, ડો.

618
00:30:49,780 --> 00:30:56,540
તેથી વર્તન સમાન છે
hello2.php, પરંતુ તે શા hello3.php છે?

619
00:30:56,540 --> 00:30:58,040
>> ઠીક છે, અહીં તફાવત છે.

620
00:30:58,040 --> 00:31:00,620
આ કિસ્સામાં, નોટિસ
કે અહીં 1 વાક્ય પર,

621
00:31:00,620 --> 00:31:04,270
હું નથી કે કંઈક હોય
PHP, વિભાજકો વચ્ચે.

622
00:31:04,270 --> 00:31:07,760
હું માત્ર out-- અથવા હું છાપવા છું
ફક્ત "તમારું નામ શું છે?", ટાઇપ

623
00:31:07,760 --> 00:31:12,060
PHP દુભાષિયો આ જુએ છે, ત્યારે તેને
કોઈ વિચાર કેવી રીતે PHP, કે અર્થઘટન છે,

624
00:31:12,060 --> 00:31:15,060
અને તેથી, તેના બદલે નિષ્ફળ
તે માત્ર તે બહાર બોલે રહ્યું છે.

625
00:31:15,060 --> 00:31:19,010
>> તેથી, હવે 3 લીટી પર મારા કોલ નોટિસ
readline, હવે કોઈ પ્રોમ્પ્ટ છે.

626
00:31:19,010 --> 00:31:21,750
હું માત્ર ખરેખર રહ્યો ત્યારે જાઉં છું
PHP દુભાષિયો, આ જુએ છે

627
00:31:21,750 --> 00:31:23,400
તે બહાર છાપી રહ્યું છે
"તમારું નામ શું છે?"

628
00:31:23,400 --> 00:31:25,941
પછી તે here's--, ઠીક છે, ઓહ, જુએ છે
બાકીનું બધું હોઈ ચાલે છે

629
00:31:25,941 --> 00:31:29,970
તેથી, PHP તરીકે અર્થઘટન
આ કામ કરે છે કે શા માટે છે.

630
00:31:29,970 --> 00:31:34,990
હું જરૂરી પૂછવા નથી
readline અંદર વપરાશકર્તા રહ્યો,

631
00:31:34,990 --> 00:31:37,490
હું માત્ર તેને બહાર કરી શકે છે
PHP, વિભાજકો ના

632
00:31:37,490 --> 00:31:41,490
અને દુભાષિયો પરવાનગી આપે છે
માત્ર મારા માટે તે છાપે.

633
00:31:41,490 --> 00:31:45,364
>> તેથી જો તમે ખરેખર માત્ર નથી
PHP, વિભાજકો એક સમૂહ હોય

634
00:31:45,364 --> 00:31:46,030
તમારા કાર્યક્રમ.

635
00:31:46,030 --> 00:31:49,887
તમે ખરેખર, તે પૈકીના કેટલાક હોઈ શકે છે
ખોલવાનું અને તેમને જરૂરી બંધ.

636
00:31:49,887 --> 00:31:51,720
તેથી આપણે એક નજર કરીએ
કાર્યક્રમો એક દંપતિ

637
00:31:51,720 --> 00:31:55,070
જ્યાં CS50 IDE અમે
કર્યા આ વિચાર સમજાવે

638
00:31:55,070 --> 00:31:58,376
સીમાંકિત PHP ની બહુવિધ સુયોજિત કરે છે.

639
00:31:58,376 --> 00:32:02,010
>> ઠીક છે, તેથી હું એક ફાઇલ ખોલી છે
અહીં add1.php કહેવાય છે.

640
00:32:02,010 --> 00:32:03,390
અને અહીં શું થઈ રહ્યું છે નોટિસ.

641
00:32:03,390 --> 00:32:08,077
માત્ર પહેલા, હું એક
એક PHP વિભાજકો સેટ.

642
00:32:08,077 --> 00:32:10,660
હું છાપે જાઉં છું
સંદેશ, "મને એક નંબર આપો."

643
00:32:10,660 --> 00:32:13,394
પછી હું એક વાક્ય વાંચવા માટે જઇ રહ્યો છું અને
ચલ $ num1 માં સંગ્રહે છે.

644
00:32:13,394 --> 00:32:14,810
પછી હું ફરી છાપે જાઉં છું.

645
00:32:14,810 --> 00:32:16,310
મને એક બીજા નંબર આપો.

646
00:32:16,310 --> 00:32:20,450
વપરાશકર્તા સ્ટોર માંથી એક વાક્ય વાંચો
તેઓ $ num2 માં ટાઇપ ગમે.

647
00:32:20,450 --> 00:32:23,980
તેમને ઉમેરવા સાથે મળીને અને તે સ્ટોર
$ રકમ એક ચલ કહેવાય પરિણમી,

648
00:32:23,980 --> 00:32:26,180
અને પછી ", છાપે
આ બે નંબરો રકમ

649
00:32:26,180 --> 00:32:29,254
છે "અને પછી ઉપસ્થિત
ત્યાં ચલ $ રકમ.

650
00:32:29,254 --> 00:32:31,170
તેથી આપણે માત્ર આ સ્કોર દો
ઈન્ટરપ્રીટર દ્વારા

651
00:32:31,170 --> 00:32:33,720
આ અમે અપેક્ષા શું છે તેની ખાતરી કરવા માટે.

652
00:32:33,720 --> 00:32:37,540
PHP add1.php.

653
00:32:37,540 --> 00:32:38,665
મને એક નંબર, 3 આપો.

654
00:32:38,665 --> 00:32:40,410
મને એક બીજા નંબર 4 આપો.

655
00:32:40,410 --> 00:32:43,370
આ બે નંબર ની રકમ 7 છે.

656
00:32:43,370 --> 00:32:45,030
એટલે કે, 3 વત્તા 4 છે.

657
00:32:45,030 --> 00:32:45,530
ઠીક છે?

658
00:32:45,530 --> 00:32:47,770
ત્યાં કશું ભયંકર ફેન્સી.

659
00:32:47,770 --> 00:32:51,080
>> અને હવે આપણે add2.php ખોલો દો.

660
00:32:51,080 --> 00:32:54,460
અહીં, હું PHP ની એક દંપતિ મળી છે
ત્યાં સેટ સીમાંકિત, અધિકાર?

661
00:32:54,460 --> 00:32:59,107
લાઇન્સ 1, 3-- લાઇન્સ 1 અને
3 કોઈ PHP, વિભાજકો હોય છે.

662
00:32:59,107 --> 00:33:00,940
તેથી જ્યારે દુભાષિયો
તે માત્ર છે, તેમને જુએ છે

663
00:33:00,940 --> 00:33:03,220
બરાબર SPIT બનશે
શું હું ત્યાં ટાઇપ કરેલ છે.

664
00:33:03,220 --> 00:33:05,011
હું છું જ્યાં કે જેથી છે
મારા પૂછવાની બધા કરી.

665
00:33:05,011 --> 00:33:11,220
2 લાઇન્સ અને 4 પર, અમે જુઓ ખૂબ જ
પરિચિત $? વિભાજકો PHP, સૉર્ટ કરો,

666
00:33:11,220 --> 00:33:15,210
તેથી તે બે લીટીઓ છે
PHP, તરીકે ચલાવવા માટે જઈ રહી છે.

667
00:33:15,210 --> 00:33:18,270
અને પછી 5 રેખા પર, હું આ છે
અહીં અલૌકિક વસ્તુ, અધિકાર?

668
00:33:18,270 --> 00:33:20,480
આ કોણ કૌંસ
પ્રશ્ન ચિહ્ન સમાન સાઇન.

669
00:33:20,480 --> 00:33:22,660
હું પણ થોડો વધુ ઝૂમ પડશે.

670
00:33:22,660 --> 00:33:29,270
તમે આ હું છું શું છે જોઈ શકે છે
, જમણી ત્યાં વિશે આ $ વાત? =.

671
00:33:29,270 --> 00:33:33,420
>> તે છે કે જેથી સામાન્ય છે કે બહાર વળે
અમે PHP સમૂહ ખોલો કે કારણ

672
00:33:33,420 --> 00:33:36,055
વિભાજકો નીચેની છાપે છે.

673
00:33:36,055 --> 00:33:37,430
અને તે આપણે કરવા જઇ રહ્યા છો બધા છે.

674
00:33:37,430 --> 00:33:39,220
પરંતુ તે માટે પણ લઘુલિપિ છે.

675
00:33:39,220 --> 00:33:46,490
$? = કહેતા માટે PHP, લઘુલિપિ છે
$ કંઈક? પડઘો PHP રકમ

676
00:33:46,490 --> 00:33:48,350
num1 અને num2 છે.

677
00:33:48,350 --> 00:33:51,900
તેથી આ માત્ર અન્ય છે
તે માટે લઘુલિપિ.

678
00:33:51,900 --> 00:33:55,550
>> હું આ કાર્યક્રમ, PHP add2.php ચલાવી રહ્યા હોય તો તેથી.

679
00:33:55,550 --> 00:33:57,530
હું થોડો નીચે ઝૂમ પડશે.

680
00:33:57,530 --> 00:33:59,000
મને એક નંબર, 4 આપો.

681
00:33:59,000 --> 00:34:00,350
મને એક બીજા નંબર આપો.

682
00:34:00,350 --> 00:34:04,650
અને હું ખરેખર વિશે કાળજી નથી, કારણ કે
PHP, માં ડેટા પ્રકારો, હું 4.8 કહી શકો છો.

683
00:34:04,650 --> 00:34:07,160
આ બે નંબર ની રકમ 8.8 છે.

684
00:34:07,160 --> 00:34:10,179
તે કાર્ય ખૂબ ખૂબ વર્તે છે
અમે અપેક્ષા કરશે તરીકે બરાબર એ જ,

685
00:34:10,179 --> 00:34:10,989
તેમજ.

686
00:34:10,989 --> 00:34:13,114
અને હું એક વધુ ખોલી છે
અહીં dice.php કહેવાય છે.

687
00:34:13,114 --> 00:34:25,625

688
00:34:25,625 --> 00:34:26,250
આ ફરીથી પ્રયાસ.

689
00:34:26,250 --> 00:34:29,429

690
00:34:29,429 --> 00:34:33,280
હું એક વધુ અહીં કહેવાય છે
પણ જુઓ, જે dice1.php,

691
00:34:33,280 --> 00:34:37,440
કે કોણ કૌંસ પ્રશ્ન છે
ત્યાં સમાન સાઇન નોટેશનમાં માર્ક,

692
00:34:37,440 --> 00:34:40,659
પરંતુ આ કિસ્સામાં હું નોંધ્યું છે કે
કાર્ય રેન્ડ, ફોન કે જે તમે

693
00:34:40,659 --> 00:34:42,790
આશા રાખી શકે રેન્ડમ નંબર પેદા કરે છે.

694
00:34:42,790 --> 00:34:46,889
"તમે રોલ્ડ" અને તે ચાલી રહ્યું છે
+ + કેટલાક રેન્ડમ નંબર, ફેરફારની 6 ગણતરી

695
00:34:46,889 --> 00:34:47,389
1.

696
00:34:47,389 --> 00:34:49,989
જેથી મને નંબર આપવા પડશે
1 થી 6 ની રેન્જમાં.

697
00:34:49,989 --> 00:34:53,040
>> ફેરફારની 6 મને આપશે કે યાદ રાખો
0 થી 5 ની રેન્જમાં એક નંબર,

698
00:34:53,040 --> 00:34:56,630
પરંતુ હું ડાઇસ રોલ્સ સમાન રહ્યો છું તો,
જે હું અહીં શું કરી રહ્યો છું છે,

699
00:34:56,630 --> 00:35:00,040
હું આ ડાઇસ 0 થી જાઓ કરવા માંગો છો નથી
5, હું 1 થી 6 પર જાઓ કે ડાઇસ માંગો છો.

700
00:35:00,040 --> 00:35:02,800
અને તેથી આ કરવા માટે એક માર્ગ છે
1 થી 6 ની રેન્જમાં મને.

701
00:35:02,800 --> 00:35:04,720
હું બે વખત આ કરી રહ્યો છું.

702
00:35:04,720 --> 00:35:08,630
તેથી દેખીતી રીતે હું રોલિંગ છું
આ કાર્યક્રમ બે ડાઇસ.

703
00:35:08,630 --> 00:35:15,210
>> તેથી હું મારા સ્ક્રીન સાફ પડશે,
અને હું PHP dice1.php કરીશ.

704
00:35:15,210 --> 00:35:16,640
તમને 4 અને 2 વળેલું.

705
00:35:16,640 --> 00:35:19,156
અને હું કાર્યક્રમ ચલાવી રહ્યા હોય તો
ફરીથી, તમે 5 અને 5 વળેલું.

706
00:35:19,156 --> 00:35:21,780
તેથી હું કાર્યક્રમ ચલાવવા દરેક સમય,
હું વિવિધ નંબરો મેળવવામાં છું

707
00:35:21,780 --> 00:35:24,280
કારણ કે હું શું દર વખતે
તેથી, તે પર શરૂ કરવામાં આવ્યું છે.

708
00:35:24,280 --> 00:35:27,250
જો તે નવી પેદા કરવા જઈ રહ્યું છે
મારા માટે રેન્ડમ નંબરો સુયોજિત કરો.

709
00:35:27,250 --> 00:35:29,790
>> અમે ઉપયોગ કરી રહ્યાં છો તેથી
સી કાર્યક્રમો ચલાવી રહ્યા હોય,

710
00:35:29,790 --> 00:35:32,520
અમે ./ ટાઇપ ઉપયોગ કરી રહ્યાં છો
અધિકાર, એક કાર્યક્રમ નામ છે?

711
00:35:32,520 --> 00:35:35,090
કે અમે બધા કર્યું કેવી રીતે
સી અમારા કાર્યક્રમોનું અત્યાર સુધી.

712
00:35:35,090 --> 00:35:37,555
અમે તેમજ PHP, કરી શકો છો
કંઈક ઉમેરીને કહેવાય

713
00:35:37,555 --> 00:35:40,026
અમારા PHP ફાઈલ ટોચ પર એક shebang.

714
00:35:40,026 --> 00:35:41,400
હું તે એક અવિવેકી શબ્દ પ્રકારની છે ખબર છે કે.

715
00:35:41,400 --> 00:35:44,540
તે હેશ બેંગ માટે ટૂંકા છે.

716
00:35:44,540 --> 00:35:46,300
તે ત્યાં પ્રથમ બે અક્ષરો છે.

717
00:35:46,300 --> 00:35:50,030
અમે ઉદ્ગારવાચક બિંદુ કૉલ યાદ રાખો
કોમ્પ્યુટર વિજ્ઞાન વારંવાર બેંગ.

718
00:35:50,030 --> 00:35:51,690
તે પણ તીવ્ર બેંગ માટે હોઈ શકે છે.

719
00:35:51,690 --> 00:35:53,273
તે અર્થઘટન એક દંપતિ માર્ગો છે.

720
00:35:53,273 --> 00:35:57,320
પરંતુ તે મૂળભૂત રીતે એક ખાસ પ્રકારની છે
આદેશ કે PHP દુભાષિયો

721
00:35:57,320 --> 00:36:00,160
ઓહ, હું માંગો છો તરીકે સમજે છે
તમે આ કાર્યક્રમ ચલાવવા માટે,

722
00:36:00,160 --> 00:36:05,250
જે દેખીતી રીતે / વપરાશકર્તા / bin / php, જે
જ્યાં PHP દુભાષિયો ખરેખર છે

723
00:36:05,250 --> 00:36:08,590
ખાસ અમારી સિસ્ટમ પર રહે છે.

724
00:36:08,590 --> 00:36:12,530
It's-- તેથી શું છે અહીં થાય છે
ઈન્ટરપ્રીટર, ઓહ, સમજે છે

725
00:36:12,530 --> 00:36:17,270
હું દેખીતી રીતે વાપરવા માટે માનવામાં છું
આ કાર્યક્રમ આ ફાઇલ ચલાવવા માટે.

726
00:36:17,270 --> 00:36:20,010
અને તેથી તે તમને પરવાનગી આપે છે
આ પગલાં પર છોડવાનું

727
00:36:20,010 --> 00:36:22,979
PHP, something.php કહેવું કર્યા.

728
00:36:22,979 --> 00:36:25,020
એક અન્ય કેચ છે
અહીં, છે કે જે જો આપણે

729
00:36:25,020 --> 00:36:27,320
અમારા કાર્યક્રમો કરવા માંગો છો
ઈચ્છિત તરીકે, અમે કામ

730
00:36:27,320 --> 00:36:30,220
કહેવાય કંઈક કરવાની જરૂર છે
ફાઇલ પરવાનગી બદલો.

731
00:36:30,220 --> 00:36:33,380
અને અમે go-- પડશે અને અમે થોડી વાત
થોડી વધુ વિશે ફાઈલ પરવાનગી ફેરફારો

732
00:36:33,380 --> 00:36:37,550
અમારા MVC પર વિડિઓ છે, પરંતુ તે પૂરતો
આ તમે શું કરવાની જરૂર છે કહે છે કે

733
00:36:37,550 --> 00:36:42,760
કરવા માટે તમારા
PHP ફાઇલોને એક્ઝેક્યુટેબલ.

734
00:36:42,760 --> 00:36:49,330
તેથી આપણે આ પર એક નજર કરીએ
CS50 IDE અમારા અંતિમ ઉદાહરણ નહીં.

735
00:36:49,330 --> 00:36:53,910
>> તેથી અહીં IDE હું આ બે ફાઈલો હોય
પ્રયત્ન નથી દેખાય છે કે જે PHP ડિરેક્ટરી

736
00:36:53,910 --> 00:36:55,310
.PHP કહેવાય છે.

737
00:36:55,310 --> 00:36:58,170
હું કાર્ય કહેવાય છે add--
હું એક ફાઈલ કહેવાય add3 છે

738
00:36:58,170 --> 00:37:00,650
અને ફાઈલ dice2 કહેવાય છે.

739
00:37:00,650 --> 00:37:03,680
તેથી આપણે એક ઝડપી લેવા દો
જુઓ અને add3 ખોલો.

740
00:37:03,680 --> 00:37:08,300
અને તમે શરૂઆતમાં, જોઈ શકો છો
મારા ફાઈલ અધિકાર, હું આ shebang છે?

741
00:37:08,300 --> 00:37:11,420
આ હેશ ચિહ્ન ઉદ્ગારવાચક બિંદુ.

742
00:37:11,420 --> 00:37:15,115
હવે, તમે કદાચ પણ પડશે
કેટલાક કારણોસર કે નોટિસ,

743
00:37:15,115 --> 00:37:16,990
હું કોઇ વાક્યરચના નથી
હવે પ્રકાશ,

744
00:37:16,990 --> 00:37:20,198
અને આ હું અગાઉ ખોટો સંદર્ભ આપવામાં આવ્યો છે તે છે
જે હું મારી ફાઇલ નામ ન હોય તો એ હતો કે

745
00:37:20,198 --> 00:37:23,040
PHP, હું લાભ નથી
વાક્યરચના હવે પ્રકાશ.

746
00:37:23,040 --> 00:37:26,220
આ ફાઇલ માત્ર add3 કહેવામાં આવે છે.

747
00:37:26,220 --> 00:37:30,960
હું પાછળથી પણ ચલાવી શકો છો કે જેથી
./ add3 નથી અને ./ add3.php છે.

748
00:37:30,960 --> 00:37:33,680
>> તેથી reason-- તે હજુ પણ છે
દંડ, તે હજુ પણ માન્ય PHP છે,

749
00:37:33,680 --> 00:37:37,000
પરંતુ તે છે, કારણ કે પ્રકાશિત વાક્યરચના નથી
આ ફાઇલ something.php કહેવાય.

750
00:37:37,000 --> 00:37:41,580
કે જે આ જ વાસ્તવિક તફાવત છે
અહીં, વત્તા shebang.

751
00:37:41,580 --> 00:37:45,170
તેથી આપણે શું થાય છે જ્યારે તે જોવા દો
હું પ્રયત્ન કરો અને આ કાર્યક્રમ ચલાવો.

752
00:37:45,170 --> 00:37:50,780
./ Add3, માત્ર હું સી બાસ સાથે આવે.

753
00:37:50,780 --> 00:37:53,190
./ Add3 પરવાનગી નકારી શકાય છે.

754
00:37:53,190 --> 00:37:55,390
આ તમને જઈ રહ્યાં છો શું છે
તમે ભૂલી જાવ તો જોવા માટે

755
00:37:55,390 --> 00:37:59,280
બદલવા માટે chmod આદેશ વાપરવા માટે
ફાઈલ પરવાનગીઓ.

756
00:37:59,280 --> 00:38:03,845
>> તે નિયમિત PHP તારણ
ફાઈલો લાગુ કરી શકાય નહીં.

757
00:38:03,845 --> 00:38:06,970
તેઓ અર્થઘટન કરી શકાય છે, પરંતુ અમે છો
અહીં થોડી અલગ કંઈક કરવાનું.

758
00:38:06,970 --> 00:38:07,761
અમે તે અમલ કરી રહ્યા છીએ.

759
00:38:07,761 --> 00:38:12,970
અને તેથી હું પરવાનગી ઉમેરવાની જરૂર છે
અમલ, એક + X માટે add3 chmod.

760
00:38:12,970 --> 00:38:15,680
પછી હું ./ add3 કહી શકો છો.

761
00:38:15,680 --> 00:38:16,860
મને એક નંબર આપો.

762
00:38:16,860 --> 00:38:18,060
5, 6.

763
00:38:18,060 --> 00:38:20,490
આ બે નંબર ની રકમ 11 છે.

764
00:38:20,490 --> 00:38:26,530
>> એ જ રીતે, હું પહેલેથી જ chmoded છે
dice2, તેથી હું માત્ર, dice2 ./ ટાઈપ કરી શકો છો

765
00:38:26,530 --> 00:38:31,260
તમે 1 અને 1 વળેલું, તમે
તેથી 5 અને 4, અને વળેલું.

766
00:38:31,260 --> 00:38:33,680
>> તેથી તે ખૂબ ખૂબ છે
એક PHP, વાક્યરચના વિચાર, અધિકાર?

767
00:38:33,680 --> 00:38:35,221
મારફતે વિચાર ઘણો છે, મને ખબર છે.

768
00:38:35,221 --> 00:38:39,160
પરંતુ આસ્થાપૂર્વક તમે કે PHP, હવે જોઇ
સી થી ખરેખર અલગ નથી

769
00:38:39,160 --> 00:38:43,670
અને ખરેખર અમને ક્ષમતા આપે છે
એક અથવા બે કાપો વસ્તુઓ લેવા માટે.

770
00:38:43,670 --> 00:38:48,230
અમે ખરેખર ચિંતા કરવાની જરૂર નથી
અમે ખરેખર નથી about-- ખૂબ

771
00:38:48,230 --> 00:38:51,605
વિશે ખૂબ ચિંતા કરવાની જરૂર
નીચા-સ્તર વિગતો અમે

772
00:38:51,605 --> 00:38:52,980
અધિકાર, C સાથે ચિંતા હતી?

773
00:38:52,980 --> 00:38:56,170
અમે ઊંચી પર ધ્યાન કેન્દ્રિત કરી શકો છો
સ્તર સામગ્રી છે કે જે PHP

774
00:38:56,170 --> 00:39:01,090
અમને શું કરવા માટે પરવાનગી આપે છે અને લેવા માટે
તે અમારા માટે કામ કરશે કે આપી હતી.

775
00:39:01,090 --> 00:39:04,350
તેથી તે, અમને હમણાં ક્ષમતા આપે છે
PHP, C સંક્રમણ,

776
00:39:04,350 --> 00:39:08,280
ઘણો વધુ છે કે જે કાર્યક્રમો બનાવવા માટે
જટિલ અને કદાચ ઘણો વધુ મજબૂત.

777
00:39:08,280 --> 00:39:13,070
>> તેથી હું તમને મજા કામ છે આશા
PHP, સાથે, અને હું ડો લોયડ છું.

778
00:39:13,070 --> 00:39:15,050
આ CS50 છે.

779
00:39:15,050 --> 00:39:17,637