1
00:00:00,000 --> 00:00:02,270
>> [రివ్యూ: క్విజ్ 1]

2
00:00:02,270 --> 00:00:04,620
[ఆలీ Nahm, Oreoluwa Barbarinsa, లుకాస్ ఫ్రీటస్, రాబ్ బౌడెన్] [హార్వర్డ్ విశ్వవిద్యాలయం]

3
00:00:04,620 --> 00:00:07,660
[ఈ CS50 ఉంది.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[లుకాస్ ఫ్రీటస్] ప్రతి ఒక్కరూ స్వాగతం. ఈ క్విజ్ 1 కోసం సమీక్ష ఉంది.

5
00:00:11,610 --> 00:00:15,040
ఒక డిస్క్లైమర్ వంటి, ఈ ఉపన్యాసం -, మేము కవర్ చేయడానికి ప్రయత్నించండి చూడాలని

6
00:00:15,040 --> 00:00:17,770
సాధ్యం, కానీ విషయాలతో అని కాదు అని

7
00:00:17,770 --> 00:00:20,780
మేము క్విజ్ 1 ఉండగల విషయాలు అన్ని కవర్ చూడాలని.

8
00:00:20,780 --> 00:00:25,270
కాబట్టి మీరు కూడా ఒక ఉపన్యాసం వద్ద లుక్, విభాగాలు, మీరు ప్రతిదీ పడుతుంది చేయండి.

9
00:00:25,270 --> 00:00:28,240
క్విజ్ 1 బుధవారం, తదుపరి బుధవారం అన్నారు.

10
00:00:28,240 --> 00:00:33,800
కాబట్టి అధ్యయనం చేయండి. ఇది మొదటి క్విజ్ వంటి, చాలా చక్కని, చేస్తాడు

11
00:00:33,800 --> 00:00:36,390
దాని ఫార్మాట్ గురించి, కానీ బహుశా చాలా కష్టం చేస్తాడు.

12
00:00:36,390 --> 00:00:39,600
నేను 50 తీసుకున్నాడు కనీసం గత ఏడాది, నేను చాలా కష్టం భావించారు.

13
00:00:39,600 --> 00:00:42,410
కాబట్టి చాలా అధ్యయనం.

14
00:00:42,410 --> 00:00:45,190
>> నేను డేటా నిర్మాణాలు కవర్ వెళుతున్న మరియు హఫ్ఫ్మన్ కోడింగ్.

15
00:00:45,190 --> 00:00:47,910
ఈ, ప్రజలు చాలా క్లిష్టమైన భావిస్తున్న విషయం

16
00:00:47,910 --> 00:00:51,930
కానీ నేను వీలైనంత ఇది సులభంగా ప్రయత్నించండి వెళుతున్న.

17
00:00:51,930 --> 00:00:56,330
అన్ని మొదటి, మేము మీరు అబ్బాయిలు క్విజ్ 1 కోసం తెలుసుకోవాలంటే ఉంది

18
00:00:56,330 --> 00:01:00,970
నేను ప్రస్తుత వెళుతున్న డేటా నిర్మాణాలు ప్రతి సంభావిత వివరణలు అర్థం.

19
00:01:00,970 --> 00:01:03,960
మీరు లేదు అర్థం వాస్తవానికి

20
00:01:03,960 --> 00:01:07,020
మీ క్విజ్ 1 లో ఒక హాష్ పట్టిక అమలు.

21
00:01:07,020 --> 00:01:10,250
మేము మీరు మొత్తం హాష్ పట్టిక అమలు చేయకూడదని; బహుశా మేము ప్రయత్నిస్తాము

22
00:01:10,250 --> 00:01:13,090
మీరు కొన్ని విధులు అమలు చేయడానికి,

23
00:01:13,090 --> 00:01:16,940
అత్యంత సాధారణ శస్త్ర, కాని మేము మీరు ప్రతిదీ అమలు చేయడానికి వెళ్ళి లేదు.

24
00:01:16,940 --> 00:01:21,010
కాబట్టి మీరు ప్రతి డేటా నిర్మాణం వెనుక భావన అర్థం ఆ ముఖ్యం

25
00:01:21,010 --> 00:01:23,510
మరియు మీరు C లో కోడ్ చేయగల,

26
00:01:23,510 --> 00:01:27,880
వారు ప్రతి చర్చించి ఉండవచ్చు కేవలం అత్యంత సాధారణ శస్త్ర.

27
00:01:27,880 --> 00:01:30,090
మరియు, గమనికలు మరియు structs సమీక్షించి చెయ్యగలరు

28
00:01:30,090 --> 00:01:33,470
వారు ఈ డేటా నిర్మాణాలు చాలా కనిపిస్తాయి ఎందుకంటే.

29
00:01:33,470 --> 00:01:37,380
>> చాట్. లింక్ జాబితాలు నిజానికి శ్రేణుల పోలి ఉంటాయి,

30
00:01:37,380 --> 00:01:39,930
కానీ ఒక లింక్ జాబితా మరియు వ్యూహం మధ్య వ్యత్యాసం,

31
00:01:39,930 --> 00:01:45,160
మొదటి అన్ని యొక్క,, అనుబంధ జాబితా చాలా సరళమైన పరిమాణం కలిగి ఉంది

32
00:01:45,160 --> 00:01:50,060
శ్రేణుల లో మీరు అమరికకు ఒక పెద్ద పరిమాణం ఎంచుకోవడానికి గాని కలిగి,

33
00:01:50,060 --> 00:01:53,710
కాబట్టి మీరు, మీరు, ఆ శ్రేణి లో అన్ని మీ డేటాను నిల్వ చెయ్యడానికి వెళుతున్న తెలుసు

34
00:01:53,710 --> 00:01:59,370
లేదా మీరు శ్రేణి యొక్క సరళమైన పొడవు కలిగి malloc ఉపయోగించాలి.

35
00:01:59,370 --> 00:02:03,680
లింక్ జాబితాలు లో ఇది కేవలం మరింత అంశాలు పొందడానికి చాలా సులభం,

36
00:02:03,680 --> 00:02:07,210
లింక్ జాబితాలో మరిన్ని అంశాలు ఉంచారు లేదా అంశాలను తొలగించు.

37
00:02:07,210 --> 00:02:09,370
మరియు వాస్తవానికి, మీరు లింక్ జాబితా వేరు చేయకూడదని ఉంటే,

38
00:02:09,370 --> 00:02:13,950
శోధన మరియు స్థిరమైన సమయంలో అంశాలు తొలగించవచ్చు,

39
00:02:13,950 --> 00:02:16,800
కాబట్టి O (1) సమయం, కాబట్టి అది చాలా సౌకర్యవంతంగా ఉంది.

40
00:02:16,800 --> 00:02:20,660
మీరు కేవలం, నోడ్స్ ఎల్లప్పుడూ malloc గుర్తుంచుకోండి జాగ్రత్తగా మరియు ఉచిత ఉండాలి

41
00:02:20,660 --> 00:02:25,510
మీరు లేకపోతే, మీరు మెమరీ లీకేజ్ ఉంటుంది కనుక.

42
00:02:25,510 --> 00:02:31,480
కాబట్టి లింక్ జాబితాలు - ఒక నోడ్ యొక్క నిర్వచనం కేవలం మేము అక్కడే ఏమి వంటి ఉంది.

43
00:02:31,480 --> 00:02:35,110
నేను p-సెట్స్, కానీ మీరు మీకు కావలసిన డేటా నిల్వ చేయవచ్చు.

44
00:02:35,110 --> 00:02:37,280
మీరు ఒక స్ట్రింగ్ నిల్వ అనుకుంటే కాబట్టి, అది మంచిది.

45
00:02:37,280 --> 00:02:41,690
మీరు ఒక struct నిల్వ చేయాలనుకుంటే, మీరు కావలసిన,, ఒక డబుల్ మంచిది.

46
00:02:41,690 --> 00:02:44,630
కాబట్టి ఈ p-సెట్స్.

47
00:02:44,630 --> 00:02:46,800
మరియు మీరు తదుపరి నోడ్ ఒక పాయింటర్.

48
00:02:46,800 --> 00:02:51,940
కాబట్టి, ప్రాథమికంగా, ఒక అనుబంధ జాబితా కొన్ని డేటా ఉంది, తరువాత ఇది తదుపరి నోడ్ పాయింట్లు.

49
00:02:51,940 --> 00:02:56,710
ఇది లింక్ జాబితాలో చివరి మూలకం, అది శూన్య సూచించడానికి జరగబోతోంది.

50
00:02:56,710 --> 00:02:59,060
కాబట్టి ఈ అనుబంధ జాబితా యొక్క ఒక ఉదాహరణ.

51
00:02:59,250 --> 00:03:05,960
>> సరే, ఇప్పుడు నేను ఒక అనుబంధ జాబితా ఒక మూలకం ఇన్సర్ట్ అనుకుంటే యొక్క మేము చెయ్యాలి చూద్దాం.

52
00:03:05,960 --> 00:03:08,810
మొదటి, ఒక ఫంక్షన్ చొప్పించు రకం శూన్యము ఉంటుంది

53
00:03:08,810 --> 00:03:11,350
నేను దేన్నీ వద్దు ఎందుకంటే.

54
00:03:11,350 --> 00:03:14,200
నేను ఒక వాదన వంటి ఒక Int తీసుకుని వెళుతున్న,

55
00:03:14,200 --> 00:03:17,090
నేను ఇన్సర్ట్ ఏమి తెలుసు అనుకుంటున్నారా ఎందుకంటే.

56
00:03:17,090 --> 00:03:21,840
నేను చెయ్యాలి మొదటి విషయం ఏమిటి? Well, నేను newnode న malloc ఉండాలి,

57
00:03:21,840 --> 00:03:24,240
కాబట్టి మొదటి లైన్.

58
00:03:24,240 --> 00:03:27,580
నేను ఒక అనుబంధ జాబితా లో ఉంచాలి ఒక కొత్త నోడ్ సృష్టించడం నేను.

59
00:03:27,580 --> 00:03:32,360
నేను ఏమి చెయ్యగలరు? బాగా, మేము తెలిసిన లింక్ జాబితాలు మా అమలు లో

60
00:03:32,360 --> 00:03:38,180
తరగతి, మేము ఎల్లప్పుడూ ఒక ప్రపంచ వేరియబుల్ వంటి తల పెట్టి.

61
00:03:38,180 --> 00:03:41,800
కాబట్టి మనం చేయవచ్చు తల మార్చండి ఉంది.

62
00:03:41,800 --> 00:03:44,300
నేను ఈ కొత్త నోడ్ కొత్త తల చేయవచ్చు,

63
00:03:44,300 --> 00:03:46,670
మరియు అది మునుపటి తల సూచించడానికి జరగబోతోంది.

64
00:03:46,670 --> 00:03:50,390
మేము ఆ చేయవచ్చు? నేను చేయాల్సిందల్లా మొదటి విషయం

65
00:03:50,390 --> 00:03:54,770
, విలువకు కొత్త నోడ్ లో 'n' మార్పు

66
00:03:54,770 --> 00:03:57,530
ఫంక్షన్ ఆమోదించింది ఇది.

67
00:03:57,530 --> 00:04:01,050
అప్పుడు newnode నెక్స్ట్ తల అన్నారు.

68
00:04:01,050 --> 00:04:05,800
తల newnode అన్నారు. కాబట్టి ఇది అందంగా సులభం.

69
00:04:05,800 --> 00:04:10,090
ఒక నోడ్ తొలగించడం, మేము లాగా చేయవచ్చు -

70
00:04:10,090 --> 00:04:14,790
మేము ఆ చేయగలిగే విధంగా చెప్పబడినది,

71
00:04:14,790 --> 00:04:18,160
సరే, నేను తొలగించడానికి కోరుకుంటే, ఉదాహరణకు, 3,

72
00:04:18,160 --> 00:04:24,850
నేను చేయగలిగే కేవలం మునుపటి నోడ్ స్థానం

73
00:04:24,850 --> 00:04:27,580
3 యొక్క తదుపరి నోడ్.

74
00:04:27,580 --> 00:04:29,400
నేను ఆ వంటి ఏదో ఒకటి అని.

75
00:04:29,400 --> 00:04:33,400
కానీ చేయడం సమస్య ఏమిటి?

76
00:04:33,400 --> 00:04:37,400
నేను మెమొరీ లీక్ ఉన్నాయి, నేను ఇకపై సంఖ్య 3 యాక్సెస్ లేదు.

77
00:04:37,400 --> 00:04:42,480
ఆ సమస్య నేను ఆ నోడ్ విడిపించేందుకు చెయ్యడానికి వెళ్ళడం లేదు అని ఉంది.

78
00:04:42,480 --> 00:04:45,360
నేను మెమరీ లీకేజీ (అపారదర్శక) నాకు ద్వేషం అన్నారు వెళుతున్న.

79
00:04:45,360 --> 00:04:49,370
బదులుగా ఆ చేయడం వలన, నేను బహుశా తాత్కాలిక పాయింటర్ కలిగి ఉండాలి.

80
00:04:49,370 --> 00:04:53,210
నేను తాత్కాలిక చాలు. ఇది నేను తొలగించదలిచారా నోడ్ సూచించడానికి అన్నారు.

81
00:04:53,210 --> 00:04:58,170
ఆపై నేను తదుపరి నోడ్ బిందువు మునుపటి నోడ్స్ తరలించవచ్చు

82
00:04:58,170 --> 00:05:00,390
నేను తొలగించదలిచారా నోడ్ యొక్క.

83
00:05:00,390 --> 00:05:02,730
చివరకు, నేను చేస్తాము.

84
00:05:02,730 --> 00:05:07,480
నేను అక్కడే సృష్టించిన పాయింటర్ విడిపించేందుకు ఉందా?

85
00:05:07,480 --> 00:05:09,560
నేను, కనుక లేదు -

86
00:05:09,560 --> 00:05:13,430
తేడా ఈ నోడ్ malloc ఉపయోగించి సృష్టించిన ఉంది,

87
00:05:13,430 --> 00:05:17,280
ఈ ఒక కేవలం స్టాక్ లో ఒక నల్ స్విచ్ ప్రకటించారు కాబట్టి ఇది, కుప్ప లో ఉంది.

88
00:05:17,280 --> 00:05:20,000
ఎప్పుడు లేదు.

89
00:05:20,000 --> 00:05:22,030
సరే >>. కాబట్టి ఇప్పుడు యొక్క స్టాక్స్ గురించి మాట్లాడటానికి వీలు.

90
00:05:22,030 --> 00:05:24,680
స్టాక్స్ అందంగా సూటిగా ఉన్నాయి.

91
00:05:24,680 --> 00:05:29,540
మేము శ్రేణుల ఉపయోగించి తరగతి లో స్టాక్స్ మరియు క్యూలు చేశాడు,

92
00:05:29,540 --> 00:05:32,820
కానీ మీరు తెలిసిన ఉండాలి - కేవలం తెలుసుకోవాలి

93
00:05:32,820 --> 00:05:40,740
మీరు కూడా అదే అనుసంధాన జాబితాలు ఉపయోగించి క్యూలు లో స్టాక్స్ చేసే.

94
00:05:40,740 --> 00:05:44,460
మీరు వ్యూహం కలిగి చేస్తే, ఏమి ఒక స్టాక్ ఉంటుంది?

95
00:05:44,460 --> 00:05:46,810
ఒక స్టాక్, మొదటి, ఒక పరిమాణం కలిగి ఉంటుంది.

96
00:05:46,810 --> 00:05:49,950
మీరు ఇప్పుడే కలిగి స్టాక్ పరిమాణం నిల్వ ఉంటుంది.

97
00:05:49,950 --> 00:05:52,980
మరియు మీరు, సంఖ్యల ఈ సందర్భంలో, వ్యూహం వుంటుంది

98
00:05:52,980 --> 00:05:55,120
కానీ మీరు కోరుకుంటే, అది వ్యూహం ఉంటుంది

99
00:05:55,120 --> 00:06:00,380
తంత్రుల struct యొక్క వ్యూహం, మీరు నిల్వ మీరు ఏదైనా.

100
00:06:00,380 --> 00:06:03,240
స్టాక్ గురించి: ఒక స్టాక్ మరియు అనుబంధ జాబితా మధ్య వ్యత్యాసం

101
00:06:03,240 --> 00:06:08,590
స్టాక్ మీరు మాత్రమే స్టాక్ లో ఉంచబడినది చివరి మూలకం ప్రాప్తి ఉంది.

102
00:06:08,590 --> 00:06:11,770
అది మొదటి, గత లో అని.

103
00:06:11,770 --> 00:06:15,090
మీరు ట్రేలు ఒక స్టాక్ కలిగి వలె,

104
00:06:15,090 --> 00:06:17,670
మీరు స్టాక్ పైన ఒక ట్రే ఉంచితే,

105
00:06:17,670 --> 00:06:22,670
మీరు ఇతర ట్రేలు యాక్సెస్ మొదటి ట్రే తొలగించాలి.

106
00:06:22,670 --> 00:06:26,310
ఇది స్టాక్లతో అదే విషయం.

107
00:06:26,310 --> 00:06:31,220
నేను, ఉదాహరణకు, ఒక స్టాక్ ఒక మూలకం జోడించడానికి అనుకుంటే, నేను ఏమి చెయ్యాలి?

108
00:06:31,220 --> 00:06:34,070
ఇది పుష్ అనే, మరియు ఇది మంచి సూటిగా వార్తలు అనిపిస్తుంది.

109
00:06:34,070 --> 00:06:37,130
మీరు చేయాల్సిందల్లా మొదటి విషయం చెక్ ఉంటే స్టాక్ పరిమాణం

110
00:06:37,130 --> 00:06:40,150
ఎక్కువ లేదా స్టాక్ సామర్థ్యం సమానం కాదు.

111
00:06:40,150 --> 00:06:45,810
మీరు ఇప్పటికే పూర్తి సామర్థ్యం ఉంటే, మీరు వేరే ఏదైనా చేర్చలేరు ఎందుకంటే.

112
00:06:45,810 --> 00:06:51,140
కాదు ఆపై, మీరు స్టాక్కు మూలకం చేర్చుకోవాలి.

113
00:06:51,140 --> 00:06:54,530
చివరకు, పరిమాణం పెంచడం. కనుక ఇది చాలా సూటిగా ఉంది.

114
00:06:54,530 --> 00:06:57,140
కాబట్టి నేను సంఖ్య 2 జోడించండి.

115
00:06:57,140 --> 00:07:00,350
నేను పాప్ అనుకుంటే, ఇది నేను తొలగించాలని అర్థం

116
00:07:00,350 --> 00:07:03,870
జోడించారు మరియు మూలకం యొక్క విలువ తిరిగి ఆ గత మూలకం,

117
00:07:03,870 --> 00:07:09,180
నేను తనిఖీ మొదటి విషయం స్టాక్ ఖాళీ కాదు.

118
00:07:09,180 --> 00:07:11,510
అది ఖాళీ ఉంటే, నేను దేన్నీ ఎందుకంటే.

119
00:07:11,510 --> 00:07:14,820
ఆ సందర్భంలో, నేను -1 తిరిగి నేను.

120
00:07:14,820 --> 00:07:18,960
లేకపోతే, నేను స్పెక్ యొక్క పరిమాణం తరుగుదల వెళుతున్న,

121
00:07:18,960 --> 00:07:22,510
మరియు సంఖ్యలు (s.size) తిరిగి.

122
00:07:22,510 --> 00:07:27,230
నేను పరిమాణం తరుగుదల ఆపై s.size తిరిగి లేదు?

123
00:07:27,230 --> 00:07:30,930
ఈ సందర్భంలో, స్పెక్ పరిమాణం 4 ఉంది, ఎందుకంటే,

124
00:07:30,930 --> 00:07:33,810
మరియు నేను నాల్గవ తిరిగి కావలసిన, కుడి?

125
00:07:33,810 --> 00:07:36,030
కానీ నాల్గవ సూచిక ఏమిటి? మూడు.

126
00:07:36,030 --> 00:07:44,510
నేను పరిమాణం కాబట్టి - 3 అన్నారు, నేను (s.size) s.numbers తిరిగి

127
00:07:44,510 --> 00:07:48,410
ఇది 3 ఎందుకంటే. కనుక ఇది కేవలం సూచిక ఉంది.

128
00:07:48,410 --> 00:07:50,380
>> ఇప్పుడు వరుసలో. క్యూలు చాలా చక్కని ఇదే ఉంటాయి.

129
00:07:50,380 --> 00:07:54,950
మాత్రమే తేడా, బదులుగా చివరి లో కలిగి, మొదటి ముగిసింది

130
00:07:54,950 --> 00:07:57,480
మీరు మొదటి, మొదటి కలిగి.

131
00:07:57,480 --> 00:07:59,460
మీరు ఒక కచేరీ వెళ్ళడానికి వేచి బహుశా ఉంటే,

132
00:07:59,460 --> 00:08:04,260
మీరు బదులుగా ఒక క్యూ ఒక స్టాక్ కలిగి ఉంటే మీరు సంతోషంగా ఉండదు.

133
00:08:04,260 --> 00:08:07,730
వచ్చిన చివరి వ్యక్తి కార్యక్రమం ప్రవేశించిన మొదటి వ్యక్తి ఉంటుంది.

134
00:08:07,730 --> 00:08:09,760
మీరు బహుశా సంతోషంగా ఉండదు.

135
00:08:09,760 --> 00:08:15,020
క్యూ లో, లో పొందడానికి మొదటి వ్యక్తి కూడా అవుట్ మొదటి వ్యక్తి.

136
00:08:15,020 --> 00:08:18,720
కాబట్టి ఒక క్యూ నిర్వచనం, అర్రే పరిమాణం కలిగి పాటు,

137
00:08:18,720 --> 00:08:23,360
మీరు కూడా స్టాక్ అధిపతి సూచిక ఇది తల, కలిగి.

138
00:08:23,360 --> 00:08:29,000
ప్రస్తుతం మొదటి మూలకం కాబట్టి.

139
00:08:29,000 --> 00:08:32,710
ఎన్క్యూ స్టాక్లకు పుష్ అదే విషయం.

140
00:08:32,710 --> 00:08:34,980
మీరు చాలా సరళ ఉంటే, మీరు కేవలం చెబుతారు,

141
00:08:34,980 --> 00:08:39,289
నేను పుష్ చేసినట్టే అలాగే, నేను అదే విషయం చేయవచ్చు.

142
00:08:39,289 --> 00:08:44,030
ఇది తలదన్నిన లేకుంటే నేను తనిఖీ చేయవచ్చు.

143
00:08:44,030 --> 00:08:48,760
అది ఉంటే, నేను లేకపోతే నేను కొత్త విలువ ఎగుమతి చేయవచ్చు, తప్పుడు తిరిగి

144
00:08:48,760 --> 00:08:50,630
ఆపై పరిమాణం పెంచడం.

145
00:08:50,630 --> 00:08:52,750
కానీ ఎందుకు ఈ తప్పు?

146
00:08:52,750 --> 00:08:55,010
ఈ ఉదాహరణ చూద్దాం.

147
00:08:55,010 --> 00:08:57,020
నేను stuff ఒక సమూహం ఎన్క్యూ ప్రయత్నిస్తున్నాను,

148
00:08:57,020 --> 00:08:58,390
ఆపై నేను dequeue మరియు ఎన్క్యూ వెళుతున్న.

149
00:08:58,390 --> 00:09:00,550
అక్కడ ఆదేశాల చాలా, కానీ ఇది చాలా సులభం.

150
00:09:00,550 --> 00:09:04,790
నేను 5 ఎన్క్యూ, కాబట్టి 5 జోడించండి మాత్రం, ఆపై 7, వెబ్

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, మరియు నేను ఏదో dequeue మీరు,

152
00:09:09,310 --> 00:09:12,000
ఇది నేను మొదటి మూలకం తొలగించు వెళుతున్న అర్థం.

153
00:09:12,000 --> 00:09:14,640
కాబట్టి నేను సంఖ్య 3 తొలగించు వెళుతున్న?

154
00:09:14,640 --> 00:09:17,320
మొదటి మూలకం. సరే.

155
00:09:17,320 --> 00:09:21,450
నేను ఏదో ఎన్క్యూ ప్రయత్నించినట్లయితే ఏమౌతుంది అన్నారు?

156
00:09:21,450 --> 00:09:24,290
నా అమలు ప్రకారం,

157
00:09:24,290 --> 00:09:31,040
నేను ఇండెక్స్ q.size తరువాత సంఖ్య ఉంచాలి వెళుతున్నాను.

158
00:09:31,040 --> 00:09:35,140
ఈ సందర్భంలో, పరిమాణం 8 ఉంది,

159
00:09:35,140 --> 00:09:38,640
కాబట్టి ఇండెక్స్ 8 గత స్థానంలో ఇక్కడే ఉంటుంది.

160
00:09:38,640 --> 00:09:43,900
నేను ఇక్కడే 1 ఎన్క్యూ ప్రయత్నించండి ఉంటే, నేను గత స్థానం కొట్టివేతలు అవుతుంది

161
00:09:43,900 --> 00:09:45,870
పూర్తిగా తప్పు సంఖ్య 1, కు.

162
00:09:45,870 --> 00:09:49,870
నేను చేయాలనుకుంటున్నారా చుట్టూ మరియు మొదటి స్థానం వెళ్ళండి ఉంది.

163
00:09:49,870 --> 00:09:52,870
బహుశా మీరు బాగా, నేను చెక్ ఉంటుంది చెబుతా

164
00:09:52,870 --> 00:09:55,600
నిజానికి అక్కడ ఏదో ఉంచవచ్చు ఉంటే.

165
00:09:55,600 --> 00:09:58,560
లేకపోతే, నేను, OH, కొత్త పూర్తి సామర్థ్యం, ​​చెప్పటానికి

166
00:09:58,560 --> 00:10:02,010
నిజానికి సామర్థ్యం - 1, మరియు మీరు అక్కడ ఒక మూలకం కాదు.

167
00:10:02,010 --> 00:10:06,150
కానీ సమస్య ఏమిటి? సమస్య అని నేను ఇక్కడే ప్రతిదీ dequeue ఉంటే

168
00:10:06,150 --> 00:10:08,240
ఆపై నేను ఏదో జోడించడానికి ప్రయత్నించండి, ఇది కేవలం చెబుతారు,

169
00:10:08,240 --> 00:10:11,210
బాగా, మీరు 0 ఇది పూర్తి సామర్థ్యం వద్ద ఉన్నాయి.

170
00:10:11,210 --> 00:10:13,620
మీ క్యూ వెళ్లిపోయిన.

171
00:10:13,620 --> 00:10:16,990
మీరు చుట్టూ ఉంటుంది, మరియు చుట్టూ చుట్టడం ఒక మార్గం

172
00:10:16,990 --> 00:10:22,040
మీరు అధ్బుతమైన మరియు ఇతర psets నేర్చుకున్న అబ్బాయిలు mod ఉపయోగించి ఆ.

173
00:10:22,040 --> 00:10:29,090
మీరు q.size + q.head అని ఎందుకు అర్థం ఇంట్లో ప్రయత్నించవచ్చు

174
00:10:29,090 --> 00:10:31,080
mod సామర్థ్యం, ​​కానీ మీరు ఇక్కడ తనిఖీ ఉంటే,

175
00:10:31,080 --> 00:10:34,760
మేము ఆ పని చూడగలరు.

176
00:10:34,760 --> 00:10:37,760
గత ఉదాహరణలో, 8 q.size ఉంది

177
00:10:37,760 --> 00:10:47,590
ఇది ఇక్కడ శ్రేణి యొక్క ఈ స్థానం ఎందుకంటే మరియు తల, 1 ఉంది.

178
00:10:47,590 --> 00:10:51,970
కనుక ఇది + 1 8, 9 ఉంటుంది. మోడ్ సామర్థ్యం 9 0 ఉంటుంది.

179
00:10:51,970 --> 00:10:56,640
ఇది ఇండెక్స్ 0 కు చేరుతుంది. మేము స్థానం ఉంటాము.

180
00:10:56,640 --> 00:10:59,750
తరువాత ఇంట్లో క్యూ ప్రయత్నించండి.

181
00:10:59,750 --> 00:11:04,950
కొన్ని ముఖ్యమైన విషయాలు: ఒక స్టాక్ మరియు ఒక క్యూ మధ్య వ్యత్యాసం అర్థం ప్రయత్నించండి.

182
00:11:04,950 --> 00:11:11,620
ఇంటిలో, ఎన్క్యూ, dequeue, పుష్ మరియు పాప్ అమలు చాలా బాగా ప్రయత్నించవచ్చు.

183
00:11:11,620 --> 00:11:16,560
మీరు వాటిని ప్రతి ఉపయోగించడానికి ఎప్పుడు మరియు అర్థం.

184
00:11:16,560 --> 00:11:22,830
>> కాబట్టి యొక్క తప్పనిసరిగా కొంత తో 10 సెకన్ల బాస్.

185
00:11:22,830 --> 00:11:26,080
ఇప్పుడు యొక్క తిరిగి డేటా నిర్మాణాలు వినుడు.

186
00:11:26,080 --> 00:11:29,770
పట్టికలు హాష్. మంది హాష్ పట్టికలు భయపడుతుంటారు.

187
00:11:29,770 --> 00:11:33,650
సమస్య 6 సెట్ లో, అక్షర తనిఖీ.

188
00:11:33,650 --> 00:11:35,980
హాష్ పట్టికలు మరియు ప్రయత్నాలు, ప్రజలు చాలా వాటిని భయపడతారు.

189
00:11:35,980 --> 00:11:38,540
వారు అర్థం చాలా కష్టం భావిస్తున్నాను. అవును?

190
00:11:38,540 --> 00:11:41,490
[రాబ్ బౌడెన్] సమస్య 5 సెట్. >> సమస్య అవును, 5 సెట్. ధన్యవాదాలు రాబ్.

191
00:11:41,490 --> 00:11:43,370
అవును. ఆరు హఫ్ n 'పఫ్, అవును ఉంది.

192
00:11:43,370 --> 00:11:49,340
సమస్య అక్షర తనిఖీ 5 సెట్, మరియు మీరు ఒక హాష్ పట్టిక లేదా ఒక ప్రయత్నించండి వుపయోగించటానికి వచ్చింది.

193
00:11:49,340 --> 00:11:55,360
మంది వారు అర్థం సూపర్ హార్డ్ అనుమానించి, కానీ వారు నిజానికి చాలా సాధారణ ఉన్నాము.

194
00:11:55,360 --> 00:12:01,290
ఒక హాష్ పట్టిక ప్రధానంగా, ఏమిటి? ఒక హాష్ పట్టిక లింక్ జాబితాలు యొక్క వ్యూహం ఉంది.

195
00:12:01,290 --> 00:12:06,730
వ్యూహం మరియు ఒక హాష్ పట్టిక మధ్య తేడా

196
00:12:06,730 --> 00:12:09,730
హాష్ పట్టిక లో మీరు హాష్ విధి అని ఏదో ఉంటుంది.

197
00:12:09,730 --> 00:12:12,080
హాష్ విధి ఏమిటి?

198
00:12:12,080 --> 00:12:13,970
మీరు అబ్బాయిలు ఇక్కడ చదువుకోవచ్చు ఉంటే నాకు తెలీదు.

199
00:12:13,970 --> 00:12:16,090
సరే ఒక ఉదాహరణ.

200
00:12:16,090 --> 00:12:19,220
కాబట్టి మీరు 31 అంశాలతో వ్యూహం కలిగి చూడగలరు.

201
00:12:19,220 --> 00:12:22,440
మరియు మేము ఒక హాష్ పట్టిక లో ఒక హాష్ ఫంక్షన్ను ఉంది

202
00:12:22,440 --> 00:12:26,660
ఒక కీ అనువదించు అన్నారు, ప్రతి ఒక ఇండెక్స్ Int.

203
00:12:26,660 --> 00:12:31,740
, ఉదాహరణకు, నేను B. హారిసన్ కోసం ఎంచుకోండి అనుకుంటే,

204
00:12:31,740 --> 00:12:34,190
నా హాష్ విధులు లో B. హారిసన్ ఉంచుతాడు,

205
00:12:34,190 --> 00:12:36,960
హాష్ ఫంక్షన్ 24 తిరిగి.

206
00:12:36,960 --> 00:12:40,930
కాబట్టి నేను 24 లో B. హారిసన్ నిల్వ మీరు తెలుసు.

207
00:12:40,930 --> 00:12:46,580
కాబట్టి ఆ వ్యూహం కలిగి మరియు ఒక హాష్ పట్టిక కలిగి మధ్య తేడా ఉంది.

208
00:12:46,580 --> 00:12:48,740
హాష్ పట్టిక మీరు చెప్పడం అన్నారు ఒక ఫంక్షన్ ఉంటుంది

209
00:12:48,740 --> 00:12:54,740
మీరు నిల్వ కావలసిన డేటా నిల్వ.

210
00:12:54,740 --> 00:12:57,040
కాబట్టి మేము, మీరు హాష్ విధి కోసం చూడవచ్చు

211
00:12:57,040 --> 00:13:00,600
ఆ డొమెస్టిక్ మరియు బాగా పంపిణీ ఉంది.

212
00:13:00,600 --> 00:13:07,810
మీరు ఇక్కడ చూడవచ్చు, మీరు నేను స్టోర్ కోరుకున్నాడు డేటా చాలా నిజానికి 19 సంపాదించెను

213
00:13:07,810 --> 00:13:12,470
బదులుగా అన్ని ఉండేవారని ఇది 31 మరియు 30 మరియు 29, ఉపయోగించి.

214
00:13:12,470 --> 00:13:16,920
నేను ఉపయోగించిన హాష్ విధి చాలా బాగా కుడి.

215
00:13:16,920 --> 00:13:20,710
మేము బాగా పంపిణీ చెప్పినప్పుడు, మేము కలిగి కావలసిన అర్థం

216
00:13:20,710 --> 00:13:26,520
సుమారు, కనీసం 1 లేదా ప్రతి 2 -

217
00:13:26,520 --> 00:13:32,190
వంటి, శ్రేణుల లో సూచీలు ప్రతి 1 లేదా 2 ఒక తేడా.

218
00:13:32,190 --> 00:13:43,950
మీరు, సుమారు, వ్యూహం ప్రతి లింక్ జాబితాలో అంశాల అదే నెంబర్ కావాలి.

219
00:13:43,950 --> 00:13:48,600
మరియు అది, హాష్ పట్టిక లో చెల్లదు హాష్ పట్టికలు వంటి వీక్షణ ఉంటే తనిఖీ సులభం.

220
00:13:48,600 --> 00:13:51,770
>> అప్పుడు చెట్లు. ఈ ఒక వృక్షం.

221
00:13:51,770 --> 00:13:56,400
కంప్యూటర్ సైన్స్ లో చెట్లు కారణం డౌన్ పైకి ఉంటాయి.

222
00:13:56,400 --> 00:14:00,150
కాబట్టి ఇక్కడ మీరు చెట్టు యొక్క మూల మరియు ఆకులు కలిగి.

223
00:14:00,150 --> 00:14:05,630
మీరు తల్లిదండ్రులు మరియు పిల్లల నామావళి తెలుసుకోవాలి.

224
00:14:05,630 --> 00:14:12,880
ప్రతి నోడ్ మాతృ క్రింద ఉండే నోడ్స్ ఉండే తన పిల్లలు, ఉంది.

225
00:14:12,880 --> 00:14:19,660
కాబట్టి, ఉదాహరణకు, 2, అక్కడే 3 కోసం మరియు ఇతర పిల్లల కోసం మాతృ అన్నారు

226
00:14:19,660 --> 00:14:25,290
3 1 కోసం మాతృ మరియు ఉన్నాయి ఇతర పిల్లలు అన్నారు అయితే.

227
00:14:25,290 --> 00:14:29,990
మరియు 1 అందువలన న 3 పిల్లలను అన్నారు, మరియు.

228
00:14:29,990 --> 00:14:34,610
మేము, మరింత ఆసక్తికరంగా, ఒక బైనరీ శోధన చెట్టు అనే

229
00:14:34,610 --> 00:14:39,040
దీనిలో ఒక నోడ్ యొక్క కుడి అన్ని విలువలు

230
00:14:39,040 --> 00:14:41,660
ఇక్కడే, కుడి ఉంటాయని - కుడి,

231
00:14:41,660 --> 00:14:46,780
x = ఎక్కువ ఉంటాయని.

232
00:14:46,780 --> 00:14:49,780
కుడి న, నేను ఇక్కడే సంఖ్య 5 కలిగి ఉంటే, అన్ని అంశాలు

233
00:14:49,780 --> 00:14:51,940
5 కంటే ఎక్కువ మాత్రం, మరియు ఎడమ ఉన్నాయి

234
00:14:51,940 --> 00:14:56,770
అన్ని అంశాలు 5 కంటే తక్కువ ఉంటాయని.

235
00:14:56,770 --> 00:14:58,780
ఎందుకు ఈ ఉపయోగపడుతుంది?

236
00:14:58,780 --> 00:15:01,660
Well, నేను సంఖ్య 7 ఇక్కడ ఉంటే తనిఖీ అనుకుంటే, ఉదాహరణకు,

237
00:15:01,660 --> 00:15:05,960
నేను మొదటి 5 వెళ్లి నేను చూడండి వెళుతున్న, 5 కంటే 7 ఎక్కువ లేదా తక్కువ ఉంది?

238
00:15:05,960 --> 00:15:09,540
ఇది ఎక్కువ, కనుక నేను చెట్టు యొక్క కుడి ఉండాలి చేస్తాడు తెలుసు.

239
00:15:09,540 --> 00:15:13,980
నేను చూడండి తక్కువ అంశాలు ఉన్నాయి.

240
00:15:13,980 --> 00:15:19,520
ఒక బైనరీ శోధన చెట్టు, నోడ్ అమలులో, నేను, డేటా కలిగి వెళుతున్న

241
00:15:19,520 --> 00:15:21,750
కాబట్టి Int n; మీరు ఒక స్ట్రింగ్ కలిగి

242
00:15:21,750 --> 00:15:23,630
లేదా మీరు కోరుకున్న ఏదైనా.

243
00:15:23,630 --> 00:15:28,100
మీరు ఎక్కువ ఏమిటి నిర్వచించు న జాగ్రత్తగా ఉండాలి, తక్కువ ఏమిటి.

244
00:15:28,100 --> 00:15:30,390
కాబట్టి మీరు తీగలను కలిగి ఉంటే, ఉదాహరణకు, మీరు నిర్వచించడం

245
00:15:30,390 --> 00:15:34,690
కుడివైపు సంగతులన్నీ పెద్ద పొడవు కలిగి వెళ్ళే,

246
00:15:34,690 --> 00:15:40,940
ఎడమ తక్కువ పొడవు పొందబోతున్నారు, కాబట్టి అది మీకు నిజంగా ఉంది.

247
00:15:40,940 --> 00:15:44,930
>> నేను జూలకంటి కోసం కనుగొనేందుకు అమలు?

248
00:15:44,930 --> 00:15:47,840
మేము మొదటి విషయం రూట్ NULL ఉంటే తనిఖీ ఉంది.

249
00:15:47,840 --> 00:15:50,920
ఇది NULL, అది విషయం కాదు అర్థం

250
00:15:50,920 --> 00:15:53,330
మీరు కూడా ఒక చెట్టు, కుడి లేదు ఎందుకంటే?

251
00:15:53,330 --> 00:15:55,790
నేను తప్పుడు తిరిగి.

252
00:15:55,790 --> 00:15:58,740
లేకపోతే, నేను సంఖ్య ఎక్కువ ఉంటే తనిఖీ వెళుతున్న

253
00:15:58,740 --> 00:16:01,720
రూటు విలువ కంటే.

254
00:16:01,720 --> 00:16:04,250
నేను కుడి మూలకం కనుగొనేందుకు ప్రయత్నించండి వెళుతున్న

255
00:16:04,250 --> 00:16:08,590
చెట్టు.

256
00:16:08,590 --> 00:16:11,310
మీరు నేను ఇక్కడ సూత్రం ఉపయోగించి వెబ్ చూడండి.

257
00:16:11,310 --> 00:16:14,150
ఇది తక్కువ ఉంటే, నేను ఎడమ చూడండి వెళుతున్న.

258
00:16:14,150 --> 00:16:18,330
చివరకు, లేకపోతే, అది ఎక్కువ తక్కువ లేదా కాదు,

259
00:16:18,330 --> 00:16:20,660
ఇది దానిని విలువ కూడా అర్థం.

260
00:16:20,660 --> 00:16:23,010
కాబట్టి నేను నిజమైన తిరిగి.

261
00:16:23,010 --> 00:16:26,360
మీరు నేను ఉంటే, ఉంటే, ఉంటే ఉపయోగించిన ఇక్కడ చూడగలరు.

262
00:16:26,360 --> 00:16:30,820
మరియు, గుర్తు క్విజ్ 0 లో, మేము,, ఉంటే, ఉంటే ఉందని ఒక సమస్య వచ్చింది

263
00:16:30,820 --> 00:16:32,780
మరియు మీరు అసమర్థతపై కనుగొనేందుకు నిర్ణయించుకున్నాయి,

264
00:16:32,780 --> 00:16:35,180
మరియు అసమర్థతపై మీరు అనుభవిస్తున్నారు.

265
00:16:35,180 --> 00:16:39,060
మీరు అయితే వేరే, ఉంటే, ఉంటే ఉపయోగిస్తారు, మరియు మిగతా వుండాలి.

266
00:16:39,060 --> 00:16:44,240
ఉంటే మిగిలిన ఉంటే మిగిలిన ఇక్కడ కాబట్టి, నేను వేరే ఉపయోగించాలి?

267
00:16:44,240 --> 00:16:46,200
మళ్ళీ చేయాలి - అవును?

268
00:16:46,200 --> 00:16:51,140
[స్టూడెంట్ మాట్లాడే, వినబడని]

269
00:16:51,140 --> 00:16:53,480
ఆ ఖచ్చితమైన ఉంది. కాబట్టి ఆమె, అది పట్టింపు లేదు మాట్లాడుతూ

270
00:16:53,480 --> 00:16:55,930
కనుక మేము ముందు ఉందని అసమర్థతపై

271
00:16:55,930 --> 00:16:59,550
అని, కొన్ని పరిస్థితి సంతృప్తి ఉండవచ్చు ఉంటే,

272
00:16:59,550 --> 00:17:03,570
కాబట్టి మీరు ఒక చర్య, కానీ మీరు ఇతర పరిస్థితులు అన్ని తనిఖీ ఉండేవి.

273
00:17:03,570 --> 00:17:06,319
కానీ ఈ సందర్భంలో, అది వెంటనే తిరిగి, కాబట్టి అది పట్టింపు లేదు.

274
00:17:06,319 --> 00:17:09,220
కాబట్టి మీరు అయితే వేరే ఉపయోగించడానికి లేదు.

275
00:17:09,220 --> 00:17:11,740
>> చివరకు, యొక్క ప్రయత్నాలు మాట్లాడటానికి వీలు,

276
00:17:11,740 --> 00:17:13,800
ఇది అందరి ఇష్టమైన ఉంది.

277
00:17:13,800 --> 00:17:15,980
ఒక ప్రయత్నించండి శ్రేణుల యొక్క ఒక వృక్షం.

278
00:17:15,980 --> 00:17:20,369
ఇది విలువలు చూసేందుకు చాలా వేగమైనది, కానీ మెమరీ చాలా ఉపయోగిస్తుంది.

279
00:17:20,369 --> 00:17:22,530
మరియు అది పదాలు ఫిల్టర్ సాధారణంగా ఉంది, కాబట్టి మీరు

280
00:17:22,530 --> 00:17:27,920
మీ ఫోన్ లో ఒక ఫోన్ బుక్ వంటి, ఉదాహరణకు, నేను తెలియదు, అమలుచెయ్యాలని

281
00:17:27,920 --> 00:17:30,440
మరియు మీరు B టైప్ చెయ్యడానికి మీరు

282
00:17:30,440 --> 00:17:32,510
మరియు కేవలం B. కలిగి వ్యక్తుల పేర్లు కలిగి

283
00:17:32,510 --> 00:17:37,960
ఇది ఉదాహరణకు, ఒక ప్రయత్నించండి ఉపయోగించి ఆ అమలు చాలా సులభం.

284
00:17:37,960 --> 00:17:39,820
ఎలా మీరు ఒక ప్రయత్నించండి ఒక నోడ్ నిర్ధారిస్తారు?

285
00:17:39,820 --> 00:17:43,910
మీరు is_word కావడం ఒక bool కలిగి.

286
00:17:43,910 --> 00:17:48,660
ఆ, ఆ నోడ్ ముందు అన్ని అక్షరాలు ఉపయోగించి ఆ సూచిస్తుంది

287
00:17:48,660 --> 00:17:51,920
మీరు ఒక పదము సాధించారు,

288
00:17:51,920 --> 00:17:57,230
ఆపై మీరు కణుపులకు గమనికలు యొక్క వ్యూహం ఉంటుంది.

289
00:17:57,230 --> 00:18:03,120
మీరు మేము ఒక పేరెంట్ ల శ్రేణి, కాబట్టి నోడ్ * శ్రేణి కలిగి చూడగలరు? అవును?

290
00:18:03,120 --> 00:18:06,050
కాబట్టి యొక్క ఆ పని ఎలా చూద్దాం. స్పెల్ చెక్ కోసం,

291
00:18:06,050 --> 00:18:08,230
మేము 27 అంశాల వ్యూహం కలిగి,

292
00:18:08,230 --> 00:18:12,150
మేము అన్ని అక్షరాలు ప్లస్ అపాస్టిఫియర్ ఎందుకంటే.

293
00:18:12,150 --> 00:18:17,800
నేను బోర్డు వ్రాయండి చెయ్యడానికి కావలసిన ఎందుకంటే ఇక్కడ ముందు నేను 2 ఉపయోగించడానికి వెళుతున్న.

294
00:18:17,800 --> 00:18:20,230
సరే. కాబట్టి ఈ ఒక ప్రయత్నించండి యొక్క ఒక ఉదాహరణ.

295
00:18:20,230 --> 00:18:25,600
నేను మొదటి నోడ్ నిర్వచించే ఉంటే, నేను 2 అంశాల వ్యూహం ఉంటుంది

296
00:18:25,600 --> 00:18:29,290
శూన్య 2 గమనికలు ఉన్నాయి, కాబట్టి నేను 'ఒక' మరియు 'బి' పెట్టే.

297
00:18:29,290 --> 00:18:32,430
నేను is_word అని ఒక bool కలిగి వెళుతున్న.

298
00:18:32,430 --> 00:18:34,420
ఇది మొదటి ఒక కోసం తప్పుడు చేస్తాడు,

299
00:18:34,420 --> 00:18:37,370
కేవలం, ఎందుకంటే ముందు మీరు ఏ అక్షరాలు లేదు.

300
00:18:37,370 --> 00:18:40,900
కాబట్టి ఒక ఖాళీ పదం ఒక పదం కాదు. కనుక ఇది తప్పు.

301
00:18:40,900 --> 00:18:46,320
నేను ఈ నిఘంటువు 'ఒక' జోడించాలనుకుంటే, నేను వుంటుంది?

302
00:18:46,320 --> 00:18:49,760
నేను 'ఒక' కోసం ఒక కొత్త నోడ్ malloc వుంటుంది,

303
00:18:49,760 --> 00:18:54,630
ఆపై నిజమైన దాని పదం జోడించండి.

304
00:18:54,630 --> 00:19:00,180
కనుక ఇది కేవలం 'ఒక' నిజమే అన్నారు వలన ఆ సూచిస్తుంది. సమంజసం?

305
00:19:00,180 --> 00:19:04,120
నేను 'బా' జోడించాలనుకుంటే అప్పుడు, నేను 'బి' కోసం malloc 1 ఉంటుంది,

306
00:19:04,120 --> 00:19:07,550
ఆపై నేను, తప్పుకు బూలియన్ ఏర్పాటు వెళుతున్న

307
00:19:07,550 --> 00:19:10,160
ద్వారా 'బి' ఒక పదం కాదు ఎందుకంటే.

308
00:19:10,160 --> 00:19:13,010
అప్పుడు నేను మరొక 'ఒక' కోసం ఒకటి, 'బా' malloc వెళుతున్న,

309
00:19:13,010 --> 00:19:16,290
ఆపై నేను నిజమైన ఒక పదం ఏర్పాటు వెళుతున్న.

310
00:19:16,290 --> 00:19:18,950
'బా' ఒక పదం ఎందుకంటే.

311
00:19:18,950 --> 00:19:21,910
నేను చూడటానికి కావాలా తర్వాత 'బి' ఈ నిఘంటువు ఉంటే

312
00:19:21,910 --> 00:19:26,730
నేను మొదటి ఒకటి, 'బి' వెళ్ళవచ్చు. నేను డౌన్ వెళ్లి, నేను పదం చూడండి, మరియు అది తప్పుడు చెప్పారు.

313
00:19:26,730 --> 00:19:30,110
కనుక ఇది ఒక పదం కాదు. నేను 'బా' తనిఖీ చేయాలనుకుంటే,

314
00:19:30,110 --> 00:19:38,010
నేను మొదటి ఒక, 'బి' వెళ్ళండి, ఆపై 'ఒక' వెళ్లి, నేను నిజమైన చూడండి, కాబట్టి ఇది ఒక పదం. సమంజసం?

315
00:19:38,010 --> 00:19:41,950
మంది ప్రయత్నాలు అయోమయంలో పొందడానికి. ఏ?

316
00:19:41,950 --> 00:19:44,740
>> చివరగా, హఫ్ఫ్మన్ కోడింగ్. హఫ్ఫ్మన్ కోడింగ్ చాలా ఉపయోగకరంగా ఉంది

317
00:19:44,740 --> 00:19:47,550
మెమరీ సేవ్ మరియు టెక్స్ట్ ఫైళ్లు కుదించుము,

318
00:19:47,550 --> 00:19:52,270
కనుక మీరు ఉదాహరణకు, 'ఒక' మరియు 'ఇ' ఉపయోగించడానికి సార్లు చాలా,

319
00:19:52,270 --> 00:19:57,710
మీరు అబ్బాయిలు చాలా 'q' లేదా 'z' ఉపయోగిస్తే మీ పత్రాలు లో, కానీ నేను తెలియదు.

320
00:19:57,710 --> 00:20:02,040
ప్రతి పాత్ర కోసం కేవలం 1 బైట్ కలిగి,

321
00:20:02,040 --> 00:20:08,520
ప్రతి - మేము ASCII పట్టిక కలిగి 256 అక్షరాలు చాలా ఆశించకూడదు,

322
00:20:08,520 --> 00:20:11,410
మీరు మరింత ఉపయోగించే కొన్ని అక్షరాలు ఉన్నాయి కనుక,

323
00:20:11,410 --> 00:20:15,180
కాబట్టి మీరు విషయాలే తక్కువ మెమరీ ఉపయోగించాలి.

324
00:20:15,180 --> 00:20:17,560
నేను హఫ్ఫ్మన్ కోడింగ్ ఉపయోగించగలను?

325
00:20:17,560 --> 00:20:20,010
మేము ఒక హఫ్ఫ్మన్ చెట్టు చేయాల్సిందల్లా.

326
00:20:20,010 --> 00:20:23,370
 ఒక హఫ్ఫ్మన్ చెట్టు నోడ్స్ ఉంది

327
00:20:23,370 --> 00:20:27,760
లేఖ, 'సి', 'బి', 'ఒక', వంటి అన్నారు చిహ్నంగా కలిగి,

328
00:20:27,760 --> 00:20:32,990
మీరు చర్యలన్నీ అక్షరం, పదం టెక్స్ట్ కనిపించే ఫ్రీక్వెన్సీ అని ఒక ఫ్రీక్వెన్సీ,

329
00:20:32,990 --> 00:20:36,280
మీరు, కోసం హఫ్ఫ్మన్ చెట్టు జరిగింది అని

330
00:20:36,280 --> 00:20:41,800
ఆపై హఫ్ఫ్మన్ చెట్టు యొక్క ఎడమ సూచించడానికి అన్నారు ఒక నోడ్

331
00:20:41,800 --> 00:20:47,210
మరియు కుడి సూచించడానికి అన్నారు మరొక నోడ్. అవును ఇష్టం.

332
00:20:47,210 --> 00:20:49,440
ఎలా మీరు ఒక హఫ్ఫ్మన్ చెట్టు నిర్మించడానికి చెయ్యాలి?

333
00:20:49,440 --> 00:20:54,020
మీరు తక్కువ పౌనః ఆ 2 నోడ్స్ ఎంచుకోండి చూడాలని.

334
00:20:54,020 --> 00:20:56,490
మీరు ఒక వ్యక్తి మీరు 2 నోడ్స్ ఎంచుకోండి చూడాలని

335
00:20:56,490 --> 00:20:59,870
అలాగే అత్యల్ప ASCII విలువలు కలిగి.

336
00:20:59,870 --> 00:21:02,420
అప్పుడు మీరు ఆ 2 నోడ్స్ నుండి కొత్త చెట్టు సృష్టించడానికి చూడాలని

337
00:21:02,420 --> 00:21:08,030
ఆ పేరెంట్ నోడ్ లో కలిపి ఫ్రీక్వెన్సీ కలిగి అన్నారు.

338
00:21:08,030 --> 00:21:13,240
ఆపై మీరు అడవి నుండి 2 పిల్లలు తొలగించడానికి చూడాలని

339
00:21:13,240 --> 00:21:15,570
మరియు మాతృ వాటిని భర్తీ.

340
00:21:15,570 --> 00:21:18,930
మరియు మీరు మాత్రమే అడవిలో 1 చెట్టు వరకు ఆ పునరావృతం చూడాలని.

341
00:21:18,930 --> 00:21:23,840
కాబట్టి యొక్క మీరు ZAMYLA కోసం ఒక హఫ్ఫ్మన్ చెట్టు అని ఎలా చూద్దాం.

342
00:21:23,840 --> 00:21:29,220
మీరు అన్ని అక్షరాలు 'ఒక' తప్ప ఫ్రీక్వెన్సీ 1 కలిగి ఇక్కడ చూడగలరు; ఫ్రీక్వెన్సీ 2 కలిగి.

343
00:21:29,220 --> 00:21:34,090
కాబట్టి నేను ASCII విలువ మరియు ఫ్రీక్వెన్సీ క్రమంలో చాలు అన్ని అక్షరాలు కోసం నోడ్స్ రూపొందించినవారు.

344
00:21:34,090 --> 00:21:40,090
నేను మొదటి చెట్టు సృష్టించడానికి అనుకుంటే, ఇది 'L' మరియు 'M' తో ఉంటుంది.

345
00:21:40,090 --> 00:21:43,100
కాబట్టి యిదిగో. జత యొక్క ఫ్రీక్వెన్సీ 2 ఉంటుంది

346
00:21:43,100 --> 00:21:49,470
అది + 1 1 ఎందుకంటే, అప్పుడు తక్కువ పౌనః తదుపరి 2 'Y' మరియు 'Z' ఉన్నాయి.

347
00:21:49,470 --> 00:21:53,180
2 యొక్క పౌనఃపున్యం కలిగి - మరియు నేను ఉండటం వాటిని అన్ని కలిగి.

348
00:21:53,180 --> 00:22:00,470
తరువాత ఒక అత్యల్ప ASCII విలువ కలవి ఇవి?

349
00:22:00,470 --> 00:22:04,830
'A' మరియు 'L'. నేను కొత్త నోడ్ సృష్టించడానికి,

350
00:22:04,830 --> 00:22:09,930
మరియు చివరికి, అది 4 మరియు 2, కనుక 2 ఎడమ అన్నారు.

351
00:22:09,930 --> 00:22:12,430
మరియు మొదటి ఒకటి.

352
00:22:12,430 --> 00:22:16,060
నేను కొన్ని టెక్స్ట్ రాయాలనుకుంటున్నాను అప్పుడు ఉంటే,

353
00:22:16,060 --> 00:22:24,440
వంటి హఫ్ఫ్మన్ చెట్టు ఉపయోగించి, టెక్స్ట్ మార్చుకునేందుకు బైనరీ లో చాలా సులభం.

354
00:22:24,440 --> 00:22:30,220
నేను ఎడమ వెళ్లడం ఒక 0 మరియు కుడి కదిలే అని చెప్పుకోవాలంటే ఉదాహరణకు,, ఒక 1 ఉంది

355
00:22:30,220 --> 00:22:32,410
ఏ ప్రాతినిధ్యం అన్నారు అని?

356
00:22:32,410 --> 00:22:35,530
కాబట్టి వంటి 1, 1, కుడి, కాబట్టి కుడి,

357
00:22:35,530 --> 00:22:40,370
ఆపై కాబట్టి వదిలి 0, L ఉంటుంది, ఆపై 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
కాబట్టి 1, 0, కాబట్టి కేవలం 1, 0, 'ఒక'.

359
00:22:43,950 --> 00:22:47,540
ఆపై 0, 1, 'మేము.

360
00:22:47,540 --> 00:22:52,170
ఆపై 1, 0, 0 - ఏ.

361
00:22:52,170 --> 00:22:56,780
0, 0 'Y' అని, కాబట్టి లేజీ ఉంటుంది.

362
00:22:56,780 --> 00:23:06,060
కాబట్టి నాకు అంతే రాబ్ యొక్క స్వాధీనం అన్నారు.

363
00:23:06,060 --> 00:23:08,400
>> [రాబ్ బౌడెన్], వారం 7 stuff.

364
00:23:08,400 --> 00:23:11,390
మేము నిజంగా ఫాస్ట్ వెళ్ళి చాలా పొందారు.

365
00:23:11,390 --> 00:23:13,430
Bitwise ఆపరేటర్లు, బఫర్ ఓవర్ఫ్లో,

366
00:23:13,430 --> 00:23:16,760
CS50 లైబ్రరీ, అప్పుడు HTML, HTTP, CSS.

367
00:23:16,760 --> 00:23:20,990
15 నుండి 20 నిమిషాలు వంటి అన్ని లో.

368
00:23:20,990 --> 00:23:24,330
Bitwise ఆపరేటర్లు. మీరు తెలుసుకోవాలి వాటిలో 6 ఉన్నాయి.

369
00:23:24,330 --> 00:23:31,200
Bitwise మరియు, bitwise లేదా, చెయ్యబడిన XOR, ఎడమ షిఫ్ట్, కుడి షిఫ్ట్, మరియు.

370
00:23:31,200 --> 00:23:35,420
కుడి Shift మరియు మీరు కేవలం అసలు ఉపన్యాసంలో పాటిస్తాయి.

371
00:23:35,420 --> 00:23:40,480
మేము త్వరగా ఇక్కడ పైగా వెళ్తారో కానీ ఈ ఉనికిలో 6 అని తెలుసుకోవడం మంచిది.

372
00:23:40,480 --> 00:23:45,070
Bitwise ఆపరేటర్లు మీరు + 4 3 చేసినప్పుడు వంటి అని గుర్తుంచుకోండి.

373
00:23:45,070 --> 00:23:49,420
మీరు 3 మరియు 4 యొక్క బైనరీ వ్యవహరించే లేదు.

374
00:23:49,420 --> 00:23:56,550
Bitwise ఆపరేటర్లు తో మీరు నిజంగానే 3 మరియు 4 యొక్క వ్యక్తిగత బిట్స్ వ్యవహరించే ఉంటాయి.

375
00:23:56,550 --> 00:23:59,120
>> కాబట్టి మేము చెప్పడానికి మేము మొదటి ఒక bitwise, కాదు

376
00:23:59,120 --> 00:24:02,340
మరియు అది చిన్నబడి ఉంది.

377
00:24:02,340 --> 00:24:05,500
మీరు C లో వ్రాస్తున్నట్లయితే ఇక్కడ, మీరు రాయలేదు

378
00:24:05,500 --> 00:24:09,380
~ 11011 లేదా ఎలాగైనా వంటి, మీరు, ఇది ~ 4 ఇష్టం రాస్తుంది

379
00:24:09,380 --> 00:24:12,970
ఆపై ఇది 4 యొక్క బైనరీ ప్రాతినిధ్యం కుదుపు చేస్తుంది.

380
00:24:12,970 --> 00:24:24,800
ఇక్కడ, 1 యొక్క ~ కొన్ని ద్వియాంశ సంఖ్య 1101101 ఖచ్చితంగా 0 యొక్క అన్ని 1 యొక్క ఫ్లిప్ అన్నారు మరియు అన్ని 0 యొక్క.

381
00:24:24,800 --> 00:24:27,600
ఓహ్, ఈ తరచుగా ఉపయోగిస్తారు,

382
00:24:27,600 --> 00:24:30,830
మేము కొన్ని సంఖ్య ఆలోచన కావలసిన వంటి మరియు మేము ఒక బిట్ లో చూస్తారు, ఉంది

383
00:24:30,830 --> 00:24:35,460
బిట్స్ అన్ని వాటిలో తప్ప, 1 ఎక్కడ.

384
00:24:35,460 --> 00:24:38,560
కనుక ఇది సంఖ్య వ్యక్తం సాధారణంగా సులభం

385
00:24:38,560 --> 00:24:40,630
కేవలం ఒక్క బిట్ సెట్ కౌంటీ,

386
00:24:40,630 --> 00:24:44,650
మరియు అది ~, కాబట్టి ప్రతి ఇతర బిట్ ఒక తప్ప సెట్ పడుతుంది.

387
00:24:44,650 --> 00:24:50,300
కాబట్టి మేము ఒక బిట్ మరింత ఉపయోగించడానికి వెళుతున్న ఏమిటి.

388
00:24:50,300 --> 00:24:58,220
>> Bitwise లేదా. ఇక్కడ 2 బైనరీ సంఖ్యలు, మరియు ఈ 2 సంఖ్యలు

389
00:24:58,220 --> 00:25:00,780
వారు ప్రతి సాధ్యం ప్రాతినిధ్యం నుండి, అందంగా ప్రతినిధి

390
00:25:00,780 --> 00:25:07,290
బిట్స్ కలయిక మీరు అమలు చేయాలి కాలేదు.

391
00:25:07,290 --> 00:25:13,540
నేను ప్రతి బిట్ or'd ఉన్నప్పుడు ఇక్కడ, మేము నేరుగా డౌన్ పోల్చి చూడాలని.

392
00:25:13,540 --> 00:25:15,410
కాబట్టి ఎడమ వైపు మేము ఒక 1 మరియు ఒక 1.

393
00:25:15,410 --> 00:25:20,510
నేను bitwise చేసినప్పుడు | ఆ, నేను పొందడానికి వెళ్తున్నాను? ఒక.

394
00:25:20,510 --> 00:25:25,320
0 మరియు 1 నా ఇవ్వాలని అన్నారు | అప్పుడు bitwise? ఒక.

395
00:25:25,320 --> 00:25:27,840
Bitwise 1 మరియు 0 ఇదే, ఒకటిగా అన్నారు.

396
00:25:27,840 --> 00:25:31,880
Bitwise 0 | 0 నాకు 0 ఇవ్వాలని అన్నారు.

397
00:25:31,880 --> 00:25:37,300
0 సందర్భంలో | నేను, 0 చోటే మాత్రమే కేసు 0 లో ఉంది.

398
00:25:37,300 --> 00:25:40,020
మరియు మీరు కేవలం మీ తార్కిక ఇతరులు వంటి ఆలోచించవచ్చు.

399
00:25:40,020 --> 00:25:44,830
మీరు నిజమైన 1 మరియు తప్పుడు 0 అనుకుంటే కాబట్టి, ఇదే ఇక్కడ వర్తిస్తుంది.

400
00:25:44,830 --> 00:25:50,040
కాబట్టి నిజమైన లేదా నిజమైన పిలిచినది నిజమైన లేదా తప్పుడు నిజం.

401
00:25:50,040 --> 00:25:57,150
తప్పుడు లేదా నిజమైన పిలిచినది తప్పుడు లేదా తప్పుడు నిజానికి తప్పుడు అని మాత్రమే విషయం.

402
00:25:57,150 --> 00:26:00,100
ఇక్కడ మీరు తెలుసు ఉండాలని ఉదాహరణకు

403
00:26:00,100 --> 00:26:05,160
bitwise ఆపరేటర్లు ఉపయోగించినప్పుడు ఒక అందమైన మంచి ఉదాహరణగా.

404
00:26:05,160 --> 00:26:08,660
ఇక్కడ మేము లేదా Ox20 రాజధాని 'A',

405
00:26:08,660 --> 00:26:11,830
మరియు మేము ఏదో, రెండవ ఈ చూడండి.

406
00:26:11,830 --> 00:26:16,020
మరియు మేము లేదా చిన్న 'ఒక' Ox20 తో, మేము ఏదో పొందుటకు.

407
00:26:16,020 --> 00:26:26,750
కాబట్టి యొక్క ASCII పట్టిక పుల్ అప్ తెలియజేయండి.

408
00:26:26,750 --> 00:26:34,000
సరే. ఇక్కడ మేము 'ఒక' ఉందని -

409
00:26:34,000 --> 00:26:36,920
ఇక్కడ మేము 'ఒక' 65 దశాంశ కలిగి.

410
00:26:36,920 --> 00:26:45,120
కానీ నేను Ox41 ఇది హెక్సాడెసిమల్, తో వెళ్తారో.

411
00:26:45,120 --> 00:26:48,280
ప్రెట్టీ ఖచ్చితంగా మేము తరగతి లో చూశాడు. మనం తరగతి చూశాడు అనుకుంటున్నాను

412
00:26:48,280 --> 00:26:52,730
ఇది హెక్సాడెసిమల్ నుండి బైనరీ మార్చేందుకు అందంగా సులభం.

413
00:26:52,730 --> 00:26:55,280
ఇక్కడ, నేను బైనరీ లోకి 4 చాలు అనుకుంటే,

414
00:26:55,280 --> 00:26:59,550
కేవలం 0100 చేస్తాడు.

415
00:26:59,550 --> 00:27:03,620
ఈ 1 స్థానాన్ని, 2 యొక్క స్థానంలో, 4 యొక్క ప్రదేశం, ఈ 4 ఉంటుంది.

416
00:27:03,620 --> 00:27:08,550
అప్పుడు నేను 0001 మాత్రం ఇది బైనరీ, లోకి 1 విభజించబడింది.

417
00:27:08,550 --> 00:27:14,280
కాబట్టి ఈ బైనరీ లో 'ఒక' యొక్క ప్రాతినిధ్యం అన్నారు.

418
00:27:14,280 --> 00:27:22,720
చిన్న 'ఒక', అది ఇప్పుడు Ox61 చేస్తాడు తీసుకొని,

419
00:27:22,720 --> 00:27:27,050
దాని బైనరీ ఈ విభజన పేరు,, ఒక 6 -

420
00:27:27,050 --> 00:27:37,830
యొక్క దీన్ని లెట్ - ఏ eraser ఉంది? Eraser.

421
00:27:37,830 --> 00:27:48,220
Ox61. కాబట్టి బైనరీ లోకి 6 విభజన + 4 + 2 + 0 0 అన్నారు.

422
00:27:48,220 --> 00:27:54,610
మరియు విభజన 1 0001 అన్నారు.

423
00:27:54,610 --> 00:27:56,520
, ఈ 2 మధ్య వ్యత్యాసం చూడటం

424
00:27:56,520 --> 00:28:04,250
మేము ఒక చిన్న మరియు పెద్ద అక్షరం 'A' మధ్య తేడా ఈ బిట్ ఉందని.

425
00:28:04,250 --> 00:28:11,810
సరే - కాబట్టి తిరిగి ఇక్కడ వస్తున్న.

426
00:28:11,810 --> 00:28:15,920
మేము బిట్ Ox20 ఉంది ఏమి చూడండి అయితే,, ఇక్కడ తిరిగి వచ్చే

427
00:28:15,920 --> 00:28:22,210
దాని బైనరీ లోకి కాబట్టి విభజన Ox20,

428
00:28:22,210 --> 00:28:27,310
0010, 0000 ఉంది.

429
00:28:27,310 --> 00:28:33,470
Ox20, సెట్ మాత్రమే బిట్, మేము సంబంధించిన ఆ ఈ బిట్ ఉంది

430
00:28:33,470 --> 00:28:38,210
అక్షరాలు మరియు చిన్న 'ఒక' మధ్య మార్పిడి తో.

431
00:28:38,210 --> 00:28:47,610
ఈ ఒక, 'ఒక' ఇది నేను లేదా 'ఒక',,

432
00:28:47,610 --> 00:28:50,580
నేను లేదా Ox20 తో 'ఒక',

433
00:28:50,580 --> 00:28:53,490
నేను పొందడానికి వెళ్తున్నాను?

434
00:28:53,490 --> 00:28:58,960
[స్టూడెంట్, వినబడని] >> చిన్న 'ఒక', ఇది ఒక 1 ఈ బిట్ కుదుపు వెళుతున్న ఎందుకంటే.

435
00:28:58,960 --> 00:29:04,170
మరియు నేను లేదా 'ఒక' Ox20 తో, నేను పొందడానికి వెళ్తున్నాను?

436
00:29:04,170 --> 00:29:08,780
ఒక చిన్న, ఎందుకంటే కేవలం oring 'ఒక' Ox20 తో,

437
00:29:08,780 --> 00:29:14,580
నేను ఒక 1 ఈ బిట్ oring వెళుతున్న ఇది పట్టింపు లేదు కాబట్టి, ఇప్పటికే ఒక 1 ఉంది.

438
00:29:14,580 --> 00:29:17,960
మేము 'ఒక' మరియు 'ఒక' పొందండి.

439
00:29:17,960 --> 00:29:24,820
>> Bitwise మరియు. మళ్లీ, మేము మా తార్కిక మరియు ప్రతిరూపమని ఈ యొక్క ఆలోచించవచ్చు.

440
00:29:24,820 --> 00:29:28,180
ఎడమవైపు మేము నిజమైన & నిజమైన కలిగి.

441
00:29:28,180 --> 00:29:31,160
ఇది, నిజమైన చేస్తాడు, మరియు కేసులు అన్ని కోసం ఉంది

442
00:29:31,160 --> 00:29:36,270
, తప్పుడు & నిజమైన లేదా నిజమైన & తప్పుడు, లేదా తప్పుడు & తప్పుడు

443
00:29:36,270 --> 00:29:38,550
ఆ ఊహలు నిజమైన.

444
00:29:38,550 --> 00:29:44,170
కాబట్టి మనం పొందడానికి ముగుస్తుంది 1000 ఉంది.

445
00:29:44,170 --> 00:29:48,830
కాబట్టి ఇప్పుడు, ఇక్కడ, ఇక్కడ నేను నమ్మదగిన bitwise కాదు ఉపయోగించిన పేరు ఉంది,

446
00:29:48,830 --> 00:29:52,230
మేము Ox20 కలిగి ఉన్న.

447
00:29:52,230 --> 00:29:54,350
కాబట్టి ఈ Ox20 ఉంది.

448
00:29:54,350 --> 00:29:59,570
ఇప్పుడు నేను మీరు ఏమి, bitwise Ox20 యొక్క ~.

449
00:29:59,570 --> 00:30:03,600
ఆ చిన్నబడి అన్నారు.

450
00:30:03,600 --> 00:30:09,330
నేను 1101, 1111 కలిగి.

451
00:30:09,330 --> 00:30:18,940
కాబట్టి 'ఒక' ~ Ox20 నాకు ఏమి ఇవ్వాలని అన్నారు తో anded?

452
00:30:18,940 --> 00:30:22,430
మేము నిజంగా గురించి ఆలోచించడానికి మాత్రమే బిట్, ఈ ఒకటి

453
00:30:22,430 --> 00:30:26,020
నుండి, ఈ బిట్స్ అన్ని 1 కు సెట్ ఉంటే,

454
00:30:26,020 --> 00:30:29,000
అప్పుడు మేము ఖచ్చితంగా 'ఒక' ఉంది పొందడానికి వెళుతున్న,

455
00:30:29,000 --> 00:30:31,260
తప్ప, బహుశా, ఈ బిట్ ఉంది.

456
00:30:31,260 --> 00:30:34,460
ఇది ఒక 1 ఉంది, ఇప్పుడు అది, ఒక 0 సెట్ చేస్తాడు ఎందుకంటే

457
00:30:34,460 --> 00:30:39,810
ఈ ఏమైనా ఈ 0 అన్నారు తో anded ఎందుకంటే.

458
00:30:39,810 --> 00:30:43,280
కాబట్టి 'ఒక' ~ Ox20 నాకు ఇవ్వాలని అన్నారు & ఏమిటి?

459
00:30:43,280 --> 00:30:48,200
[స్టూడెంట్స్ సమాధానం, వినబడని] >> మరియు 'ఒక' మరియు ఏ - ఇది 'A' ఉంది.

460
00:30:48,200 --> 00:30:52,170
మరియు 'ఒక' & ~ Ox20 నాకు ఇవ్వాలని అన్నారు ఏమిటి?

461
00:30:52,170 --> 00:30:56,720
'ఎ' ఈ ప్రస్తుతం ఒక 1 ఎందుకంటే.

462
00:30:56,720 --> 00:30:59,570
ఈ 0 తో Anding, ఇది ఒక 0 సిధ్ధంగా ఉంటుంది

463
00:30:59,570 --> 00:31:02,530
మరియు ఇప్పుడు మేము ఒక 'ఒక' ను చూడాలని.

464
00:31:02,530 --> 00:31:06,600
>> రెండు ', ఒక' మరియు ఈ రకమైన గత కానీ కనీసం,

465
00:31:06,600 --> 00:31:10,830
మేము చెయ్యబడిన XOR కలిగి. ఇది చాలా వంటిది లేదా,

466
00:31:10,830 --> 00:31:14,400
ఇది ప్రత్యేకంగా అర్థం లేదా మినహా.

467
00:31:14,400 --> 00:31:18,420
ఈ మీరు సాధారణంగా లేదా వాస్తవ ప్రపంచంలో యొక్క ఏమనుకుంటున్నారో వంటిది.

468
00:31:18,420 --> 00:31:23,190
కాబట్టి మీరు 'x' లేదా 'Y', కానీ రొండు.

469
00:31:23,190 --> 00:31:28,700
ఇక్కడ ^ 1 1 0 అన్నారు.

470
00:31:28,700 --> 00:31:33,650
నిజమైన, ఈ - ఇది తార్కిక నిజమైన మరియు తప్పుడు తో అదే పని లేదు

471
00:31:33,650 --> 00:31:37,150
, bitwise & మరియు లేదా వంటి

472
00:31:37,150 --> 00:31:40,100
కానీ నిజమైన ^ నిజమైన FALSE.

473
00:31:40,100 --> 00:31:44,810
వాటిని మాత్రమే ఒక నిజమైన ఉంటే మేము మాత్రమే నిజమైన తిరిగి తెచ్చుకున్నాయి.

474
00:31:44,810 --> 00:31:50,950
కాబట్టి ^ 1 1 0. ఏ ^ 1 0 గురించి?

475
00:31:50,950 --> 00:31:56,010
1 ఉంది. ^ 0 1 ^ 0 0 0, 1 ఉంది.

476
00:31:56,010 --> 00:32:03,890
కాబట్టి అన్ని పరిస్థితులలో, 0 bitwise ఏదో 0 0 అన్నారు.

477
00:32:03,890 --> 00:32:10,270
1 bitwise ఏదో 0 లేదా 0 bitwise 1,

478
00:32:10,270 --> 00:32:14,660
అది ఉంటే | లేదా ^, ఇది ఒక 1 ఉంటాం, మరియు అది, అయితే అది 0 ఉంటాం.

479
00:32:14,660 --> 00:32:20,850
మరియు 1 bitwise 1 1 లేనిచోట మాత్రమే కేసు ప్రత్యేక లేదా తో ఉంది.

480
00:32:20,850 --> 00:32:24,580
ఆ 0110 ఉంది.

481
00:32:24,580 --> 00:32:36,520
ఇక్కడ ఇప్పుడు, చెయ్యబడిన XOR ఉపయోగించి - కాబట్టి మేము తిరిగి 20 వద్ద ఉన్నారు.

482
00:32:36,520 --> 00:32:43,480
'ఒక' ^ Ox20 మేము పోలుస్తున్నారు ఈ 2 బిట్స్ ఉంది.

483
00:32:43,480 --> 00:32:50,020
కాబట్టి ఒక 1 ^ 0 నాకు ఒక ఏమి ఇవ్వాలని అన్నారు? ఒక ఒక.

484
00:32:50,020 --> 00:32:58,430
'ఒక' ^ Ox20 నాకు ఇవ్వాలని అన్నారు? ఒక చిన్న.

485
00:32:58,430 --> 00:33:04,010
'ఒక' ^ Ox20 నాకు ఇవ్వాలని అన్నారు? రాజధాని A.

486
00:33:04,010 --> 00:33:09,310
ఈ చేయడం ఏమైనా, Ox20 ఈ XORing

487
00:33:09,310 --> 00:33:15,380
గంగారావు బిట్ సంసార వేగంగా కదలటం ఉంది.

488
00:33:15,380 --> 00:33:21,240
ఈ ఒక 0 అయితే, అది ఇప్పుడు ఒక 1 మారింది వెళుతున్న.

489
00:33:21,240 --> 00:33:26,160
ఈ ఒక 1 నుండి, ^ 1 1 0.

490
00:33:26,160 --> 00:33:33,280
మా 'ఒక' 'ఒక' మారింది, మరియు మా 'ఒక' 'ఒక' మారింది.

491
00:33:33,280 --> 00:33:36,910
కాబట్టి చెయ్యబడిన XOR ఒకవేళ వేగంగా కదలటం ఒక నిజంగా మార్గమే.

492
00:33:36,910 --> 00:33:39,960
మీరు అక్షరాలు ఒక స్ట్రింగ్ పైగా iterate మీరు

493
00:33:39,960 --> 00:33:44,330
మరియు ప్రతి పాత్ర విషయంలో ప్రత్యామ్నాయ,

494
00:33:44,330 --> 00:33:50,680
Ox20 మీకు చెయ్యబడిన XOR ప్రతిదీ.

495
00:33:50,680 --> 00:33:55,220
>> ఇప్పుడు మేము తెలీదు. ఎడమ షిఫ్ట్ కేవలం, ప్రాథమికంగా, అన్నారు

496
00:33:55,220 --> 00:34:01,250
లోకి, లేదా ఎడమ సంఖ్యల అన్ని పుష్, మరియు వాటిని వెనుక 0 యొక్క ఇన్సర్ట్.

497
00:34:01,250 --> 00:34:05,550
కాబట్టి ఇక్కడ 00001101 కలిగి.

498
00:34:05,550 --> 00:34:08,560
మేము, కుడి నుండి 3 0 యొక్క లో పుష్ చూడాలని

499
00:34:08,560 --> 00:34:13,580
మరియు మేము 01101000 పొందండి.

500
00:34:13,580 --> 00:34:16,380
Nonbinary పరంగా,

501
00:34:16,380 --> 00:34:24,699
మేము నిజంగా 13 ఎడమ మార్చారు 3 తో, మాకు 104 ఇస్తుంది వ్యవహరించే చేసే చూడండి.

502
00:34:24,699 --> 00:34:32,530
కాబట్టి ఎడమ బదిలీ, మేము ఇక్కడ చూడండి, x << y ప్రాథమికంగా x * 2 ^ y ఉంది.

503
00:34:32,530 --> 00:34:40,139
^ 3 13 * 2, ^ 3 2 కాబట్టి * 8 13 104 ఉంది, 8.

504
00:34:40,139 --> 00:34:45,679
మీరు సాధారణంగా బైనరీ, ఎలా ప్రతి అంకెల, గురించి అనుకుంటే

505
00:34:45,679 --> 00:34:49,530
మేము కుడి నుండి ప్రారంభం, అప్పుడు అది 1 యొక్క ప్రదేశం, అప్పుడు 2 యొక్క స్థానంలో, 4 యొక్క స్థానం.

506
00:34:49,530 --> 00:34:51,330
కాబట్టి కుడి నుండి 0 యొక్క మోపడం ద్వారా,

507
00:34:51,330 --> 00:34:55,080
మేము, 8 యొక్క స్థానానికి 4 యొక్క సమకూరాయి ఆ విషయాలు నెట్టడం

508
00:34:55,080 --> 00:34:57,920
మరియు 16 యొక్క స్థానానికి 8 యొక్క సమకూరాయి ఆ విషయాలు.

509
00:34:57,920 --> 00:35:01,280
ప్రతి మార్పు కేవలం 2 ద్వారా గుణిస్తారు. అవును?

510
00:35:01,280 --> 00:35:05,210
మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే [స్టూడెంట్] ఏం జరుగుతుందో?

511
00:35:05,210 --> 00:35:10,790
[బౌడెన్] మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే మీరు అంకెలు కోల్పోతుంది.

512
00:35:10,790 --> 00:35:15,410
అనివార్యంగా, అదే విషయం. వంటి, పూర్ణ మాత్రమే 32 బిట్స్ ఉంటాయి,

513
00:35:15,410 --> 00:35:20,750
మీరు 2 నిజంగా పెద్ద పూర్ణాంకాల జోడిస్తే అంతేకాదు, ఇది ఒక పూర్ణ అధిగమించడంలో లేదు.

514
00:35:20,750 --> 00:35:23,660
కనుక ఇది ఇక్కడ అదే విషయం. మీరు 5 ద్వారా మార్చబడుతుంది ఉంటే,

515
00:35:23,660 --> 00:35:25,650
మేము ఒక కోల్పోతుంది.

516
00:35:25,650 --> 00:35:28,820
మరియు ఆ ", సుమారు" నేను కుట్టినది రకంగా

517
00:35:28,820 --> 00:35:37,470
మీరు చాలా దూరం మార్చేందుకు, మీరు బిట్స్ కోల్పోతారు పేరు.

518
00:35:37,470 --> 00:35:39,830
>> కుడి షిఫ్ట్ సరసన అన్నారు,

519
00:35:39,830 --> 00:35:43,090
మేము, ముగింపు ఆఫ్ 0 యొక్క బలంగా త్రోయు వెళుతున్న

520
00:35:43,090 --> 00:35:48,400
మరియు ఏవండీ, ఎడమ నుండి 0 యొక్క పూరించండి.

521
00:35:48,400 --> 00:35:52,910
కాబట్టి ఈ చేయడం, ప్రధానంగా మేము ఇప్పటికే చేసిన విపర్యయ చేస్తున్నారు.

522
00:35:52,910 --> 00:35:57,780
మరియు మేము, కుడి మూడు 0 యొక్క కేవలం ఆఫ్ పడిపోయిన ఆ చూడండి

523
00:35:57,780 --> 00:36:02,020
మరియు మేము కుడి 1101 అన్ని మార్గం పిలుపునిస్తున్నారు.

524
00:36:02,020 --> 00:36:08,380
ఈ సమర్థవంతంగా, x / 2 ^ y, ఇది, 104 >> 3 చేస్తోంది.

525
00:36:08,380 --> 00:36:11,200
కాబట్టి ఇప్పుడు, ఇక్కడ, అది ఇదే ఆలోచన.

526
00:36:11,200 --> 00:36:18,720
ఎందుకు అది సుమారు x / 2 ^ y, మరియు నిజానికి x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
నేను 4 ద్వారా మార్చబడుతుంది ఉంటే, నేను ఒక 1 కోల్పోయారు ఉండేది ఎందుకంటే.

528
00:36:22,240 --> 00:36:25,950
సాధారణంగా, కేవలం సాధారణంగా పూర్ణాంక విభాగంలో ఏ మీరు అనుకుంటున్నారో, అనుకుంటున్నాను.

529
00:36:25,950 --> 00:36:31,070
కాబట్టి, 5/2 వంటి 2. ఇది 2.5 కాదు.

530
00:36:31,070 --> 00:36:35,000
ఇది ఇక్కడ అదే ఆలోచన. మేము 2 విభజించడానికి, చేసినప్పుడు

531
00:36:35,000 --> 00:36:39,910
మేము మార్గం వెంట బేసి బిట్స్ కోల్పోతారు.

532
00:36:39,910 --> 00:36:43,870
కాబట్టి ఇప్పుడు - ఆ bitwise కోసం ఇది. మీరు తెలుసుకోవాలి అన్ని ఉంది.

533
00:36:43,870 --> 00:36:46,340
మేము తరగతి లో చూసిన ఈ నుంచి,

534
00:36:46,340 --> 00:36:49,340
వంటి బిట్ ముసుగు, bitwise ఆపరేటర్లు పనికొచ్చే

535
00:36:49,340 --> 00:36:53,220
లేదా మీరు బిట్ ముసుగులు కోసం వాటిని ఉపయోగించే.

536
00:36:53,220 --> 00:36:58,620
పెద్ద అక్షరాలు మరియు చిన్న అక్షరాలు, మార్పిడులు ఒక అందమైన ప్రాధమిక ఉదాహరణ.

537
00:36:58,620 --> 00:37:01,640
>> సరే, ఓవర్ఫ్లో దాడులు స్వీకరించేందుకు.

538
00:37:01,640 --> 00:37:05,110
ఎవరైనా ఈ ఫంక్షన్ తో తప్పు ఏమి గుర్తు?

539
00:37:05,110 --> 00:37:10,140
మేము 12 బైట్లు యొక్క వ్యూహం, 12 అక్షరాలు, డిక్లేర్డ్ గమనించండి

540
00:37:10,140 --> 00:37:18,510
మరియు తర్వాత మేము 12 అక్షరాలు మొత్తం స్ట్రింగ్ బార్ మా బఫర్ లోకి కాపీ.

541
00:37:18,510 --> 00:37:25,080
కాబట్టి సమస్య ఇక్కడ ఏముంది?

542
00:37:25,080 --> 00:37:32,270
ఎందుకు 12 - మేజిక్ సంఖ్య 12 వెంటనే అందంగా చాలా వంటి పాప్ ఉండాలి?

543
00:37:32,270 --> 00:37:35,050
బార్ కంటే ఎక్కువ 12 అక్షరాలు ఉండాలి ఏమి ఉంటే?

544
00:37:35,050 --> 00:37:41,200
ఏ బార్ అక్షరాలను మిలియన్ల ఉంటే?

545
00:37:41,200 --> 00:37:46,010
ఇక్కడ సమస్య memcpy ఉంది. బార్ దీర్ఘకాలం, ఉంటే

546
00:37:46,010 --> 00:37:50,330
ఇది పూర్తిగా ఉంటుంది - 'సి', 'సి' ఇది కేవలం 12 అక్షరాలు అని పట్టించుకోరు;

547
00:37:50,330 --> 00:37:53,280
'సి' ఇది అనేక బైట్లు సరిపోవు పట్టించుకోరు.

548
00:37:53,280 --> 00:37:58,250
ఇది కేవలం పూర్తిగా చార్ తిరిగి రాస్తుంది, మేము అది కోసం కేటాయించింది చేసిన 12 బైట్లు,

549
00:37:58,250 --> 00:38:01,830
మరియు మెమరీ లో గత అంశం నిజానికి ఆ బఫర్ చెందిన లేదు

550
00:38:01,830 --> 00:38:06,520
సంసార స్ట్రింగ్ బార్ తో.

551
00:38:06,520 --> 00:38:09,780
ఈ మేము తరగతి లో చూసింది చిత్రం ఉంది

552
00:38:09,780 --> 00:38:12,220
మేము మా స్టాక్ పెరుగుతూ ఉంటుంది.

553
00:38:12,220 --> 00:38:16,040
మీరు ఈ చిత్రాలు ఉపయోగిస్తారు లేదా మళ్ళీ వాటిని జలవివాదం చేయాలి.

554
00:38:16,040 --> 00:38:21,260
మేము మా స్టాక్ పెరుగుతూ కలిగి, మెమరీ చిరునామాలను ఎగువన 0 వద్ద మొదలు

555
00:38:21,260 --> 00:38:26,270
మరియు దిగువన 4 బిలియన్ ఇష్టం డౌన్ పెరుగుతాయి.

556
00:38:26,270 --> 00:38:28,820
మేము, ఎక్కడో మెమరీలో మా శ్రేణి 'సి' కలిగి

557
00:38:28,820 --> 00:38:32,260
అప్పుడు మేము అది కింద బార్ మా పాయింటర్ కలిగి,

558
00:38:32,260 --> 00:38:38,720
మరియు తర్వాత మేము ఈ సేవ్ ఫ్రేమ్ మా తిరిగి చిరునామా లో పాయింటర్ మరియు మా మాతృ రొటీన్ యొక్క స్టాక్.

559
00:38:38,720 --> 00:38:40,800
తిరిగి చిరునామా ఏమిటి మర్చిపోయారా?

560
00:38:40,800 --> 00:38:45,360
ప్రధాన ఒక ఫంక్షన్ కాల్స్ బార్, ఒక ఫంక్షన్ foo కాల్స్ అది, ఉంది

561
00:38:45,360 --> 00:38:48,100
అనివార్యంగా, తిరిగి బార్.

562
00:38:48,100 --> 00:38:52,610
కాబట్టి బార్ తిరిగి, వారు అది అని foo తిరిగి వెళుతున్న తెలుసు అవసరం.

563
00:38:52,610 --> 00:39:01,360
కాబట్టి తిరిగి చిరునామా ఉన్నప్పుడు తిరిగి తిరిగి అది ఉంది ఫంక్షన్ యొక్క చిరునామా.

564
00:39:01,360 --> 00:39:05,830
, సౌకర్యవంతంగా, ఎందుకంటే బఫర్ ఓవర్ఫ్లో దాడులు కోసం ముఖ్యమైన కారణం

565
00:39:05,830 --> 00:39:09,580
హ్యాకర్లు ఆ తిరిగి చిరునామా మార్చాలనుకుంటున్న.

566
00:39:09,580 --> 00:39:14,950
బదులుగా తిరిగి foo వెళ్లి, నేను తిరిగి హ్యాకర్ నాకు తిరిగి వెళ్ళడానికి తనకు ఎక్కడ వెళ్ళండి వెళుతున్న.

567
00:39:14,950 --> 00:39:17,760
మరియు, సౌకర్యవంతంగా, హ్యాకర్ తరచుగా తిరిగి వెళ్ళడానికి అనుకుంటుంది

568
00:39:17,760 --> 00:39:22,400
మేము అసలు ఉందని బఫర్ ప్రారంభంలో ఉంది.

569
00:39:22,400 --> 00:39:26,170
కాబట్టి, మళ్ళీ, లిటిల్ భారత గమనించవచ్చు.

570
00:39:26,170 --> 00:39:28,490
ఉపకరణం ఒక లిటిల్ భారత వ్యవస్థ యొక్క ఒక ఉదాహరణ,

571
00:39:28,490 --> 00:39:34,140
కాబట్టి పూర్ణాంకం లేదా ఒక పాయింటర్ తిరిగి బైట్లు తో నిల్వ.

572
00:39:34,140 --> 00:39:38,980
కాబట్టి ఇక్కడ చూడండి - ఈ ఉంది? అవును.

573
00:39:38,980 --> 00:39:45,660
మేము Ox80, OxC0, Ox35, OxO8 చూడండి.

574
00:39:45,660 --> 00:39:48,250
హెక్సాడెసిమల్ మర్చిపోయారా?

575
00:39:48,250 --> 00:39:50,640
మేము, లిటిల్ భారత లో హెక్సాడెసిమల్ రివర్స్ లేదు

576
00:39:50,640 --> 00:39:56,110
2 హెక్సాడెసిమల్ ఒక బైట్ తయారు, మరియు మేము బైట్లు రివర్స్ ఎందుకంటే.

577
00:39:56,110 --> 00:40:00,300
ఎందుకు మేము, వంటి, 80530CO8 నిల్వ లేదు పేర్కొంది.

578
00:40:00,300 --> 00:40:07,520
మేము కుడి నుండి ప్రారంభించబడుతుంది,, బదులుగా, 2 అంకెలు ప్రతి జంట నిల్వ.

579
00:40:07,520 --> 00:40:10,880
ఆ చిరునామా ప్రారంభానికి చిరునామా సూచిస్తుంది

580
00:40:10,880 --> 00:40:15,190
మేము నిజంగా మొదటి స్థానంలో లోకి కాపీ కోరుకున్నాడు మా బఫర్ యొక్క.

581
00:40:15,190 --> 00:40:19,230
ఉపయోగం గల కారణం ఏమి ఎందుకంటే, దాడి

582
00:40:19,230 --> 00:40:24,100
బదులుగా కేవలం స్ట్రింగ్ కలిగి, జరిగిన

583
00:40:24,100 --> 00:40:27,060
వంటి ఒక ప్రమాదకరం స్ట్రింగ్, వారి పేరు లేదా ఏదో,

584
00:40:27,060 --> 00:40:33,900
ఏం, బదులుగా, ఆ స్ట్రింగ్ కొన్ని ఏకపక్ష కోడ్ ఉన్నారు

585
00:40:33,900 --> 00:40:38,610
వారు అది ఏది కోరుకుంటే చేశాడు?

586
00:40:38,610 --> 00:40:45,630
కాబట్టి వారు కాలేదు - నేను ఏదైనా చల్లని కోడ్ భావిస్తారు కాదు.

587
00:40:45,630 --> 00:40:47,780
ఇది అయితే, ఏదైనా కావచ్చు. ఏ ఘోరమైన కోడ్.

588
00:40:47,780 --> 00:40:51,440
వారు అనుకుంటే, వారు కేవలం seg లోపాలు వద్ద ఏదో, అయితే ఆ అర్ధం ఉంటుంది.

589
00:40:51,440 --> 00:40:54,950
వారు సాధారణంగా మీ సిస్టమ్ హాక్ చేస్తున్నాయి.

590
00:40:54,950 --> 00:40:59,930
సరే >>. CS50 లైబ్రరీ.

591
00:40:59,930 --> 00:41:04,800
ఈ, ప్రధానంగా, GetInt, GetString, అన్ని విధులు మేము మీరు కోసం అందించబడింది.

592
00:41:04,800 --> 00:41:10,630
కాబట్టి మేము చార్ * స్ట్రింగ్ కలిగి, మరియు మేము దూరంగా పేల్చి సంగ్రహణం ఉంది

593
00:41:10,630 --> 00:41:12,450
సెమిస్టర్ సమయంలో ఏదో ఒక సమయంలో.

594
00:41:12,450 --> 00:41:18,220
ఒక స్ట్రింగ్ కేవలం అక్షరాల యొక్క శ్రేణి అని గుర్తుంచుకోండి.

595
00:41:18,220 --> 00:41:23,240
కాబట్టి ఇక్కడ getString ఒక కుదించబడిన చూడండి.

596
00:41:23,240 --> 00:41:25,920
మీరు నిజానికి అమలు ఎలా గుర్తు, తిరిగి చూడాలని.

597
00:41:25,920 --> 00:41:30,950
కీ వివరాలు ఉంటాయి, మేము ఒక సమయంలో ఒక పాత్ర లో పొందండి గమనించవచ్చు

598
00:41:30,950 --> 00:41:34,570
కేవలం మాకు కీబోర్డ్ వద్ద టైప్ పోలియున్నది లో నుంచి.

599
00:41:34,570 --> 00:41:37,890
కాబట్టి ఒక సమయంలో ఒకే పాత్ర, మరియు మేము చాలా అక్షరాలు వస్తే,

600
00:41:37,890 --> 00:41:40,580
కాబట్టి n + 1 సామర్థ్యం కంటే ఎక్కువ ఉంటే,

601
00:41:40,580 --> 00:41:44,140
అప్పుడు మేము మా బఫర్ యొక్క సామర్థ్యాన్ని అవసరం.

602
00:41:44,140 --> 00:41:47,780
కాబట్టి మేము ఎలా స్ట్రింగ్ యొక్క పరిమాణం రెట్టింపు చేస్తున్నారు.

603
00:41:47,780 --> 00:41:51,840
మరియు ఆ వెళ్ళి ఉంచుతుంది; మేము మా బఫర్ లోకి పాత్ర ఇన్సర్ట్

604
00:41:51,840 --> 00:41:56,220
మేము ఒక కొత్త లైన్ లేదా ఫైలు లేదా వస్తువు యొక్క ముగింపు అందుకుంటారు వరకు,

605
00:41:56,220 --> 00:41:59,380
ఈ సందర్భంలో, మేము స్ట్రింగ్ మరియు నిజ getString పూర్తి చేసిన

606
00:41:59,380 --> 00:42:05,120
మేము చాలా మెమరీ కేటాయించింది ఉంటే అది తిరిగి వెళ్లి ఒక బిట్ ముడుచుకునే చేస్తాము వంటి, మెమరీ తగ్గిస్తుంది.

607
00:42:05,120 --> 00:42:08,830
కాబట్టి మేము ఆ చూపవద్దు, కానీ ప్రధాన ఆలోచన

608
00:42:08,830 --> 00:42:11,960
ఇది ఒక సమయంలో ఒకే పాత్ర చదవడానికి కలిగి.

609
00:42:11,960 --> 00:42:17,140
ఇది కేవలం ఒకేసారి ఒక మొత్తం విషయం లో చదువలేదు

610
00:42:17,140 --> 00:42:19,550
వారి బఫర్ ఒక నిర్దిష్ట పరిమాణం యొక్క ఎందుకంటే.

611
00:42:19,550 --> 00:42:26,590
ఇది బఫర్ లోకి ఇన్సర్ట్ ప్రయత్నిస్తుంది స్ట్రింగ్ చాలా పెద్దది చేస్తే, అది ఓవర్ఫ్లో అని.

612
00:42:26,590 --> 00:42:28,940
కాబట్టి ఇక్కడ నిరోధించే ఒకే పాత్ర లో చదవడం ద్వారా

613
00:42:28,940 --> 00:42:33,750
ఒక సమయంలో మరియు మేము అవసరం చేసినప్పుడు పెరుగుతున్న.

614
00:42:33,750 --> 00:42:40,270
కాబట్టి GetInt మరియు ఇతర CS50 లైబ్రరీ విధులు getString ఉపయోగించడానికి ఉంటాయి

615
00:42:40,270 --> 00:42:42,310
వారి అమలు లో.

616
00:42:42,310 --> 00:42:45,370
నేను ఇక్కడ ముఖ్యమైన విషయాలు హైలైట్.

617
00:42:45,370 --> 00:42:49,460
ఇది ఒక స్ట్రింగ్ పొందడానికి తెలుసా.

618
00:42:49,460 --> 00:42:51,710
GetString మెమరీ తిరిగి విఫలమైంది,

619
00:42:51,710 --> 00:42:54,270
getString ఏదో mallocs గుర్తుంచుకోవాలి, కాబట్టి మీరు getString కాల్ చేసినప్పుడు

620
00:42:54,270 --> 00:42:57,820
మీరు (అపారదర్శక) మీరు వచ్చింది అని స్ట్రింగ్ విడిపించేందుకు లేదు.

621
00:42:57,820 --> 00:43:02,870
ఇది ఏదో malloc విఫలమైంది ఉంటే ఇక్కడ, మేము ఒక జెండాగా INT_MAX తిరిగి,

622
00:43:02,870 --> 00:43:05,650
హే, మేము నిజంగా ఒక పూర్ణ సంఖ్య చెయ్యలేకపోయాము.

623
00:43:05,650 --> 00:43:10,830
మీరు నేను మీరు తిరిగి సంసార విస్మరించు లేదా ఉండాలి

624
00:43:10,830 --> 00:43:15,540
మీరు చెల్లుబాటు అయ్యే ఇన్పుట్ ఈ చికిత్స.

625
00:43:15,540 --> 00:43:21,360
చివరిగా, విజయం సాధించాడు ఊహిస్తూ, మేము, ప్రత్యేక జెండా sscanf ఉపయోగించడానికి

626
00:43:21,360 --> 00:43:23,820
అంటే, మొదటి పూర్ణాంకం మ్యాచ్,

627
00:43:23,820 --> 00:43:26,770
ఆ పూర్ణాంక తర్వాత ఏ అక్షరాలు మ్యాచ్.

628
00:43:26,770 --> 00:43:29,070
కాబట్టి మేము అది 1 సమానంగా కావలసిన గమనించవచ్చు.

629
00:43:29,070 --> 00:43:32,940
కాబట్టి sscanf తిరిగి విజయవంతంగా ఎన్ని మ్యాచ్ల చేసిన ఉంటే?

630
00:43:32,940 --> 00:43:37,010
ఇది విజయవంతంగా పూర్ణాంకం సరిపోలే ఉంటే 1 చూపిస్తుంది,

631
00:43:37,010 --> 00:43:40,890
పూర్ణాంకం సరిపోలడం లేదు ఉంటే ఇది 0 తిరిగి, మరియు అది 2 తిరిగి

632
00:43:40,890 --> 00:43:45,920
సరిపోలలేదు ఉంటే పూర్ణాంకం కొన్ని పాత్ర తరువాత.

633
00:43:45,920 --> 00:43:49,780
కాబట్టి మేము 1 ఏదైనా కానీ మ్యాచ్ ఉంటే మేము మళ్ళీ గమనించవచ్చు.

634
00:43:49,780 --> 00:43:55,230
కాబట్టి మేము ఎంటర్ చేస్తే 1, 2, 3, సి, లేదా 1, 2, 3, X,

635
00:43:55,230 --> 00:43:57,400
అప్పుడు 1, 2, 3 పూర్ణాంక నిల్వ ఉంటుంది,

636
00:43:57,400 --> 00:43:59,620
X, పాత్ర వద్ద నిల్వ చేయబడుతుంది

637
00:43:59,620 --> 00:44:06,410
మేము మాత్రమే పూర్ణాంకం కావలసిన ఎందుకంటే, sscanf 2 తిరిగి, మరియు మేము మళ్ళీ చేస్తుంది.

638
00:44:06,410 --> 00:44:09,810
>> త్వరగా HTML, HTTP, CSS యొక్క వీచే.

639
00:44:09,810 --> 00:44:15,340
హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్ వెబ్ యొక్క నిర్మాణం మరియు అర్థాలను ఉంది.

640
00:44:15,340 --> 00:44:19,960
ఇక్కడ మేము HTML టాగ్లు పేరు ఉపన్యాసం నుండి ఉదాహరణ.

641
00:44:19,960 --> 00:44:22,110
మేము తల టాగ్లు, శరీరం టాగ్లు, కలిగి

642
00:44:22,110 --> 00:44:27,770
మేము, మేము నిజంగా ఒక ప్రారంభ మరియు దగ్గరగా ట్యాగ్ లేదు పేరు ఖాళీ టాగ్ ఉదాహరణలు ఉన్నాయి

643
00:44:27,770 --> 00:44:30,820
మేము లింక్ మరియు చిత్రం కలిగి.

644
00:44:30,820 --> 00:44:38,480
ఏ ముగింపు చిత్రం ట్యాగ్ ఉంది; ట్యాగ్ చేయవలసిన ప్రతిదీ సాధించింది కేవలం ఒకే ట్యాగ్ ఉంది.

645
00:44:38,480 --> 00:44:41,950
లింక్ ఒక ఉదాహరణ; మీరు CSS లింక్ ఎలా చూస్తారు,

646
00:44:41,950 --> 00:44:45,910
స్క్రిప్ట్ మీరు ఒక బాహ్య జావాస్క్రిప్ట్ ఎలా లింక్ యొక్క ఒక ఉదాహరణ.

647
00:44:45,910 --> 00:44:53,100
ఇది HTML ఒక ప్రోగ్రామింగ్ భాష కాదు, సూటిగా ఉంది, మరియు గుర్తుంచుకోండి.

648
00:44:53,100 --> 00:44:58,250
ఇక్కడ, మీరు ఈ ఏమి చేస్తుంది ఒక రూపంలో నిర్వచించే లేదా కనీసం ఎలా గుర్తు?

649
00:44:58,250 --> 00:45:01,740
ఒక రూపం ఒక చర్య మరియు ఒక పద్ధతి ఉంది.

650
00:45:01,740 --> 00:45:06,210
మీరు మాత్రమే ఎప్పుడూ చూస్తారు పద్ధతులు GET మరియు POST ఉంటాయి.

651
00:45:06,210 --> 00:45:09,040
కాబట్టి GET విషయం URL లో ఉంచే పేరు వెర్షన్.

652
00:45:09,040 --> 00:45:11,680
ఇది URL లో పెట్టలేదు రాష్ట్రం టపా.

653
00:45:11,680 --> 00:45:18,520
బదులుగా, రూపం నుండి ఏ డేటా HTTP అభ్యర్థన లో రహస్య చేర్చబడుతుంది.

654
00:45:18,520 --> 00:45:22,390
HTTP అభ్యర్థన వెళ్ళే ఇక్కడ, చర్య నిర్వచిస్తుంది.

655
00:45:22,390 --> 00:45:27,490
ఏమైందా ఎక్కడ google.com / శోధన.

656
00:45:27,490 --> 00:45:32,890
విధానం. GET మరియు POST మధ్య తేడాలు గుర్తుంచుకోండి,

657
00:45:32,890 --> 00:45:37,200
మీరు బుక్మార్క్ ఏదో అనుకుంటే, కేవలం, ఒక ఉదాహరణగా చెప్పడానికి.

658
00:45:37,200 --> 00:45:40,660
మీరు ఒక POST URL బుక్మార్క్ చేయగలరు ఎప్పటికీ

659
00:45:40,660 --> 00:45:44,970
డేటా URL చేర్చబడలేదు ఎందుకంటే.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, ఇప్పుడు, హైపర్టెక్స్ట్ ట్రాన్స్ఫర్ ప్రోటోకాల్ ఉంది.

661
00:45:49,790 --> 00:45:54,080
హైపర్టెక్స్ట్ ట్రాన్స్ఫర్ ప్రోటోకాల్, మీరు బదిలీ ఆలోచించే

662
00:45:54,080 --> 00:45:57,710
హైపర్టెక్స్ట్ మార్కప్ లాంగ్వేజ్, మరియు అది.

663
00:45:57,710 --> 00:46:00,170
కానీ అది మీరు వెబ్ లో ఏ చిత్రాలు బదిలీ,

664
00:46:00,170 --> 00:46:05,400
మీ సంప్రదింపులన్నిటిలోనూ డౌన్ ఒక HTTP అభ్యర్థన గా మొదలు.

665
00:46:05,400 --> 00:46:10,350
కాబట్టి HTTP కేవలం వరల్డ్ వైడ్ వెబ్ యొక్క భాష.

666
00:46:10,350 --> 00:46:15,610
మరియు ఇక్కడ మీరు ఒక HTTP అభ్యర్థన ఈ రకమైన గుర్తించడానికి అవసరం.

667
00:46:15,610 --> 00:46:19,300
వైపు ఇక్కడ HTTP/1.1 ఆ సంస్కరణ చెప్పారు

668
00:46:19,300 --> 00:46:21,570
ప్రోటోకాల్ యొక్క నేను ఉపయోగించి వెబ్.

669
00:46:21,570 --> 00:46:25,770
మీరు చూస్తారు ఇది ఎల్లప్పుడూ, HTTP/1.1 చేస్తాడు.

670
00:46:25,770 --> 00:46:30,110
అప్పుడు మేము ఈ మీరు చూడండి అని, ప్రత్యామ్నాయ POST ఉండటం, GET సంపాదించెను.

671
00:46:30,110 --> 00:46:40,790
మరియు నేను సందర్శించిన ప్రయత్నిస్తోందని URL www.google.com/search?q = బ్లా, బ్లా, బ్లా ఉంది.

672
00:46:40,790 --> 00:46:44,240
కాబట్టి గుర్తు ఈ, ప్రశ్న గుర్తు q = బ్లా బ్లా బ్లా,

673
00:46:44,240 --> 00:46:49,040
ఒక రూపం సమర్పించిన అని stuff యొక్క విధమైన ఉంది.

674
00:46:49,040 --> 00:46:51,830
ఇది నాకు వెళ్ళి ఎప్పుడూ ఈ వంటి ఏదో చూస్తారు.

675
00:46:51,830 --> 00:46:54,050
మళ్ళీ, ఆ మాత్రం ప్రొటోకాల్, ప్రారంభించి,

676
00:46:54,050 --> 00:46:59,190
స్థితి కోడ్ ద్వారా. ఇక్కడ ఇది 200 సరే.

677
00:46:59,190 --> 00:47:05,060
చివరకు, నేను నిజానికి అడిగారు వెబ్ పేజీ తరువాత చేయబడుతుంది.

678
00:47:05,060 --> 00:47:08,210
సాధ్యం స్థితి కోడ్ మీరు చూడవచ్చు, మరియు మీరు వాటిని అనేక తెలుసుకోవాలి.

679
00:47:08,210 --> 00:47:12,770
200 OK మీరు బహుశా ముందు చూసిన.

680
00:47:12,770 --> 00:47:17,830
403 నిషిద్ధ, 404 దొరకలేదు, 500 అంతర్గత సర్వర్ లోపం

681
00:47:17,830 --> 00:47:22,140
మీరు ఒక వెబ్ సైట్ కు వెళ్ళి ఏదో విభజించబడింది లేదా వారి PHP కోడ్ క్రాష్ అయితే, సాధారణంగా ఉంది

682
00:47:22,140 --> 00:47:24,930
పరికరంలోని మేము అయితే పెద్ద నారింజ బాక్స్

683
00:47:24,930 --> 00:47:27,830
ఆ వస్తుంది మరియు వంటి, ఏదో తప్పు ఉంది, చెప్పారు, ఈ కోడ్ పని లేదు

684
00:47:27,830 --> 00:47:30,380
లేదా ఈ ఫంక్షన్ యొక్క చెడు.

685
00:47:30,380 --> 00:47:33,230
సాధారణంగా వెబ్సైట్లు, మీరు విధులు చెడు ఏమిటో తెలుసుకోవటం లేదు

686
00:47:33,230 --> 00:47:37,880
కాబట్టి బదులుగా వారు కేవలం మీరు 500 అంతర్గత సర్వర్ లోపాలు ఇస్తాము.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP HTTP క్రింద 1 పొర.

688
00:47:43,050 --> 00:47:47,550
ఇంటర్నెట్ వరల్డ్ వైడ్ వెబ్ వెలుపల ఉంది గుర్తుంచుకోవాలి.

689
00:47:47,550 --> 00:47:52,270
ఇలా మీరు HTTP ద్వారా పోదు ఒక ఆన్లైన్ ఉంటే,

690
00:47:52,270 --> 00:47:55,740
అది వేరే ద్వారా జరగబోతోంది - ఇది ఇప్పటికీ ఇంటర్నెట్ ఉపయోగించి,

691
00:47:55,740 --> 00:47:58,900
కానీ HTTP ఉపయోగించదు.

692
00:47:58,900 --> 00:48:02,470
HTTP TCP / IP నిర్మించబడింది ప్రోటోకాల్ యొక్క కేవలం ఒక ఉదాహరణ.

693
00:48:02,470 --> 00:48:07,820
IP వాచ్యంగా ఇంటర్నెట్ ప్రోటోకాల్ అంటే.

694
00:48:07,820 --> 00:48:11,500
ప్రతి కంప్యూటర్కు IP చిరునామా కలిగి; ఆ 4 అంకెల విషయాలు

695
00:48:11,500 --> 00:48:16,510
192.168.2.1, లేదా సంసార వంటి కేటాయి ఒక స్థానిక ఒక ఉంటుంది.

696
00:48:16,510 --> 00:48:23,390
కానీ ఒక IP చిరునామా యొక్క నమూనా ఉంది.

697
00:48:23,390 --> 00:48:29,060
కాబట్టి DNS, డొమైన్ పేరు సర్వీస్,

698
00:48:29,060 --> 00:48:33,410
ఒక వాస్తవ IP చిరునామాకు google.com వంటి విషయాలు అనువాదం ఏమిటి.

699
00:48:33,410 --> 00:48:37,700
కాబట్టి మీరు ఒక URL ఆ IP చిరునామా టైప్ ఉంటే,

700
00:48:37,700 --> 00:48:40,850
మీరు Google కు మీరు తీసుకొచ్చే, కానీ మీరు ఆ విషయాలు గుర్తుంచుకోవడం ఇవ్వలేవు.

701
00:48:40,850 --> 00:48:45,470
బదులుగా మీరు google.com గుర్తుంచుకోండి ఉంటాయి.

702
00:48:45,470 --> 00:48:51,560
మేము గత విషయం ఈ IP యొక్క TCP భాగం పోర్ట్సు, ఉంది.

703
00:48:51,560 --> 00:48:54,880
TCP ఎక్కువ చేస్తుంది. మీరు మీ బ్రౌజర్ ను కలిగి, వంటి, గురించి ఆలోచించండి.

704
00:48:54,880 --> 00:48:58,670
బహుశా మీరు కొన్ని ఇమెయిల్ అప్లికేషన్ అమలు;

705
00:48:58,670 --> 00:49:02,150
బహుశా మీరు ఇంటర్నెట్ నడుస్తున్న ఉపయోగించే కొన్ని ఇతర ప్రోగ్రామ్ను.

706
00:49:02,150 --> 00:49:05,090
వారు అన్ని ఇంటర్నెట్ యాక్సెస్ అవసరం,

707
00:49:05,090 --> 00:49:08,100
కానీ మీ కంప్యూటర్ మాత్రమే 1 వైఫై కార్డ్ లేదా సంసార ఉంది.

708
00:49:08,100 --> 00:49:10,780
కాబట్టి పోర్ట్సు మేము విభజించగలదు అని మార్గం

709
00:49:10,780 --> 00:49:13,550
ఈ అనువర్తనాల్లో ఇంటర్నెట్ ఉపయోగించడానికి చేయగలరు ఎంత.

710
00:49:13,550 --> 00:49:17,230
ప్రతి అనువర్తనం, ఇది వింటుంది చేసే 1 ప్రత్యేక పోర్ట్ గెట్స్

711
00:49:17,230 --> 00:49:19,670
మరియు డిఫాల్ట్గా, HTTP పోర్ట్ 80 ఉపయోగిస్తుంది.

712
00:49:19,670 --> 00:49:22,410
కొన్ని ఇమెయిల్ సేవలు 25 ఉపయోగించడానికి.

713
00:49:22,410 --> 00:49:24,490
తక్కువ సంఖ్య వాటిని రిజర్వు ఉంటాయి.

714
00:49:24,490 --> 00:49:29,270
మీరు సాధారణంగా మీ కోసం అధిక సంఖ్యలో వాటిని పొందడానికి చేయగలరు.

715
00:49:29,270 --> 00:49:32,010
>> CSS, క్యాస్కేడింగ్ స్టైల్ షీట్లు.

716
00:49:32,010 --> 00:49:36,030
CSS తో మేము శైలి వెబ్ పేజీలకు, కాదు HTML తో.

717
00:49:36,030 --> 00:49:38,440
మీరు మీ CSS ఉంచవచ్చు 3 స్థలాలు ఉన్నాయి.

718
00:49:38,440 --> 00:49:46,300
ఇది శైలి టాగ్లు మధ్య, లేదా ఒక ప్రత్యేక పూర్తిగా ఫైలులో ఆపై సైన్ లింక్, ఇన్లైన్ ఉంటుంది

719
00:49:46,300 --> 00:49:48,470
మరియు ఇక్కడ CSS కేవలం ఒక ఉదాహరణ.

720
00:49:48,470 --> 00:49:50,450
మీరు ఈ నమూనా గుర్తించాలి,

721
00:49:50,450 --> 00:49:54,310
మొదటి ఉదాహరణ మేము శరీరం ట్యాగ్ సరిపోలే, చేస్తున్నారు పేరు

722
00:49:54,310 --> 00:49:56,680
మరియు ఇక్కడ మేము శరీరం ట్యాగ్ కేంద్రీకృతం చేస్తున్నారు.

723
00:49:56,680 --> 00:50:00,420
రెండవది, మేము విషయం సరిపోలే ఉంటాయి

724
00:50:00,420 --> 00:50:04,740
ID ఫుటరు తో, మరియు మేము ఆ కొన్ని శైలులు దరఖాస్తు చేస్తున్నారు.

725
00:50:04,740 --> 00:50:07,310
ఎడమ ఆ ID ఫుటరు టెక్స్ట్ సర్దుబాటు గమనించండి,

726
00:50:07,310 --> 00:50:09,840
శరీరం టెక్స్ట్-సర్దుబాటు సెంటర్ అయితే.

727
00:50:09,840 --> 00:50:13,180
ఫుటరు శరీరంలోనే ఉంది.

728
00:50:13,180 --> 00:50:16,470
ఇది, బదులుగా, text-align శరీర text-align సెంటర్ చెప్పారు అయినప్పటికీ, వదిలి ఉంటుంది.

729
00:50:16,470 --> 00:50:18,880
ఇది మొత్తం కాస్కేడింగ్ భాగం.

730
00:50:18,880 --> 00:50:22,110
మీరు కలిగి - మీరు శరీరం కోసం శైలులు పేర్కొనవచ్చు,

731
00:50:22,110 --> 00:50:25,320
మరియు తర్వాత శరీరంలో విషయాలు మీరు మరింత ప్రత్యేక శైలులు పేర్కొనవచ్చు,

732
00:50:25,320 --> 00:50:28,160
మరియు విషయాలు మీరు ఆశించిన విధంగా పని.

733
00:50:28,160 --> 00:50:34,420
మరింత నిర్దిష్ట CSS specifiers ప్రాధాన్యత వహిస్తాయి.

734
00:50:34,420 --> 00:50:46,140
నేను బయటకు తియ్యి.

735
00:50:46,140 --> 00:50:49,260
>> [ఆలీ Nahm] ఒక్కరూ ఎక్కువ. నేను మీ దృష్టిని ఆకర్షించింది అని.

736
00:50:49,260 --> 00:50:53,990
నేను ఆలీ నేను నిజంగా వేగంగా PHP మరియు SQL ద్వారా వెళ్ళడానికి వెళుతున్న.

737
00:50:53,990 --> 00:51:00,310
కాబట్టి మేము ప్రారంభించవచ్చు. PHP PHP సంక్షిప్తరూపం: హైపర్టెక్స్ట్ ప్రీప్రాసెసర్.

738
00:51:00,310 --> 00:51:03,730
మీకు తెలుసు ఉండాలి మరియు ఇది ఒక సర్వర్ వైపు స్క్రిప్టింగ్ భాష,

739
00:51:03,730 --> 00:51:06,800
మరియు మేము వెబ్సైట్లు వెనుక ముగింపు కోసం దీనిని ఉపయోగిస్తారు,

740
00:51:06,800 --> 00:51:12,540
మరియు గణనలు, తెర వెనుక భాగం చాలా చేస్తుంది ఎలా.

741
00:51:12,540 --> 00:51:17,510
సింటాక్స్. ఇది C, ఆశ్చర్యం, ఆశ్చర్యం ఇష్టం లేదు.

742
00:51:17,510 --> 00:51:22,060
నేను ముందుకు తరలించడానికి కాదు - ఇది ఎల్లప్పుడూ మీరు చూడగలరు ఉంటే,, ప్రారంభం ఉంది.

743
00:51:22,060 --> 00:51:31,340
మీరు జంట కలుపులు కొత్త రకాల అవసరం చూడగలరు మరియు మీరు కూడా? Php అవసరం.

744
00:51:31,340 --> 00:51:35,780
మీరు మీ PHP టెక్స్ట్, మీ PHP కోడ్ ఫ్రేమ్ కలిగి ఎప్పుడూ ఉంది.

745
00:51:35,780 --> 00:51:39,180
కాబట్టి ఇది మీరు రకమైన మొదటి దానిపై నెలకొల్పాడు సి, ఇలా ఉంటుంది.

746
00:51:39,180 --> 00:51:42,290
మీరు దాని చుట్టూ అవసరం.

747
00:51:42,290 --> 00:51:47,610
ఇప్పుడు, ప్రధాన వాక్యనిర్మాణం అన్ని వేరియబుల్స్ $ పాత్ర ప్రారంభం అవసరం ఉంది.

748
00:51:47,610 --> 00:51:49,490
మీరు వాటిని నిర్వచించు చేసినప్పుడు అది చేయాలి; మీరు దీన్ని అవసరం

749
00:51:49,490 --> 00:51:51,860
మీరు తర్వాత వారికి సూచిస్తూ చేసినప్పుడు.

750
00:51:51,860 --> 00:51:56,510
మీరు ఎప్పుడూ $ అవసరం. ఇది చాలా చక్కని, మీ కొత్త స్నేహితుడి ఉంది.

751
00:51:56,510 --> 00:52:01,690
మీరు లేదు - సి కాకుండా, మీరు వేరియబుల్ రకం ఏ విధమైన ఉంచాలి లేదు.

752
00:52:01,690 --> 00:52:04,940
మీరు $ అవసరం అందువలన, మీరు, వంటి, ఉంచాలి లేదు

753
00:52:04,940 --> 00:52:09,470
, Int x లేదా స్ట్రింగ్ y, మొదలగునవి, మొదలగునవి.

754
00:52:09,470 --> 00:52:11,490
కాబట్టి కొద్దిగా తేడా.

755
00:52:11,490 --> 00:52:15,590
ఈ ఫలితంగా, అది PHP ఒక బలహీనంగా రకం అని అర్థం.

756
00:52:15,590 --> 00:52:19,310
PHP ఒక బలహీనంగా రకం భాష, మరియు ఇది బలహీనంగా వేరియబుల్స్ టైప్ చేసారు.

757
00:52:19,310 --> 00:52:24,020
ఇతర మాటలలో, మీరు వేరియబుల్ రకాల వివిధ రకాల మధ్య మారవచ్చు అర్థం.

758
00:52:24,020 --> 00:52:27,230
మీరు ఒక Int వంటి మీ సంఖ్య 1 నిల్వ చేయవచ్చు,

759
00:52:27,230 --> 00:52:29,650
మీరు ఒక స్ట్రింగ్ వంటి నిల్వ చేయవచ్చు, మరియు మీరు ఒక ఫ్లోట్ గా నిల్వ చేయవచ్చు,

760
00:52:29,650 --> 00:52:33,550
మరియు ఆ సంఖ్య 1 ఉంటుంది.

761
00:52:33,550 --> 00:52:36,080
మీరు వివిధ రూపాల్లో నిల్వ ఉన్నప్పటికీ,

762
00:52:36,080 --> 00:52:39,120
ఇప్పటికీ - వేరియబుల్ రకాల ఇప్పటికీ చివరికి పట్టుకొని ఉంటాయి.

763
00:52:39,120 --> 00:52:41,540
కాబట్టి మీరు ఇక్కడ చూస్తే, మీరు pset 7 నుండి గుర్తుంచుకుంటే,

764
00:52:41,540 --> 00:52:43,500
మీరు అనేక బహుశా ఈ సమస్యలను కలిగి.

765
00:52:43,500 --> 00:52:47,280
రెండు సమాన సంకేతాలు, 3 సమాన సంకేతాలు, 4 సమాన సంకేతాలు.

766
00:52:47,280 --> 00:52:49,990
సరే, ఏ 4 సమాన సంకేతాలు ఉన్నాయి, కానీ 2 మరియు 3 ఉన్నాయి.

767
00:52:49,990 --> 00:52:53,320
మీరు విలువలు తనిఖీ 2 సమాన సంకేతాలు ఉపయోగిస్తారు.

768
00:52:53,320 --> 00:52:55,830
ఇది రకాల తనిఖీ చేయవచ్చు.

769
00:52:55,830 --> 00:52:58,770
కాబట్టి మీరు మొదటి ఉదాహరణ చూడగలరు ఉంటే,

770
00:52:58,770 --> 00:53:02,210
నేను num_int == num_string కలిగి.

771
00:53:02,210 --> 00:53:06,710
కాబట్టి మీ ఉంచడానికి రెండు సాంకేతికంగా, 1,

772
00:53:06,710 --> 00:53:10,790
కానీ వారు రకాల ఉన్నాము. కానీ డబుల్ సమానం కోసం, ఇది పాస్ చేస్తాము.

773
00:53:10,790 --> 00:53:15,510
అయితే, ట్రిపుల్ సమానం కోసం, ఇది విలువ అలాగే వివిధ రకాల తనిఖీ.

774
00:53:15,510 --> 00:53:18,760
అంటే, ఇది ఇక్కడ రెండవ సందర్భంలో పాస్ మాత్రం కాదు అర్థం

775
00:53:18,760 --> 00:53:22,350
మీరు బదులుగా 3 సమాన సంకేతాలు ఉపయోగిస్తున్నట్లయితే పేరు.

776
00:53:22,350 --> 00:53:26,590
కాబట్టి మీరు అన్ని ఇప్పుడు చూపించింది వుండాలి ఒక ప్రధాన తేడా ఉంది.

777
00:53:26,590 --> 00:53:31,570
>> స్ట్రింగ్ జోడింపు మీరు PHP లో ఉపయోగించే మరొక శక్తివంతమైన విషయం.

778
00:53:31,570 --> 00:53:34,080
ఇది ప్రాథమికంగా ఈ సులభ డాట్ సంకేతం

779
00:53:34,080 --> 00:53:36,230
మరియు మీరు కలిసి తీగలను కట్టుబడి ఎలా.

780
00:53:36,230 --> 00:53:40,800
కాబట్టి మీరు పిల్లి కలిగి మరియు మీరు డాగ్ కలిగి, మరియు మీరు కలిసి 2 రెమ్మలు చాలు అనుకుంటే,

781
00:53:40,800 --> 00:53:44,080
మీరు కాలం ఉపయోగించవచ్చు, మరియు ఇది ఎలా ఉంటాము.

782
00:53:44,080 --> 00:53:46,660
మీరు కూడా కేవలం ఒకదాని తరువాత వాటిని ఉంచవచ్చు,

783
00:53:46,660 --> 00:53:49,030
మీరు క్రింద ఉదాహరణకు ఇక్కడ చూడగలరు వంటి,

784
00:53:49,030 --> 00:53:51,610
నేను స్ట్రింగ్ 1, స్పేస్ స్ట్రింగ్ 2 ప్రతిధ్వని పేరు.

785
00:53:51,610 --> 00:53:56,930
PHP వంటి వాటిని స్థానంలో తెలుస్తుంది.

786
00:53:56,930 --> 00:53:59,780
వ్యూహాలను. ఇప్పుడు, PHP లో శ్రేణుల యొక్క 2 వివిధ రకాల ఉన్నాయి.

787
00:53:59,780 --> 00:54:03,180
మీరు సాధారణ శ్రేణుల కలిగి మరియు మీరు కూడా సహయోగ శ్రేణుల కలిగి,

788
00:54:03,180 --> 00:54:06,040
మరియు మేము వాటిని ద్వారా వెళ్ళడానికి వెళుతున్న.

789
00:54:06,040 --> 00:54:08,280
రెగ్యులర్ శ్రేణులను ఈ సి లో

790
00:54:08,280 --> 00:54:11,240
మరియు మీరు లెక్కించబడ్డాయి ఆ సూచీలు కలిగి.

791
00:54:11,240 --> 00:54:13,160
ప్రస్తుతం మేము సృష్టించాలి వెళ్లి ఉంచారు చేస్తున్నారు -

792
00:54:13,160 --> 00:54:15,500
ఈ మేము ఒక ఖాళీ శ్రేణి సృష్టించడానికి ఎలా, అప్పుడు మేము చూడాలని

793
00:54:15,500 --> 00:54:17,310
ఇండెక్స్ సంఖ్య 0 ఉంచి.

794
00:54:17,310 --> 00:54:19,200
మేము సంఖ్య 6, విలువ 6 ఉంచారు చూడాలని.

795
00:54:19,200 --> 00:54:21,500
మీరు ఇక్కడ దిగువన చూడగలరు.

796
00:54:21,500 --> 00:54:24,240
Where's - ఇండెక్స్ సంఖ్య 1 వద్ద మేము, విలువ సంఖ్య 4 పెట్టి చూడాలని

797
00:54:24,240 --> 00:54:26,720
మరియు మీరు ఒక 6 ఉంది చూడగలరు, ఒక 4, ఉంది

798
00:54:26,720 --> 00:54:29,160
ఆపై మేము విషయాలు ప్రింటింగ్ వంటి,

799
00:54:29,160 --> 00:54:33,550
మేము ప్రయత్నించండి మరియు ఇండెక్స్ సంఖ్య 0 వద్ద నిల్వ విలువ ప్రింట్ చేసినప్పుడు,

800
00:54:33,550 --> 00:54:36,900
అప్పుడు మేము ముద్రించబడ్డాయి 6 విలువ చూస్తారు. కూల్?

801
00:54:36,900 --> 00:54:40,160
కాబట్టి మీరు కోసం సాధారణ శ్రేణుల ఉంది.

802
00:54:40,160 --> 00:54:42,750
మీరు కూడా ఇప్పుడు సాధారణ శ్రేణుల విషయాలు మరో మార్గం

803
00:54:42,750 --> 00:54:44,780
మీరు చివరిలో వాటిని జోడించవచ్చు ఉంది.

804
00:54:44,780 --> 00:54:47,240
మీరు నిర్దిష్ట ఇండెక్స్ పేర్కొనాలి లేదు అంటే.

805
00:54:47,240 --> 00:54:51,000
మీరు సంఖ్య చూడగలరు, మరియు చదరపు బ్రాకెట్లలో పేర్కొన్న ఏ ఇండెక్స్ ఉంది.

806
00:54:51,000 --> 00:54:56,270
మరియు అది తెలుస్తుంది - PHP కేవలం జాబితా, తదుపరి ఉచిత స్పాట్ ముగింపు జోడించి తెలుస్తుంది.

807
00:54:56,270 --> 00:54:59,190
కాబట్టి మీరు ఆ 0 స్పాట్ వద్ద అక్కడే 1 చూడగలరు

808
00:54:59,190 --> 00:55:02,690
2 మొదటి స్థానంలో కుడి వెళ్ళినప్పుడు.

809
00:55:02,690 --> 00:55:04,690
3 వెళ్తాడు - అలాగే అక్కడ జోడిస్తారు.

810
00:55:04,690 --> 00:55:06,720
కాబట్టి ఆ రకమైన అర్ధమే. మీరు నిరంతరం ఇది జోడించే,

811
00:55:06,720 --> 00:55:09,360
మరియు తర్వాత మేము, సంఖ్య 1 యొక్క ఇండెక్స్ ప్రతిధ్వనించే చేసినప్పుడు

812
00:55:09,360 --> 00:55:13,080
ఇది విలువ 2 ముద్రిస్తుంది.

813
00:55:13,080 --> 00:55:16,800
>> అప్పుడు మేము సహయోగ శ్రేణుల అని శ్రేణుల కలిగి.

814
00:55:16,800 --> 00:55:19,370
బదులుగా సంఖ్యా సూచీలు కలిగి సహయోగ శ్రేణుల,,

815
00:55:19,370 --> 00:55:23,630
ఏమి చేసెదరో వారు నవలని అని సూచీలు కలిగి, ఉంది.

816
00:55:23,630 --> 00:55:25,670
మీరు బదులుగా, చూడగలరు - నేను అన్ని ఆ సంఖ్య సూచీలు తొలగిపోయారు,

817
00:55:25,670 --> 00:55:32,140
మరియు ఇప్పుడు అది key1, key2, key3, మరియు వారు అన్ని తీగలను అని సూచిస్తుంది డబుల్ కోట్స్ లో ఉన్నాము.

818
00:55:32,140 --> 00:55:34,470
కాబట్టి మేము ఈ ఒక ఉదాహరణ కలిగి.

819
00:55:34,470 --> 00:55:38,790
ఈ యొక్క ఉదాహరణ మేము TF కలిగి ఉంది, మరియు ఆ సూచిక పేరు.

820
00:55:38,790 --> 00:55:42,030
మేము, కేలరీలు తింటారు, సూచిక వద్ద, పేరు "ఆలీ" పెట్టి చూడాలని

821
00:55:42,030 --> 00:55:47,640
మేము బదులుగా ఒక స్ట్రింగ్ యొక్క ఒక పూర్ణాంకానికి ఈ సమయంలో ఉంచవచ్చు,

822
00:55:47,640 --> 00:55:52,240
ఆపై ఇండెక్స్ మంది ఇష్టపడ్డారు, మనం లోపల ఒక మొత్త ఉంచవచ్చు.

823
00:55:52,240 --> 00:55:55,490
కాబట్టి ఈ రకమైన ఉంది - మేము కలిగి ఎలా ఇదే భావన ఉంది

824
00:55:55,490 --> 00:55:58,930
సంఖ్యలు బొగ్గు దుమారం, కానీ ఇప్పుడు మేము చుట్టూ సూచీలు మార్చవచ్చు

825
00:55:58,930 --> 00:56:03,890
బదులుగా తీగలను కలిగి ఉంటాయి.

826
00:56:03,890 --> 00:56:06,070
మీరు కూడా, కేవలం వ్యక్తిగతంగా చేస్తున్న పాటు, చేయవచ్చు

827
00:56:06,070 --> 00:56:09,400
మీరు ఒక భాగం లో అన్ని చేయవచ్చు. కాబట్టి మీరు, ఆ శ్రేణి యొక్క TF చూడగలరు

828
00:56:09,400 --> 00:56:13,350
మరియు అప్పుడు మేము ఒక దిగ్గజం చదరపు బ్రాకెట్ సెట్ వాటిని అన్ని సెట్.

829
00:56:13,350 --> 00:56:15,220
కాబట్టి ఆ విషయాలు వేగవంతం.

830
00:56:15,220 --> 00:56:19,730
ఇది కాదు ఒక చిన్న అతిపెద్దదైన పొందండి మరింత.

831
00:56:19,730 --> 00:56:21,550
లూప్ కలిగి.

832
00:56:21,550 --> 00:56:26,020
సి లో మేము ఈ వంటి ఏర్పాటు చేస్తాము.

833
00:56:26,020 --> 00:56:29,690
మేము మా శ్రేణి ఉంది, మరియు మేము జాబితా చివర ఇండెక్స్ 0 నుంచి,

834
00:56:29,690 --> 00:56:31,740
మరియు మేము, అది ప్రింట్?

835
00:56:31,740 --> 00:56:33,880
, సమస్య సహయోగ శ్రేణుల కోసం, తప్ప

836
00:56:33,880 --> 00:56:36,610
మేము తప్పనిసరిగా ఆ సంఖ్యా సూచీలు తెలియదు

837
00:56:36,610 --> 00:56:39,610
ఇప్పుడు మేము స్ట్రింగ్ సూచీలు ఎందుకంటే.

838
00:56:39,610 --> 00:56:44,800
ఇప్పుడు మేము మళ్ళీ, మీరు ఆశాజనక pset 7 లో ఉపయోగించే, foreach ఉచ్చులు, ఉపయోగించడానికి.

839
00:56:44,800 --> 00:56:48,930
Foreach ఉచ్చులు జాబితాలో ప్రతి పాట తెలుస్తుంది.

840
00:56:48,930 --> 00:56:52,450
మరియు మీరు కలిగి ఖచ్చితంగా సంఖ్యా ఇండెక్స్ తెలుసు లేదు.

841
00:56:52,450 --> 00:56:56,490
కాబట్టి మీరు శ్రేణి ఉంచారు, మీరు foreach వాక్యనిర్మాణం, కాబట్టి ఇది foreach ఉంది.

842
00:56:56,490 --> 00:57:00,430
, నా అర్రే pset అంటారు, ఆపై వంటి పదం, వంటి

843
00:57:00,430 --> 00:57:04,530
మరియు మీరు ఉపయోగించడానికి వెళుతున్న ఈ స్థానిక తాత్కాలిక వేరియబుల్ చాలు

844
00:57:04,530 --> 00:57:10,690
కేవలం నిర్దిష్ట కలిగి వెళుతున్న ఆ నిర్దిష్ట విషయం కోసం -

845
00:57:10,690 --> 00:57:14,770
ఉదాహరణకు లేదా శ్రేణి యొక్క ఒక విభాగం.

846
00:57:14,770 --> 00:57:18,350
, Pset num 1 నొక్కి, ఆపై ఉండవచ్చు ఇది సంఖ్య 6 నొక్కి

847
00:57:18,350 --> 00:57:20,410
ఆపై ఇది సంఖ్య 2 కలిగి ఉంటుంది.

848
00:57:20,410 --> 00:57:26,630
కానీ శ్రేణి అని ప్రతి విలువ ద్వారా వెళ్ళడానికి హామీ ఉంది.

849
00:57:26,630 --> 00:57:30,530
మీరు PHP తెలుసుకోవాలి ఉపయోగకరమైన విధులు అవసరమవుతుంది,

850
00:57:30,530 --> 00:57:35,880
నిష్క్రమణ, ఖాళీ, ప్రతిధ్వని ఆ, మీరు కొన్ని ఫైల్స్ చేస్తున్నారు ఖచ్చితంగా చేస్తుంది.

851
00:57:35,880 --> 00:57:40,490
నేను అత్యంత మీరు pset 7 చూడండి మరియు ఆ విధులు చూడండి సిఫార్సు.

852
00:57:40,490 --> 00:57:42,810
మీరు ఆ తెలుసు ఉంటుంది,

853
00:57:42,810 --> 00:57:47,060
నేను ఖచ్చితంగా ఖచ్చితంగా, ఆ అన్ని ఏమి, తెలుస్తుంది.

854
00:57:47,060 --> 00:57:50,080
>> ఇప్పుడు మేము నిజంగా త్వరగా స్కోప్ ద్వారా వెళుతున్నాం.

855
00:57:50,080 --> 00:57:53,490
పరిధిలో, PHP, C కాకుండా, ఒక అల్లరిగా విషయం రకం

856
00:57:53,490 --> 00:57:56,170
అందువలన మేము త్వరగా ద్వారా వెళ్ళి చూడాలని.

857
00:57:56,170 --> 00:57:58,930
కాబట్టి యొక్క మేము మేము అక్కడ ఆ బాణం వద్ద మొదలు అని పిలవబడు.

858
00:57:58,930 --> 00:58:02,900
మరియు మేము $ నేను ప్రారంభం చూడాలని. కాబట్టి వేరియబుల్ 'నేను', 0 అని అన్నారు

859
00:58:02,900 --> 00:58:06,730
మరియు మేము కేవలం అక్కడ పెద్ద తెలుపు బాక్స్ లో ప్రింటింగ్ ఉంచడానికి వెళుతున్న.

860
00:58:06,730 --> 00:58:09,220
మేము I0 ప్రారంభం చూడాలని, మరియు తర్వాత మేము అది ప్రతిధ్వని చూడాలని.

861
00:58:09,220 --> 00:58:12,670
కాబట్టి 0 ఉంది.

862
00:58:12,670 --> 00:58:15,210
మరియు తర్వాత మేము, కోసం లూప్ ద్వారా పెంచడం చూడాలని

863
00:58:15,210 --> 00:58:17,810
మరియు అది 1 విలువ చేస్తాడు.

864
00:58:17,810 --> 00:58:20,070
, కంటే తక్కువ 3, కాబట్టి ఇది ఆ లూప్ గుండా వెళుతున్న

865
00:58:20,070 --> 00:58:23,230
మరియు తర్వాత మేము అది మళ్ళీ ముద్రించిన చూడండి చూడాలని.

866
00:58:23,230 --> 00:58:25,520
మేము, 2 మళ్ళీ పెంచడం చూడాలని

867
00:58:25,520 --> 00:58:29,860
మరియు 2 కంటే తక్కువ 3, కాబట్టి ఇది లూప్ పాస్ చేస్తాము, మరియు అది 2 ప్రింట్ చేస్తాము.

868
00:58:29,860 --> 00:58:35,100
అప్పుడు మీరు 3 3 కంటే తక్కువ కాదు గమనించండి చేస్తాము, కాబట్టి మేము లూప్ బయటకు వస్తుంది.

869
00:58:35,100 --> 00:58:40,050
కాబట్టి ఇప్పుడు మేము నిష్క్రమించారు తర్వాత, ఆపై మేము కార్య క్షీణత లోకి వెళ్ళి చూడాలని.

870
00:58:40,050 --> 00:58:45,010
సరే. కాబట్టి మీరు ఈ వేరియబుల్ మేము సృష్టించిన గమనించండి ఉంటుంది

871
00:58:45,010 --> 00:58:48,270
'నేను' వేరియబుల్, స్థానికంగా దర్శిని గల లేదు.

872
00:58:48,270 --> 00:58:50,280
అది లూప్ స్థానిక కాదు అర్థం,

873
00:58:50,280 --> 00:58:58,060
మరియు ఆ వేరియబుల్ మేము ఇంకా యాక్సెస్ మరియు తరువాత మార్చడానికి, మరియు ఇది ఇప్పటికీ ప్రభావవంతంగా చేయవచ్చు.

874
00:58:58,060 --> 00:59:02,160
మీరు ఇప్పుడు ఫంక్షన్ వెళ్ళాలని అలా, మీరు, మేము కూడా 'నేను' వేరియబుల్ ఉపయోగించే చూస్తారు

875
00:59:02,160 --> 00:59:05,320
మరియు మేము 'నేను' + + పెంచడం చూడాలని.

876
00:59:05,320 --> 00:59:09,410
ఆ 'నేను' వేరియబుల్ కాపీని అని, సి ఆధారంగా, మొదటి వద్ద, అనుకుంటున్నాను.

877
00:59:09,410 --> 00:59:12,830
ఇది సరైనది, ఒక విభిన్నమైన విషయం.

878
00:59:12,830 --> 00:59:16,560
మేము ప్రింట్ చేసినప్పుడు, మేము ప్రింట్ అన్నారు ఇది, 'నేను' + + ప్రింట్ వెళుతున్న 4,

879
00:59:16,560 --> 00:59:19,640
క్షమించాలి - మరియు తర్వాత మేము చూడాలని.

880
00:59:19,640 --> 00:59:22,030
తర్వాత ఆ పనితీరు ముగింపు వెళుతున్న చేస్తున్నాం,

881
00:59:22,030 --> 00:59:24,820
మరియు మేము ఆ బాణం జగన్ను మాత్రం.

882
00:59:24,820 --> 00:59:29,190
ఆ తర్వాత, అయితే, ఫంక్షన్ 'నేను' విలువ మార్చారు ఉన్నప్పటికీ అర్థం,

883
00:59:29,190 --> 00:59:32,620
పదికి ఫంక్షన్ లేదు,

884
00:59:32,620 --> 00:59:35,060
ఫంక్షన్ ఒక ప్రత్యేక పరిధిని కలిగి.

885
00:59:35,060 --> 00:59:38,960
అంటే 'నేను' echo, అది ఫంక్షన్ యొక్క పరిధిని మార్చలేదు అర్థం

886
00:59:38,960 --> 00:59:43,660
, అందువలన మేము మళ్ళీ 3 ప్రింట్ చూడాలని.

887
00:59:43,660 --> 00:59:47,520
C. కంటే PHP లో అవకాశాలపై వివిధ విషయాలు

888
00:59:47,520 --> 00:59:51,130
>> ఇప్పుడు PHP మరియు HTML లో.

889
00:59:51,130 --> 00:59:53,510
PHP వెబ్ పేజీలు డైనమిక్ చేయడానికి ఉపయోగిస్తారు.

890
00:59:53,510 --> 00:59:58,660
ఇది రకం విషయాలను వివిధ చేస్తుంది.

891
00:59:58,660 --> 01:00:02,090
మేము HTML నుండి వివిధ కలిగి.

892
01:00:02,090 --> 01:00:05,230
HTML తో, మేము ఎల్లప్పుడూ, రాబ్ చూపించింది ఎలా వంటి అదే స్టాటిక్ విషయం కలిగి

893
01:00:05,230 --> 01:00:09,370
PHP అయితే, మీరు యూజర్ అయిన ఆధారంగా విషయాలు మార్చవచ్చు.

894
01:00:09,370 --> 01:00:11,830
నేను ఈ కలిగి ఉంటారు, నేను, "మీరు వలె లాగిన్ -" మరియు తర్వాత పేరు,

895
01:00:11,830 --> 01:00:14,420
మరియు నేను మార్చవచ్చు. కాబట్టి ప్రస్తుతం పేరు, జోసెఫ్ ఉంది

896
01:00:14,420 --> 01:00:18,880
మరియు అది ", నా గురించి" ఉంది కానీ నేను కూడా టామీ కలిగి మార్చవచ్చు.

897
01:00:18,880 --> 01:00:21,700
మరియు ఆ వేరే విషయం ఉంటుంది.

898
01:00:21,700 --> 01:00:23,840
కాబట్టి అప్పుడు మేము కూడా అతని గురించి వివిధ విషయాలను మార్చవచ్చు,

899
01:00:23,840 --> 01:00:27,070
మరియు దానిని బట్టి కంటెంట్ చూపిస్తుంది.

900
01:00:27,070 --> 01:00:31,430
కాబట్టి PHP రకమైన మీ వెబ్సైట్ లో ఏమి మార్చవచ్చు.

901
01:00:31,430 --> 01:00:33,540
ఇక్కడ అదే. ఇప్పటికీ, వారు వివిధ కంటెంట్ గమనించండి,

902
01:00:33,540 --> 01:00:38,870
మీరు సాంకేతికంగా ఇప్పటికీ ఉపరితలంపై అదే వెబ్ పేజీ యాక్సెస్ అయినప్పటికీ.

903
01:00:38,870 --> 01:00:43,450
HTML ఉత్పత్తి. మీరు దీన్ని చేయవచ్చు 2 మార్గాలు ఉన్నాయి.

904
01:00:43,450 --> 01:00:48,980
కాబట్టి మేము ఇప్పుడు ఆ ద్వారా వెళ్తారో. మొదటి మార్గం మీరు, ఉంది - ఓహ్, సారీ.

905
01:00:48,980 --> 01:00:51,150
కాబట్టి మీరు, PHP లో లూప్ మీ సాధారణ కలిగి

906
01:00:51,150 --> 01:00:56,270
మరియు మీరు PHP లో ప్రతిధ్వని మరియు మీరు HTML ఎకో.

907
01:00:56,270 --> 01:00:58,720
రాబ్ HTML స్క్రిప్ట్ మీరు చూపించారు ఏమి ఉపయోగించి

908
01:00:58,720 --> 01:01:04,030
ఆపై కేవలం వెబ్ పేజీ దానిని ప్రింట్ PHP print ఉపయోగించి.

909
01:01:04,030 --> 01:01:09,520
ప్రత్యామ్నాయ మార్గం మీరు PHP మరియు HTML వేరు ఉంటే దీన్ని ఉంది.

910
01:01:09,520 --> 01:01:11,940
కాబట్టి మీరు, లూప్ ప్రారంభమయ్యే PHP ఒక లైన్ చేయవచ్చు

911
01:01:11,940 --> 01:01:16,020
అప్పుడు మీరు ఒక ప్రత్యేక విషయం లో HTML యొక్క లైన్ కలిగి,

912
01:01:16,020 --> 01:01:19,700
ఆపై మీరు ఒక PHP తో, మళ్ళీ, లూప్ ముగుస్తుంది.

913
01:01:19,700 --> 01:01:21,800
కనుక ఇది రకమైన వేరుచేసి యొక్క.

914
01:01:21,800 --> 01:01:24,020
ఎడమ వైపున, మీరు కలిగి అన్ని -

915
01:01:24,020 --> 01:01:26,360
ఇది PHP కేవలం 1 భాగం ఉంది.

916
01:01:26,360 --> 01:01:28,510
కుడివైపు మీరు, మీరు PHP ఒక లైన్ ఆ చూడగలరు

917
01:01:28,510 --> 01:01:32,540
మీరు HTML యొక్క ఒక లైన్ కలిగి, మరియు మీరు మళ్ళీ PHP ఒక లైన్.

918
01:01:32,540 --> 01:01:36,870
కాబట్టి వారు చేస్తున్న లోకి దాన్ని వేరు.

919
01:01:36,870 --> 01:01:39,330
మరియు మీరు ఆ మార్గం, వాటిలో గాని కోసం, గమనించండి చేస్తాము

920
01:01:39,330 --> 01:01:41,980
వారు ఇప్పటికీ చిత్రం ప్రింట్, చిత్రం, చిత్రం,

921
01:01:41,980 --> 01:01:44,540
కాబట్టి HTML ఇంకా అదే విధంగా ముద్రించబడుతుంది.

922
01:01:44,540 --> 01:01:49,870
ఆపై మీరు ఇప్పటికీ 3 చిత్రాలు మీ వెబ్ సైట్ లో ప్రదర్శించబడవు చూస్తారు.

923
01:01:49,870 --> 01:01:52,820
కనుక ఇది అదే పనిని 2 వివిధ మార్గాలు.

924
01:01:52,820 --> 01:01:55,060
>> ఇప్పుడు మేము రూపాలు మరియు అభ్యర్థనలు. రాబ్, మీరు చూపించారు

925
01:01:55,060 --> 01:01:59,400
అక్కడ HTML యొక్క రూపాలు, మరియు మేము ఈ పడుతారు ఉంటుంది.

926
01:01:59,400 --> 01:02:02,040
మీరు ఒక చర్య మరియు మీరు ఒక పద్ధతి, మరియు మీ చర్య

927
01:02:02,040 --> 01:02:04,350
రకమైన మీరు పంపించండి వెళుతున్న చూపుతుంది, మరియు పద్ధతి అని

928
01:02:04,350 --> 01:02:06,960
ఇది ఒక GET లేదా ఒక POST చేస్తాడు.

929
01:02:06,960 --> 01:02:11,220
మరియు ఒక కాబట్టి, చెప్పారు వంటి, మీరు ఒక రూపంలో ఉంచారు చూడాలని అర్థం

930
01:02:11,220 --> 01:02:15,760
ఒక POST అభ్యర్థనను మీరు ఒక URL లో చూడరు అయితే మరియు మీరు, ఒక URL ఇది చూస్తారు.

931
01:02:15,760 --> 01:02:17,840
కాబట్టి కొద్దిగా తేడా.

932
01:02:17,840 --> 01:02:19,950
అయితే, ఇదే విషయం అని ఒక విషయం

933
01:02:19,950 --> 01:02:22,560
POST మరియు GET సమానంగా అసురక్షిత అని.

934
01:02:22,560 --> 01:02:26,430
కాబట్టి మీరు, కనుక మీరు URL లో చూడండి లేదు అనుకోవచ్చు

935
01:02:26,430 --> 01:02:28,790
ఆ, POST ఎక్కువ సురక్షితమైనది అర్థం

936
01:02:28,790 --> 01:02:34,420
కానీ మీరు ఇంకా మీరు పంపే చేస్తున్న సమాచారాన్ని మీ కుకీలను లో చూడవచ్చు.

937
01:02:34,420 --> 01:02:38,260
కాబట్టి ఆ భావించడం లేదు గురించి ఒకటి లేదా ఇతర.

938
01:02:38,260 --> 01:02:42,160
గమనించదగ్గ మరో విషయం మీరు కూడా విభాగంలో వేరియబుల్స్ కలిగి ఉంది.

939
01:02:42,160 --> 01:02:45,850
మీరు అబ్బాయిలు మీ యూజర్ ID సమాచారం పొందడానికి pset 7 లో ఈ ఉపయోగించారు.

940
01:02:45,850 --> 01:02:48,550
ఏమి జరిగింది మీరు ఈ అనుబంధ శ్రేణి ఉపయోగించే ఉంది,

941
01:02:48,550 --> 01:02:53,310
$ _ సెషన్, మరియు మీరు వివిధ విషయాలు ప్రాప్తి చూడగలరని

942
01:02:53,310 --> 01:02:57,720
మరియు పేజీలు అంతటా వివిధ విషయాలు నిల్వ.

943
01:02:57,720 --> 01:03:00,750
>> చివరి విషయం, మేము SQL, నిర్మితీకృత ప్రశ్నా భాష కలిగి ఉంది

944
01:03:00,750 --> 01:03:04,360
మరియు ఈ డేటాబేస్ నిర్వహించడానికి ఒక ప్రోగ్రామింగ్ భాష.

945
01:03:04,360 --> 01:03:08,220
, ఖచ్చితంగా, డేటాబేస్ ఏమిటి? వారు పట్టికలు సమాహారం ఉన్నారు,

946
01:03:08,220 --> 01:03:10,630
ప్రతి పట్టిక వస్తువుల ఏకరూప ఉండవచ్చు.

947
01:03:10,630 --> 01:03:14,990
కాబట్టి మేము మీ ఆర్థిక pset లో వినియోగదారుల ఒక పట్టిక కలిగి.

948
01:03:14,990 --> 01:03:20,610
మరియు ఎందుకు వారు ఉపయోగకరం? అది శాశ్వతంగా సమాచారాన్ని నిల్వ ఒక మార్గం ఎందుకంటే.

949
01:03:20,610 --> 01:03:22,840
ఇది విషయాలు ట్రాకింగ్ మరియు విషయాలు నిర్వహించడం మార్గంగా ఉంది

950
01:03:22,840 --> 01:03:25,890
మరియు నిజానికి వేర్వేరు పేజీల మరియు కీపింగ్ ట్రాక్ చూసిన.

951
01:03:25,890 --> 01:03:29,930
అయితే మీరు కేవలం ఒక తక్షణ సమయంలో నిల్వ ఉంటే

952
01:03:29,930 --> 01:03:33,720
ఆపై తర్వాత దాన్ని ఉపయోగించవచ్చు, మీరు సేవ్ చేసిన ఏదైనా యాక్సెస్ చెయ్యడానికి చేయలేరు.

953
01:03:33,720 --> 01:03:37,660
మేము SQL ఆదేశాలను కోసం ఉపయోగించే 4 ప్రధాన విషయాల్లో.

954
01:03:37,660 --> 01:03:40,190
మేము ఎంచుకోండి చొప్పించు, తొలగించండి మరియు నవీకరణ.

955
01:03:40,190 --> 01:03:42,880
ఆ మీరు అబ్బాయిలు మీ క్విజ్ తెలుసు కోసం ముఖ్యమైనవి.

956
01:03:42,880 --> 01:03:45,990
>> మేము త్వరగా చేతికి ఎన్నుకుంటే వెళ్తారో.

957
01:03:45,990 --> 01:03:48,540
సాధారణంగా, మీరు ఒక డేటాబేస్ దీన్ని ఉంది.

958
01:03:48,540 --> 01:03:52,400
కాబట్టి మీరు ఇక్కడ, ఉంటే -

959
01:03:52,400 --> 01:03:56,740
మేము ఈ 2 వివిధ విషయాల్లో, మరియు మేము తరగతులు పట్టిక నుండి ఎంచుకోండి

960
01:03:56,740 --> 01:04:01,480
పేరు అద్భుతంగా - అద్భుతంగా కాలమ్ విలువ 1 ఉంటుంది.

961
01:04:01,480 --> 01:04:04,460
మీరు ఇక్కడ చూడగలరు, మేము, తరగతి పేరుతో ఈ 2 విషయాల్లో

962
01:04:04,460 --> 01:04:08,490
CS50 మరియు Stat110, మరియు మేము తరగతి ID లు మరియు నినాదం కలిగి.

963
01:04:08,490 --> 01:04:13,150
కాబట్టి మేము ఆ సమాచారాన్ని ఎంచుకోండి.

964
01:04:13,150 --> 01:04:17,480
అప్పుడు మీరు, అది రకమైన అద్భుతంగా కాలమ్ బయటకు ఎంపికలో ఇక్కడే చూడగలరు

965
01:04:17,480 --> 01:04:25,170
అన్ని విషయాలు 1, తరువాత అది తరగతి ID, తరగతి పేరు మరియు దాన్ని ఎంచుకోవచ్చు ఆ నినాదం ఉంది పేరు.

966
01:04:25,170 --> 01:04:28,100
మీరు ఈ కోడ్ లో ఎలా చేస్తారు? అవును ఉంటుంది.

967
01:04:28,100 --> 01:04:33,830
కాబట్టి ఆ రకమైన PHP మరియు SQL ప్రతి ఇతర సంబంధించిన ఎలా.

968
01:04:33,830 --> 01:04:38,130
ఇప్పుడు మేము మా కోడ్ కలిగి, మరియు మేము మా ప్రశ్న ఫంక్షన్ ఉపయోగించడానికి వెళుతున్న

969
01:04:38,130 --> 01:04:41,370
మేము pset 7 లో చేశాడు, మరియు మేము SQL ప్రశ్న అమలు చూడాలని.

970
01:04:41,370 --> 01:04:43,870
అప్పుడు మేము చూడాలని -

971
01:04:43,870 --> 01:04:46,280
మేము ఎల్లప్పుడూ తప్పుడు ఉంటే వరుసగా త్రివిధ సమాన అయితే తనిఖీ.

972
01:04:46,280 --> 01:04:49,010
మరలా, మీరు రకం మరియు విలువ తనిఖీ,

973
01:04:49,010 --> 01:04:53,880
ఇది పని చెయ్యకుండా ఆపై, మీకు మేము pset 7 లో వలె, సాధారణ గా, క్షమాపణలు చెబుతానన్నారు.

974
01:04:53,880 --> 01:04:55,870
లేకపోతే, మీరు ఆ సులభ తో ప్రతిదీ ద్వారా లూప్ కావలసిన

975
01:04:55,870 --> 01:04:59,410
foreach మేము కేవలం వెళ్లిన ఉచ్చులు.

976
01:04:59,410 --> 01:05:01,280
, మేము ద్వారా మళ్ళీ వెతికినా మరియు మేము గత ఇది చేసిన ఇప్పుడు ఆ

977
01:05:01,280 --> 01:05:05,080
యొక్క మా ప్రశ్న జారీ భావించేందుకు వీలు, ఇప్పుడు మేము మా foreach లూప్ ఉన్నాయి.

978
01:05:05,080 --> 01:05:11,050
అంటే, ఉంది, ఇక్కడ వరుసగా ఇక్కడే, ఉంది ఇది బాక్స్ యొక్క.

979
01:05:11,050 --> 01:05:14,010
ఇది సంపాదించిన అన్ని సమాచారం ప్రింట్ వెళుతున్న.

980
01:05:14,010 --> 01:05:18,070
కనుక ఇది దిగువన ప్రింట్ వెళుతున్న "వన్నా HTML తెలుసుకోండి?"

981
01:05:18,070 --> 01:05:23,370
ఇది మొదటి లూప్ పూర్తి ఎందుకంటే అప్పుడు,, తదుపరి వరుస వెళ్ళండి వెళుతున్న

982
01:05:23,370 --> 01:05:26,510
కాబట్టి అప్పుడు ఇది, ఇది రెండవ లైన్ ప్రింట్ వెళుతున్న

983
01:05:26,510 --> 01:05:32,120
STAT110 అన్నారు ఇది, అన్ని మూమెంట్స్ కనుగొను.

984
01:05:32,120 --> 01:05:34,290
>> ఒక చివరి విషయం SQL డిస్ప్లే ఉంది.

985
01:05:34,290 --> 01:05:37,300
నేను డేవిడ్ ఈ ఉపన్యాసంలో కొద్దిగా తాకిన తెలుసు.

986
01:05:37,300 --> 01:05:40,730
మీరు ఈ చదువుకోవచ్చు. ఇది నిజంగా సరదాగా అనిపిస్తుంది.

987
01:05:40,730 --> 01:05:45,320
SQL ఇంజెక్షన్ గమ్మత్తైన విషయం ఒక రకం.

988
01:05:45,320 --> 01:05:49,890
యొక్క మీరు కేవలం మీ ప్రశ్న లోకి ఆ వేరియబుల్స్ కర్ర అని పిలవబడు,

989
01:05:49,890 --> 01:05:52,290
మీరు ఆ మొదటి లైన్ లో చూడగలరు గా.

990
01:05:52,290 --> 01:05:54,520
కాబట్టి అది కుడి, జరిమానా ఉంది? మీరు కేవలం యూజర్ పేరు లో ఉంచడం చేసిన

991
01:05:54,520 --> 01:05:58,820
మరియు మీ SQL ప్రశ్న పాస్వర్డ్ మరియు మీరు ఇది ఆఫ్ ఓడ మరియు మీ డేటా పట్టిక లో సంసార పొందాలనుకోవడం.

992
01:05:58,820 --> 01:06:01,450
ఆ అందమైన సాధారణ కనిపిస్తుంది. కాబట్టి, ఎవరైనా లో ఉంచుతుంది చెప్పడానికి అనుమతిస్తుంది

993
01:06:01,450 --> 01:06:04,910
పాస్వర్డ్ను కోసం, ఈ OR టెక్స్ట్ ఇక్కడే -

994
01:06:04,910 --> 01:06:06,780
నిజానికి ఎరుపు బాక్స్ లో ఉండాలి.

995
01:06:06,780 --> 01:06:11,920
కాబట్టి యొక్క వారు ఆ పాస్వర్డ్ను ఉంచండి అని పిలవబడు - వారు ఎంటర్ ఏమిటి.

996
01:06:11,920 --> 01:06:16,520
కాబట్టి వారు ఉంచడం OR "1" = 1 చేస్తున్నారు.

997
01:06:16,520 --> 01:06:20,880
కలిగి ఒక వెర్రి పాస్వర్డ్ను రకం.

998
01:06:20,880 --> 01:06:25,070
ఇప్పుడు కేవలం అది స్థానంలో తెలియజేయండి మరియు మీరు ఇప్పుడు SQL ప్రశ్న లో గమనించండి చేస్తాము,

999
01:06:25,070 --> 01:06:29,090
మీరు గమనించండి చేస్తాము ఎందుకంటే, ఎప్పుడూ నిజం కు మదింపు

1000
01:06:29,090 --> 01:06:32,240
మీరు SQL ప్రశ్న ఈ సమాచారం అన్ని ఎంచుకోవచ్చు

1001
01:06:32,240 --> 01:06:35,420
లేదా మీరు = 1 1 ఉండవచ్చు.

1002
01:06:35,420 --> 01:06:41,030
కాబట్టి ఆ ఎల్లప్పుడూ నిజమైన విశ్లేషించదు చేస్తాడు.

1003
01:06:41,030 --> 01:06:46,610
మొదట వ్యవస్థ విచ్ఛిన్నం చేసే అర్థం ఎందుకంటే, నిజంగా పని మాత్రం కాదు.

1004
01:06:46,610 --> 01:06:49,300
ఈ పరిష్కారం మీరు PDO వ్యవస్థ ఉపయోగించడానికి కలిగి ఉంది,

1005
01:06:49,300 --> 01:06:51,360
ఇది, మీరు ప్రశ్నార్థకాలుగా ఉపయోగించాలి అర్థం

1006
01:06:51,360 --> 01:06:53,350
మీరు pset 7 ఉపయోగిస్తారు అబ్బాయిలు, ఇది

1007
01:06:53,350 --> 01:06:57,620
మీరు ఏదో ఉంచాలి కావలసిన ఉన్న స్థానంలో ప్రశ్నార్ధకం ఉపయోగించడానికి వెళుతున్న,

1008
01:06:57,620 --> 01:07:01,430
మరియు, మీరు కామాతో చూడాలని, ఆపై మీరు తర్వాత ఉంటుంది

1009
01:07:01,430 --> 01:07:07,610
మీ స్ట్రింగ్ తర్వాత, మీకు కావలసిన వివిధ వేరియబుల్స్ మీ ప్రశ్న గుర్తు లోకి స్థానంలో.

1010
01:07:07,610 --> 01:07:10,330
కాబట్టి మీరు ఇప్పుడు నేను ఈ ఎరుపు ప్రశ్నార్థకాలుగా కలిగి ఇక్కడ గమనించండి చేస్తాము.

1011
01:07:10,330 --> 01:07:15,420
నేను తర్వాత చేసుకున్నంతసేపూ స్థానంలో తెలుసు కాబట్టి అప్పుడు నా తీగలను తరువాత వేరియబుల్స్ ఉంచండి.

1012
01:07:15,420 --> 01:07:18,470
ఎవరైనా ఈ వంటి అది ఉంటే ఆ, ఖచ్చితంగా ఆ చేస్తుంది

1013
01:07:18,470 --> 01:07:24,050
మరియు వారు, ఖచ్చితంగా చేస్తుంది, లేదా 1 = 1 పరిస్థితి కలిగి

1014
01:07:24,050 --> 01:07:30,490
తిరిగి చివరికి, ఇది వాస్తవానికి SQL ప్రశ్న బ్రేక్ లేదు నిర్ధారించుకోండి.

1015
01:07:30,490 --> 01:07:33,660
సరే, PHP మరియు SQL సుడిగాలి, ఇది చాలా కాబట్టి.

1016
01:07:33,660 --> 01:07:41,520
మీరు అన్ని శుభాకాంక్షలు, మరియు ఇప్పుడు Ore. కు

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] సరే అందరికీ. కొన్ని జావాస్క్రిప్ట్ వెళ్ళి సమయం

