1
00:00:00,000 --> 00:00:02,270
>> [Обзор: Викторина 1]

2
00:00:02,270 --> 00:00:04,620
[Али Нама, Oreoluwa Barbarinsa, Лукас Фрейтас, Роб Боуден] [Гарвардский университет]

3
00:00:04,620 --> 00:00:07,660
[Это CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Лукас Фрейтас] Приветствую всех. Это отзыв для викторины 1.

5
00:00:11,610 --> 00:00:15,040
Так же, как за точность информации, это - я имею в виду, что мы собираемся, чтобы попытаться покрыть

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

7
00:00:17,770 --> 00:00:20,780
мы собираемся охватить все вещи, которые могут быть в викторине 1.

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

9
00:00:25,270 --> 00:00:28,240
Викторина 1 будет в среду, в следующую среду.

10
00:00:28,240 --> 00:00:33,800
Так что не забудьте изучить. Это будет, в значительной степени, как и первый викторины

11
00:00:33,800 --> 00:00:36,390
относительно его формат, но это, вероятно, будет гораздо сложнее.

12
00:00:36,390 --> 00:00:39,600
По крайней мере, в прошлом году, когда я взял 50, я думал, что это было гораздо сложнее.

13
00:00:39,600 --> 00:00:42,410
Так много учиться.

14
00:00:42,410 --> 00:00:45,190
>> Я собираюсь покрыть структуры данных и кодирование Хаффмана.

15
00:00:45,190 --> 00:00:47,910
Это то, что многие люди думают, является сложной,

16
00:00:47,910 --> 00:00:51,930
но я собираюсь попытаться сделать это как можно проще.

17
00:00:51,930 --> 00:00:56,330
Прежде всего, то, что мы хотим, вы, ребята, чтобы знать викторины 1 является

18
00:00:56,330 --> 00:01:00,970
понять концептуальные описания каждой из структур данных, которые я собираюсь представить.

19
00:01:00,970 --> 00:01:03,960
Это означает, что у вас нет на самом деле

20
00:01:03,960 --> 00:01:07,020
реализации хэш-таблицу в вашей викторины 1.

21
00:01:07,020 --> 00:01:10,250
Мы не хотим вам реализовать целый хэш-таблицу, может быть, мы постараемся

22
00:01:10,250 --> 00:01:13,090
чтобы вы реализовать некоторые функции,

23
00:01:13,090 --> 00:01:16,940
наиболее распространенные операции, но мы не собираемся, чтобы вы реализовать все.

24
00:01:16,940 --> 00:01:21,010
Поэтому важно, что вы понимаете понятие позади каждой структуры данных

25
00:01:21,010 --> 00:01:23,510
а также, что вы можете кодировать в C,

26
00:01:23,510 --> 00:01:27,880
только самые распространенные операции, которые они имеют для каждой структуры данных.

27
00:01:27,880 --> 00:01:30,090
А также сможете просмотреть указатели и структуры,

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
Вы просто должны быть осторожны, чтобы всегда помнить, чтобы Malloc и бесплатно узлы,

41
00:02:20,660 --> 00:02:25,510
только потому, что если вы этого не сделаете, вы будете иметь утечек памяти.

42
00:02:25,510 --> 00:02:31,480
Так связанные списки - определение узла точно так же как то, что мы имеем право там.

43
00:02:31,480 --> 00:02:35,110
Я положил 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 N для примеров здесь.

47
00:02:44,630 --> 00:02:46,800
И у вас есть указатель на следующий узел.

48
00:02:46,800 --> 00:02:51,940
Так, в основном, связанный список имеет некоторые данные, а затем он указывает на следующий узел.

49
00:02:51,940 --> 00:02:56,710
Если это последний элемент в связанном списке, это будет указывать на 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
И я собираюсь принять Int в качестве аргумента,

55
00:03:14,200 --> 00:03:17,090
потому что я хочу знать, что я хочу, чтобы вставить.

56
00:03:17,090 --> 00:03:21,840
Так что первое, что я должен делать? Ну, я должен Malloc на 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
Штабеля довольно просты.

91
00:05:24,680 --> 00:05:29,540
Мы сделали стеки и очереди в классе только с помощью массивов,

92
00:05:29,540 --> 00:05:32,820
но вы должны быть знакомы - просто надо знать

93
00:05:32,820 --> 00:05:40,740
что вы также можете сделать стеки в очередях с помощью связанных списков, а также.

94
00:05:40,740 --> 00:05:44,460
Так что если у вас есть массив, что было бы стек?

95
00:05:44,460 --> 00:05:46,810
Стек, во-первых, должны иметь размер.

96
00:05:46,810 --> 00:05:49,950
Вы должны сохранить то, что это размер стека, что у вас есть сейчас.

97
00:05:49,950 --> 00:05:52,980
А также вы бы массив, в данном случае чисел,

98
00:05:52,980 --> 00:05:55,120
но если вы хотите, это может быть массивом

99
00:05:55,120 --> 00:06:00,380
строк, массив структуры, все, что вы хотите сохранить.

100
00:06:00,380 --> 00:06:03,240
О стека: Разница между стеком и связанного списка

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

102
00:06:08,590 --> 00:06:11,770
Она называется последний вошел, первый вышел.

103
00:06:11,770 --> 00:06:15,090
Так же, как у вас есть стопка подносов,

104
00:06:15,090 --> 00:06:17,670
если вы положили поднос на вершине стека,

105
00:06:17,670 --> 00:06:22,670
Вы должны удалить этот лоток первым, чтобы иметь доступ к другим лотков.

106
00:06:22,670 --> 00:06:26,310
Это то же самое со стеками.

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

108
00:06:31,220 --> 00:06:34,070
Она называется толчок, и это довольно просто.

109
00:06:34,070 --> 00:06:37,130
Первое, что вы должны сделать, это проверить, если размер стека

110
00:06:37,130 --> 00:06:40,150
не больше или равна емкости стека.

111
00:06:40,150 --> 00:06:45,810
Потому что, если у вас уже есть на полную мощность, вы не можете что-либо еще добавить.

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

113
00:06:51,140 --> 00:06:54,530
И, наконец, увеличивают размер. Так что это довольно просто.

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

115
00:06:57,140 --> 00:07:00,350
И если я хочу, чтобы совать, а это значит, что я хочу, чтобы удалить

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

117
00:07:03,870 --> 00:07:09,180
Первое, что я должен проверить, что стек не пуст.

118
00:07:09,180 --> 00:07:11,510
Потому что, если он пуст, я ничего не могу вернуться.

119
00:07:11,510 --> 00:07:14,820
В этом случае, я возвращаюсь -1.

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

121
00:07:18,960 --> 00:07:22,510
и вернуться цифры (s.size).

122
00:07:22,510 --> 00:07:27,230
Почему я уменьшить размер, а затем вернуться s.size?

123
00:07:27,230 --> 00:07:30,930
Это потому, что, в данном случае, спецификация имеет размер 4,

124
00:07:30,930 --> 00:07:33,810
и я хочу вернуться четвертый элемент, не так ли?

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

126
00:07:36,030 --> 00:07:44,510
Так как я размер - будет 3, я могу просто вернуться s.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
Ставить это то же самое, как толчок для стеков.

140
00:08:32,710 --> 00:08:34,980
Если вы были очень наивны, вы бы просто сказать,

141
00:08:34,980 --> 00:08:39,289
ну, я могу просто сделать то же самое, что и я сделал для толчка.

142
00:08:39,289 --> 00:08:44,030
Я могу просто проверить, если это не выходит за пределы возможностей.

143
00:08:44,030 --> 00:08:48,760
Если это так, я вернуться ложным, иначе я могу просто экспортировать новое значение

144
00:08:48,760 --> 00:08:50,630
и затем увеличить размер.

145
00:08:50,630 --> 00:08:52,750
Но почему это так?

146
00:08:52,750 --> 00:08:55,010
Давайте посмотрим этот пример.

147
00:08:55,010 --> 00:08:57,020
Я пытаюсь поставить в очередь кучу вещей,

148
00:08:57,020 --> 00:08:58,390
а затем я собираюсь из очереди и постановки в очередь.

149
00:08:58,390 --> 00:09:00,550
Там очень много команд, но это очень просто.

150
00:09:00,550 --> 00:09:04,790
Я собираюсь поставить в очередь 5, так что добавьте 5, а затем 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, а затем я хочу из очереди что-то,

152
00:09:09,310 --> 00:09:12,000
Это означает, что я собираюсь удалить первый элемент.

153
00:09:12,000 --> 00:09:14,640
Так что я собираюсь снять номер 3, не так ли?

154
00:09:14,640 --> 00:09:17,320
Первый элемент. Хорошо.

155
00:09:17,320 --> 00:09:21,450
Теперь, если я пытаюсь поставить в очередь что-то еще, что произойдет?

156
00:09:21,450 --> 00:09:24,290
По моей реализации,

157
00:09:24,290 --> 00:09:31,040
Я собирался поставить следующий номер в индексе q.size.

158
00:09:31,040 --> 00:09:35,140
В этом случае, размер 8,

159
00:09:35,140 --> 00:09:38,640
поэтому индекс 8 будет прямо здесь, в последней позиции.

160
00:09:38,640 --> 00:09:43,900
Если я пытаюсь поставить в очередь 1 прямо здесь, я был бы перезаписи последнюю позицию

