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

2
00:00:02,270 --> 00:00:04,620
[Alí Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Universidade de Harvard]

3
00:00:04,620 --> 00:00:07,660
[Isto é CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Sexan benvidos. Esta é unha revisión para cuestionario 1.

5
00:00:11,610 --> 00:00:15,040
Así como un aviso, este é - quero dicir, imos tratar de cubrir

6
00:00:15,040 --> 00:00:17,770
tanto material como puido, pero iso non quere dicir que

7
00:00:17,770 --> 00:00:20,780
nós imos cubrir todas as cousas que poden ser en cuestionario 1.

8
00:00:20,780 --> 00:00:25,270
Entón non se esqueza que tamén dar un ollo a clase, seccións, todo o que se poida.

9
00:00:25,270 --> 00:00:28,240
Proba 1 será o mércores, próximo mércores.

10
00:00:28,240 --> 00:00:33,800
Entón non deixe de estudar. Vai ser, practicamente, como a primeira proba

11
00:00:33,800 --> 00:00:36,390
en canto ao seu formato, pero probablemente vai ser moito máis difícil.

12
00:00:36,390 --> 00:00:39,600
Polo menos, o ano pasado, cando eu tirei 50, eu penso que era moito máis difícil.

13
00:00:39,600 --> 00:00:42,410
Polo tanto, estudia moito.

14
00:00:42,410 --> 00:00:45,190
>> Eu estou indo cubrir as estruturas de datos e código de Huffman.

15
00:00:45,190 --> 00:00:47,910
Isto é algo que unha morea de xente cre que é complexo,

16
00:00:47,910 --> 00:00:51,930
pero eu vou tentar facelo tan fácil como puido.

17
00:00:51,930 --> 00:00:56,330
Primeiro de todo, o que queremos que vostedes coñecen a proba 1 é

18
00:00:56,330 --> 00:01:00,970
comprender as descricións conceptuais de cada unha das estruturas de datos que eu vou presentar.

19
00:01:00,970 --> 00:01:03,960
Isto significa que non ten que realmente

20
00:01:03,960 --> 00:01:07,020
implementar unha táboa hash no seu cuestionario 1.

21
00:01:07,020 --> 00:01:10,250
Non queremos que aplique unha táboa hash enteiro, quizais imos tratar

22
00:01:10,250 --> 00:01:13,090
para facer aplicar algunhas funcións,

23
00:01:13,090 --> 00:01:16,940
as operacións máis comúns, pero non vai facer vostede aplicar todo.

24
00:01:16,940 --> 00:01:21,010
Por iso, é importante que entenda o concepto detrás de cada estrutura de datos

25
00:01:21,010 --> 00:01:23,510
e tamén que é capaz de codificar en C,

26
00:01:23,510 --> 00:01:27,880
só as operacións máis comúns que teñen a cada estrutura de datos.

27
00:01:27,880 --> 00:01:30,090
E tamén ser capaz de analizar os punteiros e estruturas,

28
00:01:30,090 --> 00:01:33,470
porque aparecen moi nestas estruturas de datos.

29
00:01:33,470 --> 00:01:37,380
>> En primeiro lugar, as listas ligadas. Listas encadeadas son realmente moi semellantes a arrays,

30
00:01:37,380 --> 00:01:39,930
pero a diferenza entre unha lista encadeada e unha matriz,

31
00:01:39,930 --> 00:01:45,160
en primeiro lugar, que é unha lista encadeada ten un tamaño moi flexible,

32
00:01:45,160 --> 00:01:50,060
mentres que en matrices ten que quere escoller un tamaño moi grande para a matriz,

33
00:01:50,060 --> 00:01:53,710
para que vostede sabe que vai ser capaz de almacenar todos os datos en que matriz,

34
00:01:53,710 --> 00:01:59,370
ou tes que usar malloc para ter unha lonxitude flexible da matriz.

35
00:01:59,370 --> 00:02:03,680
En listas ligadas é moi fácil, é só incorporarse máis elementos,

36
00:02:03,680 --> 00:02:07,210
poñer máis elementos na lista ligada ou eliminar elementos.

37
00:02:07,210 --> 00:02:09,370
E, de feito, se non quere que a lista ligada a seren clasificados,

38
00:02:09,370 --> 00:02:13,950
pode buscar e eliminar elementos en tempo constante,

39
00:02:13,950 --> 00:02:16,800
entón A (1) tempo, polo que é moi cómodo.

40
00:02:16,800 --> 00:02:20,660
Só ten que ter coidado de lembrar sempre de malloc e free os nós,

41
00:02:20,660 --> 00:02:25,510
só porque se non fai iso, vai ter perdas de memoria.

42
00:02:25,510 --> 00:02:31,480
Entón listas ligadas - a definición dun nodo é como o que temos aí.

43
00:02:31,480 --> 00:02:35,110
Engada int n, pero pode almacenar todos os datos que quere.

44
00:02:35,110 --> 00:02:37,280
Entón, se quere gardar unha cadea, está ben.

45
00:02:37,280 --> 00:02:41,690
Se desexa almacenar unha estrutura, está todo ben, un dobre, o que quere.

46
00:02:41,690 --> 00:02:44,630
Acabo de pór int n para os exemplos aquí.

47
00:02:44,630 --> 00:02:46,800
E ten un punteiro ao seguinte nodo.

48
00:02:46,800 --> 00:02:51,940
Entón, basicamente, unha lista ligada ten algúns datos, e, a continuación, el apunta ao seguinte nodo.

49
00:02:51,940 --> 00:02:56,710
Se é o último elemento da lista ligada, que vai ligar a NULL.

50
00:02:56,710 --> 00:02:59,060
Polo tanto, este é un exemplo dunha lista ligada.

51
00:02:59,250 --> 00:03:05,960
>> Ok, entón agora imos ver o que temos que facer se eu queira introducir un elemento nunha lista vinculada.

52
00:03:05,960 --> 00:03:08,810
En primeiro lugar, unha inserción de función será do tipo void

53
00:03:08,810 --> 00:03:11,350
porque eu non quero voltar nada.

54
00:03:11,350 --> 00:03:14,200
E eu vou tomar un int como argumento,

55
00:03:14,200 --> 00:03:17,090
porque quero saber o que quero inserir.

56
00:03:17,090 --> 00:03:21,840
Entón, cal é o primeiro que debería facer? Ben, eu debería malloc en newNode,

57
00:03:21,840 --> 00:03:24,240
de xeito que é a primeira liña.

58
00:03:24,240 --> 00:03:27,580
Estou só a creación dun novo nodo para poñer nunha lista encadeada.

59
00:03:27,580 --> 00:03:32,360
Entón o que podo facer? Así, sabemos que en nosas implementacións de listas ligadas

60
00:03:32,360 --> 00:03:38,180
en clase, poñemos sempre a cabeza como unha variable global.

61
00:03:38,180 --> 00:03:41,800
Entón, o que podemos facer é cambiar a cabeza.

62
00:03:41,800 --> 00:03:44,300
Eu podo facer esta nova nó ser o novo xefe,

63
00:03:44,300 --> 00:03:46,670
e só pode apuntar á cabeza anterior.

64
00:03:46,670 --> 00:03:50,390
Como podemos facer isto? O primeiro que teño que facer

65
00:03:50,390 --> 00:03:54,770
é cambiar o 'n' o novo nó de valor,

66
00:03:54,770 --> 00:03:57,530
que foi pasado para a función.

67
00:03:57,530 --> 00:04:01,050
Entón newNode é o seguinte será o cabeza.

68
00:04:01,050 --> 00:04:05,800
A cabeza será newNode. Por iso, é moi sinxelo.

69
00:04:05,800 --> 00:04:10,090
Para eliminar un nodo, podemos facelo como -

70
00:04:10,090 --> 00:04:14,790
Un xeito que nós poderíamos facer isto é,

71
00:04:14,790 --> 00:04:18,160
Todo ben, se eu quería borrar, por exemplo, 3,

72
00:04:18,160 --> 00:04:24,850
o que eu podería facer é só apuntar o no anterior

73
00:04:24,850 --> 00:04:27,580
ao seguinte nodo de 3.

74
00:04:27,580 --> 00:04:29,400
Entón, eu só estaba a facer algo así.

75
00:04:29,400 --> 00:04:33,400
Pero cal é o problema en facelo?

76
00:04:33,400 --> 00:04:37,400
Eu teño un baleirado de memoria, entón eu non teño acceso ao número 3 máis.

77
00:04:37,400 --> 00:04:42,480
O problema con isto é que eu non vou ser capaz de liberar aquel nó.

78
00:04:42,480 --> 00:04:45,360
Vou ter de baleirado de memoria e (inintelixible) me vai odiar.

79
00:04:45,360 --> 00:04:49,370
Entón, en vez de facelo, eu probablemente debería ter un punteiro temporal.

80
00:04:49,370 --> 00:04:53,210
Entón eu coloque temporal. El vai apuntar para o nodo que desexa eliminar.

81
00:04:53,210 --> 00:04:58,170
E entón eu podo mover os nós anteriores para apuntar ao seguinte nodo

82
00:04:58,170 --> 00:05:00,390
do no que desexa eliminar.

83
00:05:00,390 --> 00:05:02,730
E, finalmente, podo liberar o punteiro.

84
00:05:02,730 --> 00:05:07,480
Teño que liberar o punteiro que eu creei alí?

85
00:05:07,480 --> 00:05:09,560
Eu non teño que, só porque -

86
00:05:09,560 --> 00:05:13,430
a diferenza é que este nodo foi creada usando malloc,

87
00:05:13,430 --> 00:05:17,280
polo que é na pila, mentres que este foi só declarado como un interruptor de NULL na pila.

88
00:05:17,280 --> 00:05:20,000
Entón, eu non teño para liberalo la.

89
00:05:20,000 --> 00:05:22,030
>> Okay. Entón, agora imos falar sobre pilas.

90
00:05:22,030 --> 00:05:24,680
As pilas son moi sinxelo.

91
00:05:24,680 --> 00:05:29,540
Fixemos pilas e colas na clase só usando matrices,

92
00:05:29,540 --> 00:05:32,820
pero ten que ser familiar - pode estar en conta

93
00:05:32,820 --> 00:05:40,740
que tamén pode facer pilas en filas empregando listas ligadas tamén.

94
00:05:40,740 --> 00:05:44,460
Entón se ten unha matriz, o que sería unha pila?

95
00:05:44,460 --> 00:05:46,810
Unha pila de, por unha banda, terá que ter un tamaño.

96
00:05:46,810 --> 00:05:49,950
Ten que gardar o que é o tamaño da pila que ten agora.

97
00:05:49,950 --> 00:05:52,980
E tamén tería un array, neste caso dos números,

98
00:05:52,980 --> 00:05:55,120
pero se o desexa, pode ser un array

99
00:05:55,120 --> 00:06:00,380
de cordas, unha matriz de struct, calquera cousa que quere gardar.

100
00:06:00,380 --> 00:06:03,240
Sobre a pila: A diferenza entre unha pila e unha lista ligada

101
00:06:03,240 --> 00:06:08,590
é que na pila só ten acceso ao elemento, que foi posto na pila.

102
00:06:08,590 --> 00:06:11,770
Chama-se en último lugar, primeiro en saír.

103
00:06:11,770 --> 00:06:15,090
Así como ten unha pila de bandexas,

104
00:06:15,090 --> 00:06:17,670
se pór unha bandexa encima da pila,

105
00:06:17,670 --> 00:06:22,670
tes que eliminar a bandexa primeiro a ter acceso ás outras bandexas.

106
00:06:22,670 --> 00:06:26,310
É o mesmo con Stacks.

107
00:06:26,310 --> 00:06:31,220
Entón, se eu queira, por exemplo, engadir un elemento a unha pila, o que debo facer?

108
00:06:31,220 --> 00:06:34,070
É chamado de impulso, e é moi sinxelo.

109
00:06:34,070 --> 00:06:37,130
O primeiro que tes que facer é comprobar se o tamaño da pila

110
00:06:37,130 --> 00:06:40,150
non é maior ou igual á capacidade do conxunto.

111
00:06:40,150 --> 00:06:45,810
Porque se xa está en plena capacidade, non pode engadir calquera outra cousa.

112
00:06:45,810 --> 00:06:51,140
E, a continuación, se non, só ten que engadir o elemento á pila.

113
00:06:51,140 --> 00:06:54,530
E, finalmente, incrementar o tamaño. Por iso, é moi sinxelo.

114
00:06:54,530 --> 00:06:57,140
Entón, eu só engadir o número 2.

115
00:06:57,140 --> 00:07:00,350
E se eu queira aparecer, o que significa que quero eliminar

116
00:07:00,350 --> 00:07:03,870
o último elemento que se engadiu e voltar o valor do elemento,

117
00:07:03,870 --> 00:07:09,180
o primeiro que ten que comprobar é que a pila non está baleiro.

118
00:07:09,180 --> 00:07:11,510
Porque se está baleiro, non podo voltar nada.

119
00:07:11,510 --> 00:07:14,820
Nese caso, estou volvendo -1.

120
00:07:14,820 --> 00:07:18,960
Se non, eu vou diminuír o tamaño da especificación,

121
00:07:18,960 --> 00:07:22,510
e devolver os números (s.size).

122
00:07:22,510 --> 00:07:27,230
Por que eu diminuír o tamaño e, a continuación, regresar s.size?

123
00:07:27,230 --> 00:07:30,930
É porque, neste caso, a especificación ten tamaño 4,

124
00:07:30,930 --> 00:07:33,810
e quero devolver o cuarto elemento, non?

125
00:07:33,810 --> 00:07:36,030
Pero o que é o índice do cuarto elemento? Tres.

126
00:07:36,030 --> 00:07:44,510
Dende que eu size - será 3, eu só podo voltar s.numbers (s.size)

127
00:07:44,510 --> 00:07:48,410
por que é 3. Entón é só o índice.

128
00:07:48,410 --> 00:07:50,380
Agora >> filas. As colas son practicamente o mesmo.

129
00:07:50,380 --> 00:07:54,950
A única diferenza é que en vez de pasar in, first out,

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

131
00:07:57,480 --> 00:07:59,460
Probablemente, se está esperando para ir a un concerto,

132
00:07:59,460 --> 00:08:04,260
non sería feliz se tivese unha pila en vez de unha fila.

133
00:08:04,260 --> 00:08:07,730
Sendo a última persoa a entrar sería o primeiro en entrar no concerto.

134
00:08:07,730 --> 00:08:09,760
Probablemente non sería feliz.

135
00:08:09,760 --> 00:08:15,020
Na cola, a primeira persoa a entrar é tamén a primeira persoa a saír.

136
00:08:15,020 --> 00:08:18,720
Así, na definición dunha cola de, ademais de ter o tamaño da matriz,

137
00:08:18,720 --> 00:08:23,360
tamén ten que ter a cabeza, que é o índice para o xefe do conxunto.

138
00:08:23,360 --> 00:08:29,000
Así, o primeiro elemento no momento.

139
00:08:29,000 --> 00:08:32,710
Enqueue é o mesmo que o impulso para Stacks.

140
00:08:32,710 --> 00:08:34,980
Se fose moi inxenuo, que tería só que dicir:

141
00:08:34,980 --> 00:08:39,289
ben, eu só podo facer exactamente o mesmo que eu fixen por impulso.

142
00:08:39,289 --> 00:08:44,030
Podo só comprobar que non é máis alá da capacidade.

143
00:08:44,030 --> 00:08:48,760
Se for, eu return false, se non, eu só podo exportar o novo valor

144
00:08:48,760 --> 00:08:50,630
e logo, aumentar o tamaño.

145
00:08:50,630 --> 00:08:52,750
Pero por que iso é malo?

146
00:08:52,750 --> 00:08:55,010
Vexamos este exemplo.

147
00:08:55,010 --> 00:08:57,020
Estou tentando fila unha morea de cousas,

148
00:08:57,020 --> 00:08:58,390
e entón eu vou a retirar da cola e na fila.

149
00:08:58,390 --> 00:09:00,550
Hai unha morea de comandos, pero é moi sinxelo.

150
00:09:00,550 --> 00:09:04,790
Vou fila 5, entón engadir 5 e 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, e entón eu quero desenfileirar algo,

152
00:09:09,310 --> 00:09:12,000
o que significa que eu estou indo para eliminar o primeiro elemento.

153
00:09:12,000 --> 00:09:14,640
Entón, eu estou indo para eliminar o número 3, non?

154
00:09:14,640 --> 00:09:17,320
O primeiro elemento. Okay.

155
00:09:17,320 --> 00:09:21,450
Agora, se eu tentar fila outra cousa, o que vai pasar?

156
00:09:21,450 --> 00:09:24,290
Segundo a miña implantación,

157
00:09:24,290 --> 00:09:31,040
Eu ía poñer o seguinte número na q.size índice.

158
00:09:31,040 --> 00:09:35,140
Neste caso, o tamaño é de 8,

159
00:09:35,140 --> 00:09:38,640
de xeito que o índice de 8 estará aquí na última posición.

160
00:09:38,640 --> 00:09:43,900
Se eu tentar fila un aquí, eu estaría substituíndo a última posición

161
00:09:43,900 --> 00:09:45,870
ao número 1, o cal é totalmente incorrecto.

162
00:09:45,870 --> 00:09:49,870
O que quero facer é embrulhar arredor e ir á primeira posición.

163
00:09:49,870 --> 00:09:52,870
Quizais lle gustaría só de dicir, ben, eu só teño que comprobar

164
00:09:52,870 --> 00:09:55,600
se realmente pode poñer algo alí.

165
00:09:55,600 --> 00:09:58,560
Se non, eu acabo de dicir, ah, a nova capacidade total

166
00:09:58,560 --> 00:10:02,010
é realmente capacidade - 1, e non pode poñer un elemento alí.

167
00:10:02,010 --> 00:10:06,150
Pero cal é o problema? O problema é que se eu só desenfileirar todo aquí

168
00:10:06,150 --> 00:10:08,240
e despois eu intento engadir algo máis, sería só dicir:

169
00:10:08,240 --> 00:10:11,210
ben, estaba en plena capacidade, que é 0.

170
00:10:11,210 --> 00:10:13,620
Así, a cola está desaparecido.

171
00:10:13,620 --> 00:10:16,990
Ten que participa en torno, e un xeito de involucrar ao redor de

172
00:10:16,990 --> 00:10:22,040
que vostedes aprenderon en Serie de exercicios visionarios e outros estaba usando mod.

173
00:10:22,040 --> 00:10:29,090
Podes probalo na casa para entender por que faría q.size + q.head

174
00:10:29,090 --> 00:10:31,080
capacidade de modificación, pero se comprobar aquí,

175
00:10:31,080 --> 00:10:34,760
podemos ver que funciona.

176
00:10:34,760 --> 00:10:37,760
Así, no último exemplo, q.size foi de 8

177
00:10:37,760 --> 00:10:47,590
e cabeza foi de 1, porque foi aquí esta posición da matriz.

178
00:10:47,590 --> 00:10:51,970
Por iso, será 8 + 1, 9. Mod capacidade de 9 sería 0.

179
00:10:51,970 --> 00:10:56,640
Ía ao índice 0. Nós imos estar na posición correcta.

180
00:10:56,640 --> 00:10:59,750
E, a continuación, tentar a cola na casa.

181
00:10:59,750 --> 00:11:04,950
Algunhas cousas importantes: intente entender a diferenza entre unha pila e unha cola.

182
00:11:04,950 --> 00:11:11,620
Xa na casa, para tratar de obter moi familiarizado coa implementación de poñela na fila, dequeue, push e pop.

183
00:11:11,620 --> 00:11:16,560
E tamén entendo cando usaría cada unha delas.

184
00:11:16,560 --> 00:11:22,830
>> Entón imos relaxarse ​​por 10 segundos, cunha chea de Pokémons.

185
00:11:22,830 --> 00:11:26,080
E agora imos voltar a estruturas de datos.

186
00:11:26,080 --> 00:11:29,770
Hash táboas. Moitas persoas estaban con medo de táboas de hash.

187
00:11:29,770 --> 00:11:33,650
no conxunto de problemas 6, Corrector Ortográfico.

188
00:11:33,650 --> 00:11:35,980
As táboas de hash e intentos, moitas persoas están con medo deles.

189
00:11:35,980 --> 00:11:38,540
Eles pensan que é tan difícil de entender. Si?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Problema xogo 5. Problema >> axuste 5, si. Grazas Rob.

191
00:11:41,490 --> 00:11:43,370
É. Seis era Huff n 'Puff, si.

192
00:11:43,370 --> 00:11:49,340
Problema xogo 5 foi Ortográfico, e tiña que usar unha táboa hash ou un intento.

193
00:11:49,340 --> 00:11:55,360
Moita xente pensou que eran super difícil de entender, pero son realmente moi simple.

194
00:11:55,360 --> 00:12:01,290
¿Que é unha táboa hash, basicamente? Unha táboa é un conxunto de listas ligadas.

195
00:12:01,290 --> 00:12:06,730
A única diferenza entre unha matriz e unha táboa hash

196
00:12:06,730 --> 00:12:09,730
é que na táboa de hash que ten algo chamado de función hash.

197
00:12:09,730 --> 00:12:12,080
¿Que é unha función hash?

198
00:12:12,080 --> 00:12:13,970
Non sei se vostedes poden ler aquí.

199
00:12:13,970 --> 00:12:16,090
Este é un exemplo dunha táboa de hash.

200
00:12:16,090 --> 00:12:19,220
Así, podes ver que ten unha matriz con 31 elementos.

201
00:12:19,220 --> 00:12:22,440
E o que facemos nunha táboa hash é ter unha función hash

202
00:12:22,440 --> 00:12:26,660
que vai traducir unha clave, cada un int a un índice.

203
00:12:26,660 --> 00:12:31,740
Se, por exemplo, se eu queira escoller para B. Harrison,

204
00:12:31,740 --> 00:12:34,190
Quere poñer B. Harrison en miñas funcións de hash,

205
00:12:34,190 --> 00:12:36,960
ea función de hash retornaría 24.

206
00:12:36,960 --> 00:12:40,930
Entón eu sei que quero gardar B. Harrison en 24.

207
00:12:40,930 --> 00:12:46,580
Así que esta é a diferenza entre ter só unha matriz e ter unha táboa hash.

208
00:12:46,580 --> 00:12:48,740
Na táboa hash terá unha función que vai dicir

209
00:12:48,740 --> 00:12:54,740
onde almacenar os datos que quere gardar.

210
00:12:54,740 --> 00:12:57,040
Para a función de hash, quere ollar a unha función hash

211
00:12:57,040 --> 00:13:00,600
que é determinista e ben distribuída.

212
00:13:00,600 --> 00:13:07,810
Como podes ver aquí, ve que unha gran cantidade de datos que eu quería tenda era en realidade 19

213
00:13:07,810 --> 00:13:12,470
en vez de usar o 31 e 30 e 29, que foron todos.

214
00:13:12,470 --> 00:13:16,920
Así, a función de hash que usei non era moi ben distribuído.

215
00:13:16,920 --> 00:13:20,710
Cando dicimos ben distribuída, isto significa que queremos ter,

216
00:13:20,710 --> 00:13:26,520
aproximadamente, polo menos, 1 ou 2 para cada unha das -

217
00:13:26,520 --> 00:13:32,190
como, unha diferenza de 1 ou 2 para cada un dos índices das matrices.

218
00:13:32,190 --> 00:13:43,950
Quere ter, aproximadamente, o mesmo número de elementos en cada lista encadeada na matriz.

219
00:13:43,950 --> 00:13:48,600
E é fácil de comprobar se é válido na táboa de hash, ver como táboas de hash.

220
00:13:48,600 --> 00:13:51,770
>> Entón árbores. Esta é unha árbore.

221
00:13:51,770 --> 00:13:56,400
Árbores en ciencia da computación están de cabeza para baixo por algún motivo.

222
00:13:56,400 --> 00:14:00,150
Entón, aquí tes a raíz da árbore e, a continuación, as follas.

223
00:14:00,150 --> 00:14:05,630
Debe só saber a nomenclatura para os pais eo neno.

224
00:14:05,630 --> 00:14:12,880
Cada nodo ten os seus fillos, que son os nós que están por baixo do pai.

225
00:14:12,880 --> 00:14:19,660
Así, por exemplo, 2, será o pai para 3 e para a outra neno alí mesmo,

226
00:14:19,660 --> 00:14:25,290
mentres 3 será o pai dunha e os outros nenos que están aí.

227
00:14:25,290 --> 00:14:29,990
E un será 3 do neno, e así por diante.

228
00:14:29,990 --> 00:14:34,610
Temos algo moito máis interesante, chamado dunha árbore de busca binaria,

229
00:14:34,610 --> 00:14:39,040
no que todos os valores á dereita dun nodo

230
00:14:39,040 --> 00:14:41,660
van estar á dereita, aquí - na dereita,

231
00:14:41,660 --> 00:14:46,780
será maior que o elemento da raíz.

232
00:14:46,780 --> 00:14:49,780
Entón, se eu teño o número 5 aquí, todos os elementos á dereita

233
00:14:49,780 --> 00:14:51,940
será maior que 5, e na parte esquerda

234
00:14:51,940 --> 00:14:56,770
todos os elementos que van ser inferior a 5.

235
00:14:56,770 --> 00:14:58,780
Por iso é útil?

236
00:14:58,780 --> 00:15:01,660
Ben, se eu queira comprobar que o número 7 está aquí, por exemplo,

237
00:15:01,660 --> 00:15:05,960
Acaba de ir a 5 primeiro e eu vou ver, é 7 maior ou menor que 5?

238
00:15:05,960 --> 00:15:09,540
É máis, entón eu sei que vai ter que ser na parte dereita da árbore.

239
00:15:09,540 --> 00:15:13,980
Entón, eu teño moito menos cousas para ollar.

240
00:15:13,980 --> 00:15:19,520
Na posta en marcha dunha árbore de busca binaria, o no, eu só vou ter que ter datos,

241
00:15:19,520 --> 00:15:21,750
así int n; tamén pode ter unha cadea

242
00:15:21,750 --> 00:15:23,630
ou calquera cousa que quería.

243
00:15:23,630 --> 00:15:28,100
Só ten que ter coidado en definir o que é máis, o que sexa menor.

244
00:15:28,100 --> 00:15:30,390
Entón se tivese cordas, por exemplo, pode definir

245
00:15:30,390 --> 00:15:34,690
que todas esas cousas á dereita terá lonxitude maior,

246
00:15:34,690 --> 00:15:40,940
a esquerda terá lonxitudes pequenas, polo que é realmente ata.

247
00:15:40,940 --> 00:15:44,930
>> Como podo aplicar para atopar CEST?

248
00:15:44,930 --> 00:15:47,840
O primeiro que tes que facer é comprobar que a raíz é NULL.

249
00:15:47,840 --> 00:15:50,920
De ser NULL, significa que a cousa non está aí

250
00:15:50,920 --> 00:15:53,330
porque non ten nin unha árbore, non?

251
00:15:53,330 --> 00:15:55,790
Entón eu voltar false.

252
00:15:55,790 --> 00:15:58,740
Se non, eu vou comprobar se o número é maior

253
00:15:58,740 --> 00:16:01,720
que o valor da raíz.

254
00:16:01,720 --> 00:16:04,250
Vou tentar atopar o elemento á dereita

255
00:16:04,250 --> 00:16:08,590
da árbore.

256
00:16:08,590 --> 00:16:11,310
Vostede ve que eu estou a usar recursão aquí.

257
00:16:11,310 --> 00:16:14,150
E entón ser menos, eu vou ollar para a esquerda.

258
00:16:14,150 --> 00:16:18,330
E, finalmente, doutro xeito, se non é menos ou non maior,

259
00:16:18,330 --> 00:16:20,660
isto significa que é o propio valor.

260
00:16:20,660 --> 00:16:23,010
Entón, eu só retornar true.

261
00:16:23,010 --> 00:16:26,360
Podes ver aquí que eu usei, se si, se.

262
00:16:26,360 --> 00:16:30,820
E lembre, o cuestionario 0, tivemos un problema que tiña, se si, se,

263
00:16:30,820 --> 00:16:32,780
e ten que atopar a ineficiencia,

264
00:16:32,780 --> 00:16:35,180
ea ineficiencia foi que usou se.

265
00:16:35,180 --> 00:16:39,060
Debería usar se, else if, else if e else.

266
00:16:39,060 --> 00:16:44,240
Entón, eu debería usar else if e else if e else aquí?

267
00:16:44,240 --> 00:16:46,200
Alguén - É mesmo?

268
00:16:46,200 --> 00:16:51,140
[Falando Student, inaudível]

269
00:16:51,140 --> 00:16:53,480
É xenial. Entón, ela está dicindo que non importa,

270
00:16:53,480 --> 00:16:55,930
só porque a ineficiencia que tiñamos antes

271
00:16:55,930 --> 00:16:59,550
foi que, porque, se cadra, se algunha condición foi satisfeita,

272
00:16:59,550 --> 00:17:03,570
para que teña realizado unha acción, pero así que ía comprobar as outras condicións.

273
00:17:03,570 --> 00:17:06,319
Pero, neste caso, voltou de inmediato, polo que non importa.

274
00:17:06,319 --> 00:17:09,220
Entón non ten que empregar else if.

275
00:17:09,220 --> 00:17:11,740
>> E, finalmente, imos falar de intentos,

276
00:17:11,740 --> 00:17:13,800
cal é o favorito de todos.

277
00:17:13,800 --> 00:17:15,980
O intento é unha árbore de matrices.

278
00:17:15,980 --> 00:17:20,369
É moi rápido para buscar valores, pero usa moita memoria.

279
00:17:20,369 --> 00:17:22,530
E é, xeralmente, para filtrar as palabras, entón cando

280
00:17:22,530 --> 00:17:27,920
pretende levar, por exemplo, eu non sei, como un libro de teléfono no seu teléfono

281
00:17:27,920 --> 00:17:30,440
e quere ser capaz de tipo B

282
00:17:30,440 --> 00:17:32,510
e só ten os nomes de persoas que teñen B.

283
00:17:32,510 --> 00:17:37,960
É moi fácil de implementar que o uso de un intento, por exemplo.

284
00:17:37,960 --> 00:17:39,820
Como define un nó nun intento?

285
00:17:39,820 --> 00:17:43,910
Vostede só ten que ter un bool que será is_word.

286
00:17:43,910 --> 00:17:48,660
Isto representa que o uso de todos os personaxes antes de que o no,

287
00:17:48,660 --> 00:17:51,920
que foron capaces de formar unha palabra,

288
00:17:51,920 --> 00:17:57,230
e entón vai ter unha matriz de punteiros para os nós.

289
00:17:57,230 --> 00:18:03,120
Podes ver que temos un conxunto de nós pai, entón nodo * array? Si?

290
00:18:03,120 --> 00:18:06,050
Entón, imos ver como iso vai funcionar. Para a comprobación ortográfica,

291
00:18:06,050 --> 00:18:08,230
temos unha matriz de 27 elementos,

292
00:18:08,230 --> 00:18:12,150
porque temos todas as letras máis o apóstrofo.

293
00:18:12,150 --> 00:18:17,800
Antes aquí eu só vou usar 2, porque quero ser capaz de escribir no cadro.

294
00:18:17,800 --> 00:18:20,230
Okay. Polo tanto, este é un exemplo de un intento.

295
00:18:20,230 --> 00:18:25,600
Se eu definir o primeiro nodo, eu vou ter unha matriz de dous elementos

296
00:18:25,600 --> 00:18:29,290
que son dous punteiros para NULL, entón eu só poñer 'a' e 'b'.

297
00:18:29,290 --> 00:18:32,430
E eu vou ter un booleano que di is_word.

298
00:18:32,430 --> 00:18:34,420
Vai ser falso para o primeiro,

299
00:18:34,420 --> 00:18:37,370
só porque, antes de que non ten ningún carácter.

300
00:18:37,370 --> 00:18:40,900
Así, unha palabra baleira non é unha palabra. Polo tanto, é falsa.

301
00:18:40,900 --> 00:18:46,320
Se eu queira engadir 'a' a este dicionario, o que eu teño que facer?

302
00:18:46,320 --> 00:18:49,760
Eu só que malloc un novo nodo a 'a',

303
00:18:49,760 --> 00:18:54,630
e, a continuación, engadir a súa palabra como certa.

304
00:18:54,630 --> 00:19:00,180
Por iso, só representa que ter 'a' será verdade. Ten sentido?

305
00:19:00,180 --> 00:19:04,120
Entón, se eu queira engadir 'ba', eu vou ter que malloc 1 para 'b',

306
00:19:04,120 --> 00:19:07,550
e entón eu vou configurar a booleana como false,

307
00:19:07,550 --> 00:19:10,160
porque 'b', por si só non é unha palabra.

308
00:19:10,160 --> 00:19:13,010
Entón eu estou indo a malloc outro para 'a', entón 'ba',

309
00:19:13,010 --> 00:19:16,290
e entón eu vou montar é unha palabra de verdade.

310
00:19:16,290 --> 00:19:18,950
Por 'ba' é unha palabra.

311
00:19:18,950 --> 00:19:21,910
E entón, se quero ver se 'b' é neste dicionario,

312
00:19:21,910 --> 00:19:26,730
Podo ir ao primeiro, 'b'. Eu baixar, e eu ollar é palabra, e ela di que falsa.

313
00:19:26,730 --> 00:19:30,110
Polo tanto, non é unha palabra. Se eu queira revisar 'ba',

314
00:19:30,110 --> 00:19:38,010
Vou para o primeiro, 'b', e logo ir a 'a', e eu vexo certo, polo que é unha palabra. Ten sentido?

315
00:19:38,010 --> 00:19:41,950
Moitas persoas están confusas coa intentos. Non?

316
00:19:41,950 --> 00:19:44,740
>> Finalmente, codificación Huffman. Codificación de Huffman é moi útil

317
00:19:44,740 --> 00:19:47,550
para aforrar memoria e comprimir arquivos de texto,

318
00:19:47,550 --> 00:19:52,270
só porque unha morea de veces que usa 'a' e 'e', ​​por exemplo,

319
00:19:52,270 --> 00:19:57,710
nos seus documentos, pero eu non sei se vostedes utilizan 'q' ou 'z' tanto.

320
00:19:57,710 --> 00:20:02,040
Tendo só 1 byte para cada personaxe,

321
00:20:02,040 --> 00:20:08,520
cada - os 256 carácteres que temos na táboa ASCII non é moito mellor,

322
00:20:08,520 --> 00:20:11,410
só porque hai algúns personaxes que utiliza moito máis,

323
00:20:11,410 --> 00:20:15,180
entón probablemente usar menos memoria para aqueles.

324
00:20:15,180 --> 00:20:17,560
Como fago para usar o código de Huffman?

325
00:20:17,560 --> 00:20:20,010
Temos que facer unha árbore de Huffman.

326
00:20:20,010 --> 00:20:23,370
 Unha árbore de Huffman ten nós

327
00:20:23,370 --> 00:20:27,760
que ten un símbolo que será como, 'a', 'b', 'c', a carta,

328
00:20:27,760 --> 00:20:32,990
letra que ten, unha frecuencia que é a frecuencia con que a palabra aparece no texto,

329
00:20:32,990 --> 00:20:36,280
que estaba creando a árbore de Huffman para,

330
00:20:36,280 --> 00:20:41,800
e logo, un nó que vai apuntar á esquerda da árbore Huffman

331
00:20:41,800 --> 00:20:47,210
e outro no que vai apuntar á dereita. Así como unha árbore.

332
00:20:47,210 --> 00:20:49,440
Como constrúe unha árbore de Huffman?

333
00:20:49,440 --> 00:20:54,020
Vai escoller os dous nós que teñen as frecuencias máis baixas.

334
00:20:54,020 --> 00:20:56,490
Se tes un lazo que vai escoller os 2 nós

335
00:20:56,490 --> 00:20:59,870
que teñen os valores máis baixos, así ASCII.

336
00:20:59,870 --> 00:21:02,420
Axiña, vai crear unha nova árbore fóra destas 2 nós

337
00:21:02,420 --> 00:21:08,030
que terá a miúdo combinados no nodo pai.

338
00:21:08,030 --> 00:21:13,240
E entón está indo para eliminar os dous fillos do bosque

339
00:21:13,240 --> 00:21:15,570
e substitúe-los co pai.

340
00:21:15,570 --> 00:21:18,930
E vai repetir iso ata que só ten unha árbore no bosque.

341
00:21:18,930 --> 00:21:23,840
Entón, imos ver como faría unha árbore Huffman para ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Podes ver aquí que todas as cartas teñen frecuencia 1, excepto a 'A'; que frecuencia 2.

343
00:21:29,220 --> 00:21:34,090
Entón, eu criei nós para todas as letras que engada en orde de valor ASCII e frecuencia.

344
00:21:34,090 --> 00:21:40,090
Entón, se eu quere crear a primeira árbore, será con 'L' e 'M'.

345
00:21:40,090 --> 00:21:43,100
Entón é aquí. A frecuencia do par será 2

346
00:21:43,100 --> 00:21:49,470
por que é 1 + 1, entón o seguinte 2 coas frecuencias máis baixas son 'Y' e 'Z'.

347
00:21:49,470 --> 00:21:53,180
E entón eu teño todos eles ser - teñen unha frecuencia de 2.

348
00:21:53,180 --> 00:22:00,470
Entón, cales son os que teñen o valor ASCII menor para o seguinte?

349
00:22:00,470 --> 00:22:04,830
'A' e 'L'. Entón eu crear o novo nó,

350
00:22:04,830 --> 00:22:09,930
e, por fin, é 4 e 2, entón 2 será do lado esquerdo.

351
00:22:09,930 --> 00:22:12,430
E esta é a árbore de Huffman.

352
00:22:12,430 --> 00:22:16,060
Entón, se eu quero escribir un texto,

353
00:22:16,060 --> 00:22:24,440
como en binario para converter en texto, a través da árbore de Huffman é moi sinxelo.

354
00:22:24,440 --> 00:22:30,220
Por exemplo, se eu digo que o cambio para a esquerda é a 0 e movendo á dereita é un 1,

355
00:22:30,220 --> 00:22:32,410
Que é o que vai representar?

356
00:22:32,410 --> 00:22:35,530
Así como 1, 1, xa que logo, dereita, dereita,

357
00:22:35,530 --> 00:22:40,370
e logo, 0, de xeito que sería deixar G, e logo, 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Entón, 1, 0, así só 1, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
E, a continuación, 0, 1, de xeito que "Z".

360
00:22:47,540 --> 00:22:52,170
E, a continuación, 1, 0, 0 - ningún.

361
00:22:52,170 --> 00:22:56,780
0, 0 será 'Y', de xeito preguiceiro.

362
00:22:56,780 --> 00:23:06,060
Entón, iso é todo para min, Rob vai asumir.

363
00:23:06,060 --> 00:23:08,400
>> [Rob Bowden] Así, a semana 7 cousas.

364
00:23:08,400 --> 00:23:11,390
Temos moito que pasar por riba moi rápido.

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

366
00:23:13,430 --> 00:23:16,760
Biblioteca CS50, a continuación, HTML, HTTP, CSS.

367
00:23:16,760 --> 00:23:20,990
Todo como en 15 a 20 minutos.

368
00:23:20,990 --> 00:23:24,330
Operadores bit a bit. Hai seis deles que precisa saber.

369
00:23:24,330 --> 00:23:31,200
Bit a bit e, bit a bit OR, XOR, desprazamento á esquerda, desprazamento cara á dereita, e non.

370
00:23:31,200 --> 00:23:35,420
Dereito cambiar e non apenas viu en charla en todo.

371
00:23:35,420 --> 00:23:40,480
Nós imos pasar por iso rapidamente aquí, pero é bo saber que estes son os 6 que hai.

372
00:23:40,480 --> 00:23:45,070
Lembre que os operadores bit a bit é como cando fai 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Non está lidando con o binario de 3 e 4.

374
00:23:49,420 --> 00:23:56,550
Con operadores bit a bit en realidade está lidando cos bits individuais dos números 3 e 4.

375
00:23:56,550 --> 00:23:59,120
>> Entón, o primeiro que imos dicir é bit a bit non,

376
00:23:59,120 --> 00:24:02,340
e todo o que fai é inverter as bits.

377
00:24:02,340 --> 00:24:05,500
Entón, aquí, se está escribindo isto en C, non gravala-lo

378
00:24:05,500 --> 00:24:09,380
como ~ 11011 ou calquera outra cousa, podería escribilo como ~ 4,

379
00:24:09,380 --> 00:24:12,970
e logo, ía virar a representación binaria de 4.

380
00:24:12,970 --> 00:24:24,800
Entón, aquí,-dun número binario 1101101 vai virar exactamente as 1 do que 0 e todo 0, 1 de.

381
00:24:24,800 --> 00:24:27,600
Como dixen alí, o uso frecuente desta,

382
00:24:27,600 --> 00:24:30,830
e nós imos velo en algo, é coma nós queremos chegar a algún número

383
00:24:30,830 --> 00:24:35,460
onde todos os bits son 1, con excepción dun deles.

384
00:24:35,460 --> 00:24:38,560
Por iso, é xeralmente máis doado de expresar o número

385
00:24:38,560 --> 00:24:40,630
onde só aquel único bit é definido,

386
00:24:40,630 --> 00:24:44,650
e, a continuación, tomar o ~ del, entón todos os outros bits defínese, excepto por iso.

387
00:24:44,650 --> 00:24:50,300
Entón é iso que nós imos usar un pouco máis.

388
00:24:50,300 --> 00:24:58,220
>> OU bit a bit. Aquí están dous números binarios, e eses 2 números

389
00:24:58,220 --> 00:25:00,780
son moi representativo, xa que representan todas as posibles

390
00:25:00,780 --> 00:25:07,290
combinación de bits que precisa para operar.

391
00:25:07,290 --> 00:25:13,540
Aquí, cando clicaria cada bit, nós só estamos indo a comparar directamente abaixo.

392
00:25:13,540 --> 00:25:15,410
Así, na parte esquerda, temos un 1 e un 1.

393
00:25:15,410 --> 00:25:20,510
Cando bit a bit | aqueles, que é o que eu vou conseguir? Unha.

394
00:25:20,510 --> 00:25:25,320
Logo bit a bit | 0 e 1 que me vai dar? Unha.

395
00:25:25,320 --> 00:25:27,840
Bit a bit 1 e 0, será o mesmo, un.

396
00:25:27,840 --> 00:25:31,880
Bit a bit 0 | 0 me vai dar 0.

397
00:25:31,880 --> 00:25:37,300
Así, o único caso en que eu recibín 0 é o 0 | 0 caso.

398
00:25:37,300 --> 00:25:40,020
E pode pensar que, así como os seus alcaldes lóxicas.

399
00:25:40,020 --> 00:25:44,830
Entón, se pensar en 1 como certo e 0 como falso, o mesmo se aplica aquí.

400
00:25:44,830 --> 00:25:50,040
Tan certo ou certo é certo, verdadeiro ou falso é certo.

401
00:25:50,040 --> 00:25:57,150
Falso ou verdadeiro é certo, falso ou falso é o único que é realmente falsa.

402
00:25:57,150 --> 00:26:00,100
Aquí está o exemplo que debes saber

403
00:26:00,100 --> 00:26:05,160
como un bo exemplo de cando operadores bit a bit son usados.

404
00:26:05,160 --> 00:26:08,660
Aquí se ou 'A' maiúsculo con OX20,

405
00:26:08,660 --> 00:26:11,830
e imos ollar para iso nun segundo, temos algo.

406
00:26:11,830 --> 00:26:16,020
E se nós ou minúsculas 'a' con OX20 temos algo.

407
00:26:16,020 --> 00:26:26,750
Entón, imos puxar arriba da táboa ASCII.

408
00:26:26,750 --> 00:26:34,000
Okay. Aquí vemos que 'A' é -

409
00:26:34,000 --> 00:26:36,920
aquí temos 'A' é decimal 65.

410
00:26:36,920 --> 00:26:45,120
Pero eu vou con hexadecimal, que é Ox41.

411
00:26:45,120 --> 00:26:48,280
Seguro que xa vimos en clase. Eu creo que nós vimos en clase

412
00:26:48,280 --> 00:26:52,730
que é moi doado converter hexadecimal para binario.

413
00:26:52,730 --> 00:26:55,280
Entón, aquí, se eu queira poñer 4 en binario,

414
00:26:55,280 --> 00:26:59,550
que só será 0100.

415
00:26:59,550 --> 00:27:03,620
Este é un lugar de, lugar de 2, 4 do lugar, polo que este é 4.

416
00:27:03,620 --> 00:27:08,550
Entón eu podo dividir 1 en binario, que será 0001.

417
00:27:08,550 --> 00:27:14,280
E así é que isto vai ser a representación de 'A' en binario.

418
00:27:14,280 --> 00:27:22,720
Tendo en minúsculas 'a', é agora será Ox61,

419
00:27:22,720 --> 00:27:27,050
onde, dividíndose estes no seu binario, para 6 -

420
00:27:27,050 --> 00:27:37,830
Imos realmente facelo - que non hai goma? Eraser.

421
00:27:37,830 --> 00:27:48,220
Ox61. Entón, dividindo 6 en binario será 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
E a división 1 será 0001.

423
00:27:54,610 --> 00:27:56,520
Mirando para a diferenza entre estes dous,

424
00:27:56,520 --> 00:28:04,250
vemos que a única diferenza entre unha letra minúscula e un 'A' maiúsculo é este único bit.

425
00:28:04,250 --> 00:28:11,810
Entón, volvendo para aquí - todo ben.

426
00:28:11,810 --> 00:28:15,920
Voltar aquí, se miramos para o que o bit é OX20,

427
00:28:15,920 --> 00:28:22,210
OX20 así dividindo-se no seu binario,

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

429
00:28:27,310 --> 00:28:33,470
OX20, o único bit que está definido é este pouco que estamos preocupados,

430
00:28:33,470 --> 00:28:38,210
coa alternancia entre capitais e minúsculas 'a'.

431
00:28:38,210 --> 00:28:47,610
Se eu ou 'A', que é un agasallo, 'A',

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

433
00:28:50,580 --> 00:28:53,490
que é o que eu vou conseguir?

434
00:28:53,490 --> 00:28:58,960
[Student, inaudível] >> minúsculas 'a', porque vai virar este bit a 1.

435
00:28:58,960 --> 00:29:04,170
E se eu ou 'a' con OX20, que é o que eu vou conseguir?

436
00:29:04,170 --> 00:29:08,780
Minúsculas un, porque só ORING 'a' con OX20,

437
00:29:08,780 --> 00:29:14,580
Eu só vou ser ORING este único bit a 1, que xa está a 1, polo que non importa.

438
00:29:14,580 --> 00:29:17,960
Entón, temos 'a' e 'a'.

439
00:29:17,960 --> 00:29:24,820
>> Bit a bit e. Unha vez máis, podemos pensar niso como a nosa contrapartida lóxica e.

440
00:29:24,820 --> 00:29:28,180
Na parte esquerda temos certo e fiel.

441
00:29:28,180 --> 00:29:31,160
Vai ser verdade, e para todos os casos,

442
00:29:31,160 --> 00:29:36,270
falso e certo ou verdadeiro e falso, ou falso e falsa,

443
00:29:36,270 --> 00:29:38,550
ningunha destas cousas son certas.

444
00:29:38,550 --> 00:29:44,170
Entón, o que acaba ficando é 1000.

445
00:29:44,170 --> 00:29:48,830
Entón, agora, aquí, aquí é onde eu usei o bit a bit de confianza non,

446
00:29:48,830 --> 00:29:52,230
onde tivemos OX20.

447
00:29:52,230 --> 00:29:54,350
Polo tanto, esta é OX20.

448
00:29:54,350 --> 00:29:59,570
Agora o que quero facer, bit a bit ~ de OX20.

449
00:29:59,570 --> 00:30:03,600
Isto vai invertir todo bits.

450
00:30:03,600 --> 00:30:09,330
Entón, eu teño 1101, 1111.

451
00:30:09,330 --> 00:30:18,940
E así 'A' anded con ~ OX20 me vai dar o que?

452
00:30:18,940 --> 00:30:22,430
A única parte que realmente necesitamos pensar é un regalo,

453
00:30:22,430 --> 00:30:26,020
xa que, se todos eses bits son definidos a 1,

454
00:30:26,020 --> 00:30:29,000
entón nós estamos indo a obter exactamente o que 'A' é,

455
00:30:29,000 --> 00:30:31,260
agás, quizais, o que é pouco.

456
00:30:31,260 --> 00:30:34,460
Por se fose a 1, agora que vai ser definido a 0,

457
00:30:34,460 --> 00:30:39,810
porque todo o que iso é, anded con iso será 0.

458
00:30:39,810 --> 00:30:43,280
Entón o que é 'A' e ~ OX20 me vai dar?

459
00:30:43,280 --> 00:30:48,200
[Os alumnos responden, inaudível] >> E o que é 'a' e - é 'A'.

460
00:30:48,200 --> 00:30:52,170
E o que é 'a' + ~ OX20 me vai dar?

461
00:30:52,170 --> 00:30:56,720
'A.' Porque este é actualmente a 1.

462
00:30:56,720 --> 00:30:59,570
Anding con este 0 vai facelo un 0,

463
00:30:59,570 --> 00:31:02,530
e agora estamos indo a obter un 'A'.

464
00:31:02,530 --> 00:31:06,600
>> Ambos son 'A', e por último, pero non menos importante deste tipo,

465
00:31:06,600 --> 00:31:10,830
temos XOR. É moi parecido, ou,

466
00:31:10,830 --> 00:31:14,400
agás que significa exclusivamente ou.

467
00:31:14,400 --> 00:31:18,420
Este é parecido co que adoita pensar en como ou no mundo real.

468
00:31:18,420 --> 00:31:23,190
Entón quere 'x' ou 'y', pero non ambos.

469
00:31:23,190 --> 00:31:28,700
Aquí 1 ^ 1 será 0.

470
00:31:28,700 --> 00:31:33,650
Porque a verdadeira, é dicir - non funciona tan ben co lóxico certo e falso

471
00:31:33,650 --> 00:31:37,150
como bit a bit e e ou facer,

472
00:31:37,150 --> 00:31:40,100
pero é verdade ^ certo é falso.

473
00:31:40,100 --> 00:31:44,810
Porque nós só queremos voltar true se só un deles é certo.

474
00:31:44,810 --> 00:31:50,950
Así, un ^ 1 é 0. E como a 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
É 1. 1 ^ 0 é de 1, 0 ^ 0 é 0.

476
00:31:56,010 --> 00:32:03,890
Así, en todas as circunstancias, bit a bit 0 0 algo será 0.

477
00:32:03,890 --> 00:32:10,270
1 bit a bit algo 0 ou 0 1 bit a bit,

478
00:32:10,270 --> 00:32:14,660
se é | ou ^, será a 1, e se é e será 0.

479
00:32:14,660 --> 00:32:20,850
E o único caso no que un bit a bit 1 non é un é coa exclusiva ou.

480
00:32:20,850 --> 00:32:24,580
Iso é 0110.

481
00:32:24,580 --> 00:32:36,520
Entón, aquí, agora, usando XOR - entón estamos de volta a 20.

482
00:32:36,520 --> 00:32:43,480
'A' ^ OX20 é eses 2 bits que estamos comparando.

483
00:32:43,480 --> 00:32:50,020
Así, a 1 ^ 0 me vai dar unha cousa? A unha.

484
00:32:50,020 --> 00:32:58,430
'A' ^ OX20 me vai dar? Minúsculas a.

485
00:32:58,430 --> 00:33:04,010
'A' ^ OX20 me vai dar? Capital A.

486
00:33:04,010 --> 00:33:09,310
Porque todo o que iso está facendo, este XORing con OX20

487
00:33:09,310 --> 00:33:15,380
é efectivamente lanzando todo o que este bit é.

488
00:33:15,380 --> 00:33:21,240
Se este é un 0, el agora vai facer un 1.

489
00:33:21,240 --> 00:33:26,160
Xa que este é un 1, 1 ^ 1 é 0.

490
00:33:26,160 --> 00:33:33,280
Polo tanto, a nosa 'a' converteuse en 'A', ea nosa 'A' converteuse en 'a'.

491
00:33:33,280 --> 00:33:36,910
Entón XOR é un xeito moi cómodo de só lanzando o caso.

492
00:33:36,910 --> 00:33:39,960
Só quere iterado sobre unha secuencia de letras

493
00:33:39,960 --> 00:33:44,330
e cambiar o caso de cada personaxe,

494
00:33:44,330 --> 00:33:50,680
só XOR todo con OX20.

495
00:33:50,680 --> 00:33:55,220
>> Agora nos queda quenda. Desprazamento á esquerda é só vai basicamente

496
00:33:55,220 --> 00:34:01,250
empurrar todos os números para, ou á esquerda, e inserir 0 de tras deles.

497
00:34:01,250 --> 00:34:05,550
Polo tanto, temos aquí 00001101.

498
00:34:05,550 --> 00:34:08,560
Imos empurrar 3 0 do da dereita,

499
00:34:08,560 --> 00:34:13,580
e temos 01101000.

500
00:34:13,580 --> 00:34:16,380
En termos non binarios,

501
00:34:16,380 --> 00:34:24,699
vemos que iso está realmente lidando 13 con 3 desprazouse esquerda, que nos dá 104.

502
00:34:24,699 --> 00:34:32,530
Entón desprazamento á esquerda, vemos aquí, x << y é basicamente x * 2 ^ y.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 a 8, de xeito que 13 * 8 é 104.

504
00:34:40,139 --> 00:34:45,679
Se só pensar en binario, en xeral, como cada un díxito,

505
00:34:45,679 --> 00:34:49,530
Se comezar a partir da dereita, é a 1 do lugar, entón a 2 do lugar, entón a 4 do lugar.

506
00:34:49,530 --> 00:34:51,330
Entón, empurrando 0 do da dereita,

507
00:34:51,330 --> 00:34:55,080
estamos só empurrando as cousas que estaban no 4 do lugar para o 8 de lugar,

508
00:34:55,080 --> 00:34:57,920
e as cousas que estaban no 8 de lugar a lugar, a 16 de.

509
00:34:57,920 --> 00:35:01,280
Cada quenda só multiplica por 2. Si?

510
00:35:01,280 --> 00:35:05,210
[Estudante] Que pasa se desviado por 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] Se desviado por 5, só ía perder díxitos.