1018
01:07:44,270 --> 01:07:48,840
మరియు కొన్ని ఇతర విషయాలు చాలా త్వరగా కాబట్టి మీరు టునైట్ పట్టుకొని లేదు.

1019
01:07:48,840 --> 01:07:56,930
జావాస్క్రిప్ట్. అవును. జావాస్క్రిప్ట్ ఉద్దేశ్య, ఒక చల్లని విషయం రకంగా ఉంది.

1020
01:07:56,930 --> 01:07:59,090
మీరు నిజంగా JavaScript గురించి తెలుసుకోవాలి విషయాలు, అది విధమైన వంటిది

1021
01:07:59,090 --> 01:08:03,810
మీ వెబ్ అప్లికేషన్ చేస్తూ అన్నారు ఏమి క్లైంట్ వైపు ముగింపు.

1022
01:08:03,810 --> 01:08:08,280
మీరు సర్వర్ వైపు అన్ని సమయం యొక్క శ్రద్ధ వహించడానికి లేదు కొన్ని విషయాలను.

1023
01:08:08,280 --> 01:08:12,880
అన్ని చిన్న పరస్పర,, ఒక విషయం చూపిస్తున్న ఏదో అదృశ్యం తయారు.

1024
01:08:12,880 --> 01:08:15,340
మీరు నిజంగా మీ సర్వర్కు కోసం అన్ని సమయం మాట్లాడటానికి కలిగి వద్దు.