161
00:09:43,900 --> 00:09:45,870
к № 1, которое является совершенно неправильным.

162
00:09:45,870 --> 00:09:49,870
То, что я хочу сделать, это обернуть вокруг и перейти к первой позиции.

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

164
00:09:52,870 --> 00:09:55,600
если я могу на самом деле положить что-то там.

165
00:09:55,600 --> 00:09:58,560
Если нет, я просто говорю, о, новый полную мощность

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

167
00:10:02,010 --> 00:10:06,150
Но в чем же проблема? Проблема в том, что, если я просто из очереди все прямо здесь

168
00:10:06,150 --> 00:10:08,240
а затем я пытаюсь добавить что-то еще, было бы просто сказать,

169
00:10:08,240 --> 00:10:11,210
ну, вы были на полную мощность, что является 0.

170
00:10:11,210 --> 00:10:13,620
Так что ваша очередь ушла.

171
00:10:13,620 --> 00:10:16,990
Вы должны обернуть вокруг, и способ обтекание

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

173
00:10:22,040 --> 00:10:29,090
Вы можете попробовать его дома, чтобы понять, почему вы могли бы сделать q.size + q.head

174
00:10:29,090 --> 00:10:31,080
мод емкость, но если вы посмотрите прямо здесь,

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

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

177
00:10:37,760 --> 00:10:47,590
и голова была 1, потому что это было это положение здесь массива.

178
00:10:47,590 --> 00:10:51,970
Так будет 8 + 1, 9. Мод емкость 9 будет 0.

179
00:10:51,970 --> 00:10:56,640
Было бы пойти в индексе 0. Мы будем в правильном положении.

180
00:10:56,640 --> 00:10:59,750
А потом попробуйте очередь дома.

181
00:10:59,750 --> 00:11:04,950
Некоторые важные вещи: попытаться понять разницу между стеком и очереди.

182
00:11:04,950 --> 00:11:11,620
Дома, попытаться получить очень хорошо знакомы с реализации в очередь, Dequeue, толчок и поп-музыки.

183
00:11:11,620 --> 00:11:16,560
А также понять, когда вы будете использовать каждый из них.

184
00:11:16,560 --> 00:11:22,830
>> Так что давайте отдохнуть в течение 10 секунд с кучей покемонов.

185
00:11:22,830 --> 00:11:26,080
А теперь давайте вернемся к структурам данных.

186
00:11:26,080 --> 00:11:29,770
Хеш-таблицы. Много людей были напуганы хэш-таблицы.

187
00:11:29,770 --> 00:11:33,650
в проблему набор 6, Spell Checker.

188
00:11:33,650 --> 00:11:35,980
Хеш-таблицы и пытается, много людей пугаются из них.

189
00:11:35,980 --> 00:11:38,540
Они думают, что они так трудно понять. Да?

190
00:11:38,540 --> 00:11:41,490
[Роб Боуден] Архив задач 5. >> Архив задач 5, да. Благодаря Роб.

191
00:11:41,490 --> 00:11:43,370
Да. Шесть был Хафф-н-Puff, да.

192
00:11:43,370 --> 00:11:49,340
Архив задач 5 был Spell Checker, и вы должны были использовать либо хэш-таблицу или попытку.

193
00:11:49,340 --> 00:11:55,360
Многие люди думают, что они были супер трудно понять, но они на самом деле довольно просто.

194
00:11:55,360 --> 00:12:01,290
Что такое хэш-таблицу, в принципе? Хеш-таблица представляет собой массив связанных списков.

195
00:12:01,290 --> 00:12:06,730
Единственная разница между массивом и хэш-таблице

196
00:12:06,730 --> 00:12:09,730
является то, что в хэш-таблице у вас есть то, что называется хэш-функция.

197
00:12:09,730 --> 00:12:12,080
Что такое хэш-функция?

198
00:12:12,080 --> 00:12:13,970
Я не знаю, если вы, ребята можете прочитать здесь.

199
00:12:13,970 --> 00:12:16,090
Это является примером хэш-таблице.

200
00:12:16,090 --> 00:12:19,220
Таким образом, вы можете видеть, что у вас есть массив с 31 элементами.

201
00:12:19,220 --> 00:12:22,440
И то, что мы делаем в хэш-таблице является иметь хэш-функцию

202
00:12:22,440 --> 00:12:26,660
что собирается перевести ключ, каждый десятичного индексу.

203
00:12:26,660 --> 00:12:31,740
Если, например, если я хочу, чтобы выбрать для Б. Харрисон,

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

205
00:12:34,190 --> 00:12:36,960
и хэш-функция вернется 24.

206
00:12:36,960 --> 00:12:40,930
Так что я знаю, что я хочу сохранить Б. Харрисон в 24.

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

208
00:12:46,580 --> 00:12:48,740
В хэш-таблице вы будете иметь функцию, которая собирается, чтобы сказать вам

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

210
00:12:54,740 --> 00:12:57,040
Для хэш-функции, вы хотите посмотреть на хэш-функции

211
00:12:57,040 --> 00:13:00,600
что является детерминированным и хорошо распределены.

212
00:13:00,600 --> 00:13:07,810
Как вы можете видеть здесь, вы видите, что много данных, которые я хотел магазине было на самом деле 19

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

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

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

216
00:13:20,710 --> 00:13:26,520
примерно, по крайней мере, 1 или 2 для каждого из -

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

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

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

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

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

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

223
00:14:00,150 --> 00:14:05,630
Вы должны просто знать номенклатуру для родителей и ребенка.

224
00:14:05,630 --> 00:14:12,880
Каждый узел имеет своих детей, которые являются узлы, которые находятся ниже родителя.

225
00:14:12,880 --> 00:14:19,660
Так, например, 2 собирается быть родителем для 3 и для другого ребенка тут же,

226
00:14:19,660 --> 00:14:25,290
в то время как 3 будет родительским для 1 и другие дети, которые там.

227
00:14:25,290 --> 00:14:29,990
И 1 будет 3 дитя, и так далее.

228
00:14:29,990 --> 00:14:34,610
У нас есть нечто гораздо более интересное, называемый бинарное дерево,

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

230
00:14:39,040 --> 00:14:41,660
будут справа, прямо здесь - на правом,

231
00:14:41,660 --> 00:14:46,780
будут больше, чем элемент в корне.

232
00:14:46,780 --> 00:14:49,780
Поэтому если я номер 5 прямо здесь, все элементы на права

233
00:14:49,780 --> 00:14:51,940
будут больше 5, и слева

234
00:14:51,940 --> 00:14:56,770
все элементы будут меньше 5.

235
00:14:56,770 --> 00:14:58,780
Почему это полезно?

236
00:14:58,780 --> 00:15:01,660
Ну, если я хочу, чтобы проверить, если число 7 здесь, например,

237
00:15:01,660 --> 00:15:05,960
Я просто перейдите к 5 первым, и я собираюсь видеть, является 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
[Студент говоря, неразборчиво]

269
00:16:51,140 --> 00:16:53,480
Отлично. Так она говорит, что это не имеет значения,

270
00:16:53,480 --> 00:16:55,930
только потому, что неэффективность, что у нас было раньше

271
00:16:55,930 --> 00:16:59,550
было то, что, потому что, может быть, если некоторое условие было выполнено,

272
00:16:59,550 --> 00:17:03,570
так что вы выполнили действия, но тогда вы собирались проверить все другие условия.

273
00:17:03,570 --> 00:17:06,319
Но в этом случае, он вернулся сразу же, так что это не имеет значения.

274
00:17:06,319 --> 00:17:09,220
Так что вам не придется использовать еще, если.

275
00:17:09,220 --> 00:17:11,740
>> И, наконец, давайте поговорим о попыток,

276
00:17:11,740 --> 00:17:13,800
который является любимцем.

277
00:17:13,800 --> 00:17:15,980
Попытка это дерево массивов.

278
00:17:15,980 --> 00:17:20,369
Это очень быстро для поиска значения, но он использует много памяти.

279
00:17:20,369 --> 00:17:22,530
И это, как правило, для фильтрации слова, поэтому, когда вы

280
00:17:22,530 --> 00:17:27,920
хотите реализовать, например, я не знаю,, как телефонная книга в телефоне

281
00:17:27,920 --> 00:17:30,440
и вы хотите, чтобы иметь возможность типа В

282
00:17:30,440 --> 00:17:32,510
и просто имена людей, которые имеют 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
Перед здесь я просто буду использовать 2 потому что я хочу, чтобы иметь возможность писать на доске.

294
00:18:17,800 --> 00:18:20,230
Хорошо. Так что это пример попытки.

295
00:18:20,230 --> 00:18:25,600
Если бы я просто определить первый узел, я буду есть массив 2-х элементов

296
00:18:25,600 --> 00:18:29,290
что 2 указатели на NULL, так что я просто положить 'A' и 'B'.

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
Я бы просто должны Malloc новый узел для "а",

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

304
00:18:54,630 --> 00:19:00,180
Так что просто представляет, что, 'а' собирается, чтобы быть правдой. Смысл?

305
00:19:00,180 --> 00:19:04,120
Тогда, если я хочу добавить 'ба', я должен буду таНос 1 для 'B',

306
00:19:04,120 --> 00:19:07,550
а затем я собираюсь настроить логическое ложь,

307
00:19:07,550 --> 00:19:10,160
потому «б» само по себе не является словом.