512
00:35:10,790 --> 00:35:15,410
Inevitablemente, é o mesmo. Como, enteiros son só 32 bits

513
00:35:15,410 --> 00:35:20,750
por iso, se engadir dous realmente grandes enteiros, el simplemente non encaixa nun enteiro.

514
00:35:20,750 --> 00:35:23,660
Entón, é o mesmo aquí. Se cambiou por 5,

515
00:35:23,660 --> 00:35:25,650
teriamos só perder esta.

516
00:35:25,650 --> 00:35:28,820
E iso é o tipo de cousas que quero dicir con "máis ou menos",

517
00:35:28,820 --> 00:35:37,470
onde se cambiar moito, perde bits.

518
00:35:37,470 --> 00:35:39,830
>> Cambio dereito será o contrario,

519
00:35:39,830 --> 00:35:43,090
onde imos enfiar 0 de fóra da final,

520
00:35:43,090 --> 00:35:48,400
e para os nosos propósitos, enche 0 do da esquerda.

521
00:35:48,400 --> 00:35:52,910
Entón, a facer iso, estamos basicamente desfacer o que xa fixera.

522
00:35:52,910 --> 00:35:57,780
E vemos que os tres 0 na dereita acabaron caído,

523
00:35:57,780 --> 00:36:02,020
e nós ter empurrado o 1101 todo o camiño para a dereita.