1025
01:08:15,340 --> 01:08:18,069
మరియు ఆ కొన్ని సర్వర్లో చేయడానికి కూడా సాధ్యం కాదు.

1026
01:08:18,069 --> 01:08:21,899
మేము JavaScript వంటి ఏదో అవసరం ఎందుకు ఉంది.

1027
01:08:21,899 --> 01:08:24,359
జావాస్క్రిప్ట్ గురించి విషయాలు: ఇది డైనమిక్ టైపు చేసినప్పుడు.

1028
01:08:24,359 --> 01:08:27,149
ఈ మీ కార్యక్రమం తెలుసుకోవాలి ఉండదు

1029
01:08:27,149 --> 01:08:30,970
మీరు దీనిని వ్రాస్తున్నప్పుడు ఏమి, ఖచ్చితంగా, వేరియబుల్స్ ఉన్నాయి.

1030
01:08:30,970 --> 01:08:34,510
ఇది అమలు ఇది కేవలం విధమైన అది కనిపెడతాడు.

1031
01:08:34,510 --> 01:08:37,520
దాని గురించి చల్లని అని ఇతర విషయాలు: ఇది ఒక వంకర కలుపు భాష,

1032
01:08:37,520 --> 01:08:41,359
వాక్యనిర్మాణం సి మరియు PHP పోలి ఉంటుంది అర్థం.

