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

2
00:00:02,270 --> 00:00:04,620
[Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Harvard University]

3
00:00:04,620 --> 00:00:07,660
[Questo è CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Benvenuti a tutti. Questa è una rassegna per quiz 1.

5
00:00:11,610 --> 00:00:15,040
Proprio come un disclaimer, questo è - voglio dire, stiamo andando a cercare di coprire

6
00:00:15,040 --> 00:00:17,770
quanto più materiale possibile, ma questo non significa che

7
00:00:17,770 --> 00:00:20,780
stiamo andando a coprire tutte le cose che possono essere in quiz 1.

8
00:00:20,780 --> 00:00:25,270
Quindi, essere sicuri che anche dare un'occhiata a lezione, sezioni, tutto quello che si può.

9
00:00:25,270 --> 00:00:28,240
Quiz 1 sarà il Mercoledì, Mercoledì prossimo.

10
00:00:28,240 --> 00:00:33,800
Quindi, essere sicuri di studiare. E sarà, più o meno, come il primo quiz

11
00:00:33,800 --> 00:00:36,390
per quanto riguarda il formato, ma è probabilmente sarà molto più difficile.

12
00:00:36,390 --> 00:00:39,600
Almeno, l'anno scorso quando ho preso 50, ho pensato che fosse molto più difficile.

13
00:00:39,600 --> 00:00:42,410
Quindi studiare molto.

14
00:00:42,410 --> 00:00:45,190
>> Io vado a coprire le strutture di dati e codifica di Huffman.

15
00:00:45,190 --> 00:00:47,910
Questo è qualcosa che un sacco di gente pensa è complessa,

16
00:00:47,910 --> 00:00:51,930
ma ho intenzione di cercare di rendere il più semplice possibile.

17
00:00:51,930 --> 00:00:56,330
Prima di tutto, quello che vogliamo voi ragazzi per sapere con quiz 1 è

18
00:00:56,330 --> 00:01:00,970
comprendere le descrizioni concettuali di ciascuna delle strutture dati che ho intenzione di presentare.

19
00:01:00,970 --> 00:01:03,960
Ciò significa che non c'è bisogno di realtà

20
00:01:03,960 --> 00:01:07,020
implementare una tabella hash nel quiz 1.

21
00:01:07,020 --> 00:01:10,250
Non vogliamo di implementare una tabella di hash intero, forse ci proveremo

22
00:01:10,250 --> 00:01:13,090
per farvi implementare alcune funzioni,

23
00:01:13,090 --> 00:01:16,940
le operazioni più comuni, ma non stiamo andando a fare di implementare tutto.

24
00:01:16,940 --> 00:01:21,010
Quindi è importante che capiate il concetto alla base di ogni struttura dati

25
00:01:21,010 --> 00:01:23,510
e anche che si è in grado di codificare in C,

26
00:01:23,510 --> 00:01:27,880
solo le più comuni operazioni che hanno per ogni struttura dati.

27
00:01:27,880 --> 00:01:30,090
E anche in grado di rivedere i puntatori e strutture,

28
00:01:30,090 --> 00:01:33,470
perché appaiono molto in queste strutture di dati.

29
00:01:33,470 --> 00:01:37,380
>> In primo luogo, le liste collegate. Liste collegate sono in realtà molto simili alle matrici,

30
00:01:37,380 --> 00:01:39,930
ma la differenza tra un elenco collegato e una matrice,

31
00:01:39,930 --> 00:01:45,160
Prima di tutto, è che una lista collegata ha una dimensione molto flessibile,

32
00:01:45,160 --> 00:01:50,060
mentre in array dovete scegliere una dimensione molto grande per la matrice,

33
00:01:50,060 --> 00:01:53,710
in modo da sapere che si sta andando ad essere in grado di memorizzare tutti i dati in tale matrice,

34
00:01:53,710 --> 00:01:59,370
o è necessario utilizzare malloc ad avere una lunghezza flessibile di array.

35
00:01:59,370 --> 00:02:03,680
Nelle liste collegate è molto facile da ottenere solo più elementi,

36
00:02:03,680 --> 00:02:07,210
mettere più elementi nella lista collegata o rimuovere elementi.

37
00:02:07,210 --> 00:02:09,370
E in realtà, se non si desidera che la lista collegata da ordinare,

38
00:02:09,370 --> 00:02:13,950
Trovare e rimuovere gli elementi in tempo costante,

39
00:02:13,950 --> 00:02:16,800
quindi O (1) tempo, quindi è molto comodo.

40
00:02:16,800 --> 00:02:20,660
Devi solo stare attenti a ricordarsi sempre di malloc e libera i nodi,

41
00:02:20,660 --> 00:02:25,510
solo perché se non lo fate, avrete perdite di memoria.

42
00:02:25,510 --> 00:02:31,480
Così le liste collegate - la definizione di un nodo è proprio come quello che abbiamo proprio lì.

43
00:02:31,480 --> 00:02:35,110
Ho messo int n, ma è possibile memorizzare tutti i dati che si desidera.

44
00:02:35,110 --> 00:02:37,280
Quindi, se si vuole memorizzare una stringa, va bene.

45
00:02:37,280 --> 00:02:41,690
Se si desidera memorizzare una struct, va bene, un doppio, quello che volete.

46
00:02:41,690 --> 00:02:44,630
Ho appena messo int n per gli esempi qui.

47
00:02:44,630 --> 00:02:46,800
E avete un puntatore al nodo successivo.

48
00:02:46,800 --> 00:02:51,940
Quindi, fondamentalmente, una lista collegata ha alcuni dati, e poi punta al nodo successivo.

49
00:02:51,940 --> 00:02:56,710
Se è l'ultimo elemento della lista collegata, sta andando a puntare a NULL.

50
00:02:56,710 --> 00:02:59,060
Quindi questo è un esempio di una lista collegata.

51
00:02:59,250 --> 00:03:05,960
>> Bene, ora vediamo cosa dobbiamo fare se voglio inserire un elemento in una lista collegata.

52
00:03:05,960 --> 00:03:08,810
In primo luogo, un inserto funzione sarà di tipo void

53
00:03:08,810 --> 00:03:11,350
perché io non voglio restituire qualcosa.

54
00:03:11,350 --> 00:03:14,200
E io vado a prendere un int come argomento,

55
00:03:14,200 --> 00:03:17,090
perché voglio sapere quello che voglio inserire.

56
00:03:17,090 --> 00:03:21,840
Allora, qual è la prima cosa che dovrei fare? Beh, dovrei malloc su newnode,

57
00:03:21,840 --> 00:03:24,240
così che è la prima riga.

58
00:03:24,240 --> 00:03:27,580
Sto solo la creazione di un nuovo nodo di mettere in una lista collegata.

59
00:03:27,580 --> 00:03:32,360
Allora cosa posso fare? Beh, sappiamo che nelle nostre implementazioni di liste collegate

60
00:03:32,360 --> 00:03:38,180
in classe, abbiamo sempre messo la testa come una variabile globale.

61
00:03:38,180 --> 00:03:41,800
Quindi cosa possiamo fare è cambiare la testa.

62
00:03:41,800 --> 00:03:44,300
Posso fare questo nuovo nodo sarà il nuovo capo,

63
00:03:44,300 --> 00:03:46,670
e sta andando a puntare alla testa precedente.

64
00:03:46,670 --> 00:03:50,390
Come possiamo farlo? La prima cosa che devo fare

65
00:03:50,390 --> 00:03:54,770
è cambiare la 'n' nel nuovo nodo di valore,

66
00:03:54,770 --> 00:03:57,530
che è stato passato alla funzione.

67
00:03:57,530 --> 00:04:01,050
Poi newnode è accanto sta per essere alla testa.

68
00:04:01,050 --> 00:04:05,800
La testa sta per essere newNode. Quindi è abbastanza semplice.

69
00:04:05,800 --> 00:04:10,090
Per cancellare un nodo, possiamo farlo come -

70
00:04:10,090 --> 00:04:14,790
Un modo potremmo farlo è quello di dire,

71
00:04:14,790 --> 00:04:18,160
Va bene, se volevo eliminare, per esempio, 3,

72
00:04:18,160 --> 00:04:24,850
quello che ho potuto fare è solo puntare il nodo precedente

73
00:04:24,850 --> 00:04:27,580
al successivo nodo di 3.

74
00:04:27,580 --> 00:04:29,400
Quindi vorrei solo fare qualcosa di simile.

75
00:04:29,400 --> 00:04:33,400
Ma qual è il problema con il fare che?

76
00:04:33,400 --> 00:04:37,400
Ho una perdita di memoria, in modo da non avere accesso al numero 3 più.

77
00:04:37,400 --> 00:04:42,480
Il problema è che io non ho intenzione di essere in grado di liberare tale nodo.

78
00:04:42,480 --> 00:04:45,360
Ho intenzione di avere perdita di memoria e (incomprensibile) sta per odiarmi.

79
00:04:45,360 --> 00:04:49,370
Così, invece di fare questo, probabilmente dovrei avere un puntatore temporaneo.

80
00:04:49,370 --> 00:04:53,210
Così ho messo temperatura. E 'intenzione di puntare al nodo che voglio eliminare.

81
00:04:53,210 --> 00:04:58,170
E poi posso spostare i nodi precedenti per puntare al nodo successivo

82
00:04:58,170 --> 00:05:00,390
del nodo che voglio eliminare.

83
00:05:00,390 --> 00:05:02,730
E, infine, io posso liberare il puntatore.

84
00:05:02,730 --> 00:05:07,480
Devo liberare il puntatore che ho creato proprio lì?

85
00:05:07,480 --> 00:05:09,560
Io non devo, solo perché -

86
00:05:09,560 --> 00:05:13,430
la differenza è che questo nodo è stata creata usando malloc,

87
00:05:13,430 --> 00:05:17,280
quindi è nel mucchio, mentre questo era solo dichiarato come un interruttore NULL nello stack.

88
00:05:17,280 --> 00:05:20,000
Quindi io non devo liberarla.

89
00:05:20,000 --> 00:05:22,030
Va bene >>. Così ora parliamo di stack.

90
00:05:22,030 --> 00:05:24,680
Le pile sono piuttosto semplici.

91
00:05:24,680 --> 00:05:29,540
Abbiamo fatto stack e code in classe solo utilizzo di matrici,

92
00:05:29,540 --> 00:05:32,820
ma si dovrebbe essere a conoscenza - basta essere consapevoli

93
00:05:32,820 --> 00:05:40,740
che si può anche fare pile in code utilizzando liste collegate pure.

94
00:05:40,740 --> 00:05:44,460
Quindi, se avete un array, quale sarebbe una pila?

95
00:05:44,460 --> 00:05:46,810
Una pila, prima, dovrà avere una dimensione.

96
00:05:46,810 --> 00:05:49,950
È necessario memorizzare ciò che è la dimensione dello stack che avete in questo momento.

97
00:05:49,950 --> 00:05:52,980
E inoltre si avrebbe una matrice, in questo caso di numeri,

98
00:05:52,980 --> 00:05:55,120
ma se si vuole, può essere un array

99
00:05:55,120 --> 00:06:00,380
di stringhe, un array di struct, tutto ciò che si desidera memorizzare.

100
00:06:00,380 --> 00:06:03,240
Circa la pila: La differenza tra una pila e una lista collegata

101
00:06:03,240 --> 00:06:08,590
è che nello stack si ha accesso solo l'ultimo elemento che è stato messo nello stack.

102
00:06:08,590 --> 00:06:11,770
Si chiama scorso in, first out.

103
00:06:11,770 --> 00:06:15,090
Proprio come avete una pila di vassoi,

104
00:06:15,090 --> 00:06:17,670
se si mette un vassoio in cima alla pila,

105
00:06:17,670 --> 00:06:22,670
è necessario rimuovere quel vassoio prima di avere accesso agli altri vassoi.

106
00:06:22,670 --> 00:06:26,310
E 'la stessa cosa con pile.

107
00:06:26,310 --> 00:06:31,220
Quindi, se voglio, ad esempio, aggiungere un elemento a una pila, cosa devo fare?

108
00:06:31,220 --> 00:06:34,070
Si chiama spinta, ed è abbastanza semplice.

109
00:06:34,070 --> 00:06:37,130
La prima cosa che dovete fare è controllare se la dimensione dello stack

110
00:06:37,130 --> 00:06:40,150
non è maggiore o uguale alla capacità dello stack.

111
00:06:40,150 --> 00:06:45,810
Perché se siete già in piena capacità, non è possibile aggiungere qualsiasi altra cosa.

112
00:06:45,810 --> 00:06:51,140
E poi se non, basta aggiungere l'elemento alla pila.

113
00:06:51,140 --> 00:06:54,530
E infine, incrementare la dimensione. Quindi è abbastanza semplice.

114
00:06:54,530 --> 00:06:57,140
Così ho appena aggiungo il numero 2.

115
00:06:57,140 --> 00:07:00,350
E se voglio pop, il che significa che voglio rimuovere

116
00:07:00,350 --> 00:07:03,870
l'ultimo elemento che è stato aggiunto e ritorno, il valore dell'elemento,

117
00:07:03,870 --> 00:07:09,180
la prima cosa che devo controllare è che la pila non è vuota.

118
00:07:09,180 --> 00:07:11,510
Perché se è vuota, non posso restituire qualcosa.

119
00:07:11,510 --> 00:07:14,820
In tal caso, sto tornando -1.

120
00:07:14,820 --> 00:07:18,960
In caso contrario, ho intenzione di diminuire le dimensioni della specifica,

121
00:07:18,960 --> 00:07:22,510
e ritorno numeri (s.size).

122
00:07:22,510 --> 00:07:27,230
Perché ho decrementare la dimensione e poi tornare s.size?

123
00:07:27,230 --> 00:07:30,930
È perché, in questo caso, la specifica ha dimensione 4,

124
00:07:30,930 --> 00:07:33,810
e voglio restituire il quarto elemento, giusto?

125
00:07:33,810 --> 00:07:36,030
Ma che cosa è l'indice del quarto elemento? Tre.

126
00:07:36,030 --> 00:07:44,510
Dal momento che la taglia - sta per essere di 3, posso solo tornare s.numbers (s.size)

127
00:07:44,510 --> 00:07:48,410
perché è 3. Quindi è solo l'indice.

128
00:07:48,410 --> 00:07:50,380
>> Ora le code. Le code sono praticamente la stessa cosa.

129
00:07:50,380 --> 00:07:54,950
L'unica differenza è che invece di avere ultimo entrato, primo uscito,

130
00:07:54,950 --> 00:07:57,480
avete first in, first out.

131
00:07:57,480 --> 00:07:59,460
Probabilmente se siete in attesa di andare a un concerto,

132
00:07:59,460 --> 00:08:04,260
non sarebbe felice se tu avessi una pila al posto di una coda.

133
00:08:04,260 --> 00:08:07,730
Essendo l'ultima persona a venire sarebbe stata la prima persona a entrare al concerto.

134
00:08:07,730 --> 00:08:09,760
Probabilmente non sarebbe felice.

135
00:08:09,760 --> 00:08:15,020
In coda, la prima persona a entrare è anche la prima persona a uscire.

136
00:08:15,020 --> 00:08:18,720
Così nella definizione di una coda, oltre ad avere la dimensione della matrice,

137
00:08:18,720 --> 00:08:23,360
bisogna anche avere la testa, che è l'indice alla testa della pila.

138
00:08:23,360 --> 00:08:29,000
Quindi, il primo elemento in questo momento.

139
00:08:29,000 --> 00:08:32,710
Enqueue è la stessa cosa come spinta per stack.

140
00:08:32,710 --> 00:08:34,980
Se tu fossi molto ingenuo, si sarebbe solo dire,

141
00:08:34,980 --> 00:08:39,289
bene, posso solo fare esattamente la stessa cosa ho fatto per spingere.

142
00:08:39,289 --> 00:08:44,030
Posso solo controllare se non è al di là della capacità.

143
00:08:44,030 --> 00:08:48,760
Se lo è, torno falso, altrimenti posso solo esportare il nuovo valore

144
00:08:48,760 --> 00:08:50,630
e quindi incrementare la dimensione.

145
00:08:50,630 --> 00:08:52,750
Ma perché è questo che non va?

146
00:08:52,750 --> 00:08:55,010
Vediamo questo esempio.

147
00:08:55,010 --> 00:08:57,020
Sto cercando di accodare un mucchio di roba,

148
00:08:57,020 --> 00:08:58,390
e poi ho intenzione di annullare l'accodamento e accodare.

149
00:08:58,390 --> 00:09:00,550
C'è un sacco di comandi, ma è molto semplice.

150
00:09:00,550 --> 00:09:04,790
Ho intenzione di accodare 5, quindi aggiungere 5 e poi 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, e poi voglio dequeue qualcosa,

152
00:09:09,310 --> 00:09:12,000
il che significa che ho intenzione di rimuovere il primo elemento.

153
00:09:12,000 --> 00:09:14,640
Quindi ho intenzione di rimuovere il numero 3, giusto?

154
00:09:14,640 --> 00:09:17,320
Il primo elemento. Ok.

155
00:09:17,320 --> 00:09:21,450
Ora, se cerco di accodare qualcosa d'altro, che cosa succederà?

156
00:09:21,450 --> 00:09:24,290
Secondo la mia implementazione,

157
00:09:24,290 --> 00:09:31,040
Stavo per inserire il numero successivo nella q.size indice.

158
00:09:31,040 --> 00:09:35,140
In questo caso, la dimensione è 8,

159
00:09:35,140 --> 00:09:38,640
così l'indice 8 sarà proprio qui in ultima posizione.

160
00:09:38,640 --> 00:09:43,900
Se cerco di accodare 1 proprio qui, sarei sovrascrivendo l'ultima posizione

161
00:09:43,900 --> 00:09:45,870
al numero 1, che è completamente sbagliato.

162
00:09:45,870 --> 00:09:49,870
Quello che voglio fare è avvolgere intorno e andare alla prima posizione.

163
00:09:49,870 --> 00:09:52,870
Forse si dovrebbe semplicemente dire, bene, devo solo controllare

164
00:09:52,870 --> 00:09:55,600
se posso effettivamente mettere qualcosa lì.

165
00:09:55,600 --> 00:09:58,560
Se no, dico solo, oh, il nuovo piena capacità

166
00:09:58,560 --> 00:10:02,010
in realtà è la capacità - 1, e non si può mettere un elemento lì.

167
00:10:02,010 --> 00:10:06,150
Ma qual è il problema? Il problema è che se ho appena Dequeue tutto qui

168
00:10:06,150 --> 00:10:08,240
e poi cerco di aggiungere qualcosa d'altro, sarebbe solo dire,

169
00:10:08,240 --> 00:10:11,210
bene, eri a pieno regime, che è 0.

170
00:10:11,210 --> 00:10:13,620
Quindi, la coda è andato.

171
00:10:13,620 --> 00:10:16,990
Bisogna avvolgere intorno, e un modo di avvolgere intorno

172
00:10:16,990 --> 00:10:22,040
che voi ragazzi imparato in visionarie e altri pset stava usando mod.

173
00:10:22,040 --> 00:10:29,090
Si può provare a casa per capire il motivo per cui si dovrebbe fare q.size + q.head

174
00:10:29,090 --> 00:10:31,080
capacità di mod, ma se si controlla proprio qui,

175
00:10:31,080 --> 00:10:34,760
possiamo vedere che funziona.

176
00:10:34,760 --> 00:10:37,760
Così nell'ultimo esempio, q.size era 8

177
00:10:37,760 --> 00:10:47,590
e la testa era 1, perché era questa posizione qui dell'array.

178
00:10:47,590 --> 00:10:51,970
Così sarà 8 + 1, 9. Capacità Mod 9 sarebbe 0.

179
00:10:51,970 --> 00:10:56,640
Sarebbe andare all'indice 0. Saremo nella giusta posizione.

180
00:10:56,640 --> 00:10:59,750
E quindi provare la coda a casa.

181
00:10:59,750 --> 00:11:04,950
Alcune cose importanti: cercare di capire la differenza tra una pila e una coda.

182
00:11:04,950 --> 00:11:11,620
A casa, cercare di ottenere molto familiare con l'attuazione enqueue, dequeue, spinta e pop.

183
00:11:11,620 --> 00:11:16,560
E anche capire quando si usa ciascuno di essi.

184
00:11:16,560 --> 00:11:22,830
>> Quindi cerchiamo di rilassarsi per 10 secondi con un mazzo di Pokemon.

185
00:11:22,830 --> 00:11:26,080
E ora torniamo alle strutture dati.

186
00:11:26,080 --> 00:11:29,770
Hash tabelle. Un sacco di gente era spaventata di tabelle hash.

187
00:11:29,770 --> 00:11:33,650
in problema set 6, Spell Checker.

188
00:11:33,650 --> 00:11:35,980
Tabelle hash e tentativi, un sacco di gente avere paura di loro.

189
00:11:35,980 --> 00:11:38,540
Credono di essere così difficile da capire. Sì?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Problema set 5. >> Problema set 5, sì. Grazie Rob.

191
00:11:41,490 --> 00:11:43,370
Già. Sei stato Huff n 'Puff, sì.

192
00:11:43,370 --> 00:11:49,340
Problema set 5 è stato Spell Checker, e si doveva utilizzare una tabella hash o una prova.

193
00:11:49,340 --> 00:11:55,360
Un sacco di gente pensava che fossero super-difficile da capire, ma sono in realtà piuttosto semplice.

194
00:11:55,360 --> 00:12:01,290
Che cosa è una tabella hash, in fondo? Una tabella hash è un array di liste concatenate.

195
00:12:01,290 --> 00:12:06,730
L'unica differenza tra una matrice e una tabella hash

196
00:12:06,730 --> 00:12:09,730
è che nella tabella hash avete qualcosa chiamato una funzione di hash.

197
00:12:09,730 --> 00:12:12,080
Che cosa è una funzione di hash?

198
00:12:12,080 --> 00:12:13,970
Non so se voi ragazzi potete leggere qui.

199
00:12:13,970 --> 00:12:16,090
Questo è un esempio di una tabella hash.

200
00:12:16,090 --> 00:12:19,220
Così si può vedere che avete un array con 31 elementi.

201
00:12:19,220 --> 00:12:22,440
E quello che facciamo in una tabella di hash è avere una funzione hash

202
00:12:22,440 --> 00:12:26,660
che sta per tradurre una chiave, ogni int ad un indice.

203
00:12:26,660 --> 00:12:31,740
Se, per esempio, se voglio scegliere per la B. Harrison,

204
00:12:31,740 --> 00:12:34,190
Vorrei mettere B. Harrison nelle mie funzioni di hash,

205
00:12:34,190 --> 00:12:36,960
e la funzione di hash sarebbe tornato 24.

206
00:12:36,960 --> 00:12:40,930
Quindi so che voglio conservare B. Harrison a 24.

207
00:12:40,930 --> 00:12:46,580
Ecco, questo è la differenza tra solo avere una matrice e aventi una tabella hash.

208
00:12:46,580 --> 00:12:48,740
Nella tabella hash avrai una funzione che sta per dirti

209
00:12:48,740 --> 00:12:54,740
dove memorizzare i dati che si desidera conservare.

210
00:12:54,740 --> 00:12:57,040
Per la funzione di hash, si vuole cercare una funzione di hash

211
00:12:57,040 --> 00:13:00,600
cioè deterministica e ben distribuita.

212
00:13:00,600 --> 00:13:07,810
Come potete vedere qui, si vede che un sacco di dati che volevo negozio era in realtà 19

213
00:13:07,810 --> 00:13:12,470
invece di usare 31 e 30 e 29, che erano tutti liberi.

214
00:13:12,470 --> 00:13:16,920
Quindi la funzione di hash che ho usato non era molto ben distribuiti.

215
00:13:16,920 --> 00:13:20,710
Quando diciamo ben distribuita, vuol dire che vogliamo avere,

216
00:13:20,710 --> 00:13:26,520
circa, almeno 1 o 2 per ciascuno dei -

217
00:13:26,520 --> 00:13:32,190
come, una differenza di 1 o 2 per ciascuno degli indici negli array.

218
00:13:32,190 --> 00:13:43,950
Volete avere, più o meno, lo stesso numero di elementi in ogni lista collegata nella matrice.

219
00:13:43,950 --> 00:13:48,600
Ed è facile controllare se è valido per la tabella hash, vista come tabelle hash.

220
00:13:48,600 --> 00:13:51,770
Poi >> alberi. Questo è un albero.

221
00:13:51,770 --> 00:13:56,400
Alberi in informatica sono a testa in giù per qualche motivo.

222
00:13:56,400 --> 00:14:00,150
Quindi, proprio qui si ha la radice dell'albero e poi le foglie.

223
00:14:00,150 --> 00:14:05,630
Si deve solo conoscere la nomenclatura per i genitori e il bambino.

224
00:14:05,630 --> 00:14:12,880
Ogni nodo ha i suoi figli, che sono i nodi che sono sotto il genitore.

225
00:14:12,880 --> 00:14:19,660
Così, per esempio, 2 sta per essere il genitore per 3 e per l'altro bambino lì,

226
00:14:19,660 --> 00:14:25,290
mentre il 3 sta per essere il genitore di uno e gli altri bambini che ci sono.

227
00:14:25,290 --> 00:14:29,990
E 1 sta per essere minore di 3, e così via.

228
00:14:29,990 --> 00:14:34,610
Abbiamo qualcosa di molto più interessante, chiamato un albero binario di ricerca,

229
00:14:34,610 --> 00:14:39,040
in cui tutti i valori a destra di un nodo

230
00:14:39,040 --> 00:14:41,660
stanno per essere sulla destra, proprio qui - a destra,

231
00:14:41,660 --> 00:14:46,780
stanno per essere superiore a quella dell'elemento nella radice.

232
00:14:46,780 --> 00:14:49,780
Quindi, se ho il numero 5 proprio qui, tutti gli elementi a destra

233
00:14:49,780 --> 00:14:51,940
stanno per essere maggiore di 5, e sulla sinistra

234
00:14:51,940 --> 00:14:56,770
tutti gli elementi stanno per essere inferiore a 5.

235
00:14:56,770 --> 00:14:58,780
Perché è utile?

236
00:14:58,780 --> 00:15:01,660
Beh, se voglio controllare se il numero 7 è qui, per esempio,

237
00:15:01,660 --> 00:15:05,960
Vado a 5 prima e vado a vedere, è di 7 maggiore o minore di 5?

238
00:15:05,960 --> 00:15:09,540
E 'grande, quindi so che sta andando ad avere per essere sulla destra dell'albero.

239
00:15:09,540 --> 00:15:13,980
Così ho molto meno roba da guardare.

240
00:15:13,980 --> 00:15:19,520
In attuazione di un albero binario di ricerca, il nodo, sto solo andando ad avere dati,

241
00:15:19,520 --> 00:15:21,750
così int n, si potrebbe anche avere una stringa

242
00:15:21,750 --> 00:15:23,630
o tutto ciò che volevamo.

243
00:15:23,630 --> 00:15:28,100
Devi solo stare attenti a definire ciò che è più grande, ciò che è meno.

244
00:15:28,100 --> 00:15:30,390
Quindi, se tu avessi stringhe, per esempio, è possibile definire

245
00:15:30,390 --> 00:15:34,690
che tutte quelle cose di destra stanno per avere una lunghezza maggiore,

246
00:15:34,690 --> 00:15:40,940
sinistra stanno per avere lunghezze inferiori, quindi è davvero a te.

247
00:15:40,940 --> 00:15:44,930
>> Come posso implementare trovare per BST?

248
00:15:44,930 --> 00:15:47,840
La prima cosa che dovremo fare è controllare se la radice è NULL.

249
00:15:47,840 --> 00:15:50,920
Se è NULL, significa che la cosa non c'è

250
00:15:50,920 --> 00:15:53,330
perché non hanno nemmeno un albero, giusto?

251
00:15:53,330 --> 00:15:55,790
Così torno falso.

252
00:15:55,790 --> 00:15:58,740
Altrimenti, io vado a controllare se il numero è maggiore

253
00:15:58,740 --> 00:16:01,720
al valore nella radice.

254
00:16:01,720 --> 00:16:04,250
Io vado a cercare di trovare l'elemento sulla destra

255
00:16:04,250 --> 00:16:08,590
dell'albero.

256
00:16:08,590 --> 00:16:11,310
Si vede che sto usando la ricorsione qui.

257
00:16:11,310 --> 00:16:14,150
E poi se è meno, sto andando a guardare a sinistra.

258
00:16:14,150 --> 00:16:18,330
E, infine, altrimenti, se è uguale o non superiore,

259
00:16:18,330 --> 00:16:20,660
significa che è il valore stesso.

260
00:16:20,660 --> 00:16:23,010
Così ho appena ritorno vero.

261
00:16:23,010 --> 00:16:26,360
Potete vedere qui che ho usato, se, se, se.

262
00:16:26,360 --> 00:16:30,820
E ricordate, nel quiz 0, abbiamo avuto un problema che ha avuto, se, se, se,

263
00:16:30,820 --> 00:16:32,780
e tu dovevi trovare l'inefficienza,

264
00:16:32,780 --> 00:16:35,180
e l'inefficienza è che si è utilizzato se.

265
00:16:35,180 --> 00:16:39,060
Avresti dovuto utilizzare se, else if, else if, e altro.

266
00:16:39,060 --> 00:16:44,240
Quindi, dovrei usare else if e else if e altro qui?

267
00:16:44,240 --> 00:16:46,200
Qualcuno - sì?

268
00:16:46,200 --> 00:16:51,140
[Parlando Studente, incomprensibile]

269
00:16:51,140 --> 00:16:53,480
È perfetto. Quindi lei sta dicendo che non importa,

270
00:16:53,480 --> 00:16:55,930
solo perché l'inefficienza che avevamo prima

271
00:16:55,930 --> 00:16:59,550
sia perché, forse se qualche condizione è stata soddisfatta,

272
00:16:59,550 --> 00:17:03,570
così è stata eseguita un'azione, ma poi si erano andando a controllare tutte le altre condizioni.

273
00:17:03,570 --> 00:17:06,319
Ma in questo caso, è tornata subito, quindi non importa.

274
00:17:06,319 --> 00:17:09,220
Quindi non c'è bisogno di usare else if.

275
00:17:09,220 --> 00:17:11,740
>> E, infine, parliamo di tentativi,

276
00:17:11,740 --> 00:17:13,800
che è preferito da tutti.

277
00:17:13,800 --> 00:17:15,980
Una meta è un albero di array.

278
00:17:15,980 --> 00:17:20,369
E 'molto veloce per cercare valori, ma utilizza un sacco di memoria.

279
00:17:20,369 --> 00:17:22,530
E di solito è di filtrare le parole, in modo che quando si

280
00:17:22,530 --> 00:17:27,920
desidera implementare, per esempio, non so, come una rubrica telefonica nel telefono

281
00:17:27,920 --> 00:17:30,440
e si vuole essere in grado di digitare B

282
00:17:30,440 --> 00:17:32,510
e solo nomi di persone che hanno B.

283
00:17:32,510 --> 00:17:37,960
E 'molto facile da implementare che l'utilizzo di una prova, per esempio.

284
00:17:37,960 --> 00:17:39,820
Come si fa a definire un nodo in una prova?

285
00:17:39,820 --> 00:17:43,910
Devi solo avere un bool che sta per essere is_word.

286
00:17:43,910 --> 00:17:48,660
Che rappresenta che utilizzando tutti i caratteri prima tale nodo,

287
00:17:48,660 --> 00:17:51,920
sono stati in grado di formare una parola,

288
00:17:51,920 --> 00:17:57,230
e poi avrete un array di puntatori ai nodi.

289
00:17:57,230 --> 00:18:03,120
Riuscite a vedere che abbiamo un array di nodi padre, quindi il nodo * array? Sì?

290
00:18:03,120 --> 00:18:06,050
Quindi vediamo come che funzionerà. Per il controllo ortografico,

291
00:18:06,050 --> 00:18:08,230
abbiamo un array di 27 elementi,

292
00:18:08,230 --> 00:18:12,150
perché abbiamo tutte le lettere più l'apostrofo.

293
00:18:12,150 --> 00:18:17,800
Prima qui Sto solo andando a utilizzare 2 perché voglio essere in grado di scrivere sulla scheda.

294
00:18:17,800 --> 00:18:20,230
Ok. Quindi questo è un esempio di una prova.

295
00:18:20,230 --> 00:18:25,600
Se ho appena definisco il primo nodo, avrò un array di due elementi

296
00:18:25,600 --> 00:18:29,290
che sono 2 puntatori a NULL, quindi ho solo messo 'a' e 'b'.

297
00:18:29,290 --> 00:18:32,430
E ho intenzione di avere un bool che dice is_word.

298
00:18:32,430 --> 00:18:34,420
Sta andando essere false per il primo,

299
00:18:34,420 --> 00:18:37,370
proprio perché, prima che non avete alcun carattere.

300
00:18:37,370 --> 00:18:40,900
Così una parola vuota non è una parola. Quindi è falso.

301
00:18:40,900 --> 00:18:46,320
Se voglio aggiungere 'a' per questo dizionario, cosa avrei dovuto fare?

302
00:18:46,320 --> 00:18:49,760
Vorrei solo avere a malloc un nuovo nodo per 'a',

303
00:18:49,760 --> 00:18:54,630
e poi aggiungere la sua parola vera.

304
00:18:54,630 --> 00:19:00,180
Quindi rappresenta solo che avendo 'a' sta per essere vero. Dare un senso?

305
00:19:00,180 --> 00:19:04,120
Poi se voglio aggiungere 'ba', dovrò malloc 1 per 'b',

306
00:19:04,120 --> 00:19:07,550
e poi ho intenzione di impostare il valore booleano false,

307
00:19:07,550 --> 00:19:10,160
perche 'b' di per sé non è una parola.

308
00:19:10,160 --> 00:19:13,010
Poi ho intenzione di malloc un altro per 'a', cosi 'ba',

309
00:19:13,010 --> 00:19:16,290
e poi ho intenzione di creare è una parola vera.

310
00:19:16,290 --> 00:19:18,950
Perche 'ba' è una parola.

311
00:19:18,950 --> 00:19:21,910
E poi se voglio vedere se 'b' è in questo dizionario,

312
00:19:21,910 --> 00:19:26,730
Posso solo andare al primo, 'b'. Vado giù, e guardo è la parola, e si dice falso.

313
00:19:26,730 --> 00:19:30,110
Quindi non è una parola. Se voglio controllare 'ba',

314
00:19:30,110 --> 00:19:38,010
Vado al primo, 'b', e poi andare a 'a', e vedo vero, quindi è una parola. Dare un senso?

315
00:19:38,010 --> 00:19:41,950
Un sacco di gente si confonda con tentativi. No?

316
00:19:41,950 --> 00:19:44,740
>> Infine, codifica Huffman. Codifica Huffman è molto utile

317
00:19:44,740 --> 00:19:47,550
per risparmiare memoria e comprimere i file di testo,

318
00:19:47,550 --> 00:19:52,270
solo perché un sacco di volte che si usa 'a' e 'e', ​​per esempio,

319
00:19:52,270 --> 00:19:57,710
nei documenti, ma non so se voi ragazzi l'uso 'q' o 'z' tanto.

320
00:19:57,710 --> 00:20:02,040
Avendo appena 1 byte per ogni singolo carattere,

321
00:20:02,040 --> 00:20:08,520
ogni singola - 256 personaggi che abbiamo nella tabella ASCII non è molto ottimale,

322
00:20:08,520 --> 00:20:11,410
solo perché ci sono alcuni personaggi che si utilizza molto di più,

323
00:20:11,410 --> 00:20:15,180
quindi probabilmente si dovrebbe utilizzare meno memoria per quelli.

324
00:20:15,180 --> 00:20:17,560
Come faccio a utilizzare codifica di Huffman?

325
00:20:17,560 --> 00:20:20,010
Dobbiamo fare un albero di Huffman.

326
00:20:20,010 --> 00:20:23,370
 Un albero di Huffman ha nodi

327
00:20:23,370 --> 00:20:27,760
che hanno un simbolo che sta per essere come, 'a', 'b', 'c', la lettera,

328
00:20:27,760 --> 00:20:32,990
qualunque sia la lettera che hai, una frequenza che è la frequenza che appare la parola nel testo,

329
00:20:32,990 --> 00:20:36,280
che si stava creando l'albero di Huffman per,

330
00:20:36,280 --> 00:20:41,800
e poi un nodo che sta per puntare a fianco dell'albero di Huffman

331
00:20:41,800 --> 00:20:47,210
e un altro nodo che sta per puntare a destra. Quindi, proprio come un albero.

332
00:20:47,210 --> 00:20:49,440
Come si costruisce un albero di Huffman?

333
00:20:49,440 --> 00:20:54,020
Stai andando a prendere i nodi 2 che hanno le frequenze più basse.

334
00:20:54,020 --> 00:20:56,490
Se si dispone di un pareggio si sta andando a prendere i 2 nodi

335
00:20:56,490 --> 00:20:59,870
che hanno i valori ASCII bassi pure.

336
00:20:59,870 --> 00:21:02,420
Poi si sta andando a creare una nuova struttura di quei 2 nodi

337
00:21:02,420 --> 00:21:08,030
che sta per avere la frequenza combinata nel nodo genitore.

338
00:21:08,030 --> 00:21:13,240
E allora si sta andando a togliere le 2 bambini dalla foresta

339
00:21:13,240 --> 00:21:15,570
e sostituirli con il genitore.

340
00:21:15,570 --> 00:21:18,930
E si sta andando a ripetere che fino ad avere solo 1 albero nella foresta.

341
00:21:18,930 --> 00:21:23,840
Vediamo quindi come si dovrebbe fare un albero di Huffman per ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Potete vedere qui che tutte le lettere hanno frequenza 1, fatta eccezione per 'A', che ha frequenza 2.

343
00:21:29,220 --> 00:21:34,090
Così ho creato nodi per tutte le lettere che ho messo in ordine di valore ASCII e frequenza.

344
00:21:34,090 --> 00:21:40,090
Quindi, se voglio creare il primo albero, sarà con 'L' e 'M'.

345
00:21:40,090 --> 00:21:43,100
Quindi è qui. La frequenza della coppia sarà 2

346
00:21:43,100 --> 00:21:49,470
perché è 1 + 1, quindi il prossimo 2 con le frequenze più basse sono 'Y' e 'Z'.

347
00:21:49,470 --> 00:21:53,180
E poi ho tutti loro essere - hanno una frequenza di 2.

348
00:21:53,180 --> 00:22:00,470
Quindi, quali sono quelli che hanno il valore ASCII più basso per il prossimo?

349
00:22:00,470 --> 00:22:04,830
'A' e 'L'. Così ho creato il nuovo nodo,

350
00:22:04,830 --> 00:22:09,930
e, infine, è 4 e 2, SO 2 sarà sulla sinistra.

351
00:22:09,930 --> 00:22:12,430
E questo è l'albero di Huffman.

352
00:22:12,430 --> 00:22:16,060
Poi se voglio scrivere un testo,

353
00:22:16,060 --> 00:22:24,440
come in binario da convertire in testo, utilizzando l'albero di Huffman è molto facile.

354
00:22:24,440 --> 00:22:30,220
Ad esempio, se dico che il passaggio a sinistra è uno 0 e lo spostamento a destra è un 1,

355
00:22:30,220 --> 00:22:32,410
Che cosa è che andando a rappresentare?

356
00:22:32,410 --> 00:22:35,530
Così come 1, 1, così giusto, giusto,

357
00:22:35,530 --> 00:22:40,370
e poi 0, quindi sinistra sarebbe L, e poi 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Quindi 1, 0, quindi basta 1, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
E quindi 0, 1, così 'Z'.

360
00:22:47,540 --> 00:22:52,170
E poi 1, 0, 0 - no.

361
00:22:52,170 --> 00:22:56,780
0, 0 sara 'Y', così pigro.

362
00:22:56,780 --> 00:23:06,060
Ecco, questo è tutto per me, Rob sta per prendere il sopravvento.

363
00:23:06,060 --> 00:23:08,400
>> [Rob Bowden] Così, la settimana 7 roba.

364
00:23:08,400 --> 00:23:11,390
Abbiamo un sacco di andare oltre veramente veloce.

365
00:23:11,390 --> 00:23:13,430
Operatori bit a bit, buffer overflow,

366
00:23:13,430 --> 00:23:16,760
Biblioteca CS50, quindi HTML, HTTP, CSS.

367
00:23:16,760 --> 00:23:20,990
Tutto come 15 a 20 minuti.

368
00:23:20,990 --> 00:23:24,330
Operatori bit a bit. Ci sono 6 di loro che è necessario sapere.

369
00:23:24,330 --> 00:23:31,200
Bitwise e, bit per bit o, XOR, spostamento a sinistra, spostamento a destra, e non.

370
00:23:31,200 --> 00:23:35,420
Spostamento a destra e non è poco visto nella lezione a tutti.

371
00:23:35,420 --> 00:23:40,480
Andremo su di esso in fretta qui, ma è bene sapere che questi sono i 6 che esistono.

372
00:23:40,480 --> 00:23:45,070
Ricordate che gli operatori bit per bit sono come quando si fa 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Non a che fare con i binari del 3 e 4.

374
00:23:49,420 --> 00:23:56,550
Con gli operatori bit a bit in realtà si sta trattando con i singoli bit dei numeri 3 e 4.

375
00:23:56,550 --> 00:23:59,120
>> Così il primo che diremo è bit per bit non è,

376
00:23:59,120 --> 00:24:02,340
e tutto ciò che fa è capovolgere tutti i bit.

377
00:24:02,340 --> 00:24:05,500
Così qui, se si sta scrivendo questo in C, si sarebbe non scrivere

378
00:24:05,500 --> 00:24:09,380
come ~ 11011 o qualsiasi altra cosa, si dovrebbe scrivere come ~ 4,

379
00:24:09,380 --> 00:24:12,970
e allora sarebbe capovolgere la rappresentazione binaria di 4.

380
00:24:12,970 --> 00:24:24,800
Così qui, ~ di qualche numero binario 1101101 sta per lanciare esattamente tutti i 1 di 0 e tutti gli 0 a 1 di.

381
00:24:24,800 --> 00:24:27,600
Come ho detto lì, l'uso frequente di questo,

382
00:24:27,600 --> 00:24:30,830
e vedremo in un po ', è come vogliamo venire con qualche numero

383
00:24:30,830 --> 00:24:35,460
dove tutti i bit sono 1, tranne per uno di loro.

384
00:24:35,460 --> 00:24:38,560
Quindi di solito è più facile esprimere il numero

385
00:24:38,560 --> 00:24:40,630
dove è ambientato proprio questo singolo bit,

386
00:24:40,630 --> 00:24:44,650
e poi prendere il ~ di esso, così ogni altro bit è impostato ad eccezione di quello.

387
00:24:44,650 --> 00:24:50,300
Ecco, questo è quello che abbiamo intenzione di utilizzare più di un po '.

388
00:24:50,300 --> 00:24:58,220
>> OR bit per bit. Qui ci sono due numeri binari, e di questi 2 numeri

389
00:24:58,220 --> 00:25:00,780
sono abbastanza rappresentativo, in quanto rappresentano ogni possibile

390
00:25:00,780 --> 00:25:07,290
combinazione di bit che si potrebbe avere bisogno di operare su.

391
00:25:07,290 --> 00:25:13,540
Qui, quando ho in OR ogni bit, stiamo solo andando a confrontare dritto verso il basso.

392
00:25:13,540 --> 00:25:15,410
Quindi, sul lato sinistro abbiamo un 1 e 1.

393
00:25:15,410 --> 00:25:20,510
Quando ho Bitwise | chi, cosa posso ottenere? Uno.

394
00:25:20,510 --> 00:25:25,320
Poi bit a bit | 0 e 1 sta per darmi? Uno.

395
00:25:25,320 --> 00:25:27,840
Bit 1 e 0 sta per essere la stessa cosa, uno.

396
00:25:27,840 --> 00:25:31,880
Bitwise 0 | 0 sta per darmi 0.

397
00:25:31,880 --> 00:25:37,300
Quindi l'unico caso in cui ottengo 0 è nel 0 | 0 caso.

398
00:25:37,300 --> 00:25:40,020
E si può pensare che, proprio come i vostri ors logiche.

399
00:25:40,020 --> 00:25:44,830
Quindi, se pensate di uno come vero e 0 come falso, la stessa cosa vale qui.

400
00:25:44,830 --> 00:25:50,040
Così vero o vero è vero, vero o falso è vero.

401
00:25:50,040 --> 00:25:57,150
Falso o vero è vero, falso o falso è l'unica cosa che in realtà è falso.

402
00:25:57,150 --> 00:26:00,100
Ecco l'esempio che si deve sapere

403
00:26:00,100 --> 00:26:05,160
come un buon esempio di quando si utilizzano gli operatori bit a bit.

404
00:26:05,160 --> 00:26:08,660
Qui se noi o il capitale 'A' con OX20,

405
00:26:08,660 --> 00:26:11,830
e vedremo questi in un secondo, otteniamo qualcosa.

406
00:26:11,830 --> 00:26:16,020
E se noi o minuscolo 'a' con OX20, otteniamo qualcosa.

407
00:26:16,020 --> 00:26:26,750
Quindi cerchiamo di tirare su tabella ASCII.

408
00:26:26,750 --> 00:26:34,000
Ok. Qui vediamo che 'A' è -

409
00:26:34,000 --> 00:26:36,920
qui abbiamo 'A' è decimale 65.

410
00:26:36,920 --> 00:26:45,120
Ma io andrò con esadecimale, che è Ox41.

411
00:26:45,120 --> 00:26:48,280
Abbastanza sicuro che abbiamo visto in classe. Penso che abbiamo visto in classe

412
00:26:48,280 --> 00:26:52,730
che è abbastanza facile convertire da esadecimale a binario.

413
00:26:52,730 --> 00:26:55,280
Così qui, se voglio mettere 4 in binario,

414
00:26:55,280 --> 00:26:59,550
questo è solo sarà 0100.

415
00:26:59,550 --> 00:27:03,620
Questo è uno di posto, 2 di posto, 4 di posto, quindi questo è 4.

416
00:27:03,620 --> 00:27:08,550
Poi posso dividere 1 in binario, che sta per essere 0001.

417
00:27:08,550 --> 00:27:14,280
E così questo sta andando essere la rappresentazione di 'A' in binario.

418
00:27:14,280 --> 00:27:22,720
Prendendo minuscolo 'a', è ora sta per essere Ox61,

419
00:27:22,720 --> 00:27:27,050
dove, dividendo questi fino nel suo binario, quindi un 6 -

420
00:27:27,050 --> 00:27:37,830
Facciamo effettivamente farlo - non c'è una gomma? Eraser.

421
00:27:37,830 --> 00:27:48,220
Ox61. Quindi, dividendo il 6 in binario sarà 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
E splitting 1 sta per essere 0001.

423
00:27:54,610 --> 00:27:56,520
Guardando la differenza tra questi 2,

424
00:27:56,520 --> 00:28:04,250
vediamo che l'unica differenza tra una minuscola e maiuscola 'A' è il singolo bit.

425
00:28:04,250 --> 00:28:11,810
Quindi, tornando a qui - va bene.

426
00:28:11,810 --> 00:28:15,920
Tornando a qui, se guardiamo a ciò che il bit di OX20 è,

427
00:28:15,920 --> 00:28:22,210
così splitting OX20 nel suo binario,

428
00:28:22,210 --> 00:28:27,310
è 0010, 0000.

429
00:28:27,310 --> 00:28:33,470
OX20, l'unico bit che viene impostato questo bit che ci occupiamo,

430
00:28:33,470 --> 00:28:38,210
con la commutazione tra capitale e minuscole 'a'.

431
00:28:38,210 --> 00:28:47,610
Se io o 'A', che è questo, 'A',

432
00:28:47,610 --> 00:28:50,580
se io o 'A' con OX20,

433
00:28:50,580 --> 00:28:53,490
cosa posso ottenere?

434
00:28:53,490 --> 00:28:58,960
[Studente, incomprensibile] >> Minuscole 'a', perché sta andando a capovolgere questo bit a 1.

435
00:28:58,960 --> 00:29:04,170
E se io o 'a' con OX20, cosa posso ottenere?

436
00:29:04,170 --> 00:29:08,780
Minuscola, perché appena oring 'a' con OX20,

437
00:29:08,780 --> 00:29:14,580
Sto solo andando a essere oring questo singolo bit a 1: è già uno, quindi non importa.

438
00:29:14,580 --> 00:29:17,960
Così otteniamo 'a' e 'a'.

439
00:29:17,960 --> 00:29:24,820
>> Bitwise e. Ancora una volta, possiamo pensare a questo come nostra controparte logico e.

440
00:29:24,820 --> 00:29:28,180
Sul lato sinistro abbiamo il vero e vero.

441
00:29:28,180 --> 00:29:31,160
Sta per essere vero, e per tutti i casi,

442
00:29:31,160 --> 00:29:36,270
falso e vero o vero e falso, o falso e falso,

443
00:29:36,270 --> 00:29:38,550
nessuna di queste cose sono vere.

444
00:29:38,550 --> 00:29:44,170
Allora, cosa si finisce per ottenere è 1000.

445
00:29:44,170 --> 00:29:48,830
Così ora, qui, qui è dove ho usato il bit non fidato,

446
00:29:48,830 --> 00:29:52,230
dove abbiamo avuto OX20.

447
00:29:52,230 --> 00:29:54,350
Quindi questo è OX20.

448
00:29:54,350 --> 00:29:59,570
Ora quello che voglio fare, bit per bit ~ di OX20.

449
00:29:59,570 --> 00:30:03,600
Che sta per capovolgere tutti i bit.

450
00:30:03,600 --> 00:30:09,330
Così ho 1101, 1111.

451
00:30:09,330 --> 00:30:18,940
E cosi 'A' AND con ~ OX20 sta per darmi cosa?

452
00:30:18,940 --> 00:30:22,430
L'unico bit di cui abbiamo veramente bisogno di pensare è questo,

453
00:30:22,430 --> 00:30:26,020
poiché, se tutti questi bit sono impostati a 1,

454
00:30:26,020 --> 00:30:29,000
allora stiamo andando a ottenere esattamente quello 'A' è stato,

455
00:30:29,000 --> 00:30:31,260
tranne, eventualmente, ciò che questo bit è.

456
00:30:31,260 --> 00:30:34,460
Perché se si trattava di un 1, ora che sta per essere impostato a 0,

457
00:30:34,460 --> 00:30:39,810
perché qualunque cosa sia, AND con questo sta per essere 0.

458
00:30:39,810 --> 00:30:43,280
Allora, qual è 'A' e ~ OX20 intenzione di darmi?

459
00:30:43,280 --> 00:30:48,200
[Gli studenti rispondono, incomprensibile] >> E che è 'a' e - è 'A'.

460
00:30:48,200 --> 00:30:52,170
E ciò che è 'a' e ~ OX20 intenzione di darmi?

461
00:30:52,170 --> 00:30:56,720
'A.' Poiché questo è attualmente un 1.

462
00:30:56,720 --> 00:30:59,570
Anding con questo 0 sta andando a fare un 0,

463
00:30:59,570 --> 00:31:02,530
e ora stiamo andando a ottenere una 'A'.

464
00:31:02,530 --> 00:31:06,600
>> Entrambi sono 'A', e, ultimo ma non meno importante di questo tipo,

465
00:31:06,600 --> 00:31:10,830
abbiamo XOR. E 'molto simile o,

466
00:31:10,830 --> 00:31:14,400
tranne significa esclusivamente o.

467
00:31:14,400 --> 00:31:18,420
Questo è come ciò che di solito si pensa di come o nel mondo reale.

468
00:31:18,420 --> 00:31:23,190
Quindi si esegue una 'x' o 'y', ma non entrambi.

469
00:31:23,190 --> 00:31:28,700
Qui 1 ^ 1 sta per essere 0.

470
00:31:28,700 --> 00:31:33,650
Perché vero, questo è - non funziona così con la logica vero e il falso

471
00:31:33,650 --> 00:31:37,150
come bit & e o fare,

472
00:31:37,150 --> 00:31:40,100
ma vero ^ vero è falso.

473
00:31:40,100 --> 00:31:44,810
Poiché vogliamo solo restituire true se solo uno di loro è vero.

474
00:31:44,810 --> 00:31:50,950
Quindi 1 ^ 1 è 0. Che dire 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
È 1. 1 ^ 0 è 1, 0 ^ 0 è 0.

476
00:31:56,010 --> 00:32:03,890
Così in tutte le circostanze, 0 bit per bit qualcosa 0 sta per essere 0.

477
00:32:03,890 --> 00:32:10,270
1 bit per bit qualcosa 0 o 0 bit 1,

478
00:32:10,270 --> 00:32:14,660
se si tratta di | o ^, sarà un 1, e se è e sarà 0.

479
00:32:14,660 --> 00:32:20,850
E l'unico caso in cui 1 bit 1 non è 1 è con esclusivo o.

480
00:32:20,850 --> 00:32:24,580
Questo è 0110.

481
00:32:24,580 --> 00:32:36,520
Così qui ora, utilizzando XOR - quindi siamo di nuovo a 20.

482
00:32:36,520 --> 00:32:43,480
'A' ^ OX20 è questi 2 bit stiamo confrontando.

483
00:32:43,480 --> 00:32:50,020
Così un 1 ^ 0 sta per darmi una cosa? Un'unica.

484
00:32:50,020 --> 00:32:58,430
'A' ^ OX20 sta per darmi? Minuscola.

485
00:32:58,430 --> 00:33:04,010
'A' ^ OX20 sta per darmi? Capital A.

486
00:33:04,010 --> 00:33:09,310
Poiché qualunque cosa stia facendo, questo XOR con OX20

487
00:33:09,310 --> 00:33:15,380
effettivamente lanciando qualunque cosa questo bit è.

488
00:33:15,380 --> 00:33:21,240
Se questo è un 0, è ora sta per diventare un 1.

489
00:33:21,240 --> 00:33:26,160
Poiché questo è un 1, 1 ^ 1 è 0.

490
00:33:26,160 --> 00:33:33,280
Così la nostra 'a' è diventato 'A', e il nostro 'A' è diventato 'a'.

491
00:33:33,280 --> 00:33:36,910
Quindi XOR è un modo davvero conveniente di soli lanciando il caso.

492
00:33:36,910 --> 00:33:39,960
Si vuole solo iterare su una stringa di lettere

493
00:33:39,960 --> 00:33:44,330
e alternare il caso di ogni singolo carattere,

494
00:33:44,330 --> 00:33:50,680
basta XOR tutto con OX20.

495
00:33:50,680 --> 00:33:55,220
>> Ora abbiamo lasciato turno. Spostamento a sinistra è solo andare a, in sostanza,

496
00:33:55,220 --> 00:34:01,250
spingere tutti i numeri in, o verso sinistra, ed inserire 0 di spalle.

497
00:34:01,250 --> 00:34:05,550
Quindi qui abbiamo 00.001.101.

498
00:34:05,550 --> 00:34:08,560
Stiamo andando a spingere 3 0 di dalla destra,

499
00:34:08,560 --> 00:34:13,580
e otteniamo 01.101.000.

500
00:34:13,580 --> 00:34:16,380
In termini non binari,

501
00:34:16,380 --> 00:34:24,699
vediamo che ciò che è realmente trattare 13 sinistra spostata con 3, che ci dà 104.

502
00:34:24,699 --> 00:34:32,530
Quindi spostamento a sinistra, vediamo qui, x << y è fondamentalmente x * 2 ^ y.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 è 8, quindi 13 * 8 è 104.

504
00:34:40,139 --> 00:34:45,679
Se solo pensate binario in generale, come ogni cifra,

505
00:34:45,679 --> 00:34:49,530
se partiamo da destra, è il 1 del posto, poi il 2 del luogo, poi il 4 del luogo.

506
00:34:49,530 --> 00:34:51,330
Quindi, spingendo in 0 di dalla destra,

507
00:34:51,330 --> 00:34:55,080
stiamo solo spingendo le cose che erano in 4, del posto alla 8 del luogo,

508
00:34:55,080 --> 00:34:57,920
e le cose che erano in 8 del posto per il 16 del posto.

509
00:34:57,920 --> 00:35:01,280
Ogni turno solo moltiplica per 2. Sì?

510
00:35:01,280 --> 00:35:05,210
[Studente] Cosa succede se si sposta di 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] Se spostata di 5 volete solo perdere cifre.