308
00:19:10,160 --> 00:19:13,010
Тогда я собираюсь Malloc еще один для "а", так что "ба",

309
00:19:13,010 --> 00:19:16,290
а затем я собираюсь создать это слово к истине.

310
00:19:16,290 --> 00:19:18,950
Потому что «ба» это слово.

311
00:19:18,950 --> 00:19:21,910
И потом, если я хочу, чтобы увидеть, если «б» в этом словаре,

312
00:19:21,910 --> 00:19:26,730
Я могу просто пойти в первый, 'B'. Я спускаюсь, и я смотрю на это слово, и он говорит, является ложным.

313
00:19:26,730 --> 00:19:30,110
Так что это не слова. Если я хочу, чтобы проверить "ба",

314
00:19:30,110 --> 00:19:38,010
Я иду в первый, 'B', а затем перейти к "а", и я вижу, правда, так это слово. Смысл?

315
00:19:38,010 --> 00:19:41,950
Много людей запутаться попыток. Нет?

316
00:19:41,950 --> 00:19:44,740
>> Наконец, кодирования Хаффмана. Кодирование Хаффмана очень полезно

317
00:19:44,740 --> 00:19:47,550
для экономии памяти и сжимать текстовые файлы,

318
00:19:47,550 --> 00:19:52,270
только потому, что много раз вы используете 'A' и 'е', например,

319
00:19:52,270 --> 00:19:57,710
в ваших документах, но я не знаю, если вы, ребята, использовать 'Q' или 'Z', как много.

320
00:19:57,710 --> 00:20:02,040
Имея всего в 1 байт для каждого персонажа,

321
00:20:02,040 --> 00:20:08,520
каждый - в 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
 Дерево Хаффмана имеет узлы

327
00:20:23,370 --> 00:20:27,760
что есть символ, который собирается быть похожим, 'а', 'б', 'C', письма,

328
00:20:27,760 --> 00:20:32,990
что письмо у вас есть, частота, частота, которая появляется слово в тексте,

329
00:20:32,990 --> 00:20:36,280
что вы создавали дерево Хаффмана для,

330
00:20:36,280 --> 00:20:41,800
а затем узел, который будет указывать на слева от дерева Хаффмана

331
00:20:41,800 --> 00:20:47,210
и другой узел, который будет указывать на справа. Так же, как дерево.

332
00:20:47,210 --> 00:20:49,440
Как вы строите дерево Хаффмана?

333
00:20:49,440 --> 00:20:54,020
Вы собираетесь выбрать 2 узла, которые имеют самые низкие частоты.

334
00:20:54,020 --> 00:20:56,490
Если у вас есть галстук вы собираетесь выбрать 2 узла

335
00:20:56,490 --> 00:20:59,870
которые имеют самые низкие значения ASCII, а также.

336
00:20:59,870 --> 00:21:02,420
Тогда вы собираетесь создать новое дерево из тех 2 узлов

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

338
00:21:08,030 --> 00:21:13,240
А потом вы собираетесь удалить 2 детей из леса

339
00:21:13,240 --> 00:21:15,570
и заменить их родителей.

340
00:21:15,570 --> 00:21:18,930
И вы собираетесь повторить, что, пока вы только не имеют 1 дерево в лесу.

341
00:21:18,930 --> 00:21:23,840
Итак, давайте посмотрим, как вы могли бы сделать дерево Хаффмана для ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Здесь можно увидеть, что все буквы имеют частоту 1 для '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
Так что это здесь. Частота пары будет два

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 и движется вправо является 1,

355
00:22:30,220 --> 00:22:32,410
Что это будет представлять?

356
00:22:32,410 --> 00:22:35,530
Так как 1, 1, так правильно, правильно,

357
00:22:35,530 --> 00:22:40,370
и затем 0, так что осталось бы L, а затем 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Так 1, 0, так что просто 1, 0, 'А'.

359
00:22:43,950 --> 00:22:47,540
И тогда 0, 1, так 'Z'.

360
00:22:47,540 --> 00:22:52,170
А потом 1, 0, 0 - нет.

361
00:22:52,170 --> 00:22:56,780
0, 0 будет 'Y', так Ленивый.

362
00:22:56,780 --> 00:23:06,060
Так что все для меня, Роб собирается взять на себя.

363
00:23:06,060 --> 00:23:08,400
>> [Роб Боуден] Итак, неделя 7 материал.

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
Битовые операции. Есть 6 из них, что вам нужно знать.

369
00:23:24,330 --> 00:23:31,200
Битовые и, побитовое ИЛИ, исключающее ИЛИ, сдвиг влево, сдвиг вправо, а не.

370
00:23:31,200 --> 00:23:35,420
Сдвиг вправо, а не вы только видели в лекции вообще.

371
00:23:35,420 --> 00:23:40,480
Мы пойдем по нему быстро здесь, но это хорошо, чтобы знать, что это 6, что существует.

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
и то было бы перевернуть бинарное представление 4.

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
>> Побитовый или. Вот 2 двоичные числа, и эти 2 цифры

389
00:24:58,220 --> 00:25:00,780
довольно представительным, так как они представляют все возможные

390
00:25:00,780 --> 00:25:07,290
Сочетание бит вам может понадобиться для работы на.

391
00:25:07,290 --> 00:25:13,540
При этом, когда я or'd каждый бит, мы только собираемся сравнивать прямо вниз.

392
00:25:13,540 --> 00:25:15,410
Таким образом, на левой стороне мы имеем один и 1.

393
00:25:15,410 --> 00:25:20,510
Когда я побитовое | тех, что я собираюсь получить? Один.

394
00:25:20,510 --> 00:25:25,320
Тогда побитовое | 0 и 1 собирается дать мне? Один.

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
Так что если вы думаете, что из 1 как истинный и 0 как ложный, то же самое применимо и здесь.

400
00:25:44,830 --> 00:25:50,040
Так правда или верно, то верно, истинно или ложно это правда.

401
00:25:50,040 --> 00:25:57,150
Ложь или правда, то правда; ложь или ложь это единственное, что на самом деле ложное.

402
00:25:57,150 --> 00:26:00,100
Вот пример, который вы должны знать,

403
00:26:00,100 --> 00:26:05,160
как довольно хороший пример, когда битовые операторы используются.

404
00:26:05,160 --> 00:26:08,660
Вот если бы мы или капитала "А" с OX20,

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

406
00:26:11,830 --> 00:26:16,020
И если мы или строчная '' с OX20, мы получаем нечто.

407
00:26:16,020 --> 00:26:26,750
Так что давайте подтянуть таблицу ASCII.

408
00:26:26,750 --> 00:26:34,000
Хорошо. Здесь мы видим, что «А» является -

409
00:26:34,000 --> 00:26:36,920
здесь мы имеем «А» является десятичной 65.

410
00:26:36,920 --> 00:26:45,120
Но я пойду с шестнадцатеричном, который Ox41.

411
00:26:45,120 --> 00:26:48,280
Уверен, что мы видели его в классе. Я думаю, что мы видели его в классе

412
00:26:48,280 --> 00:26:52,730
что это довольно легко конвертировать из шестнадцатеричной в двоичную.

413
00:26:52,730 --> 00:26:55,280
Так вот, если я хочу поставить 4 в двоичный,

414
00:26:55,280 --> 00:26:59,550
вот только будет 0100.

415
00:26:59,550 --> 00:27:03,620
Это 1 в указанное место, 2 в указанное место, 4 в указанное место, так что это 4.

416
00:27:03,620 --> 00:27:08,550
Тогда я могу разделить 1 в двоичный, который собирается быть 0001.

417
00:27:08,550 --> 00:27:14,280
И таким образом, это будет представление «А» в двоичном виде.

418
00:27:14,280 --> 00:27:22,720
Принимая нижний регистр 'а', то теперь собирается быть Ox61,

419
00:27:22,720 --> 00:27:27,050
где, разделив эти вверх в его двоичный, поэтому 6 -

420
00:27:27,050 --> 00:27:37,830
Давайте на самом деле это сделать - нет ли ластик? Ластик.

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

422
00:27:48,220 --> 00:27:54,610
И расщепление 1 будет 0001.

423
00:27:54,610 --> 00:27:56,520
Глядя на разницу между этими 2,

424
00:27:56,520 --> 00:28:04,250
мы видим, что единственная разница между строчной и прописной 'А' это один бит.

425
00:28:04,250 --> 00:28:11,810
Так возвращаясь к здесь - все в порядке.

426
00:28:11,810 --> 00:28:15,920
Возвращаясь к здесь, если мы посмотрим на то, что немного OX20 является,

427
00:28:15,920 --> 00:28:22,210
так расщепление OX20 в его двоичный,

428
00:28:22,210 --> 00:28:27,310
является 0010, 0000.

429
00:28:27,310 --> 00:28:33,470
OX20, единственный бит, который устанавливается это немного, что мы имеем дело с,

430
00:28:33,470 --> 00:28:38,210
с переключением между капиталом и нижний регистр 'A'.

431
00:28:38,210 --> 00:28:47,610
Если я или «А», который является этот, «А»,

432
00:28:47,610 --> 00:28:50,580
если я или "А" с OX20,

433
00:28:50,580 --> 00:28:53,490
что я собираюсь получить?

434
00:28:53,490 --> 00:28:58,960
[Студент, неразборчиво] >> строчная 'а', потому что он собирается перевернуть этот бит в 1.

