1
00:00:00,000 --> 00:00:02,910
>> [સંગીત વગાડવાનો]

2
00:00:02,910 --> 00:00:04,850

3
00:00:04,850 --> 00:00:07,275
>> નીલ મહેતા: અહીં તે જાય છે.

4
00:00:07,275 --> 00:00:11,070
>> વેલ, દરેક વેબ પર આપનું સ્વાગત છે
સાથે ભવિષ્યના એપ્લિકેશન્સ પ્રતિક્રિયા.

5
00:00:11,070 --> 00:00:11,870
આ CS50 છે.

6
00:00:11,870 --> 00:00:12,930
મારું નામ નીલ છે.

7
00:00:12,930 --> 00:00:17,689
હું CS50 અને દ્વિતિય માટે TA છું
હાર્વર્ડ કોલેજ અને ખૂબ, ખૂબ ઓછામાં

8
00:00:17,689 --> 00:00:18,730
પ્રખર વેબ ડેવલપર.

9
00:00:18,730 --> 00:00:20,730
તેથી હું ખૂબ જ ઉત્તેજક છું
આજે તમે વાત કરી,

10
00:00:20,730 --> 00:00:24,550
તમે અહીં અથવા ઘરે કરશો કે કેમ
જોવાનું, વિશે ફરી છે, જે પ્રતિક્રિયા

11
00:00:24,550 --> 00:00:27,270
હું વેબ એપ્લિકેશન્સ, ભવિષ્યમાં જણાવ્યું હતું કે.

12
00:00:27,270 --> 00:00:29,055
>> તેથી પ્રતિક્રિયા વેબ ફ્રેમવર્ક છે.

13
00:00:29,055 --> 00:00:30,930
હું આવી કર્યું છે અને કહેવાની
અહીં કેટલાક લોકો માટે,

14
00:00:30,930 --> 00:00:33,400
એક ફ્રેમવર્ક માત્ર એક છે
તમે ઉપયોગ કરી શકો સાધનો સમૂહ

15
00:00:33,400 --> 00:00:35,770
માળખું અને તમારા વેબ એપ્લિકેશન બીલ્ડ કરવા.

16
00:00:35,770 --> 00:00:39,010
અને વેબ એપ્લિકેશન્સ, ફરી, વેબસાઇટ્સ છે
ફેસબુક જેવી ઇન્ટરેક્ટિવ કે જે હોય છે,

17
00:00:39,010 --> 00:00:42,330
Twitter.com, Instagram.com, ગમે.

18
00:00:42,330 --> 00:00:45,590
>> તેથી ફેસબુક વેબ ફ્રેમવર્ક છે
કે ફેસબુક દ્વારા વિકસાવવામાં આવી હતી

19
00:00:45,590 --> 00:00:48,060
પ્રતિક્રિયા back-- એક દંપતિ વર્ષ છે.

20
00:00:48,060 --> 00:00:50,830
ત્યારથી તે માં ઉપયોગ કરવામાં આવે છે
તેમના મોબાઇલ એપ્લિકેશન્સ પર ફેસબુક

21
00:00:50,830 --> 00:00:52,460
અને વેબ એપ્લિકેશન, Instagram.

22
00:00:52,460 --> 00:00:56,350
ખાન એકેડેમી અન્ય છે
પ્રતિક્રિયા અગ્રણી પ્રારંભિક અપનાવનારું.

23
00:00:56,350 --> 00:00:58,630
>> તે ખરેખર મેળવવામાં આવી છે
અત્યંત લોકપ્રિય છે.

24
00:00:58,630 --> 00:01:03,420
તમે ક્યારેય કોણીય અથવા જેવી વસ્તુઓ વાપરો તો
બેકબોન, આ જ પરિવાર છે,

25
00:01:03,420 --> 00:01:05,830
પરંતુ ત્યારથી તે અત્યાર સુધી છે
તેમની લોકપ્રિયતા આગળ નીકળી જવું.

26
00:01:05,830 --> 00:01:06,890
તે ગરમ નવા વાત છે.

27
00:01:06,890 --> 00:01:09,590
તે ખરેખર, ખરેખર વિશાળ છે.

28
00:01:09,590 --> 00:01:13,470
>> અને તેથી પ્રતિક્રિયા તરીકે માત્ર સારી છે
મકાન ઈન્ટરફેસો માટે વેબ માળખું.

29
00:01:13,470 --> 00:01:16,020
તે વેબ ઈન્ટરફેસો બનાવવા માટે સારી છે.

30
00:01:16,020 --> 00:01:18,350
એક વસ્તુ પણ છે
કહેવાય મૂળ પ્રતિક્રિયા જે

31
00:01:18,350 --> 00:01:22,200
તમે ઇન્ટરફેસો બિલ્ડ કરી શકો છો
Android અને iOS માટે

32
00:01:22,200 --> 00:01:26,390
ભવિષ્યમાં અને કદાચ અન્ય પ્લેટફોર્મ
માત્ર એક જ JavaScript કોડ મદદથી.

33
00:01:26,390 --> 00:01:31,130
તમે ચોક્કસ જ ઉપયોગ કરી શકે છે
JavaScript કોડ, વેબસાઇટ્સ રેન્ડર કરવા માટે

34
00:01:31,130 --> 00:01:33,040
Android એપ્લિકેશન્સ અને iOS એપ્લિકેશન્સ રેન્ડર કરવા માટે.

35
00:01:33,040 --> 00:01:35,000
>> તે ખૂબ જ છે, ખૂબ જ આકર્ષક સમય છે.

36
00:01:35,000 --> 00:01:37,070
તે ખરેખર, ખરેખર ઠંડી તક છે.

37
00:01:37,070 --> 00:01:42,020
તે ખરેખર એક સાર્વત્રિક વેબ છે
ઈન્ટરફેસ વિકાસ સાધન

38
00:01:42,020 --> 00:01:44,420
તેથી તે ખૂબ, ખૂબ છે
મહત્વની વસ્તુ ખબર.

39
00:01:44,420 --> 00:01:46,949
અને, હું લોકો કહી હતી તરીકે
પહેલાં, આ, મને લાગે છે,

40
00:01:46,949 --> 00:01:48,990
અમે કેવી રીતે બદલી રહ્યું છે
કાયમ વેબ Apps બનાવો.

41
00:01:48,990 --> 00:01:55,820
તેથી તે કદાચ થોડી ઉદાહરણમાં ઈસુએ છે, પરંતુ હું
તે જાણવા માટે એક ખૂબ સારી બાબત છે લાગે છે.

42
00:01:55,820 --> 00:01:57,580
>> ઠીક છે, તેથી પ્રતિક્રિયા શું છે?

43
00:01:57,580 --> 00:02:01,020
પ્રતિક્રિયા એક ફ્રેમવર્ક તમે કરી શકો છો
ઇન્ટરફેસો બનાવવા માટે ઉપયોગ કરે છે.

44
00:02:01,020 --> 00:02:03,240
એક ઇન્ટરફેસ, ફરી, છે
અધિકાર વેબ પેજ?

45
00:02:03,240 --> 00:02:06,340
તેથી અહીં Instagram.com છે, ઉપયોગો પ્રતિક્રિયા.

46
00:02:06,340 --> 00:02:08,740
>> પર બાંધવામાં આવે છે પ્રતિક્રિયા
ઘટકો વિચાર.

47
00:02:08,740 --> 00:02:11,900
એક ઘટક એક એચટીએમએલ
સ્ટેરોઇડ્સ પર તત્વ,

48
00:02:11,900 --> 00:02:14,470
તેથી HTML તત્વ એક બટન જેવી છે.

49
00:02:14,470 --> 00:02:15,250
તે ફકરો છે.

50
00:02:15,250 --> 00:02:17,500
તે હક, હેડર છે?

51
00:02:17,500 --> 00:02:22,740
અને Instagram આ ઉપયોગ કરે છે પરંતુ તે કરશે
પણ પ્રતિક્રિયા ઘટકો ઉપયોગ કરશે.

52
00:02:22,740 --> 00:02:25,740
>> ઘટકો છે પ્રતિક્રિયા
souped અપ HTML તત્વો

53
00:02:25,740 --> 00:02:28,100
પોતાના વર્તન હોય છે કે
તેમને અંદર સમાયેલ છે.

54
00:02:28,100 --> 00:02:31,800
તેથી, ઉદાહરણ તરીકે, અમે કરી શકે છે
એક સમયે તત્વ, એક સમય ઘટક

55
00:02:31,800 --> 00:02:34,095
જે જેવા સમાવશે
સમય સ્ટેમ્પ, તમે જાણો છો,

56
00:02:34,095 --> 00:02:37,170
પ્રોફાઇલ ઘટક કે જે
આ પ્રોફાઇલ છબી સમાવશે

57
00:02:37,170 --> 00:02:38,820
અને વ્યક્તિનું નામ.

58
00:02:38,820 --> 00:02:42,930
તે જેવા કાઉન્ટર હોય છે જેના
પસંદ સંખ્યા જેવી ગણતરી કરી શકે છે,

59
00:02:42,930 --> 00:02:45,610
તમે તેના પર ક્લિક કરો, તો, તે પડશે
પસંદ સંખ્યા વધારે છે.

60
00:02:45,610 --> 00:02:48,200
એક ઘટક માત્ર એક છે
HTML કોડ ટોળું કે

61
00:02:48,200 --> 00:02:50,520
કેટલાક વિધેય છે
તે અંદર આવરિત.

62
00:02:50,520 --> 00:02:53,770
તેથી તે HTML તત્વ જેવું છે
સ્ટેરોઇડ્સ પર, હું પહેલાં જણાવ્યું હતું કે.

63
00:02:53,770 --> 00:02:56,270
તમે આ ઘટકો લઇ શકે છે,
અને તમે તેમને એકસાથે મૂકી શકો છો

64
00:02:56,270 --> 00:02:59,060
, નવી ઘટકો બનાવવા માટે
આ કિસ્સામાં, એક પોસ્ટ ઘટક

65
00:02:59,060 --> 00:03:00,505
જે આ તમામ સામગ્રી સમાવે છે.

66
00:03:00,505 --> 00:03:04,050
તે પ્રોફાઇલ સમય સમાવે છે,
LikeCounter, કદાચ આ ટિપ્પણી

67
00:03:04,050 --> 00:03:06,100
અને કદાચ ઇમેજ પોતાને.

68
00:03:06,100 --> 00:03:10,810
અને તેથી વેબ એપ્લિકેશન્સ માત્ર લઈને બાંધવામાં આવે છે
ઘટકો અને તેમને મળીને મૂકે.

69
00:03:10,810 --> 00:03:15,620
એક Instagram ફીડ કરતાં વધુ કંઇ છે
પોસ્ટ્સ એક ટોળું એક પછી એક,

70
00:03:15,620 --> 00:03:19,032
દરેક પોસ્ટ, સમય જેવો છે
તેથી, LikeCounter પ્રોફાઇલ, અને.

71
00:03:19,032 --> 00:03:20,490
તે પ્રકારની એક ઘર મકાન જેવું છે.

72
00:03:20,490 --> 00:03:22,660
તમે બિલ્ડ નથી
નીચે ટોચ પરથી હાઉસ.

73
00:03:22,660 --> 00:03:24,960
તમે ઘટકો લેવા
બાથરૂમમાં જેવી લે છે.

74
00:03:24,960 --> 00:03:28,320
તમે તેમને વળગી bedroom-- લેવા
તેની સાથે, અને તમે નવી ઘટક છે.

75
00:03:28,320 --> 00:03:29,760
તમે ઘરની એક નવી ભાગ હોય છે.

76
00:03:29,760 --> 00:03:32,860
>> તેથી એ બધા આસપાસ બાંધવામાં આવે છે પ્રતિક્રિયા
ઘટકો આ વિચાર કે

77
00:03:32,860 --> 00:03:36,600
ઘોષણાત્મક છે કે, ઇન્ટરેક્ટિવ છે.

78
00:03:36,600 --> 00:03:39,650
શું તમે માત્ર કહે છે જેમ
પ્રોફાઇલ છે, અને તે કરે છે.

79
00:03:39,650 --> 00:03:40,600
તેઓ composable છે.

80
00:03:40,600 --> 00:03:43,880
તમે સમય અને એક પ્રોફાઇલ લઇ શકે છે, મૂકી
તેમને મળીને કંઈક વધુ સારું બનાવવા.

81
00:03:43,880 --> 00:03:47,770
અને તેઓ તેથી જો, ફરીથી વાપરી શકાય છો તમે
એક પોસ્ટ માટે સ્રોત કોડ છે,

82
00:03:47,770 --> 00:03:49,440
તમે તે ગમે ત્યાં એમ્બેડ કરી શકે છે.

83
00:03:49,440 --> 00:03:53,160
>> તમે એક Instagram એમ્બેડ કરી શકો છો
તમારી પોતાની વેબસાઇટ પર વસ્તુ.

84
00:03:53,160 --> 00:03:56,830
તમે ફેસબુક એમ્બેડ કરી શકો છો, ઉદાહરણ તરીકે,
જ્યાં સુધી તે વાપરે તેમજ પ્રતિક્રિયા.

85
00:03:56,830 --> 00:04:00,360
તેથી ઘટકો ખરેખર, ખરેખર, ખરેખર છે
વેબ શક્તિશાળી બિલ્ડિંગ બ્લૉક્સ

86
00:04:00,360 --> 00:04:04,180
કે ગમે ત્યાં ઉપયોગ અને મૂકી શકાય છે
સાથે મળીને નવા બિલ્ડિંગ બ્લૉક્સ બનાવવા માટે.

87
00:04:04,180 --> 00:04:07,159
તે ખૂબ, ખૂબ છે
ઉચ્ચ સ્તર ઝાંખી.

88
00:04:07,159 --> 00:04:09,200
તેથી, ફરી, જો તમારી પાસે
કોઈપણ સમયે કોઈપણ પ્રશ્નો

89
00:04:09,200 --> 00:04:14,470
રિએક્ટર છે, આ તત્ત્વજ્ઞાન વિશે
કોડિંગ, મને બંધ, અને દો મને ખબર.

90
00:04:14,470 --> 00:04:18,420
>> ઠીક છે, તેથી કારણ કે તે ઠંડી પ્રતિક્રિયા છે
જોઈ એક અલગ માર્ગ છે

91
00:04:18,420 --> 00:04:19,870
તમે વેબ એપ્લિકેશન્સ બિલ્ડ કેવી રીતે.

92
00:04:19,870 --> 00:04:23,620
તમે કદાચ MVC, એક સાંભળ્યું કર્યું
મોડેલ તમે CS50 અથવા જે નિયંત્રણ

93
00:04:23,620 --> 00:04:25,940
તમે ઉપયોગ ચકાસણી વર્ગો અન્ય.

94
00:04:25,940 --> 00:04:29,000
અને સૌથી માળખા છે
MVC ના વિચાર આસપાસ બાંધવામાં આવે છે.

95
00:04:29,000 --> 00:04:30,410
પ્રતિક્રિયા નથી.

96
00:04:30,410 --> 00:04:32,980
વિચાર આસપાસ બાંધવામાં આવે છે પ્રતિક્રિયા
unidirectional માહિતી પ્રવાહ

97
00:04:32,980 --> 00:04:36,510
અહીં આ ચાર્ટ અથવા ગ્રાફિક દ્વારા જોવા મળે છે.

98
00:04:36,510 --> 00:04:38,260
>> મૂળભૂત રીતે, તમે એક ડેટા સ્રોત છે.

99
00:04:38,260 --> 00:04:42,380
અને ડેટા સ્રોત નક્કી કરશે
કેવી રીતે ચોક્કસ ઘટકો બહાર મૂકે છે.

100
00:04:42,380 --> 00:04:45,452
અને ઘટકો કરશે
પછી, તેઓ બદલો છો, ત્યારે

101
00:04:45,452 --> 00:04:47,160
તેઓ કહેશે
ડેટા સ્રોત બદલવા માટે.

102
00:04:47,160 --> 00:04:49,350
>> આ Instagram ઉપયોગ કરવા માટે
ઉદાહરણ તરીકે, તમે હોઈ શકે છે

103
00:04:49,350 --> 00:04:52,050
જેવા પોસ્ટ વસ્તુઓ યાદી
ડેટાબેઝ અથવા કંઈક.

104
00:04:52,050 --> 00:04:53,310
માહિતી કે.

105
00:04:53,310 --> 00:04:57,600
અને પછી અમારી પોસ્ટ ઘટકો
કે માહિતી લઈ જશે,

106
00:04:57,600 --> 00:05:01,830
અને રેન્ડર કરવા માટે કે ડેટાનો ઉપયોગ
સ્ક્રીન પર એક વસ્તુ.

107
00:05:01,830 --> 00:05:04,300
કે શું તીર
ઘટક છે માહિતી

108
00:05:04,300 --> 00:05:07,930
અને પછી તે જ માહિતી માટે વપરાય છે
ઘટકો એક ટોળું રેન્ડર કરવા માટે.

109
00:05:07,930 --> 00:05:10,290
>> ફેસબુક મેસેન્જર, માટે
પ્રતિક્રિયા છે, જે ઉદાહરણ,

110
00:05:10,290 --> 00:05:13,410
તમે એક યાદી હોય શકે છે
તમારી માહિતી સ્ત્રોત તરીકે સંદેશાઓ.

111
00:05:13,410 --> 00:05:15,927
અને તે રેન્ડર કરશે
સંદેશાઓ માત્ર યાદી

112
00:05:15,927 --> 00:05:17,510
પણ મિત્રો યાદી તમારી પાસે છે.

113
00:05:17,510 --> 00:05:19,200
તમે ન વાંચેલા ગણક હોય છે.

114
00:05:19,200 --> 00:05:23,330
કદાચ પણ ફેસબુક વસ્તુ રેન્ડર
કે Facebook.com તળિયે છે.

115
00:05:23,330 --> 00:05:25,610
આ જ માહિતી છે
સત્ય એક સ્રોત

116
00:05:25,610 --> 00:05:28,290
અને તે ઘણો માટેનું કારણ બને છે
ઘટકો રેન્ડર કરી શકાય છે.

117
00:05:28,290 --> 00:05:30,290
અને જ્યારે એક તે
ઘટકો બદલાઈ છે,

118
00:05:30,290 --> 00:05:32,320
તે પાછા જાય છે અને
ડેટા સ્રોત બદલે છે.

119
00:05:32,320 --> 00:05:33,460
>> તમે અધિકાર છે, એક સંદેશ મોકલો?