524
00:36:02,020 --> 00:36:08,380
Isto fai 104 >> 3, que é, de forma eficaz, x / 2 ^ y.

525
00:36:08,380 --> 00:36:11,200
Entón, agora, aquí, é unha idea similar.

526
00:36:11,200 --> 00:36:18,720
Por que é só preto de x / 2 ^ y, e en realidade non x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
Porque se eu cambiara por 4, eu perdería a 1.

528
00:36:22,240 --> 00:36:25,950
Basicamente, o que pensar, só pensar en división enteira en xeral.

529
00:36:25,950 --> 00:36:31,070
Así, como 5/2 é 2. Non é 2.5.

530
00:36:31,070 --> 00:36:35,000
É a mesma idea aquí. Cando dividimos por 2,

531
00:36:35,000 --> 00:36:39,910
podemos perder anacos estraños ao longo do camiño.

532
00:36:39,910 --> 00:36:43,870
Entón agora - é isto para bit a bit. Isto é todo o que precisa saber.

533
00:36:43,870 --> 00:36:46,340
Teña en conta que os casos de uso que vimos en clase,

534
00:36:46,340 --> 00:36:49,340
como unha máscara de bits é útil para operadores bit a bit,

535
00:36:49,340 --> 00:36:53,220
ou usalos para máscara de bits.

