1
00:00:00,000 --> 00:00:12,610

2
00:00:12,610 --> 00:00:12,900
>> Дэвид Дж. Малан: Хорошо.

3
00:00:12,900 --> 00:00:16,790
Так что добро пожаловать первой в истории
CS50 посмертное для викторины.

4
00:00:16,790 --> 00:00:18,340
Мы думали, что открывать
эта традиция в этом году.

5
00:00:18,340 --> 00:00:20,960
И это будет возможность
идти через

6
00:00:20,960 --> 00:00:22,220
решения викторины.

7
00:00:22,220 --> 00:00:26,160
И мы будем ускорить или замедлить основе
на интересах тех, кто здесь.

8
00:00:26,160 --> 00:00:29,730
>> Таким образом, вы, вероятно, здесь, потому что вы
заинтересованы в том, как вы могли бы или

9
00:00:29,730 --> 00:00:31,170
должны ответили некоторые
из этих проблем.

10
00:00:31,170 --> 00:00:33,300
Так почему бы нам не взглянуть
в этом разделе в первую очередь?

11
00:00:33,300 --> 00:00:34,450
Поэтому получение строк.

12
00:00:34,450 --> 00:00:37,600
Это дало вам три различных версии
программы, которая была, в конечном счете,

13
00:00:37,600 --> 00:00:39,650
означало, чтобы получить строку от пользователя.

14
00:00:39,650 --> 00:00:42,530
Или нет, это сделал, что было
оставляется вам определить.

15
00:00:42,530 --> 00:00:45,150
>> И мы попросили в вопросе 0,
Предположим, что версия 1

16
00:00:45,150 --> 00:00:46,400
скомпилирована и выполнена.

17
00:00:46,400 --> 00:00:48,860
Почему может программа сегментации?

18
00:00:48,860 --> 00:00:51,150
На первый взгляд, любые предложения
, почему?

19
00:00:51,150 --> 00:00:54,012

20
00:00:54,012 --> 00:00:54,489
Да.

21
00:00:54,489 --> 00:00:59,260
>> АУДИТОРИЯ: Так что я помню, это в
Предыдущий пример смотреть на

22
00:00:59,260 --> 00:01:05,506
символ * с и видя сканирование с и
видя, потому что это указатель, как

23
00:01:05,506 --> 00:01:07,971
это повлияло на то, что вы сканируется в?

24
00:01:07,971 --> 00:01:10,940
Является это с или адрес с?

25
00:01:10,940 --> 00:01:11,180
>> Дэвид Дж. Малан: ОК.

26
00:01:11,180 --> 00:01:11,480
Хорошо.

27
00:01:11,480 --> 00:01:14,830
Таким образом, в конечном счете, источник любой проблемы
Предположительно собирается сократить

28
00:01:14,830 --> 00:01:16,210
к этому переменной с.

29
00:01:16,210 --> 00:01:17,280
И это действительно переменная.

30
00:01:17,280 --> 00:01:19,900
Тип данных этой переменной является
символ *, что означает, что это собирается

31
00:01:19,900 --> 00:01:22,570
содержать адрес символа.

32
00:01:22,570 --> 00:01:23,850
И в этом заключается понимание.

33
00:01:23,850 --> 00:01:28,330
Это собирается содержать адрес
символ или, более общо,

34
00:01:28,330 --> 00:01:32,110
адрес первого символа в
целый блок символов.

35
00:01:32,110 --> 00:01:36,680
>> Но загвоздка в том, что сканирование с, цель в
жизнь, дается адрес и с учетом

36
00:01:36,680 --> 00:01:40,960
код формата, как% с, чтения
строка в кусок

37
00:01:40,960 --> 00:01:42,330
памяти по этому адресу.

38
00:01:42,330 --> 00:01:46,040
Но поскольку нет знака равенства перед
что точка с запятой на первый

39
00:01:46,040 --> 00:01:49,310
строка кода, потому что мы на самом деле не
выделяет памяти с

40
00:01:49,310 --> 00:01:53,020
таНос, потому что это на самом деле не
выделить массив какой-то размера, все

41
00:01:53,020 --> 00:01:57,620
вы делаете читает пользователя
ввод с клавиатуры в некоторых полной

42
00:01:57,620 --> 00:02:00,490
значение мусора, которые
находится в с по умолчанию.

43
00:02:00,490 --> 00:02:04,480
Так шансы вы собираетесь к выпадению, если
что адрес не просто так случиться

44
00:02:04,480 --> 00:02:08,009
быть значение, которое вы можете,
на самом деле, напишите.

45
00:02:08,009 --> 00:02:10,889
Так плохо не выделить
ваша память есть.

46
00:02:10,889 --> 00:02:13,150
>> Таким образом, в вопросе 1, мы спросили,
Предположим, что версия 2

47
00:02:13,150 --> 00:02:14,230
скомпилирована и выполнена.

48
00:02:14,230 --> 00:02:15,900
Почему может эта программа сегментации?

49
00:02:15,900 --> 00:02:17,990
Так что это один меньше ошибок.

50
00:02:17,990 --> 00:02:21,470
И есть действительно только один
очевидный способ, где вы можете

51
00:02:21,470 --> 00:02:22,810
вызвать сегментации здесь.

52
00:02:22,810 --> 00:02:23,730
И это тематическая.

53
00:02:23,730 --> 00:02:28,180
Каждый раз, когда мы используем с в памяти, что
вы могли бы сделать, чтобы вызвать сегментации

54
00:02:28,180 --> 00:02:30,718
с версии 2?

55
00:02:30,718 --> 00:02:35,560
>> АУДИТОРИЯ: Если вы используете этот вход в
строка это больше, чем 49

56
00:02:35,560 --> 00:02:35,975
символов.

57
00:02:35,975 --> 00:02:37,260
>> Дэвид Дж. Малан: Совершенно верно.

58
00:02:37,260 --> 00:02:41,420
Каждый раз, когда вы видите что-то фиксированной длины
когда дело доходит до массива, ваш

59
00:02:41,420 --> 00:02:44,650
РЛС должна погаснуть, что это может быть
проблематично, если вы не проверяя

60
00:02:44,650 --> 00:02:45,810
Границы массива.

61
00:02:45,810 --> 00:02:46,650
И это проблема.

62
00:02:46,650 --> 00:02:47,910
Мы все еще используем зсапЕ.

63
00:02:47,910 --> 00:02:52,200
Мы все еще используете% S, что означает, попробовать
читать строку от пользователя.

64
00:02:52,200 --> 00:02:56,300
Вот которые будут читать в с,,
в этой точке, эффективно

65
00:02:56,300 --> 00:02:58,570
адрес кусок памяти
или это эквивалентно.

66
00:02:58,570 --> 00:03:02,080
Это имя массива
символов памяти.

67
00:03:02,080 --> 00:03:07,610
>> Но именно это, если вы читаете строку
это больше, чем 49 символов, 49

68
00:03:07,610 --> 00:03:10,440
потому что вам нужно место для обратной косой черты
0, вы будете переполняться

69
00:03:10,440 --> 00:03:11,390
что буфер.

70
00:03:11,390 --> 00:03:16,410
И ты можешь стать счастливчиком и быть в состоянии
написать 51-й характер, 52, 53.

71
00:03:16,410 --> 00:03:18,560
Но в какой-то момент, ОС
собирается сказать, нет.

72
00:03:18,560 --> 00:03:21,270
Это определенно не памяти
Вам разрешают трогать.

73
00:03:21,270 --> 00:03:23,380
И программа будет к выпадению.

74
00:03:23,380 --> 00:03:26,650
>> Так что, эвристика должно быть никаких
Время у вас есть фиксированную длину, у вас есть

75
00:03:26,650 --> 00:03:30,150
чтобы убедиться, что вы проверяете длину
из то, что вы пытаетесь

76
00:03:30,150 --> 00:03:31,090
читать в нее.

77
00:03:31,090 --> 00:03:35,110
>> АУДИТОРИЯ: Таким образом, чтобы решить, что, вы могли бы
имели о проверки на самом деле

78
00:03:35,110 --> 00:03:37,140
длина больше
или меньше?

79
00:03:37,140 --> 00:03:37,730
>> Дэвид Дж. Малан: Совершенно верно.

80
00:03:37,730 --> 00:03:41,706
Вы просто есть условие
что говорит, если -

81
00:03:41,706 --> 00:03:46,080
или, скорее, вам не обязательно знать,
заранее, сколько символов

82
00:03:46,080 --> 00:03:49,060
пользователь собирается ввести, потому что
у вас есть курица и яйцо.

83
00:03:49,060 --> 00:03:51,860
Не, пока вы не читали его с зсапЕ
Вы можете выяснить, как долго это.

84
00:03:51,860 --> 00:03:54,500
Но в тот момент, что это слишком поздно,
потому что вы уже читали его в

85
00:03:54,500 --> 00:03:55,710
некоторый блок памяти.

86
00:03:55,710 --> 00:03:59,590
Так как в сторону, библиотека CS50 избегает
этот вопрос в целом, напомним,

87
00:03:59,590 --> 00:04:01,060
с помощью fgetc.

88
00:04:01,060 --> 00:04:05,390
И он читает один символ за один раз,
цыпочках вдоль, зная, что вам

89
00:04:05,390 --> 00:04:08,060
не может переполниться характер, если
Вы читаете по одному.

90
00:04:08,060 --> 00:04:11,580
>> Загвоздка в том, с GetString отзыве является
что мы должны постоянно изменять размеры

91
00:04:11,580 --> 00:04:13,590
что часть памяти, которая
это просто боль.

92
00:04:13,590 --> 00:04:15,310
Это много линий
Код этого делать.

93
00:04:15,310 --> 00:04:18,779
Так что другой подход будет
на самом деле использовать двоюродный брат, так

94
00:04:18,779 --> 00:04:19,790
сказать, зсапЕ.

95
00:04:19,790 --> 00:04:22,820
Существуют варианты Многие из этих
функции, которые на самом деле проверить

96
00:04:22,820 --> 00:04:25,870
длина, сколько символов
Вы могли бы читать максимально.

97
00:04:25,870 --> 00:04:29,430
А вы могли бы указать, не читайте
более 50 символов.

98
00:04:29,430 --> 00:04:34,110
Так что было бы другой подход, но
менее любезным из больших входов.

99
00:04:34,110 --> 00:04:37,040
>> Так вопрос 2 спрашивает, предположим, что версия
3 составляется и выполняется.

100
00:04:37,040 --> 00:04:39,960
Почему же это программа сегментации?

101
00:04:39,960 --> 00:04:42,650
Так что это один на самом деле то же самое
ответить, хотя это

102
00:04:42,650 --> 00:04:43,590
выглядит немного более необычным.

103
00:04:43,590 --> 00:04:46,440
Мы используем таНос, который чувствует себя подобно
мы даем себе больше возможностей.

104
00:04:46,440 --> 00:04:48,030
А потом мы освобождая, что
памяти в конце.

105
00:04:48,030 --> 00:04:49,580
Он по-прежнему всего 50 байт памяти.

106
00:04:49,580 --> 00:04:53,620
Таким образом, мы могли бы все еще пытаюсь читать
в 51, 52, 1000 байт.

107
00:04:53,620 --> 00:04:55,830
Это собирается к выпадению для
точно так же причина.

108
00:04:55,830 --> 00:04:57,530
>> Но есть и другая причина.

109
00:04:57,530 --> 00:05:03,890
Что еще могло Malloc возвращение к тому же
адрес кусок памяти?

110
00:05:03,890 --> 00:05:04,920
Это может вернуть нулевой.

111
00:05:04,920 --> 00:05:07,560
И потому, что мы не проверяя
что мы могли бы делать что-то

112
00:05:07,560 --> 00:05:11,350
глупо и по другой причине, которая является, что
мы могли бы рассказывать зсапЕ, читать

113
00:05:11,350 --> 00:05:16,050
ввод пользователя с клавиатуры
в 0 месте, AKA нуль.

114
00:05:16,050 --> 00:05:18,890
И это тоже, безусловно,
вызвать сегментации.

115
00:05:18,890 --> 00:05:21,590
Таким образом, для целей тест, мы бы
приняли один из тех, как

116
00:05:21,590 --> 00:05:22,740
веская причина.

117
00:05:22,740 --> 00:05:23,420
Одним из них является идентичным.

118
00:05:23,420 --> 00:05:25,720
Одним из них является немного больше нюансов.

119
00:05:25,720 --> 00:05:28,975
>> Наконец, в отношении програмы
использование памяти, как же версии 2 и

120
00:05:28,975 --> 00:05:30,350
версия 3 отличаются?

121
00:05:30,350 --> 00:05:35,070
Таким образом, для чего это стоит, мы видели
казалось бы, бесконечное количество можно

122
00:05:35,070 --> 00:05:35,770
Ответы на этот.

123
00:05:35,770 --> 00:05:39,300
И среди ответов людей, то, что мы были
надеясь на, но мы приняли другое

124
00:05:39,300 --> 00:05:42,250
вещи, было некоторое упоминание о
Дело в том, что версия 2 использует

125
00:05:42,250 --> 00:05:44,560
так называемый стек.

126
00:05:44,560 --> 00:05:46,710
Версия 3 использует кучу.

127
00:05:46,710 --> 00:05:50,060
И функционально, это на самом деле не
сделать все, что особой разницы.

128
00:05:50,060 --> 00:05:54,040
В конце концов, мы все еще
просто получить 50 байт памяти.

129
00:05:54,040 --> 00:05:56,640
>> Но это был один из возможных ответов
что мы смотрели.

130
00:05:56,640 --> 00:05:59,730
Но вы увидите, как вы получите ваш викторины
назад от ТФ, что мы сделали

131
00:05:59,730 --> 00:06:04,330
принять другие обсуждения их
разрозненные использования памяти, а также.

132
00:06:04,330 --> 00:06:08,600
Но стек и куча бы
простой ответ, чтобы пойти с.

133
00:06:08,600 --> 00:06:11,150
Есть вопросы?

134
00:06:11,150 --> 00:06:12,400
Я даю вам Роб.

135
00:06:12,400 --> 00:06:18,360

136
00:06:18,360 --> 00:06:20,210
>> ROB BOWDEN: Так проблема 4.

137
00:06:20,210 --> 00:06:21,985
Это то место, где вы должны были заполнить
в число байтов из всех

138
00:06:21,985 --> 00:06:23,460
эти различные типы, используемые.

139
00:06:23,460 --> 00:06:24,830
Так первое, что мы видим.

140
00:06:24,830 --> 00:06:27,930
Предположим, 32-разрядную архитектуру,
как этот CS50 прибора.

141
00:06:27,930 --> 00:06:33,530
Таким образом, одна из основных вещей, о
32-битные архитектуры, который говорит нам,

142
00:06:33,530 --> 00:06:37,490
точно, как большой указатель собирается
находиться в архитектуре.

143
00:06:37,490 --> 00:06:43,020
>> Так сразу, мы знаем, что любой указатель
тип 32 бита или 4 байта.

144
00:06:43,020 --> 00:06:46,010
Так, глядя на эту таблицу,
узел * является указателем.

145
00:06:46,010 --> 00:06:47,250
Это будет 4 байта.

146
00:06:47,250 --> 00:06:51,640
Структура, узел *, вот буквально
идентичен узла звезды.

147
00:06:51,640 --> 00:06:53,590
И так, что это будет 4 байта.

148
00:06:53,590 --> 00:06:58,270
Строка, так что не похож
указатель пока нет, но ЬурейеЕ,

149
00:06:58,270 --> 00:07:01,590
строка просто символ *, который
является тип указателя.

150
00:07:01,590 --> 00:07:03,550
Так что это будет 4 байта.

151
00:07:03,550 --> 00:07:06,150
>> Таким образом, эти три все 4 байта.

152
00:07:06,150 --> 00:07:09,350
Теперь, узел и ученик являются
немного сложнее.

153
00:07:09,350 --> 00:07:15,160
Так, глядя на узле и ученика, мы видим,
узел в виде целого числа и указатель.

154
00:07:15,160 --> 00:07:18,050
И студент два указателя
внутри него.

155
00:07:18,050 --> 00:07:23,340
Так по крайней мере в нашем случае здесь, то, как
что мы в конечном итоге расчета размера

156
00:07:23,340 --> 00:07:27,020
эта структура просто сложить все
что находится внутри структуры.

157
00:07:27,020 --> 00:07:30,690
>> Таким образом, для узла, у нас есть целое,
который имеет размер 4 байта.

158
00:07:30,690 --> 00:07:32,830
У нас есть указатель, который является 4 байта.

159
00:07:32,830 --> 00:07:35,820
И так один узел собирается
занять 8 байт.

160
00:07:35,820 --> 00:07:39,490
И точно так же для студентов, у нас есть
Указатель вот 4 байта, а другой

161
00:07:39,490 --> 00:07:40,770
Указатель вот 4 байта.

162
00:07:40,770 --> 00:07:43,180
Так что будет в конечном
тем, что 8 байт.

163
00:07:43,180 --> 00:07:45,480
Так узел и ученик 8 байт.

164
00:07:45,480 --> 00:07:48,950
И эти три все 4 байта.

165
00:07:48,950 --> 00:07:50,240
Вопросы по этому поводу?

166
00:07:50,240 --> 00:07:54,640

167
00:07:54,640 --> 00:07:54,990
Да.

168
00:07:54,990 --> 00:07:58,413
>> Зала: это был 64-разрядный
архитектура, хотел бы, чтобы

169
00:07:58,413 --> 00:07:59,880
удвоить все из них?

170
00:07:59,880 --> 00:08:01,790
>> ROB BOWDEN: Это не так
удвоить все из них.

171
00:08:01,790 --> 00:08:05,830
Так 64-разрядная архитектура, это, опять же,
изменения, которые фундаментальная вещь, которая

172
00:08:05,830 --> 00:08:08,910
Указатель Сейчас 64 бита.

173
00:08:08,910 --> 00:08:09,290
Да.

174
00:08:09,290 --> 00:08:10,930
Так указатель составляет 8 байт.

175
00:08:10,930 --> 00:08:15,420
Таким образом, эти, что были 4 байта
будут 8 байт.

176
00:08:15,420 --> 00:08:18,617
Студент, который был два указателя,
хорошо, теперь он собирается

177
00:08:18,617 --> 00:08:19,800
быть 8 байт, 8 байт.

178
00:08:19,800 --> 00:08:21,980
Это собирается сделать 16 байт.

179
00:08:21,980 --> 00:08:25,710
>> Но узел еще 4 байта.

180
00:08:25,710 --> 00:08:27,800
Так этот указатель будет
чтобы быть 8 байтов.

181
00:08:27,800 --> 00:08:28,930
Это 4 байта.

182
00:08:28,930 --> 00:08:30,870
Так узел будет только
быть 12 байт.

183
00:08:30,870 --> 00:08:36,309

184
00:08:36,309 --> 00:08:39,280
Любые другие вопросы о том, что один?

185
00:08:39,280 --> 00:08:44,500
Таким образом, следующий, это
коды состояния HTTP.

186
00:08:44,500 --> 00:08:48,000
И у вас было бы описать обстоятельства
, при которых они могли бы

187
00:08:48,000 --> 00:08:49,810
Вам возвращены.

188
00:08:49,810 --> 00:08:56,730
одна проблема, что я слышал, некоторые студенты
есть то, что они попытались сделать

189
00:08:56,730 --> 00:08:58,950
Ошибки быть на конце клиента.

190
00:08:58,950 --> 00:09:02,320
Поэтому, когда мы пытаемся сделать запрос
на сервер, что-то идет

191
00:09:02,320 --> 00:09:03,820
неправильно с нашей стороны.

192
00:09:03,820 --> 00:09:07,660
Но в целом, эти коды
возвращается на сервере.

193
00:09:07,660 --> 00:09:11,720
Поэтому мы хотим, чтобы выяснить, что происходит
неправильно или прямо на сервере,

194
00:09:11,720 --> 00:09:14,280
вызывает эти вещи должны быть возвращены.

195
00:09:14,280 --> 00:09:18,670
Так почему могли бы через сервер возвращает
Код состояния 200?

196
00:09:18,670 --> 00:09:19,920
Любые мысли?

197
00:09:19,920 --> 00:09:23,360

198
00:09:23,360 --> 00:09:23,730
>> Да.

199
00:09:23,730 --> 00:09:27,850
Так что-то успешно
запрос прошел.

200
00:09:27,850 --> 00:09:30,260
И они смогли вернуться
все, что вы просили.

201
00:09:30,260 --> 00:09:32,240
Так что все было прекрасно.

