1
00:00:00,000 --> 00:00:02,270
>> [Comentario: Concurso 1]

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

3
00:00:04,620 --> 00:00:07,660
[Este es CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Bienvenidos todos. Esta es una reseña de prueba 1.

5
00:00:11,610 --> 00:00:15,040
Así como un descargo de responsabilidad, esto es - quiero decir, vamos a tratar de cubrir

6
00:00:15,040 --> 00:00:17,770
tanto material como sea posible, pero eso no quiere decir que

7
00:00:17,770 --> 00:00:20,780
vamos a cubrir la totalidad de las cosas que pueden estar en la prueba 1.

8
00:00:20,780 --> 00:00:25,270
Así que asegúrese de que usted también está tomando un vistazo a la conferencia, secciones, todo lo que puedas.

9
00:00:25,270 --> 00:00:28,240
Cuestionario 1 va a ser el miércoles próximo miércoles.

10
00:00:28,240 --> 00:00:33,800
Así que asegúrese de estudiar. Va a ser, más o menos, como la primera prueba

11
00:00:33,800 --> 00:00:36,390
en cuanto a su formato, pero que probablemente va a ser mucho más difícil.

12
00:00:36,390 --> 00:00:39,600
Por lo menos, el año pasado cuando hice 50, pensé que era mucho más difícil.

13
00:00:39,600 --> 00:00:42,410
Así que estudiar mucho.

14
00:00:42,410 --> 00:00:45,190
>> Voy a cubrir las estructuras de datos y la codificación Huffman.

15
00:00:45,190 --> 00:00:47,910
Esto es algo que mucha gente piensa que es complejo,

16
00:00:47,910 --> 00:00:51,930
pero voy a tratar de hacerlo lo más fácil posible.

17
00:00:51,930 --> 00:00:56,330
En primer lugar, lo que queremos que sepan para quiz 1 es

18
00:00:56,330 --> 00:01:00,970
entender las descripciones conceptuales de cada una de las estructuras de datos que voy a presentar.

19
00:01:00,970 --> 00:01:03,960
Eso significa que usted no tiene que realmente

20
00:01:03,960 --> 00:01:07,020
implementar una tabla hash en su concurso 1.

21
00:01:07,020 --> 00:01:10,250
No queremos que le permite implementar una tabla hash entero, tal vez vamos a tratar

22
00:01:10,250 --> 00:01:13,090
para que se implemente algunas funciones,

23
00:01:13,090 --> 00:01:16,940
las operaciones más comunes, pero no vamos a hacer que se implemente todo.

24
00:01:16,940 --> 00:01:21,010
Así que es importante que usted entienda el concepto detrás de cada estructura de datos

25
00:01:21,010 --> 00:01:23,510
y también que usted es capaz de código en C,

26
00:01:23,510 --> 00:01:27,880
sólo las operaciones más comunes que tienen para cada estructura de datos.

27
00:01:27,880 --> 00:01:30,090
Y también podrá revisar los punteros y estructuras,

28
00:01:30,090 --> 00:01:33,470
porque aparecen mucho en estas estructuras de datos.

29
00:01:33,470 --> 00:01:37,380
>> En primer lugar, las listas enlazadas. Las listas enlazadas son en realidad muy similares a las matrices,

30
00:01:37,380 --> 00:01:39,930
pero la diferencia entre una lista enlazada y una matriz,

31
00:01:39,930 --> 00:01:45,160
primero de todo, es que una lista enlazada tiene un tamaño muy flexible,

32
00:01:45,160 --> 00:01:50,060
mientras que en las matrices lo que tienes que elegir un tamaño muy grande para la matriz,

33
00:01:50,060 --> 00:01:53,710
así que usted sabe que usted va a ser capaz de almacenar todos los datos en la matriz,

34
00:01:53,710 --> 00:01:59,370
o tienes que usar malloc para tener una longitud flexible de la matriz.

35
00:01:59,370 --> 00:02:03,680
En las listas enlazadas es muy fácil de obtener sólo más elementos,

36
00:02:03,680 --> 00:02:07,210
poner más elementos en la lista enlazada o quitar elementos.

37
00:02:07,210 --> 00:02:09,370
Y, de hecho, si usted no desea que la lista vinculada a clasificar,

38
00:02:09,370 --> 00:02:13,950
usted puede buscar y eliminar elementos en tiempo constante,

39
00:02:13,950 --> 00:02:16,800
por lo que O (1) vez, así que es muy conveniente.

40
00:02:16,800 --> 00:02:20,660
Sólo tienes que tener cuidado de recordar siempre a malloc y libre de los nodos,

41
00:02:20,660 --> 00:02:25,510
porque si no lo hace, tendrá pérdidas de memoria.

42
00:02:25,510 --> 00:02:31,480
Así listas vinculadas - la definición de un nodo es igual que lo que tenemos ahí.

43
00:02:31,480 --> 00:02:35,110
Puse int n, pero puede almacenar los datos que desee.

44
00:02:35,110 --> 00:02:37,280
Así que si desea almacenar una cadena, que está bien.

45
00:02:37,280 --> 00:02:41,690
Si desea almacenar una estructura, que está bien, un doble, lo que quieras.

46
00:02:41,690 --> 00:02:44,630
Acabo de poner int n de los ejemplos aquí.

47
00:02:44,630 --> 00:02:46,800
Y usted tiene un puntero al siguiente nodo.

48
00:02:46,800 --> 00:02:51,940
Así que, básicamente, una lista enlazada tiene algunos datos, y luego apunta al siguiente nodo.

49
00:02:51,940 --> 00:02:56,710
Si es el último elemento de la lista enlazada, que va a apuntar a NULL.

50
00:02:56,710 --> 00:02:59,060
Así que este es un ejemplo de una lista enlazada.

51
00:02:59,250 --> 00:03:05,960
>> Bien, ahora vamos a ver lo que tenemos que hacer si quiero insertar un elemento en una lista enlazada.

52
00:03:05,960 --> 00:03:08,810
En primer lugar, una inserción de la función será de tipo void

53
00:03:08,810 --> 00:03:11,350
porque yo no quiero devolver nada.

54
00:03:11,350 --> 00:03:14,200
Y me voy a tomar un int como argumento,

55
00:03:14,200 --> 00:03:17,090
porque quiero saber lo que quiero insertar.

56
00:03:17,090 --> 00:03:21,840
Entonces, ¿qué es lo primero que debo hacer? Bueno, debería malloc en nodo_nuevo,

57
00:03:21,840 --> 00:03:24,240
por lo que es la primera línea.

58
00:03:24,240 --> 00:03:27,580
Estoy creando un nuevo nodo a poner en una lista enlazada.

59
00:03:27,580 --> 00:03:32,360
Entonces, ¿qué puedo hacer? Bueno, sabemos que en nuestras implementaciones de listas enlazadas

60
00:03:32,360 --> 00:03:38,180
en clase, siempre ponemos la cabeza como una variable global.

61
00:03:38,180 --> 00:03:41,800
Así que lo que podemos hacer es cambiar la cabeza.

62
00:03:41,800 --> 00:03:44,300
Puedo hacer este nuevo nodo será el nuevo jefe,

63
00:03:44,300 --> 00:03:46,670
y que va a apuntar a la cabeza anterior.

64
00:03:46,670 --> 00:03:50,390
¿Cómo podemos hacer eso? Lo primero que tengo que hacer

65
00:03:50,390 --> 00:03:54,770
es cambiar la 'n' en el nuevo nodo al valor,

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

67
00:03:57,530 --> 00:04:01,050
Entonces es nodo_nuevo próximo va a ser el jefe.

68
00:04:01,050 --> 00:04:05,800
La cabeza va a ser nodo_nuevo. Así que es bastante simple.

69
00:04:05,800 --> 00:04:10,090
Para eliminar un nodo, podemos hacerlo así -

70
00:04:10,090 --> 00:04:14,790
Una forma en que podríamos hacer, es decir,

71
00:04:14,790 --> 00:04:18,160
bien, si quería eliminar, por ejemplo, 3,

72
00:04:18,160 --> 00:04:24,850
lo que podría hacer es simplemente apunte al nodo anterior

73
00:04:24,850 --> 00:04:27,580
al siguiente nodo de 3.

74
00:04:27,580 --> 00:04:29,400
Así que me acaba de hacer algo así.

75
00:04:29,400 --> 00:04:33,400
Pero ¿cuál es el problema de hacer eso?

76
00:04:33,400 --> 00:04:37,400
Tengo una pérdida de memoria, así que no tienen acceso al número 3 más.

77
00:04:37,400 --> 00:04:42,480
El problema con eso es que yo no voy a ser capaz de liberar a ese nodo.

78
00:04:42,480 --> 00:04:45,360
Voy a tener pérdida de memoria y (ininteligible) me va a odiar.

79
00:04:45,360 --> 00:04:49,370
Así que en vez de hacer eso, probablemente debería tener un puntero temporal.

80
00:04:49,370 --> 00:04:53,210
Así que puse temp. Se va a apuntar al nodo que quiero borrar.

81
00:04:53,210 --> 00:04:58,170
Y entonces me puedo mover los nodos anteriores a punto al siguiente nodo

82
00:04:58,170 --> 00:05:00,390
del nodo que quiero borrar.

83
00:05:00,390 --> 00:05:02,730
Y, por último, puedo liberar el puntero.

84
00:05:02,730 --> 00:05:07,480
¿Tengo que liberar el puntero que he creado allí mismo?

85
00:05:07,480 --> 00:05:09,560
Yo no tengo que, sólo porque -

86
00:05:09,560 --> 00:05:13,430
la diferencia es que este nodo se ha creado usando malloc,

87
00:05:13,430 --> 00:05:17,280
por lo que es en el montón, mientras éste estaba declarado como un interruptor de NULL en la pila.

88
00:05:17,280 --> 00:05:20,000
Así que no tengo que liberarlo.

89
00:05:20,000 --> 00:05:22,030
>> Okay. Así que ahora vamos a hablar de las pilas.

90
00:05:22,030 --> 00:05:24,680
Las pilas son bastante sencillos.

91
00:05:24,680 --> 00:05:29,540
Hicimos pilas y colas en la clase simplemente utilizando matrices,

92
00:05:29,540 --> 00:05:32,820
pero usted debe estar familiarizado - acaba de ser conscientes

93
00:05:32,820 --> 00:05:40,740
que también se puede hacer pilas de colas mediante listas enlazadas también.

94
00:05:40,740 --> 00:05:44,460
Así que si usted tiene una matriz, lo que sería una pila?

95
00:05:44,460 --> 00:05:46,810
Una pila, en primer lugar, tendrá que tener un tamaño.

96
00:05:46,810 --> 00:05:49,950
Usted tiene que guardar lo que es el tamaño de la pila que tiene en estos momentos.

97
00:05:49,950 --> 00:05:52,980
Y también tendría una matriz, en este caso de los números,

98
00:05:52,980 --> 00:05:55,120
pero si usted quiere, puede ser una matriz

99
00:05:55,120 --> 00:06:00,380
de cadenas, una matriz de estructura, cualquier cosa que usted desee almacenar.

100
00:06:00,380 --> 00:06:03,240
Acerca de la pila: La diferencia entre una pila y una lista enlazada

101
00:06:03,240 --> 00:06:08,590
es que en la pila sólo tiene acceso al último elemento que se puso en la pila.

102
00:06:08,590 --> 00:06:11,770
Se llama la última entrada, primera salida.

103
00:06:11,770 --> 00:06:15,090
Al igual que usted tiene una pila de bandejas,

104
00:06:15,090 --> 00:06:17,670
si usted pone una bandeja en la parte superior de la pila,

105
00:06:17,670 --> 00:06:22,670
tienes que eliminar esa bandeja primeros en tener acceso a las demás bandejas.

106
00:06:22,670 --> 00:06:26,310
Es lo mismo con las pilas.

107
00:06:26,310 --> 00:06:31,220
Así que si yo quiero, por ejemplo, agregar un elemento a una pila, ¿qué debo hacer?

108
00:06:31,220 --> 00:06:34,070
Se llama empuje, y es bastante sencillo.

109
00:06:34,070 --> 00:06:37,130
Lo primero que tienes que hacer es comprobar si el tamaño de la pila

110
00:06:37,130 --> 00:06:40,150
no es mayor o igual a la capacidad de la pila.

111
00:06:40,150 --> 00:06:45,810
Porque si usted ya está en plena capacidad, no se puede agregar nada más.

112
00:06:45,810 --> 00:06:51,140
Y entonces, si no es así, sólo tienes que añadir el elemento a la pila.

113
00:06:51,140 --> 00:06:54,530
Y, por último, incrementar el tamaño. Así que es bastante sencillo.

114
00:06:54,530 --> 00:06:57,140
Así que simplemente añadir el número 2.

115
00:06:57,140 --> 00:07:00,350
Y si quiero hacer estallar, lo que significa que quiero quitar

116
00:07:00,350 --> 00:07:03,870
el último elemento que se ha añadido y devuelve el valor del elemento,

117
00:07:03,870 --> 00:07:09,180
la primera cosa que tengo que comprobar es que la pila no está vacía.

118
00:07:09,180 --> 00:07:11,510
Porque si está vacío, no puedo devolver nada.

119
00:07:11,510 --> 00:07:14,820
En ese caso, estoy devolviendo -1.

120
00:07:14,820 --> 00:07:18,960
De lo contrario, voy a disminuir el tamaño de la especificación,

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

122
00:07:22,510 --> 00:07:27,230
¿Por qué disminuir el tamaño y luego vuelva s.size?

123
00:07:27,230 --> 00:07:30,930
Es porque, en este caso, la especificación tiene tamaño 4,

124
00:07:30,930 --> 00:07:33,810
y quiero devolver el cuarto elemento, ¿no?

125
00:07:33,810 --> 00:07:36,030
Pero, ¿qué es el índice del cuarto elemento? Tres.

126
00:07:36,030 --> 00:07:44,510
Ya que el tamaño - va a ser 3, no puedo volver s.numbers (s.size)

127
00:07:44,510 --> 00:07:48,410
porque es 3. Así que es sólo el índice.

128
00:07:48,410 --> 00:07:50,380
>> Ahora colas. Las colas son más o menos la misma cosa.

129
00:07:50,380 --> 00:07:54,950
La única diferencia es que en vez de tener la última entrada, primera salida,

130
00:07:54,950 --> 00:07:57,480
usted tiene primero que entra, primero que sale.

131
00:07:57,480 --> 00:07:59,460
Probablemente si usted está esperando para ir a un concierto,

132
00:07:59,460 --> 00:08:04,260
que no sería feliz si tuviera una pila en lugar de una cola.

133
00:08:04,260 --> 00:08:07,730
Al ser la última persona en llegar sería la primera persona en entrar al concierto.

134
00:08:07,730 --> 00:08:09,760
Usted probablemente no sería feliz.

135
00:08:09,760 --> 00:08:15,020
En la cola, la primera persona en entrar es también la primera persona en salir.

136
00:08:15,020 --> 00:08:18,720
Así que en la definición de una cola, además de tener el tamaño de la matriz,

137
00:08:18,720 --> 00:08:23,360
también hay que tener la cabeza, que es el índice de la cabeza de la pila.

138
00:08:23,360 --> 00:08:29,000
Así que el primer elemento en estos momentos.

139
00:08:29,000 --> 00:08:32,710
Enqueue es lo mismo que el empuje para pilas.

140
00:08:32,710 --> 00:08:34,980
Si usted era muy ingenuo, usted acaba de decir,

141
00:08:34,980 --> 00:08:39,289
bueno, yo puedo hacer exactamente lo mismo que yo hice para empujar.

142
00:08:39,289 --> 00:08:44,030
Yo sólo puedo comprobar si no es más allá de la capacidad.

143
00:08:44,030 --> 00:08:48,760
Si es así, vuelva falsa, de lo contrario sólo puedo exportar el nuevo valor

144
00:08:48,760 --> 00:08:50,630
y luego incrementar el tamaño.

145
00:08:50,630 --> 00:08:52,750
Pero ¿por qué esta mal?

146
00:08:52,750 --> 00:08:55,010
Veamos este ejemplo.

147
00:08:55,010 --> 00:08:57,020
Estoy tratando de poner en cola un montón de cosas,

148
00:08:57,020 --> 00:08:58,390
y luego me voy a quitar de la cola y poner en cola.

149
00:08:58,390 --> 00:09:00,550
Hay un montón de comandos, pero es muy simple.

150
00:09:00,550 --> 00:09:04,790
Voy a poner en cola 5, por lo que añadir 5 y luego 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, y luego quiero quitar de la cola algo,

152
00:09:09,310 --> 00:09:12,000
lo que significa que me voy a quitar el primer elemento.

153
00:09:12,000 --> 00:09:14,640
Así que me voy a quitar el número 3, ¿no?

154
00:09:14,640 --> 00:09:17,320
El primer elemento. Okay.

155
00:09:17,320 --> 00:09:21,450
Ahora bien, si yo trato de poner en cola algo más, lo que va a suceder?

156
00:09:21,450 --> 00:09:24,290
De acuerdo a mi aplicación,

157
00:09:24,290 --> 00:09:31,040
Iba a poner el siguiente número de la q.size índice.

158
00:09:31,040 --> 00:09:35,140
En este caso, el tamaño es 8,

159
00:09:35,140 --> 00:09:38,640
por lo que el índice de 8 estará aquí en la última posición.

160
00:09:38,640 --> 00:09:43,900
Si trato de poner en cola 1 aquí, yo estaría de sobrescribir la última posición

161
00:09:43,900 --> 00:09:45,870
con el número 1, que es completamente equivocado.

162
00:09:45,870 --> 00:09:49,870
Lo que quiero hacer es envolver alrededor y ve a la primera posición.

163
00:09:49,870 --> 00:09:52,870
Tal vez usted acaba de decir, bueno, tengo que comprobar

164
00:09:52,870 --> 00:09:55,600
si puedo realmente poner algo allí.

165
00:09:55,600 --> 00:09:58,560
Si no, yo sólo digo, oh, la nueva capacidad plena

166
00:09:58,560 --> 00:10:02,010
es en realidad la capacidad - 1, y no se puede poner un elemento allí.

167
00:10:02,010 --> 00:10:06,150
Pero ¿cuál es el problema? El problema es que si sólo Dequeue todo aquí

168
00:10:06,150 --> 00:10:08,240
y entonces trato de agregar algo más, sería justo decir,

169
00:10:08,240 --> 00:10:11,210
así, usted estaba en plena capacidad, que es 0.

170
00:10:11,210 --> 00:10:13,620
Así que su cola se ha ido.

171
00:10:13,620 --> 00:10:16,990
Usted tiene que envolver alrededor, y una manera de envolver alrededor

172
00:10:16,990 --> 00:10:22,040
que ustedes aprendidas en conjuntos de procesadores y otros visionarios estaba usando mod.

173
00:10:22,040 --> 00:10:29,090
Puedes probarlo en casa para entender por qué usted haría q.size + q.head

174
00:10:29,090 --> 00:10:31,080
capacidad mod, pero si revisas aquí,

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

176
00:10:34,760 --> 00:10:37,760
Así, en el último ejemplo, q.size era 8

177
00:10:37,760 --> 00:10:47,590
y la cabeza fue de 1, porque fue esta posición aquí de la matriz.

178
00:10:47,590 --> 00:10:51,970
Así que será 8 + 1, 9. Capacidad Mod. 9 sería 0.

179
00:10:51,970 --> 00:10:56,640
Iría al índice 0. Vamos a estar en la posición correcta.

180
00:10:56,640 --> 00:10:59,750
Y a continuación, intente la cola en casa.

181
00:10:59,750 --> 00:11:04,950
Algunas cosas importantes: tratar de entender la diferencia entre una pila y una cola.

182
00:11:04,950 --> 00:11:11,620
En su casa, trate de obtener muy familiarizado con la implementación de puesta en cola, quitar de la cola, empuje y pop.

183
00:11:11,620 --> 00:11:16,560
Y también entender cuándo puede utilizar cada uno de ellos.

184
00:11:16,560 --> 00:11:22,830
>> Así que relájate durante 10 segundos con un montón de Pokémons.

185
00:11:22,830 --> 00:11:26,080
Y ahora vamos a volver a las estructuras de datos.

186
00:11:26,080 --> 00:11:29,770
Tablas hash. Un montón de gente estaba asustada de las tablas hash.

187
00:11:29,770 --> 00:11:33,650
en problemas 6, corrector ortográfico.

188
00:11:33,650 --> 00:11:35,980
Las tablas hash y tries, mucha gente se asusta de ellos.

189
00:11:35,980 --> 00:11:38,540
Ellos piensan que son tan difícil de entender. ¿Sí?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Boletín de problemas 5. >> Boletín de problemas 5, sí. Gracias Rob.

191
00:11:41,490 --> 00:11:43,370
Sí. Seis era Huff n 'Puff, sí.

192
00:11:43,370 --> 00:11:49,340
Problemas 5 fue corrector ortográfico, y ha tenido que utilizar una tabla hash o una oportunidad.

193
00:11:49,340 --> 00:11:55,360
Mucha gente pensó que eran muy difíciles de entender, pero son en realidad bastante simple.

194
00:11:55,360 --> 00:12:01,290
¿Qué es una tabla hash, básicamente? Una tabla hash es un conjunto de listas enlazadas.

195
00:12:01,290 --> 00:12:06,730
La única diferencia entre una matriz y una tabla hash

196
00:12:06,730 --> 00:12:09,730
es que en la tabla hash tiene algo que se llama una función hash.

197
00:12:09,730 --> 00:12:12,080
¿Qué es una función hash?

198
00:12:12,080 --> 00:12:13,970
No sé si ustedes pueden leer aquí.

199
00:12:13,970 --> 00:12:16,090
Este es un ejemplo de una tabla hash.

200
00:12:16,090 --> 00:12:19,220
Así se puede ver que tiene una matriz con 31 elementos.

201
00:12:19,220 --> 00:12:22,440
Y lo que hacemos en una tabla hash se tiene una función hash

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

203
00:12:26,660 --> 00:12:31,740
Si, por ejemplo, si quiero elegir por B. Harrison,

204
00:12:31,740 --> 00:12:34,190
Yo pondría B. Harrison en mis funciones de hash,

205
00:12:34,190 --> 00:12:36,960
y la función hash devolvería 24.

206
00:12:36,960 --> 00:12:40,930
Así que sé que quiero para almacenar B. Harrison en 24.

207
00:12:40,930 --> 00:12:46,580
Así que esa es la diferencia entre simplemente tener un conjunto y con una tabla hash.

208
00:12:46,580 --> 00:12:48,740
En la tabla hash tendrá una función que se va a decir

209
00:12:48,740 --> 00:12:54,740
dónde almacenar los datos que desea almacenar.

210
00:12:54,740 --> 00:12:57,040
Para la función de hash, que quiere buscar una función hash

211
00:12:57,040 --> 00:13:00,600
es determinista y bien distribuida.

212
00:13:00,600 --> 00:13:07,810
Como se puede ver aquí, verá que muchos de los datos que yo quería a la tienda era en realidad 19

213
00:13:07,810 --> 00:13:12,470
en vez de usar 31 y 30 y 29, que eran todos de forma gratuita.

214
00:13:12,470 --> 00:13:16,920
Así que la función hash que usé no estaba muy bien distribuida.

215
00:13:16,920 --> 00:13:20,710
Cuando decimos bien distribuidos, significa que queremos tener,

216
00:13:20,710 --> 00:13:26,520
más o menos, al menos 1 o 2 para cada uno de los -

217
00:13:26,520 --> 00:13:32,190
como, una diferencia de 1 o 2 para cada uno de los índices en las matrices.

218
00:13:32,190 --> 00:13:43,950
Usted quiere tener, más o menos, el mismo número de elementos en cada lista enlazada de la matriz.

219
00:13:43,950 --> 00:13:48,600
Y es fácil de comprobar si es válido en la tabla hash, ver como las tablas hash.

220
00:13:48,600 --> 00:13:51,770
>> Entonces árboles. Este es un árbol.

221
00:13:51,770 --> 00:13:56,400
Árboles en ciencias de la computación están al revés, por alguna razón.

222
00:13:56,400 --> 00:14:00,150
Así que aquí tienes la raíz del árbol y luego las hojas.

223
00:14:00,150 --> 00:14:05,630
Usted sólo debe conocer la nomenclatura de los padres y el niño.

224
00:14:05,630 --> 00:14:12,880
Cada nodo tiene sus niños, que son los nodos que están debajo de la matriz.

225
00:14:12,880 --> 00:14:19,660
Así, por ejemplo, 2 va a ser el padre de 3 y para el otro niño allí,

226
00:14:19,660 --> 00:14:25,290
mientras que el 3 va a ser el padre de 1 y los otros niños que están allí.

227
00:14:25,290 --> 00:14:29,990
Y 1 va a ser un hijo de 3, y así sucesivamente.

228
00:14:29,990 --> 00:14:34,610
Tenemos algo mucho más interesante, se llama un árbol de búsqueda binaria,

229
00:14:34,610 --> 00:14:39,040
en la que todos los valores de la derecha de un nodo

230
00:14:39,040 --> 00:14:41,660
van a estar a la derecha, a la derecha aquí - a la derecha,

231
00:14:41,660 --> 00:14:46,780
van a ser mayor que el elemento en la raíz.

232
00:14:46,780 --> 00:14:49,780
Así que si tengo el número 5 aquí, todos los elementos de la derecha

233
00:14:49,780 --> 00:14:51,940
van a ser mayor que 5, y en el lado izquierdo

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

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

236
00:14:58,780 --> 00:15:01,660
Bueno, si yo quiero comprobar si el número 7 ya está aquí, por ejemplo,

237
00:15:01,660 --> 00:15:05,960
Acabo de ir a 5 primero y yo voy a ver, es 7 más o menos de 5?

238
00:15:05,960 --> 00:15:09,540
Es más, así que sé que va a tener que estar a la derecha del árbol.

239
00:15:09,540 --> 00:15:13,980
Así que tengo mucho menos cosas que ver.

240
00:15:13,980 --> 00:15:19,520
En la aplicación de un árbol de búsqueda binaria, el nodo, sólo voy a tener que disponer de datos,

241
00:15:19,520 --> 00:15:21,750
así int n; usted también podría tener una cadena

242
00:15:21,750 --> 00:15:23,630
o cualquier cosa que quisieras.

243
00:15:23,630 --> 00:15:28,100
Sólo tienes que tener cuidado en la definición de lo que sea mayor, lo que sea menor.

244
00:15:28,100 --> 00:15:30,390
Así que si usted tenía cuerdas, por ejemplo, se podría definir

245
00:15:30,390 --> 00:15:34,690
que todas esas cosas a la derecha van a tener mayor longitud,

246
00:15:34,690 --> 00:15:40,940
la izquierda van a tener longitudes inferiores, por lo que es realmente depende de ti.

247
00:15:40,940 --> 00:15:44,930
>> ¿Cómo puedo aplicar para encontrar BST?

248
00:15:44,930 --> 00:15:47,840
Lo primero que tendremos que hacer es comprobar si la raíz es NULL.

249
00:15:47,840 --> 00:15:50,920
Si es NULL, significa que la cosa no está allí

250
00:15:50,920 --> 00:15:53,330
porque no tienen ni siquiera un árbol, ¿no?

251
00:15:53,330 --> 00:15:55,790
Así que vuelvo falsa.

252
00:15:55,790 --> 00:15:58,740
De lo contrario, voy a comprobar si el número es mayor

253
00:15:58,740 --> 00:16:01,720
que el valor en la raíz.

254
00:16:01,720 --> 00:16:04,250
Voy a tratar de encontrar el elemento de la derecha

255
00:16:04,250 --> 00:16:08,590
del árbol.

256
00:16:08,590 --> 00:16:11,310
Ya ves que estoy usando aquí la recursividad.

257
00:16:11,310 --> 00:16:14,150
Y luego, si es menos, voy a mirar a la izquierda.

258
00:16:14,150 --> 00:16:18,330
Y, por último, de lo contrario, si no es menos o no mayor,

259
00:16:18,330 --> 00:16:20,660
esto significa que es el valor en sí.

260
00:16:20,660 --> 00:16:23,010
Así que me vuelvo cierto.

261
00:16:23,010 --> 00:16:26,360
Usted puede ver aquí que usé si, si, si.

262
00:16:26,360 --> 00:16:30,820
Y recuerda, en prueba 0, tuvimos un problema que tenía, si, si, si,

263
00:16:30,820 --> 00:16:32,780
y que se supone que encontrar la ineficiencia,

264
00:16:32,780 --> 00:16:35,180
y la ineficiencia fue que utilizó si.

265
00:16:35,180 --> 00:16:39,060
Deberías haber usado si, else if, else if y else.

266
00:16:39,060 --> 00:16:44,240
Por lo tanto, debo usar else if y else if y más aquí?

267
00:16:44,240 --> 00:16:46,200
¿Alguien - ¿Sí?

268
00:16:46,200 --> 00:16:51,140
[Hablando de Estudiantes, inaudible]

269
00:16:51,140 --> 00:16:53,480
Es perfecto. Así que está diciendo que no importa,

270
00:16:53,480 --> 00:16:55,930
sólo porque la ineficiencia que teníamos antes

271
00:16:55,930 --> 00:16:59,550
fue que debido a que, tal vez, si alguna condición se satisface,

272
00:16:59,550 --> 00:17:03,570
lo que ha llevado a cabo una acción, pero luego te ibas a comprobar todas las demás condiciones.

273
00:17:03,570 --> 00:17:06,319
Pero en este caso, volvió de inmediato, por lo que no importa.

274
00:17:06,319 --> 00:17:09,220
Así que usted no tiene que usar else if.

275
00:17:09,220 --> 00:17:11,740
>> Y, por último, vamos a hablar de intentos,

276
00:17:11,740 --> 00:17:13,800
que es de todos favorito.

277
00:17:13,800 --> 00:17:15,980
Un try es un árbol de matrices.

278
00:17:15,980 --> 00:17:20,369
Es muy rápido para buscar valores, sino que utiliza una gran cantidad de memoria.

279
00:17:20,369 --> 00:17:22,530
Y es por lo general para filtrar las palabras, así que cuando usted

280
00:17:22,530 --> 00:17:27,920
desee implementar, por ejemplo, no sé, como un libro de teléfono en su teléfono

281
00:17:27,920 --> 00:17:30,440
y quiere ser capaz de escribir B

282
00:17:30,440 --> 00:17:32,510
y sólo tienen los nombres de las personas que tienen B.

283
00:17:32,510 --> 00:17:37,960
Es muy fácil de implementar que el uso de un intento, por ejemplo.

284
00:17:37,960 --> 00:17:39,820
¿Cómo se define un nodo en una oportunidad?

285
00:17:39,820 --> 00:17:43,910
Usted sólo tiene que tener un bool que va a ser is_word.

286
00:17:43,910 --> 00:17:48,660
Esto representa que el uso de todos los caracteres antes de ese nodo,

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

288
00:17:51,920 --> 00:17:57,230
y entonces usted tiene una matriz de punteros a nodos.

289
00:17:57,230 --> 00:18:03,120
¿Puedes ver que tenemos una serie de nodos padre, por lo que el nodo * array? ¿Sí?

290
00:18:03,120 --> 00:18:06,050
Así que vamos a ver cómo va a funcionar. Para la corrección ortográfica,

291
00:18:06,050 --> 00:18:08,230
tenemos una serie de 27 elementos,

292
00:18:08,230 --> 00:18:12,150
porque tenemos todas las cartas más el apóstrofo.

293
00:18:12,150 --> 00:18:17,800
Antes de que aquí sólo voy a usar 2 porque quiero ser capaz de escribir en la pizarra.

294
00:18:17,800 --> 00:18:20,230
Okay. Así que este es un ejemplo de un intento.

295
00:18:20,230 --> 00:18:25,600
Si acabo de definir el primer nodo, voy a tener una matriz de 2 elementos

296
00:18:25,600 --> 00:18:29,290
que son 2 punteros a NULL, así que sólo hay que poner 'a' y 'b'.

297
00:18:29,290 --> 00:18:32,430
Y yo voy a tener un bool que dice is_word.

298
00:18:32,430 --> 00:18:34,420
Va a ser falso para el primero,

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

300
00:18:37,370 --> 00:18:40,900
Así que una palabra vacía no es una palabra. Por lo que es falso.

301
00:18:40,900 --> 00:18:46,320
Si quiero añadir 'a' a este diccionario, ¿qué tendría que hacer?

302
00:18:46,320 --> 00:18:49,760
Sólo quiero que malloc un nuevo nodo para 'a',

303
00:18:49,760 --> 00:18:54,630
y luego agregar su palabra de verdad.

304
00:18:54,630 --> 00:19:00,180
Por lo que sólo representa que el haber 'a' va a ser verdad. Tiene sentido?

305
00:19:00,180 --> 00:19:04,120
Entonces, si quiero añadir 'ba', voy a tener que malloc 1 para 'b',

306
00:19:04,120 --> 00:19:07,550
y luego voy a configurar el booleano en false,

307
00:19:07,550 --> 00:19:10,160
porque 'b' por sí mismo no es una palabra.

308
00:19:10,160 --> 00:19:13,010
Entonces voy a malloc otro para 'a', por lo que 'ba',

309
00:19:13,010 --> 00:19:16,290
y luego voy a crear es una palabra de verdad.

310
00:19:16,290 --> 00:19:18,950
Porque 'ba' es una palabra.

311
00:19:18,950 --> 00:19:21,910
Y entonces, si quiero ver si 'b' se encuentra en este diccionario,

312
00:19:21,910 --> 00:19:26,730
Yo sólo puedo ir a la primera, 'b'. Me caigo, y yo miro es la palabra, y dice falsa.

313
00:19:26,730 --> 00:19:30,110
Así que no es una palabra. Si yo quiero comprobar 'ba',

314
00:19:30,110 --> 00:19:38,010
Voy a la primera, 'b', y luego voy a la 'a', y veo cierto, por lo que es una palabra. Tiene sentido?

315
00:19:38,010 --> 00:19:41,950
Un montón de gente se confunda por intentos. No?

316
00:19:41,950 --> 00:19:44,740
>> Por último, la codificación de Huffman. La codificación de Huffman es muy útil

317
00:19:44,740 --> 00:19:47,550
para ahorrar memoria y comprimir archivos de texto,

318
00:19:47,550 --> 00:19:52,270
sólo porque un montón de veces que utilice 'a' y 'e', ​​por ejemplo,

319
00:19:52,270 --> 00:19:57,710
en sus documentos, pero no sé si ustedes usar 'q' o 'z' como mucho.

320
00:19:57,710 --> 00:20:02,040
Tener sólo 1 byte para cada carácter individual,

321
00:20:02,040 --> 00:20:08,520
todos y cada uno - los 256 caracteres que tenemos en la tabla ASCII no es muy óptima,

322
00:20:08,520 --> 00:20:11,410
sólo porque hay algunos caracteres que se utilizan mucho más,

323
00:20:11,410 --> 00:20:15,180
por lo que es mejor usar menos memoria para aquellos.

324
00:20:15,180 --> 00:20:17,560
¿Cómo se utiliza la codificación de Huffman?

325
00:20:17,560 --> 00:20:20,010
Tenemos que hacer un árbol de Huffman.

326
00:20:20,010 --> 00:20:23,370
 Un árbol de Huffman tiene nodos

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

328
00:20:27,760 --> 00:20:32,990
la letra que usted tiene, una frecuencia que es la frecuencia que aparece la palabra en el texto,

329
00:20:32,990 --> 00:20:36,280
que estuviera creando el árbol de Huffman para,

330
00:20:36,280 --> 00:20:41,800
y a continuación, un nodo que se va a punto a la izquierda del árbol de Huffman

331
00:20:41,800 --> 00:20:47,210
y otro nodo que se va a señalar a la derecha. Así como un árbol.

332
00:20:47,210 --> 00:20:49,440
¿Cómo se construye un árbol de Huffman?

333
00:20:49,440 --> 00:20:54,020
Usted va a escoger a los 2 nodos que tienen las frecuencias más bajas.

334
00:20:54,020 --> 00:20:56,490
Si usted tiene un lazo que va a recoger los 2 nodos

335
00:20:56,490 --> 00:20:59,870
que tienen los valores ASCII más bajos también.

336
00:20:59,870 --> 00:21:02,420
Entonces usted va a crear un nuevo árbol de los 2 nodos

337
00:21:02,420 --> 00:21:08,030
que va a tener la frecuencia combinada en el nodo principal.

338
00:21:08,030 --> 00:21:13,240
Y luego te vas a quitar los 2 hijos de la selva

339
00:21:13,240 --> 00:21:15,570
y reemplazarlos con los padres.

340
00:21:15,570 --> 00:21:18,930
Y usted va a repetir hasta que sólo tiene 1 árbol en el bosque.

341
00:21:18,930 --> 00:21:23,840
Así que vamos a ver cómo lo haría un árbol de Huffman para ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Usted puede ver aquí que todas las letras tienen frecuencia 1 a excepción de 'A'; que tiene la frecuencia 2.

343
00:21:29,220 --> 00:21:34,090
Así que he creado nodos para todas las cartas que pongo en orden de valor ASCII y frecuencia.

344
00:21:34,090 --> 00:21:40,090
Así que si quiero crear el primer árbol, será por 'L' y 'M'.

345
00:21:40,090 --> 00:21:43,100
Así que es aquí. La frecuencia del par será 2

346
00:21:43,100 --> 00:21:49,470
porque es 1 + 1, entonces el próximo 2 con las frecuencias más bajas son 'Y' y 'Z'.

347
00:21:49,470 --> 00:21:53,180
Y luego tengo que siendo todos ellos - tienen una frecuencia de 2.

348
00:21:53,180 --> 00:22:00,470
Así que ¿cuáles son los que tienen el valor ASCII bajo para la próxima?

349
00:22:00,470 --> 00:22:04,830
'A' y 'L'. Así que creo el nuevo nodo,

350
00:22:04,830 --> 00:22:09,930
y, por último, es 4 y 2, por lo que 2 va a estar a la izquierda.

351
00:22:09,930 --> 00:22:12,430
Y este es el árbol de Huffman.

352
00:22:12,430 --> 00:22:16,060
Entonces, si quiero escribir algo de texto,

353
00:22:16,060 --> 00:22:24,440
como en binario para convertir a texto, utilizando el árbol de Huffman es muy fácil.

354
00:22:24,440 --> 00:22:30,220
Por ejemplo, si yo digo que el paso a la izquierda es un 0 y moviéndose a la derecha hay un 1,

355
00:22:30,220 --> 00:22:32,410
¿Qué es eso de ir a representar?

356
00:22:32,410 --> 00:22:35,530
Así como 1, 1, tan a la derecha, a la derecha,

357
00:22:35,530 --> 00:22:40,370
y luego 0, por lo que sería la izquierda L, y luego 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Así 1, 0, por lo que sólo 1, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
Y a continuación, 0, 1, por lo que 'Z'.

360
00:22:47,540 --> 00:22:52,170
Y a continuación, 1, 0, 0 - no.

361
00:22:52,170 --> 00:22:56,780
0, 0 será 'Y', por lo perezoso.

362
00:22:56,780 --> 00:23:06,060
Así que eso es todo para mí, Rob va a tomar el relevo.

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

364
00:23:08,400 --> 00:23:11,390
Tenemos mucho para ir muy rápido.

365
00:23:11,390 --> 00:23:13,430
Operadores bit a bit de desbordamiento de búfer,

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
En definitiva, como 15 a 20 minutos.

368
00:23:20,990 --> 00:23:24,330
Operadores bit a bit. Hay 6 de ellos que usted necesita saber.

369
00:23:24,330 --> 00:23:31,200
Bit a bit y bit a bit OR, XOR, desplazamiento a la izquierda, desplazamiento a la derecha, y no.

370
00:23:31,200 --> 00:23:35,420
Desplazamiento a la derecha y no apenas vio en la conferencia en absoluto.

371
00:23:35,420 --> 00:23:40,480
Vamos a repasar rápidamente aquí, pero es bueno saber que estos son los 6 que existen.

372
00:23:40,480 --> 00:23:45,070
Recuerde que los operadores bit a bit son como cuando haces 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Usted no está tratando con el binario de 3 y 4.

374
00:23:49,420 --> 00:23:56,550
Con los operadores bit a bit en realidad se está tratando con los bits individuales de los números 3 y 4.

375
00:23:56,550 --> 00:23:59,120
>> Así que lo primero que vamos a decir es bit a bit no,

376
00:23:59,120 --> 00:24:02,340
y todo lo que hace es voltear todos los bits.

377
00:24:02,340 --> 00:24:05,500
Así que aquí, si usted está escribiendo esto en C, usted lo escriba

378
00:24:05,500 --> 00:24:09,380
como ~ 11011 o lo que sea, podría escribir se siente ~ 4,

379
00:24:09,380 --> 00:24:12,970
y entonces sería voltear la representación binaria de 4.

380
00:24:12,970 --> 00:24:24,800
Así que aquí, ~ de un número binario 1101101 se va a dar la vuelta exactamente todos los de 1 a 0 de los 0 y del 1 de.

381
00:24:24,800 --> 00:24:27,600
Como digo allí, el uso frecuente de esta,

382
00:24:27,600 --> 00:24:30,830
y lo veremos en un rato, es como queremos llegar a algún número

383
00:24:30,830 --> 00:24:35,460
donde todos los bits son 1, a excepción de uno de ellos.

384
00:24:35,460 --> 00:24:38,560
Así que por lo general es más fácil expresar el número

385
00:24:38,560 --> 00:24:40,630
donde se encuentra a las que solo bit,

386
00:24:40,630 --> 00:24:44,650
y luego tomar el ~ de la misma, por lo que cada otro bit está establecido a excepción de aquél.

387
00:24:44,650 --> 00:24:50,300
Así que eso es lo que vamos a utilizar más en un rato.

388
00:24:50,300 --> 00:24:58,220
>> OR bit a bit. Aquí hay 2 números binarios, y estos 2 números

389
00:24:58,220 --> 00:25:00,780
son bastante representativa, ya que representan cada posible

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

391
00:25:07,290 --> 00:25:13,540
Aquí, cuando or'd cada bit, sólo vamos a comparar directamente hacia abajo.

392
00:25:13,540 --> 00:25:15,410
Así que en el lado izquierdo tenemos un 1 y un 1.

393
00:25:15,410 --> 00:25:20,510
Cuando bit a bit | esos, ¿qué voy a recibir? Una.

394
00:25:20,510 --> 00:25:25,320
Entonces bit a bit | 0 y 1 me va a dar? Una.

395
00:25:25,320 --> 00:25:27,840
Bit a bit 1 y 0 que va a ser lo mismo, uno.

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

397
00:25:31,880 --> 00:25:37,300
Así que el único caso en el que me sale es 0 en el 0 | 0 caso.

398
00:25:37,300 --> 00:25:40,020
Y se puede pensar que al igual que sus alcaldes lógicas.

399
00:25:40,020 --> 00:25:44,830
Así que si usted piensa en 1 como verdadero y 0 como falso, lo mismo se aplica aquí.

400
00:25:44,830 --> 00:25:50,040
Tan cierto o verdadero es verdadero, verdadero o falso es verdad.

401
00:25:50,040 --> 00:25:57,150
Falso o verdadero es verdadero, falso o falso es lo único que en realidad es falso.

402
00:25:57,150 --> 00:26:00,100
Aquí está el ejemplo que usted debe saber

403
00:26:00,100 --> 00:26:05,160
como un buen ejemplo de cuando se usan los operadores bit a bit.

404
00:26:05,160 --> 00:26:08,660
Aquí si nosotros o 'A' mayúscula con OX20,

405
00:26:08,660 --> 00:26:11,830
y vamos a ver esto en un segundo, tenemos algo.

406
00:26:11,830 --> 00:26:16,020
Y si nosotros o minúscula "a" con OX20, conseguimos algo.

407
00:26:16,020 --> 00:26:26,750
Así que vamos a tirar para arriba la tabla ASCII.

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

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

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

411
00:26:45,120 --> 00:26:48,280
Estoy bastante seguro de que lo vimos en clase. Creo que hemos visto en clase

412
00:26:48,280 --> 00:26:52,730
que es bastante fácil de convertir de hexadecimal a binario.

413
00:26:52,730 --> 00:26:55,280
Así que aquí, si quiero poner 4 en binario,

414
00:26:55,280 --> 00:26:59,550
eso es sólo va a ser 0100.

415
00:26:59,550 --> 00:27:03,620
Este es el lugar de 1, el lugar de 2, lugar de 4, así que esto es 4.

416
00:27:03,620 --> 00:27:08,550
Entonces puedo dividir 1 en binario, lo que va a ser 0001.

417
00:27:08,550 --> 00:27:14,280
Y así, esta va a ser la representación de 'A' en binario.

418
00:27:14,280 --> 00:27:22,720
Tomando en minúscula 'a', ahora se va a ser Ox61,

419
00:27:22,720 --> 00:27:27,050
donde, dividiendo éstos para arriba en su binario, por lo que un 6 -

420
00:27:27,050 --> 00:27:37,830
Vamos a hacerlo realidad - no hay una goma de borrar? Borrador.

421
00:27:37,830 --> 00:27:48,220
Ox61. Así dividir 6 en binario va a ser 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
Y la división 1 va a ser 0001.

423
00:27:54,610 --> 00:27:56,520
En cuanto a la diferencia entre estos 2,

424
00:27:56,520 --> 00:28:04,250
vemos que la única diferencia entre una minúscula y una 'A' mayúscula es esto de un solo bit.

425
00:28:04,250 --> 00:28:11,810
Así que volviendo a aquí - bien.

426
00:28:11,810 --> 00:28:15,920
Volviendo a aquí, si nos fijamos en lo que el bit OX20 es,

427
00:28:15,920 --> 00:28:22,210
así que separar OX20 en su binario,

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

429
00:28:27,310 --> 00:28:33,470
OX20, la única parte que se establece este bit es que nos ocupa,

430
00:28:33,470 --> 00:28:38,210
con el cambio entre el capital y minúsculas 'a'.

431
00:28:38,210 --> 00:28:47,610
Si yo o 'A', que es éste, 'A',

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

433
00:28:50,580 --> 00:28:53,490
¿qué voy a recibir?

434
00:28:53,490 --> 00:28:58,960
[Estudiante, inaudible] >> minúscula "a", porque va a voltear este bit a 1.

435
00:28:58,960 --> 00:29:04,170
Y si yo o 'a' con OX20, ¿qué voy a recibir?

436
00:29:04,170 --> 00:29:08,780
Cambiar a minúscula una, porque justo oring 'a' con OX20,

437
00:29:08,780 --> 00:29:14,580
Yo sólo voy a ser oring esta solo bit a 1, es ya un 1, por lo que no importa.

438
00:29:14,580 --> 00:29:17,960
Así que llegar 'a' y 'a'.

439
00:29:17,960 --> 00:29:24,820
>> Bit a bit y. Una vez más, podemos pensar en esto como nuestra contraparte lógica y.

440
00:29:24,820 --> 00:29:28,180
En el lado izquierdo tenemos cierto y verdadero.

441
00:29:28,180 --> 00:29:31,160
Va a ser verdad, y para todos los casos,

442
00:29:31,160 --> 00:29:36,270
falso y verdadero o falso y verdadero, o falso y falso,

443
00:29:36,270 --> 00:29:38,550
ninguna de esas cosas son ciertas.

444
00:29:38,550 --> 00:29:44,170
Así que lo que terminamos recibiendo es 1000.

445
00:29:44,170 --> 00:29:48,830
Así que ahora, aquí, aquí es donde me he utilizado con el operador de confianza no,

446
00:29:48,830 --> 00:29:52,230
donde tuvimos OX20.

447
00:29:52,230 --> 00:29:54,350
Así que esto es OX20.

448
00:29:54,350 --> 00:29:59,570
Ahora lo que quiero hacer, bit a bit ~ de OX20.

449
00:29:59,570 --> 00:30:03,600
Eso va a voltear todos los bits.

450
00:30:03,600 --> 00:30:09,330
Así que tengo 1101, 1111.

451
00:30:09,330 --> 00:30:18,940
Y por lo que 'A' AND con ~ OX20 me va a dar lo que?

452
00:30:18,940 --> 00:30:22,430
La única parte que realmente tenemos que pensar es en éste,

453
00:30:22,430 --> 00:30:26,020
ya que, si todos estos bits se establecen en 1,

454
00:30:26,020 --> 00:30:29,000
entonces vamos a conseguir exactamente lo 'A' era,

455
00:30:29,000 --> 00:30:31,260
a excepción de, posiblemente, lo que esto es poco.

456
00:30:31,260 --> 00:30:34,460
Porque si fuera un 1, ahora que va a ser establecido en un 0,

457
00:30:34,460 --> 00:30:39,810
porque sea lo que sea, AND con esto va a ser 0.

458
00:30:39,810 --> 00:30:43,280
Entonces, ¿qué es 'A' y ~ OX20 me va a dar?

459
00:30:43,280 --> 00:30:48,200
[Los alumnos responden, inaudible] >> Y lo que es 'a' y - es 'A'.

460
00:30:48,200 --> 00:30:52,170
Y lo que es 'a' y ~ OX20 me va a dar?

461
00:30:52,170 --> 00:30:56,720
'A.' Debido a que este es actualmente un 1.

462
00:30:56,720 --> 00:30:59,570
Anding con este 0 va a hacer que sea un 0,

463
00:30:59,570 --> 00:31:02,530
y ahora vamos a obtener una 'A'.

464
00:31:02,530 --> 00:31:06,600
>> Ambos son 'A', y por último pero no menos importante de este tipo,

465
00:31:06,600 --> 00:31:10,830
tenemos XOR. Es muy parecido o,

466
00:31:10,830 --> 00:31:14,400
salvo que significa exclusiva o.

467
00:31:14,400 --> 00:31:18,420
Esto es como lo que se suele pensar en como o en el mundo real.

468
00:31:18,420 --> 00:31:23,190
Así lo hace bien 'x' o 'y', pero no ambos.

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

470
00:31:28,700 --> 00:31:33,650
Porque es verdad, esto es - no funciona tan bien con la lógica de verdadero y falso

471
00:31:33,650 --> 00:31:37,150
como a nivel de bits y yo hacer,

472
00:31:37,150 --> 00:31:40,100
pero cierto ^ verdadero es falso.

473
00:31:40,100 --> 00:31:44,810
Porque sólo queremos devolver true si sólo uno de ellos es cierto.

474
00:31:44,810 --> 00:31:50,950
Así que 1 ^ 1 es 0. ¿Qué pasa con 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
Es 1. 1 ^ 0 es 1, 0 ^ 0 es 0.

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

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

478
00:32:10,270 --> 00:32:14,660
si es | o ^, va a ser un 1, y si es y va a ser 0.

479
00:32:14,660 --> 00:32:20,850
Y el único caso en el que 1 bit a bit 1 es 1 no es exclusiva con o.

480
00:32:20,850 --> 00:32:24,580
Eso es 0110.

481
00:32:24,580 --> 00:32:36,520
Así que aquí ahora, usando XOR - así que estamos de vuelta a los 20.

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

483
00:32:43,480 --> 00:32:50,020
Así que un 1 ^ 0 me va a dar una qué? Un uno.

484
00:32:50,020 --> 00:32:58,430
'A' ^ OX20 me va a dar? Cambiar a minúscula una.

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

486
00:33:04,010 --> 00:33:09,310
Porque lo que sea que está haciendo, esta operación XOR con OX20

487
00:33:09,310 --> 00:33:15,380
está volteando efectivamente sea lo que es poco.

488
00:33:15,380 --> 00:33:21,240
Si esto es un 0, ahora se va a convertir en un 1.

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

490
00:33:26,160 --> 00:33:33,280
Así que nuestro 'a' se ha convertido en 'A', y nuestro 'A' se ha convertido en 'a'.

491
00:33:33,280 --> 00:33:36,910
Así XOR es una manera muy conveniente de simplemente dar la vuelta al caso.

492
00:33:36,910 --> 00:33:39,960
Lo que desea es iterar sobre una cadena de letras

493
00:33:39,960 --> 00:33:44,330
y alternar el caso de cada personaje,

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

495
00:33:50,680 --> 00:33:55,220
>> Ahora nos queda turno. Desplazamiento a la izquierda es sólo va a, básicamente,

496
00:33:55,220 --> 00:34:01,250
empujar todos los números en, o hacia la izquierda, e introduzca 0 de detrás de ellos.

497
00:34:01,250 --> 00:34:05,550
Así que aquí tenemos 00.001.101.

498
00:34:05,550 --> 00:34:08,560
Vamos a empujar 3 del 0 por la derecha,

499
00:34:08,560 --> 00:34:13,580
y obtenemos 01101000.

500
00:34:13,580 --> 00:34:16,380
En términos no binarios,

501
00:34:16,380 --> 00:34:24,699
vemos que lo que realmente se trata 13 izquierda con desplazamiento de 3, lo que nos da 104.

502
00:34:24,699 --> 00:34:32,530
Así desplazamiento izquierda, vemos aquí, x << y es básicamente x * 2 ^ y.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 es 8, por lo que 13 * 8 es 104.

504
00:34:40,139 --> 00:34:45,679
Si sólo piensas en binario, en general, cómo cada dígito,

505
00:34:45,679 --> 00:34:49,530
si partimos de la derecha, que es el lugar del 1, entonces el lugar del 2 y luego el lugar del 4.

506
00:34:49,530 --> 00:34:51,330
Así empujando en 0 de la derecha,

507
00:34:51,330 --> 00:34:55,080
sólo estamos empujando las cosas que estaban en el lugar del 4 al lugar del 8,

508
00:34:55,080 --> 00:34:57,920
y las cosas que estaban en el lugar del 8 al lugar de la 16.

509
00:34:57,920 --> 00:35:01,280
Cada turno sólo se multiplica por 2. ¿Sí?

510
00:35:01,280 --> 00:35:05,210
[Estudiante] ¿Qué sucede si cambiaste por 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] Si cambiaste por 5 usted acaba de perder dígitos.

