1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [8 વિભાગ - વધુ અનુકૂળ]

2
00:00:02,610 --> 00:00:04,910
[રોબ બોડેન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,910 --> 00:00:07,070
[આ CS50 છે. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> આ સપ્તાહ વિભાગ નોંધોને માટે ખૂબ ટૂંકા હશે આવે છે,

5
00:00:14,160 --> 00:00:19,070
જેથી હું માત્ર વાતો રાખવા જાઉં છું, તમે ગાય્સ પ્રશ્નો પૂછવા રાખવા જતાં હોય છે,

6
00:00:19,070 --> 00:00:22,720
અને અમે સુધી શક્ય એટલું સમય ભરવા પ્રયાસ કરીશું.

7
00:00:22,720 --> 00:00:31,950
ઘણા લોકો એમ લાગે છે કે આ pset જરૂરી મુશ્કેલ નથી, પણ તે ખૂબ જ લાંબો છે.

8
00:00:31,950 --> 00:00:37,070
આ pset પોતે સ્પેક એક કલાક વાંચવા માટે લઈ જાય છે.

9
00:00:40,530 --> 00:00:45,730
અમે તમને એસક્યુએલ ઘણો તમે કદાચ વાપરવા માટે જરૂર શકે છે.

10
00:00:45,730 --> 00:00:50,520
અમે તમને તે ઘણો લઈ જવામાં છે, તેથી તે ખૂબ ખરાબ ન હોવી જોઈએ.

11
00:00:50,520 --> 00:00:54,560
છે કોઈને શરૂ અથવા સમાપ્ત થાય?

12
00:00:55,380 --> 00:00:59,710
તે છેલ્લા pset છે. ઓહ, મારા પ્રભુ.

13
00:00:59,710 --> 00:01:05,400
સામાન્ય રીતે આ પછી એક જાવાસ્ક્રિપ્ટ, પરંતુ કૅલેન્ડર ફેરફાર વસ્તુઓ

14
00:01:05,400 --> 00:01:09,560
1 અઠવાડિયા ટૂંકા બધું કરે છે, અને અમે લાંબા સમય સુધી જાવાસ્ક્રિપ્ટ pset છે.

15
00:01:09,560 --> 00:01:12,310
મને ખબર નથી કે કેવી રીતે અસર કરે છે કે છે કે શું કરવા માટે JavaScript પરીક્ષા પર દેખાય રહ્યું છે

16
00:01:12,310 --> 00:01:15,510
અથવા 1 કિવઝઃ.

17
00:01:15,510 --> 00:01:22,260
હું કલ્પના તે કંઈક હશે તમે જાવાસ્ક્રિપ્ટ વિશે ઉચ્ચ સ્તરીય વસ્તુઓ જાણવાની જરૂર પડશે,

18
00:01:22,260 --> 00:01:26,460
પરંતુ હું શંકા અમે ફક્ત તમે સીધા JavaScript કોડ આપો છો

19
00:01:26,460 --> 00:01:28,720
કારણ કે તમે તેને એક pset થયું નથી.

20
00:01:28,720 --> 00:01:33,000
પરંતુ ક્વિઝ સમીક્ષા માટે સામગ્રી આગામી સપ્તાહમાં થશે.

21
00:01:33,000 --> 00:01:36,320
>> પ્રશ્નો વિભાગ.

22
00:01:36,320 --> 00:01:43,870
આ સામગ્રી ઘણાં અંશે શબ્દોમાં નબળી છે, પરંતુ અમે ચર્ચા કરીશું શા માટે.

23
00:01:43,870 --> 00:01:50,220
સી વિપરીત, PHP એક "ગતિશીલતાથી લખેલા" ભાષા છે. આ શું અર્થ છે, તમને?

24
00:01:50,220 --> 00:01:53,830
વેલ, ગુડબાય કહે છે તે ચાર રચે છે, ફ્લોટ, પૂર્ણાંક, અને અન્ય કીવર્ડ્સ બધા તમે ઉપયોગ કરવા જરૂર

25
00:01:53,830 --> 00:01:56,190
જ્યારે ચલો અને સી કાર્યો જાહેર

26
00:01:56,190 --> 00:02:00,420
PHP માં, એક ચલ પ્રકાર મૂલ્ય કે તે હાલમાં હોલ્ડિંગ છે દ્વારા નક્કી થાય છે.

27
00:02:00,420 --> 00:02:04,990
તેથી પહેલાં અમે એક dynamic.php તરીકે ઓળખાતી ફાઈલ આ કોડને લખો

28
00:02:04,990 --> 00:02:12,670
PHP ગતિશીલ લખ્યો છે. કે સાચું છે.

29
00:02:12,670 --> 00:02:17,590
હું એ હકીકત છે કે તેનો અર્થ એ કે અમે ગુડબાય ઘરનાં પરચૂરણ કામો, ફ્લોટ માટે કહી રહ્યાં છે, પૂર્ણાંક સાથે અસહમત છે,

30
00:02:17,590 --> 00:02:20,620
અને અન્ય કીવર્ડ્સ.

31
00:02:20,620 --> 00:02:25,510
ગતિશીલ લખેલા અને વૈકલ્પિક વચ્ચે ચોક્કસ તફાવત,

32
00:02:25,510 --> 00:02:32,010
જે સ્થિર લખ્યો છે, કે જે ગતિશીલ લખ્યો, તમારા પ્રકાર ચકાસણી અને સામગ્રી તમામ

33
00:02:32,010 --> 00:02:37,350
રન સમયે થાય છે, જ્યારે સ્થિર લખ્યો તે કમ્પાઇલ સમયે થાય છે.

34
00:02:37,350 --> 00:02:43,030
આ સામાન્ય રીતે સ્થિર શબ્દ માટે કમ્પાઇલ સમય વસ્તુઓ અર્થ લાગે છે.

35
00:02:43,030 --> 00:02:48,170
હું માનું ત્યાં તે માટે અન્ય ઉપયોગો છે, પરંતુ સી જ્યારે તમે સ્થિર ચલ જાહેર માં,

36
00:02:48,170 --> 00:02:52,650
તેના સંગ્રહ કમ્પાઇલ સમયે ફાળવેલ છે.

37
00:02:52,650 --> 00:02:59,260
અહીં, ગતિશીલ લખ્યો ફક્ત તેનો અર્થ એ કે -

38
00:02:59,260 --> 00:03:04,350
સી જો તમે શબ્દમાળા અને પૂર્ણાંક ઉમેરવા માટે, જ્યારે તમે તેને કમ્પાઇલ પ્રયત્ન કરો,

39
00:03:04,350 --> 00:03:11,000
તે ફરિયાદ કારણ કે તે કહે છે કે તમે પૂર્ણાંક અને નિર્દેશક ઉમેરી શકતા નથી ચાલી રહ્યું છે બનશે.

40
00:03:11,000 --> 00:03:14,710
તે માત્ર એક માન્ય કામગીરી નથી.

41
00:03:14,710 --> 00:03:21,170
કે અન્ય ચીજ છે કે અમે એક બીજા મળશે છે.

42
00:03:21,170 --> 00:03:24,860
પરંતુ ચકાસણી કે આનાથી સૉર્ટ કરો, હકીકત એ છે કે તે કમ્પાઇલ સમયે ફરિયાદ

43
00:03:24,860 --> 00:03:29,220
સ્થિર પ્રકાર ચકાસણી છે.

44
00:03:29,220 --> 00:03:35,220
ત્યાં ભાષાઓ જ્યાં તમે ઘરનાં પરચૂરણ કામો, ફ્લોટ, પૂર્ણાંક કહેવું જરૂરી નથી, અને તે બધું છે,

45
00:03:35,220 --> 00:03:40,940
પરંતુ ભાષા વસ્તુ ના સંદર્ભમાં કહેવું પ્રકાર તે શું હશે તેવું માનવામાં કરી શકો છો,

46
00:03:40,940 --> 00:03:43,980
પરંતુ તે હજુ પણ સ્થિર લખ્યો છે.

47
00:03:43,980 --> 00:03:49,000
તેથી જો તમે OCaml 51, લો, તમે ક્યારેય આ પ્રકારના કોઇ પણ ઉપયોગ કરે છે,

48
00:03:49,000 --> 00:03:58,700
પરંતુ તે હજુ કમ્પાઇલ સમયે કહેવું તમે આ નથી કારણ કે તમે પૂર્ણાંક છે અને શબ્દમાળાનો મિશ્રણ કરી શકો છો કરશે.

49
00:03:58,700 --> 00:04:05,650
ગતિશીલ લખ્યો માત્ર અર્થ એ થાય કે સ્કોર સમય દરમિયાન કેટલીકવાર તમે ફરિયાદ વિચાર જઈ રહ્યાં છો.

50
00:04:05,650 --> 00:04:13,430
જો તમે પણ જાવા આવે તે પહેલા સામાન્ય રીતે તેનો ઉપયોગ લગભગ કોઈ પણ ભાષા C-પ્રકાર

51
00:04:13,430 --> 00:04:20,070
છે સ્થિર, લખ્યો શકાય છે, જેથી C, C + +, જાવા, તે તમામ સામાન્ય રીતે સ્થિર લખ્યો છે જઈ રહી છે.

52
00:04:20,070 --> 00:04:22,910
જાવા માં જ્યારે તમે કંઈક કમ્પાઇલ અને તમે કહી રહ્યાં છે

53
00:04:22,910 --> 00:04:26,670
શબ્દમાળા ઓ કંઈક નવું છે કે જે શબ્દમાળા નથી સમકક્ષ,

54
00:04:26,670 --> 00:04:28,950
કે ફરિયાદ કારણ કે તે પ્રકારના હમણાં મેળ ખાતા નથી ચાલી રહ્યું છે.

55
00:04:28,950 --> 00:04:31,180
કે કમ્પાઇલ સમયે ફરિયાદ બનશે.

56
00:04:31,180 --> 00:04:36,750
પરંતુ તે પણ કેટલાક ગતિશીલ સમય વસ્તુઓ ગમે છે જો તમે કંઈક ભૂમિકા પ્રયાસ

57
00:04:36,750 --> 00:04:40,500
એક પ્રકાર છે કે જે તેના વર્તમાન પ્રકાર કરતાં ચોક્કસ કરવા માટે,

58
00:04:40,500 --> 00:04:45,610
ત્યાં કશું કમ્પાઇલ સમયે કરવું કે કેમ તેની તપાસ કે કાસ્ટ માટે સફળ રહ્યું છે કરી શકો છો.

59
00:04:45,610 --> 00:04:51,130
જાવા પણ કેટલાક ગતિશીલ કે ચકાસણી પ્રકાર છે જલદી તે કોડ કે વાક્ય નોંધાયો નહીં

60
00:04:51,130 --> 00:04:54,130
જ્યારે તે વાસ્તવમાં ચલાવવા છે, તે કાસ્ટ કરી રહ્યું છે,

61
00:04:54,130 --> 00:04:56,260
તપાસો જો કે કાસ્ટ પ્રથમ સ્થાને માન્ય હતું,

62
00:04:56,260 --> 00:04:59,890
અને જો તે ન હતો, પછી તે ફરિયાદ કરે છે કે તમે એક અમાન્ય પ્રકાર હોય બનશે.

63
00:04:59,890 --> 00:05:03,200
ગતિશીલ પ્રકાર ચકાસણી.

64
00:05:03,200 --> 00:05:07,010
એક dynamic.php તરીકે ઓળખાતી ફાઈલ આ લખો.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
હું કે ફોર્મેટિંગ ઝિપસાંકળ છોડવી પડશે.

67
00:05:18,750 --> 00:05:21,880
અમે એક ચલ છે, તો અમે તે પૂર્ણાંક 7 પર સેટ હોય,

68
00:05:21,880 --> 00:05:27,930
પછી અમે તેને અને% s છાપી રહ્યા છીએ -

69
00:05:27,930 --> 00:05:32,830
ઓહ, અમે તેને પ્રકાર છાપવા છીએ, જેથી gettype માટે ચલની પ્રકાર પાછા જઈ રહ્યું છે.

70
00:05:32,830 --> 00:05:35,720
અમે હમણાં જ પ્રકાર રહ્યાં છો પર અને ઉપર ફરીથી છાપી.

71
00:05:35,720 --> 00:05:39,440
અમે હમણાં જ php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
અમે જોશો કે તે પૂર્ણાંક માંથી બુલિયન માટે શબ્દમાળા ફેરફારો તરીકે અમે પસાર થાય છે.

73
00:05:45,920 --> 00:05:54,590
સી ત્યાં કોઈ બુલિયન માહિતી પ્રકાર છે, ત્યાં કોઈ શબ્દમાળા માહિતી પ્રકાર છે.

74
00:05:54,590 --> 00:06:00,500
ત્યાં ઘરનાં પરચૂરણ કામો * અને બુલિયન માત્ર પૂર્ણાંક અથવા ઘરનાં પરચૂરણ કામો અથવા કંઈક હોઇ શકે છે.

75
00:06:00,500 --> 00:06:05,690
PHP આ પ્રકારના અસ્તિત્વમાં નથી, અને તે એક સી ઉપર PHP ની મોટી ફાયદો છે -

76
00:06:05,690 --> 00:06:13,290
કે જેઓ શબ્દમાળા કામગીરી અનંત સી કરતાં PHP સરળ તેઓ માત્ર કામ કરે છે.

77
00:06:13,290 --> 00:06:18,290
>> તેથી અમે અહીં પાછા આવો.

78
00:06:18,290 --> 00:06:21,260
અમે dynamic.php ચાલી હતી.

79
00:06:21,260 --> 00:06:26,710
આ PHP દુભાષિયો, php કહેવાય છે, માટે dynamic.php માં PHP કોડ સ્કોર કહે છે.

80
00:06:26,710 --> 00:06:30,250
જો તમે ફાઈલમાં કોઈપણ ભૂલો હોય, તો દુભાષિયો તમે કહેશે!

81
00:06:30,250 --> 00:06:39,110
ઈન્ટરપ્રીટર, આ PHP અને સી વચ્ચે બીજી મોટી તફાવત છે

82
00:06:39,110 --> 00:06:48,200
સી માં તમે કંઈક કમ્પાઇલ અને પછી તમે તે ફાઈલ કમ્પાઈલ સ્કોર છે.

83
00:06:48,200 --> 00:06:50,490
તમે PHP પણ ક્યારેય કમ્પાઇલ.

84
00:06:50,490 --> 00:06:57,200
તેથી PHP દુભાષિયો મૂળભૂત માત્ર છે રેખા દ્વારા આ વાક્ય વાંચ્યું હતું.

85
00:06:57,200 --> 00:07:02,900
તે બનાવ્યા var = 7 પછી તેને printf પછી બનાવ્યા તે વાર પછી બનાવ્યા તે printf અને તેથી બનાવ્યા.

86
00:07:02,900 --> 00:07:10,910
ત્યાં કમ્પાઇલ તેને એક બીટ છે, અને તે પરિણામો કેશ કરે છે

87
00:07:10,910 --> 00:07:15,510
તેથી જો તમે સ્ક્રિપ્ટ ચલાવી પછીથી તમને કેટલીક કરી શકો છો,

88
00:07:15,510 --> 00:07:19,280
પરંતુ મૂળભૂત રીતે તે વસ્તુ વાક્ય આનાથી સૉર્ટ કરો લાઇન છે.

89
00:07:19,280 --> 00:07:25,280
તેનો અર્થ એ છે કે ઑપ્ટિમાઇઝેશંસ કે અમે સી વિચાર ઘણો,

90
00:07:25,280 --> 00:07:31,920
સંકલન જેવી, તે માત્ર સામાન્ય છે ત્યારે કમ્પાઇલર તમારા માટે યુક્તિઓ ઘણો કરી શકો છો.

91
00:07:31,920 --> 00:07:36,110
તે બિનઉપયોગી ચલો લાગી શકે છે, તે વસ્તુઓ આ પ્રકારની તમામ કરી શકો છો,

92
00:07:36,110 --> 00:07:38,660
તે પૂંછડી રિકર્ઝન કરી શકો છો.

93
00:07:38,660 --> 00:07:42,550
PHP માં તમે તે લાભ ન ​​મેળવી રહ્યા છીએ

94
00:07:42,550 --> 00:07:45,690
કારણ કે તે માત્ર વાક્ય દ્વારા વાક્ય દ્વારા વાક્ય ચલાવવા શરૂ ચાલી રહ્યું છે,

95
00:07:45,690 --> 00:07:49,950
અને તે ખરેખર આ બધી વસ્તુઓ ઓળખતું નથી તરીકે સરળતાથી

96
00:07:49,950 --> 00:07:54,440
કારણ કે તે આ વસ્તુ પર 1 મોટું સંકલન પાસ અને પછી અમલ નથી;

97
00:07:54,440 --> 00:07:56,860
તે માત્ર વાક્ય દ્વારા વાક્ય છે.

98
00:08:00,730 --> 00:08:02,750
જેથી ઈન્ટરપ્રીટર છે.

99
00:08:02,750 --> 00:08:06,840
>> અમારા ગતિશીલ ટાઈપ પાછળ: સરસ, એમ?

100
00:08:06,840 --> 00:08:08,640
તમે ચોક્કસપણે કે સી ન કરી શકે!

101
00:08:08,640 --> 00:08:11,860
હવે, જુઓ જો તમે નીચેની કિંમતો દરેક પ્રકાર આકૃતિ કરી શકો છો.

102
00:08:11,860 --> 00:08:14,760
સંદર્ભ માટે આ જુઓ.

103
00:08:14,760 --> 00:08:19,420
3.50 તેથી. તમે કયા પ્રકારનું વિચારો છો કે જે જ હશે?

104
00:08:24,480 --> 00:08:26,370
અહીં પ્રકારના અમે હોય છે.

105
00:08:26,370 --> 00:08:30,430
અમે bools, પૂર્ણાંકો, ફ્લોટિંગ પોઇન્ટ સ્ટ્રિંગ્સ, એરે, પદાર્થો હોય,

106
00:08:30,430 --> 00:08:38,370
અને પછી સ્રોતો, કે જે અસ્પષ્ટ પ્રકારની છે.

107
00:08:38,370 --> 00:08:41,010
મને લાગે છે કે ત્યાં ખરેખર એક ઉદાહરણ છે અહીં.

108
00:08:41,010 --> 00:08:43,740
તો પછી ત્યાં NULL છે. NULL એક ખાસ પ્રકાર છે.

109
00:08:43,740 --> 00:08:47,140
સી જ્યાં NULL માત્ર 0 સરનામાં સાથે એક નિર્દેશક છે જેમ નહિં પણ,

110
00:08:47,140 --> 00:08:54,930
PHP માં, NULL પોતાના પ્રકાર જ્યાં માત્ર તે પ્રકારના માન્ય વસ્તુ NULL છે.

111
00:08:57,560 --> 00:09:00,670
આ વધુ ભૂલ ચકાસણી માટે ઉપયોગી બને છે.

112
00:09:00,670 --> 00:09:04,310
સી જ્યાં અમે આ મુદ્દો કે જ્યાં જો તમે NULL પાછા હતો,

113
00:09:04,310 --> 00:09:08,660
કરતું નથી તો તેનો અર્થ એ તમે NULL નિર્દેશક પરત કરી રહ્યાં છે અથવા NULL મદદથી ભૂલ બતાવે છે

114
00:09:08,660 --> 00:09:12,380
અથવા તે મૂંઝવણ તમામ અમે એક તબક્કે હતો.

115
00:09:12,380 --> 00:09:18,440
અહીં, NULL પરત સામાન્ય ભૂલ થાય છે.

116
00:09:20,860 --> 00:09:27,300
વસ્તુઓ ઘણાં પણ ભૂલ માટે ખોટા આવો.

117
00:09:27,300 --> 00:09:33,140
પરંતુ બિંદુ NULL પ્રકાર છે, NULL પ્રકાર માત્ર વસ્તુ NULL છે.

118
00:09:33,140 --> 00:09:40,090
પછી કૉલબૅક છે કે તમે અમુક અનામિક વિધેયો વ્યાખ્યાયિત કરી શકો છો.

119
00:09:40,090 --> 00:09:46,420
તમે એ વિધેય એક નામ આપો નથી, પરંતુ તમે તે અહીં કામ પાર નથી.

120
00:09:46,420 --> 00:09:53,940
આ પ્રકારની છીએ કે તેઓ અમને જાણવા માટે અપેક્ષા નથી,

121
00:09:53,940 --> 00:09:59,000
તમે શું વિચારો છો 3.50 પ્રકાર છે? >> [વિદ્યાર્થી] રહેલું.

122
00:09:59,000 --> 00:10:00,370
યાહ.

123
00:10:00,370 --> 00:10:06,290
તેથી તે પછી અહીં, તમે શું વિચારો છો આ પ્રકાર છે? >> [વિદ્યાર્થી] અરે.

124
00:10:06,290 --> 00:10:09,890
યાહ. પ્રથમ એક ફ્લોટ હતા, બીજા એક વ્યૂહરચના છે.

125
00:10:09,890 --> 00:10:14,500
નોંધ કરો કે આ એરે એક સી એરે જેવી નથી

126
00:10:14,500 --> 00:10:19,610
1 અનુક્રમણિકા, કે જ્યાં તમે અનુક્રમણિકા હોય 0 અમુક મૂલ્ય ધરાવે છે અમુક મૂલ્ય ધરાવે છે.

127
00:10:19,610 --> 00:10:26,320
અહીં સૂચકાંકો એ, બી, સી અને છે અને કિંમતો 1, 2 અને 3 છે.

128
00:10:26,320 --> 00:10:33,980
PHP ત્યાં એક સમૂહનો એરે અને માત્ર એક નિયમિત એરે વચ્ચે કોઈ તફાવત નથી

129
00:10:33,980 --> 00:10:36,740
કારણકે તમે તેને સી માં લાગે કરશે

130
00:10:36,740 --> 00:10:43,040
ત્યાં આ માત્ર છે, અને હૂડ નીચે નિયમિત એરે માત્ર એક સમૂહનો એરે છે

131
00:10:43,040 --> 00:10:50,000
જ્યાં અમુક મૂલ્ય 0 એ જ રીતે નકશા અમુક મૂલ્ય એક અે નકશાઓ.

132
00:10:50,000 --> 00:11:00,410
આ કારણોસર, PHP ખૂબ ખરાબ ખરેખર ઝડપી / કોડ કસોટી સર્વેક્શણોની વસ્તુઓ માટે હોઈ શકે છે

133
00:11:00,410 --> 00:11:07,930
કારણ કે સી માં જ્યારે તમે એરે ઉપયોગ કરી રહ્યા છો તમે જાણો છો કે સભ્ય ઍક્સેસ સતત સમય છે.

134
00:11:07,930 --> 00:11:11,860
PHP સભ્ય ઍક્સેસ છે જે કેટલો સમય જાણે?

135
00:11:11,860 --> 00:11:18,970
તે કદાચ સતત છે હેશો તે બરાબર હોય.

136
00:11:18,970 --> 00:11:21,620
કોણ જાણે તે શું ખરેખર હૂડ નીચે કરવાનું છે?

137
00:11:21,620 --> 00:11:25,600
તમે ખરેખર અમલીકરણ જોવા કેવી રીતે તે સાથે વ્યવહાર રહ્યું છે જરૂર છે.

138
00:11:25,600 --> 00:11:28,550
તેથી પછી fopen.

139
00:11:28,550 --> 00:11:36,420
હું અહીં મતે ફક્ત PHP જાતે fopen માટે વળતર પ્રકાર જોવા દો.

140
00:11:36,420 --> 00:11:41,260
અમે અહીં જુઓ તમે ખૂબ ખૂબ PHP માર્ગદર્શિકામાં શકાય છે અને કોઈપણ કાર્ય જુઓ

141
00:11:41,260 --> 00:11:47,540
અને આ PHP ની મદદ પાનાં જેવું છે.

142
00:11:47,540 --> 00:11:51,060
પરત પ્રકાર માટે સ્ત્રોત રહ્યું છે.

143
00:11:51,060 --> 00:11:56,050
કે શા માટે હું તે જોવામાં અપ છે, કારણ કે અમે ખરેખર સંસાધન વ્યાખ્યાયિત ન થઇ ન હતી.

144
00:11:56,050 --> 00:12:04,110
સ્ત્રોત ના વિચાર, સી માં તમે પ્રકારની ફાઇલ * અથવા જે મળ્યું;

145
00:12:04,110 --> 00:12:07,200
PHP માં સ્ત્રોત તમારી ફાઈલ * છે.

146
00:12:07,200 --> 00:12:10,360
તે માટે તમે શું માંથી વાંચવા કરી રહ્યા છીએ, તે કરવા માટે તમારે શું લખી શકાય જઈ રહ્યાં છો.

147
00:12:10,360 --> 00:12:20,710
તે સામાન્ય રીતે બાહ્ય છે, તેથી તે સ્ત્રોત તમે વસ્તુઓ માંથી ખેંચવાનો અને વસ્તુઓ ફેંકવું કરી શકો છો.

148
00:12:20,710 --> 00:12:26,520
અને આખરે, શું NULL પ્રકાર છે? >> [વિદ્યાર્થી] NULL.

149
00:12:26,520 --> 00:12:30,650
યાહ. તેથી જ વસ્તુ કે NULL છે NULL છે.

150
00:12:30,650 --> 00:12:33,480
NULL NULL છે.

151
00:12:35,490 --> 00:12:41,170
>> માતાનો PHP પ્રકાર સિસ્ટમ (વધુ સારા માટે અથવા ખરાબ માટે) એક લક્ષણ એ તેની પ્રકારના juggle ક્ષમતા છે.

152
00:12:41,170 --> 00:12:44,390
, જ્યારે તમે PHP કોડ કે જે વિવિધ પ્રકારના કિંમતો જોડે એક વાક્ય લખી

153
00:12:44,390 --> 00:12:46,670
PHP માટે સંવેદનશીલ વસ્તુ કરવા પ્રયત્ન કરશે.

154
00:12:46,670 --> 00:12:48,920
બહાર PHP કોડ નીચેની લીટીઓ દરેક પ્રયાસ કરો. શું છપાયેલ છે?

155
00:12:48,920 --> 00:12:51,000
તે તમે શું ઈચ્છિત? શા અથવા શા માટે નથી?

156
00:12:51,000 --> 00:12:58,600
PHP વિશે આ હકીકત છે તે બનાવે છે, આપણે શું નબળું લખેલા ફોન કરો.

157
00:12:58,600 --> 00:13:04,610
નબળું લખ્યો અને મજબૂત લખ્યો,

158
00:13:04,610 --> 00:13:06,840
ત્યાં તે શબ્દો માટે વિવિધ ઉપયોગો છે,

159
00:13:06,840 --> 00:13:12,020
પરંતુ મોટા ભાગના લોકો નબળું લખ્યો અને મજબૂત લખ્યો વાપરવા માટે વસ્તુ આ પ્રકારની અર્થ

160
00:13:12,020 --> 00:13:15,920
("1" + 2) જ્યાં; કે કામ કરે છે.

161
00:13:15,920 --> 00:13:18,290
સી કે કામ કરશે.

162
00:13:18,290 --> 00:13:22,490
તમે કામ નથી આ કલ્પના કરી શકો છો.

163
00:13:22,490 --> 00:13:29,200
ઘણા લોકો ઉપર ગતિશીલ ટાઇપિંગ અને નબળા ટાઇપિંગ અને સ્થિર ટાઇપિંગ અને મજબૂત ટાઈપ મિશ્રણ.

164
00:13:29,200 --> 00:13:34,050
અજગર એક ભાષા કે ગતિશીલ લખ્યો છે અન્ય એક દાખલો છે.

165
00:13:34,050 --> 00:13:41,770
તમે ચલોમાં પ્રકારના આસપાસ ફેંકવું અને તે રન સમયે તે નક્કી થઈ રહ્યું છે તે કરી શકો છો

166
00:13:41,770 --> 00:13:44,680
કોઈપણ ભૂલ checkings.

167
00:13:44,680 --> 00:13:50,740
Python માં તેને આ ચલાવો અને તે ("1" + 2) જોશે ચાલી રહ્યું છે;

168
00:13:50,740 --> 00:13:55,920
અને આ કારણ કે તમે શબ્દમાળા અને પૂર્ણાંક ઉમેરી શકતા નથી નિષ્ફળ જશે.

169
00:13:55,920 --> 00:14:00,860
PHP, જે ફક્ત તરીકે લખ્યો ગતિશીલ છે, આ નિષ્ફળ જશે.

170
00:14:00,860 --> 00:14:04,220
નબળા ટાઈપ એ હકીકત છે કે તે પ્રકારના વસ્તુઓ કરે છે સાથે કરી છે

171
00:14:04,220 --> 00:14:07,800
કે ખરેખર અર્થમાં જરૂરી નથી કરતી.

172
00:14:07,800 --> 00:14:17,420
તેથી ("1" + 2); હું કલ્પના કરી શકો છો કે જે 12 શબ્દમાળા છે, હું તે 3 શબ્દમાળા છે કલ્પના કરી શકો છો,

173
00:14:17,420 --> 00:14:20,710
હું તે પૂર્ણાંક 3 હોવાથી કલ્પના કરી શકો છો.

174
00:14:20,710 --> 00:14:24,530
તે આવશ્યકપણે જ વ્યાખ્યાયિત ન અને અમે કદાચ અહીં જોવા જઈ રહ્યાં છો

175
00:14:24,530 --> 00:14:29,140
કે જ્યારે અમે છાપો ("1" + 2); તે કદાચ અંત અલગ હોવા રહ્યું છે

176
00:14:29,140 --> 00:14:32,320
મુદ્રણ કરતાં (+ 1 "2").

177
00:14:32,320 --> 00:14:39,700
અને આ મારા મતે તો, ખરાબ માટે, કરે છે.

178
00:14:39,700 --> 00:14:44,240
અહીં અમે આ પ્રયાસ કરી શકો છો.

179
00:14:44,240 --> 00:14:48,740
PHP વિશે અન્ય થોડી ટ્રિક છે તમે ખરેખર ફાઇલ લખવાનો જરૂર નથી.

180
00:14:48,740 --> 00:14:52,790
તેને આ આદેશ સ્થિતિમાં છે ચાલતી નથી.

181
00:14:52,790 --> 00:14:57,710
Php-r તેથી, તો પછી અમે અહીં આદેશ ફેંકવું કરી શકો છો:

182
00:14:57,710 --> 00:15:06,610
"('1 '+ 2) પ્રિન્ટ;" અને હું એક નવા વાક્ય ફેંકવું પડશે.

183
00:15:19,550 --> 00:15:23,970
આ 3 મુદ્રણ.

184
00:15:31,100 --> 00:15:35,330
એવું લાગે છે કે તે 3 છાપે છે અને તે પૂર્ણાંક 3 છે.

185
00:15:35,330 --> 00:15:38,420
તેથી હવે આપણે આસપાસ અન્ય માર્ગ પ્રયાસ કરો:

186
00:15:38,420 --> 00:15:42,970
"છાપન (+ 1 ''2);

187
00:15:45,560 --> 00:15:50,490
અમે 3 વિચાર છે, અને તે પણ 3 પૂર્ણાંક હશે? હું પ્રામાણિકપણે કોઈ વિચાર હોય છે.

188
00:15:50,490 --> 00:15:54,030
એવું લાગે છે કે સુસંગત છે.

189
00:15:54,030 --> 00:15:59,550
ત્યાં તે શબ્દમાળા 12 જેવી કંઈપણ હોવાની કોઇ શક્યતા છે કે ક્યારેય છે

190
00:15:59,550 --> 00:16:08,080
કારણ કે PHP, વિપરીત જાવાસ્ક્રિપ્ટ અને ખૂબ જાવા,

191
00:16:08,080 --> 00:16:11,670
શૃંખલીકરણ માટે અલગ ઓપરેટર છે.

192
00:16:11,670 --> 00:16:14,930
PHP માં શૃંખલીકરણ ડોટ છે.

193
00:16:14,930 --> 00:16:22,950
છાપકામ તેથી (1 '2 '.); અમને 12 આપી રહ્યું છે.

194
00:16:25,790 --> 00:16:32,420
આ મૂંઝવણ માટે જીવી જ્યાં લોકો માટે str + + = કંઈક કામ કરવાનો પ્રયત્ન કરે છે

195
00:16:32,420 --> 00:16:37,840
કેટલાક અન્ય ચીજ છે કે તેઓ તેમના શબ્દમાળા ઓવરને પર ઉમેરવા માંગો છો, અને તે નિષ્ફળ રહ્યું છે.

196
00:16:37,840 --> 00:16:40,770
તમે str જરૂર =.

197
00:16:42,000 --> 00:16:46,240
તેથી ભૂલશો નહિં PHP માં શૃંખલીકરણ કોઈ છે.

198
00:16:46,240 --> 00:16:52,100
અન્ય પ્રયાસ વસ્તુઓ: છાપો (50 + "સીએસ");

199
00:16:55,750 --> 00:17:03,610
હું તમને કહ્યું છે કે આ માટે કોઈ આશા CS50 પરિણમે છે

200
00:17:03,610 --> 00:17:06,119
ત્યારથી શૃંખલીકરણ + + નથી.

201
00:17:06,119 --> 00:17:08,440
તમે શું વિચારો છો આ અંત છે જવાની છે?

202
00:17:10,359 --> 00:17:13,460
હું પ્રામાણિકપણે સંપૂર્ણપણે કોઈ વિચાર હોય છે.

203
00:17:14,250 --> 00:17:16,460
એવું લાગે છે કે તે ફક્ત 50.

204
00:17:16,460 --> 00:17:21,490
તે શબ્દમાળા જુએ છે, અને હું શરત જો આપણે 123CS મૂકે છે -

205
00:17:21,490 --> 00:17:29,640
તે પ્રથમ શબ્દમાળા જુએ છે, તે તેમાંથી એક પૂર્ણાંક અથવા તેને એક નંબર વાંચી પ્રયાસ કરે છે.

206
00:17:29,640 --> 00:17:31,710
આ કિસ્સામાં તે 123CS જુએ છે.

207
00:17:31,710 --> 00:17:35,190
"તે અર્થમાં પૂર્ણાંક તરીકે નથી, તેથી હું માત્ર 123 લાગે જાઉં છું."

208
00:17:35,190 --> 00:17:38,580
123 તેથી 50 + માટે 173 પ્રયત્ન રહ્યું છે.

209
00:17:38,580 --> 00:17:40,740
અને અહીં તે પૂર્ણાંક તરીકે આ વાંચી શરૂ થાય છે.

210
00:17:40,740 --> 00:17:45,690
તે કશું જોઈ નથી તેથી, તે માત્ર તેને 0 તરીકે વર્તે છે. 0 તેથી 50 + થી 50 પ્રયત્ન રહ્યું છે.

211
00:17:45,690 --> 00:17:51,600
આ હું છું એમ ધારી રહ્યા છીએ જેવું જ કંઈક રહ્યું છે.

212
00:17:51,600 --> 00:17:54,310
હું 99 વિચારી રહ્યો છું.

213
00:17:54,310 --> 00:17:57,580
અરે વાહ, કારણ કે તે પ્રથમ લઇ રહ્યું છે -

214
00:18:12,880 --> 00:18:15,730
99 તેથી.

215
00:18:15,730 --> 00:18:21,970
અહીં (/ 7 10), જો આ સી હતા, કે શું પાછો આવશે?

216
00:18:23,700 --> 00:18:29,630
1 [વિદ્યાર્થી]. >> અરે વાહ, તેને 1 શકે છે કારણ કે 10/7 2 પૂર્ણાંકો ભાગાકાર રહેશે.

217
00:18:29,630 --> 00:18:32,910
એક પૂર્ણાંક દ્વારા વિભાજી પૂર્ણાંક એક પૂર્ણાંક પાછા જઈ રહ્યું છે.

218
00:18:32,910 --> 00:18:37,750
તેને 1 બિંદુ કે જે હશે નહિં આપે છે, તેથી તેને માત્ર 1 પરત ચાલી રહ્યું છે કરી શકો છો.

219
00:18:37,750 --> 00:18:46,120
અહીં (/ 7 10) છાપવા; તે ખરેખર છે કે અર્થઘટન રહ્યું છે.

220
00:18:46,120 --> 00:18:53,760
અને એનો અર્થ એ કે તમે વાસ્તવમાં કે પૂર્ણાંક rounding અને સામગ્રી કરવા માંગો છો જો,

221
00:18:53,760 --> 00:18:59,950
તમે છાપન (ફ્લોર (/ 7 10)) જરૂર પડી;

222
00:18:59,950 --> 00:19:08,460
સી તે કદાચ અકળ છે કે તમે પૂર્ણાંક કાપી નાંખવાની રીત પર નિયમિત આધાર રાખે છે શકે છે,

223
00:19:08,460 --> 00:19:12,260
પરંતુ મહેરબાની કરીને PHP માં તમે કારણ કે તે નથી આપમેળે ફ્લોટ માં શકો છો તેને ચાલુ.

224
00:19:13,430 --> 00:19:17,610
અને પછી (7 સાચું +); તમે શું વિચારો છો કે જે જ હશે?

225
00:19:18,550 --> 00:19:23,640
હું 8 અનુમાન લગાવવા છું જો તે 1 તરીકે સાચું અર્થઘટન રહ્યું છે.

226
00:19:23,640 --> 00:19:25,740
એવું લાગે છે કે તે 8 છે.

227
00:19:25,740 --> 00:19:31,710
>> કંઈપણ અમે ભૂતકાળમાં 10 મિનિટ તમે ચોક્કસપૂર્વક ક્યારેય કરવું જોઈએ થાય છે જેથી કરીને.

228
00:19:31,710 --> 00:19:39,870
તમે કોડ કે જે કરે છે તે દેખાશે.

229
00:19:39,870 --> 00:19:42,700
તે માટે આ સરળ નથી.

230
00:19:42,700 --> 00:19:47,240
તમે 2 ચલો હોય છે, અને શકે 1 ચલ માટે શબ્દમાળા બને છે

231
00:19:47,240 --> 00:19:51,310
અને અન્ય વેરિયેબલ માટે પૂર્ણાંક બને છે, અને પછી તમે આ ચલો મળીને ઉમેરો.

232
00:19:51,310 --> 00:20:00,120
ત્યારથી PHP ગતિશીલ અને લખ્યો છે તે તમારા માટે કોઈપણ પ્રકારની ચકાસણી ન કરશે

233
00:20:00,120 --> 00:20:03,640
અને કારણ કે તે નબળું અને લખ્યો છે કારણ કે તે માત્ર આપોઆપ આ વસ્તુઓ ફેંકવા આવશે એકસાથે

234
00:20:03,640 --> 00:20:11,490
અને બધું જ માત્ર કામ કરશે, તે મુશ્કેલ છે પણ ખબર છે કે આ ચલ શબ્દમાળા હવે જ હોવી જોઈએ,

235
00:20:11,490 --> 00:20:14,930
તેથી હું આ ચલ ઉમેરી શકતા નથી, કે જે પૂર્ણાંક છે કરીશું.

236
00:20:18,780 --> 00:20:24,560
શ્રેષ્ઠ અભ્યાસ છે જો ચલ એક સ્ટ્રિંગ છે, શબ્દમાળા તરીકે તે કાયમ રાખવા.

237
00:20:24,560 --> 00:20:26,980
જો ચલ પૂર્ણાંક છે, પૂર્ણાંક તરીકે તે કાયમ રાખવા.

238
00:20:26,980 --> 00:20:30,770
જો તમે પૂર્ણાંકો અને શબ્દમાળાઓ સાથે કામ કરવા માંગો છો,

239
00:20:30,770 --> 00:20:36,970
તમે varsint ઉપયોગ કરી શકો છો - એટલે કે જાવાસ્ક્રિપ્ટ છે.

240
00:20:36,970 --> 00:20:42,520
Intval. હું આ બધી સમય નથી. PHP અને જાવાસ્ક્રિપ્ટ હું બધું મિશ્રણ.

241
00:20:42,520 --> 00:20:47,600
તેથી intval માટે ચલની પૂર્ણાંક કિંમત પાછી રહ્યું છે.

242
00:20:47,600 --> 00:20:56,550
જો અમે "(intval ('123 ')) પ્રિન્ટ પાસ; તમે 123 મેળવો.

243
00:21:06,820 --> 00:21:15,850
પોતે Intval અમને માટે ચેક કે તે સંપૂર્ણપણે પૂર્ણાંક છે નથી જઈ રહ્યું છે.

244
00:21:15,850 --> 00:21:20,460
આ PHP મેન્યુઅલ, ત્યાં માત્ર ઘણા કાર્યો ઉપલ્બધ છે,

245
00:21:20,460 --> 00:21:26,560
અહીં મને લાગે છે કે હું ઉપયોગ કરશે શું is_numeric પ્રથમ છે.

246
00:21:26,560 --> 00:21:32,590
હું અનુમાન લગાવવા છું કે ખોટા ફર્યા.

247
00:21:32,590 --> 00:21:35,780
કે અન્ય વસ્તુ અમે === છે ઉપર જવું પડે છે.

248
00:21:37,850 --> 00:21:44,020
તેથી is_numeric ('123df '), કે જે તમને તરીકે is_numeric ઓફ નથી લાગતું હશે.

249
00:21:44,020 --> 00:21:46,720
સી માં તમે ઉપર તમામ અક્ષરો ફરી વળવું પડશે

250
00:21:46,720 --> 00:21:50,410
અને તે જોવા માટે જો દરેક અક્ષર આંકડાના અથવા જે છે તપાસો.

251
00:21:50,410 --> 00:21:53,850
અહીં is_numeric અમને કે શું થઈ રહ્યું છે,

252
00:21:53,850 --> 00:21:56,520
અને તે ખોટા પરત છે.

253
00:21:56,520 --> 00:22:02,120
તેથી જ્યારે હું કે મુદ્રિત, તે કંઇ મુદ્રિત છે, તેથી અહીં હું તેને જોવા માટે સરખામણી છું,

254
00:22:02,120 --> 00:22:05,490
શું તમે ખોટા પ્રયત્ન થાય છે? અને તેથી હવે તેને 1 છાપવા છે.

255
00:22:05,490 --> 00:22:10,060
દેખીતી રીતે તે સાચું તરીકે સાચું છાપવા બદલે સાચા તરીકે 1 છાપે છે.

256
00:22:10,060 --> 00:22:15,790
હું આશ્ચર્ય જો હું print_r નથી. ના, તે હજુ 1 કરે છે.

257
00:22:15,790 --> 00:22:26,760
>> === પાછા જતાં, == હજુ પણ અસ્તિત્વમાં છે,

258
00:22:26,760 --> 00:22:32,260
અને જો તમે ટોમી સાથે વાત તેમણે == કહેવું સંપૂર્ણપણે દંડ કરીશું.

259
00:22:32,260 --> 00:22:37,700
હું કહે છે કે == ભયંકર છે અને તમે == ક્યારેય ઉપયોગ કરવો જોઈએ જાઉં છું.

260
00:22:37,700 --> 00:22:44,870
તફાવત એ છે કે == વસ્તુઓ સરખાવે

261
00:22:44,870 --> 00:22:48,450
જ્યાં તે વાત સાચી છે પણ જો તેઓ એ જ પ્રકાર નથી કરી શકો છો,

262
00:22:48,450 --> 00:22:53,810
જ્યારે === વસ્તુઓ સરખાવે છે અને તેને પ્રથમ વખત તપાસમાં તેઓ જ પ્રકાર છે?

263
00:22:53,810 --> 00:22:58,010
હા. ઠીક છે, હવે હું એ જોવા માટે જો તેઓ ખરેખર સમાન હોવું સરખાવવા જાઉં છું.

264
00:22:58,010 --> 00:23:08,890
તમે વિચાર જેવા 10 વસ્તુઓ વિચિત્ર સમકક્ષ - દો છે કે નહીં તે જોવા શું કહે છે.

265
00:23:08,890 --> 00:23:15,570
તેથી ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
આ સાચું આપે છે.

267
00:23:17,980 --> 00:23:21,420
શું કોઇને કોઇ ધારી શા માટે આ સાચું આપે છે?

268
00:23:25,180 --> 00:23:27,120
તે વિશે માત્ર નથી. કદાચ આ સંકેત છે.

269
00:23:27,120 --> 00:23:33,170
પરંતુ જો હું એફ કે બદલી - તે રફૂ કરવું! હું બેવડા અવતરણ નો ઉપયોગ ચાલુ રાખી.

270
00:23:33,170 --> 00:23:38,780
કારણ બેવડા અવતરણ મને અંતે yelling છે કારણ કે હું બેવડા અવતરણ આ મૂક્યો છે.

271
00:23:38,780 --> 00:23:43,850
તેથી હું અહીં એ બે અવતરણચિહ્નો ભાગી શકે, પરંતુ એક જ અવતરણચિહ્નો તેને સરળ બનાવે છે.

272
00:23:43,850 --> 00:23:49,120
તેથી ('10 '== '1 F1'); સાચું નથી છાપી નથી. ('10 '== '1 E1'); સાચું છાપે છે.

273
00:23:49,120 --> 00:23:56,330
[વિદ્યાર્થી] તે છે તે hex? >> તે hex, નથી, પરંતુ તે નજીક કે તે પ્રમાણે છે -

274
00:23:56,330 --> 00:24:01,060
1e1, વૈજ્ઞાનિક સંકેતનમાં.

275
00:24:01,060 --> 00:24:07,950
તે 1 તરીકે 1e1 ઓળખે 10 * 1 ^ અથવા જે.

276
00:24:07,950 --> 00:24:11,510
તે સમાન પૂર્ણાંકો છે.

277
00:24:11,510 --> 00:24:15,930
જો અમે === કરી પછી તેને ખોટી સાબિત થઇ રહ્યું છે.

278
00:24:15,930 --> 00:24:28,490
હું ખરેખર આ બોલ પર કોઈ વિચાર હોય તો અમે == જે અંગે (10 અને '10abc ');? અધિકાર છે. જેથી સાચું છે.

279
00:24:28,490 --> 00:24:35,940
તેથી માત્ર ગમે છે જ્યારે તમે (10 + '10abc ') હતું; અને 20 હશે,

280
00:24:35,940 --> 00:24:38,800
અહીં (10 == '10abc '); સાચું છે.

281
00:24:38,800 --> 00:24:45,350
ખરાબ પણ જેવી વસ્તુઓ (ખોટું NULL ==) હોય છે; સાચું છે

282
00:24:45,350 --> 00:24:52,210
અથવા (ખોટું 0 ==); સાચું છે, (ખોટું == []);

283
00:24:52,210 --> 00:25:00,970
ત્યાં વિચિત્ર કિસ્સાઓમાં છે - તે એક તે વિચિત્ર કેસો છે.

284
00:25:00,970 --> 00:25:08,110
નોંધ કરો કે (ખોટું == []); સાચું છે.

285
00:25:08,110 --> 00:25:11,950
('0 'ખોટું ==); સાચું છે.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); ખોટું છે.

287
00:25:16,090 --> 00:25:19,090
== તેથી કોઇ સકર્મક માર્ગ છે.

288
00:25:19,090 --> 00:25:26,830
એક બોલ્ડ માટે સમાન હોય છે અને સી સમાન હોઇ શકે છે,

289
00:25:26,830 --> 00:25:29,340
પરંતુ બો સી સમાન હોઈ શકતી નથી.

290
00:25:29,340 --> 00:25:35,580
કે મને એક નફરત છે, અને તમે હંમેશા === ઉપયોગ કરવો જોઈએ.

291
00:25:35,580 --> 00:25:38,590
[વિદ્યાર્થી] આપણે શું કરવું! == શકું તેમજ? >> [બોડેન] હા.

292
00:25:38,590 --> 00:25:44,600
આ સમકક્ષ હોઈ! કરશે = અને ==.

293
00:25:44,600 --> 00:25:48,230
આ વાસ્તવમાં એ pset સ્પેક છે અપ લાવવામાં

294
00:25:48,230 --> 00:25:52,000
જ્યાં વિધેયો વળતર ઘણો -

295
00:25:52,000 --> 00:25:53,890
આ PHP જાતે આ વિશે સારો છે.

296
00:25:53,890 --> 00:25:59,140
તે મોટા લાલ બોક્સમાં મૂકે છે, "આ ખોટા આપશે જો ત્યાં એક ભૂલ થશે."

297
00:25:59,140 --> 00:26:03,940
પરંતુ પરત 0 સંપૂર્ણ વાજબી પર પાછા વસ્તુ છે.

298
00:26:03,940 --> 00:26:08,250
કોઈપણ કાર્ય જે પૂર્ણાંક પરત આપે છે તે વિશે વિચારો.

299
00:26:11,250 --> 00:26:17,880
હવે કહો કે આ કાર્ય કરવા માટે ફાઈલ અથવા કંઈક માં રેખાઓ સંખ્યા ગણતરી માનવામાં આવે છે.

300
00:26:17,880 --> 00:26:23,490
સામાન્ય સંજોગોમાં, તમે આ કાર્ય ફાઈલ પાસ

301
00:26:23,490 --> 00:26:27,120
અને તે એક પૂર્ણાંક છે કે જે લીટીઓ સંખ્યા પ્રતિનિધિત્વ પરત ચાલી રહ્યું છે.

302
00:26:27,120 --> 00:26:30,820
તેથી 0 સંપૂર્ણ વાજબી નંબર છે જો ફાઈલ માત્ર ખાલી છે.

303
00:26:30,820 --> 00:26:36,810
પરંતુ જો તમે તેને અમાન્ય ફાઈલ પાસ અને કાર્ય કરવા માટે ખોટા પરત થાય છે

304
00:26:36,810 --> 00:26:38,860
જો તમે તેને અમાન્ય ફાઈલ પાસ?

305
00:26:38,860 --> 00:26:46,500
જો તમે હમણાં == તમે અમાન્ય ફાઇલ અને ખાલી ફાઈલ વચ્ચે કેસ નથી જુદી કરી રહ્યાં છો.

306
00:26:48,870 --> 00:26:51,350
હંમેશા === વાપરો.

307
00:26:55,690 --> 00:26:58,000
કે જેથી તે બધા છે.

308
00:26:58,000 --> 00:27:01,660
>> PHP માં, એરે તમે કયા પ્રકારનું સી માટે ઉપયોગ કરી રહ્યા છો અલગ છે

309
00:27:01,660 --> 00:27:06,650
ખરેખર, તમે પહેલાથી જ આ ઉપર છે નોંધ્યું છે જ્યારે તમે જોયું કે આ પ્રકારની એરે છે.

310
00:27:06,650 --> 00:27:15,640
કૌંસ વાક્યરચના 5.4 PHP, કે જે PHP ની નવીનતમ સંસ્કરણ છે નવા છે.

311
00:27:15,640 --> 00:27:36,960
1> 'બોલ્ડ' - - 2> આ પહેલા તમે હંમેશા એરે લખવા ('એક' હતો.

312
00:27:36,960 --> 00:27:41,160
તે એક એરે માટે બાંધનાર હતો.

313
00:27:41,160 --> 00:27:45,950
હવે PHP છેલ્લે ફક્ત ચોરસ કૌંસ ના સરસ સિન્ટેક્ષ માટે આસપાસ આવે છે,

314
00:27:45,950 --> 00:27:50,900
જે ફક્ત એટલો બધો એરે કરતાં વધુ સારી છે.

315
00:27:50,900 --> 00:27:54,480
પરંતુ 5.4 PHP વિચારણા નવા સંસ્કરણ છે,

316
00:27:54,480 --> 00:27:59,090
તમે સ્થાનો પણ 5.3 PHP ન હોય અનુભવી શકે છે.

317
00:27:59,090 --> 00:28:08,220
ઉનાળા દરમિયાન અમે આ મુદ્દો સપડાઇ જ્યાં PHP 5.3 હતી અમે શું ઉપકરણ પર હતો,

318
00:28:08,220 --> 00:28:14,480
પરંતુ સર્વરે કે અમે અમારા બધા ગ્રેડ પુસ્તક જમાવટ અને submit અને તે તમામ સામગ્રી માટે

319
00:28:14,480 --> 00:28:16,750
5.4 PHP હતી.

320
00:28:16,750 --> 00:28:23,060
જાણીને આ નથી, આપણે 5.3 વિકાસ, 5.4 દબાણ,

321
00:28:23,060 --> 00:28:25,660
અને હવે અમારી કોડ અચાનક કંઈ બધા કામ કરે છે

322
00:28:25,660 --> 00:28:28,680
કારણ કે ત્યાં 5.3 અને 5.4 વચ્ચે ફેરફાર કરવામાં આવ્યા નથી થયું

323
00:28:28,680 --> 00:28:31,030
જે પાછળની આવૃત્તિઓ સાથે સુસંગત ન હોય તો,

324
00:28:31,030 --> 00:28:35,770
અને અમે જાઓ અને અમારી બધું છે કે 5.4 PHP માટે કામ કરતુ નથી ઠીક છે.

325
00:28:39,210 --> 00:28:42,320
આ વર્ગ માટે છે, કારણ કે ઉપકરણ કરે 5.4 PHP હોય છે,

326
00:28:42,320 --> 00:28:45,490
તે સંપૂર્ણપણે દંડ કરવા માટે ચોરસ કૌંસ વાપરો.

327
00:28:47,240 --> 00:28:50,440
પરંતુ જો તમે શોધી રહ્યા છો કે જે ઈન્ટરનેટ આસપાસ વસ્તુઓ,

328
00:28:50,440 --> 00:28:54,880
જો તમે એરે સામગ્રી અમુક પ્રકારના શોધી રહ્યાં છો, મોટા ભાગે તમે એ જોવા માટે જઈ રહ્યાં છો

329
00:28:54,880 --> 00:29:02,020
એરે બાંધનાર વાક્યરચના બહાર જોડણી કે આસપાસ PHP થી છે જન્મ થયો

330
00:29:02,020 --> 00:29:07,340
અને ચોરસ કૌંસ વાક્યરચના આસપાસ ભૂતકાળમાં દંપતી મહિના માટે કરવામાં આવી છે

331
00:29:07,340 --> 00:29:10,020
અથવા 5.4 આસપાસ જ્યારેપણ આવી હતી.

332
00:29:10,020 --> 00:29:12,710
આ તમને કેવી રીતે ઇન્ડેક્સ છે.

333
00:29:12,710 --> 00:29:30,610
જસ્ટ સી માંગો તમે $ [0], $ [1] અરે, અરે $ [2], એરે જેવી ચોરસ કૌંસ દ્વારા અનુક્રમણિકા કેવી રીતે

334
00:29:30,610 --> 00:29:36,320
તમે તે જ રીતે જો તમે તમારા સૂચકાંકો શબ્દમાળાઓ હોવા હોય થવું ઇન્ડેક્સ.

335
00:29:36,320 --> 00:29:40,440
તેથી $ એરે ['એ'] અને $ એરે ['b'].

336
00:29:40,440 --> 00:29:47,410
એરે $ [બો]. આ ખોટું શા માટે હશે?

337
00:29:52,490 --> 00:29:59,870
તે કદાચ એક ચેતવણી પેદા કરશે પરંતુ હજુ પણ કામ કરે છે. PHP કે શું થાય છે.

338
00:29:59,870 --> 00:30:04,890
તે માત્ર, "હું તમને આ વિશે ચેતવે જાઉં છું માટે કરે છે, પણ મને માત્ર ચાલુ રાખવામાં જાઉં છું

339
00:30:04,890 --> 00:30:07,550
"અને શું ગમે હું આ કરી શકો છો."

340
00:30:07,550 --> 00:30:11,500
તે કદાચ શબ્દમાળા આ ભાષાંતર કરશે,

341
00:30:11,500 --> 00:30:15,000
પરંતુ તે શક્ય છે કે ભૂતકાળમાં કોઈએ અમુક બિંદુએ કહ્યું

342
00:30:15,000 --> 00:30:20,180
બોલ્ડ વ્યાખ્યાયિત કરવા માટે પ્રયત્ન 'hello world'.

343
00:30:20,180 --> 00:30:28,740
તેથી હવે બોલ્ડ સતત અને $ એરે હોઈ શકે છે [બો] વાસ્તવમાં કરવાનું આવશે 'હેલો વર્લ્ડ'.

344
00:30:28,740 --> 00:30:32,380
હું આ બિંદુએ લાગે છે, અથવા ઓછામાં ઓછું અમારા PHP સેટિંગ્સ,

345
00:30:32,380 --> 00:30:37,870
જો તમે એક એરે માં ઇન્ડેક્સ પ્રયત્ન કરો અને તે કી અસ્તિત્વમાં નથી, તે નિષ્ફળ જશે.

346
00:30:37,870 --> 00:30:40,150
મને નથી લાગતું કે તે માત્ર તમે ચેતવે આવશે.

347
00:30:40,150 --> 00:30:44,560
અથવા ઓછામાં ઓછું તમે તે સેટ કે જેથી તે ફક્ત તમને ન ચેતવે નથી કરી શકે છે, તે માત્ર સીધા અપ નિષ્ફળ જાય છે.

348
00:30:44,560 --> 00:30:49,290
>> જે રીતે તમે તે જોવા માટે જો ત્યાં ખરેખર આવું ઘાતચિહ્ન છે તે ચકાસવા isset છે.

349
00:30:49,290 --> 00:30:54,690
તેથી isset ($ એરે ['hello world']) ખોટા આપશે.

350
00:30:54,690 --> 00:30:59,160
isset (એરે $ ['b']) સત્ય આપશે.

351
00:31:06,830 --> 00:31:09,880
તમે આ syntaxes મિશ્રણ કરી શકે છે.

352
00:31:15,060 --> 00:31:22,440
અમે તે ચકાસવા માટે બહાર કરી શકે છે - હું ખૂબ ખાતરી કરો કે આ એરે અંત હોવા કરશે શું છે છું.

353
00:31:43,290 --> 00:31:45,700
ઓહ, હું PHPWord જરૂર છે.

354
00:31:53,960 --> 00:32:00,260
આ વાક્યરચના જ્યાં તમે સ્પષ્ટ કી શું છે મિશ્રણ છે

355
00:32:00,260 --> 00:32:03,330
અને તમે સ્પષ્ટ કરો નહિં કી શું છે.

356
00:32:03,330 --> 00:32:05,520
તેથી 3 અહીં જ એક કિંમત છે.

357
00:32:05,520 --> 00:32:08,080
તમે નથી સ્પષ્ટપણે જણાવ્યું છે કે તેના મુખ્ય શું હોવું રહ્યું છે.

358
00:32:08,080 --> 00:32:11,670
તમે શું વિચારો છો તેના કી પ્રયત્ન રહ્યું છે?

359
00:32:11,670 --> 00:32:21,410
0 [વિદ્યાર્થી]. >> હું 0 અનુમાન લગાવવા છું માત્ર કારણ કે તે પ્રથમ એક અમે ઉલ્લેખ કર્યો નથી છે.

360
00:32:21,410 --> 00:32:23,500
અમે ખરેખર આ કિસ્સાઓમાં બે કરી શકો છો.

361
00:32:23,500 --> 00:32:28,030
તેથી print_r છે ફરી યાદ આવવું છાપો. તે સમગ્ર એરે છાપશે.

362
00:32:28,030 --> 00:32:32,700
તે ઍરેની subarrays છાપો જો કોઇ હોય તો.

363
00:32:32,700 --> 00:32:36,630
તેથી ($ એરે) print_r; php.test.php.

364
00:32:36,630 --> 00:32:38,810
તે જેમ તેને 0 આપ્યો લાગતું નથી.

365
00:32:38,810 --> 00:32:43,530
ત્યાં ખરેખર ધ્યાનમાં રાખવા અહીં કંઈક છે, પરંતુ અમે પાછા બીજી તેને મળશે.

366
00:32:43,530 --> 00:32:45,850
પરંતુ જો હું આ અનુક્રમણિકા 1 બનાવવા થાય છે?

367
00:32:45,850 --> 00:32:51,170
PHP શબ્દમાળા સૂચકાંકો અને પૂર્ણાંક સૂચકાંકો વચ્ચે અલગ નહી કરતું નથી,

368
00:32:51,170 --> 00:33:00,280
તેથી આ બિંદુએ હું ફક્ત 1 ઇન્ડેક્સ વ્યાખ્યાયિત કરી છે અને હું બંને $ એરે [1] અને $ એરે ['1 '] કરી શકો છો

369
00:33:00,280 --> 00:33:06,250
અને આ તે જ અનુક્રમણિકા અને તે જ કી રહેશે.

370
00:33:06,250 --> 00:33:13,000
તેથી હવે તમે શું વિચારો છો 3 થી પ્રયત્ન રહ્યું છે? >> [2 વિદ્યાર્થી]. >> [બોડેન] હું 2 અનુમાન લગાવવા છું.

371
00:33:16,000 --> 00:33:18,690
યાહ. તે 2 છે.

372
00:33:18,690 --> 00:33:24,790
જો અમે આ 10 છે, આ 4 છે? તમે શું વિચારો છો 3 ના ઇન્ડેક્સ પ્રયત્ન રહ્યું છે?

373
00:33:27,360 --> 00:33:29,110
હું 11 વિચારી રહ્યો છું.

374
00:33:29,110 --> 00:33:33,060
PHP શું કરે છે માટે મારા અનુમાન - અને મને લાગે છે કે હું આ જોઇ છે તે પહેલાં -

375
00:33:33,060 --> 00:33:39,760
છે તે માત્ર સૌથી વધુ આંકડાકીય અનુક્રમણિકા તે અત્યાર સુધી ઉપયોગ શું છે જાળવી રાખે છે.

376
00:33:39,760 --> 00:33:44,230
તે માટે 3 શબ્દમાળા અનુક્રમણિકા સોંપી ક્યારેય ચાલી રહ્યું છે. એ હંમેશા આંકડાકીય અનુક્રમણિકા હશે.

377
00:33:44,230 --> 00:33:47,690
તેથી તે સૌથી વધુ તો અત્યાર સુધી સોંપાયેલ છે, કે જે 10 બને ટ્રેક રાખે છે,

378
00:33:47,690 --> 00:33:52,540
અને તે માટે 3 થી 11 આપી રહ્યું છે.

379
00:33:52,540 --> 00:34:02,110
પહેલાં મારે શું કહ્યું હતું કે, જે રીતે તે આ એરે છાપવા છે નોટિસ.

380
00:34:02,110 --> 00:34:06,850
તેને 10 કી છાપે, 4 કી, 11 કી, કી ડી.

381
00:34:06,850 --> 00:34:09,790
અથવા તો માતાનો દો -

382
00:34:15,760 --> 00:34:22,489
હું માનું હું 0 આવ્યો ન હતો, પરંતુ તે 1 છાપકામ, 2, 3, 4 છે.

383
00:34:22,489 --> 00:34:29,330
તો શું હું અહીં સ્વિચ? દો અથવા ખરેખર આ 2 કરો.

384
00:34:29,330 --> 00:34:31,940
હવે તે 2, 1, 3, 4 છાપે છે.

385
00:34:31,940 --> 00:34:41,270
માતાનો PHP એરે તમારા નિયમિત હેશ ટેબલ જેમ જ નથી.

386
00:34:41,270 --> 00:34:45,570
તે સંપૂર્ણપણે વાજબી કરવા માટે હેશ સમય 99% કોષ્ટકો તેમને લાગે છે.

387
00:34:45,570 --> 00:34:53,790
પરંતુ તમારા હેશ કોષ્ટકોમાં ત્યાં કયા ક્રમમાં વસ્તુઓ શામેલ હતી કોઈ અર્થ છે.

388
00:34:53,790 --> 00:34:56,639
તેથી જલદી તમે તેને તમારા હેશ કોષ્ટકમાં દાખલ કરો,

389
00:34:56,639 --> 00:35:00,590
ધારે ત્યાં કોઈ કડી થયેલ યાદી અને તમે એક કડી થયેલ યાદી અંદર મૂલ્યાંકન કરી શકે છે

390
00:35:00,590 --> 00:35:03,980
જે પ્રથમ શામેલ કરવામાં આવી હતી.

391
00:35:03,980 --> 00:35:10,060
પરંતુ, અહીં આપણે 2 પ્રથમ શામેલ છે અને તે જાણે છે ત્યારે તે આ એરે છાપવા છે કે 2 પ્રથમ આવે છે.

392
00:35:10,060 --> 00:35:13,090
તે ફક્ત કોઈપણ ક્રમમાં ન છાપી નથી આઉટ.

393
00:35:13,090 --> 00:35:17,550
ટેક્નિકલ માહિતી બંધારણ છે કે તેનો ઉપયોગ તે જ એક આદેશ આપ્યો નકશો છે,

394
00:35:17,550 --> 00:35:24,690
તેથી તે કિંમતો માટે કીઓ નકશો છે અને તે કયા ક્રમમાં તે કીઓ શામેલ કરવામાં આવી હતી યાદ.

395
00:35:24,690 --> 00:35:31,600
મૂળભૂત રીતે તે કેટલીક ગૂંચવણો જ્યાં તે ખરેખર હેરાન કરવા માટે છે -

396
00:35:31,600 --> 00:35:34,510
હવે કહો કે તમે એક 0 એરે, 1, 2, 3, 4, 5 હોય છે

397
00:35:34,510 --> 00:35:37,700
અને તમે 2 અનુક્રમણિકા લેવા માંગો છો.

398
00:35:37,700 --> 00:35:47,750
આમ કરવાની એક રીત છે, જુઓ કે શું લાગે દો.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
અનસેટ બંને ચલો અને એરે સૂચકાંકો સુયોજિત થાય છે.

401
00:35:54,880 --> 00:35:58,630
તેથી સેટ કર્યા વિના ($ એરે [2]);

402
00:35:58,630 --> 00:36:03,430
હવે આ શું થઈ રહ્યું છે તે જોવા જેવી? 2 ફક્ત ગઇ છે, જેથી સંપૂર્ણ દંડ છે.

403
00:36:03,430 --> 00:36:11,670
વધુ હેરાન છે જો તમે વસ્તુઓ ખરેખર એક એરે જેવો હોવો કરવા માંગો છો.

404
00:36:11,670 --> 00:36:14,910
હું રેન્ડમ નંબર મૂકીશું.

405
00:36:14,910 --> 00:36:20,400
હવે મારી સૂચકાંકો નોટિસ.

406
00:36:20,400 --> 00:36:26,860
1 - હું તે માત્ર એક સી એરે જેવી થઈ છે જ્યાં તે 0 થી લંબાઈ જાય છે કરવા માંગો છો

407
00:36:26,860 --> 00:36:30,810
અને હું તેની પર જેમ કે ફરી વળવું કરી શકો છો.

408
00:36:30,810 --> 00:36:38,520
પરંતુ જલદી હું બીજા અનુક્રમણિકા, શું 3 અનુક્રમણિકા હતો સુયોજિત હવે 2 અનુક્રમણિકા ન બની જાય.

409
00:36:38,520 --> 00:36:44,790
તેના બદલે તે માત્ર કે ઇન્ડેક્સ દૂર કરે છે અને હવે તમે 0, 1, 3, 4 જાઓ.

410
00:36:44,790 --> 00:36:48,740
આ સંપૂર્ણપણે વાજબી છે.

411
00:36:48,740 --> 00:36:53,950
તે માત્ર નકામી છે અને તમે એરે સાંધાવાળા કરવા જેવી વસ્તુઓ હોય છે. યાહ.

412
00:36:53,950 --> 00:36:57,200
>> [વિદ્યાર્થી] જો તમે લૂપ માટે એક હતી શું થશે

413
00:36:57,200 --> 00:36:59,630
અને તમે તમામ તત્વો પર જાઓ માગે છે?

414
00:36:59,630 --> 00:37:02,290
જ્યારે તે 2 ફટકો, તે ક્યારેય પેદા થશે?

415
00:37:02,290 --> 00:37:10,150
ઝાકઝમાળ પર વારો. ત્યાં 2 રીતે તમે તે કરી શકો છો.

416
00:37:10,150 --> 00:37:12,770
તમે લૂપ માટે નિયમિત ઉપયોગ કરી શકો છો.

417
00:37:12,770 --> 00:37:22,000
આ PHP ની અન્ય જટિલતા છે.

418
00:37:22,000 --> 00:37:27,420
મોટા ભાગની ભાષાઓ હું એમ કહીશ, લંબાઈ અથવા લેન અથવા કંઈક અમુક પ્રકારની હોય છે

419
00:37:27,420 --> 00:37:30,470
ઝાકઝમાળ લંબાઈ દર્શાવે છે.

420
00:37:30,470 --> 00:37:32,820
PHP તે ગણતરી છે.

421
00:37:32,820 --> 00:37:36,160
તેથી ($ એરે) ગણતરી; $ i + +)

422
00:37:36,160 --> 00:37:42,950
ચાલો ફક્ત પ્રિન્ટ ($ એરે [i $]);

423
00:37:45,920 --> 00:37:48,820
સૂચના: ઓફસેટ અનિર્ધારિત: 2.

424
00:37:48,820 --> 00:37:51,610
તે માત્ર નિષ્ફળ રહ્યું છે.

425
00:37:51,610 --> 00:38:03,020
આ કારણ છે કે, મોટા ભાગના ભાગ માટે, તમે જરૂર પર આ જેવા એરે ફરી વળવું ક્યારેય છે.

426
00:38:03,020 --> 00:38:07,110
તે કસોટી હોઈ શકે, પણ તમે જરૂર પર આ જેવા એરે ફરી વળવું ક્યારેય

427
00:38:07,110 --> 00:38:19,410
કારણ કે PHP તેના foreach જ્યાં foreach ($ એરે તરીકે $ વસ્તુ) સિન્ટેક્ષ પૂરી પાડે છે.

428
00:38:19,410 --> 00:38:31,830
હવે અમે ($ વસ્તુ) છાપો જો; - we'll તે બીજા ચર્ચા - કે જે સંપૂર્ણપણે દંડ કામ કરે છે.

429
00:38:31,830 --> 00:38:38,960
જે રીતે foreach કામ છે પ્રથમ દલીલ એરે કે તમે ઉપર વારો કરી રહ્યાં છે.

430
00:38:38,960 --> 00:38:44,060
અને બીજી દલીલ, લૂપ માટે દરેક પાસ દ્વારા આઇટમ,

431
00:38:44,060 --> 00:38:52,690
તે એરે આગામી વસ્તુ લઇ રહ્યું છે. તેથી યાદ એરે ઓર્ડર છે.

432
00:38:52,690 --> 00:38:55,690
લૂપ માટે મારફતે પ્રથમ વખત, આઇટમ 123 પ્રયત્ન રહ્યું છે

433
00:38:55,690 --> 00:38:59,540
પછી તેને 12 થશે પછી તેને 13 થશે પછી તેને 23 થશે પછી તેને 213 રહેશે.

434
00:38:59,540 --> 00:39:04,670
વસ્તુઓ ખરેખર અદ્ભુત વિચાર જ્યારે તમે foreach કંઈક કરવું.

435
00:39:04,670 --> 00:39:07,480
માતાનો જુઓ શું થાય છે કારણ કે તમે આ ક્યારેય કરવું જોઈએ નહીં.

436
00:39:07,480 --> 00:39:13,320
જો અમે સેટ કર્યા વિના ($ એરે [1]);

437
00:39:20,410 --> 00:39:26,030
કે કદાચ અપેક્ષા હતી.

438
00:39:26,030 --> 00:39:30,950
તમે આ એરે પર વારો કરી રહ્યાં છો, અને દરેક વખતે જ્યારે તમે પ્રથમ અનુક્રમણિકા unsetting કરી રહ્યાં છો.

439
00:39:30,950 --> 00:39:39,720
તેથી 0 અનુક્રમણિકા માટે, પ્રથમ વસ્તુ, આઇટમ 0 કિંમત લે છે, તેથી તેને 123 જ હશે.

440
00:39:39,720 --> 00:39:44,630
પરંતુ અંદર લૂપ માટે અમે સેટ કર્યા વિના 1 અનુક્રમણિકા, તેથી તેનો અર્થ એ કે 12 ગઇ છે. ની

441
00:39:44,630 --> 00:39:57,480
તેથી છાપો. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL માત્ર NEWLINE છે, પરંતુ તે ટેકનિકલી વધુ સુવાહ્ય છે

443
00:40:03,580 --> 00:40:08,890
કારણ કે Windows માં newlines મેક અને UNIX પર newlines અલગ છે.

444
00:40:08,890 --> 00:40:18,040
વિન્ડોઝ પર NEWLINE \ r \ n છે, દરેક જગ્યા જ્યારે તે માત્ર \ n હોઈ શકે છે.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL કે જેથી તે વાપરે ગમે એ તમારી સિસ્ટમના NEWLINE છે રૂપરેખાંકિત થયેલ છે.

446
00:40:25,150 --> 00:40:29,310
જેથી છાપો. ચાલો ઓવરને અંતે print_r નથી ($ એરે).

447
00:40:32,830 --> 00:40:37,390
હું કોઈ વિચાર કે જે વર્તન હશે હતી.

448
00:40:41,740 --> 00:40:48,960
વસ્તુ હજુ પણ 12 કિંમત પર લઈ જાય છે પણ તેમ છતાં અમે 12 સુયોજિત પહેલાં આપણે ક્યારેય એરે માંથી તેને મળ્યો હતો.

449
00:40:52,770 --> 00:40:58,840
આ લો, તો મારા શબ્દ છે, પરંતુ તે લાગે છે કે foreach એરે એક નકલ બનાવે છે

450
00:40:58,840 --> 00:41:02,160
અને પછી વસ્તુ કે નકલ તમામ કિંમતો પર લઈ જાય છે.

451
00:41:02,160 --> 00:41:07,760
તેથી જો તમે લૂપ માટે અંદર એરે સુધારવા માટે,

452
00:41:07,760 --> 00:41:17,240
તે નથી કાળજી કરશે. આઇટમ મૂળ કિંમતો પર લઈ જશે.

453
00:41:17,240 --> 00:41:19,240
ચાલો તે unsetting પ્રયાસ કરો.

454
00:41:19,240 --> 00:41:24,460
જો આ $ [1] એરે છે = "હેલો";

455
00:41:24,460 --> 00:41:31,770
તેમ છતાં અમે એરે માં "હેલો" મૂકી છે, કે જે કિંમત પર આઇટમ ક્યારેય લે છે.

456
00:41:31,770 --> 00:41:37,430
ત્યાં બીજા આંટીઓ foreach વાક્યરચના છે

457
00:41:37,430 --> 00:41:45,900
તમે 2 એક તીર દ્વારા અલગ ચલો જ્યાં મૂકો.

458
00:41:45,900 --> 00:41:49,680
આ પ્રથમ ચલ કે મૂલ્ય કી પ્રયત્ન રહ્યું છે,

459
00:41:49,680 --> 00:41:53,050
અને આ બીજા ચલ એ જ ચોક્કસ વસ્તુ પ્રયત્ન રહ્યું છે.

460
00:41:53,050 --> 00:42:01,610
આ અહીં uninteresting છે, પરંતુ જો આપણે 'એ' ની મૂળ કેસ પર પાછા જાઓ -> 1,

461
00:42:01,610 --> 00:42:06,090
'બી' - 1>

462
00:42:06,090 --> 00:42:14,470
અહીં જો આપણે માત્ર વસ્તુ તરીકે દરેક એરે માટે ફરી વળવું, આઇટમ માટે 1 દરેક એક સમય હોય રહ્યું છે.

463
00:42:14,470 --> 00:42:18,170
પરંતુ જો આપણે માટે પણ કે જે વસ્તુ સાથે સંકળાયેલ કી જાણવા માગો છો

464
00:42:18,170 --> 00:42:25,230
> વસ્તુ $ - તો પછી આપણે $ કી નથી.

465
00:42:25,230 --> 00:42:31,980
. ':' તેથી હવે અમે પ્રિન્ટ (કી $ કરી શકો છો.

466
00:42:31,980 --> 00:42:39,380
હવે તે ઉપર વારો છે અને દરેક કી અને તેના સંકળાયેલ કિંમત છાપવા.

467
00:42:39,380 --> 00:42:47,030
>> એક વધારાનાં વસ્તુ અમે foreach આંટીઓ માં કરી શકો છો છે તમે આ વાક્યરચના જોઇ શકશે.

468
00:42:47,030 --> 00:42:54,770
ચલ નામો પહેલાં Ampersands માટે પ્રયત્ન કેવી રીતે PHP સંદર્ભો કરે વલણ ધરાવે છે.

469
00:42:54,770 --> 00:43:00,460
જ્યાં સંદર્ભો ખૂબ પોઇંટરો માટે સમાન હોય છે,

470
00:43:00,460 --> 00:43:04,820
તમે પોઇંટરો નથી, જેથી તમે સીધી મેમરી સાથે ક્યારેય વ્યવહાર.

471
00:43:04,820 --> 00:43:12,620
પરંતુ તમે સંદર્ભો જ્યાં 1 ચલ ચલ અન્ય જેવા જ વસ્તુ સંદર્ભ લે નથી.

472
00:43:12,620 --> 00:43:21,450
અહીં ની અંદર ચાલો $ વસ્તુ નથી. ચાલો 10 1 માટે પાછા જાઓ.

473
00:43:21,450 --> 00:43:28,800
ચાલો $ વસ્તુ કરવું + +; તે હજુ પણ PHP માં અસ્તિત્વમાં છે. તમે હજુ + + કરી શકો છો.

474
00:43:28,800 --> 00:43:38,260
php.test.php. હું તેને છાપી છે. print_r ($ એરે);

475
00:43:38,260 --> 00:43:42,730
અમે 11 2, છાપો.

476
00:43:42,730 --> 00:43:49,560
જો હું માત્ર foreach (એરે $ $ તરીકે વસ્તુ) કર્યું હતું તે પછી આઇટમ 1 કિંમત હશે

477
00:43:49,560 --> 00:43:54,190
આ લૂપ દ્વારા પ્રથમ વખત. તે 1 2 માટે વધારતી અને પછી અમે પૂર્ણ કરી હશે.

478
00:43:54,190 --> 00:43:57,260
તેથી પછી તે લૂપ બીજા પાસ મારફતે જાઓ અને જે વસ્તુ 10 છે.

479
00:43:57,260 --> 00:44:01,570
તે ઇન્ક્રીમેન્ટ 11 થી આઇટમ, અને પછી તે ફક્ત બગાઙ છે.

480
00:44:01,570 --> 00:44:06,670
પછી ($ એરે) print_r અમે; અને ચાલો જોવા કે આ ફક્ત 1 છે, 10.

481
00:44:06,670 --> 00:44:09,070
તેથી ઈજાફો અમે ગુમાવી હતી.

482
00:44:09,070 --> 00:44:13,410
પરંતુ foreach ($ એરે તરીકે અને $ વસ્તુ)

483
00:44:13,410 --> 00:44:21,910
હવે આ આઇટમ આ અહીં અધિકાર તરીકે જ વસ્તુ છે. તે જ વાત છે.

484
00:44:21,910 --> 00:44:26,820
તેથી વસ્તુ $ + + + 0 એરે બદલવા છે.

485
00:44:29,330 --> 00:44:41,850
મૂળભૂત રીતે, તમે પણ $ k કરી શકો છો - $> આઇટમ અને તમે $ કરી શકો છો એરે [k $] + +;

486
00:44:41,850 --> 00:44:48,650
>> જે બીજી રીતે તેથી, અમે વસ્તુ સુધારવા મફત છે,

487
00:44:48,650 --> 00:44:54,070
પરંતુ અમારા મૂળ એરે સંશોધિત કરવામાં આવશે નહીં.

488
00:44:54,070 --> 00:44:59,720
પરંતુ જો આપણે k, જે અમારા કી નો ઉપયોગ કરે છે, પછી અમારી એરે માં ફક્ત અનુક્રમણિકા કે કીની મદદથી અમે કરી શકો છો

489
00:44:59,720 --> 00:45:01,530
અને તે વધારતી.

490
00:45:01,530 --> 00:45:05,410
આ વધુ સીધી અમારા મૂળ એરે સુધારે.

491
00:45:05,410 --> 00:45:10,690
તમે પણ છે કે શું છે જો અમુક કારણ માટે તમે સુધારવા ક્ષમતા ઇચ્છતા કરી શકો છો -

492
00:45:10,690 --> 00:45:13,510
વાસ્તવમાં, આ સંપૂર્ણપણે વાજબી છે.

493
00:45:13,510 --> 00:45:16,020
તમે $ એરે લખી નથી માંગતા હતા [k $] + +,

494
00:45:16,020 --> 00:45:27,890
તમે માત્ર $ વસ્તુ લખવા માગતા હતા + + પરંતુ તમે હજુ પણ કહેવું ઇચ્છતા જો ($ === k 'એક')

495
00:45:27,890 --> 00:45:30,620
પછી આઇટમ વધારો અને પછી અમારી એરે છાપો.

496
00:45:30,620 --> 00:45:36,290
તેથી હવે અમે શું print_r કરવું અપેક્ષા છે? કિંમતો કયા મુદ્રિત કરવું જોઈએ?

497
00:45:36,290 --> 00:45:43,770
[વિદ્યાર્થી] 2 અને 10. >> [બોડેન] ફક્ત જો કી હતું 'એ' અમે ખરેખર નથી કે છાપો.

498
00:45:51,940 --> 00:45:55,670
>> તમે કદાચ જવલ્લે જ, જો ક્યારેય માટે PHP કાર્યો વ્યાખ્યાયિત કરવાની જરૂર પડશે,

499
00:45:55,670 --> 00:46:03,370
પરંતુ તમે કંઈક જોવા જ્યાં તમે કાર્ય ગમે જેમ કાર્ય વ્યાખ્યાયિત કરી શકે છે.

500
00:46:03,370 --> 00:46:09,900
સામાન્ય રીતે તમે ($ foo, $ બાર) કહે છે અને પછી તેને વ્યાખ્યાયિત કરવા માટે ગમે છે.

501
00:46:09,900 --> 00:46:17,580
પરંતુ જો હું આ કરવા માટે, પછી તે અર્થ એ થાય કે ગમે ગમે કહે છે,

502
00:46:17,580 --> 00:46:25,110
ગમે baz કહે છે તેથી, પ્રથમ દલીલ baz પસાર બદલી શકાય છે.

503
00:46:25,110 --> 00:46:38,100
ચાલો $ foo કરવું + +;

504
00:46:38,100 --> 00:46:48,020
અને અંદર અહીં ની baz ($ વસ્તુ) દો;

505
00:46:48,020 --> 00:46:52,250
હવે અમે એક કાર્ય ફોન આવે છે.

506
00:46:52,250 --> 00:46:56,780
આ દલીલ સંદર્ભ દ્વારા લેવામાં આવે છે, જેનો અર્થ છે કે જો અમે તેને સુધારવા

507
00:46:56,780 --> 00:47:00,390
અમે વસ્તુ કે સાઇન પસાર કરવામાં આવ્યો હતો ફેરફાર કરી રહ્યાં છો

508
00:47:00,390 --> 00:47:04,420
અને આ અમે અપેક્ષા છાપવા - જ્યાં સુધી હું વાક્યરચના મિશ્રિત - અમે 11 2, મળ્યું,

509
00:47:04,420 --> 00:47:06,300
તેથી તે ખરેખર વધે હતી.

510
00:47:06,300 --> 00:47:08,790
નોટીસને અમે 2 સ્થળોએ સંદર્ભો જરૂર છે.

511
00:47:08,790 --> 00:47:13,050
જો હું આ હતી? આ શું અર્થ છે?

512
00:47:13,050 --> 00:47:15,810
[વિદ્યાર્થી] આ ફેરફાર થશે. >> યાહ.

513
00:47:15,810 --> 00:47:18,290
વસ્તુ ખાલી એરે માં કિંમત એક નકલ છે.

514
00:47:18,290 --> 00:47:26,670
તેથી વસ્તુ માટે 2 ફેરફાર કરશે, પરંતુ એરે ['એ'] હજુ 1 હશે.

515
00:47:26,670 --> 00:47:32,560
અથવા જો હું આવું?

516
00:47:32,560 --> 00:47:39,260
હવે આઇટમ baz એક નકલ તરીકે મોકલવામાં આવે છે.

517
00:47:39,260 --> 00:47:46,330
તેથી દલીલના નકલ માટે 2 વધે આવશે,

518
00:47:46,330 --> 00:47:49,240
પરંતુ પોતે વસ્તુ 2 ક્યારેય વધે હતી.

519
00:47:49,240 --> 00:47:52,880
અને વસ્તુ એરે કૌંસ ગમે તરીકે આ જ વાત છે,

520
00:47:52,880 --> 00:47:55,380
જેથી એરે ક્યારેય વધે હતી.

521
00:47:55,380 --> 00:47:57,960
તેથી તે બંને જગ્યાએ તેની જરૂર પડશે.

522
00:47:57,960 --> 00:48:03,830
>> PHP સામાન્ય રીતે ખૂબ આ વિશે સ્માર્ટ.

523
00:48:03,830 --> 00:48:06,570
તમને લાગે શકે છે હું સંદર્ભ દ્વારા પસાર કરવા માંગતા હોય -

524
00:48:06,570 --> 00:48:09,560
આ વાસ્તવમાં એક psets પર એક પ્રશ્ન હતો.

525
00:48:09,560 --> 00:48:14,480
તે questions.txt વસ્તુ જ્યાં તે હતી,

526
00:48:14,480 --> 00:48:19,280
તમે સંદર્ભ દ્વારા આ સ્ટ્રક્ટ પસાર શા શકો છો?

527
00:48:19,280 --> 00:48:21,250
કે જવાબ શું હતો?

528
00:48:21,250 --> 00:48:25,100
[વિદ્યાર્થી] તેથી તમે કંઈક મોટું કરવા નકલ નથી. >> યાહ.

529
00:48:25,100 --> 00:48:32,920
એક સ્ટ્રક્ટ આપખુદ મોટી હોઈ શકે છે, અને જ્યારે તમે દલીલ તરીકે માં સ્ટ્રક્ટ પસાર

530
00:48:32,920 --> 00:48:36,800
તે છે કે સમગ્ર સ્ટ્રક્ટ નકલ તેને કાર્ય પસાર કરવાની જરૂર છે,

531
00:48:36,800 --> 00:48:40,410
જો જ્યારે તમે માત્ર સંદર્ભ દ્વારા સ્ટ્રક્ટ પસાર

532
00:48:40,410 --> 00:48:46,530
પછી તે માત્ર કામ કરવા માટે દલીલ તરીકે સરનામા 4-બાઇટ નકલ કરવાની જરૂર છે.

533
00:48:48,520 --> 00:48:52,320
PHP થોડો કરતા વધુ સ્માર્ટ છે.

534
00:48:52,320 --> 00:49:00,650
જો હું અમુક કાર્ય હોય છે અને હું તે માટે 1,000 વસ્તુઓ ઝાકઝમાળ પસાર કરવા માટે,

535
00:49:00,650 --> 00:49:03,990
કરતું નથી તો તેનો અર્થ એ કે તે માટે તમામ તે વસ્તુઓ 1,000 નકલ હોય રહ્યું છે

536
00:49:03,990 --> 00:49:10,450
તેને કાર્ય પસાર? તે કે જે તુરંત જ કરી નથી.

537
00:49:10,450 --> 00:49:15,940
જો આ કાર્ય ની અંદર તે foo ખરેખર ક્યારેય સુધારે,

538
00:49:15,940 --> 00:49:22,660
તેથી ($ === foo 'હેલો') જો સાચી આવો.;

539
00:49:22,660 --> 00:49:26,460
નોંધ અમે આ કાર્ય ની દલીલ અંદર ખરેખર ક્યારેય ફેરફાર,

540
00:49:26,460 --> 00:49:30,010
જેનો અર્થ છે કે ગમે માં પસાર કરવામાં આવ્યો તરીકે foo જરૂર નકલ ક્યારેય

541
00:49:30,010 --> 00:49:32,100
કારણ કે તે નથી સુધારવા છે.

542
00:49:32,100 --> 00:49:39,240
જેથી માર્ગ PHP કામો દલીલો હંમેશા સંદર્ભ દ્વારા પસાર કરવામાં આવે છે

543
00:49:39,240 --> 00:49:42,170
જ્યાં સુધી તમે ખરેખર તેને સુધારવા પ્રયત્ન કરો.

544
00:49:42,170 --> 00:49:51,160
હવે જો હું $ + + + + foo કહેવું; તેને હવે મૂળ foo એક નકલ કરો અને કરશે નકલ સુધારો.

545
00:49:51,160 --> 00:49:53,090
આ અમુક સમય બચાવે છે.

546
00:49:53,090 --> 00:49:58,210
જો તમે આ જંગી એરે ક્યારેય સ્પર્શ કરી રહ્યાં છો, તો તમે તેને ખરેખર ક્યારેય સુધારવા માટે,

547
00:49:58,210 --> 00:50:02,360
તે નકલ કરવાની જરૂર રહેતી નથી,

548
00:50:02,360 --> 00:50:06,640
જો જ્યારે અમે ફક્ત આ & "અને" નું ચિહ્ન તેનો અર્થ એ કે તે પણ તે નથી નકલ નથી મૂકી

549
00:50:06,640 --> 00:50:08,640
પણ જો તમે તેને સુધારવા નથી.

550
00:50:08,640 --> 00:50:10,680
આ વર્તણૂક કોપી ઓન રાઇટ કહેવામાં આવે છે.

551
00:50:10,680 --> 00:50:17,380
તમે તેને અન્ય સ્થળોએ જોવા માટે, ખાસ કરીને જો તમે ઓપરેટિંગ સિસ્ટમ કોર્સ લેવા પડશે.

552
00:50:17,380 --> 00:50:23,880
કોપી ઓન રાઇટ એક સુંદર સામાન્ય પેટર્ન જ્યાં તમે કંઈક નકલ બનાવવા જરૂર નથી છે

553
00:50:23,880 --> 00:50:26,650
સિવાય કે તે ખરેખર બદલવા છે. યાહ.

554
00:50:26,650 --> 00:50:29,520
[વિદ્યાર્થી] શું આ પરીક્ષણ અંદર ઈજાફો હતી,

555
00:50:29,520 --> 00:50:33,700
તેથી માત્ર 1,000 બહાર 1 તત્વ માટે બદલવાની જરૂર છે?

556
00:50:33,700 --> 00:50:38,770
મને ખાતરી છે કે નથી.

557
00:50:38,770 --> 00:50:51,250
મને લાગે છે કે તે વર્તમાન વસ્તુ નકલ થશે, પરંતુ તે શક્ય છે તે પર્યાપ્ત સ્માર્ટ છે -

558
00:50:51,250 --> 00:51:00,020
ખરેખર, હું વિચારી રહ્યો છું શું છે કલ્પના અમે એરે કે આ જેવી લાગે છે હતા: array2 $ = [

559
00:51:00,020 --> 00:51:11,000
પછી અનુક્રમણિકા 'એ' [2 3 4 1], અને અનુક્રમણિકા 'બી' ની વ્યૂહરચના છે ગમે ઝાકઝમાળ છે.

560
00:51:11,000 --> 00:51:15,380
હું તે બધા વચ્ચે અલ્પવિરામ જરૂર છે. કલ્પના ત્યાં અલ્પવિરામ છે.

561
00:51:15,380 --> 00:51:21,210
તે પછી 'c' કિંમત 3 છે.

562
00:51:24,210 --> 00:51:26,290
ઠીક છે.

563
00:51:26,290 --> 00:51:33,440
હવે કહો કે અમે baz $ (array2 $) ન કરો;

564
00:51:33,440 --> 00:51:36,540
baz આ જ્યાં સંદર્ભ દ્વારા નહિં લે.

565
00:51:43,510 --> 00:51:47,370
તેથી $ foo ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
આ એક ઉદાહરણ છે જ્યાં અમે એક દલીલ તરીકે array2 પસાર થાય છે

567
00:51:52,340 --> 00:51:57,010
અને પછી તેને incrementing દ્વારા એરે એક ચોક્કસ અનુક્રમણિકા બદલવા છે.

568
00:51:57,010 --> 00:52:01,090
હું પ્રામાણિકપણે કોઈ વિચાર PHP શું ચાલી રહ્યું છે.

569
00:52:01,090 --> 00:52:07,200
તેને સરળતાથી સમગ્ર વસ્તુ એક નકલ કરી શકો છો, પરંતુ જો તે સ્માર્ટ છે,

570
00:52:07,200 --> 00:52:15,030
આ કીઓ એક નકલ જ્યાં આ તેની વિશિષ્ટ કિંમત હોય છે કરશે

571
00:52:15,030 --> 00:52:20,620
પરંતુ આ હજુ પણ એ જ 1,2,3,4 એરે માટે નિર્દેશ કરી શકો છો

572
00:52:20,620 --> 00:52:22,320
અને આ હજુ પણ એ જ એરે માટે નિર્દેશ કરી શકો છો.

573
00:52:22,320 --> 00:52:24,170
હું તેને આઇપેડ પડશે.

574
00:52:28,900 --> 00:52:45,950
અમે આ એરે માં જ્યાં આ વ્યક્તિ પોઇન્ટ 3 પસાર, [1,2,3,4] આ વ્યક્તિ પોઇન્ટ

575
00:52:45,950 --> 00:52:51,350
આ વ્યક્તિ ગુણો [34, ...]

576
00:52:51,350 --> 00:52:58,590
હવે અમે તેને baz માં પસાર કરી રહ્યાં છો, તો અમે આ ફેરફાર કરવામાં આવે છે.

577
00:52:58,590 --> 00:53:03,550
જો PHP સ્માર્ટ છે, તે માત્ર કરી શકો છો -

578
00:53:11,850 --> 00:53:18,230
અમે હજી પણ અમુક મેમરી નકલ હતી, પરંતુ જો ત્યાં આ વિશાળ પુનરાવર્તિત subarrays હતા

579
00:53:18,230 --> 00:53:21,560
અમે તે નકલ જરૂર ન હતી.

580
00:53:21,560 --> 00:53:27,530
હું જો કે તે શું કરે ખબર નથી, પરંતુ હું તે કરી કલ્પના કરી શકો છો.

581
00:53:29,050 --> 00:53:36,690
આ પણ PHP પર એક સી ઓફ ખૂબ મોટો લાભ છે.

582
00:53:36,690 --> 00:53:40,320
>> PHP જીવન જેથી અનેક વસ્તુઓ માટે સરળ ખૂબ બનાવે છે,

583
00:53:40,320 --> 00:53:45,060
પરંતુ તમે પ્રકારની સંપૂર્ણપણે કોઈ વિચાર જ રીતે કેવી રીતે તે કરવા પડશે

584
00:53:45,060 --> 00:53:52,530
કારણ કે હું હૂડ નીચે કોઈ વિચાર હોય ત્યારે તે વસ્તુઓને આ નકલો બનાવવા છે,

585
00:53:52,530 --> 00:53:55,170
ઓહ, કે જે સતત સમય નકલ પ્રયત્ન રહ્યું છે,

586
00:53:55,170 --> 00:54:01,140
છે તે માત્ર માટે 1 નિર્દેશક ફેરફાર કરી હોય, તો તે હાસ્યજનક રીતે મુશ્કેલ રેખીય નકલ પ્રયત્ન રહ્યું છે?

587
00:54:01,140 --> 00:54:03,000
જો તે જગ્યા નથી મળી શકે?

588
00:54:03,000 --> 00:54:06,760
એ નથી કે તે પછી કચરો સંગ્રહ ચલાવવા માટે કેટલાક વધુ જગ્યા વિચાર કરવાની જરૂર છે?

589
00:54:06,760 --> 00:54:11,210
અને કચરાના એકત્રીકરણ લાંબા આપખુદ લઈ શકો છો.

590
00:54:11,210 --> 00:54:13,600
સી માં તમે આ બાબતો વિશે ચિંતા કરવાની જરૂર નથી.

591
00:54:13,600 --> 00:54:19,780
દરેક એક વાક્ય તમે લખી તે કેવી રીતે કરવા ચાલી રહ્યું છે તે વિશે ખૂબ ખૂબ કારણ કરી શકો છો.

592
00:54:26,800 --> 00:54:29,150
>> ચાલો આ પર એક નજર.

593
00:54:35,400 --> 00:54:37,520
સરસ કેવી રીતે છે કે તમે હેશ વિધેયોની સાથે વ્યવહાર નથી,

594
00:54:37,520 --> 00:54:39,010
કડી થયેલ યાદી છે, અથવા જેમ કંઈપણ?

595
00:54:39,010 --> 00:54:41,980
ત્યારથી હેશ કોષ્ટકો સાથે કામ કરવું ખૂબ સરળ હવે, અહીં એક મજા પર કામ પઝલ છે.

596
00:54:41,980 --> 00:54:45,920
એક અને તેને unique.php તરીકે ઓળખાતી ફાઈલ ખોલવા PHP પ્રોગ્રામ લખવા

597
00:54:45,920 --> 00:54:48,330
(પણ એક "સ્ક્રિપ્ટ" તરીકે ઓળખાય છે).

598
00:54:48,330 --> 00:54:55,700
અમે તેમને સ્ક્રિપ્ટો કૉલ કરતા હોય છે જો તેઓ ટૂંકા વસ્તુઓ છે કે જે તમે આદેશ વાક્ય પર ચલાવો છો.

599
00:54:55,700 --> 00:55:02,950
મૂળભૂત રીતે, કોઈ પણ ભાષા કે જે તમે કમ્પાઇલ નથી પરંતુ તમે ચલાવી સ્કોર જઈ રહ્યાં છો નથી

600
00:55:02,950 --> 00:55:05,920
આદેશ વાક્ય પર, તમે તે એક્ઝેક્યુટેબલ સ્ક્રિપ્ટ કૉલ કરી શકો છો.

601
00:55:05,920 --> 00:55:08,510
હું માત્ર તેમજ સી કાર્યક્રમ છે કે જે કરે લખી શકે છે,

602
00:55:08,510 --> 00:55:12,300
પરંતુ હું તે સ્ક્રિપ્ટ કૉલ થી હું તેને પ્રથમ વખત કમ્પાઇલ અને પછી દ્વિસંગી સ્કોર નથી.

603
00:55:12,300 --> 00:55:15,480
પરંતુ આ PHP કાર્યક્રમ અમે એક સ્ક્રિપ્ટ કહી રહ્યા છીએ.

604
00:55:15,480 --> 00:55:23,830
અથવા, જો અમે તેને Python અથવા પર્લ અથવા Node.js અથવા તે વસ્તુઓ કોઇ પણ લખ્યું હતું

605
00:55:23,830 --> 00:55:26,500
અમે તેમને તમામ સ્ક્રિપ્ટો કૉલ કારણ કે તમે તેમને આદેશ વાક્ય પર ચલાવવા માંગો છો

606
00:55:26,500 --> 00:55:30,040
પરંતુ અમે તેમને કમ્પાઇલ નથી.

607
00:55:30,860 --> 00:55:33,400
અમે આ ખૂબ ઝડપથી કરી શકે.

608
00:55:36,960 --> 00:55:41,480
અમે argv ઉપયોગ ન જવું છે. હિસ્સો માત્ર દો આ મારફતે ફૂંકી મારે છે.

609
00:55:41,480 --> 00:55:45,730
તે અનન્ય કૉલ કરો, એક કાર્યક્રમ લખો.

610
00:55:45,730 --> 00:55:49,400
તમે ધારણ કરી શકે છે કે જે ઈનપુટ લીટી પ્રતિ એક શબ્દ સમાવશે.

611
00:55:49,400 --> 00:55:52,020
ખરેખર, argv ખૂબ ઉપયોગ કરવા માટે તુચ્છ હશે.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
પ્રથમ વસ્તુ પ્રથમ, અમે તપાસ જો આપણે 1 દલીલ આદેશ લીટી પસાર કરવામાં આવ્યા છે કરવા માંગો છો.

614
00:56:13,750 --> 00:56:20,900
જેમ તમે argc અને C માં argv અપેક્ષા અનુસાર, અમે હજુ પણ PHP માં તે હોય છે.

615
00:56:20,900 --> 00:56:33,900
તેથી (argc $ 2 ==!) જો તે પછી હું એક સંદેશ અથવા કંઈપણ છાપવા સાથે વ્યવહાર કરશે.

616
00:56:33,900 --> 00:56:37,340
મેં હમણાં જ બહાર નીકળો, 1 ભૂલ કોડ પડશે.

617
00:56:37,340 --> 00:56:41,340
હું પણ 1 પરત કરી શકે છે.

618
00:56:41,340 --> 00:56:53,180
ભાગ્યે જ PHP જો તમે આ રાજ્ય પર છે જ્યાં અમે અંતે છો -

619
00:56:53,180 --> 00:56:57,820
સામાન્ય રીતે તમે એક એક કાર્ય દ્વારા કહેવામાં આવે કાર્ય દ્વારા કહેવામાં આવે કાર્ય દ્વારા કહેવામાં આવે કાર્ય છો.

620
00:56:57,820 --> 00:57:02,070
અને જો કંઈક ખોટું અને તમે માત્ર બધું સંપૂર્ણપણે બહાર નીકળવા માંગો છો,

621
00:57:02,070 --> 00:57:05,680
બહાર નીકળો માત્ર કાર્યક્રમ પૂર્ણ થાય છે.

622
00:57:05,680 --> 00:57:08,160
આ પણ સી અસ્તિત્વમાં છે

623
00:57:08,160 --> 00:57:10,700
જો તમે કાર્યમાં એક કાર્યમાં છો

624
00:57:10,700 --> 00:57:17,540
અને તમે માત્ર આ કાર્યક્રમ મારવા કરવા માંગો છો, તો તમે બહાર નીકળો કૉલ અને તે માત્ર બહાર નીકળવા હશે.

625
00:57:17,540 --> 00:57:23,120
પરંતુ મહેરબાની કરીને PHP તે પણ વધુ દુર્લભ છે કે અમે આ શીર્ષ સ્તર પર નથી.

626
00:57:23,120 --> 00:57:26,090
સામાન્ય રીતે અમે કાર્ય અમુક પ્રકારની અંદર છો, જેથી અમે બહાર નીકળો કૉલ

627
00:57:26,090 --> 00:57:29,650
તેથી અમે ઉપર 1 વસ્તુ જે પછી ખબર પડે પરત ન હોય ત્યાં એક ભૂલ છે

628
00:57:29,650 --> 00:57:32,270
જેથી અપ આપે છે જો કે ઓળખે છે ત્યાં ભૂલ હતી.

629
00:57:32,270 --> 00:57:35,270
અમે તે સાથે વ્યવહાર ન માગો જેથી બહાર નીકળવા (1);

630
00:57:35,270 --> 00:57:38,240
(1) વળતર, આ કિસ્સામાં સમકક્ષ હશે.

631
00:57:38,240 --> 00:57:44,000
>> તો પછી અમે શું ખોલવા માંગો છો અમે fopen કરવા માંગો છો.

632
00:57:44,000 --> 00:57:46,760
દલીલો માટે ખૂબ સમાન જુઓ જવું છે.

633
00:57:46,760 --> 00:57:51,600
અમે (argv $ fopen [1], અને અમે તેને વાંચવા માટે ખોલવા માંગો છો. માટે કરવા માંગો છો

634
00:57:51,600 --> 00:57:55,720
કે સાધનની જે અમે એફ કહી રહ્યા છીએ આપે છે.

635
00:57:55,720 --> 00:58:02,180
આ એક ખૂબ સુંદર કેવી રીતે સી તે સિવાય અમે છે FILE * કહેવું ન હોય તો જેવું જ દેખાય છે.

636
00:58:02,180 --> 00:58:06,170
તેના બદલે અમે માત્ર એફ $ કહો. ઠીક છે.

637
00:58:06,170 --> 00:58:17,190
ખરેખર, મને લાગે છે કે આ પણ અમને PHP ફાઈલ કહેવાય વિધેય તરીકે સંકેત આપે છે. PHP ફાઇલ.

638
00:58:17,190 --> 00:58:23,990
આ કરવા જઈ રહ્યો છે શું ઝાકઝમાળ માં સમગ્ર ફાઈલ વાંચી છે.

639
00:58:23,990 --> 00:58:29,770
તમે તેને fopen માટે જરૂર નથી. તે માટે તમે આ કરી રહ્યું છે.

640
00:58:37,450 --> 00:58:43,700
તેથી $ રેખાઓ ફાઈલ = (argv $ [1]);

641
00:58:43,700 --> 00:58:49,680
હવે ફાઈલ રેખાઓ બધી લીટીઓની છે. હવે અમે લીટીઓ સૉર્ટ કરવા માંગો છો.

642
00:58:49,680 --> 00:58:52,180
અમે લીટીઓ કેવી રીતે સૉર્ટ કરી શકો છો?

643
00:58:52,180 --> 00:58:54,920
અમે લીટીઓ સૉર્ટ.

644
00:58:54,920 --> 00:58:58,080
અને હવે અમે તેમને અથવા જે છાપી શકો છો.

645
00:58:58,080 --> 00:59:05,580
કદાચ સૌથી સરળ રસ્તો foreach ($ $ તરીકે રેખા રેખાઓ) $ રેખા પડઘો છે;

646
00:59:05,580 --> 00:59:10,960
[વિદ્યાર્થી] અમે સૉર્ટ માં કંઈક સંદર્ભ દ્વારા પણ નથી રેખાઓ ઓળંગી માંગો છો?

647
00:59:10,960 --> 00:59:28,850
આ તે છે જ્યાં સૉર્ટ કાર્ય સૉર્ટ (અને એરે $) તરીકે વ્યાખ્યાયિત કરવામાં આવશે.

648
00:59:28,850 --> 00:59:32,650
જ્યારે તમે કૉલ કાર્ય તમે તેને સંદર્ભ દ્વારા પાસ કરતું નથી.

649
00:59:32,650 --> 00:59:36,900
તે કાર્ય કે તેને સંદર્ભ લેવા તરીકે વ્યાખ્યાયિત છે.

650
00:59:36,900 --> 00:59:40,900
આ વાસ્તવમાં બરાબર છે શું ખોટું થયું હતું

651
00:59:40,900 --> 00:59:46,220
જ્યારે અમે અમારા સર્વર્સ માટે બધું મૂકી જ્યારે અમે 5.3 થી 5.4 ગયા હતા.

652
00:59:46,220 --> 00:59:53,800
5.4 સુધી, આ સંપૂર્ણપણે વાજબી હતો.

653
00:59:53,800 --> 00:59:58,740
એ કાર્ય માટે તેને સંદર્ભ લેવાની અપેક્ષા નથી, પરંતુ તમે તેને સંદર્ભ તરીકે પસાર કરી શકો છો

654
00:59:58,740 --> 01:00:02,860
તેથી જો કાર્ય તેને સુધારવા થાય, તે હજુ પણ ફેરફાર છે.

655
01:00:02,860 --> 01:00:05,850
5.4 થી, તમે આ કરવા નથી માનવામાં કરી રહ્યાં છો.

656
01:00:05,850 --> 01:00:11,740
તેથી હવે માત્ર રસ્તો તમે સંદર્ભ દ્વારા પસાર છે જો કાર્ય તેને બાહ્ય રીતે કરે છે.

657
01:00:11,740 --> 01:00:19,840
જો તમે તેને સુધારવા માટે નથી માંગતા, તો પછી તમારે $ નકલ $ = રેખાઓ અને પાસ નકલ કરવાની જરૂર છે.

658
01:00:19,840 --> 01:00:24,820
તેથી હવે રેખાઓ અને આરક્ષિત રહેશે નકલ બદલવામાં આવશે.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. હું કંઈક મિશ્રિત થયેલા હોઈ શકે છે.

660
01:00:31,460 --> 01:00:33,190
અણધારી 'સૉર્ટ કરો'.

661
01:00:38,320 --> 01:00:43,850
ત્યાં કંઈક કે જે આપણા માટે કરે જ હશે.

662
01:00:43,850 --> 01:00:45,820
તે પણ ત્યાં નથી.

663
01:00:45,820 --> 01:00:52,140
નોંધ જ્યારે તમે માર્ગદર્શિકા કે જે પ્રથમ દલીલ કોઈ અરે હોવો અપેક્ષા છે વાંચી

664
01:00:52,140 --> 01:00:56,490
અને તે સંદર્ભ દ્વારા લેવામાં છે.

665
01:00:58,160 --> 01:01:03,540
આ મને શા માટે ફરિયાદ છે? કારણ કે હું આ કાર્ય સૉર્ટ હજુ પણ અહીં છે કે હું નથી માંગતા હોય છે.

666
01:01:03,540 --> 01:01:09,210
ઠીક છે, php.unique.php. હું તે દલીલ પાસ ન કારણ કે હું એક ફાઇલ નથી.

667
01:01:09,210 --> 01:01:13,560
તે test.php પર php.unique.php છે.

668
01:01:13,560 --> 01:01:19,080
અહીં તમામ સરસ ક્રમમાં છપાયેલ test.php છે.

669
01:01:19,080 --> 01:01:24,600
નોંધ કરો કે ક્રમમાં કોડ ફાઈલ માટે પ્રકારની વિચિત્ર છે

670
01:01:24,600 --> 01:01:27,460
કારણ કે અમારી ખાલી લીટીઓ બધી પ્રથમ આવનારને જવું છે

671
01:01:27,460 --> 01:01:30,190
પછી અમારી સ્તર 1 indentations તમામ આવવું જવું છે

672
01:01:30,190 --> 01:01:33,360
પછી અમારી કોઈ indentations તમામ આવે છે.

673
01:01:33,360 --> 01:01:38,620
યાહ. >> [વિદ્યાર્થી] તેથી સ્ત્રોત કોડ માટે સંદર્ભ દ્વારા પસાર કરવામાં આવ્યો હતો?

674
01:01:38,620 --> 01:01:42,240
છે કે સામાન્ય રીતે કિંમત દ્વારા પસાર?

675
01:01:42,240 --> 01:01:50,240
[બોડેન] જ્યારે તમે કાર્ય કહી, તે નક્કી કરે છે કે શું તે સંદર્ભ દ્વારા પસાર કરવામાં આવ્યો નથી.

676
01:01:50,240 --> 01:01:53,960
તે કાર્ય વ્યાખ્યા જે નક્કી કરે છે કે શું તે સંદર્ભ દ્વારા પસાર કરવામાં આવ્યો છે.

677
01:01:53,960 --> 01:01:59,450
અને પ્રકારના કાર્ય વ્યાખ્યા જોઈ અથવા આ જોઈ,

678
01:01:59,450 --> 01:02:02,820
તે સંદર્ભ દ્વારા દલીલ લે છે.

679
01:02:02,820 --> 01:02:07,160
તેથી કે શું તમે તેને તે સંદર્ભ દ્વારા લેવા માંગો છો અનુલક્ષીને, તે કરે છે તે સંદર્ભ દ્વારા લે છે.

680
01:02:07,160 --> 01:02:10,200
તે જગ્યાએ એરે સુધારે.

681
01:02:10,200 --> 01:02:17,400
આ માત્ર અનુમતિ નથી. તમે આ કરવાની અનુમતિ નથી. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.

682
01:02:17,400 --> 01:02:22,410
[બોડેન] આ પ્રકારના સંદર્ભ દ્વારા રેખાઓ ભરે છે અને તેને સુધારવા રહ્યું છે.

683
01:02:22,410 --> 01:02:26,850
અને ફરી, જો તમે તે કરવું માંગતા ન હોય, તો તમે સૉર્ટ નકલ કરી શકે છે.

684
01:02:26,850 --> 01:02:35,850
આ કેસમાં પણ, નકલ ખરેખર રેખાઓ એક નકલ નથી.

685
01:02:35,850 --> 01:02:40,620
તે માત્ર એ જ વસ્તુ કરવા માટે નિર્દેશ સુધી તે પ્રથમ ફેરફાર નહીં,

686
01:02:40,620 --> 01:02:44,430
તે પ્રથમ કે જ્યાં સૉર્ટ કામગીરીમાં ફેરફાર કરો ચાલી રહ્યું છે,

687
01:02:44,430 --> 01:02:50,940
જ્યાં, કારણ કે તે કોપી ઓન રાઇટ, હવે નકલ નકલ કરવામાં આવી રહ્યું છે.

688
01:02:57,500 --> 01:03:04,250
તમે પણ કરી શકો છો. કે અન્ય જગ્યાએ તમે & "અને" નું ચિહ્ન જોઈ શકો છો.

689
01:03:04,250 --> 01:03:07,190
તમે તેને foreach આંટીઓ જુઓ, તો તમે તેને કાર્ય જાહેરાતો જુઓ,

690
01:03:07,190 --> 01:03:10,040
અને તમે તેને જુઓ છો ત્યારે માત્ર ચલો સોંપ્યું.

691
01:03:10,040 --> 01:03:12,350
હવે અમે આ કરવાથી કશું પરિપૂર્ણ છે

692
01:03:12,350 --> 01:03:15,600
કારણ કે નકલ અને લીટીઓ શાબ્દિક જ વસ્તુ છે.

693
01:03:15,600 --> 01:03:19,940
તમે લીટીઓ વાપરો અને એકબીજાના નકલ કરી શકો છો.

694
01:03:19,940 --> 01:03:25,430
તમે સેટ કર્યા વિના (નકલ $) કરી શકો છો; અને તે સેટ કર્યા વિના લીટીઓ નથી,

695
01:03:25,430 --> 01:03:29,120
તમે માત્ર એક જ વસ્તુ માટે તમારા સંદર્ભ ગુમાવી બેસે છે.

696
01:03:29,120 --> 01:03:33,440
તેથી આ મુદ્દે તરીકે, હવે રેખાઓ માત્ર રસ્તો તમે રેખાઓ ઍક્સેસ કરી શકે છે.

697
01:03:36,450 --> 01:03:38,770
>> પ્રશ્નો?

698
01:03:41,000 --> 01:03:42,460
યાહ.

699
01:03:42,460 --> 01:03:45,880
વિષય બોલ સંપૂર્ણપણે [વિદ્યાર્થી], પરંતુ તમે સાથે PHP બંધ નથી - >> કરવું તમે નથી.

700
01:03:45,880 --> 01:03:47,730
ઠીક છે.

701
01:03:47,730 --> 01:03:53,790
[બોડેન] હું સુધી જઈ કહેવા માટે તે ખરાબ વ્યવહાર કરવા માટે તેમને બંધ કરશે.

702
01:03:53,790 --> 01:03:57,580
કે કદાચ એક કસોટી છે સ્ક્રિપ્ટ, ખાસ કરીને,

703
01:03:57,580 --> 01:04:03,740
દો પરંતુ જુઓ શું થાય છે જો હું આ કરું છું.

704
01:04:03,740 --> 01:04:08,890
કે કશું જ કર્યું. જો હું ઇચ્છતો હતો - [sighs]

705
01:04:13,870 --> 01:04:16,960
મેં એક દલીલ પસાર કરવાની જરૂર છે.

706
01:04:19,000 --> 01:04:22,050
શૂટ. હું તે ખોટું કહેવાય છે.

707
01:04:24,340 --> 01:04:28,310
એક દલીલ સાથે જેથી php.unique.php.

708
01:04:28,310 --> 01:04:30,980
હવે હું પણ આ કરવાની જરૂર નથી.

709
01:04:34,520 --> 01:04:37,740
હું તે માન્ય દલીલ પસાર કરશો.

710
01:04:37,740 --> 01:04:42,050
આ મુદ્રિત ગમે તે છાપકામ છે.

711
01:04:45,260 --> 01:04:50,080
હું નકલ છાપવા છું અને નકલ અસ્તિત્વમાં નથી. લીટીઓ તેથી.

712
01:04:53,650 --> 01:04:58,270
તે બધું થયું, અને પછી અહીં નીચે આ તમામ જંક નોટિસ,

713
01:04:58,270 --> 01:05:06,690
કારણ કે PHP કંઈપણ કે PHP ટૅગ્સ બહાર છે

714
01:05:06,690 --> 01:05:09,520
છે માત્ર શાબ્દિક મુદ્રિત હશે.

715
01:05:09,520 --> 01:05:18,050
કે એચટીએમએલ શા માટે, તે આવું સરસ છે કે હું div મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત વર્ગ અથવા જે કરી શકે છે,

716
01:05:18,050 --> 01:05:25,140
મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત કરો અને પછી કેટલાક PHP કોડ કરવું અને પછી ઓવરને div નથી.

717
01:05:25,140 --> 01:05:36,460
અને હવે આ છાપવા હું ઉપર મારા સરસ div મેળવવા માટે, બધું PHP પ્રિન્ટેડ, તળિયે DIV.

718
01:05:36,460 --> 01:05:43,510
વિનાશક જ્યારે આ કંઈક થાય છે, જે ખૂબ સામાન્ય છે,

719
01:05:43,510 --> 01:05:47,930
ફક્ત ફાઇલ તળિયે એક સ્ટ્રે NEWLINE.

720
01:05:47,930 --> 01:05:50,940
તમે નથી લાગતું તે સોદો કે મોટું હશે

721
01:05:50,940 --> 01:05:58,660
જ્યાં સુધી તમે બ્રાઉઝરમાં કે હકીકત ધ્યાનમાં -

722
01:05:58,660 --> 01:06:03,880
>> વર્ક અન્યત્ર કેવી રીતે અથવા મૂળભૂત રીતે કોઈ પણ હેડરો કામ,

723
01:06:03,880 --> 01:06:07,980
જ્યારે તમે વેબસાઇટ પર તમારી કનેક્શન બનાવવા અને તેને પરત મોકલે આ બધી હેડરો અને વસ્તુઓ

724
01:06:07,980 --> 01:06:12,020
200 પ્રતિભાવ અથવા પુનઃદિશામાન અથવા જે પ્રતિભાવ જેમ,

725
01:06:12,020 --> 01:06:18,230
હેડરો જ માન્ય છે ત્યાં સુધી માહિતી પ્રથમ બાઇટ મોકલવામાં આવે છે.

726
01:06:18,230 --> 01:06:23,140
તમે વખત હજારો પુનઃદિશામાન થયેલ છે, પરંતુ વહેલી તકે માહિતી પ્રથમ બાઇટ મોકલવામાં આવે છે

727
01:06:23,140 --> 01:06:26,120
તમે ફરીથી પુનઃદિશામાન નથી માનવામાં કરી રહ્યાં છો.

728
01:06:26,120 --> 01:06:31,860
>> જો તમે એક ફાઇલ તળિયે એક સ્ટ્રે NEWLINE છે

729
01:06:31,860 --> 01:06:37,260
દો અને કહે છે કે તમે આ કાર્ય વાપરો અને પછી તમે કરવા માંગો છો -

730
01:06:41,580 --> 01:06:52,870
હવે કહો કે તે બીજી ફાઇલ છે કે જે index.php છે અને તમે કંઈક require_once -

731
01:06:52,870 --> 01:06:56,920
હું તે એક સારું ઉદાહરણ કલ્પના કરી શકતો નથી.

732
01:06:56,920 --> 01:07:04,740
આ મુદ્દો ત્યારે થાય છે જ્યારે નીચે આ વાક્ય દેખાતો નહીં.

733
01:07:04,740 --> 01:07:08,660
તમે હજી સુધી દેખાતો છે કંઈપણ નહિં માંગો.

734
01:07:10,820 --> 01:07:15,700
છતાં પણ તમે રહ્યું દેખાતો કંઈપણ નથી ઇરાદો નહોતો, કંઈક દેખાતો નહોતો કરો

735
01:07:15,700 --> 01:07:17,990
અને તેથી હવે તમે કોઈપણ વધુ હેડરો ન મોકલવા માનવામાં કરી રહ્યાં છો

736
01:07:17,990 --> 01:07:20,030
અને તમે ફરિયાદો મળી રહ્યા છીએ.

737
01:07:22,170 --> 01:07:24,420
તમે માત્ર તે બંધ ટૅગ્સ જરૂર નથી.

738
01:07:24,420 --> 01:07:27,420
જો તમને HTML સાથે આવું કરવાની યોજના છે -

739
01:07:27,420 --> 01:07:30,490
અને તે સંપૂર્ણપણે વાજબી કરવા માટે નીચે અહીં div કરવું ગમે

740
01:07:30,490 --> 01:07:39,450
અને પછી આ બિંદુએ તમે અથવા તમે સમાવેશ કરી શકે છે તેમને નથી.

741
01:07:39,450 --> 01:07:41,590
તે ખરેખર તો કોઈ વાંધો નથી.

742
01:07:41,590 --> 01:07:45,450
પરંતુ મહેરબાની કરીને PHP સ્ક્રિપ્ટો તે દુર્લભ છે તેને બંધ કરો.

743
01:07:45,450 --> 01:07:50,400
જ્યારે બધું PHP, સંપૂર્ણપણે બધું છે,

744
01:07:50,400 --> 01:07:55,460
તમે ખરેખર તેને બંધ / તમે તેને બંધ કરીશું જરૂર નથી.

745
01:08:02,030 --> 01:08:05,720
>> શબ્દમાળાઓ સાથે વ્યવહાર ખૂબ સી કરતાં NICER છે

746
01:08:05,720 --> 01:08:09,470
PHP માં તમે એક અથવા બે અવતરણચિહ્નો સાથે શબ્દમાળા સ્પષ્ટ કરી શકો છો.

747
01:08:09,470 --> 01:08:12,820
એક જ અવતરણચિહ્નો સાથે તમે "એસ્કેપ" સિક્વન્સ ઉપયોગ કરી શકતા નથી.

748
01:08:12,820 --> 01:08:17,640
સતત છટકી, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત.

749
01:08:19,920 --> 01:08:24,010
તેથી printf PHP અત્યંત દુર્લભ છે.

750
01:08:24,010 --> 01:08:32,290
હું માનું હું printf વાપરો જો હું વસ્તુ એક પ્રકારનો સુંઘવું કરશે - 5 pset માં તમે sprintf અથવા જે ઉપયોગ થાય છે.

751
01:08:32,290 --> 01:08:36,060
પરંતુ તમે 001.jpg અને 002.jpg કરવા માંગો છો.

752
01:08:36,060 --> 01:08:40,300
તેથી વસ્તુ કે આનાથી સૉર્ટ કરો માટે જ્યાં હું ખરેખર લખાણ હું printf ઉપયોગ કરશે ફોર્મેટ કરવા માંગો છો.

753
01:08:40,300 --> 01:08:44,689
પરંતુ અન્યથા હું હમણાં જ શબ્દમાળા શૃંખલીકરણ ઉપયોગ કરશે.

754
01:08:44,689 --> 01:08:47,000
હું printf ખરેખર ક્યારેય ઉપયોગ કરે છે.

755
01:08:49,229 --> 01:09:00,170
અમે હમણાં જ એક જ અવતરણચિહ્નો અને બેવડા અવતરણ વચ્ચે વિગતો જુદી કરી રહ્યાં છો.

756
01:09:00,170 --> 01:09:07,490
સૌથી મોટો તફાવત એ છે કે એક જ અવતરણચિહ્નો, તે શાબ્દિક છપાશે.

757
01:09:07,490 --> 01:09:15,390
ત્યાં PHP કોઈ કામની પાળી માહિતી પ્રકાર છે, સી વિપરીત, જેથી આ બરાબર છે.

758
01:09:15,390 --> 01:09:17,970
તેઓ બંને શબ્દમાળાઓ છો.

759
01:09:17,970 --> 01:09:29,180
અને એક ક્વોટ શબ્દમાળાઓ વિશે સરસ વસ્તુ છે, હું કહું છું શકે 'હેલો વિશ્વ!' મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત,

760
01:09:29,180 --> 01:09:33,340
$ $ Wooo.

761
01:09:33,340 --> 01:09:38,260
શું થાય છે જ્યારે હું છાપો આ છે તેને શાબ્દિક છાપશે.

762
01:09:38,260 --> 01:09:40,680
ચાલો અમારી સામગ્રી તમામ છૂટકારો મળે છે.

763
01:09:40,680 --> 01:09:44,700
તેથી str1 $ પડઘો;

764
01:09:48,569 --> 01:09:56,570
તે શાબ્દિક તે બધું મુદ્રિત: ડોલર ચિહ્ન,

765
01:09:56,570 --> 01:09:58,770
બેકસ્લેશ n એ, જે તમને લાગે કરશે newlines હશે -

766
01:09:58,770 --> 01:10:01,500
તે બધું તેને શાબ્દિક છાપે છે.

767
01:10:01,500 --> 01:10:05,650
આ જ વસ્તુ તમે ભાગી જરૂર એક જ અવતરણચિહ્નો છે

768
01:10:05,650 --> 01:10:09,470
અન્યથા કારણ કે તે લાગે તે એક અવતરણ બંધ છે.

769
01:10:09,470 --> 01:10:15,050
બેવડા અવતરણ, સંપૂર્ણપણે અલગ છે.

770
01:10:20,300 --> 01:10:25,870
અમે પહેલાથી જ સિન્ટેક્સ હાઇલાઇટિંગ અમને તે વિશે ઘણું જ ખોટું જાઓ કરવા માટે પર cluing છે જુઓ.

771
01:10:25,870 --> 01:10:36,190
php.unique. અનિર્ધારિત ચલ: wooo કારણ કે આ wooo કહેવાય ચલ તરીકે અર્થઘટન છે.

772
01:10:36,190 --> 01:10:42,400
બેવડા અવતરણ તમને માં variables સામેલ -

773
01:10:42,400 --> 01:10:52,730
ચાલો $ નામ = "રોબ" કહે છે;

774
01:10:52,730 --> 01:10:58,020
તેથી પડઘો "હાય, મારું નામ ડોલર છે નામ!";

775
01:10:58,020 --> 01:11:09,260
તે એક ચલ તરીકે આ ઓળખે છે.

776
01:11:09,260 --> 01:11:21,210
જ્યારે હું કે સ્કોર છે - અને હું એક NEWLINE દાખલ કરશે - હાય, મારું નામ રોબ છે! અને હેલો વિશ્વ!

777
01:11:21,210 --> 01:11:24,910
આ કારણ છે કે ઉપર હું wooo ના પ્રિન્ટીંગ ક્યારેય દૂર કર્યું.

778
01:11:24,910 --> 01:11:30,020
ત્યાં 1 વધુ પગલું તમે શું કરી શકો છો છે.

779
01:11:30,020 --> 01:11:39,250
એરે $ = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
જો હું માટે એરે પ્રથમ અનુક્રમણિકા પ્રિન્ટ કરવા માંગો છો?

781
01:11:43,270 --> 01:11:45,150
તમે $ એરે [0] હોય છે.

782
01:11:45,150 --> 01:11:49,280
આ સિન્ટેક્સ હાઇલાઇટિંગ એક ચાવી છે. આ શું થઈ રહ્યું છે છો?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
હાય, મારું નામ 1 છે! જે નથી હું શું ઇચ્છે છે.

785
01:11:59,860 --> 01:12:05,050
સિન્ટેક્સ હાઇલાઇટિંગ મને ખોટું બોલ્યા.

786
01:12:05,050 --> 01:12:13,020
ચાલો પ્રયાસ 'એ' - 1> 'બી' - 2>.

787
01:12:18,450 --> 01:12:21,440
કે કેવી રીતે હું તેને લખી હશે.

788
01:12:26,350 --> 01:12:32,160
અનપેક્ષિત એક અવતરણ (T_ENCAPSED મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત).

789
01:12:32,160 --> 01:12:41,780
આ વિચાર એ છે કે તે આ એરે ભાગ તરીકે માન્યતા નથી છે.

790
01:12:41,780 --> 01:12:46,620
આ એક પત્ર દ્વારા અનુક્રમિત એરે તરીકે ન ઓળખી છે.

791
01:12:46,620 --> 01:12:49,870
તમે સર્પાકાર કૌંસ ઘેરાયેલા છે કે શું કરવા માગો છો,

792
01:12:49,870 --> 01:12:54,730
અને હવે ગમે આ સર્પાકાર તાણવું છે કરી સંકેલી કરશે,

793
01:12:54,730 --> 01:13:00,340
જે શબ્દ અમે જાદુઇ અધિકાર સ્થાનો માં આ ચલો દાખલ માટે ઉપયોગ થાય છે.

794
01:13:00,340 --> 01:13:04,280
હવે આ કરી, php.unique, અને હાય, મારું નામ 1 છે! ઈચ્છિત તરીકે

795
01:13:04,280 --> 01:13:07,720
અથવા હાય, મારું નામ રોબ છે!

796
01:13:14,110 --> 01:13:23,130
એક વસ્તુ છે કે એક જ અવતરણચિહ્નો વિશે સરસ પ્રકારની એટલા માટે છે કે -

797
01:13:23,130 --> 01:13:28,480
ત્યાં પ્રક્ષેપક કેટલાક કિંમત છે.

798
01:13:30,520 --> 01:13:35,100
જો તમે બેવડા અવતરણ વાપરવા માટે, ઈન્ટરપ્રીટર પર આ શબ્દમાળાને જાઓ ધરાવે છે,

799
01:13:35,100 --> 01:13:41,500
ખાતરી કરો કે, જે "ઓહ, અહીં એક ચલ છે હવે હું જાઉં છું કે ચલ વિચાર અને તેને અહીં દાખલ કરવાની જરૂર છે.".

800
01:13:41,500 --> 01:13:48,930
જો તમે કોઈપણ variables ઉપયોગ નથી કરતા,

801
01:13:48,930 --> 01:13:52,220
આ બે અવતરણચિહ્નો ની અંદર કંઈ સંકેલી કરવાની જરૂર છે,

802
01:13:52,220 --> 01:13:56,800
પરંતુ તે હજુ પણ ધીમી હોય છે કારણ કે તે ઉપર બેવડા અવતરણ જાઓ જરૂર પડશે

803
01:13:56,800 --> 01:14:00,130
વસ્તુઓ કે જે સંકેલી કરવાની જરૂર શોધી.

804
01:14:00,130 --> 01:14:05,360
તેથી એક જ અવતરણચિહ્નો થોડી ઝડપી થઈ શકે જો કંઈ સંકેલી કરવાની જરૂર કરી શકો છો,

805
01:14:05,360 --> 01:14:15,650
અને હું માટે વાપરવા પણ એક જ અવતરણચિહ્નો 'હાય, મારું નામ છે' હોય છે. $ એરે ['એ'] કોઈપણ રીતે.

806
01:14:15,650 --> 01:14:20,430
કે આપણે શું પહેલાં હતી સમકક્ષ હશે.

807
01:14:24,840 --> 01:14:28,440
પરંતુ તે પસંદગી બાબત છે.

808
01:14:28,440 --> 01:14:34,750
જો તમે PHP ઉપયોગ કરી રહ્યાં છો, તો તમે કદાચ ઝડપ તફાવત વિશે કાળજી નથી.

809
01:14:34,750 --> 01:14:39,480
ત્યાં તેમને કારણ બહાર સાથે શરૂ પર્યાપ્ત નથી.

810
01:14:39,480 --> 01:14:43,030
>> કોઈપણ અંતિમ પ્રશ્ન છે?

811
01:14:47,430 --> 01:14:51,710
>> અમે ખરેખર તેને તમામ મારફતે મળી નથી, પરંતુ આ સામગ્રી કંટાળાજનક હતું.

812
01:14:51,710 --> 01:14:59,080
છેલ્લા વસ્તુ કે PHP માં પ્રકારની સરસ હતો એ છે કે જ્યારે તમને HTML સાથે કામ કરીએ છીએ,

813
01:14:59,080 --> 01:15:06,450
તમે તે ચલ છાપવા માટે એક બીટ, તેથી સરસ શૉર્ટકટ વાક્યરચના વાપરે પડશે.

814
01:15:32,400 --> 01:15:36,730
PHP અહીં મૂકી વિના, આ ટૂંકી ટૅગ્સ કહેવામાં આવે છે.

815
01:15:36,730 --> 01:15:44,330
તરીકે 5.4 PHP ની સત્તાવાર રીતે, આ આવેલ છે.

816
01:15:44,330 --> 01:15:48,640
તમે php મૂકવા ભલામણ કરવામાં આવે છે.

817
01:15:48,640 --> 01:15:55,770
આ હજુ પણ છે, <સાથે જ ટૂંકા ટૅગ્સ આધારભૂત છે =? હજુ સંપૂર્ણપણે દંડ છે.

818
01:15:55,770 --> 01:16:02,480
તે આધારભૂત મૂળભૂત રીતે છે, તેથી તમે આ ઉપયોગ શકો છો, અને તેઓ ખૂબ અનુકૂળ છો.

819
01:16:02,480 --> 01:16:05,700
>> કોઈપણ પ્રશ્ન છે?

820
01:16:07,780 --> 01:16:09,270
અધિકાર છે.

821
01:16:10,840 --> 01:16:13,800
>> સર્વોપરી રહો, સેન ડિયાગો.

822
01:16:13,800 --> 01:16:16,070
[Chuckles]

823
01:16:18,620 --> 01:16:22,660
બાય. [Laughs]

824
01:16:24,350 --> 01:16:28,470
[વધાવી] [laughs]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]