435
00:28:58,960 --> 00:29:04,170
И если я или "а" с OX20, что я собираюсь получить?

436
00:29:04,170 --> 00:29:08,780
Нижнему регистру, потому что как раз Öring «а» с OX20,

437
00:29:08,780 --> 00:29:14,580
Я просто хочу, чтобы быть Öring этот один бит на 1, это уже 1, так что это не имеет значения.

438
00:29:14,580 --> 00:29:17,960
Итак, мы получаем 'A' и 'A'.

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
И так «А» операция AND с ~ 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
затем мы собираемся, чтобы получить именно то, что «А» был,

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

456
00:30:31,260 --> 00:30:34,460
Потому что, если это был 1, теперь он собирается быть установлен на 0,

457
00:30:34,460 --> 00:30:39,810
потому что это, операция AND с этим будет 0.

458
00:30:39,810 --> 00:30:43,280
Так что же такое "А" и ~ OX20 собираюсь дать мне?

459
00:30:43,280 --> 00:30:48,200
[Студенты ответить, неразборчиво] >> А что такое "а" и - это "А".

460
00:30:48,200 --> 00:30:52,170
А что такое "а" и ~ OX20 собираюсь дать мне?

461
00:30:52,170 --> 00:30:56,720
'А.' Поскольку это в настоящее время 1.

462
00:30:56,720 --> 00:30:59,570
Андинг с этим +0 собирается сделать это 0,

463
00:30:59,570 --> 00:31:02,530
и теперь мы собираемся, чтобы получить 'A'.

464
00:31:02,530 --> 00:31:06,600
>> Оба ',' и не в последнюю очередь этого типа,

465
00:31:06,600 --> 00:31:10,830
у нас есть XOR. Это очень похоже или,

466
00:31:10,830 --> 00:31:14,400
кроме это означает исключительно или.

467
00:31:14,400 --> 00:31:18,420
Это как то, что вы обычно думаете, как и в реальном мире.

468
00:31:18,420 --> 00:31:23,190
Таким образом, вы выполните одно 'х' или 'у', но не оба.

469
00:31:23,190 --> 00:31:28,700
Здесь 1 ^ 1 будет 0.

470
00:31:28,700 --> 00:31:33,650
Потому что правда, это - он не работает, а с логическим истинным и ложным

471
00:31:33,650 --> 00:31:37,150
как побитовое & и или сделать,

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
если это | или ^, это будет 1, а если и это будет 0.

479
00:32:14,660 --> 00:32:20,850
И единственный случай, когда 1 побитовое 1 не 1 с эксклюзивным или.

480
00:32:20,850 --> 00:32:24,580
Это 0110.

481
00:32:24,580 --> 00:32:36,520
Так вот сейчас, используя XOR - так мы вернулись в 20.

482
00:32:36,520 --> 00:32:43,480
"А" ^ OX20 эти 2 бита мы сравниваем.

483
00:32:43,480 --> 00:32:50,020
Так 1 ^ 0 собирается дать мне что? Один.

484
00:32:50,020 --> 00:32:58,430
"А" ^ OX20 собирается дать мне? Нижнему регистру.

485
00:32:58,430 --> 00:33:04,010
'А' ^ OX20 собирается дать мне? Капитал А.

486
00:33:04,010 --> 00:33:09,310
Потому что все, что это делает, это операции XOR с OX20

487
00:33:09,310 --> 00:33:15,380
эффективно листать все этот бит.

488
00:33:15,380 --> 00:33:21,240
Если это 0, то теперь собирается стать 1.

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

490
00:33:26,160 --> 00:33:33,280
Таким образом, наш «а» стала «А», и наш «А» стал «а».

491
00:33:33,280 --> 00:33:36,910
Так XOR является действительно удобным способом просто листать дело.

492
00:33:36,910 --> 00:33:39,960
Вы просто хотите перебрать строку букв

493
00:33:39,960 --> 00:33:44,330
и чередовать дело каждого отдельного персонажа,

494
00:33:44,330 --> 00:33:50,680
вы просто 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
В небинарных точки,

501
00:34:16,380 --> 00:34:24,699
мы видим, что, что на самом деле дело 13 левой смещенную 3, что дает нам 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 * 104 8.

504
00:34:40,139 --> 00:34:45,679
Если вы просто думаете о двоичном вообще, как каждой цифры,

505
00:34:45,679 --> 00:34:49,530
если исходить из права, это в 1 в указанное место, то в 2 указанное место, то в 4 в указанное место.

506
00:34:49,530 --> 00:34:51,330
Так, нажав на 0-х годов по правому флангу,

507
00:34:51,330 --> 00:34:55,080
мы просто толкает вещи, которые были в 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
[Студент] Что произойдет, если вы перешли на 5?

511
00:35:05,210 --> 00:35:10,790
[Боуден] Если вы сдвигается на 5, вы просто потеряете цифры.

512
00:35:10,790 --> 00:35:15,410
Безусловно, это одно и то же. Мол, целые числа только 32 бит,

513
00:35:15,410 --> 00:35:20,750
так что если вы добавить 2 действительно большие целые числа, он просто не вписывается в целое число.

514
00:35:20,750 --> 00:35:23,660
Так что это то же самое здесь. Если вы перешли по 5,

515
00:35:23,660 --> 00:35:25,650
мы бы просто потерять, что один.

516
00:35:25,650 --> 00:35:28,820
И это вроде того, что я имею в виду "примерно"

517
00:35:28,820 --> 00:35:37,470
, где, если вы переносите слишком далеко, вы теряете биты.

518
00:35:37,470 --> 00:35:39,830
>> Сдвиг вправо будет наоборот,

519
00:35:39,830 --> 00:35:43,090
куда мы идем засунуть 0-х от конца,

520
00:35:43,090 --> 00:35:48,400
и для наших целей, заполните 0 с левого.

521
00:35:48,400 --> 00:35:52,910
Так делать это, мы в основном вспять то, что мы уже сделали.

522
00:35:52,910 --> 00:35:57,780
И мы видим, что три 0 о праве только отвалилась,

523
00:35:57,780 --> 00:36:02,020
и мы подтолкнули 1101 все до упора вправо.

524
00:36:02,020 --> 00:36:08,380
Это делает 104 >> 3, который является, по сути, х / 2 ^ у.

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

526
00:36:11,200 --> 00:36:18,720
Почему это только примерно х / 2 ^ у, а не на самом деле х / 2 ^ у?

527
00:36:18,720 --> 00:36:22,240
Потому что, если я сместился на 4, я бы потерял 1.

528
00:36:22,240 --> 00:36:25,950
В принципе, что вы думаете о, просто думаю, целочисленного деления в целом.

529
00:36:25,950 --> 00:36:31,070
Так что, как 5/2 составляет 2. Это не 2.5.

530
00:36:31,070 --> 00:36:35,000
Это та же идея здесь. Когда мы делим на 2,

531
00:36:35,000 --> 00:36:39,910
мы можем потерять нечетные биты на этом пути.

532
00:36:39,910 --> 00:36:43,870
Так что теперь - вот это для побитового. Вот и все, что вам нужно знать.

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
Здесь речь идет тетсру. Если бар достаточно долго,

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
и расти до нравится 4000000000 на дне.

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
Это когда основной вызывает функциональный Фу, вызывает функциональный бар,

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
Прибор является примером Маленькая индийской системе,

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
потому что 2 шестнадцатеричные цифры составляют один байт, и мы поменяем байт.

577
00:39:56,110 --> 00:40:00,300
Вот почему мы не храним, как, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Мы храним, вместо этого, каждую пару 2 цифры, начиная справа.

579
00:40:07,520 --> 00:40:10,880
Этот адрес указывает на адрес начала

580
00:40:10,880 --> 00:40:15,190
нашего буфера, что мы на самом деле хотели скопировать в в первую очередь.

581
00:40:15,190 --> 00:40:19,230
Причина, по которой полезно потому, что, что, если злоумышленник

582
00:40:19,230 --> 00:40:24,100
случилось с, вместо того, строку, которая была просто

583
00:40:24,100 --> 00:40:27,060
Безобидный строка, как их имя или что-то,

584
00:40:27,060 --> 00:40:33,900
что, если вместо, что строка были лишь некоторые произвольного кода

585
00:40:33,900 --> 00:40:38,610
что сделал все, что они хотели, чтобы это сделать?

586
00:40:38,610 --> 00:40:45,630
Таким образом, они могли - я не могу думать ни о каком прохладном кода.

587
00:40:45,630 --> 00:40:47,780
Это может быть что угодно, все же. Любой катастрофическими код.

588
00:40:47,780 --> 00:40:51,440
Если бы они хотели, они могли бы просто сделать что-то на сегментах неисправностей, но это было бы бессмысленно.

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
поэтому, если п + 1 больше мощности,

601
00:41:40,580 --> 00:41:44,140
то мы должны увеличить пропускную способность нашего буфера.

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

603
00:41:47,780 --> 00:41:51,840
И это продолжает идти, мы вставить символ в нашу буфера

604
00:41:51,840 --> 00:41:56,220
пока мы не получим новую линию или конец файла или любой другой,

605
00:41:56,220 --> 00:41:59,380
в этом случае, мы закончили со строки, а затем реальной GetString

606
00:41:59,380 --> 00:42:05,120
сжимается память, как если бы мы выделено слишком много памяти он будет вернуться и садятся немного.

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

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

