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
>> కాబట్టి Facebook వెబ్ ఫ్రేమ్వర్క్
ఫేస్బుక్లో ద్వారా అభివృద్ధి చేయబడింది

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
భవిష్యత్తులో మరియు బహుశా ఇతర వేదికల
కేవలం ఒకే జావాస్క్రిప్ట్ కోడ్ ఉపయోగించి.

33
00:01:26,390 --> 00:01:31,130
మీరు ఖచ్చితమైన వాడవచ్చు
జావాస్క్రిప్ట్ కోడ్, వెబ్సైట్లు రెండర్

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
మేము ఎలా మార్చడానికి వెళ్తున్నారు
ఎప్పటికీ వెబ్ అనువర్తనాలను రూపొందించడానికి.

41
00:01:48,990 --> 00:01:55,820
కనుక ఇది బహుశా ఒక బిట్ అతిశయోక్తి వార్తలు, కానీ నేను
తెలిసిన ఒక అందమైన మంచి విషయం భావిస్తున్నాను.

42
00:01:55,820 --> 00:01:57,580
>> OK, కాబట్టి రియాక్ట్ ఏమిటి?

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
ఒక భాగమైన ఒక HTML ఉంది
స్టెరాయిడ్స్ న మూలకం,

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
వారు కంపోసబుల్ ఉన్నాయి.

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
మీరు Facebook లో పొందుపరచవచ్చు, ఉదాహరణకు,
కాలం ఇది ఉపయోగిస్తుంది అలాగే రియాక్ట్.

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
>> OK, కాబట్టి అది ఎందుకంటే చల్లని స్పందించలేదు ఉంది
చూడటం ఒక భిన్నమైన మార్గం ఉంది

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
ఆలోచన చుట్టూ నిర్మించబడింది రియాక్ట్
ఏకదిశాత్మక డేటా ప్రవాహం

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
>> Facebook Messenger లో,
రియాక్ట్ ఉంది, ఉదాహరణకి,

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 విషయం రెండర్
ఆ 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
మేము కంపోసబుల్ నిర్మించడం చేస్తున్నారు
సులభంగా స్కేలబుల్ వెబ్ అనువర్తనాలు.

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
మీరు పైథాన్ తిరిగి ముగింపు వంటి ఉంటే,
మీ పైథాన్ కొన్ని డేటా ఉమ్మి చేయవచ్చు ఉంటే,

151
00:06:50,480 --> 00:06:51,610
ఇది చేస్తుంది స్పందించలేదు.

152
00:06:51,610 --> 00:06:54,700
మీరు ఏ JS ప్రతిఫలాన్ని ఉంటే
దత్తాంశం యొక్క రియాక్ట్ ఇది చూపుతుంది.

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-- ఉంటే,
నేను పేజీలో జావాస్క్రిప్ట్ కోడ్ నడుస్తున్న నేను

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
>> OK, కాబట్టి ఒక జావాస్క్రిప్ట్ రియాక్ట్
లైబ్రరీ, మరియు వంటి,

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
మీరు JavaScript తెలుసుకోవడానికి చేయవచ్చు
అరగంట లో.

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
మీరు తెలిసి ఉన్నారు చేస్తే
HTML, 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 లేదా జావాస్క్రిప్ట్ తెలిసిన

220
00:10:00,794 --> 00:10:02,960
OK, కాబట్టి మేము చేయబోతున్నామని ఏమి
అలా మేము చూడాలని ఉంది

221
00:10:02,960 --> 00:10:06,470
రియాక్ట్ ఉపయోగించి చాలా ప్రాథమిక ఫ్లాష్కార్డ్ అనువర్తనం.

222
00:10:06,470 --> 00:10:08,210
మేము ఒక ఫ్లాష్కార్డ్ చూడాలని.

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
App సమాన 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
మరియు ఈ భాగం
stuff చేయడానికి చెయ్యలేరు.

250
00:11:35,270 --> 00:11:40,460
దీన్ని చెయ్యవచ్చు ప్రధాన విషయం రెండర్
ఏదో ఒక ఫంక్షన్ రెండర్.

251
00:11:40,460 --> 00:11:44,500
>> మళ్ళీ, ఈ ఇండెక్స్ స్పష్టమైన కాదు ఉంటే
మీరు నేను మీరు పిల్లులు కోసం JS కొనసాగుతాయి సిఫార్సు

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
>> , మీరు విషయం రెండర్ కాబట్టి
కొన్ని HTML తిరిగి అవసరం.

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 రాయడానికి వీలు
మీ JavaScript, ఏ

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
>> కాబట్టి యొక్క మేము కేవలం రెండర్ అనుకుందాం
ఇప్పుడు ఒక నేరుగా అప్ ఫ్లాష్కార్డ్.