1033
01:08:41,359 --> 01:08:47,050
మీరు జావాస్క్రిప్ట్ నేర్చుకుంటున్నారు చాలా మరల పని చేయడానికి లేదు.

1034
01:08:47,050 --> 01:08:49,180
ఇక్కడ మేము JavaScript కొద్దిగా ఉన్నాయి.

1035
01:08:49,180 --> 01:08:52,560
ఇక్కడే ఆసక్తికరమైన విషయం, మీరు చూడండి ఉంటే, ఉంది

1036
01:08:52,560 --> 01:08:56,330
మేము తల ట్యాగ్ లో అక్కడే జావాస్క్రిప్ట్ ఒక బిట్ కలిగి.

1037
01:08:56,330 --> 01:08:59,479
ఏమిటి కేవలం ఒక JavaScript ఫైలు ఉన్నాయి ఇది ఉంటుంది.

1038
01:08:59,479 --> 01:09:02,260
ఈ మీరు మీ కార్యక్రమంలోకి జావాస్క్రిప్ట్ ఉంటాయి ఒక మార్గం.

1039
01:09:02,260 --> 01:09:06,910
అప్పుడు రెండవ కొద్దిగా, నిజానికి కొన్ని ఇన్లైన్ జావాస్క్రిప్ట్ ఉంది