202
00:09:32,240 --> 00:09:35,662
Что о 302 найдено?

203
00:09:35,662 --> 00:09:36,618
Да.

204
00:09:36,618 --> 00:09:39,008
>> АУДИТОРИЯ: Сервер искал
за то, что вы просили.

205
00:09:39,008 --> 00:09:40,442
Но это не мог найти его.

206
00:09:40,442 --> 00:09:42,850
Таким образом, есть ошибка.

207
00:09:42,850 --> 00:09:47,720
>> ROB BOWDEN: Так сервер был
ищет то, что вы хотели.

208
00:09:47,720 --> 00:09:51,682
Так что просто глядя здесь, 302 найдено,
он был в состоянии найти его.

209
00:09:51,682 --> 00:09:53,035
>> АУДИТОРИЯ: Мне очень жаль.

210
00:09:53,035 --> 00:09:54,388
Найдено означает, что они нашли его.

211
00:09:54,388 --> 00:09:55,638
Извините.

212
00:09:55,638 --> 00:09:58,120

213
00:09:58,120 --> 00:10:00,160
>> ROB BOWDEN: Так 302 найдено.

214
00:10:00,160 --> 00:10:02,350
Сервер способен найти
что вы хотели.

215
00:10:02,350 --> 00:10:04,640
>> АУДИТОРИЯ: Но это не отображая его?

216
00:10:04,640 --> 00:10:08,180
>> ROB BOWDEN: Разница между
это 302 и 200 является то, что он

217
00:10:08,180 --> 00:10:09,280
знает, что вы хотите.

218
00:10:09,280 --> 00:10:12,000
Но это не точно, где
вы хотели спросить.

219
00:10:12,000 --> 00:10:14,580
Так 302 является типичным редирект.

220
00:10:14,580 --> 00:10:16,510
Таким образом, вы запросили страницу.

221
00:10:16,510 --> 00:10:19,590
Она знает, о, я хочу
вернуться тебе это.

222
00:10:19,590 --> 00:10:21,070
Но это в другом URL.

223
00:10:21,070 --> 00:10:23,534
Так эй, вы на самом деле хотите этого.

224
00:10:23,534 --> 00:10:26,950
>> Дэвид Дж. Малан: Это кусок, что сказал
что мы дали вы, ребята редирект

225
00:10:26,950 --> 00:10:30,830
функция, которая использовалась функция заголовка
что, в свою очередь, распечатать местоположение,

226
00:10:30,830 --> 00:10:34,110
толстой кишки, а затем URL, к которому
Вы хотите, чтобы отклонить пользователя.

227
00:10:34,110 --> 00:10:37,480
Даже если вы не видели 302
явно есть, это то, что РНР

228
00:10:37,480 --> 00:10:41,550
волшебным вставить в качестве заголовка
говоря, что именно сказал Роб там -

229
00:10:41,550 --> 00:10:41,930
найдено.

230
00:10:41,930 --> 00:10:43,180
Но идут сюда вместо этого.

231
00:10:43,180 --> 00:10:45,960

232
00:10:45,960 --> 00:10:46,160
>> ROB BOWDEN: ОК.

233
00:10:46,160 --> 00:10:47,630
Так что о 403 запрещено?

234
00:10:47,630 --> 00:10:52,240

235
00:10:52,240 --> 00:10:57,120
>> Зала: Я думаю, что это то, что сервер
в основном говорит, что клиент

236
00:10:57,120 --> 00:10:59,970
не может получить доступ к домашней странице.

237
00:10:59,970 --> 00:11:03,260
>> ROB BOWDEN: Так что, да.

238
00:11:03,260 --> 00:11:07,670
Ну, типичный ответ мы были
ожидая что-то подобное, файлы

239
00:11:07,670 --> 00:11:08,920
не chmodded соответствующим образом.

240
00:11:08,920 --> 00:11:11,590
Это, вероятно, при каких обстоятельствах
вы видели их.

241
00:11:11,590 --> 00:11:18,920
Но есть причина, что клиент
может быть виноваты в этом.

242
00:11:18,920 --> 00:11:20,440
Там на самом деле другой код состояния -

243
00:11:20,440 --> 00:11:21,210
401.

244
00:11:21,210 --> 00:11:22,820
Так что это очень похоже.

245
00:11:22,820 --> 00:11:24,590
>> 401 является несанкционированным.

246
00:11:24,590 --> 00:11:26,130
И 403 запрещено.

247
00:11:26,130 --> 00:11:31,890
И так несанкционированного вы исключительно
получить, если вы не прошли идентификацию

248
00:11:31,890 --> 00:11:34,520
Но регистрация может означать
что вы имеете право.

249
00:11:34,520 --> 00:11:37,930
Но если вы уже зарегистрированы, и вы
до сих пор не имеет разрешения, то

250
00:11:37,930 --> 00:11:40,140
вы также можете получить запрещено.

251
00:11:40,140 --> 00:11:45,320
Так что, если вы вошли в систему и не имеют
разрешение, запрещено также

252
00:11:45,320 --> 00:11:47,164
то, что вы можете получить.

253
00:11:47,164 --> 00:11:48,900
>> Дэвид Дж. Малан: И механизм, с помощью
которой эти проблемы, как правило

254
00:11:48,900 --> 00:11:53,100
решается на сервере
через то, что команда?

255
00:11:53,100 --> 00:11:57,700
CHMOD, если это, действительно, прав
выдавать на файл или каталог.

256
00:11:57,700 --> 00:11:59,220
>> ROB BOWDEN: Тогда 404 не найден.

257
00:11:59,220 --> 00:12:03,100

258
00:12:03,100 --> 00:12:03,470
Да.

259
00:12:03,470 --> 00:12:10,150
Так в отличие от 302, где это не было точно
где вы спрашиваете, но он знает, что

260
00:12:10,150 --> 00:12:12,710
вы хотите, это, он просто должен
никакая идея, что вы хотите.

261
00:12:12,710 --> 00:12:15,648
И вы не с просьбой
что-то действует.

262
00:12:15,648 --> 00:12:18,580

263
00:12:18,580 --> 00:12:22,310
418 Я чайник, а затем
500 внутренний сервер.

264
00:12:22,310 --> 00:12:24,870
Так почему может ты это взял?

265
00:12:24,870 --> 00:12:26,120
>> Так сегментации -

266
00:12:26,120 --> 00:12:28,760

267
00:12:28,760 --> 00:12:30,640
Я на самом деле не знаю, градуировку
стандарт для этого.

268
00:12:30,640 --> 00:12:34,850
Но если ваш код PHP было что-то
в этом плохого, в теории, это могло

269
00:12:34,850 --> 00:12:39,650
фактически сегментации, в каком случае это
500 Внутренняя ошибка сервера, то,

270
00:12:39,650 --> 00:12:41,400
не так с вашего сервера
Конфигурация.

271
00:12:41,400 --> 00:12:44,320
Или есть ошибка синтаксиса
в коде PHP.

272
00:12:44,320 --> 00:12:46,095
Или что-то плохое происходит.

273
00:12:46,095 --> 00:12:48,320
>> Дэвид Дж. Малан: Мы действительно видели сегментации
среди ответов в нескольких людей.

274
00:12:48,320 --> 00:12:49,490
И технически, это может произойти.

275
00:12:49,490 --> 00:12:53,820
Но это было бы PHP, программа
написаны другими людьми, на самом деле

276
00:12:53,820 --> 00:12:57,790
segfaulted, которые только если эти люди
облажался и написал ошибка в программном коде в

277
00:12:57,790 --> 00:13:00,680
их переводчик были бы
Сам PHP сегментации.

278
00:13:00,680 --> 00:13:06,460
Поэтому, даже если 500 подобен сегментации
в духе, это почти всегда

279
00:13:06,460 --> 00:13:10,490
результатом вопросу конфигурационного файла
с вашего веб-сервера, или, как сказал Роб,

280
00:13:10,490 --> 00:13:13,200
ошибка синтаксиса, как и вы
не закрывал цитату.

281
00:13:13,200 --> 00:13:16,180
Или вы потеряли точку с запятой где-то.

282
00:13:16,180 --> 00:13:23,677
>> АУДИТОРИЯ: Таким образом, для Shuttle PSet, я
думаю, когда я сделал это, как только я нажал

283
00:13:23,677 --> 00:13:26,300
браузер, но ничего подошел,
то, что они называют белым страницы.

284
00:13:26,300 --> 00:13:28,056
Но это было, потому что часть кода.

285
00:13:28,056 --> 00:13:29,440
Я думаю, что было JavaScript, верно?

286
00:13:29,440 --> 00:13:29,770
>> ROB BOWDEN: Да.

287
00:13:29,770 --> 00:13:31,180
>> АУДИТОРИЯ: о, если бы ошибка
еще придумать?

288
00:13:31,180 --> 00:13:34,290
>> ROB BOWDEN: Таким образом, вы бы не получили
эта ошибка, потому что все

289
00:13:34,290 --> 00:13:36,930
с точки зрения веб-сервера
было абсолютно прекрасно.

290
00:13:36,930 --> 00:13:39,090
Но вы просили index.html.

291
00:13:39,090 --> 00:13:42,000
Вы просили shuttle.js
и service.js.

292
00:13:42,000 --> 00:13:44,580
И это было в состоянии успешно вернуться
Вам всем из тех вещей -

293
00:13:44,580 --> 00:13:44,980
200.

294
00:13:44,980 --> 00:13:45,680
ОК.

295
00:13:45,680 --> 00:13:49,330
И только когда ваш браузер пытался
интерпретировать код JavaScript, что

296
00:13:49,330 --> 00:13:51,370
Это как, подождите, это не
действует ошибка JavaScript.

297
00:13:51,370 --> 00:13:55,720

298
00:13:55,720 --> 00:13:58,210
Любые другие вопросы?

299
00:13:58,210 --> 00:14:00,750
Хорошо.

300
00:14:00,750 --> 00:14:04,120
>> Дэвид Дж. Малан: Так что в следующий
составил число 11.

301
00:14:04,120 --> 00:14:07,610
И 11 было самым страшным
для многих людей.

302
00:14:07,610 --> 00:14:14,620

303
00:14:14,620 --> 00:14:18,570
Таким образом, самое главное, чтобы отметить здесь
было то, что это было, действительно, о

304
00:14:18,570 --> 00:14:19,840
двусвязный список.

305
00:14:19,840 --> 00:14:23,160
Но это не было так же, как в прошлом году
двусвязного проблема список,

306
00:14:23,160 --> 00:14:27,170
которые не дают вам оговоркой, что
список можно, в самом деле, быть отсортированы.

307
00:14:27,170 --> 00:14:29,640
>> Поэтому тот факт, что список был несортированный
и тот факт, что это слово было

308
00:14:29,640 --> 00:14:32,930
подчеркнутый там должен был передать
что это на самом деле упрощение

309
00:14:32,930 --> 00:14:35,430
о том, что в противном случае было бы
более сложной проблемой

310
00:14:35,430 --> 00:14:36,600
и более длинный.

311
00:14:36,600 --> 00:14:40,760
Так распространенная ошибка здесь в том, чтобы поставили
решение в прошлом году на одном

312
00:14:40,760 --> 00:14:45,580
пейджер, а затем просто слепо копировать, что
вниз в ответ, что право

313
00:14:45,580 --> 00:14:48,520
ответить на другой вопрос
близки по духу.

314
00:14:48,520 --> 00:14:51,340
Но тонкости здесь
были следующие.

315
00:14:51,340 --> 00:14:55,200
>> Так что, мы узел объявлены и
определяется обычным образом здесь.

316
00:14:55,200 --> 00:14:59,230
После этого мы определили список быть глобальным
указатель инициализируется на нуль.

317
00:14:59,230 --> 00:15:02,150
Тогда, по-видимому, есть две функции
у нас есть прототипы здесь, вставка

318
00:15:02,150 --> 00:15:03,240
и удалить.

319
00:15:03,240 --> 00:15:06,600
А то у нас некоторые примеры кода здесь
делать кучу вставок.

320
00:15:06,600 --> 00:15:09,930
И тогда мы просим Вас заполнить
реализация вставки ниже в таких

321
00:15:09,930 --> 00:15:14,380
образом, что он вставляет п в список
за постоянное время, также подчеркнул,

322
00:15:14,380 --> 00:15:15,730
даже если уже присутствует.

323
00:15:15,730 --> 00:15:20,600
>> Так красота возможность вставить
в постоянном времени является то, что он предполагает

324
00:15:20,600 --> 00:15:23,060
что у вас есть, чтобы вставить
новый узел, где?

325
00:15:23,060 --> 00:15:23,690
В передней.

326
00:15:23,690 --> 00:15:27,760
Так он устраняет, к счастью, по крайней мере,
один из случаев, которые раньше требуют

327
00:15:27,760 --> 00:15:30,520
еще больше строк кода, как это было
в прошлом году и даже в классе, когда мы

328
00:15:30,520 --> 00:15:34,040
говорили через такого рода вещи
с людьми и с некоторыми

329
00:15:34,040 --> 00:15:35,250
словесное псевдо-код.

330
00:15:35,250 --> 00:15:39,190
Таким образом, в решении здесь, давайте пропустить
к тому, что просто иметь визуальный контакт

331
00:15:39,190 --> 00:15:40,480
экран.

332
00:15:40,480 --> 00:15:42,230
>> Обратите внимание, что мы делаем следующее.

333
00:15:42,230 --> 00:15:45,140
А также обратите внимание на другую упрощение
было то, что даже если это

334
00:15:45,140 --> 00:15:48,280
уже присутствует, это означает, даже если
количество уже есть, вы можете

335
00:15:48,280 --> 00:15:50,280
просто слепо вставить другой
его копия.

336
00:15:50,280 --> 00:15:52,560
И это тоже должно было быть
упрощение, так что вы могли бы

337
00:15:52,560 --> 00:15:54,940
сосредоточиться на, действительно, некоторые из более
интеллектуально интересная часть и

338
00:15:54,940 --> 00:15:58,090
не только некоторые дополнительные проверки ошибок
учитывая ограниченное время.

339
00:15:58,090 --> 00:16:02,880
>> Так что в этом примере решения, мы выделяем
указатель на левой

340
00:16:02,880 --> 00:16:04,510
сторону здесь к узлу.

341
00:16:04,510 --> 00:16:07,190
Теперь понимаю, что указатель, как
Роб сказал, только 32 бит.

342
00:16:07,190 --> 00:16:09,060
И это на самом деле не содержат
адрес до вас

343
00:16:09,060 --> 00:16:09,970
присвоить ему адрес.

344
00:16:09,970 --> 00:16:13,220
И мы делаем это на правой
сторона через таНос.

345
00:16:13,220 --> 00:16:16,550
Как добропорядочный гражданин, мы проверяем, что
таНос не является, по сути, нулевой, так что

346
00:16:16,550 --> 00:16:18,690
мы не случайно создать
сегментации здесь.

347
00:16:18,690 --> 00:16:22,840
И каждый раз при использовании таНос в жизни, вам
должны быть проверки нуль, чтобы

348
00:16:22,840 --> 00:16:24,090
у вас есть тонкий ошибка.

349
00:16:24,090 --> 00:16:28,460
>> Тогда мы инициализировать эту нуль на
присвоения п и предыдущий и следующий.

350
00:16:28,460 --> 00:16:32,450
И в этом случае здесь, я инициализации
предыдущая в нуль, потому что это новое

351
00:16:32,450 --> 00:16:34,780
узел будет новый
начало моего списка.

352
00:16:34,780 --> 00:16:37,050
Так что это будет
ничего перед ним.

353
00:16:37,050 --> 00:16:42,010
И я хочу, чтобы существенно добавить
существующий список в новый узел по

354
00:16:42,010 --> 00:16:44,700
сидит рядом равна список себя.

355
00:16:44,700 --> 00:16:47,120
Но я не сделал только пока.

356
00:16:47,120 --> 00:16:51,780
Так что, если сам список уже существует,
и было по крайней мере один узел

357
00:16:51,780 --> 00:16:57,070
уже на месте, если это список
здесь, и я вставить новый узел здесь, я

358
00:16:57,070 --> 00:17:01,840
нужно убедиться, что мой бывший узел
указывает назад, чтобы мой новый узел,

359
00:17:01,840 --> 00:17:04,260
потому что это, опять же,
двусвязный список.

360
00:17:04,260 --> 00:17:05,460
>> Так мы делаем есть простой тест.

361
00:17:05,460 --> 00:17:10,109
Если список не пуст, если есть уже
один или более узлов там, тогда

362
00:17:10,109 --> 00:17:12,470
добавить, что еще ссылку, так сказать.

363
00:17:12,470 --> 00:17:15,420
И тогда очень Последнее, что нам нужно
сделать, это на самом деле обновить глобальный

364
00:17:15,420 --> 00:17:20,329
Список переменных сама указать
к тому новому узлу.

365
00:17:20,329 --> 00:17:21,790
Да.

366
00:17:21,790 --> 00:17:26,579
>> АУДИТОРИЯ: В стрелкой указателя
[Неразборчиво] равна нуль, значит ли это

367
00:17:26,579 --> 00:17:30,420
дело со списком, потому что
список пуст?

368
00:17:30,420 --> 00:17:30,596
>> Дэвид Дж. Малан: Нет.

369
00:17:30,596 --> 00:17:34,500
Это просто я, будучи активно
осторожны, в том, что если это мое

370
00:17:34,500 --> 00:17:38,730
первоначальный список с, возможно, некоторые более узлов
здесь и я вставить мой

371
00:17:38,730 --> 00:17:42,380
Новый узел сюда, там собирается
не что иное сюда.

372
00:17:42,380 --> 00:17:44,720
И я хочу, чтобы захватить эту идею
, установив предшествующий

373
00:17:44,720 --> 00:17:47,740
нуль на новом узле.

374
00:17:47,740 --> 00:17:51,410
И надо полагать, если мой код правильный
и нет никакого другого способа для вставки

375
00:17:51,410 --> 00:17:54,970
кроме этой функции узлов,
предположительно, даже если список уже есть

376
00:17:54,970 --> 00:18:00,090
один или несколько узлов в нем, по-видимому,
список, первый узел, будет иметь

377
00:18:00,090 --> 00:18:02,750
предыдущая указатель самой нуль.

378
00:18:02,750 --> 00:18:03,550
>> АУДИТОРИЯ: И просто продолжением.

379
00:18:03,550 --> 00:18:08,139
Причина вы положили указатель следующая равно
Список вы делаете указатель

380
00:18:08,139 --> 00:18:13,579
перед список в том, что он, указывая
к другому, я думаю, -

381
00:18:13,579 --> 00:18:14,980
Я не -

382
00:18:14,980 --> 00:18:15,450
просто перечисляет?

383
00:18:15,450 --> 00:18:16,400
>> Дэвид Дж. Малан: Совершенно верно.

384
00:18:16,400 --> 00:18:19,400
И поэтому давайте на самом деле рассмотреть два случая
здесь действительно, несмотря на то,

385
00:18:19,400 --> 00:18:22,070
Порядок мы будем учитывать их не
совершенно так же, как код.

386
00:18:22,070 --> 00:18:26,250
Но на высоком уровне, если это представляет
список, и это 32-разрядная

387
00:18:26,250 --> 00:18:29,560
указатель, самый простой сценарий
что это нуль по умолчанию.

388
00:18:29,560 --> 00:18:33,010
И предположим, что я хочу, чтобы вставить
номер 50 был первым номером.

389
00:18:33,010 --> 00:18:37,640
Так что я собираюсь идти вперед и выделить
узел, который будет содержать

390
00:18:37,640 --> 00:18:38,770
три поля -

391
00:18:38,770 --> 00:18:42,070
п, предыдущей и следующей.

392
00:18:42,070 --> 00:18:44,580
>> Я собираюсь поставить номер 50
здесь, потому что это будет н.

393
00:18:44,580 --> 00:18:46,130
Это будет следующий.

394
00:18:46,130 --> 00:18:48,530
И это будет предыдущая.

395
00:18:48,530 --> 00:18:50,910
И так что же мне делать в этом случае?

396
00:18:50,910 --> 00:18:53,900
Ну, я только что сделал линию 1 здесь.

397
00:18:53,900 --> 00:18:55,400
Указатель н получает н.

398
00:18:55,400 --> 00:18:57,740
Я тогда говорил, предыдущая
должны получить нулевой.

399
00:18:57,740 --> 00:18:59,470
Так что это будет нулевым.

400
00:18:59,470 --> 00:19:01,365
Тогда я буду говорить дальше
собирается получить список.

