1
00:00:00,000 --> 00:00:02,270
>> [સમીક્ષા: ક્વિઝ 1]

2
00:00:02,270 --> 00:00:04,620
[અલી Nahm, Oreoluwa Barbarinsa, લુકાસ Freitas, રોબ બોડેન] [હાર્વર્ડ યુનિવર્સિટી]

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

4
00:00:07,660 --> 00:00:11,610
[લુકાસ Freitas] દરેક આપનું સ્વાગત છે. આ ક્વિઝ 1 માટે સમીક્ષા છે.

5
00:00:11,610 --> 00:00:15,040
માત્ર એક અસ્વીકૃતિ તરીકે, આ છે - હું તેનો અર્થ, અમે આવરી પ્રયાસ રહ્યા છીએ

6
00:00:15,040 --> 00:00:17,770
શક્ય છે, પરંતુ એટલું સામગ્રી અર્થ એ નથી કે તે

7
00:00:17,770 --> 00:00:20,780
અમે 1 ક્વિઝ માં હોઈ શકે છે તે બધું આવરી રહ્યા છીએ.

8
00:00:20,780 --> 00:00:25,270
તેથી તમે પણ વ્યાખ્યાન પર એક નજર, વિભાગો, તમે આ કરી શકો છે કે બધું લેવા ખાતરી કરો.

9
00:00:25,270 --> 00:00:28,240
1 ક્વિઝ બુધવાર, આગામી બુધવારે પ્રયત્ન રહ્યું છે.

10
00:00:28,240 --> 00:00:33,800
તેથી અભ્યાસ ખાતરી કરો. તે પ્રથમ ક્વિઝ જેમ, ખૂબ ખૂબ, જ હશે

11
00:00:33,800 --> 00:00:36,390
તેના બંધારણમાં સંબંધિત છે, પરંતુ તે કદાચ ઘણી મુશ્કેલ બની રહ્યું છે.

12
00:00:36,390 --> 00:00:39,600
હું 50 લીધી ત્યારે ઓછામાં ઓછા, ગયા વર્ષે હું તેને ખૂબ કઠણ હતું.

13
00:00:39,600 --> 00:00:42,410
તેથી ઘણો અભ્યાસ કરે છે.

14
00:00:42,410 --> 00:00:45,190
>> હું માહિતી માળખાં આવરી જાઉં છું અને હફમેનના કોડિંગ.

15
00:00:45,190 --> 00:00:47,910
આ ઘણા લોકોને જટિલ છે કે કંઈક છે

16
00:00:47,910 --> 00:00:51,930
પરંતુ હું તે શક્ય તેટલી સરળ બનાવવા પ્રયાસ જાઉં છું.

17
00:00:51,930 --> 00:00:56,330
સૌ પ્રથમ, અમે શું તમે ગાય્ઝ ક્વિઝ 1 માટે જાણવું છે

18
00:00:56,330 --> 00:01:00,970
હું હાજર જાઉં છું કે માહિતી માળખાં દરેક કાલ્પનિક વર્ણન સમજે છે.

19
00:01:00,970 --> 00:01:03,960
એટલે કે, તમે નથી અર્થ એ થાય કે ખરેખર

20
00:01:03,960 --> 00:01:07,020
તમારા ક્વિઝ 1 માં હેશ ટેબલ અમલ.

21
00:01:07,020 --> 00:01:10,250
અમે તમને એક સંપૂર્ણ હેશ ટેબલ અમલ કરવા માંગો છો નથી; કદાચ અમે પ્રયાસ કરીશું

22
00:01:10,250 --> 00:01:13,090
તમે કેટલાક કાર્યો અમલમાં મૂકવા માટે બનાવવા માટે,

23
00:01:13,090 --> 00:01:16,940
સૌથી સામાન્ય કામગીરી પણ અમે તમને બધું અમલમાં કરી રહ્યા નથી.

24
00:01:16,940 --> 00:01:21,010
તેથી તે તમે દરેક માહિતી માળખું પાછળ ખ્યાલ સમજો

25
00:01:21,010 --> 00:01:23,510
અને તમને સી કોડ કરવા સક્ષમ હોય છે કે,

26
00:01:23,510 --> 00:01:27,880
તેઓ દરેક માહિતી બંધારણ માટે છે માત્ર એકદમ સામાન્ય કામગીરી.

27
00:01:27,880 --> 00:01:30,090
અને પણ, પોઇન્ટર અને સ્ટ્ર્ક્ટ્સ સમીક્ષા કરવાનો પ્રયત્ન

28
00:01:30,090 --> 00:01:33,470
તેઓ આ માહિતી માળખામાં ખૂબ જ દેખાય છે.

29
00:01:33,470 --> 00:01:37,380
>> પ્રથમ, યાદીઓ કડી થયેલ છે. લિંક કરેલા યાદીઓ ખરેખર ખૂબ એરે માટે સમાન હોય છે,

30
00:01:37,380 --> 00:01:39,930
પરંતુ એક કડી થયેલ યાદી અને ઝાકઝમાળ વચ્ચે તફાવત,

31
00:01:39,930 --> 00:01:45,160
સૌ પ્રથમ, એક કડી થયેલ યાદી બહુ લવચીક કદ ધરાવે છે

32
00:01:45,160 --> 00:01:50,060
એરે માં તમે એરે માટે ખૂબ જ વિશાળ કદ પસંદ કરવા માટે ક્યાં છે, જ્યારે,

33
00:01:50,060 --> 00:01:53,710
જેથી તમે, તમે તે એરે તમારા તમામ ડેટા સ્ટોર કરવાનો પ્રયત્ન જઈ રહ્યાં છો ખબર છે કે

34
00:01:53,710 --> 00:01:59,370
અથવા તમે એરે એક લવચીક લંબાઈ હોય છે malloc ઉપયોગ કરે છે.

35
00:01:59,370 --> 00:02:03,680
સંલગ્ન યાદીઓ તે માત્ર વધારે તત્વો વિચાર ખૂબ જ સરળ છે,

36
00:02:03,680 --> 00:02:07,210
આ કડી થયેલ યાદીમાં વધુ તત્વો મૂકી અથવા તત્વો દૂર કરો.

37
00:02:07,210 --> 00:02:09,370
અને ખરેખર, જો તમે સંલગ્ન યાદી અલગ કરવામાં આવે છે કરવા માંગો છો નથી,

38
00:02:09,370 --> 00:02:13,950
તમે શોધવા અને સતત સમય તત્વો દૂર કરી શકો છો,

39
00:02:13,950 --> 00:02:16,800
તેથી ઓ (1) સમય છે, તેથી તે ખૂબ જ અનુકૂળ છે.

40
00:02:16,800 --> 00:02:20,660
તમે હમણાં જ ગાંઠો હંમેશા malloc યાદ કરવા માટે ખૂબ કાળજી અને મફત હોય છે

41
00:02:20,660 --> 00:02:25,510
જો તમે ન કરો તો, તમે મેમરી લીક્સ પડશે માત્ર કારણ કે.

42
00:02:25,510 --> 00:02:31,480
તેથી કડી થયેલ યાદીઓ - નોડ વ્યાખ્યા માત્ર આપણે અહિ છે એના જેવું છે.

43
00:02:31,480 --> 00:02:35,110
હું પૂર્ણાંક n એ મૂકી છે, પરંતુ જો તમે ઇચ્છો તે કોઇપણ માહિતી સ્ટોર કરી શકો છો.

44
00:02:35,110 --> 00:02:37,280
તમે શબ્દમાળા સંગ્રહવા માંગો છો તેથી, જો તે દંડ છે.

45
00:02:37,280 --> 00:02:41,690
જો તમે સ્ટ્રક્ટ સંગ્રહવા માંગો છો, તે તમે જે કરવા માંગો છો,, ડબલ દંડ છે.

46
00:02:41,690 --> 00:02:44,630
હું માત્ર અહીં ઉદાહરણ માટે પૂર્ણાંક n એ મૂકો.

47
00:02:44,630 --> 00:02:46,800
અને તમે બીજા ગાંઠ પર એક નિર્દેશક હોય છે.

48
00:02:46,800 --> 00:02:51,940
તેથી, મૂળભૂત રીતે, એક કડી થયેલ યાદી અમુક માહિતી ધરાવે છે, અને પછી તે બીજા ગાંઠ નિર્દેશ કરે છે.

49
00:02:51,940 --> 00:02:56,710
તે સાથે લિંક યાદી છેલ્લા તત્વ છે, તે માટે નલ નિર્દેશ બનશે.

50
00:02:56,710 --> 00:02:59,060
તેથી આ એક કડી થયેલ યાદી ઉદાહરણ છે.

51
00:02:59,250 --> 00:03:05,960
>> ઠીક છે, તેથી હવે હું એક કડી થયેલ યાદીમાં એક તત્વ સામેલ કરવા માંગો છો તો અમે શું કરવું જોઈએ તે જુઓ.

52
00:03:05,960 --> 00:03:08,810
પ્રથમ, એક કાર્ય સામેલ કરો પ્રકાર રદબાતલ હશે

53
00:03:08,810 --> 00:03:11,350
હું કાંઇ પરત કરવા માંગો છો નથી.

54
00:03:11,350 --> 00:03:14,200
અને હું એક દલીલ તરીકે પૂર્ણાંક લેવા જાઉં છું,

55
00:03:14,200 --> 00:03:17,090
હું સામેલ કરવા માંગો છો તે જાણવા માંગો છો છે.

56
00:03:17,090 --> 00:03:21,840
તેથી હું કરવું જોઈએ પ્રથમ વસ્તુ શું છે? ઠીક છે, હું newnode પર malloc જોઈએ,

57
00:03:21,840 --> 00:03:24,240
જેથી પ્રથમ વાક્ય છે.

58
00:03:24,240 --> 00:03:27,580
હું માત્ર એક કડી થયેલ યાદીમાં મૂકવામાં નવી નોડ બનાવવા છું.

59
00:03:27,580 --> 00:03:32,360
તેથી હું શું કરી શકું? વેલ, અમને ખબર છે કે સંલગ્ન યાદીઓ અમારી અમલીકરણો માં

60
00:03:32,360 --> 00:03:38,180
વર્ગ માં, અમે હંમેશા એક વૈશ્વિક ચલ તરીકે વડા મૂકો.

61
00:03:38,180 --> 00:03:41,800
તેથી અમે શું કરી શકો છો છે વડા બદલો.

62
00:03:41,800 --> 00:03:44,300
હું આ નવા નોડ નવા વડા હોય કરી શકે છે,

63
00:03:44,300 --> 00:03:46,670
અને તે અગાઉના વડા માટે નિર્દેશ બનશે.

64
00:03:46,670 --> 00:03:50,390
અમે તે કેવી રીતે કરી શકો છો? હું શું છે પ્રથમ વસ્તુ

65
00:03:50,390 --> 00:03:54,770
, કિંમત માટે નવા નોડ માં 'એન' બદલવા છે

66
00:03:54,770 --> 00:03:57,530
કાર્ય માટે પસાર કરવામાં આવ્યો હતો જે.

67
00:03:57,530 --> 00:04:01,050
પછી newnode આગામી છે વડા પ્રયત્ન રહ્યું છે.

68
00:04:01,050 --> 00:04:05,800
માથા પર newnode પ્રયત્ન રહ્યું છે. તેથી તે ખૂબ સરળ છે.

69
00:04:05,800 --> 00:04:10,090
નોડ કાઢી નાંખવા માટે, અમે જેમ તે કરી શકો છો -

70
00:04:10,090 --> 00:04:14,790
અમે તે કરી શકે એક રીત કહે છે,

71
00:04:14,790 --> 00:04:18,160
ઠીક છે, હું કાઢી નાખવા માગતા હતા, ઉદાહરણ તરીકે, 3,

72
00:04:18,160 --> 00:04:24,850
હું શું કરી શકે છે માત્ર અગાઉના નોડ નિર્દેશ છે

73
00:04:24,850 --> 00:04:27,580
3 ના આગળના નોડ છે.

74
00:04:27,580 --> 00:04:29,400
તેથી હું ફક્ત તે કંઈક કરી શકે છે.

75
00:04:29,400 --> 00:04:33,400
પરંતુ તે કરી સાથે સમસ્યા શું છે?

76
00:04:33,400 --> 00:04:37,400
હું મેમરી છિદ્ર હોય છે, તેથી હું હવે આ સંખ્યા 3 વપરાશ નથી.

77
00:04:37,400 --> 00:04:42,480
તે સાથે આ સમસ્યા હું કે નોડ મુક્ત કરવાનો પ્રયત્ન નથી માંગવાનો છે.

78
00:04:42,480 --> 00:04:45,360
હું મેમરી છિદ્ર અને (દુર્બોધ) મને નફરત રહ્યું છે હોય જાઉં છું.

79
00:04:45,360 --> 00:04:49,370
તેથી તેના બદલે કે કરી ના, હું કદાચ કામચલાઉ નિર્દેશક હોવી જોઇએ.

80
00:04:49,370 --> 00:04:53,210
તેથી હું કામચલાઉ નોકર મૂકો. હું કાઢી નાખવા માંગો છો તે નોડ માટે નિર્દેશ રહ્યું છે.

81
00:04:53,210 --> 00:04:58,170
અને પછી હું બીજા ગાંઠ પર બિંદુ માટે અગાઉના ગાંઠો ખસેડી શકો છો

82
00:04:58,170 --> 00:05:00,390
હું કાઢી નાખવા માંગો છો નોડ.

83
00:05:00,390 --> 00:05:02,730
અને છેલ્લે, હું નિર્દેશક મુક્ત કરી શકો છો.

84
00:05:02,730 --> 00:05:07,480
હું અહિ બનાવવામાં કે નિર્દેશક મુક્ત કરવા માટે છે?

85
00:05:07,480 --> 00:05:09,560
હું માટે, માત્ર કારણ નથી -

86
00:05:09,560 --> 00:05:13,430
તફાવત આ નોડ malloc ઉપયોગ કરીને બનાવવામાં આવી હતી કે જે,

87
00:05:13,430 --> 00:05:17,280
આ એક માત્ર સ્ટેક માં NULL સ્વીચ તરીકે જાહેર કરવામાં આવી હતી જ્યારે તેથી તે ઢગલો માં છે.

88
00:05:17,280 --> 00:05:20,000
તેથી હું તેને મુક્ત કરવાની જરૂર નથી.

89
00:05:20,000 --> 00:05:22,030
>> ઠીક છે. તેથી હવે આપણે રન ટાઇમ સ્ટેકનું વિશે વાત કરો.

90
00:05:22,030 --> 00:05:24,680
રન ટાઇમ સ્ટેકનું ખૂબ સરળ છે.

91
00:05:24,680 --> 00:05:29,540
અમે હમણાં જ એરે મદદથી વર્ગ રન ટાઇમ સ્ટેકનું અને ક્યુને હતી,

92
00:05:29,540 --> 00:05:32,820
પરંતુ તમે પરિચિત હોવા જોઈએ - માત્ર ધ્યાન રાખો

93
00:05:32,820 --> 00:05:40,740
તમે પણ સંલગ્ન યાદીઓ મદદથી ક્યુને રન ટાઇમ સ્ટેકનું કરી શકો છો.

94
00:05:40,740 --> 00:05:44,460
તમે ઝાકઝમાળ છે તેથી જો, શું સ્ટેક હશે?

95
00:05:44,460 --> 00:05:46,810
એક સ્ટેક માટે, પ્રથમ, એક માપ હોય છે.

96
00:05:46,810 --> 00:05:49,950
તમારી પાસે અત્યારે છે કે સ્ટેક કદ શું સ્ટોર છે.

97
00:05:49,950 --> 00:05:52,980
અને પણ તમે નંબરો આ કિસ્સામાં, એક એરે હશે

98
00:05:52,980 --> 00:05:55,120
તમે ઇચ્છો તો, તે એક એરે હોઈ શકે છે

99
00:05:55,120 --> 00:06:00,380
શબ્દમાળાઓ, સ્ટ્રક્ટ ઝાકઝમાળ, તમે સંગ્રહવા માંગો છો જે કંઇ.

100
00:06:00,380 --> 00:06:03,240
સ્ટેક વિશે: એક સ્ટેક અને એક કડી થયેલ યાદી વચ્ચે તફાવત

101
00:06:03,240 --> 00:06:08,590
સ્ટેક માં તમે માત્ર સ્ટેક માં મૂકવામાં આવ્યું હતું કે છેલ્લા તત્વ વપરાશ હોય છે.

102
00:06:08,590 --> 00:06:11,770
તે પ્રથમ બહાર ગયા માં કહેવાય છે.

103
00:06:11,770 --> 00:06:15,090
તમે ટ્રે એક સ્ટેક હોય જેમ,

104
00:06:15,090 --> 00:06:17,670
તમે સ્ટેક ટોચ પર ટ્રે મૂકી,

105
00:06:17,670 --> 00:06:22,670
તમે અન્ય ટ્રે વપરાશ હોય છે કે પ્રથમ ટ્રે દૂર હોય છે.

106
00:06:22,670 --> 00:06:26,310
તે રન ટાઇમ સ્ટેકનું સાથે જ વાત છે.

107
00:06:26,310 --> 00:06:31,220
હું, ઉદાહરણ તરીકે, એક સ્ટેક એક તત્વ ઍડ કરવા માંગો છો તેથી જો, મારે શું કરવું જોઈએ?

108
00:06:31,220 --> 00:06:34,070
તે દબાણ કહેવાય છે, અને તે ખૂબ સરળ છે છે.

109
00:06:34,070 --> 00:06:37,130
તમારે શું કરવું છે પ્રથમ વસ્તુ ચેક જો સ્ટેક માપ

110
00:06:37,130 --> 00:06:40,150
વધારે અથવા સ્ટેક ક્ષમતા સમાન નથી.

111
00:06:40,150 --> 00:06:45,810
જો તમે પહેલાથી જ સંપૂર્ણ ક્ષમતા પર હોય છે, તો તમે જે કંઈપણ ઉમેરી શકતા નથી કારણ કે.

112
00:06:45,810 --> 00:06:51,140
જો નહિં, તો અને પછી, તમે માત્ર સ્ટેક માટે તત્વ ઉમેરી છે.

113
00:06:51,140 --> 00:06:54,530
અને છેલ્લે, કદ વધારો. તેથી તે ખૂબ સરળ છે.

114
00:06:54,530 --> 00:06:57,140
તેથી હું ફક્ત 2 નંબર ઉમેરો.

115
00:06:57,140 --> 00:07:00,350
હું પૉપ માંગો છો, જે હું દૂર કરવા માંગો છો કે જે થાય છે

116
00:07:00,350 --> 00:07:03,870
ઉમેર્યાં છે અને તત્વ ની કિંમત પાછી આવી હતી કે છેલ્લા તત્વ,

117
00:07:03,870 --> 00:07:09,180
હું ચકાસવા માટે છે પ્રથમ વસ્તુ સ્ટેક ખાલી નથી છે.

118
00:07:09,180 --> 00:07:11,510
જો તે ખાલી, હું કાંઇ પરત ન શકે છે.

119
00:07:11,510 --> 00:07:14,820
તે કિસ્સામાં, હું -1 પરત છું.

120
00:07:14,820 --> 00:07:18,960
નહિંતર, હું સ્પેક માપ હ્રાસ જાઉં છું,

121
00:07:18,960 --> 00:07:22,510
અને સંખ્યાઓ (s.size) આવો.

122
00:07:22,510 --> 00:07:27,230
શા માટે હું કદ હ્રાસ અને પછી s.size પાછા કરી?

123
00:07:27,230 --> 00:07:30,930
આ કિસ્સામાં, સ્પેક 4 કદ ધરાવે છે, કારણ કે તે છે

124
00:07:30,930 --> 00:07:33,810
અને હું ચોથા તત્વ પાછા માંગો છો, અધિકાર?

125
00:07:33,810 --> 00:07:36,030
પરંતુ ચોથા તત્વ ની અનુક્રમણિકા છે? ત્રણ.

126
00:07:36,030 --> 00:07:44,510
હું કદ નથી કારણ - 3 પ્રયત્ન રહ્યું છે, હું હમણાં જ (s.size) જ s.numbers પાછા આવી શકો છો

127
00:07:44,510 --> 00:07:48,410
તે 3 છે, કારણ કે. તેથી તે માત્ર ઇન્ડેક્સ છે.

128
00:07:48,410 --> 00:07:50,380
>> હવે ક્યુને. ક્યુને ખૂબ ખૂબ જ વસ્તુ છે.

129
00:07:50,380 --> 00:07:54,950
માત્ર એટલો જ તફાવત છે કે, તેના બદલે છેલ્લા માં કર્યા છે, પ્રથમ બહાર છે

130
00:07:54,950 --> 00:07:57,480
તમે પ્રથમ બહાર, પ્રથમ છે.

131
00:07:57,480 --> 00:07:59,460
તમે એક કોન્સર્ટ પર જાઓ રાહ જોઈ રહ્યાં છો કદાચ હોય,

132
00:07:59,460 --> 00:08:04,260
તમે તેના બદલે એક કતાર એક સ્ટેક હોય તો તમે ખુશ નથી.

133
00:08:04,260 --> 00:08:07,730
આવો છેલ્લા વ્યક્તિ છે કોન્સર્ટ દાખલ કરવા માટે પ્રથમ વ્યક્તિ છે.

134
00:08:07,730 --> 00:08:09,760
તમે કદાચ ખુશ ન કરી શકે.

135
00:08:09,760 --> 00:08:15,020
કતાર માં, વિચાર પ્રથમ વ્યક્તિ પણ નીકળી જાય છે પ્રથમ વ્યક્તિ છે.

136
00:08:15,020 --> 00:08:18,720
તેથી કતાર વ્યાખ્યા માં, એરે માપ કર્યા ઉપરાંત,

137
00:08:18,720 --> 00:08:23,360
તમે પણ સ્ટેક વડા માટે ઇન્ડેક્સ છે કે જે વડા હોય છે.

138
00:08:23,360 --> 00:08:29,000
હમણાં પ્રથમ તત્વ છે.

139
00:08:29,000 --> 00:08:32,710
એન્ક્યૂ રન ટાઇમ સ્ટેકનું માટે દબાણ જેવા જ વસ્તુ છે.

140
00:08:32,710 --> 00:08:34,980
તમે ખૂબ જ સરળ હોય, તો તમે માત્ર કહે છે,

141
00:08:34,980 --> 00:08:39,289
હું દબાણ માટે કર્યું સાથે સાથે, હું હમણાં જ બરાબર આ જ વાત કરી શકો છો.

142
00:08:39,289 --> 00:08:44,030
તે ક્ષમતા બહાર નથી, જો હું માત્ર તપાસી શકો છો.

143
00:08:44,030 --> 00:08:48,760
તે છે, હું તો હું માત્ર નવી કિંમત નિકાસ કરી શકો છો, ખોટા પાછા

144
00:08:48,760 --> 00:08:50,630
અને પછી કદ વધારો.

145
00:08:50,630 --> 00:08:52,750
પરંતુ આ શા માટે ખોટું છે?

146
00:08:52,750 --> 00:08:55,010
ચાલો આ ઉદાહરણ જોઈએ.

147
00:08:55,010 --> 00:08:57,020
હું સામગ્રી સમૂહ એન્ક્યૂ કરવાનો પ્રયાસ કરી રહ્યો છું,

148
00:08:57,020 --> 00:08:58,390
અને પછી હું dequeue અને એન્ક્યૂ કરવા જઇ રહ્યો છું.

149
00:08:58,390 --> 00:09:00,550
ત્યાં આદેશો ઘણો છે, પણ તે ખૂબ જ સરળ છે.

150
00:09:00,550 --> 00:09:04,790
હું 5 એન્ક્યૂ, જેથી 5 ઉમેરવા રહ્યું છે, અને પછી 7, છું

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, અને પછી હું કંઈક dequeue માંગો છો,

152
00:09:09,310 --> 00:09:12,000
જે હું પ્રથમ તત્વ દૂર જઈ રહ્યો છું છે.

153
00:09:12,000 --> 00:09:14,640
તેથી હું અધિકાર સંખ્યા 3 દૂર કરવા માટે જઈ રહ્યો છું?

154
00:09:14,640 --> 00:09:17,320
પ્રથમ તત્વ. ઠીક છે.

155
00:09:17,320 --> 00:09:21,450
હું કંઈક બીજું એન્ક્યૂ પ્રયાસ કરો હવે, શું થવાનું છે?

156
00:09:21,450 --> 00:09:24,290
મારા અમલીકરણ અનુસાર,

157
00:09:24,290 --> 00:09:31,040
હું ઇન્ડેક્સ q.size આગામી નંબર મૂકી રહ્યા હતા.

158
00:09:31,040 --> 00:09:35,140
આ કિસ્સામાં, માપ 8 છે,

159
00:09:35,140 --> 00:09:38,640
જેથી અનુક્રમણિકા 8 છેલ્લા સ્થિતિમાં અહીં હશે.

160
00:09:38,640 --> 00:09:43,900
હું અહીં 1 એન્ક્યૂ પ્રયાસ કરો, હું છેલ્લા સ્થિતિ પર ફરીથી લખી આવશે

