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

2
00:00:12,610 --> 00:00:12,900
>> DAVID J. MALAN: Va bene.

3
00:00:12,900 --> 00:00:16,790
Quindi benvenuto al primo
CS50 postmortem per un quiz.

4
00:00:16,790 --> 00:00:18,340
Abbiamo pensato inauguriamo
questa tradizione di quest'anno.

5
00:00:18,340 --> 00:00:20,960
E questa sarà l'occasione
a piedi attraverso il

6
00:00:20,960 --> 00:00:22,220
soluzioni per il quiz.

7
00:00:22,220 --> 00:00:26,160
E faremo accelerare o rallentare a base di
su interessi di coloro che sono qui.

8
00:00:26,160 --> 00:00:29,730
>> Allora probabilmente siete qui perché sei
interessati a come si potrebbe avere o

9
00:00:29,730 --> 00:00:31,170
avrebbe risposto ad alcune
di questi problemi.

10
00:00:31,170 --> 00:00:33,300
Allora perché non diamo uno sguardo
in questa prima sezione?

11
00:00:33,300 --> 00:00:34,450
In modo da ottenere stringhe.

12
00:00:34,450 --> 00:00:37,600
Questo ti ha dato tre versioni diverse
di un programma che era, in ultima analisi,

13
00:00:37,600 --> 00:00:39,650
scopo di ottenere una stringa da un utente.

14
00:00:39,650 --> 00:00:42,530
Se sia o non ha fatto che era
lasciato a voi determinare.

15
00:00:42,530 --> 00:00:45,150
>> E abbiamo chiesto in domanda 0,
supponiamo che la versione 1 è

16
00:00:45,150 --> 00:00:46,400
compilato ed eseguito.

17
00:00:46,400 --> 00:00:48,860
Perché potrebbe il programma segmentation fault?

18
00:00:48,860 --> 00:00:51,150
A prima vista, qualche suggerimento
come mai?

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

20
00:00:54,012 --> 00:00:54,489
Già.

21
00:00:54,489 --> 00:00:59,260
>> PUBBLICO: Così mi ricordo di aver visto questo
una precedente esempio di guardare il

22
00:00:59,260 --> 00:01:05,506
char * s e vedendo la scansione dei s e
vedere perché è un puntatore, come

23
00:01:05,506 --> 00:01:07,971
ha influenzato quello che scansionato in?

24
00:01:07,971 --> 00:01:10,940
E 's o l' indirizzo di s?

25
00:01:10,940 --> 00:01:11,180
>> DAVID J. MALAN: OK.

26
00:01:11,180 --> 00:01:11,480
Buona.

27
00:01:11,480 --> 00:01:14,830
Quindi, in definitiva, la fonte di qualsiasi problema
è presumibilmente andando a ridurre

28
00:01:14,830 --> 00:01:16,210
a tale variabile s.

29
00:01:16,210 --> 00:01:17,280
Ed è infatti una variabile.

30
00:01:17,280 --> 00:01:19,900
Il tipo di dati di tale variabile è
char *, il che significa che sta per

31
00:01:19,900 --> 00:01:22,570
contenere l'indirizzo di un personaggio.

32
00:01:22,570 --> 00:01:23,850
E qui sta l'intuizione.

33
00:01:23,850 --> 00:01:28,330
Sta andando a contenere l'indirizzo di
un carattere o, più in generale, la

34
00:01:28,330 --> 00:01:32,110
indirizzo del primo carattere
un intero blocco di caratteri.

35
00:01:32,110 --> 00:01:36,680
>> Ma il problema è che s scansione, scopo nella
vita, viene dato un indirizzo e dato

36
00:01:36,680 --> 00:01:40,960
un codice di formato, come% s, leggere
una stringa nel pezzo di

37
00:01:40,960 --> 00:01:42,330
memoria a quell'indirizzo.

38
00:01:42,330 --> 00:01:46,040
Ma perché non c'è segno di uguale prima
che virgola al primo

39
00:01:46,040 --> 00:01:49,310
riga di codice, perché non lo facciamo davvero
allocare qualsiasi memoria con

40
00:01:49,310 --> 00:01:53,020
malloc, perché in realtà non
allocare una matrice di una certa dimensione, tutti

41
00:01:53,020 --> 00:01:57,620
si sta facendo sta leggendo l'utente del
input da tastiera in qualche completo

42
00:01:57,620 --> 00:02:00,490
valore di immondizia, che
è in s per impostazione predefinita.

43
00:02:00,490 --> 00:02:04,480
Quindi le probabilità sono che stai andando a segmentation fault se
che l'indirizzo non è proprio così capita

44
00:02:04,480 --> 00:02:08,009
ad essere un valore che è possibile,
infatti, scrivere.

45
00:02:08,009 --> 00:02:10,889
Così male non assegnare
la memoria lì.

46
00:02:10,889 --> 00:02:13,150
>> Così in questione 1, abbiamo chiesto,
supponiamo che la versione 2 è

47
00:02:13,150 --> 00:02:14,230
compilato ed eseguito.

48
00:02:14,230 --> 00:02:15,900
Perché potrebbe questo programma segmentation fault?

49
00:02:15,900 --> 00:02:17,990
Quindi questo è meno bacato.

50
00:02:17,990 --> 00:02:21,470
E c'è davvero una sola
modo ovvio dove è possibile

51
00:02:21,470 --> 00:02:22,810
innescare un segfault qui.

52
00:02:22,810 --> 00:02:23,730
E questo è tematico.

53
00:02:23,730 --> 00:02:28,180
Ogni volta che stiamo utilizzando c in memoria, cosa
si potrebbe fare per indurre un segfault

54
00:02:28,180 --> 00:02:30,718
con la versione 2?

55
00:02:30,718 --> 00:02:35,560
>> AUDIENCE: Se si utilizza quell'ingresso in
una stringa che è più lungo di 49

56
00:02:35,560 --> 00:02:35,975
caratteri.

57
00:02:35,975 --> 00:02:37,260
>> DAVID J. MALAN: Esattamente.

58
00:02:37,260 --> 00:02:41,420
Ogni volta che vedi qualcosa di lunghezza fissa
quando si tratta di un array, il vostro

59
00:02:41,420 --> 00:02:44,650
radar deve spegnersi, che questo potrebbe essere
problematico se non stai controllando la

60
00:02:44,650 --> 00:02:45,810
confini di una matrice.

61
00:02:45,810 --> 00:02:46,650
E questo è il problema qui.

62
00:02:46,650 --> 00:02:47,910
Stiamo ancora utilizzando scanf.

63
00:02:47,910 --> 00:02:52,200
Stiamo ancora utilizzando% s, il che significa provare
per leggere una stringa dall'utente.

64
00:02:52,200 --> 00:02:56,300
Che sta per essere letto in s, che,
a questo punto, è di fatto la

65
00:02:56,300 --> 00:02:58,570
indirizzo di un pezzo di memoria
o è equivalente.

66
00:02:58,570 --> 00:03:02,080
E 'il nome di un array
di caratteri di memoria.

67
00:03:02,080 --> 00:03:07,610
>> Ma esattamente che, se si legge una stringa
che è più lungo di 49 caratteri, 49

68
00:03:07,610 --> 00:03:10,440
perché avete bisogno di spazio per la barra rovesciata
0, si sta andando a traboccare

69
00:03:10,440 --> 00:03:11,390
buffer.

70
00:03:11,390 --> 00:03:16,410
E si potrebbe avere fortuna ed essere in grado di
scrivere un personaggio 51a, 52a, 53a.

71
00:03:16,410 --> 00:03:18,560
Ma a un certo punto, il sistema operativo
sta per dire, no.

72
00:03:18,560 --> 00:03:21,270
Questo sicuramente non è la memoria
si è permesso di toccare.

73
00:03:21,270 --> 00:03:23,380
E il programma sta per segmentation fault.

74
00:03:23,380 --> 00:03:26,650
>> Quindi c'è, l'euristica dovrebbero essere qualsiasi
il tempo che hai a lunghezza fissa, è necessario

75
00:03:26,650 --> 00:03:30,150
per assicurarsi che si sta controllando la lunghezza
di qualunque cosa si sta cercando

76
00:03:30,150 --> 00:03:31,090
leggere in esso.

77
00:03:31,090 --> 00:03:35,110
>> PUBBLICO: Quindi, per risolvere questo, si potrebbe
hanno avuto un controllo realmente dichiarazione

78
00:03:35,110 --> 00:03:37,140
è la lunghezza maggiore
o minore?

79
00:03:37,140 --> 00:03:37,730
>> DAVID J. MALAN: Assolutamente.

80
00:03:37,730 --> 00:03:41,706
Devi solo una condizione
che dice, se -

81
00:03:41,706 --> 00:03:46,080
o meglio, non necessariamente sa
in anticipo quanti caratteri l'

82
00:03:46,080 --> 00:03:49,060
utente sta per digitare, perché
avete pollo e l'uovo.

83
00:03:49,060 --> 00:03:51,860
Non prima di aver letto che con scanf
si può capire quanto tempo è.

84
00:03:51,860 --> 00:03:54,500
Ma a quel punto, è troppo tardi,
perché avete già letto in

85
00:03:54,500 --> 00:03:55,710
qualche blocco di memoria.

86
00:03:55,710 --> 00:03:59,590
Così come un a parte, le evita biblioteca CS50
questo problema del tutto, richiamo

87
00:03:59,590 --> 00:04:01,060
utilizzando fgetc.

88
00:04:01,060 --> 00:04:05,390
E legge un carattere per volta,
punta toeing lungo, sapendo che si

89
00:04:05,390 --> 00:04:08,060
non può straripare un personaggio se
si legge una alla volta.

90
00:04:08,060 --> 00:04:11,580
>> Il problema è con richiamo GetString è
che dobbiamo costantemente ri-size

91
00:04:11,580 --> 00:04:13,590
che pezzo di memoria, che
è solo un dolore.

92
00:04:13,590 --> 00:04:15,310
E 'un sacco di linee di
il codice per farlo.

93
00:04:15,310 --> 00:04:18,779
Così un altro approccio sarebbe quello di
effettivamente utilizzare un cugino, così

94
00:04:18,779 --> 00:04:19,790
di parlare, di scanf.

95
00:04:19,790 --> 00:04:22,820
Ci sono varianti di un sacco di questi
funzioni che effettivamente controllano la

96
00:04:22,820 --> 00:04:25,870
lunghezza di quanti caratteri
si potrebbe leggere al massimo.

97
00:04:25,870 --> 00:04:29,430
E si potrebbe specificare, non leggere
più di 50 caratteri.

98
00:04:29,430 --> 00:04:34,110
Quindi, che sarebbe un altro approccio, ma
meno accomodante di ingressi più grandi.

99
00:04:34,110 --> 00:04:37,040
>> Quindi, domanda 2 chiede, supporre che la versione
3 è compilato ed eseguito.

100
00:04:37,040 --> 00:04:39,960
Perché potrebbe quel programma segmentation fault?

101
00:04:39,960 --> 00:04:42,650
Così questo è in realtà la stessa
rispondere, anche se

102
00:04:42,650 --> 00:04:43,590
sembra un po 'più elaborato.

103
00:04:43,590 --> 00:04:46,440
Stiamo usando malloc, che si sente come
stiamo dando noi stessi più opzioni.

104
00:04:46,440 --> 00:04:48,030
E poi stiamo liberando che
memoria alla fine.

105
00:04:48,030 --> 00:04:49,580
E 'ancora solo 50 byte di memoria.

106
00:04:49,580 --> 00:04:53,620
Così potremmo ancora provare a leggere
in 51, 52, 1.000 byte.

107
00:04:53,620 --> 00:04:55,830
E 'intenzione di segmentation fault per
esattamente lo stesso motivo.

108
00:04:55,830 --> 00:04:57,530
>> Ma c'è un'altra ragione.

109
00:04:57,530 --> 00:05:03,890
Che altro potrebbe malloc ritorno oltre
l'indirizzo di un pezzo di memoria?

110
00:05:03,890 --> 00:05:04,920
Si potrebbe restituire null.

111
00:05:04,920 --> 00:05:07,560
E perché non stiamo controllando
che, potremmo fare qualcosa

112
00:05:07,560 --> 00:05:11,350
stupido per un altro motivo, che è quella
potremmo essere dicendo scanf, leggiamo

113
00:05:11,350 --> 00:05:16,050
input dell'utente dalla tastiera
in posizione 0, AKA null.

114
00:05:16,050 --> 00:05:18,890
E anche questo, sarà sicuramente
innescare un segfault.

115
00:05:18,890 --> 00:05:21,590
Così, per lo scopo del quiz, avremmo
hanno accettato uno di questi come

116
00:05:21,590 --> 00:05:22,740
motivo valido.

117
00:05:22,740 --> 00:05:23,420
Uno è identico.

118
00:05:23,420 --> 00:05:25,720
Uno è un po 'più sfumata.

119
00:05:25,720 --> 00:05:28,975
>> Infine, per quanto riguarda il programma di
uso della memoria, come fare la versione 2 e

120
00:05:28,975 --> 00:05:30,350
versione 3 differiscono?

121
00:05:30,350 --> 00:05:35,070
Quindi, per quello che vale, abbiamo visto un
fornitura apparentemente infinita di possibili

122
00:05:35,070 --> 00:05:35,770
risposte a questo.

123
00:05:35,770 --> 00:05:39,300
E tra le risposte della gente, quello che siamo stati
sperando, ma abbiamo accettato altri

124
00:05:39,300 --> 00:05:42,250
cose, era un po 'menzione del
fatto che la versione 2 utilizza

125
00:05:42,250 --> 00:05:44,560
il cosiddetto stack.

126
00:05:44,560 --> 00:05:46,710
La versione 3 utilizza l'heap.

127
00:05:46,710 --> 00:05:50,060
E funzionale, questo in realtà non
fare tutto che molta differenza.

128
00:05:50,060 --> 00:05:54,040
Alla fine della giornata, siamo ancora
solo ottenere 50 byte di memoria.

129
00:05:54,040 --> 00:05:56,640
>> Ma quella era una delle possibili risposte
che stavamo guardando.

130
00:05:56,640 --> 00:05:59,730
Ma vedrete, come si ottiene il quiz
indietro dal TF, che abbiamo fatto

131
00:05:59,730 --> 00:06:04,330
accettare altre discussioni della loro
usi disparati della memoria pure.

132
00:06:04,330 --> 00:06:08,600
Ma stack e heap sarebbe stato
una risposta facile andare con.

133
00:06:08,600 --> 00:06:11,150
Tutte le domande?

134
00:06:11,150 --> 00:06:12,400
Vi do Rob.

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

136
00:06:18,360 --> 00:06:20,210
>> ROB BOWDEN: Allora problema 4.

137
00:06:20,210 --> 00:06:21,985
Questo è quello in cui si doveva occupare
del numero di byte su tutti

138
00:06:21,985 --> 00:06:23,460
questi diversi tipi utilizzati.

139
00:06:23,460 --> 00:06:24,830
Quindi prima cosa che vediamo.

140
00:06:24,830 --> 00:06:27,930
Assumere una architettura a 32 bit,
come questo apparecchio CS50.

141
00:06:27,930 --> 00:06:33,530
Così una delle cose fondamentali su
Architetture a 32 bit, che ci dice

142
00:06:33,530 --> 00:06:37,490
esattamente quanto è grande un puntatore sta
essere nell'architettura.

143
00:06:37,490 --> 00:06:43,020
>> Così subito, sappiamo che qualsiasi puntatore
tipo è a 32-bit o 4 byte.

144
00:06:43,020 --> 00:06:46,010
Così, guardando a questo tavolo, un
nodo * è un tipo di puntatore.

145
00:06:46,010 --> 00:06:47,250
Che sta per essere 4 byte.

146
00:06:47,250 --> 00:06:51,640
Struct node *, che è letteralmente
identico al nodo stella.

147
00:06:51,640 --> 00:06:53,590
E così che sta per essere 4 byte.

148
00:06:53,590 --> 00:06:58,270
String, così non sembra un
puntatore ancora, ma il typedef, un

149
00:06:58,270 --> 00:07:01,590
stringa è solo un char *, che
è un tipo di puntatore.

150
00:07:01,590 --> 00:07:03,550
In modo che sara 'di 4 byte.

151
00:07:03,550 --> 00:07:06,150
>> Quindi questi tre sono tutti e 4 byte.

152
00:07:06,150 --> 00:07:09,350
Ora, il nodo e studente sono
un po 'più complicato.

153
00:07:09,350 --> 00:07:15,160
Quindi, guardando al nodo e studente, vediamo
nodo come un intero e un puntatore.

154
00:07:15,160 --> 00:07:18,050
Ed studente è due puntatori
all'interno di esso.

155
00:07:18,050 --> 00:07:23,340
Quindi, almeno per nostro caso, il modo
che si finisce per calcolare la dimensione del

156
00:07:23,340 --> 00:07:27,020
questa struttura è solo aggiungere a tutto
che è all'interno della struttura.

157
00:07:27,020 --> 00:07:30,690
>> Così per il nodo, abbiamo un numero intero,
che è 4 byte.

158
00:07:30,690 --> 00:07:32,830
Abbiamo un puntatore, che è 4 byte.

159
00:07:32,830 --> 00:07:35,820
E così un nodo sta andando
a prendere 8 byte.

160
00:07:35,820 --> 00:07:39,490
E allo stesso modo per gli studenti, abbiamo una
puntatore che è 4 byte e un altro

161
00:07:39,490 --> 00:07:40,770
puntatore che è 4 byte.

162
00:07:40,770 --> 00:07:43,180
Quindi, che sta andando a finire
per essere 8 byte.

163
00:07:43,180 --> 00:07:45,480
Così nodo e studente sono 8 byte.

164
00:07:45,480 --> 00:07:48,950
E questi tre sono tutti e 4 byte.

165
00:07:48,950 --> 00:07:50,240
Domande su questo?

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

167
00:07:54,640 --> 00:07:54,990
Sì.

168
00:07:54,990 --> 00:07:58,413
>> PUBBLICO: E 'stato un 64-bit
architettura, vorrei che

169
00:07:58,413 --> 00:07:59,880
raddoppiare tutti loro?

170
00:07:59,880 --> 00:08:01,790
>> ROB BOWDEN: Non sarebbe
raddoppiare tutti.

171
00:08:01,790 --> 00:08:05,830
Così architettura a 64 bit, che, di nuovo,
modifiche cosa fondamentale che un

172
00:08:05,830 --> 00:08:08,910
puntatore è ora 64 bit.

173
00:08:08,910 --> 00:08:09,290
Già.

174
00:08:09,290 --> 00:08:10,930
Quindi un puntatore è di 8 byte.

175
00:08:10,930 --> 00:08:15,420
Quindi questi che erano 4 byte
stanno per essere 8 byte.

176
00:08:15,420 --> 00:08:18,617
Uno studente, che era due puntatori,
bene, ora sta andando a

177
00:08:18,617 --> 00:08:19,800
essere di 8 byte, 8 byte.

178
00:08:19,800 --> 00:08:21,980
Sta andando a fare 16 byte.

179
00:08:21,980 --> 00:08:25,710
>> Ma un nodo è ancora 4 byte.

180
00:08:25,710 --> 00:08:27,800
Quindi questo puntatore sta andando
essere 8 byte.

181
00:08:27,800 --> 00:08:28,930
Questo è 4 byte.

182
00:08:28,930 --> 00:08:30,870
Quindi un nodo è solo andare
essere di 12 byte.

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

184
00:08:36,309 --> 00:08:39,280
Tutte le altre domande su quello?

185
00:08:39,280 --> 00:08:44,500
Quindi il prossimo, questi sono
i codici di stato HTTP.

186
00:08:44,500 --> 00:08:48,000
E dovessi descrivere circostanze
in base al quale questi possono

187
00:08:48,000 --> 00:08:49,810
essere rispedito al mittente.

188
00:08:49,810 --> 00:08:56,730
un problema che ho sentito alcuni studenti
avere è che hanno cercato di fare il

189
00:08:56,730 --> 00:08:58,950
errori siano sull'estremità del client.

190
00:08:58,950 --> 00:09:02,320
Così, quando cerchiamo di fare la richiesta
al server, qualcosa va

191
00:09:02,320 --> 00:09:03,820
sbagliato da parte nostra.

192
00:09:03,820 --> 00:09:07,660
Ma in generale, i codici sono:
essere restituito dal server.

193
00:09:07,660 --> 00:09:11,720
Quindi vogliamo capire cosa sta succedendo
giusto o sbagliato sul server che

194
00:09:11,720 --> 00:09:14,280
fa sì che queste cose devono essere restituiti.

195
00:09:14,280 --> 00:09:18,670
Allora perché potrebbe un server restituisce
codice di stato 200?

196
00:09:18,670 --> 00:09:19,920
Qualche idea?

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

198
00:09:23,360 --> 00:09:23,730
>> Già.

199
00:09:23,730 --> 00:09:27,850
Quindi qualcosa su successo
la richiesta ha attraversato.

200
00:09:27,850 --> 00:09:30,260
E sono in grado di tornare
tutto ciò che hai chiesto.