512
00:35:10,790 --> 00:35:15,410
Inevitablemente, es la misma cosa. Al igual, los enteros son sólo 32 bits

513
00:35:15,410 --> 00:35:20,750
así que si usted agrega 2 realmente grandes enteros, simplemente no cabe en un entero.

514
00:35:20,750 --> 00:35:23,660
Por lo que es lo mismo aquí. Si cambiaste por 5,

515
00:35:23,660 --> 00:35:25,650
nos volveríamos a perder esa.

516
00:35:25,650 --> 00:35:28,820
Y eso es algo de lo que quiero decir con "más o menos"

517
00:35:28,820 --> 00:35:37,470
donde si usted cambia demasiado, pierdes bits.

518
00:35:37,470 --> 00:35:39,830
>> Desplazamiento a la derecha va a ser todo lo contrario,

519
00:35:39,830 --> 00:35:43,090
donde vamos a empujar 0 de fuera de la final,

520
00:35:43,090 --> 00:35:48,400
y para nuestros propósitos, rellene 0 del de la izquierda.

521
00:35:48,400 --> 00:35:52,910
Así que haciendo esto, estamos básicamente revertir lo que ya habíamos hecho.

522
00:35:52,910 --> 00:35:57,780
Y vemos que los tres de 0 a la derecha sólo se han caído,