512
00:35:10,790 --> 00:35:15,410
Inevitabilmente, è la stessa cosa. Come, interi sono solo 32 bit,

513
00:35:15,410 --> 00:35:20,750
quindi se si aggiungono due davvero grandi numeri interi, semplicemente non si adatta in un numero intero.

514
00:35:20,750 --> 00:35:23,660
Quindi è la stessa cosa qui. Se si sposta di 5,

515
00:35:23,660 --> 00:35:25,650
ci sarebbe solo perdere quello.

516
00:35:25,650 --> 00:35:28,820
E questo è il tipo di cosa intendo per "grosso modo",

517
00:35:28,820 --> 00:35:37,470
dove se si sposta troppo lontano, si perde bit.

518
00:35:37,470 --> 00:35:39,830
>> Spostamento a destra sarà il contrario,

519
00:35:39,830 --> 00:35:43,090
dove stiamo andando a spingere 0 di fuori alla fine,

520
00:35:43,090 --> 00:35:48,400
e per i nostri scopi, riempire di 0 da sinistra.

521
00:35:48,400 --> 00:35:52,910
Così facendo, stiamo praticamente invertendo quello che avevamo già fatto.

522
00:35:52,910 --> 00:35:57,780
E vediamo che i tre 0 di di destra hanno appena caduto,