161
00:09:43,900 --> 00:09:45,870
સંપૂર્ણપણે ખોટું છે કે જે નંબર 1, છે.

162
00:09:45,870 --> 00:09:49,870
હું શું કરવા માંગો છો ફરતે વીંટળાય છે અને પ્રથમ સ્થાન પર જાઓ છે.

163
00:09:49,870 --> 00:09:52,870
કદાચ તમે હમણાં જ સાથે સાથે, હું માત્ર તપાસો, કહે છે

164
00:09:52,870 --> 00:09:55,600
હું ત્યાં ખરેખર કંઈક મૂકી શકે છે.

165
00:09:55,600 --> 00:09:58,560
જો નહિં, તો હું માત્ર ઓહ, નવા સંપૂર્ણ ક્ષમતા કહે છે,

166
00:09:58,560 --> 00:10:02,010
ખરેખર ક્ષમતા છે - 1, અને તમે ત્યાં એક તત્વ મૂકી શકો છો.

167
00:10:02,010 --> 00:10:06,150
પરંતુ સમસ્યા શું છે? સમસ્યા એ છે કે હું માત્ર અહીં બધું dequeue જો

168
00:10:06,150 --> 00:10:08,240
અને પછી હું કંઈક બીજું ઉમેરો પ્રયાસ કરો, તે માત્ર કહે છે,

169
00:10:08,240 --> 00:10:11,210
સાથે સાથે, તમે 0 છે જે સંપૂર્ણ ક્ષમતા, હતા.

170
00:10:11,210 --> 00:10:13,620
તેથી તમારા કતાર ગઇ છે.

171
00:10:13,620 --> 00:10:16,990
તમે ફરતે વીંટળાય છે, અને આસપાસ રેપિંગ એક માર્ગ

172
00:10:16,990 --> 00:10:22,040
તમે સ્વપ્નદ્રષ્ટા અને અન્ય psets શિક્ષિત ગાય્સ મોડ મદદથી કરવામાં આવી હતી.

173
00:10:22,040 --> 00:10:29,090
તમે q.size + + q.head શું કરશે સમજવા માટે શા માટે ઘરે પ્રયાસ કરી શકો છો

174
00:10:29,090 --> 00:10:31,080
મોડ ક્ષમતા છે, પણ તમે અહીં તપાસો છો,

175
00:10:31,080 --> 00:10:34,760
અમે તે કામ કરે છે કે નહીં તે જોવા કરી શકો છો.

176
00:10:34,760 --> 00:10:37,760
જેથી છેલ્લા ઉદાહરણમાં, q.size 8 હતું

177
00:10:37,760 --> 00:10:47,590
તે અહીં એરે આ સ્થિતિ હતી કારણ કે વડા, 1 હતી.

178
00:10:47,590 --> 00:10:51,970
તેથી તે 1 + 8 9 હશે. ફેરફારની ક્ષમતા 9 0 રહેશે.

179
00:10:51,970 --> 00:10:56,640
તે ઇન્ડેક્સ 0 જશે. અમે સાચી સ્થિતિમાં હશો.

180
00:10:56,640 --> 00:10:59,750
અને પછી ઘરે કતાર પ્રયાસ કરો.

181
00:10:59,750 --> 00:11:04,950
કેટલાક મહત્વપૂર્ણ વસ્તુઓ: એક સ્ટેક અને કતાર વચ્ચે તફાવત સમજી પ્રયાસ કરો.

182
00:11:04,950 --> 00:11:11,620
ઘર પર, એન્ક્યૂ, dequeue દબાણ, અને પોપ અમલીકરણ સાથે ખૂબ જ પરિચિત વિચાર કરવાનો પ્રયાસ કરો.

183
00:11:11,620 --> 00:11:16,560
તમે તેમને દરેક ઉપયોગ કરશે અને જ્યારે પણ સમજે છે.

184
00:11:16,560 --> 00:11:22,830
>> તેથી આપણે Pokemons સમૂહ સાથે 10 સેકન્ડ માટે આરામ.

185
00:11:22,830 --> 00:11:26,080
અને હવે પાછા માહિતી માળખાં માટે જાઓ.

186
00:11:26,080 --> 00:11:29,770
કોષ્ટકો હેશ. ઘણા લોકો હેશ કોષ્ટકો ભયભીત હતા.

187
00:11:29,770 --> 00:11:33,650
સમસ્યા 6 સેટ માં, જોડણી તપાસનાર.

188
00:11:33,650 --> 00:11:35,980
હેશ કોષ્ટકો અને પ્રયત્નોમાં, ઘણા લોકોને તેમાંથી ભયભીત છે.

189
00:11:35,980 --> 00:11:38,540
તેઓ તે સમજવા માટે કે જેથી મુશ્કેલ છો. અરે વાહ?

190
00:11:38,540 --> 00:11:41,490
[રોબ બોડેન] સમસ્યા 5 સુયોજિત કરો. >> સમસ્યા હા, 5 સુયોજિત કરો. આભાર રોબ.

191
00:11:41,490 --> 00:11:43,370
અરે વાહ. છ મિજાજ એન 'દોડ્યા પછી એકદમ હાંફવું, હા હતી.

192
00:11:43,370 --> 00:11:49,340
સમસ્યા જોડણી તપાસનાર હતી 5 સુયોજિત કરો, અને તમે હેશ કોષ્ટક અથવા એક પ્રયાસ ક્યાં વાપરવા માટે હતી.

193
00:11:49,340 --> 00:11:55,360
ઘણા લોકો તે સમજવામાં સુપર હાર્ડ હતા, પરંતુ તેઓ વાસ્તવમાં ખૂબ સરળ છો.

194
00:11:55,360 --> 00:12:01,290
હેશ કોષ્ટક મૂળભૂત રીતે, શું છે? એક હેશ કોષ્ટક સાથે લિંક યાદીઓ ઝાકઝમાળ છે.

195
00:12:01,290 --> 00:12:06,730
ઝાકઝમાળ અને હેશ ટેબલ વચ્ચે માત્ર એટલો જ તફાવત

196
00:12:06,730 --> 00:12:09,730
હેશ કોષ્ટકમાં તમે હેશ વિધેય કહેવાય છે તેની હોય છે.

197
00:12:09,730 --> 00:12:12,080
હેશ વિધેય શું છે?

198
00:12:12,080 --> 00:12:13,970
તમે ગાય્સ અહીં વાંચી શકો છો જો મને ખબર નથી.

199
00:12:13,970 --> 00:12:16,090
આ હેશ કોષ્ટક એક ઉદાહરણ છે.

200
00:12:16,090 --> 00:12:19,220
તેથી જો તમે 31 તત્વો સાથે ઝાકઝમાળ છે જોઈ શકે છે.

201
00:12:19,220 --> 00:12:22,440
અને શું અમે હેશ કોષ્ટકમાં શું હેશ વિધેય હોય છે

202
00:12:22,440 --> 00:12:26,660
કે કી અનુવાદ રહ્યું છે, દરેક ઇન્ડેક્સ ઈન્.

203
00:12:26,660 --> 00:12:31,740
જો, ઉદાહરણ તરીકે, હું બી હેરિસન માટે પસંદ કરો માંગો છો,

204
00:12:31,740 --> 00:12:34,190
હું મારા જટિલ કાર્ય માં બી હેરિસન મૂકવામાં આવશે,

205
00:12:34,190 --> 00:12:36,960
અને હેશ વિધેય 24 પરત ફરશે.

206
00:12:36,960 --> 00:12:40,930
તેથી હું 24 માં બી હેરિસન સંગ્રહવા માંગો છો.

207
00:12:40,930 --> 00:12:46,580
જેથી માત્ર ઝાકઝમાળ હોય અને હેશ ટેબલ કર્યા વચ્ચે તફાવત છે.

208
00:12:46,580 --> 00:12:48,740
હેશ કોષ્ટકમાં તમે તમને કહી રહ્યું છે કે એક કાર્ય પડશે

209
00:12:48,740 --> 00:12:54,740
જ્યાં તમે સંગ્રહ કરવા માંગો છો તે ડેટા સ્ટોર કરવા.

210
00:12:54,740 --> 00:12:57,040
હેશ વિધેય માટે, તમે હેશ વિધેય જોવા માટે કરવા માંગો છો

211
00:12:57,040 --> 00:13:00,600
કે નિર્ધારિત અને સારી રીતે વિતરણ થાય છે.

212
00:13:00,600 --> 00:13:07,810
તમે અહીં જોઈ શકો છો, તમે મને સ્ટોર માગે છે, માહિતી ઘણો ખરેખર 19 હતી કે જુઓ

213
00:13:07,810 --> 00:13:12,470
તેના બદલે બધા મુક્ત હતા જે 31 અને 30 અને 29, ઉપયોગ.

214
00:13:12,470 --> 00:13:16,920
તેથી કે હું ઉપયોગ હેશ વિધેય ખૂબ જ સારી રીતે વિતરણ ન હતી.

215
00:13:16,920 --> 00:13:20,710
અમે સારી રીતે વિતરણ કહે છે, તે, અમે માંગો છો કે જે થાય છે

216
00:13:20,710 --> 00:13:26,520
આશરે ઓછામાં ઓછા 1 અથવા દરેક માટે 2 -

217
00:13:26,520 --> 00:13:32,190
જેમ, એરે માં સૂચકાંકો દરેક માટે 1 અથવા 2 તફાવત.

218
00:13:32,190 --> 00:13:43,950
તમે આશરે, એરે દરેક કડી થયેલ યાદીમાં તત્વો જ નંબર છે કરવા માંગો છો.

219
00:13:43,950 --> 00:13:48,600
અને તે તે હેશ કોષ્ટકમાં માન્ય છે હેશ કોષ્ટકો તરીકે જોવા તે ચકાસવા માટે સરળ છે.

220
00:13:48,600 --> 00:13:51,770
>> પછી વૃક્ષો. આ એક વૃક્ષ છે.

221
00:13:51,770 --> 00:13:56,400
કોમ્પ્યુટર વિજ્ઞાન વૃક્ષો કેટલાક કારણોસર નીચે ઊંધો છે.

222
00:13:56,400 --> 00:14:00,150
તેથી અહીં તમે વૃક્ષના રુટ અને પછી પાંદડા છે.

223
00:14:00,150 --> 00:14:05,630
તમે હમણાં જ માબાપ અને બાળક માટે નામકરણ ખબર હોવી જોઇએ.

224
00:14:05,630 --> 00:14:12,880
દરેક નોડને પિતૃ નીચે છે કે ગાંઠો છે, જે તેના બાળકો છે.

225
00:14:12,880 --> 00:14:19,660
તેથી, ઉદાહરણ તરીકે, 2, અહિ 3 અને અન્ય બાળક માટે પિતૃ કરી રહ્યું છે

226
00:14:19,660 --> 00:14:25,290
3 1 માટે પિતૃ અને કે ત્યાં બીજા બાળકો પ્રયત્ન રહ્યું છે છે.

227
00:14:25,290 --> 00:14:29,990
અને 1 તેથી 3 બાળક પ્રયત્ન રહ્યું છે, અને છે.

228
00:14:29,990 --> 00:14:34,610
અમે વધુ રસપ્રદ કંઈક, દ્વિસંગી શોધ વૃક્ષ કહેવાય છે

229
00:14:34,610 --> 00:14:39,040
જેમાં એક નોડ જમણી પર બધી કિંમતો

230
00:14:39,040 --> 00:14:41,660
અહીં, જમણી બાજુ પર હશે આવે છે - જમણે,

231
00:14:41,660 --> 00:14:46,780
રુટ માં તત્વ કરતા વધારે હશે આવે છે.

232
00:14:46,780 --> 00:14:49,780
જમણે તેથી હું અહીં 5 નંબર છે, બધા તત્વો

233
00:14:49,780 --> 00:14:51,940
5 કરતા વધારે જ હશે, અને ડાબી બાજુએ છે

234
00:14:51,940 --> 00:14:56,770
તમામ તત્વો 5 કરતાં ઓછી હોવી જવું છે.

235
00:14:56,770 --> 00:14:58,780
શા માટે આ ઉપયોગી છે?

236
00:14:58,780 --> 00:15:01,660
ઠીક છે, હું 7 નંબર અહીં છે તે ચકાસવા માટે કરવા માંગો છો, ઉદાહરણ તરીકે,

237
00:15:01,660 --> 00:15:05,960
હું માત્ર પ્રથમ 5 પર જાઓ અને હું જોવા માટે જાઉં છું, 5 કરતાં 7 વધારે અથવા ઓછા છે?

238
00:15:05,960 --> 00:15:09,540
તે વધારે છે, તેથી હું તેને વૃક્ષ અધિકાર પર હોય છે બનશે છો.

239
00:15:09,540 --> 00:15:13,980
તેથી હું જોવા માટે ઘણી ઓછી સામગ્રી છે.

240
00:15:13,980 --> 00:15:19,520
એક દ્વિસંગી શોધ વૃક્ષ, નોડ અમલીકરણમાં, હું હમણાં જ માહિતી હોય છે જાઉં છું

241
00:15:19,520 --> 00:15:21,750
તેથી પૂર્ણાંક n એ, તમે પણ શબ્દમાળા હોઇ શકે છે

242
00:15:21,750 --> 00:15:23,630
અથવા તમે ઇચ્છતા કંઈપણ.

243
00:15:23,630 --> 00:15:28,100
તમારે માત્ર વ્યાખ્યાયિત શું વધારે છે પર કાળજી હોય છે, ઓછી છે.

244
00:15:28,100 --> 00:15:30,390
તેથી જો તમે શબ્દમાળાઓ હતો, ઉદાહરણ તરીકે, તમે વ્યાખ્યાયિત કરી શકે છે

245
00:15:30,390 --> 00:15:34,690
જમણી બાજુ પર તે તમામ બાબતો મોટા લંબાઈ હોય જવું છે કે,

246
00:15:34,690 --> 00:15:40,940
ડાબી ઓછી લંબાઈ હોય જવું છે, તેથી તે તમે નક્કી કરો ખરેખર છે.

247
00:15:40,940 --> 00:15:44,930
>> કેવી રીતે હું BST માટે અમલ કરી શકે છે?

248
00:15:44,930 --> 00:15:47,840
અમે હોય તો પડશે પ્રથમ વસ્તુ રુટ નલ છે તે ચકાસવા છે.

249
00:15:47,840 --> 00:15:50,920
તે NULL છે, તો તે વસ્તુ નથી કે જે થાય છે

250
00:15:50,920 --> 00:15:53,330
તમે પણ એક વૃક્ષ, અધિકાર નથી કારણ કે?

251
00:15:53,330 --> 00:15:55,790
તેથી હું ખોટી આવો.

252
00:15:55,790 --> 00:15:58,740
નહિં તો, હું નંબર વધારે છે તે ચકાસવા માટે જાઉં છું

253
00:15:58,740 --> 00:16:01,720
રુટ કિંમત કરતાં.

254
00:16:01,720 --> 00:16:04,250
હું અધિકાર પર તત્વ શોધવા પ્રયાસ જાઉં છું

255
00:16:04,250 --> 00:16:08,590
વૃક્ષ.

256
00:16:08,590 --> 00:16:11,310
તમે મને અહીં રિકર્ઝન ઉપયોગ કરું છું, કે જુઓ.

257
00:16:11,310 --> 00:16:14,150
જો તે ઓછું છે અને પછી, હું ડાબી જોવા જાઉં છું.

258
00:16:14,150 --> 00:16:18,330
અને છેલ્લે, નહિં તો, તે વધારે ઓછી નથી અથવા નથી જો,

259
00:16:18,330 --> 00:16:20,660
તે તે કિંમત પોતે છે છે.

260
00:16:20,660 --> 00:16:23,010
તેથી હું ફક્ત સાચું આવો.

261
00:16:23,010 --> 00:16:26,360
તમે મને તો તો જો ઉપયોગ અહીં જોઈ શકો છો.

262
00:16:26,360 --> 00:16:30,820
અને યાદ રાખો, 0 ક્વિઝ માં, અમે, જો જો, જો હતું કે સમસ્યા હતી

263
00:16:30,820 --> 00:16:32,780
અને તમે બિનકાર્યક્ષમતા શોધવા માનવામાં આવ્યા હતા,

264
00:16:32,780 --> 00:16:35,180
અને બિનકાર્યક્ષમતા જો તમે ઉપયોગ હતી.

265
00:16:35,180 --> 00:16:39,060
તમે જો બીજું, જો બીજું, જો વપરાય છે, અને બીજું છે કરીશું.

266
00:16:39,060 --> 00:16:44,240
અને જો બીજા અને જો બીજા અહીં તેથી, હું બીજું ઉપયોગ કરવો જોઇએ?

267
00:16:44,240 --> 00:16:46,200
શું કોઈને પણ - હા?

268
00:16:46,200 --> 00:16:51,140
[વિદ્યાર્થી બોલવા, અશ્રાવ્ય]

269
00:16:51,140 --> 00:16:53,480
તે યોગ્ય છે. તેથી તે, તે તો કોઈ વાંધો નથી કે કહેતા છે

270
00:16:53,480 --> 00:16:55,930
માત્ર કારણ કે અમે પહેલાં કે બિનકાર્યક્ષમતા

271
00:16:55,930 --> 00:16:59,550
હતું કે, કેટલાક સ્થિતિ સંતોષ હતો કદાચ, તો કારણ

272
00:16:59,550 --> 00:17:03,570
જેથી તમે એક ક્રિયા કરવામાં આવી છે, પરંતુ તે પછી તમે અન્ય શરતો તમામ તપાસ ચાલી રહ્યું હતું.

273
00:17:03,570 --> 00:17:06,319
પરંતુ આ કિસ્સામાં, તે સીધા જ પરત તેથી તે તો કોઈ વાંધો નથી.

274
00:17:06,319 --> 00:17:09,220
જેથી તમે જો બીજા ઉપયોગ નથી.

275
00:17:09,220 --> 00:17:11,740
>> અને છેલ્લે, ચાલો પ્રયત્નોમાં વિશે વાત કરો,

276
00:17:11,740 --> 00:17:13,800
જે દરેકના પ્રિય છે.

277
00:17:13,800 --> 00:17:15,980
એક પ્રયાસ એરે એક વૃક્ષ છે.

278
00:17:15,980 --> 00:17:20,369
તે કિંમતો જોવા ખૂબ જ ઝડપી છે, પરંતુ તે મેમરીની જરુર ઉપયોગ કરે છે.

279
00:17:20,369 --> 00:17:22,530
અને તે શબ્દો ફિલ્ટર કરવા માટે સામાન્ય રીતે છે, તેથી જ્યારે તમે

280
00:17:22,530 --> 00:17:27,920
તમારા ફોનમાં એક ફોન પુસ્તક જેવી છે, ઉદાહરણ તરીકે, મને ખબર નથી, અમલ કરવા માંગો છો

281
00:17:27,920 --> 00:17:30,440
અને તમે બી લખો કરવાનો પ્રયત્ન કરવા માંગો છો

282
00:17:30,440 --> 00:17:32,510
અને માત્ર બી જેઓ પાસે નામો હોય છે

283
00:17:32,510 --> 00:17:37,960
તે ઉદાહરણ તરીકે, એક પ્રયાસ ઉપયોગ કરીને તે અમલ ખૂબ જ સરળ છે.

284
00:17:37,960 --> 00:17:39,820
તમે કેવી રીતે એક પ્રયાસ માં નોડ વ્યાખ્યાયિત કરી શકું?

285
00:17:39,820 --> 00:17:43,910
તમે માત્ર is_word પ્રયત્ન રહ્યું છે એક bool હોય છે.

286
00:17:43,910 --> 00:17:48,660
એટલે કે, કે નોડ પહેલાં તમામ અક્ષરોનો ઉપયોગ કરીને કે રજૂ કરે છે

287
00:17:48,660 --> 00:17:51,920
તમે એક શબ્દ રચના કરવામાં સમર્થ હતા,

288
00:17:51,920 --> 00:17:57,230
અને પછી તમે ગાંઠો પોઇંટરો ઝાકઝમાળ પડશે.

289
00:17:57,230 --> 00:18:03,120
જો અમે એક પિતૃ ગાંઠો અરે, જેથી નોડ * એરે હોય છે કે જોઈ શકો છો? અરે વાહ?

290
00:18:03,120 --> 00:18:06,050
તેથી આપણે તે કામ કેવી રીતે થશે તે જોવા દો. આ જોડણી તપાસ માટે,

291
00:18:06,050 --> 00:18:08,230
અમે 27 તત્વો ઝાકઝમાળ છે,

292
00:18:08,230 --> 00:18:12,150
અમે બધા જ પત્રો ઉપરાંત એપોસ્ટ્રોફી ધરાવતા હોય છે.

293
00:18:12,150 --> 00:18:17,800
હું બોર્ડ પર લખી કરવાનો પ્રયત્ન કરવા માંગો છો, કારણ કે અહીં તે પહેલાં હું માત્ર 2 ઉપયોગ જાઉં છું.

294
00:18:17,800 --> 00:18:20,230
ઠીક છે. તેથી આ એક પ્રયાસ કરો એક ઉદાહરણ છે.

295
00:18:20,230 --> 00:18:25,600
હું માત્ર પ્રથમ નોડ વ્યાખ્યાયિત, હું 2 તત્વો ઝાકઝમાળ પડશે

296
00:18:25,600 --> 00:18:29,290
નલ 2 પોઇન્ટર છે, તેથી હું માત્ર 'એ' અને 'બી' મૂકી છે.

297
00:18:29,290 --> 00:18:32,430
અને હું is_word કહે છે કે એક bool હોય જાઉં છું.

298
00:18:32,430 --> 00:18:34,420
તે પ્રથમ એક માટે ખોટા જ હશે,

299
00:18:34,420 --> 00:18:37,370
માત્ર કારણ કે, તે પહેલાં તમે કોઈપણ અક્ષરો નથી.

300
00:18:37,370 --> 00:18:40,900
તેથી એક ખાલી શબ્દ શબ્દ નથી. તેથી તે ખોટી છે.

301
00:18:40,900 --> 00:18:46,320
હું આ શબ્દકોશમાં 'એ' ઉમેરવા માંગો છો, હું શું હશે?

302
00:18:46,320 --> 00:18:49,760
હું માત્ર 'એ' માટે નવી નોડ malloc હોવી જોઈએ,

303
00:18:49,760 --> 00:18:54,630
અને પછી તેની શબ્દ સાચું ઉમેરો.

304
00:18:54,630 --> 00:19:00,180
તેથી તે માત્ર 'એ' વાત સાચી છે રહ્યું છે એવું કે રજૂ કરે છે. અર્થમાં બનાવવા?

305
00:19:00,180 --> 00:19:04,120
હું 'બા' ઉમેરવા માંગો છો અને પછી, હું 'બી' માટે 1 malloc માટે પડશે,

306
00:19:04,120 --> 00:19:07,550
અને પછી હું ખોટા માટે બુલિયન સુયોજિત જાઉં છું

307
00:19:07,550 --> 00:19:10,160
પોતે દ્વારા 'બી' ને એક શબ્દ નથી.

308
00:19:10,160 --> 00:19:13,010
પછી હું બીજા 'એ' માટે એક, તેથી 'બા' malloc જાઉં છું,

309
00:19:13,010 --> 00:19:16,290
અને પછી હું તેને ખરા તરીકે એક શબ્દ છે સુયોજિત કરવા માટે જઈ રહ્યો છું.

310
00:19:16,290 --> 00:19:18,950
'બા' શબ્દ છે.

311
00:19:18,950 --> 00:19:21,910
હું જોવા માંગો છો તો પછી 'બી' આ શબ્દકોશ થયેલ છે કે નહિં

312
00:19:21,910 --> 00:19:26,730
હું માત્ર પ્રથમ એક, 'બી' માટે જઈ શકે છે. હું નીચે જાય છે, અને હું શબ્દ છે જોવા, અને તે ખોટા છે.

313
00:19:26,730 --> 00:19:30,110
તેથી તે એક શબ્દ નથી. હું 'બા' તપાસ કરવા માંગો છો,

314
00:19:30,110 --> 00:19:38,010
હું પ્રથમ એક, 'બી' પર જાઓ, અને પછી 'એ' પર જાઓ, અને હું સાચું જુઓ, જેથી તે એક શબ્દ છે. અર્થમાં બનાવવા?

315
00:19:38,010 --> 00:19:41,950
ઘણા લોકો પ્રયત્નોમાં દ્વારા ગુંચવણ છે. કોઈ?

316
00:19:41,950 --> 00:19:44,740
>> છેલ્લે, હફમેનના કોડિંગ. હફમેનના કોડિંગ ખૂબ ઉપયોગી છે

317
00:19:44,740 --> 00:19:47,550
મેમરી સાચવો અને લખાણ ફાઈલો સંકુચિત,

318
00:19:47,550 --> 00:19:52,270
માત્ર કારણ કે તમે ઉદાહરણ તરીકે, 'એ' અને 'ઈ' ઉપયોગ વખત ઘણો,

319
00:19:52,270 --> 00:19:57,710
તમે ગાય્સ ખૂબ 'સ' અથવા 'ઝેડ' વાપરો તો તમારા દસ્તાવેજો છે, પરંતુ મને ખબર નથી.