523
00:35:57,780 --> 00:36:02,020
y hemos empujado el 1101 hasta el final a la derecha.

524
00:36:02,020 --> 00:36:08,380
Esto está haciendo 104 >> 3, que es, efectivamente, x / 2 ^ Y.

525
00:36:08,380 --> 00:36:11,200
Así que ahora, aquí, es una idea similar.

526
00:36:11,200 --> 00:36:18,720
¿Por qué es sólo aproximadamente x / 2 ^ y, y en realidad no x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
Porque si yo había cambiado por 4, me habría perdido un 1.

528
00:36:22,240 --> 00:36:25,950
Básicamente, lo que piensa de, basta pensar en la división entera en general.

529
00:36:25,950 --> 00:36:31,070
Así que, como 5/2 es 2. No es 2,5.

530
00:36:31,070 --> 00:36:35,000
Es la misma idea aquí. Al dividir por 2,

531
00:36:35,000 --> 00:36:39,910
podemos perder cosas extrañas en el camino.

532
00:36:39,910 --> 00:36:43,870
Así que ahora - eso es todo por bit a bit. Eso es todo lo que necesita saber.

533
00:36:43,870 --> 00:36:46,340
Recuerda los casos de uso que vimos en clase,

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

535
00:36:49,340 --> 00:36:53,220
o los utiliza para las máscaras de bits.