401
00:19:01,365 --> 00:19:05,150
>> И это просто работает хорошо.

402
00:19:05,150 --> 00:19:06,500
Это нуль.

403
00:19:06,500 --> 00:19:10,620
И поэтому я говорю, нового узла рядом
поле должно получить то, что это.

404
00:19:10,620 --> 00:19:12,570
Так что ставит еще один нуль там.

405
00:19:12,570 --> 00:19:14,510
И то последнее, что
Я это проверить здесь.

406
00:19:14,510 --> 00:19:17,870
Если список не равно NULL, но это
равна нуль, поэтому мы пропускаем, что

407
00:19:17,870 --> 00:19:18,470
в целом.

408
00:19:18,470 --> 00:19:23,520
И так все, что я делать дальше, список становится
указатель, который наглядно приводит к

409
00:19:23,520 --> 00:19:25,570
картина так.

410
00:19:25,570 --> 00:19:26,620
Так вот один сценарий.

411
00:19:26,620 --> 00:19:30,490
>> И тот, который вы спрашивали о
специально это ситуация, как это,

412
00:19:30,490 --> 00:19:33,190
где у нас уже есть список с одним узлом.

413
00:19:33,190 --> 00:19:36,240
И если я вернусь в оригинале
постановка проблемы, на следующий мы будем

414
00:19:36,240 --> 00:19:39,320
вставить скажем на 34, только для
ради обсуждения.

415
00:19:39,320 --> 00:19:46,210
Так что я собираюсь просто удобно
привлечь, что здесь.

416
00:19:46,210 --> 00:19:47,540
Я только что malloced.

417
00:19:47,540 --> 00:19:49,310
Давайте предположим, я проверяю для нуль.

418
00:19:49,310 --> 00:19:51,870
>> Теперь, я собираюсь инициализации
н быть 34.

419
00:19:51,870 --> 00:19:53,040
И это будет н.

420
00:19:53,040 --> 00:19:54,670
Это будет следующий.

421
00:19:54,670 --> 00:19:57,100
И это будет предыдущая.

422
00:19:57,100 --> 00:19:59,370
Давайте убедиться, что я не сделал
получить назад.

423
00:19:59,370 --> 00:20:01,110
Предыдущий приходит первым
в определении.

424
00:20:01,110 --> 00:20:03,070
Позвольте мне исправить это.

425
00:20:03,070 --> 00:20:04,410
Это предыдущая.

426
00:20:04,410 --> 00:20:05,780
Это рядом.

427
00:20:05,780 --> 00:20:08,620
Даже если они идентичны,
давайте держать его последовательным.

428
00:20:08,620 --> 00:20:09,450
>> Предыдущий.

429
00:20:09,450 --> 00:20:11,030
Это рядом.

430
00:20:11,030 --> 00:20:16,310
Так что я просто malloced мою записку, проверил
для нуль, назначен 34 в узел.

431
00:20:16,310 --> 00:20:17,570
Предыдущий получает нуль.

432
00:20:17,570 --> 00:20:19,480
Так, что дает мне это.

433
00:20:19,480 --> 00:20:21,010
Следующая получает список.

434
00:20:21,010 --> 00:20:22,370
Так список это.

435
00:20:22,370 --> 00:20:26,520
Так что это то же самое сейчас, как рисование это
стрелка, так что они указывают на один

436
00:20:26,520 --> 00:20:27,940
в то же самое.

437
00:20:27,940 --> 00:20:30,400
А потом я проверяю, если список
не равен NULL.

438
00:20:30,400 --> 00:20:31,740
И это не в этот раз.

439
00:20:31,740 --> 00:20:35,580
Тогда я собираюсь сделать список
предыдущая получает указатель.

440
00:20:35,580 --> 00:20:39,700
>> Так списку предыдущий получает PTR.

441
00:20:39,700 --> 00:20:44,300
Таким образом, это имеет эффект ввода
графическое стрелка здесь.

442
00:20:44,300 --> 00:20:46,930
И это становится немного
волнистые, линии.

443
00:20:46,930 --> 00:20:50,780
А потом, наконец, обновить
список, чтобы указать на указатель.

444
00:20:50,780 --> 00:20:55,560
Так что теперь это указывает на этого парня.

445
00:20:55,560 --> 00:20:57,170
А теперь, давайте сделаем краткий
здравомыслие проверка.

446
00:20:57,170 --> 00:20:59,470
>> Вот список, который является
глобальная переменная.

447
00:20:59,470 --> 00:21:02,850
Первый узел, действительно, 34, потому что
Я слежу, что стрелку.

448
00:21:02,850 --> 00:21:05,210
И это правильно, потому что я хочу
вставить в начале списка

449
00:21:05,210 --> 00:21:06,070
все новые узлы.

450
00:21:06,070 --> 00:21:08,860
Его следующее поле приводит меня к этому парню.

451
00:21:08,860 --> 00:21:10,710
Если я продолжаю, я ударил рядом является недействительным.

452
00:21:10,710 --> 00:21:11,760
Так нет больше список.

453
00:21:11,760 --> 00:21:14,460
Если бы я ударил предыдущий, я получаю
туда, где я ожидаю.

454
00:21:14,460 --> 00:21:16,435
>> Так что есть еще несколько советов,
очевидно, манипулировать.

455
00:21:16,435 --> 00:21:19,870
Но то, что вы сказали сделать
это в постоянном времени означает, что вы только

456
00:21:19,870 --> 00:21:22,910
имеют конечное число вещей
Вам разрешают сделать.

457
00:21:22,910 --> 00:21:24,290
И что это за число?

458
00:21:24,290 --> 00:21:25,185
Это может быть на один шаг.

459
00:21:25,185 --> 00:21:25,700
Это может быть два.

460
00:21:25,700 --> 00:21:26,820
Это может быть 1000 шагов.

461
00:21:26,820 --> 00:21:30,500
Но это конечная, а значит, вы не можете
есть какой-либо петлеобразования происходит

462
00:21:30,500 --> 00:21:32,010
здесь, не рекурсивно, без петель.

463
00:21:32,010 --> 00:21:37,390
Это просто должно быть жестко-закодированных строк
кода, как у нас в этом образце.

464
00:21:37,390 --> 00:21:42,330
>> Так что в следующий Проблема 12 попросили нас
завершить реализацию Удалить

465
00:21:42,330 --> 00:21:46,740
Ниже таким образом, что она удаляет
н из списка в линейное время.

466
00:21:46,740 --> 00:21:48,740
Так у вас есть немного больше
маневра сейчас.

467
00:21:48,740 --> 00:21:52,380
Вы можете считать, что п, если он присутствует
в списке, будет присутствовать

468
00:21:52,380 --> 00:21:53,340
не более чем один раз.

469
00:21:53,340 --> 00:21:56,770
И это тоже предназначается, чтобы быть викторина на основе
упрощающее предположение, так

470
00:21:56,770 --> 00:21:59,780
что, если вы найдете номер 50 где-то
в списке, вы не также

471
00:21:59,780 --> 00:22:02,890
придется беспокоиться о продолжая
итерации, ищу все возможные

472
00:22:02,890 --> 00:22:06,990
копия 50, что бы просто передавать
в некоторых мелочах в ограниченное время.

473
00:22:06,990 --> 00:22:10,460
>> Так что с удалить, этот был определенно
более сложной и более

474
00:22:10,460 --> 00:22:11,640
Код писать.

475
00:22:11,640 --> 00:22:14,990
Но на первый взгляд, откровенно говоря, это могло бы
искать подавляющее и как что-то

476
00:22:14,990 --> 00:22:17,060
нет никакого способа, вы могли бы
придумать на викторине.

477
00:22:17,060 --> 00:22:22,450
Но если мы ориентируемся на отдельных этапов,
Надеюсь, он будет внезапно

478
00:22:22,450 --> 00:22:26,060
ударить вас, что каждый из этих индивидуальных
шаги делает очевидным смысл

479
00:22:26,060 --> 00:22:27,080
в ретроспективе.

480
00:22:27,080 --> 00:22:28,200
Так что давайте взглянем.

481
00:22:28,200 --> 00:22:32,570
>> Итак, сначала мы инициализируем указатель
быть список себя.

482
00:22:32,570 --> 00:22:36,040
Потому что я хочу линейное время, что средства
Я собираюсь есть цикл.

483
00:22:36,040 --> 00:22:39,730
И обычный способ для перебора
узлы в структуре списка или любого вида

484
00:22:39,730 --> 00:22:43,860
структуры многократно это взять
указатель на передней части данных

485
00:22:43,860 --> 00:22:46,990
Структура, а затем просто начать обновление
это и идти свой путь

486
00:22:46,990 --> 00:22:48,650
через структуру данных.

487
00:22:48,650 --> 00:22:50,040
Так что я собираюсь сделать именно это.

488
00:22:50,040 --> 00:22:54,260
>> В то время как указатель, моя временная переменная,
не равно NULL, давайте

489
00:22:54,260 --> 00:22:55,660
идти вперед и проверить.

490
00:22:55,660 --> 00:22:56,910
Разве я повезет?

491
00:22:56,910 --> 00:23:01,740
Является ли поле п в узле Я в настоящее время
глядя на равной

492
00:23:01,740 --> 00:23:03,380
число Я ищу?

493
00:23:03,380 --> 00:23:05,410
И если да, то давайте что-то делать.

494
00:23:05,410 --> 00:23:10,020
Теперь, обратите внимание это, если условие
окружает весь

495
00:23:10,020 --> 00:23:11,520
Следующие строки кода.

496
00:23:11,520 --> 00:23:14,610
Это единственное, что меня волнует -
найти номер в вопрос.

497
00:23:14,610 --> 00:23:18,010
Так нет еще, что упрощает
вещи концептуально немного.

498
00:23:18,010 --> 00:23:22,040
>> Но теперь я понял, и вы, возможно,
только понял это, подумав

499
00:23:22,040 --> 00:23:24,720
это через некоторое время, есть
на самом деле два случая здесь.

500
00:23:24,720 --> 00:23:28,060
Одним из них является где узел находится на
начало списка, который является

501
00:23:28,060 --> 00:23:31,040
немного раздражает, потому что это
особый случай, потому что вы должны иметь дело

502
00:23:31,040 --> 00:23:33,340
с этой вещью, которая
является единственным аномалия.

503
00:23:33,340 --> 00:23:35,720
Всюду еще в списке,
это то же самое.

504
00:23:35,720 --> 00:23:38,050
Там в предыдущий узел и рядом
узел, предыдущий узел, следующий узел.

505
00:23:38,050 --> 00:23:40,940
Но этот парень стоит несколько особняком,
если он в самом начале.

506
00:23:40,940 --> 00:23:48,710
>> Таким образом, если указатель равен список
Сам, так что если я в начале

507
00:23:48,710 --> 00:23:53,960
список, и я нашел п, мне нужно
сделать несколько вещей.

508
00:23:53,960 --> 00:23:59,230
Один из них, мне нужно изменить список
указывают на следующее поле, 50.

509
00:23:59,230 --> 00:24:01,270
Так предположить, что я пытаюсь
удалить 34.

510
00:24:01,270 --> 00:24:03,560
Так этот парень должен идти
далеко в мгновение.

511
00:24:03,560 --> 00:24:07,210
>> Так что я собираюсь сказать, список
получает указатель рядом.

512
00:24:07,210 --> 00:24:08,570
Ну, это указатель.

513
00:24:08,570 --> 00:24:10,360
Следующая указывает здесь.

514
00:24:10,360 --> 00:24:17,470
Так эта ситуация меняется эту стрелку право
Теперь, чтобы указать на этого парня здесь.

515
00:24:17,470 --> 00:24:19,580
Теперь, помните, у нас есть
временная переменная.

516
00:24:19,580 --> 00:24:23,520
Таким образом, мы не осиротел любые узлы,
потому что я также с этим парнем в моем

517
00:24:23,520 --> 00:24:25,010
реализация удаляется.

518
00:24:25,010 --> 00:24:29,600
Так что теперь, если сам список не является пустым,
Мне нужно, чтобы исправить кое-что.

519
00:24:29,600 --> 00:24:32,690
>> Мне нужно теперь убедиться, что эта стрелка,
который предварительно указывая

520
00:24:32,690 --> 00:24:36,830
от 50 до 34, это должно уйти,
потому что если я пытаюсь избавиться

521
00:24:36,830 --> 00:24:41,910
из 34, 50 лучше не поддерживать любой
вид обратная ссылка на него как

522
00:24:41,910 --> 00:24:42,820
стрелка предложил.

523
00:24:42,820 --> 00:24:44,820
Так что я просто сделал эту линию.

524
00:24:44,820 --> 00:24:46,520
Итак я сделал.

525
00:24:46,520 --> 00:24:48,040
Это дело на самом деле довольно просто.

526
00:24:48,040 --> 00:24:51,010
Отрубание головы списка
относительно проста.

527
00:24:51,010 --> 00:24:52,980
>> К сожалению, есть такой
раздражает еще блок.

528
00:24:52,980 --> 00:24:56,170
Так что теперь, я должен рассмотреть случай
где есть что-то в середине.

529
00:24:56,170 --> 00:24:59,880
Но это не так уж страшно, за исключением
синтаксиса, как это.

530
00:24:59,880 --> 00:25:03,080
Так что, если я не в начале
Список, я где-то в середине.

531
00:25:03,080 --> 00:25:08,160
И эта линия здесь говорит, старт
на все, что узел вы находитесь.

532
00:25:08,160 --> 00:25:11,210

533
00:25:11,210 --> 00:25:18,550
Переход к следующему полю предыдущего узла
и указывают, что на указатель.

534
00:25:18,550 --> 00:25:20,390
>> Давайте сделаем это графически.

535
00:25:20,390 --> 00:25:21,640
Это становилось сложнее.

536
00:25:21,640 --> 00:25:30,480

537
00:25:30,480 --> 00:25:37,990
Так что, если у меня есть предыдущие поля здесь -
давайте сделаем это - здесь следующие поля.

538
00:25:37,990 --> 00:25:41,200
Я собираюсь упростить мои указатели, а
чем нарисовать целую кучу

539
00:25:41,200 --> 00:25:45,710
вещи назад и вперед перекрещивающиеся
друг к другу.

540
00:25:45,710 --> 00:25:50,870
А теперь, давайте просто скажем, что это 1, 2,
3 ради обсуждения, даже

541
00:25:50,870 --> 00:25:53,410
хотя это не совпадать с
данная проблема.

542
00:25:53,410 --> 00:25:55,900
>> Итак, вот мой связанный список.

543
00:25:55,900 --> 00:25:59,300
Я пытаюсь удалить два в этом
частности версия истории.

544
00:25:59,300 --> 00:26:01,960
Так я обновил указатель
быть указывая на этого парня.

545
00:26:01,960 --> 00:26:03,315
Так что это PTR.

546
00:26:03,315 --> 00:26:04,530
Он указывает здесь.

547
00:26:04,530 --> 00:26:07,170
Это список, который существует
глобально, как и раньше.

548
00:26:07,170 --> 00:26:09,200
И он никогда указывая здесь ни на что.

549
00:26:09,200 --> 00:26:10,800
И теперь, я пытаюсь удалить два.

550
00:26:10,800 --> 00:26:13,850
>> Так что, если указатель направлен здесь, я
будет следовать, по-видимому,

551
00:26:13,850 --> 00:26:17,110
предыдущая указатель, который ставит меня в 1.

552
00:26:17,110 --> 00:26:22,290
Я тогда хотел сказать, что следующий
поле, которое приносит мне к этой

553
00:26:22,290 --> 00:26:25,410
коробка здесь, собирается
равна указатель напротив.

554
00:26:25,410 --> 00:26:28,400
Так что, если этот указатель, это рядом.

555
00:26:28,400 --> 00:26:31,840
Это означает, что эта стрелка потребности
указать на этого парня.

556
00:26:31,840 --> 00:26:35,140
>> Так что, что строка кода имеет только
сделано немного об этом.

557
00:26:35,140 --> 00:26:37,500
И теперь, это выглядит как
шаг в правильном направлении.

558
00:26:37,500 --> 00:26:41,390
Мы существенно хотите, чтобы отрезать 2 отъезде
середины 1 и 3.

559
00:26:41,390 --> 00:26:44,400
Так что имеет смысл, что мы хотим
маршрут этот указатель вокруг него.

560
00:26:44,400 --> 00:26:50,400
Так что это следующая строка проверки, если указатель
следующая не является нулевым, есть

561
00:26:50,400 --> 00:26:54,200
действительно кто-то справа от 2,
это означает, что мы также должны сделать

562
00:26:54,200 --> 00:26:55,850
немного СНиП здесь.

563
00:26:55,850 --> 00:27:00,590
>> Так что я теперь должны следовать этот указатель
и обновить предыдущий указатель на

564
00:27:00,590 --> 00:27:05,410
этот парень, чтобы сделать немного
обойти здесь точку здесь.

565
00:27:05,410 --> 00:27:07,100
А теперь, визуально это приятно.

566
00:27:07,100 --> 00:27:11,930
Это немного грязный в том, что есть
никто не указывая на 2 больше.

567
00:27:11,930 --> 00:27:13,600
2 указывает на левой стороне.

568
00:27:13,600 --> 00:27:14,980
И 2 указывает вправо.

569
00:27:14,980 --> 00:27:17,480
Но он может делать все, что он хочет, потому что
он собирается получить свободу.

570
00:27:17,480 --> 00:27:19,480
И не имеет значения, что
эти значения больше.

571
00:27:19,480 --> 00:27:23,040
>> Важно то, что оставшиеся
ребята маршрутизации выше

572
00:27:23,040 --> 00:27:24,280
и ниже него сейчас.

573
00:27:24,280 --> 00:27:25,810
И в самом деле, это то, что мы будем делать дальше.

574
00:27:25,810 --> 00:27:29,360
Мы бесплатно указатель, а это значит, мы говорим
операционная система, вы можете

575
00:27:29,360 --> 00:27:30,906
чтобы вернуть это.

576
00:27:30,906 --> 00:27:34,900
А потом, наконец, мы вернемся.

577
00:27:34,900 --> 00:27:37,220
Остальное неявно, если мы
еще не вернулись,

578
00:27:37,220 --> 00:27:38,290
мы должны продолжать поиски.

579
00:27:38,290 --> 00:27:41,485
Так указатель равна указатель следующий раз
означает двигаться этот парень здесь.

580
00:27:41,485 --> 00:27:42,600
Перемещение этого парня здесь.

581
00:27:42,600 --> 00:27:45,400
Перемещение этого парня здесь, если, по сути,
мы не нашли номер

582
00:27:45,400 --> 00:27:46,960
мы ищем еще.

583
00:27:46,960 --> 00:27:49,630
>> Так откровенно говоря, это выглядит совершенно
Подавляющее, я думаю, в первую очередь

584
00:27:49,630 --> 00:27:52,180
взгляд, особенно если вы изо всех сил
с этим в ходе викторины затем посмотреть,

585
00:27:52,180 --> 00:27:52,850
что-то вроде этого.

586
00:27:52,850 --> 00:27:55,050
И вы погладить себя по спине.

587
00:27:55,050 --> 00:27:57,080
Ну, нет никакого способа, я мог бы
придумать, что на викторине.

588
00:27:57,080 --> 00:28:00,470
Но я бы сказал, вы можете, если вы нарушите
это вниз, в эти индивидуальные

589
00:28:00,470 --> 00:28:04,400
случаи и просто войти в нее
тщательно, хотя, надо признать, в

590
00:28:04,400 --> 00:28:06,300
стрессовые обстоятельства.

591
00:28:06,300 --> 00:28:09,470
>> К счастью, картина сделана
все счастливее.

592
00:28:09,470 --> 00:28:11,050
Вы могли обратить на это в
любое количество способов.

593
00:28:11,050 --> 00:28:12,760
Вы не должны делать, пересекающих
вещь здесь.

594
00:28:12,760 --> 00:28:14,520
Вы можете сделать это с прямой
линии, как это.

595
00:28:14,520 --> 00:28:18,790
Но суть этой проблемы, в
Вообще, было понимать, что

596
00:28:18,790 --> 00:28:22,060
картина в конце должны немного
что-то вроде этого, потому что

597
00:28:22,060 --> 00:28:25,030
Постоянная времени подразумевает, что вы держите
помех и помех и помех

598
00:28:25,030 --> 00:28:29,900
новые узлы в начале
из списка.

599
00:28:29,900 --> 00:28:31,960
Есть вопросы?

600
00:28:31,960 --> 00:28:34,565
Вероятно, наиболее сложной из
конечно вопросы кодирования.