201
00:09:30,260 --> 00:09:32,240
Così tutto è andato bene.

202
00:09:32,240 --> 00:09:35,662
Che cosa circa 302 trovati?

203
00:09:35,662 --> 00:09:36,618
Già.

204
00:09:36,618 --> 00:09:39,008
>> PUBBLICO: Il server era alla ricerca
per quello che hai richiesto.

205
00:09:39,008 --> 00:09:40,442
Ma non poteva trovarlo.

206
00:09:40,442 --> 00:09:42,850
Quindi c'è un errore.

207
00:09:42,850 --> 00:09:47,720
>> ROB BOWDEN: Quindi il server era
ricerca di ciò che si voleva.

208
00:09:47,720 --> 00:09:51,682
Quindi basta guardare qui, 302 trovato,
è stato in grado di trovarlo.

209
00:09:51,682 --> 00:09:53,035
>> PUBBLICO: Mi dispiace.

210
00:09:53,035 --> 00:09:54,388
Trovato significa che hanno fatto trovare.

211
00:09:54,388 --> 00:09:55,638
Scusi.

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

213
00:09:58,120 --> 00:10:00,160
>> ROB BOWDEN: Quindi 302 found.

214
00:10:00,160 --> 00:10:02,350
Il server è in grado di trovare
quello che volevi.

215
00:10:02,350 --> 00:10:04,640
>> AUDIENCE: Ma non è visualizzarlo?

216
00:10:04,640 --> 00:10:08,180
>> ROB BOWDEN: La differenza tra
questa 302 e 200 è che

217
00:10:08,180 --> 00:10:09,280
sa ciò che si vuole.

218
00:10:09,280 --> 00:10:12,000
Ma non è esattamente dove
si voleva chiedere.

219
00:10:12,000 --> 00:10:14,580
Quindi 302 è un redirect tipico.

220
00:10:14,580 --> 00:10:16,510
Quindi hai richiesto una pagina.

221
00:10:16,510 --> 00:10:19,590
Si sa, oh, voglio
per restituire questo.

222
00:10:19,590 --> 00:10:21,070
Ma questo è un URL differente.

223
00:10:21,070 --> 00:10:23,534
Così hey, si vuole realmente questo.

224
00:10:23,534 --> 00:10:26,950
>> DAVID J. MALAN: E 'un pezzo che ha detto
che abbiamo dato voi ragazzi un redirect

225
00:10:26,950 --> 00:10:30,830
funzione che utilizza la funzione header
che, a sua volta, stampati posizione,

226
00:10:30,830 --> 00:10:34,110
colon, e poi l'URL a cui
si vuole rifiutare l'utente.

227
00:10:34,110 --> 00:10:37,480
Anche se non hai visto 302
esplicitamente lì, questo è ciò che PHP

228
00:10:37,480 --> 00:10:41,550
sarebbe magicamente inserire come intestazione
dicendo esattamente quello che ha detto Rob lì -

229
00:10:41,550 --> 00:10:41,930
trovato.

230
00:10:41,930 --> 00:10:43,180
Ma andate qui invece.

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

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

233
00:10:46,160 --> 00:10:47,630
Così che cosa circa 403 proibito?

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

235
00:10:52,240 --> 00:10:57,120
>> PUBBLICO: Penso che sia che il server
è fondamentalmente dicendo che il client

236
00:10:57,120 --> 00:10:59,970
non può accedere alla home page.

237
00:10:59,970 --> 00:11:03,260
>> ROB BOWDEN: Quindi sì.

238
00:11:03,260 --> 00:11:07,670
Bene, la risposta tipica eravamo
mi aspettavo qualcosa di simile, i file

239
00:11:07,670 --> 00:11:08,920
non sono chmodded appropriato.

240
00:11:08,920 --> 00:11:11,590
Questo è probabilmente in quali circostanze
li hai visti.

241
00:11:11,590 --> 00:11:18,920
Ma c'è una ragione che il cliente
potrebbe essere colpa qui.

242
00:11:18,920 --> 00:11:20,440
In realtà c'è un altro codice di stato -

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

244
00:11:21,210 --> 00:11:22,820
Quindi questi sono molto simili.

245
00:11:22,820 --> 00:11:24,590
>> 401 non è autorizzato.

246
00:11:24,590 --> 00:11:26,130
E 403 è vietato.

247
00:11:26,130 --> 00:11:31,890
E così non autorizzata voi in esclusiva
ottenere se non sei loggato

248
00:11:31,890 --> 00:11:34,520
Ma login potrebbe significare
che si è autorizzati.

249
00:11:34,520 --> 00:11:37,930
Ma se siete già connessi ed hai
ancora non hanno il permesso, poi

250
00:11:37,930 --> 00:11:40,140
è anche possibile ottenere proibito.

251
00:11:40,140 --> 00:11:45,320
Quindi, se siete registrati e non hanno
permesso, proibito è anche

252
00:11:45,320 --> 00:11:47,164
qualcosa che si può ottenere.

253
00:11:47,164 --> 00:11:48,900
>> David J. MALAN: E il meccanismo mediante
che questi problemi sono solitamente

254
00:11:48,900 --> 00:11:53,100
risolto sul server è
con quale comando?

255
00:11:53,100 --> 00:11:57,700
Chmod, se lo è, infatti, un permesso
rilasciare il file o la directory.

256
00:11:57,700 --> 00:11:59,220
>> ROB BOWDEN: Quindi 404 non trovato.

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

258
00:12:03,100 --> 00:12:03,470
Già.

259
00:12:03,470 --> 00:12:10,150
Quindi, a differenza 302 dove non era esattamente
dove si sta chiedendo, ma sa che cosa

260
00:12:10,150 --> 00:12:12,710
volete, questo, che ha appena
idea di ciò che si desidera.

261
00:12:12,710 --> 00:12:15,648
E non si sta chiedendo
qualcosa di valido.

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

263
00:12:18,580 --> 00:12:22,310
418 Sono una teiera e poi
500 server interno.

264
00:12:22,310 --> 00:12:24,870
Allora perché potreste ottenere che?

265
00:12:24,870 --> 00:12:26,120
>> Così segmentation fault -

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

267
00:12:28,760 --> 00:12:30,640
Io in realtà non so la classificazione
standard per questo.

268
00:12:30,640 --> 00:12:34,850
Ma se il vostro codice PHP aveva qualcosa
di male, in teoria, potrebbe

269
00:12:34,850 --> 00:12:39,650
effettivamente segfault, nel qual caso, questa
Errore interno del server 500, qualcosa

270
00:12:39,650 --> 00:12:41,400
è sbagliato con il server di
configurazione.

271
00:12:41,400 --> 00:12:44,320
Oppure c'è un errore di sintassi
nel codice PHP.

272
00:12:44,320 --> 00:12:46,095
O qualcosa di brutto sta accadendo.

273
00:12:46,095 --> 00:12:48,320
>> DAVID J. MALAN: abbiamo visto segfault
tra le risposte poche persone.

274
00:12:48,320 --> 00:12:49,490
E tecnicamente, potrebbe accadere.

275
00:12:49,490 --> 00:12:53,820
Ma questo sarebbe un PHP, il programma
scritto da altre persone, in realtà

276
00:12:53,820 --> 00:12:57,790
segfaulted, che solo se queste persone
incasinato e scrisse il codice buggy in

277
00:12:57,790 --> 00:13:00,680
il loro interprete sarebbe
PHP stesso segmentation fault.

278
00:13:00,680 --> 00:13:06,460
Così, anche se 500 è come un segfault
nello spirito, è quasi sempre il

279
00:13:06,460 --> 00:13:10,490
risultato di un problema di file di configurazione
con il server web o, come ha detto Rob,

280
00:13:10,490 --> 00:13:13,200
un errore di sintassi, come voi
non chiudere un preventivo.

281
00:13:13,200 --> 00:13:16,180
Oppure hai perso un punto e virgola da qualche parte.

282
00:13:16,180 --> 00:13:23,677
>> AUDIENCE: Così, per la pset Shuttle, ho
pensare che quando l'ho fatto una volta ho cliccato l'

283
00:13:23,677 --> 00:13:26,300
browser, ma nulla si avvicinò,
quello che chiamavano pagina bianca.

284
00:13:26,300 --> 00:13:28,056
Ma è stato a causa del codice.

285
00:13:28,056 --> 00:13:29,440
Credo che sia stato JavaScript, giusto?

286
00:13:29,440 --> 00:13:29,770
>> ROB BOWDEN: Già.

287
00:13:29,770 --> 00:13:31,180
>> AUDIENCE: Vorrei che errore
ancora venire?

288
00:13:31,180 --> 00:13:34,290
>> ROB BOWDEN: Quindi non avreste ottenuto
questo errore perché tutto

289
00:13:34,290 --> 00:13:36,930
dal punto di vista del server web
era completamente soddisfacente.

290
00:13:36,930 --> 00:13:39,090
Ma che hai richiesto index.html.

291
00:13:39,090 --> 00:13:42,000
È richiesto shuttle.js
e service.js.

292
00:13:42,000 --> 00:13:44,580
Ed è stato in grado di tornare con successo
a voi tutte queste cose -

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

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

295
00:13:45,680 --> 00:13:49,330
E 'solo quando il browser tenta di
interpretare il codice JavaScript che

296
00:13:49,330 --> 00:13:51,370
E 'come, aspetta, questo non è
errore JavaScript valida.

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

298
00:13:55,720 --> 00:13:58,210
Tutte le altre domande?

299
00:13:58,210 --> 00:14:00,750
Bene.

300
00:14:00,750 --> 00:14:04,120
>> DAVID J. MALAN: Così la prossima
up era il numero 11.

301
00:14:04,120 --> 00:14:07,610
E 11 è stata la più spaventosa
per un sacco di gente.

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

303
00:14:14,620 --> 00:14:18,570
Quindi la cosa più importante da notare qui
era che questo stato, infatti, sulla

304
00:14:18,570 --> 00:14:19,840
una lista doppiamente concatenata.

305
00:14:19,840 --> 00:14:23,160
Ma questa non era la stessa dello scorso anno
problema lista doppiamente concatenata,

306
00:14:23,160 --> 00:14:27,170
che non ti ha dato l'avvertenza che
l'elenco potrebbe, infatti, essere differenziati.

307
00:14:27,170 --> 00:14:29,640
>> Quindi il fatto che l'elenco era indifferenziati
e il fatto che tale parola era

308
00:14:29,640 --> 00:14:32,930
Sottolineato c'era lo scopo di trasmettere
che questo è in realtà una semplificazione

309
00:14:32,930 --> 00:14:35,430
di quello che altrimenti sarebbe stato
un problema più impegnativo

310
00:14:35,430 --> 00:14:36,600
e uno più lungo.

311
00:14:36,600 --> 00:14:40,760
Quindi, un errore comune era quello di aver messo
la soluzione dello scorso anno sul vostro one

312
00:14:40,760 --> 00:14:45,580
pager e poi basta copiare ciecamente che
giù come la risposta, che è il diritto

313
00:14:45,580 --> 00:14:48,520
rispondere ad una domanda diversa
simile nello spirito.

314
00:14:48,520 --> 00:14:51,340
Ma le sottigliezze qui
sono stati i seguenti.

315
00:14:51,340 --> 00:14:55,200
>> Così uno, abbiamo un nodo dichiarata e
definito nel modo usuale qui.

316
00:14:55,200 --> 00:14:59,230
Poi abbiamo definito la lista di essere globale
puntatore inizializzato a null.

317
00:14:59,230 --> 00:15:02,150
Poi a quanto pare, ci sono due funzioni
abbiamo prototipi di qui, inserto

318
00:15:02,150 --> 00:15:03,240
e rimuovere.

319
00:15:03,240 --> 00:15:06,600
E poi abbiamo un po 'di codice di esempio qui
di fare un gruppo di inserzioni.

320
00:15:06,600 --> 00:15:09,930
E allora vi chiediamo di completare l'
attuazione dell'inserto seguito in tale

321
00:15:09,930 --> 00:15:14,380
un modo che inserisce n nella lista
in tempo costante, anche sottolineato,

322
00:15:14,380 --> 00:15:15,730
anche se già presente.

323
00:15:15,730 --> 00:15:20,600
>> Così la bellezza di poter inserire
in tempo costante è che implica

324
00:15:20,600 --> 00:15:23,060
che si deve inserire
il nuovo nodo dove?

325
00:15:23,060 --> 00:15:23,690
Nella parte anteriore.

326
00:15:23,690 --> 00:15:27,760
Quindi elimina, per fortuna, almeno
uno dei casi che richiedevano

327
00:15:27,760 --> 00:15:30,520
ancor più righe di codice, come ha fatto
l'anno scorso e anche in classe quando abbiamo

328
00:15:30,520 --> 00:15:34,040
parlato attraverso questo genere di cose
con gli esseri umani e con qualche

329
00:15:34,040 --> 00:15:35,250
verbale pseudo codice.

330
00:15:35,250 --> 00:15:39,190
Così nella soluzione qui, saltiamo sopra
a che solo per avere una visuale sulla

331
00:15:39,190 --> 00:15:40,480
schermo.

332
00:15:40,480 --> 00:15:42,230
>> Si noti che stiamo facendo quanto segue.

333
00:15:42,230 --> 00:15:45,140
E anche notare l'altra semplificazione
era che anche se è

334
00:15:45,140 --> 00:15:48,280
già presente, quindi questo significa che anche se
il numero è già lì, si può

335
00:15:48,280 --> 00:15:50,280
ciecamente inserire un altro
copia.

336
00:15:50,280 --> 00:15:52,560
E che, troppo, voleva essere un
semplificazione, in modo che si potrebbe

337
00:15:52,560 --> 00:15:54,940
fuoco, in realtà, alcuni dei più
parte intellettualmente interessante e

338
00:15:54,940 --> 00:15:58,090
non solo qualche ulteriore controllo degli errori
dato il tempo limitato.

339
00:15:58,090 --> 00:16:02,880
>> Quindi, in questa soluzione di esempio, destiniamo
un puntatore sulla mano sinistra

340
00:16:02,880 --> 00:16:04,510
lato qui per un nodo.

341
00:16:04,510 --> 00:16:07,190
Ora, realizzare tale puntatore, come
Rob ha detto, è solo 32 bit.

342
00:16:07,190 --> 00:16:09,060
E in realtà non contiene
un indirizzo fino a che

343
00:16:09,060 --> 00:16:09,970
assegnare l'indirizzo.

344
00:16:09,970 --> 00:16:13,220
E lo facciamo sulla destra
lato via malloc.

345
00:16:13,220 --> 00:16:16,550
Come un buon cittadino, controlliamo che
malloc non è, infatti, nullo, in modo che

346
00:16:16,550 --> 00:16:18,690
non creiamo accidentalmente
un segfault qui.

347
00:16:18,690 --> 00:16:22,840
E ogni volta che si utilizza malloc nella vita,
dovrebbe essere controllo per nulla, per timore

348
00:16:22,840 --> 00:16:24,090
avete un bug sottile.

349
00:16:24,090 --> 00:16:28,460
>> Poi si inizializza che nulla da
l'assegnazione di n e precedente e successivo.

350
00:16:28,460 --> 00:16:32,450
E in questo caso qui, ho inizializzato
precedente nullo, perché questo nuovo

351
00:16:32,450 --> 00:16:34,780
nodo sta per essere il nuovo
inizio della mia lista.

352
00:16:34,780 --> 00:16:37,050
Quindi ci sara '
niente prima.

353
00:16:37,050 --> 00:16:42,010
E voglio aggiungere essenzialmente
elenco esistente al nuovo nodo

354
00:16:42,010 --> 00:16:44,700
impostazione accanto pari a lista stessa.

355
00:16:44,700 --> 00:16:47,120
Ma non sono solo ancora finito.

356
00:16:47,120 --> 00:16:51,780
Quindi, se la lista stessa esisteva già,
e c'era almeno un nodo

357
00:16:51,780 --> 00:16:57,070
già in atto, se questa è la lista
qui e mi inserisco un nuovo nodo qui, io

358
00:16:57,070 --> 00:17:01,840
necessario assicurarsi che il mio ex nodo
punti indietro al mio nuovo nodo,

359
00:17:01,840 --> 00:17:04,260
perché questo è, di nuovo,
una lista doppiamente concatenata.

360
00:17:04,260 --> 00:17:05,460
>> Quindi facciamo un controllo di integrità.

361
00:17:05,460 --> 00:17:10,109
Se la lista non è nullo, se c'è già
uno o più nodi là, allora

362
00:17:10,109 --> 00:17:12,470
Aggiungo che torna riferimento per così dire.

363
00:17:12,470 --> 00:17:15,420
E poi l'ultima cosa di cui abbiamo bisogno
di fare è in realtà aggiornare il mondiale

364
00:17:15,420 --> 00:17:20,329
elenco variabile stessa per puntare
a quel nuovo nodo.

365
00:17:20,329 --> 00:17:21,790
Già.

366
00:17:21,790 --> 00:17:26,579
>> AUDIENCE: Nel puntatore a freccia
[Incomprensibile] è uguale a null, fa che

367
00:17:26,579 --> 00:17:30,420
trattare con l'elenco perché
l'elenco è nullo?

368
00:17:30,420 --> 00:17:30,596
>> DAVID J. MALAN: Nope.

369
00:17:30,596 --> 00:17:34,500
Questo è semplicemente me essere in modo proattivo
attenzione, in quanto se questo è il mio

370
00:17:34,500 --> 00:17:38,730
lista originale con forse qualche più nodi
qui e sto inserendo il mio

371
00:17:38,730 --> 00:17:42,380
nuovo nodo qui, ci sta andando
essere niente qui.

372
00:17:42,380 --> 00:17:44,720
E voglio cogliere questa idea
impostando precedente

373
00:17:44,720 --> 00:17:47,740
nullo sul nuovo nodo.

374
00:17:47,740 --> 00:17:51,410
E presumibilmente, se il mio codice è corretto
e non c'è altro modo per inserire

375
00:17:51,410 --> 00:17:54,970
nodi diversi da questa funzione,
presumibilmente, anche se la lista ha già

376
00:17:54,970 --> 00:18:00,090
uno o più nodi in esso, presumibilmente la
elenco, il primo nodo, avrebbe un

377
00:18:00,090 --> 00:18:02,750
precedente puntatore nullo se stesso.

378
00:18:02,750 --> 00:18:03,550
>> PUBBLICO: E solo un follow-up.

379
00:18:03,550 --> 00:18:08,139
La ragione per cui si mette puntatore prossimi uguali
lista è che stai facendo il puntatore

380
00:18:08,139 --> 00:18:13,579
prima lista in che sta puntando
alla prossima, credo -

381
00:18:13,579 --> 00:18:14,980
Non. -

382
00:18:14,980 --> 00:18:15,450
basta liste?

383
00:18:15,450 --> 00:18:16,400
>> DAVID J. MALAN: Esattamente.

384
00:18:16,400 --> 00:18:19,400
E quindi cerchiamo di realtà consideriamo due casi
qui realmente, anche se la

385
00:18:19,400 --> 00:18:22,070
fine noi li consideriamo non è
abbastanza lo stesso codice.

386
00:18:22,070 --> 00:18:26,250
Ma a un livello elevato, se questo rappresenta
lista e questo è un 32-bit

387
00:18:26,250 --> 00:18:29,560
puntatore, il caso più semplice è
che ciò è null di default.

388
00:18:29,560 --> 00:18:33,010
E supponiamo che io voglio inserire il
il numero 50 è il primo numero.

389
00:18:33,010 --> 00:18:37,640
Quindi ho intenzione di andare avanti e allocare
un nodo, che sta per contenere

390
00:18:37,640 --> 00:18:38,770
tre campi -

391
00:18:38,770 --> 00:18:42,070
n, precedente e successivo.

392
00:18:42,070 --> 00:18:44,580
>> Ho intenzione di mettere il numero 50
qui, perché questa sarà la n.

393
00:18:44,580 --> 00:18:46,130
Questo sarà il prossimo.

394
00:18:46,130 --> 00:18:48,530
E questo sarà precedente.

395
00:18:48,530 --> 00:18:50,910
E così quello che faccio in questo caso?

396
00:18:50,910 --> 00:18:53,900
Beh, ho appena fatto la linea 1 qui.

397
00:18:53,900 --> 00:18:55,400
Pointer n diventa n.

398
00:18:55,400 --> 00:18:57,740
Sto quindi dicendo precedente
dovrebbe ottenere nulla.

399
00:18:57,740 --> 00:18:59,470
Quindi questo sarà nullo.

400
00:18:59,470 --> 00:19:01,365
Allora io vado a dire dopo
sta per ottenere l'elenco.

401
00:19:01,365 --> 00:19:05,150
>> E questo funziona bene.

402
00:19:05,150 --> 00:19:06,500
Questo è nullo.

403
00:19:06,500 --> 00:19:10,620
E così sto dicendo, il nuovo nodo del prossimo
campo dovrebbe ottenere tutto ciò che questo è.

404
00:19:10,620 --> 00:19:12,570
Così che mette un altro nullo lì.