120
00:05:33,460 --> 00:05:34,780
કે માહિતી સ્ત્રોત બદલે છે.

121
00:05:34,780 --> 00:05:39,490
તમે તમારા સંદેશાઓ વાંચો,
જેથી તમે 0 વાંચેલા સુયોજિત કરો.

122
00:05:39,490 --> 00:05:41,136
કે માહિતી સ્ત્રોત બદલે છે.

123
00:05:41,136 --> 00:05:44,010
અને એક આ છે કે જે બધી નોટિસ
તીર જ માહિતી પર પાછા જવાનું

124
00:05:44,010 --> 00:05:47,662
સ્ત્રોત, તમે જાણો છો, જેથી
ચોક્કસ માહિતી સમૂહ આપવામાં આવે છે,

125
00:05:47,662 --> 00:05:49,870
તમે ચોકકસ શું ખબર
પાનું જેમ દેખાય રહ્યું છે.

126
00:05:49,870 --> 00:05:50,700
તે નિર્ધારિત છે.

127
00:05:50,700 --> 00:05:53,451
તમે આપવામાં ચોક્કસ માહિતી ખબર છે, શું
આ પાનું જેમ દેખાય રહ્યું છે.

128
00:05:53,451 --> 00:05:56,158
તમે તેને કરવા જઈ રહ્યું છે કેવી રીતે આગાહી કરી શકો છો
વર્તે છે અને કેવી રીતે વસ્તુઓ જોઈ રહ્યા છે

129
00:05:56,158 --> 00:05:57,650
તેઓ સાથે મળીને રાખવામાં કરી રહ્યા હો ત્યારે કામ કરવા માટે.

130
00:05:57,650 --> 00:06:00,410
>> અને હું એક મિલિયન ઘટકો હોય તો
અહીં, તે યોગ્ય છે, એ જ રીતે વર્તે છે?

131
00:06:00,410 --> 00:06:02,290
જો તમે કોઇ ન હોત
વિચિત્ર ઈન્ટરકનેક્શન.

132
00:06:02,290 --> 00:06:04,120
એક માહિતી એક મિલિયન ઘટકો રેન્ડર.

133
00:06:04,120 --> 00:06:06,879
એક મિલિયન ઘટકો કરી શકે
પાછા જાઓ અને માહિતી ફેરફાર કરો.

134
00:06:06,879 --> 00:06:07,920
અને તેથી આ ખૂબ જ સરસ છે.

135
00:06:07,920 --> 00:06:10,870
અમે composable નિર્માણ કરી રહ્યાં છો
સરળતાથી માપી શકાય તેવા વેબ એપ્લિકેશન્સ.

136
00:06:10,870 --> 00:06:13,150
>> તમે એક ડેટા સ્રોત હોય છે,
સત્ય સ્ત્રોત છે.

137
00:06:13,150 --> 00:06:15,790
તે તમારા ઘટકો કહે
કેવી રીતે આ પાનું બહાર મૂકે છે,

138
00:06:15,790 --> 00:06:18,190
અને ઘટકો કરશે
ક્રિયાપ્રતિક્રિયા હાથ ધરે છે.

139
00:06:18,190 --> 00:06:20,150
અને તેઓ બદલી કરવા માંગો છો તો
વસ્તુઓ માત્ર પાછા જાઓ

140
00:06:20,150 --> 00:06:21,750
અને ડેટા સ્રોત બદલવા માટે કહો.

141
00:06:21,750 --> 00:06:22,850
અર્થમાં બનાવવા?

142
00:06:22,850 --> 00:06:26,010
તેથી પ્રતિક્રિયા સમજી વિશે છે
કેવી રીતે ઘટક બિલ્ડ

143
00:06:26,010 --> 00:06:29,540
અને તમારા ઘટક બનાવવા માટે કેવી રીતે
બહારના વિશ્વ સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

144
00:06:29,540 --> 00:06:31,850
>> ઘટક સંચાર બનાવી
બહારના વિશ્વ સાથે

145
00:06:31,850 --> 00:06:34,490
અન્ય ટેક્નોલોજી વાપરે
કહેવાય વહેણ, જે

146
00:06:34,490 --> 00:06:36,872
છે કે જે ફ્રેમવર્ક છે
પ્રતિક્રિયા ટોચ પર ઉમેરવામાં આવે છે.

147
00:06:36,872 --> 00:06:38,330
અમે તે વિશે વાત કરવા જઈ રહ્યાં છો.

148
00:06:38,330 --> 00:06:42,990
અમે આપવામાં વિશે વધુ વાત કરવા જઈ રહ્યાં
માહિતી, તમે કેવી રીતે એક ઘટક રેન્ડર કરી શકો છો?

149
00:06:42,990 --> 00:06:47,010
>> અને તેથી તમે, કારણ કે ખરેખર સરસ છે પ્રતિક્રિયા
તમે ઇચ્છો તે કોઇપણ પાછા ઓવરને સાથે તેનો ઉપયોગ કરી શકો છો.

150
00:06:47,010 --> 00:06:50,480
તમે Python પાછળ ઓવરને જેવા હોય છે,
તમારા પાયથોન અમુક માહિતી બહાર બોલે શકો છો,

151
00:06:50,480 --> 00:06:51,610
રેન્ડર કરી શકો છો પ્રતિક્રિયા.

152
00:06:51,610 --> 00:06:54,700
તમે કોઈ જેએસ આઉટપુટ હોય તો
માહિતી પ્રતિક્રિયા તે રેન્ડર કરે છે.

153
00:06:54,700 --> 00:06:56,890
રૂબી સાથે ટ્રેનની
માહિતી પ્રતિક્રિયા તે રેન્ડર કરે છે.

154
00:06:56,890 --> 00:07:01,860
>> તેથી પ્રતિક્રિયા મૂળભૂત વેબ
ઘટકો સાથે ફ્રન્ટ ઓવરને view--

155
00:07:01,860 --> 00:07:03,910
બિલકુલ કોઇપણ માહિતી સ્ત્રોત માટે.

156
00:07:03,910 --> 00:07:07,145
અને તેથી માહિતી સ્ત્રોત માંથી કરવા જઇ
ઘટકો પ્રતિક્રિયા ખૂબ સરળ છે.

157
00:07:07,145 --> 00:07:08,770
અન્ય માર્ગ જઈને થોડી સખત હોય છે.

158
00:07:08,770 --> 00:07:10,462
હું પહેલાં તમારો ઉલ્લેખ કર્યો છે, કારણ કે પ્રવાહ ઉપયોગ કરે છે.

159
00:07:10,462 --> 00:07:11,420
અમે તે માં મળશે નહીં.

160
00:07:11,420 --> 00:07:13,740
અમે પર વધુ ધ્યાન કેન્દ્રિત પડશે
માહિતી ટુ ઘટક બાજુ.

161
00:07:13,740 --> 00:07:15,880
તમે કરી શકો છો આ રીતે
સરસ, મજા વેબ એપ્લિકેશન્સ.

162
00:07:15,880 --> 00:07:19,870
તે બહારના વિશ્વ અસર થશે નહીં
હવે માટે, પરંતુ તે અન્ય વાર્તા છે.

163
00:07:19,870 --> 00:07:22,210
>> ઠીક છે, તેથી જો તમે અહીં હતા
મારા છેલ્લા પરિસંવાદ માટે

164
00:07:22,210 --> 00:07:26,610
તમે માટે કોડ કે જે બધા ખબર પડશે
આજે ચર્ચા આ URL પર હોઈ ચાલે છે

165
00:07:26,610 --> 00:07:29,320
અહીં, માફ કરશો, અહીં આ URL.

166
00:07:29,320 --> 00:07:32,730
અને મૂળભૂત અમે જાઓ જઈ રહ્યાં છો
કદાચ ચાર પગલાંઓ પાંચ દ્વારા

167
00:07:32,730 --> 00:07:33,510
કદાચ નથી પાંચ.

168
00:07:33,510 --> 00:07:37,300
અમે ચાર પગલાંઓ મારફતે ખસેડવા પડશે
એક નમૂનો મકાન એપ્લિકેશન પ્રતિક્રિયા.

169
00:07:37,300 --> 00:07:39,550
અને તેથી તમામ સ્રોત કોડ
જે રીતે દરેક પગલું માટે

170
00:07:39,550 --> 00:07:42,216
તેથી, જો અહીં હોઈ ચાલે છે
તમે ઘરે સાથે અનુસરી રહ્યાં છો

171
00:07:42,216 --> 00:07:43,991
આ કોડ વાંચી જવું મફત લાગે.

172
00:07:43,991 --> 00:07:46,740
તમે અહીં સાથે અનુસરી રહ્યાં છો, તો
અમે સ્ક્રીન પર દર્શાવે છે આવશે

173
00:07:46,740 --> 00:07:47,739
તેથી તે વિશે ચિંતા કરશો નહીં.

174
00:07:47,739 --> 00:07:50,930
પરંતુ તમે ઘરે હો તો, લાગે છે
આ વેબસાઇટની મુલાકાત લો કરવા માટે મુક્ત.

175
00:07:50,930 --> 00:07:56,400
અને, હા, તમે વિચાર કરવાનો પ્રયત્ન કરીશું
તમે ક્યારેય અહીં જરૂર કરશો બધા કોડ.

176
00:07:56,400 --> 00:08:01,380
તેથી તે એક સારો ખાણિયાઓને છેતરે છે શીટ તેમજ છે
સાથે તમારા ભવિષ્યના એડવેન્ચર્સ પ્રતિક્રિયા.

177
00:08:01,380 --> 00:08:04,490
કૂલ જો આમ હોય, અહીં છે જે દરેક વ્યક્તિને
અને તમે ઘરમાં છો, પણ જો

178
00:08:04,490 --> 00:08:11,580
is.gd/cs50react, આ વેબસાઈટ ઉપર ખેંચે છે,
કોઈ મૂડી કોઈ અન્ડરસ્કૉર, કોઈ કંઈ નથી.

179
00:08:11,580 --> 00:08:15,849
>> તમે લાગે છે કે પાનું જોશો
આ જેવી થોડી છે.

180
00:08:15,849 --> 00:08:17,140
આ CodePen કહેવાય વસ્તુ છે.

181
00:08:17,140 --> 00:08:20,030
CodePen એક સહયોગી છે
કોડિંગ પર્યાવરણ

182
00:08:20,030 --> 00:08:23,364
જેની સાથે હું અહીં કોડ લખવા શકે છે, અને
તે આપોઆપ તમને મોકલવામાં આવશે.

183
00:08:23,364 --> 00:08:24,780
અને આ રીતે, હું કોડ લખી શકો છો.

184
00:08:24,780 --> 00:08:26,920
હું અહીં કોડ ચલાવી શકો છો.

185
00:08:26,920 --> 00:08:33,470
>> ઉદાહરણ માટે અને તેને જોવા reloads-- તો,
હું પૃષ્ઠ પર JavaScript કોડ ચાલી રહ્યો છું

186
00:08:33,470 --> 00:08:36,390
અહીં છે, અને તે પડશે
આપમેળે વેબ પાનું રેન્ડર

187
00:08:36,390 --> 00:08:37,980
આ JavaScript કોડ સાથે.

188
00:08:37,980 --> 00:08:40,039
અને તેથી આ એક માર્ગ છે
યુએસ કોડ અજમાવી માટે

189
00:08:40,039 --> 00:08:43,089
ઉપયોગ કર્યા વગર ખરેખર ઝડપી
અમારા ID અથવા અમારા સ્થાનિક મશીન ઉપયોગ

190
00:08:43,089 --> 00:08:44,290
અથવા ગમે.

191
00:08:44,290 --> 00:08:47,670
તે તમને mockup માટે ખૂબ જ ઝડપી રીત છે
અને કોડ ઓફ વિવિધ પ્રકારના બહાર પરીક્ષણ કરો.

192
00:08:47,670 --> 00:08:50,560
>> તેથી હું લઈ શકાય જાઉં છું
ઉદાહરણ કોડ, અહીં તે મૂકે.

193
00:08:50,560 --> 00:08:52,374
અમે તે મારફતે કામ કરવા માટે જઈ રહ્યાં છો.

194
00:08:52,374 --> 00:08:54,540
અને તમે ઘરમાં હો, તો તમે
તેમજ આ અપ ખેંચી શકે છે.

195
00:08:54,540 --> 00:08:57,530
અને હું પહેલેથી જ ઇન્સ્ટોલ કર્યું
અહીં પ્રતિક્રિયા, જેથી તમે માત્ર આ કરી શકો છો

196
00:08:57,530 --> 00:09:00,770
અહીં તમારી પોતાની કોડ લખવા, અને
તમારા પોતાના રમતનું મેદાન, કે પ્રયાસ કરો.

197
00:09:00,770 --> 00:09:04,940
>> અરે વાહ, દરેકને તો
અહીં આ લિંક ખોલો.

198
00:09:04,940 --> 00:09:08,080
મને એક અંગૂઠા આપો
તમે તેને ખોલવા એક વાર ઉપર.

199
00:09:08,080 --> 00:09:10,960

200
00:09:10,960 --> 00:09:13,770
કૂલ, ઠંડી ઠંડી.

201
00:09:13,770 --> 00:09:16,914
કંઇ, હવે અહીં છે, પરંતુ
અમે ખૂબ જ ટૂંક સમયમાં ફેરફાર થશે.

202
00:09:16,914 --> 00:09:21,250
>> ઠીક છે, તેથી જાવાસ્ક્રિપ્ટ છે પ્રતિક્રિયા
લાઇબ્રેરી છે, અને જેમ કે,

203
00:09:21,250 --> 00:09:24,480
, જાવાસ્ક્રિપ્ટ જ્ઞાન જરૂરી છે
જે વેબ પ્રોગ્રામિંગ ભાષા છે.

204
00:09:24,480 --> 00:09:27,660
અને તે અન્ય વસ્તુઓ માટે ઉપયોગ કરવામાં આવી રહ્યો
હવે ખૂબ પરંતુ મુખ્યત્વે વેબ વિકાસ

205
00:09:27,660 --> 00:09:32,040
ભાષા, તમારી સાથે પરિચિત નહિં હોય, તેથી જો
કે, JSforCats.com કહેવાય સાઇટ વાંચો.

206
00:09:32,040 --> 00:09:32,700
તે અદ્ભુત છે.

207
00:09:32,700 --> 00:09:34,240
જાવાસ્ક્રિપ્ટ જાણી શકો છો
અડધા કલાક માં.

208
00:09:34,240 --> 00:09:34,990
તે અકલ્પનીય છે.

209
00:09:34,990 --> 00:09:36,420
>> તેથી તે વાંચો આપે છે.

210
00:09:36,420 --> 00:09:39,960
અમે પણ કારણ કે અહીં HTML ઘણો છે
અમે અલબત્ત વેબ પાનાંઓ ડિઝાઇન કરી રહ્યાં છીએ.

211
00:09:39,960 --> 00:09:43,890
તમે સાથે પરિચિત નહિં હોય, તો તેથી
એચટીએમએલ, HTMLdog.com તપાસો.

212
00:09:43,890 --> 00:09:46,520
હું પ્રતિક્રિયા એક છે શીખવાની લાગે
મિલિયન વખત સરળ પહેલેથી જ તમે તો

213
00:09:46,520 --> 00:09:47,892
રચનાત્મક ખબર.

214
00:09:47,892 --> 00:09:50,600
તમે ઘટકો હોય, તો તે છે
સરળ એક મોટી ઘટક બનાવે છે.

215
00:09:50,600 --> 00:09:51,860
એટલે કે, તમે ભાષા પ્રતિક્રિયા છે.

216
00:09:51,860 --> 00:09:54,270
>> તેથી આગળ વધો અને આપી
આ વસ્તુઓ વાંચો.

217
00:09:54,270 --> 00:09:55,070
આ વિડિઓ થોભો.

218
00:09:55,070 --> 00:09:57,440
તમે હો તો તે વાંચો આપો
તમે ઘરે ન હોય તો

219
00:09:57,440 --> 00:10:00,794
HTML અથવા JavaScript સાથે પરિચિત

220
00:10:00,794 --> 00:10:02,960
ઠીક છે, તેથી અમે જઈ રહ્યાં છો શું
શું આપણે કરી રહ્યા છીએ છે

221
00:10:02,960 --> 00:10:06,470
પ્રતિક્રિયા મદદથી ખૂબ જ મૂળભૂત flashcard એપ્લિકેશન.

222
00:10:06,470 --> 00:10:08,210
અમે એક flashcard હોય રહ્યા છીએ.

223
00:10:08,210 --> 00:10:09,880
તમે પાછા અને આગળ કાર્ડ વિમાનની મુસાફરી કરી શકે છે.

224
00:10:09,880 --> 00:10:12,399
અને અમે પણ યાદી પડશે
અમે કે જે બધા કાર્ડ,

225
00:10:12,399 --> 00:10:14,190
અને અમે લાગણી કરી રહ્યાં છો, તો
મહત્વાકાંક્ષી, અમે હોઈ શકે છે

226
00:10:14,190 --> 00:10:17,060
વચ્ચે સ્વિચ કરવા માટે સક્ષમ
તેમના પર ક્લિક કરીને કાર.

227
00:10:17,060 --> 00:10:20,360
>> પરંતુ આ તમારા એકદમ, છે
હાડકાં, ખૂબ જ સરળ એપ્લિકેશન પ્રતિક્રિયા.

228
00:10:20,360 --> 00:10:22,560
અને તેથી આ ખરેખર છે
અમલ કરવા માટે તુચ્છ નથી,

229
00:10:22,560 --> 00:10:26,030
પરંતુ અમે તમને હોય તો, તે બતાવવા જઈ રહ્યાં છો
આ તે વિસ્તારવા માટે ખૂબ, ખૂબ સરળ છે

230
00:10:26,030 --> 00:10:27,680
અન્ય લોકો તેની સાથે તમને મદદ કરે છે.

231
00:10:27,680 --> 00:10:33,750
તેથી અમે ચાર પગલાંઓ મારફતે જાઓ જઈ રહ્યાં છો
શરૂઆતથી શરૂ આ બીલ્ડ કરવા.

232
00:10:33,750 --> 00:10:36,740
>> ઠીક છે, તેથી આ ચાર પગલાંઓ, અમે પડશે
પ્રથમ પગલું સાથે બંધ શરૂ કરો.

233
00:10:36,740 --> 00:10:39,790
પ્રથમ પગલું હોઈ રહ્યું છે
તમારા પ્રથમ ઘટક મકાન.