320
00:19:57,710 --> 00:20:02,040
દરેક એક પાત્ર માટે માત્ર 1 બાઇટ કર્યા,

321
00:20:02,040 --> 00:20:08,520
દરેક એક - અમે તે ASCII કોષ્ટકમાં છે કે 256 અક્ષરો ખૂબ જ સ્પષ્ટ નથી,

322
00:20:08,520 --> 00:20:11,410
તમે વધુ ઉપયોગ કરે છે કેટલાક અક્ષરો છે માત્ર કારણ કે,

323
00:20:11,410 --> 00:20:15,180
તેથી તમે કદાચ તે માટે ઓછી મેમરીનો ઉપયોગ કરીશું.

324
00:20:15,180 --> 00:20:17,560
હું કેવી રીતે હફમેનના કોડિંગ ઉપયોગ કરી શકું?

325
00:20:17,560 --> 00:20:20,010
અમે હફમેનના વૃક્ષ કરો.

326
00:20:20,010 --> 00:20:23,370
 એક હફમેનના વૃક્ષ ગાંઠો છે

327
00:20:23,370 --> 00:20:27,760
આ પત્ર, 'સી', 'બી', 'એ', જેવી હોઈ ચાલે છે કે પ્રતીક છે,

328
00:20:27,760 --> 00:20:32,990
તમારી પાસે ગમે અક્ષર, શબ્દ લખાણ દેખાય છે કે આવૃત્તિ છે કે જે આવૃત્તિ,

329
00:20:32,990 --> 00:20:36,280
તમે માટે હફમેનના વૃક્ષ બનાવવા હતી કે

330
00:20:36,280 --> 00:20:41,800
અને પછી હફમેનના વૃક્ષ ડાબી નિર્દેશ રહ્યું છે નોડ

331
00:20:41,800 --> 00:20:47,210
અને જમણી નિર્દેશ રહ્યું છે કે અન્ય નોડ. તેથી માત્ર એક વૃક્ષ ગમે છે.

332
00:20:47,210 --> 00:20:49,440
તમે કેવી રીતે એક હફમેનના વૃક્ષ બીલ્ડ કરી શકું?

333
00:20:49,440 --> 00:20:54,020
તમે નીચા આવર્તનના છે કે 2 ગાંઠો બનાવ્યો રહ્યા છીએ.

334
00:20:54,020 --> 00:20:56,490
તમે ટાઇ હોય તો તમે 2 ગાંઠો બનાવ્યો જઈ રહ્યાં છો

335
00:20:56,490 --> 00:20:59,870
પણ સૌથી ઓછી ASCII કિંમતો છે.

336
00:20:59,870 --> 00:21:02,420
પછી તમે તે 2 ગાંઠો એક નવી વૃક્ષ બનાવવા જઈ રહ્યાં છો

337
00:21:02,420 --> 00:21:08,030
કે પિતૃ નોડ માં સંયુક્ત આવૃત્તિ હોય રહ્યું છે.

338
00:21:08,030 --> 00:21:13,240
અને પછી તમે જંગલ ના 2 બાળકો દૂર જઈ રહ્યાં છો

339
00:21:13,240 --> 00:21:15,570
અને પિતૃ સાથે બદલો.

340
00:21:15,570 --> 00:21:18,930
અને જો તમે તમે માત્ર વન માં 1 વૃક્ષ હોય છે ત્યાં સુધી કે પુનરાવર્તન રહ્યા છીએ.

341
00:21:18,930 --> 00:21:23,840
તેથી આપણે તમે ZAMYLA માટે હફમેનના વૃક્ષ શું કરશે તે જોવા દો.

342
00:21:23,840 --> 00:21:29,220
તમે બધા અક્ષરો 'એ' માટે સિવાય 1 આવર્તન ધરાવે છે અહીં જોઈ શકો છો; આવૃત્તિ 2 છે.

343
00:21:29,220 --> 00:21:34,090
તેથી હું તે ASCII કિંમત અને વારંવાર ક્રમમાં મૂકવામાં બધા અક્ષરો માટે ગાંઠો બનાવી.

344
00:21:34,090 --> 00:21:40,090
હું પ્રથમ વૃક્ષ બનાવવા માંગો છો, તો તે 'એલ' અને 'એમ' સાથે થશે.

345
00:21:40,090 --> 00:21:43,100
તેથી તે અહીં છે. આ જોડી ની આવૃત્તિ 2 હશે

346
00:21:43,100 --> 00:21:49,470
તે 1 + 1 છે, કારણ કે પછી નીચા આવર્તનના સાથે આગામી 2 'વાય' અને 'ઝેડ' છે.

347
00:21:49,470 --> 00:21:53,180
2 ની આવૃત્તિ છે - અને પછી હું છે તે બધા છે.

348
00:21:53,180 --> 00:22:00,470
જેથી આગામી એક માટે સૌથી ઓછી ASCII કિંમત છે તે જ કયુ છે?

349
00:22:00,470 --> 00:22:04,830
'એ' અને 'એલ'. તેથી હું નવા નોડ બનાવવા માટે,

350
00:22:04,830 --> 00:22:09,930
અને અંતે, તે 4 અને 2 છે, જેથી 2 ડાબી પર હોવા રહ્યું છે.

351
00:22:09,930 --> 00:22:12,430
અને આ હફમેનના વૃક્ષ છે.

352
00:22:12,430 --> 00:22:16,060
હું કેટલાક લખાણ લખવા માંગો છો પછી જો,

353
00:22:16,060 --> 00:22:24,440
જેમ હફમેનના વૃક્ષ મદદથી, લખાણ રૂપાંતરિત દ્વિસંગી ખૂબ જ સરળ છે.

354
00:22:24,440 --> 00:22:30,220
હું ડાબી તરફ સ્થળાંતર ના 0 અને જમણી તરફ સ્થળાંતર કહે છે કે ઉદાહરણ તરીકે, જો, એક 1 છે

355
00:22:30,220 --> 00:22:32,410
શું પ્રતિનિધિત્વ કરવાના છે?

356
00:22:32,410 --> 00:22:35,530
તેથી જેમ 1, 1, હક છે, તેથી અધિકાર

357
00:22:35,530 --> 00:22:40,370
અને પછી જેથી બાકી 0, એલ, અને કરશે તો પછી 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
તેથી 1, 0, તેથી માત્ર 1, 0, 'એ'.

359
00:22:43,950 --> 00:22:47,540
અને પછી 0, 1, તેથી 'ઝેડ'.

360
00:22:47,540 --> 00:22:52,170
અને પછી 1, 0, 0 - નં.

361
00:22:52,170 --> 00:22:56,780
0, 0 'વાય' હોઇ શકે છે, તેથી સુસ્ત છે.

362
00:22:56,780 --> 00:23:06,060
તેથી તે મારા માટે બધા છે, રોબ પર લઇ રહ્યું.

363
00:23:06,060 --> 00:23:08,400
>> [રોબ બોડેન] તેથી, સપ્તાહ 7 સામગ્રી.

364
00:23:08,400 --> 00:23:11,390
અમે ખરેખર ઝડપી પર જાઓ ઘણો મેળવ્યા છે.

365
00:23:11,390 --> 00:23:13,430
Bitwise ઓપરેટર્સ, બફર ઓવરફ્લો,

366
00:23:13,430 --> 00:23:16,760
CS50 પુસ્તકાલય, પછી એચટીએમએલ, HTTP, સીએસએસ.

367
00:23:16,760 --> 00:23:20,990
15 થી 20 મિનિટ જેવા બધા માં.

368
00:23:20,990 --> 00:23:24,330
Bitwise ઓપરેટર્સ. તમે જાણવા જરૂર છે કે જે તેમને 6 છે.

369
00:23:24,330 --> 00:23:31,200
Bitwise અને bitwise અથવા, XOR, ડાબી પાળી, જમણી પાળી, અને નથી.

370
00:23:31,200 --> 00:23:35,420
જમણી Shift અને તમે માત્ર બધા વ્યાખ્યાન જોઈ.

371
00:23:35,420 --> 00:23:40,480
અમે તેના પર ઝડપથી અહીં જાઓ, પડશે, પરંતુ તે આ અસ્તિત્વમાં છે કે જે 6 છે ખબર છે કે સારી છે.

372
00:23:40,480 --> 00:23:45,070
Bitwise ઓપરેટરો તમે 3 4 + કરવા જેવા છે જ્યારે યાદ રાખો કે.

373
00:23:45,070 --> 00:23:49,420
તમારી પાસે 3 અને 4 નું બાઈનરી સાથે વ્યવહાર કરવામાં આવે છે.

374
00:23:49,420 --> 00:23:56,550
Bitwise ઓપરેટરો સાથે તમે ખરેખર 3 નંબરો અને 4 ના વ્યક્તિગત બિટ્સ સાથે વ્યવહાર કરવામાં આવે છે.

375
00:23:56,550 --> 00:23:59,120
>> તેથી અમે કહીએ છીએ પડશે કે પ્રથમ એક bitwise નથી,

376
00:23:59,120 --> 00:24:02,340
અને તે કરે છે બધા તમામ બિટ્સ વિમાનની મુસાફરી છે.

377
00:24:02,340 --> 00:24:05,500
તમે સી માં આ લખી રહ્યાં છો અહીં, તો તમે તેને લખી નથી

378
00:24:05,500 --> 00:24:09,380
~ 11011 અથવા જે તરીકે, તમે, તે ~ 4 માંગો છો લખવા

379
00:24:09,380 --> 00:24:12,970
અને પછી તેને 4 નું બાઈનરી પ્રતિનિધિત્વ વિમાનની મુસાફરી કરશે.

380
00:24:12,970 --> 00:24:24,800
અહીં, 1 ની ~ કેટલાક દ્વિસંગી નંબર 1101101 બરાબર 0 ની બધી 1 ની વિમાનની મુસાફરી રહ્યું છે અને બધા 0.

381
00:24:24,800 --> 00:24:27,600
હું ત્યાં કહે છે, આ વારંવાર ઉપયોગ,

382
00:24:27,600 --> 00:24:30,830
અમે કેટલાક નંબર સાથે આવવા માંગો છો જેવા અને અમે થોડી માં જોશો, છે

383
00:24:30,830 --> 00:24:35,460
બિટ્સ તમામ તેમાંનુ એક સિવાય 1 છે છે.

384
00:24:35,460 --> 00:24:38,560
તેથી તે સંખ્યા વ્યક્ત સામાન્ય રીતે સરળ છે

385
00:24:38,560 --> 00:24:40,630
માત્ર કે એક બીટ સુયોજિત થયેલ છે,

386
00:24:40,630 --> 00:24:44,650
અને પછી તે ~ છે, તેથી દરેક અન્ય બીટ એક કે સિવાય સુયોજિત થયેલ છે લે છે.

387
00:24:44,650 --> 00:24:50,300
જેથી અમે થોડી વધુ ઉપયોગ જઈ રહ્યાં છો છે.

388
00:24:50,300 --> 00:24:58,220
>> Bitwise અથવા. અહીં 2 બાયનરી નંબર છે, અને આ 2 નંબરો છે

389
00:24:58,220 --> 00:25:00,780
તેઓ દરેક શક્ય પ્રતિનિધિત્વ કરે છે, ખૂબ પ્રતિનિધિ છે

390
00:25:00,780 --> 00:25:07,290
બિટ્સ મિશ્રણ તમે પર કામ કરવાની જરૂર છે.

391
00:25:07,290 --> 00:25:13,540
હું દરેક બીટ or'd જ્યારે અહીં,, અમે માત્ર સીધા નીચે સરખાવવા રહ્યા છીએ.

392
00:25:13,540 --> 00:25:15,410
તેથી ડાબી બાજુ પર અમે એક 1 અને 1 છે.

393
00:25:15,410 --> 00:25:20,510
જ્યારે હું bitwise | તે, હું શું વિચાર જાઉં છું? એક.

394
00:25:20,510 --> 00:25:25,320
0 અને 1 મારા આપી રહ્યું છે | પછી bitwise? એક.

395
00:25:25,320 --> 00:25:27,840
1 Bitwise અને 0 આ જ વાત છે, માત્ર એક પ્રયત્ન રહ્યું છે.

396
00:25:27,840 --> 00:25:31,880
0 Bitwise | 0 મને 0 આપી રહ્યું છે.

397
00:25:31,880 --> 00:25:37,300
0 કેસ | તેથી હું 0 વિચાર જ્યાં માત્ર કેસ 0 છે.

398
00:25:37,300 --> 00:25:40,020
અને તમે કે તમારા લોજિકલ Ors જેમ કે વિચાર કરી શકો છો.

399
00:25:40,020 --> 00:25:44,830
તમે સાચા 1 અને ખોટા 0 લાગે તેથી, જો આ જ વાત અહીં લાગુ પડે છે.

400
00:25:44,830 --> 00:25:50,040
તેથી સાચું કે સાચું સાચું છે; સાચું કે ખોટું સાચું છે.

401
00:25:50,040 --> 00:25:57,150
ખોટી અથવા સાચી સાચું છે; ખોટા કે ખોટું ખરેખર ખોટું છે કે આ જ વસ્તુ છે.

402
00:25:57,150 --> 00:26:00,100
અહીં તમને ખબર હોવી જોઇએ કે ઉદાહરણ છે

403
00:26:00,100 --> 00:26:05,160
bitwise ઓપરેટરો ઉપયોગ થાય છે જ્યારે એક સુંદર સારું ઉદાહરણ તરીકે.

404
00:26:05,160 --> 00:26:08,660
અહીં જો આપણે અથવા Ox20 સાથે મૂડી 'એ',

405
00:26:08,660 --> 00:26:11,830
અને અમે કંઈક વિચાર, એક બીજા માં આ જોવા મળશે.

406
00:26:11,830 --> 00:26:16,020
અને અમે અથવા લોઅરકેસ 'એ' Ox20 સાથે, અમે કંઈક વિચાર.

407
00:26:16,020 --> 00:26:26,750
તેથી આપણે તે ASCII ટેબલ ખેંચે છે.

408
00:26:26,750 --> 00:26:34,000
ઠીક છે. અહીં અમે 'એ' છે કે નહીં તે જોવા -

409
00:26:34,000 --> 00:26:36,920
અહીં અમે 'એ' 65 દશાંશ છે છે.

410
00:26:36,920 --> 00:26:45,120
પરંતુ હું Ox41 છે હેક્સાડેસિમલ સાથે જવા પડશે.

411
00:26:45,120 --> 00:26:48,280
સુંદર ખાતરી અમે વર્ગ માં જોયું હતું. અમે વર્ગ જોયું લાગે છે

412
00:26:48,280 --> 00:26:52,730
તે હેક્સાડેસિમલ માંથી દ્વિસંગી રૂપાંતરિત ખૂબ સરળ છે કે.

413
00:26:52,730 --> 00:26:55,280
અહીં, હું દ્વિસંગી માં 4 મૂકવા માંગો છો,

414
00:26:55,280 --> 00:26:59,550
કે માત્ર 0100 જ હશે.

415
00:26:59,550 --> 00:27:03,620
આ 1 સ્થળ, 2 સ્થળ, 4 ની જગ્યા છે, તેથી આ 4 છે.

416
00:27:03,620 --> 00:27:08,550
પછી હું 0001 પ્રયત્ન રહ્યું છે કે જે બાઈનરી માં 1 વિભાજિત છે.

417
00:27:08,550 --> 00:27:14,280
અને તેથી આ દ્વિસંગી માં 'એ' ના પ્રતિનિધિત્વ રહ્યું છે.

418
00:27:14,280 --> 00:27:22,720
લોઅરકેસ 'એ', તે હવે Ox61 જ હશે લઈને,

419
00:27:22,720 --> 00:27:27,050
તેના બાઈનરી માં આ અપ વિભાજન છે,, તેથી એક 6 -

420
00:27:27,050 --> 00:27:37,830
આપણે ખરેખર તે કરી દો - કોઈ ભૂંસવા માટેનું રબર છે? ભૂંસવું.

421
00:27:37,830 --> 00:27:48,220
Ox61. તેથી દ્વિસંગી માં 6 વિભાજન + + 4 + 2 + 0 0 પ્રયત્ન રહ્યું છે.

422
00:27:48,220 --> 00:27:54,610
અને વિભાજન 1 0001 પ્રયત્ન રહ્યું છે.

423
00:27:54,610 --> 00:27:56,520
, આ 2 વચ્ચે તફાવત અંતે છીએ

424
00:27:56,520 --> 00:28:04,250
અમે એક નાના અને મૂડી 'એ' વચ્ચે માત્ર એટલો જ તફાવત આ એક બીટ છે થાય છે.

425
00:28:04,250 --> 00:28:11,810
ઠીક છે - તેથી અહીં પાછા આવતા.

426
00:28:11,810 --> 00:28:15,920
અમે થોડી Ox20 શું જોવા,, અહીં પાછા આવતા

427
00:28:15,920 --> 00:28:22,210
તેના બાઈનરી આવી જાય સ્પ્લિટિંગ Ox20,

428
00:28:22,210 --> 00:28:27,310
0010, 0000 છે.

429
00:28:27,310 --> 00:28:33,470
Ox20, સુયોજિત થયેલ છે કે માત્ર થોડી, અમે સાથે સંબંધિત છે કે આ બીટ છે

430
00:28:33,470 --> 00:28:38,210
મૂડી અને લોઅરકેસ 'એ' વચ્ચે ફેરબદલી સાથે.

431
00:28:38,210 --> 00:28:47,610
જો આ એક છે, 'એ' છે, જે હું કે 'એ',,

432
00:28:47,610 --> 00:28:50,580
હું જો કે Ox20 સાથે 'એ',

433
00:28:50,580 --> 00:28:53,490
શું હું વિચાર જાઉં છું?

434
00:28:53,490 --> 00:28:58,960
[વિદ્યાર્થી, અશ્રાવ્ય] >> લોઅરકેસ 'એ', તે 1 થી આ બીટ વિમાનની મુસાફરી ચાલી રહ્યું છે, કારણ કે.

435
00:28:58,960 --> 00:29:04,170
અને જો હું કે 'એ' Ox20 સાથે, હું શું વિચાર જાઉં છું?

436
00:29:04,170 --> 00:29:08,780
એક લોઅરકેસ, કારણ કે માત્ર oring 'એ' Ox20 સાથે,

437
00:29:08,780 --> 00:29:14,580
હું માત્ર એક 1 આ એક બીટ oring કરી જાઉં છું, તે તો કોઈ વાંધો નથી, તેથી તેને પહેલાથી જ એક 1 છે.

438
00:29:14,580 --> 00:29:17,960
તેથી અમે 'એ' અને 'એ' વિશે.

439
00:29:17,960 --> 00:29:24,820
>> Bitwise અને. ફરીથી, અમે અમારી લોજિકલ અને વિરુદ્ધાર્થ તરીકે આ વિચાર કરી શકો છો.

440
00:29:24,820 --> 00:29:28,180
ડાબી બાજુ પર અમે સાચા અને સાચું હોય છે.

441
00:29:28,180 --> 00:29:31,160
તે સાચું જ હશે, અને કિસ્સાઓમાં બધા માટે છે

442
00:29:31,160 --> 00:29:36,270
, ખોટા અને સત્ય અથવા સાચા અને ખોટા, કે ખોટું અને ખોટા

443
00:29:36,270 --> 00:29:38,550
તે વસ્તુઓ કંઈ સત્ય છે.

444
00:29:38,550 --> 00:29:44,170
તેથી શું અમે મેળવવામાં અંત 1000 છે.

445
00:29:44,170 --> 00:29:48,830
તેથી હવે, અહીં, અહીં હું વિશ્વાસુ bitwise નથી ઉપયોગ કર્યો છે જ્યાં છે,

446
00:29:48,830 --> 00:29:52,230
જ્યાં અમે Ox20 હતી.

447
00:29:52,230 --> 00:29:54,350
તેથી આ Ox20 છે.

448
00:29:54,350 --> 00:29:59,570
હવે હું શું કરવા માંગો છો, bitwise Ox20 ઓફ ~.

449
00:29:59,570 --> 00:30:03,600
કે બધા બિટ્સ વિમાનની મુસાફરી રહ્યું છે.

450
00:30:03,600 --> 00:30:09,330
તેથી હું 1101, 1111 છે.

451
00:30:09,330 --> 00:30:18,940
અને તેથી 'એ' ~ Ox20 મને શું આપી રહ્યું છે સાથે anded?

452
00:30:18,940 --> 00:30:22,430
અમે ખરેખર વિચાર કરવા આ માત્ર થોડી, આ એક છે

453
00:30:22,430 --> 00:30:26,020
કારણ કે, આ બિટ્સ તમામ 1 સુયોજિત છે, તો

454
00:30:26,020 --> 00:30:29,000
પછી અમે ચોકકસ શું 'એ' હતી વિચાર જઈ રહ્યાં છો,

455
00:30:29,000 --> 00:30:31,260
સિવાય, કદાચ, આ બીટ છે.

456
00:30:31,260 --> 00:30:34,460
તે 1 હતો, હવે તે એક 0 તરીકે સુયોજિત કરી રહ્યા છે કારણ કે

457
00:30:34,460 --> 00:30:39,810
આ છે જે, આ 0 પ્રયત્ન રહ્યું છે સાથે anded છે.

458
00:30:39,810 --> 00:30:43,280
તેથી 'એ' ~ Ox20 મને આપી રહ્યું અને શું છે?

459
00:30:43,280 --> 00:30:48,200
[વિદ્યાર્થીઓ જવાબ, અશ્રાવ્ય] >> અને 'એ' અને શું છે - તે 'એ' છે.

460
00:30:48,200 --> 00:30:52,170
અને 'એ' અને ~ Ox20 મને આપી રહ્યું છે?

461
00:30:52,170 --> 00:30:56,720
'એ' હાલમાં આ એક 1 છે.

462
00:30:56,720 --> 00:30:59,570
આ 0 સાથે સાથે Anding, તે 0 કરી રહ્યા છે

463
00:30:59,570 --> 00:31:02,530
અને હવે અમે એક 'એ' વિચાર જઈ રહ્યાં છો.

464
00:31:02,530 --> 00:31:06,600
>> બંને 'એ' હોય છે અને આ પ્રકારની છેલ્લું નથી, પરંતુ ઓછામાં ઓછા,

465
00:31:06,600 --> 00:31:10,830
અમે XOR છે. તે ખૂબ જ ખૂબ જેવું છે કે,

466
00:31:10,830 --> 00:31:14,400
તે સંપૂર્ણપણે અર્થ એ થાય કે સિવાય.

467
00:31:14,400 --> 00:31:18,420
આ તમને સામાન્ય રીતે અથવા વાસ્તવિક વિશ્વમાં લાગે એના જેવું છે.

468
00:31:18,420 --> 00:31:23,190
જેથી તમે ક્યાં તો 'એક્સ' અથવા 'વાય', પરંતુ બંને નથી.

469
00:31:23,190 --> 00:31:28,700
અહીં ^ 1 1 0 પ્રયત્ન રહ્યું છે.

470
00:31:28,700 --> 00:31:33,650
સાચું કારણ કે, આ છે - તે લોજિકલ સાચા અને ખોટા સાથે કામ કરતું નથી

471
00:31:33,650 --> 00:31:37,150
, bitwise અને અને અથવા જેમ

472
00:31:37,150 --> 00:31:40,100
પરંતુ સાચું ^ સાચું ખોટું છે.

473
00:31:40,100 --> 00:31:44,810
માત્ર એક જ તેમને પણ એવું થયું છે કે અમે માત્ર સાચી પરત કરવા માંગો છો છે.

474
00:31:44,810 --> 00:31:50,950
તેથી ^ 1 1 0 છે. શું ^ 1 0 વિશે શું?

475
00:31:50,950 --> 00:31:56,010
1 છે. ^ ^ 0 1 0 0 0 છે, 1 છે.

476
00:31:56,010 --> 00:32:03,890
તેથી એ બધા સંજોગો હેઠળ, 0 bitwise કંઈક 0 0 પ્રયત્ન રહ્યું છે.

477
00:32:03,890 --> 00:32:10,270
1 bitwise કંઈક 0 અથવા 0 bitwise 1,

478
00:32:10,270 --> 00:32:14,660
તે જો | અથવા ^, તે 1 હશો, અને તે અને જો તે 0 હશો.

479
00:32:14,660 --> 00:32:20,850
અને 1 bitwise 1 1 નથી માત્ર કેસ જ્યાં વિશિષ્ટ કે સાથે છે.

480
00:32:20,850 --> 00:32:24,580
તે 0110 છે.

481
00:32:24,580 --> 00:32:36,520
અહીં હવે, XOR મદદથી - જેથી અમે પાછા 20 પર છો.

482
00:32:36,520 --> 00:32:43,480
'એ' ^ Ox20 અમે સરખામણી કરી રહ્યા છો આ 2 બિટ્સ.

483
00:32:43,480 --> 00:32:50,020
તેથી 1 0 ^ મને શું આપી રહ્યું છે? એક છે.

484
00:32:50,020 --> 00:32:58,430
'એ' ^ Ox20 મને આપી રહ્યું છે? એક લોઅરકેસ.