523
00:35:57,780 --> 00:36:02,020
e abbiamo spinto 1101 completamente verso destra.

524
00:36:02,020 --> 00:36:08,380
Questo fa 104 >> 3, che è, di fatto, x / 2 ^ y.

525
00:36:08,380 --> 00:36:11,200
Così ora, qui, è una idea simile.

526
00:36:11,200 --> 00:36:18,720
Perché è solo di circa x / 2 ^ y, e in realtà non x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
Perché se avessi spostato da 4, avrei perso un 1.

528
00:36:22,240 --> 00:36:25,950
In sostanza, cosa ne pensate di, basti pensare divisione intera in generale.

529
00:36:25,950 --> 00:36:31,070
Così, come 5/2 è 2. Non è 2.5.

530
00:36:31,070 --> 00:36:35,000
E 'la stessa idea. Quando dividiamo per 2,

531
00:36:35,000 --> 00:36:39,910
possiamo perdere bit dispari lungo la strada.

532
00:36:39,910 --> 00:36:43,870
Così ora - che è tutto per bit. Questo è tutto quello che dovete sapere.

533
00:36:43,870 --> 00:36:46,340
Ricordate i casi d'uso che abbiamo visto in classe,

534
00:36:46,340 --> 00:36:49,340
come una maschera di bit è utile per gli operatori bit per bit,