234
00:10:39,790 --> 00:10:44,830
હું પહેલાં જણાવ્યું હતું કે, એક ઘટક પ્રતિક્રિયા
સ્ટેરોઇડ્સ પર માત્ર એક HTML તત્વ છે.

235
00:10:44,830 --> 00:10:49,660
તે HTML સ્પષ્ટ
અને કેટલાક વર્તન, અને તે

236
00:10:49,660 --> 00:10:52,600
લોકો કેવી રીતે સ્પષ્ટ થશે
તે કેવી રીતે સાથે સંપર્ક કરી શકો છો

237
00:10:52,600 --> 00:10:54,270
તે આંતરિક રાજ્ય હશે.

238
00:10:54,270 --> 00:10:57,630
એક બટન કેટલા જેવા જાણતા હશે જેમ
વખત તે, ઉદાહરણ તરીકે ક્લિક કરવામાં આવી છે,

239
00:10:57,630 --> 00:11:01,010
અને તે પોતે બહાર મૂકે કેવી રીતે ખબર પડશે.

240
00:11:01,010 --> 00:11:04,430
>> તેથી આપણે આગળ વધીશું અને બિલ્ડ દો અમારા
જાવાસ્ક્રિપ્ટ ઉપયોગ કરીને પ્રથમ ઘટક.

241
00:11:04,430 --> 00:11:09,711
વાક્યરચના વિચિત્ર લાગે છે તેથી જો,
તે પ્રકારની છે કારણ કે તે છે.

242
00:11:09,711 --> 00:11:11,710
તેથી, ફરી, અમે જઈ રહ્યાં છો
એક ચલ કહેવાય બનાવવા માટે

243
00:11:11,710 --> 00:11:14,580
એપ્લિકેશન શબ્દ દો વાપરી રહ્યા હોય,
જે એક ચલ છે,

244
00:11:14,580 --> 00:11:18,210
એપ્લિકેશન સમાન React.createClass દો.

245
00:11:18,210 --> 00:11:22,609
>> પ્રતિક્રિયા એક પુસ્તકાલય છે અને છે
વર્ગ કાર્ય બનાવો.

246
00:11:22,609 --> 00:11:24,400
અને આ કાર્ય છે
કોડ એક બીટ કે જે તમે

247
00:11:24,400 --> 00:11:29,090
નવી બનાવવા માટે ઉપયોગ કરી શકો છો
ઘટક પ્રતિક્રિયા પ્રકાર.

248
00:11:29,090 --> 00:11:32,780
અને તેથી React.createClass
એક ઘટક બનાવે છે,

249
00:11:32,780 --> 00:11:35,270
અને આ ઘટક કરશે
સામગ્રી કરવા માટે સક્ષમ છે.

250
00:11:35,270 --> 00:11:40,460
તે કરી શકો છો મુખ્ય વસ્તુ રેન્ડર છે
કંઈક એક કાર્ય તરીકે રેન્ડર.

251
00:11:40,460 --> 00:11:44,500
>> ફરીથી, આ ઇન્ડેક્સ સ્પષ્ટ ન હોય તો
તમે, હું તમને બિલાડીઓ માટે જેએસ પર જવા ભલામણ

252
00:11:44,500 --> 00:11:45,682
અને તે તપાસો.

253
00:11:45,682 --> 00:11:47,710
સાજો કે ઝૂમ કરેલું છે?

254
00:11:47,710 --> 00:11:48,490
કૂલ.

255
00:11:48,490 --> 00:11:50,670
>> તેથી દરેક ઘટક જરૂરિયાતો
એક રેન્ડર કાર્ય છે.

256
00:11:50,670 --> 00:11:53,010
રેન્ડર કાર્ય કહે છે
હું સ્ક્રીન પર શું છાપો નથી?

257
00:11:53,010 --> 00:11:54,760
પરંતુ ઘટક છે
જો તેમ ન હોય તો નકામું

258
00:11:54,760 --> 00:11:58,060
તેથી, સ્ક્રીન પર શું છાપવા માટે ખબર
તમે રેન્ડર કાર્ય કરવાની જરૂર છે.

259
00:11:58,060 --> 00:12:01,904
>> આ, તમે વસ્તુ રેન્ડર તેથી
માત્ર કેટલાક એચટીએમએલ પરત કરવાની જરૂર છે.

260
00:12:01,904 --> 00:12:03,820
અને શું ઠંડી છે કે છે
કહેવાય વસ્તુ છે

261
00:12:03,820 --> 00:12:08,660
એક એક્સટેન્સન છે કે જે JSX,
દ્વારા ઉપયોગ થાય છે જે જાવાસ્ક્રિપ્ટ પ્રતિક્રિયા.

262
00:12:08,660 --> 00:12:11,845
તે તમને અંદર HTML લખવા ચાલો
તમારા જાવાસ્ક્રિપ્ટ, જે

263
00:12:11,845 --> 00:12:13,970
જ્યારે વિચિત્ર પ્રકારની લાગે છે
તમે પ્રથમ તે વિશે વિચારો,

264
00:12:13,970 --> 00:12:15,553
પરંતુ તે પછી અર્થમાં ઘણો બનાવે છે.

265
00:12:15,553 --> 00:12:17,430
તેથી અમે આ કરી શકો છો.

266
00:12:17,430 --> 00:12:21,360
તમે HTML સાથે પરિચિત કરશો, તો મને ખબર
અમે સામાન્ય હેતુ સાથે div છે

267
00:12:21,360 --> 00:12:22,790
સામગ્રી માટે કન્ટેનર.

268
00:12:22,790 --> 00:12:26,380
અમે અંદર એક div પાછા શકે છે, અને
આ div, અમે સામગ્રી મૂકી શકો છો.

269
00:12:26,380 --> 00:12:32,390
>> તેથી ચાલો આપણે માત્ર રેન્ડર કરવા માંગો છો કહે દો
હવે એક સીધી અપ flashcard.

270
00:12:32,390 --> 00:12:34,890
આ flashcard, હું કહે છે
એક પ્રશ્ન અને જવાબ હશે.

271
00:12:34,890 --> 00:12:37,530
તેથી આ div અંદર, ચાલો
એક ફકરો છાપે

272
00:12:37,530 --> 00:12:42,155
કે શું છે question-- કહે
જીવન માટે અંતિમ જવાબ, બ્રહ્માંડ?

273
00:12:42,155 --> 00:12:47,640

274
00:12:47,640 --> 00:12:50,345
અને પછી જવાબ છે
42, અલબત્ત, હોઈ ચાલે.

275
00:12:50,345 --> 00:12:56,880

276
00:12:56,880 --> 00:12:59,730
>> તે બધા પર સારી આવી ન હતી.

277
00:12:59,730 --> 00:13:04,164
અરે વાહ, જેથી મૂળભૂત રીતે તમે ખરેખર કરી શકો છો
તમારા જાવાસ્ક્રિપ્ટ અંદર HTML લખો.

278
00:13:04,164 --> 00:13:06,330
અને આ હોઈ ચાલે છે
સ્ક્રીન માં છપાયેલ.

279
00:13:06,330 --> 00:13:08,250
તેથી તે બહાર પ્રયાસ કરીએ.

280
00:13:08,250 --> 00:13:09,520
>> જેથી અમે અમારા ઘટક છે.

281
00:13:09,520 --> 00:13:12,210
અમે મૂકી પ્રતિક્રિયા કહેવું જરૂર
સ્ક્રીન પર ઘટક

282
00:13:12,210 --> 00:13:18,990
તેથી React.render, જેથી નોંધ્યું છે કે અમે
અન્ય કોઇ તત્વ જેવા એપ્લિકેશન સારવાર.

283
00:13:18,990 --> 00:13:21,010
તે HTML તત્વ હતું કે અમે તે લખો.

284
00:13:21,010 --> 00:13:25,100
બદલે img જેવા કહીને જેવી
ફકરો માટે છબી અથવા પી માટે,

285
00:13:25,100 --> 00:13:28,120
એપ્લિકેશન છે, જેથી તમે એપ્લિકેશન લખવા
એક HTML તત્વ જેવા ગણવામાં આવે છે.

286
00:13:28,120 --> 00:13:30,380
હું પહેલાં જણાવ્યું હતું કે, તે છે
સ્ટેરોઇડ્સ પર એક તત્વ.

287
00:13:30,380 --> 00:13:32,870
>> તેથી જો તમે એપ્લિકેશન રેન્ડર છે, અને તમે
તે મૂકી સ્થળ આપે છે.

288
00:13:32,870 --> 00:13:37,170
અને આ કેવી રીતે તમે આ કરી શકો છો છે
જ્યાં તે મૂકવામાં તે કહો.

289
00:13:37,170 --> 00:13:46,200
હું પર એક સરળ div બનાવેલ છે
પાનાંની એક ID સાથે કહેવાય પાનું,

290
00:13:46,200 --> 00:13:48,300
અને તે જ્યાં છે
તત્વ જવા માટે ચાલે છે.

291
00:13:48,300 --> 00:13:49,841
>> અને અમે HTML સાથે ચલાવવા માટે જઈ રહ્યાં છો.

292
00:13:49,841 --> 00:13:53,145
મૂળભૂત રીતે આ વિચાર રહ્યું છે
આ પાનું તત્વ ની અંદર મૂકી

293
00:13:53,145 --> 00:13:54,270
અમે સ્ક્રીન પર હોય છે.

294
00:13:54,270 --> 00:13:59,210
તેથી તે આ કોડ ચાલે છે, અને તે આ ખેંચે
સ્ક્રીન પર વસ્તુ છે, તેથી અહીં આપણે છે.

295
00:13:59,210 --> 00:14:01,770
અમે અમારી પ્રથમ પ્રતિક્રિયા ઘટક કર્યા છે.

296
00:14:01,770 --> 00:14:08,000
>> તેથી માત્ર એક રીકેપ, અમે ધીમેધીમે કરવામાં
ઘટક એક નવા પ્રકારની, અધિકાર?

297
00:14:08,000 --> 00:14:10,145
તે શું React.createClass છે.

298
00:14:10,145 --> 00:14:12,680
અને તે ઘટક, અમે
તે શું કરવું જોઈએ તે જણાવ્યું હતું.

299
00:14:12,680 --> 00:14:15,590
જ્યારે આ ઘટક છે
સ્ક્રીન પર છપાશે,

300
00:14:15,590 --> 00:14:19,300
તે વિભાગ સાથે છાપશે
તે અંદર બે ફકરા.

301
00:14:19,300 --> 00:14:24,460
>> અને અમે શું કર્યું, અમે એક નવી એપ્લિકેશન બનાવી
કોણ કૌંસ એપ્લિકેશન સંકેતલિપિ ની મદદથી.

302
00:14:24,460 --> 00:14:27,160
અમે તેને મૂકવા તે જણાવ્યું હતું
આ પાનું તત્વ પર આધારિત છે.

303
00:14:27,160 --> 00:14:29,867
અને તેથી હું શું તે બનાવવામાં
કે નમૂના માંથી નવા એપ્લિકેશન.

304
00:14:29,867 --> 00:14:31,200
અને પછી હું તે રેન્ડર કરવા માટે જણાવ્યું હતું.

305
00:14:31,200 --> 00:14:33,680
તેથી તે જણાવ્યું હતું કે, ઠીક છે, એપ્લિકેશન,
હું શું છાપે જોઈએ?

306
00:14:33,680 --> 00:14:36,970
એપ્લિકેશન, એક DIV છાપે જવા કહે
તે અંદર બે ફકરા સાથે.

307
00:14:36,970 --> 00:14:40,420
અને વોઇલા Query, સાથે અમારી DIV છે
તે અંદર બે ફકરા.

308
00:14:40,420 --> 00:14:43,180
અત્યાર સુધી અર્થમાં બનાવવા?

309
00:14:43,180 --> 00:14:46,690
>> તેથી, ફરી, સમગ્ર પડકાર પ્રતિક્રિયા
માત્ર ઘટકો બનાવવા માટે કેવી રીતે જાણ્યા છે.

310
00:14:46,690 --> 00:14:48,500
આ કેવી રીતે બનાવવા માટે
ઘટકો સાથે મળીને કામ.

311
00:14:48,500 --> 00:14:51,780
હવે અમે અમારી પ્રથમ કરેલા
ઘટક પાછા જવા દો

312
00:14:51,780 --> 00:14:54,284
અને ઘટકો વૈવિધ્યપૂર્ણ બનાવવા.

313
00:14:54,284 --> 00:14:56,700
તેથી જો તમે HTML માં કેવી રીતે ખબર તમે
તમારા બટનો વર્ગો આપી શકે છે?

314
00:14:56,700 --> 00:14:59,146
તમે તમારા મેજબાન આ href આપી શકે છે.

315
00:14:59,146 --> 00:15:00,770
તમે અધિકાર છે, તમારી ઇનપુટ્સ એક પ્રકાર આપી શકે છે?

316
00:15:00,770 --> 00:15:04,740
તમે વધુ વૈવિધ્યપૂર્ણ આપી શકે છે
તમારા બધા તત્વો ગુણધર્મો

317
00:15:04,740 --> 00:15:06,490
તે વધુ રસપ્રદ બનાવવા માટે.

318
00:15:06,490 --> 00:15:09,030
અને અમે ખરેખર શું કરી શકો છો
ચોક્કસ જ વસ્તુ.

319
00:15:09,030 --> 00:15:17,500
>> તેથી ચાલો આપણે માંગો છો કહેવું અમારા
એપ્લિકેશન કોઈપણ કાર્ડ રેન્ડર જાઓ.

320
00:15:17,500 --> 00:15:19,630
હમણાં અમે માત્ર
એક હાર્ડકોડ કાર્ડ રેન્ડર.

321
00:15:19,630 --> 00:15:22,530
અમે ત્યાં માત્ર એક જ છે ખબર
કાર્ડ તે કરી શકો છો, તેથી અમે છો

322
00:15:22,530 --> 00:15:25,960
પ્રયત્ન કરો અને તેથી હવે આ બદલવા માટે ચાલુ
અમે હમણાં જ તે કેટલાક કાર્ડ આપી શકે છે.

323
00:15:25,960 --> 00:15:27,410
તે કાર્ડ છાપે પડશે.

324
00:15:27,410 --> 00:15:29,380
>> તમે પ્રયાસ કરો અને બનાવવા માટે હિતાવહ તમારા
ઘટકો એક ખૂબ જ સામાન્ય હેતુ.

325
00:15:29,380 --> 00:15:31,654
તેથી આ રીતે હું ઇમેઇલ શકે
આ મારા મિત્ર અને જેમ હોઈ શકે છે,

326
00:15:31,654 --> 00:15:33,820
તમારી પાસે ગમે flashcard,
માત્ર અહીં તેને ખવડાવવા,

327
00:15:33,820 --> 00:15:35,290
અને તે પોતાની રીતે તે કરવું પડશે.

328
00:15:35,290 --> 00:15:37,650
તમે અન્ય મૂકી શકો છો
તમારા પોતાના એપ્લિકેશન વસ્તુઓ.

329
00:15:37,650 --> 00:15:40,600
>> પરંતુ પ્રથમ, ચાલો આ તોડી દો
બે ઘટકો માં,

330
00:15:40,600 --> 00:15:44,500
પરંતુ અમે કાર્ડ અલગ કરવા માંગો છો
વાસ્તવિક એપ્લિકેશન ભાગ માંથી પ્રિન્ટીંગ ભાગ.

331
00:15:44,500 --> 00:15:46,660
તેથી અમે શું કરી શકો છો અમે છે
એપ્લિકેશન આ બદલી શકો છો

332
00:15:46,660 --> 00:15:51,300
CardView માટે, માત્ર એક
એપ્લિકેશન માટે નવું નામ,

333
00:15:51,300 --> 00:15:54,450
અને અમે નવા કરી શકો છો
ઘટક એપ્લિકેશન કહેવાય

334
00:15:54,450 --> 00:15:56,336
જૂના એપ્લિકેશન સાથે ભેળસેળ ન શકાય.

335
00:15:56,336 --> 00:16:00,730
અમે createClass મળી છે,
અને HTML માં જેમ,

336
00:16:00,730 --> 00:16:03,590
તમે માળો ઘટકો પ્રતિક્રિયા કરી શકે છે
દરેક અન્ય પર આધારિત છે.

337
00:16:03,590 --> 00:16:16,430
>> આ રેન્ડર કાર્ય તેથી
કાર્ય વળતર CardView,

338
00:16:16,430 --> 00:16:18,234
અને આ ચોક્કસ જ વસ્તુ છે.

339
00:16:18,234 --> 00:16:19,400
તે જ વસ્તુ છે શા માટે જુઓ?

340
00:16:19,400 --> 00:16:22,590
તેના બદલે માત્ર એપ્લિકેશન રેન્ડરીંગ કે
, તે અંદર DIV અને જોડ છે

341
00:16:22,590 --> 00:16:26,194
એપ્લિકેશન CardView રેન્ડર છે, અને
CardView આ div અને ફકરા રેન્ડર કરે છે.

342
00:16:26,194 --> 00:16:29,110
તેથી આ અમારી પ્રથમ ઉદાહરણ છે
દરેક અન્ય અંદર માળો તત્વો છે.

343
00:16:29,110 --> 00:16:32,177
કે અર્થમાં છે?

344
00:16:32,177 --> 00:16:33,760
તેથી, ફરી, અમે એક CardView તત્વ છે.

345
00:16:33,760 --> 00:16:37,250
અમે એપ્લિકેશન તત્વો હોય છે
તે કરતાં મોટી છે છે.

346
00:16:37,250 --> 00:16:40,990
>> ઠીક છે, તેથી અમે માંગો છો અમારા CardView-- જો તમે
આ બોલ પર કોઈ CardView ચોક્કસ કાર્ડ આપે છે,

347
00:16:40,990 --> 00:16:43,370
તે અધિકાર તમારા માટે છાપે પડશે?

348
00:16:43,370 --> 00:16:48,050
તેથી પ્રથમ, અમે એક કાર્ડ બનાવવા માટે જરૂર છે,
તેથી આપણે એક કાર્ડ પદાર્થ બનાવવા દો.

349
00:16:48,050 --> 00:17:02,930
તેથી મારા કાર્ડ દો સમાન
તમે બધા પરિચિત છો, તો

350
00:17:02,930 --> 00:17:05,260
આ માત્ર નોટેશનમાં નિર્માણ છે
જાવાસ્ક્રિપ્ટ પદાર્થ.