536
00:36:53,220 --> 00:36:58,620
Las letras mayúsculas y minúsculas, las conversiones, es un ejemplo muy prototípico.

537
00:36:58,620 --> 00:37:01,640
>> Bien, así que los ataques de desbordamiento de búfer.

538
00:37:01,640 --> 00:37:05,110
Alguien se acuerda de lo que estaba mal con esta función?

539
00:37:05,110 --> 00:37:10,140
Aviso declaramos un arreglo de 12 bytes, 12 caracteres,

540
00:37:10,140 --> 00:37:18,510
y luego copiamos en nuestro buffer de 12 caracteres toda la barra de cadena.

541
00:37:18,510 --> 00:37:25,080
¿Entonces cuál es el problema aquí?

542
00:37:25,080 --> 00:37:32,270
El número mágico 12 debería aparecer casi inmediatamente como - ¿por qué 12?

543
00:37:32,270 --> 00:37:35,050
¿Qué pasa si la barra pasa a ser más de 12 caracteres?

544
00:37:35,050 --> 00:37:41,200
¿Qué pasa si la barra es de millones de caracteres?

545
00:37:41,200 --> 00:37:46,010
Aquí la cuestión es memcpy. Si la barra es el tiempo suficiente,

546
00:37:46,010 --> 00:37:50,330
se acaba por completo - 'c', 'c' no le importa que se trataba de sólo 12 caracteres;

547
00:37:50,330 --> 00:37:53,280
'C' no le importa que no puede caber de que muchos bytes.

548
00:37:53,280 --> 00:37:58,250
Se sobrescribirá completamente solo char, los 12 bytes que hemos asignado para ello,

549
00:37:58,250 --> 00:38:01,830
y todo lo pasado en la memoria que en realidad no pertenecen a ese búfer

550
00:38:01,830 --> 00:38:06,520
con lo que la barra de cadena es.

551
00:38:06,520 --> 00:38:09,780
Así que esta era la imagen que vimos en clase

552
00:38:09,780 --> 00:38:12,220
donde tenemos nuestra pila crecía.

553
00:38:12,220 --> 00:38:16,040
Usted debe estar acostumbrado a estas fotos o familiarizarse con ellos de nuevo.

554
00:38:16,040 --> 00:38:21,260
Hemos nuestra pila crecía, las direcciones de memoria comienzan en 0 en la parte superior

555
00:38:21,260 --> 00:38:26,270
y crecer hasta gustaría 4000000000 en la parte inferior.

556
00:38:26,270 --> 00:38:28,820
Tenemos nuestra array 'c' en algún lugar de la memoria,

557
00:38:28,820 --> 00:38:32,260
entonces tenemos nuestro puntero al bar justo debajo de ella,

558
00:38:32,260 --> 00:38:38,720
y luego tenemos este puntero guardado en nuestra dirección de retorno y de la pila de la rutina de los padres.

559
00:38:38,720 --> 00:38:40,800
Recuerda lo que la dirección de retorno es?

560
00:38:40,800 --> 00:38:45,360
Es cuando principal llama a una función foo, llama a una barra de funciones,

561
00:38:45,360 --> 00:38:48,100
inevitablemente, bar devoluciones.

562
00:38:48,100 --> 00:38:52,610
Así que cuando los rendimientos de barras, lo que necesitan saber de que va a foo, que lo llamó.

563
00:38:52,610 --> 00:39:01,360
Así que la dirección de retorno es la dirección de la función que tiene que volver a cuando se devuelve la función.

564
00:39:01,360 --> 00:39:05,830
La razón por la que es importante para los ataques de desbordamiento de búfer se debe a que, convenientemente,

565
00:39:05,830 --> 00:39:09,580
hackers les gusta cambiar eso remite.

566
00:39:09,580 --> 00:39:14,950
En vez de volver a foo, voy a volver a donde el hacker quiere que vaya de nuevo a.

567
00:39:14,950 --> 00:39:17,760
Y, convenientemente, donde el hacker con frecuencia quiere volver a

568
00:39:17,760 --> 00:39:22,400
es el principio del búfer que teníamos originalmente.

569
00:39:22,400 --> 00:39:26,170
Así que darse cuenta, de nuevo, Little Indian.

570
00:39:26,170 --> 00:39:28,490
El aparato es un ejemplo de un sistema indio de Little,

571
00:39:28,490 --> 00:39:34,140
por lo que un número entero o un puntero se almacena con los bytes invertidos.

572
00:39:34,140 --> 00:39:38,980
Así que aquí vemos - es esto? Sí.

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

574
00:39:45,660 --> 00:39:48,250
Recuerde que los dígitos hexadecimales?

575
00:39:48,250 --> 00:39:50,640
Nosotros no invertimos los dígitos hexadecimales en Little Indian,

576
00:39:50,640 --> 00:39:56,110
porque 2 dígitos hexadecimales representan un solo byte, y revertir los bytes.

577
00:39:56,110 --> 00:40:00,300
Es por eso que nosotros no almacenamos, como, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Almacenamos, en su lugar, cada par de 2 dígitos, empezando desde la derecha.

579
00:40:07,520 --> 00:40:10,880
Esa dirección se refiere a la dirección de inicio

580
00:40:10,880 --> 00:40:15,190
de nuestro buffer que realmente queríamos copiar en en el primer lugar.

581
00:40:15,190 --> 00:40:19,230
La razón de que es útil es porque, ¿y si el atacante

582
00:40:19,230 --> 00:40:24,100
sucedido a, en lugar de tener una cadena que sólo era

583
00:40:24,100 --> 00:40:27,060
una cadena inofensiva como su nombre o algo,

584
00:40:27,060 --> 00:40:33,900
¿y si, en cambio, que la cadena fueron sólo algunos de código arbitrario

585
00:40:33,900 --> 00:40:38,610
que hacían lo que querían que hiciera?

586
00:40:38,610 --> 00:40:45,630
Para que pudieran - no puedo pensar en ningún código cool.

587
00:40:45,630 --> 00:40:47,780
Podría ser cualquier cosa, sin embargo. Cualquier código desastroso.

588
00:40:47,780 --> 00:40:51,440
Si quisieran, podrían simplemente hacer algo en fallas seg, pero eso no tendría sentido.

589
00:40:51,440 --> 00:40:54,950
Por lo general, lo hacen para hackear el sistema.

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

591
00:40:59,930 --> 00:41:04,800
Esto es, básicamente, getInt, getString, todas aquellas funciones que le proporciona.

592
00:41:04,800 --> 00:41:10,630
Así que tenemos char * cadena, y esa es la abstracción que nos impresionaron mucho

593
00:41:10,630 --> 00:41:12,450
en algún momento durante el semestre.

594
00:41:12,450 --> 00:41:18,220
Recuerde que una cadena es sólo un conjunto de caracteres.

595
00:41:18,220 --> 00:41:23,240
Así que aquí vemos una versión abreviada de getString.

596
00:41:23,240 --> 00:41:25,920
Usted debe mirar hacia atrás en lo que hay que recordar cómo se aplica realmente.

597
00:41:25,920 --> 00:41:30,950
Los detalles clave son, notamos que obtenemos en un solo carácter a la vez

598
00:41:30,950 --> 00:41:34,570
de la norma, lo cual es lo mismo que nosotros escribiéndolo en el teclado.

599
00:41:34,570 --> 00:41:37,890
Así que un solo carácter a la vez, y si conseguimos demasiados caracteres,

600
00:41:37,890 --> 00:41:40,580
por lo que si n + 1 es mayor que la capacidad,

601
00:41:40,580 --> 00:41:44,140
entonces tenemos que aumentar la capacidad de nuestra memoria intermedia.

602
00:41:44,140 --> 00:41:47,780
Así que aquí estamos duplicando el tamaño de nuestro buffer.

603
00:41:47,780 --> 00:41:51,840
Y eso sigue adelante; insertamos el carácter en nuestro buffer

604
00:41:51,840 --> 00:41:56,220
hasta que recibamos una nueva línea o al final del archivo o lo que sea,

605
00:41:56,220 --> 00:41:59,380
en cuyo caso, hemos terminado con la cadena y luego el verdadero getString

606
00:41:59,380 --> 00:42:05,120
contrae la memoria, como si nos dieron demasiada memoria que va a ir hacia atrás y reducir un poco.

607
00:42:05,120 --> 00:42:08,830
Así que no demostramos eso, pero la idea principal es

608
00:42:08,830 --> 00:42:11,960
que tiene que leer en un solo carácter a la vez.

609
00:42:11,960 --> 00:42:17,140
No se acaba de leer en toda una cosa a la vez,

610
00:42:17,140 --> 00:42:19,550
debido a que su memoria intermedia es sólo de un cierto tamaño.

611
00:42:19,550 --> 00:42:26,590
Así que si la cadena que intenta introducir en el búfer es demasiado grande, entonces se desborde.

612
00:42:26,590 --> 00:42:28,940
Así que aquí nos prevenimos de que sólo la lectura en un solo carácter

613
00:42:28,940 --> 00:42:33,750
a la vez y cada vez más cada vez que necesitamos.

614
00:42:33,750 --> 00:42:40,270
Así getInt y las otras funciones de la biblioteca CS50 tienden a utilizar getString

615
00:42:40,270 --> 00:42:42,310
en sus implementaciones.

616
00:42:42,310 --> 00:42:45,370
Así que puse de relieve las cosas importantes aquí.

617
00:42:45,370 --> 00:42:49,460
Llama getString para obtener una cadena.

618
00:42:49,460 --> 00:42:51,710
Si getString no regresó a la memoria,

619
00:42:51,710 --> 00:42:54,270
recuerde que getString mallocs algo, así que cada vez que se llama a getString

620
00:42:54,270 --> 00:42:57,820
usted no debe (ininteligible) gratis esa cadena que te daban.

621
00:42:57,820 --> 00:43:02,870
Así que aquí, si no lograba malloc algo, volvemos INT_MAX sólo como una bandera que,

622
00:43:02,870 --> 00:43:05,650
bueno, no estábamos realmente capaces de obtener un número entero.

623
00:43:05,650 --> 00:43:10,830
Usted debe ignorar lo vuelvo a ti, o

624
00:43:10,830 --> 00:43:15,540
usted no debe tratar esto como una entrada válida.

625
00:43:15,540 --> 00:43:21,360
Por último, en el supuesto de que tuvieron éxito, utilizamos sscanf con esa bandera especial,

626
00:43:21,360 --> 00:43:23,820
lo que significa, primero que coincida con un número entero,

627
00:43:23,820 --> 00:43:26,770
entonces coincidir cualquier carácter después de ese entero.

628
00:43:26,770 --> 00:43:29,070
Así notamos que queremos que sea igual a 1.

629
00:43:29,070 --> 00:43:32,940
Así que vuelve sscanf cuántos partidos si hicieron con éxito?

630
00:43:32,940 --> 00:43:37,010
Se devolverá 1 si coincide con éxito un número entero,

631
00:43:37,010 --> 00:43:40,890
devolverá 0 si no ha coincidido con un entero, y ha de devolver 2

632
00:43:40,890 --> 00:43:45,920
si coincide con un número entero seguido de un poco de carácter.

633
00:43:45,920 --> 00:43:49,780
Así notamos que la recomprobación si igualamos cualquier cosa menos 1.

634
00:43:49,780 --> 00:43:55,230
Así que si entramos en 1, 2, 3, C, o 1, 2, 3, X,

635
00:43:55,230 --> 00:43:57,400
a continuación, 1, 2, 3 que se almacena en el número entero,

636
00:43:57,400 --> 00:43:59,620
X sería se almacenan en el carácter,

637
00:43:59,620 --> 00:44:06,410
sscanf volverían 2, y nos gustaría volver a intentar, porque sólo queremos un entero.

638
00:44:06,410 --> 00:44:09,810
>> Soplar rápidamente a través de HTML, HTTP, CSS.

639
00:44:09,810 --> 00:44:15,340
HyperText Markup Language es la estructura y la semántica de la web.

640
00:44:15,340 --> 00:44:19,960
Aquí está el ejemplo de la conferencia donde tenemos etiquetas HTML.

641
00:44:19,960 --> 00:44:22,110
Tenemos etiquetas de la cabeza, las etiquetas de cuerpo,

642
00:44:22,110 --> 00:44:27,770
tenemos ejemplos de etiquetas vacías donde en realidad no tienen un inicio y cierre de etiquetas,