536
00:36:53,220 --> 00:36:58,620
As letras maiúsculas e minúsculas, conversións é un exemplo moi prototipo.

537
00:36:58,620 --> 00:37:01,640
>> Ok, entón ataques de buffer overflow.

538
00:37:01,640 --> 00:37:05,110
Alguén recorda o que estaba mal con esta función?

539
00:37:05,110 --> 00:37:10,140
Lembra que declaramos un array de 12 bytes, 12 caracteres,

540
00:37:10,140 --> 00:37:18,510
e logo copiar a nosa memoria intermedia de 12 caracteres de todo o bar cadea.

541
00:37:18,510 --> 00:37:25,080
Entón, cal é o problema aquí?

542
00:37:25,080 --> 00:37:32,270
O número máxico 12 debe aparecer practicamente inmediatamente como - por que 12?

543
00:37:32,270 --> 00:37:35,050
E si bar pasa a ser máis de 12 caracteres?

544
00:37:35,050 --> 00:37:41,200
E si bar é millóns de personaxes?

545
00:37:41,200 --> 00:37:46,010
Aquí o importante é memcpy. Se a barra é suficiente,

546
00:37:46,010 --> 00:37:50,330
ela só vai completamente - 'c', 'c' non lle importa que tiña só 12 carácteres;

547
00:37:50,330 --> 00:37:53,280
'C' non lle importa que non pode caber moitos bytes.

548
00:37:53,280 --> 00:37:58,250
Ha substituír só completamente char, os 12 bytes que xa alocados para el,

549
00:37:58,250 --> 00:38:01,830
e todo pasado, na memoria que en realidade non pertencen a ese tapón

550
00:38:01,830 --> 00:38:06,520
co que o bar cadea é.

551
00:38:06,520 --> 00:38:09,780
Polo tanto, esta foi a imaxe que vimos en clase

552
00:38:09,780 --> 00:38:12,220
onde temos a nosa pila crecendo.

553
00:38:12,220 --> 00:38:16,040
Debe ser usado para estas imaxes ou familiarizado con eles de novo.

554
00:38:16,040 --> 00:38:21,260
Temos a nosa pila crecendo, enderezos de memoria comezan en 0 na parte superior

555
00:38:21,260 --> 00:38:26,270
e medrar ata gusto 4 millóns na parte inferior.

556
00:38:26,270 --> 00:38:28,820
Temos a nosa disposición 'c' nalgún lugar na memoria,

557
00:38:28,820 --> 00:38:32,260
entón temos a nosa punteiro para untar dereita por baixo,

558
00:38:32,260 --> 00:38:38,720
e entón temos este punteiro cadro gardadas no noso enderezo de retorno e pila da nosa rutina pai.

559
00:38:38,720 --> 00:38:40,800
Lembre que o enderezo de retorno é?

560
00:38:40,800 --> 00:38:45,360
É cando principal chama unha función foo, chama unha barra de funcións,

561
00:38:45,360 --> 00:38:48,100
inevitablemente, untar retorno.

562
00:38:48,100 --> 00:38:52,610
Entón, cando a barra de volta, eles precisan saber que vai voltar á foo que o chamou.

563
00:38:52,610 --> 00:39:01,360
Así, o enderezo de retorno é o enderezo da función que ten que volver para cando a función devolve.

564
00:39:01,360 --> 00:39:05,830
A razón pola que isto é importante para ataques de estourido de buffer é porque, cómodo,

565
00:39:05,830 --> 00:39:09,580
hackers quere cambiar o enderezo de retorno.

566
00:39:09,580 --> 00:39:14,950
No canto de volver a foo, eu vou volver a onde queira que o hacker queira que eu vaia volver.

567
00:39:14,950 --> 00:39:17,760
E, cómodo, onde o hacker miúdo quere volver a

568
00:39:17,760 --> 00:39:22,400
é o principio da memoria intermedia que tiña orixinalmente.

569
00:39:22,400 --> 00:39:26,170
Entón, teña en conta, de novo, Little Indian.

570
00:39:26,170 --> 00:39:28,490
O aparello é un exemplo dun sistema indio pequeno,

571
00:39:28,490 --> 00:39:34,140
así un número enteiro ou un punteiro é almacenado cos bytes invertidos.

572
00:39:34,140 --> 00:39:38,980
Entón, imos ver - é iso? É.

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

574
00:39:45,660 --> 00:39:48,250
Teña en conta que dos díxitos hexadecimais?

575
00:39:48,250 --> 00:39:50,640
Non inverter os díxitos hexadecimais en Little Indian,

576
00:39:50,640 --> 00:39:56,110
porque dous díxitos hexadecimais compoñen un único byte, e inverter os bytes.

577
00:39:56,110 --> 00:40:00,300
É por iso que non almacenan, como, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Nós almacenar, no seu lugar, cada par de dous díxitos, a partir da dereita.

579
00:40:07,520 --> 00:40:10,880
Este enderezo refírese ao enderezo do inicio

580
00:40:10,880 --> 00:40:15,190
da nosa memoria intermedia que realmente quería copiar, en primeiro lugar.

581
00:40:15,190 --> 00:40:19,230
A razón que é útil porque, o que se o atacante

582
00:40:19,230 --> 00:40:24,100
pasou, en vez de ter unha secuencia que era só

583
00:40:24,100 --> 00:40:27,060
unha secuencia de como inofensivo, o seu nome ou algo así,

584
00:40:27,060 --> 00:40:33,900
E si, ao contrario, esta secuencia foron só algunhas de código arbitrario

585
00:40:33,900 --> 00:40:38,610
que fixo todo o que quería facer?

586
00:40:38,610 --> 00:40:45,630
Así, eles poderían - Eu non podo pensar en ningún código legal.

587
00:40:45,630 --> 00:40:47,780
Podería ser calquera cousa, con todo. Calquera código desastroso.

588
00:40:47,780 --> 00:40:51,440
No caso de que quixesen, poderían simplemente facer algo en fallos segmentos, pero iso sería inútil.

589
00:40:51,440 --> 00:40:54,950
Eles adoitan facelo para invadir o seu sistema.

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

591
00:40:59,930 --> 00:41:04,800
É dicir, basicamente, getInt, getString, todas estas funcións que nós fornecen para ti.

592
00:41:04,800 --> 00:41:10,630
Polo tanto, temos de char cadea *, e esa é a abstracción que sorprendeu

593
00:41:10,630 --> 00:41:12,450
nalgún momento durante o semestre.

594
00:41:12,450 --> 00:41:18,220
Lembre que unha cadea é só un conxunto de caracteres.

595
00:41:18,220 --> 00:41:23,240
Entón, imos ver unha versión resumida do getString.

596
00:41:23,240 --> 00:41:25,920
Ten que mirar para atrás, el lembrar de como é realmente aplicado.

597
00:41:25,920 --> 00:41:30,950
Detalles importantes son, teña en conta que recibimos nun único carácter de cada vez

598
00:41:30,950 --> 00:41:34,570
de patrón en, que é como nós escribindo no teclado.

599
00:41:34,570 --> 00:41:37,890
Así, un único personaxe de cada vez, e se logramos moitos personaxes,

600
00:41:37,890 --> 00:41:40,580
por iso, se n + 1 é maior que a capacidade,

601
00:41:40,580 --> 00:41:44,140
entón necesitamos aumentar a capacidade do noso buffer.

602
00:41:44,140 --> 00:41:47,780
Entón, aquí estamos dobrando o tamaño do noso buffer.

603
00:41:47,780 --> 00:41:51,840
E iso segue a suceder, nós introducir o carácter na nosa memoria intermedia

604
00:41:51,840 --> 00:41:56,220
ata que recibamos unha nova liña ou fin de ficheiro ou calquera outra cousa,

605
00:41:56,220 --> 00:41:59,380
neste caso, estamos a facer coa corda e logo, o certo getString

606
00:41:59,380 --> 00:42:05,120
encolle a memoria, como se nós alocados moita memoria que vai volver e encoller un pouco.

607
00:42:05,120 --> 00:42:08,830
Entón, nós non mostran tanto, pero a idea principal é

608
00:42:08,830 --> 00:42:11,960
ten que ler nun único personaxe de cada vez.

609
00:42:11,960 --> 00:42:17,140
Non pode simplemente ler nunha cousa toda dunha vez,

610
00:42:17,140 --> 00:42:19,550
xa que o seu tapón é só dun certo tamaño.

611
00:42:19,550 --> 00:42:26,590
Entón, se a cadea que intenta introducir no búfer é moi grande, entón sería rebosar.

612
00:42:26,590 --> 00:42:28,940
Entón imos evitar isto por só lendo nun único carácter

613
00:42:28,940 --> 00:42:33,750
de cada vez e cada vez maior, sempre que necesites.

614
00:42:33,750 --> 00:42:40,270
Entón getInt e as outras funcións da biblioteca CS50 tenden a usar getString

615
00:42:40,270 --> 00:42:42,310
nas súas implementacións.

616
00:42:42,310 --> 00:42:45,370
Entón, eu destaquei as cousas importantes aquí.

617
00:42:45,370 --> 00:42:49,460
El chama getString para obter unha cadea.

618
00:42:49,460 --> 00:42:51,710
Se getString non puido volver á memoria,

619
00:42:51,710 --> 00:42:54,270
lembre que getString mallocs algo, entón sempre que chamar getString

620
00:42:54,270 --> 00:42:57,820
non debe (inintelixible) gratis esa secuencia que ten.

621
00:42:57,820 --> 00:43:02,870
Entón, aquí, se el non pode malloc algo, volvemos INT_MAX como só unha bandeira que,

622
00:43:02,870 --> 00:43:05,650
hey, nós non estabamos realmente capaz de obter un número enteiro.

623
00:43:05,650 --> 00:43:10,830
Debe ignorar o que eu voltar a vostede, ou

624
00:43:10,830 --> 00:43:15,540
non debe tratar isto como unha entrada válida.

625
00:43:15,540 --> 00:43:21,360
Por último, asumindo que tivo éxito, usamos sscanf con esa bandeira especial,

626
00:43:21,360 --> 00:43:23,820
o que significa, en primeiro lugar corresponder a un número enteiro,

627
00:43:23,820 --> 00:43:26,770
entón combinar ningún carácter tras ese enteiro.

628
00:43:26,770 --> 00:43:29,070
Entón, teña en conta que queremos igual a 1.

629
00:43:29,070 --> 00:43:32,940
Retorno Entón sscanf cantos xogos se fixo correctamente?

630
00:43:32,940 --> 00:43:37,010
El pode voltar 1 se combinaba con éxito un número enteiro,

631
00:43:37,010 --> 00:43:40,890
el pode voltar 0 se non corresponder a un número enteiro, e ha voltar 2

632
00:43:40,890 --> 00:43:45,920
se correspondese un número enteiro seguido por algún personaxe.