270
00:12:32,390 --> 00:12:34,890
ఫ్లాష్కార్డ్, నేను చెబుతా
ఒక ప్రశ్న మరియు సమాధానాన్ని ఉంటుంది.

271
00:12:34,890 --> 00:12:37,530
కాబట్టి ఈ DIV లోపల, లెట్స్
ఒక పేరా ముద్రించాలా

272
00:12:37,530 --> 00:12:42,155
ఆ ఏమిటి ప్రశ్న చెప్పారు
జీవితం అంతిమ సమాధానం, విశ్వం?

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 ఇష్టం చెప్పడం వంటి
పేరా చిత్రం లేదా p కోసం,

285
00:13:25,100 --> 00:13:28,120
App ఉంది, కాబట్టి మీరు App రాయడానికి
ఒక HTML మూలకం వంటి చికిత్స.

286
00:13:28,120 --> 00:13:30,380
నేను ముందు చెప్పారు వంటి, అది
స్టెరాయిడ్స్ న ఒక మూలకం.

287
00:13:30,380 --> 00:13:32,870
>> కాబట్టి మీరు App నటించు, మరియు మీరు
అది చాలు ఒక స్థానాన్ని ఇవ్వాలని.

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
ఇది div తో ముద్రిస్తుంది
అది లోపలి రెండు పేరాలు.

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
మరియు voila, మా 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
ప్రస్తుతం మేము కేవలం
ఒక hardcoded కార్డు అన్వయించ.

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
మీరు చర్యలన్నీ ఫ్లాష్కార్డ్,
కేవలం ఇక్కడ ఇది ఫీడ్,

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
కాబట్టి మేము ఏమి మేము ఉంది
App నుండి మార్చవచ్చు

332
00:15:46,660 --> 00:15:51,300
CardView, కేవలం ఒక
అనువర్తనం కోసం కొత్త పేరు,

333
00:15:51,300 --> 00:15:54,450
మరియు మేము ఒక కొత్త తయారు చేయవచ్చు
భాగం, App అని

334
00:15:54,450 --> 00:15:56,336
పాత App తో పడకండి.

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
>> OK, కాబట్టి మేము మీరు మా 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
కాబట్టి నా కార్డు వీలు equal--
మీరు అన్ని తెలిసి ఉంటే,

350
00:17:02,930 --> 00:17:05,260
ఈ కేవలం సంజ్ఞామానం-మేకింగ్ ఉంది
జావాస్క్రిప్ట్ లో అభ్యంతరం.

351
00:17:05,260 --> 00:17:09,280
ఇది ఒక struct వంటి రకమైన ఉంది
సి లో, కాబట్టి మేము ఒక కార్డు తయారు

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
తరగతి బూట్స్ట్రాప్ కోసం BTN సమానం ,?

357
00:17:25,240 --> 00:17:29,500
అదే ఆలోచన, App కార్డు సమానం
మీరు కలుపులు ఉంచాలి పొందారు ఇక్కడ

358
00:17:29,500 --> 00:17:33,830
App కార్డు 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
మీరు అనువర్తనానికి ఇది పాస్
App కార్డు ఉపయోగించి 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
>> ఈ అనువర్తనం కార్డు ఏమి తెలుసు
ఉంది, మరియు అది తో stuff చేయవచ్చు.

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
>> OK, కాబట్టి ఇప్పుడు మేము CardView వద్ద ఉన్నారు.

383
00:18:46,990 --> 00:18:51,719
కార్డు ఇచ్చిన మా CardView, తప్పక
దాని ప్రశ్న మరియు సమాధానాన్ని ప్రింట్.

384
00:18:51,719 --> 00:18:54,510
ప్రస్తుతం మేము కేవలం ముద్రించిన కొన్ని
hardcoded ప్రశ్నలు మరియు సమాధానాలు.

385
00:18:54,510 --> 00:18:57,720
మేము అవసరం కళంకం దొరుకుతుందని అవసరం
వారు మాకు ఇచ్చిన కార్డు గోవా

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 మీరు, చెప్పారు
నాకు ఏ ఫ్లాష్కార్డ్ వస్తువు ఇవ్వాలని

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
>> OK, కాబట్టి యొక్క ఈ తయారు చేద్దాము
విషయం ఇంటరాక్టివ్.

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
OK, కాబట్టి ప్రస్తుతం ఈ భాగాలు
అన్ని వాళ్ళు చాలా బోరింగ్ ఉంటాయి,

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
>> ఒక ఫ్లాష్కార్డ్ కోసం కోసం
రాష్ట్ర ఉదాహరణకు, ఏ రకమైన