405
00:19:12,570 --> 00:19:14,510
E poi l'ultima cosa
Che faccio è controllare qui.

406
00:19:14,510 --> 00:19:17,870
Se la lista non è uguale a null, ma
è pari a zero, così saltiamo che

407
00:19:17,870 --> 00:19:18,470
tutto.

408
00:19:18,470 --> 00:19:23,520
E così tutto quello che faccio prossimo è la lista ottiene
puntatore, che si traduce pittoricamente in

409
00:19:23,520 --> 00:19:25,570
un quadro del genere.

410
00:19:25,570 --> 00:19:26,620
Ecco, questo è uno scenario.

411
00:19:26,620 --> 00:19:30,490
>> E quello che stavate chiedendo circa
in particolare è una situazione come questa,

412
00:19:30,490 --> 00:19:33,190
dove abbiamo già una lista di un nodo.

413
00:19:33,190 --> 00:19:36,240
E se torno in originale
dichiarazione del problema, la prossima faremo

414
00:19:36,240 --> 00:19:39,320
inserisci esempio è 34, solo per
il bene della discussione.

415
00:19:39,320 --> 00:19:46,210
Quindi ho intenzione di appena convenientemente
disegnare che nel corso qui.

416
00:19:46,210 --> 00:19:47,540
Ho appena malloced.

417
00:19:47,540 --> 00:19:49,310
Supponiamo che sto controllando per nulla.

418
00:19:49,310 --> 00:19:51,870
>> Ora, ho intenzione di inizializzazione
n essere 34.

419
00:19:51,870 --> 00:19:53,040
E questo sarà n.

420
00:19:53,040 --> 00:19:54,670
Questo sarà il prossimo.

421
00:19:54,670 --> 00:19:57,100
E questo sarà precedente.

422
00:19:57,100 --> 00:19:59,370
Facciamo in modo che non l'ho fatto
ottenere questo indietro.

423
00:19:59,370 --> 00:20:01,110
Precedente viene prima
nella definizione.

424
00:20:01,110 --> 00:20:03,070
Correzione questo.

425
00:20:03,070 --> 00:20:04,410
Questa è precedente.

426
00:20:04,410 --> 00:20:05,780
Questo è il prossimo.

427
00:20:05,780 --> 00:20:08,620
Anche se questi sono identici,
teniamolo coerente.

428
00:20:08,620 --> 00:20:09,450
>> Precedente.

429
00:20:09,450 --> 00:20:11,030
Questo è il prossimo.

430
00:20:11,030 --> 00:20:16,310
Così ho appena malloced mia nota, controllato
per nulla, assegnato 34 nel nodo.

431
00:20:16,310 --> 00:20:17,570
Precedente ottiene nulla.

432
00:20:17,570 --> 00:20:19,480
In modo che mi dà questo.

433
00:20:19,480 --> 00:20:21,010
Avanti ottiene list.

434
00:20:21,010 --> 00:20:22,370
Quindi elenco è presente.

435
00:20:22,370 --> 00:20:26,520
Quindi questa è la stessa oggi come disegnare questo
freccia, in modo che puntino a uno

436
00:20:26,520 --> 00:20:27,940
nella stessa.

437
00:20:27,940 --> 00:20:30,400
E poi mi sto controllando se la lista
non è uguale a zero.

438
00:20:30,400 --> 00:20:31,740
E non è questa volta.

439
00:20:31,740 --> 00:20:35,580
Poi ho intenzione di fare la lista
precedente ottiene puntatore.

440
00:20:35,580 --> 00:20:39,700
>> Quindi lista previous ottiene PTR.

441
00:20:39,700 --> 00:20:44,300
Quindi questo ha l'effetto di mettere
una freccia grafica qui.

442
00:20:44,300 --> 00:20:46,930
E che sta diventando un po '
ondulate, le linee.

443
00:20:46,930 --> 00:20:50,780
E poi, infine, aggiorno
lista per puntare a puntatore.

444
00:20:50,780 --> 00:20:55,560
Così ora questa punta a questo ragazzo.

445
00:20:55,560 --> 00:20:57,170
E ora, facciamo un breve
controllo di integrità.

446
00:20:57,170 --> 00:20:59,470
>> Ecco la lista, che è
la variabile globale.

447
00:20:59,470 --> 00:21:02,850
Il primo nodo è, infatti, 34, perché
Sto seguendo la freccia.

448
00:21:02,850 --> 00:21:05,210
E questo è corretto perché voglio
inserire all'inizio della lista

449
00:21:05,210 --> 00:21:06,070
tutti i nuovi nodi.

450
00:21:06,070 --> 00:21:08,860
Il suo prossimo campo mi porta a questo ragazzo.

451
00:21:08,860 --> 00:21:10,710
Se continuo ad andarci, mi ha colpito il prossimo è nullo.

452
00:21:10,710 --> 00:21:11,760
Quindi non c'è più la lista.

453
00:21:11,760 --> 00:21:14,460
Se mi ha colpito precedente, ottengo
indietro dove mi aspetto.

454
00:21:14,460 --> 00:21:16,435
>> Quindi ci sono ancora alcuni indicatori,
ovviamente, per manipolare.

455
00:21:16,435 --> 00:21:19,870
Ma il fatto che vi è stato detto di fare
questo in tempo costante si intende solo

456
00:21:19,870 --> 00:21:22,910
avere un numero finito di cose
si è permesso di fare.

457
00:21:22,910 --> 00:21:24,290
E qual è quel numero?

458
00:21:24,290 --> 00:21:25,185
Potrebbe essere un passo.

459
00:21:25,185 --> 00:21:25,700
Potrebbe essere due.

460
00:21:25,700 --> 00:21:26,820
Potrebbe essere 1.000 gradini.

461
00:21:26,820 --> 00:21:30,500
Ma è finita, il che significa che non è possibile
avere qualsiasi tipo di looping in corso

462
00:21:30,500 --> 00:21:32,010
qui, nessuna ricorsione, nessun cicli.

463
00:21:32,010 --> 00:21:37,390
E 'solo avuto modo di essere linee di hard-coded
di codice come abbiamo in questo esempio.

464
00:21:37,390 --> 00:21:42,330
>> Quindi, il problema successivo 12 ci ha chiesto di
completare l'attuazione di remove

465
00:21:42,330 --> 00:21:46,740
di seguito in modo tale che rimuove
n dalla lista in tempo lineare.

466
00:21:46,740 --> 00:21:48,740
In modo da avere un po 'di più
spazio di manovra ora.

467
00:21:48,740 --> 00:21:52,380
Si può supporre che n, se presenti
nella lista, sarà presente

468
00:21:52,380 --> 00:21:53,340
non più di una volta.

469
00:21:53,340 --> 00:21:56,770
E anche questo è destinato a essere una basata su quiz
ipotesi semplificatrice, così

470
00:21:56,770 --> 00:21:59,780
che se si trova il numero 50 da qualche parte
nella lista, non lo fai anche

471
00:21:59,780 --> 00:22:02,890
devono preoccuparsi di continuare a
iterare, alla ricerca di ogni possibile

472
00:22:02,890 --> 00:22:06,990
copia di 50, che sarebbe solo devolvere
in qualche minuzia in un tempo limitato.

473
00:22:06,990 --> 00:22:10,460
>> Quindi, con remove, questo è stato sicuramente
più impegnativo e più

474
00:22:10,460 --> 00:22:11,640
codice da scrivere.

475
00:22:11,640 --> 00:22:14,990
Ma a prima vista, francamente, potrebbe
guardare travolgente e come qualcosa

476
00:22:14,990 --> 00:22:17,060
non c'è modo si potrebbe avere
venire con un quiz.

477
00:22:17,060 --> 00:22:22,450
Ma se ci concentriamo sulle singole fasi,
si spera, sarà improvvisamente

478
00:22:22,450 --> 00:22:26,060
sciopero che ognuno di questi singoli
procedura ha senso ovvio

479
00:22:26,060 --> 00:22:27,080
in retrospettiva.

480
00:22:27,080 --> 00:22:28,200
Quindi diamo un'occhiata.

481
00:22:28,200 --> 00:22:32,570
>> Quindi, prima, inizializziamo puntatore
di essere lista stessa.

482
00:22:32,570 --> 00:22:36,040
Perché voglio tempo lineare, il che significa
Ho intenzione di avere qualche loop.

483
00:22:36,040 --> 00:22:39,730
E un modo comune per scorrere i
nodi in una struttura elenco o qualsiasi tipo

484
00:22:39,730 --> 00:22:43,860
della struttura in modo iterativo è quello di prendere
un puntatore alla parte anteriore dei dati

485
00:22:43,860 --> 00:22:46,990
struttura e poi basta avviare l'aggiornamento
e camminare la strada

486
00:22:46,990 --> 00:22:48,650
attraverso la struttura di dati.

487
00:22:48,650 --> 00:22:50,040
Quindi ho intenzione di fare esattamente questo.

488
00:22:50,040 --> 00:22:54,260
>> Mentre puntatore, la mia variabile temporanea,
è diverso da null, LET'S

489
00:22:54,260 --> 00:22:55,660
andare avanti e controllare.

490
00:22:55,660 --> 00:22:56,910
Ho ricevuto fortunato?

491
00:22:56,910 --> 00:23:01,740
È il campo n nel nodo Sono attualmente
guardando pari alla

492
00:23:01,740 --> 00:23:03,380
Numero sto cercando?

493
00:23:03,380 --> 00:23:05,410
E se è così, facciamo qualcosa.

494
00:23:05,410 --> 00:23:10,020
Ora, notare questo se la condizione
circonda l'intero

495
00:23:10,020 --> 00:23:11,520
seguenti righe di codice.

496
00:23:11,520 --> 00:23:14,610
Questa è l'unica cosa che mi interessa -
trovare un numero in questione.

497
00:23:14,610 --> 00:23:18,010
Quindi non c'è nessun altro, che semplifica
cose concettualmente un po '.

498
00:23:18,010 --> 00:23:22,040
>> Ma ora, ho capito, e si potrebbe avere
solo capito questo dopo aver pensato

499
00:23:22,040 --> 00:23:24,720
attraverso un po ', non c'è
in realtà due casi qui.

500
00:23:24,720 --> 00:23:28,060
Uno è dove il nodo è al
inizio della lista, che è un

501
00:23:28,060 --> 00:23:31,040
po 'fastidioso, perché è un
caso speciale, perché si ha a che fare

502
00:23:31,040 --> 00:23:33,340
con questa cosa, che
è l'unica anomalia.

503
00:23:33,340 --> 00:23:35,720
Ovunque nella lista,
è la stessa cosa.

504
00:23:35,720 --> 00:23:38,050
C'è un nodo precedente e una successiva
nodo, il nodo precedente, successiva nodo.

505
00:23:38,050 --> 00:23:40,940
Ma questo ragazzo è un po 'speciale
se è all'inizio.

506
00:23:40,940 --> 00:23:48,710
>> Quindi, se il puntatore è uguale lista
stesso, così se sono all'inizio di

507
00:23:48,710 --> 00:23:53,960
la lista e ho trovato n, ho bisogno
per fare un paio di cose.

508
00:23:53,960 --> 00:23:59,230
Uno, ho bisogno di cambiare elenco
puntare al campo successivo, 50.

509
00:23:59,230 --> 00:24:01,270
Quindi suppongo che sto cercando
per rimuovere 34.

510
00:24:01,270 --> 00:24:03,560
Così questo ragazzo ha avuto modo di andare
via in un attimo.

511
00:24:03,560 --> 00:24:07,210
>> Quindi ho intenzione di dire, lista
viene puntatore prossimo.

512
00:24:07,210 --> 00:24:08,570
Beh, questo è il puntatore.

513
00:24:08,570 --> 00:24:10,360
Avanti si indica qui.

514
00:24:10,360 --> 00:24:17,470
Quindi questo sta cambiando questa freccia destra
ora puntare a questo tizio qui.

515
00:24:17,470 --> 00:24:19,580
Ora, ricordate, abbiamo
una variabile temporanea.

516
00:24:19,580 --> 00:24:23,520
Quindi non abbiamo orfano nodi,
perché ho anche questo ragazzo nella mia

517
00:24:23,520 --> 00:24:25,010
l'attuazione di remove.

518
00:24:25,010 --> 00:24:29,600
Così ora, se la lista in sé non è nulla,
Ho bisogno di sistemare qualcosa.

519
00:24:29,600 --> 00:24:32,690
>> Devo ora fare in modo che questa freccia,
che è già puntamento

520
00:24:32,690 --> 00:24:36,830
50-34, questo ha ottenuto di andare via,
perché se sto cercando di sbarazzarsi

521
00:24:36,830 --> 00:24:41,910
di 34, 50 avevano meglio non mantiene alcun
tipo di schiena riferimento ad essa come

522
00:24:41,910 --> 00:24:42,820
freccia suggerito.

523
00:24:42,820 --> 00:24:44,820
Così ho appena fatto questa linea.

524
00:24:44,820 --> 00:24:46,520
Allora ho finito.

525
00:24:46,520 --> 00:24:48,040
Tale causa è in realtà piuttosto semplice.

526
00:24:48,040 --> 00:24:51,010
Tritare la testa della lista
è relativamente semplice.

527
00:24:51,010 --> 00:24:52,980
>> Purtroppo, c'è questo
fastidioso altro blocco.

528
00:24:52,980 --> 00:24:56,170
Così ora, devo considerare il caso
dove c'è qualcosa in mezzo.

529
00:24:56,170 --> 00:24:59,880
Ma non è troppo terribile, fatta eccezione
per la sintassi come questo.

530
00:24:59,880 --> 00:25:03,080
Quindi, se non sono all'inizio del
elenco, sono da qualche parte nel mezzo.

531
00:25:03,080 --> 00:25:08,160
E questa linea qui sta dicendo, inizio
a qualunque nodo che ci sei.

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

533
00:25:11,210 --> 00:25:18,550
Vai al campo successivo del nodo precedente
e il punto che al puntatore.

534
00:25:18,550 --> 00:25:20,390
>> Facciamo questo pittoricamente.

535
00:25:20,390 --> 00:25:21,640
Che stava diventando complicata.

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

537
00:25:30,480 --> 00:25:37,990
Quindi, se ho una precedente campi qui -
facciamolo - campi successivi qui.

538
00:25:37,990 --> 00:25:41,200
Ho intenzione di semplificare la mia puntatori piuttosto
di disegnare un intero gruppo di

539
00:25:41,200 --> 00:25:45,710
le cose avanti e indietro si incrociano
vicenda.

540
00:25:45,710 --> 00:25:50,870
E ora, limitiamoci a dire che questo è 1, 2,
3 per il bene della discussione, anche

541
00:25:50,870 --> 00:25:53,410
anche se questo non è allineata con
il problema in questione.

542
00:25:53,410 --> 00:25:55,900
>> Quindi, ecco la mia lista collegata.

543
00:25:55,900 --> 00:25:59,300
Sto cercando di rimuovere i due in questo
particolare versione della storia.

544
00:25:59,300 --> 00:26:01,960
Così ho aggiornato puntatore
essere rivolto a questo ragazzo.

545
00:26:01,960 --> 00:26:03,315
Quindi questo è PTR.

546
00:26:03,315 --> 00:26:04,530
Sta puntando qui.

547
00:26:04,530 --> 00:26:07,170
Questa è la lista, che esiste
globalmente come prima.

548
00:26:07,170 --> 00:26:09,200
E ha rivolto qui non importa cosa.

549
00:26:09,200 --> 00:26:10,800
Ed ora, sto cercando di rimuovere due.

550
00:26:10,800 --> 00:26:13,850
>> Quindi, se il puntatore punta qui, sono
andando a seguire, a quanto pare, l'

551
00:26:13,850 --> 00:26:17,110
puntatore precedente, che mi mette a 1.

552
00:26:17,110 --> 00:26:22,290
Sto andando poi a dire che il prossimo
campo, che mi porta verso questo

553
00:26:22,290 --> 00:26:25,410
casella qui, sta per
pari indicatore accanto.

554
00:26:25,410 --> 00:26:28,400
Quindi, se questo puntatore, questo è prossima.

555
00:26:28,400 --> 00:26:31,840
Ciò significa che questa freccia esigenze
per puntare a questo ragazzo.

556
00:26:31,840 --> 00:26:35,140
>> Allora, cosa che riga di codice ha appena
fatto è un po 'di questo.

557
00:26:35,140 --> 00:26:37,500
E ora, questo è alla ricerca come un
un passo nella giusta direzione.

558
00:26:37,500 --> 00:26:41,390
Siamo essenzialmente vogliamo tagliare fuori 2
del mezzo 1 e 3.

559
00:26:41,390 --> 00:26:44,400
Quindi ha senso che vogliamo
percorso questo puntatore intorno ad esso.

560
00:26:44,400 --> 00:26:50,400
Quindi questa riga successiva sta controllando se il puntatore
successivo non è nullo, non c'è

561
00:26:50,400 --> 00:26:54,200
Al contrario uno a destra di 2,
che significa che abbiamo anche a che fare

562
00:26:54,200 --> 00:26:55,850
un po 'snip qui.

563
00:26:55,850 --> 00:27:00,590
>> Così ora ho bisogno di seguire questo puntatore
e aggiornare il puntatore precedente

564
00:27:00,590 --> 00:27:05,410
questo ragazzo per fare un po 'di
soluzione, qui il punto qui.

565
00:27:05,410 --> 00:27:07,100
E ora, visivamente questo è bello.

566
00:27:07,100 --> 00:27:11,930
E 'un po' disordinato in che non c'è
nessuno indicando la 2 più.

567
00:27:11,930 --> 00:27:13,600
2 sta indicando a sinistra.

568
00:27:13,600 --> 00:27:14,980
E 2 sta indicando a destra.

569
00:27:14,980 --> 00:27:17,480
Ma lui può fare quello che vuole, perché
sta per ottenere liberato.

570
00:27:17,480 --> 00:27:19,480
E non importa che cosa
tali valori sono più.

571
00:27:19,480 --> 00:27:23,040
>> Quello che è importante è che il restante
ragazzi sono di routing sopra

572
00:27:23,040 --> 00:27:24,280
e sotto di lui.

573
00:27:24,280 --> 00:27:25,810
E in effetti, questo è quello che facciamo dopo.

574
00:27:25,810 --> 00:27:29,360
Noi puntatore libera, il che significa che diciamo l'
il sistema operativo, sei il benvenuto

575
00:27:29,360 --> 00:27:30,906
recuperare questo.

576
00:27:30,906 --> 00:27:34,900
E poi, infine, ci ritorno.

577
00:27:34,900 --> 00:27:37,220
Altrimenti implicitamente, se
non hanno ancora restituito,

578
00:27:37,220 --> 00:27:38,290
dobbiamo continuare a cercare.

579
00:27:38,290 --> 00:27:41,485
Così puntatore è uguale puntatore successiva,
significa spostare questo tizio qui.

580
00:27:41,485 --> 00:27:42,600
Spostare questo ragazzo qui.

581
00:27:42,600 --> 00:27:45,400
Spostare questo ragazzo qui, infatti,
non abbiamo trovato il numero

582
00:27:45,400 --> 00:27:46,960
stiamo cercando ancora di.

583
00:27:46,960 --> 00:27:49,630
>> Quindi, francamente, sembra completamente
travolgente, credo, in un primo momento

584
00:27:49,630 --> 00:27:52,180
colpo d'occhio, soprattutto se si lottato
con questo durante il quiz poi vedere

585
00:27:52,180 --> 00:27:52,850
qualcosa di simile.

586
00:27:52,850 --> 00:27:55,050
E si pacca sulla schiena.

587
00:27:55,050 --> 00:27:57,080
Beh, non c'è modo avrei potuto
venire con quello sul quiz.

588
00:27:57,080 --> 00:28:00,470
Ma direi, è possibile se si rompe
giù in questi individuale

589
00:28:00,470 --> 00:28:04,400
casi e solo a piedi attraverso di essa
attenzione, anche se, certo, sotto

590
00:28:04,400 --> 00:28:06,300
circostanze stressanti.

591
00:28:06,300 --> 00:28:09,470
>> Per fortuna, l'immagine ha fatto
tutto felice.

592
00:28:09,470 --> 00:28:11,050
Si potrebbe disegnare questo
qualsiasi numero di modi.

593
00:28:11,050 --> 00:28:12,760
Non devi fare lo incrociano
cosa qui.

594
00:28:12,760 --> 00:28:14,520
Si potrebbe farlo con dritto
linee come questo.

595
00:28:14,520 --> 00:28:18,790
Ma la sostanza di questo problema, in
generale, sia per rendersi conto che la

596
00:28:18,790 --> 00:28:22,060
immagine, alla fine, dovrebbe apparire un po '
qualcosa di simile, perché

597
00:28:22,060 --> 00:28:25,030
costante di tempo implicava che si mantiene
inceppamenti e disturbo e disturbo della

598
00:28:25,030 --> 00:28:29,900
nuovi nodi all'inizio
dell'elenco.

599
00:28:29,900 --> 00:28:31,960
Tutte le domande?