633
00:43:45,920 --> 00:43:49,780
Entón, teña en conta que tenta de novo se nós quedamos nada, pero 1.

634
00:43:49,780 --> 00:43:55,230
Polo tanto, se entrou 1, 2, 3, C, ou 1, 2, 3, X,

635
00:43:55,230 --> 00:43:57,400
logo, 1, 2, 3 que se almacenan no número enteiro,

636
00:43:57,400 --> 00:43:59,620
X que quedan almacenados no personaxe,

637
00:43:59,620 --> 00:44:06,410
sscanf volvería 2, e queremos tentar de novo, porque nós só queremos un enteiro.

638
00:44:06,410 --> 00:44:09,810
>> Golpe rapidamente a través de HTML, HTTP, CSS.

639
00:44:09,810 --> 00:44:15,340
HyperText Markup Language é a estrutura ea semántica web.

640
00:44:15,340 --> 00:44:19,960
Aquí está o exemplo de clase onde temos as etiquetas HTML.

641
00:44:19,960 --> 00:44:22,110
Temos as etiquetas de cabeza, marcas no corpo,

642
00:44:22,110 --> 00:44:27,770
temos exemplos de etiquetas baleiras onde nós realmente non teñen un comezo e preto tag,

643
00:44:27,770 --> 00:44:30,820
só temos ligazón e imaxe.

644
00:44:30,820 --> 00:44:38,480
Non hai tag de imaxe de peche; hai só unha única marca que realiza todo o que a etiqueta debe facer.

645
00:44:38,480 --> 00:44:41,950
A ligazón é un exemplo, imos ver como vincular a CSS,

646
00:44:41,950 --> 00:44:45,910
o guión é un exemplo de como chamar a un JavaScript externo.

647
00:44:45,910 --> 00:44:53,100
É moi sinxelo, e lembre, HTML non é unha linguaxe de programación.

648
00:44:53,100 --> 00:44:58,250
Aquí, recordo como definiría dunha ou polo menos o que isto faría?

649
00:44:58,250 --> 00:45:01,740
Esa forma ten unha acción e un método.

650
00:45:01,740 --> 00:45:06,210
Os métodos que só vai ver son GET e POST.

651
00:45:06,210 --> 00:45:09,040
Entón Get é a versión en que a cousa é colocado na URL.

652
00:45:09,040 --> 00:45:11,680
POST é onde non colócase na URL.

653
00:45:11,680 --> 00:45:18,520
Pola contra, todos os datos do formulario insírese máis oculto na solicitude HTTP.

654
00:45:18,520 --> 00:45:22,390
Entón, aquí, a acción define onde a solicitude HTTP vai.

655
00:45:22,390 --> 00:45:27,490
Onde vai é google.com / search.

656
00:45:27,490 --> 00:45:32,890
Método. Teña en conta que as diferenzas entre GET e POST,

657
00:45:32,890 --> 00:45:37,200
e, diga só como un exemplo, se quere marcar algo.

658
00:45:37,200 --> 00:45:40,660
Vostede non será capaz de marcar unha URL POST

659
00:45:40,660 --> 00:45:44,970
Porque os datos non son incluídos na URL.

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

661
00:45:49,790 --> 00:45:54,080
O Protocolo de Transferencia de Hipertexto, esperar que transferir

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

663
00:45:57,710 --> 00:46:00,170
Pero tamén traslada todas as imaxes que se atopa na web,

664
00:46:00,170 --> 00:46:05,400
todas as descargas que fai comezar como unha solicitude HTTP.

665
00:46:05,400 --> 00:46:10,350
Entón HTTP é só a linguaxe da World Wide Web

666
00:46:10,350 --> 00:46:15,610
E aquí hai que recoñecer que este tipo de unha solicitude HTTP.

667
00:46:15,610 --> 00:46:19,300
Aquí HTTP/1.1 no lado só di que é a versión

668
00:46:19,300 --> 00:46:21,570
do protocolo que está a usar.

669
00:46:21,570 --> 00:46:25,770
É practicamente sempre será HTTP/1.1, como vai ver.

670
00:46:25,770 --> 00:46:30,110
Entón vemos que iso era GET, a alternativa de ser POST, que se pode ver.

671
00:46:30,110 --> 00:46:40,790
E a URL que eu estaba tentando visitar foi www.google.com/search?q = blah, blah, blah.

672
00:46:40,790 --> 00:46:44,240
Entón lembre que este, o punto de interrogación q = bla bla bla,

673
00:46:44,240 --> 00:46:49,040
é o tipo de material que é enviado por un formulario.

674
00:46:49,040 --> 00:46:51,830
A resposta que podería volver a me sería algo coma isto.

675
00:46:51,830 --> 00:46:54,050
Unha vez máis, comezando co protocolo, que será iso,

676
00:46:54,050 --> 00:46:59,190
seguido polo código de estado. Aquí é 200 Aceptar.

677
00:46:59,190 --> 00:47:05,060
E, finalmente, a páxina web que realmente pedín será seguido.

678
00:47:05,060 --> 00:47:08,210
A posible código de estado que se pode ver, e ten que saber varios deles.

679
00:47:08,210 --> 00:47:12,770
200 OK, probablemente xa viu antes.

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

681
00:47:17,830 --> 00:47:22,140
xeralmente é se vai a un sitio web e algo está roto ou os seus accidentes de código PHP,

682
00:47:22,140 --> 00:47:24,930
mentres que no aparello, temos que gran caixa de laranxa

683
00:47:24,930 --> 00:47:27,830
que vén e di, como, algo está mal, este código non funciona

684
00:47:27,830 --> 00:47:30,380
ou iso é malo función.

685
00:47:30,380 --> 00:47:33,230
Normalmente sitios non queren que vostede sabe que as funcións son realmente malas,

686
00:47:33,230 --> 00:47:37,880
así, no canto van só darlle 500 Internal Server Errors.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP é unha capa baixo HTTP.

688
00:47:43,050 --> 00:47:47,550
Lembre que non hai Internet fóra da World Wide Web

689
00:47:47,550 --> 00:47:52,270
Como se xogar un xogo online que non pasa por HTTP,

690
00:47:52,270 --> 00:47:55,740
el está pasando por un distinto - aínda está a través da internet,

691
00:47:55,740 --> 00:47:58,900
pero el non usa o HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP é só un exemplo de protocolo construído sobre TCP / IP.

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

694
00:48:07,820 --> 00:48:11,500
Cada ordenador ten un enderezo IP, que son esas cousas de 4 díxitos

695
00:48:11,500 --> 00:48:16,510
como 192.168.2.1, ou o que, que tende a ser un lugar.

696
00:48:16,510 --> 00:48:23,390
Pero ese é o patrón dun enderezo IP.

697
00:48:23,390 --> 00:48:29,060
Así, o DNS, Domain Name Service,

698
00:48:29,060 --> 00:48:33,410
iso é o que se traduce cousas como google.com a un enderezo IP real.

699
00:48:33,410 --> 00:48:37,700
Entón, se escribir este enderezo IP nunha URL,

700
00:48:37,700 --> 00:48:40,850
que ía leva-lo a Google, pero tende a non lembrar desas cousas.

701
00:48:40,850 --> 00:48:45,470
Tende a lembrar google.com no seu lugar.

702
00:48:45,470 --> 00:48:51,560
A última cousa que temos é portos, onde esta é a parte TCP IP.

703
00:48:51,560 --> 00:48:54,880
TCP fai máis. Pense, como, ter o seu navegador en execución web.

704
00:48:54,880 --> 00:48:58,670
Poida que teña algún programa de correo-e está a ser executado;

705
00:48:58,670 --> 00:49:02,150
quizais ten algún outro programa que utiliza a Internet en funcionamento.

706
00:49:02,150 --> 00:49:05,090
Todos precisan de acceso a Internet,

707
00:49:05,090 --> 00:49:08,100
pero o ordenador só ten unha tarxeta Wi-Fi ou o que sexa.

708
00:49:08,100 --> 00:49:10,780
Así, os portos son a forma que nós somos capaces de dividir

709
00:49:10,780 --> 00:49:13,550
como estas aplicacións son capaces de utilizar a Internet.

710
00:49:13,550 --> 00:49:17,230
Cada aplicación obtén unha porta específica que poida escoitar,

711
00:49:17,230 --> 00:49:19,670
e, por defecto, HTTP utiliza o porto 80.

712
00:49:19,670 --> 00:49:22,410
Algúns servizos de correo-e usar 25.

713
00:49:22,410 --> 00:49:24,490
Os de baixa de número tenden a ser reservados.

714
00:49:24,490 --> 00:49:29,270
Vostede xeralmente son capaces de obter os con numeración máis alta para si mesmo.

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

716
00:49:32,010 --> 00:49:36,030
Páxinas web Nós estilo con CSS, non con HTML.

717
00:49:36,030 --> 00:49:38,440
Existen 3 lugares que pode poñer o seu CSS.

718
00:49:38,440 --> 00:49:46,300
Pode ser en liña, entre marcas de estilo, ou nun ficheiro separado e logo, completamente ligado dentro

719
00:49:46,300 --> 00:49:48,470
E aquí é só un exemplo de CSS.

720
00:49:48,470 --> 00:49:50,450
Debe recoñecer ese estándar,

721
00:49:50,450 --> 00:49:54,310
onde o primeiro exemplo é que estamos combinando a etiqueta corpo,

722
00:49:54,310 --> 00:49:56,680
e aquí estamos centrando a etiqueta body.

723
00:49:56,680 --> 00:50:00,420
O segundo exemplo, estamos combinando a cousa

724
00:50:00,420 --> 00:50:04,740
ID de rodapé, e estamos aplicando algúns estilos para iso.

725
00:50:04,740 --> 00:50:07,310
Teña en conta que o ID de rodapé de texto aliñan á esquerda,

726
00:50:07,310 --> 00:50:09,840
mentres aliñan texto corpo central.

727
00:50:09,840 --> 00:50:13,180
Rodapé está dentro do corpo.

728
00:50:13,180 --> 00:50:16,470
Será, no seu lugar, text-align esquerda, aínda que o corpo di centro text-align.

729
00:50:16,470 --> 00:50:18,880
Esta é toda a parte en cascada dela.

730
00:50:18,880 --> 00:50:22,110
Pode que - pode especificar estilos para o corpo,

731
00:50:22,110 --> 00:50:25,320
e despois as cousas no corpo que pode especificar estilos máis específicos,

732
00:50:25,320 --> 00:50:28,160
e as cousas funcionan como esperado.

733
00:50:28,160 --> 00:50:34,420
Especificadores CSS máis específicas teñen precedencia.

734
00:50:34,420 --> 00:50:46,140
Eu creo que é iso.

735
00:50:46,140 --> 00:50:49,260
>> [Alí Nahm] Hola a todos. Se eu puidese chamar a atención.

736
00:50:49,260 --> 00:50:53,990
Estou Alí e eu vou pasar por PHP e SQL moi rápido.

737
00:50:53,990 --> 00:51:00,310
Así, podemos comezar. PHP é curto para PHP: Hipertexto Preprocessor.

738
00:51:00,310 --> 00:51:03,730
E como todos vostedes deben saber, é unha linguaxe de script do lado do servidor,

739
00:51:03,730 --> 00:51:06,800
e usalo para o back-end de sitios web,

740
00:51:06,800 --> 00:51:12,540
e como fai unha morea de cálculos, a parte detrás escenas.

741
00:51:12,540 --> 00:51:17,510
Sintaxe. Non é como C, sorpresa, sorpresa.

742
00:51:17,510 --> 00:51:22,060
El sempre ten que comezar coa, se pode ver, o - eu non podo seguir adiante.

743
00:51:22,060 --> 00:51:31,340
Podes ver o que precisa os novos tipos de dispositivos e, a continuación, tamén precisa do? Php.

744
00:51:31,340 --> 00:51:35,780
Isto sempre é como ten que enmarcar o texto PHP, seu código PHP.

745
00:51:35,780 --> 00:51:39,180
Polo tanto, non pode ser igual a A, onde o tipo de poñelas en primeiro lugar.

746
00:51:39,180 --> 00:51:42,290
Debe cercar-lo sempre.

747
00:51:42,290 --> 00:51:47,610
E agora, a maior sintaxe é que todas as variables precisas para comezar co caracter $.

748
00:51:47,610 --> 00:51:49,490
Debe facelo cando está definíndose os, ten que facelo

749
00:51:49,490 --> 00:51:51,860
cando está referíndose a eles máis tarde.

750
00:51:51,860 --> 00:51:56,510
Sempre ten que US $. É o seu novo mellor amigo, moi bonito.

751
00:51:56,510 --> 00:52:01,690
Non - ao contrario de C, non poñer o tipo de tipo de variable que é.

752
00:52:01,690 --> 00:52:04,940
Entón, mentres ten que facer o $, non poñer, como,

753
00:52:04,940 --> 00:52:09,470
int x ou y corda, etc, etc.

754
00:52:09,470 --> 00:52:11,490
Entón, unha pequena diferenza.

755
00:52:11,490 --> 00:52:15,590
Como resultado disto, significa que o PHP é un tipo feblemente.

756
00:52:15,590 --> 00:52:19,310
PHP é unha linguaxe de tipo feblemente, e ten variables feblemente ingresaran.

757
00:52:19,310 --> 00:52:24,020
Noutras palabras, iso significa que pode cambiar entre os distintos tipos de tipos de variables.

758
00:52:24,020 --> 00:52:27,230
Pode almacenar o seu número 1 como un int,

759
00:52:27,230 --> 00:52:29,650
pode almacena-lo como unha cadea, e pode almacena-lo como un float,

760
00:52:29,650 --> 00:52:33,550
e todo o que vai ser o número 1.

761
00:52:33,550 --> 00:52:36,080
Aínda que estea almacenando o en diferentes formas,

762
00:52:36,080 --> 00:52:39,120
aínda é - os tipos de variables aínda están sostendo ao final.

763
00:52:39,120 --> 00:52:41,540
Entón, se ollar aquí, se lembrar de pset 7,

764
00:52:41,540 --> 00:52:43,500
moitos de vós probablemente tivo problemas con iso.

765
00:52:43,500 --> 00:52:47,280
Dous sinais iguais, tres signos de igual, 4 sinais igual.

766
00:52:47,280 --> 00:52:49,990
Ok, non hai catro signos de igual, pero hai 2 e 3.

767
00:52:49,990 --> 00:52:53,320
Podes usar dous signos de igual para comprobar os valores.

768
00:52:53,320 --> 00:52:55,830
Pode comprobar en todo tipo.

769
00:52:55,830 --> 00:52:58,770
Entón, se pode ver o primeiro exemplo,

770
00:52:58,770 --> 00:53:02,210
Teño num_int num_string ==.

771
00:53:02,210 --> 00:53:06,710
Polo tanto, a súa int e súa secuencia son ambos, tecnicamente, 1,

772
00:53:06,710 --> 00:53:10,790
pero son tipos diferentes. Pero para os dous iguais, aínda vou pasar.

773
00:53:10,790 --> 00:53:15,510
Con todo, para os tres iguais, verifica valor, así como os distintos tipos.

774
00:53:15,510 --> 00:53:18,760
Isto significa que non vai pasar nese segundo caso aquí,

775
00:53:18,760 --> 00:53:22,350
onde está a usar tres signos de igual no seu lugar.

776
00:53:22,350 --> 00:53:26,590
Entón, iso é unha gran diferenza que debe todo mostraron agora.

777
00:53:26,590 --> 00:53:31,570
>> Concatenación de cadea é outra cousa poderosa que pode usar en PHP.

778
00:53:31,570 --> 00:53:34,080
É basicamente esta a notación de punto a man,

779
00:53:34,080 --> 00:53:36,230
e é así que pode conectar cordas xuntos.

780
00:53:36,230 --> 00:53:40,800
Entón se ten gato e ten can, e quere poñer as dúas cordas xuntas,

781
00:53:40,800 --> 00:53:44,080
pode utilizar o período, e iso é tipo de como funciona.

782
00:53:44,080 --> 00:53:46,660
Tamén pode simplemente poñer-los á beira do outro,

783
00:53:46,660 --> 00:53:49,030
como podes ver aquí no exemplo de fondo,

784
00:53:49,030 --> 00:53:51,610
onde eu eco secuencia 1, corda espazo 2.

785
00:53:51,610 --> 00:53:56,930
PHP saberá para substituír-los como tal.

786
00:53:56,930 --> 00:53:59,780
Arrays. Agora, en PHP, hai dous tipos de matrices.

787
00:53:59,780 --> 00:54:03,180
Pode ter matrices regulares, e tamén pode ter arrays asociativos,

788
00:54:03,180 --> 00:54:06,040
e nós imos pasar por eles agora.

789
00:54:06,040 --> 00:54:08,280
Matrices regulares son só iso en C,

790
00:54:08,280 --> 00:54:11,240
e por iso ten índices que son numerados.

791
00:54:11,240 --> 00:54:13,160
Agora estamos indo só para crear un e poñer -