601
00:28:34,565 --> 00:28:37,690
>> АУДИТОРИЯ: Так список похож на
голову в предыдущих примерах.

602
00:28:37,690 --> 00:28:39,640
>> Дэвид Дж. Малан: Точно, точно.

603
00:28:39,640 --> 00:28:43,130
Просто другое имя для
глобальная переменная.

604
00:28:43,130 --> 00:28:44,380
Во всем мире и что?

605
00:28:44,380 --> 00:28:48,880

606
00:28:48,880 --> 00:28:49,730
>> ROB BOWDEN: ОК.

607
00:28:49,730 --> 00:28:52,020
Так что это то место, где вы
должен был написать этот пункт.

608
00:28:52,020 --> 00:28:56,060
Некоторые люди писали эссе
на этот вопрос.

609
00:28:56,060 --> 00:29:00,230
Но нужно просто использовать эти шесть членов
чтобы описать, что происходит, когда

610
00:29:00,230 --> 00:29:02,440
Вы попробуйте связаться facebook.com.

611
00:29:02,440 --> 00:29:07,930
Так что я буду просто говорить через процесс
используя все эти термины.

612
00:29:07,930 --> 00:29:11,290
Так в нашем браузере, мы набираем facebook.com
и нажмите Ввод.

613
00:29:11,290 --> 00:29:17,280
Таким образом, наш браузер собирается построить
HTTP просить, чтобы он собирается отправить

614
00:29:17,280 --> 00:29:22,220
через некоторое процесса в Facebook для
Facebook, чтобы ответить на нас с

615
00:29:22,220 --> 00:29:24,450
HTML его странице.

616
00:29:24,450 --> 00:29:28,800
>> Так что это процесс, при
какой запрос HTTP

617
00:29:28,800 --> 00:29:30,730
на самом деле попадает в Facebook?

618
00:29:30,730 --> 00:29:32,790
Итак, сначала мы должны перевести
Facebook.com.

619
00:29:32,790 --> 00:29:38,780
Так что просто дано имя Facebook.com,
где на самом деле просить HTTP

620
00:29:38,780 --> 00:29:39,940
нужно идти?

621
00:29:39,940 --> 00:29:44,120
Так что мы должны перевести Facebook.com
к IP адресу, который однозначно

622
00:29:44,120 --> 00:29:47,620
идентифицирует, что машина у нас на самом деле
хотите отправить запрос на.

623
00:29:47,620 --> 00:29:49,310
Ваш ноутбук имеет IP-адрес.

624
00:29:49,310 --> 00:29:52,240
Все, что подключены к Интернету
имеет IP-адрес.

625
00:29:52,240 --> 00:29:59,030
>> Так DNS, Domain Name System, то есть
что происходит в обращении перевод

626
00:29:59,030 --> 00:30:03,750
от facebook.com к IP-адреса,
вы на самом деле хотите связаться.

627
00:30:03,750 --> 00:30:08,075
Таким образом, мы связаться с DNS-серверов и
скажем, что facebook.com?

628
00:30:08,075 --> 00:30:16,560
Это говорит, о, это IP-адрес 190,212
что-то, что-то, что-то.

629
00:30:16,560 --> 00:30:16,900
Хорошо.

630
00:30:16,900 --> 00:30:18,850
Теперь, я знаю, что машина
Я хочу связаться.

631
00:30:18,850 --> 00:30:22,360
>> Тогда вы, отправьте запрос HTTP
к этой машине.

632
00:30:22,360 --> 00:30:24,140
Так, как это добраться до этой машины?

633
00:30:24,140 --> 00:30:27,200
Ну, запрос идет от
маршрутизатор к маршрутизатору подпрыгивая.

634
00:30:27,200 --> 00:30:32,630
Помните пример в классе, где
мы фактически видели маршрут, что

635
00:30:32,630 --> 00:30:35,340
Пакеты взял, когда мы пытались
общаться.

636
00:30:35,340 --> 00:30:38,460
Мы видели это перепрыгнуть через Атлантику
Океан в одной точке или любой другой.

637
00:30:38,460 --> 00:30:42,820
>> Таким образом, последний член порт.

638
00:30:42,820 --> 00:30:46,520
Так что это теперь на вашем компьютере.

639
00:30:46,520 --> 00:30:49,970
Вы можете иметь несколько вещей в настоящее время
общения с Интернетом.

640
00:30:49,970 --> 00:30:53,730
Так что я могу быть запущен, скажем, Skype.

641
00:30:53,730 --> 00:30:55,670
Я, возможно, веб-браузер с открытым.

642
00:30:55,670 --> 00:30:59,010
Я мог бы иметь то, что
torrenting файлы.

643
00:30:59,010 --> 00:31:00,880
Так что все эти вещи
общения с

644
00:31:00,880 --> 00:31:02,600
Интернет в некотором роде.

645
00:31:02,600 --> 00:31:08,070
>> Поэтому, когда ваш компьютер получает некоторые данные
из Интернета, как делает это

646
00:31:08,070 --> 00:31:10,130
знаю, что приложение на самом деле
хочет данные?

647
00:31:10,130 --> 00:31:12,610
Как это знаю, насколько это частности
данные, предназначенные для

648
00:31:12,610 --> 00:31:16,070
torrenting приложение в отличие
в веб-браузере?

649
00:31:16,070 --> 00:31:20,980
Так что это цель портов в том, что
все эти приложения имеют

650
00:31:20,980 --> 00:31:22,720
утверждал, порт на вашем компьютере.

651
00:31:22,720 --> 00:31:27,580
Так что ваш веб-браузер говорит, эй,
Я на порту 1000.

652
00:31:27,580 --> 00:31:32,240
И ваша программа torrenting говорит,
Я на порту 3000.

653
00:31:32,240 --> 00:31:34,770
И Skype говорит, я использую порт 4000.

654
00:31:34,770 --> 00:31:41,950
>> Поэтому, когда вы получаете некоторые данные, которые принадлежит
к одному из этих приложений, данных

655
00:31:41,950 --> 00:31:45,510
отмечен какой порт он на самом деле
должны быть присланы вместе с.

656
00:31:45,510 --> 00:31:47,950
Так что это говорит, о, я принадлежу
к порту 1000.

657
00:31:47,950 --> 00:31:50,950
Я знаю, то мне нужно направить этот
вместе с моим веб-браузера.

658
00:31:50,950 --> 00:31:56,440
Так что причина, что это отношение здесь
является то, что веб-серверы, как правило,

659
00:31:56,440 --> 00:31:58,240
порт 80.

660
00:31:58,240 --> 00:32:02,420
Поэтому, когда я связаться Facebook.com, я
общения с некоторой машины.

661
00:32:02,420 --> 00:32:06,390
Но я должен сказать, какой порт, что
машина Я хочу общаться с.

662
00:32:06,390 --> 00:32:09,160
И веб-серверы, как правило,
прослушивает порт 80.

663
00:32:09,160 --> 00:32:14,010
>> Если бы они хотели, они могли установить его
так, это показывает, как на порту 7000.

664
00:32:14,010 --> 00:32:19,090
А потом в веб-браузере, я мог
вручную ввести Facebook.com: 7000 в

665
00:32:19,090 --> 00:32:24,600
отправить запрос на порт 7000
веб-сервер Facebook.

666
00:32:24,600 --> 00:32:26,820
>> Дэвид Дж. Малан: И в этом случае, даже
хотя мы не требовали, чтобы люди

667
00:32:26,820 --> 00:32:30,000
говорю об этом, в данном случае, то, что порт
будет запрос на самом деле пойти?

668
00:32:30,000 --> 00:32:36,630

669
00:32:36,630 --> 00:32:37,880
Попробуйте еще раз.

670
00:32:37,880 --> 00:32:42,810

671
00:32:42,810 --> 00:32:44,300
Именно так.

672
00:32:44,300 --> 00:32:47,960
Не нуждаюсь в этом, но тонкость
что не там ни последним.

673
00:32:47,960 --> 00:32:51,770
>> ROB BOWDEN: Так HTTPS, так как это
слушать специально для

674
00:32:51,770 --> 00:32:55,180
зашифрован, это на порту 4430.

675
00:32:55,180 --> 00:32:57,680
>> Аудитория: и электронные письма 25, не так ли?

676
00:32:57,680 --> 00:33:00,670
>> Дэвид Дж. Малан: Исходящий трафик
электронные письма, 25, да.

677
00:33:00,670 --> 00:33:03,760
>> ROB BOWDEN: я даже не знаю, что большинство из
- все нижние имеют тенденцию быть

678
00:33:03,760 --> 00:33:06,310
зарезервированы для вещей.

679
00:33:06,310 --> 00:33:09,260
Я думаю, что все под
1024 зарезервирован.

680
00:33:09,260 --> 00:33:13,450
>> АУДИТОРИЯ: Почему вы говорите,
3 был неправильный номер?

681
00:33:13,450 --> 00:33:18,820
>> ROB BOWDEN: Потому что в IP-адрес,
есть четыре группировки цифр.

682
00:33:18,820 --> 00:33:21,090
И они от 0 до 255.

683
00:33:21,090 --> 00:33:28,060
Так 192.168.2.1 является общим
Локальный IP-адрес сети.

684
00:33:28,060 --> 00:33:30,840
Обратите внимание, все те, меньше, чем 255.

685
00:33:30,840 --> 00:33:33,570
Поэтому, когда я начал с 300, что
не мог иметь

686
00:33:33,570 --> 00:33:35,210
был одним из чисел.

687
00:33:35,210 --> 00:33:38,170
>> Дэвид Дж. Малан: Но это глупо клип
от - это было CSI, где они должны были

688
00:33:38,170 --> 00:33:39,970
число, которое было слишком большим
для IP-адреса.

689
00:33:39,970 --> 00:33:42,940

690
00:33:42,940 --> 00:33:46,110
>> ROB BOWDEN: Все вопросы по этому поводу?

691
00:33:46,110 --> 00:33:51,710
Следующий, так полное изменение
тема, но у нас есть это PHP массив для

692
00:33:51,710 --> 00:33:53,270
дома в четырехядерных.

693
00:33:53,270 --> 00:33:56,360
И у нас есть неупорядоченный список.

694
00:33:56,360 --> 00:33:59,550
И мы хотим, чтобы распечатать каждого элемента списка
просто, содержащая имя дом.

695
00:33:59,550 --> 00:34:09,090

696
00:34:09,090 --> 00:34:11,870
Поэтому у нас есть цикл по каждому элементу.

697
00:34:11,870 --> 00:34:17,540
Так что помните, синтаксис Еогеасп
Массив как элемента массива.

698
00:34:17,540 --> 00:34:22,360
Так через каждый итерации цикла,
дом собирается взять на одном из

699
00:34:22,360 --> 00:34:24,060
значения внутри массива.

700
00:34:24,060 --> 00:34:26,530
>> На первой итерации, дом
будет Кабот Дом.

701
00:34:26,530 --> 00:34:30,370
На второй итерации, дом будет
быть Курьер дома и так далее.

702
00:34:30,370 --> 00:34:34,370
Таким образом, для каждого квадрата, как дома, мы
просто в печать -

703
00:34:34,370 --> 00:34:37,250
Вы также могли бы эхом -

704
00:34:37,250 --> 00:34:42,199
элемент списка, а затем название дома в
и закройте элемент списка.

705
00:34:42,199 --> 00:34:45,210
Фигурные скобки являются необязательными здесь.

706
00:34:45,210 --> 00:34:49,480
>> И тогда мы также сказал в вопросе
Сам, не забудьте закрыть

707
00:34:49,480 --> 00:34:50,770
неупорядоченный список тегов.

708
00:34:50,770 --> 00:34:53,949
Так что мы должны выйти из режима PHP
для того, чтобы сделать это.

709
00:34:53,949 --> 00:35:00,280
Или мы могли бы вторит
закрыть неупорядоченный список тег.

710
00:35:00,280 --> 00:35:02,380
>> Дэвид Дж. Малан: Также хорошо здесь будет
были использовать старую школу для

711
00:35:02,380 --> 00:35:07,340
петля с $ I = 0 0 и используя рассчитывает на
выяснить длину луча.

712
00:35:07,340 --> 00:35:09,240
Полностью тоже хорошо, только
немного wordier.

713
00:35:09,240 --> 00:35:12,170

714
00:35:12,170 --> 00:35:14,742
>> АУДИТОРИЯ: Так что, если вы собирались
[Неразборчиво], вы могли бы сделать -

715
00:35:14,742 --> 00:35:16,734
Я забыл, что петля [неразборчиво] есть.

716
00:35:16,734 --> 00:35:21,380
Вы бы $ четырехъядерный кронштейн я?

717
00:35:21,380 --> 00:35:21,850
>> Дэвид Дж. Малан: Совершенно верно.

718
00:35:21,850 --> 00:35:23,100
Да, именно так.

719
00:35:23,100 --> 00:35:26,650

720
00:35:26,650 --> 00:35:27,900
>> ROB BOWDEN: Что-нибудь еще?

721
00:35:27,900 --> 00:35:31,350

722
00:35:31,350 --> 00:35:32,010
>> Дэвид Дж. Малан: Хорошо.

723
00:35:32,010 --> 00:35:32,300
Компромиссы.

724
00:35:32,300 --> 00:35:38,290
Так появились гроздья ответов
возможно для каждого из них.

725
00:35:38,290 --> 00:35:40,510
Мы действительно просто ищете
что-то привлекательным для перевернутой и

726
00:35:40,510 --> 00:35:41,100
и обратная сторона.

727
00:35:41,100 --> 00:35:44,830
И число 16 спросил, проверка пользователи '
вход со стороны клиента, так как с JavaScript,

728
00:35:44,830 --> 00:35:47,280
вместо стороне сервера, а с PHP.

729
00:35:47,280 --> 00:35:49,450
Так в чем же потенциал роста
делать на стороне клиента?

730
00:35:49,450 --> 00:35:53,780
>> Ну, одна из вещей, мы предложили это
что вы уменьшить время ожидания, потому что вы

731
00:35:53,780 --> 00:35:56,750
не придется беспокоиться контакте
сервер, который может занять несколько

732
00:35:56,750 --> 00:36:00,390
миллисекунд или даже пару секунд
избегая, что и просто

733
00:36:00,390 --> 00:36:04,670
Проверка сведений, вводимых на стороне клиента пользователей по
вызывая на-представить обработчик и

734
00:36:04,670 --> 00:36:06,650
просто проверка, они типа
что-то в качестве имени?

735
00:36:06,650 --> 00:36:08,080
Разве они что-то типа
в течение адрес электронной почты?

736
00:36:08,080 --> 00:36:10,950
Разве они выбирают общежитие от
выпадающее меню?

737
00:36:10,950 --> 00:36:14,360
>> Вы можете дать им мгновенную обратную связь
с помощью гигагерц компьютер

738
00:36:14,360 --> 00:36:16,770
или что у них есть это
фактически на столе.

739
00:36:16,770 --> 00:36:19,310
Так что это просто лучше пользователь
опыт обычно.

740
00:36:19,310 --> 00:36:24,460
Но недостаток делать на стороне клиента
Проверка, если вы делаете это без того,

741
00:36:24,460 --> 00:36:29,860
делать проверку на стороне сервера является то, что
Наиболее кто-то выходит из CS50 знает

742
00:36:29,860 --> 00:36:33,980
что вы можете просто отправить любое данные, которые необходимо
на сервере любое количество способов.

743
00:36:33,980 --> 00:36:37,030
Честно говоря, в большинстве любом браузере, вы можете
нажмите вокруг в настройках и просто

744
00:36:37,030 --> 00:36:40,110
выключить наличие, которая бы,
Поэтому, отключить любую форму

745
00:36:40,110 --> 00:36:41,080
проверка.

746
00:36:41,080 --> 00:36:44,460
>> Но вы также могли бы вспомнить, что даже я
сделал некие замысловатые действия в классе, используя

747
00:36:44,460 --> 00:36:47,790
Telnet и фактически делая вид,
быть браузеру, отправив GET

748
00:36:47,790 --> 00:36:49,240
запросы к серверу.

749
00:36:49,240 --> 00:36:51,030
И это, конечно, не
с помощью любого JavaScript.

750
00:36:51,030 --> 00:36:53,290
Вот только мне ввода команд
на клавиатуре.

751
00:36:53,290 --> 00:36:57,410
Так на самом деле, любой программист в достаточно
комфорт с веб-и HTTP-

752
00:36:57,410 --> 00:37:01,690
может отправить все данные он или она хочет
к серверу без проверки.

753
00:37:01,690 --> 00:37:05,470
И если ваш сервер не также проверки,
они дать мне имя, является

754
00:37:05,470 --> 00:37:08,930
это на самом деле действительный адрес электронной почты, сделал
они выбирают общежитие, то в конечном

755
00:37:08,930 --> 00:37:12,800
до вставки поддельным или просто пустой данных
в базу данных, которая, вероятно,

756
00:37:12,800 --> 00:37:15,450
не будет хорошо, если
Вы были предполагая, что это было.

757
00:37:15,450 --> 00:37:16,770
>> Так что это досадная реальность.

758
00:37:16,770 --> 00:37:19,890
Но в общем, на стороне клиента
проверка велик.

759
00:37:19,890 --> 00:37:21,810
Но это значит, в два раза больше работы.

760
00:37:21,810 --> 00:37:25,970
Хотя существуют различные
библиотеки, JavaScript библиотеки для

761
00:37:25,970 --> 00:37:28,830
Экземпляр, которые делают это много,
гораздо меньше головной боли.

762
00:37:28,830 --> 00:37:31,940
И вы можете использовать часть кода
на стороне сервера, на стороне клиента.

763
00:37:31,940 --> 00:37:35,980
Но понимаю, что это, как правило,
дополнительная работа.

764
00:37:35,980 --> 00:37:36,415
Да.

765
00:37:36,415 --> 00:37:37,792
>> АУДИТОРИЯ: Так что, если мы просто
сказал менее безопасным -

766
00:37:37,792 --> 00:37:39,205
>> Дэвид Дж. Малан: [смеется]

767
00:37:39,205 --> 00:37:39,680
Тьфу.

768
00:37:39,680 --> 00:37:43,105
Те, всегда труднее
те, для рассмотрения.

769
00:37:43,105 --> 00:37:44,480
>> ROB BOWDEN: Это было бы
были приняты.

770
00:37:44,480 --> 00:37:44,810
>> Дэвид Дж. Малан: Что?

771
00:37:44,810 --> 00:37:45,810
>> ROB BOWDEN: Я создал эту проблему.

772
00:37:45,810 --> 00:37:46,735
Это была бы принята.

773
00:37:46,735 --> 00:37:47,220
>> Дэвид Дж. Малан: Да.

774
00:37:47,220 --> 00:37:47,830
>> АУДИТОРИЯ: Круто.

775
00:37:47,830 --> 00:37:51,770
>> ROB BOWDEN: Но мы не принимали
для первого -

776
00:37:51,770 --> 00:37:53,630
хорошо, что мы искали это
что-то вроде вас не должны

777
00:37:53,630 --> 00:37:55,270
связи с сервером.

778
00:37:55,270 --> 00:37:58,355
Мы не принимаем только быстрее.

779
00:37:58,355 --> 00:38:00,080
>> АУДИТОРИЯ: А как насчет
не перегрузить страницу?

780
00:38:00,080 --> 00:38:00,430
>> ROB BOWDEN: Да.

781
00:38:00,430 --> 00:38:03,000
Это было принято отвечать.

782
00:38:03,000 --> 00:38:06,300
>> Дэвид Дж. Малан: Все, где мы чувствовали,
это было более вероятно, чем нет, скорее всего

783
00:38:06,300 --> 00:38:09,780
что вы знали, что вы были
говоря, что является жестким

784
00:38:09,780 --> 00:38:13,500
линия обратить иногда.

785
00:38:13,500 --> 00:38:16,000
Использование связанного списка, а не
из массива для поддержания

786
00:38:16,000 --> 00:38:17,590
сортируются список целых чисел.

787
00:38:17,590 --> 00:38:21,000
Так с ног, мы часто цитируют с связаны
списки, мотивированные всю свою

788
00:38:21,000 --> 00:38:22,370
Введение был вы получаете динамизм.

789
00:38:22,370 --> 00:38:23,030
Они могут расти.

790
00:38:23,030 --> 00:38:23,950
Они могут сокращаться.

791
00:38:23,950 --> 00:38:27,370
Так что вам не придется прыгать через обручи
на самом деле создать больше памяти

792
00:38:27,370 --> 00:38:28,140
с массивом.