643
00:44:27,770 --> 00:44:30,820
sólo tenemos enlace y la imagen.

644
00:44:30,820 --> 00:44:38,480
No hay cierre de imagen de la placa; sólo hay una única etiqueta que lleva a cabo todo lo que la etiqueta tiene que hacer.

645
00:44:38,480 --> 00:44:41,950
El enlace es un ejemplo, vamos a ver cómo se vincula a CSS,

646
00:44:41,950 --> 00:44:45,910
el guión es un ejemplo de cómo se vincula a un JavaScript externo.

647
00:44:45,910 --> 00:44:53,100
Es bastante sencillo, y recuerda, HTML no es un lenguaje de programación.

648
00:44:53,100 --> 00:44:58,250
En este sentido, recuerda cómo se defina un formulario o por lo menos lo que esto haría?

649
00:44:58,250 --> 00:45:01,740
Tal forma tiene una acción y un método.

650
00:45:01,740 --> 00:45:06,210
Los métodos que usted sólo alguna vez ver son GET y POST.

651
00:45:06,210 --> 00:45:09,040
Así se obtiene es la versión en la que lo consigue puesto en la URL.

652
00:45:09,040 --> 00:45:11,680
POST es donde no se pone en la URL.

653
00:45:11,680 --> 00:45:18,520
En su lugar, todos los datos del formulario se inserta más oculto en la petición HTTP.

654
00:45:18,520 --> 00:45:22,390
Así que aquí, la acción define dónde va la petición HTTP.

655
00:45:22,390 --> 00:45:27,490
¿Dónde se va es google.com / categoría.

656
00:45:27,490 --> 00:45:32,890
Método. Recuerde que las diferencias entre GET y POST,

657
00:45:32,890 --> 00:45:37,200
y, acaba de decir como un ejemplo, si usted desea marcar algo.

658
00:45:37,200 --> 00:45:40,660
Usted nunca será capaz de marcar un URL POSTE

659
00:45:40,660 --> 00:45:44,970
porque los datos no está incluido en el URL.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, ahora, es el Protocolo de transferencia de hipertexto.

661
00:45:49,790 --> 00:45:54,080
El Protocolo de transferencia de hipertexto, que se puede esperar para transferir

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

663
00:45:57,710 --> 00:46:00,170
Pero también transfiere las imágenes que encuentre en la Web,

664
00:46:00,170 --> 00:46:05,400
ningún tipo de descarga que realice comienzan como una solicitud HTTP.

665
00:46:05,400 --> 00:46:10,350
Así que HTTP es sólo el lenguaje de la World Wide Web.

666
00:46:10,350 --> 00:46:15,610
Y aquí es necesario reconocer este tipo de una solicitud HTTP.

667
00:46:15,610 --> 00:46:19,300
Aquí HTTP/1.1 en el lado sólo dice que esa es la versión

668
00:46:19,300 --> 00:46:21,570
del protocolo que estoy usando.

669
00:46:21,570 --> 00:46:25,770
Es casi siempre va a ser HTTP/1.1, ya lo verás.

670
00:46:25,770 --> 00:46:30,110
Entonces vemos que este fue GET, siendo la alternativa POST, que se pueden ver.

671
00:46:30,110 --> 00:46:40,790
Y la dirección que yo estaba tratando de visitar era www.google.com/search?q = bla, bla, bla.

672
00:46:40,790 --> 00:46:44,240
Así que recuerde que este, el signo de interrogación q = bla, bla, bla,

673
00:46:44,240 --> 00:46:49,040
es el tipo de cosas que se envía por un formulario.

674
00:46:49,040 --> 00:46:51,830
La respuesta podría volver a mí sería algo como esto.

675
00:46:51,830 --> 00:46:54,050
Una vez más, empezando por el protocolo, el cual va a ser eso,

676
00:46:54,050 --> 00:46:59,190
seguido por el código de estado. Aquí es 200 OK.

677
00:46:59,190 --> 00:47:05,060
Y, por último, la página web que en realidad pedí será seguido.

678
00:47:05,060 --> 00:47:08,210
La posible código de estado que puede ver, y usted debe saber varios de ellos.

679
00:47:08,210 --> 00:47:12,770
200 OK es probable que haya visto antes.

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

681
00:47:17,830 --> 00:47:22,140
es por lo general si usted va a un sitio web y algún elemento no funciona o se bloquea su código PHP,

682
00:47:22,140 --> 00:47:24,930
mientras que en el aparato que tenemos de que el rectángulo anaranjado grande

683
00:47:24,930 --> 00:47:27,830
que viene y dice, como, algo está mal, este código no funciona

684
00:47:27,830 --> 00:47:30,380
o de mal esta función.

685
00:47:30,380 --> 00:47:33,230
Por lo general, los sitios web no quieren que usted lo sepa qué funciones son realmente malo,

686
00:47:33,230 --> 00:47:37,880
así que en vez de eso sólo te dan 500 errores internos del servidor.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP es 1 capa debajo de HTTP.

688
00:47:43,050 --> 00:47:47,550
Recuerde que no hay Internet fuera de la World Wide Web.

689
00:47:47,550 --> 00:47:52,270
Al igual que si usted juega un juego en línea que no pasa a través de HTTP,

690
00:47:52,270 --> 00:47:55,740
que va a través de un diferente - que todavía está usando el Internet,

691
00:47:55,740 --> 00:47:58,900
pero no utiliza HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP es sólo un ejemplo de protocolo basado en TCP / IP.

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

694
00:48:07,820 --> 00:48:11,500
Cada ordenador tiene una dirección IP, sino que son esas cosas de 4 dígitos

695
00:48:11,500 --> 00:48:16,510
como 192.168.2.1, o lo que sea, eso tiende a ser uno local.

696
00:48:16,510 --> 00:48:23,390
Pero ese es el patrón de una dirección IP.

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

698
00:48:29,060 --> 00:48:33,410
eso es lo que se traduce cosas como google.com en una dirección IP real.

699
00:48:33,410 --> 00:48:37,700
Así que si usted escribe que la dirección IP en una dirección URL,

700
00:48:37,700 --> 00:48:40,850
que traería a Google, pero que tienden a no recordar esas cosas.

701
00:48:40,850 --> 00:48:45,470
Usted tiende a recordar google.com en lugar.

702
00:48:45,470 --> 00:48:51,560
Lo último que tenemos es los puertos, en los que ésta es la parte de TCP IP.

703
00:48:51,560 --> 00:48:54,880
TCP hace más. Piensa, como, usted tiene el navegador web en funcionamiento.

704
00:48:54,880 --> 00:48:58,670
Tal vez usted tiene alguna aplicación de correo electrónico en funcionamiento;

705
00:48:58,670 --> 00:49:02,150
tal vez usted tiene algún otro programa que utiliza el funcionamiento de Internet.

706
00:49:02,150 --> 00:49:05,090
Todos ellos necesitan tener acceso a Internet,

707
00:49:05,090 --> 00:49:08,100
pero el equipo sólo tiene 1 tarjeta WiFi o lo que sea.

708
00:49:08,100 --> 00:49:10,780
Así que los puertos son la forma en que somos capaces de dividir

709
00:49:10,780 --> 00:49:13,550
cómo estas aplicaciones son capaces de utilizar la Internet.

710
00:49:13,550 --> 00:49:17,230
Cada aplicación obtiene 1 puerto específico que pueda escuchar en,

711
00:49:17,230 --> 00:49:19,670
y por defecto, HTTP utiliza el puerto 80.

712
00:49:19,670 --> 00:49:22,410
Algunos servicios de correo electrónico utilizan 25.

713
00:49:22,410 --> 00:49:24,490
Los números bajos tienden a ser reservados.

714
00:49:24,490 --> 00:49:29,270
Usted está por lo general capaces de obtener números más altos-uno por sí mismo.

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

716
00:49:32,010 --> 00:49:36,030
Páginas web Nosotros estilo con CSS, no con HTML.

717
00:49:36,030 --> 00:49:38,440
Hay 3 lugares que usted puede poner su CSS.

718
00:49:38,440 --> 00:49:46,300
Puede ser en línea, entre las etiquetas de estilo, o en un archivo completamente separado y luego vinculado pulg

719
00:49:46,300 --> 00:49:48,470
Y aquí es sólo un ejemplo de CSS.

720
00:49:48,470 --> 00:49:50,450
Usted debe reconocer este patrón,

721
00:49:50,450 --> 00:49:54,310
donde el primer ejemplo es que estamos igualando la etiqueta body,

722
00:49:54,310 --> 00:49:56,680
y aquí estamos centrando el cuerpo de la etiqueta.

723
00:49:56,680 --> 00:50:00,420
El segundo ejemplo, estamos igualando la cosa

724
00:50:00,420 --> 00:50:04,740
con identificador de pie de página, y estamos aplicando algunos estilos a eso.

725
00:50:04,740 --> 00:50:07,310
Nótese que los ID de pie de página de texto se alinea a la izquierda,

726
00:50:07,310 --> 00:50:09,840
mientras que el centro del cuerpo de texto-a línea.

727
00:50:09,840 --> 00:50:13,180
Pie de página está dentro del cuerpo.

728
00:50:13,180 --> 00:50:16,470
Será, en cambio, text-align izquierda, a pesar de que el cuerpo dice centro text-align.

729
00:50:16,470 --> 00:50:18,880
Esta es toda la parte de conexión en cascada de ella.

730
00:50:18,880 --> 00:50:22,110
Usted puede tener - se puede especificar estilos para el cuerpo,

731
00:50:22,110 --> 00:50:25,320
y entonces las cosas en el cuerpo que pueden especificar estilos más específicos,

732
00:50:25,320 --> 00:50:28,160
y las cosas funcionan como se espera.

733
00:50:28,160 --> 00:50:34,420
Especificadores CSS más específicos tienen prioridad.

734
00:50:34,420 --> 00:50:46,140
Creo que eso es todo.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Hola a todos. Si tan sólo pudiera conseguir su atención.

736
00:50:49,260 --> 00:50:53,990
Soy Ali y yo voy a ir a través de PHP y SQL muy rápido.

737
00:50:53,990 --> 00:51:00,310
Así que podemos empezar. PHP es el acrónimo de PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
Y como todos ustedes deben saber, es un lenguaje de script del lado del servidor,

739
00:51:03,730 --> 00:51:06,800
y lo usamos para el back-end de los sitios web,

740
00:51:06,800 --> 00:51:12,540
y cómo lo hace un montón de los cálculos, la parte de detrás de las escenas.

741
00:51:12,540 --> 00:51:17,510
Sintaxis. No es como C, sorpresa, sorpresa.

742
00:51:17,510 --> 00:51:22,060
Siempre tiene que comenzar con el, si usted puede ver, el - no puedo seguir adelante.

743
00:51:22,060 --> 00:51:31,340
Usted puede ver lo que necesita los nuevos tipos de aparatos ortopédicos y entonces también necesitará el php?.

744
00:51:31,340 --> 00:51:35,780
Eso siempre es como hay que encuadrar el texto PHP, el código PHP.

745
00:51:35,780 --> 00:51:39,180
Por lo tanto, no puede ser sólo como C, en el que tipo de ponerla en primer lugar.

746
00:51:39,180 --> 00:51:42,290
¡Tienes que siempre rodean.

747
00:51:42,290 --> 00:51:47,610
Y ahora, la sintaxis es importante que todas las variables deben comenzar con el carácter $.

748
00:51:47,610 --> 00:51:49,490
Que tiene que hacer cuando usted los está definiendo, que hay que hacerlo

749
00:51:49,490 --> 00:51:51,860
cuando te refieres a ellos más adelante.

750
00:51:51,860 --> 00:51:56,510
Siempre se necesita que $. Es su nuevo mejor amigo, bastante.

751
00:51:56,510 --> 00:52:01,690
Usted no - a diferencia de C, no es necesario poner el tipo de tipo de variable que es.

752
00:52:01,690 --> 00:52:04,940
Así, mientras que usted no necesita los $, usted no tiene que poner, como,

753
00:52:04,940 --> 00:52:09,470
int x o cadena y, etcétera, etcétera.

754
00:52:09,470 --> 00:52:11,490
Así que una ligera diferencia.

755
00:52:11,490 --> 00:52:15,590
Como resultado de esto, significa que PHP es un tipo débilmente.

756
00:52:15,590 --> 00:52:19,310
PHP es un lenguaje de tipo débil, y débilmente ha introducido variables.

757
00:52:19,310 --> 00:52:24,020
En otras palabras, eso significa que usted puede cambiar entre los diferentes tipos de tipos de variables.

758
00:52:24,020 --> 00:52:27,230
Puede almacenar el número 1 como un int,

759
00:52:27,230 --> 00:52:29,650
se puede almacenar como una cadena, y se puede almacenar como un flotador,

760
00:52:29,650 --> 00:52:33,550
y todo será que el número 1.

761
00:52:33,550 --> 00:52:36,080
A pesar de que usted está almacenando en diferentes formas,

762
00:52:36,080 --> 00:52:39,120
sigue siendo - los tipos de variables siguen manteniendo en el final.

763
00:52:39,120 --> 00:52:41,540
Así que si usted mira aquí, si usted recuerda de pset 7,

764
00:52:41,540 --> 00:52:43,500
muchos de ustedes probablemente tenía problemas con esto.

765
00:52:43,500 --> 00:52:47,280
Dos signos de igual, 3 signos de igual, 4 signos de igual.

766
00:52:47,280 --> 00:52:49,990
Está bien, no hay 4 signos de igual, pero hay 2 y 3.

767
00:52:49,990 --> 00:52:53,320
Utiliza 2 signos de igual para comprobar los valores.

768
00:52:53,320 --> 00:52:55,830
Se puede comprobar a través de tipos.

769
00:52:55,830 --> 00:52:58,770
Así que si usted puede ver en el primer ejemplo,

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

771
00:53:02,210 --> 00:53:06,710
Así que su int y su cadena son tanto, técnicamente, 1,

772
00:53:06,710 --> 00:53:10,790
pero son diferentes tipos. Sin embargo, para los dobles iguales, todavía pasará.

773
00:53:10,790 --> 00:53:15,510
Sin embargo, para los iguales triples, comprueba valor, así como los diferentes tipos.

774
00:53:15,510 --> 00:53:18,760
Eso significa que no va a pasar en ese segundo caso aquí,

775
00:53:18,760 --> 00:53:22,350
donde se está utilizando 3 signos igual en su lugar.

776
00:53:22,350 --> 00:53:26,590
Así que eso es una gran diferencia, a que todos han mostrado ahora.

777
00:53:26,590 --> 00:53:31,570
>> String concatenación es otra cosa de gran alcance que puede utilizar en PHP.

778
00:53:31,570 --> 00:53:34,080
Es básicamente esta notación de punto a mano,

779
00:53:34,080 --> 00:53:36,230
y así es como se puede enlazar las cadenas juntas.

780
00:53:36,230 --> 00:53:40,800
Así que si usted tiene gato y tienes perro, y quiere poner las 2 cadenas juntas,

781
00:53:40,800 --> 00:53:44,080
usted puede utilizar la época, y eso es una especie de cómo funciona.

782
00:53:44,080 --> 00:53:46,660
También se puede simplemente colocarlos uno al lado del otro,

783
00:53:46,660 --> 00:53:49,030
como se puede ver aquí en el ejemplo de abajo,

784
00:53:49,030 --> 00:53:51,610
donde he echo cadena 1, espacio cuerda 2.

785
00:53:51,610 --> 00:53:56,930
PHP sabrá que tiene que reemplazarlos como tal.

786
00:53:56,930 --> 00:53:59,780
Arrays. Ahora bien, en PHP, hay 2 tipos de matrices.

787
00:53:59,780 --> 00:54:03,180
Usted puede tener matrices regulares, y usted también puede tener matrices asociativas,

788
00:54:03,180 --> 00:54:06,040
y vamos a ir a través de ellos en este momento.

789
00:54:06,040 --> 00:54:08,280
Matrices regulares son simplemente esto en C,

790
00:54:08,280 --> 00:54:11,240
y por lo que tiene índices que están numeradas.

791
00:54:11,240 --> 00:54:13,160
En este momento sólo vamos a crear una y poner -

792
00:54:13,160 --> 00:54:15,500
así que esta es la forma de crear una matriz vacía, entonces vamos a

793
00:54:15,500 --> 00:54:17,310
puesto en el número de índice 0.

794
00:54:17,310 --> 00:54:19,200
Vamos a poner el número 6, el valor 6.

795
00:54:19,200 --> 00:54:21,500
Se puede ver en la parte inferior aquí.

796
00:54:21,500 --> 00:54:24,240
De dónde está - en el número de índice 1 nos vamos a poner del valor 4,

797
00:54:24,240 --> 00:54:26,720
y así que usted puede ver que hay un 6, hay un 4,

798
00:54:26,720 --> 00:54:29,160
y entonces como que estamos imprimiendo cosas,

799
00:54:29,160 --> 00:54:33,550
cuando intentamos e imprimimos el valor almacenado en el número de índice 0,

800
00:54:33,550 --> 00:54:36,900
entonces vamos a ver el valor 6 imprimirlos. ¿De acuerdo?

801
00:54:36,900 --> 00:54:40,160
Así que eso es matrices regulares para usted.

802
00:54:40,160 --> 00:54:42,750
Otra manera también se puede añadir cosas a las matrices normales ahora