351
00:17:05,260 --> 00:17:09,280
તે સ્ટ્રક્ટ જેવા પ્રકારની છે
સી, તેથી અમે એક કાર્ડ કરવામાં

352
00:17:09,280 --> 00:17:15,920
અને તેથી હવે અમે આ કાર્ડ પસાર કરી શકો છો
મિલકત અથવા HTML એક લક્ષણ તરીકે

353
00:17:15,920 --> 00:17:17,290
અમારા એપ્લિકેશન પરિભાષા.

354
00:17:17,290 --> 00:17:20,210
તેથી અમે આ એપ્લિકેશન કરી શકો છો
કાર્ડ MyCard સમકક્ષ હોય છે.

355
00:17:20,210 --> 00:17:23,200
>> તમે ઇનપુટ, તમે કેવી રીતે ખબર
ઇનપુટ પ્રકાર ટેક્સ્ટ અથવા બટન બરાબર

356
00:17:23,200 --> 00:17:25,240
વર્ગ બુટસ્ટ્રેપ માટે બીટીએન સમકક્ષ ,?

357
00:17:25,240 --> 00:17:29,500
જ વિચાર માટે, એપ્લિકેશન કાર્ડ બરાબર
તમે કૌંસ મૂકી મળી છે અહીં

358
00:17:29,500 --> 00:17:33,830
એપ્લિકેશન કાર્ડ MyCard બરાબર છે, તેથી આ
અમે આ કાર્ડ પદાર્થ હોય છે.

359
00:17:33,830 --> 00:17:39,149
હું, કે પાસ જાઉં છું
એપ્લિકેશન ઘટક મિલકત.

360
00:17:39,149 --> 00:17:41,440
અને આ એપ્લિકેશન ઘટક કરશે
તેને ઍક્સેસ કરવા માટે સક્ષમ હશે અને શું

361
00:17:41,440 --> 00:17:43,580
તે સાથે રસપ્રદ સામગ્રી.

362
00:17:43,580 --> 00:17:47,650
>> તેથી અમારા એપ્લિકેશન પ્રયત્ન રહ્યું છે
એક કાર્ડ આપવામાં આવે છે, તેથી હવે,

363
00:17:47,650 --> 00:17:49,980
માત્ર આપે છે એપ્લિકેશન કરી દો
આ CardView માટે કાર્ડ

364
00:17:49,980 --> 00:17:53,110
પોતે એપ્લિકેશન નથી જેવી છે, કારણ
તેની સાથે શું કરવું તે ખબર નથી જતા,

365
00:17:53,110 --> 00:17:54,850
તેથી આપણે ફક્ત CardView તે આપી શકશો.

366
00:17:54,850 --> 00:18:00,050
તેથી અમે તેને પસાર પડશે
એ જ રીતે, કાર્ડ, બરાબર

367
00:18:00,050 --> 00:18:05,426
અને તેથી દરેક ઘટક ઍક્સેસ કરી શકો છો
તે આપવામાં આવી છે કે જે વસ્તુઓ.

368
00:18:05,426 --> 00:18:07,800
તેઓ ગુણધર્મો ઍક્સેસ કરી શકો છો
તે આપવામાં આવી છે

369
00:18:07,800 --> 00:18:09,470
this.props.card, આ વાક્યરચના મદદથી.

370
00:18:09,470 --> 00:18:12,010

371
00:18:12,010 --> 00:18:14,920
>> તેથી શું અહીં છે થાય છે
તમે MyCard પદાર્થ હોય છે.

372
00:18:14,920 --> 00:18:18,250
તમે એપ્લિકેશન માં પસાર
એપ્લિકેશન કાર્ડનો ઉપયોગ MyCard સમકક્ષ હોય છે.

373
00:18:18,250 --> 00:18:21,420
કે કાર્ડ પદાર્થ તમારી એપ્લિકેશન માટે આપવામાં આવે છે.

374
00:18:21,420 --> 00:18:24,400
એપ્લિકેશન ઍક્સેસ કરી શકો છો
this.props.card છે.

375
00:18:24,400 --> 00:18:28,780
તે એક છબી જેવા પ્રકારની છે
તે સ્ત્રોત છે તે જાણે છે.

376
00:18:28,780 --> 00:18:31,972
>> આ એપ્લિકેશન તે કાર્ડ શું જાણે
છે, અને તે સાથે સામગ્રી કરી શકો છો.

377
00:18:31,972 --> 00:18:32,930
તે ગણતરીઓ કરી શકો છો.

378
00:18:32,930 --> 00:18:35,290
તે બંધ આધારિત નિર્ણયો કરે છે.

379
00:18:35,290 --> 00:18:39,950
>> હવે માટે, હું પસાર થઇ રહ્યા હતા
આ CardView પર this.props.card.

380
00:18:39,950 --> 00:18:43,420
અત્યાર સુધી અર્થમાં બનાવવા?

381
00:18:43,420 --> 00:18:45,210
તે હવે વધુ અર્થમાં બનાવવા પડશે.

382
00:18:45,210 --> 00:18:46,990
>> ઠીક છે, તેથી હવે અમે CardView છો.

383
00:18:46,990 --> 00:18:51,719
કાર્ડ આપવામાં અમારી CardView, જોઈએ
તેના પ્રશ્ન અને જવાબ છાપશે.

384
00:18:51,719 --> 00:18:54,510
હમણાં અમે માત્ર છપાયેલ કેટલાક
હાર્ડકોડ પ્રશ્નો અને જવાબો.

385
00:18:54,510 --> 00:18:57,720
આપણે જરૂર out-- આકૃતિ જરૂર
તેઓ અમને આપ્યું કે કાર્ડ પૂછો

386
00:18:57,720 --> 00:19:01,360
શું પ્રશ્ન અને જવાબ છે, અને
પછી સ્ક્રીન આ છાપશે.

387
00:19:01,360 --> 00:19:02,470
>> તેથી અમે અહીં કરી શકો છો.

388
00:19:02,470 --> 00:19:06,135
પ્રથમ બરાબર શું begin-- રેન્ડર.

389
00:19:06,135 --> 00:19:08,710

390
00:19:08,710 --> 00:19:13,050
તેથી શું અમે અહીં કરી રહ્યા છીએ અમે તે ખબર છે
કાર્ડ, મિલકત અમને આપવામાં આવે છે

391
00:19:13,050 --> 00:19:13,580
અધિકાર?

392
00:19:13,580 --> 00:19:15,930
તે ઇનપુટ તરીકે અમને આપવામાં આવ્યું છે.

393
00:19:15,930 --> 00:19:19,440
તે લગભગ જેમ જેમ
કાર્ય માટે દલીલો.

394
00:19:19,440 --> 00:19:22,810
આ કાર્ડ એક દલીલ છે
લગભગ આ CardView છે.

395
00:19:22,810 --> 00:19:25,239
>> અમે તે બહાર કાઢવા અને મૂકીશું
તે ચલ પ્રશ્ન માં.

396
00:19:25,239 --> 00:19:27,280
ખાતરી કરો કે જવાબ ગયા બનાવો
ચલ જવાબ આપવા માટે.

397
00:19:27,280 --> 00:19:31,130
કાર્ડ જવાબ આપવા માટે કે પૂછે છે.

398
00:19:31,130 --> 00:19:35,072
અને હવે અમે આ હોય છે,
બદલે કે લખાણ બહાર છાપવા,

399
00:19:35,072 --> 00:19:37,030
અમે બહાર છાપવા માટે જઈ રહ્યાં છો
ગમે તેઓ અમને આપ્યું હતું.

400
00:19:37,030 --> 00:19:43,580
>> તેથી આ તેથી અમે જઈ રહ્યાં છો stuff--
પ્રશ્નનો જવાબ બહાર મૂકો.

401
00:19:43,580 --> 00:19:46,380
આ કામ કરે છે જો માતાનો જોવા દો.

402
00:19:46,380 --> 00:19:52,800
સરસ, જેથી માતાનો તે મારફતે પગલું દો
વધુ એક વખત માત્ર તેની ખાતરી કરવા માટે.

403
00:19:52,800 --> 00:20:00,470
>> તેથી મારા કાર્ડ કાર્ડ પદાર્થ છે, અને અમે
એપ્લિકેશન માટે કે કાર્ડ આપ્યા છે.

404
00:20:00,470 --> 00:20:04,790
અને એપ્લિકેશન લઇ રહ્યું છે
કાર્ડ અને તે CardView આપે છે.

405
00:20:04,790 --> 00:20:09,190
અને આ CardView જો તમે કહે છે,
મને કોઇ flashcard પદાર્થ આપી

406
00:20:09,190 --> 00:20:11,920
હું તેના પ્રશ્નનો છાપે પડશે
અને તેના જવાબ, અધિકાર?

407
00:20:11,920 --> 00:20:14,590
>> તેથી હું શું કરી શકે શું હું કરી શકે છે
પ્રથમ આ કોડ મોકલી

408
00:20:14,590 --> 00:20:16,580
મારા મિત્ર મારા કોડ 10 લાઇન્સ, ગમે છે.

409
00:20:16,580 --> 00:20:18,820
તેઓ તેને એમ્બેડ કરી શકે છે
પોતાના અરજી.

410
00:20:18,820 --> 00:20:27,200
અને તે જ વસ્તુ હતી તરીકે લાંબા સમય સુધી,
, CardView કાર્ડ આ બરાબર જેવા

411
00:20:27,200 --> 00:20:30,580
તેમણે CardView બનાવવામાં તરીકે લાંબા સમય સુધી
અને તે સાચી માહિતી આપી હતી,

412
00:20:30,580 --> 00:20:31,987
તેમણે પોતાના કાર્ડ રેન્ડર કરી શકે છે.

413
00:20:31,987 --> 00:20:34,320
અને તેથી આ રીતે, તે ખરેખર છે
તમે બિલ્ડ કરવા માટે સરસ રીતે

414
00:20:34,320 --> 00:20:35,906
અધિકાર, દરેક અન્ય ઉપયોગ ઘટકો છે કે જે?

415
00:20:35,906 --> 00:20:38,280
આ કાર્ડ, હું પ્રકાશિત કરી શકે છે
ઇન્ટરનેટ પર આ CardView,

416
00:20:38,280 --> 00:20:39,790
અને લોકો તેનો ઉપયોગ કરવા માટે સક્ષમ હશે.

417
00:20:39,790 --> 00:20:45,070
તેથી મૂળભૂત રીતે, તે એક જેવી છે
C લાઈબ્રેરીમાંથી ધોરણ કાર્ય કરે છે.

418
00:20:45,070 --> 00:20:47,280
>> તે કાર્ય છે જ્યાં
કોઈને તે લખ્યું છે.

419
00:20:47,280 --> 00:20:48,419
જો તમે ચોક્કસ ઇનપુટ આપે છે.

420
00:20:48,419 --> 00:20:49,710
તે અમુક આઉટપુટ પેદા પડશે.

421
00:20:49,710 --> 00:20:50,890
તમે તેને આંતરિક કેવી રીતે કામ કરે પડી નથી.

422
00:20:50,890 --> 00:20:53,790
લાંબા સમય સુધી તમે તેને અધિકાર આપે છે, કારણ કે
ઇનપુટ, તે યોગ્ય આઉટપુટ બનાવવા પડશે.

423
00:20:53,790 --> 00:20:57,850
>> અને એક ઘટક હોઇ શકે છે
એ જ રીતે માનવામાં આવે છે.

424
00:20:57,850 --> 00:21:00,280
આ CardView જેવી છે
એક લાઈબ્રેરી કાર્ય.

425
00:21:00,280 --> 00:21:03,400
તમે તેને કેટલાક કાર્ડ આપો તો
મિલકત તરીકે, તે પડશે

426
00:21:03,400 --> 00:21:05,095
કે કાર્ડ સમાવિષ્ટો છાપશે.

427
00:21:05,095 --> 00:21:16,820
હું મારા કાર્ડ બદલી હોય તો ગમે
તેના બદલે 5 વત્તા 37 શું છે જેવા હોય છે,

428
00:21:16,820 --> 00:21:19,210
તે મુજબ અપડેટ કરવામાં આવશે.

429
00:21:19,210 --> 00:21:21,955
તેથી માત્ર ઇનપુટ બદલીને,
તે ચોક્કસ આઉટપુટ મળે છે.

430
00:21:21,955 --> 00:21:24,830
તેથી તમે લગભગ ઘટકો વિચાર કરી શકો છો
આ રીતે કાર્યો, કે જે

431
00:21:24,830 --> 00:21:25,920
તમે એક સાથે મૂકી શકો છો.

432
00:21:25,920 --> 00:21:29,440
તમે આ CardView જેમ, ઇનપુટ વિચાર
ઇનપુટ તરીકે, તમે આઉટપુટ મળે છે.

433
00:21:29,440 --> 00:21:31,900
આ કિસ્સામાં, આઉટપુટ HTML છે.

434
00:21:31,900 --> 00:21:34,404
અત્યાર સુધી અર્થમાં બનાવવા?

435
00:21:34,404 --> 00:21:36,890
સરસ, તેથી ફરી, ગુણધર્મો છે
તમે માહિતી પસાર કરી શકે છે કેવી રીતે

436
00:21:36,890 --> 00:21:40,900
માં અને ઘટકો બહાર.

437
00:21:40,900 --> 00:21:42,740
>> ઠીક છે, તેથી આપણે આ બનાવવા દો
વસ્તુ ઇન્ટરેક્ટિવ.

438
00:21:42,740 --> 00:21:44,450
હમણાં તે કંટાળાજનક પ્રકારની છે.

439
00:21:44,450 --> 00:21:45,520
[અશ્રાવ્ય] શું છે?

440
00:21:45,520 --> 00:21:48,210
તમે કેટલાક પ્રિન્ટ કરી શકો છો
પરંતુ તે કરી શકો છો બધા છે.

441
00:21:48,210 --> 00:21:51,550
>> તેથી આ પાછા જવા દો
માત્ર હવે ઓલ્ડ પ્રશ્ન.

442
00:21:51,550 --> 00:21:54,405
ઠીક છે, તેથી હમણાં આ ઘટકો
બધા તેઓ નથી કારણ કે કંટાળાજનક છે,

443
00:21:54,405 --> 00:21:55,030
તેઓ ઇનપુટ મળે છે.

444
00:21:55,030 --> 00:21:56,100
તેઓ આઉટપુટ, અધિકાર છે?

445
00:21:56,100 --> 00:21:57,049
કે કંટાળાજનક પ્રકારની છે.

446
00:21:57,049 --> 00:21:59,090
અમે અમારા છે કરવા માંગો છો
ઘટકો હોય છે સમક્ષ રજુ કરવાનો પ્રયત્ન કરવા માટે

447
00:21:59,090 --> 00:22:02,150
આંતરિક રાજ્યના કેટલાક પ્રકારની છે,
કંઈક યાદ કરે છે.

448
00:22:02,150 --> 00:22:05,320
>> એક flashcard માટે, માટેનાં
રાજ્ય ઉદાહરણ તરીકે, કેવા પ્રકારની

449
00:22:05,320 --> 00:22:07,550
તમે કરવા માંગો છો શકે છે
એક flashcard માટે યાદ?

450
00:22:07,550 --> 00:22:09,740
શું કામચલાઉ સ્થિતિ
તમને યાદ કરવા માંગો છો શકે

451
00:22:09,740 --> 00:22:12,491
એક flashcard એપ્લિકેશન એક flashcard માટે?

452
00:22:12,491 --> 00:22:13,990
પ્રેક્ષક: તે ઉછાળવામાં આવી છે કે શું?

453
00:22:13,990 --> 00:22:14,990
નીલ મહેતા: અધિકાર, હા.

454
00:22:14,990 --> 00:22:17,665
તેથી જો તમે રાખવા માંગો છો શકે
ટ્રેક તમે સામનો અથવા છે

455
00:22:17,665 --> 00:22:19,100
તમે કાર્ડ પર નીચે સામનો કરે છે.

456
00:22:19,100 --> 00:22:23,420
ફેસબુક પર, ઉદાહરણ માટે, તમે કરશે
સમાચાર ફીડ જ્યાં યાદ કરવા માંગો છો

457
00:22:23,420 --> 00:22:25,870
તમે અથવા પ્રોફાઇલ કોણ ગમે
તમે હમણાં કરી રહ્યા છે.

458
00:22:25,870 --> 00:22:30,127
>> મેસેન્જર, પર શું લખાણ તમારા જેવા
અધિકાર, ઇનપુટ બોક્સમાં લખો?

459
00:22:30,127 --> 00:22:31,710
તમે પાનું તાજું હોય, તો તે દૂર જાય છે.

460
00:22:31,710 --> 00:22:32,793
પરંતુ તમે ખરેખર પડી નથી.

461
00:22:32,793 --> 00:22:33,770
તે માત્ર કામચલાઉ છે.

462
00:22:33,770 --> 00:22:34,548
અરે વાહ?

463
00:22:34,548 --> 00:22:36,152
>> AUDIENCE: [અશ્રાવ્ય]

464
00:22:36,152 --> 00:22:38,360
નીલ મહેતા: એક ફ્લેશ જેવા
કાર્ડ, તમે જોઈ શકાય છે, જેમ કે

465
00:22:38,360 --> 00:22:40,290
પ્રશ્ન બાજુ અથવા જવાબ બાજુ?

466
00:22:40,290 --> 00:22:41,070
>> પ્રેક્ષક: બરાબર.

467
00:22:41,070 --> 00:22:43,270
>> નીલ મહેતા: જેમ
અધિકાર, flashcard બે બાજુ?

468
00:22:43,270 --> 00:22:46,370
અરે વાહ, જેથી તમે કરવા માંગો છો
હવે આ વિચાર છે

469
00:22:46,370 --> 00:22:50,370
હું ઇનપુટ્સ જેવી છે, જે ગુણધર્મો ધરાવે છે
પરંતુ ઉહ, કામચલાઉ છે, જે રાજ્ય,

470
00:22:50,370 --> 00:22:51,839
તમે પૃષ્ઠ પર છે, જ્યાં, અધિકાર?

471
00:22:51,839 --> 00:22:54,380
ફરીથી, હું ફેસબુક માં જણાવ્યું હતું કે
મેસેન્જર, હું જે વ્યક્તિની જેમ છે

472
00:22:54,380 --> 00:22:56,550
તમે ફેસબુક જોઈ રહ્યાં છો
અથવા જે અધિકાર, પ્રોફાઇલ છે?

473
00:22:56,550 --> 00:22:58,030
>> આ માત્ર કામચલાઉ છે.