793
00:38:28,140 --> 00:38:30,310
Или вы не должны просто
говорят, извините, пользователь.

794
00:38:30,310 --> 00:38:31,410
Массив заполняется.

795
00:38:31,410 --> 00:38:35,850
Так динамичный рост списке.

796
00:38:35,850 --> 00:38:37,210
Нижняя сторона, хотя связанных списков?

797
00:38:37,210 --> 00:38:40,916

798
00:38:40,916 --> 00:38:43,356
>> АУДИТОРИЯ: Это линейная.

799
00:38:43,356 --> 00:38:45,800
Поиск на связанный список линейна
вместо того, что вы входите в

800
00:38:45,800 --> 00:38:46,360
>> Дэвид Дж. Малан: Совершенно верно.

801
00:38:46,360 --> 00:38:50,160
Поиск на связанный список является линейным,
даже если это сортируется, потому что вы можете

802
00:38:50,160 --> 00:38:53,170
только следующие хлебные крошки, эти
указатели, от начала списка

803
00:38:53,170 --> 00:38:53,570
до конца.

804
00:38:53,570 --> 00:38:57,970
Вы не можете использовать произвольный доступ и,
Таким образом, бинарный поиск, даже если это

805
00:38:57,970 --> 00:39:00,740
сортируются, что вы могли бы
сделать с массивом.

806
00:39:00,740 --> 00:39:02,390
И есть еще одна стоимость.

807
00:39:02,390 --> 00:39:02,966
Да.

808
00:39:02,966 --> 00:39:03,800
>> АУДИТОРИЯ: Память неэффективно?

809
00:39:03,800 --> 00:39:04,130
>> Дэвид Дж. Малан: Да.

810
00:39:04,130 --> 00:39:06,940
Ну, я бы не стал обязательно
сказать неэффективным.

811
00:39:06,940 --> 00:39:10,110
Но это обойдется вам больше памяти,
потому что вам нужно 32 бита за каждый

812
00:39:10,110 --> 00:39:13,400
узел для дополнительного указателя, по крайней
мере, для однонаправленного списка.

813
00:39:13,400 --> 00:39:16,660
Теперь, если вы только способ хранения целочисленных и
Вы добавляете указатель, это

814
00:39:16,660 --> 00:39:17,830
на самом деле вид нетривиально.

815
00:39:17,830 --> 00:39:19,340
Это удвоение объема памяти.

816
00:39:19,340 --> 00:39:22,330
Но на самом деле, если вы храните
связанный список структур, которые могли бы

817
00:39:22,330 --> 00:39:25,540
8 байт, 16 байт, еще более
Кроме этого, может быть, это меньше

818
00:39:25,540 --> 00:39:26,500
маргинальной стоимости.

819
00:39:26,500 --> 00:39:28,320
Но это стоимость, тем не менее.

820
00:39:28,320 --> 00:39:31,880
Так что либо из тех бы уже
было прекрасно, как недостатки.

821
00:39:31,880 --> 00:39:32,110
>> 18.

822
00:39:32,110 --> 00:39:36,100
Использование PHP вместо C написать
Программа командной строки.

823
00:39:36,100 --> 00:39:41,890
Так вот, это часто быстрее использовать
язык, как PHP или Ruby, или Python.

824
00:39:41,890 --> 00:39:43,700
Вы просто быстро открыть
до текстовом редакторе.

825
00:39:43,700 --> 00:39:45,900
У вас есть гораздо больше функций
доступны для вас.

826
00:39:45,900 --> 00:39:49,325
PHP имеет раковину функций,
тогда как в C, вы

827
00:39:49,325 --> 00:39:50,420
есть очень и очень мало.

828
00:39:50,420 --> 00:39:53,820
На самом деле, ребята знают на собственном горьком опыте
что у вас нет хэш-таблицы.

829
00:39:53,820 --> 00:39:55,000
Вы не связали списки.

830
00:39:55,000 --> 00:39:57,470
Если вы хотите, чтобы те, вы должны
реализовать их самостоятельно.

831
00:39:57,470 --> 00:40:00,950
>> Так что потенциал роста PHP или действительно любой
интерпретировать язык является быстрота

832
00:40:00,950 --> 00:40:02,920
с помощью которого можно писать код.

833
00:40:02,920 --> 00:40:06,660
Но недостаток, мы видели это, когда я
быстро на скорую руку misspeller

834
00:40:06,660 --> 00:40:11,780
реализация в лекции с использованием PHP, является
что использование интерпретируемого языка

835
00:40:11,780 --> 00:40:13,570
как правило, медленнее.

836
00:40:13,570 --> 00:40:18,420
И мы видели, что явно с
увеличение времени от 0,3 секунды до 3

837
00:40:18,420 --> 00:40:24,440
секунд, из-за интерпретации
что происходит на самом деле.

838
00:40:24,440 --> 00:40:27,060
>> Другой верх в том, что вам
не обязательно собирать.

839
00:40:27,060 --> 00:40:30,130
Так оно и ускоряет разработку
кстати, потому что у вас нет

840
00:40:30,130 --> 00:40:31,360
в два этапа запуска программы.

841
00:40:31,360 --> 00:40:32,140
Вы просто есть.

842
00:40:32,140 --> 00:40:35,260
И таким образом, это довольно
убедительным, а также.

843
00:40:35,260 --> 00:40:38,450
Использование базы данных SQL вместо
файл в формате CSV для хранения данных.

844
00:40:38,450 --> 00:40:40,230
Так SQL база данных используется для pset7.

845
00:40:40,230 --> 00:40:42,060
CSV файлов, которые вы не использовали много.

846
00:40:42,060 --> 00:40:45,960
Но вы использовали его косвенно в pset7 как
хорошо, поговорив с Yahoo Finance.

847
00:40:45,960 --> 00:40:49,330
>> Но CSV так же, как файл Excel, но
супер просто, где столбцы

848
00:40:49,330 --> 00:40:54,010
просто демаркированы запятыми внутри
в противном случае из текстового файла.

849
00:40:54,010 --> 00:40:56,740
И с использованием базы данных SQL является
немного более убедительным.

850
00:40:56,740 --> 00:41:00,060
Это положительная сторона, потому что вы получаете то,
как выбрать и вставлять и удалять.

851
00:41:00,060 --> 00:41:03,790
И вы получите, предположительно, индексы,
MySQL и других баз данных, как

852
00:41:03,790 --> 00:41:07,510
Oracle, построить для вас в памяти, что
означает, что ваш выбор, вероятно, не

853
00:41:07,510 --> 00:41:09,000
будет линейной сверху вниз.

854
00:41:09,000 --> 00:41:11,300
Это на самом деле будет что-то
как бинарный поиск или что-то

855
00:41:11,300 --> 00:41:12,520
близки по духу.

856
00:41:12,520 --> 00:41:13,930
Таким образом, они как правило, быстрее.

857
00:41:13,930 --> 00:41:16,040
>> Но недостаток в том, что
это просто больше работы.

858
00:41:16,040 --> 00:41:16,730
Это больше усилий.

859
00:41:16,730 --> 00:41:18,140
Вы должны понять, базы данных.

860
00:41:18,140 --> 00:41:18,940
Вы должны установить его.

861
00:41:18,940 --> 00:41:20,840
Вам нужен сервер для запуска
что база данных по.

862
00:41:20,840 --> 00:41:22,750
Вы должны понимать,
как его настроить.

863
00:41:22,750 --> 00:41:24,930
Так что это только эти
виды компромиссов.

864
00:41:24,930 --> 00:41:27,860
В то время как файл CSV, вы можете
создать его с Gedit.

865
00:41:27,860 --> 00:41:28,770
И вы хорошо идти.

866
00:41:28,770 --> 00:41:31,550
Там нет сложности за рамки этого.

867
00:41:31,550 --> 00:41:34,870
>> Использование синтаксического дерева вместо хэш-таблице
с раздельного связывания для хранения

868
00:41:34,870 --> 00:41:37,490
словарь слов, напоминающих
из pset5.

869
00:41:37,490 --> 00:41:42,480
Так пытается вверх, в теории
по крайней мере, это то, что?

870
00:41:42,480 --> 00:41:46,380
Постоянное время, по крайней мере, если вы
хэширования на каждом из отдельных

871
00:41:46,380 --> 00:41:48,990
буквы в слова, как и вы
может иметь для pset5.

872
00:41:48,990 --> 00:41:52,720
Это может быть пять хэши, шесть
хэши, если есть пять или шесть

873
00:41:52,720 --> 00:41:53,900
буквы в слове.

874
00:41:53,900 --> 00:41:54,580
И это очень хорошо.

875
00:41:54,580 --> 00:41:56,910
И если есть верхняя граница, как
долго ваши слова могут быть, это

876
00:41:56,910 --> 00:41:59,320
действительно асимптотически постоянная времени.

877
00:41:59,320 --> 00:42:05,180
>> В то время как хэш-таблицу с отдельным
цепочки, проблему там с, что

878
00:42:05,180 --> 00:42:09,070
Такая структура данных является то, что
выполнение ваших алгоритмов обычно

879
00:42:09,070 --> 00:42:12,700
зависит от количества вещей
уже в структуре данных.

880
00:42:12,700 --> 00:42:15,660
И это, безусловно, в случае с
цепи, в результате чего больше материала вы положили

881
00:42:15,660 --> 00:42:18,800
в хэш-таблицу, тем дольше тех,
цепи идти, что означает, в худшем

882
00:42:18,800 --> 00:42:21,960
так, то, что вы могли бы искать
все пути в конце один

883
00:42:21,960 --> 00:42:26,000
из этих цепей, которые эффективно
передает в чем-то линейной.

884
00:42:26,000 --> 00:42:29,450
>> Теперь, на практике она может абсолютно
быть так, что хэш-таблицу с

885
00:42:29,450 --> 00:42:32,820
цепи быстрее, чем соответствующий
Реализация синтаксического дерева.

886
00:42:32,820 --> 00:42:35,570
Но это по разным причинам, среди
которые пытается использовать всю серию

887
00:42:35,570 --> 00:42:39,240
что память может, на самом деле, медленные вещи
вниз, потому что вы не получаете хороший

888
00:42:39,240 --> 00:42:42,410
Преимущества, что называется кэширование,
где вещи, которые близко друг к другу

889
00:42:42,410 --> 00:42:45,420
в памяти можно получить
часто более быстро.

890
00:42:45,420 --> 00:42:48,180
И иногда вы можете придумать
действительно хороший хэш-функция.

891
00:42:48,180 --> 00:42:51,060
Даже если вам придется тратить немного
памяти, вы можете, конечно, быть в состоянии

892
00:42:51,060 --> 00:42:54,430
найти вещи быстро и не
так плохо, как линейно.

893
00:42:54,430 --> 00:42:58,410
>> Короче говоря, есть не обязательно
с любым из них один или даже два

894
00:42:58,410 --> 00:43:00,050
конкретные вещи, которые мы искали.

895
00:43:00,050 --> 00:43:03,080
Действительно ничего убедительным
как вверх и недостатков

896
00:43:03,080 --> 00:43:04,800
как правило, попался на глаза.

897
00:43:04,800 --> 00:43:11,840
>> ROB BOWDEN: Так что для верху, мы сделали
не принимает самостоятельно "быстрее". Вы

898
00:43:11,840 --> 00:43:14,540
должен был сказать что-то об этом.

899
00:43:14,540 --> 00:43:17,910
Даже если вы теоретически быстрее сказал,
мы знали, что вы вроде понял

900
00:43:17,910 --> 00:43:19,470
что это 0 1.

901
00:43:19,470 --> 00:43:22,820
И хеш-таблицы, в теории,
не 0 1.

902
00:43:22,820 --> 00:43:26,550
Упоминание ничего выполнения
как правило, получили вы точки.

903
00:43:26,550 --> 00:43:32,640
Но "быстрее", большинство решений на
большой совет, которые были отрасли были

904
00:43:32,640 --> 00:43:34,990
объективно медленнее, чем решений
что были хэш-таблицы.

905
00:43:34,990 --> 00:43:37,250
Так быстрее и само по себе
не совсем так.

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> Дэвид Дж. Малан: Дом де дом дом.

908
00:43:44,380 --> 00:43:46,686
Я, наверное, единственный, который понимает,
вот как, что, как предполагается,

909
00:43:46,686 --> 00:43:47,500
произноситься, правильно?

910
00:43:47,500 --> 00:43:50,400
>> ROB BOWDEN: у меня не было на самом деле не знаю,.

911
00:43:50,400 --> 00:43:51,650
>> Дэвид Дж. Малан: Он сделал
смысл в моей голове.

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> ROB BOWDEN: Я делаю это.

914
00:43:57,580 --> 00:43:58,020
ОК.

915
00:43:58,020 --> 00:44:04,243
Так что это то место, где вы должны были обратить
диаграмма похожа на вас, возможно,

916
00:44:04,243 --> 00:44:06,040
видели на прошлых экзаменов.

917
00:44:06,040 --> 00:44:12,200
Так что давайте просто посмотрим на это.

918
00:44:12,200 --> 00:44:18,170
Так что с HTML узла, у нас есть два
дети, голова и тело.

919
00:44:18,170 --> 00:44:20,570
Таким образом, мы расшириться - голову и тело.

920
00:44:20,570 --> 00:44:22,280
Головка имеет тег заголовка.

921
00:44:22,280 --> 00:44:23,710
Поэтому у нас есть название.

922
00:44:23,710 --> 00:44:28,450
>> Теперь, одна вещь, много людей
забыл, что эти текстовые узлы

923
00:44:28,450 --> 00:44:30,430
элементы внутри этого дерева.

924
00:44:30,430 --> 00:44:36,260
И вот мы, случается, привлечь их в виде овалов
чтобы отличать их от них

925
00:44:36,260 --> 00:44:37,380
типы узлов.

926
00:44:37,380 --> 00:44:41,450
Но обратите внимание также здесь у нас есть вершины,
средний, и нижний будет в конечном итоге

927
00:44:41,450 --> 00:44:42,560
текстовые узлы.

928
00:44:42,560 --> 00:44:46,250
Так забывая тех, была несколько
общей ошибке.

929
00:44:46,250 --> 00:44:48,770
>> Тело имеет троих детей -
эти три дивы.

930
00:44:48,770 --> 00:44:53,340
Так дел, дел, дел, а затем текст
узел дети тех дивы.

931
00:44:53,340 --> 00:44:55,900
Это в значительной степени это
для этого вопросы.

932
00:44:55,900 --> 00:44:57,860
>> Дэвид Дж. Малан: И стоит заметить,,
хотя мы не будем останавливаться на них

933
00:44:57,860 --> 00:45:01,040
детали в времени мы проводим на
JavaScript, что порядок делает, в

934
00:45:01,040 --> 00:45:02,290
Дело в том, независимо от того, в техническом плане.

935
00:45:02,290 --> 00:45:06,330
Так что, если руководитель идет перед органом в
HTML, то он должен появиться в

936
00:45:06,330 --> 00:45:08,860
слева от тела в фактическом DOM.

937
00:45:08,860 --> 00:45:12,265
Что его, в общем, просто FYI,
то, что называется порядок документ, где

938
00:45:12,265 --> 00:45:13,260
это имеет значение.

939
00:45:13,260 --> 00:45:17,470
И если вы были реализации парсер,
программа, которая читает HTML в здании

940
00:45:17,470 --> 00:45:20,960
вверх по дереву в памяти, если честно,
вот интуитивно вероятно, что вы

941
00:45:20,960 --> 00:45:24,720
сделать в любом случае - сверху вниз,
слева направо.

942
00:45:24,720 --> 00:45:26,116
>> ROB BOWDEN: Вопросы по этому поводу?

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
Должен ли я сделать следующий?

945
00:45:30,000 --> 00:45:32,380
>> Дэвид Дж. Малан: Конечно.

946
00:45:32,380 --> 00:45:33,810
>> ROB BOWDEN: ОК.

947
00:45:33,810 --> 00:45:39,320
Так что это переполнение буфера
нападение вопрос.

948
00:45:39,320 --> 00:45:43,740
Главное, чтобы признать здесь,
ну, как могли бы противник трюк

949
00:45:43,740 --> 00:45:46,170
эта программа в исполнении
произвольного кода?

950
00:45:46,170 --> 00:45:51,860
Так argv1, первый командной строки
аргумент этой программы, которые могут быть

951
00:45:51,860 --> 00:45:53,920
произвольной длины.

952
00:45:53,920 --> 00:45:59,160
Но здесь мы используем тетсру скопировать
argv1, которые здесь находится бар.

953
00:45:59,160 --> 00:46:00,165
Мы передачи его в качестве аргумента.

954
00:46:00,165 --> 00:46:02,050
И так это занимает на заводской бар.

955
00:46:02,050 --> 00:46:08,040
>> Таким образом, мы memcpying бар
в этой буферной в.

956
00:46:08,040 --> 00:46:09,400
Сколько байт мы копирования?

957
00:46:09,400 --> 00:46:14,040
Ну однако многие бар байт случается
использовать, длину этого аргумента.

958
00:46:14,040 --> 00:46:17,930
Но с составляет всего 12 байт в ширину.

959
00:46:17,930 --> 00:46:22,280
Так что, если мы наберем аргумент командной строки
это больше, чем 12 байт, мы

960
00:46:22,280 --> 00:46:25,470
собирается переполняться это
частности буфера.

961
00:46:25,470 --> 00:46:31,000
Теперь, как может противник обмануть
запрограммировать в выполнении произвольный код?

962
00:46:31,000 --> 00:46:34,910
>> Поэтому помните, что здесь
Основной зовет Foo.

963
00:46:34,910 --> 00:46:37,340
И так, то основные вызовы Foo.

964
00:46:37,340 --> 00:46:40,408
Давайте нарисуем это.

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
Так у нас есть стек.

967
00:46:46,990 --> 00:46:49,090
А главное есть кадр стека
в нижней части.

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
В какой-то момент, основные вызовы Foo.

970
00:46:53,250 --> 00:46:55,390
Ну, сразу, основные вызовы Foo.

971
00:46:55,390 --> 00:46:57,130
И так Foo получает собственный фрейм стека.

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> Теперь, в какой-то момент, Foo
собирается вернуться.

974
00:47:02,220 --> 00:47:06,810
И пошел Foo возвращения, мы должны знать, в
что строка кода внутри главного мы

975
00:47:06,810 --> 00:47:10,610
были для того, чтобы знать, где
мы должны возобновить в основной.

976
00:47:10,610 --> 00:47:13,100
Мы можем назвать Foo от в целом
куча разных местах.

977
00:47:13,100 --> 00:47:14,620
Как мы знаем, где, чтобы вернуться?

978
00:47:14,620 --> 00:47:16,460
Ну, нам нужно сохранить, что где-то.

979
00:47:16,460 --> 00:47:23,010
>> Так где-то прямо здесь, мы храним
где мы должны вернуться, чтобы еще

980
00:47:23,010 --> 00:47:24,070
Foo возвращается.

981
00:47:24,070 --> 00:47:26,350
И это обратный адрес.

982
00:47:26,350 --> 00:47:30,490
Так как противник может воспользоваться
этого является тот факт, что

983
00:47:30,490 --> 00:47:37,550
этот буфер с хранится, давайте
сказать, прямо здесь с.

984
00:47:37,550 --> 00:47:39,690
Итак, мы получили 12 байт для с.

985
00:47:39,690 --> 00:47:40,540
Это с.

986
00:47:40,540 --> 00:47:43,030
И это стек кольцо Foo в.

987
00:47:43,030 --> 00:47:49,970
Таким образом, если злоумышленник входит более
байт, чем 12 или они входят в команду

988
00:47:49,970 --> 00:47:54,570
Аргумент строка, которая длиннее, чем 12
символов, то мы собираемся

989
00:47:54,570 --> 00:47:57,540
переполнение этот буфер.

990
00:47:57,540 --> 00:47:59,910
>> Мы можем продолжать идти.

991
00:47:59,910 --> 00:48:02,220
И в какой-то момент, мы идем далеко
Достаточно того, что мы начинаем

992
00:48:02,220 --> 00:48:05,120
перезаписи этот обратный адрес.

993
00:48:05,120 --> 00:48:08,310
Поэтому, как только мы перезаписать адрес возврата,
Это означает, что когда Foo

994
00:48:08,310 --> 00:48:14,220
возвращается, мы возвращаемся туда, где
злоумышленник говорит его по

995
00:48:14,220 --> 00:48:19,490
любое значение он вошел, каким бы
символов пользователь ввел.

996
00:48:19,490 --> 00:48:24,320
И поэтому, если злоумышленник в настоящее время
особенно умен, он может иметь это