609
00:42:11,960 --> 00:42:17,140
Она не может просто прочитать в целом вещь сразу,

610
00:42:17,140 --> 00:42:19,550
потому что их буфер только определенного размера.

611
00:42:19,550 --> 00:42:26,590
Таким образом, если строка, она попытается вставить в буфер слишком большой, то это было бы переполнить.

612
00:42:26,590 --> 00:42:28,940
И вот мы предотвратить это лишь чтение в один символ

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

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

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

616
00:42:42,310 --> 00:42:45,370
Так что я обратил внимание на важные вещи.

617
00:42:45,370 --> 00:42:49,460
Он призывает GetString, чтобы получить строку.

618
00:42:49,460 --> 00:42:51,710
Если GetString не вернулся память,

619
00:42:51,710 --> 00:42:54,270
помните, что GetString mallocs что-то, поэтому, когда вы звоните GetString

620
00:42:54,270 --> 00:42:57,820
вы не должны (неразборчиво) бесплатно эту строку, который вы получили.

621
00:42:57,820 --> 00:43:02,870
Так вот, если его не удалось Malloc что-то, мы возвращаемся INT_MAX просто как флаг, который,

622
00:43:02,870 --> 00:43:05,650
эй, мы не были на самом деле в состоянии получить целое.

623
00:43:05,650 --> 00:43:10,830
Вы должны игнорировать все, что я вернусь к вам, или

624
00:43:10,830 --> 00:43:15,540
вы не должны рассматривать это как правильный ввод.

625
00:43:15,540 --> 00:43:21,360
Наконец, полагая, что так получится, мы используем Sscanf с тем специальным флагом,

626
00:43:21,360 --> 00:43:23,820
что означает, в первую соответствовать целое,

627
00:43:23,820 --> 00:43:26,770
Затем соответствовать любым символам после этого целого.

628
00:43:26,770 --> 00:43:29,070
Так заметите, что мы хотим, чтобы он равен 1.

629
00:43:29,070 --> 00:43:32,940
Так Sscanf возвращается сколько матчей, если успешно сделал?

630
00:43:32,940 --> 00:43:37,010
Это вернет 1, если она успешно подобраны целое,

631
00:43:37,010 --> 00:43:40,890
это вернет 0, если она не соответствует целое, и он вернется 2

632
00:43:40,890 --> 00:43:45,920
если оно соответствует целому числу следуют некоторым характером.

633
00:43:45,920 --> 00:43:49,780
Так заметите, что мы повторить, насколько мы подходим ничего, кроме 1.

634
00:43:49,780 --> 00:43:55,230
Таким образом, если мы вошли 1, 2, 3, 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
Язык разметки гипертекста является структура и семантика в Интернете.

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
Так GET является версия, где вещь получает положить в 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
Вы никогда не будете иметь возможность установить закладку на POST URL

659
00:45:40,660 --> 00:45:44,970
поскольку данные не включены в URL.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, сейчас, является протокол передачи гипертекста.

661
00:45:49,790 --> 00:45:54,080
Протокол передачи гипертекста, можно было бы ожидать, что для передачи

662
00:45:54,080 --> 00:45:57,710
Язык разметки гипертекста, и это делает.

663
00:45:57,710 --> 00:46:00,170
Но это также передает любые изображения, которые вы найдете в Интернете,

664
00:46:00,170 --> 00:46:05,400
любые загрузки вы делаете начать как запросу HTTP.

665
00:46:05,400 --> 00:46:10,350
Так HTTP просто язык 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
И URL, что я пытался посетить был www.google.com/search?q = бла, бла, бла.

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

673
00:46:44,240 --> 00:46:49,040
является своего рода материал, который представляется в форме.

674
00:46:49,040 --> 00:46:51,830
Ответ может вернуться ко мне бы выглядеть примерно так.

675
00:46:51,830 --> 00:46:54,050
Опять же, начиная с протокола, который собирается быть, что,

676
00:46:54,050 --> 00:46:59,190
затем код состояния. Вот это 200 ОК.

677
00:46:59,190 --> 00:47:05,060
И, наконец, веб-страницы, что я на самом деле попросил последует.

678
00:47:05,060 --> 00:47:08,210
Возможный код состояния вы можете увидеть, и вы должны знать некоторые из них.

679
00:47:08,210 --> 00:47:12,770
200 ОК вы, наверное, видели раньше.

680
00:47:12,770 --> 00:47:17,830
403 Forbidden, 404 Not Found, Error 500 Internal Server

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 является 1 слой под HTTP.

688
00:47:43,050 --> 00:47:47,550
Помните, что существует Интернет за пределами Всемирной паутины.

689
00:47:47,550 --> 00:47:52,270
Подобно этому, если вы играете в онлайн игры, которая не проходит через HTTP,

690
00:47:52,270 --> 00:47:55,740
это будет через другой - она ​​по-прежнему с использованием Интернета,

691
00:47:55,740 --> 00:47:58,900
но он не использует HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP является лишь одним из примеров протокола построен на TCP / IP.

693
00:48:02,470 --> 00:48:07,820
IP буквально означает 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
но ваш компьютер имеет только 1 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
Каждое приложение получает 1 определенный порт, что он может слушать на,

711
00:49:17,230 --> 00:49:19,670
и по умолчанию, HTTP использует порт 80.

712
00:49:19,670 --> 00:49:22,410
Некоторые почтовые службы используют 25.

713
00:49:22,410 --> 00:49:24,490
Те, низким номером, как правило, защищены.

714
00:49:24,490 --> 00:49:29,270
Вы, как правило, в состоянии получить более высоким номером те для себя.

715
00:49:29,270 --> 00:49:32,010
>> CSS, каскадные таблицы стилей.

716
00:49:32,010 --> 00:49:36,030
Мы стиле веб-страниц с помощью CSS, а не с HTML.

717
00:49:36,030 --> 00:49:38,440
Есть 3 места, которые вы можете поместить свой 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
>> [Али Нама] Привет всем. Если бы я мог привлечь ваше внимание.

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
Поэтому он не может быть просто, как С, где вы вроде положить его в первую очередь.

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
внутр х или строка у, и так далее, и так далее.

754
00:52:09,470 --> 00:52:11,490
Так небольшая разница.

755
00:52:11,490 --> 00:52:15,590
В результате этого, это означает, что РНР является слабо типа.

756
00:52:15,590 --> 00:52:19,310
PHP является слабо язык Тип, и он слабо типизированные переменные.

757
00:52:19,310 --> 00:52:24,020
Другими словами, это означает, что вы можете переключаться между различными видами типов переменных.

758
00:52:24,020 --> 00:52:27,230
Вы можете сохранить свой номер 1 в виде целого числа,

759
00:52:27,230 --> 00:52:29,650
Вы можете сохранить его в виде строки, и вы можете сохранить его как поплавок,

760
00:52:29,650 --> 00:52:33,550
и это все будет, что число 1.

761
00:52:33,550 --> 00:52:36,080
Даже если вы хранить его в различных формах,

762
00:52:36,080 --> 00:52:39,120
она по-прежнему - типы переменных все еще держат в конце концов.

763
00:52:39,120 --> 00:52:41,540
Так что, если вы посмотрите сюда, если вы помните из PSet 7,

764
00:52:41,540 --> 00:52:43,500
многие из вас, вероятно, были проблемы с этим.

765
00:52:43,500 --> 00:52:47,280
Два знака равенства, 3 знака равенства, 4 знака равенства.

766
00:52:47,280 --> 00:52:49,990
Хорошо, нет 4 знака равенства, но есть 2 и 3.

767
00:52:49,990 --> 00:52:53,320
Вы можете использовать два знака равенства для проверки значений.

768
00:52:53,320 --> 00:52:55,830
Он может проверить по типам.

769
00:52:55,830 --> 00:52:58,770
Так что если вы можете видеть на первом примере,

770
00:52:58,770 --> 00:53:02,210
У меня есть num_int == num_string.

771
00:53:02,210 --> 00:53:06,710
Так что ваш внутр и ваша строка оба, технически, 1,

772
00:53:06,710 --> 00:53:10,790
но они разные типы. Но для двойных равных, это будет еще пройти.

773
00:53:10,790 --> 00:53:15,510
Тем не менее, для тройных равных, он проверяет значение, а также различные типы.

774
00:53:15,510 --> 00:53:18,760
Это означает, что он не собирается в тот втором случае здесь,

775
00:53:18,760 --> 00:53:22,350
где вы используете 3 знак равенства, а не.

776
00:53:22,350 --> 00:53:26,590
Так вот главное различие, что вы должны все показали сейчас.

777
00:53:26,590 --> 00:53:31,570
>> Объединение строк является еще одним мощным, что вы можете использовать в PHP.

778
00:53:31,570 --> 00:53:34,080
Это в основном только этот удобный точечной нотации,

779
00:53:34,080 --> 00:53:36,230
и вот как можно привязать строк вместе.

780
00:53:36,230 --> 00:53:40,800
Так что если у вас есть кошка и у вас есть собака, и вы хотите, чтобы положить 2 строки вместе,

781
00:53:40,800 --> 00:53:44,080
Вы можете использовать период, и это отчасти, как это работает.

782
00:53:44,080 --> 00:53:46,660
Вы также можете просто разместить их рядом друг с другом,

783
00:53:46,660 --> 00:53:49,030
как вы можете видеть здесь, в нижней Например,

