1
00:00:00,000 --> 00:00:02,270
>> [Review: Quiz 1]

2
00:00:02,270 --> 00:00:04,620
[Али Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Боудън] [Harvard University]

3
00:00:04,620 --> 00:00:07,660
[Това е CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Добре дошли на всички. Това е преглед на викторина 1.

5
00:00:11,610 --> 00:00:15,040
Точно както един отказ от права, това е - Искам да кажа, ние ще се опитаме да покрие

6
00:00:15,040 --> 00:00:17,770
толкова материал, колкото е възможно, но това не означава, че

7
00:00:17,770 --> 00:00:20,780
отиваме за покриване на всички от нещата, които могат да бъдат в една викторина.

8
00:00:20,780 --> 00:00:25,270
Така че бъдете сигурни, че също така да погледнете на лекция, раздели, всичко, което можете.

9
00:00:25,270 --> 00:00:28,240
Quiz 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
На първо място, това, което ние искаме вие ​​да знаят за викторина едно е да

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
прилагане на хеш таблица в една викторина.

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
или ще трябва да използвате изчистване да има гъвкава дължина на масив.

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
Вие просто трябва да бъдат внимателни, за да винаги да помним, да изчистване и безплатни възли,

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
Сложих Int N, но вие може да се съхранява всички данни, които искате.

44
00:02:35,110 --> 00:02:37,280
Така че, ако искате да съхранявате низ, всичко е наред.

45
00:02:37,280 --> 00:02:41,690
Ако искате да запазите структурата, всичко е наред, двойна, каквото си искате.

46
00:02:41,690 --> 00:02:44,630
Пуснах Int н за примерите тук.

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
Ако това е последният елемент в свързан списък, че ще ходи да сочи към NULL.

50
00:02:56,710 --> 00:02:59,060
Така че това е един пример за свързан списък.

51
00:02:59,250 --> 00:03:05,960
>> Добре, така че сега нека да видим какво трябва да направя, ако искам да вмъкнете елемент в свързан списък.

52
00:03:05,960 --> 00:03:08,810
Първо, функция вложка ще бъде от тип нищожен

53
00:03:08,810 --> 00:03:11,350
защото аз не искам да се върне нищо.

54
00:03:11,350 --> 00:03:14,200
И аз ще взема едно цяло число като аргумент,

55
00:03:14,200 --> 00:03:17,090
защото аз искам да знам какво искам да вмъкнете.

56
00:03:17,090 --> 00:03:21,840
И така, какво е първото нещо, което трябва да правя? Е, аз трябва да изчистване на newnode,

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
разликата е, че този възел е създаден с помощта изчистване,

87
00:05:13,430 --> 00:05:17,280
така че е в купчината, докато тази е била обявена просто като превключвател NULL в стека.

88
00:05:17,280 --> 00:05:20,000
Така че не е нужно да го освободи.

89
00:05:20,000 --> 00:05:22,030
>> Добре. Така че сега нека поговорим за стакове.

90
00:05:22,030 --> 00:05:24,680
Stacks са доста прости.

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
A комин, на първо място, ще трябва да имат размери.

96
00:05:46,810 --> 00:05:49,950
Вие трябва да се съхранява, какъв е размерът на стека, че имате точно сега.

97
00:05:49,950 --> 00:05:52,980
А също така можете да имате масив, в този случай на номера,

98
00:05:52,980 --> 00:05:55,120
но ако искате, може да бъде масив

99
00:05:55,120 --> 00:06:00,380
от низове, масив от структура, нещо, което искате да съхраните.

100
00:06:00,380 --> 00:06:03,240
За стека: Разликата между комин и свързан списък

101
00:06:03,240 --> 00:06:08,590
е, че в стека имате достъп до последния елемент, който е бил пуснат в стека само.

102
00:06:08,590 --> 00:06:11,770
Тя се нарича последно, първи излязъл.

103
00:06:11,770 --> 00:06:15,090
Точно като имате куп тави,

104
00:06:15,090 --> 00:06:17,670
ако ви постави поднос на върха на купчината,

105
00:06:17,670 --> 00:06:22,670
трябва да се премахне тази тава първо да имат достъп до други тавите.

106
00:06:22,670 --> 00:06:26,310
Това е едно и също нещо с стакове.

107
00:06:26,310 --> 00:06:31,220
Така че, ако искате, например, да добавите елемент към стека, какво трябва да направя?

108
00:06:31,220 --> 00:06:34,070
Нарича се бута, а това е доста ясен.

109
00:06:34,070 --> 00:06:37,130
Първото нещо, което трябва да направите, е да проверява дали размерът на стека

110
00:06:37,130 --> 00:06:40,150
не е по-голяма или равна на тази на пакета.

111
00:06:40,150 --> 00:06:45,810
Защото, ако вече сте на пълен капацитет, не можете да добавите още нещо.

112
00:06:45,810 --> 00:06:51,140
И след това, ако не, просто трябва да добавите елемент към стека.

113
00:06:51,140 --> 00:06:54,530
И накрая, нарастване на размера. Така че това е доста ясен.

114
00:06:54,530 --> 00:06:57,140
Така че аз просто добавете номер 2.

115
00:06:57,140 --> 00:07:00,350
И ако искам да се появи, което означава, че искам да се отстрани

116
00:07:00,350 --> 00:07:03,870
последният елемент, който се прибавя и връща стойността на елемента,

117
00:07:03,870 --> 00:07:09,180
първото нещо, което трябва да проверите е, че топчето не е празна.

118
00:07:09,180 --> 00:07:11,510
Защото, ако е празна, не може да се върне нищо.

119
00:07:11,510 --> 00:07:14,820
В този случай, аз връщам -1.

120
00:07:14,820 --> 00:07:18,960
В противен случай, аз ще декрементира размера на спецификацията,

121
00:07:18,960 --> 00:07:22,510
и да се върнете номера (s.size).

122
00:07:22,510 --> 00:07:27,230
Защо съм декрементира размера и след това се върнете s.size?

123
00:07:27,230 --> 00:07:30,930
Това е така, защото в този случай, спец. има размер 4,

124
00:07:30,930 --> 00:07:33,810
и аз искам да се върне на четвърти елемент, нали?

125
00:07:33,810 --> 00:07:36,030
Но това, което е индексът на четвъртия елемент? Три.

126
00:07:36,030 --> 00:07:44,510
Тъй като аз си размер - ще бъде 3, мога само да се върне s.numbers (s.size)

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
Enqueue е същото нещо като тласък за стакове.

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
Опитвам се да Enqueue куп неща,

148
00:08:57,020 --> 00:08:58,390
и след това аз ще dequeue и Enqueue.

149
00:08:58,390 --> 00:09:00,550
Има много команди, но това е много проста.

150
00:09:00,550 --> 00:09:04,790
Отивам да Enqueue 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
Сега, ако се опитам да Enqueue нещо друго, какво ще се случи?

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
Ако се опитам да Enqueue един точно тук, бих се презаписване на последната позиция

161
00:09:43,900 --> 00:09:45,870
до номер 1, което е напълно погрешно.

162
00:09:45,870 --> 00:09:49,870
Това, което искам да направите, е да обгърне и да преминете към първата позиция.

163
00:09:49,870 --> 00:09:52,870
Може би просто ще кажа, добре, аз просто трябва да се провери

164
00:09:52,870 --> 00:09:55,600
ако действително мога да сложа нещо там.

165
00:09:55,600 --> 00:09:58,560
Ако не, аз само да кажа, о, новият пълния капацитет

166
00:09:58,560 --> 00:10:02,010
всъщност капацитет - 1, и вие не може да се сложи елемент там.

167
00:10:02,010 --> 00:10:06,150
Но какъв е проблемът? Проблемът е, че ако аз просто dequeue всичко точно тук

168
00:10:06,150 --> 00:10:08,240
и след това се опитам да добавя нещо друго, тя просто ще кажа,

169
00:10:08,240 --> 00:10:11,210
добре, ти беше с пълен капацитет, което е 0.

170
00:10:11,210 --> 00:10:13,620
Така че вашата опашка е отишъл.

171
00:10:13,620 --> 00:10:16,990
Трябва да обгърне, и начин за опаковане на около

172
00:10:16,990 --> 00:10:22,040
че вие, момчета, научени по време визионерски и други psets е използвал мод.

173
00:10:22,040 --> 00:10:29,090
Можете да го изпробвате у дома, за да се разбере защо бихте направили q.size + q.head

174
00:10:29,090 --> 00:10:31,080
Министерството на отбраната на капацитет, но ако ви се покажат точно тук,

175
00:10:31,080 --> 00:10:34,760
можем да видим, че тя работи.

176
00:10:34,760 --> 00:10:37,760
Така че в последния пример, q.size е 8

177
00:10:37,760 --> 00:10:47,590
и главата е едно, защото тя е тази позиция тук на масива.

178
00:10:47,590 --> 00:10:51,970
Така ще бъде 8 + 1, 9. Mod капацитет 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
В дома, опитайте се да получите много добре запознати с прилагането Enqueue, dequeue, бута и поп.

183
00:11:11,620 --> 00:11:16,560
И също така да разберат, когато можете да използвате всеки един от тях.

184
00:11:16,560 --> 00:11:22,830
>> Така че нека да се отпуснете за 10 секунди с един куп Pokemons.

185
00:11:22,830 --> 00:11:26,080
А сега нека се върнем към структури от данни.

186
00:11:26,080 --> 00:11:29,770
Hash таблици. Много хора са уплашени от хеш таблици.

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
[Rob Боудън] Проблем комплект 5. >> Проблем комплект 5, да. Благодарение Роб.

191
00:11:41,490 --> 00:11:43,370
Да. Six беше Huff N 'Puff, да.

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
Какво е хеш таблица, в общи линии? A хеш таблица е масив от свързани списъци.

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
Ако, например, ако искате да изберете за Б. Харисън,

204
00:12:31,740 --> 00:12:34,190
Бих поставил Б. Харисън в моите хеш функции,

205
00:12:34,190 --> 00:12:36,960
и функцията за сегментиране ще се върне 24.

206
00:12:36,960 --> 00:12:40,930
Така че аз знам, че искате да съхранявате Б. Харисън в 24.

207
00:12:40,930 --> 00:12:46,580
Така че това е разликата между просто като една решетка и с хеш таблица.

208
00:12:46,580 --> 00:12:48,740
В хеш таблицата ще имате функция, която ще ви кажа

209
00:12:48,740 --> 00:12:54,740
къде да се съхраняват данните, които искате да съхраните.

210
00:12:54,740 --> 00:12:57,040
За хеш функция, която искате да търсите за хеш функция

211
00:12:57,040 --> 00:13:00,600
че е детерминирана и добре разпределен.

212
00:13:00,600 --> 00:13:07,810
Както можете да видите тук, ще видите, че много от данните, които съм искал да магазин всъщност беше 19

213
00:13:07,810 --> 00:13:12,470
вместо да се използва 31 и 30 и 29, всички, които са били свободни.

214
00:13:12,470 --> 00:13:16,920
Така че функцията на хашиш, че аз използвах не беше много добре разпределен.

215
00:13:16,920 --> 00:13:20,710
Когато казваме, добре разпределени, това означава, че искаме да имаме,

216
00:13:20,710 --> 00:13:26,520
приблизително, най-малко 1 или 2 за всеки от -

217
00:13:26,520 --> 00:13:32,190
като, за разлика от 1 или 2 за всеки от индексите в масиви.

218
00:13:32,190 --> 00:13:43,950
Вие искате да има, грубо, същия брой елементи във всеки свързан списък в масива.

219
00:13:43,950 --> 00:13:48,600
И това е лесно да се провери дали това е валидно в хеш таблица, видите като хеш таблици.

220
00:13:48,600 --> 00:13:51,770
>> Тогава дървета. Това е дърво.

221
00:13:51,770 --> 00:13:56,400
Дърветата в компютърните науки са обърнати по някаква причина.

222
00:13:56,400 --> 00:14:00,150
Така че тук имате корена на дървото и след това листата.

223
00:14:00,150 --> 00:14:05,630
Ти просто трябва да знаеш номенклатурата за родители и деца.

224
00:14:05,630 --> 00:14:12,880
Всеки възел има своите деца, които са възлите, които са под родителя.

225
00:14:12,880 --> 00:14:19,660
Така че, например, два ще бъде на родителя за 3, и за другото дете точно там,

226
00:14:19,660 --> 00:14:25,290
а 3 ще бъде на родителя за един и другите деца, които са там.

227
00:14:25,290 --> 00:14:29,990
И един ще бъде дете на 3, и така нататък.

228
00:14:29,990 --> 00:14:34,610
Ние имаме нещо много по-интересно, нарича двоично търсене дърво,

229
00:14:34,610 --> 00:14:39,040
в което всички стойности на правото на възел

230
00:14:39,040 --> 00:14:41,660
ще бъде от дясно, точно тук - в дясно,

231
00:14:41,660 --> 00:14:46,780
ще бъде по-голяма, отколкото на елемента в корена.

232
00:14:46,780 --> 00:14:49,780
Така че, ако са с номер 5, точно тук, всички елементи на правото

233
00:14:49,780 --> 00:14:51,940
ще бъде по-голяма от 5, и в ляво

234
00:14:51,940 --> 00:14:56,770
всички елементи ще бъдат по-малко от 5.

235
00:14:56,770 --> 00:14:58,780
Защо е полезно това?

236
00:14:58,780 --> 00:15:01,660
Е, ако искам да се провери дали числото 7 е тук, например,

237
00:15:01,660 --> 00:15:05,960
Просто отидете на пет първи и аз отивам да видя, е 7-голямо или по-малко от 5?

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
>> Как мога да приложи намерите за BST?

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
[Student говорене, недоловим]

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.

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
Преди тук аз съм просто ще използват два, защото искам да бъде в състояние да напише на дъската.

294
00:18:17,800 --> 00:18:20,230
Добре. Така че това е един пример на опит.

295
00:18:20,230 --> 00:18:25,600
Ако аз просто определят първия възел, ще има масив от два елемента

296
00:18:25,600 --> 00:18:29,290
, които са две указатели към NULL, така че аз просто сложи "а" и "б".

297
00:18:29,290 --> 00:18:32,430
И аз отивам да има булев, която казва is_word.

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
Бих просто трябва да изчистване на нов възел за "а",

303
00:18:49,760 --> 00:18:54,630
и след това да добавите своя дума, за да е истина.

304
00:18:54,630 --> 00:19:00,180
Така че това просто означава, че след като "а", ще бъде вярно. Направи ли смисъл?

305
00:19:00,180 --> 00:19:04,120
След това, ако искате да добавите "ба", аз ще трябва да изчистване 1 за "б",

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
Тогава аз ще изчистване още един за "а", така че "ба",

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
Мога просто да отидете до първия милион, 'B'. Сляза и аз гледам е дума, но тя казва неверни.

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
>> Накрая, кодиране на Huffman. Huffman кодиране е много полезен

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
Ако имате само един байт за всеки един символ,

321
00:20:02,040 --> 00:20:08,520
всеки един - от 256 знака, които имаме в таблицата на ASCII не е много оптимални,

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
 A Хъфман дърво има възли

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
и след това възлова точка, която ще се отбележи от ляво на дървото Huffman

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
Отиваш да вземем две възли, които имат най-ниските честоти.

334
00:20:54,020 --> 00:20:56,490
Ако имате вратовръзка ти започваш да вземем две възли

335
00:20:56,490 --> 00:20:59,870
които имат най-ниските стойности на ASCII, както добре.

336
00:20:59,870 --> 00:21:02,420
Тогава започваш да създадете нова дърво от тези две възли

337
00:21:02,420 --> 00:21:08,030
че ще има комбинираната честота в родител възел.

338
00:21:08,030 --> 00:21:13,240
И тогава започваш да се премахнат две деца от гората

339
00:21:13,240 --> 00:21:15,570
и да ги замени с родителя.

340
00:21:15,570 --> 00:21:18,930
И ти започваш да се повтаря, че докато имате само едно дърво в гората.

341
00:21:18,930 --> 00:21:23,840
Така че нека да видим как ще се направи Хъфман дърво за ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Тук можете да видите, че всички писма имат честота 1 с изключение на 'A'; който има честота 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
"А" и "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 и се движи вдясно е един,

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
Така един, 0, така че просто един, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
И след 0, 1, така че "Z".

360
00:22:47,540 --> 00:22:52,170
И тогава един, 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
>> [Rob Боудън] Така, седмица 7 неща.

364
00:23:08,400 --> 00:23:11,390
Имаме много да отидем много по-бързо.

365
00:23:11,390 --> 00:23:13,430
Побитови оператори, препълване на буфера,

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
Побитови оператори. Има шест от тях, които трябва да знаете.

369
00:23:24,330 --> 00:23:31,200
Побитовото и побитови или, XOR, олевяване, нали смени, и не.

370
00:23:31,200 --> 00:23:35,420
Right смени и не можете едва видях в лекция на всички.

371
00:23:35,420 --> 00:23:40,480
Ние ще го прегледаме бързо тук, но това е добре да се знае, че те са шест, които съществуват.

372
00:23:40,480 --> 00:23:45,070
Не забравяйте, че побитовите оператори са като когато правите 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Не се занимаваме с двоичен на 3 и 4.

374
00:23:49,420 --> 00:23:56,550
С побитови оператори, вие всъщност се занимава с отделните битове на числата 3 и 4.

375
00:23:56,550 --> 00:23:59,120
>> Така че първият, който ще каже, е побитова не,

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
и след това ще флип двоичното представяне на четири.

380
00:24:12,970 --> 00:24:24,800
Така че тук, ~ на някои двоично число 1101101 ще точно флип всички 1 на 0 и всички 0 до 1 години.

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
>> Побитово или. Тук са две двоични числа, и тези две числа

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
Така че от лявата страна имаме едно и едно.

393
00:25:15,410 --> 00:25:20,510
Когато побитови | тези, аз какво ще получа? One.

394
00:25:20,510 --> 00:25:25,320
Тогава побитови | 0 и 1 ще ми дадеш? One.

395
00:25:25,320 --> 00:25:27,840
Побитовото 1 и 0 ще бъде едно и също нещо, едно.

396
00:25:27,840 --> 00:25:31,880
Побитовото 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
Така че, ако мислите, че на един толкова вярно и 0 като фалшиво, същото важи тук.

400
00:25:44,830 --> 00:25:50,040
Така че, вярно или вярно е вярно; вярно или невярно е вярно.

401
00:25:50,040 --> 00:25:57,150
False или вярно е вярно; невярна или фалшива е единственото нещо, което всъщност е фалшива.

402
00:25:57,150 --> 00:26:00,100
Ето и пример, който трябва да знаете

403
00:26:00,100 --> 00:26:05,160
като един доста добър пример за това, когато се използва побитови оператори.

404
00:26:05,160 --> 00:26:08,660
Тук, ако ние или капитал "А" с Ox20,

405
00:26:08,660 --> 00:26:11,830
и ние ще разгледаме това в секунда, ние се получи нещо.

406
00:26:11,830 --> 00:26:16,020
И ако ние или малки букви "а" с Ox20, ние получаваме нещо.

407
00:26:16,020 --> 00:26:26,750
Така че нека да спра ASCII таблица.

408
00:26:26,750 --> 00:26:34,000
Добре. Тук ние виждаме, че "А" е -

409
00:26:34,000 --> 00:26:36,920
тук имаме "A" е десетични 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
Това е един кът, две на място, четири на място, така че това е 4.

416
00:27:03,620 --> 00:27:08,550
Тогава можете да разделите един в двоичен, който ще бъде 0001.

417
00:27:08,550 --> 00:27:14,280
И така, това ще бъде представянето на 'A' в двоичен.

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.

421
00:27:37,830 --> 00:27:48,220
Ox61. Така че разделянето 6 в двоичен ще е 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
И цепене 1 ще бъде 0001.

423
00:27:54,610 --> 00:27:56,520
С поглед към разликата между тези две,

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
Ако аз или "A", който е тази, 'A',

432
00:28:47,610 --> 00:28:50,580
ако аз или "A" с Ox20,

433
00:28:50,580 --> 00:28:53,490
аз какво ще получа?

434
00:28:53,490 --> 00:28:58,960
[Student, недоловим] >> Малки букви "а", защото то се случва да обърне тази част до един.

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
Аз съм просто ще се oring този единствен бит до 1, то е вече един, така че няма значение.

438
00:29:14,580 --> 00:29:17,960
Така че ние се "а" и "а".

439
00:29:17,960 --> 00:29:24,820
>> Побитово и. Отново, можем да мислим за това като ни логично и колега.

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
Така че сега, тук, тук е мястото, където съм използвал надежден Побитовото не,

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
Сега това, което искам да направя, побитова ~ на 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
И така, "A" anded с ~ Ox20 ще ми даде това?

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
тогава започваш да се получи точно това, което 'A' е,

455
00:30:29,000 --> 00:30:31,260
с изключение, може би, това, което този бит е.

456
00:30:31,260 --> 00:30:34,460
Защото, ако това беше едно, сега това ще бъде настроен на 0,

457
00:30:34,460 --> 00:30:39,810
защото каквото и да е, anded с това ще бъде 0.

458
00:30:39,810 --> 00:30:43,280
Така че това, което е "A" & ~ 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
"A." Тъй като това е в момента с 1.

462
00:30:56,720 --> 00:30:59,570
Anding с този 0 ще направи го на 0,

463
00:30:59,570 --> 00:31:02,530
а сега отиваме да се получи 'A'.

464
00:31:02,530 --> 00:31:06,600
>> И двете са "A", и накрая, но не на последно място от този тип,

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 ще бъде 0.

470
00:31:28,700 --> 00:31:33,650
Тъй вярно, това е - тя не работи, както и с логическата истина и лъжа

471
00:31:33,650 --> 00:31:37,150
като побитови & и или направя,

472
00:31:37,150 --> 00:31:40,100
но е истина ^ вярно е фалшива.

473
00:31:40,100 --> 00:31:44,810
Защото ние искаме само да се върне вярно, ако само един от тях е вярно.

474
00:31:44,810 --> 00:31:50,950
Така 1 ^ 1 е 0. Какво около 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
Е 1. 1 ^ 0 е 1, 0 ^ 0 е 0.

476
00:31:56,010 --> 00:32:03,890
Така че, при всички обстоятелства, 0 побитова нещо 0 ще бъде 0.

477
00:32:03,890 --> 00:32:10,270
1 побитова нещо 0 или 0 побитова 1,

478
00:32:10,270 --> 00:32:14,660
ако това е | или ^, това ще бъде един, и ако това е и ще бъде 0.

479
00:32:14,660 --> 00:32:20,850
И единственият случай, когато един побитова 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
'A' ^ Ox20 е тези два бита сме сравняващи.

483
00:32:43,480 --> 00:32:50,020
Така че един милион ^ 0 ще ми даде това, което? А една.

484
00:32:50,020 --> 00:32:58,430
'A' ^ Ox20 ще ми дадеш? Малки букви а.

485
00:32:58,430 --> 00:33:04,010
"А" ^ Ox20 ще ми дадеш? Capital A.

486
00:33:04,010 --> 00:33:09,310
Защото каквото и да се прави, това XORing с Ox20

487
00:33:09,310 --> 00:33:15,380
е ефективно обръщане каквото и да е малко.

488
00:33:15,380 --> 00:33:21,240
Ако това е 0, това е сега ще се превърне в едно.

489
00:33:21,240 --> 00:33:26,160
Тъй като това е 1, 1 ^ 1 е 0.

490
00:33:26,160 --> 00:33:33,280
Така че нашата "а" се превърна 'A', и нашата "А" е станала "а".

491
00:33:33,280 --> 00:33:36,910
Така че XOR е наистина удобен начин просто обръщане на случая.

492
00:33:36,910 --> 00:33:39,960
Вие просто искате да превъртите през поредица от букви

493
00:33:39,960 --> 00:33:44,330
и се редуват случая на всеки един символ,

494
00:33:44,330 --> 00:33:50,680
просто XOR всичко с Ox20.

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 лявата изместен с три, което ни дава 104.

502
00:34:24,699 --> 00:34:32,530
Така че лявата променяща се, ние виждаме тук, х << г. е основно х * 2 ^ ш.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 е 8, така че 13 * 8 е 104.

504
00:34:40,139 --> 00:34:45,679
Ако просто мисля за двоичен като цяло, как всяка цифра,

505
00:34:45,679 --> 00:34:49,530
ако започнем от правото, това е едно на място, а след това на два на място, а след това на 4 на място.

506
00:34:49,530 --> 00:34:51,330
Така чрез натискане на 0 е отдясно,

507
00:34:51,330 --> 00:34:55,080
ние просто бутане неща, които бяха в 4 на мястото на 8 на място,

508
00:34:55,080 --> 00:34:57,920
и нещата, които са били в 8 на място на 16 на мястото си.

509
00:34:57,920 --> 00:35:01,280
Всяка промяна просто умножава по 2. Да?

510
00:35:01,280 --> 00:35:05,210
[Student] Какво се случва, ако изместен от 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
така че ако можете да добавите два наистина големи числа, той просто не се вписва в цяло число.

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
Това прави 104 >> 3, което е ефективно, х / 2 ^ ш.

525
00:36:08,380 --> 00:36:11,200
Така че сега, ето, това е подобна идея.

526
00:36:11,200 --> 00:36:18,720
Защо това е просто грубо х / 2 ^ Y, а не действително х / 2 ^ ш?

527
00:36:18,720 --> 00:36:22,240
Защото ако бях изместен от 4, щях да загубя 1.

528
00:36:22,240 --> 00:36:25,950
По принцип, това, което се сетиш, просто мисля за целочислено деление като цяло.

529
00:36:25,950 --> 00:36:31,070
Така че, като 2.5 е 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
Така че сега - това е за побитова. Това е всичко, което трябва да знаете.

533
00:36:43,870 --> 00:36:46,340
Не забравяйте използването случаи, които видяхме в клас,

534
00:36:46,340 --> 00:36:49,340
като малко маска е полезна за побитови оператори,

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
тя просто ще напълно - "C", "C" не се интересува, че е само на 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,0 милиарда на дъното.

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
Така че забележите, отново, Little Indian.

570
00:39:26,170 --> 00:39:28,490
Уредът е пример за Little Indian система,

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
Ние не променят шестнадесетични цифри в Little Indian,

576
00:39:50,640 --> 00:39:56,110
защото две шестнадесетични цифри правят един байт, и ние се обърне байтове.

577
00:39:56,110 --> 00:40:00,300
Ето защо ние не съхраняваме, като, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Ние съхранява, вместо, всяка двойка от две цифри, като се започне от право.

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
Ако искаха, можеха просто да направим нещо по сегменти грешки, но това би било безсмислено.

589
00:40:51,440 --> 00:40:54,950
Те обикновено го направя, за да проникна вашата система.

590
00:40:54,950 --> 00:40:59,930
>> Добре. CS50 библиотека.

591
00:40:59,930 --> 00:41:04,800
Това е, общо взето, getInt, getString, всички тези функции, ние, предвидени за вас.

592
00:41:04,800 --> 00:41:10,630
Така че ние имаме Чар * низ, и това е абстракция, че ние отвя

593
00:41:10,630 --> 00:41:12,450
в някакъв момент по време на семестъра.

594
00:41:12,450 --> 00:41:18,220
Не забравяйте, че низ е просто един набор от знаци.

595
00:41:18,220 --> 00:41:23,240
Така че тук ние виждаме съкратена версия на getString.

596
00:41:23,240 --> 00:41:25,920
Трябва да погледнем назад към това да се помни, как се прилага на практика.

597
00:41:25,920 --> 00:41:30,950
Ключови подробности са, забележете, ние получите в един символ в даден момент

598
00:41:30,950 --> 00:41:34,570
от стандарт, който е точно като нас, пишете на клавиатурата.

599
00:41:34,570 --> 00:41:37,890
Така че един символ в даден момент, и ако получим твърде много герои,

600
00:41:37,890 --> 00:41:40,580
така че ако N + 1 е по-голяма от капацитета,

601
00:41:40,580 --> 00:41:44,140
тогава ние трябва да се увеличи капацитетът на нашия буфер.

602
00:41:44,140 --> 00:41:47,780
Така че тук ние сме удвояване на размера на нашия буфер.

603
00:41:47,780 --> 00:41:51,840
И това продължава да работи, ние да го вмъкнете в нашия буфер

604
00:41:51,840 --> 00:41:56,220
докато не получа нова линия или в края на файл или каквото и да,

605
00:41:56,220 --> 00:41:59,380
като в този случай, ние сме готови с въжето и след това реално getString

606
00:41:59,380 --> 00:42:05,120
свива паметта, като, ако ние разпределя прекалено много памет, че ще се върна и да се свие малко.

607
00:42:05,120 --> 00:42:08,830
Така че ние не показваме това, но основната идея е

608
00:42:08,830 --> 00:42:11,960
тя трябва да се чете в един символ в даден момент.

609
00:42:11,960 --> 00:42:17,140
Не може просто да прочетете в цялата работа наведнъж,

610
00:42:17,140 --> 00:42:19,550
защото тяхната буфер е само на определен размер.

611
00:42:19,550 --> 00:42:26,590
Така че, ако низа, че той се опитва да вмъкнете в буфер е твърде голям, а след това ще прелее.

612
00:42:26,590 --> 00:42:28,940
Така че тук можем да предотвратим, че само с четене на един символ

613
00:42:28,940 --> 00:42:33,750
в даден момент и отглеждане, когато имаме нужда да.

614
00:42:33,750 --> 00:42:40,270
Така getInt и други библиотечни функции CS50 са склонни да използват getString

615
00:42:40,270 --> 00:42:42,310
в техните реализации.

616
00:42:42,310 --> 00:42:45,370
Така че аз подчерта важните неща тук.

617
00:42:45,370 --> 00:42:49,460
Той призовава getString да получите низ.

618
00:42:49,460 --> 00:42:51,710
Ако getString не успя да се върне паметта,

619
00:42:51,710 --> 00:42:54,270
не забравяйте, че getString mallocs нещо, така че всеки път, когато ти се обадя getString

620
00:42:54,270 --> 00:42:57,820
Вие не трябва да (неразбираемо) освободи че низ, че имаш.

621
00:42:57,820 --> 00:43:02,870
Така че тук, ако той не успя да изчистване нещо, връщаме 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
Така че забележите ние повторен опит, ако съвпада с нищо, но един.

634
00:43:49,780 --> 00:43:55,230
Така че, ако влезе 1, 2, 3, C, или 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
HyperText Markup Language е структурата и семантиката на мрежата.

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
скрипт е пример за това как можете да се свържете външен JavaScript.

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
Така че да е версията, когато нещо стане постави в URL адреса.

652
00:45:09,040 --> 00:45:11,680
POST е мястото, където това не се поставя в 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
Вие никога няма да бъде в състояние да маркирате URL на POST

659
00:45:40,660 --> 00:45:44,970
тъй като данните не са включени в URL адреса.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, сега, е HyperText Transfer Protocol.

661
00:45:49,790 --> 00:45:54,080
Протокол за трансфер на хипертекст, което бихте очаквали да прехвърляте

662
00:45:54,080 --> 00:45:57,710
HyperText Markup Language, и го прави.

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 е само на езика на World Wide Web.

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
След това ние виждаме, че това е GET, алтернативата е POST, за да видиш.

671
00:46:30,110 --> 00:46:40,790
И адреса, че аз се опитвах да посетите беше www.google.com/search?q = дрън, дрън, дрън.

672
00:46:40,790 --> 00:46:44,240
Така че не забравяйте, че това, въпросителен знак на Q = бла бла бла,

673
00:46:44,240 --> 00:46:49,040
е от онези неща, които е подадено от форма.

674
00:46:49,040 --> 00:46:51,830
В отговор той може да се върне при мен ще изглежда нещо като това.

675
00:46:51,830 --> 00:46:54,050
Отново, като се започне с протокола, който ще бъде, че,

676
00:46:54,050 --> 00:46:59,190
последван от кода на състоянието. Ето това е 200 OK.

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 Forbidden, 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.

688
00:47:43,050 --> 00:47:47,550
Не забравяйте, че има интернет извън World Wide Web.

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 буквално означава Internet Protocol.

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, Domain Name Service,

698
00:48:29,060 --> 00:48:33,410
това е, което се превежда неща като google.com до едно действително IP адрес.

699
00:48:33,410 --> 00:48:37,700
Така че, ако напишете, че IP адрес в URL,

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
Последното нещо, което имаме, е пристанища, където това е част от TCP IP.

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
но компютърът разполага само с един WiFi карта или нещо такова.

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
Всяко заявление получава един специфичен порт, който тя може да слушате на,

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, Cascading Style Sheets.

716
00:49:32,010 --> 00:49:36,030
Ние стил уеб страници с CSS, а не с HTML.

717
00:49:36,030 --> 00:49:38,440
Има три места, можете да поставите вашия CSS.

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
Footer е вътре в тялото.

728
00:50:13,180 --> 00:50:16,470
Тя ще, вместо това, подравняване на текста наляво, въпреки че тялото казва подравняване на текста център.

729
00:50:16,470 --> 00:50:18,880
Това е цяло каскаден част от него.

730
00:50:18,880 --> 00:50:22,110
Вие може да има - можете да зададете стилове за тялото,

731
00:50:22,110 --> 00:50:25,320
и след това нещата в организма, можете да зададете по-конкретни стилове,

732
00:50:25,320 --> 00:50:28,160
и нещата работят според очакванията ви.

733
00:50:28,160 --> 00:50:34,420
По-специфични CSS спецификатори имат предимство.

734
00:50:34,420 --> 00:50:46,140
Мисля, че това е всичко.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Здравейте всички. Ако можех просто да привлече вниманието ви.

736
00:50:49,260 --> 00:50:53,990
Аз съм Али и аз отивам да мине през PHP и SQL наистина бързо.

737
00:50:53,990 --> 00:51:00,310
Така че можем да започнем. PHP е съкращение от PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
И тъй като всичко, което трябва да знаете, че това е от страна на сървъра скриптов език,

739
00:51:03,730 --> 00:51:06,800
и ние го използваме за задния край на уеб сайтове,

740
00:51:06,800 --> 00:51:12,540
и как го прави много изчисления, зад кулисите част на.

741
00:51:12,540 --> 00:51:17,510
Синтаксис. Това не е като 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
Така че не може просто да бъде като C, където можете вид го постави на първо място.

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
Вие не - за разлика от C, не е нужно да се сложи какъв тип променлива е то.

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
Можете да съхранявате на вашия номер едно като едно цяло число,

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
Добре, няма четири равни знаци, но има 2 и 3.

767
00:52:49,990 --> 00:52:53,320
Можете да използвате две равни знаци, за да се покажат стойностите.

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
Така че вашата Int и си низ са както технически, 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
>> String конкатенация е друг мощен нещо, което може да се използва в 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
Така че, ако имате котка и имате куче, а вие искате да поставите две струни заедно,

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, има два различни масиви.

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
Редовни масиви са просто тази в C,

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
и така можете да видите, че има шест, има 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 се отпечатва. Cool?

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 петно,

808
00:54:59,190 --> 00:55:02,690
на два отиде право там в първия място.

809
00:55:02,690 --> 00:55:04,690
The 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
В C имаме вериги, които работят по този начин.

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
Сега ние използваме foreach цикли, които, отново, да се надяваме, използвани в PSET 7.

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 брой ще проведе една, и тогава може би ще се проведе под номер 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, така че ще премине на линия за, и това ще отпечата две.

868
00:58:29,860 --> 00:58:35,100
Тогава ще се отбележи, че 3 не е по-малко от 3, така че ние ще избягаме от за линия.

869
00:58:35,100 --> 00:58:40,050
Така че сега ние сме излезли, а след това ние ще отидем в aFunction.

870
00:58:40,050 --> 00:58:45,010
Добре. Така че ще трябва да се отбележи, че тази променлива, която сме създали,

871
00:58:45,010 --> 00:58:48,270
на "Аз" променлива, не е локално с обхват.

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
Може би си мислите, на първо място, на базата на C, че това е копие на "Аз" променлива.

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
Това означава, че след това, обаче, въпреки че функцията променя стойността на "I",

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
Това означава, че когато ехо "I", това не се е променила в обхвата на функцията

886
00:59:38,960 --> 00:59:43,660
и така след това отиваме да отпечатате 3 отново.

887
00:59:43,660 --> 00:59:47,520
Различни неща за обхват в PHP, отколкото в C.

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, ние винаги просто имат същото нещо статично, като как Rob показа,

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
и тя има "За мен", но след това също може да се промени името да има Tommy.

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
Same тук. Все пак, имайте предвид, че те имат различно съдържание,

902
01:00:33,540 --> 01:00:38,870
макар и да са технически все още достъп до същата тази уеб страница на повърхността.

903
01:00:38,870 --> 01:00:43,450
Генериране на HTML. Има два различни начина, по които можете да направите това.

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
Използвайки това, което Rob ви показах на HTML скрипт

908
01:00:58,720 --> 01:01:04,030
и след това с помощта на PHP шрифт просто да го разпечатате на уеб страницата.

909
01:01:04,030 --> 01:01:09,520
Алтернативният начин е да го направите, като че ли отделянето на PHP и HTML.

910
01:01:09,520 --> 01:01:11,940
Така че можете да имате линия на PHP, която стартира за линия,

911
01:01:11,940 --> 01:01:16,020
тогава може да има линията на HTML в отделно нещо,

912
01:01:16,020 --> 01:01:19,700
и след това ти свърши цикъла, отново, с PHP.

913
01:01:19,700 --> 01:01:21,800
Така че това е един вид го отделя.

914
01:01:21,800 --> 01:01:24,020
От лявата страна, че можете да имате всичко -

915
01:01:24,020 --> 01:01:26,360
това е просто едно парче от PHP.

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
И тогава все още ще видите три изображения се показват на вашия сайт.

923
01:01:49,870 --> 01:01:52,820
Така че това е два различни начини за правене на едно и също нещо.

924
01:01:52,820 --> 01:01:55,060
>> Сега имаме форми и искания. Както Rob ви показах,

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
И искане за GET, както каза Роб, означава, че ти започваш да го сложи във форма

930
01:02:11,220 --> 01:02:15,760
и вие ще го видите като URL, като заявка за POST няма да видите в 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
това означава, че на мненията е по-сигурна,

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
Вие, момчета, използвани в този PSET 7, за да получите информация за потребителя ID.

940
01:02:45,850 --> 01:02:48,550
Какво се е случило е, че можете да използвате този асоциативен масив,

941
01:02:48,550 --> 01:02:53,310
на $ _SESSION, и тогава вие сте в състояние за достъп до различни неща

942
01:02:53,310 --> 01:02:57,720
и съхраняване на различни неща по страниците.

943
01:02:57,720 --> 01:03:00,750
>> Последното нещо е, че ние имаме SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
и това е език за програмиране, за да управлявате бази данни.

945
01:03:04,360 --> 01:03:08,220
Какво точно са бази данни? Те са колекции от маси,

946
01:03:08,220 --> 01:03:10,630
и всяка таблица може да има подобен вид обекти.

947
01:03:10,630 --> 01:03:14,990
Така че ние трябваше таблица на потребителите във вашата финанси PSET.

948
01:03:14,990 --> 01:03:20,610
И защо те са полезни? Защото това е начин на трайно съхраняване на информация.

949
01:03:20,610 --> 01:03:22,840
Това е начин за проследяване на неща и управление на неща

950
01:03:22,840 --> 01:03:25,890
и всъщност го виждаме по различни страници и водене песен.

951
01:03:25,890 --> 01:03:29,930
Като има предвид, ако просто го съхранява в този един момент незабавно

952
01:03:29,930 --> 01:03:33,720
и след това да го използвате по-късно, няма да бъде в състояние да получите достъп до всичко, което сте записали.

953
01:03:33,720 --> 01:03:37,660
В момента има 4 основни неща, които ние използваме за SQL команди.

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
имаме тези две различни неща, а ние искаме да изберете от таблицата на класове

960
01:03:56,740 --> 01:04:01,480
където страхотно - къде в страхотно колоната стойност е 1.

961
01:04:01,480 --> 01:04:04,460
Така че можете да видите тук, ние имаме тези две неща от името на класа,

962
01:04:04,460 --> 01:04:08,490
CS50 и Stat110, а ние имаме документи за самоличност класа и лозунга.

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
където всички неща са едно, а след това го има клас ID, името на класа и слогана, че тя може да избирам.

966
01:04:25,170 --> 01:04:28,100
Как точно го правиш това в кода? Вие трябва да използвате PHP.

967
01:04:28,100 --> 01:04:33,830
Така че това е вид как PHP и SQL са свързани един с друг.

968
01:04:33,830 --> 01:04:38,130
Сега имаме нашия код, и ние ще използваме нашата функция заявка

969
01:04:38,130 --> 01:04:41,370
както направихме в 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
Така че няма да разпечатате на дъното "Wanna Научете HTML?"

981
01:05:18,070 --> 01:05:23,370
След това ще преминете към следващия ред, защото е завършил първият за линия,

982
01:05:23,370 --> 01:05:26,510
и така след това, че ще ходи да разпечатате на втора линия от него,

983
01:05:26,510 --> 01:05:32,120
която ще бъде STAT110, Намери всички моменти.

984
01:05:32,120 --> 01:05:34,290
>> Едно последно нещо, което е на 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 Injection е вид сложно нещо.

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
Решението за това е, че трябва да се използва системата ЗНП,

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
Най-доброто от късмет на всички вас, а сега и на Орегон

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Добре всички. Време е да вървим по някои JavaScript

1018
01:07:44,270 --> 01:07:48,840
и някои други неща, много бързо, така че ние не ви държат тази вечер.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Да. JavaScript е вид на нещо готино, се предполага.

1020
01:07:56,930 --> 01:07:59,090
Нещата, които наистина трябва да знаете за JavaScript, това е нещо като

1021
01:07:59,090 --> 01:08:03,810
страна на клиента края на това, което вашата Web App ще се прави.

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
Готини неща за JavaScript: Тя е динамично напечатани.

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
което означава, че синтаксис е подобен на C и PHP.

1033
01:08:41,359 --> 01:08:47,050
Не е нужно да се направи много преработи, когато сте обучение JavaScript.

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
имаме малко на JavaScript точно там в главата маркер.

1037
01:08:56,330 --> 01:08:59,479
Какво ли е основно само да включите файл с JavaScript.

1038
01:08:59,479 --> 01:09:02,260
Това е един начин можете да включите JavaScript във вашата програма.

1039
01:09:02,260 --> 01:09:06,910
Тогава вторият малко бит е всъщност някои инлайн JavaScript,

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
JavaScript има решетки.

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
>> В готино нещо тук е, че JavaScript е нещо, наречено обекти.

1054
01:10:00,090 --> 01:10:04,800
Той е обектно-ориентиран език, така че това, което го има, е, по същество,

1055
01:10:04,800 --> 01:10:10,100
начин, за да можете да групирате данните заедно, донякъде подобна на структурата,

1056
01:10:10,100 --> 01:10:17,280
но можете да я ползвате като структура или в асоциативен масив синтаксис.

1057
01:10:17,280 --> 01:10:22,520
Това е доста проста и какво можете да правите с това е група данни, заедно

1058
01:10:22,520 --> 01:10:24,810
ако имате един куп данни, които е свързано.

1059
01:10:24,810 --> 01:10:26,850
Защото това е всичко, което имате нужда, за да се опише една кола,

1060
01:10:26,850 --> 01:10:29,050
не е нужно да го има в един куп от различни места.

1061
01:10:29,050 --> 01:10:35,300
Можете просто да го вкарвам в един обект в JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Както вероятно знаете, итерации е един от тези досадни задачи.

1063
01:10:39,090 --> 01:10:43,810
Вие просто го направи над отново. Трябва да говоря с всеки обект в колата,

1064
01:10:43,810 --> 01:10:47,340
или ще трябва да мине през всеки елемент от списък или нещо подобно.

1065
01:10:47,340 --> 01:10:51,770
Така че 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
Сложих в една кола, и аз го нарича Ferrari.

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
>> Също така, JavaScript е много поле-разумно да се PHP.

1090
01:12:26,520 --> 01:12:29,050
Имате два начина за решаване на проблема обхват.

1091
01:12:29,050 --> 01:12:31,960
Не можете да имате Вар в предната част на променлива,

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
Друго нещо, което, обаче, е с вар, то е ограничено до това, което функция сте влезли

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
Това, което ние всъщност се грижи за използването на JavaScript за манипулира уеб страници, нали?

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
Document Object Model The.

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 се грижи за това за вас, а вие да получите хубава структура на данните,

1116
01:13:58,140 --> 01:14:01,390
като един от лявата ми страна, където можете просто да има документ,

1117
01:14:01,390 --> 01:14:03,530
и вътре, че имате нещо, наречено HTML,

1118
01:14:03,530 --> 01:14:05,600
и вътре, че имате на главата и тялото,

1119
01:14:05,600 --> 01:14:08,420
и вътре, че главата ви да имат заглавие, и така нататък, и така нататък, и така нататък.

1120
01:14:08,420 --> 01:14:11,810
Това опростява манипулиране на уеб страница, така че това е просто,

1121
01:14:11,810 --> 01:14:14,190
ох, аз просто искам да говоря с този обект.

1122
01:14:14,190 --> 01:14:21,340
Нещо много подобен начин можете да говорите с друг обект, който сте направили сами.

1123
01:14:21,340 --> 01:14:25,980
Както казах, всички DOM е в предмета на документа.

1124
01:14:25,980 --> 01:14:29,290
Или това е просто едно място и след това можете да отидете в него да намерите неща,

1125
01:14:29,290 --> 01:14:33,880
и можете да го направите - това е най-стария стил на го прави, там горе,

1126
01:14:33,880 --> 01:14:38,130
когато правиш document.getElementById, а след това името,

1127
01:14:38,130 --> 01:14:42,420
и както вероятно можете да кажа, това става много тромава след известно време.

1128
01:14:42,420 --> 01:14:44,480
Така че най-вероятно не искате да направите това. Ето защо ние имаме

1129
01:14:44,480 --> 01:14:48,760
следващото нещо, което ние ще говорим за след това.

1130
01:14:48,760 --> 01:14:52,510
Най-важното тук е, че, добре, имате всички тези елементи, нали?

1131
01:14:52,510 --> 01:14:56,400
Така че може би мога да променя цвета на нещо, когато страница се зарежда.

1132
01:14:56,400 --> 01:14:58,380
И какво от това? Какво става, ако моят потребител кликне нещо?

1133
01:14:58,380 --> 01:15:00,540
Искам да направя нещо интересно, когато щракнете върху нещо.

1134
01:15:00,540 --> 01:15:02,600
Ето защо ние трябва събития.

1135
01:15:02,600 --> 01:15:05,330
Можете да, общо взето, да намерите всеки елемент във вашия DOM,

1136
01:15:05,330 --> 01:15:08,560
и след това казват, ей. Когато това се зарежда или някой го щракне,

1137
01:15:08,560 --> 01:15:11,410
или когато мишката върху него, направи нещо с него.

1138
01:15:11,410 --> 01:15:15,330
И това, което имаме, е, че имате функции, които се справят с това за вас.

1139
01:15:15,330 --> 01:15:17,980
Тези функции са работещи събитие.

1140
01:15:17,980 --> 01:15:20,440
Какво Те са - това е просто един луксозен начин на казвайки:

1141
01:15:20,440 --> 01:15:23,500
тази функция се изпълнява само когато това събитие се случва.

1142
01:15:23,500 --> 01:15:28,070
Така че дръжки случай, че се случи.

1143
01:15:28,070 --> 01:15:30,810
Това е начина, по който ще бъдат изложени манипулатор на събитие.

1144
01:15:30,810 --> 01:15:34,750
Имам някакъв бутон, и когато щракнете върху него, тя експлодира.

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 елемент, но ние ще спестите, че след като ние говорим за Jquery.

1152
01:16:02,770 --> 01:16:07,580
>> Jquery: Това е библиотека, която е крос-браузър.

1153
01:16:07,580 --> 01:16:09,580
Можете да го използвате в почти всичко.

1154
01:16:09,580 --> 01:16:12,090
И то просто ви дава много инструменти, за да работим.

1155
01:16:12,090 --> 01:16:15,850
Тъй като JavaScript, като същевременно мощен, не разполага с всички инструменти, необходими

1156
01:16:15,850 --> 01:16:20,550
от кутията наистина да се справи с уеб приложение може да искате да направите.

1157
01:16:20,550 --> 01:16:24,650
Така че това опростява много неща, ти дава много функции

1158
01:16:24,650 --> 01:16:28,760
изваждането му от кутията, която обикновено вие ще трябва да си пиша, отново и отново, и отново.

1159
01:16:28,760 --> 01:16:31,600
И просто прави нещата много проста.

1160
01:16:31,600 --> 01:16:35,780
Вие също трябва селектори, които ви позволяват да вземе всички тези елементи

1161
01:16:35,780 --> 01:16:42,800
от вашия DOM много по-просто, вместо да се налага да се използват тези много дълги извиквания.

1162
01:16:42,800 --> 01:16:46,630
Повече за тези селектори. Имате право, там сте, нека да кажем,

1163
01:16:46,630 --> 01:16:49,800
Аз искам да отида на елемент с ID на "скалата".

1164
01:16:49,800 --> 01:16:56,450
Е, в Jquery, това е само $ и след поредица, която има половин килограм, а след това "рок".

1165
01:16:56,450 --> 01:17:01,960
Това е много проста и много по-бързо от традиционната JavaScript начин за справяне с този проблем.

1166
01:17:01,960 --> 01:17:06,120
И вие имате подобни неща за класове и типове елементи.

1167
01:17:06,120 --> 01:17:08,140
Jquery е - един от най-страхотните възможности е, че може нещо да компресирате

1168
01:17:08,140 --> 01:17:14,350
вашите заявки на вашия DOM много, много бързо.

1169
01:17:14,350 --> 01:17:18,980
Сега ние се връщаме на работа събитие, и това е начина, по който ще се справят с едно събитие в Jquery.

1170
01:17:18,980 --> 01:17:23,090
Така че това, което ще е тук, което казваме, всичко е наред. Имам таг скрипт, нали?

1171
01:17:23,090 --> 01:17:25,400
Така че аз имам този инлайн JavaScript.

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
Така че това е защо ние имаме нещо като Ajax.

1199
01:18:55,290 --> 01:18:59,150
Какво можем да направим тук с Ajax е, че ние може да се каже, добре,

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
създавате на кликване функция за този бутон, наречен посрещач.

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
нека просто кажем, дава назад "Hello World".

1220
01:20:12,480 --> 01:20:15,650
Така че да се върнем тази "Hello World", и при успех на тази,

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
>> Много бързо, Rob вид спомена вече,

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
Design. Неща, които искате да запомните.

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 има пет страници, преди да можете дори да намерите нещо,

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]