474
00:22:58,030 --> 00:23:01,200
તે વપરાશકર્તા બતાવવા માટે મહત્વપૂર્ણ છે
શું થઈ રહ્યું છે, પરંતુ પાનું તાજું છે.

475
00:23:01,200 --> 00:23:02,250
તે ખરેખર તો કોઈ વાંધો નથી.

476
00:23:02,250 --> 00:23:04,530
તેથી તે કામચલાઉ રાજ્ય
તેથી આપણે બધા તે રાજ્ય.

477
00:23:04,530 --> 00:23:06,250
>> તેથી, ફરી, રાજ્ય અને પ્રોપ્સ છે.

478
00:23:06,250 --> 00:23:09,084
પ્રોપ્સ ઇનપુટ આપવામાં આવે છે
તમારી માહિતી સ્ત્રોત માંથી.

479
00:23:09,084 --> 00:23:10,250
રાજ્ય માત્ર મૂળભૂત જેવું છે.

480
00:23:10,250 --> 00:23:13,700
તે માત્ર સામગ્રી જેમ કે
આ વસ્તુ અરસપરસ બનાવે છે.

481
00:23:13,700 --> 00:23:17,720
>> તેથી અમારા CardView-- ચાલો હોય
અમારા CardView-- તે સરસ હતી જેથી.

482
00:23:17,720 --> 00:23:21,420
અમે અહીં કરી રહ્યા છીએ, શું અમે જઈ રહ્યાં છો
CardView અને માત્ર CardView સ્પર્શ.

483
00:23:21,420 --> 00:23:25,105
અને તેથી મારા મિત્ર આ તેઓ મળી જે
કોઈપણ તફાવત નથી જાણ કરશે.

484
00:23:25,105 --> 00:23:27,230
તેઓ બદલી ન હોત
તેમના પોતાના કોડ કોઈપણ,

485
00:23:27,230 --> 00:23:29,410
પરંતુ તેઓ જુઓ છો તેમના
CardView souped અપ મળ્યો.

486
00:23:29,410 --> 00:23:31,270
ઘટકો છે કે જે વિશે એક સરસ ભાગ છે.

487
00:23:31,270 --> 00:23:35,290
>> ઠીક છે, અમારા CardView, તેથી ચાલો પ્રયાસ અને
અમે તબક્કાવાર રહ્યાં છો કે નહીં ટ્રેક રાખવા

488
00:23:35,290 --> 00:23:36,560
અથવા નીચે સામનો કરે છે.

489
00:23:36,560 --> 00:23:40,480
પ્રતિક્રિયા અમે પ્રથમ દ્વારા આ કરવા
પ્રારંભિક રાજ્ય સ્પષ્ટ.

490
00:23:40,480 --> 00:23:42,070
જ્યાં કાર્ડ શરૂ થાય છે?

491
00:23:42,070 --> 00:23:48,480
>> તેથી getInitialState કહેવાય કાર્ય હશે
કામ કરે છે અને અમે એક ઑબ્જેક્ટ આવો.

492
00:23:48,480 --> 00:23:53,310
આ પદાર્થ, કેટલાક રાજ્ય છે અને
રાજ્ય માત્ર એક કી-કિંમત જોડ છે.

493
00:23:53,310 --> 00:23:56,950
સુચના જેમ, તમે એક ચાવી અને બીજી છે
નામ એક સ્ટ્રિંગ છે, જેમ કિંમત તમારી પાસે છે.

494
00:23:56,950 --> 00:24:01,410
>> આ કિસ્સામાં, આગળ વાત સાચી છે કહે છે.

495
00:24:01,410 --> 00:24:03,760
આ અમે એક રાજ્ય છે કે જે કહે છે.

496
00:24:03,760 --> 00:24:06,570
રાજ્ય એક ઘટક
સામે કહેવાય લક્ષણ છે.

497
00:24:06,570 --> 00:24:09,649
[અશ્રાવ્ય], મૂળભૂત રીતે, જેથી
અમે કાર્ડ આગળના છો,

498
00:24:09,649 --> 00:24:11,440
અને અમે આ બદલી શકો છો
તરીકે અમે કાર્ડ વિમાનની મુસાફરી.

499
00:24:11,440 --> 00:24:13,380
અર્થમાં બનાવવા?

500
00:24:13,380 --> 00:24:18,190
>> ઠીક છે, તેથી હમણાં, અમે છો, રેન્ડર
પ્રશ્ન અને જવાબ દર્શાવે છે.

501
00:24:18,190 --> 00:24:20,860
હવે અમે શું કરવું જોઈએ
પ્રશ્ન દર્શાવે છે

502
00:24:20,860 --> 00:24:24,370
અમે કાર્ડ આગળના પર છો, તેથી જો
જવાબ કાર્ડ પાછળ છે.

503
00:24:24,370 --> 00:24:26,850
તમે બધા બનાવવા કે શા માટે છે
કાર્ડ ઇન્ટરેક્ટિવ.

504
00:24:26,850 --> 00:24:28,100
તેથી છે અને આ અહીં પ્રયાસ કરીએ.

505
00:24:28,100 --> 00:24:31,600

506
00:24:31,600 --> 00:24:33,620
વેલ, પ્રથમ માત્ર એક ચલ બનાવે છે.

507
00:24:33,620 --> 00:24:37,790
અમે this.state.front હવે પૂછી શકો છો.

508
00:24:37,790 --> 00:24:42,010
અમે એ જ અમે રાજ્ય ઍક્સેસ
ઍક્સેસ પ્રોપ્સ, જેથી this.state.front.

509
00:24:42,010 --> 00:24:45,870
>> અમે સામે છો, તો પછી લખાણ
this.props.card.question છે.

510
00:24:45,870 --> 00:24:48,777

511
00:24:48,777 --> 00:24:51,360
અમે આ બોલ પર છો, તો
કાર્ડ, અમે પ્રયાસ અને પડાવી લેવું જઈ રહ્યાં છો

512
00:24:51,360 --> 00:24:52,485
આ કાર્ડ ના પ્રશ્ન.

513
00:24:52,485 --> 00:24:54,782

514
00:24:54,782 --> 00:24:57,240
અન્યથા, અમે આ બોલ પર છો, તો
કાર્ડ, અમે શું કરવું?

515
00:24:57,240 --> 00:25:01,830

516
00:25:01,830 --> 00:25:02,750
>> પ્રેક્ષક: જવાબ?

517
00:25:02,750 --> 00:25:05,041
>> નીલ મહેતા: હા, તેથી લખાણ
this.props.card.answer સમકક્ષ હોય છે.

518
00:25:05,041 --> 00:25:08,472

519
00:25:08,472 --> 00:25:10,930
તમે નોટિસ, તો અમે ઉપયોગ કરી રહ્યાં છો
રાજ્ય નિર્ણય કરવા માટે

520
00:25:10,930 --> 00:25:14,420
હવે ઘટક કારણ કે
અલગ જોવા મળશે

521
00:25:14,420 --> 00:25:16,710
આ તે સાથે કેવી રીતે સંચાર બંધ આધારિત છે.

522
00:25:16,710 --> 00:25:20,355
તેથી તેના બદલે આ બહાર છાપવા,
અમે હમણાં જ લખાણ છાપે પડશે.

523
00:25:20,355 --> 00:25:25,270

524
00:25:25,270 --> 00:25:28,650
સરસ, હવે તેથી, જો તમે જુઓ,
અમે ફક્ત પ્રશ્ન જુઓ.

525
00:25:28,650 --> 00:25:37,720
અને હું જાતે અહીં રાજ્ય બદલો તો
સામે ખોટા છે અમે 42 પાછા મળે છે.

526
00:25:37,720 --> 00:25:39,720
>> તેથી, ફરી, આ ઘટક
તેના પોતાના રાજ્ય છે.

527
00:25:39,720 --> 00:25:43,440
એક બટન કે કેમ તે જાણે જેવું
તે દબાવી રાખી છે અથવા નથી કરવામાં આવ્યું છે

528
00:25:43,440 --> 00:25:46,080
આ વસ્તુ શું છે તે જાણે છે
આ બોલ પર અથવા પીઠ પર.

529
00:25:46,080 --> 00:25:48,320
મૂળભૂત રીતે, તે આ બોલ પર છે.

530
00:25:48,320 --> 00:25:50,840
અને પછી તે આગળના ભાગ પર છે, તો
અમે પ્રશ્ન છાપે પડશે.

531
00:25:50,840 --> 00:25:53,106
તે પીઠ પર છે, તો અમે પડશે
જવાબ છાપશે.

532
00:25:53,106 --> 00:25:54,980
તેથી ફરીથી, આ જાણકારી
આપવામાં જ છે.

533
00:25:54,980 --> 00:25:59,090
તે માત્ર અલગ દેખાય છે
તમે તેને કાર્યક્રમ કેવી રીતે પર આધારિત છે.

534
00:25:59,090 --> 00:26:02,670
તેથી, ઉદાહરણ તરીકે, ફેસબુક મેસેન્જર,
તમે એ જ માહિતી સ્ત્રોત હોય તો પણ,

535
00:26:02,670 --> 00:26:05,170
તેને અલગ અલગ દેખાય છે,
રાજ્ય અલગ છે, કારણ કે.

536
00:26:05,170 --> 00:26:08,421
તમે જોઈ રહ્યાં છો,
વિવિધ વ્યક્તિ સંદેશ.

537
00:26:08,421 --> 00:26:10,930
>> ઠીક છે, તેથી આ તમામ સારી છે અને
સારી છે, પરંતુ હવે શું ખરેખર છે

538
00:26:10,930 --> 00:26:15,940
કે કેમ તે, અમને બદલવા માટે સક્ષમ બનાવે
અમારા કાર્ડ ફ્રન્ટ અથવા પાછા છે.

539
00:26:15,940 --> 00:26:19,010
અમે એક ફ્લિપ ઉમેરીને આ કરી શકો છો
બટન કાર્ડ માટે બટન કે

540
00:26:19,010 --> 00:26:22,950
તે [અશ્રાવ્ય] જો કાર્ડ વિમાનની મુસાફરી કરશે.

541
00:26:22,950 --> 00:26:31,770
તેથી આપણે અહીં, આ એક બટન ઉમેરવા દો
બટન, અને આ બટન ફ્લિપ કહે છે કરશે.

542
00:26:31,770 --> 00:26:35,650
>> અને તેથી હવે અધિકાર, તે
કાંઇ નથી.

543
00:26:35,650 --> 00:26:37,075
તે માત્ર સરસ લાગે છે.

544
00:26:37,075 --> 00:26:43,650
અમે શું કરી શકો છો અમે એક ક્લિક ઉમેરી શકો છો છે
સંભાળનાર, onClick, this.flip બરાબર

545
00:26:43,650 --> 00:26:44,820
અને અમે પાછળથી ફ્લિપ વ્યાખ્યાયિત પડશે.

546
00:26:44,820 --> 00:26:47,120
પરંતુ મૂળભૂત રીતે, onClick
એક કાર્ય છે કે

547
00:26:47,120 --> 00:26:48,675
વપરાશકર્તા તેને ક્લિક કરે ત્યારે કહેવાય નહીં.

548
00:26:48,675 --> 00:26:52,330
>> તેથી બટન જાણતા હશે
તે ક્લિક કરવામાં આવી છે ત્યારે.

549
00:26:52,330 --> 00:26:54,750
તે ક્લિક કરવામાં આવી છે ગયા,
તે કાર્ડ વિમાનની મુસાફરી કરશે.

550
00:26:54,750 --> 00:26:58,382
તે તમારા જેવા પ્રકારની છે
પિઝાની ડિલિવરી ગાય.

551
00:26:58,382 --> 00:27:01,590
તમને ગમે બધા અધિકાર છો, જ્યારે કોઈને
અધિકાર, હું પીત્ઝા પહોંચાડવા પડશે, મને કહે છે?

552
00:27:01,590 --> 00:27:03,420
>> તમે આ સાંભળનાર રજીસ્ટર કરો.

553
00:27:03,420 --> 00:27:04,530
તમે એક ઘટના માટે સાંભળો.

554
00:27:04,530 --> 00:27:07,657
તમને કહેવામાં આવે છે, અને જ્યારે વિચાર
ઘટના તમને કંઈક થાય.

555
00:27:07,657 --> 00:27:08,240
તમે pizza મળે છે.

556
00:27:08,240 --> 00:27:11,480
આ કિસ્સામાં, તમે જ્યારે છો
ક્લિક, તમે કાર્ડ વિમાનની મુસાફરી.

557
00:27:11,480 --> 00:27:14,560
>> અને તેથી અમે એક વ્યાખ્યાયિત કરવા માટે જરૂર
કાર્ડ વિમાનની મુસાફરી કરશે કે કાર્ય,

558
00:27:14,560 --> 00:27:17,930
તેથી અમે તે યોગ્ય લખીશ
અહીં, કાર્ય વિમાનની મુસાફરી.

559
00:27:17,930 --> 00:27:20,850

560
00:27:20,850 --> 00:27:23,680
અને તેથી તમે ફ્લિપ કરશે શું વિચારો છો?

561
00:27:23,680 --> 00:27:27,180
ફરી આ ત્યારે કહેવાય નહીં
અમે આ ફ્લિપ બટન ક્લિક કરો.

562
00:27:27,180 --> 00:27:29,406
કાર્ય ફ્લિપ શું કરવું જોઈએ?

563
00:27:29,406 --> 00:27:34,136
>> પ્રેક્ષક: બદલો this.state.front
સાચું માંથી સાચું ખોટા, ખોટી છે.

564
00:27:34,136 --> 00:27:38,420
>> નીલ મહેતા: હા, તેથી લેવા ગમે
this.front ફ્રન્ટ રાજ્ય છે is--.

565
00:27:38,420 --> 00:27:40,930
જો, આ બોલ રાજ્ય લો
તે ખોટા બનાવે છે, સાચું છે.

566
00:27:40,930 --> 00:27:42,530
જો તે ખોટા છે, અધિકાર, તે સાચું છે?

567
00:27:42,530 --> 00:27:45,330
તેથી આપણે તે પ્રયાસ કરીએ.

568
00:27:45,330 --> 00:27:48,240
>> તમે રાજ્ય બદલી શકતા નથી
માત્ર this.state કરવાથી.

569
00:27:48,240 --> 00:27:50,380
તમે આ કરી શકો છો.

570
00:27:50,380 --> 00:27:52,030
તમે તે ન કરી શકો છો.

571
00:27:52,030 --> 00:27:55,810
તમે એક કાર્ય ઉપયોગ કરે છે
this.setState કહેવાય છે.

572
00:27:55,810 --> 00:28:03,230
>> તેથી જો તમે this.setState સામે કહી શકો છો
કોલોન આ જ્યાં, ફરીથી, આ ઉદ્ગારવાચક

573
00:28:03,230 --> 00:28:04,330
બિંદુ વિરુદ્ધ થાય છે.

574
00:28:04,330 --> 00:28:07,420
હું આ તો ધારી. state.front
સાચું છે, તે ખોટા ચાલુ પડશે.

575
00:28:07,420 --> 00:28:09,170
તેથી અમે રાજ્ય સેટ કરશો
સાચું માંથી ખોટુ છે.

576
00:28:09,170 --> 00:28:11,430
જો તે ખોટા છે, અમે પડશે
તે સાચું છે તેને ખોટા સુયોજિત કરો.

577
00:28:11,430 --> 00:28:17,210
>> જસ્ટ અમે સેટ અને સહેજ વિચાર કે નોટિસ
અલગ છે, અને તેથી આ પ્રયાસ કરો.

578
00:28:17,210 --> 00:28:18,675
બડા બિંગ, આ જુઓ.

579
00:28:18,675 --> 00:28:21,810
આ ફ્લિપ બટન હવે કરશે
રાજ્ય બેકઅપ ફ્રન્ટ સ્વિચ કરો.

580
00:28:21,810 --> 00:28:24,990
>> તમે જુઓ જ્યાં અને તેથી અહીં છે
પ્રતિક્રિયા ના જાદુ થોડુંક.

581
00:28:24,990 --> 00:28:28,420
અમે તેને કહ્યું હતું કે ક્યારેય જેમ તે ફરી રેન્ડર કરવા માટે.

582
00:28:28,420 --> 00:28:30,910
અમે તે કંઇ redraw કહ્યું નથી.

583
00:28:30,910 --> 00:28:32,630
તમે આ કરી રહ્યાં છો, તો
પ્રતિક્રિયા વિના, તમે કરશો

584
00:28:32,630 --> 00:28:34,588
જ્યારે રહ્યો ગમે છે
ફ્લિપ બટન ક્લિક છે

585
00:28:34,588 --> 00:28:37,290
તમે તે કહેવું હોય તો
જાતે અધિકાર, ફરીથી રેન્ડર?

586
00:28:37,290 --> 00:28:43,050
>> ખરેખર સરસ છે પ્રતિક્રિયા કે જો તમે
તે ચોક્કસ રાજ્ય અને ગુણધર્મો આપે છે,

587
00:28:43,050 --> 00:28:45,760
તે હંમેશા રેન્ડર કરશે
ચોક્કસ જ વસ્તુ.

588
00:28:45,760 --> 00:28:48,690
અને તેથી અમે ક્યારેય અમે બદલી જ્યારે
રાજ્ય અને ગુણધર્મો,

589
00:28:48,690 --> 00:28:50,819
પ્રતિક્રિયા માત્ર સમગ્ર બાબત ફરીથી રેન્ડર કરે છે.

590
00:28:50,819 --> 00:28:52,860
તે ત્યાં છે કે જાણે
એક થી એક પત્રવ્યવહાર

591
00:28:52,860 --> 00:28:57,270
રાજ્ય અને પરિમાણ અને HTML વચ્ચે.

592
00:28:57,270 --> 00:29:00,110
તેથી જ્યારે તે ક્યાં
સમૂહ રાજ્ય દ્વારા દ્વારા ફેરફાર,

593
00:29:00,110 --> 00:29:03,750
તે બદલાશે કેવી રીતે
પગાર ફરી રેન્ડર છે.

594
00:29:03,750 --> 00:29:06,650
અને તેથી મૂળભૂત પ્રતિક્રિયા જેવી છે
તમે બદલવા માટે રાહ જોઈ.

595
00:29:06,650 --> 00:29:09,870
>> જ્યારે તે કંઈક ફેરફારો,
તે સમગ્ર પાનું ફરીથી રેન્ડર પડશે.