535
00:36:49,340 --> 00:36:53,220
o li si usa per maschere di bit.

536
00:36:53,220 --> 00:36:58,620
Le lettere maiuscole e minuscole, conversioni è un esempio piuttosto prototipo.

537
00:36:58,620 --> 00:37:01,640
>> Okay, attacchi di buffer overflow.

538
00:37:01,640 --> 00:37:05,110
Qualcuno ricorda cosa c'era di sbagliato in questa funzione?

539
00:37:05,110 --> 00:37:10,140
AVVISO abbiamo dichiarato un array di 12 byte, 12 caratteri,

540
00:37:10,140 --> 00:37:18,510
e poi copiamo nel nostro buffer di 12 caratteri l'intera barra stringa.

541
00:37:18,510 --> 00:37:25,080
Allora qual è il problema?

542
00:37:25,080 --> 00:37:32,270
Il numero magico 12 dovrebbe praticamente subito pop come - perché 12?

543
00:37:32,270 --> 00:37:35,050
E se bar sembra essere più di 12 caratteri?

544
00:37:35,050 --> 00:37:41,200
Che cosa succede se bar è milioni di caratteri?

545
00:37:41,200 --> 00:37:46,010
Qui la questione è memcpy. Se il bar è abbastanza lungo,

546
00:37:46,010 --> 00:37:50,330
sarà solo completamente - 'c', 'c' non importa che fosse solo 12 caratteri;

547
00:37:50,330 --> 00:37:53,280
'C' non importa che non può andare bene che molti byte.

548
00:37:53,280 --> 00:37:58,250
E 'solo completamente sovrascrivere char, i 12 byte che abbiamo assegnato per esso,

549
00:37:58,250 --> 00:38:01,830
e tutto passato in memoria che in realtà non appartiene a tale buffer

550
00:38:01,830 --> 00:38:06,520
con qualunque sia il bar stringa è.

551
00:38:06,520 --> 00:38:09,780
Quindi questa era l'immagine che abbiamo visto in classe

552
00:38:09,780 --> 00:38:12,220
dove abbiamo la nostra pila crescita.

553
00:38:12,220 --> 00:38:16,040
Si dovrebbe essere usato per queste foto o familiarizzare con loro.

554
00:38:16,040 --> 00:38:21,260
Noi abbiamo la nostra pila crescita, gli indirizzi di memoria partono da 0 al top

555
00:38:21,260 --> 00:38:26,270
e crescere fino a come 4 miliardi al fondo.

556
00:38:26,270 --> 00:38:28,820
Noi abbiamo la nostra matrice 'c' da qualche parte nella memoria,

557
00:38:28,820 --> 00:38:32,260
poi abbiamo il nostro puntatore al bar proprio sotto di esso,

558
00:38:32,260 --> 00:38:38,720
e poi abbiamo questo puntatore al frame salvati nel nostro indirizzo di ritorno e lo stack di nostra routine genitore.

559
00:38:38,720 --> 00:38:40,800
Ricordate ciò che l'indirizzo di ritorno è?

560
00:38:40,800 --> 00:38:45,360
E 'quando main chiama una funzione foo, richiama una barra delle funzioni,

561
00:38:45,360 --> 00:38:48,100
inevitabilmente, bar ritorni.

562
00:38:48,100 --> 00:38:52,610
Così, quando torna a barre, hanno bisogno di sapere che sta andando di nuovo a foo che la chiamava.

563
00:38:52,610 --> 00:39:01,360
Così l'indirizzo di ritorno è l'indirizzo della funzione che deve tornare quando la funzione ritorna.

564
00:39:01,360 --> 00:39:05,830
La ragione per cui è importante per attacchi di buffer overflow è perché, convenientemente,

565
00:39:05,830 --> 00:39:09,580
hacker piace cambiare tale indirizzo di ritorno.

566
00:39:09,580 --> 00:39:14,950
Invece di tornare a foo, ho intenzione di tornare laddove l'hacker vuole che io vada indietro.

567
00:39:14,950 --> 00:39:17,760
E, convenientemente, dove l'hacker vuole frequentemente per tornare a

568
00:39:17,760 --> 00:39:22,400
è l'inizio del buffer che originariamente abbiamo avuto.

569
00:39:22,400 --> 00:39:26,170
Quindi notare, ancora una volta, Little Indian.

570
00:39:26,170 --> 00:39:28,490
L'apparecchio è un esempio di un sistema Little Indian,

571
00:39:28,490 --> 00:39:34,140
così un numero intero o un puntatore vengono memorizzati con i byte invertiti.

572
00:39:34,140 --> 00:39:38,980
Così qui si vede - è questo? Già.

573
00:39:38,980 --> 00:39:45,660
Vediamo Ox80, OxC0, Ox35, OxO8.

574
00:39:45,660 --> 00:39:48,250
Ricordate le cifre esadecimali?

575
00:39:48,250 --> 00:39:50,640
Noi non invertire le cifre esadecimali Little Indian,

576
00:39:50,640 --> 00:39:56,110
perché due cifre esadecimali costituiscono un singolo byte, e invertire i byte.

577
00:39:56,110 --> 00:40:00,300
Ecco perché noi non conserviamo, come, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Memorizziamo, invece, ogni coppia di 2 cifre, partendo da destra.

579
00:40:07,520 --> 00:40:10,880
Questo indirizzo si riferisce l'indirizzo di inizio

580
00:40:10,880 --> 00:40:15,190
della nostra buffer che in realtà volevamo copiare nel in primo luogo.

581
00:40:15,190 --> 00:40:19,230
La ragione per cui è utile perché, che cosa se l'attaccante

582
00:40:19,230 --> 00:40:24,100
accaduto, invece di avere una stringa che era solo

583
00:40:24,100 --> 00:40:27,060
una stringa innocuo di simile, il proprio nome o qualcosa,

584
00:40:27,060 --> 00:40:33,900
cosa succede se, invece, tale stringa erano solo alcuni di codice arbitrario

585
00:40:33,900 --> 00:40:38,610
che facevano quello che volevano fare?

586
00:40:38,610 --> 00:40:45,630
Così si potrebbe - non riesco a pensare di qualsiasi codice cool.

587
00:40:45,630 --> 00:40:47,780
Potrebbe essere qualsiasi cosa, però. Qualsiasi codice disastroso.

588
00:40:47,780 --> 00:40:51,440
Se volevano, potevano solo fare qualcosa a difetti segmenti, ma che sarebbe inutile.

589
00:40:51,440 --> 00:40:54,950
Di solito lo fanno per incidere il vostro sistema.

590
00:40:54,950 --> 00:40:59,930
Va bene >>. Biblioteca CS50.

591
00:40:59,930 --> 00:41:04,800
Questo è, in sostanza, getInt, getString, tutte quelle funzioni che previsto per voi.

592
00:41:04,800 --> 00:41:10,630
Così abbiamo stringa char *, e questo è l'astrazione che ci ha sconvolti

593
00:41:10,630 --> 00:41:12,450
ad un certo punto durante il semestre.

594
00:41:12,450 --> 00:41:18,220
Ricordate che una stringa è solo un array di caratteri.

595
00:41:18,220 --> 00:41:23,240
Quindi qui vediamo una versione ridotta di getString.

596
00:41:23,240 --> 00:41:25,920
Si dovrebbe guardare indietro per ricordare come è effettivamente implementata.

597
00:41:25,920 --> 00:41:30,950
Dettagli chiave sono, notiamo entriamo in un singolo carattere alla volta

598
00:41:30,950 --> 00:41:34,570
da standard, che è proprio come noi digitando sulla tastiera.

599
00:41:34,570 --> 00:41:37,890
Quindi, un singolo carattere alla volta, e se otteniamo troppi caratteri,

600
00:41:37,890 --> 00:41:40,580
quindi se n + 1 è maggiore di capacità,

601
00:41:40,580 --> 00:41:44,140
allora abbiamo bisogno di aumentare la capacità del nostro buffer.

602
00:41:44,140 --> 00:41:47,780
Così qui stiamo raddoppiando le dimensioni della nostra buffer.

603
00:41:47,780 --> 00:41:51,840
E che continua a andare, inseriamo il carattere nella nostra tampone

604
00:41:51,840 --> 00:41:56,220
finché non riceviamo una nuova linea o fine del file o qualsiasi altra cosa,

605
00:41:56,220 --> 00:41:59,380
in questo caso, abbiamo finito con la corda e poi la vera getString

606
00:41:59,380 --> 00:42:05,120
restringe la memoria, come se noi assegnato troppa memoria che andrà indietro e ridurre un po '.

607
00:42:05,120 --> 00:42:08,830
Quindi noi non mostriamo che, ma l'idea principale è

608
00:42:08,830 --> 00:42:11,960
si deve leggere in un singolo carattere alla volta.

609
00:42:11,960 --> 00:42:17,140
Non può semplicemente leggere in una cosa completamente in una sola volta,

610
00:42:17,140 --> 00:42:19,550
perché il loro buffer è solo di una certa dimensione.

611
00:42:19,550 --> 00:42:26,590
Quindi, se la stringa che si cerca di inserire nel buffer è troppo grande, allora sarebbe traboccare.

612
00:42:26,590 --> 00:42:28,940
Così qui impediamo che da solo leggendo in un solo carattere

613
00:42:28,940 --> 00:42:33,750
alla volta e crescente quando occorre.

614
00:42:33,750 --> 00:42:40,270
Così getInt e le altre funzioni di libreria CS50 tendono ad usare getString

615
00:42:40,270 --> 00:42:42,310
nelle loro implementazioni.

616
00:42:42,310 --> 00:42:45,370
Così ho evidenziato le cose importanti qui.

617
00:42:45,370 --> 00:42:49,460
Chiede getString per ottenere una stringa.

618
00:42:49,460 --> 00:42:51,710
Se getString non è riuscito a riportare la memoria,

619
00:42:51,710 --> 00:42:54,270
ricordate che getString mallocs qualcosa, così ogni volta che si chiama getString

620
00:42:54,270 --> 00:42:57,820
non si dovrebbe (incomprensibile) liberare la stringa che avete ottenuto.

621
00:42:57,820 --> 00:43:02,870
Così qui, se non è riuscito a malloc qualcosa, torniamo INT_MAX solo come una bandiera che,

622
00:43:02,870 --> 00:43:05,650
ehi, non siamo stati effettivamente in grado di ottenere un numero intero.

623
00:43:05,650 --> 00:43:10,830
Si consiglia di ignorare qualsiasi cosa io tornerò a voi, o

624
00:43:10,830 --> 00:43:15,540
Non si dovrebbe trattare questo come un input valido.

625
00:43:15,540 --> 00:43:21,360
Infine, supponendo che riuscirono, usiamo sscanf con quella bandiera speciale,

626
00:43:21,360 --> 00:43:23,820
il che significa, in primo luogo corrispondere a un numero intero,

627
00:43:23,820 --> 00:43:26,770
poi corrispondere qualsiasi carattere dopo integer.

628
00:43:26,770 --> 00:43:29,070
Così notiamo vogliamo che uguale a 1.

629
00:43:29,070 --> 00:43:32,940
Ritorna così sscanf quante partite se effettuate con successo?

630
00:43:32,940 --> 00:43:37,010
Si restituirà 1 se abbinato con successo un numero intero,

631
00:43:37,010 --> 00:43:40,890
verrà restituito 0 se non corrisponde a un numero intero, e rinvierà 2

632
00:43:40,890 --> 00:43:45,920
se abbinato un numero intero seguito da qualche personaggio.

633
00:43:45,920 --> 00:43:49,780
Così notiamo ci riproveremo se abbiniamo tutt'altro 1.

634
00:43:49,780 --> 00:43:55,230
Quindi, se siamo entrati 1, 2, 3, C, o 1, 2, 3, X,