600
00:28:31,960 --> 00:28:34,565
Probabilmente il più impegnativo di
certamente le domande di codifica.

601
00:28:34,565 --> 00:28:37,690
>> AUDIENCE: Così è la lista simile a
testa negli esempi precedenti.

602
00:28:37,690 --> 00:28:39,640
>> DAVID J. MALAN: Esattamente, esattamente.

603
00:28:39,640 --> 00:28:43,130
Basta un nome diverso per
una variabile globale.

604
00:28:43,130 --> 00:28:44,380
In tutto il mondo che cosa?

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

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

607
00:28:49,730 --> 00:28:52,020
Quindi questo è quello in cui si
dovuto scrivere il paragrafo.

608
00:28:52,020 --> 00:28:56,060
Alcune persone hanno scritto saggi
per questa domanda.

609
00:28:56,060 --> 00:29:00,230
Ma basta usare questi sei termini
per descrivere cosa succede quando

610
00:29:00,230 --> 00:29:02,440
si tenta di contattare facebook.com.

611
00:29:02,440 --> 00:29:07,930
Quindi mi limiterò a parlare attraverso il processo
utilizzando tutti questi termini.

612
00:29:07,930 --> 00:29:11,290
Così nel nostro browser, digitiamo facebook.com
e premere Invio.

613
00:29:11,290 --> 00:29:17,280
Così il nostro browser sta andando a costruire un
HTTP richiedere che sta andando per inviare

614
00:29:17,280 --> 00:29:22,220
attraverso un processo a Facebook per
Facebook per rispondere a noi con l'

615
00:29:22,220 --> 00:29:24,450
HTML della propria pagina.

616
00:29:24,450 --> 00:29:28,800
>> Allora, qual è il processo mediante il
che la richiesta HTTP

617
00:29:28,800 --> 00:29:30,730
in realtà arriva a Facebook?

618
00:29:30,730 --> 00:29:32,790
Quindi in primo luogo, abbiamo bisogno di tradurre
Facebook.com.

619
00:29:32,790 --> 00:29:38,780
Così appena dato il nome di Facebook.com,
dove in realtà fa la richiesta HTTP

620
00:29:38,780 --> 00:29:39,940
bisogno di andare?

621
00:29:39,940 --> 00:29:44,120
Quindi abbiamo bisogno di tradurre Facebook.com
a un indirizzo IP, che univocamente

622
00:29:44,120 --> 00:29:47,620
identifica quale macchina abbiamo effettivamente
desidera inviare questa richiesta.

623
00:29:47,620 --> 00:29:49,310
Il vostro computer portatile ha un indirizzo IP.

624
00:29:49,310 --> 00:29:52,240
Tutto ciò connesso a internet
ha un indirizzo IP.

625
00:29:52,240 --> 00:29:59,030
>> Così DNS, Domain Name System, che è
quello che sta succedendo per gestire la traduzione

626
00:29:59,030 --> 00:30:03,750
da facebook.com a un indirizzo IP che
si vuole realmente mettersi in contatto.

627
00:30:03,750 --> 00:30:08,075
Così ci mettiamo in contatto i server DNS e
per esempio, che cosa è facebook.com?

628
00:30:08,075 --> 00:30:16,560
Si dice, oh, è l'indirizzo IP 190,212
qualcosa, qualcosa, qualcosa.

629
00:30:16,560 --> 00:30:16,900
Bene.

630
00:30:16,900 --> 00:30:18,850
Ora, so che macchina
Voglio contattare.

631
00:30:18,850 --> 00:30:22,360
>> Allora si invia la richiesta HTTP
oltre a quella macchina.

632
00:30:22,360 --> 00:30:24,140
Così come si arriva a quella macchina?

633
00:30:24,140 --> 00:30:27,200
Ebbene, la richiesta va da
router a router rimbalzo.

634
00:30:27,200 --> 00:30:32,630
Ricordate l'esempio in classe, dove
abbiamo effettivamente visto il percorso che l'

635
00:30:32,630 --> 00:30:35,340
pacchetti preso quando abbiamo cercato
comunicare.

636
00:30:35,340 --> 00:30:38,460
Abbiamo visto saltare sopra l'Atlantico
Mare in un punto o qualsiasi altra cosa.

637
00:30:38,460 --> 00:30:42,820
>> Così l'ultimo porto termine.

638
00:30:42,820 --> 00:30:46,520
Quindi questo è ora sul vostro computer.

639
00:30:46,520 --> 00:30:49,970
È possibile avere più cose attualmente
comunicare con Internet.

640
00:30:49,970 --> 00:30:53,730
Così posso essere in esecuzione, ad esempio, Skype.

641
00:30:53,730 --> 00:30:55,670
Potrei avere un browser web aperto.

642
00:30:55,670 --> 00:30:59,010
Potrei avere qualcosa che
torrenting file.

643
00:30:59,010 --> 00:31:00,880
Quindi, tutte queste cose sono
comunicante con l'

644
00:31:00,880 --> 00:31:02,600
internet in qualche modo.

645
00:31:02,600 --> 00:31:08,070
>> Così, quando il computer riceve alcuni dati
da internet, come si fa

646
00:31:08,070 --> 00:31:10,130
sapere quale applicazione effettivamente
vuole i dati?

647
00:31:10,130 --> 00:31:12,610
Come fa a sapere se questa particolare
dati è pensato per l'

648
00:31:12,610 --> 00:31:16,070
torrenting applicazione in contrapposizione
al browser web?

649
00:31:16,070 --> 00:31:20,980
Quindi questo è lo scopo di porti che
tutte queste applicazioni hanno

650
00:31:20,980 --> 00:31:22,720
rivendicato una porta del computer.

651
00:31:22,720 --> 00:31:27,580
Così il vostro browser web dice, hey,
Sto in ascolto sulla porta 1000.

652
00:31:27,580 --> 00:31:32,240
E il programma torrenting sta dicendo,
Sto in ascolto sulla porta 3000.

653
00:31:32,240 --> 00:31:34,770
E Skype dice, io sto utilizzando la porta 4000.

654
00:31:34,770 --> 00:31:41,950
>> Così, quando si ottiene alcuni dati che appartiene
ad una di queste applicazioni, i dati

655
00:31:41,950 --> 00:31:45,510
è contrassegnato con la quale porta in realtà
devono essere inviate insieme al.

656
00:31:45,510 --> 00:31:47,950
Così dice questo, oh, io appartengo
alla porta 1000.

657
00:31:47,950 --> 00:31:50,950
So poi ho bisogno di trasmettere la presente
insieme al mio browser web.

658
00:31:50,950 --> 00:31:56,440
Quindi la ragione è pertinente qui
è che i server web tendono a

659
00:31:56,440 --> 00:31:58,240
ascolto sulla porta 80.

660
00:31:58,240 --> 00:32:02,420
Così, quando posso contattare Facebook.com, sono
comunicare con una macchina.

661
00:32:02,420 --> 00:32:06,390
Ma ho bisogno di dire quale porta di quella
Macchina voglio comunicare.

662
00:32:06,390 --> 00:32:09,160
E server web tendono ad essere
in ascolto sulla porta 80.

663
00:32:09,160 --> 00:32:14,010
>> Se volevano, potevano impostarlo
in modo elenca come sulla porta 7000.

664
00:32:14,010 --> 00:32:19,090
E poi in un browser web, ho potuto
digitare manualmente Facebook.com: 7000

665
00:32:19,090 --> 00:32:24,600
inviare la richiesta alla porta 7000
di web server di Facebook.

666
00:32:24,600 --> 00:32:26,820
>> David J. MALAN: E in questo caso, anche
se non abbiamo bisogno che la gente

667
00:32:26,820 --> 00:32:30,000
citare questo, in questo caso, la porta
Sarebbe la richiesta effettivamente andare a?

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

669
00:32:36,630 --> 00:32:37,880
Prova di nuovo.

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

671
00:32:42,810 --> 00:32:44,300
Esattamente.

672
00:32:44,300 --> 00:32:47,960
Non alla ricerca di quella, ma una sottigliezza
che è lì nessuno l'ultimo.

673
00:32:47,960 --> 00:32:51,770
>> ROB BOWDEN: Così l'HTTPS, dal momento che è
ascolto specificamente per l'

674
00:32:51,770 --> 00:32:55,180
cifrato, è sulla porta 4430.

675
00:32:55,180 --> 00:32:57,680
>> Pubblico: E-mail sono 25, giusto?

676
00:32:57,680 --> 00:33:00,670
>> DAVID J. MALAN: Outbound
e-mail, 25, sì.

677
00:33:00,670 --> 00:33:03,760
>> ROB BOWDEN: Io non so nemmeno la maggior parte dei
il - tutte quelle inferiori tendono ad essere

678
00:33:03,760 --> 00:33:06,310
riservata per le cose.

679
00:33:06,310 --> 00:33:09,260
Penso che tutto sotto
1024 è riservato.

680
00:33:09,260 --> 00:33:13,450
>> AUDIENCE: Perché hai detto
3 era il numero sbagliato?

681
00:33:13,450 --> 00:33:18,820
>> ROB BOWDEN: Perché in un indirizzo IP,
ci sono quattro gruppi di cifre.

682
00:33:18,820 --> 00:33:21,090
E sono da 0 a 255.

683
00:33:21,090 --> 00:33:28,060
Quindi 192.168.2.1 è un comune
locale indirizzo IP di rete.

684
00:33:28,060 --> 00:33:30,840
Avviso tutti coloro che sono meno di 255.

685
00:33:30,840 --> 00:33:33,570
Così, quando ho iniziato con 300, che
non potrebbe avere

686
00:33:33,570 --> 00:33:35,210
stato uno dei numeri.

687
00:33:35,210 --> 00:33:38,170
>> DAVID J. MALAN: Ma quel clip stupido
da - era CSI, dove avevano una

688
00:33:38,170 --> 00:33:39,970
numero che era troppo grande
per l'indirizzo IP.

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

690
00:33:42,940 --> 00:33:46,110
>> ROB BOWDEN: Tutte le domande su questo?

691
00:33:46,110 --> 00:33:51,710
Il prossimo, cambiamento così completo in
argomento, ma abbiamo questo array PHP per

692
00:33:51,710 --> 00:33:53,270
le case del quad.

693
00:33:53,270 --> 00:33:56,360
E abbiamo una lista non ordinata.

694
00:33:56,360 --> 00:33:59,550
E vogliamo stampare ogni voce dell'elenco
solo che contiene il nome di casa.

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

696
00:34:09,090 --> 00:34:11,870
Così abbiamo un ciclo foreach.

697
00:34:11,870 --> 00:34:17,540
Quindi ricorda, la sintassi è foreach
matrice come elemento dell'array.

698
00:34:17,540 --> 00:34:22,360
Quindi attraverso ogni iterazione del ciclo,
casa sta per assumere uno dei

699
00:34:22,360 --> 00:34:24,060
I valori all'interno della matrice.

700
00:34:24,060 --> 00:34:26,530
>> Nella prima iterazione, la casa
sarà Cabot House.

701
00:34:26,530 --> 00:34:30,370
In una seconda iterazione, la casa sarà
essere Courier House e così via.

702
00:34:30,370 --> 00:34:34,370
Così, per ogni quad come casa, siamo
basta andare in stampa -

703
00:34:34,370 --> 00:34:37,250
si potrebbe anche avere eco -

704
00:34:37,250 --> 00:34:42,199
la voce di elenco e quindi il nome della casa
e quindi chiudere la voce di elenco.

705
00:34:42,199 --> 00:34:45,210
Le parentesi graffe sono opzionali qui.

706
00:34:45,210 --> 00:34:49,480
>> E poi abbiamo anche detto nella domanda
si, ricordatevi di chiudere il

707
00:34:49,480 --> 00:34:50,770
ordinato tag lista.

708
00:34:50,770 --> 00:34:53,949
Quindi abbiamo bisogno per uscire dalla modalità PHP
per fare questo.

709
00:34:53,949 --> 00:35:00,280
Oppure avremmo potuto eco l'
chiudere tag lista non ordinata.

710
00:35:00,280 --> 00:35:02,380
>> DAVID J. MALAN: bene anche qui sarebbe
sono stati per usare una vecchia scuola per

711
00:35:02,380 --> 00:35:07,340
ciclo con un $ i = 0 0 e usando conta fino
capire la lunghezza del raggio.

712
00:35:07,340 --> 00:35:09,240
Totalmente troppo bene, basta
un po wordier.

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

714
00:35:12,170 --> 00:35:14,742
>> AUDIENCE: Quindi, se si andavano a
[Incomprensibile], faresti -

715
00:35:14,742 --> 00:35:16,734
Ho dimenticato come il ciclo [incomprensibile] è.

716
00:35:16,734 --> 00:35:21,380
Volete $ supporto quad i?

717
00:35:21,380 --> 00:35:21,850
>> DAVID J. MALAN: Esattamente.

718
00:35:21,850 --> 00:35:23,100
Sì, esattamente.

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

720
00:35:26,650 --> 00:35:27,900
>> ROB BOWDEN: Nient'altro?

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

722
00:35:31,350 --> 00:35:32,010
>> DAVID J. MALAN: Va bene.

723
00:35:32,010 --> 00:35:32,300
Trade-off.

724
00:35:32,300 --> 00:35:38,290
Quindi c'erano mazzi di risposte
possibile per ciascuno di questi.

725
00:35:38,290 --> 00:35:40,510
Siamo rimasti davvero solo in cerca di
qualcosa di interessante per un rialzo e

726
00:35:40,510 --> 00:35:41,100
un aspetto negativo.

727
00:35:41,100 --> 00:35:44,830
E il numero 16 chiese, convalida gli utenti '
Ingresso lato client, come JavaScript,

728
00:35:44,830 --> 00:35:47,280
invece di server-side, come con PHP.

729
00:35:47,280 --> 00:35:49,450
Così che cosa è un rialzo di
facendo client-side?

730
00:35:49,450 --> 00:35:53,780
>> Beh, una delle cose che abbiamo proposto è
che si riduce la latenza, perché si

731
00:35:53,780 --> 00:35:56,750
non devono preoccuparsi di contattare il
server, che potrebbe richiedere un paio di

732
00:35:56,750 --> 00:36:00,390
millisecondi o anche un paio di secondi
evitando che e solo

733
00:36:00,390 --> 00:36:04,670
convalida degli utenti in ingresso lato client
innescando un gestore on-presentare e

734
00:36:04,670 --> 00:36:06,650
solo controllando, ha si digita
qualcosa per il nome?

735
00:36:06,650 --> 00:36:08,080
Hanno qualcosa tipo
a indirizzo email?

736
00:36:08,080 --> 00:36:10,950
Hanno scelto un dormitorio da
il menu a discesa?

737
00:36:10,950 --> 00:36:14,360
>> È possibile dare loro un feedback istantaneo
utilizzando il computer gigahertz

738
00:36:14,360 --> 00:36:16,770
o qualsiasi altra cosa che hanno che è
in realtà sulla loro scrivania.

739
00:36:16,770 --> 00:36:19,310
Quindi è solo un utente migliore
sperimentare in genere.

740
00:36:19,310 --> 00:36:24,460
Ma un lato negativo di fare client-side
convalida, se lo si fa anche senza

741
00:36:24,460 --> 00:36:29,860
facendo la validazione lato server è che
più nessuno esce di CS50 sa

742
00:36:29,860 --> 00:36:33,980
che si può semplicemente inviare tutti i dati che si desidera
ad un server qualsiasi numero di modi.

743
00:36:33,980 --> 00:36:37,030
Francamente, nella maggior parte qualsiasi browser, è possibile
cliccare in giro nelle impostazioni e proprio

744
00:36:37,030 --> 00:36:40,110
disattivare Javascript, che sarebbe,
quindi, disattivare qualsiasi forma di

745
00:36:40,110 --> 00:36:41,080
convalida.

746
00:36:41,080 --> 00:36:44,460
>> Ma si potrebbe anche ricordare che anche io
ha fatto alcune cose arcane in classe utilizzando

747
00:36:44,460 --> 00:36:47,790
telnet ed effettivamente fingendo di
essere un browser inviando get

748
00:36:47,790 --> 00:36:49,240
richieste a un server.

749
00:36:49,240 --> 00:36:51,030
E non è certo
utilizzando qualsiasi JavaScript.

750
00:36:51,030 --> 00:36:53,290
Questo è solo me digitare comandi
a una tastiera.

751
00:36:53,290 --> 00:36:57,410
Quindi, in realtà, ogni programmatore entro abbastanza
comfort con il web e HTTP

752
00:36:57,410 --> 00:37:01,690
potrebbe inviare qualsiasi dato lui o lei vuole
a un server senza convalida.

753
00:37:01,690 --> 00:37:05,470
E se il server non sta controllando,
si mi danno un nome, è

754
00:37:05,470 --> 00:37:08,930
questo in realtà un indirizzo email valido, ha fatto
scelgono un dormitorio, si potrebbe finire

755
00:37:08,930 --> 00:37:12,800
up inserendo falso o solo dati vuoto
nel database, che probabilmente

756
00:37:12,800 --> 00:37:15,450
non sta per essere una buona cosa se
eri supponendo che c'era.

757
00:37:15,450 --> 00:37:16,770
>> Quindi questa è una realtà fastidiosa.

758
00:37:16,770 --> 00:37:19,890
Ma in generale, lato client
convalida è grande.

759
00:37:19,890 --> 00:37:21,810
Ma significa il doppio del lavoro.

760
00:37:21,810 --> 00:37:25,970
Anche se ci fanno esistere vari
biblioteche, librerie JavaScript per

761
00:37:25,970 --> 00:37:28,830
esempio, che rendono questo molto,
molto meno di un mal di testa.

762
00:37:28,830 --> 00:37:31,940
E si può riutilizzare parte del codice
lato server, client-side.

763
00:37:31,940 --> 00:37:35,980
Ma non si rendono conto che si tratta in genere
lavoro supplementare.

764
00:37:35,980 --> 00:37:36,415
Già.

765
00:37:36,415 --> 00:37:37,792
>> AUDIENCE: Quindi, se abbiamo appena
detto meno sicuro -

766
00:37:37,792 --> 00:37:39,205
>> DAVID J. MALAN: [ride]

767
00:37:39,205 --> 00:37:39,680
Ugh.

768
00:37:39,680 --> 00:37:43,105
Quelli sono sempre più difficile
quelli a provvedere.

769
00:37:43,105 --> 00:37:44,480
>> ROB BOWDEN: Che sarebbe
sono state accettate.

770
00:37:44,480 --> 00:37:44,810
>> DAVID J. MALAN: Cosa?

771
00:37:44,810 --> 00:37:45,810
>> ROB BOWDEN: Ho creato questo problema.

772
00:37:45,810 --> 00:37:46,735
Ciò sarebbe stato accettato.

773
00:37:46,735 --> 00:37:47,220
>> DAVID J. MALAN: Già.

774
00:37:47,220 --> 00:37:47,830
>> AUDIENCE: Freddo.

775
00:37:47,830 --> 00:37:51,770
>> ROB BOWDEN: Ma noi non accettiamo
per la prima -

776
00:37:51,770 --> 00:37:53,630
bene, quello che stavamo cercando è
qualcosa di simile non si deve

777
00:37:53,630 --> 00:37:55,270
comunicare con il server.

778
00:37:55,270 --> 00:37:58,355
Non abbiamo accettato solo più veloce.

779
00:37:58,355 --> 00:38:00,080
>> AUDIENCE: Che dire
Non ricaricare la pagina?

780
00:38:00,080 --> 00:38:00,430
>> ROB BOWDEN: sì.

781
00:38:00,430 --> 00:38:03,000
Quella era una risposta accettata.

782
00:38:03,000 --> 00:38:06,300
>> DAVID J. MALAN: Anything dove ci siamo sentiti
era più probabile che non probabile

783
00:38:06,300 --> 00:38:09,780
che si sapeva quello che eri
dicendo che è un duro

784
00:38:09,780 --> 00:38:13,500
Linea per disegnare a volte.

785
00:38:13,500 --> 00:38:16,000
Utilizzando una lista collegata invece
di un array di mantenere un

786
00:38:16,000 --> 00:38:17,590
ordinati elenco di numeri interi.

787
00:38:17,590 --> 00:38:21,000
Quindi un rialzo spesso ci ricordiamo con collegata
liste che hanno motivato la loro intera

788
00:38:21,000 --> 00:38:22,370
introduzione era si ottiene dinamismo.

789
00:38:22,370 --> 00:38:23,030
Possono crescere.

790
00:38:23,030 --> 00:38:23,950
Essi possono ridursi.

791
00:38:23,950 --> 00:38:27,370
Quindi non dovete fare i salti mortali
per creare effettivamente più memoria

792
00:38:27,370 --> 00:38:28,140
con una matrice.

793
00:38:28,140 --> 00:38:30,310
O non avete a poco
dire, mi dispiace, l'utente.

794
00:38:30,310 --> 00:38:31,410
La matrice viene riempita.

795
00:38:31,410 --> 00:38:35,850
Crescita così dinamica dell'elenco.

796
00:38:35,850 --> 00:38:37,210
Un aspetto negativo anche se di liste collegate?

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