485
00:32:58,430 --> 00:33:04,010
'એ' ^ Ox20 મને આપી રહ્યું છે? મૂડી એ

486
00:33:04,010 --> 00:33:09,310
કારણ કે આ કરી છે ગમે, Ox20 સાથે આ XORing છે

487
00:33:09,310 --> 00:33:15,380
અસરકારક રીતે આ બીટ છે ગમે ફ્લિપિંગ છે.

488
00:33:15,380 --> 00:33:21,240
આ એક 0 છે, તે હવે 1 બની રહ્યું છે.

489
00:33:21,240 --> 00:33:26,160
આ એક 1 છે, ^ 1 1 0 છે.

490
00:33:26,160 --> 00:33:33,280
તેથી અમારા 'એ' 'એ' બની છે, અને અમારા 'એ' 'એ' બની છે.

491
00:33:33,280 --> 00:33:36,910
તેથી XOR માત્ર કેસ ફ્લિપિંગ એક ખરેખર અનુકૂળ માર્ગ છે.

492
00:33:36,910 --> 00:33:39,960
તમે માત્ર અક્ષરો એક શબ્દમાળા ફરી વળવું માંગો છો

493
00:33:39,960 --> 00:33:44,330
અને દરેક એક અક્ષર કિસ્સામાં એકના,

494
00:33:44,330 --> 00:33:50,680
Ox20 સાથે તમે માત્ર XOR બધું.

495
00:33:50,680 --> 00:33:55,220
>> હવે અમે પાળી છોડી ગયા છે. ડાબી પાળી માત્ર છે મૂળભૂત રીતે, રહ્યું છે

496
00:33:55,220 --> 00:34:01,250
માં, અથવા ડાબી આંકડા તમામ દબાણ, અને તેમની પાછળ 0 દાખલ કરો.

497
00:34:01,250 --> 00:34:05,550
અહીં અમે 00001101 છે.

498
00:34:05,550 --> 00:34:08,560
અમે જમણેથી 3 0 માં દબાણ રહ્યા છીએ

499
00:34:08,560 --> 00:34:13,580
અને અમે 01101000 વિષે.

500
00:34:13,580 --> 00:34:16,380
Nonbinary શરતો માં,

501
00:34:16,380 --> 00:34:24,699
અમે તે ખરેખર 13 ડાબા ખસેડી 3 સાથે, અમને 104 આપે છે વ્યવહાર છે કે જુઓ.

502
00:34:24,699 --> 00:34:32,530
તેથી ડાબી સ્થળાંતર, અમે અહીં જુઓ, એક્સ << વાય મૂળભૂત X * 2 ^ વાય છે.

503
00:34:32,530 --> 00:34:40,139
^ 3 13 * 2, 3 ^ 2 તેથી * 8 થી 13 104 છે, 8 છે.

504
00:34:40,139 --> 00:34:45,679
તમે માત્ર સામાન્ય રીતે દ્વિસંગી, દરેક કેવી રીતે આંકડાના વિશે વિચારો તો

505
00:34:45,679 --> 00:34:49,530
અમે જમણેથી શરૂ કરવા માટે, તે પછી 1 સ્થળ, પછી 2 સ્થળ, 4 ની જગ્યા છે.

506
00:34:49,530 --> 00:34:51,330
તેથી જમણેથી 0 માં દબાણ દ્વારા,

507
00:34:51,330 --> 00:34:55,080
અમે હમણાં જ 8 ની સ્થળ માટે 4 ની જગ્યાએ હતા વસ્તુઓ છે કે જે દબાણ કરી રહ્યાં છે

508
00:34:55,080 --> 00:34:57,920
અને 16 સ્થળ ના 8 ની જગ્યાએ હતા વસ્તુઓ છે કે જે.

509
00:34:57,920 --> 00:35:01,280
દરેક પાળી માત્ર 2 દ્વારા multiplies. અરે વાહ?

510
00:35:01,280 --> 00:35:05,210
તમે 5 દ્વારા કર્યું [વિદ્યાર્થી] જો શું થાય છે?

511
00:35:05,210 --> 00:35:10,790
[બોડેન] તમે 5 દ્વારા કર્યું તો તમે માત્ર અંકો ગુમાવશે.

512
00:35:10,790 --> 00:35:15,410
ખચીત, તે જ વાત છે. જેમ, પૂર્ણાંકો ફક્ત 32 બિટ્સ છે,

513
00:35:15,410 --> 00:35:20,750
તમે 2 ખરેખર મોટી પૂર્ણાંકો ઉમેરવા તેથી, જો તે માત્ર એક પૂર્ણાંક નથી ફિટ નથી.

514
00:35:20,750 --> 00:35:23,660
તેથી તે જ અહીં વાત છે. તમે 5 દ્વારા કર્યું છે,

515
00:35:23,660 --> 00:35:25,650
અમે ફક્ત એક કે ગુમાવશે.

516
00:35:25,650 --> 00:35:28,820
અને તે "આશરે" હું દ્વારા શું અર્થ પ્રકારની છે

517
00:35:28,820 --> 00:35:37,470
તમે ખૂબ દૂર પાળી છે, તમે બિટ્સ ગુમાવી છે.

518
00:35:37,470 --> 00:35:39,830
>> અધિકાર પાળી વિરુદ્ધ પ્રયત્ન રહ્યું છે,

519
00:35:39,830 --> 00:35:43,090
અમે, અંતે બોલ 0 ધક્કો રહ્યા છીએ જ્યાં

520
00:35:43,090 --> 00:35:48,400
અને અમારા હેતુઓ માટે, ડાબી બાજુથી 0 ભરો.

521
00:35:48,400 --> 00:35:52,910
તેથી આ કરી, અમે મૂળભૂત રીતે અમે પહેલાથી જ કર્યું હતું શું વિપરીત છીએ.

522
00:35:52,910 --> 00:35:57,780
અને અમે જમણી બાજુ પર ત્રણ 0 માત્ર બોલ ઘટી છે જુઓ

523
00:35:57,780 --> 00:36:02,020
અને અમે જમણી 1101 બધી રીતે દબાણ છે.

524
00:36:02,020 --> 00:36:08,380
આ અસરકારક, એક્સ / 2 ^ વાય છે, કે જે 104 >> 3 કરી છે.

525
00:36:08,380 --> 00:36:11,200
તેથી હવે, અહીં, તે એક જ પ્રકારની વિચાર છે.

526
00:36:11,200 --> 00:36:18,720
શા માટે તે માત્ર આશરે X / 2 ^ વાય છે, અને ખરેખર એક્સ / 2 ^ વાય?

527
00:36:18,720 --> 00:36:22,240
હું 4 ખસેડવામાં હતી, હું એક 1 ગુમાવી હોત કારણ કે.

528
00:36:22,240 --> 00:36:25,950
મૂળભૂત રીતે, માત્ર સામાન્ય રીતે પૂર્ણાંક ડિવિઝન કયા તમે વિચાર, છે.

529
00:36:25,950 --> 00:36:31,070
તેથી, 5/2 જેવા 2 છે. તે 2.5 નથી.

530
00:36:31,070 --> 00:36:35,000
તે અહીં જ વિચાર છે. અમે 2 દ્વારા વિભાજીત છે, જ્યારે

531
00:36:35,000 --> 00:36:39,910
અમે રસ્તામાં વિચિત્ર બિટ્સ ગુમાવી શકો છો.

532
00:36:39,910 --> 00:36:43,870
તેથી હવે - કે bitwise માટે છે. એટલે કે, તમે જાણવા જરૂર છે.

533
00:36:43,870 --> 00:36:46,340
અમે વર્ગ જોયું ઉપયોગ કિસ્સાઓમાં યાદ રાખો,

534
00:36:46,340 --> 00:36:49,340
જેવી થોડી માસ્ક, bitwise ઓપરેટરો માટે ઉપયોગી છે

535
00:36:49,340 --> 00:36:53,220
અથવા તમે બીટ માસ્ક માટે વાપરો.

536
00:36:53,220 --> 00:36:58,620
મૂડી અક્ષરો અને નાના અક્ષરો, રૂપાંતરણો એક સુંદર અજમાયશી ઉદાહરણ છે.

537
00:36:58,620 --> 00:37:01,640
>> ઠીક છે, તેથી ઓવરફ્લો હુમલાઓ બફર.

538
00:37:01,640 --> 00:37:05,110
કોઈપણ આ કાર્ય સાથે ખોટું શું છે યાદ?

539
00:37:05,110 --> 00:37:10,140
અમે 12 બાઇટ્સ ઝાકઝમાળ, 12 અક્ષરો જાહેર નોંધ

540
00:37:10,140 --> 00:37:18,510
અને પછી અમે 12 સમગ્ર શબ્દમાળા બાર અક્ષરો અમારી બફર માં નકલ કરો.

541
00:37:18,510 --> 00:37:25,080
જેથી સમસ્યા અહીં શું છે?

542
00:37:25,080 --> 00:37:32,270
શા માટે 12 - આ જાદુ નંબર 12 ખૂબ ખૂબ તરત તરીકે બહાર પૉપ જોઈએ?

543
00:37:32,270 --> 00:37:35,050
બાર 12 કરતાં વધુ અક્ષરો બને છે તો શું?

544
00:37:35,050 --> 00:37:41,200
શું બાર અક્ષરો લાખો છે?

545
00:37:41,200 --> 00:37:46,010
અહીં મુદ્દો memcpy છે. બાર પર્યાપ્ત લાંબા સમય સુધી, છે

546
00:37:46,010 --> 00:37:50,330
તે માત્ર સંપૂર્ણપણે કરશે - 'સી', 'સી' તે માત્ર 12 અક્ષરો હતો કે કાળજી નથી;

547
00:37:50,330 --> 00:37:53,280
'સી' તે ઘણા બાઇટ્સ નથી ફિટ કરી શકે છે કાળજી નથી.

548
00:37:53,280 --> 00:37:58,250
તે માત્ર સંપૂર્ણપણે ઘરનાં પરચૂરણ કામો પર ફરીથી લખી નાંખશે, અમે તેને માટે ફાળવવામાં કર્યું છે 12 ​​બાઇટ્સ,

549
00:37:58,250 --> 00:38:01,830
અને મેમરીમાં તે ભૂતકાળ બધું ખરેખર છે કે બફર ને અનુલક્ષતું નથી કે

550
00:38:01,830 --> 00:38:06,520
ગમે તે શબ્દમાળા બાર છે સાથે.

551
00:38:06,520 --> 00:38:09,780
તેથી આ અમે વર્ગ માં જોયું ચિત્ર હતું

552
00:38:09,780 --> 00:38:12,220
અમે અમારા સ્ટેક અપ વધી રહી છે જ્યાં.

553
00:38:12,220 --> 00:38:16,040
તમે આ ચિત્રો માટે ઉપયોગ કરો અથવા ફરી તેમની સાથે પરિચિત મેળવી હોવી જોઈએ.

554
00:38:16,040 --> 00:38:21,260
અમે અમારા સ્ટેક અપ વધી રહી છે, મેમરી સરનામાંઓ ટોચ પર 0 શરૂ

555
00:38:21,260 --> 00:38:26,270
અને તળિયે 4 બિલિયન ગમે છે માટે નીચે વિકસે છે.

556
00:38:26,270 --> 00:38:28,820
અમે ક્યાંક મેમરી અમારા એરે 'સી' હોય છે

557
00:38:28,820 --> 00:38:32,260
પછી અમે તેને અધિકાર નીચે બાર અમારા નિર્દેશક હોય છે,

558
00:38:32,260 --> 00:38:38,720
અને પછી અમે આ સેવ ફ્રેમ અમારા વળતર માં નિર્દેશક અને અમારા પિતૃ નિયમિત સ્ટેક હોય છે.

559
00:38:38,720 --> 00:38:40,800
પરત સરનામું શું છે યાદ રાખો?

560
00:38:40,800 --> 00:38:45,360
મુખ્ય કાર્ય બાર કહે છે, એક કાર્ય foo કહે છે જ્યારે તે છે

561
00:38:45,360 --> 00:38:48,100
ખચીત, વળતર બાર.

562
00:38:48,100 --> 00:38:52,610
તેથી જ્યારે બાર વળતર, તેઓ તેને તે કહે છે કે foo પાછા ચાલી રહ્યું છે કે જાણવાની જરૂર છે.

563
00:38:52,610 --> 00:39:01,360
તેથી પરત આંકડાના જ્યારે કાર્ય વળતર પર પાછા છે કે કાર્ય ના સરનામું છે.

564
00:39:01,360 --> 00:39:05,830
, સરળ, કારણ કે બફર ઓવરફ્લો હુમલાઓ માટે મહત્વપૂર્ણ છે કે આ કારણ છે

565
00:39:05,830 --> 00:39:09,580
હેકરો કે વળતર સરનામું બદલવા માંગો.

566
00:39:09,580 --> 00:39:14,950
તેના બદલે foo પાછા જવાની, હું પાછળ હેકર મને પાછા જવા માંગે છે ત્યાં જવા માટે જઈ રહ્યો છું.

567
00:39:14,950 --> 00:39:17,760
અને, સગવડતા, હેકર વારંવાર પાછા જવા માંગે છે

568
00:39:17,760 --> 00:39:22,400
અમે મૂળ હતું કે બફર શરૂઆત છે.

569
00:39:22,400 --> 00:39:26,170
તેથી, ફરી, લિટલ ભારતીય નોંધ લો.

570
00:39:26,170 --> 00:39:28,490
આ સાધન એક લિટલ ભારતીય સિસ્ટમ એક ઉદાહરણ છે,

571
00:39:28,490 --> 00:39:34,140
જેથી પૂર્ણાંક અથવા પૉઇન્ટર ઉલટાવી બાઇટ્સ સાથે સંગ્રહ કરવામાં આવે છે.

572
00:39:34,140 --> 00:39:38,980
અહીં અમે જુઓ - આ છે? અરે વાહ.

573
00:39:38,980 --> 00:39:45,660
અમે Ox80, OxC0, Ox35, OxO8 જુઓ.

574
00:39:45,660 --> 00:39:48,250
આ હેક્સાડેસિમલ યાદ રાખો?

575
00:39:48,250 --> 00:39:50,640
અમે લિટલ ભારતીય માં હેક્સાડેસિમલ ઉલટાવી નથી

576
00:39:50,640 --> 00:39:56,110
2 હેક્સાડેસિમલ એક બાઈટ કરી, અને અમે બાઇટ્સ ઉલટાવી છે.

577
00:39:56,110 --> 00:40:00,300
આપણે શા માટે, જેમ કે, 80530CO8 સ્ટોર નથી છે.

578
00:40:00,300 --> 00:40:07,520
અમે જમણેથી શરૂ કરીને,, તેની બદલે, 2 અંકો દરેક જોડી સ્ટોર કરે છે.

579
00:40:07,520 --> 00:40:10,880
તે સરનામું શરૂઆત ના સરનામા સંદર્ભ લે છે

580
00:40:10,880 --> 00:40:15,190
અમે ખરેખર પ્રથમ સ્થાને કૉપિ માગે છે અમારા બફર.

581
00:40:15,190 --> 00:40:19,230
ઉપયોગી છે કે આ કારણ છે જો, કારણ કે હુમલાખોર

582
00:40:19,230 --> 00:40:24,100
તેના બદલે માત્ર હતું કે શબ્દમાળા કર્યા છે, થયું

583
00:40:24,100 --> 00:40:27,060
જેમ એક હાનિકારક શબ્દમાળા, તેમના નામ અથવા કંઈક,

584
00:40:27,060 --> 00:40:33,900
જો, તેના બદલે, કે જેઓ શબ્દમાળા માત્ર કેટલાક મનસ્વી કોડ હતા

585
00:40:33,900 --> 00:40:38,610
કે તેઓ તે કરવા ઇચ્છતા ગમે હતી?

586
00:40:38,610 --> 00:40:45,630
તેથી તેઓ કરી શકે છે - હું કોઇ ઠંડી કોડ કલ્પના કરી શકતો નથી.

587
00:40:45,630 --> 00:40:47,780
તે છતાં, કંઇ હોઇ શકે છે. કોઈપણ વિનાશક કોડ.

588
00:40:47,780 --> 00:40:51,440
તેઓ માગતા હતા, તેઓ માત્ર ખામી seg પર કંઈક કરી શકે છે, પરંતુ તે અર્થહીન છે.

589
00:40:51,440 --> 00:40:54,950
તેઓ સામાન્ય રીતે તમારા સિસ્ટમ હેક કરવા કામ કરે છે.

590
00:40:54,950 --> 00:40:59,930
>> ઠીક છે. CS50 પુસ્તકાલય.

591
00:40:59,930 --> 00:41:04,800
આ છે, મૂળભૂત રીતે, getInt, getString, તે તમામ કાર્યો અમે તમારા માટે આપવામાં આવે છે.

592
00:41:04,800 --> 00:41:10,630
તેથી અમે ઘરનાં પરચૂરણ કામો * શબ્દમાળા હોય છે, અને તે અમે દૂર ઉડાવી કે તાત્વિક છે

593
00:41:10,630 --> 00:41:12,450
આ સત્ર દરમિયાન કેટલાક તબક્કે.

594
00:41:12,450 --> 00:41:18,220
શબ્દમાળા માત્ર અક્ષરો ઝાકઝમાળ છે કે યાદ રાખો.

595
00:41:18,220 --> 00:41:23,240
અહીં અમે getString એક સંક્ષિપ્ત આવૃત્તિ જુઓ.

596
00:41:23,240 --> 00:41:25,920
તમે તેને ખરેખર અમલમાં છે યાદ કેવી રીતે તે પર એક નજર કરીશું.

597
00:41:25,920 --> 00:41:30,950
કી વિગતો છે, અમે એક સમયે એક જ અક્ષર વિચાર નોટિસ

598
00:41:30,950 --> 00:41:34,570
અમને ફક્ત કીબોર્ડ લખીને ગમે છે, કે જે પ્રમાણભૂત માંથી.

599
00:41:34,570 --> 00:41:37,890
તેથી એક સમયે એક જ અક્ષર છે, અને અમે ઘણા અક્ષરો વિચાર,

600
00:41:37,890 --> 00:41:40,580
તેથી n એ + + 1 ક્ષમતા કરતાં વધારે હોય છે,

601
00:41:40,580 --> 00:41:44,140
પછી અમે અમારી બફર ક્ષમતા વધારો કરવાની જરૂર છે.

602
00:41:44,140 --> 00:41:47,780
અહીં અમે અમારા બફર માપ બમણો કરી રહ્યાં છો.

603
00:41:47,780 --> 00:41:51,840
અને તે જઈને રાખે; આપણે બફર માં અક્ષર દાખલ

604
00:41:51,840 --> 00:41:56,220
અમે એક નવી લાઇન અથવા ફાઇલ અથવા જે અંત પ્રાપ્ત થાય ત્યાં સુધી,

605
00:41:56,220 --> 00:41:59,380
જે કિસ્સામાં, અમે શબ્દમાળા અને પછી વાસ્તવિક getString સાથે પૂર્ણ કરી

606
00:41:59,380 --> 00:42:05,120
અમે ઘણી બધી મેમરીનો ફાળવવામાં જો તે પાછા જાઓ અને થોડી સંકોચો પડશે, જેમ કે મેમરી ઘટાડા.

607
00:42:05,120 --> 00:42:08,830
તેથી અમે તે બતાવશો નથી, પરંતુ મુખ્ય વિચાર છે

608
00:42:08,830 --> 00:42:11,960
તે એક સમયે એક જ અક્ષર વાંચી છે.

609
00:42:11,960 --> 00:42:17,140
તે માત્ર એક જ સમયે સમગ્ર બાબત માં વાંચી શકાય છે,

610
00:42:17,140 --> 00:42:19,550
તેમના બફર માત્ર ચોક્કસ કદના છે.

611
00:42:19,550 --> 00:42:26,590
તે બફર દાખલ કરવાનો પ્રયાસ કરે છે શબ્દમાળા કે ખૂબ મોટી છે તેથી જો, પછી તે ઓવરફ્લો થશે.

612
00:42:26,590 --> 00:42:28,940
અહીં અમે અટકાવવા કે માત્ર એક જ અક્ષર વાંચીને

613
00:42:28,940 --> 00:42:33,750
એક સમયે અને અમે જરૂર જ્યારે પણ વધી રહી છે.

614
00:42:33,750 --> 00:42:40,270
તેથી getInt અને અન્ય CS50 પુસ્તકાલય કાર્યો getString ઉપયોગ કરે છે

615
00:42:40,270 --> 00:42:42,310
તેમના અમલીકરણો છે.

616
00:42:42,310 --> 00:42:45,370
તેથી હું અહીં મહત્વપૂર્ણ વસ્તુઓ પ્રકાશિત.

617
00:42:45,370 --> 00:42:49,460
તે શબ્દમાળા મેળવવા getString કહે છે.

618
00:42:49,460 --> 00:42:51,710
GetString મેમરી પરત નિષ્ફળ તો,

619
00:42:51,710 --> 00:42:54,270
getString કંઈક mallocs યાદ રાખો કે, તેથી તમે GetString કહી જ્યારે

620
00:42:54,270 --> 00:42:57,820
તમે (દુર્બોધ) તમે મળી છે કે જેઓ શબ્દમાળા મુક્ત ન જોઈએ.

621
00:42:57,820 --> 00:43:02,870
તે કંઈક malloc નિષ્ફળ ગયું તો અહીં,, અમે માત્ર એક ફ્લેગ તરીકે INT_MAX પરત કે,

622
00:43:02,870 --> 00:43:05,650
અરે, અમે ખરેખર એક પૂર્ણાંક વિચાર સક્ષમ ન હતા.

623
00:43:05,650 --> 00:43:10,830
તમે હું તમને જે પરત અવગણો, અથવા કરીશું

624
00:43:10,830 --> 00:43:15,540
તો તમે માન્ય ઇનપુટ તરીકે આ સારવાર ન જોઈએ.

625
00:43:15,540 --> 00:43:21,360
છેલ્લે, કે કરી ગઈ એમ ધારી રહ્યા છીએ, અમે તે ખાસ ધ્વજ સાથે sscanf ઉપયોગ

626
00:43:21,360 --> 00:43:23,820
એટલે કે, પ્રથમ પૂર્ણાંક સાથે મેળ,

627
00:43:23,820 --> 00:43:26,770
પછી તે પૂર્ણાંક પછી કોઈપણ અક્ષરો મેળ ખાય છે.

628
00:43:26,770 --> 00:43:29,070
તેથી અમે તે 1 જેટલી કરવા માંગો છો નોટિસ.

629
00:43:29,070 --> 00:43:32,940
તેથી sscanf વળતર કેટલી મેચો સફળતાપૂર્વક કરી છે?

630
00:43:32,940 --> 00:43:37,010
તે સફળતાપૂર્વક પૂર્ણાંક સાથે મેળ ખાતી હોય તેને 1 આપશે,

631
00:43:37,010 --> 00:43:40,890
તે પૂર્ણાંક સાથે મેળ ખાતી નથી જો તે 0 આપશે, અને તે 2 આપશે

632
00:43:40,890 --> 00:43:45,920
તે મેળ ખાતી જો પૂર્ણાંક કેટલાક પાત્ર છે.

633
00:43:45,920 --> 00:43:49,780
તેથી અમે પણ 1 મેળ ખાય તો અમે ફરી પ્રયાસ નોંધ લો.

634
00:43:49,780 --> 00:43:55,230
તેથી અમે દાખલ કરી હોય 1, 2, 3, સી, અથવા 1, 2, 3, એક્સ,

635
00:43:55,230 --> 00:43:57,400
પછી 1, 2, 3 પૂર્ણાંક માં સ્ટોર કરશે,

636
00:43:57,400 --> 00:43:59,620
એક્સ રાજ્ય બહા પર સ્ટોર કરશે

637
00:43:59,620 --> 00:44:06,410
અમે તેને માત્ર એક પૂર્ણાંક માંગો છો કારણ કે, sscanf 2 પરત, અને અમે ફરી પ્રયાસ કરશે.

638
00:44:06,410 --> 00:44:09,810
>> ઝડપથી એચટીએમએલ, HTTP, સીએસએસ મારફતે ફૂંકાતા.

639
00:44:09,810 --> 00:44:15,340
હાઇપરટેક્સ્ટ માર્કઅપ લેંગ્વેજ વેબ બંધારણ અને સીમેન્ટિક્સ છે.

640
00:44:15,340 --> 00:44:19,960
અહીં અમે HTML ટૅગ્સ હોય છે વ્યાખ્યાન ના ઉદાહરણ છે.

641
00:44:19,960 --> 00:44:22,110
અમે વડા ટૅગ્સ, શરીર ટૅગ્સ છે

642
00:44:22,110 --> 00:44:27,770
અમે, અમે ખરેખર એક શરૂઆત અને બંધ ટેગ નથી જ્યાં ખાલી ટૅગ્સ ઉદાહરણો છે

643
00:44:27,770 --> 00:44:30,820
અમે ફક્ત કડી અને છબી હોય છે.