784
00:53:49,030 --> 00:53:51,610
где я эхо строку 1, пространство строку 2.

785
00:53:51,610 --> 00:53:56,930
PHP будет знать, чтобы заменить их в качестве таковых.

786
00:53:56,930 --> 00:53:59,780
Массивы. Теперь, в PHP, есть 2 различные виды массивов.

787
00:53:59,780 --> 00:54:03,180
Вы можете иметь регулярные массивы, и вы также можете иметь ассоциативные массивы,

788
00:54:03,180 --> 00:54:06,040
и мы собираемся пройти через них прямо сейчас.

789
00:54:06,040 --> 00:54:08,280
Регулярные массивы просто это в 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
и поэтому вы можете увидеть, что есть 6, есть 4,

798
00:54:26,720 --> 00:54:29,160
а затем, как мы печати вещи,

799
00:54:29,160 --> 00:54:33,550
когда мы пытаемся и распечатать значения с индексом числа 0,

800
00:54:33,550 --> 00:54:36,900
тогда мы увидим значение 6 его распечатки. Круто?

801
00:54:36,900 --> 00:54:40,160
Так вот регулярные массивы для вас.

802
00:54:40,160 --> 00:54:42,750
Другим способом вы можете добавить вещи обычных массивов сейчас

803
00:54:42,750 --> 00:54:44,780
что вы можете просто добавить их в конце.

804
00:54:44,780 --> 00:54:47,240
Это означает, что вам не придется указывать конкретный индекс.

805
00:54:47,240 --> 00:54:51,000
Вы можете увидеть номер, а затем в квадратных скобках нет указанный индекс.

806
00:54:51,000 --> 00:54:56,270
И он будет знать, - PHP будет знать, чтобы просто добавить его в конец списка, следующего свободное место.

807
00:54:56,270 --> 00:54:59,190
Таким образом, вы можете увидеть 1 тут же в то 0 месте,

808
00:54:59,190 --> 00:55:02,690
2 пошел тут же в первом месте.

809
00:55:02,690 --> 00:55:04,690
3 идет - добавляется там же.

810
00:55:04,690 --> 00:55:06,720
Так что вид имеет смысл. Ты просто постоянно добавлять его,

811
00:55:06,720 --> 00:55:09,360
а потом, когда мы вторя индекс числа 1,

812
00:55:09,360 --> 00:55:13,080
он выдаст значение 2.

813
00:55:13,080 --> 00:55:16,800
>> Тогда у нас есть массивы, которые являются ассоциативные массивы.

814
00:55:16,800 --> 00:55:19,370
Ассоциативные массивы, вместо того, числовые индексы,

815
00:55:19,370 --> 00:55:23,630
что они делают, они имеют индексы, которые по строке.

816
00:55:23,630 --> 00:55:25,670
Вы можете видеть, вместо того, чтобы - я избавился от всех этих числовых индексов,

817
00:55:25,670 --> 00:55:32,140
и теперь это ключ1, ключ2, ключ3, и они в двойные кавычки, чтобы показать, что они все строки.

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
Так у вас есть синтаксис Еогеасп, так что это Еогеасп, вы положили массив.

842
00:56:56,490 --> 00:57:00,430
Так что мой массив называется PSET, а затем, слово как,

843
00:57:00,430 --> 00:57:04,530
а затем вы положите этот локальный временную переменную, что вы собираетесь использовать

844
00:57:04,530 --> 00:57:10,690
только для конкретной вещи, что происходит провести конкретный -

845
00:57:10,690 --> 00:57:14,770
один экземпляр или одна часть массива.

846
00:57:14,770 --> 00:57:18,350
Pset пит проведет 1, а затем, может быть, будет содержать номер 6,

847
00:57:18,350 --> 00:57:20,410
, а затем он будет содержать номер 2.

848
00:57:20,410 --> 00:57:26,630
Но это гарантированно пройти каждый одно значение, это в массиве.

849
00:57:26,630 --> 00:57:30,530
Полезные функции, которые вы должны знать в PHP являются требуют,

850
00:57:30,530 --> 00:57:35,880
так что делает уверены, что вы в том числе определенные файлы, эхо, выход, пустой.

851
00:57:35,880 --> 00:57:40,490
Я настоятельно рекомендую вам посмотреть на PSet 7 и посмотреть на этих функций.

852
00:57:40,490 --> 00:57:42,810
Возможно, вам придется знать тех,

853
00:57:42,810 --> 00:57:47,060
так что я точно знаю, будет то, что, собственно, те, все делают.

854
00:57:47,060 --> 00:57:50,080
>> А теперь мы собираемся пройти через рамки очень быстро.

855
00:57:50,080 --> 00:57:53,490
В рамках, PHP является своего рода фанки вещи, в отличие от C,

856
00:57:53,490 --> 00:57:56,170
и так мы только собираемся пройти через это быстро.

857
00:57:56,170 --> 00:57:58,930
Так скажем, мы начинаем в этом стрелки, что у нас есть.

858
00:57:58,930 --> 00:58:02,900
И мы собираемся начать с $ я. Таким образом, переменная 'я' будет 0,

859
00:58:02,900 --> 00:58:06,730
и мы только собираемся продолжать печатать его в этой большой белой коробке там.

860
00:58:06,730 --> 00:58:09,220
Мы собираемся начать с i0, а затем мы собираемся повторить его.

861
00:58:09,220 --> 00:58:12,670
Таким образом, есть 0.

862
00:58:12,670 --> 00:58:15,210
А потом мы собираемся увеличивать его на цикл,

863
00:58:15,210 --> 00:58:17,810
, а затем он будет значение 1.

864
00:58:17,810 --> 00:58:20,070
Один меньше 3, поэтому он собирается пройти через это цикл,

865
00:58:20,070 --> 00:58:23,230
и тогда мы увидим его снова напечатаны.

866
00:58:23,230 --> 00:58:25,520
Мы собираемся увеличить его снова до 2,

867
00:58:25,520 --> 00:58:29,860
и 2 меньше 3, поэтому он пройдет цикл, и он будет печатать 2.

868
00:58:29,860 --> 00:58:35,100
Тогда вы заметите, что 3 не меньше 3, поэтому мы вырваться из цикла.

869
00:58:35,100 --> 00:58:40,050
Так что теперь мы вышли, а затем мы собираемся идти в прекращение функции.

870
00:58:40,050 --> 00:58:45,010
Хорошо. Таким образом, вы должны отметить, что это переменная, которую мы создали,

871
00:58:45,010 --> 00:58:48,270
"Я" переменной, не локальной областью видимости.

872
00:58:48,270 --> 00:58:50,280
Это означает, что оно не является локальным в петлю,

873
00:58:50,280 --> 00:58:58,060
и что переменная, которую мы до сих пор могут получить доступ и изменить впоследствии, и она по-прежнему будет эффективным.

874
00:58:58,060 --> 00:59:02,160
Так что, если вы идете в функцию сейчас, вы увидите, что мы также используем "Я" переменную,

875
00:59:02,160 --> 00:59:05,320
и мы собираемся, чтобы увеличить 'я' + +.

876
00:59:05,320 --> 00:59:09,410
Можно было бы подумать, во-первых, на основе 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
Это означает, что то, тем не менее, даже если функция изменили значение "Я",

883
00:59:29,190 --> 00:59:32,620
это не изменило за пределами функции,

884
00:59:32,620 --> 00:59:35,060
потому что функция имеет отдельный объем.

885
00:59:35,060 --> 00:59:38,960
Это означает, что, когда мы эхо 'я', она не изменилась в области действия функции,

886
00:59:38,960 --> 00:59:43,660
и так, то мы собираемся напечатать 3 раз.

887
00:59:43,660 --> 00:59:47,520
Различные вещи о рамки в PHP, чем в С.

888
00:59:47,520 --> 00:59:51,130
>> Сейчас в PHP и HTML.

889
00:59:51,130 --> 00:59:53,510
PHP используется, чтобы сделать веб-страницы динамичными.

890
00:59:53,510 --> 00:59:58,660
Это отчасти делает вещи разные.

891
00:59:58,660 --> 01:00:02,090
У нас есть его отличие от HTML.

892
01:00:02,090 --> 01:00:05,230
С HTML, мы всегда только имеют тот же статический вещь, как то, как Роб показал,

893
01:00:05,230 --> 01:00:09,370
в то время как PHP, вы можете изменить вещи на основе, кем является пользователь.

894
01:00:09,370 --> 01:00:11,830
Так что, если у меня есть это, я, "Вы вошли как -" а затем имя,

895
01:00:11,830 --> 01:00:14,420
и я могу изменить имя. Так что сейчас зовут Иосиф,

896
01:00:14,420 --> 01:00:18,880
и у него есть "обо мне", но тогда я могу также изменить имя, чтобы иметь Томми.

897
01:00:18,880 --> 01:00:21,700
И это было бы другое дело.

898
01:00:21,700 --> 01:00:23,840
Так тогда мы можем также изменять различные вещи о нем,

899
01:00:23,840 --> 01:00:27,070
и он покажет различное содержание на основе имени.

900
01:00:27,070 --> 01:00:31,430
Итак, PHP может отчасти изменить то, что происходит в вашем сайте.

901
01:00:31,430 --> 01:00:33,540
То же самое здесь. Тем не менее, обратите внимание, что у них есть различный контент,