596
00:29:09,870 --> 00:29:12,480
અને તે બિનકાર્યક્ષમ સંભળાય છે,
તે હશે, કારણ કે તે છે

597
00:29:12,480 --> 00:29:15,050
પરંતુ પ્રતિક્રિયા એક વસ્તુ વાપરે
એક પડછાયો DOM કહેવાય છે.

598
00:29:15,050 --> 00:29:19,950
તેના બદલે સીધા પાનું ચિત્રકામ, તે
મેમરી વર્ચ્યુઅલ HTML વૃક્ષ રાખે છે.

599
00:29:19,950 --> 00:29:23,620
>> તમે જાણો છો, એચટીએમએલ વૃક્ષ જેવું છે,
એક અધિક્રમિક માહિતી માળખું જેવા હોય છે.

600
00:29:23,620 --> 00:29:28,990
તે મેમરી એક નકલી વૃક્ષ રાખે
અને તમે પાનું અપડેટ ત્યારે,

601
00:29:28,990 --> 00:29:31,940
તે અન્ય નકલી દોરવા પડશે
વૃક્ષ, અને તે ગણતરી પડશે

602
00:29:31,940 --> 00:29:35,120
શું તે બનાવવા માટે જરૂર છે બદલી
પાનું બે વૃક્ષો સમાન બનાવવા માટે.

603
00:29:35,120 --> 00:29:38,540
તેથી મૂળભૂત રીતે, તે વર્ચ્યુઅલ
ઘણો ફરીથી રેન્ડર કરે છે.

604
00:29:38,540 --> 00:29:41,540
અને પછી તે માત્ર ગમે ફેરફારો
થોડું tweaks પાનું જરૂરી છે,

605
00:29:41,540 --> 00:29:44,240
તેથી તે ખૂબ, ખૂબ, ખૂબ જ કાર્યક્ષમ છે.

606
00:29:44,240 --> 00:29:46,970
>> જેથી મૂળભૂત પ્રતિક્રિયા થશે
જ્યારે તમે કંઈક બદલવા માટે,

607
00:29:46,970 --> 00:29:49,010
તે ફરી રેન્ડર વર્ચ્યુઅલ પાનું પડશે.

608
00:29:49,010 --> 00:29:52,830
હું શું જરૂર નથી બહાર આકૃતિ પડશે
વાસ્તવિક પાનું પ્રતિબિંબ બનાવવા માટે બદલી

609
00:29:52,830 --> 00:29:55,602
વર્ચ્યુઅલ પાનું, અને તે કરીશ.

610
00:29:55,602 --> 00:29:56,560
કે વર્ચ્યુઅલ DOM છે.

611
00:29:56,560 --> 00:29:59,350
તે સૌથી મોટી એક છે
ના લક્ષણો પ્રતિક્રિયા.

612
00:29:59,350 --> 00:30:00,880
>> કે અર્થમાં છે?

613
00:30:00,880 --> 00:30:01,540
કોઇ પ્રશ્નો?

614
00:30:01,540 --> 00:30:02,040
અરે વાહ?

615
00:30:02,040 --> 00:30:05,568

616
00:30:05,568 --> 00:30:08,969
>> પ્રેક્ષક: કેવી રીતે કરે છે
ના MVC હજુ તુલના

617
00:30:08,969 --> 00:30:10,760
અમે વિશે વાત કરી કે
જેવા સાધનો પહેલાં.

618
00:30:10,760 --> 00:30:13,527
>> નીલ મહેતા: અરે વાહ, પ્રશ્ન
તે MVC તુલના કરે છે કેવી રીતે છે?

619
00:30:13,527 --> 00:30:14,610
તમે સંસાધનો વિશે પૂછવામાં.

620
00:30:14,610 --> 00:30:16,445
વેલ, તે કેવી રીતે કાર્ય વિશે વાત કરો.

621
00:30:16,445 --> 00:30:18,190
>> MVC, તમે મોડેલ અપડેટ કરશો.

622
00:30:18,190 --> 00:30:20,560
આ કિસ્સામાં અમે એક કાર્ડ મોડેલ હોય તો.

623
00:30:20,560 --> 00:30:24,540
દૃશ્ય હશે
ફ્લિપ કરો, અને નિયંત્રણ

624
00:30:24,540 --> 00:30:26,310
આ ફ્લિપ કાર્ય હશે.

625
00:30:26,310 --> 00:30:28,450
તેથી જુઓ આ કહેવું કરશે
નિયંત્રક ફ્લિપ કરો.

626
00:30:28,450 --> 00:30:30,370
ફ્લિપ કહેવું કરશે
બદલવા માટે મોડેલ, અધિકાર?

627
00:30:30,370 --> 00:30:33,915
>> અને તેથી તમે એક MVC તમે શું જ્યારે
આ મોડેલ બદલવા માટે સાંભળવા,

628
00:30:33,915 --> 00:30:37,150
અને તમે ફરીથી રેન્ડર મુજબ જુઓ.

629
00:30:37,150 --> 00:30:39,210
અથવા તમે માત્ર ગમે છે
આ નિયંત્રક છે.

630
00:30:39,210 --> 00:30:42,418
પછી મોડેલ બદલવા માટે રાહ જુઓ, અને
ચૂંટો અને એક વસ્તુ જેવી એક ભાગ પસંદ

631
00:30:42,418 --> 00:30:44,032
ફેરફાર કરો.

632
00:30:44,032 --> 00:30:45,740
અહીં અમે એક વસ્તુ છે,
પરંતુ મોટા એપ્લિકેશન,

633
00:30:45,740 --> 00:30:48,510
તમે શું યાદ ગમે છે
દરેક એક જગ્યાએ ફેરફાર

634
00:30:48,510 --> 00:30:50,290
જેથી તે થોડી નકામી છે.

635
00:30:50,290 --> 00:30:53,670
અને તેથી સરસ છે પ્રતિક્રિયા
તે શેડો DOM છે કારણ કે.

636
00:30:53,670 --> 00:30:56,040
તે માત્ર પરવડી શકે છે
સમગ્ર વસ્તુ લખાણ લખે છે.

637
00:30:56,040 --> 00:30:58,680
તમે પસંદ કરવા માટે નથી
જેવા સુધારવા માટે શું ધારી.

638
00:30:58,680 --> 00:31:02,186
>> ફેસબુક પર તમે ગમે તો
MVC, એક નવો સંદેશ મેળવવા માટે,

639
00:31:02,186 --> 00:31:04,060
તમે યાદ હોય તો
ઠીક છે, વસ્તુઓ બદલવા

640
00:31:04,060 --> 00:31:06,260
આ ટોચ પર
પાનું, સંદેશ ચિહ્ન.

641
00:31:06,260 --> 00:31:08,290
પણ તળિયે નવી વિન્ડો પૉપ.

642
00:31:08,290 --> 00:31:10,070
પણ તે વિન્ડોમાં નવી વસ્તુ બનાવે છે.

643
00:31:10,070 --> 00:31:11,060
પણ અવાજ ભજવે છે.

644
00:31:11,060 --> 00:31:13,150
>> કે સામગ્રી ઘણો છે
તે જ સમયે બહાર જઈ રહી છે.

645
00:31:13,150 --> 00:31:15,320
અને તમે નથી તેથી જો
એક પડછાયો ડોમ હોય, તો તમે કરશો

646
00:31:15,320 --> 00:31:18,740
કે જાતે, કારણ કે કરવું છે
તમે સમગ્ર પાનું છુટકારો મેળવી શકો છો.

647
00:31:18,740 --> 00:31:21,430
તમે નથી પરવડી શકે છે, તેથી તમારી પાસે
જાતે દરેક વસ્તુ બદલવા માટે,

648
00:31:21,430 --> 00:31:23,990
જે MVC ખરેખર હેરાન કરે છે.

649
00:31:23,990 --> 00:31:27,640
>> તેથી ક્રમમાં હોઈ
કરકસર, તેઓ પસંદ

650
00:31:27,640 --> 00:31:30,750
છે, જે પૃષ્ઠ અપડેટ
કાર્યક્ષમ છે, પણ નકામી.

651
00:31:30,750 --> 00:31:34,002
કારણ કે શેડો ઓફ પ્રતિક્રિયા
ડોમ, તમે મફત માટે બંને વસ્તુઓ મળે છે.

652
00:31:34,002 --> 00:31:35,710
તે કાર્યક્ષમ છે, કારણ કે
શેડો ડોમ.

653
00:31:35,710 --> 00:31:37,210
અંતરાય પાનું અપડેટ થયેલ છે.

654
00:31:37,210 --> 00:31:40,292
તે વૃક્ષ મેનીપ્યુલેશન કરી નથી.

655
00:31:40,292 --> 00:31:41,250
તમે કાર્યક્ષમતા મળે છે.

656
00:31:41,250 --> 00:31:45,420
તમે પણ ઉપયોગ સરળતા કારણ કે વિચાર
તમે માત્ર સમગ્ર પાનું લખાણ લખે, તો

657
00:31:45,420 --> 00:31:48,970
પરંતુ જો તમે માત્ર, બધા અધિકાર, વસ્તુઓ ખબર
ક્યાંક પૃષ્ઠ પર હોઈ જતા હોય છે.

658
00:31:48,970 --> 00:31:51,180
તે એક અલગ જગ્યાએ હોઈ શકે, પરંતુ
તે અધિકાર પૃષ્ઠ પર હોઈ રહ્યું છે?

659
00:31:51,180 --> 00:31:52,860
તેથી જો તમે માત્ર ફરીથી પ્રસ્તુત
સમગ્ર વસ્તુ વર્ચ્યુઅલ

660
00:31:52,860 --> 00:31:55,540
અને તમે એક દંપતિ કરી શકે છે
આ પૃષ્ઠમાં ફેરફારો.

661
00:31:55,540 --> 00:31:57,850
>> તેથી, ફરી, MVC તમે
પસંદ કરવા માટે હોય છે

662
00:31:57,850 --> 00:32:01,840
ઉપયોગ અને કાર્યક્ષમતા સરળતા વચ્ચે,
અને તમે બંને વિચાર પ્રતિક્રિયા.

663
00:32:01,840 --> 00:32:04,020
તેથી તે સારી છે.

664
00:32:04,020 --> 00:32:05,220
અર્થમાં બનાવવા?

665
00:32:05,220 --> 00:32:06,676
ઘન.

666
00:32:06,676 --> 00:32:12,080
>> ઠીક છે, તેથી માતાનો વાત કરીએ જોવા દો
પગલું 4 વિશે થોડુંક,

667
00:32:12,080 --> 00:32:14,740
અમે કેવી રીતે ઘટકો એમ્બેડ કરી શકો છો.

668
00:32:14,740 --> 00:32:16,260
તેથી અમે હવે આ અધિકાર છે.

669
00:32:16,260 --> 00:32:19,420
અમે અમારા ઠંડી ઓછી બટન હોય છે.

670
00:32:19,420 --> 00:32:23,157
અમે તે પાછા વિમાનની મુસાફરી કરી શકે છે અને
આગળ, અને તે બધા કરે છે.

671
00:32:23,157 --> 00:32:24,990
અમે કરવા માંગુ છુ
અન્ય ઘટક છે.

672
00:32:24,990 --> 00:32:28,730
ચાલો અમારી flashcard એપ્લિકેશન જોઈએ કહે છે
તમામ કાર્ડ યાદી સમાવે છે

673
00:32:28,730 --> 00:32:31,520
તમારી પાસે છે, કે જેથી અમે અર્થ એ થાય કે
અન્ય ઘટક હોવા જોઈએ.

674
00:32:31,520 --> 00:32:32,970
વેલ, કદાચ યાદી જુઓ કૉલ કરો.

675
00:32:32,970 --> 00:32:36,200
ચાલો એક યાદી જુઓ કરી દો કે
આ CardView સાથે જ સહઅસ્તિત્વ ધરાવતી,

676
00:32:36,200 --> 00:32:39,680
અને આ યાદી જુઓ અને CardView
સાથે મળીને કામ ગમશે.

677
00:32:39,680 --> 00:32:43,190
અને તમે તેમને ભેગા કરી શકો છો
તમે અમારી એપ્લિકેશન બનાવવા માટે.

678
00:32:43,190 --> 00:32:45,160
>> તેથી પ્રથમ, ચાલો એક બનાવવા દો
થોડા વધુ કાર્ડ અધિકાર.

679
00:32:45,160 --> 00:32:46,370
ચાલો કહે, શું કાર્ડ?

680
00:32:46,370 --> 00:32:49,619

681
00:32:49,619 --> 00:32:51,910
અને માત્ર જેથી હું નથી
તે ટાઇપ સાથે શાર તમે,

682
00:32:51,910 --> 00:32:53,410
હું હમણાં જ અહીં તેને નકલ કરવા જઇ રહ્યો છું.

683
00:32:53,410 --> 00:33:01,664

684
00:33:01,664 --> 00:33:03,580
અને તેથી હું નથી જઈ રહ્યો છું
તે માત્ર એક કાર્ડ આપે છે.

685
00:33:03,580 --> 00:33:06,910
હું તે કાર્ડ ઝાકઝમાળ આપી જાઉં છું.

686
00:33:06,910 --> 00:33:10,240
તેથી પ્રથમ એપ્લિકેશન્સ
હવે તોડી જઈ રહી છે.

687
00:33:10,240 --> 00:33:14,717
બધા હક છે, તેથી અમે કરી રહ્યા છીએ
આ સક્ષમ બહુવિધ કાર્ડ્સ નિયંત્રિત કરવા માટે.

688
00:33:14,717 --> 00:33:17,800
તેથી પ્રથમ, અમે તેને આપી નથી જઈ રહ્યાં છો
માત્ર એક કાર્ડ પરંતુ કાર્ડ ઝાકઝમાળ,

689
00:33:17,800 --> 00:33:18,700
કાર્ડ યાદી ગમે છે.

690
00:33:18,700 --> 00:33:20,980
અને આ કિસ્સામાં, અમે તેમને ત્રણ છે.

691
00:33:20,980 --> 00:33:27,280
>> બધા હક છે, એપ્લિકેશન છે જેથી
યાદી કાર્ડ મેળવવા માટે જવાનું,

692
00:33:27,280 --> 00:33:29,870
અને તે નક્કી કરવા માટે ચાલી રહ્યું છે જે
એક CardView બતાવવા માટે.

693
00:33:29,870 --> 00:33:33,740
આ CardView કરી શકો
એક કાર્ડ, પરંતુ એપ્લિકેશન રેન્ડર

694
00:33:33,740 --> 00:33:37,610
અધિકાર, બધા કાર્ડો એક યાદી નહીં?

695
00:33:37,610 --> 00:33:40,820
>> તેથી જો તમે એક બહાર આકૃતિ જ્યારે
કાર્ડ, CardView આપવા

696
00:33:40,820 --> 00:33:44,660
તમે પ્રયત્ન કરી શકે છે ધારી કે કેવી રીતે
એક નિર્ણય જે કાર્ડ વિશે

697
00:33:44,660 --> 00:33:47,064
બતાવવા માટે?

698
00:33:47,064 --> 00:33:49,980
તમે એક હિંટ આપી, તે અસ્થાયી છે
જો તમે ચોક્કસ કાર્ડ જોઈ આવશે.

699
00:33:49,980 --> 00:33:53,260
તમે પાનું તાજું હોય તો, તમે પડશે
માત્ર પાછા પ્રથમ કાર્ડ પર જાઓ.

700
00:33:53,260 --> 00:33:55,464
તે કામચલાઉ છે, કારણ કે તે બરાબર છે.

701
00:33:55,464 --> 00:33:56,630
અમે શું ટેકનિક ઉપયોગ કરી શકે છે?

702
00:33:56,630 --> 00:34:02,534

703
00:34:02,534 --> 00:34:08,760
>> પ્રેક્ષક: તમે એક ચલ બનાવી શકે
જેથી તમે ફ્રન્ટ હતી જેમ.

704
00:34:08,760 --> 00:34:11,989
આ વાત સાચી છે, તમે કરી શકે
વર્તમાન કાર્ડ 1 સમકક્ષ હોય છે?

705
00:34:11,989 --> 00:34:14,150
>> નીલ મહેતા: અરે વાહ, અમે આમ
અધિકાર, રાજ્ય છે કરવા માંગો છો?

706
00:34:14,150 --> 00:34:16,080
તમે રાજ્ય ઉપયોગ કરશે
ઘટક બહાર આકૃતિ

707
00:34:16,080 --> 00:34:17,288
જે કાર્ડ અમે વિચાર કરવા માંગો છો.

708
00:34:17,288 --> 00:34:19,290
જેમ આપણે યાદી છે
તમામ કાર્ડ, અમે પડશે

709
00:34:19,290 --> 00:34:21,630
બહાર આકૃતિ રાજ્ય ઉપયોગ
પ્રથમ કાર્ડ એક,

710
00:34:21,630 --> 00:34:23,710
તેથી બીજા કાર્ડ, ત્રીજા કાર્ડ, અને.

711
00:34:23,710 --> 00:34:28,760
>> તેથી એક એપ્લિકેશન જેથી એક એપ્લિકેશન મળશે
, આ getInitialState કાર્ય છે

712
00:34:28,760 --> 00:34:35,020
getInitialState કાર્ય વળતર.

713
00:34:35,020 --> 00:34:39,929
અને અમે હમણાં જ activeIndex 0 કહેવું પડશે.

714
00:34:39,929 --> 00:34:42,889
તેથી હવે અમારી એપ્લિકેશન તે પોતાના રાજ્ય છે.

715
00:34:42,889 --> 00:34:47,179
>> અને તેથી હવે બહાર આકૃતિ, રેન્ડર
કાર્ડ, ચાલો માત્ર એરે પર જાઓ

716
00:34:47,179 --> 00:34:49,969
અને તે ઇન્ડેક્સ વસ્તુ પડાવી લેવું.

717
00:34:49,969 --> 00:34:53,580
પસંદ કરો કાર્ડ સમાન this.props.cards
this.state.activeIndex.

718
00:34:53,580 --> 00:34:56,469

719
00:34:56,469 --> 00:35:00,162
તમે અહીં જોઈ તો, પ્રોપ્સ અને
રાજ્ય ખરેખર મળીને કામ કરે છે.

720
00:35:00,162 --> 00:35:08,990
તેથી હવે અમે અમારા activeCard છે,
અમે તેને activeCard કહી શકશો

721
00:35:08,990 --> 00:35:10,470
અને આ કામ કરે છે જો માતાનો જોવા દો.