803
00:54:42,750 --> 00:54:44,780
es que sólo puede anexarlos al final.

804
00:54:44,780 --> 00:54:47,240
Eso significa que usted no tiene que especificar el índice específico.

805
00:54:47,240 --> 00:54:51,000
Puede consultar el número y, a continuación, en los corchetes no hay ningún índice especificado.

806
00:54:51,000 --> 00:54:56,270
Y sabrá - PHP sabrá a poco añadirlo a la final de la lista, el siguiente lugar libre.

807
00:54:56,270 --> 00:54:59,190
Así se puede ver la 1 a la derecha allí en ese punto 0,

808
00:54:59,190 --> 00:55:02,690
el 2 fue allí mismo, en el primer acto.

809
00:55:02,690 --> 00:55:04,690
El 3 va - se añade allí también.

810
00:55:04,690 --> 00:55:06,720
Así que ese tipo de tiene sentido. Sólo estás constantemente añadiendo que,

811
00:55:06,720 --> 00:55:09,360
y luego, cuando estamos haciendo eco del índice de número 1,

812
00:55:09,360 --> 00:55:13,080
se imprimirá el valor 2.

813
00:55:13,080 --> 00:55:16,800
>> Luego tenemos las matrices que son matrices asociativas.

814
00:55:16,800 --> 00:55:19,370
Las matrices asociativas, en lugar de tener índices numéricos,

815
00:55:19,370 --> 00:55:23,630
lo que hacen es, tienen índices que están por cadena.

816
00:55:23,630 --> 00:55:25,670
Se puede ver, en lugar de - Me deshice de todos esos índices numéricos,

817
00:55:25,670 --> 00:55:32,140
y ahora es clave1, key2, key3, y están entre comillas dobles para significar que son todas las cadenas.

818
00:55:32,140 --> 00:55:34,470
Así que podemos tener un ejemplo de esto.

819
00:55:34,470 --> 00:55:38,790
El ejemplo de esto es que tenemos el tf, y ese es el nombre del índice.

820
00:55:38,790 --> 00:55:42,030
Nos vamos a poner "Ali", como el nombre, en el índice, las calorías consumidas,

821
00:55:42,030 --> 00:55:47,640
podemos poner un int esta vez en lugar de una cadena,

822
00:55:47,640 --> 00:55:52,240
y luego a los gustos de índice, podemos poner toda una matriz dentro de ella.

823
00:55:52,240 --> 00:55:55,490
Así que esto es una especie de - es un concepto similar a la forma en que teníamos

824
00:55:55,490 --> 00:55:58,930
índices con los números, pero ahora podemos cambiar los índices de alrededor

825
00:55:58,930 --> 00:56:03,890
de tenerlos como cadenas en lugar.

826
00:56:03,890 --> 00:56:06,070
También puede hacer esto, además de sólo hacerlo de forma individual,

827
00:56:06,070 --> 00:56:09,400
usted puede hacerlo todo en un solo trozo. Así se puede ver que tf de la matriz,

828
00:56:09,400 --> 00:56:13,350
y luego nos fuimos a todos pusimos en un juego gigante de corchete.

829
00:56:13,350 --> 00:56:15,220
Así que puede acelerar las cosas.

830
00:56:15,220 --> 00:56:19,730
Se trata más de una elección estilística que no.

831
00:56:19,730 --> 00:56:21,550
También tenemos lazos.

832
00:56:21,550 --> 00:56:26,020
En C tenemos lazos que funcionan de esta manera.

833
00:56:26,020 --> 00:56:29,690
Tuvimos nuestra matriz, y nos fuimos desde el índice 0 hasta el final de la lista,

834
00:56:29,690 --> 00:56:31,740
e imprimimos todo, ¿verdad?

835
00:56:31,740 --> 00:56:33,880
Salvo el problema es, para matrices asociativas,

836
00:56:33,880 --> 00:56:36,610
no sabemos necesariamente los índices numéricos

837
00:56:36,610 --> 00:56:39,610
porque ahora tenemos a los índices de las cadenas.

838
00:56:39,610 --> 00:56:44,800
Ahora usamos bucles foreach, que, de nuevo, que utilizó con suerte en pset 7.

839
00:56:44,800 --> 00:56:48,930
Bucles Foreach se acaba de conocer cada parte de la lista.

840
00:56:48,930 --> 00:56:52,450
Y no tiene que saber exactamente el índice numérico que usted tiene.

841
00:56:52,450 --> 00:56:56,490
Por lo que tiene la sintaxis foreach, así que es foreach, se pone la matriz.

842
00:56:56,490 --> 00:57:00,430
Así que mi matriz se llama conjunto de procesadores, y luego como, la palabra como,

843
00:57:00,430 --> 00:57:04,530
y luego se pone esta variable temporal local que se va a utilizar

844
00:57:04,530 --> 00:57:10,690
sólo por la acción específica que va a sostener el concreto -

845
00:57:10,690 --> 00:57:14,770
una instancia o una sección de la matriz.

846
00:57:14,770 --> 00:57:18,350
Num Pset celebrará 1, y luego tal vez se llevará a cabo el número 6,

847
00:57:18,350 --> 00:57:20,410
y luego se llevará a cabo el número 2.

848
00:57:20,410 --> 00:57:26,630
Pero está garantizado que pasar por cada valor único que está en la matriz.

849
00:57:26,630 --> 00:57:30,530
Funciones útiles que usted debe saber en PHP son el requerir,

850
00:57:30,530 --> 00:57:35,880
de manera que se asegura de que usted está incluyendo algunos archivos, eco, salida, vacío.

851
00:57:35,880 --> 00:57:40,490
Le recomiendo que mire pset 7 y mirar esas funciones.

852
00:57:40,490 --> 00:57:42,810
Puede que tenga que conocer a aquellos,

853
00:57:42,810 --> 00:57:47,060
así que sin duda sabe lo que es, exactamente, los que todos estamos haciendo.

854
00:57:47,060 --> 00:57:50,080
>> Y ahora vamos a ir a través de alcance muy rápidamente.

855
00:57:50,080 --> 00:57:53,490
En el alcance, PHP es una especie de cosa cobarde, a diferencia de C,

856
00:57:53,490 --> 00:57:56,170
por lo que sólo vamos a ir a través de él rápidamente.

857
00:57:56,170 --> 00:57:58,930
Así que digamos que empezamos en esa flecha que tenemos allí.

858
00:57:58,930 --> 00:58:02,900
Y vamos a comenzar con $ i. Así que la variable 'i' va a ser 0,

859
00:58:02,900 --> 00:58:06,730
y sólo vamos a seguir imprimiendo en ese gran cuadro blanco de allá.

860
00:58:06,730 --> 00:58:09,220
Vamos a comenzar con i0, y luego vamos a repetir ella.

861
00:58:09,220 --> 00:58:12,670
Así que ahí está el 0.

862
00:58:12,670 --> 00:58:15,210
Y luego vamos a incrementarlo en el bucle para,

863
00:58:15,210 --> 00:58:17,810
y luego que va a ser el valor de 1.

864
00:58:17,810 --> 00:58:20,070
Uno de ellos es menor de 3, por lo que va a pasar a través de ese bucle,

865
00:58:20,070 --> 00:58:23,230
y luego vamos a verlo impreso de nuevo.

866
00:58:23,230 --> 00:58:25,520
Vamos a incrementar de nuevo a 2,

867
00:58:25,520 --> 00:58:29,860
y 2 es menor que 3, por lo que te pasará el bucle for, y va a imprimir la 2.

868
00:58:29,860 --> 00:58:35,100
Entonces se le nota que 3 no es menor que 3, así que vas a romper fuera del bucle for.

869
00:58:35,100 --> 00:58:40,050
Así que ahora que hemos terminado y, a continuación, vamos a entrar en AFunction.

870
00:58:40,050 --> 00:58:45,010
Okay. Así que hay que señalar que esta variable que hemos creado,

871
00:58:45,010 --> 00:58:48,270
la variable 'i', no está en el ámbito local.

872
00:58:48,270 --> 00:58:50,280
Eso significa que no es local para el bucle,

873
00:58:50,280 --> 00:58:58,060
y que la variable que todavía puede acceder y cambiar después, y todavía será eficaz.

874
00:58:58,060 --> 00:59:02,160
Así que si vas a la función ahora, verás que también utilizamos la variable 'i',

875
00:59:02,160 --> 00:59:05,320
y vamos a incrementar 'i' + +.

876
00:59:05,320 --> 00:59:09,410
Se podría pensar que, en un primer momento, sobre la base de C, que es una copia de la variable 'i'.

877
00:59:09,410 --> 00:59:12,830
Es una cosa totalmente diferente, lo cual es correcto.

878
00:59:12,830 --> 00:59:16,560
Así que cuando imprimimos, vamos a imprimir 'i' + +, que se va a imprimir que 4,

879
00:59:16,560 --> 00:59:19,640
y luego vamos a - lo siento.

880
00:59:19,640 --> 00:59:22,030
Entonces vamos a terminar de esa función,

881
00:59:22,030 --> 00:59:24,820
y nosotros vamos a estar donde la flecha es en estos momentos.

882
00:59:24,820 --> 00:59:29,190
Eso quiere decir que entonces, sin embargo, a pesar de que la función cambia el valor de 'i',

883
00:59:29,190 --> 00:59:32,620
no cambió fuera de la función,

884
00:59:32,620 --> 00:59:35,060
debido a que la función tiene un ámbito de aplicación separada.

885
00:59:35,060 --> 00:59:38,960
Eso significa que cuando nos hacemos eco de 'i', no ha cambiado en el ámbito de la función,

886
00:59:38,960 --> 00:59:43,660
y así, vamos a imprimir 3 de nuevo.

887
00:59:43,660 --> 00:59:47,520
Diferentes cosas sobre el alcance en PHP que en C.

888
00:59:47,520 --> 00:59:51,130
>> Ahora en PHP y HTML.

889
00:59:51,130 --> 00:59:53,510
PHP es usado para hacer páginas web dinámicas.

890
00:59:53,510 --> 00:59:58,660
Es algo que hace que las cosas diferente.

891
00:59:58,660 --> 01:00:02,090
Tenemos diferente de HTML.

892
01:00:02,090 --> 01:00:05,230
Con HTML, siempre sólo tenemos la misma cosa estática, como la forma de Rob mostró,

893
01:00:05,230 --> 01:00:09,370
mientras que PHP, puede cambiar las cosas en función de quién es el usuario.

894
01:00:09,370 --> 01:00:11,830
Así que si tengo esto, he, "ha iniciado la sesión como -" y luego el nombre,

895
01:00:11,830 --> 01:00:14,420
y puedo cambiar el nombre. Así que ahora el nombre es José,

896
01:00:14,420 --> 01:00:18,880
y tiene el "Acerca de mí", pero luego también puede cambiar el nombre a tener Tommy.

897
01:00:18,880 --> 01:00:21,700
Y eso sería una cosa diferente.

898
01:00:21,700 --> 01:00:23,840
Así que también podemos cambiar las cosas diferentes acerca de él,

899
01:00:23,840 --> 01:00:27,070
y se mostrará un contenido diferente en función del nombre.

900
01:00:27,070 --> 01:00:31,430
Así que PHP puede tipo de cambiar lo que está pasando en su sitio web.

901
01:00:31,430 --> 01:00:33,540
Lo mismo digo. Sin embargo, tenga en cuenta que tienen un contenido diferente,

902
01:00:33,540 --> 01:00:38,870
a pesar de que usted está técnicamente aún accediendo esa misma página web en la superficie.

903
01:00:38,870 --> 01:00:43,450
Generación de HTML. Hay 2 maneras diferentes que usted puede hacer esto.

904
01:00:43,450 --> 01:00:48,980
Así que vamos a pasar por eso en este momento. La primera manera es, usted tiene - sí, lo siento.

905
01:00:48,980 --> 01:00:51,150
Por lo que sólo tiene su habitual ciclo for en PHP,

906
01:00:51,150 --> 01:00:56,270
y luego le echo en PHP y echo fuera HTML.

907
01:00:56,270 --> 01:00:58,720
Usando lo que Rob le mostró de escritura HTML

908
01:00:58,720 --> 01:01:04,030
y luego utilizando la impresión PHP simplemente imprimirlo para la página web.

909
01:01:04,030 --> 01:01:09,520
La forma alternativa es hacerlo como si se separa el PHP y el código HTML.

910
01:01:09,520 --> 01:01:11,940
Así que usted puede tener una línea de PHP que se inicia el bucle for,

911
01:01:11,940 --> 01:01:16,020
entonces usted puede tener la línea del HTML en una cosa separada,

912
01:01:16,020 --> 01:01:19,700
y luego se termina el bucle, de nuevo, con un PHP.

913
01:01:19,700 --> 01:01:21,800
Así que es una especie de separar a cabo.

914
01:01:21,800 --> 01:01:24,020
En el lado izquierdo, puede que usted tenga toda la -

915
01:01:24,020 --> 01:01:26,360
es solo 1 trozo de PHP.

916
01:01:26,360 --> 01:01:28,510
A la derecha se puede ver que tiene una línea de PHP,

917
01:01:28,510 --> 01:01:32,540
dispone de una línea de HTML, y tiene una línea de PHP de nuevo.

918
01:01:32,540 --> 01:01:36,870
Así que lo separa hacia fuera en lo que están haciendo.

919
01:01:36,870 --> 01:01:39,330
Y se le nota que de cualquier manera, para cualquiera de ellos,

920
01:01:39,330 --> 01:01:41,980
todavía imprimen la imagen, la imagen, la imagen,

921
01:01:41,980 --> 01:01:44,540
de modo que el HTML todavía se imprime la misma manera.

922
01:01:44,540 --> 01:01:49,870
Y entonces usted todavía ve las 3 imágenes aparecen en su sitio web.

923
01:01:49,870 --> 01:01:52,820
Así que es de 2 maneras diferentes de hacer lo mismo.

924
01:01:52,820 --> 01:01:55,060
>> Ahora tenemos formularios y solicitudes. Como Rob le mostró,

925
01:01:55,060 --> 01:01:59,400
hay formas de HTML, y nosotros simplemente brisa a través de esto.

926
01:01:59,400 --> 01:02:02,040
Usted tiene una acción y tiene un método, y su acción

927
01:02:02,040 --> 01:02:04,350
amable de su parte en la que va a enviar se nota, y el método es si

928
01:02:04,350 --> 01:02:06,960
que va a ser un GET o un POST.

929
01:02:06,960 --> 01:02:11,220
Y una petición GET, como dijo Rob, significa que usted va a poner en un formulario

930
01:02:11,220 --> 01:02:15,760
y verás como un URL, mientras que una petición POST que no verá en una URL.

931
01:02:15,760 --> 01:02:17,840
Así que una ligera diferencia.

932
01:02:17,840 --> 01:02:19,950
Sin embargo, una cosa que es una cosa similar

933
01:02:19,950 --> 01:02:22,560
es que POST y GET son igualmente inseguro.

934
01:02:22,560 --> 01:02:26,430
Así que usted puede pensar que sólo porque usted no lo ve en la URL,

935
01:02:26,430 --> 01:02:28,790
eso significa que el POST es más seguro,

936
01:02:28,790 --> 01:02:34,420
pero todavía se puede ver en tus galletas en la información que usted está enviando.

937
01:02:34,420 --> 01:02:38,260
Así que no creo que alrededor de uno o del otro.

938
01:02:38,260 --> 01:02:42,160
Otra cosa a tener en cuenta es que usted también tiene variables de sección.

939
01:02:42,160 --> 01:02:45,850
Ustedes utilizan esto en pset 7 para obtener su información de ID de usuario.

940
01:02:45,850 --> 01:02:48,550
Lo que pasó es que se puede utilizar esta matriz asociativa,

941
01:02:48,550 --> 01:02:53,310
la $ _SESSION, y luego usted es capaz de acceder a diferentes cosas

942
01:02:53,310 --> 01:02:57,720
y almacenar las cosas diferentes a través de las páginas.

943
01:02:57,720 --> 01:03:00,750
>> La última cosa es que tenemos SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
y este es un lenguaje de programación para gestionar bases de datos.

945
01:03:04,360 --> 01:03:08,220
¿Qué, exactamente, son las bases de datos? Son colecciones de tablas,

946
01:03:08,220 --> 01:03:10,630
y cada tabla puede tener el mismo género de objetos.

947
01:03:10,630 --> 01:03:14,990
Así que tuvimos una tabla de usuarios en su conjunto de procesadores finanzas.

948
01:03:14,990 --> 01:03:20,610
¿Y por qué son útiles? Porque es una forma de almacenar permanentemente información.

949
01:03:20,610 --> 01:03:22,840
Es una forma de seguimiento de las cosas y la gestión de las cosas

950
01:03:22,840 --> 01:03:25,890
y de hecho de ver que en distintas páginas y hacer el seguimiento.

951
01:03:25,890 --> 01:03:29,930
Mientras que si usted acaba de guardarlo en ese momento inmediato

952
01:03:29,930 --> 01:03:33,720
y luego usarlo más tarde, usted no será capaz de acceder a cualquier cosa que te has ahorrado.

953
01:03:33,720 --> 01:03:37,660
Tenemos 4 cosas principales que utilizamos para los comandos SQL.

954
01:03:37,660 --> 01:03:40,190
Tenemos seleccionar, insertar, eliminar y actualizar.

955
01:03:40,190 --> 01:03:42,880
Esos son realmente importantes para que sepan de su concurso.