902
01:00:33,540 --> 01:00:38,870
даже если вы технически все еще доступ к этой же веб-страницу на поверхности.

903
01:00:38,870 --> 01:00:43,450
Создание HTML. Есть 2 различных способов, которыми вы можете сделать это.

904
01:00:43,450 --> 01:00:48,980
Таким образом, мы пройдем это прямо сейчас. Первый способ, у вас есть - да, жаль.

905
01:00:48,980 --> 01:00:51,150
Таким образом, вы просто должны вашей обычной для петли в PHP,

906
01:00:51,150 --> 01:00:56,270
и тогда вы эхом в PHP, и вы эхо из HTML.

907
01:00:56,270 --> 01:00:58,720
Используя то, что Роб показал вам из HTML сценария

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

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
это просто 1 кусок 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
А потом вы все равно увидите 3 изображения появляются на вашем сайте.

923
01:01:49,870 --> 01:01:52,820
Так что это 2 разные способы делать то же самое.

924
01:01:52,820 --> 01:01:55,060
>> Теперь у нас есть формы и запросы. Как Роб показал вам,

925
01:01:55,060 --> 01:01:59,400
Есть формы HTML, и мы как раз ветер через это.

926
01:01:59,400 --> 01:02:02,040
У вас есть действие и у вас есть метод, и ваши действия

927
01:02:02,040 --> 01:02:04,350
вид показывает вам, где вы собираетесь отправить его, а метод, является ли

928
01:02:04,350 --> 01:02:06,960
он собирается быть GET или POST.

929
01:02:06,960 --> 01:02:11,220
И запрос 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
это означает, что POST является более безопасным,

936
01:02:28,790 --> 01:02:34,420
но вы все еще можете увидеть это в твоих печенье в информации, вы посылаете.

937
01:02:34,420 --> 01:02:38,260
Так что не думаю, что об одном или другом.

938
01:02:38,260 --> 01:02:42,160
Другое дело, следует отметить, что у вас также есть раздел переменных.

939
01:02:42,160 --> 01:02:45,850
Вы, ребята использовали это в PSet 7, чтобы получить идентификатор пользователя информацию.

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
у нас есть эти 2 разные вещи, и мы хотим, чтобы выбрать из таблицы классов

960
01:03:56,740 --> 01:04:01,480
где удивительным - где в удивительном колонке значение равно 1.

961
01:04:01,480 --> 01:04:04,460
Таким образом, вы можете видеть здесь, у нас есть эти 2 вещи имени класса,

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

963
01:04:08,490 --> 01:04:13,150
Поэтому мы хотим, чтобы выбрать все, что информация.

964
01:04:13,150 --> 01:04:17,480
Тогда вы можете увидеть прямо здесь, что это отчасти выбирая из этой удивительной колонке,

965
01:04:17,480 --> 01:04:25,170
где все вещи 1, а затем она имеет идентификатор класса, имя класса и лозунг, что он может выбрать из.

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
Еогеасп петли, что мы просто перешли.

976
01:04:59,410 --> 01:05:01,280
Теперь, когда мы пробегаем по и мы сделали это в прошлом,

977
01:05:01,280 --> 01:05:05,080
давайте предположим, что наш запрос прошел, теперь у нас есть цикл по каждому элементу.

978
01:05:05,080 --> 01:05:11,050
И первая строка имеет, так что вот строка, прямо здесь, это в коробку.

979
01:05:11,050 --> 01:05:14,010
Это собирается распечатать всю информацию, которую он получил.

980
01:05:14,010 --> 01:05:18,070
Так это будет распечатать на дне "Хочешь узнать HTML?"

981
01:05:18,070 --> 01:05:23,370
Тогда это будет перейти к следующему ряду, потому что она завершена первая цикл,

982
01:05:23,370 --> 01:05:26,510
и так, то это будет распечатать вторую строку ней,

983
01:05:26,510 --> 01:05:32,120
который будет STAT110, Найти все моменты.

984
01:05:32,120 --> 01:05:34,290
>> И еще одно находится на SQL уязвимостей.

985
01:05:34,290 --> 01:05:37,300
Я знаю, Дэвид коснулся этого немного в лекции.

986
01:05:37,300 --> 01:05:40,730
Вы можете прочитать это позже. Это действительно забавно.

987
01:05:40,730 --> 01:05:45,320
SQL-инъекция является своего рода сложная вещь.

988
01:05:45,320 --> 01:05:49,890
Давайте предположим, что вы просто придерживаться этих переменных прямо в вашем запросе,

989
01:05:49,890 --> 01:05:52,290
как вы можете видеть в этом первой линии.

990
01:05:52,290 --> 01:05:54,520
Так что, похоже прекрасно, не так ли? Вы просто положить в имени пользователя

991
01:05:54,520 --> 01:05:58,820
и пароль в ваш запрос, и вы хотите грузить его и получить то, что находится в таблице данных.

992
01:05:58,820 --> 01:06:01,450
Это кажется довольно простым. Так что давайте говорить кто-то кладет в,

993
01:06:01,450 --> 01:06:04,910
для пароля, это или текст прямо здесь -

994
01:06:04,910 --> 01:06:06,780
должны на самом деле быть в красной коробке.

995
01:06:06,780 --> 01:06:11,920
Так скажем, что они вкладывают в этот пароль - это то, что они входят.

996
01:06:11,920 --> 01:06:16,520
Так они помещают или "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Вид глупой пароль, чтобы иметь.

998
01:06:20,880 --> 01:06:25,070
Теперь давайте просто заменить его, и вы заметите, что в этом SQL запросе, теперь,

999
01:06:25,070 --> 01:06:29,090
он оценивает всегда верно, потому что вы заметите, что

1000
01:06:29,090 --> 01:06:32,240
Вы можете SQL запросов выберите всю эту информацию

1001
01:06:32,240 --> 01:06:35,420
или вы можете просто есть 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
Так что всегда будет оценить к истине.

1003
01:06:41,030 --> 01:06:46,610
Это не будет по-настоящему работать, потому что это означает, что хакер может взломать вашу систему.

1004
01:06:46,610 --> 01:06:49,300
Решение этой проблемы является то, что вы должны использовать систему PDO,

1005
01:06:49,300 --> 01:06:51,360
Это означает, что вы должны использовать вопросительные знаки,

1006
01:06:51,360 --> 01:06:53,350
что и вы, ребята, используемые в PSet 7,

1007
01:06:53,350 --> 01:06:57,620
где вы собираетесь использовать вопросительный знак на месте, где вы хотите, чтобы положить что-то,

1008
01:06:57,620 --> 01:07:01,430
и тогда вы будете иметь запятую, а затем вы будете иметь после этого,

1009
01:07:01,430 --> 01:07:07,610
после строки, различные переменные, которые вы хотите заменить в ваш знак вопроса.

1010
01:07:07,610 --> 01:07:10,330
Таким образом, вы будете отметить, что теперь у меня есть эти красные вопросительные знаки.

1011
01:07:10,330 --> 01:07:15,420
Тогда я положил переменные после моих строк так что я знаю, чтобы заменить их в таком порядке после этого.

1012
01:07:15,420 --> 01:07:18,470
Это позволит убедиться, что если кто-то делает это, как это,

1013
01:07:18,470 --> 01:07:24,050
и у них есть или 1 = 1 ситуацию, что будет убедиться,

1014
01:07:24,050 --> 01:07:30,490
в задней части, убедитесь, что он не будет на самом деле сломать SQL запрос.

1015
01:07:30,490 --> 01:07:33,660
Хорошо, таким образом, что в значительной степени он, вихрь PHP и SQL.

1016
01:07:33,660 --> 01:07:41,520
Удачи всем вам, и теперь, чтобы штат Орегон

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Хорошо все. Время перейти некоторое наличие

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

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Да. JavaScript является своеобразной прохладном вещи, якобы.

1020
01:07:56,930 --> 01:07:59,090
То, что вы действительно должны знать о JavaScript, это вроде как

1021
01:07:59,090 --> 01:08:03,810
на стороне клиента конец того, что ваш веб-приложение будет делать.

1022
01:08:03,810 --> 01:08:08,280
Там-то вещи, которые вы просто не хотите, чтобы заботиться о все время на стороне сервера.

1023
01:08:08,280 --> 01:08:12,880
Все маленькие взаимодействия, подчеркнув одно, что делает что-то исчезает.

1024
01:08:12,880 --> 01:08:15,340
Вы действительно не хотите, чтобы поговорить с вашим сервером все время для этого.

1025
01:08:15,340 --> 01:08:18,069
И некоторые, что даже не представляется возможным сделать на стороне сервера.

1026
01:08:18,069 --> 01:08:21,899
Вот почему мы должны что-то вроде JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Прохладный вещи о 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
это означает, что синтаксис похож на С и РНР.

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
Вы можете просто придерживаться его в 1 объекта в 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, синтаксис Еогеасп.

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
Таким образом, вы можете поместить в строке Ferrari позже, и вы можете получить это.

1081
01:11:45,290 --> 01:11:50,000
И вы можете сделать это в цикле, с Ибо в петле.

1082
01:11:50,000 --> 01:11:53,320
Так что просто больше об объектах. Главное из этого вы должны помнить,

1083
01:11:53,320 --> 01:12:00,340
является то, что вы можете использовать объектную структуру подобный синтаксис, когда вы хотите с этим,