792
00:54:13,160 --> 00:54:15,500
entón é así que crear unha matriz baleira, entón imos

793
00:54:15,500 --> 00:54:17,310
posto no número de índice 0.

794
00:54:17,310 --> 00:54:19,200
Nós imos poñer o número 6, o valor 6.

795
00:54:19,200 --> 00:54:21,500
Pode velo na parte inferior aquí.

796
00:54:21,500 --> 00:54:24,240
Where 's - polo número de índice 1, imos poñer o número valor 4,

797
00:54:24,240 --> 00:54:26,720
e así se pode ver que hai un 6, hai un 4,

798
00:54:26,720 --> 00:54:29,160
e entón, como estamos imprimindo cousas,

799
00:54:29,160 --> 00:54:33,550
cando tentamos e imprimir o valor almacenado no número de índice 0,

800
00:54:33,550 --> 00:54:36,900
entón imos ver o valor 6 sendo impreso. Legal?

801
00:54:36,900 --> 00:54:40,160
Entón, iso é matrices regulares para ti.

802
00:54:40,160 --> 00:54:42,750
Outra forma que tamén pode engadir cousas para matrices regulares agora

803
00:54:42,750 --> 00:54:44,780
é que pode simplemente anexo-los ao final.

804
00:54:44,780 --> 00:54:47,240
Isto significa que non ten que especificar o índice específico.

805
00:54:47,240 --> 00:54:51,000
Pode ver o número e logo, entre corchetes non hai ningún contido especificado.

806
00:54:51,000 --> 00:54:56,270
E vai saber - PHP saberá só engadir lo ao final da lista, o seguinte lugar libre.

807
00:54:56,270 --> 00:54:59,190
Así pode ver o 1 alí, naquel 0 spot,

808
00:54:59,190 --> 00:55:02,690
o 2 foi a dereita alí no primeiro lugar.

809
00:55:02,690 --> 00:55:04,690
O 3 vai - se engade alí tamén.

810
00:55:04,690 --> 00:55:06,720
Entón, este tipo de ten sentido. Só está constantemente engadindo-lo,

811
00:55:06,720 --> 00:55:09,360
e entón, cando estamos mostrando o índice de número 1,

812
00:55:09,360 --> 00:55:13,080
ha imprimir o valor 2.

813
00:55:13,080 --> 00:55:16,800
>> Entón temos matrices que son arrays asociativos.

814
00:55:16,800 --> 00:55:19,370
As matrices de asociación, en vez de ter índices numéricos,

815
00:55:19,370 --> 00:55:23,630
o que fan é, eles teñen índices que están por cadea.

816
00:55:23,630 --> 00:55:25,670
Podes ver, no canto de - Eu me livrei de todos os índices numéricos,

817
00:55:25,670 --> 00:55:32,140
e agora é key1, key2, key3, e eles están entre comiñas para significar que están as cadeas.

818
00:55:32,140 --> 00:55:34,470
Así, podemos ter un exemplo diso.

819
00:55:34,470 --> 00:55:38,790
O exemplo diso é que temos o tf, e iso é o nome do índice.

820
00:55:38,790 --> 00:55:42,030
Imos poñer "Alí", como o seu nome, o índice, calorías inxeridas,

821
00:55:42,030 --> 00:55:47,640
podemos poñer un int esta vez no canto de unha cadea,

822
00:55:47,640 --> 00:55:52,240
e despois para os gustos de índice, podemos poñer unha matriz enteira dentro dela.

823
00:55:52,240 --> 00:55:55,490
Polo tanto, esta é unha especie de - é un concepto semellante á forma como tivemos

824
00:55:55,490 --> 00:55:58,930
índices con números, pero agora podemos cambiar os índices en torno a

825
00:55:58,930 --> 00:56:03,890
para telos como cadeas en vez.

826
00:56:03,890 --> 00:56:06,070
Tamén pode facelo, ademais de só facelo individualmente,

827
00:56:06,070 --> 00:56:09,400
pode facer todo nun só anaco. Así pode ver que tf deste array,

828
00:56:09,400 --> 00:56:13,350
e, entón, poñer-los todos nun conxunto xigante corchete.

829
00:56:13,350 --> 00:56:15,220
Así que pode acelerar as cousas.

830
00:56:15,220 --> 00:56:19,730
É máis que unha opción estilística que non.

831
00:56:19,730 --> 00:56:21,550
Temos tamén loops.

832
00:56:21,550 --> 00:56:26,020
En C temos lazos que traballan así.

833
00:56:26,020 --> 00:56:29,690
Tivemos a nosa matriz, e fomos de índices 0 ao final da lista,

834
00:56:29,690 --> 00:56:31,740
e nós imprimir lo de todo, non?

835
00:56:31,740 --> 00:56:33,880
Excepto o problema é que, para arrays asociativos,

836
00:56:33,880 --> 00:56:36,610
non necesariamente sabe quen índices numéricos

837
00:56:36,610 --> 00:56:39,610
porque agora temos os índices de cordas.

838
00:56:39,610 --> 00:56:44,800
Agora usamos loops foreach, que, unha vez máis, ten esperanza usados ​​en pset 7.

839
00:56:44,800 --> 00:56:48,930
Loops foreach só vai saber cada parte da lista.

840
00:56:48,930 --> 00:56:52,450
E el non ten que saber exactamente o índice numérico que ten.

841
00:56:52,450 --> 00:56:56,490
Entón tes a sintaxe foreach, polo que é foreach, se pon a matriz.

842
00:56:56,490 --> 00:57:00,430
Así, a miña matriz chámase pset, e despois como, a palabra como,

843
00:57:00,430 --> 00:57:04,530
e entón pon esta variable temporal lugar que vai empregar

844
00:57:04,530 --> 00:57:10,690
só para a cousa específica que vai soster o específico -

845
00:57:10,690 --> 00:57:14,770
unha instancia ou unha sección da matriz.

846
00:57:14,770 --> 00:57:18,350
Pset nun vai realizar 1, e entón quizais vai soster o número 6,

847
00:57:18,350 --> 00:57:20,410
e logo, que realizará o número 2.

848
00:57:20,410 --> 00:57:26,630
Pero está garantido para pasar por cada valor único que está na matriz.

849
00:57:26,630 --> 00:57:30,530
Funcións útiles que debes saber en PHP son o esixiren,

850
00:57:30,530 --> 00:57:35,880
de xeito que pasa a ser de que está incluíndo determinados arquivos, eco, saída, branco.

851
00:57:35,880 --> 00:57:40,490
Eu recomendo que ollar para pset 7 e mirar para esas funcións.

852
00:57:40,490 --> 00:57:42,810
Pode ter que saber quen,

853
00:57:42,810 --> 00:57:47,060
entón eu sempre sei que, exactamente, os que están a facer.

854
00:57:47,060 --> 00:57:50,080
>> E agora imos pasar por alcance moi rapidamente.

855
00:57:50,080 --> 00:57:53,490
En ámbito, o PHP é un tipo de cousa funky, ao contrario de C,

856
00:57:53,490 --> 00:57:56,170
e por iso estamos indo só para pasar por iso rapidamente.

857
00:57:56,170 --> 00:57:58,930
Entón, digamos que comezamos naquela frecha que temos alí.

858
00:57:58,930 --> 00:58:02,900
E imos comezar con $ i. Así, a variable 'i' será 0,

859
00:58:02,900 --> 00:58:06,730
e nós só estamos indo a perder imprimir lo na medida en que gran caixa branca por alí.

860
00:58:06,730 --> 00:58:09,220
Nós imos comezar con i0, e entón nós estamos indo a representala.

861
00:58:09,220 --> 00:58:12,670
Polo tanto, hai a 0.

862
00:58:12,670 --> 00:58:15,210
E entón nós estamos indo a incrementa-o co lazo para,

863
00:58:15,210 --> 00:58:17,810
e logo, que vai ser o valor de 1.

864
00:58:17,810 --> 00:58:20,070
Un deles é menor que 3, entón el vai pasar por iso para loop,

865
00:58:20,070 --> 00:58:23,230
e logo, imos velo impreso de novo.

866
00:58:23,230 --> 00:58:25,520
Estamos indo a incrementa-lo de novo a 2,

867
00:58:25,520 --> 00:58:29,860
e 2 é inferior a 3, polo que vou pasar o loop for, e só pode imprimir a 2.

868
00:58:29,860 --> 00:58:35,100
Axiña, vai notar que 3 non sexa inferior a 3, polo que imos saír do loop for.

869
00:58:35,100 --> 00:58:40,050
Entón, agora nós saíu, e entón nós estamos indo a ir en AFunction.

870
00:58:40,050 --> 00:58:45,010
Okay. Entón tes que ter en conta que esta variable que creamos,

871
00:58:45,010 --> 00:58:48,270
a variable 'i', non ten como ámbito localmente.

872
00:58:48,270 --> 00:58:50,280
Isto significa que non é lugar para o loop,

873
00:58:50,280 --> 00:58:58,060
e esta variable tamén se pode acceder e cambiar despois, e aínda vai ser eficaz.

874
00:58:58,060 --> 00:59:02,160
Entón, se vai para a función de agora, vai ver que nós tamén usan o 'i' variable,

875
00:59:02,160 --> 00:59:05,320
e imos incrementar 'i' + +.

876
00:59:05,320 --> 00:59:09,410
Vostede pensar que, nun primeiro momento, con base en C, que é unha copia do 'i' variable.

877
00:59:09,410 --> 00:59:12,830
É unha cousa totalmente diferente, o que é correcto.

878
00:59:12,830 --> 00:59:16,560
Entón, cando nós imprimir lo, imos imprimir 'i' + +, que vai imprimir de 4,

879
00:59:16,560 --> 00:59:19,640
e logo, imos - desculpe.

880
00:59:19,640 --> 00:59:22,030
Entón imos acabar fóra desa función,

881
00:59:22,030 --> 00:59:24,820
e nós estamos indo a estar onde a frecha é agora.

882
00:59:24,820 --> 00:59:29,190
Isto significa que, a continuación, con todo, aínda que a función cambiou o valor de 'i',

883
00:59:29,190 --> 00:59:32,620
non se alterou fóra da función,

884
00:59:32,620 --> 00:59:35,060
porque a función ten un ámbito separado.

885
00:59:35,060 --> 00:59:38,960
Isto significa que cando nós echo 'i', non cambiou no ámbito da función,

886
00:59:38,960 --> 00:59:43,660
e así, logo imos para imprimir 3 novo.

887
00:59:43,660 --> 00:59:47,520
Diferentes cousas sobre ámbito en PHP que en C.

888
00:59:47,520 --> 00:59:51,130
>> Agora en PHP e HTML.

889
00:59:51,130 --> 00:59:53,510
PHP é usada para facer as páxinas web dinámicas.

890
00:59:53,510 --> 00:59:58,660
É algo que fai cousas distintas.

891
00:59:58,660 --> 01:00:02,090
Temos que é distinto de HTML.

892
01:00:02,090 --> 01:00:05,230
Con HTML, que sempre só ten o mesmo estática, como o xeito no que Rob mostrou,

893
01:00:05,230 --> 01:00:09,370
mentres que o PHP, pode cambiar as cousas en base a quen é o usuario.

894
01:00:09,370 --> 01:00:11,830
Entón, se eu tivera tanto, eu, "Está dentro do sistema como -" e, a continuación, o nome,

895
01:00:11,830 --> 01:00:14,420
e podo cambiar o nome. Entón, agora o nome é José,

896
01:00:14,420 --> 01:00:18,880
e ten o "sobre min", pero entón eu tamén podo renomear a ter Tommy.

897
01:00:18,880 --> 01:00:21,700
E iso sería unha cousa diferente.

898
01:00:21,700 --> 01:00:23,840
Entón nós tamén podemos cambiar as cousas diferentes sobre el,

899
01:00:23,840 --> 01:00:27,070
e el vai amosar contido diferente baseado no nome.

900
01:00:27,070 --> 01:00:31,430
Entón PHP pode tipo de cambiar o que está a suceder no seu sitio.

901
01:00:31,430 --> 01:00:33,540
O mesmo aquí. Aínda así, teña en conta que teñen contido diferente,

902
01:00:33,540 --> 01:00:38,870
aínda que está tecnicamente aínda acceder a esta mesma páxina web na superficie.

903
01:00:38,870 --> 01:00:43,450
Xerando HTML. Hai 2 xeitos diferentes que pode facelo.

904
01:00:43,450 --> 01:00:48,980
Entón, nós imos pasar por iso agora. A primeira forma é, ten - si, moito.

905
01:00:48,980 --> 01:00:51,150
Entón acaba de ter o seu estándar para lazo en PHP,

906
01:00:51,150 --> 01:00:56,270
e entón ecoar en PHP e HTML echo fóra.

907
01:00:56,270 --> 01:00:58,720
Usando o que Rob lle mostrou de script HTML

908
01:00:58,720 --> 01:01:04,030
e logo a través da impresión PHP só imprimir lo á páxina web.

909
01:01:04,030 --> 01:01:09,520
O camiño alternativo é facelo como se separar o PHP e HTML.

910
01:01:09,520 --> 01:01:11,940
Así, pode ter unha liña de PHP que inicia o loop for,

911
01:01:11,940 --> 01:01:16,020
entón vostede pode ter a liña de HTML nunha cousa separada,

912
01:01:16,020 --> 01:01:19,700
e entón rematar o loop, unha vez máis, cun PHP.

913
01:01:19,700 --> 01:01:21,800
Entón, é unha especie de separa-lo para fóra.

914
01:01:21,800 --> 01:01:24,020
Na parte esquerda, pode que ten todo o -

915
01:01:24,020 --> 01:01:26,360
é só unha peza de PHP.

916
01:01:26,360 --> 01:01:28,510
Á dereita, podes ver que ten unha liña de PHP,

917
01:01:28,510 --> 01:01:32,540
ten unha liña de HTML, e ten unha liña de PHP de novo.

918
01:01:32,540 --> 01:01:36,870
Así, separándose o para fora o que están facendo.

919
01:01:36,870 --> 01:01:39,330
E vai ter en conta que de calquera forma, a calquera deles,

920
01:01:39,330 --> 01:01:41,980
aínda imprimir a imaxe, a imaxe, a imaxe,

921
01:01:41,980 --> 01:01:44,540
de xeito que o HTML aínda é impreso do mesmo xeito.

922
01:01:44,540 --> 01:01:49,870
E entón, aínda vai ver as 3 foto aparecen no seu sitio.

923
01:01:49,870 --> 01:01:52,820
Polo tanto, é de 2 xeitos diferentes de facer o mesmo.

924
01:01:52,820 --> 01:01:55,060
>> Agora temos formas e solicitudes. Como Rob mostrou ti,

925
01:01:55,060 --> 01:01:59,400
hai formas de HTML, e imos só brisa a través deste.

926
01:01:59,400 --> 01:02:02,040
Ten unha acción e ten un método, ea súa acción

927
01:02:02,040 --> 01:02:04,350
tipo de mostra onde está indo para envialo, eo método é se

928
01:02:04,350 --> 01:02:06,960
el será un get ou un POST.

929
01:02:06,960 --> 01:02:11,220
E unha solicitude GET, como dixo Rob, significa que está indo a poñer-lo nunha forma

930
01:02:11,220 --> 01:02:15,760
e vai ve-lo como un URL, mentres unha solicitude POST non vai ver nunha URL.

931
01:02:15,760 --> 01:02:17,840
Entón, unha pequena diferenza.

932
01:02:17,840 --> 01:02:19,950
Con todo, unha cousa que é unha cousa semellante

933
01:02:19,950 --> 01:02:22,560
é que POST e GET son igualmente inseguro.

934
01:02:22,560 --> 01:02:26,430
Así, pode pensar que, só porque non velo na URL,

935
01:02:26,430 --> 01:02:28,790
isto significa que o post é máis seguro,

936
01:02:28,790 --> 01:02:34,420
pero aínda pode velo nos seus cookies na información que está enviando.

937
01:02:34,420 --> 01:02:38,260
Entón, non creo que cerca dun ou doutro.

938
01:02:38,260 --> 01:02:42,160
Outra cousa a notar é que tamén ten variables de sección.

939
01:02:42,160 --> 01:02:45,850
Vostedes utilizaron esta en pset 7 para obter a súa información de identificación de usuario.

940
01:02:45,850 --> 01:02:48,550
O que pasou foi que pode usar esa matriz asociativa,

941
01:02:48,550 --> 01:02:53,310
o $ _SESSION, e entón é capaz de acceder cousas distintas

942
01:02:53,310 --> 01:02:57,720
e almacenar cousas distintas a través das páxinas.

943
01:02:57,720 --> 01:03:00,750
>> A última cousa é que temos SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
e esta é unha linguaxe de programación para xestionar bases de datos.

945
01:03:04,360 --> 01:03:08,220
O que, exactamente, son bases de datos? Son coleccións de táboas,

946
01:03:08,220 --> 01:03:10,630
e cada táboa pode ter tipos semellantes de obxectos.

947
01:03:10,630 --> 01:03:14,990
Entón tivemos unha mesa de usuarios no seu pset finanzas.