956
01:03:42,880 --> 01:03:45,990
>> Iremos rápidamente sobre Seleccionamos estos momentos.

957
01:03:45,990 --> 01:03:48,540
Básicamente, usted está seleccionando las filas de una base de datos.

958
01:03:48,540 --> 01:03:52,400
Así que si tienes, aquí -

959
01:03:52,400 --> 01:03:56,740
tenemos estas 2 cosas diferentes, y queremos seleccionar de la tabla de clases

960
01:03:56,740 --> 01:04:01,480
donde impresionante - donde en la columna impresionante el valor es 1.

961
01:04:01,480 --> 01:04:04,460
Así que usted puede ver aquí, tenemos estas 2 cosas del nombre de la clase,

962
01:04:04,460 --> 01:04:08,490
CS50 y Stat110, y contamos con los identificadores de clase y el lema.

963
01:04:08,490 --> 01:04:13,150
Así que queremos seleccionar toda esa información.

964
01:04:13,150 --> 01:04:17,480
A continuación se puede ver aquí que es una especie de escoger de esa columna impresionante,

965
01:04:17,480 --> 01:04:25,170
donde todas las cosas son 1, y luego tiene la clase de identificación, nombre de la clase y el lema que se puede escoger.

966
01:04:25,170 --> 01:04:28,100
¿Cómo es exactamente lo que hace esto en el código? Usted tiene que usar PHP.

967
01:04:28,100 --> 01:04:33,830
Así que es una especie de cómo PHP y SQL están relacionados entre sí.

968
01:04:33,830 --> 01:04:38,130
Ahora tenemos nuestro código, y vamos a utilizar nuestra función de consulta

969
01:04:38,130 --> 01:04:41,370
como lo hicimos en pset 7, y que vamos a ejecutar la consulta SQL.

970
01:04:41,370 --> 01:04:43,870
Entonces vamos a tener -

971
01:04:43,870 --> 01:04:46,280
siempre tenemos que comprobar si la triple fila igual si es falso.

972
01:04:46,280 --> 01:04:49,010
Así que de nuevo, que desea comprobar el tipo y el valor,

973
01:04:49,010 --> 01:04:53,880
y luego, si no funciona, entonces usted quiere pedir disculpas, como de costumbre, como lo hicimos en pset 7.

974
01:04:53,880 --> 01:04:55,870
De lo contrario, usted quiere recorrer todo con aquellos útil

975
01:04:55,870 --> 01:04:59,410
foreach bucle que nos fuimos de nuevo.

976
01:04:59,410 --> 01:05:01,280
Ahora que estamos recorriendo y hemos hecho más allá,

977
01:05:01,280 --> 01:05:05,080
vamos a suponer que nuestra consulta pasó, ahora tenemos nuestro bucle foreach.

978
01:05:05,080 --> 01:05:11,050
Y la primera fila que tiene, así que aquí está la fila, aquí, sino que está en caja.

979
01:05:11,050 --> 01:05:14,010
Se va a imprimir toda la información que se ha vuelto.

980
01:05:14,010 --> 01:05:18,070
Así que va a imprimir en la parte inferior "¿Quieres aprender HTML?"

981
01:05:18,070 --> 01:05:23,370
Luego se va a ir a la siguiente fila, porque está completa la primera bucle for,

982
01:05:23,370 --> 01:05:26,510
y por lo que también va a imprimir la segunda línea de la misma,

983
01:05:26,510 --> 01:05:32,120
que va a ser STAT110, encontrar todos los momentos.

984
01:05:32,120 --> 01:05:34,290
>> Una última cosa es en SQL vulnerabilidades.

985
01:05:34,290 --> 01:05:37,300
Sé que David se refirió a esto un poco en la conferencia.

986
01:05:37,300 --> 01:05:40,730
Usted puede leer más tarde. Es realmente gracioso.

987
01:05:40,730 --> 01:05:45,320
Inyección SQL es una especie de cosa difícil.

988
01:05:45,320 --> 01:05:49,890
Digamos que usted acaba de pegar esas variables a la derecha en la consulta,

989
01:05:49,890 --> 01:05:52,290
como se puede ver en la primera línea.

990
01:05:52,290 --> 01:05:54,520
Por lo tanto, parece estar bien, ¿verdad? No eres más que poner el nombre de usuario

991
01:05:54,520 --> 01:05:58,820
y una contraseña para su consulta de SQL, y usted quiere enviarlo fuera y obtener lo que está en la tabla de datos.

992
01:05:58,820 --> 01:06:01,450
Esto parece bastante simple. Así que digamos que alguien pone en,

993
01:06:01,450 --> 01:06:04,910
para la contraseña, este o el texto aquí -

994
01:06:04,910 --> 01:06:06,780
en realidad debería estar en el cuadro rojo.

995
01:06:06,780 --> 01:06:11,920
Así que digamos que ponen esa contraseña en - que es lo que entran.

996
01:06:11,920 --> 01:06:16,520
Así que están poniendo o "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Es una especie de contraseña tonto tener.

998
01:06:20,880 --> 01:06:25,070
Ahora vamos a reemplazarlo en consejos, se tenga en cuenta que en esa consulta SQL ahora,

999
01:06:25,070 --> 01:06:29,090
se evalúa como siempre es cierto, porque se le nota que

1000
01:06:29,090 --> 01:06:32,240
puedes consulta SQL seleccionar toda esta información

1001
01:06:32,240 --> 01:06:35,420
o simplemente puede tener 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
Así que siempre se va a evaluar a true.

1003
01:06:41,030 --> 01:06:46,610
Eso no va a trabajar de verdad, porque eso significa que el hacker puede entrar en su sistema.

1004
01:06:46,610 --> 01:06:49,300
La solución a esto es que usted tiene que usar el sistema de DOP,

1005
01:06:49,300 --> 01:06:51,360
lo que significa que usted tiene que utilizar signos de interrogación,

1006
01:06:51,360 --> 01:06:53,350
que es lo que ustedes utilizan en pset 7,

1007
01:06:53,350 --> 01:06:57,620
donde se va a utilizar un signo de interrogación en lugar de en la que desea poner algo,

1008
01:06:57,620 --> 01:07:01,430
y luego te vas a tener una coma, y ​​luego usted tendrá después,

1009
01:07:01,430 --> 01:07:07,610
después de su cadena, las diferentes variables que desea sustituir en su signo de interrogación.

1010
01:07:07,610 --> 01:07:10,330
Así podrás notar aquí que ahora tengo estos signos de interrogación rojo.

1011
01:07:10,330 --> 01:07:15,420
Luego puse las variables después de mis cadenas, así que sé que reemplazarlos en ese orden después.

1012
01:07:15,420 --> 01:07:18,470
Esto se asegurará de que si alguien lo hace así,

1013
01:07:18,470 --> 01:07:24,050
y tienen la o 1 = 1 situación, que se asegurará,

1014
01:07:24,050 --> 01:07:30,490
en la parte final, asegúrese de que en realidad no romper la consulta SQL.

1015
01:07:30,490 --> 01:07:33,660
Muy bien, así que eso es todo, un torbellino de PHP y SQL.

1016
01:07:33,660 --> 01:07:41,520
Mucha suerte a todos ustedes, y ahora a Oregon

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Bueno todo el mundo. Es hora de repasar algunos JavaScript

1018
01:07:44,270 --> 01:07:48,840
y algunas otras cosas muy rápidamente, así que no tienen que hasta esta noche.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Sí. JavaScript es una especie de cosa fresca, supuestamente.

1020
01:07:56,930 --> 01:07:59,090
Las cosas que realmente necesita saber acerca de JavaScript, es algo así como

1021
01:07:59,090 --> 01:08:03,810
Al final del lado del cliente de lo que su aplicación web va a estar haciendo.

1022
01:08:03,810 --> 01:08:08,280
Hay algunas cosas que simplemente no quiere hacerse cargo de todo el tiempo en el lado del servidor.

1023
01:08:08,280 --> 01:08:12,880
Todas las pequeñas interacciones, destacando una cosa, hacer desaparecer algo.

1024
01:08:12,880 --> 01:08:15,340
¿De verdad no quiero tener que hablar con su servidor todo el tiempo para eso.

1025
01:08:15,340 --> 01:08:18,069
Y algunos de los que ni siquiera es posible hacerlo en el lado del servidor.

1026
01:08:18,069 --> 01:08:21,899
Es por esto que necesitamos algo como JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Cosas interesantes acerca de JavaScript: es tipado dinámico.

1028
01:08:24,359 --> 01:08:27,149
Lo que esto significa es que su programa no necesita saber

1029
01:08:27,149 --> 01:08:30,970
¿qué, exactamente, las variables son cuando escribes a cabo.

1030
01:08:30,970 --> 01:08:34,510
Será sólo una especie de figura hacia fuera según se ejecuta.

1031
01:08:34,510 --> 01:08:37,520
Otras cosas que son bueno de esto: Es un lenguaje de corchete,

1032
01:08:37,520 --> 01:08:41,359
lo que significa que la sintaxis es similar a C y PHP.

1033
01:08:41,359 --> 01:08:47,050
Usted no tiene que hacer mucho de la reanudación cuando estás aprendiendo JavaScript.

1034
01:08:47,050 --> 01:08:49,180
Aquí tenemos un poco de JavaScript.

1035
01:08:49,180 --> 01:08:52,560
Lo interesante aquí es que, si nos fijamos en él,

1036
01:08:52,560 --> 01:08:56,330
tenemos un poco de JavaScript allí mismo, en la etiqueta de la cabeza.

1037
01:08:56,330 --> 01:08:59,479
Lo que es no es, básicamente, basta con incluir un archivo JavaScript.

1038
01:08:59,479 --> 01:09:02,260
Esta es una manera que usted puede incluir JavaScript en su programa.

1039
01:09:02,260 --> 01:09:06,910
A continuación, el segundo poco es en realidad algo de JavaScript inline,

1040
01:09:06,910 --> 01:09:10,790
muy similar a un estilo en línea con CSS,

1041
01:09:10,790 --> 01:09:16,180
y sólo estás escribiendo algo de código muy rápidamente allí.

1042
01:09:16,180 --> 01:09:18,120
JavaScript tiene arrays.

1043
01:09:18,120 --> 01:09:20,850
Sólo otra manera de mantener los datos de alrededor, muy útil.

1044
01:09:20,850 --> 01:09:25,180
Muy agradable y fácil de sintaxis.

1045
01:09:25,180 --> 01:09:29,870
Utilice corchetes para acceder a todo y mantener todo junto.

1046
01:09:29,870 --> 01:09:35,020
Nada demasiado complejo.

1047
01:09:35,020 --> 01:09:38,630
Lo bueno de JavaScript y lenguajes de scripting en general

1048
01:09:38,630 --> 01:09:40,920
es que usted no tiene que preocuparse sobre tamaños de matriz.

1049
01:09:40,920 --> 01:09:43,880
Usted sólo puede usar Array.length y realizar un seguimiento de la misma,

1050
01:09:43,880 --> 01:09:46,960
y también el arreglo puede aumentar o disminuir a medida que lo necesite.

1051
01:09:46,960 --> 01:09:49,279
Así que usted ni siquiera tiene que preocuparse por ningún tipo de,

1052
01:09:49,279 --> 01:09:57,050
oh no, tengo que asignar más cosas, o algo por el estilo.

1053
01:09:57,050 --> 01:10:00,090
>> Lo interesante aquí es que JavaScript tiene algo que se llama objetos.

1054
01:10:00,090 --> 01:10:04,800
Es un lenguaje orientado a objetos, por lo que lo que tiene es, en esencia,

1055
01:10:04,800 --> 01:10:10,100
una forma de agrupar datos en conjunto, algo similar a una estructura,

1056
01:10:10,100 --> 01:10:17,280
pero se puede acceder a ella como una estructura o en una sintaxis de matrices asociativas.

1057
01:10:17,280 --> 01:10:22,520
Es bastante simple y lo que puede hacer con esto es agrupar datos en conjunto

1058
01:10:22,520 --> 01:10:24,810
si usted tiene un montón de datos que está relacionado.

1059
01:10:24,810 --> 01:10:26,850
Porque es todo lo que necesita para describir un coche,

1060
01:10:26,850 --> 01:10:29,050
usted no necesita tener en un montón de diferentes lugares.

1061
01:10:29,050 --> 01:10:35,300
Usted sólo puede pegarlo en 1 objeto en JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Como usted probablemente sabe, la iteración es una de esas tareas tediosas.

1063
01:10:39,090 --> 01:10:43,810
Usted acaba de hacerlo a través de una otra vez. Usted necesita hablar con todos los objetos en el coche,

1064
01:10:43,810 --> 01:10:47,340
o si tiene que ir a través de todos los elementos de una lista o algo por el estilo.

1065
01:10:47,340 --> 01:10:51,770
Así JavaScript tiene, similar a PHP, una sintaxis foreach.

1066
01:10:51,770 --> 01:10:54,590
En este caso, es una en el bucle.

1067
01:10:54,590 --> 01:10:57,300
Usted desea utilizar este sólo en los objetos.

1068
01:10:57,300 --> 01:11:01,030
Hay algunos problemas que se producen si se utiliza este en arrays.

1069
01:11:01,030 --> 01:11:03,750
En general, es una de esas cosas, sin embargo, que es muy útil,

1070
01:11:03,750 --> 01:11:06,590
porque se elimina una gran cantidad de gastos generales

1071
01:11:06,590 --> 01:11:10,270
porque usted no tiene que tirar todo lo que encuentra a su objeto por sí mismo.

1072
01:11:10,270 --> 01:11:12,300
Usted no tiene que recordar todos los nombres de las teclas.

1073
01:11:12,300 --> 01:11:18,270
Usted sólo una especie de obtener de nuevo en esta sintaxis.

1074
01:11:18,270 --> 01:11:21,500
En esto, por, lo que desea recordar

1075
01:11:21,500 --> 01:11:27,180
que te van a dar vuelta todas las teclas, de una manera muy similar a la tabla de hash.

1076
01:11:27,180 --> 01:11:30,880
Si te acuerdas de eso, cuando usted desea poner en una cadena que podría sacar algo

1077
01:11:30,880 --> 01:11:33,840
que tendrían un valor asociado con él.

1078
01:11:33,840 --> 01:11:36,360
Lo que puede hacer con esto es que se puede decir, de acuerdo,

1079
01:11:36,360 --> 01:11:42,120
Puse en un coche, y lo llamé un Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Así que usted puede poner en la cadena de Ferrari de nuevo más tarde, y usted puede conseguir eso.

1081
01:11:45,290 --> 01:11:50,000
Y usted puede hacer esto en un bucle, con el en el bucle.

1082
01:11:50,000 --> 01:11:53,320
Así que más sobre los objetos. La clave de esto es necesario recordar

1083
01:11:53,320 --> 01:12:00,340
es que se puede utilizar la estructura objeto como sintaxis cuando quieras con ellos,

1084
01:12:00,340 --> 01:12:04,590
excepto si lo que vas a utilizar como una cadena no es un nombre de variable válido.

1085
01:12:04,590 --> 01:12:07,650
Así que si nos fijamos en que no tenemos llave con espacios.

1086
01:12:07,650 --> 01:12:12,500
Bueno, si tuviera que poner object.key, espacio, con, espacio, espacios,

1087
01:12:12,500 --> 01:12:15,320
que simplemente no tendría sentido sintácticamente.

1088
01:12:15,320 --> 01:12:22,730
Por lo que sólo puede hacer eso con este tipo de sintaxis de soporte.

1089
01:12:22,730 --> 01:12:26,520
>> También, JavaScript es muy ámbito-sabio PHP.

1090
01:12:26,520 --> 01:12:29,050
Tienes 2 maneras de abordar el alcance.

1091
01:12:29,050 --> 01:12:31,960
No se puede tener la var delante de una variable,

1092
01:12:31,960 --> 01:12:34,060
y eso sólo significa que es global.

1093
01:12:34,060 --> 01:12:37,050
Se puede ver desde cualquier lugar. Incluso si usted fuera a poner esto en una sentencia if,

1094
01:12:37,050 --> 01:12:42,430
en cualquier otro lugar en el código después de ese punto se podía ver esa variable.

1095
01:12:42,430 --> 01:12:46,730
Otra cosa, sin embargo, es con el var, que es limitada para cualquier función que usted está adentro

1096
01:12:46,730 --> 01:12:48,870
Si no está en una función, bueno, es global.

1097
01:12:48,870 --> 01:12:53,900
Pero si usted está en una función que es sólo visible dentro de esa función.

1098
01:12:53,900 --> 01:12:56,420
Yo no tengo un ejemplo, pero sí. Es una de esas cosas donde

1099
01:12:56,420 --> 01:12:59,900
usted puede manejar las variables que usted quiere ser global,

1100
01:12:59,900 --> 01:13:03,810
cuáles son las variables que desea ser local, pero sí es necesario tener cuidado con esto,

1101
01:13:03,810 --> 01:13:06,890
porque usted no tiene el tipo de control de grano fino que se hace en C,

1102
01:13:06,890 --> 01:13:15,820
donde si algo se declara en un bucle, que va a permanecer en ese bucle.

1103
01:13:15,820 --> 01:13:18,790
Lo que realmente se preocupan por el uso de JavaScript para la manipula páginas web, ¿no?

1104
01:13:18,790 --> 01:13:21,800
Quiero decir, es por eso que estamos haciendo esto.