449
00:22:05,320 --> 00:22:07,550
మీరు అనుకోవచ్చు
ఒక ఫ్లాష్కార్డ్ గుర్తుంచుకుంటుంది?

450
00:22:07,550 --> 00:22:09,740
ఏం తాత్కాలిక స్థితి
మీరు గుర్తు అనుకోవచ్చు

451
00:22:09,740 --> 00:22:12,491
ఒక ఫ్లాష్కార్డ్ అనువర్తనంలో ఫ్లాష్కార్డ్ కోసం?

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
Facebook న, ఉదాహరణకు, మీరు చేస్తాను
న్యూస్ ఫీడ్ లో ఉన్న గుర్తుంచుకోవడానికి కావలసిన

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
>> ప్రేక్షకులు: [వినబడని]

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
>> ప్రేక్షకులు: OK.

467
00:22:41,070 --> 00:22:43,270
>> నీల్ మెహతా: ఇలా ఒక
కుడి, ఫ్లాష్కార్డ్ ద్విపార్శ్వ?

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
మళ్ళీ, నేను Facebook తెలిపారు
Messenger, నేను వ్యక్తి వలె కలిగి

472
00:22:54,380 --> 00:22:56,550
మీరు Facebook చూస్తున్నపుడు
లేదా కుడి, ప్రొఫైల్ వార్తలు?

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
ఇది కేవలం stuff వంటిది
విషయం ఇంటరాక్టివ్ చేస్తుంది.

481
00:23:13,700 --> 00:23:17,720
>> సో మా CardView-- యొక్క వివరించారు
మా CardView-- అది nice ఉంది కాబట్టి.

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 దశకంలో కాకముందు.

486
00:23:29,410 --> 00:23:31,270
ఆ భాగాలు గురించి ఒక nice భాగం.

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
>> OK, కాబట్టి ప్రస్తుతం, మేము ఉన్నాము, నటించు
ప్రశ్న మరియు సమాధానాన్ని చూపుతోంది.

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
Well, మొదట మాత్రం వేరియబుల్ తయారు.

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
>> నీల్ మెహతా: YEP, కాబట్టి టెక్స్ట్
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
కాబట్టి, ఉదాహరణకు, Facebook Messenger,
మీరు అదే డేటా మూలం పొందుటకు కూడా,

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
ఇది కేవలం nice కనిపిస్తోంది.

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
మీరు పిజ్జా పొందుటకు.

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
>> నీల్ మెహతా: YEP, కాబట్టి పడుతుంది సంసార
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
మేము అది ఏదైనా పునర్ చెప్పారు ఎప్పుడూ.

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
>> మీకు తెలుసా, HTML ఒక చెట్టు వంటిది,
ఒక క్రమానుగత డేటా నిర్మాణం వలె.

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
మరియు అప్పుడు మాత్రమే ఇష్టం మార్పులు
చిన్న సర్దుబాటు గీతలు లో పేజీ అవసరమైన

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
కాబట్టి nice ఉంది రియాక్ట్
అది ఒక షాడో 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
>> Facebook న మీరు కోరుకుంటే
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
మరియు మీరు లేదు కనుక
ఒక షాడో Dom కలిగి, మీరు భావిస్తే

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
ఇది సమర్థవంతమైన ఎందుకంటే
షాడో DOM యొక్క.

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
>> OK, కాబట్టి యొక్క యొక్క మాట్లాడటానికి వీలు చూద్దాం
దశ 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
యొక్క మా ఫ్లాష్కార్డ్ అనువర్తనం తప్పక చెప్పటానికి లెట్
అన్ని కార్డులు జాబితా కలిగి

673
00:32:28,730 --> 00:32:31,520
మీరు ఉంటుంది, కాబట్టి మేము అర్థం
మరొక భాగం ఉండాలి.

674
00:32:31,520 --> 00:32:32,970
Well, బహుశా జాబితా వీక్షణ కాల్.

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
కాబట్టి మొదటి Apps
ఇప్పుడు కోసం బ్రేక్ మాత్రం.

687
00:33:10,240 --> 00:33:14,717
All right, కాబట్టి మేము తయారు చేయబోతున్నామని
ఈ చేయగలరు బహుళ కార్డులు నిర్వహించడానికి.

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
>> కూల్, YEP, కాబట్టి ఇప్పుడు మేము తిరిగి
మేము ముందు ఇక్కడ, కుడి?

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
>> OK, కాబట్టి ఇప్పుడు యొక్క ఒక జాబితా వీక్షణ కలిగి అనుమతించే
మీ ప్రోగ్రామ్ లో అన్ని కార్డులు చూపిస్తుంది

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
కాబట్టి మేము ఒక క్రమం లేని చూపాలనుకునే
ప్రతి కార్డు కోసం ఒక జాబితా అంశాన్ని జాబితా.

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
Map ఒక సాధనం లేదా మీరు ఉపయోగించే ఒక ఫంక్షన్ ఉంది
ప్రతి అంశం కోసం, కొన్ని ఫంక్షన్ నడుస్తుంది,