722
00:35:10,470 --> 00:35:20,320

723
00:35:20,320 --> 00:35:20,820
[અશ્રાવ્ય]

724
00:35:20,820 --> 00:35:41,504

725
00:35:41,504 --> 00:35:44,900
>> ઓહ, કે જે લખાણ ભૂલ હતી.

726
00:35:44,900 --> 00:35:45,400
આહ.

727
00:35:45,400 --> 00:35:51,420

728
00:35:51,420 --> 00:35:54,840
>> સરસ, હા, તેથી હવે અમે પાછા હતા
અમે પહેલા હતા, જ્યાં જમણી?

729
00:35:54,840 --> 00:35:57,100
સિવાય જ જૂના કાર્યક્રમ
હવે અમે આધાર આપી શકે છે

730
00:35:57,100 --> 00:35:59,390
કાર્ડ યાદી, માત્ર એક કાર્ડ.

731
00:35:59,390 --> 00:36:04,130
અને હવે, ફરી, અમે બદલી તો
activeIndex, અમે 1 0 થી જઈ શકે છે

732
00:36:04,130 --> 00:36:07,330
અને હવે તે બીજા કાર્ડ,
અને પછી અમે 0 ગયા.

733
00:36:07,330 --> 00:36:10,390
તેથી અહીં એક નવું
souped અપ અમારી આવૃત્તિ.

734
00:36:10,390 --> 00:36:16,000
>> ઠીક છે, તેથી હવે આપણે એક યાદી દૃશ્ય છે કે દો
તમારા કાર્યક્રમ માં તમામ કાર્ડ બતાવે છે

735
00:36:16,000 --> 00:36:19,980
તેથી અમે એક નવી બનાવવા પડશે
ઘટક listview કહેવાય છે.

736
00:36:19,980 --> 00:36:22,155
Listview react.createClass બરાબર કરીએ.

737
00:36:22,155 --> 00:36:32,890

738
00:36:32,890 --> 00:36:38,800
તેથી અમે એક unordered રેન્ડર કરવા માંગો છો
દરેક કાર્ડ માટે એક યાદી આઇટમ સાથે યાદી.

739
00:36:38,800 --> 00:36:41,490
અને તેથી અમે કાર્ડ સમૂહ છે.

740
00:36:41,490 --> 00:36:44,990
અમે એક યાદી આઇટમ માંગો છો
દરેક કાર્ડ માટે, અધિકાર?

741
00:36:44,990 --> 00:36:47,490
અમે લૂપ માટે શું કરી શકે છે અથવા
કંઈક નવી યાદી આઇટમ બનાવવા માટે.

742
00:36:47,490 --> 00:36:50,522
પરંતુ જે રીતે તમે તેને કરવા
પ્રતિક્રિયા, નકશો કહેવાય વસ્તુ વાપરો.

743
00:36:50,522 --> 00:36:57,150
નકશો એક સાધન અથવા તમે ઉપયોગ એક કાર્ય છે
કે દરેક આઇટમ માટે, અમુક કાર્ય ચાલે છે,

744
00:36:57,150 --> 00:36:59,510
વળતર કિંમત લે છે, અને
તમે તે પાછી આપે છે.

745
00:36:59,510 --> 00:37:06,310
>> ઉદાહરણ તરીકે, અમે એરે હોય છે તેથી
1, 2, 3.map function-- અને આ

746
00:37:06,310 --> 00:37:12,120
એક માટે સંકેત કરે છે
function-- X તીર X વખત એક્સ.

747
00:37:12,120 --> 00:37:16,110
આ દરેક નંબર માટે કહે છે,
1, 2, 3, તે લે છે.

748
00:37:16,110 --> 00:37:17,800
તે ચોરસ, અને તે પાછા આપે છે.

749
00:37:17,800 --> 00:37:22,090
તેથી જો તમે 1 શું વિચારો છો,
2, 3.map એક્સ એક્સ વખત જાય છે

750
00:37:22,090 --> 00:37:25,480
X તમે પાછા આપવામાં આપે છે
આ કાર્ય છે કે

751
00:37:25,480 --> 00:37:27,680
કે એરે દરેક તત્વ પર ચાલે છે.

752
00:37:27,680 --> 00:37:30,837

753
00:37:30,837 --> 00:37:32,190
>> પ્રેક્ષક: 1, 4 9?

754
00:37:32,190 --> 00:37:35,709
>> નીલ મહેતા: હા, 1, 4, 9
તમે 1 વખત 1 કરું છું.

755
00:37:35,709 --> 00:37:36,500
એટલે કે, તમે એક આપે છે.

756
00:37:36,500 --> 00:37:37,690
તે પ્રથમ તત્વ છે.

757
00:37:37,690 --> 00:37:38,530
>> 2 ગુણ્યા 2 4 છે.

758
00:37:38,530 --> 00:37:39,570
કે બીજા તત્વ છે.

759
00:37:39,570 --> 00:37:40,310
3 ગુણ્યા 3 9 છે.

760
00:37:40,310 --> 00:37:41,540
કે જે તૃતીય તત્વ છે.

761
00:37:41,540 --> 00:37:42,640
અર્થમાં બનાવવા?

762
00:37:42,640 --> 00:37:45,015
તેથી નકશો એક ટેકનિક તમે છે
કાર્યાત્મક પ્રોગ્રામરો ઉપયોગ,

763
00:37:45,015 --> 00:37:48,090
નવી શૈલી
કંઈક પ્રોગ્રામિંગ

764
00:37:48,090 --> 00:37:50,500
તમારા યાદીમાં દરેક તત્વ છે.

765
00:37:50,500 --> 00:37:51,970
અને તેથી આ પરિચિત લાગે છે.

766
00:37:51,970 --> 00:37:53,370
અમે કાર્ડ યાદી હોય છે.

767
00:37:53,370 --> 00:37:56,860
અમે દરેક માટે એક યાદી આઇટમ વિચાર કરવા માંગો છો
એક છે, તેથી અમે હમણાં જ અહીં નકશો ઉપયોગ કરશો.

768
00:37:56,860 --> 00:38:00,250
અમે યાદી સમકક્ષ દો, કહેવું પડશે
this.props, કાર્ડ, નકશો.

769
00:38:00,250 --> 00:38:10,580

770
00:38:10,580 --> 00:38:15,070
>> અને તેથી અમે છો, એક કાર્ડ આપવામાં
યાદી આઇટમ પેદા કરવા જઈ

771
00:38:15,070 --> 00:38:17,580
તે છે કે તે કાર્ડ સમાવિષ્ટો બાજુ સાથે.

772
00:38:17,580 --> 00:38:20,660
ચાલો આપણે બહાર આપવા માંગો છો કહે છે
કાર્ડ જેથી card.question પ્રશ્ન.

773
00:38:20,660 --> 00:38:24,990

774
00:38:24,990 --> 00:38:30,649
તેથી આ યાદી સમાવે છે એક
લિ માતાનો અથવા યાદી વસ્તુઓ એરે

775
00:38:30,649 --> 00:38:32,440
જ્યાં એક યાદી છે
દરેક કાર્ડ માટે વસ્તુ,

776
00:38:32,440 --> 00:38:35,150
અને તે કાર્ડ પ્રશ્ન છે.

777
00:38:35,150 --> 00:38:37,640
અર્થમાં બનાવવા?

778
00:38:37,640 --> 00:38:39,450
>> કૂલ છે, તેથી હવે દો
ખરેખર છે કે છાપશે.

779
00:38:39,450 --> 00:38:46,521
તેથી અમે એક ઉલ આપશે.

780
00:38:46,521 --> 00:38:49,020
કે unordered યાદી અંદર,
અમે ફક્ત સંપૂર્ણ યાદી વળગી પડશે

781
00:38:49,020 --> 00:38:49,890
તેઓ અમને આપ્યું છે.

782
00:38:49,890 --> 00:38:52,851

783
00:38:52,851 --> 00:38:53,350
કૂલ.

784
00:38:53,350 --> 00:38:56,060
>> બધા હક છે, તેથી હવે આ
સૂચિ દૃશ્ય માત્ર શોધી કામ કરે છે.

785
00:38:56,060 --> 00:38:59,842
આ યાદી જુઓ વિશે કોઇ પ્રશ્નો?

786
00:38:59,842 --> 00:39:01,270
તમે કાર્ડો એક ટોળું હોય છે.

787
00:39:01,270 --> 00:39:02,800
તમે દરેક કાર્ડ માટે એક યાદી આઇટમ બનાવે છે.

788
00:39:02,800 --> 00:39:05,466
અને તમે એક unordered અંદર તેમને મૂકી
યાદી, અને તમે તેને પાછા આપે છે.

789
00:39:05,466 --> 00:39:09,410
તેથી હવે આપણે તેથી અમે એમ્બેડ કાર્ય દો
અમારા એપ્લિકેશન આ અંદર,

790
00:39:09,410 --> 00:39:14,310
તેથી અમે યાદી જુઓ કરી શકો છો.

791
00:39:14,310 --> 00:39:17,070
શું દલીલ અમે જુઓ યાદી પર પસાર કરે છે?

792
00:39:17,070 --> 00:39:18,320
શું ગુણધર્મો અમે તેને આપી શકું?

793
00:39:18,320 --> 00:39:25,111

794
00:39:25,111 --> 00:39:26,860
તમે આપી, તો યાદ રાખો
તે કાર્ડ એક ટોળું

795
00:39:26,860 --> 00:39:29,590
તે યાદી બનાવવા પડશે
તે કાર્ડ માટે જુઓ.

796
00:39:29,590 --> 00:39:32,267
તેથી અમે શું પસાર થશે
અહીં દલીલ છે?

797
00:39:32,267 --> 00:39:33,350
પ્રેક્ષક: કાર્ડ યાદી?

798
00:39:33,350 --> 00:39:37,130
નીલ મહેતા: અરે વાહ, કાર્ડ જેથી
અધિકાર, this.props.cards બરાબર?

799
00:39:37,130 --> 00:39:39,850

800
00:39:39,850 --> 00:39:44,370
અને તેથી આ માત્ર સમસ્યા
કે તમે કરી શકો છો છે

801
00:39:44,370 --> 00:39:48,600
રેન્ડર એક ટોચ સ્તર તત્વ ચાલુ
જેથી તમે એક div માં લપેટી મળી છે.

802
00:39:48,600 --> 00:39:49,100
તે વિચિત્ર છે.

803
00:39:49,100 --> 00:39:56,190

804
00:39:56,190 --> 00:39:57,530
તેથી આપણે કે જો તે જોવા દો.

805
00:39:57,530 --> 00:40:09,790

806
00:40:09,790 --> 00:40:10,560
તે કામ કરે છે?

807
00:40:10,560 --> 00:40:29,774

808
00:40:29,774 --> 00:40:31,030
>> હા, ત્યાં તમે જાઓ.

809
00:40:31,030 --> 00:40:33,700
તેથી હવે અમે એક યાદી છે
તળિયે કાર્ડ,

810
00:40:33,700 --> 00:40:36,180
અને પછી અમે અમારી છે
ટોચ પર પોતે CardView,

811
00:40:36,180 --> 00:40:40,486
અને તે વચ્ચે વિમાનની મુસાફરી કરશે
કાર્ડ બે બાજુઓ.

812
00:40:40,486 --> 00:40:42,610
હવે મને લાગે છે કે કેવી રીતે કર્યું તે અર્થમાં બનાવવા કરે છે?

813
00:40:42,610 --> 00:40:45,165

814
00:40:45,165 --> 00:40:46,790
અરે વાહ, તેથી ફરી, અમે બે ઘટકો હોય છે.

815
00:40:46,790 --> 00:40:49,666
પ્રથમ ઘટક પ્રિન્ટ
બહાર યાદીમાં દરેક કાર્ડ.

816
00:40:49,666 --> 00:40:50,540
યાદી છે કે જે દૃશ્ય છે.

817
00:40:50,540 --> 00:40:54,770
અને બીજા ઘટક
કે જે હમણાં જ કાર્ડ છાપે છે.

818
00:40:54,770 --> 00:40:58,840
તમે તે ચોક્કસ કાર્ડ આપી હોય, તો તે પડશે
કે કાર્ડ વિશે જાણકારી છાપે

819
00:40:58,840 --> 00:41:01,870
અને તમે પાછા અને આગળ વિમાનની મુસાફરી દો.

820
00:41:01,870 --> 00:41:05,850
>> અમે માંગો છો, તો અમે પ્રયત્ન કરો અને ચર્ચા કરી શકો છો જેથી
આ માટે કેટલીક નવી સુવિધાઓ ઉમેરી વિશે.

821
00:41:05,850 --> 00:41:09,482
નહિંતર અમે થોડી વધુ વાત કરી શકો છો
રિએક્ટર વેગ વિશે,

822
00:41:09,482 --> 00:41:11,190
અથવા આપણે જવાબ કરી શકો છો
પ્રશ્નો તમે હોઈ શકે છે

823
00:41:11,190 --> 00:41:15,050
કારણ કે આ કોર ભાગો બધા છે
હું વિશે વાત કરવા માંગો છો કે પ્રતિક્રિયા.

824
00:41:15,050 --> 00:41:16,540
અમે આગળ જઈ શકે છે.

825
00:41:16,540 --> 00:41:17,590
અમે પ્રશ્નોના જવાબ કરી શકો છો.

826
00:41:17,590 --> 00:41:18,560
તમે કરવા માંગો છો ગમે.

827
00:41:18,560 --> 00:41:21,694

828
00:41:21,694 --> 00:41:24,205
>> પ્રેક્ષક: તમે ઉપયોગ કરી શકો છો
સામાન્ય જાવાસ્ક્રિપ્ટ JSX?

829
00:41:24,205 --> 00:41:27,150
અથવા તે કંઈક છે કે
[અશ્રાવ્ય] સાથે આવ્યા હતા?

830
00:41:27,150 --> 00:41:30,760
>> નીલ મહેતા: આ પ્રશ્ન કરી શકે છે
તમે સામાન્ય જાવાસ્ક્રિપ્ટ સાથે JSX ઉપયોગ કરો છો?

831
00:41:30,760 --> 00:41:32,620
જવાબ હા છે.

832
00:41:32,620 --> 00:41:41,070
JSX માત્ર તે એક રીતે તમારા લે છે
તે અંદર એચટીએમએલ છે કે જાવાસ્ક્રિપ્ટ,

833
00:41:41,070 --> 00:41:44,215
અને તે જાવાસ્ક્રિપ્ટ માં કમ્પાઇલ
તે અંદર એચટીએમએલ નથી.

834
00:41:44,215 --> 00:41:47,880
તેથી અહીં નોટિસ that-- નોટિસ.

835
00:41:47,880 --> 00:41:50,820
તમે DIV જેવા હોય છે, જેમ આ લાગે છે
અને તમે તેને અંદર સામગ્રી છે.

836
00:41:50,820 --> 00:41:54,970
>> જાવાસ્ક્રિપ્ટ પર કમ્પાઇલ
જેવી જ વસ્તુ પેદા કરે છે.

837
00:41:54,970 --> 00:41:59,590
હું શું હું કહી રહ્યો છું કે ધારી
તે જેવી છે JSX, માત્ર એક વાકયરચનામાં છે

838
00:41:59,590 --> 00:42:03,530
જાવાસ્ક્રિપ્ટ માટે એક preprocessor ખૂબ
PHP, જેમ HTML માટે preprocessor છે.

839
00:42:03,530 --> 00:42:05,490
JSC એક preprocessor છે
જાવાસ્ક્રિપ્ટ કે દે

840
00:42:05,490 --> 00:42:12,970
તમને તમારા Javascript ની અંદર એચટીએમએલ મૂકો.

841
00:42:12,970 --> 00:42:16,425
અને તેથી તમે યોગ્ય ટ્રાન્સફોર્મર હોય તો
જે [અશ્રાવ્ય] કહેવાય વસ્તુ છે,

842
00:42:16,425 --> 00:42:17,300
જે પરિવર્તન આવશે.

843
00:42:17,300 --> 00:42:19,360
જમણી preprocessor,
તે તમને તે કરવા દો પડશે.

844
00:42:19,360 --> 00:42:20,235
>> AUDIENCE: [અશ્રાવ્ય]

845
00:42:20,235 --> 00:42:23,026
નીલ મહેતા: સામાન્ય રીતે તમે જરૂર નથી
જાવાસ્ક્રિપ્ટ અંદર HTML મૂકી

846
00:42:23,026 --> 00:42:24,110
તમારી કરવાનું સિવાય પ્રતિક્રિયા.

847
00:42:24,110 --> 00:42:27,146
પરંતુ શું તમે તેમ છતાં તે કરી શકો છો.

848
00:42:27,146 --> 00:42:27,645
હા?

849
00:42:27,645 --> 00:42:29,353
>> પ્રેક્ષક: હું તમને લાગે
પ્રતિક્રિયા વર્ણવેલ હતી

850
00:42:29,353 --> 00:42:31,970
કાર્યાત્મક પ્રોગ્રામિંગ ભાષા તરીકે.

851
00:42:31,970 --> 00:42:35,646
અમે CS50 સી શીખવાની કરવામાં આવ્યાં છે.

852
00:42:35,646 --> 00:42:38,032
સી પણ એક કાર્યાત્મક ભાષા છે?

853
00:42:38,032 --> 00:42:39,990
નીલ મહેતા: તેથી પ્રશ્ન
કાર્યાત્મક વિશે છે

854
00:42:39,990 --> 00:42:43,010
કહેવાય અન્ય વસ્તુ વિરુદ્ધ
હિતાવહ કે પ્રક્રિયાગત પ્રોગ્રામિંગ.

855
00:42:43,010 --> 00:42:44,820
લોકપ્રિય કાર્યક્રમો બે પ્રકારના હોય છે.

856
00:42:44,820 --> 00:42:48,550
એક પ્રક્રિયાગત કહેવાય છે, જે
બધા કરી આદેશો જેવી છે

857
00:42:48,550 --> 00:42:51,510
અને એક કે જે બધી છે, વિધેયાત્મક છે
કાર્યો કર્યા અને વિશે

858
00:42:51,510 --> 00:42:52,930
ઇનપુટ અને તે આઉટપુટ.

859
00:42:52,930 --> 00:42:55,930
પ્રતિક્રિયા એક કાર્યાત્મક નમૂનારૂપ છે.

860
00:42:55,930 --> 00:42:58,010
સી ખૂબ જ પ્રક્રિયાગત નમૂનારૂપ છે.