1105
01:13:21,800 --> 01:13:23,840
>> Para hacer esto, usamos algo llamado el DOM.

1106
01:13:23,840 --> 01:13:25,850
El Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
Básicamente, lo que hace es que toma todo su HTML

1108
01:13:29,430 --> 01:13:34,110
y modelos hacia fuera en un montón de objetos que están anidados unos dentro de otros.

1109
01:13:34,110 --> 01:13:37,080
Empiezas con algo como esto.

1110
01:13:37,080 --> 01:13:44,770
Usted tiene, a la derecha para mí, un montón de código por ahí que es una especie de -

1111
01:13:44,770 --> 01:13:46,640
Se podría pensar que sería muy difícil de manipular,

1112
01:13:46,640 --> 01:13:48,700
porque estarías va a analizar a través de un montón de texto

1113
01:13:48,700 --> 01:13:52,080
y tener a pieza aparte cosas. ¿Y qué si no se ha formateado correctamente?

1114
01:13:52,080 --> 01:13:54,880
Las cosas malas que sucedería.

1115
01:13:54,880 --> 01:13:58,140
Así que JavaScript se encarga de esto para usted, y usted tiene una estructura de datos muy bien,

1116
01:13:58,140 --> 01:14:01,390
como el de la izquierda, en el que sólo tiene un documento,

1117
01:14:01,390 --> 01:14:03,530
y en el interior que usted tiene algo que se llama HTML,

1118
01:14:03,530 --> 01:14:05,600
y en el interior que tiene una cabeza y un cuerpo,

1119
01:14:05,600 --> 01:14:08,420
y dentro de esa cabeza que tienes un título, etcétera, etcétera, etcétera.

1120
01:14:08,420 --> 01:14:11,810
Esto simplifica la manipulación de una página web para que sea más justo,

1121
01:14:11,810 --> 01:14:14,190
oh, yo sólo quiero hablar con este objeto.

1122
01:14:14,190 --> 01:14:21,340
Ordenar de una manera muy similar que hablaría con otro objeto que te hiciste.

1123
01:14:21,340 --> 01:14:25,980
Como he dicho, todo el DOM está en el objeto de documento.

1124
01:14:25,980 --> 01:14:29,290
O es simplemente un lugar y luego se puede ir dentro de ella para encontrar las cosas,

1125
01:14:29,290 --> 01:14:33,880
y usted puede hacerlo - este es el viejo estilo de hacer que, allá arriba,

1126
01:14:33,880 --> 01:14:38,130
en el que hacer document.getElementById, y luego el nombre,

1127
01:14:38,130 --> 01:14:42,420
y como usted puede decir probablemente, esto se vuelve muy difícil de manejar después de un tiempo.

1128
01:14:42,420 --> 01:14:44,480
Así que es probable que no quieres hacer eso. Es por eso que tenemos

1129
01:14:44,480 --> 01:14:48,760
lo siguiente que vamos a hablar después de esto.

1130
01:14:48,760 --> 01:14:52,510
La clave aquí es que, de acuerdo, usted tiene todos estos elementos, ¿no?

1131
01:14:52,510 --> 01:14:56,400
Así que tal vez pueda cambiar el color de algo cuando se carga la página.

1132
01:14:56,400 --> 01:14:58,380
¿Y qué? ¿Qué pasa si mi usuario hace clic en algo?

1133
01:14:58,380 --> 01:15:00,540
Yo quiero que haga algo interesante cuando hagan clic en algo.

1134
01:15:00,540 --> 01:15:02,600
Es por eso que tenemos eventos.

1135
01:15:02,600 --> 01:15:05,330
Usted puede, básicamente, encontrar cualquier elemento en su DOM,

1136
01:15:05,330 --> 01:15:08,560
y luego dicen, oye. Cuando esto carga o alguien hace clic en él,

1137
01:15:08,560 --> 01:15:11,410
o cuando el ratón sobre ella, hacen algo con él.

1138
01:15:11,410 --> 01:15:15,330
Y lo que tenemos es, usted tiene las funciones que se encargan de esto para usted.

1139
01:15:15,330 --> 01:15:17,980
Estas funciones son controladores de eventos.

1140
01:15:17,980 --> 01:15:20,440
¿Qué they're - es sólo una forma elegante de decir,

1141
01:15:20,440 --> 01:15:23,500
esta función sólo se ejecuta cuando el evento ocurre.

1142
01:15:23,500 --> 01:15:28,070
Por lo tanto, controla el evento que se produce.

1143
01:15:28,070 --> 01:15:30,810
Así es como se le diseñar un controlador de eventos.

1144
01:15:30,810 --> 01:15:34,750
Tengo un poco de botón, y cuando hace clic en él, explota.

1145
01:15:34,750 --> 01:15:40,560
Así que no haga clic en el botón.

1146
01:15:40,560 --> 01:15:42,910
Esta es una manera de acercarse a ella, ¿no?

1147
01:15:42,910 --> 01:15:46,430
Usted tiene una etiqueta de botón, y al hacer clic usted tiene una cadena que dice,

1148
01:15:46,430 --> 01:15:50,460
oh, por cierto, lo hago de la explosión para mí.

1149
01:15:50,460 --> 01:15:53,990
De lo contrario, es como un botón normal que acaba de hacer.

1150
01:15:53,990 --> 01:15:56,550
También se puede hacer de otra manera,

1151
01:15:56,550 --> 01:16:02,770
agarrando el elemento DOM, pero vamos a guardar que después hablamos de jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: Es una librería que es cross-browser.

1153
01:16:07,580 --> 01:16:09,580
Se puede utilizar en casi cualquier cosa.

1154
01:16:09,580 --> 01:16:12,090
Y sólo te da un montón de herramientas para trabajar.

1155
01:16:12,090 --> 01:16:15,850
Debido JavaScript, mientras que de gran alcance, no tiene todas las herramientas que necesita

1156
01:16:15,850 --> 01:16:20,550
fuera de la caja para hacer frente realmente una aplicación web es posible que desee hacer.

1157
01:16:20,550 --> 01:16:24,650
Por lo que simplifica mucho las cosas, te da un montón de funciones

1158
01:16:24,650 --> 01:16:28,760
fuera de la caja que normalmente tiene que escribir usted mismo, una y otra y otra vez.

1159
01:16:28,760 --> 01:16:31,600
Y sólo hace las cosas muy simples.

1160
01:16:31,600 --> 01:16:35,780
Usted también tiene selectores, que le permiten tomar todos esos elementos

1161
01:16:35,780 --> 01:16:42,800
de su DOM mucho más simplemente, en lugar de tener que utilizar estas llamadas de función muy largos.

1162
01:16:42,800 --> 01:16:46,630
Más sobre estos selectores. Usted tiene, allí usted tiene, digamos

1163
01:16:46,630 --> 01:16:49,800
Quiero conseguir un elemento con el ID "roca."

1164
01:16:49,800 --> 01:16:56,450
Pues bien, en jQuery, es sólo $ y luego una cadena que tiene una libra, y luego "roca."

1165
01:16:56,450 --> 01:17:01,960
Es muy simple y mucho más rápida que la forma tradicional de JavaScript de abordar este problema.

1166
01:17:01,960 --> 01:17:06,120
Y usted tiene cosas similares para las clases y tipos de elementos.

1167
01:17:06,120 --> 01:17:08,140
jQuery es - una de las características interesantes es que más o menos puedes comprimir

1168
01:17:08,140 --> 01:17:14,350
abajo de sus consultas en su DOM muy, muy rápido.

1169
01:17:14,350 --> 01:17:18,980
Ahora estamos de vuelta a la gestión de eventos, y esto es cómo manejaría un evento en jQuery.

1170
01:17:18,980 --> 01:17:23,090
Así que lo que vamos aquí es que estamos diciendo, está bien. Tengo una etiqueta script, ¿verdad?

1171
01:17:23,090 --> 01:17:25,400
Así que tengo esta línea de JavaScript.

1172
01:17:25,400 --> 01:17:27,750
Lo que vamos a hacer es que vamos a decir, está bien.

1173
01:17:27,750 --> 01:17:30,860
Cuando el documento esté listo, lo que significa que ha sido cargado el documento,

1174
01:17:30,860 --> 01:17:34,660
vamos a ir a esa función, y que vamos a decir, está bien,

1175
01:17:34,660 --> 01:17:37,060
esta función está realmente haciendo otra cosa.

1176
01:17:37,060 --> 01:17:42,320
Es, básicamente, diciendo: bien, tráeme el elemento con el ID "myid."

1177
01:17:42,320 --> 01:17:47,960
Y a continuación, dar a este un manejador de función que se ejecuta cuando se hace clic en él.

1178
01:17:47,960 --> 01:17:49,820
Básicamente lo que hace es, se dice, está bien.

1179
01:17:49,820 --> 01:17:52,630
La página se carga, así que voy en el, de encontrar este elemento,

1180
01:17:52,630 --> 01:17:56,420
darle este controlador de eventos, y que básicamente establece su página para usted.

1181
01:17:56,420 --> 01:18:00,520
Y así es como se quiere pensar en la gestión de eventos.

1182
01:18:00,520 --> 01:18:06,310
Lo que desea es pensar, bien, cuando ocurre algo, ¿qué es lo que quiero que suceda?

1183
01:18:06,310 --> 01:18:10,520
Usted no quiere que pensar, bien, yo necesito para asegurarse de que las conversaciones esta cosa a esta cosa,

1184
01:18:10,520 --> 01:18:14,660
esta cosa, bla, bla, bla, porque lo que desea es hablar cosa en términos de eventos.

1185
01:18:14,660 --> 01:18:17,650
Cuando esto ocurre, esto sucede. Cuando esto sucede, eso sucede.

1186
01:18:17,650 --> 01:18:20,240
Y si las cosas se desencadenan otras cosas, eso es genial.

1187
01:18:20,240 --> 01:18:22,150
Pero usted no quiere tratar de hacer complicado código

1188
01:18:22,150 --> 01:18:24,130
donde usted está desencadenando múltiples cosas a la vez,

1189
01:18:24,130 --> 01:18:28,860
porque sólo vamos a dar un dolor de cabeza.

1190
01:18:28,860 --> 01:18:32,340
>> Muy bien. Ahora podemos obtener nuestra página de controlar eventos,

1191
01:18:32,340 --> 01:18:35,640
pero digamos que mi usuario hace clic en un botón.

1192
01:18:35,640 --> 01:18:38,040
¿Qué pasa si quiero enviar esa petición de vuelta al servidor,

1193
01:18:38,040 --> 01:18:41,100
pero yo no quiero volver a cargar la página, porque tener que recargar una nueva página

1194
01:18:41,100 --> 01:18:44,390
cada vez que pone un poco aburrido, y por qué lo necesito

1195
01:18:44,390 --> 01:18:47,430
para desplegar el encabezado de nuevo, y el pie de página de nuevo,

1196
01:18:47,430 --> 01:18:49,670
y todos los elementos de la página de nuevo

1197
01:18:49,670 --> 01:18:53,180
para refrescar el saludo o el tiempo?

1198
01:18:53,180 --> 01:18:55,290
Así que es por eso que tenemos algo así como el Ajax.

1199
01:18:55,290 --> 01:18:59,150
Lo que podemos hacer aquí con el Ajax es lo que podemos decir, está bien,

1200
01:18:59,150 --> 01:19:01,290
Quiero enviar algunos datos al servidor,

1201
01:19:01,290 --> 01:19:04,010
y quiero obtener una respuesta de vuelta así que puedo actualizar mi página,

1202
01:19:04,010 --> 01:19:12,120
o tal vez sólo hacer algún cálculo algorítmico que no muestra necesariamente nada al usuario.

1203
01:19:12,120 --> 01:19:15,500
¿Qué necesitas para hacer esto? Bueno, usted necesita un URL que necesita hablar.

1204
01:19:15,500 --> 01:19:18,650
Su servidor no puede mágicamente escuchar en la nada.

1205
01:19:18,650 --> 01:19:21,960
Usted necesita tener un lugar específico que va a enviar estos datos a.

1206
01:19:21,960 --> 01:19:26,240
Y también hay algunos datos para enviar, o tal vez es una consulta sin datos.

1207
01:19:26,240 --> 01:19:31,380
Lo único que quiere hacer ping de nuevo al servidor y decir, hey, estoy vivo, o algo así.

1208
01:19:31,380 --> 01:19:35,150
Y entonces usted quiere una función que básicamente maneja con éxito.

1209
01:19:35,150 --> 01:19:38,250
Digamos que usted regrese alguna información de su servidor,

1210
01:19:38,250 --> 01:19:42,960
y desea cambiar el cargo del usuario en su página.

1211
01:19:42,960 --> 01:19:44,930
Así se podrían obtener la información de nuevo,

1212
01:19:44,930 --> 01:19:48,860
y usted tendría que empujar a la pantalla.

1213
01:19:48,860 --> 01:19:51,170
Lo que ocurre es que cuando la página está lista,

1214
01:19:51,170 --> 01:19:56,500
se crea una en función de clic en este botón llamado bienvenida.

1215
01:19:56,500 --> 01:19:58,810
Lo que esto hace es entonces, cuando se pulsa el botón,

1216
01:19:58,810 --> 01:20:03,700
hablas con greetings.php, usted hace una petición POST,

1217
01:20:03,700 --> 01:20:07,290
y usted dice, hey, dame algo de tu página.

1218
01:20:07,290 --> 01:20:09,890
Realmente no necesitamos describir eso, pero greetings.php,

1219
01:20:09,890 --> 01:20:12,480
vamos a decir, le da la espalda "hola mundo".

1220
01:20:12,480 --> 01:20:15,650
Así que volvamos esto "hola mundo", y en caso de éxito de este,

1221
01:20:15,650 --> 01:20:20,730
suponiendo que nada salga mal, entonces nos vamos a este lugar de destino

1222
01:20:20,730 --> 01:20:25,720
que hemos especificado y sólo mantenemos la respuesta allí.

1223
01:20:25,720 --> 01:20:31,560
Y esta es una forma muy sencilla de configurar una consulta de Ajax.

1224
01:20:31,560 --> 01:20:34,340
>> Muy rápidamente, Rob especie de mencionar esto ya,

1225
01:20:34,340 --> 01:20:37,170
las cosas pueden ir mal, las cosas malas pueden suceder,

1226
01:20:37,170 --> 01:20:42,660
por lo que desea que se familiarice con estos códigos de respuesta HTTP.

1227
01:20:42,660 --> 01:20:46,030
Lo que se trata son sólo, como, 200, todo salió bien.

1228
01:20:46,030 --> 01:20:48,670
Otra cosa, las cosas malas que pasó.

1229
01:20:48,670 --> 01:20:50,790
Por lo general es lo que quiere recordar.

1230
01:20:50,790 --> 01:20:53,440
Pero es bueno saber que todos estos.

1231
01:20:53,440 --> 01:20:55,970
Y, por último, una vez que hemos pasado por todo eso,

1232
01:20:55,970 --> 01:20:58,680
tenemos que hablar muy rápidamente sobre el diseño,

1233
01:20:58,680 --> 01:21:00,620
y luego podemos dejar que todos ustedes se vayan.

1234
01:21:00,620 --> 01:21:03,410
Diseño. Las cosas que quieras recordar.

1235
01:21:03,410 --> 01:21:06,950
Hágase estas preguntas: ¿Quién va a usar esto?

1236
01:21:06,950 --> 01:21:09,580
¿Qué van a estar utilizando para? ¿Qué les importa a mis usuarios sobre?

1237
01:21:09,580 --> 01:21:11,750
Lo que no les importa?

1238
01:21:11,750 --> 01:21:14,500
Usted simplemente no quiere hacer una aplicación y dejar que sólo crecen

1239
01:21:14,500 --> 01:21:18,270
y convertirse en el gigante, que todo lo consume que ni siquiera se puede terminar.

1240
01:21:18,270 --> 01:21:23,900
¿Quieres tener metas discretas y planes y cosas que desea tratar.

1241
01:21:23,900 --> 01:21:29,000
Que sea sin esfuerzo. Todo esto dice, básicamente,

1242
01:21:29,000 --> 01:21:34,950
hacer más fácil para el usuario para usarlo, no lo convierten en un gigante de la burbuja de texto como esta diapositiva es, en realidad.

1243
01:21:34,950 --> 01:21:38,020
Lo que desea es que sea algo donde es muy fácil para que alguien vaya en

1244
01:21:38,020 --> 01:21:40,800
y hacen lo que quieren hacer.

1245
01:21:40,800 --> 01:21:42,920
No quiero que tengan que navegar 5 páginas

1246
01:21:42,920 --> 01:21:45,460
para llegar a su función principal de su sitio.

1247
01:21:45,460 --> 01:21:49,290
Si Google tiene 5 páginas antes de que incluso podría buscar algo,

1248
01:21:49,290 --> 01:21:53,080
nadie lo usaría.

1249
01:21:53,080 --> 01:21:55,890
Y, por último, prototipo de papel, grupo focal.

1250
01:21:55,890 --> 01:21:59,220
Tener un buen diseño y prácticas de prueba.

1251
01:21:59,220 --> 01:22:00,730
Sólo porque usted piensa que funciona para usted,

1252
01:22:00,730 --> 01:22:04,860
no significa que piensen los demás funciona.

1253
01:22:04,860 --> 01:22:14,490
Pero sí, eso es todo.

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