798
00:38:40,916 --> 00:38:43,356
>> PUBBLICO: E 'lineare.

799
00:38:43,356 --> 00:38:45,800
Ricerca su lista concatenata è lineare
invece di quello che si accede dentro

800
00:38:45,800 --> 00:38:46,360
>> DAVID J. MALAN: Esattamente.

801
00:38:46,360 --> 00:38:50,160
Ricerca su una lista collegata è lineare,
anche se è risolto, perché si può

802
00:38:50,160 --> 00:38:53,170
solo seguire queste briciole di pane, questi
puntatori, dall'inizio della lista

803
00:38:53,170 --> 00:38:53,570
alla fine.

804
00:38:53,570 --> 00:38:57,970
Non è possibile sfruttare l'accesso casuale e,
quindi, la ricerca binaria, anche se è

805
00:38:57,970 --> 00:39:00,740
ordinati, che si poteva
fare con un array.

806
00:39:00,740 --> 00:39:02,390
E c'è anche un altro costo.

807
00:39:02,390 --> 00:39:02,966
Già.

808
00:39:02,966 --> 00:39:03,800
>> AUDIENCE: Memoria inefficiente?

809
00:39:03,800 --> 00:39:04,130
>> DAVID J. MALAN: Già.

810
00:39:04,130 --> 00:39:06,940
Beh, non sarebbe necessariamente
dire inefficiente.

811
00:39:06,940 --> 00:39:10,110
Ma ti costa più memoria,
perché avete bisogno di 32 bit per ogni

812
00:39:10,110 --> 00:39:13,400
nodo per il puntatore supplementare, a
almeno per una lista concatenata.

813
00:39:13,400 --> 00:39:16,660
Ora, se si sta memorizzando solo numeri interi e
si sta aggiungendo il puntatore, che è

814
00:39:16,660 --> 00:39:17,830
in realtà sorta di non-banale.

815
00:39:17,830 --> 00:39:19,340
È raddoppiando la quantità di memoria.

816
00:39:19,340 --> 00:39:22,330
Ma in realtà, se stai memorizzare un
lista concatenata di struct che potrebbero avere

817
00:39:22,330 --> 00:39:25,540
8 byte, 16 byte, ancora di più
Oltre a questo, forse è meno

818
00:39:25,540 --> 00:39:26,500
di un costo marginale.

819
00:39:26,500 --> 00:39:28,320
Ma è un costo comunque.

820
00:39:28,320 --> 00:39:31,880
Quindi uno di questi avrei
stato bene come aspetti negativi.

821
00:39:31,880 --> 00:39:32,110
>> 18.

822
00:39:32,110 --> 00:39:36,100
Utilizzando PHP invece di C per scrivere
un programma a riga di comando.

823
00:39:36,100 --> 00:39:41,890
Quindi, ecco, è spesso più veloce di utilizzare un
linguaggio come PHP o Ruby o Python.

824
00:39:41,890 --> 00:39:43,700
Basta aprire rapidamente
un editor di testo.

825
00:39:43,700 --> 00:39:45,900
Hai molte più funzioni
a vostra disposizione.

826
00:39:45,900 --> 00:39:49,325
PHP ha il lavello della cucina di funzioni,
mentre in C, è

827
00:39:49,325 --> 00:39:50,420
sono molto, molto poco.

828
00:39:50,420 --> 00:39:53,820
In realtà, i ragazzi la conoscono nel modo più duro
che non avete le tabelle hash.

829
00:39:53,820 --> 00:39:55,000
Non avete collegato liste.

830
00:39:55,000 --> 00:39:57,470
Se volete quelli, dovete
attuare da soli.

831
00:39:57,470 --> 00:40:00,950
>> Così un rialzo di PHP o realmente qualsiasi
linguaggio interpretato è la rapidità

832
00:40:00,950 --> 00:40:02,920
con la quale è possibile scrivere codice.

833
00:40:02,920 --> 00:40:06,660
Ma un aspetto negativo, abbiamo visto questo quando ho
rapidamente montata una Misspeller

834
00:40:06,660 --> 00:40:11,780
attuazione in conferenza utilizzando PHP, è
che l'utilizzo di un linguaggio interpretato

835
00:40:11,780 --> 00:40:13,570
è generalmente più lenta.

836
00:40:13,570 --> 00:40:18,420
E abbiamo visto che dimostrabile con un
crescere nel tempo da 0,3 secondi a 3

837
00:40:18,420 --> 00:40:24,440
secondi, a causa della interpretazione
che in realtà accade.

838
00:40:24,440 --> 00:40:27,060
>> Un altro aspetto positivo è che si
non devono compilare.

839
00:40:27,060 --> 00:40:30,130
Così accelera lo sviluppo
per inciso, perché non hai

840
00:40:30,130 --> 00:40:31,360
due passi per l'esecuzione di un programma.

841
00:40:31,360 --> 00:40:32,140
Devi solo uno.

842
00:40:32,140 --> 00:40:35,260
E così che è abbastanza
convincente pure.

843
00:40:35,260 --> 00:40:38,450
Utilizzando un database SQL invece di
un file CSV per memorizzare i dati.

844
00:40:38,450 --> 00:40:40,230
Database in modo SQL viene utilizzato per pset7.

845
00:40:40,230 --> 00:40:42,060
I file CSV non è stato utilizzato molto.

846
00:40:42,060 --> 00:40:45,960
Ma è stato utilizzato indirettamente in pset7 come
bene parlando con Yahoo Finance.

847
00:40:45,960 --> 00:40:49,330
>> Ma CSV è proprio come un file di Excel, ma
super semplice, in cui le colonne sono

848
00:40:49,330 --> 00:40:54,010
solo demarked da virgole all'interno
di un file di testo altrimenti.

849
00:40:54,010 --> 00:40:56,740
E l'utilizzo di un database SQL è
un po 'più convincente.

850
00:40:56,740 --> 00:41:00,060
E 'un lato positivo, perché si ottiene cose
come selezionare e inserire ed eliminare.

851
00:41:00,060 --> 00:41:03,790
E si ottiene, presumibilmente, indici
MySQL ed altri database, come

852
00:41:03,790 --> 00:41:07,510
Oracle, costruire per voi in memoria, che
significa che il vostro prescelto non è probabilmente

853
00:41:07,510 --> 00:41:09,000
sta per essere top lineare verso il basso.

854
00:41:09,000 --> 00:41:11,300
In realtà sarà qualcosa di
come la ricerca binaria o qualcosa del genere

855
00:41:11,300 --> 00:41:12,520
simile nello spirito.

856
00:41:12,520 --> 00:41:13,930
Quindi sono generalmente più veloci.

857
00:41:13,930 --> 00:41:16,040
>> Ma un aspetto negativo è che
è solo più lavoro.

858
00:41:16,040 --> 00:41:16,730
E 'uno sforzo maggiore.

859
00:41:16,730 --> 00:41:18,140
Dovete capire database.

860
00:41:18,140 --> 00:41:18,940
È necessario configurarlo.

861
00:41:18,940 --> 00:41:20,840
Hai bisogno di un server per l'esecuzione
quest'ultima il.

862
00:41:20,840 --> 00:41:22,750
È necessario capire
come configurarlo.

863
00:41:22,750 --> 00:41:24,930
Quindi questi sono solo questi
tipi di trade-off.

864
00:41:24,930 --> 00:41:27,860
Considerando che un file CSV, è possibile
creare con gedit.

865
00:41:27,860 --> 00:41:28,770
E tu sei a posto.

866
00:41:28,770 --> 00:41:31,550
Non c'è complessità di là di questo.

867
00:41:31,550 --> 00:41:34,870
>> Utilizzando un trie anziché una tabella hash
con concatenazioni separate per memorizzare un

868
00:41:34,870 --> 00:41:37,490
dizionario delle parole che ricordano
di pset5.

869
00:41:37,490 --> 00:41:42,480
Quindi cerca un rialzo, in teoria
almeno, è ciò?

870
00:41:42,480 --> 00:41:46,380
Costante di tempo, almeno se siete
hashing su ciascuno dei singoli

871
00:41:46,380 --> 00:41:48,990
le lettere in una parola, come voi
potrebbe avere per pset5.

872
00:41:48,990 --> 00:41:52,720
Che potrebbe essere cinque, sei hash
hash se ci sono cinque o sei

873
00:41:52,720 --> 00:41:53,900
lettere nella parola.

874
00:41:53,900 --> 00:41:54,580
E questo è abbastanza buono.

875
00:41:54,580 --> 00:41:56,910
E se c'è un limite superiore come
lungo le vostre parole potrebbero essere, che è

876
00:41:56,910 --> 00:41:59,320
tempo infatti asintoticamente costante.

877
00:41:59,320 --> 00:42:05,180
>> Considerando che una tabella hash con separata
concatenamento, il problema lì con quel

878
00:42:05,180 --> 00:42:09,070
tipo di struttura dati è che l'
prestazioni di algoritmi di solito

879
00:42:09,070 --> 00:42:12,700
dipende dal numero di cose
già nella struttura dati.

880
00:42:12,700 --> 00:42:15,660
E questo è sicuramente il caso di
catene, per cui il più roba metti

881
00:42:15,660 --> 00:42:18,800
in una tabella hash, il più quelle
catene andare, il che significa che nel peggiore

882
00:42:18,800 --> 00:42:21,960
caso, la cosa si potrebbe essere alla ricerca di
è fino alla fine di una

883
00:42:21,960 --> 00:42:26,000
di quelle catene, che di fatto
devolve in qualcosa di lineare.

884
00:42:26,000 --> 00:42:29,450
>> Ora, in pratica, potrebbe assolutamente
essere il caso che una tabella hash con

885
00:42:29,450 --> 00:42:32,820
catene è più veloce di un corrispondente
attuazione trie.

886
00:42:32,820 --> 00:42:35,570
Ma questo è per vari motivi, tra
che sono tentativi utilizzano un sacco di

887
00:42:35,570 --> 00:42:39,240
memoria che può, infatti, le cose con calma
giù, perché non si ottiene bello

888
00:42:39,240 --> 00:42:42,410
vantaggi di qualcosa che si chiama caching,
dove le cose che sono vicine tra loro

889
00:42:42,410 --> 00:42:45,420
in memoria può essere letta
spesso più rapidamente.

890
00:42:45,420 --> 00:42:48,180
E a volte si può trovare con
davvero una buona funzione di hash.

891
00:42:48,180 --> 00:42:51,060
Anche se si deve sprecare un po 'di
memoria, si potrebbe, infatti, essere in grado di

892
00:42:51,060 --> 00:42:54,430
trovare le cose in fretta e non
così male come linearmente.

893
00:42:54,430 --> 00:42:58,410
>> Così, in breve, non c'era necessariamente
con qualsiasi di questi uno o anche due

894
00:42:58,410 --> 00:43:00,050
cose specifiche che stavamo cercando.

895
00:43:00,050 --> 00:43:03,080
Davvero nulla convincente
come un rialzo e al ribasso

896
00:43:03,080 --> 00:43:04,800
generalmente attirato la nostra attenzione.

897
00:43:04,800 --> 00:43:11,840
>> ROB BOWDEN: Quindi per il rialzo, abbiamo fatto
Non accettare il suo "più veloce". Voi

898
00:43:11,840 --> 00:43:14,540
dovuto dire qualcosa al riguardo.

899
00:43:14,540 --> 00:43:17,910
Anche se lei ha detto teoricamente più veloce,
sapevamo che tipo di capito

900
00:43:17,910 --> 00:43:19,470
che è 0 a 1.

901
00:43:19,470 --> 00:43:22,820
E tabella hash, in teoria,
non è 0 a 1.

902
00:43:22,820 --> 00:43:26,550
La menzione nulla di runtime
generalmente ottenuto i punti.

903
00:43:26,550 --> 00:43:32,640
Ma "più veloce", la maggior parte delle soluzioni su
la grande tavola che sono stati tentativi erano

904
00:43:32,640 --> 00:43:34,990
oggettivamente più lento di soluzioni
che erano tabelle hash.

905
00:43:34,990 --> 00:43:37,250
Così veloce in sé e per sé
non è proprio vero.

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> DAVID J. MALAN: Dom de dom dom.

908
00:43:44,380 --> 00:43:46,686
Probabilmente sono l'unico che realizza
è così che questo dovrebbe

909
00:43:46,686 --> 00:43:47,500
essere pronunciata, giusto?

910
00:43:47,500 --> 00:43:50,400
>> ROB BOWDEN: non avevo davvero idea.

911
00:43:50,400 --> 00:43:51,650
>> DAVID J. MALAN: Ha fatto
senso nella mia testa.

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> ROB BOWDEN: sto facendo questo.

914
00:43:57,580 --> 00:43:58,020
OK.

915
00:43:58,020 --> 00:44:04,243
Quindi questo è quello dove si doveva disegnare
il diagramma simile a voi potrebbe

916
00:44:04,243 --> 00:44:06,040
hanno visto negli esami precedenti.

917
00:44:06,040 --> 00:44:12,200
Così facciamo solo un'occhiata a questo.

918
00:44:12,200 --> 00:44:18,170
Quindi dal nodo HTML, abbiamo due
bambini, la testa ed il corpo.

919
00:44:18,170 --> 00:44:20,570
Così abbiamo Branch - testa e il corpo.

920
00:44:20,570 --> 00:44:22,280
La testa ha un tag title.

921
00:44:22,280 --> 00:44:23,710
Quindi abbiamo un titolo.

922
00:44:23,710 --> 00:44:28,450
>> Ora, l'unica cosa che un sacco di gente
dimenticato è che questi nodi di testo sono

923
00:44:28,450 --> 00:44:30,430
elementi all'interno di questo albero.

924
00:44:30,430 --> 00:44:36,260
Così qui ci capita di disegnarli come ovali
per differenziarli da questi

925
00:44:36,260 --> 00:44:37,380
tipi di nodi.

926
00:44:37,380 --> 00:44:41,450
Ma notate anche qui abbiamo top,
centro e in basso finirà per essere

927
00:44:41,450 --> 00:44:42,560
nodi di testo.

928
00:44:42,560 --> 00:44:46,250
Così dimenticare quelli era un po '
di un errore comune.

929
00:44:46,250 --> 00:44:48,770
>> Il corpo ha tre figli -
questi tre div.

930
00:44:48,770 --> 00:44:53,340
Così div, div, div e poi il testo
figli nodi di quei div.

931
00:44:53,340 --> 00:44:55,900
Questo è più o meno lo
per che domande.

932
00:44:55,900 --> 00:44:57,860
>> DAVID J. MALAN: E vale la pena notare,
anche se non ci soffermiamo su queste

933
00:44:57,860 --> 00:45:01,040
dettagli il tempo che passiamo su
JavaScript, che l'ordine fa, in

934
00:45:01,040 --> 00:45:02,290
Infatti, la materia tecnicamente.

935
00:45:02,290 --> 00:45:06,330
Quindi, se la testa viene prima il corpo nel
HTML, allora dovrebbe comparire il

936
00:45:06,330 --> 00:45:08,860
sinistra del corpo nel DOM reale.

937
00:45:08,860 --> 00:45:12,265
Che la sua è, in generale, solo Cordiali saluti,
qualcosa chiamato nell'ordine del documento, in cui

938
00:45:12,265 --> 00:45:13,260
lo fa materia.

939
00:45:13,260 --> 00:45:17,470
E se tu fossi implementa un parser,
un programma che legge HTML in costruzione

940
00:45:17,470 --> 00:45:20,960
l'albero in memoria, ad essere onesti,
questo è probabilmente quello che intuitivamente

941
00:45:20,960 --> 00:45:24,720
fare comunque - dall'alto verso il basso,
da sinistra a destra.

942
00:45:24,720 --> 00:45:26,116
>> ROB BOWDEN: domande su quello?

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
Devo fare il prossimo?

945
00:45:30,000 --> 00:45:32,380
>> DAVID J. MALAN: Certo.

946
00:45:32,380 --> 00:45:33,810
>> ROB BOWDEN: OK.

947
00:45:33,810 --> 00:45:39,320
Quindi questo è il sovraccarico del buffer
questione attacco.

948
00:45:39,320 --> 00:45:43,740
La cosa principale da riconoscere: ecco,
bene, come potrebbe un trucco avversario

949
00:45:43,740 --> 00:45:46,170
questo programma in esecuzione
codice arbitrario?

950
00:45:46,170 --> 00:45:51,860
Così argv1, la prima riga di comando
argomento di questo programma, che può essere

951
00:45:51,860 --> 00:45:53,920
arbitrariamente lungo.

952
00:45:53,920 --> 00:45:59,160
Ma qui stiamo usando memcpy per copiare
argv1, che qui è bar.

953
00:45:59,160 --> 00:46:00,165
Stiamo passando come argomento.

954
00:46:00,165 --> 00:46:02,050
E così sta prendendo sulla barra di nome.

955
00:46:02,050 --> 00:46:08,040
>> Quindi stiamo memcpying bar
in questo buffer c.

956
00:46:08,040 --> 00:46:09,400
Quanti byte stiamo copiando?

957
00:46:09,400 --> 00:46:14,040
Beh, tuttavia molti byte bar succede a
essere in uso, la lunghezza di tale argomento.

958
00:46:14,040 --> 00:46:17,930
Ma c è largo solo 12 byte.

959
00:46:17,930 --> 00:46:22,280
Quindi, se digitiamo un argomento della riga di comando
che è più lungo di 12 byte, siamo

960
00:46:22,280 --> 00:46:25,470
andando a straripare questo
particolare buffer.

961
00:46:25,470 --> 00:46:31,000
Ora, come potrebbe un avversario ingannare l'
programmare in esecuzione di codice arbitrario?

962
00:46:31,000 --> 00:46:34,910
>> Quindi ricorda che qui
principale sta chiamando foo.

963
00:46:34,910 --> 00:46:37,340
E così poi chiamate principali foo.

964
00:46:37,340 --> 00:46:40,408
Cerchiamo di disegnare questo.

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
Quindi abbiamo il nostro stack.

967
00:46:46,990 --> 00:46:49,090
Ed principale ha uno stack frame
nella parte inferiore.

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
Ad un certo punto, le chiamate principali foo.

970
00:46:53,250 --> 00:46:55,390
Ebbene, subito, chiamate principali foo.

971
00:46:55,390 --> 00:46:57,130
E così foo ottiene il proprio stack frame.

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> Ora, a un certo punto, foo
sta per tornare.

974
00:47:02,220 --> 00:47:06,810
E andò ritorni foo, abbiamo bisogno di sapere a
quale linea di codice all'interno di noi principale

975
00:47:06,810 --> 00:47:10,610
erano per sapere dove
dobbiamo riprendere principale.

976
00:47:10,610 --> 00:47:13,100
Possiamo chiamare foo da tutta una
mucchio di luoghi diversi.

977
00:47:13,100 --> 00:47:14,620
Come facciamo a sapere dove tornare?

978
00:47:14,620 --> 00:47:16,460
Bene, abbiamo bisogno di memorizzare che da qualche parte.

979
00:47:16,460 --> 00:47:23,010
>> Così da qualche parte proprio qui, archiviamo
dove dovremmo tornare a una volta

980
00:47:23,010 --> 00:47:24,070
foo ritorni.

981
00:47:24,070 --> 00:47:26,350
E questo è l'indirizzo di ritorno.

982
00:47:26,350 --> 00:47:30,490
Così come un avversario potrebbe sfruttare
di ciò è il fatto che

983
00:47:30,490 --> 00:47:37,550
questo buffer c è immagazzinato, LET'S
dire, proprio qui è c.

984
00:47:37,550 --> 00:47:39,690
Quindi abbiamo 12 byte per c.

985
00:47:39,690 --> 00:47:40,540
Questo è c.

986
00:47:40,540 --> 00:47:43,030
E questo è l'anello stack di foo.

987
00:47:43,030 --> 00:47:49,970
Quindi, se l'utente malintenzionato entra più
byte di 12 o entrano in un comando

988
00:47:49,970 --> 00:47:54,570
argomento della linea che è più lungo di 12
personaggi, allora stiamo andando a

989
00:47:54,570 --> 00:47:57,540
traboccare questo buffer.

990
00:47:57,540 --> 00:47:59,910
>> Possiamo andare avanti.

991
00:47:59,910 --> 00:48:02,220
E a un certo punto, andiamo lontano
basta che iniziamo

992
00:48:02,220 --> 00:48:05,120
sovrascrivendo l'indirizzo di ritorno.

993
00:48:05,120 --> 00:48:08,310
Quindi, una volta che sovrascrivere l'indirizzo di ritorno,
questo significa che quando foo

994
00:48:08,310 --> 00:48:14,220
ritorna, stiamo tornando ovunque l'
utente malintenzionato sta dicendo a da

995
00:48:14,220 --> 00:48:19,490
qualsiasi valore è entrato, con qualsiasi
caratteri che l'utente inserito.

996
00:48:19,490 --> 00:48:24,320
E così, se l'utente malintenzionato è in corso
particolarmente intelligente, può avere questo