1040
01:09:06,910 --> 01:09:10,790
చాలా CSS ఒక ఇన్లైన్ శైలి పోలి,

1041
01:09:10,790 --> 01:09:16,180
మరియు మీరు కేవలం చాలా త్వరగా అక్కడ కొన్ని కోడ్ రాస్తున్నాం.

1042
01:09:16,180 --> 01:09:18,120
జావాస్క్రిప్ట్ శ్రేణుల ఉంది.

1043
01:09:18,120 --> 01:09:20,850
చాలా ఉపయోగకరంగా, చుట్టూ డేటా ఉంచడానికి మరొక మార్గం.

1044
01:09:20,850 --> 01:09:25,180
చాలా అవును.

1045
01:09:25,180 --> 01:09:29,870
మీరు ప్రతి యాక్సెస్ మరియు కలిసి ప్రతిదీ ఉంచడానికి చదరపు బ్రాకెట్లలో ఉపయోగించండి.

1046
01:09:29,870 --> 01:09:35,020
చాలా క్లిష్టమైన ఏమీ.

1047
01:09:35,020 --> 01:09:38,630
సాధారణంగా JavaScript మరియు స్క్రిప్టింగ్ భాషలు గురించి చల్లని విషయం

1048
01:09:38,630 --> 01:09:40,920
మీరు శ్రేణి పరిమాణాలు గురించి ఆందోళన లేదు అని.