744
00:36:57,150 --> 00:36:59,510
తిరిగి విలువ పడుతుంది, మరియు
మీరు ఆ తిరిగి ఇస్తుంది.

745
00:36:59,510 --> 00:37:06,310
>> ఒక ఉదాహరణగా, మేము శ్రేణి కలిగి కాబట్టి
1, 2, 3.map ఫంక్షన్ మరియు ఈ

746
00:37:06,310 --> 00:37:12,120
ఒక కుదింపు
ఫంక్షన్ x బాణం 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 x x సార్లు వెళుతుంది

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
>> నీల్ మెహతా: YEP, 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
కాబట్టి ఈ జాబితాను కలిగి ఒక
LI యొక్క లేదా జాబితా అంశాలు శ్రేణి

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
ఆ క్రమం లేని జాబితా లోపల,
మేము మొత్తం జాబితా కట్టుబడి ఉంటాం

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
>> All right, కాబట్టి ఇప్పుడు ఈ
జాబితా వీక్షణ కేవలం కనుగొనేందుకు పనిచేస్తుంది.

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
మరియు మీరు ఒక క్రమం లేని లోపల వాటిని ఉంచాలి
జాబితా, మరియు మీరు అది తిరిగి ఇవ్వాలని.

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
>> YEP, అక్కడ మీరు వెళ్ళండి.

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 దానిని యొక్క మార్గం మీ పడుతుంది
అది లోపలి HTML కలిగి జావాస్క్రిప్ట్,

833
00:41:41,070 --> 00:41:44,215
మరియు JavaScript లోకి కూర్చింది
అది లోపలి HTML కలిగి లేదు.

834
00:41:44,215 --> 00:41:47,880
కాబట్టి ఇక్కడ గమనించవచ్చు ఆ గమనించవచ్చు.

835
00:41:47,880 --> 00:41:50,820
మీరు div వంటి కలిగి వంటి ఈ కనిపిస్తోంది
మరియు మీరు అది లోపలి అంశాలు ఉన్నాయి.

836
00:41:50,820 --> 00:41:54,970
>> ఆ JavaScript కూర్చింది
వంటి ఇదే ఉత్పత్తి.

837
00:41:54,970 --> 00:41:59,590
నేను ఏమి నేను చెప్పడం నేను ఊహించడం
అంతే వంటి JSX, కేవలం ఒక వాక్యనిర్మాణ ఉంది

838
00:41:59,590 --> 00:42:03,530
JavaScript ఒక ప్రాసెసర్ చాలా
PHP వంటి HTML కోసం ఒక ప్రాసెసర్ ఉంది.

839
00:42:03,530 --> 00:42:05,490
JSC ఒక ప్రాసెసర్ ఉంది
జావాస్క్రిప్ట్ కోసం అనుమతించే

840
00:42:05,490 --> 00:42:12,970
మీరు మీ జావాస్క్రిప్ట్ లోపలి HTML ఉంచారు.

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
కుడి ప్రాసెసర్,
అది మీరు అలా తెలియజేస్తాము.

844
00:42:19,360 --> 00:42:20,235
>> ప్రేక్షకులు: [వినబడని]

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
Yep?

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
మీరు Facebook న ఒక సందేశాన్ని వస్తే
మరియు మీరు అప్డేట్ ఏమి భాగాలు ఎంచుకోండి

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
ఒక-మార్గం డేటా ప్రవాహం
మరియు వాస్తవిక Dom,

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 లేదా ECMA స్క్రిప్ట్ 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 కొన్ని nice ఉంది
కొత్త వాక్యనిర్మాణం కొన్ని కొత్త లక్షణాలు

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
మీరు కేవలం లాగండి వంటి సులభం కాదు
మరియు అక్కడ ఒక JavaScript డ్రాప్.

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
జస్ట్ రాజు, Y-ఇ-O-M-A-N, మరియు సాగుతుంది
మీరు ఈ వంటి జనరేటర్లు వెదుక్కోవచ్చు.

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
కానీ అన్ని ఆ కనుగొనేందుకు
చిన్న వాక్యనిర్మాణ వివరాలు,

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
కాబట్టి, YEP, నేను అంతే.

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