635
00:43:55,230 --> 00:43:57,400
poi 1, 2, 3 otterrebbe memorizzato il numero intero,

636
00:43:57,400 --> 00:43:59,620
X otterrebbe memorizzato sul personaggio,

637
00:43:59,620 --> 00:44:06,410
sscanf sarebbero tornati 2, e vorremmo riprovare, perché vogliamo solo un numero intero.

638
00:44:06,410 --> 00:44:09,810
>> Soffia rapidamente tramite HTML, HTTP, CSS.

639
00:44:09,810 --> 00:44:15,340
HyperText Markup Language è la struttura e la semantica del web.

640
00:44:15,340 --> 00:44:19,960
Ecco l'esempio della lezione dove abbiamo tag HTML.

641
00:44:19,960 --> 00:44:22,110
Abbiamo tag head, tag body,

642
00:44:22,110 --> 00:44:27,770
abbiamo esempi di tag vuoti dove in realtà non hanno un inizio e tag di chiusura,

643
00:44:27,770 --> 00:44:30,820
dobbiamo solo collegamento e di immagine.

644
00:44:30,820 --> 00:44:38,480
Non c'è nessun tag di immagine di chiusura; c'è solo un unico tag che compie tutto ciò che il tag deve fare.

645
00:44:38,480 --> 00:44:41,950
Il collegamento è un esempio, vedremo come si collega a CSS,

646
00:44:41,950 --> 00:44:45,910
la sceneggiatura è un esempio di come ci si collega a un JavaScript esterno.

647
00:44:45,910 --> 00:44:53,100
E 'piuttosto semplice, e ricordate, HTML non è un linguaggio di programmazione.

648
00:44:53,100 --> 00:44:58,250
Ecco, ricordate come si definirebbe un modulo, o almeno ciò che questo avrebbe fatto?

649
00:44:58,250 --> 00:45:01,740
Tale modulo ha un'azione ed un metodo.

650
00:45:01,740 --> 00:45:06,210
I metodi si avrà solo mai vedere sono GET e POST.

651
00:45:06,210 --> 00:45:09,040
Così GET è la versione in cui la cosa viene messo nell'URL.

652
00:45:09,040 --> 00:45:11,680
POST è dove non viene messo nell'URL.

653
00:45:11,680 --> 00:45:18,520
Invece, i dati nel modulo viene inserito più nascosta nella richiesta HTTP.

654
00:45:18,520 --> 00:45:22,390
Così qui, l'azione definisce dove la richiesta HTTP va.

655
00:45:22,390 --> 00:45:27,490
Dove sta andando è google.com / search.

656
00:45:27,490 --> 00:45:32,890
Metodo. Ricordate le differenze tra GET e POST,

657
00:45:32,890 --> 00:45:37,200
e, basta dire ad esempio, se si desidera creare un segnalibro qualcosa.

658
00:45:37,200 --> 00:45:40,660
Non sarete mai in grado di contrassegnare un URL POST

659
00:45:40,660 --> 00:45:44,970
perché i dati non è incluso nel URL.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, ora, è HyperText Transfer Protocol.

661
00:45:49,790 --> 00:45:54,080
L'HyperText Transfer Protocol, ci si aspetterebbe che il trasferimento

662
00:45:54,080 --> 00:45:57,710
HyperText Markup Language, e lo fa.

663
00:45:57,710 --> 00:46:00,170
Ma si trasferisce anche le immagini che trovate sul Web,

664
00:46:00,170 --> 00:46:05,400
tutti i download che fate partono da una richiesta HTTP.

665
00:46:05,400 --> 00:46:10,350
Così HTTP è solo la lingua del World Wide Web..

666
00:46:10,350 --> 00:46:15,610
E qui è necessario riconoscere questo tipo di una richiesta HTTP.

667
00:46:15,610 --> 00:46:19,300
Qui HTTP/1.1 sul lato dice solo che è la versione

668
00:46:19,300 --> 00:46:21,570
del protocollo che sto utilizzando.

669
00:46:21,570 --> 00:46:25,770
E 'quasi sempre sarà HTTP/1.1, come lo vedrete.

670
00:46:25,770 --> 00:46:30,110
Poi vediamo che questo era GET, l'alternativa essendo POST, che si potrebbe vedere.

671
00:46:30,110 --> 00:46:40,790
E l'URL che stavo cercando di fare era www.google.com/search?q = blah, blah, blah.

672
00:46:40,790 --> 00:46:44,240
Quindi ricorda che questo, il punto di domanda q = blah blah blah,

673
00:46:44,240 --> 00:46:49,040
è il genere di cose che viene inviato da un form.

674
00:46:49,040 --> 00:46:51,830
La risposta potrebbe tornare a me sarebbe simile a questa.

675
00:46:51,830 --> 00:46:54,050
Ancora una volta, a partire dal protocollo, che sta per essere tale,

676
00:46:54,050 --> 00:46:59,190
seguito dal codice di stato. Qui è 200 OK.

677
00:46:59,190 --> 00:47:05,060
E, infine, la pagina web che in realtà ho chiesto sarà seguita.

678
00:47:05,060 --> 00:47:08,210
L'eventuale codice di stato si potrebbe vedere, e si dovrebbe sapere alcuni di loro.

679
00:47:08,210 --> 00:47:12,770
200 OK probabilmente avete visto prima.

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

681
00:47:17,830 --> 00:47:22,140
di solito se si va a un sito web e qualcosa di rotto o loro crash di codice PHP,

682
00:47:22,140 --> 00:47:24,930
mentre nel appliance abbiamo quella grande scatola arancione

683
00:47:24,930 --> 00:47:27,830
che viene e dice, come, qualcosa non va, questo codice non funziona

684
00:47:27,830 --> 00:47:30,380
o del male questa funzione.

685
00:47:30,380 --> 00:47:33,230
Di solito i siti web non vogliono farvi sapere che cosa funzioni sono effettivamente male,

686
00:47:33,230 --> 00:47:37,880
così invece faranno solo ti danno 500 errori interni del server.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP è uno strato sotto HTTP.

688
00:47:43,050 --> 00:47:47,550
Ricordate che c'è Internet al di fuori del World Wide Web..

689
00:47:47,550 --> 00:47:52,270
Come se si gioca un gioco online che non passa attraverso HTTP,

690
00:47:52,270 --> 00:47:55,740
sta andando attraverso una diversa - è ancora l'uso di Internet,

691
00:47:55,740 --> 00:47:58,900
ma non utilizza HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP è solo un esempio di protocollo costruita su TCP / IP.

693
00:48:02,470 --> 00:48:07,820
IP letteralmente significa Internet Protocol.

694
00:48:07,820 --> 00:48:11,500
Ogni computer ha un indirizzo IP, ma sono quelle cose a 4 cifre

695
00:48:11,500 --> 00:48:16,510
come 192.168.2.1, o qualsiasi altra cosa, che tende ad essere un locale.

696
00:48:16,510 --> 00:48:23,390
Ma questo è il modello di un indirizzo IP.

697
00:48:23,390 --> 00:48:29,060
Così il DNS, Domain Name Service,

698
00:48:29,060 --> 00:48:33,410
questo è quello che traduce le cose come google.com a un indirizzo IP reale.

699
00:48:33,410 --> 00:48:37,700
Quindi, se si digita l'indirizzo IP in un URL,

700
00:48:37,700 --> 00:48:40,850
che avrebbe portato a Google, ma si tende a non ricordare queste cose.

701
00:48:40,850 --> 00:48:45,470
Si tende a ricordare google.com invece.

702
00:48:45,470 --> 00:48:51,560
L'ultima cosa che abbiamo è porti, se questa è la parte TCP IP.

703
00:48:51,560 --> 00:48:54,880
TCP fa più. Pensate, come, avete il browser in esecuzione web.

704
00:48:54,880 --> 00:48:58,670
Forse hai qualche applicazione in esecuzione di posta elettronica;

705
00:48:58,670 --> 00:49:02,150
forse hai qualche altro programma che utilizza il funzionamento di Internet.

706
00:49:02,150 --> 00:49:05,090
Tutti hanno bisogno l'accesso a Internet,

707
00:49:05,090 --> 00:49:08,100
ma il computer ha solo 1 scheda WiFi o qualsiasi altra cosa.

708
00:49:08,100 --> 00:49:10,780
Così le porte sono il modo che siamo in grado di dividere

709
00:49:10,780 --> 00:49:13,550
come queste applicazioni sono in grado di utilizzare Internet.

710
00:49:13,550 --> 00:49:17,230
Ogni applicazione riceve 1 porta specifica che è possibile ascoltare su,

711
00:49:17,230 --> 00:49:19,670
e per impostazione predefinita, HTTP utilizza la porta 80.

712
00:49:19,670 --> 00:49:22,410
Alcuni servizi di posta elettronica utilizzano 25.

713
00:49:22,410 --> 00:49:24,490
Quelli numero basso tendono ad essere riservati.

714
00:49:24,490 --> 00:49:29,270
Siete solitamente in grado di ottenere quelle superiore numerati per te.

715
00:49:29,270 --> 00:49:32,010
>> CSS, Cascading Style Sheets.

716
00:49:32,010 --> 00:49:36,030
Pagine web Noi di stile con i CSS, non con HTML.

717
00:49:36,030 --> 00:49:38,440
Ci sono 3 posti potete mettere il vostro CSS.

718
00:49:38,440 --> 00:49:46,300
Può essere in linea, tra tag di stile, o in un file completamente separato e poi legato trovi

719
00:49:46,300 --> 00:49:48,470
E qui è solo un esempio di CSS.

720
00:49:48,470 --> 00:49:50,450
Si dovrebbe riconoscere questo modello,

721
00:49:50,450 --> 00:49:54,310
dove il primo esempio è che stiamo abbinando il tag body,

722
00:49:54,310 --> 00:49:56,680
e qui stiamo centrando il tag body.

723
00:49:56,680 --> 00:50:00,420
Il secondo esempio, ci sono corrispondenti la cosa

724
00:50:00,420 --> 00:50:04,740
piè di pagina con ID, e stiamo applicando alcuni stili a questo.

725
00:50:04,740 --> 00:50:07,310
Si noti che l'ID piè di pagina di testo si allinea a sinistra,

726
00:50:07,310 --> 00:50:09,840
che il corpo di testo allinea centro.

727
00:50:09,840 --> 00:50:13,180
Piè di pagina è all'interno del corpo.

728
00:50:13,180 --> 00:50:16,470
Sarà, invece, text-align sinistra, anche se il corpo dice centro text-align.

729
00:50:16,470 --> 00:50:18,880
Questa è la parte intera cascata di esso.

730
00:50:18,880 --> 00:50:22,110
Si può avere - è possibile specificare gli stili per il corpo,

731
00:50:22,110 --> 00:50:25,320
e poi le cose nel corpo è possibile specificare gli stili più specifici,

732
00:50:25,320 --> 00:50:28,160
e le cose funzionano come previsto.

733
00:50:28,160 --> 00:50:34,420
Più specifici identificatori CSS hanno la precedenza.

734
00:50:34,420 --> 00:50:46,140
Penso che sia esso.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Ciao a tutti. Se solo potessi ottenere la vostra attenzione.

736
00:50:49,260 --> 00:50:53,990
Sono Ali e ho intenzione di passare attraverso PHP e SQL veramente veloce.

737
00:50:53,990 --> 00:51:00,310
Così possiamo iniziare. PHP è l'abbreviazione di PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
E come tutti voi dovreste sapere, è un linguaggio di scripting server-side,

739
00:51:03,730 --> 00:51:06,800
e lo usiamo per il back-end di siti web,

740
00:51:06,800 --> 00:51:12,540
e come si fa un sacco di calcoli, la parte dietro quinte.

741
00:51:12,540 --> 00:51:17,510
Sintassi. Non è come C, sorpresa, sorpresa.

742
00:51:17,510 --> 00:51:22,060
Si deve sempre iniziare con la, se si può vedere, la - non posso andare avanti.

743
00:51:22,060 --> 00:51:31,340
Potete vedere avete bisogno dei nuovi tipi di parentesi graffe e quindi è necessario anche l'? Php.

744
00:51:31,340 --> 00:51:35,780
Questo è sempre come si deve inquadrare il testo PHP, il codice PHP.

745
00:51:35,780 --> 00:51:39,180
Quindi non può essere solo come C, dove è sorta di metterlo al primo.

746
00:51:39,180 --> 00:51:42,290
Hai bisogno di circondarsi di sempre.

747
00:51:42,290 --> 00:51:47,610
E ora, la sintassi principale è che tutte le variabili devono iniziare con il carattere $.

748
00:51:47,610 --> 00:51:49,490
Hai bisogno di fare quando si sta definendo loro, devi farlo

749
00:51:49,490 --> 00:51:51,860
quando ti riferisci a loro in seguito.

750
00:51:51,860 --> 00:51:56,510
Hai sempre bisogno che $. E 'il tuo nuovo migliore amico, più o meno.

751
00:51:56,510 --> 00:52:01,690
Non è - a differenza di C, non c'è bisogno di mettere che tipo di tipo di variabile che è.

752
00:52:01,690 --> 00:52:04,940
Così, mentre si ha bisogno il $, non c'è bisogno di mettere, come,

753
00:52:04,940 --> 00:52:09,470
int x o una stringa y, eccetera, eccetera.

754
00:52:09,470 --> 00:52:11,490
Quindi una leggera differenza.

755
00:52:11,490 --> 00:52:15,590
Come risultato di questo, significa che PHP è un tipo debolmente.

756
00:52:15,590 --> 00:52:19,310
PHP è un linguaggio di tipo debolmente, ed è debolmente tipizzato variabili.

757
00:52:19,310 --> 00:52:24,020
In altre parole, questo significa che è possibile passare tra i diversi tipi di tipi di variabili.

758
00:52:24,020 --> 00:52:27,230
È possibile memorizzare il proprio numero 1 come un int,

759
00:52:27,230 --> 00:52:29,650
è possibile memorizzare come una stringa, e si può archiviare come un float,

760
00:52:29,650 --> 00:52:33,550
e sarà tutto quel numero 1.

761
00:52:33,550 --> 00:52:36,080
Anche se si sta riporlo in forme diverse,

762
00:52:36,080 --> 00:52:39,120
è ancora - i tipi di variabili sono ancora in mano alla fine.

763
00:52:39,120 --> 00:52:41,540
Quindi, se si guarda qui, se vi ricordate di pset 7,

764
00:52:41,540 --> 00:52:43,500
molti di voi probabilmente hanno avuto problemi con questo.

765
00:52:43,500 --> 00:52:47,280
Due segni di uguale, 3 segni di uguale, 4 segni uguali.

766
00:52:47,280 --> 00:52:49,990
Ok, ci sono 4 segni uguali, ma ci sono 2 e 3.

767
00:52:49,990 --> 00:52:53,320
Si utilizza due segni uguali per controllare i valori.

768
00:52:53,320 --> 00:52:55,830
Si può controllare tra i tipi.

769
00:52:55,830 --> 00:52:58,770
Quindi, se si può vedere al primo esempio,

770
00:52:58,770 --> 00:53:02,210
Ho num_int == num_string.

771
00:53:02,210 --> 00:53:06,710
Così il vostro int e la stringa sono entrambi tecnicamente, 1,

772
00:53:06,710 --> 00:53:10,790
ma sono tipi diversi. Ma per i doppi uguale, sarà ancora passare.

773
00:53:10,790 --> 00:53:15,510
Tuttavia, per l'uguale triple, esso controlla il valore così come i vari tipi.

774
00:53:15,510 --> 00:53:18,760
Ciò significa che non sta andando a passare in quel secondo caso qui,

775
00:53:18,760 --> 00:53:22,350
dove si sta utilizzando invece 3 segni uguali.

776
00:53:22,350 --> 00:53:26,590
Quindi questa è una differenza importante: che tutti avete dimostrato oggi.

777
00:53:26,590 --> 00:53:31,570
>> Concatenazione di stringhe è un'altra cosa potente è possibile utilizzare in PHP.

778
00:53:31,570 --> 00:53:34,080
E 'fondamentalmente solo questa notazione del punto a portata di mano,

779
00:53:34,080 --> 00:53:36,230
ed è così che è possibile associare stringhe.

780
00:53:36,230 --> 00:53:40,800
Quindi, se avete Gatto e avete Dog, e si vuole mettere insieme i due archi,

781
00:53:40,800 --> 00:53:44,080
è possibile utilizzare il periodo, e questo è una specie di come funziona.

782
00:53:44,080 --> 00:53:46,660
È anche possibile metterli uno accanto all'altro,

783
00:53:46,660 --> 00:53:49,030
come potete vedere qui nell'esempio in basso,

784
00:53:49,030 --> 00:53:51,610
dove ho echo stringa 1, spazio stringa 2.

785
00:53:51,610 --> 00:53:56,930
PHP saprà sostituirli in quanto tali.

786
00:53:56,930 --> 00:53:59,780
Array. Ora, in PHP, ci sono 2 diversi tipi di matrici.

787
00:53:59,780 --> 00:54:03,180
Si possono avere array regolari, e si può anche avere array associativi,

788
00:54:03,180 --> 00:54:06,040
e stiamo per passare attraverso di loro in questo momento.

789
00:54:06,040 --> 00:54:08,280
Array regolari sono solo questo in C,

790
00:54:08,280 --> 00:54:11,240
e in modo da avere indici che sono numerati.

791
00:54:11,240 --> 00:54:13,160
In questo momento stiamo solo andando a creare uno e mettere -

792
00:54:13,160 --> 00:54:15,500
quindi questo è il modo in cui creiamo un array vuoto, allora stiamo andando a

793
00:54:15,500 --> 00:54:17,310
messo nel numero di indice 0.