997
00:48:24,320 --> 00:48:29,255
вернуться к где-то в PRINTDEF
функция или где-то в таНос

998
00:48:29,255 --> 00:48:31,830
Функция, где-нибудь произвольным.

999
00:48:31,830 --> 00:48:38,420
>> Но еще более умный это то, что если у него есть
пользователь вернуться к прямо здесь.

1000
00:48:38,420 --> 00:48:41,920
И тогда вы начинаете выполнение
их как строк кода.

1001
00:48:41,920 --> 00:48:46,610
Так в этой точке, пользователь может ввести
все, что он хочет в этом регионе.

1002
00:48:46,610 --> 00:48:52,210
И он имеет полный контроль
над вашей программы.

1003
00:48:52,210 --> 00:48:53,460
Вопросы по этому поводу?

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
Так что в следующий вопрос завершения
переписанной Foo таким образом

1006
00:49:00,970 --> 00:49:02,620
не, что это больше не уязвимы.

1007
00:49:02,620 --> 00:49:03,870
>> Таким образом, есть несколько способов,
вы могли бы сделать это.

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
У нас еще есть с только
быть длиной 12.

1010
00:49:13,330 --> 00:49:16,480
Вы, возможно, изменили это
как часть вашего решения.

1011
00:49:16,480 --> 00:49:18,930
Мы также добавили проверку, чтобы сделать
уверен бар не был пустым.

1012
00:49:18,930 --> 00:49:24,460
Хотя вам не нужно
что за полный кредит.

1013
00:49:24,460 --> 00:49:27,690
Таким образом, мы проверки сначала
длина строки бар.

1014
00:49:27,690 --> 00:49:31,650
Если это больше 12, то
фактически не делают копию.

1015
00:49:31,650 --> 00:49:33,010
Так вот один из способов ее исправление.

1016
00:49:33,010 --> 00:49:36,750
>> Другой способ фиксации его есть вместо
имея гр быть только длины 12, у меня

1017
00:49:36,750 --> 00:49:39,310
быть длины STRLEN (бар).

1018
00:49:39,310 --> 00:49:43,370
Другой способ фиксации его является
на самом деле, только что вернулись.

1019
00:49:43,370 --> 00:49:46,690
Так что если вы только что избавился от всех
это, если вы только что удалил все

1020
00:49:46,690 --> 00:49:51,830
строк кода, вы получили бы
полный кредит, так как эту функцию

1021
00:49:51,830 --> 00:49:54,150
на самом деле не чего-то добиться.

1022
00:49:54,150 --> 00:49:57,650
Это копирования из командной строки
Аргумент в некоторую массива в

1023
00:49:57,650 --> 00:49:59,960
его местный кадр стека.

1024
00:49:59,960 --> 00:50:01,310
И тогда, что возвращается.

1025
00:50:01,310 --> 00:50:04,020
И все, что он опытный ушел.

1026
00:50:04,020 --> 00:50:09,740
Так возвращение было также достаточно
способ получить полный кредит.

1027
00:50:09,740 --> 00:50:13,425
>> Дэвид Дж. Малан: Не совсем дух
вопрос, но приемлемый за

1028
00:50:13,425 --> 00:50:15,580
спецификации, тем не менее.

1029
00:50:15,580 --> 00:50:18,260
>> ROB BOWDEN: Вопросы по любой из этого?

1030
00:50:18,260 --> 00:50:22,270
Единственное, что вы по крайней мере
нужно было компиляции кода.

1031
00:50:22,270 --> 00:50:24,810
Поэтому, даже если технически вы не
уязвимыми, если ваш код не

1032
00:50:24,810 --> 00:50:29,130
компиляции, мы не согласиться с этим.

1033
00:50:29,130 --> 00:50:31,350
Нет вопросов?

1034
00:50:31,350 --> 00:50:33,320
ОК.

1035
00:50:33,320 --> 00:50:34,580
>> Дэвид Дж. Малан: Вы хотите
сказать это название?

1036
00:50:34,580 --> 00:50:37,230
>> ROB BOWDEN: Нет.

1037
00:50:37,230 --> 00:50:40,470
>> Дэвид Дж. Малан: Так в этом, это
была или хорошая это новость или плохая новость.

1038
00:50:40,470 --> 00:50:43,870
Это буквально та же проблема
в качестве первого викторины.

1039
00:50:43,870 --> 00:50:46,140
И это почти то же самое
Проблема, как pset1.

1040
00:50:46,140 --> 00:50:49,980
Но это было намеренно упрощена, чтобы быть
проще пирамида, который может быть

1041
00:50:49,980 --> 00:50:52,330
решена со слегка
проще итерации.

1042
00:50:52,330 --> 00:50:55,680
И в самом деле, что мы получали в
здесь не столько логика,

1043
00:50:55,680 --> 00:50:58,100
потому, вероятно, к этому моменту, вы
более комфортно, чем вы были

1044
00:50:58,100 --> 00:51:01,850
в неделю один с для петель или почему петель,
но на самом деле, чтобы дразнить друг от друга, что

1045
00:51:01,850 --> 00:51:04,790
вы немного знакомы с
Понятие, что PHP не только о том, что

1046
00:51:04,790 --> 00:51:05,290
программирования.

1047
00:51:05,290 --> 00:51:07,820
Это действительно может быть использован в качестве языка
писать программы командной строки.

1048
00:51:07,820 --> 00:51:10,060
>> И в самом деле, это то, что мы пытались
чтобы обратить ваше внимание на.

1049
00:51:10,060 --> 00:51:12,060
Это программа PHP командной строки.

1050
00:51:12,060 --> 00:51:16,690
Так C код здесь, в то время как правильное
в С, не исправить для PHP.

1051
00:51:16,690 --> 00:51:17,940
Но код действительно одно и то же.

1052
00:51:17,940 --> 00:51:21,720
Если сравнить решения для викторины
0 против Викторина 1, вы обнаружите, что

1053
00:51:21,720 --> 00:51:25,630
это почти идентичны, за исключением
некоторые знаки доллара и для

1054
00:51:25,630 --> 00:51:27,250
Отсутствие типа данных.

1055
00:51:27,250 --> 00:51:31,720
В частности, если мы взглянем здесь,
вы увидите, что мы перебираем, в этом

1056
00:51:31,720 --> 00:51:33,730
случай, от 1 до до 7.

1057
00:51:33,730 --> 00:51:34,910
>> Мы могли бы сделать это 0 индекс.

1058
00:51:34,910 --> 00:51:37,320
Но иногда, я думаю, это просто
мысленно легче думать о вещах,

1059
00:51:37,320 --> 00:51:38,200
от 1 до 7.

1060
00:51:38,200 --> 00:51:40,300
Если вы хотите один блок, потом два
блоки, потом три, потом

1061
00:51:40,300 --> 00:51:41,770
точка, точка, точка семь.

1062
00:51:41,770 --> 00:51:45,960
Мы J инициализации до 1
а затем рассчитывает на до I.

1063
00:51:45,960 --> 00:51:48,150
И здесь все
в противном случае идентичны.

1064
00:51:48,150 --> 00:51:49,790
Но следует назвать
несколько вещей.

1065
00:51:49,790 --> 00:51:53,230
Мы даем вам эти две строки, это первое
один, goofily назван как притон

1066
00:51:53,230 --> 00:51:54,560
для резкого взрыва.

1067
00:51:54,560 --> 00:51:58,770
И это только указывает путь,
папка, в которой программа может быть

1068
00:51:58,770 --> 00:52:02,160
обнаружили, что вы хотите использовать
интерпретировать этот файл.

1069
00:52:02,160 --> 00:52:04,710
>> И то линия после этого, из
Конечно, означает войти в режим PHP.

1070
00:52:04,710 --> 00:52:07,740
А линия в самом низу
означает выхода из режима PHP.

1071
00:52:07,740 --> 00:52:09,740
И это работает, в общем, с
интерпретируемые языки.

1072
00:52:09,740 --> 00:52:14,370
Это своего рода раздражает, если вы пишете
Программа в файле под названием foo.php.

1073
00:52:14,370 --> 00:52:17,320
И тогда ваши пользователи должны просто
помните, ОК, чтобы запустить эту программу, я

1074
00:52:17,320 --> 00:52:22,320
должны ввести "PHP пространство foo.php." Вид
раздражает, если ничего другого.

1075
00:52:22,320 --> 00:52:25,270
И это также показывает, что ваша программа
написано в PHP, который не все

1076
00:52:25,270 --> 00:52:27,060
что освещения для пользователя.

1077
00:52:27,060 --> 00:52:30,100
>> Таким образом, вы можете удалить. PHP вообще
Напомним, от лекции.

1078
00:52:30,100 --> 00:52:35,690
И вы реально можете сделать. / Foo если
Вы chmodded его, сделав его

1079
00:52:35,690 --> 00:52:36,500
исполняемый.

1080
00:52:36,500 --> 00:52:39,630
Так CHMOD + х Foo сделал бы это.

1081
00:52:39,630 --> 00:52:41,460
И если вы также добавить притон здесь.

1082
00:52:41,460 --> 00:52:45,320
Но на самом деле, проблема клонит
распечатав что-то вроде этого.

1083
00:52:45,320 --> 00:52:51,100
Нет HTML, нет C-код, конечно,
лишь некоторые PHP.

1084
00:52:51,100 --> 00:52:54,100
Так Мило затем вернулся в задаче 25.

1085
00:52:54,100 --> 00:52:58,050
И в 25, вам дали следующие
Код скелет, который был

1086
00:52:58,050 --> 00:52:59,730
довольно просто веб-страницы.

1087
00:52:59,730 --> 00:53:04,230
И сочная часть HTML-мудрый снизился
здесь, где мы имеем внутри тела

1088
00:53:04,230 --> 00:53:09,160
форма, которая имеет уникальный идентификатор входа
внутри которого было два входа, один

1089
00:53:09,160 --> 00:53:11,950
с идеей имя, один
с идеей кнопки.

1090
00:53:11,950 --> 00:53:14,240
>> Первым был тип текста,
Второй тип представляет.

1091
00:53:14,240 --> 00:53:16,930
И так, мы дали вам, на самом деле, более
ингредиенты, чем вам нужно, просто так

1092
00:53:16,930 --> 00:53:19,230
вы, ребята, были варианты, с которыми
чтобы решить эту проблему.

1093
00:53:19,230 --> 00:53:21,130
Вы не строго необходимо
все эти идентификаторы.

1094
00:53:21,130 --> 00:53:23,580
Но это позволяет решить
это по-разному.

1095
00:53:23,580 --> 00:53:27,050
И наверху, заметить, что
Целью было вызвать

1096
00:53:27,050 --> 00:53:27,960
окно, как это -

1097
00:53:27,960 --> 00:53:28,780
Здравствуйте, Мило! -

1098
00:53:28,780 --> 00:53:31,270
появляться в браузере с помощью
супер просто, если

1099
00:53:31,270 --> 00:53:33,190
не урод, оповещения функция.

1100
00:53:33,190 --> 00:53:37,480
И так, в конечном счете, это сводится
концептуально как-то прослушивания

1101
00:53:37,480 --> 00:53:41,290
Доводы вида на стороне клиента
, Не на стороне сервера, так или иначе

1102
00:53:41,290 --> 00:53:45,640
отвечая на этой представлению
хватая значение, введенный пользователем

1103
00:53:45,640 --> 00:53:50,120
и поле имени, а затем
отображая его в теле предупреждения.

1104
00:53:50,120 --> 00:53:53,460
>> Так один из способов сделать это с
JQuery, который выглядит немного

1105
00:53:53,460 --> 00:53:56,880
синтаксически недоумение в первую очередь.

1106
00:53:56,880 --> 00:54:00,760
Вы можете сделать это с чистой кода DOM -
document.getelement по ID.

1107
00:54:00,760 --> 00:54:02,530
Но давайте взглянем на этой версии.

1108
00:54:02,530 --> 00:54:05,110
У меня есть несколько важных
линии в первую очередь.

1109
00:54:05,110 --> 00:54:09,460
Так что, у нас есть эта линия, которая является
идентичен тому, что вы, возможно, видели

1110
00:54:09,460 --> 00:54:13,830
в, я считаю, form2.html
от класса в неделю 9.

1111
00:54:13,830 --> 00:54:16,960
И это просто говорю, выполнить
Следующий код, когда

1112
00:54:16,960 --> 00:54:18,430
документ готов.

1113
00:54:18,430 --> 00:54:21,770
Поскольку это важно только потому, что
HTML страницы читаются сверху

1114
00:54:21,770 --> 00:54:23,280
снизу, слева направо.

1115
00:54:23,280 --> 00:54:27,910
>> И поэтому, если вы попытаетесь сделать
что-то в коде здесь в какой-то DOM

1116
00:54:27,910 --> 00:54:31,560
элемент, некоторые HTML теги, это вниз
здесь, вы делаете это слишком рано,

1117
00:54:31,560 --> 00:54:34,220
потому что это не имеет даже
был прочитан в память.

1118
00:54:34,220 --> 00:54:37,740
Так, говоря эту document.ready
линия, мы говорим,

1119
00:54:37,740 --> 00:54:39,040
Вот код, браузер.

1120
00:54:39,040 --> 00:54:42,440
Но не не выполнять это, пока в целом
Документ готов, то есть DOM

1121
00:54:42,440 --> 00:54:44,320
дерево существует в памяти.

1122
00:54:44,320 --> 00:54:47,110
Это одна немного больше
просто, если синтаксически

1123
00:54:47,110 --> 00:54:51,890
немного отличается, где я говорю, захват
элемент HTML чьи уникальные

1124
00:54:51,890 --> 00:54:53,560
идентификатор входа.

1125
00:54:53,560 --> 00:54:56,220
Это то, что хэш-тег
обозначает, уникальный идентификатор.

1126
00:54:56,220 --> 00:54:58,070
А потом я звоню. Представить.

1127
00:54:58,070 --> 00:55:01,660
>> Так. Представить здесь является функцией, в противном случае
известен как способ, это

1128
00:55:01,660 --> 00:55:05,850
внутри объекта на левой
сторона там, что я не выделить.

1129
00:55:05,850 --> 00:55:08,990
Так что если вы думаете, входов в качестве объекта
в памяти - и это действительно так.

1130
00:55:08,990 --> 00:55:10,440
Это узел в дереве -

1131
00:55:10,440 --> 00:55:16,580
. Представить средства, когда эта форма с
этот идентификатор представляется, выполнить

1132
00:55:16,580 --> 00:55:17,700
следующий код.

1133
00:55:17,700 --> 00:55:20,290
Мне все равно, как называется
функция Я выполнения.

1134
00:55:20,290 --> 00:55:23,760
Так вот, я использую, как и прежде, что
называется функцией лямбда или

1135
00:55:23,760 --> 00:55:24,720
анонимная функция.

1136
00:55:24,720 --> 00:55:27,640
Это вовсе не интеллектуально
Интересно другое, чем это не имеет имени,

1137
00:55:27,640 --> 00:55:30,220
и это хорошо, если вы только
когда-либо буду называть его один раз.

1138
00:55:30,220 --> 00:55:34,490
А внутри я на самом деле справиться
представление формы.

1139
00:55:34,490 --> 00:55:36,810
Я сначала объявить переменную
называется значение.

1140
00:55:36,810 --> 00:55:40,610
И то что эффект от этого
подчеркнул часть здесь сейчас?

1141
00:55:40,610 --> 00:55:44,755
Что это делать в
высокий уровень для меня?

1142
00:55:44,755 --> 00:55:48,539
>> АУДИТОРИЯ: Он получает значение,
пользователь не ниже в HTML.

1143
00:55:48,539 --> 00:55:50,920
Он получает этот идентификатор, а затем
обнаруживает, что значение его.

1144
00:55:50,920 --> 00:55:51,590
>> Дэвид Дж. Малан: Совершенно верно.

1145
00:55:51,590 --> 00:55:54,300
Она захватывает узел, чьи уникальные
идентификатор имя.

1146
00:55:54,300 --> 00:55:56,900
Он получает значение в нем, которые
это, по-видимому, что пользователь

1147
00:55:56,900 --> 00:55:58,190
набрали его или себя.

1148
00:55:58,190 --> 00:56:01,020
А потом он хранит, что в
переменная с именем значение.

1149
00:56:01,020 --> 00:56:03,720
Как и в сторону, вы могли бы также
сделал это немного по-другому.

1150
00:56:03,720 --> 00:56:09,250
Полностью приемлемым, делая что-то
ложь значение переменной получает

1151
00:56:09,250 --> 00:56:10,500
document.getElementById.

1152
00:56:10,500 --> 00:56:12,860

1153
00:56:12,860 --> 00:56:15,460
И именно поэтому это немного
утомительно, чтобы не использовать JQuery.

1154
00:56:15,460 --> 00:56:16,710
"Название" значение..

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
Так вполне приемлемо.

1157
00:56:19,620 --> 00:56:22,770
Различные способы сделать это. JQuery просто
имеет тенденцию быть немного более кратким и

1158
00:56:22,770 --> 00:56:25,230
определенно более популярным
среди программистов.

1159
00:56:25,230 --> 00:56:27,590
>> Теперь, я делаю немного здравомыслия
проверить, потому что в задаче

1160
00:56:27,590 --> 00:56:30,820
заявление мы явно сказал, если
Пользователь пока не набрали его или ее

1161
00:56:30,820 --> 00:56:32,580
назвать, не показывают предупреждений.

1162
00:56:32,580 --> 00:56:35,390
Но вы можете проверить на что, просто
проверка на пустой строки для

1163
00:56:35,390 --> 00:56:37,850
цитата-конец цитаты, если есть
ничего на самом деле.

1164
00:56:37,850 --> 00:56:40,880
Но если это не равно котировок конец цитаты,
Я хочу позвонить оповещения.

1165
00:56:40,880 --> 00:56:45,610
И самое интересное в том, что
мы с помощью оператора плюс, который

1166
00:56:45,610 --> 00:56:48,130
чем занимается в JavaScript?

1167
00:56:48,130 --> 00:56:48,740
Объединение.

1168
00:56:48,740 --> 00:56:50,690
Так что это, как PHPs оператора точки.

1169
00:56:50,690 --> 00:56:52,820
Та же самая идея, синтаксис немного другой.

1170
00:56:52,820 --> 00:56:55,280
И я просто создание строку,
вы видели на скриншоте -

1171
00:56:55,280 --> 00:56:57,750
Здравствуйте, так и так.

1172
00:56:57,750 --> 00:56:59,200
>> И тогда последняя деталь заключается в следующем.

1173
00:56:59,200 --> 00:57:04,970
Почему я вернуться ложное внутри
этой анонимной функции?

1174
00:57:04,970 --> 00:57:07,420
>> АУДИТОРИЯ: Там нет значение.

1175
00:57:07,420 --> 00:57:09,380
Вы ставите его в форме.

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
Это просто говорит, если значение не
равно пустой, то сделайте это.

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
Был пробел в этой представления.

1180
00:57:20,940 --> 00:57:21,170
>> Дэвид Дж. Малан: ОК.

1181
00:57:21,170 --> 00:57:21,640
Осторожный, хотя.

1182
00:57:21,640 --> 00:57:22,830
Там нет никого здесь.

1183
00:57:22,830 --> 00:57:25,510
И, что возвращение ложным находится за пределами
из, если условия.

1184
00:57:25,510 --> 00:57:29,470
Так что это подчеркнул линию, вернуться ложным,
не выполняет ни на что, когда

1185
00:57:29,470 --> 00:57:32,310
формы.

1186
00:57:32,310 --> 00:57:36,810
Что возвращения ложное внутри этого
обработчик события, как это называется,

1187
00:57:36,810 --> 00:57:38,450
рассматриваемое событие
быть представление?

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> АУДИТОРИЯ: Потому что это
происходит только один раз.

1190
00:57:44,470 --> 00:57:45,320
>> Дэвид Дж. Малан: только происходит один раз.

1191
00:57:45,320 --> 00:57:46,821
Не совсем.

1192
00:57:46,821 --> 00:57:47,292
Да?

1193
00:57:47,292 --> 00:57:50,589
>> АУДИТОРИЯ: Это предотвращает форму от
представления к поведению по умолчанию,

1194
00:57:50,589 --> 00:57:52,480
который сделает перезагрузки страницы.

1195
00:57:52,480 --> 00:57:53,110
>> Дэвид Дж. Малан: Совершенно верно.

1196
00:57:53,110 --> 00:57:56,490
Так что я перегрузки термин представить здесь,
потому что я говорю, форма