997
00:48:24,320 --> 00:48:29,255
tornare da qualche parte nel printDef
funzione o da qualche parte nel malloc

998
00:48:29,255 --> 00:48:31,830
funzione, solo ovunque arbitraria.

999
00:48:31,830 --> 00:48:38,420
>> Ma ancora più intelligente è quello che se ha
l'utente ritornare al proprio qui.

1000
00:48:38,420 --> 00:48:41,920
E poi si inizia l'esecuzione
questi come linee di codice.

1001
00:48:41,920 --> 00:48:46,610
A quel punto, l'utente può immettere
quello che vuole in questa regione.

1002
00:48:46,610 --> 00:48:52,210
E lui ha il controllo completo
sopra il vostro programma.

1003
00:48:52,210 --> 00:48:53,460
Domande su questo?

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
Quindi la domanda successiva è completa l'
reimplementazione di foo in modo tale

1006
00:49:00,970 --> 00:49:02,620
che non è più vulnerabile.

1007
00:49:02,620 --> 00:49:03,870
>> Quindi ci sono un paio di modi
avresti potuto fare questo.

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
Abbiamo ancora solo c
essendo di lunghezza 12.

1010
00:49:13,330 --> 00:49:16,480
Si potrebbe avere modificato questo
come parte della soluzione.

1011
00:49:16,480 --> 00:49:18,930
Abbiamo anche aggiunto un controllo per fare
Assicurarsi bar non era nulla.

1012
00:49:18,930 --> 00:49:24,460
Anche se non hai bisogno
che per il credito pieno.

1013
00:49:24,460 --> 00:49:27,690
Quindi stiamo controllando prima la
lunghezza della stringa di bar.

1014
00:49:27,690 --> 00:49:31,650
Se è maggiore di 12, allora
realtà non non fare la copia.

1015
00:49:31,650 --> 00:49:33,010
Ecco, questo è un modo di risolverlo.

1016
00:49:33,010 --> 00:49:36,750
>> Un altro modo di fissaggio è invece
avendo c sia solo di lunghezza 12, l'hanno

1017
00:49:36,750 --> 00:49:39,310
essere di lunghezza strlen (bar).

1018
00:49:39,310 --> 00:49:43,370
Un altro modo di fissaggio è
in realtà solo ritorno.

1019
00:49:43,370 --> 00:49:46,690
Quindi, se si fosse appena deciso di eliminare tutti
questo, se si fosse appena cancellato tutti

1020
00:49:46,690 --> 00:49:51,830
righe di codice, si avrebbero ottenuto
pieno credito, poiché questa funzione

1021
00:49:51,830 --> 00:49:54,150
in realtà non realizzare nulla.

1022
00:49:54,150 --> 00:49:57,650
E 'copiare la riga di comando
argomento in qualche array in

1023
00:49:57,650 --> 00:49:59,960
il suo stack frame locale.

1024
00:49:59,960 --> 00:50:01,310
E poi la cosa sta tornando.

1025
00:50:01,310 --> 00:50:04,020
E qualunque cosa compiuta è andato.

1026
00:50:04,020 --> 00:50:09,740
Quindi ritorno è stato anche un sufficiente
modo di ottenere credito pieno.

1027
00:50:09,740 --> 00:50:13,425
>> DAVID J. MALAN: Non è proprio lo spirito di
la domanda ma accettabile per la

1028
00:50:13,425 --> 00:50:15,580
spec comunque.

1029
00:50:15,580 --> 00:50:18,260
>> ROB BOWDEN: Domande sulla niente di tutto questo?

1030
00:50:18,260 --> 00:50:22,270
L'unica cosa che almeno
necessaria per avere la compilazione del codice.

1031
00:50:22,270 --> 00:50:24,810
Quindi, anche se tecnicamente non si è
vulnerabili se il codice non

1032
00:50:24,810 --> 00:50:29,130
compilare, non abbiamo accettiamo che.

1033
00:50:29,130 --> 00:50:31,350
Nessuna domanda?

1034
00:50:31,350 --> 00:50:33,320
OK.

1035
00:50:33,320 --> 00:50:34,580
>> DAVID J. MALAN: Volete
dire questo titolo?

1036
00:50:34,580 --> 00:50:37,230
>> ROB BOWDEN: No.

1037
00:50:37,230 --> 00:50:40,470
>> David J. MALAN: Quindi, in questa, questa
era sia una buona notizia o una cattiva notizia.

1038
00:50:40,470 --> 00:50:43,870
Questo è letteralmente lo stesso problema
come il primo quiz.

1039
00:50:43,870 --> 00:50:46,140
Ed è quasi la stessa
problema come pset1.

1040
00:50:46,140 --> 00:50:49,980
Ma è stato volutamente semplificato per essere
una piramide più semplice, che può essere

1041
00:50:49,980 --> 00:50:52,330
risolto con un po '
semplice iterazione.

1042
00:50:52,330 --> 00:50:55,680
E in realtà, ciò che noi stavamo a
qui non era tanto la logica,

1043
00:50:55,680 --> 00:50:58,100
perché probabilmente, a questo punto, siete
più comodo di quello che erano

1044
00:50:58,100 --> 00:51:01,850
in settimana uno con i cicli for o perché loop,
ma in realtà per prendere in giro a parte che

1045
00:51:01,850 --> 00:51:04,790
sei un po agio con la
nozione che PHP non è solo quello

1046
00:51:04,790 --> 00:51:05,290
programmazione.

1047
00:51:05,290 --> 00:51:07,820
Si può effettivamente essere utilizzato come un linguaggio
scrivere programmi da linea di comando.

1048
00:51:07,820 --> 00:51:10,060
>> E in effetti, questo è quello che stavamo cercando
per attirare la vostra attenzione.

1049
00:51:10,060 --> 00:51:12,060
Questo è un programma PHP a riga di comando.

1050
00:51:12,060 --> 00:51:16,690
Quindi, il codice C qui, mentre corretto
in C, non correggere per PHP.

1051
00:51:16,690 --> 00:51:17,940
Ma il codice è davvero la stessa.

1052
00:51:17,940 --> 00:51:21,720
Se si confrontano le soluzioni per Quiz
0 contro il Quiz 1, vi accorgerete che

1053
00:51:21,720 --> 00:51:25,630
è quasi identico, tranne
alcuni segni del dollaro e per l'

1054
00:51:25,630 --> 00:51:27,250
assenza di un tipo di dati.

1055
00:51:27,250 --> 00:51:31,720
In particolare, se diamo uno sguardo qui,
vedrai che iteriamo, in questo

1056
00:51:31,720 --> 00:51:33,730
caso, da 1 a 7.

1057
00:51:33,730 --> 00:51:34,910
>> Avremmo potuto fare lo 0 indice.

1058
00:51:34,910 --> 00:51:37,320
Ma a volte, penso che sia solo
mentalmente più facile pensare a cose

1059
00:51:37,320 --> 00:51:38,200
da 1 a 7.

1060
00:51:38,200 --> 00:51:40,300
Se si desidera che un blocco, poi due
blocchi, poi tre, poi

1061
00:51:40,300 --> 00:51:41,770
dot, dot, dot sette.

1062
00:51:41,770 --> 00:51:45,960
Abbiamo j essere inizializzato a 1
e poi contare su un massimo di i.

1063
00:51:45,960 --> 00:51:48,150
E tutto qui è
altrimenti identico.

1064
00:51:48,150 --> 00:51:49,790
Ma degni di nota sono
un paio di cose.

1065
00:51:49,790 --> 00:51:53,230
Noi vi diamo queste due righe, questo primo
uno, goffamente nominato come una faccenda

1066
00:51:53,230 --> 00:51:54,560
per il colpo secco.

1067
00:51:54,560 --> 00:51:58,770
E che specifica solo il percorso, la
cartella, in cui un programma può essere

1068
00:51:58,770 --> 00:52:02,160
scoperto che si desidera utilizzare
interpretare questo file.

1069
00:52:02,160 --> 00:52:04,710
>> E poi la riga dopo che, di
naturalmente, significa entrare in modalità PHP.

1070
00:52:04,710 --> 00:52:07,740
E la linea in fondo
significa uscire dalla modalità PHP.

1071
00:52:07,740 --> 00:52:09,740
E questo funziona, in generale, con
interpretato lingue.

1072
00:52:09,740 --> 00:52:14,370
È un po 'fastidioso se si scrive un
programma in un file chiamato foo.php.

1073
00:52:14,370 --> 00:52:17,320
E poi gli utenti devono semplicemente
ricordare, OK, per eseguire questo programma, ho

1074
00:52:17,320 --> 00:52:22,320
necessario digitare "spazio php foo.php." Tipo
di fastidioso se non altro.

1075
00:52:22,320 --> 00:52:25,270
E rivela anche che il programma
è scritto in PHP, che non è tutto

1076
00:52:25,270 --> 00:52:27,060
che illuminante per l'utente.

1077
00:52:27,060 --> 00:52:30,100
>> Quindi, è possibile rimuovere il. Php tutto
richiamare da lezione.

1078
00:52:30,100 --> 00:52:35,690
E si può effettivamente fare. / Pippo se
hai chmodded esso rendendolo

1079
00:52:35,690 --> 00:52:36,500
eseguibile.

1080
00:52:36,500 --> 00:52:39,630
Così chmod a + x pippo avrebbe fatto.

1081
00:52:39,630 --> 00:52:41,460
E se anche si aggiunge la baracca qui.

1082
00:52:41,460 --> 00:52:45,320
Ma in realtà, il problema stava a
stampare qualcosa di simile.

1083
00:52:45,320 --> 00:52:51,100
No HTML, nessun codice C certamente,
solo alcuni PHP.

1084
00:52:51,100 --> 00:52:54,100
Così Milo poi tornato in problema 25.

1085
00:52:54,100 --> 00:52:58,050
E nel 25, è stata data la seguente
codice scheletro, che era un

1086
00:52:58,050 --> 00:52:59,730
abbastanza semplice pagina web.

1087
00:52:59,730 --> 00:53:04,230
E la parte succosa HTML-saggio era giù
qui, dove abbiamo all'interno del corpo

1088
00:53:04,230 --> 00:53:09,160
una forma che ha ID univoco di ingressi
all'interno del quale era due ingressi, uno

1089
00:53:09,160 --> 00:53:11,950
con un'idea di nome, una
con un'idea di tasto.

1090
00:53:11,950 --> 00:53:14,240
>> Il primo era tipo di testo, il
secondo di tipo submit.

1091
00:53:14,240 --> 00:53:16,930
E così vi abbiamo dato, in realtà, più
ingredienti che avete avuto bisogno, solo così

1092
00:53:16,930 --> 00:53:19,230
voi ragazzi avevano opzioni con le quali
per risolvere questo problema.

1093
00:53:19,230 --> 00:53:21,130
Non è strettamente necessario
tutti questi ID.

1094
00:53:21,130 --> 00:53:23,580
Ma permette di risolvere
in modi diversi.

1095
00:53:23,580 --> 00:53:27,050
E in cima, si noti che
l'obiettivo era quello di innescare

1096
00:53:27,050 --> 00:53:27,960
una finestra come questa -

1097
00:53:27,960 --> 00:53:28,780
Ciao, Milo! -

1098
00:53:28,780 --> 00:53:31,270
a pop-up nel browser utilizzando
il super semplice, se

1099
00:53:31,270 --> 00:53:33,190
non brutto, funzione di avviso.

1100
00:53:33,190 --> 00:53:37,480
E così, in ultima analisi, questo si riduce
concettualmente ad ascoltare qualche modo per

1101
00:53:37,480 --> 00:53:41,290
osservazioni del lato client forma
, Non il lato server, in qualche modo

1102
00:53:41,290 --> 00:53:45,640
in risposta alla suddetta presentazione da
afferrando il valore che l'utente ha digitato

1103
00:53:45,640 --> 00:53:50,120
per il campo del nome, e poi
visualizzarlo nel corpo di un avviso.

1104
00:53:50,120 --> 00:53:53,460
>> Quindi un modo che si può fare questo è con
jQuery, che sembra un po '

1105
00:53:53,460 --> 00:53:56,880
sintatticamente perplessi in un primo momento.

1106
00:53:56,880 --> 00:54:00,760
È possibile farlo con il codice DOM puro -
document.getelement da ID.

1107
00:54:00,760 --> 00:54:02,530
Ma diamo un'occhiata a questa versione.

1108
00:54:02,530 --> 00:54:05,110
Ho un paio di importanti
linee prima.

1109
00:54:05,110 --> 00:54:09,460
Così uno, disponiamo di questa linea, che è
identico a quello che si potrebbe avere visto

1110
00:54:09,460 --> 00:54:13,830
in, credo, form2.html
dalla classe in settimana 9.

1111
00:54:13,830 --> 00:54:16,960
E questo è solo dicendo, eseguire
il codice seguente

1112
00:54:16,960 --> 00:54:18,430
il documento è pronto.

1113
00:54:18,430 --> 00:54:21,770
Questo essere importante solo perché
Le pagine HTML vengono lette dall'alto verso il

1114
00:54:21,770 --> 00:54:23,280
in basso, da sinistra a destra.

1115
00:54:23,280 --> 00:54:27,910
>> E quindi, se si tenta di fare
qualcosa nel codice qui a qualche DOM

1116
00:54:27,910 --> 00:54:31,560
elemento, alcuni tag HTML, che è giù
Qui, si sta facendo troppo presto,

1117
00:54:31,560 --> 00:54:34,220
perché questo ha nemmeno
stato letto in memoria.

1118
00:54:34,220 --> 00:54:37,740
Così dicendo questo document.ready
linea, stiamo dicendo,

1119
00:54:37,740 --> 00:54:39,040
ecco qualche codice del browser.

1120
00:54:39,040 --> 00:54:42,440
Ma non eseguire questo fino a quando l'intero
documento è pronto, pari al DOM

1121
00:54:42,440 --> 00:54:44,320
albero esiste in memoria.

1122
00:54:44,320 --> 00:54:47,110
Questo è un po 'più
semplice, se sintatticamente un

1123
00:54:47,110 --> 00:54:51,890
po 'diverso, dove sto dicendo, afferrare
l'elemento HTML il cui unico

1124
00:54:51,890 --> 00:54:53,560
identificatore è ingressi.

1125
00:54:53,560 --> 00:54:56,220
Questo è ciò che l'hash tag
denota, l'ID univoco.

1126
00:54:56,220 --> 00:54:58,070
E poi sto chiamando. Presentare.

1127
00:54:58,070 --> 00:55:01,660
>> Quindi. Presentare qui è una funzione, altrimenti
noto come metodo, che è

1128
00:55:01,660 --> 00:55:05,850
all'interno dell'oggetto sulla mano sinistra
lato c'è che non ho evidenziare.

1129
00:55:05,850 --> 00:55:08,990
Quindi, se pensate di input come un oggetto
nella memoria - e infatti lo è.

1130
00:55:08,990 --> 00:55:10,440
E 'un nodo in un albero -

1131
00:55:10,440 --> 00:55:16,580
. Presentare mezzi quando questo form con
questo ID è presentata, eseguire

1132
00:55:16,580 --> 00:55:17,700
il seguente codice.

1133
00:55:17,700 --> 00:55:20,290
Non mi interessa che cosa il nome del
funzione è sto esecuzione.

1134
00:55:20,290 --> 00:55:23,760
Così qui sto usando, come prima, ciò che è
chiamato la funzione lambda o un

1135
00:55:23,760 --> 00:55:24,720
funzione anonima.

1136
00:55:24,720 --> 00:55:27,640
Non è affatto intellettualmente
interessante diverso da quello che non ha un nome,

1137
00:55:27,640 --> 00:55:30,220
che va bene se sei solo
mai andare a chiamare una volta.

1138
00:55:30,220 --> 00:55:34,490
E dentro ci ho effettivamente gestire
l'invio del modulo.

1139
00:55:34,490 --> 00:55:36,810
Io prima dichiarare una variabile
chiamato valore.

1140
00:55:36,810 --> 00:55:40,610
E allora qual è l'effetto di questa
evidenziato porzione qui ora?

1141
00:55:40,610 --> 00:55:44,755
Che cosa fare in un
alto livello per me?

1142
00:55:44,755 --> 00:55:48,539
>> AUDIENCE: Ottiene il valore che l'
l'utente non ha nel codice HTML qui sotto.

1143
00:55:48,539 --> 00:55:50,920
Si ottiene che ID e poi
rileva che il valore di esso.

1144
00:55:50,920 --> 00:55:51,590
>> DAVID J. MALAN: Esattamente.

1145
00:55:51,590 --> 00:55:54,300
Si afferra il nodo, la cui unica
identificatore è il nome.

1146
00:55:54,300 --> 00:55:56,900
Si ottiene il valore in esso, che
è, presumibilmente, ciò che l'utente

1147
00:55:56,900 --> 00:55:58,190
lui o lei digitato.

1148
00:55:58,190 --> 00:56:01,020
E poi memorizza che nella
variabile chiamata valore.

1149
00:56:01,020 --> 00:56:03,720
Per inciso, si potrebbe avere anche
fatto un po 'diverso.

1150
00:56:03,720 --> 00:56:09,250
Assolutamente accettabile facendo qualcosa
valore bugia var ottiene

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
Ed è per questo che è un po '
noioso non utilizzare jQuery.

1154
00:56:15,460 --> 00:56:16,710
"Name" value..

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
Quindi assolutamente accettabile.

1157
00:56:19,620 --> 00:56:22,770
Diversi modi per farlo. jQuery solo
tende ad essere un po 'più succinta e

1158
00:56:22,770 --> 00:56:25,230
sicuramente più popolare
tra i programmatori.

1159
00:56:25,230 --> 00:56:27,590
>> Ora, io sto facendo un po 'di sanità mentale
controllare, perché nel problema

1160
00:56:27,590 --> 00:56:30,820
dichiarazione abbiamo esplicitamente detto, se il
utente non ha ancora digitato suo

1161
00:56:30,820 --> 00:56:32,580
nome, non mostrano una avvisi.

1162
00:56:32,580 --> 00:56:35,390
Ma è possibile verificare che, appena
controllando la stringa vuota per un

1163
00:56:35,390 --> 00:56:37,850
quote-unquote se c'è
nulla in realtà c'è.

1164
00:56:37,850 --> 00:56:40,880
Ma se non è uguale a quote-unquote,
Voglio chiamare avvisi.

1165
00:56:40,880 --> 00:56:45,610
E la parte interessante è che
stiamo usando l'operatore più, che

1166
00:56:45,610 --> 00:56:48,130
fa che cosa in JavaScript?

1167
00:56:48,130 --> 00:56:48,740
Concatenare.

1168
00:56:48,740 --> 00:56:50,690
Così è come phps operatore punto.

1169
00:56:50,690 --> 00:56:52,820
Stessa idea, sintassi leggermente diversa.

1170
00:56:52,820 --> 00:56:55,280
E sto solo creando la stringa che
avete visto la schermata -

1171
00:56:55,280 --> 00:56:57,750
Ciao, così e così.

1172
00:56:57,750 --> 00:56:59,200
>> E poi l'ultimo dettaglio è questo.

1173
00:56:59,200 --> 00:57:04,970
Perché torno falso interno
di questa funzione anonima?

1174
00:57:04,970 --> 00:57:07,420
>> AUDIENCE: Non c'è nessun valore.

1175
00:57:07,420 --> 00:57:09,380
Hai messo in forma.

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
Dice solo, se il valore non è
pari a vuoto, allora fatelo.

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
C'era un vuoto in questo mezzo.

1180
00:57:20,940 --> 00:57:21,170
>> DAVID J. MALAN: OK.

1181
00:57:21,170 --> 00:57:21,640
Attenzione però.

1182
00:57:21,640 --> 00:57:22,830
Non c'è nessun altro qui.

1183
00:57:22,830 --> 00:57:25,510
E che il ritorno falso è al di fuori
del se le condizioni.

1184
00:57:25,510 --> 00:57:29,470
Quindi questo ha evidenziato linea, restituire false,
esegue qualunque cosa quando

1185
00:57:29,470 --> 00:57:32,310
il modulo viene inviato.

1186
00:57:32,310 --> 00:57:36,810
Cosa fa ritorno falso interno di questo
gestore di eventi, come viene chiamato,

1187
00:57:36,810 --> 00:57:38,450
l'evento in questione
essendo presentazione?

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> AUDIENCE: Perché
accade solo una volta.

1190
00:57:44,470 --> 00:57:45,320
>> DAVID J. MALAN: succede solo una volta.

1191
00:57:45,320 --> 00:57:46,821
Non proprio.

1192
00:57:46,821 --> 00:57:47,292
Sì?

1193
00:57:47,292 --> 00:57:50,589
>> AUDIENCE: Impedisce il modulo dal
sottoponendo al comportamento predefinito,

1194
00:57:50,589 --> 00:57:52,480
che renderebbe il ricaricamento della pagina.

1195
00:57:52,480 --> 00:57:53,110
>> DAVID J. MALAN: Esattamente.

1196
00:57:53,110 --> 00:57:56,490
Così sto sovraccaricare il termine presentare qui,
perché sto dicendo, la forma è