1049
01:09:40,920 --> 01:09:43,880
మీరు array.length దాని యొక్క ట్రాక్ చేయవచ్చు,

1050
01:09:43,880 --> 01:09:46,960
మరియు శ్రేణి పెరిగే లేదా మీరు ఇది అవసరం కుదించగలరని.

1051
01:09:46,960 --> 01:09:49,279
సో మీరు కూడా, ఏ విధమైన గురించి ఆందోళన అవసరం లేదు

1052
01:09:49,279 --> 01:09:57,050
అరెరే, నేను మరింత విషయాలు, లేదా ఆ వంటి ఏదైనా కేటాయించాల్సిన అవసరం.

1053
01:09:57,050 --> 01:10:00,090
>> ఇక్కడ చల్లని విషయం జావాస్క్రిప్ట్ వస్తువులు అని ఏదో ఉంది.

1054
01:10:00,090 --> 01:10:04,800
ఇది ఒక ఆబ్జెక్ట్ ఆధారిత భాష, కాబట్టి ఇది ఏమి, ముఖ్యంగా,

1055
01:10:04,800 --> 01:10:10,100
సమూహం డేటా మిమ్మల్ని కోసం ఒక మార్గం కలిసి, ఒక struct కొంతవరకు పోలి,

1056
01:10:10,100 --> 01:10:17,280
కానీ మీరు ఒక struct వంటి లేదా ఒక అనుబంధ శ్రేణి వాక్యనిర్మాణంలో అది యాక్సెస్ చేయవచ్చు.