794
00:54:17,310 --> 00:54:19,200
Stiamo andando a mettere il numero 6, il valore 6.

795
00:54:19,200 --> 00:54:21,500
Lo si può vedere in fondo qui.

796
00:54:21,500 --> 00:54:24,240
Where's - al numero di indice 1 andremo a mettere valore il numero 4,

797
00:54:24,240 --> 00:54:26,720
e così si può vedere c'è un 6, c'è un 4,

798
00:54:26,720 --> 00:54:29,160
e poi come stiamo stampa le cose,

799
00:54:29,160 --> 00:54:33,550
quando cerchiamo e stampiamo il valore memorizzato al numero di indice 0,

800
00:54:33,550 --> 00:54:36,900
poi vedremo il valore 6 in fase di stampa fuori. Cool?

801
00:54:36,900 --> 00:54:40,160
Ecco, questo è array regolari per voi.

802
00:54:40,160 --> 00:54:42,750
Un altro modo è possibile anche aggiungere le cose da array regolari ora

803
00:54:42,750 --> 00:54:44,780
è che si può semplicemente aggiungere alla fine.

804
00:54:44,780 --> 00:54:47,240
Ciò significa che non è necessario specificare l'indice specifico.

805
00:54:47,240 --> 00:54:51,000
È possibile visualizzare il numero, e poi nelle parentesi quadre non c'è alcun indice specificato.

806
00:54:51,000 --> 00:54:56,270
E si sa - PHP saprà aggiungere solo alla fine della lista, il prossimo posto libero.

807
00:54:56,270 --> 00:54:59,190
Così si può vedere il 1 proprio lì in quel punto 0,

808
00:54:59,190 --> 00:55:02,690
il 2 è andato proprio lì al primo posto.

809
00:55:02,690 --> 00:55:04,690
Il 3 va - è aggiunto anche lì.

810
00:55:04,690 --> 00:55:06,720
Quindi, che tipo di senso. Stai solo costantemente aggiungendo che,

811
00:55:06,720 --> 00:55:09,360
e poi quando siamo riecheggiando l'indice del numero 1,

812
00:55:09,360 --> 00:55:13,080
si stamperà il valore 2.

813
00:55:13,080 --> 00:55:16,800
>> Poi ci sono le matrici che sono array associativi.

814
00:55:16,800 --> 00:55:19,370
Array associativi, invece di avere indici numerici,

815
00:55:19,370 --> 00:55:23,630
quello che fanno è, hanno indici che sono da stringa.

816
00:55:23,630 --> 00:55:25,670
Si può vedere, invece - mi sono liberato di tutti quegli indici numerici,

817
00:55:25,670 --> 00:55:32,140
e ora è key1, key2, key3, e sono tra virgolette per significare che sono tutte le stringhe.

818
00:55:32,140 --> 00:55:34,470
Quindi possiamo avere un esempio di questo.

819
00:55:34,470 --> 00:55:38,790
L'esempio di questo è che abbiamo il tf, e questo è il nome di indice.

820
00:55:38,790 --> 00:55:42,030
Stiamo andando a mettere "Ali", come il nome, all'indice, calorie consumate,

821
00:55:42,030 --> 00:55:47,640
possiamo mettere un int questa volta invece di una stringa,

822
00:55:47,640 --> 00:55:52,240
e poi del calibro di indice, possiamo mettere un intero array all'interno di esso.

823
00:55:52,240 --> 00:55:55,490
Quindi questo è una specie di - è un concetto simile a come abbiamo avuto

824
00:55:55,490 --> 00:55:58,930
indici con i numeri, ma ora siamo in grado di cambiare gli indici intorno

825
00:55:58,930 --> 00:56:03,890
di averli come stringhe, invece.

826
00:56:03,890 --> 00:56:06,070
È anche possibile fare questo, oltre solo farlo individualmente,

827
00:56:06,070 --> 00:56:09,400
si può fare tutto in un unico pezzo. Così si può vedere che tf di tale matrice,

828
00:56:09,400 --> 00:56:13,350
e poi li abbiamo tutti insieme in un unico gigantesco set parentesi quadra.

829
00:56:13,350 --> 00:56:15,220
Quindi, che può accelerare le cose.

830
00:56:15,220 --> 00:56:19,730
E 'più di una scelta stilistica che non.

831
00:56:19,730 --> 00:56:21,550
Abbiamo anche loop.

832
00:56:21,550 --> 00:56:26,020
In C abbiamo loop che funzionano in questo modo.

833
00:56:26,020 --> 00:56:29,690
Avevamo il nostro array, e siamo andati dall'indice 0 alla fine della lista,

834
00:56:29,690 --> 00:56:31,740
e noi stampiamo tutto, giusto?

835
00:56:31,740 --> 00:56:33,880
Tranne il problema è, per gli array associativi,

836
00:56:33,880 --> 00:56:36,610
noi non sappiamo necessariamente tali indici numerici

837
00:56:36,610 --> 00:56:39,610
perché ora abbiamo gli indici di stringa.

838
00:56:39,610 --> 00:56:44,800
Ora usiamo cicli foreach, che, ancora una volta, si spera usato in pset 7.

839
00:56:44,800 --> 00:56:48,930
Cicli foreach sarà solo conoscere ogni singola parte della lista.

840
00:56:48,930 --> 00:56:52,450
E non ha bisogno di sapere esattamente l'indice numerico che avete.

841
00:56:52,450 --> 00:56:56,490
Così si ha la sintassi di foreach, quindi è foreach, si mette la matrice.

842
00:56:56,490 --> 00:57:00,430
Quindi il mio array è chiamato pset, e poi come, la parola,

843
00:57:00,430 --> 00:57:04,530
e poi mettete questa variabile temporanea locale che si sta andando ad utilizzare

844
00:57:04,530 --> 00:57:10,690
solo per la cosa specifica che sta per tenere la specifica -

845
00:57:10,690 --> 00:57:14,770
un'istanza o una sezione della matrice.

846
00:57:14,770 --> 00:57:18,350
Pset num terrà 1, e poi magari si terrà il numero 6,

847
00:57:18,350 --> 00:57:20,410
e poi si terrà la numero 2.

848
00:57:20,410 --> 00:57:26,630
Ma è garantito a passare attraverso ogni singolo valore che è nella matrice.

849
00:57:26,630 --> 00:57:30,530
Funzioni utili che si deve sapere in PHP sono i requisiti,

850
00:57:30,530 --> 00:57:35,880
in modo che si assicura che si sta tra cui alcuni file, eco, uscita, vuoto.

851
00:57:35,880 --> 00:57:40,490
Mi raccomando guardate pset 7 e guardare quelle funzioni.

852
00:57:40,490 --> 00:57:42,810
Potrebbe essere necessario sapere chi,

853
00:57:42,810 --> 00:57:47,060
quindi vorrei assolutamente sapere che cosa, esattamente, quelli sono tutti facendo.

854
00:57:47,060 --> 00:57:50,080
>> E ora stiamo per passare attraverso portata molto velocemente.

855
00:57:50,080 --> 00:57:53,490
Nel campo di applicazione, PHP è una specie di cosa funky, a differenza di C,

856
00:57:53,490 --> 00:57:56,170
e così stiamo solo andando a passare attraverso di essa in fretta.

857
00:57:56,170 --> 00:57:58,930
Quindi diciamo che iniziamo a quella freccia che abbiamo lì.

858
00:57:58,930 --> 00:58:02,900
E stiamo per iniziare con $ i. Quindi la variabile 'i' sta per essere 0,

859
00:58:02,900 --> 00:58:06,730
e stiamo solo andando a continuare a stampare in quella grande scatola bianca laggiù.

860
00:58:06,730 --> 00:58:09,220
Stiamo per iniziare con I0, e poi andremo a risuonare esso.

861
00:58:09,220 --> 00:58:12,670
Quindi c'è lo 0.

862
00:58:12,670 --> 00:58:15,210
E poi andremo a incrementare dal ciclo for,

863
00:58:15,210 --> 00:58:17,810
e poi sarà il valore di 1.

864
00:58:17,810 --> 00:58:20,070
Uno è inferiore a 3, quindi sta andando a passare attraverso quel ciclo for,

865
00:58:20,070 --> 00:58:23,230
e poi andremo a vederlo stampato di nuovo.

866
00:58:23,230 --> 00:58:25,520
Stiamo andando a incrementare nuovamente per 2,

867
00:58:25,520 --> 00:58:29,860
e 2 è inferiore a 3, quindi passerà il ciclo for, e sarà stampare il 2.

868
00:58:29,860 --> 00:58:35,100
Poi si noterà che 3 non è inferiore a 3, quindi ti scoppiare del ciclo for.

869
00:58:35,100 --> 00:58:40,050
Così ora abbiamo usciti, e poi stiamo per andare in aFunction.

870
00:58:40,050 --> 00:58:45,010
Ok. Quindi bisogna notare che questa variabile che abbiamo creato,

871
00:58:45,010 --> 00:58:48,270
la 'i' variabile, non è ambito locale.

872
00:58:48,270 --> 00:58:50,280
Ciò significa che non è locale al ciclo,

873
00:58:50,280 --> 00:58:58,060
e quella variabile possiamo ancora accedere e modificare in seguito, e sarà ancora efficace.

874
00:58:58,060 --> 00:59:02,160
Quindi, se si va nella funzione adesso, vedrai che usiamo anche la 'i' variabile,

875
00:59:02,160 --> 00:59:05,320
e stiamo andando a incrementare 'i' + +.

876
00:59:05,320 --> 00:59:09,410
Si potrebbe pensare, in un primo momento, sulla base di C, quella che è una copia della 'i' variabile.

877
00:59:09,410 --> 00:59:12,830
E 'una cosa totalmente diversa, che è corretto.

878
00:59:12,830 --> 00:59:16,560
Così, quando stampiamo, noi andremo a stampare 'i' + +, che sta per stampare che il 4,

879
00:59:16,560 --> 00:59:19,640
e poi andremo a - mi dispiace.

880
00:59:19,640 --> 00:59:22,030
Poi stiamo andando a finire fuori di tale funzione,

881
00:59:22,030 --> 00:59:24,820
e stiamo per essere dove quella freccia è adesso.

882
00:59:24,820 --> 00:59:29,190
Ciò significa che poi, però, anche se la funzione ha modificato il valore di 'i',

883
00:59:29,190 --> 00:59:32,620
non ha cambiato di fuori della funzione,

884
00:59:32,620 --> 00:59:35,060
perché la funzione ha un ambito separato.

885
00:59:35,060 --> 00:59:38,960
Ciò significa che quando abbiamo eco 'i', ma non è cambiato nel campo di applicazione della funzione,

886
00:59:38,960 --> 00:59:43,660
e così poi andremo a stampare nuovamente 3.

887
00:59:43,660 --> 00:59:47,520
Le cose diverse circa la portata in PHP che in C.

888
00:59:47,520 --> 00:59:51,130
>> Ora in PHP e HTML.

889
00:59:51,130 --> 00:59:53,510
PHP è utilizzato per rendere le pagine web dinamiche.

890
00:59:53,510 --> 00:59:58,660
E 'sorta di rende le cose diverse.

891
00:59:58,660 --> 01:00:02,090
Abbiamo diverso da HTML.

892
01:00:02,090 --> 01:00:05,230
Con HTML, abbiamo sempre e solo abbiamo la stessa cosa statica, come come Rob ha mostrato,

893
01:00:05,230 --> 01:00:09,370
considerando che PHP, è possibile cambiare le cose in base a chi l'utente.

894
01:00:09,370 --> 01:00:11,830
Quindi, se ho questo, ho "Tu sei loggato come -" e poi il nome,

895
01:00:11,830 --> 01:00:14,420
e posso cambiare il nome. Così adesso il nome è Giuseppe,

896
01:00:14,420 --> 01:00:18,880
e ha il "about me", ma poi posso anche cambiare il nome di avere Tommy.

897
01:00:18,880 --> 01:00:21,700
E sarebbe una cosa diversa.

898
01:00:21,700 --> 01:00:23,840
Allora possiamo anche cambiare diverse cose su di lui,

899
01:00:23,840 --> 01:00:27,070
e mostrerà contenuti diversi in base al nome.

900
01:00:27,070 --> 01:00:31,430
Così PHP può cambiare tipo di quello che sta succedendo nel tuo sito web.

901
01:00:31,430 --> 01:00:33,540
Stesso qui. Ancora, si noti che hanno contenuti diversi,

902
01:00:33,540 --> 01:00:38,870
anche se si sta ancora tecnicamente accede stessa pagina web in superficie.

903
01:00:38,870 --> 01:00:43,450
Generazione di HTML. Ci sono 2 modi diversi che si può fare questo.

904
01:00:43,450 --> 01:00:48,980
Quindi andremo attraverso quel momento. Il primo modo è quello, hai - sì, mi dispiace.

905
01:00:48,980 --> 01:00:51,150
Quindi basta avere il vostro normale ciclo for in PHP,

906
01:00:51,150 --> 01:00:56,270
e poi echo in PHP e HTML echo fuori.

907
01:00:56,270 --> 01:00:58,720
Utilizzando quello che Rob vi ha mostrato di script HTML

908
01:00:58,720 --> 01:01:04,030
e quindi utilizzando la stampa PHP per stampare appena fuori alla pagina web.

909
01:01:04,030 --> 01:01:09,520
La via alternativa è farlo come se separare il PHP e HTML.

910
01:01:09,520 --> 01:01:11,940
Così si può avere una linea di PHP che avvia il ciclo for,

911
01:01:11,940 --> 01:01:16,020
allora si può avere la linea del HTML in una cosa separata,

912
01:01:16,020 --> 01:01:19,700
e poi si finisce il ciclo, ancora una volta, con un PHP.

913
01:01:19,700 --> 01:01:21,800
Quindi è una specie di separazione fuori.

914
01:01:21,800 --> 01:01:24,020
Sul lato sinistro, è possibile che avete tutta la -

915
01:01:24,020 --> 01:01:26,360
è solo 1 pezzo di PHP.

916
01:01:26,360 --> 01:01:28,510
Sulla destra si può vedere che avete una linea di PHP,

917
01:01:28,510 --> 01:01:32,540
si dispone di una linea di HTML, e si dispone ancora di una linea di PHP.

918
01:01:32,540 --> 01:01:36,870
Così separa fuori in quello che stanno facendo.

919
01:01:36,870 --> 01:01:39,330
E noterete che in entrambi i casi, per una di esse,

920
01:01:39,330 --> 01:01:41,980
ancora stampare l'immagine, l'immagine, l'immagine,

921
01:01:41,980 --> 01:01:44,540
cosicché HTML ancora è stampato allo stesso modo.

922
01:01:44,540 --> 01:01:49,870
E poi ci si può comunque vedere le tre immagini mostrano sul tuo sito web.

923
01:01:49,870 --> 01:01:52,820
Quindi è 2 modi diversi di fare la stessa cosa.

924
01:01:52,820 --> 01:01:55,060
>> Ora abbiamo forme e richieste. Come Rob vi ha mostrato,

925
01:01:55,060 --> 01:01:59,400
ci sono forme di HTML, e ci sarà solo brezza attraverso questo.

926
01:01:59,400 --> 01:02:02,040
Si dispone di un'azione e si dispone di un metodo, e la vostra azione

927
01:02:02,040 --> 01:02:04,350
tipo di dove si sta andando a inviare mostra, e il metodo è se

928
01:02:04,350 --> 01:02:06,960
sta andando essere un GET o POST.

929
01:02:06,960 --> 01:02:11,220
E una richiesta GET, come ha detto Rob, significa che si sta andando a metterlo in una forma

930
01:02:11,220 --> 01:02:15,760
e vedrete come un URL, mentre una richiesta POST non si vedrà in un URL.

931
01:02:15,760 --> 01:02:17,840
Quindi una leggera differenza.

932
01:02:17,840 --> 01:02:19,950
Tuttavia, una cosa che una cosa simile

933
01:02:19,950 --> 01:02:22,560
è che POST e GET sono altrettanto insicuri.

934
01:02:22,560 --> 01:02:26,430
Così si può pensare che solo perché non si vede nella URL,

935
01:02:26,430 --> 01:02:28,790
questo significa che il POST è più sicuro,

936
01:02:28,790 --> 01:02:34,420
ma si può ancora vedere nei vostri cookie nelle informazioni che si sta inviando.

937
01:02:34,420 --> 01:02:38,260
Quindi non pensare che circa uno o l'altro.

938
01:02:38,260 --> 01:02:42,160
Un'altra cosa da notare è che avete anche le variabili di sezione.

939
01:02:42,160 --> 01:02:45,850
Voi ragazzi usato questo in pset 7 per ottenere le informazioni ID utente.

940
01:02:45,850 --> 01:02:48,550
Quello che è successo è che è possibile utilizzare questo array associativo,

941
01:02:48,550 --> 01:02:53,310
il $ _SESSION, e poi siete in grado di accedere a cose diverse

942
01:02:53,310 --> 01:02:57,720
e memorizzare cose diverse attraverso le pagine.

943
01:02:57,720 --> 01:03:00,750
>> Ultima cosa è che abbiamo SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
e questo è un linguaggio di programmazione per la gestione dei database.

945
01:03:04,360 --> 01:03:08,220
Che cosa, esattamente, sono database? Sono collezioni di tabelle,

946
01:03:08,220 --> 01:03:10,630
e ogni tabella può avere forme simili di oggetti.

947
01:03:10,630 --> 01:03:14,990
Così abbiamo avuto un tavolo di utenti in pset finanza.

948
01:03:14,990 --> 01:03:20,610
E perché sono utili? Perché è un modo per memorizzare in modo permanente informazioni.

949
01:03:20,610 --> 01:03:22,840
E 'un modo di tracciare le cose e gestire le cose

950
01:03:22,840 --> 01:03:25,890
ed effettivamente vederlo su pagine diverse e tenere traccia.