1084
01:12:00,340 --> 01:12:04,590
кроме того, если то, что ты собираешься использовать в виде строки не является допустимым именем переменной.

1085
01:12:04,590 --> 01:12:07,650
Так что, если вы посмотрите на что, у нас есть ключ с пробелами.

1086
01:12:07,650 --> 01:12:12,500
Ну, если бы вы были поставить object.key, пространство, с, пространство, пространства,

1087
01:12:12,500 --> 01:12:15,320
что просто не имело бы смысла синтаксически.

1088
01:12:15,320 --> 01:12:22,730
Таким образом, вы только можете сделать это с такого рода синтаксиса кронштейна.

1089
01:12:22,730 --> 01:12:26,520
>> Кроме того, JavaScript очень Сфера-мудро PHP.

1090
01:12:26,520 --> 01:12:29,050
У вас есть 2 пути решения сферу.

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

1104
01:13:18,790 --> 01:13:21,800
Я имею в виду, вот почему мы делаем это.

1105
01:13:21,800 --> 01:13:23,840
>> Чтобы сделать это, мы используем то, что называется DOM.

1106
01:13:23,840 --> 01:13:25,850
Объектной модели документа.

1107
01:13:25,850 --> 01:13:29,430
В общем, что она делает это занимает все ваше HTML

1108
01:13:29,430 --> 01:13:34,110
и модели его в кучу объектов, которые вложены друг в друга.

1109
01:13:34,110 --> 01:13:37,080
Вы начинаете с чем-то вроде этого.

1110
01:13:37,080 --> 01:13:44,770
У вас есть, справа для меня, куча кода, что там вроде -

1111
01:13:44,770 --> 01:13:46,640
Можно подумать, что было бы очень трудно манипулировать,

1112
01:13:46,640 --> 01:13:48,700
потому что вы бы разбора через кучу текста

1113
01:13:48,700 --> 01:13:52,080
и того, чтобы собрать кроме вещи. А что, если он не был правильно отформатирован?

1114
01:13:52,080 --> 01:13:54,880
Плохие вещи случится.

1115
01:13:54,880 --> 01:13:58,140
Так JavaScript заботится об этом для вас, и вы получите хороший структуру данных,

1116
01:13:58,140 --> 01:14:01,390
так, как на мой левый, где вы просто иметь документ,

1117
01:14:01,390 --> 01:14:03,530
и внутри, что у вас есть то, что называется HTML,

1118
01:14:03,530 --> 01:14:05,600
и внутри, что у вас есть голова и тело,

1119
01:14:05,600 --> 01:14:08,420
и внутри этой головы у вас есть название, и так далее, и так далее, и так далее.

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

1121
01:14:11,810 --> 01:14:14,190
о, я просто хочу поговорить с этим объектом.

1122
01:14:14,190 --> 01:14:21,340
Вроде очень похоже вы говорить с другим объектом вы сделали сами.

1123
01:14:21,340 --> 01:14:25,980
Как я уже сказал, все DOM в объекте документа.

1124
01:14:25,980 --> 01:14:29,290
Либо это просто одно место, а затем вы можете пойти в нем, чтобы найти вещи,

1125
01:14:29,290 --> 01:14:33,880
и вы можете сделать это - это старый стиль делают это, там,

1126
01:14:33,880 --> 01:14:38,130
где вы делаете document.getElementById, а затем имя,

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

1128
01:14:42,420 --> 01:14:44,480
Таким образом, вы, вероятно, не хотят этого делать. Вот почему у нас есть

1129
01:14:44,480 --> 01:14:48,760
Следующее, что мы собираемся говорить о после этого.

1130
01:14:48,760 --> 01:14:52,510
Главное здесь то, что, все в порядке, у вас есть все эти элементы, не так ли?

1131
01:14:52,510 --> 01:14:56,400
Поэтому, возможно, я могу изменить цвет что-то при загрузке страницы.

1132
01:14:56,400 --> 01:14:58,380
Ну и что? Что делать, если пользователь нажимает что-то?

1133
01:14:58,380 --> 01:15:00,540
Я хочу, чтобы сделать что-то интересное, когда он нажимает что-то.

1134
01:15:00,540 --> 01:15:02,600
Вот почему у нас есть события.

1135
01:15:02,600 --> 01:15:05,330
Вы можете, в принципе, найти любой элемент в вашем DOM,

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

1137
01:15:08,560 --> 01:15:11,410
или когда они мыши над ним, что-то сделать с ним.

1138
01:15:11,410 --> 01:15:15,330
И что у вас есть, у вас есть функции, которые обрабатывают это для вас.

1139
01:15:15,330 --> 01:15:17,980
Эти функции обработчики событий.

1140
01:15:17,980 --> 01:15:20,440
Что they're - это всего лишь причудливый способ сказать,

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

1142
01:15:23,500 --> 01:15:28,070
Так он обрабатывает событие, возникающее.

1143
01:15:28,070 --> 01:15:30,810
Это, как вы бы выложить обработчик событий.

1144
01:15:30,810 --> 01:15:34,750
У меня есть кнопки, а при нажатии ее, она взрывается.

1145
01:15:34,750 --> 01:15:40,560
Так что не нажать кнопку.

1146
01:15:40,560 --> 01:15:42,910
Это один из способов приближения к нему, не так ли?

1147
01:15:42,910 --> 01:15:46,430
У вас есть кнопка тег, и по щелчку у вас есть строка, которая говорит,

1148
01:15:46,430 --> 01:15:50,460
о, кстати, я делаю это взрывающийся вещь для меня.

1149
01:15:50,460 --> 01:15:53,990
В противном случае, это просто, как обычный кнопку вы только что сделали.

1150
01:15:53,990 --> 01:15:56,550
Вы также можете сделать это по-другому,

1151
01:15:56,550 --> 01:16:02,770
, захватывая элемент DOM, но мы оставим, что после того как мы говорим о 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
И вы также должны некоторые данные для отправки, или, может быть, это без данных запросов.

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
Итак, мы получаем обратно этот "привет мир", и в случае успешного завершения этого

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
И это очень простой способ создания запроса Ajax.

1224
01:20:31,560 --> 01:20:34,340
>> Очень быстро, Роб рода упомянул об этом уже,

1225
01:20:34,340 --> 01:20:37,170
все может пойти не так, плохие вещи могут случиться,

1226
01:20:37,170 --> 01:20:42,660
так что вы хотите, чтобы ознакомиться с этими кодами HTTP реагирования.

1227
01:20:42,660 --> 01:20:46,030
Что это просто, как, 200, все прошло хорошо.

1228
01:20:46,030 --> 01:20:48,670
Что-то еще, плохие вещи произошло.

1229
01:20:48,670 --> 01:20:50,790
Это вообще, что вы хотите запомнить.

1230
01:20:50,790 --> 01:20:53,440
Но приятно знать, все это.

1231
01:20:53,440 --> 01:20:55,970
И, наконец, как только мы прошли через все это,

1232
01:20:55,970 --> 01:20:58,680
мы должны говорить очень быстро о дизайне,

1233
01:20:58,680 --> 01:21:00,620
и тогда мы сможем позволить вам всем уйти.

1234
01:21:00,620 --> 01:21:03,410
Дизайн. То, что вы хотите запомнить.

1235
01:21:03,410 --> 01:21:06,950
Задайте себе эти вопросы: Кто будет использовать это?

1236
01:21:06,950 --> 01:21:09,580
Что они будут использовать его для? Что мои пользователи заботятся о?

1237
01:21:09,580 --> 01:21:11,750
Что они не заботятся о?

1238
01:21:11,750 --> 01:21:14,500
Вы просто не хотите сделать приложение, и пусть он просто расти

1239
01:21:14,500 --> 01:21:18,270
и стать этот гигант, всепоглощающей, что вы не можете даже закончить.

1240
01:21:18,270 --> 01:21:23,900
Вы хотите иметь дискретные цели и планы и вещи, которые вы хотите обратиться.

1241
01:21:23,900 --> 01:21:29,000
Сделать это легко. Все это говорит, в основном,

1242
01:21:29,000 --> 01:21:34,950
сделать его легким для пользователя, чтобы использовать его, не сделать его гигантский сгусток текста как этот слайд, собственно.

1243
01:21:34,950 --> 01:21:38,020
Вы просто хотите, чтобы он что-то где это очень легко для кого-то идти в

1244
01:21:38,020 --> 01:21:40,800
и делать то, что они хотят сделать.

1245
01:21:40,800 --> 01:21:42,920
Вы же не хотите, чтобы они имели ориентироваться 5 страниц

1246
01:21:42,920 --> 01:21:45,460
чтобы добраться до вашего премьер-функции вашего сайта.

1247
01:21:45,460 --> 01:21:49,290
Если Google было 5 страниц, прежде чем вы могли даже искать что-то,

1248
01:21:49,290 --> 01:21:53,080
никто не будет использовать его.

1249
01:21:53,080 --> 01:21:55,890
И, наконец, бумага прототип, фокус-группа.

1250
01:21:55,890 --> 01:21:59,220
Есть хороший дизайн и практики тестирования.

1251
01:21:59,220 --> 01:22:00,730
Просто потому, что вы думаете, он работает для вас,

1252
01:22:00,730 --> 01:22:04,860
не означает, кто-то еще думает, что это работает.

1253
01:22:04,860 --> 01:22:14,490
Но да, вот оно что.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]