1057
01:10:17,280 --> 01:10:22,520
ఇది చాలా సులభం మరియు మీరు ఈ తో చేయవచ్చు కలిసి సమూహం డేటా ఉంది

1058
01:10:22,520 --> 01:10:24,810
మీరు సంబంధించిన ఆ డేటా కొంత ఉంటే.

1059
01:10:24,810 --> 01:10:26,850
మీరు ఒక కారు కలిగింది అన్ని విషయాలు ఎందుకంటే,

1060
01:10:26,850 --> 01:10:29,050
మీరు వివిధ ప్రాంతాల కొంత లో కలిగి అవసరం లేదు.

1061
01:10:29,050 --> 01:10:35,300
మీరు జావాస్క్రిప్ట్ లో 1 వస్తువు అతుక్కుపోగలవు.

1062
01:10:35,300 --> 01:10:39,090
మీరు బహుశా తెలిసి, iterating ఆ దుర్భర పనులు ఒకటి.

1063
01:10:39,090 --> 01:10:43,810
మీరు మళ్ళీ ఒక మీద చేస్తున్నాయి. మీరు, కారులో ప్రతి వస్తువు మాట్లాడటానికి అవసరం

1064
01:10:43,810 --> 01:10:47,340
లేదా మీరు జాబితా లేదా అలాంటిదే లో ప్రతి అంశం ద్వారా వెళ్లాలి.

1065
01:10:47,340 --> 01:10:51,770
కాబట్టి JavaScript, PHP, ఒక foreach వాక్యనిర్మాణం పోలి ఉంది.

1066
01:10:51,770 --> 01:10:54,590
ఈ సందర్భంలో, అది లూప్ లో కోసం ఒక ఉంది.

1067
01:10:54,590 --> 01:10:57,300
మీరు వస్తువులు ఈ ఉపయోగించాలనుకుంటున్నాను.

1068
01:10:57,300 --> 01:11:01,030
మీరు శ్రేణులపై ఈ ఉపయోగిస్తే సంభవించే కొన్ని సమస్యలు ఉన్నాయి.

1069
01:11:01,030 --> 01:11:03,750
ఇది సాధారణంగా, అయితే, చాలా ఉపయోగపడుతుంది, ఆ విషయాలు ఒకటి

1070
01:11:03,750 --> 01:11:06,590
మీరు భారాన్ని చాలా తొలగించడానికి ఎందుకంటే

1071
01:11:06,590 --> 01:11:10,270
మీరే ద్వారా మీ వస్తువు ప్రతిదీ అప్ లాగండి ఉంటుంది లేదు ఎందుకంటే.

1072
01:11:10,270 --> 01:11:12,300
మీరు అన్ని కీ పేర్లు గుర్తు లేదు.

1073
01:11:12,300 --> 01:11:18,270
మీరు విధమైన ఈ వాక్యనిర్మాణంలో వాటిని తిరిగి.

1074
01:11:18,270 --> 01:11:21,500
ఈ లో, కోసం, మీరు కేవలం గుర్తు

1075
01:11:21,500 --> 01:11:27,180
మీరు పట్టిక హాష్ ఒక చాలా విధంగా, అన్ని కీలను తిరిగి పొందుతుంటే.

1076
01:11:27,180 --> 01:11:30,880
మీరు ఆ నుండి గుర్తుంచుకుంటే మీరు ఒక స్ట్రింగ్ లో ఉంచుతాడు, మీరు ఏదో అవుట్ కాలేదు

1077
01:11:30,880 --> 01:11:33,840
దానితో ఒక విలువ వుంటుంది.

1078
01:11:33,840 --> 01:11:36,360
మీరు ఈ తో చేయవచ్చు, మీరు, అన్ని కుడి చెప్పగలను ఉంది

1079
01:11:36,360 --> 01:11:42,120
నేను కారు ఉంచారు, మరియు నేను ఒక ఫెరారీ అని.

1080
01:11:42,120 --> 01:11:45,290
కాబట్టి మీరు తర్వాత మళ్ళీ స్ట్రింగ్ ఫెరారీ లో ఉంచవచ్చు, మరియు మీరు ఆ పొందవచ్చు.

1081
01:11:45,290 --> 01:11:50,000
మరియు మీరు లూప్ లో కోసం తో, ఒక లూప్ లో ఆ చేయవచ్చు.

1082
01:11:50,000 --> 01:11:53,320
కాబట్టి కేవలం వస్తువులు గురించి మరింత. మీరు గుర్తుంచుకోవాల్సిన అవసరం ఈ నుండి కీ విషయం

1083
01:11:53,320 --> 01:12:00,340
, మీరు ఈ తో కావలసినప్పుడు వాక్యనిర్మాణం వంటి వస్తువు struct ఉపయోగించే ఉంది

1084
01:12:00,340 --> 01:12:04,590
మీ స్ట్రింగ్ ఉపయోగించడానికి వెళుతున్న ఒక చెల్లుబాటు అయ్యే చరాంశం పేరు ఉంటే తప్ప.

1085
01:12:04,590 --> 01:12:07,650
మీరు ఆ అక్కడ చూడండి అలా అయితే, మేము ఫైళ్ళను తెరవడానికి.

1086
01:12:07,650 --> 01:12:12,500
సరే, మీరు object.key ఉంచాలి ఉన్నట్లయితే, స్పేస్, తో, స్పేస్, స్పేస్,

1087
01:12:12,500 --> 01:12:15,320
కేవలం పదము అర్ధవంతం లేదు.

1088
01:12:15,320 --> 01:12:22,730
కాబట్టి మీరు బ్రాకెట్ సింటాక్స్ ఈ విధమైన ఆ చేయవచ్చు.

1089
01:12:22,730 --> 01:12:26,520
>> కూడా, జావాస్క్రిప్ట్ చాలా పరిధిని వారీగా PHP ఉంది.

1090
01:12:26,520 --> 01:12:29,050
మీరు పరిధిని కొరకు 2 మార్గాలు ఉన్నాయి.

1091
01:12:29,050 --> 01:12:31,960
మీరు ఒక వేరియబుల్ ముందు var ఉండకూడదు,

1092
01:12:31,960 --> 01:12:34,060
మరియు కేవలం ఈ ప్రపంచ అర్థం.

1093
01:12:34,060 --> 01:12:37,050
మీరు ఎక్కడి నుండి చూడగలరు. మీరు ఒక ప్రకటన ఉంటే ఈ ఉంచాలి కూడా,

1094
01:12:37,050 --> 01:12:42,430
ఎక్కడైనా మీ కోడ్ లో ఆ తరువాత మీరు ఆ వేరియబుల్ చూడవచ్చు.

1095
01:12:42,430 --> 01:12:46,730
మరో విషయం, అయితే, అది మీరు సైన్ ఉన్నారు సంసార ఫంక్షన్ పరిమితం, var తో ఉంది

1096
01:12:46,730 --> 01:12:48,870
మీరు ఒక ఫంక్షన్ లో లేదు అయితే, బాగా, అది ప్రపంచ వార్తలు.

1097
01:12:48,870 --> 01:12:53,900
మీరు ఒక ఫంక్షన్ లో ఉంటే కానీ ఆ ఫంక్షన్ లో మాత్రమే కనిపిస్తుంది.

1098
01:12:53,900 --> 01:12:56,420
అవును, ఒక ఉదాహరణ, కానీ లేదు. ఇది ఆ విషయాలు ఒకటి పేరు

1099
01:12:56,420 --> 01:12:59,900
మీరు, మీరు ప్రపంచ ఉండాలనుకుంటున్నాను ఏమి వేరియబుల్స్ నిర్వహించవచ్చు

1100
01:12:59,900 --> 01:13:03,810
ఏ వేరియబుల్స్ మీరు స్థానిక ఉండాలనుకుంటున్నాను, కానీ మీరు ఈ గురించి జాగ్రత్తగా చేయాలి,

1101
01:13:03,810 --> 01:13:06,890
మీరు C లో సన్నని రేణువు నియంత్రణ రకం లేదు ఎందుకంటే,