644
00:44:30,820 --> 00:44:38,480
કોઈ બંધ છબી ટેગ છે; ટૅગ કરવાની જરૂર બધું પરિપૂર્ણ છે કે જે માત્ર એક જ ટેગ છે.

645
00:44:38,480 --> 00:44:41,950
કડી ઉદાહરણ છે; અમે તમને સીએસએસ લિંક જોશો કેવી રીતે,

646
00:44:41,950 --> 00:44:45,910
સ્ક્રિપ્ટ તમે બાહ્ય જાવાસ્ક્રિપ્ટ લિંક કેવી રીતે એક ઉદાહરણ છે.

647
00:44:45,910 --> 00:44:53,100
તે એચટીએમએલ કોઇ પ્રોગ્રામીંગ ભાષા નથી, ખૂબ સરળ છે, અને યાદ રાખો.

648
00:44:53,100 --> 00:44:58,250
અહીં, તમે આ શું કરશે તે એક ફોર્મ વ્યાખ્યાયિત અથવા ઓછામાં ઓછા કેવી રીતે યાદ?

649
00:44:58,250 --> 00:45:01,740
આવા ફોર્મ ક્રિયા અને એક પદ્ધતિ છે.

650
00:45:01,740 --> 00:45:06,210
તમે માત્ર ક્યારેય જોશે પદ્ધતિઓ મળે છે અને સમાચાર છે.

651
00:45:06,210 --> 00:45:09,040
તેથી મેળવવી આ વસ્તુ URL માં મૂકવામાં નહીં જ્યાં આવૃિત છે.

652
00:45:09,040 --> 00:45:11,680
તે URL માં મૂકી થયેલ છે પોસ્ટ છે.

653
00:45:11,680 --> 00:45:18,520
તેના બદલે, ફોર્મ કોઇપણ માહિતી HTTP વિનંતિ વધુ હિડન દાખલ કરવામાં આવે છે.

654
00:45:18,520 --> 00:45:22,390
HTTP વિનંતિ જાય છે અહીં, ક્રિયા વ્યાખ્યાયિત કરે છે.

655
00:45:22,390 --> 00:45:27,490
તે ચાલી રહ્યું છે જ્યાં google.com / શોધ છે.

656
00:45:27,490 --> 00:45:32,890
પદ્ધતિ. મળે છે અને સમાચાર વચ્ચે તફાવત યાદ રાખો,

657
00:45:32,890 --> 00:45:37,200
તમે બુકમાર્ક કંઈક કરવા માંગો છો, તો માત્ર એક ઉદાહરણ તરીકે છે.

658
00:45:37,200 --> 00:45:40,660
તમે એક POST URL ને બુકમાર્ક કરવાનો ક્યારેય થશે

659
00:45:40,660 --> 00:45:44,970
ડેટા URL માં શામેલ નથી છે.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, હવે, હાઇપરટેક્સ્ટ ટ્રાન્સફર પ્રોટોકોલ છે.

661
00:45:49,790 --> 00:45:54,080
આ હાઇપરટેક્સ્ટ ટ્રાન્સફર પ્રોટોકોલ, તો તમે તેને પરિવહન માટે અપેક્ષા કરશે

662
00:45:54,080 --> 00:45:57,710
હાઇપરટેક્સ્ટ માર્કઅપ લેંગ્વેજ, અને તે કરે છે.

663
00:45:57,710 --> 00:46:00,170
પરંતુ તે તમને વેબ પર શોધી કોઈ પણ છબીઓ પરિવહન,

664
00:46:00,170 --> 00:46:05,400
તમે કોઈપણ ડાઉનલોડ એક HTTP વિનંતિ તરીકે શરૂ કરો.

665
00:46:05,400 --> 00:46:10,350
તેથી HTTP માત્ર વર્લ્ડ વાઇડ વેબ એ ભાષા છે.

666
00:46:10,350 --> 00:46:15,610
અને અહીં તમે HTTP વિનંતિ આ પ્રકારની ઓળખી જરૂર છે.

667
00:46:15,610 --> 00:46:19,300
બાજુ પર અહીં HTTP/1.1 માત્ર કે આવૃત્તિ છે કહે છે

668
00:46:19,300 --> 00:46:21,570
પ્રોટોકોલને હું ઉપયોગ કરું છું.

669
00:46:21,570 --> 00:46:25,770
તમે તેને જોશો તે ખરેખર ખૂબ હંમેશા HTTP/1.1 જ હશે.

670
00:46:25,770 --> 00:46:30,110
પછી અમે આ તમે જોઈ શકે છે, વૈકલ્પિક પોસ્ટ વિચાર, અને હતું કે જુઓ.

671
00:46:30,110 --> 00:46:40,790
અને હું મુલાકાત લેવાનો પ્રયાસ કરી હતી કે તે URL www.google.com/search?q = મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત હતી.

672
00:46:40,790 --> 00:46:44,240
તેથી યાદ રાખો કે આ પ્રશ્ન ચિહ્ન Q = મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત,

673
00:46:44,240 --> 00:46:49,040
એક સ્વરૂપ દ્વારા રજૂ કરવામાં આવે છે કે જે સામગ્રી ના જેવું છે.

674
00:46:49,040 --> 00:46:51,830
મને તે પાછા શકે જવાબ આ કંઈક દેખાશે.

675
00:46:51,830 --> 00:46:54,050
ફરીથી, કે પ્રયત્ન રહ્યું છે જે પ્રોટોકોલ સાથે શરૂ કરીને,

676
00:46:54,050 --> 00:46:59,190
આ પરિસ્થિતિ કોડ અનુસરતા. અહીં તે 200 બરાબર છે.

677
00:46:59,190 --> 00:47:05,060
અને છેલ્લે, હું ખરેખર માટે પૂછવામાં કે વેબ પાનું અનુસરણ કરશે.

678
00:47:05,060 --> 00:47:08,210
આ શક્ય પરિસ્થિતિ કોડ તમે જુઓ શકે છે, અને તમે તેમને કેટલાક જાણવું જોઈએ.

679
00:47:08,210 --> 00:47:12,770
200 ઠીક તો તમે કદાચ તે પહેલાં જોઈ હોય તો.

680
00:47:12,770 --> 00:47:17,830
403 ફોરબિડન, 404 મળ્યો નથી, 500 આંતરિક સર્વર ભૂલ

681
00:47:17,830 --> 00:47:22,140
તમે વેબસાઇટ પર જાઓ અને કંઈક તૂટી અથવા તેમના PHP કોડ અકસ્માત તો સામાન્ય રીતે છે

682
00:47:22,140 --> 00:47:24,930
સાધન અમે જ્યારે કે મોટી નારંગી બોક્સ

683
00:47:24,930 --> 00:47:27,830
કે આવે છે અને, જેમ કે કંઈક ખોટું છે, કહે છે, આ કોડ કામ કરતું નથી

684
00:47:27,830 --> 00:47:30,380
અથવા આ કાર્ય ખરાબ.

685
00:47:30,380 --> 00:47:33,230
સામાન્ય રીતે વેબસાઇટ્સ તમે કાર્યો ખરેખર ખરાબ છે તે જાણીને નહિં માંગો

686
00:47:33,230 --> 00:47:37,880
તેથી તેના બદલે તેઓ માત્ર તમે 500 આંતરિક સર્વર ભૂલો આપવા પડશે.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP ને HTTP હેઠળ 1 સ્તર છે.

688
00:47:43,050 --> 00:47:47,550
ઇન્ટરનેટ વર્લ્ડ વાઇડ વેબ બહાર છે કે યાદ રાખો.

689
00:47:47,550 --> 00:47:52,270
જેમ તમને HTTP મારફતે ન જાય કે જે ઑનલાઇન રમવા તો,

690
00:47:52,270 --> 00:47:55,740
તેને અલગ પસાર થઇ છે - તે હજુ પણ ઇન્ટરનેટ નો ઉપયોગ છે,

691
00:47:55,740 --> 00:47:58,900
પરંતુ તે HTTP ઉપયોગ કરતું નથી.

692
00:47:58,900 --> 00:48:02,470
HTTP TCP / IP ને પર બાંધવામાં પ્રોટોકોલ એક ઉદાહરણ છે.

693
00:48:02,470 --> 00:48:07,820
આઇપી શાબ્દિક ઈન્ટરનેટ પ્રોટોકોલ થાય છે.

694
00:48:07,820 --> 00:48:11,500
દરેક કમ્પ્યુટર IP સરનામા હોય છે; તેઓ તે 4 આંકડાના US વસ્તુઓ છે

695
00:48:11,500 --> 00:48:16,510
192.168.2.1, અથવા જે ગમે; કે સ્થાનિક એક હોઇ શકે છે.

696
00:48:16,510 --> 00:48:23,390
પરંતુ તે એક IP સરનામાને પેટર્ન છે.

697
00:48:23,390 --> 00:48:29,060
તેથી કે DNS, ડોમેન નામ સેવા,

698
00:48:29,060 --> 00:48:33,410
કે એક વાસ્તવિક IP સરનામા પર google.com જેવી વસ્તુઓ અનુવાદ કરે છે.

699
00:48:33,410 --> 00:48:37,700
તેથી જો તમે એક URL માં કે IP સરનામું લખો, તો

700
00:48:37,700 --> 00:48:40,850
જે Google પર લઈ જશે, પરંતુ તમે તે વસ્તુઓ યાદ નથી કરતા હોય છે.

701
00:48:40,850 --> 00:48:45,470
તમે google.com પર બદલે યાદ કરતા હોય છે.

702
00:48:45,470 --> 00:48:51,560
અમે છેલ્લા વસ્તુ આ IP ના TCP ભાગ છે જ્યાં પોર્ટ છે.

703
00:48:51,560 --> 00:48:54,880
TCP વધુ કરે છે. તમે તમારા વેબ બ્રાઉઝર ચાલતું હોય છે, જેમ કે, તે વિશે વિચારો.

704
00:48:54,880 --> 00:48:58,670
કદાચ તમે થોડા ઇમેઇલ અરજી ચાલતા હોય છે;

705
00:48:58,670 --> 00:49:02,150
કદાચ તમે ઇન્ટરનેટ ચાલી ઉપયોગ કરે છે કેટલાક અન્ય કાર્યક્રમ છે.

706
00:49:02,150 --> 00:49:05,090
તેઓ બધા ઇન્ટરનેટ વપરાશ જરૂરી છે,

707
00:49:05,090 --> 00:49:08,100
પરંતુ તમારા કમ્પ્યુટર માત્ર 1 વાઇફાઇ કાર્ડ અથવા જે હોય છે.

708
00:49:08,100 --> 00:49:10,780
તેથી પોર્ટ અમે છૂટા પડ્યા કરવાનો છો કે જે રીતે છે

709
00:49:10,780 --> 00:49:13,550
આ કાર્યક્રમો ઇન્ટરનેટ વાપરવા માટે સક્ષમ છે કેવી રીતે.

710
00:49:13,550 --> 00:49:17,230
દરેક કાર્યક્રમ, તેના પર સાંભળવા કરી શકો છો કે 1 ચોક્કસ પોર્ટ નહીં

711
00:49:17,230 --> 00:49:19,670
અને મૂળભૂત રીતે, HTTP પોર્ટ 80 વાપરે છે.

712
00:49:19,670 --> 00:49:22,410
કેટલાક ઇમેઇલ સેવાઓ 25 વાપરો.

713
00:49:22,410 --> 00:49:24,490
આ ઓછી નંબર મુદ્દાઓ માટે અનામત હોય છે.

714
00:49:24,490 --> 00:49:29,270
તમે સામાન્ય રીતે તમારી જાતને માટે ઉંચા નંબર મુદ્દાઓ વિચાર કરવાનો છે.

715
00:49:29,270 --> 00:49:32,010
>> સીએસએસ, કેસ્કેડીંગ સ્ટાઇલ શીટ્સ.

716
00:49:32,010 --> 00:49:36,030
સીએસએસ સાથે અમે શૈલી વેબ પાનાંઓ, બિન HTML સાથે.

717
00:49:36,030 --> 00:49:38,440
તમે તમારા સીએસએસ મૂકી શકો છો 3 સ્થાનો.

718
00:49:38,440 --> 00:49:46,300
તે શૈલી ટૅગ્સ વચ્ચે, અથવા એક સંપૂર્ણપણે અલગ ફાઈલોમાં અને પછી સાઇન કડી થયેલ છે, ઇનલાઇન હોઇ શકે છે

719
00:49:46,300 --> 00:49:48,470
અને અહીં માત્ર સીએસએસ એક ઉદાહરણ છે.

720
00:49:48,470 --> 00:49:50,450
તમે આ પેટર્ન ઓળખી જોઈએ,

721
00:49:50,450 --> 00:49:54,310
પ્રથમ ઉદાહરણ અમે શરીર ટેગ બંધબેસતી છો થયેલ છે

722
00:49:54,310 --> 00:49:56,680
અને અહીં આપણે શરીરના ટેગ કેન્દ્રમાં રહ્યા છો.

723
00:49:56,680 --> 00:50:00,420
બીજા ઉદાહરણ તરીકે, અમે આ વસ્તુ બંધબેસતા આવે છે

724
00:50:00,420 --> 00:50:04,740
ID ને ફૂટર, અને અમે તે માટે કેટલાક પ્રકારો અરજી કરી રહ્યા છો.

725
00:50:04,740 --> 00:50:07,310
ડાબી કે ID ને ફૂટર લખાણ ગોઠવે નોંધ કરો,

726
00:50:07,310 --> 00:50:09,840
શરીર લખાણ ગોઠવે કેન્દ્ર જ્યારે.

727
00:50:09,840 --> 00:50:13,180
ફૂટર શરીર અંદર છે.

728
00:50:13,180 --> 00:50:16,470
તે તેના બદલે, લખાણ સંરેખિત શરીર લખાણ સંરેખિત કેન્દ્ર કહે છે, છતાં પણ બાકી છે.

729
00:50:16,470 --> 00:50:18,880
આ સમગ્ર અસ્ખલિત ભાગ છે.

730
00:50:18,880 --> 00:50:22,110
તમે કરી શકો છો - તમે શરીર માટે શૈલીઓ સ્પષ્ટ કરી શકો છો,

731
00:50:22,110 --> 00:50:25,320
અને પછી શરીરમાં વસ્તુઓ તમે વધુ ચોક્કસ પ્રકારો સ્પષ્ટ કરી શકો છો,

732
00:50:25,320 --> 00:50:28,160
અને વસ્તુઓ તમે અપેક્ષા તરીકે કામ કરે છે.

733
00:50:28,160 --> 00:50:34,420
વધુ ચોક્કસ સીએસએસ સ્પષ્ટ પ્રાધાન્ય મેળવે છે.

734
00:50:34,420 --> 00:50:46,140
હું તે છે લાગે છે.

735
00:50:46,140 --> 00:50:49,260
>> [અલી Nahm] હાય દરેકને. હું માત્ર તમારા ધ્યાન વિચાર કરી શકે છે.

736
00:50:49,260 --> 00:50:53,990
હું અલી છું અને હું ખરેખર ઝડપી PHP અને SQL મારફતે જાઓ જાઉં છું.

737
00:50:53,990 --> 00:51:00,310
તેથી અમે શરૂ કરી શકો છો. PHP, PHP, માટે ટૂંકા હોય છે: હાઇપરટેક્સ્ટ preprocessor.

738
00:51:00,310 --> 00:51:03,730
તમે બધા જાણવું જોઈએ છે, તે કોઈ સર્વર બાજુ સ્ક્રિપ્ટીંગ ભાષા છે,

739
00:51:03,730 --> 00:51:06,800
અને અમે વેબસાઇટ્સ પાછળ ઓવરને માટે વાપરવા માટે,

740
00:51:06,800 --> 00:51:12,540
અને તે ગણતરીઓ, પાછળનું દ્રશ્યો ભાગ ઘણો કરે છે.

741
00:51:12,540 --> 00:51:17,510
સિન્ટેક્સ. તે સી, આશ્ચર્યજનક આશ્ચર્ય, જેમ નથી.

742
00:51:17,510 --> 00:51:22,060
હું આગળ વધી શકો નહિં - તે હંમેશા તમે જોઈ શકો છો જો, આ સાથે શરૂ થાય છે.

743
00:51:22,060 --> 00:51:31,340
તમે કૌંસ નવા પ્રકારના જરૂર જોઈ શકો છો અને પછી તમે પણ? PHP જરૂર છે.

744
00:51:31,340 --> 00:51:35,780
એટલે કે, તમે તમારા PHP લખાણ, તમારા PHP કોડ ફ્રેમની છે કેવી રીતે હંમેશા છે.

745
00:51:35,780 --> 00:51:39,180
તેથી તે માત્ર તમે પ્રકારની પ્રથમ તેના પર મૂકવામાં જ્યાં સી, જેમ ન હોઈ શકે.

746
00:51:39,180 --> 00:51:42,290
તમે હંમેશા તેને ફરતે જરૂર છે.

747
00:51:42,290 --> 00:51:47,610
અને હવે, મુખ્ય વાક્યરચના બધા ચલો $ પાત્ર સાથે શરૂ કરવાની જરૂર છે.

748
00:51:47,610 --> 00:51:49,490
તમારી પાસે વ્યાખ્યાયિત કરી રહ્યા હો ત્યારે તે કરવા જરૂર છે; તમે તે કરી જરૂર

749
00:51:49,490 --> 00:51:51,860
તમે પાછળથી તેમને ઉલ્લેખ કરી રહ્યાં છો છે.

750
00:51:51,860 --> 00:51:56,510
તમે હંમેશા કે $ જરૂર છે. તે ખરેખર ખૂબ, તમારા નવા શ્રેષ્ઠ મિત્ર છે.

751
00:51:56,510 --> 00:52:01,690
તમે નથી - સી જેમ નહિં પણ, તમે તેને છે ચલ પ્રકાર પ્રકારની શું મુકવાની જરૂર નથી.

752
00:52:01,690 --> 00:52:04,940
તમે $ જરૂર નથી, જ્યારે તેથી, જો તમે, પસંદ, મુકવાની જરૂર નથી

753
00:52:04,940 --> 00:52:09,470
પૂર્ણાંક એક્સ અથવા સ્ટ્રિંગ વાય વગેરે વગેરે, વગેરે વગેરે.

754
00:52:09,470 --> 00:52:11,490
તેથી થોડો તફાવત.

755
00:52:11,490 --> 00:52:15,590
આ પરિણામે, તે PHP નબળા પ્રકાર હોય છે.

756
00:52:15,590 --> 00:52:19,310
PHP નબળા પ્રકાર ભાષા છે, અને તે નબળું લખેલા ચલો છે.

757
00:52:19,310 --> 00:52:24,020
અન્ય શબ્દોમાં, કે જે તમે ચલ પ્રકારના વિવિધ પ્રકારના વચ્ચે ફેરબદલી કરી શકો છો છે.

758
00:52:24,020 --> 00:52:27,230
તમે પૂર્ણાંક તરીકે તમારી નંબર 1 સ્ટોર કરી શકો છો,

759
00:52:27,230 --> 00:52:29,650
તમે શબ્દમાળા તરીકે સ્ટોર કરી શકો છો, અને તમે તે ફ્લોટ તરીકે સ્ટોર કરી શકો છો,

760
00:52:29,650 --> 00:52:33,550
અને તે બધા કે જે નંબર 1 હશે.

761
00:52:33,550 --> 00:52:36,080
તમે વિવિધ સ્વરૂપો માં સ્ટોર કરી રહ્યાં છો તેમ છતાં,

762
00:52:36,080 --> 00:52:39,120
તે હજુ પણ છે - ચલ પ્રકારના હજુ અંતે હોલ્ડિંગ છે.

763
00:52:39,120 --> 00:52:41,540
તેથી તમે અહીં જુઓ, તમે 7 pset થી યાદ રાખો કે,

764
00:52:41,540 --> 00:52:43,500
તમે ઘણા કદાચ આ સાથે મુદ્દાઓ હતા.

765
00:52:43,500 --> 00:52:47,280
બે સમાન સંકેતો, 3 સમાન સંકેતો, 4 સમાન ચિહ્નો.

766
00:52:47,280 --> 00:52:49,990
ઠીક છે, કોઈ 4 સમાન સંકેતો છે, પરંતુ 2 અને 3 છે.

767
00:52:49,990 --> 00:52:53,320
તમે કિંમતો ચેક કરો 2 સમાન સંકેતો વાપરો.

768
00:52:53,320 --> 00:52:55,830
તે પ્રકારના સમગ્ર તપાસી શકો છો.

769
00:52:55,830 --> 00:52:58,770
તેથી જો તમે પ્રથમ ઉદાહરણ જોઈ શકો છો જો,

770
00:52:58,770 --> 00:53:02,210
હું num_int == num_string છે.

771
00:53:02,210 --> 00:53:06,710
તેથી તમારા પૂર્ણાંક અને તમારા શબ્દમાળા બંને છે, જે ટેકનિકલી, 1,

772
00:53:06,710 --> 00:53:10,790
પરંતુ તેઓ વિવિધ પ્રકારની છો. પરંતુ બે સમકક્ષ માટે, તે હજુ પણ પસાર કરશો.

773
00:53:10,790 --> 00:53:15,510
જો કે, ટ્રિપલ સમકક્ષ માટે, તે કિંમત તેમજ વિવિધ પ્રકારની ચકાસે છે.

774
00:53:15,510 --> 00:53:18,760
એટલે કે, તે અહીં છે કે બીજા કિસ્સામાં પસાર નથી ચાલી રહ્યું છે અર્થ એ થાય કે

775
00:53:18,760 --> 00:53:22,350
તમે તેના બદલે 3 સમાન સંકેતો ઉપયોગ કરી રહ્યાં છો છે.

776
00:53:22,350 --> 00:53:26,590
જેથી તમે બધા હવે દર્શાવે છે જોઈએ કે મુખ્ય તફાવત છે.

777
00:53:26,590 --> 00:53:31,570
>> શબ્દમાળા શૃંખલીકરણ તમે PHP ઉપયોગ કરી શકો છો અન્ય શક્તિશાળી વસ્તુ છે.

778
00:53:31,570 --> 00:53:34,080
તે મૂળભૂત રીતે માત્ર આ સરળ કોઈ નોટેશનમાં છે

779
00:53:34,080 --> 00:53:36,230
અને તે તમે શબ્દમાળાઓ સાથે બાંધે કરી શકો છો કેવી રીતે.

780
00:53:36,230 --> 00:53:40,800
તેથી જો તમે કેટ હોય છે અને તમે ડોગ હોય છે, અને તમે એક સાથે 2 શબ્દમાળાઓ મૂકવા માંગો છો,

781
00:53:40,800 --> 00:53:44,080
તમે આ સમયગાળા ઉપયોગ કરી શકો છો, અને તે કેવી રીતે કામ કરે પ્રકારની છે.

782
00:53:44,080 --> 00:53:46,660
તમે પણ માત્ર એકબીજા આગામી તેમને મૂકી શકો છો,

783
00:53:46,660 --> 00:53:49,030
તમે નીચે ઉદાહરણમાં અહીં જોઈ શકો છો,

784
00:53:49,030 --> 00:53:51,610
હું શબ્દમાળા 1, જગ્યા શબ્દમાળા 2 પડઘો છે કે જ્યાં.

785
00:53:51,610 --> 00:53:56,930
PHP, જેમ કે તેમને બદલવા માટે જાણતા હશે.

786
00:53:56,930 --> 00:53:59,780
એરે. હવે, PHP માં, એરે 2 અલગ અલગ પ્રકારના હોય છે.

787
00:53:59,780 --> 00:54:03,180
તમે નિયમિત એરે હોય શકે છે, અને તમે પણ સાહચર્યાત્મક એરે હોઇ શકે છે,

788
00:54:03,180 --> 00:54:06,040
અને અમે હમણાં તેમના મારફતે જાઓ રહ્યા છીએ.

789
00:54:06,040 --> 00:54:08,280
નિયમિત એરે, ફક્ત આ સી છે

790
00:54:08,280 --> 00:54:11,240
અને તેથી તમે નંબર છે કે સૂચકાંક છે.

791
00:54:11,240 --> 00:54:13,160
હમણાં અમે માત્ર એક બનાવી રહ્યું અને મૂકી રહ્યા છીએ -

792
00:54:13,160 --> 00:54:15,500
તેથી આ અમે ખાલી એરે કે કેવી છે, તો પછી અમે રહ્યા છીએ

793
00:54:15,500 --> 00:54:17,310
ઇન્ડેક્સ નંબર 0 મૂકવામાં.

794
00:54:17,310 --> 00:54:19,200
અમે 6 નંબર, 6 કિંમત મૂકી રહ્યા છીએ.

795
00:54:19,200 --> 00:54:21,500
તમે અહીં નીચે જોઈ શકો છો.

796
00:54:21,500 --> 00:54:24,240
Where's - ઇન્ડેક્સ નંબર 1 અમે કિંમત 4 નંબર મૂકી રહ્યા છીએ

797
00:54:24,240 --> 00:54:26,720
અને તેથી તમે 6 છે જોઈ શકે છે, એક 4, છે

798
00:54:26,720 --> 00:54:29,160
અને પછી અમે વસ્તુઓ છાપવા કરી રહ્યાં છો, કારણ કે