1197
00:57:56,490 --> 00:57:57,670
presentata.

1198
00:57:57,670 --> 00:58:02,240
Ma, come lei suggerisce, in realtà non è
stata presentata in modo HTTP vero.

1199
00:58:02,240 --> 00:58:06,870
Quando si fa clic su Invia, a causa della nostra
handler onSubmit, stiamo intercettando

1200
00:58:06,870 --> 00:58:09,040
che la presentazione forma per così dire.

1201
00:58:09,040 --> 00:58:11,290
Stiamo poi facendo le nostre cose
con il codice JavaScript.

1202
00:58:11,290 --> 00:58:14,070
Ma sto tornando volutamente false,
perché quello che io non voglio che accada un

1203
00:58:14,070 --> 00:58:18,430
frazione di secondo più tardi è per l'intero modulo
si da sottoporre al web

1204
00:58:18,430 --> 00:58:22,800
server con coppie di valori chiave cambiando
l'URL di essere qualcosa di simile

1205
00:58:22,800 --> 00:58:26,180
q = gatti o qualsiasi altra cosa che abbiamo fatto,
per esempio, in classe.

1206
00:58:26,180 --> 00:58:29,640
Io non voglio che ciò accada, perché
non c'è ascolto server per questo

1207
00:58:29,640 --> 00:58:30,690
modulo di presentazione.

1208
00:58:30,690 --> 00:58:32,320
E 'puramente fatto in codice JavaScript.

1209
00:58:32,320 --> 00:58:35,760
Ed è per questo che non ho nemmeno un
azione attributo sulla mia forma, perché io

1210
00:58:35,760 --> 00:58:38,870
non intendono per questo
mai andare al server.

1211
00:58:38,870 --> 00:58:40,780
>> Quindi è in corso di presentazione.

1212
00:58:40,780 --> 00:58:44,340
Ma stiamo intercettando quella forma
presentazione e prevenire il default

1213
00:58:44,340 --> 00:58:47,477
comportamento, che è effettivamente
andare fino in fondo al server.

1214
00:58:47,477 --> 00:58:48,730
>> AUDIENCE: Così mantenendolo client-side.

1215
00:58:48,730 --> 00:58:49,780
>> DAVID J. MALAN: Mantenere
esso lato client.

1216
00:58:49,780 --> 00:58:51,030
Esattamente.

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
Next up era la mia oh MySQL.

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> ROB BOWDEN: OK.

1221
00:59:00,430 --> 00:59:04,990
Quindi questa prima domanda è stata generalmente
di massima per le persone.

1222
00:59:04,990 --> 00:59:07,270
Anche se quelle successive sono andate meglio.

1223
00:59:07,270 --> 00:59:12,260
Così si doveva scegliere i dati corretti
tipi per entrambe queste colonne.

1224
00:59:12,260 --> 00:59:17,750
Ed entrambi hanno una certa
cose su di loro che

1225
00:59:17,750 --> 00:59:20,620
rendere la scelta difficile.

1226
00:59:20,620 --> 00:59:24,430
Quindi int non era un valido
tipo di numero.

1227
00:59:24,430 --> 00:59:29,410
Il motivo è un conto a 12 cifre
numero, un int non è abbastanza grande per

1228
00:59:29,410 --> 00:59:31,070
memorizzare le cifre totali.

1229
00:59:31,070 --> 00:59:36,570
Quindi una scelta valida sarebbe stato un grande
int se vi capita di sapere che.

1230
00:59:36,570 --> 00:59:42,090
Un'altra scelta avrebbe potuto essere
un campo char di lunghezza 12.

1231
00:59:42,090 --> 00:59:44,560
Quindi, o di coloro che avrebbero funzionato.

1232
00:59:44,560 --> 00:59:46,100
Int. no.

1233
00:59:46,100 --> 00:59:50,170
>> Ora, equilibrio, ripensare a pset7.

1234
00:59:50,170 --> 00:59:59,540
Così abbiamo specificamente usato decimale
memorizzare il valore delle azioni o -

1235
00:59:59,540 --> 01:00:00,550
>> DAVID J. MALAN: Cash.

1236
01:00:00,550 --> 01:00:01,060
>> ROB BOWDEN: Cash.

1237
01:00:01,060 --> 01:00:05,710
Abbiamo usato decimale per memorizzare la quantità di
denaro che l'utente ha attualmente.

1238
01:00:05,710 --> 01:00:10,950
Quindi la ragione che facciamo che è
perché, ricordate, galleggianti.

1239
01:00:10,950 --> 01:00:12,480
C'è virgola mobile in precisione.

1240
01:00:12,480 --> 01:00:18,200
Esso non può memorizzare precisamente la cassa
valori come vogliamo qui.

1241
01:00:18,200 --> 01:00:23,630
Quindi decimale è in grado di precisione negozio
qualcosa, dire, due decimali.

1242
01:00:23,630 --> 01:00:27,630
Ecco perché l'equilibrio, lo vogliamo
essere decimale e non galleggiare.

1243
01:00:27,630 --> 01:00:30,230
>> DAVID J. MALAN: E poi, troppo, anche se
avrebbe potuto essere abile in altri

1244
01:00:30,230 --> 01:00:32,760
contesti a cui pensare, forse questo
è una possibilità per un int.

1245
01:00:32,760 --> 01:00:34,420
Mi limiterò a tenere traccia di
cose in centesimi.

1246
01:00:34,420 --> 01:00:38,670
Perché abbiamo mostrato esplicitamente il default
valore dell'essere 100.00, che

1247
01:00:38,670 --> 01:00:40,380
significa che potrebbe essere solo un int.

1248
01:00:40,380 --> 01:00:45,310
E un altro sottigliezza troppo con il numero
era che non doveva

1249
01:00:45,310 --> 01:00:46,180
per essere una domanda trabocchetto.

1250
01:00:46,180 --> 01:00:49,860
Ma ricordare che un int in MySQL,
come in C, almeno nella

1251
01:00:49,860 --> 01:00:51,440
apparecchio, è a 32 bit.

1252
01:00:51,440 --> 01:00:53,960
E anche se noi non ci aspettiamo di
sapere esattamente quante cifre

1253
01:00:53,960 --> 01:00:56,910
mezzi, mi ricordo che il maggior numero
è possibile rappresentare potenzialmente

1254
01:00:56,910 --> 01:01:00,710
con un numero a 32 bit è più o meno che cosa?

1255
01:01:00,710 --> 01:01:02,760
>> Che numero possiamo sempre dire?

1256
01:01:02,760 --> 01:01:04,530
2 a 32, che è ciò che all'incirca?

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
Non è necessario conoscere con precisione.

1259
01:01:08,780 --> 01:01:10,580
Ma grosso modo è utile nella vita.

1260
01:01:10,580 --> 01:01:12,200
Si tratta di circa 4 miliardi.

1261
01:01:12,200 --> 01:01:14,430
Quindi abbiamo detto che un paio di volte.

1262
01:01:14,430 --> 01:01:16,360
So che ho detto che un paio di volte.

1263
01:01:16,360 --> 01:01:17,670
Ed è di circa 4 miliardi.

1264
01:01:17,670 --> 01:01:19,710
E questa è una buona regola
di pollice di sapere.

1265
01:01:19,710 --> 01:01:21,880
Se si dispone di 8 bit, 256
è il numero magico.

1266
01:01:21,880 --> 01:01:24,160
Se si dispone di 32 bit, 4
miliardi di prendere o lasciare.

1267
01:01:24,160 --> 01:01:27,140
Quindi, se avete appena annotate 4 miliardi,
vedrai che è meno cifre di

1268
01:01:27,140 --> 01:01:30,970
12, il che significa che non è chiaramente
sufficiente espressività per catturare una

1269
01:01:30,970 --> 01:01:34,220
Numero di conto a 12 cifre.

1270
01:01:34,220 --> 01:01:34,940
>> ROB BOWDEN: OK.

1271
01:01:34,940 --> 01:01:38,520
Così gli altri sono andati meglio.

1272
01:01:38,520 --> 01:01:40,900
Quindi supponiamo che la banca
impone un 20 dollari mensili

1273
01:01:40,900 --> 01:01:42,400
canone di manutenzione su tutti i conti.

1274
01:01:42,400 --> 01:01:45,506
Con quali query SQL potrebbe la banca
dedurre $ 20 da ogni conteggio, anche se

1275
01:01:45,506 --> 01:01:47,520
risulta in alcuni saldi negativi?

1276
01:01:47,520 --> 01:01:50,380
Quindi, fondamentalmente, ci sono quattro
principali tipi di query -

1277
01:01:50,380 --> 01:01:52,840
Inserisci, selezionare, aggiornare ed eliminare.

1278
01:01:52,840 --> 01:01:56,080
Allora cosa pensiamo di essere
intenzione di utilizzare qui?

1279
01:01:56,080 --> 01:01:57,000
Aggiornare.

1280
01:01:57,000 --> 01:01:58,260
>> Quindi diamo un'occhiata.

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
Così qui stiamo aggiornando.

1283
01:02:05,870 --> 01:02:09,900
Cosa tabella stiamo aggiornando account?

1284
01:02:09,900 --> 01:02:11,670
Così l'aggiornamento dei conti.

1285
01:02:11,670 --> 01:02:15,390
E poi la sintassi dice, cosa
nei conti stiamo aggiornando?

1286
01:02:15,390 --> 01:02:19,520
Beh, stiamo impostando saldo pari al
il valore corrente della bilancia meno 20.

1287
01:02:19,520 --> 01:02:22,860
Quindi questo aggiornerà tutte le righe
dei conti, sottraendo

1288
01:02:22,860 --> 01:02:26,250
$ 20 dalla bilancia.

1289
01:02:26,250 --> 01:02:29,260
>> DAVID J. MALAN: Un errore comune qui,
anche se a volte perdonato esso,

1290
01:02:29,260 --> 01:02:32,990
era di avere effettivamente il codice PHP qui
chiamando la funzione di query o la messa

1291
01:02:32,990 --> 01:02:35,460
virgolette attorno tutto ciò che
non ha bisogno di essere lì.

1292
01:02:35,460 --> 01:02:39,780
>> ROB BOWDEN: Ricordate che MySQL è
un linguaggio separato da PHP.

1293
01:02:39,780 --> 01:02:42,410
Ci capita di scrivere MySQL in PHP.

1294
01:02:42,410 --> 01:02:46,180
E PHP viene poi trasmette il
verso il server MySQL.

1295
01:02:46,180 --> 01:02:51,120
Ma non avete bisogno di PHP al fine di
comunicare con un server MySQL.

1296
01:02:51,120 --> 01:02:51,730
>> DAVID J. MALAN: Esattamente.

1297
01:02:51,730 --> 01:02:54,240
Quindi niente variabili con il segno del dollaro
dovrebbe essere in questo contesto.

1298
01:02:54,240 --> 01:02:59,550
Si può solo fare tutti i calcoli
all'interno del database.

1299
01:02:59,550 --> 01:03:00,080
>> ROB BOWDEN: OK.

1300
01:03:00,080 --> 01:03:01,300
Quindi il prossimo.

1301
01:03:01,300 --> 01:03:02,731
E 'questo il prossimo?

1302
01:03:02,731 --> 01:03:03,210
Già.

1303
01:03:03,210 --> 01:03:06,570
Quindi, con quello query SQL potrebbe la banca
recuperare i numeri di conto dei suoi

1304
01:03:06,570 --> 01:03:09,300
i clienti più ricchi, quelli con
saldi superiori a 1.000?

1305
01:03:09,300 --> 01:03:13,280
Quindi quale dei quattro tipi principali
stiamo andando a voler qui?

1306
01:03:13,280 --> 01:03:14,430
Selezionare.

1307
01:03:14,430 --> 01:03:16,650
Quindi vogliamo selezionare.

1308
01:03:16,650 --> 01:03:17,610
Cosa vogliamo selezionare?

1309
01:03:17,610 --> 01:03:19,380
Cosa colonna vogliamo selezionare?

1310
01:03:19,380 --> 01:03:20,970
Noi in particolare vuole
per selezionare il numero.

1311
01:03:20,970 --> 01:03:23,910
Ma se lei ha detto stella, abbiamo
anche ammesso che.

1312
01:03:23,910 --> 01:03:25,820
>> Quindi, selezionare il numero da quale tabella?

1313
01:03:25,820 --> 01:03:26,640
Conti.

1314
01:03:26,640 --> 01:03:28,370
E allora la condizione che vogliamo?

1315
01:03:28,370 --> 01:03:30,140
Dove saldo superiore a 1.000.

1316
01:03:30,140 --> 01:03:31,720
Abbiamo anche accettato una maggiore
o uguale.

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
Ultimo.

1319
01:03:36,190 --> 01:03:42,940
Con quali query SQL potrebbe la banca
chiudere, vale a dire, eliminare ogni account che

1320
01:03:42,940 --> 01:03:44,480
ha un saldo di € 0?

1321
01:03:44,480 --> 01:03:47,620
Quindi, quale dei quattro siamo
andando a voler usare?

1322
01:03:47,620 --> 01:03:48,320
Elimina.

1323
01:03:48,320 --> 01:03:50,180
Così la sintassi per questo?

1324
01:03:50,180 --> 01:03:51,890
Elimina dalla quale tavolo?

1325
01:03:51,890 --> 01:03:53,550
Conti.

1326
01:03:53,550 --> 01:03:55,790
E allora la condizione in cui
Vogliamo eliminare -

1327
01:03:55,790 --> 01:03:57,280
dove l'equilibrio è uguale a zero.

1328
01:03:57,280 --> 01:04:03,050
Quindi, eliminare tutte le righe di conti
dove il saldo è zero.

1329
01:04:03,050 --> 01:04:04,300
Domande su uno di questi?

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
Vuoi fare la fila?

1332
01:04:10,260 --> 01:04:11,200
>> DAVID J. MALAN: Guida coda.

1333
01:04:11,200 --> 01:04:17,110
Quindi, in questo, vi abbiamo dato un po '
struttura familiare che abbiamo esplorato un

1334
01:04:17,110 --> 01:04:20,450
po 'in classe insieme di struct,
che era un dato

1335
01:04:20,450 --> 01:04:21,910
struttura relativa nello spirito.

1336
01:04:21,910 --> 01:04:24,670
La differenza però con una coda è
che abbiamo dovuto ricordare che in qualche modo

1337
01:04:24,670 --> 01:04:27,900
era sul davanti della coda, in grande
parte in modo che potessimo fare più

1338
01:04:27,900 --> 01:04:30,530
uso efficiente della memoria, almeno
se stessimo usando un array.

1339
01:04:30,530 --> 01:04:35,460
>> Perché richiamo, se abbiamo un array, se,
per esempio, questo è il fronte

1340
01:04:35,460 --> 01:04:38,470
la coda, se mi trovo in coda qui,
e poi qualcuno si mette in linea

1341
01:04:38,470 --> 01:04:42,710
dietro di me, dietro di me, dietro di me, e
una persona esce di linea,

1342
01:04:42,710 --> 01:04:45,930
potrebbe, come abbiamo visto alcuni dei nostri umana
volontari in classe, hanno tutti

1343
01:04:45,930 --> 01:04:47,100
spostare in questo modo.

1344
01:04:47,100 --> 01:04:50,880
Ma in generale, avendo ognuno faccia
qualcosa non è il miglior uso del tempo

1345
01:04:50,880 --> 01:04:54,600
in un programma, perché significa che il
l'algoritmo è in esecuzione in quanto

1346
01:04:54,600 --> 01:04:56,520
tempo di esecuzione asintotico?

1347
01:04:56,520 --> 01:04:57,420
E 'lineare.

1348
01:04:57,420 --> 01:04:59,600
>> E mi sento come che una specie di stupido.

1349
01:04:59,600 --> 01:05:02,890
Se la persona successiva nella fila è quello
persona che si suppone di andare in

1350
01:05:02,890 --> 01:05:04,660
negozio, non tutti hanno
a muoversi insieme.

1351
01:05:04,660 --> 01:05:08,200
Basta che quella persona sia colto off
quando arriva il momento, per esempio.

1352
01:05:08,200 --> 01:05:09,870
Così possiamo risparmiare un po 'di tempo lì.

1353
01:05:09,870 --> 01:05:14,840
E così, per fare ciò, però, che i mezzi
che la testa della coda o l'

1354
01:05:14,840 --> 01:05:18,060
anteriore della coda sta per
progressivamente spostare sempre più in profondità

1355
01:05:18,060 --> 01:05:23,340
nella matrice e alla fine potrebbe
in realtà avvolgere intorno se stiamo usando un

1356
01:05:23,340 --> 01:05:25,790
matrice per memorizzare il popolo
in questa coda.

1357
01:05:25,790 --> 01:05:28,390
Così si può quasi pensare al
array come un dato circolare

1358
01:05:28,390 --> 01:05:29,880
struttura in questo senso.

1359
01:05:29,880 --> 01:05:33,970
>> Quindi devi in ​​qualche modo a tenere traccia del
dimensioni di esso o realmente la fine di esso

1360
01:05:33,970 --> 01:05:36,250
e poi dove l'inizio è.

1361
01:05:36,250 --> 01:05:39,490
Quindi noi proponiamo che si dichiara
una tale coda, chiamata

1362
01:05:39,490 --> 01:05:41,330
esso q, solo una lettera.

1363
01:05:41,330 --> 01:05:44,570
Allora noi proponiamo che la parte anteriore sia
inizializzato a zero e che la dimensione

1364
01:05:44,570 --> 01:05:45,470
essere inizializzato a zero.

1365
01:05:45,470 --> 01:05:47,770
>> Così adesso, non c'è nulla
all'interno di tale coda.

1366
01:05:47,770 --> 01:05:50,910
E vi chiediamo di completare l'
attuazione di accodamento di seguito in

1367
01:05:50,910 --> 01:05:55,250
modo tale che la funzione aggiunge n per
fine di q e quindi restituisce true.

1368
01:05:55,250 --> 01:05:58,690
Ma se q è pieno o negativo, la
funzione dovrebbe invece restituire false.

1369
01:05:58,690 --> 01:06:01,060
E vi abbiamo dato una coppia
di ipotesi.

1370
01:06:01,060 --> 01:06:04,320
Ma non sono realmente funzionale
rilevante, solo che bool esiste,

1371
01:06:04,320 --> 01:06:06,690
perché, tecnicamente, bool non
esistere in C, a meno di includere un

1372
01:06:06,690 --> 01:06:07,310
certo file di intestazione.

1373
01:06:07,310 --> 01:06:09,350
Così che è stato appena assicurarsi che non vi
Non sono stati questo è un trucchetto

1374
01:06:09,350 --> 01:06:10,940
questione genere di cose.

1375
01:06:10,940 --> 01:06:16,280
>> Così enqueue, abbiamo proposto nel campione
soluzioni per implementare come segue.

1376
01:06:16,280 --> 01:06:20,420
Uno, per prima cosa controlliamo la facilità,
la frutta a basso impiccagione.

1377
01:06:20,420 --> 01:06:23,820
Se la coda è piena o il numero che
si sta cercando di inserire è meno

1378
01:06:23,820 --> 01:06:26,380
di zero, che abbiamo detto nella
specifica del problema dovrebbe

1379
01:06:26,380 --> 01:06:30,320
non essere consentito, perché vogliamo solo
I valori non negativi, allora si dovrebbe

1380
01:06:30,320 --> 01:06:31,640
semplicemente restituire false immediatamente.

1381
01:06:31,640 --> 01:06:33,820
Così alcuni relativamente facile
il controllo degli errori.

1382
01:06:33,820 --> 01:06:38,720
Se però si desidera aggiungere quella attuale
numero, si doveva fare un po 'di

1383
01:06:38,720 --> 01:06:39,440
pensare qui.

1384
01:06:39,440 --> 01:06:41,330
Ed è qui che è un po 'fastidioso
mentalmente, perché si deve

1385
01:06:41,330 --> 01:06:43,000
capire come gestire avvolgente.

1386
01:06:43,000 --> 01:06:46,870
>> Ma il germe dell'idea qui che è di
interesse per noi è che avvolgente

1387
01:06:46,870 --> 01:06:51,480
spesso implica l'aritmetica modulare e
l'operatore mod, il lato per cento,

1388
01:06:51,480 --> 01:06:55,140
dove si può andare da un valore maggiore
torna a zero e poi uno e due e

1389
01:06:55,140 --> 01:06:58,650
tre e poi indietro intorno a zero,
uno e due e tre e così via

1390
01:06:58,650 --> 01:06:59,380
ancora e ancora.

1391
01:06:59,380 --> 01:07:02,880
Quindi il modo in cui si propone di fare questo è
che noi vogliamo indice nella

1392
01:07:02,880 --> 01:07:05,850
array chiamato i numeri in cui
i nostri numeri interi mentono.

1393
01:07:05,850 --> 01:07:10,740
Ma per arrivarci, dobbiamo prima vogliamo fare
qualunque sia la dimensione della coda è ma

1394
01:07:10,740 --> 01:07:14,080
poi aggiungere che qualunque sia la
anteriore della lista è.