948
01:03:14,990 --> 01:03:20,610
E por que son útiles? Porque é unha forma de almacenar permanentemente a información.

949
01:03:20,610 --> 01:03:22,840
É un xeito de rastrexar cousas e administrar as cousas

950
01:03:22,840 --> 01:03:25,890
e realmente velo en diferentes páxinas e manter o control.

951
01:03:25,890 --> 01:03:29,930
Mentres que se só almacena-lo nun momento que inmediato

952
01:03:29,930 --> 01:03:33,720
e usalo máis tarde, non será capaz de acceder calquera cousa que salvo.

953
01:03:33,720 --> 01:03:37,660
Temos 4 cousas importantes que utilizamos para comandos SQL.

954
01:03:37,660 --> 01:03:40,190
Temos select, insert, delete e update.

955
01:03:40,190 --> 01:03:42,880
Esas son realmente importante para vostedes para saber para o quiz.

956
01:03:42,880 --> 01:03:45,990
>> Imos rapidamente sobre escolla agora.

957
01:03:45,990 --> 01:03:48,540
Basicamente, está escollendo liñas de unha base de datos.

958
01:03:48,540 --> 01:03:52,400
Entón, se ten, así aquí -

959
01:03:52,400 --> 01:03:56,740
temos estas dúas cousas distintas, e queremos seleccionar da táboa de clases

960
01:03:56,740 --> 01:04:01,480
onde incrible - onde na columna incrible o valor é 1.

961
01:04:01,480 --> 01:04:04,460
Así pode ver aquí, temos estas dúas cousas do nome da clase,

962
01:04:04,460 --> 01:04:08,490
CS50 e Stat110, e temos os IDs de clase eo slogan.

963
01:04:08,490 --> 01:04:13,150
Por iso, queremos seleccionar toda esta información.

964
01:04:13,150 --> 01:04:17,480
Entón podes ver aquí que é unha especie de escoller desta columna incrible,

965
01:04:17,480 --> 01:04:25,170
onde todas as cousas son un, e el ten a clase ID, nome da clase e slogan que pode escoller.

966
01:04:25,170 --> 01:04:28,100
Como exactamente facer iso no código? Tes que usar PHP.

967
01:04:28,100 --> 01:04:33,830
Entón, este é o tipo de como PHP e SQL son relacionados uns ós outros.

968
01:04:33,830 --> 01:04:38,130
Agora temos o noso código, e imos usar a nosa función de consulta

969
01:04:38,130 --> 01:04:41,370
como fixemos no pset 7, e nós estamos indo para executar a consulta SQL.

970
01:04:41,370 --> 01:04:43,870
Entón nós imos ter -

971
01:04:43,870 --> 01:04:46,280
a xente sempre ten que comprobar que o triple igual de liña se falsa.

972
01:04:46,280 --> 01:04:49,010
Entón, de novo, quere comprobar o tipo e valor,

973
01:04:49,010 --> 01:04:53,880
e logo, se non funciona, entón quere desculparse, como de costume, como fixemos no pset 7.

974
01:04:53,880 --> 01:04:55,870
En caso contrario, quere percorrer todo con aqueles accesibles

975
01:04:55,870 --> 01:04:59,410
foreach loop que só pasou.

976
01:04:59,410 --> 01:05:01,280
Agora que estamos loop e conseguimos gañar,

977
01:05:01,280 --> 01:05:05,080
imos supor que a nosa consulta pasou, agora temos o noso loop foreach.

978
01:05:05,080 --> 01:05:11,050
E a primeira liña ten, entón aquí está a liña, aquí, é casetonado.

979
01:05:11,050 --> 01:05:14,010
Vai imprimir toda a información que chega.

980
01:05:14,010 --> 01:05:18,070
Entón, que vai imprimir na parte inferior "Wanna Saber HTML?"

981
01:05:18,070 --> 01:05:23,370
Entón está indo a ir á seguinte liña, xa está concluído o primeiro ciclo for,

982
01:05:23,370 --> 01:05:26,510
e así, logo que vai imprimir a segunda liña do mesmo,

983
01:05:26,510 --> 01:05:32,120
que será STAT110, Buscar todos os momentos.

984
01:05:32,120 --> 01:05:34,290
>> Unha última cousa é sobre as vulnerabilidades de SQL.

985
01:05:34,290 --> 01:05:37,300
Sei que David tocou neste un pouco na clase.

986
01:05:37,300 --> 01:05:40,730
Podes ler máis tarde. É moi divertido.

987
01:05:40,730 --> 01:05:45,320
SQL Injection é un tipo de cousa complicada.

988
01:05:45,320 --> 01:05:49,890
Digamos que se ater só estas variables á dereita na súa consulta,

989
01:05:49,890 --> 01:05:52,290
como podes ver nesta primeira liña.

990
01:05:52,290 --> 01:05:54,520
Así, parece ben, non? Está só poñendo o seu nome de usuario

991
01:05:54,520 --> 01:05:58,820
e contrasinal para a consulta SQL, e quere envialo fóra e conseguir todo o que está na súa táboa de datos.

992
01:05:58,820 --> 01:06:01,450
Isto parece moi sinxelo. Entón, digamos que alguén pon en,

993
01:06:01,450 --> 01:06:04,910
para o contrasinal, este ou texto aquí -

994
01:06:04,910 --> 01:06:06,780
realmente debe ser na caixa vermella.

995
01:06:06,780 --> 01:06:11,920
Entón, imos dicir que eles puxeron esa contrasinal - que é o que eles entran.

996
01:06:11,920 --> 01:06:16,520
Entón, eles están poñendo ou "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Unha especie de contrasinal boba de ter.

998
01:06:20,880 --> 01:06:25,070
Agora imos substitúe-lo, e vai notar que nesa pesquisa agora,

999
01:06:25,070 --> 01:06:29,090
avalía para sempre certo, porque vai ter en conta que

1000
01:06:29,090 --> 01:06:32,240
podes pesquisa seleccionar toda esta información

1001
01:06:32,240 --> 01:06:35,420
ou pode só ter 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
De xeito que sempre vai avaliar a true.

1003
01:06:41,030 --> 01:06:46,610
Iso non vai realmente funciona, porque iso significa que o hacker pode invadir o seu sistema.

1004
01:06:46,610 --> 01:06:49,300
A solución para iso é que ten que empregar o sistema de DOP,

1005
01:06:49,300 --> 01:06:51,360
o que significa que ten que empregar puntos de interrogación,

1006
01:06:51,360 --> 01:06:53,350
que é o que vostedes usan na pset 7,

1007
01:06:53,350 --> 01:06:57,620
onde está indo para usar un punto de interrogación no lugar de onde quere poñer algo,

1008
01:06:57,620 --> 01:07:01,430
e entón vai ter unha coma, e entón vai ter despois,

1009
01:07:01,430 --> 01:07:07,610
despois da súa secuencia, as distintas variables que quere substituír o seu punto de interrogação.

1010
01:07:07,610 --> 01:07:10,330
Entón, vai notar que agora eu teño eses puntos de interrogación vermellos.

1011
01:07:10,330 --> 01:07:15,420
Entón eu coloque as variables tras miñas cordas, entón eu sei que substitúe-los nesa orde despois.

1012
01:07:15,420 --> 01:07:18,470
Isto pode estar seguro de que, se alguén fai isto así,

1013
01:07:18,470 --> 01:07:24,050
e eles teñen o ou 1 = 1 situación, que debería asegurarse de que,

1014
01:07:24,050 --> 01:07:30,490
ao final de volta, asegúrese de que non vai realmente romper a pesquisa en SQL.

1015
01:07:30,490 --> 01:07:33,660
Ok, entón iso é moi bonito iso, un turbillón de PHP e SQL.

1016
01:07:33,660 --> 01:07:41,520
Boa sorte para todos vostedes, e agora para Oregon

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] todos Okay. Tempo para percorrer algunhas JavaScript

1018
01:07:44,270 --> 01:07:48,840
e algunhas outras cousas moi rapidamente, entón non prendelo lo esta noite.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Si JavaScript é unha especie de cousa legal, presuntamente.

1020
01:07:56,930 --> 01:07:59,090
As cousas que realmente precisa saber sobre Javascript, é máis ou menos como

1021
01:07:59,090 --> 01:08:03,810
a fin do lado do cliente do que a súa aplicación web estará facendo.

1022
01:08:03,810 --> 01:08:08,280
Hai algunhas cousas que simplemente non queren coidar de todo o tempo do lado do servidor.

1023
01:08:08,280 --> 01:08:12,880
Todas as pequenas interaccións, destacando unha cousa, facer algo desaparecer.

1024
01:08:12,880 --> 01:08:15,340
Realmente non quero ter que falar co seu servidor de todo o tempo para iso.

1025
01:08:15,340 --> 01:08:18,069
E algúns que nin sequera se pode facer no lado do servidor.

1026
01:08:18,069 --> 01:08:21,899
É por iso que necesitamos algo como JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Cousas legais sobre JavaScript: El é ingresaran de forma dinámica.

1028
01:08:24,359 --> 01:08:27,149
O que isto significa que o seu programa non precisa saber

1029
01:08:27,149 --> 01:08:30,970
o que, exactamente, as variables son cando escribilo.

1030
01:08:30,970 --> 01:08:34,510
Vai só unha especie de descubrir como está correndo.

1031
01:08:34,510 --> 01:08:37,520
Outras cousas que son legais sobre iso: É unha linguaxe de bosquexo,

1032
01:08:37,520 --> 01:08:41,359
o que significa que a sintaxe é semellante a C e PHP.

1033
01:08:41,359 --> 01:08:47,050
Non ten que facer moito retraballados cando está a aprender JavaScript.

1034
01:08:47,050 --> 01:08:49,180
Aquí temos un pouco de JavaScript.

1035
01:08:49,180 --> 01:08:52,560
Unha cousa interesante aquí é que, se ollar para el,

1036
01:08:52,560 --> 01:08:56,330
temos un pouco de JavaScript alí na marca de cabeza.

1037
01:08:56,330 --> 01:08:59,479
Que é, basicamente, só incluír un arquivo JavaScript.

1038
01:08:59,479 --> 01:09:02,260
Esta é unha maneira que pode incluír JavaScript no seu programa.

1039
01:09:02,260 --> 01:09:06,910
A continuación, o segundo pouco é realmente algunha JavaScript liña,

1040
01:09:06,910 --> 01:09:10,790
moi semellante a un estilo en liña co CSS,

1041
01:09:10,790 --> 01:09:16,180
e está só escribindo algúns códigos moi rápido alí.

1042
01:09:16,180 --> 01:09:18,120
JavaScript ten arrays.

1043
01:09:18,120 --> 01:09:20,850
Só outra forma de manter os datos ao redor, moi útil.

1044
01:09:20,850 --> 01:09:25,180
Moi agradable e doado de sintaxe.

1045
01:09:25,180 --> 01:09:29,870
Podes usar corchetes para acceder todo e manter todo xunto.

1046
01:09:29,870 --> 01:09:35,020
Nada moi complexo.

1047
01:09:35,020 --> 01:09:38,630
O legal sobre Javascript e linguaxes de script en xeral

1048
01:09:38,630 --> 01:09:40,920
é que non se preocupe con tamaños de matriz.

1049
01:09:40,920 --> 01:09:43,880
Pode só usar array.length e manter o control do mesmo,

1050
01:09:43,880 --> 01:09:46,960
e tamén a matriz pode crecer ou encoller como precisa del.

1051
01:09:46,960 --> 01:09:49,279
Así, non necesita nin se preocupar de calquera tipo de,

1052
01:09:49,279 --> 01:09:57,050
Oh non, eu teño reservar máis cousas, ou algo así.

1053
01:09:57,050 --> 01:10:00,090
>> O legal aquí é que Javascript ten algo chamado obxectos.

1054
01:10:00,090 --> 01:10:04,800
É unha linguaxe orientada a obxecto, entón o que ten é, esencialmente,

1055
01:10:04,800 --> 01:10:10,100
un xeito de ti para agrupar datos en conxunto, algo semellante a unha estrutura,

1056
01:10:10,100 --> 01:10:17,280
pero pode acceder a ela como unha estrutura ou nunha sintaxe de array asociativo.

1057
01:10:17,280 --> 01:10:22,520
É moi sinxelo e que se pode facer con iso é agrupar datos xuntos

1058
01:10:22,520 --> 01:10:24,810
se ten unha morea de datos que está relacionado.

1059
01:10:24,810 --> 01:10:26,850
Por todo o que precisa para describir un coche,

1060
01:10:26,850 --> 01:10:29,050
non precisa telo en unha morea de diferentes lugares.

1061
01:10:29,050 --> 01:10:35,300
Pode simplemente poñer-lo nun obxecto en JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Como probablemente sabe, a iteración é unha desas tarefas tediosas.

1063
01:10:39,090 --> 01:10:43,810
Só fai iso a través dunha outra vez. Debe falar con todos os obxectos no coche,

1064
01:10:43,810 --> 01:10:47,340
ou ten que pasar por cada elemento nunha lista ou algo parecido.

1065
01:10:47,340 --> 01:10:51,770
Entón ten JavaScript, semellante ao PHP, unha sintaxe foreach.

1066
01:10:51,770 --> 01:10:54,590
Neste caso, é un no loop.

1067
01:10:54,590 --> 01:10:57,300
Quere usar isto só en obxectos.

1068
01:10:57,300 --> 01:11:01,030
Hai algúns problemas que se producen se usa isto en matrices.

1069
01:11:01,030 --> 01:11:03,750
De modo xeral, é unha desas cousas que, con todo, que é moi útil,

1070
01:11:03,750 --> 01:11:06,590
porque elimina unha chea de sobrecarga

1071
01:11:06,590 --> 01:11:10,270
porque non ten que tirar todo ao seu obxecto por si mesmo.

1072
01:11:10,270 --> 01:11:12,300
Non ten que se lembrar de todos os nomes clave.

1073
01:11:12,300 --> 01:11:18,270
Só tipo de levalos de volta nesta sintaxe.

1074
01:11:18,270 --> 01:11:21,500
Neste, por, só quere recordar

1075
01:11:21,500 --> 01:11:27,180
que está a recibir de volta todas as claves, dun xeito moi semellante ao de hash de táboa.

1076
01:11:27,180 --> 01:11:30,880
Se se lembrar de que, cando ía poñer nunha cadea pode aproveitar algo

1077
01:11:30,880 --> 01:11:33,840
que ten un valor asociado con el.

1078
01:11:33,840 --> 01:11:36,360
O que podes facer con isto é que pode dicir, todo ben,

1079
01:11:36,360 --> 01:11:42,120
Engada nun coche, e eu chamei-lle un Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Entón pode pór na cadea de Ferrari de novo máis tarde, e pode aproveitar iso.

1081
01:11:45,290 --> 01:11:50,000
E pode facelo en un loop, co o loop.

1082
01:11:50,000 --> 01:11:53,320
Entón, só máis sobre obxectos. A principal cousa dende esta hai que lembrar

1083
01:11:53,320 --> 01:12:00,340
é que pode utilizar o obxecto struct como sintaxe en calquera momento con estes,

1084
01:12:00,340 --> 01:12:04,590
excepto se o que vai usar como unha cadea non é un nome de variable válida.

1085
01:12:04,590 --> 01:12:07,650
Entón, se ollar para iso aí, temos clave con espazos.

1086
01:12:07,650 --> 01:12:12,500
Ben, se fose para poñer object.key, espazo, con, espazo, espazos,

1087
01:12:12,500 --> 01:12:15,320
que simplemente non tería sentido sintaticamente.

1088
01:12:15,320 --> 01:12:22,730
Así, só se pode facelo con este tipo de sintaxe soporte.

1089
01:12:22,730 --> 01:12:26,520
>> Ademais, JavaScript é moi baixo-wise para PHP.

1090
01:12:26,520 --> 01:12:29,050
Ten dúas formas de abordar ámbito.

1091
01:12:29,050 --> 01:12:31,960
Non pode ter o var diante dunha variable,

1092
01:12:31,960 --> 01:12:34,060
e iso só significa que este é global.

1093
01:12:34,060 --> 01:12:37,050
Pode velo de calquera lugar. Mesmo se pór isto nunha instrución if,

1094
01:12:37,050 --> 01:12:42,430
en calquera outro lugar no seu código despois dese punto, podería ver esta variable.

1095
01:12:42,430 --> 01:12:46,730
Outra cousa, con todo, é a var, está limitada a calquera función que está dentro

1096
01:12:46,730 --> 01:12:48,870
Se non está nunha función, ben, é global.

1097
01:12:48,870 --> 01:12:53,900
Pero se está nunha función é só visible dentro desa función.

1098
01:12:53,900 --> 01:12:56,420
Eu non teño un exemplo, pero, si. É unha desas cousas onde

1099
01:12:56,420 --> 01:12:59,900
pode xestionar o que as variables que quere ser global,

1100
01:12:59,900 --> 01:13:03,810
que as variables que quere ser local, pero ten que ter coidado con iso,

1101
01:13:03,810 --> 01:13:06,890
porque non ten o tipo de control de gran fino que fai en C,