1197
00:57:56,490 --> 00:57:57,670
представляется.

1198
00:57:57,670 --> 00:58:02,240
Но, как вы говорите, на самом деле это не
был представлен в истинной HTTP образом.

1199
00:58:02,240 --> 00:58:06,870
При нажатии кнопки Отправить, из-за нашего
OnSubmit обработчик, мы перехвата

1200
00:58:06,870 --> 00:58:09,040
что форма представления, так сказать.

1201
00:58:09,040 --> 00:58:11,290
Мы тогда делать свое дело
с кодом JavaScript.

1202
00:58:11,290 --> 00:58:14,070
Но я сознательно возвращения ложным,
потому что я не хочу чтобы это произошло

1203
00:58:14,070 --> 00:58:18,430
долю секунды позже для всей форме
Сам должен быть представлен в Интернете

1204
00:58:18,430 --> 00:58:22,800
сервер с пар ключ-значение, изменив
URL, чтобы быть что-то вроде

1205
00:58:22,800 --> 00:58:26,180
д = кошки или то, что мы сделали,
Например, в классе.

1206
00:58:26,180 --> 00:58:29,640
Я не хочу, чтобы это произошло, потому что
нет слушающий сервер для этого

1207
00:58:29,640 --> 00:58:30,690
сформировать представление.

1208
00:58:30,690 --> 00:58:32,320
Это чисто сделано в коде JavaScript.

1209
00:58:32,320 --> 00:58:35,760
И именно поэтому я даже не имеют
Действие атрибут моей форме, потому что я

1210
00:58:35,760 --> 00:58:38,870
не намерены, чтобы это
когда-либо зайти на сервер.

1211
00:58:38,870 --> 00:58:40,780
>> Так что это представляется.

1212
00:58:40,780 --> 00:58:44,340
Но мы перехвата эту форму
представление и предотвращения дефолта

1213
00:58:44,340 --> 00:58:47,477
поведение, которое является фактически
пройти весь путь к серверу.

1214
00:58:47,477 --> 00:58:48,730
>> АУДИТОРИЯ: Так держать его на стороне клиента.

1215
00:58:48,730 --> 00:58:49,780
>> Дэвид Дж. Малан: Ведение
это на стороне клиента.

1216
00:58:49,780 --> 00:58:51,030
Совершенно верно.

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
Затем был мой, о MySQL.

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> ROB BOWDEN: ОК.

1221
00:59:00,430 --> 00:59:04,990
Так что это первый вопрос был вообще
грубо для людей.

1222
00:59:04,990 --> 00:59:07,270
Хотя более поздние пошли лучше.

1223
00:59:07,270 --> 00:59:12,260
Таким образом, вы должны были выбрать правильные данные
типа для обоих этих столбцов.

1224
00:59:12,260 --> 00:59:17,750
И оба из них имеют некоторые
вещи о них, что

1225
00:59:17,750 --> 00:59:20,620
сделать выбор трудно.

1226
00:59:20,620 --> 00:59:24,430
Так внутр не правильный
введите числа.

1227
00:59:24,430 --> 00:59:29,410
Причина в том, 12-значный номер счета
число, внутр не является достаточно большим, чтобы

1228
00:59:29,410 --> 00:59:31,070
хранить всего цифры.

1229
00:59:31,070 --> 00:59:36,570
Так действует выбор был бы большой
Int, если вы не знаете, что.

1230
00:59:36,570 --> 00:59:42,090
Другой вариант мог бы быть
поле символ длины 12.

1231
00:59:42,090 --> 00:59:44,560
Так что либо из тех, работал бы.

1232
00:59:44,560 --> 00:59:46,100
Int не будет.

1233
00:59:46,100 --> 00:59:50,170
>> Теперь, баланс, вспомните pset7.

1234
00:59:50,170 --> 00:59:59,540
Таким образом, мы специально использовали десятичные
хранить стоимости акций или -

1235
00:59:59,540 --> 01:00:00,550
>> Дэвид Дж. Малан: Наличными.

1236
01:00:00,550 --> 01:00:01,060
>> ROB BOWDEN: Наличными.

1237
01:00:01,060 --> 01:00:05,710
Мы использовали десятичные для хранения количества
денежных средств, которые пользователь в настоящее время имеет.

1238
01:00:05,710 --> 01:00:10,950
Так по этой причине мы сделать это
потому что, помните, плавает.

1239
01:00:10,950 --> 01:00:12,480
Там в с плавающей точкой в ​​точности.

1240
01:00:12,480 --> 01:00:18,200
Он не может точно хранить деньги
значения, как мы хотим здесь.

1241
01:00:18,200 --> 01:00:23,630
Так десятичной способен точно магазин
что-то, скажем, два знака после запятой.

1242
01:00:23,630 --> 01:00:27,630
Вот почему баланс, мы хотим его
десятичное, а не плавать.

1243
01:00:27,630 --> 01:00:30,230
>> Дэвид Дж. Малан: А также, тоже, хотя
это могло бы быть умным и в других

1244
01:00:30,230 --> 01:00:32,760
контексты, чтобы думать, может быть, это
это шанс для внутр.

1245
01:00:32,760 --> 01:00:34,420
Я просто отслеживать
вещи в гроши.

1246
01:00:34,420 --> 01:00:38,670
Потому что мы явно показали по умолчанию
Значение будучи 100.00, что

1247
01:00:38,670 --> 01:00:40,380
означает, что он может быть просто внутр.

1248
01:00:40,380 --> 01:00:45,310
И еще тонкость тоже с числа
было то, что это не было предназначено

1249
01:00:45,310 --> 01:00:46,180
быть вопрос с подвохом.

1250
01:00:46,180 --> 01:00:49,860
Но напомним, что внутр в MySQL,
как в С, по крайней мере

1251
01:00:49,860 --> 01:00:51,440
Прибор, является 32-разрядным.

1252
01:00:51,440 --> 01:00:53,960
И хотя мы не ожидаем Вас
точно знать, сколько цифры, которые

1253
01:00:53,960 --> 01:00:56,910
средства, не вспомнить, что наибольшее количество
Вы можете представлять потенциально

1254
01:00:56,910 --> 01:01:00,710
с 32-разрядного числа примерно то, что?

1255
01:01:00,710 --> 01:01:02,760
>> Какой номер у нас всегда говорю?

1256
01:01:02,760 --> 01:01:04,530
От 2 до 32, что и примерно?

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
Вы не должны знать точно.

1259
01:01:08,780 --> 01:01:10,580
Но примерно полезно в жизни.

1260
01:01:10,580 --> 01:01:12,200
Это примерно 4 миллиарда.

1261
01:01:12,200 --> 01:01:14,430
Таким образом, мы сказали, что несколько раз.

1262
01:01:14,430 --> 01:01:16,360
Я знаю, что сказал, что несколько раз.

1263
01:01:16,360 --> 01:01:17,670
И это примерно 4 миллиарда.

1264
01:01:17,670 --> 01:01:19,710
И это хорошее правило
эмпирическое знать.

1265
01:01:19,710 --> 01:01:21,880
Если у вас есть 8 бит, 256
является магическим числом.

1266
01:01:21,880 --> 01:01:24,160
Если у вас есть 32 бита, 4
млрд. плюс-минус.

1267
01:01:24,160 --> 01:01:27,140
Так что если вы просто запишите 4000000000,
вы увидите, что это меньше цифр, чем

1268
01:01:27,140 --> 01:01:30,970
12, что означает, что явно не
достаточно выразительность захватить

1269
01:01:30,970 --> 01:01:34,220
12-значный номер счета.

1270
01:01:34,220 --> 01:01:34,940
>> ROB BOWDEN: ОК.

1271
01:01:34,940 --> 01:01:38,520
Таким образом, остальные пошли лучше.

1272
01:01:38,520 --> 01:01:40,900
Так предположить, что банк
налагает $ 20 ежемесячно

1273
01:01:40,900 --> 01:01:42,400
плата за обслуживание по всем счетам.

1274
01:01:42,400 --> 01:01:45,506
С чем SQL запросов могли банк
вычесть $ 20 с каждого счетчика, даже если

1275
01:01:45,506 --> 01:01:47,520
это приводит к некоторым отрицательным сальдо?

1276
01:01:47,520 --> 01:01:50,380
Так в основном, Есть четыре
Основные типы запросов -

1277
01:01:50,380 --> 01:01:52,840
вставить, выберите, обновления и удаления.

1278
01:01:52,840 --> 01:01:56,080
Итак, что мы думаем, что мы
собираетесь использовать здесь?

1279
01:01:56,080 --> 01:01:57,000
Обновление.

1280
01:01:57,000 --> 01:01:58,260
>> Так что давайте взглянем.

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
Так вот мы обновляем.

1283
01:02:05,870 --> 01:02:09,900
Какой стол мы обновлении счета?

1284
01:02:09,900 --> 01:02:11,670
Так обновлении счета.

1285
01:02:11,670 --> 01:02:15,390
И то синтаксис говорит, что
на счетах мы обновлении?

1286
01:02:15,390 --> 01:02:19,520
Ну, мы устанавливаем баланс, равный
текущее значение баланса минус 20.

1287
01:02:19,520 --> 01:02:22,860
Так что это будет обновить все строки
счетов, вычитания

1288
01:02:22,860 --> 01:02:26,250
$ 20 с баланса.

1289
01:02:26,250 --> 01:02:29,260
>> Дэвид Дж. Малан: Распространенная ошибка здесь,
хотя мы иногда простил его,

1290
01:02:29,260 --> 01:02:32,990
был на самом деле есть PHP код здесь
вызова функции запроса или положить

1291
01:02:32,990 --> 01:02:35,460
Кавычки вокруг всего, что
не должны быть там.

1292
01:02:35,460 --> 01:02:39,780
>> ROB BOWDEN: Помните, что MySQL является
отдельный язык из PHP.

1293
01:02:39,780 --> 01:02:42,410
Мы, оказывается, писать MySQL в PHP.

1294
01:02:42,410 --> 01:02:46,180
И PHP затем отправить его
к серверу MySQL.

1295
01:02:46,180 --> 01:02:51,120
Но вам не нужно PHP для того, чтобы
связь с сервером MySQL.

1296
01:02:51,120 --> 01:02:51,730
>> Дэвид Дж. Малан: Совершенно верно.

1297
01:02:51,730 --> 01:02:54,240
Так никакие переменные со знаками доллара
должно быть в данном контексте.

1298
01:02:54,240 --> 01:02:59,550
Он может просто сделать все математики
в самой базе данных.

1299
01:02:59,550 --> 01:03:00,080
>> ROB BOWDEN: ОК.

1300
01:03:00,080 --> 01:03:01,300
Так что в следующий один.

1301
01:03:01,300 --> 01:03:02,731
Это следующий?

1302
01:03:02,731 --> 01:03:03,210
Да.

1303
01:03:03,210 --> 01:03:06,570
Так с тем, что SQL-запрос может банк
извлечения из памяти номеров из-за его

1304
01:03:06,570 --> 01:03:09,300
богатые клиенты, те, с
Остатки больше, чем 1000?

1305
01:03:09,300 --> 01:03:13,280
Так какой из четырех основных типов
мы собираемся здесь нужно?

1306
01:03:13,280 --> 01:03:14,430
Выберите.

1307
01:03:14,430 --> 01:03:16,650
Поэтому мы хотим, чтобы выбрать.

1308
01:03:16,650 --> 01:03:17,610
Что мы хотим, чтобы выбрать?

1309
01:03:17,610 --> 01:03:19,380
Что колонка мы хотим, чтобы выбрать?

1310
01:03:19,380 --> 01:03:20,970
Мы специально хотим
для выбора номера.

1311
01:03:20,970 --> 01:03:23,910
Но если вы сказали звезда, мы
Также принято считать, что.

1312
01:03:23,910 --> 01:03:25,820
>> Так выбрать номер из какой таблицы?

1313
01:03:25,820 --> 01:03:26,640
Учетные записи.

1314
01:03:26,640 --> 01:03:28,370
И то условие мы хотим?

1315
01:03:28,370 --> 01:03:30,140
Где баланс превышает 1000.

1316
01:03:30,140 --> 01:03:31,720
Мы также приняли больше
или равно.

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
Последнее один.

1319
01:03:36,190 --> 01:03:42,940
С чем SQL запросов могли банк
близко, то есть удалить все счета, которые

1320
01:03:42,940 --> 01:03:44,480
имеет баланс $ 0?

1321
01:03:44,480 --> 01:03:47,620
Итак, какие из четырех мы
захочет использовать?

1322
01:03:47,620 --> 01:03:48,320
Удалить.

1323
01:03:48,320 --> 01:03:50,180
Так синтаксис для этого?

1324
01:03:50,180 --> 01:03:51,890
Удалить из какой таблицы?

1325
01:03:51,890 --> 01:03:53,550
Учетные записи.

1326
01:03:53,550 --> 01:03:55,790
И то условие, на котором
мы хотим, чтобы удалить -

1327
01:03:55,790 --> 01:03:57,280
где баланс равен нулю.

1328
01:03:57,280 --> 01:04:03,050
Так удалить все строки из счетов
где баланс равен нулю.

1329
01:04:03,050 --> 01:04:04,300
Вопросы по любой из них?

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
Хотите очереди?

1332
01:04:10,260 --> 01:04:11,200
>> Дэвид Дж. Малан: Очередь руководство.

1333
01:04:11,200 --> 01:04:17,110
Так в этом, мы дали вам несколько
знакомы структура, которую мы исследовали

1334
01:04:17,110 --> 01:04:20,450
немного в классе рядом с структурами,
который был данные

1335
01:04:20,450 --> 01:04:21,910
структура, относящаяся по духу.

1336
01:04:21,910 --> 01:04:24,670
Разница хоть и с очереди
что мы должны были как-то помню, кто

1337
01:04:24,670 --> 01:04:27,900
был в начале очереди, в большой
часть, так что мы могли бы сделать больше

1338
01:04:27,900 --> 01:04:30,530
эффективное использование памяти, по крайней мере,
если бы мы использовали массив.

1339
01:04:30,530 --> 01:04:35,460
>> Потому напомним, если у нас есть массив, если,
например, это фронт

1340
01:04:35,460 --> 01:04:38,470
очередь, если я получаю в очередь здесь,
а потом кто-то входит в линию

1341
01:04:38,470 --> 01:04:42,710
позади меня, у меня за спиной, у меня за спиной, и
один человек выходит из линии, вы

1342
01:04:42,710 --> 01:04:45,930
мог, как мы видели некоторые из наших человека
добровольцы в классе, есть у каждого

1343
01:04:45,930 --> 01:04:47,100
переложить этот путь.

1344
01:04:47,100 --> 01:04:50,880
Но в целом, то, все делают
что-то не наилучшим образом использовать время

1345
01:04:50,880 --> 01:04:54,600
в программе, потому что это означает, что ваш
Алгоритм работает в какой

1346
01:04:54,600 --> 01:04:56,520
асимптотическое время работы?

1347
01:04:56,520 --> 01:04:57,420
Это линейная.

1348
01:04:57,420 --> 01:04:59,600
>> И я чувствую, что это своего рода глупо.

1349
01:04:59,600 --> 01:05:02,890
Если следующий человек в очереди на следующий
Человек, который должен лететь в

1350
01:05:02,890 --> 01:05:04,660
магазин, они не у всех есть
двигаться вместе.

1351
01:05:04,660 --> 01:05:08,200
Просто позвольте, что человек будет рвал
когда придет время, например.

1352
01:05:08,200 --> 01:05:09,870
Так что мы можем сэкономить немного времени там.

1353
01:05:09,870 --> 01:05:14,840
И так, чтобы сделать это, однако, что средства
что глава очереди или

1354
01:05:14,840 --> 01:05:18,060
Передняя часть очереди будет
постепенно двигаться глубже и глубже

1355
01:05:18,060 --> 01:05:23,340
в массиве и в конечном счете могли бы
фактически обернуть вокруг, если мы используем

1356
01:05:23,340 --> 01:05:25,790
массив для хранения людей
в этой очереди.

1357
01:05:25,790 --> 01:05:28,390
Таким образом, вы можете подумать, из
Массив в виде круглого данных

1358
01:05:28,390 --> 01:05:29,880
структура в этом смысле.

1359
01:05:29,880 --> 01:05:33,970
>> Таким образом, вы так или иначе придется отслеживать
размер его или действительно конец его

1360
01:05:33,970 --> 01:05:36,250
а затем, когда начало ней.

1361
01:05:36,250 --> 01:05:39,490
Таким образом, мы полагаем, что вы объявляете
одним из таких очередей, призвание

1362
01:05:39,490 --> 01:05:41,330
это д, просто одна буква.

1363
01:05:41,330 --> 01:05:44,570
Тогда мы предлагаем, что передняя быть
инициализировано равным нулю, и что размер

1364
01:05:44,570 --> 01:05:45,470
инициализировать нулю.

1365
01:05:45,470 --> 01:05:47,770
>> Поэтому в данный момент, нет ничего
внутри этой очереди.

1366
01:05:47,770 --> 01:05:50,910
И мы просим вас заполнить
реализация Enqueue ниже в

1367
01:05:50,910 --> 01:05:55,250
таким образом, чтобы функция добавляет п к
конец д, а затем возвращает истину.

1368
01:05:55,250 --> 01:05:58,690
Но если д полон или отрицательным,
функция должна вместо вернуться ложным.

1369
01:05:58,690 --> 01:06:01,060
И мы дали вам пару
предположений.

1370
01:06:01,060 --> 01:06:04,320
Но они на самом деле не функционально
отношение, просто BOOL существует,

1371
01:06:04,320 --> 01:06:06,690
потому что, технически, логический не
существуют в C, если вы не включают

1372
01:06:06,690 --> 01:06:07,310
определенный файл заголовка.

1373
01:06:07,310 --> 01:06:09,350
Так что просто убедитесь, что
не было это трюк

1374
01:06:09,350 --> 01:06:10,940
Вопрос рода вещи.

1375
01:06:10,940 --> 01:06:16,280
>> Так поставить в очередь, мы предложили в образце
решения по реализации следующим образом.

1376
01:06:16,280 --> 01:06:20,420
Один из них, мы сначала проверяем легкость,
низко висящие фрукты.

1377
01:06:20,420 --> 01:06:23,820
Если очередь заполнена или число, что
Вы пытаетесь вставить меньше

1378
01:06:23,820 --> 01:06:26,380
нуля, что мы сказали в
спецификация проблемы должны

1379
01:06:26,380 --> 01:06:30,320
не допускается, потому что мы только хотим
неотрицательные значения, то вы должны

1380
01:06:30,320 --> 01:06:31,640
просто сразу вернуться ложным.

1381
01:06:31,640 --> 01:06:33,820
Таким образом, некоторые относительно легко
Проверка ошибок.

1382
01:06:33,820 --> 01:06:38,720
Если бы вы хотите добавить, что фактическая
число, что нужно было сделать немного

1383
01:06:38,720 --> 01:06:39,440
думаю здесь.

1384
01:06:39,440 --> 01:06:41,330
И это то, где это немного раздражает
мысленно, потому что вы должны

1385
01:06:41,330 --> 01:06:43,000
выяснить, как обращаться циклического возврата.

1386
01:06:43,000 --> 01:06:46,870
>> Но зачаток идеи здесь, это из
интерес для нас является то, что с запахом

1387
01:06:46,870 --> 01:06:51,480
часто подразумевает модульная арифметика и
мод оператор, процент сторона,

1388
01:06:51,480 --> 01:06:55,140
где вы можете пойти от большего значения
на ноль, а затем один и два и

1389
01:06:55,140 --> 01:06:58,650
три, а затем обратно к нулю,
один и два и три и так далее

1390
01:06:58,650 --> 01:06:59,380
снова и снова.

1391
01:06:59,380 --> 01:07:02,880
Так как мы предлагаем сделать это
что мы хотим в качестве индекса в

1392
01:07:02,880 --> 01:07:05,850
Массив называется чисел, где
наши целые лежат.

1393
01:07:05,850 --> 01:07:10,740
Но чтобы попасть туда, мы сначала хотим сделать
независимо от размера очереди всего лишь

1394
01:07:10,740 --> 01:07:14,080
затем добавить к этому то, что
Передняя часть списка.

1395
01:07:14,080 --> 01:07:17,880
И эффект, что является, чтобы поставить нас в
правильная позиция в очереди и

1396
01:07:17,880 --> 01:07:20,970
Не думайте, что первым человеком в линии
находится в начале, что он или