1102
01:13:06,890 --> 01:13:15,820
ఏదో లూప్ ఒక లో ప్రకటిస్తారు కాబట్టి, ఇది ఆ లూప్ లో ఉండడానికి వెళుతున్న పేరు.

1103
01:13:15,820 --> 01:13:18,790
అంటే కోసం స్కాన్ ఉపయోగించి శ్రద్ధ విషయం కుడి, వెబ్ పేజీలు రెట్టింపు ఉంది?

1104
01:13:18,790 --> 01:13:21,800
నేను అర్థం, ఎందుకు మేము ఇలా ఉంది.

1105
01:13:21,800 --> 01:13:23,840
>> మేము DOM అనే ఉపయోగించడానికి, ఆ చేయుటకు.

1106
01:13:23,840 --> 01:13:25,850
డాక్యుమెంట్ ఆబ్జెక్ట్ మోడల్.

1107
01:13:25,850 --> 01:13:29,430
సాధారణంగా, ఏమిటి అది అన్ని మీ HTML పడుతుంది

1108
01:13:29,430 --> 01:13:34,110
మరియు ప్రతి ఇతర లోపల యున్న ఆ వస్తువులు కొంత నమూనాలు దాన్ని.

1109
01:13:34,110 --> 01:13:37,080
మీరు ఈ వంటి ఏదో తో ప్రారంభమై.

1110
01:13:37,080 --> 01:13:44,770
మీరు అక్కడ కోడ్ కొంత విధమైన ఉంది, నాకు కుడి, కలిగి -

1111
01:13:44,770 --> 01:13:46,640
ఆ సవరించడానికి చాలా కష్టం భావిస్తున్నాను,

1112
01:13:46,640 --> 01:13:48,700
మీరు టెక్స్ట్ కొంత ద్వారా పార్సింగ్ అంటాను ఎందుకంటే

1113
01:13:48,700 --> 01:13:52,080
మరియు విషయాలు కాకుండా ముక్క కలిగి. మరియు అది సరిగ్గా ఏమి ఫార్మాట్ ఉంటే?

1114
01:13:52,080 --> 01:13:54,880
చెడు విషయాల జరుగుతుంది.

1115
01:13:54,880 --> 01:13:58,140
కాబట్టి, JavaScript మీరు ఈ జాగ్రత్త తీసుకుంటుంది, మీరు ఒక nice డేటా నిర్మాణం పొందండి

1116
01:13:58,140 --> 01:14:01,390
మీరు ఒక పత్రాన్ని నా, ఎడమ ఒక వంటి,

1117
01:14:01,390 --> 01:14:03,530
మరియు ఆ లోపల మీరు, HTML అనే విషయం

1118
01:14:03,530 --> 01:14:05,600
మరియు ఆ లోపల మీరు, ఒక తల మరియు శరీరం

1119
01:14:05,600 --> 01:14:08,420
మరియు ఆ తల లోపల మీరు, మొదలగునవి, మొదలగునవి మొదలగునవి శీర్షిక.

1120
01:14:08,420 --> 01:14:11,810
ఈ, అది కేవలం కాబట్టి ఒక వెబ్ పేజీ రెట్టింపు సులభతరం

1121
01:14:11,810 --> 01:14:14,190
ఓహ్, నేను కేవలం ఈ వస్తువు మాట్లాడు.

1122
01:14:14,190 --> 01:14:21,340
మీరు మీరే తయారు మరొక వస్తువు మాట్లాడిన చాలా విధంగా విధమైన.

1123
01:14:21,340 --> 01:14:25,980
నేను అన్నాడు వంటి, అన్ని DOM డాక్యుమెంట్ ఆబ్జెక్ట్ లో ఉంది.

1124
01:14:25,980 --> 01:14:29,290
గాని, ఇది కేవలం ఒక స్థానం మరియు మీరు విషయాలు కనుగొనేందుకు దానిలోని వెళ్ళే

1125
01:14:29,290 --> 01:14:33,880
మరియు మీరు దీన్ని చెయ్యవచ్చు - ఈ అక్కడికి, అది చేయడం పాత శైలి,

1126
01:14:33,880 --> 01:14:38,130
మీరు document.getElementById చేయండి, మరియు ఆపై పేరు,

1127
01:14:38,130 --> 01:14:42,420
మీరు బహుశా వర్తమాన మరియు, ఈ ఒక తర్వాత చాలా అతిపెద్దదైన గెట్స్.

1128
01:14:42,420 --> 01:14:44,480
కాబట్టి మీరు బహుశా అలా చేయకూడదని. మేము ఎందుకు పేర్కొంది

1129
01:14:44,480 --> 01:14:48,760
మేము ఈ తరువాత మాట్లాడటానికి చూడాలని తర్వాత విషయం.

1130
01:14:48,760 --> 01:14:52,510
ఇక్కడ కీ విషయం, అన్ని కుడి, మీరు కుడి, ఈ అంశాలను కలిగి?

1131
01:14:52,510 --> 01:14:56,400
కాబట్టి నేను పేజీ లోడ్ ఏదో యొక్క రంగు మార్చవచ్చు.

1132
01:14:56,400 --> 01:14:58,380
కాబట్టి ఏమి? నా యూజర్ ఏదో క్లిక్ ఉంటే?

1133
01:14:58,380 --> 01:15:00,540
నేను వారు ఏదో క్లిక్ చేసినప్పుడు అది ఆసక్తికరంగా చేయాలని.

1134
01:15:00,540 --> 01:15:02,600
మేము సంఘటనలు ఎందుకు పేర్కొంది.

1135
01:15:02,600 --> 01:15:05,330
మీరు, ప్రాథమికంగా, మీ DOM లో ఏ మూలకం పొందవచ్చు,

1136
01:15:05,330 --> 01:15:08,560
ఆపై హే, చెప్పటానికి. , ఈ లోడుచేస్తుంది లేదా ఎవరైనా అది క్లిక్ చేసినప్పుడు

1137
01:15:08,560 --> 01:15:11,410
లేదా వారు దాని పై మౌస్, దానితో ఏదో చేసినప్పుడు.

1138
01:15:11,410 --> 01:15:15,330
మరియు మీరు కలిగి మీరు ఈ కూర్పులో విధులు, ఉంది.

1139
01:15:15,330 --> 01:15:17,980
ఈ విధులు ఈవెంట్ నిర్వహించే ఉంటాయి.

1140
01:15:17,980 --> 01:15:20,440
ఏ they're - ఇది మాట్లాడుతూ ఒక ఫాన్సీ మార్గం,

1141
01:15:20,440 --> 01:15:23,500
ఈ కార్యక్రమం జరిగినప్పుడు ఈ మాత్రమే అమలు.

1142
01:15:23,500 --> 01:15:28,070
కనుక ఇది హుర్రే.

1143
01:15:28,070 --> 01:15:30,810
మీరు కార్యక్రమం నిర్వహణ బద్ధం ఎలా ఉంది.

1144
01:15:30,810 --> 01:15:34,750
నేను కొన్ని బటన్, మరియు మీరు క్లిక్ చేసినప్పుడు, అది పేలుడు.

1145
01:15:34,750 --> 01:15:40,560
కాబట్టి బటన్ క్లిక్ లేదు.

1146
01:15:40,560 --> 01:15:42,910
ఈ కుడి, సమీపించే ఒక మార్గం?

1147
01:15:42,910 --> 01:15:46,430
, మీరు ఒక బటన్ ట్యాగ్ మరియు క్లిక్ మీరు అని ఒక స్ట్రింగ్ కలిగి

1148
01:15:46,430 --> 01:15:50,460
ఓహ్, మార్గం ద్వారా, నేను నాకు ఈ పేలే పనిని.

1149
01:15:50,460 --> 01:15:53,990
లేకపోతే, అది కేవలం మీరు చేసిన ఒక సాధారణ బటన్ వంటిది.

1150
01:15:53,990 --> 01:15:56,550
మీరు కూడా ఈ మరొక మార్గం చేయవచ్చు,

1151
01:15:56,550 --> 01:16:02,770
మేము క్వెరీ గారు DOM మూలకం ఈడ్చడం కానీ ద్వారా ఆ సేవ్ చేస్తాము.

1152
01:16:02,770 --> 01:16:07,580
>> J క్వెరీ: ఇది క్రాస్ బ్రౌజర్ ఒక గ్రంథాలయం.

1153
01:16:07,580 --> 01:16:09,580
మీరు గొప్పది ఏదైనా దానిని ఉపయోగించవచ్చు.

1154
01:16:09,580 --> 01:16:12,090
ఇది మీరు పని సాధనాలు చాలా ఇస్తుంది.

1155
01:16:12,090 --> 01:16:15,850
జావాస్క్రిప్ట్, శక్తివంతమైన అయితే, మీరు అవసరం అన్ని టూల్స్ లేదు ఎందుకంటే

1156
01:16:15,850 --> 01:16:20,550
నిజంగా ఒక వెబ్ అనువర్తనం పరిష్కరించడానికి బాక్స్ బయటకు మీరు అనుకోవచ్చు.

1157
01:16:20,550 --> 01:16:24,650
కనుక ఇది, విషయాలు చాలా సులభతరం మీరు విధులు చాలా ఇస్తుంది

1158
01:16:24,650 --> 01:16:28,760
మీరు సాధారణంగా మళ్ళీ మరియు పైగా మరియు పైగా, మీరే రాయడానికి అని బాక్స్ బయటకు.

1159
01:16:28,760 --> 01:16:31,600
మరియు కేవలం విషయాలు చాలా సులభం చేస్తుంది.

1160
01:16:31,600 --> 01:16:35,780
మీరు అన్ని అంశాలను చేద్దామని వీలు ఇది సెలెక్టర్లు, కలిగి

1161
01:16:35,780 --> 01:16:42,800
మీ DOM మరింత నుండి కేవలం, బదులుగా ఈ చాలా ఫంక్షన్ కాల్స్ ఉపయోగించడానికి అవసరం.

1162
01:16:42,800 --> 01:16:46,630
ఈ సెలెక్టర్లు మరింత. మీరు, సే తెలియజేయండి చేశారు అక్కడికి, కలిగి

1163
01:16:46,630 --> 01:16:49,800
నేను ID తో ఒక మూలకం మీరు, "రాక్."

1164
01:16:49,800 --> 01:16:56,450
బాగా, j క్వెరీ లో, అది కేవలం $ ఆపై ఒక పౌండ్ ఉంది ఒక స్ట్రింగ్, మరియు ఉంది "రాక్."

1165
01:16:56,450 --> 01:17:01,960
ఇది చాలా సులభమైన మరియు ఈ సమస్య పరిష్కారంలో సంప్రదాయ జావాస్క్రిప్ట్ మార్గం కంటే చాలా వేగంగా ఉంది.

1166
01:17:01,960 --> 01:17:06,120
మరియు మీరు తరగతులు మరియు మూలకం రకాల కోసం విషయాలు కలిగి.

1167
01:17:06,120 --> 01:17:08,140
j క్వెరీ ఉంది - అద్భుతమైన ఒకటి మీరు విధమైన కుదించవచ్చు ఉంది

1168
01:17:08,140 --> 01:17:14,350
మీ DOM మీ ప్రశ్నలు డౌన్ చాలా, చాలా వేగంగా.

1169
01:17:14,350 --> 01:17:18,980
ఇప్పుడు మేము తిరిగి ఈవెంట్ నిర్వహణ ఉన్నాము, మరియు ఈ మీరు j క్వెరీ లో ఒక సంఘటన నిర్వహించడానికి ఎలా ఉంది.

1170
01:17:18,980 --> 01:17:23,090
కాబట్టి మనం ఇక్కడ చూడాలని మేము అన్ని కుడి, చెబుతున్న ఉంది. నేను స్క్రిప్ట్ ట్యాగ్ కలిగి, కుడి?

1171
01:17:23,090 --> 01:17:25,400
నేను స్ట్రింగ్ argv.

1172
01:17:25,400 --> 01:17:27,750
మనం చేయబోతున్నామని మేము అన్ని కుడి, చెప్పడానికి వెళుతున్న ఉంది.

1173
01:17:27,750 --> 01:17:30,860
పత్రం, పత్రం లోడ్ చెయ్యబడిన అంటే, సిద్దంగా ఉన్నప్పుడు

1174
01:17:30,860 --> 01:17:34,660
, మేము ఆ ఫంక్షన్ కు వెళ్ళి, మరియు మేము, అన్ని కుడి చెప్పటానికి చూడాలని

1175
01:17:34,660 --> 01:17:37,060
ఈ ఫంక్షన్ వాస్తవానికి ఏదో చేయుచున్నాడు.

1176
01:17:37,060 --> 01:17:42,320
ఇది ప్రాథమికంగా అన్ని కుడి, నాకు ID తో మూలకం పొందడానికి, మాట్లాడుతూ "myid."

1177
01:17:42,320 --> 01:17:47,960
మరియు ఈ మీరు క్లిక్ చేసినప్పుడు అమలు చేసే ఒక ఫంక్షన్ నిర్వహణ ఇవ్వాలని.

1178
01:17:47,960 --> 01:17:49,820
సాధారణంగా ఈ చేస్తుంది, అది, అన్ని హక్కు.

1179
01:17:49,820 --> 01:17:52,630
, పేజీ లోడ్, నేను లో, ఈ మూలకం కనుగొనేందుకు వెళుతున్న

1180
01:17:52,630 --> 01:17:56,420
ఈ కార్యక్రమం నిర్వహణ ఇవ్వాలని మరియు ఇది ప్రాథమికంగా మీరు కోసం మీ పేజీ సెట్స్ అప్.

1181
01:17:56,420 --> 01:18:00,520
ఇది నిజంగా నిర్వహణ గురించి ఆలోచించటం ఎలా ఉంది.

1182
01:18:00,520 --> 01:18:06,310
మీరు కేవలం, ఆలోచించడానికి అన్ని కుడి, ఏదో సంభవించినప్పుడు, నేను జరిగే ఏమి అనుకుంటున్నారు?

1183
01:18:06,310 --> 01:18:10,520
మీరు, సరే, నేను ఈ విషయం ఖచ్చితంగా ఈ విషయం చర్చలు చేయవలసి, గురించి ఆలోచించటం లేదు

1184
01:18:10,520 --> 01:18:14,660
ఈ విషయం బ్లా బ్లా బ్లా, మీరు ఈవెంట్స్ పరంగా విషయం మాట్లాడు ఎందుకంటే.

1185
01:18:14,660 --> 01:18:17,650
ఇది జరిగినప్పుడు, ఈ జరుగుతుంది. ఇది జరిగినప్పుడు, ఆ జరుగుతుంది.

1186
01:18:17,650 --> 01:18:20,240
ఇత విషయాలు ట్రిగ్గర్ ఉంటే, ఆ గొప్ప.

1187
01:18:20,240 --> 01:18:22,150
కానీ మీరు క్లిష్టమైన కోడ్ ప్రయత్నించండి మరియు చేయాలనుకుంటున్నారా లేదు

1188
01:18:22,150 --> 01:18:24,130
మీరు, అదే సమయంలో బహుళ విషయాలు చెందేందుకు చేస్తున్నారు

1189
01:18:24,130 --> 01:18:28,860
మీరు మీరే ఒక తలనొప్పి ఇవ్వాలని ఎందుకంటే.

1190
01:18:28,860 --> 01:18:32,340
>> అన్ని కుడి. ఇప్పుడు మేము మా పేజీ ఈవెంట్స్ నిర్వహించడానికి పొందవచ్చు,

1191
01:18:32,340 --> 01:18:35,640
కాని నా వినియోగదారు ఒక బటన్ను క్లిక్ పిలవబడు.

1192
01:18:35,640 --> 01:18:38,040
నాకు తిరిగి సర్వర్కు ఆ అభ్యర్థన పంపండి అనుకుంటే

1193
01:18:38,040 --> 01:18:41,100
ఒక కొత్త పేజీ రీలోడ్ అవసరం ఎందుకంటే కానీ నేను, పేజీ రీలోడ్ వద్దు

1194
01:18:41,100 --> 01:18:44,390
ప్రతి సమయం దుర్భరమైన గెట్స్, మరియు ఎందుకు నేను చేయాలి

1195
01:18:44,390 --> 01:18:47,430
మళ్ళీ శీర్షిక లాగేందుకు, మళ్ళీ ఫుటర్కు,

1196
01:18:47,430 --> 01:18:49,670
మరియు అన్ని పేజీ యొక్క అంశాలను మళ్ళీ

1197
01:18:49,670 --> 01:18:53,180
కేవలం గ్రీటింగ్ లేదా సమయం రిఫ్రెష్?

1198
01:18:53,180 --> 01:18:55,290
మేము అజాక్స్ లాగ ఎందుకు కాబట్టి ఆ.

1199
01:18:55,290 --> 01:18:59,150
మనం అజాక్స్ తో ఇక్కడ చేయవచ్చు, మేము, అన్ని కుడి చెప్పగలను ఉంది

1200
01:18:59,150 --> 01:19:01,290
నేను సర్వర్కు కొన్ని డేటా పంపాలని,

1201
01:19:01,290 --> 01:19:04,010
మరియు నేను నా పేజీ నవీకరించవచ్చు తిరిగి ఒక స్పందన కావాలి,

1202
01:19:04,010 --> 01:19:12,120
లేదా బహుశా కేవలం తప్పనిసరిగా యూజర్ ఏదైనా చూపించు లేదు కొన్ని క్రమసూత్ర లేక్కించాలంటే.

1203
01:19:12,120 --> 01:19:15,500
మీరు దీన్ని చేయాలి? బాగా, మీరు మాట్లాడటానికి అవసరం ఒక URL అవసరం.

1204
01:19:15,500 --> 01:19:18,650
మీ సర్వర్ కేవలం అద్భుతంగా ఎక్కడా నుండి లో వినడానికి కాదు.

1205
01:19:18,650 --> 01:19:21,960
మీరు ఈ డేటా పంపిస్తున్నాం ఒక నిర్దిష్ట స్థలం కలిగి ఉండాలి.

1206
01:19:21,960 --> 01:19:26,240
మరియు మీరు కూడా పంపడానికి కొన్ని డేటా అవసరం, లేదా బహుశా ఇది ఒక dataless ప్రశ్న ఉంది.

1207
01:19:26,240 --> 01:19:31,380
మీరు హే, నేను సజీవంగా, లేదా అలాంటిదే ఉన్నాను, తిరిగి సర్వర్కు పింగ్ మరియు చెప్పాలనుకోవడం.

1208
01:19:31,380 --> 01:19:35,150
మరియు అప్పుడు మీరు ప్రధానంగా విజయం సంభాలించే ఫంక్షన్ కావలసిన.

1209
01:19:35,150 --> 01:19:38,250
మీరు మీ సర్వర్ నుండి కొంత సమాచారాన్ని తిరిగి పొందడానికి లెట్,

1210
01:19:38,250 --> 01:19:42,960
మరియు మీరు వారి పేజీలో వినియోగదారు యొక్క టైటిల్ మార్చడానికి కావలసిన.

1211
01:19:42,960 --> 01:19:44,930
కాబట్టి మీరు సమాచారాన్ని తిరిగి పొందుతారు,

1212
01:19:44,930 --> 01:19:48,860
మరియు మీరు స్క్రీన్ ఆ పుష్.

1213
01:19:48,860 --> 01:19:51,170
పేజీ సిద్ధంగా ఉంది ఏమి జరుగుతుంది,, ఉంది

1214
01:19:51,170 --> 01:19:56,500
మీరు greeter అని ఈ బటన్ కోసం క్లిక్ ఫంక్షన్ ఒక సృష్టించడానికి.

1215
01:19:56,500 --> 01:19:58,810
బటన్ నెట్టడమే ఏమి ఈ అప్పుడు చేస్తుంది, ఉంది,

1216
01:19:58,810 --> 01:20:03,700
మీరు greetings.php మాట్లాడటానికి, మీరు, ఒక POST అభ్యర్థనను

1217
01:20:03,700 --> 01:20:07,290
మరియు మీరు, నాతో మీ పేజీ నుండి ఏదో చెప్పేది.

1218
01:20:07,290 --> 01:20:09,890
మేము నిజంగా, ఆ కలిగింది, కానీ greetings.php లేదు

1219
01:20:09,890 --> 01:20:12,480
లెట్ యొక్క కేవలం చెప్పే, "హలో వరల్డ్." తిరిగి ఇస్తుంది

1220
01:20:12,480 --> 01:20:15,650
కాబట్టి మేము, ", హలో వరల్డ్" ఈ మళ్లీ వచ్చి ఈ విజయం

1221
01:20:15,650 --> 01:20:20,730
ఏమీ తప్పు వెళుతుంది ఊహించి తర్వాత మేము ఈ లక్ష్యాన్ని స్థలం వెళ్ళండి

1222
01:20:20,730 --> 01:20:25,720
మేము పేర్కొన్న మరియు మేము అక్కడే ప్రతిస్పందన చూసీ.

1223
01:20:25,720 --> 01:20:31,560
మరియు ఈ ఒక అజాక్స్ ప్రశ్న అప్ సెట్ యొక్క అతి సాధారణ మార్గం.

1224
01:20:31,560 --> 01:20:34,340
>> చాలా త్వరగా, రాబ్ విధమైన, ఇప్పటికే వివరించినాడు

1225
01:20:34,340 --> 01:20:37,170
విషయాలు తప్పు వెళ్ళే, చెడు విషయాలు జరుగుతుంది,

1226
01:20:37,170 --> 01:20:42,660
కాబట్టి మీరు ఈ HTTP ప్రతిస్పందన సంకేతాలు మిమ్మల్ని పరిచయం మీరు.

1227
01:20:42,660 --> 01:20:46,030
ఏ వీటిలో ప్రతిదీ ఓకే వెళ్ళింది, 200, వంటి, కేవలం ఉన్నాయి.

1228
01:20:46,030 --> 01:20:48,670
ఏదో, చెడు విషయాల జరిగింది.

1229
01:20:48,670 --> 01:20:50,790
ఇది సాధారణంగా మీరు గుర్తు విషయం.

1230
01:20:50,790 --> 01:20:53,440
కానీ ఈ అన్ని తెలుసు మంచిది.

1231
01:20:53,440 --> 01:20:55,970
చివరకు, ఒకసారి మేము ఆ అన్ని ద్వారా మారారు,

1232
01:20:55,970 --> 01:20:58,680
మేము, డిజైన్ గురించి చాలా త్వరగా మాట్లాడటానికి అవసరం

1233
01:20:58,680 --> 01:21:00,620
మరియు తర్వాత మీరు అన్ని వదిలి తెలియజేయవచ్చు.

1234
01:21:00,620 --> 01:21:03,410
డిజైన్. మీరు గుర్తుంచుకోవాలనుకుంటున్న థింగ్స్.

1235
01:21:03,410 --> 01:21:06,950
ఈ సమాధానం రకం, వస్తారు?

1236
01:21:06,950 --> 01:21:09,580
వారు కోసం ఇది ఉపయోగించబోయే? నా వినియోగదారులు ఏమి శ్రద్ధ లేదు?

1237
01:21:09,580 --> 01:21:11,750
వారు ఏమి గురించి పట్టించుకోను?

1238
01:21:11,750 --> 01:21:14,500
మీరు కేవలం ఒక అనువర్తనం తిరిగేందుకు మరియు పెరుగుతాయి తెలియజేయాలనుకుంటున్నాము లేదు

1239
01:21:14,500 --> 01:21:18,270
మరియు ఈ దిగ్గజం, మీరు కూడా పూర్తి కాదు అన్ని వినియోగించే విషయం మారింది.

1240
01:21:18,270 --> 01:21:23,900
మీరు కావలసిన వివిక్త లక్ష్యాలను మరియు ప్రణాళికలు మరియు విషయాలు కావాలి.

1241
01:21:23,900 --> 01:21:29,000
అది అప్రయత్నంగా చేయండి. ఈ అన్ని, ప్రధానంగా, చెప్పారు

1242
01:21:29,000 --> 01:21:34,950
సులభం యూజర్ ఉపయోగించడానికి కోసం చేయుము నిజానికి, ఈ స్లయిడ్ వంటి టెక్స్ట్ యొక్క ఒక భారీ బొట్టు ఉంది చేయటం లేదు.

1243
01:21:34,950 --> 01:21:38,020
మీరు కేవలం అది ఎవరైనా లో వెళ్ళడానికి కోసం చాలా సులభం ఉన్న ఏదో ఉండాలనుకుంటున్నాను

1244
01:21:38,020 --> 01:21:40,800
మరియు వారు చేయాలనుకుంటున్నారా ఏమి.

1245
01:21:40,800 --> 01:21:42,920
మీరు వాటిని 5 పేజీలను నావిగేట్ ఉంటుంది వద్దు

1246
01:21:42,920 --> 01:21:45,460
మీ సైట్ యొక్క మీ ప్రధాన పని చెయ్యడానికి.

1247
01:21:45,460 --> 01:21:49,290
Google ముందు 5 పేజీలను కలిగి ఉంటే మీరు కూడా ఏదో శోధించండి కాలేదు,

1248
01:21:49,290 --> 01:21:53,080
ఎవరూ దానిని ఉపయోగించే.

1249
01:21:53,080 --> 01:21:55,890
చివరికి, కాగితం నమూనా, దృష్టి సమూహం.

1250
01:21:55,890 --> 01:21:59,220
మంచి డిజైన్ మరియు పరీక్ష పద్ధతులు ఉన్నాయి.

1251
01:21:59,220 --> 01:22:00,730
మీరు కోసం పనిచేస్తుంది భావించడం వలన,

1252
01:22:00,730 --> 01:22:04,860
ఎవరైనా అది పనిచేస్తుంది ఆలోచించడం కాదు.

1253
01:22:04,860 --> 01:22:14,490
కానీ అవును, అంతే.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]