799
00:54:29,160 --> 00:54:33,550
અમે પ્રયત્ન કરો અને ઇન્ડેક્સ નંબર 0 પર સંગ્રહિત કિંમત છાપી છે,

800
00:54:33,550 --> 00:54:36,900
પછી અમે છપાયેલ રહી 6 કિંમત જોશો. કૂલ?

801
00:54:36,900 --> 00:54:40,160
જેથી તમે નિયમિત એરે છે.

802
00:54:40,160 --> 00:54:42,750
તમે પણ હવે નિયમિત એરે વસ્તુઓ ઉમેરી શકો છો બીજી રીતે

803
00:54:42,750 --> 00:54:44,780
તમે માત્ર ઓવરને અંતે તેમને ઉમેરી શકો છો.

804
00:54:44,780 --> 00:54:47,240
એટલે કે, તમે ચોક્કસ અનુક્રમણિકા સ્પષ્ટ કરવાની જરૂર નથી છે.

805
00:54:47,240 --> 00:54:51,000
તમે નંબર જોઈ શકો છો, અને પછી ચોરસ કૌંસમાં ત્યાં કોઈ સ્પષ્ટ અનુક્રમણિકા છે.

806
00:54:51,000 --> 00:54:56,270
અને તે જાણતા હશે - PHP, ફક્ત યાદી, આગામી મફત હાજર ઓવરને ઉમેરવા માટે તેને જાણતા હશે.

807
00:54:56,270 --> 00:54:59,190
તેથી તમે, કે 0 સ્થળે અધિકાર ત્યાં 1 જોઈ શકો છો

808
00:54:59,190 --> 00:55:02,690
2 પ્રથમ સ્થળે અધિકાર ત્યાં ગયા હતા.

809
00:55:02,690 --> 00:55:04,690
આ 3 જાય - ત્યાં તેમજ ઉમેરવામાં આવે છે.

810
00:55:04,690 --> 00:55:06,720
જેથી પ્રકારની અર્થમાં બનાવે છે. તમે હમણાં જ તે સતત ઉમેરી રહ્યાં છીએ,

811
00:55:06,720 --> 00:55:09,360
અને પછી અમે નંબર 1 ની અનુક્રમણિકા રિચર્ડના કરી રહ્યા હો ત્યારે

812
00:55:09,360 --> 00:55:13,080
તે કિંમત 2 છાપશે.

813
00:55:13,080 --> 00:55:16,800
>> પછી અમે સમૂહનો એરે છે કે એરે છે.

814
00:55:16,800 --> 00:55:19,370
તેના બદલે આંકડાકીય સૂચકાંકો કર્યા સમૂહનો એરે,,

815
00:55:19,370 --> 00:55:23,630
તેઓ શું તેઓ શબ્દમાળા દ્વારા હોય છે સૂચકાંકો હોય છે.

816
00:55:23,630 --> 00:55:25,670
શું તમે ને બદલે, જોઈ શકો છો - હું તે બધા નંબર સૂચકાંકો છુટકારો મેળવ્યો,

817
00:55:25,670 --> 00:55:32,140
અને હવે તે key1, key2, key3, અને તેઓ બધા શબ્દમાળાઓ છો મહત્વપૂર્ણ રીતે બે અવતરણચિહ્નો છો.

818
00:55:32,140 --> 00:55:34,470
તેથી અમે આ એક ઉદાહરણ હોઈ શકે છે.

819
00:55:34,470 --> 00:55:38,790
આ ઉદાહરણ આપણે ટીએફ હોય છે, અને તે ઇન્ડેક્સ નામ છે.

820
00:55:38,790 --> 00:55:42,030
અમે કેલરી યોગ્ય જે પણ, ઇન્ડેક્સ પર, નામ "અલી" મૂકી રહ્યા છીએ

821
00:55:42,030 --> 00:55:47,640
અમે તેના બદલે એક શબ્દમાળા પૂર્ણાંક આ સમય મૂકી શકો છો,

822
00:55:47,640 --> 00:55:52,240
અને પછી ઇન્ડેક્સ પસંદ અંતે, અમે તેની અંદર સમગ્ર એરે મૂકી શકો છો.

823
00:55:52,240 --> 00:55:55,490
તેથી આ પ્રકારની છે - તે અમે હતી કેવી રીતે એક સમાન વિભાવના છે

824
00:55:55,490 --> 00:55:58,930
સંખ્યામાં સૂચકાંકો, પરંતુ હવે અમે લગભગ સૂચકાંકો બદલી શકો છો

825
00:55:58,930 --> 00:56:03,890
તેના બદલે શબ્દમાળાઓ તરીકે તેમને હોય.

826
00:56:03,890 --> 00:56:06,070
તમે પણ માત્ર તે વ્યક્તિગત રીતે કરી ઉપરાંત, આ કરી શકો છો

827
00:56:06,070 --> 00:56:09,400
તમે એક ભાગ તે તમામ કરી શકો છો. તેથી તમે તે એરે કે ટીએફ જોઈ શકો છો

828
00:56:09,400 --> 00:56:13,350
અને પછી અમે એક વિશાળ ચોરસ કૌંસ સેટ તેમને બધા સુયોજિત કરો.

829
00:56:13,350 --> 00:56:15,220
જેથી વસ્તુઓને ઝડપથી કરી શકો છો.

830
00:56:15,220 --> 00:56:19,730
તે કરતાં શૈલીયુક્ત પસંદગી વધુ છે.

831
00:56:19,730 --> 00:56:21,550
અમે પણ આંટીઓ છે.

832
00:56:21,550 --> 00:56:26,020
સી અમે આ જેમ કામ કરે છે કે લૂપ છે.

833
00:56:26,020 --> 00:56:29,690
અમે અમારા એરે હતી, અને અમે યાદી ઓવરને માટે ઇન્ડેક્સ 0 થી ગયા,

834
00:56:29,690 --> 00:56:31,740
અને અમે, તો તે બધા છાપી?

835
00:56:31,740 --> 00:56:33,880
, સમસ્યા સમૂહનો એરે માટે, છે સિવાય

836
00:56:33,880 --> 00:56:36,610
અમે જરૂરી તે આંકડાકીય સૂચકાંકો ખબર નથી

837
00:56:36,610 --> 00:56:39,610
હવે અમે શબ્દમાળા સૂચકાંકો હોય છે.

838
00:56:39,610 --> 00:56:44,800
હવે અમે ફરીથી, તમે આસ્થાપૂર્વક 7 pset ઉપયોગમાં જે, foreach આંટીઓ, ઉપયોગ કરે છે.

839
00:56:44,800 --> 00:56:48,930
Foreach આંટીઓ ફક્ત યાદી દરેક એક ભાગ જાણતા હશે.

840
00:56:48,930 --> 00:56:52,450
અને તે કે તમારી પાસે બરાબર સંખ્યાત્મક ઇન્ડેક્સ ખબર નથી.

841
00:56:52,450 --> 00:56:56,490
તેથી જો તમે એરે મૂકી, તમે foreach વાક્યરચના છે, તેથી તેને foreach છે.

842
00:56:56,490 --> 00:57:00,430
જેથી મારી એરે pset કહેવામાં આવે છે, અને પછી તરીકે શબ્દ તરીકે

843
00:57:00,430 --> 00:57:04,530
અને પછી તમે ઉપયોગ કરવા જઈ રહ્યાં છો આ સ્થાનિક કામચલાઉ ચલ મૂકી

844
00:57:04,530 --> 00:57:10,690
માત્ર ચોક્કસ પકડી રહ્યું છે કે જે ચોક્કસ એ -

845
00:57:10,690 --> 00:57:14,770
એક ઉદાહરણ અથવા એરે એક વિભાગ.

846
00:57:14,770 --> 00:57:18,350
, Pset સંખ્યા 1 પકડી કરશે, અને પછી કદાચ તે 6 નંબર પકડી કરશે

847
00:57:18,350 --> 00:57:20,410
અને પછી તે 2 નંબર પકડી કરશે.

848
00:57:20,410 --> 00:57:26,630
પરંતુ તે એરે છે કે દરેક એક કિંમત મારફતે પસાર થવા માટે ખાતરી આપી છે.

849
00:57:26,630 --> 00:57:30,530
તમે PHP માં ખબર હોવી જોઇએ કે જે ઉપયોગી કાર્યો જરૂર છે,

850
00:57:30,530 --> 00:57:35,880
બહાર નીકળો, ખાલી, પડઘો તેથી, કે જેમાં તમે ચોક્કસ ફાઈલો સહિત રહ્યા છો સુનિશ્ચિત કરે છે કે.

851
00:57:35,880 --> 00:57:40,490
હું ખૂબ તમે 7 pset જોવા અને તે કાર્યો જુઓ ભલામણ કરીએ છીએ.

852
00:57:40,490 --> 00:57:42,810
તમે તે જાણતા હોય છે શકે છે,

853
00:57:42,810 --> 00:57:47,060
તેથી હું ચોક્કસપણે બરાબર, તે બધા શું કરી રહ્યા છે, ખબર છે.

854
00:57:47,060 --> 00:57:50,080
>> અને હવે અમે અવકાશ દ્વારા ખરેખર ઝડપથી જાઓ રહ્યા છીએ.

855
00:57:50,080 --> 00:57:53,490
અવકાશ માં, PHP,, સી જેમ નહિં પણ, એક ફંકી વસ્તુ પ્રકારની છે

856
00:57:53,490 --> 00:57:56,170
અને તેથી અમે માત્ર તે ઝડપથી પસાર થાય છે રહ્યા છીએ.

857
00:57:56,170 --> 00:57:58,930
તેથી આપણે આપણે ત્યાં છે કે કે તીર પર શરૂઆત કહો.

858
00:57:58,930 --> 00:58:02,900
અને અમે હું $ સાથે શરૂ રહ્યા છીએ. તેથી ચલ 'હું', 0 પ્રયત્ન રહ્યું છે

859
00:58:02,900 --> 00:58:06,730
અને અમે હમણાં જ ત્યાં પર તે મોટા સફેદ બોક્સમાં છાપી રાખવા જઈ રહ્યાં છો.

860
00:58:06,730 --> 00:58:09,220
અમે i0 સાથે શરૂ જઈ રહ્યાં છો, અને પછી અમે તેને પડઘો રહ્યા છીએ.

861
00:58:09,220 --> 00:58:12,670
તેથી 0 છે.

862
00:58:12,670 --> 00:58:15,210
અને પછી અમે આ માટે લૂપ દ્વારા તેને વધારતી જઈ રહ્યાં છો

863
00:58:15,210 --> 00:58:17,810
અને પછી તે 1 ની કિંમત જ હશે.

864
00:58:17,810 --> 00:58:20,070
, એક 3 કરતાં ઓછી છે, તેથી તે માટે લૂપ કે પસાર બનશે

865
00:58:20,070 --> 00:58:23,230
અને પછી અમે તેને ફરીથી છાપવામાં જોવા જઈ રહ્યાં છો.

866
00:58:23,230 --> 00:58:25,520
અમે 2 ફરીથી વધારો રહ્યા છીએ

867
00:58:25,520 --> 00:58:29,860
અને 2 3 કરતાં ઓછી છે, તેથી તે લૂપ માટે પસાર કરશો, અને તે 2 છાપો પડશે.

868
00:58:29,860 --> 00:58:35,100
પછી તમે 3 3 કરતાં ઓછી નથી નોંધ કરીશું, જેથી અમે લૂપ માટે તોડી પડશે.

869
00:58:35,100 --> 00:58:40,050
તેથી હવે અમે બહાર નીકળ્યા છે, અને પછી અમે aFunction જાય રહ્યા છીએ.

870
00:58:40,050 --> 00:58:45,010
ઠીક છે. તેથી જો તમે આ ચલ અમે બનાવી છે કે નોંધ કરો કે છે

871
00:58:45,010 --> 00:58:48,270
આ 'હું' ચલ, સ્થાનિક રીતે scoped નથી.

872
00:58:48,270 --> 00:58:50,280
આ તે લૂપ સ્થાનિક નથી અર્થ એ થાય કે,

873
00:58:50,280 --> 00:58:58,060
અને તે ચલ અમે હજુ ઍક્સેસ કરો અને પછીથી બદલવા માટે, અને તે હજુ પણ અસરકારક રહેશે કરી શકો છો.

874
00:58:58,060 --> 00:59:02,160
તમે હવે કાર્ય જાય તેથી, જો તમે, અમે આ 'હું' ચલ વાપરે છે તે જોશો

875
00:59:02,160 --> 00:59:05,320
અને અમે 'આઇ' + + + + વધારતી રહ્યા છીએ.

876
00:59:05,320 --> 00:59:09,410
તમે કે 'હું' ચલ નકલ છે કે, સી પર આધારિત છે, પ્રથમ તો, વિચારો છો.

877
00:59:09,410 --> 00:59:12,830
તે સાચું છે, કે જે સંપૂર્ણપણે અલગ વાત છે.

878
00:59:12,830 --> 00:59:16,560
અમે તેને છાપી તેથી, જ્યારે અમે છાપો રહ્યું છે, 'આઇ' + + + + છાપી રહ્યા છીએ કે 4,

879
00:59:16,560 --> 00:59:19,640
માફ - અને પછી અમે જઈ રહ્યાં છો.

880
00:59:19,640 --> 00:59:22,030
પછી અમે તે કાર્ય બહાર અંત જઈ રહ્યાં છો,

881
00:59:22,030 --> 00:59:24,820
અને અમે તે તીર હમણાં છે જ્યાં કરી રહ્યા છીએ.

882
00:59:24,820 --> 00:59:29,190
કે પછી, જો કે, કાર્ય 'હું' ની કિંમત બદલાઈ છતાં પણ અર્થ એ થાય કે,

883
00:59:29,190 --> 00:59:32,620
તે બહાર કાર્ય બદલી ન હતી,

884
00:59:32,620 --> 00:59:35,060
કાર્ય અલગ અવકાશ છે કારણ કે.

885
00:59:35,060 --> 00:59:38,960
એટલે કે, અમે 'આઇ' પડઘો છે, તે કાર્ય તક નથી બદલાઈ અર્થ એ થાય કે

886
00:59:38,960 --> 00:59:43,660
અને તેથી તે પછી અમે ફરી 3 છાપી રહ્યા છીએ.

887
00:59:43,660 --> 00:59:47,520
સી કરતાં PHP માં અવકાશ વિશે અલગ વસ્તુઓ

888
00:59:47,520 --> 00:59:51,130
>> હવે PHP અને HTML માં.

889
00:59:51,130 --> 00:59:53,510
PHP, વેબ પાનાંઓ ગતિશીલ બનાવવા માટે વપરાય છે.

890
00:59:53,510 --> 00:59:58,660
તે પ્રકારની વસ્તુઓ અલગ બનાવે છે.

891
00:59:58,660 --> 01:00:02,090
અમે HTML માંથી તેને અલગ અલગ હોય છે.

892
01:00:02,090 --> 01:00:05,230
HTML સાથે, અમે હંમેશા માત્ર કેવી રીતે રોબ દર્શાવ્યું જેમ જ સ્થિર વસ્તુ હોય છે,

893
01:00:05,230 --> 01:00:09,370
PHP, જ્યારે તમે વપરાશકર્તા છે જે પર આધારિત વસ્તુઓ બદલી શકો છો.

894
01:00:09,370 --> 01:00:11,830
હું આ છે તેથી, જો હું "તમે તરીકે પ્રવેશેલ હોય -" છે અને પછી નામ,

895
01:00:11,830 --> 01:00:14,420
અને હું નામ બદલી શકો છો. તેથી હમણાં નામ જોસેફ છે

896
01:00:14,420 --> 01:00:18,880
અને તે "મારા વિશે" એ છે પરંતુ પછી હું પણ ટોમી છે માટે નામ બદલી શકો છો.

897
01:00:18,880 --> 01:00:21,700
અને તે એક અલગ વસ્તુ હોઈ શકે છે.

898
01:00:21,700 --> 01:00:23,840
તેથી તો અમે પણ તેમને વિશે અલગ વસ્તુઓ બદલી શકો છો,

899
01:00:23,840 --> 01:00:27,070
અને તે નામ પર આધારિત વિવિધ સામગ્રી બતાવશે.

900
01:00:27,070 --> 01:00:31,430
તેથી PHP, પ્રકારની તમારી વેબસાઇટ ચાલી રહ્યું છે તે બદલી શકો છો.

901
01:00:31,430 --> 01:00:33,540
અહીં જ. તેમ છતાં, તેઓ અલગ અલગ સામગ્રી છે, નોંધ કરો કે

902
01:00:33,540 --> 01:00:38,870
તમે તકનીકી હજુ પણ સપાટી પર તે જ વેબ પૃષ્ઠ ઍક્સેસ હો તો પણ.

903
01:00:38,870 --> 01:00:43,450
એચટીએમએલ પેદા કરી. તમે આ કરી શકો છો કે જે 2 અલગ અલગ રીતે છે.

904
01:00:43,450 --> 01:00:48,980
તેથી અમે હવે તે યોગ્ય પસાર કરશો. પ્રથમ રીતે તમારી પાસે છે - હા, માફ કરશો.

905
01:00:48,980 --> 01:00:51,150
જેથી તમે માત્ર, PHP માં લૂપ માટે તમારા નિયમિત હોય છે

906
01:00:51,150 --> 01:00:56,270
અને પછી તમે PHP માં પડઘો અને તમે HTML એકો.

907
01:00:56,270 --> 01:00:58,720
રોબ એચટીએમએલ સ્ક્રિપ્ટ તમે દર્શાવે છે શું વાપરી રહ્યા છે

908
01:00:58,720 --> 01:01:04,030
અને પછી માત્ર વેબ પૃષ્ઠ પર છાપે માટે PHP, પ્રિન્ટ મદદથી.

909
01:01:04,030 --> 01:01:09,520
વૈકલ્પિક રીતે તમે PHP અને HTML ને અલગ જો તે કરવા છે.

910
01:01:09,520 --> 01:01:11,940
તેથી જો તમે લૂપ માટે શરૂ થાય છે PHP, એક લીટી કરી શકો છો

911
01:01:11,940 --> 01:01:16,020
પછી તમે એક અલગ વસ્તુ માં HTML ની ​​લીટી હોઇ શકે છે,

912
01:01:16,020 --> 01:01:19,700
અને પછી તમે PHP, સાથે, ફરીથી, આ લૂપ અંત.

913
01:01:19,700 --> 01:01:21,800
તેથી તે પ્રકારની તેને અલગ છે.

914
01:01:21,800 --> 01:01:24,020
ડાબી બાજુ પર, તમે તમારી પાસે શકે છે કે જે બધા -

915
01:01:24,020 --> 01:01:26,360
તે PHP, માત્ર 1 ભાગ છે.

916
01:01:26,360 --> 01:01:28,510
જમણી પર તમે, તમે PHP ની એક લાઇન છે કે જોઈ શકો છો

917
01:01:28,510 --> 01:01:32,540
તમે HTML ની ​​એક લાઇન છે, અને તમે ફરીથી PHP ની એક લાઇન છે.

918
01:01:32,540 --> 01:01:36,870
તેથી તેઓ શું કરી રહ્યાં છો તેને બહાર અલગ પડે છે.

919
01:01:36,870 --> 01:01:39,330
અને તમે તે ક્યાં રીતે, તેમને ક્યાં માટે નોંધ પડશે

920
01:01:39,330 --> 01:01:41,980
તેઓ હજુ પણ છબી છાપે, ઇમેજ, ઇમેજ,

921
01:01:41,980 --> 01:01:44,540
તેથી તે HTML હજુ પણ તે જ રીતે છપાયેલી હોય છે.

922
01:01:44,540 --> 01:01:49,870
અને પછી તો તમે હજુ પણ 3 છબીઓ તમારી વેબસાઇટ પર જોવા જોશો.

923
01:01:49,870 --> 01:01:52,820
તેથી તે જ વસ્તુ કરી અને 2 અલગ અલગ રીતે છે.

924
01:01:52,820 --> 01:01:55,060
>> હવે અમે સ્વરૂપો અને વિનંતીઓ છે. રોબ, તમે દર્શાવે છે

925
01:01:55,060 --> 01:01:59,400
ત્યાં HTML ની ​​સ્વરૂપો છે, અને અમે ફક્ત આ મારફતે સમીર આવશે.

926
01:01:59,400 --> 01:02:02,040
તમે એક ક્રિયા છે અને તમે એક પદ્ધતિ છે, અને તમારા ક્રિયા

927
01:02:02,040 --> 01:02:04,350
પ્રકારની તમે તેને મોકલી રહ્યા છીએ જ્યાં તમે બતાવે છે, અને પદ્ધતિ છે કે શું

928
01:02:04,350 --> 01:02:06,960
તે વિચાર અથવા POST જ હશે.

929
01:02:06,960 --> 01:02:11,220
અને એક વિચાર વિનંતી, રોબ જણાવ્યું હતું કે, જો તમે ફોર્મ માં મૂકી રહ્યા છીએ કે જે થાય છે

930
01:02:11,220 --> 01:02:15,760
POST વિનંતી તમે એક URL જોઈ શકશો નહિં જ્યારે અને તમે એક URL તરીકે જોશો.

931
01:02:15,760 --> 01:02:17,840
તેથી થોડો તફાવત.

932
01:02:17,840 --> 01:02:19,950
જો કે, એક જ વાત છે કે એક વસ્તુ

933
01:02:19,950 --> 01:02:22,560
પોસ્ટ મેળવો સમાન અસુરક્ષિત છે.

934
01:02:22,560 --> 01:02:26,430
તેથી તમે માત્ર કારણ કે તમે તે URL માં દેખાય નહિં કે વિચારી શકે છે

935
01:02:26,430 --> 01:02:28,790
કે, પોસ્ટ વધુ સુરક્ષિત છે થાય છે

936
01:02:28,790 --> 01:02:34,420
પરંતુ તમે હજુ પણ તમે મોકલી રહ્યા છો તે માહિતી તમારી કૂકીઝ માં તે જોઈ શકે છે.

937
01:02:34,420 --> 01:02:38,260
જેથી લાગતું નથી એક અથવા બીજા.

938
01:02:38,260 --> 01:02:42,160
નોંધ કરવા માટે બીજો વસ્તુ તમે પણ કલમ ચલો હોય છે.

939
01:02:42,160 --> 01:02:45,850
તમે ગાય્સ તમારા વપરાશકર્તા ID ને માહિતી મેળવી 7 pset આ ઉપયોગ થાય છે.

940
01:02:45,850 --> 01:02:48,550
શું થયું જો તમે આ સમૂહનો એરે ઉપયોગ કરી શકો છો હતી,

941
01:02:48,550 --> 01:02:53,310
આ _SESSION $, અને પછી તમે વિવિધ વસ્તુઓ વાપરવા માટે સમર્થ હશો

942
01:02:53,310 --> 01:02:57,720
અને પાનાંઓ સમગ્ર અલગ વસ્તુઓ સ્ટોર કરે છે.

943
01:02:57,720 --> 01:03:00,750
>> છેલ્લું વસ્તુ, અમે એસક્યુએલ, સ્ટ્રક્ચર્ડ ક્વેરી લેંગ્વેજ હોય ​​છે

944
01:03:00,750 --> 01:03:04,360
અને આ ડેટાબેઝને મેનેજ કરવા માટે એક પ્રોગ્રામિંગ ભાષા છે.

945
01:03:04,360 --> 01:03:08,220
બરાબર, ડેટાબેઝો શું છે? તેઓ કોષ્ટકો સંગ્રહ કરશો,

946
01:03:08,220 --> 01:03:10,630
અને દરેક કોષ્ટક પદાર્થો સમાન પ્રકારના હોઈ શકે છે.

947
01:03:10,630 --> 01:03:14,990
તેથી અમે તમારી નાણા pset વપરાશકર્તાઓ એક ટેબલ હતી.

948
01:03:14,990 --> 01:03:20,610
અને શા માટે તેઓ ઉપયોગી છે? તે કાયમ માટે માહિતી સંગ્રહિત એક માર્ગ છે કારણ કે.

949
01:03:20,610 --> 01:03:22,840
તે વસ્તુઓ ટ્રેકિંગ અને વસ્તુઓ વ્યવસ્થા એક માર્ગ છે

950
01:03:22,840 --> 01:03:25,890
અને ખરેખર વિવિધ પૃષ્ઠો અને રાખવા ટ્રેક પર દેખાઈ રહ્યું છે.

951
01:03:25,890 --> 01:03:29,930
જ્યારે તમે માત્ર એક કે તાત્કાલિક ક્ષણે સંગ્રહે જો

952
01:03:29,930 --> 01:03:33,720
અને પછી પાછળથી વાપરવા માટે, તમે સાચવી લીધો છે જે કંઇ પણ વાપરવા માટે સમર્થ હશે નહિં.

953
01:03:33,720 --> 01:03:37,660
અમે એસક્યુએલ આદેશો માટે ઉપયોગ કરે છે 4 મુખ્ય વસ્તુઓ હોય છે.

954
01:03:37,660 --> 01:03:40,190
અમે પસંદ કરો, સામેલ કરો, કાઢી નાખો અને અપડેટ છે.