1397
01:07:20,970 --> 01:07:24,130
она абсолютно может быть, если мы
были также переход всех.

1398
01:07:24,130 --> 01:07:26,710
Но мы просто создаем работу
для себя, если мы взяли

1399
01:07:26,710 --> 01:07:27,800
что особое путь.

1400
01:07:27,800 --> 01:07:29,330
>> Так что мы можем держать его относительно просто.

1401
01:07:29,330 --> 01:07:32,180
Мы должны помнить, что мы просто
добавил Int в очередь.

1402
01:07:32,180 --> 01:07:35,850
А потом мы просто возвращаем правда.

1403
01:07:35,850 --> 01:07:38,560
Между тем, в Dequeue, мы попросили
вам делать следующее.

1404
01:07:38,560 --> 01:07:42,260
Реализовать это таким образом, что она
dequeues, то есть удаляет и возвращает,

1405
01:07:42,260 --> 01:07:44,190
Int в передней части очереди.

1406
01:07:44,190 --> 01:07:46,410
Чтобы снять Int, достаточно
забыть его.

1407
01:07:46,410 --> 01:07:47,650
Вам не нужно переопределить свою лепту.

1408
01:07:47,650 --> 01:07:48,820
Так что это еще на самом деле.

1409
01:07:48,820 --> 01:07:51,930
Так же, как данные на жестком диске,
мы просто игнорируя тот факт,

1410
01:07:51,930 --> 01:07:52,970
что теперь там.

1411
01:07:52,970 --> 01:07:55,520
И если д пуст, мы должны
вместо этого возвращать отрицательное 1.

1412
01:07:55,520 --> 01:07:56,750
Так что это чувствует произвольным.

1413
01:07:56,750 --> 01:08:01,640
Почему вернуться отрицательный 1
вместо ложно?

1414
01:08:01,640 --> 01:08:02,620
Да.

1415
01:08:02,620 --> 01:08:05,070
>> АУДИТОРИЯ: Вопрос хранит
положительные значения.

1416
01:08:05,070 --> 01:08:10,950
Так как вы только хранить положительные значения
в д, отрицательный ошибка.

1417
01:08:10,950 --> 01:08:11,510
>> Дэвид Дж. Малан: Хорошо, правда.

1418
01:08:11,510 --> 01:08:14,850
Так, потому что мы только хранить положительным
значения или равен нулю, то это прекрасно, чтобы

1419
01:08:14,850 --> 01:08:18,050
возвращать отрицательное значение в качестве дозорных
значение, специальный символ.

1420
01:08:18,050 --> 01:08:21,630
Но вы переписывания истории там,
потому что причина, что мы только

1421
01:08:21,630 --> 01:08:25,890
возвращение неотрицательные значения
потому что мы хотим, чтобы

1422
01:08:25,890 --> 01:08:27,670
иметь значение дозорного.

1423
01:08:27,670 --> 01:08:32,617
Так, более конкретно, почему бы просто не
вернуться ложным в случае ошибки?

1424
01:08:32,617 --> 01:08:33,099
Да.

1425
01:08:33,099 --> 01:08:35,510
>> АУДИТОРИЯ: Вы не смогли
вернуться целое.

1426
01:08:35,510 --> 01:08:36,630
>> Дэвид Дж. Малан: Совершенно верно.

1427
01:08:36,630 --> 01:08:38,569
И это где С получает
довольно сдерживающим.

1428
01:08:38,569 --> 01:08:40,590
Если вы говорите, что вы собираетесь
вернуть Int, у вас есть

1429
01:08:40,590 --> 01:08:41,279
вернуть Int.

1430
01:08:41,279 --> 01:08:43,689
Вы не можете получить фантазии и начать возвращение
BOOL или поплавок или

1431
01:08:43,689 --> 01:08:45,040
строка или что-то в этом роде.

1432
01:08:45,040 --> 01:08:49,370
Теперь, тем временем, JavaScript и PHP и
некоторые другие языки может, в самом деле,

1433
01:08:49,370 --> 01:08:51,310
Вы возвращении отличается
типы значений.

1434
01:08:51,310 --> 01:08:54,819
И это действительно может быть полезно, когда
вы могли бы вернуться положительные INTS, нули,

1435
01:08:54,819 --> 01:08:59,439
отрицательные Интс, или ложь или нулевой
даже для обозначения ошибку.

1436
01:08:59,439 --> 01:09:01,890
Но мы не имеем, что
универсальность в С.

1437
01:09:01,890 --> 01:09:04,569
>> Так что с Dequeue, что мы
предлагаю сделать это -

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> ROB BOWDEN: Вы можете вернуться ложным.

1440
01:09:09,830 --> 01:09:13,189
Это просто, что ложь является хэш
определить ложь нулю.

1441
01:09:13,189 --> 01:09:16,000
Так что если вы вернуться ложным,
вы вернулись к нулю.

1442
01:09:16,000 --> 01:09:25,470
И ноль является допустимым, что в нашей очереди,
в то время как отрицательный 1 не, если

1443
01:09:25,470 --> 01:09:27,000
ложно случилось с отрицательным 1.

1444
01:09:27,000 --> 01:09:29,972
Но вы не должны даже
должны знать, что.

1445
01:09:29,972 --> 01:09:32,399
>> Дэвид Дж. Малан: Это
почему я не сказал этого.

1446
01:09:32,399 --> 01:09:36,450
>> ROB BOWDEN: Но это не так
что вы не можете вернуться ложным.

1447
01:09:36,450 --> 01:09:37,700
>> Дэвид Дж. Малан: Конечно.

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
Так из очереди, заметить, что мы принимаем
аннулированию в качестве аргумента.

1450
01:09:44,240 --> 01:09:45,479
И это потому, что мы не
проходя ничего дюйма

1451
01:09:45,479 --> 01:09:48,359
Мы просто хотим, чтобы удалить элемент
в начале очереди.

1452
01:09:48,359 --> 01:09:49,819
Итак, как мы могли бы идти об этом?

1453
01:09:49,819 --> 01:09:51,290
Ну, во-первых, давайте сделаем это
Быстрая проверка здравомыслие.

1454
01:09:51,290 --> 01:09:53,350
Если размер очереди 0, есть
нет работы предстоит сделать.

1455
01:09:53,350 --> 01:09:54,210
Вернуться отрицательный 1.

1456
01:09:54,210 --> 01:09:54,800
Готово.

1457
01:09:54,800 --> 01:09:56,340
Так вот несколько строк моей программы.

1458
01:09:56,340 --> 01:09:58,180
Так только четыре линии остаются.

1459
01:09:58,180 --> 01:10:01,310
>> Так вот я решил уменьшить
размер.

1460
01:10:01,310 --> 01:10:04,620
И уменьшая размер эффективно
означает, что я забыл

1461
01:10:04,620 --> 01:10:06,010
что-то там.

1462
01:10:06,010 --> 01:10:09,910
Но я также должен обновить где
передняя из чисел являются.

1463
01:10:09,910 --> 01:10:11,620
Таким образом, чтобы сделать это, мне нужно
сделать две вещи.

1464
01:10:11,620 --> 01:10:16,390
Я в первую очередь необходимо вспомнить, что количество
находится в начале очереди,

1465
01:10:16,390 --> 01:10:17,860
потому что мне нужно вернуть эту вещь.

1466
01:10:17,860 --> 01:10:20,910
Так что я не хочу, чтобы случайно забыть
об этом и затем перезаписать его.

1467
01:10:20,910 --> 01:10:22,840
Я просто хочу, чтобы помнить в междунар.

1468
01:10:22,840 --> 01:10:27,310
>> А теперь, я хочу, чтобы обновить
q.front быть q.front 1.

1469
01:10:27,310 --> 01:10:30,070
Так что, если это был первый человек в
линия, сейчас, я хочу сделать плюс 1 к

1470
01:10:30,070 --> 01:10:31,930
указать на следующий человек в линии.

1471
01:10:31,930 --> 01:10:33,420
Но я должен справиться с этим циклического возврата.

1472
01:10:33,420 --> 01:10:37,270
И если мощность составляет глобальная константа,
что происходит, чтобы позволить мне убедиться

1473
01:10:37,270 --> 01:10:41,140
как я доказываю до самого последнего человека в
линия, операция по модулю принесет

1474
01:10:41,140 --> 01:10:43,840
меня обратно к нулю при
Передняя часть очереди.

1475
01:10:43,840 --> 01:10:46,050
И который обрабатывает запахом здесь.

1476
01:10:46,050 --> 01:10:48,950
А потом я продолжу вернуться н.

1477
01:10:48,950 --> 01:10:51,530
>> Теперь, собственно говоря, я не сделал
должны объявить н.

1478
01:10:51,530 --> 01:10:53,880
У меня не было, чтобы схватить его и хранить его
временно, потому что значение

1479
01:10:53,880 --> 01:10:54,740
еще там.

1480
01:10:54,740 --> 01:10:57,490
Так что я мог бы просто делать правильные арифметические
вернуть бывшего главу

1481
01:10:57,490 --> 01:10:58,450
очереди.

1482
01:10:58,450 --> 01:11:01,850
Но я просто чувствовал, что это было более ясно,
на самом деле захватить Int, положил его

1483
01:11:01,850 --> 01:11:04,320
на русском языке, а затем вернуться, что
для ясности, но

1484
01:11:04,320 --> 01:11:05,735
не является строго необходимым.

1485
01:11:05,735 --> 01:11:09,313

1486
01:11:09,313 --> 01:11:12,130
Psst.

1487
01:11:12,130 --> 01:11:13,410
Они все произносимые в моей голове.

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> ROB BOWDEN: Так первый вопрос
это проблема бинарное дерево.

1490
01:11:19,110 --> 01:11:22,140
Так первый вопрос, мы
учитывая эти цифры.

1491
01:11:22,140 --> 01:11:27,160
И мы хотим, чтобы хоть как-то вставить их в
эти узлы таким образом, что это

1492
01:11:27,160 --> 01:11:30,110
действует бинарное дерево.

1493
01:11:30,110 --> 01:11:36,260
Таким образом, одна вещь, чтобы помнить о
бинарные деревья поиска является то, что это не

1494
01:11:36,260 --> 01:11:39,800
только то, что вещь, чтобы слева
меньше и, что нужно

1495
01:11:39,800 --> 01:11:41,120
право больше.

1496
01:11:41,120 --> 01:11:44,580
Это должно быть то, что все дерево, чтобы
левый меньше, и все дерево

1497
01:11:44,580 --> 01:11:45,740
вправо, что больше.

1498
01:11:45,740 --> 01:11:55,260
>> Так что если я ставлю 34 здесь в верхней части, а затем
Я положил 20 здесь, так что это действительно так

1499
01:11:55,260 --> 01:11:56,970
далеко, потому что 34 здесь.

1500
01:11:56,970 --> 01:11:57,920
20 собирается слева.

1501
01:11:57,920 --> 01:11:58,950
Так вот меньше.

1502
01:11:58,950 --> 01:12:03,640
Но я не могу затем положить 59 здесь, потому что
хотя 59 находится справа 20,

1503
01:12:03,640 --> 01:12:06,140
она по-прежнему слева от 34.

1504
01:12:06,140 --> 01:12:10,760
Так что с этого ограничения в виду,
Самый простой способ, вероятно, решая этот

1505
01:12:10,760 --> 01:12:14,330
Проблема в том, чтобы только вид
из этих чисел -

1506
01:12:14,330 --> 01:12:18,720
так 20, 34, 36, 52, 59, 106.

1507
01:12:18,720 --> 01:12:21,640
И затем вставьте тех,
слева направо.

1508
01:12:21,640 --> 01:12:23,390
>> Так 20 идет здесь.

1509
01:12:23,390 --> 01:12:24,630
34 идет здесь.

1510
01:12:24,630 --> 01:12:25,830
36 идет здесь.

1511
01:12:25,830 --> 01:12:29,360
52, 59, 106.

1512
01:12:29,360 --> 01:12:34,730
И вы также могли бы разобрался с
некоторые подключения и понимая,

1513
01:12:34,730 --> 01:12:38,830
ой, подождите, я не хватает номеров
заполнить это в здесь.

1514
01:12:38,830 --> 01:12:42,170
Поэтому мне нужно reshift что мой
маршрут примечание будет.

1515
01:12:42,170 --> 01:12:47,490
Но обратите внимание, что в конечном трех, если
Вы читать слева направо, он находится в

1516
01:12:47,490 --> 01:12:48,740
порядке возрастания.

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> Так что теперь, мы хотим объявить, что
структура будет для

1519
01:12:56,540 --> 01:12:58,300
узлы в этом дереве.

1520
01:12:58,300 --> 01:13:02,720
Так что же нам нужно в двоичном дереве?

1521
01:13:02,720 --> 01:13:05,830
Поэтому у нас есть значение типа
внутр, поэтому некоторые внутр значение.

1522
01:13:05,830 --> 01:13:07,220
Я не знаю, что мы назвали
это в растворе -

1523
01:13:07,220 --> 01:13:08,500
Int N.

1524
01:13:08,500 --> 01:13:13,570
Нам нужно указатель на левой ребенка
и указатель на правой ребенка.

1525
01:13:13,570 --> 01:13:17,540
Так это будет выглядеть следующим образом.

1526
01:13:17,540 --> 01:13:20,510
И это будет на самом деле выглядят перед
когда же двусвязный

1527
01:13:20,510 --> 01:13:25,090
Список материал, так уведомление -

1528
01:13:25,090 --> 01:13:27,860
Я собираюсь придется прокручивать все
обратный путь до проблемы 11.

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> Так заметите, что он выглядит так же, это,
кроме того что мы просто случайно называем эти

1531
01:13:36,390 --> 01:13:38,590
разные имена.

1532
01:13:38,590 --> 01:13:41,440
У нас еще есть целое
значение и два указателя.

1533
01:13:41,440 --> 01:13:44,850
Это просто, что вместо лечения
указатели как указывая на следующую вещь

1534
01:13:44,850 --> 01:13:47,955
а предыдущая вещь, мы лечения
указатели, чтобы указать на левой ребенка

1535
01:13:47,955 --> 01:13:49,205
и право ребенка.

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
ОК.

1538
01:13:57,860 --> 01:13:59,650
Так вот наша структура узла.

1539
01:13:59,650 --> 01:14:03,920
А теперь, единственная функция, мы должны
реализации этого является траверс, которые

1540
01:14:03,920 --> 01:14:08,320
мы хотим перейти на дереве, печать
из значений дерева в порядке.

1541
01:14:08,320 --> 01:14:15,241
>> Так смотрит сюда, мы хотели бы, чтобы напечатать
из 20, 34, 36, 52, 59 и 106.

1542
01:14:15,241 --> 01:14:17,970
Как мы добились этого?

1543
01:14:17,970 --> 01:14:18,890
Так что это очень похоже.

1544
01:14:18,890 --> 01:14:22,910
Если бы вы видели в прошлом экзамен проблема
что вы хотели, чтобы распечатать

1545
01:14:22,910 --> 01:14:25,940
все дерево запятыми между
все, это было на самом деле, даже

1546
01:14:25,940 --> 01:14:27,320
легче, чем это.

1547
01:14:27,320 --> 01:14:30,950
Так вот решение.

1548
01:14:30,950 --> 01:14:33,110
Это было значительно легче
если вы сделали это рекурсивно.

1549
01:14:33,110 --> 01:14:36,650
Я не знаю, если кто-то пытался
сделать это повторно.

1550
01:14:36,650 --> 01:14:38,340
>> Но, во-первых, у нас есть базовый вариант.

1551
01:14:38,340 --> 01:14:39,660
Что делать, если корень является недействительным?

1552
01:14:39,660 --> 01:14:40,610
Тогда мы только собираемся вернуться.

1553
01:14:40,610 --> 01:14:42,300
Мы не хотим, чтобы напечатать что-нибудь.

1554
01:14:42,300 --> 01:14:45,940
Остальное мы собираемся пройти
рекурсивно вниз.

1555
01:14:45,940 --> 01:14:48,140
Распечатать весь левое поддерево.

1556
01:14:48,140 --> 01:14:51,440
Так печатать все меньше
чем мой текущего значения.

1557
01:14:51,440 --> 01:14:53,930
А потом я собираюсь печатать сам.

1558
01:14:53,930 --> 01:14:57,310
А потом я собираюсь рекурсивно вниз мой
Весь правое поддерево, поэтому все

1559
01:14:57,310 --> 01:14:58,810
больше, чем моя ценность.

1560
01:14:58,810 --> 01:15:03,870
И это в печать
из все в порядке.

1561
01:15:03,870 --> 01:15:05,860
Вопросы о том, как это на самом деле
Достигается это за?

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> АУДИТОРИЯ: У меня есть вопрос
на [неразборчиво].

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> ROB BOWDEN: Так один из способов приближается
любая рекурсивная проблема в том, чтобы просто думать

1566
01:15:23,550 --> 01:15:26,275
об этом, как вы должны думать
обо всех угловые случаи.

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
Так считают, что мы хотим
распечатать эту все дерево.

1569
01:15:38,110 --> 01:15:42,030
Так что все мы собираемся сосредоточиться на
это конкретный узел -

1570
01:15:42,030 --> 01:15:43,740
36.

1571
01:15:43,740 --> 01:15:47,420
Рекурсивные вызовы, мы делаем вид,
тех, кто только работать.

1572
01:15:47,420 --> 01:15:54,000
Так вот, это рекурсивный вызов
траверс, мы, даже не задумываясь

1573
01:15:54,000 --> 01:15:58,640
об этом, просто пересекая левую
три, представьте, что уже печатает 20

1574
01:15:58,640 --> 01:16:00,730
и 34 для нас.

1575
01:16:00,730 --> 01:16:03,350
А потом, когда мы в конечном счете рекурсивно
позвонить траверс на

1576
01:16:03,350 --> 01:16:07,890
Хорошо, что будет правильно печатать
52, 59 и 106 для нас.

1577
01:16:07,890 --> 01:16:13,620
>> Таким образом, учитывая, что это может печатать 20, 34 и
другой может печатать 52, 59, 108,

1578
01:16:13,620 --> 01:16:17,180
все, что мы должны быть в состоянии сделать, это печать
, себя в середине этого.

1579
01:16:17,180 --> 01:16:21,250
Так распечатать все перед нами.

1580
01:16:21,250 --> 01:16:27,710
Распечатать OURSELF, поэтому текущий узел печати
36, регулярный Е, а затем

1581
01:16:27,710 --> 01:16:31,170
печатать все после нас.

1582
01:16:31,170 --> 01:16:32,730
>> Дэвид Дж. Малан: Это где рекурсия
становится действительно красиво.

1583
01:16:32,730 --> 01:16:36,270
Это этот удивительный прыжок веры, где
Вы делаете мельчайшие немного работы.

1584
01:16:36,270 --> 01:16:38,460
И тогда вы позволить кому-то
еще все остальное.

1585
01:16:38,460 --> 01:16:40,180
И, что кто-то еще
является, по иронии судьбы, вы.

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
Таким образом, для серьезных пунктов домового, если
прокрутке на вопросы -

1588
01:16:48,360 --> 01:16:50,530
>> ROB BOWDEN: По вопросам?

1589
01:16:50,530 --> 01:16:53,490
>> Дэвид Дж. Малан: И немного вниз, чтобы
цифры, кто-нибудь знает, где

1590
01:16:53,490 --> 01:16:55,190
эти цифры взялись?

1591
01:16:55,190 --> 01:16:56,610
>> ROB BOWDEN: У меня буквально ни малейшего представления.

1592
01:16:56,610 --> 01:16:59,794
>> Дэвид Дж. Малан: Они появляются
по всей викторины.

1593
01:16:59,794 --> 01:17:01,150
>> АУДИТОРИЯ: Являются ли они те же номера?

1594
01:17:01,150 --> 01:17:01,910
>> Дэвид Дж. Малан: Эти цифры.

1595
01:17:01,910 --> 01:17:03,260
Немного Пасхальное яйцо.

1596
01:17:03,260 --> 01:17:08,100
Так что для тех из вас, наблюдая в Интернете по адресу
домой, если вы можете сказать нам по электронной почте

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net какое значение
этих повторяющихся шесть цифры

1598
01:17:12,680 --> 01:17:18,560
всей викторины 1, мы будем душ вас
с удивительным вниманием в финале

1599
01:17:18,560 --> 01:17:21,610
Лекция и стресс мяч.

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
Хороший, тонкий.

1602
01:17:27,790 --> 01:17:29,570
>> ROB Боуден: Любой последние вопросы
ни о чем на викторине?

1603
01:17:29,570 --> 01:17:32,608