1102
01:13:06,890 --> 01:13:15,820
onde se algo é declarado en un loop for, só pode ir nese loop for.

1103
01:13:15,820 --> 01:13:18,790
O único que realmente se preocupan o uso de JavaScript é a manipulación de páxinas web, non?

1104
01:13:18,790 --> 01:13:21,800
Quero dicir, é por iso que estamos facendo isto.

1105
01:13:21,800 --> 01:13:23,840
>> Para iso, usan algo chamado DOM.

1106
01:13:23,840 --> 01:13:25,850
O Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
Basicamente o que fai é que leva toda a súa HTML

1108
01:13:29,430 --> 01:13:34,110
e modelos para fóra en unha morea de obxectos que son aniñados uns dentro dos outros.

1109
01:13:34,110 --> 01:13:37,080
Comeza con algo así.

1110
01:13:37,080 --> 01:13:44,770
Ten, por certo, para min, unha morea de código alí fóra, que é unha especie de -

1111
01:13:44,770 --> 01:13:46,640
Vostede podería pensar que sería moi difícil de manipular,

1112
01:13:46,640 --> 01:13:48,700
porque estaría analizando a través de unha chea de texto

1113
01:13:48,700 --> 01:13:52,080
e ter a peza á parte as cousas. E se non foi formatado correctamente?

1114
01:13:52,080 --> 01:13:54,880
Cousas malas acontecerían.

1115
01:13:54,880 --> 01:13:58,140
Entón JavaScript coida diso para ti, e terá unha estrutura de datos bo,

1116
01:13:58,140 --> 01:14:01,390
como a que á miña esquerda, onde só ten un documento,

1117
01:14:01,390 --> 01:14:03,530
e dentro de que ten algo chamado HTML,

1118
01:14:03,530 --> 01:14:05,600
e dentro de que ten unha cabeza e un corpo,

1119
01:14:05,600 --> 01:14:08,420
e dentro desta cabeza que ten un título, etc, etc, etc.

1120
01:14:08,420 --> 01:14:11,810
Isto simplifica o manexo dunha páxina web para que sexa xusto,

1121
01:14:11,810 --> 01:14:14,190
Oh, eu só quero falar con ese obxecto.

1122
01:14:14,190 --> 01:14:21,340
Especie de unha forma moi semellante lle falaría a outro obxecto que fixo a si mesmo.

1123
01:14:21,340 --> 01:14:25,980
Como dixen, todo o DOM é o obxecto de documento.

1124
01:14:25,980 --> 01:14:29,290
Ou é só un lugar e entón pode ir dentro del para atopar as cousas,

1125
01:14:29,290 --> 01:14:33,880
e pode facelo - este é o vello estilo de facelo, alí encima,

1126
01:14:33,880 --> 01:14:38,130
onde fai document.getElementById, e, a continuación, o nome,

1127
01:14:38,130 --> 01:14:42,420
e como probablemente pode dicir, isto queda moi pesado despois dun tempo.

1128
01:14:42,420 --> 01:14:44,480
Entón probablemente non quere facelo. É por iso que temos

1129
01:14:44,480 --> 01:14:48,760
a próxima cousa que nós imos falar sobre iso máis tarde.

1130
01:14:48,760 --> 01:14:52,510
O importante aquí é que, todo ben, ten todos estes elementos, non?

1131
01:14:52,510 --> 01:14:56,400
Entón quizais eu poida cambiar a cor de algo cando a páxina é cargada.

1132
01:14:56,400 --> 01:14:58,380
Entón o que? E se o meu usuario fai clic en algo?

1133
01:14:58,380 --> 01:15:00,540
Eu quero que faga algo interesante cando click algo.

1134
01:15:00,540 --> 01:15:02,600
É por iso que temos eventos.

1135
01:15:02,600 --> 01:15:05,330
Pode basicamente atopar calquera elemento no seu DOM,

1136
01:15:05,330 --> 01:15:08,560
e despois dicir, hey. Cando este leva ou alguén fai clic nel,

1137
01:15:08,560 --> 01:15:11,410
ou cando do rato sobre el, facer algo con el.

1138
01:15:11,410 --> 01:15:15,330
E o que ten é, ten funcións que lidan con isto para vostede.

1139
01:15:15,330 --> 01:15:17,980
Estas funcións son manipuladores de eventos.

1140
01:15:17,980 --> 01:15:20,440
Que eles - que é só un xeito elegante de dicir,

1141
01:15:20,440 --> 01:15:23,500
esta función só é executada cando o evento ocorre.

1142
01:15:23,500 --> 01:15:28,070
Entón, el trata sobre o evento que ocorre.

1143
01:15:28,070 --> 01:15:30,810
Isto é como pór para fóra un manipulador de eventos.

1144
01:15:30,810 --> 01:15:34,750
Teño algunha tecla, e cando fai clic nel, explota.

1145
01:15:34,750 --> 01:15:40,560
Polo tanto, non fai clic no botón.

1146
01:15:40,560 --> 01:15:42,910
Esta é unha forma de abordalo, non?

1147
01:15:42,910 --> 01:15:46,430
Ten unha marca de botón e preme en que ten unha secuencia que di:

1148
01:15:46,430 --> 01:15:50,460
Oh, a propósito, eu fago esa cousa estourando para min.

1149
01:15:50,460 --> 01:15:53,990
Se non, é como un botón estándar, que acaba de facer.

1150
01:15:53,990 --> 01:15:56,550
Tamén pode facelo doutra forma,

1151
01:15:56,550 --> 01:16:02,770
agarrando o elemento DOM, pero imos gardar iso despois falamos jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: É unha biblioteca que é cross-browser.

1153
01:16:07,580 --> 01:16:09,580
Podes usalo en case calquera cousa.

1154
01:16:09,580 --> 01:16:12,090
E iso só lle dá unha morea de ferramentas para traballar.

1155
01:16:12,090 --> 01:16:15,850
Porque JavaScript, mentres poderoso, non ten todas as ferramentas que precisa

1156
01:16:15,850 --> 01:16:20,550
fóra da caixa para realmente afrontar unha aplicación web que pode querer facer.

1157
01:16:20,550 --> 01:16:24,650
Así, el simplifica unha morea de cousas, dálle unha morea de funcións

1158
01:16:24,650 --> 01:16:28,760
fóra da caixa que normalmente ten que escribir mesmo, unha e outra e outra vez.

1159
01:16:28,760 --> 01:16:31,600
E só fai as cousas moi sinxelo.

1160
01:16:31,600 --> 01:16:35,780
Tamén ten selectores, que permiten que tirar todos eses elementos

1161
01:16:35,780 --> 01:16:42,800
de seu DOM moito máis simple, en vez de ter que usar esas chamadas de función moi longos.

1162
01:16:42,800 --> 01:16:46,630
Máis información sobre estes selectores. Ten, alí enriba ten, digamos

1163
01:16:46,630 --> 01:16:49,800
Eu quero comezar un elemento con identificador "rock".

1164
01:16:49,800 --> 01:16:56,450
Ben, en jQuery, que é de só US $ e logo, unha secuencia que teña un quilo, e, a continuación, "rock".

1165
01:16:56,450 --> 01:17:01,960
É moi sinxelo e moito máis rápido que a forma tradicional de Javascript resolución deste problema.

1166
01:17:01,960 --> 01:17:06,120
E ten cousas semellantes para as clases e tipos de elementos.

1167
01:17:06,120 --> 01:17:08,140
jQuery é - un dos recursos interesantes é que pode clasificar de comprimir

1168
01:17:08,140 --> 01:17:14,350
as súas dúbidas sobre a súa DOM moi, moi rápido.

1169
01:17:14,350 --> 01:17:18,980
Agora estamos de volta para o tratamento de eventos, e iso é como lidaria con un evento en jQuery.

1170
01:17:18,980 --> 01:17:23,090
Entón, o que imos aquí é que estamos dicindo, todo ben. Eu teño unha etiqueta script, non?

1171
01:17:23,090 --> 01:17:25,400
Entón, eu teño esa liña JavaScript.

1172
01:17:25,400 --> 01:17:27,750
O que imos facer é o que vai dicir, todo ben.

1173
01:17:27,750 --> 01:17:30,860
Cando o documento estea listo, o que significa que o documento foi cargado,

1174
01:17:30,860 --> 01:17:34,660
estamos indo a ir a esta función, e imos dicir, todo ben,

1175
01:17:34,660 --> 01:17:37,060
esta función está realmente facendo outra cousa.

1176
01:17:37,060 --> 01:17:42,320
É basicamente dicindo, todo ben, mo elemento co ID "myid".

1177
01:17:42,320 --> 01:17:47,960
E, a continuación, dar a este un manipulador función que se executa cando fai clic sobre el.

1178
01:17:47,960 --> 01:17:49,820
Basicamente o que isto significa, di, todo ben.

1179
01:17:49,820 --> 01:17:52,630
A páxina é cargada, polo que estou indo a dentro, atopar este elemento,

1180
01:17:52,630 --> 01:17:56,420
darlle ese manipulador de eventos, e que basicamente define a súa páxina para ti.

1181
01:17:56,420 --> 01:18:00,520
E é así que quere pensar sobre a manipulación de eventos.

1182
01:18:00,520 --> 01:18:06,310
Só quere pensar, todo ben, cando ocorre algo, o que quero que ocorre?

1183
01:18:06,310 --> 01:18:10,520
Non quere pensar, todo ben, eu teño que seguro que esta cousa fala con esa cousa,

1184
01:18:10,520 --> 01:18:14,660
esa cousa de bla bla bla, porque só quere falar algo en termos de eventos.

1185
01:18:14,660 --> 01:18:17,650
Cando isto ocorre, isto ocorre. Cando isto ocorre, o que pasa.

1186
01:18:17,650 --> 01:18:20,240
E se as cousas desencadear outras cousas, iso é gran.

1187
01:18:20,240 --> 01:18:22,150
Pero non quere tentar facer código complicado

1188
01:18:22,150 --> 01:18:24,130
onde está provocando moitas cousas á vez,

1189
01:18:24,130 --> 01:18:28,860
porque está indo só para dar-se unha dor de cabeza.

1190
01:18:28,860 --> 01:18:32,340
>> Todo ben. Agora podemos comezar a nosa páxina de xestionar eventos,

1191
01:18:32,340 --> 01:18:35,640
pero digamos que o meu usuario fai clic nun botón.

1192
01:18:35,640 --> 01:18:38,040
E se eu queira enviar a solicitude de volta ao servidor,

1193
01:18:38,040 --> 01:18:41,100
pero eu non quero volver cargar a páxina, porque ter que volver cargar unha nova páxina

1194
01:18:41,100 --> 01:18:44,390
cada vez que queda medio entediante, e por que eu teño

1195
01:18:44,390 --> 01:18:47,430
para tirar abaixo a cabeceira de novo, e de novo o pé,

1196
01:18:47,430 --> 01:18:49,670
e todos os elementos da páxina de novo

1197
01:18:49,670 --> 01:18:53,180
só para refrescar o cumprimento ou o tempo?

1198
01:18:53,180 --> 01:18:55,290
Entón é por iso que temos algo como Ajax.

1199
01:18:55,290 --> 01:18:59,150
Que podemos facer aquí co Ajax é que podemos dicir, todo ben,

1200
01:18:59,150 --> 01:19:01,290
Quero enviar algúns datos para o servidor,

1201
01:19:01,290 --> 01:19:04,010
e quero ter unha resposta de volta para que eu poida actualizar miña páxina,

1202
01:19:04,010 --> 01:19:12,120
ou que só facer algúns cálculos algorítmicos que non necesariamente amosar nada para o usuario.

1203
01:19:12,120 --> 01:19:15,500
O que cómpre facer iso? Ben, precisa un URL que precisa para falar.

1204
01:19:15,500 --> 01:19:18,650
O servidor non pode Magic escoitar da nada.

1205
01:19:18,650 --> 01:19:21,960
Debe ter un lugar específico que está enviando os datos a.

1206
01:19:21,960 --> 01:19:26,240
E tamén ten que algúns datos para enviar, ou que sexa unha consulta sen datos.

1207
01:19:26,240 --> 01:19:31,380
Só quere facer o ping ao servidor e dicir: Ola, eu estou vivo, ou algo parecido.

1208
01:19:31,380 --> 01:19:35,150
E entón quere unha función que trata basicamente correctamente.

1209
01:19:35,150 --> 01:19:38,250
Imos dicir que recibir de volta unha información do seu servidor,

1210
01:19:38,250 --> 01:19:42,960
e quere cambiar o título do usuario na súa páxina.

1211
01:19:42,960 --> 01:19:44,930
Así, terá a información de volta,

1212
01:19:44,930 --> 01:19:48,860
e que tería que empurrar para a pantalla.

1213
01:19:48,860 --> 01:19:51,170
O que pasa é que cando a páxina está listo,

1214
01:19:51,170 --> 01:19:56,500
crear un en función de click para este botón chamado saúdo.

1215
01:19:56,500 --> 01:19:58,810
O que isto fai é entón, cando este botón é presionado,

1216
01:19:58,810 --> 01:20:03,700
fala con greetings.php, fai unha solicitude POST,

1217
01:20:03,700 --> 01:20:07,290
e di, hey, me algo da súa páxina.

1218
01:20:07,290 --> 01:20:09,890
Nós realmente non precisa describir iso, pero greetings.php,

1219
01:20:09,890 --> 01:20:12,480
imos só dicir, dá de volta "Ola mundo".

1220
01:20:12,480 --> 01:20:15,650
Así que volvemos este "Ola mundo", e no éxito deste,

1221
01:20:15,650 --> 01:20:20,730
asumindo nada sae mal, entón só tes que ir a este lugar de destino

1222
01:20:20,730 --> 01:20:25,720
que especificamos e se ater só a resposta alí.

1223
01:20:25,720 --> 01:20:31,560
E esta é un xeito moi sinxelo de configurar unha consulta Ajax.

1224
01:20:31,560 --> 01:20:34,340
>> Moi rapidamente, Rob tipo de mencionado iso xa,

1225
01:20:34,340 --> 01:20:37,170
as cousas poden dar mal, cousas malas poden ocorrer,

1226
01:20:37,170 --> 01:20:42,660
así que quere para familiarizado con estes códigos de resposta HTTP.

1227
01:20:42,660 --> 01:20:46,030
¿Qué son estes son só, como, 200, todo foi ben.

1228
01:20:46,030 --> 01:20:48,670
Outra cousa, as cousas malas aconteceron.

1229
01:20:48,670 --> 01:20:50,790
En xeral, é a cousa que quere lembrar.

1230
01:20:50,790 --> 01:20:53,440
Pero é bo saber que todos estes.

1231
01:20:53,440 --> 01:20:55,970
E, finalmente, unha vez que xa pasou por todo iso,

1232
01:20:55,970 --> 01:20:58,680
necesitamos falar moi rápido sobre o proxecto,

1233
01:20:58,680 --> 01:21:00,620
e entón podemos deixar que todos saír.

1234
01:21:00,620 --> 01:21:03,410
Proxecto. Cousas que quere lembrar.

1235
01:21:03,410 --> 01:21:06,950
Pregunta a si mesmo estas preguntas: Quen vai usar isto?

1236
01:21:06,950 --> 01:21:09,580
Que van usalo para? O que os meus usuarios se preocupan?

1237
01:21:09,580 --> 01:21:11,750
Que non se preocupan?

1238
01:21:11,750 --> 01:21:14,500
Só non quere facer unha aplicación e deixar só crecer

1239
01:21:14,500 --> 01:21:18,270
e tornar-se este xigante, que todo consome cousa que non pode mesmo acabar.

1240
01:21:18,270 --> 01:21:23,900
Quere ter obxectivos distintos plans e cousas que quere abordar.

1241
01:21:23,900 --> 01:21:29,000
Facelo sen esforzo. Todo iso, di, basicamente,

1242
01:21:29,000 --> 01:21:34,950
facer máis doado para o usuario a usala, non facelo unha burbulla xigante de texto como este slide é, en realidade.

1243
01:21:34,950 --> 01:21:38,020
Só quere que sexa algo que é moi doado para alguén para ir en

1244
01:21:38,020 --> 01:21:40,800
e facer o que eles queren facer.

1245
01:21:40,800 --> 01:21:42,920
Non quere que eles teñan a navegar 5 páxinas

1246
01:21:42,920 --> 01:21:45,460
para chegar ao seu principal función do seu sitio.

1247
01:21:45,460 --> 01:21:49,290
O Google tiña 5 páxinas antes que puidese buscar algo,

1248
01:21:49,290 --> 01:21:53,080
ninguén ía usalo.

1249
01:21:53,080 --> 01:21:55,890
E, por último, o prototipo de papel, grupo focal.

1250
01:21:55,890 --> 01:21:59,220
Teña un bo deseño e prácticas de proba.

1251
01:21:59,220 --> 01:22:00,730
Só porque pensas que funciona para vostede,

1252
01:22:00,730 --> 01:22:04,860
non significa que os outros pensan que funciona.

1253
01:22:04,860 --> 01:22:14,490
Pero si, é iso.

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