951
01:03:25,890 --> 01:03:29,930
Considerando che, se solo conservarlo in quel momento una immediata

952
01:03:29,930 --> 01:03:33,720
e poi utilizzarla in seguito, non sarà in grado di accedere a tutto ciò che hai salvato.

953
01:03:33,720 --> 01:03:37,660
Abbiamo 4 cose importanti che usiamo per i comandi SQL.

954
01:03:37,660 --> 01:03:40,190
Abbiamo select, insert, eliminare e aggiornamento.

955
01:03:40,190 --> 01:03:42,880
Quelli sono veramente importante per voi sapere per il vostro quiz.

956
01:03:42,880 --> 01:03:45,990
>> Andremo rapidamente sopra selezioniamo adesso.

957
01:03:45,990 --> 01:03:48,540
In sostanza, si sta selezionando le righe da un database.

958
01:03:48,540 --> 01:03:52,400
Quindi, se avete, proprio qui -

959
01:03:52,400 --> 01:03:56,740
abbiamo queste due cose diverse, e vogliamo selezionare dalla tabella classi

960
01:03:56,740 --> 01:04:01,480
dove impressionante - dove nella colonna impressionante il valore è 1.

961
01:04:01,480 --> 01:04:04,460
Così si può vedere qui, abbiamo queste due cose del nome della classe,

962
01:04:04,460 --> 01:04:08,490
CS50 e Stat110, e abbiamo gli ID di classe e lo slogan.

963
01:04:08,490 --> 01:04:13,150
Quindi vogliamo selezionare tutte queste informazioni.

964
01:04:13,150 --> 01:04:17,480
Poi si può vedere proprio qui che è una specie di raccolta di quella colonna impressionante,

965
01:04:17,480 --> 01:04:25,170
dove tutte le cose sono 1, e quindi ha l'ID di classe, nome della classe e slogan che si può scegliere.

966
01:04:25,170 --> 01:04:28,100
Esattamente come si fa a fare questo in codice? Devi usare PHP.

967
01:04:28,100 --> 01:04:33,830
Ecco, questo è una specie di come PHP e SQL sono legati gli uni agli altri.

968
01:04:33,830 --> 01:04:38,130
Ora abbiamo il nostro codice, e abbiamo intenzione di utilizzare la nostra funzione di interrogazione

969
01:04:38,130 --> 01:04:41,370
come abbiamo fatto in pset 7, e abbiamo intenzione di eseguire la query SQL.

970
01:04:41,370 --> 01:04:43,870
Poi stiamo andando ad avere -

971
01:04:43,870 --> 01:04:46,280
abbiamo sempre controllare se del triplice fila uguali se false.

972
01:04:46,280 --> 01:04:49,010
Quindi, di nuovo, si desidera controllare il tipo e il valore,

973
01:04:49,010 --> 01:04:53,880
e poi se non funziona, allora si vuole chiedere scusa, come al solito, come abbiamo fatto in pset 7.

974
01:04:53,880 --> 01:04:55,870
In caso contrario, si vuole scorrere tutto con quelli a portata di mano

975
01:04:55,870 --> 01:04:59,410
foreach loop che abbiamo appena visto.

976
01:04:59,410 --> 01:05:01,280
Ora che stiamo scorrendo e abbiamo fatto passato,

977
01:05:01,280 --> 01:05:05,080
supponiamo che la query passata, ora abbiamo il nostro ciclo foreach.

978
01:05:05,080 --> 01:05:11,050
E la prima fila ha, quindi ecco la fila, proprio qui: è inscatolato.

979
01:05:11,050 --> 01:05:14,010
E 'intenzione di stampare tutte le informazioni che esso è ottenuto.

980
01:05:14,010 --> 01:05:18,070
Così sta andando a stampare in fondo "Vuoi imparare l'HTML?"

981
01:05:18,070 --> 01:05:23,370
Poi si sta per andare alla riga successiva, perché è completato il primo ciclo for,

982
01:05:23,370 --> 01:05:26,510
e così poi sta andando a stampare la seconda linea di esso,

983
01:05:26,510 --> 01:05:32,120
che sta per essere STAT110, Trova tutti i momenti.

984
01:05:32,120 --> 01:05:34,290
>> Un'ultima cosa è su SQL vulnerabilità.

985
01:05:34,290 --> 01:05:37,300
So che David toccato questo un po 'di lezione.

986
01:05:37,300 --> 01:05:40,730
Si può leggere in seguito. E 'davvero divertente.

987
01:05:40,730 --> 01:05:45,320
SQL Injection è una sorta di cosa difficile.

988
01:05:45,320 --> 01:05:49,890
Diciamo che hai appena infili queste variabili a destra nella tua ricerca,

989
01:05:49,890 --> 01:05:52,290
come si può vedere in quella prima linea.

990
01:05:52,290 --> 01:05:54,520
Così sembra bene, giusto? Stai solo mettendo il nome utente

991
01:05:54,520 --> 01:05:58,820
e la password per la query SQL, e si desidera spedire fuori e ottenere tutto ciò che è nella tabella dei dati.

992
01:05:58,820 --> 01:06:01,450
Che sembra abbastanza semplice. Quindi diciamo qualcuno mette in,

993
01:06:01,450 --> 01:06:04,910
per la password, o il testo qui -

994
01:06:04,910 --> 01:06:06,780
in realtà dovrebbe essere nella scatola rossa.

995
01:06:06,780 --> 01:06:11,920
Quindi diciamo che hanno messo tale password in - questo è quello che entrano.

996
01:06:11,920 --> 01:06:16,520
Così stanno mettendo o "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Tipo di una password sciocco avere.

998
01:06:20,880 --> 01:06:25,070
Ora facciamo solo sostituirlo, e noterete che in quella query SQL ora,

999
01:06:25,070 --> 01:06:29,090
che restituisce sempre vero, perché noterete che

1000
01:06:29,090 --> 01:06:32,240
è possibile query SQL selezionare tutte queste informazioni

1001
01:06:32,240 --> 01:06:35,420
o si può solo avere 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
Così che sta andando sempre di valutare true.

1003
01:06:41,030 --> 01:06:46,610
Che non sta andando a lavorare davvero, perché ciò significa che l'hacker può entrare nel vostro sistema.

1004
01:06:46,610 --> 01:06:49,300
La soluzione a questo è che si deve utilizzare il sistema DOP,

1005
01:06:49,300 --> 01:06:51,360
il che significa che si deve usare punti interrogativi,

1006
01:06:51,360 --> 01:06:53,350
che è quello che voi ragazzi utilizzate in pset 7,

1007
01:06:53,350 --> 01:06:57,620
dove stai andando ad utilizzare un punto interrogativo al posto di dove si vuole mettere qualcosa,

1008
01:06:57,620 --> 01:07:01,430
e allora si sta andando ad avere una virgola, e poi avrete seguito,

1009
01:07:01,430 --> 01:07:07,610
dopo la stringa, le diverse variabili che si desidera sostituire nel vostro punto di domanda.

1010
01:07:07,610 --> 01:07:10,330
Quindi dovrete notare che ora ho questi punti interrogativi rossi.

1011
01:07:10,330 --> 01:07:15,420
Poi ho messo le variabili dopo le mie corde quindi so di sostituirli in questo ordine dopo.

1012
01:07:15,420 --> 01:07:18,470
Questo farà in modo che se qualcuno lo fa in questo modo,

1013
01:07:18,470 --> 01:07:24,050
e hanno la o 1 = 1 situazione, che farà in modo,

1014
01:07:24,050 --> 01:07:30,490
nel back-end, assicurarsi che non sarà effettivamente rompere la query SQL.

1015
01:07:30,490 --> 01:07:33,660
Okay, così che è praticamente esso, un turbine di PHP e SQL.

1016
01:07:33,660 --> 01:07:41,520
Buona fortuna a tutti voi, e ora a Oregon

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Va bene a tutti. È ora di andare oltre alcune JavaScript

1018
01:07:44,270 --> 01:07:48,840
e alcune altre cose molto velocemente in modo da non reggono voi stasera.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Sì. JavaScript è una specie di cosa fredda, presumibilmente.

1020
01:07:56,930 --> 01:07:59,090
Le cose si ha realmente bisogno di sapere su JavaScript, è una specie di

1021
01:07:59,090 --> 01:08:03,810
l'estremità lato client di ciò che il web app sta per fare.

1022
01:08:03,810 --> 01:08:08,280
Ci sono alcune cose che proprio non si vuole prendere cura di tutto il tempo sul lato server.

1023
01:08:08,280 --> 01:08:12,880
Tutte le piccole interazioni, mettendo in evidenza una cosa, fare qualcosa di scomparire.

1024
01:08:12,880 --> 01:08:15,340
Davvero non vogliono avere a parlare con il server di tutto il tempo per questo.

1025
01:08:15,340 --> 01:08:18,069
E alcuni di che non è nemmeno possibile fare sul lato server.

1026
01:08:18,069 --> 01:08:21,899
Questo è il motivo per cui abbiamo bisogno di qualcosa di simile a JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Cose interessanti circa JavaScript: è digitato in modo dinamico.

1028
01:08:24,359 --> 01:08:27,149
Ciò significa che il programma non ha bisogno di sapere

1029
01:08:27,149 --> 01:08:30,970
che cosa, esattamente, le variabili sono quando si scrive fuori.

1030
01:08:30,970 --> 01:08:34,510
Sarà solo una sorta di capirlo come è in esecuzione.

1031
01:08:34,510 --> 01:08:37,520
Altre cose che sono fresco su di esso: E 'un linguaggio parentesi graffa,

1032
01:08:37,520 --> 01:08:41,359
il che significa che la sintassi è simile a C e PHP.

1033
01:08:41,359 --> 01:08:47,050
Non dovete fare molto di rilavorazione quando si sta imparando JavaScript.

1034
01:08:47,050 --> 01:08:49,180
Qui abbiamo un po 'di JavaScript.

1035
01:08:49,180 --> 01:08:52,560
La cosa interessante qui è che, se la si guarda,

1036
01:08:52,560 --> 01:08:56,330
abbiamo un po 'di JavaScript proprio lì nel tag head.

1037
01:08:56,330 --> 01:08:59,479
Ciò che è non è fondamentalmente solo includere un file JavaScript.

1038
01:08:59,479 --> 01:09:02,260
Questo è un modo è possibile includere JavaScript nel vostro programma.

1039
01:09:02,260 --> 01:09:06,910
Poi la seconda po 'è in realtà una linea di JavaScript,

1040
01:09:06,910 --> 01:09:10,790
molto simile a uno stile in linea con CSS,

1041
01:09:10,790 --> 01:09:16,180
e stai solo scrivendo un codice molto rapidamente lì.

1042
01:09:16,180 --> 01:09:18,120
JavaScript ha matrici.

1043
01:09:18,120 --> 01:09:20,850
Solo un altro modo per mantenere i dati in giro, molto utile.

1044
01:09:20,850 --> 01:09:25,180
Molto piacevole e facile sintassi.

1045
01:09:25,180 --> 01:09:29,870
È possibile utilizzare le parentesi quadre per accedere a tutto e tenere tutto insieme.

1046
01:09:29,870 --> 01:09:35,020
Niente di troppo complesso.

1047
01:09:35,020 --> 01:09:38,630
La cosa bella di Javascript e linguaggi di scripting in generale

1048
01:09:38,630 --> 01:09:40,920
è che non devi preoccuparti di dimensioni di matrice.

1049
01:09:40,920 --> 01:09:43,880
È possibile utilizzare solo array.length e tenere traccia di esso,

1050
01:09:43,880 --> 01:09:46,960
e anche la matrice può crescere o ridursi come avete bisogno di.

1051
01:09:46,960 --> 01:09:49,279
Quindi non hai nemmeno bisogno di preoccuparsi di qualsiasi tipo di,

1052
01:09:49,279 --> 01:09:57,050
oh no, ho bisogno di allocare più cose, o qualcosa di simile.

1053
01:09:57,050 --> 01:10:00,090
>> La cosa interessante qui è che JavaScript ha qualcosa chiamato oggetti.

1054
01:10:00,090 --> 01:10:04,800
E 'un linguaggio orientato agli oggetti, quindi ciò che ha è, in sostanza,

1055
01:10:04,800 --> 01:10:10,100
un modo per raggruppare i dati insieme, in qualche modo simile a una struct,

1056
01:10:10,100 --> 01:10:17,280
ma è possibile accedervi come una struttura o in una sintassi array associativo.

1057
01:10:17,280 --> 01:10:22,520
E 'piuttosto semplice e che cosa si può fare con questo insieme di dati del gruppo

1058
01:10:22,520 --> 01:10:24,810
se si dispone di una serie di dati che è legato.

1059
01:10:24,810 --> 01:10:26,850
Perché è tutte le cose che avete bisogno per descrivere una macchina,

1060
01:10:26,850 --> 01:10:29,050
non c'è bisogno di avere in un mucchio di posti diversi.

1061
01:10:29,050 --> 01:10:35,300
Si può solo attaccare in 1 oggetto in JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Come probabilmente sapete, l'iterazione è uno di quei compiti noiosi.

1063
01:10:39,090 --> 01:10:43,810
Basta farlo su un più volte. Hai bisogno di parlare ad ogni oggetto in macchina,

1064
01:10:43,810 --> 01:10:47,340
o avete bisogno di passare attraverso ogni elemento in un elenco o qualcosa di simile.

1065
01:10:47,340 --> 01:10:51,770
Così JavaScript ha, simile a PHP, una sintassi foreach.

1066
01:10:51,770 --> 01:10:54,590
In questo caso, è un per in loop.

1067
01:10:54,590 --> 01:10:57,300
Si desidera utilizzare questo solo su oggetti.

1068
01:10:57,300 --> 01:11:01,030
Ci sono alcuni problemi che si verificano se si utilizza questo array.

1069
01:11:01,030 --> 01:11:03,750
Generalmente è una di quelle cose, però, che è molto utile,

1070
01:11:03,750 --> 01:11:06,590
perché si elimina un sacco di overhead

1071
01:11:06,590 --> 01:11:10,270
perché non c'è bisogno di tirare su tutto l'oggetto da soli.

1072
01:11:10,270 --> 01:11:12,300
Non c'è bisogno di ricordare tutti i nomi delle chiavi.

1073
01:11:12,300 --> 01:11:18,270
È appena sorta di farli tornare in questa sintassi.

1074
01:11:18,270 --> 01:11:21,500
In questo, con a, si vuole solo ricordare

1075
01:11:21,500 --> 01:11:27,180
che stai ricevendo indietro tutte le chiavi, in modo molto simile alla tabella hash.

1076
01:11:27,180 --> 01:11:30,880
Se vi ricordate di che, quando si sarebbe messo in una stringa si potrebbe ottenere qualcosa

1077
01:11:30,880 --> 01:11:33,840
che avrebbe un valore associato con esso.

1078
01:11:33,840 --> 01:11:36,360
Che cosa si può fare con questo è che si può dire, va bene,

1079
01:11:36,360 --> 01:11:42,120
Ho messo in una macchina, e ho chiamato una Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Così si può mettere nella stringa Ferrari più tardi, e si può ottenere che fuori.

1081
01:11:45,290 --> 01:11:50,000
E si può fare in un ciclo, con il cui ciclo.

1082
01:11:50,000 --> 01:11:53,320
Quindi, solo più sugli oggetti. La cosa fondamentale da questo è necessario ricordare

1083
01:11:53,320 --> 01:12:00,340
è che è possibile utilizzare l'oggetto struct come sintassi ogni volta che vuoi con questi,

1084
01:12:00,340 --> 01:12:04,590
salvo se ciò che la vostra intenzione di utilizzare come una stringa non è un nome di variabile valido.

1085
01:12:04,590 --> 01:12:07,650
Quindi, se si guarda a che non abbiamo chiave con spazi.

1086
01:12:07,650 --> 01:12:12,500
Beh, se si dovesse mettere object.key, spazio, con, spazio, spazi,

1087
01:12:12,500 --> 01:12:15,320
che proprio non avrebbe senso sintatticamente.

1088
01:12:15,320 --> 01:12:22,730
Così si può solo fare con questo tipo di sintassi staffa.

1089
01:12:22,730 --> 01:12:26,520
>> Inoltre, JavaScript è molto portata-saggio PHP.

1090
01:12:26,520 --> 01:12:29,050
Hai 2 modi di affrontare portata.

1091
01:12:29,050 --> 01:12:31,960
Non si può avere la var di fronte a una variabile,

1092
01:12:31,960 --> 01:12:34,060
e questo significa che solo questo è globale.

1093
01:12:34,060 --> 01:12:37,050
Lo si può vedere da qualsiasi luogo. Anche se si dovesse mettere questo in un'istruzione if,

1094
01:12:37,050 --> 01:12:42,430
altrove nel codice dopo quel punto si vedeva che variabile.

1095
01:12:42,430 --> 01:12:46,730
Un'altra cosa, però, è con il var, è limitato a qualsiasi funzione in cui ti trovi

1096
01:12:46,730 --> 01:12:48,870
Se non sei in una funzione, beh, è ​​globale.

1097
01:12:48,870 --> 01:12:53,900
Ma se siete in una funzione è visibile solo all'interno di tale funzione.

1098
01:12:53,900 --> 01:12:56,420
Non ho un esempio, ma, sì. E 'una di quelle cose in cui

1099
01:12:56,420 --> 01:12:59,900
si può gestire ciò che le variabili si vuole essere globale,

1100
01:12:59,900 --> 01:13:03,810
quali variabili si desidera essere locale, ma si ha bisogno di essere attenti a questo,

1101
01:13:03,810 --> 01:13:06,890
perché non si ha il tipo di controllo a grana fina si fa in C,

1102
01:13:06,890 --> 01:13:15,820
dove se qualcosa è dichiarata in un ciclo for, sta andando a rimanere in quel ciclo for.