861
00:42:58,010 --> 00:43:02,360
>> અને એક ઉદાહરણ તરીકે, ઉદાહરણ તરીકે સી,
તમે આ ઘોષણાત્મક રીતે નથી

862
00:43:02,360 --> 00:43:04,390
આ કાર્યક્રમ બનાવવા, અધિકાર?

863
00:43:04,390 --> 00:43:06,826
તમે કહે છે, આ છાપો.

864
00:43:06,826 --> 00:43:07,950
આ માહિતી માળખું બદલવા.

865
00:43:07,950 --> 00:43:08,530
આ છાપો.

866
00:43:08,530 --> 00:43:10,160
તે બધા આદેશો વિશે છે.

867
00:43:10,160 --> 00:43:12,640
>> પ્રતિક્રિયા, ત્યાં નથી
કે ઘણા આદેશો.

868
00:43:12,640 --> 00:43:15,145
તે કર્યા વિશે બધા છે
ઘટકો તમે સાથે મૂકવામાં.

869
00:43:15,145 --> 00:43:16,300
તેઓ કાર્યો જેવા છો.

870
00:43:16,300 --> 00:43:26,360
તમે એક કાર્ય જેમ છે
CardView કહેવાય છે,

871
00:43:26,360 --> 00:43:28,680
જે એક કાર્ય છે
કે, ઇનપુટ, આઉટપુટ છે

872
00:43:28,680 --> 00:43:30,660
અને તેથી પ્રતિક્રિયા બધા છે
આ ફિલસૂફી વિશે

873
00:43:30,660 --> 00:43:32,700
તમે માહિતી હોય having-- અમને.

874
00:43:32,700 --> 00:43:34,910
તમે આ મારફતે પસાર
અલ્ગોરિધમનો છે, અને તે પડશે

875
00:43:34,910 --> 00:43:36,800
આઉટપુટ HTML કે તમે
માત્ર પાનું પ્રિન્ટેડ,

876
00:43:36,800 --> 00:43:39,180
અને તેથી તમે છે
તે ભાગ દ્વારા ભાગ બિલ્ડ.

877
00:43:39,180 --> 00:43:42,800
>> તેથી એક રૂપક ડ્રો શું
હું પહેલાં જણાવ્યું હતું કે, તમે કેવી રીતે ખબર

878
00:43:42,800 --> 00:43:47,050
ફેસબુક પર તમે એક સંદેશ વિચાર જો
અને તમે અપડેટ કરવા શું ભાગો પસંદ કરો,

879
00:43:47,050 --> 00:43:47,882
કે પ્રક્રિયાગત છે.

880
00:43:47,882 --> 00:43:48,840
તે હક, હિતાવહ છે?

881
00:43:48,840 --> 00:43:49,806
ઠીક છે, હું એક સંદેશ મળ્યો.

882
00:43:49,806 --> 00:43:50,930
ત્યાં એકાઉન્ટ બદલી દો.

883
00:43:50,930 --> 00:43:52,110
>> અહીં વિન્ડો પોપ દો.

884
00:43:52,110 --> 00:43:52,780
ત્યાં એકાઉન્ટ બદલી દો.

885
00:43:52,780 --> 00:43:53,700
અહીં આ દોરીએ.

886
00:43:53,700 --> 00:43:55,220
તે એક પ્રક્રિયાગત અભિગમ છે.

887
00:43:55,220 --> 00:44:00,240
>> તે, કોણીય શું વસ્તુઓ છે
બુસ્ટ, બેકબોન, અન્ય માળખા ઉપયોગ કરે છે.

888
00:44:00,240 --> 00:44:01,200
પ્રતિક્રિયા વિધેયાત્મક છે.

889
00:44:01,200 --> 00:44:03,324
તે ખૂબ જ અલગ રીતે છે
વસ્તુઓ વિશે વિચારવાનો.

890
00:44:03,324 --> 00:44:07,950
તે હોય દો આ વિચાર લે છે
કાર્યો અથવા કે તમે ગાણિતીક નિયમો

891
00:44:07,950 --> 00:44:08,800
તે માહિતી આપે છે.

892
00:44:08,800 --> 00:44:11,820
તે બોલે છે પડશે શું તે
કમ્પ્યુટર હોઈ શકે છે, અને જોઈએ

893
00:44:11,820 --> 00:44:13,490
બહાર વજન કાળજી લેશે.

894
00:44:13,490 --> 00:44:15,890
તમે તેને જાતે સંભાળી નથી.

895
00:44:15,890 --> 00:44:18,470
તે અર્થમાં એક થોડો છે?

896
00:44:18,470 --> 00:44:18,970
અરે વાહ?

897
00:44:18,970 --> 00:44:24,180
>> પ્રેક્ષક: એક કાર્યાત્મક ભાષામાં,
બધું એક જ સમયે થાય છે?

898
00:44:24,180 --> 00:44:26,800
>> નીલ મહેતા: કોઈ, વસ્તુઓ ક્રમમાં થાય છે.

899
00:44:26,800 --> 00:44:29,320
અહીં જેવા હજુ પણ છે
ઓર્ડર છે, પરંતુ તે નથી

900
00:44:29,320 --> 00:44:32,390
જેમ ક્રમમાં થાય
આદેશ, આદેશ સ્વીકારવું.

901
00:44:32,390 --> 00:44:36,459
તે ક્રમમાં થાય છે
કાર્ય તમે આઉટપુટ આપે છે.

902
00:44:36,459 --> 00:44:37,750
અન્ય કાર્ય માં મૂકી.

903
00:44:37,750 --> 00:44:39,550
અન્ય માં મૂકી
કાર્ય, અન્ય કાર્ય.

904
00:44:39,550 --> 00:44:41,470
>> તમે CS51 હોય, તો તમે પડશે
કાર્યાત્મક કાર્યક્રમો શીખવા

905
00:44:41,470 --> 00:44:42,886
આ અવકાશ થોડી બહાર.

906
00:44:42,886 --> 00:44:45,090
પરંતુ મૂળભૂત રીતે, શું બનાવે છે
પ્રતિક્રિયા ઠંડી માત્ર છે

907
00:44:45,090 --> 00:44:46,840
વન-વે ડેટાનો પ્રવાહ
અને વર્ચ્યુઅલ ડોમ,

908
00:44:46,840 --> 00:44:48,700
પરંતુ પણ આ વિચાર
કાર્યાત્મક પ્રોગ્રામિંગ.

909
00:44:48,700 --> 00:44:51,720
અને વિધેયાત્મક પ્રોગ્રામિંગ ખૂબ જ સરળ છે
કંપોઝ અને બહાર સારી સામગ્રી બનાવવા માટે,

910
00:44:51,720 --> 00:44:53,844
અને લાગે છે કે તે ખૂબ જ સરળ છે
વિશે અને લગભગ કારણ છે.

911
00:44:53,844 --> 00:44:55,450
તેથી તે કામ અન્ય સારા ડ્રો છે.

912
00:44:55,450 --> 00:44:58,489

913
00:44:58,489 --> 00:44:59,280
કોઇ પ્રશ્નો?

914
00:44:59,280 --> 00:45:02,650

915
00:45:02,650 --> 00:45:03,150
અરે વાહ?

916
00:45:03,150 --> 00:45:06,840
>> પ્રેક્ષક: અમ, શા માટે તમે છો
var વિરોધ તરીકે દો ઉપયોગ કરો છો?

917
00:45:06,840 --> 00:45:10,450
>> નીલ મહેતા: તેથી પ્રશ્ન એ છે કે
શા માટે તમે તેના બદલે var દો ઉપયોગ કરી શકું?

918
00:45:10,450 --> 00:45:13,220
આ નામની એક વસ્તુ છે
ES6 અથવા એક્માસ્ક્રીપ્ટ 6.

919
00:45:13,220 --> 00:45:15,820
તે જાવાસ્ક્રિપ્ટ ની નવી આવૃત્તિ છે.

920
00:45:15,820 --> 00:45:19,050
ટેકનિકલ કારણો એક ટોળું હોય છે,
પરંતુ દો var એક સારી આવૃત્તિ છે.

921
00:45:19,050 --> 00:45:20,724
>> તમે ચલો જાહેર કેવી રીતે તે છે.

922
00:45:20,724 --> 00:45:21,390
તમે દો કરી શકો છો.

923
00:45:21,390 --> 00:45:22,140
તમે var વાપરી શકો છો.

924
00:45:22,140 --> 00:45:23,825
ચાલો ટેકનિકલ એક ટોળું છે
તમે તેમને જોવા કરી શકો છો reasons--

925
00:45:23,825 --> 00:45:25,610
તે વધુ સારું છે શા માટે later-- છે.

926
00:45:25,610 --> 00:45:28,780
મૂળભૂત રીતે, ES6 કેટલાક સરસ છે
નવી વાક્યરચના, કેટલાક નવા લક્ષણો

927
00:45:28,780 --> 00:45:30,720
જૂના જાવાસ્ક્રિપ્ટ ટોચ પર.

928
00:45:30,720 --> 00:45:32,782
>> તેથી અમે પાંચ મિનિટ જેવી છે.

929
00:45:32,782 --> 00:45:34,990
હું માત્ર વિશે વાત કરવા માગે છે
વધુ એક વસ્તુ વાસ્તવિક ઝડપી.

930
00:45:34,990 --> 00:45:36,450
જો તમે કોઇ પ્રશ્નો હોય તો,
ચાલો આ પછી તે વિશે વાત કરો.

931
00:45:36,450 --> 00:45:38,366
પરંતુ માત્ર જેથી આ નહીં
કેમેરા પર પડેલા છે, હું માત્ર

932
00:45:38,366 --> 00:45:41,550
તમે કેવી રીતે વિશે થોડી વાત કરવા માંગો છો
વાસ્તવમાં તમારા એપ્લિકેશન્સ પ્રતિક્રિયા ઉપયોગ કરે છે.

933
00:45:41,550 --> 00:45:47,220

934
00:45:47,220 --> 00:45:58,640
>> તમે અહીં જાઓ,
Facebook.GitHub.IO/react,

935
00:45:58,640 --> 00:46:03,320
આ પ્રતિક્રિયા માટે ઘર પાનું છે, અને
તે તમને ખરેખર ઉપયોગ કેવી રીતે તમે બતાવીશું

936
00:46:03,320 --> 00:46:05,320
તમારા પૃષ્ઠો પ્રતિક્રિયા.

937
00:46:05,320 --> 00:46:08,845
મૂળભૂત રીતે, તે થોડો છે
જટિલ પ્રતિક્રિયા સ્થાપિત કરવા માટે પ્રયાસ કરે છે.

938
00:46:08,845 --> 00:46:12,300
તમે માત્ર ખેંચો કારણ કે તે સરળ નથી
અને ત્યાં એક જાવાસ્ક્રિપ્ટ છોડો.

939
00:46:12,300 --> 00:46:15,890
>> તમે તમારા ટ્રાન્સફોર્મર હોય છે
તે પહેલાં કર્યું, જે કરશે સેટ,

940
00:46:15,890 --> 00:46:18,120
તમારા JSX ચાલુ
સામાન્ય જાવાસ્ક્રિપ્ટ.

941
00:46:18,120 --> 00:46:21,030
તમે કે પડશે વસ્તુ છે
તમે સામાન્ય ES6 કમ્પાઇલ.

942
00:46:21,030 --> 00:46:24,720
જાવાસ્ક્રિપ્ટ ખસેડવાની ઘણો છે
ભાગો તમે શું કરવાની હોય છે, તેથી એક વસ્તુ છે

943
00:46:24,720 --> 00:46:27,200
સામાન્ય જન, Yeoman.io કહેવાય છે.

944
00:46:27,200 --> 00:46:31,110
અને આ આદેશ વાક્ય સાધન છે કે પડશે
તમે તમારા પ્રતિક્રિયા બહાર પાલખ મદદ

945
00:46:31,110 --> 00:46:32,380
સરળતાથી પ્રોજેક્ટ.

946
00:46:32,380 --> 00:46:38,660
>> તેથી જો તમે આ વિશે વાંચી શકે છે
પાછળથી, પરંતુ કેટલાક સાધનો હોય છે

947
00:46:38,660 --> 00:46:40,160
સામાન્ય જન તક આપે છે.

948
00:46:40,160 --> 00:46:43,280
તેઓ પ્રતિક્રિયા તમે બનાવવા દો પડશે
માં બાંધવામાં બધું સાથે એપ્લિકેશન.

949
00:46:43,280 --> 00:46:46,030
તે બનેલ છે પડશે જેમ
ઘટકો, માં બાંધવામાં આવે છે.

950
00:46:46,030 --> 00:46:47,880
તે તમારા ટ્રાન્સફોર્મર માં બાંધવામાં પડશે.

951
00:46:47,880 --> 00:46:50,699
તેઓ ઠંડા ઘણો હોય છે
સામગ્રી આપોઆપ માં બાંધવામાં

952
00:46:50,699 --> 00:46:52,240
જનરેટર કહેવાય આ વસ્તુઓ મદદથી.

953
00:46:52,240 --> 00:46:54,620
>> જો તમને ગમે તો આ વિશે વાંચ્યું છે.

954
00:46:54,620 --> 00:46:59,110
જસ્ટ સામાન્ય જન, વાય-E-ઓ-એમ એ એન, અને પર જાઓ
તમે આ જેવા જનરેટર શોધી શકો છો.

955
00:46:59,110 --> 00:47:01,263
અને જેમ જનરેટર સાથે
આ, તમે માત્ર એક ગમે

956
00:47:01,263 --> 00:47:03,010
એક દંપતિ આદેશ વાક્ય આદેશો છે.

957
00:47:03,010 --> 00:47:05,530
તે બહાર પાલખ પડશે
સમગ્ર તમે માટે એપ્લિકેશન પ્રતિક્રિયા.

958
00:47:05,530 --> 00:47:10,470
તે બધા જાતે પાઇપિંગ મળશે,
અને કણકણાટ કામ, તમારા માટે કરવામાં

959
00:47:10,470 --> 00:47:13,010
અને આ તમે માત્ર ધ્યાન કેન્દ્રિત શા માટે છે
જસ્ટ લેખન પર પ્રતિક્રિયા.

960
00:47:13,010 --> 00:47:16,739
>> જેથી મૂળભૂત મકાન
એપ્લિકેશન nontrivial છે પ્રતિક્રિયા.

961
00:47:16,739 --> 00:47:19,530
તે બધા સાથે મળીને વાયર, પરંતુ ત્યાં
તમારા માટે તે કરીશ કે સાધનો છે.

962
00:47:19,530 --> 00:47:23,070
તમે બનાવવા માંગો છો તો એક પ્રતિક્રિયા તેથી
એપ્લિકેશન, તે રીતે કરી પ્રયાસ કરો.

963
00:47:23,070 --> 00:47:26,360
તમે માત્ર પ્રયોગ કરવા માંગો છો, તો
તમે આ CodePen ઉપયોગ પ્રયાસ કરી શકો છો

964
00:47:26,360 --> 00:47:28,550
આ CodePen છે, કારણ કે
બધા મકાનમાં વીજળીપ્રવાહના અખંડ માર્ગો પ્રતિક્રિયા.

965
00:47:28,550 --> 00:47:30,240
હું પહેલેથી જ તમારા માટે બધા કામ કર્યું છે.

966
00:47:30,240 --> 00:47:34,610
>> તમે જેવા બનાવવા માંગો છો, તો
ઉત્પાદન એપ્લિકેશન પ્રતિક્રિયા પ્રકાશિત કરવા માટે,

967
00:47:34,610 --> 00:47:37,220
આ જનરેટર એક પ્રયાસ કરો.

968
00:47:37,220 --> 00:47:40,240
તમે માત્ર રમવા માટે કરવા માંગો છો, તો
આસપાસ, તે ઘણી વખત માત્ર વર્થ છે

969
00:47:40,240 --> 00:47:44,490
જેમ અહીં CodePen પર આસપાસ રમી પ્રયાસ કરો.

970
00:47:44,490 --> 00:47:45,470
સાઉન્ડ સારી?

971
00:47:45,470 --> 00:47:45,970
કૂલ.

972
00:47:45,970 --> 00:47:47,890
>> જેથી હું છે બધા છે.

973
00:47:47,890 --> 00:47:52,470
ફરીથી, બધા કોડ અને ઉદાહરણો છે
અહીં આ વેબસાઇટ પર હોઈ ચાલે.

974
00:47:52,470 --> 00:47:55,509
તેથી, ફરી, અમે વાત કરી ન હતી
વિશે પ્રતિક્રિયા ખૂબ વાક્યરચના,

975
00:47:55,509 --> 00:47:57,550
પરંતુ તે તમામ શોધવા માટે
થોડી syntactical વિગતો,

976
00:47:57,550 --> 00:48:00,320
તે બધા ઉપલબ્ધ હશે
અહીં આ વેબસાઇટ પર.

977
00:48:00,320 --> 00:48:02,660
>> તેથી હું જેમ ભલામણ છો
પ્રથમ પગલું લે છે.

978
00:48:02,660 --> 00:48:06,277
તમારા CodePen માં મૂકો.

979
00:48:06,277 --> 00:48:08,110
બનાવવા પર કામ કરવાનો પ્રયાસ કરો
તે બીજું પગલું છે.

980
00:48:08,110 --> 00:48:11,310
ત્યાં ચોથા પગલું છે, અને માત્ર
તમે તે મેળવી છે તે જોવા.

981
00:48:11,310 --> 00:48:14,840
>> કોઇ પ્રશ્નો, ચેક
અથવા પેજ મને ઇમેઇલ કરો.

982
00:48:14,840 --> 00:48:16,490
તે મારા ઇમેઇલ છે.

983
00:48:16,490 --> 00:48:19,885
પરંતુ હું કોઇ પણ સાથે તમને મદદ કરવા માટે પ્રેમ કરશો
તમે વિશે હોઈ શકે છે પ્રશ્નો પ્રતિક્રિયા.

984
00:48:19,885 --> 00:48:21,010
તેથી, હા, હું છે બધા છે.

985
00:48:21,010 --> 00:48:23,410
ખૂબ ખૂબ માટે તમે બધા આભાર
જોવા અથવા હાજરી માટે.

986
00:48:23,410 --> 00:48:26,820
અને હું કોઈપણ પ્રશ્નો લેવા પડશે
તમે હવે આ પછી હોય શકે છે.

987
00:48:26,820 --> 00:48:29,140
તેથી જોવા માટે તમે બધા આભાર.

988
00:48:29,140 --> 00:48:31,270