1395
01:07:14,080 --> 01:07:17,880
E l'effetto di ciò è di metterci a
la giusta posizione in coda e

1396
01:07:17,880 --> 01:07:20,970
Non dare per scontato che la prima persona in linea
è all'inizio, che egli o

1397
01:07:20,970 --> 01:07:24,130
lei assolutamente potrebbe essere se si
erano anche spostando tutti.

1398
01:07:24,130 --> 01:07:26,710
Ma stiamo solo creando lavoro
per noi stessi, se abbiamo preso

1399
01:07:26,710 --> 01:07:27,800
quel particolare percorso.

1400
01:07:27,800 --> 01:07:29,330
>> Così possiamo mantenere relativamente semplice.

1401
01:07:29,330 --> 01:07:32,180
Noi dobbiamo ricordare che abbiamo appena
aggiunto un int alla coda.

1402
01:07:32,180 --> 01:07:35,850
E poi abbiamo appena torniamo vero.

1403
01:07:35,850 --> 01:07:38,560
Nel frattempo, in dequeue, abbiamo chiesto
a fare quanto segue.

1404
01:07:38,560 --> 01:07:42,260
Attuarlo in modo tale che essa
viene eliminata dalla coda, cioè rimuove e ritorna,

1405
01:07:42,260 --> 01:07:44,190
int nella parte anteriore della coda.

1406
01:07:44,190 --> 01:07:46,410
Per rimuovere l'int, è sufficiente
di dimenticarlo.

1407
01:07:46,410 --> 01:07:47,650
Non è necessario eseguire l'override suo bit.

1408
01:07:47,650 --> 01:07:48,820
Quindi è ancora effettivamente lì.

1409
01:07:48,820 --> 01:07:51,930
Proprio come i dati su un disco rigido,
stiamo solo ignorando il fatto

1410
01:07:51,930 --> 01:07:52,970
che ora è lì.

1411
01:07:52,970 --> 01:07:55,520
E se q è vuota, dovremmo
invece di ritorno negativo 1.

1412
01:07:55,520 --> 01:07:56,750
Quindi, questo si sente arbitraria.

1413
01:07:56,750 --> 01:08:01,640
Perché ritorno negativo 1
invece di falso?

1414
01:08:01,640 --> 01:08:02,620
Già.

1415
01:08:02,620 --> 01:08:05,070
>> AUDIENCE: Q sta memorizzando
valori positivi.

1416
01:08:05,070 --> 01:08:10,950
Dal momento che si memorizzano solo valori positivi
nel q, negativo è un errore.

1417
01:08:10,950 --> 01:08:11,510
>> DAVID J. MALAN: OK, è vero.

1418
01:08:11,510 --> 01:08:14,850
Quindi perché stiamo memorizzando solo positivo
valori o zero, allora è bene per

1419
01:08:14,850 --> 01:08:18,050
restituire un valore negativo come una sentinella
valore, un simbolo speciale.

1420
01:08:18,050 --> 01:08:21,630
Ma si sta riscrivendo la storia lì,
perché la ragione siamo solo

1421
01:08:21,630 --> 01:08:25,890
restituzione di valori non negativi
è perché vogliamo

1422
01:08:25,890 --> 01:08:27,670
avere un valore sentinella.

1423
01:08:27,670 --> 01:08:32,617
Quindi, più in particolare, perché non solo
return false in caso di errori?

1424
01:08:32,617 --> 01:08:33,099
Già.

1425
01:08:33,099 --> 01:08:35,510
>> AUDIENCE: hai fallito
per restituire un numero intero.

1426
01:08:35,510 --> 01:08:36,630
>> DAVID J. MALAN: Esattamente.

1427
01:08:36,630 --> 01:08:38,569
E questo è dove ottiene C
piuttosto vincolante.

1428
01:08:38,569 --> 01:08:40,590
Se stai dicendo che stai andando
per restituire un int, hai

1429
01:08:40,590 --> 01:08:41,279
per restituire un int.

1430
01:08:41,279 --> 01:08:43,689
Non è possibile ottenere l'immaginazione e iniziare il ritorno
un bool o di un galleggiante o di un

1431
01:08:43,689 --> 01:08:45,040
stringa o qualcosa di simile.

1432
01:08:45,040 --> 01:08:49,370
Ora, intanto, JavaScript e PHP e
alcune altre lingue può, infatti,

1433
01:08:49,370 --> 01:08:51,310
avete ritorno diverso
tipi di valori.

1434
01:08:51,310 --> 01:08:54,819
E che può effettivamente essere utile, se
si potrebbe tornare ints positivi, zeri,

1435
01:08:54,819 --> 01:08:59,439
interi negativi, o false o null
anche per significare errore.

1436
01:08:59,439 --> 01:09:01,890
Ma noi non abbiamo che
versatilità in C.

1437
01:09:01,890 --> 01:09:04,569
>> Quindi, con dequeue, quello che abbiamo
proporre di fare è -

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> ROB BOWDEN: È possibile restituire false.

1440
01:09:09,830 --> 01:09:13,189
E 'solo che è falso hash
definire falso a zero.

1441
01:09:13,189 --> 01:09:16,000
Quindi, se si torna false,
stai tornando a zero.

1442
01:09:16,000 --> 01:09:25,470
E zero è una cosa valida nella nostra coda,
considerando che negativo 1 non è se

1443
01:09:25,470 --> 01:09:27,000
falso capitato di essere negativa 1.

1444
01:09:27,000 --> 01:09:29,972
Ma non si dovrebbe nemmeno
bisogno di sapere che.

1445
01:09:29,972 --> 01:09:32,399
>> DAVID J. MALAN: Ecco
perché io non lo dissi.

1446
01:09:32,399 --> 01:09:36,450
>> ROB BOWDEN: Ma non era vero
che non si può restituire false.

1447
01:09:36,450 --> 01:09:37,700
>> DAVID J. MALAN: Certo.

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
Così dequeue, notiamo accettiamo
invalidare come argomento.

1450
01:09:44,240 --> 01:09:45,479
E questo perché non siamo
passando nulla dentro

1451
01:09:45,479 --> 01:09:48,359
Vogliamo solo rimuovere l'elemento
nella parte anteriore della coda.

1452
01:09:48,359 --> 01:09:49,819
Così come potremmo fare per fare questo?

1453
01:09:49,819 --> 01:09:51,290
Beh, in primo luogo, cerchiamo di fare questo
controllo di integrità rapido.

1454
01:09:51,290 --> 01:09:53,350
Se la dimensione della coda è 0, non c'è
nessun lavoro da fare.

1455
01:09:53,350 --> 01:09:54,210
Rientro negativo 1.

1456
01:09:54,210 --> 01:09:54,800
Fatto.

1457
01:09:54,800 --> 01:09:56,340
Ecco, questo è poche righe del mio programma.

1458
01:09:56,340 --> 01:09:58,180
Quindi solo quattro linee rimangono.

1459
01:09:58,180 --> 01:10:01,310
>> Così qui ho deciso di diminuire
la dimensione.

1460
01:10:01,310 --> 01:10:04,620
E decrementare la dimensione efficacemente
significa che sto dimenticando

1461
01:10:04,620 --> 01:10:06,010
qualcosa è in là.

1462
01:10:06,010 --> 01:10:09,910
Ma devo anche aggiornare dove
la parte anteriore dei numeri sono.

1463
01:10:09,910 --> 01:10:11,620
Quindi, per fare questo, ho bisogno
di fare due cose.

1464
01:10:11,620 --> 01:10:16,390
Ho bisogno di ricordare ciò che il numero
è nella parte anteriore della coda,

1465
01:10:16,390 --> 01:10:17,860
perché ho bisogno di tornare quella cosa.

1466
01:10:17,860 --> 01:10:20,910
Quindi io non voglio dimenticare accidentalmente
su di esso e quindi sovrascrivere.

1467
01:10:20,910 --> 01:10:22,840
Sto solo andando a ricordare in un int.

1468
01:10:22,840 --> 01:10:27,310
>> E ora, voglio aggiornare
q.front da q.front +1.

1469
01:10:27,310 --> 01:10:30,070
Quindi, se questa è stata la prima persona in
linea, ora, voglio fare più 1 per

1470
01:10:30,070 --> 01:10:31,930
puntare alla prossima persona in linea.

1471
01:10:31,930 --> 01:10:33,420
Ma devo gestire tale avvolgente.

1472
01:10:33,420 --> 01:10:37,270
E se la capacità è una costante globale,
che sta per permettermi di assicurarsi

1473
01:10:37,270 --> 01:10:41,140
come indico l'ultima persona in
linea, l'operazione di modulo porterà

1474
01:10:41,140 --> 01:10:43,840
mi riporta a zero al
anteriore della coda.

1475
01:10:43,840 --> 01:10:46,050
E che gestisce l'avvolgente qui.

1476
01:10:46,050 --> 01:10:48,950
E poi procedo per tornare n.

1477
01:10:48,950 --> 01:10:51,530
>> Ora, a rigor di termini, non l'ho fatto
devono dichiarare n.

1478
01:10:51,530 --> 01:10:53,880
Non ho avuto per afferrarla e riporlo
temporaneamente, perché il valore è

1479
01:10:53,880 --> 01:10:54,740
ancora lì.

1480
01:10:54,740 --> 01:10:57,490
Così ho potuto solo fare la media aritmetica di destra
al ritorno l'ex capo

1481
01:10:57,490 --> 01:10:58,450
della coda.

1482
01:10:58,450 --> 01:11:01,850
Ma ho appena sentito che questo era più chiaro
per afferrare effettivamente l'int, metterlo

1483
01:11:01,850 --> 01:11:04,320
n, e poi tornare che
per amor di chiarezza, ma

1484
01:11:04,320 --> 01:11:05,735
non strettamente necessario.

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
Sono tutti pronunciabile nella mia testa.

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> ROB BOWDEN: Quindi prima questione
è il problema albero binario.

1490
01:11:19,110 --> 01:11:22,140
Quindi prima domanda è, siamo
dato questi numeri.

1491
01:11:22,140 --> 01:11:27,160
E vogliamo inserirli in qualche modo in
questi nodi tale che è un

1492
01:11:27,160 --> 01:11:30,110
valida albero binario di ricerca.

1493
01:11:30,110 --> 01:11:36,260
Quindi l'unica cosa da ricordare su
alberi binari di ricerca è che non è

1494
01:11:36,260 --> 01:11:39,800
solo che la cosa di sinistra
è minore e la cosa

1495
01:11:39,800 --> 01:11:41,120
il diritto è maggiore.

1496
01:11:41,120 --> 01:11:44,580
Deve essere che l'intero albero di
la sinistra è meno, e l'intero albero

1497
01:11:44,580 --> 01:11:45,740
a destra è maggiore.

1498
01:11:45,740 --> 01:11:55,260
>> Quindi, se ho messo 34 qui in alto, e poi
Ho messo 20 qui, quindi questo è valido così

1499
01:11:55,260 --> 01:11:56,970
lontano, perché 34 quassù.

1500
01:11:56,970 --> 01:11:57,920
20 sta a sinistra.

1501
01:11:57,920 --> 01:11:58,950
Ecco, questo è meno.

1502
01:11:58,950 --> 01:12:03,640
Ma non posso poi mettere 59 qui, perché
anche se 59 è sulla destra 20,

1503
01:12:03,640 --> 01:12:06,140
è ancora a sinistra 34.

1504
01:12:06,140 --> 01:12:10,760
Quindi, con questo vincolo in mente, il
modo più semplice di risolvere questo probabilmente

1505
01:12:10,760 --> 01:12:14,330
problema è proprio ordinamento
di questi numeri -

1506
01:12:14,330 --> 01:12:18,720
così 20, 34, 36, 52, 59, 106.

1507
01:12:18,720 --> 01:12:21,640
E quindi inserire quelli
da sinistra a destra.

1508
01:12:21,640 --> 01:12:23,390
>> Quindi 20 va qui.

1509
01:12:23,390 --> 01:12:24,630
34 va qui.

1510
01:12:24,630 --> 01:12:25,830
36 va qui.

1511
01:12:25,830 --> 01:12:29,360
52, 59, 106.

1512
01:12:29,360 --> 01:12:34,730
E si potrebbe anche aver capito con
un po 'di collegare e realizzare,

1513
01:12:34,730 --> 01:12:38,830
oh, aspetta, non ho abbastanza numeri
per colmare questo qui.

1514
01:12:38,830 --> 01:12:42,170
Quindi ho bisogno tornate di nuovo ciò che il mio
nota percorso sta per essere.

1515
01:12:42,170 --> 01:12:47,490
Ma si noti che in finale tre, se
si legge da sinistra a destra, è in

1516
01:12:47,490 --> 01:12:48,740
ordine crescente.

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> Così ora, vogliamo dichiarare ciò che l'
struct sta per essere per il

1519
01:12:56,540 --> 01:12:58,300
nodi di questo albero.

1520
01:12:58,300 --> 01:13:02,720
Così che cosa abbiamo bisogno in un albero binario?

1521
01:13:02,720 --> 01:13:05,830
Quindi abbiamo un valore di tipo
int, quindi un valore int.

1522
01:13:05,830 --> 01:13:07,220
Non so quello che abbiamo chiamato
nella soluzione -

1523
01:13:07,220 --> 01:13:08,500
int n.

1524
01:13:08,500 --> 01:13:13,570
Abbiamo bisogno di un puntatore al figlio sinistro
e un puntatore al figlio destro.

1525
01:13:13,570 --> 01:13:17,540
Così sta andando a guardare come questo.

1526
01:13:17,540 --> 01:13:20,510
E sarà effettivamente sembrare prima
quando ha doppiamente legata

1527
01:13:20,510 --> 01:13:25,090
elenco roba, quindi gara -

1528
01:13:25,090 --> 01:13:27,860
Ho intenzione di dover scorrere tutta la
via del ritorno verso il basso per problema 11.

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> Quindi notare sembra identica a questa,
tranne che abbiamo appena capita di chiamare questi

1531
01:13:36,390 --> 01:13:38,590
nomi diversi.

1532
01:13:38,590 --> 01:13:41,440
Abbiamo ancora un numero intero
valore e due puntatori.

1533
01:13:41,440 --> 01:13:44,850
E 'solo che invece di trattare la
puntatori come indica la prossima cosa

1534
01:13:44,850 --> 01:13:47,955
e la cosa precedente, stiamo trattando
i puntatori per puntare a un figlio sinistro

1535
01:13:47,955 --> 01:13:49,205
e il figlio destro.

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
OK.

1538
01:13:57,860 --> 01:13:59,650
Ecco, questo è il nostro nodo struct.

1539
01:13:59,650 --> 01:14:03,920
E ora, l'unica funzione che abbiamo bisogno di
l'attuazione di questo è traversata, che

1540
01:14:03,920 --> 01:14:08,320
vogliamo andare oltre l'albero, stampa
i valori dell'albero in ordine.

1541
01:14:08,320 --> 01:14:15,241
>> Quindi, guardando qui, vorremmo stampare
su 20, 34, 36, 52, 59, e 106.

1542
01:14:15,241 --> 01:14:17,970
Come possiamo raggiungere questo?

1543
01:14:17,970 --> 01:14:18,890
Quindi è abbastanza simile.

1544
01:14:18,890 --> 01:14:22,910
Se avete visto l'esame passato il problema
che si voleva stampare

1545
01:14:22,910 --> 01:14:25,940
l'intero albero con delle virgole tra
tutto, in realtà è stato anche

1546
01:14:25,940 --> 01:14:27,320
facile di quello.

1547
01:14:27,320 --> 01:14:30,950
Quindi, ecco la soluzione.

1548
01:14:30,950 --> 01:14:33,110
Questo era significativamente più facile
se l'avete fatto in modo ricorsivo.

1549
01:14:33,110 --> 01:14:36,650
Non so se qualcuno ha tentato
per farlo in modo iterativo.

1550
01:14:36,650 --> 01:14:38,340
>> Ma prima, abbiamo il nostro caso base.

1551
01:14:38,340 --> 01:14:39,660
Che cosa succede se la radice è nullo?

1552
01:14:39,660 --> 01:14:40,610
Poi stiamo solo andando a tornare.

1553
01:14:40,610 --> 01:14:42,300
Noi non vogliamo stampare nulla.

1554
01:14:42,300 --> 01:14:45,940
Altrimenti stiamo per attraversare
ricorsivamente giù.

1555
01:14:45,940 --> 01:14:48,140
Stampa l'intero sottoalbero sinistro.

1556
01:14:48,140 --> 01:14:51,440
Così stampare tutto meno
che il mio valore corrente.

1557
01:14:51,440 --> 01:14:53,930
E poi ho intenzione di stampare me stesso.

1558
01:14:53,930 --> 01:14:57,310
E poi ho intenzione di ricorsione la mia
intero sottoalbero destro, quindi tutto

1559
01:14:57,310 --> 01:14:58,810
maggiore del mio valore.

1560
01:14:58,810 --> 01:15:03,870
E questo sta andando per la stampa
fuori tutto in ordine.

1561
01:15:03,870 --> 01:15:05,860
Domande su come questo in realtà
compie questo?

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> PUBBLICO: Ho una domanda
il [incomprensibile].

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> ROB BOWDEN: Quindi un modo di affrontare
qualsiasi problema ricorsiva è quello di pensare solo

1566
01:15:23,550 --> 01:15:26,275
su di esso come si deve pensare
su tutti i casi d'angolo.

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
Quindi consideriamo che vogliamo
stampare l'intero albero.

1569
01:15:38,110 --> 01:15:42,030
Quindi tutto quello che stiamo andando a concentrarsi su
è questo particolare nodo -

1570
01:15:42,030 --> 01:15:43,740
36.

1571
01:15:43,740 --> 01:15:47,420
Le chiamate ricorsive, facciamo finta
quelli appena funzionano.

1572
01:15:47,420 --> 01:15:54,000
Ecco, questa chiamata ricorsiva
traversata, noi senza nemmeno pensarci

1573
01:15:54,000 --> 01:15:58,640
a questo proposito, basta attraversare sinistra
tre, immaginare che stampa già 20

1574
01:15:58,640 --> 01:16:00,730
e 34 per noi.

1575
01:16:00,730 --> 01:16:03,350
E poi quando abbiamo finalmente ricorsivamente
chiamare traversata sul

1576
01:16:03,350 --> 01:16:07,890
destra, che verrà corretto stampare
52, 59, e 106 per noi.

1577
01:16:07,890 --> 01:16:13,620
>> Quindi, dato che questo può stampare 20, 34, e
l'altro può stampare 52, 59, 108,

1578
01:16:13,620 --> 01:16:17,180
tutti abbiamo bisogno di essere in grado di fare è stampare
noi stessi nel mezzo di questo.

1579
01:16:17,180 --> 01:16:21,250
Così stampare tutto prima di noi.

1580
01:16:21,250 --> 01:16:27,710
Stampare noi stessi, in modo che la stampa nodo corrente
36, printf regolare, e quindi

1581
01:16:27,710 --> 01:16:31,170
stampare tutto dopo di noi.

1582
01:16:31,170 --> 01:16:32,730
>> DAVID J. MALAN: Questo è dove ricorsione
diventa veramente bello.

1583
01:16:32,730 --> 01:16:36,270
E 'questo incredibile atto di fede in cui
si fa il più piccolo frammento di lavoro.

1584
01:16:36,270 --> 01:16:38,460
E poi si lascia qualcuno
altro fare il resto.

1585
01:16:38,460 --> 01:16:40,180
E che qualcun altro
è, ironia della sorte, si.

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
Così, per gravi punti brownie, se
scorrere verso l'alto sulle domande -

1588
01:16:48,360 --> 01:16:50,530
>> ROB BOWDEN: Sulle domande?

1589
01:16:50,530 --> 01:16:53,490
>> DAVID J. MALAN: E giù un po 'di
i numeri, qualcuno sa dove

1590
01:16:53,490 --> 01:16:55,190
questi numeri vengono?

1591
01:16:55,190 --> 01:16:56,610
>> ROB BOWDEN: ho letteralmente idea.

1592
01:16:56,610 --> 01:16:59,794
>> DAVID J. MALAN: Appaiono
tutto il quiz.

1593
01:16:59,794 --> 01:17:01,150
>> AUDIENCE: Sono gli stessi numeri?

1594
01:17:01,150 --> 01:17:01,910
>> DAVID J. MALAN: Quei numeri.

1595
01:17:01,910 --> 01:17:03,260
Un po 'di uovo di Pasqua.

1596
01:17:03,260 --> 01:17:08,100
Quindi, per quelli di voi guardando online
casa, se potete dirci via e-mail a

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net cosa il significato
di questi ricorrenti sei numeri sono

1598
01:17:12,680 --> 01:17:18,560
tutta Quiz 1, saremo doccia voi
con un'attenzione incredibile alla finale

1599
01:17:18,560 --> 01:17:21,610
conferenza e una palla stress.

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
Nizza, sottile.

1602
01:17:27,790 --> 01:17:29,570
>> ROB BOWDEN: Tutte le ultime domande
qualsiasi cosa sul quiz?

1603
01:17:29,570 --> 01:17:32,608