955
01:03:40,190 --> 01:03:42,880
તે તમને ગાય્ઝ તમારા ક્વિઝ માટે ખબર માટે ખરેખર મહત્વપૂર્ણ છે.

956
01:03:42,880 --> 01:03:45,990
>> અમે ઝડપથી હમણાં પર કરો જઈશ.

957
01:03:45,990 --> 01:03:48,540
મૂળભૂત રીતે, તમે એક ડેટાબેઝમાંથી પંક્તિઓ પસંદ કરી રહ્યા છીએ.

958
01:03:48,540 --> 01:03:52,400
તેથી તમે અહીં હોય તો -

959
01:03:52,400 --> 01:03:56,740
અમે આ 2 અલગ અલગ બાબતો છે, અને અમે વર્ગો ટેબલ પસંદ કરવા માંગો છો

960
01:03:56,740 --> 01:04:01,480
જ્યાં અદ્ભુત - પાંચ અદ્ભુત સ્તંભમાં કિંમત 1 છે.

961
01:04:01,480 --> 01:04:04,460
તમે અહીં જોઈ શકો છો તેથી, અમે વર્ગ નામ આ 2 વસ્તુઓ હોય છે

962
01:04:04,460 --> 01:04:08,490
CS50 અને Stat110, અને અમે વર્ગ ID અને સૂત્ર છે.

963
01:04:08,490 --> 01:04:13,150
તેથી અમે તે બધી માહિતી પસંદ કરો.

964
01:04:13,150 --> 01:04:17,480
પછી તમે તે પ્રકારની છે કે અદ્ભુત સ્તંભ બહાર ચૂંટવું છે કે અહીં જોઈ શકો છો

965
01:04:17,480 --> 01:04:25,170
બધી વસ્તુઓ 1 છે, અને પછી તે વર્ગ ID ને, વર્ગ નામ અને તેને પસંદ કરી શકો છો કે સૂત્ર છે જ્યાં.

966
01:04:25,170 --> 01:04:28,100
તમે આ કોડમાં કેવી રીતે બરાબર કરે છે? તમે PHP, ઉપયોગ કરે છે.

967
01:04:28,100 --> 01:04:33,830
જેથી પ્રકારની PHP અને SQL દરેક અન્ય સંબંધિત છે કેવી રીતે.

968
01:04:33,830 --> 01:04:38,130
હવે અમે અમારા કોડ છે, અને અમે અમારા ક્વેરી વિધેય વાપરી રહ્યા છીએ

969
01:04:38,130 --> 01:04:41,370
અમે 7 pset કર્યું હતું, અને અમે એસક્યુએલ ક્વેરી સ્કોર રહ્યા છીએ રિલીઝ.

970
01:04:41,370 --> 01:04:43,870
પછી અમે હોય રહ્યા છીએ -

971
01:04:43,870 --> 01:04:46,280
અમે હંમેશા ખોટા હોય ની પંક્તિ ટ્રિપલ સમાન તે ચકાસવા માટે છે.

972
01:04:46,280 --> 01:04:49,010
તેથી ફરી, તો તમે પ્રકાર અને કિંમત તપાસ કરવા માંગો છો,

973
01:04:49,010 --> 01:04:53,880
તે કામ ન કરે અને પછી જો, તો પછી તમે અમે 7 pset કર્યું હતું, હંમેશની જેમ, દિલગીર છીએ માંગો છો.

974
01:04:53,880 --> 01:04:55,870
નહિં તો, તમે તે હાથમાં સાથે બધું મારફતે લૂપ માટે કરવા માંગો છો

975
01:04:55,870 --> 01:04:59,410
foreach અમે માત્ર ગયા આંટીઓ.

976
01:04:59,410 --> 01:05:01,280
, અમે મારફતે રહ્યાં છીએ અને અમે ભૂતકાળમાં તે કર્યા છે હવે

977
01:05:01,280 --> 01:05:05,080
આપણે આપણા ક્વેરી પસાર કરી રહ્યો છે દો, હવે અમે અમારા foreach લૂપ છે.

978
01:05:05,080 --> 01:05:11,050
અને પ્રથમ પંક્તિ તે છે, તેથી અહીં પંક્તિ અહીં, છે, તે સંયોજિત છે.

979
01:05:11,050 --> 01:05:14,010
તે મેળવેલ છે કે બધી માહિતી છાપે બનશે.

980
01:05:14,010 --> 01:05:18,070
તેથી તે નીચે છાપે ચાલી રહ્યું છે "Wanna લર્ન HTML?"

981
01:05:18,070 --> 01:05:23,370
તે લૂપ માટે પ્રથમ પૂર્ણ છે, કારણ કે પછી તે, આગામી પંક્તિ પર જાઓ ચાલી રહ્યું છે

982
01:05:23,370 --> 01:05:26,510
અને તેથી તે પછી તે, તે બીજા રેખા છાપો ચાલી રહ્યું છે

983
01:05:26,510 --> 01:05:32,120
STAT110 કરી રહ્યું છે, જે તમામ પળો શોધો.

984
01:05:32,120 --> 01:05:34,290
>> એક છેલ્લા વસ્તુ એસક્યુએલ નબળાઈઓ છે.

985
01:05:34,290 --> 01:05:37,300
હું ડેવિડ આ વ્યાખ્યાન થોડો સપાટીએ બંધ રહ્યો હતો છો.

986
01:05:37,300 --> 01:05:40,730
તમે પછીથી આ વાંચી શકે છે. તે ખરેખર રમૂજી છે.

987
01:05:40,730 --> 01:05:45,320
એસક્યુએલ ઇન્જેક્શન કાવતરાબાજ વસ્તુ એક પ્રકાર છે.

988
01:05:45,320 --> 01:05:49,890
તમે માત્ર તમારા ક્વેરી માં તે ચલો વળગી કે હવે કહો,

989
01:05:49,890 --> 01:05:52,290
તમે તે પ્રથમ વાક્ય માં જોઈ શકો છો.

990
01:05:52,290 --> 01:05:54,520
તેથી તે, દંડ લાગે છે? તમે ફક્ત વપરાશકર્તા નામ આપી રહ્યા છીએ

991
01:05:54,520 --> 01:05:58,820
અને તમારા એસક્યુએલ ક્વેરી માટે પાસવર્ડ, અને તમે તેને બંધ જહાજ અને તમારા ડેટા ટેબલ માં ગમે મેળવવા માંગો છો.

992
01:05:58,820 --> 01:06:01,450
કે ખૂબ સરળ લાગે છે. તેથી, કોઈને માં મૂકે છે કહી દે

993
01:06:01,450 --> 01:06:04,910
પાસવર્ડ માટે, આ અથવા લખાણ અહીં -

994
01:06:04,910 --> 01:06:06,780
વાસ્તવમાં Red બોક્સમાં પ્રયત્ન કરીશું.

995
01:06:06,780 --> 01:06:11,920
તેથી આપણે તેઓ માં કે પાસવર્ડ મૂકે છે કહે છે કે દો - કે તેઓ દાખલ છે.

996
01:06:11,920 --> 01:06:16,520
તેથી તેઓ મૂકવા અથવા "1" = 1 રહ્યા છો.

997
01:06:16,520 --> 01:06:20,880
હોય કોઈ પાસવર્ડ કાઇન્ડ.

998
01:06:20,880 --> 01:06:25,070
હવે આપણે માત્ર તેને બદલવા, અને તમે હવે એસક્યુએલ ક્વેરી કે નોંધ પડશે,

999
01:06:25,070 --> 01:06:29,090
તમે નોંધ પડશે, કારણ કે તે હંમેશા સાચું માટે મૂલ્યાંકન કે

1000
01:06:29,090 --> 01:06:32,240
તમે એસક્યુએલ ક્વેરી આ બધી જાણકારી પસંદ કરી શકો છો

1001
01:06:32,240 --> 01:06:35,420
અથવા તમે માત્ર 1 = 1 હોઈ શકે છે.

1002
01:06:35,420 --> 01:06:41,030
જેથી હંમેશા સાચી માટે મૂલ્યાંકન ચાલી રહ્યું છે.

1003
01:06:41,030 --> 01:06:46,610
કે હેકર તમારી સિસ્ટમ તોડી શકે છે, કારણ કે ખરેખર કામ નથી ચાલી રહ્યું છે.

1004
01:06:46,610 --> 01:06:49,300
આ ઉકેલ તમે PDO સિસ્ટમ ઉપયોગ કરે છે કે જે,

1005
01:06:49,300 --> 01:06:51,360
જે, તમે પ્રશ્ન ગુણ ઉપયોગ કરે છે કે જે થાય છે

1006
01:06:51,360 --> 01:06:53,350
શું તમે 7 pset ઉપયોગમાં ગાય્સ, કે જે

1007
01:06:53,350 --> 01:06:57,620
શું તમે ખરેખર કંઈક મૂકેલ જ્યાં જગ્યાએ પ્રશ્ન ચિહ્ન ઉપયોગ જઈ રહ્યાં છો જ્યાં,

1008
01:06:57,620 --> 01:07:01,430
અને, પછી તમે અલ્પવિરામ છે જઈ રહ્યાં છો, અને પછી તમે પછીથી પડશે

1009
01:07:01,430 --> 01:07:07,610
તમારા શબ્દમાળા પછી, તમે કરવા માંગો છો કે જે વિવિધ ચલો તમારા પ્રશ્ન ચિહ્ન માં બદલવા માટે.

1010
01:07:07,610 --> 01:07:10,330
તેથી તમે હવે હું આ લાલ પ્રશ્ન ચિહ્ન છે કે અહીં નોંધ પડશે.

1011
01:07:10,330 --> 01:07:15,420
હું પછીથી તે ક્રમમાં તેમને બદલવા માટે ખબર તેથી તો હું મારા શબ્દમાળાઓ પછી ચલો મૂકી.

1012
01:07:15,420 --> 01:07:18,470
કોઈને આ રીતે કરે છે કે, જો તેની ખાતરી કરશે

1013
01:07:18,470 --> 01:07:24,050
અને તેઓ ખાતરી કરો કે, અથવા 1 = 1 પરિસ્થિતિ છે

1014
01:07:24,050 --> 01:07:30,490
પાછળ અંતે, તે ખરેખર એસક્યુએલ ક્વેરી તોડી નહીં કરે તેની ખાતરી કરો.

1015
01:07:30,490 --> 01:07:33,660
ઠીક છે, PHP અને SQL એક વાવંટોળ, તે ખૂબ ખૂબ તે છે.

1016
01:07:33,660 --> 01:07:41,520
તમે બધા માટે નસીબ શ્રેષ્ઠ છે, અને હવે ઓર માટે

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] ઠીક દરેકને. કેટલાક જાવાસ્ક્રિપ્ટ પર જાઓ સમય

1018
01:07:44,270 --> 01:07:48,840
અને કેટલાક અન્ય વસ્તુઓ ખૂબ જ ઝડપથી જેથી અમે તમને આજે રાત્રે સમાવી નથી.

1019
01:07:48,840 --> 01:07:56,930
જાવાસ્ક્રિપ્ટ. હા. જાવાસ્ક્રિપ્ટ કરવાથી, એક સરસ વસ્તુ પ્રકાર છે.

1020
01:07:56,930 --> 01:07:59,090
તમે ખરેખર જાવાસ્ક્રિપ્ટ વિશે જાણવાની જરૂર છે આ વસ્તુઓ, તે પ્રકારના જેવું છે

1021
01:07:59,090 --> 01:08:03,810
તમારી વેબ એપ્લિકેશન કરી કરી રહ્યા છે તે ક્લાઈન્ટ બાજુ અંત થાય છે.

1022
01:08:03,810 --> 01:08:08,280
તમે માત્ર સર્વર બાજુ પર બધા સમય કાળજી લેવા નથી માંગતા કેટલીક વસ્તુઓ છે.

1023
01:08:08,280 --> 01:08:12,880
બધા થોડી પ્રક્રિયાઓ, એક વસ્તુ હાયલાઇટ કંઈક થઈ જાય છે બનાવે છે.

1024
01:08:12,880 --> 01:08:15,340
તમે ખરેખર તમારા સર્વર પર તે માટે તમામ સમય વાત કરવા માંગો છો નથી.

1025
01:08:15,340 --> 01:08:18,069
અને તે કેટલાક સર્વર બાજુ પર શું પણ શક્ય નથી.

1026
01:08:18,069 --> 01:08:21,899
અમે જાવાસ્ક્રિપ્ટ કંઈક જરૂર શા માટે છે.

1027
01:08:21,899 --> 01:08:24,359
જાવાસ્ક્રિપ્ટ વિશે કૂલ વસ્તુઓ: તે ગતિશીલ લખ્યો છે.

1028
01:08:24,359 --> 01:08:27,149
આનો અર્થ એ છે તમારા કાર્યક્રમ જાણવા જરૂર નથી છે

1029
01:08:27,149 --> 01:08:30,970
તમે તેને લખી ત્યારે શું, બરાબર, ચલો છે.

1030
01:08:30,970 --> 01:08:34,510
તે ચાલી રહ્યું છે કારણ કે તે માત્ર સૉર્ટ તે એ સમજી શકશો.

1031
01:08:34,510 --> 01:08:37,520
તે વિશે સરસ છે કે અન્ય વસ્તુઓ: તે સર્પાકાર તાણવું ભાષા છે,

1032
01:08:37,520 --> 01:08:41,359
જે વાક્યરચના સી અને PHP જેવું જ છે થાય છે.

1033
01:08:41,359 --> 01:08:47,050
તમે જાવાસ્ક્રિપ્ટ શીખી રહ્યા ત્યારે ખૂબ પુનઃકાર્ય કરવું નથી.

1034
01:08:47,050 --> 01:08:49,180
અહીં અમે જાવાસ્ક્રિપ્ટ એક થોડો હોય છે.

1035
01:08:49,180 --> 01:08:52,560
અહીં રસપ્રદ બાબત એ છે કે, તો તમે તેને જોવા, છે

1036
01:08:52,560 --> 01:08:56,330
અમે વડા ટેગ માં અહિ જાવાસ્ક્રિપ્ટ એક બીટ છે.

1037
01:08:56,330 --> 01:08:59,479
શું છે મૂળભૂત રીતે માત્ર એક જાવાસ્ક્રિપ્ટ ફાઈલ સમાવેશ થાય છે નથી.

1038
01:08:59,479 --> 01:09:02,260
આ તમે તમારા પ્રોગ્રામમાં જાવાસ્ક્રિપ્ટ સમાવેશ કરી શકે છે એક રીત છે.

1039
01:09:02,260 --> 01:09:06,910
પછી બીજા થોડો વાસ્તવમાં કેટલાક ઇનલાઇન જાવાસ્ક્રિપ્ટ છે

1040
01:09:06,910 --> 01:09:10,790
ખૂબ સીએસએસ સાથે ઇનલાઇન શૈલી જેવી જ છે,

1041
01:09:10,790 --> 01:09:16,180
અને તમે માત્ર ખૂબ જ ઝડપથી ત્યાં અમુક કોડ લખી રહ્યાં.

1042
01:09:16,180 --> 01:09:18,120
જાવાસ્ક્રિપ્ટ એરે છે.

1043
01:09:18,120 --> 01:09:20,850
ખૂબ જ ઉપયોગી છે, આસપાસ માહિતી રાખવા માત્ર બીજી રીતે.

1044
01:09:20,850 --> 01:09:25,180
ખૂબ જ સરસ અને સરળ વાક્યરચના.

1045
01:09:25,180 --> 01:09:29,870
તમે બધું ઍક્સેસ અને બધું મળીને રાખો ચોરસ કૌંસ વાપરો.

1046
01:09:29,870 --> 01:09:35,020
ખૂબ જટિલ કંઈ નથી.

1047
01:09:35,020 --> 01:09:38,630
સામાન્ય રીતે જાવાસ્ક્રીપ્ટ અને સ્ક્રિપ્ટીંગ ભાષાઓ વિશે કૂલ વસ્તુ

1048
01:09:38,630 --> 01:09:40,920
તમે એરે કદ અંગે ચિંતા કરવાની જરૂર નથી.

1049
01:09:40,920 --> 01:09:43,880
તમે હમણાં જ array.length વાપરો અને તેને સાચવી રાખે છે,

1050
01:09:43,880 --> 01:09:46,960
અને એ પણ એરે વધવા અથવા તમે તેને જરૂર છે સંકોચી શકો છો.

1051
01:09:46,960 --> 01:09:49,279
તેથી તમે પણ કોઇ પણ પ્રકારની ચિંતા કરવાની જરૂર નથી

1052
01:09:49,279 --> 01:09:57,050
ઓહ ના, હું વધુ બાબતો છે, અથવા જેમ કંઈપણ ફાળવણી કરવાની જરૂર છે.

1053
01:09:57,050 --> 01:10:00,090
>> અહીં આ ઠંડી વસ્તુ જાવાસ્ક્રિપ્ટ પદાર્થો કહેવાય છે તેની ધરાવે છે.

1054
01:10:00,090 --> 01:10:04,800
તે ભાષા પદાર્થ આધારિત છે, તેથી તે છે શું, અનિવાર્યપણે,

1055
01:10:04,800 --> 01:10:10,100
ગ્રુપ માહિતી માટે તમારા માટે એક માર્ગ સાથે, સ્ટ્રક્ટ જેવો,

1056
01:10:10,100 --> 01:10:17,280
પરંતુ તમે તેને સ્ટ્રક્ટ કે એક સમૂહનો એરે વાક્યરચના માં ઍક્સેસ કરી શકો છો.

1057
01:10:17,280 --> 01:10:22,520
તે ખૂબ સરળ છે અને તમે શું આ સાથે કરી શકો છો સાથે જૂથ માહિતી છે

1058
01:10:22,520 --> 01:10:24,810
તમે સંબંધિત છે કે માહિતી સમૂહ હોય છે.

1059
01:10:24,810 --> 01:10:26,850
તે તમને એક કાર વર્ણન કરવાની જરૂર છે તે બધું છે, કારણ કે

1060
01:10:26,850 --> 01:10:29,050
તમે વિવિધ સ્થળોએ સમૂહ માં તેની પાસે જરૂર નથી.

1061
01:10:29,050 --> 01:10:35,300
તમે તેને જાવાસ્ક્રિપ્ટ 1 ઑબ્જેક્ટ માં ચોંટાડી શકો છો.

1062
01:10:35,300 --> 01:10:39,090
તમે કદાચ ખબર, વારો તે જટિલ ક્રિયાઓ છે.

1063
01:10:39,090 --> 01:10:43,810
તમે હમણાં જ ફરી એક ઓવર પર કામ કરે છે. તમે કાર દરેક પદાર્થ સાથે વાત કરવાની જરૂર છે

1064
01:10:43,810 --> 01:10:47,340
અથવા તમે યાદી અથવા તે કંઈક દરેક વસ્તુ મારફતે પણ જરૂર નથી.

1065
01:10:47,340 --> 01:10:51,770
તેથી જાવાસ્ક્રિપ્ટ, PHP, એક foreach સિન્ટેક્ષ જેવી જ છે.

1066
01:10:51,770 --> 01:10:54,590
આ કિસ્સામાં, તે લુપમાં માટે છે.

1067
01:10:54,590 --> 01:10:57,300
તમે માત્ર વસ્તુઓ પર આ ઉપયોગ કરવા માંગો છો.

1068
01:10:57,300 --> 01:11:01,030
તમે સંગ્રહ પર આ ઉપયોગ થાય છે તો કેટલીક સમસ્યાઓ છે.

1069
01:11:01,030 --> 01:11:03,750
તે સામાન્ય રીતે, જોકે, તે ખૂબ જ ઉપયોગી છે, તે વસ્તુઓ છે

1070
01:11:03,750 --> 01:11:06,590
તમે ઓવરહેડ ઘણો દૂર કારણ કે

1071
01:11:06,590 --> 01:11:10,270
તમે તમારી જાતને દ્વારા તમારા પદાર્થ બધું ખેંચી ન હોય છે.

1072
01:11:10,270 --> 01:11:12,300
તમે બધા કી નામો યાદ કરવાની જરૂર નથી.

1073
01:11:12,300 --> 01:11:18,270
તમે હમણાં જ પ્રકારના તેમને આ વાક્યરચના પાછા મળે છે.

1074
01:11:18,270 --> 01:11:21,500
આ માં, માટે સાથે, તમે ફક્ત યાદ કરવા માંગો છો

1075
01:11:21,500 --> 01:11:27,180
તમે ટેબલ હેશ ખૂબ જ રીતે, બધી કીઓ પાછા મળી રહ્યાં છે.

1076
01:11:27,180 --> 01:11:30,880
તમે તે યાદ હોય તો તમે એક શબ્દમાળા માં મૂકવામાં આવશે, ત્યારે તમે કંઈક વિચાર કરી શકે છે

1077
01:11:30,880 --> 01:11:33,840
તે તેની સાથે સંકળાયેલ કિંમત હોય છે.

1078
01:11:33,840 --> 01:11:36,360
શું તમે આ સાથે કરી શકો છો, તો તમે બધા અધિકાર કહી શકે છે

1079
01:11:36,360 --> 01:11:42,120
હું એક કાર મૂકી, અને હું એક ફેરારી કહેવાય છે.

1080
01:11:42,120 --> 01:11:45,290
તેથી જો તમે પછી ફરીથી શબ્દમાળા ફેરારી માં મૂકી શકો છો, અને તમે તે મેળવી શકો છો.

1081
01:11:45,290 --> 01:11:50,000
અને તમે લૂપ માં માટે એક લુપમાં તે કરી શકો છો.

1082
01:11:50,000 --> 01:11:53,320
તેથી માત્ર વસ્તુઓ વિશે વધારે. તમે યાદ કરવાની જરૂર છે આ કી વસ્તુ

1083
01:11:53,320 --> 01:12:00,340
, તમે આ સાથે ઇચ્છો ત્યારે તમે વાક્યરચના જેવા પદાર્થ સ્ટ્રક્ટ ઉપયોગ કરી શકો છો

1084
01:12:00,340 --> 01:12:04,590
શું તમારા શબ્દમાળા તરીકે ઉપયોગ જઈ માન્ય ચલ નામ ન હોય તો સિવાય.

1085
01:12:04,590 --> 01:12:07,650
તમે તે ત્યાં જોવા તેથી જો, અમે જગ્યાઓ સાથે કી છે.

1086
01:12:07,650 --> 01:12:12,500
સારું, તમે object.key મૂકવા હતા, જગ્યા, સાથે, જગ્યા, જગ્યાઓ,

1087
01:12:12,500 --> 01:12:15,320
તે માત્ર વાક્યરચના અનુસાર અર્થમાં ન કરી હોત.

1088
01:12:15,320 --> 01:12:22,730
તેથી જો તમે માત્ર કૌંસ વાક્યરચના આ પ્રકારની સાથે કરી શકો છો.

1089
01:12:22,730 --> 01:12:26,520
>> પણ, જાવાસ્ક્રિપ્ટ ખૂબ જ અવકાશ મુજબના PHP, છે.

1090
01:12:26,520 --> 01:12:29,050
તમે અવકાશ સરનામા 2 રીતો છે.

1091
01:12:29,050 --> 01:12:31,960
તમે ચલની સામે var ન હોય શકે,

1092
01:12:31,960 --> 01:12:34,060
અને તે માત્ર આ વૈશ્વિક છે થાય છે.

1093
01:12:34,060 --> 01:12:37,050
તમે તેને ગમે ત્યાંથી જોઈ શકો છો. તમે એક નિવેદનમાં જો આ મૂકી કરતી હોય,

1094
01:12:37,050 --> 01:12:42,430
ક્યાંય તમારો કોડ કે બિંદુ પછી તમે તે ચલ જોવા મળશે.

1095
01:12:42,430 --> 01:12:46,730
અન્ય વસ્તુ છે, જોકે, તે તમને સાઇન છો ગમે કાર્ય માટે મર્યાદિત છે, આ var સાથે છે

1096
01:12:46,730 --> 01:12:48,870
તમે એક કાર્ય માં નથી, સાથે સાથે, તે વૈશ્વિક છે.

1097
01:12:48,870 --> 01:12:53,900
તમે એક કાર્ય છે પરંતુ જો તે કાર્ય અંદર જ દેખાય છે.

1098
01:12:53,900 --> 01:12:56,420
હું હા, એક ઉદાહરણ છે, પરંતુ નથી. તે એક તે બાબતો છે કે જ્યાં

1099
01:12:56,420 --> 01:12:59,900
તમે, તમે વૈશ્વિક થવું હોય શું ચલો મેનેજ કરી શકો છો

1100
01:12:59,900 --> 01:13:03,810
શું ચલો તમે સ્થાનિક પ્રયત્ન કરવા માંગો છો, પરંતુ તમે આ વિશે ખૂબ કાળજી રાખો જરૂર છે,

1101
01:13:03,810 --> 01:13:06,890
શું તમે ખરેખર સી કરી દંડ અનાજ નિયંત્રણ પ્રકાર નથી, કારણ કે,

1102
01:13:06,890 --> 01:13:15,820
કંઈક લૂપ માટે માં જાહેર કરવામાં આવે છે, તે માટે લૂપ કે રહેવા રહ્યું છે.