1103
01:13:15,820 --> 01:13:18,790
La cosa che in realtà preoccupiamo per usare JavaScript per sta manipolando le pagine web, giusto?

1104
01:13:18,790 --> 01:13:21,800
Voglio dire, è per questo che stiamo facendo questo.

1105
01:13:21,800 --> 01:13:23,840
>> Per farlo, usiamo qualcosa chiamato DOM.

1106
01:13:23,840 --> 01:13:25,850
Il Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
In sostanza, ciò che fa è ci vuole tutto il codice HTML

1108
01:13:29,430 --> 01:13:34,110
modelli fuori in un gruppo di oggetti che sono annidati uno dentro l'altro.

1109
01:13:34,110 --> 01:13:37,080
Si inizia con qualcosa di simile.

1110
01:13:37,080 --> 01:13:44,770
Avete, sulla destra per me, un mucchio di codice là fuori che è una sorta di -

1111
01:13:44,770 --> 01:13:46,640
Si potrebbe pensare che sarebbe molto difficile da manipolare,

1112
01:13:46,640 --> 01:13:48,700
perché saresti parsing attraverso un mazzo di testo

1113
01:13:48,700 --> 01:13:52,080
e avendo a mettere le cose a parte. E se non è stato formattato correttamente?

1114
01:13:52,080 --> 01:13:54,880
Brutte cose accadrebbero.

1115
01:13:54,880 --> 01:13:58,140
Così JavaScript si prende cura di questo per voi, e si ottiene una struttura di dati piacevole,

1116
01:13:58,140 --> 01:14:01,390
come quello alla mia sinistra, dove vi è solo un documento,

1117
01:14:01,390 --> 01:14:03,530
e dentro che hai qualcosa chiamato HTML,

1118
01:14:03,530 --> 01:14:05,600
e dentro di avere una testa e un corpo,

1119
01:14:05,600 --> 01:14:08,420
e dentro quella testa di avere un titolo, eccetera, eccetera, eccetera.

1120
01:14:08,420 --> 01:14:11,810
Questo semplifica la manipolazione di una pagina web in modo che sia giusto,

1121
01:14:11,810 --> 01:14:14,190
oh, voglio solo parlare con questo oggetto.

1122
01:14:14,190 --> 01:14:21,340
Sorta di un modo molto simile si potrebbe parlare di un altro oggetto avete fatto voi.

1123
01:14:21,340 --> 01:14:25,980
Come ho detto, tutto il DOM è nell'oggetto documento.

1124
01:14:25,980 --> 01:14:29,290
O è solo un posto e poi si può andare dentro per trovare le cose,

1125
01:14:29,290 --> 01:14:33,880
e si può farlo - questo è il vecchio stile di farlo, lassù,

1126
01:14:33,880 --> 01:14:38,130
dove si fa document.getElementById, e quindi il nome,

1127
01:14:38,130 --> 01:14:42,420
e come si può probabilmente dire, questo diventa molto pesante dopo un po '.

1128
01:14:42,420 --> 01:14:44,480
Quindi probabilmente non si vuole farlo. Ecco perché abbiamo

1129
01:14:44,480 --> 01:14:48,760
la prossima cosa andremo a parlare dopo questo.

1130
01:14:48,760 --> 01:14:52,510
La cosa fondamentale qui è che, va bene, avete tutti questi elementi, giusto?

1131
01:14:52,510 --> 01:14:56,400
Così forse posso cambiare il colore di qualcosa quando la pagina viene caricata.

1132
01:14:56,400 --> 01:14:58,380
E allora? Cosa succede se il mio utente fa clic su qualcosa?

1133
01:14:58,380 --> 01:15:00,540
Io voglio fare qualcosa di interessante quando si clicca qualcosa.

1134
01:15:00,540 --> 01:15:02,600
Ecco perché abbiamo eventi.

1135
01:15:02,600 --> 01:15:05,330
È possibile, in pratica, trovare qualsiasi elemento nel DOM,

1136
01:15:05,330 --> 01:15:08,560
e poi dire, hey. Quando questa carica o qualcuno fa clic sopra,

1137
01:15:08,560 --> 01:15:11,410
o quando il mouse su di esso, fare qualcosa con esso.

1138
01:15:11,410 --> 01:15:15,330
E quello che hai è, si dispone di funzioni che gestiscono questo per voi.

1139
01:15:15,330 --> 01:15:17,980
Queste funzioni sono gestori di eventi.

1140
01:15:17,980 --> 01:15:20,440
Che Stanno - è solo un modo elegante per dire,

1141
01:15:20,440 --> 01:15:23,500
questa funzione viene eseguita solo quando questo evento si verifica.

1142
01:15:23,500 --> 01:15:28,070
Così gestisce l'evento che si verifica.

1143
01:15:28,070 --> 01:15:30,810
Questo è come si dovrebbe stendere un gestore di eventi.

1144
01:15:30,810 --> 01:15:34,750
Ho qualche tasto, e quando si fa clic su di esso, esplode.

1145
01:15:34,750 --> 01:15:40,560
Quindi non fare clic sul pulsante.

1146
01:15:40,560 --> 01:15:42,910
Questo è un modo di avvicinarsi, giusto?

1147
01:15:42,910 --> 01:15:46,430
Hai un tag pulsante e al clic si dispone di una stringa che dice:

1148
01:15:46,430 --> 01:15:50,460
Ah, a proposito, faccio questa cosa che esplode per me.

1149
01:15:50,460 --> 01:15:53,990
In caso contrario, è proprio come un pulsante normale che hai appena fatto.

1150
01:15:53,990 --> 01:15:56,550
È anche possibile fare in un altro modo,

1151
01:15:56,550 --> 01:16:02,770
afferrando l'elemento DOM, ma ci salveremo che dopo parliamo di jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: è una libreria che è cross-browser.

1153
01:16:07,580 --> 01:16:09,580
Si può usare in praticamente qualsiasi cosa.

1154
01:16:09,580 --> 01:16:12,090
E ti dà solo un sacco di strumenti per lavorare con.

1155
01:16:12,090 --> 01:16:15,850
Perché JavaScript, mentre il potente, non ha tutti gli strumenti necessari

1156
01:16:15,850 --> 01:16:20,550
fuori dalla scatola per affrontare davvero una web app si potrebbe desiderare di fare.

1157
01:16:20,550 --> 01:16:24,650
Quindi semplifica un sacco di cose, ti dà un sacco di funzioni

1158
01:16:24,650 --> 01:16:28,760
fuori dalla scatola che si avrebbe normalmente per scrivere, più e più e più volte.

1159
01:16:28,760 --> 01:16:31,600
E solo rende le cose molto semplici.

1160
01:16:31,600 --> 01:16:35,780
Hai anche selettori che consentono di stipulare tutti quegli elementi

1161
01:16:35,780 --> 01:16:42,800
dal DOM molto più semplicemente, invece di dover utilizzare queste chiamate di funzione molto lunghi.

1162
01:16:42,800 --> 01:16:46,630
Di più su questi selettori. Avete, lassù avete, diciamo

1163
01:16:46,630 --> 01:16:49,800
Voglio ottenere un elemento con l'ID "rock".

1164
01:16:49,800 --> 01:16:56,450
Beh, in jQuery, è solo $ e poi una stringa che ha un chilo, e poi "rock".

1165
01:16:56,450 --> 01:17:01,960
E 'molto semplice e molto più veloce rispetto al modo tradizionale di JavaScript di affrontare questo problema.

1166
01:17:01,960 --> 01:17:06,120
E avete cose simili per classi e tipi di elementi.

1167
01:17:06,120 --> 01:17:08,140
jQuery è - una delle più belle caratteristiche è che si può sorta di comprimere

1168
01:17:08,140 --> 01:17:14,350
le vostre domande sul DOM molto, molto veloce.

1169
01:17:14,350 --> 01:17:18,980
Ora siamo tornati alla gestione degli eventi, e questo è come si dovrebbe gestire un evento in jQuery.

1170
01:17:18,980 --> 01:17:23,090
Così che cosa stiamo andando qui è che stiamo dicendo, tutto bene. Ho un tag script, giusto?

1171
01:17:23,090 --> 01:17:25,400
Quindi ho questa linea JavaScript.

1172
01:17:25,400 --> 01:17:27,750
Quello che andremo a fare è che andremo a dire, tutto bene.

1173
01:17:27,750 --> 01:17:30,860
Quando il documento è pronto, il che significa che il documento è stato caricato,

1174
01:17:30,860 --> 01:17:34,660
stiamo per andare a quella funzione, e noi andremo a dire, va bene,

1175
01:17:34,660 --> 01:17:37,060
questa funzione sta effettivamente facendo qualcos'altro.

1176
01:17:37,060 --> 01:17:42,320
E 'fondamentalmente dicendo, va bene, portami l'elemento con ID "myid".

1177
01:17:42,320 --> 01:17:47,960
E poi dare a questo un gestore funzione che viene eseguita quando si fa clic.

1178
01:17:47,960 --> 01:17:49,820
Fondamentalmente ciò che fa è, si dice, va bene.

1179
01:17:49,820 --> 01:17:52,630
La pagina viene caricata, quindi ho intenzione di in, trovare questo elemento,

1180
01:17:52,630 --> 01:17:56,420
dare questo gestore di eventi, e stabilisce fondamentalmente la tua pagina per voi.

1181
01:17:56,420 --> 01:18:00,520
E questo è come si vuole pensare la gestione degli eventi.

1182
01:18:00,520 --> 01:18:06,310
Si vuole solo pensare, va bene, quando si verifica qualcosa, cosa voglio che accada?

1183
01:18:06,310 --> 01:18:10,520
Non si vuole pensare, va bene, ho bisogno di fare certi discorsi questa cosa a questa cosa,

1184
01:18:10,520 --> 01:18:14,660
questa cosa bla bla bla, perché si vuole solo parlare cosa in termini di eventi.

1185
01:18:14,660 --> 01:18:17,650
Quando questo accade, questo accade. Quando questo accade, ciò accade.

1186
01:18:17,650 --> 01:18:20,240
E se le cose innescano altre cose, che è grande.

1187
01:18:20,240 --> 01:18:22,150
Ma non si vuole cercare di fare il codice complicato

1188
01:18:22,150 --> 01:18:24,130
dove si sta innescando più cose allo stesso tempo,

1189
01:18:24,130 --> 01:18:28,860
perché si sta solo andando a dare voi stessi un mal di testa.

1190
01:18:28,860 --> 01:18:32,340
Va bene >>. Ora possiamo ottenere la nostra pagina per gestire gli eventi,

1191
01:18:32,340 --> 01:18:35,640
ma diciamo che il mio utente fa clic su un pulsante.

1192
01:18:35,640 --> 01:18:38,040
Cosa succede se voglio inviare la richiesta al server,

1193
01:18:38,040 --> 01:18:41,100
ma io non voglio ricaricare la pagina, perché dover ricaricare una nuova pagina

1194
01:18:41,100 --> 01:18:44,390
ogni volta diventa un po 'noioso, e perché ne ho bisogno

1195
01:18:44,390 --> 01:18:47,430
di abbattere l'intestazione di nuovo, e di nuovo il piè di pagina,

1196
01:18:47,430 --> 01:18:49,670
e tutti gli elementi della pagina di nuovo

1197
01:18:49,670 --> 01:18:53,180
solo per aggiornare il saluto o il tempo?

1198
01:18:53,180 --> 01:18:55,290
Ecco perché abbiamo qualcosa come Ajax.

1199
01:18:55,290 --> 01:18:59,150
Cosa possiamo fare qui con l'Ajax è che possiamo dire, va bene,

1200
01:18:59,150 --> 01:19:01,290
Voglio inviare alcuni dati al server,

1201
01:19:01,290 --> 01:19:04,010
e voglio ottenere una risposta indietro così posso aggiornare la mia pagina,

1202
01:19:04,010 --> 01:19:12,120
o forse solo fare qualche calcolo algoritmico che non mostra necessariamente nulla per l'utente.

1203
01:19:12,120 --> 01:19:15,500
Di cosa hai bisogno di fare questo? Beh, avete bisogno di un URL è necessario parlare.

1204
01:19:15,500 --> 01:19:18,650
Il server non è in grado magicamente ascoltare dal nulla.

1205
01:19:18,650 --> 01:19:21,960
È necessario disporre di un luogo specifico si sta inviando questi dati.

1206
01:19:21,960 --> 01:19:26,240
Ed è necessario anche alcuni dati da inviare, o forse è una query dataless.

1207
01:19:26,240 --> 01:19:31,380
Si vuole solo il ping al server e dire, hey, io sono vivo, o qualcosa di simile.

1208
01:19:31,380 --> 01:19:35,150
E poi si vuole una funzione che gestisce praticamente con successo.

1209
01:19:35,150 --> 01:19:38,250
Diciamo che si torni alcune informazioni dal server,

1210
01:19:38,250 --> 01:19:42,960
e si desidera cambiare il titolo dell'utente sulla loro pagina.

1211
01:19:42,960 --> 01:19:44,930
Così si dovrebbe ottenere le informazioni di ritorno,

1212
01:19:44,930 --> 01:19:48,860
e si dovrebbe spingere che allo schermo.

1213
01:19:48,860 --> 01:19:51,170
Quello che succede è, quando la pagina è pronta,

1214
01:19:51,170 --> 01:19:56,500
si crea un click sulla funzione di questo pulsante chiamata di benvenuto.

1215
01:19:56,500 --> 01:19:58,810
Che questo poi fa è, quando tale pulsante viene premuto,

1216
01:19:58,810 --> 01:20:03,700
si parla di greetings.php, si effettua una richiesta POST,

1217
01:20:03,700 --> 01:20:07,290
e dici: ehi, mi ottenere qualcosa dalla tua pagina.

1218
01:20:07,290 --> 01:20:09,890
Non abbiamo davvero bisogno di descrivere, ma greetings.php,

1219
01:20:09,890 --> 01:20:12,480
diciamo solo che, restituisce "ciao mondo".

1220
01:20:12,480 --> 01:20:15,650
Quindi torniamo questo "ciao mondo", e in caso di successo di questo,

1221
01:20:15,650 --> 01:20:20,730
supponendo che nulla vada storto, allora dobbiamo solo andare a questo luogo di destinazione

1222
01:20:20,730 --> 01:20:25,720
che abbiamo specificato e abbiamo appena bastone la risposta in là.

1223
01:20:25,720 --> 01:20:31,560
E questo è un modo molto semplice di creare una query Ajax.

1224
01:20:31,560 --> 01:20:34,340
>> Molto rapidamente, Rob sorta di già parlato di questo,

1225
01:20:34,340 --> 01:20:37,170
le cose possono andare male, le cose brutte possono accadere,

1226
01:20:37,170 --> 01:20:42,660
così si vuole familiarizzare con questi codici di risposta HTTP.

1227
01:20:42,660 --> 01:20:46,030
Quali sono sono solo, come, 200, tutto è andato a posto.

1228
01:20:46,030 --> 01:20:48,670
Qualcos'altro, cose brutte successe.

1229
01:20:48,670 --> 01:20:50,790
E 'in genere la cosa che si desidera ricordare.

1230
01:20:50,790 --> 01:20:53,440
Ma è bello sapere che tutti questi.

1231
01:20:53,440 --> 01:20:55,970
E, infine, una volta che siamo passati attraverso tutto questo,

1232
01:20:55,970 --> 01:20:58,680
abbiamo bisogno di parlare molto velocemente di design,

1233
01:20:58,680 --> 01:21:00,620
e poi possiamo lasciare a tutti voi di lasciare.

1234
01:21:00,620 --> 01:21:03,410
Design. Le cose che si desidera ricordare.

1235
01:21:03,410 --> 01:21:06,950
Ponetevi queste domande: Chi sarà usando questo?

1236
01:21:06,950 --> 01:21:09,580
Cosa faranno utilizzeranno per? Che cosa i miei utenti si preoccupano?

1237
01:21:09,580 --> 01:21:11,750
Quello che non si preoccupano?

1238
01:21:11,750 --> 01:21:14,500
È solo che non vuole fare un app e lasciarlo solo crescere

1239
01:21:14,500 --> 01:21:18,270
e diventare questo gigante, divorante cosa che non si può nemmeno finire.

1240
01:21:18,270 --> 01:21:23,900
Volete avere obiettivi discreti e piani e tutte le cose che si desidera affrontare.

1241
01:21:23,900 --> 01:21:29,000
Rendere sforzo. Tutto questo, dice, in sostanza,

1242
01:21:29,000 --> 01:21:34,950
rendere più facile per l'utente di usarlo, non farne un blob gigante di testo come questa diapositiva è, in realtà.

1243
01:21:34,950 --> 01:21:38,020
Si vuole solo che sia qualcosa in cui è molto facile per qualcuno di andare in

1244
01:21:38,020 --> 01:21:40,800
e fanno quello che vogliono fare.

1245
01:21:40,800 --> 01:21:42,920
Non voglio che abbiano per navigare 5 pagine

1246
01:21:42,920 --> 01:21:45,460
per raggiungere la vostra funzione principale del tuo sito.

1247
01:21:45,460 --> 01:21:49,290
Se Google aveva 5 pagine prima si potrebbe anche cercare qualcosa,

1248
01:21:49,290 --> 01:21:53,080
nessuno userebbe.

1249
01:21:53,080 --> 01:21:55,890
E, infine, la carta prototipo, focus group.

1250
01:21:55,890 --> 01:21:59,220
Avere un buon design e pratiche di verifica.

1251
01:21:59,220 --> 01:22:00,730
Solo perché pensi che funziona per voi,

1252
01:22:00,730 --> 01:22:04,860
non significa che chiunque altro pensa che funziona.

1253
01:22:04,860 --> 01:22:14,490
Ma sì, questo è tutto.

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