1103
01:13:15,820 --> 01:13:18,790
અમે ખરેખર માટે જાવાસ્ક્રિપ્ટ ઉપયોગ વિશે કાળજી આ વસ્તુ અધિકાર વેબ પૃષ્ઠો હેરફેર છે?

1104
01:13:18,790 --> 01:13:21,800
હું તેનો અર્થ, કે શા માટે આપણે આ કરી રહ્યા છીએ છે.

1105
01:13:21,800 --> 01:13:23,840
>> અમે DOM કહેવાય છે તેની વાપરવા માટે, આમ કરવા માટે કે.

1106
01:13:23,840 --> 01:13:25,850
આ દસ્તાવેજ ઓબ્જેક્ટ મોડેલ.

1107
01:13:25,850 --> 01:13:29,430
મૂળભૂત રીતે, તેને શું છે તે તમારા બધા HTML લે છે

1108
01:13:29,430 --> 01:13:34,110
અને દરેક અન્ય અંદર નેસ્ટ છે કે વસ્તુઓ એક ટોળું માં મોડેલો તેને.

1109
01:13:34,110 --> 01:13:37,080
તમે આ કંઈક સાથે શરૂ કરો.

1110
01:13:37,080 --> 01:13:44,770
તમે ત્યાં બહાર કોડ સમૂહ છે કે જે પ્રકારના છે, મારા માટે જમણી બાજુ પર, છે -

1111
01:13:44,770 --> 01:13:46,640
તમે કે ચાલાકી માટે ખૂબ જ મુશ્કેલ હોઈ છો લાગે કરશે,

1112
01:13:46,640 --> 01:13:48,700
તમે લખાણ સમૂહ દ્વારા વિશ્લેષિત કરી છો કારણ કે

1113
01:13:48,700 --> 01:13:52,080
અને અલગ વસ્તુઓ ભાગ હોય છે. અને તે બરાબર ફોર્મેટ કરી હતી તો શું?

1114
01:13:52,080 --> 01:13:54,880
ખરાબ વસ્તુઓ થાય છે.

1115
01:13:54,880 --> 01:13:58,140
તેથી, જાવાસ્ક્રિપ્ટ તમારા માટે આ કાળજી લે છે, અને તમે એક સરસ માહિતી બંધારણ મેળવવા

1116
01:13:58,140 --> 01:14:01,390
તમે માત્ર એક દસ્તાવેજ છે કે જ્યાં મારા, બાકી પર એક જેવી,

1117
01:14:01,390 --> 01:14:03,530
અને તે અંદર તમે, HTML કહેવાય કંઈક હોય છે

1118
01:14:03,530 --> 01:14:05,600
અને તે અંદર તમે વડા અને શરીર છે

1119
01:14:05,600 --> 01:14:08,420
અને તે વડા અંદર તમે, વગેરે વગેરે, વગેરે વગેરે વગેરે વગેરે એક શીર્ષક છે.

1120
01:14:08,420 --> 01:14:11,810
આ, તે માત્ર છે કે જેથી વેબ પાનું હેરફેર સરળ બનાવે છે

1121
01:14:11,810 --> 01:14:14,190
ઓહ, હું હમણાં જ આ પદાર્થ સાથે વાત કરવા માંગો છો.

1122
01:14:14,190 --> 01:14:21,340
તમે તમારી જાતને કરવામાં અન્ય પદાર્થ સાથે વાત કરશે ખૂબ જ રીતે ક્રમમાં ગોઠવો.

1123
01:14:21,340 --> 01:14:25,980
જેમ હું જણાવ્યું હતું કે, તમામ DOM દસ્તાવેજ પદાર્થ છે.

1124
01:14:25,980 --> 01:14:29,290
ક્યાં છે, તે માત્ર એક જગ્યા છે અને પછી તમે વસ્તુઓ શોધવા માટે બનાવવા માટે તેની અંદર જઈ શકો છો

1125
01:14:29,290 --> 01:14:33,880
અને તમે તે કરી શકો છો - આ છે, આમ જૂના શૈલી છે,

1126
01:14:33,880 --> 01:14:38,130
તમે document.getElementById, અને ક્યાં તો પછી નામ,

1127
01:14:38,130 --> 01:14:42,420
તમે કદાચ કહી શકે છે અને, આ સમય પછી ખૂબ અતિભારે નોંધાયો નહીં.

1128
01:14:42,420 --> 01:14:44,480
તેથી તમે કદાચ એ કરવા માંગતા નથી. અમે શા માટે છે

1129
01:14:44,480 --> 01:14:48,760
અમે આ પછી વિશે વાત જઈ રહ્યાં છો આગામી વસ્તુ.

1130
01:14:48,760 --> 01:14:52,510
અહીં કી બાબત એ છે કે, તે બધા અધિકાર છે, તમે આ બધા તત્વો ધરાવે છે?

1131
01:14:52,510 --> 01:14:56,400
તેથી કદાચ હું થવા પર પૃષ્ઠ લોડ કંઈક ના રંગ બદલી શકો છો.

1132
01:14:56,400 --> 01:14:58,380
તેથી શું? જો મારું વપરાશકર્તા કંઈક ક્લિક્સ તો શું?

1133
01:14:58,380 --> 01:15:00,540
હું તેઓ કંઈક ક્લિક કરો ત્યારે તે રસપ્રદ કંઈક કરવા માંગો છો.

1134
01:15:00,540 --> 01:15:02,600
અમે ઘટનાઓ છે શા માટે છે.

1135
01:15:02,600 --> 01:15:05,330
તમે, મૂળભૂત રીતે, તમારા DOM કોઈપણ તત્વ શોધી શકો છો,

1136
01:15:05,330 --> 01:15:08,560
અને પછી અરે, કહે છે. આ લોડ કોઇ ક્લિક્સ તે જ્યારે

1137
01:15:08,560 --> 01:15:11,410
અથવા તેઓ માઉસ તેની પર, તેની સાથે કંઈક છે.

1138
01:15:11,410 --> 01:15:15,330
અને શું તમારી પાસે તમે તમારા માટે આ હેન્ડલ કે કાર્યો કરતા હોય છે, છે.

1139
01:15:15,330 --> 01:15:17,980
આ વિધેયો ઘટના હેન્ડલર્સ છે.

1140
01:15:17,980 --> 01:15:20,440
શું ચાળીસના - તે માત્ર કહેતા ફેન્સી માર્ગ છે,

1141
01:15:20,440 --> 01:15:23,500
આ ઘટના થાય ત્યારે આ કાર્ય માત્ર ચલાવવામાં આવે છે.

1142
01:15:23,500 --> 01:15:28,070
તેથી તે થાય છે ઘટના સંભાળે છે.

1143
01:15:28,070 --> 01:15:30,810
આ તમને એક ઘટના સંભાળનાર મૂકે કરશે કેવી રીતે છે.

1144
01:15:30,810 --> 01:15:34,750
હું કેટલાક બટન હોય છે, અને તમે તેને ક્લિક કરો ત્યારે, તે explodes.

1145
01:15:34,750 --> 01:15:40,560
તેથી બટન ક્લિક ન કરો.

1146
01:15:40,560 --> 01:15:42,910
આ અધિકાર છે, તે નજીક કરવાની એક રીત છે?

1147
01:15:42,910 --> 01:15:46,430
, તમે એક બટન ટેગ હોય છે, અને ક્લિક પર તમે કહે છે કે શબ્દમાળા છે

1148
01:15:46,430 --> 01:15:50,460
ઓહ, જો કે, હું મારા માટે આ વિસ્ફોટથી વસ્તુ નથી.

1149
01:15:50,460 --> 01:15:53,990
નહિં તો, તે માત્ર તમે જ કરી નિયમિત બટન જેવું છે.

1150
01:15:53,990 --> 01:15:56,550
તમે પણ આ બીજી રીતે કરી શકો છો,

1151
01:15:56,550 --> 01:16:02,770
અમે jQuery વિશે વાત પછી આ DOM તત્વ પડતો, પરંતુ અમે કે સાચવીશું.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: તે ક્રોસ બ્રાઉઝર છે કે પુસ્તકાલય છે.

1153
01:16:07,580 --> 01:16:09,580
તમે ખૂબ ખૂબ કંઈપણ વાપરી શકો છો.

1154
01:16:09,580 --> 01:16:12,090
અને તે માત્ર તમારી સાથે કામ કરવા માટે સાધનો ઘણો આપે છે.

1155
01:16:12,090 --> 01:16:15,850
જાવાસ્ક્રિપ્ટ, શક્તિશાળી, તો તમે જરૂરી બધા સાધનો નથી કારણ કે

1156
01:16:15,850 --> 01:16:20,550
ખરેખર એક વેબ એપ્લિકેશન હલ બોક્સની બહાર તમે કરવા માંગો છો શકે છે.

1157
01:16:20,550 --> 01:16:24,650
તેથી તે વસ્તુઓ ઘણો સરળ બનાવે છે તમે વિધેયો ઘણો આપે છે

1158
01:16:24,650 --> 01:16:28,760
તમે સામાન્ય રીતે ઉપર અને ઉપર ફરીથી અને ઉપર, તમારા લખી હશે કે બોક્સની બહાર.

1159
01:16:28,760 --> 01:16:31,600
અને માત્ર વસ્તુઓ ખૂબ જ સરળ બનાવે છે.

1160
01:16:31,600 --> 01:16:35,780
તમે તે બધા તત્વો લેવા દો જે પસંદગીકારો છે

1161
01:16:35,780 --> 01:16:42,800
તમારા DOM થી વધારે સરળ, તેના બદલે આ ખૂબ જ લાંબા વિધેય કોલ ઉપયોગ કર્યા છે.

1162
01:16:42,800 --> 01:16:46,630
આ પસંદગીકારો પર વધુ. તમે, ચાલો કહે છે ત્યાં, છે

1163
01:16:46,630 --> 01:16:49,800
હું ID સાથે એક તત્વ મેળવવા માંગો છો "ખડક."

1164
01:16:49,800 --> 01:16:56,450
વેલ, jQuery, તે માત્ર $ અને પછી એક પાઉન્ડ છે કે શબ્દમાળા અને પછી છે "રોક."

1165
01:16:56,450 --> 01:17:01,960
તે ખૂબ જ સરળ અને આ સમસ્યા હાથ ધરવા માટે પરંપરાગત જાવાસ્ક્રિપ્ટ માર્ગ કરતાં ઘણો વધુ ઝડપી છે.

1166
01:17:01,960 --> 01:17:06,120
અને તમે વર્ગો અને તત્વ પ્રકારો માટે સમાન વસ્તુઓ હોય છે.

1167
01:17:06,120 --> 01:17:08,140
jQuery છે - ઠંડી લક્ષણો છે કે તમે પ્રકારના સંકુચિત કરી શકો છો છે

1168
01:17:08,140 --> 01:17:14,350
તમારા DOM પર તમારા પ્રશ્નો નીચે ખૂબ, ખૂબ જ ઝડપી.

1169
01:17:14,350 --> 01:17:18,980
હવે અમે પાછા ઘટના નિયંત્રણમાં છો, અને આ તમને jQuery માં એક ઘટના હેન્ડલ કેવી રીતે છે.

1170
01:17:18,980 --> 01:17:23,090
તેથી શું અમે અહીં જઈ રહ્યાં છો અમે બધા હક છે, કહી રહ્યાં છે. હું સ્ક્રિપ્ટ ટેગ છે, અધિકાર?

1171
01:17:23,090 --> 01:17:25,400
તેથી હું આ ઇનલાઇન જાવાસ્ક્રિપ્ટ છે.

1172
01:17:25,400 --> 01:17:27,750
અમે શું કરી રહ્યા છીએ અમે બધા હક છે, કહે રહ્યા છીએ છે.

1173
01:17:27,750 --> 01:17:30,860
આ દસ્તાવેજ, દસ્તાવેજ લોડ કરવામાં આવ્યું, જેનો અર્થ છે તૈયાર છે

1174
01:17:30,860 --> 01:17:34,660
, અમે તે કામ કરવા માટે જઈ રહ્યા છે, અને અમે બધા હક કહે રહ્યા છીએ

1175
01:17:34,660 --> 01:17:37,060
આ કાર્ય ખરેખર કંઈક બીજું કરવાનું છે.

1176
01:17:37,060 --> 01:17:42,320
તે વાસ્તવમાં બધા હક છે, મને ID ને સાથે તત્વ વિચાર, કહેતા "myid."

1177
01:17:42,320 --> 01:17:47,960
અને પછી આ તમે તેને ક્લિક કરો ત્યારે ચલાવે છે કે એક કાર્ય સંભાળનાર આપે છે.

1178
01:17:47,960 --> 01:17:49,820
મૂળભૂત રીતે આ શું કરે છે, તે કહે છે, બધા અધિકાર છે.

1179
01:17:49,820 --> 01:17:52,630
આ પાનું લોડ થાય છે, તેથી હું, આ તત્વ શોધવા જાઉં છું

1180
01:17:52,630 --> 01:17:56,420
તે આ ઘટના સંભાળનાર આપે છે, અને તે વાસ્તવમાં તમારા માટે તમારા પાનું સુયોજિત કરે છે.

1181
01:17:56,420 --> 01:18:00,520
અને આ તમને ઘટના હેન્ડલિંગ વિશે વિચારો કરવા માંગો છો કેવી રીતે છે.

1182
01:18:00,520 --> 01:18:06,310
તમે માત્ર વિશે વિચારો બધા હક છે, કંઈક થાય છે, હું શું કરવા શું માંગો છો માંગો છો?

1183
01:18:06,310 --> 01:18:10,520
તમે ઠીક છે, હું આ વસ્તુ માટે ખાતરી કરો કે આ વસ્તુ વાટાઘાટો કરવાની જરૂર છે, વિશે વિચારો નથી માંગતા

1184
01:18:10,520 --> 01:18:14,660
આ વાત મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત મૂર્ખામી ભરેલી વાહિયાત વાત, તમે માત્ર ઘટનાઓ દ્રષ્ટિએ વસ્તુ વાત કરવા માંગો છો છે.

1185
01:18:14,660 --> 01:18:17,650
જ્યારે આવું થાય, આવું થાય. જ્યારે આવું થાય, આવું થાય છે.

1186
01:18:17,650 --> 01:18:20,240
વસ્તુઓ અન્ય વસ્તુઓ ટ્રિગર છો, કે જે મહાન છે.

1187
01:18:20,240 --> 01:18:22,150
પરંતુ તમે જટિલ કોડ પ્રયત્ન કરો અને કરવા માંગો છો નથી

1188
01:18:22,150 --> 01:18:24,130
તમે જ્યાં છો, એ જ સમયે અનેક વસ્તુઓ સર્જાઈ રહ્યા છીએ

1189
01:18:24,130 --> 01:18:28,860
તમે માત્ર તમારી જાતને એક માથાનો દુખાવો આપી રહ્યા છીએ કારણ કે.

1190
01:18:28,860 --> 01:18:32,340
>> અધિકાર છે. હવે અમે અમારા પાનું ઘટનાઓ નિયંત્રિત કરવા માટે મળી શકે છે,

1191
01:18:32,340 --> 01:18:35,640
પરંતુ હું મારા વપરાશકર્તાઓ બટન ક્લિક કરે કહો.

1192
01:18:35,640 --> 01:18:38,040
શું, હું સર્વર સાથે કે વિનંતી મોકલવા માંગો છો

1193
01:18:38,040 --> 01:18:41,100
નવી પૃષ્ઠને ફરીથી લોડ કર્યા કારણ કે હું પૃષ્ઠને ફરીથી લોડ કરો નહિં માંગો

1194
01:18:41,100 --> 01:18:44,390
દરેક એક સમય જટિલ પ્રકારની નોંધાયો નહીં, અને હું શા માટે જરૂર છે

1195
01:18:44,390 --> 01:18:47,430
ફરી હેડર નીચે ખેંચે છે, અને ફરી ફૂટર માટે,

1196
01:18:47,430 --> 01:18:49,670
અને તમામ પાનાંના તત્વો ફરી

1197
01:18:49,670 --> 01:18:53,180
માત્ર શુભેચ્છા અથવા સમય તાજું?

1198
01:18:53,180 --> 01:18:55,290
અમે એજેક્સ કંઈક તેથી કે શા માટે છે.

1199
01:18:55,290 --> 01:18:59,150
આપણે એજેક્સ સાથે અહીં કરી શકો છો, અમે બધા હક કહી શકે છે

1200
01:18:59,150 --> 01:19:01,290
હું સર્વર સાથે અમુક માહિતી મોકલવા માંગો છો,

1201
01:19:01,290 --> 01:19:04,010
અને હું તેથી હું મારા પાનું સુધારી શકે છે પાછા પ્રતિભાવ મેળવવા માંગો છો,

1202
01:19:04,010 --> 01:19:12,120
અથવા કદાચ માત્ર જરૂરી વપરાશકર્તા કંઈપણ બતાવશો નથી કે કેટલાક ગાણિતિક ગણતરી કરી.

1203
01:19:12,120 --> 01:19:15,500
શું તમે આ કરવા માટે જરૂર છે? સારું, તમે તમારી સાથે વાત કરવાની જરૂર છે એક URL જરૂર છે.

1204
01:19:15,500 --> 01:19:18,650
તમારા સર્વર માત્ર જાદુઇ ક્યાંય થી સાંભળતું નથી કરી શકો છો.

1205
01:19:18,650 --> 01:19:21,960
તમે તમારા માટે આ માહિતી મોકલી રહ્યાં છો ચોક્કસ સ્થળ હોવું જરૂરી છે.

1206
01:19:21,960 --> 01:19:26,240
અને તમે પણ મોકલી અમુક માહિતી જરૂર છે, અથવા કદાચ તે dataless ક્વેરી છે.

1207
01:19:26,240 --> 01:19:31,380
તમે માત્ર હેય, હું જીવતો, અથવા તે કંઈક છું, પાછા સર્વર સાથે ping અને કહે માંગો છો.

1208
01:19:31,380 --> 01:19:35,150
અને પછી તમે મૂળભૂત રીતે સફળતા સાથે સંભાળે છે કે કાર્ય કરવા માંગો છો.

1209
01:19:35,150 --> 01:19:38,250
કે તમે તમારા સર્વર માંથી કેટલીક માહિતી પાછી મેળવવા કહો કે,

1210
01:19:38,250 --> 01:19:42,960
અને તમે તેમના પાનાં પર વપરાશકર્તાની શીર્ષક બદલવા માંગો છો.

1211
01:19:42,960 --> 01:19:44,930
તેથી તમારી પાસે માહિતી પાછા મળી જશે,

1212
01:19:44,930 --> 01:19:48,860
અને તમે સ્ક્રીન પર દબાણ કરશે કે.

1213
01:19:48,860 --> 01:19:51,170
પૃષ્ઠ તૈયાર છે ત્યારે શું થાય છે,

1214
01:19:51,170 --> 01:19:56,500
તમે આવકાર કહેવાય બટન માટે ક્લિક કાર્ય પર બનાવો.

1215
01:19:56,500 --> 01:19:58,810
તે બટન ધકેલવામાં આવે છે ત્યારે શું આ પછી કરે છે,

1216
01:19:58,810 --> 01:20:03,700
તમે greetings.php વાત, તમે, પોસ્ટ વિનંતી કરી

1217
01:20:03,700 --> 01:20:07,290
અને તમે અરે, મને તમારા પાનું માંથી કંઈક વિચાર, છે.

1218
01:20:07,290 --> 01:20:09,890
અમે ખરેખર કે વર્ણન કરવાની જરૂર છે, પરંતુ greetings.php નથી

1219
01:20:09,890 --> 01:20:12,480
ચાલો માત્ર કહે છે, "હેલો વર્લ્ડ." પાછળ આપે છે

1220
01:20:12,480 --> 01:20:15,650
તેથી અમે, "હેલો વર્લ્ડ" આ પાછળ વિચાર અને આ સફળતા પર

1221
01:20:15,650 --> 01:20:20,730
કશું ખોટું થાય એમ ધારી રહ્યા છીએ, તો પછી અમે ફક્ત આ લક્ષ્ય સ્થળ પર જાઓ

1222
01:20:20,730 --> 01:20:25,720
અમે સ્પષ્ટ છે અને અમે માત્ર ત્યાં માં જવાબ વળગી છે.

1223
01:20:25,720 --> 01:20:31,560
અને આ એક એજેક્સ ક્વેરી સુયોજિત એક ખૂબ સરળ માર્ગ છે.

1224
01:20:31,560 --> 01:20:34,340
>> ખૂબ ઝડપથી, રોબ પ્રકારના, પહેલેથી જ આ ઉલ્લેખ કર્યો છે

1225
01:20:34,340 --> 01:20:37,170
વસ્તુઓ ખોટી જઈ શકે છે, ખરાબ વસ્તુઓ થઇ શકે છે,

1226
01:20:37,170 --> 01:20:42,660
તેથી તમે આ HTTP પ્રતિસાદ કોડ સાથે જાતે પરિચિત કરવા માંગો છો.

1227
01:20:42,660 --> 01:20:46,030
શું આ છે બધું ઠીક ગયા, 200, જેમ જ છે.

1228
01:20:46,030 --> 01:20:48,670
બીજું કંઈક, ખરાબ વસ્તુઓ થયું.

1229
01:20:48,670 --> 01:20:50,790
તે સામાન્ય રીતે તમે યાદ કરવા માંગો છો તે વાત છે.

1230
01:20:50,790 --> 01:20:53,440
પરંતુ તે આ બધી ખબર સારું છે.

1231
01:20:53,440 --> 01:20:55,970
અને છેલ્લે, એક વખત અમે તે બધી પસાર કર્યો છે,

1232
01:20:55,970 --> 01:20:58,680
અમે ડિઝાઇન વિશે ખૂબ જ ઝડપથી વાત કરવાની જરૂર છે

1233
01:20:58,680 --> 01:21:00,620
અને પછી અમે તમને બધા છોડી દઇ શકો છો.

1234
01:21:00,620 --> 01:21:03,410
ડિઝાઇન. તમે યાદ કરવા માંગો છો વસ્તુઓ.

1235
01:21:03,410 --> 01:21:06,950
આ પ્રશ્નોના વિચાર કરો આ કોણ ઉપયોગ કરી શકશો?

1236
01:21:06,950 --> 01:21:09,580
શું તેઓ માટે ઉપયોગ કરવામાં આવશે? મારા વપરાશકર્તાઓ વિશે શું કાળજી કરું?

1237
01:21:09,580 --> 01:21:11,750
તેઓ શું વિશે પડી નથી?

1238
01:21:11,750 --> 01:21:14,500
તમે માત્ર એક એપ્લિકેશન બનાવવા અને તે માત્ર વધવા દો નહિં માંગો

1239
01:21:14,500 --> 01:21:18,270
અને આ વિશાળ, તમે પણ સમાપ્ત કરી શકે છે કે તમામ વપરાશ બાબત બની જાય છે.

1240
01:21:18,270 --> 01:21:23,900
તમે કરવા માંગો છો અલગ ગોલ અને યોજનાઓ અને વસ્તુઓ હોય છે કરવા માંગો છો.

1241
01:21:23,900 --> 01:21:29,000
તે સહેલું બનાવે છે. આ તમામ, મૂળભૂત રીતે, કહે છે

1242
01:21:29,000 --> 01:21:34,950
તેને સરળ વપરાશકર્તા તેનો ઉપયોગ બનાવવા માટે; ખરેખર, તે આ સ્લાઇડ જેવા લખાણ એક વિશાળ તલ છે તે નથી.

1243
01:21:34,950 --> 01:21:38,020
તમે હમણાં જ તે કોઈને જવા માટે તે ખૂબ જ સરળ છે જ્યાં કંઈક કરવા માંગો છો

1244
01:21:38,020 --> 01:21:40,800
અને તેઓ શું કરવા માંગો છો નથી.

1245
01:21:40,800 --> 01:21:42,920
તમે તેમને 5 પૃષ્ઠો નેવિગેટ હોય નથી માંગતા

1246
01:21:42,920 --> 01:21:45,460
તમારી સાઇટ તમારા મુખ્ય કામગીરી મેળવો.

1247
01:21:45,460 --> 01:21:49,290
ગૂગલ પહેલાં 5 પાના હોય તો તમે પણ કંઈક શોધવા શકે,

1248
01:21:49,290 --> 01:21:53,080
કોઈ એક તેનો ઉપયોગ કરશે.

1249
01:21:53,080 --> 01:21:55,890
અને છેલ્લે, કાગળ પ્રોટોટાઇપ, ધ્યાન ગ્રુપ.

1250
01:21:55,890 --> 01:21:59,220
સારી ડિઝાઇન અને પરીક્ષણ પદ્ધતિઓ છે.

1251
01:21:59,220 --> 01:22:00,730
તમે તેને તમારા માટે કામ લાગે છે જસ્ટ કારણ કે,

1252
01:22:00,730 --> 01:22:04,860
બીજા કોઈની તે કામ કરે છે વિચારે અર્થ એ નથી.

1253
01:22:04,860 --> 01:22:14,490
પરંતુ હા, તે છે.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]